From d20556eb2987a174db078437d62b94ace4f84dca Mon Sep 17 00:00:00 2001 From: PozzettiAndrea Date: Thu, 14 May 2026 13:02:34 +0200 Subject: [PATCH] playcanvas/spark dual backend --- __init__.py | 3 - preview_gaussian.py | 16 +- requirements.txt | 6 +- scripts/probes/state.js | 74 +- scripts/run_probe.py | 15 +- server_tools/ply_to_spz.mjs | 49 + server_tools/spz-js/LICENSE | 21 + server_tools/spz-js/README.md | 75 + .../spz-js/dist/compressed-ply-loader.d.ts | 2 + .../spz-js/dist/compressed-ply-loader.js | 474 + .../dist/compressed-ply-serializer.d.ts | 8 + .../spz-js/dist/compressed-ply-serializer.js | 356 + server_tools/spz-js/dist/compression.d.ts | 3 + server_tools/spz-js/dist/compression.js | 41 + server_tools/spz-js/dist/constant.d.ts | 7 + server_tools/spz-js/dist/constant.js | 25 + server_tools/spz-js/dist/index.d.ts | 9 + server_tools/spz-js/dist/index.js | 9 + server_tools/spz-js/dist/math.d.ts | 19 + server_tools/spz-js/dist/math.js | 125 + server_tools/spz-js/dist/ply-loader.d.ts | 2 + server_tools/spz-js/dist/ply-loader.js | 184 + server_tools/spz-js/dist/ply-serializer.d.ts | 2 + server_tools/spz-js/dist/ply-serializer.js | 85 + server_tools/spz-js/dist/spz-loader.d.ts | 3 + server_tools/spz-js/dist/spz-loader.js | 282 + server_tools/spz-js/dist/spz-serializer.d.ts | 3 + server_tools/spz-js/dist/spz-serializer.js | 43 + server_tools/spz-js/dist/test.d.ts | 1 + server_tools/spz-js/dist/types.d.ts | 26 + server_tools/spz-js/dist/types.js | 1 + server_tools/spz-js/package.json | 36 + spz_route.py | 137 - web/js/OrbitControls.js | 1963 ++ web/js/gaussian-splats-3d.umd.js | 14491 -------------- web/js/gaussian_preview.js | 86 +- web/js/spark.module.min.js | 16533 ++++++++++++++++ web/js/three.core.min.js | 6 + web/js/three.min.js | 7 - web/js/three.module.min.js | 6 + web/viewer_gaussian.html | 517 +- 41 files changed, 20651 insertions(+), 15100 deletions(-) create mode 100644 server_tools/ply_to_spz.mjs create mode 100644 server_tools/spz-js/LICENSE create mode 100644 server_tools/spz-js/README.md create mode 100644 server_tools/spz-js/dist/compressed-ply-loader.d.ts create mode 100644 server_tools/spz-js/dist/compressed-ply-loader.js create mode 100644 server_tools/spz-js/dist/compressed-ply-serializer.d.ts create mode 100644 server_tools/spz-js/dist/compressed-ply-serializer.js create mode 100644 server_tools/spz-js/dist/compression.d.ts create mode 100644 server_tools/spz-js/dist/compression.js create mode 100644 server_tools/spz-js/dist/constant.d.ts create mode 100644 server_tools/spz-js/dist/constant.js create mode 100644 server_tools/spz-js/dist/index.d.ts create mode 100644 server_tools/spz-js/dist/index.js create mode 100644 server_tools/spz-js/dist/math.d.ts create mode 100644 server_tools/spz-js/dist/math.js create mode 100644 server_tools/spz-js/dist/ply-loader.d.ts create mode 100644 server_tools/spz-js/dist/ply-loader.js create mode 100644 server_tools/spz-js/dist/ply-serializer.d.ts create mode 100644 server_tools/spz-js/dist/ply-serializer.js create mode 100644 server_tools/spz-js/dist/spz-loader.d.ts create mode 100644 server_tools/spz-js/dist/spz-loader.js create mode 100644 server_tools/spz-js/dist/spz-serializer.d.ts create mode 100644 server_tools/spz-js/dist/spz-serializer.js create mode 100644 server_tools/spz-js/dist/test.d.ts create mode 100644 server_tools/spz-js/dist/types.d.ts create mode 100644 server_tools/spz-js/dist/types.js create mode 100644 server_tools/spz-js/package.json delete mode 100644 spz_route.py create mode 100644 web/js/OrbitControls.js delete mode 100644 web/js/gaussian-splats-3d.umd.js create mode 100644 web/js/spark.module.min.js create mode 100644 web/js/three.core.min.js delete mode 100644 web/js/three.min.js create mode 100644 web/js/three.module.min.js diff --git a/__init__.py b/__init__.py index 7759d0a..62146b0 100644 --- a/__init__.py +++ b/__init__.py @@ -3,9 +3,6 @@ """ComfyUI-TurntableGSViewer — tiny Gaussian-splat turntable viewer node.""" from .preview_gaussian import PreviewGaussians -from .spz_route import register_routes as _register_spz_route - -_register_spz_route() WEB_DIRECTORY = "web" diff --git a/preview_gaussian.py b/preview_gaussian.py index 6c0bfa8..cd281f8 100644 --- a/preview_gaussian.py +++ b/preview_gaussian.py @@ -46,11 +46,17 @@ class PreviewGaussians: "image_height": ("INT", { "default": 512, "min": 64, "max": 4096, "step": 8, }), - "renderer": (["webgl2", "webgpu"], { - "default": "webgl2", - "tooltip": "webgl2 = universal compatibility (mkkellogg/GaussianSplats3D); " - "webgpu = faster on Chrome/Safari (PlayCanvas), " - "falls back to webgl2 if the browser lacks WebGPU support", + "renderer": (["spark", "playcanvas"], { + "default": "spark", + "tooltip": ( + "spark — Three.js + WebGL2. Best SH3 fidelity, " + "auto-detects all formats (PLY, compressed.ply, SPZ, " + "KSPLAT, SOG, SPLAT). " + "\n" + "playcanvas — WebGPU path (currently falls back to " + "spark; real adapter pending). Will win on large " + "scenes (5M+ splats) when implemented." + ), }), }, } diff --git a/requirements.txt b/requirements.txt index c2e40fd..ebdf833 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,2 @@ -# spz: Niantic's compressed Gaussian-splat format. When the viewer's -# "Compress (SPZ)" toggle is on, we transcode the PLY on the server and -# ship the ~6x smaller .spz to the client. -spz +# No Python deps — PLY parsing happens in the browser via gsplat.js. +# Server-side gzip transport in spz_route.py uses Python stdlib only. diff --git a/scripts/probes/state.js b/scripts/probes/state.js index ad239bd..db8303f 100644 --- a/scripts/probes/state.js +++ b/scripts/probes/state.js @@ -1,65 +1,11 @@ -// Read viewer + splatMesh + renderer state. Pure data dump, no side-effects -// (no manual render, no forced sort). -// -// Returned as a JSON-friendly object. window.__gs.run() calls this with -// (adapter, viewer, splatMesh, THREE, GS) bound. -const out = {}; -const r = viewer.renderer; - -out.gates = { - initialized: viewer.initialized, - splatRenderReady: viewer.splatRenderReady, - disposing: viewer.disposing, - disposed: viewer.disposed, - sortRunning: viewer.sortRunning, - selfDrivenModeRunning: viewer.selfDrivenModeRunning, - splatRenderCount: viewer.splatRenderCount, - lastSplatSortCount: viewer.lastSplatSortCount, - lastSortTime: viewer.lastSortTime, - gpuAcceleratedSort: viewer.gpuAcceleratedSort, +// State probe for the Spark-based adapter. Pure read; no side effects. +return { + adapterReady: !!adapter, + adapterKind: adapter && adapter.kind && adapter.kind(), + splatCount: splatMesh?.numSplats ?? splatMesh?.getSplatCount?.() ?? 0, + cameraPos: adapter ? adapter.getCameraPosition() : null, + cameraTarget: adapter ? adapter.getCameraTarget() : null, + fov: adapter && adapter.camera ? adapter.camera.fov : null, + frames: adapter && adapter._frameCount, + sceneChildren: scene ? scene.children.map(c => ({ type: c.type, visible: c.visible })) : null, }; - -out.rendererInfo = JSON.parse(JSON.stringify(r.info)); -out.size = r.getSize(new THREE.Vector2()).toArray(); -out.dprSize = r.getDrawingBufferSize(new THREE.Vector2()).toArray(); -out.autoClear = r.autoClear; -out.renderTarget = !!r.getRenderTarget(); - -out.camera = { - pos: viewer.camera.position.toArray(), - quat: viewer.camera.quaternion.toArray(), - near: viewer.camera.near, far: viewer.camera.far, - fov: viewer.camera.fov, aspect: viewer.camera.aspect, -}; - -const g = splatMesh.geometry; -out.geom = { - type: splatMesh.type, - geomType: g.type, - drawRange: { start: g.drawRange.start, count: g.drawRange.count }, - instanceCount: g.instanceCount, - visible: splatMesh.visible, - inScene: !!splatMesh.parent, - frustumCulled: splatMesh.frustumCulled, - attrs: {}, -}; -for (const k of Object.keys(g.attributes || {})) { - const a = g.attributes[k]; - out.geom.attrs[k] = { - itemSize: a.itemSize, - count: a.count, - instanced: !!a.isInstancedBufferAttribute, - }; -} - -// Material -const mat = splatMesh.material; -out.material = { - type: mat && mat.type, - visible: mat && mat.visible, - transparent: mat && mat.transparent, - program: !!(mat && mat.program), - uniformsKeys: mat && mat.uniforms ? Object.keys(mat.uniforms) : null, -}; - -return out; diff --git a/scripts/run_probe.py b/scripts/run_probe.py index 518750f..cde8ed5 100644 --- a/scripts/run_probe.py +++ b/scripts/run_probe.py @@ -39,18 +39,27 @@ def main(): ctx = browser.new_context(viewport={"width": 1024, "height": 768}) page = ctx.new_page() page.on("console", lambda m: print(f" {m.text}") if "heartbeat" not in m.text else None) + page.on("requestfailed", lambda r: print(f" [requestfailed] {r.url} - {r.failure}")) + page.on("response", lambda r: print(f" [response {r.status}] {r.url}") if r.status >= 400 else None) page.goto(f"http://127.0.0.1:{PORT}/viewer_gaussian.html", wait_until="load") page.wait_for_function("typeof window.__gs === 'object'") - page.evaluate("""async () => { + # Pick the iframe-side filename to match the source extension so the + # adapter picks the right SceneFormat (.ply vs .spz). + ext = PLY_PATH.suffix.lower() + iframe_filename = f"t{ext}" if ext in (".ply", ".spz") else "t.ply" + import os as _os + chosen_renderer = _os.environ.get("RENDERER", "spark") + print(f"[harness] renderer: {chosen_renderer}") + page.evaluate("""async ({fname, rend}) => { window._loaded = false; window._error = null; addEventListener('message', e => { if (e.data?.type === 'MESH_LOADED') window._loaded = true; if (e.data?.type === 'MESH_ERROR') window._error = e.data.error; }); const r = await fetch('/test.ply'); const buf = await r.arrayBuffer(); - postMessage({ type:'LOAD_MESH_DATA', data: buf, filename:'t.ply', renderer:'webgl2' }, '*'); - }""") + postMessage({ type: 'LOAD_MESH_DATA', data: buf, filename: fname, renderer: rend }, '*'); + }""", {"fname": iframe_filename, "rend": chosen_renderer}) page.wait_for_function("window._loaded || window._error", timeout=180000) page.wait_for_timeout(1500) diff --git a/server_tools/ply_to_spz.mjs b/server_tools/ply_to_spz.mjs new file mode 100644 index 0000000..3ec40db --- /dev/null +++ b/server_tools/ply_to_spz.mjs @@ -0,0 +1,49 @@ +#!/usr/bin/env node +/** + * Convert a 3DGS PLY to SPZ (v2, gzipped — mkkellogg-compatible). + * + * usage: node ply_to_spz.mjs + * + * Uses the vendored spz-js library; no external npm install needed. + */ +import { createReadStream, writeFileSync, statSync } from "node:fs"; +import { Readable } from "node:stream"; +import { fileURLToPath } from "node:url"; +import { dirname, resolve } from "node:path"; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +// Import the sub-modules directly so we don't trip the `playcanvas` +// dep that the `compressed-ply-*` modules pull in (we don't need them). +const { loadPly } = await import(resolve(__dirname, "spz-js/dist/ply-loader.js")); +const { serializeSpz } = await import(resolve(__dirname, "spz-js/dist/spz-serializer.js")); + +const [, , inPath, outPath] = process.argv; +if (!inPath || !outPath) { + console.error("usage: node ply_to_spz.mjs "); + process.exit(2); +} + +const t0 = Date.now(); +const stream = createReadStream(inPath); +const web = Readable.toWeb(stream); +const gs = await loadPly(web); +const tLoad = (Date.now() - t0) / 1000; + +const t1 = Date.now(); +const buf = await serializeSpz(gs); +const tSer = (Date.now() - t1) / 1000; + +writeFileSync(outPath, Buffer.from(buf)); + +const inMB = statSync(inPath).size / (1024 * 1024); +const outMB = statSync(outPath).size / (1024 * 1024); +console.log(JSON.stringify({ + numPoints: gs.numPoints, + plyMB: +inMB.toFixed(2), + spzMB: +outMB.toFixed(2), + ratio: +(inMB / outMB).toFixed(2), + loadSec: +tLoad.toFixed(2), + serSec: +tSer.toFixed(2), +})); diff --git a/server_tools/spz-js/LICENSE b/server_tools/spz-js/LICENSE new file mode 100644 index 0000000..408aa02 --- /dev/null +++ b/server_tools/spz-js/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Stratum1 GmbH + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/server_tools/spz-js/README.md b/server_tools/spz-js/README.md new file mode 100644 index 0000000..6f67937 --- /dev/null +++ b/server_tools/spz-js/README.md @@ -0,0 +1,75 @@ +# Library to convert gaussian splats between PLY and SPZ formats + +Based on the [original C++ library](https://github.com/nianticlabs/spz). + +## Installation + +[![NPM](https://nodei.co/npm/spz-js.png)](https://npmjs.org/package/spz-js) + +```bash +npm install spz-js +``` + +## Example (Node.js) + +```javascript +import { + createReadStream, + readFileSync, + writeFileSync, + unlinkSync +} from 'fs'; +import { Readable } from 'stream'; +import path from 'path'; + +import { + loadPly, + loadSpz, + serializePly, + serializeSpz +} from 'spz-js'; + +// Helper function to load either SPZ or PLY files +const loadFile = async (file) => { + const extension = path.extname(file); + if (extension === '.spz') { + const fileBuffer = readFileSync(file); + return await loadSpz(fileBuffer); + } else if (extension === '.ply') { + const fileStream = createReadStream(file); + const webStream = Readable.toWeb(fileStream); + return await loadPly(webStream); + } + throw new Error(`Unsupported file extension: ${extension}`); +}; + +const gs = await loadFile("gs.ply"); // or gs.spz + +const plyData = serializePly(gs); +writeFileSync("gs.ply", Buffer.from(plyData)); + +const spzData = await serializeSpz(gs); +writeFileSync("gs.spz", Buffer.from(spzData)); +``` + +## Example (Browser) + +```javascript +import { + loadPly, + loadSpz +} from 'spz-js'; + +const loadFile = async (url) => { + const response = await fetch(url); + const extension = url.split('.').pop(); + + if (extension === 'spz') { + const buffer = await response.arrayBuffer(); + return await loadSpz(buffer); + } else if (extension === 'ply') { + return await loadPly(response.body); + } + throw new Error(`Unsupported file extension: ${extension}`); +}; +``` \ No newline at end of file diff --git a/server_tools/spz-js/dist/compressed-ply-loader.d.ts b/server_tools/spz-js/dist/compressed-ply-loader.d.ts new file mode 100644 index 0000000..211e9f4 --- /dev/null +++ b/server_tools/spz-js/dist/compressed-ply-loader.d.ts @@ -0,0 +1,2 @@ +import { GaussianCloud } from "./types.js"; +export declare function loadCompressedPly(stream: ReadableStream): Promise; diff --git a/server_tools/spz-js/dist/compressed-ply-loader.js b/server_tools/spz-js/dist/compressed-ply-loader.js new file mode 100644 index 0000000..eca5a87 --- /dev/null +++ b/server_tools/spz-js/dist/compressed-ply-loader.js @@ -0,0 +1,474 @@ +// This file is largely based on the ply.js and gsplat-compressed-data.js files from "playcanvas". +import { Quat, Vec4, Vec3 } from "playcanvas"; +import { dimForDegree, SH_C0 } from "./constant.js"; +const magicBytes = new Uint8Array([112, 108, 121, 10]); // ply\n +const endHeaderBytes = new Uint8Array([10, 101, 110, 100, 95, 104, 101, 97, 100, 101, 114, 10]); // \nend_header\n +const dataTypeMap = new Map([ + ['char', Int8Array], + ['uchar', Uint8Array], + ['short', Int16Array], + ['ushort', Uint16Array], + ['int', Int32Array], + ['uint', Uint32Array], + ['float', Float32Array], + ['double', Float64Array] +]); +// parse the ply header text and return an array of Element structures and a +// string containing the ply format +const parseHeader = (lines) => { + const elements = []; + let format = null; + for (let i = 1; i < lines.length; ++i) { + const words = lines[i].split(' '); + switch (words[0]) { + case 'format': + format = words[1]; + break; + case 'element': + elements.push({ + name: words[1], + count: parseInt(words[2], 10), + properties: [] + }); + break; + case 'property': { + if (!dataTypeMap.has(words[1])) { + throw new Error(`Unrecognized property data type '${words[1]}' in ply header`); + } + const element = elements[elements.length - 1]; + element.properties.push({ + type: words[1], + name: words[2], + storage: null, + byteSize: dataTypeMap.get(words[1]).BYTES_PER_ELEMENT + }); + break; + } + default: + throw new Error(`Unrecognized header value '${words[0]}' in ply header`); + } + } + return { elements, format }; +}; +const isCompressedPly = (elements) => { + const chunkProperties = [ + 'min_x', 'min_y', 'min_z', + 'max_x', 'max_y', 'max_z', + 'min_scale_x', 'min_scale_y', 'min_scale_z', + 'max_scale_x', 'max_scale_y', 'max_scale_z', + 'min_r', 'min_g', 'min_b', + 'max_r', 'max_g', 'max_b' + ]; + const vertexProperties = [ + 'packed_position', 'packed_rotation', 'packed_scale', 'packed_color' + ]; + const shProperties = new Array(45).fill('').map((_, i) => `f_rest_${i}`); + const hasBaseElements = () => { + return elements[0].name === 'chunk' && + elements[0].properties.every((p, i) => p.name === chunkProperties[i] && p.type === 'float') && + elements[1].name === 'vertex' && + elements[1].properties.every((p, i) => p.name === vertexProperties[i] && p.type === 'uint'); + }; + const hasSHElements = () => { + return elements[2].name === 'sh' && + [9, 24, 45].indexOf(elements[2].properties.length) !== -1 && + elements[2].properties.every((p, i) => p.name === shProperties[i] && p.type === 'uchar'); + }; + return (elements.length === 2 && hasBaseElements()) || (elements.length === 3 && hasBaseElements() && hasSHElements()); +}; +// helper for streaming in chunks of data in a memory efficient way +class StreamBuf { + reader; + data; + view; + head = 0; + tail = 0; + constructor(reader) { + this.reader = reader; + } + // read the next chunk of data + async read() { + const { value, done } = await this.reader.read(); + if (done) { + throw new Error('Stream finished before end of header'); + } + this.push(value); + } + // append data to the buffer + push(data) { + if (!this.data) { + // first buffer + this.data = data; + this.view = new DataView(this.data.buffer); + this.tail = data.length; + } + else { + const remaining = this.tail - this.head; + const newSize = remaining + data.length; + if (this.data.length >= newSize) { + // buffer is large enough to contain combined data + if (this.head > 0) { + // shuffle existing data to index 0 and append the new data + this.data.copyWithin(0, this.head, this.tail); + this.data.set(data, remaining); + this.head = 0; + this.tail = newSize; + } + else { + // no shuffle needed, just append new data + this.data.set(data, this.tail); + this.tail += data.length; + } + } + else { + // buffer is too small and must grow + const tmp = new Uint8Array(newSize); + if (this.head > 0 || this.tail < this.data.length) { + // shuffle existing data to index 0 and append the new data + tmp.set(this.data.subarray(this.head, this.tail), 0); + } + else { + tmp.set(this.data, 0); + } + tmp.set(data, remaining); + this.data = tmp; + this.view = new DataView(this.data.buffer); + this.head = 0; + this.tail = newSize; + } + } + } + // remove the read data from the head of the buffer + compact() { + if (this.head > 0) { + this.data.copyWithin(0, this.head, this.tail); + this.tail -= this.head; + this.head = 0; + } + } + get remaining() { + return this.tail - this.head; + } + // helpers for extracting data from head + getInt8() { + const result = this.view.getInt8(this.head); + this.head++; + return result; + } + getUint8() { + const result = this.view.getUint8(this.head); + this.head++; + return result; + } + getInt16() { + const result = this.view.getInt16(this.head, true); + this.head += 2; + return result; + } + getUint16() { + const result = this.view.getUint16(this.head, true); + this.head += 2; + return result; + } + getInt32() { + const result = this.view.getInt32(this.head, true); + this.head += 4; + return result; + } + getUint32() { + const result = this.view.getUint32(this.head, true); + this.head += 4; + return result; + } + getFloat32() { + const result = this.view.getFloat32(this.head, true); + this.head += 4; + return result; + } + getFloat64() { + const result = this.view.getFloat64(this.head, true); + this.head += 8; + return result; + } +} +class SplatCompressedIterator { + read; + constructor(gsplatData, p, r, s, c, sh) { + const unpackUnorm = (value, bits) => { + const t = (1 << bits) - 1; + return (value & t) / t; + }; + const unpack111011 = (result, value) => { + result.x = unpackUnorm(value >>> 21, 11); + result.y = unpackUnorm(value >>> 11, 10); + result.z = unpackUnorm(value, 11); + }; + const unpack8888 = (result, value) => { + result.x = unpackUnorm(value >>> 24, 8); + result.y = unpackUnorm(value >>> 16, 8); + result.z = unpackUnorm(value >>> 8, 8); + result.w = unpackUnorm(value, 8); + }; + // unpack quaternion with 2,10,10,10 format (largest element, 3x10bit element) + const unpackRot = (result, value) => { + const norm = 1.0 / (Math.sqrt(2) * 0.5); + const a = (unpackUnorm(value >>> 20, 10) - 0.5) * norm; + const b = (unpackUnorm(value >>> 10, 10) - 0.5) * norm; + const c = (unpackUnorm(value, 10) - 0.5) * norm; + const m = Math.sqrt(1.0 - (a * a + b * b + c * c)); + switch (value >>> 30) { + case 0: + result.set(a, b, c, m); + break; + case 1: + result.set(m, b, c, a); + break; + case 2: + result.set(b, m, c, a); + break; + case 3: + result.set(b, c, m, a); + break; + } + }; + const lerp = (a, b, t) => a * (1 - t) + b * t; + const { chunkData, vertexData, shData } = gsplatData.compressedData; + const { chunkSize, shBands } = gsplatData; + const shCoeffs = [3, 8, 15][shBands - 1]; + this.read = (i) => { + const ci = Math.floor(i / 256) * chunkSize; + if (p) { + unpack111011(p, vertexData[i * 4 + 0]); + p.x = lerp(chunkData[ci + 0], chunkData[ci + 3], p.x); + p.y = lerp(chunkData[ci + 1], chunkData[ci + 4], p.y); + p.z = lerp(chunkData[ci + 2], chunkData[ci + 5], p.z); + } + if (r) { + unpackRot(r, vertexData[i * 4 + 1]); + } + if (s) { + unpack111011(s, vertexData[i * 4 + 2]); + s.x = lerp(chunkData[ci + 6], chunkData[ci + 9], s.x); + s.y = lerp(chunkData[ci + 7], chunkData[ci + 10], s.y); + s.z = lerp(chunkData[ci + 8], chunkData[ci + 11], s.z); + } + if (c) { + unpack8888(c, vertexData[i * 4 + 3]); + if (chunkSize > 12) { + c.x = lerp(chunkData[ci + 12], chunkData[ci + 15], c.x); + c.y = lerp(chunkData[ci + 13], chunkData[ci + 16], c.y); + c.z = lerp(chunkData[ci + 14], chunkData[ci + 17], c.z); + } + } + if (sh && shBands > 0) { + for (let j = 0; j < 3; ++j) { + for (let k = 0; k < 15; ++k) { + sh[j * 15 + k] = (k < shCoeffs) ? (shData[(i * 3 + j) * shCoeffs + k] * (8 / 255) - 4) : 0; + } + } + } + }; + } +} +const decompress = (compressedData, elements) => { + const members = [ + 'x', 'y', 'z', + 'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity', + 'scale_0', 'scale_1', 'scale_2', + 'rot_0', 'rot_1', 'rot_2', 'rot_3' + ]; + const getShBands = () => { + const sizes = { + 3: 1, + 8: 2, + 15: 3 + }; + return sizes[compressedData.shData?.length / compressedData.numSplats / 3] ?? 0; + }; + const getNumChunks = () => { + return Math.ceil(compressedData.numSplats / 256); + }; + const getChunkSize = () => { + return compressedData.chunkData.length / getNumChunks(); + }; + const shBands = getShBands(); + const numSplats = compressedData.numSplats; + // allocate spherical harmonics data + if (shBands > 0) { + const shMembers = []; + for (let i = 0; i < 45; ++i) { + shMembers.push(`f_rest_${i}`); + } + members.splice(members.indexOf('f_dc_0') + 1, 0, ...shMembers); + } + // allocate uncompressed data + const data = { + numPoints: numSplats, + shDegree: shBands, + antialiased: false, + positions: new Float32Array(numSplats * 3), + scales: new Float32Array(numSplats * 3), + rotations: new Float32Array(numSplats * 4), + alphas: new Float32Array(numSplats), + colors: new Float32Array(numSplats * 3), + sh: new Float32Array(numSplats * dimForDegree(shBands) * 3) + }; + const p = new Vec3(); + const r = new Quat(); + const s = new Vec3(); + const c = new Vec4(); + const sh = shBands > 0 ? new Float32Array(45) : null; + const iter = new SplatCompressedIterator({ + compressedData, + chunkSize: getChunkSize(), + shBands, + }, p, r, s, c, sh); + for (let i = 0; i < compressedData.numSplats; ++i) { + iter.read(i); + data.positions[i * 3 + 0] = p.x; + data.positions[i * 3 + 1] = p.y; + data.positions[i * 3 + 2] = p.z; + data.rotations[i * 4 + 0] = r.x; + data.rotations[i * 4 + 1] = r.y; + data.rotations[i * 4 + 2] = r.z; + data.rotations[i * 4 + 3] = r.w; + data.scales[i * 3 + 0] = s.x; + data.scales[i * 3 + 1] = s.y; + data.scales[i * 3 + 2] = s.z; + data.colors[i * 3 + 0] = (c.x - 0.5) / SH_C0; + data.colors[i * 3 + 1] = (c.y - 0.5) / SH_C0; + data.colors[i * 3 + 2] = (c.z - 0.5) / SH_C0; + // convert opacity to log sigmoid taking into account infinities at 0 and 1 + data.alphas[i] = (c.w <= 0) ? -40 : (c.w >= 1) ? 40 : -Math.log(1 / c.w - 1); + const shDim = dimForDegree(shBands); + for (let j = 0; j < shBands; ++j) { + for (let k = 0; k < shDim; ++k) { + data.sh[(i * shDim + k) * 3 + j] = sh[j * shDim + k]; + } + } + } + return data; +}; +export async function loadCompressedPly(stream) { + const reader = stream.getReader(); + // Read header + /** + * Searches for the first occurrence of a sequence within a buffer. + * @example + * find(new Uint8Array([1, 2, 3, 4]), new Uint8Array([3, 4])); // 2 + * @param {Uint8Array} buf - The buffer in which to search. + * @param {Uint8Array} search - The sequence to search for. + * @returns {number} The index of the first occurrence of the search sequence in the buffer, or -1 if not found. + */ + const find = (buf, search) => { + const endIndex = buf.length - search.length; + let i, j; + for (i = 0; i <= endIndex; ++i) { + for (j = 0; j < search.length; ++j) { + if (buf[i + j] !== search[j]) { + break; + } + } + if (j === search.length) { + return i; + } + } + return -1; + }; + /** + * Checks if array 'a' starts with the same elements as array 'b'. + * @example + * startsWith(new Uint8Array([1, 2, 3, 4]), new Uint8Array([1, 2])); // true + * @param {Uint8Array} a - The array to check against. + * @param {Uint8Array} b - The array of elements to look for at the start of 'a'. + * @returns {boolean} - True if 'a' starts with all elements of 'b', otherwise false. + */ + const startsWith = (a, b) => { + if (a.length < b.length) { + return false; + } + for (let i = 0; i < b.length; ++i) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + }; + const streamBuf = new StreamBuf(reader); + let headerLength; + while (true) { + // get the next chunk of data + /* eslint-disable no-await-in-loop */ + await streamBuf.read(); + // check magic bytes + if (streamBuf.tail >= magicBytes.length && !startsWith(streamBuf.data, magicBytes)) { + throw new Error('Invalid ply header'); + } + // search for end-of-header marker + headerLength = find(streamBuf.data, endHeaderBytes); + if (headerLength !== -1) { + break; + } + } + // decode buffer header text and split into lines and remove comments + const lines = new TextDecoder() + .decode(streamBuf.data.subarray(0, headerLength)) + .split('\n') + .filter(line => !line.startsWith('comment ')); + // decode header and build element and property list + const { elements, format } = parseHeader(lines); + if (!isCompressedPly(elements)) { + throw new Error('Invalid ply header, not a compressed ply file.'); + } + // check format is supported + if (format !== 'binary_little_endian' && format !== 'binary_big_endian') { + throw new Error('Unsupported ply format'); + } + streamBuf.head = headerLength + endHeaderBytes.length; + streamBuf.compact(); + // Read compressed ply data + const numChunks = elements[0].count; + const numChunkProperties = elements[0].properties.length; + const numVertices = elements[1].count; + // evaluate the storage size for the given count (this must match the + // texture size calculation in GSplatCompressed). + const evalStorageSize = (count) => { + const width = Math.ceil(Math.sqrt(count)); + const height = Math.ceil(count / width); + return width * height; + }; + // allocate result + const result = { + numSplats: numVertices, + chunkData: new Float32Array(numChunks * numChunkProperties), + vertexData: new Uint32Array(evalStorageSize(numVertices) * 4), + }; + // read length bytes of data into buffer + const read = async (buffer, length) => { + const target = new Uint8Array(buffer); + let cursor = 0; + while (cursor < length) { + while (streamBuf.remaining === 0) { + /* eslint-disable no-await-in-loop */ + await streamBuf.read(); + } + const toCopy = Math.min(length - cursor, streamBuf.remaining); + const src = streamBuf.data; + for (let i = 0; i < toCopy; ++i) { + target[cursor++] = src[streamBuf.head++]; + } + } + }; + // read chunk data + await read(result.chunkData.buffer, numChunks * numChunkProperties * 4); + // read packed vertices + await read(result.vertexData.buffer, numVertices * 4 * 4); + // read sh data + if (elements.length === 3) { + result.shData = new Uint8Array(elements[2].count * elements[2].properties.length); + await read(result.shData.buffer, result.shData.byteLength); + } + // Decompress + const data = decompress(result, elements); + return data; +} diff --git a/server_tools/spz-js/dist/compressed-ply-serializer.d.ts b/server_tools/spz-js/dist/compressed-ply-serializer.d.ts new file mode 100644 index 0000000..655e634 --- /dev/null +++ b/server_tools/spz-js/dist/compressed-ply-serializer.d.ts @@ -0,0 +1,8 @@ +import { GaussianCloud } from './types.js'; +/** + * Serialize a GaussianCloud to a compressed PLY file as used by the PlayCanvas engine. + * + * @param data - The GaussianCloud to serialize. + * @returns The serialized PLY file as an ArrayBuffer. + */ +export declare function serializeCompressedPly(data: GaussianCloud): Uint8Array; diff --git a/server_tools/spz-js/dist/compressed-ply-serializer.js b/server_tools/spz-js/dist/compressed-ply-serializer.js new file mode 100644 index 0000000..a305131 --- /dev/null +++ b/server_tools/spz-js/dist/compressed-ply-serializer.js @@ -0,0 +1,356 @@ +// Parts of the code are taken from https://github.com/playcanvas/supersplat/blob/main/src/splat-serialize.ts +import { Quat } from 'playcanvas'; +import { dimForDegree, SH_C0 } from './constant.js'; +const generatedByString = 'spz-js package'; +const shNames = new Array(45).fill('').map((_, i) => `f_rest_${i}`); +const shBandCoeffs = [0, 3, 8, 15]; +/** + * Serialize a GaussianCloud to a compressed PLY file as used by the PlayCanvas engine. + * + * @param data - The GaussianCloud to serialize. + * @returns The serialized PLY file as an ArrayBuffer. + */ +export function serializeCompressedPly(data) { + const numSplats = data.numPoints; + const numChunks = Math.ceil(numSplats / 256); + const indices = []; + for (let i = 0; i < numSplats; ++i) { + indices.push(i); + } + const chunkProps = [ + 'min_x', 'min_y', 'min_z', + 'max_x', 'max_y', 'max_z', + 'min_scale_x', 'min_scale_y', 'min_scale_z', + 'max_scale_x', 'max_scale_y', 'max_scale_z', + 'min_r', 'min_g', 'min_b', + 'max_r', 'max_g', 'max_b' + ]; + const vertexProps = [ + 'packed_position', + 'packed_rotation', + 'packed_scale', + 'packed_color' + ]; + const outputSHBands = data.shDegree; + const outputSHCoeffs = shBandCoeffs[outputSHBands]; + const shHeader = outputSHBands ? [ + `element sh ${numSplats}`, + new Array(outputSHCoeffs * 3).fill('').map((_, i) => `property uchar f_rest_${i}`) + ].flat() : []; + const headerText = [ + 'ply', + 'format binary_little_endian 1.0', + `comment ${generatedByString}`, + `element chunk ${numChunks}`, + chunkProps.map(p => `property float ${p}`), + `element vertex ${numSplats}`, + vertexProps.map(p => `property uint ${p}`), + shHeader, + 'end_header\n' + ].flat().join('\n'); + const header = (new TextEncoder()).encode(headerText); + const result = new Uint8Array(header.byteLength + + numChunks * chunkProps.length * 4 + + numSplats * vertexProps.length * 4 + + outputSHCoeffs * 3 * numSplats); + const dataView = new DataView(result.buffer); + result.set(header); + const chunkOffset = header.byteLength; + const vertexOffset = chunkOffset + numChunks * chunkProps.length * 4; + const shOffset = vertexOffset + numSplats * 4 * 4; + sortSplats(data, indices); + const chunk = new Chunk(); + const singleSplat = new SingleSplat([ + 'x', 'y', 'z', + 'scale_0', 'scale_1', 'scale_2', + 'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity', + 'rot_0', 'rot_1', 'rot_2', 'rot_3' + ].concat(shNames.slice(0, outputSHCoeffs * 3))); + for (let i = 0; i < numChunks; ++i) { + const num = Math.min(numSplats, (i + 1) * 256) - i * 256; + for (let j = 0; j < num; ++j) { + const index = indices[i * 256 + j]; + // read splat + singleSplat.read(data, index); + // update chunk + chunk.set(j, singleSplat); + // quantize and write sh data + let off = shOffset + (i * 256 + j) * outputSHCoeffs * 3; + for (let k = 0; k < outputSHCoeffs * 3; ++k) { + const nvalue = singleSplat.data[shNames[k]] / 8 + 0.5; + dataView.setUint8(off++, Math.max(0, Math.min(255, Math.trunc(nvalue * 256)))); + } + } + const result = chunk.pack(); + const off = chunkOffset + i * 18 * 4; + // write chunk data + dataView.setFloat32(off + 0, result.px.min, true); + dataView.setFloat32(off + 4, result.py.min, true); + dataView.setFloat32(off + 8, result.pz.min, true); + dataView.setFloat32(off + 12, result.px.max, true); + dataView.setFloat32(off + 16, result.py.max, true); + dataView.setFloat32(off + 20, result.pz.max, true); + dataView.setFloat32(off + 24, result.sx.min, true); + dataView.setFloat32(off + 28, result.sy.min, true); + dataView.setFloat32(off + 32, result.sz.min, true); + dataView.setFloat32(off + 36, result.sx.max, true); + dataView.setFloat32(off + 40, result.sy.max, true); + dataView.setFloat32(off + 44, result.sz.max, true); + dataView.setFloat32(off + 48, result.cr.min, true); + dataView.setFloat32(off + 52, result.cg.min, true); + dataView.setFloat32(off + 56, result.cb.min, true); + dataView.setFloat32(off + 60, result.cr.max, true); + dataView.setFloat32(off + 64, result.cg.max, true); + dataView.setFloat32(off + 68, result.cb.max, true); + // write splat data + const offset = vertexOffset + i * 256 * 4 * 4; + const chunkSplats = Math.min(numSplats, (i + 1) * 256) - i * 256; + for (let j = 0; j < chunkSplats; ++j) { + dataView.setUint32(offset + j * 4 * 4 + 0, chunk.position[j], true); + dataView.setUint32(offset + j * 4 * 4 + 4, chunk.rotation[j], true); + dataView.setUint32(offset + j * 4 * 4 + 8, chunk.scale[j], true); + dataView.setUint32(offset + j * 4 * 4 + 12, chunk.color[j], true); + } + } + return result; +} +function sortSplats(data, indices) { + // https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/ + const encodeMorton3 = (x, y, z) => { + const Part1By2 = (x) => { + x &= 0x000003ff; + x = (x ^ (x << 16)) & 0xff0000ff; + x = (x ^ (x << 8)) & 0x0300f00f; + x = (x ^ (x << 4)) & 0x030c30c3; + x = (x ^ (x << 2)) & 0x09249249; + return x; + }; + return (Part1By2(z) << 2) + (Part1By2(y) << 1) + Part1By2(x); + }; + let minx; + let miny; + let minz; + let maxx; + let maxy; + let maxz; + const centers = data.positions; + for (let i = 0; i < data.numPoints; ++i) { + const x = centers[i * 3 + 0]; + const y = centers[i * 3 + 1]; + const z = centers[i * 3 + 2]; + if (minx === undefined) { + minx = maxx = x; + miny = maxy = y; + minz = maxz = z; + } + else { + if (x < minx) + minx = x; + else if (x > maxx) + maxx = x; + if (y < miny) + miny = y; + else if (y > maxy) + maxy = y; + if (z < minz) + minz = z; + else if (z > maxz) + maxz = z; + } + } + const xlen = maxx - minx; + const ylen = maxy - miny; + const zlen = maxz - minz; + const morton = new Uint32Array(data.numPoints); + let idx = 0; + for (let i = 0; i < data.numPoints; ++i) { + const x = centers[i * 3 + 0]; + const y = centers[i * 3 + 1]; + const z = centers[i * 3 + 2]; + const ix = Math.floor(1024 * (x - minx) / xlen); + const iy = Math.floor(1024 * (y - miny) / ylen); + const iz = Math.floor(1024 * (z - minz) / zlen); + morton[idx++] = encodeMorton3(ix, iy, iz); + } + // order splats by morton code + indices.sort((a, b) => morton[a] - morton[b]); +} +class SingleSplat { + data = {}; + constructor(members) { + members.forEach((name) => { + this.data[name] = 0; + }); + } + read(cloud, i) { + // Direct mapping from GaussianCloud to SingleSplat format + if (this.data.hasOwnProperty('x')) { + this.data.x = cloud.positions[i * 3 + 0]; + this.data.y = cloud.positions[i * 3 + 1]; + this.data.z = cloud.positions[i * 3 + 2]; + } + if (this.data.hasOwnProperty('scale_0')) { + this.data.scale_0 = cloud.scales[i * 3 + 0]; + this.data.scale_1 = cloud.scales[i * 3 + 1]; + this.data.scale_2 = cloud.scales[i * 3 + 2]; + } + if (this.data.hasOwnProperty('rot_0')) { + this.data.rot_0 = cloud.rotations[i * 4 + 3]; + this.data.rot_1 = cloud.rotations[i * 4 + 0]; + this.data.rot_2 = cloud.rotations[i * 4 + 1]; + this.data.rot_3 = cloud.rotations[i * 4 + 2]; + } + if (this.data.hasOwnProperty('f_dc_0')) { + this.data.f_dc_0 = cloud.colors[i * 3 + 0]; + this.data.f_dc_1 = cloud.colors[i * 3 + 1]; + this.data.f_dc_2 = cloud.colors[i * 3 + 2]; + } + if (this.data.hasOwnProperty('opacity')) { + this.data.opacity = cloud.alphas[i]; + } + // Handle SH coefficients if present + const shDim = dimForDegree(cloud.shDegree); + for (let j = 0; j < shDim; j++) { + for (let c = 0; c < 3; c++) { + const name = `f_rest_${j + c * shDim}`; + if (this.data.hasOwnProperty(name)) { + this.data[name] = cloud.sh[(i * shDim + j) * 3 + c]; + } + } + } + } +} +const q = new Quat(); +// process and compress a chunk of 256 splats +class Chunk { + static members = [ + 'x', 'y', 'z', + 'scale_0', 'scale_1', 'scale_2', + 'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity', + 'rot_0', 'rot_1', 'rot_2', 'rot_3' + ]; + size; + /// @ts-ignore + data = {}; + // compressed data + position; + rotation; + scale; + color; + constructor(size = 256) { + this.size = size; + Chunk.members.forEach((m) => { + this.data[m] = new Float32Array(size); + }); + this.position = new Uint32Array(size); + this.rotation = new Uint32Array(size); + this.scale = new Uint32Array(size); + this.color = new Uint32Array(size); + } + set(index, splat) { + Chunk.members.forEach((name) => { + this.data[name][index] = splat.data[name]; + }); + } + pack() { + const calcMinMax = (data) => { + let min; + let max; + min = max = data[0]; + for (let i = 1; i < data.length; ++i) { + const v = data[i]; + min = Math.min(min, v); + max = Math.max(max, v); + } + return { min, max }; + }; + const normalize = (x, min, max) => { + if (x <= min) + return 0; + if (x >= max) + return 1; + return (max - min < 0.00001) ? 0 : (x - min) / (max - min); + }; + const data = this.data; + const x = data.x; + const y = data.y; + const z = data.z; + const scale_0 = data.scale_0; + const scale_1 = data.scale_1; + const scale_2 = data.scale_2; + const rot_0 = data.rot_0; + const rot_1 = data.rot_1; + const rot_2 = data.rot_2; + const rot_3 = data.rot_3; + const f_dc_0 = data.f_dc_0; + const f_dc_1 = data.f_dc_1; + const f_dc_2 = data.f_dc_2; + const opacity = data.opacity; + const px = calcMinMax(x); + const py = calcMinMax(y); + const pz = calcMinMax(z); + const sx = calcMinMax(scale_0); + const sy = calcMinMax(scale_1); + const sz = calcMinMax(scale_2); + // clamp scale because sometimes values are at infinity + const clamp = (v, min, max) => Math.max(min, Math.min(max, v)); + sx.min = clamp(sx.min, -20, 20); + sx.max = clamp(sx.max, -20, 20); + sy.min = clamp(sy.min, -20, 20); + sy.max = clamp(sy.max, -20, 20); + sz.min = clamp(sz.min, -20, 20); + sz.max = clamp(sz.max, -20, 20); + // convert f_dc_ to colors before calculating min/max and packaging + for (let i = 0; i < f_dc_0.length; ++i) { + f_dc_0[i] = f_dc_0[i] * SH_C0 + 0.5; + f_dc_1[i] = f_dc_1[i] * SH_C0 + 0.5; + f_dc_2[i] = f_dc_2[i] * SH_C0 + 0.5; + } + const cr = calcMinMax(f_dc_0); + const cg = calcMinMax(f_dc_1); + const cb = calcMinMax(f_dc_2); + const packUnorm = (value, bits) => { + const t = (1 << bits) - 1; + return Math.max(0, Math.min(t, Math.floor(value * t + 0.5))); + }; + const pack111011 = (x, y, z) => { + return packUnorm(x, 11) << 21 | + packUnorm(y, 10) << 11 | + packUnorm(z, 11); + }; + const pack8888 = (x, y, z, w) => { + return packUnorm(x, 8) << 24 | + packUnorm(y, 8) << 16 | + packUnorm(z, 8) << 8 | + packUnorm(w, 8); + }; + // pack quaternion into 2,10,10,10 + const packRot = (x, y, z, w) => { + q.set(x, y, z, w).normalize(); + const a = [q.x, q.y, q.z, q.w]; + const largest = a.reduce((curr, v, i) => (Math.abs(v) > Math.abs(a[curr]) ? i : curr), 0); + if (a[largest] < 0) { + a[0] = -a[0]; + a[1] = -a[1]; + a[2] = -a[2]; + a[3] = -a[3]; + } + const norm = Math.sqrt(2) * 0.5; + let result = largest; + for (let i = 0; i < 4; ++i) { + if (i !== largest) { + result = (result << 10) | packUnorm(a[i] * norm + 0.5, 10); + } + } + return result; + }; + // pack + for (let i = 0; i < this.size; ++i) { + this.position[i] = pack111011(normalize(x[i], px.min, px.max), normalize(y[i], py.min, py.max), normalize(z[i], pz.min, pz.max)); + this.rotation[i] = packRot(rot_0[i], rot_1[i], rot_2[i], rot_3[i]); + this.scale[i] = pack111011(normalize(scale_0[i], sx.min, sx.max), normalize(scale_1[i], sy.min, sy.max), normalize(scale_2[i], sz.min, sz.max)); + this.color[i] = pack8888(normalize(f_dc_0[i], cr.min, cr.max), normalize(f_dc_1[i], cg.min, cg.max), normalize(f_dc_2[i], cb.min, cb.max), 1 / (1 + Math.exp(-opacity[i]))); + } + return { px, py, pz, sx, sy, sz, cr, cg, cb }; + } +} diff --git a/server_tools/spz-js/dist/compression.d.ts b/server_tools/spz-js/dist/compression.d.ts new file mode 100644 index 0000000..8a6c2af --- /dev/null +++ b/server_tools/spz-js/dist/compression.d.ts @@ -0,0 +1,3 @@ +export declare function decompressGzipped(data: Uint8Array): Promise; +export declare function decompressGzipStream(stream: ReadableStream): Promise; +export declare function compressGzipped(data: Uint8Array): Promise; diff --git a/server_tools/spz-js/dist/compression.js b/server_tools/spz-js/dist/compression.js new file mode 100644 index 0000000..e7a099c --- /dev/null +++ b/server_tools/spz-js/dist/compression.js @@ -0,0 +1,41 @@ +const createStream = (data) => { + return new ReadableStream({ + async start(controller) { + controller.enqueue(data); + controller.close(); + }, + }); +}; +export async function decompressGzipped(data) { + try { + const stream = createStream(data); + if (!stream) + throw new Error('Failed to create stream from data'); + return await decompressGzipStream(stream); + } + catch (error) { + console.error('Error decompressing gzipped data:', error); + throw error; + } +} +export async function decompressGzipStream(stream) { + const decompressor = new DecompressionStream('gzip'); + const decompressedStream = stream.pipeThrough(decompressor); + const response = new Response(decompressedStream); + const buffer = await response.arrayBuffer(); + return new Uint8Array(buffer); +} +export async function compressGzipped(data) { + try { + const stream = createStream(data); + const compressor = new CompressionStream('gzip'); + const compressedStream = stream.pipeThrough(compressor); + const response = new Response(compressedStream); + const buffer = await response.arrayBuffer(); + return new Uint8Array(buffer); + } + catch (error) { + console.error('Error compressing gzipped data:', error); + throw error; + } +} diff --git a/server_tools/spz-js/dist/constant.d.ts b/server_tools/spz-js/dist/constant.d.ts new file mode 100644 index 0000000..bbb3371 --- /dev/null +++ b/server_tools/spz-js/dist/constant.d.ts @@ -0,0 +1,7 @@ +export declare const SPZ_MAGIC = 1347635022; +export declare const SPZ_VERSION = 2; +export declare const FLAG_ANTIALIASED = 1; +export declare const COLOR_SCALE = 0.15; +export declare const SH_C0 = 0.28209479177387814; +export declare function degreeForDim(dim: number): number; +export declare function dimForDegree(degree: number): number; diff --git a/server_tools/spz-js/dist/constant.js b/server_tools/spz-js/dist/constant.js new file mode 100644 index 0000000..e311d1f --- /dev/null +++ b/server_tools/spz-js/dist/constant.js @@ -0,0 +1,25 @@ +export const SPZ_MAGIC = 0x5053474e; // NGSP = Niantic gaussian splat +export const SPZ_VERSION = 2; +export const FLAG_ANTIALIASED = 0x1; +export const COLOR_SCALE = 0.15; +export const SH_C0 = 0.28209479177387814; +export function degreeForDim(dim) { + if (dim < 3) + return 0; + if (dim < 8) + return 1; + if (dim < 15) + return 2; + return 3; +} +export function dimForDegree(degree) { + switch (degree) { + case 0: return 0; + case 1: return 3; + case 2: return 8; + case 3: return 15; + default: + console.error(`[SPZ: ERROR] Unsupported SH degree: ${degree}`); + return 0; + } +} diff --git a/server_tools/spz-js/dist/index.d.ts b/server_tools/spz-js/dist/index.d.ts new file mode 100644 index 0000000..19ac6e1 --- /dev/null +++ b/server_tools/spz-js/dist/index.d.ts @@ -0,0 +1,9 @@ +export * from './types.js'; +export * from './spz-serializer.js'; +export * from './spz-loader.js'; +export * from './constant.js'; +export * from './compression.js'; +export * from './ply-serializer.js'; +export * from './ply-loader.js'; +export * from './compressed-ply-serializer.js'; +export * from './compressed-ply-loader.js'; diff --git a/server_tools/spz-js/dist/index.js b/server_tools/spz-js/dist/index.js new file mode 100644 index 0000000..19ac6e1 --- /dev/null +++ b/server_tools/spz-js/dist/index.js @@ -0,0 +1,9 @@ +export * from './types.js'; +export * from './spz-serializer.js'; +export * from './spz-loader.js'; +export * from './constant.js'; +export * from './compression.js'; +export * from './ply-serializer.js'; +export * from './ply-loader.js'; +export * from './compressed-ply-serializer.js'; +export * from './compressed-ply-loader.js'; diff --git a/server_tools/spz-js/dist/math.d.ts b/server_tools/spz-js/dist/math.d.ts new file mode 100644 index 0000000..b093b94 --- /dev/null +++ b/server_tools/spz-js/dist/math.d.ts @@ -0,0 +1,19 @@ +import { Vec3f, Quat4f, Half } from './types.js'; +export declare const PI: number; +export declare function halfToFloat(h: Half): number; +export declare function floatToHalf(f: number): Half; +export declare function axisAngleQuat(scaledAxis: Vec3f): Quat4f; +export declare function isVec3f(v: number[]): v is Vec3f; +export declare function isQuat4f(v: number[]): v is Quat4f; +export declare function vec3f(data: number[]): Vec3f; +export declare function quat4f(data: number[]): Quat4f; +export declare function dot(a: Vec3f, b: Vec3f): number; +export declare function squaredNorm(v: Vec3f | Quat4f): number; +export declare function norm(v: Vec3f | Quat4f): number; +export declare function normalized(v: T): T; +export declare function timesVec3(q: Quat4f, p: Vec3f): Vec3f; +export declare function timesQuat(a: Quat4f, b: Quat4f): Quat4f; +export declare function timesScalar(v: T, s: number): T; +export declare function plus(a: T, b: T): T; +export declare function vec3ToQuat4(v: Vec3f, w: number): Quat4f; +export declare function quatToVec3(q: Quat4f): Vec3f; diff --git a/server_tools/spz-js/dist/math.js b/server_tools/spz-js/dist/math.js new file mode 100644 index 0000000..38557bd --- /dev/null +++ b/server_tools/spz-js/dist/math.js @@ -0,0 +1,125 @@ +export const PI = Math.PI; +export function halfToFloat(h) { + const sgn = (h >> 15) & 0x1; + const exponent = (h >> 10) & 0x1f; + const mantissa = h & 0x3ff; + const signMul = sgn === 1 ? -1.0 : 1.0; + if (exponent === 0) { + return signMul * Math.pow(2, -14) * mantissa / 1024; + } + if (exponent === 31) { + return mantissa !== 0 ? NaN : signMul * Infinity; + } + return signMul * Math.pow(2, exponent - 15) * (1 + mantissa / 1024); +} +export function floatToHalf(f) { + const buffer = new ArrayBuffer(4); + const view = new DataView(buffer); + view.setFloat32(0, f); + const f32 = view.getUint32(0); + const sign = (f32 >> 31) & 0x01; + const exponent = (f32 >> 23) & 0xff; + const mantissa = f32 & 0x7fffff; + if (exponent === 0xff) { + if (mantissa === 0) { + return (sign << 15) | 0x7c00; + } + return (sign << 15) | 0x7c01; + } + const centeredExp = exponent - 127; + if (centeredExp > 15) { + return (sign << 15) | 0x7c00; + } + if (centeredExp > -15) { + return (sign << 15) | ((centeredExp + 15) << 10) | (mantissa >> 13); + } + const fullMantissa = 0x800000 | mantissa; + const shift = -(centeredExp + 14); + const newMantissa = fullMantissa >> shift; + return (sign << 15) | (newMantissa >> 13); +} +export function axisAngleQuat(scaledAxis) { + const [a0, a1, a2] = scaledAxis; + const thetaSquared = a0 * a0 + a1 * a1 + a2 * a2; + if (thetaSquared > 0) { + const theta = Math.sqrt(thetaSquared); + const halfTheta = theta * 0.5; + const k = Math.sin(halfTheta) / theta; + return normalized([Math.cos(halfTheta), a0 * k, a1 * k, a2 * k]); + } + const k = 0.5; + return normalized([1.0, a0 * k, a1 * k, a2 * k]); +} +export function isVec3f(v) { + return v.length === 3; +} +export function isQuat4f(v) { + return v.length === 4; +} +export function vec3f(data) { + return [data[0], data[1], data[2]]; +} +export function quat4f(data) { + return [data[0], data[1], data[2], data[3]]; +} +export function dot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} +export function squaredNorm(v) { + return v.reduce((sum, val) => sum + val * val, 0); +} +export function norm(v) { + return Math.sqrt(squaredNorm(v)); +} +export function normalized(v) { + const n = norm(v); + return v.map(x => x / n); +} +// Quaternion multiplication with a vector +export function timesVec3(q, p) { + const [w, x, y, z] = q; + const [vx, vy, vz] = p; + const x2 = x + x; + const y2 = y + y; + const z2 = z + z; + const wx2 = w * x2; + const wy2 = w * y2; + const wz2 = w * z2; + const xx2 = x * x2; + const xy2 = x * y2; + const xz2 = x * z2; + const yy2 = y * y2; + const yz2 = y * z2; + const zz2 = z * z2; + return [ + vx * (1.0 - (yy2 + zz2)) + vy * (xy2 - wz2) + vz * (xz2 + wy2), + vx * (xy2 + wz2) + vy * (1.0 - (xx2 + zz2)) + vz * (yz2 - wx2), + vx * (xz2 - wy2) + vy * (yz2 + wx2) + vz * (1.0 - (xx2 + yy2)) + ]; +} +// Quaternion multiplication +export function timesQuat(a, b) { + const [w, x, y, z] = a; + const [qw, qx, qy, qz] = b; + return normalized([ + w * qw - x * qx - y * qy - z * qz, + w * qx + x * qw + y * qz - z * qy, + w * qy - x * qz + y * qw + z * qx, + w * qz + x * qy - y * qx + z * qw + ]); +} +// Scalar multiplication +export function timesScalar(v, s) { + return v.map(x => x * s); +} +// Vector/quaternion addition +export function plus(a, b) { + return a.map((x, i) => x + b[i]); +} +// Convert Vec3f to Quat4f with w component +export function vec3ToQuat4(v, w) { + return [w, v[0], v[1], v[2]]; // w first, then xyz +} +export function quatToVec3(q) { + return [q[1], q[2], q[3]]; // Skip w, take xyz +} diff --git a/server_tools/spz-js/dist/ply-loader.d.ts b/server_tools/spz-js/dist/ply-loader.d.ts new file mode 100644 index 0000000..0283123 --- /dev/null +++ b/server_tools/spz-js/dist/ply-loader.d.ts @@ -0,0 +1,2 @@ +import { GaussianCloud } from './types.js'; +export declare function loadPly(readable: ReadableStream): Promise; diff --git a/server_tools/spz-js/dist/ply-loader.js b/server_tools/spz-js/dist/ply-loader.js new file mode 100644 index 0000000..1e60859 --- /dev/null +++ b/server_tools/spz-js/dist/ply-loader.js @@ -0,0 +1,184 @@ +import { degreeForDim } from './constant.js'; +/* ────────────────────────────── constants ─────────────────────────────── */ +const END_MARKER = /\r?\nend_header\r?\n/; // handles \n and \r\n +/* ────────────────────────────── helpers ───────────────────────────────── */ +function getFieldIndex(map, name) { + const idx = map.get(name); + if (idx === undefined) { + throw new Error(`[PLY] Missing required field "${name}"`); + } + return idx; +} +function byteSizeForType(type) { + switch (type) { + case 'float': + case 'int': + case 'uint': + case 'uint32': + case 'int32': return 4; + case 'double': return 8; + case 'uchar': + case 'char': + case 'uint8': + case 'int8': return 1; + case 'ushort': + case 'short': + case 'uint16': + case 'int16': return 2; + default: + throw new Error(`[PLY] Unsupported property type "${type}"`); + } +} +/* ────────────────────────────── parser ────────────────────────────────── */ +export async function loadPly(readable) { + /* ---------- 1. Stream-safe header read -------------------------------- */ + const reader = readable.getReader(); + const decoder = new TextDecoder(); + const headerChunks = []; + let headerText = ''; + let binaryStartByteOffset = 0; // where vertex blob begins (byte index) + while (true) { + const { value, done } = await reader.read(); + if (done) + throw new Error('[PLY] Unexpected EOF before end_header'); + headerChunks.push(value); + headerText += decoder.decode(value, { stream: true }); + const m = headerText.match(END_MARKER); + if (!m) + continue; // need more data + const headerChars = headerText.indexOf(m[0]) + m[0].length; + binaryStartByteOffset = new TextEncoder().encode(headerText.slice(0, headerChars)).length; + // Trim sentinel from headerText (makes later `.split` cleaner) + headerText = headerText.slice(0, headerChars - m[0].length); + break; + } + /* ---------- 2. Stitch chunks & grab first payload bytes --------------- */ + const headerTotal = headerChunks.reduce((s, c) => s + c.length, 0); + const stitched = new Uint8Array(headerTotal); + let off = 0; + for (const c of headerChunks) { + stitched.set(c, off); + off += c.length; + } + const initialBinary = stitched.subarray(binaryStartByteOffset); + /* ---------- 3. Robust header parsing ---------------------------------- */ + const lines = headerText.split(/\r?\n/).filter(Boolean); + if (lines[0] !== 'ply') { + throw new Error('[PLY] Not a PLY file'); + } + let formatOK = false; + let numPoints = 0; + const propDefs = []; + let strideBytes = 0; + let parsingVertexProps = false; + for (let i = 1; i < lines.length; i++) { + const line = lines[i]; + if (line.startsWith('format binary_little_endian')) { + formatOK = true; + continue; + } + if (line.startsWith('comment') || line.startsWith('obj_info')) + continue; + if (line.startsWith('element')) { + const [, elem, count] = line.split(/\s+/); + parsingVertexProps = (elem === 'vertex'); + if (elem === 'vertex') + numPoints = Number(count); + continue; + } + if (line.startsWith('property') && parsingVertexProps) { + const [, type, name] = line.split(/\s+/); + const size = byteSizeForType(type); + propDefs.push({ name, type, offsetBytes: strideBytes }); + strideBytes += size; + continue; + } + } + if (!formatOK) + throw new Error('[PLY] Only binary_little_endian supported'); + if (!numPoints) + throw new Error('[PLY] Vertex count missing or zero'); + /* ---------- 4. Fast lookup tables ------------------------------------- */ + const fieldOffsetMap = new Map(); + propDefs.forEach(({ name, offsetBytes }) => fieldOffsetMap.set(name, offsetBytes / 4) // convert to float index + ); + const posIdx = ['x', 'y', 'z'].map(n => getFieldIndex(fieldOffsetMap, n)); + const scaleIdx = ['scale_0', 'scale_1', 'scale_2'].map(n => getFieldIndex(fieldOffsetMap, n)); + const rotIdx = ['rot_1', 'rot_2', 'rot_3', 'rot_0'].map(n => getFieldIndex(fieldOffsetMap, n)); + const alphaIdx = [getFieldIndex(fieldOffsetMap, 'opacity')]; + const colorIdx = ['f_dc_0', 'f_dc_1', 'f_dc_2'].map(n => getFieldIndex(fieldOffsetMap, n)); + const shIdx = []; + for (let i = 0;; i++) { + const idx = fieldOffsetMap.get(`f_rest_${i}`); + if (idx === undefined) + break; + shIdx.push(idx); + } + const shDim = Math.floor(shIdx.length / 3); + const strideFloats = strideBytes / 4; + /* ---------- 5. Stream binary payload directly into pre-alloc buffer --- */ + const totalBinaryBytes = numPoints * strideBytes; + const buffer = new ArrayBuffer(totalBinaryBytes); + const dest = new Uint8Array(buffer); + // paste the bytes we already have + dest.set(initialBinary, 0); + let cursor = initialBinary.length; + while (cursor < totalBinaryBytes) { + const { value, done } = await reader.read(); + if (done) + throw new Error('[PLY] Truncated binary section'); + dest.set(value, cursor); + cursor += value.length; + } + reader.releaseLock(); + /* ---------- 6. Decode vertices via Float32 view ----------------------- */ + const f32 = new Float32Array(buffer); + const result = { + numPoints, + shDegree: degreeForDim(shDim), + antialiased: false, + positions: new Float32Array(numPoints * 3), + scales: new Float32Array(numPoints * 3), + rotations: new Float32Array(numPoints * 4), + alphas: new Float32Array(numPoints), + colors: new Float32Array(numPoints * 3), + sh: new Float32Array(numPoints * shDim * 3), + }; + for (let i = 0; i < numPoints; i++) { + const base = i * strideFloats; + /* positions, scales, colours */ + result.positions.set([ + f32[base + posIdx[0]], + f32[base + posIdx[1]], + f32[base + posIdx[2]], + ], i * 3); + result.scales.set([ + f32[base + scaleIdx[0]], + f32[base + scaleIdx[1]], + f32[base + scaleIdx[2]], + ], i * 3); + result.colors.set([ + f32[base + colorIdx[0]], + f32[base + colorIdx[1]], + f32[base + colorIdx[2]], + ], i * 3); + /* rotations (quat wxyz order rot_0..3) */ + result.rotations.set([ + f32[base + rotIdx[0]], + f32[base + rotIdx[1]], + f32[base + rotIdx[2]], + f32[base + rotIdx[3]], + ], i * 4); + /* alpha */ + result.alphas[i] = f32[base + alphaIdx[0]]; + /* spherical harmonics */ + for (let j = 0; j < shDim; j++) { + const dst = (i * shDim + j) * 3; + result.sh[dst] = f32[base + shIdx[j]]; // R + result.sh[dst + 1] = f32[base + shIdx[j + shDim]]; // G + result.sh[dst + 2] = f32[base + shIdx[j + 2 * shDim]]; // B + } + } + return result; +} +// -------------------------------------------------------------------------- diff --git a/server_tools/spz-js/dist/ply-serializer.d.ts b/server_tools/spz-js/dist/ply-serializer.d.ts new file mode 100644 index 0000000..7f85b46 --- /dev/null +++ b/server_tools/spz-js/dist/ply-serializer.d.ts @@ -0,0 +1,2 @@ +import { GaussianCloud } from './types.js'; +export declare function serializePly(data: GaussianCloud): ArrayBuffer; diff --git a/server_tools/spz-js/dist/ply-serializer.js b/server_tools/spz-js/dist/ply-serializer.js new file mode 100644 index 0000000..ab764ab --- /dev/null +++ b/server_tools/spz-js/dist/ply-serializer.js @@ -0,0 +1,85 @@ +export function serializePly(data) { + const N = data.numPoints; + // Validate sizes + if (data.positions.length !== N * 3 || + data.scales.length !== N * 3 || + data.rotations.length !== N * 4 || + data.alphas.length !== N || + data.colors.length !== N * 3) { + throw new Error('[PLY ERROR] Invalid data sizes'); + } + const shDim = Math.floor(data.sh.length / N / 3); + const D = 17 + shDim * 3; + // Create header + const header = [ + 'ply', + 'format binary_little_endian 1.0', + `element vertex ${N}`, + 'property float x', + 'property float y', + 'property float z', + 'property float nx', + 'property float ny', + 'property float nz', + 'property float f_dc_0', + 'property float f_dc_1', + 'property float f_dc_2', + ...Array.from({ length: shDim * 3 }, (_, i) => `property float f_rest_${i}`), + 'property float opacity', + 'property float scale_0', + 'property float scale_1', + 'property float scale_2', + 'property float rot_0', + 'property float rot_1', + 'property float rot_2', + 'property float rot_3', + 'end_header\n' + ].join('\n'); + // Prepare values array + const values = new Float32Array(N * D); + let outIdx = 0, i3 = 0, i4 = 0; + for (let i = 0; i < N; i++) { + // Position (x, y, z) + values[outIdx++] = data.positions[i3 + 0]; + values[outIdx++] = data.positions[i3 + 1]; + values[outIdx++] = data.positions[i3 + 2]; + // Normals (nx, ny, nz) - always zero + values[outIdx++] = 0; + values[outIdx++] = 0; + values[outIdx++] = 0; + // Colors (r, g, b) + values[outIdx++] = data.colors[i3 + 0]; + values[outIdx++] = data.colors[i3 + 1]; + values[outIdx++] = data.colors[i3 + 2]; + // Spherical harmonics + for (let j = 0; j < shDim; j++) { + values[outIdx++] = data.sh[(i * shDim + j) * 3 + 0]; + } + for (let j = 0; j < shDim; j++) { + values[outIdx++] = data.sh[(i * shDim + j) * 3 + 1]; + } + for (let j = 0; j < shDim; j++) { + values[outIdx++] = data.sh[(i * shDim + j) * 3 + 2]; + } + // Alpha + values[outIdx++] = data.alphas[i]; + // Scale (sx, sy, sz) + values[outIdx++] = data.scales[i3 + 0]; + values[outIdx++] = data.scales[i3 + 1]; + values[outIdx++] = data.scales[i3 + 2]; + // Rotation (qw, qx, qy, qz) + values[outIdx++] = data.rotations[i4 + 3]; + values[outIdx++] = data.rotations[i4 + 0]; + values[outIdx++] = data.rotations[i4 + 1]; + values[outIdx++] = data.rotations[i4 + 2]; + i3 += 3; + i4 += 4; + } + // Combine header and values into final buffer + const headerBuffer = new TextEncoder().encode(header); + const finalBuffer = new ArrayBuffer(headerBuffer.length + values.buffer.byteLength); + const finalView = new Uint8Array(finalBuffer); + finalView.set(headerBuffer, 0); + finalView.set(new Uint8Array(values.buffer), headerBuffer.length); + return finalBuffer; +} diff --git a/server_tools/spz-js/dist/spz-loader.d.ts b/server_tools/spz-js/dist/spz-loader.d.ts new file mode 100644 index 0000000..33e8656 --- /dev/null +++ b/server_tools/spz-js/dist/spz-loader.d.ts @@ -0,0 +1,3 @@ +import { GaussianCloud, PackedGaussians } from './types.js'; +export declare function packGaussians(g: GaussianCloud): PackedGaussians; +export declare function loadSpz(buffer: Uint8Array): Promise; diff --git a/server_tools/spz-js/dist/spz-loader.js b/server_tools/spz-js/dist/spz-loader.js new file mode 100644 index 0000000..293a2b4 --- /dev/null +++ b/server_tools/spz-js/dist/spz-loader.js @@ -0,0 +1,282 @@ +import { decompressGzipped } from './compression.js'; +import { dimForDegree, FLAG_ANTIALIASED, SPZ_MAGIC } from './constant.js'; +import { normalized, timesScalar, plus, halfToFloat } from './math.js'; +const colorScale = 0.15; +function sigmoid(x) { + return 1.0 / (1.0 + Math.exp(-x)); +} +function invSigmoid(x) { + return Math.log(x / (1.0 - x)); +} +function toUint8(x) { + return Math.min(Math.max(Math.round(x), 0), 255); +} +function quantizeSH(x, bucketSize) { + let q = Math.round(x * 128.0 + 128.0); + q = Math.floor((q + bucketSize / 2) / bucketSize) * bucketSize; + return Math.min(Math.max(q, 0), 255); +} +function unquantizeSH(x) { + return (x - 128.0) / 128.0; +} +function checkSizes(g) { + const shDim = dimForDegree(g.shDegree); + if (g.positions.length !== g.numPoints * 3) + return false; + if (g.scales.length !== g.numPoints * 3) + return false; + if (g.rotations.length !== g.numPoints * 4) + return false; + if (g.alphas.length !== g.numPoints) + return false; + if (g.colors.length !== g.numPoints * 3) + return false; + if (g.sh.length !== g.numPoints * shDim * 3) + return false; + return true; +} +export function packGaussians(g) { + if (!checkSizes(g)) { + throw new Error("Invalid GaussianCloud"); + } + const numPoints = g.numPoints; + const shDim = dimForDegree(g.shDegree); + // Use 12 bits for the fractional part of coordinates (~0.25 millimeter resolution) + const packed = { + numPoints: g.numPoints, + shDegree: g.shDegree, + fractionalBits: 12, + antialiased: g.antialiased, + positions: new Uint8Array(numPoints * 3 * 3), + scales: new Uint8Array(numPoints * 3), + rotations: new Uint8Array(numPoints * 3), + alphas: new Uint8Array(numPoints), + colors: new Uint8Array(numPoints * 3), + sh: new Uint8Array(numPoints * shDim * 3) + }; + // Store coordinates as 24-bit fixed point values + const scale = 1 << packed.fractionalBits; + for (let i = 0; i < numPoints * 3; i++) { + const fixed32 = Math.round(g.positions[i] * scale); + packed.positions[i * 3 + 0] = fixed32 & 0xff; + packed.positions[i * 3 + 1] = (fixed32 >> 8) & 0xff; + packed.positions[i * 3 + 2] = (fixed32 >> 16) & 0xff; + } + for (let i = 0; i < numPoints * 3; i++) { + packed.scales[i] = toUint8((g.scales[i] + 10.0) * 16.0); + } + for (let i = 0; i < numPoints; i++) { + // Normalize the quaternion, make w positive, then store xyz + // NOTE: These are already in xyzw order + const q = normalized(Array.from(g.rotations.subarray(i * 4, i * 4 + 4))); + const scaledQ = timesScalar(q, q[3] < 0 ? -127.5 : 127.5); + const offsetQ = plus(scaledQ, [127.5, 127.5, 127.5, 127.5]); + packed.rotations[i * 3 + 0] = toUint8(offsetQ[0]); + packed.rotations[i * 3 + 1] = toUint8(offsetQ[1]); + packed.rotations[i * 3 + 2] = toUint8(offsetQ[2]); + } + for (let i = 0; i < numPoints; i++) { + // Apply sigmoid activation to alpha + packed.alphas[i] = toUint8(sigmoid(g.alphas[i]) * 255.0); + } + for (let i = 0; i < numPoints * 3; i++) { + // Convert SH DC component to wide RGB + packed.colors[i] = toUint8(g.colors[i] * (colorScale * 255.0) + (0.5 * 255.0)); + } + if (g.shDegree > 0) { + // Spherical harmonics quantization parameters + const sh1Bits = 5; + const shRestBits = 4; + const shPerPoint = dimForDegree(g.shDegree) * 3; + for (let i = 0; i < numPoints * shPerPoint; i += shPerPoint) { + let j = 0; + for (; j < 9; j++) { // There are 9 coefficients for degree 1 + packed.sh[i + j] = quantizeSH(g.sh[i + j], 1 << (8 - sh1Bits)); + } + for (; j < shPerPoint; j++) { + packed.sh[i + j] = quantizeSH(g.sh[i + j], 1 << (8 - shRestBits)); + } + } + } + return packed; +} +function unpackGaussians(packed) { + const numPoints = packed.numPoints; + const shDim = dimForDegree(packed.shDegree); + const usesFloat16 = packed.positions.length === numPoints * 3 * 2; + // Validate sizes + if (!checkSizes2(packed, numPoints, shDim, usesFloat16)) { + return null; + } + const result = { + numPoints: packed.numPoints, + shDegree: packed.shDegree, + antialiased: packed.antialiased, + positions: new Float32Array(numPoints * 3), + scales: new Float32Array(numPoints * 3), + rotations: new Float32Array(numPoints * 4), + alphas: new Float32Array(numPoints), + colors: new Float32Array(numPoints * 3), + sh: new Float32Array(numPoints * shDim * 3) + }; + // Decode positions + if (usesFloat16) { + // Decode legacy float16 format + const halfData = new Uint16Array(packed.positions.buffer, packed.positions.byteOffset, numPoints * 3); + for (let i = 0; i < numPoints * 3; i++) { + result.positions[i] = halfToFloat(halfData[i]); + } + } + else { + // Decode 24-bit fixed point coordinates + const scale = 1.0 / (1 << packed.fractionalBits); + for (let i = 0; i < numPoints * 3; i++) { + let fixed32 = packed.positions[i * 3 + 0]; + fixed32 |= packed.positions[i * 3 + 1] << 8; + fixed32 |= packed.positions[i * 3 + 2] << 16; + fixed32 |= (fixed32 & 0x800000) ? 0xff000000 : 0; // sign extension + result.positions[i] = fixed32 * scale; + } + } + // Decode scales + for (let i = 0; i < numPoints * 3; i++) { + result.scales[i] = packed.scales[i] / 16.0 - 10.0; + } + // Decode rotations + for (let i = 0; i < numPoints; i++) { + const r = packed.rotations.subarray(i * 3, i * 3 + 3); + // Create xyz vector and apply scaling and offset + const xyz = [ + r[0] / 127.5 - 1.0, + r[1] / 127.5 - 1.0, + r[2] / 127.5 - 1.0 + ]; + // Copy xyz components + result.rotations[i * 4] = xyz[0]; + result.rotations[i * 4 + 1] = xyz[1]; + result.rotations[i * 4 + 2] = xyz[2]; + // Compute the real component (w) - quaternion is normalized and w is non-negative + const squaredNorm = xyz[0] * xyz[0] + xyz[1] * xyz[1] + xyz[2] * xyz[2]; + result.rotations[i * 4 + 3] = Math.sqrt(Math.max(0.0, 1.0 - squaredNorm)); + } + // Decode alphas + for (let i = 0; i < numPoints; i++) { + result.alphas[i] = invSigmoid(packed.alphas[i] / 255.0); + } + // Decode colors + for (let i = 0; i < numPoints * 3; i++) { + result.colors[i] = ((packed.colors[i] / 255.0) - 0.5) / colorScale; + } + // Decode spherical harmonics + for (let i = 0; i < packed.sh.length; i++) { + result.sh[i] = unquantizeSH(packed.sh[i]); + } + return result; +} +// Helper function to check sizes (matching C++ checkSizes function) +function checkSizes2(packed, numPoints, shDim, usesFloat16) { + if (packed.positions.length !== numPoints * 3 * (usesFloat16 ? 2 : 3)) + return false; + if (packed.scales.length !== numPoints * 3) + return false; + if (packed.rotations.length !== numPoints * 3) + return false; + if (packed.alphas.length !== numPoints) + return false; + if (packed.colors.length !== numPoints * 3) + return false; + if (packed.sh.length !== numPoints * shDim * 3) + return false; + return true; +} +const HEADER_SIZE = 16; // 4 + 4 + 4 + 1 + 1 + 1 + 1 bytes +const MAX_POINTS_TO_READ = 10000000; +function deserializePackedGaussians(buffer) { + const view = new DataView(buffer); + let offset = 0; + // Read and validate header + const header = { + magic: view.getUint32(offset, true), + version: view.getUint32(offset + 4, true), + numPoints: view.getUint32(offset + 8, true), + shDegree: view.getUint8(offset + 12), + fractionalBits: view.getUint8(offset + 13), + flags: view.getUint8(offset + 14), + reserved: view.getUint8(offset + 15) + }; + offset += HEADER_SIZE; + // Validate header + if (header.magic !== SPZ_MAGIC) { + console.error("[SPZ ERROR] deserializePackedGaussians: header not found"); + return null; + } + if (header.version < 1 || header.version > 2) { + console.error(`[SPZ ERROR] deserializePackedGaussians: version not supported: ${header.version}`); + return null; + } + if (header.numPoints > MAX_POINTS_TO_READ) { + console.error(`[SPZ ERROR] deserializePackedGaussians: Too many points: ${header.numPoints}`); + return null; + } + if (header.shDegree > 3) { + console.error(`[SPZ ERROR] deserializePackedGaussians: Unsupported SH degree: ${header.shDegree}`); + return null; + } + const numPoints = header.numPoints; + const shDim = dimForDegree(header.shDegree); + const usesFloat16 = header.version === 1; + // Initialize result object + const result = { + numPoints, + shDegree: header.shDegree, + fractionalBits: header.fractionalBits, + antialiased: (header.flags & FLAG_ANTIALIASED) !== 0, + positions: new Uint8Array(numPoints * 3 * (usesFloat16 ? 2 : 3)), + scales: new Uint8Array(numPoints * 3), + rotations: new Uint8Array(numPoints * 3), + alphas: new Uint8Array(numPoints), + colors: new Uint8Array(numPoints * 3), + sh: new Uint8Array(numPoints * shDim * 3) + }; + // Read data sections + try { + const uint8View = new Uint8Array(buffer); + let positionsSize = result.positions.length; + let currentOffset = offset; + result.positions.set(uint8View.slice(currentOffset, currentOffset + positionsSize)); + currentOffset += positionsSize; + result.alphas.set(uint8View.slice(currentOffset, currentOffset + result.alphas.length)); + currentOffset += result.alphas.length; + result.colors.set(uint8View.slice(currentOffset, currentOffset + result.colors.length)); + currentOffset += result.colors.length; + result.scales.set(uint8View.slice(currentOffset, currentOffset + result.scales.length)); + currentOffset += result.scales.length; + result.rotations.set(uint8View.slice(currentOffset, currentOffset + result.rotations.length)); + currentOffset += result.rotations.length; + result.sh.set(uint8View.slice(currentOffset, currentOffset + result.sh.length)); + // Verify we read the expected amount of data + if (currentOffset + result.sh.length !== buffer.byteLength) { + console.error("[SPZ ERROR] deserializePackedGaussians: incorrect buffer size"); + return null; + } + } + catch (error) { + console.error("[SPZ ERROR] deserializePackedGaussians: read error", error); + return null; + } + return result; +} +async function loadSpzPacked(compressedData) { + try { + const decompressed = await decompressGzipped(compressedData); + return deserializePackedGaussians(decompressed.buffer); + } + catch (error) { + console.error("[SPZ ERROR] loadSpzPacked: decompression error", error); + return null; + } +} +export async function loadSpz(buffer) { + const packed = await loadSpzPacked(buffer); + return unpackGaussians(packed); +} diff --git a/server_tools/spz-js/dist/spz-serializer.d.ts b/server_tools/spz-js/dist/spz-serializer.d.ts new file mode 100644 index 0000000..fcabb97 --- /dev/null +++ b/server_tools/spz-js/dist/spz-serializer.d.ts @@ -0,0 +1,3 @@ +import { PackedGaussians, GaussianCloud } from './types.js'; +export declare function serializePackedGaussians(packed: PackedGaussians): Promise; +export declare function serializeSpz(g: GaussianCloud): Promise; diff --git a/server_tools/spz-js/dist/spz-serializer.js b/server_tools/spz-js/dist/spz-serializer.js new file mode 100644 index 0000000..7cf6b15 --- /dev/null +++ b/server_tools/spz-js/dist/spz-serializer.js @@ -0,0 +1,43 @@ +import { SPZ_MAGIC, SPZ_VERSION, FLAG_ANTIALIASED } from './constant.js'; +import { compressGzipped } from './compression.js'; +import { packGaussians } from './spz-loader.js'; +export async function serializePackedGaussians(packed) { + const headerSize = 16; + const totalSize = headerSize + + packed.positions.length + + packed.alphas.length + + packed.colors.length + + packed.scales.length + + packed.rotations.length + + packed.sh.length; + const buffer = new ArrayBuffer(totalSize); + const view = new DataView(buffer); + const uint8View = new Uint8Array(buffer); + // Write header + view.setUint32(0, SPZ_MAGIC, true); + view.setUint32(4, SPZ_VERSION, true); + view.setUint32(8, packed.numPoints, true); + view.setUint8(12, packed.shDegree); + view.setUint8(13, packed.fractionalBits); + view.setUint8(14, packed.antialiased ? FLAG_ANTIALIASED : 0); + view.setUint8(15, 0); // reserved + // Write data + let offset = headerSize; + uint8View.set(packed.positions, offset); + offset += packed.positions.length; + uint8View.set(packed.alphas, offset); + offset += packed.alphas.length; + uint8View.set(packed.colors, offset); + offset += packed.colors.length; + uint8View.set(packed.scales, offset); + offset += packed.scales.length; + uint8View.set(packed.rotations, offset); + offset += packed.rotations.length; + uint8View.set(packed.sh, offset); + return uint8View; +} +export async function serializeSpz(g) { + const packed = packGaussians(g); + const serialized = await serializePackedGaussians(packed); + return compressGzipped(serialized); +} diff --git a/server_tools/spz-js/dist/test.d.ts b/server_tools/spz-js/dist/test.d.ts new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/server_tools/spz-js/dist/test.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/server_tools/spz-js/dist/types.d.ts b/server_tools/spz-js/dist/types.d.ts new file mode 100644 index 0000000..4d23fc6 --- /dev/null +++ b/server_tools/spz-js/dist/types.d.ts @@ -0,0 +1,26 @@ +export type Vec3f = [number, number, number]; +export type Quat4f = [number, number, number, number]; +export type Half = number; +export interface PackedGaussians { + numPoints: number; + shDegree: number; + fractionalBits: number; + antialiased: boolean; + positions: Uint8Array; + scales: Uint8Array; + rotations: Uint8Array; + alphas: Uint8Array; + colors: Uint8Array; + sh: Uint8Array; +} +export interface GaussianCloud { + numPoints: number; + shDegree: number; + antialiased: boolean; + positions: Float32Array; + scales: Float32Array; + rotations: Float32Array; + alphas: Float32Array; + colors: Float32Array; + sh: Float32Array; +} diff --git a/server_tools/spz-js/dist/types.js b/server_tools/spz-js/dist/types.js new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/server_tools/spz-js/dist/types.js @@ -0,0 +1 @@ +export {}; diff --git a/server_tools/spz-js/package.json b/server_tools/spz-js/package.json new file mode 100644 index 0000000..ce3de4b --- /dev/null +++ b/server_tools/spz-js/package.json @@ -0,0 +1,36 @@ +{ + "name": "spz-js", + "email": "ludovit@arrival.space", + "author": "Ludovit Kramar", + "version": "1.2.5", + "main": "dist/index.js", + "types": "dist/index.d.ts", + "files": [ + "/dist/**/*" + ], + "scripts": { + "build": "tsc" + }, + "keywords": [ + "spz", + "ply", + "converter", + "splat", + "3dgs", + "gaussian-splatting" + ], + "description": "Convert gaussian splats between SPZ and PLY formats.", + "devDependencies": { + "typescript": "^5.7.2" + }, + "type": "module", + "homepage": "https://github.com/arrival-space/spz-js", + "bugs": { + "url": "https://github.com/arrival-space/spz-js/issues", + "email": "ludovit@arrival.space" + }, + "license": "MIT", + "dependencies": { + "playcanvas": "^2.3.3" + } +} diff --git a/spz_route.py b/spz_route.py deleted file mode 100644 index 856b8c1..0000000 --- a/spz_route.py +++ /dev/null @@ -1,137 +0,0 @@ -"""HTTP route that transcodes a PLY to SPZ on demand and serves it. - -Registered into ComfyUI's aiohttp server (PromptServer.instance.routes). -The first request for a given PLY pays the conversion cost and writes a -sibling `.spz` next to the PLY; subsequent requests stream the cached SPZ -directly. - -Query: - /turntablegsviewer/spz?filename=&subfolder= - [&type=output] - -Mirrors ComfyUI's /view endpoint shape so the JS side can build URLs the -same way it does today. -""" -import logging -import os -import threading -from pathlib import Path - -from aiohttp import web - -import folder_paths - -log = logging.getLogger("comfyui-turntablegsviewer") - -# Per-path lock so two concurrent requests for the same PLY don't both -# kick off the transcode in parallel. -_locks: dict[str, threading.Lock] = {} -_locks_lock = threading.Lock() - - -def _lock_for(p: str) -> threading.Lock: - with _locks_lock: - if p not in _locks: - _locks[p] = threading.Lock() - return _locks[p] - - -def _resolve_output_path(filename: str, subfolder: str, type_: str) -> Path | None: - """Resolve a /view-style (filename, subfolder, type) to an absolute path, - refusing anything that escapes the output directory.""" - base_dir = { - "output": folder_paths.get_output_directory(), - "input": folder_paths.get_input_directory(), - "temp": folder_paths.get_temp_directory(), - }.get(type_, folder_paths.get_output_directory()) - base = Path(base_dir).resolve() - candidate = (base / (subfolder or "") / filename).resolve() - try: - candidate.relative_to(base) - except ValueError: - return None - return candidate - - -def _transcode_ply_to_spz(ply_path: Path, spz_path: Path) -> None: - """Run the spz package's PLY → SPZ pipeline and write atomically.""" - import spz - tmp = spz_path.with_suffix(spz_path.suffix + ".part") - unpack = spz.UnpackOptions() - cloud = spz.load_splat_from_ply(str(ply_path), unpack) - pack = spz.PackOptions() - ok = spz.save_spz(cloud, pack, str(tmp)) - if not ok: - try: tmp.unlink() - except FileNotFoundError: pass - raise RuntimeError(f"spz.save_spz failed for {ply_path}") - tmp.replace(spz_path) - - -def register_routes() -> None: - """Register the /turntablegsviewer/spz route. Idempotent and a no-op - if PromptServer isn't available (e.g. during static analysis).""" - try: - from server import PromptServer - except ImportError: - log.warning("PromptServer not importable; SPZ route not registered.") - return - if PromptServer.instance is None: - log.warning("PromptServer.instance is None; SPZ route not registered.") - return - - routes = PromptServer.instance.routes - - @routes.get("/turntablegsviewer/spz") - async def get_spz(request: web.Request) -> web.StreamResponse: - filename = request.query.get("filename", "") - subfolder = request.query.get("subfolder", "") - type_ = request.query.get("type", "output") - if not filename: - return web.Response(status=400, text="missing 'filename'") - if not filename.lower().endswith(".ply"): - return web.Response(status=400, text="filename must end in .ply") - - ply = _resolve_output_path(filename, subfolder, type_) - if ply is None: - return web.Response(status=403, text="path traversal rejected") - if not ply.is_file(): - return web.Response(status=404, text=f"PLY not found: {ply}") - - spz = ply.with_suffix(".spz") - # Cache valid only if newer than the PLY. - cache_fresh = spz.is_file() and spz.stat().st_mtime >= ply.stat().st_mtime - - if not cache_fresh: - with _lock_for(str(spz)): - # Re-check after acquiring the lock — someone else may have - # finished while we were waiting. - cache_fresh = spz.is_file() and spz.stat().st_mtime >= ply.stat().st_mtime - if not cache_fresh: - log.info("SPZ cache miss; transcoding %s -> %s", ply.name, spz.name) - try: - _transcode_ply_to_spz(ply, spz) - except ImportError: - return web.Response( - status=500, - text=("'spz' package not installed in the ComfyUI env. " - "Disable the 'Compress (SPZ)' toggle or " - "`pip install spz`."), - ) - except Exception as e: - log.exception("SPZ transcode failed for %s", ply) - return web.Response(status=500, text=f"SPZ transcode failed: {e}") - log.info( - "SPZ written: %s (%.1f MB → %.1f MB)", - spz.name, - ply.stat().st_size / (1024 * 1024), - spz.stat().st_size / (1024 * 1024), - ) - - return web.FileResponse( - spz, - headers={ - "Content-Type": "application/octet-stream", - "Cache-Control": "no-cache", - }, - ) diff --git a/web/js/OrbitControls.js b/web/js/OrbitControls.js new file mode 100644 index 0000000..6060cd4 --- /dev/null +++ b/web/js/OrbitControls.js @@ -0,0 +1,1963 @@ +import { + Controls, + MOUSE, + Quaternion, + Spherical, + TOUCH, + Vector2, + Vector3, + Plane, + Ray, + MathUtils +} from 'three'; + +/** + * Fires when the camera has been transformed by the controls. + * + * @event OrbitControls#change + * @type {Object} + */ +const _changeEvent = { type: 'change' }; + +/** + * Fires when an interaction was initiated. + * + * @event OrbitControls#start + * @type {Object} + */ +const _startEvent = { type: 'start' }; + +/** + * Fires when an interaction has finished. + * + * @event OrbitControls#end + * @type {Object} + */ +const _endEvent = { type: 'end' }; + +const _ray = new Ray(); +const _plane = new Plane(); +const _TILT_LIMIT = Math.cos( 70 * MathUtils.DEG2RAD ); + +const _v = new Vector3(); +const _twoPI = 2 * Math.PI; + +const _STATE = { + NONE: - 1, + ROTATE: 0, + DOLLY: 1, + PAN: 2, + TOUCH_ROTATE: 3, + TOUCH_PAN: 4, + TOUCH_DOLLY_PAN: 5, + TOUCH_DOLLY_ROTATE: 6 +}; +const _EPS = 0.000001; + + +/** + * Orbit controls allow the camera to orbit around a target. + * + * OrbitControls performs orbiting, dollying (zooming), and panning. Unlike {@link TrackballControls}, + * it maintains the "up" direction `object.up` (+Y by default). + * + * - Orbit: Left mouse / touch: one-finger move. + * - Zoom: Middle mouse, or mousewheel / touch: two-finger spread or squish. + * - Pan: Right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move. + * + * ```js + * const controls = new OrbitControls( camera, renderer.domElement ); + * + * // controls.update() must be called after any manual changes to the camera's transform + * camera.position.set( 0, 20, 100 ); + * controls.update(); + * + * function animate() { + * + * // required if controls.enableDamping or controls.autoRotate are set to true + * controls.update(); + * + * renderer.render( scene, camera ); + * + * } + * ``` + * + * @augments Controls + * @three_import import { OrbitControls } from 'three/addons/controls/OrbitControls.js'; + */ +class OrbitControls extends Controls { + + /** + * Constructs a new controls instance. + * + * @param {Object3D} object - The object that is managed by the controls. + * @param {?HTMLElement} domElement - The HTML element used for event listeners. + */ + constructor( object, domElement = null ) { + + super( object, domElement ); + + this.state = _STATE.NONE; + + /** + * The focus point of the controls, the `object` orbits around this. + * It can be updated manually at any point to change the focus of the controls. + * + * @type {Vector3} + */ + this.target = new Vector3(); + + /** + * The focus point of the `minTargetRadius` and `maxTargetRadius` limits. + * It can be updated manually at any point to change the center of interest + * for the `target`. + * + * @type {Vector3} + */ + this.cursor = new Vector3(); + + /** + * How far you can dolly in (perspective camera only). + * + * @type {number} + * @default 0 + */ + this.minDistance = 0; + + /** + * How far you can dolly out (perspective camera only). + * + * @type {number} + * @default Infinity + */ + this.maxDistance = Infinity; + + /** + * How far you can zoom in (orthographic camera only). + * + * @type {number} + * @default 0 + */ + this.minZoom = 0; + + /** + * How far you can zoom out (orthographic camera only). + * + * @type {number} + * @default Infinity + */ + this.maxZoom = Infinity; + + /** + * How close you can get the target to the 3D `cursor`. + * + * @type {number} + * @default 0 + */ + this.minTargetRadius = 0; + + /** + * How far you can move the target from the 3D `cursor`. + * + * @type {number} + * @default Infinity + */ + this.maxTargetRadius = Infinity; + + /** + * How far you can orbit vertically, lower limit. Range is `[0, Math.PI]` radians. + * + * @type {number} + * @default 0 + */ + this.minPolarAngle = 0; + + /** + * How far you can orbit vertically, upper limit. Range is `[0, Math.PI]` radians. + * + * @type {number} + * @default Math.PI + */ + this.maxPolarAngle = Math.PI; + + /** + * How far you can orbit horizontally, lower limit. If set, the interval `[ min, max ]` + * must be a sub-interval of `[ - 2 PI, 2 PI ]`, with `( max - min < 2 PI )`. + * + * @type {number} + * @default -Infinity + */ + this.minAzimuthAngle = - Infinity; + + /** + * How far you can orbit horizontally, upper limit. If set, the interval `[ min, max ]` + * must be a sub-interval of `[ - 2 PI, 2 PI ]`, with `( max - min < 2 PI )`. + * + * @type {number} + * @default -Infinity + */ + this.maxAzimuthAngle = Infinity; + + /** + * Set to `true` to enable damping (inertia), which can be used to give a sense of weight + * to the controls. Note that if this is enabled, you must call `update()` in your animation + * loop. + * + * @type {boolean} + * @default false + */ + this.enableDamping = false; + + /** + * The damping inertia used if `enableDamping` is set to `true`. + * + * Note that for this to work, you must call `update()` in your animation loop. + * + * @type {number} + * @default 0.05 + */ + this.dampingFactor = 0.05; + + /** + * Enable or disable zooming (dollying) of the camera. + * + * @type {boolean} + * @default true + */ + this.enableZoom = true; + + /** + * Speed of zooming / dollying. + * + * @type {number} + * @default 1 + */ + this.zoomSpeed = 1.0; + + /** + * Enable or disable horizontal and vertical rotation of the camera. + * + * Note that it is possible to disable a single axis by setting the min and max of the + * `minPolarAngle` or `minAzimuthAngle` to the same value, which will cause the vertical + * or horizontal rotation to be fixed at that value. + * + * @type {boolean} + * @default true + */ + this.enableRotate = true; + + /** + * Speed of rotation. + * + * @type {number} + * @default 1 + */ + this.rotateSpeed = 1.0; + + /** + * How fast to rotate the camera when the keyboard is used. + * + * @type {number} + * @default 1 + */ + this.keyRotateSpeed = 1.0; + + /** + * Enable or disable camera panning. + * + * @type {boolean} + * @default true + */ + this.enablePan = true; + + /** + * Speed of panning. + * + * @type {number} + * @default 1 + */ + this.panSpeed = 1.0; + + /** + * Defines how the camera's position is translated when panning. If `true`, the camera pans + * in screen space. Otherwise, the camera pans in the plane orthogonal to the camera's up + * direction. + * + * @type {boolean} + * @default true + */ + this.screenSpacePanning = true; + + /** + * How fast to pan the camera when the keyboard is used in + * pixels per keypress. + * + * @type {number} + * @default 7 + */ + this.keyPanSpeed = 7.0; + + /** + * Setting this property to `true` allows to zoom to the cursor's position. + * + * @type {boolean} + * @default false + */ + this.zoomToCursor = false; + + /** + * Set to true to automatically rotate around the target + * + * Note that if this is enabled, you must call `update()` in your animation loop. + * If you want the auto-rotate speed to be independent of the frame rate (the refresh + * rate of the display), you must pass the time `deltaTime`, in seconds, to `update()`. + * + * @type {boolean} + * @default false + */ + this.autoRotate = false; + + /** + * How fast to rotate around the target if `autoRotate` is `true`. The default equates to 30 seconds + * per orbit at 60fps. + * + * Note that if `autoRotate` is enabled, you must call `update()` in your animation loop. + * + * @type {number} + * @default 2 + */ + this.autoRotateSpeed = 2.0; + + /** + * This object contains references to the keycodes for controlling camera panning. + * + * ```js + * controls.keys = { + * LEFT: 'ArrowLeft', //left arrow + * UP: 'ArrowUp', // up arrow + * RIGHT: 'ArrowRight', // right arrow + * BOTTOM: 'ArrowDown' // down arrow + * } + * ``` + * @type {Object} + */ + this.keys = { LEFT: 'ArrowLeft', UP: 'ArrowUp', RIGHT: 'ArrowRight', BOTTOM: 'ArrowDown' }; + + /** + * This object contains references to the mouse actions used by the controls. + * + * ```js + * controls.mouseButtons = { + * LEFT: THREE.MOUSE.ROTATE, + * MIDDLE: THREE.MOUSE.DOLLY, + * RIGHT: THREE.MOUSE.PAN + * } + * ``` + * @type {Object} + */ + this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN }; + + /** + * This object contains references to the touch actions used by the controls. + * + * ```js + * controls.mouseButtons = { + * ONE: THREE.TOUCH.ROTATE, + * TWO: THREE.TOUCH.DOLLY_PAN + * } + * ``` + * @type {Object} + */ + this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN }; + + /** + * Used internally by `saveState()` and `reset()`. + * + * @type {Vector3} + */ + this.target0 = this.target.clone(); + + /** + * Used internally by `saveState()` and `reset()`. + * + * @type {Vector3} + */ + this.position0 = this.object.position.clone(); + + /** + * Used internally by `saveState()` and `reset()`. + * + * @type {number} + */ + this.zoom0 = this.object.zoom; + + this._cursorStyle = 'auto'; + + // the target DOM element for key events + this._domElementKeyEvents = null; + + // internals + + this._lastPosition = new Vector3(); + this._lastQuaternion = new Quaternion(); + this._lastTargetPosition = new Vector3(); + + // so camera.up is the orbit axis + this._quat = new Quaternion().setFromUnitVectors( object.up, new Vector3( 0, 1, 0 ) ); + this._quatInverse = this._quat.clone().invert(); + + // current position in spherical coordinates + this._spherical = new Spherical(); + this._sphericalDelta = new Spherical(); + + this._scale = 1; + this._panOffset = new Vector3(); + + this._rotateStart = new Vector2(); + this._rotateEnd = new Vector2(); + this._rotateDelta = new Vector2(); + + this._panStart = new Vector2(); + this._panEnd = new Vector2(); + this._panDelta = new Vector2(); + + this._dollyStart = new Vector2(); + this._dollyEnd = new Vector2(); + this._dollyDelta = new Vector2(); + + this._dollyDirection = new Vector3(); + this._mouse = new Vector2(); + this._performCursorZoom = false; + + this._pointers = []; + this._pointerPositions = {}; + + this._controlActive = false; + + // event listeners + + this._onPointerMove = onPointerMove.bind( this ); + this._onPointerDown = onPointerDown.bind( this ); + this._onPointerUp = onPointerUp.bind( this ); + this._onContextMenu = onContextMenu.bind( this ); + this._onMouseWheel = onMouseWheel.bind( this ); + this._onKeyDown = onKeyDown.bind( this ); + + this._onTouchStart = onTouchStart.bind( this ); + this._onTouchMove = onTouchMove.bind( this ); + + this._onMouseDown = onMouseDown.bind( this ); + this._onMouseMove = onMouseMove.bind( this ); + + this._interceptControlDown = interceptControlDown.bind( this ); + this._interceptControlUp = interceptControlUp.bind( this ); + + // + + if ( this.domElement !== null ) { + + this.connect( this.domElement ); + + } + + this.update(); + + } + + /** + * Defines the visual representation of the cursor. + * + * @type {('auto'|'grab')} + * @default 'auto' + */ + set cursorStyle( type ) { + + this._cursorStyle = type; + + if ( type === 'grab' ) { + + this.domElement.style.cursor = 'grab'; + + } else { + + this.domElement.style.cursor = 'auto'; + + } + + } + + get cursorStyle() { + + return this._cursorStyle; + + } + + connect( element ) { + + super.connect( element ); + + this.domElement.addEventListener( 'pointerdown', this._onPointerDown ); + this.domElement.addEventListener( 'pointercancel', this._onPointerUp ); + + this.domElement.addEventListener( 'contextmenu', this._onContextMenu ); + this.domElement.addEventListener( 'wheel', this._onMouseWheel, { passive: false } ); + + const document = this.domElement.getRootNode(); // offscreen canvas compatibility + document.addEventListener( 'keydown', this._interceptControlDown, { passive: true, capture: true } ); + + this.domElement.style.touchAction = 'none'; // Disable touch scroll + + } + + disconnect() { + + this.domElement.removeEventListener( 'pointerdown', this._onPointerDown ); + this.domElement.ownerDocument.removeEventListener( 'pointermove', this._onPointerMove ); + this.domElement.ownerDocument.removeEventListener( 'pointerup', this._onPointerUp ); + this.domElement.removeEventListener( 'pointercancel', this._onPointerUp ); + + this.domElement.removeEventListener( 'wheel', this._onMouseWheel ); + this.domElement.removeEventListener( 'contextmenu', this._onContextMenu ); + + this.stopListenToKeyEvents(); + + const document = this.domElement.getRootNode(); // offscreen canvas compatibility + document.removeEventListener( 'keydown', this._interceptControlDown, { capture: true } ); + + this.domElement.style.touchAction = ''; // Restore touch scroll + + } + + dispose() { + + this.disconnect(); + + } + + /** + * Get the current vertical rotation, in radians. + * + * @return {number} The current vertical rotation, in radians. + */ + getPolarAngle() { + + return this._spherical.phi; + + } + + /** + * Get the current horizontal rotation, in radians. + * + * @return {number} The current horizontal rotation, in radians. + */ + getAzimuthalAngle() { + + return this._spherical.theta; + + } + + /** + * Returns the distance from the camera to the target. + * + * @return {number} The distance from the camera to the target. + */ + getDistance() { + + return this.object.position.distanceTo( this.target ); + + } + + /** + * Adds key event listeners to the given DOM element. + * `window` is a recommended argument for using this method. + * + * @param {HTMLElement} domElement - The DOM element + */ + listenToKeyEvents( domElement ) { + + domElement.addEventListener( 'keydown', this._onKeyDown ); + this._domElementKeyEvents = domElement; + + } + + /** + * Removes the key event listener previously defined with `listenToKeyEvents()`. + */ + stopListenToKeyEvents() { + + if ( this._domElementKeyEvents !== null ) { + + this._domElementKeyEvents.removeEventListener( 'keydown', this._onKeyDown ); + this._domElementKeyEvents = null; + + } + + } + + /** + * Save the current state of the controls. This can later be recovered with `reset()`. + */ + saveState() { + + this.target0.copy( this.target ); + this.position0.copy( this.object.position ); + this.zoom0 = this.object.zoom; + + } + + /** + * Reset the controls to their state from either the last time the `saveState()` + * was called, or the initial state. + */ + reset() { + + this.target.copy( this.target0 ); + this.object.position.copy( this.position0 ); + this.object.zoom = this.zoom0; + + this.object.updateProjectionMatrix(); + this.dispatchEvent( _changeEvent ); + + this.update(); + + this.state = _STATE.NONE; + + } + + /** + * Programmatically pan the camera. + * + * @param {number} deltaX - The horizontal pan amount in pixels. + * @param {number} deltaY - The vertical pan amount in pixels. + */ + pan( deltaX, deltaY ) { + + this._pan( deltaX, deltaY ); + this.update(); + + } + + /** + * Programmatically dolly in (zoom in for perspective camera). + * + * @param {number} dollyScale - The dolly scale factor. + */ + dollyIn( dollyScale ) { + + this._dollyIn( dollyScale ); + this.update(); + + } + + /** + * Programmatically dolly out (zoom out for perspective camera). + * + * @param {number} dollyScale - The dolly scale factor. + */ + dollyOut( dollyScale ) { + + this._dollyOut( dollyScale ); + this.update(); + + } + + /** + * Programmatically rotate the camera left (around the vertical axis). + * + * @param {number} angle - The rotation angle in radians. + */ + rotateLeft( angle ) { + + this._rotateLeft( angle ); + this.update(); + + } + + /** + * Programmatically rotate the camera up (around the horizontal axis). + * + * @param {number} angle - The rotation angle in radians. + */ + rotateUp( angle ) { + + this._rotateUp( angle ); + this.update(); + + } + + update( deltaTime = null ) { + + const position = this.object.position; + + _v.copy( position ).sub( this.target ); + + // rotate offset to "y-axis-is-up" space + _v.applyQuaternion( this._quat ); + + // angle from z-axis around y-axis + this._spherical.setFromVector3( _v ); + + if ( this.autoRotate && this.state === _STATE.NONE ) { + + this._rotateLeft( this._getAutoRotationAngle( deltaTime ) ); + + } + + if ( this.enableDamping ) { + + this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor; + this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor; + + } else { + + this._spherical.theta += this._sphericalDelta.theta; + this._spherical.phi += this._sphericalDelta.phi; + + } + + // restrict theta to be between desired limits + + let min = this.minAzimuthAngle; + let max = this.maxAzimuthAngle; + + if ( isFinite( min ) && isFinite( max ) ) { + + if ( min < - Math.PI ) min += _twoPI; else if ( min > Math.PI ) min -= _twoPI; + + if ( max < - Math.PI ) max += _twoPI; else if ( max > Math.PI ) max -= _twoPI; + + if ( min <= max ) { + + this._spherical.theta = Math.max( min, Math.min( max, this._spherical.theta ) ); + + } else { + + this._spherical.theta = ( this._spherical.theta > ( min + max ) / 2 ) ? + Math.max( min, this._spherical.theta ) : + Math.min( max, this._spherical.theta ); + + } + + } + + // restrict phi to be between desired limits + this._spherical.phi = Math.max( this.minPolarAngle, Math.min( this.maxPolarAngle, this._spherical.phi ) ); + + this._spherical.makeSafe(); + + + // move target to panned location + + if ( this.enableDamping === true ) { + + this.target.addScaledVector( this._panOffset, this.dampingFactor ); + + } else { + + this.target.add( this._panOffset ); + + } + + // Limit the target distance from the cursor to create a sphere around the center of interest + this.target.sub( this.cursor ); + this.target.clampLength( this.minTargetRadius, this.maxTargetRadius ); + this.target.add( this.cursor ); + + let zoomChanged = false; + // adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera + // we adjust zoom later in these cases + if ( this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera ) { + + this._spherical.radius = this._clampDistance( this._spherical.radius ); + + } else { + + const prevRadius = this._spherical.radius; + this._spherical.radius = this._clampDistance( this._spherical.radius * this._scale ); + zoomChanged = prevRadius != this._spherical.radius; + + } + + _v.setFromSpherical( this._spherical ); + + // rotate offset back to "camera-up-vector-is-up" space + _v.applyQuaternion( this._quatInverse ); + + position.copy( this.target ).add( _v ); + + this.object.lookAt( this.target ); + + if ( this.enableDamping === true ) { + + this._sphericalDelta.theta *= ( 1 - this.dampingFactor ); + this._sphericalDelta.phi *= ( 1 - this.dampingFactor ); + + this._panOffset.multiplyScalar( 1 - this.dampingFactor ); + + } else { + + this._sphericalDelta.set( 0, 0, 0 ); + + this._panOffset.set( 0, 0, 0 ); + + } + + // adjust camera position + if ( this.zoomToCursor && this._performCursorZoom ) { + + let newRadius = null; + if ( this.object.isPerspectiveCamera ) { + + // move the camera down the pointer ray + // this method avoids floating point error + const prevRadius = _v.length(); + newRadius = this._clampDistance( prevRadius * this._scale ); + + const radiusDelta = prevRadius - newRadius; + this.object.position.addScaledVector( this._dollyDirection, radiusDelta ); + this.object.updateMatrixWorld(); + + zoomChanged = !! radiusDelta; + + } else if ( this.object.isOrthographicCamera ) { + + // adjust the ortho camera position based on zoom changes + const mouseBefore = new Vector3( this._mouse.x, this._mouse.y, 0 ); + mouseBefore.unproject( this.object ); + + const prevZoom = this.object.zoom; + this.object.zoom = Math.max( this.minZoom, Math.min( this.maxZoom, this.object.zoom / this._scale ) ); + this.object.updateProjectionMatrix(); + + zoomChanged = prevZoom !== this.object.zoom; + + const mouseAfter = new Vector3( this._mouse.x, this._mouse.y, 0 ); + mouseAfter.unproject( this.object ); + + this.object.position.sub( mouseAfter ).add( mouseBefore ); + this.object.updateMatrixWorld(); + + newRadius = _v.length(); + + } else { + + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.' ); + this.zoomToCursor = false; + + } + + // handle the placement of the target + if ( newRadius !== null ) { + + if ( this.screenSpacePanning ) { + + // position the orbit target in front of the new camera position + this.target.set( 0, 0, - 1 ) + .transformDirection( this.object.matrix ) + .multiplyScalar( newRadius ) + .add( this.object.position ); + + } else { + + // get the ray and translation plane to compute target + _ray.origin.copy( this.object.position ); + _ray.direction.set( 0, 0, - 1 ).transformDirection( this.object.matrix ); + + // if the camera is 20 degrees above the horizon then don't adjust the focus target to avoid + // extremely large values + if ( Math.abs( this.object.up.dot( _ray.direction ) ) < _TILT_LIMIT ) { + + this.object.lookAt( this.target ); + + } else { + + _plane.setFromNormalAndCoplanarPoint( this.object.up, this.target ); + _ray.intersectPlane( _plane, this.target ); + + } + + } + + } + + } else if ( this.object.isOrthographicCamera ) { + + const prevZoom = this.object.zoom; + this.object.zoom = Math.max( this.minZoom, Math.min( this.maxZoom, this.object.zoom / this._scale ) ); + + if ( prevZoom !== this.object.zoom ) { + + this.object.updateProjectionMatrix(); + zoomChanged = true; + + } + + } + + this._scale = 1; + this._performCursorZoom = false; + + // update condition is: + // min(camera displacement, camera rotation in radians)^2 > EPS + // using small-angle approximation cos(x/2) = 1 - x^2 / 8 + + if ( zoomChanged || + this._lastPosition.distanceToSquared( this.object.position ) > _EPS || + 8 * ( 1 - this._lastQuaternion.dot( this.object.quaternion ) ) > _EPS || + this._lastTargetPosition.distanceToSquared( this.target ) > _EPS ) { + + this.dispatchEvent( _changeEvent ); + + this._lastPosition.copy( this.object.position ); + this._lastQuaternion.copy( this.object.quaternion ); + this._lastTargetPosition.copy( this.target ); + + return true; + + } + + return false; + + } + + _getAutoRotationAngle( deltaTime ) { + + if ( deltaTime !== null ) { + + return ( _twoPI / 60 * this.autoRotateSpeed ) * deltaTime; + + } else { + + return _twoPI / 60 / 60 * this.autoRotateSpeed; + + } + + } + + _getZoomScale( delta ) { + + const normalizedDelta = Math.abs( delta * 0.01 ); + return Math.pow( 0.95, this.zoomSpeed * normalizedDelta ); + + } + + _rotateLeft( angle ) { + + this._sphericalDelta.theta -= angle; + + } + + _rotateUp( angle ) { + + this._sphericalDelta.phi -= angle; + + } + + _panLeft( distance, objectMatrix ) { + + _v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix + _v.multiplyScalar( - distance ); + + this._panOffset.add( _v ); + + } + + _panUp( distance, objectMatrix ) { + + if ( this.screenSpacePanning === true ) { + + _v.setFromMatrixColumn( objectMatrix, 1 ); + + } else { + + _v.setFromMatrixColumn( objectMatrix, 0 ); + _v.crossVectors( this.object.up, _v ); + + } + + _v.multiplyScalar( distance ); + + this._panOffset.add( _v ); + + } + + // deltaX and deltaY are in pixels; right and down are positive + _pan( deltaX, deltaY ) { + + const element = this.domElement; + + if ( this.object.isPerspectiveCamera ) { + + // perspective + const position = this.object.position; + _v.copy( position ).sub( this.target ); + let targetDistance = _v.length(); + + // half of the fov is center to top of screen + targetDistance *= Math.tan( ( this.object.fov / 2 ) * Math.PI / 180.0 ); + + // we use only clientHeight here so aspect ratio does not distort speed + this._panLeft( 2 * deltaX * targetDistance / element.clientHeight, this.object.matrix ); + this._panUp( 2 * deltaY * targetDistance / element.clientHeight, this.object.matrix ); + + } else if ( this.object.isOrthographicCamera ) { + + // orthographic + this._panLeft( deltaX * ( this.object.right - this.object.left ) / this.object.zoom / element.clientWidth, this.object.matrix ); + this._panUp( deltaY * ( this.object.top - this.object.bottom ) / this.object.zoom / element.clientHeight, this.object.matrix ); + + } else { + + // camera neither orthographic nor perspective + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' ); + this.enablePan = false; + + } + + } + + _dollyOut( dollyScale ) { + + if ( this.object.isPerspectiveCamera || this.object.isOrthographicCamera ) { + + this._scale /= dollyScale; + + } else { + + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' ); + this.enableZoom = false; + + } + + } + + _dollyIn( dollyScale ) { + + if ( this.object.isPerspectiveCamera || this.object.isOrthographicCamera ) { + + this._scale *= dollyScale; + + } else { + + console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' ); + this.enableZoom = false; + + } + + } + + _updateZoomParameters( x, y ) { + + if ( ! this.zoomToCursor ) { + + return; + + } + + this._performCursorZoom = true; + + const rect = this.domElement.getBoundingClientRect(); + const dx = x - rect.left; + const dy = y - rect.top; + const w = rect.width; + const h = rect.height; + + this._mouse.x = ( dx / w ) * 2 - 1; + this._mouse.y = - ( dy / h ) * 2 + 1; + + this._dollyDirection.set( this._mouse.x, this._mouse.y, 1 ).unproject( this.object ).sub( this.object.position ).normalize(); + + } + + _clampDistance( dist ) { + + return Math.max( this.minDistance, Math.min( this.maxDistance, dist ) ); + + } + + // + // event callbacks - update the object state + // + + _handleMouseDownRotate( event ) { + + this._rotateStart.set( event.clientX, event.clientY ); + + } + + _handleMouseDownDolly( event ) { + + this._updateZoomParameters( event.clientX, event.clientX ); + this._dollyStart.set( event.clientX, event.clientY ); + + } + + _handleMouseDownPan( event ) { + + this._panStart.set( event.clientX, event.clientY ); + + } + + _handleMouseMoveRotate( event ) { + + this._rotateEnd.set( event.clientX, event.clientY ); + + this._rotateDelta.subVectors( this._rotateEnd, this._rotateStart ).multiplyScalar( this.rotateSpeed ); + + const element = this.domElement; + + this._rotateLeft( _twoPI * this._rotateDelta.x / element.clientHeight ); // yes, height + + this._rotateUp( _twoPI * this._rotateDelta.y / element.clientHeight ); + + this._rotateStart.copy( this._rotateEnd ); + + this.update(); + + } + + _handleMouseMoveDolly( event ) { + + this._dollyEnd.set( event.clientX, event.clientY ); + + this._dollyDelta.subVectors( this._dollyEnd, this._dollyStart ); + + if ( this._dollyDelta.y > 0 ) { + + this._dollyOut( this._getZoomScale( this._dollyDelta.y ) ); + + } else if ( this._dollyDelta.y < 0 ) { + + this._dollyIn( this._getZoomScale( this._dollyDelta.y ) ); + + } + + this._dollyStart.copy( this._dollyEnd ); + + this.update(); + + } + + _handleMouseMovePan( event ) { + + this._panEnd.set( event.clientX, event.clientY ); + + this._panDelta.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.panSpeed ); + + this._pan( this._panDelta.x, this._panDelta.y ); + + this._panStart.copy( this._panEnd ); + + this.update(); + + } + + _handleMouseWheel( event ) { + + this._updateZoomParameters( event.clientX, event.clientY ); + + if ( event.deltaY < 0 ) { + + this._dollyIn( this._getZoomScale( event.deltaY ) ); + + } else if ( event.deltaY > 0 ) { + + this._dollyOut( this._getZoomScale( event.deltaY ) ); + + } + + this.update(); + + } + + _handleKeyDown( event ) { + + let needsUpdate = false; + + switch ( event.code ) { + + case this.keys.UP: + + if ( event.ctrlKey || event.metaKey || event.shiftKey ) { + + if ( this.enableRotate ) { + + this._rotateUp( _twoPI * this.keyRotateSpeed / this.domElement.clientHeight ); + + } + + } else { + + if ( this.enablePan ) { + + this._pan( 0, this.keyPanSpeed ); + + } + + } + + needsUpdate = true; + break; + + case this.keys.BOTTOM: + + if ( event.ctrlKey || event.metaKey || event.shiftKey ) { + + if ( this.enableRotate ) { + + this._rotateUp( - _twoPI * this.keyRotateSpeed / this.domElement.clientHeight ); + + } + + } else { + + if ( this.enablePan ) { + + this._pan( 0, - this.keyPanSpeed ); + + } + + } + + needsUpdate = true; + break; + + case this.keys.LEFT: + + if ( event.ctrlKey || event.metaKey || event.shiftKey ) { + + if ( this.enableRotate ) { + + this._rotateLeft( _twoPI * this.keyRotateSpeed / this.domElement.clientHeight ); + + } + + } else { + + if ( this.enablePan ) { + + this._pan( this.keyPanSpeed, 0 ); + + } + + } + + needsUpdate = true; + break; + + case this.keys.RIGHT: + + if ( event.ctrlKey || event.metaKey || event.shiftKey ) { + + if ( this.enableRotate ) { + + this._rotateLeft( - _twoPI * this.keyRotateSpeed / this.domElement.clientHeight ); + + } + + } else { + + if ( this.enablePan ) { + + this._pan( - this.keyPanSpeed, 0 ); + + } + + } + + needsUpdate = true; + break; + + } + + if ( needsUpdate ) { + + // prevent the browser from scrolling on cursor keys + event.preventDefault(); + + this.update(); + + } + + + } + + _handleTouchStartRotate( event ) { + + if ( this._pointers.length === 1 ) { + + this._rotateStart.set( event.pageX, event.pageY ); + + } else { + + const position = this._getSecondPointerPosition( event ); + + const x = 0.5 * ( event.pageX + position.x ); + const y = 0.5 * ( event.pageY + position.y ); + + this._rotateStart.set( x, y ); + + } + + } + + _handleTouchStartPan( event ) { + + if ( this._pointers.length === 1 ) { + + this._panStart.set( event.pageX, event.pageY ); + + } else { + + const position = this._getSecondPointerPosition( event ); + + const x = 0.5 * ( event.pageX + position.x ); + const y = 0.5 * ( event.pageY + position.y ); + + this._panStart.set( x, y ); + + } + + } + + _handleTouchStartDolly( event ) { + + const position = this._getSecondPointerPosition( event ); + + const dx = event.pageX - position.x; + const dy = event.pageY - position.y; + + const distance = Math.sqrt( dx * dx + dy * dy ); + + this._dollyStart.set( 0, distance ); + + } + + _handleTouchStartDollyPan( event ) { + + if ( this.enableZoom ) this._handleTouchStartDolly( event ); + + if ( this.enablePan ) this._handleTouchStartPan( event ); + + } + + _handleTouchStartDollyRotate( event ) { + + if ( this.enableZoom ) this._handleTouchStartDolly( event ); + + if ( this.enableRotate ) this._handleTouchStartRotate( event ); + + } + + _handleTouchMoveRotate( event ) { + + if ( this._pointers.length == 1 ) { + + this._rotateEnd.set( event.pageX, event.pageY ); + + } else { + + const position = this._getSecondPointerPosition( event ); + + const x = 0.5 * ( event.pageX + position.x ); + const y = 0.5 * ( event.pageY + position.y ); + + this._rotateEnd.set( x, y ); + + } + + this._rotateDelta.subVectors( this._rotateEnd, this._rotateStart ).multiplyScalar( this.rotateSpeed ); + + const element = this.domElement; + + this._rotateLeft( _twoPI * this._rotateDelta.x / element.clientHeight ); // yes, height + + this._rotateUp( _twoPI * this._rotateDelta.y / element.clientHeight ); + + this._rotateStart.copy( this._rotateEnd ); + + } + + _handleTouchMovePan( event ) { + + if ( this._pointers.length === 1 ) { + + this._panEnd.set( event.pageX, event.pageY ); + + } else { + + const position = this._getSecondPointerPosition( event ); + + const x = 0.5 * ( event.pageX + position.x ); + const y = 0.5 * ( event.pageY + position.y ); + + this._panEnd.set( x, y ); + + } + + this._panDelta.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.panSpeed ); + + this._pan( this._panDelta.x, this._panDelta.y ); + + this._panStart.copy( this._panEnd ); + + } + + _handleTouchMoveDolly( event ) { + + const position = this._getSecondPointerPosition( event ); + + const dx = event.pageX - position.x; + const dy = event.pageY - position.y; + + const distance = Math.sqrt( dx * dx + dy * dy ); + + this._dollyEnd.set( 0, distance ); + + this._dollyDelta.set( 0, Math.pow( this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed ) ); + + this._dollyOut( this._dollyDelta.y ); + + this._dollyStart.copy( this._dollyEnd ); + + const centerX = ( event.pageX + position.x ) * 0.5; + const centerY = ( event.pageY + position.y ) * 0.5; + + this._updateZoomParameters( centerX, centerY ); + + } + + _handleTouchMoveDollyPan( event ) { + + if ( this.enableZoom ) this._handleTouchMoveDolly( event ); + + if ( this.enablePan ) this._handleTouchMovePan( event ); + + } + + _handleTouchMoveDollyRotate( event ) { + + if ( this.enableZoom ) this._handleTouchMoveDolly( event ); + + if ( this.enableRotate ) this._handleTouchMoveRotate( event ); + + } + + // pointers + + _addPointer( event ) { + + this._pointers.push( event.pointerId ); + + } + + _removePointer( event ) { + + delete this._pointerPositions[ event.pointerId ]; + + for ( let i = 0; i < this._pointers.length; i ++ ) { + + if ( this._pointers[ i ] == event.pointerId ) { + + this._pointers.splice( i, 1 ); + return; + + } + + } + + } + + _isTrackingPointer( event ) { + + for ( let i = 0; i < this._pointers.length; i ++ ) { + + if ( this._pointers[ i ] == event.pointerId ) return true; + + } + + return false; + + } + + _trackPointer( event ) { + + let position = this._pointerPositions[ event.pointerId ]; + + if ( position === undefined ) { + + position = new Vector2(); + this._pointerPositions[ event.pointerId ] = position; + + } + + position.set( event.pageX, event.pageY ); + + } + + _getSecondPointerPosition( event ) { + + const pointerId = ( event.pointerId === this._pointers[ 0 ] ) ? this._pointers[ 1 ] : this._pointers[ 0 ]; + + return this._pointerPositions[ pointerId ]; + + } + + // + + _customWheelEvent( event ) { + + const mode = event.deltaMode; + + // minimal wheel event altered to meet delta-zoom demand + const newEvent = { + clientX: event.clientX, + clientY: event.clientY, + deltaY: event.deltaY, + }; + + switch ( mode ) { + + case 1: // LINE_MODE + newEvent.deltaY *= 16; + break; + + case 2: // PAGE_MODE + newEvent.deltaY *= 100; + break; + + } + + // detect if event was triggered by pinching + if ( event.ctrlKey && ! this._controlActive ) { + + newEvent.deltaY *= 10; + + } + + return newEvent; + + } + +} + +function onPointerDown( event ) { + + if ( this.enabled === false ) return; + + if ( this._pointers.length === 0 ) { + + this.domElement.setPointerCapture( event.pointerId ); + + this.domElement.ownerDocument.addEventListener( 'pointermove', this._onPointerMove ); + this.domElement.ownerDocument.addEventListener( 'pointerup', this._onPointerUp ); + + } + + // + + if ( this._isTrackingPointer( event ) ) return; + + // + + this._addPointer( event ); + + if ( event.pointerType === 'touch' ) { + + this._onTouchStart( event ); + + } else { + + this._onMouseDown( event ); + + } + + if ( this._cursorStyle === 'grab' ) { + + this.domElement.style.cursor = 'grabbing'; + + } + +} + +function onPointerMove( event ) { + + if ( this.enabled === false ) return; + + if ( event.pointerType === 'touch' ) { + + this._onTouchMove( event ); + + } else { + + this._onMouseMove( event ); + + } + +} + +function onPointerUp( event ) { + + this._removePointer( event ); + + switch ( this._pointers.length ) { + + case 0: + + this.domElement.releasePointerCapture( event.pointerId ); + + this.domElement.ownerDocument.removeEventListener( 'pointermove', this._onPointerMove ); + this.domElement.ownerDocument.removeEventListener( 'pointerup', this._onPointerUp ); + + this.dispatchEvent( _endEvent ); + + this.state = _STATE.NONE; + + if ( this._cursorStyle === 'grab' ) { + + this.domElement.style.cursor = 'grab'; + + } + + break; + + case 1: + + const pointerId = this._pointers[ 0 ]; + const position = this._pointerPositions[ pointerId ]; + + // minimal placeholder event - allows state correction on pointer-up + this._onTouchStart( { pointerId: pointerId, pageX: position.x, pageY: position.y } ); + + break; + + } + +} + +function onMouseDown( event ) { + + let mouseAction; + + switch ( event.button ) { + + case 0: + + mouseAction = this.mouseButtons.LEFT; + break; + + case 1: + + mouseAction = this.mouseButtons.MIDDLE; + break; + + case 2: + + mouseAction = this.mouseButtons.RIGHT; + break; + + default: + + mouseAction = - 1; + + } + + switch ( mouseAction ) { + + case MOUSE.DOLLY: + + if ( this.enableZoom === false ) return; + + this._handleMouseDownDolly( event ); + + this.state = _STATE.DOLLY; + + break; + + case MOUSE.ROTATE: + + if ( event.ctrlKey || event.metaKey || event.shiftKey ) { + + if ( this.enablePan === false ) return; + + this._handleMouseDownPan( event ); + + this.state = _STATE.PAN; + + } else { + + if ( this.enableRotate === false ) return; + + this._handleMouseDownRotate( event ); + + this.state = _STATE.ROTATE; + + } + + break; + + case MOUSE.PAN: + + if ( event.ctrlKey || event.metaKey || event.shiftKey ) { + + if ( this.enableRotate === false ) return; + + this._handleMouseDownRotate( event ); + + this.state = _STATE.ROTATE; + + } else { + + if ( this.enablePan === false ) return; + + this._handleMouseDownPan( event ); + + this.state = _STATE.PAN; + + } + + break; + + default: + + this.state = _STATE.NONE; + + } + + if ( this.state !== _STATE.NONE ) { + + this.dispatchEvent( _startEvent ); + + } + +} + +function onMouseMove( event ) { + + switch ( this.state ) { + + case _STATE.ROTATE: + + if ( this.enableRotate === false ) return; + + this._handleMouseMoveRotate( event ); + + break; + + case _STATE.DOLLY: + + if ( this.enableZoom === false ) return; + + this._handleMouseMoveDolly( event ); + + break; + + case _STATE.PAN: + + if ( this.enablePan === false ) return; + + this._handleMouseMovePan( event ); + + break; + + } + +} + +function onMouseWheel( event ) { + + if ( this.enabled === false || this.enableZoom === false || this.state !== _STATE.NONE ) return; + + event.preventDefault(); + + this.dispatchEvent( _startEvent ); + + this._handleMouseWheel( this._customWheelEvent( event ) ); + + this.dispatchEvent( _endEvent ); + +} + +function onKeyDown( event ) { + + if ( this.enabled === false ) return; + + this._handleKeyDown( event ); + +} + +function onTouchStart( event ) { + + this._trackPointer( event ); + + switch ( this._pointers.length ) { + + case 1: + + switch ( this.touches.ONE ) { + + case TOUCH.ROTATE: + + if ( this.enableRotate === false ) return; + + this._handleTouchStartRotate( event ); + + this.state = _STATE.TOUCH_ROTATE; + + break; + + case TOUCH.PAN: + + if ( this.enablePan === false ) return; + + this._handleTouchStartPan( event ); + + this.state = _STATE.TOUCH_PAN; + + break; + + default: + + this.state = _STATE.NONE; + + } + + break; + + case 2: + + switch ( this.touches.TWO ) { + + case TOUCH.DOLLY_PAN: + + if ( this.enableZoom === false && this.enablePan === false ) return; + + this._handleTouchStartDollyPan( event ); + + this.state = _STATE.TOUCH_DOLLY_PAN; + + break; + + case TOUCH.DOLLY_ROTATE: + + if ( this.enableZoom === false && this.enableRotate === false ) return; + + this._handleTouchStartDollyRotate( event ); + + this.state = _STATE.TOUCH_DOLLY_ROTATE; + + break; + + default: + + this.state = _STATE.NONE; + + } + + break; + + default: + + this.state = _STATE.NONE; + + } + + if ( this.state !== _STATE.NONE ) { + + this.dispatchEvent( _startEvent ); + + } + +} + +function onTouchMove( event ) { + + this._trackPointer( event ); + + switch ( this.state ) { + + case _STATE.TOUCH_ROTATE: + + if ( this.enableRotate === false ) return; + + this._handleTouchMoveRotate( event ); + + this.update(); + + break; + + case _STATE.TOUCH_PAN: + + if ( this.enablePan === false ) return; + + this._handleTouchMovePan( event ); + + this.update(); + + break; + + case _STATE.TOUCH_DOLLY_PAN: + + if ( this.enableZoom === false && this.enablePan === false ) return; + + this._handleTouchMoveDollyPan( event ); + + this.update(); + + break; + + case _STATE.TOUCH_DOLLY_ROTATE: + + if ( this.enableZoom === false && this.enableRotate === false ) return; + + this._handleTouchMoveDollyRotate( event ); + + this.update(); + + break; + + default: + + this.state = _STATE.NONE; + + } + +} + +function onContextMenu( event ) { + + if ( this.enabled === false ) return; + + event.preventDefault(); + +} + +function interceptControlDown( event ) { + + if ( event.key === 'Control' ) { + + this._controlActive = true; + + const document = this.domElement.getRootNode(); // offscreen canvas compatibility + + document.addEventListener( 'keyup', this._interceptControlUp, { passive: true, capture: true } ); + + } + +} + +function interceptControlUp( event ) { + + if ( event.key === 'Control' ) { + + this._controlActive = false; + + const document = this.domElement.getRootNode(); // offscreen canvas compatibility + + document.removeEventListener( 'keyup', this._interceptControlUp, { passive: true, capture: true } ); + + } + +} + +export { OrbitControls }; diff --git a/web/js/gaussian-splats-3d.umd.js b/web/js/gaussian-splats-3d.umd.js deleted file mode 100644 index 92aed6c..0000000 --- a/web/js/gaussian-splats-3d.umd.js +++ /dev/null @@ -1,14491 +0,0 @@ -(function (global, factory) { - typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('three')) : - typeof define === 'function' && define.amd ? define(['exports', 'three'], factory) : - (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["Gaussian Splats 3D"] = global["Gaussian Splats 3D"] || {}, global.THREE)); -})(this, (function (exports, THREE) { 'use strict'; - - function _interopNamespaceDefault(e) { - var n = Object.create(null); - if (e) { - Object.keys(e).forEach(function (k) { - if (k !== 'default') { - var d = Object.getOwnPropertyDescriptor(e, k); - Object.defineProperty(n, k, d.get ? d : { - enumerable: true, - get: function () { return e[k]; } - }); - } - }); - } - n.default = e; - return Object.freeze(n); - } - - var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE); - - /** - * AbortablePromise: A quick & dirty wrapper for JavaScript's Promise class that allows the underlying - * asynchronous operation to be cancelled. It is only meant for simple situations where no complex promise - * chaining or merging occurs. It needs a significant amount of work to truly replicate the full - * functionality of JavaScript's Promise class. Look at Util.fetchWithProgress() for example usage. - * - * This class was primarily added to allow splat scene downloads to be cancelled. It has not been tested - * very thoroughly and the implementation is kinda janky. If you can at all help it, please avoid using it :) - */ - class AbortablePromise { - - static idGen = 0; - - constructor(promiseFunc, abortHandler) { - - let resolver; - let rejecter; - this.promise = new Promise((resolve, reject) => { - resolver = resolve; - rejecter = reject; - }); - - const promiseResolve = resolver.bind(this); - const promiseReject = rejecter.bind(this); - - const resolve = (...args) => { - promiseResolve(...args); - }; - - const reject = (error) => { - promiseReject(error); - }; - - promiseFunc(resolve.bind(this), reject.bind(this)); - this.abortHandler = abortHandler; - this.id = AbortablePromise.idGen++; - } - - then(onResolve) { - return new AbortablePromise((resolve, reject) => { - this.promise = this.promise - .then((...args) => { - const onResolveResult = onResolve(...args); - if (onResolveResult instanceof Promise || onResolveResult instanceof AbortablePromise) { - onResolveResult.then((...args2) => { - resolve(...args2); - }); - } else { - resolve(onResolveResult); - } - }) - .catch((error) => { - reject(error); - }); - }, this.abortHandler); - } - - catch(onFail) { - return new AbortablePromise((resolve) => { - this.promise = this.promise.then((...args) => { - resolve(...args); - }) - .catch(onFail); - }, this.abortHandler); - } - - abort(reason) { - if (this.abortHandler) this.abortHandler(reason); - } - - } - - class AbortedPromiseError extends Error { - - constructor(msg) { - super(msg); - } - - } - - const floatToHalf = function() { - - const floatView = new Float32Array(1); - const int32View = new Int32Array(floatView.buffer); - - return function(val) { - floatView[0] = val; - const x = int32View[0]; - - let bits = (x >> 16) & 0x8000; - let m = (x >> 12) & 0x07ff; - const e = (x >> 23) & 0xff; - - if (e < 103) return bits; - - if (e > 142) { - bits |= 0x7c00; - bits |= ((e == 255) ? 0 : 1) && (x & 0x007fffff); - return bits; - } - - if (e < 113) { - m |= 0x0800; - bits |= (m >> (114 - e)) + ((m >> (113 - e)) & 1); - return bits; - } - - bits |= (( e - 112) << 10) | (m >> 1); - bits += m & 1; - return bits; - }; - - }(); - - const uintEncodedFloat = function() { - - const floatView = new Float32Array(1); - const int32View = new Int32Array(floatView.buffer); - - return function(f) { - floatView[0] = f; - return int32View[0]; - }; - - }(); - - const rgbaToInteger = function(r, g, b, a) { - return r + (g << 8) + (b << 16) + (a << 24); - }; - - const rgbaArrayToInteger = function(arr, offset) { - return arr[offset] + (arr[offset + 1] << 8) + (arr[offset + 2] << 16) + (arr[offset + 3] << 24); - }; - - const fetchWithProgress = function(path, onProgress, saveChunks = true, headers) { - - const abortController = new AbortController(); - const signal = abortController.signal; - let aborted = false; - const abortHandler = (reason) => { - abortController.abort(reason); - aborted = true; - }; - - let onProgressCalledAtComplete = false; - const localOnProgress = (percent, percentLabel, chunk, fileSize) => { - if (onProgress && !onProgressCalledAtComplete) { - onProgress(percent, percentLabel, chunk, fileSize); - if (percent === 100) { - onProgressCalledAtComplete = true; - } - } - }; - - return new AbortablePromise((resolve, reject) => { - const fetchOptions = { signal }; - if (headers) fetchOptions.headers = headers; - fetch(path, fetchOptions) - .then(async (data) => { - // Handle error conditions where data is still returned - if (!data.ok) { - const errorText = await data.text(); - reject(new Error(`Fetch failed: ${data.status} ${data.statusText} ${errorText}`)); - return; - } - - const reader = data.body.getReader(); - let bytesDownloaded = 0; - let _fileSize = data.headers.get('Content-Length'); - let fileSize = _fileSize ? parseInt(_fileSize) : undefined; - - const chunks = []; - - while (!aborted) { - try { - const { value: chunk, done } = await reader.read(); - if (done) { - localOnProgress(100, '100%', chunk, fileSize); - if (saveChunks) { - const buffer = new Blob(chunks).arrayBuffer(); - resolve(buffer); - } else { - resolve(); - } - break; - } - bytesDownloaded += chunk.length; - let percent; - let percentLabel; - if (fileSize !== undefined) { - percent = bytesDownloaded / fileSize * 100; - percentLabel = `${percent.toFixed(2)}%`; - } - if (saveChunks) { - chunks.push(chunk); - } - localOnProgress(percent, percentLabel, chunk, fileSize); - } catch (error) { - reject(error); - return; - } - } - }) - .catch((error) => { - reject(new AbortedPromiseError(error)); - }); - }, abortHandler); - - }; - - const clamp = function(val, min, max) { - return Math.max(Math.min(val, max), min); - }; - - const getCurrentTime = function() { - return performance.now() / 1000; - }; - - const disposeAllMeshes = (object3D) => { - if (object3D.geometry) { - object3D.geometry.dispose(); - object3D.geometry = null; - } - if (object3D.material) { - object3D.material.dispose(); - object3D.material = null; - } - if (object3D.children) { - for (let child of object3D.children) { - disposeAllMeshes(child); - } - } - }; - - const delayedExecute = (func, fast) => { - return new Promise((resolve) => { - window.setTimeout(() => { - resolve(func ? func() : undefined); - }, fast ? 1 : 50); - }); - }; - - - const getSphericalHarmonicsComponentCountForDegree = (sphericalHarmonicsDegree = 0) => { - let shCoeffPerSplat = 0; - if (sphericalHarmonicsDegree === 1) { - shCoeffPerSplat = 9; - } else if (sphericalHarmonicsDegree === 2) { - shCoeffPerSplat = 24; - } else if (sphericalHarmonicsDegree === 3) { - shCoeffPerSplat = 45; - } else if (sphericalHarmonicsDegree > 3) { - throw new Error('getSphericalHarmonicsComponentCountForDegree() -> Invalid spherical harmonics degree'); - } - return shCoeffPerSplat; - }; - - const nativePromiseWithExtractedComponents = () => { - let resolver; - let rejecter; - const promise = new Promise((resolve, reject) => { - resolver = resolve; - rejecter = reject; - }); - return { - 'promise': promise, - 'resolve': resolver, - 'reject': rejecter - }; - }; - - const abortablePromiseWithExtractedComponents = (abortHandler) => { - let resolver; - let rejecter; - if (!abortHandler) { - abortHandler = () => {}; - } - const promise = new AbortablePromise((resolve, reject) => { - resolver = resolve; - rejecter = reject; - }, abortHandler); - return { - 'promise': promise, - 'resolve': resolver, - 'reject': rejecter - }; - }; - - class Semver { - constructor(major, minor, patch) { - this.major = major; - this.minor = minor; - this.patch = patch; - } - - toString() { - return `${this.major}_${this.minor}_${this.patch}`; - } - } - - function isIOS() { - const ua = navigator.userAgent; - return ua.indexOf('iPhone') > 0 || ua.indexOf('iPad') > 0; - } - - function getIOSSemever() { - if (isIOS()) { - const extract = navigator.userAgent.match(/OS (\d+)_(\d+)_?(\d+)?/); - return new Semver( - parseInt(extract[1] || 0, 10), - parseInt(extract[2] || 0, 10), - parseInt(extract[3] || 0, 10) - ); - } else { - return null; // or [0,0,0] - } - } - - const BASE_COMPONENT_COUNT = 14; - - class UncompressedSplatArray { - - static OFFSET = { - X: 0, - Y: 1, - Z: 2, - SCALE0: 3, - SCALE1: 4, - SCALE2: 5, - ROTATION0: 6, - ROTATION1: 7, - ROTATION2: 8, - ROTATION3: 9, - FDC0: 10, - FDC1: 11, - FDC2: 12, - OPACITY: 13, - FRC0: 14, - FRC1: 15, - FRC2: 16, - FRC3: 17, - FRC4: 18, - FRC5: 19, - FRC6: 20, - FRC7: 21, - FRC8: 22, - FRC9: 23, - FRC10: 24, - FRC11: 25, - FRC12: 26, - FRC13: 27, - FRC14: 28, - FRC15: 29, - FRC16: 30, - FRC17: 31, - FRC18: 32, - FRC19: 33, - FRC20: 34, - FRC21: 35, - FRC22: 36, - FRC23: 37 - }; - - constructor(sphericalHarmonicsDegree = 0) { - this.sphericalHarmonicsDegree = sphericalHarmonicsDegree; - this.sphericalHarmonicsCount = getSphericalHarmonicsComponentCountForDegree(this.sphericalHarmonicsDegree); - this.componentCount = this.sphericalHarmonicsCount + BASE_COMPONENT_COUNT; - this.defaultSphericalHarmonics = new Array(this.sphericalHarmonicsCount).fill(0); - this.splats = []; - this.splatCount = 0; - } - - static createSplat(sphericalHarmonicsDegree = 0) { - const baseSplat = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]; - let shEntries = getSphericalHarmonicsComponentCountForDegree(sphericalHarmonicsDegree); - for (let i = 0; i < shEntries; i++) baseSplat.push(0); - return baseSplat; - } - - addSplat(splat) { - this.splats.push(splat); - this.splatCount++; - } - - getSplat(index) { - return this.splats[index]; - } - - addDefaultSplat() { - const newSplat = UncompressedSplatArray.createSplat(this.sphericalHarmonicsDegree); - this.addSplat(newSplat); - return newSplat; - } - - addSplatFromComonents(x, y, z, scale0, scale1, scale2, rot0, rot1, rot2, rot3, r, g, b, opacity, ...rest) { - const newSplat = [x, y, z, scale0, scale1, scale2, rot0, rot1, rot2, rot3, r, g, b, opacity, ...this.defaultSphericalHarmonics]; - for (let i = 0; i < rest.length && i < this.sphericalHarmonicsCount; i++) { - newSplat[i] = rest[i]; - } - this.addSplat(newSplat); - return newSplat; - } - - addSplatFromArray(src, srcIndex) { - const srcSplat = src.splats[srcIndex]; - const newSplat = UncompressedSplatArray.createSplat(this.sphericalHarmonicsDegree); - for (let i = 0; i < this.componentCount && i < srcSplat.length; i++) { - newSplat[i] = srcSplat[i]; - } - this.addSplat(newSplat); - } - } - - class Constants { - - static DefaultSplatSortDistanceMapPrecision = 16; - static MemoryPageSize = 65536; - static BytesPerFloat = 4; - static BytesPerInt = 4; - static MaxScenes = 32; - static ProgressiveLoadSectionSize = 262144; - static ProgressiveLoadSectionDelayDuration = 15; - static SphericalHarmonics8BitCompressionRange = 3; - } - - const DefaultSphericalHarmonics8BitCompressionRange = Constants.SphericalHarmonics8BitCompressionRange; - const DefaultSphericalHarmonics8BitCompressionHalfRange = DefaultSphericalHarmonics8BitCompressionRange / 2.0; - - const toHalfFloat = THREE__namespace.DataUtils.toHalfFloat.bind(THREE__namespace.DataUtils); - const fromHalfFloat$1 = THREE__namespace.DataUtils.fromHalfFloat.bind(THREE__namespace.DataUtils); - - const toUncompressedFloat = (f, compressionLevel, isSH = false, range8BitMin, range8BitMax) => { - if (compressionLevel === 0) { - return f; - } else if (compressionLevel === 1 || compressionLevel === 2 && !isSH) { - return THREE__namespace.DataUtils.fromHalfFloat(f); - } else if (compressionLevel === 2) { - return fromUint8(f, range8BitMin, range8BitMax); - } - }; - - const toUint8 = (v, rangeMin, rangeMax) => { - v = clamp(v, rangeMin, rangeMax); - const range = (rangeMax - rangeMin); - return clamp(Math.floor((v - rangeMin) / range * 255), 0, 255); - }; - - const fromUint8 = (v, rangeMin, rangeMax) => { - const range = (rangeMax - rangeMin); - return (v / 255 * range + rangeMin); - }; - - const fromHalfFloatToUint8 = (v, rangeMin, rangeMax) => { - return toUint8(fromHalfFloat$1(v, rangeMin, rangeMax)); - }; - - const fromUint8ToHalfFloat = (v, rangeMin, rangeMax) => { - return toHalfFloat(fromUint8(v, rangeMin, rangeMax)); - }; - - const dataViewFloatForCompressionLevel = (dataView, floatIndex, compressionLevel, isSH = false) => { - if (compressionLevel === 0) { - return dataView.getFloat32(floatIndex * 4, true); - } else if (compressionLevel === 1 || compressionLevel === 2 && !isSH) { - return dataView.getUint16(floatIndex * 2, true); - } else { - return dataView.getUint8(floatIndex, true); - } - }; - - const convertBetweenCompressionLevels = function() { - - const noop = (v) => v; - - return function(val, fromLevel, toLevel, isSH = false) { - if (fromLevel === toLevel) return val; - let outputConversionFunc = noop; - - if (fromLevel === 2 && isSH) { - if (toLevel === 1) outputConversionFunc = fromUint8ToHalfFloat; - else if (toLevel == 0) { - outputConversionFunc = fromUint8; - } - } else if (fromLevel === 2 || fromLevel === 1) { - if (toLevel === 0) outputConversionFunc = fromHalfFloat$1; - else if (toLevel == 2) { - if (!isSH) outputConversionFunc = noop; - else outputConversionFunc = fromHalfFloatToUint8; - } - } else if (fromLevel === 0) { - if (toLevel === 1) outputConversionFunc = toHalfFloat; - else if (toLevel == 2) { - if (!isSH) outputConversionFunc = toHalfFloat; - else outputConversionFunc = toUint8; - } - } - - return outputConversionFunc(val); - }; - - }(); - - const copyBetweenBuffers = (srcBuffer, srcOffset, destBuffer, destOffset, byteCount = 0) => { - const src = new Uint8Array(srcBuffer, srcOffset); - const dest = new Uint8Array(destBuffer, destOffset); - for (let i = 0; i < byteCount; i++) { - dest[i] = src[i]; - } - }; - - /** - * SplatBuffer: Container for splat data from a single scene/file and capable of (mediocre) compression. - */ - class SplatBuffer { - - static CurrentMajorVersion = 0; - static CurrentMinorVersion = 1; - - static CenterComponentCount = 3; - static ScaleComponentCount = 3; - static RotationComponentCount = 4; - static ColorComponentCount = 4; - static CovarianceComponentCount = 6; - - static SplatScaleOffsetFloat = 3; - static SplatRotationOffsetFloat = 6; - - static CompressionLevels = { - 0: { - BytesPerCenter: 12, - BytesPerScale: 12, - BytesPerRotation: 16, - BytesPerColor: 4, - ScaleOffsetBytes: 12, - RotationffsetBytes: 24, - ColorOffsetBytes: 40, - SphericalHarmonicsOffsetBytes: 44, - ScaleRange: 1, - BytesPerSphericalHarmonicsComponent: 4, - SphericalHarmonicsOffsetFloat: 11, - SphericalHarmonicsDegrees: { - 0: { BytesPerSplat: 44 }, - 1: { BytesPerSplat: 80 }, - 2: { BytesPerSplat: 140 } - }, - }, - 1: { - BytesPerCenter: 6, - BytesPerScale: 6, - BytesPerRotation: 8, - BytesPerColor: 4, - ScaleOffsetBytes: 6, - RotationffsetBytes: 12, - ColorOffsetBytes: 20, - SphericalHarmonicsOffsetBytes: 24, - ScaleRange: 32767, - BytesPerSphericalHarmonicsComponent: 2, - SphericalHarmonicsOffsetFloat: 12, - SphericalHarmonicsDegrees: { - 0: { BytesPerSplat: 24 }, - 1: { BytesPerSplat: 42 }, - 2: { BytesPerSplat: 72 } - }, - }, - 2: { - BytesPerCenter: 6, - BytesPerScale: 6, - BytesPerRotation: 8, - BytesPerColor: 4, - ScaleOffsetBytes: 6, - RotationffsetBytes: 12, - ColorOffsetBytes: 20, - SphericalHarmonicsOffsetBytes: 24, - ScaleRange: 32767, - BytesPerSphericalHarmonicsComponent: 1, - SphericalHarmonicsOffsetFloat: 12, - SphericalHarmonicsDegrees: { - 0: { BytesPerSplat: 24 }, - 1: { BytesPerSplat: 33 }, - 2: { BytesPerSplat: 48 } - }, - } - }; - - static CovarianceSizeFloats = 6; - - static HeaderSizeBytes = 4096; - static SectionHeaderSizeBytes = 1024; - - static BucketStorageSizeBytes = 12; - static BucketStorageSizeFloats = 3; - - static BucketBlockSize = 5.0; - static BucketSize = 256; - - constructor(bufferData, secLoadedCountsToMax = true) { - this.constructFromBuffer(bufferData, secLoadedCountsToMax); - } - - getSplatCount() { - return this.splatCount; - } - - getMaxSplatCount() { - return this.maxSplatCount; - } - - getMinSphericalHarmonicsDegree() { - let minSphericalHarmonicsDegree = 0; - for (let i = 0; i < this.sections.length; i++) { - const section = this.sections[i]; - if (i === 0 || section.sphericalHarmonicsDegree < minSphericalHarmonicsDegree) { - minSphericalHarmonicsDegree = section.sphericalHarmonicsDegree; - } - } - return minSphericalHarmonicsDegree; - } - - getBucketIndex(section, localSplatIndex) { - let bucketIndex; - const maxSplatIndexInFullBuckets = section.fullBucketCount * section.bucketSize; - if (localSplatIndex < maxSplatIndexInFullBuckets) { - bucketIndex = Math.floor(localSplatIndex / section.bucketSize); - } else { - let bucketSplatIndex = maxSplatIndexInFullBuckets; - bucketIndex = section.fullBucketCount; - let partiallyFullBucketIndex = 0; - while (bucketSplatIndex < section.splatCount) { - let currentPartiallyFilledBucketSize = section.partiallyFilledBucketLengths[partiallyFullBucketIndex]; - if (localSplatIndex >= bucketSplatIndex && localSplatIndex < bucketSplatIndex + currentPartiallyFilledBucketSize) { - break; - } - bucketSplatIndex += currentPartiallyFilledBucketSize; - bucketIndex++; - partiallyFullBucketIndex++; - } - } - return bucketIndex; - } - - getSplatCenter(globalSplatIndex, outCenter, transform) { - const sectionIndex = this.globalSplatIndexToSectionMap[globalSplatIndex]; - const section = this.sections[sectionIndex]; - const localSplatIndex = globalSplatIndex - section.splatCountOffset; - - const srcSplatCentersBase = section.bytesPerSplat * localSplatIndex; - const dataView = new DataView(this.bufferData, section.dataBase + srcSplatCentersBase); - - const x = dataViewFloatForCompressionLevel(dataView, 0, this.compressionLevel); - const y = dataViewFloatForCompressionLevel(dataView, 1, this.compressionLevel); - const z = dataViewFloatForCompressionLevel(dataView, 2, this.compressionLevel); - if (this.compressionLevel >= 1) { - const bucketIndex = this.getBucketIndex(section, localSplatIndex); - const bucketBase = bucketIndex * SplatBuffer.BucketStorageSizeFloats; - const sf = section.compressionScaleFactor; - const sr = section.compressionScaleRange; - outCenter.x = (x - sr) * sf + section.bucketArray[bucketBase]; - outCenter.y = (y - sr) * sf + section.bucketArray[bucketBase + 1]; - outCenter.z = (z - sr) * sf + section.bucketArray[bucketBase + 2]; - } else { - outCenter.x = x; - outCenter.y = y; - outCenter.z = z; - } - if (transform) outCenter.applyMatrix4(transform); - } - - getSplatScaleAndRotation = function() { - - const scaleMatrix = new THREE__namespace.Matrix4(); - const rotationMatrix = new THREE__namespace.Matrix4(); - const tempMatrix = new THREE__namespace.Matrix4(); - const tempPosition = new THREE__namespace.Vector3(); - const scale = new THREE__namespace.Vector3(); - const rotation = new THREE__namespace.Quaternion(); - - return function(index, outScale, outRotation, transform, scaleOverride) { - const sectionIndex = this.globalSplatIndexToSectionMap[index]; - const section = this.sections[sectionIndex]; - const localSplatIndex = index - section.splatCountOffset; - - const srcSplatScalesBase = section.bytesPerSplat * localSplatIndex + - SplatBuffer.CompressionLevels[this.compressionLevel].ScaleOffsetBytes; - - const dataView = new DataView(this.bufferData, section.dataBase + srcSplatScalesBase); - - scale.set(toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 0, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 1, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 2, this.compressionLevel), this.compressionLevel)); - if (scaleOverride) { - if (scaleOverride.x !== undefined) scale.x = scaleOverride.x; - if (scaleOverride.y !== undefined) scale.y = scaleOverride.y; - if (scaleOverride.z !== undefined) scale.z = scaleOverride.z; - } - - rotation.set(toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 4, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 5, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 6, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 3, this.compressionLevel), this.compressionLevel)); - - if (transform) { - scaleMatrix.makeScale(scale.x, scale.y, scale.z); - rotationMatrix.makeRotationFromQuaternion(rotation); - tempMatrix.copy(scaleMatrix).multiply(rotationMatrix).multiply(transform); - tempMatrix.decompose(tempPosition, outRotation, outScale); - } else { - outScale.copy(scale); - outRotation.copy(rotation); - } - }; - - }(); - - getSplatColor(globalSplatIndex, outColor) { - const sectionIndex = this.globalSplatIndexToSectionMap[globalSplatIndex]; - const section = this.sections[sectionIndex]; - const localSplatIndex = globalSplatIndex - section.splatCountOffset; - - const srcSplatColorsBase = section.bytesPerSplat * localSplatIndex + - SplatBuffer.CompressionLevels[this.compressionLevel].ColorOffsetBytes; - const splatColorsArray = new Uint8Array(this.bufferData, section.dataBase + srcSplatColorsBase, 4); - - outColor.set(splatColorsArray[0], splatColorsArray[1], - splatColorsArray[2], splatColorsArray[3]); - } - - fillSplatCenterArray(outCenterArray, transform, srcFrom, srcTo, destFrom) { - const splatCount = this.splatCount; - - srcFrom = srcFrom || 0; - srcTo = srcTo || splatCount - 1; - if (destFrom === undefined) destFrom = srcFrom; - - const center = new THREE__namespace.Vector3(); - for (let i = srcFrom; i <= srcTo; i++) { - const sectionIndex = this.globalSplatIndexToSectionMap[i]; - const section = this.sections[sectionIndex]; - const localSplatIndex = i - section.splatCountOffset; - const centerDestBase = (i - srcFrom + destFrom) * SplatBuffer.CenterComponentCount; - - const srcSplatCentersBase = section.bytesPerSplat * localSplatIndex; - const dataView = new DataView(this.bufferData, section.dataBase + srcSplatCentersBase); - - const x = dataViewFloatForCompressionLevel(dataView, 0, this.compressionLevel); - const y = dataViewFloatForCompressionLevel(dataView, 1, this.compressionLevel); - const z = dataViewFloatForCompressionLevel(dataView, 2, this.compressionLevel); - if (this.compressionLevel >= 1) { - const bucketIndex = this.getBucketIndex(section, localSplatIndex); - const bucketBase = bucketIndex * SplatBuffer.BucketStorageSizeFloats; - const sf = section.compressionScaleFactor; - const sr = section.compressionScaleRange; - center.x = (x - sr) * sf + section.bucketArray[bucketBase]; - center.y = (y - sr) * sf + section.bucketArray[bucketBase + 1]; - center.z = (z - sr) * sf + section.bucketArray[bucketBase + 2]; - } else { - center.x = x; - center.y = y; - center.z = z; - } - if (transform) { - center.applyMatrix4(transform); - } - outCenterArray[centerDestBase] = center.x; - outCenterArray[centerDestBase + 1] = center.y; - outCenterArray[centerDestBase + 2] = center.z; - } - } - - fillSplatScaleRotationArray = function() { - - const scaleMatrix = new THREE__namespace.Matrix4(); - const rotationMatrix = new THREE__namespace.Matrix4(); - const tempMatrix = new THREE__namespace.Matrix4(); - const scale = new THREE__namespace.Vector3(); - const rotation = new THREE__namespace.Quaternion(); - const tempPosition = new THREE__namespace.Vector3(); - - const ensurePositiveW = (quaternion) => { - const flip = quaternion.w < 0 ? -1 : 1; - quaternion.x *= flip; - quaternion.y *= flip; - quaternion.z *= flip; - quaternion.w *= flip; - }; - - return function(outScaleArray, outRotationArray, transform, srcFrom, srcTo, destFrom, - desiredOutputCompressionLevel, scaleOverride) { - const splatCount = this.splatCount; - - srcFrom = srcFrom || 0; - srcTo = srcTo || splatCount - 1; - if (destFrom === undefined) destFrom = srcFrom; - - const outputConversion = (value, srcCompressionLevel) => { - if (srcCompressionLevel === undefined) srcCompressionLevel = this.compressionLevel; - return convertBetweenCompressionLevels(value, srcCompressionLevel, desiredOutputCompressionLevel); - }; - - for (let i = srcFrom; i <= srcTo; i++) { - const sectionIndex = this.globalSplatIndexToSectionMap[i]; - const section = this.sections[sectionIndex]; - const localSplatIndex = i - section.splatCountOffset; - - const srcSplatScalesBase = section.bytesPerSplat * localSplatIndex + - SplatBuffer.CompressionLevels[this.compressionLevel].ScaleOffsetBytes; - - const scaleDestBase = (i - srcFrom + destFrom) * SplatBuffer.ScaleComponentCount; - const rotationDestBase = (i - srcFrom + destFrom) * SplatBuffer.RotationComponentCount; - const dataView = new DataView(this.bufferData, section.dataBase + srcSplatScalesBase); - - const srcScaleX = (scaleOverride && scaleOverride.x !== undefined) ? scaleOverride.x : - dataViewFloatForCompressionLevel(dataView, 0, this.compressionLevel); - const srcScaleY = (scaleOverride && scaleOverride.y !== undefined) ? scaleOverride.y : - dataViewFloatForCompressionLevel(dataView, 1, this.compressionLevel); - const srcScaleZ = (scaleOverride && scaleOverride.z !== undefined) ? scaleOverride.z : - dataViewFloatForCompressionLevel(dataView, 2, this.compressionLevel); - - const srcRotationW = dataViewFloatForCompressionLevel(dataView, 3, this.compressionLevel); - const srcRotationX = dataViewFloatForCompressionLevel(dataView, 4, this.compressionLevel); - const srcRotationY = dataViewFloatForCompressionLevel(dataView, 5, this.compressionLevel); - const srcRotationZ = dataViewFloatForCompressionLevel(dataView, 6, this.compressionLevel); - - scale.set(toUncompressedFloat(srcScaleX, this.compressionLevel), - toUncompressedFloat(srcScaleY, this.compressionLevel), - toUncompressedFloat(srcScaleZ, this.compressionLevel)); - - rotation.set(toUncompressedFloat(srcRotationX, this.compressionLevel), - toUncompressedFloat(srcRotationY, this.compressionLevel), - toUncompressedFloat(srcRotationZ, this.compressionLevel), - toUncompressedFloat(srcRotationW, this.compressionLevel)).normalize(); - - if (transform) { - tempPosition.set(0, 0, 0); - scaleMatrix.makeScale(scale.x, scale.y, scale.z); - rotationMatrix.makeRotationFromQuaternion(rotation); - tempMatrix.identity().premultiply(scaleMatrix).premultiply(rotationMatrix); - tempMatrix.premultiply(transform); - tempMatrix.decompose(tempPosition, rotation, scale); - rotation.normalize(); - } - - ensurePositiveW(rotation); - - if (outScaleArray) { - outScaleArray[scaleDestBase] = outputConversion(scale.x, 0); - outScaleArray[scaleDestBase + 1] = outputConversion(scale.y, 0); - outScaleArray[scaleDestBase + 2] = outputConversion(scale.z, 0); - } - - if (outRotationArray) { - outRotationArray[rotationDestBase] = outputConversion(rotation.x, 0); - outRotationArray[rotationDestBase + 1] = outputConversion(rotation.y, 0); - outRotationArray[rotationDestBase + 2] = outputConversion(rotation.z, 0); - outRotationArray[rotationDestBase + 3] = outputConversion(rotation.w, 0); - } - } - }; - }(); - - static computeCovariance = function() { - - const tempMatrix4 = new THREE__namespace.Matrix4(); - const scaleMatrix = new THREE__namespace.Matrix3(); - const rotationMatrix = new THREE__namespace.Matrix3(); - const covarianceMatrix = new THREE__namespace.Matrix3(); - const transformedCovariance = new THREE__namespace.Matrix3(); - const transform3x3 = new THREE__namespace.Matrix3(); - const transform3x3Transpose = new THREE__namespace.Matrix3(); - - return function(scale, rotation, transform, outCovariance, outOffset = 0, desiredOutputCompressionLevel) { - - tempMatrix4.makeScale(scale.x, scale.y, scale.z); - scaleMatrix.setFromMatrix4(tempMatrix4); - - tempMatrix4.makeRotationFromQuaternion(rotation); - rotationMatrix.setFromMatrix4(tempMatrix4); - - covarianceMatrix.copy(rotationMatrix).multiply(scaleMatrix); - transformedCovariance.copy(covarianceMatrix).transpose().premultiply(covarianceMatrix); - - if (transform) { - transform3x3.setFromMatrix4(transform); - transform3x3Transpose.copy(transform3x3).transpose(); - transformedCovariance.multiply(transform3x3Transpose); - transformedCovariance.premultiply(transform3x3); - } - - if (desiredOutputCompressionLevel >= 1) { - outCovariance[outOffset] = toHalfFloat(transformedCovariance.elements[0]); - outCovariance[outOffset + 1] = toHalfFloat(transformedCovariance.elements[3]); - outCovariance[outOffset + 2] = toHalfFloat(transformedCovariance.elements[6]); - outCovariance[outOffset + 3] = toHalfFloat(transformedCovariance.elements[4]); - outCovariance[outOffset + 4] = toHalfFloat(transformedCovariance.elements[7]); - outCovariance[outOffset + 5] = toHalfFloat(transformedCovariance.elements[8]); - } else { - outCovariance[outOffset] = transformedCovariance.elements[0]; - outCovariance[outOffset + 1] = transformedCovariance.elements[3]; - outCovariance[outOffset + 2] = transformedCovariance.elements[6]; - outCovariance[outOffset + 3] = transformedCovariance.elements[4]; - outCovariance[outOffset + 4] = transformedCovariance.elements[7]; - outCovariance[outOffset + 5] = transformedCovariance.elements[8]; - } - - }; - - }(); - - fillSplatCovarianceArray(covarianceArray, transform, srcFrom, srcTo, destFrom, desiredOutputCompressionLevel) { - const splatCount = this.splatCount; - - const scale = new THREE__namespace.Vector3(); - const rotation = new THREE__namespace.Quaternion(); - - srcFrom = srcFrom || 0; - srcTo = srcTo || splatCount - 1; - if (destFrom === undefined) destFrom = srcFrom; - - for (let i = srcFrom; i <= srcTo; i++) { - const sectionIndex = this.globalSplatIndexToSectionMap[i]; - const section = this.sections[sectionIndex]; - const localSplatIndex = i - section.splatCountOffset; - - const covarianceDestBase = (i - srcFrom + destFrom) * SplatBuffer.CovarianceComponentCount; - const srcSplatScalesBase = section.bytesPerSplat * localSplatIndex + - SplatBuffer.CompressionLevels[this.compressionLevel].ScaleOffsetBytes; - - const dataView = new DataView(this.bufferData, section.dataBase + srcSplatScalesBase); - - scale.set(toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 0, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 1, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 2, this.compressionLevel), this.compressionLevel)); - - rotation.set(toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 4, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 5, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 6, this.compressionLevel), this.compressionLevel), - toUncompressedFloat(dataViewFloatForCompressionLevel(dataView, 3, this.compressionLevel), this.compressionLevel)); - - SplatBuffer.computeCovariance(scale, rotation, transform, covarianceArray, covarianceDestBase, desiredOutputCompressionLevel); - } - } - - fillSplatColorArray(outColorArray, minimumAlpha, srcFrom, srcTo, destFrom) { - const splatCount = this.splatCount; - - srcFrom = srcFrom || 0; - srcTo = srcTo || splatCount - 1; - if (destFrom === undefined) destFrom = srcFrom; - - for (let i = srcFrom; i <= srcTo; i++) { - - const sectionIndex = this.globalSplatIndexToSectionMap[i]; - const section = this.sections[sectionIndex]; - const localSplatIndex = i - section.splatCountOffset; - - const colorDestBase = (i - srcFrom + destFrom) * SplatBuffer.ColorComponentCount; - const srcSplatColorsBase = section.bytesPerSplat * localSplatIndex + - SplatBuffer.CompressionLevels[this.compressionLevel].ColorOffsetBytes; - - const dataView = new Uint8Array(this.bufferData, section.dataBase + srcSplatColorsBase); - - let alpha = dataView[3]; - alpha = (alpha >= minimumAlpha) ? alpha : 0; - - outColorArray[colorDestBase] = dataView[0]; - outColorArray[colorDestBase + 1] = dataView[1]; - outColorArray[colorDestBase + 2] = dataView[2]; - outColorArray[colorDestBase + 3] = alpha; - } - } - - fillSphericalHarmonicsArray = function() { - - const sphericalHarmonicVectors = []; - for (let i = 0; i < 15; i++) { - sphericalHarmonicVectors[i] = new THREE__namespace.Vector3(); - } - - const tempMatrix3 = new THREE__namespace.Matrix3(); - const tempMatrix4 = new THREE__namespace.Matrix4(); - - const tempTranslation = new THREE__namespace.Vector3(); - const tempScale = new THREE__namespace.Vector3(); - const tempRotation = new THREE__namespace.Quaternion(); - - const sh11 = []; - const sh12 = []; - const sh13 = []; - - const sh21 = []; - const sh22 = []; - const sh23 = []; - const sh24 = []; - const sh25 = []; - - const shIn1 = []; - const shIn2 = []; - const shIn3 = []; - const shIn4 = []; - const shIn5 = []; - - const shOut1 = []; - const shOut2 = []; - const shOut3 = []; - const shOut4 = []; - const shOut5 = []; - - const noop = (v) => v; - - const set3 = (array, val1, val2, val3) => { - array[0] = val1; - array[1] = val2; - array[2] = val3; - }; - - const set3FromArray = (array, srcDestView, stride, srcBase, compressionLevel) => { - array[0] = dataViewFloatForCompressionLevel(srcDestView, srcBase, compressionLevel, true); - array[1] = dataViewFloatForCompressionLevel(srcDestView, srcBase + stride, compressionLevel, true); - array[2] = dataViewFloatForCompressionLevel(srcDestView, srcBase + stride + stride, compressionLevel, true); - }; - - const copy3 = (srcArray, destArray) => { - destArray[0] = srcArray[0]; - destArray[1] = srcArray[1]; - destArray[2] = srcArray[2]; - }; - - const setOutput3 = (srcArray, destArray, destBase, conversionFunc) => { - destArray[destBase] = conversionFunc(srcArray[0]); - destArray[destBase + 1] = conversionFunc(srcArray[1]); - destArray[destBase + 2] = conversionFunc(srcArray[2]); - }; - - const toUncompressedFloatArray3 = (src, dest, compressionLevel, range8BitMin, range8BitMax) => { - dest[0] = toUncompressedFloat(src[0], compressionLevel, true, range8BitMin, range8BitMax); - dest[1] = toUncompressedFloat(src[1], compressionLevel, true, range8BitMin, range8BitMax); - dest[2] = toUncompressedFloat(src[2], compressionLevel, true, range8BitMin, range8BitMax); - return dest; - }; - - return function(outSphericalHarmonicsArray, outSphericalHarmonicsDegree, transform, - srcFrom, srcTo, destFrom, desiredOutputCompressionLevel) { - const splatCount = this.splatCount; - - srcFrom = srcFrom || 0; - srcTo = srcTo || splatCount - 1; - if (destFrom === undefined) destFrom = srcFrom; - - if (transform && outSphericalHarmonicsDegree >= 1) { - tempMatrix4.copy(transform); - tempMatrix4.decompose(tempTranslation, tempRotation, tempScale); - tempRotation.normalize(); - tempMatrix4.makeRotationFromQuaternion(tempRotation); - tempMatrix3.setFromMatrix4(tempMatrix4); - set3(sh11, tempMatrix3.elements[4], -tempMatrix3.elements[7], tempMatrix3.elements[1]); - set3(sh12, -tempMatrix3.elements[5], tempMatrix3.elements[8], -tempMatrix3.elements[2]); - set3(sh13, tempMatrix3.elements[3], -tempMatrix3.elements[6], tempMatrix3.elements[0]); - } - - const localFromHalfFloatToUint8 = (v) => { - return fromHalfFloatToUint8(v, this.minSphericalHarmonicsCoeff, this.maxSphericalHarmonicsCoeff); - }; - - const localToUint8 = (v) => { - return toUint8(v, this.minSphericalHarmonicsCoeff, this.maxSphericalHarmonicsCoeff); - }; - - for (let i = srcFrom; i <= srcTo; i++) { - - const sectionIndex = this.globalSplatIndexToSectionMap[i]; - const section = this.sections[sectionIndex]; - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, section.sphericalHarmonicsDegree); - const outSphericalHarmonicsComponentsCount = getSphericalHarmonicsComponentCountForDegree(outSphericalHarmonicsDegree); - - const localSplatIndex = i - section.splatCountOffset; - - const srcSplatSHBase = section.bytesPerSplat * localSplatIndex + - SplatBuffer.CompressionLevels[this.compressionLevel].SphericalHarmonicsOffsetBytes; - - const dataView = new DataView(this.bufferData, section.dataBase + srcSplatSHBase); - - const shDestBase = (i - srcFrom + destFrom) * outSphericalHarmonicsComponentsCount; - - let compressionLevelForOutputConversion = transform ? 0 : this.compressionLevel; - let outputConversionFunc = noop; - if (compressionLevelForOutputConversion !== desiredOutputCompressionLevel) { - if (compressionLevelForOutputConversion === 1) { - if (desiredOutputCompressionLevel === 0) outputConversionFunc = fromHalfFloat$1; - else if (desiredOutputCompressionLevel == 2) outputConversionFunc = localFromHalfFloatToUint8; - } else if (compressionLevelForOutputConversion === 0) { - if (desiredOutputCompressionLevel === 1) outputConversionFunc = toHalfFloat; - else if (desiredOutputCompressionLevel == 2) outputConversionFunc = localToUint8; - } - } - - const minShCoeff = this.minSphericalHarmonicsCoeff; - const maxShCoeff = this.maxSphericalHarmonicsCoeff; - - if (outSphericalHarmonicsDegree >= 1) { - - set3FromArray(shIn1, dataView, 3, 0, this.compressionLevel); - set3FromArray(shIn2, dataView, 3, 1, this.compressionLevel); - set3FromArray(shIn3, dataView, 3, 2, this.compressionLevel); - - if (transform) { - toUncompressedFloatArray3(shIn1, shIn1, this.compressionLevel, minShCoeff, maxShCoeff); - toUncompressedFloatArray3(shIn2, shIn2, this.compressionLevel, minShCoeff, maxShCoeff); - toUncompressedFloatArray3(shIn3, shIn3, this.compressionLevel, minShCoeff, maxShCoeff); - SplatBuffer.rotateSphericalHarmonics3(shIn1, shIn2, shIn3, sh11, sh12, sh13, shOut1, shOut2, shOut3); - } else { - copy3(shIn1, shOut1); - copy3(shIn2, shOut2); - copy3(shIn3, shOut3); - } - - setOutput3(shOut1, outSphericalHarmonicsArray, shDestBase, outputConversionFunc); - setOutput3(shOut2, outSphericalHarmonicsArray, shDestBase + 3, outputConversionFunc); - setOutput3(shOut3, outSphericalHarmonicsArray, shDestBase + 6, outputConversionFunc); - - if (outSphericalHarmonicsDegree >= 2) { - - set3FromArray(shIn1, dataView, 5, 9, this.compressionLevel); - set3FromArray(shIn2, dataView, 5, 10, this.compressionLevel); - set3FromArray(shIn3, dataView, 5, 11, this.compressionLevel); - set3FromArray(shIn4, dataView, 5, 12, this.compressionLevel); - set3FromArray(shIn5, dataView, 5, 13, this.compressionLevel); - - if (transform) { - toUncompressedFloatArray3(shIn1, shIn1, this.compressionLevel, minShCoeff, maxShCoeff); - toUncompressedFloatArray3(shIn2, shIn2, this.compressionLevel, minShCoeff, maxShCoeff); - toUncompressedFloatArray3(shIn3, shIn3, this.compressionLevel, minShCoeff, maxShCoeff); - toUncompressedFloatArray3(shIn4, shIn4, this.compressionLevel, minShCoeff, maxShCoeff); - toUncompressedFloatArray3(shIn5, shIn5, this.compressionLevel, minShCoeff, maxShCoeff); - SplatBuffer.rotateSphericalHarmonics5(shIn1, shIn2, shIn3, shIn4, shIn5, - sh11, sh12, sh13, sh21, sh22, sh23, sh24, sh25, - shOut1, shOut2, shOut3, shOut4, shOut5); - } else { - copy3(shIn1, shOut1); - copy3(shIn2, shOut2); - copy3(shIn3, shOut3); - copy3(shIn4, shOut4); - copy3(shIn5, shOut5); - } - - setOutput3(shOut1, outSphericalHarmonicsArray, shDestBase + 9, outputConversionFunc); - setOutput3(shOut2, outSphericalHarmonicsArray, shDestBase + 12, outputConversionFunc); - setOutput3(shOut3, outSphericalHarmonicsArray, shDestBase + 15, outputConversionFunc); - setOutput3(shOut4, outSphericalHarmonicsArray, shDestBase + 18, outputConversionFunc); - setOutput3(shOut5, outSphericalHarmonicsArray, shDestBase + 21, outputConversionFunc); - } - } - } - }; - - }(); - - static dot3 = (v1, v2, v3, transformRow, outArray) => { - outArray[0] = outArray[1] = outArray[2] = 0; - const t0 = transformRow[0]; - const t1 = transformRow[1]; - const t2 = transformRow[2]; - SplatBuffer.addInto3(v1[0] * t0, v1[1] * t0, v1[2] * t0, outArray); - SplatBuffer.addInto3(v2[0] * t1, v2[1] * t1, v2[2] * t1, outArray); - SplatBuffer.addInto3(v3[0] * t2, v3[1] * t2, v3[2] * t2, outArray); - }; - - static addInto3 = (val1, val2, val3, destArray) => { - destArray[0] = destArray[0] + val1; - destArray[1] = destArray[1] + val2; - destArray[2] = destArray[2] + val3; - }; - - static dot5 = (v1, v2, v3, v4, v5, transformRow, outArray) => { - outArray[0] = outArray[1] = outArray[2] = 0; - const t0 = transformRow[0]; - const t1 = transformRow[1]; - const t2 = transformRow[2]; - const t3 = transformRow[3]; - const t4 = transformRow[4]; - SplatBuffer.addInto3(v1[0] * t0, v1[1] * t0, v1[2] * t0, outArray); - SplatBuffer.addInto3(v2[0] * t1, v2[1] * t1, v2[2] * t1, outArray); - SplatBuffer.addInto3(v3[0] * t2, v3[1] * t2, v3[2] * t2, outArray); - SplatBuffer.addInto3(v4[0] * t3, v4[1] * t3, v4[2] * t3, outArray); - SplatBuffer.addInto3(v5[0] * t4, v5[1] * t4, v5[2] * t4, outArray); - }; - - static rotateSphericalHarmonics3 = (in1, in2, in3, tsh11, tsh12, tsh13, out1, out2, out3) => { - SplatBuffer.dot3(in1, in2, in3, tsh11, out1); - SplatBuffer.dot3(in1, in2, in3, tsh12, out2); - SplatBuffer.dot3(in1, in2, in3, tsh13, out3); - }; - - static rotateSphericalHarmonics5 = (in1, in2, in3, in4, in5, tsh11, tsh12, tsh13, - tsh21, tsh22, tsh23, tsh24, tsh25, out1, out2, out3, out4, out5) => { - - const kSqrt0104 = Math.sqrt(1.0 / 4.0); - const kSqrt0304 = Math.sqrt(3.0 / 4.0); - const kSqrt0103 = Math.sqrt(1.0 / 3.0); - const kSqrt0403 = Math.sqrt(4.0 / 3.0); - const kSqrt0112 = Math.sqrt(1.0 / 12.0); - - tsh21[0] = kSqrt0104 * ((tsh13[2] * tsh11[0] + tsh13[0] * tsh11[2]) + (tsh11[2] * tsh13[0] + tsh11[0] * tsh13[2])); - tsh21[1] = (tsh13[1] * tsh11[0] + tsh11[1] * tsh13[0]); - tsh21[2] = kSqrt0304 * (tsh13[1] * tsh11[1] + tsh11[1] * tsh13[1]); - tsh21[3] = (tsh13[1] * tsh11[2] + tsh11[1] * tsh13[2]); - tsh21[4] = kSqrt0104 * ((tsh13[2] * tsh11[2] - tsh13[0] * tsh11[0]) + (tsh11[2] * tsh13[2] - tsh11[0] * tsh13[0])); - SplatBuffer.dot5(in1, in2, in3, in4, in5, tsh21, out1); - - tsh22[0] = kSqrt0104 * ((tsh12[2] * tsh11[0] + tsh12[0] * tsh11[2]) + (tsh11[2] * tsh12[0] + tsh11[0] * tsh12[2])); - tsh22[1] = tsh12[1] * tsh11[0] + tsh11[1] * tsh12[0]; - tsh22[2] = kSqrt0304 * (tsh12[1] * tsh11[1] + tsh11[1] * tsh12[1]); - tsh22[3] = tsh12[1] * tsh11[2] + tsh11[1] * tsh12[2]; - tsh22[4] = kSqrt0104 * ((tsh12[2] * tsh11[2] - tsh12[0] * tsh11[0]) + (tsh11[2] * tsh12[2] - tsh11[0] * tsh12[0])); - SplatBuffer.dot5(in1, in2, in3, in4, in5, tsh22, out2); - - tsh23[0] = kSqrt0103 * (tsh12[2] * tsh12[0] + tsh12[0] * tsh12[2]) + -kSqrt0112 * - ((tsh13[2] * tsh13[0] + tsh13[0] * tsh13[2]) + (tsh11[2] * tsh11[0] + tsh11[0] * tsh11[2])); - tsh23[1] = kSqrt0403 * tsh12[1] * tsh12[0] + -kSqrt0103 * (tsh13[1] * tsh13[0] + tsh11[1] * tsh11[0]); - tsh23[2] = tsh12[1] * tsh12[1] + -kSqrt0104 * (tsh13[1] * tsh13[1] + tsh11[1] * tsh11[1]); - tsh23[3] = kSqrt0403 * tsh12[1] * tsh12[2] + -kSqrt0103 * (tsh13[1] * tsh13[2] + tsh11[1] * tsh11[2]); - tsh23[4] = kSqrt0103 * (tsh12[2] * tsh12[2] - tsh12[0] * tsh12[0]) + -kSqrt0112 * - ((tsh13[2] * tsh13[2] - tsh13[0] * tsh13[0]) + (tsh11[2] * tsh11[2] - tsh11[0] * tsh11[0])); - SplatBuffer.dot5(in1, in2, in3, in4, in5, tsh23, out3); - - tsh24[0] = kSqrt0104 * ((tsh12[2] * tsh13[0] + tsh12[0] * tsh13[2]) + (tsh13[2] * tsh12[0] + tsh13[0] * tsh12[2])); - tsh24[1] = tsh12[1] * tsh13[0] + tsh13[1] * tsh12[0]; - tsh24[2] = kSqrt0304 * (tsh12[1] * tsh13[1] + tsh13[1] * tsh12[1]); - tsh24[3] = tsh12[1] * tsh13[2] + tsh13[1] * tsh12[2]; - tsh24[4] = kSqrt0104 * ((tsh12[2] * tsh13[2] - tsh12[0] * tsh13[0]) + (tsh13[2] * tsh12[2] - tsh13[0] * tsh12[0])); - SplatBuffer.dot5(in1, in2, in3, in4, in5, tsh24, out4); - - tsh25[0] = kSqrt0104 * ((tsh13[2] * tsh13[0] + tsh13[0] * tsh13[2]) - (tsh11[2] * tsh11[0] + tsh11[0] * tsh11[2])); - tsh25[1] = (tsh13[1] * tsh13[0] - tsh11[1] * tsh11[0]); - tsh25[2] = kSqrt0304 * (tsh13[1] * tsh13[1] - tsh11[1] * tsh11[1]); - tsh25[3] = (tsh13[1] * tsh13[2] - tsh11[1] * tsh11[2]); - tsh25[4] = kSqrt0104 * ((tsh13[2] * tsh13[2] - tsh13[0] * tsh13[0]) - (tsh11[2] * tsh11[2] - tsh11[0] * tsh11[0])); - SplatBuffer.dot5(in1, in2, in3, in4, in5, tsh25, out5); - }; - - static parseHeader(buffer) { - const headerArrayUint8 = new Uint8Array(buffer, 0, SplatBuffer.HeaderSizeBytes); - const headerArrayUint16 = new Uint16Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 2); - const headerArrayUint32 = new Uint32Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 4); - const headerArrayFloat32 = new Float32Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 4); - const versionMajor = headerArrayUint8[0]; - const versionMinor = headerArrayUint8[1]; - const maxSectionCount = headerArrayUint32[1]; - const sectionCount = headerArrayUint32[2]; - const maxSplatCount = headerArrayUint32[3]; - const splatCount = headerArrayUint32[4]; - const compressionLevel = headerArrayUint16[10]; - const sceneCenter = new THREE__namespace.Vector3(headerArrayFloat32[6], headerArrayFloat32[7], headerArrayFloat32[8]); - - const minSphericalHarmonicsCoeff = headerArrayFloat32[9] || -DefaultSphericalHarmonics8BitCompressionHalfRange; - const maxSphericalHarmonicsCoeff = headerArrayFloat32[10] || DefaultSphericalHarmonics8BitCompressionHalfRange; - - return { - versionMajor, - versionMinor, - maxSectionCount, - sectionCount, - maxSplatCount, - splatCount, - compressionLevel, - sceneCenter, - minSphericalHarmonicsCoeff, - maxSphericalHarmonicsCoeff - }; - } - - static writeHeaderCountsToBuffer(sectionCount, splatCount, buffer) { - const headerArrayUint32 = new Uint32Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 4); - headerArrayUint32[2] = sectionCount; - headerArrayUint32[4] = splatCount; - } - - static writeHeaderToBuffer(header, buffer) { - const headerArrayUint8 = new Uint8Array(buffer, 0, SplatBuffer.HeaderSizeBytes); - const headerArrayUint16 = new Uint16Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 2); - const headerArrayUint32 = new Uint32Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 4); - const headerArrayFloat32 = new Float32Array(buffer, 0, SplatBuffer.HeaderSizeBytes / 4); - headerArrayUint8[0] = header.versionMajor; - headerArrayUint8[1] = header.versionMinor; - headerArrayUint8[2] = 0; // unused for now - headerArrayUint8[3] = 0; // unused for now - headerArrayUint32[1] = header.maxSectionCount; - headerArrayUint32[2] = header.sectionCount; - headerArrayUint32[3] = header.maxSplatCount; - headerArrayUint32[4] = header.splatCount; - headerArrayUint16[10] = header.compressionLevel; - headerArrayFloat32[6] = header.sceneCenter.x; - headerArrayFloat32[7] = header.sceneCenter.y; - headerArrayFloat32[8] = header.sceneCenter.z; - headerArrayFloat32[9] = header.minSphericalHarmonicsCoeff || -DefaultSphericalHarmonics8BitCompressionHalfRange; - headerArrayFloat32[10] = header.maxSphericalHarmonicsCoeff || DefaultSphericalHarmonics8BitCompressionHalfRange; - } - - static parseSectionHeaders(header, buffer, offset = 0, secLoadedCountsToMax) { - const compressionLevel = header.compressionLevel; - - const maxSectionCount = header.maxSectionCount; - const sectionHeaderArrayUint16 = new Uint16Array(buffer, offset, maxSectionCount * SplatBuffer.SectionHeaderSizeBytes / 2); - const sectionHeaderArrayUint32 = new Uint32Array(buffer, offset, maxSectionCount * SplatBuffer.SectionHeaderSizeBytes / 4); - const sectionHeaderArrayFloat32 = new Float32Array(buffer, offset, maxSectionCount * SplatBuffer.SectionHeaderSizeBytes / 4); - - const sectionHeaders = []; - let sectionHeaderBase = 0; - let sectionHeaderBaseUint16 = sectionHeaderBase / 2; - let sectionHeaderBaseUint32 = sectionHeaderBase / 4; - let sectionBase = SplatBuffer.HeaderSizeBytes + header.maxSectionCount * SplatBuffer.SectionHeaderSizeBytes; - let splatCountOffset = 0; - for (let i = 0; i < maxSectionCount; i++) { - const maxSplatCount = sectionHeaderArrayUint32[sectionHeaderBaseUint32 + 1]; - const bucketSize = sectionHeaderArrayUint32[sectionHeaderBaseUint32 + 2]; - const bucketCount = sectionHeaderArrayUint32[sectionHeaderBaseUint32 + 3]; - const bucketBlockSize = sectionHeaderArrayFloat32[sectionHeaderBaseUint32 + 4]; - const halfBucketBlockSize = bucketBlockSize / 2.0; - const bucketStorageSizeBytes = sectionHeaderArrayUint16[sectionHeaderBaseUint16 + 10]; - const compressionScaleRange = sectionHeaderArrayUint32[sectionHeaderBaseUint32 + 6] || - SplatBuffer.CompressionLevels[compressionLevel].ScaleRange; - const fullBucketCount = sectionHeaderArrayUint32[sectionHeaderBaseUint32 + 8]; - const partiallyFilledBucketCount = sectionHeaderArrayUint32[sectionHeaderBaseUint32 + 9]; - const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4; - const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes; - - const sphericalHarmonicsDegree = sectionHeaderArrayUint16[sectionHeaderBaseUint16 + 20]; - const { bytesPerSplat } = SplatBuffer.calculateComponentStorage(compressionLevel, sphericalHarmonicsDegree); - - const splatDataStorageSizeBytes = bytesPerSplat * maxSplatCount; - const storageSizeBytes = splatDataStorageSizeBytes + bucketsStorageSizeBytes; - const sectionHeader = { - bytesPerSplat: bytesPerSplat, - splatCountOffset: splatCountOffset, - splatCount: secLoadedCountsToMax ? maxSplatCount : 0, - maxSplatCount: maxSplatCount, - bucketSize: bucketSize, - bucketCount: bucketCount, - bucketBlockSize: bucketBlockSize, - halfBucketBlockSize: halfBucketBlockSize, - bucketStorageSizeBytes: bucketStorageSizeBytes, - bucketsStorageSizeBytes: bucketsStorageSizeBytes, - splatDataStorageSizeBytes: splatDataStorageSizeBytes, - storageSizeBytes: storageSizeBytes, - compressionScaleRange: compressionScaleRange, - compressionScaleFactor: halfBucketBlockSize / compressionScaleRange, - base: sectionBase, - bucketsBase: sectionBase + bucketsMetaDataSizeBytes, - dataBase: sectionBase + bucketsStorageSizeBytes, - fullBucketCount: fullBucketCount, - partiallyFilledBucketCount: partiallyFilledBucketCount, - sphericalHarmonicsDegree: sphericalHarmonicsDegree - }; - sectionHeaders[i] = sectionHeader; - sectionBase += storageSizeBytes; - sectionHeaderBase += SplatBuffer.SectionHeaderSizeBytes; - sectionHeaderBaseUint16 = sectionHeaderBase / 2; - sectionHeaderBaseUint32 = sectionHeaderBase / 4; - splatCountOffset += maxSplatCount; - } - - return sectionHeaders; - } - - - static writeSectionHeaderToBuffer(sectionHeader, compressionLevel, buffer, offset = 0) { - const sectionHeadeArrayUint16 = new Uint16Array(buffer, offset, SplatBuffer.SectionHeaderSizeBytes / 2); - const sectionHeadeArrayUint32 = new Uint32Array(buffer, offset, SplatBuffer.SectionHeaderSizeBytes / 4); - const sectionHeadeArrayFloat32 = new Float32Array(buffer, offset, SplatBuffer.SectionHeaderSizeBytes / 4); - - sectionHeadeArrayUint32[0] = sectionHeader.splatCount; - sectionHeadeArrayUint32[1] = sectionHeader.maxSplatCount; - sectionHeadeArrayUint32[2] = compressionLevel >= 1 ? sectionHeader.bucketSize : 0; - sectionHeadeArrayUint32[3] = compressionLevel >= 1 ? sectionHeader.bucketCount : 0; - sectionHeadeArrayFloat32[4] = compressionLevel >= 1 ? sectionHeader.bucketBlockSize : 0.0; - sectionHeadeArrayUint16[10] = compressionLevel >= 1 ? SplatBuffer.BucketStorageSizeBytes : 0; - sectionHeadeArrayUint32[6] = compressionLevel >= 1 ? sectionHeader.compressionScaleRange : 0; - sectionHeadeArrayUint32[7] = sectionHeader.storageSizeBytes; - sectionHeadeArrayUint32[8] = compressionLevel >= 1 ? sectionHeader.fullBucketCount : 0; - sectionHeadeArrayUint32[9] = compressionLevel >= 1 ? sectionHeader.partiallyFilledBucketCount : 0; - sectionHeadeArrayUint16[20] = sectionHeader.sphericalHarmonicsDegree; - - } - - static writeSectionHeaderSplatCountToBuffer(splatCount, buffer, offset = 0) { - const sectionHeadeArrayUint32 = new Uint32Array(buffer, offset, SplatBuffer.SectionHeaderSizeBytes / 4); - sectionHeadeArrayUint32[0] = splatCount; - } - - constructFromBuffer(bufferData, secLoadedCountsToMax) { - this.bufferData = bufferData; - - this.globalSplatIndexToLocalSplatIndexMap = []; - this.globalSplatIndexToSectionMap = []; - - const header = SplatBuffer.parseHeader(this.bufferData); - this.versionMajor = header.versionMajor; - this.versionMinor = header.versionMinor; - this.maxSectionCount = header.maxSectionCount; - this.sectionCount = secLoadedCountsToMax ? header.maxSectionCount : 0; - this.maxSplatCount = header.maxSplatCount; - this.splatCount = secLoadedCountsToMax ? header.maxSplatCount : 0; - this.compressionLevel = header.compressionLevel; - this.sceneCenter = new THREE__namespace.Vector3().copy(header.sceneCenter); - this.minSphericalHarmonicsCoeff = header.minSphericalHarmonicsCoeff; - this.maxSphericalHarmonicsCoeff = header.maxSphericalHarmonicsCoeff; - - this.sections = SplatBuffer.parseSectionHeaders(header, this.bufferData, SplatBuffer.HeaderSizeBytes, secLoadedCountsToMax); - - this.linkBufferArrays(); - this.buildMaps(); - } - - static calculateComponentStorage(compressionLevel, sphericalHarmonicsDegree) { - const bytesPerCenter = SplatBuffer.CompressionLevels[compressionLevel].BytesPerCenter; - const bytesPerScale = SplatBuffer.CompressionLevels[compressionLevel].BytesPerScale; - const bytesPerRotation = SplatBuffer.CompressionLevels[compressionLevel].BytesPerRotation; - const bytesPerColor = SplatBuffer.CompressionLevels[compressionLevel].BytesPerColor; - const sphericalHarmonicsComponentsPerSplat = getSphericalHarmonicsComponentCountForDegree(sphericalHarmonicsDegree); - const sphericalHarmonicsBytesPerSplat = SplatBuffer.CompressionLevels[compressionLevel].BytesPerSphericalHarmonicsComponent * - sphericalHarmonicsComponentsPerSplat; - const bytesPerSplat = bytesPerCenter + bytesPerScale + bytesPerRotation + - bytesPerColor + sphericalHarmonicsBytesPerSplat; - return { - bytesPerCenter, - bytesPerScale, - bytesPerRotation, - bytesPerColor, - sphericalHarmonicsComponentsPerSplat, - sphericalHarmonicsBytesPerSplat, - bytesPerSplat - }; - } - - linkBufferArrays() { - for (let i = 0; i < this.maxSectionCount; i++) { - const section = this.sections[i]; - section.bucketArray = new Float32Array(this.bufferData, section.bucketsBase, - section.bucketCount * SplatBuffer.BucketStorageSizeFloats); - if (section.partiallyFilledBucketCount > 0) { - section.partiallyFilledBucketLengths = new Uint32Array(this.bufferData, section.base, - section.partiallyFilledBucketCount); - } - } - } - - buildMaps() { - let cumulativeSplatCount = 0; - for (let i = 0; i < this.maxSectionCount; i++) { - const section = this.sections[i]; - for (let j = 0; j < section.maxSplatCount; j++) { - const globalSplatIndex = cumulativeSplatCount + j; - this.globalSplatIndexToLocalSplatIndexMap[globalSplatIndex] = j; - this.globalSplatIndexToSectionMap[globalSplatIndex] = i; - } - cumulativeSplatCount += section.maxSplatCount; - } - } - - updateLoadedCounts(newSectionCount, newSplatCount) { - SplatBuffer.writeHeaderCountsToBuffer(newSectionCount, newSplatCount, this.bufferData); - this.sectionCount = newSectionCount; - this.splatCount = newSplatCount; - } - - updateSectionLoadedCounts(sectionIndex, newSplatCount) { - const sectionHeaderOffset = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * sectionIndex; - SplatBuffer.writeSectionHeaderSplatCountToBuffer(newSplatCount, this.bufferData, sectionHeaderOffset); - this.sections[sectionIndex].splatCount = newSplatCount; - } - - static writeSplatDataToSectionBuffer = function() { - - const tempCenterBuffer = new ArrayBuffer(12); - const tempScaleBuffer = new ArrayBuffer(12); - const tempRotationBuffer = new ArrayBuffer(16); - const tempColorBuffer = new ArrayBuffer(4); - const tempSHBuffer = new ArrayBuffer(256); - const tempRot = new THREE__namespace.Quaternion(); - const tempScale = new THREE__namespace.Vector3(); - const bucketCenterDelta = new THREE__namespace.Vector3(); - - const { - X: OFFSET_X, Y: OFFSET_Y, Z: OFFSET_Z, - SCALE0: OFFSET_SCALE0, SCALE1: OFFSET_SCALE1, SCALE2: OFFSET_SCALE2, - ROTATION0: OFFSET_ROT0, ROTATION1: OFFSET_ROT1, ROTATION2: OFFSET_ROT2, ROTATION3: OFFSET_ROT3, - FDC0: OFFSET_FDC0, FDC1: OFFSET_FDC1, FDC2: OFFSET_FDC2, OPACITY: OFFSET_OPACITY, - FRC0: OFFSET_FRC0, FRC9: OFFSET_FRC9, - } = UncompressedSplatArray.OFFSET; - - const compressPositionOffset = (v, compressionScaleFactor, compressionScaleRange) => { - const doubleCompressionScaleRange = compressionScaleRange * 2 + 1; - v = Math.round(v * compressionScaleFactor) + compressionScaleRange; - return clamp(v, 0, doubleCompressionScaleRange); - }; - - return function(targetSplat, sectionBuffer, bufferOffset, compressionLevel, sphericalHarmonicsDegree, - bucketCenter, compressionScaleFactor, compressionScaleRange, - minSphericalHarmonicsCoeff = -DefaultSphericalHarmonics8BitCompressionHalfRange, - maxSphericalHarmonicsCoeff = DefaultSphericalHarmonics8BitCompressionHalfRange) { - - const sphericalHarmonicsComponentsPerSplat = getSphericalHarmonicsComponentCountForDegree(sphericalHarmonicsDegree); - const bytesPerCenter = SplatBuffer.CompressionLevels[compressionLevel].BytesPerCenter; - const bytesPerScale = SplatBuffer.CompressionLevels[compressionLevel].BytesPerScale; - const bytesPerRotation = SplatBuffer.CompressionLevels[compressionLevel].BytesPerRotation; - const bytesPerColor = SplatBuffer.CompressionLevels[compressionLevel].BytesPerColor; - - const centerBase = bufferOffset; - const scaleBase = centerBase + bytesPerCenter; - const rotationBase = scaleBase + bytesPerScale; - const colorBase = rotationBase + bytesPerRotation; - const sphericalHarmonicsBase = colorBase + bytesPerColor; - - if (targetSplat[OFFSET_ROT0] !== undefined) { - tempRot.set(targetSplat[OFFSET_ROT0], targetSplat[OFFSET_ROT1], targetSplat[OFFSET_ROT2], targetSplat[OFFSET_ROT3]); - tempRot.normalize(); - } else { - tempRot.set(1.0, 0.0, 0.0, 0.0); - } - - if (targetSplat[OFFSET_SCALE0] !== undefined) { - tempScale.set(targetSplat[OFFSET_SCALE0] || 0, - targetSplat[OFFSET_SCALE1] || 0, - targetSplat[OFFSET_SCALE2] || 0); - } else { - tempScale.set(0, 0, 0); - } - - if (compressionLevel === 0) { - const center = new Float32Array(sectionBuffer, centerBase, SplatBuffer.CenterComponentCount); - const rot = new Float32Array(sectionBuffer, rotationBase, SplatBuffer.RotationComponentCount); - const scale = new Float32Array(sectionBuffer, scaleBase, SplatBuffer.ScaleComponentCount); - - rot.set([tempRot.x, tempRot.y, tempRot.z, tempRot.w]); - scale.set([tempScale.x, tempScale.y, tempScale.z]); - center.set([targetSplat[OFFSET_X], targetSplat[OFFSET_Y], targetSplat[OFFSET_Z]]); - - if (sphericalHarmonicsDegree > 0) { - const shOut = new Float32Array(sectionBuffer, sphericalHarmonicsBase, sphericalHarmonicsComponentsPerSplat); - if (sphericalHarmonicsDegree >= 1) { - for (let s = 0; s < 9; s++) shOut[s] = targetSplat[OFFSET_FRC0 + s] || 0; - if (sphericalHarmonicsDegree >= 2) { - for (let s = 0; s < 15; s++) shOut[s + 9] = targetSplat[OFFSET_FRC9 + s] || 0; - } - } - } - } else { - const center = new Uint16Array(tempCenterBuffer, 0, SplatBuffer.CenterComponentCount); - const rot = new Uint16Array(tempRotationBuffer, 0, SplatBuffer.RotationComponentCount); - const scale = new Uint16Array(tempScaleBuffer, 0, SplatBuffer.ScaleComponentCount); - - rot.set([toHalfFloat(tempRot.x), toHalfFloat(tempRot.y), toHalfFloat(tempRot.z), toHalfFloat(tempRot.w)]); - scale.set([toHalfFloat(tempScale.x), toHalfFloat(tempScale.y), toHalfFloat(tempScale.z)]); - - bucketCenterDelta.set(targetSplat[OFFSET_X], targetSplat[OFFSET_Y], targetSplat[OFFSET_Z]).sub(bucketCenter); - bucketCenterDelta.x = compressPositionOffset(bucketCenterDelta.x, compressionScaleFactor, compressionScaleRange); - bucketCenterDelta.y = compressPositionOffset(bucketCenterDelta.y, compressionScaleFactor, compressionScaleRange); - bucketCenterDelta.z = compressPositionOffset(bucketCenterDelta.z, compressionScaleFactor, compressionScaleRange); - center.set([bucketCenterDelta.x, bucketCenterDelta.y, bucketCenterDelta.z]); - - if (sphericalHarmonicsDegree > 0) { - const SHArrayType = compressionLevel === 1 ? Uint16Array : Uint8Array; - const bytesPerSHComponent = compressionLevel === 1 ? 2 : 1; - const shOut = new SHArrayType(tempSHBuffer, 0, sphericalHarmonicsComponentsPerSplat); - if (sphericalHarmonicsDegree >= 1) { - for (let s = 0; s < 9; s++) { - const srcVal = targetSplat[OFFSET_FRC0 + s] || 0; - shOut[s] = compressionLevel === 1 ? toHalfFloat(srcVal) : - toUint8(srcVal, minSphericalHarmonicsCoeff, maxSphericalHarmonicsCoeff); - } - const degree1ByteCount = 9 * bytesPerSHComponent; - copyBetweenBuffers(shOut.buffer, 0, sectionBuffer, sphericalHarmonicsBase, degree1ByteCount); - if (sphericalHarmonicsDegree >= 2) { - for (let s = 0; s < 15; s++) { - const srcVal = targetSplat[OFFSET_FRC9 + s] || 0; - shOut[s + 9] = compressionLevel === 1 ? toHalfFloat(srcVal) : - toUint8(srcVal, minSphericalHarmonicsCoeff, maxSphericalHarmonicsCoeff); - } - copyBetweenBuffers(shOut.buffer, degree1ByteCount, sectionBuffer, - sphericalHarmonicsBase + degree1ByteCount, 15 * bytesPerSHComponent); - } - } - } - - copyBetweenBuffers(center.buffer, 0, sectionBuffer, centerBase, 6); - copyBetweenBuffers(scale.buffer, 0, sectionBuffer, scaleBase, 6); - copyBetweenBuffers(rot.buffer, 0, sectionBuffer, rotationBase, 8); - } - - const rgba = new Uint8ClampedArray(tempColorBuffer, 0, 4); - rgba.set([targetSplat[OFFSET_FDC0] || 0, targetSplat[OFFSET_FDC1] || 0, targetSplat[OFFSET_FDC2] || 0]); - rgba[3] = targetSplat[OFFSET_OPACITY] || 0; - - copyBetweenBuffers(rgba.buffer, 0, sectionBuffer, colorBase, 4); - }; - - }(); - - static generateFromUncompressedSplatArrays(splatArrays, minimumAlpha, compressionLevel, - sceneCenter, blockSize, bucketSize, options = []) { - - let shDegree = 0; - for (let sa = 0; sa < splatArrays.length; sa ++) { - const splatArray = splatArrays[sa]; - shDegree = Math.max(splatArray.sphericalHarmonicsDegree, shDegree); - } - - let minSphericalHarmonicsCoeff; - let maxSphericalHarmonicsCoeff; - - for (let sa = 0; sa < splatArrays.length; sa ++) { - const splatArray = splatArrays[sa]; - for (let i = 0; i < splatArray.splats.length; i++) { - const splat = splatArray.splats[i]; - for (let sc = UncompressedSplatArray.OFFSET.FRC0; sc < UncompressedSplatArray.OFFSET.FRC23 && sc < splat.length; sc++) { - if (!minSphericalHarmonicsCoeff || splat[sc] < minSphericalHarmonicsCoeff) { - minSphericalHarmonicsCoeff = splat[sc]; - } - if (!maxSphericalHarmonicsCoeff || splat[sc] > maxSphericalHarmonicsCoeff) { - maxSphericalHarmonicsCoeff = splat[sc]; - } - } - } - } - - minSphericalHarmonicsCoeff = minSphericalHarmonicsCoeff || -DefaultSphericalHarmonics8BitCompressionHalfRange; - maxSphericalHarmonicsCoeff = maxSphericalHarmonicsCoeff || DefaultSphericalHarmonics8BitCompressionHalfRange; - - const { bytesPerSplat } = SplatBuffer.calculateComponentStorage(compressionLevel, shDegree); - const compressionScaleRange = SplatBuffer.CompressionLevels[compressionLevel].ScaleRange; - - const sectionBuffers = []; - const sectionHeaderBuffers = []; - let totalSplatCount = 0; - - for (let sa = 0; sa < splatArrays.length; sa ++) { - const splatArray = splatArrays[sa]; - const validSplats = new UncompressedSplatArray(shDegree); - for (let i = 0; i < splatArray.splatCount; i++) { - const targetSplat = splatArray.splats[i]; - if ((targetSplat[UncompressedSplatArray.OFFSET.OPACITY] || 0) >= minimumAlpha) { - validSplats.addSplat(targetSplat); - } - } - - const sectionOptions = options[sa] || {}; - const sectionBlockSize = (sectionOptions.blockSizeFactor || 1) * (blockSize || SplatBuffer.BucketBlockSize); - const sectionBucketSize = Math.ceil((sectionOptions.bucketSizeFactor || 1) * (bucketSize || SplatBuffer.BucketSize)); - - const bucketInfo = SplatBuffer.computeBucketsForUncompressedSplatArray(validSplats, sectionBlockSize, sectionBucketSize); - const fullBucketCount = bucketInfo.fullBuckets.length; - const partiallyFullBucketLengths = bucketInfo.partiallyFullBuckets.map((bucket) => bucket.splats.length); - const partiallyFilledBucketCount = partiallyFullBucketLengths.length; - const buckets = [...bucketInfo.fullBuckets, ...bucketInfo.partiallyFullBuckets]; - - const sectionDataSizeBytes = validSplats.splats.length * bytesPerSplat; - const bucketMetaDataSizeBytes = partiallyFilledBucketCount * 4; - const bucketDataBytes = compressionLevel >= 1 ? buckets.length * - SplatBuffer.BucketStorageSizeBytes + bucketMetaDataSizeBytes : 0; - const sectionSizeBytes = sectionDataSizeBytes + bucketDataBytes; - const sectionBuffer = new ArrayBuffer(sectionSizeBytes); - - const compressionScaleFactor = compressionScaleRange / (sectionBlockSize * 0.5); - const bucketCenter = new THREE__namespace.Vector3(); - - let outSplatCount = 0; - for (let b = 0; b < buckets.length; b++) { - const bucket = buckets[b]; - bucketCenter.fromArray(bucket.center); - for (let i = 0; i < bucket.splats.length; i++) { - let row = bucket.splats[i]; - const targetSplat = validSplats.splats[row]; - const bufferOffset = bucketDataBytes + outSplatCount * bytesPerSplat; - SplatBuffer.writeSplatDataToSectionBuffer(targetSplat, sectionBuffer, bufferOffset, compressionLevel, shDegree, - bucketCenter, compressionScaleFactor, compressionScaleRange, - minSphericalHarmonicsCoeff, maxSphericalHarmonicsCoeff); - outSplatCount++; - } - } - totalSplatCount += outSplatCount; - - if (compressionLevel >= 1) { - const bucketMetaDataArray = new Uint32Array(sectionBuffer, 0, partiallyFullBucketLengths.length * 4); - for (let pfb = 0; pfb < partiallyFullBucketLengths.length; pfb ++) { - bucketMetaDataArray[pfb] = partiallyFullBucketLengths[pfb]; - } - const bucketArray = new Float32Array(sectionBuffer, bucketMetaDataSizeBytes, - buckets.length * SplatBuffer.BucketStorageSizeFloats); - for (let b = 0; b < buckets.length; b++) { - const bucket = buckets[b]; - const base = b * 3; - bucketArray[base] = bucket.center[0]; - bucketArray[base + 1] = bucket.center[1]; - bucketArray[base + 2] = bucket.center[2]; - } - } - sectionBuffers.push(sectionBuffer); - - const sectionHeaderBuffer = new ArrayBuffer(SplatBuffer.SectionHeaderSizeBytes); - SplatBuffer.writeSectionHeaderToBuffer({ - maxSplatCount: outSplatCount, - splatCount: outSplatCount, - bucketSize: sectionBucketSize, - bucketCount: buckets.length, - bucketBlockSize: sectionBlockSize, - compressionScaleRange: compressionScaleRange, - storageSizeBytes: sectionSizeBytes, - fullBucketCount: fullBucketCount, - partiallyFilledBucketCount: partiallyFilledBucketCount, - sphericalHarmonicsDegree: shDegree - }, compressionLevel, sectionHeaderBuffer, 0); - sectionHeaderBuffers.push(sectionHeaderBuffer); - - } - - let sectionsCumulativeSizeBytes = 0; - for (let sectionBuffer of sectionBuffers) sectionsCumulativeSizeBytes += sectionBuffer.byteLength; - const unifiedBufferSize = SplatBuffer.HeaderSizeBytes + - SplatBuffer.SectionHeaderSizeBytes * sectionBuffers.length + sectionsCumulativeSizeBytes; - const unifiedBuffer = new ArrayBuffer(unifiedBufferSize); - - SplatBuffer.writeHeaderToBuffer({ - versionMajor: 0, - versionMinor: 1, - maxSectionCount: sectionBuffers.length, - sectionCount: sectionBuffers.length, - maxSplatCount: totalSplatCount, - splatCount: totalSplatCount, - compressionLevel: compressionLevel, - sceneCenter: sceneCenter, - minSphericalHarmonicsCoeff: minSphericalHarmonicsCoeff, - maxSphericalHarmonicsCoeff: maxSphericalHarmonicsCoeff - }, unifiedBuffer); - - let currentUnifiedBase = SplatBuffer.HeaderSizeBytes; - for (let sectionHeaderBuffer of sectionHeaderBuffers) { - new Uint8Array(unifiedBuffer, currentUnifiedBase, SplatBuffer.SectionHeaderSizeBytes).set(new Uint8Array(sectionHeaderBuffer)); - currentUnifiedBase += SplatBuffer.SectionHeaderSizeBytes; - } - - for (let sectionBuffer of sectionBuffers) { - new Uint8Array(unifiedBuffer, currentUnifiedBase, sectionBuffer.byteLength).set(new Uint8Array(sectionBuffer)); - currentUnifiedBase += sectionBuffer.byteLength; - } - - const splatBuffer = new SplatBuffer(unifiedBuffer); - return splatBuffer; - } - - static computeBucketsForUncompressedSplatArray(splatArray, blockSize, bucketSize) { - let splatCount = splatArray.splatCount; - const halfBlockSize = blockSize / 2.0; - - const min = new THREE__namespace.Vector3(); - const max = new THREE__namespace.Vector3(); - - for (let i = 0; i < splatCount; i++) { - const targetSplat = splatArray.splats[i]; - const center = [targetSplat[UncompressedSplatArray.OFFSET.X], - targetSplat[UncompressedSplatArray.OFFSET.Y], - targetSplat[UncompressedSplatArray.OFFSET.Z]]; - if (i === 0 || center[0] < min.x) min.x = center[0]; - if (i === 0 || center[0] > max.x) max.x = center[0]; - if (i === 0 || center[1] < min.y) min.y = center[1]; - if (i === 0 || center[1] > max.y) max.y = center[1]; - if (i === 0 || center[2] < min.z) min.z = center[2]; - if (i === 0 || center[2] > max.z) max.z = center[2]; - } - - const dimensions = new THREE__namespace.Vector3().copy(max).sub(min); - const yBlocks = Math.ceil(dimensions.y / blockSize); - const zBlocks = Math.ceil(dimensions.z / blockSize); - - const blockCenter = new THREE__namespace.Vector3(); - const fullBuckets = []; - const partiallyFullBuckets = {}; - - for (let i = 0; i < splatCount; i++) { - const targetSplat = splatArray.splats[i]; - const center = [targetSplat[UncompressedSplatArray.OFFSET.X], - targetSplat[UncompressedSplatArray.OFFSET.Y], - targetSplat[UncompressedSplatArray.OFFSET.Z]]; - const xBlock = Math.floor((center[0] - min.x) / blockSize); - const yBlock = Math.floor((center[1] - min.y) / blockSize); - const zBlock = Math.floor((center[2] - min.z) / blockSize); - - blockCenter.x = xBlock * blockSize + min.x + halfBlockSize; - blockCenter.y = yBlock * blockSize + min.y + halfBlockSize; - blockCenter.z = zBlock * blockSize + min.z + halfBlockSize; - - const bucketId = xBlock * (yBlocks * zBlocks) + yBlock * zBlocks + zBlock; - let bucket = partiallyFullBuckets[bucketId]; - if (!bucket) { - partiallyFullBuckets[bucketId] = bucket = { - 'splats': [], - 'center': blockCenter.toArray() - }; - } - - bucket.splats.push(i); - if (bucket.splats.length >= bucketSize) { - fullBuckets.push(bucket); - partiallyFullBuckets[bucketId] = null; - } - } - - const partiallyFullBucketArray = []; - for (let bucketId in partiallyFullBuckets) { - if (partiallyFullBuckets.hasOwnProperty(bucketId)) { - const bucket = partiallyFullBuckets[bucketId]; - if (bucket) { - partiallyFullBucketArray.push(bucket); - } - } - } - - return { - 'fullBuckets': fullBuckets, - 'partiallyFullBuckets': partiallyFullBucketArray, - }; - } - - static preallocateUncompressed(splatCount, sphericalHarmonicsDegrees) { - const shDescriptor = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[sphericalHarmonicsDegrees]; - const splatBufferDataOffsetBytes = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes; - const splatBufferSizeBytes = splatBufferDataOffsetBytes + shDescriptor.BytesPerSplat * splatCount; - const outBuffer = new ArrayBuffer(splatBufferSizeBytes); - SplatBuffer.writeHeaderToBuffer({ - versionMajor: SplatBuffer.CurrentMajorVersion, - versionMinor: SplatBuffer.CurrentMinorVersion, - maxSectionCount: 1, - sectionCount: 1, - maxSplatCount: splatCount, - splatCount: splatCount, - compressionLevel: 0, - sceneCenter: new THREE__namespace.Vector3() - }, outBuffer); - - SplatBuffer.writeSectionHeaderToBuffer({ - maxSplatCount: splatCount, - splatCount: splatCount, - bucketSize: 0, - bucketCount: 0, - bucketBlockSize: 0, - compressionScaleRange: 0, - storageSizeBytes: 0, - fullBucketCount: 0, - partiallyFilledBucketCount: 0, - sphericalHarmonicsDegree: sphericalHarmonicsDegrees - }, 0, outBuffer, SplatBuffer.HeaderSizeBytes); - - return { - splatBuffer: new SplatBuffer(outBuffer, true), - splatBufferDataOffsetBytes - }; - } - } - - const HeaderMagicBytes = new Uint8Array([112, 108, 121, 10]); - const HeaderEndTokenBytes = new Uint8Array([10, 101, 110, 100, 95, 104, 101, 97, 100, 101, 114, 10]); - const HeaderEndToken = 'end_header'; - - const DataTypeMap = new Map([ - ['char', Int8Array], - ['uchar', Uint8Array], - ['short', Int16Array], - ['ushort', Uint16Array], - ['int', Int32Array], - ['uint', Uint32Array], - ['float', Float32Array], - ['double', Float64Array], - ]); - - const unpackUnorm = (value, bits) => { - const t = (1 << bits) - 1; - return (value & t) / t; - }; - - const unpack111011 = (result, value) => { - result.x = unpackUnorm(value >>> 21, 11); - result.y = unpackUnorm(value >>> 11, 10); - result.z = unpackUnorm(value, 11); - }; - - const unpack8888 = (result, value) => { - result.x = unpackUnorm(value >>> 24, 8); - result.y = unpackUnorm(value >>> 16, 8); - result.z = unpackUnorm(value >>> 8, 8); - result.w = unpackUnorm(value, 8); - }; - - // unpack quaternion with 2,10,10,10 format (largest element, 3x10bit element) - const unpackRot = (result, value) => { - const norm = 1.0 / (Math.sqrt(2) * 0.5); - const a = (unpackUnorm(value >>> 20, 10) - 0.5) * norm; - const b = (unpackUnorm(value >>> 10, 10) - 0.5) * norm; - const c = (unpackUnorm(value, 10) - 0.5) * norm; - const m = Math.sqrt(1.0 - (a * a + b * b + c * c)); - - switch (value >>> 30) { - case 0: - result.set(m, a, b, c); - break; - case 1: - result.set(a, m, b, c); - break; - case 2: - result.set(a, b, m, c); - break; - case 3: - result.set(a, b, c, m); - break; - } - }; - - const lerp = (a, b, t) => { - return a * (1 - t) + b * t; - }; - - const getElementPropStorage = (element, name) => { - return element.properties.find((p) => p.name === name && p.storage) - ?.storage; - }; - - class PlayCanvasCompressedPlyParser { - - static decodeHeaderText(headerText) { - - let element; - let chunkElement; - let vertexElement; - let shElement; - - const headerLines = headerText.split('\n').filter((line) => !line.startsWith('comment ')); - - let bytesPerSplat = 0; - let done = false; - for (let i = 1; i < headerLines.length; ++i) { - const words = headerLines[i].split(' '); - - switch (words[0]) { - case 'format': - if (words[1] !== 'binary_little_endian') { - throw new Error('Unsupported ply format'); - } - break; - case 'element': - element = { - name: words[1], - count: parseInt(words[2], 10), - properties: [], - storageSizeBytes: 0 - }; - if (element.name === 'chunk') chunkElement = element; - else if (element.name === 'vertex') vertexElement = element; - else if (element.name === 'sh') shElement = element; - break; - case 'property': { - if (!DataTypeMap.has(words[1])) { - throw new Error( - `Unrecognized property data type '${words[1]}' in ply header` - ); - } - const StorageType = DataTypeMap.get(words[1]); - const storageSizeByes = StorageType.BYTES_PER_ELEMENT * element.count; - if (element.name === 'vertex') bytesPerSplat += StorageType.BYTES_PER_ELEMENT; - element.properties.push({ - type: words[1], - name: words[2], - storage: null, - byteSize: StorageType.BYTES_PER_ELEMENT, - storageSizeByes: storageSizeByes - }); - element.storageSizeBytes += storageSizeByes; - break; - } - case HeaderEndToken: - done = true; - break; - default: - throw new Error( - `Unrecognized header value '${words[0]}' in ply header` - ); - } - if (done) break; - } - - let sphericalHarmonicsDegree = 0; - let sphericalHarmonicsPerSplat = 0; - if (shElement) { - sphericalHarmonicsPerSplat = shElement.properties.length; - if (shElement.properties.length >= 45) { - sphericalHarmonicsDegree = 3; - } else if (shElement.properties.length >= 24) { - sphericalHarmonicsDegree = 2; - } else if (shElement.properties.length >= 9) { - sphericalHarmonicsDegree = 1; - } - } - - return { - 'chunkElement': chunkElement, - 'vertexElement': vertexElement, - 'shElement': shElement, - 'bytesPerSplat': bytesPerSplat, - 'headerSizeBytes': headerText.indexOf(HeaderEndToken) + HeaderEndToken.length + 1, - 'sphericalHarmonicsDegree': sphericalHarmonicsDegree, - 'sphericalHarmonicsPerSplat': sphericalHarmonicsPerSplat - }; - } - - static decodeHeader(plyBuffer) { - - /** - * Searches for the first occurrence of a sequence within a buffer. - * @example - * find(new Uint8Array([1, 2, 3, 4]), new Uint8Array([3, 4])); // 2 - * @param {Uint8Array} buf - The buffer in which to search. - * @param {Uint8Array} search - The sequence to search for. - * @return {number} The index of the first occurrence of the search sequence in the buffer, or -1 if not found. - */ - const find = (buf, search) => { - const endIndex = buf.length - search.length; - let i; - let j; - for (i = 0; i <= endIndex; ++i) { - for (j = 0; j < search.length; ++j) { - if (buf[i + j] !== search[j]) { - break; - } - } - if (j === search.length) { - return i; - } - } - return -1; - }; - - /** - * Checks if array 'a' starts with the same elements as array 'b'. - * @example - * startsWith(new Uint8Array([1, 2, 3, 4]), new Uint8Array([1, 2])); // true - * @param {Uint8Array} a - The array to check against. - * @param {Uint8Array} b - The array of elements to look for at the start of 'a'. - * @return {boolean} - True if 'a' starts with all elements of 'b', otherwise false. - */ - const startsWith = (a, b) => { - if (a.length < b.length) { - return false; - } - - for (let i = 0; i < b.length; ++i) { - if (a[i] !== b[i]) { - return false; - } - } - - return true; - }; - - let buf = new Uint8Array(plyBuffer); - let endHeaderTokenOffset; - - if (buf.length >= HeaderMagicBytes.length && !startsWith(buf, HeaderMagicBytes)) { - throw new Error('Invalid PLY header'); - } - - endHeaderTokenOffset = find(buf, HeaderEndTokenBytes); - if (endHeaderTokenOffset === -1) { - throw new Error('End of PLY header not found'); - } - - const headerText = new TextDecoder('ascii').decode( - buf.slice(0, endHeaderTokenOffset) - ); - - const { - chunkElement, - vertexElement, - shElement, - sphericalHarmonicsDegree, - sphericalHarmonicsPerSplat, - bytesPerSplat - } = PlayCanvasCompressedPlyParser.decodeHeaderText(headerText); - - return { - 'headerSizeBytes': endHeaderTokenOffset + HeaderEndTokenBytes.length, - 'bytesPerSplat': bytesPerSplat, - 'chunkElement': chunkElement, - 'vertexElement': vertexElement, - 'shElement': shElement, - 'sphericalHarmonicsDegree': sphericalHarmonicsDegree, - 'sphericalHarmonicsPerSplat': sphericalHarmonicsPerSplat - }; - } - - static readElementData(element, readBuffer, readOffset, fromIndex, toIndex, propertyFilter = null) { - - let dataView = readBuffer instanceof DataView ? readBuffer : new DataView(readBuffer); - - fromIndex = fromIndex || 0; - toIndex = toIndex || element.count - 1; - for (let e = fromIndex; e <= toIndex; ++e) { - for (let j = 0; j < element.properties.length; ++j) { - const property = element.properties[j]; - - const StorageType = DataTypeMap.get(property.type); - const requiredStorageSizeBytes = StorageType.BYTES_PER_ELEMENT * element.count; - if ((!property.storage || property.storage.byteLength < requiredStorageSizeBytes) && - (!propertyFilter || propertyFilter(property.name))) { - property.storage = new StorageType(element.count); - } - - if (property.storage) { - switch (property.type) { - case 'char': - property.storage[e] = dataView.getInt8(readOffset); - break; - case 'uchar': - property.storage[e] = dataView.getUint8(readOffset); - break; - case 'short': - property.storage[e] = dataView.getInt16(readOffset, true); - break; - case 'ushort': - property.storage[e] = dataView.getUint16(readOffset, true); - break; - case 'int': - property.storage[e] = dataView.getInt32(readOffset, true); - break; - case 'uint': - property.storage[e] = dataView.getUint32(readOffset, true); - break; - case 'float': - property.storage[e] = dataView.getFloat32(readOffset, true); - break; - case 'double': - property.storage[e] = dataView.getFloat64(readOffset, true); - break; - } - } - - readOffset += property.byteSize; - } - } - - return readOffset; - } - - static readPly(plyBuffer, propertyFilter = null) { - - const header = PlayCanvasCompressedPlyParser.decodeHeader(plyBuffer); - - let readIndex = PlayCanvasCompressedPlyParser.readElementData(header.chunkElement, plyBuffer, - header.headerSizeBytes, null, null, propertyFilter); - readIndex = PlayCanvasCompressedPlyParser.readElementData(header.vertexElement, plyBuffer, readIndex, null, null, propertyFilter); - PlayCanvasCompressedPlyParser.readElementData(header.shElement, plyBuffer, readIndex, null, null, propertyFilter); - - return { - 'chunkElement': header.chunkElement, - 'vertexElement': header.vertexElement, - 'shElement': header.shElement, - 'sphericalHarmonicsDegree': header.sphericalHarmonicsDegree, - 'sphericalHarmonicsPerSplat': header.sphericalHarmonicsPerSplat - }; - } - - static getElementStorageArrays(chunkElement, vertexElement, shElement) { - const storageArrays = {}; - - if (vertexElement) { - const minR = getElementPropStorage(chunkElement, 'min_r'); - const minG = getElementPropStorage(chunkElement, 'min_g'); - const minB = getElementPropStorage(chunkElement, 'min_b'); - const maxR = getElementPropStorage(chunkElement, 'max_r'); - const maxG = getElementPropStorage(chunkElement, 'max_g'); - const maxB = getElementPropStorage(chunkElement, 'max_b'); - const minX = getElementPropStorage(chunkElement, 'min_x'); - const minY = getElementPropStorage(chunkElement, 'min_y'); - const minZ = getElementPropStorage(chunkElement, 'min_z'); - const maxX = getElementPropStorage(chunkElement, 'max_x'); - const maxY = getElementPropStorage(chunkElement, 'max_y'); - const maxZ = getElementPropStorage(chunkElement, 'max_z'); - const minScaleX = getElementPropStorage(chunkElement, 'min_scale_x'); - const minScaleY = getElementPropStorage(chunkElement, 'min_scale_y'); - const minScaleZ = getElementPropStorage(chunkElement, 'min_scale_z'); - const maxScaleX = getElementPropStorage(chunkElement, 'max_scale_x'); - const maxScaleY = getElementPropStorage(chunkElement, 'max_scale_y'); - const maxScaleZ = getElementPropStorage(chunkElement, 'max_scale_z'); - const position = getElementPropStorage(vertexElement, 'packed_position'); - const rotation = getElementPropStorage(vertexElement, 'packed_rotation'); - const scale = getElementPropStorage(vertexElement, 'packed_scale'); - const color = getElementPropStorage(vertexElement, 'packed_color'); - - storageArrays['colorExtremes'] = { - minR, maxR, - minG, maxG, - minB, maxB - }; - storageArrays['positionExtremes'] = { - minX, maxX, - minY, maxY, - minZ, maxZ - }; - storageArrays['scaleExtremes'] = { - minScaleX, maxScaleX, minScaleY, - maxScaleY, minScaleZ, maxScaleZ - }; - storageArrays['position'] = position; - storageArrays['rotation'] = rotation; - storageArrays['scale'] = scale; - storageArrays['color'] = color; - } - - if (shElement) { - const shStorageArrays = {}; - for (let i = 0; i < 45; i++) { - const fRestKey = `f_rest_${i}`; - const fRest = getElementPropStorage(shElement, fRestKey); - if (fRest) { - shStorageArrays[fRestKey] = fRest; - } else { - break; - } - } - storageArrays['sh'] = shStorageArrays; - } - - return storageArrays; - } - - static decompressBaseSplat = function() { - - const p = new THREE__namespace.Vector3(); - const r = new THREE__namespace.Quaternion(); - const s = new THREE__namespace.Vector3(); - const c = new THREE__namespace.Vector4(); - - const OFFSET = UncompressedSplatArray.OFFSET; - - return function(index, chunkSplatIndexOffset, positionArray, positionExtremes, scaleArray, scaleExtremes, - rotationArray, colorExtremes, colorArray, outSplat) { - outSplat = outSplat || UncompressedSplatArray.createSplat(); - - const chunkIndex = Math.floor((chunkSplatIndexOffset + index) / 256); - - unpack111011(p, positionArray[index]); - unpackRot(r, rotationArray[index]); - unpack111011(s, scaleArray[index]); - unpack8888(c, colorArray[index]); - - outSplat[OFFSET.X] = lerp(positionExtremes.minX[chunkIndex], positionExtremes.maxX[chunkIndex], p.x); - outSplat[OFFSET.Y] = lerp(positionExtremes.minY[chunkIndex], positionExtremes.maxY[chunkIndex], p.y); - outSplat[OFFSET.Z] = lerp(positionExtremes.minZ[chunkIndex], positionExtremes.maxZ[chunkIndex], p.z); - - outSplat[OFFSET.ROTATION0] = r.x; - outSplat[OFFSET.ROTATION1] = r.y; - outSplat[OFFSET.ROTATION2] = r.z; - outSplat[OFFSET.ROTATION3] = r.w; - - outSplat[OFFSET.SCALE0] = Math.exp(lerp(scaleExtremes.minScaleX[chunkIndex], scaleExtremes.maxScaleX[chunkIndex], s.x)); - outSplat[OFFSET.SCALE1] = Math.exp(lerp(scaleExtremes.minScaleY[chunkIndex], scaleExtremes.maxScaleY[chunkIndex], s.y)); - outSplat[OFFSET.SCALE2] = Math.exp(lerp(scaleExtremes.minScaleZ[chunkIndex], scaleExtremes.maxScaleZ[chunkIndex], s.z)); - - if (colorExtremes.minR && colorExtremes.maxR) { - outSplat[OFFSET.FDC0] = clamp(Math.round(lerp(colorExtremes.minR[chunkIndex], colorExtremes.maxR[chunkIndex], c.x) * 255), 0, 255); - } else { - outSplat[OFFSET.FDC0] = clamp(Math.floor(c.x * 255), 0, 255); - } - if (colorExtremes.minG && colorExtremes.maxG) { - outSplat[OFFSET.FDC1] = clamp(Math.round(lerp(colorExtremes.minG[chunkIndex], colorExtremes.maxG[chunkIndex], c.y) * 255), 0, 255); - } else { - outSplat[OFFSET.FDC1] = clamp(Math.floor(c.y * 255), 0, 255); - } - if (colorExtremes.minB && colorExtremes.maxB) { - outSplat[OFFSET.FDC2] = clamp(Math.round(lerp(colorExtremes.minB[chunkIndex], colorExtremes.maxB[chunkIndex], c.z) * 255), 0, 255); - } else { - outSplat[OFFSET.FDC2] = clamp(Math.floor(c.z * 255), 0, 255); - } - outSplat[OFFSET.OPACITY] = clamp(Math.floor(c.w * 255), 0, 255); - - return outSplat; - }; - - }(); - - static decompressSphericalHarmonics = function() { - - const shCoeffMap = [0, 3, 8, 15]; - - const shIndexMap = [ - 0, 1, 2, 9, 10, 11, 12, 13, 24, 25, 26, 27, 28, 29, 30, - 3, 4, 5, 14, 15, 16, 17, 18, 31, 32, 33, 34, 35, 36, 37, - 6, 7, 8, 19, 20, 21, 22, 23, 38, 39, 40, 41, 42, 43, 44 - ]; - - return function(index, shArray, outSphericalHarmonicsDegree, readSphericalHarmonicsDegree, outSplat) { - outSplat = outSplat || UncompressedSplatArray.createSplat(); - let outSHCoeff = shCoeffMap[outSphericalHarmonicsDegree]; - let readSHCoeff = shCoeffMap[readSphericalHarmonicsDegree]; - for (let j = 0; j < 3; ++j) { - for (let k = 0; k < 15; ++k) { - const outIndex = shIndexMap[j * 15 + k]; - if (k < outSHCoeff && k < readSHCoeff) { - outSplat[UncompressedSplatArray.OFFSET.FRC0 + outIndex] = (shArray[j * readSHCoeff + k][index] * (8 / 255) - 4); - } - } - } - - return outSplat; - }; - - }(); - - static parseToUncompressedSplatBufferSection(chunkElement, vertexElement, fromIndex, toIndex, chunkSplatIndexOffset, - vertexDataBuffer, outBuffer, outOffset, propertyFilter = null) { - - PlayCanvasCompressedPlyParser.readElementData(vertexElement, vertexDataBuffer, 0, fromIndex, toIndex, propertyFilter); - - const outBytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[0].BytesPerSplat; - - const { positionExtremes, scaleExtremes, colorExtremes, position, rotation, scale, color } = - PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, vertexElement); - - const tempSplat = UncompressedSplatArray.createSplat(); - - for (let i = fromIndex; i <= toIndex; ++i) { - PlayCanvasCompressedPlyParser.decompressBaseSplat(i, chunkSplatIndexOffset, position, positionExtremes, - scale, scaleExtremes, rotation, colorExtremes, color, tempSplat); - const outBase = i * outBytesPerSplat + outOffset; - SplatBuffer.writeSplatDataToSectionBuffer(tempSplat, outBuffer, outBase, 0, 0); - } - } - - static parseToUncompressedSplatArraySection(chunkElement, vertexElement, fromIndex, toIndex, chunkSplatIndexOffset, - vertexDataBuffer, splatArray, propertyFilter = null) { - - PlayCanvasCompressedPlyParser.readElementData(vertexElement, vertexDataBuffer, 0, fromIndex, toIndex, propertyFilter); - - const { positionExtremes, scaleExtremes, colorExtremes, position, rotation, scale, color } = - PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, vertexElement); - - for (let i = fromIndex; i <= toIndex; ++i) { - const tempSplat = UncompressedSplatArray.createSplat(); - PlayCanvasCompressedPlyParser.decompressBaseSplat(i, chunkSplatIndexOffset, position, positionExtremes, - scale, scaleExtremes, rotation, colorExtremes, color, tempSplat); - splatArray.addSplat(tempSplat); - } - } - - static parseSphericalHarmonicsToUncompressedSplatArraySection(chunkElement, shElement, fromIndex, toIndex, - vertexDataBuffer, vertexReadOffset, outSphericalHarmonicsDegree, readSphericalHarmonicsDegree, splatArray, propertyFilter = null) { - - PlayCanvasCompressedPlyParser.readElementData(shElement, vertexDataBuffer, vertexReadOffset, fromIndex, toIndex, propertyFilter); - - const { sh } = PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, undefined, shElement); - const shArrays = Object.values(sh); - - for (let i = fromIndex; i <= toIndex; ++i) { - PlayCanvasCompressedPlyParser.decompressSphericalHarmonics( - i, shArrays, outSphericalHarmonicsDegree, readSphericalHarmonicsDegree, splatArray.splats[i] - ); - } - } - - static parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree) { - const { chunkElement, vertexElement, shElement, sphericalHarmonicsDegree } = PlayCanvasCompressedPlyParser.readPly(plyBuffer); - - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, sphericalHarmonicsDegree); - - const splatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree); - - const { positionExtremes, scaleExtremes, colorExtremes, position, rotation, scale, color } = - PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, vertexElement); - - let shArrays; - if (outSphericalHarmonicsDegree > 0) { - const { sh } = PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, undefined, shElement); - shArrays = Object.values(sh); - } - - for (let i = 0; i < vertexElement.count; ++i) { - - splatArray.addDefaultSplat(); - const newSplat = splatArray.getSplat(splatArray.splatCount - 1); - - PlayCanvasCompressedPlyParser.decompressBaseSplat(i, 0, position, positionExtremes, scale, - scaleExtremes, rotation, colorExtremes, color, newSplat); - - if (outSphericalHarmonicsDegree > 0) { - PlayCanvasCompressedPlyParser.decompressSphericalHarmonics( - i, shArrays, outSphericalHarmonicsDegree, sphericalHarmonicsDegree, newSplat - ); - } - } - - return splatArray; - } - - static parseToUncompressedSplatBuffer(plyBuffer, outSphericalHarmonicsDegree) { - const { chunkElement, vertexElement, shElement, sphericalHarmonicsDegree } = PlayCanvasCompressedPlyParser.readPly(plyBuffer); - - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, sphericalHarmonicsDegree); - - const { - splatBuffer, - splatBufferDataOffsetBytes - } = SplatBuffer.preallocateUncompressed(vertexElement.count, outSphericalHarmonicsDegree); - - const { positionExtremes, scaleExtremes, colorExtremes, position, rotation, scale, color } = - PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, vertexElement); - - let shArrays; - if (outSphericalHarmonicsDegree > 0) { - const { sh } = PlayCanvasCompressedPlyParser.getElementStorageArrays(chunkElement, undefined, shElement); - shArrays = Object.values(sh); - } - - const outBytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree].BytesPerSplat; - - const newSplat = UncompressedSplatArray.createSplat(outSphericalHarmonicsDegree); - - for (let i = 0; i < vertexElement.count; ++i) { - PlayCanvasCompressedPlyParser.decompressBaseSplat( - i, 0, position, positionExtremes, scale, scaleExtremes, rotation, colorExtremes, color, newSplat - ); - if (outSphericalHarmonicsDegree > 0) { - PlayCanvasCompressedPlyParser.decompressSphericalHarmonics( - i, shArrays, outSphericalHarmonicsDegree, sphericalHarmonicsDegree, newSplat - ); - } - - const outBase = i * outBytesPerSplat + splatBufferDataOffsetBytes; - SplatBuffer.writeSplatDataToSectionBuffer(newSplat, splatBuffer.bufferData, outBase, 0, outSphericalHarmonicsDegree); - } - - return splatBuffer; - } - - } - - const PlyFormat = { - 'INRIAV1': 0, - 'INRIAV2': 1, - 'PlayCanvasCompressed': 2 - }; - - const [ - FieldSizeIdDouble, FieldSizeIdInt, FieldSizeIdUInt, FieldSizeIdFloat, FieldSizeIdShort, FieldSizeIdUShort, FieldSizeIdUChar - ] = [0, 1, 2, 3, 4, 5, 6]; - - const FieldSizeStringMap = { - 'double': FieldSizeIdDouble, - 'int': FieldSizeIdInt, - 'uint': FieldSizeIdUInt, - 'float': FieldSizeIdFloat, - 'short': FieldSizeIdShort, - 'ushort': FieldSizeIdUShort, - 'uchar': FieldSizeIdUChar, - }; - - const FieldSize = { - [FieldSizeIdDouble]: 8, - [FieldSizeIdInt]: 4, - [FieldSizeIdUInt]: 4, - [FieldSizeIdFloat]: 4, - [FieldSizeIdShort]: 2, - [FieldSizeIdUShort]: 2, - [FieldSizeIdUChar]: 1, - }; - - class PlyParserUtils { - - static HeaderEndToken = 'end_header'; - - static decodeSectionHeader(headerLines, fieldNameIdMap, headerStartLine = 0) { - - const extractedLines = []; - - let processingSection = false; - let headerEndLine = -1; - let vertexCount = 0; - let endOfHeader = false; - let sectionName = null; - - const fieldIds = []; - const fieldTypes = []; - const allFieldNames = []; - const usedFieldNames = []; - const fieldTypesByName = {}; - - for (let i = headerStartLine; i < headerLines.length; i++) { - const line = headerLines[i].trim(); - if (line.startsWith('element')) { - if (processingSection) { - headerEndLine--; - break; - } else { - processingSection = true; - headerStartLine = i; - headerEndLine = i; - const lineComponents = line.split(' '); - let validComponents = 0; - for (let lineComponent of lineComponents) { - const trimmedComponent = lineComponent.trim(); - if (trimmedComponent.length > 0) { - validComponents++; - if (validComponents === 2) { - sectionName = trimmedComponent; - } else if (validComponents === 3) { - vertexCount = parseInt(trimmedComponent); - } - } - } - } - } else if (line.startsWith('property')) { - const fieldMatch = line.match(/(\w+)\s+(\w+)\s+(\w+)/); - if (fieldMatch) { - const fieldTypeStr = fieldMatch[2]; - const fieldName = fieldMatch[3]; - allFieldNames.push(fieldName); - const fieldId = fieldNameIdMap[fieldName]; - fieldTypesByName[fieldName] = fieldTypeStr; - const fieldType = FieldSizeStringMap[fieldTypeStr]; - if (fieldId !== undefined) { - usedFieldNames.push(fieldName); - fieldIds.push(fieldId); - fieldTypes[fieldId] = fieldType; - } - } - } - if (line === PlyParserUtils.HeaderEndToken) { - endOfHeader = true; - break; - } - if (processingSection) { - extractedLines.push(line); - headerEndLine++; - } - } - - const fieldOffsets = []; - let bytesPerVertex = 0; - for (let fieldName of allFieldNames) { - const fieldType = fieldTypesByName[fieldName]; - if (fieldTypesByName.hasOwnProperty(fieldName)) { - const fieldId = fieldNameIdMap[fieldName]; - if (fieldId !== undefined) { - fieldOffsets[fieldId] = bytesPerVertex; - } - } - bytesPerVertex += FieldSize[FieldSizeStringMap[fieldType]]; - } - - const sphericalHarmonics = PlyParserUtils.decodeSphericalHarmonicsFromSectionHeader(allFieldNames, fieldNameIdMap); - - return { - 'headerLines': extractedLines, - 'headerStartLine': headerStartLine, - 'headerEndLine': headerEndLine, - 'fieldTypes': fieldTypes, - 'fieldIds': fieldIds, - 'fieldOffsets': fieldOffsets, - 'bytesPerVertex': bytesPerVertex, - 'vertexCount': vertexCount, - 'dataSizeBytes': bytesPerVertex * vertexCount, - 'endOfHeader': endOfHeader, - 'sectionName': sectionName, - 'sphericalHarmonicsDegree': sphericalHarmonics.degree, - 'sphericalHarmonicsCoefficientsPerChannel': sphericalHarmonics.coefficientsPerChannel, - 'sphericalHarmonicsDegree1Fields': sphericalHarmonics.degree1Fields, - 'sphericalHarmonicsDegree2Fields': sphericalHarmonics.degree2Fields - }; - - } - - static decodeSphericalHarmonicsFromSectionHeader(fieldNames, fieldNameIdMap) { - let sphericalHarmonicsFieldCount = 0; - let coefficientsPerChannel = 0; - for (let fieldName of fieldNames) { - if (fieldName.startsWith('f_rest')) sphericalHarmonicsFieldCount++; - } - coefficientsPerChannel = sphericalHarmonicsFieldCount / 3; - let degree = 0; - if (coefficientsPerChannel >= 3) degree = 1; - if (coefficientsPerChannel >= 8) degree = 2; - - let degree1Fields = []; - let degree2Fields = []; - - for (let rgb = 0; rgb < 3; rgb++) { - if (degree >= 1) { - for (let i = 0; i < 3; i++) { - degree1Fields.push(fieldNameIdMap['f_rest_' + (i + coefficientsPerChannel * rgb)]); - } - } - if (degree >= 2) { - for (let i = 0; i < 5; i++) { - degree2Fields.push(fieldNameIdMap['f_rest_' + (i + coefficientsPerChannel * rgb + 3)]); - } - } - } - - return { - 'degree': degree, - 'coefficientsPerChannel': coefficientsPerChannel, - 'degree1Fields': degree1Fields, - 'degree2Fields': degree2Fields - }; - } - - static getHeaderSectionNames(headerLines) { - const sectionNames = []; - for (let headerLine of headerLines) { - if (headerLine.startsWith('element')) { - const lineComponents = headerLine.split(' '); - let validComponents = 0; - for (let lineComponent of lineComponents) { - const trimmedComponent = lineComponent.trim(); - if (trimmedComponent.length > 0) { - validComponents++; - if (validComponents === 2) { - sectionNames.push(trimmedComponent); - } - } - } - } - } - return sectionNames; - } - - static checkTextForEndHeader(endHeaderTestText) { - if (endHeaderTestText.includes(PlyParserUtils.HeaderEndToken)) { - return true; - } - return false; - } - - static checkBufferForEndHeader(buffer, searchOfset, chunkSize, decoder) { - const endHeaderTestChunk = new Uint8Array(buffer, Math.max(0, searchOfset - chunkSize), chunkSize); - const endHeaderTestText = decoder.decode(endHeaderTestChunk); - return PlyParserUtils.checkTextForEndHeader(endHeaderTestText); - } - - static extractHeaderFromBufferToText(plyBuffer) { - const decoder = new TextDecoder(); - let headerOffset = 0; - let headerText = ''; - const readChunkSize = 100; - - while (true) { - if (headerOffset + readChunkSize >= plyBuffer.byteLength) { - throw new Error('End of file reached while searching for end of header'); - } - const headerChunk = new Uint8Array(plyBuffer, headerOffset, readChunkSize); - headerText += decoder.decode(headerChunk); - headerOffset += readChunkSize; - - if (PlyParserUtils.checkBufferForEndHeader(plyBuffer, headerOffset, readChunkSize * 2, decoder)) { - break; - } - } - - return headerText; - } - - static readHeaderFromBuffer(plyBuffer) { - const decoder = new TextDecoder(); - let headerOffset = 0; - let headerText = ''; - const readChunkSize = 100; - - while (true) { - if (headerOffset + readChunkSize >= plyBuffer.byteLength) { - throw new Error('End of file reached while searching for end of header'); - } - const headerChunk = new Uint8Array(plyBuffer, headerOffset, readChunkSize); - headerText += decoder.decode(headerChunk); - headerOffset += readChunkSize; - - if (PlyParserUtils.checkBufferForEndHeader(plyBuffer, headerOffset, readChunkSize * 2, decoder)) { - break; - } - } - - return headerText; - } - - static convertHeaderTextToLines(headerText) { - const headerLines = headerText.split('\n'); - const prunedLines = []; - for (let i = 0; i < headerLines.length; i++) { - const line = headerLines[i].trim(); - prunedLines.push(line); - if (line === PlyParserUtils.HeaderEndToken) { - break; - } - } - return prunedLines; - } - - static determineHeaderFormatFromHeaderText(headertText) { - const headerLines = PlyParserUtils.convertHeaderTextToLines(headertText); - let format = PlyFormat.INRIAV1; - for (let i = 0; i < headerLines.length; i++) { - const line = headerLines[i].trim(); - if (line.startsWith('element chunk') || line.match(/[A-Za-z]*packed_[A-Za-z]*/)) { - format = PlyFormat.PlayCanvasCompressed; - } else if (line.startsWith('element codebook_centers')) { - format = PlyFormat.INRIAV2; - } else if (line === PlyParserUtils.HeaderEndToken) { - break; - } - } - return format; - } - - static determineHeaderFormatFromPlyBuffer(plyBuffer) { - const headertText = PlyParserUtils.extractHeaderFromBufferToText(plyBuffer); - return PlyParserUtils.determineHeaderFormatFromHeaderText(headertText); - } - - static readVertex(vertexData, header, row, dataOffset, fieldsToRead, rawVertex, normalize = true) { - const offset = row * header.bytesPerVertex + dataOffset; - const fieldOffsets = header.fieldOffsets; - const fieldTypes = header.fieldTypes; - for (let fieldId of fieldsToRead) { - const fieldType = fieldTypes[fieldId]; - if (fieldType === FieldSizeIdFloat) { - rawVertex[fieldId] = vertexData.getFloat32(offset + fieldOffsets[fieldId], true); - } else if (fieldType === FieldSizeIdShort) { - rawVertex[fieldId] = vertexData.getInt16(offset + fieldOffsets[fieldId], true); - } else if (fieldType === FieldSizeIdUShort) { - rawVertex[fieldId] = vertexData.getUint16(offset + fieldOffsets[fieldId], true); - } else if (fieldType === FieldSizeIdInt) { - rawVertex[fieldId] = vertexData.getInt32(offset + fieldOffsets[fieldId], true); - } else if (fieldType === FieldSizeIdUInt) { - rawVertex[fieldId] = vertexData.getUint32(offset + fieldOffsets[fieldId], true); - } else if (fieldType === FieldSizeIdUChar) { - if (normalize) { - rawVertex[fieldId] = vertexData.getUint8(offset + fieldOffsets[fieldId]) / 255.0; - } else { - rawVertex[fieldId] = vertexData.getUint8(offset + fieldOffsets[fieldId]); - } - } - } - } - } - - const BaseFieldNamesToRead = ['scale_0', 'scale_1', 'scale_2', 'rot_0', 'rot_1', 'rot_2', 'rot_3', 'x', 'y', 'z', - 'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity', 'red', 'green', 'blue', 'f_rest_0']; - - const BaseFieldsToReadIndexes = BaseFieldNamesToRead.map((e, i) => i); - - const [ - SCALE_0, SCALE_1, SCALE_2, ROT_0, ROT_1, ROT_2, ROT_3, X, Y, Z, F_DC_0, F_DC_1, F_DC_2, OPACITY, RED$1, GREEN$1, BLUE$1, F_REST_0 - ] = BaseFieldsToReadIndexes; - - class INRIAV1PlyParser { - - static decodeHeaderLines(headerLines) { - - let shLineCount = 0; - headerLines.forEach((line) => { - if (line.includes('f_rest_')) shLineCount++; - }); - - let shFieldsToReadCount = 0; - if (shLineCount >= 45) { - shFieldsToReadCount = 45; - } else if (shLineCount >= 24) { - shFieldsToReadCount = 24; - } else if (shLineCount >= 9) { - shFieldsToReadCount = 9; - } - - const shFieldIndexesToMap = Array.from(Array(Math.max(shFieldsToReadCount - 1, 0))); - let shRemainingFieldNamesToRead = shFieldIndexesToMap.map((element, index) => `f_rest_${index + 1}`); - - const fieldNamesToRead = [...BaseFieldNamesToRead, ...shRemainingFieldNamesToRead]; - const fieldsToReadIndexes = fieldNamesToRead.map((e, i) => i); - - const fieldNameIdMap = fieldsToReadIndexes.reduce((acc, element) => { - acc[fieldNamesToRead[element]] = element; - return acc; - }, {}); - const header = PlyParserUtils.decodeSectionHeader(headerLines, fieldNameIdMap, 0); - header.splatCount = header.vertexCount; - header.bytesPerSplat = header.bytesPerVertex; - header.fieldsToReadIndexes = fieldsToReadIndexes; - return header; - } - - static decodeHeaderText(headerText) { - const headerLines = PlyParserUtils.convertHeaderTextToLines(headerText); - const header = INRIAV1PlyParser.decodeHeaderLines(headerLines); - header.headerText = headerText; - header.headerSizeBytes = headerText.indexOf(PlyParserUtils.HeaderEndToken) + PlyParserUtils.HeaderEndToken.length + 1; - return header; - } - - static decodeHeaderFromBuffer(plyBuffer) { - const headerText = PlyParserUtils.readHeaderFromBuffer(plyBuffer); - return INRIAV1PlyParser.decodeHeaderText(headerText); - } - - static findSplatData(plyBuffer, header) { - return new DataView(plyBuffer, header.headerSizeBytes); - } - - static parseToUncompressedSplatBufferSection(header, fromSplat, toSplat, splatData, splatDataOffset, - toBuffer, toOffset, outSphericalHarmonicsDegree = 0) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree); - const outBytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree].BytesPerSplat; - - for (let i = fromSplat; i <= toSplat; i++) { - const parsedSplat = INRIAV1PlyParser.parseToUncompressedSplat(splatData, i, header, - splatDataOffset, outSphericalHarmonicsDegree); - const outBase = i * outBytesPerSplat + toOffset; - SplatBuffer.writeSplatDataToSectionBuffer(parsedSplat, toBuffer, outBase, 0, outSphericalHarmonicsDegree); - } - } - - static parseToUncompressedSplatArraySection(header, fromSplat, toSplat, splatData, splatDataOffset, - splatArray, outSphericalHarmonicsDegree = 0) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree); - for (let i = fromSplat; i <= toSplat; i++) { - const parsedSplat = INRIAV1PlyParser.parseToUncompressedSplat(splatData, i, header, - splatDataOffset, outSphericalHarmonicsDegree); - splatArray.addSplat(parsedSplat); - } - } - - static decodeSectionSplatData(sectionSplatData, splatCount, sectionHeader, outSphericalHarmonicsDegree, toSplatArray = true) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, sectionHeader.sphericalHarmonicsDegree); - if (toSplatArray) { - const splatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree); - for (let row = 0; row < splatCount; row++) { - const newSplat = INRIAV1PlyParser.parseToUncompressedSplat(sectionSplatData, row, sectionHeader, - 0, outSphericalHarmonicsDegree); - splatArray.addSplat(newSplat); - } - return splatArray; - } else { - const { - splatBuffer, - splatBufferDataOffsetBytes - } = SplatBuffer.preallocateUncompressed(splatCount, outSphericalHarmonicsDegree); - INRIAV1PlyParser.parseToUncompressedSplatBufferSection( - sectionHeader, 0, splatCount - 1, sectionSplatData, 0, - splatBuffer.bufferData, splatBufferDataOffsetBytes, outSphericalHarmonicsDegree - ); - return splatBuffer; - } - } - - static parseToUncompressedSplat = function() { - - let rawSplat = []; - const tempRotation = new THREE__namespace.Quaternion(); - - const OFFSET_X = UncompressedSplatArray.OFFSET.X; - const OFFSET_Y = UncompressedSplatArray.OFFSET.Y; - const OFFSET_Z = UncompressedSplatArray.OFFSET.Z; - - const OFFSET_SCALE0 = UncompressedSplatArray.OFFSET.SCALE0; - const OFFSET_SCALE1 = UncompressedSplatArray.OFFSET.SCALE1; - const OFFSET_SCALE2 = UncompressedSplatArray.OFFSET.SCALE2; - - const OFFSET_ROTATION0 = UncompressedSplatArray.OFFSET.ROTATION0; - const OFFSET_ROTATION1 = UncompressedSplatArray.OFFSET.ROTATION1; - const OFFSET_ROTATION2 = UncompressedSplatArray.OFFSET.ROTATION2; - const OFFSET_ROTATION3 = UncompressedSplatArray.OFFSET.ROTATION3; - - const OFFSET_FDC0 = UncompressedSplatArray.OFFSET.FDC0; - const OFFSET_FDC1 = UncompressedSplatArray.OFFSET.FDC1; - const OFFSET_FDC2 = UncompressedSplatArray.OFFSET.FDC2; - const OFFSET_OPACITY = UncompressedSplatArray.OFFSET.OPACITY; - - const OFFSET_FRC = []; - - for (let i = 0; i < 45; i++) { - OFFSET_FRC[i] = UncompressedSplatArray.OFFSET.FRC0 + i; - } - - return function(splatData, row, header, splatDataOffset = 0, outSphericalHarmonicsDegree = 0) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree); - INRIAV1PlyParser.readSplat(splatData, header, row, splatDataOffset, rawSplat); - const newSplat = UncompressedSplatArray.createSplat(outSphericalHarmonicsDegree); - if (rawSplat[SCALE_0] !== undefined) { - newSplat[OFFSET_SCALE0] = Math.exp(rawSplat[SCALE_0]); - newSplat[OFFSET_SCALE1] = Math.exp(rawSplat[SCALE_1]); - newSplat[OFFSET_SCALE2] = Math.exp(rawSplat[SCALE_2]); - } else { - newSplat[OFFSET_SCALE0] = 0.01; - newSplat[OFFSET_SCALE1] = 0.01; - newSplat[OFFSET_SCALE2] = 0.01; - } - - if (rawSplat[F_DC_0] !== undefined) { - const SH_C0 = 0.28209479177387814; - newSplat[OFFSET_FDC0] = (0.5 + SH_C0 * rawSplat[F_DC_0]) * 255; - newSplat[OFFSET_FDC1] = (0.5 + SH_C0 * rawSplat[F_DC_1]) * 255; - newSplat[OFFSET_FDC2] = (0.5 + SH_C0 * rawSplat[F_DC_2]) * 255; - } else if (rawSplat[RED$1] !== undefined) { - newSplat[OFFSET_FDC0] = rawSplat[RED$1] * 255; - newSplat[OFFSET_FDC1] = rawSplat[GREEN$1] * 255; - newSplat[OFFSET_FDC2] = rawSplat[BLUE$1] * 255; - } else { - newSplat[OFFSET_FDC0] = 0; - newSplat[OFFSET_FDC1] = 0; - newSplat[OFFSET_FDC2] = 0; - } - - if (rawSplat[OPACITY] !== undefined) { - newSplat[OFFSET_OPACITY] = (1 / (1 + Math.exp(-rawSplat[OPACITY]))) * 255; - } - - newSplat[OFFSET_FDC0] = clamp(Math.floor(newSplat[OFFSET_FDC0]), 0, 255); - newSplat[OFFSET_FDC1] = clamp(Math.floor(newSplat[OFFSET_FDC1]), 0, 255); - newSplat[OFFSET_FDC2] = clamp(Math.floor(newSplat[OFFSET_FDC2]), 0, 255); - newSplat[OFFSET_OPACITY] = clamp(Math.floor(newSplat[OFFSET_OPACITY]), 0, 255); - - if (outSphericalHarmonicsDegree >= 1) { - if (rawSplat[F_REST_0] !== undefined) { - for (let i = 0; i < 9; i++) { - newSplat[OFFSET_FRC[i]] = rawSplat[header.sphericalHarmonicsDegree1Fields[i]]; - } - if (outSphericalHarmonicsDegree >= 2) { - for (let i = 0; i < 15; i++) { - newSplat[OFFSET_FRC[9 + i]] = rawSplat[header.sphericalHarmonicsDegree2Fields[i]]; - } - } - } - } - - tempRotation.set(rawSplat[ROT_0], rawSplat[ROT_1], rawSplat[ROT_2], rawSplat[ROT_3]); - tempRotation.normalize(); - - newSplat[OFFSET_ROTATION0] = tempRotation.x; - newSplat[OFFSET_ROTATION1] = tempRotation.y; - newSplat[OFFSET_ROTATION2] = tempRotation.z; - newSplat[OFFSET_ROTATION3] = tempRotation.w; - - newSplat[OFFSET_X] = rawSplat[X]; - newSplat[OFFSET_Y] = rawSplat[Y]; - newSplat[OFFSET_Z] = rawSplat[Z]; - - return newSplat; - }; - - }(); - - static readSplat(splatData, header, row, dataOffset, rawSplat) { - return PlyParserUtils.readVertex(splatData, header, row, dataOffset, header.fieldsToReadIndexes, rawSplat, true); - } - - static parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree = 0) { - const { header, splatCount, splatData } = separatePlyHeaderAndData(plyBuffer); - return INRIAV1PlyParser.decodeSectionSplatData(splatData, splatCount, header, outSphericalHarmonicsDegree, true); - } - - static parseToUncompressedSplatBuffer(plyBuffer, outSphericalHarmonicsDegree = 0) { - const { header, splatCount, splatData } = separatePlyHeaderAndData(plyBuffer); - return INRIAV1PlyParser.decodeSectionSplatData(splatData, splatCount, header, outSphericalHarmonicsDegree, false); - } - } - - function separatePlyHeaderAndData(plyBuffer) { - const header = INRIAV1PlyParser.decodeHeaderFromBuffer(plyBuffer); - const splatCount = header.splatCount; - const splatData = INRIAV1PlyParser.findSplatData(plyBuffer, header); - return { - header, - splatCount, - splatData - }; - } - - const CodeBookEntryNamesToRead = [ - 'features_dc', 'features_rest_0', 'features_rest_1', 'features_rest_2', 'features_rest_3', 'features_rest_4', 'features_rest_5', - 'features_rest_6', 'features_rest_7', 'features_rest_8', 'features_rest_9', 'features_rest_10', 'features_rest_11', 'features_rest_12', - 'features_rest_13', 'features_rest_14', 'opacity', 'scaling', 'rotation_re', 'rotation_im' - ]; - const CodeBookEntriesToReadIndexes = CodeBookEntryNamesToRead.map((e, i) => i); - - const [ - CB_FEATURES_DC, CB_FEATURES_REST_0, CB_FEATURES_REST_3, CB_OPACITY, CB_SCALING, CB_ROTATION_RE, CB_ROTATION_IM - ] = [0, 1, 4, 16, 17, 18, 19]; - - const FieldNamesToRead = ['scale_0', 'scale_1', 'scale_2', 'rot_0', 'rot_1', 'rot_2', 'rot_3', - 'x', 'y', 'z', 'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity', 'red', 'green', 'blue', - 'f_rest_0', 'f_rest_1', 'f_rest_2', 'f_rest_3', 'f_rest_4', 'f_rest_5', 'f_rest_6', 'f_rest_7', 'f_rest_8', - 'f_rest_9', 'f_rest_10', 'f_rest_11', 'f_rest_12', 'f_rest_13', 'f_rest_14', 'f_rest_15', 'f_rest_16', - 'f_rest_17', 'f_rest_18', 'f_rest_19', 'f_rest_20', 'f_rest_21', 'f_rest_22', 'f_rest_23', 'f_rest_24', - 'f_rest_25', 'f_rest_26', 'f_rest_27', 'f_rest_28', 'f_rest_29', 'f_rest_30', 'f_rest_31', 'f_rest_32', - 'f_rest_33', 'f_rest_34', 'f_rest_35', 'f_rest_36', 'f_rest_37', 'f_rest_38', 'f_rest_39', 'f_rest_40', - 'f_rest_41', 'f_rest_42', 'f_rest_43', 'f_rest_44', 'f_rest_45' - ]; - const FieldsToReadIndexes = FieldNamesToRead.map((e, i) => i); - - const [ - PLY_SCALE_0, PLY_SCALE_1, PLY_SCALE_2, PLY_ROT_0, PLY_ROT_1, PLY_ROT_2, PLY_ROT_3, PLY_X, PLY_Y, PLY_Z, - PLY_F_DC_0, PLY_F_DC_1, PLY_F_DC_2, PLY_OPACITY, - ] = FieldsToReadIndexes; - - const PLY_RED = PLY_F_DC_0; - const PLY_GREEN = PLY_F_DC_1; - const PLY_BLUE = PLY_F_DC_2; - - const fromHalfFloat = (hf) =>{ - const t = (31744 & hf) >> 10; - const a = 1023 & hf; - return (hf >> 15 ? -1 : 1)*(t ? t === 31 ? a ? NaN : 1/0 : Math.pow(2, t - 15) *( 1 + a / 1024) : a / 1024*6103515625e-14); - }; - - class INRIAV2PlyParser { - - static decodeSectionHeadersFromHeaderLines(headerLines) { - const fieldNameIdMap = FieldsToReadIndexes.reduce((acc, element) => { - acc[FieldNamesToRead[element]] = element; - return acc; - }, {}); - - const codeBookEntriesToReadIdMap = CodeBookEntriesToReadIndexes.reduce((acc, element) => { - acc[CodeBookEntryNamesToRead[element]] = element; - return acc; - }, {}); - - const sectionNames = PlyParserUtils.getHeaderSectionNames(headerLines); - let codeBookSectionIndex; - for (let s = 0; s < sectionNames.length; s++) { - const sectionName = sectionNames[s]; - if (sectionName === 'codebook_centers') { - codeBookSectionIndex = s; - } - } - - let currentStartLine = 0; - let lastSectionFound = false; - const sectionHeaders = []; - let sectionIndex = 0; - while (!lastSectionFound) { - let sectionHeader; - if (sectionIndex === codeBookSectionIndex) { - sectionHeader = PlyParserUtils.decodeSectionHeader(headerLines, codeBookEntriesToReadIdMap, currentStartLine); - } else { - sectionHeader = PlyParserUtils.decodeSectionHeader(headerLines, fieldNameIdMap, currentStartLine); - } - lastSectionFound = sectionHeader.endOfHeader; - currentStartLine = sectionHeader.headerEndLine + 1; - if (!lastSectionFound) { - sectionHeader.splatCount = sectionHeader.vertexCount; - sectionHeader.bytesPerSplat = sectionHeader.bytesPerVertex; - } - sectionHeaders.push(sectionHeader); - sectionIndex++; - } - return sectionHeaders; - } - - static decodeSectionHeadersFromHeaderText(headerText) { - const headerLines = PlyParserUtils.convertHeaderTextToLines(headerText); - return INRIAV2PlyParser.decodeSectionHeadersFromHeaderLines(headerLines); - } - - static getSplatCountFromSectionHeaders(sectionHeaders) { - let splatCount = 0; - for (let sectionHeader of sectionHeaders) { - if (sectionHeader.sectionName !== 'codebook_centers') { - splatCount += sectionHeader.vertexCount; - } - } - return splatCount; - } - - static decodeHeaderFromHeaderText(headerText) { - const headerSizeBytes = headerText.indexOf(PlyParserUtils.HeaderEndToken) + PlyParserUtils.HeaderEndToken.length + 1; - const sectionHeaders = INRIAV2PlyParser.decodeSectionHeadersFromHeaderText(headerText); - const splatCount = INRIAV2PlyParser.getSplatCountFromSectionHeaders(sectionHeaders); - return { - 'headerSizeBytes': headerSizeBytes, - 'sectionHeaders': sectionHeaders, - 'splatCount': splatCount - }; - } - - static decodeHeaderFromBuffer(plyBuffer) { - const headerText = PlyParserUtils.readHeaderFromBuffer(plyBuffer); - return INRIAV2PlyParser.decodeHeaderFromHeaderText(headerText); - } - - static findVertexData(plyBuffer, header, targetSection) { - let byteOffset = header.headerSizeBytes; - for (let s = 0; s < targetSection && s < header.sectionHeaders.length; s++) { - const sectionHeader = header.sectionHeaders[s]; - byteOffset += sectionHeader.dataSizeBytes; - } - return new DataView(plyBuffer, byteOffset, header.sectionHeaders[targetSection].dataSizeBytes); - } - - static decodeCodeBook(codeBookData, sectionHeader) { - - const rawVertex = []; - const codeBook = []; - for (let row = 0; row < sectionHeader.vertexCount; row++) { - PlyParserUtils.readVertex(codeBookData, sectionHeader, row, 0, CodeBookEntriesToReadIndexes, rawVertex); - for (let index of CodeBookEntriesToReadIndexes) { - const codeBookElementOffset = CodeBookEntriesToReadIndexes[index]; - let codeBookPage = codeBook[codeBookElementOffset]; - if (!codeBookPage) { - codeBook[codeBookElementOffset] = codeBookPage = []; - } - codeBookPage.push(rawVertex[index]); - } - } - for (let page = 0; page < codeBook.length; page++) { - const codeBookPage = codeBook[page]; - const SH_C0 = 0.28209479177387814; - for (let i = 0; i < codeBookPage.length; i++) { - const baseValue = fromHalfFloat(codeBookPage[i]); - if (page === CB_OPACITY) { - codeBookPage[i] = Math.round((1 / (1 + Math.exp(-baseValue))) * 255); - } else if (page === CB_FEATURES_DC) { - codeBookPage[i] = Math.round((0.5 + SH_C0 * baseValue) * 255); - } else if (page === CB_SCALING) { - codeBookPage[i] = Math.exp(baseValue); - } else { - codeBookPage[i] = baseValue; - } - } - } - return codeBook; - } - - static decodeSectionSplatData(sectionSplatData, splatCount, sectionHeader, codeBook, outSphericalHarmonicsDegree) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, sectionHeader.sphericalHarmonicsDegree); - const splatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree); - for (let row = 0; row < splatCount; row++) { - const newSplat = INRIAV2PlyParser.parseToUncompressedSplat(sectionSplatData, row, sectionHeader, codeBook, - 0, outSphericalHarmonicsDegree); - splatArray.addSplat(newSplat); - } - return splatArray; - } - - static parseToUncompressedSplat = function() { - - let rawSplat = []; - const tempRotation = new THREE__namespace.Quaternion(); - - const OFFSET_X = UncompressedSplatArray.OFFSET.X; - const OFFSET_Y = UncompressedSplatArray.OFFSET.Y; - const OFFSET_Z = UncompressedSplatArray.OFFSET.Z; - - const OFFSET_SCALE0 = UncompressedSplatArray.OFFSET.SCALE0; - const OFFSET_SCALE1 = UncompressedSplatArray.OFFSET.SCALE1; - const OFFSET_SCALE2 = UncompressedSplatArray.OFFSET.SCALE2; - - const OFFSET_ROTATION0 = UncompressedSplatArray.OFFSET.ROTATION0; - const OFFSET_ROTATION1 = UncompressedSplatArray.OFFSET.ROTATION1; - const OFFSET_ROTATION2 = UncompressedSplatArray.OFFSET.ROTATION2; - const OFFSET_ROTATION3 = UncompressedSplatArray.OFFSET.ROTATION3; - - const OFFSET_FDC0 = UncompressedSplatArray.OFFSET.FDC0; - const OFFSET_FDC1 = UncompressedSplatArray.OFFSET.FDC1; - const OFFSET_FDC2 = UncompressedSplatArray.OFFSET.FDC2; - const OFFSET_OPACITY = UncompressedSplatArray.OFFSET.OPACITY; - - const OFFSET_FRC = []; - - for (let i = 0; i < 45; i++) { - OFFSET_FRC[i] = UncompressedSplatArray.OFFSET.FRC0 + i; - } - - return function(splatData, row, header, codeBook, splatDataOffset = 0, outSphericalHarmonicsDegree = 0) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree); - INRIAV2PlyParser.readSplat(splatData, header, row, splatDataOffset, rawSplat); - const newSplat = UncompressedSplatArray.createSplat(outSphericalHarmonicsDegree); - if (rawSplat[PLY_SCALE_0] !== undefined) { - newSplat[OFFSET_SCALE0] = codeBook[CB_SCALING][rawSplat[PLY_SCALE_0]]; - newSplat[OFFSET_SCALE1] = codeBook[CB_SCALING][rawSplat[PLY_SCALE_1]]; - newSplat[OFFSET_SCALE2] = codeBook[CB_SCALING][rawSplat[PLY_SCALE_2]]; - } else { - newSplat[OFFSET_SCALE0] = 0.01; - newSplat[OFFSET_SCALE1] = 0.01; - newSplat[OFFSET_SCALE2] = 0.01; - } - - if (rawSplat[PLY_F_DC_0] !== undefined) { - newSplat[OFFSET_FDC0] = codeBook[CB_FEATURES_DC][rawSplat[PLY_F_DC_0]]; - newSplat[OFFSET_FDC1] = codeBook[CB_FEATURES_DC][rawSplat[PLY_F_DC_1]]; - newSplat[OFFSET_FDC2] = codeBook[CB_FEATURES_DC][rawSplat[PLY_F_DC_2]]; - } else if (rawSplat[PLY_RED] !== undefined) { - newSplat[OFFSET_FDC0] = rawSplat[PLY_RED] * 255; - newSplat[OFFSET_FDC1] = rawSplat[PLY_GREEN] * 255; - newSplat[OFFSET_FDC2] = rawSplat[PLY_BLUE] * 255; - } else { - newSplat[OFFSET_FDC0] = 0; - newSplat[OFFSET_FDC1] = 0; - newSplat[OFFSET_FDC2] = 0; - } - - if (rawSplat[PLY_OPACITY] !== undefined) { - newSplat[OFFSET_OPACITY] = codeBook[CB_OPACITY][rawSplat[PLY_OPACITY]]; - } - - newSplat[OFFSET_FDC0] = clamp(Math.floor(newSplat[OFFSET_FDC0]), 0, 255); - newSplat[OFFSET_FDC1] = clamp(Math.floor(newSplat[OFFSET_FDC1]), 0, 255); - newSplat[OFFSET_FDC2] = clamp(Math.floor(newSplat[OFFSET_FDC2]), 0, 255); - newSplat[OFFSET_OPACITY] = clamp(Math.floor(newSplat[OFFSET_OPACITY]), 0, 255); - - if (outSphericalHarmonicsDegree >= 1 && header.sphericalHarmonicsDegree >= 1) { - for (let i = 0; i < 9; i++) { - const codeBookPage = codeBook[CB_FEATURES_REST_0 + i % 3]; - newSplat[OFFSET_FRC[i]] = codeBookPage[rawSplat[header.sphericalHarmonicsDegree1Fields[i]]]; - } - if (outSphericalHarmonicsDegree >= 2 && header.sphericalHarmonicsDegree >= 2) { - for (let i = 0; i < 15; i++) { - const codeBookPage = codeBook[CB_FEATURES_REST_3 + i % 5]; - newSplat[OFFSET_FRC[9 + i]] = codeBookPage[rawSplat[header.sphericalHarmonicsDegree2Fields[i]]]; - } - } - } - - const rot0 = codeBook[CB_ROTATION_RE][rawSplat[PLY_ROT_0]]; - const rot1 = codeBook[CB_ROTATION_IM][rawSplat[PLY_ROT_1]]; - const rot2 = codeBook[CB_ROTATION_IM][rawSplat[PLY_ROT_2]]; - const rot3 = codeBook[CB_ROTATION_IM][rawSplat[PLY_ROT_3]]; - tempRotation.set(rot0, rot1, rot2, rot3); - tempRotation.normalize(); - - newSplat[OFFSET_ROTATION0] = tempRotation.x; - newSplat[OFFSET_ROTATION1] = tempRotation.y; - newSplat[OFFSET_ROTATION2] = tempRotation.z; - newSplat[OFFSET_ROTATION3] = tempRotation.w; - - newSplat[OFFSET_X] = fromHalfFloat(rawSplat[PLY_X]); - newSplat[OFFSET_Y] = fromHalfFloat(rawSplat[PLY_Y]); - newSplat[OFFSET_Z] = fromHalfFloat(rawSplat[PLY_Z]); - - return newSplat; - }; - - }(); - - static readSplat(splatData, header, row, dataOffset, rawSplat) { - return PlyParserUtils.readVertex(splatData, header, row, dataOffset, FieldsToReadIndexes, rawSplat, false); - } - - static parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree = 0) { - const splatArrays = []; - const header = INRIAV2PlyParser.decodeHeaderFromBuffer(plyBuffer, outSphericalHarmonicsDegree); - let codeBook; - - for (let s = 0; s < header.sectionHeaders.length; s++) { - const sectionHeader = header.sectionHeaders[s]; - if (sectionHeader.sectionName === 'codebook_centers') { - const codeBookData = INRIAV2PlyParser.findVertexData(plyBuffer, header, s); - codeBook = INRIAV2PlyParser.decodeCodeBook(codeBookData, sectionHeader); - } - } - for (let s = 0; s < header.sectionHeaders.length; s++) { - const sectionHeader = header.sectionHeaders[s]; - if (sectionHeader.sectionName !== 'codebook_centers') { - const splatCount = sectionHeader.vertexCount; - const vertexData = INRIAV2PlyParser.findVertexData(plyBuffer, header, s); - const splatArray = INRIAV2PlyParser.decodeSectionSplatData(vertexData, splatCount, sectionHeader, - codeBook, outSphericalHarmonicsDegree); - splatArrays.push(splatArray); - } - } - - const unified = new UncompressedSplatArray(outSphericalHarmonicsDegree); - for (let splatArray of splatArrays) { - for (let splat of splatArray.splats) { - unified.addSplat(splat); - } - } - - return unified; - } - } - - class PlyParser { - - static parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree = 0) { - const plyFormat = PlyParserUtils.determineHeaderFormatFromPlyBuffer(plyBuffer); - if (plyFormat === PlyFormat.PlayCanvasCompressed) { - return PlayCanvasCompressedPlyParser.parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree); - } else if (plyFormat === PlyFormat.INRIAV1) { - return INRIAV1PlyParser.parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree); - } else if (plyFormat === PlyFormat.INRIAV2) { - return INRIAV2PlyParser.parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree); - } - } - - static parseToUncompressedSplatBuffer(plyBuffer, outSphericalHarmonicsDegree = 0) { - const plyFormat = PlyParserUtils.determineHeaderFormatFromPlyBuffer(plyBuffer); - if (plyFormat === PlyFormat.PlayCanvasCompressed) { - return PlayCanvasCompressedPlyParser.parseToUncompressedSplatBuffer(plyBuffer, outSphericalHarmonicsDegree); - } else if (plyFormat === PlyFormat.INRIAV1) { - return INRIAV1PlyParser.parseToUncompressedSplatBuffer(plyBuffer, outSphericalHarmonicsDegree); - } else if (plyFormat === PlyFormat.INRIAV2) { - // TODO: Implement! - throw new Error('parseToUncompressedSplatBuffer() is not implemented for INRIA V2 PLY files'); - } - } - - } - - class SplatPartitioner { - - constructor(sectionCount, sectionFilters, groupingParameters, partitionGenerator) { - this.sectionCount = sectionCount; - this.sectionFilters = sectionFilters; - this.groupingParameters = groupingParameters; - this.partitionGenerator = partitionGenerator; - } - - partitionUncompressedSplatArray(splatArray) { - let groupingParameters; - let sectionCount; - let sectionFilters; - if (this.partitionGenerator) { - const results = this.partitionGenerator(splatArray); - groupingParameters = results.groupingParameters; - sectionCount = results.sectionCount; - sectionFilters = results.sectionFilters; - } else { - groupingParameters = this.groupingParameters; - sectionCount = this.sectionCount; - sectionFilters = this.sectionFilters; - } - - const newArrays = []; - for (let s = 0; s < sectionCount; s++) { - const sectionSplats = new UncompressedSplatArray(splatArray.sphericalHarmonicsDegree); - const sectionFilter = sectionFilters[s]; - for (let i = 0; i < splatArray.splatCount; i++) { - if (sectionFilter(i)) { - sectionSplats.addSplat(splatArray.splats[i]); - } - } - newArrays.push(sectionSplats); - } - return { - splatArrays: newArrays, - parameters: groupingParameters - }; - } - - static getStandardPartitioner(partitionSize = 0, sceneCenter = new THREE__namespace.Vector3(), - blockSize = SplatBuffer.BucketBlockSize, bucketSize = SplatBuffer.BucketSize) { - - const partitionGenerator = (splatArray) => { - - const OFFSET_X = UncompressedSplatArray.OFFSET.X; - const OFFSET_Y = UncompressedSplatArray.OFFSET.Y; - const OFFSET_Z = UncompressedSplatArray.OFFSET.Z; - - if (partitionSize <= 0) partitionSize = splatArray.splatCount; - - const center = new THREE__namespace.Vector3(); - const clampDistance = 0.5; - const clampPoint = (point) => { - point.x = Math.floor(point.x / clampDistance) * clampDistance; - point.y = Math.floor(point.y / clampDistance) * clampDistance; - point.z = Math.floor(point.z / clampDistance) * clampDistance; - }; - splatArray.splats.forEach((splat) => { - center.set(splat[OFFSET_X], splat[OFFSET_Y], splat[OFFSET_Z]).sub(sceneCenter); - clampPoint(center); - splat.centerDist = center.lengthSq(); - }); - splatArray.splats.sort((a, b) => { - let centerADist = a.centerDist; - let centerBDist = b.centerDist; - if (centerADist > centerBDist) return 1; - else return -1; - }); - - const sectionFilters = []; - const groupingParameters = []; - partitionSize = Math.min(splatArray.splatCount, partitionSize); - const patitionCount = Math.ceil(splatArray.splatCount / partitionSize); - let currentStartSplat = 0; - for (let i = 0; i < patitionCount; i ++) { - let startSplat = currentStartSplat; - sectionFilters.push((splatIndex) => { - return splatIndex >= startSplat && splatIndex < startSplat + partitionSize; - }); - groupingParameters.push({ - 'blocksSize': blockSize, - 'bucketSize': bucketSize, - }); - currentStartSplat += partitionSize; - } - return { - 'sectionCount': sectionFilters.length, - sectionFilters, - groupingParameters - }; - }; - return new SplatPartitioner(undefined, undefined, undefined, partitionGenerator); - } - } - - class SplatBufferGenerator { - - constructor(splatPartitioner, alphaRemovalThreshold, compressionLevel, sectionSize, sceneCenter, blockSize, bucketSize) { - this.splatPartitioner = splatPartitioner; - this.alphaRemovalThreshold = alphaRemovalThreshold; - this.compressionLevel = compressionLevel; - this.sectionSize = sectionSize; - this.sceneCenter = sceneCenter ? new THREE__namespace.Vector3().copy(sceneCenter) : undefined; - this.blockSize = blockSize; - this.bucketSize = bucketSize; - } - - generateFromUncompressedSplatArray(splatArray) { - const partitionResults = this.splatPartitioner.partitionUncompressedSplatArray(splatArray); - return SplatBuffer.generateFromUncompressedSplatArrays(partitionResults.splatArrays, - this.alphaRemovalThreshold, this.compressionLevel, - this.sceneCenter, this.blockSize, this.bucketSize, - partitionResults.parameters); - } - - static getStandardGenerator(alphaRemovalThreshold = 1, compressionLevel = 1, sectionSize = 0, sceneCenter = new THREE__namespace.Vector3(), - blockSize = SplatBuffer.BucketBlockSize, bucketSize = SplatBuffer.BucketSize) { - const splatPartitioner = SplatPartitioner.getStandardPartitioner(sectionSize, sceneCenter, blockSize, bucketSize); - return new SplatBufferGenerator(splatPartitioner, alphaRemovalThreshold, compressionLevel, - sectionSize, sceneCenter, blockSize, bucketSize); - } - } - - const LoaderStatus = { - 'Downloading': 0, - 'Processing': 1, - 'Done': 2 - }; - - class DirectLoadError extends Error { - - constructor(msg) { - super(msg); - } - - } - - const InternalLoadType = { - ProgressiveToSplatBuffer: 0, - ProgressiveToSplatArray: 1, - DownloadBeforeProcessing: 2 - }; - - function storeChunksInBuffer(chunks, buffer) { - let inBytes = 0; - for (let chunk of chunks) inBytes += chunk.sizeBytes; - - if (!buffer || buffer.byteLength < inBytes) { - buffer = new ArrayBuffer(inBytes); - } - - let offset = 0; - for (let chunk of chunks) { - new Uint8Array(buffer, offset, chunk.sizeBytes).set(chunk.data); - offset += chunk.sizeBytes; - } - - return buffer; - } - - function finalize$1(splatData, optimizeSplatData, minimumAlpha, compressionLevel, sectionSize, sceneCenter, blockSize, bucketSize) { - if (optimizeSplatData) { - const splatBufferGenerator = SplatBufferGenerator.getStandardGenerator(minimumAlpha, compressionLevel, - sectionSize, sceneCenter, - blockSize, bucketSize); - return splatBufferGenerator.generateFromUncompressedSplatArray(splatData); - } else { - return SplatBuffer.generateFromUncompressedSplatArrays([splatData], minimumAlpha, 0, new THREE__namespace.Vector3()); - } - } - - class PlyLoader { - - static loadFromURL(fileName, onProgress, progressiveLoadToSplatBuffer, onProgressiveLoadSectionProgress, - minimumAlpha, compressionLevel, optimizeSplatData = true, outSphericalHarmonicsDegree = 0, - headers, sectionSize, sceneCenter, blockSize, bucketSize) { - - let internalLoadType; - if (!progressiveLoadToSplatBuffer && !optimizeSplatData) { - internalLoadType = InternalLoadType.DownloadBeforeProcessing; - } else { - if (optimizeSplatData) internalLoadType = InternalLoadType.ProgressiveToSplatArray; - else internalLoadType = InternalLoadType.ProgressiveToSplatBuffer; - } - - const directLoadSectionSizeBytes = Constants.ProgressiveLoadSectionSize; - const splatBufferDataOffsetBytes = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes; - const sectionCount = 1; - - let plyFormat; - let directLoadBufferIn; - let directLoadBufferOut; - let directLoadSplatBuffer; - let compressedPlyHeaderChunksBuffer; - let maxSplatCount = 0; - let processedBaseSplatCount = 0; - let processedSphericalHarmonicsSplatCount = 0; - - let headerLoaded = false; - let readyToLoadSplatData = false; - let baseSplatDataLoaded = false; - - const loadPromise = nativePromiseWithExtractedComponents(); - - let numBytesStreamed = 0; - let numBytesParsed = 0; - let numBytesDownloaded = 0; - let endOfBaseSplatDataBytes = 0; - let headerText = ''; - let header = null; - let chunks = []; - - let standardLoadUncompressedSplatArray; - - const textDecoder = new TextDecoder(); - - const localOnProgress = (percent, percentLabel, chunkData) => { - const loadComplete = percent >= 100; - - if (chunkData) { - chunks.push({ - 'data': chunkData, - 'sizeBytes': chunkData.byteLength, - 'startBytes': numBytesDownloaded, - 'endBytes': numBytesDownloaded + chunkData.byteLength - }); - numBytesDownloaded += chunkData.byteLength; - } - - if (internalLoadType === InternalLoadType.DownloadBeforeProcessing) { - if (loadComplete) { - loadPromise.resolve(chunks); - } - } else { - if (!headerLoaded) { - headerText += textDecoder.decode(chunkData); - if (PlyParserUtils.checkTextForEndHeader(headerText)) { - plyFormat = PlyParserUtils.determineHeaderFormatFromHeaderText(headerText); - if (plyFormat === PlyFormat.INRIAV1) { - header = INRIAV1PlyParser.decodeHeaderText(headerText); - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree); - maxSplatCount = header.splatCount; - readyToLoadSplatData = true; - endOfBaseSplatDataBytes = header.headerSizeBytes + header.bytesPerSplat * maxSplatCount; - } else if (plyFormat === PlyFormat.PlayCanvasCompressed) { - header = PlayCanvasCompressedPlyParser.decodeHeaderText(headerText); - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree); - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer && outSphericalHarmonicsDegree > 0) { - throw new DirectLoadError( - 'PlyLoader.loadFromURL() -> Selected PLY format has spherical ' + - 'harmonics data that cannot be progressively loaded.' - ); - } - maxSplatCount = header.vertexElement.count; - endOfBaseSplatDataBytes = header.headerSizeBytes + header.bytesPerSplat * maxSplatCount + - header.chunkElement.storageSizeBytes; - } else { - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - throw new DirectLoadError( - 'PlyLoader.loadFromURL() -> Selected PLY format cannot be progressively loaded.' - ); - } else { - internalLoadType = InternalLoadType.DownloadBeforeProcessing; - return; - } - } - - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - const shDescriptor = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree]; - const splatBufferSizeBytes = splatBufferDataOffsetBytes + shDescriptor.BytesPerSplat * maxSplatCount; - directLoadBufferOut = new ArrayBuffer(splatBufferSizeBytes); - SplatBuffer.writeHeaderToBuffer({ - versionMajor: SplatBuffer.CurrentMajorVersion, - versionMinor: SplatBuffer.CurrentMinorVersion, - maxSectionCount: sectionCount, - sectionCount: sectionCount, - maxSplatCount: maxSplatCount, - splatCount: 0, - compressionLevel: 0, - sceneCenter: new THREE__namespace.Vector3() - }, directLoadBufferOut); - } else { - standardLoadUncompressedSplatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree); - } - - numBytesStreamed = header.headerSizeBytes; - numBytesParsed = header.headerSizeBytes; - headerLoaded = true; - } - } else if (plyFormat === PlyFormat.PlayCanvasCompressed && !readyToLoadSplatData) { - const sizeRequiredForHeaderAndChunks = header.headerSizeBytes + header.chunkElement.storageSizeBytes; - compressedPlyHeaderChunksBuffer = storeChunksInBuffer(chunks, compressedPlyHeaderChunksBuffer); - if (compressedPlyHeaderChunksBuffer.byteLength >= sizeRequiredForHeaderAndChunks) { - PlayCanvasCompressedPlyParser.readElementData(header.chunkElement, compressedPlyHeaderChunksBuffer, - header.headerSizeBytes); - numBytesStreamed = sizeRequiredForHeaderAndChunks; - numBytesParsed = sizeRequiredForHeaderAndChunks; - readyToLoadSplatData = true; - } - } - - if (headerLoaded && readyToLoadSplatData && chunks.length > 0) { - - directLoadBufferIn = storeChunksInBuffer(chunks, directLoadBufferIn); - - const bytesLoadedSinceLastStreamedSection = numBytesDownloaded - numBytesStreamed; - if (bytesLoadedSinceLastStreamedSection > directLoadSectionSizeBytes || - (numBytesDownloaded >= endOfBaseSplatDataBytes && !baseSplatDataLoaded) || - loadComplete) { - const bytesPerSplat = baseSplatDataLoaded ? header.sphericalHarmonicsPerSplat : header.bytesPerSplat; - const endOfBytesToProcess = baseSplatDataLoaded ? numBytesDownloaded : - Math.min(endOfBaseSplatDataBytes, numBytesDownloaded); - const numBytesToProcess = endOfBytesToProcess - numBytesParsed; - const addedSplatCount = Math.floor(numBytesToProcess / bytesPerSplat); - const numBytesToParse = addedSplatCount * bytesPerSplat; - const numBytesLeftOver = numBytesDownloaded - numBytesParsed - numBytesToParse; - const parsedDataViewOffset = numBytesParsed - chunks[0].startBytes; - const dataToParse = new DataView(directLoadBufferIn, parsedDataViewOffset, numBytesToParse); - - if (!baseSplatDataLoaded) { - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - const shDesc = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree]; - const outOffset = processedBaseSplatCount * shDesc.BytesPerSplat + splatBufferDataOffsetBytes; - if (plyFormat === PlyFormat.PlayCanvasCompressed) { - PlayCanvasCompressedPlyParser.parseToUncompressedSplatBufferSection( - header.chunkElement, header.vertexElement, 0, addedSplatCount - 1, - processedBaseSplatCount, dataToParse, directLoadBufferOut, outOffset - ); - } else { - INRIAV1PlyParser.parseToUncompressedSplatBufferSection( - header, 0, addedSplatCount - 1, dataToParse, 0, - directLoadBufferOut, outOffset, outSphericalHarmonicsDegree - ); - } - } else { - if (plyFormat === PlyFormat.PlayCanvasCompressed) { - PlayCanvasCompressedPlyParser.parseToUncompressedSplatArraySection( - header.chunkElement, header.vertexElement, 0, addedSplatCount - 1, - processedBaseSplatCount, dataToParse, standardLoadUncompressedSplatArray - ); - } else { - INRIAV1PlyParser.parseToUncompressedSplatArraySection( - header, 0, addedSplatCount - 1, dataToParse, 0, - standardLoadUncompressedSplatArray, outSphericalHarmonicsDegree - ); - } - } - - processedBaseSplatCount += addedSplatCount; - - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - if (!directLoadSplatBuffer) { - SplatBuffer.writeSectionHeaderToBuffer({ - maxSplatCount: maxSplatCount, - splatCount: processedBaseSplatCount, - bucketSize: 0, - bucketCount: 0, - bucketBlockSize: 0, - compressionScaleRange: 0, - storageSizeBytes: 0, - fullBucketCount: 0, - partiallyFilledBucketCount: 0, - sphericalHarmonicsDegree: outSphericalHarmonicsDegree - }, 0, directLoadBufferOut, SplatBuffer.HeaderSizeBytes); - directLoadSplatBuffer = new SplatBuffer(directLoadBufferOut, false); - } - directLoadSplatBuffer.updateLoadedCounts(1, processedBaseSplatCount); - } - if (numBytesDownloaded >= endOfBaseSplatDataBytes) { - baseSplatDataLoaded = true; - } - } else { - if (plyFormat === PlyFormat.PlayCanvasCompressed) { - if (internalLoadType === InternalLoadType.ProgressiveToSplatArray) { - PlayCanvasCompressedPlyParser.parseSphericalHarmonicsToUncompressedSplatArraySection( - header.chunkElement, header.shElement, processedSphericalHarmonicsSplatCount, - processedSphericalHarmonicsSplatCount + addedSplatCount - 1, - dataToParse, 0, outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree, - standardLoadUncompressedSplatArray - ); - processedSphericalHarmonicsSplatCount += addedSplatCount; - } - } - } - - if (numBytesLeftOver === 0) { - chunks = []; - } else { - let keepChunks = []; - let keepSize = 0; - for (let i = chunks.length - 1; i >= 0; i--) { - const chunk = chunks[i]; - keepSize += chunk.sizeBytes; - keepChunks.unshift(chunk); - if (keepSize >= numBytesLeftOver) break; - } - chunks = keepChunks; - } - - numBytesStreamed += directLoadSectionSizeBytes; - numBytesParsed += numBytesToParse; - } - } - - if (onProgressiveLoadSectionProgress && directLoadSplatBuffer) { - onProgressiveLoadSectionProgress(directLoadSplatBuffer, loadComplete); - } - - if (loadComplete) { - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - loadPromise.resolve(directLoadSplatBuffer); - } else { - loadPromise.resolve(standardLoadUncompressedSplatArray); - } - } - } - - if (onProgress) onProgress(percent, percentLabel, LoaderStatus.Downloading); - }; - - if (onProgress) onProgress(0, '0%', LoaderStatus.Downloading); - return fetchWithProgress(fileName, localOnProgress, false, headers).then(() => { - if (onProgress) onProgress(0, '0%', LoaderStatus.Processing); - return loadPromise.promise.then((splatData) => { - if (onProgress) onProgress(100, '100%', LoaderStatus.Done); - if (internalLoadType === InternalLoadType.DownloadBeforeProcessing) { - const chunkDatas = chunks.map((chunk) => chunk.data); - return new Blob(chunkDatas).arrayBuffer().then((plyFileData) => { - return PlyLoader.loadFromFileData(plyFileData, minimumAlpha, compressionLevel, optimizeSplatData, - outSphericalHarmonicsDegree, sectionSize, sceneCenter, blockSize, bucketSize); - }); - } else if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - return splatData; - } else { - return delayedExecute(() => { - return finalize$1(splatData, optimizeSplatData, minimumAlpha, compressionLevel, - sectionSize, sceneCenter, blockSize, bucketSize); - }); - } - }); - }); - } - - static loadFromFileData(plyFileData, minimumAlpha, compressionLevel, optimizeSplatData, outSphericalHarmonicsDegree = 0, - sectionSize, sceneCenter, blockSize, bucketSize) { - if (optimizeSplatData) { - return delayedExecute(() => { - return PlyParser.parseToUncompressedSplatArray(plyFileData, outSphericalHarmonicsDegree); - }) - .then((splatArray) => { - return finalize$1(splatArray, optimizeSplatData, minimumAlpha, compressionLevel, - sectionSize, sceneCenter, blockSize, bucketSize); - }); - } else { - return delayedExecute(() => { - return PlyParser.parseToUncompressedSplatBuffer(plyFileData, outSphericalHarmonicsDegree); - }); - } - } - } - - const createStream = (data)=> { - return new ReadableStream({ - async start(controller) { - controller.enqueue(data); - controller.close(); - }, - }); - }; - - async function decompressGzipped(data) { - try { - const stream = createStream(data); - if (!stream) throw new Error('Failed to create stream from data'); - - return await decompressGzipStream(stream); - } catch (error) { - console.error('Error decompressing gzipped data:', error); - throw error; - } - } - - async function decompressGzipStream(stream) { - const decompressedStream = stream.pipeThrough(new DecompressionStream('gzip')); - const response = new Response(decompressedStream); - const buffer = await response.arrayBuffer(); - - return new Uint8Array(buffer); - } - - async function compressGzipped(data) { - try { - const stream = createStream(data); - const compressedStream = stream.pipeThrough(new CompressionStream('gzip')); - const response = new Response(compressedStream); - const buffer = await response.arrayBuffer(); - - return new Uint8Array(buffer); - } catch (error) { - console.error('Error compressing gzipped data:', error); - throw error; - } - } - - const SPZ_MAGIC = 1347635022; - const FLAG_ANTIALIASED = 1; - const COLOR_SCALE = 0.15; - - function halfToFloat(h) { - const sgn = (h >> 15) & 0x1; - const exponent = (h >> 10) & 0x1f; - const mantissa = h & 0x3ff; - - const signMul = sgn === 1 ? -1.0 : 1.0; - if (exponent === 0) { - return signMul * Math.pow(2, -14) * mantissa / 1024; - } - - if (exponent === 31) { - return mantissa !== 0 ? NaN : signMul * Infinity; - } - - return signMul * Math.pow(2, exponent - 15) * (1 + mantissa / 1024); - } - - function unquantizeSH(x) { - return (x - 128.0) / 128.0; - } - - function dimForDegree(degree) { - switch (degree) { - case 0: return 0; - case 1: return 3; - case 2: return 8; - case 3: return 15; - default: - console.error(`[SPZ: ERROR] Unsupported SH degree: ${degree}`); - return 0; - } - } - - const unpackedSplatToUncompressedSplat = function() { - - let rawSplat = []; - const tempRotation = new THREE__namespace.Quaternion(); - - const OFFSET_X = UncompressedSplatArray.OFFSET.X; - const OFFSET_Y = UncompressedSplatArray.OFFSET.Y; - const OFFSET_Z = UncompressedSplatArray.OFFSET.Z; - - const OFFSET_SCALE0 = UncompressedSplatArray.OFFSET.SCALE0; - const OFFSET_SCALE1 = UncompressedSplatArray.OFFSET.SCALE1; - const OFFSET_SCALE2 = UncompressedSplatArray.OFFSET.SCALE2; - - const OFFSET_ROTATION0 = UncompressedSplatArray.OFFSET.ROTATION0; - const OFFSET_ROTATION1 = UncompressedSplatArray.OFFSET.ROTATION1; - const OFFSET_ROTATION2 = UncompressedSplatArray.OFFSET.ROTATION2; - const OFFSET_ROTATION3 = UncompressedSplatArray.OFFSET.ROTATION3; - - const OFFSET_FDC0 = UncompressedSplatArray.OFFSET.FDC0; - const OFFSET_FDC1 = UncompressedSplatArray.OFFSET.FDC1; - const OFFSET_FDC2 = UncompressedSplatArray.OFFSET.FDC2; - const OFFSET_OPACITY = UncompressedSplatArray.OFFSET.OPACITY; - - const OFFSET_FRC = []; - - for (let i = 0; i < 45; i++) { - OFFSET_FRC[i] = UncompressedSplatArray.OFFSET.FRC0 + i; - } - - const shCoeffMap = [dimForDegree(0), dimForDegree(1), dimForDegree(2), dimForDegree(3)]; - - const shIndexMap = [ - 0, 1, 2, 9, 10, 11, 12, 13, 24, 25, 26, 27, 28, 29, 30, - 3, 4, 5, 14, 15, 16, 17, 18, 31, 32, 33, 34, 35, 36, 37, - 6, 7, 8, 19, 20, 21, 22, 23, 38, 39, 40, 41, 42, 43, 44 - ]; - - return function(unpackedSplat, unpackedSphericalHarmonicsDegree, outSphericalHarmonicsDegree) { - outSphericalHarmonicsDegree = Math.min(unpackedSphericalHarmonicsDegree, outSphericalHarmonicsDegree); - - const newSplat = UncompressedSplatArray.createSplat(outSphericalHarmonicsDegree); - if (unpackedSplat.scale[0] !== undefined) { - newSplat[OFFSET_SCALE0] = unpackedSplat.scale[0]; - newSplat[OFFSET_SCALE1] = unpackedSplat.scale[1]; - newSplat[OFFSET_SCALE2] = unpackedSplat.scale[2]; - } else { - newSplat[OFFSET_SCALE0] = 0.01; - newSplat[OFFSET_SCALE1] = 0.01; - newSplat[OFFSET_SCALE2] = 0.01; - } - - if (unpackedSplat.color[0] !== undefined) { - newSplat[OFFSET_FDC0] = unpackedSplat.color[0]; - newSplat[OFFSET_FDC1] = unpackedSplat.color[1]; - newSplat[OFFSET_FDC2] = unpackedSplat.color[2]; - } else if (rawSplat[RED] !== undefined) { - newSplat[OFFSET_FDC0] = rawSplat[RED] * 255; - newSplat[OFFSET_FDC1] = rawSplat[GREEN] * 255; - newSplat[OFFSET_FDC2] = rawSplat[BLUE] * 255; - } else { - newSplat[OFFSET_FDC0] = 0; - newSplat[OFFSET_FDC1] = 0; - newSplat[OFFSET_FDC2] = 0; - } - - if (unpackedSplat.alpha !== undefined) { - newSplat[OFFSET_OPACITY] = unpackedSplat.alpha; - } - - newSplat[OFFSET_FDC0] = clamp(Math.floor(newSplat[OFFSET_FDC0]), 0, 255); - newSplat[OFFSET_FDC1] = clamp(Math.floor(newSplat[OFFSET_FDC1]), 0, 255); - newSplat[OFFSET_FDC2] = clamp(Math.floor(newSplat[OFFSET_FDC2]), 0, 255); - newSplat[OFFSET_OPACITY] = clamp(Math.floor(newSplat[OFFSET_OPACITY]), 0, 255); - - let outSHCoeff = shCoeffMap[outSphericalHarmonicsDegree]; - let readSHCoeff = shCoeffMap[unpackedSphericalHarmonicsDegree]; - for (let j = 0; j < 3; ++j) { - for (let k = 0; k < 15; ++k) { - const outIndex = shIndexMap[j * 15 + k]; - if (k < outSHCoeff && k < readSHCoeff) { - newSplat[UncompressedSplatArray.OFFSET.FRC0 + outIndex] = unpackedSplat.sh[j * readSHCoeff + k]; - } - } - } - - tempRotation.set(unpackedSplat.rotation[3], unpackedSplat.rotation[0], unpackedSplat.rotation[1], unpackedSplat.rotation[2]); - tempRotation.normalize(); - - newSplat[OFFSET_ROTATION0] = tempRotation.x; - newSplat[OFFSET_ROTATION1] = tempRotation.y; - newSplat[OFFSET_ROTATION2] = tempRotation.z; - newSplat[OFFSET_ROTATION3] = tempRotation.w; - - newSplat[OFFSET_X] = unpackedSplat.position[0]; - newSplat[OFFSET_Y] = unpackedSplat.position[1]; - newSplat[OFFSET_Z] = unpackedSplat.position[2]; - - return newSplat; - }; - - }(); - - // Helper function to check sizes (matching C++ checkSizes function) - function checkSizes2(packed, numPoints, shDim, usesFloat16) { - if (packed.positions.length !== numPoints * 3 * (usesFloat16 ? 2 : 3)) return false; - if (packed.scales.length !== numPoints * 3) return false; - if (packed.rotations.length !== numPoints * 3) return false; - if (packed.alphas.length !== numPoints) return false; - if (packed.colors.length !== numPoints * 3) return false; - if (packed.sh.length !== numPoints * shDim * 3) return false; - return true; - } - - function unpackGaussians(packed, outSphericalHarmonicsDegree, directToSplatBuffer, outTarget, outTargetOffset) { - outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, packed.shDegree); - const numPoints = packed.numPoints; - const shDim = dimForDegree(packed.shDegree); - const usesFloat16 = packed.positions.length === numPoints * 3 * 2; - - // Validate sizes - if (!checkSizes2(packed, numPoints, shDim, usesFloat16)) { - return null; - } - - const splat = { - position: [], - scale: [], - rotation: [], - alpha: undefined, - color: [], - sh: [] - }; - - let halfData; - if (usesFloat16) { - halfData = new Uint16Array(packed.positions.buffer, packed.positions.byteOffset, numPoints * 3); - } - const fullPrecisionPositionScale = 1.0 / (1 << packed.fractionalBits); - const shCoeffPerChannelPerSplat = dimForDegree(packed.shDegree); - const SH_C0 = 0.28209479177387814; - - for (let i = 0; i < numPoints; i++) { - // Splat position - if (usesFloat16) { - // Decode legacy float16 format - for (let j = 0; j < 3; j++) { - splat.position[j] = halfToFloat(halfData[i * 3 + j]); - } - } else { - // Decode 24-bit fixed point coordinates - for (let j = 0; j < 3; j++) { - const base = i * 9 + j * 3; - let fixed32 = packed.positions[base]; - fixed32 |= packed.positions[base + 1] << 8; - fixed32 |= packed.positions[base + 2] << 16; - fixed32 |= (fixed32 & 0x800000) ? 0xff000000 : 0; - splat.position[j] = fixed32 * fullPrecisionPositionScale; - } - } - - // Splat scale - for (let j = 0; j < 3; j++) { - splat.scale[j] = Math.exp(packed.scales[i * 3 + j] / 16.0 - 10.0); - } - - // Splat rotation - const r = packed.rotations.subarray(i * 3, i * 3 + 3); - const xyz = [ - r[0] / 127.5 - 1.0, - r[1] / 127.5 - 1.0, - r[2] / 127.5 - 1.0 - ]; - splat.rotation[0] = xyz[0]; - splat.rotation[1] = xyz[1]; - splat.rotation[2] = xyz[2]; - const squaredNorm = xyz[0] * xyz[0] + xyz[1] * xyz[1] + xyz[2] * xyz[2]; - splat.rotation[3] = Math.sqrt(Math.max(0.0, 1.0 - squaredNorm)); - - // Splat alpha - // splat.alpha = invSigmoid(packed.alphas[i] / 255.0); - splat.alpha = Math.floor(packed.alphas[i]); - - // Splat color - for (let j = 0; j < 3; j++) { - splat.color[j] = Math.floor(((((packed.colors[i * 3 + j] / 255.0) - 0.5) / COLOR_SCALE) * SH_C0 + 0.5) * 255); - } - - // Splat spherical harmonics - for (let j = 0; j < 3; j++) { - for (let k = 0; k < shCoeffPerChannelPerSplat; k++) { - splat.sh[j * shCoeffPerChannelPerSplat + k] = unquantizeSH(packed.sh[shCoeffPerChannelPerSplat * 3 * i + k * 3 + j]); - } - } - - const uncompressedSplat = unpackedSplatToUncompressedSplat(splat, packed.shDegree, outSphericalHarmonicsDegree); - if (directToSplatBuffer) { - const outBytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree].BytesPerSplat; - const outBase = i * outBytesPerSplat + outTargetOffset; - SplatBuffer.writeSplatDataToSectionBuffer(uncompressedSplat, outTarget, outBase, 0, outSphericalHarmonicsDegree); - } else { - outTarget.addSplat(uncompressedSplat); - } - } - } - - const HEADER_SIZE = 16; // 4 + 4 + 4 + 1 + 1 + 1 + 1 bytes - const MAX_POINTS_TO_READ = 10000000; - - function deserializePackedGaussians(buffer) { - const view = new DataView(buffer); - let offset = 0; - - // Read and validate header - const header = { - magic: view.getUint32(offset, true), - version: view.getUint32(offset + 4, true), - numPoints: view.getUint32(offset + 8, true), - shDegree: view.getUint8(offset + 12), - fractionalBits: view.getUint8(offset + 13), - flags: view.getUint8(offset + 14), - reserved: view.getUint8(offset + 15) - }; - - offset += HEADER_SIZE; - - // Validate header - if (header.magic !== SPZ_MAGIC) { - console.error('[SPZ ERROR] deserializePackedGaussians: header not found'); - return null; - } - if (header.version < 1 || header.version > 2) { - console.error(`[SPZ ERROR] deserializePackedGaussians: version not supported: ${header.version}`); - return null; - } - if (header.numPoints > MAX_POINTS_TO_READ) { - console.error(`[SPZ ERROR] deserializePackedGaussians: Too many points: ${header.numPoints}`); - return null; - } - if (header.shDegree > 3) { - console.error(`[SPZ ERROR] deserializePackedGaussians: Unsupported SH degree: ${header.shDegree}`); - return null; - } - - const numPoints = header.numPoints; - const shDim = dimForDegree(header.shDegree); - const usesFloat16 = header.version === 1; - - // Initialize result object - const result = { - numPoints, - shDegree: header.shDegree, - fractionalBits: header.fractionalBits, - antialiased: (header.flags & FLAG_ANTIALIASED) !== 0, - positions: new Uint8Array(numPoints * 3 * (usesFloat16 ? 2 : 3)), - scales: new Uint8Array(numPoints * 3), - rotations: new Uint8Array(numPoints * 3), - alphas: new Uint8Array(numPoints), - colors: new Uint8Array(numPoints * 3), - sh: new Uint8Array(numPoints * shDim * 3) - }; - - // Read data sections - try { - const uint8View = new Uint8Array(buffer); - let positionsSize = result.positions.length; - let currentOffset = offset; - - result.positions.set(uint8View.slice(currentOffset, currentOffset + positionsSize)); - currentOffset += positionsSize; - - result.alphas.set(uint8View.slice(currentOffset, currentOffset + result.alphas.length)); - currentOffset += result.alphas.length; - - result.colors.set(uint8View.slice(currentOffset, currentOffset + result.colors.length)); - currentOffset += result.colors.length; - - result.scales.set(uint8View.slice(currentOffset, currentOffset + result.scales.length)); - currentOffset += result.scales.length; - - result.rotations.set(uint8View.slice(currentOffset, currentOffset + result.rotations.length)); - currentOffset += result.rotations.length; - - result.sh.set(uint8View.slice(currentOffset, currentOffset + result.sh.length)); - - // Verify we read the expected amount of data - if (currentOffset + result.sh.length !== buffer.byteLength) { - console.error('[SPZ ERROR] deserializePackedGaussians: incorrect buffer size'); - return null; - } - } catch (error) { - console.error('[SPZ ERROR] deserializePackedGaussians: read error', error); - return null; - } - - return result; - } - - async function loadSpzPacked(compressedData) { - try { - const decompressed = await decompressGzipped(compressedData); - return deserializePackedGaussians(decompressed.buffer); - } catch (error) { - console.error('[SPZ ERROR] loadSpzPacked: decompression error', error); - return null; - } - } - - class SpzLoader { - - static loadFromURL(fileName, onProgress, minimumAlpha, compressionLevel, optimizeSplatData = true, - outSphericalHarmonicsDegree = 0, headers, sectionSize, sceneCenter, blockSize, bucketSize) { - if (onProgress) onProgress(0, '0%', LoaderStatus.Downloading); - return fetchWithProgress(fileName, onProgress, true, headers).then((fileData) => { - if (onProgress) onProgress(0, '0%', LoaderStatus.Processing); - return SpzLoader.loadFromFileData(fileData, minimumAlpha, compressionLevel, optimizeSplatData, - outSphericalHarmonicsDegree, sectionSize, sceneCenter, blockSize, bucketSize); - }); - } - - static async loadFromFileData(spzFileData, minimumAlpha, compressionLevel, optimizeSplatData, - outSphericalHarmonicsDegree = 0, sectionSize, sceneCenter, blockSize, bucketSize) { - await delayedExecute(); - const packed = await loadSpzPacked(spzFileData); - outSphericalHarmonicsDegree = Math.min(packed.shDegree, outSphericalHarmonicsDegree); - - const splatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree); - - if (optimizeSplatData) { - unpackGaussians(packed, outSphericalHarmonicsDegree, false, splatArray, 0); - const splatBufferGenerator = SplatBufferGenerator.getStandardGenerator(minimumAlpha, compressionLevel, - sectionSize, sceneCenter, - blockSize, bucketSize); - return splatBufferGenerator.generateFromUncompressedSplatArray(splatArray); - } else { - const { - splatBuffer, - splatBufferDataOffsetBytes - } = SplatBuffer.preallocateUncompressed(packed.numPoints, outSphericalHarmonicsDegree); - unpackGaussians(packed, outSphericalHarmonicsDegree, true, splatBuffer.bufferData, splatBufferDataOffsetBytes); - return splatBuffer; - } - } - - } - - class SplatParser { - - static RowSizeBytes = 32; - static CenterSizeBytes = 12; - static ScaleSizeBytes = 12; - static RotationSizeBytes = 4; - static ColorSizeBytes = 4; - - static parseToUncompressedSplatBufferSection(fromSplat, toSplat, fromBuffer, fromOffset, toBuffer, toOffset) { - - const outBytesPerCenter = SplatBuffer.CompressionLevels[0].BytesPerCenter; - const outBytesPerScale = SplatBuffer.CompressionLevels[0].BytesPerScale; - const outBytesPerRotation = SplatBuffer.CompressionLevels[0].BytesPerRotation; - const outBytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[0].BytesPerSplat; - - for (let i = fromSplat; i <= toSplat; i++) { - const inBase = i * SplatParser.RowSizeBytes + fromOffset; - const inCenter = new Float32Array(fromBuffer, inBase, 3); - const inScale = new Float32Array(fromBuffer, inBase + SplatParser.CenterSizeBytes, 3); - const inColor = new Uint8Array(fromBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes, 4); - const inRotation = new Uint8Array(fromBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes + - SplatParser.RotationSizeBytes, 4); - - const quat = new THREE__namespace.Quaternion((inRotation[1] - 128) / 128, (inRotation[2] - 128) / 128, - (inRotation[3] - 128) / 128, (inRotation[0] - 128) / 128); - quat.normalize(); - - const outBase = i * outBytesPerSplat + toOffset; - const outCenter = new Float32Array(toBuffer, outBase, 3); - const outScale = new Float32Array(toBuffer, outBase + outBytesPerCenter, 3); - const outRotation = new Float32Array(toBuffer, outBase + outBytesPerCenter + outBytesPerScale, 4); - const outColor = new Uint8Array(toBuffer, outBase + outBytesPerCenter + outBytesPerScale + outBytesPerRotation, 4); - - outCenter[0] = inCenter[0]; - outCenter[1] = inCenter[1]; - outCenter[2] = inCenter[2]; - - outScale[0] = inScale[0]; - outScale[1] = inScale[1]; - outScale[2] = inScale[2]; - - outRotation[0] = quat.w; - outRotation[1] = quat.x; - outRotation[2] = quat.y; - outRotation[3] = quat.z; - - outColor[0] = inColor[0]; - outColor[1] = inColor[1]; - outColor[2] = inColor[2]; - outColor[3] = inColor[3]; - } - } - - static parseToUncompressedSplatArraySection(fromSplat, toSplat, fromBuffer, fromOffset, splatArray) { - - for (let i = fromSplat; i <= toSplat; i++) { - const inBase = i * SplatParser.RowSizeBytes + fromOffset; - const inCenter = new Float32Array(fromBuffer, inBase, 3); - const inScale = new Float32Array(fromBuffer, inBase + SplatParser.CenterSizeBytes, 3); - const inColor = new Uint8Array(fromBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes, 4); - const inRotation = new Uint8Array(fromBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes + - SplatParser.RotationSizeBytes, 4); - - const quat = new THREE__namespace.Quaternion((inRotation[1] - 128) / 128, (inRotation[2] - 128) / 128, - (inRotation[3] - 128) / 128, (inRotation[0] - 128) / 128); - quat.normalize(); - - splatArray.addSplatFromComonents(inCenter[0], inCenter[1], inCenter[2], inScale[0], inScale[1], inScale[2], - quat.w, quat.x, quat.y, quat.z, inColor[0], inColor[1], inColor[2], inColor[3]); - } - } - - static parseStandardSplatToUncompressedSplatArray(inBuffer) { - // Standard .splat row layout: - // XYZ - Position (Float32) - // XYZ - Scale (Float32) - // RGBA - colors (uint8) - // IJKL - quaternion/rot (uint8) - - const splatCount = inBuffer.byteLength / SplatParser.RowSizeBytes; - - const splatArray = new UncompressedSplatArray(); - - for (let i = 0; i < splatCount; i++) { - const inBase = i * SplatParser.RowSizeBytes; - const inCenter = new Float32Array(inBuffer, inBase, 3); - const inScale = new Float32Array(inBuffer, inBase + SplatParser.CenterSizeBytes, 3); - const inColor = new Uint8Array(inBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes, 4); - const inRotation = new Uint8Array(inBuffer, inBase + SplatParser.CenterSizeBytes + - SplatParser.ScaleSizeBytes + SplatParser.ColorSizeBytes, 4); - - const quat = new THREE__namespace.Quaternion((inRotation[1] - 128) / 128, (inRotation[2] - 128) / 128, - (inRotation[3] - 128) / 128, (inRotation[0] - 128) / 128); - quat.normalize(); - - splatArray.addSplatFromComonents(inCenter[0], inCenter[1], inCenter[2], inScale[0], inScale[1], inScale[2], - quat.w, quat.x, quat.y, quat.z, inColor[0], inColor[1], inColor[2], inColor[3]); - } - - return splatArray; - } - - } - - function finalize(splatData, optimizeSplatData, minimumAlpha, compressionLevel, sectionSize, sceneCenter, blockSize, bucketSize) { - if (optimizeSplatData) { - const splatBufferGenerator = SplatBufferGenerator.getStandardGenerator(minimumAlpha, compressionLevel, - sectionSize, sceneCenter, - blockSize, bucketSize); - return splatBufferGenerator.generateFromUncompressedSplatArray(splatData); - } else { - // TODO: Implement direct-to-SplatBuffer when not optimizing splat data - return SplatBuffer.generateFromUncompressedSplatArrays([splatData], minimumAlpha, 0, new THREE__namespace.Vector3()); - } - } - - class SplatLoader { - - static loadFromURL(fileName, onProgress, progressiveLoadToSplatBuffer, onProgressiveLoadSectionProgress, minimumAlpha, compressionLevel, - optimizeSplatData = true, headers, sectionSize, sceneCenter, blockSize, bucketSize) { - - let internalLoadType = progressiveLoadToSplatBuffer ? InternalLoadType.ProgressiveToSplatBuffer : - InternalLoadType.ProgressiveToSplatArray; - if (optimizeSplatData) internalLoadType = InternalLoadType.ProgressiveToSplatArray; - - const splatDataOffsetBytes = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes; - const directLoadSectionSizeBytes = Constants.ProgressiveLoadSectionSize; - const sectionCount = 1; - - let directLoadBufferIn; - let directLoadBufferOut; - let directLoadSplatBuffer; - let maxSplatCount = 0; - let splatCount = 0; - - let standardLoadUncompressedSplatArray; - - const loadPromise = nativePromiseWithExtractedComponents(); - - let numBytesStreamed = 0; - let numBytesLoaded = 0; - let chunks = []; - - const localOnProgress = (percent, percentStr, chunk, fileSize) => { - const loadComplete = percent >= 100; - - if (chunk) { - chunks.push(chunk); - } - - if (internalLoadType === InternalLoadType.DownloadBeforeProcessing) { - if (loadComplete) { - loadPromise.resolve(chunks); - } - return; - } - - if (!fileSize) { - if (progressiveLoadToSplatBuffer) { - throw new DirectLoadError('Cannon directly load .splat because no file size info is available.'); - } else { - internalLoadType = InternalLoadType.DownloadBeforeProcessing; - return; - } - } - - if (!directLoadBufferIn) { - maxSplatCount = fileSize / SplatParser.RowSizeBytes; - directLoadBufferIn = new ArrayBuffer(fileSize); - const bytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[0].BytesPerSplat; - const splatBufferSizeBytes = splatDataOffsetBytes + bytesPerSplat * maxSplatCount; - - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - directLoadBufferOut = new ArrayBuffer(splatBufferSizeBytes); - SplatBuffer.writeHeaderToBuffer({ - versionMajor: SplatBuffer.CurrentMajorVersion, - versionMinor: SplatBuffer.CurrentMinorVersion, - maxSectionCount: sectionCount, - sectionCount: sectionCount, - maxSplatCount: maxSplatCount, - splatCount: splatCount, - compressionLevel: 0, - sceneCenter: new THREE__namespace.Vector3() - }, directLoadBufferOut); - } else { - standardLoadUncompressedSplatArray = new UncompressedSplatArray(0); - } - } - - if (chunk) { - new Uint8Array(directLoadBufferIn, numBytesLoaded, chunk.byteLength).set(new Uint8Array(chunk)); - numBytesLoaded += chunk.byteLength; - - const bytesLoadedSinceLastSection = numBytesLoaded - numBytesStreamed; - if (bytesLoadedSinceLastSection > directLoadSectionSizeBytes || loadComplete) { - const bytesToUpdate = loadComplete ? bytesLoadedSinceLastSection : directLoadSectionSizeBytes; - const addedSplatCount = bytesToUpdate / SplatParser.RowSizeBytes; - const newSplatCount = splatCount + addedSplatCount; - - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - SplatParser.parseToUncompressedSplatBufferSection(splatCount, newSplatCount - 1, directLoadBufferIn, 0, - directLoadBufferOut, splatDataOffsetBytes); - } else { - SplatParser.parseToUncompressedSplatArraySection(splatCount, newSplatCount - 1, directLoadBufferIn, 0, - standardLoadUncompressedSplatArray); - } - - splatCount = newSplatCount; - - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - if (!directLoadSplatBuffer) { - SplatBuffer.writeSectionHeaderToBuffer({ - maxSplatCount: maxSplatCount, - splatCount: splatCount, - bucketSize: 0, - bucketCount: 0, - bucketBlockSize: 0, - compressionScaleRange: 0, - storageSizeBytes: 0, - fullBucketCount: 0, - partiallyFilledBucketCount: 0 - }, 0, directLoadBufferOut, SplatBuffer.HeaderSizeBytes); - directLoadSplatBuffer = new SplatBuffer(directLoadBufferOut, false); - } - directLoadSplatBuffer.updateLoadedCounts(1, splatCount); - if (onProgressiveLoadSectionProgress) { - onProgressiveLoadSectionProgress(directLoadSplatBuffer, loadComplete); - } - } - - numBytesStreamed += directLoadSectionSizeBytes; - } - } - - if (loadComplete) { - if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - loadPromise.resolve(directLoadSplatBuffer); - } else { - loadPromise.resolve(standardLoadUncompressedSplatArray); - } - } - - if (onProgress) onProgress(percent, percentStr, LoaderStatus.Downloading); - }; - - if (onProgress) onProgress(0, '0%', LoaderStatus.Downloading); - return fetchWithProgress(fileName, localOnProgress, false, headers).then(() => { - if (onProgress) onProgress(0, '0%', LoaderStatus.Processing); - return loadPromise.promise.then((splatData) => { - if (onProgress) onProgress(100, '100%', LoaderStatus.Done); - if (internalLoadType === InternalLoadType.DownloadBeforeProcessing) { - return new Blob(chunks).arrayBuffer().then((splatData) => { - return SplatLoader.loadFromFileData(splatData, minimumAlpha, compressionLevel, optimizeSplatData, - sectionSize, sceneCenter, blockSize, bucketSize); - }); - } else if (internalLoadType === InternalLoadType.ProgressiveToSplatBuffer) { - return splatData; - } else { - return delayedExecute(() => { - return finalize(splatData, optimizeSplatData, minimumAlpha, compressionLevel, - sectionSize, sceneCenter, blockSize, bucketSize); - }); - } - }); - }); - } - - static loadFromFileData(splatFileData, minimumAlpha, compressionLevel, optimizeSplatData, - sectionSize, sceneCenter, blockSize, bucketSize) { - return delayedExecute(() => { - const splatArray = SplatParser.parseStandardSplatToUncompressedSplatArray(splatFileData); - return finalize(splatArray, optimizeSplatData, minimumAlpha, compressionLevel, - sectionSize, sceneCenter, blockSize, bucketSize); - }); - } - - } - - class KSplatLoader { - - static checkVersion(buffer) { - const minVersionMajor = SplatBuffer.CurrentMajorVersion; - const minVersionMinor = SplatBuffer.CurrentMinorVersion; - const header = SplatBuffer.parseHeader(buffer); - if (header.versionMajor === minVersionMajor && - header.versionMinor >= minVersionMinor || - header.versionMajor > minVersionMajor) { - return true; - } else { - throw new Error(`KSplat version not supported: v${header.versionMajor}.${header.versionMinor}. ` + - `Minimum required: v${minVersionMajor}.${minVersionMinor}`); - } - }; - - static loadFromURL(fileName, externalOnProgress, progressiveLoadToSplatBuffer, onSectionBuilt, headers) { - let directLoadBuffer; - let directLoadSplatBuffer; - - let headerBuffer; - let header; - let headerLoaded = false; - let headerLoading = false; - - let sectionHeadersBuffer; - let sectionHeaders = []; - let sectionHeadersLoaded = false; - let sectionHeadersLoading = false; - - let numBytesLoaded = 0; - let numBytesProgressivelyLoaded = 0; - let totalBytesToDownload = 0; - - let downloadComplete = false; - let loadComplete = false; - let loadSectionQueued = false; - - let chunks = []; - - const directLoadPromise = nativePromiseWithExtractedComponents(); - - const checkAndLoadHeader = () => { - if (!headerLoaded && !headerLoading && numBytesLoaded >= SplatBuffer.HeaderSizeBytes) { - headerLoading = true; - const headerAssemblyPromise = new Blob(chunks).arrayBuffer(); - headerAssemblyPromise.then((bufferData) => { - headerBuffer = new ArrayBuffer(SplatBuffer.HeaderSizeBytes); - new Uint8Array(headerBuffer).set(new Uint8Array(bufferData, 0, SplatBuffer.HeaderSizeBytes)); - KSplatLoader.checkVersion(headerBuffer); - headerLoading = false; - headerLoaded = true; - header = SplatBuffer.parseHeader(headerBuffer); - window.setTimeout(() => { - checkAndLoadSectionHeaders(); - }, 1); - }); - } - }; - - let queuedCheckAndLoadSectionsCount = 0; - const queueCheckAndLoadSections = () => { - if (queuedCheckAndLoadSectionsCount === 0) { - queuedCheckAndLoadSectionsCount++; - window.setTimeout(() => { - queuedCheckAndLoadSectionsCount--; - checkAndLoadSections(); - }, 1); - } - }; - - const checkAndLoadSectionHeaders = () => { - const performLoad = () => { - sectionHeadersLoading = true; - const sectionHeadersAssemblyPromise = new Blob(chunks).arrayBuffer(); - sectionHeadersAssemblyPromise.then((bufferData) => { - sectionHeadersLoading = false; - sectionHeadersLoaded = true; - sectionHeadersBuffer = new ArrayBuffer(header.maxSectionCount * SplatBuffer.SectionHeaderSizeBytes); - new Uint8Array(sectionHeadersBuffer).set(new Uint8Array(bufferData, SplatBuffer.HeaderSizeBytes, - header.maxSectionCount * SplatBuffer.SectionHeaderSizeBytes)); - sectionHeaders = SplatBuffer.parseSectionHeaders(header, sectionHeadersBuffer, 0, false); - let totalSectionStorageStorageByes = 0; - for (let i = 0; i < header.maxSectionCount; i++) { - totalSectionStorageStorageByes += sectionHeaders[i].storageSizeBytes; - } - const totalStorageSizeBytes = SplatBuffer.HeaderSizeBytes + header.maxSectionCount * - SplatBuffer.SectionHeaderSizeBytes + totalSectionStorageStorageByes; - if (!directLoadBuffer) { - directLoadBuffer = new ArrayBuffer(totalStorageSizeBytes); - let offset = 0; - for (let i = 0; i < chunks.length; i++) { - const chunk = chunks[i]; - new Uint8Array(directLoadBuffer, offset, chunk.byteLength).set(new Uint8Array(chunk)); - offset += chunk.byteLength; - } - } - - totalBytesToDownload = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * header.maxSectionCount; - for (let i = 0; i <= sectionHeaders.length && i < header.maxSectionCount; i++) { - totalBytesToDownload += sectionHeaders[i].storageSizeBytes; - } - - queueCheckAndLoadSections(); - }); - }; - - if (!sectionHeadersLoading && !sectionHeadersLoaded && headerLoaded && - numBytesLoaded >= SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * header.maxSectionCount) { - performLoad(); - } - }; - - const checkAndLoadSections = () => { - if (loadSectionQueued) return; - loadSectionQueued = true; - const checkAndLoadFunc = () => { - loadSectionQueued = false; - if (sectionHeadersLoaded) { - - if (loadComplete) return; - - downloadComplete = numBytesLoaded >= totalBytesToDownload; - - let bytesLoadedSinceLastSection = numBytesLoaded - numBytesProgressivelyLoaded; - if (bytesLoadedSinceLastSection > Constants.ProgressiveLoadSectionSize || downloadComplete) { - - numBytesProgressivelyLoaded += Constants.ProgressiveLoadSectionSize; - loadComplete = numBytesProgressivelyLoaded >= totalBytesToDownload; - - if (!directLoadSplatBuffer) directLoadSplatBuffer = new SplatBuffer(directLoadBuffer, false); - - const baseDataOffset = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * header.maxSectionCount; - let sectionBase = 0; - let reachedSections = 0; - let loadedSplatCount = 0; - for (let i = 0; i < header.maxSectionCount; i++) { - const sectionHeader = sectionHeaders[i]; - const bucketsDataOffset = sectionBase + sectionHeader.partiallyFilledBucketCount * 4 + - sectionHeader.bucketStorageSizeBytes * sectionHeader.bucketCount; - const bytesRequiredToReachSectionSplatData = baseDataOffset + bucketsDataOffset; - if (numBytesProgressivelyLoaded >= bytesRequiredToReachSectionSplatData) { - reachedSections++; - const bytesPastSSectionSplatDataStart = numBytesProgressivelyLoaded - bytesRequiredToReachSectionSplatData; - const baseDescriptor = SplatBuffer.CompressionLevels[header.compressionLevel]; - const shDesc = baseDescriptor.SphericalHarmonicsDegrees[sectionHeader.sphericalHarmonicsDegree]; - const bytesPerSplat = shDesc.BytesPerSplat; - let loadedSplatsForSection = Math.floor(bytesPastSSectionSplatDataStart / bytesPerSplat); - loadedSplatsForSection = Math.min(loadedSplatsForSection, sectionHeader.maxSplatCount); - loadedSplatCount += loadedSplatsForSection; - directLoadSplatBuffer.updateLoadedCounts(reachedSections, loadedSplatCount); - directLoadSplatBuffer.updateSectionLoadedCounts(i, loadedSplatsForSection); - } else { - break; - } - sectionBase += sectionHeader.storageSizeBytes; - } - - onSectionBuilt(directLoadSplatBuffer, loadComplete); - - const percentComplete = numBytesProgressivelyLoaded / totalBytesToDownload * 100; - const percentLabel = (percentComplete).toFixed(2) + '%'; - - if (externalOnProgress) externalOnProgress(percentComplete, percentLabel, LoaderStatus.Downloading); - - if (loadComplete) { - directLoadPromise.resolve(directLoadSplatBuffer); - } else { - checkAndLoadSections(); - } - } - } - }; - window.setTimeout(checkAndLoadFunc, Constants.ProgressiveLoadSectionDelayDuration); - }; - - const localOnProgress = (percent, percentStr, chunk) => { - if (chunk) { - chunks.push(chunk); - if (directLoadBuffer) { - new Uint8Array(directLoadBuffer, numBytesLoaded, chunk.byteLength).set(new Uint8Array(chunk)); - } - numBytesLoaded += chunk.byteLength; - } - if (progressiveLoadToSplatBuffer) { - checkAndLoadHeader(); - checkAndLoadSectionHeaders(); - checkAndLoadSections(); - } else { - if (externalOnProgress) externalOnProgress(percent, percentStr, LoaderStatus.Downloading); - } - }; - - return fetchWithProgress(fileName, localOnProgress, !progressiveLoadToSplatBuffer, headers).then((fullBuffer) => { - if (externalOnProgress) externalOnProgress(0, '0%', LoaderStatus.Processing); - const loadPromise = progressiveLoadToSplatBuffer ? directLoadPromise.promise : KSplatLoader.loadFromFileData(fullBuffer); - return loadPromise.then((splatBuffer) => { - if (externalOnProgress) externalOnProgress(100, '100%', LoaderStatus.Done); - return splatBuffer; - }); - }); - } - - static loadFromFileData(fileData) { - return delayedExecute(() => { - KSplatLoader.checkVersion(fileData); - return new SplatBuffer(fileData); - }); - } - - static downloadFile = function() { - - let downLoadLink; - - return function(splatBuffer, fileName) { - const blob = new Blob([splatBuffer.bufferData], { - type: 'application/octet-stream', - }); - - if (!downLoadLink) { - downLoadLink = document.createElement('a'); - document.body.appendChild(downLoadLink); - } - downLoadLink.download = fileName; - downLoadLink.href = URL.createObjectURL(blob); - downLoadLink.click(); - }; - - }(); - - } - - const SceneFormat = { - 'Splat': 0, - 'KSplat': 1, - 'Ply': 2, - 'Spz': 3 - }; - - const sceneFormatFromPath = (path) => { - if (path.endsWith('.ply')) return SceneFormat.Ply; - else if (path.endsWith('.splat')) return SceneFormat.Splat; - else if (path.endsWith('.ksplat')) return SceneFormat.KSplat; - else if (path.endsWith('.spz')) return SceneFormat.Spz; - return null; - }; - - var Utils = /*#__PURE__*/Object.freeze({ - __proto__: null, - sceneFormatFromPath: sceneFormatFromPath - }); - - /* - Copyright © 2010-2024 three.js authors & Mark Kellogg - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - */ - - - // OrbitControls performs orbiting, dollying (zooming), and panning. - // Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default). - // - // Orbit - left mouse / touch: one-finger move - // Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish - // Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move - - const _changeEvent = { type: 'change' }; - const _startEvent = { type: 'start' }; - const _endEvent = { type: 'end' }; - const _ray = new THREE.Ray(); - const _plane = new THREE.Plane(); - const TILT_LIMIT = Math.cos( 70 * THREE.MathUtils.DEG2RAD ); - - class OrbitControls extends THREE.EventDispatcher { - - constructor( object, domElement ) { - - super(); - - this.object = object; - this.domElement = domElement; - this.domElement.style.touchAction = 'none'; // disable touch scroll - - // Set to false to disable this control - this.enabled = true; - - // "target" sets the location of focus, where the object orbits around - this.target = new THREE.Vector3(); - - // How far you can dolly in and out ( PerspectiveCamera only ) - this.minDistance = 0; - this.maxDistance = Infinity; - - // How far you can zoom in and out ( OrthographicCamera only ) - this.minZoom = 0; - this.maxZoom = Infinity; - - // How far you can orbit vertically, upper and lower limits. - // Range is 0 to Math.PI radians. - this.minPolarAngle = 0; // radians - this.maxPolarAngle = Math.PI; // radians - - // How far you can orbit horizontally, upper and lower limits. - // If set, the interval [min, max] must be a sub-interval of [- 2 PI, 2 PI], with ( max - min < 2 PI ) - this.minAzimuthAngle = - Infinity; // radians - this.maxAzimuthAngle = Infinity; // radians - - // Set to true to enable damping (inertia) - // If damping is enabled, you must call controls.update() in your animation loop - this.enableDamping = false; - this.dampingFactor = 0.05; - - // This option actually enables dollying in and out; left as "zoom" for backwards compatibility. - // Set to false to disable zooming - this.enableZoom = true; - this.zoomSpeed = 1.0; - - // Set to false to disable rotating - this.enableRotate = true; - this.rotateSpeed = 1.0; - - // Set to false to disable panning - this.enablePan = true; - this.panSpeed = 1.0; - this.screenSpacePanning = true; // if false, pan orthogonal to world-space direction camera.up - this.keyPanSpeed = 7.0; // pixels moved per arrow key push - this.zoomToCursor = false; - - // Set to true to automatically rotate around the target - // If auto-rotate is enabled, you must call controls.update() in your animation loop - this.autoRotate = false; - this.autoRotateSpeed = 2.0; // 30 seconds per orbit when fps is 60 - - // The four arrow keys - this.keys = { LEFT: 'KeyA', UP: 'KeyW', RIGHT: 'KeyD', BOTTOM: 'KeyS' }; - - // Mouse buttons - this.mouseButtons = { LEFT: THREE.MOUSE.ROTATE, MIDDLE: THREE.MOUSE.DOLLY, RIGHT: THREE.MOUSE.PAN }; - - // Touch fingers - this.touches = { ONE: THREE.TOUCH.ROTATE, TWO: THREE.TOUCH.DOLLY_PAN }; - - // for reset - this.target0 = this.target.clone(); - this.position0 = this.object.position.clone(); - this.zoom0 = this.object.zoom; - - // the target DOM element for key events - this._domElementKeyEvents = null; - - // - // public methods - // - - this.getPolarAngle = function() { - - return spherical.phi; - - }; - - this.getAzimuthalAngle = function() { - - return spherical.theta; - - }; - - this.getDistance = function() { - - return this.object.position.distanceTo( this.target ); - - }; - - this.listenToKeyEvents = function( domElement ) { - - domElement.addEventListener( 'keydown', onKeyDown ); - this._domElementKeyEvents = domElement; - - }; - - this.stopListenToKeyEvents = function() { - - this._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown ); - this._domElementKeyEvents = null; - - }; - - this.saveState = function() { - - scope.target0.copy( scope.target ); - scope.position0.copy( scope.object.position ); - scope.zoom0 = scope.object.zoom; - - }; - - this.reset = function() { - - scope.target.copy( scope.target0 ); - scope.object.position.copy( scope.position0 ); - scope.object.zoom = scope.zoom0; - this.clearDampedRotation(); - this.clearDampedPan(); - - scope.object.updateProjectionMatrix(); - scope.dispatchEvent( _changeEvent ); - - scope.update(); - - state = STATE.NONE; - - }; - - this.clearDampedRotation = function() { - sphericalDelta.theta = 0.0; - sphericalDelta.phi = 0.0; - }; - - this.clearDampedPan = function() { - panOffset.set(0, 0, 0); - }; - - // this method is exposed, but perhaps it would be better if we can make it private... - this.update = function() { - - const offset = new THREE.Vector3(); - - // so camera.up is the orbit axis - const quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) ); - const quatInverse = quat.clone().invert(); - - const lastPosition = new THREE.Vector3(); - const lastQuaternion = new THREE.Quaternion(); - const lastTargetPosition = new THREE.Vector3(); - - const twoPI = 2 * Math.PI; - - return function update() { - - quat.setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) ); - quatInverse.copy(quat).invert(); - - const position = scope.object.position; - - offset.copy( position ).sub( scope.target ); - - // rotate offset to "y-axis-is-up" space - offset.applyQuaternion( quat ); - - // angle from z-axis around y-axis - spherical.setFromVector3( offset ); - - if ( scope.autoRotate && state === STATE.NONE ) { - - rotateLeft( getAutoRotationAngle() ); - - } - - if ( scope.enableDamping ) { - - spherical.theta += sphericalDelta.theta * scope.dampingFactor; - spherical.phi += sphericalDelta.phi * scope.dampingFactor; - - } else { - - spherical.theta += sphericalDelta.theta; - spherical.phi += sphericalDelta.phi; - - } - - // restrict theta to be between desired limits - - let min = scope.minAzimuthAngle; - let max = scope.maxAzimuthAngle; - - if ( isFinite( min ) && isFinite( max ) ) { - - if ( min < - Math.PI ) min += twoPI; else if ( min > Math.PI ) min -= twoPI; - - if ( max < - Math.PI ) max += twoPI; else if ( max > Math.PI ) max -= twoPI; - - if ( min <= max ) { - - spherical.theta = Math.max( min, Math.min( max, spherical.theta ) ); - - } else { - - spherical.theta = ( spherical.theta > ( min + max ) / 2 ) ? - Math.max( min, spherical.theta ) : - Math.min( max, spherical.theta ); - - } - - } - - // restrict phi to be between desired limits - spherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) ); - - spherical.makeSafe(); - - - // move target to panned location - - if ( scope.enableDamping === true ) { - - scope.target.addScaledVector( panOffset, scope.dampingFactor ); - - } else { - - scope.target.add( panOffset ); - - } - - // adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera - // we adjust zoom later in these cases - if ( scope.zoomToCursor && performCursorZoom || scope.object.isOrthographicCamera ) { - - spherical.radius = clampDistance( spherical.radius ); - - } else { - - spherical.radius = clampDistance( spherical.radius * scale ); - - } - - - offset.setFromSpherical( spherical ); - - // rotate offset back to "camera-up-vector-is-up" space - offset.applyQuaternion( quatInverse ); - - position.copy( scope.target ).add( offset ); - - scope.object.lookAt( scope.target ); - - if ( scope.enableDamping === true ) { - - sphericalDelta.theta *= ( 1 - scope.dampingFactor ); - sphericalDelta.phi *= ( 1 - scope.dampingFactor ); - - panOffset.multiplyScalar( 1 - scope.dampingFactor ); - - } else { - - sphericalDelta.set( 0, 0, 0 ); - - panOffset.set( 0, 0, 0 ); - - } - - // adjust camera position - let zoomChanged = false; - if ( scope.zoomToCursor && performCursorZoom ) { - - let newRadius = null; - if ( scope.object.isPerspectiveCamera ) { - - // move the camera down the pointer ray - // this method avoids floating point error - const prevRadius = offset.length(); - newRadius = clampDistance( prevRadius * scale ); - - const radiusDelta = prevRadius - newRadius; - scope.object.position.addScaledVector( dollyDirection, radiusDelta ); - scope.object.updateMatrixWorld(); - - } else if ( scope.object.isOrthographicCamera ) { - - // adjust the ortho camera position based on zoom changes - const mouseBefore = new THREE.Vector3( mouse.x, mouse.y, 0 ); - mouseBefore.unproject( scope.object ); - - scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / scale ) ); - scope.object.updateProjectionMatrix(); - zoomChanged = true; - - const mouseAfter = new THREE.Vector3( mouse.x, mouse.y, 0 ); - mouseAfter.unproject( scope.object ); - - scope.object.position.sub( mouseAfter ).add( mouseBefore ); - scope.object.updateMatrixWorld(); - - newRadius = offset.length(); - - } else { - - console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.' ); - scope.zoomToCursor = false; - - } - - // handle the placement of the target - if ( newRadius !== null ) { - - if ( this.screenSpacePanning ) { - - // position the orbit target in front of the new camera position - scope.target.set( 0, 0, - 1 ) - .transformDirection( scope.object.matrix ) - .multiplyScalar( newRadius ) - .add( scope.object.position ); - - } else { - - // get the ray and translation plane to compute target - _ray.origin.copy( scope.object.position ); - _ray.direction.set( 0, 0, - 1 ).transformDirection( scope.object.matrix ); - - // if the camera is 20 degrees above the horizon then don't adjust the focus target to avoid - // extremely large values - if ( Math.abs( scope.object.up.dot( _ray.direction ) ) < TILT_LIMIT ) { - - object.lookAt( scope.target ); - - } else { - - _plane.setFromNormalAndCoplanarPoint( scope.object.up, scope.target ); - _ray.intersectPlane( _plane, scope.target ); - - } - - } - - } - - } else if ( scope.object.isOrthographicCamera ) { - - scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / scale ) ); - scope.object.updateProjectionMatrix(); - zoomChanged = true; - - } - - scale = 1; - performCursorZoom = false; - - // update condition is: - // min(camera displacement, camera rotation in radians)^2 > EPS - // using small-angle approximation cos(x/2) = 1 - x^2 / 8 - - if ( zoomChanged || - lastPosition.distanceToSquared( scope.object.position ) > EPS || - 8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS || - lastTargetPosition.distanceToSquared( scope.target ) > 0 ) { - - scope.dispatchEvent( _changeEvent ); - - lastPosition.copy( scope.object.position ); - lastQuaternion.copy( scope.object.quaternion ); - lastTargetPosition.copy( scope.target ); - - zoomChanged = false; - - return true; - - } - - return false; - - }; - - }(); - - this.dispose = function() { - - scope.domElement.removeEventListener( 'contextmenu', onContextMenu ); - - scope.domElement.removeEventListener( 'pointerdown', onPointerDown ); - scope.domElement.removeEventListener( 'pointercancel', onPointerUp ); - scope.domElement.removeEventListener( 'wheel', onMouseWheel ); - - scope.domElement.removeEventListener( 'pointermove', onPointerMove ); - scope.domElement.removeEventListener( 'pointerup', onPointerUp ); - - - if ( scope._domElementKeyEvents !== null ) { - - scope._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown ); - scope._domElementKeyEvents = null; - - } - - }; - - // - // internals - // - - const scope = this; - - const STATE = { - NONE: - 1, - ROTATE: 0, - DOLLY: 1, - PAN: 2, - TOUCH_ROTATE: 3, - TOUCH_PAN: 4, - TOUCH_DOLLY_PAN: 5, - TOUCH_DOLLY_ROTATE: 6 - }; - - let state = STATE.NONE; - - const EPS = 0.000001; - - // current position in spherical coordinates - const spherical = new THREE.Spherical(); - const sphericalDelta = new THREE.Spherical(); - - let scale = 1; - const panOffset = new THREE.Vector3(); - - const rotateStart = new THREE.Vector2(); - const rotateEnd = new THREE.Vector2(); - const rotateDelta = new THREE.Vector2(); - - const panStart = new THREE.Vector2(); - const panEnd = new THREE.Vector2(); - const panDelta = new THREE.Vector2(); - - const dollyStart = new THREE.Vector2(); - const dollyEnd = new THREE.Vector2(); - const dollyDelta = new THREE.Vector2(); - - const dollyDirection = new THREE.Vector3(); - const mouse = new THREE.Vector2(); - let performCursorZoom = false; - - const pointers = []; - const pointerPositions = {}; - - function getAutoRotationAngle() { - - return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed; - - } - - function getZoomScale() { - - return Math.pow( 0.95, scope.zoomSpeed ); - - } - - function rotateLeft( angle ) { - - sphericalDelta.theta -= angle; - - } - - function rotateUp( angle ) { - - sphericalDelta.phi -= angle; - - } - - const panLeft = function() { - - const v = new THREE.Vector3(); - - return function panLeft( distance, objectMatrix ) { - - v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix - v.multiplyScalar( - distance ); - - panOffset.add( v ); - - }; - - }(); - - const panUp = function() { - - const v = new THREE.Vector3(); - - return function panUp( distance, objectMatrix ) { - - if ( scope.screenSpacePanning === true ) { - - v.setFromMatrixColumn( objectMatrix, 1 ); - - } else { - - v.setFromMatrixColumn( objectMatrix, 0 ); - v.crossVectors( scope.object.up, v ); - - } - - v.multiplyScalar( distance ); - - panOffset.add( v ); - - }; - - }(); - - // deltaX and deltaY are in pixels; right and down are positive - const pan = function() { - - const offset = new THREE.Vector3(); - - return function pan( deltaX, deltaY ) { - - const element = scope.domElement; - - if ( scope.object.isPerspectiveCamera ) { - - // perspective - const position = scope.object.position; - offset.copy( position ).sub( scope.target ); - let targetDistance = offset.length(); - - // half of the fov is center to top of screen - targetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 ); - - // we use only clientHeight here so aspect ratio does not distort speed - panLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix ); - panUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix ); - - } else if ( scope.object.isOrthographicCamera ) { - - // orthographic - panLeft( deltaX * ( scope.object.right - scope.object.left ) / - scope.object.zoom / element.clientWidth, scope.object.matrix ); - panUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / - element.clientHeight, scope.object.matrix ); - - } else { - - // camera neither orthographic nor perspective - console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' ); - scope.enablePan = false; - - } - - }; - - }(); - - function dollyOut( dollyScale ) { - - if ( scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera ) { - - scale /= dollyScale; - - } else { - - console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' ); - scope.enableZoom = false; - - } - - } - - function dollyIn( dollyScale ) { - - if ( scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera ) { - - scale *= dollyScale; - - } else { - - console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' ); - scope.enableZoom = false; - - } - - } - - function updateMouseParameters( event ) { - - if ( ! scope.zoomToCursor ) { - - return; - - } - - performCursorZoom = true; - - const rect = scope.domElement.getBoundingClientRect(); - const x = event.clientX - rect.left; - const y = event.clientY - rect.top; - const w = rect.width; - const h = rect.height; - - mouse.x = ( x / w ) * 2 - 1; - mouse.y = - ( y / h ) * 2 + 1; - - dollyDirection.set( mouse.x, mouse.y, 1 ).unproject( object ).sub( object.position ).normalize(); - - } - - function clampDistance( dist ) { - - return Math.max( scope.minDistance, Math.min( scope.maxDistance, dist ) ); - - } - - // - // event callbacks - update the object state - // - - function handleMouseDownRotate( event ) { - - rotateStart.set( event.clientX, event.clientY ); - - } - - function handleMouseDownDolly( event ) { - - updateMouseParameters( event ); - dollyStart.set( event.clientX, event.clientY ); - - } - - function handleMouseDownPan( event ) { - - panStart.set( event.clientX, event.clientY ); - - } - - function handleMouseMoveRotate( event ) { - - rotateEnd.set( event.clientX, event.clientY ); - - rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed ); - - const element = scope.domElement; - - rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height - - rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight ); - - rotateStart.copy( rotateEnd ); - - scope.update(); - - } - - function handleMouseMoveDolly( event ) { - - dollyEnd.set( event.clientX, event.clientY ); - - dollyDelta.subVectors( dollyEnd, dollyStart ); - - if ( dollyDelta.y > 0 ) { - - dollyOut( getZoomScale() ); - - } else if ( dollyDelta.y < 0 ) { - - dollyIn( getZoomScale() ); - - } - - dollyStart.copy( dollyEnd ); - - scope.update(); - - } - - function handleMouseMovePan( event ) { - - panEnd.set( event.clientX, event.clientY ); - - panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed ); - - pan( panDelta.x, panDelta.y ); - - panStart.copy( panEnd ); - - scope.update(); - - } - - function handleMouseWheel( event ) { - - updateMouseParameters( event ); - - if ( event.deltaY < 0 ) { - - dollyIn( getZoomScale() ); - - } else if ( event.deltaY > 0 ) { - - dollyOut( getZoomScale() ); - - } - - scope.update(); - - } - - function handleKeyDown( event ) { - - let needsUpdate = false; - - switch ( event.code ) { - - case scope.keys.UP: - - if ( event.ctrlKey || event.metaKey || event.shiftKey ) { - - rotateUp( 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight ); - - } else { - - pan( 0, scope.keyPanSpeed ); - - } - - needsUpdate = true; - break; - - case scope.keys.BOTTOM: - - if ( event.ctrlKey || event.metaKey || event.shiftKey ) { - - rotateUp( - 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight ); - - } else { - - pan( 0, - scope.keyPanSpeed ); - - } - - needsUpdate = true; - break; - - case scope.keys.LEFT: - - if ( event.ctrlKey || event.metaKey || event.shiftKey ) { - - rotateLeft( 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight ); - - } else { - - pan( scope.keyPanSpeed, 0 ); - - } - - needsUpdate = true; - break; - - case scope.keys.RIGHT: - - if ( event.ctrlKey || event.metaKey || event.shiftKey ) { - - rotateLeft( - 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight ); - - } else { - - pan( - scope.keyPanSpeed, 0 ); - - } - - needsUpdate = true; - break; - - } - - if ( needsUpdate ) { - - // prevent the browser from scrolling on cursor keys - event.preventDefault(); - - scope.update(); - - } - - - } - - function handleTouchStartRotate() { - - if ( pointers.length === 1 ) { - - rotateStart.set( pointers[0].pageX, pointers[0].pageY ); - - } else { - - const x = 0.5 * ( pointers[0].pageX + pointers[1].pageX ); - const y = 0.5 * ( pointers[0].pageY + pointers[1].pageY ); - - rotateStart.set( x, y ); - - } - - } - - function handleTouchStartPan() { - - if ( pointers.length === 1 ) { - - panStart.set( pointers[0].pageX, pointers[0].pageY ); - - } else { - - const x = 0.5 * ( pointers[0].pageX + pointers[1].pageX ); - const y = 0.5 * ( pointers[0].pageY + pointers[1].pageY ); - - panStart.set( x, y ); - - } - - } - - function handleTouchStartDolly() { - - const dx = pointers[0].pageX - pointers[1].pageX; - const dy = pointers[0].pageY - pointers[1].pageY; - - const distance = Math.sqrt( dx * dx + dy * dy ); - - dollyStart.set( 0, distance ); - - } - - function handleTouchStartDollyPan() { - - if ( scope.enableZoom ) handleTouchStartDolly(); - - if ( scope.enablePan ) handleTouchStartPan(); - - } - - function handleTouchStartDollyRotate() { - - if ( scope.enableZoom ) handleTouchStartDolly(); - - if ( scope.enableRotate ) handleTouchStartRotate(); - - } - - function handleTouchMoveRotate( event ) { - - if ( pointers.length == 1 ) { - - rotateEnd.set( event.pageX, event.pageY ); - - } else { - - const position = getSecondPointerPosition( event ); - - const x = 0.5 * ( event.pageX + position.x ); - const y = 0.5 * ( event.pageY + position.y ); - - rotateEnd.set( x, y ); - - } - - rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed ); - - const element = scope.domElement; - - rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height - - rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight ); - - rotateStart.copy( rotateEnd ); - - } - - function handleTouchMovePan( event ) { - - if ( pointers.length === 1 ) { - - panEnd.set( event.pageX, event.pageY ); - - } else { - - const position = getSecondPointerPosition( event ); - - const x = 0.5 * ( event.pageX + position.x ); - const y = 0.5 * ( event.pageY + position.y ); - - panEnd.set( x, y ); - - } - - panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed ); - - pan( panDelta.x, panDelta.y ); - - panStart.copy( panEnd ); - - } - - function handleTouchMoveDolly( event ) { - - const position = getSecondPointerPosition( event ); - - const dx = event.pageX - position.x; - const dy = event.pageY - position.y; - - const distance = Math.sqrt( dx * dx + dy * dy ); - - dollyEnd.set( 0, distance ); - - dollyDelta.set( 0, Math.pow( dollyEnd.y / dollyStart.y, scope.zoomSpeed ) ); - - dollyOut( dollyDelta.y ); - - dollyStart.copy( dollyEnd ); - - } - - function handleTouchMoveDollyPan( event ) { - - if ( scope.enableZoom ) handleTouchMoveDolly( event ); - - if ( scope.enablePan ) handleTouchMovePan( event ); - - } - - function handleTouchMoveDollyRotate( event ) { - - if ( scope.enableZoom ) handleTouchMoveDolly( event ); - - if ( scope.enableRotate ) handleTouchMoveRotate( event ); - - } - - // - // event handlers - FSM: listen for events and reset state - // - - function onPointerDown( event ) { - - if ( scope.enabled === false ) return; - - if ( pointers.length === 0 ) { - - scope.domElement.setPointerCapture( event.pointerId ); - - scope.domElement.addEventListener( 'pointermove', onPointerMove ); - scope.domElement.addEventListener( 'pointerup', onPointerUp ); - - } - - // - - addPointer( event ); - - if ( event.pointerType === 'touch' ) { - - onTouchStart( event ); - - } else { - - onMouseDown( event ); - - } - - } - - function onPointerMove( event ) { - - if ( scope.enabled === false ) return; - - if ( event.pointerType === 'touch' ) { - - onTouchMove( event ); - - } else { - - onMouseMove( event ); - - } - - } - - function onPointerUp( event ) { - - removePointer( event ); - - if ( pointers.length === 0 ) { - - scope.domElement.releasePointerCapture( event.pointerId ); - - scope.domElement.removeEventListener( 'pointermove', onPointerMove ); - scope.domElement.removeEventListener( 'pointerup', onPointerUp ); - - } - - scope.dispatchEvent( _endEvent ); - - state = STATE.NONE; - - } - - function onMouseDown( event ) { - - let mouseAction; - - switch ( event.button ) { - - case 0: - - mouseAction = scope.mouseButtons.LEFT; - break; - - case 1: - - mouseAction = scope.mouseButtons.MIDDLE; - break; - - case 2: - - mouseAction = scope.mouseButtons.RIGHT; - break; - - default: - - mouseAction = - 1; - - } - - switch ( mouseAction ) { - - case THREE.MOUSE.DOLLY: - - if ( scope.enableZoom === false ) return; - - handleMouseDownDolly( event ); - - state = STATE.DOLLY; - - break; - - case THREE.MOUSE.ROTATE: - - if ( event.ctrlKey || event.metaKey || event.shiftKey ) { - - if ( scope.enablePan === false ) return; - - handleMouseDownPan( event ); - - state = STATE.PAN; - - } else { - - if ( scope.enableRotate === false ) return; - - handleMouseDownRotate( event ); - - state = STATE.ROTATE; - - } - - break; - - case THREE.MOUSE.PAN: - - if ( event.ctrlKey || event.metaKey || event.shiftKey ) { - - if ( scope.enableRotate === false ) return; - - handleMouseDownRotate( event ); - - state = STATE.ROTATE; - - } else { - - if ( scope.enablePan === false ) return; - - handleMouseDownPan( event ); - - state = STATE.PAN; - - } - - break; - - default: - - state = STATE.NONE; - - } - - if ( state !== STATE.NONE ) { - - scope.dispatchEvent( _startEvent ); - - } - - } - - function onMouseMove( event ) { - - switch ( state ) { - - case STATE.ROTATE: - - if ( scope.enableRotate === false ) return; - - handleMouseMoveRotate( event ); - - break; - - case STATE.DOLLY: - - if ( scope.enableZoom === false ) return; - - handleMouseMoveDolly( event ); - - break; - - case STATE.PAN: - - if ( scope.enablePan === false ) return; - - handleMouseMovePan( event ); - - break; - - } - - } - - function onMouseWheel( event ) { - - if ( scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE ) return; - - event.preventDefault(); - - scope.dispatchEvent( _startEvent ); - - handleMouseWheel( event ); - - scope.dispatchEvent( _endEvent ); - - } - - function onKeyDown( event ) { - - if ( scope.enabled === false || scope.enablePan === false ) return; - - handleKeyDown( event ); - - } - - function onTouchStart( event ) { - - trackPointer( event ); - - switch ( pointers.length ) { - - case 1: - - switch ( scope.touches.ONE ) { - - case THREE.TOUCH.ROTATE: - - if ( scope.enableRotate === false ) return; - - handleTouchStartRotate(); - - state = STATE.TOUCH_ROTATE; - - break; - - case THREE.TOUCH.PAN: - - if ( scope.enablePan === false ) return; - - handleTouchStartPan(); - - state = STATE.TOUCH_PAN; - - break; - - default: - - state = STATE.NONE; - - } - - break; - - case 2: - - switch ( scope.touches.TWO ) { - - case THREE.TOUCH.DOLLY_PAN: - - if ( scope.enableZoom === false && scope.enablePan === false ) return; - - handleTouchStartDollyPan(); - - state = STATE.TOUCH_DOLLY_PAN; - - break; - - case THREE.TOUCH.DOLLY_ROTATE: - - if ( scope.enableZoom === false && scope.enableRotate === false ) return; - - handleTouchStartDollyRotate(); - - state = STATE.TOUCH_DOLLY_ROTATE; - - break; - - default: - - state = STATE.NONE; - - } - - break; - - default: - - state = STATE.NONE; - - } - - if ( state !== STATE.NONE ) { - - scope.dispatchEvent( _startEvent ); - - } - - } - - function onTouchMove( event ) { - - trackPointer( event ); - - switch ( state ) { - - case STATE.TOUCH_ROTATE: - - if ( scope.enableRotate === false ) return; - - handleTouchMoveRotate( event ); - - scope.update(); - - break; - - case STATE.TOUCH_PAN: - - if ( scope.enablePan === false ) return; - - handleTouchMovePan( event ); - - scope.update(); - - break; - - case STATE.TOUCH_DOLLY_PAN: - - if ( scope.enableZoom === false && scope.enablePan === false ) return; - - handleTouchMoveDollyPan( event ); - - scope.update(); - - break; - - case STATE.TOUCH_DOLLY_ROTATE: - - if ( scope.enableZoom === false && scope.enableRotate === false ) return; - - handleTouchMoveDollyRotate( event ); - - scope.update(); - - break; - - default: - - state = STATE.NONE; - - } - - } - - function onContextMenu( event ) { - - if ( scope.enabled === false ) return; - - event.preventDefault(); - - } - - function addPointer( event ) { - - pointers.push( event ); - - } - - function removePointer( event ) { - - delete pointerPositions[event.pointerId]; - - for ( let i = 0; i < pointers.length; i ++ ) { - - if ( pointers[i].pointerId == event.pointerId ) { - - pointers.splice( i, 1 ); - return; - - } - - } - - } - - function trackPointer( event ) { - - let position = pointerPositions[event.pointerId]; - - if ( position === undefined ) { - - position = new THREE.Vector2(); - pointerPositions[event.pointerId] = position; - - } - - position.set( event.pageX, event.pageY ); - - } - - function getSecondPointerPosition( event ) { - - const pointer = ( event.pointerId === pointers[0].pointerId ) ? pointers[1] : pointers[0]; - - return pointerPositions[pointer.pointerId]; - - } - - // - - scope.domElement.addEventListener( 'contextmenu', onContextMenu ); - - scope.domElement.addEventListener( 'pointerdown', onPointerDown ); - scope.domElement.addEventListener( 'pointercancel', onPointerUp ); - scope.domElement.addEventListener( 'wheel', onMouseWheel, { passive: false } ); - - // force an update at start - - this.update(); - - } - - } - - const fadeElement = (element, out, displayStyle, duration, onComplete) => { - const startTime = performance.now(); - - let startOpacity = element.style.display === 'none' ? 0 : parseFloat(element.style.opacity); - if (isNaN(startOpacity)) startOpacity = 1; - - const interval = window.setInterval(() => { - const currentTime = performance.now(); - const elapsed = currentTime - startTime; - - let t = Math.min(elapsed / duration, 1.0); - if (t > 0.999) t = 1; - - let opacity; - if (out) { - opacity = (1.0 - t) * startOpacity; - if (opacity < 0.0001) opacity = 0; - } else { - opacity = (1.0 - startOpacity) * t + startOpacity; - } - - if (opacity > 0) { - element.style.display = displayStyle; - element.style.opacity = opacity; - } else { - element.style.display = 'none'; - } - - if (t >= 1) { - if (onComplete) onComplete(); - window.clearInterval(interval); - } - }, 16); - return interval; - }; - - const cancelFade = (interval) => { - window.clearInterval(interval); - }; - - const STANDARD_FADE_DURATION = 500; - - class LoadingSpinner { - - static elementIDGen = 0; - - constructor(message, container) { - - this.taskIDGen = 0; - this.elementID = LoadingSpinner.elementIDGen++; - - this.tasks = []; - - this.message = message || 'Loading...'; - this.container = container || document.body; - - this.spinnerContainerOuter = document.createElement('div'); - this.spinnerContainerOuter.className = `spinnerOuterContainer${this.elementID}`; - this.spinnerContainerOuter.style.display = 'none'; - - this.spinnerContainerPrimary = document.createElement('div'); - this.spinnerContainerPrimary.className = `spinnerContainerPrimary${this.elementID}`; - this.spinnerPrimary = document.createElement('div'); - this.spinnerPrimary.classList.add(`spinner${this.elementID}`, `spinnerPrimary${this.elementID}`); - this.messageContainerPrimary = document.createElement('div'); - this.messageContainerPrimary.classList.add(`messageContainer${this.elementID}`, `messageContainerPrimary${this.elementID}`); - this.messageContainerPrimary.innerHTML = this.message; - - this.spinnerContainerMin = document.createElement('div'); - this.spinnerContainerMin.className = `spinnerContainerMin${this.elementID}`; - this.spinnerMin = document.createElement('div'); - this.spinnerMin.classList.add(`spinner${this.elementID}`, `spinnerMin${this.elementID}`); - this.messageContainerMin = document.createElement('div'); - this.messageContainerMin.classList.add(`messageContainer${this.elementID}`, `messageContainerMin${this.elementID}`); - this.messageContainerMin.innerHTML = this.message; - - this.spinnerContainerPrimary.appendChild(this.spinnerPrimary); - this.spinnerContainerPrimary.appendChild(this.messageContainerPrimary); - this.spinnerContainerOuter.appendChild(this.spinnerContainerPrimary); - - this.spinnerContainerMin.appendChild(this.spinnerMin); - this.spinnerContainerMin.appendChild(this.messageContainerMin); - this.spinnerContainerOuter.appendChild(this.spinnerContainerMin); - - const style = document.createElement('style'); - style.innerHTML = ` - - .spinnerOuterContainer${this.elementID} { - width: 100%; - height: 100%; - margin: 0; - top: 0; - left: 0; - position: absolute; - pointer-events: none; - } - - .messageContainer${this.elementID} { - height: 20px; - font-family: arial; - font-size: 12pt; - color: #ffffff; - text-align: center; - vertical-align: middle; - } - - .spinner${this.elementID} { - padding: 15px; - background: #07e8d6; - z-index:99999; - - aspect-ratio: 1; - border-radius: 50%; - --_m: - conic-gradient(#0000,#000), - linear-gradient(#000 0 0) content-box; - -webkit-mask: var(--_m); - mask: var(--_m); - -webkit-mask-composite: source-out; - mask-composite: subtract; - box-sizing: border-box; - animation: load 1s linear infinite; - } - - .spinnerContainerPrimary${this.elementID} { - z-index:99999; - background-color: rgba(128, 128, 128, 0.75); - border: #666666 1px solid; - border-radius: 5px; - padding-top: 20px; - padding-bottom: 10px; - margin: 0; - position: absolute; - top: 50%; - left: 50%; - transform: translate(-80px, -80px); - width: 180px; - pointer-events: auto; - } - - .spinnerPrimary${this.elementID} { - width: 120px; - margin-left: 30px; - } - - .messageContainerPrimary${this.elementID} { - padding-top: 15px; - } - - .spinnerContainerMin${this.elementID} { - z-index:99999; - background-color: rgba(128, 128, 128, 0.75); - border: #666666 1px solid; - border-radius: 5px; - padding-top: 20px; - padding-bottom: 15px; - margin: 0; - position: absolute; - bottom: 50px; - left: 50%; - transform: translate(-50%, 0); - display: flex; - flex-direction: left; - pointer-events: auto; - min-width: 250px; - } - - .messageContainerMin${this.elementID} { - margin-right: 15px; - } - - .spinnerMin${this.elementID} { - width: 50px; - height: 50px; - margin-left: 15px; - margin-right: 25px; - } - - .messageContainerMin${this.elementID} { - padding-top: 15px; - } - - @keyframes load { - to{transform: rotate(1turn)} - } - - `; - this.spinnerContainerOuter.appendChild(style); - this.container.appendChild(this.spinnerContainerOuter); - - this.setMinimized(false, true); - - this.fadeTransitions = []; - } - - addTask(message) { - const newTask = { - 'message': message, - 'id': this.taskIDGen++ - }; - this.tasks.push(newTask); - this.update(); - return newTask.id; - } - - removeTask(id) { - let index = 0; - for (let task of this.tasks) { - if (task.id === id) { - this.tasks.splice(index, 1); - break; - } - index++; - } - this.update(); - } - - removeAllTasks() { - this.tasks = []; - this.update(); - } - - setMessageForTask(id, message) { - for (let task of this.tasks) { - if (task.id === id) { - task.message = message; - break; - } - } - this.update(); - } - - update() { - if (this.tasks.length > 0) { - this.show(); - this.setMessage(this.tasks[this.tasks.length - 1].message); - } else { - this.hide(); - } - } - - show() { - this.spinnerContainerOuter.style.display = 'block'; - this.visible = true; - } - - hide() { - this.spinnerContainerOuter.style.display = 'none'; - this.visible = false; - } - - setContainer(container) { - if (this.container && this.spinnerContainerOuter.parentElement === this.container) { - this.container.removeChild(this.spinnerContainerOuter); - } - if (container) { - this.container = container; - this.container.appendChild(this.spinnerContainerOuter); - this.spinnerContainerOuter.style.zIndex = this.container.style.zIndex + 1; - } - } - - setMinimized(minimized, instant) { - const showHideSpinner = (element, show, instant, displayStyle, fadeTransitionsIndex) => { - if (instant) { - element.style.display = show ? displayStyle : 'none'; - } else { - this.fadeTransitions[fadeTransitionsIndex] = fadeElement(element, !show, displayStyle, STANDARD_FADE_DURATION, () => { - this.fadeTransitions[fadeTransitionsIndex] = null; - }); - } - }; - showHideSpinner(this.spinnerContainerPrimary, !minimized, instant, 'block', 0); - showHideSpinner(this.spinnerContainerMin, minimized, instant, 'flex', 1); - this.minimized = minimized; - } - - setMessage(msg) { - this.messageContainerPrimary.innerHTML = msg; - this.messageContainerMin.innerHTML = msg; - } - } - - class LoadingProgressBar { - - constructor(container) { - - this.idGen = 0; - - this.tasks = []; - - this.container = container || document.body; - - this.progressBarContainerOuter = document.createElement('div'); - this.progressBarContainerOuter.className = 'progressBarOuterContainer'; - this.progressBarContainerOuter.style.display = 'none'; - - this.progressBarBox = document.createElement('div'); - this.progressBarBox.className = 'progressBarBox'; - - this.progressBarBackground = document.createElement('div'); - this.progressBarBackground.className = 'progressBarBackground'; - - this.progressBar = document.createElement('div'); - this.progressBar.className = 'progressBar'; - - this.progressBarBackground.appendChild(this.progressBar); - this.progressBarBox.appendChild(this.progressBarBackground); - this.progressBarContainerOuter.appendChild(this.progressBarBox); - - const style = document.createElement('style'); - style.innerHTML = ` - - .progressBarOuterContainer { - width: 100%; - height: 100%; - margin: 0; - top: 0; - left: 0; - position: absolute; - pointer-events: none; - } - - .progressBarBox { - z-index:99999; - padding: 7px 9px 5px 7px; - background-color: rgba(190, 190, 190, 0.75); - border: #555555 1px solid; - border-radius: 15px; - margin: 0; - position: absolute; - bottom: 50px; - left: 50%; - transform: translate(-50%, 0); - width: 180px; - height: 30px; - pointer-events: auto; - } - - .progressBarBackground { - width: 100%; - height: 25px; - border-radius:10px; - background-color: rgba(128, 128, 128, 0.75); - border: #444444 1px solid; - box-shadow: inset 0 0 10px #333333; - } - - .progressBar { - height: 25px; - width: 0px; - border-radius:10px; - background-color: rgba(0, 200, 0, 0.75); - box-shadow: inset 0 0 10px #003300; - } - - `; - this.progressBarContainerOuter.appendChild(style); - this.container.appendChild(this.progressBarContainerOuter); - } - - show() { - this.progressBarContainerOuter.style.display = 'block'; - } - - hide() { - this.progressBarContainerOuter.style.display = 'none'; - } - - setProgress(progress) { - this.progressBar.style.width = progress + '%'; - } - - setContainer(container) { - if (this.container && this.progressBarContainerOuter.parentElement === this.container) { - this.container.removeChild(this.progressBarContainerOuter); - } - if (container) { - this.container = container; - this.container.appendChild(this.progressBarContainerOuter); - this.progressBarContainerOuter.style.zIndex = this.container.style.zIndex + 1; - } - } - - } - - class InfoPanel { - - constructor(container) { - - this.container = container || document.body; - - this.infoCells = {}; - - const layout = [ - ['Camera position', 'cameraPosition'], - ['Camera look-at', 'cameraLookAt'], - ['Camera up', 'cameraUp'], - ['Camera mode', 'orthographicCamera'], - ['Cursor position', 'cursorPosition'], - ['FPS', 'fps'], - ['Rendering:', 'renderSplatCount'], - ['Sort time', 'sortTime'], - ['Render window', 'renderWindow'], - ['Focal adjustment', 'focalAdjustment'], - ['Splat scale', 'splatScale'], - ['Point cloud mode', 'pointCloudMode'] - ]; - - this.infoPanelContainer = document.createElement('div'); - const style = document.createElement('style'); - style.innerHTML = ` - - .infoPanel { - width: 430px; - padding: 10px; - background-color: rgba(50, 50, 50, 0.85); - border: #555555 2px solid; - color: #dddddd; - border-radius: 10px; - z-index: 9999; - font-family: arial; - font-size: 11pt; - text-align: left; - margin: 0; - top: 10px; - left:10px; - position: absolute; - pointer-events: auto; - } - - .info-panel-cell { - margin-bottom: 5px; - padding-bottom: 2px; - } - - .label-cell { - font-weight: bold; - font-size: 12pt; - width: 140px; - } - - `; - this.infoPanelContainer.append(style); - - this.infoPanel = document.createElement('div'); - this.infoPanel.className = 'infoPanel'; - - const infoTable = document.createElement('div'); - infoTable.style.display = 'table'; - - for (let layoutEntry of layout) { - const row = document.createElement('div'); - row.style.display = 'table-row'; - row.className = 'info-panel-row'; - - const labelCell = document.createElement('div'); - labelCell.style.display = 'table-cell'; - labelCell.innerHTML = `${layoutEntry[0]}: `; - labelCell.classList.add('info-panel-cell', 'label-cell'); - - const spacerCell = document.createElement('div'); - spacerCell.style.display = 'table-cell'; - spacerCell.style.width = '10px'; - spacerCell.innerHTML = ' '; - spacerCell.className = 'info-panel-cell'; - - const infoCell = document.createElement('div'); - infoCell.style.display = 'table-cell'; - infoCell.innerHTML = ''; - infoCell.className = 'info-panel-cell'; - - this.infoCells[layoutEntry[1]] = infoCell; - - row.appendChild(labelCell); - row.appendChild(spacerCell); - row.appendChild(infoCell); - - infoTable.appendChild(row); - } - - this.infoPanel.appendChild(infoTable); - this.infoPanelContainer.append(this.infoPanel); - this.infoPanelContainer.style.display = 'none'; - this.container.appendChild(this.infoPanelContainer); - - this.visible = false; - } - - update = function(renderDimensions, cameraPosition, cameraLookAtPosition, cameraUp, orthographicCamera, - meshCursorPosition, currentFPS, splatCount, splatRenderCount, - splatRenderCountPct, lastSortTime, focalAdjustment, splatScale, pointCloudMode) { - - const cameraPosString = `${cameraPosition.x.toFixed(5)}, ${cameraPosition.y.toFixed(5)}, ${cameraPosition.z.toFixed(5)}`; - if (this.infoCells.cameraPosition.innerHTML !== cameraPosString) { - this.infoCells.cameraPosition.innerHTML = cameraPosString; - } - - if (cameraLookAtPosition) { - const cla = cameraLookAtPosition; - const cameraLookAtString = `${cla.x.toFixed(5)}, ${cla.y.toFixed(5)}, ${cla.z.toFixed(5)}`; - if (this.infoCells.cameraLookAt.innerHTML !== cameraLookAtString) { - this.infoCells.cameraLookAt.innerHTML = cameraLookAtString; - } - } - - const cameraUpString = `${cameraUp.x.toFixed(5)}, ${cameraUp.y.toFixed(5)}, ${cameraUp.z.toFixed(5)}`; - if (this.infoCells.cameraUp.innerHTML !== cameraUpString) { - this.infoCells.cameraUp.innerHTML = cameraUpString; - } - - this.infoCells.orthographicCamera.innerHTML = orthographicCamera ? 'Orthographic' : 'Perspective'; - - if (meshCursorPosition) { - const cursPos = meshCursorPosition; - const cursorPosString = `${cursPos.x.toFixed(5)}, ${cursPos.y.toFixed(5)}, ${cursPos.z.toFixed(5)}`; - this.infoCells.cursorPosition.innerHTML = cursorPosString; - } else { - this.infoCells.cursorPosition.innerHTML = 'N/A'; - } - - this.infoCells.fps.innerHTML = currentFPS; - this.infoCells.renderWindow.innerHTML = `${renderDimensions.x} x ${renderDimensions.y}`; - - this.infoCells.renderSplatCount.innerHTML = - `${splatRenderCount} splats out of ${splatCount} (${splatRenderCountPct.toFixed(2)}%)`; - - this.infoCells.sortTime.innerHTML = `${lastSortTime.toFixed(3)} ms`; - this.infoCells.focalAdjustment.innerHTML = `${focalAdjustment.toFixed(3)}`; - this.infoCells.splatScale.innerHTML = `${splatScale.toFixed(3)}`; - this.infoCells.pointCloudMode.innerHTML = `${pointCloudMode}`; - }; - - setContainer(container) { - if (this.container && this.infoPanelContainer.parentElement === this.container) { - this.container.removeChild(this.infoPanelContainer); - } - if (container) { - this.container = container; - this.container.appendChild(this.infoPanelContainer); - this.infoPanelContainer.style.zIndex = this.container.style.zIndex + 1; - } - } - - show() { - this.infoPanelContainer.style.display = 'block'; - this.visible = true; - } - - hide() { - this.infoPanelContainer.style.display = 'none'; - this.visible = false; - } - - } - - const _axis = new THREE__namespace.Vector3(); - - class ArrowHelper extends THREE__namespace.Object3D { - - constructor(dir = new THREE__namespace.Vector3(0, 0, 1), origin = new THREE__namespace.Vector3(0, 0, 0), length = 1, - radius = 0.1, color = 0xffff00, headLength = length * 0.2, headRadius = headLength * 0.2) { - super(); - - this.type = 'ArrowHelper'; - - const lineGeometry = new THREE__namespace.CylinderGeometry(radius, radius, length, 32); - lineGeometry.translate(0, length / 2.0, 0); - const coneGeometry = new THREE__namespace.CylinderGeometry( 0, headRadius, headLength, 32); - coneGeometry.translate(0, length, 0); - - this.position.copy( origin ); - - this.line = new THREE__namespace.Mesh(lineGeometry, new THREE__namespace.MeshBasicMaterial({color: color, toneMapped: false})); - this.line.matrixAutoUpdate = false; - this.add(this.line); - - this.cone = new THREE__namespace.Mesh(coneGeometry, new THREE__namespace.MeshBasicMaterial({color: color, toneMapped: false})); - this.cone.matrixAutoUpdate = false; - this.add(this.cone); - - this.setDirection(dir); - } - - setDirection( dir ) { - if (dir.y > 0.99999) { - this.quaternion.set(0, 0, 0, 1); - } else if (dir.y < - 0.99999) { - this.quaternion.set(1, 0, 0, 0); - } else { - _axis.set(dir.z, 0, -dir.x).normalize(); - const radians = Math.acos(dir.y); - this.quaternion.setFromAxisAngle(_axis, radians); - } - } - - setColor( color ) { - this.line.material.color.set(color); - this.cone.material.color.set(color); - } - - copy(source) { - super.copy(source, false); - this.line.copy(source.line); - this.cone.copy(source.cone); - return this; - } - - dispose() { - this.line.geometry.dispose(); - this.line.material.dispose(); - this.cone.geometry.dispose(); - this.cone.material.dispose(); - } - - } - - class SceneHelper { - - constructor(threeScene) { - this.threeScene = threeScene; - this.splatRenderTarget = null; - this.renderTargetCopyQuad = null; - this.renderTargetCopyCamera = null; - this.meshCursor = null; - this.focusMarker = null; - this.controlPlane = null; - this.debugRoot = null; - this.secondaryDebugRoot = null; - } - - updateSplatRenderTargetForRenderDimensions(width, height) { - this.destroySplatRendertarget(); - this.splatRenderTarget = new THREE__namespace.WebGLRenderTarget(width, height, { - format: THREE__namespace.RGBAFormat, - stencilBuffer: false, - depthBuffer: true, - - }); - this.splatRenderTarget.depthTexture = new THREE__namespace.DepthTexture(width, height); - this.splatRenderTarget.depthTexture.format = THREE__namespace.DepthFormat; - this.splatRenderTarget.depthTexture.type = THREE__namespace.UnsignedIntType; - } - - destroySplatRendertarget() { - if (this.splatRenderTarget) { - this.splatRenderTarget = null; - } - } - - setupRenderTargetCopyObjects() { - const uniforms = { - 'sourceColorTexture': { - 'type': 't', - 'value': null - }, - 'sourceDepthTexture': { - 'type': 't', - 'value': null - }, - }; - const renderTargetCopyMaterial = new THREE__namespace.ShaderMaterial({ - vertexShader: ` - varying vec2 vUv; - void main() { - vUv = uv; - gl_Position = vec4( position.xy, 0.0, 1.0 ); - } - `, - fragmentShader: ` - #include - #include - varying vec2 vUv; - uniform sampler2D sourceColorTexture; - uniform sampler2D sourceDepthTexture; - void main() { - vec4 color = texture2D(sourceColorTexture, vUv); - float fragDepth = texture2D(sourceDepthTexture, vUv).x; - gl_FragDepth = fragDepth; - gl_FragColor = vec4(color.rgb, color.a * 2.0); - } - `, - uniforms: uniforms, - depthWrite: false, - depthTest: false, - transparent: true, - blending: THREE__namespace.CustomBlending, - blendSrc: THREE__namespace.SrcAlphaFactor, - blendSrcAlpha: THREE__namespace.SrcAlphaFactor, - blendDst: THREE__namespace.OneMinusSrcAlphaFactor, - blendDstAlpha: THREE__namespace.OneMinusSrcAlphaFactor - }); - renderTargetCopyMaterial.extensions.fragDepth = true; - this.renderTargetCopyQuad = new THREE__namespace.Mesh(new THREE__namespace.PlaneGeometry(2, 2), renderTargetCopyMaterial); - this.renderTargetCopyCamera = new THREE__namespace.OrthographicCamera(-1, 1, 1, -1, 0, 1); - } - - destroyRenderTargetCopyObjects() { - if (this.renderTargetCopyQuad) { - disposeAllMeshes(this.renderTargetCopyQuad); - this.renderTargetCopyQuad = null; - } - } - - setupMeshCursor() { - if (!this.meshCursor) { - const coneGeometry = new THREE__namespace.ConeGeometry(0.5, 1.5, 32); - const coneMaterial = new THREE__namespace.MeshBasicMaterial({color: 0xFFFFFF}); - - const downArrow = new THREE__namespace.Mesh(coneGeometry, coneMaterial); - downArrow.rotation.set(0, 0, Math.PI); - downArrow.position.set(0, 1, 0); - const upArrow = new THREE__namespace.Mesh(coneGeometry, coneMaterial); - upArrow.position.set(0, -1, 0); - const leftArrow = new THREE__namespace.Mesh(coneGeometry, coneMaterial); - leftArrow.rotation.set(0, 0, Math.PI / 2.0); - leftArrow.position.set(1, 0, 0); - const rightArrow = new THREE__namespace.Mesh(coneGeometry, coneMaterial); - rightArrow.rotation.set(0, 0, -Math.PI / 2.0); - rightArrow.position.set(-1, 0, 0); - - this.meshCursor = new THREE__namespace.Object3D(); - this.meshCursor.add(downArrow); - this.meshCursor.add(upArrow); - this.meshCursor.add(leftArrow); - this.meshCursor.add(rightArrow); - this.meshCursor.scale.set(0.1, 0.1, 0.1); - this.threeScene.add(this.meshCursor); - this.meshCursor.visible = false; - } - } - - destroyMeshCursor() { - if (this.meshCursor) { - disposeAllMeshes(this.meshCursor); - this.threeScene.remove(this.meshCursor); - this.meshCursor = null; - } - } - - setMeshCursorVisibility(visible) { - this.meshCursor.visible = visible; - } - - getMeschCursorVisibility() { - return this.meshCursor.visible; - } - - setMeshCursorPosition(position) { - this.meshCursor.position.copy(position); - } - - positionAndOrientMeshCursor(position, camera) { - this.meshCursor.position.copy(position); - this.meshCursor.up.copy(camera.up); - this.meshCursor.lookAt(camera.position); - } - - setupFocusMarker() { - if (!this.focusMarker) { - const sphereGeometry = new THREE__namespace.SphereGeometry(.5, 32, 32); - const focusMarkerMaterial = SceneHelper.buildFocusMarkerMaterial(); - focusMarkerMaterial.depthTest = false; - focusMarkerMaterial.depthWrite = false; - focusMarkerMaterial.transparent = true; - this.focusMarker = new THREE__namespace.Mesh(sphereGeometry, focusMarkerMaterial); - } - } - - destroyFocusMarker() { - if (this.focusMarker) { - disposeAllMeshes(this.focusMarker); - this.focusMarker = null; - } - } - - updateFocusMarker = function() { - - const tempPosition = new THREE__namespace.Vector3(); - const tempMatrix = new THREE__namespace.Matrix4(); - const toCamera = new THREE__namespace.Vector3(); - - return function(position, camera, viewport) { - tempMatrix.copy(camera.matrixWorld).invert(); - tempPosition.copy(position).applyMatrix4(tempMatrix); - tempPosition.normalize().multiplyScalar(10); - tempPosition.applyMatrix4(camera.matrixWorld); - toCamera.copy(camera.position).sub(position); - const toCameraDistance = toCamera.length(); - this.focusMarker.position.copy(position); - this.focusMarker.scale.set(toCameraDistance, toCameraDistance, toCameraDistance); - this.focusMarker.material.uniforms.realFocusPosition.value.copy(position); - this.focusMarker.material.uniforms.viewport.value.copy(viewport); - this.focusMarker.material.uniformsNeedUpdate = true; - }; - - }(); - - setFocusMarkerVisibility(visible) { - this.focusMarker.visible = visible; - } - - setFocusMarkerOpacity(opacity) { - this.focusMarker.material.uniforms.opacity.value = opacity; - this.focusMarker.material.uniformsNeedUpdate = true; - } - - getFocusMarkerOpacity() { - return this.focusMarker.material.uniforms.opacity.value; - } - - setupControlPlane() { - if (!this.controlPlane) { - const planeGeometry = new THREE__namespace.PlaneGeometry(1, 1); - planeGeometry.rotateX(-Math.PI / 2); - const planeMaterial = new THREE__namespace.MeshBasicMaterial({color: 0xffffff}); - planeMaterial.transparent = true; - planeMaterial.opacity = 0.6; - planeMaterial.depthTest = false; - planeMaterial.depthWrite = false; - planeMaterial.side = THREE__namespace.DoubleSide; - const planeMesh = new THREE__namespace.Mesh(planeGeometry, planeMaterial); - - const arrowDir = new THREE__namespace.Vector3(0, 1, 0); - arrowDir.normalize(); - const arrowOrigin = new THREE__namespace.Vector3(0, 0, 0); - const arrowLength = 0.5; - const arrowRadius = 0.01; - const arrowColor = 0x00dd00; - const arrowHelper = new ArrowHelper(arrowDir, arrowOrigin, arrowLength, arrowRadius, arrowColor, 0.1, 0.03); - - this.controlPlane = new THREE__namespace.Object3D(); - this.controlPlane.add(planeMesh); - this.controlPlane.add(arrowHelper); - } - } - - destroyControlPlane() { - if (this.controlPlane) { - disposeAllMeshes(this.controlPlane); - this.controlPlane = null; - } - } - - setControlPlaneVisibility(visible) { - this.controlPlane.visible = visible; - } - - positionAndOrientControlPlane = function() { - - const tempQuaternion = new THREE__namespace.Quaternion(); - const defaultUp = new THREE__namespace.Vector3(0, 1, 0); - - return function(position, up) { - tempQuaternion.setFromUnitVectors(defaultUp, up); - this.controlPlane.position.copy(position); - this.controlPlane.quaternion.copy(tempQuaternion); - }; - - }(); - - addDebugMeshes() { - this.debugRoot = this.createDebugMeshes(); - this.secondaryDebugRoot = this.createSecondaryDebugMeshes(); - this.threeScene.add(this.debugRoot); - this.threeScene.add(this.secondaryDebugRoot); - } - - destroyDebugMeshes() { - for (let debugRoot of [this.debugRoot, this.secondaryDebugRoot]) { - if (debugRoot) { - disposeAllMeshes(debugRoot); - this.threeScene.remove(debugRoot); - } - } - this.debugRoot = null; - this.secondaryDebugRoot = null; - } - - createDebugMeshes(renderOrder) { - const sphereGeometry = new THREE__namespace.SphereGeometry(1, 32, 32); - const debugMeshRoot = new THREE__namespace.Object3D(); - - const createMesh = (color, position) => { - let sphereMesh = new THREE__namespace.Mesh(sphereGeometry, SceneHelper.buildDebugMaterial(color)); - sphereMesh.renderOrder = renderOrder; - debugMeshRoot.add(sphereMesh); - sphereMesh.position.fromArray(position); - }; - - createMesh(0xff0000, [-50, 0, 0]); - createMesh(0xff0000, [50, 0, 0]); - createMesh(0x00ff00, [0, 0, -50]); - createMesh(0x00ff00, [0, 0, 50]); - createMesh(0xffaa00, [5, 0, 5]); - - return debugMeshRoot; - } - - createSecondaryDebugMeshes(renderOrder) { - const boxGeometry = new THREE__namespace.BoxGeometry(3, 3, 3); - const debugMeshRoot = new THREE__namespace.Object3D(); - - let boxColor = 0xBBBBBB; - const createMesh = (position) => { - let boxMesh = new THREE__namespace.Mesh(boxGeometry, SceneHelper.buildDebugMaterial(boxColor)); - boxMesh.renderOrder = renderOrder; - debugMeshRoot.add(boxMesh); - boxMesh.position.fromArray(position); - }; - - let separation = 10; - createMesh([-separation, 0, -separation]); - createMesh([-separation, 0, separation]); - createMesh([separation, 0, -separation]); - createMesh([separation, 0, separation]); - - return debugMeshRoot; - } - - static buildDebugMaterial(color) { - const vertexShaderSource = ` - #include - varying float ndcDepth; - - void main() { - gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(position.xyz, 1.0); - ndcDepth = gl_Position.z / gl_Position.w; - gl_Position.x = gl_Position.x / gl_Position.w; - gl_Position.y = gl_Position.y / gl_Position.w; - gl_Position.z = 0.0; - gl_Position.w = 1.0; - - } - `; - - const fragmentShaderSource = ` - #include - uniform vec3 color; - varying float ndcDepth; - void main() { - gl_FragDepth = (ndcDepth + 1.0) / 2.0; - gl_FragColor = vec4(color.rgb, 0.0); - } - `; - - const uniforms = { - 'color': { - 'type': 'v3', - 'value': new THREE__namespace.Color(color) - }, - }; - - const material = new THREE__namespace.ShaderMaterial({ - uniforms: uniforms, - vertexShader: vertexShaderSource, - fragmentShader: fragmentShaderSource, - transparent: false, - depthTest: true, - depthWrite: true, - side: THREE__namespace.FrontSide - }); - material.extensions.fragDepth = true; - - return material; - } - - static buildFocusMarkerMaterial(color) { - const vertexShaderSource = ` - #include - - uniform vec2 viewport; - uniform vec3 realFocusPosition; - - varying vec4 ndcPosition; - varying vec4 ndcCenter; - varying vec4 ndcFocusPosition; - - void main() { - float radius = 0.01; - - vec4 viewPosition = modelViewMatrix * vec4(position.xyz, 1.0); - vec4 viewCenter = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0); - - vec4 viewFocusPosition = modelViewMatrix * vec4(realFocusPosition, 1.0); - - ndcPosition = projectionMatrix * viewPosition; - ndcPosition = ndcPosition * vec4(1.0 / ndcPosition.w); - ndcCenter = projectionMatrix * viewCenter; - ndcCenter = ndcCenter * vec4(1.0 / ndcCenter.w); - - ndcFocusPosition = projectionMatrix * viewFocusPosition; - ndcFocusPosition = ndcFocusPosition * vec4(1.0 / ndcFocusPosition.w); - - gl_Position = projectionMatrix * viewPosition; - - } - `; - - const fragmentShaderSource = ` - #include - uniform vec3 color; - uniform vec2 viewport; - uniform float opacity; - - varying vec4 ndcPosition; - varying vec4 ndcCenter; - varying vec4 ndcFocusPosition; - - void main() { - vec2 screenPosition = vec2(ndcPosition) * viewport; - vec2 screenCenter = vec2(ndcCenter) * viewport; - - vec2 screenVec = screenPosition - screenCenter; - - float projectedRadius = length(screenVec); - - float lineWidth = 0.0005 * viewport.y; - float aaRange = 0.0025 * viewport.y; - float radius = 0.06 * viewport.y; - float radDiff = abs(projectedRadius - radius) - lineWidth; - float alpha = 1.0 - clamp(radDiff / 5.0, 0.0, 1.0); - - gl_FragColor = vec4(color.rgb, alpha * opacity); - } - `; - - const uniforms = { - 'color': { - 'type': 'v3', - 'value': new THREE__namespace.Color(color) - }, - 'realFocusPosition': { - 'type': 'v3', - 'value': new THREE__namespace.Vector3() - }, - 'viewport': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2() - }, - 'opacity': { - 'value': 0.0 - } - }; - - const material = new THREE__namespace.ShaderMaterial({ - uniforms: uniforms, - vertexShader: vertexShaderSource, - fragmentShader: fragmentShaderSource, - transparent: true, - depthTest: false, - depthWrite: false, - side: THREE__namespace.FrontSide - }); - - return material; - } - - dispose() { - this.destroyMeshCursor(); - this.destroyFocusMarker(); - this.destroyDebugMeshes(); - this.destroyControlPlane(); - this.destroyRenderTargetCopyObjects(); - this.destroySplatRendertarget(); - } - } - - const VectorRight = new THREE__namespace.Vector3(1, 0, 0); - const VectorUp = new THREE__namespace.Vector3(0, 1, 0); - const VectorBackward = new THREE__namespace.Vector3(0, 0, 1); - - class Ray { - - constructor(origin = new THREE__namespace.Vector3(), direction = new THREE__namespace.Vector3()) { - this.origin = new THREE__namespace.Vector3(); - this.direction = new THREE__namespace.Vector3(); - this.setParameters(origin, direction); - } - - setParameters(origin, direction) { - this.origin.copy(origin); - this.direction.copy(direction).normalize(); - } - - boxContainsPoint(box, point, epsilon) { - return point.x < box.min.x - epsilon || point.x > box.max.x + epsilon || - point.y < box.min.y - epsilon || point.y > box.max.y + epsilon || - point.z < box.min.z - epsilon || point.z > box.max.z + epsilon ? false : true; - } - - intersectBox = function() { - - const planeIntersectionPoint = new THREE__namespace.Vector3(); - const planeIntersectionPointArray = []; - const originArray = []; - const directionArray = []; - - return function(box, outHit) { - - originArray[0] = this.origin.x; - originArray[1] = this.origin.y; - originArray[2] = this.origin.z; - directionArray[0] = this.direction.x; - directionArray[1] = this.direction.y; - directionArray[2] = this.direction.z; - - if (this.boxContainsPoint(box, this.origin, 0.0001)) { - if (outHit) { - outHit.origin.copy(this.origin); - outHit.normal.set(0, 0, 0); - outHit.distance = -1; - } - return true; - } - - for (let i = 0; i < 3; i++) { - if (directionArray[i] == 0.0) continue; - - const hitNormal = i == 0 ? VectorRight : i == 1 ? VectorUp : VectorBackward; - const extremeVec = directionArray[i] < 0 ? box.max : box.min; - let multiplier = -Math.sign(directionArray[i]); - planeIntersectionPointArray[0] = i == 0 ? extremeVec.x : i == 1 ? extremeVec.y : extremeVec.z; - let toSide = planeIntersectionPointArray[0] - originArray[i]; - - if (toSide * multiplier < 0) { - const idx1 = (i + 1) % 3; - const idx2 = (i + 2) % 3; - planeIntersectionPointArray[2] = directionArray[idx1] / directionArray[i] * toSide + originArray[idx1]; - planeIntersectionPointArray[1] = directionArray[idx2] / directionArray[i] * toSide + originArray[idx2]; - planeIntersectionPoint.set(planeIntersectionPointArray[i], - planeIntersectionPointArray[idx2], - planeIntersectionPointArray[idx1]); - if (this.boxContainsPoint(box, planeIntersectionPoint, 0.0001)) { - if (outHit) { - outHit.origin.copy(planeIntersectionPoint); - outHit.normal.copy(hitNormal).multiplyScalar(multiplier); - outHit.distance = planeIntersectionPoint.sub(this.origin).length(); - } - return true; - } - } - } - - return false; - }; - - }(); - - intersectSphere = function() { - - const toSphereCenterVec = new THREE__namespace.Vector3(); - - return function(center, radius, outHit) { - toSphereCenterVec.copy(center).sub(this.origin); - const toClosestApproach = toSphereCenterVec.dot(this.direction); - const toClosestApproachSq = toClosestApproach * toClosestApproach; - const toSphereCenterSq = toSphereCenterVec.dot(toSphereCenterVec); - const diffSq = toSphereCenterSq - toClosestApproachSq; - const radiusSq = radius * radius; - - if (diffSq > radiusSq) return false; - - const thc = Math.sqrt(radiusSq - diffSq); - const t0 = toClosestApproach - thc; - const t1 = toClosestApproach + thc; - - if (t1 < 0) return false; - let t = t0 < 0 ? t1 : t0; - - if (outHit) { - outHit.origin.copy(this.origin).addScaledVector(this.direction, t); - outHit.normal.copy(outHit.origin).sub(center).normalize(); - outHit.distance = t; - } - return true; - }; - - }(); - } - - class Hit { - - constructor() { - this.origin = new THREE__namespace.Vector3(); - this.normal = new THREE__namespace.Vector3(); - this.distance = 0; - this.splatIndex = 0; - } - - set(origin, normal, distance, splatIndex) { - this.origin.copy(origin); - this.normal.copy(normal); - this.distance = distance; - this.splatIndex = splatIndex; - } - - clone() { - const hitClone = new Hit(); - hitClone.origin.copy(this.origin); - hitClone.normal.copy(this.normal); - hitClone.distance = this.distance; - hitClone.splatIndex = this.splatIndex; - return hitClone; - } - - } - - const SplatRenderMode = { - ThreeD: 0, - TwoD: 1 - }; - - class Raycaster { - - constructor(origin, direction, raycastAgainstTrueSplatEllipsoid = false) { - this.ray = new Ray(origin, direction); - this.raycastAgainstTrueSplatEllipsoid = raycastAgainstTrueSplatEllipsoid; - } - - setFromCameraAndScreenPosition = function() { - - const ndcCoords = new THREE__namespace.Vector2(); - - return function(camera, screenPosition, screenDimensions) { - ndcCoords.x = screenPosition.x / screenDimensions.x * 2.0 - 1.0; - ndcCoords.y = (screenDimensions.y - screenPosition.y) / screenDimensions.y * 2.0 - 1.0; - if (camera.isPerspectiveCamera) { - this.ray.origin.setFromMatrixPosition(camera.matrixWorld); - this.ray.direction.set(ndcCoords.x, ndcCoords.y, 0.5 ).unproject(camera).sub(this.ray.origin).normalize(); - this.camera = camera; - } else if (camera.isOrthographicCamera) { - this.ray.origin.set(ndcCoords.x, ndcCoords.y, - (camera.near + camera.far) / (camera.near - camera.far)).unproject(camera); - this.ray.direction.set(0, 0, -1).transformDirection(camera.matrixWorld); - this.camera = camera; - } else { - throw new Error('Raycaster::setFromCameraAndScreenPosition() -> Unsupported camera type'); - } - }; - - }(); - - intersectSplatMesh = function() { - - const toLocal = new THREE__namespace.Matrix4(); - const fromLocal = new THREE__namespace.Matrix4(); - const sceneTransform = new THREE__namespace.Matrix4(); - const localRay = new Ray(); - const tempPoint = new THREE__namespace.Vector3(); - - return function(splatMesh, outHits = []) { - const splatTree = splatMesh.getSplatTree(); - - if (!splatTree) return; - - for (let s = 0; s < splatTree.subTrees.length; s++) { - const subTree = splatTree.subTrees[s]; - - fromLocal.copy(splatMesh.matrixWorld); - if (splatMesh.dynamicMode) { - splatMesh.getSceneTransform(s, sceneTransform); - fromLocal.multiply(sceneTransform); - } - toLocal.copy(fromLocal).invert(); - - localRay.origin.copy(this.ray.origin).applyMatrix4(toLocal); - localRay.direction.copy(this.ray.origin).add(this.ray.direction); - localRay.direction.applyMatrix4(toLocal).sub(localRay.origin).normalize(); - - const outHitsForSubTree = []; - if (subTree.rootNode) { - this.castRayAtSplatTreeNode(localRay, splatTree, subTree.rootNode, outHitsForSubTree); - } - - outHitsForSubTree.forEach((hit) => { - hit.origin.applyMatrix4(fromLocal); - hit.normal.applyMatrix4(fromLocal).normalize(); - hit.distance = tempPoint.copy(hit.origin).sub(this.ray.origin).length(); - }); - - outHits.push(...outHitsForSubTree); - } - - outHits.sort((a, b) => { - if (a.distance > b.distance) return 1; - else return -1; - }); - - return outHits; - }; - - }(); - - castRayAtSplatTreeNode = function() { - - const tempColor = new THREE__namespace.Vector4(); - const tempCenter = new THREE__namespace.Vector3(); - const tempScale = new THREE__namespace.Vector3(); - const tempRotation = new THREE__namespace.Quaternion(); - const tempHit = new Hit(); - const scaleEpsilon = 0.0000001; - - const origin = new THREE__namespace.Vector3(0, 0, 0); - const uniformScaleMatrix = new THREE__namespace.Matrix4(); - const scaleMatrix = new THREE__namespace.Matrix4(); - const rotationMatrix = new THREE__namespace.Matrix4(); - const toSphereSpace = new THREE__namespace.Matrix4(); - const fromSphereSpace = new THREE__namespace.Matrix4(); - const tempRay = new Ray(); - - return function(ray, splatTree, node, outHits = []) { - if (!ray.intersectBox(node.boundingBox)) { - return; - } - if (node.data && node.data.indexes && node.data.indexes.length > 0) { - for (let i = 0; i < node.data.indexes.length; i++) { - - const splatGlobalIndex = node.data.indexes[i]; - const splatSceneIndex = splatTree.splatMesh.getSceneIndexForSplat(splatGlobalIndex); - const splatScene = splatTree.splatMesh.getScene(splatSceneIndex); - if (!splatScene.visible) continue; - - splatTree.splatMesh.getSplatColor(splatGlobalIndex, tempColor); - splatTree.splatMesh.getSplatCenter(splatGlobalIndex, tempCenter); - splatTree.splatMesh.getSplatScaleAndRotation(splatGlobalIndex, tempScale, tempRotation); - - if (tempScale.x <= scaleEpsilon || tempScale.y <= scaleEpsilon || - splatTree.splatMesh.splatRenderMode === SplatRenderMode.ThreeD && tempScale.z <= scaleEpsilon) { - continue; - } - - if (!this.raycastAgainstTrueSplatEllipsoid) { - let radius = (tempScale.x + tempScale.y); - let componentCount = 2; - if (splatTree.splatMesh.splatRenderMode === SplatRenderMode.ThreeD) { - radius += tempScale.z; - componentCount = 3; - } - radius = radius / componentCount; - if (ray.intersectSphere(tempCenter, radius, tempHit)) { - const hitClone = tempHit.clone(); - hitClone.splatIndex = splatGlobalIndex; - outHits.push(hitClone); - } - } else { - scaleMatrix.makeScale(tempScale.x, tempScale.y, tempScale.z); - rotationMatrix.makeRotationFromQuaternion(tempRotation); - const uniformScale = Math.log10(tempColor.w) * 2.0; - uniformScaleMatrix.makeScale(uniformScale, uniformScale, uniformScale); - fromSphereSpace.copy(uniformScaleMatrix).multiply(rotationMatrix).multiply(scaleMatrix); - toSphereSpace.copy(fromSphereSpace).invert(); - tempRay.origin.copy(ray.origin).sub(tempCenter).applyMatrix4(toSphereSpace); - tempRay.direction.copy(ray.origin).add(ray.direction).sub(tempCenter); - tempRay.direction.applyMatrix4(toSphereSpace).sub(tempRay.origin).normalize(); - if (tempRay.intersectSphere(origin, 1.0, tempHit)) { - const hitClone = tempHit.clone(); - hitClone.splatIndex = splatGlobalIndex; - hitClone.origin.applyMatrix4(fromSphereSpace).add(tempCenter); - outHits.push(hitClone); - } - } - } - } - if (node.children && node.children.length > 0) { - for (let child of node.children) { - this.castRayAtSplatTreeNode(ray, splatTree, child, outHits); - } - } - return outHits; - }; - - }(); - } - - class SplatMaterial { - - static buildVertexShaderBase(dynamicMode = false, enableOptionalEffects = false, maxSphericalHarmonicsDegree = 0, customVars = '') { - let vertexShaderSource = ` - precision highp float; - #include - - attribute uint splatIndex; - uniform highp usampler2D centersColorsTexture; - uniform highp sampler2D sphericalHarmonicsTexture; - uniform highp sampler2D sphericalHarmonicsTextureR; - uniform highp sampler2D sphericalHarmonicsTextureG; - uniform highp sampler2D sphericalHarmonicsTextureB; - - uniform highp usampler2D sceneIndexesTexture; - uniform vec2 sceneIndexesTextureSize; - uniform int sceneCount; - `; - - if (enableOptionalEffects) { - vertexShaderSource += ` - uniform float sceneOpacity[${Constants.MaxScenes}]; - uniform int sceneVisibility[${Constants.MaxScenes}]; - `; - } - - if (dynamicMode) { - vertexShaderSource += ` - uniform highp mat4 transforms[${Constants.MaxScenes}]; - `; - } - - vertexShaderSource += ` - ${customVars} - uniform vec2 focal; - uniform float orthoZoom; - uniform int orthographicMode; - uniform int pointCloudModeEnabled; - uniform float inverseFocalAdjustment; - uniform vec2 viewport; - uniform vec2 basisViewport; - uniform vec2 centersColorsTextureSize; - uniform int sphericalHarmonicsDegree; - uniform vec2 sphericalHarmonicsTextureSize; - uniform int sphericalHarmonics8BitMode; - uniform int sphericalHarmonicsMultiTextureMode; - uniform float visibleRegionRadius; - uniform float visibleRegionFadeStartRadius; - uniform float firstRenderTime; - uniform float currentTime; - uniform int fadeInComplete; - uniform vec3 sceneCenter; - uniform float splatScale; - uniform float sphericalHarmonics8BitCompressionRangeMin[${Constants.MaxScenes}]; - uniform float sphericalHarmonics8BitCompressionRangeMax[${Constants.MaxScenes}]; - - varying vec4 vColor; - varying vec2 vUv; - varying vec2 vPosition; - - mat3 quaternionToRotationMatrix(float x, float y, float z, float w) { - float s = 1.0 / sqrt(w * w + x * x + y * y + z * z); - - return mat3( - 1. - 2. * (y * y + z * z), - 2. * (x * y + w * z), - 2. * (x * z - w * y), - 2. * (x * y - w * z), - 1. - 2. * (x * x + z * z), - 2. * (y * z + w * x), - 2. * (x * z + w * y), - 2. * (y * z - w * x), - 1. - 2. * (x * x + y * y) - ); - } - - const float sqrt8 = sqrt(8.0); - const float minAlpha = 1.0 / 255.0; - - const vec4 encodeNorm4 = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0); - const uvec4 mask4 = uvec4(uint(0x000000FF), uint(0x0000FF00), uint(0x00FF0000), uint(0xFF000000)); - const uvec4 shift4 = uvec4(0, 8, 16, 24); - vec4 uintToRGBAVec (uint u) { - uvec4 urgba = mask4 & u; - urgba = urgba >> shift4; - vec4 rgba = vec4(urgba) * encodeNorm4; - return rgba; - } - - vec2 getDataUV(in int stride, in int offset, in vec2 dimensions) { - vec2 samplerUV = vec2(0.0, 0.0); - float d = float(splatIndex * uint(stride) + uint(offset)) / dimensions.x; - samplerUV.y = float(floor(d)) / dimensions.y; - samplerUV.x = fract(d); - return samplerUV; - } - - vec2 getDataUVF(in uint sIndex, in float stride, in uint offset, in vec2 dimensions) { - vec2 samplerUV = vec2(0.0, 0.0); - float d = float(uint(float(sIndex) * stride) + offset) / dimensions.x; - samplerUV.y = float(floor(d)) / dimensions.y; - samplerUV.x = fract(d); - return samplerUV; - } - - const float SH_C1 = 0.4886025119029199f; - const float[5] SH_C2 = float[](1.0925484, -1.0925484, 0.3153916, -1.0925484, 0.5462742); - - void main () { - - uint oddOffset = splatIndex & uint(0x00000001); - uint doubleOddOffset = oddOffset * uint(2); - bool isEven = oddOffset == uint(0); - uint nearestEvenIndex = splatIndex - oddOffset; - float fOddOffset = float(oddOffset); - - uvec4 sampledCenterColor = texture(centersColorsTexture, getDataUV(1, 0, centersColorsTextureSize)); - vec3 splatCenter = uintBitsToFloat(uvec3(sampledCenterColor.gba)); - - uint sceneIndex = uint(0); - if (sceneCount > 1) { - sceneIndex = texture(sceneIndexesTexture, getDataUV(1, 0, sceneIndexesTextureSize)).r; - } - `; - - if (enableOptionalEffects) { - vertexShaderSource += ` - float splatOpacityFromScene = sceneOpacity[sceneIndex]; - int sceneVisible = sceneVisibility[sceneIndex]; - if (splatOpacityFromScene <= 0.01 || sceneVisible == 0) { - gl_Position = vec4(0.0, 0.0, 2.0, 1.0); - return; - } - `; - } - - if (dynamicMode) { - vertexShaderSource += ` - mat4 transform = transforms[sceneIndex]; - mat4 transformModelViewMatrix = viewMatrix * transform; - `; - } else { - vertexShaderSource += `mat4 transformModelViewMatrix = modelViewMatrix;`; - } - - vertexShaderSource += ` - float sh8BitCompressionRangeMinForScene = sphericalHarmonics8BitCompressionRangeMin[sceneIndex]; - float sh8BitCompressionRangeMaxForScene = sphericalHarmonics8BitCompressionRangeMax[sceneIndex]; - float sh8BitCompressionRangeForScene = sh8BitCompressionRangeMaxForScene - sh8BitCompressionRangeMinForScene; - float sh8BitCompressionHalfRangeForScene = sh8BitCompressionRangeForScene / 2.0; - vec3 vec8BitSHShift = vec3(sh8BitCompressionRangeMinForScene); - - vec4 viewCenter = transformModelViewMatrix * vec4(splatCenter, 1.0); - - vec4 clipCenter = projectionMatrix * viewCenter; - - float clip = 1.2 * clipCenter.w; - if (clipCenter.z < -clip || clipCenter.x < -clip || clipCenter.x > clip || clipCenter.y < -clip || clipCenter.y > clip) { - gl_Position = vec4(0.0, 0.0, 2.0, 1.0); - return; - } - - vec3 ndcCenter = clipCenter.xyz / clipCenter.w; - - vPosition = position.xy; - vColor = uintToRGBAVec(sampledCenterColor.r); - `; - - // Proceed to sampling and rendering 1st degree spherical harmonics - if (maxSphericalHarmonicsDegree >= 1) { - - vertexShaderSource += ` - if (sphericalHarmonicsDegree >= 1) { - `; - - if (dynamicMode) { - vertexShaderSource += ` - vec3 worldViewDir = normalize(splatCenter - vec3(inverse(transform) * vec4(cameraPosition, 1.0))); - `; - } else { - vertexShaderSource += ` - vec3 worldViewDir = normalize(splatCenter - cameraPosition); - `; - } - - vertexShaderSource += ` - vec3 sh1; - vec3 sh2; - vec3 sh3; - `; - - if (maxSphericalHarmonicsDegree >= 2) { - vertexShaderSource += ` - vec3 sh4; - vec3 sh5; - vec3 sh6; - vec3 sh7; - vec3 sh8; - `; - } - - // Determining how to sample spherical harmonics textures to get the coefficients for calculations for a given degree - // depends on how many total degrees (maxSphericalHarmonicsDegree) are present in the textures. This is because that - // number affects how they are packed in the textures, and therefore the offset & stride required to access them. - - // Sample spherical harmonics textures with 1 degree worth of data for 1st degree calculations, and store in sh1, sh2, and sh3 - if (maxSphericalHarmonicsDegree === 1) { - vertexShaderSource += ` - if (sphericalHarmonicsMultiTextureMode == 0) { - vec2 shUV = getDataUVF(nearestEvenIndex, 2.5, doubleOddOffset, sphericalHarmonicsTextureSize); - vec4 sampledSH0123 = texture(sphericalHarmonicsTexture, shUV); - shUV = getDataUVF(nearestEvenIndex, 2.5, doubleOddOffset + uint(1), sphericalHarmonicsTextureSize); - vec4 sampledSH4567 = texture(sphericalHarmonicsTexture, shUV); - shUV = getDataUVF(nearestEvenIndex, 2.5, doubleOddOffset + uint(2), sphericalHarmonicsTextureSize); - vec4 sampledSH891011 = texture(sphericalHarmonicsTexture, shUV); - sh1 = vec3(sampledSH0123.rgb) * (1.0 - fOddOffset) + vec3(sampledSH0123.ba, sampledSH4567.r) * fOddOffset; - sh2 = vec3(sampledSH0123.a, sampledSH4567.rg) * (1.0 - fOddOffset) + vec3(sampledSH4567.gba) * fOddOffset; - sh3 = vec3(sampledSH4567.ba, sampledSH891011.r) * (1.0 - fOddOffset) + vec3(sampledSH891011.rgb) * fOddOffset; - } else { - vec2 sampledSH01R = texture(sphericalHarmonicsTextureR, getDataUV(2, 0, sphericalHarmonicsTextureSize)).rg; - vec2 sampledSH23R = texture(sphericalHarmonicsTextureR, getDataUV(2, 1, sphericalHarmonicsTextureSize)).rg; - vec2 sampledSH01G = texture(sphericalHarmonicsTextureG, getDataUV(2, 0, sphericalHarmonicsTextureSize)).rg; - vec2 sampledSH23G = texture(sphericalHarmonicsTextureG, getDataUV(2, 1, sphericalHarmonicsTextureSize)).rg; - vec2 sampledSH01B = texture(sphericalHarmonicsTextureB, getDataUV(2, 0, sphericalHarmonicsTextureSize)).rg; - vec2 sampledSH23B = texture(sphericalHarmonicsTextureB, getDataUV(2, 1, sphericalHarmonicsTextureSize)).rg; - sh1 = vec3(sampledSH01R.rg, sampledSH23R.r); - sh2 = vec3(sampledSH01G.rg, sampledSH23G.r); - sh3 = vec3(sampledSH01B.rg, sampledSH23B.r); - } - `; - // Sample spherical harmonics textures with 2 degrees worth of data for 1st degree calculations, and store in sh1, sh2, and sh3 - } else if (maxSphericalHarmonicsDegree === 2) { - vertexShaderSource += ` - vec4 sampledSH0123; - vec4 sampledSH4567; - vec4 sampledSH891011; - - vec4 sampledSH0123R; - vec4 sampledSH0123G; - vec4 sampledSH0123B; - - if (sphericalHarmonicsMultiTextureMode == 0) { - sampledSH0123 = texture(sphericalHarmonicsTexture, getDataUV(6, 0, sphericalHarmonicsTextureSize)); - sampledSH4567 = texture(sphericalHarmonicsTexture, getDataUV(6, 1, sphericalHarmonicsTextureSize)); - sampledSH891011 = texture(sphericalHarmonicsTexture, getDataUV(6, 2, sphericalHarmonicsTextureSize)); - sh1 = sampledSH0123.rgb; - sh2 = vec3(sampledSH0123.a, sampledSH4567.rg); - sh3 = vec3(sampledSH4567.ba, sampledSH891011.r); - } else { - sampledSH0123R = texture(sphericalHarmonicsTextureR, getDataUV(2, 0, sphericalHarmonicsTextureSize)); - sampledSH0123G = texture(sphericalHarmonicsTextureG, getDataUV(2, 0, sphericalHarmonicsTextureSize)); - sampledSH0123B = texture(sphericalHarmonicsTextureB, getDataUV(2, 0, sphericalHarmonicsTextureSize)); - sh1 = vec3(sampledSH0123R.rgb); - sh2 = vec3(sampledSH0123G.rgb); - sh3 = vec3(sampledSH0123B.rgb); - } - `; - } - - // Perform 1st degree spherical harmonics calculations - vertexShaderSource += ` - if (sphericalHarmonics8BitMode == 1) { - sh1 = sh1 * sh8BitCompressionRangeForScene + vec8BitSHShift; - sh2 = sh2 * sh8BitCompressionRangeForScene + vec8BitSHShift; - sh3 = sh3 * sh8BitCompressionRangeForScene + vec8BitSHShift; - } - float x = worldViewDir.x; - float y = worldViewDir.y; - float z = worldViewDir.z; - vColor.rgb += SH_C1 * (-sh1 * y + sh2 * z - sh3 * x); - `; - - // Proceed to sampling and rendering 2nd degree spherical harmonics - if (maxSphericalHarmonicsDegree >= 2) { - - vertexShaderSource += ` - if (sphericalHarmonicsDegree >= 2) { - float xx = x * x; - float yy = y * y; - float zz = z * z; - float xy = x * y; - float yz = y * z; - float xz = x * z; - `; - - // Sample spherical harmonics textures with 2 degrees worth of data for 2nd degree calculations, - // and store in sh4, sh5, sh6, sh7, and sh8 - if (maxSphericalHarmonicsDegree === 2) { - vertexShaderSource += ` - if (sphericalHarmonicsMultiTextureMode == 0) { - vec4 sampledSH12131415 = texture(sphericalHarmonicsTexture, getDataUV(6, 3, sphericalHarmonicsTextureSize)); - vec4 sampledSH16171819 = texture(sphericalHarmonicsTexture, getDataUV(6, 4, sphericalHarmonicsTextureSize)); - vec4 sampledSH20212223 = texture(sphericalHarmonicsTexture, getDataUV(6, 5, sphericalHarmonicsTextureSize)); - sh4 = sampledSH891011.gba; - sh5 = sampledSH12131415.rgb; - sh6 = vec3(sampledSH12131415.a, sampledSH16171819.rg); - sh7 = vec3(sampledSH16171819.ba, sampledSH20212223.r); - sh8 = sampledSH20212223.gba; - } else { - vec4 sampledSH4567R = texture(sphericalHarmonicsTextureR, getDataUV(2, 1, sphericalHarmonicsTextureSize)); - vec4 sampledSH4567G = texture(sphericalHarmonicsTextureG, getDataUV(2, 1, sphericalHarmonicsTextureSize)); - vec4 sampledSH4567B = texture(sphericalHarmonicsTextureB, getDataUV(2, 1, sphericalHarmonicsTextureSize)); - sh4 = vec3(sampledSH0123R.a, sampledSH4567R.rg); - sh5 = vec3(sampledSH4567R.ba, sampledSH0123G.a); - sh6 = vec3(sampledSH4567G.rgb); - sh7 = vec3(sampledSH4567G.a, sampledSH0123B.a, sampledSH4567B.r); - sh8 = vec3(sampledSH4567B.gba); - } - `; - } - - // Perform 2nd degree spherical harmonics calculations - vertexShaderSource += ` - if (sphericalHarmonics8BitMode == 1) { - sh4 = sh4 * sh8BitCompressionRangeForScene + vec8BitSHShift; - sh5 = sh5 * sh8BitCompressionRangeForScene + vec8BitSHShift; - sh6 = sh6 * sh8BitCompressionRangeForScene + vec8BitSHShift; - sh7 = sh7 * sh8BitCompressionRangeForScene + vec8BitSHShift; - sh8 = sh8 * sh8BitCompressionRangeForScene + vec8BitSHShift; - } - - vColor.rgb += - (SH_C2[0] * xy) * sh4 + - (SH_C2[1] * yz) * sh5 + - (SH_C2[2] * (2.0 * zz - xx - yy)) * sh6 + - (SH_C2[3] * xz) * sh7 + - (SH_C2[4] * (xx - yy)) * sh8; - } - `; - } - - vertexShaderSource += ` - - vColor.rgb = clamp(vColor.rgb, vec3(0.), vec3(1.)); - - } - - `; - } - - return vertexShaderSource; - } - - static getVertexShaderFadeIn() { - return ` - if (fadeInComplete == 0) { - float opacityAdjust = 1.0; - float centerDist = length(splatCenter - sceneCenter); - float renderTime = max(currentTime - firstRenderTime, 0.0); - - float fadeDistance = 0.75; - float distanceLoadFadeInFactor = step(visibleRegionFadeStartRadius, centerDist); - distanceLoadFadeInFactor = (1.0 - distanceLoadFadeInFactor) + - (1.0 - clamp((centerDist - visibleRegionFadeStartRadius) / fadeDistance, 0.0, 1.0)) * - distanceLoadFadeInFactor; - opacityAdjust *= distanceLoadFadeInFactor; - vColor.a *= opacityAdjust; - } - `; - } - - static getUniforms(dynamicMode = false, enableOptionalEffects = false, maxSphericalHarmonicsDegree = 0, - splatScale = 1.0, pointCloudModeEnabled = false) { - - const uniforms = { - 'sceneCenter': { - 'type': 'v3', - 'value': new THREE__namespace.Vector3() - }, - 'fadeInComplete': { - 'type': 'i', - 'value': 0 - }, - 'orthographicMode': { - 'type': 'i', - 'value': 0 - }, - 'visibleRegionFadeStartRadius': { - 'type': 'f', - 'value': 0.0 - }, - 'visibleRegionRadius': { - 'type': 'f', - 'value': 0.0 - }, - 'currentTime': { - 'type': 'f', - 'value': 0.0 - }, - 'firstRenderTime': { - 'type': 'f', - 'value': 0.0 - }, - 'centersColorsTexture': { - 'type': 't', - 'value': null - }, - 'sphericalHarmonicsTexture': { - 'type': 't', - 'value': null - }, - 'sphericalHarmonicsTextureR': { - 'type': 't', - 'value': null - }, - 'sphericalHarmonicsTextureG': { - 'type': 't', - 'value': null - }, - 'sphericalHarmonicsTextureB': { - 'type': 't', - 'value': null - }, - 'sphericalHarmonics8BitCompressionRangeMin': { - 'type': 'f', - 'value': [] - }, - 'sphericalHarmonics8BitCompressionRangeMax': { - 'type': 'f', - 'value': [] - }, - 'focal': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2() - }, - 'orthoZoom': { - 'type': 'f', - 'value': 1.0 - }, - 'inverseFocalAdjustment': { - 'type': 'f', - 'value': 1.0 - }, - 'viewport': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2() - }, - 'basisViewport': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2() - }, - 'debugColor': { - 'type': 'v3', - 'value': new THREE__namespace.Color() - }, - 'centersColorsTextureSize': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2(1024, 1024) - }, - 'sphericalHarmonicsDegree': { - 'type': 'i', - 'value': maxSphericalHarmonicsDegree - }, - 'sphericalHarmonicsTextureSize': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2(1024, 1024) - }, - 'sphericalHarmonics8BitMode': { - 'type': 'i', - 'value': 0 - }, - 'sphericalHarmonicsMultiTextureMode': { - 'type': 'i', - 'value': 0 - }, - 'splatScale': { - 'type': 'f', - 'value': splatScale - }, - 'pointCloudModeEnabled': { - 'type': 'i', - 'value': pointCloudModeEnabled ? 1 : 0 - }, - 'sceneIndexesTexture': { - 'type': 't', - 'value': null - }, - 'sceneIndexesTextureSize': { - 'type': 'v2', - 'value': new THREE__namespace.Vector2(1024, 1024) - }, - 'sceneCount': { - 'type': 'i', - 'value': 1 - } - }; - for (let i = 0; i < Constants.MaxScenes; i++) { - uniforms.sphericalHarmonics8BitCompressionRangeMin.value.push(-Constants.SphericalHarmonics8BitCompressionRange / 2.0); - uniforms.sphericalHarmonics8BitCompressionRangeMax.value.push(Constants.SphericalHarmonics8BitCompressionRange / 2.0); - } - - if (enableOptionalEffects) { - const sceneOpacity = []; - for (let i = 0; i < Constants.MaxScenes; i++) { - sceneOpacity.push(1.0); - } - uniforms['sceneOpacity'] ={ - 'type': 'f', - 'value': sceneOpacity - }; - - const sceneVisibility = []; - for (let i = 0; i < Constants.MaxScenes; i++) { - sceneVisibility.push(1); - } - uniforms['sceneVisibility'] ={ - 'type': 'i', - 'value': sceneVisibility - }; - } - - if (dynamicMode) { - const transformMatrices = []; - for (let i = 0; i < Constants.MaxScenes; i++) { - transformMatrices.push(new THREE__namespace.Matrix4()); - } - uniforms['transforms'] = { - 'type': 'mat4', - 'value': transformMatrices - }; - } - - return uniforms; - } - - } - - class SplatMaterial3D { - - /** - * Build the Three.js material that is used to render the splats. - * @param {number} dynamicMode If true, it means the scene geometry represented by this splat mesh is not stationary or - * that the splat count might change - * @param {boolean} enableOptionalEffects When true, allows for usage of extra properties and attributes in the shader for effects - * such as opacity adjustment. Default is false for performance reasons. - * @param {boolean} antialiased If true, calculate compensation factor to deal with gaussians being rendered at a significantly - * different resolution than that of their training - * @param {number} maxScreenSpaceSplatSize The maximum clip space splat size - * @param {number} splatScale Value by which all splats are scaled in screen-space (default is 1.0) - * @param {number} pointCloudModeEnabled Render all splats as screen-space circles - * @param {number} maxSphericalHarmonicsDegree Degree of spherical harmonics to utilize in rendering splats - * @return {THREE.ShaderMaterial} - */ - static build(dynamicMode = false, enableOptionalEffects = false, antialiased = false, maxScreenSpaceSplatSize = 2048, - splatScale = 1.0, pointCloudModeEnabled = false, maxSphericalHarmonicsDegree = 0, kernel2DSize = 0.3) { - - const customVertexVars = ` - uniform vec2 covariancesTextureSize; - uniform highp sampler2D covariancesTexture; - uniform highp usampler2D covariancesTextureHalfFloat; - uniform int covariancesAreHalfFloat; - - void fromCovarianceHalfFloatV4(uvec4 val, out vec4 first, out vec4 second) { - vec2 r = unpackHalf2x16(val.r); - vec2 g = unpackHalf2x16(val.g); - vec2 b = unpackHalf2x16(val.b); - - first = vec4(r.x, r.y, g.x, g.y); - second = vec4(b.x, b.y, 0.0, 0.0); - } - `; - - let vertexShaderSource = SplatMaterial.buildVertexShaderBase(dynamicMode, enableOptionalEffects, - maxSphericalHarmonicsDegree, customVertexVars); - vertexShaderSource += SplatMaterial3D.buildVertexShaderProjection(antialiased, enableOptionalEffects, - maxScreenSpaceSplatSize, kernel2DSize); - const fragmentShaderSource = SplatMaterial3D.buildFragmentShader(); - - const uniforms = SplatMaterial.getUniforms(dynamicMode, enableOptionalEffects, - maxSphericalHarmonicsDegree, splatScale, pointCloudModeEnabled); - - uniforms['covariancesTextureSize'] = { - 'type': 'v2', - 'value': new THREE__namespace.Vector2(1024, 1024) - }; - uniforms['covariancesTexture'] = { - 'type': 't', - 'value': null - }; - uniforms['covariancesTextureHalfFloat'] = { - 'type': 't', - 'value': null - }; - uniforms['covariancesAreHalfFloat'] = { - 'type': 'i', - 'value': 0 - }; - - const material = new THREE__namespace.ShaderMaterial({ - uniforms: uniforms, - vertexShader: vertexShaderSource, - fragmentShader: fragmentShaderSource, - transparent: true, - alphaTest: 1.0, - blending: THREE__namespace.NormalBlending, - depthTest: true, - depthWrite: false, - side: THREE__namespace.DoubleSide - }); - - return material; - } - - static buildVertexShaderProjection(antialiased, enableOptionalEffects, maxScreenSpaceSplatSize, kernel2DSize) { - let vertexShaderSource = ` - - vec4 sampledCovarianceA; - vec4 sampledCovarianceB; - vec3 cov3D_M11_M12_M13; - vec3 cov3D_M22_M23_M33; - if (covariancesAreHalfFloat == 0) { - sampledCovarianceA = texture(covariancesTexture, getDataUVF(nearestEvenIndex, 1.5, oddOffset, - covariancesTextureSize)); - sampledCovarianceB = texture(covariancesTexture, getDataUVF(nearestEvenIndex, 1.5, oddOffset + uint(1), - covariancesTextureSize)); - - cov3D_M11_M12_M13 = vec3(sampledCovarianceA.rgb) * (1.0 - fOddOffset) + - vec3(sampledCovarianceA.ba, sampledCovarianceB.r) * fOddOffset; - cov3D_M22_M23_M33 = vec3(sampledCovarianceA.a, sampledCovarianceB.rg) * (1.0 - fOddOffset) + - vec3(sampledCovarianceB.gba) * fOddOffset; - } else { - uvec4 sampledCovarianceU = texture(covariancesTextureHalfFloat, getDataUV(1, 0, covariancesTextureSize)); - fromCovarianceHalfFloatV4(sampledCovarianceU, sampledCovarianceA, sampledCovarianceB); - cov3D_M11_M12_M13 = sampledCovarianceA.rgb; - cov3D_M22_M23_M33 = vec3(sampledCovarianceA.a, sampledCovarianceB.rg); - } - - // Construct the 3D covariance matrix - mat3 Vrk = mat3( - cov3D_M11_M12_M13.x, cov3D_M11_M12_M13.y, cov3D_M11_M12_M13.z, - cov3D_M11_M12_M13.y, cov3D_M22_M23_M33.x, cov3D_M22_M23_M33.y, - cov3D_M11_M12_M13.z, cov3D_M22_M23_M33.y, cov3D_M22_M23_M33.z - ); - - mat3 J; - if (orthographicMode == 1) { - // Since the projection is linear, we don't need an approximation - J = transpose(mat3(orthoZoom, 0.0, 0.0, - 0.0, orthoZoom, 0.0, - 0.0, 0.0, 0.0)); - } else { - // Construct the Jacobian of the affine approximation of the projection matrix. It will be used to transform the - // 3D covariance matrix instead of using the actual projection matrix because that transformation would - // require a non-linear component (perspective division) which would yield a non-gaussian result. - float s = 1.0 / (viewCenter.z * viewCenter.z); - J = mat3( - focal.x / viewCenter.z, 0., -(focal.x * viewCenter.x) * s, - 0., focal.y / viewCenter.z, -(focal.y * viewCenter.y) * s, - 0., 0., 0. - ); - } - - // Concatenate the projection approximation with the model-view transformation - mat3 W = transpose(mat3(transformModelViewMatrix)); - mat3 T = W * J; - - // Transform the 3D covariance matrix (Vrk) to compute the 2D covariance matrix - mat3 cov2Dm = transpose(T) * Vrk * T; - `; - - if (antialiased) { - vertexShaderSource += ` - float detOrig = cov2Dm[0][0] * cov2Dm[1][1] - cov2Dm[0][1] * cov2Dm[0][1]; - cov2Dm[0][0] += ${kernel2DSize}; - cov2Dm[1][1] += ${kernel2DSize}; - float detBlur = cov2Dm[0][0] * cov2Dm[1][1] - cov2Dm[0][1] * cov2Dm[0][1]; - vColor.a *= sqrt(max(detOrig / detBlur, 0.0)); - if (vColor.a < minAlpha) return; - `; - } else { - vertexShaderSource += ` - cov2Dm[0][0] += ${kernel2DSize}; - cov2Dm[1][1] += ${kernel2DSize}; - `; - } - - vertexShaderSource += ` - - // We are interested in the upper-left 2x2 portion of the projected 3D covariance matrix because - // we only care about the X and Y values. We want the X-diagonal, cov2Dm[0][0], - // the Y-diagonal, cov2Dm[1][1], and the correlation between the two cov2Dm[0][1]. We don't - // need cov2Dm[1][0] because it is a symetric matrix. - vec3 cov2Dv = vec3(cov2Dm[0][0], cov2Dm[0][1], cov2Dm[1][1]); - - // We now need to solve for the eigen-values and eigen vectors of the 2D covariance matrix - // so that we can determine the 2D basis for the splat. This is done using the method described - // here: https://people.math.harvard.edu/~knill/teaching/math21b2004/exhibits/2dmatrices/index.html - // After calculating the eigen-values and eigen-vectors, we calculate the basis for rendering the splat - // by normalizing the eigen-vectors and then multiplying them by (sqrt(8) * sqrt(eigen-value)), which is - // equal to scaling them by sqrt(8) standard deviations. - // - // This is a different approach than in the original work at INRIA. In that work they compute the - // max extents of the projected splat in screen space to form a screen-space aligned bounding rectangle - // which forms the geometry that is actually rasterized. The dimensions of that bounding box are 3.0 - // times the square root of the maximum eigen-value, or 3 standard deviations. They then use the inverse - // 2D covariance matrix (called 'conic') in the CUDA rendering thread to determine fragment opacity by - // calculating the full gaussian: exp(-0.5 * (X - mean) * conic * (X - mean)) * splat opacity - float a = cov2Dv.x; - float d = cov2Dv.z; - float b = cov2Dv.y; - float D = a * d - b * b; - float trace = a + d; - float traceOver2 = 0.5 * trace; - float term2 = sqrt(max(0.1f, traceOver2 * traceOver2 - D)); - float eigenValue1 = traceOver2 + term2; - float eigenValue2 = traceOver2 - term2; - - if (pointCloudModeEnabled == 1) { - eigenValue1 = eigenValue2 = 0.2; - } - - if (eigenValue2 <= 0.0) return; - - vec2 eigenVector1 = normalize(vec2(b, eigenValue1 - a)); - // since the eigen vectors are orthogonal, we derive the second one from the first - vec2 eigenVector2 = vec2(eigenVector1.y, -eigenVector1.x); - - // We use sqrt(8) standard deviations instead of 3 to eliminate more of the splat with a very low opacity. - vec2 basisVector1 = eigenVector1 * splatScale * min(sqrt8 * sqrt(eigenValue1), ${parseInt(maxScreenSpaceSplatSize)}.0); - vec2 basisVector2 = eigenVector2 * splatScale * min(sqrt8 * sqrt(eigenValue2), ${parseInt(maxScreenSpaceSplatSize)}.0); - `; - - if (enableOptionalEffects) { - vertexShaderSource += ` - vColor.a *= splatOpacityFromScene; - `; - } - - vertexShaderSource += ` - vec2 ndcOffset = vec2(vPosition.x * basisVector1 + vPosition.y * basisVector2) * - basisViewport * 2.0 * inverseFocalAdjustment; - - vec4 quadPos = vec4(ndcCenter.xy + ndcOffset, ndcCenter.z, 1.0); - gl_Position = quadPos; - - // Scale the position data we send to the fragment shader - vPosition *= sqrt8; - `; - - vertexShaderSource += SplatMaterial.getVertexShaderFadeIn(); - vertexShaderSource += `}`; - - return vertexShaderSource; - } - - static buildFragmentShader() { - let fragmentShaderSource = ` - precision highp float; - #include - - uniform vec3 debugColor; - - varying vec4 vColor; - varying vec2 vUv; - varying vec2 vPosition; - `; - - fragmentShaderSource += ` - void main () { - // Compute the positional squared distance from the center of the splat to the current fragment. - float A = dot(vPosition, vPosition); - // Since the positional data in vPosition has been scaled by sqrt(8), the squared result will be - // scaled by a factor of 8. If the squared result is larger than 8, it means it is outside the ellipse - // defined by the rectangle formed by vPosition. It also means it's farther - // away than sqrt(8) standard deviations from the mean. - if (A > 8.0) discard; - vec3 color = vColor.rgb; - - // Since the rendered splat is scaled by sqrt(8), the inverse covariance matrix that is part of - // the gaussian formula becomes the identity matrix. We're then left with (X - mean) * (X - mean), - // and since 'mean' is zero, we have X * X, which is the same as A: - float opacity = exp(-0.5 * A) * vColor.a; - - gl_FragColor = vec4(color.rgb, opacity); - } - `; - - return fragmentShaderSource; - } - - } - - class SplatMaterial2D { - - /** - * Build the Three.js material that is used to render the splats. - * @param {number} dynamicMode If true, it means the scene geometry represented by this splat mesh is not stationary or - * that the splat count might change - * @param {boolean} enableOptionalEffects When true, allows for usage of extra properties and attributes in the shader for effects - * such as opacity adjustment. Default is false for performance reasons. - * @param {number} splatScale Value by which all splats are scaled in screen-space (default is 1.0) - * @param {number} pointCloudModeEnabled Render all splats as screen-space circles - * @param {number} maxSphericalHarmonicsDegree Degree of spherical harmonics to utilize in rendering splats - * @return {THREE.ShaderMaterial} - */ - static build(dynamicMode = false, enableOptionalEffects = false, splatScale = 1.0, - pointCloudModeEnabled = false, maxSphericalHarmonicsDegree = 0) { - - const customVertexVars = ` - uniform vec2 scaleRotationsTextureSize; - uniform highp sampler2D scaleRotationsTexture; - varying mat3 vT; - varying vec2 vQuadCenter; - varying vec2 vFragCoord; - `; - - let vertexShaderSource = SplatMaterial.buildVertexShaderBase(dynamicMode, enableOptionalEffects, - maxSphericalHarmonicsDegree, customVertexVars); - vertexShaderSource += SplatMaterial2D.buildVertexShaderProjection(); - const fragmentShaderSource = SplatMaterial2D.buildFragmentShader(); - - const uniforms = SplatMaterial.getUniforms(dynamicMode, enableOptionalEffects, - maxSphericalHarmonicsDegree, splatScale, pointCloudModeEnabled); - - uniforms['scaleRotationsTexture'] = { - 'type': 't', - 'value': null - }; - uniforms['scaleRotationsTextureSize'] = { - 'type': 'v2', - 'value': new THREE__namespace.Vector2(1024, 1024) - }; - - const material = new THREE__namespace.ShaderMaterial({ - uniforms: uniforms, - vertexShader: vertexShaderSource, - fragmentShader: fragmentShaderSource, - transparent: true, - alphaTest: 1.0, - blending: THREE__namespace.NormalBlending, - depthTest: true, - depthWrite: false, - side: THREE__namespace.DoubleSide - }); - - return material; - } - - static buildVertexShaderProjection() { - - // Original CUDA code for calculating splat-to-screen transformation, for reference - /* - glm::mat3 R = quat_to_rotmat(rot); - glm::mat3 S = scale_to_mat(scale, mod); - glm::mat3 L = R * S; - - // center of Gaussians in the camera coordinate - glm::mat3x4 splat2world = glm::mat3x4( - glm::vec4(L[0], 0.0), - glm::vec4(L[1], 0.0), - glm::vec4(p_orig.x, p_orig.y, p_orig.z, 1) - ); - - glm::mat4 world2ndc = glm::mat4( - projmatrix[0], projmatrix[4], projmatrix[8], projmatrix[12], - projmatrix[1], projmatrix[5], projmatrix[9], projmatrix[13], - projmatrix[2], projmatrix[6], projmatrix[10], projmatrix[14], - projmatrix[3], projmatrix[7], projmatrix[11], projmatrix[15] - ); - - glm::mat3x4 ndc2pix = glm::mat3x4( - glm::vec4(float(W) / 2.0, 0.0, 0.0, float(W-1) / 2.0), - glm::vec4(0.0, float(H) / 2.0, 0.0, float(H-1) / 2.0), - glm::vec4(0.0, 0.0, 0.0, 1.0) - ); - - T = glm::transpose(splat2world) * world2ndc * ndc2pix; - normal = transformVec4x3({L[2].x, L[2].y, L[2].z}, viewmatrix); - */ - - // Compute a 2D-to-2D mapping matrix from a tangent plane into a image plane - // given a 2D gaussian parameters. T = WH (from the paper: https://arxiv.org/pdf/2403.17888) - let vertexShaderSource = ` - - vec4 scaleRotationA = texture(scaleRotationsTexture, getDataUVF(nearestEvenIndex, 1.5, - oddOffset, scaleRotationsTextureSize)); - vec4 scaleRotationB = texture(scaleRotationsTexture, getDataUVF(nearestEvenIndex, 1.5, - oddOffset + uint(1), scaleRotationsTextureSize)); - - vec3 scaleRotation123 = vec3(scaleRotationA.rgb) * (1.0 - fOddOffset) + - vec3(scaleRotationA.ba, scaleRotationB.r) * fOddOffset; - vec3 scaleRotation456 = vec3(scaleRotationA.a, scaleRotationB.rg) * (1.0 - fOddOffset) + - vec3(scaleRotationB.gba) * fOddOffset; - - float missingW = sqrt(1.0 - scaleRotation456.x * scaleRotation456.x - scaleRotation456.y * - scaleRotation456.y - scaleRotation456.z * scaleRotation456.z); - mat3 R = quaternionToRotationMatrix(scaleRotation456.r, scaleRotation456.g, scaleRotation456.b, missingW); - mat3 S = mat3(scaleRotation123.r, 0.0, 0.0, - 0.0, scaleRotation123.g, 0.0, - 0.0, 0.0, scaleRotation123.b); - - mat3 L = R * S; - - mat3x4 splat2World = mat3x4(vec4(L[0], 0.0), - vec4(L[1], 0.0), - vec4(splatCenter.x, splatCenter.y, splatCenter.z, 1.0)); - - mat4 world2ndc = transpose(projectionMatrix * transformModelViewMatrix); - - mat3x4 ndc2pix = mat3x4(vec4(viewport.x / 2.0, 0.0, 0.0, (viewport.x - 1.0) / 2.0), - vec4(0.0, viewport.y / 2.0, 0.0, (viewport.y - 1.0) / 2.0), - vec4(0.0, 0.0, 0.0, 1.0)); - - mat3 T = transpose(splat2World) * world2ndc * ndc2pix; - vec3 normal = vec3(viewMatrix * vec4(L[0][2], L[1][2], L[2][2], 0.0)); - `; - - // Original CUDA code for projection to 2D, for reference - /* - float3 T0 = {T[0][0], T[0][1], T[0][2]}; - float3 T1 = {T[1][0], T[1][1], T[1][2]}; - float3 T3 = {T[2][0], T[2][1], T[2][2]}; - - // Compute AABB - float3 temp_point = {1.0f, 1.0f, -1.0f}; - float distance = sumf3(T3 * T3 * temp_point); - float3 f = (1 / distance) * temp_point; - if (distance == 0.0) return false; - - point_image = { - sumf3(f * T0 * T3), - sumf3(f * T1 * T3) - }; - - float2 temp = { - sumf3(f * T0 * T0), - sumf3(f * T1 * T1) - }; - float2 half_extend = point_image * point_image - temp; - extent = sqrtf2(maxf2(1e-4, half_extend)); - return true; - */ - - // Computing the bounding box of the 2D Gaussian and its center - // The center of the bounding box is used to create a low pass filter. - // This code is based off the reference implementation and creates an AABB aligned - // with the screen for the quad to be rendered. - const referenceQuadGeneration = ` - vec3 T0 = vec3(T[0][0], T[0][1], T[0][2]); - vec3 T1 = vec3(T[1][0], T[1][1], T[1][2]); - vec3 T3 = vec3(T[2][0], T[2][1], T[2][2]); - - vec3 tempPoint = vec3(1.0, 1.0, -1.0); - float distance = (T3.x * T3.x * tempPoint.x) + (T3.y * T3.y * tempPoint.y) + (T3.z * T3.z * tempPoint.z); - vec3 f = (1.0 / distance) * tempPoint; - if (abs(distance) < 0.00001) return; - - float pointImageX = (T0.x * T3.x * f.x) + (T0.y * T3.y * f.y) + (T0.z * T3.z * f.z); - float pointImageY = (T1.x * T3.x * f.x) + (T1.y * T3.y * f.y) + (T1.z * T3.z * f.z); - vec2 pointImage = vec2(pointImageX, pointImageY); - - float tempX = (T0.x * T0.x * f.x) + (T0.y * T0.y * f.y) + (T0.z * T0.z * f.z); - float tempY = (T1.x * T1.x * f.x) + (T1.y * T1.y * f.y) + (T1.z * T1.z * f.z); - vec2 temp = vec2(tempX, tempY); - - vec2 halfExtend = pointImage * pointImage - temp; - vec2 extent = sqrt(max(vec2(0.0001), halfExtend)); - float radius = max(extent.x, extent.y); - - vec2 ndcOffset = ((position.xy * radius * 3.0) * basisViewport * 2.0); - - vec4 quadPos = vec4(ndcCenter.xy + ndcOffset, ndcCenter.z, 1.0); - gl_Position = quadPos; - - vT = T; - vQuadCenter = pointImage; - vFragCoord = (quadPos.xy * 0.5 + 0.5) * viewport; - `; - - const useRefImplementation = false; - if (useRefImplementation) { - vertexShaderSource += referenceQuadGeneration; - } else { - // Create a quad that is aligned with the eigen vectors of the projected gaussian for rendering. - // This is a different approach than the reference implementation, similar to how the rendering of - // 3D gaussians in this viewer differs from the reference implementation. If the quad is too small - // (smaller than a pixel), then revert to the reference implementation. - vertexShaderSource += ` - - mat4 splat2World4 = mat4(vec4(L[0], 0.0), - vec4(L[1], 0.0), - vec4(L[2], 0.0), - vec4(splatCenter.x, splatCenter.y, splatCenter.z, 1.0)); - - mat4 Tt = transpose(transpose(splat2World4) * world2ndc); - - vec4 tempPoint1 = Tt * vec4(1.0, 0.0, 0.0, 1.0); - tempPoint1 /= tempPoint1.w; - - vec4 tempPoint2 = Tt * vec4(0.0, 1.0, 0.0, 1.0); - tempPoint2 /= tempPoint2.w; - - vec4 center = Tt * vec4(0.0, 0.0, 0.0, 1.0); - center /= center.w; - - vec2 basisVector1 = tempPoint1.xy - center.xy; - vec2 basisVector2 = tempPoint2.xy - center.xy; - - vec2 basisVector1Screen = basisVector1 * 0.5 * viewport; - vec2 basisVector2Screen = basisVector2 * 0.5 * viewport; - - const float minPix = 1.; - if (length(basisVector1Screen) < minPix || length(basisVector2Screen) < minPix) { - ${referenceQuadGeneration} - } else { - vec2 ndcOffset = vec2(position.x * basisVector1 + position.y * basisVector2) * 3.0 * inverseFocalAdjustment; - vec4 quadPos = vec4(ndcCenter.xy + ndcOffset, ndcCenter.z, 1.0); - gl_Position = quadPos; - - vT = T; - vQuadCenter = center.xy; - vFragCoord = (quadPos.xy * 0.5 + 0.5) * viewport; - } - `; - } - - vertexShaderSource += SplatMaterial.getVertexShaderFadeIn(); - vertexShaderSource += `}`; - - return vertexShaderSource; - } - - static buildFragmentShader() { - - // Original CUDA code for splat intersection, for reference - /* - const float2 xy = collected_xy[j]; - const float3 Tu = collected_Tu[j]; - const float3 Tv = collected_Tv[j]; - const float3 Tw = collected_Tw[j]; - float3 k = pix.x * Tw - Tu; - float3 l = pix.y * Tw - Tv; - float3 p = cross(k, l); - if (p.z == 0.0) continue; - float2 s = {p.x / p.z, p.y / p.z}; - float rho3d = (s.x * s.x + s.y * s.y); - float2 d = {xy.x - pixf.x, xy.y - pixf.y}; - float rho2d = FilterInvSquare * (d.x * d.x + d.y * d.y); - - // compute intersection and depth - float rho = min(rho3d, rho2d); - float depth = (rho3d <= rho2d) ? (s.x * Tw.x + s.y * Tw.y) + Tw.z : Tw.z; - if (depth < near_n) continue; - float4 nor_o = collected_normal_opacity[j]; - float normal[3] = {nor_o.x, nor_o.y, nor_o.z}; - float opa = nor_o.w; - - float power = -0.5f * rho; - if (power > 0.0f) - continue; - - // Eq. (2) from 3D Gaussian splatting paper. - // Obtain alpha by multiplying with Gaussian opacity - // and its exponential falloff from mean. - // Avoid numerical instabilities (see paper appendix). - float alpha = min(0.99f, opa * exp(power)); - if (alpha < 1.0f / 255.0f) - continue; - float test_T = T * (1 - alpha); - if (test_T < 0.0001f) - { - done = true; - continue; - } - - float w = alpha * T; - */ - let fragmentShaderSource = ` - precision highp float; - #include - - uniform vec3 debugColor; - - varying vec4 vColor; - varying vec2 vUv; - varying vec2 vPosition; - varying mat3 vT; - varying vec2 vQuadCenter; - varying vec2 vFragCoord; - - void main () { - - const float FilterInvSquare = 2.0; - const float near_n = 0.2; - const float T = 1.0; - - vec2 xy = vQuadCenter; - vec3 Tu = vT[0]; - vec3 Tv = vT[1]; - vec3 Tw = vT[2]; - vec3 k = vFragCoord.x * Tw - Tu; - vec3 l = vFragCoord.y * Tw - Tv; - vec3 p = cross(k, l); - if (p.z == 0.0) discard; - vec2 s = vec2(p.x / p.z, p.y / p.z); - float rho3d = (s.x * s.x + s.y * s.y); - vec2 d = vec2(xy.x - vFragCoord.x, xy.y - vFragCoord.y); - float rho2d = FilterInvSquare * (d.x * d.x + d.y * d.y); - - // compute intersection and depth - float rho = min(rho3d, rho2d); - float depth = (rho3d <= rho2d) ? (s.x * Tw.x + s.y * Tw.y) + Tw.z : Tw.z; - if (depth < near_n) discard; - // vec4 nor_o = collected_normal_opacity[j]; - // float normal[3] = {nor_o.x, nor_o.y, nor_o.z}; - float opa = vColor.a; - - float power = -0.5f * rho; - if (power > 0.0f) discard; - - // Eq. (2) from 3D Gaussian splatting paper. - // Obtain alpha by multiplying with Gaussian opacity - // and its exponential falloff from mean. - // Avoid numerical instabilities (see paper appendix). - float alpha = min(0.99f, opa * exp(power)); - if (alpha < 1.0f / 255.0f) discard; - float test_T = T * (1.0 - alpha); - if (test_T < 0.0001)discard; - - float w = alpha * T; - gl_FragColor = vec4(vColor.rgb, w); - } - `; - - return fragmentShaderSource; - } - } - - class SplatGeometry { - - /** - * Build the Three.js geometry that will be used to render the splats. The geometry is instanced and is made up of - * vertices for a single quad as well as an attribute buffer for the splat indexes. - * @param {number} maxSplatCount The maximum number of splats that the geometry will need to accomodate - * @return {THREE.InstancedBufferGeometry} - */ - static build(maxSplatCount) { - - const baseGeometry = new THREE__namespace.BufferGeometry(); - baseGeometry.setIndex([0, 1, 2, 0, 2, 3]); - - // Vertices for the instanced quad - const positionsArray = new Float32Array(4 * 3); - const positions = new THREE__namespace.BufferAttribute(positionsArray, 3); - baseGeometry.setAttribute('position', positions); - positions.setXYZ(0, -1.0, -1.0, 0.0); - positions.setXYZ(1, -1.0, 1.0, 0.0); - positions.setXYZ(2, 1.0, 1.0, 0.0); - positions.setXYZ(3, 1.0, -1.0, 0.0); - positions.needsUpdate = true; - - const geometry = new THREE__namespace.InstancedBufferGeometry().copy(baseGeometry); - - // Splat index buffer - const splatIndexArray = new Uint32Array(maxSplatCount); - const splatIndexes = new THREE__namespace.InstancedBufferAttribute(splatIndexArray, 1, false); - splatIndexes.setUsage(THREE__namespace.DynamicDrawUsage); - geometry.setAttribute('splatIndex', splatIndexes); - - geometry.instanceCount = 0; - - return geometry; - } - } - - /** - * SplatScene: Descriptor for a single splat scene managed by an instance of SplatMesh. - */ - class SplatScene extends THREE__namespace.Object3D { - - constructor(splatBuffer, position = new THREE__namespace.Vector3(), quaternion = new THREE__namespace.Quaternion(), - scale = new THREE__namespace.Vector3(1, 1, 1), minimumAlpha = 1, opacity = 1.0, visible = true) { - super(); - this.splatBuffer = splatBuffer; - this.position.copy(position); - this.quaternion.copy(quaternion); - this.scale.copy(scale); - this.transform = new THREE__namespace.Matrix4(); - this.minimumAlpha = minimumAlpha; - this.opacity = opacity; - this.visible = visible; - } - - copyTransformData(otherScene) { - this.position.copy(otherScene.position); - this.quaternion.copy(otherScene.quaternion); - this.scale.copy(otherScene.scale); - this.transform.copy(otherScene.transform); - } - - updateTransform(dynamicMode) { - if (dynamicMode) { - if (this.matrixWorldAutoUpdate) this.updateWorldMatrix(true, false); - this.transform.copy(this.matrixWorld); - } else { - if (this.matrixAutoUpdate) this.updateMatrix(); - this.transform.copy(this.matrix); - } - } - } - - class SplatTreeNode { - - static idGen = 0; - - constructor(min, max, depth, id) { - this.min = new THREE__namespace.Vector3().copy(min); - this.max = new THREE__namespace.Vector3().copy(max); - this.boundingBox = new THREE__namespace.Box3(this.min, this.max); - this.center = new THREE__namespace.Vector3().copy(this.max).sub(this.min).multiplyScalar(0.5).add(this.min); - this.depth = depth; - this.children = []; - this.data = null; - this.id = id || SplatTreeNode.idGen++; - } - - } - - class SplatSubTree { - - constructor(maxDepth, maxCentersPerNode) { - this.maxDepth = maxDepth; - this.maxCentersPerNode = maxCentersPerNode; - this.sceneDimensions = new THREE__namespace.Vector3(); - this.sceneMin = new THREE__namespace.Vector3(); - this.sceneMax = new THREE__namespace.Vector3(); - this.rootNode = null; - this.nodesWithIndexes = []; - this.splatMesh = null; - } - - static convertWorkerSubTreeNode(workerSubTreeNode) { - const minVector = new THREE__namespace.Vector3().fromArray(workerSubTreeNode.min); - const maxVector = new THREE__namespace.Vector3().fromArray(workerSubTreeNode.max); - const convertedNode = new SplatTreeNode(minVector, maxVector, workerSubTreeNode.depth, workerSubTreeNode.id); - if (workerSubTreeNode.data.indexes) { - convertedNode.data = { - 'indexes': [] - }; - for (let index of workerSubTreeNode.data.indexes) { - convertedNode.data.indexes.push(index); - } - } - if (workerSubTreeNode.children) { - for (let child of workerSubTreeNode.children) { - convertedNode.children.push(SplatSubTree.convertWorkerSubTreeNode(child)); - } - } - return convertedNode; - } - - static convertWorkerSubTree(workerSubTree, splatMesh) { - const convertedSubTree = new SplatSubTree(workerSubTree.maxDepth, workerSubTree.maxCentersPerNode); - convertedSubTree.sceneMin = new THREE__namespace.Vector3().fromArray(workerSubTree.sceneMin); - convertedSubTree.sceneMax = new THREE__namespace.Vector3().fromArray(workerSubTree.sceneMax); - - convertedSubTree.splatMesh = splatMesh; - convertedSubTree.rootNode = SplatSubTree.convertWorkerSubTreeNode(workerSubTree.rootNode); - - - const visitLeavesFromNode = (node, visitFunc) => { - if (node.children.length === 0) visitFunc(node); - for (let child of node.children) { - visitLeavesFromNode(child, visitFunc); - } - }; - - convertedSubTree.nodesWithIndexes = []; - visitLeavesFromNode(convertedSubTree.rootNode, (node) => { - if (node.data && node.data.indexes && node.data.indexes.length > 0) { - convertedSubTree.nodesWithIndexes.push(node); - } - }); - - return convertedSubTree; - } - } - - function createSplatTreeWorker(self) { - - let WorkerSplatTreeNodeIDGen = 0; - - class WorkerBox3 { - - constructor(min, max) { - this.min = [min[0], min[1], min[2]]; - this.max = [max[0], max[1], max[2]]; - } - - containsPoint(point) { - return point[0] >= this.min[0] && point[0] <= this.max[0] && - point[1] >= this.min[1] && point[1] <= this.max[1] && - point[2] >= this.min[2] && point[2] <= this.max[2]; - } - } - - class WorkerSplatSubTree { - - constructor(maxDepth, maxCentersPerNode) { - this.maxDepth = maxDepth; - this.maxCentersPerNode = maxCentersPerNode; - this.sceneDimensions = []; - this.sceneMin = []; - this.sceneMax = []; - this.rootNode = null; - this.addedIndexes = {}; - this.nodesWithIndexes = []; - this.splatMesh = null; - this.disposed = false; - } - - } - - class WorkerSplatTreeNode { - - constructor(min, max, depth, id) { - this.min = [min[0], min[1], min[2]]; - this.max = [max[0], max[1], max[2]]; - this.center = [(max[0] - min[0]) * 0.5 + min[0], - (max[1] - min[1]) * 0.5 + min[1], - (max[2] - min[2]) * 0.5 + min[2]]; - this.depth = depth; - this.children = []; - this.data = null; - this.id = id || WorkerSplatTreeNodeIDGen++; - } - - } - - processSplatTreeNode = function(tree, node, indexToCenter, sceneCenters) { - const splatCount = node.data.indexes.length; - - if (splatCount < tree.maxCentersPerNode || node.depth > tree.maxDepth) { - const newIndexes = []; - for (let i = 0; i < node.data.indexes.length; i++) { - if (!tree.addedIndexes[node.data.indexes[i]]) { - newIndexes.push(node.data.indexes[i]); - tree.addedIndexes[node.data.indexes[i]] = true; - } - } - node.data.indexes = newIndexes; - node.data.indexes.sort((a, b) => { - if (a > b) return 1; - else return -1; - }); - tree.nodesWithIndexes.push(node); - return; - } - - const nodeDimensions = [node.max[0] - node.min[0], - node.max[1] - node.min[1], - node.max[2] - node.min[2]]; - const halfDimensions = [nodeDimensions[0] * 0.5, - nodeDimensions[1] * 0.5, - nodeDimensions[2] * 0.5]; - const nodeCenter = [node.min[0] + halfDimensions[0], - node.min[1] + halfDimensions[1], - node.min[2] + halfDimensions[2]]; - - const childrenBounds = [ - // top section, clockwise from upper-left (looking from above, +Y) - new WorkerBox3([nodeCenter[0] - halfDimensions[0], nodeCenter[1], nodeCenter[2] - halfDimensions[2]], - [nodeCenter[0], nodeCenter[1] + halfDimensions[1], nodeCenter[2]]), - new WorkerBox3([nodeCenter[0], nodeCenter[1], nodeCenter[2] - halfDimensions[2]], - [nodeCenter[0] + halfDimensions[0], nodeCenter[1] + halfDimensions[1], nodeCenter[2]]), - new WorkerBox3([nodeCenter[0], nodeCenter[1], nodeCenter[2]], - [nodeCenter[0] + halfDimensions[0], nodeCenter[1] + halfDimensions[1], nodeCenter[2] + halfDimensions[2]]), - new WorkerBox3([nodeCenter[0] - halfDimensions[0], nodeCenter[1], nodeCenter[2]], - [nodeCenter[0], nodeCenter[1] + halfDimensions[1], nodeCenter[2] + halfDimensions[2]]), - - // bottom section, clockwise from lower-left (looking from above, +Y) - new WorkerBox3([nodeCenter[0] - halfDimensions[0], nodeCenter[1] - halfDimensions[1], nodeCenter[2] - halfDimensions[2]], - [nodeCenter[0], nodeCenter[1], nodeCenter[2]]), - new WorkerBox3([nodeCenter[0], nodeCenter[1] - halfDimensions[1], nodeCenter[2] - halfDimensions[2]], - [nodeCenter[0] + halfDimensions[0], nodeCenter[1], nodeCenter[2]]), - new WorkerBox3([nodeCenter[0], nodeCenter[1] - halfDimensions[1], nodeCenter[2]], - [nodeCenter[0] + halfDimensions[0], nodeCenter[1], nodeCenter[2] + halfDimensions[2]]), - new WorkerBox3([nodeCenter[0] - halfDimensions[0], nodeCenter[1] - halfDimensions[1], nodeCenter[2]], - [nodeCenter[0], nodeCenter[1], nodeCenter[2] + halfDimensions[2]]), - ]; - - const splatCounts = []; - const baseIndexes = []; - for (let i = 0; i < childrenBounds.length; i++) { - splatCounts[i] = 0; - baseIndexes[i] = []; - } - - const center = [0, 0, 0]; - for (let i = 0; i < splatCount; i++) { - const splatGlobalIndex = node.data.indexes[i]; - const centerBase = indexToCenter[splatGlobalIndex]; - center[0] = sceneCenters[centerBase]; - center[1] = sceneCenters[centerBase + 1]; - center[2] = sceneCenters[centerBase + 2]; - for (let j = 0; j < childrenBounds.length; j++) { - if (childrenBounds[j].containsPoint(center)) { - splatCounts[j]++; - baseIndexes[j].push(splatGlobalIndex); - } - } - } - - for (let i = 0; i < childrenBounds.length; i++) { - const childNode = new WorkerSplatTreeNode(childrenBounds[i].min, childrenBounds[i].max, node.depth + 1); - childNode.data = { - 'indexes': baseIndexes[i] - }; - node.children.push(childNode); - } - - node.data = {}; - for (let child of node.children) { - processSplatTreeNode(tree, child, indexToCenter, sceneCenters); - } - return; - }; - - const buildSubTree = (sceneCenters, maxDepth, maxCentersPerNode) => { - - const sceneMin = [0, 0, 0]; - const sceneMax = [0, 0, 0]; - const indexes = []; - const centerCount = Math.floor(sceneCenters.length / 4); - for ( let i = 0; i < centerCount; i ++) { - const base = i * 4; - const x = sceneCenters[base]; - const y = sceneCenters[base + 1]; - const z = sceneCenters[base + 2]; - const index = Math.round(sceneCenters[base + 3]); - if (i === 0 || x < sceneMin[0]) sceneMin[0] = x; - if (i === 0 || x > sceneMax[0]) sceneMax[0] = x; - if (i === 0 || y < sceneMin[1]) sceneMin[1] = y; - if (i === 0 || y > sceneMax[1]) sceneMax[1] = y; - if (i === 0 || z < sceneMin[2]) sceneMin[2] = z; - if (i === 0 || z > sceneMax[2]) sceneMax[2] = z; - indexes.push(index); - } - const subTree = new WorkerSplatSubTree(maxDepth, maxCentersPerNode); - subTree.sceneMin = sceneMin; - subTree.sceneMax = sceneMax; - subTree.rootNode = new WorkerSplatTreeNode(subTree.sceneMin, subTree.sceneMax, 0); - subTree.rootNode.data = { - 'indexes': indexes - }; - - return subTree; - }; - - function createSplatTree(allCenters, maxDepth, maxCentersPerNode) { - const indexToCenter = []; - for (let sceneCenters of allCenters) { - const centerCount = Math.floor(sceneCenters.length / 4); - for ( let i = 0; i < centerCount; i ++) { - const base = i * 4; - const index = Math.round(sceneCenters[base + 3]); - indexToCenter[index] = base; - } - } - const subTrees = []; - for (let sceneCenters of allCenters) { - const subTree = buildSubTree(sceneCenters, maxDepth, maxCentersPerNode); - subTrees.push(subTree); - processSplatTreeNode(subTree, subTree.rootNode, indexToCenter, sceneCenters); - } - self.postMessage({ - 'subTrees': subTrees - }); - } - - self.onmessage = (e) => { - if (e.data.process) { - createSplatTree(e.data.process.centers, e.data.process.maxDepth, e.data.process.maxCentersPerNode); - } - }; - } - - function workerProcessCenters(splatTreeWorker, centers, transferBuffers, maxDepth, maxCentersPerNode) { - splatTreeWorker.postMessage({ - 'process': { - 'centers': centers, - 'maxDepth': maxDepth, - 'maxCentersPerNode': maxCentersPerNode - } - }, transferBuffers); - } - - function checkAndCreateWorker() { - const splatTreeWorker = new Worker( - URL.createObjectURL( - new Blob(['(', createSplatTreeWorker.toString(), ')(self)'], { - type: 'application/javascript', - }), - ), - ); - return splatTreeWorker; - } - - /** - * SplatTree: Octree tailored to splat data from a SplatMesh instance - */ - class SplatTree { - - constructor(maxDepth, maxCentersPerNode) { - this.maxDepth = maxDepth; - this.maxCentersPerNode = maxCentersPerNode; - this.subTrees = []; - this.splatMesh = null; - } - - - dispose() { - this.diposeSplatTreeWorker(); - this.disposed = true; - } - - diposeSplatTreeWorker() { - if (this.splatTreeWorker) this.splatTreeWorker.terminate(); - this.splatTreeWorker = null; - }; - - /** - * Construct this instance of SplatTree from an instance of SplatMesh. - * - * @param {SplatMesh} splatMesh The instance of SplatMesh from which to construct this splat tree. - * @param {function} filterFunc Optional function to filter out unwanted splats. - * @param {function} onIndexesUpload Function to be called when the upload of splat centers to the splat tree - * builder worker starts and finishes. - * @param {function} onSplatTreeConstruction Function to be called when the conversion of the local splat tree from - * the format produced by the splat tree builder worker starts and ends. - * @return {undefined} - */ - processSplatMesh = function(splatMesh, filterFunc = () => true, onIndexesUpload, onSplatTreeConstruction) { - if (!this.splatTreeWorker) this.splatTreeWorker = checkAndCreateWorker(); - - this.splatMesh = splatMesh; - this.subTrees = []; - const center = new THREE__namespace.Vector3(); - - const addCentersForScene = (splatOffset, splatCount) => { - const sceneCenters = new Float32Array(splatCount * 4); - let addedCount = 0; - for (let i = 0; i < splatCount; i++) { - const globalSplatIndex = i + splatOffset; - if (filterFunc(globalSplatIndex)) { - splatMesh.getSplatCenter(globalSplatIndex, center); - const addBase = addedCount * 4; - sceneCenters[addBase] = center.x; - sceneCenters[addBase + 1] = center.y; - sceneCenters[addBase + 2] = center.z; - sceneCenters[addBase + 3] = globalSplatIndex; - addedCount++; - } - } - return sceneCenters; - }; - - return new Promise((resolve) => { - - const checkForEarlyExit = () => { - if (this.disposed) { - this.diposeSplatTreeWorker(); - resolve(); - return true; - } - return false; - }; - - if (onIndexesUpload) onIndexesUpload(false); - - delayedExecute(() => { - - if (checkForEarlyExit()) return; - - const allCenters = []; - if (splatMesh.dynamicMode) { - let splatOffset = 0; - for (let s = 0; s < splatMesh.scenes.length; s++) { - const scene = splatMesh.getScene(s); - const splatCount = scene.splatBuffer.getSplatCount(); - const sceneCenters = addCentersForScene(splatOffset, splatCount); - allCenters.push(sceneCenters); - splatOffset += splatCount; - } - } else { - const sceneCenters = addCentersForScene(0, splatMesh.getSplatCount()); - allCenters.push(sceneCenters); - } - - this.splatTreeWorker.onmessage = (e) => { - - if (checkForEarlyExit()) return; - - if (e.data.subTrees) { - - if (onSplatTreeConstruction) onSplatTreeConstruction(false); - - delayedExecute(() => { - - if (checkForEarlyExit()) return; - - for (let workerSubTree of e.data.subTrees) { - const convertedSubTree = SplatSubTree.convertWorkerSubTree(workerSubTree, splatMesh); - this.subTrees.push(convertedSubTree); - } - this.diposeSplatTreeWorker(); - - if (onSplatTreeConstruction) onSplatTreeConstruction(true); - - delayedExecute(() => { - resolve(); - }); - - }); - } - }; - - delayedExecute(() => { - if (checkForEarlyExit()) return; - if (onIndexesUpload) onIndexesUpload(true); - const transferBuffers = allCenters.map((array) => array.buffer); - workerProcessCenters(this.splatTreeWorker, allCenters, transferBuffers, this.maxDepth, this.maxCentersPerNode); - }); - - }); - - }); - - }; - - countLeaves() { - - let leafCount = 0; - this.visitLeaves(() => { - leafCount++; - }); - - return leafCount; - } - - visitLeaves(visitFunc) { - - const visitLeavesFromNode = (node, visitFunc) => { - if (node.children.length === 0) visitFunc(node); - for (let child of node.children) { - visitLeavesFromNode(child, visitFunc); - } - }; - - for (let subTree of this.subTrees) { - visitLeavesFromNode(subTree.rootNode, visitFunc); - } - } - - } - - function WebGLExtensions( gl ) { - - const extensions = {}; - - function getExtension( name ) { - - if ( extensions[name] !== undefined ) { - - return extensions[name]; - - } - - let extension; - - switch ( name ) { - - case 'WEBGL_depth_texture': - extension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || - gl.getExtension( 'WEBKIT_WEBGL_depth_texture' ); - break; - - case 'EXT_texture_filter_anisotropic': - extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || - gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || - gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' ); - break; - - case 'WEBGL_compressed_texture_s3tc': - extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || - gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || - gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' ); - break; - - case 'WEBGL_compressed_texture_pvrtc': - extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || - gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' ); - break; - - default: - extension = gl.getExtension( name ); - - } - - extensions[name] = extension; - - return extension; - - } - - return { - - has: function( name ) { - - return getExtension( name ) !== null; - - }, - - init: function( capabilities ) { - - if ( capabilities.isWebGL2 ) { - - getExtension( 'EXT_color_buffer_float' ); - getExtension( 'WEBGL_clip_cull_distance' ); - - } else { - - getExtension( 'WEBGL_depth_texture' ); - getExtension( 'OES_texture_float' ); - getExtension( 'OES_texture_half_float' ); - getExtension( 'OES_texture_half_float_linear' ); - getExtension( 'OES_standard_derivatives' ); - getExtension( 'OES_element_index_uint' ); - getExtension( 'OES_vertex_array_object' ); - getExtension( 'ANGLE_instanced_arrays' ); - - } - - getExtension( 'OES_texture_float_linear' ); - getExtension( 'EXT_color_buffer_half_float' ); - getExtension( 'WEBGL_multisampled_render_to_texture' ); - - }, - - get: function( name ) { - - const extension = getExtension( name ); - - if ( extension === null ) { - - console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' ); - - } - - return extension; - - } - - }; - - } - - function WebGLCapabilities( gl, extensions, parameters ) { - - let maxAnisotropy; - - function getMaxAnisotropy() { - - if ( maxAnisotropy !== undefined ) return maxAnisotropy; - - if ( extensions.has( 'EXT_texture_filter_anisotropic' ) === true ) { - - const extension = extensions.get( 'EXT_texture_filter_anisotropic' ); - - maxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT ); - - } else { - - maxAnisotropy = 0; - - } - - return maxAnisotropy; - - } - - function getMaxPrecision( precision ) { - - if ( precision === 'highp' ) { - - if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 && - gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) { - - return 'highp'; - - } - - precision = 'mediump'; - - } - - if ( precision === 'mediump' ) { - - if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 && - gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) { - - return 'mediump'; - - } - - } - - return 'lowp'; - - } - - const isWebGL2 = typeof WebGL2RenderingContext !== 'undefined' && gl.constructor.name === 'WebGL2RenderingContext'; - - let precision = parameters.precision !== undefined ? parameters.precision : 'highp'; - const maxPrecision = getMaxPrecision( precision ); - - if ( maxPrecision !== precision ) { - - console.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' ); - precision = maxPrecision; - - } - - const drawBuffers = isWebGL2 || extensions.has( 'WEBGL_draw_buffers' ); - - const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true; - - const maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS ); - const maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS ); - const maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE ); - const maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE ); - - const maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS ); - const maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS ); - const maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS ); - const maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS ); - - const vertexTextures = maxVertexTextures > 0; - const floatFragmentTextures = isWebGL2 || extensions.has( 'OES_texture_float' ); - const floatVertexTextures = vertexTextures && floatFragmentTextures; - - const maxSamples = isWebGL2 ? gl.getParameter( gl.MAX_SAMPLES ) : 0; - - return { - - isWebGL2: isWebGL2, - - drawBuffers: drawBuffers, - - getMaxAnisotropy: getMaxAnisotropy, - getMaxPrecision: getMaxPrecision, - - precision: precision, - logarithmicDepthBuffer: logarithmicDepthBuffer, - - maxTextures: maxTextures, - maxVertexTextures: maxVertexTextures, - maxTextureSize: maxTextureSize, - maxCubemapSize: maxCubemapSize, - - maxAttributes: maxAttributes, - maxVertexUniforms: maxVertexUniforms, - maxVaryings: maxVaryings, - maxFragmentUniforms: maxFragmentUniforms, - - vertexTextures: vertexTextures, - floatFragmentTextures: floatFragmentTextures, - floatVertexTextures: floatVertexTextures, - - maxSamples: maxSamples - - }; - - } - - const SceneRevealMode = { - Default: 0, - Gradual: 1, - Instant: 2 - }; - - const LogLevel = { - None: 0, - Error: 1, - Warning: 2, - Info: 3, - Debug: 4 - }; - - const dummyGeometry = new THREE__namespace.BufferGeometry(); - const dummyMaterial = new THREE__namespace.MeshBasicMaterial(); - - const COVARIANCES_ELEMENTS_PER_SPLAT = 6; - const CENTER_COLORS_ELEMENTS_PER_SPLAT = 4; - - const COVARIANCES_ELEMENTS_PER_TEXEL_STORED = 4; - const COVARIANCES_ELEMENTS_PER_TEXEL_ALLOCATED = 4; - const COVARIANCES_ELEMENTS_PER_TEXEL_COMPRESSED_STORED = 6; - const COVARIANCES_ELEMENTS_PER_TEXEL_COMPRESSED_ALLOCATED = 8; - const SCALES_ROTATIONS_ELEMENTS_PER_TEXEL = 4; - const CENTER_COLORS_ELEMENTS_PER_TEXEL = 4; - const SCENE_INDEXES_ELEMENTS_PER_TEXEL = 1; - - const SCENE_FADEIN_RATE_FAST = 0.012; - const SCENE_FADEIN_RATE_GRADUAL = 0.003; - - const VISIBLE_REGION_EXPANSION_DELTA = 1; - - // Based on my own observations across multiple devices, OSes and browsers, using textures that have one dimension - // greater than 4096 while the other is greater than or equal to 4096 causes issues (Essentially any texture larger - // than 4096 x 4096 (16777216) texels). Specifically it seems all texture data beyond the 4096 x 4096 texel boundary - // is corrupted, while data below that boundary is usable. In these cases the texture has been valid in the eyes of - // both Three.js and WebGL, and the texel format (RG, RGBA, etc.) has not mattered. More investigation will be needed, - // but for now the work-around is to split the spherical harmonics into three textures (one for each color channel). - const MAX_TEXTURE_TEXELS = 16777216; - - /** - * SplatMesh: Container for one or more splat scenes, abstracting them into a single unified container for - * splat data. Additionally contains data structures and code to make the splat data renderable as a Three.js mesh. - */ - class SplatMesh extends THREE__namespace.Mesh { - - constructor(splatRenderMode = SplatRenderMode.ThreeD, dynamicMode = false, enableOptionalEffects = false, - halfPrecisionCovariancesOnGPU = false, devicePixelRatio = 1, enableDistancesComputationOnGPU = true, - integerBasedDistancesComputation = false, antialiased = false, maxScreenSpaceSplatSize = 1024, logLevel = LogLevel.None, - sphericalHarmonicsDegree = 0, sceneFadeInRateMultiplier = 1.0, kernel2DSize = 0.3) { - super(dummyGeometry, dummyMaterial); - - // Reference to a Three.js renderer - this.renderer = undefined; - - // Determine how the splats are rendered - this.splatRenderMode = splatRenderMode; - - // When 'dynamicMode' is true, scenes are assumed to be non-static. Dynamic scenes are handled differently - // and certain optimizations cannot be made for them. Additionally, by default, all splat data retrieved from - // this splat mesh will not have their scene transform applied to them if the splat mesh is dynamic. That - // can be overriden via parameters to the individual functions that are used to retrieve splat data. - this.dynamicMode = dynamicMode; - - // When true, allows for usage of extra properties and attributes during rendering for effects such as opacity adjustment. - // Default is false for performance reasons. These properties are separate from transform properties (scale, rotation, position) - // that are enabled by the 'dynamicScene' parameter. - this.enableOptionalEffects = enableOptionalEffects; - - // Use 16-bit floating point values when storing splat covariance data in textures, instead of 32-bit - this.halfPrecisionCovariancesOnGPU = halfPrecisionCovariancesOnGPU; - - // Ratio of the resolution in physical pixels to the resolution in CSS pixels for the current display device - this.devicePixelRatio = devicePixelRatio; - - // Use a transform feedback to calculate splat distances from the camera - this.enableDistancesComputationOnGPU = enableDistancesComputationOnGPU; - - // Use a faster integer-based approach for calculating splat distances from the camera - this.integerBasedDistancesComputation = integerBasedDistancesComputation; - - // When true, will perform additional steps during rendering to address artifacts caused by the rendering of gaussians at a - // substantially different resolution than that at which they were rendered during training. This will only work correctly - // for models that were trained using a process that utilizes this compensation calculation. For more details: - // https://github.com/nerfstudio-project/gsplat/pull/117 - // https://github.com/graphdeco-inria/gaussian-splatting/issues/294#issuecomment-1772688093 - this.antialiased = antialiased; - - // The size of the 2D kernel used for splat rendering - // This will adjust the 2D kernel size after the projection - this.kernel2DSize = kernel2DSize; - - // Specify the maximum clip space splat size, can help deal with large splats that get too unwieldy - this.maxScreenSpaceSplatSize = maxScreenSpaceSplatSize; - - // The verbosity of console logging - this.logLevel = logLevel; - - // Degree 0 means no spherical harmonics - this.sphericalHarmonicsDegree = sphericalHarmonicsDegree; - this.minSphericalHarmonicsDegree = 0; - - this.sceneFadeInRateMultiplier = sceneFadeInRateMultiplier; - - // The individual splat scenes stored in this splat mesh, each containing their own transform - this.scenes = []; - - // Special octree tailored to SplatMesh instances - this.splatTree = null; - this.baseSplatTree = null; - - // Cache textures and the intermediate data used to populate them - this.splatDataTextures = {}; - - this.distancesTransformFeedback = { - 'id': null, - 'vertexShader': null, - 'fragmentShader': null, - 'program': null, - 'centersBuffer': null, - 'sceneIndexesBuffer': null, - 'outDistancesBuffer': null, - 'centersLoc': -1, - 'modelViewProjLoc': -1, - 'sceneIndexesLoc': -1, - 'transformsLocs': [] - }; - - this.globalSplatIndexToLocalSplatIndexMap = []; - this.globalSplatIndexToSceneIndexMap = []; - - this.lastBuildSplatCount = 0; - this.lastBuildScenes = []; - this.lastBuildMaxSplatCount = 0; - this.lastBuildSceneCount = 0; - this.firstRenderTime = -1; - this.finalBuild = false; - - this.webGLUtils = null; - - this.boundingBox = new THREE__namespace.Box3(); - this.calculatedSceneCenter = new THREE__namespace.Vector3(); - this.maxSplatDistanceFromSceneCenter = 0; - this.visibleRegionBufferRadius = 0; - this.visibleRegionRadius = 0; - this.visibleRegionFadeStartRadius = 0; - this.visibleRegionChanging = false; - - this.splatScale = 1.0; - this.pointCloudModeEnabled = false; - - this.disposed = false; - this.lastRenderer = null; - this.visible = false; - } - - /** - * Build a container for each scene managed by this splat mesh based on an instance of SplatBuffer, along with optional - * transform data (position, scale, rotation) passed to the splat mesh during the build process. - * @param {Array} splatBuffers SplatBuffer instances containing splats for each scene - * @param {Array} sceneOptions Array of options objects: { - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * } - * @return {Array} - */ - static buildScenes(parentObject, splatBuffers, sceneOptions) { - const scenes = []; - scenes.length = splatBuffers.length; - for (let i = 0; i < splatBuffers.length; i++) { - const splatBuffer = splatBuffers[i]; - const options = sceneOptions[i] || {}; - let positionArray = options['position'] || [0, 0, 0]; - let rotationArray = options['rotation'] || [0, 0, 0, 1]; - let scaleArray = options['scale'] || [1, 1, 1]; - const position = new THREE__namespace.Vector3().fromArray(positionArray); - const rotation = new THREE__namespace.Quaternion().fromArray(rotationArray); - const scale = new THREE__namespace.Vector3().fromArray(scaleArray); - const scene = SplatMesh.createScene(splatBuffer, position, rotation, scale, - options.splatAlphaRemovalThreshold || 1, options.opacity, options.visible); - parentObject.add(scene); - scenes[i] = scene; - } - return scenes; - } - - static createScene(splatBuffer, position, rotation, scale, minimumAlpha, opacity = 1.0, visible = true) { - return new SplatScene(splatBuffer, position, rotation, scale, minimumAlpha, opacity, visible); - } - - /** - * Build data structures that map global splat indexes (based on a unified index across all splat buffers) to - * local data within a single scene. - * @param {Array} splatBuffers Instances of SplatBuffer off which to build the maps - * @return {object} - */ - static buildSplatIndexMaps(splatBuffers) { - const localSplatIndexMap = []; - const sceneIndexMap = []; - let totalSplatCount = 0; - for (let s = 0; s < splatBuffers.length; s++) { - const splatBuffer = splatBuffers[s]; - const maxSplatCount = splatBuffer.getMaxSplatCount(); - for (let i = 0; i < maxSplatCount; i++) { - localSplatIndexMap[totalSplatCount] = i; - sceneIndexMap[totalSplatCount] = s; - totalSplatCount++; - } - } - return { - localSplatIndexMap, - sceneIndexMap - }; - } - - /** - * Build an instance of SplatTree (a specialized octree) for the given splat mesh. - * @param {Array} minAlphas Array of minimum splat slphas for each scene - * @param {function} onSplatTreeIndexesUpload Function to be called when the upload of splat centers to the splat tree - * builder worker starts and finishes. - * @param {function} onSplatTreeConstruction Function to be called when the conversion of the local splat tree from - * the format produced by the splat tree builder worker starts and ends. - * @return {SplatTree} - */ - buildSplatTree = function(minAlphas = [], onSplatTreeIndexesUpload, onSplatTreeConstruction) { - return new Promise((resolve) => { - this.disposeSplatTree(); - // TODO: expose SplatTree constructor parameters (maximumDepth and maxCentersPerNode) so that they can - // be configured on a per-scene basis - this.baseSplatTree = new SplatTree(8, 1000); - const buildStartTime = performance.now(); - const splatColor = new THREE__namespace.Vector4(); - this.baseSplatTree.processSplatMesh(this, (splatIndex) => { - this.getSplatColor(splatIndex, splatColor); - const sceneIndex = this.getSceneIndexForSplat(splatIndex); - const minAlpha = minAlphas[sceneIndex] || 1; - return splatColor.w >= minAlpha; - }, onSplatTreeIndexesUpload, onSplatTreeConstruction) - .then(() => { - const buildTime = performance.now() - buildStartTime; - if (this.logLevel >= LogLevel.Info) console.log('SplatTree build: ' + buildTime + ' ms'); - if (this.disposed) { - resolve(); - } else { - - this.splatTree = this.baseSplatTree; - this.baseSplatTree = null; - - let leavesWithVertices = 0; - let avgSplatCount = 0; - let maxSplatCount = 0; - let nodeCount = 0; - - this.splatTree.visitLeaves((node) => { - const nodeSplatCount = node.data.indexes.length; - if (nodeSplatCount > 0) { - avgSplatCount += nodeSplatCount; - maxSplatCount = Math.max(maxSplatCount, nodeSplatCount); - nodeCount++; - leavesWithVertices++; - } - }); - if (this.logLevel >= LogLevel.Info) { - console.log(`SplatTree leaves: ${this.splatTree.countLeaves()}`); - console.log(`SplatTree leaves with splats:${leavesWithVertices}`); - avgSplatCount = avgSplatCount / nodeCount; - console.log(`Avg splat count per node: ${avgSplatCount}`); - console.log(`Total splat count: ${this.getSplatCount()}`); - } - resolve(); - } - }); - }); - }; - - /** - * Construct this instance of SplatMesh. - * @param {Array} splatBuffers The base splat data, instances of SplatBuffer - * @param {Array} sceneOptions Dynamic options for each scene { - * - * splatAlphaRemovalThreshold: Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * - * } - * @param {boolean} keepSceneTransforms For a scene that already exists and is being overwritten, this flag - * says to keep the transform from the existing scene. - * @param {boolean} finalBuild Will the splat mesh be in its final state after this build? - * @param {function} onSplatTreeIndexesUpload Function to be called when the upload of splat centers to the splat tree - * builder worker starts and finishes. - * @param {function} onSplatTreeConstruction Function to be called when the conversion of the local splat tree from - * the format produced by the splat tree builder worker starts and ends. - * @return {object} Object containing info about the splats that are updated - */ - build(splatBuffers, sceneOptions, keepSceneTransforms = true, finalBuild = false, - onSplatTreeIndexesUpload, onSplatTreeConstruction, preserveVisibleRegion = true) { - - this.sceneOptions = sceneOptions; - this.finalBuild = finalBuild; - - const maxSplatCount = SplatMesh.getTotalMaxSplatCountForSplatBuffers(splatBuffers); - - const newScenes = SplatMesh.buildScenes(this, splatBuffers, sceneOptions); - if (keepSceneTransforms) { - for (let i = 0; i < this.scenes.length && i < newScenes.length; i++) { - const newScene = newScenes[i]; - const existingScene = this.getScene(i); - newScene.copyTransformData(existingScene); - } - } - this.scenes = newScenes; - - let minSphericalHarmonicsDegree = 3; - for (let splatBuffer of splatBuffers) { - const splatBufferSphericalHarmonicsDegree = splatBuffer.getMinSphericalHarmonicsDegree(); - if (splatBufferSphericalHarmonicsDegree < minSphericalHarmonicsDegree) { - minSphericalHarmonicsDegree = splatBufferSphericalHarmonicsDegree; - } - } - this.minSphericalHarmonicsDegree = Math.min(minSphericalHarmonicsDegree, this.sphericalHarmonicsDegree); - - let splatBuffersChanged = false; - if (splatBuffers.length !== this.lastBuildScenes.length) { - splatBuffersChanged = true; - } else { - for (let i = 0; i < splatBuffers.length; i++) { - const splatBuffer = splatBuffers[i]; - if (splatBuffer !== this.lastBuildScenes[i].splatBuffer) { - splatBuffersChanged = true; - break; - } - } - } - - let isUpdateBuild = true; - if (this.scenes.length !== 1 || - this.lastBuildSceneCount !== this.scenes.length || - this.lastBuildMaxSplatCount !== maxSplatCount || - splatBuffersChanged) { - isUpdateBuild = false; - } - - if (!isUpdateBuild) { - this.boundingBox = new THREE__namespace.Box3(); - if (!preserveVisibleRegion) { - this.maxSplatDistanceFromSceneCenter = 0; - this.visibleRegionBufferRadius = 0; - this.visibleRegionRadius = 0; - this.visibleRegionFadeStartRadius = 0; - this.firstRenderTime = -1; - } - this.lastBuildScenes = []; - this.lastBuildSplatCount = 0; - this.lastBuildMaxSplatCount = 0; - this.disposeMeshData(); - this.geometry = SplatGeometry.build(maxSplatCount); - if (this.splatRenderMode === SplatRenderMode.ThreeD) { - this.material = SplatMaterial3D.build(this.dynamicMode, this.enableOptionalEffects, this.antialiased, - this.maxScreenSpaceSplatSize, this.splatScale, this.pointCloudModeEnabled, - this.minSphericalHarmonicsDegree, this.kernel2DSize); - } else { - this.material = SplatMaterial2D.build(this.dynamicMode, this.enableOptionalEffects, - this.splatScale, this.pointCloudModeEnabled, this.minSphericalHarmonicsDegree); - } - - const indexMaps = SplatMesh.buildSplatIndexMaps(splatBuffers); - this.globalSplatIndexToLocalSplatIndexMap = indexMaps.localSplatIndexMap; - this.globalSplatIndexToSceneIndexMap = indexMaps.sceneIndexMap; - } - - const splatBufferSplatCount = this.getSplatCount(true); - if (this.enableDistancesComputationOnGPU) this.setupDistancesComputationTransformFeedback(); - const dataUpdateResults = this.refreshGPUDataFromSplatBuffers(isUpdateBuild); - - for (let i = 0; i < this.scenes.length; i++) { - this.lastBuildScenes[i] = this.scenes[i]; - } - this.lastBuildSplatCount = splatBufferSplatCount; - this.lastBuildMaxSplatCount = this.getMaxSplatCount(); - this.lastBuildSceneCount = this.scenes.length; - - if (finalBuild && this.scenes.length > 0) { - this.buildSplatTree(sceneOptions.map(options => options.splatAlphaRemovalThreshold || 1), - onSplatTreeIndexesUpload, onSplatTreeConstruction) - .then(() => { - if (this.onSplatTreeReadyCallback) this.onSplatTreeReadyCallback(this.splatTree); - this.onSplatTreeReadyCallback = null; - }); - } - - this.visible = (this.scenes.length > 0); - - return dataUpdateResults; - } - - freeIntermediateSplatData() { - - const deleteTextureData = (texture) => { - delete texture.source.data; - delete texture.image; - texture.onUpdate = null; - }; - - delete this.splatDataTextures.baseData.covariances; - delete this.splatDataTextures.baseData.centers; - delete this.splatDataTextures.baseData.colors; - delete this.splatDataTextures.baseData.sphericalHarmonics; - - delete this.splatDataTextures.centerColors.data; - delete this.splatDataTextures.covariances.data; - if (this.splatDataTextures.sphericalHarmonics) { - delete this.splatDataTextures.sphericalHarmonics.data; - } - if (this.splatDataTextures.sceneIndexes) { - delete this.splatDataTextures.sceneIndexes.data; - } - - this.splatDataTextures.centerColors.texture.needsUpdate = true; - this.splatDataTextures.centerColors.texture.onUpdate = () => { - deleteTextureData(this.splatDataTextures.centerColors.texture); - }; - - this.splatDataTextures.covariances.texture.needsUpdate = true; - this.splatDataTextures.covariances.texture.onUpdate = () => { - deleteTextureData(this.splatDataTextures.covariances.texture); - }; - - if (this.splatDataTextures.sphericalHarmonics) { - if (this.splatDataTextures.sphericalHarmonics.texture) { - this.splatDataTextures.sphericalHarmonics.texture.needsUpdate = true; - this.splatDataTextures.sphericalHarmonics.texture.onUpdate = () => { - deleteTextureData(this.splatDataTextures.sphericalHarmonics.texture); - }; - } else { - this.splatDataTextures.sphericalHarmonics.textures.forEach((texture) => { - texture.needsUpdate = true; - texture.onUpdate = () => { - deleteTextureData(texture); - }; - }); - } - } - if (this.splatDataTextures.sceneIndexes) { - this.splatDataTextures.sceneIndexes.texture.needsUpdate = true; - this.splatDataTextures.sceneIndexes.texture.onUpdate = () => { - deleteTextureData(this.splatDataTextures.sceneIndexes.texture); - }; - } - } - /** - * Dispose all resources held by the splat mesh - */ - dispose() { - this.disposeMeshData(); - this.disposeTextures(); - this.disposeSplatTree(); - if (this.enableDistancesComputationOnGPU) { - if (this.computeDistancesOnGPUSyncTimeout) { - clearTimeout(this.computeDistancesOnGPUSyncTimeout); - this.computeDistancesOnGPUSyncTimeout = null; - } - this.disposeDistancesComputationGPUResources(); - } - this.scenes = []; - this.distancesTransformFeedback = { - 'id': null, - 'vertexShader': null, - 'fragmentShader': null, - 'program': null, - 'centersBuffer': null, - 'sceneIndexesBuffer': null, - 'outDistancesBuffer': null, - 'centersLoc': -1, - 'modelViewProjLoc': -1, - 'sceneIndexesLoc': -1, - 'transformsLocs': [] - }; - this.renderer = null; - - this.globalSplatIndexToLocalSplatIndexMap = []; - this.globalSplatIndexToSceneIndexMap = []; - - this.lastBuildSplatCount = 0; - this.lastBuildScenes = []; - this.lastBuildMaxSplatCount = 0; - this.lastBuildSceneCount = 0; - this.firstRenderTime = -1; - this.finalBuild = false; - - this.webGLUtils = null; - - this.boundingBox = new THREE__namespace.Box3(); - this.calculatedSceneCenter = new THREE__namespace.Vector3(); - this.maxSplatDistanceFromSceneCenter = 0; - this.visibleRegionBufferRadius = 0; - this.visibleRegionRadius = 0; - this.visibleRegionFadeStartRadius = 0; - this.visibleRegionChanging = false; - - this.splatScale = 1.0; - this.pointCloudModeEnabled = false; - - this.disposed = true; - this.lastRenderer = null; - this.visible = false; - } - - /** - * Dispose of only the Three.js mesh resources (geometry, material, and texture) - */ - disposeMeshData() { - if (this.geometry && this.geometry !== dummyGeometry) { - this.geometry.dispose(); - this.geometry = null; - } - if (this.material) { - this.material.dispose(); - this.material = null; - } - } - - disposeTextures() { - for (let textureKey in this.splatDataTextures) { - if (this.splatDataTextures.hasOwnProperty(textureKey)) { - const textureContainer = this.splatDataTextures[textureKey]; - if (textureContainer.texture) { - textureContainer.texture.dispose(); - textureContainer.texture = null; - } - } - } - this.splatDataTextures = null; - } - - disposeSplatTree() { - if (this.splatTree) { - this.splatTree.dispose(); - this.splatTree = null; - } - if (this.baseSplatTree) { - this.baseSplatTree.dispose(); - this.baseSplatTree = null; - } - } - - getSplatTree() { - return this.splatTree; - } - - onSplatTreeReady(callback) { - this.onSplatTreeReadyCallback = callback; - } - - /** - * Get copies of data that are necessary for splat distance computation: splat center positions and splat - * scene indexes (necessary for applying dynamic scene transformations during distance computation) - * @param {*} start The index at which to start copying data - * @param {*} end The index at which to stop copying data - * @return {object} - */ - getDataForDistancesComputation(start, end) { - const centers = this.integerBasedDistancesComputation ? - this.getIntegerCenters(start, end, true) : - this.getFloatCenters(start, end, true); - const sceneIndexes = this.getSceneIndexes(start, end); - return { - centers, - sceneIndexes - }; - } - - /** - * Refresh data textures and GPU buffers with splat data from the splat buffers belonging to this mesh. - * @param {boolean} sinceLastBuildOnly Specify whether or not to only update for splats that have been added since the last build. - * @return {object} - */ - refreshGPUDataFromSplatBuffers(sinceLastBuildOnly) { - const splatCount = this.getSplatCount(true); - this.refreshDataTexturesFromSplatBuffers(sinceLastBuildOnly); - const updateStart = sinceLastBuildOnly ? this.lastBuildSplatCount : 0; - const { centers, sceneIndexes } = this.getDataForDistancesComputation(updateStart, splatCount - 1); - if (this.enableDistancesComputationOnGPU) { - this.refreshGPUBuffersForDistancesComputation(centers, sceneIndexes, sinceLastBuildOnly); - } - return { - 'from': updateStart, - 'to': splatCount - 1, - 'count': splatCount - updateStart, - 'centers': centers, - 'sceneIndexes': sceneIndexes - }; - } - - /** - * Update the GPU buffers that are used for computing splat distances on the GPU. - * @param {Array} centers Splat center positions - * @param {Array} sceneIndexes Indexes of the scene to which each splat belongs - * @param {boolean} sinceLastBuildOnly Specify whether or not to only update for splats that have been added since the last build. - */ - refreshGPUBuffersForDistancesComputation(centers, sceneIndexes, sinceLastBuildOnly = false) { - const offset = sinceLastBuildOnly ? this.lastBuildSplatCount : 0; - this.updateGPUCentersBufferForDistancesComputation(sinceLastBuildOnly, centers, offset); - this.updateGPUTransformIndexesBufferForDistancesComputation(sinceLastBuildOnly, sceneIndexes, offset); - } - - /** - * Refresh data textures with data from the splat buffers for this mesh. - * @param {boolean} sinceLastBuildOnly Specify whether or not to only update for splats that have been added since the last build. - */ - refreshDataTexturesFromSplatBuffers(sinceLastBuildOnly) { - const splatCount = this.getSplatCount(true); - const fromSplat = this.lastBuildSplatCount; - const toSplat = splatCount - 1; - - if (!sinceLastBuildOnly) { - this.setupDataTextures(); - this.updateBaseDataFromSplatBuffers(); - } else { - this.updateBaseDataFromSplatBuffers(fromSplat, toSplat); - } - - this.updateDataTexturesFromBaseData(fromSplat, toSplat); - this.updateVisibleRegion(sinceLastBuildOnly); - } - - setupDataTextures() { - const maxSplatCount = this.getMaxSplatCount(); - const splatCount = this.getSplatCount(true); - - this.disposeTextures(); - - const computeDataTextureSize = (elementsPerTexel, elementsPerSplat) => { - const texSize = new THREE__namespace.Vector2(4096, 1024); - while (texSize.x * texSize.y * elementsPerTexel < maxSplatCount * elementsPerSplat) texSize.y *= 2; - return texSize; - }; - - const getCovariancesElementsPertexelStored = (compressionLevel) => { - return compressionLevel >= 1 ? COVARIANCES_ELEMENTS_PER_TEXEL_COMPRESSED_STORED : COVARIANCES_ELEMENTS_PER_TEXEL_STORED; - }; - - const getCovariancesInitialTextureSpecs = (compressionLevel) => { - const elementsPerTexelStored = getCovariancesElementsPertexelStored(compressionLevel); - const texSize = computeDataTextureSize(elementsPerTexelStored, 6); - return {elementsPerTexelStored, texSize}; - }; - - let covarianceCompressionLevel = this.getTargetCovarianceCompressionLevel(); - const scaleRotationCompressionLevel = 0; - const shCompressionLevel = this.getTargetSphericalHarmonicsCompressionLevel(); - - let covariances; - let scales; - let rotations; - if (this.splatRenderMode === SplatRenderMode.ThreeD) { - const initialCovTexSpecs = getCovariancesInitialTextureSpecs(covarianceCompressionLevel); - if (initialCovTexSpecs.texSize.x * initialCovTexSpecs.texSize.y > MAX_TEXTURE_TEXELS && covarianceCompressionLevel === 0) { - covarianceCompressionLevel = 1; - } - covariances = new Float32Array(maxSplatCount * COVARIANCES_ELEMENTS_PER_SPLAT); - } else { - scales = new Float32Array(maxSplatCount * 3); - rotations = new Float32Array(maxSplatCount * 4); - } - - const centers = new Float32Array(maxSplatCount * 3); - const colors = new Uint8Array(maxSplatCount * 4); - - let SphericalHarmonicsArrayType = Float32Array; - if (shCompressionLevel === 1) SphericalHarmonicsArrayType = Uint16Array; - else if (shCompressionLevel === 2) SphericalHarmonicsArrayType = Uint8Array; - const shComponentCount = getSphericalHarmonicsComponentCountForDegree(this.minSphericalHarmonicsDegree); - const shData = this.minSphericalHarmonicsDegree ? new SphericalHarmonicsArrayType(maxSplatCount * shComponentCount) : undefined; - - // set up centers/colors data texture - const centersColsTexSize = computeDataTextureSize(CENTER_COLORS_ELEMENTS_PER_TEXEL, 4); - const paddedCentersCols = new Uint32Array(centersColsTexSize.x * centersColsTexSize.y * CENTER_COLORS_ELEMENTS_PER_TEXEL); - SplatMesh.updateCenterColorsPaddedData(0, splatCount - 1, centers, colors, paddedCentersCols); - - const centersColsTex = new THREE__namespace.DataTexture(paddedCentersCols, centersColsTexSize.x, centersColsTexSize.y, - THREE__namespace.RGBAIntegerFormat, THREE__namespace.UnsignedIntType); - centersColsTex.internalFormat = 'RGBA32UI'; - centersColsTex.needsUpdate = true; - this.material.uniforms.centersColorsTexture.value = centersColsTex; - this.material.uniforms.centersColorsTextureSize.value.copy(centersColsTexSize); - this.material.uniformsNeedUpdate = true; - - this.splatDataTextures = { - 'baseData': { - 'covariances': covariances, - 'scales': scales, - 'rotations': rotations, - 'centers': centers, - 'colors': colors, - 'sphericalHarmonics': shData - }, - 'centerColors': { - 'data': paddedCentersCols, - 'texture': centersColsTex, - 'size': centersColsTexSize - } - }; - - if (this.splatRenderMode === SplatRenderMode.ThreeD) { - // set up covariances data texture - - const covTexSpecs = getCovariancesInitialTextureSpecs(covarianceCompressionLevel); - const covariancesElementsPerTexelStored = covTexSpecs.elementsPerTexelStored; - const covTexSize = covTexSpecs.texSize; - - let CovariancesDataType = covarianceCompressionLevel >= 1 ? Uint32Array : Float32Array; - const covariancesElementsPerTexelAllocated = covarianceCompressionLevel >= 1 ? - COVARIANCES_ELEMENTS_PER_TEXEL_COMPRESSED_ALLOCATED : - COVARIANCES_ELEMENTS_PER_TEXEL_ALLOCATED; - const covariancesTextureData = new CovariancesDataType(covTexSize.x * covTexSize.y * covariancesElementsPerTexelAllocated); - - if (covarianceCompressionLevel === 0) { - covariancesTextureData.set(covariances); - } else { - SplatMesh.updatePaddedCompressedCovariancesTextureData(covariances, covariancesTextureData, 0, 0, covariances.length); - } - - let covTex; - if (covarianceCompressionLevel >= 1) { - covTex = new THREE__namespace.DataTexture(covariancesTextureData, covTexSize.x, covTexSize.y, - THREE__namespace.RGBAIntegerFormat, THREE__namespace.UnsignedIntType); - covTex.internalFormat = 'RGBA32UI'; - this.material.uniforms.covariancesTextureHalfFloat.value = covTex; - } else { - covTex = new THREE__namespace.DataTexture(covariancesTextureData, covTexSize.x, covTexSize.y, THREE__namespace.RGBAFormat, THREE__namespace.FloatType); - this.material.uniforms.covariancesTexture.value = covTex; - - // For some reason a usampler2D needs to have a valid texture attached or WebGL complains - const dummyTex = new THREE__namespace.DataTexture(new Uint32Array(32), 2, 2, THREE__namespace.RGBAIntegerFormat, THREE__namespace.UnsignedIntType); - dummyTex.internalFormat = 'RGBA32UI'; - this.material.uniforms.covariancesTextureHalfFloat.value = dummyTex; - dummyTex.needsUpdate = true; - } - covTex.needsUpdate = true; - - this.material.uniforms.covariancesAreHalfFloat.value = (covarianceCompressionLevel >= 1) ? 1 : 0; - this.material.uniforms.covariancesTextureSize.value.copy(covTexSize); - - this.splatDataTextures['covariances'] = { - 'data': covariancesTextureData, - 'texture': covTex, - 'size': covTexSize, - 'compressionLevel': covarianceCompressionLevel, - 'elementsPerTexelStored': covariancesElementsPerTexelStored, - 'elementsPerTexelAllocated': covariancesElementsPerTexelAllocated - }; - } else { - // set up scale & rotations data texture - const elementsPerSplat = 6; - const scaleRotationsTexSize = computeDataTextureSize(SCALES_ROTATIONS_ELEMENTS_PER_TEXEL, elementsPerSplat); - let ScaleRotationsDataType = scaleRotationCompressionLevel >= 1 ? Uint16Array : Float32Array; - let scaleRotationsTextureType = scaleRotationCompressionLevel >= 1 ? THREE__namespace.HalfFloatType : THREE__namespace.FloatType; - const paddedScaleRotations = new ScaleRotationsDataType(scaleRotationsTexSize.x * scaleRotationsTexSize.y * - SCALES_ROTATIONS_ELEMENTS_PER_TEXEL); - - SplatMesh.updateScaleRotationsPaddedData(0, splatCount - 1, scales, rotations, paddedScaleRotations); - - const scaleRotationsTex = new THREE__namespace.DataTexture(paddedScaleRotations, scaleRotationsTexSize.x, scaleRotationsTexSize.y, - THREE__namespace.RGBAFormat, scaleRotationsTextureType); - scaleRotationsTex.needsUpdate = true; - this.material.uniforms.scaleRotationsTexture.value = scaleRotationsTex; - this.material.uniforms.scaleRotationsTextureSize.value.copy(scaleRotationsTexSize); - - this.splatDataTextures['scaleRotations'] = { - 'data': paddedScaleRotations, - 'texture': scaleRotationsTex, - 'size': scaleRotationsTexSize, - 'compressionLevel': scaleRotationCompressionLevel - }; - } - - if (shData) { - const shTextureType = shCompressionLevel === 2 ? THREE__namespace.UnsignedByteType : THREE__namespace.HalfFloatType; - - let paddedSHComponentCount = shComponentCount; - if (paddedSHComponentCount % 2 !== 0) paddedSHComponentCount++; - const shElementsPerTexel = 4; - const texelFormat = shElementsPerTexel === 4 ? THREE__namespace.RGBAFormat : THREE__namespace.RGFormat; - let shTexSize = computeDataTextureSize(shElementsPerTexel, paddedSHComponentCount); - - // Use one texture for all spherical harmonics data - if (shTexSize.x * shTexSize.y <= MAX_TEXTURE_TEXELS) { - const paddedSHArraySize = shTexSize.x * shTexSize.y * shElementsPerTexel; - const paddedSHArray = new SphericalHarmonicsArrayType(paddedSHArraySize); - for (let c = 0; c < splatCount; c++) { - const srcBase = shComponentCount * c; - const destBase = paddedSHComponentCount * c; - for (let i = 0; i < shComponentCount; i++) { - paddedSHArray[destBase + i] = shData[srcBase + i]; - } - } - - const shTexture = new THREE__namespace.DataTexture(paddedSHArray, shTexSize.x, shTexSize.y, texelFormat, shTextureType); - shTexture.needsUpdate = true; - this.material.uniforms.sphericalHarmonicsTexture.value = shTexture; - this.splatDataTextures['sphericalHarmonics'] = { - 'componentCount': shComponentCount, - 'paddedComponentCount': paddedSHComponentCount, - 'data': paddedSHArray, - 'textureCount': 1, - 'texture': shTexture, - 'size': shTexSize, - 'compressionLevel': shCompressionLevel, - 'elementsPerTexel': shElementsPerTexel - }; - // Use three textures for spherical harmonics data, one per color channel - } else { - const shComponentCountPerChannel = shComponentCount / 3; - paddedSHComponentCount = shComponentCountPerChannel; - if (paddedSHComponentCount % 2 !== 0) paddedSHComponentCount++; - shTexSize = computeDataTextureSize(shElementsPerTexel, paddedSHComponentCount); - - const paddedSHArraySize = shTexSize.x * shTexSize.y * shElementsPerTexel; - const textureUniforms = [this.material.uniforms.sphericalHarmonicsTextureR, - this.material.uniforms.sphericalHarmonicsTextureG, - this.material.uniforms.sphericalHarmonicsTextureB]; - const paddedSHArrays = []; - const shTextures = []; - for (let t = 0; t < 3; t++) { - const paddedSHArray = new SphericalHarmonicsArrayType(paddedSHArraySize); - paddedSHArrays.push(paddedSHArray); - for (let c = 0; c < splatCount; c++) { - const srcBase = shComponentCount * c; - const destBase = paddedSHComponentCount * c; - if (shComponentCountPerChannel >= 3) { - for (let i = 0; i < 3; i++) paddedSHArray[destBase + i] = shData[srcBase + t * 3 + i]; - if (shComponentCountPerChannel >= 8) { - for (let i = 0; i < 5; i++) paddedSHArray[destBase + 3 + i] = shData[srcBase + 9 + t * 5 + i]; - } - } - } - - const shTexture = new THREE__namespace.DataTexture(paddedSHArray, shTexSize.x, shTexSize.y, texelFormat, shTextureType); - shTextures.push(shTexture); - shTexture.needsUpdate = true; - textureUniforms[t].value = shTexture; - } - - this.material.uniforms.sphericalHarmonicsMultiTextureMode.value = 1; - this.splatDataTextures['sphericalHarmonics'] = { - 'componentCount': shComponentCount, - 'componentCountPerChannel': shComponentCountPerChannel, - 'paddedComponentCount': paddedSHComponentCount, - 'data': paddedSHArrays, - 'textureCount': 3, - 'textures': shTextures, - 'size': shTexSize, - 'compressionLevel': shCompressionLevel, - 'elementsPerTexel': shElementsPerTexel - }; - } - - this.material.uniforms.sphericalHarmonicsTextureSize.value.copy(shTexSize); - this.material.uniforms.sphericalHarmonics8BitMode.value = shCompressionLevel === 2 ? 1 : 0; - for (let s = 0; s < this.scenes.length; s++) { - const splatBuffer = this.scenes[s].splatBuffer; - this.material.uniforms.sphericalHarmonics8BitCompressionRangeMin.value[s] = - splatBuffer.minSphericalHarmonicsCoeff; - this.material.uniforms.sphericalHarmonics8BitCompressionRangeMax.value[s] = - splatBuffer.maxSphericalHarmonicsCoeff; - } - this.material.uniformsNeedUpdate = true; - } - - const sceneIndexesTexSize = computeDataTextureSize(SCENE_INDEXES_ELEMENTS_PER_TEXEL, 4); - const paddedTransformIndexes = new Uint32Array(sceneIndexesTexSize.x * - sceneIndexesTexSize.y * SCENE_INDEXES_ELEMENTS_PER_TEXEL); - for (let c = 0; c < splatCount; c++) paddedTransformIndexes[c] = this.globalSplatIndexToSceneIndexMap[c]; - const sceneIndexesTexture = new THREE__namespace.DataTexture(paddedTransformIndexes, sceneIndexesTexSize.x, sceneIndexesTexSize.y, - THREE__namespace.RedIntegerFormat, THREE__namespace.UnsignedIntType); - sceneIndexesTexture.internalFormat = 'R32UI'; - sceneIndexesTexture.needsUpdate = true; - this.material.uniforms.sceneIndexesTexture.value = sceneIndexesTexture; - this.material.uniforms.sceneIndexesTextureSize.value.copy(sceneIndexesTexSize); - this.material.uniformsNeedUpdate = true; - this.splatDataTextures['sceneIndexes'] = { - 'data': paddedTransformIndexes, - 'texture': sceneIndexesTexture, - 'size': sceneIndexesTexSize - }; - this.material.uniforms.sceneCount.value = this.scenes.length; - } - - updateBaseDataFromSplatBuffers(fromSplat, toSplat) { - const covarancesTextureDesc = this.splatDataTextures['covariances']; - const covarianceCompressionLevel = covarancesTextureDesc ? covarancesTextureDesc.compressionLevel : undefined; - const scaleRotationsTextureDesc = this.splatDataTextures['scaleRotations']; - const scaleRotationCompressionLevel = scaleRotationsTextureDesc ? scaleRotationsTextureDesc.compressionLevel : undefined; - const shITextureDesc = this.splatDataTextures['sphericalHarmonics']; - const shCompressionLevel = shITextureDesc ? shITextureDesc.compressionLevel : 0; - - this.fillSplatDataArrays(this.splatDataTextures.baseData.covariances, this.splatDataTextures.baseData.scales, - this.splatDataTextures.baseData.rotations, this.splatDataTextures.baseData.centers, - this.splatDataTextures.baseData.colors, this.splatDataTextures.baseData.sphericalHarmonics, undefined, - covarianceCompressionLevel, scaleRotationCompressionLevel, shCompressionLevel, - fromSplat, toSplat, fromSplat); - } - - updateDataTexturesFromBaseData(fromSplat, toSplat) { - const covarancesTextureDesc = this.splatDataTextures['covariances']; - const covarianceCompressionLevel = covarancesTextureDesc ? covarancesTextureDesc.compressionLevel : undefined; - const scaleRotationsTextureDesc = this.splatDataTextures['scaleRotations']; - const scaleRotationCompressionLevel = scaleRotationsTextureDesc ? scaleRotationsTextureDesc.compressionLevel : undefined; - const shTextureDesc = this.splatDataTextures['sphericalHarmonics']; - const shCompressionLevel = shTextureDesc ? shTextureDesc.compressionLevel : 0; - - // Update center & color data texture - const centerColorsTextureDescriptor = this.splatDataTextures['centerColors']; - const paddedCenterColors = centerColorsTextureDescriptor.data; - const centerColorsTexture = centerColorsTextureDescriptor.texture; - SplatMesh.updateCenterColorsPaddedData(fromSplat, toSplat, this.splatDataTextures.baseData.centers, - this.splatDataTextures.baseData.colors, paddedCenterColors); - const centerColorsTextureProps = this.renderer ? this.renderer.properties.get(centerColorsTexture) : null; - if (!centerColorsTextureProps || !centerColorsTextureProps.__webglTexture) { - centerColorsTexture.needsUpdate = true; - } else { - this.updateDataTexture(paddedCenterColors, centerColorsTextureDescriptor.texture, centerColorsTextureDescriptor.size, - centerColorsTextureProps, CENTER_COLORS_ELEMENTS_PER_TEXEL, CENTER_COLORS_ELEMENTS_PER_SPLAT, 4, - fromSplat, toSplat); - } - - // update covariance data texture - if (covarancesTextureDesc) { - const covariancesTexture = covarancesTextureDesc.texture; - const covarancesStartElement = fromSplat * COVARIANCES_ELEMENTS_PER_SPLAT; - const covariancesEndElement = toSplat * COVARIANCES_ELEMENTS_PER_SPLAT; - - if (covarianceCompressionLevel === 0) { - for (let i = covarancesStartElement; i <= covariancesEndElement; i++) { - const covariance = this.splatDataTextures.baseData.covariances[i]; - covarancesTextureDesc.data[i] = covariance; - } - } else { - SplatMesh.updatePaddedCompressedCovariancesTextureData(this.splatDataTextures.baseData.covariances, - covarancesTextureDesc.data, - fromSplat * covarancesTextureDesc.elementsPerTexelAllocated, - covarancesStartElement, covariancesEndElement); - } - - const covariancesTextureProps = this.renderer ? this.renderer.properties.get(covariancesTexture) : null; - if (!covariancesTextureProps || !covariancesTextureProps.__webglTexture) { - covariancesTexture.needsUpdate = true; - } else { - if (covarianceCompressionLevel === 0) { - this.updateDataTexture(covarancesTextureDesc.data, covarancesTextureDesc.texture, covarancesTextureDesc.size, - covariancesTextureProps, covarancesTextureDesc.elementsPerTexelStored, - COVARIANCES_ELEMENTS_PER_SPLAT, 4, fromSplat, toSplat); - } else { - this.updateDataTexture(covarancesTextureDesc.data, covarancesTextureDesc.texture, covarancesTextureDesc.size, - covariancesTextureProps, covarancesTextureDesc.elementsPerTexelAllocated, - covarancesTextureDesc.elementsPerTexelAllocated, 2, fromSplat, toSplat); - } - } - } - - // update scale and rotation data texture - if (scaleRotationsTextureDesc) { - const paddedScaleRotations = scaleRotationsTextureDesc.data; - const scaleRotationsTexture = scaleRotationsTextureDesc.texture; - const elementsPerSplat = 6; - const bytesPerElement = scaleRotationCompressionLevel === 0 ? 4 : 2; - - SplatMesh.updateScaleRotationsPaddedData(fromSplat, toSplat, this.splatDataTextures.baseData.scales, - this.splatDataTextures.baseData.rotations, paddedScaleRotations); - const scaleRotationsTextureProps = this.renderer ? this.renderer.properties.get(scaleRotationsTexture) : null; - if (!scaleRotationsTextureProps || !scaleRotationsTextureProps.__webglTexture) { - scaleRotationsTexture.needsUpdate = true; - } else { - this.updateDataTexture(paddedScaleRotations, scaleRotationsTextureDesc.texture, scaleRotationsTextureDesc.size, - scaleRotationsTextureProps, SCALES_ROTATIONS_ELEMENTS_PER_TEXEL, elementsPerSplat, bytesPerElement, - fromSplat, toSplat); - } - } - - // update spherical harmonics data texture - const shData = this.splatDataTextures.baseData.sphericalHarmonics; - if (shData) { - let shBytesPerElement = 4; - if (shCompressionLevel === 1) shBytesPerElement = 2; - else if (shCompressionLevel === 2) shBytesPerElement = 1; - - const updateTexture = (shTexture, shTextureSize, elementsPerTexel, paddedSHArray, paddedSHComponentCount) => { - const shTextureProps = this.renderer ? this.renderer.properties.get(shTexture) : null; - if (!shTextureProps || !shTextureProps.__webglTexture) { - shTexture.needsUpdate = true; - } else { - this.updateDataTexture(paddedSHArray, shTexture, shTextureSize, shTextureProps, elementsPerTexel, - paddedSHComponentCount, shBytesPerElement, fromSplat, toSplat); - } - }; - - const shComponentCount = shTextureDesc.componentCount; - const paddedSHComponentCount = shTextureDesc.paddedComponentCount; - - // Update for the case of a single texture for all spherical harmonics data - if (shTextureDesc.textureCount === 1) { - const paddedSHArray = shTextureDesc.data; - for (let c = fromSplat; c <= toSplat; c++) { - const srcBase = shComponentCount * c; - const destBase = paddedSHComponentCount * c; - for (let i = 0; i < shComponentCount; i++) { - paddedSHArray[destBase + i] = shData[srcBase + i]; - } - } - updateTexture(shTextureDesc.texture, shTextureDesc.size, - shTextureDesc.elementsPerTexel, paddedSHArray, paddedSHComponentCount); - // Update for the case of spherical harmonics data split among three textures, one for each color channel - } else { - const shComponentCountPerChannel = shTextureDesc.componentCountPerChannel; - for (let t = 0; t < 3; t++) { - const paddedSHArray = shTextureDesc.data[t]; - for (let c = fromSplat; c <= toSplat; c++) { - const srcBase = shComponentCount * c; - const destBase = paddedSHComponentCount * c; - if (shComponentCountPerChannel >= 3) { - for (let i = 0; i < 3; i++) paddedSHArray[destBase + i] = shData[srcBase + t * 3 + i]; - if (shComponentCountPerChannel >= 8) { - for (let i = 0; i < 5; i++) paddedSHArray[destBase + 3 + i] = shData[srcBase + 9 + t * 5 + i]; - } - } - } - updateTexture(shTextureDesc.textures[t], shTextureDesc.size, - shTextureDesc.elementsPerTexel, paddedSHArray, paddedSHComponentCount); - } - } - } - - // update scene index & transform data - const sceneIndexesTexDesc = this.splatDataTextures['sceneIndexes']; - const paddedSceneIndexes = sceneIndexesTexDesc.data; - for (let c = this.lastBuildSplatCount; c <= toSplat; c++) { - paddedSceneIndexes[c] = this.globalSplatIndexToSceneIndexMap[c]; - } - const sceneIndexesTexture = sceneIndexesTexDesc.texture; - const sceneIndexesTextureProps = this.renderer ? this.renderer.properties.get(sceneIndexesTexture) : null; - if (!sceneIndexesTextureProps || !sceneIndexesTextureProps.__webglTexture) { - sceneIndexesTexture.needsUpdate = true; - } else { - this.updateDataTexture(paddedSceneIndexes, sceneIndexesTexDesc.texture, sceneIndexesTexDesc.size, - sceneIndexesTextureProps, 1, 1, 1, this.lastBuildSplatCount, toSplat); - } - } - - getTargetCovarianceCompressionLevel() { - return this.halfPrecisionCovariancesOnGPU ? 1 : 0; - } - - getTargetSphericalHarmonicsCompressionLevel() { - return Math.max(1, this.getMaximumSplatBufferCompressionLevel()); - } - - getMaximumSplatBufferCompressionLevel() { - let maxCompressionLevel; - for (let i = 0; i < this.scenes.length; i++) { - const scene = this.getScene(i); - const splatBuffer = scene.splatBuffer; - if (i === 0 || splatBuffer.compressionLevel > maxCompressionLevel) { - maxCompressionLevel = splatBuffer.compressionLevel; - } - } - return maxCompressionLevel; - } - - getMinimumSplatBufferCompressionLevel() { - let minCompressionLevel; - for (let i = 0; i < this.scenes.length; i++) { - const scene = this.getScene(i); - const splatBuffer = scene.splatBuffer; - if (i === 0 || splatBuffer.compressionLevel < minCompressionLevel) { - minCompressionLevel = splatBuffer.compressionLevel; - } - } - return minCompressionLevel; - } - - static computeTextureUpdateRegion(startSplat, endSplat, textureWidth, elementsPerTexel, elementsPerSplat) { - const texelsPerSplat = elementsPerSplat / elementsPerTexel; - - const startSplatTexels = startSplat * texelsPerSplat; - const startRow = Math.floor(startSplatTexels / textureWidth); - const startRowElement = startRow * textureWidth * elementsPerTexel; - - const endSplatTexels = endSplat * texelsPerSplat; - const endRow = Math.floor(endSplatTexels / textureWidth); - const endRowEndElement = endRow * textureWidth * elementsPerTexel + (textureWidth * elementsPerTexel); - - return { - 'dataStart': startRowElement, - 'dataEnd': endRowEndElement, - 'startRow': startRow, - 'endRow': endRow - }; - } - - updateDataTexture(paddedData, texture, textureSize, textureProps, elementsPerTexel, elementsPerSplat, bytesPerElement, from, to) { - const gl = this.renderer.getContext(); - const updateRegion = SplatMesh.computeTextureUpdateRegion(from, to, textureSize.x, elementsPerTexel, elementsPerSplat); - const updateElementCount = updateRegion.dataEnd - updateRegion.dataStart; - const updateDataView = new paddedData.constructor(paddedData.buffer, - updateRegion.dataStart * bytesPerElement, updateElementCount); - const updateHeight = updateRegion.endRow - updateRegion.startRow + 1; - const glType = this.webGLUtils.convert(texture.type); - const glFormat = this.webGLUtils.convert(texture.format, texture.colorSpace); - const currentTexture = gl.getParameter(gl.TEXTURE_BINDING_2D); - gl.bindTexture(gl.TEXTURE_2D, textureProps.__webglTexture); - gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, updateRegion.startRow, - textureSize.x, updateHeight, glFormat, glType, updateDataView); - gl.bindTexture(gl.TEXTURE_2D, currentTexture); - } - - static updatePaddedCompressedCovariancesTextureData(sourceData, textureData, textureDataStartIndex, fromElement, toElement) { - let textureDataView = new DataView(textureData.buffer); - let textureDataIndex = textureDataStartIndex; - let sequentialCount = 0; - for (let i = fromElement; i <= toElement; i+=2) { - textureDataView.setUint16(textureDataIndex * 2, sourceData[i], true); - textureDataView.setUint16(textureDataIndex * 2 + 2, sourceData[i + 1], true); - textureDataIndex += 2; - sequentialCount++; - if (sequentialCount >= 3) { - textureDataIndex += 2; - sequentialCount = 0; - } - } - } - - static updateCenterColorsPaddedData(from, to, centers, colors, paddedCenterColors) { - for (let c = from; c <= to; c++) { - const colorsBase = c * 4; - const centersBase = c * 3; - const centerColorsBase = c * 4; - paddedCenterColors[centerColorsBase] = rgbaArrayToInteger(colors, colorsBase); - paddedCenterColors[centerColorsBase + 1] = uintEncodedFloat(centers[centersBase]); - paddedCenterColors[centerColorsBase + 2] = uintEncodedFloat(centers[centersBase + 1]); - paddedCenterColors[centerColorsBase + 3] = uintEncodedFloat(centers[centersBase + 2]); - } - } - - static updateScaleRotationsPaddedData(from, to, scales, rotations, paddedScaleRotations) { - const combinedSize = 6; - for (let c = from; c <= to; c++) { - const scaleBase = c * 3; - const rotationBase = c * 4; - const scaleRotationsBase = c * combinedSize; - - paddedScaleRotations[scaleRotationsBase] = scales[scaleBase]; - paddedScaleRotations[scaleRotationsBase + 1] = scales[scaleBase + 1]; - paddedScaleRotations[scaleRotationsBase + 2] = scales[scaleBase + 2]; - - paddedScaleRotations[scaleRotationsBase + 3] = rotations[rotationBase]; - paddedScaleRotations[scaleRotationsBase + 4] = rotations[rotationBase + 1]; - paddedScaleRotations[scaleRotationsBase + 5] = rotations[rotationBase + 2]; - } - } - - updateVisibleRegion(sinceLastBuildOnly) { - const splatCount = this.getSplatCount(true); - const tempCenter = new THREE__namespace.Vector3(); - if (!sinceLastBuildOnly) { - const avgCenter = new THREE__namespace.Vector3(); - this.scenes.forEach((scene) => { - avgCenter.add(scene.splatBuffer.sceneCenter); - }); - avgCenter.multiplyScalar(1.0 / this.scenes.length); - this.calculatedSceneCenter.copy(avgCenter); - this.material.uniforms.sceneCenter.value.copy(this.calculatedSceneCenter); - this.material.uniformsNeedUpdate = true; - } - - const startSplatFormMaxDistanceCalc = sinceLastBuildOnly ? this.lastBuildSplatCount : 0; - for (let i = startSplatFormMaxDistanceCalc; i < splatCount; i++) { - this.getSplatCenter(i, tempCenter, true); - const distFromCSceneCenter = tempCenter.sub(this.calculatedSceneCenter).length(); - if (distFromCSceneCenter > this.maxSplatDistanceFromSceneCenter) this.maxSplatDistanceFromSceneCenter = distFromCSceneCenter; - } - - if (this.maxSplatDistanceFromSceneCenter - this.visibleRegionBufferRadius > VISIBLE_REGION_EXPANSION_DELTA) { - this.visibleRegionBufferRadius = this.maxSplatDistanceFromSceneCenter; - this.visibleRegionRadius = Math.max(this.visibleRegionBufferRadius - VISIBLE_REGION_EXPANSION_DELTA, 0.0); - } - if (this.finalBuild) this.visibleRegionRadius = this.visibleRegionBufferRadius = this.maxSplatDistanceFromSceneCenter; - this.updateVisibleRegionFadeDistance(); - } - - updateVisibleRegionFadeDistance(sceneRevealMode = SceneRevealMode.Default) { - const fastFadeRate = SCENE_FADEIN_RATE_FAST * this.sceneFadeInRateMultiplier; - const gradualFadeRate = SCENE_FADEIN_RATE_GRADUAL * this.sceneFadeInRateMultiplier; - const defaultFadeInRate = this.finalBuild ? fastFadeRate : gradualFadeRate; - const fadeInRate = sceneRevealMode === SceneRevealMode.Default ? defaultFadeInRate : gradualFadeRate; - this.visibleRegionFadeStartRadius = (this.visibleRegionRadius - this.visibleRegionFadeStartRadius) * - fadeInRate + this.visibleRegionFadeStartRadius; - const fadeInPercentage = (this.visibleRegionBufferRadius > 0) ? - (this.visibleRegionFadeStartRadius / this.visibleRegionBufferRadius) : 0; - const fadeInComplete = fadeInPercentage > 0.99; - const shaderFadeInComplete = (fadeInComplete || sceneRevealMode === SceneRevealMode.Instant) ? 1 : 0; - - this.material.uniforms.visibleRegionFadeStartRadius.value = this.visibleRegionFadeStartRadius; - this.material.uniforms.visibleRegionRadius.value = this.visibleRegionRadius; - this.material.uniforms.firstRenderTime.value = this.firstRenderTime; - this.material.uniforms.currentTime.value = performance.now(); - this.material.uniforms.fadeInComplete.value = shaderFadeInComplete; - this.material.uniformsNeedUpdate = true; - this.visibleRegionChanging = !fadeInComplete; - } - - /** - * Set the indexes of splats that should be rendered; should be sorted in desired render order. - * @param {Uint32Array} globalIndexes Sorted index list of splats to be rendered - * @param {number} renderSplatCount Total number of splats to be rendered. Necessary because we may not want to render - * every splat. - */ - updateRenderIndexes(globalIndexes, renderSplatCount) { - const geometry = this.geometry; - geometry.attributes.splatIndex.set(globalIndexes); - geometry.attributes.splatIndex.needsUpdate = true; - if (renderSplatCount > 0 && this.firstRenderTime === -1) this.firstRenderTime = performance.now(); - geometry.instanceCount = renderSplatCount; - geometry.setDrawRange(0, renderSplatCount); - } - - /** - * Update the transforms for each scene in this splat mesh from their individual components (position, - * quaternion, and scale) - */ - updateTransforms() { - for (let i = 0; i < this.scenes.length; i++) { - const scene = this.getScene(i); - scene.updateTransform(this.dynamicMode); - } - } - - updateUniforms = function() { - - const viewport = new THREE__namespace.Vector2(); - - return function(renderDimensions, cameraFocalLengthX, cameraFocalLengthY, - orthographicMode, orthographicZoom, inverseFocalAdjustment) { - const splatCount = this.getSplatCount(); - if (splatCount > 0) { - viewport.set(renderDimensions.x * this.devicePixelRatio, - renderDimensions.y * this.devicePixelRatio); - this.material.uniforms.viewport.value.copy(viewport); - this.material.uniforms.basisViewport.value.set(1.0 / viewport.x, 1.0 / viewport.y); - this.material.uniforms.focal.value.set(cameraFocalLengthX, cameraFocalLengthY); - this.material.uniforms.orthographicMode.value = orthographicMode ? 1 : 0; - this.material.uniforms.orthoZoom.value = orthographicZoom; - this.material.uniforms.inverseFocalAdjustment.value = inverseFocalAdjustment; - if (this.dynamicMode) { - for (let i = 0; i < this.scenes.length; i++) { - this.material.uniforms.transforms.value[i].copy(this.getScene(i).transform); - } - } - if (this.enableOptionalEffects) { - for (let i = 0; i < this.scenes.length; i++) { - this.material.uniforms.sceneOpacity.value[i] = clamp(this.getScene(i).opacity, 0.0, 1.0); - this.material.uniforms.sceneVisibility.value[i] = this.getScene(i).visible ? 1 : 0; - this.material.uniformsNeedUpdate = true; - } - } - this.material.uniformsNeedUpdate = true; - } - }; - - }(); - - setSplatScale(splatScale = 1) { - this.splatScale = splatScale; - this.material.uniforms.splatScale.value = splatScale; - this.material.uniformsNeedUpdate = true; - } - - getSplatScale() { - return this.splatScale; - } - - setPointCloudModeEnabled(enabled) { - this.pointCloudModeEnabled = enabled; - this.material.uniforms.pointCloudModeEnabled.value = enabled ? 1 : 0; - this.material.uniformsNeedUpdate = true; - } - - getPointCloudModeEnabled() { - return this.pointCloudModeEnabled; - } - - getSplatDataTextures() { - return this.splatDataTextures; - } - - getSplatCount(includeSinceLastBuild = false) { - if (!includeSinceLastBuild) return this.lastBuildSplatCount; - else return SplatMesh.getTotalSplatCountForScenes(this.scenes); - } - - static getTotalSplatCountForScenes(scenes) { - let totalSplatCount = 0; - for (let scene of scenes) { - if (scene && scene.splatBuffer) totalSplatCount += scene.splatBuffer.getSplatCount(); - } - return totalSplatCount; - } - - static getTotalSplatCountForSplatBuffers(splatBuffers) { - let totalSplatCount = 0; - for (let splatBuffer of splatBuffers) totalSplatCount += splatBuffer.getSplatCount(); - return totalSplatCount; - } - - getMaxSplatCount() { - return SplatMesh.getTotalMaxSplatCountForScenes(this.scenes); - } - - static getTotalMaxSplatCountForScenes(scenes) { - let totalSplatCount = 0; - for (let scene of scenes) { - if (scene && scene.splatBuffer) totalSplatCount += scene.splatBuffer.getMaxSplatCount(); - } - return totalSplatCount; - } - - static getTotalMaxSplatCountForSplatBuffers(splatBuffers) { - let totalSplatCount = 0; - for (let splatBuffer of splatBuffers) totalSplatCount += splatBuffer.getMaxSplatCount(); - return totalSplatCount; - } - - disposeDistancesComputationGPUResources() { - - if (!this.renderer) return; - - const gl = this.renderer.getContext(); - - if (this.distancesTransformFeedback.vao) { - gl.deleteVertexArray(this.distancesTransformFeedback.vao); - this.distancesTransformFeedback.vao = null; - } - if (this.distancesTransformFeedback.program) { - gl.deleteProgram(this.distancesTransformFeedback.program); - gl.deleteShader(this.distancesTransformFeedback.vertexShader); - gl.deleteShader(this.distancesTransformFeedback.fragmentShader); - this.distancesTransformFeedback.program = null; - this.distancesTransformFeedback.vertexShader = null; - this.distancesTransformFeedback.fragmentShader = null; - } - this.disposeDistancesComputationGPUBufferResources(); - if (this.distancesTransformFeedback.id) { - gl.deleteTransformFeedback(this.distancesTransformFeedback.id); - this.distancesTransformFeedback.id = null; - } - } - - disposeDistancesComputationGPUBufferResources() { - - if (!this.renderer) return; - - const gl = this.renderer.getContext(); - - if (this.distancesTransformFeedback.centersBuffer) { - this.distancesTransformFeedback.centersBuffer = null; - gl.deleteBuffer(this.distancesTransformFeedback.centersBuffer); - } - if (this.distancesTransformFeedback.outDistancesBuffer) { - gl.deleteBuffer(this.distancesTransformFeedback.outDistancesBuffer); - this.distancesTransformFeedback.outDistancesBuffer = null; - } - } - - /** - * Set the Three.js renderer used by this splat mesh - * @param {THREE.WebGLRenderer} renderer Instance of THREE.WebGLRenderer - */ - setRenderer(renderer) { - if (renderer !== this.renderer) { - this.renderer = renderer; - const gl = this.renderer.getContext(); - const extensions = new WebGLExtensions(gl); - const capabilities = new WebGLCapabilities(gl, extensions, {}); - extensions.init(capabilities); - this.webGLUtils = new THREE__namespace.WebGLUtils(gl, extensions, capabilities); - if (this.enableDistancesComputationOnGPU && this.getSplatCount() > 0) { - this.setupDistancesComputationTransformFeedback(); - const { centers, sceneIndexes } = this.getDataForDistancesComputation(0, this.getSplatCount() - 1); - this.refreshGPUBuffersForDistancesComputation(centers, sceneIndexes); - } - } - } - - setupDistancesComputationTransformFeedback = function() { - - let currentMaxSplatCount; - - return function() { - const maxSplatCount = this.getMaxSplatCount(); - - if (!this.renderer) return; - - const rebuildGPUObjects = (this.lastRenderer !== this.renderer); - const rebuildBuffers = currentMaxSplatCount !== maxSplatCount; - - if (!rebuildGPUObjects && !rebuildBuffers) return; - - if (rebuildGPUObjects) { - this.disposeDistancesComputationGPUResources(); - } else if (rebuildBuffers) { - this.disposeDistancesComputationGPUBufferResources(); - } - - const gl = this.renderer.getContext(); - - const createShader = (gl, type, source) => { - const shader = gl.createShader(type); - if (!shader) { - console.error('Fatal error: gl could not create a shader object.'); - return null; - } - - gl.shaderSource(shader, source); - gl.compileShader(shader); - - const compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS); - if (!compiled) { - let typeName = 'unknown'; - if (type === gl.VERTEX_SHADER) typeName = 'vertex shader'; - else if (type === gl.FRAGMENT_SHADER) typeName = 'fragement shader'; - const errors = gl.getShaderInfoLog(shader); - console.error('Failed to compile ' + typeName + ' with these errors:' + errors); - gl.deleteShader(shader); - return null; - } - - return shader; - }; - - let vsSource; - if (this.integerBasedDistancesComputation) { - vsSource = - `#version 300 es - in ivec4 center; - flat out int distance;`; - if (this.dynamicMode) { - vsSource += ` - in uint sceneIndex; - uniform ivec4 transforms[${Constants.MaxScenes}]; - void main(void) { - ivec4 transform = transforms[sceneIndex]; - distance = center.x * transform.x + center.y * transform.y + center.z * transform.z + transform.w * center.w; - } - `; - } else { - vsSource += ` - uniform ivec3 modelViewProj; - void main(void) { - distance = center.x * modelViewProj.x + center.y * modelViewProj.y + center.z * modelViewProj.z; - } - `; - } - } else { - vsSource = - `#version 300 es - in vec4 center; - flat out float distance;`; - if (this.dynamicMode) { - vsSource += ` - in uint sceneIndex; - uniform mat4 transforms[${Constants.MaxScenes}]; - void main(void) { - vec4 transformedCenter = transforms[sceneIndex] * vec4(center.xyz, 1.0); - distance = transformedCenter.z; - } - `; - } else { - vsSource += ` - uniform vec3 modelViewProj; - void main(void) { - distance = center.x * modelViewProj.x + center.y * modelViewProj.y + center.z * modelViewProj.z; - } - `; - } - } - - const fsSource = - `#version 300 es - precision lowp float; - out vec4 fragColor; - void main(){} - `; - - const currentVao = gl.getParameter(gl.VERTEX_ARRAY_BINDING); - const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM); - const currentProgramDeleted = currentProgram ? gl.getProgramParameter(currentProgram, gl.DELETE_STATUS) : false; - - if (rebuildGPUObjects) { - this.distancesTransformFeedback.vao = gl.createVertexArray(); - } - - gl.bindVertexArray(this.distancesTransformFeedback.vao); - - if (rebuildGPUObjects) { - const program = gl.createProgram(); - const vertexShader = createShader(gl, gl.VERTEX_SHADER, vsSource); - const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fsSource); - if (!vertexShader || !fragmentShader) { - throw new Error('Could not compile shaders for distances computation on GPU.'); - } - gl.attachShader(program, vertexShader); - gl.attachShader(program, fragmentShader); - gl.transformFeedbackVaryings(program, ['distance'], gl.SEPARATE_ATTRIBS); - gl.linkProgram(program); - - const linked = gl.getProgramParameter(program, gl.LINK_STATUS); - if (!linked) { - const error = gl.getProgramInfoLog(program); - console.error('Fatal error: Failed to link program: ' + error); - gl.deleteProgram(program); - gl.deleteShader(fragmentShader); - gl.deleteShader(vertexShader); - throw new Error('Could not link shaders for distances computation on GPU.'); - } - - this.distancesTransformFeedback.program = program; - this.distancesTransformFeedback.vertexShader = vertexShader; - this.distancesTransformFeedback.vertexShader = fragmentShader; - } - - gl.useProgram(this.distancesTransformFeedback.program); - - this.distancesTransformFeedback.centersLoc = - gl.getAttribLocation(this.distancesTransformFeedback.program, 'center'); - if (this.dynamicMode) { - this.distancesTransformFeedback.sceneIndexesLoc = - gl.getAttribLocation(this.distancesTransformFeedback.program, 'sceneIndex'); - for (let i = 0; i < this.scenes.length; i++) { - this.distancesTransformFeedback.transformsLocs[i] = - gl.getUniformLocation(this.distancesTransformFeedback.program, `transforms[${i}]`); - } - } else { - this.distancesTransformFeedback.modelViewProjLoc = - gl.getUniformLocation(this.distancesTransformFeedback.program, 'modelViewProj'); - } - - if (rebuildGPUObjects || rebuildBuffers) { - this.distancesTransformFeedback.centersBuffer = gl.createBuffer(); - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.centersBuffer); - gl.enableVertexAttribArray(this.distancesTransformFeedback.centersLoc); - if (this.integerBasedDistancesComputation) { - gl.vertexAttribIPointer(this.distancesTransformFeedback.centersLoc, 4, gl.INT, 0, 0); - } else { - gl.vertexAttribPointer(this.distancesTransformFeedback.centersLoc, 4, gl.FLOAT, false, 0, 0); - } - - if (this.dynamicMode) { - this.distancesTransformFeedback.sceneIndexesBuffer = gl.createBuffer(); - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.sceneIndexesBuffer); - gl.enableVertexAttribArray(this.distancesTransformFeedback.sceneIndexesLoc); - gl.vertexAttribIPointer(this.distancesTransformFeedback.sceneIndexesLoc, 1, gl.UNSIGNED_INT, 0, 0); - } - } - - if (rebuildGPUObjects || rebuildBuffers) { - this.distancesTransformFeedback.outDistancesBuffer = gl.createBuffer(); - } - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.outDistancesBuffer); - gl.bufferData(gl.ARRAY_BUFFER, maxSplatCount * 4, gl.STATIC_READ); - - if (rebuildGPUObjects) { - this.distancesTransformFeedback.id = gl.createTransformFeedback(); - } - gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.distancesTransformFeedback.id); - gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this.distancesTransformFeedback.outDistancesBuffer); - - if (currentProgram && currentProgramDeleted !== true) gl.useProgram(currentProgram); - if (currentVao) gl.bindVertexArray(currentVao); - - this.lastRenderer = this.renderer; - currentMaxSplatCount = maxSplatCount; - }; - - }(); - - /** - * Refresh GPU buffers used for computing splat distances with centers data from the scenes for this mesh. - * @param {boolean} isUpdate Specify whether or not to update the GPU buffer or to initialize & fill - * @param {Array} centers The splat centers data - * @param {number} offsetSplats Offset in the GPU buffer at which to start updating data, specified in splats - */ - updateGPUCentersBufferForDistancesComputation(isUpdate, centers, offsetSplats) { - - if (!this.renderer) return; - - const gl = this.renderer.getContext(); - - const currentVao = gl.getParameter(gl.VERTEX_ARRAY_BINDING); - gl.bindVertexArray(this.distancesTransformFeedback.vao); - - const ArrayType = this.integerBasedDistancesComputation ? Uint32Array : Float32Array; - const attributeBytesPerCenter = 16; - const subBufferOffset = offsetSplats * attributeBytesPerCenter; - - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.centersBuffer); - - if (isUpdate) { - gl.bufferSubData(gl.ARRAY_BUFFER, subBufferOffset, centers); - } else { - const maxArray = new ArrayType(this.getMaxSplatCount() * attributeBytesPerCenter); - maxArray.set(centers); - gl.bufferData(gl.ARRAY_BUFFER, maxArray, gl.STATIC_DRAW); - } - - gl.bindBuffer(gl.ARRAY_BUFFER, null); - - if (currentVao) gl.bindVertexArray(currentVao); - } - - /** - * Refresh GPU buffers used for pre-computing splat distances with centers data from the scenes for this mesh. - * @param {boolean} isUpdate Specify whether or not to update the GPU buffer or to initialize & fill - * @param {Array} sceneIndexes The splat scene indexes - * @param {number} offsetSplats Offset in the GPU buffer at which to start updating data, specified in splats - */ - updateGPUTransformIndexesBufferForDistancesComputation(isUpdate, sceneIndexes, offsetSplats) { - - if (!this.renderer || !this.dynamicMode) return; - - const gl = this.renderer.getContext(); - - const currentVao = gl.getParameter(gl.VERTEX_ARRAY_BINDING); - gl.bindVertexArray(this.distancesTransformFeedback.vao); - - const subBufferOffset = offsetSplats * 4; - - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.sceneIndexesBuffer); - - if (isUpdate) { - gl.bufferSubData(gl.ARRAY_BUFFER, subBufferOffset, sceneIndexes); - } else { - const maxArray = new Uint32Array(this.getMaxSplatCount() * 4); - maxArray.set(sceneIndexes); - gl.bufferData(gl.ARRAY_BUFFER, maxArray, gl.STATIC_DRAW); - } - gl.bindBuffer(gl.ARRAY_BUFFER, null); - - if (currentVao) gl.bindVertexArray(currentVao); - } - - /** - * Get a typed array containing a mapping from global splat indexes to their scene index. - * @param {number} start Starting splat index to store - * @param {number} end Ending splat index to store - * @return {Uint32Array} - */ - getSceneIndexes(start, end) { - - let sceneIndexes; - const fillCount = end - start + 1; - sceneIndexes = new Uint32Array(fillCount); - for (let i = start; i <= end; i++) { - sceneIndexes[i] = this.globalSplatIndexToSceneIndexMap[i]; - } - - return sceneIndexes; - } - - /** - * Fill 'array' with the transforms for each scene in this splat mesh. - * @param {Array} array Empty array to be filled with scene transforms. If not empty, contents will be overwritten. - */ - fillTransformsArray = function() { - - const tempArray = []; - - return function(array) { - if (tempArray.length !== array.length) tempArray.length = array.length; - for (let i = 0; i < this.scenes.length; i++) { - const sceneTransform = this.getScene(i).transform; - const sceneTransformElements = sceneTransform.elements; - for (let j = 0; j < 16; j++) { - tempArray[i * 16 + j] = sceneTransformElements[j]; - } - } - array.set(tempArray); - }; - - }(); - - computeDistancesOnGPU = function() { - - const tempMatrix = new THREE__namespace.Matrix4(); - - return function(modelViewProjMatrix, outComputedDistances) { - if (!this.renderer) return; - - // console.time("gpu_compute_distances"); - const gl = this.renderer.getContext(); - - const currentVao = gl.getParameter(gl.VERTEX_ARRAY_BINDING); - const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM); - const currentProgramDeleted = currentProgram ? gl.getProgramParameter(currentProgram, gl.DELETE_STATUS) : false; - - gl.bindVertexArray(this.distancesTransformFeedback.vao); - gl.useProgram(this.distancesTransformFeedback.program); - - gl.enable(gl.RASTERIZER_DISCARD); - - if (this.dynamicMode) { - for (let i = 0; i < this.scenes.length; i++) { - tempMatrix.copy(this.getScene(i).transform); - tempMatrix.premultiply(modelViewProjMatrix); - - if (this.integerBasedDistancesComputation) { - const iTempMatrix = SplatMesh.getIntegerMatrixArray(tempMatrix); - const iTransform = [iTempMatrix[2], iTempMatrix[6], iTempMatrix[10], iTempMatrix[14]]; - gl.uniform4i(this.distancesTransformFeedback.transformsLocs[i], iTransform[0], iTransform[1], - iTransform[2], iTransform[3]); - } else { - gl.uniformMatrix4fv(this.distancesTransformFeedback.transformsLocs[i], false, tempMatrix.elements); - } - } - } else { - if (this.integerBasedDistancesComputation) { - const iViewProjMatrix = SplatMesh.getIntegerMatrixArray(modelViewProjMatrix); - const iViewProj = [iViewProjMatrix[2], iViewProjMatrix[6], iViewProjMatrix[10]]; - gl.uniform3i(this.distancesTransformFeedback.modelViewProjLoc, iViewProj[0], iViewProj[1], iViewProj[2]); - } else { - const viewProj = [modelViewProjMatrix.elements[2], modelViewProjMatrix.elements[6], modelViewProjMatrix.elements[10]]; - gl.uniform3f(this.distancesTransformFeedback.modelViewProjLoc, viewProj[0], viewProj[1], viewProj[2]); - } - } - - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.centersBuffer); - gl.enableVertexAttribArray(this.distancesTransformFeedback.centersLoc); - if (this.integerBasedDistancesComputation) { - gl.vertexAttribIPointer(this.distancesTransformFeedback.centersLoc, 4, gl.INT, 0, 0); - } else { - gl.vertexAttribPointer(this.distancesTransformFeedback.centersLoc, 4, gl.FLOAT, false, 0, 0); - } - - if (this.dynamicMode) { - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.sceneIndexesBuffer); - gl.enableVertexAttribArray(this.distancesTransformFeedback.sceneIndexesLoc); - gl.vertexAttribIPointer(this.distancesTransformFeedback.sceneIndexesLoc, 1, gl.UNSIGNED_INT, 0, 0); - } - - gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.distancesTransformFeedback.id); - gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this.distancesTransformFeedback.outDistancesBuffer); - - gl.beginTransformFeedback(gl.POINTS); - gl.drawArrays(gl.POINTS, 0, this.getSplatCount()); - gl.endTransformFeedback(); - - gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null); - gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null); - - gl.disable(gl.RASTERIZER_DISCARD); - - const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0); - gl.flush(); - - const promise = new Promise((resolve) => { - const checkSync = () => { - if (this.disposed) { - resolve(); - } else { - const timeout = 0; - const bitflags = 0; - const status = gl.clientWaitSync(sync, bitflags, timeout); - switch (status) { - case gl.TIMEOUT_EXPIRED: - this.computeDistancesOnGPUSyncTimeout = setTimeout(checkSync); - return this.computeDistancesOnGPUSyncTimeout; - case gl.WAIT_FAILED: - throw new Error('should never get here'); - default: - this.computeDistancesOnGPUSyncTimeout = null; - gl.deleteSync(sync); - const currentVao = gl.getParameter(gl.VERTEX_ARRAY_BINDING); - gl.bindVertexArray(this.distancesTransformFeedback.vao); - gl.bindBuffer(gl.ARRAY_BUFFER, this.distancesTransformFeedback.outDistancesBuffer); - gl.getBufferSubData(gl.ARRAY_BUFFER, 0, outComputedDistances); - gl.bindBuffer(gl.ARRAY_BUFFER, null); - - if (currentVao) gl.bindVertexArray(currentVao); - - // console.timeEnd("gpu_compute_distances"); - - resolve(); - } - } - }; - this.computeDistancesOnGPUSyncTimeout = setTimeout(checkSync); - }); - - if (currentProgram && currentProgramDeleted !== true) gl.useProgram(currentProgram); - if (currentVao) gl.bindVertexArray(currentVao); - - return promise; - }; - - }(); - - /** - * Given a global splat index, return corresponding local data (splat buffer, index of splat in that splat - * buffer, and the corresponding transform) - * @param {number} globalIndex Global splat index - * @param {object} paramsObj Object in which to store local data - * @param {boolean} returnSceneTransform By default, the transform of the scene to which the splat at 'globalIndex' belongs will be - * returned via the 'sceneTransform' property of 'paramsObj' only if the splat mesh is static. - * If 'returnSceneTransform' is true, the 'sceneTransform' property will always contain the scene - * transform, and if 'returnSceneTransform' is false, the 'sceneTransform' property will always - * be null. - */ - getLocalSplatParameters(globalIndex, paramsObj, returnSceneTransform) { - if (returnSceneTransform === undefined || returnSceneTransform === null) { - returnSceneTransform = this.dynamicMode ? false : true; - } - paramsObj.splatBuffer = this.getSplatBufferForSplat(globalIndex); - paramsObj.localIndex = this.getSplatLocalIndex(globalIndex); - paramsObj.sceneTransform = returnSceneTransform ? this.getSceneTransformForSplat(globalIndex) : null; - } - - /** - * Fill arrays with splat data and apply transforms if appropriate. Each array is optional. - * @param {Float32Array} covariances Target storage for splat covariances - * @param {Float32Array} scales Target storage for splat scales - * @param {Float32Array} rotations Target storage for splat rotations - * @param {Float32Array} centers Target storage for splat centers - * @param {Uint8Array} colors Target storage for splat colors - * @param {Float32Array} sphericalHarmonics Target storage for spherical harmonics - * @param {boolean} applySceneTransform By default, scene transforms are applied to relevant splat data only if the splat mesh is - * static. If 'applySceneTransform' is true, scene transforms will always be applied and if - * it is false, they will never be applied. If undefined, the default behavior will apply. - * @param {number} covarianceCompressionLevel The compression level for covariances in the destination array - * @param {number} sphericalHarmonicsCompressionLevel The compression level for spherical harmonics in the destination array - * @param {number} srcStart The start location from which to pull source data - * @param {number} srcEnd The end location from which to pull source data - * @param {number} destStart The start location from which to write data - */ - fillSplatDataArrays(covariances, scales, rotations, centers, colors, sphericalHarmonics, applySceneTransform, - covarianceCompressionLevel = 0, scaleRotationCompressionLevel = 0, sphericalHarmonicsCompressionLevel = 1, - srcStart, srcEnd, destStart = 0, sceneIndex) { - const scaleOverride = new THREE__namespace.Vector3(); - scaleOverride.x = undefined; - scaleOverride.y = undefined; - if (this.splatRenderMode === SplatRenderMode.ThreeD) { - scaleOverride.z = undefined; - } else { - scaleOverride.z = 1; - } - const tempTransform = new THREE__namespace.Matrix4(); - - let startSceneIndex = 0; - let endSceneIndex = this.scenes.length - 1; - if (sceneIndex !== undefined && sceneIndex !== null && sceneIndex >= 0 && sceneIndex <= this.scenes.length) { - startSceneIndex = sceneIndex; - endSceneIndex = sceneIndex; - } - for (let i = startSceneIndex; i <= endSceneIndex; i++) { - if (applySceneTransform === undefined || applySceneTransform === null) { - applySceneTransform = this.dynamicMode ? false : true; - } - - const scene = this.getScene(i); - const splatBuffer = scene.splatBuffer; - let sceneTransform; - if (applySceneTransform) { - this.getSceneTransform(i, tempTransform); - sceneTransform = tempTransform; - } - if (covariances) { - splatBuffer.fillSplatCovarianceArray(covariances, sceneTransform, srcStart, srcEnd, destStart, covarianceCompressionLevel); - } - if (scales || rotations) { - if (!scales || !rotations) { - throw new Error('SplatMesh::fillSplatDataArrays() -> "scales" and "rotations" must both be valid.'); - } - splatBuffer.fillSplatScaleRotationArray(scales, rotations, sceneTransform, - srcStart, srcEnd, destStart, scaleRotationCompressionLevel, scaleOverride); - } - if (centers) splatBuffer.fillSplatCenterArray(centers, sceneTransform, srcStart, srcEnd, destStart); - if (colors) splatBuffer.fillSplatColorArray(colors, scene.minimumAlpha, srcStart, srcEnd, destStart); - if (sphericalHarmonics) { - splatBuffer.fillSphericalHarmonicsArray(sphericalHarmonics, this.minSphericalHarmonicsDegree, - sceneTransform, srcStart, srcEnd, destStart, sphericalHarmonicsCompressionLevel); - } - destStart += splatBuffer.getSplatCount(); - } - } - - /** - * Convert splat centers, which are floating point values, to an array of integers and multiply - * each by 1000. Centers will get transformed as appropriate before conversion to integer. - * @param {number} start The index at which to start retrieving data - * @param {number} end The index at which to stop retrieving data - * @param {boolean} padFour Enforce alignment of 4 by inserting a 1 after every 3 values - * @return {Int32Array} - */ - getIntegerCenters(start, end, padFour = false) { - const splatCount = end - start + 1; - const floatCenters = new Float32Array(splatCount * 3); - this.fillSplatDataArrays(null, null, null, floatCenters, null, null, undefined, undefined, undefined, undefined, start); - let intCenters; - let componentCount = padFour ? 4 : 3; - intCenters = new Int32Array(splatCount * componentCount); - for (let i = 0; i < splatCount; i++) { - for (let t = 0; t < 3; t++) { - intCenters[i * componentCount + t] = Math.round(floatCenters[i * 3 + t] * 1000.0); - } - if (padFour) intCenters[i * componentCount + 3] = 1000; - } - return intCenters; - } - - /** - * Returns an array of splat centers, transformed as appropriate, optionally padded. - * @param {number} start The index at which to start retrieving data - * @param {number} end The index at which to stop retrieving data - * @param {boolean} padFour Enforce alignment of 4 by inserting a 1 after every 3 values - * @return {Float32Array} - */ - getFloatCenters(start, end, padFour = false) { - const splatCount = end - start + 1; - const floatCenters = new Float32Array(splatCount * 3); - this.fillSplatDataArrays(null, null, null, floatCenters, null, null, undefined, undefined, undefined, undefined, start); - if (!padFour) return floatCenters; - let paddedFloatCenters = new Float32Array(splatCount * 4); - for (let i = 0; i < splatCount; i++) { - for (let t = 0; t < 3; t++) { - paddedFloatCenters[i * 4 + t] = floatCenters[i * 3 + t]; - } - paddedFloatCenters[i * 4 + 3] = 1.0; - } - return paddedFloatCenters; - } - - /** - * Get the center for a splat, transformed as appropriate. - * @param {number} globalIndex Global index of splat - * @param {THREE.Vector3} outCenter THREE.Vector3 instance in which to store splat center - * @param {boolean} applySceneTransform By default, if the splat mesh is static, the transform of the scene to which the splat at - * 'globalIndex' belongs will be applied to the splat center. If 'applySceneTransform' is true, - * the scene transform will always be applied and if 'applySceneTransform' is false, the - * scene transform will never be applied. If undefined, the default behavior will apply. - */ - getSplatCenter = function() { - - const paramsObj = {}; - - return function(globalIndex, outCenter, applySceneTransform) { - this.getLocalSplatParameters(globalIndex, paramsObj, applySceneTransform); - paramsObj.splatBuffer.getSplatCenter(paramsObj.localIndex, outCenter, paramsObj.sceneTransform); - }; - - }(); - - /** - * Get the scale and rotation for a splat, transformed as appropriate. - * @param {number} globalIndex Global index of splat - * @param {THREE.Vector3} outScale THREE.Vector3 instance in which to store splat scale - * @param {THREE.Quaternion} outRotation THREE.Quaternion instance in which to store splat rotation - * @param {boolean} applySceneTransform By default, if the splat mesh is static, the transform of the scene to which the splat at - * 'globalIndex' belongs will be applied to the splat scale and rotation. If - * 'applySceneTransform' is true, the scene transform will always be applied and if - * 'applySceneTransform' is false, the scene transform will never be applied. If undefined, - * the default behavior will apply. - */ - getSplatScaleAndRotation = function() { - - const paramsObj = {}; - const scaleOverride = new THREE__namespace.Vector3(); - - return function(globalIndex, outScale, outRotation, applySceneTransform) { - this.getLocalSplatParameters(globalIndex, paramsObj, applySceneTransform); - scaleOverride.x = undefined; - scaleOverride.y = undefined; - scaleOverride.z = undefined; - if (this.splatRenderMode === SplatRenderMode.TwoD) scaleOverride.z = 0; - paramsObj.splatBuffer.getSplatScaleAndRotation(paramsObj.localIndex, outScale, outRotation, - paramsObj.sceneTransform, scaleOverride); - }; - - }(); - - /** - * Get the color for a splat. - * @param {number} globalIndex Global index of splat - * @param {THREE.Vector4} outColor THREE.Vector4 instance in which to store splat color - */ - getSplatColor = function() { - - const paramsObj = {}; - - return function(globalIndex, outColor) { - this.getLocalSplatParameters(globalIndex, paramsObj); - paramsObj.splatBuffer.getSplatColor(paramsObj.localIndex, outColor); - }; - - }(); - - /** - * Store the transform of the scene at 'sceneIndex' in 'outTransform'. - * @param {number} sceneIndex Index of the desired scene - * @param {THREE.Matrix4} outTransform Instance of THREE.Matrix4 in which to store the scene's transform - */ - getSceneTransform(sceneIndex, outTransform) { - const scene = this.getScene(sceneIndex); - scene.updateTransform(this.dynamicMode); - outTransform.copy(scene.transform); - } - - /** - * Get the scene at 'sceneIndex'. - * @param {number} sceneIndex Index of the desired scene - * @return {SplatScene} - */ - getScene(sceneIndex) { - if (sceneIndex < 0 || sceneIndex >= this.scenes.length) { - throw new Error('SplatMesh::getScene() -> Invalid scene index.'); - } - return this.scenes[sceneIndex]; - } - - getSceneCount() { - return this.scenes.length; - } - - getSplatBufferForSplat(globalIndex) { - return this.getScene(this.globalSplatIndexToSceneIndexMap[globalIndex]).splatBuffer; - } - - getSceneIndexForSplat(globalIndex) { - return this.globalSplatIndexToSceneIndexMap[globalIndex]; - } - - getSceneTransformForSplat(globalIndex) { - return this.getScene(this.globalSplatIndexToSceneIndexMap[globalIndex]).transform; - } - - getSplatLocalIndex(globalIndex) { - return this.globalSplatIndexToLocalSplatIndexMap[globalIndex]; - } - - static getIntegerMatrixArray(matrix) { - const matrixElements = matrix.elements; - const intMatrixArray = []; - for (let i = 0; i < 16; i++) { - intMatrixArray[i] = Math.round(matrixElements[i] * 1000.0); - } - return intMatrixArray; - } - - computeBoundingBox(applySceneTransforms = false, sceneIndex) { - let splatCount = this.getSplatCount(); - if (sceneIndex !== undefined && sceneIndex !== null) { - if (sceneIndex < 0 || sceneIndex >= this.scenes.length) { - throw new Error('SplatMesh::computeBoundingBox() -> Invalid scene index.'); - } - splatCount = this.scenes[sceneIndex].splatBuffer.getSplatCount(); - } - - const floatCenters = new Float32Array(splatCount * 3); - this.fillSplatDataArrays(null, null, null, floatCenters, null, null, applySceneTransforms, - undefined, undefined, undefined, undefined, sceneIndex); - - const min = new THREE__namespace.Vector3(); - const max = new THREE__namespace.Vector3(); - for (let i = 0; i < splatCount; i++) { - const offset = i * 3; - const x = floatCenters[offset]; - const y = floatCenters[offset + 1]; - const z = floatCenters[offset + 2]; - if (i === 0 || x < min.x) min.x = x; - if (i === 0 || y < min.y) min.y = y; - if (i === 0 || z < min.z) min.z = z; - if (i === 0 || x > max.x) max.x = x; - if (i === 0 || y > max.y) max.y = y; - if (i === 0 || z > max.z) max.z = z; - } - - return new THREE__namespace.Box3(min, max); - } - } - - var SorterWasm = "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"; - - var SorterWasmNoSIMD = "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"; - - var SorterWasmNonShared = "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"; - - var SorterWasmNoSIMDNonShared = "AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAEXAmAAAGAQf39/f39/f39/f39/f39/fwACDwEDZW52Bm1lbW9yeQIAAAMDAgABBz4DEV9fd2FzbV9jYWxsX2N0b3JzAAAYX193YXNtX2FwcGx5X2RhdGFfcmVsb2NzAAALc29ydEluZGV4ZXMAAQqiDwICAAucDwMBfAd9Bn8gCyAKayEMAkACQCAOBEAgDQRAQfj///8HIQpBiICAgHghDSALIAxNDQMgDCEFA0AgAyAFQQJ0IgFqIAIgACABaigCAEECdGooAgAiATYCACABIAogASAKSBshCiABIA0gASANShshDSAFQQFqIgUgC0cNAAsMAwsgDwRAIAsgDE0NAkF/IQ9B+P///wchCkGIgICAeCENIAwhAgNAIA8gByAAIAJBAnQiGmooAgBBAnQiG2ooAgAiDkcEQAJ/IAUqAjgiESAIIA5BBnRqIg8qAjyUIAUqAigiEiAPKgI4lCAFKgIIIhMgDyoCMJQgBSoCGCIUIA8qAjSUkpKSu0QAAAAAAECPQKIiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIRgCfyARIA8qAiyUIBIgDyoCKJQgEyAPKgIglCAUIA8qAiSUkpKSu0QAAAAAAECPQKIiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIRkCfyARIA8qAhyUIBIgDyoCGJQgEyAPKgIQlCAUIA8qAhSUkpKSu0QAAAAAAECPQKIiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIRwCfyARIA8qAgyUIBIgDyoCCJQgEyAPKgIAlCAUIA8qAgSUkpKSu0QAAAAAAECPQKIiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIR0gDiEPCyADIBpqIAEgG0ECdGoiDigCBCAcbCAOKAIAIB1saiAOKAIIIBlsaiAOKAIMIBhsaiIONgIAIA4gCiAKIA5KGyEKIA4gDSANIA5IGyENIAJBAWoiAiALRw0ACwwDCwJ/IAUqAii7RAAAAAAAQI9AoiIQmUQAAAAAAADgQWMEQCAQqgwBC0GAgICAeAshAgJ/IAUqAhi7RAAAAAAAQI9AoiIQmUQAAAAAAADgQWMEQCAQqgwBC0GAgICAeAshByALIAxNAn8gBSoCCLtEAAAAAABAj0CiIhCZRAAAAAAAAOBBYwRAIBCqDAELQYCAgIB4CyEPQfj///8HIQpBiICAgHghDQ0CIAwhBQNAIAMgBUECdCIIaiABIAAgCGooAgBBBHRqIggoAgQgB2wgCCgCACAPbGogCCgCCCACbGoiCDYCACAIIAogCCAKSBshCiAIIA0gCCANShshDSAFQQFqIgUgC0cNAAsMAgsgDQRAQfj///8HIQpBiICAgHghDSALIAxNDQIgDCEFA0AgAyAFQQJ0IgFqAn8gAiAAIAFqKAIAQQJ0aioCALtEAAAAAAAAsECiIhCZRAAAAAAAAOBBYwRAIBCqDAELQYCAgIB4CyIONgIAIAogDiAKIA5IGyEKIA0gDiANIA5KGyENIAVBAWoiBSALRw0ACwwCCyAPRQRAIAsgDE0NASAFKgIoIREgBSoCGCESIAUqAgghE0H4////ByEKQYiAgIB4IQ0gDCEFA0ACfyARIAEgACAFQQJ0IgdqKAIAQQR0aiICKgIIlCATIAIqAgCUIBIgAioCBJSSkrtEAAAAAAAAsECiIhCZRAAAAAAAAOBBYwRAIBCqDAELQYCAgIB4CyEOIAMgB2ogDjYCACAKIA4gCiAOSBshCiANIA4gDSAOShshDSAFQQFqIgUgC0cNAAsMAgsgCyAMTQ0AQX8hD0H4////ByEKQYiAgIB4IQ0gDCECA0AgDyAHIAAgAkECdCIYaigCAEECdCIZaigCACIORwRAIAUqAjgiESAIIA5BBnRqIg8qAjyUIAUqAigiEiAPKgI4lCAFKgIIIhMgDyoCMJQgBSoCGCIUIA8qAjSUkpKSIRUgESAPKgIslCASIA8qAiiUIBMgDyoCIJQgFCAPKgIklJKSkiEWIBEgDyoCHJQgEiAPKgIYlCATIA8qAhCUIBQgDyoCFJSSkpIhFyARIA8qAgyUIBIgDyoCCJQgEyAPKgIAlCAUIA8qAgSUkpKSIREgDiEPCyADIBhqAn8gFSABIBlBAnRqIg4qAgyUIBYgDioCCJQgESAOKgIAlCAXIA4qAgSUkpKSu0QAAAAAAACwQKIiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIg42AgAgCiAOIAogDkgbIQogDSAOIA0gDkobIQ0gAkEBaiICIAtHDQALDAELQYiAgIB4IQ1B+P///wchCgsgCyAMSwRAIAlBAWuzIA2yIAqyk5UhESAMIQ0DQAJ/IBEgAyANQQJ0aiIBKAIAIAprspQiEotDAAAAT10EQCASqAwBC0GAgICAeAshDiABIA42AgAgBCAOQQJ0aiIBIAEoAgBBAWo2AgAgDUEBaiINIAtHDQALCyAJQQJPBEAgBCgCACENQQEhCgNAIAQgCkECdGoiASABKAIAIA1qIg02AgAgCkEBaiIKIAlHDQALCyAMQQBKBEAgDCEKA0AgBiAKQQFrIgFBAnQiAmogACACaigCADYCACAKQQFLIAEhCg0ACwsgCyAMSgRAIAshCgNAIAYgCyAEIAMgCkEBayIKQQJ0IgFqKAIAQQJ0aiICKAIAIgVrQQJ0aiAAIAFqKAIANgIAIAIgBUEBazYCACAKIAxKDQALCws="; - - function sortWorker(self) { - - let wasmInstance; - let wasmMemory; - let useSharedMemory; - let integerBasedSort; - let dynamicMode; - let splatCount; - let indexesToSortOffset; - let sortedIndexesOffset; - let sceneIndexesOffset; - let transformsOffset; - let precomputedDistancesOffset; - let mappedDistancesOffset; - let frequenciesOffset; - let centersOffset; - let modelViewProjOffset; - let countsZero; - let sortedIndexesOut; - let distanceMapRange; - let uploadedSplatCount; - let Constants; - - function sort(splatSortCount, splatRenderCount, modelViewProj, - usePrecomputedDistances, copyIndexesToSort, copyPrecomputedDistances, copyTransforms) { - const sortStartTime = performance.now(); - - if (!useSharedMemory) { - const indexesToSort = new Uint32Array(wasmMemory, indexesToSortOffset, copyIndexesToSort.byteLength / Constants.BytesPerInt); - indexesToSort.set(copyIndexesToSort); - const transforms = new Float32Array(wasmMemory, transformsOffset, copyTransforms.byteLength / Constants.BytesPerFloat); - transforms.set(copyTransforms); - if (usePrecomputedDistances) { - let precomputedDistances; - if (integerBasedSort) { - precomputedDistances = new Int32Array(wasmMemory, precomputedDistancesOffset, - copyPrecomputedDistances.byteLength / Constants.BytesPerInt); - } else { - precomputedDistances = new Float32Array(wasmMemory, precomputedDistancesOffset, - copyPrecomputedDistances.byteLength / Constants.BytesPerFloat); - } - precomputedDistances.set(copyPrecomputedDistances); - } - } - - if (!countsZero) countsZero = new Uint32Array(distanceMapRange); - new Float32Array(wasmMemory, modelViewProjOffset, 16).set(modelViewProj); - new Uint32Array(wasmMemory, frequenciesOffset, distanceMapRange).set(countsZero); - wasmInstance.exports.sortIndexes(indexesToSortOffset, centersOffset, precomputedDistancesOffset, - mappedDistancesOffset, frequenciesOffset, modelViewProjOffset, - sortedIndexesOffset, sceneIndexesOffset, transformsOffset, distanceMapRange, - splatSortCount, splatRenderCount, splatCount, usePrecomputedDistances, integerBasedSort, - dynamicMode); - - const sortMessage = { - 'sortDone': true, - 'splatSortCount': splatSortCount, - 'splatRenderCount': splatRenderCount, - 'sortTime': 0 - }; - if (!useSharedMemory) { - const sortedIndexes = new Uint32Array(wasmMemory, sortedIndexesOffset, splatRenderCount); - if (!sortedIndexesOut || sortedIndexesOut.length < splatRenderCount) { - sortedIndexesOut = new Uint32Array(splatRenderCount); - } - sortedIndexesOut.set(sortedIndexes); - sortMessage.sortedIndexes = sortedIndexesOut; - } - const sortEndTime = performance.now(); - - sortMessage.sortTime = sortEndTime - sortStartTime; - - self.postMessage(sortMessage); - } - - self.onmessage = (e) => { - if (e.data.centers) { - centers = e.data.centers; - sceneIndexes = e.data.sceneIndexes; - if (integerBasedSort) { - new Int32Array(wasmMemory, centersOffset + e.data.range.from * Constants.BytesPerInt * 4, - e.data.range.count * 4).set(new Int32Array(centers)); - } else { - new Float32Array(wasmMemory, centersOffset + e.data.range.from * Constants.BytesPerFloat * 4, - e.data.range.count * 4).set(new Float32Array(centers)); - } - if (dynamicMode) { - new Uint32Array(wasmMemory, sceneIndexesOffset + e.data.range.from * 4, - e.data.range.count).set(new Uint32Array(sceneIndexes)); - } - uploadedSplatCount = e.data.range.from + e.data.range.count; - } else if (e.data.sort) { - const renderCount = Math.min(e.data.sort.splatRenderCount || 0, uploadedSplatCount); - const sortCount = Math.min(e.data.sort.splatSortCount || 0, uploadedSplatCount); - const usePrecomputedDistances = e.data.sort.usePrecomputedDistances; - - let copyIndexesToSort; - let copyPrecomputedDistances; - let copyTransforms; - if (!useSharedMemory) { - copyIndexesToSort = e.data.sort.indexesToSort; - copyTransforms = e.data.sort.transforms; - if (usePrecomputedDistances) copyPrecomputedDistances = e.data.sort.precomputedDistances; - } - sort(sortCount, renderCount, e.data.sort.modelViewProj, usePrecomputedDistances, - copyIndexesToSort, copyPrecomputedDistances, copyTransforms); - } else if (e.data.init) { - // Yep, this is super hacky and gross :( - Constants = e.data.init.Constants; - - splatCount = e.data.init.splatCount; - useSharedMemory = e.data.init.useSharedMemory; - integerBasedSort = e.data.init.integerBasedSort; - dynamicMode = e.data.init.dynamicMode; - distanceMapRange = e.data.init.distanceMapRange; - uploadedSplatCount = 0; - - const CENTERS_BYTES_PER_ENTRY = integerBasedSort ? (Constants.BytesPerInt * 4) : (Constants.BytesPerFloat * 4); - - const sorterWasmBytes = new Uint8Array(e.data.init.sorterWasmBytes); - - const matrixSize = 16 * Constants.BytesPerFloat; - const memoryRequiredForIndexesToSort = splatCount * Constants.BytesPerInt; - const memoryRequiredForCenters = splatCount * CENTERS_BYTES_PER_ENTRY; - const memoryRequiredForModelViewProjectionMatrix = matrixSize; - const memoryRequiredForPrecomputedDistances = integerBasedSort ? - (splatCount * Constants.BytesPerInt) : (splatCount * Constants.BytesPerFloat); - const memoryRequiredForMappedDistances = splatCount * Constants.BytesPerInt; - const memoryRequiredForSortedIndexes = splatCount * Constants.BytesPerInt; - const memoryRequiredForIntermediateSortBuffers = integerBasedSort ? (distanceMapRange * Constants.BytesPerInt * 2) : - (distanceMapRange * Constants.BytesPerFloat * 2); - const memoryRequiredforTransformIndexes = dynamicMode ? (splatCount * Constants.BytesPerInt) : 0; - const memoryRequiredforTransforms = dynamicMode ? (Constants.MaxScenes * matrixSize) : 0; - const extraMemory = Constants.MemoryPageSize * 32; - - const totalRequiredMemory = memoryRequiredForIndexesToSort + - memoryRequiredForCenters + - memoryRequiredForModelViewProjectionMatrix + - memoryRequiredForPrecomputedDistances + - memoryRequiredForMappedDistances + - memoryRequiredForIntermediateSortBuffers + - memoryRequiredForSortedIndexes + - memoryRequiredforTransformIndexes + - memoryRequiredforTransforms + - extraMemory; - const totalPagesRequired = Math.floor(totalRequiredMemory / Constants.MemoryPageSize ) + 1; - const sorterWasmImport = { - module: {}, - env: { - memory: new WebAssembly.Memory({ - initial: totalPagesRequired, - maximum: totalPagesRequired, - shared: true, - }), - } - }; - WebAssembly.compile(sorterWasmBytes) - .then((wasmModule) => { - return WebAssembly.instantiate(wasmModule, sorterWasmImport); - }) - .then((instance) => { - wasmInstance = instance; - indexesToSortOffset = 0; - centersOffset = indexesToSortOffset + memoryRequiredForIndexesToSort; - modelViewProjOffset = centersOffset + memoryRequiredForCenters; - precomputedDistancesOffset = modelViewProjOffset + memoryRequiredForModelViewProjectionMatrix; - mappedDistancesOffset = precomputedDistancesOffset + memoryRequiredForPrecomputedDistances; - frequenciesOffset = mappedDistancesOffset + memoryRequiredForMappedDistances; - sortedIndexesOffset = frequenciesOffset + memoryRequiredForIntermediateSortBuffers; - sceneIndexesOffset = sortedIndexesOffset + memoryRequiredForSortedIndexes; - transformsOffset = sceneIndexesOffset + memoryRequiredforTransformIndexes; - wasmMemory = sorterWasmImport.env.memory.buffer; - if (useSharedMemory) { - self.postMessage({ - 'sortSetupPhase1Complete': true, - 'indexesToSortBuffer': wasmMemory, - 'indexesToSortOffset': indexesToSortOffset, - 'sortedIndexesBuffer': wasmMemory, - 'sortedIndexesOffset': sortedIndexesOffset, - 'precomputedDistancesBuffer': wasmMemory, - 'precomputedDistancesOffset': precomputedDistancesOffset, - 'transformsBuffer': wasmMemory, - 'transformsOffset': transformsOffset - }); - } else { - self.postMessage({ - 'sortSetupPhase1Complete': true - }); - } - }); - } - }; - } - - function createSortWorker(splatCount, useSharedMemory, enableSIMDInSort, integerBasedSort, dynamicMode, - splatSortDistanceMapPrecision = Constants.DefaultSplatSortDistanceMapPrecision) { - const worker = new Worker( - URL.createObjectURL( - new Blob(['(', sortWorker.toString(), ')(self)'], { - type: 'application/javascript', - }), - ), - ); - - let sourceWasm = SorterWasm; - - // iOS makes choosing the right WebAssembly configuration tricky :( - const iOSSemVer = isIOS() ? getIOSSemever() : null; - if (!enableSIMDInSort && !useSharedMemory) { - sourceWasm = SorterWasmNoSIMD; - // Testing on various devices has shown that even when shared memory is disabled, the WASM module with shared - // memory can still be used most of the time -- the exception seems to be iOS devices below 16.4 - if (iOSSemVer && iOSSemVer.major <= 16 && iOSSemVer.minor < 4) { - sourceWasm = SorterWasmNoSIMDNonShared; - } - } else if (!enableSIMDInSort) { - sourceWasm = SorterWasmNoSIMD; - } else if (!useSharedMemory) { - // Same issue with shared memory as above on iOS devices - if (iOSSemVer && iOSSemVer.major <= 16 && iOSSemVer.minor < 4) { - sourceWasm = SorterWasmNonShared; - } - } - - const sorterWasmBinaryString = atob(sourceWasm); - const sorterWasmBytes = new Uint8Array(sorterWasmBinaryString.length); - for (let i = 0; i < sorterWasmBinaryString.length; i++) { - sorterWasmBytes[i] = sorterWasmBinaryString.charCodeAt(i); - } - - worker.postMessage({ - 'init': { - 'sorterWasmBytes': sorterWasmBytes.buffer, - 'splatCount': splatCount, - 'useSharedMemory': useSharedMemory, - 'integerBasedSort': integerBasedSort, - 'dynamicMode': dynamicMode, - 'distanceMapRange': 1 << splatSortDistanceMapPrecision, - // Super hacky - 'Constants': { - 'BytesPerFloat': Constants.BytesPerFloat, - 'BytesPerInt': Constants.BytesPerInt, - 'MemoryPageSize': Constants.MemoryPageSize, - 'MaxScenes': Constants.MaxScenes - } - } - }); - return worker; - } - - const WebXRMode = { - None: 0, - VR: 1, - AR: 2 - }; - - /* - Copyright © 2010-2024 three.js authors & Mark Kellogg - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - */ - - class VRButton { - - static createButton( renderer, sessionInit = {} ) { - - const button = document.createElement( 'button' ); - - function showEnterVR( /* device */ ) { - - let currentSession = null; - - async function onSessionStarted( session ) { - - session.addEventListener( 'end', onSessionEnded ); - - await renderer.xr.setSession( session ); - button.textContent = 'EXIT VR'; - - currentSession = session; - - } - - function onSessionEnded( /* event */ ) { - - currentSession.removeEventListener( 'end', onSessionEnded ); - - button.textContent = 'ENTER VR'; - - currentSession = null; - - } - - // - - button.style.display = ''; - - button.style.cursor = 'pointer'; - button.style.left = 'calc(50% - 50px)'; - button.style.width = '100px'; - - button.textContent = 'ENTER VR'; - - // WebXR's requestReferenceSpace only works if the corresponding feature - // was requested at session creation time. For simplicity, just ask for - // the interesting ones as optional features, but be aware that the - // requestReferenceSpace call will fail if it turns out to be unavailable. - // ('local' is always available for immersive sessions and doesn't need to - // be requested separately.) - - const sessionOptions = { - ...sessionInit, - optionalFeatures: [ - 'local-floor', - 'bounded-floor', - 'layers', - ...( sessionInit.optionalFeatures || [] ) - ], - }; - - button.onmouseenter = function() { - - button.style.opacity = '1.0'; - - }; - - button.onmouseleave = function() { - - button.style.opacity = '0.5'; - - }; - - button.onclick = function() { - - if ( currentSession === null ) { - - navigator.xr.requestSession( 'immersive-vr', sessionOptions ).then( onSessionStarted ); - - } else { - - currentSession.end(); - - if ( navigator.xr.offerSession !== undefined ) { - - navigator.xr.offerSession( 'immersive-vr', sessionOptions ) - .then( onSessionStarted ) - .catch( ( err ) => { - - console.warn( err ); - - } ); - - } - - } - - }; - - if ( navigator.xr.offerSession !== undefined ) { - - navigator.xr.offerSession( 'immersive-vr', sessionOptions ) - .then( onSessionStarted ) - .catch( ( err ) => { - - console.warn( err ); - - } ); - - } - - } - - function disableButton() { - - button.style.display = ''; - - button.style.cursor = 'auto'; - button.style.left = 'calc(50% - 75px)'; - button.style.width = '150px'; - - button.onmouseenter = null; - button.onmouseleave = null; - - button.onclick = null; - - } - - function showWebXRNotFound() { - - disableButton(); - - button.textContent = 'VR NOT SUPPORTED'; - - } - - function showVRNotAllowed( exception ) { - - disableButton(); - - console.warn( 'Exception when trying to call xr.isSessionSupported', exception ); - - button.textContent = 'VR NOT ALLOWED'; - - } - - function stylizeElement( element ) { - - element.style.position = 'absolute'; - element.style.bottom = '20px'; - element.style.padding = '12px 6px'; - element.style.border = '1px solid #fff'; - element.style.borderRadius = '4px'; - element.style.background = 'rgba(0,0,0,0.1)'; - element.style.color = '#fff'; - element.style.font = 'normal 13px sans-serif'; - element.style.textAlign = 'center'; - element.style.opacity = '0.5'; - element.style.outline = 'none'; - element.style.zIndex = '999'; - - } - - if ( 'xr' in navigator ) { - - button.id = 'VRButton'; - button.style.display = 'none'; - - stylizeElement( button ); - - navigator.xr.isSessionSupported( 'immersive-vr' ).then( function( supported ) { - - supported ? showEnterVR() : showWebXRNotFound(); - - if ( supported && VRButton.xrSessionIsGranted ) { - - button.click(); - - } - - } ).catch( showVRNotAllowed ); - - return button; - - } else { - - const message = document.createElement( 'a' ); - - if ( window.isSecureContext === false ) { - - message.href = document.location.href.replace( /^http:/, 'https:' ); - message.innerHTML = 'WEBXR NEEDS HTTPS'; // TODO Improve message - - } else { - - message.href = 'https://immersiveweb.dev/'; - message.innerHTML = 'WEBXR NOT AVAILABLE'; - - } - - message.style.left = 'calc(50% - 90px)'; - message.style.width = '180px'; - message.style.textDecoration = 'none'; - - stylizeElement( message ); - - return message; - - } - - } - - static registerSessionGrantedListener() { - - if ( typeof navigator !== 'undefined' && 'xr' in navigator ) { - - // WebXRViewer (based on Firefox) has a bug where addEventListener - // throws a silent exception and aborts execution entirely. - if ( /WebXRViewer\//i.test( navigator.userAgent ) ) return; - - navigator.xr.addEventListener( 'sessiongranted', () => { - - VRButton.xrSessionIsGranted = true; - - } ); - - } - - } - - } - - VRButton.xrSessionIsGranted = false; - VRButton.registerSessionGrantedListener(); - - /* - Copyright © 2010-2024 three.js authors & Mark Kellogg - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - */ - - class ARButton { - - static createButton( renderer, sessionInit = {} ) { - - const button = document.createElement( 'button' ); - - function showStartAR( /* device */ ) { - - if ( sessionInit.domOverlay === undefined ) { - - const overlay = document.createElement( 'div' ); - overlay.style.display = 'none'; - document.body.appendChild( overlay ); - - const svg = document.createElementNS( 'http://www.w3.org/2000/svg', 'svg' ); - svg.setAttribute( 'width', 38 ); - svg.setAttribute( 'height', 38 ); - svg.style.position = 'absolute'; - svg.style.right = '20px'; - svg.style.top = '20px'; - svg.addEventListener( 'click', function() { - - currentSession.end(); - - } ); - overlay.appendChild( svg ); - - const path = document.createElementNS( 'http://www.w3.org/2000/svg', 'path' ); - path.setAttribute( 'd', 'M 12,12 L 28,28 M 28,12 12,28' ); - path.setAttribute( 'stroke', '#fff' ); - path.setAttribute( 'stroke-width', 2 ); - svg.appendChild( path ); - - if ( sessionInit.optionalFeatures === undefined ) { - - sessionInit.optionalFeatures = []; - - } - - sessionInit.optionalFeatures.push( 'dom-overlay' ); - sessionInit.domOverlay = { root: overlay }; - - } - - // - - let currentSession = null; - - async function onSessionStarted( session ) { - - session.addEventListener( 'end', onSessionEnded ); - - renderer.xr.setReferenceSpaceType( 'local' ); - - await renderer.xr.setSession( session ); - - button.textContent = 'STOP AR'; - sessionInit.domOverlay.root.style.display = ''; - - currentSession = session; - - } - - function onSessionEnded( /* event */ ) { - - currentSession.removeEventListener( 'end', onSessionEnded ); - - button.textContent = 'START AR'; - sessionInit.domOverlay.root.style.display = 'none'; - - currentSession = null; - - } - - // - - button.style.display = ''; - - button.style.cursor = 'pointer'; - button.style.left = 'calc(50% - 50px)'; - button.style.width = '100px'; - - button.textContent = 'START AR'; - - button.onmouseenter = function() { - - button.style.opacity = '1.0'; - - }; - - button.onmouseleave = function() { - - button.style.opacity = '0.5'; - - }; - - button.onclick = function() { - - if ( currentSession === null ) { - - navigator.xr.requestSession( 'immersive-ar', sessionInit ).then( onSessionStarted ); - - } else { - - currentSession.end(); - - if ( navigator.xr.offerSession !== undefined ) { - - navigator.xr.offerSession( 'immersive-ar', sessionInit ) - .then( onSessionStarted ) - .catch( ( err ) => { - - console.warn( err ); - - } ); - - } - - } - - }; - - if ( navigator.xr.offerSession !== undefined ) { - - navigator.xr.offerSession( 'immersive-ar', sessionInit ) - .then( onSessionStarted ) - .catch( ( err ) => { - - console.warn( err ); - - } ); - - } - - } - - function disableButton() { - - button.style.display = ''; - - button.style.cursor = 'auto'; - button.style.left = 'calc(50% - 75px)'; - button.style.width = '150px'; - - button.onmouseenter = null; - button.onmouseleave = null; - - button.onclick = null; - - } - - function showARNotSupported() { - - disableButton(); - - button.textContent = 'AR NOT SUPPORTED'; - - } - - function showARNotAllowed( exception ) { - - disableButton(); - - console.warn( 'Exception when trying to call xr.isSessionSupported', exception ); - - button.textContent = 'AR NOT ALLOWED'; - - } - - function stylizeElement( element ) { - - element.style.position = 'absolute'; - element.style.bottom = '20px'; - element.style.padding = '12px 6px'; - element.style.border = '1px solid #fff'; - element.style.borderRadius = '4px'; - element.style.background = 'rgba(0,0,0,0.1)'; - element.style.color = '#fff'; - element.style.font = 'normal 13px sans-serif'; - element.style.textAlign = 'center'; - element.style.opacity = '0.5'; - element.style.outline = 'none'; - element.style.zIndex = '999'; - - } - - if ( 'xr' in navigator ) { - - button.id = 'ARButton'; - button.style.display = 'none'; - - stylizeElement( button ); - - navigator.xr.isSessionSupported( 'immersive-ar' ).then( function( supported ) { - - supported ? showStartAR() : showARNotSupported(); - - } ).catch( showARNotAllowed ); - - return button; - - } else { - - const message = document.createElement( 'a' ); - - if ( window.isSecureContext === false ) { - - message.href = document.location.href.replace( /^http:/, 'https:' ); - message.innerHTML = 'WEBXR NEEDS HTTPS'; // TODO Improve message - - } else { - - message.href = 'https://immersiveweb.dev/'; - message.innerHTML = 'WEBXR NOT AVAILABLE'; - - } - - message.style.left = 'calc(50% - 90px)'; - message.style.width = '180px'; - message.style.textDecoration = 'none'; - - stylizeElement( message ); - - return message; - - } - - } - - } - - const RenderMode = { - Always: 0, - OnChange: 1, - Never: 2 - }; - - const THREE_CAMERA_FOV = 50; - const MINIMUM_DISTANCE_TO_NEW_FOCAL_POINT = .75; - const MIN_SPLAT_COUNT_TO_SHOW_SPLAT_TREE_LOADING_SPINNER = 1500000; - const FOCUS_MARKER_FADE_IN_SPEED = 10.0; - const FOCUS_MARKER_FADE_OUT_SPEED = 2.5; - const CONSECUTIVE_RENDERED_FRAMES_FOR_FPS_CALCULATION = 60; - - /** - * Viewer: Manages the rendering of splat scenes. Manages an instance of SplatMesh as well as a web worker - * that performs the sort for its splats. - */ - class Viewer { - - constructor(options = {}) { - - // The natural 'up' vector for viewing the scene (only has an effect when used with orbit controls and - // when the viewer uses its own camera). - if (!options.cameraUp) options.cameraUp = [0, 1, 0]; - this.cameraUp = new THREE__namespace.Vector3().fromArray(options.cameraUp); - - // The camera's initial position (only used when the viewer uses its own camera). - if (!options.initialCameraPosition) options.initialCameraPosition = [0, 10, 15]; - this.initialCameraPosition = new THREE__namespace.Vector3().fromArray(options.initialCameraPosition); - - // The initial focal point of the camera and center of the camera's orbit (only used when the viewer uses its own camera). - if (!options.initialCameraLookAt) options.initialCameraLookAt = [0, 0, 0]; - this.initialCameraLookAt = new THREE__namespace.Vector3().fromArray(options.initialCameraLookAt); - - // 'dropInMode' is a flag that is used internally to support the usage of the viewer as a Three.js scene object - this.dropInMode = options.dropInMode || false; - - // If 'selfDrivenMode' is true, the viewer manages its own update/animation loop via requestAnimationFrame() - if (options.selfDrivenMode === undefined || options.selfDrivenMode === null) options.selfDrivenMode = true; - this.selfDrivenMode = options.selfDrivenMode && !this.dropInMode; - this.selfDrivenUpdateFunc = this.selfDrivenUpdate.bind(this); - - // If 'useBuiltInControls' is true, the viewer will create its own instance of OrbitControls and attach to the camera - if (options.useBuiltInControls === undefined) options.useBuiltInControls = true; - this.useBuiltInControls = options.useBuiltInControls; - - // parent element of the Three.js renderer canvas - this.rootElement = options.rootElement; - - // Tells the viewer to pretend the device pixel ratio is 1, which can boost performance on devices where it is larger, - // at a small cost to visual quality - this.ignoreDevicePixelRatio = options.ignoreDevicePixelRatio || false; - this.devicePixelRatio = this.ignoreDevicePixelRatio ? 1 : (window.devicePixelRatio || 1); - - // Tells the viewer to use 16-bit floating point values when storing splat covariance data in textures, instead of 32-bit - this.halfPrecisionCovariancesOnGPU = options.halfPrecisionCovariancesOnGPU || false; - - // If 'threeScene' is valid, it will be rendered by the viewer along with the splat mesh - this.threeScene = options.threeScene; - // Allows for usage of an external Three.js renderer - this.renderer = options.renderer; - // Allows for usage of an external Three.js camera - this.camera = options.camera; - - // If 'gpuAcceleratedSort' is true, a partially GPU-accelerated approach to sorting splats will be used. - // Currently this means pre-computing splat distances from the camera on the GPU - this.gpuAcceleratedSort = options.gpuAcceleratedSort || false; - - // if 'integerBasedSort' is true, the integer version of splat centers as well as other values used to calculate - // splat distances are used instead of the float version. This speeds up computation, but introduces the possibility of - // overflow in larger scenes. - if (options.integerBasedSort === undefined || options.integerBasedSort === null) { - options.integerBasedSort = true; - } - this.integerBasedSort = options.integerBasedSort; - - // If 'sharedMemoryForWorkers' is true, a SharedArrayBuffer will be used to communicate with web workers. This method - // is faster than copying memory to or from web workers, but comes with security implications as outlined here: - // https://web.dev/articles/cross-origin-isolation-guide - // If enabled, it requires specific CORS headers to be present in the response from the server that is sent when - // loading the application. More information is available in the README. - if (options.sharedMemoryForWorkers === undefined || options.sharedMemoryForWorkers === null) options.sharedMemoryForWorkers = true; - this.sharedMemoryForWorkers = options.sharedMemoryForWorkers; - - // if 'dynamicScene' is true, it tells the viewer to assume scene elements are not stationary or that the number of splats in the - // scene may change. This prevents optimizations that depend on a static scene from being made. Additionally, if 'dynamicScene' is - // true it tells the splat mesh to not apply scene tranforms to splat data that is returned by functions like - // SplatMesh.getSplatCenter() by default. - this.dynamicScene = !!options.dynamicScene; - - // When true, will perform additional steps during rendering to address artifacts caused by the rendering of gaussians at a - // substantially different resolution than that at which they were rendered during training. This will only work correctly - // for models that were trained using a process that utilizes this compensation calculation. For more details: - // https://github.com/nerfstudio-project/gsplat/pull/117 - // https://github.com/graphdeco-inria/gaussian-splatting/issues/294#issuecomment-1772688093 - this.antialiased = options.antialiased || false; - - // This constant is added to the projected 2D screen-space splat scales - this.kernel2DSize = (options.kernel2DSize === undefined) ? 0.3 : options.kernel2DSize; - - this.webXRMode = options.webXRMode || WebXRMode.None; - if (this.webXRMode !== WebXRMode.None) { - this.gpuAcceleratedSort = false; - } - this.webXRActive = false; - - this.webXRSessionInit = options.webXRSessionInit || {}; - - // if 'renderMode' is RenderMode.Always, then the viewer will rrender the scene on every update. If it is RenderMode.OnChange, - // it will only render when something in the scene has changed. - this.renderMode = options.renderMode || RenderMode.Always; - - // SceneRevealMode.Default results in a nice, slow fade-in effect for progressively loaded scenes, - // and a fast fade-in for non progressively loaded scenes. - // SceneRevealMode.Gradual will force a slow fade-in for all scenes. - // SceneRevealMode.Instant will force all loaded scene data to be immediately visible. - this.sceneRevealMode = options.sceneRevealMode || SceneRevealMode.Default; - - // Hacky, experimental, non-scientific parameter for tweaking focal length related calculations. For scenes with very - // small gaussians, small details, and small dimensions -- increasing this value can help improve visual quality. - this.focalAdjustment = options.focalAdjustment || 1.0; - - // Specify the maximum screen-space splat size, can help deal with large splats that get too unwieldy - this.maxScreenSpaceSplatSize = options.maxScreenSpaceSplatSize || 1024; - - // The verbosity of console logging - this.logLevel = options.logLevel || LogLevel.None; - - // Degree of spherical harmonics to utilize in rendering splats (assuming the data is present in the splat scene). - // Valid values are 0 - 2. Default value is 0. - this.sphericalHarmonicsDegree = options.sphericalHarmonicsDegree || 0; - - // When true, allows for usage of extra properties and attributes during rendering for effects such as opacity adjustment. - // Default is false for performance reasons. These properties are separate from transform properties (scale, rotation, position) - // that are enabled by the 'dynamicScene' parameter. - this.enableOptionalEffects = options.enableOptionalEffects || false; - - // Enable the usage of SIMD WebAssembly instructions for the splat sort - if (options.enableSIMDInSort === undefined || options.enableSIMDInSort === null) options.enableSIMDInSort = true; - this.enableSIMDInSort = options.enableSIMDInSort; - - // Level to compress non KSPLAT files when loading them for direct rendering - if (options.inMemoryCompressionLevel === undefined || options.inMemoryCompressionLevel === null) { - options.inMemoryCompressionLevel = 0; - } - this.inMemoryCompressionLevel = options.inMemoryCompressionLevel; - - // Reorder splat data in memory after loading is complete to optimize cache utilization. Default is true. - // Does not apply if splat scene is progressively loaded. - if (options.optimizeSplatData === undefined || options.optimizeSplatData === null) { - options.optimizeSplatData = true; - } - this.optimizeSplatData = options.optimizeSplatData; - - // When true, the intermediate splat data that is the result of decompressing splat bufffer(s) and is used to - // populate the data textures will be freed. This will reduces memory usage, but if that data needs to be modified - // it will need to be re-populated from the splat buffer(s). Default is false. - if (options.freeIntermediateSplatData === undefined || options.freeIntermediateSplatData === null) { - options.freeIntermediateSplatData = false; - } - this.freeIntermediateSplatData = options.freeIntermediateSplatData; - - // It appears that for certain iOS versions, special actions need to be taken with the - // usage of SIMD instructions and shared memory - if (isIOS()) { - const semver = getIOSSemever(); - if (semver.major < 17) { - this.enableSIMDInSort = false; - } - if (semver.major < 16) { - this.sharedMemoryForWorkers = false; - } - } - - // Tell the viewer how to render the splats - if (options.splatRenderMode === undefined || options.splatRenderMode === null) { - options.splatRenderMode = SplatRenderMode.ThreeD; - } - this.splatRenderMode = options.splatRenderMode; - - // Customize the speed at which the scene is revealed - this.sceneFadeInRateMultiplier = options.sceneFadeInRateMultiplier || 1.0; - - // Set the range for the depth map for the counting sort used to sort the splats - this.splatSortDistanceMapPrecision = options.splatSortDistanceMapPrecision || Constants.DefaultSplatSortDistanceMapPrecision; - const maxPrecision = this.integerBasedSort ? 20 : 24; - this.splatSortDistanceMapPrecision = clamp(this.splatSortDistanceMapPrecision, 10, maxPrecision); - - this.onSplatMeshChangedCallback = null; - this.createSplatMesh(); - - this.controls = null; - this.perspectiveControls = null; - this.orthographicControls = null; - - this.orthographicCamera = null; - this.perspectiveCamera = null; - - this.showMeshCursor = false; - this.showControlPlane = false; - this.showInfo = false; - - this.sceneHelper = null; - - this.sortWorker = null; - this.sortRunning = false; - this.splatRenderCount = 0; - this.splatSortCount = 0; - this.lastSplatSortCount = 0; - this.sortWorkerIndexesToSort = null; - this.sortWorkerSortedIndexes = null; - this.sortWorkerPrecomputedDistances = null; - this.sortWorkerTransforms = null; - this.preSortMessages = []; - this.runAfterNextSort = []; - - this.selfDrivenModeRunning = false; - this.splatRenderReady = false; - - this.raycaster = new Raycaster(); - - this.infoPanel = null; - - this.startInOrthographicMode = false; - - this.currentFPS = 0; - this.lastSortTime = 0; - this.consecutiveRenderFrames = 0; - - this.previousCameraTarget = new THREE__namespace.Vector3(); - this.nextCameraTarget = new THREE__namespace.Vector3(); - - this.mousePosition = new THREE__namespace.Vector2(); - this.mouseDownPosition = new THREE__namespace.Vector2(); - this.mouseDownTime = null; - - this.resizeObserver = null; - this.mouseMoveListener = null; - this.mouseDownListener = null; - this.mouseUpListener = null; - this.keyDownListener = null; - - this.sortPromise = null; - this.sortPromiseResolver = null; - this.splatSceneDownloadPromises = {}; - this.splatSceneDownloadAndBuildPromise = null; - this.splatSceneRemovalPromise = null; - - this.loadingSpinner = new LoadingSpinner(null, this.rootElement || document.body); - this.loadingSpinner.hide(); - this.loadingProgressBar = new LoadingProgressBar(this.rootElement || document.body); - this.loadingProgressBar.hide(); - this.infoPanel = new InfoPanel(this.rootElement || document.body); - this.infoPanel.hide(); - - this.usingExternalCamera = (this.dropInMode || this.camera) ? true : false; - this.usingExternalRenderer = (this.dropInMode || this.renderer) ? true : false; - - this.initialized = false; - this.disposing = false; - this.disposed = false; - this.disposePromise = null; - if (!this.dropInMode) this.init(); - } - - createSplatMesh() { - this.splatMesh = new SplatMesh(this.splatRenderMode, this.dynamicScene, this.enableOptionalEffects, - this.halfPrecisionCovariancesOnGPU, this.devicePixelRatio, this.gpuAcceleratedSort, - this.integerBasedSort, this.antialiased, this.maxScreenSpaceSplatSize, this.logLevel, - this.sphericalHarmonicsDegree, this.sceneFadeInRateMultiplier, this.kernel2DSize); - this.splatMesh.frustumCulled = false; - if (this.onSplatMeshChangedCallback) this.onSplatMeshChangedCallback(); - } - - init() { - - if (this.initialized) return; - - if (!this.rootElement) { - if (!this.usingExternalRenderer) { - this.rootElement = document.createElement('div'); - this.rootElement.style.width = '100%'; - this.rootElement.style.height = '100%'; - this.rootElement.style.position = 'absolute'; - document.body.appendChild(this.rootElement); - } else { - this.rootElement = this.renderer.domElement || document.body; - } - } - - this.setupCamera(); - this.setupRenderer(); - this.setupWebXR(this.webXRSessionInit); - this.setupControls(); - this.setupEventHandlers(); - - this.threeScene = this.threeScene || new THREE__namespace.Scene(); - this.sceneHelper = new SceneHelper(this.threeScene); - this.sceneHelper.setupMeshCursor(); - this.sceneHelper.setupFocusMarker(); - this.sceneHelper.setupControlPlane(); - - this.loadingProgressBar.setContainer(this.rootElement); - this.loadingSpinner.setContainer(this.rootElement); - this.infoPanel.setContainer(this.rootElement); - - this.initialized = true; - } - - setupCamera() { - if (!this.usingExternalCamera) { - const renderDimensions = new THREE__namespace.Vector2(); - this.getRenderDimensions(renderDimensions); - - this.perspectiveCamera = new THREE__namespace.PerspectiveCamera(THREE_CAMERA_FOV, renderDimensions.x / renderDimensions.y, 0.1, 1000); - this.orthographicCamera = new THREE__namespace.OrthographicCamera(renderDimensions.x / -2, renderDimensions.x / 2, - renderDimensions.y / 2, renderDimensions.y / -2, 0.1, 1000 ); - this.camera = this.startInOrthographicMode ? this.orthographicCamera : this.perspectiveCamera; - this.camera.position.copy(this.initialCameraPosition); - this.camera.up.copy(this.cameraUp).normalize(); - this.camera.lookAt(this.initialCameraLookAt); - } - } - - setupRenderer() { - if (!this.usingExternalRenderer) { - const renderDimensions = new THREE__namespace.Vector2(); - this.getRenderDimensions(renderDimensions); - - this.renderer = new THREE__namespace.WebGLRenderer({ - antialias: false, - precision: 'highp' - }); - this.renderer.setPixelRatio(this.devicePixelRatio); - this.renderer.autoClear = true; - this.renderer.setClearColor(new THREE__namespace.Color( 0x000000 ), 0.0); - this.renderer.setSize(renderDimensions.x, renderDimensions.y); - - this.resizeObserver = new ResizeObserver(() => { - this.getRenderDimensions(renderDimensions); - this.renderer.setSize(renderDimensions.x, renderDimensions.y); - this.forceRenderNextFrame(); - }); - this.resizeObserver.observe(this.rootElement); - this.rootElement.appendChild(this.renderer.domElement); - } - - } - - setupWebXR(webXRSessionInit) { - if (this.webXRMode) { - if (this.webXRMode === WebXRMode.VR) { - this.rootElement.appendChild(VRButton.createButton(this.renderer, webXRSessionInit)); - } else if (this.webXRMode === WebXRMode.AR) { - this.rootElement.appendChild(ARButton.createButton(this.renderer, webXRSessionInit)); - } - this.renderer.xr.addEventListener('sessionstart', (e) => { - this.webXRActive = true; - }); - this.renderer.xr.addEventListener('sessionend', (e) => { - this.webXRActive = false; - }); - this.renderer.xr.enabled = true; - this.camera.position.copy(this.initialCameraPosition); - this.camera.up.copy(this.cameraUp).normalize(); - this.camera.lookAt(this.initialCameraLookAt); - } - } - - setupControls() { - if (this.useBuiltInControls && this.webXRMode === WebXRMode.None) { - if (!this.usingExternalCamera) { - this.perspectiveControls = new OrbitControls(this.perspectiveCamera, this.renderer.domElement); - this.orthographicControls = new OrbitControls(this.orthographicCamera, this.renderer.domElement); - } else { - if (this.camera.isOrthographicCamera) { - this.orthographicControls = new OrbitControls(this.camera, this.renderer.domElement); - } else { - this.perspectiveControls = new OrbitControls(this.camera, this.renderer.domElement); - } - } - for (let controls of [this.orthographicControls, this.perspectiveControls,]) { - if (controls) { - controls.listenToKeyEvents(window); - controls.rotateSpeed = 0.5; - controls.maxPolarAngle = Math.PI * .75; - controls.minPolarAngle = 0.1; - controls.enableDamping = true; - controls.dampingFactor = 0.05; - controls.target.copy(this.initialCameraLookAt); - controls.update(); - } - } - this.controls = this.camera.isOrthographicCamera ? this.orthographicControls : this.perspectiveControls; - this.controls.update(); - } - } - - setupEventHandlers() { - if (this.useBuiltInControls && this.webXRMode === WebXRMode.None) { - this.mouseMoveListener = this.onMouseMove.bind(this); - this.renderer.domElement.addEventListener('pointermove', this.mouseMoveListener, false); - this.mouseDownListener = this.onMouseDown.bind(this); - this.renderer.domElement.addEventListener('pointerdown', this.mouseDownListener, false); - this.mouseUpListener = this.onMouseUp.bind(this); - this.renderer.domElement.addEventListener('pointerup', this.mouseUpListener, false); - this.keyDownListener = this.onKeyDown.bind(this); - window.addEventListener('keydown', this.keyDownListener, false); - } - } - - removeEventHandlers() { - if (this.useBuiltInControls) { - this.renderer.domElement.removeEventListener('pointermove', this.mouseMoveListener); - this.mouseMoveListener = null; - this.renderer.domElement.removeEventListener('pointerdown', this.mouseDownListener); - this.mouseDownListener = null; - this.renderer.domElement.removeEventListener('pointerup', this.mouseUpListener); - this.mouseUpListener = null; - window.removeEventListener('keydown', this.keyDownListener); - this.keyDownListener = null; - } - } - - setRenderMode(renderMode) { - this.renderMode = renderMode; - } - - setActiveSphericalHarmonicsDegrees(activeSphericalHarmonicsDegrees) { - this.splatMesh.material.uniforms.sphericalHarmonicsDegree.value = activeSphericalHarmonicsDegrees; - this.splatMesh.material.uniformsNeedUpdate = true; - } - - onSplatMeshChanged(callback) { - this.onSplatMeshChangedCallback = callback; - } - - onKeyDown = function() { - - const forward = new THREE__namespace.Vector3(); - const tempMatrixLeft = new THREE__namespace.Matrix4(); - const tempMatrixRight = new THREE__namespace.Matrix4(); - - return function(e) { - forward.set(0, 0, -1); - forward.transformDirection(this.camera.matrixWorld); - tempMatrixLeft.makeRotationAxis(forward, Math.PI / 128); - tempMatrixRight.makeRotationAxis(forward, -Math.PI / 128); - switch (e.code) { - case 'KeyG': - this.focalAdjustment += 0.02; - this.forceRenderNextFrame(); - break; - case 'KeyF': - this.focalAdjustment -= 0.02; - this.forceRenderNextFrame(); - break; - case 'ArrowLeft': - this.camera.up.transformDirection(tempMatrixLeft); - break; - case 'ArrowRight': - this.camera.up.transformDirection(tempMatrixRight); - break; - case 'KeyC': - this.showMeshCursor = !this.showMeshCursor; - break; - case 'KeyU': - this.showControlPlane = !this.showControlPlane; - break; - case 'KeyI': - this.showInfo = !this.showInfo; - if (this.showInfo) { - this.infoPanel.show(); - } else { - this.infoPanel.hide(); - } - break; - case 'KeyO': - if (!this.usingExternalCamera) { - this.setOrthographicMode(!this.camera.isOrthographicCamera); - } - break; - case 'KeyP': - if (!this.usingExternalCamera) { - this.splatMesh.setPointCloudModeEnabled(!this.splatMesh.getPointCloudModeEnabled()); - } - break; - case 'Equal': - if (!this.usingExternalCamera) { - this.splatMesh.setSplatScale(this.splatMesh.getSplatScale() + 0.05); - } - break; - case 'Minus': - if (!this.usingExternalCamera) { - this.splatMesh.setSplatScale(Math.max(this.splatMesh.getSplatScale() - 0.05, 0.0)); - } - break; - } - }; - - }(); - - onMouseMove(mouse) { - this.mousePosition.set(mouse.offsetX, mouse.offsetY); - } - - onMouseDown() { - this.mouseDownPosition.copy(this.mousePosition); - this.mouseDownTime = getCurrentTime(); - } - - onMouseUp = function() { - - const clickOffset = new THREE__namespace.Vector2(); - - return function(mouse) { - clickOffset.copy(this.mousePosition).sub(this.mouseDownPosition); - const mouseUpTime = getCurrentTime(); - const wasClick = mouseUpTime - this.mouseDownTime < 0.5 && clickOffset.length() < 2; - if (wasClick) { - this.onMouseClick(mouse); - } - }; - - }(); - - onMouseClick(mouse) { - this.mousePosition.set(mouse.offsetX, mouse.offsetY); - this.checkForFocalPointChange(); - } - - checkForFocalPointChange = function() { - - const renderDimensions = new THREE__namespace.Vector2(); - const toNewFocalPoint = new THREE__namespace.Vector3(); - const outHits = []; - - return function() { - if (!this.transitioningCameraTarget) { - this.getRenderDimensions(renderDimensions); - outHits.length = 0; - this.raycaster.setFromCameraAndScreenPosition(this.camera, this.mousePosition, renderDimensions); - this.raycaster.intersectSplatMesh(this.splatMesh, outHits); - if (outHits.length > 0) { - const hit = outHits[0]; - const intersectionPoint = hit.origin; - toNewFocalPoint.copy(intersectionPoint).sub(this.camera.position); - if (toNewFocalPoint.length() > MINIMUM_DISTANCE_TO_NEW_FOCAL_POINT) { - this.previousCameraTarget.copy(this.controls.target); - this.nextCameraTarget.copy(intersectionPoint); - this.transitioningCameraTarget = true; - this.transitioningCameraTargetStartTime = getCurrentTime(); - } - } - } - }; - - }(); - - getRenderDimensions(outDimensions) { - if (this.rootElement) { - outDimensions.x = this.rootElement.offsetWidth; - outDimensions.y = this.rootElement.offsetHeight; - } else { - this.renderer.getSize(outDimensions); - } - } - - setOrthographicMode(orthographicMode) { - if (orthographicMode === this.camera.isOrthographicCamera) return; - const fromCamera = this.camera; - const toCamera = orthographicMode ? this.orthographicCamera : this.perspectiveCamera; - toCamera.position.copy(fromCamera.position); - toCamera.up.copy(fromCamera.up); - toCamera.rotation.copy(fromCamera.rotation); - toCamera.quaternion.copy(fromCamera.quaternion); - toCamera.matrix.copy(fromCamera.matrix); - this.camera = toCamera; - - if (this.controls) { - - const resetControls = (controls) => { - controls.saveState(); - controls.reset(); - }; - - const fromControls = this.controls; - const toControls = orthographicMode ? this.orthographicControls : this.perspectiveControls; - - resetControls(toControls); - resetControls(fromControls); - - toControls.target.copy(fromControls.target); - if (orthographicMode) { - Viewer.setCameraZoomFromPosition(toCamera, fromCamera, fromControls); - } else { - Viewer.setCameraPositionFromZoom(toCamera, fromCamera, toControls); - } - this.controls = toControls; - this.camera.lookAt(this.controls.target); - } - } - - static setCameraPositionFromZoom = function() { - - const tempVector = new THREE__namespace.Vector3(); - - return function(positionCamera, zoomedCamera, controls) { - const toLookAtDistance = 1 / (zoomedCamera.zoom * 0.001); - tempVector.copy(controls.target).sub(positionCamera.position).normalize().multiplyScalar(toLookAtDistance).negate(); - positionCamera.position.copy(controls.target).add(tempVector); - }; - - }(); - - - static setCameraZoomFromPosition = function() { - - const tempVector = new THREE__namespace.Vector3(); - - return function(zoomCamera, positionZamera, controls) { - const toLookAtDistance = tempVector.copy(controls.target).sub(positionZamera.position).length(); - zoomCamera.zoom = 1 / (toLookAtDistance * .001); - }; - - }(); - - updateSplatMesh = function() { - - const renderDimensions = new THREE__namespace.Vector2(); - - return function() { - if (!this.splatMesh) return; - const splatCount = this.splatMesh.getSplatCount(); - if (splatCount > 0) { - this.splatMesh.updateVisibleRegionFadeDistance(this.sceneRevealMode); - this.splatMesh.updateTransforms(); - this.getRenderDimensions(renderDimensions); - const focalLengthX = this.camera.projectionMatrix.elements[0] * 0.5 * - this.devicePixelRatio * renderDimensions.x; - const focalLengthY = this.camera.projectionMatrix.elements[5] * 0.5 * - this.devicePixelRatio * renderDimensions.y; - - const focalMultiplier = this.camera.isOrthographicCamera ? (1.0 / this.devicePixelRatio) : 1.0; - const focalAdjustment = this.focalAdjustment * focalMultiplier; - const inverseFocalAdjustment = 1.0 / focalAdjustment; - - this.adjustForWebXRStereo(renderDimensions); - this.splatMesh.updateUniforms(renderDimensions, focalLengthX * focalAdjustment, focalLengthY * focalAdjustment, - this.camera.isOrthographicCamera, this.camera.zoom || 1.0, inverseFocalAdjustment); - } - }; - - }(); - - adjustForWebXRStereo(renderDimensions) { - // TODO: Figure out a less hacky way to determine if stereo rendering is active - if (this.camera && this.webXRActive) { - const xrCamera = this.renderer.xr.getCamera(); - const xrCameraProj00 = xrCamera.projectionMatrix.elements[0]; - const cameraProj00 = this.camera.projectionMatrix.elements[0]; - renderDimensions.x *= (cameraProj00 / xrCameraProj00); - } - } - - isLoadingOrUnloading() { - return Object.keys(this.splatSceneDownloadPromises).length > 0 || this.splatSceneDownloadAndBuildPromise !== null || - this.splatSceneRemovalPromise !== null; - } - - isDisposingOrDisposed() { - return this.disposing || this.disposed; - } - - addSplatSceneDownloadPromise(promise) { - this.splatSceneDownloadPromises[promise.id] = promise; - } - - removeSplatSceneDownloadPromise(promise) { - delete this.splatSceneDownloadPromises[promise.id]; - } - - setSplatSceneDownloadAndBuildPromise(promise) { - this.splatSceneDownloadAndBuildPromise = promise; - } - - clearSplatSceneDownloadAndBuildPromise() { - this.splatSceneDownloadAndBuildPromise = null; - } - - /** - * Add a splat scene to the viewer and display any loading UI if appropriate. - * @param {string} path Path to splat scene to be loaded - * @param {object} options { - * - * splatAlphaRemovalThreshold: Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * showLoadingUI: Display a loading spinner while the scene is loading, defaults to true - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * - * onProgress: Function to be called as file data are received, or other processing occurs - * - * headers: Optional HTTP headers to be sent along with splat requests - * } - * @return {AbortablePromise} - */ - addSplatScene(path, options = {}) { - - if (this.isLoadingOrUnloading()) { - throw new Error('Cannot add splat scene while another load or unload is already in progress.'); - } - - if (this.isDisposingOrDisposed()) { - throw new Error('Cannot add splat scene after dispose() is called.'); - } - - if (options.progressiveLoad && this.splatMesh.scenes && this.splatMesh.scenes.length > 0) { - console.log('addSplatScene(): "progressiveLoad" option ignore because there are multiple splat scenes'); - options.progressiveLoad = false; - } - - const format = (options.format !== undefined && options.format !== null) ? options.format : sceneFormatFromPath(path); - const progressiveLoad = Viewer.isProgressivelyLoadable(format) && options.progressiveLoad; - const showLoadingUI = (options.showLoadingUI !== undefined && options.showLoadingUI !== null) ? options.showLoadingUI : true; - - let loadingUITaskId = null; - if (showLoadingUI) { - this.loadingSpinner.removeAllTasks(); - loadingUITaskId = this.loadingSpinner.addTask('Downloading...'); - } - const hideLoadingUI = () => { - this.loadingProgressBar.hide(); - this.loadingSpinner.removeAllTasks(); - }; - - const onProgressUIUpdate = (percentComplete, percentCompleteLabel, loaderStatus) => { - if (showLoadingUI) { - if (loaderStatus === LoaderStatus.Downloading) { - if (percentComplete == 100) { - this.loadingSpinner.setMessageForTask(loadingUITaskId, 'Download complete!'); - } else { - if (progressiveLoad) { - this.loadingSpinner.setMessageForTask(loadingUITaskId, 'Downloading splats...'); - } else { - const suffix = percentCompleteLabel ? `: ${percentCompleteLabel}` : `...`; - this.loadingSpinner.setMessageForTask(loadingUITaskId, `Downloading${suffix}`); - } - } - } else if (loaderStatus === LoaderStatus.Processing) { - this.loadingSpinner.setMessageForTask(loadingUITaskId, 'Processing splats...'); - } - } - }; - - let downloadDone = false; - let downloadedPercentage = 0; - const splatBuffersAddedUIUpdate = (firstBuild, finalBuild) => { - if (showLoadingUI) { - if (firstBuild && progressiveLoad || finalBuild && !progressiveLoad) { - this.loadingSpinner.removeTask(loadingUITaskId); - if (!finalBuild && !downloadDone) this.loadingProgressBar.show(); - } - if (progressiveLoad) { - if (finalBuild) { - downloadDone = true; - this.loadingProgressBar.hide(); - } else { - this.loadingProgressBar.setProgress(downloadedPercentage); - } - } - } - }; - - const onProgress = (percentComplete, percentCompleteLabel, loaderStatus) => { - downloadedPercentage = percentComplete; - onProgressUIUpdate(percentComplete, percentCompleteLabel, loaderStatus); - if (options.onProgress) options.onProgress(percentComplete, percentCompleteLabel, loaderStatus); - }; - - const buildSection = (splatBuffer, firstBuild, finalBuild) => { - if (!progressiveLoad && options.onProgress) options.onProgress(0, '0%', LoaderStatus.Processing); - const addSplatBufferOptions = { - 'rotation': options.rotation || options.orientation, - 'position': options.position, - 'scale': options.scale, - 'splatAlphaRemovalThreshold': options.splatAlphaRemovalThreshold, - }; - return this.addSplatBuffers([splatBuffer], [addSplatBufferOptions], - finalBuild, firstBuild && showLoadingUI, showLoadingUI, - progressiveLoad, progressiveLoad).then(() => { - if (!progressiveLoad && options.onProgress) options.onProgress(100, '100%', LoaderStatus.Processing); - splatBuffersAddedUIUpdate(firstBuild, finalBuild); - }); - }; - - const loadFunc = progressiveLoad ? this.downloadAndBuildSingleSplatSceneProgressiveLoad.bind(this) : - this.downloadAndBuildSingleSplatSceneStandardLoad.bind(this); - return loadFunc(path, format, options.splatAlphaRemovalThreshold, buildSection.bind(this), - onProgress, hideLoadingUI.bind(this), options.headers); - } - - /** - * Download a single splat scene, convert to splat buffer and then rebuild the viewer's splat mesh - * by calling 'buildFunc' -- all before displaying the scene. Also sets/clears relevant instance synchronization objects, - * and calls appropriate functions on success or failure. - * @param {string} path Path to splat scene to be loaded - * @param {SceneFormat} format Format of the splat scene file - * @param {number} splatAlphaRemovalThreshold Ignore any splats with an alpha less than the specified value (valid range: 0 - 255) - * @param {function} buildFunc Function to build the viewer's splat mesh with the downloaded splat buffer - * @param {function} onProgress Function to be called as file data are received, or other processing occurs - * @param {function} onException Function to be called when exception occurs - * @param {object} headers Optional HTTP headers to pass to use for downloading splat scene - * @return {AbortablePromise} - */ - downloadAndBuildSingleSplatSceneStandardLoad(path, format, splatAlphaRemovalThreshold, buildFunc, onProgress, onException, headers) { - - const downloadPromise = this.downloadSplatSceneToSplatBuffer(path, splatAlphaRemovalThreshold, onProgress, false, - undefined, format, headers); - const downloadAndBuildPromise = abortablePromiseWithExtractedComponents(downloadPromise.abortHandler); - - downloadPromise.then((splatBuffer) => { - this.removeSplatSceneDownloadPromise(downloadPromise); - return buildFunc(splatBuffer, true, true).then(() => { - downloadAndBuildPromise.resolve(); - this.clearSplatSceneDownloadAndBuildPromise(); - }); - }) - .catch((e) => { - if (onException) onException(); - this.clearSplatSceneDownloadAndBuildPromise(); - this.removeSplatSceneDownloadPromise(downloadPromise); - downloadAndBuildPromise.reject(this.updateError(e, `Viewer::addSplatScene -> Could not load file ${path}`)); - }); - - this.addSplatSceneDownloadPromise(downloadPromise); - this.setSplatSceneDownloadAndBuildPromise(downloadAndBuildPromise.promise); - - return downloadAndBuildPromise.promise; - } - - /** - * Download a single splat scene and convert to splat buffer in a progressive manner, allowing rendering as the file downloads. - * As each section is downloaded, the viewer's splat mesh is rebuilt by calling 'buildFunc' - * Also sets/clears relevant instance synchronization objects, and calls appropriate functions on success or failure. - * @param {string} path Path to splat scene to be loaded - * @param {SceneFormat} format Format of the splat scene file - * @param {number} splatAlphaRemovalThreshold Ignore any splats with an alpha less than the specified value (valid range: 0 - 255) - * @param {function} buildFunc Function to rebuild the viewer's splat mesh after a new splat buffer section is downloaded - * @param {function} onDownloadProgress Function to be called as file data are received - * @param {function} onDownloadException Function to be called when exception occurs at any point during the full download - * @param {object} headers Optional HTTP headers to pass to use for downloading splat scene - * @return {AbortablePromise} - */ - downloadAndBuildSingleSplatSceneProgressiveLoad(path, format, splatAlphaRemovalThreshold, buildFunc, - onDownloadProgress, onDownloadException, headers) { - let progressiveLoadedSectionBuildCount = 0; - let progressiveLoadedSectionBuilding = false; - const queuedProgressiveLoadSectionBuilds = []; - - const checkAndBuildProgressiveLoadSections = () => { - if (queuedProgressiveLoadSectionBuilds.length > 0 && - !progressiveLoadedSectionBuilding && - !this.isDisposingOrDisposed()) { - progressiveLoadedSectionBuilding = true; - const queuedBuild = queuedProgressiveLoadSectionBuilds.shift(); - buildFunc(queuedBuild.splatBuffer, queuedBuild.firstBuild, queuedBuild.finalBuild) - .then(() => { - progressiveLoadedSectionBuilding = false; - if (queuedBuild.firstBuild) { - progressiveLoadFirstSectionBuildPromise.resolve(); - } else if (queuedBuild.finalBuild) { - splatSceneDownloadAndBuildPromise.resolve(); - this.clearSplatSceneDownloadAndBuildPromise(); - } - if (queuedProgressiveLoadSectionBuilds.length > 0) { - delayedExecute(() => checkAndBuildProgressiveLoadSections()); - } - }); - } - }; - - const onProgressiveLoadSectionProgress = (splatBuffer, finalBuild) => { - if (!this.isDisposingOrDisposed()) { - if (finalBuild || queuedProgressiveLoadSectionBuilds.length === 0 || - splatBuffer.getSplatCount() > queuedProgressiveLoadSectionBuilds[0].splatBuffer.getSplatCount()) { - queuedProgressiveLoadSectionBuilds.push({ - splatBuffer, - firstBuild: progressiveLoadedSectionBuildCount === 0, - finalBuild - }); - progressiveLoadedSectionBuildCount++; - checkAndBuildProgressiveLoadSections(); - } - } - }; - - const splatSceneDownloadPromise = this.downloadSplatSceneToSplatBuffer(path, splatAlphaRemovalThreshold, onDownloadProgress, true, - onProgressiveLoadSectionProgress, format, headers); - - const progressiveLoadFirstSectionBuildPromise = abortablePromiseWithExtractedComponents(splatSceneDownloadPromise.abortHandler); - const splatSceneDownloadAndBuildPromise = abortablePromiseWithExtractedComponents(); - - this.addSplatSceneDownloadPromise(splatSceneDownloadPromise); - this.setSplatSceneDownloadAndBuildPromise(splatSceneDownloadAndBuildPromise.promise); - - splatSceneDownloadPromise.then(() => { - this.removeSplatSceneDownloadPromise(splatSceneDownloadPromise); - }) - .catch((e) => { - this.clearSplatSceneDownloadAndBuildPromise(); - this.removeSplatSceneDownloadPromise(splatSceneDownloadPromise); - const error = this.updateError(e, `Viewer::addSplatScene -> Could not load one or more scenes`); - progressiveLoadFirstSectionBuildPromise.reject(error); - if (onDownloadException) onDownloadException(error); - }); - - return progressiveLoadFirstSectionBuildPromise.promise; - } - - /** - * Add multiple splat scenes to the viewer and display any loading UI if appropriate. - * @param {Array} sceneOptions Array of per-scene options: { - * - * path: Path to splat scene to be loaded - * - * splatAlphaRemovalThreshold: Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * - * headers: Optional HTTP headers to be sent along with splat requests - * - * format (SceneFormat) Optional, the format of the scene data (.ply, .ksplat, .splat). If not present, the - * file extension in 'path' will be used to determine the format (if it is present) - * } - * @param {boolean} showLoadingUI Display a loading spinner while the scene is loading, defaults to true - * @param {function} onProgress Function to be called as file data are received - * @return {AbortablePromise} - */ - addSplatScenes(sceneOptions, showLoadingUI = true, onProgress = undefined) { - - if (this.isLoadingOrUnloading()) { - throw new Error('Cannot add splat scene while another load or unload is already in progress.'); - } - - if (this.isDisposingOrDisposed()) { - throw new Error('Cannot add splat scene after dispose() is called.'); - } - - const fileCount = sceneOptions.length; - const percentComplete = []; - - let loadingUITaskId; - if (showLoadingUI) { - this.loadingSpinner.removeAllTasks(); - loadingUITaskId = this.loadingSpinner.addTask('Downloading...'); - } - - const onLoadProgress = (fileIndex, percent, percentLabel, loaderStatus) => { - percentComplete[fileIndex] = percent; - let totalPercent = 0; - for (let i = 0; i < fileCount; i++) totalPercent += percentComplete[i] || 0; - totalPercent = totalPercent / fileCount; - percentLabel = `${totalPercent.toFixed(2)}%`; - if (showLoadingUI) { - if (loaderStatus === LoaderStatus.Downloading) { - this.loadingSpinner.setMessageForTask(loadingUITaskId, totalPercent == 100 ? - `Download complete!` : `Downloading: ${percentLabel}`); - } - } - if (onProgress) onProgress(totalPercent, percentLabel, loaderStatus); - }; - - const baseDownloadPromises = []; - const nativeDownloadPromises = []; - for (let i = 0; i < sceneOptions.length; i++) { - const options = sceneOptions[i]; - const format = (options.format !== undefined && options.format !== null) ? options.format : sceneFormatFromPath(options.path); - const baseDownloadPromise = this.downloadSplatSceneToSplatBuffer(options.path, options.splatAlphaRemovalThreshold, - onLoadProgress.bind(this, i), false, undefined, - format, options.headers); - baseDownloadPromises.push(baseDownloadPromise); - nativeDownloadPromises.push(baseDownloadPromise.promise); - } - - const downloadAndBuildPromise = new AbortablePromise((resolve, reject) => { - Promise.all(nativeDownloadPromises) - .then((splatBuffers) => { - if (showLoadingUI) this.loadingSpinner.removeTask(loadingUITaskId); - if (onProgress) onProgress(0, '0%', LoaderStatus.Processing); - this.addSplatBuffers(splatBuffers, sceneOptions, true, showLoadingUI, showLoadingUI, false, false).then(() => { - if (onProgress) onProgress(100, '100%', LoaderStatus.Processing); - this.clearSplatSceneDownloadAndBuildPromise(); - resolve(); - }); - }) - .catch((e) => { - if (showLoadingUI) this.loadingSpinner.removeTask(loadingUITaskId); - this.clearSplatSceneDownloadAndBuildPromise(); - reject(this.updateError(e, `Viewer::addSplatScenes -> Could not load one or more splat scenes.`)); - }) - .finally(() => { - this.removeSplatSceneDownloadPromise(downloadAndBuildPromise); - }); - }, (reason) => { - for (let baseDownloadPromise of baseDownloadPromises) { - baseDownloadPromise.abort(reason); - } - }); - this.addSplatSceneDownloadPromise(downloadAndBuildPromise); - this.setSplatSceneDownloadAndBuildPromise(downloadAndBuildPromise); - return downloadAndBuildPromise; - } - - /** - * Download a splat scene and convert to SplatBuffer instance. - * @param {string} path Path to splat scene to be loaded - * @param {number} splatAlphaRemovalThreshold Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * @param {function} onProgress Function to be called as file data are received - * @param {boolean} progressiveBuild Construct file sections into splat buffers as they are downloaded - * @param {function} onSectionBuilt Function to be called when new section is added to the file - * @param {string} format File format of the scene - * @param {object} headers Optional HTTP headers to pass to use for downloading splat scene - * @return {AbortablePromise} - */ - downloadSplatSceneToSplatBuffer(path, splatAlphaRemovalThreshold = 1, onProgress = undefined, - progressiveBuild = false, onSectionBuilt = undefined, format, headers) { - try { - if (format === SceneFormat.Splat || format === SceneFormat.KSplat || format === SceneFormat.Ply) { - const optimizeSplatData = progressiveBuild ? false : this.optimizeSplatData; - if (format === SceneFormat.Splat) { - return SplatLoader.loadFromURL(path, onProgress, progressiveBuild, onSectionBuilt, splatAlphaRemovalThreshold, - this.inMemoryCompressionLevel, optimizeSplatData, headers); - } else if (format === SceneFormat.KSplat) { - return KSplatLoader.loadFromURL(path, onProgress, progressiveBuild, onSectionBuilt, headers); - } else if (format === SceneFormat.Ply) { - return PlyLoader.loadFromURL(path, onProgress, progressiveBuild, onSectionBuilt, splatAlphaRemovalThreshold, - this.inMemoryCompressionLevel, optimizeSplatData, this.sphericalHarmonicsDegree, headers); - } - } else if (format === SceneFormat.Spz) { - return SpzLoader.loadFromURL(path, onProgress, splatAlphaRemovalThreshold, this.inMemoryCompressionLevel, - this.optimizeSplatData, this.sphericalHarmonicsDegree, headers); - } - } catch (e) { - throw this.updateError(e, null); - } - - throw new Error(`Viewer::downloadSplatSceneToSplatBuffer -> File format not supported: ${path}`); - } - - static isProgressivelyLoadable(format) { - return format === SceneFormat.Splat || format === SceneFormat.KSplat || format === SceneFormat.Ply; - } - - /** - * Add one or more instances of SplatBuffer to the SplatMesh instance managed by the viewer and set up the sorting web worker. - * This function will terminate the existing sort worker (if there is one). - */ - addSplatBuffers = function() { - - return function(splatBuffers, splatBufferOptions = [], finalBuild = true, showLoadingUI = true, - showLoadingUIForSplatTreeBuild = true, replaceExisting = false, - enableRenderBeforeFirstSort = false, preserveVisibleRegion = true) { - - if (this.isDisposingOrDisposed()) return Promise.resolve(); - - let splatProcessingTaskId = null; - const removeSplatProcessingTask = () => { - if (splatProcessingTaskId !== null) { - this.loadingSpinner.removeTask(splatProcessingTaskId); - splatProcessingTaskId = null; - } - }; - - this.splatRenderReady = false; - return new Promise((resolve) => { - if (showLoadingUI) { - splatProcessingTaskId = this.loadingSpinner.addTask('Processing splats...'); - } - delayedExecute(() => { - if (this.isDisposingOrDisposed()) { - resolve(); - } else { - const buildResults = this.addSplatBuffersToMesh(splatBuffers, splatBufferOptions, finalBuild, - showLoadingUIForSplatTreeBuild, replaceExisting, - preserveVisibleRegion); - - const maxSplatCount = this.splatMesh.getMaxSplatCount(); - if (this.sortWorker && this.sortWorker.maxSplatCount !== maxSplatCount) this.disposeSortWorker(); - // If we aren't calculating the splat distances from the center on the GPU, the sorting worker needs - // splat centers and transform indexes so that it can calculate those distance values. - if (!this.gpuAcceleratedSort) { - this.preSortMessages.push({ - 'centers': buildResults.centers.buffer, - 'sceneIndexes': buildResults.sceneIndexes.buffer, - 'range': { - 'from': buildResults.from, - 'to': buildResults.to, - 'count': buildResults.count - } - }); - } - const sortWorkerSetupPromise = (!this.sortWorker && maxSplatCount > 0) ? - this.setupSortWorker(this.splatMesh) : Promise.resolve(); - sortWorkerSetupPromise.then(() => { - if (this.isDisposingOrDisposed()) return; - this.runSplatSort(true, true).then((sortRunning) => { - if (!this.sortWorker || !sortRunning) { - this.splatRenderReady = true; - removeSplatProcessingTask(); - resolve(); - } else { - if (enableRenderBeforeFirstSort) { - this.splatRenderReady = true; - } else { - this.runAfterNextSort.push(() => { - this.splatRenderReady = true; - }); - } - this.runAfterNextSort.push(() => { - removeSplatProcessingTask(); - resolve(); - }); - } - }); - }); - } - }, true); - }); - }; - - }(); - - /** - * Add one or more instances of SplatBuffer to the SplatMesh instance managed by the viewer. By default, this function is additive; - * all splat buffers contained by the viewer's splat mesh before calling this function will be preserved. This behavior can be - * changed by passing 'true' for 'replaceExisting'. - * @param {Array} splatBuffers SplatBuffer instances - * @param {Array} splatBufferOptions Array of options objects: { - * - * splatAlphaRemovalThreshold: Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * } - * @param {boolean} finalBuild Will the splat mesh be in its final state after this build? - * @param {boolean} showLoadingUIForSplatTreeBuild Whether or not to show the loading spinner during construction of the splat tree. - * @return {object} Object containing info about the splats that are updated - */ - addSplatBuffersToMesh = function() { - - let splatOptimizingTaskId; - - return function(splatBuffers, splatBufferOptions, finalBuild = true, showLoadingUIForSplatTreeBuild = false, - replaceExisting = false, preserveVisibleRegion = true) { - if (this.isDisposingOrDisposed()) return; - let allSplatBuffers = []; - let allSplatBufferOptions = []; - if (!replaceExisting) { - allSplatBuffers = this.splatMesh.scenes.map((scene) => scene.splatBuffer) || []; - allSplatBufferOptions = this.splatMesh.sceneOptions ? this.splatMesh.sceneOptions.map((sceneOptions) => sceneOptions) : []; - } - allSplatBuffers.push(...splatBuffers); - allSplatBufferOptions.push(...splatBufferOptions); - if (this.renderer) this.splatMesh.setRenderer(this.renderer); - const onSplatTreeIndexesUpload = (finished) => { - if (this.isDisposingOrDisposed()) return; - const splatCount = this.splatMesh.getSplatCount(); - if (showLoadingUIForSplatTreeBuild && splatCount >= MIN_SPLAT_COUNT_TO_SHOW_SPLAT_TREE_LOADING_SPINNER) { - if (!finished && !splatOptimizingTaskId) { - this.loadingSpinner.setMinimized(true, true); - splatOptimizingTaskId = this.loadingSpinner.addTask('Optimizing data structures...'); - } - } - }; - const onSplatTreeReady = (finished) => { - if (this.isDisposingOrDisposed()) return; - if (finished && splatOptimizingTaskId) { - this.loadingSpinner.removeTask(splatOptimizingTaskId); - splatOptimizingTaskId = null; - } - }; - const buildResults = this.splatMesh.build(allSplatBuffers, allSplatBufferOptions, true, finalBuild, onSplatTreeIndexesUpload, - onSplatTreeReady, preserveVisibleRegion); - if (finalBuild && this.freeIntermediateSplatData) this.splatMesh.freeIntermediateSplatData(); - return buildResults; - }; - - }(); - - /** - * Set up the splat sorting web worker. - * @param {SplatMesh} splatMesh SplatMesh instance that contains the splats to be sorted - * @return {Promise} - */ - setupSortWorker(splatMesh) { - if (this.isDisposingOrDisposed()) return; - return new Promise((resolve) => { - const DistancesArrayType = this.integerBasedSort ? Int32Array : Float32Array; - const splatCount = splatMesh.getSplatCount(); - const maxSplatCount = splatMesh.getMaxSplatCount(); - this.sortWorker = createSortWorker(maxSplatCount, this.sharedMemoryForWorkers, this.enableSIMDInSort, - this.integerBasedSort, this.splatMesh.dynamicMode, this.splatSortDistanceMapPrecision); - this.sortWorker.onmessage = (e) => { - if (e.data.sortDone) { - this.sortRunning = false; - if (this.sharedMemoryForWorkers) { - this.splatMesh.updateRenderIndexes(this.sortWorkerSortedIndexes, e.data.splatRenderCount); - } else { - const sortedIndexes = new Uint32Array(e.data.sortedIndexes.buffer, 0, e.data.splatRenderCount); - this.splatMesh.updateRenderIndexes(sortedIndexes, e.data.splatRenderCount); - } - - this.lastSplatSortCount = this.splatSortCount; - - this.lastSortTime = e.data.sortTime; - this.sortPromiseResolver(); - this.sortPromiseResolver = null; - this.forceRenderNextFrame(); - if (this.runAfterNextSort.length > 0) { - this.runAfterNextSort.forEach((func) => { - func(); - }); - this.runAfterNextSort.length = 0; - } - } else if (e.data.sortCanceled) { - this.sortRunning = false; - } else if (e.data.sortSetupPhase1Complete) { - if (this.logLevel >= LogLevel.Info) console.log('Sorting web worker WASM setup complete.'); - if (this.sharedMemoryForWorkers) { - this.sortWorkerSortedIndexes = new Uint32Array(e.data.sortedIndexesBuffer, - e.data.sortedIndexesOffset, maxSplatCount); - this.sortWorkerIndexesToSort = new Uint32Array(e.data.indexesToSortBuffer, - e.data.indexesToSortOffset, maxSplatCount); - this.sortWorkerPrecomputedDistances = new DistancesArrayType(e.data.precomputedDistancesBuffer, - e.data.precomputedDistancesOffset, - maxSplatCount); - this.sortWorkerTransforms = new Float32Array(e.data.transformsBuffer, - e.data.transformsOffset, Constants.MaxScenes * 16); - } else { - this.sortWorkerIndexesToSort = new Uint32Array(maxSplatCount); - this.sortWorkerPrecomputedDistances = new DistancesArrayType(maxSplatCount); - this.sortWorkerTransforms = new Float32Array(Constants.MaxScenes * 16); - } - for (let i = 0; i < splatCount; i++) this.sortWorkerIndexesToSort[i] = i; - this.sortWorker.maxSplatCount = maxSplatCount; - - if (this.logLevel >= LogLevel.Info) { - console.log('Sorting web worker ready.'); - const splatDataTextures = this.splatMesh.getSplatDataTextures(); - const covariancesTextureSize = splatDataTextures.covariances.size; - const centersColorsTextureSize = splatDataTextures.centerColors.size; - console.log('Covariances texture size: ' + covariancesTextureSize.x + ' x ' + covariancesTextureSize.y); - console.log('Centers/colors texture size: ' + centersColorsTextureSize.x + ' x ' + centersColorsTextureSize.y); - } - - resolve(); - } - }; - }); - } - - updateError(error, defaultMessage) { - if (error instanceof AbortedPromiseError) return error; - if (error instanceof DirectLoadError) { - return new Error('File type or server does not support progressive loading.'); - } - return defaultMessage ? new Error(defaultMessage) : error; - } - - disposeSortWorker() { - if (this.sortWorker) this.sortWorker.terminate(); - this.sortWorker = null; - this.sortPromise = null; - if (this.sortPromiseResolver) { - this.sortPromiseResolver(); - this.sortPromiseResolver = null; - } - this.preSortMessages = []; - this.sortRunning = false; - } - - removeSplatScene(indexToRemove, showLoadingUI = true) { - return this.removeSplatScenes([indexToRemove], showLoadingUI); - } - - removeSplatScenes(indexesToRemove, showLoadingUI = true) { - if (this.isLoadingOrUnloading()) { - throw new Error('Cannot remove splat scene while another load or unload is already in progress.'); - } - - if (this.isDisposingOrDisposed()) { - throw new Error('Cannot remove splat scene after dispose() is called.'); - } - - let sortPromise; - - this.splatSceneRemovalPromise = new Promise((resolve, reject) => { - let revmovalTaskId; - - if (showLoadingUI) { - this.loadingSpinner.removeAllTasks(); - this.loadingSpinner.show(); - revmovalTaskId = this.loadingSpinner.addTask('Removing splat scene...'); - } - - const checkAndHideLoadingUI = () => { - if (showLoadingUI) { - this.loadingSpinner.hide(); - this.loadingSpinner.removeTask(revmovalTaskId); - } - }; - - const onDone = (error) => { - checkAndHideLoadingUI(); - this.splatSceneRemovalPromise = null; - if (!error) resolve(); - else reject(error); - }; - - const checkForEarlyExit = () => { - if (this.isDisposingOrDisposed()) { - onDone(); - return true; - } - return false; - }; - - sortPromise = this.sortPromise || Promise.resolve(); - sortPromise.then(() => { - if (checkForEarlyExit()) return; - const savedSplatBuffers = []; - const savedSceneOptions = []; - const savedSceneTransformComponents = []; - for (let i = 0; i < this.splatMesh.scenes.length; i++) { - let shouldRemove = false; - for (let indexToRemove of indexesToRemove) { - if (indexToRemove === i) { - shouldRemove = true; - break; - } - } - if (!shouldRemove) { - const scene = this.splatMesh.scenes[i]; - savedSplatBuffers.push(scene.splatBuffer); - savedSceneOptions.push(this.splatMesh.sceneOptions[i]); - savedSceneTransformComponents.push({ - 'position': scene.position.clone(), - 'quaternion': scene.quaternion.clone(), - 'scale': scene.scale.clone() - }); - } - } - this.disposeSortWorker(); - this.splatMesh.dispose(); - this.sceneRevealMode = SceneRevealMode.Instant; - this.createSplatMesh(); - this.addSplatBuffers(savedSplatBuffers, savedSceneOptions, true, false, true) - .then(() => { - if (checkForEarlyExit()) return; - checkAndHideLoadingUI(); - this.splatMesh.scenes.forEach((scene, index) => { - scene.position.copy(savedSceneTransformComponents[index].position); - scene.quaternion.copy(savedSceneTransformComponents[index].quaternion); - scene.scale.copy(savedSceneTransformComponents[index].scale); - }); - this.splatMesh.updateTransforms(); - this.splatRenderReady = false; - - this.runSplatSort(true) - .then(() => { - if (checkForEarlyExit()) { - this.splatRenderReady = true; - return; - } - sortPromise = this.sortPromise || Promise.resolve(); - sortPromise.then(() => { - this.splatRenderReady = true; - onDone(); - }); - }); - }) - .catch((e) => { - onDone(e); - }); - }); - }); - - return this.splatSceneRemovalPromise; - } - - /** - * Start self-driven mode - */ - start() { - if (this.selfDrivenMode) { - if (this.webXRMode) { - this.renderer.setAnimationLoop(this.selfDrivenUpdateFunc); - } else { - this.requestFrameId = requestAnimationFrame(this.selfDrivenUpdateFunc); - } - this.selfDrivenModeRunning = true; - } else { - throw new Error('Cannot start viewer unless it is in self driven mode.'); - } - } - - /** - * Stop self-driven mode - */ - stop() { - if (this.selfDrivenMode && this.selfDrivenModeRunning) { - if (this.webXRMode) { - this.renderer.setAnimationLoop(null); - } else { - cancelAnimationFrame(this.requestFrameId); - } - this.selfDrivenModeRunning = false; - } - } - - /** - * Dispose of all resources held directly and indirectly by this viewer. - */ - async dispose() { - if (this.isDisposingOrDisposed()) return this.disposePromise; - - let waitPromises = []; - let promisesToAbort = []; - for (let promiseKey in this.splatSceneDownloadPromises) { - if (this.splatSceneDownloadPromises.hasOwnProperty(promiseKey)) { - const downloadPromiseToAbort = this.splatSceneDownloadPromises[promiseKey]; - promisesToAbort.push(downloadPromiseToAbort); - waitPromises.push(downloadPromiseToAbort.promise); - } - } - if (this.sortPromise) { - waitPromises.push(this.sortPromise); - } - - this.disposing = true; - this.disposePromise = Promise.all(waitPromises).finally(() => { - this.stop(); - if (this.orthographicControls) { - this.orthographicControls.dispose(); - this.orthographicControls = null; - } - if (this.perspectiveControls) { - this.perspectiveControls.dispose(); - this.perspectiveControls = null; - } - this.controls = null; - if (this.splatMesh) { - this.splatMesh.dispose(); - this.splatMesh = null; - } - if (this.sceneHelper) { - this.sceneHelper.dispose(); - this.sceneHelper = null; - } - if (this.resizeObserver) { - this.resizeObserver.unobserve(this.rootElement); - this.resizeObserver = null; - } - this.disposeSortWorker(); - this.removeEventHandlers(); - - this.loadingSpinner.removeAllTasks(); - this.loadingSpinner.setContainer(null); - this.loadingProgressBar.hide(); - this.loadingProgressBar.setContainer(null); - this.infoPanel.setContainer(null); - - this.camera = null; - this.threeScene = null; - this.splatRenderReady = false; - this.initialized = false; - if (this.renderer) { - if (!this.usingExternalRenderer) { - this.rootElement.removeChild(this.renderer.domElement); - this.renderer.dispose(); - } - this.renderer = null; - } - - if (!this.usingExternalRenderer) { - document.body.removeChild(this.rootElement); - } - - this.sortWorkerSortedIndexes = null; - this.sortWorkerIndexesToSort = null; - this.sortWorkerPrecomputedDistances = null; - this.sortWorkerTransforms = null; - this.disposed = true; - this.disposing = false; - this.disposePromise = null; - }); - promisesToAbort.forEach((toAbort) => { - toAbort.abort('Scene disposed'); - }); - return this.disposePromise; - } - - selfDrivenUpdate() { - if (this.selfDrivenMode && !this.webXRMode) { - this.requestFrameId = requestAnimationFrame(this.selfDrivenUpdateFunc); - } - this.update(); - if (this.shouldRender()) { - this.render(); - this.consecutiveRenderFrames++; - } else { - this.consecutiveRenderFrames = 0; - } - this.renderNextFrame = false; - } - - forceRenderNextFrame() { - this.renderNextFrame = true; - } - - shouldRender = function() { - - let renderCount = 0; - const lastCameraPosition = new THREE__namespace.Vector3(); - const lastCameraOrientation = new THREE__namespace.Quaternion(); - const changeEpsilon = 0.0001; - - return function() { - if (!this.initialized || !this.splatRenderReady || this.isDisposingOrDisposed()) return false; - - let shouldRender = false; - let cameraChanged = false; - if (this.camera) { - const cp = this.camera.position; - const co = this.camera.quaternion; - cameraChanged = Math.abs(cp.x - lastCameraPosition.x) > changeEpsilon || - Math.abs(cp.y - lastCameraPosition.y) > changeEpsilon || - Math.abs(cp.z - lastCameraPosition.z) > changeEpsilon || - Math.abs(co.x - lastCameraOrientation.x) > changeEpsilon || - Math.abs(co.y - lastCameraOrientation.y) > changeEpsilon || - Math.abs(co.z - lastCameraOrientation.z) > changeEpsilon || - Math.abs(co.w - lastCameraOrientation.w) > changeEpsilon; - } - - shouldRender = this.renderMode !== RenderMode.Never && (renderCount === 0 || this.splatMesh.visibleRegionChanging || - cameraChanged || this.renderMode === RenderMode.Always || this.dynamicMode === true || this.renderNextFrame); - - if (this.camera) { - lastCameraPosition.copy(this.camera.position); - lastCameraOrientation.copy(this.camera.quaternion); - } - - renderCount++; - return shouldRender; - }; - - }(); - - render = function() { - - return function() { - if (!this.initialized || !this.splatRenderReady || this.isDisposingOrDisposed()) return; - - const hasRenderables = (threeScene) => { - for (let child of threeScene.children) { - if (child.visible) return true; - } - return false; - }; - - const savedAuoClear = this.renderer.autoClear; - if (hasRenderables(this.threeScene)) { - this.renderer.render(this.threeScene, this.camera); - this.renderer.autoClear = false; - } - this.renderer.render(this.splatMesh, this.camera); - this.renderer.autoClear = false; - if (this.sceneHelper.getFocusMarkerOpacity() > 0.0) this.renderer.render(this.sceneHelper.focusMarker, this.camera); - if (this.showControlPlane) this.renderer.render(this.sceneHelper.controlPlane, this.camera); - this.renderer.autoClear = savedAuoClear; - }; - - }(); - - update(renderer, camera) { - if (this.dropInMode) this.updateForDropInMode(renderer, camera); - - if (!this.initialized || !this.splatRenderReady || this.isDisposingOrDisposed()) return; - - if (this.controls) { - this.controls.update(); - if (this.camera.isOrthographicCamera && !this.usingExternalCamera) { - Viewer.setCameraPositionFromZoom(this.camera, this.camera, this.controls); - } - } - this.runSplatSort(); - this.updateForRendererSizeChanges(); - this.updateSplatMesh(); - this.updateMeshCursor(); - this.updateFPS(); - this.timingSensitiveUpdates(); - this.updateInfoPanel(); - this.updateControlPlane(); - } - - updateForDropInMode(renderer, camera) { - this.renderer = renderer; - if (this.splatMesh) this.splatMesh.setRenderer(this.renderer); - this.camera = camera; - if (this.controls) this.controls.object = camera; - this.init(); - } - - updateFPS = function() { - - let lastCalcTime = getCurrentTime(); - let frameCount = 0; - - return function() { - if (this.consecutiveRenderFrames > CONSECUTIVE_RENDERED_FRAMES_FOR_FPS_CALCULATION) { - const currentTime = getCurrentTime(); - const calcDelta = currentTime - lastCalcTime; - if (calcDelta >= 1.0) { - this.currentFPS = frameCount; - frameCount = 0; - lastCalcTime = currentTime; - } else { - frameCount++; - } - } else { - this.currentFPS = null; - } - }; - - }(); - - updateForRendererSizeChanges = function() { - - const lastRendererSize = new THREE__namespace.Vector2(); - const currentRendererSize = new THREE__namespace.Vector2(); - let lastCameraOrthographic; - - return function() { - if (!this.usingExternalCamera) { - this.renderer.getSize(currentRendererSize); - if (lastCameraOrthographic === undefined || lastCameraOrthographic !== this.camera.isOrthographicCamera || - currentRendererSize.x !== lastRendererSize.x || currentRendererSize.y !== lastRendererSize.y) { - if (this.camera.isOrthographicCamera) { - this.camera.left = -currentRendererSize.x / 2.0; - this.camera.right = currentRendererSize.x / 2.0; - this.camera.top = currentRendererSize.y / 2.0; - this.camera.bottom = -currentRendererSize.y / 2.0; - } else { - this.camera.aspect = currentRendererSize.x / currentRendererSize.y; - } - this.camera.updateProjectionMatrix(); - lastRendererSize.copy(currentRendererSize); - lastCameraOrthographic = this.camera.isOrthographicCamera; - } - } - }; - - }(); - - timingSensitiveUpdates = function() { - - let lastUpdateTime; - - return function() { - const currentTime = getCurrentTime(); - if (!lastUpdateTime) lastUpdateTime = currentTime; - const timeDelta = currentTime - lastUpdateTime; - - this.updateCameraTransition(currentTime); - this.updateFocusMarker(timeDelta); - - lastUpdateTime = currentTime; - }; - - }(); - - updateCameraTransition = function() { - - let tempCameraTarget = new THREE__namespace.Vector3(); - let toPreviousTarget = new THREE__namespace.Vector3(); - let toNextTarget = new THREE__namespace.Vector3(); - - return function(currentTime) { - if (this.transitioningCameraTarget) { - toPreviousTarget.copy(this.previousCameraTarget).sub(this.camera.position).normalize(); - toNextTarget.copy(this.nextCameraTarget).sub(this.camera.position).normalize(); - const rotationAngle = Math.acos(toPreviousTarget.dot(toNextTarget)); - const rotationSpeed = rotationAngle / (Math.PI / 3) * .65 + .3; - const t = (rotationSpeed / rotationAngle * (currentTime - this.transitioningCameraTargetStartTime)); - tempCameraTarget.copy(this.previousCameraTarget).lerp(this.nextCameraTarget, t); - this.camera.lookAt(tempCameraTarget); - this.controls.target.copy(tempCameraTarget); - if (t >= 1.0) { - this.transitioningCameraTarget = false; - } - } - }; - - }(); - - updateFocusMarker = function() { - - const renderDimensions = new THREE__namespace.Vector2(); - let wasTransitioning = false; - - return function(timeDelta) { - this.getRenderDimensions(renderDimensions); - if (this.transitioningCameraTarget) { - this.sceneHelper.setFocusMarkerVisibility(true); - const currentFocusMarkerOpacity = Math.max(this.sceneHelper.getFocusMarkerOpacity(), 0.0); - let newFocusMarkerOpacity = Math.min(currentFocusMarkerOpacity + FOCUS_MARKER_FADE_IN_SPEED * timeDelta, 1.0); - this.sceneHelper.setFocusMarkerOpacity(newFocusMarkerOpacity); - this.sceneHelper.updateFocusMarker(this.nextCameraTarget, this.camera, renderDimensions); - wasTransitioning = true; - this.forceRenderNextFrame(); - } else { - let currentFocusMarkerOpacity; - if (wasTransitioning) currentFocusMarkerOpacity = 1.0; - else currentFocusMarkerOpacity = Math.min(this.sceneHelper.getFocusMarkerOpacity(), 1.0); - if (currentFocusMarkerOpacity > 0) { - this.sceneHelper.updateFocusMarker(this.nextCameraTarget, this.camera, renderDimensions); - let newFocusMarkerOpacity = Math.max(currentFocusMarkerOpacity - FOCUS_MARKER_FADE_OUT_SPEED * timeDelta, 0.0); - this.sceneHelper.setFocusMarkerOpacity(newFocusMarkerOpacity); - if (newFocusMarkerOpacity === 0.0) this.sceneHelper.setFocusMarkerVisibility(false); - } - if (currentFocusMarkerOpacity > 0.0) this.forceRenderNextFrame(); - wasTransitioning = false; - } - }; - - }(); - - updateMeshCursor = function() { - - const outHits = []; - const renderDimensions = new THREE__namespace.Vector2(); - - return function() { - if (this.showMeshCursor) { - this.forceRenderNextFrame(); - this.getRenderDimensions(renderDimensions); - outHits.length = 0; - this.raycaster.setFromCameraAndScreenPosition(this.camera, this.mousePosition, renderDimensions); - this.raycaster.intersectSplatMesh(this.splatMesh, outHits); - if (outHits.length > 0) { - this.sceneHelper.setMeshCursorVisibility(true); - this.sceneHelper.positionAndOrientMeshCursor(outHits[0].origin, this.camera); - } else { - this.sceneHelper.setMeshCursorVisibility(false); - } - } else { - if (this.sceneHelper.getMeschCursorVisibility()) this.forceRenderNextFrame(); - this.sceneHelper.setMeshCursorVisibility(false); - } - }; - - }(); - - updateInfoPanel = function() { - - const renderDimensions = new THREE__namespace.Vector2(); - - return function() { - if (!this.showInfo) return; - const splatCount = this.splatMesh.getSplatCount(); - this.getRenderDimensions(renderDimensions); - const cameraLookAtPosition = this.controls ? this.controls.target : null; - const meshCursorPosition = this.showMeshCursor ? this.sceneHelper.meshCursor.position : null; - const splatRenderCountPct = splatCount > 0 ? this.splatRenderCount / splatCount * 100 : 0; - this.infoPanel.update(renderDimensions, this.camera.position, cameraLookAtPosition, - this.camera.up, this.camera.isOrthographicCamera, meshCursorPosition, - this.currentFPS || 'N/A', splatCount, this.splatRenderCount, splatRenderCountPct, - this.lastSortTime, this.focalAdjustment, this.splatMesh.getSplatScale(), - this.splatMesh.getPointCloudModeEnabled()); - }; - - }(); - - updateControlPlane() { - if (this.showControlPlane) { - this.sceneHelper.setControlPlaneVisibility(true); - this.sceneHelper.positionAndOrientControlPlane(this.controls.target, this.camera.up); - } else { - this.sceneHelper.setControlPlaneVisibility(false); - } - } - - runSplatSort = function() { - - const mvpMatrix = new THREE__namespace.Matrix4(); - const cameraPositionArray = []; - const lastSortViewDir = new THREE__namespace.Vector3(0, 0, -1); - const sortViewDir = new THREE__namespace.Vector3(0, 0, -1); - const lastSortViewPos = new THREE__namespace.Vector3(); - const sortViewOffset = new THREE__namespace.Vector3(); - const queuedSorts = []; - - const partialSorts = [ - { - 'angleThreshold': 0.55, - 'sortFractions': [0.125, 0.33333, 0.75] - }, - { - 'angleThreshold': 0.65, - 'sortFractions': [0.33333, 0.66667] - }, - { - 'angleThreshold': 0.8, - 'sortFractions': [0.5] - } - ]; - - return function(force = false, forceSortAll = false) { - if (!this.initialized) return Promise.resolve(false); - if (this.sortRunning) return Promise.resolve(true); - if (this.splatMesh.getSplatCount() <= 0) { - this.splatRenderCount = 0; - return Promise.resolve(false); - } - - let angleDiff = 0; - let positionDiff = 0; - let needsRefreshForRotation = false; - let needsRefreshForPosition = false; - - sortViewDir.set(0, 0, -1).applyQuaternion(this.camera.quaternion); - angleDiff = sortViewDir.dot(lastSortViewDir); - positionDiff = sortViewOffset.copy(this.camera.position).sub(lastSortViewPos).length(); - - if (!force) { - if (!this.splatMesh.dynamicMode && queuedSorts.length === 0) { - if (angleDiff <= 0.99) needsRefreshForRotation = true; - if (positionDiff >= 1.0) needsRefreshForPosition = true; - if (!needsRefreshForRotation && !needsRefreshForPosition) return Promise.resolve(false); - } - } - - this.sortRunning = true; - let { splatRenderCount, shouldSortAll } = this.gatherSceneNodesForSort(); - shouldSortAll = shouldSortAll || forceSortAll; - this.splatRenderCount = splatRenderCount; - - mvpMatrix.copy(this.camera.matrixWorld).invert(); - const mvpCamera = this.perspectiveCamera || this.camera; - mvpMatrix.premultiply(mvpCamera.projectionMatrix); - if (!this.splatMesh.dynamicMode) mvpMatrix.multiply(this.splatMesh.matrixWorld); - - let gpuAcceleratedSortPromise = Promise.resolve(true); - if (this.gpuAcceleratedSort && (queuedSorts.length <= 1 || queuedSorts.length % 2 === 0)) { - gpuAcceleratedSortPromise = this.splatMesh.computeDistancesOnGPU(mvpMatrix, this.sortWorkerPrecomputedDistances); - } - - gpuAcceleratedSortPromise.then(() => { - if (queuedSorts.length === 0) { - if (this.splatMesh.dynamicMode || shouldSortAll) { - queuedSorts.push(this.splatRenderCount); - } else { - for (let partialSort of partialSorts) { - if (angleDiff < partialSort.angleThreshold) { - for (let sortFraction of partialSort.sortFractions) { - queuedSorts.push(Math.floor(this.splatRenderCount * sortFraction)); - } - break; - } - } - queuedSorts.push(this.splatRenderCount); - } - } - let sortCount = Math.min(queuedSorts.shift(), this.splatRenderCount); - this.splatSortCount = sortCount; - - cameraPositionArray[0] = this.camera.position.x; - cameraPositionArray[1] = this.camera.position.y; - cameraPositionArray[2] = this.camera.position.z; - - const sortMessage = { - 'modelViewProj': mvpMatrix.elements, - 'cameraPosition': cameraPositionArray, - 'splatRenderCount': this.splatRenderCount, - 'splatSortCount': sortCount, - 'usePrecomputedDistances': this.gpuAcceleratedSort - }; - if (this.splatMesh.dynamicMode) { - this.splatMesh.fillTransformsArray(this.sortWorkerTransforms); - } - if (!this.sharedMemoryForWorkers) { - sortMessage.indexesToSort = this.sortWorkerIndexesToSort; - sortMessage.transforms = this.sortWorkerTransforms; - if (this.gpuAcceleratedSort) { - sortMessage.precomputedDistances = this.sortWorkerPrecomputedDistances; - } - } - - this.sortPromise = new Promise((resolve) => { - this.sortPromiseResolver = resolve; - }); - - if (this.preSortMessages.length > 0) { - this.preSortMessages.forEach((message) => { - this.sortWorker.postMessage(message); - }); - this.preSortMessages = []; - } - this.sortWorker.postMessage({ - 'sort': sortMessage - }); - - if (queuedSorts.length === 0) { - lastSortViewPos.copy(this.camera.position); - lastSortViewDir.copy(sortViewDir); - } - - return true; - }); - - return gpuAcceleratedSortPromise; - }; - - }(); - - /** - * Determine which splats to render by checking which are inside or close to the view frustum - */ - gatherSceneNodesForSort = function() { - - const nodeRenderList = []; - let allSplatsSortBuffer = null; - const tempVectorYZ = new THREE__namespace.Vector3(); - const tempVectorXZ = new THREE__namespace.Vector3(); - const tempVector = new THREE__namespace.Vector3(); - const modelView = new THREE__namespace.Matrix4(); - const baseModelView = new THREE__namespace.Matrix4(); - const sceneTransform = new THREE__namespace.Matrix4(); - const renderDimensions = new THREE__namespace.Vector3(); - const forward = new THREE__namespace.Vector3(0, 0, -1); - - const tempMax = new THREE__namespace.Vector3(); - const nodeSize = (node) => { - return tempMax.copy(node.max).sub(node.min).length(); - }; - - return function(gatherAllNodes = false) { - - this.getRenderDimensions(renderDimensions); - const cameraFocalLength = (renderDimensions.y / 2.0) / Math.tan(this.camera.fov / 2.0 * THREE__namespace.MathUtils.DEG2RAD); - const fovXOver2 = Math.atan(renderDimensions.x / 2.0 / cameraFocalLength); - const fovYOver2 = Math.atan(renderDimensions.y / 2.0 / cameraFocalLength); - const cosFovXOver2 = Math.cos(fovXOver2); - const cosFovYOver2 = Math.cos(fovYOver2); - - const splatTree = this.splatMesh.getSplatTree(); - - if (splatTree) { - baseModelView.copy(this.camera.matrixWorld).invert(); - if (!this.splatMesh.dynamicMode) baseModelView.multiply(this.splatMesh.matrixWorld); - - let nodeRenderCount = 0; - let splatRenderCount = 0; - - for (let s = 0; s < splatTree.subTrees.length; s++) { - const subTree = splatTree.subTrees[s]; - modelView.copy(baseModelView); - if (this.splatMesh.dynamicMode) { - this.splatMesh.getSceneTransform(s, sceneTransform); - modelView.multiply(sceneTransform); - } - const nodeCount = subTree.nodesWithIndexes.length; - for (let i = 0; i < nodeCount; i++) { - const node = subTree.nodesWithIndexes[i]; - if (!node.data || !node.data.indexes || node.data.indexes.length === 0) continue; - tempVector.copy(node.center).applyMatrix4(modelView); - - const distanceToNode = tempVector.length(); - tempVector.normalize(); - - tempVectorYZ.copy(tempVector).setX(0).normalize(); - tempVectorXZ.copy(tempVector).setY(0).normalize(); - - const cameraAngleXZDot = forward.dot(tempVectorXZ); - const cameraAngleYZDot = forward.dot(tempVectorYZ); - - const ns = nodeSize(node); - const outOfFovY = cameraAngleYZDot < (cosFovYOver2 - .6); - const outOfFovX = cameraAngleXZDot < (cosFovXOver2 - .6); - if (!gatherAllNodes && ((outOfFovX || outOfFovY) && distanceToNode > ns)) { - continue; - } - splatRenderCount += node.data.indexes.length; - nodeRenderList[nodeRenderCount] = node; - node.data.distanceToNode = distanceToNode; - nodeRenderCount++; - } - } - - nodeRenderList.length = nodeRenderCount; - nodeRenderList.sort((a, b) => { - if (a.data.distanceToNode < b.data.distanceToNode) return -1; - else return 1; - }); - - let currentByteOffset = splatRenderCount * Constants.BytesPerInt; - for (let i = 0; i < nodeRenderCount; i++) { - const node = nodeRenderList[i]; - const windowSizeInts = node.data.indexes.length; - const windowSizeBytes = windowSizeInts * Constants.BytesPerInt; - let destView = new Uint32Array(this.sortWorkerIndexesToSort.buffer, - currentByteOffset - windowSizeBytes, windowSizeInts); - destView.set(node.data.indexes); - currentByteOffset -= windowSizeBytes; - } - - return { - 'splatRenderCount': splatRenderCount, - 'shouldSortAll': false - }; - } else { - const totalSplatCount = this.splatMesh.getSplatCount(); - if (!allSplatsSortBuffer || allSplatsSortBuffer.length !== totalSplatCount) { - allSplatsSortBuffer = new Uint32Array(totalSplatCount); - for (let i = 0; i < totalSplatCount; i++) { - allSplatsSortBuffer[i] = i; - } - } - this.sortWorkerIndexesToSort.set(allSplatsSortBuffer); - return { - 'splatRenderCount': totalSplatCount, - 'shouldSortAll': true - }; - } - }; - - }(); - - getSplatMesh() { - return this.splatMesh; - } - - /** - * Get a reference to a splat scene. - * @param {number} sceneIndex The index of the scene to which the reference will be returned - * @return {SplatScene} - */ - getSplatScene(sceneIndex) { - return this.splatMesh.getScene(sceneIndex); - } - - getSceneCount() { - return this.splatMesh.getSceneCount(); - } - - isMobile() { - return navigator.userAgent.includes('Mobi'); - } - } - - /** - * DropInViewer: Wrapper for a Viewer instance that enables it to be added to a Three.js scene like - * any other Three.js scene object (Mesh, Object3D, etc.) - */ - class DropInViewer extends THREE__namespace.Group { - - constructor(options = {}) { - super(); - - options.selfDrivenMode = false; - options.useBuiltInControls = false; - options.rootElement = null; - options.dropInMode = true; - options.camera = undefined; - options.renderer = undefined; - - this.viewer = new Viewer(options); - this.splatMesh = null; - this.updateSplatMesh(); - - this.callbackMesh = DropInViewer.createCallbackMesh(); - this.add(this.callbackMesh); - this.callbackMesh.onBeforeRender = DropInViewer.onBeforeRender.bind(this, this.viewer); - - this.viewer.onSplatMeshChanged(() => { - this.updateSplatMesh(); - }); - - } - - updateSplatMesh() { - if (this.splatMesh !== this.viewer.splatMesh) { - if (this.splatMesh) { - this.remove(this.splatMesh); - } - this.splatMesh = this.viewer.splatMesh; - this.add(this.viewer.splatMesh); - } - } - - /** - * Add a single splat scene to the viewer. - * @param {string} path Path to splat scene to be loaded - * @param {object} options { - * - * splatAlphaRemovalThreshold: Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * showLoadingUI: Display a loading spinner while the scene is loading, defaults to true - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * - * onProgress: Function to be called as file data are received - * - * } - * @return {AbortablePromise} - */ - addSplatScene(path, options = {}) { - if (options.showLoadingUI !== false) options.showLoadingUI = true; - return this.viewer.addSplatScene(path, options); - } - - /** - * Add multiple splat scenes to the viewer. - * @param {Array} sceneOptions Array of per-scene options: { - * - * path: Path to splat scene to be loaded - * - * splatAlphaRemovalThreshold: Ignore any splats with an alpha less than the specified - * value (valid range: 0 - 255), defaults to 1 - * - * position (Array): Position of the scene, acts as an offset from its default position, defaults to [0, 0, 0] - * - * rotation (Array): Rotation of the scene represented as a quaternion, defaults to [0, 0, 0, 1] - * - * scale (Array): Scene's scale, defaults to [1, 1, 1] - * } - * @param {boolean} showLoadingUI Display a loading spinner while the scene is loading, defaults to true - * @return {AbortablePromise} - */ - addSplatScenes(sceneOptions, showLoadingUI) { - if (showLoadingUI !== false) showLoadingUI = true; - return this.viewer.addSplatScenes(sceneOptions, showLoadingUI); - } - - /** - * Get a reference to a splat scene. - * @param {number} sceneIndex The index of the scene to which the reference will be returned - * @return {SplatScene} - */ - getSplatScene(sceneIndex) { - return this.viewer.getSplatScene(sceneIndex); - } - - removeSplatScene(index, showLoadingUI = true) { - return this.viewer.removeSplatScene(index, showLoadingUI); - } - - removeSplatScenes(indexes, showLoadingUI = true) { - return this.viewer.removeSplatScenes(indexes, showLoadingUI); - } - - getSceneCount() { - return this.viewer.getSceneCount(); - } - - setActiveSphericalHarmonicsDegrees(activeSphericalHarmonicsDegrees) { - this.viewer.setActiveSphericalHarmonicsDegrees(activeSphericalHarmonicsDegrees); - } - - async dispose() { - return await this.viewer.dispose(); - } - - static onBeforeRender(viewer, renderer, threeScene, camera) { - viewer.update(renderer, camera); - } - - static createCallbackMesh() { - const geometry = new THREE__namespace.SphereGeometry(1, 8, 8); - const material = new THREE__namespace.MeshBasicMaterial(); - material.colorWrite = false; - material.depthWrite = false; - const mesh = new THREE__namespace.Mesh(geometry, material); - mesh.frustumCulled = false; - return mesh; - } - - } - - exports.AbortablePromise = AbortablePromise; - exports.DropInViewer = DropInViewer; - exports.KSplatLoader = KSplatLoader; - exports.LoaderUtils = Utils; - exports.LogLevel = LogLevel; - exports.OrbitControls = OrbitControls; - exports.PlayCanvasCompressedPlyParser = PlayCanvasCompressedPlyParser; - exports.PlyLoader = PlyLoader; - exports.PlyParser = PlyParser; - exports.RenderMode = RenderMode; - exports.SceneFormat = SceneFormat; - exports.SceneRevealMode = SceneRevealMode; - exports.SplatBuffer = SplatBuffer; - exports.SplatBufferGenerator = SplatBufferGenerator; - exports.SplatLoader = SplatLoader; - exports.SplatParser = SplatParser; - exports.SplatPartitioner = SplatPartitioner; - exports.SplatRenderMode = SplatRenderMode; - exports.SpzLoader = SpzLoader; - exports.Viewer = Viewer; - exports.WebXRMode = WebXRMode; - -})); -//# sourceMappingURL=gaussian-splats-3d.umd.cjs.map diff --git a/web/js/gaussian_preview.js b/web/js/gaussian_preview.js index 427bf68..3dbbf94 100644 --- a/web/js/gaussian_preview.js +++ b/web/js/gaussian_preview.js @@ -208,23 +208,6 @@ app.registerExtension({ pendingRestoreJSON = savedCfg.state; } - // Viewer-only "Use SPZ" preference, persisted to workflow JSON. - // Defaults to true (SPZ is much smaller for the same scene). - this.properties = this.properties || {}; - if (typeof this.properties["Use SPZ"] !== "boolean") { - this.properties["Use SPZ"] = true; - } - const getUseSPZ = () => !!this.properties["Use SPZ"]; - - const sendSettings = () => { - if (!iframe.contentWindow) return; - iframe.contentWindow.postMessage({ - type: "RESTORE_VIEWER_SETTINGS", - settings: { useSPZ: getUseSPZ() }, - }, "*"); - }; - this._sendSettings = sendSettings; - // Iframe-display widget. serialize: false → never lands in // widgets_values; we own persistence via node.properties. const widget = this.addDOMWidget( @@ -264,9 +247,6 @@ app.registerExtension({ // Push any pending saved camera state now that the iframe is alive // (e.g. on workflow reload before the node has been re-queued). sendRestore(); - // Also push the current SPZ toggle state so the checkbox - // reflects the workflow's saved preference. - sendSettings(); }); // Listen for messages from iframe @@ -276,21 +256,6 @@ app.registerExtension({ // node's state. if (event.source !== iframe.contentWindow) return; - // Settings toggle (currently just SPZ compression) from - // iframe → persist on node.properties + re-fetch. - if (event.data?.type === "SETTING_CHANGED" && event.data.key) { - const key = event.data.key; - if (key === "useSPZ") { - node.properties = node.properties || {}; - node.properties["Use SPZ"] = !!event.data.value; - console.log("[TurntableGSViewer] Use SPZ ->", node.properties["Use SPZ"]); - // Re-fetch with the new format if a PLY is loaded. - if (typeof node._reloadSplat === "function") { - node._reloadSplat(); - } - } - return; - } // Camera-state pushes from iframe → persist on // node.properties["Camera Config"] (Load3D pattern). if (event.data?.type === "CAMERA_STATE" && event.data.state) { @@ -418,25 +383,12 @@ app.registerExtension({ `; - // Build a fetch URL based on the current SPZ toggle. - // ON → /turntablegsviewer/spz (lazy server-side transcode + cache) - // OFF → ComfyUI's /view endpoint, raw PLY - // The iframe picks SceneFormat from the extension in - // `filename`, so we also flip that. - const buildFetchPlan = () => { - if (getUseSPZ()) { - return { - url: `/turntablegsviewer/spz?filename=${encodeURIComponent(filename)}&type=output&subfolder=`, - filename: filename.replace(/\.ply$/i, ".spz"), - label: "Compressing / downloading SPZ...", - }; - } - return { - url: `/view?filename=${encodeURIComponent(filename)}&type=output&subfolder=`, - filename: filename, - label: "Downloading PLY...", - }; - }; + // ComfyUI's /view endpoint streams the file LiTo wrote. + // Format choice (PLY / SPZ / compressed.ply) is decided + // at export time inside LiTo — the iframe just gets + // bytes and auto-detects via the renderer. + const filepath = `/view?filename=${encodeURIComponent(filename)}&type=output&subfolder=`; + const loadLabel = "Downloading splat..."; // Function to fetch and send data to iframe const fetchAndSend = async () => { @@ -445,18 +397,19 @@ app.registerExtension({ return; } - const plan = buildFetchPlan(); - const filepath = plan.url; - try { // Fetch the file from parent context (authenticated). - // Stream so we can log download progress (often >200 MB for PLY). + // Stream so we can log download progress. const t0 = performance.now(); console.log("[TurntableGSViewer] fetch start:", filepath); - node._showLoadBar?.(plan.label); + node._showLoadBar?.(loadLabel); const response = await fetch(filepath); if (!response.ok) { - throw new Error(`HTTP ${response.status}: ${response.statusText}`); + // Bubble the server's body up — for /turntablegsviewer/spz + // we put an actionable message there (e.g. "spz not installed"). + let body = ""; + try { body = (await response.text() || "").slice(0, 400); } catch (_) {} + throw new Error(`HTTP ${response.status}: ${response.statusText}${body ? " - " + body : ""}`); } const totalHdr = response.headers.get("content-length"); const total = totalHdr ? parseInt(totalHdr, 10) : 0; @@ -499,15 +452,15 @@ app.registerExtension({ const speed = received > 0 ? (received / (1024*1024)) / (dt / 1000) : 0; console.log(`[TurntableGSViewer] fetch done: ${arrayBuffer.byteLength} bytes in ${dt.toFixed(0)} ms (${speed.toFixed(1)} MB/s)`); - // Send the data to iframe with camera parameters. - // `plan.filename` is `.spz` or `.ply` so the - // adapter can pick SceneFormat. - console.log("[TurntableGSViewer] posting LOAD_MESH_DATA to iframe, renderer:", renderer, "filename:", plan.filename); + // Send the data to iframe — filename carries + // the extension so the renderer can sniff + // format (Spark/PlayCanvas both auto-detect). + console.log("[TurntableGSViewer] posting LOAD_MESH_DATA to iframe, renderer:", renderer, "filename:", filename); node._setLoadProgress?.(100, "Parsing splats..."); iframe.contentWindow.postMessage({ type: "LOAD_MESH_DATA", data: arrayBuffer, - filename: plan.filename, + filename: filename, extrinsics: extrinsics, intrinsics: intrinsics, renderer: renderer, @@ -519,9 +472,6 @@ app.registerExtension({ } }; - // Expose so the SPZ toggle handler can re-fetch. - node._reloadSplat = fetchAndSend; - // Fetch and send when iframe is ready if (iframeLoaded) { fetchAndSend(); diff --git a/web/js/spark.module.min.js b/web/js/spark.module.min.js new file mode 100644 index 0000000..6ad6bad --- /dev/null +++ b/web/js/spark.module.min.js @@ -0,0 +1,16533 @@ +import * as G from "three"; +import { Mesh as Qo, OrthographicCamera as Bo, BufferGeometry as Co, Float32BufferAttribute as tB, Loader as Eo, FileLoader as Do, Quaternion as HB, Vector3 as gI, Color as LB, Matrix4 as hQ } from "three"; +class tQ extends G.InstancedBufferGeometry { + constructor(A, I) { + super(), this.ordering = A, this.setAttribute("position", new G.BufferAttribute(io, 3)), this.setIndex(new G.BufferAttribute(wo, 1)), this._maxInstanceCount = A.length, this.instanceCount = I, this.attribute = new G.InstancedBufferAttribute(A, 1, !1, 1), this.attribute.setUsage(G.DynamicDrawUsage), this.setAttribute("splatIndex", this.attribute); + } + update(A, I) { + this.ordering = A, this.attribute.array = A, this.instanceCount = I, this.attribute.addUpdateRange(0, I), this.attribute.needsUpdate = !0; + } +} +const io = new Float32Array([ + -1, + -1, + 0, + 1, + -1, + 0, + 1, + 1, + 0, + -1, + 1, + 0 +]), wo = new Uint16Array([0, 1, 2, 0, 2, 3]), vB = '(function(){"use strict";class gI{static __wrap(A){A=A>>>0;const I=Object.create(gI.prototype);return I.__wbg_ptr=A,Ug.register(I,I.__wbg_ptr,I),I}__destroy_into_raw(){const A=this.__wbg_ptr;return this.__wbg_ptr=0,Ug.unregister(this),A}free(){const A=this.__destroy_into_raw();L.__wbg_csplatarray_free(A,0)}bhatt_lod(A){L.csplatarray_bhatt_lod(this.__wbg_ptr,A)}has_lod(){return L.csplatarray_has_lod(this.__wbg_ptr)!==0}inject_rgba8(A){L.csplatarray_inject_rgba8(this.__wbg_ptr,A)}len(){return L.csplatarray_len(this.__wbg_ptr)>>>0}tiny_lod(A,I){L.csplatarray_tiny_lod(this.__wbg_ptr,A,I)}to_extsplats(){const A=L.csplatarray_to_extsplats(this.__wbg_ptr);if(A[2])throw QA(A[1]);return QA(A[0])}to_extsplats_lod(){const A=L.csplatarray_to_extsplats_lod(this.__wbg_ptr);if(A[2])throw QA(A[1]);return QA(A[0])}to_packedsplats(){const A=L.csplatarray_to_packedsplats(this.__wbg_ptr);if(A[2])throw QA(A[1]);return QA(A[0])}to_packedsplats_lod(){const A=L.csplatarray_to_packedsplats_lod(this.__wbg_ptr);if(A[2])throw QA(A[1]);return QA(A[0])}get maxShDegree(){return L.__wbg_get_csplatarray_maxShDegree(this.__wbg_ptr)>>>0}get numSplats(){return L.__wbg_get_csplatarray_numSplats(this.__wbg_ptr)>>>0}set maxShDegree(A){L.__wbg_set_csplatarray_maxShDegree(this.__wbg_ptr,A)}set numSplats(A){L.__wbg_set_csplatarray_numSplats(this.__wbg_ptr,A)}}Symbol.dispose&&(gI.prototype[Symbol.dispose]=gI.prototype.free);class QI{static __wrap(A){A=A>>>0;const I=Object.create(QI.prototype);return I.__wbg_ptr=A,cg.register(I,I.__wbg_ptr,I),I}__destroy_into_raw(){const A=this.__wbg_ptr;return this.__wbg_ptr=0,cg.unregister(this),A}free(){const A=this.__destroy_into_raw();L.__wbg_gsplatarray_free(A,0)}get maxShDegree(){return L.__wbg_get_gsplatarray_maxShDegree(this.__wbg_ptr)>>>0}get numSplats(){return L.__wbg_get_gsplatarray_numSplats(this.__wbg_ptr)>>>0}bhatt_lod(A){L.gsplatarray_bhatt_lod(this.__wbg_ptr,A)}has_lod(){return L.gsplatarray_has_lod(this.__wbg_ptr)!==0}inject_rgba8(A){L.gsplatarray_inject_rgba8(this.__wbg_ptr,A)}len(){return L.gsplatarray_len(this.__wbg_ptr)>>>0}tiny_lod(A,I){L.gsplatarray_tiny_lod(this.__wbg_ptr,A,I)}to_extsplats(){const A=L.gsplatarray_to_extsplats(this.__wbg_ptr);if(A[2])throw QA(A[1]);return QA(A[0])}to_extsplats_lod(){const A=L.gsplatarray_to_extsplats_lod(this.__wbg_ptr);if(A[2])throw QA(A[1]);return QA(A[0])}to_packedsplats(A){const I=L.gsplatarray_to_packedsplats(this.__wbg_ptr,A);if(I[2])throw QA(I[1]);return QA(I[0])}to_packedsplats_lod(A){const I=L.gsplatarray_to_packedsplats_lod(this.__wbg_ptr,A);if(I[2])throw QA(I[1]);return QA(I[0])}set maxShDegree(A){L.__wbg_set_gsplatarray_maxShDegree(this.__wbg_ptr,A)}set numSplats(A){L.__wbg_set_gsplatarray_numSplats(this.__wbg_ptr,A)}}Symbol.dispose&&(QI.prototype[Symbol.dispose]=QI.prototype.free);function UQ(Q,A,I){return L.sort32_splats(Q,A,I)>>>0}function cQ(Q,A,I){return L.sort_splats(Q,A,I)>>>0}function HQ(){return{__proto__:null,"./spark_worker_rs_bg.js":{__proto__:null,__wbg_Error_2e59b1b37a9a34c3:function(A,I){return Error(sI(A,I))},__wbg___wbindgen_boolean_get_a86c216575a75c30:function(A){const I=A,g=typeof I=="boolean"?I:void 0;return NI(g)?16777215:g?1:0},__wbg___wbindgen_debug_string_dd5d2d07ce9e6c57:function(A,I){const g=OI(I),B=ZI(g,L.__wbindgen_malloc,L.__wbindgen_realloc),C=wI;dA().setInt32(A+4,C,!0),dA().setInt32(A+0,B,!0)},__wbg___wbindgen_in_4bd7a57e54337366:function(A,I){return A in I},__wbg___wbindgen_is_falsy_c6ddfae1bb56d5ef:function(A){return!A},__wbg___wbindgen_is_object_40c5a80572e8f9d3:function(A){const I=A;return typeof I=="object"&&I!==null},__wbg___wbindgen_is_undefined_c0cca72b82b86f4d:function(A){return A===void 0},__wbg___wbindgen_jsval_loose_eq_3a72ae764d46d944:function(A,I){return A==I},__wbg___wbindgen_number_get_7579aab02a8a620c:function(A,I){const g=I,B=typeof g=="number"?g:void 0;dA().setFloat64(A+8,NI(B)?0:B,!0),dA().setInt32(A+0,!NI(B),!0)},__wbg___wbindgen_string_get_914df97fcfa788f2:function(A,I){const g=I,B=typeof g=="string"?g:void 0;var C=NI(B)?0:ZI(B,L.__wbindgen_malloc,L.__wbindgen_realloc),E=wI;dA().setInt32(A+4,E,!0),dA().setInt32(A+0,C,!0)},__wbg___wbindgen_throw_81fc77679af83bc6:function(A,I){throw new Error(sI(A,I))},__wbg_csplatarray_new:function(A){return gI.__wrap(A)},__wbg_error_a6fa202b58aa1cd3:function(A,I){let g,B;try{g=A,B=I,console.error(sI(A,I))}finally{L.__wbindgen_free(g,B,1)}},__wbg_get_4848e350b40afc16:function(A,I){return A[I>>>0]},__wbg_get_f96702c6245e4ef9:function(){return Lg(function(A,I){return Reflect.get(A,I)},arguments)},__wbg_get_unchecked_7d7babe32e9e6a54:function(A,I){return A[I>>>0]},__wbg_get_with_ref_key_6412cf3094599694:function(A,I){return A[I]},__wbg_gsplatarray_new:function(A){return QI.__wrap(A)},__wbg_instanceof_ArrayBuffer_ff7c1337a5e3b33a:function(A){let I;try{I=A instanceof ArrayBuffer}catch{I=!1}return I},__wbg_instanceof_Uint8Array_4b8da683deb25d72:function(A){let I;try{I=A instanceof Uint8Array}catch{I=!1}return I},__wbg_length_0c32cb8543c8e4c8:function(A){return A.length},__wbg_length_1e701798fdcaa3b4:function(A){return A.length},__wbg_length_6e821edde497a532:function(A){return A.length},__wbg_length_a4ca9e78359b5f1f:function(A){return A.length},__wbg_new_227d7c05414eb861:function(){return new Error},__wbg_new_4f9fafbb3909af72:function(){return new Object},__wbg_new_a560378ea1240b14:function(A){return new Uint8Array(A)},__wbg_new_f3c9df4f38f3f798:function(){return new Array},__wbg_new_with_length_41a22191b9bdfd66:function(A){return new Uint32Array(A>>>0)},__wbg_prototypesetcall_3e05eb9545565046:function(A,I,g){Uint8Array.prototype.set.call(YQ(A,I),g)},__wbg_prototypesetcall_64c287a27cc24d27:function(A,I,g){Uint16Array.prototype.set.call(aQ(A,I),g)},__wbg_prototypesetcall_e42275e601e14eeb:function(A,I,g){Uint32Array.prototype.set.call(Hg(A,I),g)},__wbg_push_6bdbc990be5ac37b:function(A,I){return A.push(I)},__wbg_set_448126769bf7c181:function(A,I,g){A.set(Hg(I,g))},__wbg_set_6be42768c690e380:function(A,I,g){A[I]=g},__wbg_set_81b4174352e6a095:function(A,I,g){A.set(I,g>>>0)},__wbg_set_8ee2d34facb8466e:function(){return Lg(function(A,I,g){return Reflect.set(A,I,g)},arguments)},__wbg_set_index_338a66e40fc45dee:function(A,I,g){A[I>>>0]=g>>>0},__wbg_stack_3b0d974bbf31e44f:function(A,I){const g=I.stack,B=ZI(g,L.__wbindgen_malloc,L.__wbindgen_realloc),C=wI;dA().setInt32(A+4,C,!0),dA().setInt32(A+0,B,!0)},__wbg_subarray_0f98d3fb634508ad:function(A,I,g){return A.subarray(I>>>0,g>>>0)},__wbg_subarray_517cd0f1811ab872:function(A,I,g){return A.subarray(I>>>0,g>>>0)},__wbg_subarray_d51e89458b3fdbf6:function(A,I,g){return A.subarray(I>>>0,g>>>0)},__wbindgen_cast_0000000000000001:function(A){return A},__wbindgen_cast_0000000000000002:function(A,I){return sI(A,I)},__wbindgen_init_externref_table:function(){const A=L.__wbindgen_externrefs,I=A.grow(4);A.set(0,void 0),A.set(I+0,void 0),A.set(I+1,null),A.set(I+2,!0),A.set(I+3,!1)}}}}typeof FinalizationRegistry>"u"||new FinalizationRegistry(Q=>L.__wbg_chunkdecoder_free(Q>>>0,1));const Ug=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(Q=>L.__wbg_csplatarray_free(Q>>>0,1)),cg=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(Q=>L.__wbg_gsplatarray_free(Q>>>0,1));function LQ(Q){const A=L.__externref_table_alloc();return L.__wbindgen_externrefs.set(A,Q),A}function OI(Q){const A=typeof Q;if(A=="number"||A=="boolean"||Q==null)return`${Q}`;if(A=="string")return`"${Q}"`;if(A=="symbol"){const B=Q.description;return B==null?"Symbol":`Symbol(${B})`}if(A=="function"){const B=Q.name;return typeof B=="string"&&B.length>0?`Function(${B})`:"Function"}if(Array.isArray(Q)){const B=Q.length;let C="[";B>0&&(C+=OI(Q[0]));for(let E=1;E1)g=I[1];else return toString.call(Q);if(g=="Object")try{return"Object("+JSON.stringify(Q)+")"}catch{return"Object"}return Q instanceof Error?`${Q.name}: ${Q.message}\n${Q.stack}`:g}function aQ(Q,A){return Q=Q>>>0,KQ().subarray(Q/2,Q/2+A)}function Hg(Q,A){return Q=Q>>>0,tQ().subarray(Q/4,Q/4+A)}function YQ(Q,A){return Q=Q>>>0,DI().subarray(Q/1,Q/1+A)}let OA=null;function dA(){return(OA===null||OA.buffer.detached===!0||OA.buffer.detached===void 0&&OA.buffer!==L.memory.buffer)&&(OA=new DataView(L.memory.buffer)),OA}function sI(Q,A){return Q=Q>>>0,dQ(Q,A)}let BI=null;function KQ(){return(BI===null||BI.byteLength===0)&&(BI=new Uint16Array(L.memory.buffer)),BI}let CI=null;function tQ(){return(CI===null||CI.byteLength===0)&&(CI=new Uint32Array(L.memory.buffer)),CI}let EI=null;function DI(){return(EI===null||EI.byteLength===0)&&(EI=new Uint8Array(L.memory.buffer)),EI}function Lg(Q,A){try{return Q.apply(this,A)}catch(I){const g=LQ(I);L.__wbindgen_exn_store(g)}}function NI(Q){return Q==null}function ZI(Q,A,I){if(I===void 0){const D=iI.encode(Q),i=A(D.length,1)>>>0;return DI().subarray(i,i+D.length).set(D),wI=D.length,i}let g=Q.length,B=A(g,1)>>>0;const C=DI();let E=0;for(;E127)break;C[B+E]=D}if(E!==g){E!==0&&(Q=Q.slice(E)),B=I(B,g,g=E+Q.length*3,1)>>>0;const D=DI().subarray(B+E,B+g),i=iI.encodeInto(Q,D);E+=i.written,B=I(B,g,E,1)>>>0}return wI=E,B}function QA(Q){const A=L.__wbindgen_externrefs.get(Q);return L.__externref_table_dealloc(Q),A}let JI=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0});JI.decode();const qQ=2146435072;let TI=0;function dQ(Q,A){return TI+=A,TI>=qQ&&(JI=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),JI.decode(),TI=A),JI.decode(DI().subarray(Q,Q+A))}const iI=new TextEncoder;"encodeInto"in iI||(iI.encodeInto=function(Q,A){const I=iI.encode(Q);return A.set(I),{read:Q.length,written:I.length}});let wI=0,L;function xQ(Q,A){return L=Q.exports,OA=null,BI=null,CI=null,EI=null,L.__wbindgen_start(),L}async function rQ(Q,A){if(typeof Response=="function"&&Q instanceof Response){if(typeof WebAssembly.instantiateStreaming=="function")try{return await WebAssembly.instantiateStreaming(Q,A)}catch(B){if(Q.ok&&I(Q.type)&&Q.headers.get("Content-Type")!=="application/wasm")console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n",B);else throw B}const g=await Q.arrayBuffer();return await WebAssembly.instantiate(g,A)}else{const g=await WebAssembly.instantiate(Q,A);return g instanceof WebAssembly.Instance?{instance:g,module:Q}:g}function I(g){switch(g){case"basic":case"cors":case"default":return!0}return!1}}async function nQ(Q){if(L!==void 0)return L;Q!==void 0&&(Object.getPrototypeOf(Q)===Object.prototype?{module_or_path:Q}=Q:console.warn("using deprecated parameters for the initialization function; pass a single object instead")),Q===void 0&&(Q=new URL("data:application/wasm;base64,AGFzbQEAAAAB6wZpYAN/f38Bf2ACf38AYAJ/fwF/YAF/AGABfwF/YAN/f38AYAR/f39/AGAFf39/f38AYAADf39/YAZ/f39/f38AYAd/f39/f39/AGAEf39/fwF/YAFvAX9gCH9/f39/f39/AGABfwN/f39gBX9/f39/AX9gAX0BfWAAAGACf28AYAF/AX5gA399fwBgBn9/f39/fwF/YAZ/f39/f30AYAABf2ACf30AYAV/f39+fwBgA29/fwFvYAN/f28AYAF/AW9gAAFvYAJvbwF/YAl/f39/f39/f38AYAF+AX9gAn9vA39/f2ACfX0BfWADb39/AGACb28Bb2ACb38Bb2ACf38Bb2AEf39/fQF/YAx/f39/f39/f39/f38AYAl/f39/f39/f38Bf2AFf39/fX8AYAd/f39/f39/AX9gBX9/f399AGAEf31/fwF/YBN/f39/f39/f39/f39/f39/f39/AX9gE39/f39/f39/f39/f39/f39/f38AYAN+fn8BfmAHf39/f399fQBgA39+fgBgBX9/fn9/AGAFf398f38AYAV/f31/fwBgBH9vf28Df39/YAN/b28Bf2AAAn9/YANvb28Bf2ADb29vAGADb29/AGABbwFvYAF8AW9gCn9/f39/f39/f38Bf2ALf39/f39/f39/f38Bf2AKf39/f39/f39/fwBgBn9/fX9/fwBgAn9/AX1gBH9/f34AYAN/f38BfmACf34AYAN/fX8Bf2AFf39/fn4AYAZ/fn9/f38AYAZ/f39/fX0AYAF/AX1gBH5+f38BfmAFf39/f38BfWAJf39/f39/fn5+AGAEf39/fwF9YAJ+fwBgA39/ewBgAn9+AX9gAn1/AX1gA319fQF9YAR/fn5/AGAGf39/fn9/AGAGf39/fH9/AGAGf39/fX9/AGATf318f39/f39/f39/f39/f39/fwN/f39gCX9/f39/f39/bwN/f39gCH9/f39vf39/A39/f2AHf29/fX9/bwN/f39gB39vb399f38Df39/YAd/f39/f39/A39/f2AGf29vf31/A39/f2AGf29/fX9vA39/f2AFf39/f28Df39/YAR/b29/A39/f2AEf39/fwN/f39gAn9/A39/f2ACf28Cf39gBH9+f38AYAR/fX9/AGAEf3x/fwBgAXwBfwKdFS0XLi9zcGFya193b3JrZXJfcnNfYmcuanMfX193Ymdfc3ViYXJyYXlfZDUxZTg5NDU4YjNmZGJmNgAaFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzHV9fd2JnX2xlbmd0aF8xZTcwMTc5OGZkY2FhM2I0AAwXLi9zcGFya193b3JrZXJfcnNfYmcuanMaX193Ymdfc2V0XzQ0ODEyNjc2OWJmN2MxODEAIxcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcydfX3diZ19wcm90b3R5cGVzZXRjYWxsX2U0MjI3NWU2MDFlMTRlZWIAGxcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcyZfX3diZ19uZXdfd2l0aF9sZW5ndGhfNDFhMjIxOTFiOWJkZmQ2NgAcFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzGl9fd2JnX25ld180ZjlmYWZiYjM5MDlhZjcyAB0XLi9zcGFya193b3JrZXJfcnNfYmcuanMaX193Ymdfc2V0XzhlZTJkMzRmYWNiODQ2NmUAORcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcxpfX3diZ19uZXdfZjNjOWRmNGYzOGYzZjc5OAAdFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzG19fd2JnX3B1c2hfNmJkYmM5OTBiZTVhYzM3YgAeFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzGl9fd2JnX2dldF9mOTY3MDJjNjI0NWU0ZWY5ACQXLi9zcGFya193b3JrZXJfcnNfYmcuanMqX193YmdfX193YmluZGdlbl9pc19mYWxzeV9jNmRkZmFlMWJiNTZkNWVmAAwXLi9zcGFya193b3JrZXJfcnNfYmcuanMaX193Ymdfc2V0XzZiZTQyNzY4YzY5MGUzODAAOhcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcxpfX3diZ19nZXRfNDg0OGUzNTBiNDBhZmMxNgAlFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzFV9fd2JnX2dzcGxhdGFycmF5X25ldwAcFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzFV9fd2JnX2NzcGxhdGFycmF5X25ldwAcFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzHF9fd2JnX0Vycm9yXzJlNTliMWIzN2E5YTM0YzMAJhcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcytfX3diZ19fX3diaW5kZ2VuX2lzX29iamVjdF80MGM1YTgwNTcyZThmOWQzAAwXLi9zcGFya193b3JrZXJfcnNfYmcuanMnX193YmdfZ2V0X3dpdGhfcmVmX2tleV82NDEyY2YzMDk0NTk5Njk0ACQXLi9zcGFya193b3JrZXJfcnNfYmcuanMuX193YmdfX193YmluZGdlbl9pc191bmRlZmluZWRfYzBjY2E3MmI4MmI4NmY0ZAAMFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzJF9fd2JnX19fd2JpbmRnZW5faW5fNGJkN2E1N2U1NDMzNzM2NgAeFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzLF9fd2JnX19fd2JpbmRnZW5fbnVtYmVyX2dldF83NTc5YWFiMDJhOGE2MjBjABIXLi9zcGFya193b3JrZXJfcnNfYmcuanMtX193YmdfX193YmluZGdlbl9ib29sZWFuX2dldF9hODZjMjE2NTc1YTc1YzMwAAwXLi9zcGFya193b3JrZXJfcnNfYmcuanMaX193Ymdfc2V0XzgxYjQxNzQzNTJlNmEwOTUAOxcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcx1fX3diZ19sZW5ndGhfMGMzMmNiODU0M2M4ZTRjOAAMFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzH19fd2JnX3N1YmFycmF5XzBmOThkM2ZiNjM0NTA4YWQAGhcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcydfX3diZ19wcm90b3R5cGVzZXRjYWxsXzNlMDVlYjk1NDU1NjUwNDYAGxcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcyBfX3diZ19zZXRfaW5kZXhfMzM4YTY2ZTQwZmM0NWRlZQAjFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzHV9fd2JnX2xlbmd0aF9hNGNhOWU3ODM1OWI1ZjFmAAwXLi9zcGFya193b3JrZXJfcnNfYmcuanMfX193Ymdfc3ViYXJyYXlfNTE3Y2QwZjE4MTFhYjg3MgAaFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzJ19fd2JnX3Byb3RvdHlwZXNldGNhbGxfNjRjMjg3YTI3Y2MyNGQyNwAbFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzHV9fd2JnX2xlbmd0aF82ZTgyMWVkZGU0OTdhNTMyAAwXLi9zcGFya193b3JrZXJfcnNfYmcuanMkX193YmdfZ2V0X3VuY2hlY2tlZF83ZDdiYWJlMzJlOWU2YTU0ACUXLi9zcGFya193b3JrZXJfcnNfYmcuanMaX193YmdfbmV3XzIyN2Q3YzA1NDE0ZWI4NjEAHRcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcxxfX3diZ19zdGFja18zYjBkOTc0YmJmMzFlNDRmABIXLi9zcGFya193b3JrZXJfcnNfYmcuanMcX193YmdfZXJyb3JfYTZmYTIwMmI1OGFhMWNkMwABFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzMF9fd2JnX19fd2JpbmRnZW5fanN2YWxfbG9vc2VfZXFfM2E3MmFlNzY0ZDQ2ZDk0NAAeFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzLF9fd2JnX19fd2JpbmRnZW5fc3RyaW5nX2dldF85MTRkZjk3ZmNmYTc4OGYyABIXLi9zcGFya193b3JrZXJfcnNfYmcuanMsX193YmdfaW5zdGFuY2VvZl9VaW50OEFycmF5XzRiOGRhNjgzZGViMjVkNzIADBcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcy1fX3diZ19pbnN0YW5jZW9mX0FycmF5QnVmZmVyX2ZmN2MxMzM3YTVlM2IzM2EADBcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcxpfX3diZ19uZXdfYTU2MDM3OGVhMTI0MGIxNAA8Fy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzJ19fd2JnX19fd2JpbmRnZW5fdGhyb3dfODFmYzc3Njc5YWY4M2JjNgABFy4vc3Bhcmtfd29ya2VyX3JzX2JnLmpzLl9fd2JnX19fd2JpbmRnZW5fZGVidWdfc3RyaW5nX2RkNWQyZDA3Y2U5ZTZjNTcAEhcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcx9fX3diaW5kZ2VuX2luaXRfZXh0ZXJucmVmX3RhYmxlABEXLi9zcGFya193b3JrZXJfcnNfYmcuanMgX193YmluZGdlbl9jYXN0XzAwMDAwMDAwMDAwMDAwMDEAPRcuL3NwYXJrX3dvcmtlcl9yc19iZy5qcyBfX3diaW5kZ2VuX2Nhc3RfMDAwMDAwMDAwMDAwMDAwMgAmA5cKlQoYGBQUAQoKAQkBCgoFCgkKBAQnBAQNJw0BAQYEBAoEBAUNBgQEBAQJCREFBgEJAQQEBAQJCQYBAgcoCQIJASgGBQ0BKQQGAQA+BQE/DQcGAgIGAgYGAQEGBgUEBAQEBgECBgUGBgYCBwkCBgEFBgEBAwMEBA8DBAEHAQcGAAYDBA0BAgEEAQEVAQYBBAIEBQYDBUABDwcDAgEBBwICBSoCCQEFBwQEBgQCBwUfAioGAQcFBgEHBhYGAQcrCQENAAEBAAIFAQIFAQUKLCsGBQcDBgYBDQEFAwEDBAUCBQMCAwMBAQFBAgYBLAcJARADEEIHBwUGAQMHBwECAgQWCQkBAQJDBw0DCUQAAQEBAQELBC0DAwMEAQIBAgECAwMCRQUGBEYBAQEBBwACCRkCBQIBAQcABQQJAQYBRwYGSAMDBQUDAQUDBgUFAwMtBgUKBQYBAwkABQUHAQIDAwMDLi4FCQkvLwkHBwIBAQAGBQEDAwMDAQMAAQIBAQYCAQZJAgsFAQAFAQYJCQQEBAQCBAEVAQICFQABAQUGAwUVBw0ABQUHAgEAAAIFBQAACQUWHwICCgICAQcHAgMHCgUFAwMBARkCBwUwAgUFBQMwBAABAQQBMQMDCgkFAwMEChBKAQUFBQUWBgEDBksHBQEDAwIBBAIBAQUCBgcBAgICAQEDAgQBAkwDTQEHBwcHAQIKBwlOAwNPAgUBAgcHBQsGAgQEBAEDAQIJBgYHAQMPARcHEAIEUAoCBAMGBAQBDwUfAgkDBAsZFAoCAgIQAwcxBAcCAzIAAQcWAQMCAgYBBAECDwEGCwEFAhcGAQICAgICAgYCEAEHAgcDBwUEBAICBAEBAQEBAQIBAgQEAQECAAICAgIBAgMBBwMCAxAEAQMFAgEBAwMAAgMCAQkBAQEFAgIHAwEDAwcCAAcDAwICAgECBwMpBQICAgICAQIFBQEBAQICAgICAlEBAgICAgICAgEDAgkCAQEHAwEDAwEBAQEBCQkCAwIBAQIBAQMBAQEFAQUCAgFSAQICUwMDAQEBBgADAwEDAgELCwUCAgEBBAMBCwMDAgEBAgMDAwEBAQICAAMyAAAHAgUDAwUCAxkFAxQUBwcJAwYFBQUFAwMDAwMDAwYYGAMFAgMABgMEBAQEAgUBBAQECQQDBwQFAwMDAwMCAgICBVQFBAEDEwEDAQEFBARVCVZXAQECBQcCBhAAAAAAAAAAAAAAAAAEAgIAAAAAIAQgAAQgBAQEAgACAgIAWAUTBQEAAAABAgABAgIGBQIBBAICAlkPWgcCBgIHAQFbXF0DEQMDXl8RC2ACNmFiNgEJAgIhIWMhAAICAgICAg4ODg4ODg4ODgQEBAQCAmQBAQEBAgICAgICAgICFQICAgICAgICAQICAQICDwczNTQCAQECAgIGCwIAAQIANzcDAgIiIgACBQMCAgICAgMCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMDAwECBQEBAQEBAQEBBAIAAgICAgIJAgICAgEBAQECAwEBAQICAgIEaAMDAgcCCQEXBRcSEgIBAgEBAQEBAQEBAgIBAgEBAQEBAQEDBAEDBQEFBQEFAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQICAwMBAQEBAQEBAQEBEQERAgICAQIBAgECAgICAQEBAQEBAQEEAwEBAQEBAQEBAQMDCgEEAgEiBAQEBAQEEQQXBQQLAnAB4QThBG8AgAgFAwEAEwYPAn8BQYCAwAALfwFBgAgLB7AMPgZtZW1vcnkCABdfX3diZ19jaHVua2RlY29kZXJfZnJlZQCSBBZfX3diZ19jc3BsYXRhcnJheV9mcmVlALYFIV9fd2JnX2dldF9jc3BsYXRhcnJheV9tYXhTaERlZ3JlZQClCB9fX3diZ19nZXRfY3NwbGF0YXJyYXlfbnVtU3BsYXRzAKYIIV9fd2JnX2dldF9nc3BsYXRhcnJheV9tYXhTaERlZ3JlZQCnCB9fX3diZ19nZXRfZ3NwbGF0YXJyYXlfbnVtU3BsYXRzAKgIFl9fd2JnX2dzcGxhdGFycmF5X2ZyZWUAtwUhX193Ymdfc2V0X2NzcGxhdGFycmF5X21heFNoRGVncmVlAKwIH19fd2JnX3NldF9jc3BsYXRhcnJheV9udW1TcGxhdHMArQghX193Ymdfc2V0X2dzcGxhdGFycmF5X21heFNoRGVncmVlAK4IH19fd2JnX3NldF9nc3BsYXRhcnJheV9udW1TcGxhdHMArwgTYmhhdHRfbG9kX2V4dHNwbGF0cwCDCBZiaGF0dF9sb2RfcGFja2Vkc3BsYXRzAIQIE2NodW5rZGVjb2Rlcl9maW5pc2gAoggRY2h1bmtkZWNvZGVyX3B1c2gAqwgVY3NwbGF0YXJyYXlfYmhhdHRfbG9kAP4GE2NzcGxhdGFycmF5X2hhc19sb2QAxgcYY3NwbGF0YXJyYXlfaW5qZWN0X3JnYmE4AMIJD2NzcGxhdGFycmF5X2xlbgDVBxRjc3BsYXRhcnJheV90aW55X2xvZADrBhhjc3BsYXRhcnJheV90b19leHRzcGxhdHMAnAgcY3NwbGF0YXJyYXlfdG9fZXh0c3BsYXRzX2xvZACeCBtjc3BsYXRhcnJheV90b19wYWNrZWRzcGxhdHMAnQgfY3NwbGF0YXJyYXlfdG9fcGFja2Vkc3BsYXRzX2xvZACfCBVkZWNvZGVfdG9fY3NwbGF0YXJyYXkAhwgTZGVjb2RlX3RvX2V4dHNwbGF0cwD+BxVkZWNvZGVfdG9fZ3NwbGF0YXJyYXkAiwgWZGVjb2RlX3RvX3BhY2tlZHNwbGF0cwD0BxBkaXNwb3NlX2xvZF90cmVlAIwCGGV4dHNwbGF0c190b19nc3BsYXRhcnJheQCKCBJnZXRfbG9kX3RyZWVfbGV2ZWwAkwgVZ3NwbGF0YXJyYXlfYmhhdHRfbG9kAP8GGGdzcGxhdGFycmF5X2luamVjdF9yZ2JhOADDCQ9nc3BsYXRhcnJheV9sZW4A1QcUZ3NwbGF0YXJyYXlfdGlueV9sb2QA7AYYZ3NwbGF0YXJyYXlfdG9fZXh0c3BsYXRzAKAIHGdzcGxhdGFycmF5X3RvX2V4dHNwbGF0c19sb2QAoQgbZ3NwbGF0YXJyYXlfdG9fcGFja2Vkc3BsYXRzAJEIH2dzcGxhdGFycmF5X3RvX3BhY2tlZHNwbGF0c19sb2QAkggNaW5pdF9sb2RfdHJlZQCUCAxuZXdfbG9kX3RyZWUApAgTbmV3X3NoYXJlZF9sb2RfdHJlZQCjCBtwYWNrZWRzcGxhdHNfdG9fY3NwbGF0YXJyYXkAjAgbcGFja2Vkc3BsYXRzX3RvX2dzcGxhdGFycmF5AIkIDHNpbWRfZW5hYmxlZADACg1zb3J0MzJfc3BsYXRzANoIC3NvcnRfc3BsYXRzANsIEnRpbnlfbG9kX2V4dHNwbGF0cwD9BxV0aW55X2xvZF9wYWNrZWRzcGxhdHMA/AcSdHJhdmVyc2VfbG9kX3RyZWVzANwHEHVwZGF0ZV9sb2RfdHJlZXMA8gcKd2FzbV9zdGFydACFCBNnc3BsYXRhcnJheV9oYXNfbG9kAMYHEV9fd2JpbmRnZW5fbWFsbG9jANoHEl9fd2JpbmRnZW5fcmVhbGxvYwCGCA9fX3diaW5kZ2VuX2ZyZWUAlgcUX193YmluZGdlbl9leG5fc3RvcmUA2gkXX19leHRlcm5yZWZfdGFibGVfYWxsb2MA2gQVX193YmluZGdlbl9leHRlcm5yZWZzAQEZX19leHRlcm5yZWZfdGFibGVfZGVhbGxvYwCbBxBfX3diaW5kZ2VuX3N0YXJ0AL4KCbgJAQBBAQvgBIsFxAnpCPMD7QiNASwrvAnECboJ0gjoB5sF9QSnAqIE8gHVCMQBggeeBOwHrASyCvwC5wP2AagG0AeJBssF5gaWCMMI3gLRCZsIswa0AsQIhQXGCYkG3APTA8AG0AmSCpMKugW4BZsKkwGPBtkG3Qj0BMcH2AjDApoKuAiZCsYJ1gLEBLIGpwOABu0GyAjcBdUFyQjJCMkIrgevB7YHygiwB9MIuAevB8sIsQfMCK8HlAfICLkIkQfZCPEG1AjuBukHlwrhBpwKugixCLsI/ATSCaMG7wfzBNMFqAXSCc8J5APKAo0GwgGDA9sExQTVBH20CecI/QjyCIMJiAnwCIwJhgn0CP8I9wiLCYUJhAmCCfoIjQnxCIcJgAn1CIEJ/gjqCIUE/QnRA4oHkQHKBogIgATmCdYDiQeQAYEE+gnXA4cHhQGGBOwJ0gOIB5IB5gj2CIkJgwfGCc8JswqUCsUJwQqDB9cHkgWBCpIJnAnaBs4FrgKzB6cKsge6BdIGsQXwBfEF/AWGCsQJoArjBN0EhQPCCKoKwgjGCc8Jnwq5CcQJ/QXtB4kK7QexBK4G6wSNB4UKjQeDCv4FkQmMCo8J8Qe1CuAHjQrFCeAHwQqQCYcK6gaECoIKoQrJBagKigqOCYsK3AiICqUHlAnMCdAGswikB78K9wSZCcsJ0QbBCJgHmgnICdcGsgipB5kHlgnHCZkGtQinB4wGlwnJCZgGvwiVCcoJvga0CJcHmwnNCZsG2AfLBoYHmAnOCZoG9gfNBe4HxQa4CZEK6wHaBYAK5wX7CPgI8wjvCIoJ+QjuCPwItQb/Cb0HuAOHA+oJxAe1BfkG8wnMB4kB8AlI8QlSnAPoCcEH0we8BvUJuge2A4YD9gnCB6YF+AbnCcsHhwHuCUzrCVCbA+8JvgetB7YG9wm7B7cDiAPkCcUHtAX6BvQJyQeKAfIJSekJU50D7QnAB9QHvQb5CbwHtQOJA+UJwwenBfcG+wnKB4gB+AlL/AlRngP+Cb8HrAeSCYMH4QeWBZ0J4geXBaAJ1QLbBZ8JoQmvA+UHogmpBb8FgwfjB5gFowm5BKkFxQXhBO8BlgrFCKsEyQF/1wiYCtcIngaYCJcIxwiqCLsFlQpk0QXGCLcIsAi2CP8F8gXzBYEG7wbvBu8GpAmkCY4IjgiOCLwEvAS9CdIE2APYA5sE0giSCZUKpgm8CPgH5geaBaUJ+gOpCKcJqAmmCs4IvQrfCbgGuQbcAaQB1AWmB+kGYsAFpAqlCr4J1wWNBdgFtgqzBN4H3wdPoQW8BbMF5wajA50FmgiZCM0I6QWtCYAH2wL0BYgCvgjIB9YHgwLIAdkBpQaiCsUJpQbBCuUIoAazCp0KxQnBCsYJ8AbGCYgGsQmpCuoGrgnxB7UK4AejCsUJ4AfBCtwGqwqCCp4KqAepCdMJ2Aa9CJoHrAnWCd4FwAiqB68J1wnWBqsJ1QnBBowGqgnUCaEG7QWwCdgJlAbZB8wFxgbjBM8IzwiyCegFwwX/BO8Djwi9BdAIzwnSCd4I4geXBbMJ5gj6B9kJrQr2Bq0GlQX1BbMK0QjtBMsD4wWsCq4KgwemBPYFgweKBpAItQkMAogBCsDmVJUK1NUBBBd/HX4FeyF9IwBB8ANrIgIkACAAEKIBIAIgACgCCDYCLCACIAJBLGqtQoCAgIAQhCIsNwOwAiACQgE3AuwCIAJBATYC5AIgAkHM5sEANgLgAiACIAJBsAJqNgLoAiACQdAAaiACQeACahDsAwJAAkACQAJAAkACQAJ/IAIoAlAiAwRAIAIoAlQiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgA2pJDQYgBUEAIAYgA0EnaksbDQcgBBCiAgsgAigCLEUNAQJAIAAoAggiBEUEQCAAQQRBABCJAgwBCyAEQQJ0IgkQcSIHRQ0DQQAhAwJAAkACQCAEQQRPBED9DAAAAAABAAAAAgAAAAMAAAAhNiAHIQUgBEH8//8/cSIDIQYDQCAFIDb9CwIAIAVBEGohBSA2/QwEAAAABAAAAAQAAAAEAAAA/a4BITYgBkEEayIGDQALIAMgBEYNAQsgByADQQJ0aiEFA0AgBSADNgIAIAVBBGohBSAEIANBAWoiA0cNAAsgAiAANgLkAiACIAJBsAJqNgLgAiACIAJB4AJqNgJQIARBAUYNAgwBCyACIAA2AuQCIAIgAkGwAmo2AuACIAIgAkHgAmo2AlALIARBFU8EQCACQdAAaiEGIwBBgCBrIgokAAJAAkACQAJAAkBBgIn6ACAEIARBgIn6AE8bIgUgBCAEQQF2ayIDIAMgBUkbIgVBgQhPBEAgA0H/////A0sNAkEwIAUgBUEwTRsiC0ECdCIDQf3///8HTw0CIAMQcSIFRQ0DIAcgBCAFIAsgBEHBAEkgBhBgIAVBBGsoAgAiBkF4cSILQQRBCCAGQQNxIgYbIANqSQ0EIAZBACALIANBJ2pLGw0FIAUQogIMAQsgByAEIApBgAggBEHBAEkgBhBgCyAKQYAgaiQADAULQdiVwQAQ/wcLAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQQQhAwNAIAcgAyAHaiACQeACahDKASAJIANBBGoiA0cNAAsLIAAgByAEEIkCIAdBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAlqSQ0GIANBACAEIAlBJ2pLGw0HIAcQogILIAAQmgQCQCAAKAIIIgMEQCADQQF0QQFrIgYQcSIFRQ0EQQAhAyACQQA2AjggAiAFNgI0IAIgBjYCMAJ9AkACQCAAKAIIIgQEQCAEIAZLBEAgAkEwakEAIARBAUEBEKQFIAIoAjQhBSACKAI4IQMLIAMgBWohBiAEQQFHBH8gBEEBayIEBEAgBkEBIAT8CwALIAUgAyAEaiIDagUgBgtBAToAACACIANBAWo2AjggACgCCEUNASAAKAIEIgQtABMiAyAELQASIgUgBC0AESIGIAUgBksbIgUgAyAFSxsiBg0CQwAAAAAMAwsgAkEANgI4C0EAQQBB3LvHABCMBwALQwAAQMEgACoCRCAALQBYQQJGIgMbIjxDAAAQQSAAKgJIIAMbIDyTQwAAfkOVIAZBAWtB/wFxs5SSEIkEIjwgPJILITwgBEEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEDIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIANFDQMaIAUgA0ENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIANBDXRyQYCAgMADaiAHcgwCC0HU5sEAEP8HAAsgAyADZ0EQayIDQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIANBF3RrcgshAyACQf//ASA8IAO+IjxDAACAP14EfSA8EMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUQ703hjUQ4AgQxgVDGHIxP5WNIjz8AEGAgH4gPEMAAADHYBsgPEMA/v9GXhtBACA8IDxbGzsBPCACIAYEfUMAAEDBIAAqAkQgAC0AWEECRiIDGyI8QwAAEEEgACoCSCADGyA8k0MAAH5DlSAGQQFrQf8BcbOUkhCJBCI8IDySBUMAAAAACwJ/IARBDGovAQAiBEH//wFxRQRAIARBEHQMAQsgBEH/B3EhAyAEQYCAAnEhBSAEQYD4AXEiBEGA+AFGBEAgBUEQdCIEQYCAgPwHciADRQ0BGiAEIANBDXRyQYCAgP4HcgwBCyAFQRB0IgUgBEENdEGAgID8AHEgA0ENdHJBgICAwANqciAEDQAaIAMgA2dBEGsiA0H//wNxQQhqdEH///8DcSAFQYCAgNgDciADQRd0a3ILviI8QwAAgD9eBH0gPBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlDgCwAEgAiACQcABaq1CgICAgNABhDcDWCACIAJBPGqtQoCAgIDgAYQ3A1AgAkICNwLsAiACQQI2AuQCIAJBuOPBADYC4AIgAiACQdAAajYC6AIgAkGwAmogAkHgAmoQ7AMCQCACKAKwAiIDBEAgAigCtAIiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgA2pJDQEgBUEAIAYgA0EnaksbDQcgBBCiAgsgAiACLwE8OwE+IAJBADYCQCACQQA2AkwgAkKAgICAwAA3AkRB2LbJACgCACIDRQRAEJMFIQMLIAMoAgAgAygCBCgCDBEEACEDIAJB8JrIAP0AAwD9CwNQIAIgA61Cxs7rhrfq7a0ShSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEQpK23Z0FhELSgaqbq/qC16d/fiIZQoDoAoNCKIYgGUKAgJQDg0IYhiAZQoCAgKgKg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQoCAgICAgICARIQgGkLYotHvwqnlvy1+hSIcQu3cspuNpYnMywCFIhlC2KLR78Kp5b8tfiAZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQtKBqpur+oLXp39+IhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhISFQov9+pfHxteXhn+FIhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhCAZQtii0e/CqeW/LX6FIhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRCiKyRp/aIgJywf34iGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhCAZQs+O/8e788bUd36FIBmJNwN4IAIgHELWgs2hkP2UjkuFIhlC2KLR78Kp5b8tfiAZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQtKBqpur+oLXp39+IhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhISFQvzDvKfJldXk6ACFIhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhCAZQtii0e/CqeW/LX6FIhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRCiKyRp/aIgJywf34iGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhCAZQs+O/8e788bUd36FIBmJNwNwIAIgHEL8w7ynyZXV5OgAhSIZQtii0e/CqeW/LX4gGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhELSgaqbq/qC16d/fiIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEhULt3LKbjaWJzMsAhSIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIQgGULYotHvwqnlvy1+hSIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQoiskaf2iICcsH9+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIQgGULPjv/Hu/PG1Hd+hSAZiTcDaCACIBxCi/36l8fG15eGf4UiGULYotHvwqnlvy1+IBlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhIVC1oLNoZD9lI5LhSIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIQgGULYotHvwqnlvy1+hSIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEQoiskaf2iICcsH9+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIQgGULPjv/Hu/PG1Hd+hSAZiTcDYCAAQTxqIQ8gAkHwAWqtIi1CgICAgBCEISkgAkHgAWqtQoCAgIAQhCEuIAJBQGutQoCAgIAQhCEvIAJBgAFqrUKAgICA0AGEITAgAkE+aq1CgICAgOABhCExIAJB6AJqIRUgAigCLCEJIAIoAkAhBANAIAJDAACAPyACLgE+ELAGIjw4AoABIAAoAgghCwJAIAQgCU8NAEMAABBBIAAqAkggAC0AWEECRiIDG0MAAEDBIAAqAkQgAxsiO5NDAAB+Q5UhRSAEIAlrIQ0gBEEYbCIMIAAoAgRqQQxqIQMgBCAEIAsgBCALSxtrIQ5BACEFAkADQCAEIAVqIQcCfwJAIAUgDmoEQCADQQdqLQAAIgYgA0EGai0AACIKIANBBWotAAAiCCAIIApJGyIKIAYgCksbIgYEfSA7IEUgBkEBa0H/AXGzlJIQiQQiQiBCkgVDAAAAAAshQiADLwEAIgpB//8BcUUEQCAKQRB0DAMLIApB/wdxIQYgCkGAgAJxIQggCkGA+AFxIgpBgPgBRgRAIAhBEHQiCkGAgID8B3IgBkUNAxogCiAGQQ10ckGAgID+B3IMAwsgCEEQdCEIIApFDQEgCkENdEGAgID8AHEgBkENdHJBgICAwANqIAhyDAILIAcgC0Hcu8cAEIwHAAsgBiAGZ0EQayIGQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAZBF3RrcgshBiBCIAa+IkJDAACAP14EfSBCEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUIDxeDQEgAiAHQQFqNgJAIANBGGohAyANIAVBAWoiBWoNAAsgCSEHCyAEIAdPDQACQCAHIARrIgtB/////wFNBEAgC0EDdCIDQf3///8HSQ0BC0Hg/8YAEP8HAAtBACEGAkAgA0UEQEEEIQlBACELDAELIAMQcSIJRQ0FCyAEIAdrIQ0gCSEDA0BDAACAPyE8An8CQCAEIAZqIgogACgCCCIFSQRAIAAoAgQgDGoiBUETai0AACIHIAVBEmotAAAiCCAFQRFqLQAAIg4gCCAOSxsiCCAHIAhLGyIHBH1DAABAwSAAKgJEIAAtAFhBAkYiCBsiO0MAABBBIAAqAkggCBsgO5NDAAB+Q5UgB0EBa0H/AXGzlJIQiQQiOyA7kgVDAAAAAAshOyAFQQxqLwEAIgdB//8BcUUEQCAHQRB0DAMLIAdB/wdxIQUgB0GAgAJxIQggB0GA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgBUUNAxogByAFQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgBUENdHJBgICAwANqIAhyDAILIAogBUHcu8cAEIwHAAsgBSAFZ0EQayIFQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAVBF3Rrcgu+IkVDAACAP14EQCBFEMYFQ1T4LUCUQwAAgD+SkSE8CyADQQRqIAo2AgAgAyA7IDyMlDgCACAMQRhqIQwgA0EIaiEDIA0gBkEBaiIGag0ACyACIAY2AowBIAIgCTYCiAEgAiALNgKEASACQcQAaiACQYQBahCUAiAAKAIIIQsLIAIgAigCTCIHNgLgASACIAs2AvABIAIgKTcDiAMgAiAuNwOAAyACICw3A/gCIAIgLzcD8AIgAiAwNwPoAiACIDE3A+ACIAJCBjcCvAIgAkEGNgK0AiACQfzmwQA2ArACIAIgAkHgAmo2ArgCIAJBoAJqIAJBsAJqEOwDIAIoAqACIgMEQCACKAKkAiIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyADakkNByAFQQAgBiADQSdqSxsNCCAEEKICCyACKAJcIgQEQCACKAJQIgZBCGohAyAGKQMAQn+FQoCBgoSIkKDAgH+DIRkgBiEFA0AgGVAEQANAIAVBgARrIQUgAykDACADQQhqIQNCgIGChIiQoMCAf4MiGUKAgYKEiJCgwIB/UQ0ACyAZQoCBgoSIkKDAgH+FIRkLIAUgGXqnQQN0QcAHcWsiCUEEaygCACIKQQlPBEAgCUEgaygCACIJQQRrKAIAIgtBeHEiCCAKQQJ0IgpBBEEIIAtBA3EiCxtqSQ0JIAtBACAIIApBJ2pLGw0KIAkQogILIBlCAX0gGYMhGSAEQQFrIgQNAAsgAiACKAJUIgMEfyADQQlqIgQEQCAGQf8BIAT8CwALIAMgA0EBakEDdkEHbCADQQhJGwVBAAs2AlggAkEANgJcCwJAIAdFDQAgAigCSCIDIAdBA3RqIQsgA0EIaiEFAkADQCADKAIEIgkgACgCCCIDTw0BIAUhByACIAAoAgQgCUEYbGr9AAIAIDb9DQABAgMEBQYHCAkKCwgJCgsgAv0JAoAB/ecB/WgiNv0fAvwENwOgASACIDb9HwH8BDcDmAEgAiA2/R8A/AQ3A5ABIAJB4AJqIAJB0ABqIAJBkAFqEIcCAkAgAigCgAMiBgRAIAJBuAJqIBVBCGr9AAMA/QsDACACIBUpAwA3A7ACIAYoAgAiBSAGKAIEIgogAigC4AIiCHEiBGopAABCgIGChIiQoMCAf4MiGVAEQEEIIQMDQCADIARqIQQgA0EIaiEDIAUgBCAKcSIEaikAAEKAgYKEiJCgwIB/gyIZUA0ACwsgBSAZeqdBA3YgBGogCnEiBGosAAAiA0EATgRAIAUgBSkDAEKAgYKEiJCgwIB/g3qnQQN2IgRqLQAAIQMLIAQgBWogCEEZdiIIOgAAIAYgBigCCCADQQFxazYCCCAFIARBCGsgCnFqQQhqIAg6AAAgBSAEQQZ0ayIDQUBqIgRBEGogAkHAAmopAwA3AwAgBCAC/QADsAL9CwMAIANBBGtBADYCACADQShrQQA2AgAgBiAGKAIMQQFqNgIMDAELIAIoAuACIQMLIANBJGshBgJ/IANBBGsiBSgCACIIQQlJBEAgCCEEQQghCCAGDAELIAYoAgAhBCAGIQUgA0EgaygCAAshDCAEIAhGBH8gA0EoaxDNBiADQSBrKAIAIQwgBiIFKAIABSAEC0ECdCAMaiAJNgIAIAUgBSgCAEEBajYCACAHQQBBCCAHIAtGIgQbaiEFIAchAyAERQ0ACwwBCyAJIANB3LvHABCMBwALIAJBADYCsAEgAkKAgICAwAA3AqgBA0AgAigCNCERIAIoAjghDAJAAkACQAJAAkADQCACQbQBaiACQcQAahCEAyACKAK0AUEBRw0CIAIoArwBIg0gDE8NASANIBFqIhItAABFDQALIAAoAggiCSANSwRAAkAgACgCBCIUIA1BGGxqIgT9AAIAIDb9DQABAgMEBQYHCAkKCwgJCgsgAv0JAoAB/ecB/WgiNv0fAvwEIiJCAX0iHyAiQgF8IipXBEAgAikDYCIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEITJDAACAPyAAKgJAIAAtAFhBAkYiAxtDAAAAACAAKgI8IAMbIkWTIUJDAAAQQSAAKgJIIAMbQwAAQMEgACoCRCADGyJIk0MAAH5DlSFJIBlCf4UhMyA2/R8A/AQiI0IBfCEgICNCAX0hJCA2/R8B/AQiKEIBfCEeIChCAX0hHEL///////////8AISVDAACA/yE8QX8hCyACKAJQIQggAigCVCEKIAIpA2ghNCACKAJcIRYgBEEWaiEXIARBFGohGEL///////////8AISZC////////////ACEnA0ACQCAcIB5VDQAgICAkUwRAIBwhGQNAIBkgHlkNAiAeIBkgGSAeU618IhlZDQALDAELAkAgFgRAIBwhGQwBCyAcIRoDQCAkIRkDQCAZICBTIgMEQCAZIAOtfCIZICBXDQELCyAaIB5ZDQIgHiAaIBogHlOtfCIaWQ0ACwwBCwNAIBkiISAZIB5TrXwhGSAkIRoCQAJAA0AgCiAaIDSFIhtC2KLR78Kp5b8tfiAbQjiGIBtCgP4Dg0IohoQgG0KAgPwHg0IYhiAbQoCAgPgPg0IIhoSEIBtCCIhCgICA+A+DIBtCGIhCgID8B4OEIBtCKIhCgP4DgyAbQjiIhISEQtKBqpur+oLXp39+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhISFICGFIhtC2KLR78Kp5b8tfiAbQjiGIBtCgP4Dg0IohoQgG0KAgPwHg0IYhiAbQoCAgPgPg0IIhoSEIBtCCIhCgICA+A+DIBtCGIhCgID8B4OEIBtCKIhCgP4DgyAbQjiIhISEQtKBqpur+oLXp39+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhISFIB+FIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIRC0oGqm6v6gtenf34iHUI4hiAdQoD+A4NCKIaEIB1CgID8B4NCGIYgHUKAgID4D4NCCIaEhCAdQgiIQoCAgPgPgyAdQhiIQoCA/AeDhCAdQiiIQoD+A4MgHUI4iISEhCAbQtii0e/CqeW/LX6FIhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgM34iHUI4hiAdQoD+A4NCKIaEIB1CgID8B4NCGIYgHUKAgID4D4NCCIaEhCAdQgiIQoCAgPgPgyAdQhiIQoCA/AeDhCAdQiiIQoD+A4MgHUI4iISEhCAbIDJ+hSAbiSIbp3EhBSAbQhmIQv8Ag0KBgoSIkKDAgAF+ITUgGiAaICBTrXwhG0EAIQYCQAJAA0ACQCAFIAhqKQAAIisgNYUiHUJ/hSAdQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIh1QRQRAA0ACQCAaIAggHXqnQQN2IAVqIApxQQZ0ayIDQUBqKQMAUg0AICEgA0E4aykDAFINACAfIANBMGspAwBRDQMLIB1CAX0gHYMiHVBFDQALCyArICtCAYaDQoCBgoSIkKDAgH+DUEUNAiAFIAZBCGoiBmogCnEhBQwBCwsCfyADQQRrKAIAIgVBCU8EQCADQSRrKAIAIQUgA0EgaygCAAwBCyADQSRrCyEGIAVFDQAgBUECdCEHA0AgBigCACIDIAxPDQICQCADIA1GDQAgAyARai0AAEEBcUUNACADIAlPDQUgBEERai8AACAEQRNqLQAAIgVBEHRyIg5BCHYhEEMAAAAAIUBDAAAAACE/IA5B/wFxBEAgSCBJIA5BAWtB/wFxs5SSEIkEIT8LIBBB/wFxBEAgSCBJIBBBAWtB/wFxs5SSEIkEIUALQwAAAAAhTEMAAAAAITsgBQRAIEggSSAFQQFrQf8BcbOUkhCJBCE7C0MAAIA/IBgvAQAiBUEIdrP9EyAFIBctAAAiDkEQdHJB/wFxs/0gAf0MAAB/QwAAf0MAAH9DAAB/Q/3nASI2IDb95AH9DAAAgL8AAIC/AACAvwAAgL/95AEiNv0fASJDi5MgNv0fACJEi5MiPYxDAAAAABDgCCE+IDv9EyAOs0MAAH9DlUMAAAA/lEPbD0lAlCJKEJkCIkEgQyA+ID6MIkMgNv0MAAAAAAAAAAAAAAAAAAAAAP1G/U0iNv3HAf0bAkEBcRuSIjsgPSA9lCA7IDuUIEQgPiBDIDb9GwBBAXEbkiJDIEOUkpKRIkSVlCI7IEEgPSBElZQiRyBHkiI+lCJNIEoQmwIiSiBBIEMgRJWUIj0gPZIiQZQiRJL9EyA9ID6UIkMgSiA7IDuSIkuUIkaT/SABQwAAgD8gOyBLlCJLID0gQZQiUpKT/SAC/eYBIjb9HwIhPSBA/RMgOyBBlCI7IEogPpQiQJP9E0MAAIA/IEsgRyA+lCJBkpP9IAEgQyBGkv0gAv3mASI3/R8BIkMgN/0fAiI+lCFLID/9E0MAAIA/IFIgQZKT/RMgOyBAkv0gASBNIEST/SAC/eYBIjj9HwEiRCA4/R8CIkCUIUEgN/0fACJHID6UIUYgOP0fACJKIECUIVMgA0EYbCAUaiIFQRFqLwAAIAVBE2otAAAiDkEQdHIiEEEIdiETIBBB/wFxBEAgSCBJIBBBAWtB/wFxs5SSEIkEIUwLQwAAAAAhO0MAAAAAIT8gE0H/AXEEQCBIIEkgE0EBa0H/AXGzlJIQiQQhPwsgDgRAIEggSSAOQQFrQf8BcbOUkhCJBCE7CyA2/R8BIk0gPZQgSyBBkpIhUiA2/R8AIksgPZQgRiBTkpIhU0MAAAAAIVRDAACAPyAFQRRqLwEAIg5BCHaz/RMgDiAFQRZqLQAAIhBBEHRyQf8BcbP9IAH9DAAAf0MAAH9DAAB/QwAAf0P95wEiNiA2/eQB/QwAAIC/AACAvwAAgL8AAIC//eQBIjb9HwEiTouTIDb9HwAiT4uTIkGMQwAAAAAQ4AghRiA9ID2UID4gPpQgQCBAlJKSIlZDAAAAPyA7/RMgELNDAAB/Q5VDAAAAP5RD2w9JQJQiUBCZAiI+IE4gRiBGjCI9IDb9DAAAAAAAAAAAAAAAAAAAAAD9Rv1NIjb9xwH9GwJBAXEbkiI7IEEgQZQgOyA7lCBPIEYgPSA2/RsAQQFxG5IiQCBAlJKSkSJGlZQiOyA+IEEgRpWUIkEgQZIiPZQiTyBQEJsCIk4gPiBAIEaVlCI+ID6SIkCUIkaS/RMgPiA9lCJQIE4gOyA7kiJRlCJVk/0gAUMAAIA/IDsgUZQiUSA+IECUIj6Sk/0gAv3mASI2IDb95gEgP/0TIDsgQJQiOyBOID2UIj+T/RNDAACAPyBRIEEgPZQiPZKT/SABIFAgVZL9IAL95gEiNyA3/eYBIEz9E0MAAIA/ID4gPZKT/RMgOyA/kv0gASBPIEaT/SAC/eYBIjggOP3mAf3kAf3kASI5IDb9HwIiPSA9lCA3/R8CIkYgRpQgOP0fAiJMIEyUkpIiTv0gAiA2/R8AIj8gNv0fASJPlCA3/R8AIlAgN/0fASJRlCA4/R8AIlUgOP0fASJXlJKSIlj9IAP9DAAAAD8AAAA/AAAAPwAAAD/95gEiNv0fAhC0BiE+IE0gTZQgQyBDlCBEIESUkpIiWUMAAAA/IDb9HwEQtAYhQCBLIEuUIEcgR5QgSiBKlJKSIlpDAAAAPyA2/R8AELQGIkGLIECLEOAIID6LEOAIIjsgOyA7lJRDYEKiDRDgCCFbIEsgTZQgRyBDlCBKIESUkpIiQ0MAAAA/IDb9HwMQtAYhOyBTQwAAAD8gPyA9lCBQIEaUIFUgTJSSkiJHQwAAAD+UELQGIj8gOyBSQwAAAD8gTyA9lCBRIEaUIFcgTJSSkiJKQwAAAD+UELQGIj2UID8gQJSTIk2UIEEgQCA+lCA9ID2UkyJLlCA7ID4gO5QiRiA/ID2UIkyTlJOSIkSLIFtDX3CJMJRdRQRAIEQgU/0TIEf9IAEiNyBD/RMgWP0gASI4IFL9EyBK/SABIjb95gEgNyA5IFn9IAAiOv3mAf3lAf3mASBa/RMgOf0NAAECAxAREhMAAQIDAAECAyA6IFb9EyBO/SABIjn95gEgNiA2/eYB/eUB/eYBIDggOSA4/eYBIDcgNv3mAf3lAf3mAf3lAf3kASI2/R8AIDb9HwGUkZUQxgVDAAAAP5QgBf0AAgAgBP0AAgD95QEiNv0fAiJDID8gO5QgPSBBlJNDAACAPyBElSI9lCJEIESSIDb9HwEiRJSUIEMgTSA9lCJHIEeSIDb9HwAiR5SUIEQgTCBGkyA9lCJKIEqSIEeUlCBDIEMgQSBAlCA7IDuUkyA9lJSUIEcgRyBLID2UlJQgRCBEIEEgPpQgPyA/lJMgPZSUlJKSkpKSQwAAAD6UkiFUCyBFIARBEGotAAAiDrNDAAB/Q5UgQpSS/RMgRSAEQQ5qLwEAIhAgDkEQdHJB/wFxs0MAAH9DlSBClJL9IAAgRSAQQQh2s0MAAH9DlSBClJL9IAEgRSBCIAVBEGotAAAiDrNDAAB/Q5WUkv0TIEUgQiAFQQ5qLwEAIgUgDkEQdHJB/wFxs0MAAH9DlZSS/SAAIEUgQiAFQQh2s0MAAH9DlZSS/SAB/eUBIjYgNv3mASI2IDb9DQgJCgsAAQIDAAECAwABAgMgNiA2IDb9DQQFBgcAAQIDAAECAwABAgP95AH95AH9HwCMEIkEIFSMEIkElCI7QwAAAAAgOyA7WxsiOyA8XkUNACAaIScgISEmIB8hJSA7ITwgAyELCyAGQQRqIQYgB0EEayIHDQALCyAaICBZDQMgGyIaICBVDQMMAQsLIAMgDEGc6MEAEIwHAAsgAyAJQdy7xwAQjAcACyAeICFXDQEgGSAeVw0ACwsgHyAqUyIDBEAgHyADrXwiHyAqVw0BCwsgC0F/Rw0BCyACKgK4ASE8IAIoArABIgMgAigCqAFGBEAgAkGoAWpBvOfBABD5BQsgAigCrAEgA0EDdGoiBCANNgIEIAQgPDgCACACIANBAWo2ArABDAcLIAIgCzYC5AIgAiANNgLgAiAAIAJB4AJqQQJDAAAAABBDIRAgEkEAOgAAIAIoAlxFDQMgAigCVCIFIAIpA2ggI4UiGULYotHvwqnlvy1+IBlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhIUgKIUiGULYotHvwqnlvy1+IBlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhIUgIoUiGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhELSgaqbq/qC16d/fiIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEIBlC2KLR78Kp5b8tfoUiGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhCACKQNgIhpCf4V+IhxCOIYgHEKA/gODQiiGhCAcQoCA/AeDQhiGIBxCgICA+A+DQgiGhIQgHEIIiEKAgID4D4MgHEIYiEKAgPwHg4QgHEIoiEKA/gODIBxCOIiEhIQgGSAaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEfoUgGYkiGadxIQMgGUIZiEL/AINCgYKEiJCgwIABfiEcQQAhBCACKAJQIQYDQAJAIAMgBmopAAAiGiAchSIZQn+FIBlCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiGVBFBEADQAJAICMgBiAZeqdBA3YgA2ogBXFBBnRrIg5BQGopAwBSDQAgKCAOQThrKQMAUg0AICIgDkEwaykDAFENAwsgGUIBfSAZgyIZUEUNAAsLIBogGkIBhoNCgIGChIiQoMCAf4NQRQ0FIAMgBEEIaiIEaiAFcSEDDAELCyAOQQRrIhMoAgAiAyEJIANBCU8EQCAOQSRrKAIAIQkLIAlFBEBBACEIDAYLIA5BIGshEiAOQSRrIQpBACEFQQAhCEEAIQMDQCATKAIAIgYhBCAKIQcgBkEJSSIURQRAIAcoAgAhBCASKAIAIQcLAkACQCADIARJBEAgDSAFIAdqKAIARgRAIAhBAWohCAwDCyAIRQRAQQAhCAwDCyAKIQQgFEUEQCAEKAIAIQYgEigCACEECyADIAhrIgcgBk8NASADIAZJBEAgBCAFIAhBAnRraiIGKAIAIQcgBiAEIAVqIgQoAgA2AgAgBCAHNgIADAMLIAMgBkHopMEAEIwHAAsgAyAEQdikwQAQjAcACyAHIAZB6KTBABCMBwALIAVBBGohBSADQQFqIgMgCUcNAAsMBAsgDSAJQdy7xwAQjAcACyANIAxBrOfBABCMBwALIAIgAi8BPkEBajsBPiACQcQAaiACQagBahCUAiACKAJAIgQgAigCLCIJSQ0EIAIoAkxBAUsNBCACIAAoAghBAWs2AtwBIAJBATYC5AIgAkH45MEANgLgAiACQgE3AuwCIAIgAkHcAWqtQoCAgIAQhDcDoAIgAiACQaACajYC6AIgAkGwAmogAkHgAmoQsQYgAigCsAIiAwRAIAIoArQCIANBARCiBwsCQAJAAkAgAigC3AEiAyAAKAIIIgRJBEAgAiAPNgKkAiACQQE2AuQCIAJBuOjBADYC4AIgAkIBNwLsAiACIAAoAgQgA0EYbGo2AqACIAIgAkGgAmqtQoCAgICAAoQ3A/ABIAIgAkHwAWo2AugCIAJBsAJqIAJB4AJqELEGIAIoArACIgMEQCACKAK0AiADQQEQogcLIAJBIGogACgCCEEBdEEBaxDkB0EAIQUgAkEANgLoASACIAIpAyA3AuABIAJB4AFqIgMgAigCLEEBEMQGIAMgACgCCEEAEMQGIAIoAtwBIgQgAigC6AEiCk8NAiACKALkASIJIARqQQE6AAAgAkHgAmogACACKALcASADIAEQ9wFBACEGAkAgCkEETwRA/QwAAAAAAAAAAAAAAAAAAAAAITYgCSEDIApBfHEiBiEFA0AgNiAD/VwAAP2JAf2pAf2uASE2IANBBGohAyAFQQRrIgUNAAsgNiA2IDb9DQgJCgsMDQ4PAAECAwABAgP9rgEiNiA2IDb9DQQFBgcAAQIDAAECAwABAgP9rgH9GwAhBSAGIApGDQELIAYgCWohAyAKIAZrIQYDQCAFIAMtAABqIQUgA0EBaiEDIAZBAWsiBg0ACwsgAigCiAMhCyACKALsAiEMIAIgBTYC7AEgAiAAKAIINgLwASACQQI2AuQCIAJB7OjBADYC4AIgAkICNwLsAiACICk3A7gCIAIgAkHsAWqtQoCAgIAQhCIZNwOwAiACIAJBsAJqNgLoAiACQaACaiACQeACahCxBiACKAKgAiIDBEAgAigCpAIgA0EBEKIHCyACQQE2AuQCIAJBkOnBADYC4AIgAkIBNwLsAiACIC1CgICAgNABhDcDoAIgAiACKALsAbMgAigCLLOVOALwASACIAJBoAJqNgLoAiACQbACaiACQeACahCxBiACKAKwAiIDBEAgAigCtAIgA0EBEKIHCyACQQA2AvgBIAJCgICAgMAANwLwASACKALcASEDIAJB8AFqQZjpwQAQiwYgAigC9AEgAzYCACACQQE2AvgBIAIoAtwBIgMgACgCCCIETw0BIAIgACgCBCADQRhsaiIDLQATIgQgAy0AEiIFIAMtABEiBiAFIAZLGyIFIAQgBUsbIgQEfUMAAEDBIA8qAgggDy0AHEECRiIFGyIBQwAAEEEgDyoCDCAFGyABk0MAAH5DlSAEQQFrQf8BcbOUkhCJBCIBIAGSBUMAAAAACwJ/IANBDGovAQAiBEH//wFxRQRAIARBEHQMAQsgBEH/B3EhAyAEQYCAAnEhBSAEQYD4AXEiBEGA+AFGBEAgBUEQdCIEQYCAgPwHciADRQ0BGiAEIANBDXRyQYCAgP4HcgwBCyAFQRB0IgUgBEENdEGAgID8AHEgA0ENdHJBgICAwANqciAEDQAaIAMgA2dBEGsiA0H//wNxQQhqdEH///8DcSAFQYCAgNgDciADQRd0a3ILviIBQwAAgD9eBH0gARDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlDgCgAJBBBBxIgVFDQsgBSACKALcATYCACACQZACaq1CgICAgBCEIRogAkGAAmqtQoCAgIDQAYQhHEEBIQZBASEEA0AgAiAGNgKQAiACIBo3A7gCIAIgHDcDsAIgAkICNwLsAiACQQI2AuQCIAJB0OnBADYC4AIgAiACQbACajYC6AIgAkGgAmogAkHgAmoQ7AMgAigCoAIiAwRAIAIoAqQCIgdBBGsoAgAiCEF4cSINQQRBCCAIQQNxIggbIANqSQ0QIAhBACANIANBJ2pLGw0RIAcQogILQQAhAyACQQA2AugCIAJCgICAgMAANwLgAiAGQQJ0IQYDQCAAIAMgBWooAgAgAkHwAWogAioCgAIgAkHgAmoQywEgBiADQQRqIgNHDQALAkAgAigC6AIiBkUEQCACKALgAiIDBEAgAigC5AIgA0ECdEEEEKIHCyACIAIoAvgBIgc2AoQCIAcgAigC7AFGDQEgAkEANgLgAkEAIAJBhAJqIAJB7AFqIAJB4AJqQeDpwQAQ9QcACyACIAIqAoACQwAAgD6UOAKAAiACKALkAiACKALgAiEHIAQEQCAFQQRrKAIAIghBeHEiDSAEQQJ0IgRBBEEIIAhBA3EiCBtqSQ0RIAhBACANIARBJ2pLGw0SIAUQogILIQUgByEEDAELCyAJQQFqIQggCSAKaiENQQAhBiAJIQMDQCADLQAARQRAIAIoAvABIAdGBEAgAkHwAWpB3OrBABCLBgsgAigC9AEgB0ECdGogBjYCACACIAdBAWoiBzYC+AELIAgiAyANRyADaiEIIAogBkEBaiIGRw0ACyAAIAIoAvQBIAcQiQIgACACKALsARCIBSACQQE2AuQCIAJBjOrBADYC4AIgAkIBNwLsAiACIBk3A6ACIAIgAkGgAmo2AugCIAJBsAJqIAJB4AJqELEGIAIoArACIgMEQCACKAK0AiADQQEQogcLIAIgACgCCCIKBHxCACEZQQAhBkEAIQcDQCACQeACaiAAKAIQIAAoAhQgBhDnAiACKAKEAyIDQQhLBEAgAigC6AIiCEEEaygCACINQXhxIg4gA0ECdCIQQQRBCCANQQNxIg0bakkNESACKALkAiEDIA1BACAOIBBBJ2pLGw0GIAgQogILIAcgA0EAR2ohByAZIAOtfCEZIAogBkEBaiIGRw0ACyAZuiAHt6MFRAAAAAAAAPh/CzkDiAIgAkEBNgLkAiACQbzqwQA2AuACIAJCATcC7AIgAiACQYgCaq1CgICAgPAChDcDoAIgAiACQaACajYC6AIgAkGwAmogAkHgAmoQsQYgAigCsAIiAwRAIAIoArQCIANBARCiBwsgAkHgAmogACgCECAAKAIUQQAQ5wIgAiACKAKEAyIDQQlJIgYEfyADBSACKALkAgs2ApwCIAJBATYCtAIgAkHU6sEANgKwAiACQgE3ArwCIAIgAkGcAmqtQoCAgIAQhDcDkAIgAiACQZACajYCuAIgAkGgAmogAkGwAmoQsQYgBkUEQCACKALoAiADQQJ0QQQQogcLIAIoAqACIgMEQCACKAKkAiADQQEQogcLIAQEQCAFIARBAnRBBBCiBwsgAigC8AEiAwRAIAIoAvQBIANBAnRBBBCiBwsgC0EJTwRAIAwgC0ECdEEEEKIHCyACKALgASIDBEAgCSADQQEQogcLIAJB0ABqEL4EIAIoAkQiAwRAIAIoAkggA0EDdEEEEKIHCyACKAIwIgNFDQogESADQQEQogcMCgsgAyAEQdy7xwAQjAcACyADIARB3LvHABCMBwALIAQgCkHQ6MEAEIwHAAsMCwtBzOfBABDdCQALIBMoAgAhAwsgCSAIayIEIA5BJGsgEyADQQhLGyIDKAIASQRAIAMgBDYCAAsCQAJAAkACQCALIAxJBEAgCyARakEAOgAAIAIoAlxFDQIgAigCVCIFIAIpA2ggJ4UiGULYotHvwqnlvy1+IBlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhIUgJoUiGULYotHvwqnlvy1+IBlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIRC0oGqm6v6gtenf34iGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhIUgJYUiGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhELSgaqbq/qC16d/fiIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEIBlC2KLR78Kp5b8tfoUiGUI4hiAZQoD+A4NCKIaEIBlCgID8B4NCGIYgGUKAgID4D4NCCIaEhCAZQgiIQoCAgPgPgyAZQhiIQoCA/AeDhCAZQiiIQoD+A4MgGUI4iISEhCACKQNgIhpCf4V+IhxCOIYgHEKA/gODQiiGhCAcQoCA/AeDQhiGIBxCgICA+A+DQgiGhIQgHEIIiEKAgID4D4MgHEIYiEKAgPwHg4QgHEIoiEKA/gODIBxCOIiEhIQgGSAaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEfoUgGYkiGadxIQMgGUIZiEL/AINCgYKEiJCgwIABfiEcQQAhBCACKAJQIQYDQCADIAZqKQAAIhogHIUiGUJ/hSAZQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIhlQRQRAA0ACQCAnIAYgGXqnQQN2IANqIAVxQQZ0ayINQUBqKQMAUg0AICYgDUE4aykDAFINACAlIA1BMGspAwBRDQULIBlCAX0gGYMiGVBFDQALCyAaIBpCAYaDQoCBgoSIkKDAgH+DUEUNAyADIARBCGoiBGogBXEhAwwACwALIAsgDEHc58EAEIwHAAsgDUEEayIOKAIAIgMhCSADQQlPBEAgDUEkaygCACEJCyAJRQRAQQAhCAwDCyANQSBrIRMgDUEkayEKQQAhBUEAIQhBACEDA0AgDigCACIGIQQgCiEHIAZBCUkiEkUEQCAHKAIAIQQgEygCACEHCwJAAkAgAyAESQRAIAsgBSAHaigCAEYEQCAIQQFqIQgMAwsgCEUEQEEAIQgMAwsgCiEEIBJFBEAgBCgCACEGIBMoAgAhBAsgAyAIayIHIAZPDQEgAyAGSQRAIAQgBSAIQQJ0a2oiBigCACEHIAYgBCAFaiIEKAIANgIAIAQgBzYCAAwDCyADIAZB6KTBABCMBwALIAMgBEHYpMEAEIwHAAsgByAGQeikwQAQjAcACyAFQQRqIQUgA0EBaiIDIAlHDQALDAELQeznwQAQ3QkACyAOKAIAIQMLIAkgCGsiBCANQSRrIA4gA0EISxsiAygCAEkEQCADIAQ2AgALIAIoAjAgDEYEfyACQTBqEKYGIAIoAjQFIBELIAxqQQE6AAAgAiAMQQFqNgI4An8CQCAAKAIIIgMgEEsEQCAAKAIEIBBBGGxqIgQtABMiAyAELQASIgUgBC0AESIGIAUgBksbIgUgAyAFSxsiAwR9QwAAQMEgACoCRCAALQBYQQJGIgUbIjxDAAAQQSAAKgJIIAUbIDyTQwAAfkOVIANBAWtB/wFxs5SSEIkEIjwgPJIFQwAAAAALITwgBEEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEDIAVBgIACcSEGIAVBgPgBcSIFQYD4AUYEQCAGQRB0IgVBgICA/AdyIANFDQMaIAUgA0ENdHJBgICA/gdyDAMLIAZBEHQhBiAFRQ0BIAVBDXRBgICA/ABxIANBDXRyQYCAgMADaiAGcgwCCyAQIANB3LvHABCMBwALIAMgA2dBEGsiA0H//wNxQQhqdEH///8DcSAGQYCAgNgDciADQRd0a3ILIQMgPCADviI8QwAAgD9eBH0gPBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlCI8IAIqAoABIjteRQRAIAIgBP0AAgAgNv0NAAECAwQFBgcICQoLCAkKCyA7/RP95wH9aCI2/R8C/AQ3A9ABIAIgNv0fAfwENwPIASACIDb9HwD8BDcDwAEgAkHgAmogAkHQAGogAkHAAWoQhwICQCACKAKAAyIEBEAgAkG4AmogFUEIav0AAwD9CwMAIAIgFSkDADcDsAIgBCgCACIDIAQoAgQiBSACKALgAiIJcSIGaikAAEKAgYKEiJCgwIB/gyIZUARAQQghBwNAIAYgB2ohBiAHQQhqIQcgAyAFIAZxIgZqKQAAQoCBgoSIkKDAgH+DIhlQDQALCyADIBl6p0EDdiAGaiAFcSIGaiwAACIHQQBOBEAgAyADKQMAQoCBgoSIkKDAgH+DeqdBA3YiBmotAAAhBwsgAyAGaiAJQRl2Igk6AAAgBCAEKAIIIAdBAXFrNgIIIAMgBkEIayAFcWpBCGogCToAACADIAZBBnRrIgNBQGoiBUEQaiACQcACaikDADcDACAFIAL9AAOwAv0LAwAgA0EEa0EANgIAIANBKGtBADYCACAEIAQoAgxBAWo2AgwMAQsgAigC4AIhAwsgA0EkayEHAn8gA0EEayIFKAIAIgRBCUkEQCAEIQZBCCEEIAcMAQsgBygCACEGIAchBSADQSBrKAIACyEIIAQgBkYEQCADQShrEM0GIANBIGsoAgAhCCAHKAIAIQYgByEFCyAIIAZBAnRqIBA2AgAgBSAFKAIAQQFqNgIAIAJBxABqIDyMIBAQ8QQMAQsgAigCsAEiAyACKAKoAUYEQCACQagBakGM6MEAEPkFCyACKAKsASADQQN0aiIEIBA2AgQgBCA8jDgCACACIANBAWo2ArABDAALAAsACwwECyAAKAIIIgsEQEEMIQZBACEFA0ACQAJ/AkACQAJ/AkACQCAAKAIIIgMgBUsEQCAAKAIEIAZqIggvAQAiBEH//wFxIgxFDQEgBEH/B3EhAyAEQYCAAnEhByAEQYD4AXEiCUGA+AFHIg1FBEAgB0EQdCIKQYCAgPwHciADRQ0EGiAKIANBDXRyQYCAgP4HcgwECyAHQRB0IQogCUUNAiAJQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogCnIMAwsgBSADQey7xwAQjAcACyAEQRB0vkMAAIA/Xg0CDAULIAMgA2dBEGsiDkH//wNxQQhqdEH///8DcSAKQYCAgNgDciAOQRd0a3ILvkMAAIA/XkUNAyAMDQELIARBEHQMAQsgDUUEQCAHQRB0IgRBgICA/AdyIANFDQEaIAQgA0ENdHJBgICA/gdyDAELIAdBEHQiBCAJQQ10QYCAgPwAcSADQQ10ckGAgIDAA2pyIAkNABogAyADZ0EQayIDQf//A3FBCGp0Qf///wNxIARBgICA2ANyIANBF3RrcgtDAACAPyE8viIBQwAAgD9eBEAgARDGBUNU+C1AlEMAAIA/kpFDAACAv5JDAACAPpRDAACAP5IhPAtDAAAAQEMAAIA/IDwgPEMAAIA/XRsiASABQwAAAEBeG7wiB0H///8DcSEJIAdBgICAgHhxIQQCQCAHQYCAgPwHcSIDQYCAgPwHRgRAIAlBDXYgBEEQdnJBgARBACAJG3JBgPgBciEEDAELIARBEHYhBCADQYCAgLgETQRAIANBgICAxANPBEAgB0EMdiAHQf/fAHFBAEdxIANBDXYgCUENdmpBgIABaiAEcmohBAwCCyADQYCAgJgDSQ0BIAlBgICABHIiB0H+ACADQRd2IglrdiEDIAdBHSAJayIJdkEBcQR/IANBAyAJdEEBayAHcUEAR2oFIAMLIARyIQQMAQsgBEGA+AFyIQQLIAggBDsBAAsgBkEYaiEGIAsgBUEBaiIFRw0ACwsgAkEANgKoAiACQoCAgIDAADcCoAIgAkGgAmpBqMHBABCLBiACKAKkAkEANgIAQQEhBSACQQE2AqgCIAJCgICAgMAANwLAASACQgA3AsgBQQQQcSIDRQ0AIANBADYCACACQcABakG4wcEAEKQGIAIoAsQBIAIoAswBIgYgAigCyAFqIgQgAigCwAEiB0EAIAQgB08ba0EMbGoiBEEBNgIIIAQgAzYCBCAEQQE2AgAgAiAGQQFqNgLMASACKALMASIDRQ0CIAJB8AFqrUKAgICAEIQhISACQeABaq0iGUKAgICAEIQhJCACQdAAaq1CgICAgJAChCEfIAJBtAFqrUKAgICA0AGEISUgAkGwAmqtQoCAgICgAoQhJiACQagBaq1CgICAgLAChCEnIBlCgICAgNABhCEbIAJBnANqIRUgAkHoAmohDSACQeQCaiEKIAJBuAJqIQ4gAkHUAGohEyACQYQDaiEQAkADQCACIANBAWs2AswBIAIgAigCyAEiA0EBaiIEIAIoAsABIgVBACAEIAVPG2s2AsgBIAIoAsQBIANBDGxqIgMoAgAiC0GAgICAeEYNAyADKQIEIRkgAkEANgKYASACQoCAgIDAADcCkAEgGachBSAZQh6Ip0H8////B3EiAwRAIAMgBWohEUEAIQlBBCEGIAUhDANAIAkhA0MAAIA/ITwCfwJAIAwoAgAiByAAKAIIIgRJBEAgACgCBCAHQRhsaiIELQATIgkgBC0AEiIIIAQtABEiDyAIIA9LGyIIIAggCUkbIgkEfUMAAEDBIAAqAkQgAC0AWEECRiIIGyIBQwAAEEEgACoCSCAIGyABk0MAAH5DlSAJQQFrQf8BcbOUkhCJBCIBIAGSBUMAAAAACyEBIARBDGovAQAiCUH//wFxRQRAIAlBEHQMAwsgCUH/B3EhBCAJQYCAAnEhCCAJQYD4AXEiCUGA+AFGBEAgCEEQdCIJQYCAgPwHciAERQ0DGiAJIARBDXRyQYCAgP4HcgwDCyAIQRB0IQggCUUNASAJQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogCHIMAgsgByAEQdy7xwAQjAcACyAEIARnQRBrIgRB//8DcUEIanRB////A3EgCEGAgIDYA3IgBEEXdGtyC74iO0MAAIA/XgRAIDsQxgVDVPgtQJRDAACAP5KRITwLIAIoApABIANGBEAgAkGQAWpByJXBABD5BSACKAKUASEGCyAGIANBA3RqIgQgBzYCBCAEIAEgPJQiATgCACACIANBAWoiCTYCmAECQCADRQRAQQAhBAwBCyABIAFcBEADQAJAIAYgA0EBayIPQQF2IgRBA3RqIggqAgAiPCA8WyABIDxfRXENACAHIAhBBGooAgBLDQAgAyEEDAMLIAYgA0EDdGogCCkCADcCACAEIQMgD0ECTw0ADAILAAsDQCAGIANBAWsiD0EBdiIEQQN0aiIIKgIAIjwgPFsgASA8X0VxQX8gASA8YBsiEkEATCAHIAhBBGooAgBNIBIbBEAgAyEEDAILIAYgA0EDdGogCCkCADcCACAEIQMgD0EBSw0ACwsgBiAEQQN0aiIDIAc2AgQgAyABOAIAIAxBBGoiDCARRw0ACwsgCwRAIAVBBGsoAgAiA0F4cSIEIAtBAnQiBkEEQQggA0EDcSIDG2pJDQYgA0EAIAQgBkEnaksbDQcgBRCiAgsCQAJAAkAgAigCmAEiDEUNACACKAKoAkH/vwRqQYCA/P8DcSERA0AgAiAMQQFrIgQ2ApgBIAIoApQBIgcgBEEDdGoiAygCBCEFIAMqAgAhAQJAIARFBEAgASE8IAUhCQwBCyAHKAIEIQkgByAFNgIEIAcqAgAhPCAHIAE4AgBBACEDQQEhBiAMQQRPBEAgBEECayIDQQAgAyAETRshC0EAIQQDQCAHIARBA3RqIAcgBiAHIAZBA3RqIgNBCGoqAgAiOyA7WyA7IAMqAgAiRWBFcSIEIARBfyA7IEVfGyBFIEVcGyIEQQBMIANBBGooAgAgA0EMaigCAE0gBBtqIgNBA3RqKQIANwIAIANBAXQiCEEBciEGIAMhBCAIIAtJDQALCwJAAkAgDEECayAGRgRAIAcgA0EDdGogByAGQQN0aiIDKQIANwIAIAMgBTYCBCADIAE4AgAgBiEDDAELIAcgA0EDdGoiBCAFNgIEIAQgATgCACADDQBBACEEDAELIAEgAVwEQANAAkAgByADQQFrIgtBAXYiBEEDdGoiBioCACI7IDtbIAEgO19FcQ0AIAUgBkEEaigCAEsNACADIQQMAwsgByADQQN0aiAGKQIANwIAIAQhAyALQQJPDQAMAgsACwNAIAcgA0EBayILQQF2IgRBA3RqIgYqAgAiOyA7WyABIDtfRXFBfyABIDtgGyIIQQBMIAUgBkEEaigCAE0gCBsEQCADIQQMAgsgByADQQN0aiAGKQIANwIAIAQhAyALQQFLDQALCyAHIARBA3RqIgMgBTYCBCADIAE4AgALIAJBsAJqIAAoAhAgACgCFCAJEOcCIAIoAqgCIQMCQAJAIAIoAtQCIgRBCUkiBUUEQCACKAK0AiADaiIIIBFLDQEMAgsgAyAEaiIIIBFNDQELIAJBkAFqIDwgCRDxBCACIBs3A/ABIAIgA7NDAACAN5Q4AuABIAJCATcC7AIgAkEBNgLkAiACQfjBwQA2AuACIAIgAkHwAWo2AugCIAJB0ABqIAJB4AJqEOwDIAIoAlAiAwRAIAIoAlQiBkEEaygCACIHQXhxIglBBEEIIAdBA3EiBxsgA2pJDQsgB0EAIAkgA0EnaksbDQwgBhCiAgsgBUUEQCACKAK4AiIDQQRrKAIAIgVBeHEiBiAEQQJ0IgRBBEEIIAVBA3EiBRtqSQ0LIAVBACAGIARBJ2pLGw0MIAMQogILIAIoApgBIgNFDQJDAAAQQSAAKgJIIAAtAFhBAkYiBBtDAABAwSAAKgJEIAQbIjyTQwAAfkOVIUUgAigClAEiBCADQQN0IgZqIQwgACgCBCERIAAoAgghB/0MAACA/wAAgP8AAID/AACA/yE3/QwAAIB/AACAfwAAgH8AAIB/IThBACEFAkACQAJAAkACQANAIAQgBWpBBGooAgAiAyAHTw0BIBEgA0EYbGoiA0ERai8AACADQRNqLQAAIglBEHRyIgtBCHYhCEMAAAAAITtDAAAAACE/IAtB/wFxBEAgPCBFIAtBAWtB/wFxs5SSEIkEIT8LIAhB/wFxBEAgPCBFIAhBAWtB/wFxs5SSEIkEITsLIAkEfSA8IEUgCUEBa0H/AXGzlJIQiQQFQwAAAAALIT1DAACAPyADQRRqLwEAIglBCHaz/RMgCSADQRZqLQAAIgtBEHRyQf8BcbP9IAH9DAAAf0MAAH9DAAB/QwAAf0P95wEiNiA2/eQB/QwAAIC/AACAvwAAgL8AAIC//eQBIjb9HwEiPouTIDb9HwAiQIuTIkKMQwAAAAAQ4AghASALs0MAAH9DlUMAAAA/lEPbD0lAlCJJEJkCIUggSRCbAiFJIDcgA/0AAgAgNv0NAAECAwQFBgcICQoLCAkKCyI5ID39EyA//SAAIDv9IAH9DG8SgzpvEoM6bxKDOm8Sgzr96wH9DAAAwD8AAMA/AADAPwAAwD/95gEiNyA2/Q0ICQoLCAkKCwgJCgsAAQIDQwAAgD8gSCA+IAEgAYwiPyA2/QwAAAAAAAAAAAAAAAAAAAAA/Ub9TSI2/ccB/RsCQQFxG5IiOyBCIEKUIDsgO5QgQCABID8gNv0bAEEBcRuSIjsgO5SSkpEiP5WUIgEgASABkiI+lCJAIEggOyA/lZQiOyA7IDuSIj2UIkGSk/0TIAEgSCBCID+VlCJIIEiSIkKUIj8gSSA9lCJDkv0gACA7IEKUIjsgSSA+lCI+k/0gAf3gAf3mASA3IDb9DQQFBgcEBQYHBAUGBwABAgMgOyA+kv0TIAEgPZQiASBJIEKUIjuT/SAAQwAAgD8gQCBIIEKUIkKSk/0gAf3gAf3mASA3IDb9DQABAgMAAQIDAAECAwABAgMgPyBDk/0TQwAAgD8gQSBCkpP9IAAgASA7kv0gAf3gAf3mAf3kAf3kASI2/eQB/esBITcgOCA5IDb95QH96gEhOCAGIAVBCGoiBUcNAAsgNyA4/eUBIjYgNiA2/Q0ICQoLCAkKCwABAgMAAQID/esBIjkgOSA2/Q0EBQYHAAECAwABAgMAAQID/esB/R8AIDYgNiA2/Q0ICQoLCAkKCwQFBgcEBQYH/eoBIjkgOSA2/Q0EBQYHAAECAwABAgMAAQID/eoB/R8AQwAAQECUYEUEQCACQgQ3AugDIAJCADcC4AMgAkKAgICAwAA3AtgDIAJCBDcC0AMgAkIANwLIAyACQoCAgIDAADcCwAMgAkIENwK4AyACQgA3ArADIAJCgICAgMAANwKoAyACQgQ3AqADIAJCADcCmAMgAkKAgICAwAA3ApADIDggN/3kAf0MAAAAPwAAAD8AAAA/AAAAP/3mASI2/R8AIQEgNv0fAiE8IDb9HwEhO0EAIQMgAigCkAEhBwNAIAMgBGpBBGooAgAiBSAAKAIIIglPDQMgAkGQA2ogFSAAKAIEIAVBGGxqIgkqAgAgAV0bQQBBGCAJKgIEIDtdG2oiC0EIQTggCSoCCCA8XSIJG2oiDCgCACIIIAtBAEEwIAkbaiIRKAIARgRAIBFBsMLBABCLBgsgC0EEQTQgCRtqKAIAIAwgCEEBajYCACAIQQJ0aiAFNgIAIAYgA0EIaiIDRw0ACyAHBEAgBEEEaygCACIDQXhxIgUgB0EDdCIGQQRBCCADQQNxIgMbakkNESADQQAgBSAGQSdqSxsNEiAEEKICC0EgEHEiA0UNDSADIAIoApgDNgIAIAMgAigCpAM2AgQgAyACKAKwAzYCCCADIAIoArwDNgIMIAMgAigCyAM2AhAgAyACKALUAzYCFCADIAIoAuADNgIYIAMgAigC7AM2AhwgAkEINgJYIAIgAzYCVCACQQg2AlAgAiAfNwOwAiACQgE3AuwCIAJBAjYC5AIgAkGQwsEANgLgAiACIAJBsAJqNgLoAiACQeACahDrAiACKAJQIgMEQCACKAJUIgRBBGsoAgAiBUF4cSIGIANBAnQiA0EEQQggBUEDcSIFG2pJDREgBUEAIAYgA0EnaksbDQQgBBCiAgtB4AAQcSIDRQ0NIAMgAkGQA2pB4AD8CgAAIAMoAgAhBCADQYCAgIB4NgIAIARBgICAgHhGDQQgA0EEaiISKQIAIRkgAygCDCEHIANBgICAgHg2AgwgB0GAgICAeEYNBCADKQIQIRogAygCJCEJIANBgICAgHg2AiQgCUGAgICAeEYNBCADKQIoIRwgAygCGCELIANBgICAgHg2AhggC0GAgICAeEYNBCADKQIcIR4gAygCSCEIIANBgICAgHg2AkggCEGAgICAeEYNBCADKQJMIR0gAygCVCEMIANBgICAgHg2AlQgDEGAgICAeEYNBCADKQJYISAgAygCPCERIANBgICAgHg2AjwgEUGAgICAeEYNBCADKQJAISIgAygCMCEPIANBgICAgHg2AjAgD0GAgICAeEYNBCADKQI0ISMgAigCzAEiBSACKALAASIGRgRAIAJBwAFqQaDCwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIUIAZBACAGIBRNG2tBDGxqIgYgGTcCBCAGIAQ2AgAgAiAFQQFqIgU2AswBIAIoAsABIgYgBUYEQCACQcABakGgwsEAEKQGIAIoAsABIQYgAigCzAEhBQsgAigCxAEgAigCyAEgBWoiBCAGQQAgBCAGTxtrQQxsaiIEIBo3AgQgBCAHNgIAIAIgBUEBaiIFNgLMASACKALAASIGIAVGBEAgAkHAAWpBoMLBABCkBiACKALAASEGIAIoAswBIQULIAIoAsQBIAIoAsgBIAVqIgQgBkEAIAQgBk8ba0EMbGoiBCAcNwIEIAQgCTYCACACIAVBAWoiBTYCzAEgAigCwAEiBiAFRgRAIAJBwAFqQaDCwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIEIAZBACAEIAZPG2tBDGxqIgQgHjcCBCAEIAs2AgAgAiAFQQFqIgU2AswBIAIoAsABIgYgBUYEQCACQcABakGgwsEAEKQGIAIoAsABIQYgAigCzAEhBQsgAigCxAEgAigCyAEgBWoiBCAGQQAgBCAGTxtrQQxsaiIEIB03AgQgBCAINgIAIAIgBUEBaiIFNgLMASACKALAASIGIAVGBEAgAkHAAWpBoMLBABCkBiACKALAASEGIAIoAswBIQULIAIoAsQBIAIoAsgBIAVqIgQgBkEAIAQgBk8ba0EMbGoiBCAgNwIEIAQgDDYCACACIAVBAWoiBTYCzAEgAigCwAEiBiAFRgRAIAJBwAFqQaDCwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIEIAZBACAEIAZPG2tBDGxqIgQgIjcCBCAEIBE2AgAgAiAFQQFqIgU2AswBIAIoAsABIgYgBUYEQCACQcABakGgwsEAEKQGIAIoAsABIQYgAigCzAEhBQsgAigCxAEgAigCyAEgBWoiBCAGQQAgBCAGTxtrQQxsaiIEICM3AgQgBCAPNgIAIAIgBUEBajYCzAEgAygCACIEQYCAgIB4ckGAgICAeEcEQCASKAIAIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCDCIEQYCAgIB4ckGAgICAeEcEQCADKAIQIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCGCIEQYCAgIB4ckGAgICAeEcEQCADKAIcIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCJCIEQYCAgIB4ckGAgICAeEcEQCADKAIoIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCMCIEQYCAgIB4ckGAgICAeEcEQCADKAI0IgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCPCIEQYCAgIB4ckGAgICAeEcEQCADKAJAIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCSCIEQYCAgIB4ckGAgICAeEcEQCADKAJMIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgAygCVCIEQYCAgIB4ckGAgICAeEcEQCADKAJYIgVBBGsoAgAiBkF4cSIHIARBAnQiBEEEQQggBkEDcSIGG2pJDREgBkEAIAcgBEEnaksbDRIgBRCiAgsgA0EEaygCACIEQXhxQeQAQegAIARBA3EiBRtJDRAgBUEAIARBiAFPGw0FIAMQogIMCQsgAiA4IDf95AH9DAAAAD8AAAA/AAAAPwAAAD/95gH9CwQAIAJBAEEBQQIgNv0fASIBIDb9HwIiPGAbIgMgPCA2/R8AIjtfGyADIAEgO18bIgM6AKgBIAIgAiADQQJ0cioCADgCtAEgAiAMNgJcIAIgAigCkAE2AlggAiAENgJUIAIgBDYCUCACIAA2ArQCIAIgAkG0AWo2ArgCIAIgAkGoAWo2ArACIAJB4AJqIgUgAkHQAGoiBiACQbACahCXBCACKQPgAiEcIAIpAuwCIRkgAigC9AIhAyACKALoAiEEIAIgNv0LBLACIAIgBDYC4AEgAiADNgLwASACQQY2AlQgAkHswsEANgJQIAJCBTcCXCACICE3A4ADIAIgJDcD+AIgAiAlNwPwAiACICY3A+gCIAIgJzcD4AIgAiAFNgJYIAYQ6wICQCADIARNBEAgGSEaIAMhBiAcIRkgBCEDDAELIBwhGiAEIQYLIAIgAzYC8AIgAkECNgLkAiACIAY2AvwCIAIgGTcC6AIgAiAaNwL0AkEBIQMCQCAZpyIEQYCAgIB4Rg0AIAIpAuwCIRkgAigCzAEiAyACKALAASIFRgRAIAJBwAFqQZzDwQAQpAYgAigCwAEhBSACKALMASEDCyACKALEASACKALIASADaiIGIAVBACAFIAZNG2tBDGxqIgUgGTcCBCAFIAQ2AgAgAiADQQFqNgLMAUECIQMgGqciBEGAgICAeEYNACACKQL4AiEZIAIoAswBIgUgAigCwAEiBkYEQCACQcABakGcw8EAEKQGIAIoAsABIQYgAigCzAEhBQsgAigCxAEgAigCyAEgBWoiByAGQQAgBiAHTRtrQQxsaiIGIBk3AgQgBiAENgIAIAIgBUEBajYCzAELIAIgAzYC4AIgAkHgAmoQlgYMCAsgAyAHQdy7xwAQjAcACyAFIAlB3LvHABCMBwALQYyNyABBLkG8jcgAEOsHDAkLQbzDwQAQ3QkACwwLC0EAIQYgAkEANgLgAiACQQA2AoQDQQghBwJAAkACfyAIIANrIgRBACAEIAhNGyIEQQlJBEAgCiELIBAMAQsgAkEYaiACQeACakF/IARBAWtndkEBahDoAyACKAIYIgRBgYCAgHhHBEAgBA0KQdiVxwBBEUHUzMcAEOsHAAsgAigChAMiB0EJSQRAIAchBiAKIQtBCCEHIBAMAQsgAigC5AIhBiACKALoAiELIAoLIg8gBiAHSQR/IAcgBkF/c2oiBCAIIAMgAyAISRsiEiADayIFIAQgBUkbQQFqIgRBBEsEQCALIAZBAnRqIQUgA/0R/QwAAAAAAQAAAAIAAAADAAAA/a4BITYgBCAEQQNxIgRBBCAEG2siDCEEA0AgBSA2/QsCACAFQRBqIQUgNv0MBAAAAAQAAAAEAAAABAAAAP2uASE2IARBBGsiBA0ACyAGIAxqIQYgAyAMaiEDCyALIAZBAnRqIQUDQCADIBJGDQIgBSADNgIAIAVBBGohBSADQQFqIQMgByAGQQFqIgZHDQALIAcFIAYLNgIAIAMgCE8NAQNAAn8gAigChAMiBEEJTwRAIAIoAuQCIQUgAigC6AIhByAKDAELIAQhBSAKIQdBCCEEIBALIQYgBCAFRgR/IAJB4AJqEM0GIAIoAugCIQcgCiEGIAIoAuQCBSAFC0ECdCAHaiADNgIAIAYgBigCAEEBajYCACADQQFqIgMgCEcNAAsMAQsgDyAGNgIACyACQfAAaiACQYADaikCADcDACACQeAAaiACQfACav0AAgD9CwMAIAIgAv0AAuAC/QsDUCACKAJ0IgshBSAAKAIQIAAoAhQgCSALQQlJIhIEfyATBSACKAJUIQUgAigCWAsgBRDUAiACKAK0AiEEIAIoArACIQMgDUEYaiAOQRhqKAIANgIAIA1BEGogDkEQaikCADcCACANIA79AAIA/QsCACACIAM2AuACIAIgBCACKALUAiIHIAdBCEsiAxsiCDYCjAMgAiAHQQAgAxs2AoQDIAJBACAEIAMbNgLkAiAIBEAgAigC6AIgCiADGyEUQQAhCSACKAKoAiEMA0AgAiAJIgNBAWoiCTYCiAMgFCADQQJ0aigCACEFIAIoAqACIAxGBEAgAkGgAmpByMHBABCLBgsgAigCpAIgDEECdGogBTYCACACIAxBAWoiDDYCqAJDAACAPyE8An8CQCAAKAIIIgMgBUsEQCAAKAIEIAVBGGxqIgMtABMiBCADLQASIgYgAy0AESIPIAYgD0sbIgYgBCAGSxsiBAR9QwAAQMEgACoCRCAALQBYQQJGIgYbIgFDAAAQQSAAKgJIIAYbIAGTQwAAfkOVIARBAWtB/wFxs5SSEIkEIgEgAZIFQwAAAAALIQEgA0EMai8BACIEQf//AXFFBEAgBEEQdAwDCyAEQf8HcSEDIARBgIACcSEGIARBgPgBcSIEQYD4AUYEQCAGQRB0IgRBgICA/AdyIANFDQMaIAQgA0ENdHJBgICA/gdyDAMLIAZBEHQhBiAERQ0BIARBDXRBgICA/ABxIANBDXRyQYCAgMADaiAGcgwCCyAFIANB3LvHABCMBwALIAMgA2dBEGsiA0H//wNxQQhqdEH///8DcSAGQYCAgNgDciADQRd0a3ILviI7QwAAgD9eBEAgOxDGBUNU+C1AlEMAAIA/kpEhPAsgAigCmAEiAyACKAKQAUYEQCACQZABakHIlcEAEPkFCyACKAKUASIGIANBA3RqIgQgBTYCBCAEIAEgPJQiATgCACACIANBAWo2ApgBAkAgA0UEQEEAIQQMAQsgASABXARAA0ACQCAGIANBAWsiFkEBdiIEQQN0aiIPKgIAIjwgPFsgASA8X0VxDQAgBSAPQQRqKAIASw0AIAMhBAwDCyAGIANBA3RqIA8pAgA3AgAgBCEDIBZBAk8NAAwCCwALA0AgBiADQQFrIhZBAXYiBEEDdGoiDyoCACI8IDxbIAEgPF9FcUF/IAEgPGAbIhdBAEwgBSAPQQRqKAIATSAXGwRAIAMhBAwCCyAGIANBA3RqIA8pAgA3AgAgBCEDIBZBAUsNAAsLIAYgBEEDdGoiAyAFNgIEIAMgATgCACAIIAlHDQALCyAHQQlPBEAgAigC6AIiA0EEaygCACIEQXhxIgUgB0ECdCIGQQRBCCAEQQNxIgQbakkNBCAEQQAgBSAGQSdqSxsNCyADEKICCyASRQRAIAIoAlgiA0EEaygCACIEQXhxIgUgC0ECdCIGQQRBCCAEQQNxIgQbakkNCiAEQQAgBSAGQSdqSxsNCyADEKICCyACKAKYASIMDQALCyACKAKQASIDRQ0AIAIoApQBIgRBBGsoAgAiBUF4cSIGIANBA3QiA0EEQQggBUEDcSIFG2pJDQcgBUEAIAYgA0EnaksbDQMgBBCiAgsgAigCzAEiAw0BDAQLCwwECwwECwALIAIoAqgCIQULIAIgACgCCCIDNgJQIAIgBTYCsAIgAyAFRwRAIAJBADYC4AJBACACQbACaiACQdAAaiACQeACakGsw8EAEPUHAAsgACACKAKkAiIAIAUQiQIgAkHAAWoQ6wMCQCACKAKgAiIDBEAgAEEEaygCACIEQXhxIgUgA0ECdCIDQQRBCCAEQQNxIgQbakkNAiAEQQAgBSADQSdqSxsNASAAEKICCyACQfADaiQADwsMAQtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALyM0BBBR/HX4Nexd9IwBB8ANrIgIkACAAEJ4BIAIgACgCCCIENgIsIAIgAkEsaq1CgICAgBCEIio3A7ACIAJCATcC7AIgAkEBNgLkAiACQczmwQA2AuACIAIgAkGwAmo2AugCIAJB0ABqIAJB4AJqEOwDAkACQAJAAkACQAJAAn8gAigCUCIDBEAgAigCVCIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyADakkNBiAFQQAgBiADQSdqSxsNByAEEKICIAAoAgghBAsgAigCLEUNAQJAIARFBEAgAEEEQQAQ8AEMAQsgBEECdCIIEHEiB0UNA0EAIQMCQAJAAkAgBEEETwRA/QwAAAAAAQAAAAIAAAADAAAAITMgByEFIARB/P//H3EiAyEGA0AgBSAz/QsCACAFQRBqIQUgM/0MBAAAAAQAAAAEAAAABAAAAP2uASEzIAZBBGsiBg0ACyADIARGDQELIAcgA0ECdGohBQNAIAUgAzYCACAFQQRqIQUgBCADQQFqIgNHDQALIAIgADYC5AIgAiACQbACajYC4AIgAiACQeACajYCUCAEQQFGDQIMAQsgAiAANgLkAiACIAJBsAJqNgLgAiACIAJB4AJqNgJQCyAEQRVPBEAgAkHQAGohBiMAQYAgayILJAACQAJAAkACQAJAQYCJ+gAgBCAEQYCJ+gBPGyIFIAQgBEEBdmsiAyADIAVJGyIFQYEITwRAIANB/////wNLDQJBMCAFIAVBME0bIglBAnQiA0H9////B08NAiADEHEiBUUNAyAHIAQgBSAJIARBwQBJIAYQVCAFQQRrKAIAIgZBeHEiCUEEQQggBkEDcSIGGyADakkNBCAGQQAgCSADQSdqSxsNBSAFEKICDAELIAcgBCALQYAIIARBwQBJIAYQVAsgC0GAIGokAAwFC0HYlcEAEP8HCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0EEIQMDQCAHIAMgB2ogAkHgAmoQ+gEgCCADQQRqIgNHDQALCyAAIAcgBBDwASAHQQRrKAIAIgRBeHEiA0EEQQggBEEDcSIEGyAIakkNBiAEQQAgAyAIQSdqSxsNByAHEKICCyAAEJoEAkAgACgCCCIEBEAgBEEBdEEBayIGEHEiBUUNBEEAIQMgAkEANgI4IAIgBTYCNCACIAY2AjACQAJAIAAoAggiBARAIAQgBksEQCACQTBqQQAgBEEBQQEQpAUgAigCNCEFIAIoAjghAwsgAyAFaiEGIARBAUcEfyAEQQFrIgQEQCAGQQEgBPwLAAsgBSADIARqIgNqBSAGC0EBOgAAIAIgA0EBajYCOCAAKAIIRQ0BIAAoAgQiBRCKBCFAIAUvARQiBEH//wFxIggNAiAEQRB0DAULIAJBADYCOAtBAEEAQdTAxwAQjAcACyAEQf8HcSEDIARBgIACcSEGIARBgPgBcSIHQYD4AUYEQCAGQRB0IgZBgICA/AdyIANFDQMaIAYgA0ENdHJBgICA/gdyDAMLIAZBEHQhBiAHRQ0BIAdBDXRBgICA/ABxIANBDXRyQYCAgMADaiAGcgwCC0HU5sEAEP8HAAsgBkGAgIDYA3IgA2dBEGsiBkEXdGsgAyAGQf//A3FBCGp0Qf///wNxcgshAyACQf//ASBAIECSIAO+IkBDAACAP14EfSBAEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUQ703hjUQ4AgQxgVDGHIxP5WNIkD8AEGAgH4gQEMAAADHYBsgQEMA/v9GXhtBACBAIEBbGzsBPCACIAUQigQiQCBAkgJ/IARBEHQgCEUNABogBEH/B3EhAyAEQYCAAnEhBSAEQYD4AXEiBEGA+AFGBEAgBUEQdCIEQYCAgPwHciADRQ0BGiAEIANBDXRyQYCAgP4HcgwBCyAFQRB0IgUgBEENdEGAgID8AHEgA0ENdHJBgICAwANqciAEDQAaIAVBgICA2ANyIANnQRBrIgRBF3RrIAMgBEH//wNxQQhqdEH///8DcXILviJAQwAAgD9eBH0gQBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlDgCwAEgAiACQcABaq1CgICAgNABhDcDWCACIAJBPGqtQoCAgIDgAYQ3A1AgAkICNwLsAiACQQI2AuQCIAJBuOPBADYC4AIgAiACQdAAajYC6AIgAkGwAmogAkHgAmoQ7AMCQCACKAKwAiIEBEAgAigCtAIiA0EEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgBGpJDQEgBUEAIAYgBEEnaksbDQcgAxCiAgsgAiACLwE8OwE+IAJBADYCQCACQQA2AkwgAkKAgICAwAA3AkRB2LbJACgCACIDRQRAEJMFIQMLIAMoAgAgAygCBCgCDBEEACEEIAJB8JrIAP0AAwD9CwNQIAIgBK1Cxs7rhrfq7a0ShSIXQjiGIBdCgP4Dg0IohoQgF0KAgPwHg0IYhiAXQoCAgPgPg0IIhoSEQpK23Z0FhELSgaqbq/qC16d/fiIWQoDoAoNCKIYgFkKAgJQDg0IYhiAWQoCAgKgKg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQoCAgICAgICARIQgF0LYotHvwqnlvy1+hSIZQu3cspuNpYnMywCFIhZC2KLR78Kp5b8tfiAWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQtKBqpur+oLXp39+IhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhISFQov9+pfHxteXhn+FIhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRC0oGqm6v6gtenf34iF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAWQtii0e/CqeW/LX6FIhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRCiKyRp/aIgJywf34iF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAWQs+O/8e788bUd36FIBaJNwN4IAIgGULWgs2hkP2UjkuFIhZC2KLR78Kp5b8tfiAWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQtKBqpur+oLXp39+IhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhISFQvzDvKfJldXk6ACFIhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRC0oGqm6v6gtenf34iF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAWQtii0e/CqeW/LX6FIhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRCiKyRp/aIgJywf34iF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAWQs+O/8e788bUd36FIBaJNwNwIAIgGUL8w7ynyZXV5OgAhSIWQtii0e/CqeW/LX4gFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhELSgaqbq/qC16d/fiIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEhULt3LKbjaWJzMsAhSIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQtKBqpur+oLXp39+IhdCOIYgF0KA/gODQiiGhCAXQoCA/AeDQhiGIBdCgICA+A+DQgiGhIQgF0IIiEKAgID4D4MgF0IYiEKAgPwHg4QgF0IoiEKA/gODIBdCOIiEhIQgFkLYotHvwqnlvy1+hSIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQoiskaf2iICcsH9+IhdCOIYgF0KA/gODQiiGhCAXQoCA/AeDQhiGIBdCgICA+A+DQgiGhIQgF0IIiEKAgID4D4MgF0IYiEKAgPwHg4QgF0IoiEKA/gODIBdCOIiEhIQgFkLPjv/Hu/PG1Hd+hSAWiTcDaCACIBlCi/36l8fG15eGf4UiFkLYotHvwqnlvy1+IBZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRC0oGqm6v6gtenf34iFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhIVC1oLNoZD9lI5LhSIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQtKBqpur+oLXp39+IhdCOIYgF0KA/gODQiiGhCAXQoCA/AeDQhiGIBdCgICA+A+DQgiGhIQgF0IIiEKAgID4D4MgF0IYiEKAgPwHg4QgF0IoiEKA/gODIBdCOIiEhIQgFkLYotHvwqnlvy1+hSIWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQoiskaf2iICcsH9+IhdCOIYgF0KA/gODQiiGhCAXQoCA/AeDQhiGIBdCgICA+A+DQgiGhIQgF0IIiEKAgID4D4MgF0IYiEKAgPwHg4QgF0IoiEKA/gODIBdCOIiEhIQgFkLPjv/Hu/PG1Hd+hSAWiTcDYCACQfABaq0iJkKAgICAEIQhJyACQeABaq1CgICAgBCEISsgAkFAa61CgICAgBCEISwgAkGAAWqtQoCAgIDQAYQhLSACQT5qrUKAgICA4AGEIS4gAkHoAmohEyACKAIsIQogAigCQCEEA0AgAkMAAIA/IAIuAT4QsAYiQjgCgAEgACgCCCELAkAgBCAKTw0AIAQgCmshDCAEQSRsIgggACgCBGohBSAEIAQgCyAEIAtLG2shEEEAIQMCQANAIAMgBGohB0MAAIA/IUACfwJAIAMgEGoEQCAFEIoEIUEgBUEUai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEGIAlBgIACcSENIAlBgPgBcSIJQYD4AUYEQCANQRB0IglBgICA/AdyIAZFDQMaIAkgBkENdHJBgICA/gdyDAMLIA1BEHQhDSAJRQ0BIAlBDXRBgICA/ABxIAZBDXRyQYCAgMADaiANcgwCCyAHIAtB1MDHABCMBwALIA1BgICA2ANyIAZnQRBrIglBF3RrIAYgCUH//wNxQQhqdEH///8DcXILviJDQwAAgD9eBEAgQxDGBUNU+C1AlEMAAIA/kpEhQAsgQSBBkiBAlCBCXg0BIAIgB0EBajYCQCAFQSRqIQUgDCADQQFqIgNqDQALIAohBwsgBCAHTw0AAkAgByAEayIKQf////8BTQRAIApBA3QiA0H9////B0kNAQtB4P/GABD/BwALQQAhBgJAIANFBEBBBCELQQAhCgwBCyADEHEiC0UNBQsgBCAHayEMIAshAwNAQwAAgD8hQAJ/AkAgBCAGaiIJIAAoAggiBUkEQCAAKAIEIAhqIgUQigQhQSAFQRRqLwEAIgdB//8BcUUEQCAHQRB0DAMLIAdB/wdxIQUgB0GAgAJxIQ0gB0GA+AFxIgdBgPgBRgRAIA1BEHQiB0GAgID8B3IgBUUNAxogByAFQQ10ckGAgID+B3IMAwsgDUEQdCENIAdFDQEgB0ENdEGAgID8AHEgBUENdHJBgICAwANqIA1yDAILIAkgBUHUwMcAEIwHAAsgDUGAgIDYA3IgBWdBEGsiB0EXdGsgBSAHQf//A3FBCGp0Qf///wNxcgu+IkJDAACAP14EQCBCEMYFQ1T4LUCUQwAAgD+SkSFACyADQQRqIAk2AgAgAyBBIEGSIECMlDgCACAIQSRqIQggA0EIaiEDIAwgBkEBaiIGag0ACyACIAY2AowBIAIgCzYCiAEgAiAKNgKEASACQcQAaiACQYQBahCUAiAAKAIIIQsLIAIgAigCTCIHNgLgASACIAs2AvABIAIgJzcDiAMgAiArNwOAAyACICo3A/gCIAIgLDcD8AIgAiAtNwPoAiACIC43A+ACIAJCBjcCvAIgAkEGNgK0AiACQfzmwQA2ArACIAIgAkHgAmo2ArgCIAJBoAJqIAJBsAJqEOwDIAIoAqACIgQEQCACKAKkAiIDQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyAEakkNByAFQQAgBiAEQSdqSxsNCCADEKICCyACKAJcIgQEQCACKAJQIgZBCGohAyAGKQMAQn+FQoCBgoSIkKDAgH+DIRcgBiEFA0AgF1AEQANAIAVBgARrIQUgAykDACADQQhqIQNCgIGChIiQoMCAf4MiFkKAgYKEiJCgwIB/UQ0ACyAWQoCBgoSIkKDAgH+FIRcLIAUgF3qnQQN0QcAHcWsiCEEEaygCACILQQlPBEAgCEEgaygCACIIQQRrKAIAIglBeHEiCiALQQJ0IgtBBEEIIAlBA3EiCRtqSQ0JIAlBACAKIAtBJ2pLGw0KIAgQogILIBdCAX0gF4MhFyAEQQFrIgQNAAsgAiACKAJUIgQEfyAEQQlqIgMEQCAGQf8BIAP8CwALIAQgBEEBakEDdkEHbCAEQQhJGwVBAAs2AlggAkEANgJcCwJAIAdFDQAgAigCSCIDIAdBA3RqIQ0gA0EIaiEFAkADQCADKAIEIgsgACgCCCIETw0BIAUhByACIAAoAgQgC0EkbGoiBP1dAgggBCoCECJA/SACIED9IAMgAv0JAoAB/ecB/WgiM/0fAvwENwOgASACIDP9HwH8BDcDmAEgAiAz/R8A/AQ3A5ABIAJB4AJqIAJB0ABqIAJBkAFqEIcCAkAgAigCgAMiBQRAIAJBuAJqIBNBCGr9AAMA/QsDACACIBMpAwA3A7ACIAUoAgAiAyAFKAIEIgYgAigC4AIiCXEiBGopAABCgIGChIiQoMCAf4MiF1AEQEEIIQgDQCAEIAhqIQQgCEEIaiEIIAMgBCAGcSIEaikAAEKAgYKEiJCgwIB/gyIXUA0ACwsgAyAXeqdBA3YgBGogBnEiBGosAAAiCEEATgRAIAMgAykDAEKAgYKEiJCgwIB/g3qnQQN2IgRqLQAAIQgLIAMgBGogCUEZdiIJOgAAIAUgBSgCCCAIQQFxazYCCCADIARBCGsgBnFqQQhqIAk6AAAgAyAEQQZ0ayIDQUBqIgRBEGogAkHAAmopAwA3AwAgBCAC/QADsAL9CwMAIANBBGtBADYCACADQShrQQA2AgAgBSAFKAIMQQFqNgIMDAELIAIoAuACIQMLIANBJGshBgJ/IANBBGsiBSgCACIJQQlJBEAgCSEEQQghCSAGDAELIAYoAgAhBCAGIQUgA0EgaygCAAshCiAEIAlGBH8gA0EoaxDNBiADQSBrKAIAIQogBiIFKAIABSAEC0ECdCAKaiALNgIAIAUgBSgCAEEBajYCACAHQQBBCCAHIA1GIgQbaiEFIAchAyAERQ0ACwwBCyALIARB1MDHABCMBwALIAJBADYCsAEgAkKAgICAwAA3AqgBA0AgAigCNCEUIAIoAjghDQJAAkACQAJAAkADQCACQbQBaiACQcQAahCEAyACKAK0AUEBRw0CIAIoArwBIgogDU8NASAKIBRqIg4tAABFDQALIAAoAggiCCAKSwRAAkAgACgCBCIRIApBJGxqIgP9XQIIIAMqAhAiQP0gAiBA/SADIAL9CQKAAf3nAf1oIjP9HwL8BCIeQgF9IhwgHkIBfCIoVwRAIAIpA2AiFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhCEvIBZCf4UhMCAz/R8A/AQiH0IBfCEdIB9CAX0hICAz/R8B/AQiJUIBfCEbICVCAX0hGUL///////////8AISFDAACA/yFAQX8hCyACKAJQIRAgAigCVCEJIAIpA2ghMSACKAJcIRVC////////////ACEiQv///////////wAhIwNAAkAgGSAbVQ0AIB0gIFMEQCAZIRcDQCAXIBtZDQIgGyAXIBcgG1OtfCIXWQ0ACwwBCwJAIBUEQCAZISQMAQsgGSEWA0AgICEXA0AgFyAdUyIFBEAgFyAFrXwiFyAdVw0BCwsgFiAbWQ0CIBsgFiAWIBtTrXwiFlkNAAsMAQsDQCAkIhcgFyAbU618ISQgICEWAkACQANAIAkgFiAxhSIYQtii0e/CqeW/LX4gGEI4hiAYQoD+A4NCKIaEIBhCgID8B4NCGIYgGEKAgID4D4NCCIaEhCAYQgiIQoCAgPgPgyAYQhiIQoCA/AeDhCAYQiiIQoD+A4MgGEI4iISEhELSgaqbq/qC16d/fiIYQjiGIBhCgP4Dg0IohoQgGEKAgPwHg0IYhiAYQoCAgPgPg0IIhoSEIBhCCIhCgICA+A+DIBhCGIhCgID8B4OEIBhCKIhCgP4DgyAYQjiIhISEhSAXhSIYQtii0e/CqeW/LX4gGEI4hiAYQoD+A4NCKIaEIBhCgID8B4NCGIYgGEKAgID4D4NCCIaEhCAYQgiIQoCAgPgPgyAYQhiIQoCA/AeDhCAYQiiIQoD+A4MgGEI4iISEhELSgaqbq/qC16d/fiIYQjiGIBhCgP4Dg0IohoQgGEKAgPwHg0IYhiAYQoCAgPgPg0IIhoSEIBhCCIhCgICA+A+DIBhCGIhCgID8B4OEIBhCKIhCgP4DgyAYQjiIhISEhSAchSIYQjiGIBhCgP4Dg0IohoQgGEKAgPwHg0IYhiAYQoCAgPgPg0IIhoSEIBhCCIhCgICA+A+DIBhCGIhCgID8B4OEIBhCKIhCgP4DgyAYQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIQgGELYotHvwqnlvy1+hSIYQjiGIBhCgP4Dg0IohoQgGEKAgPwHg0IYhiAYQoCAgPgPg0IIhoSEIBhCCIhCgICA+A+DIBhCGIhCgID8B4OEIBhCKIhCgP4DgyAYQjiIhISEIDB+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIQgGCAvfoUgGIkiGKdxIQUgGEIZiEL/AINCgYKEiJCgwIABfiEyIBYgFiAdU618IRhBACEGAkACQANAAkAgBSAQaikAACIpIDKFIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIaUEUEQANAAkAgFiAQIBp6p0EDdiAFaiAJcUEGdGsiBEFAaikDAFINACAXIARBOGspAwBSDQAgHCAEQTBrKQMAUQ0DCyAaQgF9IBqDIhpQRQ0ACwsgKSApQgGGg0KAgYKEiJCgwIB/g1BFDQIgBSAGQQhqIgZqIAlxIQUMAQsLAn8gBEEEaygCACIGQQlPBEAgBEEkaygCACEGIARBIGsoAgAMAQsgBEEkawshBSAGRQ0AIAZBAnQhBgNAIAUoAgAiBCANTw0CAkAgBCAKRg0AIAQgFGotAABBAXFFDQAgBCAITw0FIAJB4AJqIgwgAxCaAyAC/QAE4AIhNCAMIAMpAgAQywIgAv0ABOACITMgDCARIARBJGxqIgcQmgMgAv0ABOACITUgDCAHKQIAEMsCIDQgM/0NCAkKCwgJCgsICQoLAAECAyAz/R8AIkEgM/0fAiJJIEmSIkOUIkwgM/0fAyJFIDP9HwEiQiBCkiJHlCJNkv0TIEIgQ5QiTyBFIEEgQZIiRJQiUJP9IAFDAACAPyBBIESUIlEgQiBHlCJSkpP9IAL95gEiNiA1IDP9DQgJCgsICQoLCAkKCwABAgMgAv0ABOACIjP9HwAiQiAz/R8CIkggSJIiRJQiUyAz/R8DIkogM/0fASJGIEaSIkuUIlSS/RMgRiBElCJVIEogQiBCkiJOlCJWk/0gAUMAAIA/IEIgTpQiTiBGIEuUIkaSk/0gAv3mASI3/Q0AAQIDEBESEwABAgMAAQIDIjMgNiAz/Q0ICQoLAAECAwABAgMAAQIDIDcgM/0NCAkKCwABAgMAAQIDAAECA/0NAAECAxAREhMAAQIDAAECAyI4/eYBIDQgM/0NBAUGBwQFBgcEBQYHAAECAyBBIEeUIkEgRSBDlCJFk/0TQwAAgD8gUSBJIEOUIkOSk/0gASBPIFCS/SAC/eYBIjkgNSAz/Q0EBQYHBAUGBwQFBgcAAQIDIEIgS5QiQiBKIESUIkmT/RNDAACAPyBOIEggRJQiRJKT/SABIFUgVpL9IAL95gEiOv0NAAECAxAREhMAAQIDAAECAyI7IDkgM/0NCAkKCwABAgMAAQIDAAECAyA6IDP9DQgJCgsAAQIDAAECAwABAgP9DQABAgMQERITAAECAwABAgMiPP3mASA0IDP9DQABAgMAAQIDAAECAwABAgNDAACAPyBSIEOSk/0TIEEgRZL9IAEgTCBNk/0gAv3mASI0IDUgM/0NAAECAwABAgMAAQIDAAECA0MAAIA/IEYgRJKT/RMgQiBJkv0gASBTIFST/SAC/eYBIj/9DQABAgMQERITAAECAwABAgMiPSA0IDP9DQgJCgsAAQIDAAECAwABAgMgPyAz/Q0ICQoLAAECAwABAgMAAQID/Q0AAQIDEBESEwABAgMAAQIDIj795gH95AH95AEiNf0fAEMAAAA/IDX9HwFDAAAAP5QQtAYhQSA2IDf9DQQFBgcUFRYXAAECAwABAgMiNyA4/eYBIDkgOv0NBAUGBxQVFhcAAQIDAAECAyI5IDz95gEgNCA//Q0EBQYHFBUWFwABAgMAAQIDIjogPv3mAf3kAf3kASI0/R8AQwAAAD8gNP0fAUMAAAA/lBC0BiFDIDMgN/3mASA7IDn95gEgPSA6/eYB/eQB/eQBIjb9HwBDAAAAPyA3IDf95gEgOSA5/eYBIDogOv3mAf3kAf3kASI3IDb9DQABAgMEBQYHAAECAxQVFhcgMyAz/eYBIDsgO/3mASA9ID395gH95AH95AEiO/0NFBUWFwQFBgcAAQIDDA0ODyA4IDj95gEgPCA8/eYBID4gPv3mAf3kAf3kASIz/Q0AAQIDBAUGBxQVFhcMDQ4P/QwAAAA/AAAAPwAAAD8AAAA//eYBIjj9HwMQtAYhQiAz/R8AQwAAAD8gOP0fAhC0BiFEQwAAAAAhRSBBIEMgQpQgQSA3/R8AQwAAAD8gOP0fARC0BiJJlJMiSpQgO/0fAEMAAAA/IDj9HwAQtAYiRiBJIESUIEMgQ5STIkuUIEIgRCBClCJMIEEgQ5QiTZOUk5IiR4sgRosgSYsQ4AggRIsQ4AgiSCBIIEiUlENgQqINEOAIQ19wiTCUXUUEQCBHIDUgNiA0/eYBIDcgNf3mAf3lAf3mASA7IDcgM/3mASA0IDT95gH95QH95gEgNiAzIDb95gEgNSA0/eYB/eUB/eYB/eUB/eQBIjP9HwAgM/0fAZSRlRDGBUMAAAA/lCAHQRBqIAf9XQII/VYCAAIgA0EQaiAD/V0CCP1WAgAC/eUBIjP9HwIiRSBBIEKUIEMgRpSTQwAAgD8gR5UiQ5QiRyBHkiAz/R8BIkeUlCBFIEogQ5QiSCBIkiAz/R8AIkiUlCBHIE0gTJMgQ5QiSiBKkiBIlJQgRSBFIEYgSZQgQiBClJMgQ5SUlCBIIEggSyBDlJSUIEcgRyBGIESUIEEgQZSTIEOUlJSSkpKSkkMAAAA+lJIhRQsgAkHgAmoiDCADEKQDIAL9AATgAiAMIAcQpAMgAv0ABOAC/eUBIjMgM/3mASIzIDP9DQgJCgsAAQIDAAECAwABAgMgMyAzIDP9DQQFBgcAAQIDAAECAwABAgP95AH95AH9HwCMEIkEIEWMEIkElCJBQwAAAAAgQSBBWxsiQSBAXkUNACAWISMgFyEiIBwhISBBIUAgBCELCyAFQQRqIQUgBkEEayIGDQALCyAWIB1ZDQMgGCIWIB1VDQMMAQsLIAQgDUGc6MEAEIwHAAsgBCAIQdTAxwAQjAcACyAXIBtZDQEgGyAkWQ0ACwsgHCAoUyIEBEAgHCAErXwiHCAoVw0BCwsgC0F/Rw0BCyACKgK4ASFAIAIoArABIgQgAigCqAFGBEAgAkGoAWpBvOfBABD5BQsgAigCrAEgBEEDdGoiAyAKNgIEIAMgQDgCACACIARBAWo2ArABDAcLIAIgCzYC5AIgAiAKNgLgAiAAIAJB4AJqQQJDAAAAABA/IRAgDkEAOgAAIAIoAlxFDQMgAigCVCIFIAIpA2ggH4UiFkLYotHvwqnlvy1+IBZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRC0oGqm6v6gtenf34iFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhIUgJYUiFkLYotHvwqnlvy1+IBZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRC0oGqm6v6gtenf34iFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhIUgHoUiFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhELSgaqbq/qC16d/fiIXQjiGIBdCgP4Dg0IohoQgF0KAgPwHg0IYhiAXQoCAgPgPg0IIhoSEIBdCCIhCgICA+A+DIBdCGIhCgID8B4OEIBdCKIhCgP4DgyAXQjiIhISEIBZC2KLR78Kp5b8tfoUiFkI4hiAWQoD+A4NCKIaEIBZCgID8B4NCGIYgFkKAgID4D4NCCIaEhCAWQgiIQoCAgPgPgyAWQhiIQoCA/AeDhCAWQiiIQoD+A4MgFkI4iISEhCACKQNgIhdCf4V+IhlCOIYgGUKA/gODQiiGhCAZQoCA/AeDQhiGIBlCgICA+A+DQgiGhIQgGUIIiEKAgID4D4MgGUIYiEKAgPwHg4QgGUIoiEKA/gODIBlCOIiEhIQgFiAXQjiGIBdCgP4Dg0IohoQgF0KAgPwHg0IYhiAXQoCAgPgPg0IIhoSEIBdCCIhCgICA+A+DIBdCGIhCgID8B4OEIBdCKIhCgP4DgyAXQjiIhISEfoUgFokiFqdxIQMgFkIZiEL/AINCgYKEiJCgwIABfiEZQQAhBCACKAJQIQYDQAJAIAMgBmopAAAiFiAZhSIXQn+FIBdCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiF1BFBEADQAJAIB8gBiAXeqdBA3YgA2ogBXFBBnRrIgxBQGopAwBSDQAgJSAMQThrKQMAUg0AIB4gDEEwaykDAFENAwsgF0IBfSAXgyIXUEUNAAsLIBYgFkIBhoNCgIGChIiQoMCAf4NQRQ0FIAMgBEEIaiIEaiAFcSEDDAELCyAMQQRrIhEoAgAiAyEOIANBCU8EQCAMQSRrKAIAIQ4LIA5FBEBBACEIDAYLIAxBIGshFSAMQSRrIQlBACEFQQAhCEEAIQMDQCARKAIAIgYhBCAJIQcgBkEJSSIPRQRAIAcoAgAhBCAVKAIAIQcLAkACQCADIARJBEAgCiAFIAdqKAIARgRAIAhBAWohCAwDCyAIRQRAQQAhCAwDCyAJIQQgD0UEQCAEKAIAIQYgFSgCACEECyADIAhrIgcgBk8NASADIAZJBEAgBCAFIAhBAnRraiIGKAIAIQcgBiAEIAVqIgQoAgA2AgAgBCAHNgIADAMLIAMgBkHopMEAEIwHAAsgAyAEQdikwQAQjAcACyAHIAZB6KTBABCMBwALIAVBBGohBSADQQFqIgMgDkcNAAsMBAsgCiAIQdTAxwAQjAcACyAKIA1BrOfBABCMBwALIAIgAi8BPkEBajsBPiACQcQAaiACQagBahCUAiACKAJAIgQgAigCLCIKSQ0EIAIoAkxBAUsNBCACIAAoAghBAWs2AtwBIAJBATYC5AIgAkH45MEANgLgAiACQgE3AuwCIAIgAkHcAWqtQoCAgIAQhDcDoAIgAiACQaACajYC6AIgAkGwAmogAkHgAmoQsQYgAigCsAIiBARAIAIoArQCIARBARCiBwsCQAJAAkAgAigC3AEiBCAAKAIIIgNJBEAgAkEBNgLkAiACQbjowQA2AuACIAJCATcC7AIgAiAAKAIEIARBJGxqNgLwASACICZCgICAgIADhDcDoAIgAiACQaACajYC6AIgAkGwAmogAkHgAmoQsQYgAigCsAIiBARAIAIoArQCIARBARCiBwsgAkEgaiAAKAIIQQF0QQFrEOQHQQAhBSACQQA2AugBIAIgAikDIDcC4AEgAkHgAWoiBCACKAIsQQEQxAYgBCAAKAIIQQAQxAYgAigC3AEiAyACKALoASIKTw0CIAIoAuQBIgsgA2pBAToAACACQeACaiAAIAIoAtwBIAQgARCVAkEAIQYCQCAKQQRPBED9DAAAAAAAAAAAAAAAAAAAAAAhMyALIQMgCkF8cSIGIQUDQCAzIAP9XAAA/YkB/akB/a4BITMgA0EEaiEDIAVBBGsiBQ0ACyAzIDMgM/0NCAkKCwwNDg8AAQIDAAECA/2uASIzIDMgM/0NBAUGBwABAgMAAQIDAAECA/2uAf0bACEFIAYgCkYNAQsgBiALaiEDIAogBmshBgNAIAUgAy0AAGohBSADQQFqIQMgBkEBayIGDQALCyACKAKIAyENIAIoAuwCIQwgAiAFNgLsASACIAAoAgg2AvABIAJBAjYC5AIgAkHs6MEANgLgAiACQgI3AuwCIAIgJzcDuAIgAiACQewBaq1CgICAgBCEIhY3A7ACIAIgAkGwAmo2AugCIAJBoAJqIAJB4AJqELEGIAIoAqACIgQEQCACKAKkAiAEQQEQogcLIAJBATYC5AIgAkGQ6cEANgLgAiACQgE3AuwCIAIgJkKAgICA0AGENwOgAiACIAIoAuwBsyACKAIss5U4AvABIAIgAkGgAmo2AugCIAJBsAJqIAJB4AJqELEGIAIoArACIgQEQCACKAK0AiAEQQEQogcLIAJBADYC+AEgAkKAgICAwAA3AvABIAIoAtwBIQQgAkHwAWpBmOnBABCLBiACKAL0ASAENgIAIAJBATYC+AEgAigC3AEiBCAAKAIIIgNPDQEgAiAAKAIEIARBJGxqIgQQigQiASABkgJ/IAQvARQiA0H//wFxRQRAIANBEHQMAQsgA0H/B3EhBCADQYCAAnEhBSADQYD4AXEiA0GA+AFGBEAgBUEQdCIDQYCAgPwHciAERQ0BGiADIARBDXRyQYCAgP4HcgwBCyAFQRB0IgUgA0ENdEGAgID8AHEgBEENdHJBgICAwANqciADDQAaIAVBgICA2ANyIARnQRBrIgNBF3RrIAQgA0H//wNxQQhqdEH///8DcXILviIBQwAAgD9eBH0gARDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlDgCgAJBBBBxIgVFDQsgBSACKALcATYCACACQZACaq1CgICAgBCEIRcgAkGAAmqtQoCAgIDQAYQhGUEBIQZBASEEA0AgAiAGNgKQAiACIBc3A7gCIAIgGTcDsAIgAkICNwLsAiACQQI2AuQCIAJB0OnBADYC4AIgAiACQbACajYC6AIgAkGgAmogAkHgAmoQ7AMgAigCoAIiAwRAIAIoAqQCIgdBBGsoAgAiCEF4cSIJQQRBCCAIQQNxIggbIANqSQ0QIAhBACAJIANBJ2pLGw0RIAcQogILQQAhAyACQQA2AugCIAJCgICAgMAANwLgAiAGQQJ0IQYDQCAAIAMgBWooAgAgAkHwAWogAioCgAIgAkHgAmoQ2gEgBiADQQRqIgNHDQALAkAgAigC6AIiBkUEQCACKALgAiIDBEAgAigC5AIgA0ECdEEEEKIHCyACIAIoAvgBIgc2AoQCIAcgAigC7AFGDQEgAkEANgLgAkEAIAJBhAJqIAJB7AFqIAJB4AJqQeDpwQAQ9QcACyACIAIqAoACQwAAgD6UOAKAAiACKALkAiACKALgAiEHIAQEQCAFQQRrKAIAIghBeHEiCSAEQQJ0IgRBBEEIIAhBA3EiCBtqSQ0RIAhBACAJIARBJ2pLGw0SIAUQogILIQUgByEEDAELCyALQQFqIQkgCiALaiEDQQAhBiALIQgDQCAILQAARQRAIAIoAvABIAdGBEAgAkHwAWpB3OrBABCLBgsgAigC9AEgB0ECdGogBjYCACACIAdBAWoiBzYC+AELIAkgCSIIIANHaiEJIAogBkEBaiIGRw0ACyAAIAIoAvQBIAcQ8AEgACACKALsARCIBSACQQE2AuQCIAJBjOrBADYC4AIgAkIBNwLsAiACIBY3A6ACIAIgAkGgAmo2AugCIAJBsAJqIAJB4AJqELEGIAIoArACIgMEQCACKAK0AiADQQEQogcLIAIgACgCCCIIBHxCACEXQQAhBkEAIQcDQCACQeACaiAAKAIQIAAoAhQgBhDoAiACKAKEAyIDQQhLBEAgAigC6AIiCUEEaygCACIKQXhxIhAgA0ECdCITQQRBCCAKQQNxIgobakkNESACKALkAiEDIApBACAQIBNBJ2pLGw0GIAkQogILIAcgA0EAR2ohByAXIAOtfCEXIAggBkEBaiIGRw0ACyAXuiAHt6MFRAAAAAAAAPh/CzkDiAIgAkEBNgLkAiACQbzqwQA2AuACIAJCATcC7AIgAiACQYgCaq1CgICAgPAChDcDoAIgAiACQaACajYC6AIgAkGwAmogAkHgAmoQsQYgAigCsAIiAwRAIAIoArQCIANBARCiBwsgAkHgAmogACgCECAAKAIUQQAQ6AIgAiACKAKEAyIDQQlJIgYEfyADBSACKALkAgs2ApwCIAJBATYCtAIgAkHU6sEANgKwAiACQgE3ArwCIAIgAkGcAmqtQoCAgIAQhDcDkAIgAiACQZACajYCuAIgAkGgAmogAkGwAmoQsQYgBkUEQCACKALoAiADQQJ0QQQQogcLIAIoAqACIgMEQCACKAKkAiADQQEQogcLIAQEQCAFIARBAnRBBBCiBwsgAigC8AEiBARAIAIoAvQBIARBAnRBBBCiBwsgDUEJTwRAIAwgDUECdEEEEKIHCyACKALgASIEBEAgCyAEQQEQogcLIAJB0ABqEL4EIAIoAkQiBARAIAIoAkggBEEDdEEEEKIHCyACKAIwIgQEQCAUIARBARCiBwsgACgCCCEEDAoLIAQgA0HUwMcAEIwHAAsgBCADQdTAxwAQjAcACyADIApB0OjBABCMBwALDAsLQcznwQAQ3QkACyARKAIAIQMLIA4gCGsiBCAMQSRrIBEgA0EISxsiAygCAEkEQCADIAQ2AgALAkACQAJAAkAgCyANSQRAIAsgFGpBADoAACACKAJcRQ0CIAIoAlQiBSACKQNoICOFIhZC2KLR78Kp5b8tfiAWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQtKBqpur+oLXp39+IhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhISFICKFIhZC2KLR78Kp5b8tfiAWQjiGIBZCgP4Dg0IohoQgFkKAgPwHg0IYhiAWQoCAgPgPg0IIhoSEIBZCCIhCgICA+A+DIBZCGIhCgID8B4OEIBZCKIhCgP4DgyAWQjiIhISEQtKBqpur+oLXp39+IhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhISFICGFIhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIRC0oGqm6v6gtenf34iF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhCAWQtii0e/CqeW/LX6FIhZCOIYgFkKA/gODQiiGhCAWQoCA/AeDQhiGIBZCgICA+A+DQgiGhIQgFkIIiEKAgID4D4MgFkIYiEKAgPwHg4QgFkIoiEKA/gODIBZCOIiEhIQgAikDYCIXQn+FfiIZQjiGIBlCgP4Dg0IohoQgGUKAgPwHg0IYhiAZQoCAgPgPg0IIhoSEIBlCCIhCgICA+A+DIBlCGIhCgID8B4OEIBlCKIhCgP4DgyAZQjiIhISEIBYgF0I4hiAXQoD+A4NCKIaEIBdCgID8B4NCGIYgF0KAgID4D4NCCIaEhCAXQgiIQoCAgPgPgyAXQhiIQoCA/AeDhCAXQiiIQoD+A4MgF0I4iISEhH6FIBaJIhancSEDIBZCGYhC/wCDQoGChIiQoMCAAX4hGUEAIQQgAigCUCEGA0AgAyAGaikAACIWIBmFIhdCf4UgF0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIXUEUEQANAAkAgIyAGIBd6p0EDdiADaiAFcUEGdGsiDEFAaikDAFINACAiIAxBOGspAwBSDQAgISAMQTBrKQMAUQ0FCyAXQgF9IBeDIhdQRQ0ACwsgFiAWQgGGg0KAgYKEiJCgwIB/g1BFDQMgAyAEQQhqIgRqIAVxIQMMAAsACyALIA1B3OfBABCMBwALIAxBBGsiDigCACIDIQogA0EJTwRAIAxBJGsoAgAhCgsgCkUEQEEAIQkMAwsgDEEgayERIAxBJGshCEEAIQVBACEJQQAhAwNAIA4oAgAiBiEEIAghByAGQQlJIhVFBEAgBygCACEEIBEoAgAhBwsCQAJAIAMgBEkEQCALIAUgB2ooAgBGBEAgCUEBaiEJDAMLIAlFBEBBACEJDAMLIAghBCAVRQRAIAQoAgAhBiARKAIAIQQLIAMgCWsiByAGTw0BIAMgBkkEQCAEIAUgCUECdGtqIgYoAgAhByAGIAQgBWoiBCgCADYCACAEIAc2AgAMAwsgAyAGQeikwQAQjAcACyADIARB2KTBABCMBwALIAcgBkHopMEAEIwHAAsgBUEEaiEFIANBAWoiAyAKRw0ACwwBC0Hs58EAEN0JAAsgDigCACEDCyAKIAlrIgQgDEEkayAOIANBCEsbIgMoAgBJBEAgAyAENgIACyACKAIwIA1GBH8gAkEwahCmBiACKAI0BSAUCyANakEBOgAAIAIgDUEBajYCOEMAAIA/IUACfwJAIAAoAggiBCAQSwRAIAAoAgQgEEEkbGoiBRCKBCFBIAUvARQiA0H//wFxRQRAIANBEHQMAwsgA0H/B3EhBCADQYCAAnEhBiADQYD4AXEiA0GA+AFGBEAgBkEQdCIDQYCAgPwHciAERQ0DGiADIARBDXRyQYCAgP4HcgwDCyAGQRB0IQYgA0UNASADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBnIMAgsgECAEQdTAxwAQjAcACyAGQYCAgNgDciAEZ0EQayIDQRd0ayAEIANB//8DcUEIanRB////A3FyC74iQkMAAIA/XgRAIEIQxgVDVPgtQJRDAACAP5KRIUALIEEgQZIgQJQiQCACKgKAASJBXkUEQCACIAX9XQIIIAUqAhAiQv0gAiBC/SADIEH9E/3nAf1oIjP9HwL8BDcD0AEgAiAz/R8B/AQ3A8gBIAIgM/0fAPwENwPAASACQeACaiACQdAAaiACQcABahCHAgJAIAIoAoADIgUEQCACQbgCaiATQQhq/QADAP0LAwAgAiATKQMANwOwAiAFKAIAIgQgBSgCBCIDIAIoAuACIghxIgZqKQAAQoCBgoSIkKDAgH+DIhdQBEBBCCEHA0AgBiAHaiEGIAdBCGohByAEIAMgBnEiBmopAABCgIGChIiQoMCAf4MiF1ANAAsLIAQgF3qnQQN2IAZqIANxIgZqLAAAIgdBAE4EQCAEIAQpAwBCgIGChIiQoMCAf4N6p0EDdiIGai0AACEHCyAEIAZqIAhBGXYiCDoAACAFIAUoAgggB0EBcWs2AgggBCAGQQhrIANxakEIaiAIOgAAIAQgBkEGdGsiA0FAaiIEQRBqIAJBwAJqKQMANwMAIAQgAv0AA7AC/QsDACADQQRrQQA2AgAgA0Eoa0EANgIAIAUgBSgCDEEBajYCDAwBCyACKALgAiEDCyADQSRrIQcCfyADQQRrIgUoAgAiBEEJSQRAIAQhBkEIIQQgBwwBCyAHKAIAIQYgByEFIANBIGsoAgALIQkgBCAGRgRAIANBKGsQzQYgA0EgaygCACEJIAcoAgAhBiAHIQULIAkgBkECdGogEDYCACAFIAUoAgBBAWo2AgAgAkHEAGogQIwgEBDxBAwBCyACKAKwASIEIAIoAqgBRgRAIAJBqAFqQYzowQAQ+QULIAIoAqwBIARBA3RqIgMgEDYCBCADIECMOAIAIAIgBEEBajYCsAEMAAsACwALDAQLIAQEQEEUIQZBACEFA0ACQAJ/AkACQAJ/AkACQCAAKAIIIgMgBUsEQCAAKAIEIAZqIgovAQAiB0H//wFxIg1FDQEgB0H/B3EhAyAHQYCAAnEhCCAHQYD4AXEiC0GA+AFHIgxFBEAgCEEQdCIJQYCAgPwHciADRQ0EGiAJIANBDXRyQYCAgP4HcgwECyAIQRB0IQkgC0UNAiALQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogCXIMAwsgBSADQeTAxwAQjAcACyAHQRB0vkMAAIA/Xg0CDAULIAlBgICA2ANyIANnQRBrIglBF3RrIAMgCUH//wNxQQhqdEH///8DcXILvkMAAIA/XkUNAyANDQELIAdBEHQMAQsgDEUEQCAIQRB0IgdBgICA/AdyIANFDQEaIAcgA0ENdHJBgICA/gdyDAELIAhBEHQiByALQQ10QYCAgPwAcSADQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgA2dBEGsiB0EXdGsgAyAHQf//A3FBCGp0Qf///wNxcgtDAACAPyEBviJAQwAAgD9eBEAgQBDGBUNU+C1AlEMAAIA/kpFDAACAv5JDAACAPpRDAACAP5IhAQtDAAAAQEMAAIA/IAEgAUMAAIA/XRsiASABQwAAAEBeG7wiCEH///8DcSELIAhBgICAgHhxIQcCQCAIQYCAgPwHcSIDQYCAgPwHRgRAIAtBDXYgB0EQdnJBgARBACALG3JBgPgBciEHDAELIAdBEHYhByADQYCAgLgETQRAIANBgICAxANPBEAgCEEMdiAIQf/fAHFBAEdxIANBDXYgC0ENdmpBgIABaiAHcmohBwwCCyADQYCAgJgDSQ0BIAtBgICABHIiCEH+ACADQRd2IgtrdiEDIAhBHSALayILdkEBcQR/IANBAyALdEEBayAIcUEAR2oFIAMLIAdyIQcMAQsgB0GA+AFyIQcLIAogBzsBAAsgBkEkaiEGIAQgBUEBaiIFRw0ACwsgAkEANgKoAiACQoCAgIDAADcCoAIgAkGgAmpBqMHBABCLBiACKAKkAkEANgIAQQEhBSACQQE2AqgCIAJCgICAgMAANwLAASACQgA3AsgBQQQQcSIERQ0AIARBADYCACACQcABakG4wcEAEKQGIAIoAsQBIAIoAswBIgYgAigCyAFqIgMgAigCwAEiB0EAIAMgB08ba0EMbGoiA0EBNgIIIAMgBDYCBCADQQE2AgAgAiAGQQFqNgLMASACKALMASIDRQ0CIAJB8AFqrUKAgICAEIQhICACQeABaq0iFkKAgICAEIQhJCACQdAAaq1CgICAgJAChCEcIAJBtAFqrUKAgICA0AGEISEgAkGwAmqtQoCAgICgAoQhIiACQagBaq1CgICAgLAChCEjIBZCgICAgNABhCEYIAJBnANqIRUgAkHoAmohECACQeQCaiELIAJBuAJqIRQgAkHUAGohDSACQYQDaiETAkADQCACIANBAWs2AswBIAIgAigCyAEiBEEBaiIDIAIoAsABIgVBACADIAVPG2s2AsgBIAIoAsQBIARBDGxqIgQoAgAiDkGAgICAeEYNAyAEKQIEIRYgAkEANgKYASACQoCAgIDAADcCkAEgFqchBSAWQh6Ip0H8////B3EiBARAIAQgBWohEUEAIQhBBCEGIAUhCgNAIAghAwJ/AkAgCigCACIHIAAoAggiBEkEQCAAKAIEIAdBJGxqIgwvARwhBEEAIQhBACAMLwEeIglB//8BcSIPQYD4AUsNAhpBACAEQf//AXEiEkGA+AFLDQIaIAnBQQBIDQEgBCAJSSAEwUEATg0CGiAJIBJyQQBHDAILIAcgBEHUwMcAEIwHAAsgBMFBAEggBCAJS3ELIRIgCSAEIBIbIAQgD0GB+AFJGyEEAkAgDC8BICIJQf//AXEiD0GA+AFLDQAgBEH//wFxIhJBgPgBSw0AIAnBQQBOBEAgBMFBAE4EQCAJIARB//8DcUshCAwCCyAJIBJyQQBHIQgMAQsgBMFBAEggCSAEQf//A3FJcSEICyAMLwEUIQwCfyAJIAQgCBsgBCAPQYH4AUkbIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQQgCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgBEUNARogCCAEQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIARBDXRyQYCAgMADanIgCA0AGiAJQYCAgNgDciAEZ0EQayIIQRd0ayAEIAhB//8DcUEIanRB////A3FyC74QiQQhAUMAAIA/IUACfyAMQRB0IAxB//8BcUUNABogDEH/B3EhBCAMQYCAAnEhCCAMQYD4AXEiCUGA+AFGBEAgCEEQdCIIQYCAgPwHciAERQ0BGiAIIARBDXRyQYCAgP4HcgwBCyAIQRB0IgggCUENdEGAgID8AHEgBEENdHJBgICAwANqciAJDQAaIAhBgICA2ANyIARnQRBrIghBF3RrIAQgCEH//wNxQQhqdEH///8DcXILviJBQwAAgD9eBEAgQRDGBUNU+C1AlEMAAIA/kpEhQAsgAigCkAEgA0YEQCACQZABakHIlcEAEPkFIAIoApQBIQYLIAYgA0EDdGoiBCAHNgIEIAQgASABkiBAlCIBOAIAIAIgA0EBaiIINgKYAQJAIANFBEBBACEEDAELIAEgAVwEQANAAkAgBiADQQFrIgxBAXYiBEEDdGoiCSoCACJAIEBbIAEgQF9FcQ0AIAcgCUEEaigCAEsNACADIQQMAwsgBiADQQN0aiAJKQIANwIAIAQhAyAMQQJPDQAMAgsACwNAIAYgA0EBayIMQQF2IgRBA3RqIgkqAgAiQCBAWyABIEBfRXFBfyABIEBgGyIPQQBMIAcgCUEEaigCAE0gDxsEQCADIQQMAgsgBiADQQN0aiAJKQIANwIAIAQhAyAMQQFLDQALCyAGIARBA3RqIgQgBzYCBCAEIAE4AgAgCkEEaiIKIBFHDQALCyAOBEAgBUEEaygCACIEQXhxIgMgDkECdCIGQQRBCCAEQQNxIgQbakkNBiAEQQAgAyAGQSdqSxsNByAFEKICCwJAAkACQCACKAKYASIKRQ0AIAIoAqgCQf+/BGpBgID8/wNxIQwDQCACIApBAWsiBDYCmAEgAigClAEiByAEQQN0aiIDKAIEIQUgAyoCACEBAkAgBEUEQCABIUAgBSEIDAELIAcoAgQhCCAHIAU2AgQgByoCACFAIAcgATgCAEEAIQNBASEGIApBBE8EQCAEQQJrIgNBACADIARNGyEJQQAhBANAIAcgBEEDdGogByAGIAcgBkEDdGoiBEEIaioCACJBIEFbIEEgBCoCACJCYEVxIgMgA0F/IEEgQl8bIEIgQlwbIgNBAEwgBEEEaigCACAEQQxqKAIATSADG2oiA0EDdGopAgA3AgAgA0EBdCIOQQFyIQYgAyEEIAkgDksNAAsLAkACQCAKQQJrIAZGBEAgByADQQN0aiAHIAZBA3RqIgQpAgA3AgAgBCAFNgIEIAQgATgCACAGIQMMAQsgByADQQN0aiIEIAU2AgQgBCABOAIAIAMNAEEAIQQMAQsgASABXARAA0ACQCAHIANBAWsiCUEBdiIEQQN0aiIGKgIAIkEgQVsgASBBX0VxDQAgBSAGQQRqKAIASw0AIAMhBAwDCyAHIANBA3RqIAYpAgA3AgAgBCEDIAlBAk8NAAwCCwALA0AgByADQQFrIglBAXYiBEEDdGoiBioCACJBIEFbIAEgQV9FcUF/IAEgQWAbIgpBAEwgBSAGQQRqKAIATSAKGwRAIAMhBAwCCyAHIANBA3RqIAYpAgA3AgAgBCEDIAlBAUsNAAsLIAcgBEEDdGoiBCAFNgIEIAQgATgCAAsgAkGwAmogACgCECAAKAIUIAgQ6AIgAigCqAIhAwJAAkAgAigC1AIiBEEJSSIFRQRAIAIoArQCIANqIgkgDEsNAQwCCyADIARqIgkgDE0NAQsgAkGQAWogQCAIEPEEIAIgGDcD8AEgAiADs0MAAIA3lDgC4AEgAkIBNwLsAiACQQE2AuQCIAJB+MHBADYC4AIgAiACQfABajYC6AIgAkHQAGogAkHgAmoQ7AMgAigCUCIDBEAgAigCVCIGQQRrKAIAIgdBeHEiCEEEQQggB0EDcSIHGyADakkNCyAHQQAgCCADQSdqSxsNDCAGEKICCyAFRQRAIAIoArgCIgNBBGsoAgAiBUF4cSIGIARBAnQiBEEEQQggBUEDcSIFG2pJDQsgBUEAIAYgBEEnaksbDQwgAxCiAgsgAigCmAEiA0UNAiACKAKUASIEIANBA3QiBmohCCAAKAIEIQkgACgCCCEH/QwAAID/AACA/wAAgP8AAID/ITT9DAAAgH8AAIB/AACAfwAAgH8hNUEAIQUCQAJAAkACQAJAA0AgBCAFakEEaigCACIDIAdPDQEgAkHgAmoiCiAJIANBJGxqIgMQmgMgAv0ABOACITMgCiADKQIAEMsCIDQgA/1dAgggAyoCECIB/SACIAH9IAMiNiAz/QxvEoM6bxKDOm8SgzpvEoM6/esB/QwAAMA/AADAPwAAwD8AAMA//eYBIjQgM/0NCAkKCwgJCgsICQoLAAECA0MAAIA/IAL9AATgAiIz/R8AIgEgASABkiJGlCJJIDP9HwEiQCBAIECSIkKUIkWSk/0TIAEgM/0fAiJDIEOSIkGUIkcgM/0fAyJEIEKUIkiS/SAAIEAgQZQiQCBEIEaUIkaT/SAB/eAB/eYBIDQgM/0NBAUGBwQFBgcEBQYHAAECAyBAIEaS/RMgASBClCIBIEQgQZQiQJP9IABDAACAPyBJIEMgQZQiQZKT/SAB/eAB/eYBIDQgM/0NAAECAwABAgMAAQIDAAECAyBHIEiT/RNDAACAPyBFIEGSk/0gACABIECS/SAB/eAB/eYB/eQB/eQBIjP95AH96wEhNCA1IDYgM/3lAf3qASE1IAYgBUEIaiIFRw0ACyA0IDX95QEiMyAzIDP9DQgJCgsICQoLAAECAwABAgP96wEiNiA2IDP9DQQFBgcAAQIDAAECAwABAgP96wH9HwAgMyAzIDP9DQgJCgsICQoLBAUGBwQFBgf96gEiNiA2IDP9DQQFBgcAAQIDAAECAwABAgP96gH9HwBDAABAQJRgRQRAIAJCBDcC6AMgAkIANwLgAyACQoCAgIDAADcC2AMgAkIENwLQAyACQgA3AsgDIAJCgICAgMAANwLAAyACQgQ3ArgDIAJCADcCsAMgAkKAgICAwAA3AqgDIAJCBDcCoAMgAkIANwKYAyACQoCAgIDAADcCkAMgNSA0/eQB/QwAAAA/AAAAPwAAAD8AAAA//eYBIjP9HwAhASAz/R8CIUAgM/0fASFBQQAhAyACKAKQASEHA0AgAyAEakEEaigCACIFIAAoAggiCE8NAyACQZADaiAVIAAoAgQgBUEkbGoiCCoCCCABXRtBAEEYIAgqAgwgQV0baiIJQQhBOCAIKgIQIEBdIggbaiIMKAIAIgogCUEAQTAgCBtqIg4oAgBGBEAgDkGwwsEAEIsGCyAJQQRBNCAIG2ooAgAgDCAKQQFqNgIAIApBAnRqIAU2AgAgBiADQQhqIgNHDQALIAcEQCAEQQRrKAIAIgNBeHEiBSAHQQN0IgZBBEEIIANBA3EiAxtqSQ0RIANBACAFIAZBJ2pLGw0SIAQQogILQSAQcSIERQ0NIAQgAigCmAM2AgAgBCACKAKkAzYCBCAEIAIoArADNgIIIAQgAigCvAM2AgwgBCACKALIAzYCECAEIAIoAtQDNgIUIAQgAigC4AM2AhggBCACKALsAzYCHCACQQg2AlggAiAENgJUIAJBCDYCUCACIBw3A7ACIAJCATcC7AIgAkECNgLkAiACQZDCwQA2AuACIAIgAkGwAmo2AugCIAJB4AJqEOsCIAIoAlAiBARAIAIoAlQiA0EEaygCACIFQXhxIgYgBEECdCIEQQRBCCAFQQNxIgUbakkNESAFQQAgBiAEQSdqSxsNBCADEKICC0HgABBxIgRFDQ0gBCACQZADakHgAPwKAAAgBCgCACEDIARBgICAgHg2AgAgA0GAgICAeEYNBCAEQQRqIg8pAgAhFiAEKAIMIQcgBEGAgICAeDYCDCAHQYCAgIB4Rg0EIAQpAhAhFyAEKAIkIQggBEGAgICAeDYCJCAIQYCAgIB4Rg0EIAQpAighGSAEKAIYIQkgBEGAgICAeDYCGCAJQYCAgIB4Rg0EIAQpAhwhGyAEKAJIIQogBEGAgICAeDYCSCAKQYCAgIB4Rg0EIAQpAkwhHSAEKAJUIQwgBEGAgICAeDYCVCAMQYCAgIB4Rg0EIAQpAlghGiAEKAI8IQ4gBEGAgICAeDYCPCAOQYCAgIB4Rg0EIAQpAkAhHiAEKAIwIREgBEGAgICAeDYCMCARQYCAgIB4Rg0EIAQpAjQhHyACKALMASIFIAIoAsABIgZGBEAgAkHAAWpBoMLBABCkBiACKALAASEGIAIoAswBIQULIAIoAsQBIAIoAsgBIAVqIhIgBkEAIAYgEk0ba0EMbGoiBiAWNwIEIAYgAzYCACACIAVBAWoiBTYCzAEgAigCwAEiBiAFRgRAIAJBwAFqQaDCwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIDIAZBACADIAZPG2tBDGxqIgMgFzcCBCADIAc2AgAgAiAFQQFqIgU2AswBIAIoAsABIgYgBUYEQCACQcABakGgwsEAEKQGIAIoAsABIQYgAigCzAEhBQsgAigCxAEgAigCyAEgBWoiAyAGQQAgAyAGTxtrQQxsaiIDIBk3AgQgAyAINgIAIAIgBUEBaiIFNgLMASACKALAASIGIAVGBEAgAkHAAWpBoMLBABCkBiACKALAASEGIAIoAswBIQULIAIoAsQBIAIoAsgBIAVqIgMgBkEAIAMgBk8ba0EMbGoiAyAbNwIEIAMgCTYCACACIAVBAWoiBTYCzAEgAigCwAEiBiAFRgRAIAJBwAFqQaDCwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIDIAZBACADIAZPG2tBDGxqIgMgHTcCBCADIAo2AgAgAiAFQQFqIgU2AswBIAIoAsABIgYgBUYEQCACQcABakGgwsEAEKQGIAIoAsABIQYgAigCzAEhBQsgAigCxAEgAigCyAEgBWoiAyAGQQAgAyAGTxtrQQxsaiIDIBo3AgQgAyAMNgIAIAIgBUEBaiIFNgLMASACKALAASIGIAVGBEAgAkHAAWpBoMLBABCkBiACKALAASEGIAIoAswBIQULIAIoAsQBIAIoAsgBIAVqIgMgBkEAIAMgBk8ba0EMbGoiAyAeNwIEIAMgDjYCACACIAVBAWoiBTYCzAEgAigCwAEiBiAFRgRAIAJBwAFqQaDCwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIDIAZBACADIAZPG2tBDGxqIgMgHzcCBCADIBE2AgAgAiAFQQFqNgLMASAEKAIAIgNBgICAgHhyQYCAgIB4RwRAIA8oAgAiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAIMIgNBgICAgHhyQYCAgIB4RwRAIAQoAhAiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAIYIgNBgICAgHhyQYCAgIB4RwRAIAQoAhwiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAIkIgNBgICAgHhyQYCAgIB4RwRAIAQoAigiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAIwIgNBgICAgHhyQYCAgIB4RwRAIAQoAjQiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAI8IgNBgICAgHhyQYCAgIB4RwRAIAQoAkAiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAJIIgNBgICAgHhyQYCAgIB4RwRAIAQoAkwiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEKAJUIgNBgICAgHhyQYCAgIB4RwRAIAQoAlgiBUEEaygCACIGQXhxIgcgA0ECdCIDQQRBCCAGQQNxIgYbakkNESAGQQAgByADQSdqSxsNEiAFEKICCyAEQQRrKAIAIgNBeHFB5ABB6AAgA0EDcSIFG0kNECAFQQAgA0GIAU8bDQUgBBCiAgwJCyACIDUgNP3kAf0MAAAAPwAAAD8AAAA/AAAAP/3mAf0LBAAgAkEAQQFBAiAz/R8BIgEgM/0fAiJAYBsiAyBAIDP9HwAiQV8bIAMgASBBXxsiAzoAqAEgAiACIANBAnRyKgIAOAK0ASACIAg2AlwgAiACKAKQATYCWCACIAQ2AlQgAiAENgJQIAIgADYCtAIgAiACQbQBajYCuAIgAiACQagBajYCsAIgAkHgAmoiBSACQdAAaiIGIAJBsAJqEI4EIAIpA+ACIRkgAikC7AIhFyACKAL0AiEDIAIoAugCIQQgAiAz/QsEsAIgAiAENgLgASACIAM2AvABIAJBBjYCVCACQezCwQA2AlAgAkIFNwJcIAIgIDcDgAMgAiAkNwP4AiACICE3A/ACIAIgIjcD6AIgAiAjNwPgAiACIAU2AlggBhDrAgJAIAMgBE0EQCAXIRYgAyEGIBkhFyAEIQMMAQsgGSEWIAQhBgsgAiADNgLwAiACQQI2AuQCIAIgBjYC/AIgAiAXNwLoAiACIBY3AvQCQQEhAwJAIBenIgRBgICAgHhGDQAgAikC7AIhFyACKALMASIDIAIoAsABIgVGBEAgAkHAAWpBnMPBABCkBiACKALAASEFIAIoAswBIQMLIAIoAsQBIAIoAsgBIANqIgYgBUEAIAUgBk0ba0EMbGoiBSAXNwIEIAUgBDYCACACIANBAWo2AswBQQIhAyAWpyIEQYCAgIB4Rg0AIAIpAvgCIRYgAigCzAEiBSACKALAASIGRgRAIAJBwAFqQZzDwQAQpAYgAigCwAEhBiACKALMASEFCyACKALEASACKALIASAFaiIHIAZBACAGIAdNG2tBDGxqIgYgFjcCBCAGIAQ2AgAgAiAFQQFqNgLMAQsgAiADNgLgAiACQeACahCWBgwICyADIAdB1MDHABCMBwALIAUgCEHUwMcAEIwHAAtBjI3IAEEuQbyNyAAQ6wcMCQtBvMPBABDdCQALDAsLQQAhBiACQQA2AuACIAJBADYChANBCCEHAkACQAJ/IAkgA2siBEEAIAQgCU0bIgRBCUkEQCALIQogEwwBCyACQRhqIAJB4AJqQX8gBEEBa2d2QQFqEOgDIAIoAhgiBEGBgICAeEcEQCAEDQpB2JXHAEERQdTMxwAQ6wcACyACKAKEAyIHQQlJBEAgByEGIAshCkEIIQcgEwwBCyACKALkAiEGIAIoAugCIQogCwsiESAGIAdJBH8gByAGQX9zaiIEIAkgAyADIAlJGyIPIANrIgUgBCAFSRtBAWoiBEEESwRAIAogBkECdGohBSAD/RH9DAAAAAABAAAAAgAAAAMAAAD9rgEhMyAEIARBA3EiBEEEIAQbayIOIQQDQCAFIDP9CwIAIAVBEGohBSAz/QwEAAAABAAAAAQAAAAEAAAA/a4BITMgBEEEayIEDQALIAYgDmohBiADIA5qIQMLIAogBkECdGohBQNAIAMgD0YNAiAFIAM2AgAgBUEEaiEFIANBAWohAyAHIAZBAWoiBkcNAAsgBwUgBgs2AgAgAyAJTw0BA0ACfyACKAKEAyIEQQlPBEAgAigC5AIhBSACKALoAiEHIAsMAQsgBCEFIAshB0EIIQQgEwshBiAEIAVGBH8gAkHgAmoQzQYgAigC6AIhByALIQYgAigC5AIFIAULQQJ0IAdqIAM2AgAgBiAGKAIAQQFqNgIAIANBAWoiAyAJRw0ACwwBCyARIAY2AgALIAJB8ABqIAJBgANqKQIANwMAIAJB4ABqIAJB8AJq/QACAP0LAwAgAiAC/QAC4AL9CwNQIAAoAhAgACgCFCAIIAIoAnQiBUEJTwR/IAIoAlQhBSACKAJYBSANCyAFEOQFIAIoArQCIQMgAigCsAIhBCAQQRhqIBRBGGooAgA2AgAgEEEQaiAUQRBqKQIANwIAIBAgFP0AAgD9CwIAIAIgBDYC4AIgAiADIAIoAtQCIgkgCUEISyIEGyIONgKMAyACIAlBACAEGzYChAMgAkEAIAMgBBs2AuQCIA4EQCACKALoAiALIAQbIRFBACEIIAIoAqgCIQoDQCACIAgiBEEBaiIINgKIAyARIARBAnRqKAIAIQUgAigCoAIgCkYEQCACQaACakHIwcEAEIsGCyACKAKkAiAKQQJ0aiAFNgIAIAIgCkEBaiIKNgKoAgJ/AkAgACgCCCIEIAVLBEAgACgCBCAFQSRsaiIGLwEcIQRBACEHQQAgBi8BHiIDQf//AXEiD0GA+AFLDQIaQQAgBEH//wFxIhJBgPgBSw0CGiADwUEASA0BIAMgBEsgBMFBAE4NAhogAyASckEARwwCCyAFIARB1MDHABCMBwALIATBQQBIIAMgBElxCyESIAMgBCASGyAEIA9BgfgBSRshBAJAIAYvASAiA0H//wFxIg9BgPgBSw0AIARB//8BcSISQYD4AUsNACADwUEATgRAIATBQQBOBEAgAyAEQf//A3FLIQcMAgsgAyASckEARyEHDAELIATBQQBIIAMgBEH//wNxSXEhBwsgBi8BFCEGAn8gAyAEIAcbIAQgD0GB+AFJGyIDQf//AXFFBEAgA0EQdAwBCyADQf8HcSEEIANBgIACcSEHIANBgPgBcSIDQYD4AUYEQCAHQRB0IgNBgICA/AdyIARFDQEaIAMgBEENdHJBgICA/gdyDAELIAdBEHQiByADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAMNABogB0GAgIDYA3IgBGdBEGsiA0EXdGsgBCADQf//A3FBCGp0Qf///wNxcgu+EIkEIQFDAACAPyFAAn8gBkEQdCAGQf//AXFFDQAaIAZB/wdxIQQgBkGAgAJxIQMgBkGA+AFxIgZBgPgBRgRAIANBEHQiA0GAgID8B3IgBEUNARogAyAEQQ10ckGAgID+B3IMAQsgA0EQdCIDIAZBDXRBgICA/ABxIARBDXRyQYCAgMADanIgBg0AGiADQYCAgNgDciAEZ0EQayIDQRd0ayAEIANB//8DcUEIanRB////A3FyC74iQUMAAIA/XgRAIEEQxgVDVPgtQJRDAACAP5KRIUALIAIoApgBIgMgAigCkAFGBEAgAkGQAWpByJXBABD5BQsgAigClAEiBiADQQN0aiIEIAU2AgQgBCABIAGSIECUIgE4AgAgAiADQQFqNgKYAQJAIANFBEBBACEEDAELIAEgAVwEQANAAkAgBiADQQFrIg9BAXYiBEEDdGoiByoCACJAIEBbIAEgQF9FcQ0AIAUgB0EEaigCAEsNACADIQQMAwsgBiADQQN0aiAHKQIANwIAIAQhAyAPQQJPDQAMAgsACwNAIAYgA0EBayIPQQF2IgRBA3RqIgcqAgAiQCBAWyABIEBfRXFBfyABIEBgGyISQQBMIAUgB0EEaigCAE0gEhsEQCADIQQMAgsgBiADQQN0aiAHKQIANwIAIAQhAyAPQQFLDQALCyAGIARBA3RqIgQgBTYCBCAEIAE4AgAgCCAORw0ACwsgCUEJTwRAIAIoAugCIgRBBGsoAgAiA0F4cSIFIAlBAnQiBkEEQQggA0EDcSIDG2pJDQQgA0EAIAUgBkEnaksbDQsgBBCiAgsgAigCdCIEQQlPBEAgAigCWCIDQQRrKAIAIgVBeHEiBiAEQQJ0IgRBBEEIIAVBA3EiBRtqSQ0KIAVBACAGIARBJ2pLGw0LIAMQogILIAIoApgBIgoNAAsLIAIoApABIgRFDQAgAigClAEiA0EEaygCACIFQXhxIgYgBEEDdCIEQQRBCCAFQQNxIgUbakkNByAFQQAgBiAEQSdqSxsNAyADEKICCyACKALMASIDDQEMBAsLDAQLDAQLAAsgAigCqAIhBQsgAiAAKAIIIgQ2AlAgAiAFNgKwAiAEIAVHBEAgAkEANgLgAkEAIAJBsAJqIAJB0ABqIAJB4AJqQazDwQAQ9QcACyAAIAIoAqQCIgAgBRDwASACQcABahDrAwJAIAIoAqACIgQEQCAAQQRrKAIAIgNBeHEiBSAEQQJ0IgRBBEEIIANBA3EiAxtqSQ0CIANBACAFIARBJ2pLGw0BIAAQogILIAJB8ANqJAAPCwwBC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu6vgEEF38TfgR7Cn0jAEGAA2siAyQAIAAQngEgAyACOgAnIAMgATgCICADIAAoAggiBjYC8AIgAyADQSdqrUKAgICAwAGENwPIASADIANBIGqtQoCAgIDQAYQ3A8ABIAMgA0HwAmqtIhpCgICAgBCENwO4ASADQgM3AuwBIANBAzYC5AEgA0GA48EANgLgASADIANBuAFqNgLoASADQZABaiADQeABahDsAwJAAkACQCADKAKQASICBEAgAygClAEiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgAmpJDQEgBUEAIAYgAkEnaksbDQIgBBCiAiAAKAIIIQYLAkACQAJAAkAgBkUNACAGQQJ0IggQcSIHRQ0BQQAhAgJAAkACQCAGQQRPBED9DAAAAAABAAAAAgAAAAMAAAAhLSAHIQUgBkH8//8fcSICIQQDQCAFIC39CwIAIAVBEGohBSAt/QwEAAAABAAAAAQAAAAEAAAA/a4BIS0gBEEEayIEDQALIAIgBkYNAQsgByACQQJ0aiEFA0AgBSACNgIAIAVBBGohBSAGIAJBAWoiAkcNAAsgAyAANgLkASADIANB/wJqNgLgASADIANB4AFqNgK4ASAGQQFGDQIMAQsgAyAANgLkASADIANB/wJqNgLgASADIANB4AFqNgK4AQsgBkEVTwRAIANBuAFqIQUjAEGAIGsiCiQAAkACQAJAAkACQEGAifoAIAYgBkGAifoATxsiBCAGIAZBAXZrIgIgAiAESRsiBEGBCE8EQCACQf////8DSw0CQTAgBCAEQTBNGyIJQQJ0IgJB/f///wdPDQIgAhBxIgRFDQMgByAGIAQgCSAGQcEASSAFEFUgBEEEaygCACIFQXhxIglBBEEIIAVBA3EiBRsgAmpJDQQgBUEAIAkgAkEnaksbDQUgBBCiAgwBCyAHIAYgCkGACCAGQcEASSAFEFULIApBgCBqJAAMBQtB2JXBABD/BwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBBCECA0AgByACIAdqIANB4AFqEPoBIAggAkEEaiICRw0ACwsgACAHIAYQ8AFDAACAPyEBAn8CQAJAIAdBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAhqTwRAIAJBACAEIAhBJ2pLGw0JIAcQogIgABCaBCAAKAIIRQ0BIAAoAgQiBRCKBCExIAUvARQiAkH//wFxIghFBEAgAkEQdAwECyACQf8HcSEEIAJBgIACcSEGIAJBgPgBcSIHQYD4AUYEQCAGQRB0IgZBgICA/AdyIARFDQQaIAYgBEENdHJBgICA/gdyDAQLIAZBEHQhBiAHRQ0CIAdBDXRBgICA/ABxIARBDXRyQYCAgMADaiAGcgwDCwwHC0EAQQBB1MDHABCMBwALIAZBgICA2ANyIARnQRBrIgZBF3RrIAQgBkH//wNxQQhqdEH///8DcXILviIyQwAAgD9eBEAgMhDGBUNU+C1AlEMAAIA/kpEhAQsgAyoCICEyIANB//8BIDEgMZIgAZRDvTeGNRDgCBDGBSAyEMYFlY0iAfwAQYCAfiABQwAAAMdgGyABQwD+/0ZeG0EAIAEgAVsbOwEoIAMgBRCKBCIBIAGSAn8gAkEQdCAIRQ0AGiACQf8HcSEEIAJBgIACcSEFIAJBgPgBcSICQYD4AUYEQCAFQRB0IgJBgICA/AdyIARFDQEaIAIgBEENdHJBgICA/gdyDAELIAVBEHQiBSACQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAINABogBUGAgIDYA3IgBGdBEGsiAkEXdGsgBCACQf//A3FBCGp0Qf///wNxcgu+IgFDAACAP14EfSABEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUOALwAiADIBpCgICAgNABhDcDwAEgAyADQShqrUKAgICA4AGENwO4ASADQgI3AuwBIANBAjYC5AEgA0G448EANgLgASADIANBuAFqNgLoASADQZABaiADQeABahDsAyADKAKQASICBEAgAygClAEiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgAmpJDQUgBUEAIAYgAkEnaksbDQYgBBCiAgsgAyADLwEoOwEqIAMgACgCCDYCLCADQQA2AjAgA0EANgI8IANCgICAgIABNwI0IANBADYCSCADQoCAgIDAADcCQEHYtskAKAIAIgJFBEAQkwUhAgsgAigCACACKAIEKAIMEQQAIQIgA0HwmsgA/QADAP0LA+ABIAMgAq1Cxs7rhrfq7a0ShSIbQjiGIBtCgP4Dg0IohoQgG0KAgPwHg0IYhiAbQoCAgPgPg0IIhoSEQpK23Z0FhELSgaqbq/qC16d/fiIaQoDoAoNCKIYgGkKAgJQDg0IYhiAaQoCAgKgKg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQoCAgICAgICARIQgG0LYotHvwqnlvy1+hSIcQu3cspuNpYnMywCFIhpC2KLR78Kp5b8tfiAaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhISFQov9+pfHxteXhn+FIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRC0oGqm6v6gtenf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQtii0e/CqeW/LX6FIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRCiKyRp/aIgJywf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQs+O/8e788bUd36FIBqJNwOIAiADIBxC1oLNoZD9lI5LhSIaQtii0e/CqeW/LX4gGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhELSgaqbq/qC16d/fiIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEhUL8w7ynyZXV5OgAhSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLYotHvwqnlvy1+hSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQoiskaf2iICcsH9+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLPjv/Hu/PG1Hd+hSAaiTcDgAIgAyAcQvzDvKfJldXk6ACFIhpC2KLR78Kp5b8tfiAaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhISFQu3cspuNpYnMywCFIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRC0oGqm6v6gtenf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQtii0e/CqeW/LX6FIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRCiKyRp/aIgJywf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQs+O/8e788bUd36FIBqJNwP4ASADIBxCi/36l8fG15eGf4UiGkLYotHvwqnlvy1+IBpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRC0oGqm6v6gtenf34iGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhIVC1oLNoZD9lI5LhSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLYotHvwqnlvy1+hSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQoiskaf2iICcsH9+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLPjv/Hu/PG1Hd+hSAaiTcD8AEgA0HQAGqtIiNCgICAgBCEISQgA0Esaq1CgICAgBCEISUgA0Ewaq1CgICAgBCEISYgA0HMAGqtQoCAgIDQAYQhJyADQSpqrUKAgICA4AGEISggA0GAAWqtIilCgICAgPABhCEqIANB3ABqrUKAgICA8AGEISsgA0G8AWohECADQeQAaiETIANBzAFqIRQgA0HQAWohEgJAAkACQAJAA0AgAyADKgIgIAMuASqyELcKOAJMAkAgAygCMCICIAMoAixPDQADQAJ/AkAgACgCCCIEIAJLBEAgACgCBCACQSRsaiIGLwEcIQRBACEIQQAgBi8BHiIFQf//AXEiB0GA+AFLDQIaQQAgBEH//wFxIgpBgPgBSw0CGiAFwUEASA0BIAQgBUkgBMFBAE4NAhogBSAKckEARwwCCyACIARB1MDHABCMBwALIATBQQBIIAQgBUtxCyEKIAUgBCAKGyAEIAdBgfgBSRshBAJAIAYvASAiBUH//wFxIgdBgPgBSw0AIARB//8BcSIKQYD4AUsNACAFwUEATgRAIATBQQBOBEAgBSAEQf//A3FLIQgMAgsgBSAKckEARyEIDAELIATBQQBIIAUgBEH//wNxSXEhCAsgBi8BFCEGAn8gBSAEIAgbIAQgB0GB+AFJGyIFQf//AXFFBEAgBUEQdAwBCyAFQf8HcSEEIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIARFDQEaIAUgBEENdHJBgICA/gdyDAELIAdBEHQiByAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAUNABogB0GAgIDYA3IgBGdBEGsiBUEXdGsgBCAFQf//A3FBCGp0Qf///wNxcgu+EIkEITFDAACAPyEBAn8gBkEQdCAGQf//AXFFDQAaIAZB/wdxIQQgBkGAgAJxIQUgBkGA+AFxIgZBgPgBRgRAIAVBEHQiBUGAgID8B3IgBEUNARogBSAEQQ10ckGAgID+B3IMAQsgBUEQdCIFIAZBDXRBgICA/ABxIARBDXRyQYCAgMADanIgBg0AGiAFQYCAgNgDciAEZ0EQayIFQRd0ayAEIAVB//8DcUEIanRB////A3FyC74iMkMAAIA/XgRAIDIQxgVDVPgtQJRDAACAP5KRIQELIAMqAkwgMSAxkiABlF0NASADKAI8IgQgAygCNEYEQCADQTRqEJMGCyADKAI4IARBBXRqIgUgAjYCACAFQgA3AgggBUEQav0MAAAAAAAAAAAAAAAAAAAAAP0LAgAgAyAEQQFqNgI8IAMgAygCMEEBaiICNgIwIAIgAygCLEkNAAsLIAMgJTcD0AEgAyAmNwPIASADICc3A8ABIAMgKDcDuAFBPBBxIgJFDQYgA0EANgL4AiADIAI2AvQCIANBPDYC8AIgA0IENwKcASADQQQ2ApQBIANB+OPBADYCkAEgAyADQbgBajYCmAECQCADQfACakGM78EAIANBkAFqEMEDRQRAIAMoAvACIgIEQCADKAL0AiIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyACakkNDCAFQQAgBiACQSdqSxsNDSAEEKICCwJAAkAgAygCPCIHRQ0AIAMoAjgiBiAHQQV0aiEIIAP9CQJMIS4gBiECA0AgAigCACIEIAAoAggiBU8NAiACQQhqIAAoAgQgBEEkbGoiBP1dAgggBCoCECIB/SACIAH9IAMgLv3nAf1oIi39HwD8BCIbQv///wCDIhpCEIYgG0IghoQgGoRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX5CyaSSyaSSyaQSgyAbQhWIIh9CP4aEIC39HwH8BCIcQv///wCDIhpCEIYgHEIghoQgGoRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCCn5Cksmkksmkkskkg4QgLf0fAvwEIhpC////AIMiHUIQhiAaQiCGhCAdhEL/gYD4j4DAD4NCgQJ+Qo/gg/iAnsCHEINCEX5Cw+GwmIyGw+EQg0IUfkKkksmkksmkkskAg4Q3AwAgAkEYaiAcQiqIIh1CEIYgHUIghoQgHYRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX5CyKSSyaSSyaQSgyAcQoCAgICAgICAgH+DhEIBiCAbQiqIIh5CEIYgHkIghoQgHoRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX5CyaSSyaSSyaQSgyIeIBtCgICAgICAgICAf4OEQgKIhCAaQiqIIhtCEIYgG0IghoQgG4RC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX4iG0LIpJLJpJLJpBKDIBpCgICAgICAgICAf4OEIBtCAYOEhDcDACACQRBqIBxCFYgiG0L///8AgyIcQhCGIBtCIIaEIByEQv+BgPiPgMAPg0KBAn5Cj+CD+ICewIcQg0IRfkLD4bCYjIbD4RCDQgV+QsikksmkksmkEoMgHUI/hoQgG0IBg4QgH0L///8AgyIbQhCGIB9CIIaEIBuEQv+BgPiPgMAPg0KBAn5Cj+CD+ICewIcQg0IRfkLD4bCYjIbD4RCDQgV+QgGIQqSSyaSSyaSSCYMgHkI+hoSEIBpCFYgiG0L///8AgyIcQhCGIBtCIIaEIByEQv+BgPiPgMAPg0KBAn5Cj+CD+ICewIcQg0IRfkLD4bCYjIbD4RCDQgp+QpDJpJLJpJLJJIMgGkIUiEICg4SENwMAIAJBIGoiAiAIRw0ACyAHQQFGDQAgB0EVTwRAIAYgBxD+AwwBCyAGQSBqIQVBACEJIAYhCwNAIAshAiAFIQsgAikDOCEcIAIpAygiHSEaAkACQCAdIAIpAwgiG1INACACKQMwIhogAikDECIbUg0AIAIpAxgiGyAcIhpRDQELIBogG1oNACACKQMwIR8gAikDICEeIAkhBQNAAkAgBSAGaiICQSBqIgQgAv0AAwD9CwMAIAJBMGogAkEQav0AAwD9CwMAIAVFBEAgAkEgaiEEIAYhAgwBCwJAIAJBGGspAwAiGyAdIhpSDQAgBSAGakEQaykDACIbIB8iGlINACACQQhrKQMAIhsgHCIaUQ0BCyAFQSBrIQUgGiAbVA0BCwsgAiAeNwMAIARBCGsgHDcDACAEQRBrIB83AwAgBEEYayAdNwMACyAJQSBqIQkgC0EgaiIFIAhHDQALCyADICQ3A/ACIAMgBzYCUEEeEHEiAkUNCSADQQA2ApgBIAMgAjYClAEgA0EeNgKQASADQgE3AsQBIANBATYCvAEgA0Go5MEANgK4ASADIANB8AJqNgLAASADQZABakGM78EAIANBuAFqEMEDRQRAIAMoApABIgIEQCADKAKUASIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyACakkNDiAFQQAgBiACQSdqSxsNDyAEEKICCyADQQA2AlggA0KAgICAwAA3AlAgA0EANgKMASADQoCAgIDAADcChAEgA0EANgJcIANBADYCgAEgB0UEQEL///////////8AIR1CgICAgICAgICAfyEfQoCAgICAgICAgH8hHkKAgICAgICAgIB/ISBC////////////ACEhQv///////////wAhIgwEC0KAgICAgICAgIB/ISBC////////////ACEiQQAhAkL///////////8AISFC////////////ACEdQoCAgICAgICAgH8hHkKAgICAgICAgIB/IR8DQAJAAkAgAygCOCINIAJBBXQiCWoiBSgCACIGIAAoAggiBEkEQCAAKAIEIgsgBkEkbGoiBv1dAgggBioCECIB/SACIAH9IAMgA/0JAkwiLv3nAf1oIi39HwL8BCEaIC39HwH8BCEbIC39HwD8BCEcIAcgAkEBaiIITQRAIAIhCgwDCyAHQQFrIQogFUEBcQRAIAchCAwDCyAJIA1qQSBqIQYDQCAGKAIAIgkgBE8NAiALIAlBJGxqIgn9XQIIIAkqAhAiAf0gAiAB/SADIC795wH9aCIt/R8A/AQgHFIgLf0fAfwEIBtSckUgLf0fAvwEIBpRcUUEQCAIQQFrIQoMBAsgBkEgaiEGIAcgCEEBaiIIRw0ACyAHIQgMAgsgBiAEQdTAxwAQjAcACyAJIARB1MDHABCMBwALIB8gGiAaIB9TGyEfIB4gGyAbIB5TGyEeICAgHCAcICBTGyEgIB0gGiAaIB1VGyEdICEgGyAbICFVGyEhICIgHCAcICJVGyEiIAMgAygCgAFBAWo2AoABIAMpA/gBIhogCCACayILrYUiG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhELSgaqbq/qC16d/fiIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEIBtC2KLR78Kp5b8tfoUiGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhCADKQPwASIbQn+FfiIcQjiGIBxCgP4Dg0IohoQgHEKAgPwHg0IYhiAcQoCAgPgPg0IIhoSEIBxCCIhCgICA+A+DIBxCGIhCgID8B4OEIBxCKIhCgP4DgyAcQjiIhISEIBogG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhH6FIBqJIhpCGYgiHEL/AINCgYKEiJCgwIABfiEsIAMoAuABIgZBCGshDEEAIREgAygC5AEiByAapyIOcSIJIQQCfwJAA0AgBCAGaikAACIbICyFIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIaUEUEQANAIAwgGnqnQQN2IARqIAdxIg9BA3RrKAIAIAtGDQMgGkIBfSAagyIaUEUNAAsLIBsgG0IBhoNCgIGChIiQoMCAf4NQBEAgBCARQQhqIhFqIAdxIQQMAQsLIAMoAugBRQRAIANB4AFqIANB8AFqEJwBIAMoAuQBIgcgDnEhCSADKALgASEGCyAGIAlqKQAAQoCBgoSIkKDAgH+DIhpQBEBBCCEEA0AgBCAJaiEJIARBCGohBCAGIAcgCXEiCWopAABCgIGChIiQoMCAf4MiGlANAAsLIAYgGnqnQQN2IAlqIAdxIgRqLAAAIglBAE4EQCAGIAYpAwBCgIGChIiQoMCAf4N6p0EDdiIEai0AACEJCyAEIAZqIBynQf8AcSIMOgAAIAYgBEEIayAHcWpBCGogDDoAACAGIARBA3RrIgZBBGtBADYCACAGQQhrIAs2AgAgAyADKALsAUEBajYC7AEgAyADKALoASAJQQFxazYC6AFBAQwBCyAGQQAgD2tBA3RqIgZBBGsoAgBBAWoLIQQgBkEEayAENgIAAkACQAJAAkACQAJAIAtBAU0EQCACIAMoAjwiB08NASAFKAIAIQQgAygCWCICIAMoAlBGBEAgA0HQAGpBsOXBABCLBgsgAygCVCACQQJ0aiAENgIAIAMgAkEBajYCWAwGCyADKgJMIQEgAy0AJyEWQQAhBCADQQA2ArgBIANBADYCzAFBBCEHAn8gC0EAIAggC08bIgZBBUkEQCAQIQwgFAwBCwJAIAZBAWtnIgQEQCADQRhqIANBuAFqQX8gBHZBAWoQ6QMgAygCGCIEQYGAgIB4Rg0BIAQNFAtB2JXHAEERQdTMxwAQ6wcACyADKALMASIHQQVJBEAgByEEIBAhDEEEIQcgFAwBCyADKAK8ASEEIAMoAsABIQwgEAshCyAEIAdPDQIgByAEQX9zaiIGIAIgAygCPCIRIAIgEUsbIg4gAmsiCSAGIAlJGyIGIAIgCCACIAhLGyIXIAJrIgkgBiAJSRsiCUEBaiIPQQxNDQEgDCAEQQJ0aiIGIA0gAiAJakEFdGpBBGpJIAUgDCAEIAlqQQJ0akEEaklxDQEgDyAPQQNxIglBBCAJG2siDyEJA0AgBiAFQeAAaiAFQUBrIAVBIGogBf1cAgD9VgIAAf1WAgAC/VYCAAP9CwIAIAVBgAFqIQUgBkEQaiEGIAlBBGsiCQ0ACyACIA9qIQIgBCAPaiEEDAELIAIgB0Gg5cEAEIwHAAsgDSACQQV0aiEFIAwgBEECdGohBgJAA0AgAiAXRg0BIAIgDkYEQCAOIBFB4OXBABCMBwALIAYgBSgCADYCACAFQSBqIQUgBkEEaiEGIAJBAWohAiAHIARBAWoiBEcNAAsgByEEDAELIAsgBDYCAAwBCyALIAQ2AgAgAiAKSw0AIApBAWohCiACQQV0IQUDQCACIAMoAjwiBE8NAiADKAI4IAVqAn8gAygCzAEiB0EFSQRAIAchBiAQIQtBBCEHIBQMAQsgAygCvAEhBiADKALAASELIBALIQQoAgAhCSAGIAdGBEAgA0G4AWoQzgYgAygCvAEhBiADKALAASELIBAhBAsgCyAGQQJ0aiAJNgIAIAQgBCgCAEEBajYCACAFQSBqIQUgCiACQQFqIgJHDQALCyADQfAAaiIGIANByAFqIgcpAgA3AwAgAyAD/QACuAH9CwNgIAAgAygCdCIFQQVPBH8gAygCZCEFIAMoAmgFIBMLIAUgAUMAAAAAIBYbED8hAiADKAJYIgQgAygCUEYEQCADQdAAakHA5cEAEIsGCyADKAJUIARBAnRqIAI2AgAgAyAEQQFqNgJYIAcgBikDADcDACADIAP9AANg/QsDuAEgAygCjAEiBCADKAKEAUYEQCADQYQBahCVBgsgAygCiAEgBEEcbGoiBSACNgIAIAUgAykDuAE3AgQgBUEMaiADQcABav0AAwD9CwIAIAMgBEEBajYCjAEgAyADKAJcQQFqNgJcIAMoAjwhBwwBCyACIARB4OXBABCMBwALIAcgCCICSw0ACwwDCwwOCyAEIAVB1MDHABCMBwALDAwLIAMgKjcDmAEgAyArNwOQAUEWEHEiAkUNBiADQQA2AvgCIAMgAjYC9AIgA0EWNgLwAiADQgI3AsQBIANBAjYCvAEgA0G45MEANgK4ASADIANBkAFqNgLAAQJAAkAgA0HwAmpBjO/BACADQbgBahDBA0UEQCADKALwAiICBEAgAygC9AIiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgAmpJDQ0gBUEAIAYgAkEnaksbDQ4gBBCiAgsgAygC7AEhCiADQegBakH4msgAKQMANwMAIAMoAuQBIQsgAygC4AEhCCADQfCayAApAwA3A+ABAkACQAJAIAoEQCAIQQhqIQYCQCAIKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1IEQCAGIQIgCCEFDAELIAghBQNAIAVBQGohBSAGKQMAIAZBCGoiAiEGQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsLIApB/////wFLDQNBBCAKIApBBE0bIgRBA3QiBkH9////B08NAyAFIBpCgIGChIiQoMCAf4UiGnqnQfgAcWsiB0EEaygCACEMIAdBCGsoAgAhByAGEHEiCUUNDSAJIAw2AgQgCSAHNgIAQQEhBiADQQE2AsABIAMgCTYCvAEgAyAENgK4ASAKQQFrIgcEQCAaQgF9IBqDIRpBASEEA0AgGlAEQANAIAVBQGohBSACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBSAaeqdB+ABxayIGQQRrKAIAIQwgBkEIaygCACEGIBpCAX0gGoMhGiADKAK4ASAERgRAIANBuAFqIAQgB0EEQQgQpAUgAygCvAEhCQsgCSAEQQN0aiINIAw2AgQgDSAGNgIAIAMgBEEBaiIENgLAASAHQQFrIgcNAAsgCiEGCwJAIAtFDQAgC0EJaiICRQ0AIAhB/wEgAvwLAAsgA0EANgLsASADIAg2AuABIAMgCzYC5AEgAyALIAtBAWpBA3ZBB2wgC0EISRs2AugBIAMoArgBIQ0gAygCvAEhCCAGQQJJDQIgBkEVSQ0BIAggBhDOBAwCCwJAIAtFDQAgC0EJaiICRQ0AIAhB/wEgAvwLAAtBACENIANBADYC7AEgAyAINgLgASADIAs2AuQBIAMgCyALQQFqQQN2QQdsIAtBCEkbNgLoAUEEIQgMAQsgCEEIaiEEIAggBkEDdGohBkEAIQcDQCAEKAIAIgUgBEEIaygCAEkEQCAENQIEIRogByECAn8DQCACIAhqIgpBCGogCikCADcCACAIIAJFDQEaIAUgAkEIayICIAhqIgooAgBJDQALIApBCGoLIAWtIBpCIIaENwIACyAHQQhqIQcgBEEIaiIEIAZHDQALCyADKAJIIgcgAygCQEYEQCADQUBrQcjkwQAQogYLIAMoAkQiDCAHQQxsaiICIAMpAoQBNwIAIAJBCGogA0GMAWooAgA2AgAgA0EANgI8IAMgB0EBaiIKNgJIIAMoAlQhBCADKAJQIQkCQAJAIAMoAlgiAiADKAI0SwRAIANBNGpBACACQQhBIBCkBSADKAI4IREgAygCPCEGDAELQQAhBiADKAI4IREgAkUNAQsgAkECdCILQQRrIg5BBHEEfyAEBSAEKAIAIQUgEEEQakIANwIAIBD9DAAAAAAAAAAAAAAAAAAAAAD9CwIAIBEgBkEFdGoiAiAFNgIAIAIgAykCuAE3AgQgAkEMaiADQcABav0AAgD9CwIAIAJBHGogEigCADYCACAGQQFqIQYgBEEEagshBSAORQ0AIAQgC2ohCyARIAZBBXRqIQIDQCACIAUoAgA2AgAgEEEQaiIOQgA3AgAgEP0MAAAAAAAAAAAAAAAAAAAAAP0LAgAgAkEEaiADKQK4ATcCACACQQxqIANBwAFqIg/9AAIA/QsCACACQRxqIBIoAgA2AgAgBUEEaigCACEWIA5CADcCACAQ/QwAAAAAAAAAAAAAAAAAAAAA/QsCACACQSBqIBY2AgAgAkEkaiADKQK4ATcCACACQSxqIA/9AAIA/QsCACACQTxqIBIoAgA2AgAgAkFAayECIAZBAmohBiAFQQhqIgUgC0cNAAsLIAMgBjYCPAJAIAkEQCAEQQRrKAIAIgJBeHEiBSAJQQJ0IglBBEEIIAJBA3EiAhtqSQ0BIAJBACAFIAlBJ2pLGw0QIAQQogILIAMgAy8BKkEBajsBKiADKAIwIAMoAixJDQQgAygCgAFBAUcNAwJAIA0EQCAIQQRrKAIAIgJBeHEiBCANQQN0IgVBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAVBJ2pLGw0RIAgQogILIAMgBjYCfCAGQQFGBEAgAyARKAIANgKAAUEcEHEiAkUNDSACQv////8PNwIAIAJBATYCGCACIAMoAoABNgIIIAMoAkAgCkYEQCADQUBrQdzkwQAQogYgAygCRCEMCyAMIApBDGxqIgRBATYCCCAEIAI2AgQgBEEBNgIAIAMgB0ECaiIKNgJIIAMgKUKAgICAEIQ3A/ACIANCATcCxAEgA0EBNgK8ASADQfjkwQA2ArgBIAMgA0HwAmo2AsABIANBkAFqIANBuAFqEOwDAkAgAygCkAEiAgRAIAMoApQBIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIAJqSQ0BIAVBACAGIAJBJ2pLGw0TIAQQogILIAMoAoABIgIgACgCCCIESQRAIAMgACgCBCACQSRsajYCUCADICNCgICAgIADhDcD8AIgA0IBNwLEASADQQE2ArwBIANBiOXBADYCuAEgAyADQfACajYCwAEgA0GQAWogA0G4AWoQ7AMCQCADKAKQASICBEAgAygClAEiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgAmpJDQEgBUEAIAYgAkEnaksbDRUgBBCiAgtBACECIANBADYCmAEgA0KAgICAwAA3ApABQQAhCSAKRQ0OIANBvAFqIhRBEGohGEEEIQtBACEIAkADQCADIApBAWsiEzYCSCAMIBNBDGxqIhIoAgAiD0GAgICAeEYEQCATIQoMDgsCQAJAIBIpAgQiGqciECAaQiCIpyINQRxsaiIOAn8gGkKAgICAEFoEQCAOIBBrIgVBHG4iBkEBcUEAIQRBACEHIAVBHGtBHE8EQCAGQf7///8AcSEWIBAhBQNAIAVBGGooAgAiBkEFTwR/IAVBCGooAgAFIAYLIARqIAVBNGooAgAiBkEFTwRAIAVBJGooAgAhBgsgBUE4aiEFIAZqIQQgFiAHQQJqIgdHDQALCwR/IBAgB0EcbGoiBSgCGCIGQQVPBH8gBSgCCAUgBgsgBGoFIAQLIAlqQYCABEsNAiAQIQUCQANAIAVBHGoiEiAFKAIEIgRBAkYNAxogBSgCACEWIBggBUEYaigCADYCACAUIAX9AAII/QsCACADIAQ2ArgBIBQhBSADKALMASIXIQogF0EFSSIZRQRAIAMoArwBIQogAygCwAEhBQsCQCAWQX9GDQACQAJAIApBACAKIAggCmoiCU0bIhVB/////wNLDQAgFUECdCIEQf3///8HTw0AQQAhBwJAIARFBEBBBCEEQQAhFQwBCyAEEHEiBEUNHAsCQCAIIAlPDQBBACENIAghBiAKQQRPBEAgBv0R/QwAAAAAAQAAAAIAAAADAAAA/a4BIS0gBCEGIApBfHEiDSEHA0AgBiAt/QsCACAGQRBqIQYgLf0MBAAAAAQAAAAEAAAABAAAAP2uASEtIAdBBGsiBw0ACyANIAoiB0YNASAIIA1qIQYLIAQgDUECdGohBwNAIAcgBjYCACAHQQRqIQcgCSAGQQFqIgZHDQALIAohBwsgACgCECAAKAIUIBYgBCAHEOQFIAghCSAVRQ0CIARBBGsoAgAiBkF4cSIHIBVBAnQiCUEEQQggBkEDcSIGG2pJDR4gBkEAIAcgCUEnaksbDQEgBBCiAiAIIQkMAgtB4P/GABD/BwALDB0LIAoEQCAKQQJ0IQcgCEECdCEGIAghAgNAIAUoAgAhBCAFQQRqIQUgAygCkAEgAkYEQCADQZABakGs4sEAEIsGIAMoApQBIQsLIAYgC2ogBDYCACADIAJBAWoiAjYCmAEgBkEEaiEGIAIhCCACIQkgB0EEayIHDQALCwJAIBlFBEAgAygCwAEiBEEEaygCACIFQXhxIgYgF0ECdCIHQQRBCCAFQQNxIgUbakkNASAFQQAgBiAHQSdqSxsNAyAEEKICCyAOIBIiBUcNAQwGCwsMGgsMGgsgAkGAgARLDQEgAiEIIAIhCSAQCyIEa0EcbiEFIAQgDkYNAQNAIARBGGooAgAiBkEFTwRAIARBDGooAgAiB0EEaygCACIKQXhxIhIgBkECdCIGQQRBCCAKQQNxIgobakkNGSAKQQAgEiAGQSdqSxsNGiAHEKICCyAEQRxqIQQgBUEBayIFDQALDAELIBIgDTYCCCASIBA2AgQMDgsCQCAPBEAgEEEEaygCACIEQXhxIgUgD0EcbCIGQQRBCCAEQQNxIgQbakkNASAEQQAgBSAGQSdqSxsNAyAQEKICCyATIgoNAQwPCwsMFAsMFAsMEgsgAiAEQdTAxwAQjAcACwwQCyADQQA2ArgBQQAgA0H8AGpB2OTBACADQbgBakGQ5cEAEPUHAAsMDgsMDQtB4P/GABD/BwALDA0LAkAgDQRAIAhBBGsoAgAiAkF4cSIEIA1BA3QiBUEEQQggAkEDcSICG2pJDQwgAkEAIAQgBUEnaksbDQEgCBCiAgsgICAifSIaIB4gIX0iGyAfIB19IhwgGyAcVRsiGyAaIBtVG0ICUyAVciEVDAILDAsLIA1FDQAgCEEEaygCACICQXhxIgQgDUEDdCIFQQRBCCACQQNxIgIbak8EQCACQQAgBCAFQSdqSxsNCyAIEKICDAELCwwICyAKDQELQQAhCQwBCyADQbwBaiIQQRBqIRYCQANAIAMgCkEBayIKNgJIIAwgCkEMbGoiBCgCACISQYCAgIB4RgRAIAohCQwDCyAEKQIEIhqnIgkgGkIgiKdBHGxqIRQCQAJAAkAgGkKAgICAEFQEQCAJIQQMAQsgCSEFA0AgBUEcaiEEIAUoAgQiBkECRg0BIAUoAgAhFSAWIAVBGGooAgA2AgAgECAF/QACCP0LAgAgAyAGNgK4ASAQIQUgAygCzAEiDiEIIA5BBUkiF0UEQCADKAK8ASEIIAMoAsABIQULAkAgFUF/Rg0AAkAgCEEAIAggAiAIaiIPTRsiDUH/////A0sNACANQQJ0IgZB/f///wdPDQBBACEHAkAgBkUEQEEEIQtBACENDAELIAYQcSILRQ0LCwJAIAIgD08NAEEAIRMgAiEGIAhBBE8EQCAC/RH9DAAAAAABAAAAAgAAAAMAAAD9rgEhLSALIQYgCEF8cSITIQcDQCAGIC39CwIAIAZBEGohBiAt/QwEAAAABAAAAAQAAAAEAAAA/a4BIS0gB0EEayIHDQALIBMgCCIHRg0BIAIgE2ohBgsgCyATQQJ0aiEHA0AgByAGNgIAIAdBBGohByAPIAZBAWoiBkcNAAsgCCEHCyAAKAIQIAAoAhQgFSALIAcQ5AUgDUUNASALIA1BAnRBBBCiBwwBC0Hg/8YAEP8HAAsgCARAIAhBAnQhByACQQJ0IQYDQCAFKAIAIQggAygCkAEgAkYEQCADQZABakGs4sEAEIsGCyAFQQRqIQUgAygClAEgBmogCDYCACADIAJBAWoiAjYCmAEgBkEEaiEGIAdBBGsiBw0ACwsgF0UEQCADKALAASAOQQJ0QQQQogcLIBQgBCIFRw0ACwwBCyAUIARrQRxuIQUgBCAURg0AA0AgBEEYaigCACIGQQVPBEAgBEEMaigCACIHQQRrKAIAIghBeHEiCyAGQQJ0IgZBBEEIIAhBA3EiCBtqSQ0DIAhBACALIAZBJ2pLGw0FIAcQogILIARBHGohBCAFQQFrIgUNAAsLIBIEQCAJIBJBHGxBBBCiBwtBACEJIApFDQMMAQsLDAYLDAYLIAAgAygClAEiBCACEPABIAMoApABIgIEQCAEQQRrKAIAIgVBeHEiBiACQQJ0IgJBBEEIIAVBA3EiBRtqSQ0FIAVBACAGIAJBJ2pLGw0GIAQQogILAkAgAygC5AEiAkUNACACIAJBA3QiAmpBEWoiBEUNACADKALgASACa0EIayAEQQgQogcLIAkEQEEAIQsDQCAMIAtBDGxqIgYoAgQhBCAGKAIIIgUEQCAEIQIDQCACQRhqKAIAIgdBBU8EQCACQQxqKAIAIghBBGsoAgAiCkF4cSIQIAdBAnQiB0EEQQggCkEDcSIKG2pJDQkgCkEAIBAgB0EnaksbDQogCBCiAgsgAkEcaiECIAVBAWsiBQ0ACwsgBigCACICBEAgBEEEaygCACIFQXhxIgYgAkEcbCICQQRBCCAFQQNxIgUbakkNByAFQQAgBiACQSdqSxsNCCAEEKICCyALQQFqIgsgCUcNAAsLIAMoAkAiAgRAIAxBBGsoAgAiBEF4cSIFIAJBDGwiAkEEQQggBEEDcSIEG2pJDQUgBEEAIAUgAkEnaksbDQYgDBCiAgsgAygCNCICBEAgEUEEaygCACIEQXhxIgUgAkEFdCICQQRBCCAEQQNxIgQbckkNBSAEQQAgBSACQSdqSxsNBiAREKICCyAAKAIIIglFDQBBFCEGQQAhBQNAAkACfwJAAkACfwJAAkAgACgCCCICIAVLBEAgACgCBCAGaiILLwEAIgRB//8BcSIQRQ0BIARB/wdxIQIgBEGAgAJxIQcgBEGA+AFxIghBgPgBRyIMRQRAIAdBEHQiCkGAgID8B3IgAkUNBBogCiACQQ10ckGAgID+B3IMBAsgB0EQdCEKIAhFDQIgCEENdEGAgID8AHEgAkENdHJBgICAwANqIApyDAMLIAUgAkHkwMcAEIwHAAsgBEEQdL5DAACAP14NAgwFCyAKQYCAgNgDciACZ0EQayIKQRd0ayACIApB//8DcUEIanRB////A3FyC75DAACAP15FDQMgEA0BCyAEQRB0DAELIAxFBEAgB0EQdCIEQYCAgPwHciACRQ0BGiAEIAJBDXRyQYCAgP4HcgwBCyAHQRB0IgQgCEENdEGAgID8AHEgAkENdHJBgICAwANqciAIDQAaIARBgICA2ANyIAJnQRBrIgRBF3RrIAIgBEH//wNxQQhqdEH///8DcXILQwAAgD8hAb4iMUMAAIA/XgRAIDEQxgVDVPgtQJRDAACAP5KRQwAAgL+SQwAAgD6UQwAAgD+SIQELQwAAAEBDAACAPyABIAFDAACAP10bIgEgAUMAAABAXhu8IgdB////A3EhCCAHQYCAgIB4cSEEAkAgB0GAgID8B3EiAkGAgID8B0YEQCAIQQ12IARBEHZyQYAEQQAgCBtyQYD4AXIhBAwBCyAEQRB2IQQgAkGAgIC4BE0EQCACQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSACQQ12IAhBDXZqQYCAAWogBHJqIQQMAgsgAkGAgICYA0kNASAIQYCAgARyIgdB/gAgAkEXdiIIa3YhAiAHQR0gCGsiCHZBAXEEfyACQQMgCHRBAWsgB3FBAEdqBSACCyAEciEEDAELIARBgPgBciEECyALIAQ7AQALIAZBJGohBiAJIAVBAWoiBUcNAAsLIANBADYCjAEgA0KAgICAwAA3AoQBIANBhAFqQajBwQAQiwYgAygCiAFBADYCAEEBIQUgA0EBNgKMASADQoCAgIDAADcCYCADQgA3AmhBBBBxIgJFDQAgAkEANgIAIANB4ABqQbjBwQAQpAYgAygCZCADKAJsIgYgAygCaGoiBCADKAJgIgdBACAEIAdPG2tBDGxqIgRBATYCCCAEIAI2AgQgBEEBNgIAIAMgBkEBajYCbCADKAJsIgJFDQIgA0HQAGqtQoCAgIAQhCEdIANBQGutIhpCgICAgBCEIR8gA0E0aq1CgICAgNABhCEeIBpCgICAgNABhCEgIANBuAFqrUKAgICAkAKEISEgA0GQAWqtQoCAgICgAoQhIiADQYABaq1CgICAgLAChCEjIANBnAJqIRUgA0HoAWohEyADQeQBaiELIANBmAFqIRQgA0G8AWohECADQYQCaiESAkADQCADIAJBAWs2AmwgAyADKAJoIgJBAWoiBCADKAJgIgVBACAEIAVPG2s2AmggAygCZCACQQxsaiICKAIAIg1BgICAgHhGDQMgAikCBCEaIANBADYC+AIgA0KAgICAwAA3AvACIBqnIQUgGkIeiKdB/P///wdxIgIEQCACIAVqIRFBACEKQQQhBiAFIQkDQCAKIQICfwJAIAkoAgAiByAAKAIIIgRJBEAgACgCBCAHQSRsaiIMLwEcIQRBACEKQQAgDC8BHiIIQf//AXEiDkGA+AFLDQIaQQAgBEH//wFxIg9BgPgBSw0CGiAIwUEASA0BIAQgCEkgBMFBAE4NAhogCCAPckEARwwCCyAHIARB1MDHABCMBwALIATBQQBIIAQgCEtxCyEPIAggBCAPGyAEIA5BgfgBSRshBAJAIAwvASAiCEH//wFxIg5BgPgBSw0AIARB//8BcSIPQYD4AUsNACAIwUEATgRAIATBQQBOBEAgCCAEQf//A3FLIQoMAgsgCCAPckEARyEKDAELIATBQQBIIAggBEH//wNxSXEhCgsgDC8BFCEMAn8gCCAEIAobIAQgDkGB+AFJGyIIQf//AXFFBEAgCEEQdAwBCyAIQf8HcSEEIAhBgIACcSEKIAhBgPgBcSIIQYD4AUYEQCAKQRB0IghBgICA/AdyIARFDQEaIAggBEENdHJBgICA/gdyDAELIApBEHQiCiAIQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAgNABogCkGAgIDYA3IgBGdBEGsiCEEXdGsgBCAIQf//A3FBCGp0Qf///wNxcgu+EIkEITFDAACAPyEBAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQQgDEGAgAJxIQggDEGA+AFxIgpBgPgBRgRAIAhBEHQiCEGAgID8B3IgBEUNARogCCAEQQ10ckGAgID+B3IMAQsgCEEQdCIIIApBDXRBgICA/ABxIARBDXRyQYCAgMADanIgCg0AGiAIQYCAgNgDciAEZ0EQayIIQRd0ayAEIAhB//8DcUEIanRB////A3FyC74iMkMAAIA/XgRAIDIQxgVDVPgtQJRDAACAP5KRIQELIAMoAvACIAJGBEAgA0HwAmpByJXBABD5BSADKAL0AiEGCyAGIAJBA3RqIgQgBzYCBCAEIDEgMZIgAZQiATgCACADIAJBAWoiCjYC+AICQCACRQRAQQAhBAwBCyABIAFcBEADQAJAIAYgAkEBayIMQQF2IgRBA3RqIggqAgAiMSAxWyABIDFfRXENACAHIAhBBGooAgBLDQAgAiEEDAMLIAYgAkEDdGogCCkCADcCACAEIQIgDEECTw0ADAILAAsDQCAGIAJBAWsiDEEBdiIEQQN0aiIIKgIAIjEgMVsgASAxX0VxQX8gASAxYBsiDkEATCAHIAhBBGooAgBNIA4bBEAgAiEEDAILIAYgAkEDdGogCCkCADcCACAEIQIgDEEBSw0ACwsgBiAEQQN0aiICIAc2AgQgAiABOAIAIAlBBGoiCSARRw0ACwsgDQRAIAVBBGsoAgAiAkF4cSIEIA1BAnQiBkEEQQggAkEDcSICG2pJDQYgAkEAIAQgBkEnaksbDQcgBRCiAgsCQAJAAkAgAygC+AIiCUUNACADKAKMAUH/vwRqQYCA/P8DcSEMA0AgAyAJQQFrIgQ2AvgCIAMoAvQCIgcgBEEDdGoiAigCBCEFIAIqAgAhMQJAIARFBEAgMSEBIAUhCgwBCyAHKAIEIQogByAFNgIEIAcqAgAhASAHIDE4AgBBACECQQEhBiAJQQRPBEAgBEECayICQQAgAiAETRshCEEAIQQDQCAHIARBA3RqIAcgBiAHIAZBA3RqIgJBCGoqAgAiMiAyWyAyIAIqAgAiM2BFcSIEIARBfyAyIDNfGyAzIDNcGyIEQQBMIAJBBGooAgAgAkEMaigCAE0gBBtqIgJBA3RqKQIANwIAIAJBAXQiDUEBciEGIAIhBCAIIA1LDQALCwJAAkAgCUECayAGRgRAIAcgAkEDdGogByAGQQN0aiICKQIANwIAIAIgBTYCBCACIDE4AgAgBiECDAELIAcgAkEDdGoiBCAFNgIEIAQgMTgCACACDQBBACEEDAELIDEgMVwEQANAAkAgByACQQFrIghBAXYiBEEDdGoiBioCACIyIDJbIDEgMl9FcQ0AIAUgBkEEaigCAEsNACACIQQMAwsgByACQQN0aiAGKQIANwIAIAQhAiAIQQJPDQAMAgsACwNAIAcgAkEBayIIQQF2IgRBA3RqIgYqAgAiMiAyWyAxIDJfRXFBfyAxIDJgGyIJQQBMIAUgBkEEaigCAE0gCRsEQCACIQQMAgsgByACQQN0aiAGKQIANwIAIAQhAiAIQQFLDQALCyAHIARBA3RqIgIgBTYCBCACIDE4AgALIANBkAFqIAAoAhAgACgCFCAKEOgCIAMoAowBIQICQAJAIAMoArQBIgRBCUkiBUUEQCADKAKUASACaiIIIAxLDQEMAgsgAiAEaiIIIAxNDQELIANB8AJqIAEgChDxBCADICA3A1AgAyACs0MAAIA3lDgCQCADQgE3AuwBIANBATYC5AEgA0H4wcEANgLgASADIANB0ABqNgLoASADQbgBaiADQeABahDsAyADKAK4ASICBEAgAygCvAEiBkEEaygCACIHQXhxIghBBEEIIAdBA3EiBxsgAmpJDQsgB0EAIAggAkEnaksbDQwgBhCiAgsgBUUEQCADKAKYASICQQRrKAIAIgVBeHEiBiAEQQJ0IgRBBEEIIAVBA3EiBRtqSQ0LIAVBACAGIARBJ2pLGw0MIAIQogILIAMoAvgCIgJFDQIgAygC9AIiBCACQQN0IgZqIQggACgCBCEKIAAoAgghB/0MAACA/wAAgP8AAID/AACA/yEu/QwAAIB/AACAfwAAgH8AAIB/IS9BACEFAkACQAJAAkACQANAIAQgBWpBBGooAgAiAiAHTw0BIANB4AFqIgkgCiACQSRsaiICEJoDIAP9AATgASEtIAkgAikCABDLAiAuIAL9XQIIIAIqAhAiAf0gAiAB/SADIjAgLf0MbxKDOm8SgzpvEoM6bxKDOv3rAf0MAADAPwAAwD8AAMA/AADAP/3mASIuIC39DQgJCgsICQoLCAkKCwABAgNDAACAPyAD/QAE4AEiLf0fACIBIAEgAZIiNJQiNyAt/R8BIjEgMSAxkiIzlCI4kpP9EyABIC39HwIiNSA1kiIylCI5IC39HwMiNiAzlCI6kv0gACAxIDKUIjEgNiA0lCI0k/0gAf3gAf3mASAuIC39DQQFBgcEBQYHBAUGBwABAgMgMSA0kv0TIAEgM5QiASA2IDKUIjGT/SAAQwAAgD8gNyA1IDKUIjKSk/0gAf3gAf3mASAuIC39DQABAgMAAQIDAAECAwABAgMgOSA6k/0TQwAAgD8gOCAykpP9IAAgASAxkv0gAf3gAf3mAf3kAf3kASIt/eQB/esBIS4gLyAwIC395QH96gEhLyAGIAVBCGoiBUcNAAsgLiAv/eUBIi0gLSAt/Q0ICQoLCAkKCwABAgMAAQID/esBIjAgMCAt/Q0EBQYHAAECAwABAgMAAQID/esB/R8AIC0gLSAt/Q0ICQoLCAkKCwQFBgcEBQYH/eoBIjAgMCAt/Q0EBQYHAAECAwABAgMAAQID/eoB/R8AQwAAQECUYEUEQCADQgQ3AugCIANCADcC4AIgA0KAgICAwAA3AtgCIANCBDcC0AIgA0IANwLIAiADQoCAgIDAADcCwAIgA0IENwK4AiADQgA3ArACIANCgICAgMAANwKoAiADQgQ3AqACIANCADcCmAIgA0KAgICAwAA3ApACIC8gLv3kAf0MAAAAPwAAAD8AAAA/AAAAP/3mASIt/R8AIQEgLf0fAiExIC39HwEhMkEAIQIgAygC8AIhBwNAIAIgBGpBBGooAgAiBSAAKAIIIghPDQMgA0GQAmogFSAAKAIEIAVBJGxqIggqAgggAV0bQQBBGCAIKgIMIDJdG2oiCkEIQTggCCoCECAxXSIIG2oiDCgCACIJIApBAEEwIAgbaiINKAIARgRAIA1BsMLBABCLBgsgCkEEQTQgCBtqKAIAIAwgCUEBajYCACAJQQJ0aiAFNgIAIAYgAkEIaiICRw0ACyAHBEAgBEEEaygCACICQXhxIgUgB0EDdCIGQQRBCCACQQNxIgIbakkNESACQQAgBSAGQSdqSxsNEiAEEKICC0EgEHEiAkUNDSACIAMoApgCNgIAIAIgAygCpAI2AgQgAiADKAKwAjYCCCACIAMoArwCNgIMIAIgAygCyAI2AhAgAiADKALUAjYCFCACIAMoAuACNgIYIAIgAygC7AI2AhwgA0EINgLAASADIAI2ArwBIANBCDYCuAEgAyAhNwOQASADQgE3AuwBIANBAjYC5AEgA0GQwsEANgLgASADIANBkAFqNgLoASADQeABahDrAiADKAK4ASICBEAgAygCvAEiBEEEaygCACIFQXhxIgYgAkECdCICQQRBCCAFQQNxIgUbakkNESAFQQAgBiACQSdqSxsNBCAEEKICC0HgABBxIgJFDQ0gAiADQZACakHgAPwKAAAgAigCACEEIAJBgICAgHg2AgAgBEGAgICAeEYNBCACQQRqIg4pAgAhGiACKAIMIQcgAkGAgICAeDYCDCAHQYCAgIB4Rg0EIAIpAhAhGyACKAIkIQggAkGAgICAeDYCJCAIQYCAgIB4Rg0EIAIpAighHCACKAIYIQogAkGAgICAeDYCGCAKQYCAgIB4Rg0EIAIpAhwhJCACKAJIIQkgAkGAgICAeDYCSCAJQYCAgIB4Rg0EIAIpAkwhJSACKAJUIQwgAkGAgICAeDYCVCAMQYCAgIB4Rg0EIAIpAlghJiACKAI8IQ0gAkGAgICAeDYCPCANQYCAgIB4Rg0EIAIpAkAhJyACKAIwIREgAkGAgICAeDYCMCARQYCAgIB4Rg0EIAIpAjQhKCADKAJsIgUgAygCYCIGRgRAIANB4ABqQaDCwQAQpAYgAygCYCEGIAMoAmwhBQsgAygCZCADKAJoIAVqIg8gBkEAIAYgD00ba0EMbGoiBiAaNwIEIAYgBDYCACADIAVBAWoiBTYCbCADKAJgIgYgBUYEQCADQeAAakGgwsEAEKQGIAMoAmAhBiADKAJsIQULIAMoAmQgAygCaCAFaiIEIAZBACAEIAZPG2tBDGxqIgQgGzcCBCAEIAc2AgAgAyAFQQFqIgU2AmwgAygCYCIGIAVGBEAgA0HgAGpBoMLBABCkBiADKAJgIQYgAygCbCEFCyADKAJkIAMoAmggBWoiBCAGQQAgBCAGTxtrQQxsaiIEIBw3AgQgBCAINgIAIAMgBUEBaiIFNgJsIAMoAmAiBiAFRgRAIANB4ABqQaDCwQAQpAYgAygCYCEGIAMoAmwhBQsgAygCZCADKAJoIAVqIgQgBkEAIAQgBk8ba0EMbGoiBCAkNwIEIAQgCjYCACADIAVBAWoiBTYCbCADKAJgIgYgBUYEQCADQeAAakGgwsEAEKQGIAMoAmAhBiADKAJsIQULIAMoAmQgAygCaCAFaiIEIAZBACAEIAZPG2tBDGxqIgQgJTcCBCAEIAk2AgAgAyAFQQFqIgU2AmwgAygCYCIGIAVGBEAgA0HgAGpBoMLBABCkBiADKAJgIQYgAygCbCEFCyADKAJkIAMoAmggBWoiBCAGQQAgBCAGTxtrQQxsaiIEICY3AgQgBCAMNgIAIAMgBUEBaiIFNgJsIAMoAmAiBiAFRgRAIANB4ABqQaDCwQAQpAYgAygCYCEGIAMoAmwhBQsgAygCZCADKAJoIAVqIgQgBkEAIAQgBk8ba0EMbGoiBCAnNwIEIAQgDTYCACADIAVBAWoiBTYCbCADKAJgIgYgBUYEQCADQeAAakGgwsEAEKQGIAMoAmAhBiADKAJsIQULIAMoAmQgAygCaCAFaiIEIAZBACAEIAZPG2tBDGxqIgQgKDcCBCAEIBE2AgAgAyAFQQFqNgJsIAIoAgAiBEGAgICAeHJBgICAgHhHBEAgDigCACIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAgwiBEGAgICAeHJBgICAgHhHBEAgAigCECIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAhgiBEGAgICAeHJBgICAgHhHBEAgAigCHCIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAiQiBEGAgICAeHJBgICAgHhHBEAgAigCKCIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAjAiBEGAgICAeHJBgICAgHhHBEAgAigCNCIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAjwiBEGAgICAeHJBgICAgHhHBEAgAigCQCIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAkgiBEGAgICAeHJBgICAgHhHBEAgAigCTCIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAIoAlQiBEGAgICAeHJBgICAgHhHBEAgAigCWCIFQQRrKAIAIgZBeHEiByAEQQJ0IgRBBEEIIAZBA3EiBhtqSQ0RIAZBACAHIARBJ2pLGw0SIAUQogILIAJBBGsoAgAiBEF4cUHkAEHoACAEQQNxIgUbSQ0QIAVBACAEQYgBTxsNBSACEKICDAkLIAMgLyAu/eQB/QwAAAA/AAAAPwAAAD8AAAA//eYB/QsEACADQQBBAUECIC39HwEiASAt/R8CIjFgGyICIDEgLf0fACIyXxsgAiABIDJfGyICOgCAASADIAMgAkECdHIqAgA4AjQgAyAINgLEASADIAMoAvACNgLAASADIAQ2ArwBIAMgBDYCuAEgAyAANgKUASADIANBNGo2ApgBIAMgA0GAAWo2ApABIANB4AFqIgUgA0G4AWoiBiADQZABahCOBCADKQPgASEcIAMpAuwBIRogAygC9AEhAiADKALoASEEIAMgLf0LBJABIAMgBDYCQCADIAI2AlAgA0EGNgK8ASADQezCwQA2ArgBIANCBTcCxAEgAyAdNwOAAiADIB83A/gBIAMgHjcD8AEgAyAiNwPoASADICM3A+ABIAMgBTYCwAEgBhDrAgJAIAIgBE0EQCAaIRsgAiEGIBwhGiAEIQIMAQsgHCEbIAQhBgsgAyACNgLwASADQQI2AuQBIAMgBjYC/AEgAyAaNwLoASADIBs3AvQBQQEhAgJAIBqnIgRBgICAgHhGDQAgAykC7AEhGiADKAJsIgIgAygCYCIFRgRAIANB4ABqQZzDwQAQpAYgAygCYCEFIAMoAmwhAgsgAygCZCADKAJoIAJqIgYgBUEAIAUgBk0ba0EMbGoiBSAaNwIEIAUgBDYCACADIAJBAWo2AmxBAiECIBunIgRBgICAgHhGDQAgAykC+AEhGiADKAJsIgUgAygCYCIGRgRAIANB4ABqQZzDwQAQpAYgAygCYCEGIAMoAmwhBQsgAygCZCADKAJoIAVqIgcgBkEAIAYgB00ba0EMbGoiBiAaNwIEIAYgBDYCACADIAVBAWo2AmwLIAMgAjYC4AEgA0HgAWoQlgYMCAsgAiAHQdTAxwAQjAcACyAFIAhB1MDHABCMBwALQYyNyABBLkG8jcgAEOsHDAkLQbzDwQAQ3QkACwwLC0EAIQYgA0EANgLgASADQQA2AoQCQQghBwJAAkACfyAIIAJrIgRBACAEIAhNGyIEQQlJBEAgCyEJIBIMAQsgA0EQaiADQeABakF/IARBAWtndkEBahDoAyADKAIQIgRBgYCAgHhHBEAgBA0KQdiVxwBBEUHUzMcAEOsHAAsgAygChAIiB0EJSQRAIAchBiALIQlBCCEHIBIMAQsgAygC5AEhBiADKALoASEJIAsLIhEgBiAHSQR/IAcgBkF/c2oiBCAIIAIgAiAISRsiDiACayIFIAQgBUkbQQFqIgRBBEsEQCAJIAZBAnRqIQUgAv0R/QwAAAAAAQAAAAIAAAADAAAA/a4BIS0gBCAEQQNxIgRBBCAEG2siDSEEA0AgBSAt/QsCACAFQRBqIQUgLf0MBAAAAAQAAAAEAAAABAAAAP2uASEtIARBBGsiBA0ACyAGIA1qIQYgAiANaiECCyAJIAZBAnRqIQUDQCACIA5GDQIgBSACNgIAIAVBBGohBSACQQFqIQIgByAGQQFqIgZHDQALIAcFIAYLNgIAIAIgCE8NAQNAAn8gAygChAIiBEEJTwRAIAMoAuQBIQUgAygC6AEhByALDAELIAQhBSALIQdBCCEEIBILIQYgBCAFRgR/IANB4AFqEM0GIAMoAugBIQcgCyEGIAMoAuQBBSAFC0ECdCAHaiACNgIAIAYgBigCAEEBajYCACACQQFqIgIgCEcNAAsMAQsgESAGNgIACyADQdgBaiADQYACaikCADcDACADQcgBaiADQfABav0AAgD9CwMAIAMgA/0AAuAB/QsDuAEgACgCECAAKAIUIAogAygC3AEiBUEJTwR/IAMoArwBIQUgAygCwAEFIBALIAUQ5AUgAygClAEhBCADKAKQASECIBNBGGogFEEYaigCADYCACATQRBqIBRBEGopAgA3AgAgEyAU/QACAP0LAgAgAyACNgLgASADIAQgAygCtAEiCCAIQQhLIgIbIg02AowCIAMgCEEAIAIbNgKEAiADQQAgBCACGzYC5AEgDQRAIAMoAugBIAsgAhshEUEAIQogAygCjAEhCQNAIAMgCiICQQFqIgo2AogCIBEgAkECdGooAgAhBSADKAKEASAJRgRAIANBhAFqQcjBwQAQiwYLIAMoAogBIAlBAnRqIAU2AgAgAyAJQQFqIgk2AowBAn8CQCAAKAIIIgIgBUsEQCAAKAIEIAVBJGxqIgYvARwhAkEAIQdBACAGLwEeIgRB//8BcSIOQYD4AUsNAhpBACACQf//AXEiD0GA+AFLDQIaIATBQQBIDQEgAiAESSACwUEATg0CGiAEIA9yQQBHDAILIAUgAkHUwMcAEIwHAAsgAsFBAEggAiAES3ELIQ8gBCACIA8bIAIgDkGB+AFJGyECAkAgBi8BICIEQf//AXEiDkGA+AFLDQAgAkH//wFxIg9BgPgBSw0AIATBQQBOBEAgAsFBAE4EQCAEIAJB//8DcUshBwwCCyAEIA9yQQBHIQcMAQsgAsFBAEggBCACQf//A3FJcSEHCyAGLwEUIQYCfyAEIAIgBxsgAiAOQYH4AUkbIgRB//8BcUUEQCAEQRB0DAELIARB/wdxIQIgBEGAgAJxIQcgBEGA+AFxIgRBgPgBRgRAIAdBEHQiBEGAgID8B3IgAkUNARogBCACQQ10ckGAgID+B3IMAQsgB0EQdCIHIARBDXRBgICA/ABxIAJBDXRyQYCAgMADanIgBA0AGiAHQYCAgNgDciACZ0EQayIEQRd0ayACIARB//8DcUEIanRB////A3FyC74QiQQhMUMAAIA/IQECfyAGQRB0IAZB//8BcUUNABogBkH/B3EhAiAGQYCAAnEhBCAGQYD4AXEiBkGA+AFGBEAgBEEQdCIEQYCAgPwHciACRQ0BGiAEIAJBDXRyQYCAgP4HcgwBCyAEQRB0IgQgBkENdEGAgID8AHEgAkENdHJBgICAwANqciAGDQAaIARBgICA2ANyIAJnQRBrIgRBF3RrIAIgBEH//wNxQQhqdEH///8DcXILviIyQwAAgD9eBEAgMhDGBUNU+C1AlEMAAIA/kpEhAQsgAygC+AIiAiADKALwAkYEQCADQfACakHIlcEAEPkFCyADKAL0AiIGIAJBA3RqIgQgBTYCBCAEIDEgMZIgAZQiATgCACADIAJBAWo2AvgCAkAgAkUEQEEAIQQMAQsgASABXARAA0ACQCAGIAJBAWsiDkEBdiIEQQN0aiIHKgIAIjEgMVsgASAxX0VxDQAgBSAHQQRqKAIASw0AIAIhBAwDCyAGIAJBA3RqIAcpAgA3AgAgBCECIA5BAk8NAAwCCwALA0AgBiACQQFrIg5BAXYiBEEDdGoiByoCACIxIDFbIAEgMV9FcUF/IAEgMWAbIg9BAEwgBSAHQQRqKAIATSAPGwRAIAIhBAwCCyAGIAJBA3RqIAcpAgA3AgAgBCECIA5BAUsNAAsLIAYgBEEDdGoiAiAFNgIEIAIgATgCACAKIA1HDQALCyAIQQlPBEAgAygC6AEiAkEEaygCACIEQXhxIgUgCEECdCIGQQRBCCAEQQNxIgQbakkNBCAEQQAgBSAGQSdqSxsNCyACEKICCyADKALcASICQQlPBEAgAygCwAEiBEEEaygCACIFQXhxIgYgAkECdCICQQRBCCAFQQNxIgUbakkNCiAFQQAgBiACQSdqSxsNCyAEEKICCyADKAL4AiIJDQALCyADKALwAiICRQ0AIAMoAvQCIgRBBGsoAgAiBUF4cSIGIAJBA3QiAkEEQQggBUEDcSIFG2pJDQcgBUEAIAYgAkEnaksbDQMgBBCiAgsgAygCbCICDQEMBAsLDAQLDAQLAAsgAygCjAEhBQsgAyAAKAIIIgI2ArgBIAMgBTYCkAEgAiAFRwRAIANBADYC4AFBACADQZABaiADQbgBaiADQeABakGsw8EAEPUHAAsgACADKAKIASIAIAUQ8AEgA0HgAGoQ6wMCQCADKAKEASICBEAgAEEEaygCACIEQXhxIgUgAkECdCICQQRBCCAEQQNxIgQbakkNAiAEQQAgBSACQSdqSxsNASAAEKICCyADQYADaiQADwsMAQtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQZj6xwBB1gAgA0H/AmpBpO7BAEG07sEAEOAGAAuSvAEEF38SfgR7DH0jAEGAA2siAyQAIAAQogEgAyACOgAnIAMgATgCICADIAAoAggiBTYCYCADIANBJ2qtQoCAgIDAAYQ3A8gBIAMgA0Egaq1CgICAgNABhDcDwAEgAyADQeAAaq0iGkKAgICAEIQ3A7gBIANCAzcC7AEgA0EDNgLkASADQYDjwQA2AuABIAMgA0G4AWo2AugBIANBkAFqIANB4AFqEOwDAkACQAJAIAMoApABIgIEQCADKAKUASIEQQRrKAIAIgZBeHEiBUEEQQggBkEDcSIGGyACakkNASAGQQAgBSACQSdqSxsNAiAEEKICIAAoAgghBQsCQAJAAkACQCAFRQ0AIAVBAnQiCBBxIgdFDQFBACECAkACQAJAIAVBBE8EQP0MAAAAAAEAAAACAAAAAwAAACEsIAchBiAFQfz//z9xIgIhBANAIAYgLP0LAgAgBkEQaiEGICz9DAQAAAAEAAAABAAAAAQAAAD9rgEhLCAEQQRrIgQNAAsgAiAFRg0BCyAHIAJBAnRqIQYDQCAGIAI2AgAgBkEEaiEGIAUgAkEBaiICRw0ACyADIAA2AuQBIAMgA0H8AGo2AuABIAMgA0HgAWo2ArgBIAVBAUYNAgwBCyADIAA2AuQBIAMgA0H8AGo2AuABIAMgA0HgAWo2ArgBCyAFQRVPBEAgA0G4AWohBiMAQYAgayIJJAACQAJAAkACQAJAQYCJ+gAgBSAFQYCJ+gBPGyIEIAUgBUEBdmsiAiACIARJGyIEQYEITwRAIAJB/////wNLDQJBMCAEIARBME0bIgpBAnQiAkH9////B08NAiACEHEiBEUNAyAHIAUgBCAKIAVBwQBJIAYQYSAEQQRrKAIAIgZBeHEiCkEEQQggBkEDcSIGGyACakkNBCAGQQAgCiACQSdqSxsNBSAEEKICDAELIAcgBSAJQYAIIAVBwQBJIAYQYQsgCUGAIGokAAwFC0HYlcEAEP8HCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0EEIQIDQCAHIAIgB2ogA0HgAWoQygEgCCACQQRqIgJHDQALCyAAIAcgBRCJAgJ/AkACQCAHQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyAIak8EQCACQQAgBCAIQSdqSxsNCSAHEKICIAAQmgQgACgCCEUNASAAKAIEIgQtABMiAiAELQASIgYgBC0AESIFIAUgBkkbIgYgAiAGSxsiBQR9QwAAQMEgACoCRCAALQBYQQJGIgIbIgFDAAAQQSAAKgJIIAIbIAGTQwAAfkOVIAVBAWtB/wFxs5SSEIkEIgEgAZIFQwAAAAALITAgBEEMai8BACIGQf//AXFFBEAgBkEQdAwECyAGQf8HcSECIAZBgIACcSEHIAZBgPgBcSIGQYD4AUYEQCAHQRB0IgZBgICA/AdyIAJFDQQaIAYgAkENdHJBgICA/gdyDAQLIAdBEHQhByAGRQ0CIAZBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAHcgwDCwwHC0EAQQBB3LvHABCMBwALIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAHQYCAgNgDciACQRd0a3ILQwAAgD8hAb4iMUMAAIA/XgRAIDEQxgVDVPgtQJRDAACAP5KRIQELIAMqAiAhMSADQf//ASAwIAGUQ703hjUQ4AgQxgUgMRDGBZWNIgH8AEGAgH4gAUMAAADHYBsgAUMA/v9GXhtBACABIAFbGzsBKCADIAUEfUMAAEDBIAAqAkQgAC0AWEECRiICGyIBQwAAEEEgACoCSCACGyABk0MAAH5DlSAFQQFrQf8BcbOUkhCJBCIBIAGSBUMAAAAACwJ/IARBDGovAQAiBEH//wFxRQRAIARBEHQMAQsgBEH/B3EhAiAEQYCAAnEhBiAEQYD4AXEiBEGA+AFGBEAgBkEQdCIEQYCAgPwHciACRQ0BGiAEIAJBDXRyQYCAgP4HcgwBCyAGQRB0IgYgBEENdEGAgID8AHEgAkENdHJBgICAwANqciAEDQAaIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAGQYCAgNgDciACQRd0a3ILviIBQwAAgD9eBH0gARDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlDgCYCADIBpCgICAgNABhDcDwAEgAyADQShqrUKAgICA4AGENwO4ASADQgI3AuwBIANBAjYC5AEgA0G448EANgLgASADIANBuAFqNgLoASADQZABaiADQeABahDsAyADKAKQASICBEAgAygClAEiBEEEaygCACIGQXhxIgVBBEEIIAZBA3EiBhsgAmpJDQUgBkEAIAUgAkEnaksbDQYgBBCiAgsgAyADLwEoOwEqIAMgACgCCDYCLCADQQA2AjAgA0EANgI8IANCgICAgIABNwI0IANBADYCSCADQoCAgIDAADcCQEHYtskAKAIAIgJFBEAQkwUhAgsgAigCACACKAIEKAIMEQQAIQIgA0HwmsgA/QADAP0LA+ABIAMgAq1Cxs7rhrfq7a0ShSIbQjiGIBtCgP4Dg0IohoQgG0KAgPwHg0IYhiAbQoCAgPgPg0IIhoSEQpK23Z0FhELSgaqbq/qC16d/fiIaQoDoAoNCKIYgGkKAgJQDg0IYhiAaQoCAgKgKg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQoCAgICAgICARIQgG0LYotHvwqnlvy1+hSIcQu3cspuNpYnMywCFIhpC2KLR78Kp5b8tfiAaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhISFQov9+pfHxteXhn+FIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRC0oGqm6v6gtenf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQtii0e/CqeW/LX6FIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRCiKyRp/aIgJywf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQs+O/8e788bUd36FIBqJNwOIAiADIBxC1oLNoZD9lI5LhSIaQtii0e/CqeW/LX4gGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhELSgaqbq/qC16d/fiIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEhUL8w7ynyZXV5OgAhSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLYotHvwqnlvy1+hSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQoiskaf2iICcsH9+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLPjv/Hu/PG1Hd+hSAaiTcDgAIgAyAcQvzDvKfJldXk6ACFIhpC2KLR78Kp5b8tfiAaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhISFQu3cspuNpYnMywCFIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRC0oGqm6v6gtenf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQtii0e/CqeW/LX6FIhpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRCiKyRp/aIgJywf34iG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhCAaQs+O/8e788bUd36FIBqJNwP4ASADIBxCi/36l8fG15eGf4UiGkLYotHvwqnlvy1+IBpCOIYgGkKA/gODQiiGhCAaQoCA/AeDQhiGIBpCgICA+A+DQgiGhIQgGkIIiEKAgID4D4MgGkIYiEKAgPwHg4QgGkIoiEKA/gODIBpCOIiEhIRC0oGqm6v6gtenf34iGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhIVC1oLNoZD9lI5LhSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQtKBqpur+oLXp39+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLYotHvwqnlvy1+hSIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEQoiskaf2iICcsH9+IhtCOIYgG0KA/gODQiiGhCAbQoCA/AeDQhiGIBtCgICA+A+DQgiGhIQgG0IIiEKAgID4D4MgG0IYiEKAgPwHg4QgG0IoiEKA/gODIBtCOIiEhIQgGkLPjv/Hu/PG1Hd+hSAaiTcD8AEgA0HQAGqtQoCAgIAQhCEjIANBLGqtQoCAgIAQhCEkIANBMGqtQoCAgIAQhCElIANBzABqrUKAgICA0AGEISYgA0Eqaq1CgICAgOABhCEnIANBgAFqrSIoQoCAgIDwAYQhKSADQdwAaq1CgICAgPABhCEqIANBvAFqIQ0gA0HkAGohEiADQcwBaiEPAkACQAJAAkADQCADIAMqAiAgAy4BKrIQtwo4AkwCQCADKAIwIgIgAygCLE8NAANAQwAAgD8hAQJ/AkAgACgCCCIEIAJLBEAgACgCBCACQRhsaiIELQATIgYgBC0AEiIFIAQtABEiByAFIAdLGyIFIAUgBkkbIgYEfUMAAEDBIAAqAkQgAC0AWEECRiIFGyIwQwAAEEEgACoCSCAFGyAwk0MAAH5DlSAGQQFrQf8BcbOUkhCJBCIwIDCSBUMAAAAACyEwIARBDGovAQAiBkH//wFxRQRAIAZBEHQMAwsgBkH/B3EhBCAGQYCAAnEhBSAGQYD4AXEiBkGA+AFGBEAgBUEQdCIGQYCAgPwHciAERQ0DGiAGIARBDXRyQYCAgP4HcgwDCyAFQRB0IQUgBkUNASAGQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIMAgsgAiAEQdy7xwAQjAcACyAEIARnQRBrIgRB//8DcUEIanRB////A3EgBUGAgIDYA3IgBEEXdGtyC74iMUMAAIA/XgRAIDEQxgVDVPgtQJRDAACAP5KRIQELIAMqAkwgMCABlF0NASADKAI8IgQgAygCNEYEQCADQTRqEJMGCyADKAI4IARBBXRqIgYgAjYCACAGQgA3AgggBkEQav0MAAAAAAAAAAAAAAAAAAAAAP0LAgAgAyAEQQFqNgI8IAMgAygCMEEBaiICNgIwIAIgAygCLEkNAAsLIAMgJDcD0AEgAyAlNwPIASADICY3A8ABIAMgJzcDuAFBPBBxIgJFDQYgA0EANgL4AiADIAI2AvQCIANBPDYC8AIgA0IENwKcASADQQQ2ApQBIANB+OPBADYCkAEgAyADQbgBajYCmAECQCADQfACakGM78EAIANBkAFqEMEDRQRAIAMoAvACIgIEQCADKAL0AiIEQQRrKAIAIgZBeHEiBUEEQQggBkEDcSIGGyACakkNDCAGQQAgBSACQSdqSxsNDSAEEKICCwJAAkAgAygCPCIHRQ0AIAMoAjgiBSAHQQV0aiEIIAP9CQJMIS0gBSECA0AgAigCACIEIAAoAggiBk8NAiACQQhqIAAoAgQgBEEYbGr9AAIAICz9DQABAgMEBQYHCAkKCwgJCgsgLf3nAf1oIiz9HwD8BCIbQv///wCDIhpCEIYgG0IghoQgGoRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX5CyaSSyaSSyaQSgyAbQhWIIh9CP4aEICz9HwH8BCIcQv///wCDIhpCEIYgHEIghoQgGoRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCCn5Cksmkksmkkskkg4QgLP0fAvwEIhpC////AIMiHUIQhiAaQiCGhCAdhEL/gYD4j4DAD4NCgQJ+Qo/gg/iAnsCHEINCEX5Cw+GwmIyGw+EQg0IUfkKkksmkksmkkskAg4Q3AwAgAkEYaiAcQiqIIh1CEIYgHUIghoQgHYRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX5CyKSSyaSSyaQSgyAcQoCAgICAgICAgH+DhEIBiCAbQiqIIh5CEIYgHkIghoQgHoRC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX5CyaSSyaSSyaQSgyIeIBtCgICAgICAgICAf4OEQgKIhCAaQiqIIhtCEIYgG0IghoQgG4RC/4GA+I+AwA+DQoECfkKP4IP4gJ7AhxCDQhF+QsPhsJiMhsPhEINCBX4iG0LIpJLJpJLJpBKDIBpCgICAgICAgICAf4OEIBtCAYOEhDcDACACQRBqIBxCFYgiG0L///8AgyIcQhCGIBtCIIaEIByEQv+BgPiPgMAPg0KBAn5Cj+CD+ICewIcQg0IRfkLD4bCYjIbD4RCDQgV+QsikksmkksmkEoMgHUI/hoQgG0IBg4QgH0L///8AgyIbQhCGIB9CIIaEIBuEQv+BgPiPgMAPg0KBAn5Cj+CD+ICewIcQg0IRfkLD4bCYjIbD4RCDQgV+QgGIQqSSyaSSyaSSCYMgHkI+hoSEIBpCFYgiG0L///8AgyIcQhCGIBtCIIaEIByEQv+BgPiPgMAPg0KBAn5Cj+CD+ICewIcQg0IRfkLD4bCYjIbD4RCDQgp+QpDJpJLJpJLJJIMgGkIUiEICg4SENwMAIAJBIGoiAiAIRw0ACyAHQQFGDQAgB0EVTwRAIAUgBxD+AwwBCyAFQSBqIQZBACEJIAUhDANAIAwhAiAGIQwgAikDOCEcIAIpAygiHSEaAkACQCAdIAIpAwgiG1INACACKQMwIhogAikDECIbUg0AIAIpAxgiGyAcIhpRDQELIBogG1oNACACKQMwIR8gAikDICEeIAkhBgNAAkAgBSAGaiICQSBqIgQgAv0AAwD9CwMAIAJBMGogAkEQav0AAwD9CwMAIAZFBEAgAkEgaiEEIAUhAgwBCwJAIAJBGGspAwAiGyAdIhpSDQAgBSAGakEQaykDACIbIB8iGlINACACQQhrKQMAIhsgHCIaUQ0BCyAGQSBrIQYgGiAbVA0BCwsgAiAeNwMAIARBCGsgHDcDACAEQRBrIB83AwAgBEEYayAdNwMACyAJQSBqIQkgDEEgaiIGIAhHDQALCyADICM3A/ACIAMgBzYCUEEeEHEiAkUNCSADQQA2ApgBIAMgAjYClAEgA0EeNgKQASADQgE3AsQBIANBATYCvAEgA0Go5MEANgK4ASADIANB8AJqNgLAASADQZABakGM78EAIANBuAFqEMEDRQRAIAMoApABIgIEQCADKAKUASIEQQRrKAIAIgZBeHEiBUEEQQggBkEDcSIGGyACakkNDiAGQQAgBSACQSdqSxsNDyAEEKICCyADQQA2AlggA0KAgICAwAA3AlAgA0EANgKMASADQoCAgIDAADcChAEgA0EANgJcIANBADYCgAEgB0UEQEL///////////8AIR1CgICAgICAgICAfyEfQoCAgICAgICAgH8hHkKAgICAgICAgIB/ISBC////////////ACEhQv///////////wAhIgwEC0KAgICAgICAgIB/ISBC////////////ACEiQQAhAkL///////////8AISFC////////////ACEdQoCAgICAgICAgH8hHkKAgICAgICAgIB/IR8DQAJAAkAgAygCOCIWIAJBBXQiCWoiBigCACIFIAAoAggiBEkEQCAAKAIEIgogBUEYbGr9AAIAICz9DQABAgMEBQYHCAkKCwgJCgsgA/0JAkwiLf3nAf1oIiz9HwL8BCEaICz9HwH8BCEbICz9HwD8BCEcIAcgAkEBaiIITQRAIAIhCwwDCyAHQQFrIQsgDkEBcQRAIAchCAwDCyAJIBZqQSBqIQUDQCAFKAIAIgkgBE8NAiAKIAlBGGxq/QACACAs/Q0AAQIDBAUGBwgJCgsICQoLIC395wH9aCIs/R8A/AQgHFIgLP0fAfwEIBtSckUgLP0fAvwEIBpRcUUEQCAIQQFrIQsMBAsgBUEgaiEFIAcgCEEBaiIIRw0ACyAHIQgMAgsgBSAEQdy7xwAQjAcACyAJIARB3LvHABCMBwALIB8gGiAaIB9TGyEfIB4gGyAbIB5TGyEeICAgHCAcICBTGyEgIB0gGiAaIB1VGyEdICEgGyAbICFVGyEhICIgHCAcICJVGyEiIAMgAygCgAFBAWo2AoABIAMpA/gBIhogCCACayIMrYUiG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhELSgaqbq/qC16d/fiIaQjiGIBpCgP4Dg0IohoQgGkKAgPwHg0IYhiAaQoCAgPgPg0IIhoSEIBpCCIhCgICA+A+DIBpCGIhCgID8B4OEIBpCKIhCgP4DgyAaQjiIhISEIBtC2KLR78Kp5b8tfoUiGkI4hiAaQoD+A4NCKIaEIBpCgID8B4NCGIYgGkKAgID4D4NCCIaEhCAaQgiIQoCAgPgPgyAaQhiIQoCA/AeDhCAaQiiIQoD+A4MgGkI4iISEhCADKQPwASIbQn+FfiIcQjiGIBxCgP4Dg0IohoQgHEKAgPwHg0IYhiAcQoCAgPgPg0IIhoSEIBxCCIhCgICA+A+DIBxCGIhCgID8B4OEIBxCKIhCgP4DgyAcQjiIhISEIBogG0I4hiAbQoD+A4NCKIaEIBtCgID8B4NCGIYgG0KAgID4D4NCCIaEhCAbQgiIQoCAgPgPgyAbQhiIQoCA/AeDhCAbQiiIQoD+A4MgG0I4iISEhH6FIBqJIhpCGYgiHEL/AINCgYKEiJCgwIABfiErIAMoAuABIgVBCGshEUEAIQogAygC5AEiByAapyITcSIJIQQCfwJAA0AgBCAFaikAACIbICuFIhpCf4UgGkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIaUEUEQANAIBEgGnqnQQN2IARqIAdxIhBBA3RrKAIAIAxGDQMgGkIBfSAagyIaUEUNAAsLIBsgG0IBhoNCgIGChIiQoMCAf4NQBEAgBCAKQQhqIgpqIAdxIQQMAQsLIAMoAugBRQRAIANB4AFqIANB8AFqEJwBIAMoAuQBIgcgE3EhCSADKALgASEFCyAFIAlqKQAAQoCBgoSIkKDAgH+DIhpQBEBBCCEEA0AgBCAJaiEJIARBCGohBCAFIAcgCXEiCWopAABCgIGChIiQoMCAf4MiGlANAAsLIAUgGnqnQQN2IAlqIAdxIgRqLAAAIglBAE4EQCAFIAUpAwBCgIGChIiQoMCAf4N6p0EDdiIEai0AACEJCyAEIAVqIBynQf8AcSIKOgAAIAUgBEEIayAHcWpBCGogCjoAACAFIARBA3RrIgVBBGtBADYCACAFQQhrIAw2AgAgAyADKALsAUEBajYC7AEgAyADKALoASAJQQFxazYC6AFBAQwBCyAFQQAgEGtBA3RqIgVBBGsoAgBBAWoLIQQgBUEEayAENgIAAkACQAJAAkACQAJAIAxBAU0EQCACIAMoAjwiB08NASAGKAIAIQQgAygCWCICIAMoAlBGBEAgA0HQAGpBsOXBABCLBgsgAygCVCACQQJ0aiAENgIAIAMgAkEBajYCWAwGCyADKgJMIQEgAy0AJyEUQQAhBCADQQA2ArgBIANBADYCzAFBBCEHAn8gDEEAIAggDE8bIgVBBUkEQCANIREgDwwBCwJAIAVBAWtnIgQEQCADQRhqIANBuAFqQX8gBHZBAWoQ6QMgAygCGCIEQYGAgIB4Rg0BIAQNFAtB2JXHAEERQdTMxwAQ6wcACyADKALMASIHQQVJBEAgByEEIA0hEUEEIQcgDwwBCyADKAK8ASEEIAMoAsABIREgDQshCiAEIAdPDQIgByAEQX9zaiIFIAIgAygCPCIMIAIgDEsbIhMgAmsiCSAFIAlJGyIFIAIgCCACIAhLGyIVIAJrIgkgBSAJSRsiCUEBaiIQQQxNDQEgESAEQQJ0aiIFIBYgAiAJakEFdGpBBGpJIAYgESAEIAlqQQJ0akEEaklxDQEgECAQQQNxIglBBCAJG2siECEJA0AgBSAGQeAAaiAGQUBrIAZBIGogBv1cAgD9VgIAAf1WAgAC/VYCAAP9CwIAIAZBgAFqIQYgBUEQaiEFIAlBBGsiCQ0ACyACIBBqIQIgBCAQaiEEDAELIAIgB0Gg5cEAEIwHAAsgFiACQQV0aiEGIBEgBEECdGohBQJAA0AgAiAVRg0BIAIgE0YEQCATIAxB4OXBABCMBwALIAUgBigCADYCACAGQSBqIQYgBUEEaiEFIAJBAWohAiAHIARBAWoiBEcNAAsgByEEDAELIAogBDYCAAwBCyAKIAQ2AgAgAiALSw0AIAtBAWohCSACQQV0IQYDQCACIAMoAjwiBE8NAiADKAI4IAZqAn8gAygCzAEiB0EFSQRAIAchBSANIQxBBCEHIA8MAQsgAygCvAEhBSADKALAASEMIA0LIQQoAgAhCiAFIAdGBEAgA0G4AWoQzgYgAygCvAEhBSADKALAASEMIA0hBAsgDCAFQQJ0aiAKNgIAIAQgBCgCAEEBajYCACAGQSBqIQYgCSACQQFqIgJHDQALCyADQfAAaiIFIANByAFqIgcpAgA3AwAgAyAD/QACuAH9CwNgIAAgAygCdCIGQQVPBH8gAygCZCEGIAMoAmgFIBILIAYgAUMAAAAAIBQbEEMhAiADKAJYIgQgAygCUEYEQCADQdAAakHA5cEAEIsGCyADKAJUIARBAnRqIAI2AgAgAyAEQQFqNgJYIAcgBSkDADcDACADIAP9AANg/QsDuAEgAygCjAEiBCADKAKEAUYEQCADQYQBahCVBgsgAygCiAEgBEEcbGoiBiACNgIAIAYgAykDuAE3AgQgBkEMaiADQcABav0AAwD9CwIAIAMgBEEBajYCjAEgAyADKAJcQQFqNgJcIAMoAjwhBwwBCyACIARB4OXBABCMBwALIAcgCCICSw0ACwwDCwwOCyAEIAZB3LvHABCMBwALDAwLIAMgKTcDmAEgAyAqNwOQAUEWEHEiAkUNBiADQQA2AvgCIAMgAjYC9AIgA0EWNgLwAiADQgI3AsQBIANBAjYCvAEgA0G45MEANgK4ASADIANBkAFqNgLAAQJAAkAgA0HwAmpBjO/BACADQbgBahDBA0UEQCADKALwAiICBEAgAygC9AIiBEEEaygCACIGQXhxIgVBBEEIIAZBA3EiBhsgAmpJDQ0gBkEAIAUgAkEnaksbDQ4gBBCiAgsgAygC7AEhCiADQegBakH4msgAKQMANwMAIAMoAuQBIQsgAygC4AEhCCADQfCayAApAwA3A+ABAkACQAJAIAoEQCAIQQhqIQUCQCAIKQMAQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1IEQCAFIQIgCCEGDAELIAghBgNAIAZBQGohBiAFKQMAIAVBCGoiAiEFQoCBgoSIkKDAgH+DIhpCgIGChIiQoMCAf1ENAAsLIApB/////wFLDQNBBCAKIApBBE0bIgRBA3QiBUH9////B08NAyAGIBpCgIGChIiQoMCAf4UiGnqnQfgAcWsiB0EEaygCACEMIAdBCGsoAgAhByAFEHEiCUUNDSAJIAw2AgQgCSAHNgIAQQEhBSADQQE2AsABIAMgCTYCvAEgAyAENgK4ASAKQQFrIgcEQCAaQgF9IBqDIRpBASEEA0AgGlAEQANAIAZBQGohBiACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyIaQoCBgoSIkKDAgH9RDQALIBpCgIGChIiQoMCAf4UhGgsgBiAaeqdB+ABxayIFQQRrKAIAIQwgBUEIaygCACEFIBpCAX0gGoMhGiADKAK4ASAERgRAIANBuAFqIAQgB0EEQQgQpAUgAygCvAEhCQsgCSAEQQN0aiIRIAw2AgQgESAFNgIAIAMgBEEBaiIENgLAASAHQQFrIgcNAAsgCiEFCwJAIAtFDQAgC0EJaiICRQ0AIAhB/wEgAvwLAAsgA0EANgLsASADIAg2AuABIAMgCzYC5AEgAyALIAtBAWpBA3ZBB2wgC0EISRs2AugBIAMoArgBIQwgAygCvAEhCiAFQQJJDQIgBUEVSQ0BIAogBRDOBAwCCwJAIAtFDQAgC0EJaiICRQ0AIAhB/wEgAvwLAAtBACEMIANBADYC7AEgAyAINgLgASADIAs2AuQBIAMgCyALQQFqQQN2QQdsIAtBCEkbNgLoAUEEIQoMAQsgCkEIaiEEIAogBUEDdGohBUEAIQcDQCAEKAIAIgYgBEEIaygCAEkEQCAENQIEIRogByECAn8DQCACIApqIghBCGogCCkCADcCACAKIAJFDQEaIAYgAkEIayICIApqIggoAgBJDQALIAhBCGoLIAatIBpCIIaENwIACyAHQQhqIQcgBEEIaiIEIAVHDQALCyADKAJIIgcgAygCQEYEQCADQUBrQcjkwQAQogYLIAMoAkQiFiAHQQxsaiICIAMpAoQBNwIAIAJBCGogA0GMAWooAgA2AgAgA0EANgI8IAMgB0EBaiIINgJIIAMoAlQhBCADKAJQIQkCQAJAIAMoAlgiAiADKAI0SwRAIANBNGpBACACQQhBIBCkBSADKAI4IREgAygCPCEFDAELQQAhBSADKAI4IREgAkUNAQsgAkECdCILQQRrIhNBBHEEfyAEBSAEKAIAIQYgDUEQakIANwIAIA39DAAAAAAAAAAAAAAAAAAAAAD9CwIAIBEgBUEFdGoiAiAGNgIAIAIgAykCuAE3AgQgAkEMaiADQcABav0AAgD9CwIAIAJBHGogA0HQAWooAgA2AgAgBUEBaiEFIARBBGoLIQYgE0UNACAEIAtqIQsgESAFQQV0aiECA0AgAiAGKAIANgIAIA1BEGoiE0IANwIAIA39DAAAAAAAAAAAAAAAAAAAAAAiLP0LAgAgAkEEaiADKQK4ATcCACACQQxqIANBwAFqIhD9AAIA/QsCACACQRxqIANB0AFqIhQoAgA2AgAgBkEEaigCACEVIBNCADcCACAN/QwAAAAAAAAAAAAAAAAAAAAA/QsCACACQSBqIBU2AgAgAkEkaiADKQK4ATcCACACQSxqIBD9AAIA/QsCACACQTxqIBQoAgA2AgAgAkFAayECIAVBAmohBSAGQQhqIgYgC0cNAAsLIAMgBTYCPAJAIAkEQCAEQQRrKAIAIgJBeHEiBiAJQQJ0IglBBEEIIAJBA3EiAhtqSQ0BIAJBACAGIAlBJ2pLGw0QIAQQogILIAMgAy8BKkEBajsBKiADKAIwIAMoAixJDQQgAygCgAFBAUcNAwJAIAwEQCAKQQRrKAIAIgJBeHEiBCAMQQN0IgZBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAZBJ2pLGw0RIAoQogILIAMgBTYCfCAFQQFGBEAgAyARKAIANgKAAUEcEHEiAkUNDSACQv////8PNwIAIAJBATYCGCACIAMoAoABNgIIIAMoAkAgCEYEQCADQUBrQdzkwQAQogYgAygCRCEWCyAWIAhBDGxqIgRBATYCCCAEIAI2AgQgBEEBNgIAIAMgB0ECaiILNgJIIAMgKEKAgICAEIQ3A/ACIANCATcCxAEgA0EBNgK8ASADQfjkwQA2ArgBIAMgA0HwAmo2AsABIANBkAFqIANBuAFqEOwDAkAgAygCkAEiAgRAIAMoApQBIgRBBGsoAgAiBkF4cSIFQQRBCCAGQQNxIgYbIAJqSQ0BIAZBACAFIAJBJ2pLGw0TIAQQogILIAMoAoABIgIgACgCCCIESQRAIAMgAEE8ajYC9AIgAyAAKAIEIAJBGGxqNgLwAiADIANB8AJqrUKAgICAgAKENwNQIANCATcCxAEgA0EBNgK8ASADQYjlwQA2ArgBIAMgA0HQAGo2AsABIANBkAFqIANBuAFqEOwDAkAgAygCkAEiAgRAIAMoApQBIgRBBGsoAgAiBkF4cSIFQQRBCCAGQQNxIgYbIAJqSQ0BIAZBACAFIAJBJ2pLGw0VIAQQogILQQAhAiADQQA2ApgBIANCgICAgMAANwKQAUEAIQkgC0UNDiADQbwBaiIPQRBqIRhBBCEMQQAhCAJAA0AgAyALQQFrIhI2AkggFiASQQxsaiIKKAIAIhBBgICAgHhGBEAgEiELDA4LAkACQCAKKQIEIhqnIg0gGkIgiKciDkEcbGoiEwJ/IBpCgICAgBBaBEAgEyANayIGQRxuIgVBAXFBACEEQQAhByAGQRxrQRxPBEAgBUH+////AHEhFSANIQYDQCAGQRhqKAIAIgVBBU8EfyAGQQhqKAIABSAFCyAEaiAGQTRqKAIAIgVBBU8EQCAGQSRqKAIAIQULIAZBOGohBiAFaiEEIBUgB0ECaiIHRw0ACwsEfyANIAdBHGxqIgYoAhgiBUEFTwR/IAYoAggFIAULIARqBSAECyAJakGAgARLDQIgDSEGAkADQCAGQRxqIgQgBigCBCIFQQJGDQMaIAYoAgAhFCAYIAZBGGooAgA2AgAgDyAG/QACCP0LAgAgAyAFNgK4ASAPIQYgAygCzAEiFSEKIBVBBUkiGUUEQCADKAK8ASEKIAMoAsABIQYLAkAgFEF/Rg0AAkACQCAKQQAgCiAIIApqIhdNGyIOQf////8DSw0AIA5BAnQiBUH9////B08NAEEAIQcCQCAFRQRAQQQhC0EAIQ4MAQsgBRBxIgtFDRwLAkAgCCAXTw0AQQAhCSAIIQUgCkEETwRAIAX9Ef0MAAAAAAEAAAACAAAAAwAAAP2uASEsIAshBSAKQXxxIgkhBwNAIAUgLP0LAgAgBUEQaiEFICz9DAQAAAAEAAAABAAAAAQAAAD9rgEhLCAHQQRrIgcNAAsgCSAKIgdGDQEgCCAJaiEFCyALIAlBAnRqIQcDQCAHIAU2AgAgB0EEaiEHIBcgBUEBaiIFRw0ACyAKIQcLIAAoAhAgACgCFCAUIAsgBxDUAiAIIQkgDkUNAiALQQRrKAIAIgVBeHEiByAOQQJ0IglBBEEIIAVBA3EiBRtqSQ0eIAVBACAHIAlBJ2pLGw0BIAsQogIgCCEJDAILQeD/xgAQ/wcACwwdCyAKBEAgCkECdCEHIAhBAnQhBSAIIQIDQCAGKAIAIQggBkEEaiEGIAMoApABIAJGBEAgA0GQAWpBrOLBABCLBiADKAKUASEMCyAFIAxqIAg2AgAgAyACQQFqIgI2ApgBIAVBBGohBSACIQggAiEJIAdBBGsiBw0ACwsCQCAZRQRAIAMoAsABIgZBBGsoAgAiBUF4cSIHIBVBAnQiCkEEQQggBUEDcSIFG2pJDQEgBUEAIAcgCkEnaksbDQMgBhCiAgsgEyAEIgZHDQEMBgsLDBoLDBoLIAJBgIAESw0BIAIhCCACIQkgDQsiBGtBHG4hBiAEIBNGDQEDQCAEQRhqKAIAIgVBBU8EQCAEQQxqKAIAIgdBBGsoAgAiCkF4cSILIAVBAnQiBUEEQQggCkEDcSIKG2pJDRkgCkEAIAsgBUEnaksbDRogBxCiAgsgBEEcaiEEIAZBAWsiBg0ACwwBCyAKIA42AgggCiANNgIEDA4LAkAgEARAIA1BBGsoAgAiBEF4cSIGIBBBHGwiBUEEQQggBEEDcSIEG2pJDQEgBEEAIAYgBUEnaksbDQMgDRCiAgsgEiILDQEMDwsLDBQLDBQLDBILIAIgBEHcu8cAEIwHAAsMEAsgA0EANgK4AUEAIANB/ABqQdjkwQAgA0G4AWpBkOXBABD1BwALDA4LDA0LQeD/xgAQ/wcACwwNCwJAIAwEQCAKQQRrKAIAIgJBeHEiBCAMQQN0IgZBBEEIIAJBA3EiAhtqSQ0MIAJBACAEIAZBJ2pLGw0BIAoQogILICAgIn0iGiAeICF9IhsgHyAdfSIcIBsgHFUbIhsgGiAbVRtCAlMgDnIhDgwCCwwLCyAMRQ0AIApBBGsoAgAiAkF4cSIEIAxBA3QiBkEEQQggAkEDcSICG2pPBEAgAkEAIAQgBkEnaksbDQsgChCiAgwBCwsMCAsgCw0BC0EAIQkMAQsgA0G8AWoiEkEQaiEVAkADQCADIAtBAWsiCzYCSCAWIAtBDGxqIgQoAgAiDkGAgICAeEYEQCALIQkMAwsgBCkCBCIapyIKIBpCIIinQRxsaiEPAkACQAJAIBpCgICAgBBUBEAgCiEEDAELIAohBgNAIAZBHGohBCAGKAIEIgVBAkYNASAGKAIAIRMgFSAGQRhqKAIANgIAIBIgBv0AAgj9CwIAIAMgBTYCuAEgEiEGIAMoAswBIhAhCCAQQQVJIhdFBEAgAygCvAEhCCADKALAASEGCwJAIBNBf0YNAAJAIAhBACAIIAIgCGoiFE0bIgxB/////wNLDQAgDEECdCIFQf3///8HTw0AQQAhBwJAIAVFBEBBBCENQQAhDAwBCyAFEHEiDUUNCwsCQCACIBRPDQBBACEJIAIhBSAIQQRPBEAgAv0R/QwAAAAAAQAAAAIAAAADAAAA/a4BISwgDSEFIAhBfHEiCSEHA0AgBSAs/QsCACAFQRBqIQUgLP0MBAAAAAQAAAAEAAAABAAAAP2uASEsIAdBBGsiBw0ACyAJIAgiB0YNASACIAlqIQULIA0gCUECdGohBwNAIAcgBTYCACAHQQRqIQcgFCAFQQFqIgVHDQALIAghBwsgACgCECAAKAIUIBMgDSAHENQCIAxFDQEgDSAMQQJ0QQQQogcMAQtB4P/GABD/BwALIAgEQCAIQQJ0IQcgAkECdCEFA0AgBigCACEIIAMoApABIAJGBEAgA0GQAWpBrOLBABCLBgsgBkEEaiEGIAMoApQBIAVqIAg2AgAgAyACQQFqIgI2ApgBIAVBBGohBSAHQQRrIgcNAAsLIBdFBEAgAygCwAEgEEECdEEEEKIHCyAPIAQiBkcNAAsMAQsgDyAEa0EcbiEGIAQgD0YNAANAIARBGGooAgAiBUEFTwRAIARBDGooAgAiB0EEaygCACIIQXhxIgkgBUECdCIFQQRBCCAIQQNxIggbakkNAyAIQQAgCSAFQSdqSxsNBSAHEKICCyAEQRxqIQQgBkEBayIGDQALCyAOBEAgCiAOQRxsQQQQogcLQQAhCSALRQ0DDAELCwwGCwwGCyAAIAMoApQBIgQgAhCJAiADKAKQASICBEAgBEEEaygCACIGQXhxIgUgAkECdCICQQRBCCAGQQNxIgYbakkNBSAGQQAgBSACQSdqSxsNBiAEEKICCwJAIAMoAuQBIgJFDQAgAiACQQN0IgRqQRFqIgJFDQAgAygC4AEgBGtBCGsgAkEIEKIHCyAJBEBBACEMA0AgFiAMQQxsaiIFKAIEIQQgBSgCCCIGBEAgBCECA0AgAkEYaigCACIHQQVPBEAgAkEMaigCACIIQQRrKAIAIgpBeHEiCyAHQQJ0IgdBBEEIIApBA3EiChtqSQ0JIApBACALIAdBJ2pLGw0KIAgQogILIAJBHGohAiAGQQFrIgYNAAsLIAUoAgAiAgRAIARBBGsoAgAiBkF4cSIFIAJBHGwiAkEEQQggBkEDcSIGG2pJDQcgBkEAIAUgAkEnaksbDQggBBCiAgsgDEEBaiIMIAlHDQALCyADKAJAIgIEQCAWQQRrKAIAIgRBeHEiBiACQQxsIgJBBEEIIARBA3EiBBtqSQ0FIARBACAGIAJBJ2pLGw0GIBYQogILIAMoAjQiAkUNACARQQRrKAIAIgRBeHEiBiACQQV0IgJBBEEIIARBA3EiBBtySQ0EIARBACAGIAJBJ2pLGw0FIBEQogILIAAoAggiCgRAQQwhBUEAIQYDQAJAAn8CQAJAAn8CQAJAIAAoAggiAiAGSwRAIAAoAgQgBWoiCy8BACIEQf//AXEiDEUNASAEQf8HcSECIARBgIACcSEHIARBgPgBcSIIQYD4AUciDUUEQCAHQRB0IglBgICA/AdyIAJFDQQaIAkgAkENdHJBgICA/gdyDAQLIAdBEHQhCSAIRQ0CIAhBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAJcgwDCyAGIAJB7LvHABCMBwALIARBEHS+QwAAgD9eDQIMBQsgAiACZ0EQayIRQf//A3FBCGp0Qf///wNxIAlBgICA2ANyIBFBF3Rrcgu+QwAAgD9eRQ0DIAwNAQsgBEEQdAwBCyANRQRAIAdBEHQiBEGAgID8B3IgAkUNARogBCACQQ10ckGAgID+B3IMAQsgB0EQdCIEIAhBDXRBgICA/ABxIAJBDXRyQYCAgMADanIgCA0AGiACIAJnQRBrIgJB//8DcUEIanRB////A3EgBEGAgIDYA3IgAkEXdGtyC0MAAIA/IQG+IjBDAACAP14EQCAwEMYFQ1T4LUCUQwAAgD+SkUMAAIC/kkMAAIA+lEMAAIA/kiEBC0MAAABAQwAAgD8gASABQwAAgD9dGyIBIAFDAAAAQF4bvCIHQf///wNxIQggB0GAgICAeHEhBAJAIAdBgICA/AdxIgJBgICA/AdGBEAgCEENdiAEQRB2ckGABEEAIAgbckGA+AFyIQQMAQsgBEEQdiEEIAJBgICAuARNBEAgAkGAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgAkENdiAIQQ12akGAgAFqIARyaiEEDAILIAJBgICAmANJDQEgCEGAgIAEciIHQf4AIAJBF3YiCGt2IQIgB0EdIAhrIgh2QQFxBH8gAkEDIAh0QQFrIAdxQQBHagUgAgsgBHIhBAwBCyAEQYD4AXIhBAsgCyAEOwEACyAFQRhqIQUgCiAGQQFqIgZHDQALCyADQQA2AowBIANCgICAgMAANwKEASADQYQBakGowcEAEIsGIAMoAogBQQA2AgBBASEGIANBATYCjAEgA0KAgICAwAA3AmAgA0IANwJoQQQQcSICRQ0AIAJBADYCACADQeAAakG4wcEAEKQGIAMoAmQgAygCbCIFIAMoAmhqIgQgAygCYCIHQQAgBCAHTxtrQQxsaiIEQQE2AgggBCACNgIEIARBATYCACADIAVBAWo2AmwgAygCbCICRQ0CIANB0ABqrUKAgICAEIQhHSADQUBrrSIaQoCAgIAQhCEfIANBNGqtQoCAgIDQAYQhHiAaQoCAgIDQAYQhICADQbgBaq1CgICAgJAChCEhIANBkAFqrUKAgICAoAKEISIgA0GAAWqtQoCAgICwAoQhIyADQZwCaiEWIANB6AFqIQwgA0HkAWohCyADQZgBaiENIANBvAFqIRMgA0GEAmohEQJAA0AgAyACQQFrNgJsIAMgAygCaCICQQFqIgQgAygCYCIGQQAgBCAGTxtrNgJoIAMoAmQgAkEMbGoiAigCACISQYCAgIB4Rg0DIAIpAgQhGiADQQA2AvgCIANCgICAgMAANwLwAiAapyEGIBpCHoinQfz///8HcSICBEAgAiAGaiEPQQAhCkEEIQUgBiEJA0AgCiECQwAAgD8hAQJ/AkAgCSgCACIHIAAoAggiBEkEQCAAKAIEIAdBGGxqIgQtABMiCCAELQASIgogBC0AESIOIAogDksbIgogCCAKSxsiCAR9QwAAQMEgACoCRCAALQBYQQJGIgobIjBDAAAQQSAAKgJIIAobIDCTQwAAfkOVIAhBAWtB/wFxs5SSEIkEIjAgMJIFQwAAAAALITAgBEEMai8BACIIQf//AXFFBEAgCEEQdAwDCyAIQf8HcSEEIAhBgIACcSEKIAhBgPgBcSIIQYD4AUYEQCAKQRB0IghBgICA/AdyIARFDQMaIAggBEENdHJBgICA/gdyDAMLIApBEHQhCiAIRQ0BIAhBDXRBgICA/ABxIARBDXRyQYCAgMADaiAKcgwCCyAHIARB3LvHABCMBwALIAQgBGdBEGsiBEH//wNxQQhqdEH///8DcSAKQYCAgNgDciAEQRd0a3ILviIxQwAAgD9eBEAgMRDGBUNU+C1AlEMAAIA/kpEhAQsgAygC8AIgAkYEQCADQfACakHIlcEAEPkFIAMoAvQCIQULIAUgAkEDdGoiBCAHNgIEIAQgMCABlCIBOAIAIAMgAkEBaiIKNgL4AgJAIAJFBEBBACEEDAELIAEgAVwEQANAAkAgBSACQQFrIg5BAXYiBEEDdGoiCCoCACIwIDBbIAEgMF9FcQ0AIAcgCEEEaigCAEsNACACIQQMAwsgBSACQQN0aiAIKQIANwIAIAQhAiAOQQJPDQAMAgsACwNAIAUgAkEBayIOQQF2IgRBA3RqIggqAgAiMCAwWyABIDBfRXFBfyABIDBgGyIQQQBMIAcgCEEEaigCAE0gEBsEQCACIQQMAgsgBSACQQN0aiAIKQIANwIAIAQhAiAOQQFLDQALCyAFIARBA3RqIgIgBzYCBCACIAE4AgAgCUEEaiIJIA9HDQALCyASBEAgBkEEaygCACICQXhxIgQgEkECdCIFQQRBCCACQQNxIgIbakkNBiACQQAgBCAFQSdqSxsNByAGEKICCwJAAkACQCADKAL4AiIJRQ0AIAMoAowBQf+/BGpBgID8/wNxIRIDQCADIAlBAWsiBDYC+AIgAygC9AIiByAEQQN0aiICKAIEIQYgAioCACEBAkAgBEUEQCABITAgBiEKDAELIAcoAgQhCiAHIAY2AgQgByoCACEwIAcgATgCAEEAIQJBASEFIAlBBE8EQCAEQQJrIgJBACACIARNGyEIQQAhBANAIAcgBEEDdGogByAFIAcgBUEDdGoiAkEIaioCACIxIDFbIDEgAioCACIzYEVxIgQgBEF/IDEgM18bIDMgM1wbIgRBAEwgAkEEaigCACACQQxqKAIATSAEG2oiAkEDdGopAgA3AgAgAkEBdCIPQQFyIQUgAiEEIAggD0sNAAsLAkACQCAJQQJrIAVGBEAgByACQQN0aiAHIAVBA3RqIgIpAgA3AgAgAiAGNgIEIAIgATgCACAFIQIMAQsgByACQQN0aiIEIAY2AgQgBCABOAIAIAINAEEAIQQMAQsgASABXARAA0ACQCAHIAJBAWsiCEEBdiIEQQN0aiIFKgIAIjEgMVsgASAxX0VxDQAgBiAFQQRqKAIASw0AIAIhBAwDCyAHIAJBA3RqIAUpAgA3AgAgBCECIAhBAk8NAAwCCwALA0AgByACQQFrIghBAXYiBEEDdGoiBSoCACIxIDFbIAEgMV9FcUF/IAEgMWAbIglBAEwgBiAFQQRqKAIATSAJGwRAIAIhBAwCCyAHIAJBA3RqIAUpAgA3AgAgBCECIAhBAUsNAAsLIAcgBEEDdGoiAiAGNgIEIAIgATgCAAsgA0GQAWogACgCECAAKAIUIAoQ5wIgAygCjAEhAgJAAkAgAygCtAEiBEEJSSIGRQRAIAMoApQBIAJqIgggEksNAQwCCyACIARqIgggEk0NAQsgA0HwAmogMCAKEPEEIAMgIDcDUCADIAKzQwAAgDeUOAJAIANCATcC7AEgA0EBNgLkASADQfjBwQA2AuABIAMgA0HQAGo2AugBIANBuAFqIANB4AFqEOwDIAMoArgBIgIEQCADKAK8ASIFQQRrKAIAIgdBeHEiCEEEQQggB0EDcSIHGyACakkNCyAHQQAgCCACQSdqSxsNDCAFEKICCyAGRQRAIAMoApgBIgJBBGsoAgAiBkF4cSIFIARBAnQiBEEEQQggBkEDcSIGG2pJDQsgBkEAIAUgBEEnaksbDQwgAhCiAgsgAygC+AIiAkUNAkMAABBBIAAqAkggAC0AWEECRiIEG0MAAEDBIAAqAkQgBBsiMJNDAAB+Q5UhMSADKAL0AiIEIAJBA3QiBWohEiAAKAIEIQ8gACgCCCEH/QwAAID/AACA/wAAgP8AAID/IS39DAAAgH8AAIB/AACAfwAAgH8hLkEAIQYCQAJAAkACQAJAA0AgBCAGakEEaigCACICIAdPDQEgDyACQRhsaiICQRFqLwAAIAJBE2otAAAiCEEQdHIiCUEIdiEKQwAAAAAhMkMAAAAAITQgCUH/AXEEQCAwIDEgCUEBa0H/AXGzlJIQiQQhNAsgCkH/AXEEQCAwIDEgCkEBa0H/AXGzlJIQiQQhMgsgCAR9IDAgMSAIQQFrQf8BcbOUkhCJBAVDAAAAAAshOEMAAIA/IAJBFGovAQAiCEEIdrP9EyAIIAJBFmotAAAiCUEQdHJB/wFxs/0gAf0MAAB/QwAAf0MAAH9DAAB/Q/3nASIsICz95AH9DAAAgL8AAIC/AACAvwAAgL/95AEiLP0fASI3i5MgLP0fACI5i5MiM4xDAAAAABDgCCEBIAmzQwAAf0OVQwAAAD+UQ9sPSUCUIjUQmQIhNiA1EJsCITUgLSAC/QACACAs/Q0AAQIDBAUGBwgJCgsICQoLIi8gOP0TIDT9IAAgMv0gAf0MbxKDOm8SgzpvEoM6bxKDOv3rAf0MAADAPwAAwD8AAMA/AADAP/3mASItICz9DQgJCgsICQoLCAkKCwABAgNDAACAPyA2IDcgASABjCI0ICz9DAAAAAAAAAAAAAAAAAAAAAD9Rv1NIiz9xwH9GwJBAXEbkiIyIDMgM5QgMiAylCA5IAEgNCAs/RsAQQFxG5IiMiAylJKSkSI0lZQiASABIAGSIjeUIjkgNiAyIDSVlCIyIDIgMpIiOJQiOpKT/RMgASA2IDMgNJWUIjYgNpIiM5QiNCA1IDiUIjuS/SAAIDIgM5QiMiA1IDeUIjeT/SAB/eAB/eYBIC0gLP0NBAUGBwQFBgcEBQYHAAECAyAyIDeS/RMgASA4lCIBIDUgM5QiNZP9IABDAACAPyA5IDYgM5QiM5KT/SAB/eAB/eYBIC0gLP0NAAECAwABAgMAAQIDAAECAyA0IDuT/RNDAACAPyA6IDOSk/0gACABIDWS/SAB/eAB/eYB/eQB/eQBIiz95AH96wEhLSAuIC8gLP3lAf3qASEuIAUgBkEIaiIGRw0ACyAtIC795QEiLCAsICz9DQgJCgsICQoLAAECAwABAgP96wEiLyAvICz9DQQFBgcAAQIDAAECAwABAgP96wH9HwAgLCAsICz9DQgJCgsICQoLBAUGBwQFBgf96gEiLyAvICz9DQQFBgcAAQIDAAECAwABAgP96gH9HwBDAABAQJRgRQRAIANCBDcC6AIgA0IANwLgAiADQoCAgIDAADcC2AIgA0IENwLQAiADQgA3AsgCIANCgICAgMAANwLAAiADQgQ3ArgCIANCADcCsAIgA0KAgICAwAA3AqgCIANCBDcCoAIgA0IANwKYAiADQoCAgIDAADcCkAIgLiAt/eQB/QwAAAA/AAAAPwAAAD8AAAA//eYBIiz9HwAhASAs/R8CITAgLP0fASExQQAhAiADKALwAiEHA0AgAiAEakEEaigCACIGIAAoAggiCE8NAyADQZACaiAWIAAoAgQgBkEYbGoiCCoCACABXRtBAEEYIAgqAgQgMV0baiIJQQhBOCAIKgIIIDBdIggbaiISKAIAIgogCUEAQTAgCBtqIg8oAgBGBEAgD0GwwsEAEIsGCyAJQQRBNCAIG2ooAgAgEiAKQQFqNgIAIApBAnRqIAY2AgAgBSACQQhqIgJHDQALIAcEQCAEQQRrKAIAIgJBeHEiBiAHQQN0IgVBBEEIIAJBA3EiAhtqSQ0RIAJBACAGIAVBJ2pLGw0SIAQQogILQSAQcSICRQ0NIAIgAygCmAI2AgAgAiADKAKkAjYCBCACIAMoArACNgIIIAIgAygCvAI2AgwgAiADKALIAjYCECACIAMoAtQCNgIUIAIgAygC4AI2AhggAiADKALsAjYCHCADQQg2AsABIAMgAjYCvAEgA0EINgK4ASADICE3A5ABIANCATcC7AEgA0ECNgLkASADQZDCwQA2AuABIAMgA0GQAWo2AugBIANB4AFqEOsCIAMoArgBIgIEQCADKAK8ASIEQQRrKAIAIgZBeHEiBSACQQJ0IgJBBEEIIAZBA3EiBhtqSQ0RIAZBACAFIAJBJ2pLGw0EIAQQogILQeAAEHEiAkUNDSACIANBkAJqQeAA/AoAACACKAIAIQQgAkGAgICAeDYCACAEQYCAgIB4Rg0EIAJBBGoiECkCACEaIAIoAgwhByACQYCAgIB4NgIMIAdBgICAgHhGDQQgAikCECEbIAIoAiQhCCACQYCAgIB4NgIkIAhBgICAgHhGDQQgAikCKCEcIAIoAhghCSACQYCAgIB4NgIYIAlBgICAgHhGDQQgAikCHCEkIAIoAkghCiACQYCAgIB4NgJIIApBgICAgHhGDQQgAikCTCElIAIoAlQhEiACQYCAgIB4NgJUIBJBgICAgHhGDQQgAikCWCEmIAIoAjwhDyACQYCAgIB4NgI8IA9BgICAgHhGDQQgAikCQCEnIAIoAjAhDiACQYCAgIB4NgIwIA5BgICAgHhGDQQgAikCNCEoIAMoAmwiBiADKAJgIgVGBEAgA0HgAGpBoMLBABCkBiADKAJgIQUgAygCbCEGCyADKAJkIAMoAmggBmoiFCAFQQAgBSAUTRtrQQxsaiIFIBo3AgQgBSAENgIAIAMgBkEBaiIGNgJsIAMoAmAiBSAGRgRAIANB4ABqQaDCwQAQpAYgAygCYCEFIAMoAmwhBgsgAygCZCADKAJoIAZqIgQgBUEAIAQgBU8ba0EMbGoiBCAbNwIEIAQgBzYCACADIAZBAWoiBjYCbCADKAJgIgUgBkYEQCADQeAAakGgwsEAEKQGIAMoAmAhBSADKAJsIQYLIAMoAmQgAygCaCAGaiIEIAVBACAEIAVPG2tBDGxqIgQgHDcCBCAEIAg2AgAgAyAGQQFqIgY2AmwgAygCYCIFIAZGBEAgA0HgAGpBoMLBABCkBiADKAJgIQUgAygCbCEGCyADKAJkIAMoAmggBmoiBCAFQQAgBCAFTxtrQQxsaiIEICQ3AgQgBCAJNgIAIAMgBkEBaiIGNgJsIAMoAmAiBSAGRgRAIANB4ABqQaDCwQAQpAYgAygCYCEFIAMoAmwhBgsgAygCZCADKAJoIAZqIgQgBUEAIAQgBU8ba0EMbGoiBCAlNwIEIAQgCjYCACADIAZBAWoiBjYCbCADKAJgIgUgBkYEQCADQeAAakGgwsEAEKQGIAMoAmAhBSADKAJsIQYLIAMoAmQgAygCaCAGaiIEIAVBACAEIAVPG2tBDGxqIgQgJjcCBCAEIBI2AgAgAyAGQQFqIgY2AmwgAygCYCIFIAZGBEAgA0HgAGpBoMLBABCkBiADKAJgIQUgAygCbCEGCyADKAJkIAMoAmggBmoiBCAFQQAgBCAFTxtrQQxsaiIEICc3AgQgBCAPNgIAIAMgBkEBaiIGNgJsIAMoAmAiBSAGRgRAIANB4ABqQaDCwQAQpAYgAygCYCEFIAMoAmwhBgsgAygCZCADKAJoIAZqIgQgBUEAIAQgBU8ba0EMbGoiBCAoNwIEIAQgDjYCACADIAZBAWo2AmwgAigCACIEQYCAgIB4ckGAgICAeEcEQCAQKAIAIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCDCIEQYCAgIB4ckGAgICAeEcEQCACKAIQIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCGCIEQYCAgIB4ckGAgICAeEcEQCACKAIcIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCJCIEQYCAgIB4ckGAgICAeEcEQCACKAIoIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCMCIEQYCAgIB4ckGAgICAeEcEQCACKAI0IgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCPCIEQYCAgIB4ckGAgICAeEcEQCACKAJAIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCSCIEQYCAgIB4ckGAgICAeEcEQCACKAJMIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAigCVCIEQYCAgIB4ckGAgICAeEcEQCACKAJYIgZBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDREgBUEAIAcgBEEnaksbDRIgBhCiAgsgAkEEaygCACIEQXhxQeQAQegAIARBA3EiBhtJDRAgBkEAIARBiAFPGw0FIAIQogIMCQsgAyAuIC395AH9DAAAAD8AAAA/AAAAPwAAAD/95gH9CwQAIANBAEEBQQIgLP0fASIBICz9HwIiMGAbIgIgMCAs/R8AIjFfGyACIAEgMV8bIgI6AIABIAMgAyACQQJ0cioCADgCNCADIBI2AsQBIAMgAygC8AI2AsABIAMgBDYCvAEgAyAENgK4ASADIAA2ApQBIAMgA0E0ajYCmAEgAyADQYABajYCkAEgA0HgAWoiBiADQbgBaiIFIANBkAFqEJcEIAMpA+ABIRwgAykC7AEhGiADKAL0ASECIAMoAugBIQQgAyAs/QsEkAEgAyAENgJAIAMgAjYCUCADQQY2ArwBIANB7MLBADYCuAEgA0IFNwLEASADIB03A4ACIAMgHzcD+AEgAyAeNwPwASADICI3A+gBIAMgIzcD4AEgAyAGNgLAASAFEOsCAkAgAiAETQRAIBohGyACIQUgHCEaIAQhAgwBCyAcIRsgBCEFCyADIAI2AvABIANBAjYC5AEgAyAFNgL8ASADIBo3AugBIAMgGzcC9AFBASECAkAgGqciBEGAgICAeEYNACADKQLsASEaIAMoAmwiAiADKAJgIgZGBEAgA0HgAGpBnMPBABCkBiADKAJgIQYgAygCbCECCyADKAJkIAMoAmggAmoiBSAGQQAgBSAGTxtrQQxsaiIGIBo3AgQgBiAENgIAIAMgAkEBajYCbEECIQIgG6ciBEGAgICAeEYNACADKQL4ASEaIAMoAmwiBiADKAJgIgVGBEAgA0HgAGpBnMPBABCkBiADKAJgIQUgAygCbCEGCyADKAJkIAMoAmggBmoiByAFQQAgBSAHTRtrQQxsaiIFIBo3AgQgBSAENgIAIAMgBkEBajYCbAsgAyACNgLgASADQeABahCWBgwICyACIAdB3LvHABCMBwALIAYgCEHcu8cAEIwHAAtBjI3IAEEuQbyNyAAQ6wcMCQtBvMPBABDdCQALDAsLQQAhBSADQQA2AuABIANBADYChAJBCCEHAkACQAJ/IAggAmsiBEEAIAQgCE0bIgRBCUkEQCALIQkgEQwBCyADQRBqIANB4AFqQX8gBEEBa2d2QQFqEOgDIAMoAhAiBEGBgICAeEcEQCAEDQpB2JXHAEERQdTMxwAQ6wcACyADKAKEAiIHQQlJBEAgByEFIAshCUEIIQcgEQwBCyADKALkASEFIAMoAugBIQkgCwsiDiAFIAdJBH8gByAFQX9zaiIEIAggAiACIAhJGyIQIAJrIgYgBCAGSRtBAWoiBEEESwRAIAkgBUECdGohBiAC/RH9DAAAAAABAAAAAgAAAAMAAAD9rgEhLCAEIARBA3EiBEEEIAQbayIPIQQDQCAGICz9CwIAIAZBEGohBiAs/QwEAAAABAAAAAQAAAAEAAAA/a4BISwgBEEEayIEDQALIAUgD2ohBSACIA9qIQILIAkgBUECdGohBgNAIAIgEEYNAiAGIAI2AgAgBkEEaiEGIAJBAWohAiAHIAVBAWoiBUcNAAsgBwUgBQs2AgAgAiAITw0BA0ACfyADKAKEAiIEQQlPBEAgAygC5AEhBiADKALoASEHIAsMAQsgBCEGIAshB0EIIQQgEQshBSAEIAZGBH8gA0HgAWoQzQYgAygC6AEhByALIQUgAygC5AEFIAYLQQJ0IAdqIAI2AgAgBSAFKAIAQQFqNgIAIAJBAWoiAiAIRw0ACwwBCyAOIAU2AgALIANB2AFqIANBgAJqKQIANwMAIANByAFqIANB8AFq/QACAP0LAwAgAyAD/QAC4AH9CwO4ASADKALcASIIIQYgACgCECAAKAIUIAogCEEJSSIQBH8gEwUgAygCvAEhBiADKALAAQsgBhDUAiADKAKUASEEIAMoApABIQIgDEEYaiANQRhqKAIANgIAIAxBEGogDUEQaikCADcCACAMIA39AAIA/QsCACADIAI2AuABIAMgBCADKAK0ASIHIAdBCEsiAhsiDzYCjAIgAyAHQQAgAhs2AoQCIANBACAEIAIbNgLkASAPBEAgAygC6AEgCyACGyEUQQAhCiADKAKMASEJA0AgAyAKIgJBAWoiCjYCiAIgFCACQQJ0aigCACEGIAMoAoQBIAlGBEAgA0GEAWpByMHBABCLBgsgAygCiAEgCUECdGogBjYCACADIAlBAWoiCTYCjAFDAACAPyEBAn8CQCAAKAIIIgIgBksEQCAAKAIEIAZBGGxqIgItABMiBCACLQASIgUgAi0AESIOIAUgDksbIgUgBCAFSxsiBAR9QwAAQMEgACoCRCAALQBYQQJGIgUbIjBDAAAQQSAAKgJIIAUbIDCTQwAAfkOVIARBAWtB/wFxs5SSEIkEIjAgMJIFQwAAAAALITAgAkEMai8BACIEQf//AXFFBEAgBEEQdAwDCyAEQf8HcSECIARBgIACcSEFIARBgPgBcSIEQYD4AUYEQCAFQRB0IgRBgICA/AdyIAJFDQMaIAQgAkENdHJBgICA/gdyDAMLIAVBEHQhBSAERQ0BIARBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAFcgwCCyAGIAJB3LvHABCMBwALIAIgAmdBEGsiAkH//wNxQQhqdEH///8DcSAFQYCAgNgDciACQRd0a3ILviIxQwAAgD9eBEAgMRDGBUNU+C1AlEMAAIA/kpEhAQsgAygC+AIiAiADKALwAkYEQCADQfACakHIlcEAEPkFCyADKAL0AiIFIAJBA3RqIgQgBjYCBCAEIDAgAZQiATgCACADIAJBAWo2AvgCAkAgAkUEQEEAIQQMAQsgASABXARAA0ACQCAFIAJBAWsiFUEBdiIEQQN0aiIOKgIAIjAgMFsgASAwX0VxDQAgBiAOQQRqKAIASw0AIAIhBAwDCyAFIAJBA3RqIA4pAgA3AgAgBCECIBVBAk8NAAwCCwALA0AgBSACQQFrIhVBAXYiBEEDdGoiDioCACIwIDBbIAEgMF9FcUF/IAEgMGAbIhdBAEwgBiAOQQRqKAIATSAXGwRAIAIhBAwCCyAFIAJBA3RqIA4pAgA3AgAgBCECIBVBAUsNAAsLIAUgBEEDdGoiAiAGNgIEIAIgATgCACAKIA9HDQALCyAHQQlPBEAgAygC6AEiAkEEaygCACIEQXhxIgYgB0ECdCIFQQRBCCAEQQNxIgQbakkNBCAEQQAgBiAFQSdqSxsNCyACEKICCyAQRQRAIAMoAsABIgJBBGsoAgAiBEF4cSIGIAhBAnQiBUEEQQggBEEDcSIEG2pJDQogBEEAIAYgBUEnaksbDQsgAhCiAgsgAygC+AIiCQ0ACwsgAygC8AIiAkUNACADKAL0AiIEQQRrKAIAIgZBeHEiBSACQQN0IgJBBEEIIAZBA3EiBhtqSQ0HIAZBACAFIAJBJ2pLGw0DIAQQogILIAMoAmwiAg0BDAQLCwwECwwECwALIAMoAowBIQYLIAMgACgCCCICNgK4ASADIAY2ApABIAIgBkcEQCADQQA2AuABQQAgA0GQAWogA0G4AWogA0HgAWpBrMPBABD1BwALIAAgAygCiAEiACAGEIkCIANB4ABqEOsDAkAgAygChAEiAgRAIABBBGsoAgAiBEF4cSIGIAJBAnQiAkEEQQggBEEDcSIEG2pJDQIgBEEAIAYgAkEnaksbDQEgABCiAgsgA0GAA2okAA8LDAELQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0GY+scAQdYAIANB/ABqQaTuwQBBtO7BABDgBgAL3MwBA0R/E34EeyMAQcAGayIEJAAgASABNQIEIlc3AwhBqJDIACkDACJGQgiIIkmnIhxBCHQgRqciCkH/AXEiJHIhLCBGQv8BgyFMQuSRwYCwAiFVIApBCHYhNCAEQbAGaq1CgICAgCCEIVYgBEGQBmqtQoCAgIAghCFYIEZCIIinIhNBBGshQyBGQhCIpyElIARB1wRqITwgBEH4BWohRCAEQfQBaiFFIARB2AJqIT0gBEG4A2pBAXIhNyAEQYACaiE+IARB4AFqQQlyIT8gBEHDA2ohQEGGgICAeCEtIFchTgJAAkACQAJAAkADQAJAIAQCfgJAAkACQAJAAkBBgBAQcSIiRQ0AICJBBGsiOS0AAEEDcQRAICJBAEGAEPwLAAtBACEFQQMhDEEBIRZBBCEGAkACQAJAAkACQANAIAYgBUF/cyIDaiIQQQNLDQIgAyAMIgJqIgxBBE8NAQJAIAwtAKCOQSIIIBAtAKCOQSIDTwRAIAMgCE8EQEEAIAVBAWoiAyADIBZGIgMbIQUgAiAWQQAgAxtrIQwMAgsgBiAMayEWQQAhBQwBCyACQQFrIQxBASEWQQAhBSACIQYLIAUgDEkNAAtBACEFQQMhDEEBIQdBBCECAkACQAJAAkACQAJAAkACQANAIAwhAyACIAVBf3MiCGoiD0EDSw0BIAMgCGoiDEEDSw0CAkAgDC0AoI5BIhAgDy0AoI5BIghNBEAgCCAQTQRAQQAgBUEBaiIMIAcgDEYiDBshBSADIAdBACAMG2shDAwCCyACIAxrIQdBACEFDAELIANBAWshDEEBIQdBACEFIAMhAgsgBSAMSQ0AC0EEIAYgAiACIAZLIgIbIhJrIgZB/v///wdxDQQgEkEFTw0HIBIgFiAHIAIbIhprIQIgEiAaSQ0GIAYgGksNBEEAIR8gBkEDSw0FIBJBoI7BAGohAyACQaCOwQBqIQUgBkECSQ0CIAUvAAAgAy8AAEcNBCADQQJqIQMgBUECaiEFDAMLIA9BBEGQ/MQAEIwHAAsgDEEEQaD8xAAQjAcACyASQQRGDQILIAUtAAAgAy0AAEYNAQsgBiASIAYgEksbIRpBASEfCyBOQoAQfSJGQgAgRiBOWBshS0EEIBIgEkEETRshLyAiQQVrISkgEkEDaiELQQEhBSASQQFqITogEkEEayEbIBJBA2shHSASQQJrIRggEkEBayEgIBJBf3MhQSAEQQI2ApADIBJBAmohFEGGgICAeCEPA0AgAyEHIAghDiANIRAgASgCACEJIAEoAgQiFa0hTQNAIEsgTloNBkJ/IEtCgBB8IkYgRiBLVBsiRiBLWA0GAkACQAJAIE4gRiBGIE5WGyBLfSJGpyICQYAQTQRAAkACQCAFQQFxBEAgAQJ+AkAgAiAVIEsgTSBLIE1UG6ciA2tNBEAgAyAJaiEDIAJBAUcEQCACBEAgIiADIAL8CgAAC0EEIQUMAgsgIiADLQAAOgAAQQQhBQwBCyAKIQUgTSBMQgRSDQEaCyBGQv8fgyBLfAs3AwggBUH/AXEiA0EERgRAIAIhAwwCCyBJQhiIpyEIIEmnIQwCQAJAAkAgA0EBaw4DAQACEQsgCC0ACCEMCyAMQf8BcUElRg0ODA8LIAgtAAhBJUcNDiAIKAIAIQogCEEEaigCACICKAIAIgEEQCAKIAERAwALIAIoAgQiAwRAIApBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIANqSQ0dIAFBACACIANBJ2pLGw0cIAoQogILIAhBBGsoAgAiAUF4cSICQRBBFCABQQNxIgEbSQ0cIAFBACACQTRPGw0bIAgQogIMDQsgAiAQIgNJDQELIANBBEkNAyADQRBJDQICQAJAIB8EQCADIQwDQAJ/AkAgAyAMQQRrIg1LBEBCASANICJqLQAAIgJBP3GthkLgkASDQgBSDQEgDQwCCyANIANB+JjIABCMBwALAkACQCAgQQNNBEACQCAMQQVrIgUgEmoiBiADTw0AIBIhCCAgQaCOwQBqLQAAIAYgImotAABHDQMgIEUNAiAFICBqIgYgA08NACAgIQggGEGgjsEAai0AACAGICJqLQAARw0DIBhFDQIgBSAYaiIGIANPDQAgGCEIIB1BoI7BAGotAAAgBiAiai0AAEcNAyAdRQ0CIAUgHWoiBiADTw0AIB0hCCAbQaCOwQBqLQAAIAYgImotAABHDQMgG0UNAiAFIBsiCGoiBiADSQ0DCyAGIANBmJnIABCMBwALIBINBQtBACEIIAJB0ABHDQAgEkEETw0KIA0gEmoiAiADTw0FAkAgEkGgjsEAai0AACACICJqLQAARw0AIDpBBEYNCyANIDpqIgIgA08NBiA6QaCOwQBqLQAAIAIgImotAABHDQAgFEEERg0LIA0gFGoiAiADTw0GIBQiBUGgjsEAai0AACACICJqLQAARgRAIAtBBEYNDCALIA1qIgIgA08NByALIgVBoI7BAGotAAAgAiAiai0AAEYNDAsgBUEERg0LCyAMIBprDAELIAwgQWogCGoLIgxBBE8NAAsMBgtBBCEWIAMhAgNAAn8CQCADIAJBBGsiDUsEQEIBIA0gImotAAAiI0E/ca2GQuCQBINCAFINAUEEIRYgDQwCCyANIANBuJnIABCMBwALIAIgImohJiAWIBIgEiAWSxtBAWohDAJAAkACQAJAAkADQCAMQQFGDQEgDEEBayIFQQRLDQIgAyACIAxqQQZrIghLBEAgDEGejsEAaiAMICZqIQggBSEMLQAAIAhBBmstAABGDQEMBgsLIAggA0HYmcgAEIwHAAtBACEFICNB0ABHDQMgEiAWTw0MIAIgOWohCCASIQwDQCAMIC9GDQIgDCANaiADTw0DIAxBoI7BAGotAAAgCCAMai0AAEYEQCAWIAxBAWoiDEYNDgwBCwsgAiAaIhZrDAQLIAxBAmtBBEHImcgAEIwHAAsgL0EEQeiZyAAQjAcACyADIAIgEmpBBGsiACAAIANJGyADQfiZyAAQjAcAC0EEIRYgAiBBaiAFagsiAkEETw0ACwwFCyAgQQRBiJnIABCMBwALIAMgDCASakEEayIAIAAgA0kbIANBqJnIABCMBwALQQAgECACQfCbyAAQ6gcAC0EAIAJBgBBBvIrBABDqBwALIAMgImohAkEAIQxBASEFA0AgAiAFakECay0AACAMQQF0aiEMIAVBAWsiBUF9Sg0ACyADIClqIQUDQCAFQQFqIQICQCAMQaoCRw0AIAJBoI7BAEEEELsGRQ0AIAIgImshDQwDCyACICJNDQEgBS0AACAMQQF0IAVBBGotAABBBHRraiEMIAVBAWshBQwACwALIEtQDQdCfyBLQgN8IkYgRiBLVBsiR0KAEH0iRkIAIEYgR1gbIkYgTiBGIE5UGyFLQQEhBQwBCwsCQCABAn4CQAJAAn8CQAJAAkAgFSBLIA2tfCJGIE0gRiBNVBunIgJrQRVNBEACQAJAAkACQCBMQgRRBEAgASBGQhZ8NwMIIBwhDCAkQQFrDgQCAQEGAwsgASBNNwMIIBwhDCAkQQFrDgQBAAAFAgsgEy0ACCEMCyAMQf8BcUElRg0BCyAEIBM2AsADIAQgLDYCvAMgBEGBgICAeDYCuAMMAwsgBCBWNwOQBiAEQRg2ArQGIARBiI7BADYCsAYgBEIBNwLcBCAEQQE2AtQEIARBuJ7HADYC0AQgBCAEQZAGajYC2AQgBEG4A2ogBEHQBGoQ7AMgJEEDRw0CIBMoAgAhBiATQQRqKAIAIgMoAgAiAgRAIAYgAhEDAAsgAygCBCIIBEAgBkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgCGpJDR4gAkEAIAMgCEEnaksbDR0gBhCiAgsgQygCACICQXhxIgNBEEEUIAJBA3EiAhtJDR0gAkEAIANBNE8bDRwgExCiAgwCCyABIEZCFnwiSDcDCCACIAlqIgIoAABB0JaVMEYNAgsgBEHAA2pBzI7BACgCADYCACAEQcSOwQApAgA3A7gDCyAELwC5A0EIdCEDIAQtALsDQRh0IQggBC8AwQMgQC0AAEEQdHIhAiAELQDAAyEFIAQtAL8DISogBC8AvQMhFiAELQC8AyEGIAQtALgDISMMBQsgNyACKQAENwAAIDdBCGoiQiACQQxqKAAANgAAIAIoABAhCCAELwC5AyEjIAQvALsDISYgBC8AvQMhFiAELwC/AyERIAQoAMEDIQUgAi8AFCIMrSFKIAwEQCAMEHEiGUUNDiAZQQRrLQAAQQNxRSAMRXJFBEAgGUEAIAz8CwALIAwgFSBIIE0gSCBNVBunIgJrTQRAIAIgCWoiAiAMQQFHDQIaIBkgAi0AADoAAAwDCyAKIQYgSSFHIE0gTEIEUg0EGgwDC0EBIRkgCSBIIE0gSCBNVBunagshAiAMRQ0AIBkgAiAM/AoAAAtCACFHQQQhBgsgSCBKfAs3AwgCfwJAIAZB/wFxIgJBBEcEQCBHQhiIpyEFIEenIQgCQAJAAkACQCACQQFrDgMBAAIDCyAFLQAIIQgLIAhB/wFxQSVHDQEMAwsgBS0ACEElRw0AIAUoAgAhCCAFQQRqKAIAIgMoAgAiAgRAIAggAhEDAAsgAygCBCICBEAgCCACIAMoAggQogcLIAVBBGsoAgAiAkF4cSIDQRBBFCACQQNxIgIbSQ0ZIAJBACADQTRPGw0YIAUQogIMAgsgR0IQiKchKiBHpyEWQQEhIyAFQQh2DAILAkACQAJAAkACQAJAAkACQAJAAkACQAJAIFcgSCBKfFoEQCARQf//A0cgCEF/R3EgRkITWHINBiAVIEZCFH0iUiBNIE0gUlYbpyICa0ETSw0DIExCBFINASABIEY3AwggJEEERw0CDAQLQRshCCAPQYaAgIB4RgRAQcmRwQAhAwwLC0HJkcEAIQMCQAJAQQEgD0H/////B2ogD0GAgICAeE0bDgIAAQwLIAdB/wFxQQNHDQsgDigCACEGIA5BBGooAgAiAygCACICBEAgBiACEQMACyADKAIEIgIEQCAGIAIgAygCCBCiBwsgDkEMQQQQogdByZHBACEDDAsLIA9BgICAgHhyQYCAgIB4Rg0KIAdB/wFxIChBCHRyIA9BARCiBwwKCyABIE03AwggJEEERg0CCyAcIQYCQAJAAkACQCAkQQFrDgMBAAACCyATLQAIIQYLIAZB/wFxQSVGDQELIAQgEzYCwAMgBCAsNgK8AyAEQYGAgIB4NgK4AwwDCyAEIFg3A/AFIARBHzYClAYgBEHQjsEANgKQBiAEQgE3AtwEIARBATYC1AQgBEG4nscANgLQBCAEIARB8AVqNgLYBCAEQbgDaiAEQdAEahDsAyAkQQNHDQIgEygCACEGIBNBBGooAgAiAygCACICBEAgBiACEQMACyADKAIEIgIEQCAGIAIgAygCCBCiBwsgE0EMQQQQogcMAgsgASBGNwMIIAIgCWoiAigAAEHQlpk4Rg0DCyAEQcADakGoj8EAKAIANgIAIARBoI/BACkCADcDuAMLIAQgBDUAvQMiRz4CtAYgBCAEKAC5AyICNgKwBiAEKACzBiEDIAQtALgDIAJBCHRyIgJBgYCAgHhPBEAgAkGBgICAeEcgA0H/AXFBA0dyDQEgRyBAMQAAQjCGIARBwQNqMwAAQiCGhIRCGIinIhAoAgAhBiAQQQRqKAIAIgMoAgAiAgRAIAYgAhEDAAsgAygCBCICBEAgBiACIAMoAggQogcLIBBBDEEEEKIHDAELIAJBgICAgHhyQYCAgIB4Rg0AIAMgAkEBEKIHCyAIrSFHIBENASBGIEd9IkdCACBGIEdaGyFRDAULIDcgAikABDcAACBCIAJBDGooAAA2AAAgUiAEKQC9AyJPWARAQSAhCAJAIA9BhoCAgHhGDQBBgZHBACEDAkACQEEBIA9B/////wdqIA9BgICAgHhNGw4CAAEHCyAHQf8BcUEDRw0GIA4oAgAhBiAOQQRqKAIAIgMoAgAiAgRAIAYgAhEDAAsgAygCBCICBEAgBiACIAMoAggQogcLIA5BDEEEEKIHDAELIA9BgICAgHhyQYCAgIB4Rg0FIAdB/wFxIChBCHRyIA9BARCiBwtBgZHBACEDDAQLIAIoABBBAUsNAiAEKAC5AyEGAkAgBCgCkANBAkcEQCAEKALwAiAEQdAEakHEj8EAENACRQ0BIAQoAvgCIgJFDQEgBCgC9AIgAkEBEKIHDAELQYAQEHEiA0UNESADQQRrLQAAQQNxBEAgA0EAQYAQ/AsACyA8/QwAAAAAAAAAAAAAAAAAAAAA/QsAACAEQQI6AOgBID8gBEHQBGoiAkHHAPwKAAAgBEKAEDcCjAMgBCADNgKIAyAEQgA3A4ADIARBADYC+AIgBEKAgICAEDcD8AIgBEEZNgLoAiAEQoCAgIAQNwPgAiAEQRo2ArACIAJBxI/BABDQAgsgPiAEQdAEakGAAfwKAAAgBCBPNwOAAyAEQQA2ApADIAQgUjcD+AEgBCBPNwPwASAEQQA6AOgBIAQgTzcD4AFBhoCAgHghAiAhIQMgHiEQA0AgECEeIAMhISACIQkgBEHQBGogBEHgAWogARD1ASAEKQPYBCFKIAQoAtAEQQFGBEAgBCgC1AQhAyACQYaAgIB4Rg0DAkACQEEBIAJB/////wdqIAJBgICAgHhNGw4CAAEFCyAeQf8BcUEDRw0EICEoAgAhBiAhQQRqKAIAIggoAgAiAgRAIAYgAhEDAAsgCCgCBCICBEAgBiACIAgoAggQogcLICFBDEEEEKIHDAQLIAlBgICAgHhyQYCAgIB4Rg0DIB4gCUEBEKIHDAMLAkACQAJAAkACQAJ/AkACQCBKp0EBcQRAIAEoAgQiA60hRwJAAkACQCADQv////8PIAEpAwgiSiBKQv////8PWhunayICQQAgAiADTRtBN00EQAJAAkACQAJAIExCBFEEQCABIEpCOHw3AwggHCEDICRBAWsOBAIBAQYDCyABIEc3AwggHCEDICRBAWsOBAEAAAUCCyATLQAIIQMLIANB/wFxQSVGDQELIAQgEzYCwAMgBCAsNgK8AyAEQYGAgIB4NgK4AwwDCyAEIFY3A5AGIARBGDYCtAYgBEGsj8EANgKwBiAEQgE3AtwEIARBATYC1AQgBEG4nscANgLQBCAEIARBkAZqNgLYBCAEQbgDaiAEQdAEahDsAyAkQQNHDQIgEygCACEQIBNBBGooAgAiAygCACICBEAgECACEQMACyADKAIEIgIEQCAQIAIgAygCCBCiBwsgE0EMQQQQogcMAgsgBCkD4AQhUCABIEpCOHwiUzcDCCABKAIAIiogSiBHIEcgSlYbp2oiECgAAEHQlpkwRg0CCyAEQcADakHMjsEAKAIANgIAIARBxI7BACkCADcDuAMLIAQtALsDQRh0IAQvALkDQQh0ciErIAQoAsADIQMgBCgCvAMhECAELQC4AyECDAgLIDcgECkABDcAACBCIBBBDGooAAA2AABBACECQYCAgIB4ISsgBCkAuQMiSEIsVARAQRYhA0GDk8EAIRAMCAsgUiBQfSJKQgAgSiBSWBsiVEJ/IEhCDHwiSiBIIEpWG1QEQEEkIQNB35LBACEQDAgLIEinQSxrIhVBAEgNASAQ/QAAKCFaIBD9AAAYIVsgECgAECECIBAoABQhECAENQC5AyFNIAQ1AL0DIUggFUUNAiAVEHEiEUUNGiARQQRrLQAAQQNxRSAVRXJFBEAgEUEAIBX8CwALIAMgUyBHIEcgU1YbpyIDayAVTwRAIAMgKmoiAyAVQQFHDQQaIBEgAy0AADoAAAwFCyAKIQMgSSFKIExCBFINBgwFC0HGkMEAIB4gCUGGgICAeEYiBRshAwJAIA9BhoCAgHhGDQACQAJAQQEgD0H/////B2ogD0GAgICAeE0bDgIAAQILIAdB/wFxQQNHDQEgDigCACEGIA5BBGooAgAiCCgCACICBEAgBiACEQMACyAIKAIEIgIEQCAGIAIgCCgCCBCiBwsgDkEMQQQQogcMAQsgD0GAgICAeHJBgICAgHhGDQAgB0H/AXEgKEEIdHIgD0EBEKIHC0EVICEgBRshCEGAgICAeCAJIAUbIQ8gA0EIdiEoQQAhBSAMRQ0RIBkgDEEBEKIHDBELQZySwQAQ/wcAC0EBIREgKiBTIEcgRyBTVhunagshAyAVRQ0AIBEgAyAV/AoAAAtCACFKQQQhAwsgUyAVrXwhRwsgASBHNwMIAn8CQCADQf8BcSIqQQRHBEAgSkIYiKchAyBKpyICIRACQAJAAkACQCAqQQFrDgMBAAIDCyADLQAIIRALIBBB/wFxQSVHDQEMAwsgAy0ACEElRw0AIAMoAgAhKiADQQRqKAIAIhAoAgAiAgRAICogAhEDAAsgECgCBCICBEAgKiACIBAoAggQogcLIANBDEEEEKIHDAILIAJBCHQgKnIhEEEBDAILAkACfyAGIBBHBEBB64/BACEQQS8MAQsgSEIghiBNhEIMfCBUUQ0BQciPwQAhEEEjCyEDQYCAgIB4IQIgFUUNBCARIBVBARCiBwwECyAEQSBqIFv9HQFCLhDdBgJAQn9CfyAEKQMgIkogWv0dAXwiRyBHIEpUGyAEKQMoQgBSGyBQWARAIFAgT30hUSAJQYaAgIB4Rg0BIA0hECAGIRcgAiE4IBUhNSARITMgRiFOIBYhMiAmIS4gIyEwIFshXCBaIVkCQAJAQQEgCUH/////B2ogCUGAgICAeE0bDgIAARgLIB5B/wFxQQNHDQIgISgCACEXICFBBGooAgAiECgCACIDBEAgFyADEQMACyAQKAIEIgMEQCAXIAMgECgCCBCiBwsgIUEMQQQQogcMAgsgCUGAgICAeHJBgICAgHhGDQEgHiAJQQEQogcMAQsCQCAJQYaAgIB4Rg0AAkACQEEBIAlB/////wdqIAlBgICAgHhNGw4CAAECCyAeQf8BcUEDRw0BICEoAgAhECAhQQRqKAIAIgMoAgAiAgRAIBAgAhEDAAsgAygCBCICBEAgECACIAMoAggQogcLICFBDEEEEKIHDAELIAlBgICAgHhyQYCAgIB4Rg0AIB4gCUEBEKIHC0GakMEAIRBBLCEDQYCAgIB4IQIgFUUNBSARIBVBARCiBwwFCyANIRAgBiEXIAIhOCAVITUgESEzIEYhTiAWITIgJiEuICMhMCBbIVwgWiFZDBQLQaySwQAhEEEzIQNBAAshAiAVRQ0AIBEgFUEBEKIHCyArIAJB/wFxciECCyAJQYaAgIB4Rg0AAkACQEEBIAlB/////wdqIAlBgICAgHhNGw4CAAECCyAeQf8BcUEDRw0BICEoAgAhFSAhQQRqKAIAIh4oAgAiEQRAIBUgEREDAAsgHigCBCIRBEAgFSARIB4oAggQogcLICFBDEEEEKIHDAELIAlBgICAgHhyQYCAgIB4Rg0AIB4gCUEBEKIHDAALAAsCQCBGIEdWBEACQCAEKAKQA0ECRwRAIAQoAvACIARB0ARqQeSNwQAQ0AJFDQEgBCgC+AIiAkUNASAEKAL0AiACQQEQogcMAQtBgBAQcSIDRQ0SIANBBGstAABBA3EEQCADQQBBgBD8CwALIDz9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIARBAjoA6AEgPyAEQdAEaiICQccA/AoAACAEQoAQNwKMAyAEIAM2AogDIARCADcDgAMgBEEANgL4AiAEQoCAgIAQNwPwAiAEQRk2AugCIARCgICAgBA3A+ACIARBGjYCsAIgAkHkjcEAENACCyA+IARB0ARqIgJBgAH8CgAAIAQgRzcDgAMgBEEANgKQAyAEIEY3A/gBIAQgRzcD8AEgBEEAOgDoASAEIEc3A+ABIAIgBEHgAWogARD1ASAEKQPYBCFKIAQoAtAERQ0BIAQoAtQEIQMMAgtBGyEIIA9BhoCAgHhGBEBBrpHBACEDDAQLQa6RwQAhAwJAAkBBASAPQf////8HaiAPQYCAgIB4TRsOAgABBQsgB0H/AXFBA0cNBCAOKAIAIQYgDkEEaigCACIDKAIAIgIEQCAGIAIRAwALIAMoAgQiAgRAIAYgAiADKAIIEKIHCyAOQQxBBBCiB0GukcEAIQMMBAsgD0GAgICAeHJBgICAgHhGDQMgB0H/AXEgKEEIdHIgD0EBEKIHDAMLIEqnQQFxBEAgBCkD4AQgR30hUQwEC0ENIQggD0GGgICAeEYEQEGhkcEAIQMMAwtBoZHBACEDAkACQEEBIA9B/////wdqIA9BgICAgHhNGw4CAAEECyAHQf8BcUEDRw0DIA4oAgAhBiAOQQRqKAIAIgMoAgAiAgRAIAYgAhEDAAsgAygCBCICBEAgBiACIAMoAggQogcLIA5BDEEEEKIHQaGRwQAhAwwDCyAPQYCAgIB4ckGAgICAeEYNAiAHQf8BcSAoQQh0ciAPQQEQogcMAgsgSkIgiKchCCBKpyEFIAwEQCAZIAxBARCiBwtBACEZIA0hECADIQwMDQtBJiEIIA9BhoCAgHhGBEBB25DBACEDDAELQduQwQAhAwJAAkBBASAPQf////8HaiAPQYCAgIB4TRsOAgABAgsgB0H/AXFBA0cNASAOKAIAIQYgDkEEaigCACIDKAIAIgIEQCAGIAIRAwALIAMoAgQiAgRAIAYgAiADKAIIEKIHCyAOQQxBBBCiB0HbkMEAIQMMAQsgD0GAgICAeHJBgICAgHhGDQAgB0H/AXEgKEEIdHIgD0EBEKIHCyADQQh2IShBgICAgHghD0EAIQUgDEUNBAJAIBlBBGsoAgAiAkF4cSIGQQRBCCACQQNxIgIbIAxqTwRAIAJBACAGIAxBJ2pLGw0BIBkQogIMBgsMGQsMFwtBACEzIA0hECBGIU4gFiEyICYhLiAjITAMCgtBIiEFQQAhI0H3kcEAIQZBACEqQcggIRZBAAshAkGAgICAeCEIQQAhAyAMRQ0AIBlBBGsoAgAiEEF4cSImQQRBCCAQQQNxIhAbIAxqSQ0VIBBBACAmIAxBJ2pLGw0UIBkQogILIAVB/wFxIAJBCHRyIQwgFkH//wNxICpB/wFxQRB0ciECIAMgI0H/AXFyIAhyIRACQCAPQYaAgIB4RwRAQQAhBSAOIQggByEDAkACQEEBIBBB/////wdqIBBBgICAgHhNGw4CAAEECyAGQf8BcUEDRw0DIAwoAgAhBiAMQQRqKAIAIgMoAgAiAgRAIAYgAhEDAAsgAygCBCIIBEAgBkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgCGpJDRggAkEAIAMgCEEnaksbDRcgBhCiAgsgDEEEaygCACICQXhxIgNBEEEUIAJBA3EiAhtJDRcgAkEAIANBNE8bDRYgDBCiAgwCCyAQQYCAgIB4ckGAgICAeEYNAiAGQf8BcSACQQh0ciIIQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyAQakkNFiACQQAgAyAQQSdqSxsNFSAIEKICDAELQQAhBSAQIQ8gDCEIIAYhAyACISgMAQsgDiEIIAchAwwACwALIAIgEiASQYD8xAAQ6gcACyAEQQA2AvABIARBATYC5AEgBEGIgsgANgLgASAEQgQ3AugBIARB4AFqQfD7xAAQjQgACyAMQQRBoPzEABCMBwALIBBBBEGQ/MQAEIwHAAtBgICAgHghDCAPQYaAgIB4RwRAIAetQv8BgyAorUL///8Hg0IIhoQgDq1CIIaEIVUgDyEMCwJAIAQoApADQQJGDQAgBCgCjAMiCgRAIAQoAogDIgNBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIApqSQ0QIAFBACACIApBJ2pLGw0PIAMQogILIAQoAvACRQ0AIAQoAvgCIgpFDQAgBCgC9AIiA0EEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgCmpJDQ8gAUEAIAIgCkEnaksbDQ4gAxCiAgsgOSgCACICQXhxQYQQQYgQIAJBA3EiARtJDQ4gAUEAIAJBqBBPG0UEQCBVQiCIpyEIIFWnIQUgIhCiAgwLCwwNCyAFrUL/AYMgSUL//////////wCDQgiGhKchBUEAIRlBgYCAgHghDAsCQCAPQYaAgIB4Rg0AAkACQEEBIA9B/////wdqIA9BgICAgHhNGw4CAAECCyAHQf8BcUEDRw0BIA4oAgAhBiAOQQRqKAIAIgMoAgAiAgRAIAYgAhEDAAsgAygCBCICBEAgBiACIAMoAggQogcLIA5BBGsoAgAiAkF4cSIDQRBBFCACQQNxIgIbSQ0OIAJBACADQTRPGw0NIA4QogIMAQsgD0GAgICAeHJBgICAgHhGDQAgB0H/AXEgKEEIdHIgD0EBEKIHCwJAIAQoApADQQJGDQAgBCgCjAMiDQRAIAQoAogDIgZBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIA1qSQ0OIAJBACADIA1BJ2pLGw0NIAYQogILIAQoAvACRQ0AIAQoAvgCIg1FDQAgBCgC9AIiBkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgDWpJDQ0gAkEAIAMgDUEnaksbDQwgBhCiAgsCQCA5KAIAIgNBeHFBhBBBiBAgA0EDcSICG08EQCACQQAgA0GoEE8bRQRAICIQogIgGUUNCwJ/AkAgMwRAIFz9HQEiRiBc/R0AWg0BQYCAgIB4IQVBkI/IACEDQcgAIQgMDAsgLkH//wNxIQUgMkH//wNxIQYgCK0hSyAwQf//A3EMAQsgRqchBiBZ/R0BIUsgFyEFIDgLIFEgSyBRfCJPVgRAQYCAgIB4IQVB2I/IACEDQSghCAwKCyAFRgRAQYOAgIB4IQVB+IzBACEDQRshCCAGQQAgBiBPp00bIgetQqgBfiJGQiCIpw0KIEanIgJBAEgNCiACQfn///8HSQRAAkAgAkUEQEEIISpBACEHDAELIAIQcSIqRQ0GCyABIE83AwggBEEANgK0AyAEICo2ArADIAQgBzYCrAMCQCAGBEBBACEIA0AgASgCBCIDrSFGIANC/////w8gASkDCCJIIEhC/////w9aG6drIgJBACACIANNG0EtTQRAAkAgTEIEUQRAIAEgSEIufDcDCCAkQQRHDQEMDgsgASBGNwMIICRBBEYNDQtBgYCAgHghBSAcIQIgEyEDICwhBgJAAkAgJEEBaw4DAQAADwsgEy0ACCECCyACQf8BcUElRw0NIAQgVjcDkAYgBEEgNgK0BiAEQcKNwQA2ArAGIARCATcC7AEgBEEBNgLkASAEQbiexwA2AuABIAQgBEGQBmo2AugBIARB0ARqIARB4AFqEOwDIAQoAtgEIQMgBCgC1AQhBiAEKALQBCEFICRBA0cNDSATKAIAIQcgE0EEaigCACINKAIAIgIEQCAHIAIRAwALIA0oAgQiAgRAIAcgAiANKAIIEKIHCyATQQxBBBCiBwwNCyABIEhCLnw3AwggASgCACBIIEYgRiBIVhunaiICKAAAQdCWhRBHDQsgAjUAKiFKIAIoACYhDiACLwAgIQcgAi8AHiENIAI1ABghRyACNQAUIUYgAigAECEPIAIvAAQhFCACLwAcIQMgAigAByERIAIoAAshFSAEIAItAA86AOgBIAQgFTYC5AEgBCARNgLgASAELwDnASEaIAQvAOMBIR0gBEHgAWoiAiABIAMQ9AIgBCgC6AEhAyAEKALkASEWIAQoAuABIgVBhoCAgHhHDQogAiABIA0Q9AIgBCgC6AEhGyAEKALkASESIAQoAuABIgVBhoCAgHhHBEAgEiEmIBshIwwKCyAEQeABaiABIAcQ9AIgBCgC6AEhIyAEKALkASEmIAQoAuABIgVBhoCAgHhHBEAgG0UNCiASIBtBARCiBwwKCwJAAkACQAJAIBFBCHYiGEGAEHEiIEUEQCADQQBIDQECfyADRQRAIARBEGpBAUEAEPACIAQoAhAhESAEKAIUDAELIAMQcSICRQ0OIAMEQCACIBYgA/wKAAALIARBGGogAiADEPACIAQoAhghESAEKAIcCyECIARBCGogJiAjEPACIAQoAgwhKyAEKAIIIR8MBAsgBEHgAWogFiADEMQDIAQoAugBIQIgBCgC5AEhBQJAIAQoAuABIhFBgICAgHhHBEAgAiARTwRAIAUhEQwCCyACRQRAIAVBBGsoAgAiB0F4cSINQQRBCCAHQQNxIi8bIBFqSQ0bIC9BACANIBFBJ2pLGw0aIAUQogJBASERDAILIAUgEUEBIAIQuwIiEQ0BDA4LIAJBAEgNAgJAIAJFBEBBASERDAELIAIQcSIRRQ0OCyACRQ0AIBEgBSAC/AoAAAsgBEHgAWogJiAjEMQDIAQoAugBISsgBCgC5AEhByAEKALgASILQYCAgIB4RwRAIAsgK00EQCAHIR8MBQsgK0UEQCAHQQRrKAIAIg1BeHEiBUEEQQggDUEDcSIvGyALakkNGiAvQQAgBSALQSdqSxsNGSAHEKICQQEhHwwFCyAHIAtBASArELsCIh8NBAwNCyArQQBIDQICQCArRQRAQQEhHwwBCyArEHEiH0UNDQsgK0UNAyAfIAcgK/wKAAAMAwtB2JrIABD/BwALQazWwAAQ/wcAC0Gs1sAAEP8HAAsCf0EBIBpBH3EiCUUNABpBASAaQQV2QQ9xIgVBDWtBdEkNABpBASAVQQh2IgtBgA9xQYAPRg0AGkEBIAtBgPADcUELdkEXSw0AGkEBIAtBAXRBPnEiDUE8Sw0AGiAaQYD8A3FBCXZBvA9qIRVBHiEoQQEgBXQiB0GqK3FFBEACQCAHQdAUcQ0AQRwhKCAaQYAMcQ0AQR1BHEEdIBVBDHEbIBVBGXAbISgLQQEgCSAoSw0BGgsgGkH/A3EgFUEJdHJBgPABayEvIAtB4P//B3FBOiANIA1BOk8bQQF2ciEHQQALIRUCQAJ/AkACfwJAAkAgG0EATgRAAkAgG0UEQEEBIQ0MAQsgGxBxIg1FDRALIBsEQCANIBIgG/wKAAALQRQQcSILRQ0PIAsgGzYCECALIA02AgwgCyAbNgIIIAtCgYCAgBA3AgAgBCAUOgCFAyAEQQNBBCAUQQh2IgVBA0YbQQAgBRs6AIQDIAQgIEELdjoAgQMgBCAdOwHmAiAEQQFBAiAdQQhGG0EAIB0bOwHkAiAEIAc7AfwCIAQgLzsB+gIgBCAVQQFzOwH4AiAEQgA3A+ABIAQgDzYC6AIgBCBHNwOoAiAEIEY3A6ACIARBADYC8AIgBCALNgLsAiAEIAM2ApQCIAQgFjYCkAIgBCACNgKMAiAEIBE2AogCIAQgGDsB/gIgBCAYQQFxOgCAAyAEIBhBA3ZBAXE6AIIDIAQgSjcDsAIgBCArNgKcAiAEIB82ApgCIARCADcD8AEgBCBINwO4AiAEIA42AvQCIARBADoAgwMgBEEAOgDIAiAEQgA3A9ACIARBADYC4AIgBEKAgICAgAE3A9gCIARBADsBgAIgCyALKAIAIgJBAWo2AgAgAkEASA0PIAhBAWohFSAEIAs2AugFQQAhBSAEQQA2AuwFIARBAjYC9AUgBCAEQewFajYC/AUgBCAEQegFajYC+AUDQCAFQQFqIQICQCBEIAVBAnRqKAIAIi8oAgAiBQRAIAIhFgwBC0ECIRYgAkECRg0IIARB7AVqIS8gBCgC7AUiBUUNCAsgBEEANgKMBiAEQoCAgIAQNwKEBiAEIBY2AvAFIAU1AhAhVCAEIAVBCGo2ApgGAkAgVFANAEEAIQ1CACFHQQEhK0EAIR1CACFKA0AgBCgCmAYiKUEIaiIUKAIAIgOtIUggBAJ+AkAgA0L/////DyBHIEdC/////w9aG6drIgJBACACIANNG0ECTwRAQQQhAiApQQRqKAIAIEcgSCBHIEhUG6dqLwAAIQdCACFGDAELQQAhByBJIUYgCiECIEggTEIEUg0BGgsgR0ICfAsiRzcDkAYCQAJ/AkACQAJAAkACfgJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkH/AXEiBUEERwRAIEZCGIinIQMgRqciByELAkACQAJAIAVBAWsOAwEAAiQLIAMtAAghCwsgC0H/AXFBJUYNFQwiCyADLQAIQSVGDQFBAyECDCELIAQCfgJAIAMgRyBIIEcgSFQbpyIFa0ECTwRAQQQhAiApQQRqKAIAIAVqLwAAIRpCACFGDAELQQAhGiBJIUYgCiECIEggTEIEUg0BGgsgR0ICfAsiSzcDkAYCQAJAIAJB/wFxIgVBBEcEQCBGQhiIpyEDIEanIgchBgJAAkAgBUEBaw4DAQADBAsgAy0ACCEGCyAGQf8BcUElRw0CDCILAkACQAJAAkACQAJAAkACQAJAAkAgB0H//wNxIgJB9MYBTQRAIAJBAWsOCgUfHx8fHx8fHwEDCyACQfXGAUYNCCACQfXgAUYNAyACQYGyAkYNAQweC0GDgICAeCEFIBpB//8DcUEgRwRAQSohA0HIksgAIQJBEiEGQYkkIQcMLgtBgYCAgHghBSADIEsgSCBIIEtWG6drQQNLIgIgJEEERnJFBEAgJSEGIBwhByAKIQIgEyEDDC4LIAMgS0IEfCJGIEYgSCBMQgRRGyACGyJHIEggRyBIVBunIgJrQQFNBEAgTEIEUg0FIAQgR0ICfDcDkAYgJSEGIBwhByAKIQIgEyEDICRBBEcNLgwdCyApQQRqKAIAIgcgAmovAABBAUcNHAJAAkACQCADIEdCAnwiRiBIIEYgSFQbpyICa0EBTQRAIExCBFINASAEIEdCBHw3A5AGICUhBiAcIQcgCiECIBMhAyAkQQRHDTEMAgsgAiAHai8AAEEYRw0BAn4CQCADIEdCBHwiRiBIIEYgSFQbpyICa0EITwRAIAIgB2opAAAhRkEEIQJCACFNDAELQgAhRiBJIU0gCiECIEggTEIEUg0BGgsgR0IMfAshRyACQf8BcUEERg0CIE1CCIinIQYgTUIYiKchAyBNpyEHDDALIAQgSDcDkAYgJSEGIBwhByAKIQIgEyEDICRBBEcNLwtBMiEDQeWRyAAhAkESIQZBiCQhB0GDgICAeCEFDC4LAn4CQCADIEcgSCBHIEhUG6ciAmtBCE8EQCACIAdqKQAAIU1BBCECQgAhSwwBC0IAIU0gSSFLIAohAiBIIExCBFINARoLIEdCCHwLIVAgAkH/AXFBBEcEQCBLQgiIpyEGIEtCGIinIQMgS6chBwwuCwJAAkAgAyBQIEggSCBQVhunIgJrQQhPBEAgAiAHaikAACFHQQQhAkIAIUsMAQtCACFHIEkhSyAKIQIgTEIEUg0BCyBQQgh8IUgLIAQgSDcDkAYgAkH/AXFBBEYNBSBLQgiIpyEGIEtCGIinIQMgS6chBwwtCyAaQf//A3FBB0YNBUGDgICAeCEFQfyUyAAhAkEuIQNBiiQhB0ESIQYMLAsgAkHVqAFHDRsgGkH//wNxIgdFBEBBgICAgHghBUEhIQNB/JDIACECQYgkIgdBCHYhBgwsCyApQQRqKAIAIRQgBAJ+AkAgSyBIIEggS1YbpyICIANHBEAgAiAUai0AACELQQQhAkIAIUYMAQtBACELIEkhRiAKIQIgSCBMQgRSDQEaCyBLQgF8CyJHNwOQBiACQf8BcUEERw0ZIAdBBUcNFgwXCyAEQbAGaiAEQZAGaiAaENoCIAQoArwGIQMgBCgCuAYhCyAEKAK0BiEUIAQoArAGRQ0FDBQLIARBAToAgwMgBAJ+AkACQAJAAkACQAJAIBpB//8DcSILQRdNBEBBACEFIAQpA6gCQv////8PUQ0BIEshSgwECwJ+AkAgAyBLIEggSCBLVhunIgVrQQhPBEBBBCECIClBBGooAgAgBWopAAAhSkIAIUYMAQtCACFKIEkhRiAKIQIgSCBMQgRSDQEaCyBLQgh8CyFLIAJB/wFxQQRHDQEgBCBKNwOoAiADIEsgSCBIIEtWG6ciBWtBCEkNBEEEIQIgKUEEaigCACAFaikAACFHQgAhRgwFCyAEAn4CQCADIEsgSCBIIEtWG6ciBWtBCE8EQEEEIQIgKUEEaigCACAFaikAACFHQgAhRgwBC0IAIUcgSSFGIAohAiBIIExCBFINARoLIEtCCHwLIko3A5AGIAJB/wFxQQRGDQELIAKtQv8BgyBGQgiGhKchDSBGQhiIpyEDQYGAgIB4IQUCQAJ/AkACQCACQf8BcUEBaw4DAAEBAwsgRqcMAQsgAy0ACAtB/wFxQSVHDQAgDUH/AXFBgICAgHghBUHAk8gAIQ1BA0YEQCADKAIAIQcgA0EEaigCACIGKAIAIgIEQCAHIAIRAwALIAYoAgQiAgRAIAcgAiAGKAIIEKIHCyADQQxBBBCiBwtBwJPIACECQRshAwsgDUEQdiEGIA1BCHYhBwwuCyAEIEc3A6gCQQghBQsgBCkDoAJC/////w9RBEACfgJAIAMgSiBIIEggSlYbpyIHa0EITwRAQQQhAiApQQRqKAIAIAdqKQAAIUdCACFGDAELQgAhRyBJIUYgCiECIEggTEIEUg0BGgsgSkIIfAshSiACQf8BcUEERw0WIAQgRzcDoAIgBUEIaiEFIAQpA7ACQv////8PUg0VDBQLIAQpA7ACQv////8PUQ0TDBQLQgAhRyBJIUYgCiECIEggTEIEUg0BGgsgS0IIfAsiSjcDkAYgAkH/AXFBBEcNEiAEIEc3A6ACQRAhBQwQCyAEIEg3A5AGICUhBiAcIQcgCiECIBMhAyAkQQRHDSgMFwsgBCgC4AIiAiAEKALYAkYEQCA9QYiUyAAQ+wULIAQoAtwCIAJBBXRqIgMgRzcCGCADIE03AhAgAyBGQiCIPgIMIAMgRj4CCCADQQA2AgAgBCACQQFqNgLgAgwYCwJ+AkAgAyBLIEggSCBLVhunIgVrQQJPBEBBBCECIClBBGooAgAgBWovAAAhB0IAIUYMAQtBACEHIEkhRiAKIQIgSCBMQgRSDQEaCyBLQgJ8CyFHIAJB/wFxQQRHBEAgRkIYiKchAyBGpyEHIEZCCIinDCYLAn4CQCADIEcgSCBHIEhUG6ciBWtBAk8EQEEEIQIgKUEEaigCACAFai8AAEHBigFGIRpCACFGDAELQQAhGiBJIUYgCiECIEggTEIEUg0BGgsgR0ICfAshRyACQf8BcUEERwRAIEZCGIinIQMgRqchByBGQgiIpwwmCwJ+AkAgRyBIIEcgSFQbpyIFIANHBEBBBCECIClBBGooAgAgBWotAABBAWshFEIAIUYMAQtB/wEhFCBJIUYgCiECIEggTEIEUg0BGgsgR0IBfAshSwJAAkACQCACQf8BcSIFQQRHBEAgRkIYiKchAwJ/AkACQCAFQQFrDgMAAQQFCyBGpwwBCyADLQAIC0H/AXFBJUcNAgwQCwJAAkAgAyBLIEggSCBLVhunIgNrQQJPBEBBBCECIClBBGooAgAgA2ovAAAhA0IAIUcMAQtBACEDIEkhRyAKIQIgTEIEUg0BCyBLQgJ8IUgLIAQgSDcDkAYgAkH/AXFBBEYNAiBHQhiIpyEDIEenIQcgR0IIiKcMKAsgAy0ACEElRg0NCyBGpyEHIEZCCIinDCYLQYCAgIB4IQUgGkUEQEHqlMgAIQJBEiEDQYokIQdBEiEGDCcLIAdBAWtB//8DcUEBSwRAQdCUyAAhAkEaIQNBiiQhB0ESIQYMJwsgFEH/AXFBAk0NBUGxlMgAIQJBHyEDQYokIQdBEiEGDCYLIARBsAZqIgIgBEGQBmogGhDaAiAEKAK8BiEDIAQoArgGIQsgBCgCtAYhFCAEKAKwBg0PIAQoApwCIRggBCgCmAIhByAEQQA2ArgGIARCADcDsAYgAiAHIBgQ3gEgBCgCuAYgA0cEQCALBEAgFCALQQEQogcLQYCAgIB4IQVBsJDIACECQSwhAwwICyAEIAs2AqgGIAQgFDYCpAYgBCALNgKgBiAEQbAGaiAUIAsQ+wIgBCgCsAZFBEAgBCkDoAYhSAwKC0GAgICAeCEFIAQpAqQGIUggC0GAgICAeEYEQCAEKAK0BiELDAoLQYCcyAAhAkENIQMgC0UNCCBIpyALQQEQogcMCAsgBCgClAIhBSAEKAKQAiECIARBADYCuAYgBEIANwOwBiAEQbAGaiACIAUQ3gEgBCgCuAYgA0cEQEGAgICAeCEFQbCQyAAhAkEsIQMgC0UNByAUIAtBARCiBwwHCyAFBEAgAiAFQQEQogcLIAQgFDYCkAIgBCALNgKUAiALQQBIDQQCQCALRQRAQQEhBQwBCyALEHEiBUUNMAsgCwRAIAUgFCAL/AoAAAsgBCALNgKoBiAEIAU2AqQGIAQgCzYCoAYgBEGwBmogBSALEPsCAkACQCAEKAKwBkUEQCAEKQOgBiJGQiCIpyECIAsgRqciBUkNASACIQMMAgtBgICAgHghBUGAnMgAIQJBDSEDIAtFDQkgBCkCpAanIAtBARCiBwwJCyALRQRAQQEhAyACIAVBARCiBwwBCyACIAVBASALELsCIgNFDTALIAQoAowCIgIEQCAEKAKIAiACQQEQogcLIARBAToAgQMgBCALNgKMAiAEIAM2AogCDBULIAMtAAhBJUYNBAsgRkIIiKcMIQsgAygCACEUIANBBGooAgAiBSgCACICBEAgFCACEQMACyAFKAIEIgcEQCAUQQRrKAIAIgJBeHEiBUEEQQggAkEDcSICGyAHakkNOSACQQAgBSAHQSdqSxsNOCAUEKICCyADQQRrKAIAIgJBeHEiBUEQQRQgAkEDcSICG0kNOCACQQAgBUE0TxsNNyADEKICDBILIAQgSjcD0AIgBCADOwHmAiAEQQFBAiADQf//A3EiAkEIRhtBACACGyICOwHkAiAEIAetQv//A4MgAq1CIIYgA61CMIaEhCAUrUL/AYNCEIaEQoCABHw3A4ACDBELQdiayAAQ/wcACyADKAIAIQUgA0EEaigCACIGKAIAIgIEQCAFIAIRAwALIAYoAgQiAgRAIAUgAiAGKAIIEKIHCyADQQxBBBCiBwwbC0GIJCEHQRIhBgwdC0GOJCEHQRIhBgwcCyBIQiCIpyEFAkACQCALIEinIhRPDQAgC0UEQCAFQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyAUakkNNSACQQAgAyAUQSdqSxsNAiAFEKICQQEhBQwBCyAFIBRBASALELsCIgVFDSgLIBgEQCAHIBhBARCiBwsgBCALNgKcAiAEIAU2ApgCDA0LDDELIAMoAgAhBSADQQRqKAIAIgYoAgAiAgRAIAUgAhEDAAsgBigCBCICBEAgBSACIAYoAggQogcLIANBDEEEEKIHC0GAgICAeCEFQZiUyAAhAkEZIQNBiiQhB0ESIQYMGQsCfgJAIAMgSiBIIEggSlYbpyIHa0EITwRAQQQhAiApQQRqKAIAIAdqKQAAIUdCACFGDAELQgAhRyBJIUYgCiECIEggTEIEUg0BGgsgSkIIfAshSiACQf8BcSIHQQRHBEAgAq1C/wGDIEZCCIaEpyENIEZCGIinIQNBgYCAgHghBQJAAn8CQAJAIAdBAWsOAwABAQMLIEanDAELIAMtAAgLQf8BcUElRw0AIA1B/wFxQYCAgIB4IQVBwJPIACENQQNGBEAgAygCACEHIANBBGooAgAiBigCACICBEAgByACEQMACyAGKAIEIgIEQCAHIAIgBigCCBCiBwsgA0EMQQQQogcLQcCTyAAhAkEbIQMLIA1BEHYhBiANQQh2IQcMGQsgBCBHNwOwAiAFQQhqIQULIAUgC0sEQEGAgICAeCEFQduTyAAhAkEqIQNBiSQhB0ESIQYMGAsgCyAFayEYQQEhESAFIAtGIgdFBEAgGBBxIhFFDSMgEUEEay0AAEEDcUUgGEVyRQRAIBFBACAY/AsACyAUKAIAIgOtIUgLAkACQCADIEogSCBIIEpWG6ciAmsgGE8EQCApQQRqKAIAIAJqIQIgGEEBRwRAIBgEQCARIAIgGPwKAAALQQQhAgwCCyARIAItAAA6AABBBCECDAELIBMhDyAKIQIgNCEOIExCBFINAQsgSiAYrXwhSAsgBCBINwOQBgJAAn8CQCACQf8BcSIDQQRHBEACfwJAAkAgA0EBaw4DAAEBBAsgDgwBCyAPLQAIC0H/AXFBJUcNASACQf8BcUEDRgRAIA8oAgAhBSAPQQRqKAIAIgMoAgAiAgRAIAUgAhEDAAsgAygCBCIGBEAgBUEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgBmpJDTQgAkEAIAMgBkEnaksbDTMgBRCiAgsgD0EEaygCACICQXhxIgNBEEEUIAJBA3EiAhtJDTMgAkEAIANBNE8bDTIgDxCiAgtBgICAgHghBUEbIQ9BwJPIACECQYkkIQ5BEgwCC0EBIR0gBw0CIBFBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIBhqSQ0xIAJBACADIBhBJ2pLGw0wIBEQogIMAgtBgYCAgHghBSAOQf///wdxQQh2CyEGIAdFBEAgESAYQQEQogcLIA8hAyAOIQcMGAsgSCFKIEghRwwPCyACrUL/AYMgRkIIhoSnIQ0gRkIYiKchA0GBgICAeCEFAkACfwJAAkAgAkH/AXFBAWsOAwABAQMLIEanDAELIAMtAAgLQf8BcUElRw0AIA1B/wFxQYCAgIB4IQVBwJPIACENQQNGBEAgAygCACEHIANBBGooAgAiBigCACICBEAgByACEQMACyAGKAIEIgIEQCAHIAIgBigCCBCiBwsgA0EMQQQQogcLQcCTyAAhAkEbIQMLIA1BEHYhBiANQQh2IQcMFgsgFEGGgICAeEcEQCALQRB2IQYgC0EIdiEHIAshAiAUIQUMFgsgBCkDkAYiRyALQQFxRQ0HGiBHIUpBASEdDA0LIAtB/wFxaUECdEEBciAHRwRAQYOAgIB4IQVBNSEDQbCRyAAhAkGIJCIHQQh2IQYMFQsgC0EBcQ0AQQAhHyAHQQFrDAELIAQCfgJAIAMgRyBIIEcgSFQbpyICa0EETwRAIAIgFGooAAAhEUEEIQJCACFGDAELQQAhESBJIUYgCiECIEggTEIEUg0BGgsgR0IEfAsiRzcDkAYgAkH/AXFBBEcNAUEBIR8gB0EFawshBUEAIRogB0EGSSIHIAtBAnFFckUEQCAEAn4CQCADIEcgSCBHIEhUG6ciAmtBBE8EQCACIBRqKAAAIQlBBCECQgAhRgwBC0EAIQkgSSFGIAohAiBIIExCBFINARoLIEdCBHwLIkc3A5AGIAJB/wFxQQRHDQFBASEaIAVBBGshBQtCACFGAkAgByALQQRxRXJFBEAgBAJ+AkAgAyBHIEggRyBIVBunIgJrQQRPBEAgAiAUajUAAEIghiFNQQQhAgwBC0IAIU0gSSFGIAohAiBIIExCBFINARoLIEdCBHwLIkc3A5AGIAJB/wFxQQRHDQIgBUEEayEFQgEhRgwBC0IAIU0LAkAgBUUNACAFQQBOBEAgBCBHIAWtfCJLIEsgSCBMQgRRGyAFIAMgRyBIIEcgSFQbp2tNIgIbNwOQBiACICRBBEZyDQFBgYCAgHghBSAKIQIgEyEDIBwiB0EIdiEGDBQLQaCRyAAQ/wcACyAEKALgAiICIAQoAtgCRgRAID1BrJXIABD7BQsgBCgC3AIgAkEFdGoiAyBGIE2ENwIUIAMgCTYCECADIBo2AgwgAyARNgIIIAMgHzYCBCADQQE2AgAgBCACQQFqNgLgAgwDCyBGQhiIpyEDQYGAgIB4IQUgRqciB0EIdiEGDBELQTEhA0GXksgAIQJBEiEGQYkkIQdBg4CAgHghBQwQCwJAIBpB//8DcSIRRQRAQQEhHwwBCyAREHEiH0UNGyAfQQRrLQAAQQNxRSARRXJFBEAgH0EAIBH8CwALIBQoAgAiA60hSAsCQAJAAkAgESADIEsgSCBIIEtWG6ciAmtNBEAgKUEEaigCACACaiECIBFBAUcEQCARRQ0CIB8gAiAR/AoAAAwCCyAfIAItAAA6AAAMAQsgSSFHIAohAiBMQgRSDQIMAQtBBCECQgAhRwsgSyAarUL//wODfCFICyAEIEg3A5AGAkACQCACQf8BcSIFQQRHBEAgR0IYiKchAwJ/AkACQCAFQQFrDgMAAQQFCyBHpwwBCyADLQAIC0H/AXFBJUcNAgwICyARRQ0CIB9BBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIBFqSQ0oIAJBACADIBFBJ2pLGw0nIB8QogIMAgsgAy0ACEElRg0FCyBHpyEHQYGAgIB4IQUgR0IIiKcMBgsgBCkDkAYLIkYgSn0iR6ciC0EATgRAAkAgC0UEQEEBIQMMAQsgCxBxIgNFDRogA0EEay0AAEEDcUUgC0VyDQAgA0EAIAv8CwALIAQoAoQGIA0iAmsgC0kEQCAEQYQGaiACIAsQ7wUgBCgCiAYhKyAEKAKMBiECCyALRSIURQRAIAIgK2ogAyAL/AoAAAsgBCACIAtqIgI2AowGIAsEQCADQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyALakkNJiAFQQAgByALQSdqSxsNJSADEKICCyALIA1qIgMgAksNASAEKAKYBiIFQQhqKAIAIgetIUgCQAJAIAsgB0L/////DyBKIEpC/////w9aG6drIgNBACADIAdNG00EQCAFQQRqKAIAIEogSCBIIEpWG6dqIQUgDSAraiEDIAtBAUcEQCAURQRAIAMgBSAL/AoAAAtBBCEFDAILIAMgBS0AADoAAEEEIQUMAQsgCiEFIExCBFINAQsgR0L/////B4MgSnwhSAsgBCBINwOQBiAFQf8BcSINQQRGBEAgRiFKIAIhDSBIIUcMBwsgSUIYiKchAyBJpyICIQYCQAJAAkACQCANQQFrDgMBAAIDCyADLQAIIQYLIAZB/wFxQSVHDQEMBAsgAy0ACEElRw0AIAMoAgAhBSADQQRqKAIAIgYoAgAiAgRAIAUgAhEDAAsgBigCBCICBEAgBSACIAYoAggQogcLIANBDEEEEKIHDAMLQYGAgIB4IQUgAkEIdCANcgwPC0H0ksgAEP8HAAsgDSADIAJBsJPIABDqBwALQSshA0GAgICAeCEFQYSTyAAMDAsgAygCACEFIANBBGooAgAiBigCACICBEAgBSACEQMACyAGKAIEIgIEQCAFIAIgBigCCBCiBwsgA0EMQQQQogcLQYCAgIB4IQVBHSEDQbyVyAAhAkGKJCEHQRILIQYgEUUNCCAfIBFBARCiBwwICyBKIFRUDQALAkAgHUUEQCAEKAKEBiINRQ0CIAQoAogGIgVBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIA1qSQ0fIAJBACADIA1BJ2pLGw0BIAUQogIMAgtBFBBxIgNFDRIgAyAEKQKEBjcCCCADQoGAgIAQNwIAIANBEGogBEGMBmooAgA2AgACQCAvKAIAIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIC8oAgAQ3QULIC8gAzYCAAwBCwwcC0EBIQUgFkECRw0ACwwGC0HYmsgAEP8HAAtBgICAgHghBUHZlcgAIQJBHCEDQYokIQdBEiEGDAILIEZCCIinCyEGQYGAgIB4IQULIAJB/wFxIAdB/wFxQQh0ciAGQRB0cgshFgJAIAQoAoQGIgcEQCAEKAKIBiINQQRrKAIAIgJBeHEiBkEEQQggAkEDcSICGyAHakkNFyACQQAgBiAHQSdqSxsNASANEKICCwJAIAQoAuwFIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAQoAuwFEN0FCyAEKALoBSICRQ0JIAIgAigCACICQQFrNgIAIAJBAUcNCSAEKALoBRDdBQwJCwwUCyAEKALoBSEDAkAgBCgC7AIiAkUNACACIAIoAgAiAkEBazYCACACQQFHDQAgBCgC7AIQ3QULIAQgAzYC7AIgBCgC7AUhAwJAIAQoAvACIgJFDQAgAiACKAIAIgJBAWs2AgAgAkEBRw0AIAQoAvACEN0FCyAEIAM2AvACQYCAgIB4IQUCQCAELwHkAkECRw0AIAQvAeYCQeMARw0AIAQvAYACDQBBKyEDQZGMwQAhFgwICyAEKQOwAiJHIFF8IkYgR1QEQEEbIQNBvIzBACEWDAgLIAQgRjcDsAIgBCkD4AEhRiAEKALoASEFIAQoAuwBIRYgBCgC8AEhAyAEQdAEaiBFQZQB/AoAAAJAICBFICNFcg0AAkAgJkEEaygCACICQXhxIg1BBEEIIAJBA3EiAhsgI2pPBEAgAkEAIA0gI0EnaksbDQEgJhCiAgwCCwwWCwwUCyAbBEAgEkEEaygCACICQXhxIg1BBEEIIAJBA3EiAhsgG2pJDRUgAkEAIA0gG0EnaksbDQMgEhCiAgsgRkICUQ0KIARBuANqIARB0ARqQZQB/AoAACAEKAKsAyAIRgRAIwBBIGsiDiQAAkAgBEGsA2oiDygCACIHQZiMhgNLBH9BAAVBBCAHQQF0IgIgAkEETRsiDUGoAWwhAiAOIAcEfyAOIAdBqAFsNgIcIA4gDygCBDYCFEEIBUEACzYCGCAOQQhqQQggAiAOQRRqEIUHIA4oAghBAUcNASAOKAIQIQ8gDigCDAsgD0HojMEAEJMJAAsgDigCDCECIA8gDTYCACAPIAI2AgQgDkEgaiQAIAQoArADISoLICogCEGoAWxqIgIgFq0gA61CIIaENwIMIAIgBTYCCCACIEY3AwAgAkEUaiAEQbgDakGUAfwKAAAgBCAVNgK0AyAVIgggBkcNAAsLIARB2AFqIARBtANqKAIANgIAIAQgUTcCpAEgBEHEAWogBEGoAWooAgA2AgAgBCAEKQKsAzcD0AEgBCAnNgK4ASAEQgA3A7ABIAQgTzcDyAEgBCAEKQOgATcCvAEgBEFAayEYIBkhEEEAIR0jAEHQA2siCSQAIARBsAFqIhQoAighBkHIu8kAAn5BwLvJAC0AAARAQdC7yQApAwAhRkHIu8kAKQMADAELIAlBOGoQvwZBwLvJAEEBOgAAQdC7yQAgCSkDQCJGNwMAIAkpAzgLIklCAXw3AwACQCAGRQRAIAlCgICAgIABNwMYIAkgRjcDECAJIEk3AwggCUEANgIgIAlB8JrIAP0AAwD9CwIkIBQoAiQhDyAUKAIgISYMAQsCQCAGQQ9PBH9BfyAGQQN0QQduQQFrZ3ZBAWoFQQQgBkEIcUEIaiAGQQRJGwsiHEECdEEHakH4////B3EiAyAcQQhqIghqEHEiAkUNACACIANqIQogCARAIApB/wEgCPwLAAsgBkHDrMgFSQRAIAZBuAFsEHEiAkUNASAJQQA2AjAgCSAcQQFrIgMgHEEDdkEHbCADQQhJGzYCLCAJIAM2AiggCSAKNgIkIAlBADYCICAJIAI2AhwgCSBGNwMQIAkgSTcDCCAJIAY2AhggFCgCJCIPIAZBqAFsaiE4IAlBsANqIREgFCgCICEmIAlBGGohBSAJQSRqIRwgDyEDA0AgCUE4aiADQagB/AoAACAJQeACaiIjIANBCGr9AAMA/QsDACAJQfACaiIWIANBGGr9AAMA/QsDACAJIAMpAwA3A9gCIAMoAighFSADKAIsIRkgCUHgAWogA0EwakH4APwKAAAgGUEATgRAAkAgGUUEQEEBISEMAQsgGRBxIiFFDQQLIBkEQCAhIBUgGfwKAAALIAkpAwghRiAJKQMQIUkgEf0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgCSBJNwOoAyAJIEY3A6ADIAkgSULzytHLp4zZsvQAhTcDmAMgCSBJQu3ekfOWzNy35ACFNwOQAyAJIEZC4eSV89bs2bzsAIU3A4gDIAkgRkL1ys2D16zbt/MAhTcDgAMgCUGAA2oiAiAhIBkQggMgCUH/AToAxAMgAiAJQcQDakEBEIIDIAkpA7ADIAk1ArgDQjiGhCJIIAkpA5gDhSJJQhCJIEkgCSkDiAN8Ik6FIkZCFYkgRiAJKQOQAyJHIAkpA4ADfCJJQiCJfCJKhSJGQhCJIEYgTiBHQg2JIEmFIkd8IklCIIlC/wGFfCJOhSJGQhWJIEYgSSBHQhGJhSJHIEggSoV8IklCIIl8IkqFIkZCEIkgRiBJIEdCDYmFIkcgTnwiSUIgiXwiToUiRkIViSBGIEkgR0IRiYUiRyBKfCJJQiCJfCJKhSJGQhCJIEYgR0INiSBJhSJHIE58IklCIIl8IkaFQhWJIEdCEYkgSYUiSUINiSBJIEp8hSJJQhGJhSBGIEl8IklCIIiFIEmFpyEoIAkoAiAhDSAJKAIcIRMgCSgCLEUEQAJAQQAhFyMAQSBrIiAkAAJAAkACQAJAAkACQAJAAn8CQCAcKAIMIiVBAWoiCgRAIBwoAgQiLCAsQQFqIgtBA3YiAkEHbCAsQQhJGyIeQQF2IApJBEAgHkEBaiICIAogAiAKSxsiAkEPSQ0CIAJB/////wFNBEBBfyACQQN0QQduQQFrZ3YiAkH9////A0sNBSACQQFqDAQLDAoLIAsEQCAcKAIAIQ4CQAJAIAIgC0EHcUEAR2oiB0ECSQRAIAchCgwBCyAHQQFxIQogB0H+////A3EiBkEDdCEXIAYhCCAOIQIDQCACIAL9AAMAIln9TUEH/c0B/QwBAQEBAQEBAQEBAQEBAQEB/U4gWf0Mf39/f39/f39/f39/f39/f/1Q/c4B/QsDACACQRBqIQIgCEECayIIDQALIAYgB0YNAQsgDiAXaiECA0AgAiACKQMAIklCf4VCB4hCgYKEiJCgwIABgyBJQv/+/fv379+//wCEfDcDACACQQhqIQIgCkEBayIKDQALCyAOQQhqITQCQCALQQhPBEAgCyAOaiAOKQAANwAADAELIAtFDQAgNCAOIAv8CgAACyAOQQRrITBBASEIQQAhAgNAIAIhCiAIIQICQCAKIA5qIi4tAABBgAFHDQACQAJAIA0gMCAKQQJ0IgZrIgcoAgAiCEsEQCAOIAZrQQRrIRIDQCATIAhBuAFsaigCsAEiMiAscSIGIRcgBiAOaikAAEKAgYKEiJCgwIB/gyJGUARAQQghGwNAIBcgG2ohCCAbQQhqIRsgDiAIICxxIhdqKQAAQoCBgoSIkKDAgH+DIkZQDQALCyAOIEZ6p0EDdiAXaiAscSIXaiwAAEEATgRAIA4pAwBCgIGChIiQoMCAf4N6p0EDdiEXCyAXIAZrIAogBmtzICxxQQhJDQIgDiAXaiIILQAAIAggMkEZdiIIOgAAIDQgF0EIayAscWogCDoAACAOIBdBAnRrQQRrIRdB/wFGDQMgEigAACEIIBIgFygAADYAACAXIAg2AAAgBygCACIIIA1JDQALCyAIIA1B0JvIABCMBwALIC4gMkEZdiIIOgAAIDQgCkEIayAscWogCDoAAAwBCyAuQf8BOgAAIDQgCkEIayAscWpB/wE6AAAgFyASKAAANgAACyACIAIgC0kiCmohCCAKDQALCyAcIB4gJWs2AggMBQsMCAtBBCACQQhxQQhqIAJBBEkbCyIuQQJ0QQdqQXhxIgggLkEIaiIKaiICIAhJIAJB+P///wdLcg0AIAIQcSICRQ0BIAIgCGohEiAKBEAgEkH/ASAK/AsACyAuQQFrIR4gHCgCACEGICUEQCASQQhqITIgBkEEayEwIAYpAwBCf4VCgIGChIiQoMCAf4MhRiAGIQpBACECICUhFwNAIEZQBEADQCACQQhqIQIgCkEIaiIKKQMAQoCBgoSIkKDAgH+DIklCgIGChIiQoMCAf1ENAAsgSUKAgYKEiJCgwIB/hSFGCyAwIEZ6p0EDdiACakECdCIOaygCACIIIA1PDQUgEiATIAhBuAFsaigCsAEiByAecSIIaikAAEKAgYKEiJCgwIB/gyJJUARAQQghGwNAIAggG2ohCCAbQQhqIRsgEiAIIB5xIghqKQAAQoCBgoSIkKDAgH+DIklQDQALCyBGQgF9IEaDIUYgEiBJeqdBA3YgCGogHnEiCGosAABBAE4EQCASKQMAQoCBgoSIkKDAgH+DeqdBA3YhCAsgCCASaiAHQRl2Igc6AAAgMiAIQQhrIB5xaiAHOgAAIBIgCEECdGtBBGsgBiAOa0EEaygAADYAACAXQQFrIhcNAAsLIBwgHjYCBCAcIBI2AgAgHCAeIC5BA3ZBB2wgHkEISRsgJWs2AgggLEUNAiAGIAtBAnRBB2pBeHEiCmsiBkEEaygCACICQXhxIgggCiAsakEJaiIKQQRBCCACQQNxIgIbakkNBCACQQAgCCAKQSdqSxsNBSAGEKICDAILICBBADYCGCAgQQE2AgwgIEHEtcQANgIIICBCBDcCECAgQQhqQcy1xAAQjQgLAAsgIEEgaiQADAQLIAggDUHQm8gAEIwHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALICBBADYCGCAgQQE2AgwgIEHEtcQANgIIICBCBDcCECAgQQhqQcy1xAAQjQgACwsgA0GoAWohAyAJKAIkIhdBBGshCCAJKAIoIg4gKHEhJyAoQRl2IgetQoGChIiQoMCAAX4hRkEAIS5BACEGA0ACQAJAAkACQAJAAkACQAJAAkAgFyAnaikAACJHIEaFIklCf4UgSUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyJJUEUEQANAIAggSXqnQQN2ICdqIA5xQQJ0aygCACIlIA1PDQMgEyAlQbgBbCIKaiICQawBaigCACAZRgRAICEgAkGoAWooAgAgGRDbB0UNAwsgSUIBfSBJgyJJUEUNAAsLIEdCgIGChIiQoMCAf4MhSSAuRQRAIElQDQMgSXqnQQN2ICdqIA5xIR0LIEkgR0IBhoNQBEBBASEuDAkLIBcgHWosAAAiJ0EATgRAIBcgFykDAEKAgYKEiJCgwIB/g3qnQQN2Ih1qLQAAIScLIBcgHWogBzoAACAXIB1BCGsgDnFqQQhqIAc6AAAgFyAdQQJ0a0EEayAJKAIgIhM2AgAgCSAJKAIwQQFqIgo2AjAgCSAJKAIsICdBAXFrIgI2AiwgEyAJKAIYIgZHDQZBwqzIBSACIApqIicgJ0HCrMgFTxsiBiATa0EBTSATICdLcg0EQQAhJyATBEAgCSAJKAIcNgKAAyAJIBNBuAFsNgKIA0EIIScLIAkgJzYChAMgCUHEA2pBCCAGQbgBbCAJQYADahCFByAJKALEA0EBRg0EDAULICUgCSgCICICTw0CIAkoAhwgCmoiAikDACACIAkpA9gCNwMAIAJBCGogI/0AAwD9CwMAIAJBGGogFv0AAwD9CwMAIAIoApABITAgAigCjAEhFyACKAJ8IQcgAigCeCENIAIoAjwhHSACKAI4IRMgAigCNCEOIAIoAjAhBiACKAIsISUgAigCKCEIIAIgGTYCLCACIBU2AiggAkEwaiAJQeABakH4APwKAAAgGQRAICFBBGsoAgAiAkF4cSIKQQRBCCACQQNxIgIbIBlqSQ0hIAJBACAKIBlBJ2pLGw0gICEQogILQgJRDQYgJQRAIAhBBGsoAgAiAkF4cSIKQQRBCCACQQNxIgIbICVqSQ0hIAJBACAKICVBJ2pLGw0gIAgQogILIA4EQCAGQQRrKAIAIgJBeHEiCkEEQQggAkEDcSICGyAOakkNISACQQAgCiAOQSdqSxsNICAGEKICCwJAIBdFDQAgFyAXKAIAIgJBAWs2AgAgAkEBRw0AIBcQ3QULAkAgMEUNACAwIDAoAgAiAkEBazYCACACQQFHDQAgMBDdBQsgHQRAIBNBBGsoAgAiAkF4cSIKQQRBCCACQQNxIgIbIB1qSQ0hIAJBACAKIB1BJ2pLGw0gIBMQogILIA1FDQYgB0EEaygCACICQXhxIgggDUEFdCIKQQRBCCACQQNxIgIbckkNICACQQAgCCAKQSdqSxsNHyAHEKICDAYLICUgDUGQm8gAEIwHAAtBACEuDAULICUgAkGwm8gAEIwHAAsgE0HBrMgFTQR/IBNBAWoiBkG4AWwhAiAJIBMEfyAJIAkoAhw2AoADIAkgE0G4AWw2AogDQQgFQQALNgKEAyAJQcQDakEIIAIgCUGAA2oQhQcgCSgCxANBAUcNASAJKALMAyEnIAkoAsgDBUEACyAnQcCbyAAQkwkACyAJKALIAyECIAkgBjYCGCAJIAI2AhwLIAYgE0YEQCMAQSBrIgYkAAJAIAUoAgAiCEGhluQCSwR/QQAFQQQgCEEBdCICIAJBBE0bIgpBuAFsIQIgBiAIBH8gBiAIQbgBbDYCHCAGIAUoAgQ2AhRBCAVBAAs2AhggBkEIakEIIAIgBkEUahCFByAGKAIIQQFHDQEgBigCECEFIAYoAgwLIAVBoJvIABCTCQALIAYoAgwhAiAFIAo2AgAgBSACNgIEIAZBIGokAAsgCSgCHCATQbgBbGoiAiAJQThqQagB/AoAACACICg2ArABIAIgGTYCrAEgAiAhNgKoASAJIBNBAWo2AiALIAMgOEcNAwwGCyAGQQhqIgYgJ2ogDnEhJwwACwALC0GE7sEAEP8HAAtBgJvIABD/BwALAAsCQCAmBEAgD0EEaygCACICQXhxIgogJkGoAWwiA0EEQQggAkEDcSICG2pJDRQgAkEAIAogA0EnaksbDRMgDxCiAgsgGCAJ/QADCP0LAxAgGCA1NgJcIBggMzYCWCAYIAw2AkQgGCAQNgJAIBggFP0AAxD9CwNIIBggFP0AAwD9CwMAIBhBMGogCUEoav0AAwD9CwMAIBhBIGogCUEYav0AAwD9CwMAIAlB0ANqJAAMAAsCQCAtQYaAgIB4Rg0AAkACQEEBIC1B/////wdqIC1BgICAgHhNGw4CAAECCyA2Qf8BcUEDRw0BIDEoAgAhCiAxQQRqKAIAIgMoAgAiAgRAIAogAhEDAAsgAygCBCICBEAgCiACIAMoAggQogcLIDFBDEEEEKIHDAELIC1BgICAgHhyQYCAgIB4Rg0AIDZB/wFxIDtBCHRyIC1BARCiBwsgBCkDQCJJQgNRDQ8gBEE4aiIKIARB0ABqKAIANgIAIAQgBCkDSDcDMCAEQeABaiIDIARB1ABqQcwA/AoAACAEQdgEaiICIAooAgA2AgAgBCAEKQMwNwPQBEHoABBxIgpFDQYgCiBJNwMIIApCgYCAgBA3AwAgCiAEKQPQBDcDECAKQRhqIAIoAgA2AgAgCkEcaiADQcwA/AoAACAAIAo2AhAgACAB/QADAP0LAwAMEAsMEAtB2IzBABD/BwALQZONwQAhAyAEQZONwQA2AqABQYOAgIB4IQVBLyEIDAkLDA0LDA0LIARB4AFqEOoDICBFICNFckUEQCAmICNBARCiBwsgG0UNAiASIBtBARCiBwwCCwALIAMEQCAWIANBARCiBwsgIyEDICYhFgsgFq0gA61CIIaEDAILQeiNwQAhBkEgIQNBgICAgHghBQsgBCADNgLUBCAEIAY2AtAEIAZB////B3GtIAQzANMEQhiGhCADQQh2Qf//A3GtQiiGhCADQRh2rUI4hoQLIkY3A6ABIAQoArADIQIgCARAIAIhAwNAIAMQ6gMgA0GoAWohAyAIQQFrIggNAAsLAkAgBCgCrAMiCARAIAJBBGsoAgAiA0F4cSIGIAhBqAFsIghBBEEIIANBA3EiAxtqSQ0IIANBACAGIAhBJ2pLGw0BIAIQogILIEZCIIinIQggRqchAwwBCwwFCwJAAkAgLUGGgICAeEYNAAJAAkACQEEBIC1B/////wdqIC1BgICAgHhNGw4CAAEDCyA2Qf8BcUEDRw0CIDEoAgAhByAxQQRqKAIAIgYoAgAiAgRAIAcgAhEDAAsgBigCBCINBEAgB0EEaygCACICQXhxIgZBBEEIIAJBA3EiAhsgDWpJDQQgAkEAIAYgDUEnaksbDQkgBxCiAgsgMUEEaygCACICQXhxIgZBEEEUIAJBA3EiAhtJDQkgAkUgBkE0SXINAQwICyAtQYCAgIB4ckGAgICAeEYNASA2Qf8BcSA7QQh0ciIxQQRrKAIAIgJBeHEiBkEEQQggAkEDcSICGyAtakkNCCACRQ0AIAYgLUEnaksNBwsgMRCiAgsgDARAIBlBBGsoAgAiAkF4cSIGQQRBCCACQQNxIgIbIAxqSQ0HIAJBACAGIAxBJ2pLGw0GIBkQogILIANBCHYhOyAQIQ0gBSEnIAMhNiAIITEgBSEtIDNFIDVFcg0BIDNBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIDVqSQ0GIAJBACADIDVBJ2pLGw0FIDMQogIMAQsLDAQLAkAgLUGGgICAeEYEQCAMIS0gBSEDIAghMQwBCyA2Qf8BcSA7QQh0ciEDAkACQEEBIAxB/////wdqIAxBgICAgHhNGw4CAAECCyAFQf8BcUEDRw0BIAgoAgAhCiAIQQRqKAIAIgIoAgAiAQRAIAogAREDAAsgAigCBCIBBEAgCiABIAIoAggQogcLIAhBBGsoAgAiAUF4cSICQRBBFCABQQNxIgEbSQ0FIAFBACACQTRPGw0EIAgQogIMAQsgDEGAgICAeHJBgICAgHhGDQAgBSAMQQEQogcLIAQgMTYCUCAEIAM2AkwgBCAtNgJICyAEQThqIARB0ABqKAIAIgE2AgAgBCAEKQNIIkk3AzAgAEEMaiABNgIAIAAgSTcCBCAAQQA2AgALIARBwAZqJAAPC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAvpigECHH8HfSMAQSBrIh0kAAJAAkAgAUEhSQRAIAAhCCABIQcMAQsgAkEEayEhIAJBEGshIgNAIARFBEAgACABIAIgA0EBIAYQVAwDCyAAIAFBA3YiCEEcbGohDiAAIAhBBHRqIQ8CQCABQcAATwRAIAAgDyAOIAggBhDBASERIAYoAgAhHgwBC0MAAIA/ISQCfwJAIAAoAgAiCCAGKAIAIh5BBGooAgAiB0EIaigCACISSQRAIA8oAgAhCyAHQQRqKAIAIgkgCEEkbGoiChCKBCEjIAovARQiCEH//wFxIhBFBEAgCEEQdAwDCyAIQf8HcSEHIAhBgIACcSERIAhBgPgBcSINQYD4AUYEQCARQRB0IhFBgICA/AdyIAdFDQMaIBEgB0ENdHJBgICA/gdyDAMLIBFBEHQhESANRQ0BIA1BDXRBgICA/ABxIAdBDXRyQYCAgMADaiARcgwCCyAIIBJB1MDHABCMBwALIBFBgICA2ANyIAdnQRBrIhFBF3RrIAcgEUH//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhJAtDAACAPyElAn8CQCALIBJJBEAgCSALQSRsaiINEIoEISYgDS8BFCIHQf//AXEiFEUEQCAHQRB0DAMLIAdB/wdxIQsgB0GAgAJxIREgB0GA+AFxIgxBgPgBRgRAIBFBEHQiEUGAgID8B3IgC0UNAxogESALQQ10ckGAgID+B3IMAwsgEUEQdCERIAxFDQEgDEENdEGAgID8AHEgC0ENdHJBgICAwANqIBFyDAILIAsgEkHUwMcAEIwHAAsgEUGAgIDYA3IgC2dBEGsiEUEXdGsgCyARQf//A3FBCGp0Qf///wNxcgu+IidDAACAP14EQCAnEMYFQ1T4LUCUQwAAgD+SkSElCyAOKAIAIREgChCKBCEnQwAAgD8hKAJ/IAhBEHQgEEUNABogCEH/B3EhCyAIQYCAAnEhCiAIQYD4AXEiCEGA+AFGBEAgCkEQdCIIQYCAgPwHciALRQ0BGiAIIAtBDXRyQYCAgP4HcgwBCyAKQRB0IgogCEENdEGAgID8AHEgC0ENdHJBgICAwANqciAIDQAaIApBgICA2ANyIAtnQRBrIghBF3RrIAsgCEH//wNxQQhqdEH///8DcXILviIpQwAAgD9eBEAgKRDGBUNU+C1AlEMAAIA/kpEhKAsCfwJAIBEgEkkEQCAjICOSICSUIiMgJiAmkiAllGBFIQogIyAjWyEMIAkgEUEkbGoiCxCKBCEjIAsvARQiCEH//wFxIhBFBEAgCEEQdAwDCyAIQf8HcSESIAhBgIACcSERIAhBgPgBcSIJQYD4AUYEQCARQRB0IhFBgICA/AdyIBJFDQMaIBEgEkENdHJBgICA/gdyDAMLIBFBEHQhESAJRQ0BIAlBDXRBgICA/ABxIBJBDXRyQYCAgMADaiARcgwCCyARIBJB1MDHABCMBwALIBFBgICA2ANyIBJnQRBrIhFBF3RrIBIgEUH//wNxQQhqdEH///8DcXILQwAAgD8hJL4iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISQLIAogDHEiCSAnICeSICiUIiUgJVsgJSAjICOSICSUYEVxRwRAIAAhEQwBC0MAAIA/ISMgDiAPIAkgDRCKBCIkICSSAn8gB0EQdCAURQ0AGiAHQf8HcSESIAdBgIACcSERIAdBgPgBcSIHQYD4AUYEQCARQRB0IgdBgICA/AdyIBJFDQEaIAcgEkENdHJBgICA/gdyDAELIBFBEHQiESAHQQ10QYCAgPwAcSASQQ10ckGAgIDAA2pyIAcNABogEUGAgIDYA3IgEmdBEGsiB0EXdGsgEiAHQf//A3FBCGp0Qf///wNxcgu+IiVDAACAP14EfSAlEMYFQ1T4LUCUQwAAgD+SkQUgIwuUIiMgI1sgIyALEIoEIiQgJJICfyAIQRB0IBBFDQAaIAhB/wdxIQcgCEGAgAJxIRIgCEGA+AFxIghBgPgBRgRAIBJBEHQiCEGAgID8B3IgB0UNARogCCAHQQ10ckGAgID+B3IMAQsgEkEQdCISIAhBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCA0AGiASQYCAgNgDciAHZ0EQayIIQRd0ayAHIAhB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXFzGyERCyAEQQFrIQQgHSARKAIAIgs2AgQgESAAa0ECdiESAkACQAJAIAUEQEMAAIA/ISMCfwJAIAUoAgAiCCAeQQRqKAIAIgdBCGooAgAiDkkEQCAHQQRqKAIAIgkgCEEkbGoiCBCKBCElIAgvARQiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCCAHQYCAAnEhDyAHQYD4AXEiB0GA+AFGBEAgD0EQdCIHQYCAgPwHciAIRQ0DGiAHIAhBDXRyQYCAgP4HcgwDCyAPQRB0IQ8gB0UNASAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogD3IMAgsgCCAOQdTAxwAQjAcACyAPQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJEMAAIA/XgRAICQQxgVDVPgtQJRDAACAP5KRISMLQwAAgD8hJAJ/AkAgCyAOSQRAIAkgC0EkbGoiCBCKBCEmIAgvARQiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCCAHQYCAAnEhCyAHQYD4AXEiB0GA+AFGBEAgC0EQdCIHQYCAgPwHciAIRQ0DGiAHIAhBDXRyQYCAgP4HcgwDCyALQRB0IQsgB0UNASAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogC3IMAgsgCyAOQdTAxwAQjAcACyALQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJ0MAAIA/XgRAICcQxgVDVPgtQJRDAACAP5KRISQLICUgJZIgI5QiIyAjXCAjICYgJpIgJJRgcg0BCyABIANLDQEgAiABQQJ0IhhqIQ9BACEHIAAhDiASIQsDQCAAIAtBA2siCEEAIAggC00bQQJ0aiIcIA5LBEAgESgCACENIB5BBGoiHygCACIbIQgDQAJ/AkAgDigCACIUIBtBCGooAgAiCUkEQCAbQQRqKAIAIBRBJGxqIhAvARwhCkEAIQlBACAQLwEeIgxB//8BcSITQYD4AUsNAhpBACAKQf//AXEiFUGA+AFLDQIaIAzBQQBIDQEgCiAMSSAKwUEATg0CGiAMIBVyQQBHDAILIBQgCUHUwMcAEIwHAAsgCsFBAEggCiAMS3ELIRUgDCAKIBUbIAogE0GB+AFJGyEKAkAgEC8BICIMQf//AXEiE0GA+AFLDQAgCkH//wFxIhVBgPgBSw0AIAzBQQBOBEAgCsFBAE4EQCAMIApB//8DcUshCQwCCyAMIBVyQQBHIQkMAQsgCsFBAEggDCAKQf//A3FJcSEJCyAQLwEUIRACfyAMIAogCRsgCiATQYH4AUkbIgpB//8BcUUEQCAKQRB0DAELIApB/wdxIQkgCkGAgAJxIQwgCkGA+AFxIgpBgPgBRgRAIAxBEHQiCkGAgID8B3IgCUUNARogCiAJQQ10ckGAgID+B3IMAQsgDEEQdCIMIApBDXRBgICA/ABxIAlBDXRyQYCAgMADanIgCg0AGiAMQYCAgNgDciAJZ0EQayIKQRd0ayAJIApB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAQQRB0IBBB//8BcUUNABogEEH/B3EhCSAQQYCAAnEhCiAQQYD4AXEiDEGA+AFGBEAgCkEQdCIKQYCAgPwHciAJRQ0BGiAKIAlBDXRyQYCAgP4HcgwBCyAKQRB0IgogDEENdEGAgID8AHEgCUENdHJBgICAwANqciAMDQAaIApBgICA2ANyIAlnQRBrIgpBF3RrIAkgCkH//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIAhBCGoiFSgCACIJIA1LBEAgDUEkbCIQIAhBBGoiGigCAGoiDC8BHCEJQQAhCEEAIAwvAR4iCkH//wFxIhNBgPgBSw0CGkEAIAlB//8BcSIWQYD4AUsNAhogCsFBAEgNASAJIApJIAnBQQBODQIaIAogFnJBAEcMAgsgDSAJQdTAxwAQjAcACyAJwUEASCAJIApLcQshFiAKIAkgFhsgCSATQYH4AUkbIQkCQCAMLwEgIgpB//8BcSITQYD4AUsNACAJQf//AXEiFkGA+AFLDQAgCsFBAE4EQCAJwUEATgRAIAogCUH//wNxSyEIDAILIAogFnJBAEchCAwBCyAJwUEASCAKIAlB//8DcUlxIQgLIAwvARQhDCAHQQJ0IAIgD0EEayAkICSSICOUIiMgI1sgIwJ/IAogCSAIGyAJIBNBgfgBSRsiCUH//wFxRQRAIAlBEHQMAQsgCUH/B3EhCCAJQYCAAnEhCiAJQYD4AXEiCUGA+AFGBEAgCkEQdCIJQYCAgPwHciAIRQ0BGiAJIAhBDXRyQYCAgP4HcgwBCyAKQRB0IgogCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIApBgICA2ANyIAhnQRBrIglBF3RrIAggCUH//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQggDEGAgAJxIQkgDEGA+AFxIgpBgPgBRgRAIAlBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCUEQdCIJIApBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCg0AGiAJQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiFhtqIBQ2AgACfwJAIA5BBGooAgAiFCAVKAIAIhNJBEAgGigCACIXIBRBJGxqIgwvARwhCUEAIQhBACAMLwEeIgpB//8BcSIZQYD4AUsNAhpBACAJQf//AXEiIEGA+AFLDQIaIArBQQBIDQEgCSAKSSAJwUEATg0CGiAKICByQQBHDAILIBQgE0HUwMcAEIwHAAsgCcFBAEggCSAKS3ELISAgCiAJICAbIAkgGUGB+AFJGyEJAkAgDC8BICIKQf//AXEiGUGA+AFLDQAgCUH//wFxIiBBgPgBSw0AIArBQQBOBEAgCcFBAE4EQCAKIAlB//8DcUshCAwCCyAKICByQQBHIQgMAQsgCcFBAEggCiAJQf//A3FJcSEICyAMLwEUIQwCfyAKIAkgCBsgCSAZQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQggCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAMQRB0IAxB//8BcUUNABogDEH/B3EhCCAMQYCAAnEhCSAMQYD4AXEiCkGA+AFGBEAgCUEQdCIJQYCAgPwHciAIRQ0BGiAJIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgCkENdEGAgID8AHEgCEENdHJBgICAwANqciAKDQAaIAlBgICA2ANyIAhnQRBrIglBF3RrIAggCUH//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIA0gE0kEQCAQIBdqIgwvARwhCUEAIQhBACAMLwEeIgpB//8BcSITQYD4AUsNAhpBACAJQf//AXEiF0GA+AFLDQIaIArBQQBIDQEgCSAKSSAJwUEATg0CGiAKIBdyQQBHDAILIA0gE0HUwMcAEIwHAAsgCcFBAEggCSAKS3ELIRcgCiAJIBcbIAkgE0GB+AFJGyEJAkAgDC8BICIKQf//AXEiE0GA+AFLDQAgCUH//wFxIhdBgPgBSw0AIArBQQBOBEAgCcFBAE4EQCAKIAlB//8DcUshCAwCCyAKIBdyQQBHIQgMAQsgCcFBAEggCiAJQf//A3FJcSEICyAMLwEUIQwgByAWaiIWQQJ0IAIgD0EIayAkICSSICOUIiMgI1sgIwJ/IAogCSAIGyAJIBNBgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCSAHQYD4AXEiB0GA+AFGBEAgCUEQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAlBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQggDEGAgAJxIQcgDEGA+AFxIglBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiExtqIBQ2AgACfwJAIA5BCGooAgAiFCAVKAIAIghJBEAgGigCACAUQSRsaiIKLwEcIQhBACEJQQAgCi8BHiIHQf//AXEiDEGA+AFLDQIaQQAgCEH//wFxIhVBgPgBSw0CGiAHwUEASA0BIAcgCEsgCMFBAE4NAhogByAVckEARwwCCyAUIAhB1MDHABCMBwALIAjBQQBIIAcgCElxCyEVIAcgCCAVGyAIIAxBgfgBSRshCAJAIAovASAiB0H//wFxIgxBgPgBSw0AIAhB//8BcSIVQYD4AUsNACAHwUEATgRAIAjBQQBOBEAgByAIQf//A3FLIQkMAgsgByAVckEARyEJDAELIAjBQQBIIAcgCEH//wNxSXEhCQsgCi8BFCEKAn8gByAIIAkbIAggDEGB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEIIAdBgIACcSEJIAdBgPgBcSIHQYD4AUYEQCAJQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAlBEHQiCSAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAcNABogCUGAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gCkEQdCAKQf//AXFFDQAaIApB/wdxIQggCkGAgAJxIQcgCkGA+AFxIglBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAfKAIAIghBCGoiFSgCACIHIA1LBEAgCEEEaiIaKAIAIBBqIgwvARwhB0EAIQpBACAMLwEeIglB//8BcSIXQYD4AUsNAhpBACAHQf//AXEiGUGA+AFLDQIaIAnBQQBIDQEgByAJSSAHwUEATg0CGiAJIBlyQQBHDAILIA0gB0HUwMcAEIwHAAsgB8FBAEggByAJS3ELIRkgCSAHIBkbIAcgF0GB+AFJGyEHAkAgDC8BICIJQf//AXEiF0GA+AFLDQAgB0H//wFxIhlBgPgBSw0AIAnBQQBOBEAgB8FBAE4EQCAJIAdB//8DcUshCgwCCyAJIBlyQQBHIQoMAQsgB8FBAEggCSAHQf//A3FJcSEKCyAMLwEUIQwgEyAWaiIWQQJ0IAIgD0EMayAkICSSICOUIiMgI1sgIwJ/IAkgByAKGyAHIBdBgfgBSRsiCUH//wFxRQRAIAlBEHQMAQsgCUH/B3EhByAJQYCAAnEhCiAJQYD4AXEiCUGA+AFGBEAgCkEQdCIJQYCAgPwHciAHRQ0BGiAJIAdBDXRyQYCAgP4HcgwBCyAKQRB0IgogCUENdEGAgID8AHEgB0ENdHJBgICAwANqciAJDQAaIApBgICA2ANyIAdnQRBrIglBF3RrIAcgCUH//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQcgDEGAgAJxIQkgDEGA+AFxIgpBgPgBRgRAIAlBEHQiCUGAgID8B3IgB0UNARogCSAHQQ10ckGAgID+B3IMAQsgCUEQdCIJIApBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCg0AGiAJQYCAgNgDciAHZ0EQayIJQRd0ayAHIAlB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiFxtqIBQ2AgACfwJAIA5BDGooAgAiFCAVKAIAIhNJBEAgGigCACIVIBRBJGxqIgwvARwhB0EAIQpBACAMLwEeIglB//8BcSIaQYD4AUsNAhpBACAHQf//AXEiGUGA+AFLDQIaIAnBQQBIDQEgByAJSSAHwUEATg0CGiAJIBlyQQBHDAILIBQgE0HUwMcAEIwHAAsgB8FBAEggByAJS3ELIRkgCSAHIBkbIAcgGkGB+AFJGyEHAkAgDC8BICIJQf//AXEiGkGA+AFLDQAgB0H//wFxIhlBgPgBSw0AIAnBQQBOBEAgB8FBAE4EQCAJIAdB//8DcUshCgwCCyAJIBlyQQBHIQoMAQsgB8FBAEggCSAHQf//A3FJcSEKCyAMLwEUIQwCfyAJIAcgChsgByAaQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQcgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgB0UNARogCSAHQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAHZ0EQayIJQRd0ayAHIAlB//8DcUEIanRB////A3FyC74QiQQhJUMAAIA/ISMCfyAMQRB0IAxB//8BcUUNABogDEH/B3EhByAMQYCAAnEhCSAMQYD4AXEiCkGA+AFGBEAgCUEQdCIJQYCAgPwHciAHRQ0BGiAJIAdBDXRyQYCAgP4HcgwBCyAJQRB0IgkgCkENdEGAgID8AHEgB0ENdHJBgICAwANqciAKDQAaIAlBgICA2ANyIAdnQRBrIglBF3RrIAcgCUH//wNxQQhqdEH///8DcXILviIkQwAAgD9eBEAgJBDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIA0gE0kEQCAQIBVqIgwvARwhB0EAIQlBACAMLwEeIgpB//8BcSIQQYD4AUsNAhpBACAHQf//AXEiE0GA+AFLDQIaIArBQQBIDQEgByAKSSAHwUEATg0CGiAKIBNyQQBHDAILIA0gE0HUwMcAEIwHAAsgB8FBAEggByAKS3ELIRMgCiAHIBMbIAcgEEGB+AFJGyEHAkAgDC8BICIKQf//AXEiEEGA+AFLDQAgB0H//wFxIhNBgPgBSw0AIArBQQBOBEAgB8FBAE4EQCAKIAdB//8DcUshCQwCCyAKIBNyQQBHIQkMAQsgB8FBAEggCiAHQf//A3FJcSEJCyAMLwEUIQwCfyAKIAcgCRsgByAQQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQcgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgB0UNARogCSAHQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAHZ0EQayIJQRd0ayAHIAlB//8DcUEIanRB////A3FyC74QiQQhJkMAAIA/ISQCfyAMQRB0IAxB//8BcUUNABogDEH/B3EhByAMQYCAAnEhCSAMQYD4AXEiCkGA+AFGBEAgCUEQdCIJQYCAgPwHciAHRQ0BGiAJIAdBDXRyQYCAgP4HcgwBCyAJQRB0IgkgCkENdEGAgID8AHEgB0ENdHJBgICAwANqciAKDQAaIAlBgICA2ANyIAdnQRBrIglBF3RrIAcgCUH//wNxQQhqdEH///8DcXILviInQwAAgD9eBEAgJxDGBUNU+C1AlEMAAIA/kpEhJAsgFiAXaiIHQQJ0IAIgD0EQayIPICUgJZIgI5QiIyAjWyAjICYgJpIgJJRgRXEiCRtqIBQ2AgAgByAJaiEHIA5BEGoiDiAcSQ0ACwsgACALQQJ0aiIbIA5LBEAgHkEEaigCACETIBEoAgAhDANAAn8CQCAOKAIAIhAgE0EIaigCACIUSQRAIBNBBGooAgAiFSAQQSRsaiINLwEcIQhBACEJQQAgDS8BHiIKQf//AXEiGkGA+AFLDQIaQQAgCEH//wFxIhxBgPgBSw0CGiAKwUEASA0BIAggCkkgCMFBAE4NAhogCiAcckEARwwCCyAQIBRB1MDHABCMBwALIAjBQQBIIAggCktxCyEcIAogCCAcGyAIIBpBgfgBSRshCAJAIA0vASAiCkH//wFxIhpBgPgBSw0AIAhB//8BcSIcQYD4AUsNACAKwUEATgRAIAjBQQBOBEAgCiAIQf//A3FLIQkMAgsgCiAcckEARyEJDAELIAjBQQBIIAogCEH//wNxSXEhCQsgDS8BFCENAn8gCiAIIAkbIAggGkGB+AFJGyIJQf//AXFFBEAgCUEQdAwBCyAJQf8HcSEIIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAhFDQEaIAkgCEENdHJBgICA/gdyDAELIApBEHQiCiAJQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAkNABogCkGAgIDYA3IgCGdBEGsiCUEXdGsgCCAJQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gDUEQdCANQf//AXFFDQAaIA1B/wdxIQggDUGAgAJxIQkgDUGA+AFxIgpBgPgBRgRAIAlBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCUEQdCIJIApBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCg0AGiAJQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAMIBRJBEAgFSAMQSRsaiINLwEcIQhBACEJQQAgDS8BHiIKQf//AXEiFEGA+AFLDQIaQQAgCEH//wFxIhVBgPgBSw0CGiAKwUEASA0BIAggCkkgCMFBAE4NAhogCiAVckEARwwCCyAMIBRB1MDHABCMBwALIAjBQQBIIAggCktxCyEVIAogCCAVGyAIIBRBgfgBSRshCAJAIA0vASAiCkH//wFxIhRBgPgBSw0AIAhB//8BcSIVQYD4AUsNACAKwUEATgRAIAjBQQBOBEAgCiAIQf//A3FLIQkMAgsgCiAVckEARyEJDAELIAjBQQBIIAogCEH//wNxSXEhCQsgDS8BFCENIAdBAnQgAiAPQQRrIg8gJCAkkiAjlCIjICNbICMCfyAKIAggCRsgCCAUQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQggCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74QiQQiJCAkkgJ/IA1BEHQgDUH//wFxRQ0AGiANQf8HcSEIIA1BgIACcSEJIA1BgPgBcSIKQYD4AUYEQCAJQRB0IglBgICA/AdyIAhFDQEaIAkgCEENdHJBgICA/gdyDAELIAlBEHQiCSAKQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAoNABogCUGAgIDYA3IgCGdBEGsiCUEXdGsgCCAJQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EfSAkEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYEVxIggbaiAQNgIAIAcgCGohByAOQQRqIg4gG0kNAAsLIAEgC0cEQCAPQQRrIg8gB0ECdGogDigCADYCACAOQQRqIQ4gASELDAELCyAHQQJ0IggEQCAAIAIgCPwKAAALIAEgB2shCQJAIAEgB0YNAEEAIQogCUEETwRAIAAgCGohDiAYICJqIQ8gCUF8cSIKIQsDQCAOIA/9AAIA/QwAAAAAAAAAAAAAAAAAAAAA/Q0MDQ4PCAkKCwQFBgcAAQID/QsCACAPQRBrIQ8gDkEQaiEOIAtBBGsiCw0ACyAJIApGDQELICEgGCAKQQJ0IgtraiEOIAAgC2ogCGohDyAKIAFrIAdqIQsDQCAPIA4oAgA2AgAgDkEEayEOIA9BBGohDyALQQFqIgsNAAsLIAdFDQAgASAHTw0CIB1BADYCGCAdQQE2AgwgHUGIgsgANgIIIB1CBDcCECAdQQhqQfSUwQAQjQgACyABIANLDQAgAiABQQJ0Ih5qIQ8gBigCACEUQQAhCyAAIQ4DQCAAIBJBA2siBUEAIAUgEk0bQQJ0aiIVIA5LBEAgFEEEaiIaKAIAIRMgESgCACEFIAYoAgBBBGohHANAAn8CQCATQQhqKAIAIgggBUsEQCAFQSRsIgwgE0EEaigCAGoiCi8BHCEIQQAhCUEAIAovAR4iB0H//wFxIg1BgPgBSw0CGkEAIAhB//8BcSIQQYD4AUsNAhogB8FBAEgNASAHIAhLIAjBQQBODQIaIAcgEHJBAEcMAgsgBSAIQdTAxwAQjAcACyAIwUEASCAHIAhJcQshECAHIAggEBsgCCANQYH4AUkbIQgCQCAKLwEgIgdB//8BcSIQQYD4AUsNACAIQf//AXEiDUGA+AFLDQAgB8FBAE4EQCAIwUEATgRAIAcgCEH//wNxSyEJDAILIAcgDXJBAEchCQwBCyAIwUEASCAHIAhB//8DcUlxIQkLIA4oAgAhDSAKLwEUIQoCfyAHIAggCRsgCCAQQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQggB0GAgAJxIQkgB0GA+AFxIgdBgPgBRgRAIAlBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgCUEQdCIJIAdBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgBw0AGiAJQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAKQRB0IApB//8BcUUNABogCkH/B3EhCCAKQYCAAnEhByAKQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIBooAgAiCEEIaigCACIHIA1LBEAgCEEEaigCACANQSRsaiIKLwEcIQhBACEJQQAgCi8BHiIHQf//AXEiEEGA+AFLDQIaQQAgCEH//wFxIhhBgPgBSw0CGiAHwUEASA0BIAcgCEsgCMFBAE4NAhogByAYckEARwwCCyANIAdB1MDHABCMBwALIAjBQQBIIAcgCElxCyEYIAcgCCAYGyAIIBBBgfgBSRshCAJAIAovASAiB0H//wFxIhBBgPgBSw0AIAhB//8BcSIYQYD4AUsNACAHwUEATgRAIAjBQQBOBEAgByAIQf//A3FLIQkMAgsgByAYckEARyEJDAELIAjBQQBIIAcgCEH//wNxSXEhCQsgCi8BFCEKIAtBAnQgAiAPQQRrICQgJJIgI5QiIyAjXCAjAn8gByAIIAkbIAggEEGB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEIIAdBgIACcSEJIAdBgPgBcSIHQYD4AUYEQCAJQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAlBEHQiCSAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAcNABogCUGAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+EIkEIiQgJJICfyAKQRB0IApB//8BcUUNABogCkH/B3EhCCAKQYCAAnEhByAKQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILviIkQwAAgD9eBH0gJBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlGByIh8baiANNgIAAn8CQCAcKAIAIghBCGoiGCgCACIQIAVLBEAgCEEEaiIbKAIAIhYgDGoiCS8BHCEIQQAhCkEAIAkvAR4iB0H//wFxIg1BgPgBSw0CGkEAIAhB//8BcSIXQYD4AUsNAhogB8FBAEgNASAHIAhLIAjBQQBODQIaIAcgF3JBAEcMAgsgBSAQQdTAxwAQjAcACyAIwUEASCAHIAhJcQshFyAHIAggFxsgCCANQYH4AUkbIQgCQCAJLwEgIgdB//8BcSIXQYD4AUsNACAIQf//AXEiDUGA+AFLDQAgB8FBAE4EQCAIwUEATgRAIAcgCEH//wNxSyEKDAILIAcgDXJBAEchCgwBCyAIwUEASCAHIAhB//8DcUlxIQoLIA5BBGooAgAhDSAJLwEUIQkCfyAHIAggChsgCCAXQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQggB0GAgAJxIQogB0GA+AFxIgdBgPgBRgRAIApBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgCkEQdCIKIAdBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgBw0AGiAKQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAJQRB0IAlB//8BcUUNABogCUH/B3EhCCAJQYCAAnEhByAJQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIA0gEEkEQCAWIA1BJGxqIgovARwhB0EAIQhBACAKLwEeIglB//8BcSIQQYD4AUsNAhpBACAHQf//AXEiFkGA+AFLDQIaIAnBQQBIDQEgByAJSSAHwUEATg0CGiAJIBZyQQBHDAILIA0gEEHUwMcAEIwHAAsgB8FBAEggByAJS3ELIRYgCSAHIBYbIAcgEEGB+AFJGyEHAkAgCi8BICIJQf//AXEiEEGA+AFLDQAgB0H//wFxIhZBgPgBSw0AIAnBQQBOBEAgB8FBAE4EQCAJIAdB//8DcUshCAwCCyAJIBZyQQBHIQgMAQsgB8FBAEggCSAHQf//A3FJcSEICyAKLwEUIQogCyAfaiIfQQJ0IAIgD0EIayAkICSSICOUIiMgI1wgIwJ/IAkgByAIGyAHIBBBgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCyAHQYD4AXEiB0GA+AFGBEAgC0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyALQRB0IgsgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAtBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gCkEQdCAKQf//AXFFDQAaIApB/wdxIQggCkGAgAJxIQcgCkGA+AFxIgtBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAtBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCw0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgciIQG2ogDTYCAAJ/AkAgGCgCACIJIAVLBEAgGygCACIWIAxqIgsvARwhCEEAIQpBACALLwEeIgdB//8BcSINQYD4AUsNAhpBACAIQf//AXEiF0GA+AFLDQIaIAfBQQBIDQEgByAISyAIwUEATg0CGiAHIBdyQQBHDAILIAUgCUHUwMcAEIwHAAsgCMFBAEggByAISXELIRcgByAIIBcbIAggDUGB+AFJGyEIAkAgCy8BICIHQf//AXEiF0GA+AFLDQAgCEH//wFxIg1BgPgBSw0AIAfBQQBOBEAgCMFBAE4EQCAHIAhB//8DcUshCgwCCyAHIA1yQQBHIQoMAQsgCMFBAEggByAIQf//A3FJcSEKCyAOQQhqKAIAIQ0gCy8BFCELAn8gByAIIAobIAggF0GB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEIIAdBgIACcSEKIAdBgPgBcSIHQYD4AUYEQCAKQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIApBEHQiCiAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAcNABogCkGAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gC0EQdCALQf//AXFFDQAaIAtB/wdxIQggC0GAgAJxIQcgC0GA+AFxIgtBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAtBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCw0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAJIA1LBEAgFiANQSRsaiIJLwEcIQdBACEIQQAgCS8BHiILQf//AXEiCkGA+AFLDQIaQQAgB0H//wFxIhZBgPgBSw0CGiALwUEASA0BIAcgC0kgB8FBAE4NAhogCyAWckEARwwCCyANIAlB1MDHABCMBwALIAfBQQBIIAcgC0txCyEWIAsgByAWGyAHIApBgfgBSRshBwJAIAkvASAiC0H//wFxIgpBgPgBSw0AIAdB//8BcSIWQYD4AUsNACALwUEATgRAIAfBQQBOBEAgCyAHQf//A3FLIQgMAgsgCyAWckEARyEIDAELIAfBQQBIIAsgB0H//wNxSXEhCAsgCS8BFCEJIBAgH2oiEEECdCACIA9BDGsgJCAkkiAjlCIjICNcICMCfyALIAcgCBsgByAKQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQggB0GAgAJxIQsgB0GA+AFxIgdBgPgBRgRAIAtBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgC0EQdCILIAdBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgBw0AGiALQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74QiQQiJCAkkgJ/IAlBEHQgCUH//wFxRQ0AGiAJQf8HcSEIIAlBgIACcSEHIAlBgPgBcSILQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAdBEHQiByALQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EfSAkEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYHIiHxtqIA02AgACfwJAIBgoAgAiDSAFSwRAIAwgGygCACIYaiILLwEcIQhBACEJQQAgCy8BHiIHQf//AXEiCkGA+AFLDQIaQQAgCEH//wFxIgxBgPgBSw0CGiAHwUEASA0BIAcgCEsgCMFBAE4NAhogByAMckEARwwCCyAFIA1B1MDHABCMBwALIAjBQQBIIAcgCElxCyEMIAcgCCAMGyAIIApBgfgBSRshCAJAIAsvASAiB0H//wFxIgxBgPgBSw0AIAhB//8BcSIKQYD4AUsNACAHwUEATgRAIAjBQQBOBEAgByAIQf//A3FLIQkMAgsgByAKckEARyEJDAELIAjBQQBIIAcgCEH//wNxSXEhCQsgDkEMaigCACEKIAsvARQhCwJ/IAcgCCAJGyAIIAxBgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCSAHQYD4AXEiB0GA+AFGBEAgCUEQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAlBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCElQwAAgD8hIwJ/IAtBEHQgC0H//wFxRQ0AGiALQf8HcSEIIAtBgIACcSEHIAtBgPgBcSILQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAdBEHQiByALQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EQCAkEMYFQ1T4LUCUQwAAgD+SkSEjCwJ/AkAgCiANSQRAIBggCkEkbGoiCy8BHCEIQQAhCUEAIAsvAR4iB0H//wFxIg1BgPgBSw0CGkEAIAhB//8BcSIMQYD4AUsNAhogB8FBAEgNASAHIAhLIAjBQQBODQIaIAcgDHJBAEcMAgsgCiANQdTAxwAQjAcACyAIwUEASCAHIAhJcQshDCAHIAggDBsgCCANQYH4AUkbIQgCQCALLwEgIgdB//8BcSINQYD4AUsNACAIQf//AXEiDEGA+AFLDQAgB8FBAE4EQCAIwUEATgRAIAcgCEH//wNxSyEJDAILIAcgDHJBAEchCQwBCyAIwUEASCAHIAhB//8DcUlxIQkLIAsvARQhCwJ/IAcgCCAJGyAIIA1BgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCSAHQYD4AXEiB0GA+AFGBEAgCUEQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAlBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCEmQwAAgD8hJAJ/IAtBEHQgC0H//wFxRQ0AGiALQf8HcSEIIAtBgIACcSEHIAtBgPgBcSILQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAdBEHQiByALQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+IidDAACAP14EQCAnEMYFQ1T4LUCUQwAAgD+SkSEkCyAQIB9qIghBAnQgAiAPQRBrIg8gJSAlkiAjlCIjICNcICMgJiAmkiAklGByIgcbaiAKNgIAIAcgCGohCyAOQRBqIg4gFUkNAAsLIAAgEkECdGoiEyAOSwRAIBRBBGooAgAhECARKAIAIQ0DQAJ/AkAgEEEIaigCACIMIA1LBEAgEEEEaigCACIYIA1BJGxqIgkvARwhBUEAIQdBACAJLwEeIghB//8BcSIKQYD4AUsNAhpBACAFQf//AXEiG0GA+AFLDQIaIAjBQQBIDQEgBSAISSAFwUEATg0CGiAIIBtyQQBHDAILIA0gDEHUwMcAEIwHAAsgBcFBAEggBSAIS3ELIRsgCCAFIBsbIAUgCkGB+AFJGyEFAkAgCS8BICIIQf//AXEiG0GA+AFLDQAgBUH//wFxIgpBgPgBSw0AIAjBQQBOBEAgBcFBAE4EQCAIIAVB//8DcUshBwwCCyAIIApyQQBHIQcMAQsgBcFBAEggCCAFQf//A3FJcSEHCyAOKAIAIQogCS8BFCEJAn8gCCAFIAcbIAUgG0GB+AFJGyIIQf//AXFFBEAgCEEQdAwBCyAIQf8HcSEFIAhBgIACcSEHIAhBgPgBcSIIQYD4AUYEQCAHQRB0IghBgICA/AdyIAVFDQEaIAggBUENdHJBgICA/gdyDAELIAdBEHQiByAIQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2pyIAgNABogB0GAgIDYA3IgBWdBEGsiCEEXdGsgBSAIQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gCUEQdCAJQf//AXFFDQAaIAlB/wdxIQUgCUGAgAJxIQggCUGA+AFxIgdBgPgBRgRAIAhBEHQiCEGAgID8B3IgBUUNARogCCAFQQ10ckGAgID+B3IMAQsgCEEQdCIIIAdBDXRBgICA/ABxIAVBDXRyQYCAgMADanIgBw0AGiAIQYCAgNgDciAFZ0EQayIIQRd0ayAFIAhB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAKIAxJBEAgGCAKQSRsaiIHLwEcIQVBACEJQQAgBy8BHiIIQf//AXEiDEGA+AFLDQIaQQAgBUH//wFxIhhBgPgBSw0CGiAIwUEASA0BIAUgCEkgBcFBAE4NAhogCCAYckEARwwCCyAKIAxB1MDHABCMBwALIAXBQQBIIAUgCEtxCyEYIAggBSAYGyAFIAxBgfgBSRshBQJAIAcvASAiCEH//wFxIgxBgPgBSw0AIAVB//8BcSIYQYD4AUsNACAIwUEATgRAIAXBQQBOBEAgCCAFQf//A3FLIQkMAgsgCCAYckEARyEJDAELIAXBQQBIIAggBUH//wNxSXEhCQsgBy8BFCEHIAtBAnQgAiAPQQRrIg8gJCAkkiAjlCIjICNcICMCfyAIIAUgCRsgBSAMQYH4AUkbIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQUgCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgBUUNARogCCAFQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIAVBDXRyQYCAgMADanIgCA0AGiAJQYCAgNgDciAFZ0EQayIIQRd0ayAFIAhB//8DcUEIanRB////A3FyC74QiQQiJCAkkgJ/IAdBEHQgB0H//wFxRQ0AGiAHQf8HcSEFIAdBgIACcSEIIAdBgPgBcSIHQYD4AUYEQCAIQRB0IghBgICA/AdyIAVFDQEaIAggBUENdHJBgICA/gdyDAELIAhBEHQiCCAHQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2pyIAcNABogCEGAgIDYA3IgBWdBEGsiCEEXdGsgBSAIQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EfSAkEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYHIiBRtqIAo2AgAgBSALaiELIA5BBGoiDiATSQ0ACwsgASASRwRAIAIgC0ECdGogDigCADYCACAOQQRqIQ4gC0EBaiELIA9BBGshDyABIRIMAQsLIAtBAnQiBQRAIAAgAiAF/AoAAAsgASALRg0EIAAgBWohCEEAIQoCQCABIAtrIgdBBE8EQCAeICJqIQ4gCCEPIAdBfHEiCiEJA0AgDyAO/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgDkEQayEOIA9BEGohDyAJQQRrIgkNAAsgByAKRg0BCyAhIApBAnQiEmsgHmohDiAAIBJqIAVqIQ8gCiABayALaiEJA0AgDyAOKAIANgIAIA5BBGshDiAPQQRqIQ8gCUEBaiIJDQALCyABIAtPBEBBACEFIAghACAHIQEgB0EhSQ0EDAMLIAsgASABQYSVwQAQ6gcACwALIAAgCGogCSACIAMgBCAdQQRqIAYQMiAHIQEgB0EhTw0ACyAAIQgLIAdBAkkNACAGKAIAIQEgB0EBdiEAIAACfyAHQQ9NBEAgB0EHSwRAIAggAiABQQRqIgMoAgAQhgEgCCAAQQJ0IgRqIAIgBGogAygCABCGAUEEDAILIAIgCCgCADYCACACIABBAnQiA2ogAyAIaigCADYCAEEBDAELIAggAiAHQQJ0aiIDIAFBBGoiBCgCABCGASAIQRBqIANBEGogBCgCABCGASADQQggAiABEOQBIAggAEECdCIFaiIGIANBIGoiEiAEKAIAEIYBIAZBEGogA0EwaiAEKAIAEIYBIBJBCCACIAVqIAEQ5AFBCAsiA0sEQCAAIANrIQ8gA0ECdCEOA0AgAiAOaiIEIAggDmooAgA2AgAgAiAEIAEQ+gEgDkEEaiEOIA9BAWsiDw0ACwsgByAAayADSwRAIAIgAEECdCIEaiEFIAggA0ECdCAEaiIEaiEPIAIgBGohDiAAIANqIAdrIQkDQCAOIA8oAgA2AgAgBSAOIAEQ+gEgD0EEaiEPIA5BBGohDiAJQQFqIgkNAAsLIAIgByAIIAEQ5AELIB1BIGokAAvpigECHH8HfSMAQSBrIh0kAAJAAkAgAUEhSQRAIAAhCCABIQcMAQsgAkEEayEhIAJBEGshIgNAIARFBEAgACABIAIgA0EBIAYQVQwDCyAAIAFBA3YiCEEcbGohDiAAIAhBBHRqIQ8CQCABQcAATwRAIAAgDyAOIAggBhDBASERIAYoAgAhHgwBC0MAAIA/ISQCfwJAIAAoAgAiCCAGKAIAIh5BBGooAgAiB0EIaigCACISSQRAIA8oAgAhCyAHQQRqKAIAIgkgCEEkbGoiChCKBCEjIAovARQiCEH//wFxIhBFBEAgCEEQdAwDCyAIQf8HcSEHIAhBgIACcSERIAhBgPgBcSINQYD4AUYEQCARQRB0IhFBgICA/AdyIAdFDQMaIBEgB0ENdHJBgICA/gdyDAMLIBFBEHQhESANRQ0BIA1BDXRBgICA/ABxIAdBDXRyQYCAgMADaiARcgwCCyAIIBJB1MDHABCMBwALIBFBgICA2ANyIAdnQRBrIhFBF3RrIAcgEUH//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhJAtDAACAPyElAn8CQCALIBJJBEAgCSALQSRsaiINEIoEISYgDS8BFCIHQf//AXEiFEUEQCAHQRB0DAMLIAdB/wdxIQsgB0GAgAJxIREgB0GA+AFxIgxBgPgBRgRAIBFBEHQiEUGAgID8B3IgC0UNAxogESALQQ10ckGAgID+B3IMAwsgEUEQdCERIAxFDQEgDEENdEGAgID8AHEgC0ENdHJBgICAwANqIBFyDAILIAsgEkHUwMcAEIwHAAsgEUGAgIDYA3IgC2dBEGsiEUEXdGsgCyARQf//A3FBCGp0Qf///wNxcgu+IidDAACAP14EQCAnEMYFQ1T4LUCUQwAAgD+SkSElCyAOKAIAIREgChCKBCEnQwAAgD8hKAJ/IAhBEHQgEEUNABogCEH/B3EhCyAIQYCAAnEhCiAIQYD4AXEiCEGA+AFGBEAgCkEQdCIIQYCAgPwHciALRQ0BGiAIIAtBDXRyQYCAgP4HcgwBCyAKQRB0IgogCEENdEGAgID8AHEgC0ENdHJBgICAwANqciAIDQAaIApBgICA2ANyIAtnQRBrIghBF3RrIAsgCEH//wNxQQhqdEH///8DcXILviIpQwAAgD9eBEAgKRDGBUNU+C1AlEMAAIA/kpEhKAsCfwJAIBEgEkkEQCAjICOSICSUIiMgJiAmkiAllGBFIQogIyAjWyEMIAkgEUEkbGoiCxCKBCEjIAsvARQiCEH//wFxIhBFBEAgCEEQdAwDCyAIQf8HcSESIAhBgIACcSERIAhBgPgBcSIJQYD4AUYEQCARQRB0IhFBgICA/AdyIBJFDQMaIBEgEkENdHJBgICA/gdyDAMLIBFBEHQhESAJRQ0BIAlBDXRBgICA/ABxIBJBDXRyQYCAgMADaiARcgwCCyARIBJB1MDHABCMBwALIBFBgICA2ANyIBJnQRBrIhFBF3RrIBIgEUH//wNxQQhqdEH///8DcXILQwAAgD8hJL4iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISQLIAogDHEiCSAnICeSICiUIiUgJVsgJSAjICOSICSUYEVxRwRAIAAhEQwBC0MAAIA/ISMgDiAPIAkgDRCKBCIkICSSAn8gB0EQdCAURQ0AGiAHQf8HcSESIAdBgIACcSERIAdBgPgBcSIHQYD4AUYEQCARQRB0IgdBgICA/AdyIBJFDQEaIAcgEkENdHJBgICA/gdyDAELIBFBEHQiESAHQQ10QYCAgPwAcSASQQ10ckGAgIDAA2pyIAcNABogEUGAgIDYA3IgEmdBEGsiB0EXdGsgEiAHQf//A3FBCGp0Qf///wNxcgu+IiVDAACAP14EfSAlEMYFQ1T4LUCUQwAAgD+SkQUgIwuUIiMgI1sgIyALEIoEIiQgJJICfyAIQRB0IBBFDQAaIAhB/wdxIQcgCEGAgAJxIRIgCEGA+AFxIghBgPgBRgRAIBJBEHQiCEGAgID8B3IgB0UNARogCCAHQQ10ckGAgID+B3IMAQsgEkEQdCISIAhBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCA0AGiASQYCAgNgDciAHZ0EQayIIQRd0ayAHIAhB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXFzGyERCyAEQQFrIQQgHSARKAIAIgs2AgQgESAAa0ECdiESAkACQAJAIAUEQEMAAIA/ISMCfwJAIAUoAgAiCCAeQQRqKAIAIgdBCGooAgAiDkkEQCAHQQRqKAIAIgkgCEEkbGoiCBCKBCElIAgvARQiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCCAHQYCAAnEhDyAHQYD4AXEiB0GA+AFGBEAgD0EQdCIHQYCAgPwHciAIRQ0DGiAHIAhBDXRyQYCAgP4HcgwDCyAPQRB0IQ8gB0UNASAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogD3IMAgsgCCAOQdTAxwAQjAcACyAPQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJEMAAIA/XgRAICQQxgVDVPgtQJRDAACAP5KRISMLQwAAgD8hJAJ/AkAgCyAOSQRAIAkgC0EkbGoiCBCKBCEmIAgvARQiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCCAHQYCAAnEhCyAHQYD4AXEiB0GA+AFGBEAgC0EQdCIHQYCAgPwHciAIRQ0DGiAHIAhBDXRyQYCAgP4HcgwDCyALQRB0IQsgB0UNASAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogC3IMAgsgCyAOQdTAxwAQjAcACyALQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJ0MAAIA/XgRAICcQxgVDVPgtQJRDAACAP5KRISQLICUgJZIgI5QiIyAjXCAjICYgJpIgJJRgcg0BCyABIANLDQEgAiABQQJ0IhhqIQ9BACEHIAAhDiASIQsDQCAAIAtBA2siCEEAIAggC00bQQJ0aiIcIA5LBEAgESgCACENIB5BBGoiHygCACIbIQgDQAJ/AkAgDigCACIUIBtBCGooAgAiCUkEQCAbQQRqKAIAIBRBJGxqIhAvARwhCkEAIQlBACAQLwEeIgxB//8BcSITQYD4AUsNAhpBACAKQf//AXEiFUGA+AFLDQIaIAzBQQBIDQEgCiAMSSAKwUEATg0CGiAMIBVyQQBHDAILIBQgCUHUwMcAEIwHAAsgCsFBAEggCiAMS3ELIRUgDCAKIBUbIAogE0GB+AFJGyEKAkAgEC8BICIMQf//AXEiE0GA+AFLDQAgCkH//wFxIhVBgPgBSw0AIAzBQQBOBEAgCsFBAE4EQCAMIApB//8DcUshCQwCCyAMIBVyQQBHIQkMAQsgCsFBAEggDCAKQf//A3FJcSEJCyAQLwEUIRACfyAMIAogCRsgCiATQYH4AUkbIgpB//8BcUUEQCAKQRB0DAELIApB/wdxIQkgCkGAgAJxIQwgCkGA+AFxIgpBgPgBRgRAIAxBEHQiCkGAgID8B3IgCUUNARogCiAJQQ10ckGAgID+B3IMAQsgDEEQdCIMIApBDXRBgICA/ABxIAlBDXRyQYCAgMADanIgCg0AGiAMQYCAgNgDciAJZ0EQayIKQRd0ayAJIApB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAQQRB0IBBB//8BcUUNABogEEH/B3EhCSAQQYCAAnEhCiAQQYD4AXEiDEGA+AFGBEAgCkEQdCIKQYCAgPwHciAJRQ0BGiAKIAlBDXRyQYCAgP4HcgwBCyAKQRB0IgogDEENdEGAgID8AHEgCUENdHJBgICAwANqciAMDQAaIApBgICA2ANyIAlnQRBrIgpBF3RrIAkgCkH//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIAhBCGoiFSgCACIJIA1LBEAgDUEkbCIQIAhBBGoiGigCAGoiDC8BHCEJQQAhCEEAIAwvAR4iCkH//wFxIhNBgPgBSw0CGkEAIAlB//8BcSIWQYD4AUsNAhogCsFBAEgNASAJIApJIAnBQQBODQIaIAogFnJBAEcMAgsgDSAJQdTAxwAQjAcACyAJwUEASCAJIApLcQshFiAKIAkgFhsgCSATQYH4AUkbIQkCQCAMLwEgIgpB//8BcSITQYD4AUsNACAJQf//AXEiFkGA+AFLDQAgCsFBAE4EQCAJwUEATgRAIAogCUH//wNxSyEIDAILIAogFnJBAEchCAwBCyAJwUEASCAKIAlB//8DcUlxIQgLIAwvARQhDCAHQQJ0IAIgD0EEayAkICSSICOUIiMgI1sgIwJ/IAogCSAIGyAJIBNBgfgBSRsiCUH//wFxRQRAIAlBEHQMAQsgCUH/B3EhCCAJQYCAAnEhCiAJQYD4AXEiCUGA+AFGBEAgCkEQdCIJQYCAgPwHciAIRQ0BGiAJIAhBDXRyQYCAgP4HcgwBCyAKQRB0IgogCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIApBgICA2ANyIAhnQRBrIglBF3RrIAggCUH//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQggDEGAgAJxIQkgDEGA+AFxIgpBgPgBRgRAIAlBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCUEQdCIJIApBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCg0AGiAJQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiFhtqIBQ2AgACfwJAIA5BBGooAgAiFCAVKAIAIhNJBEAgGigCACIXIBRBJGxqIgwvARwhCUEAIQhBACAMLwEeIgpB//8BcSIZQYD4AUsNAhpBACAJQf//AXEiIEGA+AFLDQIaIArBQQBIDQEgCSAKSSAJwUEATg0CGiAKICByQQBHDAILIBQgE0HUwMcAEIwHAAsgCcFBAEggCSAKS3ELISAgCiAJICAbIAkgGUGB+AFJGyEJAkAgDC8BICIKQf//AXEiGUGA+AFLDQAgCUH//wFxIiBBgPgBSw0AIArBQQBOBEAgCcFBAE4EQCAKIAlB//8DcUshCAwCCyAKICByQQBHIQgMAQsgCcFBAEggCiAJQf//A3FJcSEICyAMLwEUIQwCfyAKIAkgCBsgCSAZQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQggCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAMQRB0IAxB//8BcUUNABogDEH/B3EhCCAMQYCAAnEhCSAMQYD4AXEiCkGA+AFGBEAgCUEQdCIJQYCAgPwHciAIRQ0BGiAJIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgCkENdEGAgID8AHEgCEENdHJBgICAwANqciAKDQAaIAlBgICA2ANyIAhnQRBrIglBF3RrIAggCUH//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIA0gE0kEQCAQIBdqIgwvARwhCUEAIQhBACAMLwEeIgpB//8BcSITQYD4AUsNAhpBACAJQf//AXEiF0GA+AFLDQIaIArBQQBIDQEgCSAKSSAJwUEATg0CGiAKIBdyQQBHDAILIA0gE0HUwMcAEIwHAAsgCcFBAEggCSAKS3ELIRcgCiAJIBcbIAkgE0GB+AFJGyEJAkAgDC8BICIKQf//AXEiE0GA+AFLDQAgCUH//wFxIhdBgPgBSw0AIArBQQBOBEAgCcFBAE4EQCAKIAlB//8DcUshCAwCCyAKIBdyQQBHIQgMAQsgCcFBAEggCiAJQf//A3FJcSEICyAMLwEUIQwgByAWaiIWQQJ0IAIgD0EIayAkICSSICOUIiMgI1sgIwJ/IAogCSAIGyAJIBNBgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCSAHQYD4AXEiB0GA+AFGBEAgCUEQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAlBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQggDEGAgAJxIQcgDEGA+AFxIglBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiExtqIBQ2AgACfwJAIA5BCGooAgAiFCAVKAIAIghJBEAgGigCACAUQSRsaiIKLwEcIQhBACEJQQAgCi8BHiIHQf//AXEiDEGA+AFLDQIaQQAgCEH//wFxIhVBgPgBSw0CGiAHwUEASA0BIAcgCEsgCMFBAE4NAhogByAVckEARwwCCyAUIAhB1MDHABCMBwALIAjBQQBIIAcgCElxCyEVIAcgCCAVGyAIIAxBgfgBSRshCAJAIAovASAiB0H//wFxIgxBgPgBSw0AIAhB//8BcSIVQYD4AUsNACAHwUEATgRAIAjBQQBOBEAgByAIQf//A3FLIQkMAgsgByAVckEARyEJDAELIAjBQQBIIAcgCEH//wNxSXEhCQsgCi8BFCEKAn8gByAIIAkbIAggDEGB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEIIAdBgIACcSEJIAdBgPgBcSIHQYD4AUYEQCAJQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAlBEHQiCSAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAcNABogCUGAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gCkEQdCAKQf//AXFFDQAaIApB/wdxIQggCkGAgAJxIQcgCkGA+AFxIglBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAfKAIAIghBCGoiFSgCACIHIA1LBEAgCEEEaiIaKAIAIBBqIgwvARwhB0EAIQpBACAMLwEeIglB//8BcSIXQYD4AUsNAhpBACAHQf//AXEiGUGA+AFLDQIaIAnBQQBIDQEgByAJSSAHwUEATg0CGiAJIBlyQQBHDAILIA0gB0HUwMcAEIwHAAsgB8FBAEggByAJS3ELIRkgCSAHIBkbIAcgF0GB+AFJGyEHAkAgDC8BICIJQf//AXEiF0GA+AFLDQAgB0H//wFxIhlBgPgBSw0AIAnBQQBOBEAgB8FBAE4EQCAJIAdB//8DcUshCgwCCyAJIBlyQQBHIQoMAQsgB8FBAEggCSAHQf//A3FJcSEKCyAMLwEUIQwgEyAWaiIWQQJ0IAIgD0EMayAkICSSICOUIiMgI1sgIwJ/IAkgByAKGyAHIBdBgfgBSRsiCUH//wFxRQRAIAlBEHQMAQsgCUH/B3EhByAJQYCAAnEhCiAJQYD4AXEiCUGA+AFGBEAgCkEQdCIJQYCAgPwHciAHRQ0BGiAJIAdBDXRyQYCAgP4HcgwBCyAKQRB0IgogCUENdEGAgID8AHEgB0ENdHJBgICAwANqciAJDQAaIApBgICA2ANyIAdnQRBrIglBF3RrIAcgCUH//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gDEEQdCAMQf//AXFFDQAaIAxB/wdxIQcgDEGAgAJxIQkgDEGA+AFxIgpBgPgBRgRAIAlBEHQiCUGAgID8B3IgB0UNARogCSAHQQ10ckGAgID+B3IMAQsgCUEQdCIJIApBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCg0AGiAJQYCAgNgDciAHZ0EQayIJQRd0ayAHIAlB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiFxtqIBQ2AgACfwJAIA5BDGooAgAiFCAVKAIAIhNJBEAgGigCACIVIBRBJGxqIgwvARwhB0EAIQpBACAMLwEeIglB//8BcSIaQYD4AUsNAhpBACAHQf//AXEiGUGA+AFLDQIaIAnBQQBIDQEgByAJSSAHwUEATg0CGiAJIBlyQQBHDAILIBQgE0HUwMcAEIwHAAsgB8FBAEggByAJS3ELIRkgCSAHIBkbIAcgGkGB+AFJGyEHAkAgDC8BICIJQf//AXEiGkGA+AFLDQAgB0H//wFxIhlBgPgBSw0AIAnBQQBOBEAgB8FBAE4EQCAJIAdB//8DcUshCgwCCyAJIBlyQQBHIQoMAQsgB8FBAEggCSAHQf//A3FJcSEKCyAMLwEUIQwCfyAJIAcgChsgByAaQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQcgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgB0UNARogCSAHQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAHZ0EQayIJQRd0ayAHIAlB//8DcUEIanRB////A3FyC74QiQQhJUMAAIA/ISMCfyAMQRB0IAxB//8BcUUNABogDEH/B3EhByAMQYCAAnEhCSAMQYD4AXEiCkGA+AFGBEAgCUEQdCIJQYCAgPwHciAHRQ0BGiAJIAdBDXRyQYCAgP4HcgwBCyAJQRB0IgkgCkENdEGAgID8AHEgB0ENdHJBgICAwANqciAKDQAaIAlBgICA2ANyIAdnQRBrIglBF3RrIAcgCUH//wNxQQhqdEH///8DcXILviIkQwAAgD9eBEAgJBDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIA0gE0kEQCAQIBVqIgwvARwhB0EAIQlBACAMLwEeIgpB//8BcSIQQYD4AUsNAhpBACAHQf//AXEiE0GA+AFLDQIaIArBQQBIDQEgByAKSSAHwUEATg0CGiAKIBNyQQBHDAILIA0gE0HUwMcAEIwHAAsgB8FBAEggByAKS3ELIRMgCiAHIBMbIAcgEEGB+AFJGyEHAkAgDC8BICIKQf//AXEiEEGA+AFLDQAgB0H//wFxIhNBgPgBSw0AIArBQQBOBEAgB8FBAE4EQCAKIAdB//8DcUshCQwCCyAKIBNyQQBHIQkMAQsgB8FBAEggCiAHQf//A3FJcSEJCyAMLwEUIQwCfyAKIAcgCRsgByAQQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQcgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgB0UNARogCSAHQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAdBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAHZ0EQayIJQRd0ayAHIAlB//8DcUEIanRB////A3FyC74QiQQhJkMAAIA/ISQCfyAMQRB0IAxB//8BcUUNABogDEH/B3EhByAMQYCAAnEhCSAMQYD4AXEiCkGA+AFGBEAgCUEQdCIJQYCAgPwHciAHRQ0BGiAJIAdBDXRyQYCAgP4HcgwBCyAJQRB0IgkgCkENdEGAgID8AHEgB0ENdHJBgICAwANqciAKDQAaIAlBgICA2ANyIAdnQRBrIglBF3RrIAcgCUH//wNxQQhqdEH///8DcXILviInQwAAgD9eBEAgJxDGBUNU+C1AlEMAAIA/kpEhJAsgFiAXaiIHQQJ0IAIgD0EQayIPICUgJZIgI5QiIyAjWyAjICYgJpIgJJRgRXEiCRtqIBQ2AgAgByAJaiEHIA5BEGoiDiAcSQ0ACwsgACALQQJ0aiIbIA5LBEAgHkEEaigCACETIBEoAgAhDANAAn8CQCAOKAIAIhAgE0EIaigCACIUSQRAIBNBBGooAgAiFSAQQSRsaiINLwEcIQhBACEJQQAgDS8BHiIKQf//AXEiGkGA+AFLDQIaQQAgCEH//wFxIhxBgPgBSw0CGiAKwUEASA0BIAggCkkgCMFBAE4NAhogCiAcckEARwwCCyAQIBRB1MDHABCMBwALIAjBQQBIIAggCktxCyEcIAogCCAcGyAIIBpBgfgBSRshCAJAIA0vASAiCkH//wFxIhpBgPgBSw0AIAhB//8BcSIcQYD4AUsNACAKwUEATgRAIAjBQQBOBEAgCiAIQf//A3FLIQkMAgsgCiAcckEARyEJDAELIAjBQQBIIAogCEH//wNxSXEhCQsgDS8BFCENAn8gCiAIIAkbIAggGkGB+AFJGyIJQf//AXFFBEAgCUEQdAwBCyAJQf8HcSEIIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAhFDQEaIAkgCEENdHJBgICA/gdyDAELIApBEHQiCiAJQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAkNABogCkGAgIDYA3IgCGdBEGsiCUEXdGsgCCAJQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gDUEQdCANQf//AXFFDQAaIA1B/wdxIQggDUGAgAJxIQkgDUGA+AFxIgpBgPgBRgRAIAlBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCUEQdCIJIApBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCg0AGiAJQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAMIBRJBEAgFSAMQSRsaiINLwEcIQhBACEJQQAgDS8BHiIKQf//AXEiFEGA+AFLDQIaQQAgCEH//wFxIhVBgPgBSw0CGiAKwUEASA0BIAggCkkgCMFBAE4NAhogCiAVckEARwwCCyAMIBRB1MDHABCMBwALIAjBQQBIIAggCktxCyEVIAogCCAVGyAIIBRBgfgBSRshCAJAIA0vASAiCkH//wFxIhRBgPgBSw0AIAhB//8BcSIVQYD4AUsNACAKwUEATgRAIAjBQQBOBEAgCiAIQf//A3FLIQkMAgsgCiAVckEARyEJDAELIAjBQQBIIAogCEH//wNxSXEhCQsgDS8BFCENIAdBAnQgAiAPQQRrIg8gJCAkkiAjlCIjICNbICMCfyAKIAggCRsgCCAUQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQggCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgCEUNARogCSAIQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCQ0AGiAKQYCAgNgDciAIZ0EQayIJQRd0ayAIIAlB//8DcUEIanRB////A3FyC74QiQQiJCAkkgJ/IA1BEHQgDUH//wFxRQ0AGiANQf8HcSEIIA1BgIACcSEJIA1BgPgBcSIKQYD4AUYEQCAJQRB0IglBgICA/AdyIAhFDQEaIAkgCEENdHJBgICA/gdyDAELIAlBEHQiCSAKQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAoNABogCUGAgIDYA3IgCGdBEGsiCUEXdGsgCCAJQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EfSAkEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYEVxIggbaiAQNgIAIAcgCGohByAOQQRqIg4gG0kNAAsLIAEgC0cEQCAPQQRrIg8gB0ECdGogDigCADYCACAOQQRqIQ4gASELDAELCyAHQQJ0IggEQCAAIAIgCPwKAAALIAEgB2shCQJAIAEgB0YNAEEAIQogCUEETwRAIAAgCGohDiAYICJqIQ8gCUF8cSIKIQsDQCAOIA/9AAIA/QwAAAAAAAAAAAAAAAAAAAAA/Q0MDQ4PCAkKCwQFBgcAAQID/QsCACAPQRBrIQ8gDkEQaiEOIAtBBGsiCw0ACyAJIApGDQELICEgGCAKQQJ0IgtraiEOIAAgC2ogCGohDyAKIAFrIAdqIQsDQCAPIA4oAgA2AgAgDkEEayEOIA9BBGohDyALQQFqIgsNAAsLIAdFDQAgASAHTw0CIB1BADYCGCAdQQE2AgwgHUGIgsgANgIIIB1CBDcCECAdQQhqQfSUwQAQjQgACyABIANLDQAgAiABQQJ0Ih5qIQ8gBigCACEUQQAhCyAAIQ4DQCAAIBJBA2siBUEAIAUgEk0bQQJ0aiIVIA5LBEAgFEEEaiIaKAIAIRMgESgCACEFIAYoAgBBBGohHANAAn8CQCATQQhqKAIAIgggBUsEQCAFQSRsIgwgE0EEaigCAGoiCi8BHCEIQQAhCUEAIAovAR4iB0H//wFxIg1BgPgBSw0CGkEAIAhB//8BcSIQQYD4AUsNAhogB8FBAEgNASAHIAhLIAjBQQBODQIaIAcgEHJBAEcMAgsgBSAIQdTAxwAQjAcACyAIwUEASCAHIAhJcQshECAHIAggEBsgCCANQYH4AUkbIQgCQCAKLwEgIgdB//8BcSIQQYD4AUsNACAIQf//AXEiDUGA+AFLDQAgB8FBAE4EQCAIwUEATgRAIAcgCEH//wNxSyEJDAILIAcgDXJBAEchCQwBCyAIwUEASCAHIAhB//8DcUlxIQkLIA4oAgAhDSAKLwEUIQoCfyAHIAggCRsgCCAQQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQggB0GAgAJxIQkgB0GA+AFxIgdBgPgBRgRAIAlBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgCUEQdCIJIAdBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgBw0AGiAJQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAKQRB0IApB//8BcUUNABogCkH/B3EhCCAKQYCAAnEhByAKQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIBooAgAiCEEIaigCACIHIA1LBEAgCEEEaigCACANQSRsaiIKLwEcIQhBACEJQQAgCi8BHiIHQf//AXEiEEGA+AFLDQIaQQAgCEH//wFxIhhBgPgBSw0CGiAHwUEASA0BIAcgCEsgCMFBAE4NAhogByAYckEARwwCCyANIAdB1MDHABCMBwALIAjBQQBIIAcgCElxCyEYIAcgCCAYGyAIIBBBgfgBSRshCAJAIAovASAiB0H//wFxIhBBgPgBSw0AIAhB//8BcSIYQYD4AUsNACAHwUEATgRAIAjBQQBOBEAgByAIQf//A3FLIQkMAgsgByAYckEARyEJDAELIAjBQQBIIAcgCEH//wNxSXEhCQsgCi8BFCEKIAtBAnQgAiAPQQRrICQgJJIgI5QiIyAjXCAjAn8gByAIIAkbIAggEEGB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEIIAdBgIACcSEJIAdBgPgBcSIHQYD4AUYEQCAJQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAlBEHQiCSAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAcNABogCUGAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+EIkEIiQgJJICfyAKQRB0IApB//8BcUUNABogCkH/B3EhCCAKQYCAAnEhByAKQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILviIkQwAAgD9eBH0gJBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlGByIh8baiANNgIAAn8CQCAcKAIAIghBCGoiGCgCACIQIAVLBEAgCEEEaiIbKAIAIhYgDGoiCS8BHCEIQQAhCkEAIAkvAR4iB0H//wFxIg1BgPgBSw0CGkEAIAhB//8BcSIXQYD4AUsNAhogB8FBAEgNASAHIAhLIAjBQQBODQIaIAcgF3JBAEcMAgsgBSAQQdTAxwAQjAcACyAIwUEASCAHIAhJcQshFyAHIAggFxsgCCANQYH4AUkbIQgCQCAJLwEgIgdB//8BcSIXQYD4AUsNACAIQf//AXEiDUGA+AFLDQAgB8FBAE4EQCAIwUEATgRAIAcgCEH//wNxSyEKDAILIAcgDXJBAEchCgwBCyAIwUEASCAHIAhB//8DcUlxIQoLIA5BBGooAgAhDSAJLwEUIQkCfyAHIAggChsgCCAXQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQggB0GAgAJxIQogB0GA+AFxIgdBgPgBRgRAIApBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgCkEQdCIKIAdBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgBw0AGiAKQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74QiQQhJEMAAIA/ISMCfyAJQRB0IAlB//8BcUUNABogCUH/B3EhCCAJQYCAAnEhByAJQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgCEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILviIlQwAAgD9eBEAgJRDGBUNU+C1AlEMAAIA/kpEhIwsCfwJAIA0gEEkEQCAWIA1BJGxqIgovARwhB0EAIQhBACAKLwEeIglB//8BcSIQQYD4AUsNAhpBACAHQf//AXEiFkGA+AFLDQIaIAnBQQBIDQEgByAJSSAHwUEATg0CGiAJIBZyQQBHDAILIA0gEEHUwMcAEIwHAAsgB8FBAEggByAJS3ELIRYgCSAHIBYbIAcgEEGB+AFJGyEHAkAgCi8BICIJQf//AXEiEEGA+AFLDQAgB0H//wFxIhZBgPgBSw0AIAnBQQBOBEAgB8FBAE4EQCAJIAdB//8DcUshCAwCCyAJIBZyQQBHIQgMAQsgB8FBAEggCSAHQf//A3FJcSEICyAKLwEUIQogCyAfaiIfQQJ0IAIgD0EIayAkICSSICOUIiMgI1wgIwJ/IAkgByAIGyAHIBBBgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCyAHQYD4AXEiB0GA+AFGBEAgC0EQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyALQRB0IgsgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAtBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCIkICSSAn8gCkEQdCAKQf//AXFFDQAaIApB/wdxIQggCkGAgAJxIQcgCkGA+AFxIgtBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAtBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCw0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJEMAAIA/XgR9ICQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgciIQG2ogDTYCAAJ/AkAgGCgCACIJIAVLBEAgGygCACIWIAxqIgsvARwhCEEAIQpBACALLwEeIgdB//8BcSINQYD4AUsNAhpBACAIQf//AXEiF0GA+AFLDQIaIAfBQQBIDQEgByAISyAIwUEATg0CGiAHIBdyQQBHDAILIAUgCUHUwMcAEIwHAAsgCMFBAEggByAISXELIRcgByAIIBcbIAggDUGB+AFJGyEIAkAgCy8BICIHQf//AXEiF0GA+AFLDQAgCEH//wFxIg1BgPgBSw0AIAfBQQBOBEAgCMFBAE4EQCAHIAhB//8DcUshCgwCCyAHIA1yQQBHIQoMAQsgCMFBAEggByAIQf//A3FJcSEKCyAOQQhqKAIAIQ0gCy8BFCELAn8gByAIIAobIAggF0GB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEIIAdBgIACcSEKIAdBgPgBcSIHQYD4AUYEQCAKQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIApBEHQiCiAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAcNABogCkGAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gC0EQdCALQf//AXFFDQAaIAtB/wdxIQggC0GAgAJxIQcgC0GA+AFxIgtBgPgBRgRAIAdBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgB0EQdCIHIAtBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgCw0AGiAHQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAJIA1LBEAgFiANQSRsaiIJLwEcIQdBACEIQQAgCS8BHiILQf//AXEiCkGA+AFLDQIaQQAgB0H//wFxIhZBgPgBSw0CGiALwUEASA0BIAcgC0kgB8FBAE4NAhogCyAWckEARwwCCyANIAlB1MDHABCMBwALIAfBQQBIIAcgC0txCyEWIAsgByAWGyAHIApBgfgBSRshBwJAIAkvASAiC0H//wFxIgpBgPgBSw0AIAdB//8BcSIWQYD4AUsNACALwUEATgRAIAfBQQBOBEAgCyAHQf//A3FLIQgMAgsgCyAWckEARyEIDAELIAfBQQBIIAsgB0H//wNxSXEhCAsgCS8BFCEJIBAgH2oiEEECdCACIA9BDGsgJCAkkiAjlCIjICNcICMCfyALIAcgCBsgByAKQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQggB0GAgAJxIQsgB0GA+AFxIgdBgPgBRgRAIAtBEHQiB0GAgID8B3IgCEUNARogByAIQQ10ckGAgID+B3IMAQsgC0EQdCILIAdBDXRBgICA/ABxIAhBDXRyQYCAgMADanIgBw0AGiALQYCAgNgDciAIZ0EQayIHQRd0ayAIIAdB//8DcUEIanRB////A3FyC74QiQQiJCAkkgJ/IAlBEHQgCUH//wFxRQ0AGiAJQf8HcSEIIAlBgIACcSEHIAlBgPgBcSILQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAdBEHQiByALQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EfSAkEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYHIiHxtqIA02AgACfwJAIBgoAgAiDSAFSwRAIAwgGygCACIYaiILLwEcIQhBACEJQQAgCy8BHiIHQf//AXEiCkGA+AFLDQIaQQAgCEH//wFxIgxBgPgBSw0CGiAHwUEASA0BIAcgCEsgCMFBAE4NAhogByAMckEARwwCCyAFIA1B1MDHABCMBwALIAjBQQBIIAcgCElxCyEMIAcgCCAMGyAIIApBgfgBSRshCAJAIAsvASAiB0H//wFxIgxBgPgBSw0AIAhB//8BcSIKQYD4AUsNACAHwUEATgRAIAjBQQBOBEAgByAIQf//A3FLIQkMAgsgByAKckEARyEJDAELIAjBQQBIIAcgCEH//wNxSXEhCQsgDkEMaigCACEKIAsvARQhCwJ/IAcgCCAJGyAIIAxBgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCSAHQYD4AXEiB0GA+AFGBEAgCUEQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAlBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCElQwAAgD8hIwJ/IAtBEHQgC0H//wFxRQ0AGiALQf8HcSEIIAtBgIACcSEHIAtBgPgBcSILQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAdBEHQiByALQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EQCAkEMYFQ1T4LUCUQwAAgD+SkSEjCwJ/AkAgCiANSQRAIBggCkEkbGoiCy8BHCEIQQAhCUEAIAsvAR4iB0H//wFxIg1BgPgBSw0CGkEAIAhB//8BcSIMQYD4AUsNAhogB8FBAEgNASAHIAhLIAjBQQBODQIaIAcgDHJBAEcMAgsgCiANQdTAxwAQjAcACyAIwUEASCAHIAhJcQshDCAHIAggDBsgCCANQYH4AUkbIQgCQCALLwEgIgdB//8BcSINQYD4AUsNACAIQf//AXEiDEGA+AFLDQAgB8FBAE4EQCAIwUEATgRAIAcgCEH//wNxSyEJDAILIAcgDHJBAEchCQwBCyAIwUEASCAHIAhB//8DcUlxIQkLIAsvARQhCwJ/IAcgCCAJGyAIIA1BgfgBSRsiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCCAHQYCAAnEhCSAHQYD4AXEiB0GA+AFGBEAgCUEQdCIHQYCAgPwHciAIRQ0BGiAHIAhBDXRyQYCAgP4HcgwBCyAJQRB0IgkgB0ENdEGAgID8AHEgCEENdHJBgICAwANqciAHDQAaIAlBgICA2ANyIAhnQRBrIgdBF3RrIAggB0H//wNxQQhqdEH///8DcXILvhCJBCEmQwAAgD8hJAJ/IAtBEHQgC0H//wFxRQ0AGiALQf8HcSEIIAtBgIACcSEHIAtBgPgBcSILQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQEaIAcgCEENdHJBgICA/gdyDAELIAdBEHQiByALQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2pyIAsNABogB0GAgIDYA3IgCGdBEGsiB0EXdGsgCCAHQf//A3FBCGp0Qf///wNxcgu+IidDAACAP14EQCAnEMYFQ1T4LUCUQwAAgD+SkSEkCyAQIB9qIghBAnQgAiAPQRBrIg8gJSAlkiAjlCIjICNcICMgJiAmkiAklGByIgcbaiAKNgIAIAcgCGohCyAOQRBqIg4gFUkNAAsLIAAgEkECdGoiEyAOSwRAIBRBBGooAgAhECARKAIAIQ0DQAJ/AkAgEEEIaigCACIMIA1LBEAgEEEEaigCACIYIA1BJGxqIgkvARwhBUEAIQdBACAJLwEeIghB//8BcSIKQYD4AUsNAhpBACAFQf//AXEiG0GA+AFLDQIaIAjBQQBIDQEgBSAISSAFwUEATg0CGiAIIBtyQQBHDAILIA0gDEHUwMcAEIwHAAsgBcFBAEggBSAIS3ELIRsgCCAFIBsbIAUgCkGB+AFJGyEFAkAgCS8BICIIQf//AXEiG0GA+AFLDQAgBUH//wFxIgpBgPgBSw0AIAjBQQBOBEAgBcFBAE4EQCAIIAVB//8DcUshBwwCCyAIIApyQQBHIQcMAQsgBcFBAEggCCAFQf//A3FJcSEHCyAOKAIAIQogCS8BFCEJAn8gCCAFIAcbIAUgG0GB+AFJGyIIQf//AXFFBEAgCEEQdAwBCyAIQf8HcSEFIAhBgIACcSEHIAhBgPgBcSIIQYD4AUYEQCAHQRB0IghBgICA/AdyIAVFDQEaIAggBUENdHJBgICA/gdyDAELIAdBEHQiByAIQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2pyIAgNABogB0GAgIDYA3IgBWdBEGsiCEEXdGsgBSAIQf//A3FBCGp0Qf///wNxcgu+EIkEISRDAACAPyEjAn8gCUEQdCAJQf//AXFFDQAaIAlB/wdxIQUgCUGAgAJxIQggCUGA+AFxIgdBgPgBRgRAIAhBEHQiCEGAgID8B3IgBUUNARogCCAFQQ10ckGAgID+B3IMAQsgCEEQdCIIIAdBDXRBgICA/ABxIAVBDXRyQYCAgMADanIgBw0AGiAIQYCAgNgDciAFZ0EQayIIQRd0ayAFIAhB//8DcUEIanRB////A3FyC74iJUMAAIA/XgRAICUQxgVDVPgtQJRDAACAP5KRISMLAn8CQCAKIAxJBEAgGCAKQSRsaiIHLwEcIQVBACEJQQAgBy8BHiIIQf//AXEiDEGA+AFLDQIaQQAgBUH//wFxIhhBgPgBSw0CGiAIwUEASA0BIAUgCEkgBcFBAE4NAhogCCAYckEARwwCCyAKIAxB1MDHABCMBwALIAXBQQBIIAUgCEtxCyEYIAggBSAYGyAFIAxBgfgBSRshBQJAIAcvASAiCEH//wFxIgxBgPgBSw0AIAVB//8BcSIYQYD4AUsNACAIwUEATgRAIAXBQQBOBEAgCCAFQf//A3FLIQkMAgsgCCAYckEARyEJDAELIAXBQQBIIAggBUH//wNxSXEhCQsgBy8BFCEHIAtBAnQgAiAPQQRrIg8gJCAkkiAjlCIjICNcICMCfyAIIAUgCRsgBSAMQYH4AUkbIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQUgCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgBUUNARogCCAFQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIAVBDXRyQYCAgMADanIgCA0AGiAJQYCAgNgDciAFZ0EQayIIQRd0ayAFIAhB//8DcUEIanRB////A3FyC74QiQQiJCAkkgJ/IAdBEHQgB0H//wFxRQ0AGiAHQf8HcSEFIAdBgIACcSEIIAdBgPgBcSIHQYD4AUYEQCAIQRB0IghBgICA/AdyIAVFDQEaIAggBUENdHJBgICA/gdyDAELIAhBEHQiCCAHQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2pyIAcNABogCEGAgIDYA3IgBWdBEGsiCEEXdGsgBSAIQf//A3FBCGp0Qf///wNxcgu+IiRDAACAP14EfSAkEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYHIiBRtqIAo2AgAgBSALaiELIA5BBGoiDiATSQ0ACwsgASASRwRAIAIgC0ECdGogDigCADYCACAOQQRqIQ4gC0EBaiELIA9BBGshDyABIRIMAQsLIAtBAnQiBQRAIAAgAiAF/AoAAAsgASALRg0EIAAgBWohCEEAIQoCQCABIAtrIgdBBE8EQCAeICJqIQ4gCCEPIAdBfHEiCiEJA0AgDyAO/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgDkEQayEOIA9BEGohDyAJQQRrIgkNAAsgByAKRg0BCyAhIApBAnQiEmsgHmohDiAAIBJqIAVqIQ8gCiABayALaiEJA0AgDyAOKAIANgIAIA5BBGshDiAPQQRqIQ8gCUEBaiIJDQALCyABIAtPBEBBACEFIAghACAHIQEgB0EhSQ0EDAMLIAsgASABQYSVwQAQ6gcACwALIAAgCGogCSACIAMgBCAdQQRqIAYQMyAHIQEgB0EhTw0ACyAAIQgLIAdBAkkNACAGKAIAIQEgB0EBdiEAIAACfyAHQQ9NBEAgB0EHSwRAIAggAiABQQRqIgMoAgAQhgEgCCAAQQJ0IgRqIAIgBGogAygCABCGAUEEDAILIAIgCCgCADYCACACIABBAnQiA2ogAyAIaigCADYCAEEBDAELIAggAiAHQQJ0aiIDIAFBBGoiBCgCABCGASAIQRBqIANBEGogBCgCABCGASADQQggAiABEOQBIAggAEECdCIFaiIGIANBIGoiEiAEKAIAEIYBIAZBEGogA0EwaiAEKAIAEIYBIBJBCCACIAVqIAEQ5AFBCAsiA0sEQCAAIANrIQ8gA0ECdCEOA0AgAiAOaiIEIAggDmooAgA2AgAgAiAEIAEQ+gEgDkEEaiEOIA9BAWsiDw0ACwsgByAAayADSwRAIAIgAEECdCIEaiEFIAggA0ECdCAEaiIEaiEPIAIgBGohDiAAIANqIAdrIQkDQCAOIA8oAgA2AgAgBSAOIAEQ+gEgD0EEaiEPIA5BBGohDiAJQQFqIgkNAAsLIAIgByAIIAEQ5AELIB1BIGokAAv5vAICd38EfiMAQbAZayIEJAAgBEEAOgDKDCAEQQA7AcgMIAEpA+ADIXkgASgC6AMhC0EDIRUgBEHIDGohCAJAAkACQAJAAkACfwJAA0ACQCB5UARAQgAheQwBCyALKQMIInogCygCBCIHrSJ7IHoge1QbpyICIAsoAgBqIQkCQCAHQv////8PIHogekL/////D1obp2siA0EAIAMgB00bIgMgeSAVrSJ7IHkge1QbpyIOIAMgDkkbIgNBAUYEQCAIIAktAAA6AAAMAQsgA0UNACAIIAkgA/wKAAALIAEgeSADrSJ7fSJ5NwPgAyALIHoge3w3AwggAiAHRg0AIAMgCGohCCAVIANrIhUNAQwCCwtBqJDIACkDACJ6Qv8Bg0IEUQ0AIHpCIIinIhIgeqciA0H/AXFBBEYNARogekIQiKchFSB6QgiIpyEIQQAhCwwCCyAELwHIDCAELQDKDEEQdHILIRJBASEJIAEgEkEBdkEHcToAKyABIBJBAXEiA0U6ACggASASQQR2QQFxOgApAkACQAJAAkACQAJAAkAgAw0AIARBADoA2hggBEEAOwHYGCABKALoAyELQQMhFSAEQdgYaiEIAkADQAJAIHlQBEBCACF5DAELIAspAwgieiALKAIEIgetInsgeiB7VBunIgIgCygCAGohEAJAIAdC/////w8geiB6Qv////8PWhunayIDQQAgAyAHTRsiAyB5IBWtInsgeSB7VBunIg4gAyAOSRsiA0EBRgRAIAggEC0AADoAAAwBCyADRQ0AIAggECAD/AoAAAsgASB5IAOtInt9Ink3A+ADIAsgeiB7fDcDCCACIAdGDQAgAyAIaiEIIBUgA2siFQ0BDAILC0EAIQtBqJDIACkDACJ6pyIDQf8BcUEERg0AIHpCIIinIRIgekIQiKchFSB6QgiIpyEIDAgLIAECfwJAAkACQAJ/AkACQCAELwHYGCAELQDaGEEQdHIiB0Gdg6gBRgRAIARBADsByAwgASgC6AMhC0ECIRUgBEHIDGohCANAIHlQBEBCACF5DAMLIAspAwgieiALKAIEIgetInsgeiB7VBunIgIgCygCAGohEAJAIAdC/////w8geiB6Qv////8PWhunayIDQQAgAyAHTRsiAyB5IBWtInsgeSB7VBunIg4gAyAOSRsiA0EBRgRAIAggEC0AADoAAAwBCyADRQ0AIAggECAD/AoAAAsgASB5IAOtInt9Ink3A+ADIAsgeiB7fDcDCCACIAdGDQIgAyAIaiEIIBUgA2siFQ0ACwwCCyAHQQh2IQJBESELDA4LQaiQyAApAwAiekL/AYNCBFENACB6QhCIpyEVIHqnIgNB/wFxQQRHDQIgFQwBCyAELwHIDAshESAEQQA7AcgMIAEoAugDIQtBAiEVIARByAxqIQgDQCB5UA0CIAspAwgieiALKAIEIgetInsgeiB7VBunIgIgCygCAGohEAJAIAdC/////w8geiB6Qv////8PWhunayIDQQAgAyAHTRsiAyB5IBWtInsgeSB7VBunIg4gAyAOSRsiA0EBRgRAIAggEC0AADoAAAwBCyADRQ0AIAggECAD/AoAAAsgASB5IAOtInt9Ink3A+ADIAsgeiB7fDcDCCACIAdGDQIgAyAIaiEIIBUgA2siFQ0ACwwCCyB6QgiIpyEIIHpCIIinIRJBACELDAoLQaiQyAApAwAieUL/AYNCBFENACB5QhCIpyIVIHmnIgNB/wFxQQRGDQEaIHlCCIinIQggeUIgiKchEkEAIQsMCQsgBC8ByAwLQf//AHE7ASYgASARQf//AHEiCDsBJCAIQQ9qQQR2IQICfyAIRQRAQQEhFUEADAELIAJBHmwQcSIVRQ0CIBUhAwJAIAhBEUkNACACQQFrIhBBB3EhCyACQQJrQQdPBEAgEEF4cSEHA0AgA/0MAAAAAAAAAAAAAAAAAAAAAP0LAAAgA0EQakIANwAAIANBFmr9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIANBJmr9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIANBNGr9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIANBxABq/QwAAAAAAAAAAAAAAAAAAAAA/QsAACADQdIAav0MAAAAAAAAAAAAAAAAAAAAAP0LAAAgA0HiAGr9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIANB8ABqQgA3AAAgA0GIAWpCADcAACADQY4BakIANwAAIANB+ABq/QwAAAAAAAAAAAAAAAAAAAAA/QsAACADQaYBakIANwAAIANBrAFqQgA3AAAgA0GWAWr9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIANBxAFqQgA3AAAgA0HKAWpCADcAACADQbQBav0MAAAAAAAAAAAAAAAAAAAAAP0LAAAgA0HoAWpCADcAACADQeIBakIANwAAIANB0gFq/QwAAAAAAAAAAAAAAAAAAAAA/QsAACADQfABaiEDIAdBCGsiBw0ACwsgC0UNAANAIAP9DAAAAAAAAAAAAAAAAAAAAAD9CwAAIANBFmpCADcAACADQRBqQgA3AAAgA0EeaiEDIAtBAWsiCw0ACwsgA/0MAAAAAAAAAAAAAAAAAAAAAP0LAAAgA0EWakIANwAAIANBEGpCADcAACACCyEDIAEoApwEIgsEQCABKAKgBCIOQQRrKAIAIhBBeHEiESALQR5sIgtBBEEIIBBBA3EiEBtqSQ0LIBBBACARIAtBJ2pLGw0MIA4QogILIAEgAjYCpAQgASAVNgKgBCABIAM2ApwEAn8CQCAIRQ0AIBUtAAAiA0ECRg0AIARBMGogFUEcai0AADoAACAEIBX9AAAE/QsDyAwgBCAVKQAUNwMoIBUtAAEhCyAVLQACIQcgFS0AAyEIIBUtAB0MAQsgBEEwakEAOgAAIAT9DAAAAAAAAAAAAAAAAAAAAAD9CwPIDCAEQgA3AyhBACEIQQAhB0EAIQtBACEDQQALIRUgASAIOgCFBSABIAc6AIQFIAEgCzoAgwUgASADOgCCBSABIAT9AAPIDP0LAIYFIAEgBCkDKDcAlgUgASAVOgCfBSABQZ4FaiAEQTBqLQAAOgAAIAEgAS8BJCIDQQR2IANBD3FBAEdqIgM7AaAFIAEgAS8BJiILQQR2IAtBD3FBAEdqIgs7AaIFAkACQCADIAtsQQh0IgNBAE4EQAJAIANFBEBBASELDAELIAMQcSILRQ0FIAtBBGstAABBA3FFIANFcg0AIAtBACAD/AsACyABKAIAIhUEQCABKAIEIghBBGsoAgAiEEF4cSICQQRBCCAQQQNxIhAbIBVqSQ0OIBBBACACIBVBJ2pLGw0PIAgQogILIAEgAzYCCCABIAs2AgQgASADNgIAIAEvAaAFIAEvAaIFbEEGdCIDQQBIDQECQCADRQRAQQEhCwwBCyADEHEiC0UNBSALQQRrLQAAQQNxRSADRXINACALQQAgA/wLAAsgASgCDCIVBEAgASgCECAVQQEQogcLIAEgAzYCFCABIAs2AhAgASADNgIMIAEvAaAFIAEvAaIFbEEGdCIDQQBIDQICQCADRQRAQQEhCwwBCyADEHEiC0UNBSALQQRrLQAAQQNxRSADRXINACALQQAgA/wLAAsgASgCGCIVBEAgASgCHCAVQQEQogcLIAEgAzYCICABIAs2AhwgASADNgIYIAEvASRBFGoiAxBxIgtFDQQgAwRAIAtB/wAgA/wLAAsgASgCqAQiFQRAIAEoAqwEIBVBARCiBwsgASADNgKwBCABIAs2AqwEIAEgAzYCqARBERBxIgNFDQQgA0KBg4aMmLDgwIF/NwAAIANBEGpBgQE6AAAgA0EIakKBg4aMmLDgwIF/NwAAIAEoArQEIgsEQCABKAK4BCALQQEQogcLIAFBETYCvAQgASADNgK4BCABQRE2ArQEIAEvAaAFIgtBA3QhAwJAIAtFBEBBASELDAELIAMQcSILRQ0FCyADBEAgC0H/ACAD/AsACyABKALABCIVBEAgASgCxAQgFUEBEKIHCyABIAM2AsgEIAEgCzYCxAQgASADNgLABEEJEHEiA0UNBCADQoGDhoyYsODAgX83AAAgA0EIakGBAToAACABKALMBCILBEAgASgC0AQgC0EBEKIHCyABQQk2AtQEIAEgAzYC0AQgAUEJNgLMBCABLwGgBSILQQN0IQMCQCALRQRAQQEhCwwBCyADEHEiC0UNBQsgAwRAIAtB/wAgA/wLAAsgASgC2AQiBwRAIAEoAtwEIAdBARCiBwsgASADNgLgBCABIAs2AtwEIAEgAzYC2ARBCRBxIgNFDQQgA0KBg4aMmLDgwIF/NwAAIANBCGpBgQE6AAAgASgC5AQiCwRAIAEoAugEIAtBARCiBwsgAUEJNgLsBCABIAM2AugEIAFBCTYC5AQMAwtB7KzGABD/BwALQfysxgAQ/wcAC0GMrcYAEP8HAAsgEkEHdiASQeAAcUEAR2oiCkECdCERAkAgCkUNACAREHEiCUUNASAJQQRrLQAAQQNxRSARRXINACAJQQAgEfwLAAsCQAJAAkACQCARIBJBBXYiEE8EQCASQSBJDQIgASkD4AMheSABKALoAyELIAkhCCAQIRUDQCB5UA0CIAspAwgieiALKAIEIgetInsgeiB7VBunIgIgCygCAGohEgJAIAdC/////w8geiB6Qv////8PWhunayIDQQAgAyAHTRsiAyB5IBWtInsgeSB7VBunIg4gAyAOSRsiA0EBRgRAIAggEi0AADoAAAwBCyADRQ0AIAggEiAD/AoAAAsgASB5IAOtInt9Ink3A+ADIAsgeiB7fDcDCCACIAdGDQIgAyAIaiEIIBUgA2siFQ0ACwwCC0EAIBAgEUGwrcYAEOoHAAtBACELQaiQyAApAwAieaciA0H/AXFBBEYNACB5QiCIpyESIHlCEIinIRUgeUIIiKchCCAKDQEMCQsgBCAKNgIwIAQgCTYCLCAEIAo2AiggBEHIDGogAUHwAGoiFSAEQShqIBAQsgMgBC0AyAwiC0EdRg0BIAQ1AM0MInkgBEHTDGoxAABCMIYgBEHRDGozAABCIIaEhCJ6QhiIpyESIHpCCIinIRUgBCgC1AwhDiAELQDMDCEDIAQvAcoMIQIgBC0AyQwhByB5pyEIDAgLIAlBBGsoAgAiBkF4cSICQQRBCCAGQQNxIgcbIBFqSQ0KIAdBACACIBFBJ2pLGw0LIAkQogIMBwsCQCABLQAoRQ0AIBVBARC5ASEHIAEgFUEBELkBOgAsIAdB/wFxRQ0AQRMhCwwHCyABIBUQqgUiAzoApAUCQCADRQ0AIAEgFRCqBToApQUgFRCqBQRAIAEgFRCqBUEBcyIDOgBuIAEgAzoAXiABIAM6AE4gASADOgA+IAEgFUEHEK8BOgA8IAEgFUEHEK8BOgBMIAEgFUEHEK8BOgBcIAEgFUEHEK8BOgBsIAEgFUEGEK8BOgA9IAEgFUEGEK8BOgBNIAEgFUEGEK8BOgBdIAEgFUEGEK8BOgBtCyABLQClBUEBRgRAQf8BIQMgASAVEKoFBH8gFUEIELkBBUH/AQs6APYEIAEgFRCqBQR/IBVBCBC5AQVB/wELOgD6BCAVEKoFBEAgFUEIELkBIQMLIAEgAzoA/gQLIAEtAJMBQfIBRw0AQQ8hCwwGCyABIBUQqgU6ACogASAVQQYQuQE6AC0gASAVQQMQuQE6AC4gASAVEKoFIgM6AKYFAkACQAJAIANFDQAgFRCqBQRAIAEgFUEGEK8BNgLwAyABIBVBBhCvATYC9AMgASAVQQYQrwE2AvgDIAEgFUEGEK8BNgL8AyABIBVBBhCvATYCgAQgASAVQQYQrwE2AoQEIAEgFUEGEK8BNgKIBCABIBVBBhCvATYCjAQLIAEtAJMBQfIBRw0AQQ8hCwwBCyAVQQIQuQEhA0EPIQsgAS0AkwFB8gFGDQcgAUEBIAN0Ihg6AKcFAkAgA0EfcSIPRQ0AAkACQEEDIA90QQNrIgNBAE4EQCADEHEiEUUNBiARQQRrLQAAQQNxRSADRXJFBEAgEUEAIAP8CwALIAEpA+ADIXkgASgC6AMhByARIQ4gAyECAkADQCB5UA0BIAcpAwgieiAHKAIEIgitInsgeiB7VBunIgogBygCAGohEAJAIAhC/////w8geiB6Qv////8PWhunayIJQQAgCCAJTxsiCSB5IAKtInsgeSB7VBunIg0gCSANSRsiCUEBRgRAIA4gEC0AADoAAAwBCyAJRQ0AIA4gECAJ/AoAAAsgASB5IAmtInt9Ink3A+ADIAcgeiB7fDcDCCAIIApGDQEgCSAOaiEOIAIgCWsiAg0AC0GokMgAKQMAInpC/wGDQgRRIQwMAgtBASEMQaiQyAApAwAiekL/AYNCBFENAUEAIQsMAgtBuKnGABD/BwALIAFBmAFqISYgESEZIAMhDQJAA0ACQCANQQJNBEAgDARAQQEhCUEAIQpBACEIQQAhEAwCCyAEIHo3A8gMQaiqxgBBNyAEQcgMakGYqsYAQeCqxgAQ4AYACyAZLwAAIBlBAmotAABBEHRyIghBA2oiCUECdiEKAn8gCUH8//8PcSIURQRAQQEhCUEADAELIBQQcSIJRQ0IIAlBBGstAABBA3FFIBRFckUEQCAJQQAgFPwLAAsgCgshECAIIBRNBEAgCEUEQEEAIQpBACEIDAILIAEpA+ADIXkgASgC6AMhByAJIQ4gCCECA0ACQCB5UA0AIAcpAwgieyAHKAIEIhKtInwgeyB8VBunIiIgBygCAGohFgJAIBJC/////w8geyB7Qv////8PWhunayIUQQAgEiAUTxsiFCB5IAKtInwgeSB8VBunIhsgFCAbSRsiFEEBRgRAIA4gFi0AADoAAAwBCyAURQ0AIA4gFiAU/AoAAAsgASB5IBStInx9Ink3A+ADIAcgeyB8fDcDCCASICJGDQAgDiAUaiEOIAIgFGsiAg0BDAMLCyAMDQFBACELIBBFDQQgCSAQQQJ0QQEQogcMBAtBACAIIBRBiKrGABDqBwALIAVBCEYNASAEIAo2AuAYIAQgCTYC3BggBCAQNgLYGCAEQcgMaiAmIAVBKGxqIARB2BhqIAgQsgMgBC0AyAwiCUEdRwRAIAQoAtQMIQ4gBCkCzAwheiAELwHKDCECIAQtAMkMIQcgCSELDAMLIAVBAWohBSAZQQMgDSANQQNPGyIJaiEZIA0gCWsiDQ0ACyARIANBARCiBwwCC0EIQQhB+KnGABCMBwALIBEgA0EBEKIHIHqnIQMMBwsgBEEANgLgGCAEQoCAgIAQNwLYGCAEQcgMaiABQdgDaiAEQdgYahDzAQJAAkACQAJAAkACfwJAIAQtAMgMQQRGDQAgBCkDyAwieqciA0H/AXFBBEYNAEEADAELIAQoAuAYIgNBA2oiCUEASA0CIAlBAnYhAgJ/IAlBfHEiCUUEQEEBIQdBAAwBCyAJEHEiB0UNCSAHQQRrLQAAQQNxRSAJRXJFBEAgB0EAIAn8CwALIAILIQggBCACNgIwIAQgBzYCLCAEIAg2AiggAyAJSw0DIAQoAtwYIQkgAwRAIAcgCSAD/AoAAAsgGEEBayECIA9BBE8NBCAEQcgMaiABQZgBaiJdIAJBKGxqIARBKGogAxCyAyAELQDIDCIIQR1GDQEgBCgC1AwhDiAELwHKDCECIAQtAMkMIQcgBCkCzAwieqchAyAICyELIAQoAtgYIgZFDQsgBCgC3BggBkEBEKIHDAsLIAQoAtgYIgMEQCAJIANBARCiBwsgFUEHELkBIQMgFUEEEK8BIQggFUEEEK8BIQIgFUEEEK8BIQ4gFUEEEK8BIRIgFUEEEK8BIQkgAUH/ACABLAA8IANB/wFxIgdBACABLQA+G2ogByABLQCkBSIQGyIDQQAgA0EAShsiESARQf8AThtBAXQvAbjkRDsBMiABQf8AIAMgCWoiEUEAIBFBAEobIhEgEUH/AE4bQQF0LwG45EQ7ATogAUH/ACADIBJqIhFBACARQQBKGyIRIBFB/wBOG0EBdC4BuOZEIhE7ATggAUH/ACADIAhqIgpBACAKQQBKGyIKIApB/wBOG0EBdC8BuOZEOwEwIAFB/wAgAiADaiIKQQAgCkEAShsiCiAKQf8AThtBAXQvAbjmREEBdDsBNCABQf8AIAMgDmoiA0EAIANBAEobIgMgA0H/AE4bQQF0LgG45ERBmwFsQeQAbSIDOwE2IAPBQQdMBEAgAUEIOwE2CyARQYQBTA0DIAFBhAE7ATgMAwtByKnGABD/BwALQQAgAyAJQeipxgAQ6gcACyACQQhB2KnGABCMBwALAkAgEEUNACABQf8AIAEsAEwgB0EAIAEtAE4baiAHIAEtAKQFGyIDQQAgA0EAShsiECAQQf8AThtBAXQvAbjkRDsBQiABQf8AIAMgCWoiEEEAIBBBAEobIhAgEEH/AE4bQQF0LwG45EQ7AUogAUH/ACADIBJqIhBBACAQQQBKGyIQIBBB/wBOG0EBdC4BuOZEIhA7AUggAUH/ACADIAhqIhFBACARQQBKGyIRIBFB/wBOG0EBdC8BuOZEOwFAIAFB/wAgAiADaiIRQQAgEUEAShsiESARQf8AThtBAXQvAbjmREEBdDsBRCABQf8AIAMgDmoiA0EAIANBAEobIgMgA0H/AE4bQQF0LgG45ERBmwFsQeQAbSIDOwFGIAPBQQdMBEAgAUEIOwFGCyAQQYUBTgRAIAFBhAE7AUgLIAFB/wAgASwAXCAHQQAgAS0AXhtqIAcgAS0ApAUbIgNBACADQQBKGyIQIBBB/wBOG0EBdC8BuOREOwFSIAFB/wAgAyAJaiIQQQAgEEEAShsiECAQQf8AThtBAXQvAbjkRDsBWiABQf8AIAMgEmoiEEEAIBBBAEobIhAgEEH/AE4bQQF0LgG45kQiEDsBWCABQf8AIAMgCGoiEUEAIBFBAEobIhEgEUH/AE4bQQF0LwG45kQ7AVAgAUH/ACACIANqIhFBACARQQBKGyIRIBFB/wBOG0EBdC8BuOZEQQF0OwFUIAFB/wAgAyAOaiIDQQAgA0EAShsiAyADQf8AThtBAXQuAbjkREGbAWxB5ABtIgM7AVYgA8FBB0wEQCABQQg7AVYLIBBBhQFOBEAgAUGEATsBWAsgAUH/ACABLABsIAdBACABLQBuG2ogByABLQCkBRsiA0EAIANBAEobIhAgEEH/AE4bQQF0LwG45EQ7AWIgAUH/ACADIAlqIglBACAJQQBKGyIJIAlB/wBOG0EBdC8BuOREOwFqIAFB/wAgAyASaiIJQQAgCUEAShsiCSAJQf8AThtBAXQuAbjmRCIHOwFoIAFB/wAgAyAIaiIJQQAgCUEAShsiCSAJQf8AThtBAXQvAbjmRDsBYCABQf8AIAIgA2oiCUEAIAlBAEobIgggCEH/AE4bQQF0LwG45kRBAXQ7AWQgAUH/ACADIA5qIgNBACADQQBKGyIDIANB/wBOG0EBdC4BuOREQZsBbEHkAG0iAzsBZiADwUEHTARAIAFBCDsBZgsgB0GFAUgNACABQYQBOwFoCyABLQCTAUHyAUcNAQtBACEVQQAhEgwHCwJAAn8gAS0AKEUEQEETIQ5BExBxIgZFDQMgBkEPakGrrcYAKAAANgAAIAZBnK3GAP0AAAD9CwAAIAQgBjYCzAwgBEETNgLIDCAENQDJDCJ5IAQxAM8MQjCGIAQzAM0MQiCGhIQiekIYiKchEiB5pyEIIHpCCIinDAELIBVBARC5ARogBEHIDGpBACEKIAFB8ABqIQ1BoM/GACEJQZjNxgAhEANAIAkhESAKIQcgECEJQSEhFANAQfx+IRkDQCANIAktAAAQmQUEQCANQQgQuQEhBSABKALwBCAHaiAZakGGAWogBToAAAsgDSAJQQFqLQAAEJkFBEAgDUEIELkBIQUgASgC8AQgB2ogGWpBigFqIAU6AAALIA0gCUECai0AABCZBQRAIA1BCBC5ASEFIAEoAvAEIAdqIBlqQY4BaiAFOgAACyANIAlBA2otAAAQmQUEQCANQQgQuQEhBSABKALwBCAHaiAZakGSAWogBToAAAsgDSAJQQRqLQAAEJkFBEAgDUEIELkBIQUgASgC8AQgB2ogGWpBlgFqIAU6AAALIA0gCUEFai0AABCZBQRAIA1BCBC5ASEFIAEoAvAEIAdqIBlqQZoBaiAFOgAACyANIAlBBmotAAAQmQUEQCANQQgQuQEhBSABKALwBCAHaiAZakGeAWogBToAAAsgDSAJQQdqLQAAEJkFBEAgDUEIELkBIQUgASgC8AQgB2ogGWpBogFqIAU6AAALIA0gCUEIai0AABCZBQRAIA1BCBC5ASEFIAEoAvAEIAdqIBlqQaYBaiAFOgAACyANIAlBCWotAAAQmQUEQCANQQgQuQEhBSABKALwBCAHaiAZakGqAWogBToAAAsgDSAJQQpqLQAAEJkFBEAgDUEIELkBIQUgASgC8AQgB2ogGWpBrgFqIAU6AAALIAlBC2ohCSAZQSxqIhkNAAsgB0GEAWohByAQIBRqIQkgFEEhakGIAiAUQYgCRyIZGyEUIBkNAAsgCkGgCGohCiARQYgCaiEJIBEiEEG41cYARw0AC0EPQR0gAS0AkwFB8gFGGzoAACAELQDIDCIJQR1HBEAgBDUAzQwieSAEQdMMajEAAEIwhiAEQdEMajMAAEIghoSEInpCGIinIRIgekIIiKchFSAEKALUDCEOIAQtAMwMIQMgBC8BygwhAiAELQDJDCEHIHmnIQggCSELDAkLIBVBARC5AUH/AXEiB0EBRgRAIBVBCBC5ASEDCyABIAM6AIEFIAEgB0EBRjoAgAUgAS0AkwFB8gFGDQcgAS0AKA0BIAFBADoAqAVBEyEOQRMQcSIGRQ0CIAZBD2pBq63GACgAADYAACAGQZytxgD9AAAA/QsAACAEIAY2AswMIARBEzYCyAwgBDUAyQwieSAEMQDPDEIwhiAEMwDNDEIghoSEInpCGIinIRIgeachCCB6QgiIpwshFUEYIQtBEyEDDAcLIAEvAaIFIkpFDQMgAUEwaiE6IAFBkARqIRkgAUH0BGohFyABQZYFaiEcIAFBhgVqIUcgAUGCBWohJyAEQZENaiFLIARBiA1qIRggBEH/DGohTCAEQfYMaiFNIARB7QxqIU4gBEHkDGohTyAEQdsMaiEoIARBoRlqIVAgBEGYGWohUSAEQY8ZaiFSIARBhhlqIVMgBEH9GGohVCAEQfQYaiFVIARB6xhqIVYgBEGZD2ohKSAEQYQPaiEqIARB7w5qISsgBEHaDmohLCAEQcUOaiEtIARBsA5qIRMgBEGbDmohLiAEQYYOaiEvIARB8Q1qITAgBEHcDWohMSAEQccNaiEyIARBsg1qITMgBEGdDWohNCAEQfMMaiE1IARB0gxqIVcgBEHiGGohWCAEQegLaiFZIARB6AlqIVogBEGoC2ohICAEQagJaiEhIARB6ApqIV4gBEHoCGohXyAEQagKaiFgIARBqAhqIWEgBEHeDGohNiAEQegHaiFiIARBqAdqIWMgBEHoBmohZCAEQagGaiFlIARB6AVqIWYgBEGoBWohZyAEQegEaiFoIARBqARqIWkgBEHoA2ohaiAEQagDaiFrIARB6AJqIWwgBEGoAmohbSAEQegBaiFuIARBqAFqIW8gBEHoAGohcCAEQThqIXEgBEEoakECciFIIARB2AxqITwgBEHIDGpBAnIhPSAEQR1qIT4gBEEOaiEUIARBzwxqIQwgBEHMDGohciAEQckMaiI/QRVqIXMgBEGIGWohdEEBIQNBACEQA0AgAS0ApwUiC0UNAiADIREgJ/0MAAAAAAAAAAAAAAAAAAAAAP0LAQAgJ0EWakIANwEAICdBEGpCADcBACAQIAtwIQ8CQCABLwGgBSJ1RQ0AQQEhN0EAISZBACEKAkACQAJAAkACQAJAAkACQANAIHNCADcAACA/QRBqQgA3AAAgP/0MAAAAAAAAAAAAAAAAAAAAAP0LAAACQCABLQCkBUEBRw0AIAEtAKUFQQFxRQ0AIAQgFSAXQQMgFygCABDIBDoA5QwLIAQgAS0AgAUEfyAVIAEtAIEFEJkFBUEACzoAyAwCQAJAAkACQAJ/AkACQCABLQAoDQAgFSABLQCoBRCZBUUEQEEAIQlBACELIAEtACgNAQwCC0EUIThBFBBxIhpFDRIgGkEQakGYsMYAKAAANgAAIBpBiLDGAP0AAAD9CwAAQRQhOUEYDAILIBVBnLDGAEEEQYSDxAQQyAQhAyAEQRQ6ACggBCADQf8BcSIJOgApIAlBBU8EQCAJIQZBFAwCCyAEQShqEKsEIAQgCToAywxBAiEDAkACQAJAAkACQAJAAkACQCAJQQFrDgQDAAEEAgtBAyEDDAILQQEhAwwBC0EAIQMLIEcgA0GBgoQIbCIDNgEAIDwgAzYAAAwBC0EAIQ4gCkEebCEIIAwhCwNAIAogASgCpAQiAk8NAiAVIAEoAqAEIAhqLQAQQegCbCAOIEdqIgctAABBJGxqIgNBvLDGAGpBCSADKAC8sEYQyAQhAyAEQRU6ACggBCADQf8BcSIDOgApIANBCUsEQCADIQZBFQwGCyAEQShqEKsEIAtBA2tBCiADIANBCk8bIgM6AAAgCiABKAKkBCICTw0DIAEoAqAEIAhqIAM6ABAgByADOgAAIAogASgCpAQiAk8NAiAVIAEoAqAEIAhqLQARQegCbCADQSRsaiIDQbywxgBqQQkgAygAvLBGEMgEIQMgBEEVOgAoIAQgA0H/AXEiAzoAKSADQQlLBEAgAyEGQRUMBgsgBEEoahCrBCALQQJrQQogAyADQQpPGyIDOgAAIAogASgCpAQiAk8NAyABKAKgBCAIaiADOgARIAcgAzoAACAKIAEoAqQEIgJPDQIgFSABKAKgBCAIai0AEkHoAmwgA0EkbGoiA0G8sMYAakEJIAMoALywRhDIBCEDIARBFToAKCAEIANB/wFxIgM6ACkgA0EJSwRAIAMhBkEVDAYLIARBKGoQqwQgC0EBa0EKIAMgA0EKTxsiAzoAACAKIAEoAqQEIgJPDQMgASgCoAQgCGogAzoAEiAHIAM6AAAgCiABKAKkBCICTw0CIBUgASgCoAQgCGotABNB6AJsIANBJGxqIgNBvLDGAGpBCSADKAC8sEYQyAQhAyAEQRU6ACggBCADQf8BcSIDOgApIANBCUsEQCADIQZBFQwGCyAEQShqEKsEIAtBCiADIANBCk8bIgM6AAAgCiABKAKkBCICTw0DIAEoAqAEIAhqIAM6ABMgByADOgAAIAtBBGohCyAOQQFqIg5BBEkNAAsLIBVB3MzGAEEDQYCDuAQQyAQhAyAEQRY6ACggBCADQf8BcSILOgApIAtBA0sEQCALIQZBFgwECyAEQShqEKsEIAQgCzoAygwMAgsgCiACQaywxgAQjAcACyAKIAJBzMzGABCMBwwRCyAKIAEoAqQEIgNPDQEgCkEebCIFIAEoAqAEaiALOgACIAogASgCpAQiA08NAiABKAKgBCAFaiAJOgADIAogASgCpAQiA08NAyABKAKgBCAFaiBy/QAAAP0LAAQgAS0AkwFB8gFHDQRBDwshAyAAIDg2AhAgACAaNgIMIAAgOTYCCCAAIEA7AQYgACAGOgAFIAAgAzoABCAAQYCAgIB4NgIADBYLIAogA0HozMYAEIwHAAsgCiADQfjMxgAQjAcACyAKIANBiM3GABCMBwALIARBDGogBEHKDGotAAA6AAAgBCAELwDIDDsBCiAEICgpAAA3A9gYIAQgKEEHaigAADYA3xggBEHPDGooAAAhOSAELQDMDCEGIAQvAM0MIUAgBCgA0wwhGiAEKADXDCE4ID5BB2ogBCgA3xg2AAAgPiAEKQPYGDcAACAEIDg2ABkgBCAaNgAVIAQgOTYAESAEIEA7AA8gBCAGOgAOIAQgCToADQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBC0ACkEBcUUEQCAELQAnIQsgBEHIDGpBAEGADPwLAAJAAkACQAJAIAlBBEcEQCAKIAEoAqQEIgNPDQEgASgCoAQgBWotABQhAyABLQCWBSECIHT9DAAAAAAAAAAAAAAAAAAAAAD9CwMAIARB+Bhq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAEQegYav0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgBP0MAAAAAAAAAAAAAAAAAAAAAP0LA9gYIAtBBE8NAiAEQcgYaiABIARB2BhqIA9BASACIANqQf8BcSA6IAtBBHRqIgMvAQQgAy8BBhDqASAELQDJGCEHIAQtAMgYIgJBHUYNAyAEIAQpAcoYNwO4DCAEIARB0BhqKQEANwG+DAwcC0EDIQ4gC0EDSw0DDAULIAogA0GgrsYAEIwHAAsgC0EEQbCuxgAQjAcACyABIAc6AJYFIAEoAqQEIgMgCksEQCABKAKgBCAFaiAHOgAUIARB2BhqIgMgAygCACICIAMoAjAiCGsiDiADKAIQIgcgAygCICINayISazYCMCADIAIgCGoiAiAHIA1qIghrNgIgIAMgDiASajYCECADIAIgCGo2AgAgAyADKAIkIgIgAygCFCIIaiIOIAMoAjQiByADKAIEIg1qIhJqNgIEIAMgDSAHayIHIAggAmsiAms2AjQgAyACIAdqNgIUIAMgEiAOazYCJCADIAMoAigiCCADKAIYIg5qIgcgAygCOCINIAMoAggiEmoiFmoiAjYCCCADIBIgDWsiDSAOIAhrIghrNgI4IAMgFiAHazYCKCADIAggDWo2AhggAyADKAIsIg4gAygCHCIHaiINIAMoAjwiEiADKAIMIhZqIiJqIgg2AgwgAyAHIA5rIgcgFiASayISaiIONgIcIAMgEiAHazYCPCADICIgDWsiBzYCLCADIAggAygCACINakEDaiISIAIgAygCBCIWaiIia0EDdTYCCCADIA0gCGtBA2oiCCAWIAJrIgJrQQN1NgIMIAMgAiAIakEDdTYCBCADIBIgImpBA3U2AgAgAyADKAIQIgIgDmtBA2oiCCADKAIUIg0gAygCGCISayIWa0EDdTYCHCADIAIgDmpBA2oiAiANIBJqIg5rQQN1NgIYIAMgCCAWakEDdTYCFCADIAIgDmpBA3U2AhAgAyADKAIgIgIgB2tBA2oiCCADKAIkIg4gAygCKCINayISa0EDdTYCLCADIAIgB2pBA2oiAiANIA5qIg5rQQN1NgIoIAMgCCASakEDdTYCJCADIAIgDmpBA3U2AiAgAyADKAIwIgIgAygCPCIIa0EDaiIOIAMoAjQiByADKAI4Ig1rIhJrQQN1NgI8IAMgAiAIakEDaiICIAcgDWoiCGtBA3U2AjggAyAOIBJqQQN1NgI0IAMgAiAIakEDdTYCMCAEIAQoAtgYNgLIDCAEIAQoAtwYNgKIDSAEIAQoAuAYNgLIDSAEIAQoAuQYNgKIDiAEIAQoAugYNgLIDiAEIAQoAuwYNgKIDyAEIAQoAvAYNgLIDyAEIAQoAvQYNgKIECAEIAQoAvgYNgLIECAEIAQoAvwYNgKIESAEIAQoAoAZNgLIESAEIAQoAoQZNgKIEiAEIAQoAogZNgLIEiAEIAQoAowZNgKIEyAEIAQoApAZNgLIEyAEIAQoApQZNgKIFEEAIQ4MAwsgCiADQcCuxgAQjAcACyAKIAEoAqQEIgJPDQ0gC0EEQaivxgAQjAcACwJAIAlBBEYNACABQQA6AJYFIAEoAqQEIgMgCksEQCABKAKgBCAFakEAOgAUDAELIAogA0GIqcYAEIwHAAsgAUEAOgCXBQJAIAogASgCpAQiC08NACABKAKgBCAFakEAOgAVIAFBADoAmAUgCiABKAKkBCILTw0AIAEoAqAEIAVqQQA6ABYgAUEAOgCZBSAKIAEoAqQEIgtPDQAgASgCoAQgBWpBADoAFyABQQA6AJoFIAogASgCpAQiC08NACABKAKgBCAFakEAOgAYIAFBADoAmwUgCiABKAKkBCILTw0AIAEoAqAEIAVqQQA6ABkgAUEAOgCcBSAKIAEoAqQEIgtPDQAgASgCoAQgBWpBADoAGiABQQA6AJ0FIAogASgCpAQiC08NACABKAKgBCAFakEAOgAbIAFBADoAngUgCiABKAKkBCILTw0AIAEoAqAEIAVqQQA6ABwgBEEoakEAQYAM/AsADAILIAogC0GoqcYAEIwHAAsgOiALQQR0aiEDQQAhDUGXBSESIAQtAAshCANAIAogASgCpAQiAk8NDCAEQdgYaiABIARByAxqIA1qIgsgDyAOIAEoAqAEIAVqLQAVIAEgEmoiIi0AAGpB/wFxIAMvAQAgAy8BAhDqASAELQDYGCICQR1HDRUgBC0A2RghAgJ/AkAgCygCAARAIAsQmgJBASEIIAJBAXENAUEADAILQQAgAkEBcUUNARogCxCaAgtBASEIQQELIRYgCiABKAKkBCICTw0FIAEoAqAEIAVqIBY6ABUgCiABKAKkBCICTw0MIARB2BhqIAEgC0FAayIHIA8gDiABKAKgBCAFai0AFiAWakH/AXEgAy8BACADLwECEOoBIAQtANgYIgJBHUcNFSAELQDZGCECAn8CQCAHKAIABEAgBxCaAkEBIQggAkEBcQ0BQQAMAgtBACACQQFxRQ0BGiAHEJoCC0EBIQhBAQshFiAKIAEoAqQEIgJPDQUgASgCoAQgBWogFjoAFiAKIAEoAqQEIgJPDQwgBEHYGGogASALQYABaiIHIA8gDiABKAKgBCAFai0AFyAWakH/AXEgAy8BACADLwECEOoBIAQtANgYIgJBHUcNFSAELQDZGCECAn8CQCAHKAIABEAgBxCaAkEBIQggAkEBcQ0BQQAMAgtBACACQQFxRQ0BGiAHEJoCC0EBIQhBAQshByAKIAEoAqQEIgJPDQUgASgCoAQgBWogBzoAFyAKIAEoAqQEIgJPDQwgBEHYGGogASALQcABaiILIA8gDiABKAKgBCAFai0AGCAHakH/AXEgAy8BACADLwECEOoBIAQtANgYIgJBHUcNFSAELQDZGCECAn8CQCALKAIABEAgCxCaAkEBIQggAkEBcQ0BQQAMAgtBACACQQFxRQ0BGiALEJoCC0EBIQhBAQshCyAKIAEoAqQEIgJPDQUgASgCoAQgBWogCzoAGCAiIAs6AAAgDUGAAmohDSASQZYFayASQQFqIRJBBEkNAAtBeCENA0ACQCANQdiuxgBqKAIAIgtBCE0EfyAKIAEoAqQEIgJPDQQgBEHYGGogASAEQcgMakGACEGACiALQQVGIgcbaiIOIA9BAiABKAKgBCAFaiALai0AFCALIBxqIiItAABqQf8BcSADLwEIIAMvAQoQ6gEgBC0A2BgiAkEdRw0XIAQtANkYIQICfwJAIA4oAgAEQCAOEJoCQQEhCCACQQFxDQFBAAwCC0EAIAJBAXFFDQEaIA4QmgILQQEhCEEBCyEWIAogASgCpAQiAk8NBiABKAKgBCAFaiALaiAWOgAUIAogASgCpAQiAk8NBCALQQFqIQ5BCSALayICQQAgAkEJTRtBAUYNBSAEQdgYaiABIARByAxqQcAIQcAKIAcbaiISIA9BAiABKAKgBCAFaiAOai0AFCAWakH/AXEgAy8BCCADLwEKEOoBIAQtANgYIgJBHUcNFyAELQDZGCECAn8CQCASKAIABEAgEhCaAkEBIQggAkEBcQ0BQQAMAgtBACACQQFxRQ0BGiASEJoCC0EBIQhBAQshEiAKIAEoAqQEIgJPDQYgASgCoAQgBWogDmogEjoAFCAiIBI6AAAgC0EIRw0BQQkFIAsLQQlB2K7GABCMBwALIAogASgCpAQiAk8NAiAEQdgYaiABIARByAxqQYAJQYALIAcbaiISIA9BAiABKAKgBCAFaiALai0AFCAOIBxqIhYtAABqQf8BcSADLwEIIAMvAQoQ6gEgBC0A2BgiAkEdRw0VIAQtANkYIQICfwJAIBIoAgAEQCASEJoCQQEhCCACQQFxDQFBAAwCC0EAIAJBAXFFDQEaIBIQmgILQQEhCEEBCyESIAogASgCpAQiAk8NBCABKAKgBCAFaiALaiASOgAUIAogASgCpAQiAk8NAiAEQdgYaiABIARByAxqQcAJQcALIAcbaiILIA9BAiABKAKgBCAFaiAOai0AFCASakH/AXEgAy8BCCADLwEKEOoBIAQtANgYIgJBHUcNFSAELQDZGCECAn8CQCALKAIABEAgCxCaAkEBIQggAkEBcQ0BQQAMAgtBACACQQFxRQ0BGiALEJoCC0EBIQhBAQshCyAKIAEoAqQEIgJPDQQgASgCoAQgBWogDmogCzoAFCAWIAs6AAAgDUEEaiINDQALIAQgCDoACyAEID0pAQA3A7gMIAQgPUEGaikBADcBvgwgBC8ByAwhAyBxIDxB8Av8CgAAIAQgBCkDuAw3A6gMIAQgBCkBvgw3Aa4MIEhBBmogBCkBrgw3AQAgSCAEKQOoDDcBACAEIAM7ASgLIARByAxqIQcgAS8BoAUiJCEFIAEoAqwEInYhDiABKAKwBCIiIQIgASgCuAQiDSELIAEoArwEIkEhEiMAQfACayIDJAAgA0EIakEAQeQC/AsAAkAgEEUEQCADQRhqQf/+/fsHNgIAIANBEGpC//79+/fv37//ADcDACADQv/+/fv379+//wA3AwgMAQsgCkEEdCIIIAJNBEACQCACIAhGDQBBECACIAhrIhYgFkEQTxsiFkUNACADQQhqIAggDmogFvwKAAALAkAgBUEBayAKRgRAIAhBD3IiCCACTw0BIAMgCCAOai0AAEGBgoQIbDYAGAwDCyAIQRBqIgggAk0EQCACIAhGDQNBBCACIAhrIgIgAkEETxsiAkUNAyADQRhqIAggDmogAvwKAAAMAwsgCCACIAJB+OPEABDqBwALIAggAkGY5MQAEIwHAAsgCCACIAJBqOTEABDqBwALIAMgAy0AGCICOgCUAiADIAI6AMABIAMgAjoAbCADIAMtABkiAjoAlQIgAyACOgDBASADIAI6AG0gAyADLQAaIgI6AJYCIAMgAjoAwgEgAyACOgBuIAMgAy0AGyICOgCXAiADIAI6AMMBIAMgAjoAbyAHAn8gCkUEQCADQYEBOgDXAiADQYEBOgDCAiADQYEBOgCtAiADQYEBOgCYAiADQYEBOgCDAiADQYEBOgDuASADQYEBOgDZASADQYEBOgDEASADQYEBOgCvASADQYEBOgCaASADQYEBOgCFASADQYEBOgBwIANBgQE6AFsgA0GBAToARiADQYEBOgAxIANBgQE6ABxBgX9B/wAgEBsMAQsCQCASBEAgEkEBayICRQ0BIAMgCy0AAToAHCACQQFGDQEgAyALLQACOgAxIAJBAkYNASADIAstAAM6AEYgAkEDRg0BIAMgCy0ABDoAWyACQQRGDQEgAyALLQAFOgBwIAJBBUYNASADIAstAAY6AIUBIAJBBkYNASADIAstAAc6AJoBIAJBB0YNASADIAstAAg6AK8BIAJBCEYNASADIAstAAk6AMQBIAJBCUYNASADIAstAAo6ANkBIAJBCkYNASADIAstAAs6AO4BIAJBC0YNASADIAstAAw6AIMCIAJBDEYNASADIAstAA06AJgCIAJBDUYNASADIAstAA46AK0CIAJBDkYNASADIAstAA86AMICIAJBD0YNASADIAstABA6ANcCDAELQQFBAEEAQYjkxAAQ6gcAC0GBf0H/ACAQGyAQRQ0AGiALLQAACzoAACAHQQFqIANBCGpB5AL8CgAAIANB8AJqJAAgCUEBaw4EBAUGBwgLIAogAkHorsYAEIwHAAsgDkEJQfiuxgAQjAcACyAKIAJBiK/GABCMBwALIAogAkG4r8YAEIwHAAtBsH0hCwNAIARByAxqIAtqIgNB5gJqIAQtAMkMOgAAIANB5wJqIAQtAMoMOgAAIANB6AJqIAQtAMsMOgAAIANB6QJqIAQtAMwMOgAAIANB6gJqIAQtAM0MOgAAIANB6wJqIAQtAM4MOgAAIANB7AJqIAQtAM8MOgAAIANB7QJqIAQtANAMOgAAIANB7gJqIAQtANEMOgAAIANB7wJqIAQtANIMOgAAIANB8AJqIAQtANMMOgAAIANB8QJqIAQtANQMOgAAIANB8gJqIAQtANUMOgAAIANB8wJqIAQtANYMOgAAIANB9AJqIAQtANcMOgAAIANB9QJqIAQtANgMOgAAIANB9gJqIAQtANkMOgAAIANB9wJqIAQtANoMOgAAIANB+AJqIAQtANsMOgAAIANB+QJqIAQtANwMOgAAIAtBFWoiCw0ACwwECyA2QRBqIAQtAN0MIgNBgYKECGw2AAAgNUEQaiAELQDyDCILQYGChAhsNgAAIBhBEGogBC0Ahw0iCUGBgoQIbDYAACA0QRBqIAQtAJwNIgJBgYKECGw2AAAgM0EQaiAELQCxDSIIQYGChAhsNgAAIDYgA61CgYKEiJCgwIABfiJ5NwAAIDZBCGogeTcAACA1IAutQoGChIiQoMCAAX4ieTcAACA1QQhqIHk3AAAgGCAJrUKBgoSIkKDAgAF+Ink3AAAgGEEIaiB5NwAAIDQgAq1CgYKEiJCgwIABfiJ5NwAAIDRBCGogeTcAACAzQQhqIAitQoGChIiQoMCAAX4ieTcAACAzIHk3AAAgMkEQaiAELQDGDSIDQYGChAhsNgAAIDFBEGogBC0A2w0iC0GBgoQIbDYAACAwQRBqIAQtAPANIglBgYKECGw2AAAgL0EQaiAELQCFDiICQYGChAhsNgAAIC5BEGogBC0Amg4iCEGBgoQIbDYAACAyIAOtQoGChIiQoMCAAX4ieTcAACAyQQhqIHk3AAAgMSALrUKBgoSIkKDAgAF+Ink3AAAgMUEIaiB5NwAAIDAgCa1CgYKEiJCgwIABfiJ5NwAAIDBBCGogeTcAACAvIAKtQoGChIiQoMCAAX4ieTcAACAvQQhqIHk3AAAgLiAIrUKBgoSIkKDAgAF+Ink3AAAgLkEIaiB5NwAAIBNBEGogBC0Arw4iA0GBgoQIbDYAACAtQRBqIAQtAMQOIgtBgYKECGw2AAAgLEEQaiAELQDZDiIJQYGChAhsNgAAICtBEGogBC0A7g4iAkGBgoQIbDYAACAqQRBqIAQtAIMPIghBgYKECGw2AAAgE0EIaiADrUKBgoSIkKDAgAF+Ink3AAAgEyB5NwAAIC1BCGogC61CgYKEiJCgwIABfiJ5NwAAIC0geTcAACAsQQhqIAmtQoGChIiQoMCAAX4ieTcAACAsIHk3AAAgK0EIaiACrUKBgoSIkKDAgAF+Ink3AAAgKyB5NwAAICpBCGogCK1CgYKEiJCgwIABfiJ5NwAAICogeTcAACApQRBqIAQtAJgPIgNBgYKECGw2AAAgKUEIaiADrUKBgoSIkKDAgAF+Ink3AAAgKSB5NwAADAMLIARByAxqQeUCQRBBAUEBQRUQ4gIMAgsgFCEDIARBKGohC0EAIQkjAEEQayIOJAAgBEHIDGoiQiEFA0AgCSICQQFqIQkgAkECdEEBciFDQXAhEiADIQIgCyEIA0AgEkERaiFEAkACQAJAAkACQAJAAkACQAJAAkACQCACLQAAQQFrDgkBAgMEBQYHCAkACyAFIBJqIgdB5QBqIAdB5ABqLQAAIAdBzwBqLQAAIAdBOmotAAAgB0Elai0AACAHQRRqLQAAIAdBE2otAAAgB0ERai0AACAHQRJqLQAAampqampqakEEakH4/wNxQQN2QYGChAhsIhY2AAAgB0HQAGogFjYAACAHQTtqIBY2AAAgB0EmaiAWNgAADAkLIEJB5QJBBCBEIENBFRDiAgwICyAFIBJqIgdB5QBqIAdBFWotAAAgB0ETai0AACIWQQJqIhsgB0EUai0AACIdQQF0ampBFnRBgICAeHEgHSAHQRJqLQAAIh5BAmoiIyAWQQF0ampBDnRBgID8D3FqIBsgB0ERai0AACIWakEGdCAeQQd0akGA/gNxciAHQRBqLQAAIBZBAXRqICNqQQJ2aiIWNgAAIAdB0ABqIBY2AAAgB0E7aiAWNgAAIAdBJmogFjYAAAwHCyAFIBJqIgdB5QBqIAdBzwBqLQAAIhtBAmoiHSAHQeQAai0AACIWIBZBAXRqakECdkGBgoQIbDYAACAHQdAAaiAWIAdBOmotAAAiHkECaiIjaiAbQQF0akECdkGBgoQIbDYAACAHQTtqIB0gB0Elai0AACIWaiAeQQF0akECdkGBgoQIbDYAACAHQSZqICMgB0EQai0AAGogFkEBdGpBAnZBgYKECGw2AAAMBgsgBSASaiIHQRhqLQAAIRYgB0EXai0AACEbIAdBEWotAAAhOyAHQRJqLQAAIR0gB0ETai0AACEeIA4gB0EWai0AACIjIAdBFGotAAAiRkECaiJbIAdBFWotAAAiJUEBdGpqQQJ2OgADIA4gJSAeQQJqIlwgRkEBdGpqQQJ2OgACIA4gHSAeQQF0aiBbakECdjoAASAOIDsgHUEBdGogXGpBAnY6AAAgB0EmaiAOKAIANgAAIA4gJSAbQQJqIh1qICNBAXRqQQJ2OgAEIAdBO2ogDigAATYAACAOIBYgI2ogG0EBdGpBAmpBAnY6AAUgB0HQAGogDigBAjYAACAOIBYgHWogFkEBdGpBAnY6AAYgB0HlAGogDigAAzYAAAwFCyAFIBJqIgdBFGotAAAhOyAHQRNqLQAAIRYgB0HkAGotAAAhRiAHQc8Aai0AACEbIAdBOmotAAAhHSAHQSVqLQAAIR4gDiAHQRJqLQAAIltBAmoiXCAHQRBqLQAAIiNqIAdBEWotAAAiJUEBdGpBAnY6AAwgDiAlIB5BAmoidyAjQQF0ampBAnY6AAsgDiAjIB1BAmoieCAeQQF0ampBAnY6AAogDiAbIB1BAXRqIHdqQQJ2OgAJIAdB0ABqIA4oAAk2AAAgDiBGIBtBAXRqIHhqQQJ2OgAIIAdB5QBqIA4oAgg2AAAgDiA7IFwgFkEBdGpqQQJ2OgAOIA4gFiAlIFtBAXRqakECakECdjoADSAHQSZqIA4oAAs2AAAgB0E7aiAOKAEKNgAADAQLIAUgEmoiB0HRAGogB0EQai0AACIdIAdBEWotAAAiFmpBAWpBAXYiGzoAACAHQSZqIBs6AAAgB0HSAGogFiAHQRJqLQAAIhtqQQFqQQF2Ih46AAAgB0EnaiAeOgAAIAdB5QBqIAdBJWotAAAiHiAHQc8Aai0AACAHQTpqLQAAIiNBAXRqakECakECdjoAACAHQeYAaiAWIB4gHUEBdGpqQQJqQQJ2IiU6AAAgB0HQAGogHSAjIB5BAXRqakECakECdjoAACAHQTtqICU6AAAgB0HnAGogGyAdIBZBAXRqakECakECdiIdOgAAIAdBPGogHToAACAHQegAaiAHQRNqLQAAIh0gFiAbQQF0ampBAmpBAnYiHjoAACAHQRRqLQAAIRYgB0HTAGogGyAdakEBakEBdiIjOgAAIAdBPWogHjoAACAHQShqICM6AAAgB0E+aiAWIBsgHUEBdGpqQQJqQQJ2OgAAIAdBKWogFiAdakEBakEBdjoAAAwDCyAFIBJqIgdB0ABqIAdBEmotAAAiHSAHQRNqLQAAIhZqQQFqQQF2Ihs6AAAgB0EmaiAdIAdBEWotAAAiI2pBAWpBAXY6AAAgB0EnaiAbOgAAIAdB0QBqIBYgB0EUai0AACIbakEBakEBdiIeOgAAIAdBKGogHjoAACAHQdIAaiAbIAdBFWotAAAiHmpBAWpBAXYiJToAACAHQeUAaiAbIB1qIBZBAXRqQQJqQQJ2Ijs6AAAgB0E8aiA7OgAAIAdB5gBqIBYgHkECaiI7IBtBAXRqakECdiJGOgAAIAdBPWogRjoAACAHQTtqICMgFiAdQQF0ampBAmpBAnY6AAAgB0EYai0AACEjIAdBF2otAAAhFiAHQecAaiAHQRZqLQAAIh0gGyAeQQF0ampBAmpBAnYiGzoAACAHQSlqICU6AAAgB0HoAGogIyAdIBZBAXRqakECakECdjoAACAHQdMAaiAWIB1BAXQgO2pqQQJ2OgAAIAdBPmogGzoAAAwCCyAFIBJqIgdB5QBqIAdB5ABqLQAAIiMgB0HPAGotAAAiHWpBAWpBAXY6AAAgB0HnAGogHSAHQTpqLQAAIhZqQQFqQQF2Ihs6AAAgB0HQAGogGzoAACAHQdIAaiAWIAdBJWotAAAiG2pBAWpBAXYiHjoAACAHQTtqIB46AAAgB0E9aiAbIAdBEGotAAAiHmpBAWpBAXYiJToAACAHQeYAaiAWICMgHUEBdGpqQQJqQQJ2OgAAIAdB6ABqIBsgHSAWQQF0ampBAmpBAnYiHToAACAHQdEAaiAdOgAAIAdB0wBqIB4gFiAbQQF0ampBAmpBAnYiFjoAACAHQTxqIBY6AAAgB0ETai0AACEjIAdBEmotAAAhFiAHQT5qIAdBEWotAAAiHSAbIB5BAXRqakECakECdiIbOgAAIAdBJmogJToAACAHQSlqICMgHSAWQQF0ampBAmpBAnY6AAAgB0EoaiAWIB4gHUEBdGpqQQJqQQJ2OgAAIAdBJ2ogGzoAAAwBCyAFIBJqIgdB6ABqIAdB5ABqLQAAIhY6AAAgB0HnAGogFjoAACAHQeYAaiAWOgAAIAdB5QBqIBY6AAAgB0HTAGogFjoAACAHQdIAaiAWOgAAIAdBO2ogB0E6ai0AACIbIAdBzwBqLQAAIh1qQQFqQQF2Ih46AAAgB0EoaiAeOgAAIAdBJmogGyAHQSVqLQAAIh5qQQFqQQF2OgAAIAdB0ABqIBYgHWoiI0EBakEBdiIlOgAAIAdBPWogJToAACAHQTxqIBYgG2ogHUEBdGpBAmpBAnYiJToAACAHQSlqICU6AAAgB0HRAGogIyAWQQF0akECakECdiIWOgAAIAdBPmogFjoAACAHQSdqIB0gHiAbQQF0ampBAmpBAnY6AAALIEJB5QIgCCBDIERBFRDXAiACQQFqIQIgCEFAayEIIBJBBGoiEg0ACyADQQRqIQMgC0GAAmohCyAFQdQAaiEFIAlBBEcNAAsgDkEQaiQADAMLIARByAxqQeUCQRBBFSAQQQBHIApBAEcQgwQLIARByAxqIgNB5QIgBEEoakEBQQFBFRDXAiADQeUCIHBBAUEFQRUQ1wIgA0HlAiBvQQFBCUEVENcCIANB5QIgbkEBQQ1BFRDXAiADQeUCIG1BBUEBQRUQ1wIgA0HlAiBsQQVBBUEVENcCIANB5QIga0EFQQlBFRDXAiADQeUCIGpBBUENQRUQ1wIgA0HlAiBpQQlBAUEVENcCIANB5QIgaEEJQQVBFRDXAiADQeUCIGdBCUEJQRUQ1wIgA0HlAiBmQQlBDUEVENcCIANB5QIgZUENQQFBFRDXAiADQeUCIGRBDUEFQRUQ1wIgA0HlAiBjQQ1BCUEVENcCIANB5QIgYkENQQ1BFRDXAgwBCyAKIAJBmK/GABCMBwALAkAgQQRAIA0gBC0A2Aw6AAAgQUEBayIDQQ9NBEBBAEEQIANB0K3GABDqBwALIA0gBC0A7Qw6AAEgDSAELQCCDToAAiANIAQtAJcNOgADIA0gBC0ArA06AAQgDSAELQDBDToABSANIAQtANYNOgAGIA0gBC0A6w06AAcgDSAELQCADjoACCANIAQtAJUOOgAJIA0gBC0Aqg46AAogDSAELQC/DjoACyANIAQtANQOOgAMIA0gBC0A6Q46AA0gDSAELQD+DjoADiANIAQtAJMPOgAPIA0gBC0AqA86ABAgIiAKQQR0IgNJDQggIiADayILQQ9LDQFBAEEQIAtB4K3GABDqBwALQQBBAEHArcYAEIwHAAsgAyB2aiIDIAQtAJkPOgAAIAMgBC0Amg86AAEgAyAELQCbDzoAAiADIAQtAJwPOgADIAMgBC0AnQ86AAQgAyAELQCeDzoABSADIAQtAJ8POgAGIAMgBC0AoA86AAcgAyAELQChDzoACCADIAQtAKIPOgAJIAMgBC0Aow86AAogAyAELQCkDzoACyADIAQtAKUPOgAMIAMgBC0Apg86AA0gAyAELQCnDzoADiADIAQtAKgPOgAPICRBBHQhDiABKAIIIgkgCiAkIEVsakEEdCIHayEIIAEoAgQhDUEAIRJBACECAkADQCAHIAlLDQEgCEEPTQ0DIAcgDWoiAyAEQcgMaiIFIAJqIgtBFmotAAA6AAAgA0EBaiALQRdqLQAAOgAAIANBAmogC0EYai0AADoAACADQQNqIAtBGWotAAA6AAAgA0EEaiALQRpqLQAAOgAAIANBBWogC0Ebai0AADoAACADQQZqIAtBHGotAAA6AAAgA0EHaiALQR1qLQAAOgAAIANBCGogC0Eeai0AADoAACADQQlqIAtBH2otAAA6AAAgA0EKaiALQSBqLQAAOgAAIANBC2ogC0Ehai0AADoAACADQQxqIAtBImotAAA6AAAgA0ENaiALQSNqLQAAOgAAIANBDmogC0Ekai0AADoAACADQQ9qIAtBJWotAAA6AAAgCCAOayEIIAcgDmohByACQRVqIQIgEkEBaiISQRBJDQALIAEvAaAFIQkgBC0ADCEDIARB2BhqIAogECABKALEBCICIAEoAsgEIgggASgC0AQiDiABKALUBCIHELoEIAUgCiAQIAEoAtwEIg0gASgC4AQiEiABKALoBCIFIAEoAuwEIhYQugQCQAJAAkACQAJAIANBAWsOAwECAwALIARB2BhqQdEAQQhBCSAQQQBHIgMgCkEARyILEIMEIARByAxqQdEAQQhBCSADIAsQgwQMAwsgBCAELQDZGCIDOgDiGCAEIAQtANoYIgs6AOMYIAQgBC8A2xg7AOQYIAQgBCgA3Rg2AOYYIAQgAzoA6xggBCAEKADaGDYA7BggBCAELwDeGDsA8BggBCAELQDgGDoA8hggBCADOgD0GCAEIAs6APUYIAQgBC0A2xg6APYYIAQgBC0A3Bg6APcYIAQgBC8A3RgiAzsA+BggBCAELQDfGCILOgD6GCAEIAQtAOAYIiI6APsYIAQgBCkA2Rg3AP0YIAQgBCgA2Rg2AIYZIAQgAzsAihkgBCALOgCMGSAEICI6AI0ZIAQgBC0A2Rg6AI8ZIAQgBC0A2hg6AJAZIAQgBC0A2xgiAzoAkRkgBCAELQDcGDoAkhkgBCAEKADdGDYAkxkgBCAELQDZGCILOgCYGSAEIAQoANoYNgCZGSAEIAQvAN4YOwCdGSAEIAQtAOAYOgCfGSAEIAs6AKEZIAQgBC0A2hg6AKIZIAQgAzoAoxkgBCAELQDcGDoApBkgBCAELQDdGDoApRkgBCAELQDeGDoAphkgBCAELQDfGDoApxkgBCAELQDgGDoAqBkgBCAELQDJDDoA0gwgBCAELQDKDDoA0wwgBCAELQDLDDoA1AwgBCAELQDMDDoA1QwgBCAELQDNDDoA1gwgBCAELQDODDoA1wwgBCAELQDPDDoA2AwgBCAELQDQDDoA2QwgBCAELQDJDDoA2wwgBCAELQDKDDoA3AwgBCAELQDLDDoA3QwgBCAELQDMDDoA3gwgBCAELQDNDDoA3wwgBCAELQDODDoA4AwgBCAELQDPDDoA4QwgBCAELQDQDDoA4gwgBCAELQDJDDoA5AwgBCAELQDKDDoA5QwgBCAELQDLDDoA5gwgBCAELQDMDDoA5wwgBCAELQDNDDoA6AwgBCAELQDODDoA6QwgBCAELQDPDDoA6gwgBCAELQDQDDoA6wwgBCAELQDJDDoA7QwgBCAELQDKDDoA7gwgBCAELQDLDDoA7wwgBCAELQDMDDoA8AwgBCAELQDNDDoA8QwgBCAELQDODDoA8gwgBCAELQDPDDoA8wwgBCAELQDQDDoA9AwgBCAELQDJDDoA9gwgBCAELQDKDDoA9wwgBCAELQDLDDoA+AwgBCAELQDMDDoA+QwgBCAELQDNDDoA+gwgBCAELQDODDoA+wwgBCAELQDPDDoA/AwgBCAELQDQDDoA/QwgBCAELQDJDDoA/wwgBCAELQDKDDoAgA0gBCAELQDLDDoAgQ0gBCAELQDMDDoAgg0gBCAELQDNDDoAgw0gBCAELQDODDoAhA0gBCAELQDPDDoAhQ0gBCAELQDQDDoAhg0gBCAELQDJDDoAiA0gBCAELQDKDDoAiQ0gBCAELQDLDDoAig0gBCAELQDMDDoAiw0gBCAELQDNDDoAjA0gBCAELQDODDoAjQ0gBCAELQDPDDoAjg0gBCAELQDQDDoAjw0gBCAELQDJDDoAkQ0gBCAELQDKDDoAkg0gBCAELQDLDDoAkw0gBCAELQDMDDoAlA0gBCAELQDNDDoAlQ0gBCAELQDODDoAlg0gBCAELQDPDDoAlw0gBCAELQDQDDoAmA0MAgsgWCAEMQDhGEKBgoSIkKDAgAF+NwAAIFYgBDEA6hhCgYKEiJCgwIABfjcAACBVIAQxAPMYQoGChIiQoMCAAX43AAAgVCAEMQD8GEKBgoSIkKDAgAF+NwAAIFMgBDEAhRlCgYKEiJCgwIABfjcAACBSIAQxAI4ZQoGChIiQoMCAAX43AAAgUSAEMQCXGUKBgoSIkKDAgAF+NwAAIFAgBDEAoBlCgYKEiJCgwIABfjcAACBXIAQxANEMQoGChIiQoMCAAX43AAAgKCAEMQDaDEKBgoSIkKDAgAF+NwAAIE8gBDEA4wxCgYKEiJCgwIABfjcAACBOIAQxAOwMQoGChIiQoMCAAX43AAAgTSAEMQD1DEKBgoSIkKDAgAF+NwAAIEwgBDEA/gxCgYKEiJCgwIABfjcAACAYIAQxAIcNQoGChIiQoMCAAX43AAAgSyAEMQCQDUKBgoSIkKDAgAF+NwAADAELIARB2BhqQdEAQQhBAUEBQQkQ4gIgBEHIDGpB0QBBCEEBQQFBCRDiAgsgBEHYGGoiA0HRACBhQQFBAUEJENcCIARByAxqIgtB0QAgYEEBQQFBCRDXAiADQdEAIF9BAUEFQQkQ1wIgC0HRACBeQQFBBUEJENcCIANB0QAgIUEFQQFBCRDXAiALQdEAICBBBUEBQQkQ1wIgA0HRACBaQQVBBUEJENcCIAtB0QAgWUEFQQVBCRDXAiAOIAcgAiAIIAMgChCOBiAFIBYgDSASIAsgChCOBiAJIB9sIQ4gCUEDdCEWIAogCSBJbGpBA3QhAiABKAIUIgcgJmohIiABKAIgIg0gJmohGyABKAIcIR0gASgCECEeQQAhBUEAIRIDQCACIAdLDQQgDiAiaiIDQQdNDQUgAiANSw0GIA4gG2oiA0EHTQ0HIARByAxqIBJqIgNBCmotAAAhJCACIB5qIgsgBEHYGGogEmoiCUEKai0AADoAACACIB1qIgggJDoAACADQQtqLQAAISQgC0EBaiAJQQtqLQAAOgAAIAhBAWogJDoAACADQQxqLQAAISQgC0ECaiAJQQxqLQAAOgAAIAhBAmogJDoAACADQQ1qLQAAISQgC0EDaiAJQQ1qLQAAOgAAIAhBA2ogJDoAACADQQ5qLQAAISQgC0EEaiAJQQ5qLQAAOgAAIAhBBGogJDoAACADQQ9qLQAAISQgC0EFaiAJQQ9qLQAAOgAAIAhBBWogJDoAACADQRBqLQAAISQgC0EGaiAJQRBqLQAAOgAAIAhBBmogJDoAACADQRFqLQAAIQMgC0EHaiAJQRFqLQAAOgAAIAhBB2ogAzoAACAOIBZrIQ4gAiAWaiECIBJBCWohEiAFQQFqIgVBCEkNAAsgASgCmAQiAiABKAKQBEYEQEEAIQgjAEEgayILJAACQAJAQQQgGSIDKAIAIg5BAXQiCSAJQQRNGyIHrUIefiJ5QiCIUEUNACB5pyINQQBIDQAgCyAOBH8gCyAOQR5sNgIcIAsgAygCBDYCFEEBBUEACzYCGCALQQhqQQEgDSALQRRqEIUHIAsoAghBAUcNASALKAIQIQkgCygCDCEICyAIIAlBmKnGABCTCQALIAsoAgwhCSADIAc2AgAgAyAJNgIEIAtBIGokAAsgASgClAQgAkEebGoiAyAE/QABCv0LAAAgA0EWaiAEQSBqKQEANwAAIANBEGogBEEaaikBADcAACABIAJBAWo2ApgEICZBCGshJiAKQQFqIQogNyA3IHVJIgNqITcgAw0BDAoLCyAHIAkgCUGArsYAEOoHAAtBAEEQIAhB8K3GABDqBwALIAIgByAHQfivxgAQ6gcAC0EAQQggA0HIr8YAEOoHAAsgAiANIA1B6K/GABDqBwALQQBBCCADQdivxgAQ6gcACyADICIgIkGQrsYAEOoHAAsgBCAEKQHaGDcDuAwgBCAEQeAYaikBADcBvgwgBC0A2RghBwsgBCAEKQO4DDcDqAwgBCAEKQG+DDcBrgwgAEEMaiAEKQGuDDcBACAAIAQpA6gMNwEGIAAgBzoABSAAIAI6AAQgAEGAgICAeDYCAAwJC0EREHEiA0UNASADQoGDhoyYsODAgX83AAAgA0EQakGBAToAACADQQhqQoGDhoyYsODAgX83AAAgASgCtAQiCwRAIAEoArgEIAtBARCiBwsgAUERNgK8BCABIAM2ArgEIAFBETYCtARBCRBxIgNFDQEgA0KBg4aMmLDgwIF/NwAAIANBCGpBgQE6AAAgASgCzAQiCwRAIAEoAtAEIAtBARCiBwsgAUEJNgLUBCABIAM2AtAEIAFBCTYCzARBCRBxIgNFDQEgA0KBg4aMmLDgwIF/NwAAIANBCGpBgQE6AAAgASgC5AQiCwRAIAEoAugEIAtBARCiBwsgAUEJNgLsBCABIAM2AugEIAFBCTYC5AQgH0FAaiEfIElBCGohSSBFQRBqIUUgESARIEpJIgtqIQMgESEQIAsNAAsMAgsAC0H4qMYAEIIIAAsgAS8BogUiR0UNAEEAIQdBASEDA0AgAyELAkAgAS8BoAUiSEUNAEEAIQMDQCADIAcgAS8BoAVsaiIGIAEoApgEIglJBEAgBEHQDGogASgClAQgBkEebGoiBkEIav0AAAD9CwMAIARB3gxqIAZBFmopAAA3AQAgBCAGKQAANwPIDAJAAkAgBEHIDGoiCi0AHSIGQQNNBEAgAS0ALSIJRQ0CIAotAAMhDUE/IAlBACABIAZBBHRqIgYtAD4bIAYsAD1qIgZBACAGQQBKGyAJIAEtAKQFGyIGIAZBP08bIQIgAS0ApgVFDQEgASgC8AMgAmohAiANQQRHDQEgASgCgAQgAmohAgwBCyAGQQRBuNXGABCMBwALQT8gAkEAIAJBAEobIgYgBkE/ThshBiABLQAuIgkEfyAGQf8BcUECQQEgCUEESxt2IghBCSAJa0H/AXEiCSAIIAlJGwUgBgshCSABLwGgBSESAn8CQAJAIAEtAChFBEAgAkEnTA0BQQMMAwsgAkEnTA0BQQIMAgsgAkETTA0AQQIMAQsgAkEATA0BIAJBDkoLIQggEkEDdCEZIBJBBHQhDkEBIRZBASAJQf8BcSIJIAlBAU0bIgkgBkEBdGoiEEEEaiERAkACQAJAAkACQAJAAkAgDUEERgRAIANFDQMMAQsgCi0AAEUEQCAKLQABIRYgAw0BDAILQQAhFiADRQ0DCyADQQR0QQRrIg0gB0EEdCIUIA5saiECIAEoAgQhCiABKAIIIQYCQAJAAkACQAJAAkACQAJAAkAgAS0AKkUEQCACIAZLDQMgBiACayIMQQdLDQEMDwsgAiAGSw0DIAYgAmsiDEEHSw0BDA0LIAggCSARIAIgCmoQ+AIgBiANIBRBAXIgDmxqIgJJDQEgBiACayIMQQhJDQ0gCCAJIBEgAiAKahD4AiAGIA0gFEECciAObGoiAkkNASAGIAJrIgxBCEkNDSAIIAkgESACIApqEPgCIAYgDSAUQQNyIA5saiICSQ0BIAYgAmsiDEEISQ0NIAggCSARIAIgCmoQ+AIgBiANIBRBBHIgDmxqIgJJDQEgBiACayIMQQhJDQ0gCCAJIBEgAiAKahD4AiAGIA0gFEEFciAObGoiAkkNASAGIAJrIgxBCEkNDSAIIAkgESACIApqEPgCIAYgDSAUQQZyIA5saiICSQ0BIAYgAmsiDEEISQ0NIAggCSARIAIgCmoQ+AIgBiANIBRBB3IgDmxqIgJJDQEgBiACayIMQQhJDQ0gCCAJIBEgAiAKahD4AiAGIA0gFEEIciAObGoiAkkNASAGIAJrIgxBCEkNDSAIIAkgESACIApqEPgCIAYgDSAUQQlyIA5saiICSQ0BIAYgAmsiDEEISQ0NIAggCSARIAIgCmoQ+AIgBiANIBRBCnIgDmxqIgJJDQEgBiACayIMQQhJDQ0gCCAJIBEgAiAKahD4AiAGIA0gFEELciAObGoiAkkNASAGIAJrIgxBCEkNDSAIIAkgESACIApqEPgCIAYgDSAUQQxyIA5saiICSQ0BIAYgAmsiDEEISQ0NIAggCSARIAIgCmoQ+AIgBiANIBRBDXIgDmxqIgJJDQEgBiACayIMQQhJDQ0gCCAJIBEgAiAKahD4AiAGIA0gFEEOciAObGoiAkkNASAGIAJrIgxBCEkNDSAIIAkgESACIApqEPgCIAYgDSAUQQ9yIA5saiICSQ0BIAYgAmsiDEEISQ0NIAggCSARIAIgCmoQ+AIgASgCFCIKIANBA3RBBGsiDCAHQQN0IgUgGWxqIgJPDQMMBAsgEUH/AXEiBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBAXIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBAnIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBA3IgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBBHIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBBXIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBBnIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBB3IgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBCHIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBCXIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBCnIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBC3IgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBDHIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBDXIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBDnIgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgItAAIgAi0ABWsiDCAMQR91Ig9zIA9rQQF2IAItAAMiDyACLQAEIhprIhggGEEfdSIYcyAYa0EBdGpPBEAgAkH/AEGAfyAPQfwAQYB/IBogD2tBA2xB/wBBgH8gDCAMQYB/TBsiDCAMQf8AThtqIgwgDEGAf0wbIgwgDEH8AE4bQQNqQQN1akGAAWsiDyAPQYB/TBsiDyAPQf8AThtBgAFzOgADIAJB/wBBgH8gGkH7ACAMIAxB+wBOG0EEakEDdWtBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoABAsgBiANIBRBD3IgDmxqIgJJDQEgBiACayIMQQhJDQsgBSACIApqIgYtAAIgBi0ABWsiAiACQR91IgpzIAprQQF2IAYtAAMiCiAGLQAEIg1rIhQgFEEfdSIUcyAUa0EBdGpPBEAgBkH/AEGAfyAKQfwAQYB/IA0gCmtBA2xB/wBBgH8gAiACQYB/TBsiAiACQf8AThtqIgIgAkGAf0wbIgIgAkH8AE4bQQNqQQN1akGAAWsiCiAKQYB/TBsiCiAKQf8AThtBgAFzOgADIAZB/wBBgH8gDUH7ACACIAJB+wBOG0EEakEDdWtBgAFrIgYgBkGAf0wbIgYgBkH/AE4bQYABczoABAsMBwsgAiAGIAZBuKfGABDqBwALIAIgBiAGQdioxgAQ6gcACyAKIAJrIhRBB00NASABKAIcIQ0gASgCICEGIAggCSARIAEoAhAiDyACahD4AiACIAZLDQMgBiACayIUQQdNDQIgCCAJIBEgAiANahD4AiAKIAwgBUEBciAZbGoiAkkNACAKIAJrIhRBCEkNASAIIAkgESACIA9qEPgCIAIgBksNAyAGIAJrIhRBCEkNAiAIIAkgESACIA1qEPgCIAogDCAFQQJyIBlsaiICSQ0AIAogAmsiFEEISQ0BIAggCSARIAIgD2oQ+AIgAiAGSw0DIAYgAmsiFEEISQ0CIAggCSARIAIgDWoQ+AIgCiAMIAVBA3IgGWxqIgJJDQAgCiACayIUQQhJDQEgCCAJIBEgAiAPahD4AiACIAZLDQMgBiACayIUQQhJDQIgCCAJIBEgAiANahD4AiAKIAwgBUEEciAZbGoiAkkNACAKIAJrIhRBCEkNASAIIAkgESACIA9qEPgCIAIgBksNAyAGIAJrIhRBCEkNAiAIIAkgESACIA1qEPgCIAogDCAFQQVyIBlsaiICSQ0AIAogAmsiFEEISQ0BIAggCSARIAIgD2oQ+AIgAiAGSw0DIAYgAmsiFEEISQ0CIAggCSARIAIgDWoQ+AIgCiAMIAVBBnIgGWxqIgJJDQAgCiACayIUQQhJDQEgCCAJIBEgAiAPahD4AiACIAZLDQMgBiACayIUQQhJDQIgCCAJIBEgAiANahD4AiAKIAwgBUEHciAZbGoiAkkNACAKIAJrIhRBCEkNASAIIAkgESACIA9qEPgCIAIgBksNAyAGIAJrIhRBCEkNAiAIIAkgESACIA1qEPgCDAQLIAIgCiAKQZinxgAQ6gcAC0EAQQggFEHopsYAEOoHAAtBAEEIIBRB+KbGABDqBwALIAIgBiAGQYinxgAQ6gcACyAWQQFxDQBBACEWDAELIANBBHQhCiAHQQR0Ig0gDmwhFCABKAIEIQYgASgCCCECAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAqRQRAIAYgCiAUaiIPaiETQQAhBkEAIAcgEmxBCHQgCmprIQVBACANQQFqIBJsIi5BBHQgCmoiL2shGkEAIA1BAmogEmwiMEEEdCAKaiIxayEMQQAgDUEDaiASbCIyQQR0IApqIjNrIRRBACANQQRqIBJsIjRBBHQgCmoiNWshFkEAIA1BBWogEmwiNkEEdCAKaiI3ayEYQQAgDUEGaiASbCI4QQR0IApqIjlrISZBACANQQdqIBJsIh1BBHQgCmoiHmshIkEAIA1BCGogEmwiOkEEdCAKaiIXayEbQQAgDUEJaiASbCIcQQR0IApqIjxrISdBACANQQpqIBJsIj1BBHQgCmoiPmshKEEAIA1BC2ogEmwiP0EEdCAKaiJAayEpQQAgDUEMaiASbCIkQQR0IApqIkFrISpBACANQQ1qIBJsIkJBBHQgCmoiQ2shK0EAIA1BDmogEmwiREEEdCAKaiIjayEsQQAgDUEPaiASbCIlQQR0IApqIkVrIS0DQCAGIA9qIg0gAksNESACIAVqIg1BB00NFCAIIAkgECAGIBNqIh8QlAQgBiAvaiACSw0QIAIgGmoiDUEISQ0UIAggCSAQIA4gH2oiHxCUBCAGIDFqIAJLDQ8gAiAMaiINQQhJDRQgCCAJIBAgDiAfaiIfEJQEIAYgM2ogAksNDiACIBRqIg1BCEkNFCAIIAkgECAOIB9qIh8QlAQgBiA1aiACSw0NIAIgFmoiDUEISQ0UIAggCSAQIA4gH2oiHxCUBCAGIDdqIAJLDQwgAiAYaiINQQhJDRQgCCAJIBAgDiAfaiIfEJQEIAYgOWogAksNCyACICZqIg1BCEkNFCAIIAkgECAOIB9qIh8QlAQgBiAeaiACSw0KIAIgImoiDUEISQ0UIAggCSAQIA4gH2oiHxCUBCAGIBdqIAJLDQkgAiAbaiINQQhJDRQgCCAJIBAgDiAfaiIfEJQEIAYgPGogAksNCCACICdqIg1BCEkNFCAIIAkgECAOIB9qIh8QlAQgBiA+aiACSw0HIAIgKGoiDUEISQ0UIAggCSAQIA4gH2oiHxCUBCAGIEBqIAJLDQYgAiApaiINQQhJDRQgCCAJIBAgDiAfaiIfEJQEIAYgQWogAksNBSACICpqIg1BCEkNFCAIIAkgECAOIB9qIh8QlAQgBiBDaiACSw0EIAIgK2oiDUEISQ0UIAggCSAQIA4gH2oiHxCUBCAGICNqIAJLDQMgAiAsaiINQQhJDRQgCCAJIBAgDiAfaiIfEJQEIAYgRWogAksNAiACIC1qIg1BCEkNFCAIIAkgECAOIB9qEJQEIAVBBGshBSAaQQRrIRogDEEEayEMIBRBBGshFCAWQQRrIRYgGEEEayEYICZBBGshJiAiQQRrISIgG0EEayEbICdBBGshJyAoQQRrISggKUEEayEpICpBBGshKiArQQRrISsgLEEEayEsIC1BBGshLSAGQQRqIgZBDEcNAAsMEQsgEEH/AXEhDyAGIAogFGoiPGohPUEAIAcgEmxBCHQgCmprIRogBiANQQFqIBJsIj5BBHQgCmoiLmohP0EAIC5rIQwgBiANQQJqIBJsIkBBBHQgCmoiL2ohJEEAIC9rIRQgBiANQQNqIBJsIkFBBHQgCmoiMGohQkEAIDBrIRYgBiANQQRqIBJsIkNBBHQgCmoiMWohREEAIDFrIRggBiANQQVqIBJsIiNBBHQgCmoiMmohJUEAIDJrISYgBiANQQZqIBJsIkVBBHQgCmoiM2ohH0EAIDNrISIgBiANQQdqIBJsIklBBHQgCmoiNGohSkEAIDRrIRsgBiANQQhqIBJsIktBBHQgCmoiNWohTEEAIDVrIScgBiANQQlqIBJsIk1BBHQgCmoiNmohTkEAIDZrISggBiANQQpqIBJsIk9BBHQgCmoiN2ohUEEAIDdrISkgBiANQQtqIBJsIlFBBHQgCmoiOGohUkEAIDhrISogBiANQQxqIBJsIlNBBHQgCmoiOWohVEEAIDlrISsgBiANQQ1qIBJsIlVBBHQgCmoiHWohVkEAIB1rISwgBiANQQ5qIBJsIldBBHQgCmoiHmohWEEAIB5rIS0gBiANQQ9qIBJsIllBBHQgCmoiOmohWkEAIDprIQ1BdCEGAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAAkAgAiAGIDxqIgVBDGpPBEAgAiAaaiIFQQdLDQEMEwsgBUEMagwRCyAPIAYgPWoiBUEOai0AACAFQRFqLQAAayITIBNBH3UiF3MgF2tBAXYgBUEPaiIgLQAAIhcgBUEQaiIhLQAAIhxrIgUgBUEfdSIFcyAFa0EBdGpPBEAgIEH/AEGAfyAXQfwAQYB/IBwgF2tBA2xB/wBBgH8gEyATQYB/TBsiBSAFQf8AThtqIgUgBUGAf0wbIgUgBUH8AE4bQQNqQQN1akGAAWsiEyATQYB/TBsiEyATQf8AThtBgAFzOgAAICFB/wBBgH8gHEH7ACAFIAVB+wBOG0EEakEDdWtBgAFrIgUgBUGAf0wbIgUgBUH/AE4bQYABczoAAAsgBiAuakEMaiACSw0PIAIgDGoiBUEISQ0RIA8gBiA/aiIFQQ5qLQAAIAVBEWotAABrIhMgE0EfdSIXcyAXa0EBdiAFQQ9qIiAtAAAiFyAFQRBqIiEtAAAiHGsiBSAFQR91IgVzIAVrQQF0ak8EQCAgQf8AQYB/IBdB/ABBgH8gHCAXa0EDbEH/AEGAfyATIBNBgH9MGyIFIAVB/wBOG2oiBSAFQYB/TBsiBSAFQfwAThtBA2pBA3VqQYABayITIBNBgH9MGyITIBNB/wBOG0GAAXM6AAAgIUH/AEGAfyAcQfsAIAUgBUH7AE4bQQRqQQN1a0GAAWsiBSAFQYB/TBsiBSAFQf8AThtBgAFzOgAACyAGIC9qQQxqIAJLDQ4gAiAUaiIFQQhJDREgDyAGICRqIgVBDmotAAAgBUERai0AAGsiEyATQR91IhdzIBdrQQF2IAVBD2oiIC0AACIXIAVBEGoiIS0AACIcayIFIAVBH3UiBXMgBWtBAXRqTwRAICBB/wBBgH8gF0H8AEGAfyAcIBdrQQNsQf8AQYB/IBMgE0GAf0wbIgUgBUH/AE4baiIFIAVBgH9MGyIFIAVB/ABOG0EDakEDdWpBgAFrIhMgE0GAf0wbIhMgE0H/AE4bQYABczoAACAhQf8AQYB/IBxB+wAgBSAFQfsAThtBBGpBA3VrQYABayIFIAVBgH9MGyIFIAVB/wBOG0GAAXM6AAALIAYgMGpBDGogAksNDSACIBZqIgVBCEkNESAPIAYgQmoiBUEOai0AACAFQRFqLQAAayITIBNBH3UiF3MgF2tBAXYgBUEPaiIgLQAAIhcgBUEQaiIhLQAAIhxrIgUgBUEfdSIFcyAFa0EBdGpPBEAgIEH/AEGAfyAXQfwAQYB/IBwgF2tBA2xB/wBBgH8gEyATQYB/TBsiBSAFQf8AThtqIgUgBUGAf0wbIgUgBUH8AE4bQQNqQQN1akGAAWsiEyATQYB/TBsiEyATQf8AThtBgAFzOgAAICFB/wBBgH8gHEH7ACAFIAVB+wBOG0EEakEDdWtBgAFrIgUgBUGAf0wbIgUgBUH/AE4bQYABczoAAAsgBiAxakEMaiACSw0MIAIgGGoiBUEISQ0RIA8gBiBEaiIFQQ5qLQAAIAVBEWotAABrIhMgE0EfdSIXcyAXa0EBdiAFQQ9qIiAtAAAiFyAFQRBqIiEtAAAiHGsiBSAFQR91IgVzIAVrQQF0ak8EQCAgQf8AQYB/IBdB/ABBgH8gHCAXa0EDbEH/AEGAfyATIBNBgH9MGyIFIAVB/wBOG2oiBSAFQYB/TBsiBSAFQfwAThtBA2pBA3VqQYABayITIBNBgH9MGyITIBNB/wBOG0GAAXM6AAAgIUH/AEGAfyAcQfsAIAUgBUH7AE4bQQRqQQN1a0GAAWsiBSAFQYB/TBsiBSAFQf8AThtBgAFzOgAACyAGIDJqQQxqIAJLDQsgAiAmaiIFQQhJDREgDyAGICVqIgVBDmotAAAgBUERai0AAGsiEyATQR91IhdzIBdrQQF2IAVBD2oiIC0AACIXIAVBEGoiIS0AACIcayIFIAVBH3UiBXMgBWtBAXRqTwRAICBB/wBBgH8gF0H8AEGAfyAcIBdrQQNsQf8AQYB/IBMgE0GAf0wbIgUgBUH/AE4baiIFIAVBgH9MGyIFIAVB/ABOG0EDakEDdWpBgAFrIhMgE0GAf0wbIhMgE0H/AE4bQYABczoAACAhQf8AQYB/IBxB+wAgBSAFQfsAThtBBGpBA3VrQYABayIFIAVBgH9MGyIFIAVB/wBOG0GAAXM6AAALIAYgM2pBDGogAksNCiACICJqIgVBCEkNESAPIAYgH2oiBUEOai0AACAFQRFqLQAAayITIBNBH3UiF3MgF2tBAXYgBUEPaiIgLQAAIhcgBUEQaiIhLQAAIhxrIgUgBUEfdSIFcyAFa0EBdGpPBEAgIEH/AEGAfyAXQfwAQYB/IBwgF2tBA2xB/wBBgH8gEyATQYB/TBsiBSAFQf8AThtqIgUgBUGAf0wbIgUgBUH8AE4bQQNqQQN1akGAAWsiEyATQYB/TBsiEyATQf8AThtBgAFzOgAAICFB/wBBgH8gHEH7ACAFIAVB+wBOG0EEakEDdWtBgAFrIgUgBUGAf0wbIgUgBUH/AE4bQYABczoAAAsgBiA0akEMaiACSw0JIAIgG2oiBUEISQ0RIA8gBiBKaiIFQQ5qLQAAIAVBEWotAABrIhMgE0EfdSIXcyAXa0EBdiAFQQ9qIiAtAAAiFyAFQRBqIiEtAAAiHGsiBSAFQR91IgVzIAVrQQF0ak8EQCAgQf8AQYB/IBdB/ABBgH8gHCAXa0EDbEH/AEGAfyATIBNBgH9MGyIFIAVB/wBOG2oiBSAFQYB/TBsiBSAFQfwAThtBA2pBA3VqQYABayITIBNBgH9MGyITIBNB/wBOG0GAAXM6AAAgIUH/AEGAfyAcQfsAIAUgBUH7AE4bQQRqQQN1a0GAAWsiBSAFQYB/TBsiBSAFQf8AThtBgAFzOgAACyAGIDVqQQxqIAJLDQggAiAnaiIFQQhJDREgDyAGIExqIgVBDmotAAAgBUERai0AAGsiEyATQR91IhdzIBdrQQF2IAVBD2oiIC0AACIXIAVBEGoiIS0AACIcayIFIAVBH3UiBXMgBWtBAXRqTwRAICBB/wBBgH8gF0H8AEGAfyAcIBdrQQNsQf8AQYB/IBMgE0GAf0wbIgUgBUH/AE4baiIFIAVBgH9MGyIFIAVB/ABOG0EDakEDdWpBgAFrIhMgE0GAf0wbIhMgE0H/AE4bQYABczoAACAhQf8AQYB/IBxB+wAgBSAFQfsAThtBBGpBA3VrQYABayIFIAVBgH9MGyIFIAVB/wBOG0GAAXM6AAALIAYgNmpBDGogAksNByACIChqIgVBCEkNESAPIAYgTmoiBUEOai0AACAFQRFqLQAAayITIBNBH3UiF3MgF2tBAXYgBUEPaiIgLQAAIhcgBUEQaiIhLQAAIhxrIgUgBUEfdSIFcyAFa0EBdGpPBEAgIEH/AEGAfyAXQfwAQYB/IBwgF2tBA2xB/wBBgH8gEyATQYB/TBsiBSAFQf8AThtqIgUgBUGAf0wbIgUgBUH8AE4bQQNqQQN1akGAAWsiEyATQYB/TBsiEyATQf8AThtBgAFzOgAAICFB/wBBgH8gHEH7ACAFIAVB+wBOG0EEakEDdWtBgAFrIgUgBUGAf0wbIgUgBUH/AE4bQYABczoAAAsgBiA3akEMaiACSw0GIAIgKWoiBUEISQ0RIA8gBiBQaiIFQQ5qLQAAIAVBEWotAABrIhMgE0EfdSIXcyAXa0EBdiAFQQ9qIiAtAAAiFyAFQRBqIiEtAAAiHGsiBSAFQR91IgVzIAVrQQF0ak8EQCAgQf8AQYB/IBdB/ABBgH8gHCAXa0EDbEH/AEGAfyATIBNBgH9MGyIFIAVB/wBOG2oiBSAFQYB/TBsiBSAFQfwAThtBA2pBA3VqQYABayITIBNBgH9MGyITIBNB/wBOG0GAAXM6AAAgIUH/AEGAfyAcQfsAIAUgBUH7AE4bQQRqQQN1a0GAAWsiBSAFQYB/TBsiBSAFQf8AThtBgAFzOgAACyAGIDhqQQxqIAJLDQUgAiAqaiIFQQhJDREgDyAGIFJqIgVBDmotAAAgBUERai0AAGsiEyATQR91IhdzIBdrQQF2IAVBD2oiIC0AACIXIAVBEGoiIS0AACIcayIFIAVBH3UiBXMgBWtBAXRqTwRAICBB/wBBgH8gF0H8AEGAfyAcIBdrQQNsQf8AQYB/IBMgE0GAf0wbIgUgBUH/AE4baiIFIAVBgH9MGyIFIAVB/ABOG0EDakEDdWpBgAFrIhMgE0GAf0wbIhMgE0H/AE4bQYABczoAACAhQf8AQYB/IBxB+wAgBSAFQfsAThtBBGpBA3VrQYABayIFIAVBgH9MGyIFIAVB/wBOG0GAAXM6AAALIAYgOWpBDGogAksNBCACICtqIgVBCEkNESAPIAYgVGoiBUEOai0AACAFQRFqLQAAayITIBNBH3UiF3MgF2tBAXYgBUEPaiIgLQAAIhcgBUEQaiIhLQAAIhxrIgUgBUEfdSIFcyAFa0EBdGpPBEAgIEH/AEGAfyAXQfwAQYB/IBwgF2tBA2xB/wBBgH8gEyATQYB/TBsiBSAFQf8AThtqIgUgBUGAf0wbIgUgBUH8AE4bQQNqQQN1akGAAWsiEyATQYB/TBsiEyATQf8AThtBgAFzOgAAICFB/wBBgH8gHEH7ACAFIAVB+wBOG0EEakEDdWtBgAFrIgUgBUGAf0wbIgUgBUH/AE4bQYABczoAAAsgBiAdakEMaiACSw0DIAIgLGoiBUEISQ0RIA8gBiBWaiIFQQ5qLQAAIAVBEWotAABrIhMgE0EfdSIXcyAXa0EBdiAFQQ9qIiAtAAAiFyAFQRBqIiEtAAAiHGsiBSAFQR91IgVzIAVrQQF0ak8EQCAgQf8AQYB/IBdB/ABBgH8gHCAXa0EDbEH/AEGAfyATIBNBgH9MGyIFIAVB/wBOG2oiBSAFQYB/TBsiBSAFQfwAThtBA2pBA3VqQYABayITIBNBgH9MGyITIBNB/wBOG0GAAXM6AAAgIUH/AEGAfyAcQfsAIAUgBUH7AE4bQQRqQQN1a0GAAWsiBSAFQYB/TBsiBSAFQf8AThtBgAFzOgAACyAGIB5qQQxqIAJLDQIgAiAtaiIFQQhJDREgDyAGIFhqIgVBDmotAAAgBUERai0AAGsiEyATQR91IhdzIBdrQQF2IAVBD2oiIC0AACIXIAVBEGoiIS0AACIcayIFIAVBH3UiBXMgBWtBAXRqTwRAICBB/wBBgH8gF0H8AEGAfyAcIBdrQQNsQf8AQYB/IBMgE0GAf0wbIgUgBUH/AE4baiIFIAVBgH9MGyIFIAVB/ABOG0EDakEDdWpBgAFrIhMgE0GAf0wbIhMgE0H/AE4bQYABczoAACAhQf8AQYB/IBxB+wAgBSAFQfsAThtBBGpBA3VrQYABayIFIAVBgH9MGyIFIAVB/wBOG0GAAXM6AAALIAYgOmpBDGogAksNASACIA1qIgVBCEkNESAPIAYgWmoiBUEOai0AACAFQRFqLQAAayITIBNBH3UiF3MgF2tBAXYgBUEPaiIgLQAAIhcgBUEQaiIhLQAAIhxrIgUgBUEfdSIFcyAFa0EBdGpPBEAgIEH/AEGAfyAXQfwAQYB/IBwgF2tBA2xB/wBBgH8gEyATQYB/TBsiBSAFQf8AThtqIgUgBUGAf0wbIgUgBUH8AE4bQQNqQQN1akGAAWsiEyATQYB/TBsiEyATQf8AThtBgAFzOgAAICFB/wBBgH8gHEH7ACAFIAVB+wBOG0EEakEDdWtBgAFrIgUgBUGAf0wbIgUgBUH/AE4bQYABczoAAAsgGkEEayEaIAxBBGshDCAUQQRrIRQgFkEEayEWIBhBBGshGCAmQQRrISYgIkEEayEiIBtBBGshGyAnQQRrIScgKEEEayEoIClBBGshKSAqQQRrISogK0EEayErICxBBGshLCAtQQRrIS0gDUEEayENIAZBBGoiBg0AC0EBIRYMIgsgWUEEdCAKaiAGakEMagwOCyBXQQR0IApqIAZqQQxqDA0LIFVBBHQgCmogBmpBDGoMDAsgU0EEdCAKaiAGakEMagwLCyBRQQR0IApqIAZqQQxqDAoLIE9BBHQgCmogBmpBDGoMCQsgTUEEdCAKaiAGakEMagwICyBLQQR0IApqIAZqQQxqDAcLIElBBHQgCmogBmpBDGoMBgsgRUEEdCAKaiAGakEMagwFCyAjQQR0IApqIAZqQQxqDAQLIENBBHQgCmogBmpBDGoMAwsgQUEEdCAKaiAGakEMagwCCyBAQQR0IApqIAZqQQxqDAELID5BBHQgCmogBmpBDGoLIAIgAkG4qMYAEOoHAAtBAEEIIAVBqKjGABDqBwALICVBBHQgCmogBmohDQwOCyBEQQR0IApqIAZqIQ0MDQsgQkEEdCAKaiAGaiENDAwLICRBBHQgCmogBmohDQwLCyA/QQR0IApqIAZqIQ0MCgsgPUEEdCAKaiAGaiENDAkLIBxBBHQgCmogBmohDQwICyA6QQR0IApqIAZqIQ0MBwsgHUEEdCAKaiAGaiENDAYLIDhBBHQgCmogBmohDQwFCyA2QQR0IApqIAZqIQ0MBAsgNEEEdCAKaiAGaiENDAMLIDJBBHQgCmogBmohDQwCCyAwQQR0IApqIAZqIQ0MAQsgLkEEdCAKaiAGaiENCyANIAIgAkGYqMYAEOoHAAsCQAJAIAEoAhQiCiADQQN0IgwgB0EDdCIFIBlsaiICSQ0AAkACQCAKIAJrIhRBB00NACABKAIcIQ0gASgCICEGIAggCSAQIAEoAhAiDyACahCUBCACIAZLDQMgBiACayIUQQdNDQEgCCAJIBAgAiANahCUBCAKIAVBAXIgGWwgDGoiAkkNAiAKIAJrIhRBCEkNACAIIAkgECACIA9qEJQEIAIgBksNAyAGIAJrIhRBCEkNASAIIAkgECACIA1qEJQEIAogBUECciAZbCAMaiICSQ0CIAogAmsiFEEISQ0AIAggCSAQIAIgD2oQlAQgAiAGSw0DIAYgAmsiFEEISQ0BIAggCSAQIAIgDWoQlAQgCiAFQQNyIBlsIAxqIgJJDQIgCiACayIUQQhJDQAgCCAJIBAgAiAPahCUBCACIAZLDQMgBiACayIUQQhJDQEgCCAJIBAgAiANahCUBCAKIAVBBHIgGWwgDGoiAkkNAiAKIAJrIhRBCEkNACAIIAkgECACIA9qEJQEIAIgBksNAyAGIAJrIhRBCEkNASAIIAkgECACIA1qEJQEIAogBUEFciAZbCAMaiICSQ0CIAogAmsiFEEISQ0AIAggCSAQIAIgD2oQlAQgAiAGSw0DIAYgAmsiFEEISQ0BIAggCSAQIAIgDWoQlAQgCiAFQQZyIBlsIAxqIgJJDQIgCiACayIUQQhJDQAgCCAJIBAgAiAPahCUBCACIAZLDQMgBiACayIUQQhJDQEgCCAJIBAgAiANahCUBCAKIAVBB3IgGWwgDGoiAkkNAiAKIAJrIhRBCEkNACAIIAkgECACIA9qEJQEIAIgBksNAyAGIAJrIhRBCEkNASAIIAkgECACIA1qEJQEQQEhFgwEC0EAQQggFEHIp8YAEOoHAAtBAEEIIBRB2KfGABDqBwALIAIgCiAKQfinxgAQ6gcACyACIAYgBkHop8YAEOoHAAsCQCAHRQ0AIAcgDmxBBHQgA0EEdGoiCkEPciENIApBDnIhFCAKQQ1yIQwgCkEMciEFIApBC3IhDyAKQQpyIRogCkEJciEYIApBCHIhJiAKQQdyISIgCkEGciEbIApBBXIhJyAKQQRyISggCkEDciEpIApBAnIhKiAKQQFyISsgASgCCCEGIAEoAgQhAiABLQAqRQRAIAggCSARIAIgBiAKIA4Q+gIgCCAJIBEgAiAGICsgDhD6AiAIIAkgESACIAYgKiAOEPoCIAggCSARIAIgBiApIA4Q+gIgCCAJIBEgAiAGICggDhD6AiAIIAkgESACIAYgJyAOEPoCIAggCSARIAIgBiAbIA4Q+gIgCCAJIBEgAiAGICIgDhD6AiAIIAkgESACIAYgJiAOEPoCIAggCSARIAIgBiAYIA4Q+gIgCCAJIBEgAiAGIBogDhD6AiAIIAkgESACIAYgDyAOEPoCIAggCSARIAIgBiAFIA4Q+gIgCCAJIBEgAiAGIAwgDhD6AiAIIAkgESACIAYgFCAOEPoCIAggCSARIAIgBiANIA4Q+gIgASgCICEGIAEoAhwhAiAIIAkgESABKAIQIg0gASgCFCIUIAcgGWxBA3QgA0EDdGoiCiAZEPoCIAggCSARIAIgBiAKIBkQ+gIgCCAJIBEgDSAUIApBAXIiDCAZEPoCIAggCSARIAIgBiAMIBkQ+gIgCCAJIBEgDSAUIApBAnIiDCAZEPoCIAggCSARIAIgBiAMIBkQ+gIgCCAJIBEgDSAUIApBA3IiDCAZEPoCIAggCSARIAIgBiAMIBkQ+gIgCCAJIBEgDSAUIApBBHIiDCAZEPoCIAggCSARIAIgBiAMIBkQ+gIgCCAJIBEgDSAUIApBBXIiDCAZEPoCIAggCSARIAIgBiAMIBkQ+gIgCCAJIBEgDSAUIApBBnIiDCAZEPoCIAggCSARIAIgBiAMIBkQ+gIgCCAJIBEgDSAUIApBB3IiCiAZEPoCIAggCSARIAIgBiAKIBkQ+gIMAQsgESACIAYgCiAOEOEFIBEgAiAGICsgDhDhBSARIAIgBiAqIA4Q4QUgESACIAYgKSAOEOEFIBEgAiAGICggDhDhBSARIAIgBiAnIA4Q4QUgESACIAYgGyAOEOEFIBEgAiAGICIgDhDhBSARIAIgBiAmIA4Q4QUgESACIAYgGCAOEOEFIBEgAiAGIBogDhDhBSARIAIgBiAPIA4Q4QUgESACIAYgBSAOEOEFIBEgAiAGIAwgDhDhBSARIAIgBiAUIA4Q4QUgESACIAYgDSAOEOEFCyAWRQ0DIANBBHQhESAHQQR0IQogASgCCCEGIAEoAgQhAiABLQAqRQRAIBJBBnQhFCAKQQRqIBJsQQR0IBFqQQ9qIQ1BfSEFA0AgCCAJIBAgAiAGIA1BD2sgDhDgBCAIIAkgECACIAYgDUEOayAOEOAEIAggCSAQIAIgBiANQQ1rIA4Q4AQgCCAJIBAgAiAGIA1BDGsgDhDgBCAIIAkgECACIAYgDUELayAOEOAEIAggCSAQIAIgBiANQQprIA4Q4AQgCCAJIBAgAiAGIA1BCWsgDhDgBCAIIAkgECACIAYgDUEIayAOEOAEIAggCSAQIAIgBiANQQdrIA4Q4AQgCCAJIBAgAiAGIA1BBmsgDhDgBCAIIAkgECACIAYgDUEFayAOEOAEIAggCSAQIAIgBiANQQRrIA4Q4AQgCCAJIBAgAiAGIA1BA2sgDhDgBCAIIAkgECACIAYgDUECayAOEOAEIAggCSAQIAIgBiANQQFrIA4Q4AQgCCAJIBAgAiAGIA0gDhDgBCANIBRqIQ0gBUEBaiIFDQALIAEoAiAhBiABKAIcIQIgCCAJIBAgASgCECIRIAEoAhQiCiAZIAdBA3RBBHJsIANBA3RqIg4gGRDgBCAIIAkgECACIAYgDiAZEOAEIAggCSAQIBEgCiAOQQFyIg0gGRDgBCAIIAkgECACIAYgDSAZEOAEIAggCSAQIBEgCiAOQQJyIg0gGRDgBCAIIAkgECACIAYgDSAZEOAEIAggCSAQIBEgCiAOQQNyIg0gGRDgBCAIIAkgECACIAYgDSAZEOAEIAggCSAQIBEgCiAOQQRyIg0gGRDgBCAIIAkgECACIAYgDSAZEOAEIAggCSAQIBEgCiAOQQVyIg0gGRDgBCAIIAkgECACIAYgDSAZEOAEIAggCSAQIBEgCiAOQQZyIg0gGRDgBCAIIAkgECACIAYgDSAZEOAEIAggCSAQIBEgCiAOQQdyIg4gGRDgBCAIIAkgECACIAYgDiAZEOAEDAQLIBJBBnQhDSAKQQRqIBJsQQR0IBFqQQ9qIQlBfSEIA0AgECACIAYgCUEPayAOEOEFIBAgAiAGIAlBDmsgDhDhBSAQIAIgBiAJQQ1rIA4Q4QUgECACIAYgCUEMayAOEOEFIBAgAiAGIAlBC2sgDhDhBSAQIAIgBiAJQQprIA4Q4QUgECACIAYgCUEJayAOEOEFIBAgAiAGIAlBCGsgDhDhBSAQIAIgBiAJQQdrIA4Q4QUgECACIAYgCUEGayAOEOEFIBAgAiAGIAlBBWsgDhDhBSAQIAIgBiAJQQRrIA4Q4QUgECACIAYgCUEDayAOEOEFIBAgAiAGIAlBAmsgDhDhBSAQIAIgBiAJQQFrIA4Q4QUgECACIAYgCSAOEOEFIAkgDWohCSAIQQFqIggNAAsMAwtBAEEIIA1BiKjGABDqBwALQQBBCCAMQcioxgAQ6gcAC0EAQQggDEGop8YAEOoHAAsgA0EBaiIDIEhHDQEMAgsLIAYgCUHoqMYAEIwHAAsgB0EBaiEHIAsgCyBHSSIGaiEDIAYNAAsLIAAgAf0AAgD9CwIAIABBIGogAUEgav0AAgD9CwIAIABBEGogAUEQav0AAgD9CwIAIAEoAnQiAARAIBUoAgAgAEECdEEBEKIHCyABKAKQBCIABEAgASgClAQgAEEebEEBEKIHCyBdEL8CIAEoAvAEQYAhQQEQogcgASgCnAQiAARAIAEoAqAEIABBHmxBARCiBwsgASgCqAQiAARAIAEoAqwEIABBARCiBwsgASgCtAQiAARAIAEoArgEIABBARCiBwsgASgCwAQiAARAIAEoAsQEIABBARCiBwsgASgCzAQiAARAIAEoAtAEIABBARCiBwsgASgC2AQiAEUNBCABKALcBCAAQQEQogcMBAsgekIgiKchEiB6QhCIpyEVIHpCCIinIQgLCyAAIA42AhAgACADOgAIIAAgAjsBBiAAIAc6AAUgACALOgAEIABBgICAgHg2AgAgAEEPaiASQRh2rTwAACAAQQ1qIBJBCHatPQAAIAAgEkEYdK0gCEH/AXEgFUEIdHKtQv///weDhD4ACQsgASgCdCIABEAgASgCcCIGQQRrKAIAIgNBeHEiCyAAQQJ0IgBBBEEIIANBA3EiAxtqSQ0CIANBACALIABBJ2pLGw0DIAYQogILIAEoApAEIgAEQCABKAKUBCIGQQRrKAIAIgNBeHEiCyAAQR5sIgBBBEEIIANBA3EiAxtqSQ0CIANBACALIABBJ2pLGw0DIAYQogILIAEoAgAiAARAIAEoAgQiBkEEaygCACIDQXhxIgtBBEEIIANBA3EiAxsgAGpJDQIgA0EAIAsgAEEnaksbDQMgBhCiAgsgASgCDCIABEAgASgCECIGQQRrKAIAIgNBeHEiC0EEQQggA0EDcSIDGyAAakkNAiADQQAgCyAAQSdqSxsNAyAGEKICCyABKAIYIgAEQCABKAIcIgZBBGsoAgAiA0F4cSILQQRBCCADQQNxIgMbIABqSQ0CIANBACALIABBJ2pLGw0DIAYQogILIAFBmAFqEL8CIAEoAvAEIgZBBGsoAgAiAEF4cUGEIUGIISAAQQNxIgMbSQ0BIANBACAAQaghTxsNAiAGEKICIAEoApwEIgAEQCABKAKgBCIGQQRrKAIAIgNBeHEiCyAAQR5sIgBBBEEIIANBA3EiAxtqSQ0CIANBACALIABBJ2pLGw0DIAYQogILIAEoAqgEIgAEQCABKAKsBCIGQQRrKAIAIgNBeHEiC0EEQQggA0EDcSIDGyAAakkNAiADQQAgCyAAQSdqSxsNAyAGEKICCyABKAK0BCIABEAgASgCuAQiBkEEaygCACIDQXhxIgtBBEEIIANBA3EiAxsgAGpJDQIgA0EAIAsgAEEnaksbDQMgBhCiAgsgASgCwAQiAARAIAEoAsQEIgZBBGsoAgAiA0F4cSILQQRBCCADQQNxIgMbIABqSQ0CIANBACALIABBJ2pLGw0DIAYQogILIAEoAswEIgAEQCABKALQBCIGQQRrKAIAIgNBeHEiC0EEQQggA0EDcSIDGyAAakkNAiADQQAgCyAAQSdqSxsNAyAGEKICCyABKALYBCIARQ0AIAEoAtwEIgZBBGsoAgAiA0F4cSILQQRBCCADQQNxIgMbIABqSQ0BIANBACALIABBJ2pLGw0CIAYQogILAkAgASgC5AQiAARAIAEoAugEIgFBBGsoAgAiBkF4cSIDQQRBCCAGQQNxIgYbIABqSQ0CIAZBACADIABBJ2pLGw0BIAEQogILIARBsBlqJAAPCwwBC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu6pAECEX8BfiMAQbABayIGJAAgAy0AACIPQRh0IAMtAAMiB0EYdCINIA9yIAMtAAEiCkEIdCIRIAMtAAIiCUEQdCIMcnIiCEGA/gNxQQh0ciAMQQh2IAdyciEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAYCfwJAAkACQAJAAkACQAJAAkACQCAGAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAi0AAEEBaw4FBAABAgwDCyABQgA3A4ADIAEgAzYC/AIgAUEDOgD4AiAAQQA6AAggACAFNgIEIABBADYCAAxLCyACKAIEIQsgASgCCEECRiAPIBFyIAwgDXJyIgNByZCRkgVHcQ0DIAMgASgC2AIiCEcNBAxJCyACKAABIREgAS0AkQMNBCABKALQAiICIANGDQQgAS0AlANBAUZBACARQSBxGw0FIAAgETYCECAAIAI2AgwgACADNgIIIABBADoABCAAQQE2AgAMSQsgCEGJobm6BEcEQCAAQQE2AgAgAEEBOgAEDEkLIAFCADcDgAMgAUEBOgD4AiAAQQA6AAggACAFNgIEIABBADYCAAxICyAIQY2U6NAARwRAIABBATYCACAAQQE6AAQMSAsgAUIANwOAAyABQQI6APgCIABBADoACCAAIAU2AgQgAEEANgIADEcLIAAgAzYABSAAQQQ6AAQgAEEBNgIADEYLIAhB5siFogVHIAhByYiFogVHcQ1EAkAgBARAIAZBQGshCCABKALwAiENIAEtAPQCIQwjAEEQayILJAACQAJAIAxBAXFFDQAgDS0AowdBB0YNAAJAIAQoAgwiECgCACISIAQoAgQiDEcEQCAMIAQoAggiESgCACIOSQ0BIAtBBGogDUEBQQAgBCgCACAOaiAMIA5rIBIgDmtBABBCIAstAAQEQCAIIAstAAU6AAEgCEEcOgAADAQLIBAgECgCACALKAIMaiIENgIAIA0tAKMHQQdGBEAgESAENgIAIAhBqAI7AQAMBAsgBCAMRwRAIAhBnAI7AQAMBAsgCEEoOwEAIBEgDEGAgAJrIgRBACAEIAxNGyIEIBEoAgAiCCAEIAhLGzYCAAwDCyAIQagCOwEADAILIA4gDCAMQeCQxQAQ6gcACyAIQagCOwEACyALQRBqJAAgBi0AQSEEIAYtAEAiCEEoRg0BIAAgBikBQjcBBiAAQQxqIAZByABqKQEANwEAIAAgBDoABSAAIAg6AAQgAEEBNgIADEcLIAEgBzoAgwMgASAJOgCCAyABIAo6AIEDIAEgDzoAgAMgAUEEIAVrNgKEAyABIAIpAgA3A/gCDEQLIAEgBzoAgwMgASAJOgCCAyABIAo6AIEDIAEgDzoAgAMgAUEEIAVrNgKEAyABIAIpAgA3A/gCIARBAXENQyAAQQU6AAggAEIANwIADEULIAEtAOwCQQFrDgICAwELIAFCADcDgAMgAUECOgD4AiAAIBE2AAkgAEEDOgAIIAAgBTYCBCAAQQA2AgAMQwsgBiARNgIkIBFBGHYhByARQRB2IQIgEUEIdiEEAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBFB/wFxQckAaw4yAG9vb29vbwFvb29vb29vb29vb29vb29vBwoIbwsCBm8Mb29vCW9vBW9vAwRvb29vbw1vCyAEQf8BcUHEAGsOBQ8Obm4NbgsgBEH/AXFBzABHIAJB/wFxQdQAR3IgB0HFAEdyDW0gASgCCEECRg0zIAEoAuABQYGAgIB4Rg0QIAZB0JjRqgQ2AClBCSECIAZBCToAKAxkCyAEQf8BcUHjAGsOAhEQbAsgBEH/AXFBwgBrIgRFDREgBEEQRg0SDGsLIARB/wFxQcUAayIERQ0VIARBDUYNFAxqCyAHQfMARyAEQf8BcUHIAEdyIAJB/wFxQdkAR3INaSABKAIIQQJGDTogAS0AjAMNOyABLQCcAkECRg0XIAZB8JDlmgc2AClBCSECIAZBCToAKAxgCyAHQcEARyAEQf8BcUHBAEdyIAJB/wFxQc0AR3INaCABKAIIIgJBAkYNOyABLQCMAw08IAJBAUcNFyAGQeeCtYoENgApQQkhAiAGQQk6ACgMXwsgB0HMAEcgBEH/AXFB4wBHciACQf8BcUHUAEdyDWcgASgCCEECRg08IAEtAIwDDT0gASgCNEUNFyAGQeHG0eIENgApQQkhAiAGQQk6ACgMXgsgBEH/AXFByABrDgUXGGZmGWYLIAdB1gBHIARB/wFxQcQAR3IgAkH/AXFBwwBHcg1lIAEoAghBAkYNQCABKAJsRQ0cIAZB7YiNsgU2AClBCSECIAZBCToAKAxcCyAHQcQARyAEQf8BcUHLAEdyIAJB/wFxQccAR3INZCABKAIIQQJGDUEgASgC7AFBgYCAgHhGDRwgBkHilp2iBDYAKUEJIQIgBkEJOgAoDFsLIAdB5gBHIARB/wFxQdgAR3IgAkH/AXFByQBHcg1jIAEoAghBAkYNQSABKAKEAkGBgICAeEYNHCAGQeWwpbIGNgApQQkhAiAGQQk6ACgMWgsgBEH/AXFBwwBrIgRFDRwgBEERRg1HDGILIAdB9ABHIARB/wFxQdQAR3INYSACQf8BcUHYAEYNHAxhCyACQf8BcUHEAEcgB0HSAEdyDWAgASgCCEECRg0CIAZByZCRkgU2AClBCQxaCyACQf8BcUHOAEcgB0HEAEdyDV8MXQsgAkH/AXFBwQBHIAdB1ABHcg1eDFwLAkACQCABKALoAiIEQQNNBEBBqJDIACkDACIXpyICQf8BcUEERg0BIAZBL2ogAkEYdjoAACAGIAI6ACwgBkEkOgAoIAYgAkEIdjsALSAGIBdCIIinIgg2AjAMSgsgBEF8cUEERgRAQaiQyAApAwAiF6ciAkH/AXFBBEYNASAGQS9qIAJBGHY6AAAgBiACOgAsIAZBJDoAKCAGIAJBCHY7AC0gBiAXQiCIpyIINgIwDEoLIAEoAuQCIgIoAAAiD0UNACACKAAEIggNAQtBEQxYCwJAIARBCEYEQEEAIQNBqJDIACkDACIXpyICQf8BcUEERg0BIAZBMmogF0IwiD0BACAGIAI6ACwgBkEkOgAoIAYgF0IQiD4BLiAGIBdCCIg8AC0gF0IgiKchCAxJCyACLQAIIgNBAWsiCUH/AXEiB0EPS0GLgQIgB3ZBAXFFcg0AAkACQAJAAkACfyAEQQlGBEBBACEHQaiQyAApAwAiF6ciBEH/AXFBBEcNJCACQQlqIQpBACEMQQAMAQsgAkEJai0AACIMQQZLDQEgBEEKayEHIAJBCmohCkEAQQEgDHRB1QBxDQAaIAxBA0cNAUEBCyECIANBAWsOEAEBAwEDAwMDAwMDAwMDAwIDCyAGIAw6AClBEwxbCyAMQQZNQQBBASAMdEHUAHEbDVkgAkGAgAIgCXZxQQFHDQEMWQsgAg1YCwJAIAdFBEBBACEHQaiQyAApAwAiF6ciAkH/AXFBBEYNASAGQTJqIBdCMIg9AQAgBiACOgAsIAZBJDoAKCAGIBdCEIg+AS4gBiAXQgiIPAAtIBdCIIinIQgMSgsgCi0AACICDSMgB0EBRgRAQQAhB0GokMgAKQMAIhenIgJB/wFxQQRGDQEgBkEyaiAXQjCIPQEAIAYgAjoALCAGQSQ6ACggBiAXQhCIPgEuIAYgF0IIiDwALSAXQiCIpyEIDEoLIAotAAEiAg0kIAdBAkYEQEEAIQdBqJDIACkDACIXpyICQf8BcUEERg0BIAZBMmogF0IwiD0BACAGIAI6ACwgBkEkOgAoIAYgF0IQiD4BLiAGIBdCCIg8AC0gF0IgiKchCAxKC0EAIQcCQAJAIAotAAIiAg4CAgEACyAGIAI6AClBGgxaC0EBIQcLAkAgAUEIaiIJKAIAQQJGDQACQCAJKALAASICQYKAgIB4SCACRXJFBEAgCSgCxAEiBEEEaygCACIKQXhxIgtBBEEIIApBA3EiChsgAmpJDWUgCkEAIAsgAkEnaksbDQEgBBCiAgsgCSgCzAEiAkGCgICAeEggAkVyRQRAIAkoAtABIgRBBGsoAgAiCkF4cSILQQRBCCAKQQNxIgobIAJqSQ1lIApBACALIAJBJ2pLGw0BIAQQogILIAkoAtgBIgJBgoCAgHhIIAJFckUEQCAJKALcASIEQQRrKAIAIgpBeHEiC0EEQQggCkEDcSIKGyACakkNZSAKQQAgCyACQSdqSxsNASAEEKICCyAJKALkASICQYKAgIB4SCACRXJFBEAgCSgC6AEiBEEEaygCACIKQXhxIgtBBEEIIApBA3EiChsgAmpJDWUgCkEAIAsgAkEnaksbDQEgBBCiAgsgCSgC8AEiAkGCgICAeEggAkVyRQRAIAkoAvQBIgRBBGsoAgAiCkF4cSILQQRBCCAKQQNxIgobIAJqSQ1lIApBACALIAJBJ2pLGw0BIAQQogILIAkoAvwBIgJBgoCAgHhIIAJFckUEQCAJKAKAAiIEQQRrKAIAIgpBeHEiC0EEQQggCkEDcSIKGyACakkNZSAKQQAgCyACQSdqSxsNASAEEKICCyAJKAKgASEEIAkoAqQBIgoEQCAEIQIDQCACKAIAIgsEQCACQQRqKAIAIg5BBGsoAgAiDUF4cSIQQQRBCCANQQNxIg0bIAtqSQ1nIA1BACAQIAtBJ2pLGw0DIA4QogILIAJBDGooAgAiCwRAIAJBEGooAgAiDkEEaygCACINQXhxIhBBBEEIIA1BA3EiDRsgC2pJDWcgDUEAIBAgC0EnaksbDQMgDhCiAgsgAkEYaiECIApBAWsiCg0ACwsgCSgCnAEiAgRAIARBBGsoAgAiCkF4cSILIAJBGGwiAkEEQQggCkEDcSIKG2pJDWUgCkEAIAsgAkEnaksbDQEgBBCiAgsgCSgCrAEhBCAJKAKwASIKBEAgBEEUaiECA0AgAkEEaygCACILBEAgAigCACIOQQRrKAIAIg1BeHEiEEEEQQggDUEDcSINGyALakkNZyANQQAgECALQSdqSxsNAyAOEKICCyACQRBrKAIAIgsEQCACQQxrKAIAIg5BBGsoAgAiDUF4cSIQQQRBCCANQQNxIg0bIAtqSQ1nIA1BACAQIAtBJ2pLGw0DIA4QogILIAJBHGohAiAKQQFrIgoNAAsLIAkoAqgBIgIEQCAEQQRrKAIAIgpBeHEiCyACQRxsIgJBBEEIIApBA3EiChtqSQ1lIApBACALIAJBJ2pLGw0BIAQQogILIAkoArgBIQQgCSgCvAEiCgRAIAQhAgNAIAJBEGooAgAiCwRAIAJBFGooAgAiDkEEaygCACINQXhxIhBBBEEIIA1BA3EiDRsgC2pJDWcgDUEAIBAgC0EnaksbDQMgDhCiAgsgAkEcaigCACILBEAgAkEgaigCACIOQQRrKAIAIg1BeHEiEEEEQQggDUEDcSINGyALakkNZyANQQAgECALQSdqSxsNAyAOEKICCyACQShqKAIAIgsEQCACQSxqKAIAIg5BBGsoAgAiDUF4cSIQQQRBCCANQQNxIg0bIAtqSQ1nIA1BACAQIAtBJ2pLGw0DIA4QogILIAJBBGooAgAiCwRAIAJBCGooAgAiDkEEaygCACINQXhxIhBBBEEIIA1BA3EiDRsgC2pJDWcgDUEAIBAgC0EnaksbDQMgDhCiAgsgAkE4aiECIApBAWsiCg0ACwsgCSgCtAEiAkUNASAEQQRrKAIAIglBeHEiCiACQThsIgJBBEEIIAlBA3EiCRtqSQ1kIAlBACAKIAJBJ2pLGw0AIAQQogIMAQsMZAsgASADOgDHAiABIAw6AMYCIAFBBDoAxQIgASAHOgDEAiABIAhBGHQgCEGA/gNxQQh0ciAIQQh2QYD+A3EgCEEYdnJyNgLAAiABIA9BGHQgD0GA/gNxQQh0ciAPQQh2QYD+A3EgD0EYdnJyNgK8AiABQQI6ALkCIAFBAjoAnAIgAUECNgKQAiABQYGAgIB4NgKEAiABQYGAgIB4NgL4ASABQYGAgIB4NgLsASABQYGAgIB4NgLgASABQYGAgIB4NgLUASABQoCAgICQgICAgH83AsQBIAFCgICAgMAANwK8ASABQgQ3ArQBIAFCADcCrAEgAUKAgICAwAA3AqQBIAFBADYCmAEgAUEANgJsIAFBADYCSCABQQA2AkAgAUEANgI0IAFBADYCECABQQA2AggMXAsgBiADOgApQRIMVwsgASgC6AIiB0EASA1iIAEoAuQCIQQCQCAHRQRAQQEhAgwBCyAHEHEiAkUNGQsgBwRAIAIgBCAH/AoAAAsgASAHNgLoASABIAI2AuQBIAEgBzYC4AEMTwsgB0HUAEcgAkH/AXFBwQBHcg1bDFkLIAdBzABHIAJB/wFxQdQAR3INWiABKALkAiEEAkACQAJAAkACQAJAAkACQAJAAkACQCABAn8CQAJAAkAgASgC6AIiA0EDTQRAQQAhCUGokMgAKQMAIhenIgJB/wFxQQRGDQEgBkEvaiACQRh2OgAAIAYgAjoALCAGQSQ6ACggBiACQQh2OwAtIAYgF0IgiKciCDYCMAxUCyAEKAAAIgJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyIQkgA0EEayEDIARBBGohByABKAIARQ0CIAMhDAwBCyADIARqIQdBACEMQQAhA0EAIAEoAgBBAUcNAhoLIAkgASgCBEEBaiIIRw0DIAwhAyAJDAELIAINAUEACzYCBCABQQE2AgAjAEEQayIEJAAgAUHwAmoiAkEAOgAEAkACQEGAgAEQcSIIRQ0AIAhBAEGAgAH8CwBBgBAQcSIMRQ0AIAxBAEGAEPwLACAEQQxqQQA7AQAgBEEANgIIIAIoAgAiAigC+AYiD0EEaygCACIKQXhxQYSAAUGIgAEgCkEDcSILG0kNayALQQAgCkGogAFPGw1sIA8QogIgAigC4AYiCgRAIAIoAuQGIg9BBGsoAgAiC0F4cSINIApBAXQiCkEEQQggC0EDcSILG2pJDWwgC0EAIA0gCkEnaksbDW0gDxCiAgsgAigC/AYiD0EEaygCACIKQXhxQYQQQYgQIApBA3EiCxtJDWsgC0EAIApBqBBPGw1sIA8QogIgAigC7AYiCgRAIAIoAvAGIg9BBGsoAgAiC0F4cSINIApBAXQiCkEEQQggC0EDcSILG2pJDWwgC0EAIA0gCkEnaksbDW0gDxCiAgsgAkEAQdgG/AsAIAJBADYClAcgAkEANgKIByACQQA6AIQHIAJBADYCgAcgAiAMNgL8BiACIAg2AvgGIAJCAjcD8AYgAkIANwPoBiACQoCAgIAgNwPgBiACQQE2AtwGIAJBJDYC2AYgAkEAOgCmByACIAQpAwA3A5gHIAJBngdqIAQpAQY3AQAgBEEQaiQADAELAAsgASABLQCMAyIQOgCOAyADQQNLDQNBACEPQaiQyAApAwAiF6ciAkH/AXFBBEcNAkEAIQhBACEMQQAhBEEAIQsMBAtBACEICyAGIAg2AjAgBiAJNgIsQQohAiAGQQo6ACgMWgsgBkEvaiACQRh2OgAAIAYgAjoALCAGQSQ6ACggBiACQQh2OwAtIAYgF0IgiKciCDYCMAxMCyAHKAAAIgJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyIQggA0F8cSIKQQRGBEBBACEPQaiQyAApAwAiF6ciAkH/AXFBBEYEQEEAIQxBACEEQQAhCwwCCyAGQS9qIAJBGHY6AAAgBiACOgAsIAZBJDoAKCAGIAJBCHY7AC0gBiAXQiCIpyIINgIwDEwLIAcoAAQiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnIhDCAKQQhGBEBBACEPQaiQyAApAwAiF6ciAkH/AXFBBEYEQEEAIQRBACELDAILIAZBL2ogAkEYdjoAACAGIAI6ACwgBkEkOgAoIAYgAkEIdjsALSAGIBdCIIinIgg2AjAMTAsgBygACCICQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZyciEEIApBDEYEQEEAIQ9BqJDIACkDACIXpyICQf8BcUEERgRAQQAhCwwCCyAGQS9qIAJBGHY6AAAgBiACOgAsIAZBJDoAKCAGIAJBCHY7AC0gBiAXQiCIpyIINgIwDEwLIAcoAAwiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnIhCyADQX5xIgJBEEYEQEEAIQ9BqJDIACkDACIXpyICQf8BcUEERg0BIAYgAjoALCAGQSQ6ACggBiAXQhCIPQEuIAYgF0IIiDwALSAGIBdCIIinIgg2AjAMTAsgBy8AECIKQQh0IApBCHZyIQ4gAkESRw0CQQAhD0GokMgAKQMAIhenIgJB/wFxQQRHDQELQQAhCkEAIQMMAgsgBiACOgAsIAZBJDoAKCAGIBdCEIg9AS4gBiAXQgiIPAAtIAYgF0IgiKciCDYCMAxJCyAHLwASIgJBCHQgAkEIdnIhCiADQRRGBEBBACEPQQAhA0GokMgAKQMAIhenIgJB/wFxQQRGDQEgBkEyaiAXQjCIPQEAIAYgAjoALCAGQSQ6ACggBiAXQhCIPgEuIAYgF0IIiDwALSAXQiCIpyEIDEkLIActABQiD0ECSw0BIANBFUYEQEEAIQNBqJDIACkDACIXpyICQf8BcUEERg0BIAZBMmogF0IwiD0BACAGIAI6ACwgBkEkOgAoIAYgF0IQiD4BLiAGIBdCCIg8AC0gF0IgiKchCAxJC0EAIQMCQCAHLQAVIgIOAgEAJgtBASEDCyABKAIIQQJHBEBBESECIAhFIAxFcg0CQRshAiABKALAAiIHIAtJIAwgByALa0tyDQIgASgCvAIiDSAESSAIIA0gBGtLcg0CIBBBAXEgBCALciAHIAxHckUgCCANRnFyDQMgBkEbOgAoDFULQaCSxQAQ3QkACyAGIA86AClBFCECCyAGIAI6ACgMUgsgASADOgC5AiABIA86ALgCIAEgCjsBtgIgASAOOwG0AiABIAs2ArACIAEgBDYCrAIgASAMNgKoAiABIAg2AqQCIAEgCTYCoAIMTQsgB0HUAEcgAkH/AXFByQBHcg1ZIAEoAghBAkYNISABKALgAUGBgICAeEYNASAGQfOEpaIFNgApDE8LIAdBwgBHIAJB/wFxQccAR3INWCABKAIIQQJGDSIgAS0AjAMNIyABLQDFAkEERg0BIAZB86SdkgQ2AClBCSECIAZBCToAKAxPCwJAIAEtAIwDRQRAIAEoAsgBQYGAgIB4Rg0BIAZB84SlogU2AClBCSECIAZBCToAKAxQCyAGQfOEpaIFNgApDE0LIAEoAugCIghBAEgNXSABLQDGAiECIAEtAMcCIQMgASgC5AIhBAJAIAhFBEBBASEJDAELIAgQcSIJRQ0UCyAIBEAgCSAEIAj8CgAACyAGAn8CQCAIIAJBAnQoApiPSSIERgRAQQggAyACQQNGGyECQQAhBwwBCyAGIAg2AjAgBiAENgIsIAYgAjoAKUEMDAELA0AgByAJai0AACIDQQFrQf8BcSACQf8BcUkEQCAHQQFqIgcgCEcNAQwjCwsgBiACOgAqIAYgAzoAKUENCyICOgAoIAgNFkEAIQgMTgsCQCABKALoAkUEQEEAIQdBqJDIACkDACIXpyICQf8BcUEERg0BIAZBMmogF0IwiD0BACAGIAI6ACwgBkEkOgAoIAYgF0IQiD4BLiAGIBdCCIg8AC0gF0IgiKchCAxCCyABKALkAi0AACIHQQRJDQAgBiAHOgApQRchAiAGQRc6ACgMTgsgASAHOgDFAgxJCyAHQdMARyACQf8BcUHOAEdyDVUgASgCCEECRg0hIAEoAtQBQYGAgIB4Rg0BIAZB0JjRqgQ2AClBCSECIAZBCToAKAxMCyAHQfQARyACQf8BcUHYAEdyDVQgASgCiAMiBCABKALoAiICTw0BDEgLIAEoAugCIghBAEgNWSABKALkAiEEIAEtAMcCIQMgAS0AxgIhAgJAIAhFBEBBASEHDAELIAgQcSIHRQ0QCyAIBEAgByAEIAj8CgAACwJAAkACQAJAIAIOBAEAAgMACyAGIAI6AClBECECIAZBEDoAKCAIRQ1NIAcgCEEBEKIHDE0LIAhBAk8EQCAIIQIgA0H/AXFBEEkNIwxHCyAGIAg2AjAgBkECNgIsDEQLIAhBBkkNIiADQf8BcUEQTwRAIAEgCDYC3AEMRwsgByAHLQABOgAAIAcgBy0AAzoAASAHIActAAU6AAIgAUEDNgLcAQxGCyABKALgAUGBgICAeEYNIiABLQCMA0UEQCABIAg2AtwBDEYLIAZB9KS5mgU2AClBCAxDCyABIAQgAms2AogDQZ4EIQgCQAJAIAJFDQAgASgC5AIhCUEAIQcDQCAHIAlqIgMtAAAEQCACIAdBAWoiB0cNAQwCCwtBngIhCCAHQdAAa0Gwf0sNAQsgBiAINgIoQR4hBwxLCyABKAIIQQJGDSIgB0F/cyACaiEPIANBAWohCiACIAdBAWoiDmshDUEAIQwgBkEANgKAASAGQoCAgIAQNwJ4IAZB+ABqQQAgBxDvBSAGKAKAASEDA0BBAUECIAkgDGosAAAiCEEATiIQGyILIAYoAnggA2tLBH8gBkH4AGogAyALEO8FIAYoAoABBSADCyAGKAJ8IgRqIhIgEEUEQCASIAhBvwFxOgABIAhBwAFxQQZ2QUByIQgLIAg6AAAgBiADIAtqIgM2AoABIAcgDEEBaiIMRw0AC0EAIQkgBkEANgJIIAZCgICAgBA3A0AgAiAORwRAIAZBQGtBACANEO8FIAYoAkghCQNAQQFBAiAKLAAAIgJBAE4iCBsiAyAGKAJAIAlrSwR/IAZBQGsgCSADEO8FIAYoAkgFIAkLIAYoAkRqIgcgCAR/IAIFIAcgAkG/AXE6AAEgAkHAAXFBBnZBQHILOgAAIAYgAyAJaiIJNgJIIApBAWohCiAPQQFrIg8NAAsLIAZBPGoiAiAGQYIBai8BADsBACAGIAYoAX42AjggBigCeCIPQYCAgIB4Rg1AIARBCHYhAyAGKQNAIRcgBkGkAWogAi8BADsBACAGIAYoAjg2AqABIAEoAqwBIgogASgCpAFGBEAjAEEgayICJAACQCABQaQBaiIHKAIAIgxBqtWqFUsEf0EABUEEIAxBAXQiCyALQQRNGyILQRhsIQ4gAiAMBH8gAiAMQRhsNgIcIAIgBygCBDYCFEEEBUEACzYCGCACQQhqQQQgDiACQRRqEIUHIAIoAghBAUcNASACKAIQIQcgAigCDAsgB0GAlMUAEJMJAAsgAigCDCEMIAcgCzYCACAHIAw2AgQgAkEgaiQACyABIApBAWo2AqwBIAEoAqgBIApBGGxqIgIgAzoABSACIAQ6AAQgAiAPNgIAIAIgBigCoAE2AQYgAiAJNgIUIAIgFzcBDCACQQpqIAZBpAFqLwEAOwEADD8LAkAgASgC6AIiBEEDTQRAQQAhCUEAIQNBACEHQaiQyAApAwAiF6ciAkH/AXFBBEYNASAGQS9qIAJBGHY6AAAgBiACOgAsIAZBJDoAKCAGIAJBCHY7AC0gBiAXQiCIpyIINgIwDD0LIAEoAuQCIggoAAAiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnIhAyAEQXxxQQRGBEBBACEJQQAhB0GokMgAKQMAIhenIgJB/wFxQQRGDQEgBkEvaiACQRh2OgAAIAYgAjoALCAGQSQ6ACggBiACQQh2OwAtIAYgF0IgiKciCDYCMAw9CyAIKAAEIgJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyIQkgBEEIRgRAQQAhB0GokMgAKQMAIhenIgJB/wFxQQRGDQEgBkEyaiAXQjCIPQEAIAYgAjoALCAGQSQ6ACggBiAXQhCIPgEuIAYgF0IIiDwALSAXQiCIpyEIDD0LQQAhBwJAAkAgCC0ACCICDgICAQALIAYgAjoAKUEWIQIgBkEWOgAoDEoLQQEhBwsgASAHOgCcAiABIAk2ApgCIAEgAzYClAIMRAsCQAJAIAEoAugCQQNNBEBBqJDIACkDACIXpyICQf8BcUEERg0BIAZBL2ogAkEYdjoAACAGIAI6ACwgBkEkOgAoIAYgAkEIdjsALSAGIBdCIIinIgg2AjAMPQsgASgC5AIoAAAiBw0BC0EjIQIgBkEjOgAoDEgLIAFBATYCCCABIAdBGHQgB0GA/gNxQQh0ciAHQQh2QYD+A3EgB0EYdnJyNgIMDEMLIAEoAugCIgJBA00EQEGokMgAKQMAIhenIgdB/wFxQQRGDUMgBkEvaiAHQRh2OgAAIAYgBzoALCAGQSQ6ACggBiAHQQh2OwAtIAYgF0IgiKciCDYCMAw6CyABKALkAiIEKAAAIQcgAkF8cUEERwRAIAQoAAQhAgw8C0EAIQJBqJDIACkDACIXpyIEQf8BcUEERg07IAZBL2ogBEEYdjoAACAGIAQ6ACwgBkEkOgAoIAYgBEEIdjsALSAGIBdCIIinIgg2AjAMOQsgB0HNAEcgAkH/AXFB0gBHcg1OIAEoAghBAkYNJSABLQCMAw0mIAEoAhBFDQIgBkHjkMnqBDYAKUEJIQIgBkEJOgAoDEULIAdB0ABHIAJB/wFxQcMAR3INTSABKAIIQQJGDSYgAS0AkAJBAkYNAiAGQeOSjYIFNgApQQkhAiAGQQk6ACgMRAsgB0HJAEcgAkH/AXFBzABHcg1MIAEoAghBAkYNJiABKAKYAUUNAiAGQeOYscoENgApQQkhAiAGQQk6ACgMQwsgASgC6AIiA0EDTQRAQQAhB0EAIQJBACEJQQAhA0EAIQhBACEMQQAhCkGokMgAKQMAIhenIgRB/wFxQQRGDTcgBkEvaiAEQRh2OgAAIAYgBDoALCAGQSQ6ACggBiAEQQh2OwAtIAYgF0IgiKciCDYCMAw2CyABKALkAiIEKAAAIgJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyIQIgA0F8cSIHQQRGBEBBACEHQQAhCUEAIQNBACEIQQAhDEEAIQpBqJDIACkDACIXpyIEQf8BcUEERg03IAZBL2ogBEEYdjoAACAGIAQ6ACwgBkEkOgAoIAYgBEEIdjsALSAGIBdCIIinIgg2AjAMNgsgBCgABCIDQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZyciEJIAdBCEYEQEEAIQdBACEDQQAhCEEAIQxBACEKQaiQyAApAwAiF6ciBEH/AXFBBEYNNyAGQS9qIARBGHY6AAAgBiAEOgAsIAZBJDoAKCAGIARBCHY7AC0gBiAXQiCIpyIINgIwDDYLIAQoAAgiA0EYdCADQYD+A3FBCHRyIANBCHZBgP4DcSADQRh2cnIhAyAHQQxGBEBBACEHQQAhCEEAIQxBACEKQaiQyAApAwAiF6ciBEH/AXFBBEYNNyAGQS9qIARBGHY6AAAgBiAEOgAsIAZBJDoAKCAGIARBCHY7AC0gBiAXQiCIpyIINgIwDDYLIAQoAAwiCEEYdCAIQYD+A3FBCHRyIAhBCHZBgP4DcSAIQRh2cnIhCCAHQRBGBEBBACEHQQAhDEEAIQpBqJDIACkDACIXpyIEQf8BcUEERg03IAZBL2ogBEEYdjoAACAGIAQ6ACwgBkEkOgAoIAYgBEEIdjsALSAGIBdCIIinIgg2AjAMNgsgBCgAECIMQRh0IAxBgP4DcUEIdHIgDEEIdkGA/gNxIAxBGHZyciEMIAdBFEYEQEEAIQdBACEKQaiQyAApAwAiF6ciBEH/AXFBBEYNNyAGQS9qIARBGHY6AAAgBiAEOgAsIAZBJDoAKCAGIARBCHY7AC0gBiAXQiCIpyIINgIwDDYLIAQoABQiCkEYdCAKQYD+A3FBCHRyIApBCHZBgP4DcSAKQRh2cnIhCyAHQRhGBEBBACEHQQAhCkGokMgAKQMAIhenIgRB/wFxQQRGDTcgBkEvaiAEQRh2OgAAIAYgBDoALCAGQSQ6ACggBiAEQQh2OwAtIAYgF0IgiKciCDYCMAw2CyAEKAAYIgpBGHQgCkGA/gNxQQh0ciAKQQh2QYD+A3EgCkEYdnJyIQogB0EcRwRAIAQoABwhBww3C0EAIQdBqJDIACkDACIXpyIEQf8BcUEERg02IAZBL2ogBEEYdjoAACAGIAQ6ACwgBkEkOgAoIAYgBEEIdjsALSAGIBdCIIinIgg2AjAMNQsgASgC4AFBgYCAgHhHBEAgBkHjko2CBTYAKQxBCwJAAkACQAJAAkACQCABLQCMA0UEQCABKALoAiIHDQJBACEDQaiQyAApAwAiF6ciAkH/AXFBBEcNAUEBIQJBACEIDAMLIAZB45KNggU2ACkMRQsgBkEyaiAXQjCIPQEAIAYgAjoALCAGQSQ6ACggBiAXQhCIPgEuIAYgF0IIiDwALSAXQiCIpyEIDDkLQQEhAiABKALkAiIELQAAIQggB0EBRgRAQQAhA0GokMgAKQMAIhenIgRB/wFxQQRGDQEgBkEyaiAXQjCIPQEAIAYgBDoALCAGQSQ6ACggBiAXQhCIPgEuIAYgF0IIiDwALSAXQiCIpyEIDDkLIAQtAAEhAyAHQQJGBEBBqJDIACkDACIXpyICQf8BcUEERgRAQQEhAgwCCyAGQTJqIBdCMIg9AQAgBiACOgAsIAZBJDoAKCAGIBdCEIg+AS4gBiAXQgiIPAAtIBdCIIinIQgMOQsgBC0AAiECIAdBA0cNASACRSECQaiQyAApAwAhFwsgF6ciB0H/AXFBBEYNASAGQTJqIBdCMIg9AQAgBiAHOgAsIAZBJDoAKCAGIBdCEIg+AS4gBiAXQgiIPAAtIBdCIIinIQgMNwsCQAJAAkAgBC0AAyIJDgICAQALIAZCgSo3AiwgBkEkOgAoQQAhCAw4C0EBIQkLIAINNSAHQQRGDQEgBkKBKjcCLCAGQSQ6AChBACEIDDYLQQAhCSACRQ00CyABIAkgA0H/AXFBEHRyIAhB/wFxQQh0cjYCkAIMPQsCQAJ/IAEoAugCIgRBA00EQEEAIQlBAEGokMgAKQMAIhenIgJB/wFxQQRGDQEaIAZBL2ogAkEYdjoAACAGIAI6ACwgBkEkOgAoIAYgAkEIdjsALSAGIBdCIIinIgg2AjAMNgsgASgC5AIiAygAACICQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZyciEJIARBfHFBBEYEQEEAQaiQyAApAwAiF6ciAkH/AXFBBEYNARogBkEvaiACQRh2OgAAIAYgAjoALCAGQSQ6ACggBiACQQh2OwAtIAYgF0IgiKciCDYCMAw2CyAEQQhHDQEgAygABAshByABIAk2ApwBIAFBATYCmAEgASAHQRh0IAdBgP4DcUEIdHIgB0EIdkGA/gNxIAdBGHZycjYCoAEMPQsgBkKBKjcCLCAGQSQ6AChBACEIDDMLIAEoAuABQYGAgIB4RwRAIAZB7YiNsgU2ACkMPwsCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AjANFBEAgASgC5AIhAiABKALoAiIHQQFLDQJBACEJQaiQyAApAwAiF6ciA0H/AXFBBEcNAUEAIQMMAwsgBkHtiI2yBTYAKQxMCyAGIAM6ACwgBkEkOgAoIAYgF0IQiD0BLiAGIBdCCIg8AC0gBiAXQiCIpyIINgIwDEALIAIvAAAiA0EIdCADQQh2ciEJIAdBAmsiA0EBSw0BQaiQyAApAwAhF0ECIQcLIBenIgRB/wFxQQRGBEAgAiAHaiADaiEHQQAhCEEAIQMMAgsgBiAEOgAsIAZBJDoAKCAGIBdCEIg9AS4gBiAXQgiIPAAtIAYgF0IgiKciCDYCMAw+CyACLwACIgNBCHQgA0EIdnIhCCAHQQRrIgNBAUsNASACQQRqIQdBqJDIACkDACEXCyAXpyICQf8BcUEERgRAIAMgB2ohB0EAIQxBACEDDAILIAYgAjoALCAGQSQ6ACggBiAXQhCIPQEuIAYgF0IIiDwALSAGIBdCIIinIgg2AjAMPAsgAi8ABCIDQQh0IANBCHZyIQwgB0EGayIDQQFLDQEgAkEGaiEHQaiQyAApAwAhFwsgF6ciAkH/AXFBBEYEQCADIAdqIQdBACEDDAILIAYgAjoALCAGQSQ6ACggBiAXQhCIPQEuIAYgF0IIiDwALSAGIBdCIIinIgg2AjAMOgsgAi8ABiIDQQh0IANBCHZyIQsgB0EIayIDQQFLDQEgAkEIaiEHQaiQyAApAwAhFwsgF6ciAkH/AXFBBEYEQCADIAdqIQdBACEKQQAhAwwCCyAGIAI6ACwgBkEkOgAoIAYgF0IQiD0BLiAGIBdCCIg8AC0gBiAXQiCIpyIINgIwDDgLIAIvAAgiA0EIdCADQQh2ciEKIAdBCmsiA0EBSw0BIAJBCmohB0GokMgAKQMAIRcLIBenIgJB/wFxQQRGBEAgAyAHaiEDQQAhBEEAIQ8MAgsgBiACOgAsIAZBJDoAKCAGIBdCEIg9AS4gBiAXQgiIPAAtIAYgF0IgiKciCDYCMAw2CyACLwAKIgNBCHQgA0EIdnIhBCACQQxqIQMgB0EMayIPQQFLDQFBqJDIACkDACEXCyAXpyICQf8BcUEERgRAIAMgD2ohD0EAIQNBAAwCCyAGIAI6ACwgBkEkOgAoIAYgF0IQiD0BLiAGIBdCCIg8AC0gBiAXQiCIpyIINgIwDDQLIAMvAAAiA0EIdCADQQh2ciEOIAdBfnFBDkcEQCAHQRBrIQMgAkEQaiEPIAIvAA4MAQtBACEDQaiQyAApAwAiF6ciD0H/AXFBBEcNJSACIAdqIQ9BAAshBwJAIAECfyADQQNNBEBBACECQQBBqJDIACkDACIXpyIDQf8BcUEERg0BGiAGQS9qIANBGHY6AAAgBiADOgAsIAZBJDoAKCAGIANBCHY7AC0gBiAXQiCIpyIINgIwDDULIA8oAAAiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnIhAiADQXxxQQRGBEBBAEGokMgAKQMAIhenIgNB/wFxQQRGDQEaIAZBL2ogA0EYdjoAACAGIAM6ACwgBkEkOgAoIAYgA0EIdjsALSAGIBdCIIinIgg2AjAMNQsgA0EIRw0BIA8oAAQiA0EYdCADQYD+A3FBCHRyIANBCHZBgP4DcSADQRh2cnILIgM2ApQBIAEgAjYCkAEgASAEQf//A3FBAXQ2AowBIAEgCkH//wNxQQF0NgKIASABIAtB//8DcUEBdDYChAEgASAMQf//A3FBAXQ2AoABIAEgDv0QIAdBCHQgB0GA/gNxQQh2cv0aASAJ/RoCIAj9GgP9qQFBAf2rAf0LA3AgAUEBNgJsDDwLIAZCgSo3AiwgBkEkOgAoQQAhCAwyCwJAAkACQCABLQCMA0UEQEECIQIgAS0AxgJBAWsOBgcCAQMHAgMLIAZB4padogQ2ACkMPwsgASgC4AFBgYCAgHhHBEBBASECDAILIAZCgSo3AiwgBkEkOgAoQQAhCAwzC0EGIQILIAEoAugCIgdBAEgNTQJAIAcEQCABKALkAiEDIAcQcSIERQ0FIAcEQCAEIAMgB/wKAAALIAIgB0cNASABIAI2AvQBIAEgBDYC8AEgASACNgLsAQw8CyAGQeKWnaIENgApQSEhAiAGQSE6ACgMPwsgBkHilp2iBDYAKUEhIQIgBkEhOgAoIAQgB0EBEKIHDD4LIAEoAugCIgdBAEgNTCABKALkAiEEAkAgB0UEQEEBIQIMAQsgBxBxIgJFDQMLIAcEQCACIAQgB/wKAAALIAEgBzYCjAIgASACNgKIAiABIAc2AoQCDDkLIAdB0ABHIAJB/wFxQcMAR3INRSABLQCMAw0kIAEtAI8DRQRAIAFBAToAjwMgASgCCEECRg0mIAEoAugCIgxBAWshDyAMQQJrIQsgASgC5AIiCiAMaiEEQQAhByAMIQMDQCAHIAxGDS0gByAKaiIJQQFqIQggCS0AAEUEQCAHRQ07IANBAWshByAIIQQgAwwsCyAHIA9GDS0gByAKaiECIAgtAABFDSogByALRg0tIAJBAmotAABFDSkgA0EDayEDIAdBA2oiB0HRAEcNAAsMOQsgBkHpho2CBTYAKUEJIQIgBkEJOgAoDDwLIAEoAogDIgMgASgC6AIiAkkEQEEnIQIgBkEnOgAoDDwLIAEgAyACazYCiANBngQhAwJAAkAgAkUNACABKALkAiEEQQAhBwNAIAQgB2otAAAEQCACIAdBAWoiB0cNAQwCCwtBngIhAyAHQdAAa0Gwf0sNAQsgBiADNgIoQR4hAgw8CyAHQQFqIgMgAkYEQCAGQQA2AiwgBkGeCjsBKEEeIQIMPAsgASgCCEECRiIMDQEgAiAHa0ECayEIIAMgBGoiAi0AAA0CQQAgAUEIaiAMGyEJIAJBAWohD0EAIQwgBkEANgJIIAZCgICAgBA3AkAgBkFAa0EAIAcQ7wUgBigCSCECA0BBAUECIAQgDGosAAAiA0EATiILGyIKIAYoAkAgAmtLBH8gBkFAayACIAoQ7wUgBigCSAUgAgsgBigCRGoiDiALBH8gAwUgDiADQb8BcToAASADQcABcUEGdkFAcgs6AAAgBiACIApqIgI2AkggByAMQQFqIgxHDQALIAhBAEgNSiAIRQRAQQEhAgwmCyAIEHEiAg0lCwALQaCUxQAQ3QkACyAGIAg2AjAgBkGeCjsBKEEeIQIMOAsgCSAIQQEQogcMNwsgBkEyaiAXQjCIPQEAIAYgBDoALCAGQSQ6ACggBiAXQhCIPgEuIAYgF0IIiDwALSAXQiCIpyEIDCkLIAFCADcDgAMgAUECOgD4AiAAQQQ6AAggACAFNgIEIABBADYCACAAIAEoAtgCNgAJDEELIAFCADcDgAMgAUECOgD4AiAAIBE2AAkgAEEDOgAIIAAgBTYCBCAAQQA2AgAMQAsgASABKALcAkEEazYC3AIgASgCAEUEQCAAQQE2AgAgAEECOgAEDEALIAEoAgRBAWoiAiADRwRAIAAgAjYCDCAAIAM2AgggAEEKOgAEIABBATYCAAxACyABIAM2AgQgAUEBNgIAIAEtAJEDRQRAIAEgASkDyAJCBHw3A8gCIAEgByAJIAogDyABKALQAkF/cyICc0H/AXFBAnQoApiNQyACQQh2cyICc0H/AXFBAnQoApiNQyACQQh2cyICc0H/AXFBAnQoApiNQyACQQh2cyICc0H/AXFBAnQoApiNQyACQQh2c0F/czYC0AILIAFB5siFogU2APkCIAFBBzoA+AIgAEEAOgAIIAAgBTYCBCAAQQA2AgAMPwsgBiACOgApQRgMNQsgBiACOgApQRkMNAtBwJPFABDdCQALIAYgAjoAKUEVIQIgBkEVOgAoDC8LQdCTxQAQ3QkACyABIAg2AtABIAEgCTYCzAEgASAINgLIAQwpC0Hgk8UAEN0JAAsgBkHzpJ2SBDYAKQwpC0GQlMUAEN0JAAsgByAHLQABOgAAQQEhAgwjCyAGIAg2AjAgBkEGNgIsDCALIAZB9KS5mgU2AClBBgwgC0Hwk8UAEN0JAAtBsJPFABDdCQALIAZB8JDlmgc2ACkMIgtBsJLFABDdCQALIAZB54K1igQ2ACkMIAtBwJHFABDdCQALIAZB4cbR4gQ2ACkMHgtB4JHFABDdCQALIAZB45DJ6gQ2ACkMHAtB8JHFABDdCQALQYCSxQAQ3QkAC0Ggk8UAEN0JAAsgBiAPOgAsIAZBJDoAKCAGIBdCEIg9AS4gBiAXQgiIPAAtIAYgF0IgiKciCDYCMAwNC0HQkcUAEN0JAAtBkJLFABDdCQALIAZB6YaNggU2ACkMFQtB1JXFABDdCQALIAgEQCACIA8gCPwKAAALIAhBCHYhAyAGKQJEIRcgBigCQCEPIAkoArABIgogCSgCqAFGBEAjAEEgayIEJAACQCAJQagBaiIHKAIAIgxBksmkEksEf0EABUEEIAxBAXQiCyALQQRNGyILQRxsIQ4gBCAMBH8gBCAMQRxsNgIcIAQgBygCBDYCFEEEBUEACzYCGCAEQQhqQQQgDiAEQRRqEIUHIAQoAghBAUcNASAEKAIQIQcgBCgCDAsgB0GwlMUAEJMJAAsgBCgCDCEMIAcgCzYCACAHIAw2AgQgBEEgaiQACyABKAK0ASAJIApBAWo2ArABIApBHGxqIgcgFzcCFCAHIA82ARAgByAINgEMIAcgAjYBCCAHIAhBEHY7AQYgByADOgAFIAcgCDoABCAHQQA2AgAMEQsgA0EDayEHIAJBAmohCSACQQNqIQQgA0ECawwBCyADQQJrIQcgAkEBaiEJIAJBAmohBCADQQFrCyAHRQRAQQAhB0GokMgAKQMAIhenIgJB/wFxQQRGDQQMAwsgBC0AAA0OQQJrIQcgCUECaiEEDAMLIAdB9ABHIAJB/wFxQdgAR3INGiABKAKIAyIEIAEoAugCIghJDQ4gASgC5AIhAiABIAQgCGs2AogDQZ4EIQwCQAJAIAhFDQAgAiAIaiEJQQAhB0EAIAhrIQMDQCACIAdqIg8tAAAEQCADIAdBAWoiB2oNAQwCCwtBngIhDCAHQdAAa0Gwf0sNAQsgBiAMNgIoQR4hBwwTCyAHQQFqIgMgCEYEQCAGQQA2AiwgBkGeDjsBKEEeIQcMEwsgCCADayIOQQFNBEAgBkEANgIsIAZBngo7AShBHiEHDBMLAkAgCSACIANqIhBBAmoiBEcEQCAQLQAAIQwgEC0AASEKIAcgCGshC0EAIQMDQCADIA9qQQNqLQAARQ0CIAMgC2ogA0EBaiEDQXxHDQALCyAGQZ4EOwEoQR4hBwwTCwJAAkACQAJAIANBAmoiDyAOSyADQX1LckUEQCADQQNqIgsgDksNAQJAIAkgCyAQaiIPRwRAIAMgB2ohCSAIQQRrIQ1BACEIA0AgAiAJakEEai0AAEUNAiAIQQFqIQggDSAJQQFqIglHDQALCyAGQZ4EOwEoQR4hBwwYCyAIIAtqIgkgCEkgCSAOS3INAiAJQQFqIRIgCSAOTw0DIAEoAghBAkYNBCAGQUBrIQ0gAiEJIAwhCyAQIBJqIRMgDiASayECIwBBIGsiDiQAAkAgB0HQAGtBsH9NBEAgDUECNgIAIA1BAToABAwBCyAOQQA2AhwgDkKAgICAEDcCFCAOQRRqQQAgBxDvBSAOKAIcIQwDQEEBQQIgCSwAACIQQQBOIhQbIhIgDigCFCAMa0sEfyAOQRRqIAwgEhDvBSAOKAIcBSAMCyAOKAIYIhVqIhYgFAR/IBAFIBYgEEG/AXE6AAEgEEHAAXFBBnZBQHILOgAAIA4gDCASaiIMNgIcIAlBAWohCSAHQQFrIgcNAAsgDigCFCEQQQAhBwJAAkACQAJAAkACQAJAAkACQAJAAkAgC0H/AXEOAgEABAsgCkH/AXENAUEBIQcLAkAgA0EETwRAIAQoAABBgIGChHhxDQlBBCAEQQNqQXxxIgkgBGsgBCAJRhsiCSADQQRrIgpJBEADQCAEIAlqKAIAQYCBgoR4cQ0LIAlBBGoiCSAKSQ0ACwsgBCAKaigAAEGAgYKEeHFFDQEMCQsgA0UNACAEIANBAWsiCWosAABBAEgNCCAJRQ0AIAQgA0ECayIJaiwAAEEASA0IIAlFDQAgBCADQQNrIglqLAAAQQBIIAlyDQgLIA5BFGogBCADEPsCIA4oAhRBAUcNASAOIA4pAhg3AwhB3IzFAEELIA5BCGpBzIzFAEHojMUAEOAGAAsgDUECNgIAIA1BBToABAwHCyAOKAIcIgpBAEgNASAOKAIYIQQCQCAKRQRAQQEhCwwBCyAKEHEiC0UNAwsgCgRAIAsgBCAK/AoAAAsgDkEUaiAPIAgQ+wIgDigCFEEBRgRAIA1BAjYCACANQQA6AAQMBQsgDigCHCIPQQBIDS0gDigCGCEEAkAgD0UEQEEBIRIMAQsgDxBxIhJFDQMLIA8EQCASIAQgD/wKAAALAn8CQCAHRQRAIAJBAEgNMAJAIAJFBEBBASEJDAELIAIQcSIJRQ0GCyACBEAgCSATIAL8CgAACyAOIAI2AhAgDiAJNgIMIA4gAjYCCCAOQRRqIAkgAhD7AiAOKAIURQ0BQQAhCSACRQ0GIA4pAgynIAJBARCiBwwGCyACQQBIDS8CQCACRQRAQQEhCQwBCyACEHEiCUUNBQsgAgRAIAkgEyAC/AoAAAsgCUEIdiETIAIhBEEADAELIA4pAwgiF0IgiKchCSAXpyIEQYCAgIB4Rg0EIBdCKIinIRNBAQshFCANIBM7AAkgDSAHOgA0IA0gDzYCMCANIBI2AiwgDSAPNgIoIA0gCjYCJCANIAs2AiAgDSAKNgIcIA0gDDYCGCANIBU2AhQgDSAQNgIQIA0gAjYCDCANIAk6AAggDSAENgIEIA0gFDYCACANQQtqIBNBEHY6AAAMBwsgDUECNgIAIA1BBjoABAwFC0HYmsgAEP8HCwALIA1BAjYCACANIAk6AAQgD0UNACASIA9BARCiBwsgCkUNASALIApBARCiBwwBCyANQQI2AgAgDUEAOgAECyAQRQ0AAkAgFUEEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgEGpPBEAgAkEAIAQgEEEnaksbDQEgFRCiAgwCCwwlCwwlCyAOQSBqJAAgBi0ARCEEIAYoAkAiCUECRg0NIAZBiAFqIgggBkHkAGr9AAIA/QsDACAGQZgBaiIKIAZB9ABqKAIANgIAIAYgBikBRjcDoAEgBiAG/QACVP0LA3ggBiAGQcwAaikBADcBpgEgBi0ARSEPIAEoAsQBIgMgASgCvAFGBEAjAEEgayICJAACQCABQbwBaiIHKAIAIgxByaSSCUsEf0EABUEEIAxBAXQiCyALQQRNGyILQThsIQ4gAiAMBH8gAiAMQThsNgIcIAIgBygCBDYCFEEEBUEACzYCGCACQQhqQQQgDiACQRRqEIUHIAIoAghBAUcNASACKAIQIQcgAigCDAsgB0HQksUAEJMJAAsgAigCDCEMIAcgCzYCACAHIAw2AgQgAkEgaiQACyABKALAASADQThsaiICQSRqIAj9AAMA/QsCACACIA86AAUgAiAEOgAEIAIgCTYCACACIAYpA6ABNwEGIAIgBv0AA3j9CwIUIAJBDGogBikBpgE3AQAgAkE0aiAKKAIANgIAIAEgA0EBajYCxAEMDAtBAiAPIA5BkJPFABDqBwALIAsgDiAOQYCTxQAQ6gcACyALIAkgDkHwksUAEOoHAAsgEiAOIA5B4JLFABDqBwALQcCSxQAQ3QkAC0EAIQdBqJDIACkDACIXpyICQf8BcUEERw0AIAwNAQwMCyACQf8BcUEDRw0LIBdCIIinIgcoAgAhAiAHQQRqKAIAIgQoAgAiAwRAIAIgAxEDAAsgBCgCBCIDBEAgAiADIAQoAggQogcLIAdBDEEEEKIHDAsLIAZBQGsgBCAHIAEoAogDIgIQ3wEgBigCRCEHAkACQCAGKAJAQQFGBEAgB0GAgICAeHJBgICAgHhGDQ0gBigCSCEJDAELIAYoAkghCSACIAYoAkwiA08NASAHRQ0MCyAJIAdBARCiBwwLCyABIAIgA2s2AogDIAEoAvgBIgJBgoCAgHhIIAJFckUEQCABKAL8ASACQQEQogcLIAEgAzYCgAIgASAJNgL8ASABIAc2AvgBDAoLIAZCgSo3AiwgBkEkOgAoQQAhCAsgBiAGKAApNgJAIAYgBkEsaigAADYAQyAGQShqQQFyIQlBJCECIAYoAiQhBwJ/AkACQAJAIAYtAENBAWsOAwABAhULIAZBxABqDAILIAhBCGoMAQsgCEEIagstAABBJUcNEUEhIQIgBi0AQ0EDTwRAIAgoAgAhAyAIQQRqKAIAIgQoAgAiDARAIAMgDBEDAAsgBCgCBCIMBEAgAyAMIAQoAggQogcLIAhBDEEEEKIHCwwSCyABIAo2AiwgASALNgIoIAEgDDYCJCABIAg2AiAgASADNgIcIAEgCTYCGCABIAI2AhQgAUEBNgIQIAEgB0EYdCAHQYD+A3FBCHRyIAdBCHZBgP4DcSAHQRh2cnI2AjAMBwsgB0UNBiACQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZyciICIAdBGHQgB0GA/gNxQQh0ciAHQQh2QYD+A3EgB0EYdnJyIgdyQQBIDQYgASACNgI8IAEgBzYCOCABQQE2AjQMBgtBKCEHIAZBKDoAKAwKCyAGIAQ6AClBHiEHIAZBHjoAKAwJC0ELCyICOgAoIAhFBEBBACEIDAcLIAcgCEEBEKIHDAYLIAEgAjYC3AELIAEgBzYC2AEgASAINgLUAQsgBkEoakEBciEJQSghAgwLC0EnIQcgBkEnOgAoDAMLQQUhAiAGQQU6ACgMAQtBByECIAZBBzoAKAsgBiAGKAApNgJAIAYgBkEsaigAADYAQyAGQShqQQFyIQkMBAsgBiAGKAApNgJ4IAYgBkEsaigAADYAe0EoIQIgBkEoakEBciEJIAdBKEYNBiAGKAIwIQggByECDAILIAYgDDoAKiAGIAM6AClBDwsiAjoAKCAGIAYoACk2AnggBiAGQSxqKAAANgB7IAZBKGpBAXIhCQsgBiAGKAB7NgBDIAYgBigCeDYCQAsgBkE2aiAGQcYAai0AADoAACAGIAYvAUQ7ATQgBigCQCEHCyAHQRh2IQMMAQsgBkEoakEBciEJQSghAgsgBiADOgAsIAkgBi8BNDsABEECIQMgCUEGaiAGQTZqLQAAOgAAIAYgBzsAKSAGIAdBEHY6ACsgBiAINgIwIAYgAjoAKAJAIAJBKEcEQAJAIAJBI0sNACAGKAIkIgdB5sbR4gRGDQBBAyEDIAdBIHENAgsgBkEaaiICIAYtACs6AAAgBkESaiAGQTNqLQAAOgAAIAYgBi8AKTsBGCAGIAYvADE7ARAgBi0ALCEDIAYoAC0hByAGLQAoIgRBKEYNASAAIAYvARg7AAUgAEEHaiACLQAAOgAAIAYgBigBEDYCCCAGIAZBE2ooAAA2AAsgAEEQaiAGKAALNgAAIAAgBigCCDYADSAAIAc2AAkgACADOgAIIAAgBDoABCAAQQE2AgAMBQsgBigCJCEHCyAGIAYoARA2AgggBiAGQRNqKAAANgALIAYgBigCCDYCHCAGIAYoAAs2AB8gEUHJirmiBEcEQCABQgA3A4ADIAFBAjoA+AILIAAgBzYACSAAIAM6AAggACAFNgIEIAAgBigCHDYADSAAQQA2AgAgAEEQaiAGKAAfNgAADAMLIAZBAjYCRCAGQaSVxQA2AkAgBkIBNwJMIAYgBkEkaq1CgICAgJANhDcDeCAGIAZB+ABqNgJIIAZBQGtBtJXFABCNCAALIAFBADsAjQMgASADNgLYAiAAQQY6AAggAEIANwIADAELIAEgAzYC2AIgAS0AkQNFBEAgAUIENwPIAiABIAcgCSAKIA9B/wFzQQJ0KAKYjUNB////B3MiAnNB/wFxQQJ0KAKYjUMgAkEIdnMiAnNB/wFxQQJ0KAKYjUMgAkEIdnMiAnNB/wFxQQJ0KAKYjUMgAkEIdnNBf3M2AtACCyABQQA2AugCIAEgCzYC3AICQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgD0HJAEcEQCAPQeYARwRAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgD0HQAGsOKwEAAAAAAAAAAAAAAAAAAAAABgkHAAoABQALAAAACAAABAAAAgMAAAAAAAwACyAPQSBxDRhBIiECDCgLQSIhAiAHQcUARyAKQcwAR3IgCUHUAEdyDSdBAyEMQYAGIQIMIgtBBiEIQQEhAiAKQcIAayIERQ0KIARBEEYNCwwkC0EGIQhBASECIApBxQBrIgRFDQwgBEENRg0LDCMLQQYhCEEBIQIgB0HzAEcgCkHIAEdyIAlB2QBHcg0iQQkhAkEJIQwMHwtBBiEIQQEhAiAHQcEARyAKQcEAR3IgCUHNAEdyDSEMHQtBBiEIQQEhAiAHQcwARyAKQeMAR3IgCUHUAEdyDSAMGwtBBiEIQQEhAiAKQcgAaw4FCQofHwsfC0EGIQhBASECIAdB1gBHIApBxABHciAJQcMAR3INHkEYIQJBGCEMDBsLQQYhCEEBIQwgB0HEAEcgCkHLAEdyIAlBxwBHcg0QQQYhAgwaC0EGIQhBASECIAdB5gBHIApB2ABHciAJQckAR3INHEH/////ByECDBoLQQYhCEEBIQIgCkHDAGsiBEUNCCAEQRFGDQkMGwtBBiEIQQEhAiAHQfQARyAKQdQAR3IgCUHYAEdyDRogAS0AkgNBAXENGkH/////ByECDBgLQQEhDCAHQdQARyAJQckAR3INDEEEIQIMFgsgB0HCAEcNGEEBIQwgCUHHAEYNFQwYC0EBIQwgB0HTAEcgCUHOAEdyDQpBgAIhAgwUCyAHQfQARyAJQdgAR3INFiABLQCSA0EBcQ0WQf////8HIQIMFAsgB0HNAEcgCUHSAEdyDRVBICECQSAhDAwSCyAHQdAARw0UIAlBwwBGDRAMFAsgB0HJAEcNEyAJQcwARg0ODBMLIAdB0ABHIAlBwwBHcg0SIAEtAJMDQQFxDRJB/////wchAgwQCyAHQfQARyAJQdgAR3INESABLQCSA0EBcQ0RQf////8HIQIMDwsgCkHkAEcgCUHBAEdyRSAHQdQARnENAUEBIQJBBiEIIApB4wBrDgIGBRALIApBxABHIAlBwQBHckUgB0HUAEZxDQNBIiECIApBxABrDgUGCBERCRELIAEtAI4DRQRAIABB5siFogU2AAUgAEEgOgAEIABBATYCAAwSCyALQQNLBEBBBSEIQQAhAgwPCyAAQQE2AgAgAEEfOgAEDBELQQYhCAtBASECDAwLIAEtAI0DRQRAIABByYiFogU2AAUgAEEgOgAEIABBATYCAAwPCyABQQE6AIwDQQchCEEAIQIMCwsgB0HUAEcNCiAJQcEARg0CDAoLIAdBzABHIAlB1ABHcg0JQRohAkEaIQwMBgsgB0HUAEcgCUHBAEdyDQoLQaT4xgBBKEHElcUAEOsHAAsgB0HEAEcgCUHOAEdyDQhBACECDAQLIAdB0gBHIAlBxABHcg0HQQ0hAkENIQwMAgtBCCECQQghDAwBC0EEIQJBBCEMCyALIAxJDQELIAIgC0kNAEEGIQhBACECDAELQQYhCEECIQICQAJAAkACQAJAIA9ByQBrDh4ABQUFBQUFAQUFBQUFBQUFBQUFBQUFBQUFBQUFBQIFCyAKQcUAaw4EAwQEAgQLIAdBxQBHIApBzABHciAJQdQAR3INAwwECyAHQcwARyAKQeMAR3INAiAJQdQARg0DDAILIAdB0gBHDQEgCUHEAEYNAgwBCyAHQcQARw0AIAlBzgBGDQELIAFCADcDgAMgASADNgD5AiABIAg6APgCIAEgAjoA7AIgACADNgIQIAAgCzYCDCAAQQE6AAggACAFNgIEIABBADYCAAwCC0EhIQILIAAgAzYABSAAIAI6AAQgAEEBNgIACyAGQbABaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQdiayAAQ/wcAC4J7AyJ/B30BfiMAQcABayIEJAACQAJAAkACQAJAIAEoAgBBAkcEQCABKAKkAiICIAEoAmRJBEAgAUH0A2ohFiABQbwCaiETIAFB8ABqIRwgAUGwA2ohHSABQYADaiEeIAFBjANqIR8gAUGYA2ohICABQaQDaiEhA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASgCYCACQShsaiINKQMQIAEpA4ABfCIrIAEpA3BRBEAgASgCuAIiAyANKAIYIgJBB2pBeHFJDQEgAiADSw0CIAEoArQCIQMgDS0AICIbQQFGBEAgBEEYaiADIAIQ+QIgBCgCGCIDQYCAgIB4RwRAIAQoAhwgBEEANgK4ASAEQQE2AqwBIARBuMnBADYCqAEgBEIENwKwASAEQagBahCSByEZIANFDR4gA0EBEKIHDB4LIAQoAiAhGSAEKAIcIhpBgICAgHhGDR0gBCgCJCECIBkhAwtBCSEFAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAn8CQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA0tACJBAWsODQECAxofHR4bHB8dHgQACyANLQAhDgQEBQYHCQsgDS0AIQ4FCwoJCQwJCyANLQAhIgUOBg4NEBAPDxALIA0tACEOChIRERERERERFBMRCyANLQAhQQtrDgIcHRsLIARBGGogAyACQQMgASgCrAIQ+AQMAwsgBEEYaiADIAJBAyABKAKsAhDmAwwCCyAEQRhqIAMgAiABKAKsAhCgAgwBCyAEQRhqIAMgAiABKAKsAhD+AQsgEyABKAKoAiABKAKsAiAEKAIcIgMgBCgCIBDCBSAEKAIYIgJFDTIgA0EEaygCACIIQXhxIgUgAkECdCICQQRBCCAIQQNxIggbakkNOCAIQQAgBSACQSdqSxsNOSADEKICDDILIARBATYCrAEgBEHgycEANgKoASAEQgE3ArQBIAQgDUEhaq1CgICAgJAFhDcDWCAEIARB2ABqNgKwASAEQShqIgEgBEGoAWoQsQYgARCOByEBDDALIARBATYCrAEgBEG8ysEANgKoASAEQgE3ArQBIAQgDUEhaq1CgICAgJAFhDcDWCAEIARB2ABqNgKwASAEQTRqIgEgBEGoAWoQsQYgARCOBwwDCyAEQRhqIAMgAkEBIAEoAqwCEOYDDC0LIARBGGogAyACQQEgASgCrAIQ+AQMLAsgDSgCAEUEQCAEQQA2ArgBIARBATYCrAEgBEGYysEANgKoASAEQgQ3ArABIARBqAFqEJIHDAELIA0oAggNKiAEQQA2ArgBIARBATYCrAEgBEH8ycEANgKoASAEQgQ3ArABIARBqAFqEJIHCyEBDCsLIARBGGogAyACQQMgASgCrAIQ5gMMJwsgBEEYaiADIAJBAyABKAKsAhD4BAwmCyANKAIARQRAIARBADYCuAEgBEEBNgKsASAEQZjKwQA2AqgBIARCBDcCsAEgBEGoAWoQkgcMAgsgDSgCCEUEQCAEQQA2ArgBIARBATYCrAEgBEH8ycEANgKoASAEQgQ3ArABIARBqAFqEJIHDAILIA0qAgQhJCABKAKsAiEIIA0qAgwhJyAFQQRGDSQgBEEYaiADIAJBAyAIICQgJxD/AwwlCyAEQQE2AqwBIARB4MrBADYCqAEgBEIBNwK0ASAEIA1BIWqtQoCAgICQBYQ3A1ggBCAEQdgAajYCsAEgBEFAayIBIARBqAFqELEGIAEQjgcLIQEMJgsgBEEBNgKsASAEQYjLwQA2AqgBIARCATcCtAEgBCANQSFqrUKAgICAkAWENwNYIAQgBEHYAGo2ArABIARBzABqIgEgBEGoAWoQsQYgARCOBwwDCyAEQRhqIAMgAkEDIAEoAqwCEPgEDB8LIARBGGogAyACIAEoAqwCEP0BDB4LIA0oAgBFBEAgBEEANgK4ASAEQQE2AqwBIARBmMrBADYCqAEgBEIENwKwASAEQagBahCSBwwBCyANKAIIDRwgBEEANgK4ASAEQQE2AqwBIARB/MnBADYCqAEgBEIENwKwASAEQagBahCSBwshAQwhCwJAAkACQAJAIA0tACEiCEEKRwRAIAgOAgIDAQsgBEHYAGogAyACIAEoAqwCEMUDDB0LIARBATYCrAEgBEHEy8EANgKoASAEQgE3ArQBIAQgDUEhaq1CgICAgJAFhDcDcCAEIARB8ABqNgKwASAEQeQAaiIBIARBqAFqELEGIAEQjgchAQwjCyAEQRhqIAMgAkEDIAEoAqwCEPgEDAELIARBGGogAyACQQMgASgCrAIQ5gMLIAEoAqwCIgdBAnQiAkH/////A0sNDCAHQQR0IgNB/f///wdPDQwCQCADRQRAQQQhC0EAIQIMAQsgAxBxIgtFDQ4gASgCrAIhBwsgBEEANgKwASAEIAs2AqwBIAQgAjYCqAEgBwRAQQAhA0EBIQYgBCgCICEIIAQoAhwhAgNAIAZBAWsiDCIFIAhPBEAgDCEGDBsLIAggBWsiBUEAIAUgCE0bIgVBAUYNGiAFQQJGDRlDAACAPyACKgIAIiQgJJSTIAJBBGoqAgAiJyAnlJMgAkEIaioCACIoICiUk0MAAAAAEOAIkSElIAQoAqgBIANrQQNNBEAgBEGoAWogA0EEQQRBBBCkBSAEKAKsASELIAQoArABIQMLIAsgA0ECdGoiBSAlOAIMIAUgKDgCCCAFICc4AgQgBSAkOAIAIAQgA0EEaiIDNgKwASAGQQNqIQYgAkEMaiECIAdBAWsiBw0ACwsgBEHgAGogBEGwAWooAgA2AgAgBCAEKQKoATcDWCAEKAIYIgNFDRkgBCgCHCICQQRrKAIAIghBeHEiBSADQQJ0IgNBBEEIIAhBA3EiCBtqSQ0nIAhBACAFIANBJ2pLGw0oIAIQogIMGQsgDS0AIUELRg0VIARBATYCrAEgBEHwy8EANgKoASAEQgE3ArQBIAQgDUEhaq1CgICAgJAFhDcDGCAEIARBGGo2ArABIARBkAFqIgEgBEGoAWoQsQYgARCOByEBDB8LIA0tACFBDEYNEyAEQQE2AqwBIARBnMzBADYCqAEgBEIBNwK0ASAEIA1BIWqtQoCAgICQBYQ3AxggBCAEQRhqNgKwASAEQZwBaiIBIARBqAFqELEGIAEQjgchAQweC0EPIQUMAQtBFSEFCwJAAkACQAJAAkAgDS0AISIIDggBAAMDAgIEBAMLIARBGGogAyACIAUgASgCrAIQ5gMMEwsgBEEYaiADIAIgBSABKAKsAhD4BAwSCyANKAIARQRAIARBADYCuAEgBEEBNgKsASAEQZjKwQA2AqgBIARCBDcCsAEgBEGoAWoQkgchAQweCyANKAIIRQRAIARBADYCuAEgBEEBNgKsASAEQfzJwQA2AqgBIARCBDcCsAEgBEGoAWoQkgchAQweCyANKgIEISQgASgCrAIhByANKgIMIScgCEEERg0QIARBGGogAyACIAUgByAkICcQ/wMMEQsgBEEBNgKsASAEQdDMwQA2AqgBIARCATcCtAEgBCANQSFqrUKAgICAkAWENwNYIAQgBEHYAGo2ArABIARB+ABqIgEgBEGoAWoQsQYgARCOByEBDBwLIA0oAghFBEAgBEEANgK4ASAEQQE2AqwBIARB/MnBADYCqAEgBEIENwKwASAEQagBahCSByEBDBwLIAEoAqwCIQcgDSoCDCEkIAhBBkYNDSAEQRhqIAMgAiAFIAcgJBCQBAwPCyAEQQE2AqwBIARB+MzBADYCqAEgBEIBNwK0ASAEIA1BIWqtQoCAgICQBYQ3A1ggBCAEQdgAajYCsAEgBEGEAWoiASAEQagBahCxBiABEI4HIQEMGgsgBEEYaiADIAIgASgCrAIQjgUMAQsgBEEYaiADIAIgASgCrAIQ0wQLIAQoAhwhECABKALoA0UNByABKAKsAiEOIAEoAqgCIRQgBCgCICEPIBMQowUgFkEIakEAOgAAIBZCADcCACATIA4Q0AQgEygCAEEBRw0HIA5BAnQiCSABKAK4AyIDSw0FIAEoArQDIQogDkUNBkEAIQcgCiEFQQAhAgJAAkACQANAAkAgByAPSQRAIAIgEGooAgBBAnQiAyABKAKIAyIGTw0OIAIgCU8NBSAFIAEoAoQDIANBAnRqKAIANgIAIANBAXIiCCABKAKIAyIGSQ0BIAghAwwOCyAPIA9BiLnBABCMBwALIAJBAWogCU8NAiAFQQRqIAEoAoQDIAhBAnRqKAIANgIAIANBAnIiCCABKAKIAyIGTwRAIAghAwwNCyACQQJqIAlPDQEgBUEIaiABKAKEAyAIQQJ0aigCADYCACADQQNyIgMgASgCiAMiBk8NDCAJIAJBA2pLBEAgBUEMaiABKAKEAyADQQJ0aigCADYCACAFQRBqIQUgAkEEaiECIAdBAWoiByAOSQ0BDAsLCyACQQNqIQIMAgsgAkECaiECDAELIAJBAWohAgsgAiAJQai5wQAQjAcACyAEICs3A1ggBEECNgKsASAEQbTNwQA2AqgBIARCAjcCtAEgBEKAgICAoAUiKyAEQdgAaq2ENwMgIAQgKyAcrYQ3AxggBCAEQRhqNgKwASAEQQxqIgEgBEGoAWoQsQYgARCOByEBIABBAToAACAAIAE2AgQMHAsgAEEAOwEADBsLQQAgAiADQYDNwQAQ6gcAC0GQy8EAEP8HCwALQQAgCSADQbi5wQAQ6gcACwJAAkACQAJAAkAgASgC6ANBAUYEQCAEIAEoAsACIBRBAnQgDiAUakECdBDhCCICELgKIgM2AnAgBCAJNgJYIAMgCUcNHyACIAogCRDgCSACQYMISw0DDAYLIAEoAsQCQQFHDQUgCSABKALEAyIDSw0AIAEoAsADIQwgDkUNASAKQQxqIQtBACEHIAwhA0EAIQUDQAJAAkACQCAHIA9JBEAgBSAQaigCAEECdCICIAEoApQDIghPDQEgBUEDaiIIIAlPDQIgCyACQQJ0IgggASgCkANqKAIANgIAIAIgASgClAMiBk8NCSADIAEoApADIAhqKAIANgIAIAJBAXIiCCABKAKUAyIGSQ0DIAghAgwJCyAPIA9BuLjBABCMBwALIAIgCEHIuMEAEIwHAAsgCCAJQdi4wQAQjAcACyADQQRqIAEoApADIAhBAnRqKAIANgIAIAJBAnIiCCABKAKUAyIGTwRAIAghAgwGCyADQQhqIAEoApADIAhBAnRqKAIANgIAIAJBA3IiAiABKAKUAyIGTw0FIANBDGogASgCkAMgAkECdGooAgA2AgAgC0EQaiELIANBEGohAyAFQQRqIQUgB0EBaiIHIA5JDQALDAELQQAgCSADQfi4wQAQ6gcACyAEIAEoAsACIBRBAnQiFSAOIBRqQQJ0IhQQ4QgiAxC4CiICNgJwIAQgCTYCWAJAIAIgCUYEQCADIAogCRDgCSADQYQITwRAIAMQmwcLIAQgASgCyAIgFSAUEOEIIgMQuAoiAjYCcCAEIAk2AlggAiAJRgRAIAMgDCAJEOAJIANBhAhPBEAgAxCbBwsgASgC6ANBAkYNBiABKALMAkUNBiABKALUAkUNBiAORQ0CQQAhEkEAIAlrIRdBAyEDQQAhBQJAAn8CQANAAkACQAJAAkACQAJAAkAgDyASSwRAIANBA2siCCAQaigCAEECdCICIAEoAqADIgZPDRAgCCAJTw0CIAUgCmoiESACQQJ0IiIgASgCnANqKAIANgIAIAJBAXIiCCABKAKgAyIGSQ0BIAghAgwQCyAPIA9B6LfBABCMBwALIANBAmsgCU8NAiARQQRqIAhBAnQiIyABKAKcA2ooAgA2AgAgAkECciIHIAEoAqADIgZPBEAgByECDA8LIANBAWsgCU8NASARQQhqIAdBAnQiGCABKAKcA2ooAgA2AgAgAkEDciILIAEoAqADIgZPBEAgCyECDA8LIAMgCU8NAyARQQxqIAEoApwDIAtBAnRqKAIANgIAIAIgASgCrAMiBk8NCSADIBdqIgtBA0YNBCAFIAxqIhEgASgCqAMgImooAgA2AgAgASgCrAMiBiAIIgJLDQUMCQsgA0EDayEDDAILIANBAWshAwwBCyADQQJrIQMLIAMgCUGouMEAEIwHAAsgA0EDawwDCyALQQJGDQEgEUEEaiABKAKoAyAjaigCADYCACABKAKsAyIGIAciAk0NAyALQQFHBEAgEUEIaiABKAKoAyAYaigCADYCACAFQRBqIQUgA0EEaiEDIBJBAWoiEiAOSQ0BDAcLCyADQQFrDAELIANBAmsLIAlBiLjBABCMBwALIAIgBkH4t8EAEIwHAAsMHgsMHQsgASgC0AIgFSAUEOEIIgMgCiAJELUHIANBhAhPBEAgAxCbBwsgASgC2AIgFSAUEOEIIgIgDCAJELUHIAJBgwhNDQMLIAIQmwcMAgsgAiAGQZi4wQAQjAcACyACIAZB6LjBABCMBwALIAQoAhgiA0UNEAJAIBBBBGsoAgAiAkF4cSIIIANBAnQiA0EEQQggAkEDcSICG2pPBEAgAkEAIAggA0EnaksbDQEgEBCiAgwSCwwXCwwXCyADIAZBmLnBABCMBwALIARBGGogAyACIAUgByAkEIIFDAELIARBGGogAyACIAUgByAkICcQ+QQLAkACQAJAAkACQAJ/AkACQAJAAn8CQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAIA0tACJBBWsOCAYBAgAAAwQFAAtBpPjGAEEoQaTMwQAQ6wcACyATIAEoAqgCIAEoAqwCIAQoAhwiCCAEKAIgEKcBDBQLIBMgASgCqAIgASgCrAIgBCgCHCIIIAQoAiAQlAEMEwsgASgCrAIiDiABKAKoAiIPaiIUQQJ0IQkgBCgCICEFIAQoAhwhCAJAIAEoAtwCQQFGBEAgASgC4AIQuAogCU8NEyAJELYJIgIgASgC4AIQ3AkgASgC4AIiA0GECEkNASADEJsHDAELIAlFDRIgCRC2CSECCyABIAI2AuACIAFBATYC3AIMEQsgASgCrAIiECABKAKoAiIUaiISQQJ0IQkgBCgCICEFIAQoAhwhCAJAIAEoAuQCQQFGBEAgASgC6AIQuAogCU8NESAJELYJIgIgASgC6AIQ3AkgASgC6AIiA0GECEkNASADEJsHDAELIAlFDRAgCRC2CSECCyABIAI2AugCIAFBATYC5AIMDwsgASgCrAIiDyABKAKoAiIJaiIVQQJ0IQwgBCgCICEFIAQoAhwhCCABKALsAiIHQQFHBH9BAAUgASgC8AIQuAoLIAxJBEAgDBC2CSEDIAwQtgkhAgJAIAdFBEAgA60gAq1CIIaEISsMAQsgAyABKALwAhDcCSACIAEoAvQCENwJIAEoAvACIgdBhAhPBEAgBxCbBwsgA60gAq1CIIaEISsgASgC9AIiA0GECEkNACADEJsHCyABICs3A/ACIAFBATYC7AILIBMQowUgFkEIakEAOgAAIBZCADcCACATIA8Q0AQgASgC7AJFDRAgD0ECdCIKIAEoArgDIgNNBEAgASgCxAMiAyAKTwRAIAEoArQDIRAgASgCwAMhFCAPRQ0PQQAhB0EAIAprIRFBAyEGQQohAkEBIQ4gCCEDAn8CQANAAkACfwJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkAgBSACQQprSwRAIAJBCWsgBU8NASACQQhrIAVPDQIgBkEDayIYIApJDQMgGCEGDAQLIAJBCmsMDgsgAkEJayECDAkLIAJBCGsMBQtDAAB/QyADQQRqKgIAIieLIiRDAACAP0MAAPhBQwAAAAAgAyoCACIoiyIlICQgA0EIaioCACIpiyIqEOAIEOAIEJ4FjkMAAHBBkiIkICRDAAAAAF0bIiQgJEMAAPhBXhsQuQf8ACISQQ9rELAGQwAAf0OVIiSVIiYgJkMAAH9DXhsQuQchJiAHIBBqIgtDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASASQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBB2sgBU8NCCACQQZrIAVPDQUgAkEFayAFTw0BIAogBkECa0sEQEMAAH9DIANBEGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQQxqKgIAIiiLIiUgJCADQRRqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhJBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIAtBBGpDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASASQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBBGsgBU8NCiACQQNrIAVPDQcgAkECayAFTw0DIAogBkEBa0sEQEMAAH9DIANBHGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQRhqKgIAIiiLIiUgJCADQSBqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhJBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIAtBCGpDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASASQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBAWsgBU8NDCACIAVPDQkgAkEBaiAFTw0FIAYgCk8NAkMAAH9DIANBKGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQSRqKgIAIiiLIiUgJCADQSxqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhJBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIAtBDGpDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASASQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBAmogBU8NHSACQQNqIAVPDRkgAkEEaiAFTw0VIAYgEWoiC0EDRw0OIAZBA2sMEQsgBkEBayEGDAELIAZBAmshBgsgBiAKQbi3wQAQjAcACyACQQVrDAILIAJBAmsMAQsgAkEBagsgBUGot8EAEIwHAAsgAkEGayECDAELIAJBA2shAgsgAiAFQZi3wQAQjAcACyACQQdrDAILIAJBBGsMAQsgAkEBawsgBUGIt8EAEIwHAAtDAAB/QyADQTRqKgIAIieLIiRDAACAP0MAAPhBQwAAAAAgA0EwaioCACIoiyIlICQgA0E4aioCACIpiyIqEOAIEOAIEJ4FjkMAAHBBkiIkICRDAAAAAF0bIiQgJEMAAPhBXhsQuQf8ACIXQQ9rELAGQwAAf0OVIiSVIiYgJkMAAH9DXhsQuQchJiAHIBRqIhJDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASAXQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBBWogBU8NDyACQQZqIAVPDQsgAkEHaiAFTw0HIAtBAkYNAUMAAH9DIANBQGsqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQTxqKgIAIiiLIiUgJCADQcQAaioCACIpiyIqEOAIEOAIEJ4FjkMAAHBBkiIkICRDAAAAAF0bIiQgJEMAAPhBXhsQuQf8ACIXQQ9rELAGQwAAf0OVIiSVIiYgJkMAAH9DXhsQuQchJiASQQRqQwAAf0MgJSAklSIlICVDAAB/Q14bELkH/AEgF0EbdEGAgIAIQQAgKEMAAAAAXRtyQYCAgBBBACAnQwAAAABdG3JBgICAIEEAIClDAAAAAF0bcnIgJvwBQQh0ckMAAH9DICogJJUiJCAkQwAAf0NeGxC5B/wBQRB0cjYCACACQQhqIAVPDRAgAkEJaiAFTw0MIAJBCmogBU8NCCALQQFHBEBDAAB/QyADQcwAaioCACIniyIkQwAAgD9DAAD4QUMAAAAAIANByABqKgIAIiiLIiUgJCADQdAAaioCACIpiyIqEOAIEOAIEJ4FjkMAAHBBkiIkICRDAAAAAF0bIiQgJEMAAPhBXhsQuQf8ACILQQ9rELAGQwAAf0OVIiSVIiYgJkMAAH9DXhsQuQchJiASQQhqQwAAf0MgJSAklSIlICVDAAB/Q14bELkH/AEgC0EbdEGAgIAIQQAgKEMAAAAAXRtyQYCAgBBBACAnQwAAAABdG3JBgICAIEEAIClDAAAAAF0bcnIgJvwBQQh0ckMAAH9DICogJJUiJCAkQwAAf0NeGxC5B/wBQRB0cjYCACAHQRBqIQcgAkEVaiECIANB1ABqIQMgBkEEaiEGIA4gD0kgDkEBaiEODQEMEwsLIAZBAWsMAQsgBkECawsgCkH4tsEAEIwHAAtBACAKIANByLfBABDqBwALQQAgCiADQdi3wQAQ6gcACyATIAEoAqgCIAEoAqwCIAQoAhwiCCAEKAIgEOYBDA8LIAJBBGoMAgsgAkEHagwBCyACQQpqCyAFQei2wQAQjAcACyACQQNqDAILIAJBBmoMAQsgAkEJagsgBUHYtsEAEIwHAAsgAkECagwCCyACQQVqDAELIAJBCGoLIAVByLbBABCMBwALIAQgASgC8AIgCUECdCIOIAwQ4QgiAxC4CiICNgJwIAQgCjYCWAJ/AkACQAJAIAIgCkYEQCADIBAgChDgCSADQYQITwRAIAMQmwcLIAQgASgC9AIgDiAMEOEIIgMQuAoiAjYCcCAEIAo2AlggAiAKRgRAIAMgFCAKEOAJIANBhAhPBEAgAxCbBwsgASgCoAMiAiAMSQRAIAwgAiIDayIHIAEoApgDIAJrSwRAICAgAiAHQQRBBBCkBSABKAKgAyEDCyABKAKcAyILIANBAnQiBmohBSAHQQJPBEAgDCACQX9zakECdCISBEAgBUEAIBL8CwALIBVBBHQgAkECdGsgC2ogBmpBBGshBSADIAdqQQFrIQMLIAVBADYCACABIANBAWo2AqADIAEgASgCrAMiAiAMSQR/IAwgAiIDayIHIAEoAqQDIAJrSwRAICEgAiAHQQRBBBCkBSABKAKsAyEDCyABKAKoAyILIANBAnQiBmohBSAHQQJPBEAgDCACQX9zakECdCIMBEAgBUEAIAz8CwALIBVBBHQgAkECdGsgC2ogBmpBBGshBSADIAdqQQFrIQMLIAVBADYCACADQQFqBSAMCzYCrAMLIA9FDQggCUEEdCEFQQAhAkEAIAprIRVBAyEDQQEhCwJ/AkADQAJAAkACQAJAAn8CQCAKIANBA2siB0sEQCAHIA5qIhIgASgCoAMiBkkNASAJQQJ0IANqQQNrDAILIANBA2shAwwECyABKAKcAyAFaiACaiACIBBqIgcoAgA2AgAgA0ECayAKTw0BIAMgDmoiDEECayIRIAEoAqADIgZJBEAgASgCnAMgBWogAmpBBGogB0EEaigCADYCACADQQFrIApPDQMgDEEBayIXIAEoAqADIgZJBEAgASgCnAMgBWogAmpBCGogB0EIaigCADYCACADIApPDQUgASgCoAMiBiAMSwRAIAEoApwDIAVqIAJqQQxqIAdBDGooAgA2AgAgAyAVaiIMQQNGDQ8gEiABKAKsAyIHSQ0HIAlBAnQgA2pBA2sMCgsgCUECdCADagwCCyAJQQJ0IANqQQFrDAELIAlBAnQgA2pBAmsLIAZBuLbBABCMBwALIANBAmshAwwBCyADQQFrIQMLIAMgCkGotsEAEIwHAAsgASgCqAMgBWogAmogAiAUaiIGKAIANgIAIAxBAkYNBSARIAEoAqwDIgdPDQEgASgCqAMgBWogAmpBBGogBkEEaigCADYCACAMQQFGDQYgASgCrAMiByAXSwRAIAEoAqgDIAVqIAJqQQhqIAZBCGooAgA2AgAgAkEQaiECIANBBGohAyALIA9JIAtBAWohCw0BDAwLCyAJQQJ0IANqQQFrDAELIAlBAnQgA2pBAmsLIAdBmLbBABCMBwALDB0LDBwLIANBAmsMAgsgA0EBawwBCyADQQNrCyAKQYi2wQAQjAcACyATEKMFIBZBCGpBADoAACAWQgA3AgAgEyAQENAEIAEoAtwCQQFHDQEgASgC5AJFDQECQAJ/AkACQAJAAn8CQAJAAkACfwJAAkACQAJAIBBBAnQiBiABKAK4AyIDTQRAIAYgASgCxAMiA0sNASABKAK0AyEVIAEoAsADIQwgBCABKALgAiAUQQJ0Ig8gCRDhCCIDELgKIgI2AnAgBCAGNgJYIAIgBkcNJiAVIAYgAxDhCSADQYQITwRAIAMQmwcLIBBFDQ4gFUEMaiELQQAhAkEDIQdBASEOIAwhCiAIIQMDQAJAAkACQAJAAkACQCACIAVJBEAgAkEBaiIRIAVPDQEgAkECaiIRIAVPDQIgBiAHTQ0DQwAAf0MgA0EEaioCACIniyIkQwAAgD9DAAD4QUMAAAAAIAMqAgAiKIsiJSAkIANBCGoqAgAiKYsiKhDgCBDgCBCeBY5DAABwQZIiJCAkQwAAAABdGyIkICRDAAD4QV4bELkH/AAiEUEPaxCwBkMAAH9DlSIklSImICZDAAB/Q14bELkHISYgC0MAAH9DICUgJJUiJSAlQwAAf0NeGxC5B/wBIBFBG3RBgICACEEAIChDAAAAAF0bckGAgIAQQQAgJ0MAAAAAXRtyQYCAgCBBACApQwAAAABdG3JyICb8AUEIdHJDAAB/QyAqICSVIiQgJEMAAH9DXhsQuQf8AUEQdHI2AgAgAkEDaiAFTw0EIAJBBGogBU8NBSACQQVqIhggBUkNBiAYDA0LIAIgBUH4tMEAEIwHAAsgESAFQYi1wQAQjAcACyARIAVBmLXBABCMBwALIAcgBkGotcEAEIwHAAsgAkEDagwQCyACQQRqDAsLQwAAf0MgA0EQaioCACIniyIkQwAAgD9DAAD4QUMAAAAAIANBDGoqAgAiKIsiJSAkIANBFGoqAgAiKYsiKhDgCBDgCBCeBY5DAABwQZIiJCAkQwAAAABdGyIkICRDAAD4QV4bELkH/AAiEUEPaxCwBkMAAH9DlSIklSImICZDAAB/Q14bELkHISYgCkMAAH9DICUgJJUiJSAlQwAAf0NeGxC5B/wBIBFBG3RBgICACEEAIChDAAAAAF0bckGAgIAQQQAgJ0MAAAAAXRtyQYCAgCBBACApQwAAAABdG3JyICb8AUEIdHJDAAB/QyAqICSVIiQgJEMAAH9DXhsQuQf8AUEQdHI2AgAgAkEGaiAFTw0LIAJBB2ogBU8NByACQQhqIAVPDQNDAAB/QyADQRxqKgIAIieLIiRDAACAP0MAAPhBQwAAAAAgA0EYaioCACIoiyIlICQgA0EgaioCACIpiyIqEOAIEOAIEJ4FjkMAAHBBkiIkICRDAAAAAF0bIiQgJEMAAPhBXhsQuQf8ACIRQQ9rELAGQwAAf0OVIiSVIiYgJkMAAH9DXhsQuQchJiAKQQRqQwAAf0MgJSAklSIlICVDAAB/Q14bELkH/AEgEUEbdEGAgIAIQQAgKEMAAAAAXRtyQYCAgBBBACAnQwAAAABdG3JBgICAIEEAIClDAAAAAF0bcnIgJvwBQQh0ckMAAH9DICogJJUiJCAkQwAAf0NeGxC5B/wBQRB0cjYCACACQQlqIAVPDQwgAkEKaiAFTw0IIAJBC2ogBU8NBEMAAH9DIANBKGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQSRqKgIAIiiLIiUgJCADQSxqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhFBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIApBCGpDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASARQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBDGogBU8NDSACQQ1qIAVPDQkgAkEOaiAFTw0FQwAAf0MgA0E0aioCACIniyIkQwAAgD9DAAD4QUMAAAAAIANBMGoqAgAiKIsiJSAkIANBOGoqAgAiKYsiKhDgCBDgCBCeBY5DAABwQZIiJCAkQwAAAABdGyIkICRDAAD4QV4bELkH/AAiEUEPaxCwBkMAAH9DlSIklSImICZDAAB/Q14bELkHISYgCkEMakMAAH9DICUgJJUiJSAlQwAAf0NeGxC5B/wBIBFBG3RBgICACEEAIChDAAAAAF0bckGAgIAQQQAgJ0MAAAAAXRtyQYCAgCBBACApQwAAAABdG3JyICb8AUEIdHJDAAB/QyAqICSVIiQgJEMAAH9DXhsQuQf8AUEQdHI2AgAgC0EQaiELIAdBBGohByAKQRBqIQogA0E8aiEDIAJBD2ohAiAOIBBJIA5BAWohDg0ACwwOC0EAIAYgA0H4tcEAEOoHAAtBACAGIANB6LXBABDqBwALIAJBCGoMAgsgAkELagwBCyACQQ5qCyAFQdi1wQAQjAcACyACQQdqDAILIAJBCmoMAQsgAkENagsgBUHItcEAEIwHAAsgAkEGagwCCyACQQlqDAELIAJBDGoLIAVBuLXBABCMBwALIAQgASgC4AIgDyAJEOEIIgMQuAoiAjYCcCAEIAY2AlgCQAJAIAIgBkYEQCADIBUgBhDgCSADQYQITwRAIAMQmwcLIAQgASgC6AIgDyAJEOEIIgMQuAoiAjYCcCAEIAY2AlggAiAGRw0aIAMgDCAGEOAJIANBhAhPBEAgAxCbBwsgASgClAMiAiAJSQRAIAkgAiIDayIHIAEoAowDIAJrSwRAIB8gAiAHQQRBBBCkBSABKAKUAyEDCyABKAKQAyIKIANBAnQiC2ohBSAHQQJPBEAgCSACQX9zakECdCIJBEAgBUEAIAn8CwALIBJBBHQgAkECdGsgCmogC2pBBGshBSADIAdqQQFrIQMLIAVBADYCACABIANBAWo2ApQDCyAQRQ0EIBVBDGohCSAUQQR0QQxyIQ5BACEDQQEhB0EAIQICQAJAAkADQCADQQNqIgUgBk8NBSADIA9qQQNqIgUgASgCiAMiCk8NBiABKAKEAyAOaiACaiACIAlqKAIANgIAIAMgFGoiCiABKAKUAyIFTw0DIAEoApADIA9qIAJqIAIgDGoiCygCADYCACABKAKUAyIFIApBAWpLBEAgASgCkAMgD2ogAmpBBGogC0EEaigCADYCACABKAKUAyIFIApBAmpNDQIgASgCkAMgD2ogAmpBCGogC0EIaigCADYCACABKAKUAyIFIApBA2pNDQMgASgCkAMgD2ogAmpBDGogC0EMaigCADYCACADQQRqIQMgAkEQaiECIAcgEEkgB0EBaiEHDQEMCQsLIApBAWohCgwCCyAKQQJqIQoMAQsgCkEDaiEKCyAKIAVB6LTBABCMBwALDBkLIAUgBkHItMEAEIwHAAsgBSAKQdi0wQAQjAcACyATEKMFIBZBCGpBADoAACAWQgA3AgAgDkECdCIMIQIgASgCuAMiAyAMSQRAIAwgAyICayIHIAEoArADIAJrSwRAIB0gAiAHQQRBBBCkBSABKAK4AyECCyABKAK0AyIKIAJBAnQiC2ohBiAHQQJPBEAgDCADQX9zakECdCIQBEAgBkEAIBD8CwALIA5BBHQgA0ECdGsgCmogC2pBBGshBiACIAdqQQFrIQILIAZBADYCACACQQFqIQILIAEgAjYCuAMgASgC3AJFDQACQAJ/AkACQAJAAkACfwJAAkAgAiAMTwRAIAEoArQDIQogDkUNCUEEIQJBASELQQEhBiAKIQcgCCEDAkADQAJAAkACQCAFIAJBBGtLBEAgAkEDayAFTw0BIAJBAmsgBU8NAiAGQQFrIhggDEkNAyAYIQYMBQsgAkEEawwNCyACQQNrIQIMCQsgAkECawwGC0MAAH9DIANBBGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADKgIAIiiLIiUgJCADQQhqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhBBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIAdDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASAQQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBAWsgBU8NCCACIAVPDQcgAkEBaiAFTw0DIAYgDE8NAUMAAH9DIANBEGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQQxqKgIAIiiLIiUgJCADQRRqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhBBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIAdBBGpDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASAQQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAJBAmogBU8NCSACQQNqIAVPDQYgAkEEaiAFTw0EIAwgBkEBaksEQEMAAH9DIANBHGoqAgAiJ4siJEMAAIA/QwAA+EFDAAAAACADQRhqKgIAIiiLIiUgJCADQSBqKgIAIimLIioQ4AgQ4AgQngWOQwAAcEGSIiQgJEMAAAAAXRsiJCAkQwAA+EFeGxC5B/wAIhBBD2sQsAZDAAB/Q5UiJJUiJiAmQwAAf0NeGxC5ByEmIAdBCGpDAAB/QyAlICSVIiUgJUMAAH9DXhsQuQf8ASAQQRt0QYCAgAhBACAoQwAAAABdG3JBgICAEEEAICdDAAAAAF0bckGAgIAgQQAgKUMAAAAAXRtyciAm/AFBCHRyQwAAf0MgKiAklSIkICRDAAB/Q14bELkH/AFBEHRyNgIAIAZBBGohBiAHQRBqIQcgAkEJaiECIANBJGohAyALIA5JIAtBAWohCw0BDAwLCyAGQQFqIQYLIAYgDEGotMEAEIwHAAtBACAMIAJBuLTBABDqBwALIAJBAWoMAQsgAkEEagsgBUGYtMEAEIwHAAsgAkEDaiECCyACIAVBiLTBABCMBwALIAJBAWsMAQsgAkECagsgBUH4s8EAEIwHAAsgBCABKALgAiAPQQJ0IhAgCRDhCCIDELgKIgI2AnAgBCAMNgJYIAIgDEcNFiADIAogDBDgCSADQYQITwRAIAMQmwcLIAEoAogDIgIgCUkEQCAJIAIiA2siByABKAKAAyACa0sEQCAeIAIgB0EEQQQQpAUgASgCiAMhAwsgASgChAMiCyADQQJ0IgZqIQUgB0ECTwRAIAkgAkF/c2pBAnQiCQRAIAVBACAJ/AsACyAUQQR0IAJBAnRrIAtqIAZqQQRrIQUgAyAHakEBayEDCyAFQQA2AgAgASADQQFqNgKIAwsgDkUNACAPQQR0IQVBACEDQQEhC0EBIQICfwJAAkACQAJAAkACQAJAA0AgDCACQQFrIgdLBEAgASgCiAMiBiAHIBBqTQ0FIAEoAoQDIAVqIANqIAMgCmoiBygCADYCACACIAxPDQQgAiAQaiIJIAEoAogDIgZPDQggASgChAMgBWogA2pBBGogB0EEaigCADYCACACQQFqIAxPDQMgASgCiAMiBiAJQQFqTQ0HIAEoAoQDIAVqIANqQQhqIAdBCGooAgA2AgAgAkECaiAMTw0CIAEoAogDIgYgCUECak0NBiABKAKEAyAFaiADakEMaiAHQQxqKAIANgIAIAJBBGohAiADQRBqIQMgCyAOSSALQQFqIQsNAQwKCwsgAkEBayECDAILIAJBAmohAgwBCyACQQFqIQILIAIgDEHYs8EAEIwHAAsgD0ECdCACakEBawwDCyAPQQJ0IAJqQQJqDAILIA9BAnQgAmpBAWoMAQsgD0ECdCACagsgBkHos8EAEIwHAAsgBCgCGCIDRQ0NIAhBBGsoAgAiAkF4cSIFIANBAnQiA0EEQQggAkEDcSICG2pJDRMgAkEAIAUgA0EnaksbDQAgCBCiAgwNCwwTCyAEQagBaiADIAIgASgCrAIQ1AQgEyABKAKoAiABKAKsAiAEKAKsASIDIAQoArABELcEIAQoAqgBIgJFDQsCQCADQQRrKAIAIghBeHEiBSACQQJ0IgJBBEEIIAhBA3EiCBtqTwRAIAhBACAFIAJBJ2pLGw0BIAMQogIMDQsMEgsMEgsgBEGoAWogAyACIAEoAqwCEJwFIBMgASgCqAIgASgCrAIgBCgCrAEiAyAEKAKwARC2BCAEKAKoASICRQ0KAkAgA0EEaygCACIIQXhxIgUgAkEBdCICQQRBCCAIQQNxIggbak8EQCAIQQAgBSACQSdqSxsNASADEKICDAwLDBELDBELIAZBAWohBgsgBiAIQcTNwQAQjAcACyATIAEoAqgCIAEoAqwCIAQoAlwiAyAEKAJgEKAFIAQoAlgiAkUNBwJAIANBBGsoAgAiCEF4cSIFIAJBAnQiAkEEQQggCEEDcSIIG2pPBEAgCEEAIAUgAkEnaksbDQEgAxCiAgwJCwwOCwwOCyAEQRhqIAMgAiABKAKsAiANKgIEIA0qAgwQqgMLIBMgASgCqAIgASgCrAIgBCgCHCIDIAQoAiAQngIgBCgCGCICRQ0FAkAgA0EEaygCACIIQXhxIgUgAkECdCICQQRBCCAIQQNxIggbak8EQCAIQQAgBSACQSdqSxsNASADEKICDAcLDAwLDAwLIARBGGogAyACQQMgCCAkICcQ+QQLIBMgASgCqAIgASgCrAIgBCgCHCIDIAQoAiAQpAIgBCgCGCICRQ0DAkAgA0EEaygCACIIQXhxIgUgAkECdCICQQRBCCAIQQNxIggbak8EQCAIQQAgBSACQSdqSxsNASADEKICDAULDAoLDAoLIARBGGogAyACQQEgASgCrAIgDSoCBCANKgIMEPkECyAEKAIgIQggBCgCHCEJIBMgASgCqAIgASgCrAIiCxDpBCALBEBBACECQQwhCiAIIQUDQAJAAkACQCABKAK4AyIDIAJBA2pLBEAgBUUNAiACIAlqKAIAIgdB////A3EhDCAHQYCAgIB4cSEGIAdBgICA/AdxIgNBgICA/AdGBEAgBkEQdiAMQQ12ckGABEEAIAwbckGA+AFyIQYMBAsgBkEQdiEGIANBgICAuARLDQEgA0GAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgA0ENdiAMQQ12akGAgAFqIAZyaiEGDAQLIANBgICAmANJDQMgDEGAgIAEciIHQf4AIANBF3YiDGt2IQMgB0EdIAxrIgx2QQFxBH8gA0EDIAx0QQFrIAdxQQBHagUgAwsgBnIhBgwDCyACIAJBBGogA0HIs8EAEOoHAAsgBkGA+AFyIQYMAQsgCCAIQbizwQAQjAcACyABKAK0AyAKaiAGQf//A3E2AgAgCkEQaiEKIAVBAWshBSACQQRqIQIgC0EBayILDQALCyABQQE6APwDIAQoAhgiA0UNAQJAIAlBBGsoAgAiAkF4cSIIIANBAnQiA0EEQQggAkEDcSICG2pPBEAgAkEAIAggA0EnaksbDQEgCRCiAgwDCwwICwwICyAAQQE6AAAgACABNgIEIBtFIBpFcg0FIBkgGkEBEKIHDAULAkACQAJAIAEoArgCIgIgDSgCGEEHakF4cSIDTwRAIAFBADYCuAIgAiADayEIIANFDQEgAiADRg0DIAhFDQIgASgCtAIiAiACIANqIAj8CgAADAILQQAgAyACQYSkxwAQ6gcACyACIANGDQELIAEgCDYCuAILIA0pAxghKyABIAEoAqQCQQFqIgI2AqQCIAEgASkDcCArQgd8Qvj///8Pg3w3A3ACQCAbRSAaRXINAAJAIBlBBGsoAgAiA0F4cSICQQRBCCADQQNxIgMbIBpqTwRAIANBACACIBpBJ2pLGw0BIBkQogIgASgCpAIhAgwCCwwHCwwHCyACIAEoAmRJDQALCyAAQYACOwEADAILQYzJwQAQ3QkACyAAQQE6AAAgACAZNgIECyAEQcABaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIARBADYCqAFBACAEQfAAaiAEQdgAaiAEQagBakHg+cQAEPUHAAvlXgIZfwd9IwBBIGsiHSQAAkACQAJAIAFBIUkEQCAAIQcgASEIDAELIAJBBGshHiACQRBrIR8DQCAERQRAIAAgASACIANBASAGEGEMAwsgACABQQN2IgdBHGxqIRMgACAHQQR0aiENAkAgAUHAAE8EQCAAIA0gEyAHIAYQoQEhFiAGKAIAIRwMAQtDAACAPyEhAn8CQCAAKAIAIgcgBigCACIcQQRqKAIAIhEoAggiGkkEQCANKAIAIRYgESgCBCIJIAdBGGxqIgstABMiDyALLQASIgggCy0AESIHIAcgCEkbIgcgByAPSRsiCgR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISUgC0EMai8BACIQQf//AXEiC0UEQCAQQRB0DAMLIBBB/wdxIQ8gEEGAgAJxIQggEEGA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgD0UNAxogByAPQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgD0ENdHJBgICAwANqIAhyDAILIAcgGkHcu8cAEIwHAAsgDyAPZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIBYgGkkEQCAJIBZBGGxqIhYtABMiDyAWLQASIgggFi0AESIHIAcgCEkbIgcgByAPSRsiDAR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIAxBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgFkEMai8BACIOQf//AXEiFkUEQCAOQRB0DAMLIA5B/wdxIQ8gDkGAgAJxIQggDkGA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgD0UNAxogByAPQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgD0ENdHJBgICAwANqIAhyDAILIBYgGkHcu8cAEIwHAAsgDyAPZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEiCyATKAIAIQ8gCgR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISRDAACAPyEmAn8gEEEQdCALRQ0AGiAQQf8HcSELIBBBgIACcSEIIBBBgPgBcSIHQYD4AUYEQCAIQRB0IgdBgICA/AdyIAtFDQEaIAcgC0ENdHJBgICA/gdyDAELIAhBEHQiCCAHQQ10QYCAgPwAcSALQQ10ckGAgIDAA2pyIAcNABogCyALZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEmCwJ/AkAgDyAaSQRAICUgIZQiJSAjICKUYCAJIA9BGGxqIgktABMiDyAJLQASIgggCS0AESIHIAcgCEkbIgcgByAPSRsiCgR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISNFIQ8gJSAlWyEIIAlBDGovAQAiEEH//wFxIgtFBEAgEEEQdAwDCyAQQf8HcSEaIBBBgIACcSEJIBBBgPgBcSIHQYD4AUYEQCAJQRB0IgdBgICA/AdyIBpFDQMaIAcgGkENdHJBgICA/gdyDAMLIAlBEHQhCSAHRQ0BIAdBDXRBgICA/ABxIBpBDXRyQYCAgMADaiAJcgwCCyAPIBpB3LvHABCMBwALIBogGmdBEGsiB0H//wNxQQhqdEH///8DcSAJQYCAgNgDciAHQRd0a3ILQwAAgD8hIr4iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAggD3EiDyAkICaUIiAgIFsgICAjICKUYEVxRwRAIAAhFgwBCyATIA0gDyAMBH1DAABAwSARKgJEIBEtAFhBAkYiBxsiIEMAABBBIBEqAkggBxsgIJNDAAB+Q5UgDEEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAsCfyAOQRB0IBZFDQAaIA5B/wdxIRYgDkGAgAJxIQggDkGA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgFkUNARogByAWQQ10ckGAgID+B3IMAQsgCEEQdCIIIAdBDXRBgICA/ABxIBZBDXRyQYCAgMADanIgBw0AGiAWIBZnQRBrIgdB//8DcUEIanRB////A3EgCEGAgIDYA3IgB0EXdGtyC74iIEMAAIA/XgR9ICAQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5QiIyAjWyAjIAoEfUMAAEDBIBEqAkQgES0AWEECRiIHGyIgQwAAEEEgESoCSCAHGyAgk0MAAH5DlSAKQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACwJ/IBBBEHQgC0UNABogEEH/B3EhCyAQQYCAAnEhCCAQQYD4AXEiB0GA+AFGBEAgCEEQdCIHQYCAgPwHciALRQ0BGiAHIAtBDXRyQYCAgP4HcgwBCyAIQRB0IgggB0ENdEGAgID8AHEgC0ENdHJBgICAwANqciAHDQAaIAsgC2dBEGsiB0H//wNxQQhqdEH///8DcSAIQYCAgNgDciAHQRd0a3ILviIgQwAAgD9eBH0gIBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlGBFcXMbIRYLIARBAWshBCAdIBYoAgAiDTYCBCAWIABrQQJ2IQ8CQAJAAkAgBQRAQwAAgD8hIQJ/AkAgBSgCACIHIBxBBGooAgAiEygCCCIMSQRAIBMoAgQiCSAHQRhsaiIKLQATIgsgCi0AEiIIIAotABEiByAHIAhJGyIHIAcgC0kbIggEfUMAAEDBIBMqAkQgEy0AWEECRiIHGyIgQwAAEEEgEyoCSCAHGyAgk0MAAH5DlSAIQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEkIApBDGovAQAiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCyAHQYCAAnEhCCAHQYD4AXEiB0GA+AFGBEAgCEEQdCIHQYCAgPwHciALRQ0DGiAHIAtBDXRyQYCAgP4HcgwDCyAIQRB0IQggB0UNASAHQQ10QYCAgPwAcSALQQ10ckGAgIDAA2ogCHIMAgsgByAMQdy7xwAQjAcACyALIAtnQRBrIgdB//8DcUEIanRB////A3EgCEGAgIDYA3IgB0EXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISELQwAAgD8hIgJ/AkAgDCANSwRAIAkgDUEYbGoiCS0AEyILIAktABIiCCAJLQARIgcgByAISRsiByAHIAtJGyIIBH1DAABAwSATKgJEIBMtAFhBAkYiBxsiIEMAABBBIBMqAkggBxsgIJNDAAB+Q5UgCEEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshIyAJQQxqLwEAIgdB//8BcUUEQCAHQRB0DAMLIAdB/wdxIQsgB0GAgAJxIQggB0GA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgC0UNAxogByALQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgC0ENdHJBgICAwANqIAhyDAILIA0gDEHcu8cAEIwHAAsgCyALZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEiCyAkICGUIiAgIFwgICAjICKUYHINAQsgASADSw0BIAIgAUECdCIaaiEVQQAhCCAAIQsgDyEHA0AgACAHQQNrIglBACAHIAlPG0ECdGoiEyALSwRAIBxBBGooAgAiEigCCCEZIBYoAgAhFANAQwAAgD8hIQJ/AkAgGSALKAIAIhBLBEAgEigCBCIbIBBBGGxqIg0tABMiDCANLQASIgogDS0AESIJIAkgCkkbIgkgCSAMSRsiCgR9QwAAQMEgEioCRCASLQBYQQJGIgkbIiBDAAAQQSASKgJIIAkbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISQgDUEMai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyAQIBlB3LvHABCMBwALIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQtDAACAPyEiAn8CQCAUIBlJBEAgGyAUQRhsaiIXLQATIgwgFy0AEiIKIBctABEiCSAJIApJGyIJIAkgDEkbIgoEfUMAAEDBIBIqAkQgEi0AWEECRiIJGyIgQwAAEEEgEioCSCAJGyAgk0MAAH5DlSAKQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEjIBdBDGoiES8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyAUIBlB3LvHABCMBwALIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIgsgCEECdCACIBVBBGsgJCAhlCIgICBbICAgIyAilGBFcSING2ogEDYCAEMAAIA/ISECfwJAIBkgC0EEaigCACIOSwRAIBsgDkEYbGoiEC0AEyIMIBAtABIiCiAQLQARIgkgCSAKSRsiCSAJIAxJGyIKBH1DAABAwSASKgJEIBItAFhBAkYiCRsiIEMAABBBIBIqAkggCRsgIJNDAAB+Q5UgCkEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAQQQxqLwEAIglB//8BcUUEQCAJQRB0DAMLIAlB/wdxIQwgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgDEUNAxogCSAMQQ10ckGAgID+B3IMAwsgCkEQdCEKIAlFDQEgCUENdEGAgID8AHEgDEENdHJBgICAwANqIApyDAILDAsLIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsgFy0AEyIMIBctABIiCiAXLQARIgkgCSAKSRsiCSAJIAxJGyIKBH1DAABAwSASKgJEIBItAFhBAkYiCRsiIEMAABBBIBIqAkggCRsgIJNDAAB+Q5UgCkEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshI0MAAIA/ISICfyARLwEAIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQwgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgDEUNARogCSAMQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADanIgCQ0AGiAMIAxnQRBrIglB//8DcUEIanRB////A3EgCkGAgIDYA3IgCUEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAggDWoiDUECdCACIBVBCGsgJCAhlCIgICBbICAgIyAilGBFcSIMG2ogDjYCAEMAAIA/ISECfwJAIBkgC0EIaigCACIOSwRAIBsgDkEYbGoiEC0AEyIKIBAtABIiCSAQLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAQQQxqLwEAIghB//8BcUUEQCAIQRB0DAMLIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNAxogCCAKQQ10ckGAgID+B3IMAwsgCUEQdCEJIAhFDQEgCEENdEGAgID8AHEgCkENdHJBgICAwANqIAlyDAILDAsLIAogCmdBEGsiCEH//wNxQQhqdEH///8DcSAJQYCAgNgDciAIQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsgFy0AEyIKIBctABIiCSAXLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshI0MAAIA/ISICfyARLwEAIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNARogCCAKQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIApBDXRyQYCAgMADanIgCA0AGiAKIApnQRBrIghB//8DcUEIanRB////A3EgCUGAgIDYA3IgCEEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAwgDWoiDUECdCACIBVBDGsgJCAhlCIgICBbICAgIyAilGBFcSIMG2ogDjYCAEMAAIA/ISECfwJAIBkgC0EMaigCACIOSwRAIBsgDkEYbGoiEC0AEyIKIBAtABIiCSAQLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAQQQxqLwEAIghB//8BcUUEQCAIQRB0DAMLIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNAxogCCAKQQ10ckGAgID+B3IMAwsgCUEQdCEJIAhFDQEgCEENdEGAgID8AHEgCkENdHJBgICAwANqIAlyDAILDAsLIAogCmdBEGsiCEH//wNxQQhqdEH///8DcSAJQYCAgNgDciAIQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsgFy0AEyIKIBctABIiCSAXLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshI0MAAIA/ISICfyARLwEAIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNARogCCAKQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIApBDXRyQYCAgMADanIgCA0AGiAKIApnQRBrIghB//8DcUEIanRB////A3EgCUGAgIDYA3IgCEEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAwgDWoiCUECdCACIBVBEGsiFSAkICGUIiAgIFsgICAjICKUYEVxIggbaiAONgIAIAggCWohCCALQRBqIgsgE0kNAAsLIAAgB0ECdGoiEyALSwRAIBxBBGooAgAiGygCCCEUIBYoAgAhEQNAQwAAgD8hIQJ/AkAgFCALKAIAIg5LBEAgGygCBCINIA5BGGxqIhAtABMiDCAQLQASIgogEC0AESIJIAkgCkkbIgkgCSAMSRsiCgR9QwAAQMEgGyoCRCAbLQBYQQJGIgkbIiBDAAAQQSAbKgJIIAkbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgEEEMai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyAOIBRB3LvHABCMBwALIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsCfwJAIBEgFEkEQCANIBFBGGxqIg0tABMiDCANLQASIgogDS0AESIJIAkgCkkbIgkgCSAMSRsiCgR9QwAAQMEgGyoCRCAbLQBYQQJGIgkbIiBDAAAQQSAbKgJIIAkbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISAgDUEMai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyARIBRB3LvHABCMBwwGCyAMIAxnQRBrIglB//8DcUEIanRB////A3EgCkGAgIDYA3IgCUEXdGtyCyEJIAhBAnQgAiAVQQRrIhUgIyAhlCIjICNbICMgICAJviIgQwAAgD9eBH0gIBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlGBFcSIJG2ogDjYCACAIIAlqIQggC0EEaiILIBNJDQALCyABIAdHBEAgFUEEayIVIAhBAnRqIAsoAgA2AgAgC0EEaiELIAEhBwwBCwsgCEECdCIMBEAgACACIAz8CgAACyABIAhrIQoCQCABIAhGDQBBACEHIApBBE8EQCAAIAxqIQ0gGiAfaiEJIApBfHEiByELA0AgDSAJ/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgCUEQayEJIA1BEGohDSALQQRrIgsNAAsgByAKRg0BCyAeIBogB0ECdCILa2ohDSAAIAtqIAxqIQkgByABayAIaiELA0AgCSANKAIANgIAIA1BBGshDSAJQQRqIQkgC0EBaiILDQALCyAIRQ0AIAEgCE8NAiAdQQA2AhggHUEBNgIMIB1BiILIADYCCCAdQgQ3AhAgHUEIakH0lMEAEI0IAAsgASADSw0AIAIgAUECdCIQaiEVIAYoAgAhGkEAIRQgACELA0AgACAPQQNrIgVBACAFIA9NG0ECdGoiDSALSwRAIBpBBGooAgAiFygCCCEbIBYoAgAhHCAGKAIAQQRqIQwDQEMAAIA/ISECfwJAIBsgHEsEQCALKAIAIQ4gFygCBCIJIBxBGGwiCmoiEy0AEyIIIBMtABIiByATLQARIgUgBSAHSRsiBSAFIAhJGyIHBH1DAABAwSAXKgJEIBctAFhBAkYiBRsiIEMAABBBIBcqAkggBRsgIJNDAAB+Q5UgB0EBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCATQQxqLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQggBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgCEUNAxogBSAIQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgCEENdHJBgICAwANqIAdyDAILIBwgG0Hcu8cAEIwHAAsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIA4gG0kEQCAJIA5BGGxqIgktABMiCCAJLQASIgcgCS0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgFyoCRCAXLQBYQQJGIgUbIiBDAAAQQSAXKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgCUEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEIIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIAhFDQMaIAUgCEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCyAOIBtB3LvHABCMBwALIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIgsgFEECdCACIBVBBGsgJCAhlCIgICBcICAgIyAilGByIgkbaiAONgIAQwAAgD8hIQJ/AkAgDCgCACIYKAIIIhkgHEsEQCALQQRqKAIAIQ4gCiAYKAIEIhFqIhItABMiCCASLQASIgcgEi0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgGCoCRCAYLQBYQQJGIgUbIiBDAAAQQSAYKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISQgEkEMaiITLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQggBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgCEUNAxogBSAIQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgCEENdHJBgICAwANqIAdyDAILIBwgGUHcu8cAEIwHAAsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIA4gGUkEQCARIA5BGGxqIgotABMiCCAKLQASIgcgCi0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgGCoCRCAYLQBYQQJGIgUbIiBDAAAQQSAYKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgCkEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEIIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIAhFDQMaIAUgCEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCwwKCyAIIAhnQRBrIgVB//8DcUEIanRB////A3EgB0GAgIDYA3IgBUEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAkgFGoiCkECdCACIBVBCGsgJCAhlCIgICBcICAgIyAilGByIgkbaiAONgIAIAtBCGooAgAhFCASLQATIgggEi0AEiIHIBItABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEkQwAAgD8hIQJ/IBMvAQAiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0BGiAFIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgBUENdEGAgID8AHEgCEENdHJBgICAwANqciAFDQAaIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQtDAACAPyEiAn8CQCAUIBlJBEAgESAUQRhsaiIOLQATIgggDi0AEiIHIA4tABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEjIA5BDGovAQAiBUH//wFxRQRAIAVBEHQMAwsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0DGiAFIAhBDXRyQYCAgP4HcgwDCyAHQRB0IQcgBUUNASAFQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogB3IMAgsgFCAZQdy7xwAQjAcACyAIIAhnQRBrIgVB//8DcUEIanRB////A3EgB0GAgIDYA3IgBUEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAkgCmoiCkECdCACIBVBDGsgJCAhlCIgICBcICAgIyAilGByIgkbaiAUNgIAIAtBDGooAgAhDiASLQATIgggEi0AEiIHIBItABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEkQwAAgD8hIQJ/IBMvAQAiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0BGiAFIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgBUENdEGAgID8AHEgCEENdHJBgICAwANqciAFDQAaIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQtDAACAPyEiAn8CQCAOIBlJBEAgESAOQRhsaiITLQATIgggEy0AEiIHIBMtABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEjIBNBDGovAQAiBUH//wFxRQRAIAVBEHQMAwsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0DGiAFIAhBDXRyQYCAgP4HcgwDCyAHQRB0IQcgBUUNASAFQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogB3IMAgsMCgsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEiCyAJIApqIgdBAnQgAiAVQRBrIhUgJCAhlCIgICBcICAgIyAilGByIgUbaiAONgIAIAUgB2ohFCALQRBqIgsgDUkNAAsLIAAgD0ECdGoiCiALSwRAIBpBBGooAgAiESgCCCEOIBYoAgAhDQNAQwAAgD8hIQJ/AkAgDSAOSQRAIAsoAgAhEyARKAIEIgkgDUEYbGoiDC0AEyIIIAwtABIiByAMLQARIgUgBSAHSRsiBSAFIAhJGyIHBH1DAABAwSARKgJEIBEtAFhBAkYiBRsiIEMAABBBIBEqAkggBRsgIJNDAAB+Q5UgB0EBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAMQQxqLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQggBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgCEUNAxogBSAIQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgCEENdHJBgICAwANqIAdyDAILIA0gDkHcu8cAEIwHAAsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIA4gE0sEQCAJIBNBGGxqIgktABMiCCAJLQASIgcgCS0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgESoCRCARLQBYQQJGIgUbIiBDAAAQQSARKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgCUEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEIIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIAhFDQMaIAUgCEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCyATIA5B3LvHABCMBwALIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIgsgFEECdCACIBVBBGsiFSAkICGUIiAgIFwgICAjICKUYHIiBRtqIBM2AgAgBSAUaiEUIAtBBGoiCyAKSQ0ACwsgASAPRwRAIAIgFEECdGogCygCADYCACALQQRqIQsgFEEBaiEUIBVBBGshFSABIQ8MAQsLIBRBAnQiDwRAIAAgAiAP/AoAAAsgASAURg0EIAAgD2ohB0EAIRUCQCABIBRrIghBBE8EQCAQIB9qIQ0gByEJIAhBfHEiFSELA0AgCSAN/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgDUEQayENIAlBEGohCSALQQRrIgsNAAsgCCAVRg0BCyAeIBVBAnQiBWsgEGohDSAAIAVqIA9qIQkgFSABayAUaiELA0AgCSANKAIANgIAIA1BBGshDSAJQQRqIQkgC0EBaiILDQALCyABIBRPBEBBACEFIAchACAIIQEgCEEhSQ0EDAMLIBQgASABQYSVwQAQ6gcACwALIAAgDGogCiACIAMgBCAdQQRqIAYQNyAIIQEgCEEhTw0ACyAAIQcLIAhBAkkNACAGKAIAIQYgCEEBdiEPIA8CfyAIQQ9NBEAgCEEHSwRAIAcgAiAGQQRqIgEoAgAQbSAHIA9BAnQiAGogACACaiABKAIAEG1BBAwCCyACIAcoAgA2AgAgAiAPQQJ0IgBqIAAgB2ooAgA2AgBBAQwBCyAHIAIgCEECdGoiBSAGQQRqIgQoAgAQbSAHQRBqIAVBEGogBCgCABBtIAVBCCACIAYQtgEgByAPQQJ0IgNqIgEgBUEgaiIAIAQoAgAQbSABQRBqIAVBMGogBCgCABBtIABBCCACIANqIAYQtgFBCAsiA0sEQCAPIANrIQkgA0ECdCENA0AgAiANaiIAIAcgDWooAgA2AgAgAiAAIAYQygEgDUEEaiENIAlBAWsiCQ0ACwsgCCAPayADSwRAIAIgD0ECdCIAaiEBIAcgA0ECdCAAaiIAaiEJIAAgAmohDSADIA9qIAhrIRUDQCANIAkoAgA2AgAgASANIAYQygEgCUEEaiEJIA1BBGohDSAVQQFqIhUNAAsLIAIgCCAHIAYQtgELIB1BIGokAA8LIA4gGUHcu8cAEIwHAAvlXgIZfwd9IwBBIGsiHSQAAkACQAJAIAFBIUkEQCAAIQcgASEIDAELIAJBBGshHiACQRBrIR8DQCAERQRAIAAgASACIANBASAGEGAMAwsgACABQQN2IgdBHGxqIRMgACAHQQR0aiENAkAgAUHAAE8EQCAAIA0gEyAHIAYQoQEhFiAGKAIAIRwMAQtDAACAPyEhAn8CQCAAKAIAIgcgBigCACIcQQRqKAIAIhEoAggiGkkEQCANKAIAIRYgESgCBCIJIAdBGGxqIgstABMiDyALLQASIgggCy0AESIHIAcgCEkbIgcgByAPSRsiCgR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISUgC0EMai8BACIQQf//AXEiC0UEQCAQQRB0DAMLIBBB/wdxIQ8gEEGAgAJxIQggEEGA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgD0UNAxogByAPQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgD0ENdHJBgICAwANqIAhyDAILIAcgGkHcu8cAEIwHAAsgDyAPZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIBYgGkkEQCAJIBZBGGxqIhYtABMiDyAWLQASIgggFi0AESIHIAcgCEkbIgcgByAPSRsiDAR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIAxBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgFkEMai8BACIOQf//AXEiFkUEQCAOQRB0DAMLIA5B/wdxIQ8gDkGAgAJxIQggDkGA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgD0UNAxogByAPQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgD0ENdHJBgICAwANqIAhyDAILIBYgGkHcu8cAEIwHAAsgDyAPZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEiCyATKAIAIQ8gCgR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISRDAACAPyEmAn8gEEEQdCALRQ0AGiAQQf8HcSELIBBBgIACcSEIIBBBgPgBcSIHQYD4AUYEQCAIQRB0IgdBgICA/AdyIAtFDQEaIAcgC0ENdHJBgICA/gdyDAELIAhBEHQiCCAHQQ10QYCAgPwAcSALQQ10ckGAgIDAA2pyIAcNABogCyALZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEmCwJ/AkAgDyAaSQRAICUgIZQiJSAjICKUYCAJIA9BGGxqIgktABMiDyAJLQASIgggCS0AESIHIAcgCEkbIgcgByAPSRsiCgR9QwAAQMEgESoCRCARLQBYQQJGIgcbIiBDAAAQQSARKgJIIAcbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISNFIQ8gJSAlWyEIIAlBDGovAQAiEEH//wFxIgtFBEAgEEEQdAwDCyAQQf8HcSEaIBBBgIACcSEJIBBBgPgBcSIHQYD4AUYEQCAJQRB0IgdBgICA/AdyIBpFDQMaIAcgGkENdHJBgICA/gdyDAMLIAlBEHQhCSAHRQ0BIAdBDXRBgICA/ABxIBpBDXRyQYCAgMADaiAJcgwCCyAPIBpB3LvHABCMBwALIBogGmdBEGsiB0H//wNxQQhqdEH///8DcSAJQYCAgNgDciAHQRd0a3ILQwAAgD8hIr4iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAggD3EiDyAkICaUIiAgIFsgICAjICKUYEVxRwRAIAAhFgwBCyATIA0gDyAMBH1DAABAwSARKgJEIBEtAFhBAkYiBxsiIEMAABBBIBEqAkggBxsgIJNDAAB+Q5UgDEEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAsCfyAOQRB0IBZFDQAaIA5B/wdxIRYgDkGAgAJxIQggDkGA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgFkUNARogByAWQQ10ckGAgID+B3IMAQsgCEEQdCIIIAdBDXRBgICA/ABxIBZBDXRyQYCAgMADanIgBw0AGiAWIBZnQRBrIgdB//8DcUEIanRB////A3EgCEGAgIDYA3IgB0EXdGtyC74iIEMAAIA/XgR9ICAQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5QiIyAjWyAjIAoEfUMAAEDBIBEqAkQgES0AWEECRiIHGyIgQwAAEEEgESoCSCAHGyAgk0MAAH5DlSAKQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACwJ/IBBBEHQgC0UNABogEEH/B3EhCyAQQYCAAnEhCCAQQYD4AXEiB0GA+AFGBEAgCEEQdCIHQYCAgPwHciALRQ0BGiAHIAtBDXRyQYCAgP4HcgwBCyAIQRB0IgggB0ENdEGAgID8AHEgC0ENdHJBgICAwANqciAHDQAaIAsgC2dBEGsiB0H//wNxQQhqdEH///8DcSAIQYCAgNgDciAHQRd0a3ILviIgQwAAgD9eBH0gIBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlGBFcXMbIRYLIARBAWshBCAdIBYoAgAiDTYCBCAWIABrQQJ2IQ8CQAJAAkAgBQRAQwAAgD8hIQJ/AkAgBSgCACIHIBxBBGooAgAiEygCCCIMSQRAIBMoAgQiCSAHQRhsaiIKLQATIgsgCi0AEiIIIAotABEiByAHIAhJGyIHIAcgC0kbIggEfUMAAEDBIBMqAkQgEy0AWEECRiIHGyIgQwAAEEEgEyoCSCAHGyAgk0MAAH5DlSAIQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEkIApBDGovAQAiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCyAHQYCAAnEhCCAHQYD4AXEiB0GA+AFGBEAgCEEQdCIHQYCAgPwHciALRQ0DGiAHIAtBDXRyQYCAgP4HcgwDCyAIQRB0IQggB0UNASAHQQ10QYCAgPwAcSALQQ10ckGAgIDAA2ogCHIMAgsgByAMQdy7xwAQjAcACyALIAtnQRBrIgdB//8DcUEIanRB////A3EgCEGAgIDYA3IgB0EXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISELQwAAgD8hIgJ/AkAgDCANSwRAIAkgDUEYbGoiCS0AEyILIAktABIiCCAJLQARIgcgByAISRsiByAHIAtJGyIIBH1DAABAwSATKgJEIBMtAFhBAkYiBxsiIEMAABBBIBMqAkggBxsgIJNDAAB+Q5UgCEEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshIyAJQQxqLwEAIgdB//8BcUUEQCAHQRB0DAMLIAdB/wdxIQsgB0GAgAJxIQggB0GA+AFxIgdBgPgBRgRAIAhBEHQiB0GAgID8B3IgC0UNAxogByALQQ10ckGAgID+B3IMAwsgCEEQdCEIIAdFDQEgB0ENdEGAgID8AHEgC0ENdHJBgICAwANqIAhyDAILIA0gDEHcu8cAEIwHAAsgCyALZ0EQayIHQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAdBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEiCyAkICGUIiAgIFwgICAjICKUYHINAQsgASADSw0BIAIgAUECdCIaaiEVQQAhCCAAIQsgDyEHA0AgACAHQQNrIglBACAHIAlPG0ECdGoiEyALSwRAIBxBBGooAgAiEigCCCEZIBYoAgAhFANAQwAAgD8hIQJ/AkAgGSALKAIAIhBLBEAgEigCBCIbIBBBGGxqIg0tABMiDCANLQASIgogDS0AESIJIAkgCkkbIgkgCSAMSRsiCgR9QwAAQMEgEioCRCASLQBYQQJGIgkbIiBDAAAQQSASKgJIIAkbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISQgDUEMai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyAQIBlB3LvHABCMBwALIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQtDAACAPyEiAn8CQCAUIBlJBEAgGyAUQRhsaiIXLQATIgwgFy0AEiIKIBctABEiCSAJIApJGyIJIAkgDEkbIgoEfUMAAEDBIBIqAkQgEi0AWEECRiIJGyIgQwAAEEEgEioCSCAJGyAgk0MAAH5DlSAKQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEjIBdBDGoiES8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyAUIBlB3LvHABCMBwALIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIgsgCEECdCACIBVBBGsgJCAhlCIgICBbICAgIyAilGBFcSING2ogEDYCAEMAAIA/ISECfwJAIBkgC0EEaigCACIOSwRAIBsgDkEYbGoiEC0AEyIMIBAtABIiCiAQLQARIgkgCSAKSRsiCSAJIAxJGyIKBH1DAABAwSASKgJEIBItAFhBAkYiCRsiIEMAABBBIBIqAkggCRsgIJNDAAB+Q5UgCkEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAQQQxqLwEAIglB//8BcUUEQCAJQRB0DAMLIAlB/wdxIQwgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgDEUNAxogCSAMQQ10ckGAgID+B3IMAwsgCkEQdCEKIAlFDQEgCUENdEGAgID8AHEgDEENdHJBgICAwANqIApyDAILDAsLIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsgFy0AEyIMIBctABIiCiAXLQARIgkgCSAKSRsiCSAJIAxJGyIKBH1DAABAwSASKgJEIBItAFhBAkYiCRsiIEMAABBBIBIqAkggCRsgIJNDAAB+Q5UgCkEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshI0MAAIA/ISICfyARLwEAIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQwgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQiCUGAgID8B3IgDEUNARogCSAMQQ10ckGAgID+B3IMAQsgCkEQdCIKIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADanIgCQ0AGiAMIAxnQRBrIglB//8DcUEIanRB////A3EgCkGAgIDYA3IgCUEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAggDWoiDUECdCACIBVBCGsgJCAhlCIgICBbICAgIyAilGBFcSIMG2ogDjYCAEMAAIA/ISECfwJAIBkgC0EIaigCACIOSwRAIBsgDkEYbGoiEC0AEyIKIBAtABIiCSAQLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAQQQxqLwEAIghB//8BcUUEQCAIQRB0DAMLIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNAxogCCAKQQ10ckGAgID+B3IMAwsgCUEQdCEJIAhFDQEgCEENdEGAgID8AHEgCkENdHJBgICAwANqIAlyDAILDAsLIAogCmdBEGsiCEH//wNxQQhqdEH///8DcSAJQYCAgNgDciAIQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsgFy0AEyIKIBctABIiCSAXLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshI0MAAIA/ISICfyARLwEAIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNARogCCAKQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIApBDXRyQYCAgMADanIgCA0AGiAKIApnQRBrIghB//8DcUEIanRB////A3EgCUGAgIDYA3IgCEEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAwgDWoiDUECdCACIBVBDGsgJCAhlCIgICBbICAgIyAilGBFcSIMG2ogDjYCAEMAAIA/ISECfwJAIBkgC0EMaigCACIOSwRAIBsgDkEYbGoiEC0AEyIKIBAtABIiCSAQLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAQQQxqLwEAIghB//8BcUUEQCAIQRB0DAMLIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNAxogCCAKQQ10ckGAgID+B3IMAwsgCUEQdCEJIAhFDQEgCEENdEGAgID8AHEgCkENdHJBgICAwANqIAlyDAILDAsLIAogCmdBEGsiCEH//wNxQQhqdEH///8DcSAJQYCAgNgDciAIQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsgFy0AEyIKIBctABIiCSAXLQARIgggCCAJSRsiCCAIIApJGyIJBH1DAABAwSASKgJEIBItAFhBAkYiCBsiIEMAABBBIBIqAkggCBsgIJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshI0MAAIA/ISICfyARLwEAIghB//8BcUUEQCAIQRB0DAELIAhB/wdxIQogCEGAgAJxIQkgCEGA+AFxIghBgPgBRgRAIAlBEHQiCEGAgID8B3IgCkUNARogCCAKQQ10ckGAgID+B3IMAQsgCUEQdCIJIAhBDXRBgICA/ABxIApBDXRyQYCAgMADanIgCA0AGiAKIApnQRBrIghB//8DcUEIanRB////A3EgCUGAgIDYA3IgCEEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAwgDWoiCUECdCACIBVBEGsiFSAkICGUIiAgIFsgICAjICKUYEVxIggbaiAONgIAIAggCWohCCALQRBqIgsgE0kNAAsLIAAgB0ECdGoiEyALSwRAIBxBBGooAgAiGygCCCEUIBYoAgAhEQNAQwAAgD8hIQJ/AkAgFCALKAIAIg5LBEAgGygCBCINIA5BGGxqIhAtABMiDCAQLQASIgogEC0AESIJIAkgCkkbIgkgCSAMSRsiCgR9QwAAQMEgGyoCRCAbLQBYQQJGIgkbIiBDAAAQQSAbKgJIIAkbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgEEEMai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyAOIBRB3LvHABCMBwALIAwgDGdBEGsiCUH//wNxQQhqdEH///8DcSAKQYCAgNgDciAJQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQsCfwJAIBEgFEkEQCANIBFBGGxqIg0tABMiDCANLQASIgogDS0AESIJIAkgCkkbIgkgCSAMSRsiCgR9QwAAQMEgGyoCRCAbLQBYQQJGIgkbIiBDAAAQQSAbKgJIIAkbICCTQwAAfkOVIApBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISAgDUEMai8BACIJQf//AXFFBEAgCUEQdAwDCyAJQf8HcSEMIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IglBgICA/AdyIAxFDQMaIAkgDEENdHJBgICA/gdyDAMLIApBEHQhCiAJRQ0BIAlBDXRBgICA/ABxIAxBDXRyQYCAgMADaiAKcgwCCyARIBRB3LvHABCMBwwGCyAMIAxnQRBrIglB//8DcUEIanRB////A3EgCkGAgIDYA3IgCUEXdGtyCyEJIAhBAnQgAiAVQQRrIhUgIyAhlCIjICNbICMgICAJviIgQwAAgD9eBH0gIBDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlGBFcSIJG2ogDjYCACAIIAlqIQggC0EEaiILIBNJDQALCyABIAdHBEAgFUEEayIVIAhBAnRqIAsoAgA2AgAgC0EEaiELIAEhBwwBCwsgCEECdCIMBEAgACACIAz8CgAACyABIAhrIQoCQCABIAhGDQBBACEHIApBBE8EQCAAIAxqIQ0gGiAfaiEJIApBfHEiByELA0AgDSAJ/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgCUEQayEJIA1BEGohDSALQQRrIgsNAAsgByAKRg0BCyAeIBogB0ECdCILa2ohDSAAIAtqIAxqIQkgByABayAIaiELA0AgCSANKAIANgIAIA1BBGshDSAJQQRqIQkgC0EBaiILDQALCyAIRQ0AIAEgCE8NAiAdQQA2AhggHUEBNgIMIB1BiILIADYCCCAdQgQ3AhAgHUEIakH0lMEAEI0IAAsgASADSw0AIAIgAUECdCIQaiEVIAYoAgAhGkEAIRQgACELA0AgACAPQQNrIgVBACAFIA9NG0ECdGoiDSALSwRAIBpBBGooAgAiFygCCCEbIBYoAgAhHCAGKAIAQQRqIQwDQEMAAIA/ISECfwJAIBsgHEsEQCALKAIAIQ4gFygCBCIJIBxBGGwiCmoiEy0AEyIIIBMtABIiByATLQARIgUgBSAHSRsiBSAFIAhJGyIHBH1DAABAwSAXKgJEIBctAFhBAkYiBRsiIEMAABBBIBcqAkggBRsgIJNDAAB+Q5UgB0EBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCATQQxqLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQggBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgCEUNAxogBSAIQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgCEENdHJBgICAwANqIAdyDAILIBwgG0Hcu8cAEIwHAAsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIA4gG0kEQCAJIA5BGGxqIgktABMiCCAJLQASIgcgCS0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgFyoCRCAXLQBYQQJGIgUbIiBDAAAQQSAXKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgCUEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEIIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIAhFDQMaIAUgCEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCyAOIBtB3LvHABCMBwALIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIgsgFEECdCACIBVBBGsgJCAhlCIgICBcICAgIyAilGByIgkbaiAONgIAQwAAgD8hIQJ/AkAgDCgCACIYKAIIIhkgHEsEQCALQQRqKAIAIQ4gCiAYKAIEIhFqIhItABMiCCASLQASIgcgEi0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgGCoCRCAYLQBYQQJGIgUbIiBDAAAQQSAYKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISQgEkEMaiITLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQggBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgCEUNAxogBSAIQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgCEENdHJBgICAwANqIAdyDAILIBwgGUHcu8cAEIwHAAsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIA4gGUkEQCARIA5BGGxqIgotABMiCCAKLQASIgcgCi0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgGCoCRCAYLQBYQQJGIgUbIiBDAAAQQSAYKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgCkEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEIIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIAhFDQMaIAUgCEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCwwKCyAIIAhnQRBrIgVB//8DcUEIanRB////A3EgB0GAgIDYA3IgBUEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAkgFGoiCkECdCACIBVBCGsgJCAhlCIgICBcICAgIyAilGByIgkbaiAONgIAIAtBCGooAgAhFCASLQATIgggEi0AEiIHIBItABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEkQwAAgD8hIQJ/IBMvAQAiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0BGiAFIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgBUENdEGAgID8AHEgCEENdHJBgICAwANqciAFDQAaIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQtDAACAPyEiAn8CQCAUIBlJBEAgESAUQRhsaiIOLQATIgggDi0AEiIHIA4tABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEjIA5BDGovAQAiBUH//wFxRQRAIAVBEHQMAwsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0DGiAFIAhBDXRyQYCAgP4HcgwDCyAHQRB0IQcgBUUNASAFQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogB3IMAgsgFCAZQdy7xwAQjAcACyAIIAhnQRBrIgVB//8DcUEIanRB////A3EgB0GAgIDYA3IgBUEXdGtyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRISILIAkgCmoiCkECdCACIBVBDGsgJCAhlCIgICBcICAgIyAilGByIgkbaiAUNgIAIAtBDGooAgAhDiASLQATIgggEi0AEiIHIBItABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEkQwAAgD8hIQJ/IBMvAQAiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0BGiAFIAhBDXRyQYCAgP4HcgwBCyAHQRB0IgcgBUENdEGAgID8AHEgCEENdHJBgICAwANqciAFDQAaIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIQtDAACAPyEiAn8CQCAOIBlJBEAgESAOQRhsaiITLQATIgggEy0AEiIHIBMtABEiBSAFIAdJGyIFIAUgCEkbIgcEfUMAAEDBIBgqAkQgGC0AWEECRiIFGyIgQwAAEEEgGCoCSCAFGyAgk0MAAH5DlSAHQQFrQf8BcbOUkhCJBCIgICCSBUMAAAAACyEjIBNBDGovAQAiBUH//wFxRQRAIAVBEHQMAwsgBUH/B3EhCCAFQYCAAnEhByAFQYD4AXEiBUGA+AFGBEAgB0EQdCIFQYCAgPwHciAIRQ0DGiAFIAhBDXRyQYCAgP4HcgwDCyAHQRB0IQcgBUUNASAFQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogB3IMAgsMCgsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEiCyAJIApqIgdBAnQgAiAVQRBrIhUgJCAhlCIgICBcICAgIyAilGByIgUbaiAONgIAIAUgB2ohFCALQRBqIgsgDUkNAAsLIAAgD0ECdGoiCiALSwRAIBpBBGooAgAiESgCCCEOIBYoAgAhDQNAQwAAgD8hIQJ/AkAgDSAOSQRAIAsoAgAhEyARKAIEIgkgDUEYbGoiDC0AEyIIIAwtABIiByAMLQARIgUgBSAHSRsiBSAFIAhJGyIHBH1DAABAwSARKgJEIBEtAFhBAkYiBRsiIEMAABBBIBEqAkggBRsgIJNDAAB+Q5UgB0EBa0H/AXGzlJIQiQQiICAgkgVDAAAAAAshJCAMQQxqLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQggBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgCEUNAxogBSAIQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgCEENdHJBgICAwANqIAdyDAILIA0gDkHcu8cAEIwHAAsgCCAIZ0EQayIFQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAVBF3Rrcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEhC0MAAIA/ISICfwJAIA4gE0sEQCAJIBNBGGxqIgktABMiCCAJLQASIgcgCS0AESIFIAUgB0kbIgUgBSAISRsiBwR9QwAAQMEgESoCRCARLQBYQQJGIgUbIiBDAAAQQSARKgJIIAUbICCTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIiAgIJIFQwAAAAALISMgCUEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEIIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIAhFDQMaIAUgCEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCyATIA5B3LvHABCMBwALIAggCGdBEGsiBUH//wNxQQhqdEH///8DcSAHQYCAgNgDciAFQRd0a3ILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhIgsgFEECdCACIBVBBGsiFSAkICGUIiAgIFwgICAjICKUYHIiBRtqIBM2AgAgBSAUaiEUIAtBBGoiCyAKSQ0ACwsgASAPRwRAIAIgFEECdGogCygCADYCACALQQRqIQsgFEEBaiEUIBVBBGshFSABIQ8MAQsLIBRBAnQiDwRAIAAgAiAP/AoAAAsgASAURg0EIAAgD2ohB0EAIRUCQCABIBRrIghBBE8EQCAQIB9qIQ0gByEJIAhBfHEiFSELA0AgCSAN/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgDUEQayENIAlBEGohCSALQQRrIgsNAAsgCCAVRg0BCyAeIBVBAnQiBWsgEGohDSAAIAVqIA9qIQkgFSABayAUaiELA0AgCSANKAIANgIAIA1BBGshDSAJQQRqIQkgC0EBaiILDQALCyABIBRPBEBBACEFIAchACAIIQEgCEEhSQ0EDAMLIBQgASABQYSVwQAQ6gcACwALIAAgDGogCiACIAMgBCAdQQRqIAYQOCAIIQEgCEEhTw0ACyAAIQcLIAhBAkkNACAGKAIAIQYgCEEBdiEPIA8CfyAIQQ9NBEAgCEEHSwRAIAcgAiAGQQRqIgEoAgAQbSAHIA9BAnQiAGogACACaiABKAIAEG1BBAwCCyACIAcoAgA2AgAgAiAPQQJ0IgBqIAAgB2ooAgA2AgBBAQwBCyAHIAIgCEECdGoiBSAGQQRqIgQoAgAQbSAHQRBqIAVBEGogBCgCABBtIAVBCCACIAYQtgEgByAPQQJ0IgNqIgEgBUEgaiIAIAQoAgAQbSABQRBqIAVBMGogBCgCABBtIABBCCACIANqIAYQtgFBCAsiA0sEQCAPIANrIQkgA0ECdCENA0AgAiANaiIAIAcgDWooAgA2AgAgAiAAIAYQygEgDUEEaiENIAlBAWsiCQ0ACwsgCCAPayADSwRAIAIgD0ECdCIAaiEBIAcgA0ECdCAAaiIAaiEJIAAgAmohDSADIA9qIAhrIRUDQCANIAkoAgA2AgAgASANIAYQygEgCUEEaiEJIA1BBGohDSAVQQFqIhUNAAsLIAIgCCAHIAYQtgELIB1BIGokAA8LIA4gGUHcu8cAEIwHAAvgawMRfwd+AXsjAEGw1QBrIgMkACAD/QwAAAAAAAAAAAAAAAAAAAAA/QsD8EggAq0hFAJAAkACQAJAAkACQAJAAn8CQAJ+AkACQAJAAkACQAJAAkACQEG4nMcAKQMAIhhC/wGDQgRSBEBCECEXA0AgAiAVIBQgFCAVVhunIgZrIgRCgMAAIBcgF0KAwABaG6ciBSAEIAVJGyIEBEAgA0EYaiABIAZqIAT8CgAACyACIAZGDQJBEEIQIBYgFkIQWhunIgVrIgYgBCAEIAZLIgcbIgYEQCADQfDIAGogBWogA0EYaiAG/AoAAAsgBw0DIBUgBK0iGnwhFSAEIApqIQogFiAGrXwhFiAXIBp9IhdCAFINAAsMAQtCECEXA0AgAiAVIBQgFCAVVhunIgZrIgRCgMAAIBcgF0KAwABaG6ciBSAEIAVJGyIEBEAgA0EYaiABIAZqIAT8CgAACyACIAZGDQFBEEIQIBYgFkIQWhunIgVrIgYgBCAEIAZLGyIGBEAgA0HwyABqIAVqIANBGGogBvwKAAALIBYgBq18IRYgBCAKaiEKIBUgBK0iGHwhFSAXIBh9IhdQRQ0ACwtB+LbJACgCACINQQBIDQJB+LbJACANQQFqNgIAIApBEUkEQANAIAwoAuy3RCEFIAwoAui3RCEEAkAgDCgC9LdEIgdFBEAgBSAKSw0BIAQgA0HwyABqIAUQ2wcNAQwFCyAFIApLDQAgDCgC8LdEIgYgB2ohDiADQfDIAGohBwNAIAVFDQUgBUEBayEFQaSkxwAgBiAGRSAGIA5GciIIGyEPIActAAAhCSAELQAAIQsgB0EBaiEHIARBAWohBEEAIAZBAWogCBshBiALIAkgDy0AAHFGDQALCyAMQRRqIgxBuANHDQALQfi2yQAgDTYCAEEDIQRBBCEBQQMhCQwLC0EAIApBEEGUpMcAEOoHAAsgGBDSByEBIABBgICAgHg2AgAgACABNgIEDAoLQfi2yQAgDTYCAAJAAn4CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAxB+LfEAGotAAAiBA4EAAMDAQMLQYCAARBxIgZFDRUgBkEAQYCAAfwLAEGAEBBxIgVFDRUgBUEAQYAQ/AsAIANBJGpBADsBACADQQA2AiBBqAcQcSIERQ0VIARBAEHYBvwLACAEQQA2ApQHIARBADYCiAcgBEEAOgCEByAEQQA2AoAHIAQgBTYC/AYgBCAGNgL4BiAEQgI3A/AGIARCADcD6AYgBEKAgICAIDcD4AYgBEEBNgLcBiAEQSQ2AtgGIARBADoApgcgBCADKQMYNwOYByAEQZ4HaiADKQEeNwEAQYABEHEiBkUNFSADQeQCakIANwIAIAP9DAAAAAAAAAAAAAAAAAAAAAD9CwLUAiADQQI2ArhFIANBADYCsEUgA0G8xQBqIANBGGoiBUHUAvwKAAAgA0GAAjsAw0ggA0EBOwHASCADQoCAgICCIDcDuEggA0IANwOwSCADQQA6AKhIIANBgAI7AaRIIAMgBDYCoEggA0EAOgCcSCADQQA2AphIIAMgBjYClEggA0GAATYCkEggAyABNgLISCADIAI2AsxIIANCADcD0EggA0EANgLYSCADQQA6AMJIIANB4MgAaiIBIANBsMUAahCcBCADLQDgSEEoRwRAIAUgARD8AyADKAIYIgFBBkcNBAsgA0EQNgLYSCADQdDRAGoiASADQbDFAGpBsAP8CgAAIANBGGogARCcBCADLQAYIgZBKEcEQCADQarVAGogAy0AGzoAACADIAMvABk7AahVIAMoAhwhBSADKQIgIRQgARCdAQwZCwJAAkAgAygCHCIBLQC+AiICQQN0KQOwkkkgATUCtAIgATEAvwJ+IhR+IhVC8P////8AVg0AIBVCB3xCA4inQQFqrUGAASABKAK4AiIBIAFBgAFPG61+IhVCIIinDQAgFaciAUH/AXEiBEEARyABQYB+cUGAAmoiBiABSXENACAGIAEgBBsiBkGBgAhJDQELQYCACCEGC0EBIQVB/////wchBAJAIAJBA3QpA+iSSSAUfiIUQvD/////AFYNACAUQgd8QgOIp0EBaiIBQf////8DSw0AIAFBAnQiAkFAcUFAayEIIAFBD3EiAUEAIAIgCEsbDQBBgIAIIAggAiABGyIBIAFBgIAITRshBAsgBgRAIAYQcSIFRQ0WCyADQRhqIANB0NEAakGoA/wKAAAgA0H1A2pCADcAACADQbQEakEANgIAIANBAToA3QQgA0EANgLUBCADQQA2AsgDIANCADcDwAMgA0IANwPwAyADQYCAgIB4NgKgBCADQgE3A5gEIANCADcDkAQgAyAFNgKMBCADIAY2AogEIANCfzcDgAQgA/0MAAAAAAAAAAAAAAAAAAAAAP0LAqQEIAMgBDYCuAQgAyADKAL4VDYC2AQgA0ECNgLcAyADQQA6ANwEIANBADYC0AQgA0KAgICAEDcDyAQgA0EANgLABAJAIAMoAiBBAkcEQEEnIQYgAy0A3gJBA3QpA6CTSSADNQLUAiIUIAMxAN8Cfn5C8f////8AVA0BDBkLQayYxwAQ3QkACyADKALYAiEFIANBEGogA0EYaiIBEIoFIAMtABBBA3QpA9iTSSADMQARIBR+fiIUQvD/////AFYNFyAFrSAUQgd8QgOIfiIVQiCIpyAVp0EASHINFyADQZDVAGogARCMASADLQCQVSIGQShHBEAgA0Gq1QBqIAMtAJNVOgAAIAMgAy8AkVU7AahVIAMoApRVIQUgAykCmFUhFAwYCyADKAIgIgVBAkYNAUEBIQYgAygCTARAIAMoAlAgAy0A0QJBAkZqIQYLIANBqtUAaiIBIAMtAB86AAAgAyAGNgLUBCADIAMvAB07AahVIAMtABwhBiADKQIkIRQgAygCLCECIAMoAjAhCCADLQA0IQcgAy0ANSEJIAMtADYhCyADLQA3IQogA/0AAzghGyADKAIYIQQgA0G4zQBqIgwgA0HIAGpBmAT8CgAAIARBAkYNGCADIAMvAahVOwD1SCADIAEtAAA6APdIIANBoMkAaiAMQZgE/AoAACADIBv9CwSQSSADIAo6AI9JIAMgCzoAjkkgAyAJOgCNSSADIAc6AIxJIAMgCDYCiEkgAyACNgKESSADIBQ3AvxIIAMgBTYC+EggAyAGOgD0SCADIAQ2AvBIIANBCGogA0HwyABqEIoFQRwhByADLQAJIQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAy0ACEEBaw4GJAElAiQDAAtBACEFQQEhByAGaCIEQQFrDgQEAxMSJAtBAiEFQQMhByAGaCIEQQFrDgQEBRIGIwtBASEFQQIhByAGaCIEQQFrDgQGBxEIIgtBBCEHIAZoIgVBAWsOBAgJEAohC0EJIQcMIAtBBSEHDB8LQQchBwweC0ELIQcMHQtBBiEFDAsLQQYhBwwbC0EKIQcMGgtBBSEFDAgLQQghBwwYC0EMIQcMFwtBByEFDAULAn5BwLvJAC0AAARAQdC7yQApAwAhF0HIu8kAKQMADAELIANBuM0AahC/BkHAu8kAQQE6AABB0LvJACADKQPATSIXNwMAIAMpA7hNCyEVQQAhBiADQTxqQQA2AgAgAyAVNwOAAUHIu8kAIBVCAXw3AwAgA0IANwNoIAMgATYCYCADQQI6AF0gA0GAgICAeDYCICADQgA3AxggA/0MAAAAAAAAAAAAAAAAAAAAAP0LAiwgA0EBOgBAIANBATYCqAEgA/0M/////wAAAAAAAAAAAAAAAP0LA5gBIANCADcDkAEgA0EAOgCsASADIBc3A4gBIANB8JrIAP0AAwD9CwNwIAMgAjYCZAJAAkACQCACQQRPBEAgASgAACEGQgQhFwwBCyADQgQgFEGokMgAKQMAIhVC/wGDQgRRIgQbIhc3A2ggBEUNAQsgA0G4zQBqQQFyIAYQmAQgAyADLQC7TToA0lEgAyADLwC5TTsB0FEgAyADLwG8TTsA01FBBCEGIAMCfgJAIAIgFyAUIBQgF1YbpyIEa0EETwRAIAEgBGo1AAAhGUIAIRYMAQtBqJDIACkDACIVQgiIIRYgFachBiAUIBVC/wGDQgRSDQEaCyAXQgR8CyIVNwNoIAZB/wFxQQRGDQEgBq1C/wGDIBZCCIaEIRULIAMgFT0Ak1UgA0GZ1QBqIBVCMIg9AAAgAyAVQhCIPgCVVUEAIQVBEyEEDBELIAMtANBRRQRAQQQhBgJAAkAgAiAVIBQgFCAVVhunIgJrQQRPBEAgASACaigAACEFQgAhFgwBC0EAIQVBqJDIACkDACIXQgiIIRYgF6chBiAXQv8Bg0IEUg0BCyAVQgR8IRQLIAMgFDcDaCAGQf8BcUEERwRAIANBkNUAakEBciEEIAMgBq1C/wGDIBZCCIaENwK8TSADQZnVAGogA0HCzQBqLwEAOwAAIAMgAygBvk02AJVVIAMoAbpNIQZBACEFDAkLIANBuM0AakEBciAFEJgEQdKSmbIEIQYgA0GQ1QBqIQRBAiEFAkACQAJAAkACQAJAAkACQAJAAkAgAy0AuU1BAWsOCwkRAAECAwQFBgcIEgtB1qDh4QQhBgwRC0HWoOHBBSEGDBALQcGcpeoEIQYMDwtBwZy1sgQhBgwOC0HBmMHCBCEGDA0LQcmGjYIFIQYMDAtBxbClsgQhBgwLC0HYmsGCAiEGDAoLIAMoAbpNIQYMCQsgA0G4zQBqIANB4ABqIgEQvQMgAygCuE0NDyADQfAAaiEIIAMgAy0AzE06AKxVIAMgAygCyE0iAjYCqFUgAykDwE0hFkHSkpmyBCEEIAMpA2ghFwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAJB/wFxQQFrDgsACQoLAQIDBAUGBwgLQdeKiYIFIQQMBwtBwZyl6gQhBAwGC0HBnLWyBCEEDAULQcGYwcIEIQQMBAtByYaNggUhBAwDC0HFsKWyBCEEDAILQdiawYICIQQMAQsgAygAqVUhBAsgAyAENgKQVUEEIQVBEyEEDBULIANBuM0AaiECQQAhBkIAIRkgASgCBCIErSEUAkACQCAEQv////8PIAEpAwgiFSAVQv////8PWhunayIFQQAgBCAFTxtBA08EQCABKAIAIBUgFCAUIBVWG6dqIgQvAAAgBEECai0AAEEQdHIhBkEEIQQMAQtBqJDIACkDACIYQgiIIRkgGKchBCAYQv8Bg0IEUg0BCyAVQgN8IRQLIAEgFDcDCAJAIARB/wFxQQRHBEAgAiAErUL/AYMgGUIIhoQ3AgAMAQsgAkEEOgAAIAIgBjYCBAsCQCADLQC4TUEERwRAIAMpA7hNIhRCIIinIQUgFKciAkH/AXFBBEYNASADIAU2AJdVIAMgAjoAk1UgAyACQRh2OgCWVSADIAJBCHY7AZRVQQAhBUETIQQMFgsgAygCvE0hBQsCQCAFQQFxRQRAIAMoAmQiAq0hFSACQv////8PIAMpA2giFCAUQv////8PWhunayIEQQAgAiAETxtBAksNAUGokMgAKQMAIhenIQECQCAXQv8Bg0IEUQRAIAMgFEIDfDcDaCABQf8BcUEERg0BDBULIAMgFTcDaCABQf8BcUEERw0UC0EAIQUMEgtBExBxIgFFDRkgAUGcrcYA/QAAAP0LAAAgAUEPakGrrcYAKAAANgAAIANBmdUAaiABQRB2rT0AACADQRM7AJNVIAMgAUEQdDYAlVVBGCEFQRMhBAwVCyADIBRCA3w3A2ggAygCYCAUIBUgFCAVVBunaiICLwAAIAJBAmotAABBEHRyIgVBnYOoAUcNECADQbjNAGogARCQBiADLQC4TUEERgRAIAMvAbpNIQUMDwsgAykDuE0iFEIQiKchBSAUpyICQf8BcUEERg0OIAMgBTsAlVUgAyACOgCTVSADIBRCIIg+AJdVIAMgFEIIiDwAlFVBACEFQRMhBAwUCyADQbjNAGogARCpBgJAIAMtALhNQQRHBEAgAykDuE0iFEIIiKchBSAUpyICQf8BcUEERg0BIANBmdUAaiAUQjCIPQAAIAMgBToAlFUgAyACOgCTVSADIBRCEIg+AJVVQQAhBUETIQQMFQsgAy0AuU0hBQsgBUH/AXFBL0cNASADQbjNAGogARCRBiADLQC4TUEERgRAIAMoArxNIQYMDQsgAykDuE0iFEIgiKchBiAUpyIBQf8BcUEERg0MIAMgBjYAl1UgAyABOgCTVSADIAFBGHY6AJZVIAMgAUEIdjsBlFVBACEFQRMhBAwTCyADKQPQTSEaIANBuM0AaiEFQgAhFUEAIQlBACEMQQAhBkEAIQRBACENIwBBEGshCyABAn4CQCABKAIEIgogASkDCCIWIAqtIhQgFCAWVhunIgJHBEAgASgCACACai0AACEJQQQhBwwBC0GokMgAKQMAIhhCCIghFSAYpyEHIBQgGEL/AYNCBFINARoLIBZCAXwLIhY3AwhBBCECAkACQCAHQf8BcUEERwRAIAUgFTwABSAFIAc6AAQgBUEAOgAAIAVBCmogFUIoiD0BACAFIBVCCIg+AQYMAQtCACEVIAECfiAKIBYgFCAUIBZWG6drQQJNBEBBqJDIACkDACIYQgiIIRUgGKchAiAUIBhC/wGDQgRSDQEaCyAWQgN8CyIWNwMIIAJB/wFxQQRHBEAgCyACrUL/AYMgFUIIhoQiFDcDACAFIAspAgQ3AgggBSAUPgIEIAVBADoAAAwBCyABAn4CQCAKIBYgFCAUIBZWG6ciAmtBA08EQCABKAIAIAJqIgYtAAFBCHQhAiAGLQACQRB0IQQgBi0AACEMQQQhB0IAIRUMAQtBqJDIACkDACIYQgiIIRUgGKchB0EAIQIgFCAYQv8Bg0IEUg0BGgsgAiEGIBZCA3wLIhY3AwggB0H/AXFBBEcEQCALIAetQv8BgyAVQgiGhCIUNwMAIAUgCykCBDcCCCAFIBQ+AgQgBUEAOgAADAELAn8CQCAKIBYgFCAUIBZWG6ciAmtBA08EQCABKAIAIAJqIgotAAFBCHQhByAKLQACQRB0IQIgCi0AACENQQQhCkIAIRUMAQtBqJDIACkDACIYQgiIIRUgGKchCkEAIQdBACECQQAgGEL/AYNCBFINARoLIBZCA3whFCAHCyEHIAEgFDcDCCAKQf8BcUEERwRAIAsgCq1C/wGDIBVCCIaEIhQ3AwAgBSALKQIENwIIIAUgFD4CBCAFQQA6AAAMAQsgBiAMciAEckEBaiIErSAHIA1yIAJyQQFqIgKtfkIgiFAEQCAFQQA6AAwgBUEANgIIIAUgAjYCBCAFIAQ2AgAgBSAJQQJ2QQFxOgAUIAUgCUEDdkEBcToAEyAFIAlBBXZBAXE6ABIgBSAJQQR2QQFxOgARIAUgCUEBdkEBcToAFQwCCyAFQQk6AAALIAVBAjoAFQsgAygCxE0hBCADKALATSELIAMoArxNIQYgAygCuE0hAiADLQDNTSIJQQJGDQcgAyAGNgKgASADIAI2ApwBIAMgFyAafCIUNwNoIAMvAc5NIRAgAy0AzE0hDCADLQDLTSENIAMtAMpNIREgAy0AyU0hDiADLQDITSESAkACQAJAIBQgFCAZQgx9IhVCACAVIBlYG3wiF1oNAANAIANB0NEAaiABEL0DAkACQAJAAn8CQAJAAkAgAygC0FEEQCADLQDUUSIFDQUgAy0A2FFBAWsOAwECAwULIAMpA+hRIhUgFEIIfCIWfCEUAkACQCADLQDgUSIFQQtHBEAgAykD2FEiGSAWfCEYIAMgAygA4VE2ALFFIAMgBToAsEUgA0G4zQBqIAggA0GwxQBqEIQEAkAgAy0AxE1BDEcEQCADQcDFAGogA0HIzQBqKQMANwMAIAMgA/0AA7hN/QsDsEUMAQsgA0EMOgC8RSADIAMpA7hNNwOwRQsgA0GwxQBqIBYgGBD+BCAFQQZGDQELIBVCAFMgFSADKQNoIhV8IhYgFVRzRQ0BIANCgICAgA4+ApRVIANBmtUAakIAPAAAIANBmNUAakLVIz0BACADQQI6AJNVQQAhBQweCyADIAMoAqQBQQFqNgKkASAZQhhUBEBBGyEFDB4LIAMpA2giFkJ0WgRAIANCgICAgA4+ApRVIANBmtUAakIAPAAAIANBmNUAakLVIz0BACADQQI6AJNVQQAhBQweCyADIBZCDHw3A2ggA0G4zQBqIAEQkQYgAy0AuE1BBEYEQCADKAK8TSEFDAgLIAMpA7hNIhZCIIinIQUgFqciB0H/AXFBBEYNByADQZbVAGogB0EYdjoAACADIAU2AJdVIAMgBzoAk1UgAyAHQQh2OwGUVUEAIQUMHQsgAyAWNwNoIBQgF1QNBwwICyADLQDZUQwCCyADKALcUS0ACAwBCyADKALcUS0ACAtBJUYNAQsgAyADKQDVUTcDkFUgAyADQdzRAGooAAA2AJdVIAMoAuBRIQQMFwsgAyADKQPYUTcDuE0gA0G4zQBqEM4FDAILIAMgAykDkAEgBUH///8Hca18NwOQAQJAIAMtAKoBRQRAIANBuM0AaiABEL0DIAMoArhNDRYCQAJAIAMtAMhNQQJrDgYAAQEBAQABCyADQQE6AKoBCyAVQhh9IhVCAFMgAykDaCIWIBV8IhUgFlRzRQ0BIANCgICAgA4+ApRVIANBmtUAakIAPAAAIANBmNUAakLVIz0BACADQQI6AJNVQQAhBQwXCyAVQhB9IhVCAFMgAykDaCIWIBV8IhUgFlRzDQMLIAMgFTcDaCAUIBdUDQALCyADIAMtAKoBBH9BAQUgCEHk+MYAEKgEQQBHCzoAqgEgCUEBcQ0BDAwLIANCgICAgA4+ApRVIANBmtUAakIAPAAAIANBmNUAakLVIz0BACADQQI6AJNVQQAhBQwSC0EDIQUgCEGo+cYAEKgERQ0NIAhBkPnGABCoBA0KDA0LIAMgBToAkFVBCyEFQRMhBAwRCyADQdKSmbIENgKQVUEEIQVBEyEEDBALQayYxwAQ3QkAC0EEIQFCACEUIARBCHQiCSEEQgAMFwsgAykDOCEUIAMpAzAhFyADLQAvIQkgAy0ALiEGIAMtAC0hByADLQAsIQogAygCKCELIAMoAhwhBCADKQMgIhVCIIinIQUgFachCCADQbDFAGoQnQEMFQtBBCEFCyAD/QAE8EghGyADQZjAAGoiASADQYDJAGpBuAT8CgAAQfAEEHEiBkUNDyAGQQA6AB8gBkEAOwAdIAZBgICAgAI2AgggBkIBNwMAIAb9DAAAAAAAAAAAAAAAAAAAAAD9CwIMIAYgG/0LAyAgBkEwaiABQbgE/AoAACAGIAU6AOgEQaikxwAMFgsgAyALNgCXVSADIAJBGHY6AJJVIAMgAkEIdjsBkFUgAyAGOwCTVSADIAZBEHY7AJVVIAIhBQwJC0HWoOGBAiEGCyAEIAY2AAAMAwsCQCANQQFxRQ0AIAhBrfnGABCoBA0AQQMhBUETIQQMCAsCQCAMQQFxRQ0AIAhBsvnGABCoBA0AQQMhBUETIQQMCAsCQAJAAkAgCUEBcUUEQCAIQeT4xgAQqARBAEcgCEHM+MYAEKgERXNFDQFBAyEFQRMhBAwLCyADQQU6ALhNIANB0NEAaiADQRhqIANBuM0AakEGEOQEAkACQAJAAkACQAJAAkACQCADLQDQUSIFQRprDgQBBgYABgsgAygC1FFBgICAgHhGBEBBAyEFDBELIANByM0AaiADQdTRAGoiB0EIaigCACIFNgIAIAMgBykCADcDwE0gBUEESQ0BIANCBDcDuE0gAygCxE0oAAAhCwwCCyADQdDRAGoQqwRBGyEFDA8LIANCBCAFrUGokMgAKQMAIhRC/wGDQgRRGzcDuE0gFKciBUH/AXFBBEcNAQsgA0GwxQBqIQVBACEPQgAhFyADQbjNAGoiBygCECIKrSEUAkACQCAKQv////8PIAcpAwAiFSAVQv////8PWhunayITQQAgCiATTxtBAk8EQCAHKAIMIBUgFCAUIBVWG6dqLwAAIQ9BBCEKDAELQaiQyAApAwAiFkIIiCEXIBanIQogFkL/AYNCBFINAQsgFUICfCEUCyAHIBQ3AwACQCAKQf8BcUEERwRAIAUgCq1C/wGDIBdCCIaENwIADAELIAVBBDoAACAFIA87AQILIAMtALBFQQRGBEAgAy8BskUhBQwECyADKQOwRSIUQhCIpyEFIBSnIgdB/wFxQQRGDQMgAyAFOwCVVSADIAc6AJNVIAMgFEIgiD4Al1UgAyAUQgiIPACUVQwBCyADQZrVAGogFEI4iDwAACADQZjVAGogFEIoiD0BACADIAU6AJNVIAMgFEIIiD4ClFULIAMoAsBNIgEEQCADKALETSABQQEQogcLQQAhBQwLCyADIAMpANFRNwOQVSADIANB2NEAaigAADYAl1UgAygC3FEhBAwKCyADIAU7AagBIAhBkPnGABCoBCIFRQ0BIAMgBSkDCEIIfTcDGCADKALATSIFRQ0AIAMoAsRNIAVBARCiBwsCQCAIQZD5xgAQqAQiBUUNACAFKQMQIRUgAyAFKQMIIhRCEHw3A2ggA0G4zQBqIgUgARC9AyADKAK4TQ0CIAMgAy0AzE06AIRVIAMgAygCyE02AoBVIAMpA9BNIRcgAykDwE0gBSAIIANBgNUAahCEBCAUQhh8Ihl8IRYCQCADLQDETUEMRwRAIANB4NEAaiADQcjNAGopAwA3AwAgAyAD/QADuE39CwPQUQwBCyADQQw6ANxRIAMgAykDuE03A9BRCyADQdDRAGogGSAWEP4EIBQgF3xCIHwiFCAVVg0AIANBuM0AaiIFIAEQvQMgAygCuE0NAiADIAMtAMxNOgCEVSADIAMoAshNNgKAVSADKQPATSEVIAUgCCADQYDVAGoQhAQgFCAVfCEVAkAgAy0AxE1BDEcEQCADQeDRAGogA0HIzQBqKQMANwMAIAMgA/0AA7hN/QsD0FEMAQsgA0EMOgDcUSADIAMpA7hNNwPQUQsgA0HQ0QBqIBQgFRD+BAsgAyAQOwFeIAMgCToAXSADIAw6AFwgAyANOgBbIAMgEToAWiADIA46AFkgAyASOgBYIAMgBDYCVCADIAs2AlAgAyAGNgJMIAMgAjYCSCADIA46AKsBDAoLQbj5xgAQ3QkACwwFCyAGQf////8BTQRAIAMgBkEBakH//wBxNgKcASADIAZBDnZBAWpB//8AcTYCoAEgA0EDOgDQUSADQbjNAGogCCADQdDRAGogFyAWIBd8EOYCIAMgBkH/////AEs6AKsBIANBAzoAXQwICyADIAZBHXY6AJBVQQwhBUETIQQMBgsgA0G4zQBqIAEQkAYCQCADLQC4TUEERgRAIAMvAbpNIQYMAQsgAykDuE0iFEIQiKchBiAUpyIBQf8BcUEERg0AIAMgBjsAlVUgAyABOgCTVSADIBRCIIg+AJdVIAMgFEIIiDwAlFVBACEFQRMhBAwGCyADIAZB//8AcSIBNgKgASADIAVB//8AcSICNgKcAUEXIQUgAkUgAUVyDQAgA0ECOgDQUSADQbjNAGogCCADQdDRAGogFyAWIBd8EOYCIANBAToAqgEgA0ECOgBdDAYLQRMhBAwECyADIAU7AZBVIAMgBUEQdjoAklVBESEFQRMhBAwDCyADIBdCCIgiFD4ClFUgA0Ga1QBqIBRCMIg8AAAgA0GY1QBqIBRCIIg9AQAgAyABOgCTVUEAIQVBEyEEDAILIANBmdUAaiADQcbNAGozAQA9AAAgAyADNQHCTT4AlVUgAyADLQC/TToAklUgAyADLwC9TTsBkFUgAyADLwHATTsAk1UgAygCyE0hBCADLQC8TSEFCyAFQf8BcUEdRg0BCyADQabVAGogAy0AklU6AAAgAyADLwGQVTsBpFUgA0GZ1QBqMwAAIRQgAzUAlVUhFSADLwCTVSEGIAMoAiAiAUGAgICAeHJBgICAgHhHBEAgAygCJCICQQRrKAIAIghBeHEiCUEEQQggCEEDcSIIGyABakkNDiAIQQAgCSABQSdqSxsNDyACEKICCwJAAkAgAygCdCIBRQ0AIAEgAUEYbCICakEhaiIBRQ0AIAMoAnAgAmsiAkEcaygCACIIQXhxIglBBEEIIAhBA3EiCBsgAWpJDQ8gCEEAIAkgAUEnaksbDQEgAkEYaxCiAgsgFSAUQiCGhAwCCwwOCyADQabVAGogA0Enai0AADoAACADIAMvACU7AaRVIAMpAxghFCADLQAkIQUgAygCMCEEIAMoAjQhCCADKAI4IQIgAygCPCEJIAP9AANAIRsgAygCICEBIAMpAyghFSADQfDIAGogA0HQAGpB4AD8CgAAIAFBgYCAgHhHDQEgFachBiAVQhCICyEUIAatQv//A4MgFEIQhoQhFCAFQf8BcQR/QRAQcSIJRQ0CIAkgBToAACAJIAMvAaRVOwABIAkgBDYCDCAJIBQ3AgQgCUEDaiADQabVAGotAAA6AABCgAYhFEEABUEFCyEBIBRCIIinIQggFKchBEHsu8QAIQdCAAwGCyADQdDEAGoiByADQfDIAGpB4AD8CgAAQaABEHEiBkUNACAGIAU6AAwgBiABNgIIIAYgFDcDACAGIAMvAaRVOwANIAYgG/0LAiggBiAJNgIkIAYgAjYCICAGIAg2AhwgBiAENgIYIAYgFTcCECAGQQ9qIANBptUAai0AADoAACAGQThqIAdB4AD8CgAAIAZBCDoAmAFB4KTHAAwHCwALIANB8MgAahDGA0EEIQpBACEEQQQhAQwCCyADQRhqEMYDCyADIAY6AIBVIAMgAy8BqFU7AIFVIAMgFDcCiFUgAyAFNgKEVSADIANBqtUAai0AADoAg1UgA0EYaiADQYDVAGoQ/AMgAykDOCEUIAMpAzAhFyADLQAvIQkgAy0ALiEGIAMtAC0hByADLQAsIQogAygCKCELIAMoAiQhBSADKAIgIQggAygCHCEEIAMoAhghAQsgAUEGRg0BIApB/wFxIAdB/wFxQQh0ciAGQf8BcUEQdHIgCUEYdHIhCSAXpyEHIBdCgICAgHCDCyAHrYQhFQwCCyAEIQYgCAshAgJAAn8gBiACKAIsERMAIhRCgICAgAJWBEBBACEFQQMhAUEDDAELIANBADYCiEkgA0EANgKASSADQoCAgIACIBR9NwP4SCADQgE3A/BIIANBGGogBiADQfDIAGogAigCMBEFACADKAIYIgFBBkYNASADKQM4IRQgAykDMCEVIAMoAiwhCSADKAIoIQsgAygCJCEFIAMoAhwhBCADKAIgCyEIIAIoAgAiBwRAIAYgBxEDAAsgAigCBCICRQ0BIAZBBGsoAgAiB0F4cSIKQQRBCCAHQQNxIgcbIAJqSQ0DIAdBACAKIAJBJ2pLGw0EIAYQogIMAQsgAyAGIAIoAgwRAQAgAygCBCEKIAMoAgAhCQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGIAIoAhARBABB/wFxQQFrDgkBAgMEBQYHCAkACyADQRhqIAYgAhChBCADKAIkIQUgAygCICEIIAMoAhwhBCADKAIYIgFBBkcNHwJAIAqtIhUgCa1+IhRCIIhQBEAgFKciASAFTQ0BC0EAIQtBAiEBIARFDR8gCCAEQQEQogdBgICAgHghBAwhCyAEQYCAgIB4Rw0JDBwLIANBGGogBiACEKEEIAMoAiQhBSADKAIgIQggAygCHCEEIAMoAhgiAUEGRw0eQQAhCwJAIAlBAEgNACAKrSIUIAlBAXStfiIVQiCIpw0AIBWnIAVNDQoLQQIhASAERQ0dIAggBEEBEKIHQYCAgIB4IQQMHwsgA0EYaiAGIAIQoQQgAygCJCEFIAMoAiAhCCADKAIcIQQgAygCGCIBQQZHDR0CQAJAIAmtIhdCA34iFEIgiKcNACAUp60gCq0iFH4iFUIgiKcNACAVpyAFTQ0BC0EAIQtBAiEBIARFDR0gCCAEQQEQogdBgICAgHghBAwfCyAEQYCAgIB4Rg0aIBdCA34iFUIgiKcNJCAVp60gFH4iFUIgiKcNJCAVpyIBIAVNDQkMIgsgA0EYaiAGIAIQoQQgAygCJCEFIAMoAiAhByADKAIcIQYgAygCGCIBQQZHBEAgAykDOCEUIAMpAzAhFSADKAIsIQkgAygCKCELIAYhBCAHIQgMHgsCQAJAIAlB/////wNLDQAgCUECdK0gCq1+IhRCIIinDQAgFKcgBU0NAQtBACELQYCAgIB4IQRBAiEBIAZFDR4gByAGQQEQogcMHgtBgICAgHghBCAGQYCAgIB4Rw0YQQAhC0ECIQEMHQsgA0EYaiAGIAIQjAQgAygCJCEFIAMoAiAhCCADKAIcIQQgAygCGCIBQQZHDRsgCq0iFSAJrX4iFEIgiFAEQCAUpyIBIAVNDQkLQQAhCyAERQ0ZQQIhASAIIARBAXRBAhCiB0GAgICAeCEEDBwLIANBGGogBiACEIwEIAMoAiQhBSADKAIgIQggAygCHCEEIAMoAhgiAUEGRw0aQQAhCwJAIAlBAEgNACAKrSIUIAlBAXStfiIVQiCIpw0AIBWnIAVNDQkLIARFDRhBAiEBIAggBEEBdEECEKIHQYCAgIB4IQQMGwsgA0EYaiAGIAIQjAQgAygCJCEFIAMoAiAhCCADKAIcIQQgAygCGCIBQQZHDRkCQAJAIAmtIhdCA34iFEIgiKcNACAUp60gCq0iFH4iFUIgiKcNACAVpyAFTQ0BC0EAIQsgBEUNGEECIQEgCCAEQQF0QQIQogdBgICAgHghBAwbCyAEQYCAgIB4Rg0WIBdCA34iFUIgiKcNICAVp60gFH4iFUIgiKcNICAVpyIBIAVNDQgMHgsgA0EYaiAGIAIQjAQgAygCJCEFIAMoAiAhCCADKAIcIQQgAygCGCIBQQZHDRgCQCAJQf////8DSw0AIAqtIhUgCUECdK1+IhRCIIinDQAgFKcgBU0NCQtBACELIARFDRZBAiEBIAggBEEBdEECEKIHQYCAgIB4IQQMGQsgA0EYaiAGIAIQjQQgAygCJCEFIAMoAiAhCCADKAIcIQQgAygCGCIBQQZHDRcCQAJAIAmtIhdCA34iFEIgiKcNACAUp60gCq0iFH4iFUIgiKcNACAVpyAFTQ0BC0EAIQsgBEUNFkECIQEgCCAEQQJ0QQQQogdBgICAgHghBAwZCyAEQYCAgIB4Rg0UIBdCA34iFUIgiKcNHiAVp60gFH4iFUIgiKcNHiAVpyIBIAVNDQgMHAsgA0EYaiAGIAIQjQQgAygCJCEFIAMoAiAhCCADKAIcIQQgAygCGCIBQQZHDRYCQCAJQf////8DSw0AIAqtIhUgCUECdK1+IhRCIIinDQAgFKcgBU0NCQtBACELIARFDRRBAiEBIAggBEECdEEEEKIHQYCAgIB4IQQMFwsgFEIgiKcNHCABIAVLDRogA0EYaiAIIAFBAhCBASADKAIcIQcCQAJAAkAgCUH/////A0sNACAJQQJ0rSAVfiIUQiCIpw0AIAMoAiAiBSAUp08NAQsgAygCGCIARQ0BIAcgAEEBEKIHDAELIAMoAhgiBkGAgICAeEcNCQsMGwsgBEGAgICAeEYNESAJQQF0rSAUfiIVQiCIpw0bIBWnIgEgBUsNGSADQRhqIAggAUEDEIEBIAMoAhwhBwJAAkACQCAJQf////8DSw0AIAlBAnStIBR+IhRCIIinDQAgAygCICIFIBSnTw0BCyADKAIYIgBFDQEgByAAQQEQogcMAQsgAygCGCIGQYCAgIB4Rw0JCwwaCyADQRhqIAggAUEAEIEBIAMoAhwhBwJAAkACQCAJQf////8DSw0AIAlBAnStIBR+IhRCIIinDQAgAygCICIFIBSnTw0BCyADKAIYIgBFDQEgByAAQQEQogcMAQsgAygCGCIGQYCAgIB4Rw0JCwwZCyAEQYCAgIB4Rg0PIBRCIIinDRkgASAFSw0XIANBGGogCCABQQIQeyADKAIcIQcCQAJAAkAgCUH/////A0sNACAJQQJ0rSAVfiIUQiCIpw0AIAMoAiAiBSAUp08NAQsgAygCGCIARQ0BIAcgAEEBEKIHDAELIAMoAhgiBkGAgICAeEcNCQsMGAsgBEGAgICAeEYNDiAJQQF0rSAUfiIVQiCIpw0YIBWnIgEgBUsNFiADQRhqIAggAUEDEHsgAygCHCEHAkACQAJAIAlB/////wNLDQAgCUECdK0gFH4iFEIgiKcNACADKAIgIgUgFKdPDQELIAMoAhgiAEUNASAHIABBARCiBwwBCyADKAIYIgZBgICAgHhHDQkLDBcLIANBGGogCCABQQAQeyADKAIcIQcCQAJAAkAgCUH/////A0sNACAJQQJ0rSAUfiIUQiCIpw0AIAMoAiAiBSAUp08NAQsgAygCGCIARQ0BIAcgAEEBEKIHDAELIAMoAhgiBkGAgICAeEcNCQsMFgsgBEGAgICAeEYNDCAJQQJ0rSAVfiIUQiCIpw0WIBSnIgEgBUsNFCADQRhqIAggAUEBEHsgAygCHCEHAkAgAygCICIFIAFJBEAgAygCGCIARQ0BIAcgAEEBEKIHDAELIAMoAhgiBkGAgICAeEcNCQsMFQsgA0EYaiAIIAFBABDNAiADKAIcIQcCQAJAAkAgCUH/////A0sNACAJQQJ0rSAUfiIUQiCIpw0AIAMoAiAiBSAUp08NAQsgAygCGCIARQ0BIAcgAEEBEKIHDAELIAMoAhgiBkGAgICAeEcNCQsMFAsgBEGAgICAeEYNCiAJQQJ0rSAVfiIUQiCIpw0UIBSnIgEgBUsNEiADQRhqIAggAUEBEM0CIAMoAhwhByADKAIgIgUgAUkEQCADKAIYIgBFDRQgByAAQQEQogcMFAsgAygCGCIGQYCAgIB4Rg0TIARFDQkgCEEEaygCACIBQXhxIgIgBEECdCIEQQRBCCABQQNxIgEbakkNECABRSACIARBJ2pNcg0IDBELIARFDQggCEEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgBGpJDQ8gAUUgAiAEQSdqTXINBwwQCyAERQ0HIAhBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIARqSQ0OIAFFIAIgBEEnak1yDQYMDwsgBEUNBiAIQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyAEakkNDSABRSACIARBJ2pNcg0FDA4LIARFDQUgCEEEaygCACIBQXhxIgIgBEEBdCIEQQRBCCABQQNxIgEbakkNDCABRSACIARBJ2pNcg0EDA0LIARFDQQgCEEEaygCACIBQXhxIgIgBEEBdCIEQQRBCCABQQNxIgEbakkNCyABRSACIARBJ2pNcg0DDAwLIARFDQMgCEEEaygCACIBQXhxIgIgBEEBdCIEQQRBCCABQQNxIgEbakkNCiABRSACIARBJ2pNcg0CDAsLIARFDQIgCEEEaygCACIBQXhxIgIgBEEBdCIEQQRBCCABQQNxIgEbakkNCSABRSACIARBJ2pNcg0BDAoLIARFDQEgCEEEaygCACIBQXhxIgIgBEECdCIEQQRBCCABQQNxIgEbakkNCCABRQ0AIAIgBEEnaksNCQsgCBCiAgsgACAKNgIQIAAgCTYCDCAAIAU2AgggACAHNgIEIAAgBjYCAAwFC0EAIQsLQQIhAUGAgICAeCEEDAILQYCAgIB4IQQMAQsgAykDOCEUIAMpAzAhFSADKAIsIQkgAygCKCELCyADIBQ3AzggAyAVNwMwIAMgCTYCLCADIAs2AiggAyAFNgIkIAMgCDYCICADIAQ2AhwgAyABNgIYIwBB0ABrIgEkACABQQxqEOQIIAFByABqIANBGGoiAkEgaikCADcCACABQThqIAJBEGr9AAIA/QsCACABIAL9AAIA/QsCKEHIABBxIgJFBEAACyACQdC0xwA2AgAgAiABKQIMNwIEIAIgASkCJDcCHCACQQxqIAFBFGr9AAIA/QsCACACQSRqIAFBLGr9AAIA/QsCACACQTRqIAFBPGr9AAIA/QsCACACQcQAaiABQcwAaigCADYCACABQdAAaiQAIABBgICAgHg2AgAgACACNgIECyADQbDVAGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0EAIAEgBUGovMQAEOoHAAtBuLzEAEEvQei8xAAQqwcAC0GYvMQAEN0JAAvvXQMvfwV+BnsjAEHQAmsiByQAIAFBQGshDwJAAkACQAJAAkACQAJAAkAgAS0AYCIIDQAgB0G0AmogDxCOAiAHLQC0AiIIQR1GBEAgAS0AYCIIDQEMAwsMAQsgASAIQQFrIgs6AGAgASABKQNAIjdCAYgiNjcDQAJAAkACQAJAAkACQAJAAkACQCA3QgGDUARAQYCAgIB4IR4MAQsgCEEETQRAIAdBtAJqIA8QjgIgBy0AtAIiCEEdRw0KIAEtAGAiC0EESQ0LIA8pAwAhNgsgASALQQRrOgBgIAEgNkIEiDcDQCA2p0EPcSIfQQFrQQtPBEBBDSEIDAwLQQQgH3QiDRBxIghFDQMgCEEEay0AAEEDcUUgDUVyRQRAIAhBACAN/AsACyAIrUEBIB90Ih6tQiCGhCE3CyA3pyEnQQEhHEECIRpBASEvIARFDQECQAJAAkAgAS0AYCIIRQRAIAdBtAJqIA8QjgIgBy0AtAIiCEEdRw0BIAEtAGAiCEUNBAsgASAIQQFrIgQ6AGAgASABKQNAIjZCAYgiODcDQCA2QgGDUA0EIAhBA00EQCAHQbQCaiAPEI4CIActALQCIghBHUcNASABLQBgIgRBA0kNBCAPKQMAITgLIAEgBEEDazoAYCABIDhCA4g3A0BBfyA4p0EHcUECaiIddEF/cyIEIAJB//8DcWogHXYiLyAEIANB//8DcWogHXYiBGwiIEECdCESICAEQCASEHEiDUUNBiANQQRrLQAAQQNxRSASRXJFBEAgDUEAIBL8CwALIAdBtAJqIAEgLyAEQQAgDSASEDogBy0AtAIiCEEdRg0DIAcpArwCITcgBygCuAIhCiAHLwG2AiEOIActALUCIQkgDSASQQEQogcMCwsgB0G0AmogASAvIARBAEEBIBIQOiAHLQC0AiIIQR1GDQELIAcpArwCITcgBygCuAIhCiAHLwG2AiEOIActALUCIQkMCQtBACEgDAILICBBAXQQcSIaRQ0CAn8gEkEEayIEQSBJBEAgEiELIA0hCEEBDAELIA0gEmpBAmsgGksEQCASIQtBASANIgggGiAEQQF2akECakkNARoLIA0gBEECdkEBaiIEIARBA3EiBEEEIAQbayIZQQJ0aiEIICAgGWtBAnQhCyAaIQQgGSEKIA0hCf0MAQAAAAEAAAABAAAAAQAAACI+ITsDQCAEIAn9AAAAIj0gO/0NAAAEAAgADAAAAAAAAAAAAEEI/YsBID0gO/0NAQUJDQAAAAAAAAAAAAAAAP2JAf1QIj39WwEAACA7ID39qQEgPv2uAf25ASE7IARBCGohBCAJQRBqIQkgCkEEayIKDQALIDsgOyA7/Q0ICQoLDA0ODwABAgMAAQID/bkBIjsgOyA7/Q0EBQYHAAECAwABAgMAAQID/bkB/RsACyEcIBogGUEBdGohBANAIAQgCC8AACIKQQh0IApBCHZyIgo7AQAgHCAKQf//A3FBAWoiCSAJIBxJGyEcIAhBBGohCCAEQQJqIQQgGUEBaiEZIAtBBGsiCw0ACyANIBJBARCiBwwBC0EPIQgMBgsgN0IgiKchISAHQQA2AhggB0KAgICAwAA3AxBBASAfQQ9xdCExIAdBuAJqISIgB0G0AmoiBEEBciEsIAdBsgFqISMgB0GxAWohLSAHQbQBaiEkIARBAnIhJUEBIQhBBCESQQAhCwNAIAghNEEAIQ0gB0EAOwGUASAHQYCAgIB4NgKQASAHQQA7AXggB0GAgICAeDYCdCAHQQA7AVwgB0GAgICAeDYCWCAHQQA7AUAgB0GAgICAeDYCPCAHQQA7ASQgB0GAgICAeDYCIEEBIQgCQAJ/AkACQAJAA0AgDSEbIAghDSAbQQF0LwGAgEcCQCABLQBgIggNACAHQbQCaiAPEI4CAkAgBy0AtAIiCEEdRgRAIAEtAGAiCA0CQQ8hCAwBCyAHICUpAQA3A8gBIAcgJUEGaikBADcBzgEgBy0AtQIhAQsgIyAHKQPIATcBACAjQQZqIAcpAc4BNwEAIAcgAToAsQEgByAIOgCwAQwEC0EAIDFBACAeQYCAgIB4RxsgGxtqIRYgASAIQQFrIgg6AGAgASABKQNAIjZCAYgiNzcDQAJAAkACfwJAAkACQAJAAkACQAJAAkAgNkIBg1BFBEAgCEH/AXENBCAHQbQCaiAPEI4CIActALQCIghBHUcNASABLQBgIggNA0EPIQgMAgtBJhBxIgpFDRIgCkEEayIMLQAAQQNxBEAgCv0MAAAAAAAAAAAAAAAAAAAAACI7/QsAACAKQR5qQgA3AAAgCkEQaiA7/QsAAAsgAS0AYCIIQQNLDQYgB0G0AmogDxCOAiAHLQC0AiIIQR1HDQQgAS0AYCIIQQRPDQZBDyEIDAULIAcgJSkBADcD2AEgByAlQQZqKQEANwHeASAHLQC1AiEBCyAjIAcpA9gBNwEAICNBBmogBykB3gE3AQAgByABOgCxASAHIAg6ALABIAdBgYCAgHg2AqwBDAwLIA8pAwAhNwsgASAIQQFrIgg6AGAgASA3QgGIIjY3A0AgCEH/AXFFBEAgB0G0AmogDxCOAgJAAkAgBy0AtAIiCEEdRgRAIAEtAGAiCA0CQQ8hCAwBCyAHICUpAQA3A+gBIAcgJUEGaikBADcB7gEgBy0AtQIhAQsgIyAHKQPoATcBACAjQQZqIAcpAe4BNwEAIAcgAToAsQEgByAIOgCwASAHQYGAgIB4NgKsAQwMCyAPKQMAITYLIAEgCEEBayIIOgBgIAEgNkIBiDcDQAJAAkBBCEEBIDanQQFxGyIEIAhB/wFxSwRAIAdBtAJqIA8QjgIgBy0AtAIiCEEdRwRAIAdBgAJqICJBCGooAgA2AgAgByAiKQIANwP4ASAHLwG2AiEBIActALUCIQQMAgsgAS0AYCEICyAIQf8BcSAETw0BQQ8hCAsgJCAHKQP4ATcCACAkQQhqIAdBgAJqKAIANgIAIAcgATsBsgEgByAEOgCxASAHIAg6ALABIAdBgYCAgHg2AqwBDAsLIAEgCCAEayIJOgBgIAEgASkDQCI4IAStIjmIIjY3A0AgFkH//wNxIgogOEJ/IDmGQn+Fg6ciCE0EQAwKCyA3QgGDUA0DIAlB/wFxQQdNBEAgB0G0AmogDxCOAgJAAn8gBy0AtAIiBEEdRgRAIAEtAGAiCUEITw0CQQ8MAQsgB0GgAmogIkEIaigCADYCACAHICIpAgA3A5gCIAcvAbYCISggBy0AtQIhASAECyEIICQgBykDmAI3AgAgJEEIaiAHQaACaigCADYCACAHICg7AbIBIAcgAToAsQEgByAIOgCwASAHQYGAgIB4NgKsAQwMCyAPKQMAITYLIAEgCUEIazoAYCABIDZCCIg3A0AgCiA2p0H/AXEiKEsEQEEYEHEiBEUNDyAEQQI7ARAgBCAoOwEKIARBATsBCCAEIAg7AQIgBEEBOwEAQQgQcSIKRQ0PIAogKEGAgARyNgIEIAogCEGAgARyNgIAIAdBATsBxAEgB0ECNgLAASAHIAo2ArwBIAdCg4CAgCA3ArQBIAcgBDYCsAEgB0EDNgKsASAEIQhBAwwFCwwJCyAHQYYCaiAsQQJqLQAAOgAAIAcgLC8AADsBhAIgBygCuAIhASAHKQK8AiE3CyAtIAcvAYQCOwAAIC1BAmogB0GGAmotAAA6AAAgByAIOgCwASAHIDc3ArgBIAcgATYCtAEMBgsgASAIQQRrIgg6AGAgASABKQNAIjZCBIgiNzcDQCA2p0EPcUECdCEOQXAhBANAIAhB/wFxQQJNBEAgB0G0AmogDxCOAgJAAkAgBy0AtAIiCEEdRgRAIAEtAGAiCEEDTw0CQQ8hCAwBCyAHQZACaiAiQQhqKAIANgIAIAcgIikCADcDiAIgBy8BtgIhCSAHLQC1AiEBCyAkIAcpA4gCNwIAICRBCGogB0GQAmooAgA2AgAgByAJOwGyASAHIAE6ALEBIAcgCDoAsAEMCAsgDykDACE3CyABIAhBA2siCDoAYCABIDdCA4giNjcDQCAEQZT/xgBqKAIAIglBEk0EQCAKIAlBAXRqIDenQQdxIgk7AQAgNiE3IA4gBEEEaiIERg0EDAELCyAJQRNB0P/GABCMBwALIAcgCDsBsAEgB0GAgICAeDYCrAFBgICAgHgLIQwgBykCuAEhNyAHKAK0ASEKIAcvAbIBIQ4gBy0AsQEhCQwBCyAHQRM2AqACIAcgCjYCnAIgB0ETNgKYAiAHQbQCaiAHQZgCahCYASAHKALEAiETIAcoAsACIRggBygCvAIhDiAHKAK4AiEKAkAgBygCtAIiFEGBgICAeEYEQCAKIQggEyEVIBghBAwBCyAHKQLIAiE3AkACQCAIQf8BcUUEQCAHQbQCaiAPEI4CAkAgBy0AtAIiCEEdRgRAIAEtAGAiCA0BQQ8hCAwECwwCCyAPKQMAITYLIAEgCEEBayIJOgBgIAEgNkIBiCI4NwNAIBYhDCA2QgGDUEUEQAJAAkAgCEH/AXFBA00EQCAHQbQCaiAPEI4CIActALQCIghBHUcNBEEPIQggAS0AYCIJQQNJDQUgDykDACE4CyABIAlBA2siCToAYCABIDhCA4g3A0AgOKdBAXRBDnFBAmoiDCAJQf8BcU0NASAHQbQCaiAPEI4CIActALQCIghBHUYNAAwDCyABLQBgIQkLQQ8hCCAJQf8BcSAMSQ0CIAEgCSAMazoAYCABIAEpA0AiNiAMrSI4iDcDQCAWQQJrQf//A3EgNkJ/IDiGQn+Fg6ciCUH//wNxSQ0CIAlBAmohDAsgFkH//wNxIhUEfyAVQQF0IikQcSIQRQ0MIBBBBGsiMi0AAEEDcUUgKUVyRQRAIBBBACAp/AsACwJAIAxB//8DcUUNACA3QiCIITYgN6chLkEAIQhBCCEqAkADQAJAIAdBtAJqIA8QjgICQAJAAkACQAJAAn8gBy0AtAIiBEEdRwRAIActALcCQRh0IAcvALUCQQh0ciAEcgwBCyAKIQQgFEGAgICAeEYNAiAPKQMAIjcgNoOnQf//A3EiBCAuTw0DAkAgEyAEQQJ0aigCACIEQYCABE8EQCABLQBgIhEgBEEQdiIJQf8BcU8NA0EPIQkgBy8BtgIhBAwBCyAHQbQCaiAKIA4gN6dBCnZBP3EgBEEBayAPEJwGIAcvAbYCIQQgBy0AtAIiCUEdRg0DCyAHLQC1AkEIdCAJciAEQRB0cgshCCAHKALAAiEVIAcoArwCIQQgBygCuAIhDgwHCyABIBEgCWs6AGAgASA3IAmtiDcDQAsCQCAEQf//A3EiEUEQTwRAIARBEGsiJkH//wNxQQNJDQEMBQsgECAIQf//A3FBAXRqIAQ7AQAgBCAqIBEbISogCEEBaiEIDAMLIAEtAGAiCUGChhwgJkEDdEH4/wNxdiIEQQdxSQRAIAdBtAJqIA8QjgIgBy0AtAIiCUEdRwRAIActALUCQQh0IAlyIQggBygCwAIhFSAHKAK8AiEEIAcoArgCIQ4gBy8BtgIhKwwDCyABLQBgIQkLIAlB/wFxIARB/wFxSQRAQQ8hCAwCCyABIAkgBGs6AGAgASABKQNAIjcgBK1CB4MiOIg3A0AgFkH//wNxIgRCg4CMgLABICZBBHStQvD/A4OIpyI1IDdCfyA4hkJ/hYOnIitqIgkgCGpB//8DcUkNAyAqQQAgEUEQRhshJiAIQf//A3EiCCAEIAQgCEkbIjAgCGsiBCArIDVqQQFrQf//A3EiESAEIBFJGyIEQQhPBEAgBEEBaiIRQQdxIhdBCCAXGyIXIARBf3NqIQQgCSARIBdrIhFrIQkgCCARaiAQIAhBAXRqIQggJv0QITsDQCAIIDv9CwEAIAhBEGohCCAEQQhqIgQNAAshCAsgECAIQQF0aiEEA0AgCCAwRwRAIAQgJjsBACAEQQJqIQQgCEEBaiEIIAlBAWsiCUH//wNxDQEMBAsLIDAgFUGMgscAEIwHAAsgBCAuQdj5xgAQjAcACyArQRB0IAhyIQgMAwsgCEH//wNxIBZB//8DcU8NAyAMQQFrIgxB//8DcQ0BDAMLC0EPIQgLAkAgMigCACIJQXhxIgxBBEEIIAlBA3EiCRsgKWpPBEAgCUEAIAwgKUEnaksbDQEgEBCiAgwFCwwYCwwYCyAQBUECCyEEQR0hCAJAAkAgFEGAgICAeEYNACAUBEAgCkEEaygCACIJQXhxIgwgFEEDdCIOQQRBCCAJQQNxIgkbakkNGCAJQQAgDCAOQSdqSxsNGSAKEKICCyAYRQ0AIBNBBGsoAgAiCkF4cSIJIBhBAnQiDEEEQQggCkEDcSIKG2pJDRcgCkEAIAkgDEEnaksbDQEgExCiAgsgFSEODAMLDBYLIActALUCQQh0IAhyIAcvAbYCQRB0ciEIIAcoAsACIRUgBygCvAIhBCAHKAK4AiEOCyAUQYCAgIB4Rg0AAkAgFARAIApBBGsoAgAiCUF4cSIMIBRBA3QiEEEEQQggCUEDcSIJG2pJDRUgCUEAIAwgEEEnaksbDRYgChCiAgsgGEUNASATQQRrKAIAIgpBeHEiCSAYQQJ0IgxBBEEIIApBA3EiChtqSQ0UIApBACAJIAxBJ2pLGw0AIBMQogIMAQsMFAsgCEH/AXFBHUcEQCAHQbMBaiAIQRh2OgAAIAcgFTYCvAEgByAENgK4ASAHIA42ArQBIAcgCDoAsAEgB0GBgICAeDYCrAEgByAIQQh2OwCxAQwFCyAHIBU2ArACIAcgBDYCrAIgByAONgKoAiAHQawBaiAHQagCahCYASAHLQCwASEIIAcpArgBITcgBy8BsgEhDiAHLQCxASEJIAcoArQBIgogBygCrAEiDEGBgICAeEYNBRoLIAcpAsABITYCQAJAIAdBIGogG0EcbGoiBCgCACIQQYCAgIB4Rg0AIBAEQCAEKAIEIhZBBGsoAgAiE0F4cSIYIBBBA3QiEEEEQQggE0EDcSITG2pJDQIgE0EAIBggEEEnaksbDRUgFhCiAgsgBCgCDCIQRQ0AIAQoAhAiFkEEaygCACITQXhxIhggEEECdCIQQQRBCCATQQNxIhMbakkNEyATQQAgGCAQQSdqSxsNFCAWEKICCyAEIDY3AhQgBCA3NwIMIAQgCjYCCCAEIA47AQYgBCAJOgAFIAQgCDoABCAEIAw2AgAgDSANQQVJIgRqIQggBEUNBgwBCwsMEAsCQCAMKAIAIgFBeHEiAkEqQS4gAUEDcSIBG08EQCABQQAgAkHOAE8bDQEgChCiAgwDCwwQC0GMjcgAQS5BvI3IABDrBwwFCyAHQYGAgIB4NgKsAUEPIQggB0EPOgCwAQsgBykCuAEhNyAHLwGyASEOIActALEBIQkgBygCtAELIQogB0EgahCNAiALBEAgEiEBA0AgARCNAiABQYwBaiEBIAtBAWsiCw0ACwsCQCAHKAIQIgEEQCASQQRrKAIAIgJBeHEiAyABQYwBbCIBQQRBCCACQQNxIgIbakkNDiACQQAgAyABQSdqSxsNDyASEKICCyAgRQ0IIBpBBGsoAgAiAUF4cSICICBBAXQiA0EEQQggAUEDcSIBG2pJDQ0gAUEAIAIgA0EnaksbDQAgGhCiAgwICwwNCyAHKAIQIAtGBEAgB0EQahCfBiAHKAIUIRILIBIgC0GMAWxqIAdBIGpBjAH8CgAAIAcgC0EBaiILNgIYIDRBAWohCCALIBxHDQALIAcpAxAhNyAHKAIQITACQAJ/IB1FBEBBACEIIDdCIIinDAELIBlFDQEgGi8BACIIIBxPDQYgN0IgiKcLIQQCQAJAAkACQCACQf//A3EiFiADQf//A3FsIhVFDQBBfyAddEF/c0H//wMgHRshNSAGQRBrIRMgBq1CAXwhN0EAIB9rQR9xIRggAkEBa0H//wNxITEgBCAIQYwBbGohDEEAIQ1BACEQA0ACQCACQf//A3FFBEAgB0G0AmogDxCOAiAHLQC0AiIIQR1HDQkgDSAQSQ0BQdj7xgAQgggACwJAA0AgB0G0AmogDxCOAiAHLQC0AiIIQR1HDQogDSAQSQ0CIA0gDSAWbiIEIBZsIghrIQMCQCAdRQRAQQAhCwwBCyAZIC8gBEH//wNxIB12bCADQf//A3EgHXZqIgRLBEAgGiAEQQF0ai8BACILIBxJDQEgCyAcQej7xgAQjAcACyAEIBlByPLEABCMBwALIAggAyA1ciIDIDEgAyAxSRtqQQFqIRAgEiALQYwBbGoiDCgCAEGAgICAeEcNAiAMKAIcQYCAgIB4Rw0CIAwoAjhBgICAgHhHDQIgDCgCVEGAgICAeEcNAiAMLwEEIgNBgAJPDQIgDC0AWCEEIAwtADwhCCAMLQAgIQsCQCAQIA1rIBUgHRsiGwRAQQAhCkEBIQ4CQCA3IA1BAnQiCa19IjZCACA2IDdYG0IDfEICiCI2IAZBACAJIAZrQQNqIhEgEUEDSyIUG2ogCWtBAnatIjggNiA4VBsiOSAbQQFrrSI4IDggOVYbIjlCIFQNACANIDYgBkEAIBEgFBtqIAlrQQJ2rSI6IDYgOlQbIjYgOCA2IDhUG6dqQQJ0IAlJDQAgOaciCkF/cyAKQQFqIgpBD3EiCUEQIAkbIglqITIgCiAJayIKQQFqIQ4gDf0RITv9DAwAAAANAAAADgAAAA8AAAAhPv0MCAAAAAkAAAAKAAAACwAAACE9/QwEAAAABQAAAAYAAAAHAAAAIT/9DAAAAAABAAAAAgAAAAMAAAAhQANAIAUgQCA7/a4BQQL9qwEiPP0bAGoiCSALOgAAIAUgPP0bAWoiESALOgAAIAUgPP0bAmoiFCALOgAAIAUgPP0bA2oiHyALOgAAIAUgPyA7/a4BQQL9qwEiPP0bAGoiIiALOgAAIAUgPP0bAWoiIyALOgAAIAUgPP0bAmoiJCALOgAAIAUgPP0bA2oiJSALOgAAIAUgPSA7/a4BQQL9qwEiPP0bAGoiKCALOgAAIAUgPP0bAWoiKSALOgAAIAUgPP0bAmoiKiALOgAAIAUgPP0bA2oiKyALOgAAIAUgPiA7/a4BQQL9qwEiPP0bAGoiLCALOgAAIAUgPP0bAWoiLSALOgAAIAUgPP0bAmoiLiALOgAAIAUgPP0bA2oiJiALOgAAIAkgAzoAASARIAM6AAEgFCADOgABIB8gAzoAASAiIAM6AAEgIyADOgABICQgAzoAASAlIAM6AAEgKCADOgABICkgAzoAASAqIAM6AAEgKyADOgABICwgAzoAASAtIAM6AAEgLiADOgABICYgAzoAASAJIAg6AAIgESAIOgACIBQgCDoAAiAfIAg6AAIgIiAIOgACICMgCDoAAiAkIAg6AAIgJSAIOgACICggCDoAAiApIAg6AAIgKiAIOgACICsgCDoAAiAsIAg6AAIgLSAIOgACIC4gCDoAAiAmIAg6AAIgCSAEOgADIBEgBDoAAyAUIAQ6AAMgHyAEOgADICIgBDoAAyAjIAQ6AAMgJCAEOgADICUgBDoAAyAoIAQ6AAMgKSAEOgADICogBDoAAyArIAQ6AAMgLCAEOgADIC0gBDoAAyAuIAQ6AAMgJiAEOgADIED9DBAAAAAQAAAAEAAAABAAAAAiPP2uASFAID8gPP2uASE/ID0gPP2uASE9ID4gPP2uASE+IDJBEGoiMg0ACwsgG0EBaiEJA0AgBiAKIA1qQQJ0IgpJDQIgBiAKayIRQQNNBEBBAEEEIBFB1P7GABDqBwALIAUgCmoiCiAEOgADIAogCDoAAiAKIAM6AAEgCiALOgAAIAkgDiIKQQFqIg5HDQALCyAeQYCAgIB4RwRAIANBCHRBgP4DcSALQRB0ciAEQRh0ciAIckG9z9bxAWwgGHYiCiAhTw0DICcgCkECdGoiCiAEOgADIAogCDoAAiAKIAM6AAEgCiALOgAACyANIBtqIg0gFUkNAQwFCwsgCiAGIAZB5P7GABDqBwALIAogIUGY+sYAEIwHAAsCQCAVAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDCgCAEGAgICAeEcEQCAMKAIUIgQgDykDACI2pyILIAwvARhxIgNNDSQCQCAMKAIQIANBAnRqKAIAIghBgIAETwRAIAEtAGAiBCAIQRB2IgNB/wFxSQRAQQ8hBCAHLwG2AiEIDAILIAEgBCADazoAYCABIDYgA62INwNADAMLIAdBtAJqIAwoAgQgDCgCCCALQYD4A3FBCnYgCEEBayAPEJwGIAcvAbYCIQggBy0AtAIiBEEdRg0CCyAAIAcpArgCNwIEIABBDGogB0HAAmooAgA2AgAgBy0AtQIhASAAIAg7AQIgACABOgABIAAgBDoAAAwaCyAMLwEEIQgLAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAhB//8DcSIDQYACTwRAIANBmAJJDQEgB0EPOgC0AiAeQYCAgIB4Rw0CIABBADYCBCAAQQ86AAAMJgsgDCgCHEGAgICAeEYNCiAMKAIwIgQgDykDACI2pyIKIAwvATRxIgNNDS4gDCgCLCADQQJ0aigCACILQYCABEkNCCABLQBgIgQgC0EQdiIDQf8BcUkEQEEPIQQgBy8BtgIhCwwKCyABIAQgA2s6AGAgASA2IAOtiDcDQAwLCyAIQfwDcUGAAkYEfyAIQf8Ba0H//wNxBSABLQBgIgQgCEH+AWpB/v8DcUEBdiIDQf8BcSILSQ0CIAEgBCADazoAYCABIAEpA0AiNiADrUL/AYMiOIg3A0AgNkJ/IDiGQn+Fg6cgCEEBcUECciALdGpBAWoLIRcgDCgCcEGAgICAeEYNBSAMKAKEASIEIA8pAwAiNqciCyAMLwGIAXEiA00NLSAMKAKAASADQQJ0aigCACIIQYCABEkNAyABLQBgIgQgCEEQdiIDQf8BcU8NAkEPIQQgBy8BtgIhCAwECyAHQbQCahCrBCAhIAhBmAJrQf//A3EiBE0NCiAGIA1BAnQiA0kNCyAGIANrIghBA00NDCADIAVqICcgBEECdGooAAA2AAAgECANQQFqIgNNBEAgAwwZCyAPKQMAITYgDCgCAEGAgICAeEYNDQJAIAwoAhQiCCAMLwEYIDancSIESwRAIAwoAhAgBEECdGooAgAiBEGAgARPDQEgAwwaCyAEIAhByPnGABCMBwALIARBEHYhCwwXCyAAIBc2AgQgAEEPOgAADCELIAEgBCADazoAYCABIDYgA62INwNADAMLIAdBtAJqIAwoAnQgDCgCeCALQYD4A3FBCnYgCEEBayAPEJwGIAcvAbYCIQggBy0AtAIiBEEdRg0CCyAAIAcpArgCNwIEIABBDGogB0HAAmooAgA2AgAgBy0AtQIhASAAIAg7AQIgACABOgABIAAgBDoAAAweCyAMLwF0IQgLIAhB//8DcUEESQ0IIAhBAmsiA0H//wNxQf8DSw0JIAEtAGAiBCADQQF2IgNB/wFxSQRAIAAgMzYCBCAAQQ86AAAMHQsgASAEIANB//8BcSIDazoAYCABIAEpA0AiNiADrSI4iDcDQCA2Qn8gOIZCf4WDpyAIQQFxQQJyIAN0akEBaiIzQfgATQ0PIDNB+ABrIQsMEAsgB0G0AmogDCgCICAMKAIkIApBgPgDcUEKdiALQQFrIA8QnAYgBy8BtgIhCyAHLQC0AiIEQR1GDQILIAAgBykCuAI3AgQgAEEMaiAHQcACaigCADYCACAHLQC1AiEBIAAgCzsBAiAAIAE6AAEgACAEOgAADBoLIAwtACAhCwsCQAJ/IAwoAjhBgICAgHhHBEAgDCgCTCIEIA8pAwAiNqciCiAMLwFQcSIDTQ0lAkAgDCgCSCADQQJ0aigCACIJQYCABE8EQCABLQBgIgQgCUEQdiIDQf8BcUkEQEEPIQQgBy8BtgIhCQwCCyABIAQgA2siBDoAYCABIDYgA62INwNADAQLIAdBtAJqIAwoAjwgDCgCQCAKQYD4A3FBCnYgCUEBayAPEJwGIAcvAbYCIgkgBy0AtAIiBEEdRg0CGgsgACAHKQK4AjcCBCAAQQxqIAdBwAJqKAIANgIAIActALUCIQEgACAJOwECIAAgAToAASAAIAQ6AAAMGwsgDC0APAshCSABLQBgIQQLAkAgBEH/AXFBDksNACAHQbQCaiAPEI4CIActALQCIgNBHUYNACAAIAcpALUCNwABIABBCGogB0G8AmopAAA3AAAgACADOgAADBkLAkAgDCgCVEGAgICAeEcEQCAMKAJoIgQgDykDACI2pyIOIAwvAWxxIgNNDSQCQCAMKAJkIANBAnRqKAIAIgpBgIAETwRAIAEtAGAiBCAKQRB2IgNB/wFxSQRAQQ8hBCAHLwG2AiEKDAILIAEgBCADazoAYCABIDYgA62INwNADAMLIAdBtAJqIAwoAlggDCgCXCAOQYD4A3FBCnYgCkEBayAPEJwGIAcvAbYCIQogBy0AtAIiBEEdRg0CCyAAIAcpArgCNwIEIABBDGogB0HAAmooAgA2AgAgBy0AtQIhASAAIAo7AQIgACABOgABIAAgBDoAAAwaCyAMLQBYIQoLIA1BAnQiAyAGTw0GIAMgBWogCzoAACADQQFyIgQgBk8NByAEIAVqIAg6AAAgA0ECciIEIAZPDQggBCAFaiAJOgAAIANBA3IiAyAGTw0JIAMgBWogCjoAACAeQYCAgIB4RwRAIAlB/wFxIAhBCHRBgP4DcSALQRB0ckGA/v8HcSAKQRh0cnJBvc/W8QFsIBh2IgMgIU8NCyAnIANBAnRqIgMgCjoAAyADIAk6AAIgAyAIOgABIAMgCzoAAAsgDUEBagwOCyAEICFB+PvGABCMBwALIAMgBiAGQbj8xgAQ6gcAC0EAQQQgCEGI/MYAEOoHAAsgDC8BBCEEQQAhCwwJCyAIQQFqQf//A3EhMwwGC0HY5sgAQSsgB0G0AmpBmPvGAEH0/sYAEOAGAAsgAyAGQZT+xgAQjAcACyAEIAZBpP7GABCMBwALIAQgBkG0/sYAEIwHAAsgAyAGQcT+xgAQjAcACyADICFBmPrGABCMBwALIDNBAWsiA0H4AEkEQEEBIANBAXQiAywAi4BHIBZsIAMsAIqAR2oiAyADQQFMGyELDAELQX9B+ABB/IHHABCMBwALAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgFSANayAXSSALIA1LckUEQCALQQFGBEAgBiANQQJ0IgNBBGsiBEkNAiAGIARrIghBA00NAyAEIAVqKAAAIQtBACEEAkAgF0EBa60iNiA3IAOtfSI4QgAgNyA4WhtCA3xCAogiOCAGIANrQQJ2Ig6tIjkgOCA5VBsiOCA2IDhUGyI2QhRUBEBBASEIDAELQQEhCCANIDanIgpqQQJ0IANJDQAgCkEBaiIEQQNxIghBBCAIGyIIIApBf3NqIQogAyAFaiEJIAQgCGsiBEEBaiEIIAv9ESE7A0AgCSA7/QsAACAJQRBqIQkgCkEEaiIKDQALCyAOQQFqIQogF0EBaiEJA0AgBiAEIA1qQQJ0IgNJDQUgCCAKRg0GIAMgBWogCzYAACAJIAgiBEEBaiIIRw0ACwwRCyANIBdqQQNqIBVLDQsgDSALa0ECdCIEQRBqIgMgBksNBSAEQW9LDQYgDUECdCIIIBNLDQcgBSAIaiAEIAVq/QAAAP0LAAAgF0EETSALQQRPcQ0MIAtBAnQiCkUNCCAXQQJ0IgMgA0H8/wNxQRAgCiAKQRBPGyIDQf//A3FuIgsgA2xrQf//A3FBAEcgC2oiC0ECSQ0MIAMgBGoiCUEQaiIOIAZLDQkgCUFvSw0KIBMgAyAIak8EQCALQQJrIQsgA0EBdCAKayEOIAMgBWohCSAFIAMgCmtqIQogAyEEA0AgCCAJaiAIIApq/QAAAP0LAAAgC0UNDgJAIAYgCCAOaiIbQRBqTwRAIBtBb00NASANQQJ0IA5qIglBEGohDgwOCyANQQJ0IA5qQRBqIQ4MDAsgC0EBayELIAMgDmohDiADIAlqIQkgAyAKaiEKIAggAyAEaiIEaiATTQ0ACwsgB0EANgLEAiAHQQE2ArgCIAdB1JzIADYCtAIgB0IENwK8AiAHQbQCakGE/sYAEI0IAAsgAEEPOgAADBsLIAQgBiAGQfj8xgAQ6gcAC0EAQQQgCEHI/MYAEOoHAAsgAyAGIAZB6PzGABDqBwALQQBBBCAGIANrQdj8xgAQ6gcAC0EAIAMgBkGo/cYAEOoHAAsgBCADIAZBqP3GABDqBwALIAdBADYCxAIgB0EBNgK4AiAHQdScyAA2ArQCIAdCBDcCvAIgB0G0AmpBqP3GABCNCAALQbj9xgBBG0HU/cYAEOsHAAtBACAOIAZBhP7GABDqBwALIAkgDiAGQYT+xgAQ6gcAC0EAIQQCQCAXQQJ0IhFBAWsiCCAGIA1BAnQiAyALQQJ0IgprIgsgBiALSxsgCmogA2siCyAGIANrIglBACAGIAlPGyIJIAkgC0sbIgsgCCALSRsiC0EBaiIbQRFJBEBBASEIDAELQQEhCCAKQQ9NDQAgG0EPcSIEQRAgBBsiBCALQX9zaiEOIAMgBWohC0EAIAprIRQgGyAEayIEQQFqIQgDQCALIAsgFGr9AAAA/QsAACALQRBqIQsgDkEQaiIODQALCyAJQQFqIQkgEUEBaiEOA0AgAyAEaiIEIAprIgsgBk8NAiAIIAlGDQMgBCAFaiAFIAtqLQAAOgAAIA4gCCIEQQFqIghHDQALCyAeQYCAgIB4Rw0CDAMLIAsgBkGI/cYAEIwHAAsgBCAGQZj9xgAQjAcACwJAAkAgDUECdCIDIAZNBEAgF0ECdCIEIAYgA2siCEsNASAERQ0DIAMgBWohC0EAIARrIQkDQCALKAAAIgNBgP6DeHEgA0EQdEGAgPwHcXIgA0EQdiIIQf8BcXJBvc/W8QFsIBh2IgQgIU8NAyAnIARBAnRqIgQgA0EYdjoAAyAEIAg6AAIgBCADQQh2OgABIAQgAzoAACALQQRqIQsgCUEEaiIJDQALDAMLIAMgBiAGQfT9xgAQ6gcAC0EAIAQgCEHk/cYAEOoHAAsgBCAhQZj6xgAQjAcACyANIBdqDAELIAMgBEH//wNxQZgCSQ0AGiABLQBgIgggC0H/AXFJDQQgASAIIAtrOgBgIAEgNiALrYg3A0AgBiADQQJ0IgNJDQUgBiADayIIQQNNDQYgISAEQZgCa0H//wNxIgRNDQEgAyAFaiAnIARBAnRqKAAANgAAIA1BAmoLIg1LDQEMAgsLIAQgIUH4+8YAEIwHAAsgAEEdOgAADAYLIABBDzoAAAwFCyADIAYgBkGo/MYAEOoHAAtBAEEEIAhBmPzGABDqBwALQQBBAEHI8sQAEIwHAAsACyAAIAcpALUCNwABIABBCGogB0G8AmopAAA3AAAgACAIOgAACyAeQYCAgIB4ckGAgICAeEYNACAnIB5BAnRBARCiBwsgIARAIBogIEEBdEECEKIHCyASIQEDQCABEI0CIAFBjAFqIQEgNEEBayI0DQALIDBFDQUgEiAwQYwBbEEEEKIHDAULIAggHEHI+8YAEIwHAAsCQCAeQYCAgIB4ckGAgICAeEcEQCAnQQRrKAIAIgFBeHEiAiAeQQJ0IgNBBEEIIAFBA3EiARtqSQ0GIAFBACACIANBJ2pLGw0BICcQogILIAAgNzcCCCAAIAo2AgQgACAOOwECIAAgCToAASAAIAg6AAAMBAsMBQsgByAHKQC3AjcDACAHIAdBvAJqKQAANwAFIActALYCIQEgBy0AtQIhHwwBC0EPIQgLIAAgAToAAiAAIB86AAEgACAIOgAAIAAgBykDADcAAyAAQQhqIAcpAAU3AAALIAdB0AJqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgAyAEQdj5xgAQjAcAC4xaBC5/B30BewF+IwBBkARrIgYkAEEAELYJIQdBABC2CSEJIAZBwANqQQA6AAAgBkIANwO4AyACELgKIQwgAxC4CiEWIAdBhAhPBEAgBxCbBwsgCUGECE8EQCAJEJsHCyACrSADrUIghoQhPAJAIARBAXFFDQAgBUH458AAQQMQ7AgiAhDiCCEHQbS7yQAtAAAhA0G0u8kAQQA6AABBuLvJACgCAEG4u8kAQQA2AgAgByADGyEIAkACQCADRQRAIAgQuQpFBEBBASEQDAMLIAhBgwhLDQEMAgsgCEGECEkNAQsgCBCbBwsgAkGECE8EQCACEJsHCyAFQfvnwABBAxDsCCICEOIIIQdBtLvJAC0AACEDQbS7yQBBADoAAEG4u8kAKAIAQbi7yQBBADYCACAHIAMbIQkCfwJAAkAgA0UEQCAJELkKRQRAQQEhDkECDAQLIAlBgwhLDQEMAgsgECAJQYQISQ0CGgsgCRCbBwsgEAshHyACQYQITwRAIAIQmwcLIAVB/ufAAEEEEOwIIgMQ4gghAkG0u8kALQAAIQdBtLvJAEEAOgAAQbi7yQAoAgBBuLvJAEEANgIAIAIgBxshAgJAAkAgB0UEQCACELkKRQRAQQMhH0EBIQsMAwsgAkGDCEsNAQwCCyACQYQISQ0BCyACEJsHCyADQYQITwRAIAMQmwcLIAVBgujAAEEEEOwIIgcQ4gghA0G0u8kALQAAIQ9BtLvJAEEAOgAAQbi7yQAoAgBBuLvJAEEANgIAIAMgDxshAwJAAkAgD0UEQCADELkKRQRAQQMhH0EBISAMAwsgA0GDCEsNAQwCCyADQYQISQ0BCyADEJsHCyAHQYQITwRAIAcQmwcLIAVBhujAAEEHEOwIIg8Q4gghB0G0u8kALQAAIQ1BtLvJAEEAOgAAQbi7yQAoAgBBuLvJAEEANgIAIAcgDRshBwJAAkAgDUUEQCAHELkKRQRAQQEhLAwDCyAHQYMISw0BDAILIAdBhAhJDQELIAcQmwcLIA9BhAhJDQAgDxCbBwsgBkHMAWogBkHAA2otAAA6AAAgBiAGKQO4AzcCxAEgBiA8NwK8ASAGIB82ArgBIAYgATYCtAEgBkGAgICAeDYCpAEgBkGAgICAeDYCmAEgBkIENwKQASAGQgA3AogBIAZCgICAgMAANwKAASAGQgQ3AnggBkIANwJwIAZCgICAgMAANwJoIAZCBDcCYCAGQgA3AlggBkKAgICAwAA3AlAgBiAHNgJMIAYgLDYCSCAGQQA2AjwgBkEANgI0IAZBADYCLCAGIAM2AiggBiAgNgIkIAYgAjYCICAGIAs2AhwgBiAJNgIYIAYgDjYCFCAGIAg2AhAgBiAQNgIMIAYgFiAMIAwgFksbQQJ2NgKwASAGQoCAgIAgNwKwAiAGQgI3AqgCIAZCADcCoAIgBkKAgICAIDcCmAIgBkIENwKQAiAGQgA3AogCIAZCgICAgMAANwKAAiAGQgA3ArgCIAYgLDoAwAMgBiAfNgK8AyAGIAE2ArgDIAZBgAJqIAZBuANqEIQCIAZBADYCyAIgBkKAgICAwAA3AsACIAZBADYC1AIgBkKAgICAwAA3AswCIAZBADYC4AIgBkKAgICAwAA3AtgCIAZBADYC7AIgBkKAgICAwAA3AuQCIAZBADYC+AIgBkKAgICAwAA3AvACIAZBADYChAMgBkKAgICAwAA3AvwCIAZBADYCkAMgBkKAgICAwAA3AogDIAZBADYCnAMgBkKAgICAwAA3ApQDIAZBADYCqAMgBkKAgICAIDcCoAMgBkEANgK0AyAGQoCAgIDAADcCrAMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABRQRAQQQhFkEEISBBBCEOQQQhKEEEISkMAQsgBkHEAWohISAGQYABaiEtQQQhFgNAIBdBgIAEIAEgFWsiAiACQYCABE8bIgxBA2wiEkkEQCASIBdrIgIgBigCwAIgF2tLBEAgBkHAAmogFyACQQRBBBCkBSAGKALIAiEXIAYoAsQCIRYLIBYgF0ECdGohAyACQQJPBH8gAkECdEEEayIHBEAgA0EAIAf8CwALIAIgF2oiAkEBayEXIBYgAkECdGpBBGsFIAMLQQA2AgAgBiAXQQFqIhc2AsgCIAYoAtQCIRgLIAwgGEsEQCAMIBhrIgIgBigCzAIgGGtLBEAgBkHMAmogGCACQQRBBBCkBSAGKALUAiEYCyAGKALQAiIHIBhBAnRqIQMgAkECTwR/IAJBAnRBBGsiCQRAIANBACAJ/AsACyACIBhqIgJBAWshGCAHIAJBAnRqQQRrBSADC0EANgIAIAYgGEEBaiIYNgLUAgsgBigC4AIiDiASSQRAIBIgDmsiAiAGKALYAiAOa0sEQCAGQdgCaiAOIAJBBEEEEKQFIAYoAuACIQ4LIAYoAtwCIgcgDkECdGohAyACQQJPBH8gAkECdEEEayIJBEAgA0EAIAn8CwALIAIgDmoiAkEBayEOIAcgAkECdGpBBGsFIAMLQQA2AgAgBiAOQQFqIg42AuACCyAGKALsAiIRIBJJBEAgEiARayICIAYoAuQCIBFrSwRAIAZB5AJqIBEgAkEEQQQQpAUgBigC7AIhEQsgBigC6AIiByARQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgkEQCADQQAgCfwLAAsgAiARaiICQQFrIREgByACQQJ0akEEawUgAwtBADYCACAGIBFBAWoiETYC7AILIAxBAnQiCSAGKAL4AiITSwRAIAkgE2siAiAGKALwAiATa0sEQCAGQfACaiATIAJBBEEEEKQFIAYoAvgCIRMLIAYoAvQCIgcgE0ECdGohAyACQQJPBH8gAkECdEEEayIIBEAgA0EAIAj8CwALIAIgE2oiAkEBayETIAcgAkECdGpBBGsFIAMLQQA2AgAgBiATQQFqIhM2AvgCCwJAAkAgEiAXTQRAIAYoAsQCIRYgBkEMaiAVIAwQ6QQgDEEEdCEiQQIgEiASQQJNG0EDbkEEdCEPQQAhCCAGKAKEASENIAYoAogBIRAgFiECQQAhB0EAIQMCQAJAAkADQCAHQQRqIgsgEEsNAyADICJGDQIgAyANaiIHQQhqKgIAITQgByoCACE1IAJBBGogB0EEaioCADgCACACIDU4AgAgAyAPRg0BIAJBCGogNDgCACACQQxqIQIgCEEDaiEIIAshByAiIANBEGoiA0cNAAsgDCAYTQRAIAYoAtACISkgBkEMaiAVIAwQ6QQgDEECdCEmIAYoAoQBQQxqIQdBACEDIAYoAogBIRACQANAAn8CQCAQIANBBGoiAk8EQCAHKAIAIgtB//8BcUUEQCALQRB0DAMLIAtB/wdxIQggC0GAgAJxIQ8gC0GA+AFxIgtBgPgBRgRAIA9BEHQiC0GAgID8B3IgCEUNAxogCyAIQQ10ckGAgID+B3IMAwsgD0EQdCEPIAtFDQEgC0ENdEGAgID8AHEgCEENdHJBgICAwANqIA9yDAILIAMgAiAQQfClwQAQ6gcACyAPQYCAgNgDciAIZ0EQayILQRd0ayAIIAtB//8DcUEIanRB////A3FyCyEIIAMgJkYNASADIClqIAg2AgAgB0EQaiEHIAIiAyAmRw0ACyAOIBJPBEAgBigC3AIhKCAGQQxqIBUgDBDpBCAMQQxsIQ9BACELIAYoApABIQggBigClAEhDUEAIQNBACEQAkACQAJAAkACQAJAAkACQAJAAkADQAJ/AkAgDSADQQRqIgJPBEAgCCgCACIDQRB2IQcgA0EQdCADQf//AXFFDQIaIANB/wdxIQ4gA0GAgAJxIQogA0GA+AFxIhRBgPgBRgRAIApBEHQiCkGAgID8B3IgDkUNAxogCiAOQQ10ckGAgID+B3IMAwsgCkEQdCEKIBRFDQEgFEENdEGAgID8AHEgDkENdHJBgICAwANqIApyDAILIAMgAiANQfCmwQAQ6gcACyAOIA5nQRBrIg5B//8DcUEIanRB////A3EgCkGAgIDYA3IgDkEXdGtyCyEZIAhBBGooAgAhDgJ/IAdB//8BcQRAIAdB/wdxIQMgB0GAgAJxIQogB0GA+AFxIhRBgPgBRwRAIApBEHQiByAUQQ10QYCAgPwAcSADQQ10ckGAgIDAA2pyIBQNAhogAyADZ0EQayIDQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIANBF3RrcgwCCyAHQQ10IApBEHQiB3JBgICA/gdyIAMNARogB0GAgID8B3IMAQsgA0GAgHxxCyEKAn8gDkH//wFxBEAgDkH/B3EhAyAOQYCAAnEhByAOQYD4AXEiDkGA+AFHBEAgB0EQdCIHIA5BDXRBgICA/ABxIANBDXRyQYCAgMADanIgDg0CGiADIANnQRBrIgNB//8DcUEIanRB////A3EgB0GAgIDYA3IgA0EXdGtyDAILIAdBEHQiByADQQ10ckGAgID+B3IgAw0BGiAHQYCAgPwHcgwBCyAOQRB0CyEHIA8gEEYNASAQIChqIgMgGTYCACADQQhqIAc2AgAgA0EEaiAKNgIAIAtBA2ohCyAIQRBqIQggAiEDIA8gEEEMaiIQRw0ACyARIBJJDQEgBigC6AIhDiAGQQxqIBUgDBDpBEEAIQggBigCkAEhByAGKAKUASEQIA4hA0EAIQIDQCAIQQRqIgsgEEsNAyAGQbgDaiAHEJYDIAIgEkYNBCADIAYqArgDOAIAIANBBGogBikCvAM3AgAgA0EMaiEDIAdBEGohByALIQggEiACQQNqIgJHDQALIAkgE0sNBCAGKAL0AiEgIAZBDGogFSAMEOkEIAYoApABQQxqIQtBACECIAYoApQBIQhBACEDA0AgAkEEaiIHIAhLDQYgAyAiRg0HQwAAgD8gAyALaigCACICQQp2/REgAv0cAf0M/wMAAP8DAAD/AwAA/wMAAP1O/fsB/QwAwH9EAMB/RADAf0QAwH9E/ecBIjsgO/3kAf0MAACAvwAAgL8AAIC/AACAv/3kASI7/R8BIjaLkyA7/R8AIjiLkyI0jEMAAAAAEOAIITUgAyAgaiACQRR2s0MA8H9FlUMAAAA/lEPbD0lAlCI5EJkCIjcgNiA1IDWMIjogO/0MAAAAAAAAAAAAAAAAAAAAAP1G/U0iO/3HAf0bAkEBcRuSIjYgNCA0lCA2IDaUIDggNSA6IDv9GwBBAXEbkiI1IDWUkpKRIjaVlP0TIDcgNSA2lZT9IAEgNyA0IDaVlP0gAiA5EJsC/SAD/QsCACAHIQIgIiADQRBqIgNHDQALQQQhLkEAIQ9BACENQQQhFEEAIRlBBCEQQQAhJ0EEIS8gH0UNEiAMQQlsIicgBigChAMiA0sEQCAnIANrIgIgBigC/AIgA2tLBEAgBkH8AmogAyACQQRBBBCkBSAGKAKEAyEDCyAGKAKAAyIIIANBAnRqIQcgAkECTwR/IAJBAnRBBGsiCwRAIAdBACAL/AsACyACIANqIgJBAWshAyAIIAJBAnRqQQRrBSAHC0EANgIAIAYgA0EBaiIDNgKEAwsgAyAnSQ0HIAYoAoADIS8gBkEMahCjBSAhQQhqIh1BADoAACAhQgA3AgAgBigCDEUNESAGKAIQIBVBAnQgDCAVakECdBDhCCENAkAgBigCiAEiAyAJTwRAIAYgCTYCiAEgCSELDAELIAkgAyICayIIIAYoAoABIANrSwRAIC0gAyAIQQRBBBCkBSAGKAKIASECCyAGKAKEASILIAJBAnQiEGohByAIQQJPBEAgCSADQX9zakECdCIKBEAgB0EAIAr8CwALICIgA0ECdGsgC2ogEGpBBGshByACIAhqQQFrIQILIAdBADYCACAGIAJBAWoiCzYCiAEgCSALSw0JCyAGKAKEASEHIAYgDRC4CiICNgKIBCAGIAk2AowEIAIgCUcNCSAHIAkgDRDhCSAMQSRsIQpBACEUQQEhCEEAIRACQAJAAkACQANAIAhBAWsgC08NASAKIBBGDQQgECAvaiICQQhqQwAAgD8gBygCACIDQRt2QQ9rELAGQwAAf0OVIjQgA0EQdkH/AXGzlCI1jCA1IANBgICAIHEbOAIAIAJBBGogNCADQQh2Qf8BcbOUIjWMIDUgA0GAgIAQcRs4AgAgAiA0IANB/wFxs5QiNIwgNCADQYCAgAhxGzgCACAIIAtPDQMgAkEUakMAAIA/IAdBBGooAgAiA0EbdkEPaxCwBkMAAH9DlSI0IANBEHZB/wFxs5QiNYwgNSADQYCAgCBxGzgCACACQRBqIDQgA0EIdkH/AXGzlCI1jCA1IANBgICAEHEbOAIAIAJBDGogNCADQf8BcbOUIjSMIDQgA0GAgIAIcRs4AgAgCEEBaiALTw0CIAJBIGpDAACAPyAHQQhqKAIAIgNBG3ZBD2sQsAZDAAB/Q5UiNCADQRB2Qf8BcbOUIjWMIDUgA0GAgIAgcRs4AgAgAkEcaiA0IANBCHZB/wFxs5QiNYwgNSADQYCAgBBxGzgCACACQRhqIDQgA0H/AXGzlCI0jCA0IANBgICACHEbOAIAIAhBBGohCCAHQRBqIQcgFEEJaiEUIAogEEEkaiIQRw0ACyANQYQISQ0VIA0QmwcMFQsgCEEBayEIDAELIAhBAWohCAsgCCALQYCnwQAQjAcACyAUICdBkKfBABCMBwALIAsgEkHgpsEAEIwHAAtBACASIBFB7OHBABDqBwALIAggCyAQQeCpwQAQ6gcACyACIBJB0KnBABCMBwALQQAgCSATQdzhwQAQ6gcACyACIAcgCEHAqcEAEOoHAAsgAiAJQbCpwQAQjAcAC0EAICcgA0HM4cEAEOoHAAtBACAJIAtBoKfBABDqBwALDBQLQQAgEiAOQfzhwQAQ6gcACyAMIAxB4KXBABCMBwALQQAgDCAYQYziwQAQ6gcACyAIQQJqIBJBwKXBABCMBwALIAggEkGwpcEAEIwHAAsgByALIBBB0KXBABDqBwALQQAgEiAXQZziwQAQ6gcACyAfQQFGBEBBACENQQQhFEEEIRAMAQsgDEEPbCIZIAYoApADIgNLBEAgGSADayICIAYoAogDIANrSwRAIAZBiANqIAMgAkEEQQQQpAUgBigCkAMhAwsgBigCjAMiCCADQQJ0aiEHIAJBAk8EfyACQQJ0QQRrIgsEQCAHQQAgC/wLAAsgAiADaiICQQFrIQMgCCACQQJ0akEEawUgBwtBADYCACAGIANBAWoiAzYCkAMLAkACQAJAAkAgAyAZTwRAIAYoAowDIRAgBkEMahCjBSAdQQA6AAAgIUIANwIAIAYoAgxFDQQgBigCECAVQQJ0IgIgDCAVakECdCIDEOEIIREgBigCFEEBRwRAIBFBgwhNDQUMBAsgBigCGCACIAMQ4QghEyAGQQxqIAwQ0AQgCSAGKAKIASIaSw0BIAYoAoQBIQMgBiARELgKIgI2AogEIAYgCTYCjAQgAiAJRw0RIAMgCSAREOEJIAkgBigClAEiAksNAiAGKAKQASEjIAYgExC4CiIHNgKIBCAGIAk2AowEIAcgCUcNESAjIAkgExDhCSADQQxqISogGUEDayEHQQAhC0EBIQggECEDQQAhDUEAIRQCfwJAAkACQAJAAn8CQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkADQCAHQQFqIiRBA24gB0ECaiIeQQNuIAhBAmoiGyAaTw0BIAwgFE0NAiADQQhqQwAAgD8gCyAqaigCACIKQRt2QQ9rELAGQwAAf0OVIjQgCkEQdkH/AXGzlCI1jCA1IApBgICAIHEbOAIAIANBBGogNCAKQQh2Qf8BcbOUIjWMIDUgCkGAgIAQcRs4AgAgAyA0IApB/wFxs5QiNIwgNCAKQYCAgAhxGzgCACAIQQFrIAJPDQRDAACAPyALICNqIhwoAgAiCkEbdkEPaxCwBiE0IB5BA0kNByADQQxqIDRDAAB/Q5UiNCAKQf8BcbOUIjWMIDUgCkGAgIAIcRs4AgAgJEEDSQ0MIANBEGogNCAKQQh2Qf8BcbOUIjWMIDUgCkGAgIAQcRs4AgAgB0EDSQ0RIANBFGogNCAKQRB2Qf8BcbOUIjSMIDQgCkGAgIAgcRs4AgAgAiAITQ0GQwAAgD8gHEEEaigCACIKQRt2QQ9rELAGITRBAmoiJEEDRg0IIANBGGogNEMAAH9DlSI0IApB/wFxs5QiNYwgNSAKQYCAgAhxGzgCAEECaiIlQQNGDQ0gA0EcaiA0IApBCHZB/wFxs5QiNYwgNSAKQYCAgBBxGzgCACAHQQNuQQJqIh5BA0YNEiADQSBqIDQgCkEQdkH/AXGzlCI0jCA0IApBgICAIHEbOAIAIAhBAWogAk8NBUMAAIA/IBxBCGooAgAiCkEbdkEPaxCwBiE0ICRBBEYNCSADQSRqIDRDAAB/Q5UiNCAKQf8BcbOUIjWMIDUgCkGAgIAIcRs4AgAgJUEERg0OIANBKGogNCAKQQh2Qf8BcbOUIjWMIDUgCkGAgIAQcRs4AgAgHkEERg0TIANBLGogNCAKQRB2Qf8BcbOUIjSMIDQgCkGAgIAgcRs4AgAgAiAbTQ0DQwAAgD8gHEEMaigCACIKQRt2QQ9rELAGITQgJEEFRg0KIANBMGogNEMAAH9DlSI0IApB/wFxs5QiNYwgNSAKQYCAgAhxGzgCACAlQQVGDQ8gA0E0aiA0IApBCHZB/wFxs5QiNYwgNSAKQYCAgBBxGzgCACAeQQVGDRQgA0E4aiA0IApBEHZB/wFxs5QiNIwgNCAKQYCAgCBxGzgCACAIQQRqIQggC0EQaiELIANBPGohAyANQQ9qIQ0gB0EPayEHIBRBAWoiFCAMSQ0ACyATQYQITwRAIBMQmwcLIBFBgwhLDRgMGQsgGyAaQcCnwQAQjAcACyANIBlB0KfBABCMBwALIAhBAmohCAwCCyAIQQFrIQgMAQsgCEEBaiEICyAIIAJB4KfBABCMBwALIA1BA2oMAwsgDUEGagwCCyANQQlqDAELIA1BDGoLIBlB8KfBABCMBwALIA1BBGoMAwsgDUEHagwCCyANQQpqDAELIA1BDWoLIBlBgKjBABCMBwALIA1BBWoMAwsgDUEIagwCCyANQQtqDAELIA1BDmoLIBlBkKjBABCMBwALQQAgGSADQbzhwQAQ6gcAC0EAIAkgGkGgqMEAEOoHAAtBACAJIAJBsKfBABDqBwALIBEQmwcLIB9BAk0EQEEAIQ1BBCEUDAELIAxBFWwiDSAGKAKcAyIDSwRAIA0gA2siAiAGKAKUAyADa0sEQCAGQZQDaiADIAJBBEEEEKQFIAYoApwDIQMLIAYoApgDIgggA0ECdGohByACQQJPBH8gAkECdEEEayILBEAgB0EAIAv8CwALIAIgA2oiAkEBayEDIAggAkECdGpBBGsFIAcLQQA2AgAgBiADQQFqIgM2ApwDCwJAAkACQAJAAkACQAJ/AkACQAJ/AkACQCADIA1PBEAgBigCmAMhFCAGQQxqIgIQowUgHUEAOgAAICFCADcCACAGKAIcQQFHDQ0gBigCICAVQQJ0IgMgDCAVakECdCIHEOEIIRwgBigCJEEBRw0LIAYoAiggAyAHEOEIISMgAiAMENAEAkACQCAGKAKIASIaIAlPBEAgBigChAEhJCAGIBwQuAoiAjYCiAQgBiAJNgKMBCACIAlHDQIgJCAJIBwQ4QkgCSAGKAKUASIdSw0BIAYoApABISUgBiAjELgKIgI2AogEIAYgCTYCjAQgAiAJRw0cICUgCSAjEOEJIA1BDGshCEEAIQJBACELQQAhE0EAIQdBACERAn8CQANAIAhBA24gCEEBaiIqQQNuIAhBAmoiMEEDbgJAAkAgAiAaTw0AAkAgDCARSwRAIBMgFGoiCkEIakMAAIA/IAsgJGoiGygCACIDQRt2QQ9rELAGQwAAf0OVIjQgA0EQdkH/AXGzlCI1jCA1IANBgICAIHEbOAIAIApBBGogNCADQQh2Qf8BcbOUIjWMIDUgA0GAgIAQcRs4AgAgCiA0IANB/wFxs5QiNIwgNCADQYCAgAhxGzgCACACQQFqIgMiMiAaSQ0BIAMhAgwCCyAHIA1BkKnBABCMBwALIApBFGpDAACAPyAbQQRqKAIAIgNBG3ZBD2sQsAZDAAB/Q5UiNCADQRB2Qf8BcbOUIjWMIDUgA0GAgIAgcRs4AgAgCkEQaiA0IANBCHZB/wFxs5QiNYwgNSADQYCAgBBxGzgCACAKQQxqIDQgA0H/AXGzlCI0jCA0IANBgICACHEbOAIAAkAgGiACQQJqIjNLBEAgCkEgakMAAIA/IBtBCGooAgAiA0EbdkEPaxCwBkMAAH9DlSI0IANBEHZB/wFxs5QiNYwgNSADQYCAgCBxGzgCACAKQRxqIDQgA0EIdkH/AXGzlCI1jCA1IANBgICAEHEbOAIAIApBGGogNCADQf8BcbOUIjSMIDQgA0GAgIAIcRs4AgAgAkEDaiAaTw0BIApBLGpDAACAPyAbQQxqKAIAIgNBG3ZBD2sQsAZDAAB/Q5UiNCADQRB2Qf8BcbOUIjWMIDUgA0GAgIAgcRs4AgAgCkEoaiA0IANBCHZB/wFxs5QiNYwgNSADQYCAgBBxGzgCACAKQSRqIDQgA0H/AXGzlCI0jCA0IANBgICACHEbOAIAIAIgHUkNAwwTCyACQQJqIQIMAQsgAkEDaiECCyACIBpBgKnBABCMBwALQwAAgD8gCyAlaiIbKAIAIgNBG3ZBD2sQsAYhNAJAAkAgMEEDTwRAIApBMGogNEMAAH9DlSI0IANB/wFxs5QiNYwgNSADQYCAgAhxGzgCACAqQQNJDQEgCkE0aiA0IANBCHZB/wFxs5QiNYwgNSADQYCAgBBxGzgCACAIQQNPDQIgB0EOagwFCyAHQQxqDA4LIAdBDWoMCgsgCkE4aiA0IANBEHZB/wFxs5QiNIwgNCADQYCAgCBxGzgCACAdIDJNDQ1DAACAPyAbQQRqKAIAIgNBG3ZBD2sQsAYhNEEFaiIqQQZGDQsgCkE8aiA0QwAAf0OVIjQgA0H/AXGzlCI1jCA1IANBgICACHEbOAIAQQVqIitBBkYNCCAKQUBrIDQgA0EIdkH/AXGzlCI1jCA1IANBgICAEHEbOAIAQQVqIh5BBkcEQCAKQcQAaiA0IANBEHZB/wFxs5QiNIwgNCADQYCAgCBxGzgCACAdIDNNDQ9DAACAPyAbQQhqKAIAIgNBG3ZBD2sQsAYhNCAqQQdGDQsgCkHIAGogNEMAAH9DlSI0IANB/wFxs5QiNYwgNSADQYCAgAhxGzgCACArQQdGDQggCkHMAGogNCADQQh2Qf8BcbOUIjWMIDUgA0GAgIAQcRs4AgAgHkEHRg0CIApB0ABqIDQgA0EQdkH/AXGzlCI0jCA0IANBgICAIHEbOAIAIAJBBGohAiALQRBqIQsgE0HUAGohEyAHQRVqIQcgCEEVayEIIBFBAWoiESAMTw0RDAELCyAHQRFqDAELIAdBFGoLIA1B8KjBABCMBwALQQAgCSAaQaCpwQAQ6gcAC0EAIAkgHUGwqMEAEOoHAAsMGQtBACANIANBrOHBABDqBwALIAdBE2oMAQsgB0EQagsgDUHgqMEAEIwHAAsgB0ESagwBCyAHQQ9qCyANQdCowQAQjAcACyACQQFqIQIMAQsgAkECaiECCyACIB1BwKjBABCMBwALICNBhAhPBEAgIxCbBwsgHEGDCEsNAQwCCyAcQYMITQ0BCyAcEJsHCwJAICxFBEBBAiELDAELIAYoAqgDIgMgDEkEQCAMIANrIgIgBigCoAMgA2tLBEAgBkGgA2ogAyACQQJBAhCkBSAGKAKoAyEDCyAGKAKkAyIIIANBAXRqIQcgAkECTwR/IAJBAXRBAmsiCwRAIAdBACAL/AsACyACIANqIgJBAWshAyAIIAJBAXRqQQJrBSAHC0EAOwEAIAYgA0EBaiIDNgKoAwsCQAJAAkAgAyAMTwRAIAYoAqQDIQsgBkEMahCjBSAhQQhqIgpBADoAACAhQgA3AgAgBigCSEUNAyAGKAJMIBVBAnQgDCAVakECdBDhCCEPAkAgBigCiAEiAyAJTwRAIAYgCTYCiAEgCSEIDAELIAkgAyICayIIIAYoAoABIANrSwRAIC0gAyAIQQRBBBCkBSAGKAKIASECCyAGKAKEASIRIAJBAnQiE2ohByAIQQJPBEAgCSADQX9zakECdCIaBEAgB0EAIBr8CwALICIgA0ECdGsgEWogE2pBBGshByACIAhqQQFrIQILIAdBADYCACAGIAJBAWoiCDYCiAEgCCAJSQ0CCyAGKAKEASECIAYgDxC4CiIDNgKIBCAGIAk2AowEIAMgCUcNECACIAkgDxDhCSACQQhqIQJBACEDIAshBwJAA0AgA0ECaiIRIAhPDQQgAyAmRg0BIAcgAigCADsBACACQRBqIQIgB0ECaiEHICYgA0EEaiIDRw0ACyAPQYQISQ0EIA8QmwcMBAsgDCAMQZCmwQAQjAcAC0EAIAwgA0Gc4cEAEOoHAAtBACAJIAhBoKbBABDqBwALIBEgCEGApsEAEIwHAAsgBigCtAMiAyAMSQRAIAwgA2siAiAGKAKsAyADa0sEQCAGQawDaiADIAJBBEEEEKQFIAYoArQDIQMLIAYoArADIgggA0ECdGohByACQQJPBH8gAkECdEEEayIPBEAgB0EAIA/8CwALIAIgA2oiAkEBayEDIAggAkECdGpBBGsFIAcLQQA2AgAgBiADQQFqIgM2ArQDCyADIAxJDQggBigCsAMhLiAGQQxqEKMFIApBADoAACAhQgA3AgACQCAGKAJIQQFHDQAgBigCTCAVQQJ0IAwgFWpBAnQQ4QghCAJAIAYoAogBIgMgCU8EQCAGIAk2AogBIAkhBwwBCyAJIAMiAmsiDyAGKAKAASADa0sEQCAtIAMgD0EEQQQQpAUgBigCiAEhAgsgBigChAEiCiACQQJ0IhFqIQcgD0ECTwRAIAkgA0F/c2pBAnQiEwRAIAdBACAT/AsACyAiIANBAnRrIApqIBFqQQRrIQcgAiAPakEBayECCyAHQQA2AgAgBiACQQFqIgc2AogBIAcgCUkNCwsgBigChAEhAiAGIAgQuAoiAzYCiAQgBiAJNgKMBCADIAlHDQ0gAiAJIAgQ4QkgAkEMaiECQQAhAwNAIANBA2oiDyAHTw0MIAMgJkYNBiADIC5qIAIoAgA2AgAgAkEQaiECICYgA0EEaiIDRw0ACyAIQYQISQ0AIAgQmwcLIAwhDwsgEiAXSw0CIAYgDzYChAQgBiAuNgKABCAGIA82AvwDIAYgCzYC+AMgBiANNgL0AyAGIBQ2AvADIAYgGTYC7AMgBiAQNgLoAyAGICc2AuQDIAYgLzYC4AMgBiAJNgLcAyAGICA2AtgDIAYgEjYC1AMgBiAONgLQAyAGIBI2AswDIAYgKDYCyAMgBiAMNgLEAyAGICk2AsADIAYgEjYCvAMgBiAWNgK4AyAGQYACaiAVIAwgBkG4A2oQ4gEgDCAVaiIVIAFJDQALIAYoAqwDIgFFDQAgBigCsAMiAkEEaygCACIDQXhxIgcgAUECdCIBQQRBCCADQQNxIgMbakkNCyADQQAgByABQSdqSxsNDCACEKICCyAGKAKgAyIBBEAgBigCpAMiAkEEaygCACIDQXhxIgcgAUEBdCIBQQRBCCADQQNxIgMbakkNCyADQQAgByABQSdqSxsNDCACEKICCyAGKAKUAyIBBEAgBigCmAMiAkEEaygCACIDQXhxIgcgAUECdCIBQQRBCCADQQNxIgMbakkNCyADQQAgByABQSdqSxsNDCACEKICCyAGKAKIAyIBBEAgBigCjAMiAkEEaygCACIDQXhxIgcgAUECdCIBQQRBCCADQQNxIgMbakkNCyADQQAgByABQSdqSxsNDCACEKICCyAGKAL8AiIBBEAgBigCgAMiAkEEaygCACIDQXhxIgcgAUECdCIBQQRBCCADQQNxIgMbakkNCyADQQAgByABQSdqSxsNDCACEKICCyAGKALwAiIBBEAgIEEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNCyACQQAgAyABQSdqSxsNDCAgEKICCyAGKALkAiIBBEAgDkEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNCyACQQAgAyABQSdqSxsNDCAOEKICCyAGKALYAiIBBEAgKEEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNCyACQQAgAyABQSdqSxsNDCAoEKICCyAGKALMAiIBBEAgKUEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNCyACQQAgAyABQSdqSxsNDCApEKICCyAGKALAAiIBBEAgFkEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNCyACQQAgAyABQSdqSxsNDCAWEKICCyAGQeABaiIHIAZBjAJqIgFBEGr9AAIA/QsDACAGQfABaiIJIAFBIGr9AAIA/QsDACAGIAH9AAIA/QsD0AEgBigChAIhASAGKAKAAiIIQYCAgIB4Rw0CIAZBADYCiAIgBkKAgICAEDcCgAIgBkGck8EANgK8AyAGQqCAgIAONwLAAyAGIAZBgAJqNgK4AyABIAZBuANqEK8EDQggBigCgAIhAiAGKAKEAiIDIAYoAogCEOwIIQcgAgRAIANBBGsoAgAiCUF4cSIIQQRBCCAJQQNxIgkbIAJqSQ0LIAlBACAIIAJBJ2pLGw0MIAMQogILIABBgICAgHg2AgAgACAHNgIEIAEgASgCACgCABEDACAGQQxqEIoCIARFDQQgBUGDCEsNAwwEC0EAIBIgF0H84MEAEOoHAAsgDCAMQcCmwQAQjAcACyAGKAKIAiECIAYoArwCIQMgACAG/QAD0AH9CwIMIABBLGogCf0AAwD9CwIAIABBHGogB/0AAwD9CwIAIAAgAzYCRCAAIAI2AkAgACADNgI8IAAgAjYCCCAAIAE2AgQgACAINgIAIAZBDGoQigIgBEUgBUGECElyDQELIAUQmwcLIAZBkARqJAAPC0EAIAwgA0GM4cEAEOoHAAtBACAJIAdB0KbBABDqBwALIA8gB0GwpsEAEIwHAAtBoJ7GAEE3IAZBrANqQbSTwQBB2J7GABDgBgALIAZBADYCuANBACAGQYgEaiAGQYwEaiAGQbgDakHg+cQAEPUHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALt10DMH8EfgZ7IwBB0AJrIgckACABQUBrIRACQAJAAkACQAJAAkACQAJAIAEtAEwiCA0AIAdBtAJqIBAQjwIgBy0AtAIiCEEdRgRAIAEtAEwiCA0BDAMLDAELIAEgCEEBayIKOgBMIAEgASkDQCI3QgGIIjg3A0ACQAJAAkACQAJAAkACQAJAAkAgN0IBg1AEQEGAgICAeCEdDAELIAhBBE0EQCAHQbQCaiAQEI8CIActALQCIghBHUcNCiABLQBMIgpBBEkNCyAQKQMAITgLIAEgCkEEazoATCABIDhCBIg3A0AgOKdBD3EiHkEBa0ELTwRAQQ0hCAwMC0EEIB50IgsQcSIIRQ0DIAhBBGstAABBA3FFIAtFckUEQCAIQQAgC/wLAAsgCK1BASAedCIdrUIghoQhNwsgN6chJkEBIRtBAiEZQQEhMSAERQ0BAkACQAJAIAEtAEwiCEUEQCAHQbQCaiAQEI8CIActALQCIghBHUcNASABLQBMIghFDQQLIAEgCEEBayIEOgBMIAEgASkDQCI4QgGIIjk3A0AgOEIBg1ANBCAIQQNNBEAgB0G0AmogEBCPAiAHLQC0AiIIQR1HDQEgAS0ATCIEQQNJDQQgECkDACE5CyABIARBA2s6AEwgASA5QgOINwNAQX8gOadBB3FBAmoiHHRBf3MiBCACQf//A3FqIBx2IjEgBCADQf//A3FqIBx2IgRsIh9BAnQhEyAfBEAgExBxIgtFDQYgC0EEay0AAEEDcUUgE0VyRQRAIAtBACAT/AsACyAHQbQCaiABIDEgBEEAIAsgExA8IActALQCIghBHUYNAyAHKQK8AiE3IAcoArgCIQwgBy8BtgIhDiAHLQC1AiEJIAsgE0EBEKIHDAsLIAdBtAJqIAEgMSAEQQBBASATEDwgBy0AtAIiCEEdRg0BCyAHKQK8AiE3IAcoArgCIQwgBy8BtgIhDiAHLQC1AiEJDAkLQQAhHwwCCyAfQQF0EHEiGUUNAgJ/IBNBBGsiBEEgSQRAIBMhCiALIQhBAQwBCyALIBNqQQJrIBlLBEAgEyEKQQEgCyIIIBkgBEEBdmpBAmpJDQEaCyALIARBAnZBAWoiBCAEQQNxIgRBBCAEG2siGEECdGohCCAfIBhrQQJ0IQogGSEEIBghDCALIQn9DAEAAAABAAAAAQAAAAEAAAAiPiE7A0AgBCAJ/QAAACI9IDv9DQAABAAIAAwAAAAAAAAAAABBCP2LASA9IDv9DQEFCQ0AAAAAAAAAAAAAAAD9iQH9UCI9/VsBAAAgOyA9/akBID79rgH9uQEhOyAEQQhqIQQgCUEQaiEJIAxBBGsiDA0ACyA7IDsgO/0NCAkKCwwNDg8AAQIDAAECA/25ASI7IDsgO/0NBAUGBwABAgMAAQIDAAECA/25Af0bAAshGyAZIBhBAXRqIQQDQCAEIAgvAAAiDEEIdCAMQQh2ciIMOwEAIBsgDEH//wNxQQFqIgkgCSAbSRshGyAIQQRqIQggBEECaiEEIBhBAWohGCAKQQRrIgoNAAsgCyATQQEQogcMAQtBDyEIDAYLIDdCIIinISAgB0EANgIYIAdCgICAgMAANwMQQQEgHkEPcXQhMiAHQbgCaiEhIAdBtAJqIgRBAXIhLSAHQbIBaiEiIAdBsQFqIS4gB0G0AWohIyAEQQJyISRBASEIQQQhE0EAIQoDQCAIITRBACELIAdBADsBlAEgB0GAgICAeDYCkAEgB0EAOwF4IAdBgICAgHg2AnQgB0EAOwFcIAdBgICAgHg2AlggB0EAOwFAIAdBgICAgHg2AjwgB0EAOwEkIAdBgICAgHg2AiBBASEIAkACfwJAAkACQANAIAshKiAIIQsgKkEBdC8BgIBHAkAgAS0ATCIIDQAgB0G0AmogEBCPAgJAIActALQCIghBHUYEQCABLQBMIggNAkEPIQgMAQsgByAkKQEANwPIASAHICRBBmopAQA3Ac4BIActALUCIQELICIgBykDyAE3AQAgIkEGaiAHKQHOATcBACAHIAE6ALEBIAcgCDoAsAEMBAtBACAyQQAgHUGAgICAeEcbICobaiEVIAEgCEEBayIIOgBMIAEgASkDQCI4QgGIIjc3A0ACQAJAAn8CQAJAAkACQAJAAkACQAJAIDhCAYNQRQRAIAhB/wFxDQQgB0G0AmogEBCPAiAHLQC0AiIIQR1HDQEgAS0ATCIIDQNBDyEIDAILQSYQcSIMRQ0SIAxBBGsiDi0AAEEDcQRAIAz9DAAAAAAAAAAAAAAAAAAAAAAiO/0LAAAgDEEeakIANwAAIAxBEGogO/0LAAALIAEtAEwiCEEDSw0GIAdBtAJqIBAQjwIgBy0AtAIiCEEdRw0EIAEtAEwiCEEETw0GQQ8hCAwFCyAHICQpAQA3A9gBIAcgJEEGaikBADcB3gEgBy0AtQIhAQsgIiAHKQPYATcBACAiQQZqIAcpAd4BNwEAIAcgAToAsQEgByAIOgCwASAHQYGAgIB4NgKsAQwMCyAQKQMAITcLIAEgCEEBayIIOgBMIAEgN0IBiCI4NwNAIAhB/wFxRQRAIAdBtAJqIBAQjwICQAJAIActALQCIghBHUYEQCABLQBMIggNAkEPIQgMAQsgByAkKQEANwPoASAHICRBBmopAQA3Ae4BIActALUCIQELICIgBykD6AE3AQAgIkEGaiAHKQHuATcBACAHIAE6ALEBIAcgCDoAsAEgB0GBgICAeDYCrAEMDAsgECkDACE4CyABIAhBAWsiCDoATCABIDhCAYg3A0ACQAJAQQhBASA4p0EBcRsiBCAIQf8BcUsEQCAHQbQCaiAQEI8CIActALQCIghBHUcEQCAHQYACaiAhQQhqKAIANgIAIAcgISkCADcD+AEgBy8BtgIhASAHLQC1AiEEDAILIAEtAEwhCAsgCEH/AXEgBE8NAUEPIQgLICMgBykD+AE3AgAgI0EIaiAHQYACaigCADYCACAHIAE7AbIBIAcgBDoAsQEgByAIOgCwASAHQYGAgIB4NgKsAQwLCyABIAggBGsiCToATCABIAEpA0AiOSAErSI6iCI4NwNAIBVB//8DcSIMIDlCfyA6hkJ/hYOnIghNBEAMCgsgN0IBg1ANAyAJQf8BcUEHTQRAIAdBtAJqIBAQjwICQAJ/IActALQCIgRBHUYEQCABLQBMIglBCE8NAkEPDAELIAdBoAJqICFBCGooAgA2AgAgByAhKQIANwOYAiAHLwG2AiEnIActALUCIQEgBAshCCAjIAcpA5gCNwIAICNBCGogB0GgAmooAgA2AgAgByAnOwGyASAHIAE6ALEBIAcgCDoAsAEgB0GBgICAeDYCrAEMDAsgECkDACE4CyABIAlBCGs6AEwgASA4QgiINwNAIAwgOKdB/wFxIidLBEBBGBBxIgRFDQ8gBEECOwEQIAQgJzsBCiAEQQE7AQggBCAIOwECIARBATsBAEEIEHEiDEUNDyAMICdBgIAEcjYCBCAMIAhBgIAEcjYCACAHQQE7AcQBIAdBAjYCwAEgByAMNgK8ASAHQoOAgIAgNwK0ASAHIAQ2ArABIAdBAzYCrAEgBCEIQQMMBQsMCQsgB0GGAmogLUECai0AADoAACAHIC0vAAA7AYQCIAcoArgCIQEgBykCvAIhNwsgLiAHLwGEAjsAACAuQQJqIAdBhgJqLQAAOgAAIAcgCDoAsAEgByA3NwK4ASAHIAE2ArQBDAYLIAEgCEEEayIIOgBMIAEgASkDQCI4QgSIIjc3A0AgOKdBD3FBAnQhD0FwIQQDQCAIQf8BcUECTQRAIAdBtAJqIBAQjwICQAJAIActALQCIghBHUYEQCABLQBMIghBA08NAkEPIQgMAQsgB0GQAmogIUEIaigCADYCACAHICEpAgA3A4gCIAcvAbYCIQkgBy0AtQIhAQsgIyAHKQOIAjcCACAjQQhqIAdBkAJqKAIANgIAIAcgCTsBsgEgByABOgCxASAHIAg6ALABDAgLIBApAwAhNwsgASAIQQNrIgg6AEwgASA3QgOIIjg3A0AgBEGU/8YAaigCACIJQRJNBEAgDCAJQQF0aiA3p0EHcSIJOwEAIDghNyAPIARBBGoiBEYNBAwBCwsgCUETQdD/xgAQjAcACyAHIAg7AbABIAdBgICAgHg2AqwBQYCAgIB4CyEPIAcpArgBITcgBygCtAEhDCAHLwGyASEOIActALEBIQkMAQsgB0ETNgKgAiAHIAw2ApwCIAdBEzYCmAIgB0G0AmogB0GYAmoQmAEgBygCxAIhFCAHKALAAiEXIAcoArwCIQ4gBygCuAIhDAJAIAcoArQCIhJBgYCAgHhGBEAgDCEIIBQhDSAXIQQMAQsgBykCyAIhNwJAAkAgCEH/AXFFBEAgB0G0AmogEBCPAgJAIActALQCIghBHUYEQCABLQBMIggNAUEPIQgMBAsMAgsgECkDACE4CyABIAhBAWsiCToATCABIDhCAYgiOTcDQCAVIQ8gOEIBg1BFBEACQAJAIAhB/wFxQQNNBEAgB0G0AmogEBCPAiAHLQC0AiIIQR1HDQRBDyEIIAEtAEwiCUEDSQ0FIBApAwAhOQsgASAJQQNrIgk6AEwgASA5QgOINwNAIDmnQQF0QQ5xQQJqIg8gCUH/AXFNDQEgB0G0AmogEBCPAiAHLQC0AiIIQR1GDQAMAwsgAS0ATCEJC0EPIQggCUH/AXEgD0kNAiABIAkgD2s6AEwgASABKQNAIjggD60iOYg3A0AgFUECa0H//wNxIDhCfyA5hkJ/hYOnIglB//8DcUkNAiAJQQJqIQ8LIBVB//8DcSINBH8gDUEBdCIoEHEiEUUNDCARQQRrIhotAABBA3FFIChFckUEQCARQQAgKPwLAAsCQCAPQf//A3FFDQAgN0IgiCE4IDenIS9BACEIQQghKwJAA0ACQCAHQbQCaiAQEI8CAkACQAJAAkACQAJ/IActALQCIgRBHUcEQCAHLQC3AkEYdCAHLwC1AkEIdHIgBHIMAQsgDCEEIBJBgICAgHhGDQIgECkDACI3IDiDp0H//wNxIgQgL08NAwJAIBQgBEECdGooAgAiBEGAgARPBEAgAS0ATCIWIARBEHYiCUH/AXFPDQNBDyEJIAcvAbYCIQQMAQsgB0G0AmogDCAOIDenQQp2QT9xIARBAWsgEBCdBiAHLwG2AiEEIActALQCIglBHUYNAwsgBy0AtQJBCHQgCXIgBEEQdHILIQggBygCwAIhDSAHKAK8AiEEIAcoArgCIQ4MBwsgASAWIAlrOgBMIAEgNyAJrYg3A0ALAkAgBEH//wNxIhZBEE8EQCAEQRBrIiVB//8DcUEDSQ0BDAULIBEgCEH//wNxQQF0aiAEOwEAIAQgKyAWGyErIAhBAWohCAwDCyABLQBMIglBgoYcICVBA3RB+P8DcXYiBEEHcUkEQCAHQbQCaiAQEI8CIActALQCIglBHUcEQCAHLQC1AkEIdCAJciEIIAcoAsACIQ0gBygCvAIhBCAHKAK4AiEOIAcvAbYCISwMAwsgAS0ATCEJCyAJQf8BcSAEQf8BcUkEQEEPIQgMAgsgASAJIARrOgBMIAEgASkDQCI3IAStQgeDIjmINwNAIBVB//8DcSIEQoOAjICwASAlQQR0rULw/wODiKciKSA3Qn8gOYZCf4WDpyIsaiIJIAhqQf//A3FJDQMgK0EAIBZBEEYbISUgCEH//wNxIgggBCAEIAhJGyIwIAhrIgQgKSAsakEBa0H//wNxIhYgBCAWSRsiBEEITwRAIARBAWoiFkEHcSIpQQggKRsiKSAEQX9zaiEEIAkgFiApayIWayEJIAggFmogESAIQQF0aiEIICX9ECE7A0AgCCA7/QsBACAIQRBqIQggBEEIaiIEDQALIQgLIBEgCEEBdGohBANAIAggMEcEQCAEICU7AQAgBEECaiEEIAhBAWohCCAJQQFrIglB//8DcQ0BDAQLCyAwIA1BjILHABCMBwALIAQgL0HY+cYAEIwHAAsgLEEQdCAIciEIDAMLIAhB//8DcSAVQf//A3FPDQMgD0EBayIPQf//A3ENAQwDCwtBDyEICwJAIBooAgAiCUF4cSIPQQRBCCAJQQNxIgkbIChqTwRAIAlBACAPIChBJ2pLGw0BIBEQogIMBQsMGAsMGAsgEQVBAgshBEEdIQgCQAJAIBJBgICAgHhGDQAgEgRAIAxBBGsoAgAiCUF4cSIOIBJBA3QiD0EEQQggCUEDcSIJG2pJDRggCUEAIA4gD0EnaksbDRkgDBCiAgsgF0UNACAUQQRrKAIAIgxBeHEiCSAXQQJ0Ig5BBEEIIAxBA3EiDBtqSQ0XIAxBACAJIA5BJ2pLGw0BIBQQogILIA0hDgwDCwwWCyAHLQC1AkEIdCAIciAHLwG2AkEQdHIhCCAHKALAAiENIAcoArwCIQQgBygCuAIhDgsgEkGAgICAeEYNAAJAIBIEQCAMQQRrKAIAIglBeHEiDyASQQN0IhFBBEEIIAlBA3EiCRtqSQ0VIAlBACAPIBFBJ2pLGw0WIAwQogILIBdFDQEgFEEEaygCACIMQXhxIgkgF0ECdCIPQQRBCCAMQQNxIgwbakkNFCAMQQAgCSAPQSdqSxsNACAUEKICDAELDBQLIAhB/wFxQR1HBEAgB0GzAWogCEEYdjoAACAHIA02ArwBIAcgBDYCuAEgByAONgK0ASAHIAg6ALABIAdBgYCAgHg2AqwBIAcgCEEIdjsAsQEMBQsgByANNgKwAiAHIAQ2AqwCIAcgDjYCqAIgB0GsAWogB0GoAmoQmAEgBy0AsAEhCCAHKQK4ASE3IAcvAbIBIQ4gBy0AsQEhCSAHKAK0ASIMIAcoAqwBIg9BgYCAgHhGDQUaCyAHKQLAASE4AkACQCAHQSBqICpBHGxqIgQoAgAiEUGAgICAeEYNACARBEAgBCgCBCIVQQRrKAIAIhRBeHEiFyARQQN0IhFBBEEIIBRBA3EiFBtqSQ0CIBRBACAXIBFBJ2pLGw0VIBUQogILIAQoAgwiEUUNACAEKAIQIhVBBGsoAgAiFEF4cSIXIBFBAnQiEUEEQQggFEEDcSIUG2pJDRMgFEEAIBcgEUEnaksbDRQgFRCiAgsgBCA4NwIUIAQgNzcCDCAEIAw2AgggBCAOOwEGIAQgCToABSAEIAg6AAQgBCAPNgIAIAsgC0EFSSIEaiEIIARFDQYMAQsLDBALAkAgDigCACIBQXhxIgJBKkEuIAFBA3EiARtPBEAgAUEAIAJBzgBPGw0BIAwQogIMAwsMEAtBjI3IAEEuQbyNyAAQ6wcMBQsgB0GBgICAeDYCrAFBDyEIIAdBDzoAsAELIAcpArgBITcgBy8BsgEhDiAHLQCxASEJIAcoArQBCyEMIAdBIGoQjQIgCgRAIBMhAQNAIAEQjQIgAUGMAWohASAKQQFrIgoNAAsLAkAgBygCECIBBEAgE0EEaygCACICQXhxIgMgAUGMAWwiAUEEQQggAkEDcSICG2pJDQ4gAkEAIAMgAUEnaksbDQ8gExCiAgsgH0UNCCAZQQRrKAIAIgFBeHEiAiAfQQF0IgNBBEEIIAFBA3EiARtqSQ0NIAFBACACIANBJ2pLGw0AIBkQogIMCAsMDQsgBygCECAKRgRAIAdBEGoQnwYgBygCFCETCyATIApBjAFsaiAHQSBqQYwB/AoAACAHIApBAWoiCjYCGCA0QQFqIQggCiAbRw0ACyAHKQMQITcgBygCECEpAkACfyAcRQRAQQAhCCA3QiCIpwwBCyAYRQ0BIBkvAQAiCCAbTw0GIDdCIIinCyEEAkACQAJAAkAgAkH//wNxIhcgA0H//wNxbCIRRQ0AQX8gHHRBf3NB//8DIBwbITYgBkEBaiEUIAZBEGshKkEAIB5rQR9xIRYgAkEBa0H//wNxITUgBCAIQYwBbGohDUEAIQNBACEVA0ACQCACQf//A3FFBEAgB0G0AmogEBCPAiAHLQC0AiIIQR1HDQkgAyAVSQ0BQdj7xgAQgggACwJAA0AgB0G0AmogEBCPAiAHLQC0AiIIQR1HDQogAyAVSQ0CIAMgAyAXbiIIIBdsIgtrIQQCQCAcRQRAQQAhCgwBCyAYIDEgCEH//wNxIBx2bCAEQf//A3EgHHZqIghLBEAgGSAIQQF0ai8BACIKIBtJDQEgCiAbQej7xgAQjAcACyAIIBhByPLEABCMBwALIAsgBCA2ciIEIDUgBCA1SRtqQQFqIRUgEyAKQYwBbGoiDSgCAEGAgICAeEcNAiANKAIcQYCAgIB4Rw0CIA0oAjhBgICAgHhHDQIgDSgCVEGAgICAeEcNAiANLwEEIgtBgAJPDQIgDS0AWCEKIA0tADwhDCANLQAgIQkCQCAVIANrIBEgHBsiDgRAQQAhCEEBIQQgBiADQQJ0Ig8gBmtBA2oiEkEAIBJBA00baiAPa0ECdiISIBQgD2siD0EAIA8gFE0bQQNqQQJ2Ig8gDyASSxsiDyAOQQFrIhIgDyASSRsiD0EQTwRAIA9BAWoiBEEPcSIIQRAgCBsiCCAPQX9zaiEPIAQgCGsiCEEBaiEEIAP9ESE7/QwMAAAADQAAAA4AAAAPAAAAIT79DAgAAAAJAAAACgAAAAsAAAAhPf0MBAAAAAUAAAAGAAAABwAAACE//QwAAAAAAQAAAAIAAAADAAAAIUADQCAFIEAgO/2uAUEC/asBIjz9GwBqIhIgCToAACAFIDz9GwFqIh4gCToAACAFIDz9GwJqIiEgCToAACAFIDz9GwNqIiIgCToAACAFID8gO/2uAUEC/asBIjz9GwBqIiMgCToAACAFIDz9GwFqIiQgCToAACAFIDz9GwJqIicgCToAACAFIDz9GwNqIiggCToAACAFID0gO/2uAUEC/asBIjz9GwBqIisgCToAACAFIDz9GwFqIiwgCToAACAFIDz9GwJqIi0gCToAACAFIDz9GwNqIi4gCToAACAFID4gO/2uAUEC/asBIjz9GwBqIi8gCToAACAFIDz9GwFqIiUgCToAACAFIDz9GwJqIjAgCToAACAFIDz9GwNqIjIgCToAACASIAs6AAEgHiALOgABICEgCzoAASAiIAs6AAEgIyALOgABICQgCzoAASAnIAs6AAEgKCALOgABICsgCzoAASAsIAs6AAEgLSALOgABIC4gCzoAASAvIAs6AAEgJSALOgABIDAgCzoAASAyIAs6AAEgEiAMOgACIB4gDDoAAiAhIAw6AAIgIiAMOgACICMgDDoAAiAkIAw6AAIgJyAMOgACICggDDoAAiArIAw6AAIgLCAMOgACIC0gDDoAAiAuIAw6AAIgLyAMOgACICUgDDoAAiAwIAw6AAIgMiAMOgACIBIgCjoAAyAeIAo6AAMgISAKOgADICIgCjoAAyAjIAo6AAMgJCAKOgADICcgCjoAAyAoIAo6AAMgKyAKOgADICwgCjoAAyAtIAo6AAMgLiAKOgADIC8gCjoAAyAlIAo6AAMgMCAKOgADIDIgCjoAAyBA/QwQAAAAEAAAABAAAAAQAAAAIjz9rgEhQCA/IDz9rgEhPyA9IDz9rgEhPSA+IDz9rgEhPiAPQRBqIg8NAAsLIA5BAWohDwNAIAYgAyAIakECdCIISQ0CIAYgCGsiEkEDTQRAQQBBBCASQdT+xgAQ6gcACyAFIAhqIgggCjoAAyAIIAw6AAIgCCALOgABIAggCToAACAEIQggDyAEQQFqIgRHDQALCyAdQYCAgIB4RwRAIAtBCHRBgP4DcSAJQRB0ciAKQRh0ciAMckG9z9bxAWwgFnYiBCAgTw0DICYgBEECdGoiBCAKOgADIAQgDDoAAiAEIAs6AAEgBCAJOgAACyADIA5qIgMgEUkNAQwFCwsgCCAGIAZB5P7GABDqBwALIAQgIEGY+sYAEIwHAAsCQCARAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA0oAgBBgICAgHhHBEAgDSgCFCIIIBApAwAiN6ciCyANLwEYcSIETQ0CAkAgDSgCECAEQQJ0aigCACIIQYCABE8EQCABLQBMIgsgCEEQdiIEQf8BcUkEQEEPIQQgBy8BtgIhCAwCCyABIAsgBGs6AEwgASA3IAStiDcDQAwDCyAHQbQCaiANKAIEIA0oAgggC0GA+ANxQQp2IAhBAWsgEBCdBiAHLwG2AiEIIActALQCIgRBHUYNAgsgACAHKQK4AjcCBCAAQQxqIAdBwAJqKAIANgIAIActALUCIQEgACAIOwECIAAgAToAASAAIAQ6AAAMHAsgDS8BBCEICwJAAkACQAJAAkACQAJAAkACQAJAAkACQCAIQf//A3EiBEGAAk8EQCAEQZgCSQ0BIAdBDzoAtAIgHUGAgICAeEcNAiAAQQA2AgQgAEEPOgAADCgLIA0oAhxBgICAgHhGDQogDSgCMCILIBApAwAiN6ciDCANLwE0cSIETQ0wIA0oAiwgBEECdGooAgAiCkGAgARJDQggAS0ATCILIApBEHYiBEH/AXFJBEBBDyEEIAcvAbYCIQoMCgsgASALIARrOgBMIAEgNyAErYg3A0AMCwsgCEH8A3FBgAJGBH8gCEH/AWtB//8DcQUgAS0ATCILIAhB/gFqQf7/A3FBAXYiBEH/AXEiCkkNAiABIAsgBGs6AEwgASABKQNAIjcgBK1C/wGDIjiINwNAIDdCfyA4hkJ/hYOnIAhBAXFBAnIgCnRqQQFqCyEaIA0oAnBBgICAgHhGDQUgDSgChAEiCCAQKQMAIjenIgsgDS8BiAFxIgRNDRAgDSgCgAEgBEECdGooAgAiCEGAgARJDQMgAS0ATCILIAhBEHYiBEH/AXFPDQJBDyEEIAcvAbYCIQgMBAsgB0G0AmoQqwQgICAIQZgCa0H//wNxIghNDQsgBiADQQJ0IgRJDQwgBiAEayILQQNNDQ0gBCAFaiAmIAhBAnRqKAAANgAAIBUgA0EBaiIITQRAIAgMGwsgECkDACE3IA0oAgBBgICAgHhGDQ4CQCANKAIUIgsgDS8BGCA3p3EiBEsEQCANKAIQIARBAnRqKAIAIgRBgIAETw0BIAgMHAsgBCALQcj5xgAQjAcACyAEQRB2IQoMGQsgACAaNgIEIABBDzoAAAwjCyABIAsgBGs6AEwgASA3IAStiDcDQAwDCyAHQbQCaiANKAJ0IA0oAnggC0GA+ANxQQp2IAhBAWsgEBCdBiAHLwG2AiEIIActALQCIgRBHUYNAgsgACAHKQK4AjcCBCAAQQxqIAdBwAJqKAIANgIAIActALUCIQEgACAIOwECIAAgAToAASAAIAQ6AAAMIAsgDS8BdCEICyAIQf//A3FBBEkNCiAIQQJrIgRB//8DcUH/A0sNCyABLQBMIgsgBEEBdiIEQf8BcUkEQCAAIDM2AgQgAEEPOgAADB8LIAEgCyAEQf//AXEiBGs6AEwgASABKQNAIjcgBK0iOIg3A0AgN0J/IDiGQn+Fg6cgCEEBcUECciAEdGpBAWoiM0H4AE0NESAzQfgAayEKDBILIAdBtAJqIA0oAiAgDSgCJCAMQYD4A3FBCnYgCkEBayAQEJ0GIAcvAbYCIQogBy0AtAIiBEEdRg0CCyAAIAcpArgCNwIEIABBDGogB0HAAmooAgA2AgAgBy0AtQIhASAAIAo7AQIgACABOgABIAAgBDoAAAwcCyANLQAgIQoLAkACfyANKAI4QYCAgIB4RwRAIA0oAkwiCyAQKQMAIjenIgwgDS8BUHEiBE0NJwJAIA0oAkggBEECdGooAgAiCUGAgARPBEAgAS0ATCIEIAlBEHYiC0H/AXFJBEBBDyEEIAcvAbYCIQkMAgsgASAEIAtrIgQ6AEwgASA3IAutiDcDQAwECyAHQbQCaiANKAI8IA0oAkAgDEGA+ANxQQp2IAlBAWsgEBCdBiAHLwG2AiIJIActALQCIgRBHUYNAhoLIAAgBykCuAI3AgQgAEEMaiAHQcACaigCADYCACAHLQC1AiEBIAAgCTsBAiAAIAE6AAEgACAEOgAADB0LIA0tADwLIQkgAS0ATCEECwJAIARB/wFxQQ5LDQAgB0G0AmogEBCPAiAHLQC0AiIEQR1GDQAgACAHKQC1AjcAASAAQQhqIAdBvAJqKQAANwAAIAAgBDoAAAwbCwJAIA0oAlRBgICAgHhHBEAgDSgCaCILIBApAwAiN6ciDiANLwFscSIETQ0mAkAgDSgCZCAEQQJ0aigCACIMQYCABE8EQCABLQBMIgsgDEEQdiIEQf8BcUkEQEEPIQQgBy8BtgIhDAwCCyABIAsgBGs6AEwgASA3IAStiDcDQAwDCyAHQbQCaiANKAJYIA0oAlwgDkGA+ANxQQp2IAxBAWsgEBCdBiAHLwG2AiEMIActALQCIgRBHUYNAgsgACAHKQK4AjcCBCAAQQxqIAdBwAJqKAIANgIAIActALUCIQEgACAMOwECIAAgAToAASAAIAQ6AAAMHAsgDS0AWCEMCyADQQJ0IgQgBk8NCCAEIAVqIAo6AAAgBEEBciILIAZPDQkgBSALaiAIOgAAIARBAnIiCyAGTw0KIAUgC2ogCToAACAEQQNyIgQgBk8NCyAEIAVqIAw6AAAgHUGAgICAeEcEQCAJQf8BcSAIQQh0QYD+A3EgCkEQdHJBgP7/B3EgDEEYdHJyQb3P1vEBbCAWdiIEICBPDQ0gJiAEQQJ0aiIEIAw6AAMgBCAJOgACIAQgCDoAASAEIAo6AAALIANBAWoMEAsgBCAIQdj5xgAQjAcACyAIICBB+PvGABCMBwALIAQgBiAGQbj8xgAQ6gcAC0EAQQQgC0GI/MYAEOoHAAsgDS8BBCEEQQAhCgwKCyAEIAhB2PnGABCMBwALIAhBAWpB//8DcSEzDAYLQdjmyABBKyAHQbQCakGY+8YAQfT+xgAQ4AYACyAEIAZBlP7GABCMBwALIAsgBkGk/sYAEIwHAAsgCyAGQbT+xgAQjAcACyAEIAZBxP7GABCMBwALIAQgIEGY+sYAEIwHAAsgM0EBayIEQfgASQRAQQEgBEEBdCIELACLgEcgF2wgBCwAioBHaiIEIARBAUwbIQoMAQtBf0H4AEH8gccAEIwHAAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADIApJIBEgA2sgGklyRQRAIApBAUYEQCAGIANBAnQiC0EEayIISQ0CIAYgCGsiBEEDTQ0DQQAhBCAFIAhqKAAAIQlBASEIIBpBAWsiCiAUIAtrIgxBACAMIBRNG0EDakECdiIMIAYgC2tBAnYiDiAMIA5JGyIMIAogDEkbIgpBBE8EQCAKQQFqIgRBA3EiCEEEIAgbIgggCkF/c2ohDCAEIAhrIgRBAWohCCAFIAtqIQogCf0RITsDQCAKIDv9CwAAIApBEGohCiAMQQRqIgwNAAsLIA5BAWohCyAaQQFqIQoDQCAGIAMgBGpBAnQiBEkNBSAIIAtGDQYgBCAFaiAJNgAAIAogCCIEQQFqIghHDQALDBELIAMgGmpBA2ogEUsNCyADIAprQQJ0IgtBEGoiBCAGSw0FIAtBb0sNBiADQQJ0IgggKksNByAFIAhqIAUgC2r9AAAA/QsAACAaQQRNIApBBE9xDQwgCkECdCIMRQ0IIBpBAnQiBCAEQfz/A3FBECAMIAxBEE8bIgRB//8DcW4iCiAEbGtB//8DcUEARyAKaiIKQQJJDQwgBCALaiIJQRBqIg4gBksNCSAJQW9LDQogKiAEIAhqTwRAIApBAmshCiAEQQF0IAxrIQ4gBCAFaiEJIAUgBCAMa2ohDCAEIQsDQCAIIAlqIAggDGr9AAAA/QsAACAKRQ0OAkAgBiAIIA5qIg9BEGpPBEAgD0FvTQ0BIANBAnQgDmoiCUEQaiEODA4LIANBAnQgDmpBEGohDgwMCyAKQQFrIQogBCAOaiEOIAQgCWohCSAEIAxqIQwgCCAEIAtqIgtqICpNDQALCyAHQQA2AsQCIAdBATYCuAIgB0HUnMgANgK0AiAHQgQ3ArwCIAdBtAJqQYT+xgAQjQgACyAAQQ86AAAMGwsgCCAGIAZB+PzGABDqBwALQQBBBCAEQcj8xgAQ6gcACyAEIAYgBkHo/MYAEOoHAAtBAEEEIAYgBGtB2PzGABDqBwALQQAgBCAGQaj9xgAQ6gcACyALIAQgBkGo/cYAEOoHAAsgB0EANgLEAiAHQQE2ArgCIAdB1JzIADYCtAIgB0IENwK8AiAHQbQCakGo/cYAEI0IAAtBuP3GAEEbQdT9xgAQ6wcAC0EAIA4gBkGE/sYAEOoHAAsgCSAOIAZBhP7GABDqBwALQQAhBAJAIBpBAnQiD0EBayIIIAYgA0ECdCILIApBAnQiDGsiCiAGIApLGyAMaiALayIKIAYgC2siCUEAIAYgCU8bIgkgCSAKSxsiCiAIIApJGyIKQRBJBEBBASEIDAELQQEhCCAMQQ9NDQAgCkEBaiIEQQ9xIghBECAIGyIIIApBf3NqIQ4gBCAIayIEQQFqIQggBSALaiEKQQAgDGshEgNAIAogCiASav0AAAD9CwAAIApBEGohCiAOQRBqIg4NAAsLIAlBAWohCSAPQQFqIQ4DQCAEIAtqIgQgDGsiCiAGTw0CIAggCUYNAyAEIAVqIAUgCmotAAA6AAAgDiAIIgRBAWoiCEcNAAsLIB1BgICAgHhHDQIMAwsgCiAGQYj9xgAQjAcACyAEIAZBmP3GABCMBwALAkACQCADQQJ0IgQgBk0EQCAaQQJ0IgggBiAEayILSw0BIAhFDQMgBCAFaiEKQQAgCGshCQNAIAooAAAiBEGA/oN4cSAEQRB0QYCA/AdxciAEQRB2IgtB/wFxckG9z9bxAWwgFnYiCCAgTw0DICYgCEECdGoiCCAEQRh2OgADIAggCzoAAiAIIARBCHY6AAEgCCAEOgAAIApBBGohCiAJQQRqIgkNAAsMAwsgBCAGIAZB9P3GABDqBwALQQAgCCALQeT9xgAQ6gcACyAIICBBmPrGABCMBwALIAMgGmoMAQsgCCAEQf//A3FBmAJJDQAaIAEtAEwiCyAKQf8BcUkNBCABIAsgCms6AEwgASA3IAqtiDcDQCAGIAhBAnQiCEkNBSAGIAhrIgtBA00NBiAgIARBmAJrQf//A3EiBE0NASAFIAhqICYgBEECdGooAAA2AAAgA0ECagsiA0sNAQwCCwsgBCAgQfj7xgAQjAcACyAAQR06AAAMBgsgAEEPOgAADAULIAggBiAGQaj8xgAQ6gcAC0EAQQQgC0GY/MYAEOoHAAtBAEEAQcjyxAAQjAcACwALIAAgBykAtQI3AAEgAEEIaiAHQbwCaikAADcAACAAIAg6AAALIB1BgICAgHhyQYCAgIB4Rg0AICYgHUECdEEBEKIHCyAfBEAgGSAfQQF0QQIQogcLIBMhAQNAIAEQjQIgAUGMAWohASA0QQFrIjQNAAsgKUUNBSATIClBjAFsQQQQogcMBQsgCCAbQcj7xgAQjAcACwJAIB1BgICAgHhyQYCAgIB4RwRAICZBBGsoAgAiAUF4cSICIB1BAnQiA0EEQQggAUEDcSIBG2pJDQYgAUEAIAIgA0EnaksbDQEgJhCiAgsgACA3NwIIIAAgDDYCBCAAIA47AQIgACAJOgABIAAgCDoAAAwECwwFCyAHIAcpALcCNwMAIAcgB0G8AmopAAA3AAUgBy0AtgIhASAHLQC1AiEeDAELQQ8hCAsgACABOgACIAAgHjoAASAAIAg6AAAgACAHKQMANwADIABBCGogBykABTcAAAsgB0HQAmokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAEIAtB2PnGABCMBwALi10EGX8EfQF+AXsjAEHwAGsiCCQAAkACQAJAAkACQAJAIAAtAKRTRQRAIAhB0ABqIABBQGsQuAQgCC0AUARAIAgoAlQhAQwDCyAILQBRQQFHDQEgAEEBOgCkUwsgACgCSCIDRQ0AIABBnAFqIRYgCEE8aq1CgICAgBCEIR4gAEHYAGohFyAAQeQAaiEUIABB8ABqIRggAEH8AGohGQNAAkAgACgCVCIFIAAoAqBTIgFrIgJBACACIAVNG0GAgARPBEAgASECDAELIAEgAUGAgAJrIgJBACABIAJPGyIEayECIAEgBEYEQCAAIAI2AqBTDAELIAEgBU0EQCACBEAgACgCUCIBIAEgBGogAvwKAAALIAAoAkghAyAAIAI2AqBTDAELQQAgASAFQczVwQAQ6gcACwJAAkAgAyAOTwRAIAhB0ABqIBYgACgCRCAOaiADIA5rIAAoAlAgACgCVCACQQYQRCAIIAgtAFQiAToADyAIKAJQIRUgCCgCWCITRQ0CIAAoAqBTIgQgE2oiAyAETyADIAAoAlQiAk1xDQEgBCADIAJB3NXBABDqBwALIA4gAyADQezVwQAQ6gcACyAAKAJQIQMgACgCWCAAKAJgIgJrIBNJBEAgFyACIBNBAUEBEKQFIAAoAmAhAgsgEwRAIAAoAlwgAmogAyAEaiAT/AoAAAsgACACIBNqIgc2AmAgACAAKAKgUyATajYCoFMCQAJAIAAoAmRBgICAgHhGBEAgB0EQTwRAIAggACgCXCINKAAAIgI2AhwgAkHOjs2CBUcEQCAIQQE2AmQgCEHMyMEANgJgIAhBATYCVCAIQdTOwQA2AlAgCEEBNgJcIAggCEEcaq1CgICAgJAEhDcDQCAIIAhBQGs2AlggCEEgaiIAIAhB0ABqELEGIAAQjgchAQwICyAIIA0oAAQiBjYCLCAGQQRrQX1JDQIgAEEANgJgIA0tAA4hBSANLQANIQMgDS0ADCEJIA0oAAghBCAHQRBrIgIEQCACBEAgDSANQRBqIAL8CgAACyAAIAI2AmALIAggCTYCPAJAIAlBA00EQEGAgMAAEHEiAg0BAAsgCEEBNgJUIAhBoO3HADYCUCAIQgE3AlwgCCAeNwNoIAggCEHoAGo2AlggCEFAayIAIAhB0ABqELEGIAAQkAchAQwICyAAIAU6AJoBIAAgAzoAmQEgAEEAOgCYASAAQQA2ApQBIAAgCTYCkAEgACAENgKMASAAIAY2AogBIABBADYChAEgAEKAgICAwAA3AnwgAEICNwJ0IABCADcCbCAAIAI2AmggAEGAgBA2AmQgCCAFQYABcUEHdjoAWCAIIAk2AlQgCCAENgJQIAAgCEHQAGoQhAILIAAoAmRBgICAgHhGDQMLA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AmAFBAWsOCQ0MCwoAAQYEFwILQQkhBUEGIQEgACgCkAEOBAQIBwYCCyAAQQlBByAALACaAUEAThs6AJgBDBMLIAAoAmBBBkEJIAAoAogBIgNBAUYbIg1uIgIgACgCjAEgACgClAFrIgRJBEAgAiIEQYCABEkNFQtBgIAEIAQgBEGAgARPGyIPQQNsIgIgACgCbCIBSwR/IAIgAWsiBiAAKAJkIAFrSwRAIBQgASAGQQRBBBCkBSAAKAJsIQELIAAoAmgiAyABQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgIEQCAFQQAgAvwLAAsgASAGaiICQQFrIQEgAyACQQJ0akEEawUgBQtBADYCACAAIAFBAWo2AmwgACgCiAEFIAMLQQFHDQsgBEUNDUEAIQdBACEBQQAhAkEAIQMDQCABQQJqIQwgACgCYCIFIAFBAWpNBEAgASAMIAVBrM/BABDqBwALAn8gACgCXCABaiIFQQFqLQAAQQh0IgkgBS0AAHIiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhCyAJQYCAAnEhBiAJQYD4AXEiBUGA+AFGBEAgBkEQdCIFQYCAgPwHciALRQ0BGiALQQ10IAVyQYCAgP4HcgwBCyAGQRB0IgYgBUENdEGAgID8AHEgC0ENdHJBgICAwANqciAFDQAaIAsgC2dBEGsiBUH//wNxQQhqdEH///8DcSAGQYCAgNgDciAFQRd0a3ILIQYCfwJAAkAgACgCbCIFIANLBEAgACgCaCACaiAGNgIAIAFBBGoiCyAAKAJgIgVLDQEgACgCXCABaiIFQQNqLQAAQQh0IgkgBUECai0AAHIiBUH//wFxRQRAIAVBEHQMBAsgBUH/B3EhDCAJQYCAAnEhBiAJQYD4AXEiBUGA+AFGBEAgBkEQdCIFQYCAgPwHciAMRQ0EGiAMQQ10IAVyQYCAgP4HcgwECyAGQRB0IQYgBUUNAiAFQQ10QYCAgPwAcSAMQQ10ckGAgIDAA2ogBnIMAwsgAyAFQdzOwQAQjAcACyAMIAsgBUGcz8EAEOoHAAsgDCAMZ0EQayIFQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIAVBF3RrcgshCQJ/AkACQCADQQFqIgYgACgCbCIFSQRAIAAoAmggAmpBBGogCTYCACABQQZqIgUgACgCYCIGSw0BIAAoAlwgAWoiAUEFai0AAEEIdCIJIAFBBGotAAByIgFB//8BcUUEQCABQRB0DAQLIAFB/wdxIQsgCUGAgAJxIQYgCUGA+AFxIgFBgPgBRgRAIAZBEHQiAUGAgID8B3IgC0UNBBogC0ENdCABckGAgID+B3IMBAsgBkEQdCEGIAFFDQIgAUENdEGAgID8AHEgC0ENdHJBgICAwANqIAZyDAMLIAYgBUHszsEAEIwHAAsgCyAFIAZBjM/BABDqBwALIAsgC2dBEGsiAUH//wNxQQhqdEH///8DcSAGQYCAgNgDciABQRd0a3ILIQkgA0ECaiIGIAAoAmwiAUkEQCAAKAJoIAJqQQhqIAk2AgAgAkEMaiECIANBA2ohAyAFIQEgB0EBaiIHIA9JDQEMDgsLIAYgAUH8zsEAEIwHAAtB7NPBABCBCAALIAAoAmAiAUECdiICIAAoAowBIAAoApQBayIESQRAIAIhBCABQYCAEEkNEwtBgIAEIAQgBEGAgARPGyIHIAAoAoQBIgFLBEAgByABayIGIAAoAnwgAWtLBEAgGSABIAZBBEEEEKQFIAAoAoQBIQELIAAoAoABIgMgAUECdGohBSAGQQJPBH8gBkECdEEEayICBEAgBUEAIAL8CwALIAEgBmoiAkEBayEBIAMgAkECdGpBBGsFIAULQQA2AgAgACABQQFqIgE2AoQBCyAEBEBBACEBQQAhAwJAA0AgACgCYCICIAFBA2pNBEAgASABQQRqIAJBvNXBABDqBwALIAAoAoQBIgIgA0sEQCAAKAKAASABaiAAKAJcIAFqKAAANgIAIAFBBGohASAHIANBAWoiA0YNAgwBCwsgAyACQazVwQAQjAcACyAAKAKEASEBCyAAKAIQIAAoAhQgACgClAEgByAAKAKAASABEI4DAkACQAJAIAAoAmAiAyAHQQJ0IgFPBEAgAEEANgJgIAMgAWshBSAERQ0BIAEgA0YNAyAFRQ0CIAAoAlwiAiABIAJqIAX8CgAADAILDBoLIAEgA0YNAQsgACAFNgJgCyAAIAAoApQBIAdqIgI2ApQBIAIgACgCjAFHDRAgAEEANgKUAUEJIQELIAAgAToAmAEMDwsgACgCYCIBQQF2IgIgACgCjAEgACgClAFrIgRJBEAgAiEEIAFBgIAISQ0RC0GAgAQgBCAEQYCABE8bIgcgACgCeCIBSwRAIAcgAWsiBiAAKAJwIAFrSwRAIBggASAGQQJBAhCkBSAAKAJ4IQELIAAoAnQiAyABQQF0aiEFIAZBAk8EfyAGQQF0QQJrIgIEQCAFQQAgAvwLAAsgASAGaiICQQFrIQEgAyACQQF0akECawUgBQtBADsBACAAIAFBAWoiATYCeAsgBARAQQAhA0ECIQECQANAIAAoAmAiAiABSQRAIAFBAmsgASACQZzVwQAQ6gcACyAAKAJ4IgIgA0sEQCAAKAJ0IAFqQQJrIAAoAlwgAWpBAmsvAAA7AQAgAUECaiEBIAcgA0EBaiIDRg0CDAELCyADIAJBjNXBABCMBwALIAAoAnghAQsgACgCECAAKAIUIAAoApQBIAcgACgCdCABELQDAkACQAJAIAAoAmAiAyAHQQF0IgFPBEAgAEEANgJgIAMgAWshBSAERQ0BIAEgA0YNAyAFRQ0CIAAoAlwiAiABIAJqIAX8CgAADAILDBgLIAEgA0YNAQsgACAFNgJgCyAAIAAoApQBIAdqIgI2ApQBIAIgACgCjAFHDQ4gAEEANgKUASAAQQg6AJgBDA4LQS0hBQwBC0EYIQULIAAoAmAgBW4iAiAAKAKMASAAKAKUAWsiC0kEQCACIgtBgIAESQ0OC0GAgAQgCyALQYCABE8bIhAgBWwiESAAKAJsIgFLBEAgESABayIGIAAoAmQgAWtLBEAgFCABIAZBBEEEEKQFIAAoAmwhAQsgACgCaCIDIAFBAnRqIQQgBkECTwR/IAZBAnRBBGsiAgRAIARBACAC/AsACyABIAZqIgJBAWshASADIAJBAnRqQQRrBSAEC0EANgIAIAAgAUEBaiIBNgJsCyAQQQlsIQ8CQCALBEAgEEHgAGwhDCAQQRhsIQdBASEBQQAhEkEAIQYCQANAIAYhDSABIQYgBSANbCIBIAAoAmAiAk8NAwJAAkACQAJAIA1BCWwiAyAAKAJsIgJPDQAgACgCaCADQQJ0aiAAKAJcIAFqLQAAs0MAAADDkkMAAAA8lDgCACABQQNqIgkgACgCYCICTwRAIAkhAQwICyADQQNqIgQgACgCbCICTwRAIAQhAwwBCyAAKAJoIARBAnRqIAAoAlwgCWotAACzQwAAAMOSQwAAADyUOAIAIAFBBmoiCSAAKAJgIgJPBEAgCSEBDAgLIANBBmoiBCAAKAJsIgJPBEAgBCEDDAELIAAoAmggBEECdGogACgCXCAJai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEBaiIJIAAoAmAiAk8EQCAJIQEMCAsgA0EBaiIEIAAoAmwiAk8EQCAEIQMMAQsgACgCaCAEQQJ0aiAAKAJcIAlqLQAAs0MAAADDkkMAAAA8lDgCACABQQRqIgkgACgCYCICTwRAIAkhAQwICyADQQRqIgQgACgCbCICTwRAIAQhAwwBCyAAKAJoIARBAnRqIAAoAlwgCWotAACzQwAAAMOSQwAAADyUOAIAIAFBB2oiCSAAKAJgIgJPBEAgCSEBDAgLIANBB2oiBCAAKAJsIgJPBEAgBCEDDAELIAAoAmggBEECdGogACgCXCAJai0AALNDAAAAw5JDAAAAPJQ4AgAgAUECaiIJIAAoAmAiAk8EQCAJIQEMCAsgA0ECaiIEIAAoAmwiAk8EQCAEIQMMAQsgACgCaCAEQQJ0aiAAKAJcIAlqLQAAs0MAAADDkkMAAAA8lDgCACABQQVqIgkgACgCYCICTwRAIAkhAQwICyADQQVqIgQgACgCbCICTwRAIAQhAwwBCyAAKAJoIARBAnRqIAAoAlwgCWotAACzQwAAAMOSQwAAADyUOAIAIAFBCGoiBCAAKAJgIgJPBEAgBCEBDAgLIANBCGoiAyAAKAJsIgJPDQAgACgCaCADQQJ0aiAAKAJcIARqLQAAs0MAAADDkkMAAAA8lDgCACAAKAKQAUEBSw0BDAILIAMgAkH81MEAEIwHAAsCQAJAIAFBCWoiAyAAKAJgIgpPDQAgDUEPbCAPaiICIAAoAmwiCk8NAyAAKAJoIAJBAnRqIAAoAlwgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBDGoiAyAAKAJgIgpPDQAgAkEDaiIEIAAoAmwiCk8EQCAEIQIMBAsgACgCaCAEQQJ0aiAAKAJcIANqLQAAs0MAAADDkkMAAAA8lDgCACABQQ9qIgMgACgCYCIKTw0AIAJBBmoiBCAAKAJsIgpPBEAgBCECDAQLIAAoAmggBEECdGogACgCXCADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUESaiIDIAAoAmAiCk8NACACQQlqIgQgACgCbCIKTwRAIAQhAgwECyAAKAJoIARBAnRqIAAoAlwgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBFWoiAyAAKAJgIgpPDQAgAkEMaiIEIAAoAmwiCk8EQCAEIQIMBAsgACgCaCAEQQJ0aiAAKAJcIANqLQAAs0MAAADDkkMAAAA8lDgCACABQQpqIgMgACgCYCIKTw0AIAJBAWoiBCAAKAJsIgpPBEAgBCECDAQLIAAoAmggBEECdGogACgCXCADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUENaiIDIAAoAmAiCk8NACACQQRqIgQgACgCbCIKTwRAIAQhAgwECyAAKAJoIARBAnRqIAAoAlwgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBEGoiAyAAKAJgIgpPDQAgAkEHaiIEIAAoAmwiCk8EQCAEIQIMBAsgACgCaCAEQQJ0aiAAKAJcIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRNqIgMgACgCYCIKTw0AIAJBCmoiBCAAKAJsIgpPBEAgBCECDAQLIAAoAmggBEECdGogACgCXCADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEWaiIDIAAoAmAiCk8NACACQQ1qIgQgACgCbCIKTwRAIAQhAgwECyAAKAJoIARBAnRqIAAoAlwgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBC2oiAyAAKAJgIgpPDQAgAkECaiIEIAAoAmwiCk8EQCAEIQIMBAsgACgCaCAEQQJ0aiAAKAJcIANqLQAAs0MAAADDkkMAAAA8lDgCACABQQ5qIgMgACgCYCIKTw0AIAJBBWoiBCAAKAJsIgpPBEAgBCECDAQLIAAoAmggBEECdGogACgCXCADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUERaiIDIAAoAmAiCk8NACACQQhqIgQgACgCbCIKTwRAIAQhAgwECyAAKAJoIARBAnRqIAAoAlwgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBFGoiAyAAKAJgIgpPDQAgAkELaiIEIAAoAmwiCk8EQCAEIQIMBAsgACgCaCAEQQJ0aiAAKAJcIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRdqIgMgACgCYCIKTw0AIAJBDmoiAiAAKAJsIgpPDQMgACgCaCACQQJ0aiAAKAJcIANqLQAAs0MAAADDkkMAAAA8lDgCACAAKAKQAUECTQ0CQQAhCiAMIQMMAQsgAyAKQczUwQAQjAcACwJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkADQCAAKAJgIgIgCiASaiIBQRhqSwRAIAcgCmoiBCAAKAJsIgJPDQ8gACgCaCADaiABIAAoAlxqQRhqLQAAs0MAAADDkkMAAAA8lDgCACAAKAJgIgIgAUEbak0NByAAKAJsIgIgBEEDak0NDiAAKAJoIANqQQxqIAEgACgCXGpBG2otAACzQwAAAMOSQwAAADyUOAIAIAAoAmAiAiABQR5qTQ0GIAAoAmwiAiAEQQZqTQ0NIAAoAmggA2pBGGogASAAKAJcakEeai0AALNDAAAAw5JDAAAAPJQ4AgAgACgCYCICIAFBIWpNDQUgACgCbCICIARBCWpNDQwgACgCaCADakEkaiABIAAoAlxqQSFqLQAAs0MAAADDkkMAAAA8lDgCACAAKAJgIgIgAUEkak0NBCAAKAJsIgIgBEEMak0NCyAAKAJoIANqQTBqIAEgACgCXGpBJGotAACzQwAAAMOSQwAAADyUOAIAIAAoAmAiAiABQSdqTQ0DIAAoAmwiAiAEQQ9qTQ0KIAAoAmggA2pBPGogASAAKAJcakEnai0AALNDAAAAw5JDAAAAPJQ4AgAgACgCYCICIAFBKmpNDQIgACgCbCICIARBEmpNDQkgACgCaCADakHIAGogACgCXCASaiAKakEqai0AALNDAAAAw5JDAAAAPJQ4AgAgA0EEaiEDIApBAWoiCkEDSQ0BDBALCyABQRhqDAYLIAFBKmoMBQsgAUEnagwECyABQSRqDAMLIAFBIWoMAgsgAUEeagwBCyABQRtqCyACQazUwQAQjAcACyAEQRJqIQQMBQsgBEEPaiEEDAQLIARBDGohBAwDCyAEQQlqIQQMAgsgBEEGaiEEDAELIARBA2ohBAsgBCACQbzUwQAQjAcACyAFIBJqIRIgB0EVaiEHIAxB1ABqIQwgBiAGIBBJIgJqIQEgAkUNAgwBCwsgAiAKQdzUwQAQjAcACyAAKAJsIQELAkACQAJAAkACQAJAIAEgD08EQCAAKAJoIQUgACgClAEhBEEAIQJBBCEKAkAgACgCkAEiA0ECSQRAQQQhB0EAIRIMAQsgEEEYbCIGIAFLDQIgEEEPbCESIAUgD0ECdGohByADQQJGDQAgASARSSAGIBFLcg0FIBEgBmshAiAFIAZBAnRqIQoLIAAgBCAQIAUgDyAHIBIgCiACENsDIAAoAmAiAiARSQ0CIABBADYCYCACIBFrIQEgC0UNAyACIBFGDQYgAUUNBSAAKAJcIgIgAiARaiAB/AoAAAwFC0EAIA8gAUGc1MEAEOoHAAsgDyAGIAFBjNTBABDqBwALQQAgESACQYSkxwAQ6gcACyACIBFHDQEMAgsgBiARIAFB/NPBABDqBwALIAAgATYCYAsgACAAKAKUASAQaiICNgKUASACIAAoAowBRw0MIABBADYClAEgAEEGOgCYAQwMCyABIAJB7NTBABCMBwALIAAoAmBBBEEDIAAoAogBIgNBA0YbIg1uIgIgACgCjAEgACgClAFrIgVJBEAgAiIFQYCABEkNDQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQYCABCAFIAVBgIAETxsiBkECdCICIAAoAmwiAUsEfyACIAFrIgcgACgCZCABa0sEQCAUIAEgB0EEQQQQpAUgACgCbCEBCyAAKAJoIgMgAUECdGohBCAHQQJPBH8gB0ECdEEEayICBEAgBEEAIAL8CwALIAEgB2oiAkEBayEBIAMgAkECdGpBBGsFIAQLQQA2AgAgACABQQFqNgJsIAAoAogBBSADC0EDRwRAIAVFDQxBACEEQQAhAUEAIQJBACEDA0AgASAAKAJgIglPDQIgAUEBaiIHIAlPDQMgAUECaiIHIAlPDQRDAACAPyAAKAJcIAFqIgctAACzQwAA/0KVQwAAgL+SIhwgHJQgB0EBai0AALNDAAD/QpVDAACAv5IiHSAdlJIgB0ECai0AALNDAAD/QpVDAACAv5IiGyAblJKTQwAAAAAQ4AghGiADIAAoAmwiB08NBSAAKAJoIAJqIBw4AgAgA0EBaiIJIAAoAmwiB08NBiAAKAJoIAJqQQRqIB04AgAgA0ECaiIJIAAoAmwiB08NByAAKAJoIAJqQQhqIBs4AgAgA0EDaiIJIAAoAmwiB08NCCAAKAJoIAJqQQxqIBqROAIAIAFBA2ohASACQRBqIQIgA0EEaiEDIARBAWoiBCAGSQ0ACwwLCyAFRQ0LQQAhAkEBIQdBACEDA0ACQAJAAkACQCAAKAJgIgEgA0sEQCADQQFqIhAgAU8NASADQQJqIhIgAU8NAiADQQNqIg8gAU8NAyAAKAJcIANqIgRBAmotAAAhCSAEQQNqLQAAIQwgBC0AACAEQQFqLQAAIQsgCP0MAAAAAAAAAAAAAAAAAAAAAP0LA1AgC0EIdHIiBCAJQRB0IAxBGHRyciEBQwAAAAAhGwJ/AkAgDEEGdiIJQQNHBEAgCCAEQf8DcbNDAID/Q5VD8wQ1P5QiGowgGiALQQJxGyIaOAJcIBogGpQhGyABQQp2IQEgCUECRg0BCyAIIAFB/wNxs0MAgP9DlUPzBDU/lCIajCAaIAFBgARxGyIaOAJYIBsgGiAalJIhGyABQQp2IgEgCUEBRg0BGgsgCCABQf8DcbNDAID/Q5VD8wQ1P5QiGowgGiABQYAEcRsiGjgCVCAbIBogGpSSIRsgAUEKdgshASAIQdAAaiAJQQJ0akMAAIA/IAxBwABPBH0gCCABQf8DcbNDAID/Q5VD8wQ1P5QiGowgGiABQYAEcRsiGjgCUCAbIBogGpSSBSAbC5MiGpFDAAAAACAaQwAAAABeGzgCACADIAAoAmwiAUkNBCADIAFBvNLBABCMBwALIAMgAUH80cEAEIwHAAsgECABQYzSwQAQjAcACyASIAFBnNLBABCMBwALIA8gAUGs0sEAEIwHAAsgACgCaCACaiAIKgJQOAIAIBAgACgCbCIBTw0KIAAoAmggAmpBBGogCCoCVDgCACASIAAoAmwiAU8NCSAAKAJoIAJqQQhqIAgqAlg4AgAgDyAAKAJsIgFPDQggACgCaCACakEMaiAIKgJcOAIAIAJBEGohAiADQQRqIQMgBiAHSyAHQQFqIQcNAAsMCgsgASAJQfzSwQAQjAcACyAHIAlBjNPBABCMBwALIAcgCUGc08EAEIwHAAsgAyAHQazTwQAQjAcACyAJIAdBvNPBABCMBwALIAkgB0HM08EAEIwHAAsgCSAHQdzTwQAQjAcACyAPIAFB7NLBABCMBwALIBIgAUHc0sEAEIwHAAsgECABQczSwQAQjAcACyAFRQ0AIAAoAmwhCyAAKAJoIQJBACEBIAAoAggiCSAAKAKUASIEayIDQQAgAyAJTRshAyAAKAIEIARBJGxqIQogBiEHA0AgA0UNAiABQQNqIAtPDQMgCCAC/QACAP0LBFAgAkEQaiECIAFBBGohASAEQQFqIQQgA0EBayEDIAogCEHQAGoQkAIgCkEkaiEKIAdBAWsiBw0ACwsgACgCYCIBIAYgDWwiAkkNFyAAQQA2AmAgASACayEDIAVFDQIgASACRg0EIANFDQMgACgCXCIBIAEgAmogA/wKAAAMAwsgBCAJQeTAxwAQjAcACyABIAFBBGogC0Gkx8cAEOoHAAsgASACRg0BCyAAIAM2AmALIAAgACgClAEgBmoiAjYClAEgAiAAKAKMAUcNCiAAQQA2ApQBIABBBToAmAEMCgsgACgCYCIBQQNuIgIgACgCjAEgACgClAFrIgVJBEAgAiEFIAFBgIAMSQ0MC0GAgAQgBSAFQYCABE8bIgtBA2wiBiAAKAJsIgFLBEAgBiABayIHIAAoAmQgAWtLBEAgFCABIAdBBEEEEKQFIAAoAmwhAQsgACgCaCIDIAFBAnRqIQQgB0ECTwR/IAdBAnRBBGsiAgRAIARBACAC/AsACyABIAdqIgJBAWshASADIAJBAnRqQQRrBSAEC0EANgIAIAAgAUEBajYCbAsCQAJAAkACQAJAAkACQAJAAkACQCAFBEBBACEDQQAhAQNAIAEgACgCYCICTw0CIAEgACgCbCICTw0DIAAoAmggA2ogACgCXCABai0AALNDAACAPZRDAAAgwZIQiQQ4AgAgAUEBaiIEIAAoAmAiAk8NBCAEIAAoAmwiAk8NBSAAKAJoIANqQQRqIAAoAlwgAWpBAWotAACzQwAAgD2UQwAAIMGSEIkEOAIAIAFBAmoiBCAAKAJgIgJPDQYgBCAAKAJsIgJPDQcgACgCaCADakEIaiAAKAJcIAFqQQJqLQAAs0MAAIA9lEMAACDBkhCJBDgCACADQQxqIQMgBiABQQNqIgFHDQALQQAhBCAAKAIIIgwgACgClAEiCmsiAkEAIAIgDE0bIQkgACgCBCAKQSRsaiECIAAoAmghAyAAKAJsIQ1BACEBA0AgASAJRg0eIARBA2oiByANSyABQdSq1aoFS3INCCAIIAP9XQIAIANBCGoqAgAiGv0gAiAa/SAD/QsEUCADQQxqIQMgAiAIQdAAahDdAiACQSRqIQIgByEEIAsgAUEBaiIBRw0ACwsgACgCYCICIAZJDR0gAEEANgJgIAIgBmshASAFRQ0HIAIgBkYNCSABRQ0IIAAoAlwiAiACIAZqIAH8CgAADAgLIAEgAkGc0cEAEIwHAAsgASACQazRwQAQjAcACyAEIAJBvNHBABCMBwALIAQgAkHM0cEAEIwHAAsgBCACQdzRwQAQjAcACyAEIAJB7NHBABCMBwALIAQgByANQfDKxwAQ6gcACyACIAZGDQELIAAgATYCYAsgACAAKAKUASALaiICNgKUASACIAAoAowBRw0JIABBADYClAEgAEEEOgCYAQwJCyAAKAJgIgFBA24iAiAAKAKMASAAKAKUAWsiBUkEQCACIQUgAUGAgAxJDQsLQYCABCAFIAVBgIAETxsiC0EDbCIGIAAoAmwiAUsEQCAGIAFrIgcgACgCZCABa0sEQCAUIAEgB0EEQQQQpAUgACgCbCEBCyAAKAJoIgMgAUECdGohBCAHQQJPBH8gB0ECdEEEayICBEAgBEEAIAL8CwALIAEgB2oiAkEBayEBIAMgAkECdGpBBGsFIAQLQQA2AgAgACABQQFqNgJsCwJAAkACQAJAAkACQAJAAkACQAJAIAUEQEEAIQNBACEBA0AgASAAKAJgIgJPDQIgASAAKAJsIgJPDQMgACgCaCADaiAAKAJcIAFqLQAAs0MAAH9DlUMAAAC/kkOMuPA/lEMAAAA/kjgCACABQQFqIgQgACgCYCICTw0EIAQgACgCbCICTw0FIAAoAmggA2pBBGogACgCXCABakEBai0AALNDAAB/Q5VDAAAAv5JDjLjwP5RDAAAAP5I4AgAgAUECaiIEIAAoAmAiAk8NBiAEIAAoAmwiAk8NByAAKAJoIANqQQhqIAAoAlwgAWpBAmotAACzQwAAf0OVQwAAAL+SQ4y48D+UQwAAAD+SOAIAIANBDGohAyAGIAFBA2oiAUcNAAtBACEEIAAoAggiDCAAKAKUASIKayICQQAgAiAMTRshCSAAKAIEIApBJGxqIQIgACgCaCEDIAAoAmwhDUEAIQEDQCABIAlGDR0gBEEDaiIHIA1LIAFB1KrVqgVLcg0IIAggA/1dAgAgA0EIaioCACIa/SACIBr9IAP9CwRQIANBDGohAyACIAhB0ABqEOUCIAJBJGohAiAHIQQgCyABQQFqIgFHDQALCyAAKAJgIgIgBkkNHCAAQQA2AmAgAiAGayEBIAVFDQcgAiAGRg0JIAFFDQggACgCXCICIAIgBmogAfwKAAAMCAsgASACQbzQwQAQjAcACyABIAJBzNDBABCMBwALIAQgAkHc0MEAEIwHAAsgBCACQezQwQAQjAcACyAEIAJB/NDBABCMBwALIAQgAkGM0cEAEIwHAAsgBCAHIA1BtMbHABDqBwALIAIgBkYNAQsgACABNgJgCyAAIAAoApQBIAtqIgI2ApQBIAIgACgCjAFHDQggAEEANgKUASAAQQM6AJgBDAgLIAAoAmAiAiAAKAKMASAAKAKUAWsiBEkEQCACIgRBgIAESQ0KC0GAgAQgBCAEQYCABE8bIgIgACgCbCIBSwRAIAIgAWsiByAAKAJkIAFrSwRAIBQgASAHQQRBBBCkBSAAKAJsIQELIAAoAmgiBSABQQJ0aiEGIAdBAk8EfyAHQQJ0QQRrIgMEQCAGQQAgA/wLAAsgASAHaiIDQQFrIQEgBSADQQJ0akEEawUgBgtBADYCACAAIAFBAWoiATYCbAsCQAJAAkACQAJAIAQEQEMAAIA/QwAAAEAgACwAmgFBAE4bIRpBACEDQQAhAQNAIAEgACgCYCIFTw0CIAEgACgCbCIFTw0DIAAoAmggA2ogGiAAKAJcIAFqLQAAs0MAAH9DlZQ4AgAgA0EEaiEDIAIgAUEBaiIBRw0ACyAAKAJsIQELIAAoAgQgACgCCCAAKAKUASACIAAoAmggARCrAiAAKAJgIgEgAkkNFCAAQQA2AmAgASACayEDIARFDQIgASACRg0EIANFDQMgACgCXCIBIAEgAmogA/wKAAAMAwsgASAFQZzQwQAQjAcACyABIAVBrNDBABCMBwALIAEgAkYNAQsgACADNgJgCyAAIAAoApQBIAJqIgI2ApQBIAIgACgCjAFHDQcgAEEANgKUASAAQQI6AJgBDAcLIARFDQFBASAALQCZAXSzIRpBACEHQQAhAUEAIQJBACEDAkACQAJAAkADQCABQQNqIgsgACgCYCIFSwRAIAEgCyAFQYzQwQAQ6gcACyADIAAoAmwiBU8NASAAKAJoIAJqIAAoAlwgAWoiBUECai0AACIGQRB0IAUtAAByIAVBAWotAABBCHRyIgVBgICAeHIgBSAGwEEASBuyIBqVOAIAIAFBBmoiCSAAKAJgIgVLDQIgA0EBaiIGIAAoAmwiBU8NAyAAKAJoIAJqQQRqIAAoAlwgAWoiBUEFai0AACIGQRB0IAVBA2otAAByIAVBBGotAABBCHRyIgVBgICAeHIgBSAGwEEASBuyIBqVOAIAIAFBCWoiBSAAKAJgIgZLDQQgA0ECaiIJIAAoAmwiBkkEQCAAKAJoIAJqQQhqIAAoAlwgAWoiAUEIai0AACIGQRB0IAFBBmotAAByIAFBB2otAABBCHRyIgFBgICAeHIgASAGwEEASBuyIBqVOAIAIAJBDGohAiADQQNqIQMgBSEBIAdBAWoiByAPSQ0BDAYLCyAJIAZB3M/BABCMBwALIAMgBUG8z8EAEIwHAAsgCyAJIAVB/M/BABDqBwALIAYgBUHMz8EAEIwHAAsgCSAFIAZB7M/BABDqBwALIARFDQAgACgCbCEJIAAoAmghA0EAIQcgACgCCCIMIAAoApQBIgprIgJBACACIAxNGyEGIAAoAgQgCkEkbGpBCGohAkEAIQEDQCABIAZGDQ8gB0EDaiIFIAlLIAFB1KrVqgVLcg0CIAIgA0EIaiAD/V0CAP1WAgACIh/9WgIIAiACIB/9WwIAACADQQxqIQMgAkEkaiECIAUhByAPIAFBAWoiAUcNAAsLIAAoAmAiASANIA9sIgJJDQwgAEEANgJgIAEgAmshAyAERQ0BIAEgAkYNAyADRQ0CIAAoAlwiASABIAJqIAP8CgAADAILIAcgBSAJQcTFxwAQ6gcACyABIAJGDQELIAAgAzYCYAsgACAAKAKUASAPaiICNgKUASACIAAoAowBRw0AIABBADYClAEgAEEBOgCYAQwACwALIAhBATYCVCAIQbTOwQA2AlAgCEIBNwJcIAggCEEsaq1CgICAgBCENwNAIAggCEFAazYCWCAIQTBqIgAgCEHQAGoQsQYgABCOByEBDAQLIAgtAA8hAQsgDiAVaiEOAkACQAJAAkACQCABQf8BcQ4DAQIDAAsgCEEBNgJUIAhBmPfHADYCUCAIQgE3AlwgCCAIQQ9qrUKAgICAoASENwNAIAggCEFAazYCWCAIQRBqIgAgCEHQAGoQsQYgABCOByEBDAYLIABBAToApVMgDkEIaiAOIAAoAkgiASAOayICQQAgASACTxtBB0sbIQ4MAgsgEyAVckUNAQsgDiAAKAJIIgNJDQELCyAORQ0AIA4gACgCSCICTQRAQQAhASAAQQA2AkggAiAORg0CIAIgDmsiAwRAIAAoAkQiAiACIA5qIAP8CgAACyAAIAM2AkgMAgtBACAOIAJBhKTHABDqBwALQQAhAQsgCEHwAGokACABDwtBACABIANBhKTHABDqBwALQQAgAiABQYSkxwAQ6gcACyABIApqIAxB5MDHABCMBwALQQAgBiACQYSkxwAQ6gcAC8pfBBt/BH0BewF+IwBB8ABrIgckAAJAAkACQAJAIAAtAMRTRQRAIAdB0ABqIABB4ABqELgEIActAFAEQCAHKAJUIQEMAwsgBy0AUUEBRw0BIABBAToAxFMLIAAoAmgiBEUNACAAQdkAaiEVIABBPGohFyAAQbwBaiEYIAdBPGqtQoCAgIAQhCEhIABB+ABqIRkgAEGEAWohFCAAQZABaiEaIABBnAFqIRsDQAJAIAAoAnQiAyAAKALAUyIBayICQQAgAiADTRtBgIAETwRAIAEhAgwBCyABIAFBgIACayICQQAgASACTxsiCGshAiABIAhGBEAgACACNgLAUwwBCyABIANNBEAgAgRAIAAoAnAiASABIAhqIAL8CgAACyAAKAJoIQQgACACNgLAUwwBC0EAIAEgA0HM1cEAEOoHAAsCQAJAIAQgDk8EQCAHQdAAaiAYIAAoAmQgDmogBCAOayAAKAJwIAAoAnQgAkEGEEQgByAHLQBUIgE6AA8gBygCUCEWIAcoAlgiE0UNAiAAKALAUyIIIBNqIgQgCE8gBCAAKAJ0IgJNcQ0BIAggBCACQdzVwQAQ6gcACyAOIAQgBEHs1cEAEOoHAAsgACgCcCEEIAAoAnggACgCgAEiAmsgE0kEQCAZIAIgE0EBQQEQpAUgACgCgAEhAgsgEwRAIAAoAnwgAmogBCAIaiAT/AoAAAsgACACIBNqIgY2AoABIAAgACgCwFMgE2o2AsBTIAAoAoQBQYCAgIB4RgRAAkAgBkEQSQ0AIAcgACgCfCINKAAAIgI2AhwgAkHOjs2CBUcEQCAHQQE2AmQgB0HMyMEANgJgIAdBATYCVCAHQdTOwQA2AlAgB0EBNgJcIAcgB0Ecaq1CgICAgJAEhDcDQCAHIAdBQGs2AlggB0EgaiIAIAdB0ABqELEGIAAQjgchAQwGCyAHIA0oAAQiAzYCLCADQQRrQX1PBEAgAEEANgKAASANLAAOIQUgDS0ADSEEIA0tAAwhCSANKAAIIQggBkEQayICBEAgAgRAIA0gDUEQaiAC/AoAAAsgACACNgKAAQsgByAJNgI8AkAgCUEDTQRAQYCAwAAQcSICDQEACyAHQQE2AlQgB0Gg7ccANgJQIAdCATcCXCAHICE3A2ggByAHQegAajYCWCAHQUBrIgAgB0HQAGoQsQYgABCQByEBDAcLIAAgBToAugEgACAEOgC5ASAAQQA6ALgBIABBADYCtAEgACAJNgKwASAAIAg2AqwBIAAgAzYCqAEgAEEANgKkASAAQoCAgIDAADcCnAEgAEICNwKUASAAQgA3AowBIAAgAjYCiAEgAEGAgBA2AoQBIAcgBUGAAXFBB3Y6AFggByAJNgJUIAcgCDYCUCAAIAdB0ABqEOkBIAVBAE4NAQJ9IAAtAFhBAkYEQP0MAAAAAAAAgD8AAEDBAAAQQSEgQwAAgD8hHkMAAIA/IR1DAACAPwwBCyAHQdIAaiAVQQJqLQAAOgAAIAcgFS8AADsBUCAAKgJQIR4gACoCTCEdIAD9AAI8ISAgACoCVAshHCAAQQE6AFggACAcOAJUIAAgHjgCUCAAIB04AkwgACAg/QsCPCAVIAcvAVA7AAAgFUECaiAHQdIAai0AADoAAAwBCyAHQQE2AlQgB0G0zsEANgJQIAdCATcCXCAHIAdBLGqtQoCAgIAQhDcDQCAHIAdBQGs2AlggB0EwaiIAIAdB0ABqELEGIAAQjgchAQwFCyAAKAKEAUGAgICAeEYNAQsDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AuAFBAWsOCQ0MCwoAAQYEFgILQQkhD0EGIQEgACgCsAEOBAQIBwYCCyAAQQlBByAALAC6AUEAThs6ALgBDBULIAAoAoABQQZBCSAAKAKoASIEQQFGGyINbiICIAAoAqwBIAAoArQBayIISQRAIAIiCEGAgARJDRQLQYCABCAIIAhBgIAETxsiD0EDbCICIAAoAowBIgFLBH8gAiABayIGIAAoAoQBIAFrSwRAIBQgASAGQQRBBBCkBSAAKAKMASEBCyAAKAKIASIEIAFBAnRqIQMgBkECTwR/IAZBAnRBBGsiAgRAIANBACAC/AsACyABIAZqIgJBAWshASAEIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYCjAEgACgCqAEFIAQLQQFHDQsgCEUNDUEAIQZBACEBQQAhAkEAIQQDQCABQQJqIQwgACgCgAEiAyABQQFqTQRAIAEgDCADQazPwQAQ6gcACwJ/IAAoAnwgAWoiA0EBai0AAEEIdCIJIAMtAAByIgNB//8BcUUEQCADQRB0DAELIANB/wdxIQsgCUGAgAJxIQUgCUGA+AFxIgNBgPgBRgRAIAVBEHQiA0GAgID8B3IgC0UNARogC0ENdCADckGAgID+B3IMAQsgBUEQdCIFIANBDXRBgICA/ABxIAtBDXRyQYCAgMADanIgAw0AGiALIAtnQRBrIgNB//8DcUEIanRB////A3EgBUGAgIDYA3IgA0EXdGtyCyEFAn8CQAJAIAAoAowBIgMgBEsEQCAAKAKIASACaiAFNgIAIAFBBGoiCyAAKAKAASIDSw0BIAAoAnwgAWoiA0EDai0AAEEIdCIJIANBAmotAAByIgNB//8BcUUEQCADQRB0DAQLIANB/wdxIQwgCUGAgAJxIQUgCUGA+AFxIgNBgPgBRgRAIAVBEHQiA0GAgID8B3IgDEUNBBogDEENdCADckGAgID+B3IMBAsgBUEQdCEFIANFDQIgA0ENdEGAgID8AHEgDEENdHJBgICAwANqIAVyDAMLIAQgA0HczsEAEIwHAAsgDCALIANBnM/BABDqBwALIAwgDGdBEGsiA0H//wNxQQhqdEH///8DcSAFQYCAgNgDciADQRd0a3ILIQkCfwJAAkAgBEEBaiIFIAAoAowBIgNJBEAgACgCiAEgAmpBBGogCTYCACABQQZqIgMgACgCgAEiBUsNASAAKAJ8IAFqIgFBBWotAABBCHQiCSABQQRqLQAAciIBQf//AXFFBEAgAUEQdAwECyABQf8HcSELIAlBgIACcSEFIAlBgPgBcSIBQYD4AUYEQCAFQRB0IgFBgICA/AdyIAtFDQQaIAtBDXQgAXJBgICA/gdyDAQLIAVBEHQhBSABRQ0CIAFBDXRBgICA/ABxIAtBDXRyQYCAgMADaiAFcgwDCyAFIANB7M7BABCMBwALIAsgAyAFQYzPwQAQ6gcACyALIAtnQRBrIgFB//8DcUEIanRB////A3EgBUGAgIDYA3IgAUEXdGtyCyEJIARBAmoiBSAAKAKMASIBSQRAIAAoAogBIAJqQQhqIAk2AgAgAkEMaiECIARBA2ohBCADIQEgBkEBaiIGIA9JDQEMDgsLIAUgAUH8zsEAEIwHAAtB7NPBABCBCAALIAAoAoABIgFBAnYiAiAAKAKsASAAKAK0AWsiA0kEQCACIQMgAUGAgBBJDRILQYCABCADIANBgIAETxsiBSAAKAKkASIBSwRAIAUgAWsiBiAAKAKcASABa0sEQCAbIAEgBkEEQQQQpAUgACgCpAEhAQsgACgCoAEiBCABQQJ0aiEIIAZBAk8EfyAGQQJ0QQRrIgIEQCAIQQAgAvwLAAsgASAGaiICQQFrIQEgBCACQQJ0akEEawUgCAtBADYCACAAIAFBAWoiATYCpAELIAMEQEEAIQFBACEEAkADQCAAKAKAASICIAFBA2pNBEAgASABQQRqIAJBvNXBABDqBwALIAAoAqQBIgIgBEsEQCAAKAKgASABaiAAKAJ8IAFqKAAANgIAIAFBBGohASAFIARBAWoiBEYNAgwBCwsgBCACQazVwQAQjAcACyAAKAKkASEBCyAAKAIQIAAoAhQgACgCtAEgBSAAKAKgASABEI0DAkACQAJAIAAoAoABIgQgBUECdCIBTwRAIABBADYCgAEgBCABayEIIANFDQEgASAERg0DIAhFDQIgACgCfCICIAEgAmogCPwKAAAMAgsMGgsgASAERg0BCyAAIAg2AoABCyAAIAAoArQBIAVqIgI2ArQBIAIgACgCrAFHDRIgAEEANgK0AUEJIQELIAAgAToAuAEMEQsgACgCgAEiAUEBdiICIAAoAqwBIAAoArQBayIDSQRAIAIhAyABQYCACEkNEAtBgIAEIAMgA0GAgARPGyIFIAAoApgBIgFLBEAgBSABayIGIAAoApABIAFrSwRAIBogASAGQQJBAhCkBSAAKAKYASEBCyAAKAKUASIEIAFBAXRqIQggBkECTwR/IAZBAXRBAmsiAgRAIAhBACAC/AsACyABIAZqIgJBAWshASAEIAJBAXRqQQJrBSAIC0EAOwEAIAAgAUEBaiIBNgKYAQsgAwRAQQAhBEECIQECQANAIAAoAoABIgIgAUkEQCABQQJrIAEgAkGc1cEAEOoHAAsgACgCmAEiAiAESwRAIAAoApQBIAFqQQJrIAAoAnwgAWpBAmsvAAA7AQAgAUECaiEBIAUgBEEBaiIERg0CDAELCyAEIAJBjNXBABCMBwALIAAoApgBIQELIAAoAhAgACgCFCAAKAK0ASAFIAAoApQBIAEQswMCQAJAAkAgACgCgAEiBCAFQQF0IgFPBEAgAEEANgKAASAEIAFrIQggA0UNASABIARGDQMgCEUNAiAAKAJ8IgIgASACaiAI/AoAAAwCCwwYCyABIARGDQELIAAgCDYCgAELIAAgACgCtAEgBWoiAjYCtAEgAiAAKAKsAUcNECAAQQA2ArQBIABBCDoAuAEMEAtBLSEPDAELQRghDwsgACgCgAEgD24iAiAAKAKsASAAKAK0AWsiC0kEQCACIgtBgIAESQ0NC0GAgAQgCyALQYCABE8bIhAgD2wiESAAKAKMASIBSwRAIBEgAWsiAyAAKAKEASABa0sEQCAUIAEgA0EEQQQQpAUgACgCjAEhAQsgACgCiAEiBCABQQJ0aiEIIANBAk8EfyADQQJ0QQRrIgIEQCAIQQAgAvwLAAsgASADaiICQQFrIQEgBCACQQJ0akEEawUgCAtBADYCACAAIAFBAWoiATYCjAELIBBBCWwhDAJAIAsEQCAQQeAAbCENIBBBGGwhBkEBIQFBACESQQAhCAJAA0AgCCEJIAEhCCAJIA9sIgEgACgCgAEiAk8NAwJAAkACQAJAIAlBCWwiBCAAKAKMASICTw0AIAAoAogBIARBAnRqIAAoAnwgAWotAACzQwAAAMOSQwAAADyUOAIAIAFBA2oiBSAAKAKAASICTwRAIAUhAQwICyAEQQNqIgMgACgCjAEiAk8EQCADIQQMAQsgACgCiAEgA0ECdGogACgCfCAFai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEGaiIFIAAoAoABIgJPBEAgBSEBDAgLIARBBmoiAyAAKAKMASICTwRAIAMhBAwBCyAAKAKIASADQQJ0aiAAKAJ8IAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQFqIgUgACgCgAEiAk8EQCAFIQEMCAsgBEEBaiIDIAAoAowBIgJPBEAgAyEEDAELIAAoAogBIANBAnRqIAAoAnwgBWotAACzQwAAAMOSQwAAADyUOAIAIAFBBGoiBSAAKAKAASICTwRAIAUhAQwICyAEQQRqIgMgACgCjAEiAk8EQCADIQQMAQsgACgCiAEgA0ECdGogACgCfCAFai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEHaiIFIAAoAoABIgJPBEAgBSEBDAgLIARBB2oiAyAAKAKMASICTwRAIAMhBAwBCyAAKAKIASADQQJ0aiAAKAJ8IAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQJqIgUgACgCgAEiAk8EQCAFIQEMCAsgBEECaiIDIAAoAowBIgJPBEAgAyEEDAELIAAoAogBIANBAnRqIAAoAnwgBWotAACzQwAAAMOSQwAAADyUOAIAIAFBBWoiBSAAKAKAASICTwRAIAUhAQwICyAEQQVqIgMgACgCjAEiAk8EQCADIQQMAQsgACgCiAEgA0ECdGogACgCfCAFai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEIaiIDIAAoAoABIgJPBEAgAyEBDAgLIARBCGoiBCAAKAKMASICTw0AIAAoAogBIARBAnRqIAAoAnwgA2otAACzQwAAAMOSQwAAADyUOAIAIAAoArABQQFLDQEMAgsgBCACQfzUwQAQjAcACwJAAkAgAUEJaiIEIAAoAoABIgpPDQAgCUEPbCAMaiICIAAoAowBIgpPDQMgACgCiAEgAkECdGogACgCfCAEai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEMaiIEIAAoAoABIgpPDQAgAkEDaiIDIAAoAowBIgpPBEAgAyECDAQLIAAoAogBIANBAnRqIAAoAnwgBGotAACzQwAAAMOSQwAAADyUOAIAIAFBD2oiBCAAKAKAASIKTw0AIAJBBmoiAyAAKAKMASIKTwRAIAMhAgwECyAAKAKIASADQQJ0aiAAKAJ8IARqLQAAs0MAAADDkkMAAAA8lDgCACABQRJqIgQgACgCgAEiCk8NACACQQlqIgMgACgCjAEiCk8EQCADIQIMBAsgACgCiAEgA0ECdGogACgCfCAEai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEVaiIEIAAoAoABIgpPDQAgAkEMaiIDIAAoAowBIgpPBEAgAyECDAQLIAAoAogBIANBAnRqIAAoAnwgBGotAACzQwAAAMOSQwAAADyUOAIAIAFBCmoiBCAAKAKAASIKTw0AIAJBAWoiAyAAKAKMASIKTwRAIAMhAgwECyAAKAKIASADQQJ0aiAAKAJ8IARqLQAAs0MAAADDkkMAAAA8lDgCACABQQ1qIgQgACgCgAEiCk8NACACQQRqIgMgACgCjAEiCk8EQCADIQIMBAsgACgCiAEgA0ECdGogACgCfCAEai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEQaiIEIAAoAoABIgpPDQAgAkEHaiIDIAAoAowBIgpPBEAgAyECDAQLIAAoAogBIANBAnRqIAAoAnwgBGotAACzQwAAAMOSQwAAADyUOAIAIAFBE2oiBCAAKAKAASIKTw0AIAJBCmoiAyAAKAKMASIKTwRAIAMhAgwECyAAKAKIASADQQJ0aiAAKAJ8IARqLQAAs0MAAADDkkMAAAA8lDgCACABQRZqIgQgACgCgAEiCk8NACACQQ1qIgMgACgCjAEiCk8EQCADIQIMBAsgACgCiAEgA0ECdGogACgCfCAEai0AALNDAAAAw5JDAAAAPJQ4AgAgAUELaiIEIAAoAoABIgpPDQAgAkECaiIDIAAoAowBIgpPBEAgAyECDAQLIAAoAogBIANBAnRqIAAoAnwgBGotAACzQwAAAMOSQwAAADyUOAIAIAFBDmoiBCAAKAKAASIKTw0AIAJBBWoiAyAAKAKMASIKTwRAIAMhAgwECyAAKAKIASADQQJ0aiAAKAJ8IARqLQAAs0MAAADDkkMAAAA8lDgCACABQRFqIgQgACgCgAEiCk8NACACQQhqIgMgACgCjAEiCk8EQCADIQIMBAsgACgCiAEgA0ECdGogACgCfCAEai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEUaiIEIAAoAoABIgpPDQAgAkELaiIDIAAoAowBIgpPBEAgAyECDAQLIAAoAogBIANBAnRqIAAoAnwgBGotAACzQwAAAMOSQwAAADyUOAIAIAFBF2oiBCAAKAKAASIKTw0AIAJBDmoiAiAAKAKMASIKTw0DIAAoAogBIAJBAnRqIAAoAnwgBGotAACzQwAAAMOSQwAAADyUOAIAIAAoArABQQJNDQJBACEKIA0hBAwBCyAEIApBzNTBABCMBwALAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQANAIAAoAoABIgIgCiASaiIBQRhqSwRAIAYgCmoiAyAAKAKMASICTw0PIAAoAogBIARqIAEgACgCfGpBGGotAACzQwAAAMOSQwAAADyUOAIAIAAoAoABIgIgAUEbak0NByAAKAKMASICIANBA2pNDQ4gACgCiAEgBGpBDGogASAAKAJ8akEbai0AALNDAAAAw5JDAAAAPJQ4AgAgACgCgAEiAiABQR5qTQ0GIAAoAowBIgIgA0EGak0NDSAAKAKIASAEakEYaiABIAAoAnxqQR5qLQAAs0MAAADDkkMAAAA8lDgCACAAKAKAASICIAFBIWpNDQUgACgCjAEiAiADQQlqTQ0MIAAoAogBIARqQSRqIAEgACgCfGpBIWotAACzQwAAAMOSQwAAADyUOAIAIAAoAoABIgIgAUEkak0NBCAAKAKMASICIANBDGpNDQsgACgCiAEgBGpBMGogASAAKAJ8akEkai0AALNDAAAAw5JDAAAAPJQ4AgAgACgCgAEiAiABQSdqTQ0DIAAoAowBIgIgA0EPak0NCiAAKAKIASAEakE8aiABIAAoAnxqQSdqLQAAs0MAAADDkkMAAAA8lDgCACAAKAKAASICIAFBKmpNDQIgACgCjAEiAiADQRJqTQ0JIAAoAogBIARqQcgAaiAAKAJ8IBJqIApqQSpqLQAAs0MAAADDkkMAAAA8lDgCACAEQQRqIQQgCkEBaiIKQQNJDQEMEAsLIAFBGGoMBgsgAUEqagwFCyABQSdqDAQLIAFBJGoMAwsgAUEhagwCCyABQR5qDAELIAFBG2oLIAJBrNTBABCMBwALIANBEmohAwwFCyADQQ9qIQMMBAsgA0EMaiEDDAMLIANBCWohAwwCCyADQQZqIQMMAQsgA0EDaiEDCyADIAJBvNTBABCMBwALIA8gEmohEiAGQRVqIQYgDUHUAGohDSAIIAggEEkiAmohASACRQ0CDAELCyACIApB3NTBABCMBwALIAAoAowBIQELAkACQAJAAkACQAJAIAEgDE8EQCAAKAKIASEDIAAoArQBIQhBACECQQQhCgJAIAAoArABIgRBAkkEQEEEIQZBACESDAELIBBBGGwiBSABSw0CIBBBD2whEiADIAxBAnRqIQYgBEECRg0AIAEgEUkgBSARS3INByARIAVrIQIgAyAFQQJ0aiEKCyAAIAggECADIAwgBiASIAogAhDqBCAAKAKAASICIBFJDQIgAEEANgKAASACIBFrIQEgC0UNAyACIBFGDQUgAUUNBCAAKAJ8IgIgAiARaiAB/AoAAAwEC0EAIAwgAUGc1MEAEOoHAAsgDCAFIAFBjNTBABDqBwALQQAgESACQYSkxwAQ6gcACyACIBFGDQELIAAgATYCgAELIAAgACgCtAEgEGoiAjYCtAEgAiAAKAKsAUcNDyAAQQA2ArQBIABBBjoAuAEMDwsgBSARIAFB/NPBABDqBwALIAEgAkHs1MEAEIwHAAsgACgCgAFBBEEDIAAoAqgBIgRBA0YbIg1uIgIgACgCrAEgACgCtAFrIghJBEAgAiIIQYCABEkNDAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQYCABCAIIAhBgIAETxsiBUECdCICIAAoAowBIgFLBH8gAiABayIGIAAoAoQBIAFrSwRAIBQgASAGQQRBBBCkBSAAKAKMASEBCyAAKAKIASIEIAFBAnRqIQMgBkECTwR/IAZBAnRBBGsiAgRAIANBACAC/AsACyABIAZqIgJBAWshASAEIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYCjAEgACgCqAEFIAQLQQNHBEAgCEUNDEEAIQNBACEBQQAhAkEAIQQDQCABIAAoAoABIglPDQIgAUEBaiIGIAlPDQMgAUECaiIGIAlPDQRDAACAPyAAKAJ8IAFqIgYtAACzQwAA/0KVQwAAgL+SIh8gH5QgBkEBai0AALNDAAD/QpVDAACAv5IiHiAelJIgBkECai0AALNDAAD/QpVDAACAv5IiHSAdlJKTQwAAAAAQ4AghHCAEIAAoAowBIgZPDQUgACgCiAEgAmogHzgCACAEQQFqIgkgACgCjAEiBk8NBiAAKAKIASACakEEaiAeOAIAIARBAmoiCSAAKAKMASIGTw0HIAAoAogBIAJqQQhqIB04AgAgBEEDaiIJIAAoAowBIgZPDQggACgCiAEgAmpBDGogHJE4AgAgAUEDaiEBIAJBEGohAiAEQQRqIQQgA0EBaiIDIAVJDQALDAsLIAhFDQtBACECQQEhBkEAIQQDQAJAAkACQAJAIAAoAoABIgEgBEsEQCAEQQFqIhAgAU8NASAEQQJqIhIgAU8NAiAEQQNqIg8gAU8NAyAAKAJ8IARqIgNBAmotAAAhCSADQQNqLQAAIQwgAy0AACADQQFqLQAAIQsgB/0MAAAAAAAAAAAAAAAAAAAAAP0LA1AgC0EIdHIiAyAJQRB0IAxBGHRyciEBQwAAAAAhHQJ/AkAgDEEGdiIJQQNHBEAgByADQf8DcbNDAID/Q5VD8wQ1P5QiHIwgHCALQQJxGyIcOAJcIBwgHJQhHSABQQp2IQEgCUECRg0BCyAHIAFB/wNxs0MAgP9DlUPzBDU/lCIcjCAcIAFBgARxGyIcOAJYIB0gHCAclJIhHSABQQp2IgEgCUEBRg0BGgsgByABQf8DcbNDAID/Q5VD8wQ1P5QiHIwgHCABQYAEcRsiHDgCVCAdIBwgHJSSIR0gAUEKdgshASAHQdAAaiAJQQJ0akMAAIA/IAxBwABPBH0gByABQf8DcbNDAID/Q5VD8wQ1P5QiHIwgHCABQYAEcRsiHDgCUCAdIBwgHJSSBSAdC5MiHJFDAAAAACAcQwAAAABeGzgCACAEIAAoAowBIgFJDQQgBCABQbzSwQAQjAcACyAEIAFB/NHBABCMBwALIBAgAUGM0sEAEIwHAAsgEiABQZzSwQAQjAcACyAPIAFBrNLBABCMBwALIAAoAogBIAJqIAcqAlA4AgAgECAAKAKMASIBTw0KIAAoAogBIAJqQQRqIAcqAlQ4AgAgEiAAKAKMASIBTw0JIAAoAogBIAJqQQhqIAcqAlg4AgAgDyAAKAKMASIBTw0IIAAoAogBIAJqQQxqIAcqAlw4AgAgAkEQaiECIARBBGohBCAFIAZLIAZBAWohBg0ACwwKCyABIAlB/NLBABCMBwALIAYgCUGM08EAEIwHAAsgBiAJQZzTwQAQjAcACyAEIAZBrNPBABCMBwALIAkgBkG808EAEIwHAAsgCSAGQczTwQAQjAcACyAJIAZB3NPBABCMBwALIA8gAUHs0sEAEIwHAAsgEiABQdzSwQAQjAcACyAQIAFBzNLBABCMBwALIAhFDQAgACgCjAEhDCAAKAKIASEKQQAhBCAAKAIIIgsgACgCtAEiA2siAkEAIAIgC00bIQIgACgCBCADQRhsakEUaiEBIAUhBgNAIAJFDQIgBEEDaiAMTw0DIAcgCv0AAgD9CwRQIAFBAmogB0HQAGoQnQQiCUEQdjoAACABIAk7AQAgCkEQaiEKIARBBGohBCABQRhqIQEgA0EBaiEDIAJBAWshAiAGQQFrIgYNAAsLIAAoAoABIgEgBSANbCICSQ0XIABBADYCgAEgASACayEEIAhFDQIgASACRg0EIARFDQMgACgCfCIBIAEgAmogBPwKAAAMAwsgAyALQey7xwAQjAcACyAEIARBBGogDEHUxMcAEOoHAAsgASACRg0BCyAAIAQ2AoABCyAAIAAoArQBIAVqIgI2ArQBIAIgACgCrAFHDQwgAEEANgK0ASAAQQU6ALgBDAwLIAAoAoABIgFBA24iAiAAKAKsASAAKAK0AWsiCEkEQCACIQggAUGAgAxJDQsLQYCABCAIIAhBgIAETxsiC0EDbCIMIAAoAowBIgFLBEAgDCABayIGIAAoAoQBIAFrSwRAIBQgASAGQQRBBBCkBSAAKAKMASEBCyAAKAKIASIEIAFBAnRqIQMgBkECTwR/IAZBAnRBBGsiAgRAIANBACAC/AsACyABIAZqIgJBAWshASAEIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYCjAELAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAgEQEEAIQRBACEBA0AgASAAKAKAASICTw0CIAEgACgCjAEiAk8NAyAAKAKIASAEaiAAKAJ8IAFqLQAAs0MAAIA9lEMAACDBkhCJBDgCACABQQFqIgMgACgCgAEiAk8NBCADIAAoAowBIgJPDQUgACgCiAEgBGpBBGogACgCfCABakEBai0AALNDAACAPZRDAAAgwZIQiQQ4AgAgAUECaiIDIAAoAoABIgJPDQYgAyAAKAKMASICTw0HIAAoAogBIARqQQhqIAAoAnwgAWpBAmotAACzQwAAgD2UQwAAIMGSEIkEOAIAIARBDGohBCAMIAFBA2oiAUcNAAsgACgCtAEiCUEYbCECIAAoAogBIQQgACgCjAEhDUEAIQNBACEBA0AgASAJaiIFIAAoAggiBk8NCCADQQNqIgYgDUsgAUHUqtWqBUtyDQkgACgCBCACaiAXIAT9XQIAIARBCGoqAgAiHP0gAiAc/SADEN8EIARBDGohBCACQRhqIQIgBiEDIAsgAUEBaiIBRw0ACwsgACgCgAEiAiAMSQ0IIABBADYCgAEgAiAMayEBIAhFDQkgAiAMRg0LIAFFDQogACgCfCICIAIgDGogAfwKAAAMCgsgASACQZzRwQAQjAcACyABIAJBrNHBABCMBwALIAMgAkG80cEAEIwHAAsgAyACQczRwQAQjAcACyADIAJB3NHBABCMBwALIAMgAkHs0cEAEIwHAAsgBSAGQey7xwAQjAcACyADIAYgDUG0xccAEOoHAAtBACAMIAJBhKTHABDqBwALIAIgDEYNAQsgACABNgKAAQsgACAAKAK0ASALaiICNgK0ASACIAAoAqwBRw0LIABBADYCtAEgAEEEOgC4AQwLCyAAKAKAASIBQQNuIgIgACgCrAEgACgCtAFrIgZJBEAgAiEGIAFBgIAMSQ0KC0GAgAQgBiAGQYCABE8bIgNBA2wiCSAAKAKMASIBSwRAIAkgAWsiBSAAKAKEASABa0sEQCAUIAEgBUEEQQQQpAUgACgCjAEhAQsgACgCiAEiBCABQQJ0aiEIIAVBAk8EfyAFQQJ0QQRrIgIEQCAIQQAgAvwLAAsgASAFaiICQQFrIQEgBCACQQJ0akEEawUgCAtBADYCACAAIAFBAWoiATYCjAELAkACQAJAAkACQAJAAkACQAJAAkAgBgRAQQAhBEEAIQEDQCABIAAoAoABIgJPDQIgASAAKAKMASICTw0DIAAoAogBIARqIAAoAnwgAWotAACzQwAAf0OVQwAAAL+SQ4y48D+UQwAAAD+SOAIAIAFBAWoiCCAAKAKAASICTw0EIAggACgCjAEiAk8NBSAAKAKIASAEakEEaiAAKAJ8IAFqQQFqLQAAs0MAAH9DlUMAAAC/kkOMuPA/lEMAAAA/kjgCACABQQJqIgggACgCgAEiAk8NBiAIIAAoAowBIgJPDQcgACgCiAEgBGpBCGogACgCfCABakECai0AALNDAAB/Q5VDAAAAv5JDjLjwP5RDAAAAP5I4AgAgBEEMaiEEIAkgAUEDaiIBRw0ACyAAKAKMASEBCyAAIAAoArQBIAMgACgCiAEgARCkBCAAKAKAASICIAlJDQYgAEEANgKAASACIAlrIQEgBkUNByACIAlGDQkgAUUNCCAAKAJ8IgIgAiAJaiAB/AoAAAwICyABIAJBvNDBABCMBwALIAEgAkHM0MEAEIwHAAsgCCACQdzQwQAQjAcACyAIIAJB7NDBABCMBwALIAggAkH80MEAEIwHAAsgCCACQYzRwQAQjAcAC0EAIAkgAkGEpMcAEOoHAAsgAiAJRg0BCyAAIAE2AoABCyAAIAAoArQBIANqIgI2ArQBIAIgACgCrAFHDQogAEEANgK0ASAAQQM6ALgBDAoLIAAoAoABIgIgACgCrAEgACgCtAFrIgNJBEAgAiIDQYCABEkNCQtBgIAEIAMgA0GAgARPGyICIAAoAowBIgFLBEAgAiABayIFIAAoAoQBIAFrSwRAIBQgASAFQQRBBBCkBSAAKAKMASEBCyAAKAKIASIIIAFBAnRqIQYgBUECTwR/IAVBAnRBBGsiBARAIAZBACAE/AsACyABIAVqIgRBAWshASAIIARBAnRqQQRrBSAGC0EANgIAIAAgAUEBaiIBNgKMAQsCQAJAAkACQAJAIAMEQEMAAIA/QwAAAEAgACwAugFBAE4bIRxBACEEQQAhAQNAIAEgACgCgAEiCE8NAiABIAAoAowBIghPDQMgACgCiAEgBGogHCAAKAJ8IAFqLQAAs0MAAH9DlZQ4AgAgBEEEaiEEIAIgAUEBaiIBRw0ACyAAKAKMASEBCyAAKAIEIAAoAgggACgCtAEgAiAAKAKIASABEKoCIAAoAoABIgEgAkkNFCAAQQA2AoABIAEgAmshBCADRQ0CIAEgAkYNBCAERQ0DIAAoAnwiASABIAJqIAT8CgAADAMLIAEgCEGc0MEAEIwHAAsgASAIQazQwQAQjAcACyABIAJGDQELIAAgBDYCgAELIAAgACgCtAEgAmoiAjYCtAEgAiAAKAKsAUcNCSAAQQA2ArQBIABBAjoAuAEMCQsgCEUNAUEBIAAtALkBdLMhHEEAIQZBACEBQQAhAkEAIQQCQAJAAkACQANAIAFBA2oiCyAAKAKAASIDSwRAIAEgCyADQYzQwQAQ6gcACyAEIAAoAowBIgNPDQEgACgCiAEgAmogACgCfCABaiIDQQJqLQAAIgVBEHQgAy0AAHIgA0EBai0AAEEIdHIiA0GAgIB4ciADIAXAQQBIG7IgHJU4AgAgAUEGaiIJIAAoAoABIgNLDQIgBEEBaiIFIAAoAowBIgNPDQMgACgCiAEgAmpBBGogACgCfCABaiIDQQVqLQAAIgVBEHQgA0EDai0AAHIgA0EEai0AAEEIdHIiA0GAgIB4ciADIAXAQQBIG7IgHJU4AgAgAUEJaiIDIAAoAoABIgVLDQQgBEECaiIJIAAoAowBIgVJBEAgACgCiAEgAmpBCGogACgCfCABaiIBQQhqLQAAIgVBEHQgAUEGai0AAHIgAUEHai0AAEEIdHIiAUGAgIB4ciABIAXAQQBIG7IgHJU4AgAgAkEMaiECIARBA2ohBCADIQEgBkEBaiIGIA9JDQEMBgsLIAkgBUHcz8EAEIwHAAsgBCADQbzPwQAQjAcACyALIAkgA0H8z8EAEOoHAAsgBSADQczPwQAQjAcACyAJIAMgBUHsz8EAEOoHAAsgCEUNACAAKAKMASEMIAAoAogBIQRBACEGIAAoAggiCyAAKAK0ASIJayICQQAgAiALTRshBSAAKAIEIAlBGGxqIQJBACEBA0AgASAFRg0CIAZBA2oiAyAMSyABQdSq1aoFS3INAyACIARBCGogBP1dAgD9VgIAAiIg/VoCCAIgAiAg/VsCAAAgBEEMaiEEIAJBGGohAiADIQYgDyABQQFqIgFHDQALCyAAKAKAASIBIA0gD2wiAkkNDCAAQQA2AoABIAEgAmshBCAIRQ0CIAEgAkYNBCAERQ0DIAAoAnwiASABIAJqIAT8CgAADAMLIAEgCWogC0Hsu8cAEIwHAAsgBiADIAxB9MLHABDqBwALIAEgAkYNAQsgACAENgKAAQsgACAAKAK0ASAPaiICNgK0ASACIAAoAqwBRw0BIABBADYCtAEgAEEBOgC4AQwBCwsgBy0ADyEBCyAOIBZqIQ4CQAJAAkACQAJAIAFB/wFxDgMBAgMACyAHQQE2AlQgB0GY98cANgJQIAdCATcCXCAHIAdBD2qtQoCAgICgBIQ3A0AgByAHQUBrNgJYIAdBEGoiACAHQdAAahCxBiAAEI4HIQEMBgsgAEEBOgDFUyAOQQhqIA4gACgCaCIBIA5rIgJBACABIAJPG0EHSxshDgwCCyATIBZyRQ0BCyAOIAAoAmgiBEkNAQsLIA5FDQAgDiAAKAJoIgJNBEBBACEBIABBADYCaCACIA5GDQIgAiAOayIEBEAgACgCZCICIAIgDmogBPwKAAALIAAgBDYCaAwCC0EAIA4gAkGEpMcAEOoHAAtBACEBCyAHQfAAaiQAIAEPC0EAIAEgBEGEpMcAEOoHAAtBACACIAFBhKTHABDqBwALzF8EE38SfQh7BH4jAEGQBWsiCiQAIAAoAgghFiAKQQA2AtADIApBADYC1AQgCiAANgKoASAKIAEgAkECdCIMaiIUNgKkASAKIAE2AqABIApB1ANqIQkgCkHUBGohBkEgIQcCQAJAAkACQAJAAn8gAkEhSQRAIAYhCCAJDAELIApBEGogCkHQA2pBfyACQQFrZ3ZBAWoQ9AMgCigCECIIQYGAgIB4RwRAIAgNAkHYlccAQRFB1MzHABDrBwALIAooAtQEIgdBIUkEQCAHIQQgBiEIQSAhByAJDAELIAooAtQDIQQgCSEIIAooAtgDCyEFAkACQCAIIAQgB0kEfyAFIARBAnRqIQUDQCAKQQhqIApBoAFqEMMEIAooAghBAXFFDQIgBSAKKgIMOAIAIAVBBGohBSAHIARBAWoiBEcNAAsgBwUgBAs2AgAgCkEgaiAKQagBaigCADYCACAKIAopAqABNwMYA0AgCiAKQRhqEMMEIAooAgBBAXFFDQICfyAKKALUBCIHQSFJBEAgByEFIAkhCEEgIQcgBgwBCyAKKALUAyEFIAooAtgDIQggCQshBCAKKgIEIRcgBSAHRgR/IApB0ANqENMGIAooAtgDIQggCSEEIAooAtQDBSAFC0ECdCAIaiAXOAIAIAQgBCgCAEEBajYCAAwACwALIAggBDYCAAsgCkEYaiAKQdADakGIAfwKAAACQAJ/IAooApwBIglBIU8EQCAKKAIgIQYgCigCHAwBCyAKQRxqIQYgCQsiCEUEQEMAAACAIRsMAQsgCEEDcSEEAkAgCEEESQRAQQAhB0MAAACAIRsMAQsgCEF8cSEIQQAhB0MAAACAIRsgBiEFA0AgGyAFKgIAkiAFQQRqKgIAkiAFQQhqKgIAkiAFQQxqKgIAkiEbIAVBEGohBSAIIAdBBGoiB0cNAAsLIARFDQAgBiAHQQJ0aiEFA0AgGyAFKgIAkiEbIAVBBGohBSAEQQFrIgQNAAsLIBtDYEKiDRDgCCEnIApBHGoiFSEIIAlBIU8EQCAKKAIcIQkgCigCICEICwJAIAlFDQAgCCEFIAlBAnQiC0EEayIEQQxPBEAgBSAEQQJ2QQFqIgZB/P///wdxIglBAnRqIQUgJ/0TISkgCSEHIAghBANAIAQgBP0AAgAgKf3nAf0LAgAgBEEQaiEEIAdBBGsiBw0ACyAGIAlGDQELIAggC2ohCANAIAUgBSoCACAnlTgCACAFQQRqIgUgCEcNAAsLIAJFBEAgCkIANwOwAUMAAAAAIRsMBQsgCigCHCAKKAKcASIIIAhBIEsiCBshDyAMQQRrQQJ2QQFqIQwgACgCBCELIAAoAgghDSAKKAIgIBUgCBsiCSEIQQAhByABQQRqIgUhBCABIQYDQCAGKAIAIgYgDU8NAiAHIA9PDQMgCyAGQSRsaiIGKgIMIRogBioCCCEYIAYqAhAgCCoCACEZIApB0ANqIAYQpAMgCv0ABNADIin9HwIgGSAt/R8CELQG/RMgKf0fACAZIC39HwAQtAb9IAAgKf0fASAZIC39HwEQtAb9IAEhLSAZIC79HwIQtAb9EyAYIBkgLv0fABC0Bv0gACAaIBkgLv0fARC0Bv0gASEuIAhBBGohCCAEQQRBACAEIgYgFEcbaiEEIAwgB0EBaiIHRw0ACyAKQgA3A7ABIANDAAAAP5QiAyADlCEoQQAhByABIQRDAAAAACEbA0AgDSAEKAIAIghNBEAgCCANQfS/xwAQjAcACyAHIA9PDQQgCyAIQSRsaiIEQRBqIAT9XQII/VYCAAIhKSAJKgIAISQgCkHQA2oiCCAEEJoDIAr9AATQAyEvIAggBCkCABDLAiAoICkgLv3lASIw/R8AIh8gH5QgLyAq/Q0ICQoLCAkKCwgJCgsAAQIDIAr9AATQAyIp/R8AIiYgKf0fAiIdIB2SIiCUIiEgKf0fAyIeICn9HwEiGCAYkiIXlCIikv0TIBggIJQiHCAeICYgJpIiA5QiGZP9IAFDAACAPyAmIAOUIgMgGCAXlCIakpP9IAL95gEiK/0fACIjICOUIC8gKv0NBAUGBwQFBgcEBQYHAAECAyAmIBeUIhggHiAglCIXk/0TQwAAgD8gAyAdICCUIgOSk/0gASAcIBmS/SAC/eYBIiz9HwAiHSAdlCAvICr9DQABAgMAAQIDAAECAwABAgNDAACAPyAaIAOSk/0TIBggF5L9IAEgISAik/0gAv3mASIp/R8AIh4gHpSSkpKSICQgKv0fABC0Bv0TICggMP0fASIhICGUICv9HwEiIiAilCAs/R8BIhwgHJQgKf0fASIZIBmUkpKSkiAkICr9HwEQtAb9IAEgKCAw/R8CIhogGpQgK/0fAiIYIBiUICz9HwIiFyAXlCAp/R8CIgMgA5SSkpKSICQgKv0fAhC0Bv0gAiAfICGUICMgIpQgHSAclCAeIBmUkpKSICQgKv0fAxC0Bv0gAyEqIAlBBGohCUEEQQAgBSIEIBRHGyAEaiEFICEgGpQgIiAYlCAcIBeUIBkgA5SSkpIgJCAbELQGIRsgHyAalCAjIBiUIB0gF5QgHiADlJKSkiAkICUQtAYhJSAHQQFqIgcgDEcNAAsMBAsACyAGIA1B1MDHABCMBwALIAcgD0GUwMcAEIwHAAsgByAPQYTAxwAQjAcACyAKIBs4ArQBIAogJTgCsAEgCiAq/QsEoAEgKv3gASIp/QwAAIB/AACAfwAAgH8AAIB//UQgKf0MAACAfwAAgH8AAIB/AACAf/1D/VD9TSIp/RsAQQFxICn9xwH9GwJBAXFyRSAq/R8CvEH/////B3FB////+wdNcUUEQEG8vMcAQewAQai9xwAQ6wcACwJ9AkACQCAq/R8DvEH/////B3FB////+wdLICW8Qf////8HcUH////7B0tyIBu8Qf////8HcUH////7B0tyRQRAIApB0ANqIApBoAFqEK4BIAr9AASABCErIAoqAvgDIR8gCioC8AMhICAKKgLkAyEjIAoqAvQDIRwgCioC4AMhGiAKKgLoAyEdIAoqAtADQwAAAAAQ4AggCioC1ANDAAAAABDgCCEXIAoqAtgDQwAAAAAQ4AghA/0TIBf9IAH94wEiLP0M////f////3////9/////f/1O/QwAAIB/AACAfwAAgH8AAIB//T8iKf0bAEEBcSAp/ccB/RsCQQFxcg0BIAORIgO8Qf////8HcUH////7B0sNASAsIAP9IAIgA/0gA/0MYEKiDWBCog1gQqINYEKiDf3rASEsICv94QEgK/0fAiIYjCID/SACIAP9IAMgKyAdICAgK/0fASIXlCAcICv9HwAiA5STlCAaIBwgGJQgHyAXlJOUICMgICAYlCAfIAOUk5STkkMAAAAAXRsiKf0fASEZICn9HwAhGCAp/R8CIgNDAAAAAF9FBEAgA0MAAIA/kiEXIBogHJIiA0MAAAAAX0UEQCADIBeSIgNDAAAAPyADkZUiA5QhHiAjICCTIAOUISEgGCAdkyADlCEiIB8gGZMgA5QMBQsgIyAgk0MAAAA/IBcgA5MiA5GVIheUIR4gAyAXlCEhIB8gGZIgF5QhIiAdIBiSIBeUDAQLQwAAgD8gA5MhFyAcIBqTIgNDAAAAAF9FDQIgHyAZk0MAAAA/IBcgA5MiA5GVIheUIR4gHSAYkiAXlCEhICMgIJIgF5QhIiADIBeUDAMLQbi9xwBB7ABBpL7HABDrBwALQfS4xwBB1gBBtL7HABDrBwALIBggHZNDAAAAPyADIBeSIgORlSIXlCEeIB8gGZIgF5QhISADIBeUISIgIyAgkiAXlAsgLP0fACIcICz9HwEiGZRDj8LNPxC3CiEXIBwgLP0fAiIalEOPws0/ELcKIQNDAAB6REO9N4Y1ICcgGSAalEOPws0/ELcKIBcgA5KSQwAAQECVQ+ZAHz8QtwpD2w9JQZSVIgMgA0O9N4Y1XRsiAyADQwAAekReG7wiBEH///8DcSEFIARBgICAgHhxIQgCQCAEQYCAgPwHcSIHQYCAgPwHRgRAIAVBDXYgCEEQdnJBgARBACAFG3JBgPgBciEODAELIAhBEHYhDiAHQYCAgLgETQRAIAdBgICAxANPBEAgBEEMdiAEQf/fAHFBAEdxIAdBDXYgBUENdmpBgIABaiAOcmohDgwCCyAHQYCAgJgDSQ0BIAVBgICABHIiBEH+ACAHQRd2IghrdiEFIARBHSAIayIIdkEBcQR/IAVBAyAIdEEBayAEcUEAR2oFIAULIA5yIQ4MAQsgDkGA+AFyIQ4LIC39GwAiBEH///8DcSEFIARBgICAgHhxIQggLf0bASELAkAgBEGAgID8B3EiB0GAgID8B0YEQCAFQQ12IAhBEHZyQYAEQQAgBRtyQYD4AXIhEQwBCyAIQRB2IREgB0GAgIC4BE0EQCAHQYCAgMQDTwRAIARBDHYgBEH/3wBxQQBHcSAHQQ12IAVBDXZqQYCAAWogEXJqIREMAgsgB0GAgICYA0kNASAFQYCAgARyIgRB/gAgB0EXdiIIa3YhBSAEQR0gCGsiCHZBAXEEfyAFQQMgCHRBAWsgBHFBAEdqBSAFCyARciERDAELIBFBgPgBciERCyAt/RsCIQYgC0H///8DcSEFIAtBgICAgHhxIQgCQCALQYCAgPwHcSIJQYCAgPwHRwRAIAhBEHYhByAJQYCAgLgETQRAIAlBgICAxANPBEAgC0EMdiALQf/fAHFBAEdxIAlBDXYgBUENdmpBgIABaiAHcmohBwwDCyAJQYCAgJgDSQ0CIAVBgICABHIiBEH+ACAJQRd2IghrdiEFIARBHSAIayIIdkEBcQR/IAVBAyAIdEEBayAEcUEAR2oFIAULIAdyIQcMAgsgB0GA+AFyIQcMAQsgBUENdiAIQRB2ckGABEEAIAUbckGA+AFyIQcLIAZB////A3EhBSAGQYCAgIB4cSEIAkAgBkGAgID8B3EiBEGAgID8B0cEQCAIQRB2IQggBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSAEQQ12IAVBDXZqQYCAAWogCHJqIQgMAwsgBEGAgICYA0kNAiAFQYCAgARyIglB/gAgBEEXdiIFa3YhBCAJQR0gBWsiBXZBAXEEfyAEQQMgBXRBAWsgCXFBAEdqBSAECyAIciEIDAILIAhBgPgBciEIDAELIAVBDXYgCEEQdnJBgARBACAFG3JBgPgBciEICyAcEMYFvCIJQf///wNxIQQgCUGAgICAeHEhBQJAIAlBgICA/AdxIgZBgICA/AdGBEAgBEENdiAFQRB2ckGABEEAIAQbckGA+AFyIRAMAQsgBUEQdiEQIAZBgICAuARNBEAgBkGAgIDEA08EQCAJQQx2IAlB/98AcUEAR3EgBkENdiAEQQ12akGAgAFqIBByaiEQDAILIAZBgICAmANJDQEgBEGAgIAEciIJQf4AIAZBF3YiBWt2IQQgCUEdIAVrIgV2QQFxBH8gBEEDIAV0QQFrIAlxQQBHagUgBAsgEHIhEAwBCyAQQYD4AXIhEAsgGRDGBbwiBkH///8DcSEEIAZBgICAgHhxIQUCQCAGQYCAgPwHcSILQYCAgPwHRwRAIAVBEHYhCSALQYCAgLgETQRAIAtBgICAxANPBEAgBkEMdiAGQf/fAHFBAEdxIAtBDXYgBEENdmpBgIABaiAJcmohCQwDCyALQYCAgJgDSQ0CIARBgICABHIiBkH+ACALQRd2IgVrdiEEIAZBHSAFayIFdkEBcQR/IARBAyAFdEEBayAGcUEAR2oFIAQLIAlyIQkMAgsgCUGA+AFyIQkMAQsgBEENdiAFQRB2ckGABEEAIAQbckGA+AFyIQkLIBoQxgW8IgtB////A3EhBCALQYCAgIB4cSEFAkAgC0GAgID8B3EiDEGAgID8B0cEQCAFQRB2IQYgDEGAgIC4BE0EQCAMQYCAgMQDTwRAIAtBDHYgC0H/3wBxQQBHcSAMQQ12IARBDXZqQYCAAWogBnJqIQYMAwsgDEGAgICYA0kNAiAEQYCAgARyIgtB/gAgDEEXdiIFa3YhBCALQR0gBWsiBXZBAXEEfyAEQQMgBXRBAWsgC3FBAEdqBSAECyAGciEGDAILIAZBgPgBciEGDAELIARBDXYgBUEQdnJBgARBACAEG3JBgPgBciEGC7wiC0H///8DcSEEICK8IQ8CfiAEQQ12IhIgC0GAgICAeHEiBUEQdnJBgARBACAEG3JBgPgBcq0gC0GAgID8B3EiDUGAgID8B0YNABogBUEQdiEMAkAgDUGAgIC4BE0EQCASIA1BDXZqQYCAAWogDHKtIAtBDHYgC0H/3wBxQQBHca18IA1BgICAxANPDQIaIA1BgICAmANJDQEgBEGAgIAEciILQf4AIA1BF3YiBWt2IQQgC0EdIAVrIgV2QQFxBH8gBEEDIAV0QQFrIAtxQQBHagUgBAsgDHKtDAILIAxBgPgBcq0MAQsgDK0LITEgIbwhEiAPQf///wNxIQQgD0GAgICAeHEhBQJ+IA9BgICA/AdxIg1BgICA/AdHBEAgBUEQdiEMIA1BgICAuARNBEAgDUENdiAEQQ12akGAgAFqIAxyrSAPQQx2IA9B/98AcUEAR3GtfCANQYCAgMQDTw0CGiANQYCAgJgDTwRAIARBgICABHIiC0H+ACANQRd2IgVrdiEEIAtBHSAFayIFdkEBcQR/IARBAyAFdEEBayALcUEAR2oFIAQLIAxyrQwDCyAMrQwCCyAMQYD4AXKtDAELIAVBEHYgBEENdnJBgARBACAEG3JBgPgBcq0LITIgHrwhDyASQf///wNxIQQgEkGAgICAeHEhBQJ+IBJBgICA/AdxIg1BgICA/AdHBEAgBUEQdiEMIA1BgICAuARNBEAgDUENdiAEQQ12akGAgAFqIAxyrSASQQx2IBJB/98AcUEAR3GtfCANQYCAgMQDTw0CGiANQYCAgJgDTwRAIARBgICABHIiC0H+ACANQRd2IgVrdiEEIAtBHSAFayIFdkEBcQR/IARBAyAFdEEBayALcUEAR2oFIAQLIAxyrQwDCyAMrQwCCyAMQYD4AXKtDAELIAVBEHYgBEENdnJBgARBACAEG3JBgPgBcq0LITMgD0H///8DcSEEIA9BgICAgHhxIQUCfiAPQYCAgPwHcSINQYCAgPwHRwRAIAVBEHYhDCANQYCAgLgETQRAIA1BDXYgBEENdmpBgIABaiAMcq0gD0EMdiAPQf/fAHFBAEdxrXwgDUGAgIDEA08NAhogDUGAgICYA08EQCAEQYCAgARyIgtB/gAgDUEXdiIFa3YhBCALQR0gBWsiBXZBAXEEfyAEQQMgBXRBAWsgC3FBAEdqBSAECyAMcq0MAwsgDK0MAgsgDEGA+AFyrQwBCyAFQRB2IARBDXZyQYAEQQAgBBtyQYD4AXKtCyE0IAAoAggiCyAAKAIARgRAIwBBIGsiDSQAAkAgACgCACIMQfG4nA5LBH9BAAVBBCAMQQF0IgUgBUEETRsiBEEkbCEFIA0gDAR/IA0gDEEkbDYCHCANIAAoAgQ2AhRBBAVBAAs2AhggDUEIakEEIAUgDUEUahCFByANKAIIQQFHDQEgDSgCECEAIA0oAgwLIABBxL7HABCTCQALIA0oAgwhBSAAIAQ2AgAgACAFNgIEIA1BIGokAAsgACgCBCALQSRsaiIFIC79WgIQAiAFIC79WwIIACAFIAY7ASAgBSAJOwEeIAUgEDsBHCAFIAg7ARogBSAHOwEYIAUgETsBFiAFIA47ARQgBSAxQv//A4MgMkIQhkKAgPz/D4MgM0IghkKAgICA8P8/gyA0QjCGhISENwIAIAAgC0EBajYCCCAKQdADaiABIBQQmQMgACgCFCIEIAAoAgxGBEAjAEEgayIGJAACQCAAQQxqIgkoAgAiB0Gq1aoVSwR/QQAFQQQgB0EBdCIIIAhBBE0bIgVBGGwhCCAGIAcEfyAGIAdBGGw2AhwgBiAJKAIENgIUQQQFQQALNgIYIAZBCGpBBCAIIAZBFGoQhQcgBigCCEEBRw0BIAYoAhAhCSAGKAIMCyAJQdS+xwAQkwkACyAGKAIMIQggCSAFNgIAIAkgCDYCBCAGQSBqJAALIAAoAhAgBEEYbGoiCCAK/QAC0AP9CwIAIAhBEGogCkHgA2opAgA3AgAgACAEQQFqNgIUAkAgACgCPEUNACAKQeABaiIS/QwAAAAAAAAAAAAAAAAAAAAA/QsEACAKQdABav0MAAAAAAAAAAAAAAAAAAAAAP0LBAAgCv0MAAAAAAAAAAAAAAAAAAAAAP0LBMABAkAgAkUEQCAAKAIgIRAMAQsgCigCICAVIAooApwBIgVBIEsiCBshDyAKKAIcIAUgCBshESABQQRqIQcgACgCHCENIAAoAiAhEEEBIQggASEJQQAhBQJAA0AgBSARSQRAIAkoAgAiBiAQTw0CIAchCSAIIQQgDyAFQQJ0aioCACEDIA0gBkESbGohBUEAIQgDQCAFQQJqLwEAIQ4CfyAFLwEAIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQsgB0GAgAJxIQYgB0GA+AFxIgdBgPgBRgRAIAZBEHQiB0GAgID8B3IgC0UNARogByALQQ10ckGAgID+B3IMAQsgBkEQdCIGIAdBDXRBgICA/ABxIAtBDXRyQYCAgMADanIgBw0AGiALIAtnQRBrIgdB//8DcUEIanRB////A3EgBkGAgIDYA3IgB0EXdGtyCyEMIAVBBGovAQAhEwJ/IA5B//8BcQRAIA5B/wdxIQsgDkGAgAJxIQYgDkGA+AFxIgdBgPgBRwRAIAZBEHQiBiAHQQ10QYCAgPwAcSALQQ10ckGAgIDAA2pyIAcNAhogCyALZ0EQayIHQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIAdBF3RrcgwCCyAGQRB0IgcgC0ENdHJBgICA/gdyIAsNARogB0GAgID8B3IMAQsgDkEQdAshCyAKQdADaiAIagJ/IBNB//8BcQRAIBNB/wdxIQ4gE0GAgAJxIQYgE0GA+AFxIgdBgPgBRwRAIAZBEHQiBiAHQQ10QYCAgPwAcSAOQQ10ckGAgIDAA2pyIAcNAhogDiAOZ0EQayIHQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIAdBF3RrcgwCCyAGQRB0IgcgDkENdHJBgICA/gdyIA4NARogB0GAgID8B3IMAQsgE0EQdAu+IAMgCkHAAWogCGoiB0EIaioCABC0Bv0TIAy+IAMgByoCABC0Bv0gACALviADIAdBBGoqAgAQtAb9IAH9CwQAIAVBBmohBSAIQRBqIghBMEcNAAsgEiAKQfADav0ABAD9CwQAIApB0AFqIApB4ANq/QAEAP0LBAAgCiAK/QAE0AP9CwTAASAEIAkgFEciBmohCCAJQQRBACAGG2ohByAEIQUgBg0BDAMLCyAFIBFB1L/HABCMBwALIAYgEEHkv8cAEIwHAAsgCkHAAWohBUEAIQgDQCAFKAIAIgZB////A3EhByAGQYCAgIB4cSEEIAVBBGooAgAhDwJAIAZBgICA/AdxIgtBgICA/AdGBEAgB0ENdiAEQRB2ckGABEEAIAcbckGA+AFyIQkMAQsgBEEQdiEJIAtBgICAuARNBEAgC0GAgIDEA08EQCAGQQx2IAZB/98AcUEAR3EgC0ENdiAHQQ12akGAgAFqIAlyaiEJDAILIAtBgICAmANJDQEgB0GAgIAEciIGQf4AIAtBF3YiBGt2IQcgBkEdIARrIgR2QQFxBH8gB0EDIAR0QQFrIAZxQQBHagUgBwsgCXIhCQwBCyAJQYD4AXIhCQsgBUEIaigCACENIA9B////A3EhByAPQYCAgIB4cSEEAkAgD0GAgID8B3EiDEGAgID8B0cEQCAEQRB2IQYgDEGAgIC4BE0EQCAMQYCAgMQDTwRAIA9BDHYgD0H/3wBxQQBHcSAMQQ12IAdBDXZqQYCAAWogBnJqIQYMAwsgDEGAgICYA0kNAiAHQYCAgARyIgtB/gAgDEEXdiIEa3YhByALQR0gBGsiBHZBAXEEfyAHQQMgBHRBAWsgC3FBAEdqBSAHCyAGciEGDAILIAZBgPgBciEGDAELIAdBDXYgBEEQdnJBgARBACAHG3JBgPgBciEGCyANQf///wNxIQcgDUGAgICAeHEhBAJAIA1BgICA/AdxIgxBgICA/AdHBEAgBEEQdiEOIAxBgICAuARNBEAgDEGAgIDEA08EQCANQQx2IA1B/98AcUEAR3EgDEENdiAHQQ12akGAgAFqIA5yaiEODAMLIAxBgICAmANJDQIgB0GAgIAEciILQf4AIAxBF3YiBGt2IQcgC0EdIARrIgR2QQFxBH8gB0EDIAR0QQFrIAtxQQBHagUgBwsgDnIhDgwCCyAOQYD4AXIhDgwBCyAHQQ12IARBEHZyQYAEQQAgBxtyQYD4AXIhDgsgCkHQA2ogCGoiBCAJOwEAIARBBGogDjsBACAEQQJqIAY7AQAgBUEQaiEFIAhBBmoiCEESRw0ACyAKQdACaiIEIApB4ANqLwEAOwEAIAogCv0AAdAD/QsDwAIgACgCGCAQRgRAIwBBIGsiBiQAAkAgAEEYaiIJKAIAIgdB4/G4HEsEf0EABUEEIAdBAXQiCCAIQQRNGyIFQRJsIQggBiAHBH8gBiAHQRJsNgIcIAYgCSgCBDYCFEECBUEACzYCGCAGQQhqQQIgCCAGQRRqEIUHIAYoAghBAUcNASAGKAIQIQkgBigCDAsgCUHkvscAEJMJAAsgBigCDCEIIAkgBTYCACAJIAg2AgQgBkEgaiQACyAAKAIcIBBBEmxqIgggCv0AA8AC/QsBACAIQRBqIAQvAQA7AQAgACAQQQFqNgIgIAAoAjxBAU0NACAKQfABakEAQdAA/AsAAkAgAkUEQCAAKAIsIRAMAQsgCigCICAVIAooApwBIgVBIEsiCBshEiAKKAIcIAUgCBshESABQQRqIQcgACgCKCEPIAAoAiwhEEEBIQggASEJQQAhBQJAA0AgBSARSQRAIAkoAgAiCSAQTw0CIAghBCASIAVBAnRqKgIAIQMgDyAJQR5saiEFQQAhCANAIAVBAmovAQAhDAJ/IAUvAQAiCUH//wFxRQRAIAlBEHQMAQsgCUH/B3EhCyAJQYCAAnEhBiAJQYD4AXEiCUGA+AFGBEAgBkEQdCIJQYCAgPwHciALRQ0BGiAJIAtBDXRyQYCAgP4HcgwBCyAGQRB0IgYgCUENdEGAgID8AHEgC0ENdHJBgICAwANqciAJDQAaIAsgC2dBEGsiCUH//wNxQQhqdEH///8DcSAGQYCAgNgDciAJQRd0a3ILIQ0gBUEEai8BACETAn8gDEH//wFxBEAgDEH/B3EhCyAMQYCAAnEhBiAMQYD4AXEiCUGA+AFHBEAgBkEQdCIGIAlBDXRBgICA/ABxIAtBDXRyQYCAgMADanIgCQ0CGiALIAtnQRBrIglB//8DcUEIanRB////A3EgBkGAgIDYA3IgCUEXdGtyDAILIAZBEHQiCSALQQ10ckGAgID+B3IgCw0BGiAJQYCAgPwHcgwBCyAMQRB0CyEMIApB0ANqIgsgCGoCfyATQf//AXEEQCATQf8HcSEOIBNBgIACcSEGIBNBgPgBcSIJQYD4AUcEQCAGQRB0IgYgCUENdEGAgID8AHEgDkENdHJBgICAwANqciAJDQIaIA4gDmdBEGsiCUH//wNxQQhqdEH///8DcSAGQYCAgNgDciAJQRd0a3IMAgsgBkEQdCIJIA5BDXRyQYCAgP4HciAODQEaIAlBgICA/AdyDAELIBNBEHQLviADIApB8AFqIgkgCGoiBkEIaioCABC0Bv0TIA2+IAMgBioCABC0Bv0gACAMviADIAZBBGoqAgAQtAb9IAH9CwQAIAVBBmohBSAIQRBqIghB0ABHDQALIAkgC0HQAPwKAAAgBCAHIgkgFEciBmohCCAHQQRBACAGG2ohByAEIQUgBg0BDAMLCyAFIBFBtL/HABCMBwALIAkgEEHEv8cAEIwHAAsgCkHwAWohBUEAIQgDQCAFKAIAIgZB////A3EhByAGQYCAgIB4cSEEIAVBBGooAgAhDwJAIAZBgICA/AdxIgtBgICA/AdGBEAgB0ENdiAEQRB2ckGABEEAIAcbckGA+AFyIQkMAQsgBEEQdiEJIAtBgICAuARNBEAgC0GAgIDEA08EQCAGQQx2IAZB/98AcUEAR3EgC0ENdiAHQQ12akGAgAFqIAlyaiEJDAILIAtBgICAmANJDQEgB0GAgIAEciIGQf4AIAtBF3YiBGt2IQcgBkEdIARrIgR2QQFxBH8gB0EDIAR0QQFrIAZxQQBHagUgBwsgCXIhCQwBCyAJQYD4AXIhCQsgBUEIaigCACENIA9B////A3EhByAPQYCAgIB4cSEEAkAgD0GAgID8B3EiDEGAgID8B0cEQCAEQRB2IQYgDEGAgIC4BE0EQCAMQYCAgMQDTwRAIA9BDHYgD0H/3wBxQQBHcSAMQQ12IAdBDXZqQYCAAWogBnJqIQYMAwsgDEGAgICYA0kNAiAHQYCAgARyIgtB/gAgDEEXdiIEa3YhByALQR0gBGsiBHZBAXEEfyAHQQMgBHRBAWsgC3FBAEdqBSAHCyAGciEGDAILIAZBgPgBciEGDAELIAdBDXYgBEEQdnJBgARBACAHG3JBgPgBciEGCyANQf///wNxIQcgDUGAgICAeHEhBAJAIA1BgICA/AdxIgxBgICA/AdHBEAgBEEQdiEOIAxBgICAuARNBEAgDEGAgIDEA08EQCANQQx2IA1B/98AcUEAR3EgDEENdiAHQQ12akGAgAFqIA5yaiEODAMLIAxBgICAmANJDQIgB0GAgIAEciILQf4AIAxBF3YiBGt2IQcgC0EdIARrIgR2QQFxBH8gB0EDIAR0QQFrIAtxQQBHagUgBwsgDnIhDgwCCyAOQYD4AXIhDgwBCyAHQQ12IARBEHZyQYAEQQAgBxtyQYD4AXIhDgsgCkHQA2ogCGoiBCAJOwEAIARBBGogDjsBACAEQQJqIAY7AQAgBUEQaiEFIAhBBmoiCEEeRw0ACyAKQdYCaiIHIApB5gNqKQEANwEAIApB0AJqIgQgCkHgA2opAQA3AwAgCiAK/QAB0AP9CwPAAiAAKAIkIBBGBEAjAEEgayILJAACQCAAQSRqIgYoAgAiCUGixIgRSwR/QQAFQQQgCUEBdCIIIAhBBE0bIgVBHmwhCCALIAkEfyALIAlBHmw2AhwgCyAGKAIENgIUQQIFQQALNgIYIAtBCGpBAiAIIAtBFGoQhQcgCygCCEEBRw0BIAsoAhAhBiALKAIMCyAGQfS+xwAQkwkACyALKAIMIQggBiAFNgIAIAYgCDYCBCALQSBqJAALIAAoAiggEEEebGoiCCAK/QADwAL9CwEAIAhBFmogBykBADcBACAIQRBqIAQpAwA3AQAgACAQQQFqNgIsIAAoAjxBAk0NACAKQeACakEAQfAA/AsAAkAgAkUEQCAAKAI4IRAMAQsgCigCICAVIAooApwBIghBIEsiAhshDSAKKAIcIAggAhshDyABQQRqIQcgACgCNCEMIAAoAjghEEEBIQhBACEFAkADQCAFIA9JBEAgASgCACIBIBBPDQIgCCECIA0gBUECdGoqAgAhAyAMIAFBKmxqIQVBACEIA0AgBUECai8BACEGAn8gBS8BACIBQf//AXFFBEAgAUEQdAwBCyABQf8HcSEJIAFBgIACcSEEIAFBgPgBcSIBQYD4AUYEQCAEQRB0IgFBgICA/AdyIAlFDQEaIAEgCUENdHJBgICA/gdyDAELIARBEHQiBCABQQ10QYCAgPwAcSAJQQ10ckGAgIDAA2pyIAENABogCSAJZ0EQayIBQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAFBF3RrcgshCyAFQQRqLwEAIRECfyAGQf//AXEEQCAGQf8HcSEJIAZBgIACcSEEIAZBgPgBcSIBQYD4AUcEQCAEQRB0IgQgAUENdEGAgID8AHEgCUENdHJBgICAwANqciABDQIaIAkgCWdBEGsiAUH//wNxQQhqdEH///8DcSAEQYCAgNgDciABQRd0a3IMAgsgBEEQdCIBIAlBDXRyQYCAgP4HciAJDQEaIAFBgICA/AdyDAELIAZBEHQLIQYgCkHQA2oiCSAIagJ/IBFB//8BcQRAIBFB/wdxIRIgEUGAgAJxIQQgEUGA+AFxIgFBgPgBRwRAIARBEHQiBCABQQ10QYCAgPwAcSASQQ10ckGAgIDAA2pyIAENAhogEiASZ0EQayIBQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAFBF3RrcgwCCyAEQRB0IgEgEkENdHJBgICA/gdyIBINARogAUGAgID8B3IMAQsgEUEQdAu+IAMgCkHgAmoiASAIaiIEQQhqKgIAELQG/RMgC74gAyAEKgIAELQG/SAAIAa+IAMgBEEEaioCABC0Bv0gAf0LBAAgBUEGaiEFIAhBEGoiCEHwAEcNAAsgASAJQfAA/AoAACACIAciASAURyIEaiEIIAdBBEEAIAQbaiEHIAIhBSAEDQEMAwsLIAUgD0GUv8cAEIwHAAsgASAQQaS/xwAQjAcACyAKQeACaiEFQQAhCANAIAUoAgAiBEH///8DcSECIARBgICAgHhxIQEgBUEEaigCACEMAkAgBEGAgID8B3EiB0GAgID8B0YEQCACQQ12IAFBEHZyQYAEQQAgAhtyQYD4AXIhCQwBCyABQRB2IQkgB0GAgIC4BE0EQCAHQYCAgMQDTwRAIARBDHYgBEH/3wBxQQBHcSAHQQ12IAJBDXZqQYCAAWogCXJqIQkMAgsgB0GAgICYA0kNASACQYCAgARyIgRB/gAgB0EXdiIBa3YhAiAEQR0gAWsiAXZBAXEEfyACQQMgAXRBAWsgBHFBAEdqBSACCyAJciEJDAELIAlBgPgBciEJCyAFQQhqKAIAIQsgDEH///8DcSECIAxBgICAgHhxIQECQCAMQYCAgPwHcSIHQYCAgPwHRwRAIAFBEHYhBiAHQYCAgLgETQRAIAdBgICAxANPBEAgDEEMdiAMQf/fAHFBAEdxIAdBDXYgAkENdmpBgIABaiAGcmohBgwDCyAHQYCAgJgDSQ0CIAJBgICABHIiBEH+ACAHQRd2IgFrdiECIARBHSABayIBdkEBcQR/IAJBAyABdEEBayAEcUEAR2oFIAILIAZyIQYMAgsgBkGA+AFyIQYMAQsgAkENdiABQRB2ckGABEEAIAIbckGA+AFyIQYLIAtB////A3EhAiALQYCAgIB4cSEBAkAgC0GAgID8B3EiB0GAgID8B0cEQCABQRB2IQ4gB0GAgIC4BE0EQCAHQYCAgMQDTwRAIAtBDHYgC0H/3wBxQQBHcSAHQQ12IAJBDXZqQYCAAWogDnJqIQ4MAwsgB0GAgICYA0kNAiACQYCAgARyIgRB/gAgB0EXdiIBa3YhAiAEQR0gAWsiAXZBAXEEfyACQQMgAXRBAWsgBHFBAEdqBSACCyAOciEODAILIA5BgPgBciEODAELIAJBDXYgAUEQdnJBgARBACACG3JBgPgBciEOCyAKQeYEaiAIaiIBIAk7AQAgAUEEaiAOOwEAIAFBAmogBjsBACAFQRBqIQUgCEEGaiIIQSpHDQALIAAoAjAgEEYEQCMAQSBrIgQkAAJAIABBMGoiBSgCACIIQeGwmAxLBH9BAAVBBCAIQQF0IgEgAUEETRsiAkEqbCEBIAQgCAR/IAQgCEEqbDYCHCAEIAUoAgQ2AhRBAgVBAAs2AhggBEEIakECIAEgBEEUahCFByAEKAIIQQFHDQEgBCgCECEFIAQoAgwLIAVBhL/HABCTCQALIAQoAgwhASAFIAI2AgAgBSABNgIEIARBIGokAAsgACgCNCAQQSpsaiIBIAr9AAHmBP0LAQAgAUEoaiAKQY4Fai8BADsBACABQSBqIApBhgVqKQEANwEAIAFBEGogCkH2BGr9AAEA/QsBACAAIBBBAWo2AjgLAkACQCAKKAKcASIBQSFPBEAgCigCICIIQQRrKAIAIgBBeHEiAiABQQJ0IgFBBEEIIABBA3EiABtqSQ0BIABBACACIAFBJ2pLGw0CIAgQogILIApBkAVqJAAgFg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9BdAxh/BH0BfiMAQfAAayIJJAACQAJAAkACQAJAIAAtAKhURQRAIAlB0ABqIABBxAFqELgEIAktAFAEQCAJKAJUIQEMAwsgCS0AUUEBRw0BIABBAToAqFQLIAAoAswBIgNFDQAgAEGgAmohFSAJQTxqrUKAgICAEIQhHSAAQdwBaiEWIABB6AFqIRIgAEH0AWohFyAAQYACaiEYA0ACQCAAKALYASIFIAAoAqRUIgFrIgJBACACIAVNG0GAgARPBEAgASECDAELIAEgAUGAgAJrIgJBACABIAJPGyILayECIAEgC0YEQCAAIAI2AqRUDAELIAEgBU0EQCACBEAgACgC1AEiASABIAtqIAL8CgAACyAAKALMASEDIAAgAjYCpFQMAQtBACABIAVBzNXBABDqBwALAkACQCADIA1PBEAgCUHQAGogFSAAKALIASANaiADIA1rIAAoAtQBIAAoAtgBIAJBBhBEIAkgCS0AVCIBOgAPIAkoAlAhFCAJKAJYIhFFDQIgACgCpFQiAyARaiICIANPIAIgACgC2AEiBU1xDQEgAyACIAVB3NXBABDqBwALIA0gAyADQezVwQAQ6gcACyAAKALUASEFIAAoAtwBIAAoAuQBIgJrIBFJBEAgFiACIBFBAUEBEKQFIAAoAuQBIQILIBEEQCAAKALgASACaiADIAVqIBH8CgAACyAAIAIgEWoiBTYC5AEgACAAKAKkVCARajYCpFQCQAJAIAAoAugBQYCAgIB4RgRAIAVBEE8EQCAJIAAoAuABIgIoAAAiAzYCHCADQc6OzYIFRwRAIAlBATYCZCAJQczIwQA2AmAgCUEBNgJUIAlB1M7BADYCUCAJQQE2AlwgCSAJQRxqrUKAgICAkASENwNAIAkgCUFAazYCWCAJQSBqIgAgCUHQAGoQsQYgABCOByEBDAgLIAkgAigABCILNgIsIAtBBGtBfUkNAiAAQQA2AuQBIAItAA4hBCACLQANIQcgAi0ADCEDIAIoAAghCCAFQRBrIgUEQCAFBEAgAiACQRBqIAX8CgAACyAAIAU2AuQBCyAJIAM2AjwCQCADQQNNBEBBgIDAABBxIgINAQALIAlBATYCVCAJQaDtxwA2AlAgCUIBNwJcIAkgHTcDaCAJIAlB6ABqNgJYIAlBQGsiACAJQdAAahCxBiAAEJAHIQEMCAsgACAEOgCeAiAAIAc6AJ0CIABBADoAnAIgAEEANgKYAiAAIAM2ApQCIAAgCDYCkAIgACALNgKMAiAAQQA2AogCIABCgICAgMAANwKAAiAAQgI3AvgBIABCADcC8AEgACACNgLsASAAQYCAEDYC6AEgCSAEQYABcUEHdjoAWCAJIAM2AlQgCSAINgJQIAAgCUHQAGoQ4QMLIAAoAugBQYCAgIB4Rg0DCwNAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AnAJBAWsOCQ0MCwoAAQYEEgILQQkhD0EGIQEgACgClAIOBAQIBwYCCyAAQQlBByAALACeAkEAThs6AJwCDA4LIAAoAuQBQQZBCSAAKAKMAiIDQQFGGyIMbiICIAAoApACIAAoApgCayILSQRAIAIiC0GAgARJDRALQYCABCALIAtBgIAETxsiBEEDbCICIAAoAvABIgFLBH8gAiABayICIAAoAugBIAFrSwRAIBIgASACQQRBBBCkBSAAKALwASEBCyAAKALsASIFIAFBAnRqIQMgAkECTwR/IAJBAnRBBGsiCARAIANBACAI/AsACyABIAJqIgJBAWshASAFIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYC8AEgACgCjAIFIAMLQQFHDQsgC0UNDEEAIQhBACEBQQAhAkEAIQMDQCABQQJqIQcgACgC5AEiBSABQQFqTQRAIAEgByAFQazPwQAQ6gcACwJ/IAAoAuABIAFqIgVBAWotAABBCHQiBiAFLQAAciIFQf//AXFFBEAgBUEQdAwBCyAFQf8HcSEFIAZBgIACcSEKIAZBgPgBcSIGQYD4AUYEQCAKQRB0IgZBgICA/AdyIAVFDQEaIAVBDXQgBnJBgICA/gdyDAELIApBEHQiCiAGQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2pyIAYNABogBSAFZ0EQayIFQf//A3FBCGp0Qf///wNxIApBgICA2ANyIAVBF3RrcgshBQJ/AkACQCAAKALwASIGIANLBEAgACgC7AEgAmogBTYCACABQQRqIgYgACgC5AEiBUsNASAAKALgASABaiIFQQNqLQAAQQh0IgcgBUECai0AAHIiBUH//wFxRQRAIAVBEHQMBAsgBUH/B3EhBSAHQYCAAnEhCiAHQYD4AXEiB0GA+AFGBEAgCkEQdCIHQYCAgPwHciAFRQ0EGiAFQQ10IAdyQYCAgP4HcgwECyAKQRB0IQogB0UNAiAHQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2ogCnIMAwsgAyAGQdzOwQAQjAcACyAHIAYgBUGcz8EAEOoHAAsgBSAFZ0EQayIFQf//A3FBCGp0Qf///wNxIApBgICA2ANyIAVBF3RrcgshBQJ/AkACQCADQQFqIgcgACgC8AEiCkkEQCAAKALsASACakEEaiAFNgIAIAFBBmoiBSAAKALkASIHSw0BIAAoAuABIAFqIgFBBWotAABBCHQiByABQQRqLQAAciIBQf//AXFFBEAgAUEQdAwECyABQf8HcSEBIAdBgIACcSEGIAdBgPgBcSIHQYD4AUYEQCAGQRB0IgdBgICA/AdyIAFFDQQaIAFBDXQgB3JBgICA/gdyDAQLIAZBEHQhBiAHRQ0CIAdBDXRBgICA/ABxIAFBDXRyQYCAgMADaiAGcgwDCyAHIApB7M7BABCMBwALIAYgBSAHQYzPwQAQ6gcACyABIAFnQRBrIgFB//8DcUEIanRB////A3EgBkGAgIDYA3IgAUEXdGtyCyEBIANBAmoiByAAKALwASIGSQRAIAAoAuwBIAJqQQhqIAE2AgAgAkEMaiECIANBA2ohAyAFIQEgCEEBaiIIIARJDQEMDgsLIAcgBkH8zsEAEIwHAAtB7NPBABCBCAALIAAoAuQBIgFBAnYiAiAAKAKQAiAAKAKYAmsiBEkEQCACIQQgAUGAgBBJDQ4LQYCABCAEIARBgIAETxsiAiAAKAKIAiIBSwRAIAIgAWsiAyAAKAKAAiABa0sEQCAYIAEgA0EEQQQQpAUgACgCiAIhAQsgACgChAIiCyABQQJ0aiEFIANBAk8EfyADQQJ0QQRrIggEQCAFQQAgCPwLAAsgASADaiIDQQFrIQEgCyADQQJ0akEEawUgBQtBADYCACAAIAFBAWoiATYCiAILIAQEQEEAIQFBACEDAkADQCAAKALkASIFIAFBA2pNBEAgASABQQRqIAVBvNXBABDqBwALIAAoAogCIgUgA0sEQCAAKAKEAiABaiAAKALgASABaigAADYCACABQQRqIQEgAiADQQFqIgNGDQIMAQsLIAMgBUGs1cEAEIwHAAsgACgCiAIhAQsgACAAKAKYAiACIAAoAoQCIAEQtwQCQAJAAkAgACgC5AEiAyACQQJ0IgFPBEAgAEEANgLkASADIAFrIQUgBEUNASABIANGDQMgBUUNAiAAKALgASIDIAEgA2ogBfwKAAAMAgsMFQsgASADRg0BCyAAIAU2AuQBCyAAIAAoApgCIAJqIgI2ApgCIAIgACgCkAJHDQsgAEEANgKYAkEJIQELIAAgAToAnAIMCgsgACgC5AEiAUEBdiICIAAoApACIAAoApgCayIESQRAIAIhBCABQYCACEkNDAtBgIAEIAQgBEGAgARPGyICIAAoAvwBIgFLBEAgAiABayIDIAAoAvQBIAFrSwRAIBcgASADQQJBAhCkBSAAKAL8ASEBCyAAKAL4ASILIAFBAXRqIQUgA0ECTwR/IANBAXRBAmsiCARAIAVBACAI/AsACyABIANqIgNBAWshASALIANBAXRqQQJrBSAFC0EAOwEAIAAgAUEBaiIBNgL8AQsgBARAQQAhA0ECIQECQANAIAAoAuQBIgUgAUkEQCABQQJrIAEgBUGc1cEAEOoHAAsgACgC/AEiBSADSwRAIAAoAvgBIAFqQQJrIAAoAuABIAFqQQJrLwAAOwEAIAFBAmohASACIANBAWoiA0YNAgwBCwsgAyAFQYzVwQAQjAcACyAAKAL8ASEBCyAAIAAoApgCIAIgACgC+AEgARC2BAJAAkACQCAAKALkASIDIAJBAXQiAU8EQCAAQQA2AuQBIAMgAWshBSAERQ0BIAEgA0YNAyAFRQ0CIAAoAuABIgMgASADaiAF/AoAAAwCCwwTCyABIANGDQELIAAgBTYC5AELIAAgACgCmAIgAmoiAjYCmAIgAiAAKAKQAkcNCSAAQQA2ApgCIABBCDoAnAIMCQtBLSEPDAELQRghDwsgACgC5AEgD24iAiAAKAKQAiAAKAKYAmsiC0kEQCACIgtBgIAESQ0JC0GAgAQgCyALQYCABE8bIg4gD2wiDCAAKALwASIBSwRAIAwgAWsiAiAAKALoASABa0sEQCASIAEgAkEEQQQQpAUgACgC8AEhAQsgACgC7AEiBSABQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgQEQCADQQAgBPwLAAsgASACaiICQQFrIQEgBSACQQJ0akEEawUgAwtBADYCACAAIAFBAWoiATYC8AELIA5BCWwhEwJAIAsEQCAOQeAAbCEHIA5BGGwhCEEBIQFBACEQQQAhBQJAA0AgBSEEIAEhBSAEIA9sIgEgACgC5AEiAk8NAwJAAkACQAJAIARBCWwiAyAAKALwASICTw0AIAAoAuwBIANBAnRqIAAoAuABIAFqLQAAs0MAAADDkkMAAAA8lDgCACABQQNqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EDaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQZqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EGaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQFqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EBaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQRqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EEaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQdqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EHaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQJqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0ECaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQVqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EFaiIKIAAoAvABIgJPBEAgCiEDDAELIAAoAuwBIApBAnRqIAAoAuABIAZqLQAAs0MAAADDkkMAAAA8lDgCACABQQhqIgYgACgC5AEiAk8EQCAGIQEMCAsgA0EIaiIDIAAoAvABIgJPDQAgACgC7AEgA0ECdGogACgC4AEgBmotAACzQwAAAMOSQwAAADyUOAIAIAAoApQCQQFLDQEMAgsgAyACQfzUwQAQjAcACwJAAkAgAUEJaiIDIAAoAuQBIgZPDQAgBEEPbCATaiICIAAoAvABIgZPDQMgACgC7AEgAkECdGogACgC4AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBDGoiAyAAKALkASIGTw0AIAJBA2oiBCAAKALwASIGTwRAIAQhAgwECyAAKALsASAEQQJ0aiAAKALgASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEPaiIDIAAoAuQBIgZPDQAgAkEGaiIEIAAoAvABIgZPBEAgBCECDAQLIAAoAuwBIARBAnRqIAAoAuABIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRJqIgMgACgC5AEiBk8NACACQQlqIgQgACgC8AEiBk8EQCAEIQIMBAsgACgC7AEgBEECdGogACgC4AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBFWoiAyAAKALkASIGTw0AIAJBDGoiBCAAKALwASIGTwRAIAQhAgwECyAAKALsASAEQQJ0aiAAKALgASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEKaiIDIAAoAuQBIgZPDQAgAkEBaiIEIAAoAvABIgZPBEAgBCECDAQLIAAoAuwBIARBAnRqIAAoAuABIANqLQAAs0MAAADDkkMAAAA8lDgCACABQQ1qIgMgACgC5AEiBk8NACACQQRqIgQgACgC8AEiBk8EQCAEIQIMBAsgACgC7AEgBEECdGogACgC4AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBEGoiAyAAKALkASIGTw0AIAJBB2oiBCAAKALwASIGTwRAIAQhAgwECyAAKALsASAEQQJ0aiAAKALgASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUETaiIDIAAoAuQBIgZPDQAgAkEKaiIEIAAoAvABIgZPBEAgBCECDAQLIAAoAuwBIARBAnRqIAAoAuABIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRZqIgMgACgC5AEiBk8NACACQQ1qIgQgACgC8AEiBk8EQCAEIQIMBAsgACgC7AEgBEECdGogACgC4AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBC2oiAyAAKALkASIGTw0AIAJBAmoiBCAAKALwASIGTwRAIAQhAgwECyAAKALsASAEQQJ0aiAAKALgASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEOaiIDIAAoAuQBIgZPDQAgAkEFaiIEIAAoAvABIgZPBEAgBCECDAQLIAAoAuwBIARBAnRqIAAoAuABIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRFqIgMgACgC5AEiBk8NACACQQhqIgQgACgC8AEiBk8EQCAEIQIMBAsgACgC7AEgBEECdGogACgC4AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBFGoiAyAAKALkASIGTw0AIAJBC2oiBCAAKALwASIGTwRAIAQhAgwECyAAKALsASAEQQJ0aiAAKALgASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEXaiIDIAAoAuQBIgZPDQAgAkEOaiICIAAoAvABIgZPDQMgACgC7AEgAkECdGogACgC4AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAAoApQCQQJNDQJBACEGIAchAwwBCyADIAZBzNTBABCMBwALAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQANAIAAoAuQBIgIgBiAQaiIBQRhqSwRAIAYgCGoiBCAAKALwASICTw0PIAAoAuwBIANqIAEgACgC4AFqQRhqLQAAs0MAAADDkkMAAAA8lDgCACAAKALkASICIAFBG2pNDQcgACgC8AEiAiAEQQNqTQ0OIAAoAuwBIANqQQxqIAEgACgC4AFqQRtqLQAAs0MAAADDkkMAAAA8lDgCACAAKALkASICIAFBHmpNDQYgACgC8AEiAiAEQQZqTQ0NIAAoAuwBIANqQRhqIAEgACgC4AFqQR5qLQAAs0MAAADDkkMAAAA8lDgCACAAKALkASICIAFBIWpNDQUgACgC8AEiAiAEQQlqTQ0MIAAoAuwBIANqQSRqIAEgACgC4AFqQSFqLQAAs0MAAADDkkMAAAA8lDgCACAAKALkASICIAFBJGpNDQQgACgC8AEiAiAEQQxqTQ0LIAAoAuwBIANqQTBqIAEgACgC4AFqQSRqLQAAs0MAAADDkkMAAAA8lDgCACAAKALkASICIAFBJ2pNDQMgACgC8AEiAiAEQQ9qTQ0KIAAoAuwBIANqQTxqIAEgACgC4AFqQSdqLQAAs0MAAADDkkMAAAA8lDgCACAAKALkASICIAFBKmpNDQIgACgC8AEiAiAEQRJqTQ0JIAAoAuwBIANqQcgAaiAAKALgASAQaiAGakEqai0AALNDAAAAw5JDAAAAPJQ4AgAgA0EEaiEDIAZBAWoiBkEDSQ0BDBALCyABQRhqDAYLIAFBKmoMBQsgAUEnagwECyABQSRqDAMLIAFBIWoMAgsgAUEeagwBCyABQRtqCyACQazUwQAQjAcACyAEQRJqIQQMBQsgBEEPaiEEDAQLIARBDGohBAwDCyAEQQlqIQQMAgsgBEEGaiEEDAELIARBA2ohBAsgBCACQbzUwQAQjAcACyAPIBBqIRAgCEEVaiEIIAdB1ABqIQcgBSAFIA5JIgJqIQEgAkUNAgwBCwsgAiAGQdzUwQAQjAcACyAAKALwASEBCwJAAkACQCABIBNPBEAgACgC7AEhBSAAKAKYAiEEQQAhAkEEIQggACgClAIiB0ECSQRAQQQhEEEAIQYMBAsgDkEYbCIDIAFLDQEgDkEPbCEGIAUgE0ECdGohECAHQQJGDQMgAyAMTSABIAxPcQ0CIAMgDCABQfzTwQAQ6gcAC0EAIBMgAUGc1MEAEOoHAAsgEyADIAFBjNTBABDqBwALIAwgA2shAiAFIANBAnRqIQgLIAsEQCAAIAQgDiAFIBMQ5gELIAYEQCAAIAQgDiAQIAYQpwELIAIEQCAAIAQgDiAIIAIQlAELAkACQAJAIAwgACgC5AEiAk0EQCAAQQA2AuQBIAIgDGshASALRQ0BIAIgDEYNAyABRQ0CIAAoAuABIgIgAiAMaiAB/AoAAAwCC0EAIAwgAkGEpMcAEOoHAAsgAiAMRg0BCyAAIAE2AuQBCyAAIAAoApgCIA5qIgI2ApgCIAIgACgCkAJHDQcgAEEANgKYAiAAQQY6AJwCDAcLIAEgAkHs1MEAEIwHAAsgACgC5AFBBEEDIAAoAowCIgNBA0YbIhBuIgIgACgCkAIgACgCmAJrIgVJBEAgAiIFQYCABEkNCAsCQAJAAkACQAJAAkACQAJAAkACQAJAQYCABCAFIAVBgIAETxsiC0ECdCICIAAoAvABIgFLBH8gAiABayICIAAoAugBIAFrSwRAIBIgASACQQRBBBCkBSAAKALwASEBCyAAKALsASIEIAFBAnRqIQMgAkECTwR/IAJBAnRBBGsiCARAIANBACAI/AsACyABIAJqIgJBAWshASAEIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYC8AEgACgCjAIFIAMLQQNHBEAgBUUNC0EAIQRBACEBQQAhAkEAIQMDQCABIAAoAuQBIghPDQIgAUEBaiIHIAhPDQMgAUECaiIHIAhPDQRDAACAPyAAKALgASABaiIILQAAs0MAAP9ClUMAAIC/kiIZIBmUIAhBAWotAACzQwAA/0KVQwAAgL+SIhogGpSSIAhBAmotAACzQwAA/0KVQwAAgL+SIhsgG5SSk0MAAAAAEOAIIRwgAyAAKALwASIITw0FIAAoAuwBIAJqIBk4AgAgA0EBaiIIIAAoAvABIgdPDQYgACgC7AEgAmpBBGogGjgCACADQQJqIgggACgC8AEiB08NByAAKALsASACakEIaiAbOAIAIANBA2oiCCAAKALwASIHTw0IIAAoAuwBIAJqQQxqIByROAIAIAFBA2ohASACQRBqIQIgA0EEaiEDIARBAWoiBCALSQ0ACwwLCyAFRQ0KQQAhAkEBIQhBACEDA0ACQAJAAkACQCAAKALkASIBIANLBEAgA0EBaiIEIAFPDQEgA0ECaiIHIAFPDQIgA0EDaiIGIAFPDQMgACgC4AEgA2oiAUECai0AACEMIAFBA2otAAAhCiABLQAAIAFBAWotAAAhDiAJ/QwAAAAAAAAAAAAAAAAAAAAA/QsDUCAOQQh0ciIPIAxBEHQgCkEYdHJyIQFDAAAAACEZAn8CQCAKQQZ2IgxBA0cEQCAJIA9B/wNxs0MAgP9DlUPzBDU/lCIZjCAZIA5BAnEbIhk4AlwgGSAZlCEZIAFBCnYhASAMQQJGDQELIAkgAUH/A3GzQwCA/0OVQ/MENT+UIhqMIBogAUGABHEbIho4AlggGSAaIBqUkiEZIAFBCnYiASAMQQFGDQEaCyAJIAFB/wNxs0MAgP9DlUPzBDU/lCIajCAaIAFBgARxGyIaOAJUIBkgGiAalJIhGSABQQp2CyEBIAlB0ABqIAxBAnRqQwAAgD8gCkHAAE8EfSAJIAFB/wNxs0MAgP9DlUPzBDU/lCIajCAaIAFBgARxGyIaOAJQIBkgGiAalJIFIBkLkyIZkUMAAAAAIBlDAAAAAF4bOAIAIAMgACgC8AEiAUkNBCADIAFBvNLBABCMBwALIAMgAUH80cEAEIwHAAsgBCABQYzSwQAQjAcACyAHIAFBnNLBABCMBwALIAYgAUGs0sEAEIwHAAsgACgC7AEgAmogCSoCUDgCACAEIAAoAvABIgFPDQogACgC7AEgAmpBBGogCSoCVDgCACAHIAAoAvABIgFPDQkgACgC7AEgAmpBCGogCSoCWDgCACAGIAAoAvABIgFPDQggACgC7AEgAmpBDGogCSoCXDgCACACQRBqIQIgA0EEaiEDIAggC0kgCEEBaiEIDQALDAoLIAEgCEH80sEAEIwHAAsgByAIQYzTwQAQjAcACyAHIAhBnNPBABCMBwALIAMgCEGs08EAEIwHAAsgCCAHQbzTwQAQjAcACyAIIAdBzNPBABCMBwALIAggB0Hc08EAEIwHAAsgBiABQezSwQAQjAcACyAHIAFB3NLBABCMBwALIAQgAUHM0sEAEIwHAAsgACAAKAKYAiALIAAoAuwBIAAoAvABEKAFAkACQAJAIAAoAuQBIgEgCyAQbCICTwRAIABBADYC5AEgASACayEDIAVFDQEgASACRg0DIANFDQIgACgC4AEiASABIAJqIAP8CgAADAILDBALIAEgAkYNAQsgACADNgLkAQsgACAAKAKYAiALaiICNgKYAiACIAAoApACRw0FIABBADYCmAIgAEEFOgCcAgwFCyAAKALkASIBQQNuIgIgACgCkAIgACgCmAJrIghJBEAgAiEIIAFBgIAMSQ0HC0GAgAQgCCAIQYCABE8bIgtBA2wiBSAAKALwASIBSwRAIAUgAWsiAiAAKALoASABa0sEQCASIAEgAkEEQQQQpAUgACgC8AEhAQsgACgC7AEiBCABQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgcEQCADQQAgB/wLAAsgASACaiICQQFrIQEgBCACQQJ0akEEawUgAwtBADYCACAAIAFBAWoiATYC8AELAkACQAJAAkACQAJAAkACQAJAIAgEQEEAIQNBACEBA0AgASAAKALkASICTw0CIAEgACgC8AEiAk8NAyAAKALsASADaiAAKALgASABai0AALNDAACAPZRDAAAgwZIQiQQ4AgAgAUEBaiICIAAoAuQBIgRPDQQgAiAAKALwASIETw0FIAAoAuwBIANqQQRqIAAoAuABIAFqQQFqLQAAs0MAAIA9lEMAACDBkhCJBDgCACABQQJqIgIgACgC5AEiBE8NBiACIAAoAvABIgRPDQcgACgC7AEgA2pBCGogACgC4AEgAWpBAmotAACzQwAAgD2UQwAAIMGSEIkEOAIAIANBDGohAyAFIAFBA2oiAUcNAAsgACgC8AEhAQsgACAAKAKYAiALIAAoAuwBIAEQngIgACgC5AEiAiAFSQ0WIABBADYC5AEgAiAFayEBIAhFDQYgAiAFRg0IIAFFDQcgACgC4AEiAiACIAVqIAH8CgAADAcLIAEgAkGc0cEAEIwHAAsgASACQazRwQAQjAcACyACIARBvNHBABCMBwALIAIgBEHM0cEAEIwHAAsgAiAEQdzRwQAQjAcACyACIARB7NHBABCMBwALIAIgBUYNAQsgACABNgLkAQsgACAAKAKYAiALaiICNgKYAiACIAAoApACRw0EIABBADYCmAIgAEEEOgCcAgwECyAAKALkASIBQQNuIgIgACgCkAIgACgCmAJrIghJBEAgAiEIIAFBgIAMSQ0GC0GAgAQgCCAIQYCABE8bIgtBA2wiBSAAKALwASIBSwRAIAUgAWsiAiAAKALoASABa0sEQCASIAEgAkEEQQQQpAUgACgC8AEhAQsgACgC7AEiBCABQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgcEQCADQQAgB/wLAAsgASACaiICQQFrIQEgBCACQQJ0akEEawUgAwtBADYCACAAIAFBAWoiATYC8AELAkACQAJAAkACQAJAAkACQAJAIAgEQEEAIQNBACEBA0AgASAAKALkASICTw0CIAEgACgC8AEiAk8NAyAAKALsASADaiAAKALgASABai0AALNDAAB/Q5VDAAAAv5JDjLjwP5RDAAAAP5I4AgAgAUEBaiICIAAoAuQBIgRPDQQgAiAAKALwASIETw0FIAAoAuwBIANqQQRqIAAoAuABIAFqQQFqLQAAs0MAAH9DlUMAAAC/kkOMuPA/lEMAAAA/kjgCACABQQJqIgIgACgC5AEiBE8NBiACIAAoAvABIgRPDQcgACgC7AEgA2pBCGogACgC4AEgAWpBAmotAACzQwAAf0OVQwAAAL+SQ4y48D+UQwAAAD+SOAIAIANBDGohAyAFIAFBA2oiAUcNAAsgACgC8AEhAQsgACAAKAKYAiALIAAoAuwBIAEQpAIgACgC5AEiAiAFSQ0VIABBADYC5AEgAiAFayEBIAhFDQYgAiAFRg0IIAFFDQcgACgC4AEiAiACIAVqIAH8CgAADAcLIAEgAkG80MEAEIwHAAsgASACQczQwQAQjAcACyACIARB3NDBABCMBwALIAIgBEHs0MEAEIwHAAsgAiAEQfzQwQAQjAcACyACIARBjNHBABCMBwALIAIgBUYNAQsgACABNgLkAQsgACAAKAKYAiALaiICNgKYAiACIAAoApACRw0DIABBADYCmAIgAEEDOgCcAgwDCyAAKALkASICIAAoApACIAAoApgCayILSQRAIAIiC0GAgARJDQULQYCABCALIAtBgIAETxsiCCAAKALwASIBSwRAIAggAWsiAiAAKALoASABa0sEQCASIAEgAkEEQQQQpAUgACgC8AEhAQsgACgC7AEiBSABQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgQEQCADQQAgBPwLAAsgASACaiICQQFrIQEgBSACQQJ0akEEawUgAwtBADYCACAAIAFBAWo2AvABCwJAIAsEQEMAAIA/QwAAAEAgACwAngJBAE4bIRlBACEDQQAhAQJAAkADQCABIAAoAuQBIgJPDQIgASAAKALwASICTw0BIAAoAuwBIANqIBkgACgC4AEgAWotAACzQwAAf0OVlDgCACADQQRqIQMgCCABQQFqIgFHDQALIAAoAuwBIQ4gACgC8AEhAyAAIAAoApgCIAgQ6QRBACEBQQwhBiAIIQUgAyECA0ACQAJAIAAoAnwiBCABQQNqSwRAIAIEQCABIA5qKAIAIgpB////A3EhDCAKQYCAgIB4cSEEIApBgICA/AdxIgdBgICA/AdGBEAgBEEQdiAMQQ12ckGABEEAIAwbckGA+AFyIQQMBAsgBEEQdiEEIAdBgICAuARLDQIgB0GAgIDEA08EQCAKQQx2IApB/98AcUEAR3EgB0ENdiAMQQ12akGAgAFqIARyaiEEDAQLIAdBgICAmANJDQMgDEGAgIAEciIKQf4AIAdBF3YiDGt2IQcgCkEdIAxrIgx2QQFxBH8gB0EDIAx0QQFrIApxQQBHagUgBwsgBHIhBAwDCyADIANBuLPBABCMBwALIAEgAUEEaiAEQcizwQAQ6gcACyAEQYD4AXIhBAsgACgCeCAGaiAEQf//A3E2AgAgBkEQaiEGIAJBAWshAiABQQRqIQEgBUEBayIFDQALDAMLIAEgAkGs0MEAEIwHAAsgASACQZzQwQAQjAcACyAAIAAoApgCIAgQ6QQLIABBAToAwAECQAJAAkAgCCAAKALkASICTQRAIABBADYC5AEgAiAIayEBIAtFDQEgAiAIRg0DIAFFDQIgACgC4AEiAiACIAhqIAH8CgAADAILQQAgCCACQYSkxwAQ6gcACyACIAhGDQELIAAgATYC5AELIAAgACgCmAIgCGoiAjYCmAIgAiAAKAKQAkcNAiAAQQA2ApgCIABBAjoAnAIMAgsgC0UNAEEBIAAtAJ0CdLMhGUEAIQhBACEBQQAhAkEAIQMCQAJAAkACQANAIAFBA2oiBSAAKALkASIHSwRAIAEgBSAHQYzQwQAQ6gcACyADIAAoAvABIgdPDQEgACgC7AEgAmogACgC4AEgAWoiB0ECai0AACIGQRB0IActAAByIAdBAWotAABBCHRyIgdBgICAeHIgByAGwEEASBuyIBmVOAIAIAFBBmoiByAAKALkASIGSw0CIANBAWoiBSAAKALwASIGTw0DIAAoAuwBIAJqQQRqIAAoAuABIAFqIgVBBWotAAAiBkEQdCAFQQNqLQAAciAFQQRqLQAAQQh0ciIFQYCAgHhyIAUgBsBBAEgbsiAZlTgCACABQQlqIgUgACgC5AEiBksNBCADQQJqIgcgACgC8AEiBkkEQCAAKALsASACakEIaiAAKALgASABaiIBQQhqLQAAIgdBEHQgAUEGai0AAHIgAUEHai0AAEEIdHIiAUGAgIB4ciABIAfAQQBIG7IgGZU4AgAgAkEMaiECIANBA2ohAyAFIQEgCEEBaiIIIARJDQEMBgsLIAcgBkHcz8EAEIwHAAsgAyAHQbzPwQAQjAcACyAFIAcgBkH8z8EAEOoHAAsgBSAGQczPwQAQjAcACyAHIAUgBkHsz8EAEOoHAAsgACAAKAKYAiAEIAAoAuwBIAAoAvABEMIFAkACQAJAIAAoAuQBIgEgBCAMbCICTwRAIABBADYC5AEgASACayEDIAtFDQEgASACRg0DIANFDQIgACgC4AEiASABIAJqIAP8CgAADAILDAsLIAEgAkYNAQsgACADNgLkAQsgACAAKAKYAiAEaiICNgKYAiACIAAoApACRw0AIABBADYCmAIgAEEBOgCcAgwACwALIAlBATYCVCAJQbTOwQA2AlAgCUIBNwJcIAkgCUEsaq1CgICAgBCENwNAIAkgCUFAazYCWCAJQTBqIgAgCUHQAGoQsQYgABCOByEBDAQLIAktAA8hAQsgDSAUaiENAkACQAJAAkACQCABQf8BcQ4DAQIDAAsgCUEBNgJUIAlBmPfHADYCUCAJQgE3AlwgCSAJQQ9qrUKAgICAoASENwNAIAkgCUFAazYCWCAJQRBqIgAgCUHQAGoQsQYgABCOByEBDAYLIABBAToAqVQgDUEIaiANIAAoAswBIgIgDWsiAUEAIAEgAk0bQQdLGyENDAILIBEgFHJFDQELIA0gACgCzAEiA0kNAQsLIA1FDQAgDSAAKALMASICTQRAQQAhASAAQQA2AswBIAIgDUYNAiACIA1rIgIEQCAAKALIASIDIAMgDWogAvwKAAALIAAgAjYCzAEMAgtBACANIAJBhKTHABDqBwALQQAhAQsgCUHwAGokACABDwtBACABIANBhKTHABDqBwALQQAgAiABQYSkxwAQ6gcAC0EAIAUgAkGEpMcAEOoHAAvRXAMYfwR9AX4jAEHwAGsiCCQAAkACQAJAAkACQCAALQCgVEUEQCAIQdAAaiAAQbwBahC4BCAILQBQBEAgCCgCVCEBDAMLIAgtAFFBAUcNASAAQQE6AKBUCyAAKALEASIDRQ0AIABBmAJqIRUgCEE8aq1CgICAgBCEIR0gAEHUAWohFiAAQeABaiESIABB7AFqIRcgAEH4AWohGANAAkAgACgC0AEiBiAAKAKcVCIBayICQQAgAiAGTRtBgIAETwRAIAEhAgwBCyABIAFBgIACayICQQAgASACTxsiBGshAiABIARGBEAgACACNgKcVAwBCyABIAZNBEAgAgRAIAAoAswBIgEgASAEaiAC/AoAAAsgACgCxAEhAyAAIAI2ApxUDAELQQAgASAGQczVwQAQ6gcACwJAAkAgAyANTwRAIAhB0ABqIBUgACgCwAEgDWogAyANayAAKALMASAAKALQASACQQYQRCAIIAgtAFQiAToADyAIKAJQIRQgCCgCWCIRRQ0CIAAoApxUIgMgEWoiAiADTyACIAAoAtABIgZNcQ0BIAMgAiAGQdzVwQAQ6gcACyANIAMgA0Hs1cEAEOoHAAsgACgCzAEhBiAAKALUASAAKALcASICayARSQRAIBYgAiARQQFBARCkBSAAKALcASECCyARBEAgACgC2AEgAmogAyAGaiAR/AoAAAsgACACIBFqIgQ2AtwBIAAgACgCnFQgEWo2ApxUIAAoAuABQYCAgIB4RgRAAkAgBEEQSQ0AIAggACgC2AEiAigAACIDNgIcIANBzo7NggVHBEAgCEEBNgJkIAhBzMjBADYCYCAIQQE2AlQgCEHUzsEANgJQIAhBATYCXCAIIAhBHGqtQoCAgICQBIQ3A0AgCCAIQUBrNgJYIAhBIGoiACAIQdAAahCxBiAAEI4HIQEMBgsgCCACKAAEIgk2AiwgCUEEa0F9TwRAIABBADYC3AEgAiwADiEGIAItAA0hByACLQAMIQMgAigACCEFIARBEGsiBARAIAQEQCACIAJBEGogBPwKAAALIAAgBDYC3AELIAggAzYCPAJAIANBA00EQEGAgMAAEHEiAg0BAAsgCEEBNgJUIAhBoO3HADYCUCAIQgE3AlwgCCAdNwNoIAggCEHoAGo2AlggCEFAayIAIAhB0ABqELEGIAAQkAchAQwHCyAAIAY6AJYCIAAgBzoAlQIgAEEAOgCUAiAAQQA2ApACIAAgAzYCjAIgACAFNgKIAiAAIAk2AoQCIABBADYCgAIgAEKAgICAwAA3AvgBIABCAjcC8AEgAEIANwLoASAAIAI2AuQBIABBgIAQNgLgASAIIAZBgAFxQQd2OgBYIAggAzYCVCAIIAU2AlAgACAIQdAAahClBCAGQQBODQEgAEEBOgCcAQwBCyAIQQE2AlQgCEG0zsEANgJQIAhCATcCXCAIIAhBLGqtQoCAgIAQhDcDQCAIIAhBQGs2AlggCEEwaiIAIAhB0ABqELEGIAAQjgchAQwFCyAAKALgAUGAgICAeEYNAQsDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AlAJBAWsOCQ0MCwoAAQYEEAILQQkhD0EGIQEgACgCjAIOBAQIBwYCCyAAQQlBByAALACWAkEAThs6AJQCDA8LIAAoAtwBQQZBCSAAKAKEAiIDQQFGGyIMbiICIAAoAogCIAAoApACayIGSQRAIAIiBkGAgARJDQ4LQYCABCAGIAZBgIAETxsiBUEDbCICIAAoAugBIgFLBH8gAiABayICIAAoAuABIAFrSwRAIBIgASACQQRBBBCkBSAAKALoASEBCyAAKALkASIEIAFBAnRqIQMgAkECTwR/IAJBAnRBBGsiCQRAIANBACAJ/AsACyABIAJqIgJBAWshASAEIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYC6AEgACgChAIFIAMLQQFHDQsgBkUNDEEAIQlBACEBQQAhAkEAIQMDQCABQQJqIQcgACgC3AEiBCABQQFqTQRAIAEgByAEQazPwQAQ6gcACwJ/IAAoAtgBIAFqIgRBAWotAABBCHQiCiAELQAAciIEQf//AXFFBEAgBEEQdAwBCyAEQf8HcSEEIApBgIACcSELIApBgPgBcSIKQYD4AUYEQCALQRB0IgpBgICA/AdyIARFDQEaIARBDXQgCnJBgICA/gdyDAELIAtBEHQiCyAKQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAoNABogBCAEZ0EQayIEQf//A3FBCGp0Qf///wNxIAtBgICA2ANyIARBF3RrcgshBAJ/AkACQCAAKALoASIKIANLBEAgACgC5AEgAmogBDYCACABQQRqIgogACgC3AEiBEsNASAAKALYASABaiIEQQNqLQAAQQh0IgcgBEECai0AAHIiBEH//wFxRQRAIARBEHQMBAsgBEH/B3EhBCAHQYCAAnEhCyAHQYD4AXEiB0GA+AFGBEAgC0EQdCIHQYCAgPwHciAERQ0EGiAEQQ10IAdyQYCAgP4HcgwECyALQRB0IQsgB0UNAiAHQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogC3IMAwsgAyAKQdzOwQAQjAcACyAHIAogBEGcz8EAEOoHAAsgBCAEZ0EQayIEQf//A3FBCGp0Qf///wNxIAtBgICA2ANyIARBF3RrcgshBAJ/AkACQCADQQFqIgcgACgC6AEiC0kEQCAAKALkASACakEEaiAENgIAIAFBBmoiBCAAKALcASIHSw0BIAAoAtgBIAFqIgFBBWotAABBCHQiByABQQRqLQAAciIBQf//AXFFBEAgAUEQdAwECyABQf8HcSEBIAdBgIACcSEKIAdBgPgBcSIHQYD4AUYEQCAKQRB0IgdBgICA/AdyIAFFDQQaIAFBDXQgB3JBgICA/gdyDAQLIApBEHQhCiAHRQ0CIAdBDXRBgICA/ABxIAFBDXRyQYCAgMADaiAKcgwDCyAHIAtB7M7BABCMBwALIAogBCAHQYzPwQAQ6gcACyABIAFnQRBrIgFB//8DcUEIanRB////A3EgCkGAgIDYA3IgAUEXdGtyCyEBIANBAmoiByAAKALoASIKSQRAIAAoAuQBIAJqQQhqIAE2AgAgAkEMaiECIANBA2ohAyAEIQEgCUEBaiIJIAVJDQEMDgsLIAcgCkH8zsEAEIwHAAtB7NPBABCBCAALIAAoAtwBIgFBAnYiAiAAKAKIAiAAKAKQAmsiBEkEQCACIQQgAUGAgBBJDQwLQYCABCAEIARBgIAETxsiAiAAKAKAAiIBSwRAIAIgAWsiAyAAKAL4ASABa0sEQCAYIAEgA0EEQQQQpAUgACgCgAIhAQsgACgC/AEiCSABQQJ0aiEGIANBAk8EfyADQQJ0QQRrIgUEQCAGQQAgBfwLAAsgASADaiIDQQFrIQEgCSADQQJ0akEEawUgBgtBADYCACAAIAFBAWoiATYCgAILIAQEQEEAIQFBACEDAkADQCAAKALcASIGIAFBA2pNBEAgASABQQRqIAZBvNXBABDqBwALIAAoAoACIgYgA0sEQCAAKAL8ASABaiAAKALYASABaigAADYCACABQQRqIQEgAiADQQFqIgNGDQIMAQsLIAMgBkGs1cEAEIwHAAsgACgCgAIhAQsgACAAKAKQAiACIAAoAvwBIAEQtQQCQAJAAkAgACgC3AEiAyACQQJ0IgFPBEAgAEEANgLcASADIAFrIQYgBEUNASABIANGDQMgBkUNAiAAKALYASIDIAEgA2ogBvwKAAAMAgsMFAsgASADRg0BCyAAIAY2AtwBCyAAIAAoApACIAJqIgI2ApACIAIgACgCiAJHDQwgAEEANgKQAkEJIQELIAAgAToAlAIMCwsgACgC3AEiAUEBdiICIAAoAogCIAAoApACayIESQRAIAIhBCABQYCACEkNCgtBgIAEIAQgBEGAgARPGyICIAAoAvQBIgFLBEAgAiABayIDIAAoAuwBIAFrSwRAIBcgASADQQJBAhCkBSAAKAL0ASEBCyAAKALwASIJIAFBAXRqIQYgA0ECTwR/IANBAXRBAmsiBQRAIAZBACAF/AsACyABIANqIgNBAWshASAJIANBAXRqQQJrBSAGC0EAOwEAIAAgAUEBaiIBNgL0AQsgBARAQQAhA0ECIQECQANAIAAoAtwBIgYgAUkEQCABQQJrIAEgBkGc1cEAEOoHAAsgACgC9AEiBiADSwRAIAAoAvABIAFqQQJrIAAoAtgBIAFqQQJrLwAAOwEAIAFBAmohASACIANBAWoiA0YNAgwBCwsgAyAGQYzVwQAQjAcACyAAKAL0ASEBCyAAIAAoApACIAIgACgC8AEgARC0BAJAAkACQCAAKALcASIDIAJBAXQiAU8EQCAAQQA2AtwBIAMgAWshBiAERQ0BIAEgA0YNAyAGRQ0CIAAoAtgBIgMgASADaiAG/AoAAAwCCwwSCyABIANGDQELIAAgBjYC3AELIAAgACgCkAIgAmoiAjYCkAIgAiAAKAKIAkcNCiAAQQA2ApACIABBCDoAlAIMCgtBLSEPDAELQRghDwsgACgC3AEgD24iAiAAKAKIAiAAKAKQAmsiB0kEQCACIgdBgIAESQ0HC0GAgAQgByAHQYCABE8bIg4gD2wiDCAAKALoASIBSwRAIAwgAWsiAiAAKALgASABa0sEQCASIAEgAkEEQQQQpAUgACgC6AEhAQsgACgC5AEiBiABQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgQEQCADQQAgBPwLAAsgASACaiICQQFrIQEgBiACQQJ0akEEawUgAwtBADYCACAAIAFBAWoiATYC6AELIA5BCWwhEwJAIAcEQCAOQeAAbCEKIA5BGGwhCUEBIQFBACEQQQAhBgJAA0AgBiEEIAEhBiAEIA9sIgEgACgC3AEiAk8NAwJAAkACQAJAIARBCWwiAyAAKALoASICTw0AIAAoAuQBIANBAnRqIAAoAtgBIAFqLQAAs0MAAADDkkMAAAA8lDgCACABQQNqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EDaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQZqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EGaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQFqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EBaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQRqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EEaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQdqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EHaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQJqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0ECaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQVqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EFaiILIAAoAugBIgJPBEAgCyEDDAELIAAoAuQBIAtBAnRqIAAoAtgBIAVqLQAAs0MAAADDkkMAAAA8lDgCACABQQhqIgUgACgC3AEiAk8EQCAFIQEMCAsgA0EIaiIDIAAoAugBIgJPDQAgACgC5AEgA0ECdGogACgC2AEgBWotAACzQwAAAMOSQwAAADyUOAIAIAAoAowCQQFLDQEMAgsgAyACQfzUwQAQjAcACwJAAkAgAUEJaiIDIAAoAtwBIgVPDQAgBEEPbCATaiICIAAoAugBIgVPDQMgACgC5AEgAkECdGogACgC2AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBDGoiAyAAKALcASIFTw0AIAJBA2oiBCAAKALoASIFTwRAIAQhAgwECyAAKALkASAEQQJ0aiAAKALYASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEPaiIDIAAoAtwBIgVPDQAgAkEGaiIEIAAoAugBIgVPBEAgBCECDAQLIAAoAuQBIARBAnRqIAAoAtgBIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRJqIgMgACgC3AEiBU8NACACQQlqIgQgACgC6AEiBU8EQCAEIQIMBAsgACgC5AEgBEECdGogACgC2AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBFWoiAyAAKALcASIFTw0AIAJBDGoiBCAAKALoASIFTwRAIAQhAgwECyAAKALkASAEQQJ0aiAAKALYASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEKaiIDIAAoAtwBIgVPDQAgAkEBaiIEIAAoAugBIgVPBEAgBCECDAQLIAAoAuQBIARBAnRqIAAoAtgBIANqLQAAs0MAAADDkkMAAAA8lDgCACABQQ1qIgMgACgC3AEiBU8NACACQQRqIgQgACgC6AEiBU8EQCAEIQIMBAsgACgC5AEgBEECdGogACgC2AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBEGoiAyAAKALcASIFTw0AIAJBB2oiBCAAKALoASIFTwRAIAQhAgwECyAAKALkASAEQQJ0aiAAKALYASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUETaiIDIAAoAtwBIgVPDQAgAkEKaiIEIAAoAugBIgVPBEAgBCECDAQLIAAoAuQBIARBAnRqIAAoAtgBIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRZqIgMgACgC3AEiBU8NACACQQ1qIgQgACgC6AEiBU8EQCAEIQIMBAsgACgC5AEgBEECdGogACgC2AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBC2oiAyAAKALcASIFTw0AIAJBAmoiBCAAKALoASIFTwRAIAQhAgwECyAAKALkASAEQQJ0aiAAKALYASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEOaiIDIAAoAtwBIgVPDQAgAkEFaiIEIAAoAugBIgVPBEAgBCECDAQLIAAoAuQBIARBAnRqIAAoAtgBIANqLQAAs0MAAADDkkMAAAA8lDgCACABQRFqIgMgACgC3AEiBU8NACACQQhqIgQgACgC6AEiBU8EQCAEIQIMBAsgACgC5AEgBEECdGogACgC2AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAFBFGoiAyAAKALcASIFTw0AIAJBC2oiBCAAKALoASIFTwRAIAQhAgwECyAAKALkASAEQQJ0aiAAKALYASADai0AALNDAAAAw5JDAAAAPJQ4AgAgAUEXaiIDIAAoAtwBIgVPDQAgAkEOaiICIAAoAugBIgVPDQMgACgC5AEgAkECdGogACgC2AEgA2otAACzQwAAAMOSQwAAADyUOAIAIAAoAowCQQJNDQJBACEFIAohAwwBCyADIAVBzNTBABCMBwALAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQANAIAAoAtwBIgIgBSAQaiIBQRhqSwRAIAUgCWoiBCAAKALoASICTw0PIAAoAuQBIANqIAEgACgC2AFqQRhqLQAAs0MAAADDkkMAAAA8lDgCACAAKALcASICIAFBG2pNDQcgACgC6AEiAiAEQQNqTQ0OIAAoAuQBIANqQQxqIAEgACgC2AFqQRtqLQAAs0MAAADDkkMAAAA8lDgCACAAKALcASICIAFBHmpNDQYgACgC6AEiAiAEQQZqTQ0NIAAoAuQBIANqQRhqIAEgACgC2AFqQR5qLQAAs0MAAADDkkMAAAA8lDgCACAAKALcASICIAFBIWpNDQUgACgC6AEiAiAEQQlqTQ0MIAAoAuQBIANqQSRqIAEgACgC2AFqQSFqLQAAs0MAAADDkkMAAAA8lDgCACAAKALcASICIAFBJGpNDQQgACgC6AEiAiAEQQxqTQ0LIAAoAuQBIANqQTBqIAEgACgC2AFqQSRqLQAAs0MAAADDkkMAAAA8lDgCACAAKALcASICIAFBJ2pNDQMgACgC6AEiAiAEQQ9qTQ0KIAAoAuQBIANqQTxqIAEgACgC2AFqQSdqLQAAs0MAAADDkkMAAAA8lDgCACAAKALcASICIAFBKmpNDQIgACgC6AEiAiAEQRJqTQ0JIAAoAuQBIANqQcgAaiAAKALYASAQaiAFakEqai0AALNDAAAAw5JDAAAAPJQ4AgAgA0EEaiEDIAVBAWoiBUEDSQ0BDBALCyABQRhqDAYLIAFBKmoMBQsgAUEnagwECyABQSRqDAMLIAFBIWoMAgsgAUEeagwBCyABQRtqCyACQazUwQAQjAcACyAEQRJqIQQMBQsgBEEPaiEEDAQLIARBDGohBAwDCyAEQQlqIQQMAgsgBEEGaiEEDAELIARBA2ohBAsgBCACQbzUwQAQjAcACyAPIBBqIRAgCUEVaiEJIApB1ABqIQogBiAGIA5JIgJqIQEgAkUNAgwBCwsgAiAFQdzUwQAQjAcACyAAKALoASEBCwJAAkACQAJAAkACQCABIBNPBEAgACgC5AEhBiAAKAKQAiEEQQAhAkEEIQkCQCAAKAKMAiIKQQJJBEBBBCEQQQAhBQwBCyAOQRhsIgMgAUsNAiAOQQ9sIQUgBiATQQJ0aiEQIApBAkYNACABIAxJIAMgDEtyDQcgDCADayECIAYgA0ECdGohCQsgBwRAIAAgBCAOIAYgExDOAwsgBQRAIAAgBCAOIBAgBRDiAwsgAgRAIAAgBCAOIAkgAhDjAwsgACgC3AEiAiAMSQ0CIABBADYC3AEgAiAMayEBIAdFDQMgAiAMRg0FIAFFDQQgACgC2AEiAiACIAxqIAH8CgAADAQLQQAgEyABQZzUwQAQ6gcACyATIAMgAUGM1MEAEOoHAAtBACAMIAJBhKTHABDqBwALIAIgDEYNAQsgACABNgLcAQsgACAAKAKQAiAOaiICNgKQAiACIAAoAogCRw0JIABBADYCkAIgAEEGOgCUAgwJCyADIAwgAUH808EAEOoHAAsgASACQezUwQAQjAcACyAAKALcAUEEQQMgACgChAIiA0EDRhsiEG4iAiAAKAKIAiAAKAKQAmsiBkkEQCACIgZBgIAESQ0GCwJAAkACQAJAAkACQAJAAkACQAJAAkBBgIAEIAYgBkGAgARPGyIFQQJ0IgIgACgC6AEiAUsEfyACIAFrIgIgACgC4AEgAWtLBEAgEiABIAJBBEEEEKQFIAAoAugBIQELIAAoAuQBIgQgAUECdGohAyACQQJPBH8gAkECdEEEayIJBEAgA0EAIAn8CwALIAEgAmoiAkEBayEBIAQgAkECdGpBBGsFIAMLQQA2AgAgACABQQFqNgLoASAAKAKEAgUgAwtBA0cEQCAGRQ0LQQAhBEEAIQFBACECQQAhAwNAIAEgACgC3AEiCU8NAiABQQFqIgcgCU8NAyABQQJqIgcgCU8NBEMAAIA/IAAoAtgBIAFqIgktAACzQwAA/0KVQwAAgL+SIhkgGZQgCUEBai0AALNDAAD/QpVDAACAv5IiGiAalJIgCUECai0AALNDAAD/QpVDAACAv5IiGyAblJKTQwAAAAAQ4AghHCADIAAoAugBIglPDQUgACgC5AEgAmogGTgCACADQQFqIgkgACgC6AEiB08NBiAAKALkASACakEEaiAaOAIAIANBAmoiCSAAKALoASIHTw0HIAAoAuQBIAJqQQhqIBs4AgAgA0EDaiIJIAAoAugBIgdPDQggACgC5AEgAmpBDGogHJE4AgAgAUEDaiEBIAJBEGohAiADQQRqIQMgBEEBaiIEIAVJDQALDAsLIAZFDQpBACECQQEhCUEAIQMDQAJAAkACQAJAIAAoAtwBIgEgA0sEQCADQQFqIgQgAU8NASADQQJqIgcgAU8NAiADQQNqIgogAU8NAyAAKALYASADaiIBQQJqLQAAIQwgAUEDai0AACELIAEtAAAgAUEBai0AACEOIAj9DAAAAAAAAAAAAAAAAAAAAAD9CwNQIA5BCHRyIg8gDEEQdCALQRh0cnIhAUMAAAAAIRkCfwJAIAtBBnYiDEEDRwRAIAggD0H/A3GzQwCA/0OVQ/MENT+UIhmMIBkgDkECcRsiGTgCXCAZIBmUIRkgAUEKdiEBIAxBAkYNAQsgCCABQf8DcbNDAID/Q5VD8wQ1P5QiGowgGiABQYAEcRsiGjgCWCAZIBogGpSSIRkgAUEKdiIBIAxBAUYNARoLIAggAUH/A3GzQwCA/0OVQ/MENT+UIhqMIBogAUGABHEbIho4AlQgGSAaIBqUkiEZIAFBCnYLIQEgCEHQAGogDEECdGpDAACAPyALQcAATwR9IAggAUH/A3GzQwCA/0OVQ/MENT+UIhqMIBogAUGABHEbIho4AlAgGSAaIBqUkgUgGQuTIhmRQwAAAAAgGUMAAAAAXhs4AgAgAyAAKALoASIBSQ0EIAMgAUG80sEAEIwHAAsgAyABQfzRwQAQjAcACyAEIAFBjNLBABCMBwALIAcgAUGc0sEAEIwHAAsgCiABQazSwQAQjAcACyAAKALkASACaiAIKgJQOAIAIAQgACgC6AEiAU8NCiAAKALkASACakEEaiAIKgJUOAIAIAcgACgC6AEiAU8NCSAAKALkASACakEIaiAIKgJYOAIAIAogACgC6AEiAU8NCCAAKALkASACakEMaiAIKgJcOAIAIAJBEGohAiADQQRqIQMgBSAJSyAJQQFqIQkNAAsMCgsgASAJQfzSwQAQjAcACyAHIAlBjNPBABCMBwALIAcgCUGc08EAEIwHAAsgAyAJQazTwQAQjAcACyAJIAdBvNPBABCMBwALIAkgB0HM08EAEIwHAAsgCSAHQdzTwQAQjAcACyAKIAFB7NLBABCMBwALIAcgAUHc0sEAEIwHAAsgBCABQczSwQAQjAcACyAAIAAoApACIAUgACgC5AEgACgC6AEQ+wQCQAJAAkAgACgC3AEiASAFIBBsIgJPBEAgAEEANgLcASABIAJrIQMgBkUNASABIAJGDQMgA0UNAiAAKALYASIBIAEgAmogA/wKAAAMAgsMDwsgASACRg0BCyAAIAM2AtwBCyAAIAAoApACIAVqIgI2ApACIAIgACgCiAJHDQYgAEEANgKQAiAAQQU6AJQCDAYLIAAoAtwBIgFBA24iAiAAKAKIAiAAKAKQAmsiCUkEQCACIQkgAUGAgAxJDQULQYCABCAJIAlBgIAETxsiBEEDbCIGIAAoAugBIgFLBEAgBiABayICIAAoAuABIAFrSwRAIBIgASACQQRBBBCkBSAAKALoASEBCyAAKALkASIFIAFBAnRqIQMgAkECTwR/IAJBAnRBBGsiBwRAIANBACAH/AsACyABIAJqIgJBAWshASAFIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBaiIBNgLoAQsCQAJAAkACQAJAAkACQAJAAkAgCQRAQQAhA0EAIQEDQCABIAAoAtwBIgJPDQIgASAAKALoASICTw0DIAAoAuQBIANqIAAoAtgBIAFqLQAAs0MAAIA9lEMAACDBkhCJBDgCACABQQFqIgIgACgC3AEiBU8NBCACIAAoAugBIgVPDQUgACgC5AEgA2pBBGogACgC2AEgAWpBAWotAACzQwAAgD2UQwAAIMGSEIkEOAIAIAFBAmoiAiAAKALcASIFTw0GIAIgACgC6AEiBU8NByAAKALkASADakEIaiAAKALYASABakECai0AALNDAACAPZRDAAAgwZIQiQQ4AgAgA0EMaiEDIAYgAUEDaiIBRw0ACyAAKALoASEBCyAAIAAoApACIAQgACgC5AEgARDJAyAAKALcASICIAZJDRUgAEEANgLcASACIAZrIQEgCUUNBiACIAZGDQggAUUNByAAKALYASICIAIgBmogAfwKAAAMBwsgASACQZzRwQAQjAcACyABIAJBrNHBABCMBwALIAIgBUG80cEAEIwHAAsgAiAFQczRwQAQjAcACyACIAVB3NHBABCMBwALIAIgBUHs0cEAEIwHAAsgAiAGRg0BCyAAIAE2AtwBCyAAIAAoApACIARqIgI2ApACIAIgACgCiAJHDQUgAEEANgKQAiAAQQQ6AJQCDAULIAAoAtwBIgFBA24iAiAAKAKIAiAAKAKQAmsiCUkEQCACIQkgAUGAgAxJDQQLQYCABCAJIAlBgIAETxsiBEEDbCIGIAAoAugBIgFLBEAgBiABayICIAAoAuABIAFrSwRAIBIgASACQQRBBBCkBSAAKALoASEBCyAAKALkASIFIAFBAnRqIQMgAkECTwR/IAJBAnRBBGsiBwRAIANBACAH/AsACyABIAJqIgJBAWshASAFIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBaiIBNgLoAQsCQAJAAkACQAJAAkACQAJAAkAgCQRAQQAhA0EAIQEDQCABIAAoAtwBIgJPDQIgASAAKALoASICTw0DIAAoAuQBIANqIAAoAtgBIAFqLQAAs0MAAH9DlUMAAAC/kkOMuPA/lEMAAAA/kjgCACABQQFqIgIgACgC3AEiBU8NBCACIAAoAugBIgVPDQUgACgC5AEgA2pBBGogACgC2AEgAWpBAWotAACzQwAAf0OVQwAAAL+SQ4y48D+UQwAAAD+SOAIAIAFBAmoiAiAAKALcASIFTw0GIAIgACgC6AEiBU8NByAAKALkASADakEIaiAAKALYASABakECai0AALNDAAB/Q5VDAAAAv5JDjLjwP5RDAAAAP5I4AgAgA0EMaiEDIAYgAUEDaiIBRw0ACyAAKALoASEBCyAAIAAoApACIAQgACgC5AEgARCWBCAAKALcASICIAZJDRQgAEEANgLcASACIAZrIQEgCUUNBiACIAZGDQggAUUNByAAKALYASICIAIgBmogAfwKAAAMBwsgASACQbzQwQAQjAcACyABIAJBzNDBABCMBwALIAIgBUHc0MEAEIwHAAsgAiAFQezQwQAQjAcACyACIAVB/NDBABCMBwALIAIgBUGM0cEAEIwHAAsgAiAGRg0BCyAAIAE2AtwBCyAAIAAoApACIARqIgI2ApACIAIgACgCiAJHDQQgAEEANgKQAiAAQQM6AJQCDAQLIAAoAtwBIgIgACgCiAIgACgCkAJrIgZJBEAgAiIGQYCABEkNAwtBgIAEIAYgBkGAgARPGyIEIAAoAugBIgFLBEAgBCABayICIAAoAuABIAFrSwRAIBIgASACQQRBBBCkBSAAKALoASEBCyAAKALkASIJIAFBAnRqIQMgAkECTwR/IAJBAnRBBGsiBQRAIANBACAF/AsACyABIAJqIgJBAWshASAJIAJBAnRqQQRrBSADC0EANgIAIAAgAUEBajYC6AELAkACQAJAAkACQAJAAkACQCAGBEBDAACAP0MAAABAIAAsAJYCQQBOGyEZQQAhA0EAIQEDQCABIAAoAtwBIgJPDQMgASAAKALoASICTw0EIAAoAuQBIANqIBkgACgC2AEgAWotAACzQwAAf0OVlDgCACADQQRqIQMgBCABQQFqIgFHDQALIAAoAuQBIQcgACgC6AEhCSAAIAAoApACIAQQzANBACECIAQhBSAJIQNBACEBA0AgACgCZCIKIAFBA2pNDQUgAwRAIAAoAmAgAmpBA2pB/wFDAAB/Q0MAAAAAIAEgB2oqAgBDAAAAQEMAAIA/IAAtAJwBQQFxG5VDAAB/Q5QiGSAZQwAAAABdGyIZIBlDAAB/Q14bELkHIhn8AUEAIBlDAAAAAGAbIBlDAAB/Q14bOgAAIAJBEGohAiADQQFrIQMgAUEEaiEBIAVBAWsiBQ0BDAMLCyAJIAlBqNvAABCMBwALIAAgACgCkAIgBBDMAwsgAEEBOgC4ASAAKALcASICIARJDQMgAEEANgLcASACIARrIQEgBkUNBCACIARGDQYgAUUNBSAAKALYASICIAIgBGogAfwKAAAMBQsgASACQZzQwQAQjAcACyABIAJBrNDBABCMBwALIAEgAUEEaiAKQbjbwAAQ6gcAC0EAIAQgAkGEpMcAEOoHAAsgAiAERg0BCyAAIAE2AtwBCyAAIAAoApACIARqIgI2ApACIAIgACgCiAJHDQMgAEEANgKQAiAAQQI6AJQCDAMLIAZFDQBBASAALQCVAnSzIRlBACEJQQAhAUEAIQJBACEDAkACQAJAAkADQCABQQNqIgQgACgC3AEiB0sEQCABIAQgB0GM0MEAEOoHAAsgAyAAKALoASIHTw0BIAAoAuQBIAJqIAAoAtgBIAFqIgdBAmotAAAiCkEQdCAHLQAAciAHQQFqLQAAQQh0ciIHQYCAgHhyIAcgCsBBAEgbsiAZlTgCACABQQZqIgcgACgC3AEiCksNAiADQQFqIgQgACgC6AEiCk8NAyAAKALkASACakEEaiAAKALYASABaiIEQQVqLQAAIgpBEHQgBEEDai0AAHIgBEEEai0AAEEIdHIiBEGAgIB4ciAEIArAQQBIG7IgGZU4AgAgAUEJaiIEIAAoAtwBIgpLDQQgA0ECaiIHIAAoAugBIgpJBEAgACgC5AEgAmpBCGogACgC2AEgAWoiAUEIai0AACIHQRB0IAFBBmotAAByIAFBB2otAABBCHRyIgFBgICAeHIgASAHwEEASBuyIBmVOAIAIAJBDGohAiADQQNqIQMgBCEBIAlBAWoiCSAFSQ0BDAYLCyAHIApB3M/BABCMBwALIAMgB0G8z8EAEIwHAAsgBCAHIApB/M/BABDqBwALIAQgCkHMz8EAEIwHAAsgByAEIApB7M/BABDqBwALIAAgACgCkAIgBSAAKALkASAAKALoARCjAgJAAkACQCAAKALcASIBIAUgDGwiAk8EQCAAQQA2AtwBIAEgAmshAyAGRQ0BIAEgAkYNAyADRQ0CIAAoAtgBIgEgASACaiAD/AoAAAwCCwwKCyABIAJGDQELIAAgAzYC3AELIAAgACgCkAIgBWoiAjYCkAIgAiAAKAKIAkcNASAAQQA2ApACIABBAToAlAIMAQsLIAgtAA8hAQsgDSAUaiENAkACQAJAAkACQCABQf8BcQ4DAQIDAAsgCEEBNgJUIAhBmPfHADYCUCAIQgE3AlwgCCAIQQ9qrUKAgICAoASENwNAIAggCEFAazYCWCAIQRBqIgAgCEHQAGoQsQYgABCOByEBDAYLIABBAToAoVQgDUEIaiANIAAoAsQBIgIgDWsiAUEAIAEgAk0bQQdLGyENDAILIBEgFHJFDQELIA0gACgCxAEiA0kNAQsLIA1FDQAgDSAAKALEASICTQRAQQAhASAAQQA2AsQBIAIgDUYNAiACIA1rIgIEQCAAKALAASIDIAMgDWogAvwKAAALIAAgAjYCxAEMAgtBACANIAJBhKTHABDqBwALQQAhAQsgCEHwAGokACABDwtBACABIANBhKTHABDqBwALQQAgAiABQYSkxwAQ6gcAC0EAIAYgAkGEpMcAEOoHAAvVVgMffwR+AXsjAEGgBWsiDiQAAkACQCAAAn8CQCABLQCjByIKQQdGBEAgAEIANwIEDAELIAUgBk8EQCABKAKIByEIIAFBADYCiAcgBiELAkAgCEEBcUUNACAFIAtrIhUgASgCkAciDCAMIBVLGyIIRSAIRXJFBEAgBCALaiABLQCMByAI/AsACyAMIBVNBEAgBiAMaiELDAELIAFBATYCiAcgACAVNgIIIABBADYCBCABIAwgFWs2ApAHQQAMAwsgASgClAchCCABQQA2ApQHAkACQAJAIAhBAXEEQCAFIAtrIhkgASgCnAciGyAZIBtJGyIRBEBBACEMAkAgEUEBayIJIAEoApgHIhggBSALIBhrIgggBSAISxtqIAtrIgggGUEAIAUgGU8bIhAgCCAQSRsiCCAIIAlLGyIVQQFqIg9BEUkEQEEBIQkMAQtBASEJIBhBD00NACAPQQ9xIghBECAIGyIJIBVBf3NqIQggBCALaiENQQAgGGshFSAPIAlrIgxBAWohCQNAIA0gDSAVav0AAAD9CwAAIA1BEGohDSAIQRBqIggNAAsLIBBBAWohFSARQQFqIQgDQCALIAxqIg8gGGsiDCAFTw0EIAkgFUYNAyAEIA9qIAQgDGotAAA6AAAgCSEMIAggCUEBaiIJRw0ACwsgGSAbSQ0DIAsgG2ohCwsgAUHsBmohIiABQeAGaiEjIAVBEGshHSABQaAGaiEgIAFBgARqIR4gDkE+aiEkIA5BkAVqISUgAyENAkACQANAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCiIVQf8BcSImQQFrDgcCCAcGAAUEAQsgAS0AogciDEUgAS8BoAciCUVyIAUgC01yRQRAIAEpA9AGIScDQAJAIAQgC2ogJzwAACALQQFqIQsgJ0IIiCEnIAxBCGsiDEH/AXFFIAlBAWsiCUH//wNxRXINACAFIAtLDQELCyABIAw6AKIHIAEgJzcD0AYgASAJOwGgBwsgDEH/AXFFBEAgAUIANwPQBgsgBSALSQ0CIAUgC2siCiANIAlB//8DcSIMIAwgDUsbIgggCCAKSxsiCARAIAQgC2ogAiAI/AoAAAsgASAJIAhrOwGgByAIIAtqIQsgAiAIaiECIA0gCGshDSAIIAxHDQogAUEGQQEgAS0ApAcbOgCjBwwKCyANQQhPBEAgASABKQPQBiACKQAAIAEtAKIHIghBP3GthoQiJzcD0AZBPyAIa0EDdiIJIA1NBEAgASAIQThyIgo6AKIHIA0gCWshDQwKCwwVCyABLQCiByEMIA5CADcDIEE/IAxrQQN2IgggDSAIIA1JGyIJBEAgDkEgaiACIAn8CgAACyABIAlBA3QgDGoiCjoAogcgASABKQPQBiAOKQMgIAythkIAIAxBwABJG4QiJzcD0AYgDSAJayENIApB/wFxQRBPDQhBACEVDAoLIAEpA9AGIScgAS0AogchCQNAAkAgDUEITwRAIAEgAikAACAJrYYgJ4QiJzcD0AZBPyAJQf8BcWtBA3YiCCANTQRAIAEgCUE4ciIMOgCiByACIAhqIQIgDSAIayENDAILIAggDSANQZiNxAAQ6gcACyAOQgA3AyBBPyAJQf8BcSIKa0EDdiIIIA0gCCANSRsiCARAIA5BIGogAiAI/AoAAAsgASAIQQN0IAlqIgw6AKIHIAEgDikDICAJrYZCACAKQcAASRsgJ4QiJzcD0AYgAiAIaiECIA0gCGshDSAMQf8BcUEKSQ0KCyABICenIg9BAXEiCDoApAcCQCAAAn8CQAJAAkACQAJAIA9BAXZBA3FBAWsOAwIBBAALIAxBBWpBB3EiCUEjaiIIIAxB/wFxSw0PQQMgJ0J/IAlBE2qtIiqGQn+FgyAJQQNqrYgiKSAnQn8gCK0iKIZCf4WDICqIhUL//wODQv//A1INBBogASApPQGgByABQQU6AKMHIAEgDCAIazoAogcgASAnICiINwPQBgwPCyAMQf8BcUERSQ0OIAEgD0ENdkEPcUEEajYCyAYgASAPQQh2QR9xIglBAWo2AsQGIAEgD0EDdkEfcSIIQYECajYCwAZBBCAIQR1LDQMaIAlBHU0NAUEFDAMLIAEgDEEDazoAogcgASAnQgOINwPQBiAnQvgHg1ANAyABLQClB0UEQCABQQE6AKUHIAEoAvgGIQpBACIIRQRAIApB7J3EAEGAEPwKAAALIAhFBEAgCkGAEGpB7J3EAEGAEPwKAAALIAhFBEAgCkGAIGpB7J3EAEGAEPwKAAALIAhFBEAgCkGAMGpB7J3EAEGAEPwKAAALIAhFBEAgCkGAQGtB7J3EAEGAEPwKAAALIAhFBEAgCkGA0ABqQeydxABBgBD8CgAACyAIRQRAIApBgOAAakHsncQAQYAQ/AoAAAsgCEUEQCAKQYDwAGpB7J3EAEGAEPwKAAALIAEoAvwGIQpBAEUEQCAKQeycxABBgAH8CgAACyAIRQRAIApBgAFqQeycxABBgAH8CgAACyAIRQRAIApBgAJqQeycxABBgAH8CgAACyAIRQRAIApBgANqQeycxABBgAH8CgAACyAIRQRAIApBgARqQeycxABBgAH8CgAACyAIRQRAIApBgAVqQeycxABBgAH8CgAACyAIRQRAIApBgAZqQeycxABBgAH8CgAACyAIRQRAIApBgAdqQeycxABBgAH8CgAACyAIRQRAIApBgAhqQeycxABBgAH8CgAACyAIRQRAIApBgAlqQeycxABBgAH8CgAACyAIRQRAIApBgApqQeycxABBgAH8CgAACyAIRQRAIApBgAtqQeycxABBgAH8CgAACyAIRQRAIApBgAxqQeycxABBgAH8CgAACyAIRQRAIApBgA1qQeycxABBgAH8CgAACyAIRQRAIApBgA5qQeycxABBgAH8CgAACyAIRQRAIApBgA9qQeycxABBgAH8CgAACyABQYCA/AM2AoAHIAFBBzoAhAcLIAFBBDoAowcMDQsgAUEAOgClByABQQI6AKMHIAEgDEERazoAogcgASAnQhGINwPQBgwMC0ECCzoAAUEBDBQLIAEgDEEKayIJOgCiByABICdCCogiJzcD0AYgCA0HIAlB/wFxQQpJDQADQCAnQv8Hg0ICUg0BIAEgCUEKayIPOgCiByABICdCCogiJzcD0AYCQAJAIA1BB00EQCAOQgA3AyBBPyAPQf8BcSIMa0EDdiIIIA0gCCANSRsiCgRAIA5BIGogAiAK/AoAAAsgASAKQQN0IA9qIgk6AKIHIAEgDikDICAPrYZCACAMQcAASRsgJ4QiJzcD0AYMAQsgASACKQAAIA+thiAnhCInNwPQBkE/IA9B/wFxa0EDdiIKIA1LDQEgASAPQThyIgk6AKIHCyACIApqIQIgDSAKayENIAlB/wFxQQlNDQIMAQsLCwwUCyALIAUgBUGMsMQAEOoHAAtBpPjGAEEoQbywxAAQ6wcACwJAAkACQAJAIA1BB00EQCABLQCiByEKIA5CADcDIEE/IAprQQN2IgggDSAIIA1JGyIJBEAgDkEgaiACIAn8CgAACyABIAlBA3QgCmoiDDoAogcgASABKQPQBiAOKQMgIAqthkIAIApBwABJG4Q3A9AGDAELIAEgASkD0AYgAikAACABLQCiByIIQT9xrYaENwPQBkE/IAhrQQN2IgkgDUsNFCABIAhBOHIiDDoAogcLIA0gCWshDSAMQf8BcSAMQQdxIghBIHJJBEAgAiAJaiECDAkLIAUgC0kgBiALS3INACAOQRBqIAEvAdwGIAEvAd4GIAQgBmogCyAGayIJIAEoAtgGEQcAIAEgDigCEDYC3AYgASkD0AYhJyAIDQEMAgsgBiALIAVBrLDEABDqBwALIAEgJyAIrYgiJzcD0AYgASABLQCiByAIazoAogcLAkAgAS0ApgdFBEAgASgC3AYgJ6ciAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnJHDQELIAFBBzoAowcgASAnQiCINwPQBiABIAEtAKIHQSBrOgCiBwwJCyAAQQ46AAFBAQwPCwJAAn8CQAJAAkACQAJAAkACQAJAAkAgDUEHTQRAIAEtAKIHIQogDkIANwMgQT8gCmtBA3YiCCANIAggDUkbIggEQCAOQSBqIAIgCPwKAAALIAEgCEEDdCAKaiIMOgCiByABIAEpA9AGIA4pAyAgCq2GQgAgCkHAAEkbhCInNwPQBiACIAhqIQIgDSAIayENIAEoAvgGIRwMAQsgASABKQPQBiACKQAAIAEtAKIHIghBP3GthoQiJzcD0AYgDUE/IAhrQQN2IgpJDRsgASAIQThyIgw6AKIHIAIgCmohAiABKAL4BiEcIA0gCmsiDUEISSALQQhqIAVLcg0AIBwgJ6dB/x9xQQJ0aigCACEKIAEoAvAGISEgASgC9AYhGiABKAL8BiEZIAEoAuQGIRsgASgC6AYhHwNAAn8CQCAKQYCAAnFFBEAgCiEJICchKAwBCwJAAkACQCAFIAtLBEAgHCAnIBwgJyAKrYgiKKdB/x9xQQJ0aigCACIJIApqIhggHCAnIBhBP3GtiCIpp0H/H3FBAnRqKAIAIg9qIhBBP3GtiCInp0H/H3FBAnRqKAIAIQggBCALaiAKQRB2OgAAIAUgC0EBaiIRTQRAIBEgBUH4l8QAEIwHAAsgBCARaiAKQRh2OgAAIApBCHZBD3EgC2ohCyAJQYCAAnFFDQICQCAFIAtLBEAgBCALaiAJQRB2OgAAIAtBAWoiCiAFTw0BIAQgCmogCUEYdjoAACAJQQh2QQ9xIAtqIQsgD0GAgAJxRQRAIAEgKTcD0AYgASAMIBhrIgw6AKIHIAEgAikAACAMQT9xrYYgKYQiJzcD0AYgDUE/IAxB/wFxa0EDdiIKTwRAIA8hCSAnISgMBwsMJQsgBSALTQRAIAsgBUH8msQAEIwHAAsgBCALaiAPQRB2OgAAIAtBAWoiCiAFSQ0DIAogBUGMm8QAEIwHAAsgCyAFQYiYxAAQjAcACyAKIAVBmJjEABCMBwALIAsgBUHol8QAEIwHAAsgASAnNwPQBiABIAwgEGsiCToAogcgBCAKaiAPQRh2OgAAIAEgAikAACAJQT9xrYYgJ4QiJzcD0AZBPyAJQf8BcWtBA3YiCiANTQRAIAEgCUE4ciIMOgCiByACIApqIQIgDSAKayENIAghCiALIA9BCHZBD3FqDAQLDCALIAEgKDcD0AYgASAMIAprIgw6AKIHIAxB/wFxQTBPBEAgKCEnDAILIAEgAikAACAMrYYgKIQiJzcD0AZBPyAMa0H4AXFBA3YhCgsgASAMQThyIgw6AKIHIAIgCmohAiANIAprIQ0LAkACQAJAAkACQAJ/IAlBgIABcUUEQCAJQRB2IRQgCUEIdgwBCyAJQYDAAHFFDQ0CQAJAIB8gCSAop0EMdnFB/wFxIAlBEHZqIghLBEAgGyAIQQF0ai8BACIIQQ9xIQkgCEEEdiEQIAhBgCBJDQEgEEGAAkcNAiAJDBQLIAggH0GomMQAEIwHAAsgASAMIAlrIhE6AKIHIAEgJyAJrYgiJzcD0AYgHCAnp0H/H3FBAnRqKAIAIQoCQCANQQdNBEAgDkIANwMgQT8gEUH/AXEiD2tBA3YiCCANIAggDUkbIgkEQCAOQSBqIAIgCfwKAAALIAEgCUEDdCARaiIMOgCiByABIA4pAyAgEa2GQgAgD0HAAEkbICeEIic3A9AGDAELIAEgAikAACARrYYgJ4QiJzcD0AZBPyARQf8BcWtBA3YiCSANSw0kIAEgEUE4ciIMOgCiBwsgBSALTQ0CIAQgC2ogEDoAACACIAlqIQIgDSAJayENIAtBAWoMBwsgEEGBAmsiCEEcSw0CIAhBAnQoAriYRCEUIAgtALyZRAshCCAZICggCa2IIiogCK0iKYgiKKciD0H/A3FBAnRqKAIAIgpBgIACcQ0CQQshECAKQYACSQ0OIAogD0EJdnFB/wFxIApBEHZqIgogGk8NAyAhIApBAXRqLwEAIg9B3wNLDQ4gD0EPcSEKIA9BBHYiDy0A7JlEIREgD0EBdC8Bxv5EIRIMBAsgCyAFQeyaxAAQjAcACyAIQR1BrJnEABCMBwALIApBEHYhEiAKQQh2QQ9xIREMAQsgCiAaQdyZxAAQjAcAC0J/IBGthkJ/hSAoIAqtiIOnIhggEkH//wNxIhBqIhYgC0sEQEENIRAMCgsgASAMIAggCWogEWogCmoiCGsiDzoAogcgASAnIAhBP3GtiCInNwPQBgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA1BB00EQCAOQgA3AyBBPyAPQf8BcSIJa0EDdiIIIA0gCCANSRsiCgRAIA5BIGogAiAK/AoAAAsgASAKQQN0IA9qIgw6AKIHIAEgDikDICAPrYZCACAJQcAASRsgJ4QiJzcD0AYMAQsgASACKQAAIA+thiAnhCInNwPQBkE/IA9B/wFxa0EDdiIKIA1LDSogASAPQThyIgw6AKIHCyAFIAtrIhIgFCAqQn8gKYZCf4WDp2oiEyASIBNJGyEXIAIgCmohAiANIAprIQ0gHCAnp0H/H3FBAnRqKAIAIQogFkEBRgRAIAtBAWsiCCAFTw0BIAQgCGotAAAhCCAXBEAgBCALaiAIIBf8CwALIBIgE08NDCABIAg6AIwHIAFBATYCiAcgASATIBJrNgKQBwwJCyALIBNqQQ9qIAVLDQcgCyAWayIQQRBqIgggBUsNASAQQW9LDQIgCyAdSw0DIAQgC2ogBCAQav0AAAD9CwAAIBZBEE8iCCATQRBNcQ0LIBZFDQQgE0EQIBYgCBsiD24iCCATIAggD2xHaiIJQQJJDQsgDyAQaiIQQRBqIgggBUsNBSAQQW9LDQYgHSALIA9qTwRAIAlBAmshCCAPQQF0IBZrIRQgBCAPaiERIAQgDyAWa2ohEiAPIQkDQCALIBFqIAsgEmr9AAAA/QsAACAIRQ0NAkAgBSALIBRqIhBBEGpPBEAgEEFvTQ0BIBBBEGohCAwKCyALIBRqQRBqIQgMCAsgCEEBayEIIA8gFGohFCAPIBFqIREgDyASaiESIAsgCSAPaiIJaiAdTQ0ACwsgDkEANgIwIA5BATYCJCAOQdScyAA2AiAgDkIENwIoIA5BIGpB3JrEABCNCAALIAggBUGMmsQAEIwHAAtBACAIIAVBzJrEABDqBwALIBAgCCAFQcyaxAAQ6gcACyAOQQA2AjAgDkEBNgIkIA5B1JzIADYCICAOQgQ3AiggDkEgakHMmsQAEI0IAAtBuP3GAEEbQdT9xgAQ6wcAC0EAIAggBUHcmsQAEOoHAAsgECAIIAVB3JrEABDqBwALAkACQCAWIBdJBEBBACEIIBdBAWsiDyAFIAsgFmsiCSAFIAlLGyAQaiAYaiALayIJIBJBACAFIBJPGyIYIAkgGEkbIgkgCSAPSxsiD0EBaiIQQRFJBEBBASEJDAILQQEhCSAWQQ9NDQEgEEEPcSIIQRAgCBsiCCAPQX9zaiEUIAQgC2ohEUEAIBZrIQ8gECAIayIIQQFqIQkDQCARIA8gEWr9AAAA/QsAACARQRBqIREgFEEQaiIUDQALDAELAkACQCAFIAsgF2ogFmsiCE8EQCAIIAsgFmsiCUkNASALIAUgCCAJayIIa0sNAiAIRQ0EIAQgC2ogBCAJaiAI/AoAAAwEC0EAIAggBUGcmsQAEOoHAAsgCSAIIAVBnJrEABDqBwALIA5BADYCMCAOQQE2AiQgDkHUnMgANgIgIA5CBDcCKCAOQSBqQZyaxAAQjQgACyAYQQFqIRAgF0EBaiEPA0AgCCALaiIRIBZrIgggBU8NAyAJIBBGDQQgBCARaiAEIAhqLQAAOgAAIA8gCSIIQQFqIglHDQALCyASIBNPDQMgASAWNgKYByABQQE2ApQHIAEgEyASazYCnAcLIAUhCwwFCyAIIAVBrJrEABCMBwALIBEgBUG8msQAEIwHAAsgCyAXagsiC0EIaiAFSw0BIA1BB0sNAAsLIAEoAvAGIRkgASgC9AYhHyABKAL8BiEbIAEoAuQGIRggASgC6AYhIQNAAkACQAJAAkACQAJAAkACQCANQQdNBEAgDkIANwMgQT8gDEH/AXEiD2tBA3YiCCANIAggDUkbIgkEQCAOQSBqIAIgCfwKAAALIAEgCUEDdCAMaiIKOgCiByABIA4pAyAgDK2GQgAgD0HAAEkbICeEIic3A9AGDAELIAEgAikAACAMrYYgJ4QiJzcD0AZBPyAMQf8BcWtBA3YiCSANSw0iIAEgDEE4ciIKOgCiBwsgAiAJaiECIA0gCWshDSAFIAtGBEAgCiEMDAsLAkACQAJ/AkAgHCAnpyIIQf8fcUECdGooAgAiCUGAgAJxRQRAIAlBgIABcQ0BIAlBEHYhEiAJQQh2DAILIApB/wFxIAlB/wFxTw0DDA0LIAlBgMAAcUUNCyAIQQx2IAlxQf8BcSAJQRB2aiIIICFPDQYgGCAIQQF0ai8BACIIQQ9xIgkgCkH/AXFLDQwgCEEEdiEPIAhBgCBJDQEgD0GAAkYEQCABICcgCa2INwPQBiAKIAlrIQkMFQsgD0GBAmsiCEEcSw0DIAhBAnQoAriYRCESIAgtALyZRAshCCAbICcgCa2IIiogCK0iKYgiKKciD0H/A3FBAnRqKAIAIgxBgIACcQ0DIApB/wFxIAggCWoiCEEJakH/AXFNDQtBCyEQIAxBgAJJDRAgDCAPQQl2cUH/AXEgDEEQdmoiCSAfTw0EIBkgCUEBdGovAQAiCUHfA0sNECAJQQ9xIQwgCUEEdiIPLQDsmUQhCSAPQQF0LwHG/kQhEQwICyABIAogCWsiDDoAogcgASAnIAmtiCInNwPQBiAFIAtLBEAgBCALaiAPOgAAIAtBAWohCwwJCyALIAVBrJzEABCMBwALIAlBCHZBD3EhDyAFIAtBAWoiCE0EQCAFIAsgD2pHBEAgBSALSwRAIAFBATYCkAcgAUEBNgKIByABIAlBGHY6AIwHIAQgC2ogCUEQdjoAACABIAogCWsiDDoAogcgASAnIAmtiCInNwPQBgwOCyALIAVBvJzEABCMBwALIAUgC0sNBiALIAVBzJzEABCMBwALIAUgC0sNBCALIAVB3JzEABCMBwALIAhBHUGsm8QAEIwHAAsgCCAJaiEIIAxBEHYhESAMQQh2QQ9xIQkMBAsgCSAfQbybxAAQjAcACyAIICFBnJvEABCMBwALIAQgCGogCUEYdjoAACAEIAtqIAlBEHY6AAAgASAKIAlrIgw6AKIHIAEgJyAJrYgiJzcD0AYgCyAPaiELDAILIAEgCiAJayIMOgCiByAEIAtqIAlBEHY6AAAgASAnIAmtiCInNwPQBgwFCyAKQf8BcSAIIAlqIAxqIhBB/wFxSQ0CQn8gCa2GQn+FICggDK2Ig6ciDyARQf//A3EiCGoiEyALSwRAQQ0hEAwICyABIAogEGsiDDoAogcgASAnIBCtiCInNwPQBiAFIAtrIhcgEiAqQn8gKYZCf4WDp2oiEiASIBdLGyEaAkACQAJAAkACQAJAAkACQAJAIBNBAUYEQCALQQFrIgggBU8NASAEIAhqLQAAIQggEkUgGkVyRQRAIAQgC2ogCCAa/AsACyASIBdNDQkgASAIOgCMByABQQE2AogHIAEgEiAXazYCkAcMDQsgCyASakEPaiAFSw0HIAsgE2siCkEQaiIIIAVLDQEgCkFvSw0CIAsgHUsNAyAEIAtqIAQgCmr9AAAA/QsAACATQRBPIgggEkEQTXENCCATRQ0EIBJBECATIAgbIgluIgggEiAIIAlsR2oiCEECSQ0IIAkgCmoiFEEQaiIKIAVLDQUgFEFvSw0GIB0gCSALak8EQCAIQQJrIQogCUEBdCATayESIAQgCWohCCAEIAkgE2tqIREgCSEQA0AgCCALaiALIBFq/QAAAP0LAAAgCkUNCgJAIAUgCyASaiIUQRBqTwRAIBRBb00NASAUQRBqIQoMCgsgCyASakEQaiEKDAgLIApBAWshCiAJIBJqIRIgCCAJaiEIIAkgEWohESALIAkgEGoiEGogHU0NAAsLIA5BADYCMCAOQQE2AiQgDkHUnMgANgIgIA5CBDcCKCAOQSBqQZycxAAQjQgACyAIIAVBzJvEABCMBwALQQAgCCAFQYycxAAQ6gcACyAKIAggBUGMnMQAEOoHAAsgDkEANgIwIA5BATYCJCAOQdScyAA2AiAgDkIENwIoIA5BIGpBjJzEABCNCAALQbj9xgBBG0HU/cYAEOsHAAtBACAKIAVBnJzEABDqBwALIBQgCiAFQZycxAAQ6gcACwJAAkACQAJAIBMgGkkEQEEAIQogGkEBayIJIAggBSALIBNrIgggBSAISxtqIA9qIAtrIgggF0EAIAUgF08bIhEgCCARSRsiCCAIIAlLGyIPQQFqIhBBEUkEQEEBIQkMAgtBASEJIBNBD00NASAQQQ9xIghBECAIGyIKIA9Bf3NqIRQgBCALaiEIQQAgE2shDyAQIAprIgpBAWohCQNAIAggCCAPav0AAAD9CwAAIAhBEGohCCAUQRBqIhQNAAsMAQsCQAJAIAUgCyAaaiATayIITwRAIAggCyATayIKSQ0BIAsgBSAIIAprIghrSw0CIAhFDQQgBCALaiAEIApqIAj8CgAADAQLQQAgCCAFQdybxAAQ6gcACyAKIAggBUHcm8QAEOoHAAsgDkEANgIwIA5BATYCJCAOQdScyAA2AiAgDkIENwIoIA5BIGpB3JvEABCNCAALIBFBAWohDyAaQQFqIQgDQCAKIAtqIhAgE2siCiAFTw0CIAkgD0YNAyAEIBBqIAQgCmotAAA6AAAgCSEKIAggCUEBaiIJRw0ACwsgEiAXTQ0CIAEgEzYCmAcgAUEBNgKUByABIBIgF2s2ApwHIAUhCwwSCyAKIAVB7JvEABCMBwALIBAgBUH8m8QAEIwHAAsgCyAaaiELDAALAAsgCUH/AXEiCEUNBCAKQf8BcSAISQ0AIAEgJyAJrYg3A9AGIAogCWshCQwICyAKIQwgCyEIDAELIAUhCAsgASgClAcEQCAIIQsMCwsgASgCiAcEQCAIIQsMCwsgDEH/AXFBD0kEQCAIIQsMCwsgAS8BgAcgAS8BggcgJ6dxQf//AXFHBEAgCCELDAsLIAEgJyABLQCEByILQT9xrYg3A9AGIAwgC2shCSAIIQsMBQsgCUH/AXENAgtBCiEQCyAAIBA6AAFBAQwRCyAJQT9xCyEKIAEgJyAKrYg3A9AGIAwgCWshCQsgASAJOgCiByABQQZBASABLQCkBxs6AKMHDAQLAkAgASgCzAYiCSABKALABiIMIAEoAsQGaiIQSQRAA0ACQCANQQhPBEAgASABKQPQBiACKQAAIAEtAKIHIghBP3GthoQiJzcD0AZBPyAIa0EDdiIKIA1NBEAgASAIQThyIgg6AKIHIAIgCmohAiANIAprIQ0MAgsMFAsgAS0AogchDCAOQgA3AyBBPyAMa0EDdiIIIA0gCCANSRsiCgRAIA5BIGogAiAK/AoAAAsgASAKQQN0IAxqIgg6AKIHIAEgASkD0AYgDikDICAMrYZCACAMQcAASRuEIic3A9AGIAIgCmohAiANIAprIQ0gCEH/AXFBB0kNBwsgASAnp0H/AHFBAnRqKAIAIgpBB3EhDAJ+AkACQAJAIApBEHYiCkH/AXEiD0EQTwRAIA9BE08NAQJ/AkACQAJAAkAgD0ERaw4CAQIACyAMQQJqIhEgCEH/AXFLDQ8gCQ0CQQYhAQwLC0EDIQogDEEDaiIRIAhB/wFxSw0OQQAMAgsgDEEHaiIRIAhB/wFxSw0NQQshCkEADAELIAlBAWshCCAJQcACSw0DQQMhCiAIIB5qLQAACyEIIBAgCiAnQn8gEa0iKIZCf4WDIAytiKdqIgwgCWpJBEBBBiEBDAgLQQAhCQJAA0AgCSABKALMBmoiCkHAAk8NASAKIB5qIAg6AAAgDCAJQQFqIglHDQALIAEgASgCzAYgDGoiCTYCzAYgASkD0AYgKIgMBQsgCkHAAkGcrsQAEIwHAAsgCUHAAkkNAiAJQcACQayuxAAQjAcAC0Gk+MYAQShB/K3EABDrBwALIAhBwAJBjK7EABCMBwALIAkgHmogCjoAACABIAEoAswGQQFqIgk2AswGIAwhESABKQPQBiAMrYgLIScgASAnNwPQBiABIAEtAKIHIBFrOgCiByAJIBBJDQALIAEoAsAGIQwLAkACQAJAAkAgEEHAAk0EQCAMIBBLDQEgECAMayIIQSFPDQIgCARAICAgDCAeaiAI/AoAAAsCQCABKALABiIKQZ8CSw0AQaACIAprIghFDQAgCiAeakEAIAj8CwALAkAgASgCxAYiCkGgAmpBvwJLDQBBICAKayIIRQ0AIAogIGpBACAI/AsACyABLQCABiIIRQRAQQghAQwGCyABKALABiEKIA5BIGoiCUEAQcAE/AsAIAFBADYC6AYgCkHBAk8NAyAKQaECTw0EIB4gCkGojcQAQaACIAkgCiABKAL4BkGAICAjQQBBARB4RQRAQQchAQwGCyABIAg6AIQHIAEgDi8BoAQ7AYAHIAFBfyAIQQ9xdEF/czsBggcCQCAgQbiWxABBIBDbBwRAICX9DAAAAAAAAAAAAAAAAAAAAAD9CwMAIA5BgAVqICv9CwMAIA5B8ARqICv9CwMAIA4gK/0LA+AEICBBIEHYlsQAQSAgDkHgBGpBICABKAL8BkGABCAiQQFBABB4DQFBCSEBDAcLIAEoAvwGQQBBgBD8CwALIAFBBDoAowcMCQtBACAQQcACQeytxAAQ6gcACyAMIBBBwAJB7K3EABDqBwALIA5BADYCMCAOQQE2AiQgDkHUnMgANgIgIA5CBDcCKCAOQSBqQeytxAAQjQgAC0EAIApBwAJB2JfEABDqBwALQQAgCkGgAkGolsQAEOoHAAsgACABOgABQQEMDQsCQAJAAkAgDUEHTQRAIAEtAKIHIQwgDkIANwMgQT8gDGtBA3YiCCANIAggDUkbIgkEQCAOQSBqIAIgCfwKAAALIAEgCUEDdCAMaiIKOgCiByABIAEpA9AGIA4pAyAgDK2GQgAgDEHAAEkbhCInNwPQBgwBCyABIAEpA9AGIAIpAAAgAS0AogciCEE/ca2GhCInNwPQBkE/IAhrQQN2IgkgDUsNECABIAhBOHIiCjoAogcLIAIgCWohAiAKQf8BcSANIAlrIg1BA3RqIAEoAsgGIghBA2xJDQQgDkHvBGpBADYAACAO/QwAAAAAAAAAAAAAAAAAAAAA/QsD4AQgCARAQbR/IQkDQAJAAkACQCAJBEAgCUGIr8QAaigCACIPQRNPDQEgASAKQQNrIgw6AKIHIAEgJ0IDiCIoNwPQBiAOQeAEaiAPaiAnp0EHcToAACAJQXhGDQIgKCEnIAwhCgwDC0ETQRNBiK/EABCMBwALIA9BE0GYr8QAEIwHAAsgDUEHTQRAIA5CADcDIEE/IAxB/wFxIg9rQQN2IgogDSAKIA1JGyIQBEAgDkEgaiACIBD8CgAACyABIBBBA3QgDGoiCjoAogcgASAOKQMgIAythkIAIA9BwABJGyAohCInNwPQBiACIBBqIQIgDSAQayENDAELIAEgAikAACAMrYYgKIQiJzcD0AYgDUE/IAxB/wFxa0EDdiIPSQ0DIAEgDEE4ciIKOgCiByACIA9qIQIgDSAPayENCyAJQQRqIQkgCEEBayIIDQALCyAkQgA3AQAgDkEwaiAr/QsDACAOICv9CwMgIA5BADYCHCAOQoCAgIAgNwIUIA5B4ARqQRNBBEEAIA5BIGpBEyABQYABIA5BFGpBAEEAEHgNASAOKAIUIgEEQCAOKAIYIAFBAXRBAhCiBwsgAEEHOgABQQEMDgsgDyANIA1BmI3EABDqBwALAkACQCAOKAIUIgoEQCAOKAIYIgxBBGsoAgAiCEF4cSIJIApBAXQiCkEEQQggCEEDcSIIG2pJDQEgCEEAIAkgCkEnaksbDQIgDBCiAgsgAUEANgLMBiABQQM6AKMHDAQLQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyABQQY6AKMHDAELAkAgJ0KPwACDQghSICdC8AGDQvAAVnINACAnpyIIQQh0IAhBgP4DcUEIdnJB//8DcUEfcA0AIAIgCWohAiABQQE6AKMHIAEgCkEQazoAogcgASAnQhCINwPQBgwBCyAAQQA6AAFBAQwKCyAmIAEtAKMHIgpHDQELCwJAIBVB/wFxQQdGDQAgAS0ApgdBAXENACAFIAtJIAYgC0tyRQRAIA5BCGogAS8B3AYgAS8B3gYgBCAGaiALIAZrIAEoAtgGEQcAIAEgDigCCDYC3AYgAS0AowchFQwBCyAGIAsgBUGcsMQAEOoHAAsgB0UgFUH/AXFBB0ZyRSAFIAtHcQ0BIAsgBmshCQsgACAJNgIIIAAgAyANazYCBAwFCyAAQQE6AAFBAQwFCyAPIAVB/K/EABCMBwALIAwgBUHsr8QAEIwHAAsgAUEBNgKUByAAIBk2AgggAEEANgIEIAEgGyAZazYCnAdBAAwCC0Gor8QAQTFB3K/EABDrBwALQQALOgAAIA5BoAVqJAAPCyAJIA0gDUGYjcQAEOoHAAsgCiANIA1BmI3EABDqBwAL718EHX8efQd7AX4jAEGAA2siBSQAIAAoAgghHyAFQQA2AvABIAVBADYC9AIgBSAANgK4ASAFIAEgAkECdCISaiIQNgK0ASAFIAE2ArABIAVB9AFqIQogBUH0AmohCUEgIQgCQAJAAkACQAJAAn8gAkEhSQRAIAkhByAKDAELIAVBIGogBUHwAWpBfyACQQFrZ3ZBAWoQ9AMgBSgCICIEQYGAgIB4RwRAIAQNAkHYlccAQRFB1MzHABDrBwALIAUoAvQCIghBIUkEQCAIIQYgCSEHQSAhCCAKDAELIAUoAvQBIQYgCiEHIAUoAvgBCyEEAkACQCAHIAYgCEkEfyAEIAZBAnRqIQQDQCAFQRhqIAVBsAFqEMIDIAUoAhhBAXFFDQIgBCAFKgIcOAIAIARBBGohBCAIIAZBAWoiBkcNAAsgCAUgBgs2AgAgBUEwaiAFQbgBaigCADYCACAFIAUpArABNwMoA0AgBUEQaiAFQShqEMIDIAUoAhBBAXFFDQICfyAFKAL0AiIIQSFJBEAgCCEEIAkhBkEgIQggCgwBCyAFKAL0ASEEIAohBiAFKAL4AQshByAFKgIUISEgBCAIRgR/IAVB8AFqENMGIAUoAvgBIQcgCiEGIAUoAvQBBSAEC0ECdCAHaiAhOAIAIAYgBigCAEEBajYCAAwACwALIAcgBjYCAAsgBUEoaiAFQfABakGIAfwKAAACQAJ/IAUoAqwBIgpBIU8EQCAFKAIwIQkgBSgCLAwBCyAFQSxqIQkgCgsiBEUEQEMAAACAISEMAQsgBEEDcSEGAkAgBEEESQRAQQAhCEMAAACAISEMAQsgBEF8cSEHQQAhCEMAAACAISEgCSEEA0AgISAEKgIAkiAEQQRqKgIAkiAEQQhqKgIAkiAEQQxqKgIAkiEhIARBEGohBCAHIAhBBGoiCEcNAAsLIAZFDQAgCSAIQQJ0aiEEA0AgISAEKgIAkiEhIARBBGohBCAGQQFrIgYNAAsLICFDYEKiDRDgCCEsIAVBLGoiEyEHIApBIU8EQCAFKAIsIQogBSgCMCEHCwJAIApFDQAgByEEIApBAnQiCUEEayIGQQxPBEAgBCAGQQJ2QQFqIgtB/P///wdxIgpBAnRqIQQgLP0TIUIgCiEIIAchBgNAIAYgBv0AAgAgQv3nAf0LAgAgBkEQaiEGIAhBBGsiCA0ACyAKIAtGDQELIAcgCWohBwNAIAQgBCoCACAslTgCACAEQQRqIgQgB0cNAAsLAn0CQAJAAkACQAJAAkACQCACRQRAIAVCADcDwAEMAQtDAACAPyAAKgJAIAAtAFgiEUECRiIEG0MAAAAAIAAqAjwgBBsiIpMhJSAFKAIsIAUoAqwBIgQgBEEgSyIEGyELIBJBBGtBAnZBAWohDSAAKAIEIQ4gACgCCCEMIAUoAjAgEyAEGyIKIQdBACEIIAFBBGoiBiEEIAEhCQNAIAkoAgAiCSAMTw0CIAggC08NAyAOIAlBGGxqIgkqAgggByoCACIhID/9HwIQtAb9EyAJKgIAICEgP/0fABC0Bv0gACAJKgIEICEgP/0fARC0Bv0gASE/IAlBDmovAQAhDyAiIAlBEGotAAAiCbNDAAB/Q5UgJZSSICEgQf0fAhC0Bv0TICIgDyAJQRB0ckH/AXGzQwAAf0OVICWUkiAhIEH9HwAQtAb9IAAgIiAPQQh2s0MAAH9DlSAllJIgISBB/R8BELQG/SABIUEgB0EEaiEHIARBBEEAIAQiCSAQRxtqIQQgDSAIQQFqIghHDQALIAVCADcDwAFDAAAQQSAAKgJIIBFBAkYiBBtDAABAwSAAKgJEIAQbIiWTQwAAfkOVISMgA0MAAAA/lCIDIAOUISZBACEIIAEhBANAIAQoAgAiBCAMTw0EIAggC08NBSAOIARBGGxqIgdBEWovAAAgB0ETai0AACIJQRB0ciIEQQh2IQ8gB/0AAgAgCioCACEDQwAAAAAhIkMAAAAAIScgBEH/AXEEQCAlICMgBEEBa0H/AXGzlJIQiQQhJwsgD0H/AXEEQCAlICMgD0EBa0H/AXGzlJIQiQQhIgsgBiEEID/95QEhQiAJBH0gJSAjIAlBAWtB/wFxs5SSEIkEBUMAAAAACyEqQwAAgD8gB0EUai8BACIGQQh2s/0TIAYgB0EWai0AACIHQRB0ckH/AXGz/SAB/QwAAH9DAAB/QwAAf0MAAH9D/ecBIkMgQ/3kAf0MAACAvwAAgL8AAIC/AACAv/3kASJD/R8BIiuLkyBD/R8AIi2LkyIkjEMAAAAAEOAIISEgJiBC/R8AIiggKJQgKv0TIAezQwAAf0OVQwAAAD+UQ9sPSUCUIjIQmQIiKiArICEgIYwiMyBD/QwAAAAAAAAAAAAAAAAAAAAA/Ub9TSJD/ccB/RsCQQFxG5IiKyAkICSUICsgK5QgLSAhIDMgQ/0bAEEBcRuSIisgK5SSkpEiLZWUIiEgKiAkIC2VlCIzIDOSIiSUIjQgMhCbAiIyICogKyAtlZQiKiAqkiIrlCItkv0TICogJJQiNSAyICEgIZIiNpQiN5P9IAFDAACAPyAhIDaUIjYgKiArlCI4kpP9IAL95gEiQ/0fACIqICqUICL9EyAhICuUIiIgMiAklCIrk/0TQwAAgD8gNiAzICSUIiSSk/0gASA1IDeS/SAC/eYBIkT9HwAiISAhlCAn/RNDAACAPyA4ICSSk/0TICIgK5L9IAEgNCAtk/0gAv3mASJF/R8AIiIgIpSSkpKSIAMgQP0fABC0Bv0TICYgQv0fASInICeUIEP9HwEiJCAklCBE/R8BIisgK5QgRf0fASItIC2UkpKSkiADIED9HwEQtAb9IAEgJiBC/R8CIjMgM5QgQ/0fAiIyIDKUIET9HwIiNCA0lCBF/R8CIjUgNZSSkpKSIAMgQP0fAhC0Bv0gAiAoICeUICogJJQgISArlCAiIC2UkpKSIAMgQP0fAxC0Bv0gAyFAIApBBGohCiAEQQRBACAEIBBHG2ohBiAnIDOUICQgMpQgKyA0lCAtIDWUkpKSIAMgKRC0BiEpICggM5QgKiAylCAhIDSUICIgNZSSkpIgAyAuELQGIS4gDSAIQQFqIghHDQALCyAFICk4AsQBIAUgLjgCwAEgBSBA/QsEsAEgBUHwAWogBUGwAWoQrgEgBf0ABKACIUAgBSoCmAIhAyAFKgKQAiEhIAUqAoQCIScgBSoClAIhIiAFKgKAAiElIAUqAogCISYgBSoC8AFDAAAAABDgCCAFKgL0AUMAAAAAEOAIISQgBSoC+AFDAAAAABDgCCEo/RMgJP0gAf3jASJC/Qz///9/////f////3////9//U79DAAAgH8AAIB/AACAfwAAgH/9PyJD/RsAQQFxIEP9xwH9GwJBAXFyDQQgKJEiI7xB/////wdxQf////sHSw0EIEIgI/0gAiAj/SAD/QxgQqINYEKiDWBCog1gQqIN/esBIUIgQP3hASBA/R8CIiOMIiT9IAIgJP0gAyBAICYgISBA/R8BIiSUICIgQP0fACIolJOUICUgIiAjlCADICSUk5QgJyAhICOUIAMgKJSTlJOSQwAAAABdGyJA/R8BISQgQP0fACEoIED9HwIiI0MAAAAAX0UEQCAjQwAAgD+SISMgJSAikiIiQwAAAABfRQRAICIgI5IiIkMAAAA/ICKRlSIplCElICcgIZMgKZQhIyAoICaTICmUISIgAyAkkyAplAwICyAnICGTQwAAAD8gIyAikyIikZUiIZQhJSAiICGUISMgAyAkkiAhlCEiICYgKJIgIZQMBwtDAACAPyAjkyEjICIgJZMiIkMAAAAAX0UNBSADICSTQwAAAD8gIyAikyIkkZUiA5QhJSAmICiSIAOUISMgJyAhkiADlCEiICQgA5QMBgsgCSAMQdy7xwAQjAcACyAIIAtBnLvHABCMBwALIAQgDEHcu8cAEIwHAAsgCCALQYy7xwAQjAcAC0H0uMcAQdYAQcy5xwAQ6wcACyAoICaTQwAAAD8gIiAjkiIikZUiJpQhJSADICSSICaUISMgIiAmlCEiICcgIZIgJpQLISggQv0fACInIEL9HwEiJpRDj8LNPxC3CiEDICcgQv0fAiIklEOPws0/ELcKISFDAAB6REO9N4Y1ICwgJiAklEOPws0/ELcKIAMgIZKSQwAAQECVQ+ZAHz8QtwpD2w9JQZSVIgMgA0O9N4Y1XRsiAyADQwAAekReGwJ/IAAtAFhBAkYEQCAFQfABaiEIIAVB/AJqIQogBUHYAWohCSAFQfgCagwBCyAAQUBrIQkgAEHEAGohCiAAQTxqIQggAEHIAGoLIQQgBUGAgICKfDYC/AIgBUGAgID8AzYC2AEgBUEANgLwASAFQYCAwIgENgL4ArwiB0H///8DcSELIAdBgICAgHhxIQYgCioCACEDIAkqAgAhKSAIKgIAISEgBCoCACEsAkAgB0GAgID8B3EiBEGAgID8B0YEQCALQQ12IAZBEHZyQYAEQQAgCxtyQYD4AXIhBgwBCyAGQRB2IQYgBEGAgIC4BE0EQCAEQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAEQQ12IAtBDXZqQYCAAWogBnJqIQYMAgsgBEGAgICYA0kNASALQYCAgARyIgdB/gAgBEEXdiIIa3YhBCAHQR0gCGsiCHZBAXEEfyAEQQMgCHRBAWsgB3FBAEdqBSAECyAGciEGDAELIAZBgPgBciEGCyAFICU4AvwBIAUgIzgC+AEgBSAiOAL0ASAFICg4AvABQwAAf0NDAAAAACBB/R8BICGTICkgIZMiJZVDAAB/Q5QiIiAiQwAAAABdGyIiICJDAAB/Q14bELkHISJBACEIQf8BQwAAf0NDAAAAACBB/R8CICGTICWVQwAAf0OUIiMgI0MAAAAAXRsiIyAjQwAAf0NeGxC5ByIj/AFBACAjQwAAAABgGyAjQwAAf0NeG0EQdEH/ASAi/AFBACAiQwAAAABgGyAiQwAAf0NeG0EIdHJB/wFDAAB/Q0MAAAAAIEH9HwAgIZMgJZVDAAB/Q5QiISAhQwAAAABdGyIhICFDAAB/Q14bELkHIiH8AUEAICFDAAAAAGAbICFDAAB/Q14bciEKQf8BQwAAgD9DAAAAACAkEMYFIAOTICwgA5MiIZUiIiAiQwAAAABdGyIiICJDAACAP14bQwAAfkOUELkHIiL8AUEAICJDAAAAAGAbICJDAAB/Q14bQRB0Qf8BQwAAgD9DAAAAACAmEMYFIAOTICGVIiIgIkMAAAAAXRsiIiAiQwAAgD9eG0MAAH5DlBC5ByIi/AFBACAiQwAAAABgGyAiQwAAf0NeG0EBakH/AXFBCHRyQf8BQwAAgD9DAAAAACAnEMYFIAOTICGVIgMgA0MAAAAAXRsiAyADQwAAgD9eG0MAAH5DlBC5ByID/AFBACADQwAAAABgGyADQwAAf0NeG0EBakH/AXFyQYCABGohCSAFQfABahCdBCELIAAoAggiDCAAKAIARgRAIwBBIGsiBCQAAkAgACgCACIHQarVqhVLBH9BAAVBBCAHQQF0Ig0gDUEETRsiDUEYbCEOIAQgBwR/IAQgB0EYbDYCHCAEIAAoAgQ2AhRBBAVBAAs2AhggBEEIakEEIA4gBEEUahCFByAEKAIIQQFHDQEgBCgCECEAIAQoAgwLIABB3LnHABCTCQALIAQoAgwhByAAIA02AgAgACAHNgIEIARBIGokAAsgACgCBCAMQRhsaiIEID/9WgIIAiAEID/9WwIAACAEIAs7ARQgBCAJOwARIAQgCjsBDiAEIAY7AQwgBEEWaiALQRB2OgAAIARBE2ogCUEQdjoAACAEQRBqIApBEHY6AAAgACAMQQFqNgIIIAVBADYC8AEgBUEANgKEAkEEIQogBUH0AWohCyAFQYQCaiENAn8gAkEFSQRAIAshDCANDAELIAVBCGogBUHwAWpBfyACQQFrZ3ZBAWoQ9QMgBSgCCCIEQYGAgIB4RwRAIAQNAkHYlccAQRFB1MzHABDrBwALIAUoAoQCIgpBBUkEQCAKIQggCyEMQQQhCiANDAELIAUoAvQBIQggBSgC+AEhDCALCyEOAkACQCAIIApPBEAgASEEDAELAkACQCACQf////8DcSIEIAogCEF/c2oiByAEIAdJGyIEQQdNDQAgCEECdCAMaiIGIAFrQRBJDQAgCCAEQQFqIgQgBEEDcSIEQQQgBBtrIglqIQggASAJQQJ0aiEEIAEhBwNAIAYgB/0AAgD9CwIAIAdBEGohByAGQRBqIQYgCUEEayIJDQALDAELIAEhBAsgDCAIQQJ0aiEGAkADQCAEIBBGDQEgBiAEKAIANgIAIAZBBGohBiAEQQRqIQQgCiAIQQFqIghHDQALIAohCAwBCyAOIAg2AgAMAQsgDiAINgIAIAQgEEYNAANAAn8gBSgChAIiB0EFSQRAIAchBiALIQlBBCEHIA0MAQsgBSgC9AEhBiAFKAL4ASEJIAsLIQggBCgCACEKIAYgB0YEfyAFQfABahDUBiAFKAL4ASEJIAshCCAFKAL0AQUgBgtBAnQgCWogCjYCACAIIAgoAgBBAWo2AgAgBEEEaiIEIBBHDQALCyAFQegBaiIKIAVBgAJqKQIANwMAIAUgBf0AAvAB/QsD2AEgACgCFCIIIAAoAgxGBEAjAEEgayIEJAACQCAAQQxqIgcoAgAiBkGq1aoVSwR/QQAFQQQgBkEBdCIJIAlBBE0bIglBGGwhCyAEIAYEfyAEIAZBGGw2AhwgBCAHKAIENgIUQQQFQQALNgIYIARBCGpBBCALIARBFGoQhQcgBCgCCEEBRw0BIAQoAhAhByAEKAIMCyAHQey5xwAQkwkACyAEKAIMIQYgByAJNgIAIAcgBjYCBCAEQSBqJAALIAAoAhAgCEEYbGoiBCAF/QAD2AH9CwIAIARBEGogCikDADcCACAAIAhBAWo2AhQgACgCXEUNBAJAAnsgAkUEQCAAKAIgIQlDAAAAACEh/QwAAAAAAAAAAAAAAAAAAAAAIj8MAQsgBSgCLCAFKAKsASIEIARBIEsiBxshBCAFKAIwIBMgBxshCCABQQRqIQcgEkEEa0ECdkEBaiELIAAoAhwhDCAAKAIgIQlDAAAAACEhQQAhBiABIQr9DAAAAAAAAAAAAAAAAAAAAAAiQCFBA0AgBCAGTQ0EIAooAgAiCiAJTw0CIEEgCCoCACID/RMiQiAMIApBCWxqIg39XQABIj/9FQSy/RMgP/0VBbL9IAEgP/0VBrL9IAIgP/0VB7L9IAP95gH9DAAA/kIAAP5CAAD+QgAA/kL95wH95AEhQSBAIEIgP/0VALL9EyA//RUBsv0gASA//RUCsv0gAiA//RUDsv0gA/3mAf0MAAD+QgAA/kIAAP5CAAD+Qv3nAf3kASFAIAhBBGohCCAHQQRBACAHIgogEEcbaiEHICEgAyANLAAAspRDAAD+QpWSISEgCyAGQQFqIgZHDQALIED9DAAA/kIAAP5CAAD+QgAA/kL95gEhPyAhQwAA/kKUISEgQf0MAAD+QgAA/kIAAP5CAAD+Qv3mAQshQUH/AEMAAP5CQwAA/sIgISAhQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQtB/wBDAAD+QkMAAP7CID/9HwMiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQxB/wBDAAD+QkMAAP7CID/9HwIiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQ1B/wBDAAD+QkMAAP7CID/9HwEiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQ5B/wBDAAD+QkMAAP7CID/9HwAiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQ9B/wBDAAD+QkMAAP7CIEH9HwMiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRFB/wBDAAD+QkMAAP7CIEH9HwIiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRRB/wBDAAD+QkMAAP7CIEH9HwEiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRVB/wBDAAD+QkMAAP7CIEH9HwAiAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRYgACgCGCAJRgRAQQAhCCMAQSBrIgQkAAJAAkBBBCAAQRhqIgcoAgAiCkEBdCIGIAZBBE0bIhetQgl+IkZCIIhQRQ0AIEanIhhBAEgNACAEIAoEfyAEIApBCWw2AhwgBCAHKAIENgIUQQEFQQALNgIYIARBCGpBASAYIARBFGoQhQcgBCgCCEEBRw0BIAQoAhAhBiAEKAIMIQgLIAggBkH8uccAEJMJAAsgBCgCDCEGIAcgFzYCACAHIAY2AgQgBEEgaiQACyAAKAIcIAlBCWxqIgQgEToACCAEIBQ6AAcgBCAVOgAGIAQgFjoABSAEIAw6AAQgBCANOgADIAQgDjoAAiAEIA86AAEgBCALOgAAIAAgCUEBajYCICAAKAJcQQFNDQUCQAJ9IAJFBEBDAAAAACEhQwAAAAAhJUMAAAAAIQNDAAAAACEmQwAAAAAhJEMAAAAAISNDAAAAACEiQwAAAAAhJ0MAAAAAIShDAAAAACEsQwAAAAAhKUMAAAAADAELIAUoAiwgBSgCrAEiBCAEQSBLIgQbIQkgBSgCMCATIAQbIQcgAUEEaiEKIBJBBGtBAnZBAWohDCAAKAIoIQ0gACgCLCELQQAhCEMAAAAAISUgASEEQwAAAAAhA0MAAAAAISZDAAAAACEkQwAAAAAhI0MAAAAAISJDAAAAACEnQwAAAAAhKEMAAAAAISxDAAAAACEqQwAAAAAhKUMAAAAAIS4DQCAIIAlPDQYgBCgCACIEIAtPDQIgI/0TICL9IAEgJ/0gAiAo/SADIAcqAgAiIf0TIkAgDSAEQQ9saiIG/V0AASI//RUEsv0TID/9FQWy/SABID/9FQay/SACID/9FQey/SAD/eYB/QwAAP5CAAD+QgAA/kIAAP5C/ecB/eQBIkH9HwMhKCBB/R8CIScgQf0fASEiIEH9HwAhIyAm/RMgL/0gASAk/SACIDD9IAMgQCA//RUAsv0TID/9FQGy/SABID/9FQKy/SACID/9FQOy/SAD/eYB/QwAAP5CAAD+QgAA/kIAAP5C/ecB/eQBIj/9HwMhMCA//R8CISQgP/0fASEvID/9HwAhJiAs/RMgKv0gASAp/SACIC79IAMgQCAG/VwACSI//RUAsv0TID/9FQGy/SABID/9FQKy/SACID8gP/0NAAECAwABAgMAAQIDAAECA/0VC7L9IAP95gH9DAAA/kIAAP5CAAD+QgAA/kL95wH95AEiP/0fAyEuID/9HwIhKSA//R8BISogP/0fACEsIAdBBGohB0EEQQAgCiIEIBBHGyAEaiEKIDEgISAGLAAOspRDAAD+QpWSITEgJSAhIAYsAA2ylEMAAP5ClZIhJSADICEgBiwAALKUQwAA/kKVkiEDIAwgCEEBaiIIRw0ACyAxQwAA/kKUISEgJUMAAP5ClCExIANDAAD+QpQhJSAm/RMgL/0gASAk/SACIDD9IAP9DAAA/kIAAP5CAAD+QgAA/kL95gEiP/0fAyEkID/9HwIhLyA//R8BISYgP/0fACEDICP9EyAi/SABICf9IAIgKP0gA/0MAAD+QgAA/kIAAP5CAAD+Qv3mASI//R8DIScgP/0fAiEiID/9HwEhIyA//R8AITAgLP0TICr9IAEgKf0gAiAu/SAD/QwAAP5CAAD+QgAA/kIAAP5C/eYBIj/9HwMhKSA//R8BISwgP/0fACEoID/9HwILIS5B/wBDAAD+QkMAAP7CICEgIUMAAP7CXRsiISAhQwAA/kJeGxC5ByIh/ABBgH8gIUMAAADDYBsgIUMAAP5CXhtBACAhICFbGyELQf8AQwAA/kJDAAD+wiAxIDFDAAD+wl0bIiEgIUMAAP5CXhsQuQciIfwAQYB/ICFDAAAAw2AbICFDAAD+Ql4bQQAgISAhWxshDEH/AEMAAP5CQwAA/sIgAyADQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQ1B/wBDAAD+QkMAAP7CICUgJUMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEOQf8AQwAA/kJDAAD+wiAmICZDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshD0H/AEMAAP5CQwAA/sIgLyAvQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRFB/wBDAAD+QkMAAP7CICQgJEMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEUQf8AQwAA/kJDAAD+wiAwIDBDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshFUH/AEMAAP5CQwAA/sIgIyAjQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRZB/wBDAAD+QkMAAP7CICIgIkMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEXQf8AQwAA/kJDAAD+wiAnICdDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshGEH/AEMAAP5CQwAA/sIgKCAoQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRlB/wBDAAD+QkMAAP7CICwgLEMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEaQf8AQwAA/kJDAAD+wiAuIC5DAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshG0H/AEMAAP5CQwAA/sIgKSApQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRwgACgCLCIIIAAoAiRGBEBBACEKIwBBIGsiBCQAAkACQEEEIABBJGoiBygCACIJQQF0IgYgBkEETRsiHa1CD34iRkIgiFBFDQAgRqciHkEASA0AIAQgCQR/IAQgCUEPbDYCHCAEIAcoAgQ2AhRBAQVBAAs2AhggBEEIakEBIB4gBEEUahCFByAEKAIIQQFHDQEgBCgCECEGIAQoAgwhCgsgCiAGQYy6xwAQkwkACyAEKAIMIQYgByAdNgIAIAcgBjYCBCAEQSBqJAALIAAoAiggCEEPbGoiBCALOgAOIAQgDDoADSAEIBw6AAwgBCAbOgALIAQgGjoACiAEIBk6AAkgBCAYOgAIIAQgFzoAByAEIBY6AAYgBCAVOgAFIAQgFDoABCAEIBE6AAMgBCAPOgACIAQgDToAASAEIA46AAAgACAIQQFqNgIsIAAoAlxBAk0NBgJAAn0gAkUEQEMAAAAAITFDAAAAACElQwAAAAAhJkMAAAAAIS9DAAAAACEkQwAAAAAhMEMAAAAAISNDAAAAACEiQwAAAAAhJ0MAAAAAIShDAAAAACErQwAAAAAhLUMAAAAAITNDAAAAACEyQwAAAAAhNEMAAAAAITVDAAAAACE2QwAAAAAhN0MAAAAAIThDAAAAACEhQwAAAAAMAQsgBSgCLCAFKAKsASICIAJBIEsiAhshBCAFKAIwIBMgAhshByABQQRqIQogEkEEa0ECdkEBaiEJIAAoAjQhCyAAKAI4IQZDAAAAACExQQAhCEMAAAAAISVDAAAAACEDQwAAAAAhJkMAAAAAIS9DAAAAACEkQwAAAAAhMEMAAAAAISNDAAAAACEiQwAAAAAhJ0MAAAAAIShDAAAAACEsQwAAAAAhKkMAAAAAISlDAAAAACEuA0AgBCAITQ0IIAEoAgAiAiAGTw0CQQRBACAKIgEgEEcbIAFqIQogMSAHKgIAIiEgCyACQRVsaiICLAAUspRDAAD+QpWSITEgJSAhIAIsABOylEMAAP5ClZIhJSADICEgAiwAErKUQwAA/kKVkiEDICYgISACLAARspRDAAD+QpWSISYgLyAhIAIsABCylEMAAP5ClZIhLyAkICEgAiwAD7KUQwAA/kKVkiEkIDAgISACLAAOspRDAAD+QpWSITAgIyAhIAIsAA2ylEMAAP5ClZIhIyAiICEgAiwADLKUQwAA/kKVkiEiICcgISACLAALspRDAAD+QpWSIScgKCAhIAIsAAqylEMAAP5ClZIhKCAsICEgAiwACbKUQwAA/kKVkiEsICogISACLAAIspRDAAD+QpWSISogKSAhIAIsAAeylEMAAP5ClZIhKSAuICEgAiwABrKUQwAA/kKVkiEuIDkgISACLAAFspRDAAD+QpWSITkgOiAhIAIsAASylEMAAP5ClZIhOiA7ICEgAiwAA7KUQwAA/kKVkiE7IDwgISACLAACspRDAAD+QpWSITwgPSAhIAIsAAGylEMAAP5ClZIhPSA+ICEgAiwAALKUQwAA/kKVkiE+IAdBBGohByAJIAhBAWoiCEcNAAsgMUMAAP5ClCEhICVDAAD+QpQhOCADQwAA/kKUITcgJkMAAP5ClCE2IC9DAAD+QpQhNSAkQwAA/kKUITQgMEMAAP5ClCEyICNDAAD+QpQhMyAiQwAA/kKUIS0gJ0MAAP5ClCErIChDAAD+QpQhKCAsQwAA/kKUIScgKkMAAP5ClCEiIClDAAD+QpQhIyAuQwAA/kKUITAgOUMAAP5ClCEkIDpDAAD+QpQhLyA7QwAA/kKUISYgPUMAAP5ClCElID5DAAD+QpQhMSA8QwAA/kKUCyEpQf8AQwAA/kJDAAD+wiAhICFDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshCkH/AEMAAP5CQwAA/sIgOCA4QwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQlB/wBDAAD+QkMAAP7CIDcgN0MAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyELQf8AQwAA/kJDAAD+wiA2IDZDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshDEH/AEMAAP5CQwAA/sIgNSA1QwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRBB/wBDAAD+QkMAAP7CIDQgNEMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyESQf8AQwAA/kJDAAD+wiAyIDJDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshE0H/AEMAAP5CQwAA/sIgMyAzQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIQ1B/wBDAAD+QkMAAP7CIC0gLUMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEOQf8AQwAA/kJDAAD+wiArICtDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshD0H/AEMAAP5CQwAA/sIgKCAoQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRFB/wBDAAD+QkMAAP7CICcgJ0MAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEUQf8AQwAA/kJDAAD+wiAiICJDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshFUH/AEMAAP5CQwAA/sIgIyAjQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRZB/wBDAAD+QkMAAP7CIDAgMEMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEXQf8AQwAA/kJDAAD+wiAkICRDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshGEH/AEMAAP5CQwAA/sIgLyAvQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRlB/wBDAAD+QkMAAP7CICYgJkMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEaQf8AQwAA/kJDAAD+wiApIClDAAD+wl0bIgMgA0MAAP5CXhsQuQciA/wAQYB/IANDAAAAw2AbIANDAAD+Ql4bQQAgAyADWxshG0H/AEMAAP5CQwAA/sIgJSAlQwAA/sJdGyIDIANDAAD+Ql4bELkHIgP8AEGAfyADQwAAAMNgGyADQwAA/kJeG0EAIAMgA1sbIRxB/wBDAAD+QkMAAP7CIDEgMUMAAP7CXRsiAyADQwAA/kJeGxC5ByID/ABBgH8gA0MAAADDYBsgA0MAAP5CXhtBACADIANbGyEdIAAoAjgiByAAKAIwRgRAQQAhBiMAQSBrIgEkAAJAAkBBBCAAQTBqIgIoAgAiCEEBdCIEIARBBE0bIh6tQhV+IkZCIIhQRQ0AIEanIiBBAEgNACABIAgEfyABIAhBFWw2AhwgASACKAIENgIUQQEFQQALNgIYIAFBCGpBASAgIAFBFGoQhQcgASgCCEEBRw0BIAEoAhAhBCABKAIMIQYLIAYgBEGcuscAEJMJAAsgASgCDCEEIAIgHjYCACACIAQ2AgQgAUEgaiQACyAAKAI0IAdBFWxqIgEgCjoAFCABIAk6ABMgASALOgASIAEgDDoAESABIBA6ABAgASASOgAPIAEgEzoADiABIA06AA0gASAOOgAMIAEgDzoACyABIBE6AAogASAUOgAJIAEgFToACCABIBY6AAcgASAXOgAGIAEgGDoABSABIBk6AAQgASAaOgADIAEgGzoAAiABIBw6AAEgASAdOgAAIAAgB0EBajYCOAwHCyACIAZBvLrHABCMBwALIAQgC0HcuscAEIwHAAsgCiAJQfy6xwAQjAcLAAsgBiAEQey6xwAQjAcACyAIIAlBzLrHABCMBwALIAggBEGsuscAEIwHAAsCQAJAIAUoAqwBIgBBIU8EQCAFKAIwIgFBBGsoAgAiAkF4cSIEIABBAnQiAEEEQQggAkEDcSICG2pJDQEgAkEAIAQgAEEnaksbDQIgARCiAgsgBUGAA2okACAfDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL6U0CH38EeyMAQUBqIgskAAJAAkACQCAFIAZPBEAgAS0AgFIhDSALIAEtAOxROgAwIAsgASgC2FE2AiwgCyABKALUUTYCKCALIAEoAsBRNgIkIAsgASgC3FE2AiBBAUEDIAdBAXEiIBshI0EBQXwgB0ECcSIUGyEkIAFBgNEAaiEcIAFBkNAAaiElIAFB4NEAaiEhIAFB7dEAaiEdIAFBgMYAaiEeIAFBgDZqIR8gAUGg0QBqIRkgAUGAzwBqISIgAUHk0QBqISYgAUGAFGohFiABQYAEaiEXIAFBgC1qIRogAUGAHWohGyAGIRAgAyEOIAIhBwNAQQAhCkEAIQkCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDSIIQf8BcQ4ZAAsKAQIDHAkbCBoYFgcVFBMSDg0GBQwEIBcLIAH9DAAAAAAAAAAAAQAAAAEAAAD9CwLEUSALQTBqQQA6AAAgC/0MAAAAAAAAAAAAAAAAAAAAAP0LAyAgIyENDCYLIAsoAiQiDUEDTwRAIAsoAiAhCQwdCyAORQ0bIA5BAWshDiALKAIgIActAAAgDXRyIQkgB0EBaiEHIA1BCHIhDQwcCyALQQA2AiwgCyALKAIkIgpBeHE2AiQgCyALKAIgIApBB3F2NgIgQQUhDQwkC0EEIAsoAiwiCSAJQQRNGyEMIAsoAiAhDSALKAIkIQgDQCAJIAxGBEAgCyABQeDRAGovAQAiCjYCLEEfIQ0gAS8B4lEgCnNB//8DRw0lQRQhDSAKRQ0lQRFBBiAIGyENDCULAkACQCAIBEAgCEEHSwRAIAghCgwCCyAORQRAQQUhCAweCyAIQQhyIQogDkEBayEOIActAAAgCHQgDXIhDSAHQQFqIQcMAQsgDgRAIAkgIWogBy0AADoAACAHQQFqIQcgDkEBayEOQQAhCAwCC0EFIQhBACEMIBRFDRhBACEODCILIAkgIWogDToAACALIApBCGsiCDYCJCALIA1BCHYiDTYCIAsgCyAJQQFqIgk2AiwMAAsAC0EYIQ0gCygCLCIRQQNLDSIgASgCzFEhCQJAAkACQAJAAkACfwJAAkAgCygCJCIMRQRAIA5FDQggASAHLQAAIAlBCHRyIgg2AsxRIAdBAWohByAOQQFrIQ4gCyARQQFqIgo2AiwgCkEERg0rDAELIAsoAiAhCiAMQQdNBEAgDkUNByAOQQFrIQ4gBy0AACAMdCAKciEKIAdBAWohByAMQQhyIQwLIAEgCkH/AXEgCUEIdHIiCDYCzFEgCyAMQQhrIgk2AiQgCyAKQQh2Igw2AiAgCyARQQFqIgo2AiwgCkEERg0qIAlFDQAgCUEHTQ0BIAkMAgsgDkUNBiABIActAAAgCEEIdHIiCDYCzFEgB0EBaiEHIA5BAWshDiALIBFBAmoiCjYCLCAKQQRGDSkMAgsgDkUNBCAOQQFrIQ4gBy0AACAJdCAMciEMIAdBAWohByAJQQhyCyEKIAEgDEH/AXEgCEEIdHIiCDYCzFEgCyAKQQhrIgk2AiQgCyAMQQh2Igw2AiAgCyARQQJqIgo2AiwgCkEERg0nIAlFDQAgCUEHTQRAIA5FDQQgDkEBayEOIActAAAgCXQgDHIhDCAHQQFqIQcgCUEIciEJCyABIAxB/wFxIAhBCHRyIgo2AsxRIAsgCUEIayIINgIkIAsgDEEIdiIMNgIgIAsgEUEDaiIJNgIsIAlBBEYNJyAIRQ0BIAsgCEEHSwR/IAgFIA5FDQQgDkEBayEOIActAAAgCHQgDHIhDCAHQQFqIQcgCEEIcgtBCGs2AiQgCyAMQQh2NgIgIAxB/wFxIApBCHRyIQgMAgsgDkUNAyABIActAAAgCEEIdHIiCjYCzFEgB0EBaiEHIA5BAWshDiALIBFBA2oiDDYCLCAMQQRGDSYLIA5FDQIgDkEBayEOIActAAAgCkEIdHIhCCAHQQFqIQcLIAEgCDYCzFEgCyARQQRyNgIsDCQLQRchCAwZC0EXIQhBACEMIBRFDRRBACEODB4LIAsgCygCLCIKQf8DcSIMNgIsQRQhDSAMQYACRg0hQSEhDSAMQZ0CSw0hIAsgCkEBa0EfcSIKQQF0QcD9xABqLwEANgIsIAsgCi0AoP1EIgo6ADBBDkEPIAobIQ0MIQtBAyENIAEtAOpRRQ0gIAsgCygCJCIJQXhxIAMgDmsiDCAJQQN2IgcgByAMSxsiCkEDdGsiBzYCJCAMIAprIgogA00EQEEYIQ0gC0F/IAdBGHF0QX9zIAsoAiAgCUEHcXZxNgIgIAMgCmshDiACIApqIQcgIEUNISALQQA2AixBFyENDCELIAogAyADQZD9xAAQ6gcAC0EVIQ0gCygCLCIKQf8BSw0fIAUgEEYNByAFIBBLBEAgBCAQaiAKOgAAIBBBAWohEAwfCwwiCwJAAkADQAJAAkAgCygCLCIMIAEvAehRTwRAIAFBEzsB6FEgC0EQaiABIAtBIGoQvgEgCy0AECIJQQNHDQFB/wEhCUEJIQhBACEKDB0LAkAgCygCJCIIQQNPBEAgCygCICENDAELIA5FBEBBCSEIDBsLIA5BAWshDiALKAIgIActAAAgCHRyIQ0gB0EBaiEHIAhBCHIhCAsgCyAIQQNrNgIkIAsgDUEDdjYCICAMQRJLDQMgDC0Ag+dIIgpBE08NBCAKIB1qIA1BB3E6AAAgCyAMQQFqNgIsQQAhCQwBCyALLQARIQ0LIAlFDQALQQkhCCAJQQJrDSAMGAsgDEETQZD+xAAQjAcACyAKQRNBoP7EABCMBwALIA4EQCALKAIsIgwgDiAFIBBrIgogCiAOSxsiCiAKIAxLGyIJIBBqIgogCUkgBSAKSXJFBEAgCQRAIAQgEGogByAJ/AoAAAsgCyAMIAlrNgIsIAcgCWohByAOIAlrIQ5BBiENIAohEAwfCyAQIAogBUGw/MQAEOoHAAtBByEIQQAhDCAURQ0PQQAhDgwZCyAOBEAgASAHLQAAIgw2AshRQR1BHUEDIAEoAsRRIgpBBHZBCGpBEHEgDCAKQQh0ckEfcCAMQSBxcnIbIApBD3FBCEcbIQ0gDkEBayEOIAdBAWohBwwdC0ECIQhBACEMIBRFDQ5BACEODBgLIA4EQCABIActAAA2AsRRIAdBAWohByAOQQFrIQ5BAiENDBwLQQEhCEEAIQwgFEUNDUEAIQ4MFwtBHiENIAsoAigiCSAFSyAJIBBLcg0aIAUgCygCLCIMIBBqIgpPIBAgCWsgEEkgDEEAIAlrTXJxRQRAQRNBDCAMGyENDBsLIBAgCWshDQJAIAxBA0YEQCAQQQNqIAVLIBBBfEtyDQEgBSANTSANQQJqIgkgBU9yDQEgDUEBaiIMIAVPDQEgBCAQaiIIIAQgDWotAAA6AAAgCCAEIAxqLQAAOgABIAggBCAJai0AADoAAgwBCyAEIAUgDSAQIAwQnQILQQwhDSAKIRAMGgsgCygCKCEIIAsoAiwhCQNAIAUgEEcEQCAEIAUgECAIayAQIAkgBSAQayIMIAkgDEkbIgoQnQIgCiAQaiEQIAkgDEsgCSAKayIKIQkNAQwZCwsgCyAJNgIsQRMhCEECDAILIAUgEEcNAgtBAgshCUEAIQogBSEQDA8LIAUgEEsEQCAEIBBqIAsoAig6AAAgCygCJCEMIAsgCygCLEEBayIKNgIsQRFBBiAMG0EGIAobIQ0gEEEBaiEQDBYLDBgLAkAgCygCJCIJQQhPBEAgCygCICEIDAELIA4EQCAOQQFrIQ4gCygCICAHLQAAIAl0ciEIIAdBAWohByAJQQhyIQkMAQtBESEIQQAhDCAURQ0HQQAhDgwRCyALIAhB/wFxNgIoIAsgCUEIazYCJCALIAhBCHY2AiBBEiENDBQLIAsoAiAhDQJAIAsoAiQiDCALLQAwIg9JBEAgDkUEQCAMIQkMAgsCQCAOQQFrIgkgDEF/cyAMQQhqIgogDyAKIA9LG2pBA3YiCiAJIApJGyIRQQRJBEAgByEIIAwhCQwBCyARQQFqIghBA3EiCkEEIAobIgkgEUF/c2ohCiAOIAggCWsiCWshDiAHIAlqIQggDCAJQQN0aiEJ/QwAAAAAAAAAAAAAAAAAAAAAIA39HAAhKCAM/RH9DAAAAAAIAAAAEAAAABgAAAD9rgEhKgNAIAf9XAAA/YkB/akBIin9GwAgKv0MHwAAAB8AAAAfAAAAHwAAAP1OIif9GwB0/REgKf0bASAn/RsBdP0cASAp/RsCICf9GwJ0/RwCICn9GwMgJ/0bA3T9HAMgKP1QISggB0EEaiEHICr9DCAAAAAgAAAAIAAAACAAAAD9rgEhKiAKQQRqIgoNAAsgKCAoICn9DQgJCgsMDQ4PAAECAwABAgP9UCInICcgJ/0NBAUGBwABAgMAAQIDAAECA/1Q/RsAIQ0LQQEgDmshBwNAAkAgCC0AACAJdCANciENIAlBCGoiCSIMIA9PDQAgCEEBaiEIIAdBAWoiB0EBRw0BDAMLC0EAIAdrIQ4gCEEBaiEHCyALIAwgD2s2AiQgCyANIA92NgIgIAsgCygCKCANQX8gD3RBf3NxajYCKEEWIQ0MFAsgCyAJNgIkIAsgDTYCIEEQIQhBACEMIBRFDQVBACEODA8LAkACQAJAAkAgCygCJCIMQQ9PBEAgCygCICENIAwhCgwBCwJAAkAgDkEBTQRAIBsgCygCICINQf8HcUEBdGouAQAiCEEATg0BQQshCiAMQQtJDQIDQCANIApBAWt2QQFxIAhBf3NqIghBvwRLDQUgGiAIQQF0ai4BACIIQQBOBEAgDCEKDAULIAwgCkEBaiIKTw0ACwwCCyAMQRByIQogDkECayEOIAsoAiAgBy8AACAMdHIhDSAHQQJqIQcMAgsgCEGABEkgDCAIQQl2SXINACAMIQoMAQsCQCAORQRAIAwhCgwBCyAMQQhqIQogB0EBaiEJIActAAAgDHQgDXIhDUEAIQ4gDEEGSwRAIAkhBwwCCyAbIA1B/wdxQQF0ai4BACIIQQBIBEAgDEEDSQ0BQQshBwNAIA0gB0EBa3ZBAXEgCEF/c2oiCEG/BEsNBCAaIAhBAXRqLgEAIghBAE4EQCAJIQcMBAsgCiAHQQFqIgdPDQALDAELIAhBgARJDQAgCSEHIAogCEEJdk8NAQsgCyAKNgIkIAsgDTYCIEEPIQhBACEMIBRFDQhBACEODBILIBsgDUH/B3FBAXRqLgEAIghBAE4NAUEKIQkDQAJAIA0gCXZBAXEgCEF/c2oiDEHABE8EQCAJQQFqIQlB//8BIQgMAQsgCUEBaiEJIBogDEEBdGouAQAiCEEASA0BCwsgCUH/AXEhCQwCCyAIQcAEQZSHxQAQjAcACyAIQQl2IQkgCEH/A3EhCAsgCyAKIAlrNgIkIAsgDSAJdjYCIEEiIQ0gCEEdSw0SIAsgCEEBdC8Bxv5ENgIoIAsgCEH+AXFBAXYiDEEBayIKQQAgCiAMTRs6ADBBFkEQIAhBBEkbIQ0MEgsgCygCICENAkAgCygCJCIMIAstADAiD0kEQCAORQRAIAwhCQwCCwJAIA5BAWsiCSAMQX9zIAxBCGoiCiAPIAogD0sbakEDdiIKIAkgCkkbIhFBBEkEQCAHIQggDCEJDAELIBFBAWoiCEEDcSIKQQQgChsiCSARQX9zaiEKIA4gCCAJayIJayEOIAcgCWohCCAMIAlBA3RqIQn9DAAAAAAAAAAAAAAAAAAAAAAgDf0cACEoIAz9Ef0MAAAAAAgAAAAQAAAAGAAAAP2uASEqA0AgB/1cAAD9iQH9qQEiKf0bACAq/QwfAAAAHwAAAB8AAAAfAAAA/U4iJ/0bAHT9ESAp/RsBICf9GwF0/RwBICn9GwIgJ/0bAnT9HAIgKf0bAyAn/RsDdP0cAyAo/VAhKCAHQQRqIQcgKv0MIAAAACAAAAAgAAAAIAAAAP2uASEqIApBBGoiCg0ACyAoICggKf0NCAkKCwwNDg8AAQIDAAECA/1QIicgJyAn/Q0EBQYHAAECAwABAgMAAQID/VD9GwAhDQtBASAOayEHA0ACQCAILQAAIAl0IA1yIQ0gCUEIaiIJIgwgD08NACAIQQFqIQggB0EBaiIHQQFHDQEMAwsLQQAgB2shDiAIQQFqIQcLIAsgDCAPazYCJCALIA0gD3Y2AiAgCyALKAIsIA1BfyAPdEF/c3FqNgIsQQ8hDQwSCyALIAk2AiQgCyANNgIgQQ4hCEEAIQwgFEUNA0EAIQ4MDQsgCy0AMCETIAsoAighFSALKAIgIQkgCygCJCEPIA4hDCAHIRECQAJAAkADQAJ/AkACQCAMQQRJDQAgBSAQayIHQQJJDQAgDEENSyAHQYMCT3FFBEAgD0EPSQ0CIA8hCiARDAMLIAwhDiARIQcDQCAPQQ5LBH8gDwUgES8AACAPdCAJciEJIBFBAmoiByERIAxBAmsiDiEMIA9BEHILAn8gFyAJQf8HcUEBdGouAQAiCkEASARAQQohCANAAkAgCSAIdkEBcSAKQX9zaiIKQcAETwRAIAhBAWohCEH//wEhCgwBCyAIQQFqIQggFiAKQQF0ai4BACIKQQBIDQELCyAIQf8BcQwBCyAKQQl2CyIIayEPIAkgCHYhCUGAAiESAkACQAJAIApBgAJxRQRAIA9BDk0EQCARLwAAIA90IAlyIQkgEUECaiIHIREgDEECayIOIQwgD0EQciEPCwJ/IBcgCUH/B3FBAXRqLgEAIg1BAEgEQEEKIQgDQAJAIAkgCHZBAXEgDUF/c2oiDUHABE8EQCAIQQFqIQhB//8BIQ0MAQsgCEEBaiEIIBYgDUEBdGouAQAiDUEASA0BCwsgCEH/AXEMAQsgDUEJdgshCCAFIBBNDR8gDyAIayEPIAkgCHYhCSAEIBBqIAo6AAAgEEEBaiEIIA1BgAJxRQ0BIAghECANIQoLIApB/wNxIg1BgAJHDQFBFCENDAILIAUgCEsEQCAEIAhqIA06AABBDCENIAUgEEECaiIQa0GDAkkEQCAKIRIMAwsgDEEOTw0DIAohEgwCCyAIIAVBgP3EABCMBwALIA1BnQJLBEBBISEIDAkLIApBAWtBH3EiCi0AoP1EIRMgCkEBdEHA/cQAai8BACESAn8gD0EOSwR/IA8FIAxBAU0NHyARLwAAIA90IAlyIQkgEUECaiIHIREgDEECayIOIQwgD0EQcgshCgJAIBNFDQAgCSATdiEIIAlBfyATdEF/c3EgEmohEiAKIBNrIglBDksEQCAJIQogCCEJDAELIAxBAU0NHyAJQRByIQogES8AACAJdCAIciEJIBFBAmoiByERIAxBAmsiDiEMCyAKAn8gGyAJQf8HcUEBdGouAQAiDUEASARAQQohCANAAkAgCSAIdkEBcSANQX9zaiIKQcAETwRAIAhBAWohCEH//wEhDQwBCyAIQQFqIQggGiAKQQF0ai4BACINQQBIDQELCyAIQf8BcQwBCyANQQl2CyIKayEPIAkgCnYhCSANQf8DcSIYQR1LBEBBIiEIIBIhDQwKCyANQf8BcSINQQF2IghBAWsiCkEAIAggCk8bIRMgGEEBdC8Bxv5EIhUgDUEESQ0AGgJ/IA9BD08EQCAJIQggDwwBCyAMQQFNDR8gES8AACAPdCAJciEIIBFBAmoiByERIAxBAmsiDiEMIA9BEHILIBNrIQ8gCCATdiEJIAhBfyATdEF/c3EgFWoLIRVBHiEIIAUgFUkEQCASIQ0MCQsgECAVSQRAIBIhDQwJCyAQIBVrIRgCQCASQQNGBEAgEEEDaiAFSyAQQXxLcg0BIAUgGE0gGEECaiIIIAVPcg0BIBhBAWoiCiAFTw0BIAQgEGoiDSAEIBhqLQAAOgAAIA0gBCAKai0AADoAASANIAQgCGotAAA6AAIMAQsgBCAFIBggECASEJ0CC0EMIQ0gBSAQIBJqIhBrQYMCSQ0AIAxBDUsNAQsLIAsgEzoAMCALIBI2AiwgCyAVNgIoIAsgDzYCJCALIAk2AiAMFwsCQAJAIA9BDksNACAMQQJPBEAgD0EQciEKIBFBAmohByAMQQJrIQ4gES8AACAPdCAJciEJDAILAkACQCAXIAlB/wdxQQF0ai4BACIOQQBIBEBBCyEHIA9BC0kNAQNAIAkgB0EBa3ZBAXEgDkF/c2oiCEG/BEsNAyAWIAhBAXRqLgEAIg5BAE4NBCAPIAdBAWoiB08NAAsMAQsgDkGABEkNACAPIA5BCXZPDQILAkAgDEUNACAPQQhqIQogEUEBaiEHIBEtAAAgD3QgCXIhCUEAIQ4gD0EGSw0DIBcgCUH/B3FBAXRqLgEAIghBAEgEQCAPQQNJDQFBCyENA0AgCSANQQFrdkEBcSAIQX9zaiIIQb8ESw0DIBYgCEEBdGouAQAiCEEATg0FIAogDUEBaiINTw0ACwwBCyAIQYAESQ0AIAogCEEJdk8NAwsgCyAJNgIgIAsgDyAMQQN0ajYCJEEMIQgMDwsgCEHABEGUh8UAEIwHAAsgDCEOIBEhByAPIQoLAkAgFyAJQf8HcUEBdGouAQAiDUEASARAQQohCANAAkAgCSAIdkEBcSANQX9zaiIMQcAETwRAIAhBAWohCEH//wEhDQwBCyAIQQFqIQggFiAMQQF0ai4BACINQQBIDQELCyAIQf8BcSEIDAELIA1BCXYhCCANQf8DcSENCyALIA02AiwgCyAKIAhrNgIkIAsgCSAIdjYCIEENIQ0MFgsgD0EQciEKIAxBAmshDCARLwAAIA90IAlyIQkgEUECagshByALIAoCfyAXIAlB/wdxQQF0ai4BACIIQQBIBEBBCiEOA0ACQCAJIA52QQFxIAhBf3NqIgpBwARPBEAgDkEBaiEOQf//ASEIDAELIA5BAWohDiAWIApBAXRqLgEAIghBAEgNAQsLIA5B/wFxDAELIAhBCXYLIgprIg42AiQgCyAJIAp2Igo2AiAgCyAINgIsQRUhDSAIQYACcQRAIAwhDgwVCyALAn8gDkEOSwRAIAchESAODAELIAdBAmohESAMQQJrIQwgBy8AACAOdCAKciEKIA5BEHILAn8gFyAKQf8HcUEBdGouAQAiDkEASARAQQohBwNAAkAgCiAHdkEBcSAOQX9zaiIJQcAETwRAIAdBAWohB0H//wEhDgwBCyAHQQFqIQcgFiAJQQF0ai4BACIOQQBIDQELCyAHQf8BcQwBCyAOQQl2CyIHayIPNgIkIAsgCiAHdiIJNgIgIAUgEEsEQCAEIBBqIAg6AAAgEEEBaiEHIA5BgAJxDQIgBSAHTQ0DIAQgB2ogDjoAACAQQQJqIRAMAQsLDBYLIAsgDjYCLCAHIRAgDCEOIBEhBwwSCyAHIAVBgP3EABCMBwALIAsgEzoAMCALIA02AiwgCyAVNgIoIAsgDzYCJCALIAk2AiALQf8BIQlBACEKDAgLIAsoAiAhDQJAIAsoAiQiDCALLQAwIg9JBEAgDkUEQCAMIQkMAgsCQCAOQQFrIgkgDEF/cyAMQQhqIgogDyAKIA9LG2pBA3YiCiAJIApJGyIRQQRJBEAgByEIIAwhCQwBCyARQQFqIghBA3EiCkEEIAobIgkgEUF/c2ohCiAOIAggCWsiCWshDiAHIAlqIQggDCAJQQN0aiEJ/QwAAAAAAAAAAAAAAAAAAAAAIA39HAAhKCAM/RH9DAAAAAAIAAAAEAAAABgAAAD9rgEhKgNAIAf9XAAA/YkB/akBIin9GwAgKv0MHwAAAB8AAAAfAAAAHwAAAP1OIif9GwB0/REgKf0bASAn/RsBdP0cASAp/RsCICf9GwJ0/RwCICn9GwMgJ/0bA3T9HAMgKP1QISggB0EEaiEHICr9DCAAAAAgAAAAIAAAACAAAAD9rgEhKiAKQQRqIgoNAAsgKCAoICn9DQgJCgsMDQ4PAAECAwABAgP9UCInICcgJ/0NBAUGBwABAgMAAQIDAAECA/1Q/RsAIQ0LQQEgDmshBwNAAkAgCC0AACAJdCANciENIAlBCGoiCSIMIA9PDQAgCEEBaiEIIAdBAWoiB0EBRw0BDAMLC0EAIAdrIQ4gCEEBaiEHCyALIAwgD2s2AiQgCyANIA92NgIgIAtBCzYCPCALQoOAgIAwNwI0IAtBNGogCygCKCIJQQJxQQJ0aigCACANQX8gD3RBf3NxaiEMQQAhCiALKAIsIQggCUEQRgRAIAEgCEEBa0H/A3FqLQAAIQoLIAggDGoiCUH/A3EiDCAIQf8DcSIITwRAAkAgCCAMRg0AIAwgCGsiDEUNACABIAhqIAogDPwLAAsgCyAJNgIsQQohDQwQCyAIIAxBgARBsP7EABDqBwALIAsgCTYCJCALIA02AiBBCyEIQQAhDCAURQ0AQQAhDgwKC0H8ASEJQQAhDgwKCyAHIQgDQAJAAkACQAJAAkACQAJAIAsoAiwiESABLwHkUSIKIAEvAeZRaiIHTwRAQRohDSAHIBFGDQEgCCEHDBULAkACQCALKAIkIgpBD08EQCALKAIgIQ0MAQsgDkEBSw0BIB8gCygCICINQf8HcUEBdGouAQAiD0EASARAQQshByAKQQtJDQQDQCANIAdBAWt2QQFxIA9Bf3NqIgxBvwRLDQcgHiAMQQF0ai4BACIPQQBODQIgCiAHQQFqIgdPDQALDAQLIA9BgARJIAogD0EJdklyDQMLIAghByAKIQ8MAwsgCkEQciEPIAhBAmohByAOQQJrIQ4gCygCICAILwAAIAp0ciENDAILAkACQCAKQaECSQRAIAoEQCAiIAEgCvwKAAALIAEvAeZRIgogAS8B5FEiB2pB/wNxIgwgB0H/A3EiCUkNASAMIAlrIgcgCkEfcSIKRw0CIAoEQCAZIAEgCWogCvwKAAALIAEgAS0A61FBAWs6AOtRIAtBGGogASALQSBqEL4BIAstABgiCUEDRgRAQf8BIQlBCiEIQQAhCgwQCyALLQAZIQ0MCAtBACAKQaACQfD8xAAQ6gcACyAJIAxBgARB4PzEABDqBwALIAogB0HQ/MQAEN4JAAsCQCAORQRAIAohDwwBCyAKQQhqIQ8gCEEBaiEHIAgtAAAgCnQgDXIhDUEAIQ4gCkEGSw0BIB8gDUH/B3FBAXRqLgEAIghBAEgEQCAKQQNJDQFBCyEJA0AgDSAJQQFrdkEBcSAIQX9zaiIMQb8ESw0EIB4gDEEBdGouAQAiCEEATg0DIA8gCUEBaiIJTw0ACwwBCyAIQYAESQ0AIA8gCEEJdk8NAQsgCyAPNgIkIAsgDTYCIEEKIQgMCAsgHyANQf8HcUEBdGouAQAiCEEATg0BQQohCQNAAkAgDSAJdkEBcSAIQX9zaiIKQcAETwRAIAlBAWohCUH//wEhCAwBCyAJQQFqIQkgHiAKQQF0ai4BACIIQQBIDQELCyAJQf8BcSEJDAILIAxBwARBlIfFABCMBwALIAhBCXYhCSAIQf8DcSEICyALIA8gCWs2AiQgCyANIAl2NgIgIAsgCDYCKCAIQRBPBEAgEUUEQEEgIQ0gCEEQRg0QCyALQYKGHDYANCALIAtBNGogCEEDcWotAAA6ADBBCyENDA8LIAEgEUH/A3FqIAg6AAAgCyARQQFqNgIsQQAhCSAHIQgLIAlFDQALIAghByAJQQJrDQxBCiEIDAQLQQMgCygCLCIMIAxBA00bIQ8gCygCICEIIAsoAiQhEQNAAkACQCAMIA9HBEAgC0EENgI8IAtChYCAgNAANwI0IBEgC0E0aiAMQQJ0aigCACISTw0CAkAgDgRAQQEgDmshDSARIQkDQCAHLQAAIAl0IAhyIQggCUEIaiIKIBJPDQQgB0EBaiEHIAohCSANQQFqIg1BAUcNAAsgCyAMNgIsIBEgDkEDdGohEQwBCyALIAw2AiwLIAsgETYCJCALIAg2AiBBCCEIDAULIB39DAAAAAAAAAAAAAAAAAAAAAD9CwAAIB1BD2pBADYAACALIBE2AiQgCyAINgIgIAtBADYCLEEbQQlBGyABLwHmUUEfSRsgAS8B5FFBnwJPGyENDA4LQQAgDWshDiAHQQFqIQcgCUEIaiERCyAmIAxBAXQiCmogCi8BwP5EIAhBfyASdEF/c3FqOwEAIAxBAWohDCARIBJrIREgCCASdiEIDAALAAtBAkEHIAUgEEYiDBtBFCALKAIsIgobIQ0gCkUgDEVyDQogBSEQDAILQQAhDiAkIQ0MAQsgASAJQQFxOgDqUSABIAlBAXZBA3EiCjoA61EgCyANQQNrNgIkIAsgCUEDdjYCIEEZIQ0CQAJAAkAgCkEBaw4DAAELBQsgAUGggoABNgLkUSAiQQhBkAH8CwAgJUEJQfAA/AsAIBxBEGpCh46cuPDgwYMHNwIAIBxBCGpCh46cuPDgwYMHNwIAIBxCh46cuPDgwYMHNwIAIAFCiJCgwICBgoQINwKYUSAZQoWKlKjQoMGCBTcCACAZQQhqQoWKlKjQoMGCBTcCACAZQRBqQoWKlKjQoMGCBTcCACAZQRhqQoWKlKjQoMGCBTcCACALQQhqIAEgC0EgahC+ASALLQAJIQ0gCy0ACCIMQQFGDQpB/wEhCUEAIQogDEEDaw0BDAMLIAtBADYCLEEIIQ0MCQtBAyEICyANQf8BcSICQQFGIgogAkH8AUZyDQIgDSEJCyALIAsoAiQiAiADIA5rIgcgAkEDdiICIAIgB0sbIgxBA3RrNgIkIAoNAgwDC0EEIQ0MBQtBACEMIA0hCSACQQFHDQELQQFBAUECIAhB/wFxQRdGGyAFIBBHGyEJCyABIAg6AIBSIAEgCygCJCICNgLAUSABIAspAyg3AtRRIAEgCy0AMDoA7FEgASALKAIgQX8gAnRBf3NxNgLcUQJAIAnAQQBOICBxRQRAIBAgBmshBwwBCyAFIBBJIAYgEEtyRQRAIAsgASgC0FEiAiACQRB2IAQgBmogECAGayIHEN4CIAEgCygCACICNgLQUSAJQf8BcQ0BQX5BACACIAEoAsxRRxshCQwBCyAGIBAgBUGA/sQAEOoHAAsgACAHNgIIIAAgCToABCAAIAMgDCAOams2AgAMBAsgCyAKNgIsC0EMIQ0MAAsACyAAQQA2AgggAEEANgIAIABB/QE6AAQLIAtBQGskAA8LIBAgBUGA/cQAEIwHAAtBAEECIAxBhP/EABDqBwAL00wDHX8EfQF+IwBBwAFrIgIkAAJAAkACQAJAAkACQCABKAIAQQJHBEAgASgCpAIiAyABKAJkSQRAIAFBvAJqIRQgAUHsA2ohFiABQfAAaiEbIAFBmANqIRkgAUH0AmohHCABQYADaiEdIAFBjANqIR4DQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAmAgA0EobGoiCikDECABKQOAAXwiIyABKQNwUQRAIAEoArgCIgMgCigCGCIEQQdqQXhxSQ0BIAMgBEkNAiABKAK0AiEDIAotACAiGkEBRgRAIAJBGGogAyAEEPkCIAIoAhgiA0GAgICAeEcEQCACKAIcIAJBADYCuAEgAkEBNgKsASACQbjJwQA2AqgBIAJCBDcCsAEgAkGoAWoQkgchFyADRQ0iIANBARCiBwwiCyACKAIgIRcgAigCHCIYQYCAgIB4Rg0hIAIoAiQhBCAXIQMLQQkhBgJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJ/AkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKLQAiQQFrDg0BAgMaHx0eGxwfHR4EAAsgCi0AIQ4EBAUGBwkLIAotACEOBQsKCQkMCQsgCi0AISIFDgYODRAQDw8QCyAKLQAhDgoSERERERERERQTEQsgCi0AIUELaw4CHB0bCyACQRhqIAMgBEEDIAEoAqwCEPgEDAMLIAJBGGogAyAEQQMgASgCrAIQ5gMMAgsgAkEYaiADIAQgASgCrAIQoAIMAQsgAkEYaiADIAQgASgCrAIQ/gELIBQgASgCqAIgASgCrAIgAigCHCIGIAIoAiAQowIgAigCGCIFRQ02IAZBBGsoAgAiA0F4cSIEIAVBAnQiBUEEQQggA0EDcSIDG2pJDT0gA0EAIAQgBUEnaksbDT4gBhCiAgw2CyACQQE2AqwBIAJB4MnBADYCqAEgAkIBNwK0ASACIApBIWqtQoCAgICQBYQ3A1ggAiACQdgAajYCsAEgAkEoaiIBIAJBqAFqELEGIAEQjgchAQw0CyACQQE2AqwBIAJBvMrBADYCqAEgAkIBNwK0ASACIApBIWqtQoCAgICQBYQ3A1ggAiACQdgAajYCsAEgAkE0aiIBIAJBqAFqELEGIAEQjgcMAwsgAkEYaiADIARBASABKAKsAhDmAwwxCyACQRhqIAMgBEEBIAEoAqwCEPgEDDALIAooAgBFBEAgAkEANgK4ASACQQE2AqwBIAJBmMrBADYCqAEgAkIENwKwASACQagBahCSBwwBCyAKKAIIDS4gAkEANgK4ASACQQE2AqwBIAJB/MnBADYCqAEgAkIENwKwASACQagBahCSBwshAQwvCyACQRhqIAMgBEEDIAEoAqwCEOYDDCsLIAJBGGogAyAEQQMgASgCrAIQ+AQMKgsgCigCAEUEQCACQQA2ArgBIAJBATYCrAEgAkGYysEANgKoASACQgQ3ArABIAJBqAFqEJIHDAILIAooAghFBEAgAkEANgK4ASACQQE2AqwBIAJB/MnBADYCqAEgAkIENwKwASACQagBahCSBwwCCyAKKgIEISAgASgCrAIhBiAKKgIMIR8gBUEERg0oIAJBGGogAyAEQQMgBiAgIB8Q/wMMKQsgAkEBNgKsASACQeDKwQA2AqgBIAJCATcCtAEgAiAKQSFqrUKAgICAkAWENwNYIAIgAkHYAGo2ArABIAJBQGsiASACQagBahCxBiABEI4HCyEBDCoLIAJBATYCrAEgAkGIy8EANgKoASACQgE3ArQBIAIgCkEhaq1CgICAgJAFhDcDWCACIAJB2ABqNgKwASACQcwAaiIBIAJBqAFqELEGIAEQjgcMAwsgAkEYaiADIARBAyABKAKsAhD4BAwjCyACQRhqIAMgBCABKAKsAhD9AQwiCyAKKAIARQRAIAJBADYCuAEgAkEBNgKsASACQZjKwQA2AqgBIAJCBDcCsAEgAkGoAWoQkgcMAQsgCigCCA0gIAJBADYCuAEgAkEBNgKsASACQfzJwQA2AqgBIAJCBDcCsAEgAkGoAWoQkgcLIQEMJQsCQAJAAkACQCAKLQAhIgVBCkcEQCAFDgICAwELIAJB2ABqIAMgBCABKAKsAhDFAwwhCyACQQE2AqwBIAJBxMvBADYCqAEgAkIBNwK0ASACIApBIWqtQoCAgICQBYQ3A3AgAiACQfAAajYCsAEgAkHkAGoiASACQagBahCxBiABEI4HIQEMJwsgAkEYaiADIARBAyABKAKsAhD4BAwBCyACQRhqIAMgBEEDIAEoAqwCEOYDCyABKAKsAiILQQJ0IgRB/////wNLDQwgC0EEdCIDQf3///8HTw0MAkAgA0UEQEEEIQ1BACEEDAELIAMQcSINRQ0OIAEoAqwCIQsLIAJBADYCsAEgAiANNgKsASACIAQ2AqgBIAsEQEEAIQNBASEPIAIoAiAhBiACKAIcIQQDQCAPQQFrIgUgBk8EQCAFIQ8MHwsgBiAFayIFQQAgBSAGTRsiBUEBRg0eIAVBAkYNHUMAAIA/IAQqAgAiISAhlJMgBEEEaioCACIiICKUkyAEQQhqKgIAIiAgIJSTQwAAAAAQ4AiRIR8gAigCqAEgA2tBA00EQCACQagBaiADQQRBBEEEEKQFIAIoAqwBIQ0gAigCsAEhAwsgDSADQQJ0aiIFIB84AgwgBSAgOAIIIAUgIjgCBCAFICE4AgAgAiADQQRqIgM2ArABIA9BA2ohDyAEQQxqIQQgC0EBayILDQALCyACQeAAaiACQbABaigCADYCACACIAIpAqgBNwNYIAIoAhgiBUUNHSACKAIcIgZBBGsoAgAiA0F4cSIEIAVBAnQiBUEEQQggA0EDcSIDG2pJDSwgA0EAIAQgBUEnaksbDS0gBhCiAgwdCyAKLQAhQQtGDRkgAkEBNgKsASACQfDLwQA2AqgBIAJCATcCtAEgAiAKQSFqrUKAgICAkAWENwMYIAIgAkEYajYCsAEgAkGQAWoiASACQagBahCxBiABEI4HIQEMIwsgCi0AIUEMRg0XIAJBATYCrAEgAkGczMEANgKoASACQgE3ArQBIAIgCkEhaq1CgICAgJAFhDcDGCACIAJBGGo2ArABIAJBnAFqIgEgAkGoAWoQsQYgARCOByEBDCILQQ8hBgwBC0EVIQYLAkACQAJAAkACQCAKLQAhIgcOCAEAAwMCAgQEAwsgAkEYaiADIAQgBiABKAKsAhDmAwwXCyACQRhqIAMgBCAGIAEoAqwCEPgEDBYLIAooAgBFBEAgAkEANgK4ASACQQE2AqwBIAJBmMrBADYCqAEgAkIENwKwASACQagBahCSByEBDCILIAooAghFBEAgAkEANgK4ASACQQE2AqwBIAJB/MnBADYCqAEgAkIENwKwASACQagBahCSByEBDCILIAoqAgQhICABKAKsAiEFIAoqAgwhHyAHQQRGDRQgAkEYaiADIAQgBiAFICAgHxD/AwwVCyACQQE2AqwBIAJB0MzBADYCqAEgAkIBNwK0ASACIApBIWqtQoCAgICQBYQ3A1ggAiACQdgAajYCsAEgAkH4AGoiASACQagBahCxBiABEI4HIQEMIAsgCigCCEUEQCACQQA2ArgBIAJBATYCrAEgAkH8ycEANgKoASACQgQ3ArABIAJBqAFqEJIHIQEMIAsgASgCrAIhBSAKKgIMIR8gB0EGRg0RIAJBGGogAyAEIAYgBSAfEJAEDBMLIAJBATYCrAEgAkH4zMEANgKoASACQgE3ArQBIAIgCkEhaq1CgICAgJAFhDcDWCACIAJB2ABqNgKwASACQYQBaiIBIAJBqAFqELEGIAEQjgchAQweCyACQRhqIAMgBCABKAKsAhCOBQwBCyACQRhqIAMgBCABKAKsAhDTBAsgAigCHCEIIAEoAuQDRQ0KIAEoAqwCIREgASgCqAIhEiACKAIgIQwCQCABLQD0A0UEQCABKAKgAyEEDAELIAEoAugDIAEoAuwDIgNBAnQgAyABKALwAyIDakECdBDhCCEHIANBAnQiBiABKAKgAyIESw0GIAEoApwDIQUgAiAHELgKIgM2AnAgAiAGNgJYIAMgBkcNJiAHIAUgBhDgCSABQQA6APQDIAdBhAhJDQAgBxCbBwsgFkIANwIAIBZBCGpBADoAACARQQJ0IgkhAyAEIAlJBEAgCSAEIgNrIg4gASgCmAMgA2tLBEAgGSADIA5BBEEEEKQFIAEoAqADIQMLIAEoApwDIhMgA0ECdCIHaiEFIA5BAk8EQCAJIARBf3NqQQJ0IgYEQCAFQQAgBvwLAAsgEUEEdCAEQQJ0ayATaiAHakEEayEFIAMgDmpBAWshAwsgBUEANgIAIANBAWohAwsgASADNgKgAyABKAK8AkEBRw0KIBFBAXQiECADSw0GIAEoApwDIQYCQAJAAkAgEQRAIBFB/////wdxIQ9BACENIAwhAyARIQcgCCEFIAYhBANAIANFDQIgBSgCAEEBdCIOIAEoAvwCIhNPDQMgD0UNBCAEIAEoAvgCIA5BAnRqKAIANgIAIA5BAXIiDiABKAL8AiITTw0NIARBBGogASgC+AIgDkECdGooAgA2AgAgA0EBayEDIA9BAWshDyAFQQRqIQUgBEEIaiEEIA1BAmohDSAHQQFrIgcNAAsLIAIgASgCwAIgEkEBdCARIBJqIhNBAXQQ4QgiBRC4CiIDNgJwIAIgEDYCWCADIBBHDSggBSAGIBAQ4AkgBUGECE8EQCAFEJsHCyABKALkA0EBRg0NIAEoAsQCRQ0NIAkgASgCoAMiA0sNCiABKAKcAyEHIBFFDQxBACELIAchBUEAIQQCQAJAAkADQAJAIAsgDEkEQCAEIAhqKAIAQQJ0IgMgASgCiAMiD08NFSAEIAlPDQUgBSABKAKEAyADQQJ0aigCADYCACADQQFyIgYgASgCiAMiD0kNASAGIQMMFQsgDCAMQajdwAAQjAcACyAEQQFqIAlPDQIgBUEEaiABKAKEAyAGQQJ0aigCADYCACADQQJyIgYgASgCiAMiD08EQCAGIQMMFAsgBEECaiAJTw0BIAVBCGogASgChAMgBkECdGooAgA2AgAgA0EDciIDIAEoAogDIg9PDRMgCSAEQQNqSwRAIAVBDGogASgChAMgA0ECdGooAgA2AgAgBUEQaiEFIARBBGohBCALQQFqIgsgEUkNAQwRCwsgBEEDaiEEDAILIARBAmohBAwBCyAEQQFqIQQLIAQgCUHI3cAAEIwHAAsgDCAMQejdwAAQjAcACyAOIBNB+N3AABCMBwALIA0gEEGI3sAAEIwHAAsgAiAjNwNYIAJBAjYCrAEgAkG0zcEANgKoASACQgI3ArQBIAJCgICAgKAFIiMgAkHYAGqthDcDICACICMgG62ENwMYIAIgAkEYajYCsAEgAkEMaiIBIAJBqAFqELEGIAEQjgchASAAQQE6AAAgACABNgIEDCALIABBADsBAAwfC0EAIAQgA0GAzcEAEOoHAAtBkMvBABD/BwsAC0EAIAYgBEH868AAEOoHAAtBACAQIANBqN7AABDqBwALQQAgCSADQdjdwAAQ6gcACyAOIBNBmN7AABCMBwALIAIgASgCyAIgEkECdCIOIBNBAnQiExDhCCIFELgKIgM2AnAgAiAJNgJYAkACQCADIAlGBEAgBSAHIAkQ4AkgBUGECE8EQCAFEJsHCyABKALkA0ECRg0DIAEoAswCRQ0DIAkgASgCoAMiA0sNASABKAKcAyEHIBFFDQJBACELIAchBUEAIQQCQAJAAkADQAJAIAsgDEkEQCAEIAhqKAIAQQJ0IgMgASgClAMiD08NCiAEIAlPDQUgBSABKAKQAyADQQJ0aigCADYCACADQQFyIgYgASgClAMiD0kNASAGIQMMCgsgDCAMQejcwAAQjAcACyAEQQFqIAlPDQIgBUEEaiABKAKQAyAGQQJ0aigCADYCACADQQJyIgYgASgClAMiD08EQCAGIQMMCQsgBEECaiAJTw0BIAVBCGogASgCkAMgBkECdGooAgA2AgAgA0EDciIDIAEoApQDIg9PDQggCSAEQQNqSwRAIAVBDGogASgCkAMgA0ECdGooAgA2AgAgBUEQaiEFIARBBGohBCALQQFqIgsgEUkNAQwHCwsgBEEDaiEEDAILIARBAmohBAwBCyAEQQFqIQQLIAQgCUGI3cAAEIwHAAsMHQtBACAJIANBmN3AABDqBwALIAIgASgC0AIgDiATEOEIIgUQuAoiAzYCcCACIAk2AlggAyAJRw0bIAUgByAJEOAJIAVBhAhJDQAgBRCbBwsgAigCGCIFRQ0RIAhBBGsoAgAiA0F4cSIEIAVBAnQiBUEEQQggA0EDcSIDG2pJDRggA0EAIAQgBUEnaksbDRkgCBCiAgwRCyADIA9B+NzAABCMBwALIAMgD0G43cAAEIwHAAsgAkEYaiADIAQgBiAFIB8QggUMAQsgAkEYaiADIAQgBiAFICAgHxD5BAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKLQAiQQVrDggGAQIAAAMEBQALQaT4xgBBKEGkzMEAEOsHAAsgFCABKAKoAiABKAKsAiACKAIcIhUgAigCIBDiAwwICyAUIAEoAqgCIAEoAqwCIAIoAhwiFSACKAIgEOMDDAcLIAEoAqwCIg8gASgCqAIiE2oiEUEBdCEQIAIoAiAhDCACKAIcIRUCQAJAIAEoAtQCQQFGBEAgASgC2AIQuAogEEkNAUEBIQUMCAsgEEUEQEEAIQUMCAsgEBC2CSEEDAELIBAQtgkiBCABKALYAhDcCSABKALYAiIDQYQISQ0AIAMQmwcLIAEgBDYC2AJBASEFIAFBATYC1AIMBQsgASgCrAIiByABKAKoAiIQaiITQQJ0IQ0gAigCICERIAIoAhwhFQJAAkAgASgC3AJBAUYEQCABKALgAhC4CiANSQ0BQQEhBQwGCyANRQRAQQAhBQwGCyANELYJIQQMAQsgDRC2CSIEIAEoAuACENwJIAEoAuACIgNBhAhJDQAgAxCbBwsgASAENgLgAkEBIQUgAUEBNgLcAgwDCyABKAKsAiIHIAEoAqgCIhBqIhNBAnQhDSACKAIgIREgAigCHCEVAkACQCABKALkAkEBRgRAIAEoAugCELgKIA1JDQFBASEFDAQLIA1FBEBBACEFDAQLIA0QtgkhBAwBCyANELYJIgQgASgC6AIQ3AkgASgC6AIiA0GECEkNACADEJsHCyABIAQ2AugCQQEhBSABQQE2AuQCDAELIBQgASgCqAIgASgCrAIgAigCHCIVIAIoAiAQzgMMAwsCQAJAAkAgAS0A9ANFBEAgASgCoAMhBAwBCyABKALoAyABKALsAyIDQQJ0IAMgASgC8AMiA2pBAnQQ4QghDCADQQJ0IgggASgCoAMiBEsNHSABKAKcAyEGIAIgDBC4CiIDNgJwIAIgCDYCWCADIAhHDSAgDCAGIAgQ4AkgAUEAOgD0AyAMQYQISQ0AIAwQmwcLIBZCADcCACAWQQhqQQA6AAAgB0ECdCIJIQYgBCAJSQRAIAQhBiAJIARrIg4gASgCmAMgBGtLBEAgGSAEIA5BBEEEEKQFIAEoAqADIQYLIAEoApwDIgwgBkECdCIIaiEFIA5BAk8EfyAJIARBf3NqQQJ0IgMEQCAFQQAgA/wLAAsgBiAOakEBayEGIAdBBHQgBEECdGsgDGogCGpBBGsFIAULQQA2AgAgBkEBaiEGIAEoAuQCIQULIAEgBjYCoAMgBUUNBCAGIAlJDQAgASgCnAMiDiAJIBUgESAHIAEqAtQDENoDIAEoAugCIBBBAnQiESANEOEIIgUQuAohAyACIAk2AlggAiADNgJwIAMgCUcNHyAFIA4gCRDgCSAFQYQITwRAIAUQmwcLIAEoApQDIgMgDUkEQCANIAMiBmsiEiABKAKMAyADa0sEQCAeIAMgEkEEQQQQpAUgASgClAMhBgsgASgCkAMiDCAGQQJ0IghqIQUgEkECTwR/IA0gA0F/c2pBAnQiBARAIAVBACAE/AsACyAGIBJqQQFrIQYgE0EEdCADQQJ0ayAMaiAIakEEawUgBQtBADYCACABIAZBAWo2ApQDCyAHRQ0EIBBBBHQhCCAHQf////8DcSENQQAhBEEAIQsCfwJAAkACQANAIA1FDQYgCyARaiIFIAEoApQDIgZJBEAgASgCkAMgCGogBGogBCAOaiIDKAIANgIAIAEoApQDIgYgBUEBak0NBCABKAKQAyAIaiAEakEEaiADQQRqKAIANgIAIAEoApQDIgYgBUECak0NAyABKAKQAyAIaiAEakEIaiADQQhqKAIANgIAIAEoApQDIgYgBUEDak0NAiABKAKQAyAIaiAEakEMaiADQQxqKAIANgIAIARBEGohBCALQQRqIQsgDUEBayENIAdBAWsiBw0BDAoLCyAQQQJ0IAtqDAMLIBBBAnQgC2pBA2oMAgsgEEECdCALakECagwBCyAQQQJ0IAtqQQFqCyAGQcjcwAAQjAcAC0EAIAkgBkHY3MAAEOoHAAsgCyAJQbjcwAAQjAcACwJAAkACQCABLQD0A0UEQCABKAKgAyEEDAELIAEoAugDIAEoAuwDIgNBAnQgAyABKALwAyIDakECdBDhCCEMIANBAnQiCCABKAKgAyIESw0cIAEoApwDIQYgAiAMELgKIgM2AnAgAiAINgJYIAMgCEcNHyAMIAYgCBDgCSABQQA6APQDIAxBhAhJDQAgDBCbBwsgFkIANwIAIBZBCGpBADoAACAHQQJ0IgkhBiAEIAlJBEAgBCEGIAkgBGsiDiABKAKYAyAEa0sEQCAZIAQgDkEEQQQQpAUgASgCoAMhBgsgASgCnAMiDCAGQQJ0IghqIQUgDkECTwR/IAkgBEF/c2pBAnQiAwRAIAVBACAD/AsACyAGIA5qQQFrIQYgB0EEdCAEQQJ0ayAMaiAIakEEawUgBQtBADYCACAGQQFqIQYgASgC3AIhBQsgASAGNgKgAyAFRQ0DIAYgCUkNACABKAKcAyIOIAkgFSARIAcgASoC0AMQ4wEgASgC4AIgEEECdCIRIA0Q4QgiBRC4CiEDIAIgCTYCWCACIAM2AnAgAyAJRw0eIAUgDiAJEOAJIAVBhAhPBEAgBRCbBwsgASgCiAMiAyANSQRAIA0gAyIGayISIAEoAoADIANrSwRAIB0gAyASQQRBBBCkBSABKAKIAyEGCyABKAKEAyIMIAZBAnQiCGohBSASQQJPBH8gDSADQX9zakECdCIEBEAgBUEAIAT8CwALIAYgEmpBAWshBiATQQR0IANBAnRrIAxqIAhqQQRrBSAFC0EANgIAIAEgBkEBajYCiAMLIAdFDQMgEEEEdCEIIAdB/////wNxIQ1BACEEQQAhCwJ/AkACQAJAA0AgDUUNBiALIBFqIgUgASgCiAMiBkkEQCABKAKEAyAIaiAEaiAEIA5qIgMoAgA2AgAgASgCiAMiBiAFQQFqTQ0EIAEoAoQDIAhqIARqQQRqIANBBGooAgA2AgAgASgCiAMiBiAFQQJqTQ0DIAEoAoQDIAhqIARqQQhqIANBCGooAgA2AgAgASgCiAMiBiAFQQNqTQ0CIAEoAoQDIAhqIARqQQxqIANBDGooAgA2AgAgBEEQaiEEIAtBBGohCyANQQFrIQ0gB0EBayIHDQEMCQsLIBBBAnQgC2oMAwsgEEECdCALakEDagwCCyAQQQJ0IAtqQQJqDAELIBBBAnQgC2pBAWoLIAZBmNzAABCMBwALQQAgCSAGQajcwAAQ6gcACyALIAlBiNzAABCMBwALAkAgAS0A9ANFBEAgASgCoAMhBAwBCyABKALoAyABKALsAyIDQQJ0IAMgASgC8AMiA2pBAnQQ4QghCCADQQJ0IgcgASgCoAMiBEsNAiABKAKcAyEGIAIgCBC4CiIDNgJwIAIgBzYCWCADIAdHDRwgCCAGIAcQ4AkgAUEAOgD0AyAIQYQISQ0AIAgQmwcLIBZCADcCACAWQQhqQQA6AAAgBCAPQQJ0IgZJBEAgBCEFIAYgBGsiDiABKAKYAyAEa0sEQCAZIAQgDkEEQQQQpAUgASgCoAMhBQsgASgCnAMiCCAFQQJ0IgdqIQsgDkECTwRAIAYgBEF/c2pBAnQiAwRAIAtBACAD/AsACyAPQQR0IARBAnRrIAhqIAdqQQRrIQsgBSAOakEBayEFCyALQQA2AgAgBUEBaiEGIAEoAtQCIQULIAEgBjYCoAMgBUUNACAPQQF0IhIgBksNAiABKAKcAyIEIBIgFSAMIA8gASoCzAMQqQIgASgC2AIgE0EBdCIMIBAQ4QgiBRC4CiEDIAIgEjYCWCACIAM2AnAgAyASRw0bIAUgBCASEOAJIAVBhAhPBEAgBRCbBwsgASgC/AIiAyAQSQRAIBAgAyIFayIOIAEoAvQCIANrSwRAIBwgAyAOQQRBBBCkBSABKAL8AiEFCyABKAL4AiIIIAVBAnQiB2ohCyAOQQJPBEAgECADQX9zakECdCIGBEAgC0EAIAb8CwALIBFBA3QgA0ECdGsgCGogB2pBBGshCyAFIA5qQQFrIQULIAtBADYCACABIAVBAWo2AvwCCyAPRQ0AIBNBA3QhAyAPQf////8HcSEGQQAhBQNAIAZFDQQgBSAMaiIIIAEoAvwCIgdPDQUgASgC+AIgA2ogBCgCADYCACAIQQFqIgggASgC/AIiB0kEQCABKAL4AiADakEEaiAEQQRqKAIANgIAIANBCGohAyAEQQhqIQQgBUECaiEFIAZBAWshBiAPQQFrIg8NAQwCCwsgCCAHQejbwAAQjAcACyACKAIYIgVFDREgFUEEaygCACIDQXhxIgQgBUECdCIFQQRBCCADQQNxIgMbakkNGCADQQAgBCAFQSdqSxsNBCAVEKICDBELQQAgByAEQfzrwAAQ6gcAC0EAIBIgBkH428AAEOoHAAsgBSASQcjbwAAQjAcACyAIIAdB2NvAABCMBwALDBQLIAJBqAFqIAMgBCABKAKsAhDUBCAUIAEoAqgCIAEoAqwCIAIoAqwBIgYgAigCsAEQtQQgAigCqAEiBUUNCwJAIAZBBGsoAgAiA0F4cSIEIAVBAnQiBUEEQQggA0EDcSIDG2pPBEAgA0EAIAQgBUEnaksbDQEgBhCiAgwNCwwTCwwTCyACQagBaiADIAQgASgCrAIQnAUgFCABKAKoAiABKAKsAiACKAKsASIGIAIoArABELQEIAIoAqgBIgVFDQoCQCAGQQRrKAIAIgNBeHEiBCAFQQF0IgVBBEEIIANBA3EiAxtqTwRAIANBACAEIAVBJ2pLGw0BIAYQogIMDAsMEgsMEgsgD0EBaiEPCyAPIAZBxM3BABCMBwALIBQgASgCqAIgASgCrAIgAigCXCIGIAIoAmAQ+wQgAigCWCIFRQ0HAkAgBkEEaygCACIDQXhxIgQgBUECdCIFQQRBCCADQQNxIgMbak8EQCADQQAgBCAFQSdqSxsNASAGEKICDAkLDA8LDA8LIAJBGGogAyAEIAEoAqwCIAoqAgQgCioCDBCqAwsgFCABKAKoAiABKAKsAiACKAIcIgYgAigCIBDJAyACKAIYIgVFDQUCQCAGQQRrKAIAIgNBeHEiBCAFQQJ0IgVBBEEIIANBA3EiAxtqTwRAIANBACAEIAVBJ2pLGw0BIAYQogIMBwsMDQsMDQsgAkEYaiADIARBAyAGICAgHxD5BAsgFCABKAKoAiABKAKsAiACKAIcIgYgAigCIBCWBCACKAIYIgVFDQMCQCAGQQRrKAIAIgNBeHEiBCAFQQJ0IgVBBEEIIANBA3EiAxtqTwRAIANBACAEIAVBJ2pLGw0BIAYQogIMBQsMCwsMCwsgAkEYaiADIARBASABKAKsAiAKKgIEIAoqAgwQ+QQLIAIoAiAhByACKAIcIQwgFCABKAKoAiABKAKsAiIFEMwDAkACQAJAIAUEQEEAIQYgByEDQQAhBANAIAEoAqADIgggBEEDak0NAiADRQ0DIAEoApwDIAZqQQNqQf8BQwAAf0NDAAAAACAEIAxqKgIAQwAAAEBDAACAPyABLQDYA0EBcRuVQwAAf0OUIh8gH0MAAAAAXRsiHyAfQwAAf0NeGxC5ByIf/AFBACAfQwAAAABgGyAfQwAAf0NeGzoAACAGQRBqIQYgA0EBayEDIARBBGohBCAFQQFrIgUNAAsLIAFBAToA9AMgAigCGCIFRQ0EIAxBBGsoAgAiA0F4cSIEIAVBAnQiBUEEQQggA0EDcSIDG2pJDQsgA0EAIAQgBUEnaksbDQIgDBCiAgwECyAEIARBBGogCEG428AAEOoHAAsgByAHQajbwAAQjAcACwwJCyAAQQE6AAAgACABNgIEIBpFIBhFcg0FIBcgGEEBEKIHDAULAkACQAJAIAEoArgCIgMgCigCGEEHakF4cSIETwRAIAFBADYCuAIgAyAEayEFIARFDQEgAyAERg0DIAVFDQIgASgCtAIiAyADIARqIAX8CgAADAILQQAgBCADQYSkxwAQ6gcACyADIARGDQELIAEgBTYCuAILIAopAxghIyABIAEoAqQCQQFqIgM2AqQCIAEgASkDcCAjQgd8Qvj///8Pg3w3A3ACQCAaRSAYRXINAAJAIBdBBGsoAgAiA0F4cSIFQQRBCCADQQNxIgMbIBhqTwRAIANBACAFIBhBJ2pLGw0BIBcQogIgASgCpAIhAwwCCwwICwwICyADIAEoAmRJDQALCyAAQYACOwEADAILQYzJwQAQ3QkACyAAQQE6AAAgACAXNgIECyACQcABaiQADwtBACAIIARB/OvAABDqBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyACQQA2AqgBQQAgAkHwAGogAkHYAGogAkGoAWpB4PnEABD1BwALwE0CLX8CfiMAQbALayICJAAgAkHIAGogAUEIaigCADYCACACQYABOgBMIAJBADYCPCACQoCAgIAQNwI0IAIgASkCADcCQCACQdgGaiACQTRqEIIBIAIoAtwGIRICQAJAAkACQAJAAkAgAigC2AYiAUGVgICAeEcEQCACIAIpA+AGIi83A+ADIAIgEjYC3AMgAiABNgLYA0GAgICAeCEJIC+nIQUCQAJAAn8CfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAFBgICAgHhzIAFBAE4bIihBFGsOAgABAgsCQCAvQoCAgIAQWgRAIAJBGGogBRCqBCACKAIcIg4gAigCGEEBcQ0UGiAvQiCIIjBCAVENBCACQRBqIAVBEGoQqQQgAigCFCETIAIoAhBBAXFFDQEgEwwUC0EAQZyAwQBBgP3AABDbBgwTCyAwQgJRDQMgAkGYBmoiCCAFQSBqEKYBIAIoApwGIgMgAigCmAYiAUECRg0SGiACQbAJaiACQcAGav0AAgD9CwMAIAJBwAlqIAJB0AZqKAIANgIAIAIgAikCuAY3A6gJIAIoArQGIQcgAigCsAYhCSACKAKoBiEPIAIoAqQGIQogMEIDUQ0EIAIoAqwGIRAgAigCoAYhFyAIIAVBMGoQxQEgAigCnAYiHSACKAKYBiIUQYCAgIB4Rg0RGiACKAKoBiEeIAIoAqQGIRkgMEIEUQ0FIAIoAqwGISIgAigCoAYhIyAIIAVBQGsQtwEgAigCnAYhBiACKAKYBiILQYCAgIB4Rg0QIAIoAqgGISEgAigCpAYhGwJAAkACfwJAIDBCBVIEQCACKAKsBiEkIAIoAqAGISUgCCAFQdAAahDGASACKAKcBiENIAIoApgGIhFBgICAgHhGDQMgAiAC/QACoAb9CwLACCACIA02ArwIIAIgETYCuAggMEIGUQ0BQYCAgIB4IQQCQAJAQRUgBUHgAGoiGCgCACIMQYCAgIB4cyAMQQBOG0EQaw4DBgAGAQsgBSgCZCEYCyACQZgGaiAYELIBIAIoApwGIhUgAigCmAYiBEGBgICAeEYNAhogFSAEQYKAgIB4Rg0CGiACKQK4BiEvIAIoArQGIRYgAigCsAYhGCACKAKsBiEcIAIoAqgGIRogAigCpAYhDCACKAKgBiEfDAQLQQVBnIDBAEGA/cAAENsGIQ0MAgtBBkGcgMEAQYD9wAAQ2wYLIQ0gAkG4CGoQ3wULIAsEQCAGIAtBARCiBwsgG0GAgICAeHJBgICAgHhHBEAgISAbQQEQogcLIA0hBgwRCyACQZgJaiIFIAJBwAlqKAIANgIAIAJBkAlqIgggAkG4CWopAwA3AwAgAiAC/QADqAn9CwOACSACIAc2AuwEIAIgCTYC6AQgAiAQNgLkBCACIA82AuAEIAIgCjYC3AQgAiAXNgLYBCACIAM2AtQEIAIgATYC0AQgAigCwAghJyACKALECCEQIAIoAsgIIRcgAigCzAghICACQYgFaiAFKAIANgIAIAJBgAVqIAgpAwA3AgAgAiAC/QADgAn9CwLwBCACIBM2AoAGIAIgDjYC/AUgAiAvNwL0BSACIBY2AvAFIAIgGDYC7AUgAiAcNgLoBSACIBo2AuQFIAIgDDYC4AUgAiAfNgLcBSACIBU2AtgFIAIgBDYC1AUgAiAgNgLQBSACIBc2AswFIAIgEDYCyAUgAiAnNgLEBSACIA02AsAFIAIgETYCvAUgAiAkNgK4BSACICE2ArQFIAIgGzYCsAUgAiAlNgKsBSACIAY2AqgFIAIgCzYCpAUgAiAiNgKgBSACIB42ApwFIAIgGTYCmAUgAiAjNgKUBSACIB02ApAFIAIgFDYCjAUgMEIHUgRAIAJBBzYCmAYgMKdB+f///wBqQf////8AcUEHaiACQZgGakHolcEAENsGIQMgAkHQBGoQhQJBAiEBDBQLIAJB6ANqIAJB2ARqQeQA/AoAAAwTCyAFRQRAQYGAgIB4IQpBAiEGQYCAgIB4IQVBgICAgHghEQwKCyAFQQV0ISYgAkHwBGohGUECIQZBgICAgHghBUGAgICAeCERQYGAgIB4IQoDQAJAAkACQAJAAkACQAJAAkBBFSALIBJqIgEoAgAiBEGAgICAeHMgBEEAThtBAWsODwEAAAIAAAAAAAAAAwQFBgALIAEgAkGACWpB9OTAABCVCCEEIAJBAToA0AQgAiAENgLUBAwGCyACQQA6ANAEIAJBByABQQRqLQAAIgQgBEEHTxs6ANEEDAULIAJBADoA0AQgAkIHIAFBCGopAwAiMCAwQgdaGzwA0QQMBAsgAkHQBGogAUEIaigCACABQQxqKAIAEKoGDAMLIAJB0ARqIAFBBGooAgAgAUEIaigCABCqBgwCCyACQdAEaiABQQhqKAIAIAFBDGooAgAQxwQMAQsgAkHQBGogAUEEaigCACABQQhqKAIAEMcECyACLQDQBEEBRgRAIAIoAtQEIQNBASEHDAwLIAFBEGohBAJAAkACQAJAAkACQAJAAkAgAi0A0QRBAWsOBwECAwQFBgcACyAHQQFGDRAgAkEgaiAEEKoEQQEhByACKAIkIQ4gAigCIEEBcUUNBiAOIQMMEgsgD0EBRg0OIAJBKGogBBCpBEEBIQ8gAigCLCETIAIoAihBAXFFDQUgEyEDQQEhB0EBIQsMEgsgBkECRwRAQQEhB0G8/8AAQQUQnwchAwwRCyACQdAEaiAEEKYBIAIoAtQEIQMgAigC0AQiBkECRgRAQQEhB0ECIQYMEQsgAkGwCWogGUEIav0AAgD9CwMAIAJBwAlqIBlBGGooAgA2AgAgAiAZKQIANwOoCSACKALsBCEhIAIoAugEIRsgAigC5AQhKSACKALgBCEiIAIoAtwEIR0gAigC2AQhKgwECyAJQYCAgIB4RwRAQQEhB0HB/8AAQQYQnwchAwwQCyACQdAEaiAEEMUBIAIoAtQEIQEgAigC0AQiCUGAgICAeEYEQEEBIQdBgICAgHghCSABIQMMEAsgAigC5AQhKyACKALgBCEjIAIoAtwEISQgAigC2AQhLCABIRQMAwsgBUGAgICAeEcEQEEBIQdBx//AAEEFEJ8HIQMMDwsgAkHQBGogBBC3ASACKALUBCEBIAIoAtAEIgVBgICAgHhGBEBBASEHQYCAgIB4IQUgASEDDA8LIAIoAuQEIS0gAigC4AQhJSACKALcBCEeIAIoAtgEIS4gASEIDAILIBFBgICAgHhHBEBBASEHQcz/wABBAxCfByEDDA4LIAJB0ARqIAQQxgEgAigC1AQhASACKALQBCIRQYCAgIB4RgRAQQEhB0GAgICAeCERIAEhAwwOCyACKALkBCEgIAIoAuAEIRcgAigC3AQhECACKALYBCEnIAEhDQwBCyAKQYGAgIB4RwRAQQEhC0HP/8AAQQMQnwchA0EBIQ9BASEHDA8LQYCAgIB4IQoCQAJAAkBBFSAEKAIAIgxBgICAgHhzIAxBAE4bQRBrDgMCAAIBCyABQRRqKAIAIQQLIAJB0ARqIAQQsgEgAigC0AQiCkGBgICAeEcNACACKALUBCEDQQEhC0EBIQ9BASEHDBALIAIpAvAEIS8gAigC7AQhFiACKALoBCEYIAIoAuQEIRwgAigC4AQhGiACKALcBCEMIAIoAtgEIR8gAigC1AQhFQsgJiALQSBqIgtHDQALIAdBAXFFDQkgD0EBcUUEQEEBIQdBq/zAAEEFEJwHIQMMCwsCQAJAIAZBAkYiC0UEQCACQdAGaiACQcAJaigCADYCACACQcgGaiACQbgJaikDADcCACACIAL9AAOoCf0LArgGIAIgITYCtAYgAiAbNgKwBiACICk2AqwGIAIgIjYCqAYgAiAdNgKkBiACICo2AqAGIAIgAzYCnAYgAiAGNgKYBgJAAkAgCUGAgICAeEYiD0UEQCACICs2AswIIAIgIzYCyAggAiAkNgLECCACICw2AsAIIAIgFDYCvAggAiAJNgK4CCAFQYCAgIB4RiIHDQEgAiAtNgKUCSACICU2ApAJIAIgHjYCjAkgAiAuNgKICSACIAg2AoQJIAIgBTYCgAlBgICAgHghBCARQYCAgIB4Rg0CIAJBoAZqIQEgCkGBgICAeEcNBAwFC0EBIQdBwf/AAEEGEJwHIQMMCwtBx//AAEEFEJwHIQMMCQtBzP/AAEEDEJwHIQMgAkGACWoQ4AUMCAtBASEHQbz/wABBBRCcByEDQQEhDwwNCyAKIQQLIAJBgAVqIAFBMGooAgA2AgAgAkHwBGogAUEgav0AAgD9CwMAIAJB4ARqIAFBEGr9AAIA/QsDACACQYwFaiACQcAIav0AAgD9CwIAIAJBrAVqIAJBkAlqKQIANwIAIAIgAikCuAg3AoQFIAIgAv0AAoAJ/QsCnAUgAiAB/QACAP0LA9AEIAYhAQwOCyACQdgDaiACQYAJakG048AAEJUIIQMMEgtBAUGcgMEAQYD9wAAQ2wYMDwtBAkGcgMEAQYD9wAAQ2wYMDgtBA0GcgMEAQYD9wAAQ2wYMDAtBBEGcgMEAQYD9wAAQ2wYhBgwKCyACQbgIahDfBQsgAkGYBmoQ5QUMBAtBASEHQav8wABBBRCfByEDDAILQQEhB0Gk/MAAQQcQnwchAwwBC0EBIQdBpPzAAEEHEJwHIQMLQQEhD0EBIQsLIApBgYCAgHhGDQELIApBgICAgHhGDQAgCgRAIBVBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIApqSQ0NIAFBACAEIApBJ2pLGw0OIBUQogILIAwEQCAaQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyAMakkNDSABQQAgBCAMQSdqSxsNDiAaEKICCyAYRQ0AIBZBBGsoAgAiAUF4cSIEIBhBAnQiJkEEQQggAUEDcSIBG2pJDQwgAUEAIAQgJkEnaksbDQ0gFhCiAgsCQCARQYCAgIB4Rg0AIBEEQCANQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyARakkNDSABQQAgBCARQSdqSxsNDiANEKICCyAQRQ0AIBdBBGsoAgAiAUF4cSIEIBBBAnQiJkEEQQggAUEDcSIBG2pJDQwgAUEAIAQgJkEnaksbDQ0gFxCiAgsCQCAFQYCAgIB4RyAHcUUNACAFBEAgCEEEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgBWpJDQ0gAUEAIAQgBUEnaksbDQ4gCBCiAgsgHkGAgICAeHJBgICAgHhGDQAgJUEEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgHmpJDQwgAUEAIAQgHkEnaksbDQ0gJRCiAgsCQCAJQYCAgIB4RyAPcUUNACAJBEAgFEEEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgCWpJDQ0gAUEAIAQgCUEnaksbDQ4gFBCiAgsgJEUNACAjQQRrKAIAIgFBeHEiBCAkQQJ0IgVBBEEIIAFBA3EiARtqSQ0MIAFBACAEIAVBJ2pLG0UEQCAjEKICDAELDA0LQQIhAQJAIAZBAkcgC3FFDQAgHQRAICJBBGsoAgAiBUF4cSIEQQRBCCAFQQNxIgUbIB1qSQ0NIAVBACAEIB1BJ2pLGw0OICIQogILIBtFDQAgIUEEaygCACIFQXhxIgRBBEEIIAVBA3EiBRsgG2pJDQwgBUEAIAQgG0EnaksbRQRAICEQogIMAgsMDQsLIAJB6ANqIAJB0ARqQeQA/AoAAAwDCyAUBEAgHSAUQQEQogcLIBkEQCAeIBlBAnRBBBCiBwsgBgsgCgRAIA8gCkEBEKIHCyAJBEAgByAJQQEQogcLCyEDIAJBiARqIAJBiAlq/QADAP0LAgAgAkGYBGogAkGYCWooAgA2AgAgAiACKQOACTcCgARBAiEBCyABQQJGDQAgAkHkBmogAkHoA2pB5AD8CgAAIAIgEzYCjAggAiAONgKICCACIC83AoAIIAIgFjYC/AcgAiAYNgL4ByACIBw2AvQHIAIgGjYC8AcgAiAMNgLsByACIB82AugHIAIgFTYC5AcgAiAENgLgByACICA2AtwHIAIgFzYC2AcgAiAQNgLUByACICc2AtAHIAIgDTYCzAcgAiARNgLIByACIAM2AuAGIAJBmAJqIAJB4AZqQcAB/AoAAEGAgICAeCEIDAMLIAJBgYCAgHg2AtgGIAIgAzYC3AYgAkHcBmoQsQQCQAJAAkACfwJAAkACQAJ/An8CQAJAAkACQAJAAkACQAJAIChBFGsOAgECAAsgAkHYA2ogAkGACWpB1OLAABCVCCEBDA8LIAIoAuQDIgZFDQMgAkHoA2ogAigC4AMiDRCwASACKALsAyEDIAIoAugDIghBgICAgHhGBEAgAyEBDA0LIAJBuAlqIAJBjARq/QACAP0LAwAgAkHICWogAkGcBGooAgA2AgAgAiAC/QAC/AP9CwOoCSACKAL4AyEWIAIoAvQDIQQgBkEBRg0CIAIoAvADIQcgAkHoA2oiCyANQRBqEM4BIAIoAuwDIgEgAigC6AMiCUGAgICAeEYNCxogAkHoCWogAkGIBGooAgA2AgAgAkHgCWogAkGABGoiEikCADcDACACIAL9AALwA/0LA9AJIAZBAkYNASALIA1BIGoQtwEgAigC7AMhBSACKALoAyIUQYCAgIB4Rg0KIAIoAvgDIREgAigC9AMhDAJAAn8CQAJAIAZBA0cEQCACKAL8AyEZIAIoAvADIRogCyANQTBqELMBIAIoAuwDIg8gAigC6AMiCkGAgICAeEYNAxogAkG4BmogAkGQBGooAgA2AgAgAkGoBmogEv0AAgD9CwMAIAIgAv0AAvAD/QsDmAYgBkEERg0BQYCAgIB4IQ4CQAJAQRUgDUFAayIQKAIAIhNBgICAgHhzIBNBAE4bQRBrDgMGAAYBCyANKAJEIRALIAJB6ANqIBAQmwEgAigC7AMhECACKALoAyIOQYGAgIB4Rg0CIAJBgApqIAJBjARqKAIANgIAIAIgAv0AAvwD/QsD8AkgDkGCgICAeEYNAiACKAL4AyEXIAIoAvQDIRMgAigC8AMhGAwEC0EDQfT/wABBgP3AABDbBgwCC0EEQfT/wABBgP3AABDbBiEQCyAKBEAgDyAKQQEQogcLIBALIQ8gFARAIAUgFEEBEKIHCyAMQYCAgIB4ckGAgICAeEcEQCARIAxBARCiBwsgDyEFDAsLIAJBsAhqIg0gAkGACmooAgA2AgAgAkGQCWoiHCACQbgJav0AAwD9CwMAIAJBoAlqIh8gAkHICWooAgA2AgAgAkH4CGoiCyACQegJaigCADYCACACQfAIaiIgIAJB4AlqKQMANwMAIAIgAv0AA/AJ/QsDoAggAiAC/QADqAn9CwOACSACIAL9AAPQCf0LA+AIIAJB2AhqIhIgAkG4BmooAgA2AgAgAkHICGoiFSACQagGav0AAwD9CwMAIAIgAv0AA5gG/QsDuAggAiAWNgLoBiACIAQ2AuQGIAIgBzYC4AYgAiADNgLcBiACIAg2AtgGIAJBjAdqIB8oAgA2AgAgAkH8BmogHP0AAwD9CwIAIAIgAv0AA4AJ/QsC7AYgAiABNgKUByACIAk2ApAHIAJBsAdqIAsoAgA2AgAgAkGoB2ogICkDADcCACACIAL9AAPgCP0LApgHIAIgDzYC0AcgAiAKNgLMByACIBk2AsgHIAIgETYCxAcgAiAMNgLAByACIBo2ArwHIAIgBTYCuAcgAiAUNgK0ByACQfQHaiASKAIANgIAIAJB5AdqIBX9AAMA/QsCACACIAL9AAO4CP0LAtQHIAIgFzYCiAggAiATNgKECCACIBg2AoAIIAIgEDYC/AcgAiAONgL4ByACQZwIaiANKAIANgIAIAIgAv0AA6AI/QsCjAggBkEFRwRAIAJBBTYC6AMgBkH7////AGpB/////wBxQQVqIAJB6ANqQeiVwQAQ2wYhASACQdgGahDIAkGAgICAeCEIDA4LIAJBiAtqIAJB4AZqIgZBIGr9AAIA/QsDACACQfgKaiAGQRBq/QACAP0LAwAgAkHQCmogAkHoCGr9AAMA/QsDACACQeAKaiALKAIANgIAIAJBwApqIAJBtAdqIgdBEGopAgA3AwAgAkGYCmogFf0AAwD9CwMAIAJBqApqIBIoAgA2AgAgAiACKQPgCDcDyAogAiAC/QADuAj9CwOICiACIAb9AAIA/QsD6AogAiAH/QACAP0LA7AKIAJBqAtqIA0oAgA2AgAgAiAC/QADoAj9CwOYCyABIQcgAyEBDA0LIAIoAuADIgFFBEBBgYCAgHghDkGAgICAeCEJQYCAgIB4IQxBgICAgHghCgwFCyABQQV0IRQgAkHsBmohCCACQeAGaiEDQQAhC0GAgICAeCEFQYCAgIB4IQlBgICAgHghDEGAgICAeCEKQYGAgIB4IQ4DQAJAAkACQAJAAkACQAJAAkBBFSALIBJqIgEoAgAiBEGAgICAeHMgBEEAThtBAWsODwEAAAIAAAAAAAAAAwQFBgALIAEgAkGACWpBpOTAABCVCCEEIAJBAToA2AYgAiAENgLcBgwGCyACQQA6ANgGIAJBBSABQQRqLQAAIgQgBEEFTxs6ANkGDAULIAJBADoA2AYgAkIFIAFBCGopAwAiLyAvQgVaGzwA2QYMBAsgAkHYBmogAUEIaigCACABQQxqKAIAEOIGDAMLIAJB2AZqIAFBBGooAgAgAUEIaigCABDiBgwCCyACQdgGaiABQQhqKAIAIAFBDGooAgAQpQUMAQsgAkHYBmogAUEEaigCACABQQhqKAIAEKUFCyACLQDYBkEBRgRAIAIoAtwGIQFBAQwHCyABQRBqIQQCQAJAAkACQAJAAkAgAi0A2QYOBQABAgMEBQsgBUGAgICAeEcEQEG8/8AAQQUQnwchAUEBDAwLIAJB2AZqIAQQsAEgAigC3AYhASACKALYBiIFQYCAgIB4RgRAQYCAgIB4IQVBAQwMCyACQagGaiAIQRBq/QACAP0LAwAgAkG4BmogCEEgaigCADYCACACIAj9AAIA/QsDmAYgAigC6AYhFSACKALkBiENIAIoAuAGIR8gASEGDAQLIAlBgICAgHhHBEBBwf/AAEEGEJ8HIQFBAQwLCyACQdgGaiAEEM4BIAIoAtwGIQEgAigC2AYiCUGAgICAeEYEQEGAgICAeCEJQQEMCwsgAkHACWogA0EYaigCADYCACACQbgJaiADQRBqKQIANwMAIAIgA/0AAgD9CwOoCSABIQcMAwsgDEGAgICAeEcEQEHH/8AAQQUQnwchAUEBDAoLIAJB2AZqIAQQtwEgAigC3AYhASACKALYBiIMQYCAgIB4RgRAQYCAgIB4IQxBAQwKCyACKALsBiEgIAIoAugGIRwgAigC5AYhGiACKALgBiEZIAEhFgwCCyAKQYCAgIB4RwRAQcz/wABBAxCfByEBQQEMCQsgAkHYBmogBBCzASACKALcBiEBIAIoAtgGIgpBgICAgHhGBEBBgICAgHghCkEBDAkLIAJBiARqIANBIGooAgA2AgAgAkH4A2ogA0EQav0AAgD9CwMAIAIgA/0AAgD9CwPoAyABIQ8MAQsgDkGBgICAeEcEQEEBIQRBz//AAEEDEJ8HIQFBASESQQEhCwwKCwJ/AkACQAJAQRUgBCgCACIOQYCAgIB4cyAOQQBOG0EQaw4DAgACAQsgAUEUaigCACEECyACQdgGaiAEEJsBIAIoAtwGIhAgAigC2AYiDkGBgICAeEcNARpBASEEIBAhAUEBIRJBASELDAwLQYCAgIB4IQ4gAigC3AYLIRAgAkHICGogCEEQaigCADYCACACIAj9AAIA/QsDuAggAigC6AYhFyACKALkBiETIAIoAuAGIRgLIAtBIGoiCyAURw0ACwwDC0ECQfT/wABBgP3AABDbBiEFDAgLQQFB9P/AAEGA/cAAENsGDAgLQQBB9P/AAEGA/cAAENsGIQEMCAsgBUGAgICAeEYNACACQYwHaiACQbgGaigCADYCACACQfwGaiACQagGav0AAwD9CwIAIAIgAv0AA5gG/QsC7AYgAiAVNgLoBiACIA02AuQGIAIgHzYC4AYgAiAGNgLcBiACIAU2AtgGAkACQAJAAkACQAJAIAlBgICAgHhGIhJFBEAgDEGAgICAeEYiCw0BIAIgIDYClAkgAiAcNgKQCSACIBo2AowJIAIgGTYCiAkgAiAWNgKECSACIAw2AoAJIApBgICAgHhGDQIgAkHgBmohASAOQYGAgIB4Rw0DQYCAgIB4IQ4MBAtBASELQcH/wABBBhCcByEBDAULQcf/wABBBRCcByEBDAMLQcz/wABBAxCcByEBIAJBgAlqEOAFDAILIAJBqAtqIAJByAhqKAIANgIAIAIgAv0AA7gI/QsDmAsLIAJBiAtqIAFBIGr9AAIA/QsDACACQfgKaiABQRBq/QACAP0LAwAgAkHQCmogAkGwCWr9AAMA/QsDACACQeAKaiACQcAJaigCADYCACACQcAKaiACQZAJaikCADcDACACQZgKaiACQfgDav0AAwD9CwMAIAJBqApqIAJBiARqKAIANgIAIAIgAikDqAk3A8gKIAIgAv0AAoAJ/QsDsAogAiAC/QAD6AP9CwOICiACIAH9AAIA/QsD6AogBiEBIAUhCAwKCyAJRQ0AIAcgCUEBEKIHCyACQdgGahDmBUEADAILQYCAgIB4IQVBvP/AAEEFEJwHIQFBAQshC0EBIRJBAQshBCAOQYGAgIB4Rg0BCyAOQYCAgIB4Rg0AIA4EQCAQIA5BARCiBwsgE0UNACAXIBNBARCiBwsCQCAKQYCAgIB4ckGAgICAeEYNAAJAIA9BBGsoAgAiA0F4cSIIQQRBCCADQQNxIgMbIApqTwRAIANBACAIIApBJ2pLGw0BIA8QogIMAgsMDAsMDAsCQCAMQYCAgIB4RyALcUUNAAJAIAwEQCAWQQRrKAIAIgNBeHEiCEEEQQggA0EDcSIDGyAMakkNDSADQQAgCCAMQSdqSxsNASAWEKICCyAaQYCAgIB4ckGAgICAeEYNASAcIBpBARCiBwwBCwwMCwJAIAlB/////wdxQQBHIBJxRQ0AAkAgB0EEaygCACIDQXhxIghBBEEIIANBA3EiAxsgCWpPBEAgA0EAIAggCUEnaksbDQEgBxCiAgwCCwwMCwwMC0GAgICAeCEIAkAgBUGAgICAeEcgBHFFDQAgBQRAIAZBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAVqSQ0MIANBACAEIAVBJ2pLGw0NIAYQogILIA1FDQAgFUEEaygCACIDQXhxIgZBBEEIIANBA3EiAxsgDWpJDQsgA0EAIAYgDUEnaksbRQRAIBUQogIMBQtBjI3IAEEuQbyNyAAQ6wcMCQsMAwsgCQRAIAEgCUEBEKIHCyAFCyEBIAgEQCADQQRrKAIAIgZBeHEiBUEEQQggBkEDcSIGGyAIakkNCSAGQQAgBSAIQSdqSxsNCiADEKICCyAERQ0AIBZBBGsoAgAiA0F4cSIGQQRBCCADQQNxIgMbIARqSQ0IIANBACAGIARBJ2pLGw0JIBYQogILIAJBhAtqIAJBkAlq/QADAP0LAgAgAkGUC2ogAkGgCWooAgA2AgAgAkHQCmogAkHoCGr9AAMA/QsDACACQeAKaiACQfgIaigCADYCACACQagKaiACQdgIaigCADYCACACQZgKaiACQcgIav0AAwD9CwMAIAIgAv0AA4AJ/QsC9AogAiACKQPgCDcDyAogAiAC/QADuAj9CwOICiACQagLaiACQbAIaigCADYCACACIAL9AAOgCP0LA5gLQYCAgIB4IQgLIAhBgICAgHhHDQILIAJBgYCAgHg2AtAEIAIgATYC1AQCQAJAAkACQCACQdAEaiIBKAIAQYCAgIB4aw4CAAIBCyABQQRqEIUCDAILIAEQyAIMAQsgAUEEahCxBAsjAEEQayIDJABBOhBxIgFFBEAACyABQThqQbDYwQAvAAA7AAAgAUEwakGo2MEAKQAANwAAIAFBIGpBmNjBAP0AAAD9CwAAIAFBEGpBiNjBAP0AAAD9CwAAIAFB+NfBAP0AAAD9CwAAIANBOjYCDCADIAE2AgggA0E6NgIEIANBBGoQugEgA0EQaiQAIRIgAkHYA2oQ/gILIAAgEjYCBCAAQYGAgIB4NgIAIABBCGogAkGYAmpBwAH8CgAADAMLIAJB+ARqIAJBiAtq/QADAP0LAgAgAkHoBGogAkH4Cmr9AAMA/QsCACACQZgFaiACQdAKav0AAwD9CwIAIAJBqAVqIAJB4ApqKAIANgIAIAJBvAVqIAJBwApqKQMANwIAIAJB3AVqIAJBmApq/QADAP0LAgAgAkHsBWogAkGoCmooAgA2AgAgAiAC/QAD6Ar9CwLYBCACIAIpA8gKNwKQBSACIAL9AAOwCv0LAqwFIAIgAv0AA4gK/QsCzAUgAkGUBmogAkGoC2ooAgA2AgAgAiAJNgKIBSACIAc2AowFIAIgCjYCxAUgAiAPNgLIBSACIA42AvAFIAIgEDYC9AUgAiAYNgL4BSACIBM2AvwFIAIgFzYCgAYgAiAC/QADmAv9CwKEBiACQZgCaiACQdgEakHAAfwKAAALIAJB2ANqEP4CIAIgATYCVCACIAg2AlAgAkHYAGogAkGYAmpBwAH8CgAAAkAgAigCSCIBIAIoAkQiA0kEQCACQdQAaiEHIAIoAkAhBgNAIAEgBmotAABBCWsiBUEXS0EBIAV0QZOAgARxRXINAiADIAFBAWoiAUcNAAsgAiADNgJICyAAIAJB0ABqQcgB/AoAAAwCCyACIAE2AkggAkEIaiAGIAMgAUEBaiIBIAMgASADSRsQ+QEgAigCDCEDIAIoAgghBkEUEHEiAUUNACABIAY2AgwgAUEWNgIAIAAgATYCBCAAQYGAgIB4NgIAIAEgAzYCECAIQYCAgIB4RgRAIAcQhQIMAgsgAkHQAGoQyAIMAQsACwJAIAIoAjQiAARAIAIoAjgiAUEEaygCACIDQXhxIgZBBEEIIANBA3EiAxsgAGpJDQIgA0EAIAYgAEEnaksbDQEgARCiAgsgAkGwC2okAA8LDAELQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4s9Agh+F38jAEGAAWsiDSQAAkACQAJAAkAgASkDCCIFUEUEQCABKAIQIhUoAgQiDyAVKQMIIgYgD60iBCAEIAZWG6ciDEcEQCAVKAIAIAxqLQAAIR4LIAEgBSAMIA9HIgytIgR9NwMIIBUgBCAGfDcDCCAMDQELQaiQyAApAwAiBEL/AYNCBFENACAAIAQ8AAggAEEAOgAEIABBATYCACAAQQ5qIARCMIg9AQAgACAEQhCIPgEKIAAgBEIIiDwACQwBCwJAAkACQAJAAkACQCAeQQR2QQNxDgIBAAILQQEhIQsCQAJAAkACQAJAAkAgHkEDcQ4CAQIACyAAQQE2AgAgAEEHOgAEDAkLIANB//8DcSACQf//A3FsIhVBAEgNAyAVRQRAQQAhFUEBIQIMCAsgFRBxIgJFDQEgAkEEay0AAEEDcUUgFUVyRQRAIAJBACAV/AsACyABKQMIIQcgASgCECESIAIhECAVIQMDQAJAIAdQDQAgEikDCCIFIBIoAgQiD60iBCAEIAVWG6ciGiASKAIAaiEcAkAgD0L/////DyAFIAVC/////w9aG6drIgxBACAMIA9NGyIbIAcgA60iBCAEIAdWG6ciDCAMIBtLGyIMQQFGBEAgECAcLQAAOgAADAELIAxFDQAgECAcIAz8CgAACyABIAcgDK0iBH0iBzcDCCASIAQgBXw3AwggDyAaRg0AIAwgEGohECADIAxrIgMNAQwJCwtBqJDIACkDACIEQv8Bg0IEUQ0HIAAgBDcCCCAAQQA6AAQgAEEBNgIAIAIgFUEBEKIHDAgLIA1BADoATCANIAE2AkggDUIANwNAIA1CADcDWCANQoCAgIAQNwNQIA1BBDoAMCANQQQ6ACAgDUEEOgAQIA1BBDoAACADQf//A3EgAkH//wNxbCIVQQJ0IhhBAEgNAUEBIRYCQCAYRQ0AIBgQcSIWRQ0BIBZBBGstAABBA3FFIBhFcg0AIBZBACAY/AsACyANQdAAaiEiIA0gAzsBXiANIAI7AVxBACEBAkADQAJAIAFB/wFxBEAgDSkDQCEJDAELQQ8hGUEBIQMgDSgCSCIRQQhqIhQpAwAiBVANCCARQRBqIg4oAgAiEygCACATKQMIIgggEygCBCIQrSIEIAQgCFYbpyIMaiEPAn4gBSAQQv////8PIAggCEL/////D1obp2siAUEAIAEgEE0brSIEIAQgBVYbQgdYBEAgDCAQRg0KQQghASAPMQAAIBFBCGoiDCAFQgF9NwMAIBMgCEIBfDcDCCANKQNAhCEJIAwpAwAiBlANAiAOKAIAIgwoAgQiAyAMKQMIIgUgA60iBCAEIAVWG6ciA0YNAiAMKAIAIANqMQAAIBMgCEICfDcDCCAUIAZCAX03AwBCCIYgCYQhCUEQIQEgFCkDACIGUA0CIA4oAgAiDygCBCIMIA8pAwgiBSAMrSIEIAQgBVYbpyIMRg0CIA8oAgAgDGoxAAAgEyAIQgN8NwMIIBQgBkIBfTcDAEIQhiAJhCEJQRghASAUKQMAIgZQDQIgDigCACIPKAIEIgwgDykDCCIFIAytIgQgBCAFVhunIgxGDQIgDygCACAMajEAACATIAhCBHw3AwggFCAGQgF9NwMAQhiGIAmEIQlBICEBIBQpAwAiBlANAiAOKAIAIg8oAgQiDCAPKQMIIgUgDK0iBCAEIAVWG6ciDEYNAiAPKAIAIAxqMQAAIBMgCEIFfDcDCCAUIAZCAX03AwBCIIYgCYQhCUEoIQEgFCkDACIGUA0CIA4oAgAiDygCBCIMIA8pAwgiBSAMrSIEIAQgBVYbpyIMRg0CIA8oAgAgDGoxAAAgEyAIQgZ8NwMIIBQgBkIBfTcDAEIohiAJhCEJQTAhASAUKQMAIgZQDQIgDigCACIPKAIEIgwgDykDCCIFIAytIgQgBCAFVhunIgxGDQIgDygCACAMajEAACATIAhCB3w3AwggFCAGQgF9NwMAQjCGIAmEDAELIA8pAAAgEyAIQgd8NwMIIBQgBUIHfTcDACANKQNAhAshCUE4IQELIA0gAUEBayIMOgBMIA0gCUIBiCIHNwNAAkACQAJAIAlCAYNQRQRAAkAgAUH/AXFBAksEQCAMIQEMAQtBDyEZIA0oAkgiA0EIaiIUKQMAIgZQDQsgA0EQaiIOKAIAIhMoAgAgEykDCCILIBMoAgQiA60iBCAEIAtWG6ciEGohEQJAAkAgBiADQv////8PIAsgC0L/////D1obp2siD0EAIAMgD08brSIEIAQgBlYbQgdYBEAgAyAQRg0OIBExAAAgEyALQgF8NwMIIBQgBkIBfTcDACAMrUL/AYMiCkIIfCEEIAqGIAeEIQcgFCkDACIIUA0CIA4oAgAiAygCBCIBIAMpAwgiBiABrSIFIAUgBlYbpyIBRg0CIAMoAgAgAWoxAAAgEyALQgJ8NwMIIBQgCEIBfTcDACAKQhB8IQUgBIYgB4QhByAUKQMAIghQBEAgBSEEDAMLIA4oAgAiAygCBCIBIAMpAwgiBiABrSIEIAQgBlYbpyIBRgRAIAUhBAwDCyADKAIAIAFqMQAAIBMgC0IDfDcDCCAUIAhCAX03AwAgCkIYfCEEIAWGIAeEIQcgFCkDACIIUA0CIA4oAgAiAygCBCIBIAMpAwgiBiABrSIFIAUgBlYbpyIBRg0CIAMoAgAgAWoxAAAgEyALQgR8NwMIIBQgCEIBfTcDACAKQiCEIQUgBIYgB4QhByAUKQMAIghQBEAgBSEEDAMLIA4oAgAiAygCBCIBIAMpAwgiBiABrSIEIAQgBlYbpyIBRgRAIAUhBAwDCyADKAIAIAFqMQAAIBMgC0IFfDcDCCAUIAhCAX03AwAgCkIofCEEIAWGIAeEIQcgFCkDACIJUA0CIA4oAgAiAygCBCIBIAMpAwgiCCABrSIGIAYgCFYbpyIBRiAFQi9Wcg0CIAMoAgAgAWoxAAAgEyALQgZ8NwMIIBQgCUIBfTcDACAKQjB8IQUgBIYgB4QhByAUKQMAIghQBEAgBSEEDAMLIA4oAgAiAygCBCIBIAMpAwgiBiABrSIEIAQgBlYbpyIBRw0BIAUhBAwCCyARKQAAIBMgBkHAACABa0H4AXFBA3atIgQgBCAGVhsiBCALfDcDCCAUIAYgBH03AwAgDEE4ciEBIAythiAHhCEHDAILIAMoAgAgAWoxAAAgEyALQgd8NwMIIBQgCEIBfTcDACAKQjiEIQQgBYYgB4QhBwsgDSAHNwNAIA0gBKciAToATCAcIQMgAUH/AXFBAkkNDAsgDSABQQJrOgBMIA0gB0ICiDcDQCANIAenQQNxIhxBBHRqIhMtAABBBEcEQEEQIRkMDAsgDSgCWCIBIA0oAlBGBEAgIkGI+8YAEKcGCyANKAJUIAFqIBw6AAAgDSABQQFqNgJYAkACQAJAAkACQAJAAkACQAJAIBxBAWsOAwEMAgALIA0tAEwiAUEDTwRAIA0pA0AhBwwEC0EPIRkgDSgCSCIDQQhqIg4pAwAiBVAEQCAaIQMMFAsgAa0hCSADQRBqIhAoAgAiESgCACARKQMIIgogESgCBCISrSIEIAQgClYbpyIMaiEPIAUgEkL/////DyAKIApC/////w9aG6drIgNBACADIBJNG60iBCAEIAVWG0IHVg0CIBohAyAMIBJGDRMgDzEAACEEIA4gBUIBfTcDACARIApCAXw3AwggCUIIhCELIA0pA0AgBCAJhoQhBwJAIA4pAwAiBlANACAQKAIAIgwoAgQiASAMKQMIIgUgAa0iBCAEIAVWG6ciAUYNACAMKAIAIAFqMQAAIBEgCkICfDcDCCAOIAZCAX03AwAgCUIQhCEIIAuGIAeEIQcgDikDACIGUARAIAinIQEMBQsgECgCACIMKAIEIgEgDCkDCCIFIAGtIgQgBCAFVhunIgFGBEAgCKchAQwFCyAMKAIAIAFqMQAAIBEgCkIDfDcDCCAOIAZCAX03AwAgCUIYhCELIAiGIAeEIQcgDikDACIGUA0AIBAoAgAiDCgCBCIBIAwpAwgiBSABrSIEIAQgBVYbpyIBRiAIQi9Wcg0AIAwoAgAgAWoxAAAgESAKQgR8NwMIIA4gBkIBfTcDACAJQiCEIQggC4YgB4QhByAOKQMAIgZQBEAgCKchAQwFCyAQKAIAIgwoAgQiASAMKQMIIgUgAa0iBCAEIAVWG6ciAUYEQCAIpyEBDAULIAtCL1YEQCAIpyEBDAULIAwoAgAgAWoxAAAgESAKQgV8NwMIIA4gBkIBfTcDACAJQiiEIQsgCIYgB4QhByAOKQMAIgZQDQAgECgCACIMKAIEIgEgDCkDCCIFIAGtIgQgBCAFVhunIgFGIAhCL1ZyDQAgDCgCACABajEAACARIApCBnw3AwggDiAGQgF9NwMAIAlCMIQhCCALhiAHhCEHIA4pAwAiBlAEQCAIpyEBDAULIBAoAgAiDCgCBCIBIAwpAwgiBSABrSIEIAQgBVYbpyIBRgRAIAinIQEMBQsgC0IvVgRAIAinIQEMBQsgDCgCACABajEAACARIApCB3w3AwggDiAGQgF9NwMAIAlCOIQhCyAIhiAHhCEHCyALpyEBDAMLIA0tAEwiAUEDTwRAIA0pA0AhBwwFC0EPIRkgDSgCSCIDQQhqIg4pAwAiBVAEQCAbIQMMEwsgAa0hCSADQRBqIhAoAgAiESgCACARKQMIIgogESgCBCISrSIEIAQgClYbpyIMaiEPIAUgEkL/////DyAKIApC/////w9aG6drIgNBACADIBJNG60iBCAEIAVWG0IHVg0DIBshAyAMIBJGDRIgDzEAACEEIA4gBUIBfTcDACARIApCAXw3AwggCUIIhCELIA0pA0AgBCAJhoQhBwJAIA4pAwAiBlANACAQKAIAIgwoAgQiASAMKQMIIgUgAa0iBCAEIAVWG6ciAUYNACAMKAIAIAFqMQAAIBEgCkICfDcDCCAOIAZCAX03AwAgCUIQhCEIIAuGIAeEIQcgDikDACIGUARAIAinIQEMBgsgECgCACIMKAIEIgEgDCkDCCIFIAGtIgQgBCAFVhunIgFGBEAgCKchAQwGCyAMKAIAIAFqMQAAIBEgCkIDfDcDCCAOIAZCAX03AwAgCUIYhCELIAiGIAeEIQcgDikDACIGUA0AIBAoAgAiDCgCBCIBIAwpAwgiBSABrSIEIAQgBVYbpyIBRiAIQi9Wcg0AIAwoAgAgAWoxAAAgESAKQgR8NwMIIA4gBkIBfTcDACAJQiCEIQggC4YgB4QhByAOKQMAIgZQBEAgCKchAQwGCyAQKAIAIgwoAgQiASAMKQMIIgUgAa0iBCAEIAVWG6ciAUYEQCAIpyEBDAYLIAtCL1YEQCAIpyEBDAYLIAwoAgAgAWoxAAAgESAKQgV8NwMIIA4gBkIBfTcDACAJQiiEIQsgCIYgB4QhByAOKQMAIgZQDQAgECgCACIMKAIEIgEgDCkDCCIFIAGtIgQgBCAFVhunIgFGIAhCL1ZyDQAgDCgCACABajEAACARIApCBnw3AwggDiAGQgF9NwMAIAlCMIQhCCALhiAHhCEHIA4pAwAiBlAEQCAIpyEBDAYLIBAoAgAiDCgCBCIBIAwpAwgiBSABrSIEIAQgBVYbpyIBRgRAIAinIQEMBgsgC0IvVgRAIAinIQEMBgsgDCgCACABajEAACARIApCB3w3AwggDiAGQgF9NwMAIAlCOIQhCyAIhiAHhCEHCyALpyEBDAQLIA0tAEwiAUEITwRAIA0pA0AhBwwGC0EPIRkgDSgCSCIMQQhqIg4pAwAiBVANESABrSEJIAxBEGoiECgCACIRKAIAIBEpAwgiCiARKAIEIhKtIgQgBCAKVhunIgxqIQ8gBSASQv////8PIAogCkL/////D1obp2siA0EAIAMgEk0brSIEIAQgBVYbQgdWDQQgDCASRg0RIA8xAAAhBCAOIAVCAX03AwAgESAKQgF8NwMIIAlCCIQhCyANKQNAIAQgCYaEIQcCQCAOKQMAIgZQDQAgECgCACIDKAIEIgEgAykDCCIFIAGtIgQgBCAFVhunIgFGDQAgAygCACABajEAACARIApCAnw3AwggDiAGQgF9NwMAIAlCEIQhCCALhiAHhCEHIA4pAwAiBlAEQCAIpyEBDAcLIBAoAgAiAygCBCIBIAMpAwgiBSABrSIEIAQgBVYbpyIBRgRAIAinIQEMBwsgAygCACABajEAACARIApCA3w3AwggDiAGQgF9NwMAIAlCGIQhCyAIhiAHhCEHIA4pAwAiBlANACAQKAIAIgMoAgQiASADKQMIIgUgAa0iBCAEIAVWG6ciAUYgCEIvVnINACADKAIAIAFqMQAAIBEgCkIEfDcDCCAOIAZCAX03AwAgCUIghCEIIAuGIAeEIQcgDikDACIGUARAIAinIQEMBwsgECgCACIDKAIEIgEgAykDCCIFIAGtIgQgBCAFVhunIgFGBEAgCKchAQwHCyALQi9WBEAgCKchAQwHCyADKAIAIAFqMQAAIBEgCkIFfDcDCCAOIAZCAX03AwAgCUIohCELIAiGIAeEIQcgDikDACIGUA0AIBAoAgAiAygCBCIBIAMpAwgiBSABrSIEIAQgBVYbpyIBRiAIQi9Wcg0AIAMoAgAgAWoxAAAgESAKQgZ8NwMIIA4gBkIBfTcDACAJQjCEIQggC4YgB4QhByAOKQMAIgZQBEAgCKchAQwHCyAQKAIAIgMoAgQiASADKQMIIgUgAa0iBCAEIAVWG6ciAUYEQCAIpyEBDAcLIAtCL1YEQCAIpyEBDAcLIAMoAgAgAWoxAAAgESAKQgd8NwMIIA4gBkIBfTcDACAJQjiEIQsgCIYgB4QhBwsgC6chAQwFCyAPKQAAIQQgESAKQgd8NwMIIA4gBUIHfTcDACABQThyIQEgDSkDQCAEIAmGhCEHCyANIAFBA2s6AEwgDSAHQgOINwNAQX8gB6dBB3EiGkECaiIfdEF/cyIBIAJB//8DcWogH3YiDCABIA0vAV5qIB92IgFsIg9BAnQhFwJAIA9FBEBBASESDAELIBcQcSISRQ0LIBJBBGstAABBA3FFIBdFcg0AIBJBACAX/AsACyANQewAaiANIAwgAUEAIBIgFxA8IA0tAGwiGUEdRg0HIA1B6ABqIA1B+ABqKAIANgIAIA0gDSkCcDcDYCANLwFuIR0gDS0AbSEDIA9FDQ8gEiAXQQEQogcMDwsgDykAACEEIBEgCkIHfDcDCCAOIAVCB303AwAgAUE4ciEBIA0pA0AgBCAJhoQhBwsgDSABQQNrOgBMIA0gB0IDiDcDQEF/IAenQQdxIhtBAmoiH3RBf3MiASACQf//A3FqIB92IgwgASANLwFeaiAfdiIBbCIPQQJ0IRcCQCAPRQRAQQEhEgwBCyAXEHEiEkUNCSASQQRrLQAAQQNxRSAXRXINACASQQAgF/wLAAsgDUHsAGogDSAMIAFBACASIBcQPCANLQBsIhlBHUYNBSANQegAaiANQfgAaigCADYCACANIA0pAnA3A2AgDS8BbiEdIA0tAG0hAyAPRQ0NIBIgF0EBEKIHDA0LIA8pAAAhBCARIApCB3w3AwggDiAFQgd9NwMAIAFBOHIhASANKQNAIAQgCYaEIQcLIA0gAUEIazoATCANIAdCCIg3A0AgB6ciDEH/AXEiHUEBaiIgQQJ0IhcQcSISRQ0GIBJBBGsiAy0AAEEDcUUgF0VyRQRAIBJBACAX/AsACyANQewAaiANICBBAUEAIBIgFxA8IA0tAGwiGUEdRwRAIA1B6ABqIA1B+ABqKAIANgIAIA0gDSkCcDcDYCANLwFuIR0gDS0AbSEDIBIgF0EBEKIHDAwLIAJB//8DcUEBAn9BAyAdQQJJDQAaQQIgHUEESQ0AGiAdQRBJCyIBdGpBAWsgAXYiAkH//wNNBEAgHUUEQEEBISBBACEdDAULQQQhASAMQQJ0QfwHcSIOQQFrIgwgFyAMIBdJGyIPQQRPBEAgD0EBaiIMQQNxIgFBBCABGyIBIA9Bf3NqIRAgDCABa0EEaiEBIBIhDANAIAxBBGoiDyAM/VwAACAP/VwAAP1u/VoAAAAgDyEMIBBBBGoiEA0ACwsgDkEIaiERIA5BBGohEANAIAEgEUYNAyABIANqIg9BBGoiDCAPLQAAIAwtAABqOgAAIAFBAWoiASAQRw0ACwwEC0HY5sgAQSsgDUH/AGpBmPvGAEGo+8YAEOAGAAsgGCANLwFeIgEgAkH//wNxbEECdCIQTwRAIA1B7ABqIA0gAiABQQEgFiAQEDwgDS0AbCIZQR1HBEAMAwsgDSgCWCIBBEAgFkEEaiEbIA0oAlQiDyABaiEDA0ACQAJAAkACQAJAAkACQAJAIANBAWsiAy0AACIBQQNNBEAgDSABQQR0aiIMLQAAQQFrDgQEBQIBAwsgAUEEQaj6xgAQjAcAC0G4+sYAEN0JAAsgFiAYIA0vAVwiAiANLwFeIgEgDC8BAiAMKAIIIAwoAgwQSiABIAJsQQJ0IRAMBQsgECAYSw0DIA1B7ABqIBYgECACIA0vAV4gDC0AASAMKAIIIAwoAgwQTiANLQBsIhlBHUYNBAwJCyAQIBhLDQEgFiAQIAIgDC0AASAMKAIIIAwoAgwQlwIMAwsgECAYTQRAIBBBfHEiDEUNAyAQQQRrIhpBBHEEfyAWBSAWIBYtAAEiASAWLQAAajoAACAWIAEgFi0AAmo6AAIgGkEESQ0EIAxBBGshDCAbCyEBA0AgASABQQFqLQAAIhwgAS0AAGo6AAAgAUECaiIaIBwgGi0AAGo6AAAgAUEEaiIaIAFBBWotAAAiHCAaLQAAajoAACABQQZqIhogHCAaLQAAajoAACABQQhqIQEgDEEIayIMDQALDAMLQQAgECAYQej6xgAQ6gcAC0EAIBAgGEHY+sYAEOoHAAtBACAQIBhByPrGABDqBwALIAMgD0cNAAsLIBVBAE4EQEEBIQICQCAVRQ0AIBUQcSICRQ0IIAJBBGstAABBA3FFIBVFcg0AIAJBACAV/AsACwJAIBUgFUH/////A3EiASABIBVLGyIDRQ0AQQAhGwJAIANBEUkNACACIBYgA0ECdGpBAmtJIBZBAWoiASACIANqSXENACACIQwgAyADQQ9xIhtBECAbG2siGyEZA0AgDCAB/QAAACAB/QAAEP0NAAQIDBAUGBwAAAAAAAAAACAB/QAAICAB/QAAMP0NAAAAAAAAAAAABAgMEBQYHP0NAAECAwQFBgcYGRobHB0eH/0LAAAgAUFAayEBIAxBEGohDCAZQRBrIhkNAAsLIAMgGyIMa0EDcSIBBEAgAUECdCEZIAxBAnQgFmpBAWohAQNAIAIgDGogAS0AADoAACABQQRqIQEgDEEBaiEMIBlBBGsiGQ0ACwsgGyADa0F8Sw0AIBYgDEECdGohASACIRsDQCAMIBtqIhogAUEBai0AADoAACAaQQFqIAFBBWotAAA6AAAgGkECaiABQQlqLQAAOgAAIBpBA2ogAUENai0AADoAACABQRBqIQEgG0EEaiEbIAwgA0EEayIDRw0ACwsgGARAIBYgGEEBEKIHCyANEPcDIA0oAlAiAUUNDSANKAJUIAFBARCiBwwNC0GI+sYAEP8HDAYLQQAgECAYQfj6xgAQ6gcACyABQQRrIBdBuPvGABCMBwALIA1B6ABqIA1B+ABqKAIANgIAIA0gDSkCcDcDYCANLwFuIR0gDS0AbSEDDAgLAkACQCATLQAAIgFBBEYgAUECRnINACATKAIEIg9FDQAgEygCCCIMQQRrKAIAIgFBeHEiA0EEQQggAUEDcSIBGyAPakkNASABQQAgAyAPQSdqSxsNAyAMEKICCyATIBc2AgwgEyASNgIIIBMgFzYCBCATICA7AQIgEyAfOgABIBMgHDoAACANLQBMIQEMAQsLDAkLDAkLAAtB+PnGABD/BwALQej5xgAQ/wcACyAAQQE2AgAgAEEGOgAEDAMLIBwhAwsgACAdOwEGIAAgAzoABSAAIBk6AAQgACANKQNgNwIIIABBATYCACAAQRBqIA1B6ABqKAIANgIAAkAgGARAIBZBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIBhqSQ0EIABBACABIBhBJ2pLGw0FIBYQogILIA0Q9wMgDSgCUCIDRQ0CIA0oAlQiAkEEaygCACIAQXhxIgFBBEEIIABBA3EiABsgA2pJDQMgAEEAIAEgA0EnaksbDQAgAhCiAgwCCwwDCyAAIB5BAnZBA3E6ABEgACAhOgAQIAAgFTYCDCAAIAI2AgggACAVNgIEIABBADYCAAsgDUGAAWokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC545Azd/A30BfiMAQYABayIBJAACQAJAAkAgACgCaCICQf8fTQRAIAFBADYCQCABQQE2AjQgAUHwssEANgIwIAFCBDcCOCABQTBqEJIHIQMMAQsgASAAKAJkIgMtAAAiBDoABiABIAMtAAEiBjoAByAEQQEgBhsEQCABQQI2AjQgAUHAssEANgIwIAFCAjcCPCABQoCAgIDwBCI7IAFBB2qthDcDECABIDsgAUEGaq2ENwMIIAEgAUEIajYCOCABQTBqEJIHIQMMAQsgA0EEaigAACEqIAMoABAhDSABIAMvABQiBDYCHCAEQQNPBEAgAUEBNgI0IAFBmLLBADYCMCABQgE3AjwgASABQRxqrUKAgICAEIQ3AwggASABQQhqNgI4IAFBMGoQkgchAwwBCyABIANBJGooAAAiBkGAgID+eyAGQf////8HcRs2AiAgASADKAAoIgZBgICA/gMgBkH/////B3EbNgIkIARBKGxBrKrBAGohECACQYAga0EKdkEBaiEUQQAhBEEAIQIgKkEKdEGAIGoiKyEhAkADQAJAIAQgKkcEQCAUIARBAWoiBEcNASABQQA2AkAgAUEBNgI0IAFB1LHBADYCMCABQgQ3AjggAUEwahCSByEDDAQLIAFBADoAOCABIAI2AjQgASANNgIwIAAgAUEwahDpASAqRQ0CQYAgISFBASEuAkADQCAhIgRBgAhqIiEgACgCaCIDSwRAIAFBADYCQCABQQE2AjQgAUHUscEANgIwIAFCBDcCOCABQTBqEJIHIQMMBgsgACgCZCIGIARqIgIoABgiEUUEQCAQKAIkIRELIAMgBEEkckkEQCABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAYLIAMgBEEockkEQCABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAYLIAMgBEEqckkEQCABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAYLIAIoAAQhB0EAIQQgECgCCCAQKAIAIBAoAgRqaiACLwAoIiJBA00EfyAiQQJ0KAKkq0EFIAQLIBAoAhBsakEEaiI1rSAHrX4iO0IgiFBFBEAgAUEANgJAIAFBATYCNCABQdCrwQA2AjAgAUIENwI4IAFBMGoQkgchAwwGCwJAAkACQAJ/AkAgAyArIgQgAigAJCIwQQJ0IgkgAigADCINIAIvABRsamoiFCA7pyIIaiIrTwRAIAIqABAhOCACKAAIIS8gAigAACEHIAIoACAhHCANDQFBAAwCCyABQQA2AkAgAUEBNgI0IAFBmLHBADYCMCABQgQ3AjggAUEwahCSByEDDAoLIAQgCWoiAiANQQxsaiADSw0BIA1BA2whHiACIAZqCyEjIBQgK00EQAJAIAdBA2wiDUH/////A0sNACAHQQxsIgJB/f///wdPDQACQAJAAkACQAJAAn8gAkUEQEEEIRZBBCEXQQAMAQsgAhBxIhZFDQEgFkEEay0AAEEDcUUgAkVyRQRAIBZBACAC/AsACyACEHEiF0UNASAXQQRrLQAAQQNxRSACRXJFBEAgF0EAIAL8CwALIA0LISQgB0ECdCIOQf////8DSw0EIAdBBHQiA0H9////B08NBEEEIRhBACElQQAhJkEEIRUgAwRAIAMQcSIVRQ0BIBVBBGstAABBA3FFIANFckUEQCAVQQAgA/wLAAsgDiEmCyACBEAgAhBxIhhFDQEgGEEEay0AAEEDcUUgAkVyRQRAIBhBACAC/AsACyANISULIAdB/////wNLIA5B/f///wdPcg0DQQQhD0EAIR1BACEnQQQhGiAOBEAgDhBxIhpFDQEgGkEEay0AAEEDcUUgDkVyRQRAIBpBACAO/AsACyAHIScLAkACfwJAAkAgIkUEQEEAIRJBACEfQQQhCgwBCyAHQQlsIhJB/////wNLDQYgB0EkbCICQf3///8HTw0GQQQhCkEAIR8gAgRAIAIQcSIPRQ0FIA9BBGstAABBA3FFIAJFckUEQCAPQQAgAvwLAAsgEiEfCyAiQQFHDQELQQAhCUEAIShBBCEZQQAhG0EAIS1BAAwBCyAHQQ9sIglB/////wNLDQMgB0E8bCICQf3///8HTw0DQQQhGUEAISggAgRAIAIQcSIKRQ0DIApBBGstAABBA3FFIAJFckUEQCAKQQAgAvwLAAsgCSEdCyAiQQNJBEBBASEtQQAhG0EADAELIAdBFWwiG0H/////A0sNASAHQdQAbCICQf3///8HTw0BAn8gAkUEQEEADAELIAIQcSIZRQ0DIBlBBGstAABBA3FFIAJFckUEQCAZQQAgAvwLAAsgGwshKEEBIS1BAQshMSABKAIcBH0gOEMAAAA/lCARs5UFQwAAAAALITogB0UNCiAEIAZqITYgBiAUaiEMQQEhA0EAISAgGSERQQAhBCAcIgYgL2wiNyETA0AgAyEUIAEgBCA1bCIDNgIoAkAgBCA3TwRAIDBFBEAgBiECDAILIDAgBiAcayICQQAgAiAGTRsiAk0EQCAGIQIMAgsgNiACQQJ0aigCACATaiICIARLBEAgBiECDAILIAIhEyAGQQFqIgIhBgwBCyAvBEAgBCAvbiECDAELQfitwQAQgQgACwJAAkACQAJAAn0CQAJAIAEoAhxFBEAgA0F7TSADQQRqIAhNcQ0BIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBAsgA0F9TSADQQJqIAhNcQ0BIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMAwsgAyAMaioAAAwBCyA6IAMgDGovAACzIBAoAiSzk5RDAAAAACE4AkAgI0UNACACQQNsIgMgHk8NACAjIANBAnRqKgIAITgLIDiSCyE4An0CQAJAAkAgDSAEQQNsIgNLBEAgFiADQQJ0IjJqIDg4AgAgASgCKCEFIAEoAhwNASAFQQRqIgtBe00gBUEIaiAITXENAiABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAULIAMgDUGIrsEAEIwHAAsgBUECaiILQX1NIAVBBGogCE1xDQEgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwDCyALIAxqKgAADAELIDogCyAMai8AALMgECgCJLOTlEMAAAAAITgCQCAjRQ0AIAJBA2xBAWoiBSAeTw0AICMgBUECdGoqAgAhOAsgOJILITgCfQJAAkACQCANIANBAWoiBUsEQCAWIAVBAnQiM2ogODgCACABKAIoIQUgASgCHA0BIAVBCGoiAkF7TSAFQQxqIAhNcQ0CIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBQsgBSANQZiuwQAQjAcACyAFQQRqIgtBfU0gBUEGaiAITXENASABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAMLIAIgDGoqAAAMAQsgOiALIAxqLwAAsyAQKAIks5OUQwAAAAAhOAJAICNFDQAgAkEDbEECaiICIB5PDQAgIyACQQJ0aioCACE4CyA4kgshOAJAIA0gA0ECaiICSwRAIBYgAkECdCI0aiA4OAIAIAFBMGoiBSAMIAggASgCKCAQKAIUaiICIAEoAhwQuwQgASgCNCEDIAEoAjANAiAXIDJqIAM2AgAgBSAMIAhBAkEEIAEoAhwiAxsgAmogAxC7BCABKAI0IQMgASgCMA0CIBcgM2ogAzYCACAFIAwgCCACQQRBCCABKAIcIgIbaiACELsEIAEoAjQhAyABKAIwDQIgFyA0aiADNgIAIAUgDCAIIAEoAiggECgCGGoiCyABKAIcELsEIAEoAjQhAyABKAIwDQIgBSAMIAhBAkEEIAEoAhwiAhsgC2ogAhC7BCABKAI0IQIgASgCMEUNASACIQMMAgsgAiANQaiuwQAQjAcACyABQTBqIAwgCEEEQQggASgCHCIFGyALaiAFELsEIAEoAjQhBSABKAIwBEAgBSEDDAELIAFBMGogDCAIIAtBBkEMIAEoAhwiCxtqIAsQuwQgASgCNCELIAEoAjAEQCALIQMMAQsCQAJAAkACQAJAAkACQAJAAkACQCAOIARBAnQiKUsEQCAVIClBAnRqIAI2AgAgKUEBciICIA5PDQEgFSACQQJ0aiAFNgIAIClBAnIiAiAOTw0CIBUgAkECdGogCzYCACApQQNyIgIgDk8NAyAVIAJBAnRqIAM2AgAgASgCKCAQKAIcaiICIAhPDQQgGCAyaiACIAxqLQAAs0MAAH9DlTgCACACQQFqIgMgCE8NBSAYIDNqIAMgDGotAACzQwAAf0OVOAIAIAJBAmoiAyAITw0GIBggNGogAyAMai0AALNDAAB/Q5U4AgAgAkEDaiICIAhPDQcgBCAHTw0IIBogKWogAiAMai0AALNDAAB/Q5U4AgAgIkUNDiABIBAoAiA2AiwgASAINgJEIAEgDDYCQCABIBA2AjggASABQSRqNgJMIAEgAUEgajYCSCABIAFBHGo2AjwgASABQSxqNgI0IAEgAUEoajYCMCABQQhqIgUgAUEwaiILQQAQzQMgASgCDCEDIAEoAggNCyAEQQlsIgIgEk8NDSAPIAJBAnRqIAM2AgAgBSALQQMQzQMgASgCDCEDIAEoAggNCyASIAJBAWoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEGEM0DIAEoAgwhAyABKAIIDQsgEiACQQJqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBARDNAyABKAIMIQMgASgCCA0LIBIgAkEDaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQQQzQMgASgCDCEDIAEoAggNCyASIAJBBGoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEHEM0DIAEoAgwhAyABKAIIDQsgEiACQQVqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBAhDNAyABKAIMIQMgASgCCA0LIBIgAkEGaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQUQzQMgASgCDCEDIAEoAggNCyASIAJBB2oiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEIEM0DIAEoAgwhAyABKAIIDQsgAkEIaiICIBJPDQ0gDyACQQJ0aiADNgIAIC0NCQwKCyApIA5BuK7BABCMBwALIAIgDkHIrsEAEIwHAAsgAiAOQdiuwQAQjAcACyACIA5B6K7BABCMBwALIAIgCEH4rsEAEIwHAAsgAyAIQYivwQAQjAcACyADIAhBmK/BABCMBwALIAIgCEGor8EAEIwHAAsgBCAHQbivwQAQjAcACyABQQhqIgIgAUEwaiIFQQkQzQMgASgCDCEDIAEoAggNASAEQQ9sIgQgCU8NAiAKIARBAnRqIAM2AgAgAiAFQQ4QzQMgASgCDCEDIAEoAggNASAJIARBAWoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakETEM0DIAEoAgwhAyABKAIIDQEgCSAEQQJqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBChDNAyABKAIMIQMgASgCCA0BIAkgBEEDaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQQ8QzQMgASgCDCEDIAEoAggNASAJIARBBGoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEUEM0DIAEoAgwhAyABKAIIDQEgCSAEQQVqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBCxDNAyABKAIMIQMgASgCCA0BIAkgBEEGaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRAQzQMgASgCDCEDIAEoAggNASAJIARBB2oiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEVEM0DIAEoAgwhAyABKAIIDQEgCSAEQQhqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBDBDNAyABKAIMIQMgASgCCA0BIAkgBEEJaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQREQzQMgASgCDCEDIAEoAggNASAJIARBCmoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEWEM0DIAEoAgwhAyABKAIIDQEgCSAEQQtqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBDRDNAyABKAIMIQMgASgCCA0BIAkgBEEMaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRIQzQMgASgCDCEDIAEoAggNASAJIARBDWoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEXEM0DIAEoAgwhAyABKAIIDQEgBEEOaiIEIAlPDQIgCiAEQQJ0aiADNgIACyAxRQ0DQQAhBCAgIQIDQCABQQhqIAFBMGogBEHIr8EAaigCABDNAyABKAIMIQMgASgCCA0BIAIgG0kEQCAEIBFqIAM2AgAgAkEBaiECIARBBGoiBEHUAEYNBQwBCwsgAiAbQZywwQAQjAcACwJAICgEQCAZQQRrKAIAIgBBeHEiBCAoQQJ0IgJBBEEIIABBA3EiABtqSQ0XIABBACAEIAJBJ2pLGw0YIBkQogILIB0EQCAKQQRrKAIAIgBBeHEiBCAdQQJ0IgJBBEEIIABBA3EiABtqSQ0XIABBACAEIAJBJ2pLGw0YIAoQogILIB8EQCAPQQRrKAIAIgBBeHEiBCAfQQJ0IgJBBEEIIABBA3EiABtqSQ0XIABBACAEIAJBJ2pLGw0YIA8QogILICcEQCAaQQRrKAIAIgBBeHEiBCAnQQJ0IgJBBEEIIABBA3EiABtqSQ0XIABBACAEIAJBJ2pLGw0YIBoQogILICUEQCAYQQRrKAIAIgBBeHEiBCAlQQJ0IgJBBEEIIABBA3EiABtqSQ0XIABBACAEIAJBJ2pLGw0YIBgQogILICYEQCAVQQRrKAIAIgBBeHEiBCAmQQJ0IgJBBEEIIABBA3EiABtySQ0XIABBACAEIAJBJ2pLGw0YIBUQogILICRFDRUgF0EEaygCACIAQXhxIgQgJEECdCICQQRBCCAAQQNxIgAbakkNFiAAQQAgBCACQSdqSxsNFyAXEKICICRFDRUgFkEEaygCACIAQXhxIgRBBEEIIABBA3EiABsgAmpJDRYgAEEAIAQgAkEnaksbDQAgFhCiAgwVCwwWCyAEIAlBrLDBABCMBwALIAIgEkG8sMEAEIwHAAsgEUHUAGohESAgQRVqISAgFCAHIBRLIgJqIQMgFCEEIAINAAsgByECICwhBAwJC0GorMEAEP8HCwALQZiswQAQ/wcAC0GIrMEAEP8HAAtB+KvBABD/BwALQeirwQAQ/wcAC0HYq8EAEP8HAAsgFCArIANBzLDBABDqBwALIAFBADYCQCABQQE2AjQgAUH4sMEANgIwIAFCBDcCOCABQTBqEJIHIQMMBwsCQAJAAkACQAJAAkACQAJAAkACQANAIAQgLGsiBkEDbCIgIA1NBEBBgIAEIAIgAkGAgARPGyIDQQNsIhQgDSAgayIRSw0CIAYgB0sNAyADIAcgBmsiEUsNBCAOIAZBAnQiEUkNBSADQQJ0IgUgDiARayIcSw0GQQAhHkEEIQtBBCEIQQAhHCAiBEAgEiAGQQlsIhNJDQggA0EJbCIcIBIgE2siCEsNCSAPIBNBAnRqIQgLAn8CQAJAIC0EQCAJIAZBD2wiE0kNASADQQ9sIh4gCSATayILSw0PIAogE0ECdGohCwsgMQ0BQQAhBkEEDAILIBMgCSAJQeiswQAQ6gcACyAbIAZBFWwiE0kNCiADQRVsIgYgGyATayIMSw0LIBkgE0ECdGoLIRMgAUIENwJ4IAFCAjcCcCABIAY2AmwgASATNgJoIAEgHjYCZCABIAs2AmAgASAcNgJcIAEgCDYCWCABIAU2AlQgASAVIBFBAnRqNgJQIAEgFDYCTCABIBcgIEECdCIGajYCSCABIBQ2AkQgASAGIBhqNgJAIAEgAzYCPCABIBEgGmo2AjggASAUNgI0IAEgBiAWajYCMCAAIAQgAyABQTBqEJMCIAMgBGohBCACIANrIgINAQwMCwsgICANIA1B6K3BABDqBwALQQAgFCARQditwQAQ6gcACyAGIAcgB0HIrcEAEOoHAAtBACADIBFBuK3BABDqBwALIBEgDiAOQaitwQAQ6gcAC0EAIAUgHEGYrcEAEOoHAAsgEyASIBJBiK3BABDqBwALQQAgHCAIQfiswQAQ6gcACyATIBsgG0HIrMEAEOoHAAtBACAGIAxBuKzBABDqBwALQQAgHiALQdiswQAQ6gcACwJAICgEQCAZQQRrKAIAIgRBeHEiAiAoQQJ0IgNBBEEIIARBA3EiBBtqSQ0BIARBACACIANBJ2pLGw0JIBkQogILIB0EQCAKQQRrKAIAIgRBeHEiAiAdQQJ0IgNBBEEIIARBA3EiBBtqSQ0IIARBACACIANBJ2pLGw0JIAoQogILIB8EQCAPQQRrKAIAIgRBeHEiAiAfQQJ0IgNBBEEIIARBA3EiBBtqSQ0IIARBACACIANBJ2pLGw0JIA8QogILICcEQCAaQQRrKAIAIgRBeHEiAiAnQQJ0IgNBBEEIIARBA3EiBBtqSQ0IIARBACACIANBJ2pLGw0JIBoQogILICUEQCAYQQRrKAIAIgRBeHEiAiAlQQJ0IgNBBEEIIARBA3EiBBtqSQ0IIARBACACIANBJ2pLGw0JIBgQogILICYEQCAVQQRrKAIAIgRBeHEiAiAmQQJ0IgNBBEEIIARBA3EiBBtySQ0IIARBACACIANBJ2pLGw0JIBUQogILAkAgJEUNACAXQQRrKAIAIgJBeHEiAyAkQQJ0IgRBBEEIIAJBA3EiBhtqSQ0IIAZBACAEQSdqIgIgA0kbDQkgFxCiAiAkRQ0AIBZBBGsoAgAiA0F4cSIGIARBBEEIIANBA3EiBBtqSQ0IIARBACACIAZJGw0DIBYQogILIAcgLGohLCAuICogLksiBGohLiAEDQEMBQsLDAULDAULIAIgA0GoIGovAAAiB0shCUEAIQYgAiAHIAkbIQIgISADQYQgaigAACAQKAIIIBAoAgAgECgCBGpqIAdBA00EfyAHQQJ0KAKkq0EFIAYLIBAoAhBsakEEamwgIWogA0GMIGooAAAgA0GUIGovAABsaiADQaQgaigAAEECdGoiIU0gA0GACGohAw0ACyABQQA2AkAgAUEBNgI0IAFB9LHBADYCMCABQgQ3AjggAUEwahCSByEDDAELQQAhAwsgAUGAAWokACADDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALnjkDN38DfQF+IwBBgAFrIgEkAAJAAkACQCAAKAJIIgJB/x9NBEAgAUEANgJAIAFBATYCNCABQfCywQA2AjAgAUIENwI4IAFBMGoQkgchAwwBCyABIAAoAkQiAy0AACIEOgAGIAEgAy0AASIGOgAHIARBASAGGwRAIAFBAjYCNCABQcCywQA2AjAgAUICNwI8IAFCgICAgPAEIjsgAUEHaq2ENwMQIAEgOyABQQZqrYQ3AwggASABQQhqNgI4IAFBMGoQkgchAwwBCyADQQRqKAAAISogAygAECENIAEgAy8AFCIENgIcIARBA08EQCABQQE2AjQgAUGYssEANgIwIAFCATcCPCABIAFBHGqtQoCAgIAQhDcDCCABIAFBCGo2AjggAUEwahCSByEDDAELIAEgA0EkaigAACIGQYCAgP57IAZB/////wdxGzYCICABIAMoACgiBkGAgID+AyAGQf////8HcRs2AiQgBEEobEGsqsEAaiEQIAJBgCBrQQp2QQFqIRRBACEEQQAhAiAqQQp0QYAgaiIrISECQANAAkAgBCAqRwRAIBQgBEEBaiIERw0BIAFBADYCQCABQQE2AjQgAUHUscEANgIwIAFCBDcCOCABQTBqEJIHIQMMBAsgAUEAOgA4IAEgAjYCNCABIA02AjAgACABQTBqEIQCICpFDQJBgCAhIUEBIS4CQANAICEiBEGACGoiISAAKAJIIgNLBEAgAUEANgJAIAFBATYCNCABQdSxwQA2AjAgAUIENwI4IAFBMGoQkgchAwwGCyAAKAJEIgYgBGoiAigAGCIRRQRAIBAoAiQhEQsgAyAEQSRySQRAIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBgsgAyAEQShySQRAIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBgsgAyAEQSpySQRAIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBgsgAigABCEHQQAhBCAQKAIIIBAoAgAgECgCBGpqIAIvACgiIkEDTQR/ICJBAnQoAqSrQQUgBAsgECgCEGxqQQRqIjWtIAetfiI7QiCIUEUEQCABQQA2AkAgAUEBNgI0IAFB0KvBADYCMCABQgQ3AjggAUEwahCSByEDDAYLAkACQAJAAn8CQCADICsiBCACKAAkIjBBAnQiCSACKAAMIg0gAi8AFGxqaiIUIDunIghqIitPBEAgAioAECE4IAIoAAghLyACKAAAIQcgAigAICEcIA0NAUEADAILIAFBADYCQCABQQE2AjQgAUGYscEANgIwIAFCBDcCOCABQTBqEJIHIQMMCgsgBCAJaiICIA1BDGxqIANLDQEgDUEDbCEeIAIgBmoLISMgFCArTQRAAkAgB0EDbCINQf////8DSw0AIAdBDGwiAkH9////B08NAAJAAkACQAJAAkACfyACRQRAQQQhFkEEIRdBAAwBCyACEHEiFkUNASAWQQRrLQAAQQNxRSACRXJFBEAgFkEAIAL8CwALIAIQcSIXRQ0BIBdBBGstAABBA3FFIAJFckUEQCAXQQAgAvwLAAsgDQshJCAHQQJ0Ig5B/////wNLDQQgB0EEdCIDQf3///8HTw0EQQQhGEEAISVBACEmQQQhFSADBEAgAxBxIhVFDQEgFUEEay0AAEEDcUUgA0VyRQRAIBVBACAD/AsACyAOISYLIAIEQCACEHEiGEUNASAYQQRrLQAAQQNxRSACRXJFBEAgGEEAIAL8CwALIA0hJQsgB0H/////A0sgDkH9////B09yDQNBBCEPQQAhHUEAISdBBCEaIA4EQCAOEHEiGkUNASAaQQRrLQAAQQNxRSAORXJFBEAgGkEAIA78CwALIAchJwsCQAJ/AkACQCAiRQRAQQAhEkEAIR9BBCEKDAELIAdBCWwiEkH/////A0sNBiAHQSRsIgJB/f///wdPDQZBBCEKQQAhHyACBEAgAhBxIg9FDQUgD0EEay0AAEEDcUUgAkVyRQRAIA9BACAC/AsACyASIR8LICJBAUcNAQtBACEJQQAhKEEEIRlBACEbQQAhLUEADAELIAdBD2wiCUH/////A0sNAyAHQTxsIgJB/f///wdPDQNBBCEZQQAhKCACBEAgAhBxIgpFDQMgCkEEay0AAEEDcUUgAkVyRQRAIApBACAC/AsACyAJIR0LICJBA0kEQEEBIS1BACEbQQAMAQsgB0EVbCIbQf////8DSw0BIAdB1ABsIgJB/f///wdPDQECfyACRQRAQQAMAQsgAhBxIhlFDQMgGUEEay0AAEEDcUUgAkVyRQRAIBlBACAC/AsACyAbCyEoQQEhLUEBCyExIAEoAhwEfSA4QwAAAD+UIBGzlQVDAAAAAAshOiAHRQ0KIAQgBmohNiAGIBRqIQxBASEDQQAhICAZIRFBACEEIBwiBiAvbCI3IRMDQCADIRQgASAEIDVsIgM2AigCQCAEIDdPBEAgMEUEQCAGIQIMAgsgMCAGIBxrIgJBACACIAZNGyICTQRAIAYhAgwCCyA2IAJBAnRqKAIAIBNqIgIgBEsEQCAGIQIMAgsgAiETIAZBAWoiAiEGDAELIC8EQCAEIC9uIQIMAQtB+K3BABCBCAALAkACQAJAAkACfQJAAkAgASgCHEUEQCADQXtNIANBBGogCE1xDQEgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwECyADQX1NIANBAmogCE1xDQEgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwDCyADIAxqKgAADAELIDogAyAMai8AALMgECgCJLOTlEMAAAAAITgCQCAjRQ0AIAJBA2wiAyAeTw0AICMgA0ECdGoqAgAhOAsgOJILITgCfQJAAkACQCANIARBA2wiA0sEQCAWIANBAnQiMmogODgCACABKAIoIQUgASgCHA0BIAVBBGoiC0F7TSAFQQhqIAhNcQ0CIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBQsgAyANQYiuwQAQjAcACyAFQQJqIgtBfU0gBUEEaiAITXENASABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAMLIAsgDGoqAAAMAQsgOiALIAxqLwAAsyAQKAIks5OUQwAAAAAhOAJAICNFDQAgAkEDbEEBaiIFIB5PDQAgIyAFQQJ0aioCACE4CyA4kgshOAJ9AkACQAJAIA0gA0EBaiIFSwRAIBYgBUECdCIzaiA4OAIAIAEoAighBSABKAIcDQEgBUEIaiICQXtNIAVBDGogCE1xDQIgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwFCyAFIA1BmK7BABCMBwALIAVBBGoiC0F9TSAFQQZqIAhNcQ0BIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMAwsgAiAMaioAAAwBCyA6IAsgDGovAACzIBAoAiSzk5RDAAAAACE4AkAgI0UNACACQQNsQQJqIgIgHk8NACAjIAJBAnRqKgIAITgLIDiSCyE4AkAgDSADQQJqIgJLBEAgFiACQQJ0IjRqIDg4AgAgAUEwaiIFIAwgCCABKAIoIBAoAhRqIgIgASgCHBC7BCABKAI0IQMgASgCMA0CIBcgMmogAzYCACAFIAwgCEECQQQgASgCHCIDGyACaiADELsEIAEoAjQhAyABKAIwDQIgFyAzaiADNgIAIAUgDCAIIAJBBEEIIAEoAhwiAhtqIAIQuwQgASgCNCEDIAEoAjANAiAXIDRqIAM2AgAgBSAMIAggASgCKCAQKAIYaiILIAEoAhwQuwQgASgCNCEDIAEoAjANAiAFIAwgCEECQQQgASgCHCICGyALaiACELsEIAEoAjQhAiABKAIwRQ0BIAIhAwwCCyACIA1BqK7BABCMBwALIAFBMGogDCAIQQRBCCABKAIcIgUbIAtqIAUQuwQgASgCNCEFIAEoAjAEQCAFIQMMAQsgAUEwaiAMIAggC0EGQQwgASgCHCILG2ogCxC7BCABKAI0IQsgASgCMARAIAshAwwBCwJAAkACQAJAAkACQAJAAkACQAJAIA4gBEECdCIpSwRAIBUgKUECdGogAjYCACApQQFyIgIgDk8NASAVIAJBAnRqIAU2AgAgKUECciICIA5PDQIgFSACQQJ0aiALNgIAIClBA3IiAiAOTw0DIBUgAkECdGogAzYCACABKAIoIBAoAhxqIgIgCE8NBCAYIDJqIAIgDGotAACzQwAAf0OVOAIAIAJBAWoiAyAITw0FIBggM2ogAyAMai0AALNDAAB/Q5U4AgAgAkECaiIDIAhPDQYgGCA0aiADIAxqLQAAs0MAAH9DlTgCACACQQNqIgIgCE8NByAEIAdPDQggGiApaiACIAxqLQAAs0MAAH9DlTgCACAiRQ0OIAEgECgCIDYCLCABIAg2AkQgASAMNgJAIAEgEDYCOCABIAFBJGo2AkwgASABQSBqNgJIIAEgAUEcajYCPCABIAFBLGo2AjQgASABQShqNgIwIAFBCGoiBSABQTBqIgtBABDNAyABKAIMIQMgASgCCA0LIARBCWwiAiASTw0NIA8gAkECdGogAzYCACAFIAtBAxDNAyABKAIMIQMgASgCCA0LIBIgAkEBaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQYQzQMgASgCDCEDIAEoAggNCyASIAJBAmoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEBEM0DIAEoAgwhAyABKAIIDQsgEiACQQNqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBBBDNAyABKAIMIQMgASgCCA0LIBIgAkEEaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQcQzQMgASgCDCEDIAEoAggNCyASIAJBBWoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakECEM0DIAEoAgwhAyABKAIIDQsgEiACQQZqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBBRDNAyABKAIMIQMgASgCCA0LIBIgAkEHaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQgQzQMgASgCDCEDIAEoAggNCyACQQhqIgIgEk8NDSAPIAJBAnRqIAM2AgAgLQ0JDAoLICkgDkG4rsEAEIwHAAsgAiAOQciuwQAQjAcACyACIA5B2K7BABCMBwALIAIgDkHorsEAEIwHAAsgAiAIQfiuwQAQjAcACyADIAhBiK/BABCMBwALIAMgCEGYr8EAEIwHAAsgAiAIQaivwQAQjAcACyAEIAdBuK/BABCMBwALIAFBCGoiAiABQTBqIgVBCRDNAyABKAIMIQMgASgCCA0BIARBD2wiBCAJTw0CIAogBEECdGogAzYCACACIAVBDhDNAyABKAIMIQMgASgCCA0BIAkgBEEBaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRMQzQMgASgCDCEDIAEoAggNASAJIARBAmoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEKEM0DIAEoAgwhAyABKAIIDQEgCSAEQQNqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBDxDNAyABKAIMIQMgASgCCA0BIAkgBEEEaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRQQzQMgASgCDCEDIAEoAggNASAJIARBBWoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakELEM0DIAEoAgwhAyABKAIIDQEgCSAEQQZqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBEBDNAyABKAIMIQMgASgCCA0BIAkgBEEHaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRUQzQMgASgCDCEDIAEoAggNASAJIARBCGoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEMEM0DIAEoAgwhAyABKAIIDQEgCSAEQQlqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBERDNAyABKAIMIQMgASgCCA0BIAkgBEEKaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRYQzQMgASgCDCEDIAEoAggNASAJIARBC2oiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakENEM0DIAEoAgwhAyABKAIIDQEgCSAEQQxqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBEhDNAyABKAIMIQMgASgCCA0BIAkgBEENaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRcQzQMgASgCDCEDIAEoAggNASAEQQ5qIgQgCU8NAiAKIARBAnRqIAM2AgALIDFFDQNBACEEICAhAgNAIAFBCGogAUEwaiAEQcivwQBqKAIAEM0DIAEoAgwhAyABKAIIDQEgAiAbSQRAIAQgEWogAzYCACACQQFqIQIgBEEEaiIEQdQARg0FDAELCyACIBtBnLDBABCMBwALAkAgKARAIBlBBGsoAgAiAEF4cSIEIChBAnQiAkEEQQggAEEDcSIAG2pJDRcgAEEAIAQgAkEnaksbDRggGRCiAgsgHQRAIApBBGsoAgAiAEF4cSIEIB1BAnQiAkEEQQggAEEDcSIAG2pJDRcgAEEAIAQgAkEnaksbDRggChCiAgsgHwRAIA9BBGsoAgAiAEF4cSIEIB9BAnQiAkEEQQggAEEDcSIAG2pJDRcgAEEAIAQgAkEnaksbDRggDxCiAgsgJwRAIBpBBGsoAgAiAEF4cSIEICdBAnQiAkEEQQggAEEDcSIAG2pJDRcgAEEAIAQgAkEnaksbDRggGhCiAgsgJQRAIBhBBGsoAgAiAEF4cSIEICVBAnQiAkEEQQggAEEDcSIAG2pJDRcgAEEAIAQgAkEnaksbDRggGBCiAgsgJgRAIBVBBGsoAgAiAEF4cSIEICZBAnQiAkEEQQggAEEDcSIAG3JJDRcgAEEAIAQgAkEnaksbDRggFRCiAgsgJEUNFSAXQQRrKAIAIgBBeHEiBCAkQQJ0IgJBBEEIIABBA3EiABtqSQ0WIABBACAEIAJBJ2pLGw0XIBcQogIgJEUNFSAWQQRrKAIAIgBBeHEiBEEEQQggAEEDcSIAGyACakkNFiAAQQAgBCACQSdqSxsNACAWEKICDBULDBYLIAQgCUGssMEAEIwHAAsgAiASQbywwQAQjAcACyARQdQAaiERICBBFWohICAUIAcgFEsiAmohAyAUIQQgAg0ACyAHIQIgLCEEDAkLQaiswQAQ/wcLAAtBmKzBABD/BwALQYiswQAQ/wcAC0H4q8EAEP8HAAtB6KvBABD/BwALQdirwQAQ/wcACyAUICsgA0HMsMEAEOoHAAsgAUEANgJAIAFBATYCNCABQfiwwQA2AjAgAUIENwI4IAFBMGoQkgchAwwHCwJAAkACQAJAAkACQAJAAkACQAJAA0AgBCAsayIGQQNsIiAgDU0EQEGAgAQgAiACQYCABE8bIgNBA2wiFCANICBrIhFLDQIgBiAHSw0DIAMgByAGayIRSw0EIA4gBkECdCIRSQ0FIANBAnQiBSAOIBFrIhxLDQZBACEeQQQhC0EEIQhBACEcICIEQCASIAZBCWwiE0kNCCADQQlsIhwgEiATayIISw0JIA8gE0ECdGohCAsCfwJAAkAgLQRAIAkgBkEPbCITSQ0BIANBD2wiHiAJIBNrIgtLDQ8gCiATQQJ0aiELCyAxDQFBACEGQQQMAgsgEyAJIAlB6KzBABDqBwALIBsgBkEVbCITSQ0KIANBFWwiBiAbIBNrIgxLDQsgGSATQQJ0agshEyABQgQ3AnggAUICNwJwIAEgBjYCbCABIBM2AmggASAeNgJkIAEgCzYCYCABIBw2AlwgASAINgJYIAEgBTYCVCABIBUgEUECdGo2AlAgASAUNgJMIAEgFyAgQQJ0IgZqNgJIIAEgFDYCRCABIAYgGGo2AkAgASADNgI8IAEgESAaajYCOCABIBQ2AjQgASAGIBZqNgIwIAAgBCADIAFBMGoQ4gEgAyAEaiEEIAIgA2siAg0BDAwLCyAgIA0gDUHorcEAEOoHAAtBACAUIBFB2K3BABDqBwALIAYgByAHQcitwQAQ6gcAC0EAIAMgEUG4rcEAEOoHAAsgESAOIA5BqK3BABDqBwALQQAgBSAcQZitwQAQ6gcACyATIBIgEkGIrcEAEOoHAAtBACAcIAhB+KzBABDqBwALIBMgGyAbQciswQAQ6gcAC0EAIAYgDEG4rMEAEOoHAAtBACAeIAtB2KzBABDqBwALAkAgKARAIBlBBGsoAgAiBEF4cSICIChBAnQiA0EEQQggBEEDcSIEG2pJDQEgBEEAIAIgA0EnaksbDQkgGRCiAgsgHQRAIApBBGsoAgAiBEF4cSICIB1BAnQiA0EEQQggBEEDcSIEG2pJDQggBEEAIAIgA0EnaksbDQkgChCiAgsgHwRAIA9BBGsoAgAiBEF4cSICIB9BAnQiA0EEQQggBEEDcSIEG2pJDQggBEEAIAIgA0EnaksbDQkgDxCiAgsgJwRAIBpBBGsoAgAiBEF4cSICICdBAnQiA0EEQQggBEEDcSIEG2pJDQggBEEAIAIgA0EnaksbDQkgGhCiAgsgJQRAIBhBBGsoAgAiBEF4cSICICVBAnQiA0EEQQggBEEDcSIEG2pJDQggBEEAIAIgA0EnaksbDQkgGBCiAgsgJgRAIBVBBGsoAgAiBEF4cSICICZBAnQiA0EEQQggBEEDcSIEG3JJDQggBEEAIAIgA0EnaksbDQkgFRCiAgsCQCAkRQ0AIBdBBGsoAgAiAkF4cSIDICRBAnQiBEEEQQggAkEDcSIGG2pJDQggBkEAIARBJ2oiAiADSRsNCSAXEKICICRFDQAgFkEEaygCACIDQXhxIgYgBEEEQQggA0EDcSIEG2pJDQggBEEAIAIgBkkbDQMgFhCiAgsgByAsaiEsIC4gKiAuSyIEaiEuIAQNAQwFCwsMBQsMBQsgAiADQaggai8AACIHSyEJQQAhBiACIAcgCRshAiAhIANBhCBqKAAAIBAoAgggECgCACAQKAIEamogB0EDTQR/IAdBAnQoAqSrQQUgBgsgECgCEGxqQQRqbCAhaiADQYwgaigAACADQZQgai8AAGxqIANBpCBqKAAAQQJ0aiIhTSADQYAIaiEDDQALIAFBADYCQCABQQE2AjQgAUH0scEANgIwIAFCBDcCOCABQTBqEJIHIQMMAQtBACEDCyABQYABaiQAIAMPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu+PAMWfwF+AXsjAEEgayITJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIARB//8DcSIHBEACQAJAAkACQCAHQRBNBEAgBEH/AXEiCEEDSQ0BIAhBBUkNB0GAEBBxIhBFDQhBACEEA0BCACEdIAggBEEPcSIHSwRAIAdBAnQiCkEEaiIMIAZLDQQgBSAKajUAACEdCyAJIBBqIAggBEEEdkEPcSIHSwR+IAdBAnQiCkEEaiIMIAZLDQQgBSAKajUAAEIghgVCAAsgHYQ3AAAgBEEBaiEEIAlBCGoiCUGAEEcNAAsgAkH//wNxIgkiBEUgA0H//wNxRXINGCACIARBAXZrIgZB//8DcSILEHEiAkUNCCALQQFrIgRBACAEIAtNGyIRQQN0IRkgCUECdCEOIAJBBGsoAgAiF0EDcSIcRSALRXJFBEAgAkEAIAv8CwALIAtBAnQhDyAAQQFqIRQgA0H//wNxIRIgDiAZTw0SIAEgDyASQQFrIgVsIgpJDRQgDyABIAprIgRLDRNBASALIAtBAU0bIQ1BACEIIAZB//8DcUEQSw0ZDCQLIAZBAEgNAwJAIAZBfHEiAgRAIAIQcSIERQ0JIAZBAnYhCCAGQQRrIgNBfHFBBGoiAgRAIAQgBSAC/AoAAAsgEyADQQJ2QQFqIgc2AgwgEyAENgIIIBMgCDYCBCADQfwHSQ0BDCMLIBNBADYCDCATQoCAgIAQNwIEQQEhBEEAIQcLIAchCUGAAiAHayINIAggB2tLBEBBACEFIwBBIGsiCCQAAkACQCAHIA1qIgIgE0EEaiIJKAIAIgRBAXQiBiACIAZLGyICQf////8DSw0AQQQgAiACQQRNGyIDQQJ0IgJBAEgNACAIIAQEfyAIIARBAnQ2AhwgCCAJKAIENgIUQQEFQQALNgIYIAhBCGpBASACIAhBFGoQhQcgCCgCCEEBRw0BIAgoAhAhBiAIKAIMIQULIAUgBkGclsgAEJMJAAsgCCgCDCECIAkgAzYCACAJIAI2AgQgCEEgaiQAIBMoAgwhCSATKAIIIQQLIAQgCUECdGohAyAHQf8BRwR/IA1BAnRBBGsiAgRAIANBACAC/AsACyAJIA1qIgJBAWshCSAEIAJBAnRqQQRrBSADC0EANgAAIBMgCUEBaiICNgIMIAJBgAJHDQUgEygCCCEEDCELQYDAABBxIhBFDQYgBEH/AXEhFkEAIQcDQEEAIRcgFiAHQQFxIgRLBEAgBEECdCIIQQRqIgogBksNAyAFIAhqKAAAIRcLQQAhDUEAIRggFiAHQQF2QQFxIgRLBEAgBEECdCIIQQRqIgogBksNAyAFIAhqKAAAIRgLIBYgB0ECdkEBcSIESwRAIARBAnQiCEEEaiIKIAZLDQMgBSAIaigAACENC0EAIRRBACEaIBYgB0EDdkEBcSIESwRAIARBAnQiCEEEaiIKIAZLDQMgBSAIaigAACEaCyAWIAdBBHZBAXEiBEsEQCAEQQJ0IghBBGoiCiAGSw0DIAUgCGooAAAhFAtBACEbQQAhCSAWIAdBBXZBAXEiBEsEQCAEQQJ0IghBBGoiCiAGSw0DIAUgCGooAAAhCQsgFiAHQQZ2QQFxIgRLBEAgBEECdCIIQQRqIgogBksNAyAFIAhqKAAAIRsLQQAhCiAWIAdBB3ZBAXEiBEsEQCAEQQJ0IghBBGoiCiAGSw0DIAUgCGooAAAhCgsgDCAQaiIEIBc2AAAgBEEcaiAKNgAAIARBGGogGzYAACAEQRRqIAk2AAAgBEEQaiAUNgAAIARBDGogGjYAACAEQQhqIA02AAAgBEEEaiAYNgAAIAdBAWohByAMQSBqIgxBgMAARw0ACyACQf//A3EiBEUgA0H//wNxRXINHiAEQQN2IAJBB3FBAEdqIgsQcSIGRQ0GIAtBAWsiAkEAIAIgC00bIg1BBXQhFSAEQQJ0IQ4gBkEEaygCACIWQQNxIhlFIAtFckUEQCAGQQAgC/wLAAsgC0ECdCEPIABBAWohCSADQf//A3EhESAOIBVJBEAgASAPIBFBAWsiA2wiBUkNGyAPIAEgBWsiB0sNKUEBIAsgC0EBTRshDUEAIQggC0EQTQ0gIAUgCWohByAGIQQgDSANQQ9xIgJBECACG2siCCEJA0AgBCAH/QAAACAH/QAAEP0NAAQIDBAUGBwAAAAAAAAAACAH/QAAICAH/QAAMP0NAAAAAAAAAAAABAgMEBQYHP0NAAECAwQFBgcYGRobHB0eH/0LAAAgB0FAayEHIARBEGohBCAJQRBrIgkNAAsMIAsgDiAVayESIAYgC2pBAWshHCALQQJJDRggEkEgSw0ZIA1B/v8AcSEXIA1BAXEhGEEAIQdBACAEQQJ0ayEaQQAgC0ECdGshGyALIAtBD3EiAkEQIAIbayEDIAAgBCARQQFrIgRsQQJ0aiECIAQgC2xBAnQgAGpBAWohDSALQRFJIRRBASEEA0AgASAHQX9zIBFqIgogD2wiBUkNGyAPIAEgBWsiB0sNKSAEIQlBACEFIA0hByAGIQQgAyEIIBRFBEADQCAEIAf9AAAAIAf9AAAQ/Q0ABAgMEBQYHAAAAAAAAAAAIAf9AAAgIAf9AAAw/Q0AAAAAAAAAAAAECAwQFBgc/Q0AAQIDBAUGBxgZGhscHR4f/QsAACAHQUBrIQcgBEEQaiEEIAhBEGsiCA0ACyADIQULIAsgBWshCCAFIAZqIQcgDSAFQQJ0aiEEA0AgByAELQAAOgAAIARBBGohBCAHQQFqIQcgCEEBayIIDQALIAEgCiAObCIMSQ0oIA4gASAMayIESw0qQQAhBCALQQJHBEAgAiEHA0AgByAQIAQgBmoiCC0AAEEFdGoiBf0AAAD9CwAAIAdBEGogBUEQav0AAAD9CwAAIAdBIGogECAIQQFqLQAAQQV0aiIF/QAAAP0LAAAgB0EwaiAFQRBq/QAAAP0LAAAgB0FAayEHIBcgBEECaiIERw0ACwsgACAMaiEHIBgEQCAHIARBBXRqIgUgECAEIAZqLQAAQQV0aiIE/QAAAP0LAAAgBUEQaiAEQRBq/QAAAP0LAAALIBIEQCAHIBVqIBAgHC0AAEEFdGogEvwKAAALIAIgGmohAiANIBtqIQ0gCSAJIBFJIgVqIQQgCSEHIAUNAAsMHQsgCiAMIAZB6OHEABDqBwALIAggCiAGQejhxAAQ6gcAC0Hg/8YAEP8HDAMLQcjgxABBIEHo4MQAEOsHAAtB2ObIAEErIBNBH2pBmNvEAEH44MQAEOAGAAtBgCAQcSIQRQ0AIARB/wFxIQlBACEHAkADQEEAIQwgCSAHQQNxIgRLBEAgBEECdCIIQQRqIg0gBksNAiAFIAhqKAAAIQwLQQAhGEEAIRcgCSAHQQJ2QQNxIgRLBEAgBEECdCIIQQRqIg0gBksNAiAFIAhqKAAAIRcLIAkgB0EEdkEDcSIESwRAIARBAnQiCEEEaiINIAZLDQIgBSAIaigAACEYC0EAIQ0gCSAHQQZ2QQNxIgRLBEAgBEECdCIIQQRqIg0gBksNAiAFIAhqKAAAIQ0LIAogEGoiBCAMNgAAIARBDGogDTYAACAEQQhqIBg2AAAgBEEEaiAXNgAAIAdBAWohByAKQRBqIgpBgCBHDQALIAJB//8DcSIERSADQf//A3FFcg0IIARBAnYgAkEDcUEAR2oiCxBxIgZFDQEgC0EBayICQQAgAiALTRsiDUEEdCEVIARBAnQhDiAGQQRrKAIAIhZBA3EiGUUgC0VyRQRAIAZBACAL/AsACyALQQJ0IQ8gAEEBaiEJIANB//8DcSERIA4gFUkEQCABIA8gEUEBayIDbCIMSQ0FIA8gASAMayIHSw0kQQEgCyALQQFNGyEFQQAhCCALQRBNDQogCSAMaiEHIAYhBCAFIAVBD3EiAkEQIAIbayIIIQkDQCAEIAf9AAAAIAf9AAAQ/Q0ABAgMEBQYHAAAAAAAAAAAIAf9AAAgIAf9AAAw/Q0AAAAAAAAAAAAECAwQFBgc/Q0AAQIDBAUGBxgZGhscHR4f/QsAACAHQUBrIQcgBEEQaiEEIAlBEGsiCQ0ACwwKCyAOIBVrIRIgBiALakEBayEcIAtBAkkNAiASQRBLDQMgDUH+/wFxIRcgDUEBcSEYQQAhB0EAIARBAnRrIRpBACALQQJ0ayEbIAsgC0EPcSICQRAgAhtrIQMgACAEIBFBAWsiBGxBAnRqIQIgBCALbEECdCAAakEBaiENIAtBEUkhFEEBIQQDQCABIAdBf3MgEWoiCSAPbCIMSQ0FIA8gASAMayIHSw0kIAQhBUEAIQogDSEHIAYhBCADIQggFEUEQANAIAQgB/0AAAAgB/0AABD9DQAECAwQFBgcAAAAAAAAAAAgB/0AACAgB/0AADD9DQAAAAAAAAAAAAQIDBAUGBz9DQABAgMEBQYHGBkaGxwdHh/9CwAAIAdBQGshByAEQRBqIQQgCEEQayIIDQALIAMhCgsgCyAKayEIIAYgCmohByANIApBAnRqIQQDQCAHIAQtAAA6AAAgBEEEaiEEIAdBAWohByAIQQFrIggNAAsgASAJIA5sIgpJDQsgDiABIAprIgRLDSVBACEEIAtBAkcEQCACIQcDQCAHIBAgBCAGaiIJLQAAQQR0av0AAAD9CwAAIAdBEGogECAJQQFqLQAAQQR0av0AAAD9CwAAIAdBIGohByAXIARBAmoiBEcNAAsLIAAgCmohByAYBEAgByAEQQR0aiAQIAQgBmotAABBBHRq/QAAAP0LAAALIBIEQCAHIBVqIBAgHC0AAEEEdGogEvwKAAALIAIgGmohAiANIBtqIQ0gBSAFIBFJIglqIQQgBSEHIAkNAAsMBwsgCCANIAZB6OHEABDqBwALAAsgEkEQTQRAIAAgFWohAiABIBFBAWsiACALbEECdCIMayEHIAEgACAEbEECdCIKayEEQQEhCANAIAEgDEkNAyAHIA9JDSIgBiAJIAxqLQAAOgAAIAEgCkkNCSAEIA5JDSMgEgRAIAIgCmogECAcLQAAQQR0aiAS/AoAAAsgByAPaiEHIAwgD2shDCAEIA5qIQQgCiAOayEKIAggEUkgCEEBaiEIDQALDAULIAEgDyARQQFrIgBsIgxJDQEgDyABIAxrIgdLDSAgBiAJIAxqLQAAOgAAIAEgACAObCIKSQ0HIA4gASAKayIETQ0DDCELIAEgDyARQQFrIgNsIgxJDQAgDyABIAxrIgdLDR9BACEFIAtBEE0NASAJIAxqIQcgBiEEIAsgC0EPcSICQRAgAhtrIgUhCANAIAQgB/0AAAAgB/0AABD9DQAECAwQFBgcAAAAAAAAAAAgB/0AACAgB/0AADD9DQAAAAAAAAAAAAQIDBAUGBz9DQABAgMEBQYHGBkaGxwdHh/9CwAAIAdBQGshByAEQRBqIQQgCEEQayIIDQALDAELIAwgASABQdjhxAAQ6gcACyALIAVrIQggBSAGaiEHIAwgBUECdGogAGpBAWohBANAIAcgBC0AADoAACAEQQRqIQQgB0EBaiEHIAhBAWsiCA0ACyABIAMgDmwiCkkNBCAOIAEgCmsiBEsNHiAAIApqIQBBASANIA1BAU0bIgFBAXFBACEEIA1BAk8EQCABQf7/AXEhAiAAIQcDQCAHIBAgBCAGaiIBLQAAQQR0av0AAAD9CwAAIAdBEGogECABQQFqLQAAQQR0av0AAAD9CwAAIAdBIGohByACIARBAmoiBEcNAAsLRQ0AIAAgBEEEdGogECAEIAZqLQAAQQR0av0AAAD9CwAAC0EAIBJBEEGY4cQAEOoHAAsgFkF4cSIAQQRBCCAZGyALakkNFyAZQQAgACALQSdqSxsNGCAGEKICCyAQQQRrKAIAIgFBeHFBhCBBiCAgAUEDcSIAG0kNFiAAQQAgAUGoIE8bDRcgEBCiAgwTCyAFIAhrIQkgBiAIaiEHIAwgCEECdGogAGpBAWohBANAIAcgBC0AADoAACAEQQRqIQQgB0EBaiEHIAlBAWsiCQ0ACyABIAMgDmwiCkkNACAOIAEgCmsiBEsNGgwXCyAKIAEgAUG44cQAEOoHAAsgDiAZayEVIAIgC2pBAWshFgJAIAZB//8DcSIHQQJPBEAgFUEISw0BIBFB/v8DcSEFQQAhBEEAIAlBAnRrIRhBACALQQJ0ayEaIAsgC0EPcSIDQRAgAxtrIQMgACASQQFrIgYgCWxBAnRqIRQgBiALbEECdCAAakEBaiENIAdBEUkhG0EBIQkDQCABIARBf3MgEmoiByAPbCIKSQ0EIA8gASAKayIESw0DIAkhBkEAIQogDSEEIAIhCSADIQggG0UEQANAIAkgBP0AAAAgBP0AABD9DQAECAwQFBgcAAAAAAAAAAAgBP0AACAgBP0AADD9DQAAAAAAAAAAAAQIDBAUGBz9DQABAgMEBQYHGBkaGxwdHh/9CwAAIARBQGshBCAJQRBqIQkgCEEQayIIDQALIAMhCgsgCyAKayEIIAIgCmohBCANIApBAnRqIQkDQCAEIAktAAA6AAAgCUEEaiEJIARBAWohBCAIQQFrIggNAAsgASAHIA5sIgxJDRkgDiABIAxrIglLDRVBACEEAkAgEUECTwRAIBQhBCACIQkgBSEIA0AgBCAQIAkvAAD9EP2JAf2pASIe/RsBQQN0aiAQIB79GwBBA3Rq/V0AAP1XAAAB/QsAACAEQRBqIQQgCUECaiEJIAhBAmsiCA0ACyAFIgQgEUYNAQsgFCAEQQN0aiEJA0AgCSAQIAIgBGotAABBA3RqKQAANwAAIAlBCGohCSAEQQFqIgQgEUkNAAsLIBUEQCAAIAxqIBlqIBAgFi0AAEEDdGogFfwKAAALIBQgGGohFCANIBpqIQ0gBiAGIBJJIgdqIQkgBiEEIAcNAAsMBgsgFUEITQRAIAAgGWohAyABIBJBAWsiACALbEECdCIKayEEIAEgACAJbEECdCIMayEJQQEhCANAIAEgCkkNBCAEIA9JDQMgAiAKIBRqLQAAOgAAIAEgDEkNGSAJIA5JDRUgFQRAIAMgDGogECAWLQAAQQN0aiAV/AoAAAsgBCAPaiEEIAogD2shCiAJIA5qIQkgDCAOayEMIAggEkkgCEEBaiEIDQALDAYLIAEgDyASQQFrIgBsIgpJDQIgDyABIAprIgRLDQEgAiAKIBRqLQAAOgAAIAEgACAObCIMSQ0XIA4gASAMayIJTQ0EDBMLIAEgDyASQQFrIgVsIgpJDQEgDyABIAprIgRLDQBBACEMIAZB//8DcUEQTQ0CIAogFGohBCACIQkgCyALQQ9xIgNBECADG2siDCEIA0AgCSAE/QAAACAE/QAAEP0NAAQIDBAUGBwAAAAAAAAAACAE/QAAICAE/QAAMP0NAAAAAAAAAAAABAgMEBQYHP0NAAECAwQFBgcYGRobHB0eH/0LAAAgBEFAayEEIAlBEGohCSAIQRBrIggNAAsMAgtBACAPIARByOHEABDqBwALIAogASABQdjhxAAQ6gcACyALIAxrIQggAiAMaiEEIAogDEECdGogAGpBAWohCQNAIAQgCS0AADoAACAJQQRqIQkgBEEBaiEEIAhBAWsiCA0ACyABIAUgDmwiDEkNEyAOIAEgDGsiCUsND0EBIBEgEUEBTRshAUEAIQogEUECTwRAIAAgDGohBCACIQkgAUH+/wNxIgohCANAIAQgECAJLwAA/RD9iQH9qQEiHv0bAUEDdGogECAe/RsAQQN0av1dAAD9VwAAAf0LAAAgBEEQaiEEIAlBAmohCSAIQQJrIggNAAsgCiARRg0BCyACIApqIQQgCiABayEIIAAgDCAKQQN0amohCQNAIAkgECAELQAAQQN0aikAADcAACAJQQhqIQkgBEEBaiEEIAhBAWoiCA0ACwtBACAVQQhBmOHEABDqBwALIBdBeHEiAEEEQQggHBsgC2pJDQ4gHEEAIAAgC0EnaksbDQ8gAhCiAgsgEEEEaygCACIBQXhxQYQQQYgQIAFBA3EiABtJDQ0gAEEAIAFBqBBPGw0OIBAQogIMCgsgCiAUaiEHIA1BD3EiA0EQIAMbIgMgDWshCSANIANrIQggAiEEA0AgBCAH/QAAACAH/QAAEP0NAAQIDBAUGBwAAAAAAAAAACAH/QAAICAH/QAAMP0NAAAAAAAAAAAABAgMEBQYHP0NAAECAwQFBgcYGRobHB0eH/0LAAAgB0FAayEHIARBEGohBCAJQRBqIgkNAAsMCgsgEkEgTQRAIAAgFWohAiABIBFBAWsiACALbEECdCIFayEHIAEgACAEbEECdCIMayEEQQEhCANAIAEgBUkNAyAHIA9JDREgBiAFIAlqLQAAOgAAIAEgDEkNECAEIA5JDRIgEgRAIAIgDGogECAcLQAAQQV0aiAS/AoAAAsgByAPaiEHIAUgD2shBSAEIA5qIQQgDCAOayEMIAggEUkgCEEBaiEIDQALDAULIAEgDyARQQFrIgBsIgVJDQEgDyABIAVrIgdLDQ8gBiAFIAlqLQAAOgAAIAEgACAObCIMSQ0OIA4gASAMayIETQ0DDBALIAEgDyARQQFrIgNsIgVJDQAgDyABIAVrIgdLDQ5BACEKIAtBEE0NASAFIAlqIQcgBiEEIAsgC0EPcSICQRAgAhtrIgohCANAIAQgB/0AAAAgB/0AABD9DQAECAwQFBgcAAAAAAAAAAAgB/0AACAgB/0AADD9DQAAAAAAAAAAAAQIDBAUGBz9DQABAgMEBQYHGBkaGxwdHh/9CwAAIAdBQGshByAEQRBqIQQgCEEQayIIDQALDAELIAUgASABQdjhxAAQ6gcACyALIAprIQggBiAKaiEHIAUgCkECdGogAGpBAWohBANAIAcgBC0AADoAACAEQQRqIQQgB0EBaiEHIAhBAWsiCA0ACyABIAMgDmwiDEkNCyAOIAEgDGsiBEsNDSAAIAxqIQBBASANIA1BAU0bIgFBAXFBACEEIA1BAk8EQCABQf7/AHEhAyAAIQcDQCAHIBAgBCAGaiICLQAAQQV0aiIB/QAAAP0LAAAgB0EQaiABQRBq/QAAAP0LAAAgB0EgaiAQIAJBAWotAABBBXRqIgH9AAAA/QsAACAHQTBqIAFBEGr9AAAA/QsAACAHQUBrIQcgAyAEQQJqIgRHDQALC0UNACAAIARBBXRqIgEgECAEIAZqLQAAQQV0aiIA/QAAAP0LAAAgAUEQaiAAQRBq/QAAAP0LAAALQQAgEkEgQZjhxAAQ6gcACyAWQXhxIgBBBEEIIBkbIAtqSQ0GIBlBACAAIAtBJ2pLGw0HIAYQogILIBBBBGsoAgAiAUF4cUGEwABBiMAAIAFBA3EiABtJDQUgAEEAIAFBqMAATxsNBiAQEKICDAILIA0gCGshCSAGIAhqIQcgBSAIQQJ0aiAAakEBaiEEA0AgByAELQAAOgAAIARBBGohBCAHQQFqIQcgCUEBayIJDQALIAEgAyAObCIMSQ0HIA4gASAMayIESw0JDAYLAkAgAUF8cSIIRQ0AIAFBBGsiAUEMcUEMRwRAIAggAUECdkEBakEDcSIHQQJ0ayEIA0AgACAEIABBAWotAABBAnRqKAAANgAAIABBBGohACAHQQFrIgcNAAsgAUEMSQ0BC0EAIQkDQCAAIAlqIgEgBCABQQFqLQAAQQJ0aigAADYAACABQQRqIAQgAUEFai0AAEECdGooAAA2AAAgAUEIaiAEIAFBCWotAABBAnRqKAAANgAAIAFBDGogBCABQQ1qLQAAQQJ0aigAADYAACAIIAlBEGoiCUcNAAsLIBMoAgQiAUUNACAEQQRrKAIAIgBBeHEiAiABQQJ0IgFBBEEIIABBA3EiABtqSQ0DIABBACACIAFBJ2pLGw0EIAQQogILIBNBIGokAA8LIAggDWshCSACIAhqIQcgCiAIQQJ0aiAAakEBaiEEA0AgByAELQAAOgAAIARBBGohBCAHQQFqIQcgCUEBaiIJDQALIAEgBSAObCIMSQ0EIA4gASAMayIJSw0ADAMLQQAgDiAJQajhxAAQ6gcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgE0EANgIUIBNBATYCCCATQYiCyAA2AgQgE0IENwIMIBNBBGpBiOHEABCNCAALIAwgASABQbjhxAAQ6gcAC0EAIA8gB0HI4cQAEOoHAAtBACAOIARBqOHEABDqBwALgjgDN38DfQF+IwBBgAFrIgEkAAJAAkACQCAAKALMASICQf8fTQRAIAFBADYCQCABQQE2AjQgAUHwssEANgIwIAFCBDcCOCABQTBqEJIHIQMMAQsgASAAKALIASIDLQAAIgQ6AAYgASADLQABIgY6AAcgBEEBIAYbBEAgAUECNgI0IAFBwLLBADYCMCABQgI3AjwgAUKAgICA8AQiOyABQQdqrYQ3AxAgASA7IAFBBmqthDcDCCABIAFBCGo2AjggAUEwahCSByEDDAELIANBBGooAAAhKiADKAAQIQ0gASADLwAUIgQ2AhwgBEEDTwRAIAFBATYCNCABQZiywQA2AjAgAUIBNwI8IAEgAUEcaq1CgICAgBCENwMIIAEgAUEIajYCOCABQTBqEJIHIQMMAQsgASADQSRqKAAAIgZBgICA/nsgBkH/////B3EbNgIgIAEgAygAKCIGQYCAgP4DIAZB/////wdxGzYCJCAEQShsQayqwQBqIRAgAkGAIGtBCnZBAWohFEEAIQQgKkEKdEGAIGoiKyECAkACQAJAA0AgBCAqRg0BIBQgBEEBaiIERg0CIB4gA0GoIGovAAAiBkshCCAeIAYgCBshHiACIANBhCBqKAAAIBAoAgggECgCACAQKAIEamogBkEDTQR/IAZBAnQoAqSrQQUgCQsgECgCEGxqQQRqbCACaiADQYwgaigAACADQZQgai8AAGxqIANBpCBqKAAAQQJ0aiICTSADQYAIaiEDDQALIAFBADYCQCABQQE2AjQgAUH0scEANgIwIAFCBDcCOCABQTBqEJIHIQMMAwsgAUEAOgA4IAEgHjYCNCABIA02AjAgACABQTBqEOEDICpFDQFBgCAhHkEBIS4CQANAIB4iBEGACGoiHiAAKALMASIDSwRAIAFBADYCQCABQQE2AjQgAUHUscEANgIwIAFCBDcCOCABQTBqEJIHIQMMBQsgACgCyAEiBiAEaiICKAAYIhFFBEAgECgCJCERCyACKAAEIQlBACEEIBAoAgggECgCACAQKAIEamogAi8AKCIiQQNNBH8gIkECdCgCpKtBBSAECyAQKAIQbGpBBGoiNa0gCa1+IjtCIIhQRQRAIAFBADYCQCABQQE2AjQgAUHQq8EANgIwIAFCBDcCOCABQTBqEJIHIQMMBQsCQAJAAkACfwJAIAMgKyIEIAIoACQiMEECdCIIIAIoAAwiDSACLwAUbGpqIhQgO6ciB2oiK08EQCACKgAQITggAigACCEvIAIoAAAhCSACKAAgIRwgDQ0BQQAMAgsgAUEANgJAIAFBATYCNCABQZixwQA2AjAgAUIENwI4IAFBMGoQkgchAwwJCyAEIAhqIgIgDUEMbGogA0sNASANQQNsIR8gAiAGagshIyAUICtNBEACQCAJQQNsIg1B/////wNLDQAgCUEMbCICQf3///8HTw0AAkACQAJAAkACQAJ/IAJFBEBBBCEWQQQhF0EADAELIAIQcSIWRQ0BIBZBBGstAABBA3FFIAJFckUEQCAWQQAgAvwLAAsgAhBxIhdFDQEgF0EEay0AAEEDcUUgAkVyRQRAIBdBACAC/AsACyANCyEkIAlBAnQiDkH/////A0sNBCAJQQR0IgNB/f///wdPDQRBBCEYQQAhJUEAISZBBCEVIAMEQCADEHEiFUUNASAVQQRrLQAAQQNxRSADRXJFBEAgFUEAIAP8CwALIA4hJgsgAgRAIAIQcSIYRQ0BIBhBBGstAABBA3FFIAJFckUEQCAYQQAgAvwLAAsgDSElCyAJQf////8DSyAOQf3///8HT3INA0EEIQ9BACEgQQAhJ0EEIRogDgRAIA4QcSIaRQ0BIBpBBGstAABBA3FFIA5FckUEQCAaQQAgDvwLAAsgCSEnCwJAAn8CQAJAICJFBEBBACESQQAhHUEEIQoMAQsgCUEJbCISQf////8DSw0GIAlBJGwiAkH9////B08NBkEEIQpBACEdIAIEQCACEHEiD0UNBSAPQQRrLQAAQQNxRSACRXJFBEAgD0EAIAL8CwALIBIhIAsgIkEBRw0BC0EAIQhBACEoQQQhGUEAIRtBACEtQQAMAQsgCUEPbCIIQf////8DSw0DIAlBPGwiAkH9////B08NA0EEIRlBACEoIAIEQCACEHEiCkUNAyAKQQRrLQAAQQNxRSACRXJFBEAgCkEAIAL8CwALIAghHQsgIkEDSQRAQQEhLUEAIRtBAAwBCyAJQRVsIhtB/////wNLDQEgCUHUAGwiAkH9////B08NAQJ/IAJFBEBBAAwBCyACEHEiGUUNAyAZQQRrLQAAQQNxRSACRXJFBEAgGUEAIAL8CwALIBsLIShBASEtQQELITEgASgCHAR9IDhDAAAAP5QgEbOVBUMAAAAACyE6IAlFDQogBCAGaiE2IAYgFGohDEEBIQNBACEhIBkhEUEAIQQgHCIGIC9sIjchEwNAIAMhFCABIAQgNWwiAzYCKAJAIAQgN08EQCAwRQRAIAYhAgwCCyAwIAYgHGsiAkEAIAIgBk0bIgJNBEAgBiECDAILIDYgAkECdGooAgAgE2oiAiAESwRAIAYhAgwCCyACIRMgBkEBaiICIQYMAQsgLwRAIAQgL24hAgwBC0H4rcEAEIEIAAsCQAJAAkACQAJ9AkACQCABKAIcRQRAIANBe00gA0EEaiAHTXENASABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAQLIANBfU0gA0ECaiAHTXENASABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAMLIAMgDGoqAAAMAQsgOiADIAxqLwAAsyAQKAIks5OUQwAAAAAhOAJAICNFDQAgAkEDbCIDIB9PDQAgIyADQQJ0aioCACE4CyA4kgshOAJ9AkACQAJAIA0gBEEDbCIDSwRAIBYgA0ECdCIyaiA4OAIAIAEoAighBSABKAIcDQEgBUEEaiILQXtNIAVBCGogB01xDQIgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwFCyADIA1BiK7BABCMBwALIAVBAmoiC0F9TSAFQQRqIAdNcQ0BIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMAwsgCyAMaioAAAwBCyA6IAsgDGovAACzIBAoAiSzk5RDAAAAACE4AkAgI0UNACACQQNsQQFqIgUgH08NACAjIAVBAnRqKgIAITgLIDiSCyE4An0CQAJAAkAgDSADQQFqIgVLBEAgFiAFQQJ0IjNqIDg4AgAgASgCKCEFIAEoAhwNASAFQQhqIgJBe00gBUEMaiAHTXENAiABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAULIAUgDUGYrsEAEIwHAAsgBUEEaiILQX1NIAVBBmogB01xDQEgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwDCyACIAxqKgAADAELIDogCyAMai8AALMgECgCJLOTlEMAAAAAITgCQCAjRQ0AIAJBA2xBAmoiAiAfTw0AICMgAkECdGoqAgAhOAsgOJILITgCQCANIANBAmoiAksEQCAWIAJBAnQiNGogODgCACABQTBqIgUgDCAHIAEoAiggECgCFGoiAiABKAIcELsEIAEoAjQhAyABKAIwDQIgFyAyaiADNgIAIAUgDCAHQQJBBCABKAIcIgMbIAJqIAMQuwQgASgCNCEDIAEoAjANAiAXIDNqIAM2AgAgBSAMIAcgAkEEQQggASgCHCICG2ogAhC7BCABKAI0IQMgASgCMA0CIBcgNGogAzYCACAFIAwgByABKAIoIBAoAhhqIgsgASgCHBC7BCABKAI0IQMgASgCMA0CIAUgDCAHQQJBBCABKAIcIgIbIAtqIAIQuwQgASgCNCECIAEoAjBFDQEgAiEDDAILIAIgDUGorsEAEIwHAAsgAUEwaiAMIAdBBEEIIAEoAhwiBRsgC2ogBRC7BCABKAI0IQUgASgCMARAIAUhAwwBCyABQTBqIAwgByALQQZBDCABKAIcIgsbaiALELsEIAEoAjQhCyABKAIwBEAgCyEDDAELAkACQAJAAkACQAJAAkACQAJAAkAgDiAEQQJ0IilLBEAgFSApQQJ0aiACNgIAIClBAXIiAiAOTw0BIBUgAkECdGogBTYCACApQQJyIgIgDk8NAiAVIAJBAnRqIAs2AgAgKUEDciICIA5PDQMgFSACQQJ0aiADNgIAIAEoAiggECgCHGoiAiAHTw0EIBggMmogAiAMai0AALNDAAB/Q5U4AgAgAkEBaiIDIAdPDQUgGCAzaiADIAxqLQAAs0MAAH9DlTgCACACQQJqIgMgB08NBiAYIDRqIAMgDGotAACzQwAAf0OVOAIAIAJBA2oiAiAHTw0HIAQgCU8NCCAaIClqIAIgDGotAACzQwAAf0OVOAIAICJFDQ4gASAQKAIgNgIsIAEgBzYCRCABIAw2AkAgASAQNgI4IAEgAUEkajYCTCABIAFBIGo2AkggASABQRxqNgI8IAEgAUEsajYCNCABIAFBKGo2AjAgAUEIaiIFIAFBMGoiC0EAEM0DIAEoAgwhAyABKAIIDQsgBEEJbCICIBJPDQ0gDyACQQJ0aiADNgIAIAUgC0EDEM0DIAEoAgwhAyABKAIIDQsgEiACQQFqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBBhDNAyABKAIMIQMgASgCCA0LIBIgAkECaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQEQzQMgASgCDCEDIAEoAggNCyASIAJBA2oiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEEEM0DIAEoAgwhAyABKAIIDQsgEiACQQRqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBBxDNAyABKAIMIQMgASgCCA0LIBIgAkEFaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQIQzQMgASgCDCEDIAEoAggNCyASIAJBBmoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEFEM0DIAEoAgwhAyABKAIIDQsgEiACQQdqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBCBDNAyABKAIMIQMgASgCCA0LIAJBCGoiAiASTw0NIA8gAkECdGogAzYCACAtDQkMCgsgKSAOQbiuwQAQjAcACyACIA5ByK7BABCMBwALIAIgDkHYrsEAEIwHAAsgAiAOQeiuwQAQjAcACyACIAdB+K7BABCMBwALIAMgB0GIr8EAEIwHAAsgAyAHQZivwQAQjAcACyACIAdBqK/BABCMBwALIAQgCUG4r8EAEIwHAAsgAUEIaiICIAFBMGoiBUEJEM0DIAEoAgwhAyABKAIIDQEgBEEPbCIEIAhPDQIgCiAEQQJ0aiADNgIAIAIgBUEOEM0DIAEoAgwhAyABKAIIDQEgCCAEQQFqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBExDNAyABKAIMIQMgASgCCA0BIAggBEECaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQQoQzQMgASgCDCEDIAEoAggNASAIIARBA2oiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEPEM0DIAEoAgwhAyABKAIIDQEgCCAEQQRqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBFBDNAyABKAIMIQMgASgCCA0BIAggBEEFaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQQsQzQMgASgCDCEDIAEoAggNASAIIARBBmoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEQEM0DIAEoAgwhAyABKAIIDQEgCCAEQQdqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBFRDNAyABKAIMIQMgASgCCA0BIAggBEEIaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQQwQzQMgASgCDCEDIAEoAggNASAIIARBCWoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEREM0DIAEoAgwhAyABKAIIDQEgCCAEQQpqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBFhDNAyABKAIMIQMgASgCCA0BIAggBEELaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQQ0QzQMgASgCDCEDIAEoAggNASAIIARBDGoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakESEM0DIAEoAgwhAyABKAIIDQEgCCAEQQ1qIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBFxDNAyABKAIMIQMgASgCCA0BIARBDmoiBCAITw0CIAogBEECdGogAzYCAAsgMUUNA0EAIQQgISECA0AgAUEIaiABQTBqIARByK/BAGooAgAQzQMgASgCDCEDIAEoAggNASACIBtJBEAgBCARaiADNgIAIAJBAWohAiAEQQRqIgRB1ABGDQUMAQsLIAIgG0GcsMEAEIwHAAsCQCAoBEAgGUEEaygCACIAQXhxIgQgKEECdCICQQRBCCAAQQNxIgAbakkNFiAAQQAgBCACQSdqSxsNFyAZEKICCyAdBEAgCkEEaygCACIAQXhxIgQgHUECdCICQQRBCCAAQQNxIgAbakkNFiAAQQAgBCACQSdqSxsNFyAKEKICCyAgBEAgD0EEaygCACIAQXhxIgQgIEECdCICQQRBCCAAQQNxIgAbakkNFiAAQQAgBCACQSdqSxsNFyAPEKICCyAnBEAgGkEEaygCACIAQXhxIgQgJ0ECdCICQQRBCCAAQQNxIgAbakkNFiAAQQAgBCACQSdqSxsNFyAaEKICCyAlBEAgGEEEaygCACIAQXhxIgQgJUECdCICQQRBCCAAQQNxIgAbakkNFiAAQQAgBCACQSdqSxsNFyAYEKICCyAmBEAgFUEEaygCACIAQXhxIgQgJkECdCICQQRBCCAAQQNxIgAbckkNFiAAQQAgBCACQSdqSxsNFyAVEKICCyAkRQ0UIBdBBGsoAgAiAEF4cSIEICRBAnQiAkEEQQggAEEDcSIAG2pJDRUgAEEAIAQgAkEnaksbDRYgFxCiAiAkRQ0UIBZBBGsoAgAiAEF4cSIEQQRBCCAAQQNxIgAbIAJqSQ0VIABBACAEIAJBJ2pLGw0AIBYQogIMFAsMFQsgBCAIQaywwQAQjAcACyACIBJBvLDBABCMBwALIBFB1ABqIREgIUEVaiEhIBQgCSAUSyICaiEDIBQhBCACDQALIAkhAyAsIQQMCQtBqKzBABD/BwsAC0GYrMEAEP8HAAtBiKzBABD/BwALQfirwQAQ/wcAC0Hoq8EAEP8HAAtB2KvBABD/BwALIBQgKyADQcywwQAQ6gcACyABQQA2AkAgAUEBNgI0IAFB+LDBADYCMCABQgQ3AjggAUEwahCSByEDDAYLAkACQAJAAkACQAJAAkACQAJAAkADQCAEICxrIgJBA2wiISANTQRAQYCABCADIANBgIAETxsiBkEDbCIUIA0gIWsiEUsNAiACIAlLDQMgBiAJIAJrIhFLDQQgDiACQQJ0IhFJDQUgBkECdCIFIA4gEWsiHEsNBkEAIR9BBCELQQQhB0EAIRwgIgRAIBIgAkEJbCITSQ0IIAZBCWwiHCASIBNrIgdLDQkgDyATQQJ0aiEHCwJ/AkACQCAtBEAgCCACQQ9sIhNJDQEgBkEPbCIfIAggE2siC0sNDyAKIBNBAnRqIQsLIDENAUEAIQJBBAwCCyATIAggCEHorMEAEOoHAAsgGyACQRVsIhNJDQogBkEVbCICIBsgE2siDEsNCyAZIBNBAnRqCyETIAFCBDcCeCABQgI3AnAgASACNgJsIAEgEzYCaCABIB82AmQgASALNgJgIAEgHDYCXCABIAc2AlggASAFNgJUIAEgFSARQQJ0ajYCUCABIBQ2AkwgASAXICFBAnQiAmo2AkggASAUNgJEIAEgAiAYajYCQCABIAY2AjwgASARIBpqNgI4IAEgFDYCNCABIAIgFmo2AjAgACAEIAYgAUEwahB+IAQgBmohBCADIAZrIgMNAQwMCwsgISANIA1B6K3BABDqBwALQQAgFCARQditwQAQ6gcACyACIAkgCUHIrcEAEOoHAAtBACAGIBFBuK3BABDqBwALIBEgDiAOQaitwQAQ6gcAC0EAIAUgHEGYrcEAEOoHAAsgEyASIBJBiK3BABDqBwALQQAgHCAHQfiswQAQ6gcACyATIBsgG0HIrMEAEOoHAAtBACACIAxBuKzBABDqBwALQQAgHyALQdiswQAQ6gcACwJAICgEQCAZQQRrKAIAIgRBeHEiAiAoQQJ0IgNBBEEIIARBA3EiBBtqSQ0BIARBACACIANBJ2pLGw0IIBkQogILIB0EQCAKQQRrKAIAIgRBeHEiAiAdQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIAoQogILICAEQCAPQQRrKAIAIgRBeHEiAiAgQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIA8QogILICcEQCAaQQRrKAIAIgRBeHEiAiAnQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIBoQogILICUEQCAYQQRrKAIAIgRBeHEiAiAlQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIBgQogILICYEQCAVQQRrKAIAIgRBeHEiAiAmQQJ0IgNBBEEIIARBA3EiBBtySQ0HIARBACACIANBJ2pLGw0IIBUQogILAkAgJEUNACAXQQRrKAIAIgJBeHEiAyAkQQJ0IgRBBEEIIAJBA3EiBhtqSQ0HIAZBACAEQSdqIgIgA0kbDQggFxCiAiAkRQ0AIBZBBGsoAgAiA0F4cSIGIARBBEEIIANBA3EiBBtqSQ0HIARBACACIAZJGw0DIBYQogILIAkgLGohLCAuICogLksiBGohLiAEDQEMBAsLDAQLDAQLIAFBADYCQCABQQE2AjQgAUHUscEANgIwIAFCBDcCOCABQTBqEJIHIQMMAQsgABDUASIDDQBBACEDCyABQYABaiQAIAMPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuDOAM3fwN9AX4jAEGAAWsiASQAAkACQAJAIAAoAsQBIgJB/x9NBEAgAUEANgJAIAFBATYCNCABQfCywQA2AjAgAUIENwI4IAFBMGoQkgchAwwBCyABIAAoAsABIgMtAAAiBDoABiABIAMtAAEiBjoAByAEQQEgBhsEQCABQQI2AjQgAUHAssEANgIwIAFCAjcCPCABQoCAgIDwBCI7IAFBB2qthDcDECABIDsgAUEGaq2ENwMIIAEgAUEIajYCOCABQTBqEJIHIQMMAQsgA0EEaigAACEqIAMoABAhDSABIAMvABQiBDYCHCAEQQNPBEAgAUEBNgI0IAFBmLLBADYCMCABQgE3AjwgASABQRxqrUKAgICAEIQ3AwggASABQQhqNgI4IAFBMGoQkgchAwwBCyABIANBJGooAAAiBkGAgID+eyAGQf////8HcRs2AiAgASADKAAoIgZBgICA/gMgBkH/////B3EbNgIkIARBKGxBrKrBAGohECACQYAga0EKdkEBaiEUQQAhBCAqQQp0QYAgaiIrIQICQAJAAkADQCAEICpGDQEgFCAEQQFqIgRGDQIgHiADQaggai8AACIGSyEIIB4gBiAIGyEeIAIgA0GEIGooAAAgECgCCCAQKAIAIBAoAgRqaiAGQQNNBH8gBkECdCgCpKtBBSAJCyAQKAIQbGpBBGpsIAJqIANBjCBqKAAAIANBlCBqLwAAbGogA0GkIGooAABBAnRqIgJNIANBgAhqIQMNAAsgAUEANgJAIAFBATYCNCABQfSxwQA2AjAgAUIENwI4IAFBMGoQkgchAwwDCyABQQA6ADggASAeNgI0IAEgDTYCMCAAIAFBMGoQpQQgKkUNAUGAICEeQQEhLgJAA0AgHiIEQYAIaiIeIAAoAsQBIgNLBEAgAUEANgJAIAFBATYCNCABQdSxwQA2AjAgAUIENwI4IAFBMGoQkgchAwwFCyAAKALAASIGIARqIgIoABgiEUUEQCAQKAIkIRELIAIoAAQhCUEAIQQgECgCCCAQKAIAIBAoAgRqaiACLwAoIiJBA00EfyAiQQJ0KAKkq0EFIAQLIBAoAhBsakEEaiI1rSAJrX4iO0IgiFBFBEAgAUEANgJAIAFBATYCNCABQdCrwQA2AjAgAUIENwI4IAFBMGoQkgchAwwFCwJAAkACQAJ/AkAgAyArIgQgAigAJCIwQQJ0IgggAigADCINIAIvABRsamoiFCA7pyIHaiIrTwRAIAIqABAhOCACKAAIIS8gAigAACEJIAIoACAhHCANDQFBAAwCCyABQQA2AkAgAUEBNgI0IAFBmLHBADYCMCABQgQ3AjggAUEwahCSByEDDAkLIAQgCGoiAiANQQxsaiADSw0BIA1BA2whHyACIAZqCyEjIBQgK00EQAJAIAlBA2wiDUH/////A0sNACAJQQxsIgJB/f///wdPDQACQAJAAkACQAJAAn8gAkUEQEEEIRZBBCEXQQAMAQsgAhBxIhZFDQEgFkEEay0AAEEDcUUgAkVyRQRAIBZBACAC/AsACyACEHEiF0UNASAXQQRrLQAAQQNxRSACRXJFBEAgF0EAIAL8CwALIA0LISQgCUECdCIOQf////8DSw0EIAlBBHQiA0H9////B08NBEEEIRhBACElQQAhJkEEIRUgAwRAIAMQcSIVRQ0BIBVBBGstAABBA3FFIANFckUEQCAVQQAgA/wLAAsgDiEmCyACBEAgAhBxIhhFDQEgGEEEay0AAEEDcUUgAkVyRQRAIBhBACAC/AsACyANISULIAlB/////wNLIA5B/f///wdPcg0DQQQhD0EAISBBACEnQQQhGiAOBEAgDhBxIhpFDQEgGkEEay0AAEEDcUUgDkVyRQRAIBpBACAO/AsACyAJIScLAkACfwJAAkAgIkUEQEEAIRJBACEdQQQhCgwBCyAJQQlsIhJB/////wNLDQYgCUEkbCICQf3///8HTw0GQQQhCkEAIR0gAgRAIAIQcSIPRQ0FIA9BBGstAABBA3FFIAJFckUEQCAPQQAgAvwLAAsgEiEgCyAiQQFHDQELQQAhCEEAIShBBCEZQQAhG0EAIS1BAAwBCyAJQQ9sIghB/////wNLDQMgCUE8bCICQf3///8HTw0DQQQhGUEAISggAgRAIAIQcSIKRQ0DIApBBGstAABBA3FFIAJFckUEQCAKQQAgAvwLAAsgCCEdCyAiQQNJBEBBASEtQQAhG0EADAELIAlBFWwiG0H/////A0sNASAJQdQAbCICQf3///8HTw0BAn8gAkUEQEEADAELIAIQcSIZRQ0DIBlBBGstAABBA3FFIAJFckUEQCAZQQAgAvwLAAsgGwshKEEBIS1BAQshMSABKAIcBH0gOEMAAAA/lCARs5UFQwAAAAALITogCUUNCiAEIAZqITYgBiAUaiEMQQEhA0EAISEgGSERQQAhBCAcIgYgL2wiNyETA0AgAyEUIAEgBCA1bCIDNgIoAkAgBCA3TwRAIDBFBEAgBiECDAILIDAgBiAcayICQQAgAiAGTRsiAk0EQCAGIQIMAgsgNiACQQJ0aigCACATaiICIARLBEAgBiECDAILIAIhEyAGQQFqIgIhBgwBCyAvBEAgBCAvbiECDAELQfitwQAQgQgACwJAAkACQAJAAn0CQAJAIAEoAhxFBEAgA0F7TSADQQRqIAdNcQ0BIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBAsgA0F9TSADQQJqIAdNcQ0BIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMAwsgAyAMaioAAAwBCyA6IAMgDGovAACzIBAoAiSzk5RDAAAAACE4AkAgI0UNACACQQNsIgMgH08NACAjIANBAnRqKgIAITgLIDiSCyE4An0CQAJAAkAgDSAEQQNsIgNLBEAgFiADQQJ0IjJqIDg4AgAgASgCKCEFIAEoAhwNASAFQQRqIgtBe00gBUEIaiAHTXENAiABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAULIAMgDUGIrsEAEIwHAAsgBUECaiILQX1NIAVBBGogB01xDQEgAUEANgJAIAFBATYCNCABQcjbwQA2AjAgAUIENwI4IAFBMGoQkgchAwwDCyALIAxqKgAADAELIDogCyAMai8AALMgECgCJLOTlEMAAAAAITgCQCAjRQ0AIAJBA2xBAWoiBSAfTw0AICMgBUECdGoqAgAhOAsgOJILITgCfQJAAkACQCANIANBAWoiBUsEQCAWIAVBAnQiM2ogODgCACABKAIoIQUgASgCHA0BIAVBCGoiAkF7TSAFQQxqIAdNcQ0CIAFBADYCQCABQQE2AjQgAUHI28EANgIwIAFCBDcCOCABQTBqEJIHIQMMBQsgBSANQZiuwQAQjAcACyAFQQRqIgtBfU0gBUEGaiAHTXENASABQQA2AkAgAUEBNgI0IAFByNvBADYCMCABQgQ3AjggAUEwahCSByEDDAMLIAIgDGoqAAAMAQsgOiALIAxqLwAAsyAQKAIks5OUQwAAAAAhOAJAICNFDQAgAkEDbEECaiICIB9PDQAgIyACQQJ0aioCACE4CyA4kgshOAJAIA0gA0ECaiICSwRAIBYgAkECdCI0aiA4OAIAIAFBMGoiBSAMIAcgASgCKCAQKAIUaiICIAEoAhwQuwQgASgCNCEDIAEoAjANAiAXIDJqIAM2AgAgBSAMIAdBAkEEIAEoAhwiAxsgAmogAxC7BCABKAI0IQMgASgCMA0CIBcgM2ogAzYCACAFIAwgByACQQRBCCABKAIcIgIbaiACELsEIAEoAjQhAyABKAIwDQIgFyA0aiADNgIAIAUgDCAHIAEoAiggECgCGGoiCyABKAIcELsEIAEoAjQhAyABKAIwDQIgBSAMIAdBAkEEIAEoAhwiAhsgC2ogAhC7BCABKAI0IQIgASgCMEUNASACIQMMAgsgAiANQaiuwQAQjAcACyABQTBqIAwgB0EEQQggASgCHCIFGyALaiAFELsEIAEoAjQhBSABKAIwBEAgBSEDDAELIAFBMGogDCAHIAtBBkEMIAEoAhwiCxtqIAsQuwQgASgCNCELIAEoAjAEQCALIQMMAQsCQAJAAkACQAJAAkACQAJAAkACQCAOIARBAnQiKUsEQCAVIClBAnRqIAI2AgAgKUEBciICIA5PDQEgFSACQQJ0aiAFNgIAIClBAnIiAiAOTw0CIBUgAkECdGogCzYCACApQQNyIgIgDk8NAyAVIAJBAnRqIAM2AgAgASgCKCAQKAIcaiICIAdPDQQgGCAyaiACIAxqLQAAs0MAAH9DlTgCACACQQFqIgMgB08NBSAYIDNqIAMgDGotAACzQwAAf0OVOAIAIAJBAmoiAyAHTw0GIBggNGogAyAMai0AALNDAAB/Q5U4AgAgAkEDaiICIAdPDQcgBCAJTw0IIBogKWogAiAMai0AALNDAAB/Q5U4AgAgIkUNDiABIBAoAiA2AiwgASAHNgJEIAEgDDYCQCABIBA2AjggASABQSRqNgJMIAEgAUEgajYCSCABIAFBHGo2AjwgASABQSxqNgI0IAEgAUEoajYCMCABQQhqIgUgAUEwaiILQQAQzQMgASgCDCEDIAEoAggNCyAEQQlsIgIgEk8NDSAPIAJBAnRqIAM2AgAgBSALQQMQzQMgASgCDCEDIAEoAggNCyASIAJBAWoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEGEM0DIAEoAgwhAyABKAIIDQsgEiACQQJqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBARDNAyABKAIMIQMgASgCCA0LIBIgAkEDaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQQQzQMgASgCDCEDIAEoAggNCyASIAJBBGoiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEHEM0DIAEoAgwhAyABKAIIDQsgEiACQQVqIgVNBEAgBSECDA4LIA8gBUECdGogAzYCACABQQhqIAFBMGpBAhDNAyABKAIMIQMgASgCCA0LIBIgAkEGaiIFTQRAIAUhAgwOCyAPIAVBAnRqIAM2AgAgAUEIaiABQTBqQQUQzQMgASgCDCEDIAEoAggNCyASIAJBB2oiBU0EQCAFIQIMDgsgDyAFQQJ0aiADNgIAIAFBCGogAUEwakEIEM0DIAEoAgwhAyABKAIIDQsgAkEIaiICIBJPDQ0gDyACQQJ0aiADNgIAIC0NCQwKCyApIA5BuK7BABCMBwALIAIgDkHIrsEAEIwHAAsgAiAOQdiuwQAQjAcACyACIA5B6K7BABCMBwALIAIgB0H4rsEAEIwHAAsgAyAHQYivwQAQjAcACyADIAdBmK/BABCMBwALIAIgB0Gor8EAEIwHAAsgBCAJQbivwQAQjAcACyABQQhqIgIgAUEwaiIFQQkQzQMgASgCDCEDIAEoAggNASAEQQ9sIgQgCE8NAiAKIARBAnRqIAM2AgAgAiAFQQ4QzQMgASgCDCEDIAEoAggNASAIIARBAWoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakETEM0DIAEoAgwhAyABKAIIDQEgCCAEQQJqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBChDNAyABKAIMIQMgASgCCA0BIAggBEEDaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQQ8QzQMgASgCDCEDIAEoAggNASAIIARBBGoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEUEM0DIAEoAgwhAyABKAIIDQEgCCAEQQVqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBCxDNAyABKAIMIQMgASgCCA0BIAggBEEGaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRAQzQMgASgCDCEDIAEoAggNASAIIARBB2oiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEVEM0DIAEoAgwhAyABKAIIDQEgCCAEQQhqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBDBDNAyABKAIMIQMgASgCCA0BIAggBEEJaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQREQzQMgASgCDCEDIAEoAggNASAIIARBCmoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEWEM0DIAEoAgwhAyABKAIIDQEgCCAEQQtqIgJNBEAgAiEEDAMLIAogAkECdGogAzYCACABQQhqIAFBMGpBDRDNAyABKAIMIQMgASgCCA0BIAggBEEMaiICTQRAIAIhBAwDCyAKIAJBAnRqIAM2AgAgAUEIaiABQTBqQRIQzQMgASgCDCEDIAEoAggNASAIIARBDWoiAk0EQCACIQQMAwsgCiACQQJ0aiADNgIAIAFBCGogAUEwakEXEM0DIAEoAgwhAyABKAIIDQEgBEEOaiIEIAhPDQIgCiAEQQJ0aiADNgIACyAxRQ0DQQAhBCAhIQIDQCABQQhqIAFBMGogBEHIr8EAaigCABDNAyABKAIMIQMgASgCCA0BIAIgG0kEQCAEIBFqIAM2AgAgAkEBaiECIARBBGoiBEHUAEYNBQwBCwsgAiAbQZywwQAQjAcACwJAICgEQCAZQQRrKAIAIgBBeHEiBCAoQQJ0IgJBBEEIIABBA3EiABtqSQ0WIABBACAEIAJBJ2pLGw0XIBkQogILIB0EQCAKQQRrKAIAIgBBeHEiBCAdQQJ0IgJBBEEIIABBA3EiABtqSQ0WIABBACAEIAJBJ2pLGw0XIAoQogILICAEQCAPQQRrKAIAIgBBeHEiBCAgQQJ0IgJBBEEIIABBA3EiABtqSQ0WIABBACAEIAJBJ2pLGw0XIA8QogILICcEQCAaQQRrKAIAIgBBeHEiBCAnQQJ0IgJBBEEIIABBA3EiABtqSQ0WIABBACAEIAJBJ2pLGw0XIBoQogILICUEQCAYQQRrKAIAIgBBeHEiBCAlQQJ0IgJBBEEIIABBA3EiABtqSQ0WIABBACAEIAJBJ2pLGw0XIBgQogILICYEQCAVQQRrKAIAIgBBeHEiBCAmQQJ0IgJBBEEIIABBA3EiABtySQ0WIABBACAEIAJBJ2pLGw0XIBUQogILICRFDRQgF0EEaygCACIAQXhxIgQgJEECdCICQQRBCCAAQQNxIgAbakkNFSAAQQAgBCACQSdqSxsNFiAXEKICICRFDRQgFkEEaygCACIAQXhxIgRBBEEIIABBA3EiABsgAmpJDRUgAEEAIAQgAkEnaksbDQAgFhCiAgwUCwwVCyAEIAhBrLDBABCMBwALIAIgEkG8sMEAEIwHAAsgEUHUAGohESAhQRVqISEgFCAJIBRLIgJqIQMgFCEEIAINAAsgCSEDICwhBAwJC0GorMEAEP8HCwALQZiswQAQ/wcAC0GIrMEAEP8HAAtB+KvBABD/BwALQeirwQAQ/wcAC0HYq8EAEP8HAAsgFCArIANBzLDBABDqBwALIAFBADYCQCABQQE2AjQgAUH4sMEANgIwIAFCBDcCOCABQTBqEJIHIQMMBgsCQAJAAkACQAJAAkACQAJAAkACQANAIAQgLGsiAkEDbCIhIA1NBEBBgIAEIAMgA0GAgARPGyIGQQNsIhQgDSAhayIRSw0CIAIgCUsNAyAGIAkgAmsiEUsNBCAOIAJBAnQiEUkNBSAGQQJ0IgUgDiARayIcSw0GQQAhH0EEIQtBBCEHQQAhHCAiBEAgEiACQQlsIhNJDQggBkEJbCIcIBIgE2siB0sNCSAPIBNBAnRqIQcLAn8CQAJAIC0EQCAIIAJBD2wiE0kNASAGQQ9sIh8gCCATayILSw0PIAogE0ECdGohCwsgMQ0BQQAhAkEEDAILIBMgCCAIQeiswQAQ6gcACyAbIAJBFWwiE0kNCiAGQRVsIgIgGyATayIMSw0LIBkgE0ECdGoLIRMgAUIENwJ4IAFCAjcCcCABIAI2AmwgASATNgJoIAEgHzYCZCABIAs2AmAgASAcNgJcIAEgBzYCWCABIAU2AlQgASAVIBFBAnRqNgJQIAEgFDYCTCABIBcgIUECdCICajYCSCABIBQ2AkQgASACIBhqNgJAIAEgBjYCPCABIBEgGmo2AjggASAUNgI0IAEgAiAWajYCMCAAIAQgBiABQTBqEJcBIAQgBmohBCADIAZrIgMNAQwMCwsgISANIA1B6K3BABDqBwALQQAgFCARQditwQAQ6gcACyACIAkgCUHIrcEAEOoHAAtBACAGIBFBuK3BABDqBwALIBEgDiAOQaitwQAQ6gcAC0EAIAUgHEGYrcEAEOoHAAsgEyASIBJBiK3BABDqBwALQQAgHCAHQfiswQAQ6gcACyATIBsgG0HIrMEAEOoHAAtBACACIAxBuKzBABDqBwALQQAgHyALQdiswQAQ6gcACwJAICgEQCAZQQRrKAIAIgRBeHEiAiAoQQJ0IgNBBEEIIARBA3EiBBtqSQ0BIARBACACIANBJ2pLGw0IIBkQogILIB0EQCAKQQRrKAIAIgRBeHEiAiAdQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIAoQogILICAEQCAPQQRrKAIAIgRBeHEiAiAgQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIA8QogILICcEQCAaQQRrKAIAIgRBeHEiAiAnQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIBoQogILICUEQCAYQQRrKAIAIgRBeHEiAiAlQQJ0IgNBBEEIIARBA3EiBBtqSQ0HIARBACACIANBJ2pLGw0IIBgQogILICYEQCAVQQRrKAIAIgRBeHEiAiAmQQJ0IgNBBEEIIARBA3EiBBtySQ0HIARBACACIANBJ2pLGw0IIBUQogILAkAgJEUNACAXQQRrKAIAIgJBeHEiAyAkQQJ0IgRBBEEIIAJBA3EiBhtqSQ0HIAZBACAEQSdqIgIgA0kbDQggFxCiAiAkRQ0AIBZBBGsoAgAiA0F4cSIGIARBBEEIIANBA3EiBBtqSQ0HIARBACACIAZJGw0DIBYQogILIAkgLGohLCAuICogLksiBGohLiAEDQEMBAsLDAQLDAQLIAFBADYCQCABQQE2AjQgAUHUscEANgIwIAFCBDcCOCABQTBqEJIHIQMMAQsgABCjASIDDQBBACEDCyABQYABaiQAIAMPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu3OwMafwV+AnsjAEGAA2siAyQAIANBADYCFCADQoCAgIDAADcCDCADQYCAgIB4NgIYIANBADYCYCADQQA7AVwgAyACNgJYIANBADYCVCADQQE6AFAgA0EKNgJMIAMgAjYCSCADQQA2AkQgAyACNgJAIAMgATYCPCADQQo2AjggA0EkaiEQIANBHGoiEkEYaiETAkACQAJAAkACQAJ/AkACQANAAkAgAygCPCECIANB4AJqIANBOGoQ/QICQAJ/IAMoAuACQQFGBEAgAygCVCEEIAMgAygC6AIiATYCVCACIARqIQcgASAEawwBCyADLQBdDQIgA0EBOgBdAkAgAy0AXEEBRgRAIAMoAlghASADKAJUIQIMAQsgAygCWCIBIAMoAlQiAkYNAwsgAygCPCACaiEHIAEgAmsLIgVFDQAgByAFQQFrIgJqLQAAQQpHDQAgBUECayIBIAIgAgR/IAdBACABIAdqLQAAQQ1GGwVBAAsiARshBSABIAcgARshBwsgB0UNACADIAMoAmAiCkEBajYCYCAFIAdqIQRBACEBIAchAgJAAkAgBUUEQEEAIQgMAQsDQCABIggCfyACIgEsAAAiBkEATgRAIAZB/wFxIQUgAUEBagwBCyABLQABQT9xIQIgBkEfcSEFIAZBX00EQCAFQQZ0IAJyIQUgAUECagwBCyABLQACQT9xIAJBBnRyIQIgBkFwSQRAIAIgBUEMdHIhBSABQQNqDAELIAVBEnRBgIDwAHEgAS0AA0E/cSACQQZ0cnIhBSABQQRqCyICIAFraiEBAkAgBUEgRiAFQQlrQQVJcg0AIAVBgAFJDQICQAJAAkACQCAFQQh2IgZBFmsOGwEGBgYGBgYGBgYCBgYGBgYGBgYGBgYGBgYGAwALIAYNBSAFQf8BcS0AxKFHQQFxRQ0FDAMLIAVBgC1HDQQMAgsgBUH/AXEtAMShR0ECcUUNAwwBCyAFQYDgAEcNAgsgAiAERw0AC0EAIQhBACEBDAELIAIgBEYNAANAAkAgBCIGQQFrIgQsAAAiBUEASARAIAVBP3ECfyAGQQJrIgQtAAAiCcAiBUFATgRAIAlBH3EMAQsgBUE/cQJ/IAZBA2siBC0AACIJwCIFQUBOBEAgCUEPcQwBCyAFQT9xIAZBBGsiBC0AAEEHcUEGdHILQQZ0cgtBBnRyIQULAkAgBUEgRiAFQQlrQQVJcg0AIAVBgAFJDQECQAJAAkACQCAFQQh2IglBFmsOGwAFBQUFBQUFBQUBBQUFBQUFBQUFBQUFBQUFAgMLIAVBgC1GDQMMBAsgBUH/AXEtAMShR0ECcQ0CDAMLIAVBgOAARw0CDAELIAkNASAFQf8BcS0AxKFHQQFxRQ0BCyACIARHDQEMAgsLIAEgAmsgBmohAQsgAyABIAhrIgw2AmwgAyAHIAhqIhQ2AmgCQAJAIApFBEAgDEEDRgRAIBRBkNDHAEEDENsHRQ0CCyADQQA2AvACIANBATYC5AIgA0Go0McANgLgAiADQgQ3AugCIANB4AJqEJUHIQEgAEGAgICAeDYCrAEgACABNgIADAgLIAwNAQsgAy0AXUUNAgwBCyABIAdqIQlBACENQQAhAkEAIQogFCIEIQFBACEGQQAhBwNAIAYhCAJ/AkAgB0EBcUUEQEEBIQcgASAJRkUEQANAIAIiBQJ/IAEiAiwAACIGQQBOBEAgBkH/AXEhBCABQQFqDAELIAItAAFBP3EhASAGQR9xIQQgBkFfTQRAIARBBnQgAXIhBCACQQJqDAELIAItAAJBP3EgAUEGdHIhASAGQXBJBEAgASAEQQx0ciEEIAJBA2oMAQsgBEESdEGAgPAAcSACLQADQT9xIAFBBnRyciEEIAJBBGoLIgEgAmtqIQIgBEEJayIGQRdNQQBBASAGdEGfgIAEcRsNAwJAIARBgAFJDQACQAJAAkACQCAEQQh2IgZBFmsOGwAEBAQEBAQEBAQBBAQEBAQEBAQEBAQEBAQEAgMLIARBgC1GDQcMAwsgBEH/AXEtAMShR0ECcQ0GDAILIARBgOAARg0FDAELIAYNACAEQf8BcS0AxKFHQQFxDQQLIAEgCUcNAAsgCSEEC0EBIQ0gCSEBIAwhBSAIDAILQQBBAEGw0McAEIwHAAsgASEEIAIhCkEAIQcgAgshBiAFIAhGDQALQSAQcSIRRQ0CIBEgBSAIazYCBCARIAggFGo2AgBBASEOIANBATYC6AIgAyARNgLkAiADQQQ2AuACA0AgCiEBIA0hBwNAIAEhBgJ/AkAgB0EBcUUEQEEBIQcgBCAJRwRAA0AgAiIFAn8gBCICLAAAIghBAE4EQCAIQf8BcSEBIAJBAWoMAQsgAi0AAUE/cSEBIAhBH3EhBCAIQV9NBEAgBEEGdCABciEBIAJBAmoMAQsgAi0AAkE/cSABQQZ0ciEBIAhBcEkEQCABIARBDHRyIQEgAkEDagwBCyAEQRJ0QYCA8ABxIAItAANBP3EgAUEGdHJyIQEgAkEEagsiBCACa2ohAiABQQlrIghBF01BAEEBIAh0QZ+AgARxGw0DAkAgAUGAAUkNAAJAAkACQAJAIAFBCHYiCEEWaw4bAAQEBAQEBAQEBAEEBAQEBAQEBAQEBAQEBAQCAwsgAUGALUYNBwwDCyABQf8BcS0AxKFHQQJxDQYMAgsgAUGA4ABGDQUMAQsgCA0AIAFB/wFxLQDEoUdBAXENBAsgBCAJRw0ACwtBASENIAwhBSAGDAILIAMoAuACIQgCQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQCADKALkAiILKAIEQQZrDgUAAQIKAwoLIAsoAgBBqajHAEEGENsHIA5BA0dyDQkCQCALKAIMQRRHDQAgCygCCEHA0McAQRQQ2wcNACALKAIUQQNGBEBBASEVIAsoAhBB1NDHAEEDENsHRQ0NCyADQQE2AuQCIANB8NDHADYC4AIgA0IBNwLsAiADIAtBEGqtQoCAgIAghDcD0AIgAyADQdACajYC6AIgA0H8AGoiASADQeACahCxBiABEJAHDAsLIANBATYC5AIgA0GQ0ccANgLgAiADQgE3AuwCIAMgC0EIaq1CgICAgCCENwPQAiADIANB0AJqNgLoAiADQfAAaiIBIANB4AJqELEGIAEQkAcMCgsgCygCACIBQfeVxwBBBxDbB0UNCiABQZjRxwBBBxDbByAOQQNHcg0IIAMoAhghAiADQYCAgIB4NgIYIAJBgICAgHhHBEAgAygCFCIBIAMoAgxGBEAgA0EMakGg0ccAEIMGCyADKAIQIAFBBXRqIgQgAjYCACAEIBIpAgA3AgQgBEEMaiASQQhq/QACAP0LAgAgBEEcaiATKAIANgIAIAMgAUEBajYCFAsgCygCECECIAsoAgwhDCALKAIIIQZBACEEAkACQAJAIAsoAhQiAQ4CCQABC0EBIQQgAi0AAEEraw4DCAEIAQsgAi0AAEErRgRAIAFBAWshBCACQQFqIQIgAUEKSQ0BDAcLIAEiBEEJTw0GC0EAIQEDQCACLQAAQTBrIgVBCUsEQEEBENEHDAsLIAJBAWohAiAFIAFBCmxqIQEgBEEBayIEDQALDAcLIAsoAgApAABC8OS9g9fMnLr5AFINByAOQQFGDQIgCygCDCIBQQRHDQEgCygCCCgAAEHs0s2jB0cNASADQQA2AvACIANBATYC5AIgA0Hg0ccANgLgAiADQgQ3AugCIANB4AJqEJUHDAgLIAsoAgBBrNLHAEEKENsHDQYgCEUNDQJAIAtBBGsoAgAiAUF4cSIEIAhBA3QiAkEEQQggAUEDcSIBG2pPBEAgAUEAIAQgAkEnaksbDQEgCxCiAgwPCwwWCwwWCyAOQQNHDQAgAygCGEGAgICAeEcNASADQQA2AvACIANBATYC5AIgA0GE0scANgLgAiADQgQ3AugCIANB4AJqEJUHDAYLIANBATYC5AIgA0Gk0scANgLgAiADQgE3AuwCIAMgA0HoAGqtQoCAgIAghDcD0AIgAyADQdACajYC6AIgA0GIAWoiASADQeACahCxBiABEJAHDAULIAMgCygCCCICNgLAAiADIAE2AsQCAn8CQAJAAkACQAJAAkACQAJAAkAgAUEDaw4EAwABAgcLIAIoAABB49CFkwdHDQNBACEEQQEMCAsgAkHU5ccAQQUQ2wdFBEBBASEEQQEMCAsgAkHZ5ccAQQUQ2wcNA0ECIQRBAgwHCyACQd7lxwBBBhDbBw0DQQMhBEECDAYLIAJB5OXHAEEDENsHDQNBBCEEQQQMBQsgAigAAEH10rmjB0cNAkEFIQRBBAwECyACQeflxwBBBRDbBw0BQQYhBEEEDAMLIAJB7OXHAEEGENsHRQ0BCyADIANBwAJqrUKAgICAIIQ3A8gCIANCATcC7AIgA0EBNgLkAiADQZTmxwA2AuACIAMgA0HIAmo2AugCIANB0AJqIgEgA0HgAmoQ7AMgARCQBwwGC0EHIQRBCAshASADIAEgAygCNCIFajYCNCALKAIUIgdBAE4EQCALKAIQIQECQCAHRQRAQQEhDAwBCyAHEHEiDEUNDgsgBwRAIAwgASAH/AoAAAsgAygCLCIGIAMoAiRGBEAjAEEgayIPJAACQCAQKAIAIglBs+bMGUsEf0EABUEEIAlBAXQiASABQQRNGyICQRRsIQEgDyAJBH8gDyAJQRRsNgIcIA8gECgCBDYCFEEEBUEACzYCGCAPQQhqQQQgASAPQRRqEIUHIA8oAghBAUcNASAPKAIQIRAgDygCDAsgEEHA5ccAEJMJAAsgDygCDCEBIBAgAjYCACAQIAE2AgQgD0EgaiQACyADKAIoIAZBFGxqIgEgBDoAECABIAU2AgwgASAHNgIIIAEgDDYCBCABIAc2AgAgAyAGQQFqNgIsDAYLQdiayAAQ/wcAC0EAIQEgBCEFA0AgBUUNAiACLQAAQTBrIglBCUsEQEEBENEHDAULQQIhBCABrUIKfiIdQiCIpw0BIAJBAWohAiAFQQFrIQUgCSAdp2oiASAJTw0ACwsgBBDRBwwCCyAMQQBOBEACQCAMRQRAQQEhAgwBCyAMEHEiAkUNCwsgDARAIAIgBiAM/AoAAAsgA0EANgI0IAMgATYCMCADQQA2AiwgA0KAgICAwAA3AiQgAyAMNgIgIAMgAjYCHCADIAw2AhgMAwtB2JrIABD/BwALIANBATYC5AIgA0Gw08cANgLgAiADQgE3AuwCIAMgA0HoAGqtQoCAgIAghDcD0AIgAyADQdACajYC6AIgA0GUAWoiASADQeACahCxBiABEJAHCyEBIABBgICAgHg2AqwBIAAgATYCACAIRQ0KIAsgCEEDdEEEEKIHDAoLAkAgCARAIAtBBGsoAgAiAUF4cSIEIAhBA3QiAkEEQQggAUEDcSIBG2pJDQ4gAUEAIAQgAkEnaksbDQEgCxCiAgsgAy0AXUUNBgwFCwwNCyACIQpBACEHIAILIQEgBSAGRg0ACyADKALgAiAORgRAIANB4AJqIA5BAUEEQQgQpAUgAygC5AIhEQsgESAOQQN0aiIBIAUgBms2AgQgASAGIBRqNgIAIAMgDkEBaiIONgLoAgwACwALCyADKAIYIQIgA0GAgICAeDYCGCACQYCAgIB4RwRAIAMoAhQiASADKAIMRgRAIANBDGpBuNLHABCDBgsgAygCECABQQV0aiIEIAI2AgAgBCASKQIANwIEIARBDGogEkEIav0AAgD9CwIAIARBHGogEkEYaigCADYCACADIAFBAWo2AhQLIBVBAXFFBEAgA0EANgJIIANBATYCPCADQeDSxwA2AjggA0IENwJAIANBOGoQlQchASAAQYCAgIB4NgKsASAAIAE2AgAMBQsCfwJAIAMoAhQiFkGTyaQSSQRAIAMoAhAhBCADKAIMIRoCQCAWRQRAQQAhFkEIIQlBACEIDAELIBZBOGwQcSIJRQ0EIAQgFkEFdGohFCADQThqrSEgQQAhCCAEIQIDQCADQdgCaiIPIAJBCGooAgA2AgAgAyACKQIANwPQAiACKAIUIQcgAigCECEBIAIoAgwhGyACKAIYIRIgAigCHCEMIAMCfkHAu8kALQAABEBB0LvJACkDACEeQci7yQApAwAMAQsgA0EAOgA4QQEQcSIKRQ0GIApBBGsoAgAiBkF4cSIFQQVBCSAGQQNxIg0bSQ0MIA1BACAFQSlPGw0NIAoQogJBwLvJAEEBOgAAQdC7yQAgCq0iHjcDACAgCyIdNwNIQci7yQAgHUIBfDcDACADIB43A1AgA0HwmsgA/QADAP0LAzgCQCAHRQ0AIAEgB0EUbGohECADQThqIAcgA0HIAGoiBxC7ASABIQUDQCAFLQAQIRwgBSgCDCELIAUoAgAhFSADKQNIIAMpA1AgBSgCBCIRIAUoAggiGBCVBCEdIAMoAkBFBEAgA0E4akEBIAcQuwELIAVBFGohBSADKAI8IhcgHadxIQ0gHUIZiCIhQv8Ag0KBgoSIkKDAgAF+IR5BACEOIAMoAjghCkEAIQYDQAJ/AkACQAJAIAogDWopAAAiHyAehSIdQn+FIB1CgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiHVBFBEADQCAKIB16p0EDdiANaiAXcUFsbGoiGUEMaygCACAYRgRAIBEgGUEQaygCACAYENsHRQ0DCyAdQgF9IB2DIh1QRQ0ACwsgH0KAgYKEiJCgwIB/gyEdIA5FBEAgHVANAyAdeqdBA3YgDWogF3EhEwtBASAdIB9CAYaDUA0DGiAKIBNqLAAAIg1BAE4EQCAKIAopAwBCgIGChIiQoMCAf4N6p0EDdiITai0AACENCyAKIBNqICGnQf8AcSIGOgAAIAogE0EIayAXcWpBCGogBjoAACAKIBNBbGxqIgpBFGsgFTYCACAKQRBrIBE2AgAgCkEMayAYNgIAIApBCGsgCzYCACAKQQRrIBw6AAAgAyADKAJEQQFqNgJEIAMgAygCQCANQQFxazYCQAwBCyAZQQRrIBw6AAAgGUEIayALNgIAIBVFDQAgEUEEaygCACIGQXhxIg1BBEEIIAZBA3EiChsgFWpJDREgCkEAIA0gFUEnaksbDRIgERCiAgsgBSAQRw0DDAQLQQALIQ4gBkEIaiIGIA1qIBdxIQ0MAAsACwALIBsEQCABQQRrKAIAIgVBeHEiCiAbQRRsIgZBBEEIIAVBA3EiBRtqSQ0MIAVBACAKIAZBJ2pLGw0NIAEQogILIANB8AJqIANByABq/QADACIi/QsDACADIAP9AAM4IiP9CwPgAiAJIAhBOGxqIgFBEGogIv0LAwAgASAj/QsDACABIAw2AiQgASASNgIgIAEgAykD0AI3AiggAUEwaiAPKAIANgIAIAhBAWohCCACQSBqIgIgFEcNAAsLAkAgGgRAIARBBGsoAgAiAUF4cSIFIBpBBXQiAkEEQQggAUEDcSIBG3JJDQsgAUEAIAUgAkEnaksbDQEgBBCiAgsgCUE4QQAgCBsiEGohBiAJIAhBOGwiBWohD0GAgICAeCESIAhFDQIgBiEEIAkhAQNAAkAgAUEwaigCAEEGRgRAIAFBLGooAgAiAkHo0scAQQYQ2wdFDQELIAQiASAPRiICDQQgAUEAQTggAhtqIQQgAQ0BDAQLC0EGIRJBBhBxIgRFDQQgBCACKAAANgAAIARBBGogAkEEai8AADsAACABKAIgIREgASgCJCEVIANBOGogARDDAyADQegCaiADQcQAav0AAgD9CwMAIANB+AJqIANB1ABqKAIANgIAIAMgAykCPDcD4AIgBK1CgICAgOAAhCEfIAMoAjghE0EADAMLDAoLQciVxwAQ/wcAC0EBCyADQQA2AkggA0EBNgI8IANBhNPHADYCOCADQgQ3AkAgA0E4ahCVByECBEAgAEGAgICAeDYCrAEgACACNgIAIAgEQCAJIQIDQCACQShqKAIAIgUEQCACQSxqKAIAIgRBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIAVqSQ0KIABBACABIAVBJ2pLGw0LIAQQogILIAIQvwQgAkE4aiECIAhBAWsiCA0ACwsgFkUNBiAJQQRrKAIAIgBBeHEiAiAWQThsIgFBBEEIIABBA3EiABtqSQ0HIABBACACIAFBJ2pLGw0IIAkQogIMBgsgA0G4AWogA0H4AmooAgA2AgAgA0GwAWogA0HwAmopAwA3AwAgAyAD/QAD4AL9CwOgASACIAIoAgAoAgARAwAgCEUNASAGIQQgCSEBAkADQAJAIAFBMGooAgBBBUYEQCABQSxqKAIAIgJBjNPHAEEFENsHRQ0BC0GAgICAeCEHIAQiASAPRiICDQIgAUEAQTggAhtqIQQgAQ0BDAILC0EFIQdBBRBxIgRFDQEgBCACKAAANgAAIARBBGogAkEEai0AADoAACABKAIgIQwgASgCJCEUIANBgAJqIAEQwwMgBK1CgICAgNAAhCEdCyAGIQQgCSEBA0ACQCAEIQICQAJAIAFBMGooAgBBAkYEQCABQSxqKAIAIgQvAABB89ABRg0BC0GAgICAeCEOIAIgD0YiAUUNAQwCC0ECIQ5BAhBxIgJFDQMgAiAELwAAOwAAIAEoAiQhDSABKAIgIQogA0GgAmogARDDAyACrUKAgICAIIQhHgwBCyACQQBBOCABG2ohBCACIgENAQsLIANB0AFqIANBkAJq/QADAP0LAwAgA0HwAWogA0GwAmr9AAMA/QsDACADIAP9AAOAAv0LA8ABIAMgA/0AA6AC/QsD4AEgECAFayEEIAkhAQNAIAYhAgJAIAFBMGooAgBBBUcNACABQSxqKAIAQYzTxwBBBRDbBw0AQQEMBAsgAkE4aiEGIAIhASAEQThqIgRBOEcNAAtBAAwCCwALIANB0AFqIANBkAJq/QADAP0LAwAgA0HwAWogA0GwAmr9AAMA/QsDACADIAP9AAOAAv0LA8ABIAMgA/0AA6AC/QsD4AFBgICAgHghDkGAgICAeCEHQQALIQEgACAD/QADwAH9CwMAIAAgHTcCLCAAIAc2AiggACAUNgIkIAAgDDYCICAAIAP9AAPgAf0LAzggACAKNgJYIAAgDTYCXCAAIA42AmAgACAeNwJkIAAgEzYCcCAAQRBqIANB0AFq/QADAP0LAwAgAEHIAGogA0HwAWr9AAMA/QsDACAAIAg2ArQBIAAgCTYCsAEgACAWNgKsASAAIBE2AqgBIAAgHzcCnAEgACASNgKYASAAIBU2ApQBIAAgETYCkAEgACABOgC4ASAAQYwBaiADQbgBaigCADYCACAAQYQBaiADQbABaikDADcCACAAIAP9AAOgAf0LAnQMAgsgAygCGCIAQYCAgIB4Rg0AIAAEQCADKAIcIABBARCiBwsgAygCKCEAIAMoAiwiAQRAIAAhAgNAIAIoAgAiCQRAIAJBBGooAgAiBkEEaygCACIEQXhxIgVBBEEIIARBA3EiBBsgCWpJDQUgBEEAIAUgCUEnaksbDQYgBhCiAgsgAkEUaiECIAFBAWsiAQ0ACwsgAygCJCIBRQ0AIAAgAUEUbEEEEKIHCyADKAIQIQcgAygCFCIJBEBBACEMA0AgByAMQQV0aiIQKAIAIgQEQCAQKAIEIgJBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIARqSQ0EIABBACABIARBJ2pLGw0FIAIQogILIBAoAhAhACAQKAIUIgEEQCAAIQIDQCACKAIAIgoEQCACQQRqKAIAIgZBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIApqSQ0GIARBACAFIApBJ2pLGw0HIAYQogILIAJBFGohAiABQQFrIgENAAsLIBAoAgwiAgRAIABBBGsoAgAiAUF4cSIEIAJBFGwiAkEEQQggAUEDcSIBG2pJDQQgAUEAIAQgAkEnaksbDQUgABCiAgsgDEEBaiIMIAlHDQALCyADKAIMIgFFDQAgB0EEaygCACIAQXhxIgIgAUEFdCIBQQRBCCAAQQNxIgAbckkNASAAQQAgAiABQSdqSxsNAiAHEKICCyADQYADaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALgDoCHn8EeyMAQSBrIg4kAAJAAkACQCADQf//A3EiAyIQQQEgBXRqQQFrIAV2IhpB//8DTQRAIAJBA0sEQCABIAEtAANBAWs6AAMgAiAQQQJ0IgxPBEAgA0ECSQ0EQQQhDSACIAxBBWsiAyACIANJG0EBaiIDQQRNDQMgAyADQQNxIgNBBCADG2siCUEEaiENIAEhAwNAIANBBGoiCCAD/VwAACAI/VwAAP1u/VoAAAAgCCEDIAlBBGsiCQ0ACwwDC0Go2cQAQS9B6NnEABDrBwALQQMgAkHo2MQAEIwHAAtB2ObIAEErIA5BH2pB2NjEAEGo+8YAEOAGAAsgDUEEayEDQQAgEEECdGshCANAIAIgA0YNAiABIANqIhNBBGoiCiATLQAAIAotAABqOgAAIAggA0EBaiIDakF8Rw0ACwsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAEQf//A3EiIEECSQ0AIAVBH3EhGyAgQQFrIQUgASAMaiEKQQAhAwNAIAMgDGoiBCACTw08IAIgA00NQCADIApqIgggASADaiITLQAAIAgtAABqOgAAIARBAWogAk8NOyADQQFqIAJPDT8gCEEBaiIYIBNBAWotAAAgGC0AAGo6AAAgBEECaiACTw06IANBAmogAk8NPiAIQQJqIhggE0ECai0AACAYLQAAajoAACAEQQNqIAJPDTkgA0EDaiACTw09IAhBA2oiAyATQQNqLQAAIAMtAABqOgAAIAQhAyAFQQFrIgUNAAsgGkUNACABQQRrIRwgDEEEayEVIAxBBGohFCABQQFqIRYgAUEDayEkIAEgEEECdCIDayEXQQAgA2shESABIAxrIgNBBWohISABQQQgDGsiGWohIiADQQFqIR0gA0EDayEeIAFBfCAMayISaiEfIBAhBUEBIQMDQCADIBBsISMgA0EBaiADIBt2IBpsISVBACETA0AgEyIDICVqQQJ0QQFyIgggB08NAyADQQFqIhMgG3QiBCAQIAQgEEkbIg0gI2pBAnQhBEEBIAMgG3QiAyADQQFNGyIPICNqQQJ0IQMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBiAIai0AAA4ODQwLCgkIBwYFBAMCAQAOCyACIARJDUEgAyAESw1CIANBBGshCiADRQ1DIAMgAyAMayINQQRrIglJDUQgBCADayIIIAMgCWtLDUUgAyAMSQ1GIAggDEsNRyADIARGDQ0gASAKaigAACIDQRB2/REgA0EYdv0cASAm/Q0AAAAEAAAAAAAAAAAAAAAAIAP9FwAgA0EIdv0XASEmIAhBAnYhBCABIAUgD2pBAnRqIQMDQCADIAP9XAAAIAMgEmoiCEEEav1cAAAiJyAm/U4gJyAm/VFBAf1t/W79iQEiKCAI/VwAAP2JAf2RASIn/RgAQQJt/RAgJ/0YAUECbf0aASAn/RgCQQJt/RoCICf9GANBAm39GgMgKP2OAf0MAAAAAAAAAAAAAAAAAAAAAP2YAf0M/wD/AP8A/wD/AP8A/wD/AP2WASAn/Q0AAgQGAAAAAAAAAAAAAAAA/W4iJv0WA0EYdCAm/RYCQRB0ciAm/RYBQQh0ciAm/RYAcjYAACADQQRqIQMgBEEBayIEDQALDA0LIAIgBEkNOyADIARLDTwgA0EEayEIIANFDT0gAyADIAxrIglBBGsiCkkNPiADIAxJDT8gECADIAprQQJ2IgogBCADa0ECdiIDIAMgCksbIgMgAyAQSxsiBEUNDCABIAhqKAAAIgNBEHb9ESADQRh2/RwBICb9DQAAAAQAAAAAAAAAAAAAAAAgA/0XACADQQh2/RcBISYgASAFIA9qQQJ0aiEDA0AgAyAD/VwAACADIBJqIghBBGr9XAAA/YkBICb9iQH9jgEgCP1cAAD9iQH9kQH9DAAAAAAAAAAAAAAAAAAAAAD9mAH9DP8A/wD/AP8A/wD/AP8A/wD9lgEgJv0NAAIEBgAAAAAAAAAAAAAAAP1uIib9FgNBGHQgJv0WAkEQdHIgJv0WAUEIdHIgJv0WAHI2AAAgA0EEaiEDIARBAWsiBA0ACwwMCyACIARJDTIgAyAESw0zIAMgDGshCCADIAxJDTQgA0EEayEKIANFDTUgCEEEayIJIANPDTYgCEEDayINIANPDTcgCEECayILIANPDTggCEEBayIIIANPDTkgECAEIANrQQJ2IgMgAyAQSxsiBEUNCyABIApq/VwAACEmIAEgCWotAAD9DyABIA1qLQAA/RcBIAEgC2ovAAD9EP0NAAEQEQAAAAAAAAAAAAAAACEnIAEgBSAPakECdGohAwNAIAMgJiADIBFq/VwAACIoICggJ/15ICggJ/13/XH9iQEiKSApICb9DQQFBgcAAQABAAEAAQABAAH9jgEiKSApICb9DQIDAAEAAQABAAEAAQABAAH9jgH9GQBB/wdxICYgJ/15ICYgJ/13/XH9iQEiKf0ZASAp/RkAaiAm/YkBICf9iQH9kQEiJ/0ZAiAn/RgCQQ91IghzIAhraiAn/RgDQQ91IgggJ/0ZA3MgCGtqQf//A3FJ/Q9BB/1rQQf9bP1SIAP9XAAA/W4iJv0WAUEIdCAm/RYAciAm/RYDQRh0ICb9FgJBEHRycjYAACADQQRqIQMgKCEnIARBAWsiBA0ACwwLCyACIARJDSsgAyAESw0sIANBBGshCCADRQ0tIAMgAyAMayIKQQRrIglJDS4gAyAMSQ0vIAMgCkEEaiIKSQ0wIAMgCmtBAnYiCiAQIAMgCWtBAnYiCSAEIANrQQJ2IgMgAyAJSxsiAyADIBBLGyIDIAMgCksbIglFDQogASAIaigAACIDQRB2/REgA0EYdv0cASAm/Q0AAAAEAAAAAAAAAAAAAAAAIAP9FwAgA0EIdv0XASEmIAEgBSAPakECdGohAwNAIAMgA/1cAAAgAyASaiIEQQhq/VwAACInIARBBGr9XAAAIij9TiAnICj9UUEB/W39biInIAT9XAAAIiggJv1OICggJv1RQQH9bf1uIij9TiAnICj9UUEB/W39bv1uIib9FgNBGHQgJv0WAkEQdHIgJv0WAUEIdHIgJv0WAHI2AAAgA0EEaiEDIAlBAWsiCQ0ACwwKCyACIARJDScgAyAETw0JAkAgD0ECdEF/cyANQQJ0aiIEIBUgAiADIAxrQQRqIgggAiAISxtqIANrIgogDCACIAMgEWoiCCACIAhLG2ogA2siCCAIIApLGyIKIAQgCkkbQQFqIgpBEUkNACABIANqIgkgHSAEIBUgAiADIBlqIgsgAiALSxtqIANrIgsgCCAIIAtLGyIIIAQgCEkbIANqIghqSSAIIBZqIgsgAyAXaktxIAkgCCAhakkgAyAiaiALSXFyDQAgCkEPcSIIQRAgCBsiCyAEIBUgAiAZIAUgD2pBAnQiCGoiCSACIAlLG2ogCGsiCSAEIAlJGyIEIAwgAiAIIBFqIgkgAiAJSxtqIAhrIgkgBCAJSRtBf3NqIQkgASAIaiEEIAMgCiALa2ohAwNAIAQgBP0AAAAgBCARaiIIQQRq/QAAACImIAj9AAAAIif9TiAmICf9UUEB/W39bv1u/QsAACAEQRBqIQQgCUEQaiIJDQALCyADIBFqIQQgAyAFIA1qQQJ0ayEJA0AgAiAETQ0pIARBBGoiCCACTw0qIAEgA2oiCCAILQAAIAEgBGoiCEEEai0AACAILQAAakEBdmo6AAAgBEEBaiEEIANBAWohAyAJQQFqIgkNAAsMCQsgAiAESQ0jIAMgBE8NCAJAIA9BAnRBf3MgDUECdGoiBCAUIAIgAyAMa0EEayIIIAIgCEsbaiADayIKIAwgAiADIBFqIgggAiAISxtqIANrIgggCCAKSxsiCiAEIApJG0EBaiIKQRFJDQAgASADaiIJIB4gBCAUIAIgAyASaiILIAIgC0sbaiADayILIAggCCALSxsiCCAEIAhJGyADaiIIakkgCCAWaiILIAMgH2pLcSAJIAggHWpJIAMgF2ogC0lxcg0AIApBD3EiCEEQIAgbIgsgBCAUIAIgEiAFIA9qQQJ0IghqIgkgAiAJSxtqIAhrIgkgBCAJSRsiBCAMIAIgCCARaiIJIAIgCUsbaiAIayIJIAQgCUkbQX9zaiEJIAEgCGohBCADIAogC2tqIQMDQCAEIAT9AAAAIAQgEmoiCEEEav0AAAAiJiAI/QAAACIn/U4gJiAn/VFBAf1t/W79bv0LAAAgBEEQaiEEIAlBEGoiCQ0ACwsgAyASaiEEIAMgBSANakECdGshCQNAIAIgBE0NJSAEQQRqIgggAk8NJiABIANqIgggCC0AACABIARqIghBBGotAAAgCC0AAGpBAXZqOgAAIARBAWohBCADQQFqIQMgCUEBaiIJDQALDAgLIAIgBEkNHSADIARLDR4gA0EEayEIIANFDR8gAyAMayENIAMgDEkNICAEIANrIgQgDEsNISABIAhqKAAAIghBEHb9ESAIQRh2/RwBICb9DQAAAAQAAAAAAAAAAAAAAAAgCP0XACAIQQh2/RcBISYgBEFAcSIKBEAgASADaiEJIAEgDWohDSAKIQgDQEEAIQMDQCADIAlqIgsgAyANav1cAAAiJyAm/U4gC/1cAAD9biAnICb9UUEB/W39biIm/RYDQRh0ICb9FgJBEHRyICb9FgFBCHRyICb9FgByNgAAIANBBGoiA0HAAEcNAAsgDUFAayENIAlBQGshCSAIQUBqIggNAAsLIARBAnZBD3EiA0UNByADQQJ0IQQgASAKIAUgD2pBAnRqaiEDA0AgAyADIBFq/VwAACInICb9TiAD/VwAAP1uICcgJv1RQQH9bf1uIib9FgNBGHQgJv0WAkEQdHIgJv0WAUEIdHIgJv0WAHI2AAAgA0EEaiEDIARBBGsiBA0ACwwHCyACIARJDRkgAyAETw0GAkAgD0ECdEF/cyANQQJ0aiIEIBQgAiADIAxrQQRrIgggAiAISxtqIANrIgogAiADQQRrIgggAiAISxsgA2tBBGoiCCAIIApLGyIKIAQgCkkbQQFqIgpBDUkNACABIANqIgkgJCAEIBQgAiADIBJqIgsgAiALSxtqIANrIgsgCCAIIAtLGyIIIAQgCEkbIANqIghqSSAIIBZqIgsgAyAcaktxIAkgCCAeakkgAyAfaiALSXFyDQAgCkEDcSIIQQQgCBsiCyAEIBQgAiASIAUgD2pBAnQiCGoiCSACIAlLG2ogCGsiCSAEIAlJGyIEIAIgCEEEayIJIAIgCUsbIAhrQQRqIgkgBCAJSRtBf3NqIQkgCCAcaiEEIAMgCiALa2ohAwNAIAQgEWohCCAE/VwAACEmIARBBGoiBCAE/VwAACAmIAj9XAAAIif9TiAnICb9UUEB/W39bv1u/VoAAAAgCUEEaiIJDQALCyADQQRrIQQgAyASaiEJIAMgBSANakECdGshAwNAIAIgBE0NGyACIAlNDRwgASAEaiIIQQRqIgogCi0AACABIAlqLQAAIAgtAABqQQF2ajoAACAEQQFqIQQgCUEBaiEJIANBAWoiAw0ACwwGCyACIARJDRMgAyAESw0UIANBBGshCCADRQ0VIAMgAyAMayIJQQRqIgpJDRYgAyAMSQ0XIBAgAyAKa0ECdiIKIAQgA2tBAnYiAyADIApLGyIDIAMgEEsbIgRFDQUgASAIaigAACIDQRB2/REgA0EYdv0cASAm/Q0AAAAEAAAAAAAAAAAAAAAAIAP9FwAgA0EIdv0XASEmIAEgBSAPakECdGohAwNAIAMgAyARaiIIQQRq/VwAACInICb9TiAnICb9UUEB/W39biInIAj9XAAAIij9TiAD/VwAAP1uICcgKP1RQQH9bf1uIib9FgNBGHQgJv0WAkEQdHIgJv0WAUEIdHIgJv0WAHI2AAAgA0EEaiEDIARBAWsiBA0ACwwFCyACIARJDRAgAyAETw0EAkAgD0ECdEF/cyANQQJ0aiIEIBQgAiADIAxrQQRrIgggAiAISxtqIANrIgggBCAISRtBAWoiCEERSQ0AIAEgA2ogHiAEIBQgAiADIBJqIgogAiAKSxtqIANrIgogBCAKSRsgA2oiCmpJIAMgH2ogCiAWaklxDQAgCEEPcSIKQRAgChsiCyAEIBQgAiASIAUgD2pBAnQiCmoiCSACIAlLG2ogCmsiCSAEIAlJG0F/c2ohCSABIApqIQQgAyAIIAtraiEDA0AgBCAEIBJq/QAAACAE/QAAAP1u/QsAACAEQRBqIQQgCUEQaiIJDQALCyAFIA1qQQJ0IQQDQCADIBFqQQRrIgggAk8NEiABIANqIgggAyAXakEEay0AACAILQAAajoAACAEIANBAWoiA0cNAAsMBAsgAiAESQ0NIAMgBE8NAwJAIA9BAnRBf3MgDUECdGoiBCAVIAIgAyAMa0EEaiIIIAIgCEsbaiADayIIIAQgCEkbQQFqIghBEUkNACABIANqICEgBCAVIAIgAyAZaiIKIAIgCksbaiADayIKIAQgCkkbIANqIgpqSSADICJqIAogFmpJcQ0AIAhBD3EiCkEQIAobIgsgBCAVIAIgGSAFIA9qQQJ0IgpqIgkgAiAJSxtqIAprIgkgBCAJSRtBf3NqIQkgASAKaiEEIAMgCCALa2ohAwNAIAQgBCAZav0AAAAgBP0AAAD9bv0LAAAgBEEQaiEEIAlBEGoiCQ0ACwsgBSANakECdCEEA0AgAyARakEEaiIIIAJPDQ8gASADaiIIIAMgF2pBBGotAAAgCC0AAGo6AAAgBCADQQFqIgNHDQALDAMLIAIgBEkNCiADIARPDQICQCAPQQJ0QX9zIA1BAnRqIgQgDCACIAMgEWoiCCACIAhLG2ogA2siCCAEIAhJGyIKQQFqIghBEUkNACABIANqIB0gAyAKaiIKakkgAyAXaiAKIBZqSXENACAIQQ9xIgpBECAKGyILIAQgDCACIBEgBSAPakECdCIKaiIJIAIgCUsbaiAKayIJIAQgCUkbQX9zaiEJIAEgCmohBCADIAggC2tqIQMDQCAEIAQgEWr9AAAAIAT9AAAA/W79CwAAIARBEGohBCAJQRBqIgkNAAsLIAUgDWpBAnQhBANAIAMgEWoiCCACTw0MIAEgA2oiCCADIBdqLQAAIAgtAABqOgAAIAQgA0EBaiIDRw0ACwwCCyACIARJDQcgAyAETw0BIA9BAnRBf3MgDUECdGoiBCACIANBBGsiCCACIAhLGyADa0EEaiIIIAQgCEkbQQFqIgpBBU8EQCAKQQNxIghBBCAIGyILIAQgAiAFIA9qQQJ0IglBBGsiCCACIAhLGyAJa0EEaiIIIAQgCEkbQX9zaiEIIAkgHGohBCADIAogC2tqIQMDQCAEQQRqIgogBP1cAAAgCv1cAAD9bv1aAAAAIAohBCAIQQRqIggNAAsLIAUgDWpBAnQhCANAIANBBGsiBCACTw0JIAEgA2oiBCAEQQRrLQAAIAQtAABqOgAAIAggA0EBaiIDRw0ACwwBCyACIARJDQUgA0EDciIJIARPDQAgBCADQQdqIgggBCAISxsgA2tBBGsiA0HAAE8EQCAJIANBAnZBAWoiAyADQQ9xIgNBECADGyIDa0ECdGohCSADIAUgDWpBAnQiCCAFIA9qQQJ0IgNBB2oiCiAIIApLGyADa0EEa0ECdkF/c2ohDSABIANqIQMDQCADQT9qIANBA2oiCP0AAAAgA0ETaiIK/QAAAP0NAAQIDBAUGBwAAAAAAAAAACADQSNqIg/9AAAAIANBM2oiC/0AAAD9DQAAAAAAAAAAAAQIDBAUGBz9DQABAgMEBQYHGBkaGxwdHh/9DP/////////////////////9biIm/VgAAA8gA0E7aiAm/VgAAA4gA0E3aiAm/VgAAA0gCyAm/VgAAAwgA0EvaiAm/VgAAAsgA0EraiAm/VgAAAogA0EnaiAm/VgAAAkgDyAm/VgAAAggA0EfaiAm/VgAAAcgA0EbaiAm/VgAAAYgA0EXaiAm/VgAAAUgCiAm/VgAAAQgA0EPaiAm/VgAAAMgA0ELaiAm/VgAAAIgA0EHaiAm/VgAAAEgCCAm/VgAAAAgA0FAayEDIA1BEGoiDQ0ACwsDQCABIAlqIgMgAy0AAEEBazoAACAJQQRqIgkgBEkNAAsLIBMgGkcNAAsgBSAQaiEFIgMgIEcNAAsLIABBHToAACAOQSBqJAAPCyAIIAdB+NjEABCMBwALQajZxABBL0HY2cQAEOsHAAtBqNnEAEEvQejZxAAQ6wcACyAEIAJB+NnEABCMBwALQajZxABBL0GI2sQAEOsHAAsgCCACQZjaxAAQjAcAC0Go2cQAQS9BqNrEABDrBwALIAggAkG42sQAEIwHAAtBqNnEAEEvQcjaxAAQ6wcACyAIIAJB2NrEABCMBwALQQAgBCACQbjbxAAQ6gcACyAOQQA2AhQgDkEBNgIIIA5BiILIADYCBCAOQgQ3AgwgDkEEakHo2sQAEI0IAAsgCEEAQQBBqNvEABDqBwALIAogAyADQYjbxAAQ6gcACyAJIAMgA0H42sQAEOoHAAtBqNnEAEEvQcjbxAAQ6wcACyAEIAJB2NvEABCMBwALIAkgAkHo28QAEIwHAAtBACAEIAJBuNzEABDqBwALIA5BADYCFCAOQQE2AgggDkGIgsgANgIEIA5CBDcCDCAOQQRqQfjbxAAQjQgACyAIQQBBAEGo3MQAEOoHAAsgDSADIANBmNzEABDqBwALQQAgBCAMQYjcxAAQ6gcAC0Go2cQAQS9ByNzEABDrBwALIAQgAkHY3MQAEIwHAAsgCCACQejcxAAQjAcAC0Go2cQAQS9B+NzEABDrBwALIAQgAkGI3cQAEIwHAAsgCCACQZjdxAAQjAcAC0EAIAQgAkH43cQAEOoHAAsgDkEANgIUIA5BATYCCCAOQYiCyAA2AgQgDkIENwIMIA5BBGpBqN3EABCNCAALIAhBAEEAQejdxAAQ6gcACyAJIAMgA0HY3cQAEOoHAAsgCiADIANByN3EABDqBwALIAogAyADQbjdxAAQ6gcAC0EAIAQgAkH43sQAEOoHAAsgDkEANgIUIA5BATYCCCAOQYiCyAA2AgQgDkIENwIMIA5BBGpBiN7EABCNCAALIAggAyADQejexAAQ6gcACyAKQQBBmN7EABCMBwALIAkgA0Go3sQAEIwHAAsgDSADQbjexAAQjAcACyALIANByN7EABCMBwALIAggA0HY3sQAEIwHAAtBACAEIAJByN/EABDqBwALIA5BADYCFCAOQQE2AgggDkGIgsgANgIEIA5CBDcCDCAOQQRqQYjfxAAQjQgACyAIQQBBAEG438QAEOoHAAsgCiADIANBqN/EABDqBwALIAkgAyADQZjfxAAQ6gcAC0EAIAQgAkG44MQAEOoHAAsgDkEANgIUIA5BATYCCCAOQYiCyAA2AgQgDkIENwIMIA5BBGpB2N/EABCNCAALIApBAEEAQajgxAAQ6gcACyAJIAMgA0GY4MQAEOoHAAtBACAIIAxBBGpBiODEABDqBwALIA0gAyADQfjfxAAQ6gcAC0EAIAggDEHo38QAEOoHAAsgBEEDaiEEDAILIARBAmohBAwBCyAEQQFqIQQLIAQgAkGI2cQAEIwHAAsgA0EDaiEDDAILIANBAmohAwwBCyADQQFqIQMLIAMgAkGY2cQAEIwHAAsgAyACQfjZxAAQjAcAC+BZAyd/EH4HeyMAQfAIayIEJAAgBEEQaiABQaAB/AoAACAEQgA3A6gCIAQgBCgCmAEiC60gBCgClAEiCK1+Ii5CBEIDIAQtAKMBIgcbEN0GIAQgA60iKzcDsAIgBEIANwPoAiAEQn8gBCkDACAEKQMIQgBSGyIsNwPwAgJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkAgKyAsUQRAQQkhBSAuQiCIpw0NIC6nIg6tQgRCAyAHG34iK0IgiKcgAyArp0dyDQ0gBC0AVUEBRwRAAkAgBEHoAGoiDUHM+MYAEKgEIgVFBEAgDUHk+MYAEKgEIQdBAyEFIARBAzoAsAMgB0UNECAEQbADaiIFEKsEIAQgBEHYAGoiCDYCiAIgBykDECErIAQgBykDCCIuNwNgIAQgKyAufSIrNwOAAiAEICs3A/gBIAUgBEH4AWoQrAIgBEHoAmogBRA0IAQpAvQCIS4gBCgC8AIhCSAEKALsAiEFIAQoAugCIgdBgICAgHhHDQEgBUEIdiEGDA8LIARBBDoAsAMgBSkDECEuIAUpAwghKyAEQQA6AJAEIAQgBEHYAGo2AogEIARCADcD8AMgBCArNwNgIARCADcDoAQgBEKAgICAEDcDmAQgBEEEOgDgAyAEQQQ6ANADIARBBDoAwAMgBCAuICt9Iis3A4AEIAQgKzcD+AMgB0UEQCAOQQJ0IgZBAEgNBAJAIAYEQCAGEHEiB0UNFCAHQQRrLQAAQQNxRSAGRXJFBEAgB0EAIAb8CwALIARB6AJqIARBsANqIAQoApQBIAQoApgBIAcgBhDNASAELQDoAiIFQR1GDQEgBCkC8AIhLiAEKALsAiEJIAQvAOkCIAQtAOsCIAcgBkEBEKIHQRB0ciEGDBALQQEhByAEQegCaiAEQbADaiAIIAtBAUEAEM0BIAQtAOgCIgVBHUcNDQsCQCADQQNuIgMgDkH/////A3EiBSADIAVJGyIDRQ0AQQAhCCADQQFHBEAgA0EBcSADQf7///8DcSELIAIhAyAHIQUDQCADIAUvAAA7AAAgA0ECaiAFQQJqLQAAOgAAIANBA2ogBUEEai8AADsAACADQQVqIAVBBmotAAA6AAAgA0EGaiEDIAVBCGohBSALIAhBAmoiCEcNAAtFDQELIAIgCEEDbGoiAiAHIAhBAnRqIgMvAAA7AAAgAkECaiADQQJqLQAAOgAACyAGRQ0KIAcgBkEBEKIHDAoLIARB6AJqIARBsANqIAggCyACIAMQzQEgBC0A6AIiBUEdRg0JIAQvAOkCIAQtAOsCQRB0cgwMCyAEQdQCaiAEQZQDaigCADYCACAEQcwCaiAEQYwDaikCACIrNwIAIAQgBP0AAvwC/QsCvAIgBCAJNgKwAiAEIAU2AqwCIAQgBzYCqAIgBCgClAEhCSAEIC43ArQCQRchCyAJICunIg9B//8DcSIGRw0HIAQvAc4CIhAgBCgCmAFHDQcgBC0ApAEhCSAELQCjAUUEQCAEQagCaiACIAMgCUEBcRCOAQwHCyAEQagCaiACIAMgCUEBcRCAASANQen4xgAQqAQhCUEDIQsgBEEDOgCwAyAJRQ0HIARBsANqIgsQqwQgCSkDECErIAQgCSkDCCItNwNgIAQgCDYCwAMgBCArIC19Iis3A7gDIAQgKzcDsAMgBEHoAmogCyAEKAKUASAEKAKYARBHIAQoAvQCIQ4gBCgC8AIhCSAEKALsAiELIAQoAugCRQRAAkACQCAQRSAPQf//A3FFckUEQCAELQD5AiEHIAZBAnQhD0EDIQ0DQCAJIBxqIREgDSEIQQAhBQNAIAUgCiAGIAcgAiADELwDIRogBSAcaiIVIA5PDQMgAyAITQ0EIAIgCGogBSARai0AACAaajoAACAIQQRqIQggBiAFQQFqIgVHDQALIA0gD2ohDSAGIBxqIRwgCkEBaiIKIBBHDQALCyALRQ0JIAkgC0EBEKIHDAkLIBUgDkHw+MYAEIwHAAsgCCADQYD5xgAQjAcACyAOrSAEMQD4AkIghoQgBDEA+QJCKIaEIAQzAfoCQjCGhCErIAtBCHYhBgwHCyAEQTRqQQA2AgAgBEHQAWogAUEgav0AAwD9CwMAIARBwAFqIAFBEGr9AAMA/QsDACAEQYCAgIB4NgIYIARCADcDECAE/QwAAAAAAAAAAAAAAAAAAAAA/QsCJCAEQQE6ADggBCAB/QADAP0LA7ABIARB6ABqQZD5xgAQqAQiBUUNAiAEIAUpAwgiLEIIfSIuNwMQIAQoApwBRQRAIARBHDoA4AEMBQsgBCAuNwNgQQQhBSAEKAJcIgetISsgBAJ+AkAgB0L/////DyAuIC5C/////w9aG6drIgZBACAGIAdNG0EETwRAIAQoAlggLiArICsgLlYbp2ooAAAhCQwBC0GokMgAKQMAIi5CCIghLSAupyEFICsgLkL/AYNCBFINARoLICxCBH0LIiw3A2ACQCAFQf8BcUEERgRAIARBsANqQQFyIAkQmAQgBC0AswMhCSAELwCxAyEGIAQCfgJAIAcgLCArICsgLFYbpyIFa0EETwRAIAQoAlggBWo1AAAhLkEEIQVCACEtDAELQaiQyAApAwAiMEIIiCEtIDCnIQVCACEuICsgMEL/AYNCBFINARoLICxCBHwLIiw3A2AgBUH/AXFBBEYNAQsgBEEANgLgASAEIC1CGIg+AugBIAQgBUH/AXEgLadBCHRyNgLkAQwFCyAGIAlBEHRyQf8BcUEGRiAuQh9WcUUEQCAEQcGctbIENgDhASAEQQQ6AOABDAULIAQCfgJAIAcgLCArICsgLFYbpyIFa0EDTwRAIAQoAlggBWoiBS0AAUEIdCEJIAUtAAJBEHQhBiAFLQAAIQpBBCEFQgAhLQwBC0GokMgAKQMAIjBCCIghLSAwpyEFQQAhCUEAIQZBACELICsgMEL/AYNCBFINARoLIAkhCyAGIRwgLEIDfAsiLDcDYCAFQf8BcUEERwRAIAQgBa1C/wGDIC1CCIaEIis3A7ADIARBADoA4AEgBCArPgLkASAEIAQpArQDNwPoAQwFCwJ/AkAgByAsICsgKyAsVhunIgVrQQNPBEAgBCgCWCAFaiIFLQABQQh0IQggBS0AAkEQdCEJIAUtAAAhDUEEIQVCACEtDAELQaiQyAApAwAiMEIIiCEtIDCnIQVBACEIQQAhCUEAIQZBACAwQv8Bg0IEUg0BGgsgLEIDfCErIAghBiAJCyEJIAQgKzcDYCAFQf8BcUEERwRAIAQgBa1C/wGDIC1CCIaEIis3A7ADIARBADoA4AEgBCArPgLkASAEIAQpArQDNwPoAQwFCyAEQbADaiAEQdgAaiIFEL4FIAQtALADIgdBHUcEQCAEIAQtALMDOgDjASAEIAQvALEDOwDhASAEIAQpArgDNwPoASAEIAQoArQDNgLkASAEIAc6AOABDAULIAQoArQDIQcgBEGwA2ogBRC+BSAELQCwAyIIQR1HBEAgBCAELQCzAzoA4wEgBCAELwCxAzsA4QEgBCAEKQK4AzcD6AEgBCAEKAK0AzYC5AEgBCAIOgDgAQwFCwJAIAdBAWoiFUGAgAFNBEAgBCgCtANBAWoiGkGBgAFJDQELIARBCToA4AEMBQsCQCAEKAKUASAVIAogC3IgHHJBAXQiH2pJDQAgBCgCmAEgGiAGIA1yIAlyQQF0IiBqSQ0AIARBsANqIAUQvgUgBC0AsAMiCUEdRwRAIAQgBC0AswM6AOMBIAQgBC8AsQM7AOEBIAQgBCkCuAM3A+gBIAQgBCgCtAM2AuQBIAQgCToA4AEMBgsgBCgCtAMhKCAEQbADaiAFEKkGIAQtALADQQRGBEAgBC0AsQMhHAwFCyAEKQOwAyIrQgiIpyEcICunIglB/wFxQQRGDQQgBCAcOgDlASAEIAk6AOQBIARBADoA4AEgBCArQjCIPQHqASAEICtCEIg+AeYBDAULIARBCjoA4AEMBAsgBEEANgKwAyAEQagCaiAEQegCaiAEQbADakHYpsYAEPcHAAtB1PjGABD/BwALQZj5xgAQ3QkMDAsgBCgATSEOIAQtAEwhEiAELQA4IRcgBEGwA2ogBRC9AyAEKAKwA0EBRgRAIAQgBP0AArQD/QsE4AEMAQsgBCAELQDEAzoA5AggBCAEKALAAyIJNgLgCAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgLiAEKQPIAyItQhh8WgRAIAQpA7gDIStB0pKZsgQhCyAJQf8BcUEBaw4LAQoLAgMEDAUGBwgJC0HSkpmyBCEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAlB/wFxQQFrDgsAAQIDBAUGBwgJCgsLQdeKiYIFIQMMCgtB1qDhgQIhAwwJC0HWoOHhBCEDDAgLQdag4cEFIQMMBwtBwZyl6gQhAwwGC0HBnLWyBCEDDAULQcGYwcIEIQMMBAtByYaNggUhAwwDC0HFsKWyBCEDDAILQdiawYICIQMMAQsgBCgA4QghAwsgBCADNgDhASAEQQQ6AOABDA4LQdeKiYIFIQsMBwtB1qDhwQUhCwwGC0HBnKXqBCELDAULQcGctbIEIQsMBAtByYaNggUhCwwDC0HFsKWyBCELDAILQdiawYICIQsMAQsgBCgA4QghCwsgBCALNgDhASAEQQQ6AOABDAULIAQgKzcDoAMgBCArNwOYAyAEIAU2AqgDIARBsANqIgUgBEGYA2oQrAIgBEHoAmogBRA0IAQgBP0AAuwC/QsDkAIgBCgC6AIiBUGAgICAeEYNAyAEQdQCaiAEQZQDaigCADYCACAEQcwCaiAEQYwDaikCACIrNwIAIAQgBP0AAvwC/QsCvAIgBCAE/QADkAL9CwKsAiAEIAU2AqgCAkAgFSArp0H//wNxRw0AIBogBC8BzgJHDQAgBEHYAmogFSAabEEDbEHk9sYAEKAHIARBqAJqIgUgBCgC3AIiCyAEKALgAiINIAQtAKQBEI4BIAQoAtgCIScgBRD9BEEAIQoMAwsgBEEXOgDgASAEQagCahD9BAwECyAEQQA6AJAEIAQgBTYCiAQgBCArNwOABCAEICs3A/gDIARCADcD8AMgBEIANwOgBCAEQoCAgIAQNwOYBCAEQQQ6AOADIARBBDoA0AMgBEEEOgDAAyAEQQQ6ALADIARBqAJqIBUgGmxBAnRB9PbGABCgByAEQegCaiAEQbADaiAVIBogBCgCrAIiCyAEKAKwAiINEM0BIAQtAOgCIgVBHUcEQCAEIAQpAOkCNwDhASAEIARB8AJqKQAANwDoASAEIAU6AOABIAQoAqgCIgIEQCALIAJBARCiBwsgBEGwA2oQ/AYMBAsgBCgCqAIhJyAEQbADahD8BkEBIQoMAQsgLiAtQiB8WgRAIAQpA2AhLCAEICs3A5gCIAQgKzcDkAIgBCAFNgKgAiAEQbADaiAEQZACaiAVIBoQRyAEKAKwA0EBRgRAIAQgBP0AArQD/QsE4AEMBAsgBCAsIC18NwNgIAQtAMEDIRYgBCgCvAMhESAEKAK4AyEPIAQoArQDIQggBEGwA2ogBRC9AwJAIAQoArADQQFGBEAgBCAE/QACtAP9CwTgAQwBCyAEIAQtAMQDOgDsCCAEIAQoAsADIgk2AugIAkAgLiArIAQpA7gDIi18QiB8WgRAIAQgLTcDoAMgBCAtNwOYAyAEIAU2AqgDIARBsANqIgUgBEGYA2oQrAIgBEHoAmogBRA0IAQgBP0AAuwC/QsD2AIgBCgC6AIiBUGAgICAeEcNASAEIAT9AAPYAv0LBOABDAILQdKSmbIEIQMCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgCUH/AXFBAWsOCwABAgMEBQYHCAkKCwtB14qJggUhAwwKC0HWoOGBAiEDDAkLQdag4eEEIQMMCAtB1qDhwQUhAwwHC0HBnKXqBCEDDAYLQcGctbIEIQMMBQtBwZjBwgQhAwwEC0HJho2CBSEDDAMLQcWwpbIEIQMMAgtB2JrBggIhAwwBCyAEKADpCCEDCyAEIAM2AOEBIARBBDoA4AEMAQsgBEHUAmogBEGUA2ooAgA2AgAgBEHMAmogBEGMA2opAgA3AgAgBCAE/QAC/AL9CwK8AiAEIAT9AAPYAv0LAqwCIAQgBTYCqAIgBEGYA2ogFSAabEECdEGE98YAEKAHIARBqAJqIAQoApwDIgsgBCgCoAMiDSAELQCkARCAAQJAIAQvAc4CIgxFDQAgBC8BzAIiEEUNACAQQQJ0IRNBACEGQQMhCUEAIQoDQCAGIA9qIRQgCSEHQQAhBQJAAkADQCAFIAogECAWIAsgDRC8AyEYIAUgBmoiGSARTw0BIAcgDUkEQCAHIAtqIAUgFGotAAAgGGo6AAAgB0EEaiEHIBAgBUEBaiIFRg0DDAELCyAHIA1BlPjGABCMBwALIBkgEUGE+MYAEIwHAAsgCSATaiEJIAYgEGohBiAKQQFqIgogDEcNAAsLIAQoApgDIScgBEGoAmoQ/QQgCARAIA8gCEEBEKIHC0EBIQoMAgsgCEUNAyAPIAhBARCiBwwDCyAEQcGYwcIENgDhASAEQQQ6AOABDAILAkACQAJAIAQoAhhBgICAgHhGBEAgBEGQAmogBCgClAEgBCgCmAFsQQJ0QZT3xgAQoAcCQCAELQBMQQFHDQAgBCgCmAIiBUF8cSIHRQ0AIAQoApQCIQkCQCAFQQRrIgZBLEkEQCAJIQUMAQsgCSAEQdEAak8gBEHNAGogCSAFQXxxak9yRQRAIAkhBQwBCyAJIAZBAnZBAWoiEEH8////B3EiCEECdCIGaiEFIAcgBmshByAIIQYDQCAJIAT9AABN/QwAAAAAAAAAAAAAAAAAAAAA/Q0AAQIDAAECAwABAgMAAQID/QsAACAJQRBqIQkgBkEEayIGDQALIAggEEYNAQsDQCAFIAQoAE02AAAgBUEEaiEFIAdBBGsiBw0ACwsgBCgCGCIFQYCAgIB4ckGAgICAeEcEQCAEKAIcIAVBARCiBwsgBEEYaiIFIAQpApACNwIAIAVBCGogBEGYAmooAgA2AgAgBCgCGEGAgICAeEYNAQsgBCgCHCEJIAQoAiAhDCAEKAKYASEdIBJBACAXGyEGIA4hCCAKIRcgHEECcUUhISAEKAIoIQUgBCgCLCEiIAQoAjAhGCAEKAI0IRlBACEOQQAhFAJAAkACQAJAAkACQAJAIB8gIHIgFSAEKAKUASITR3JFBEAgGiAdRyIHICFyBEAgBkEBcUUNByAHDQIgCg0FIAwgDEEDcGsiBkEDSQ0HIAZBA2siB0EDbiIFQQdxQQdHDQMgCSEFDAQLIBdFBEAgDEECdiIFIA1BA24iBiAFIAZJGyIFRQ0IQQAhBiAFQQFHBEAgBUEBcSAFQf7///8DcSENIAkhCCALIQUDQCAIIAUvAAA7AAAgCEEDakH/AToAACAIQQdqQf8BOgAAIAhBAmogBUECai0AADoAACAIQQRqIAVBA2ovAAA7AAAgCEEGaiAFQQVqLQAAOgAAIAhBCGohCCAFQQZqIQUgDSAGQQJqIgZHDQALRQ0JCyAJIAZBAnRqIgVB/wE6AAMgBSALIAZBA2xqIgkvAAA7AAAgBUECaiAJQQJqLQAAOgAADAgLIAwgDUcNBSANRQ0HIAkgCyAN/AoAAAwHCyAGQQFxRQ0FCyAiRSAFRXIhBgJAAkACQAJAIBdFBEAgBg0JIAxBAmoiIyAYIBMgGWxqQQNsIgdrIREgBUEBaiEkIBNBA2whFCATQX1sISUgDK1CAXwhLSAFQQFrrSErIAhBEHYhDyAMIAciEmsiJiEWQQEhEANAIA4gGWogE2wgGGohHiARQQIgFiAWQQJPG2utQgOAITBBASEFQQAhBgJAICMgDiAlbCIKaiAHQQIgCiAmaiIKIApBAk8bamsiG0EDbq0iMyAtIAcgDiAUbGoiCq0iMSAtIDFWGyAxIAogDE2tIix8fSIxQgOAICx8IjQgMyA0VBsiMyArICsgM1YbIjNCCFQNACAbQQNurSI0IDFCA4AgLHwiMSAxIDRWGyIxICsgKyAxVhunQQNsIApBf3NLDQAgMCAtIBKtIjEgLSAxVhsgLCAxfH1CA4AgLHwiLCAsIDBWGyIsICsgKyAsVhunIDOnQQFqIgVBA3EiBkEEIAYbIgZrQQFqIQogBSAGayIGQQFqIQUgHv0RIT39DAAAAAABAAAAAgAAAAMAAAAhOwNAIAkgPSA7/a4B/QwDAAAAAwAAAAMAAAADAAAA/bUBIjz9GwBqIhsgCDsAACAbQQJqIA86AAAgCSA8/RsBaiIbQQJqIA86AAAgGyAIOwAAIAkgPP0bAmoiG0ECaiAPOgAAIBsgCDsAACAJIDz9GwNqIhtBAmogDzoAACAbIAg7AAAgO/0MBAAAAAQAAAAEAAAABAAAAP2uASE7IApBBGsiCg0ACwsDQCAMIAYgHmpBA2wiBkkNAyAMIAZrIgpBA0kNBCAGIAlqIgYgCDsAACAGQQJqIA86AAAgBSEGICQgBUEBaiIFRw0ACyASIBRqIRIgFiAUayEWIBEgFGshESAOQQFqIQ4gECAQICJJIgVqIRAgBQ0ACwwJCyAGDQggDEEDaiIjIBggEyAZbGpBAnQiD2shHiAFQQFqISRBACATQQJ0IhJrISUgDK1CAXwhKyAJIA9qIREgBUEBa60hLSAI/REhOyAMIA9rIiYhFiAPIRBBASEOA0AgFCAZaiATbCEbQQEhBUEAIQYCQCArIA8gEiAUbGoiB619IixCACArICxaG0IDfEICiCIsICMgFCAlbCIKaiAPQQMgCiAmaiIKIApBA08bcmtBAnatIjAgLCAwVBsiLCAtICwgLVQbIixCCFQNACAHQX9zICynIgdBAnRJDQAgB0EBaiIFQQNxIgZBBCAGGyIGICsgEK19IixCACArICxaG0IDfEICiCIsIB5BAyAWIBZBA08ba61CAogiMCAsIDBUGyIsIC0gLCAtVBunQX9zaiEHIAUgBmsiBkEBaiEFIBEhCgNAIAogO/0LAAAgCkEQaiEKIAdBBGoiBw0ACwsgGCAbaiEHA0AgDCAGIAdqQQJ0IgZJDQQgDCAGayIKQQRJDQUgBiAJaiAINgAAIAUhBiAkIAVBAWoiBUcNAAsgESASaiERIBYgEmshFiAeIBJrIR4gECASaiEQIBRBAWohFCAOIA4gIkkiBWohDiAFDQALDAgLIAYgDCAMQcjvxAAQ6gcAC0EAQQMgCkG478QAEOoHAAsgBiAMIAxB6O/EABDqBwALQQBBBCAKQdjvxAAQ6gcACyAGIAVBAWpBB3EiCkEDbGshBiAIQRB2IQ4gCSEFA0AgBSAIOwAAIAVBAmogDjoAACAFQQNqIQUgCkEBayIKDQALCyAHQRVJDQIgCEEQdiEHA0AgBSAIOwAAIAVBF2ogBzoAACAFQRVqIAg7AAAgBUEUaiAHOgAAIAVBEmogCDsAACAFQRFqIAc6AAAgBUEPaiAIOwAAIAVBDmogBzoAACAFQQxqIAg7AAAgBUELaiAHOgAAIAVBCWogCDsAACAFQQhqIAc6AAAgBUEGaiAIOwAAIAVBBWogBzoAACAFQQNqIAg7AAAgBUECaiAHOgAAIAVBGGohBSAGQRhrIgZBA08NAAsMAgsgDEEESQ0BIAxBfHEhCgJAIAxBBGsiBUEMSQRAIAkhBQwBCyAKIAVBAnZBAWoiEEH8////B3EiDkECdCIFayEKIAUgCWohBSAI/REhOyAOIQcgCSEGA0AgBiA7/QsAACAGQRBqIQYgB0EEayIHDQALIA4gEEYNAgsDQCAFIAg2AAAgBUEEaiEFIApBBGsiCg0ACwwBCyAMIA1BqO/EABDeCQALIB0gIGsiBUEAIAUgHU0bIgUgGiAFIBpJGyERIBMgH2siBUEAIAUgE00bIgUgFSAFIBVJGyEPAkACQAJAAkACQAJAAkACQAJAIBdFBEAgEUUNCiATQQJ0IRggD0H+/wFxIRlBASEFIA9BAXEhHSAPQQJ0IRcgD0EDbCEWIBVBA2whFCAJIB8gEyAgbGpBAnRqIRBBACEHIAshDgwBCyAhRQRAIBFFDQogE0ECdCEOIA9BAnQhCCAVQQJ0IRAgDCAfIBMgIGxqQQJ0IgVrIQZBACEKIA0hBwNAIAUgDEsNBiAGIAhJDQUgCiANSw0EIAcgCEkNAyAIBEAgBSAJaiAKIAtqIAj8CgAACyAHIBBrIQcgCiAQaiEKIAYgDmshBiAFIA5qIQUgEUEBayIRDQALDAoLIBFFIA9Fcg0JIAxBA2oiIyAfIBMgIGxqQQJ0IhdrIRIgD0EBaiEkIA2tQgF8ITAgDK1CAXwhLUIAIBWtQgKGIjN9ITggCSAXaiEWIA9BAWutISxBACEZQQAgE0ECdCIYa60hOUEAIBVBAnQiImutITogCyEPIAwgF2siJSEdIA0hECANQQNqIiYhFEIDITRCACExIBchDkIAIStBASEeA0AgGSAgaiATbCEhQQEhBUEAIQgCQCAtIBggK6dsIBdqrX0iL0IAIC0gL1obQgN8QgKIIjIgKyA4fiArIDN+Ii8gMCAvIDBWG3xCA3xCAogiLyAvIDJWGyI1ICYgKyA6fqciBmpBAyAGIA1qIgYgBkEDTxtrQQJ2rSIyIDIgNVYbIjYgIyArIDl+pyIGaiAXQQMgBiAlaiIGIAZBA08bcmtBAnatIjUgNSA2VhsiNiAsICwgNlYbIjZCBFQNACAtIBcgGCAZbGoiBq19IjdCACAtIDdaG0IDfEICiCI3IC8gLyA3VhsiLyAyIC8gMlQbIi8gNSAvIDVUGyIvICwgLCAvVhunQQJ0IAZBf3NLDQAgNqdBAWoiBUEDcSIGQQQgBhsiBiAtIA6tfSIvQgAgLSAvWhtCA3xCAogiLyAxIDAgMCAxVBsgNHxCAogiMiAvIDJUGyIvIBRBAyAQIBBBA08ba61CAogiMiAvIDJUGyIvIBJBAyAdIB1BA08ba61CAogiMiAvIDJUGyIvICwgLCAvVhunQX9zaiEHIAUgBmsiCEEBaiEFIBYhCiAPIQYDQCAK/QAAACI9QRj9rQEgBv0AAAAiPkEY/a0BIj/9DP8AAAD/AAAA/wAAAP8AAAD9Uf21Af0MgAAAAIAAAACAAAAAgAAAAP2uASI7QQj9rQEgO/2uAUEI/a0BIkEgP/2uASE8ID79DP///wD///8A////AP///wD9PCJA/RsAQQFxBEBBgICACCA8/RsAbv0RITsLIED9GwFBAXEEQCA7QYCAgAggPP0bAW79HAEhOwsgQP0bAkEBcQRAIDtBgICACCA8/RsCbv0cAiE7CyBA/RsDQQFxBEAgO0GAgIAIIDz9GwNu/RwDITsLIAogOyBBID39DP8AAAD/AAAA/wAAAP8AAAD9Tv21ASA+/Qz/AAAA/wAAAP8AAAD/AAAA/U4gP/21Af2uAf21AUEY/a0BIDxBGP2rAf1QIDsgQSA9QQj9rQH9DP8AAAD/AAAA/wAAAP8AAAD9Tv21ASA+QQj9rQH9DP8AAAD/AAAA/wAAAP8AAAD9TiA//bUB/a4B/bUBQRD9rQH9DAD/AAAA/wAAAP8AAAD/AAD9Tv1QIDsgQSA9QRD9rQH9DP8AAAD/AAAA/wAAAP8AAAD9Tv21ASA+QRD9rQH9DP8AAAD/AAAA/wAAAP8AAAD9TiA//bUB/a4B/bUBQQj9rQH9DAAA/wAAAP8AAAD/AAAA/wD9Tv1QID0gQP1S/QsAACAKQRBqIQogBkEQaiEGIAdBBGoiBw0ACwsgFSAZbCEbIB8gIWohKQNAIA0gCCAbakECdCIHSQ0KIA0gB2siBkEESQ0JIAwgCCApakECdCIGSQ0IIAwgBmsiCEEESQ0HIAYgCWoiCCgAACEGIAggByALaigAACIHQYCAgAhPBH9BgICACCAHQRh2IghB/wFzIAZBGHZsQYABaiIKQQh2IApqQQh2IgogCGoiKm4iISAKIAZB/wFxbCAHQf8BcSAIbGpsQRh2ICpBGHRyICEgCiAGQQh2Qf8BcWwgB0EIdkH/AXEgCGxqbEEQdkGA/gNxciAhIAogBkEQdkH/AXFsIAdBEHZB/wFxIAhsamxBCHZBgID8B3FyBSAGCzYAACAFIQggJCAFQQFqIgVHDQALIBYgGGohFiAPICJqIQ8gHSAYayEdIBIgGGshEiAQICJrIRAgFCAiayEUIDQgM30hNCAxIDN8ITEgDiAYaiEOICtCAXwhKyAZQQFqIRkgHiARIB5LIgVqIR4gBQ0ACwwJCwNAIAchBiAFIQcCQAJAAkACQAJAAkAgBiAUbCISIA1NBEAgFiANIBJrIgVLDQEgDCAGICBqIBNsIB9qQQJ0IgZJDQIgFyAMIAZrIgVLDQNBACEKAkAgDw4CBwYACyAQIQggDiEFA0AgCCAFLwAAOwAAIAhBA2pB/wE6AAAgCEEHakH/AToAACAIQQJqIAVBAmotAAA6AAAgCEEEaiAFQQNqLwAAOwAAIAhBBmogBUEFai0AADoAACAIQQhqIQggBUEGaiEFIBkgCkECaiIKRw0ACwwECyASIA0gDUGo8MQAEOoHAAtBACAWIAVBmPDEABDqBwALIAYgDCAMQYjwxAAQ6gcAC0EAIBcgBUH478QAEOoHAAsgHUUNAQsgBiAJaiAKQQJ0aiIFQf8BOgADIAUgCyASaiAKQQNsaiIGLwAAOwAAIAVBAmogBkECai0AADoAAAsgECAYaiEQIA4gFGohDiAHIAcgEUkiBmohBSAGDQALDAgLQQAgCCAHQbjwxAAQ6gcACyAKIA0gDUHI8MQAEOoHAAtBACAIIAZB2PDEABDqBwALIAUgDCAMQejwxAAQ6gcAC0EAQQQgCEGI8cQAEOoHAAsgBiAMIAxBmPHEABDqBwALQQBBBCAGQfjwxAAQ6gcACyAHIA0gDUGo8cQAEOoHAAsgBCAcQQFxOgA4IAQgIDYCNCAEIB82AjAgBCAaNgIsIAQgFTYCKCAEIAQoAiRBAWo2AiQgBCAuIAQpAxB8Qgh8NwMQIAQtAKMBRQRAIARBAzYCuAIgBCADQQNwIgU2AqwCIAQgAyAFayIDNgK0AiAEIAI2ArACIAQgAiADajYCqAICQAJAIAQoAhhBgICAgHhHBEAgBEEENgL4AiAEIAQoAhwiAjYC6AIgBCAEKAIgIgNBA3E2AvQCIAQgA0F8cSIDNgLsAiAEIAIgA2o2AvACIARBsANqIQIgBEHoAmohAwJAAkAgBEGoAmoiBSgCECIJBEAgAygCECIGRQ0BIAJBADYCKCACIAX9AAIA/QsCACACIAP9AAIA/QsCFCACQRBqIAVBEGooAgA2AgAgAkEkaiADQRBqKAIANgIAIAIgAygCBCAGbiICIAUoAgwgCW4iAyACIANJGzYCLAwCC0HIpsYAEIEIAAtBgM7HABCBCAALIAQoAtwDIgYgBCgC2AMiA00NBiAEKAK4AyIHRQ0GIAQoAtQDIglBA0kNAiAEKALAAyICQQNHDQEgBCgCxAMhBSADQQFqIQIgBiADa0EBcQRAIAcgA0EDbGoiCCAFIAMgCWxqIgMvAAA7AAAgCEECaiADQQJqLQAAOgAAIAIhAwsgAiAGRg0GIAlBAXQhAiADIAlsIQ0gBiADayEIIAkgA0EBamwhCSAHIANBA2xqIQMDQCADIAUgDWoiBi8AADsAACADQQJqIAZBAmotAAA6AAAgA0EDaiAFIAlqIgYvAAA7AAAgA0EFaiAGQQJqLQAAOgAAIANBBmohAyACIAVqIQUgCEECayIIDQALDAYLQbT3xgAQ3QkACyACQQNB1PfGABDeCQALQQBBAyAJQcT3xgAQ6gcACyAEKAIYQYCAgIB4RwRAIAMgBCgCICIFRw0CIANFDQMgAiAEKAIcIAP8CgAADAMLQeT3xgAQ3QkAC0Gk98YAEN0JAAsgAyAFQfT3xgAQ3gkACyAEQR06AOABIAQgKDYC5AEgJ0UNASALICdBARCiBwwBCyAEIAT9AAOQAv0LBOABCwJAIAQoAhgiAkGAgICAeHJBgICAgHhHBEAgBCgCHCIDQQRrKAIAIgVBeHEiCUEEQQggBUEDcSIFGyACakkNDSAFQQAgCSACQSdqSxsNASADEKICCyAEQTBqIARB0AFq/QADAP0LAwAgBEEgaiAEQcABav0AAwD9CwMAIAQgBP0AA7AB/QsDECAELQDgASIFQR1GDQQgBC8A4QEgBC0A4wFBEHRyIQYgBCkD6AEhLiAEKALkASEJDAkLDAwLIARBqAJqEP0EDAILIAcEQCAFIAdBARCiBwsgLqciAgRAIC5CIIinIAJBARCiBwsgBCgCwAIiAgRAIAQoAsQCIAJBARCiBwsgCyEFICshLgwFCyAEQbADahD3AyAEKAKYBCICRQ0AIAQoApwEIgNBBGsoAgAiBUF4cSIJQQRBCCAFQQNxIgUbIAJqSQ0IIAVBACAJIAJBJ2pLGw0JIAMQogJBBiEDDAYLQQYhAwwFCyAELwDpAiAELQDrAkEQdHILIQYgBCkC8AIhLiAEKALsAiEJCyAEQbADahD3AyAEKAKYBCICRQ0BAkAgBCgCnAQiA0EEaygCACIHQXhxIgtBBEEIIAdBA3EiBxsgAmpPBEAgB0EAIAsgAkEnaksbDQEgAxCiAgwDCwwFCwwFC0EGIQMgBUH/AXFBHUcNAAwBCyAEIC43ArQDIAQgCTYCsAMgBUH/AXFFBEAgACAEKQOwAzcCBEEFIQMMAQtBEBBxIgJFDQEgAiAEKQOwAzcCBCAAQey7xAA2AhggACACNgIUIABBgAY7AQQgAiAFQf8BcSAGQQh0cjYCACACQQxqIARBuANqKAIANgIAQQAhAwsgACADNgIAIAQoAhgiAEGAgICAeHJBgICAgHhHBEAgBCgCHCICQQRrKAIAIgNBeHEiBUEEQQggA0EDcSIDGyAAakkNAiADQQAgBSAAQSdqSxsNAyACEKICCwJAIAQoAmwiAEUNACAAQRhsIgIgAGpBIWoiAEUNACAEKAJoIAJrIgJBHGsoAgAiA0F4cSIFQQRBCCADQQNxIgMbIABqSQ0CIANBACAFIABBJ2pLGw0DIAJBGGsQogILIAFBBGsoAgAiAEF4cUGkAUGoASAAQQNxIgIbSQ0BIAJBACAAQcgBTxsNAiABEKICIARB8AhqJAAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC5c1Aih/An4jAEGQBWsiASQAAkACQCAAKALEASIDQQRPBEAgACgCwAEiAigAAEHQlo0gRw0BIAFCADcDGCABIAM2AhQgASACNgIQIAFB2AJqIAFBEGoQMSABQUBrIgMgAUHkAmooAgA2AgAgASABKQLcAjcDOCABKALYAiICRQRAIAFBOGoQjwchAgwDCyABQSxqIAMoAgA2AgAgASABKQM4NwIkIAEgASkD6AIiKTcDMCABIAI2AiACQAJAICmnKAJAIhAEQCABQfwAaiEEIAFB8ABqIQwgAUHsAmohIiABQeACaiENA0AgAUEAOgC4AiABQQA2ArACIAFB2AJqIAFBIGogHSABQbACahCoASABQdAAaiICIA1BCGooAgA2AgAgASANKQMANwNIAkACQAJAAkACQAJAAkACQAJAIAEpA9gCIilCA1IEQCAEICJBtAH8CgAAIAxBCGogAigCADYCACAMIAEpA0g3AwAgASApNwNoAkAgASgCcCABQegAaiApQgJRGyICKAIsIgdBAE4EQCACKAIoIQICQCAHRQRAQQEhCwwBCyAHEHEiC0UNCAsgBwRAIAsgAiAH/AoAAAsgAUHoAGoQ/AEgB0EJSQ0IQfzVwQAgByALakEJa0EJENsHDQkgByECAkADQCABQQhqQS8gCyACEKkDQQEhHUEAISIgASgCCEEBcUUEQAwCCwJAIAcgASgCDCICSwRAIAIgC2otAABBL0YNAQsgAiAHTQ0BDAILCyABIAI2AqgEIAEgCzYCpAQgASABQaQEaq1CgICAgCCENwOwAiABQgE3AuQCIAFBAjYC3AIgAUGs1sEANgLYAiABIAFBsAJqNgLgAiABQegAaiABQdgCahDsAyABKAJoIgJBgICAgHhGDQAgASkCbCIpQiCIpyEFICmnIR0gAiEiCyABQdgCaiABQSBqIAsgBxDJBCABQeAAaiABQegCaigCADYCACABIAEpA+ACNwNYAkAgASkD2AIiKUIDUQRAIAFB2ABqEI8HIQIMAQsgAUH8AGogAUHsAmpBtAH8CgAAIAFB+ABqIAFB4ABqKAIANgIAIAEgKTcDaCABIAEpA1g3A3AgAUEANgK4AiABQoCAgIAQNwKwAiABQdgCaiABQegAaiABQbACahCZASABKALYAkEBRgRAIAEpAtwCEM8HIQIgASgCsAIiAARAIAEoArQCIABBARCiBwsgAUHoAGoQ/AEMAQsgASgCsAIhJyABKAK0AiEoIAEoArgCIQIgAUHoAGoQ/AEgAUEANgK4AiABIAI2ArQCIAEgKDYCsAIgAUHYAmogAUGwAmoQRiABKALcAiECAkAgASgC2AIiBEGBgICAeEYEQCACEKMHIQIMAQsgAUHwAGogAUHgAmpBwAH8CgAAIAEgAjYCbCABIAQ2AmggAUHsAGohAyABAn5BwLvJAC0AAARAQdC7yQApAwAhKUHIu8kAKQMADAELIAFB2AJqEL8GQcC7yQBBAToAAEHQu8kAIAEpA+ACIik3AwAgASkD2AILIio3A8ACQci7yQAgKkIBfDcDACABICk3A8gCIAFB8JrIAP0AAwD9CwOwAgJAIAFB6ABqIB0gBSABQSBqIAFBsAJqIgUQ2AQiAgRAIAUQ5QMgBEGAgICAeEcNASADEIUCDAILIAEgAUGwAmo2AtQCIARBgICAgHhHBEAgAUHYAmogAUHoAGpByAH8CgAAIAEoAsADIiVBgICAgHhGDQUgASgCyANBEUcNBSABKAKIAyERIAEoAsQDQbLYwQBBERDbBw0FIAEoAvgDIgZBgICAgHhGDQggASgCnAQiAkEtTwRAQQMhCAwJCyACQRdLBEBBAiEIDAkLIAJBCEshCAwICyABQdgCaiADQbQB/AoAACABKAKIBCEJIAEoAtwDIhJBgICAgHhGDQZBAyEIIAEtAIAEIgJBA08NBkECIAJBAEcgAkECRhshCAwGCyABQegAahDIAgsgJ0UNACAoICdBARCiBwsgIgRAIB0gIkEBEKIHCyALIAdBARCiBwwOC0HYmsgAEP8HDAYLIAFBADYCtARBASEFIAFBATYCqAQgAUGw2sEANgKkBCABQgQ3AqwEIAFBpARqEJIHIQIMAwsgAUHIAGoQjwchAgwLCyABQQA6AKwEIAEgCDYCqAQgASAJNgKkBCAAIAFBpARqIgIQpQQgAiABQbACaiABKALoAiIeIAEoAuwCEKMEIAEoAqgEIQNBASEGAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRMgASgCpAQiFEGAgICAeEYEQEEoEHEiAkUNBSACIBM2AiQgAkEPNgIgIAJBw9jBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDCAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoAvQCIAEoAvgCEKMEIAEoAqgEIQMCQCABKAKkBCIEQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhFSABKAKkBCIWQYCAgIB4RgRAQSgQcSICRQ0GIAIgFTYCJCACQQ82AiAgAkHS2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgBEUNASADIARBARCiBwwBCyABKAKsBCENIAQEQCADIARBARCiBwsgAUGkBGogAUGwAmogASgCmAMgASgCnAMQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEXIAEoAqQEIhhBgICAgHhGBEBBKBBxIgJFDQcgAiAXNgIkIAJBDTYCICACQeHYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIRAgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAKwAyABKAK0AxCjBCABKAKoBCEDAkAgASgCpAQiCkGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRkgASgCpAQiGkGAgICAeEYEQEEoEHEiAkUNCCACIBk2AiQgAkEMNgIgIAJB7tjBADYCHCACQQM2AgQgAkHsn8EANgIAIApFDQEgAyAKQQEQogcMAQsgASgCrAQhBCAKBEAgAyAKQQEQogcLIAFBpARqIAFBsAJqIAEoAsgDIAEoAswDEKMEIAEoAqgEIQMCQCABKAKkBCIKQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhGyABKAKkBCIcQYCAgIB4RgRAQSgQcSICRQ0JIAIgGzYCJCACQQo2AiAgAkH62MEANgIcIAJBAzYCBCACQeyfwQA2AgAgCkUNASADIApBARCiBwwBCyABKAKsBCECIAoEQCADIApBARCiBwsgAUG8BGogCUEDbCIDQbjawQAQ5QYgAUHIBGogA0HI2sEAEOUGIAFB1ARqIAlBAnRB2NrBABDlBiABQeAEaiADQejawQAQ5QYgAUHsBGogCUH42sEAEOUGAkACQAJAAkACQCAIRQRAIAFBADYCgAUgAUKAgICAwAA3AvgEDAELIAFB+ARqIAlBCWxBiNvBABDlBiAIQQFHDQELIAFBADYCjAUgAUKAgICAwAA3AoQFDAELIAFBhAVqIAlBD2xBmNvBABDlBiAIQQJLDQELIAFBADYCrAQgAUKAgICAwAA3AqQEDAELIAFBpARqIAlBFWxBqNvBABDlBgsgAUH8AmogAUGIA2ogEyAMIBUgDSABKALABCIjIAEoAsQEIgwQygMgASgCpAMgASgCqAMgFyAQIAEoAswEIiQgASgC0AQiDRD/AiAZIAQgASgC2AQiJSABKALcBCIQEJgDIAEoAtQDIAEoAtgDIBsgAiABKALkBCImIAEoAugEIgQgASgC8AQiBSABKAL0BCIDELECIAEoAqwEIQ4gASgCqAQhHyABKAKMBSEGIAEoAogFISAgASgCgAUhCiABKAL8BCEhAkACQCASQYCAgIB4RgRAIAEoAqQEIQ8MAQsgAUHcA2ogAUHUAmogCSAhIAogICAGIB8gDhBwIQIgASgCpAQhDyACDQELIAAgCSAIICMgDCAkIA0gJSAQICYgBCAFIAMgISAKICAgBiAfIA4QigMhAiAPBEAgHyAPQQJ0QQQQogcLIAEoAoQFIgAEQCAgIABBAnRBBBCiBwsgASgC+AQiAARAICEgAEECdEEEEKIHCyABKALsBCIABEAgBSAAQQJ0QQQQogcLIAEoAuAEIgAEQCAmIABBAnRBBBCiBwsgASgC1AQiAARAICUgAEECdEEEEKIHCyABKALIBCIABEAgJCAAQQJ0QQQQogcLIAEoArwEIgAEQCAjIABBAnRBBBCiBwsgHARAIBsgHEEBEKIHCyAaBEAgGSAaQQEQogcLIBgEQCAXIBhBARCiBwsgFgRAIBUgFkEBEKIHCyAUBEAgEyAUQQEQogcLIAFB2AJqEOUFIAFBlANqEN8FIAFBrANqEOAFIAFBxANqEN8FDAgLIA8EQCAfIA9BAnRBBBCiBwsgASgChAUiAARAICAgAEECdEEEEKIHCyABKAL4BCIABEAgISAAQQJ0QQQQogcLIAEoAuwEIgAEQCAFIABBAnRBBBCiBwsgASgC4AQiAARAICYgAEECdEEEEKIHCyABKALUBCIABEAgJSAAQQJ0QQQQogcLIAEoAsgEIgAEQCAkIABBAnRBBBCiBwsgASgCvAQiAARAICMgAEECdEEEEKIHC0EAIQYgHEUNACAbIBxBARCiBwsgGkUNACAZIBpBARCiBwsgGEUNACAXIBhBARCiBwsgFkUNACAVIBZBARCiBwsgFEUNACATIBRBARCiBwsgASgC5AIiAARAIB4gAEEBEKIHCyABKALwAiIABEAgASgC9AIgAEEBEKIHCyABKAKUAyIABEAgASgCmAMgAEEBEKIHCyABKAKgAyIABEAgASgCpAMgAEECdEEEEKIHCyABKAKsAyIABEAgASgCsAMgAEEBEKIHCyABKAK4AyIAQYCAgIB4ckGAgICAeEcEQCABKAK8AyAAQQEQogcLIAEoAsQDIgAEQCABKALIAyAAQQEQogcLIAEoAtADIgAEQCABKALUAyAAQQJ0QQQQogcLIAZFIBJBgICAgHhGcg0CIBIEQCABKALgAyASQQEQogcLIAEoAugDIgAEQCABKALsAyAAQQEQogcLIAEoAvQDIgBFDQIgASgC+AMgAEECdEEEEKIHDAILIAFBADoArAQgASAINgKoBCABIBE2AqQEIAAgAUGkBGoiAhClBCACIAFBsAJqIAEoAtwCIAEoAuACEKMEIAEoAqgEIQNBASEFIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEJIAEoAqQEIg9BgICAgHhGBEBBKBBxIgJFDQMgAiAJNgIkIAJBDzYCICACQcPYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIQwgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKALoAiABKALsAhCjBCABKAKoBCEDAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRIgASgCpAQiE0GAgICAeEYEQEEoEHEiAkUNBCACIBI2AiQgAkEPNgIgIAJB0tjBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDSAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoApQDIgogASgCmAMQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEUIAEoAqQEIhVBgICAgHhGBEBBKBBxIgJFDQUgAiAUNgIkIAJBDTYCICACQeHYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIRAgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAK4AyABKAK8AxCjBCABKAKoBCEDAkAgASgCpAQiHkGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRYgASgCpAQiF0GAgICAeEYEQEEoEHEiAkUNBiACIBY2AiQgAkEMNgIgIAJB7tjBADYCHCACQQM2AgQgAkHsn8EANgIAIB5FDQEgAyAeQQEQogcMAQsgASgCrAQhBCAeBEAgAyAeQQEQogcLIAFBpARqIAFBsAJqIAEoAtADIh4gASgC1AMQowQgASgCqAQhAwJAIAEoAqQEIg5BgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEYIAEoAqQEIhlBgICAgHhGBEBBKBBxIgJFDQcgAiAYNgIkIAJBCjYCICACQfrYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAORQ0BIAMgDkEBEKIHDAELIAEoAqwEIQIgDgRAIAMgDkEBEKIHCyABQbwEaiARQQNsIgNBhNnBABDlBiABQcgEaiADQZTZwQAQ5QYgAUHUBGogEUECdEGk2cEAEOUGIAFB4ARqIANBtNnBABDlBiABQewEaiARQcTZwQAQ5QYCQAJAAkACQAJAIAhFBEAgAUEANgKABSABQoCAgIDAADcC+AQMAQsgAUH4BGogEUEJbEHU2cEAEOUGIAhBAUcNAQsgAUEANgKMBSABQoCAgIDAADcChAUMAQsgAUGEBWogEUEPbEHk2cEAEOUGIAhBA0YNAQsgAUEANgKsBCABQoCAgIDAADcCpAQMAQsgAUGkBGogEUEVbEH02cEAEOUGCyABQfACaiABQfwCaiAJIAwgEiANIAEoAsAEIh8gASgCxAQiDBDKAyABQZwDaiABQagDaiAUIBAgASgCzAQiICABKALQBCINELMCIBYgBCABKALYBCIhIAEoAtwEIhAQmAMgAUHYA2ogAUHoA2ogGCACIAEoAuQEIiMgASgC6AQiBCABKALwBCIkIAEoAvQEIgMQgAIgASgCrAQhJiABKAKoBCEaIAEoAowFIQUgASgCiAUhGyABKAKABSEOIAEoAvwEIRwCQAJAIAZBgICAgHhGBEAgASgCpAQhBgwBCyABQfgDaiABQdQCaiARIAggHCAOIBsgBSAaICYQdSECIAEoAqQEIQYgAg0BCyAAIBEgCCAfIAwgICANICEgECAjIAQgJCADIBwgDiAbIAUgGiAmEIoDIQIgBgRAIBogBkECdEEEEKIHCyABKAKEBSIABEAgGyAAQQJ0QQQQogcLIAEoAvgEIgAEQCAcIABBAnRBBBCiBwsgASgC7AQiAARAICQgAEECdEEEEKIHCyABKALgBCIABEAgIyAAQQJ0QQQQogcLIAEoAtQEIgAEQCAhIABBAnRBBBCiBwsgASgCyAQiAARAICAgAEECdEEEEKIHCyABKAK8BCIABEAgHyAAQQJ0QQQQogcLIBkEQCAYIBlBARCiBwsgFwRAIBYgF0EBEKIHCyAVBEAgFCAVQQEQogcLIBMEQCASIBNBARCiBwsgDwRAIAkgD0EBEKIHCyABQdgCahDmBSABKAKQAyIABEAgCiAAQQEQogcLIAFBtANqEOAFIAEoAswDIgBFDQYgHiAAQQEQogcMBgsgBgRAIBogBkECdEEEEKIHCyABKAKEBSIABEAgGyAAQQJ0QQQQogcLIAEoAvgEIgAEQCAcIABBAnRBBBCiBwsgASgC7AQiAARAICQgAEECdEEEEKIHCyABKALgBCIABEAgIyAAQQJ0QQQQogcLIAEoAtQEIgAEQCAhIABBAnRBBBCiBwsgASgCyAQiAARAICAgAEECdEEEEKIHCyABKAK8BCIABEAgHyAAQQJ0QQQQogcLQQAhBSAZRQ0AIBggGUEBEKIHCyAXRQ0AIBYgF0EBEKIHCyAVRQ0AIBQgFUEBEKIHCyATRQ0AIBIgE0EBEKIHCyAPRQ0AIAkgD0EBEKIHCyABKALYAiIABEAgASgC3AIgAEEBEKIHCyABKALkAiIABEAgASgC6AIgAEEBEKIHCyABKAKQAyIABEAgASgClAMgAEEBEKIHCyABKAK0AyIABEAgASgCuAMgAEEBEKIHCyAlQYCAgIB4ckGAgICAeEcEQCABKALEAyAlQQEQogcLIAEoAswDIgAEQCABKALQAyAAQQEQogcLIAVBAXMgASgC+AMiAEGAgICAeEZyDQAgAARAIAEoAvwDIABBARCiBwsgASgChAQiAEUNACABKAKIBCAAQQEQogcLIAFBsAJqEOUDICcEQCAoICdBARCiBwsgIgRAIB0gIkEBEKIHCyALIAdBARCiByABKAIwIgAgACgCACIAQQFrNgIAIABBAUcNCyABKAIwEPECDAsLAAsgB0UNAgJAIAtBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAdqTwRAIAJFDQMgAyAHQSdqSw0BDAMLQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyALQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyAHakkNBSACRSADIAdBJ2pNcg0AQYyNyABBLkG8jcgAEOsHAAsgCxCiAgsgECAdQQFqIh1HDQALCyABQQA2AugCIAFBATYC3AIgAUGk1sEANgLYAiABQgQ3AuACIAFB2AJqEJIHIQILIAEoAjAiACAAKAIAIgBBAWs2AgAgAEEBRw0DIAEoAjAQ8QIMAwtBzIzIAEEuQfyMyAAQ6wcACyABQQA2AugCIAFBATYC3AIgAUGopcEANgLYAiABQgQ3AuACIAFB2AJqEJIHIQIMAQsgAUEANgLoAiABQQE2AtwCIAFBjKXBADYC2AIgAUIENwLgAiABQdgCahCSByECCyABQZAFaiQAIAILlzUCKH8CfiMAQZAFayIBJAACQAJAIAAoAswBIgNBBE8EQCAAKALIASICKAAAQdCWjSBHDQEgAUIANwMYIAEgAzYCFCABIAI2AhAgAUHYAmogAUEQahAxIAFBQGsiAyABQeQCaigCADYCACABIAEpAtwCNwM4IAEoAtgCIgJFBEAgAUE4ahCPByECDAMLIAFBLGogAygCADYCACABIAEpAzg3AiQgASABKQPoAiIpNwMwIAEgAjYCIAJAAkAgKacoAkAiEARAIAFB/ABqIQQgAUHwAGohDCABQewCaiEiIAFB4AJqIQ0DQCABQQA6ALgCIAFBADYCsAIgAUHYAmogAUEgaiAdIAFBsAJqEKgBIAFB0ABqIgIgDUEIaigCADYCACABIA0pAwA3A0gCQAJAAkACQAJAAkACQAJAAkAgASkD2AIiKUIDUgRAIAQgIkG0AfwKAAAgDEEIaiACKAIANgIAIAwgASkDSDcDACABICk3A2gCQCABKAJwIAFB6ABqIClCAlEbIgIoAiwiB0EATgRAIAIoAighAgJAIAdFBEBBASELDAELIAcQcSILRQ0ICyAHBEAgCyACIAf8CgAACyABQegAahD8ASAHQQlJDQhB/NXBACAHIAtqQQlrQQkQ2wcNCSAHIQICQANAIAFBCGpBLyALIAIQqQNBASEdQQAhIiABKAIIQQFxRQRADAILAkAgByABKAIMIgJLBEAgAiALai0AAEEvRg0BCyACIAdNDQEMAgsLIAEgAjYCqAQgASALNgKkBCABIAFBpARqrUKAgICAIIQ3A7ACIAFCATcC5AIgAUECNgLcAiABQazWwQA2AtgCIAEgAUGwAmo2AuACIAFB6ABqIAFB2AJqEOwDIAEoAmgiAkGAgICAeEYNACABKQJsIilCIIinIQUgKachHSACISILIAFB2AJqIAFBIGogCyAHEMkEIAFB4ABqIAFB6AJqKAIANgIAIAEgASkD4AI3A1gCQCABKQPYAiIpQgNRBEAgAUHYAGoQjwchAgwBCyABQfwAaiABQewCakG0AfwKAAAgAUH4AGogAUHgAGooAgA2AgAgASApNwNoIAEgASkDWDcDcCABQQA2ArgCIAFCgICAgBA3ArACIAFB2AJqIAFB6ABqIAFBsAJqEJkBIAEoAtgCQQFGBEAgASkC3AIQzwchAiABKAKwAiIABEAgASgCtAIgAEEBEKIHCyABQegAahD8AQwBCyABKAKwAiEnIAEoArQCISggASgCuAIhAiABQegAahD8ASABQQA2ArgCIAEgAjYCtAIgASAoNgKwAiABQdgCaiABQbACahBGIAEoAtwCIQICQCABKALYAiIEQYGAgIB4RgRAIAIQowchAgwBCyABQfAAaiABQeACakHAAfwKAAAgASACNgJsIAEgBDYCaCABQewAaiEDIAECfkHAu8kALQAABEBB0LvJACkDACEpQci7yQApAwAMAQsgAUHYAmoQvwZBwLvJAEEBOgAAQdC7yQAgASkD4AIiKTcDACABKQPYAgsiKjcDwAJByLvJACAqQgF8NwMAIAEgKTcDyAIgAUHwmsgA/QADAP0LA7ACAkAgAUHoAGogHSAFIAFBIGogAUGwAmoiBRDYBCICBEAgBRDlAyAEQYCAgIB4Rw0BIAMQhQIMAgsgASABQbACajYC1AIgBEGAgICAeEcEQCABQdgCaiABQegAakHIAfwKAAAgASgCwAMiJUGAgICAeEYNBSABKALIA0ERRw0FIAEoAogDIREgASgCxANBstjBAEERENsHDQUgASgC+AMiBkGAgICAeEYNCCABKAKcBCICQS1PBEBBAyEIDAkLIAJBF0sEQEECIQgMCQsgAkEISyEIDAgLIAFB2AJqIANBtAH8CgAAIAEoAogEIQkgASgC3AMiEkGAgICAeEYNBkEDIQggAS0AgAQiAkEDTw0GQQIgAkEARyACQQJGGyEIDAYLIAFB6ABqEMgCCyAnRQ0AICggJ0EBEKIHCyAiBEAgHSAiQQEQogcLIAsgB0EBEKIHDA4LQdiayAAQ/wcMBgsgAUEANgK0BEEBIQUgAUEBNgKoBCABQbDawQA2AqQEIAFCBDcCrAQgAUGkBGoQkgchAgwDCyABQcgAahCPByECDAsLIAFBADoArAQgASAINgKoBCABIAk2AqQEIAAgAUGkBGoiAhDhAyACIAFBsAJqIAEoAugCIh4gASgC7AIQowQgASgCqAQhA0EBIQYCQCABKAKkBCIEQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhEyABKAKkBCIUQYCAgIB4RgRAQSgQcSICRQ0FIAIgEzYCJCACQQ82AiAgAkHD2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgBEUNASADIARBARCiBwwBCyABKAKsBCEMIAQEQCADIARBARCiBwsgAUGkBGogAUGwAmogASgC9AIgASgC+AIQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEVIAEoAqQEIhZBgICAgHhGBEBBKBBxIgJFDQYgAiAVNgIkIAJBDzYCICACQdLYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIQ0gBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAKYAyABKAKcAxCjBCABKAKoBCEDAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRcgASgCpAQiGEGAgICAeEYEQEEoEHEiAkUNByACIBc2AiQgAkENNgIgIAJB4djBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhECAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoArADIAEoArQDEKMEIAEoAqgEIQMCQCABKAKkBCIKQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhGSABKAKkBCIaQYCAgIB4RgRAQSgQcSICRQ0IIAIgGTYCJCACQQw2AiAgAkHu2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgCkUNASADIApBARCiBwwBCyABKAKsBCEEIAoEQCADIApBARCiBwsgAUGkBGogAUGwAmogASgCyAMgASgCzAMQowQgASgCqAQhAwJAIAEoAqQEIgpBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEbIAEoAqQEIhxBgICAgHhGBEBBKBBxIgJFDQkgAiAbNgIkIAJBCjYCICACQfrYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAKRQ0BIAMgCkEBEKIHDAELIAEoAqwEIQIgCgRAIAMgCkEBEKIHCyABQbwEaiAJQQNsIgNBuNrBABDlBiABQcgEaiADQcjawQAQ5QYgAUHUBGogCUECdEHY2sEAEOUGIAFB4ARqIANB6NrBABDlBiABQewEaiAJQfjawQAQ5QYCQAJAAkACQAJAIAhFBEAgAUEANgKABSABQoCAgIDAADcC+AQMAQsgAUH4BGogCUEJbEGI28EAEOUGIAhBAUcNAQsgAUEANgKMBSABQoCAgIDAADcChAUMAQsgAUGEBWogCUEPbEGY28EAEOUGIAhBAksNAQsgAUEANgKsBCABQoCAgIDAADcCpAQMAQsgAUGkBGogCUEVbEGo28EAEOUGCyABQfwCaiABQYgDaiATIAwgFSANIAEoAsAEIiMgASgCxAQiDBDKAyABKAKkAyABKAKoAyAXIBAgASgCzAQiJCABKALQBCINEP8CIBkgBCABKALYBCIlIAEoAtwEIhAQmAMgASgC1AMgASgC2AMgGyACIAEoAuQEIiYgASgC6AQiBCABKALwBCIFIAEoAvQEIgMQsQIgASgCrAQhDiABKAKoBCEfIAEoAowFIQYgASgCiAUhICABKAKABSEKIAEoAvwEISECQAJAIBJBgICAgHhGBEAgASgCpAQhDwwBCyABQdwDaiABQdQCaiAJICEgCiAgIAYgHyAOEHAhAiABKAKkBCEPIAINAQsgACAJIAggIyAMICQgDSAlIBAgJiAEIAUgAyAhIAogICAGIB8gDhCLAyECIA8EQCAfIA9BAnRBBBCiBwsgASgChAUiAARAICAgAEECdEEEEKIHCyABKAL4BCIABEAgISAAQQJ0QQQQogcLIAEoAuwEIgAEQCAFIABBAnRBBBCiBwsgASgC4AQiAARAICYgAEECdEEEEKIHCyABKALUBCIABEAgJSAAQQJ0QQQQogcLIAEoAsgEIgAEQCAkIABBAnRBBBCiBwsgASgCvAQiAARAICMgAEECdEEEEKIHCyAcBEAgGyAcQQEQogcLIBoEQCAZIBpBARCiBwsgGARAIBcgGEEBEKIHCyAWBEAgFSAWQQEQogcLIBQEQCATIBRBARCiBwsgAUHYAmoQ5QUgAUGUA2oQ3wUgAUGsA2oQ4AUgAUHEA2oQ3wUMCAsgDwRAIB8gD0ECdEEEEKIHCyABKAKEBSIABEAgICAAQQJ0QQQQogcLIAEoAvgEIgAEQCAhIABBAnRBBBCiBwsgASgC7AQiAARAIAUgAEECdEEEEKIHCyABKALgBCIABEAgJiAAQQJ0QQQQogcLIAEoAtQEIgAEQCAlIABBAnRBBBCiBwsgASgCyAQiAARAICQgAEECdEEEEKIHCyABKAK8BCIABEAgIyAAQQJ0QQQQogcLQQAhBiAcRQ0AIBsgHEEBEKIHCyAaRQ0AIBkgGkEBEKIHCyAYRQ0AIBcgGEEBEKIHCyAWRQ0AIBUgFkEBEKIHCyAURQ0AIBMgFEEBEKIHCyABKALkAiIABEAgHiAAQQEQogcLIAEoAvACIgAEQCABKAL0AiAAQQEQogcLIAEoApQDIgAEQCABKAKYAyAAQQEQogcLIAEoAqADIgAEQCABKAKkAyAAQQJ0QQQQogcLIAEoAqwDIgAEQCABKAKwAyAAQQEQogcLIAEoArgDIgBBgICAgHhyQYCAgIB4RwRAIAEoArwDIABBARCiBwsgASgCxAMiAARAIAEoAsgDIABBARCiBwsgASgC0AMiAARAIAEoAtQDIABBAnRBBBCiBwsgBkUgEkGAgICAeEZyDQIgEgRAIAEoAuADIBJBARCiBwsgASgC6AMiAARAIAEoAuwDIABBARCiBwsgASgC9AMiAEUNAiABKAL4AyAAQQJ0QQQQogcMAgsgAUEAOgCsBCABIAg2AqgEIAEgETYCpAQgACABQaQEaiICEOEDIAIgAUGwAmogASgC3AIgASgC4AIQowQgASgCqAQhA0EBIQUgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIQkgASgCpAQiD0GAgICAeEYEQEEoEHEiAkUNAyACIAk2AiQgAkEPNgIgIAJBw9jBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDCAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoAugCIAEoAuwCEKMEIAEoAqgEIQMCQCABKAKkBCIEQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhEiABKAKkBCITQYCAgIB4RgRAQSgQcSICRQ0EIAIgEjYCJCACQQ82AiAgAkHS2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgBEUNASADIARBARCiBwwBCyABKAKsBCENIAQEQCADIARBARCiBwsgAUGkBGogAUGwAmogASgClAMiCiABKAKYAxCjBCABKAKoBCEDAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRQgASgCpAQiFUGAgICAeEYEQEEoEHEiAkUNBSACIBQ2AiQgAkENNgIgIAJB4djBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhECAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoArgDIAEoArwDEKMEIAEoAqgEIQMCQCABKAKkBCIeQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhFiABKAKkBCIXQYCAgIB4RgRAQSgQcSICRQ0GIAIgFjYCJCACQQw2AiAgAkHu2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgHkUNASADIB5BARCiBwwBCyABKAKsBCEEIB4EQCADIB5BARCiBwsgAUGkBGogAUGwAmogASgC0AMiHiABKALUAxCjBCABKAKoBCEDAkAgASgCpAQiDkGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRggASgCpAQiGUGAgICAeEYEQEEoEHEiAkUNByACIBg2AiQgAkEKNgIgIAJB+tjBADYCHCACQQM2AgQgAkHsn8EANgIAIA5FDQEgAyAOQQEQogcMAQsgASgCrAQhAiAOBEAgAyAOQQEQogcLIAFBvARqIBFBA2wiA0GE2cEAEOUGIAFByARqIANBlNnBABDlBiABQdQEaiARQQJ0QaTZwQAQ5QYgAUHgBGogA0G02cEAEOUGIAFB7ARqIBFBxNnBABDlBgJAAkACQAJAAkAgCEUEQCABQQA2AoAFIAFCgICAgMAANwL4BAwBCyABQfgEaiARQQlsQdTZwQAQ5QYgCEEBRw0BCyABQQA2AowFIAFCgICAgMAANwKEBQwBCyABQYQFaiARQQ9sQeTZwQAQ5QYgCEEDRg0BCyABQQA2AqwEIAFCgICAgMAANwKkBAwBCyABQaQEaiARQRVsQfTZwQAQ5QYLIAFB8AJqIAFB/AJqIAkgDCASIA0gASgCwAQiHyABKALEBCIMEMoDIAFBnANqIAFBqANqIBQgECABKALMBCIgIAEoAtAEIg0QswIgFiAEIAEoAtgEIiEgASgC3AQiEBCYAyABQdgDaiABQegDaiAYIAIgASgC5AQiIyABKALoBCIEIAEoAvAEIiQgASgC9AQiAxCAAiABKAKsBCEmIAEoAqgEIRogASgCjAUhBSABKAKIBSEbIAEoAoAFIQ4gASgC/AQhHAJAAkAgBkGAgICAeEYEQCABKAKkBCEGDAELIAFB+ANqIAFB1AJqIBEgCCAcIA4gGyAFIBogJhB1IQIgASgCpAQhBiACDQELIAAgESAIIB8gDCAgIA0gISAQICMgBCAkIAMgHCAOIBsgBSAaICYQiwMhAiAGBEAgGiAGQQJ0QQQQogcLIAEoAoQFIgAEQCAbIABBAnRBBBCiBwsgASgC+AQiAARAIBwgAEECdEEEEKIHCyABKALsBCIABEAgJCAAQQJ0QQQQogcLIAEoAuAEIgAEQCAjIABBAnRBBBCiBwsgASgC1AQiAARAICEgAEECdEEEEKIHCyABKALIBCIABEAgICAAQQJ0QQQQogcLIAEoArwEIgAEQCAfIABBAnRBBBCiBwsgGQRAIBggGUEBEKIHCyAXBEAgFiAXQQEQogcLIBUEQCAUIBVBARCiBwsgEwRAIBIgE0EBEKIHCyAPBEAgCSAPQQEQogcLIAFB2AJqEOYFIAEoApADIgAEQCAKIABBARCiBwsgAUG0A2oQ4AUgASgCzAMiAEUNBiAeIABBARCiBwwGCyAGBEAgGiAGQQJ0QQQQogcLIAEoAoQFIgAEQCAbIABBAnRBBBCiBwsgASgC+AQiAARAIBwgAEECdEEEEKIHCyABKALsBCIABEAgJCAAQQJ0QQQQogcLIAEoAuAEIgAEQCAjIABBAnRBBBCiBwsgASgC1AQiAARAICEgAEECdEEEEKIHCyABKALIBCIABEAgICAAQQJ0QQQQogcLIAEoArwEIgAEQCAfIABBAnRBBBCiBwtBACEFIBlFDQAgGCAZQQEQogcLIBdFDQAgFiAXQQEQogcLIBVFDQAgFCAVQQEQogcLIBNFDQAgEiATQQEQogcLIA9FDQAgCSAPQQEQogcLIAEoAtgCIgAEQCABKALcAiAAQQEQogcLIAEoAuQCIgAEQCABKALoAiAAQQEQogcLIAEoApADIgAEQCABKAKUAyAAQQEQogcLIAEoArQDIgAEQCABKAK4AyAAQQEQogcLICVBgICAgHhyQYCAgIB4RwRAIAEoAsQDICVBARCiBwsgASgCzAMiAARAIAEoAtADIABBARCiBwsgBUEBcyABKAL4AyIAQYCAgIB4RnINACAABEAgASgC/AMgAEEBEKIHCyABKAKEBCIARQ0AIAEoAogEIABBARCiBwsgAUGwAmoQ5QMgJwRAICggJ0EBEKIHCyAiBEAgHSAiQQEQogcLIAsgB0EBEKIHIAEoAjAiACAAKAIAIgBBAWs2AgAgAEEBRw0LIAEoAjAQ8QIMCwsACyAHRQ0CAkAgC0EEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgB2pPBEAgAkUNAyADIAdBJ2pLDQEMAwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAtBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAdqSQ0FIAJFIAMgB0Enak1yDQBBjI3IAEEuQbyNyAAQ6wcACyALEKICCyAQIB1BAWoiHUcNAAsLIAFBADYC6AIgAUEBNgLcAiABQaTWwQA2AtgCIAFCBDcC4AIgAUHYAmoQkgchAgsgASgCMCIAIAAoAgAiAEEBazYCACAAQQFHDQMgASgCMBDxAgwDC0HMjMgAQS5B/IzIABDrBwALIAFBADYC6AIgAUEBNgLcAiABQailwQA2AtgCIAFCBDcC4AIgAUHYAmoQkgchAgwBCyABQQA2AugCIAFBATYC3AIgAUGMpcEANgLYAiABQgQ3AuACIAFB2AJqEJIHIQILIAFBkAVqJAAgAguSNQIofwJ+IwBBkAVrIgEkAAJAAkAgACgCaCIDQQRPBEAgACgCZCICKAAAQdCWjSBHDQEgAUIANwMYIAEgAzYCFCABIAI2AhAgAUHYAmogAUEQahAxIAFBQGsiAyABQeQCaigCADYCACABIAEpAtwCNwM4IAEoAtgCIgJFBEAgAUE4ahCPByECDAMLIAFBLGogAygCADYCACABIAEpAzg3AiQgASABKQPoAiIpNwMwIAEgAjYCIAJAAkAgKacoAkAiEARAIAFB/ABqIQQgAUHwAGohDCABQewCaiEiIAFB4AJqIQ0DQCABQQA6ALgCIAFBADYCsAIgAUHYAmogAUEgaiAdIAFBsAJqEKgBIAFB0ABqIgIgDUEIaigCADYCACABIA0pAwA3A0gCQAJAAkACQAJAAkAgASkD2AIiKUIDUgRAIAQgIkG0AfwKAAAgDEEIaiACKAIANgIAIAwgASkDSDcDACABICk3A2gCQAJAIAEoAnAgAUHoAGogKUICURsiAigCLCIHQQBOBEAgAigCKCECAkAgB0UEQEEBIQoMAQsgBxBxIgpFDQILIAcEQCAKIAIgB/wKAAALIAFB6ABqEPwBIAdBCUkNBkH81cEAIAcgCmpBCWtBCRDbBw0HIAchAgJAA0AgAUEIakEvIAogAhCpA0EBIR1BACEiIAEoAghBAXFFBEAMAgsCQCAHIAEoAgwiAksEQCACIApqLQAAQS9GDQELIAIgB00NAQwCCwsgASACNgKoBCABIAo2AqQEIAEgAUGkBGqtQoCAgIAghDcDsAIgAUIBNwLkAiABQQI2AtwCIAFBrNbBADYC2AIgASABQbACajYC4AIgAUHoAGogAUHYAmoQ7AMgASgCaCICQYCAgIB4Rg0AIAEpAmwiKUIgiKchBSAppyEdIAIhIgsgAUHYAmogAUEgaiAKIAcQyQQgAUHgAGogAUHoAmooAgA2AgAgASABKQPgAjcDWAJAIAEpA9gCIilCA1EEQCABQdgAahCPByECDAELIAFB/ABqIAFB7AJqQbQB/AoAACABQfgAaiABQeAAaigCADYCACABICk3A2ggASABKQNYNwNwIAFBADYCuAIgAUKAgICAEDcCsAIgAUHYAmogAUHoAGogAUGwAmoQmQEgASgC2AJBAUYEQCABKQLcAhDPByECIAEoArACIgAEQCABKAK0AiAAQQEQogcLIAFB6ABqEPwBDAELIAEoArACIScgASgCtAIhKCABKAK4AiECIAFB6ABqEPwBIAFBADYCuAIgASACNgK0AiABICg2ArACIAFB2AJqIAFBsAJqEEYgASgC3AIhAgJAIAEoAtgCIgRBgYCAgHhGBEAgAhCjByECDAELIAFB8ABqIAFB4AJqQcAB/AoAACABIAI2AmwgASAENgJoIAFB7ABqIQMgAQJ+QcC7yQAtAAAEQEHQu8kAKQMAISlByLvJACkDAAwBCyABQdgCahC/BkHAu8kAQQE6AABB0LvJACABKQPgAiIpNwMAIAEpA9gCCyIqNwPAAkHIu8kAICpCAXw3AwAgASApNwPIAiABQfCayAD9AAMA/QsDsAICQCABQegAaiAdIAUgAUEgaiABQbACaiIFENgEIgIEQCAFEOUDIARBgICAgHhHDQEgAxCFAgwCCyABIAFBsAJqNgLUAiAEQYCAgIB4RwRAIAFB2AJqIAFB6ABqQcgB/AoAACABKALAAyIlQYCAgIB4Rg0GIAEoAsgDQRFHDQYgASgCiAMhESABKALEA0Gy2MEAQREQ2wcNBgJ/QQAgASgC+AMiBkGAgICAeEYNABpBAyABKAKcBCICQSxLDQAaQQIgAkEXSw0AGiACQQhLCyELIAFBADoArAQgASALNgKoBCABIBE2AqQEIAAgAUGkBGoiAhDpASACIAFBsAJqIAEoAtwCIAEoAuACEKMEIAEoAqgEIQNBASEFIAEoAqQEIgRBgICAgHhGBEAgAyECDAkLIAFBpARqIAMgASgCrAQQOSABKAKoBCEIIAEoAqQEIg5BgICAgHhGBEBBKBBxIgJFDQYgAiAINgIkIAJBDzYCICACQcPYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0JIAMgBEEBEKIHDAkLIAEoAqwEIQwgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKALoAiABKALsAhCjBCABKAKoBCEDAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRIgASgCpAQiE0GAgICAeEYEQEEoEHEiAkUNByACIBI2AiQgAkEPNgIgIAJB0tjBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDSAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoApQDIgkgASgCmAMQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEUIAEoAqQEIhVBgICAgHhGBEBBKBBxIgJFDQggAiAUNgIkIAJBDTYCICACQeHYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIRAgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAK4AyABKAK8AxCjBCABKAKoBCEDAkAgASgCpAQiHkGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRYgASgCpAQiF0GAgICAeEYEQEEoEHEiAkUNCSACIBY2AiQgAkEMNgIgIAJB7tjBADYCHCACQQM2AgQgAkHsn8EANgIAIB5FDQEgAyAeQQEQogcMAQsgASgCrAQhBCAeBEAgAyAeQQEQogcLIAFBpARqIAFBsAJqIAEoAtADIh4gASgC1AMQowQgASgCqAQhAwJAIAEoAqQEIg9BgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEYIAEoAqQEIhlBgICAgHhGBEBBKBBxIgJFDQogAiAYNgIkIAJBCjYCICACQfrYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAPRQ0BIAMgD0EBEKIHDAELIAEoAqwEIQIgDwRAIAMgD0EBEKIHCyABQbwEaiARQQNsIgNBhNnBABDlBiABQcgEaiADQZTZwQAQ5QYgAUHUBGogEUECdEGk2cEAEOUGIAFB4ARqIANBtNnBABDlBiABQewEaiARQcTZwQAQ5QYCQAJAAkACQAJAIAtFBEAgAUEANgKABSABQoCAgIDAADcC+AQMAQsgAUH4BGogEUEJbEHU2cEAEOUGIAtBAUcNAQsgAUEANgKMBSABQoCAgIDAADcChAUMAQsgAUGEBWogEUEPbEHk2cEAEOUGIAtBA0YNAQsgAUEANgKsBCABQoCAgIDAADcCpAQMAQsgAUGkBGogEUEVbEH02cEAEOUGCyABQfACaiABQfwCaiAIIAwgEiANIAEoAsAEIh8gASgCxAQiDBDKAyABQZwDaiABQagDaiAUIBAgASgCzAQiICABKALQBCINELMCIBYgBCABKALYBCIhIAEoAtwEIhAQmAMgAUHYA2ogAUHoA2ogGCACIAEoAuQEIiMgASgC6AQiBCABKALwBCIkIAEoAvQEIgMQgAIgASgCrAQhJiABKAKoBCEaIAEoAowFIQUgASgCiAUhGyABKAKABSEPIAEoAvwEIRwCQAJAIAZBgICAgHhGBEAgASgCpAQhBgwBCyABQfgDaiABQdQCaiARIAsgHCAPIBsgBSAaICYQdSECIAEoAqQEIQYgAg0BCyAAIBEgCyAfIAwgICANICEgECAjIAQgJCADIBwgDyAbIAUgGiAmEI8DIAYEQCAaIAZBAnRBBBCiBwsgASgChAUiAARAIBsgAEECdEEEEKIHCyABKAL4BCIABEAgHCAAQQJ0QQQQogcLIAEoAuwEIgAEQCAkIABBAnRBBBCiBwsgASgC4AQiAARAICMgAEECdEEEEKIHCyABKALUBCIABEAgISAAQQJ0QQQQogcLIAEoAsgEIgAEQCAgIABBAnRBBBCiBwsgASgCvAQiAARAIB8gAEECdEEEEKIHCyAZBEAgGCAZQQEQogcLIBcEQCAWIBdBARCiBwsgFQRAIBQgFUEBEKIHCyATBEAgEiATQQEQogcLIA4EQCAIIA5BARCiBwsgAUHYAmoQ5gUgASgCkAMiAARAIAkgAEEBEKIHCyABQbQDahDgBUEAIQIgASgCzAMiAEUNDiAeIABBARCiBwwOCyAGBEAgGiAGQQJ0QQQQogcLIAEoAoQFIgAEQCAbIABBAnRBBBCiBwsgASgC+AQiAARAIBwgAEECdEEEEKIHCyABKALsBCIABEAgJCAAQQJ0QQQQogcLIAEoAuAEIgAEQCAjIABBAnRBBBCiBwsgASgC1AQiAARAICEgAEECdEEEEKIHCyABKALIBCIABEAgICAAQQJ0QQQQogcLIAEoArwEIgAEQCAfIABBAnRBBBCiBwtBACEFIBlFDQAgGCAZQQEQogcLIBdFDQAgFiAXQQEQogcLIBVFDQAgFCAVQQEQogcLIBNFDQAgEiATQQEQogcLIA5FDQggCCAOQQEQogcMCAsgAUHYAmogA0G0AfwKAAAgASgCiAQhCAJ/QQAgASgC3AMiEkGAgICAeEYNABpBAyABLQCABCICQQJLDQAaQQIgAkEARyACQQJGGwshCyABQQA6AKwEIAEgCzYCqAQgASAINgKkBCAAIAFBpARqIgIQ6QEgAiABQbACaiABKALoAiIeIAEoAuwCEKMEIAEoAqgEIQNBASEGAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRMgASgCpAQiFEGAgICAeEYEQEEoEHEiAkUNBiACIBM2AiQgAkEPNgIgIAJBw9jBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDCAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoAvQCIAEoAvgCEKMEIAEoAqgEIQMCQCABKAKkBCIEQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhFSABKAKkBCIWQYCAgIB4RgRAQSgQcSICRQ0HIAIgFTYCJCACQQ82AiAgAkHS2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgBEUNASADIARBARCiBwwBCyABKAKsBCENIAQEQCADIARBARCiBwsgAUGkBGogAUGwAmogASgCmAMgASgCnAMQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEXIAEoAqQEIhhBgICAgHhGBEBBKBBxIgJFDQggAiAXNgIkIAJBDTYCICACQeHYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIRAgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAKwAyABKAK0AxCjBCABKAKoBCEDAkAgASgCpAQiCUGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRkgASgCpAQiGkGAgICAeEYEQEEoEHEiAkUNCSACIBk2AiQgAkEMNgIgIAJB7tjBADYCHCACQQM2AgQgAkHsn8EANgIAIAlFDQEgAyAJQQEQogcMAQsgASgCrAQhBCAJBEAgAyAJQQEQogcLIAFBpARqIAFBsAJqIAEoAsgDIAEoAswDEKMEIAEoAqgEIQMCQCABKAKkBCIJQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhGyABKAKkBCIcQYCAgIB4RgRAQSgQcSICRQ0KIAIgGzYCJCACQQo2AiAgAkH62MEANgIcIAJBAzYCBCACQeyfwQA2AgAgCUUNASADIAlBARCiBwwBCyABKAKsBCECIAkEQCADIAlBARCiBwsgAUG8BGogCEEDbCIDQbjawQAQ5QYgAUHIBGogA0HI2sEAEOUGIAFB1ARqIAhBAnRB2NrBABDlBiABQeAEaiADQejawQAQ5QYgAUHsBGogCEH42sEAEOUGAkACQAJAAkACQCALRQRAIAFBADYCgAUgAUKAgICAwAA3AvgEDAELIAFB+ARqIAhBCWxBiNvBABDlBiALQQFHDQELIAFBADYCjAUgAUKAgICAwAA3AoQFDAELIAFBhAVqIAhBD2xBmNvBABDlBiALQQJLDQELIAFBADYCrAQgAUKAgICAwAA3AqQEDAELIAFBpARqIAhBFWxBqNvBABDlBgsgAUH8AmogAUGIA2ogEyAMIBUgDSABKALABCIjIAEoAsQEIgwQygMgASgCpAMgASgCqAMgFyAQIAEoAswEIiQgASgC0AQiDRD/AiAZIAQgASgC2AQiJSABKALcBCIQEJgDIAEoAtQDIAEoAtgDIBsgAiABKALkBCImIAEoAugEIgQgASgC8AQiBSABKAL0BCIDELECIAEoAqwEIQ8gASgCqAQhHyABKAKMBSEGIAEoAogFISAgASgCgAUhCSABKAL8BCEhAkACQCASQYCAgIB4RgRAIAEoAqQEIQ4MAQsgAUHcA2ogAUHUAmogCCAhIAkgICAGIB8gDxBwIQIgASgCpAQhDiACDQELIAAgCCALICMgDCAkIA0gJSAQICYgBCAFIAMgISAJICAgBiAfIA8QjwMgDgRAIB8gDkECdEEEEKIHCyABKAKEBSIABEAgICAAQQJ0QQQQogcLIAEoAvgEIgAEQCAhIABBAnRBBBCiBwsgASgC7AQiAARAIAUgAEECdEEEEKIHCyABKALgBCIABEAgJiAAQQJ0QQQQogcLIAEoAtQEIgAEQCAlIABBAnRBBBCiBwsgASgCyAQiAARAICQgAEECdEEEEKIHCyABKAK8BCIABEAgIyAAQQJ0QQQQogcLIBwEQCAbIBxBARCiBwsgGgRAIBkgGkEBEKIHCyAYBEAgFyAYQQEQogcLIBYEQCAVIBZBARCiBwsgFARAIBMgFEEBEKIHCyABQdgCahDlBSABQZQDahDfBSABQawDahDgBSABQcQDahDfBUEAIQIMDgsgDgRAIB8gDkECdEEEEKIHCyABKAKEBSIABEAgICAAQQJ0QQQQogcLIAEoAvgEIgAEQCAhIABBAnRBBBCiBwsgASgC7AQiAARAIAUgAEECdEEEEKIHCyABKALgBCIABEAgJiAAQQJ0QQQQogcLIAEoAtQEIgAEQCAlIABBAnRBBBCiBwsgASgCyAQiAARAICQgAEECdEEEEKIHCyABKAK8BCIABEAgIyAAQQJ0QQQQogcLQQAhBiAcRQ0AIBsgHEEBEKIHCyAaRQ0AIBkgGkEBEKIHCyAYRQ0AIBcgGEEBEKIHCyAWRQ0AIBUgFkEBEKIHCyAURQ0AIBMgFEEBEKIHCyABKALkAiIABEAgHiAAQQEQogcLIAEoAvACIgAEQCABKAL0AiAAQQEQogcLIAEoApQDIgAEQCABKAKYAyAAQQEQogcLIAEoAqADIgAEQCABKAKkAyAAQQJ0QQQQogcLIAEoAqwDIgAEQCABKAKwAyAAQQEQogcLIAEoArgDIgBBgICAgHhyQYCAgIB4RwRAIAEoArwDIABBARCiBwsgASgCxAMiAARAIAEoAsgDIABBARCiBwsgASgC0AMiAARAIAEoAtQDIABBAnRBBBCiBwsgBkUgEkGAgICAeEZyDQggEgRAIAEoAuADIBJBARCiBwsgASgC6AMiAARAIAEoAuwDIABBARCiBwsgASgC9AMiAEUNCCABKAL4AyAAQQJ0QQQQogcMCAsgAUHoAGoQyAILICdFDQAgKCAnQQEQogcLICIEQCAdICJBARCiBwsgCiAHQQEQogcMDAtB2JrIABD/BwsACyABQQA2ArQEQQEhBSABQQE2AqgEIAFBsNrBADYCpAQgAUIENwKsBCABQaQEahCSByECDAELIAFByABqEI8HIQIMCAsgASgC2AIiAARAIAEoAtwCIABBARCiBwsgASgC5AIiAARAIAEoAugCIABBARCiBwsgASgCkAMiAARAIAEoApQDIABBARCiBwsgASgCtAMiAARAIAEoArgDIABBARCiBwsgJUGAgICAeHJBgICAgHhHBEAgASgCxAMgJUEBEKIHCyABKALMAyIABEAgASgC0AMgAEEBEKIHCyAFQQFzIAEoAvgDIgBBgICAgHhGcg0AIAAEQCABKAL8AyAAQQEQogcLIAEoAoQEIgBFDQAgASgCiAQgAEEBEKIHCyABQbACahDlAyAnBEAgKCAnQQEQogcLICIEQCAdICJBARCiBwsgCiAHQQEQogcgASgCMCIAIAAoAgAiAEEBazYCACAAQQFHDQogASgCMBDxAgwKCyAHRQ0CAkAgCkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgB2pPBEAgAkUNAyADIAdBJ2pLDQEMAwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIApBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAdqSQ0FIAJFIAMgB0Enak1yDQBBjI3IAEEuQbyNyAAQ6wcACyAKEKICCyAQIB1BAWoiHUcNAAsLIAFBADYC6AIgAUEBNgLcAiABQaTWwQA2AtgCIAFCBDcC4AIgAUHYAmoQkgchAgsgASgCMCIAIAAoAgAiAEEBazYCACAAQQFHDQMgASgCMBDxAgwDC0HMjMgAQS5B/IzIABDrBwALIAFBADYC6AIgAUEBNgLcAiABQailwQA2AtgCIAFCBDcC4AIgAUHYAmoQkgchAgwBCyABQQA2AugCIAFBATYC3AIgAUGMpcEANgLYAiABQgQ3AuACIAFB2AJqEJIHIQILIAFBkAVqJAAgAguSNQIofwJ+IwBBkAVrIgEkAAJAAkAgACgCSCIDQQRPBEAgACgCRCICKAAAQdCWjSBHDQEgAUIANwMYIAEgAzYCFCABIAI2AhAgAUHYAmogAUEQahAxIAFBQGsiAyABQeQCaigCADYCACABIAEpAtwCNwM4IAEoAtgCIgJFBEAgAUE4ahCPByECDAMLIAFBLGogAygCADYCACABIAEpAzg3AiQgASABKQPoAiIpNwMwIAEgAjYCIAJAAkAgKacoAkAiEARAIAFB/ABqIQQgAUHwAGohDCABQewCaiEiIAFB4AJqIQ0DQCABQQA6ALgCIAFBADYCsAIgAUHYAmogAUEgaiAdIAFBsAJqEKgBIAFB0ABqIgIgDUEIaigCADYCACABIA0pAwA3A0gCQAJAAkACQAJAAkAgASkD2AIiKUIDUgRAIAQgIkG0AfwKAAAgDEEIaiACKAIANgIAIAwgASkDSDcDACABICk3A2gCQAJAIAEoAnAgAUHoAGogKUICURsiAigCLCIHQQBOBEAgAigCKCECAkAgB0UEQEEBIQoMAQsgBxBxIgpFDQILIAcEQCAKIAIgB/wKAAALIAFB6ABqEPwBIAdBCUkNBkH81cEAIAcgCmpBCWtBCRDbBw0HIAchAgJAA0AgAUEIakEvIAogAhCpA0EBIR1BACEiIAEoAghBAXFFBEAMAgsCQCAHIAEoAgwiAksEQCACIApqLQAAQS9GDQELIAIgB00NAQwCCwsgASACNgKoBCABIAo2AqQEIAEgAUGkBGqtQoCAgIAghDcDsAIgAUIBNwLkAiABQQI2AtwCIAFBrNbBADYC2AIgASABQbACajYC4AIgAUHoAGogAUHYAmoQ7AMgASgCaCICQYCAgIB4Rg0AIAEpAmwiKUIgiKchBSAppyEdIAIhIgsgAUHYAmogAUEgaiAKIAcQyQQgAUHgAGogAUHoAmooAgA2AgAgASABKQPgAjcDWAJAIAEpA9gCIilCA1EEQCABQdgAahCPByECDAELIAFB/ABqIAFB7AJqQbQB/AoAACABQfgAaiABQeAAaigCADYCACABICk3A2ggASABKQNYNwNwIAFBADYCuAIgAUKAgICAEDcCsAIgAUHYAmogAUHoAGogAUGwAmoQmQEgASgC2AJBAUYEQCABKQLcAhDPByECIAEoArACIgAEQCABKAK0AiAAQQEQogcLIAFB6ABqEPwBDAELIAEoArACIScgASgCtAIhKCABKAK4AiECIAFB6ABqEPwBIAFBADYCuAIgASACNgK0AiABICg2ArACIAFB2AJqIAFBsAJqEEYgASgC3AIhAgJAIAEoAtgCIgRBgYCAgHhGBEAgAhCjByECDAELIAFB8ABqIAFB4AJqQcAB/AoAACABIAI2AmwgASAENgJoIAFB7ABqIQMgAQJ+QcC7yQAtAAAEQEHQu8kAKQMAISlByLvJACkDAAwBCyABQdgCahC/BkHAu8kAQQE6AABB0LvJACABKQPgAiIpNwMAIAEpA9gCCyIqNwPAAkHIu8kAICpCAXw3AwAgASApNwPIAiABQfCayAD9AAMA/QsDsAICQCABQegAaiAdIAUgAUEgaiABQbACaiIFENgEIgIEQCAFEOUDIARBgICAgHhHDQEgAxCFAgwCCyABIAFBsAJqNgLUAiAEQYCAgIB4RwRAIAFB2AJqIAFB6ABqQcgB/AoAACABKALAAyIlQYCAgIB4Rg0GIAEoAsgDQRFHDQYgASgCiAMhESABKALEA0Gy2MEAQREQ2wcNBgJ/QQAgASgC+AMiBkGAgICAeEYNABpBAyABKAKcBCICQSxLDQAaQQIgAkEXSw0AGiACQQhLCyELIAFBADoArAQgASALNgKoBCABIBE2AqQEIAAgAUGkBGoiAhCEAiACIAFBsAJqIAEoAtwCIAEoAuACEKMEIAEoAqgEIQNBASEFIAEoAqQEIgRBgICAgHhGBEAgAyECDAkLIAFBpARqIAMgASgCrAQQOSABKAKoBCEIIAEoAqQEIg5BgICAgHhGBEBBKBBxIgJFDQYgAiAINgIkIAJBDzYCICACQcPYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0JIAMgBEEBEKIHDAkLIAEoAqwEIQwgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKALoAiABKALsAhCjBCABKAKoBCEDAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRIgASgCpAQiE0GAgICAeEYEQEEoEHEiAkUNByACIBI2AiQgAkEPNgIgIAJB0tjBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDSAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoApQDIgkgASgCmAMQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEUIAEoAqQEIhVBgICAgHhGBEBBKBBxIgJFDQggAiAUNgIkIAJBDTYCICACQeHYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIRAgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAK4AyABKAK8AxCjBCABKAKoBCEDAkAgASgCpAQiHkGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRYgASgCpAQiF0GAgICAeEYEQEEoEHEiAkUNCSACIBY2AiQgAkEMNgIgIAJB7tjBADYCHCACQQM2AgQgAkHsn8EANgIAIB5FDQEgAyAeQQEQogcMAQsgASgCrAQhBCAeBEAgAyAeQQEQogcLIAFBpARqIAFBsAJqIAEoAtADIh4gASgC1AMQowQgASgCqAQhAwJAIAEoAqQEIg9BgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEYIAEoAqQEIhlBgICAgHhGBEBBKBBxIgJFDQogAiAYNgIkIAJBCjYCICACQfrYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAPRQ0BIAMgD0EBEKIHDAELIAEoAqwEIQIgDwRAIAMgD0EBEKIHCyABQbwEaiARQQNsIgNBhNnBABDlBiABQcgEaiADQZTZwQAQ5QYgAUHUBGogEUECdEGk2cEAEOUGIAFB4ARqIANBtNnBABDlBiABQewEaiARQcTZwQAQ5QYCQAJAAkACQAJAIAtFBEAgAUEANgKABSABQoCAgIDAADcC+AQMAQsgAUH4BGogEUEJbEHU2cEAEOUGIAtBAUcNAQsgAUEANgKMBSABQoCAgIDAADcChAUMAQsgAUGEBWogEUEPbEHk2cEAEOUGIAtBA0YNAQsgAUEANgKsBCABQoCAgIDAADcCpAQMAQsgAUGkBGogEUEVbEH02cEAEOUGCyABQfACaiABQfwCaiAIIAwgEiANIAEoAsAEIh8gASgCxAQiDBDKAyABQZwDaiABQagDaiAUIBAgASgCzAQiICABKALQBCINELMCIBYgBCABKALYBCIhIAEoAtwEIhAQmAMgAUHYA2ogAUHoA2ogGCACIAEoAuQEIiMgASgC6AQiBCABKALwBCIkIAEoAvQEIgMQgAIgASgCrAQhJiABKAKoBCEaIAEoAowFIQUgASgCiAUhGyABKAKABSEPIAEoAvwEIRwCQAJAIAZBgICAgHhGBEAgASgCpAQhBgwBCyABQfgDaiABQdQCaiARIAsgHCAPIBsgBSAaICYQdSECIAEoAqQEIQYgAg0BCyAAIBEgCyAfIAwgICANICEgECAjIAQgJCADIBwgDyAbIAUgGiAmEJADIAYEQCAaIAZBAnRBBBCiBwsgASgChAUiAARAIBsgAEECdEEEEKIHCyABKAL4BCIABEAgHCAAQQJ0QQQQogcLIAEoAuwEIgAEQCAkIABBAnRBBBCiBwsgASgC4AQiAARAICMgAEECdEEEEKIHCyABKALUBCIABEAgISAAQQJ0QQQQogcLIAEoAsgEIgAEQCAgIABBAnRBBBCiBwsgASgCvAQiAARAIB8gAEECdEEEEKIHCyAZBEAgGCAZQQEQogcLIBcEQCAWIBdBARCiBwsgFQRAIBQgFUEBEKIHCyATBEAgEiATQQEQogcLIA4EQCAIIA5BARCiBwsgAUHYAmoQ5gUgASgCkAMiAARAIAkgAEEBEKIHCyABQbQDahDgBUEAIQIgASgCzAMiAEUNDiAeIABBARCiBwwOCyAGBEAgGiAGQQJ0QQQQogcLIAEoAoQFIgAEQCAbIABBAnRBBBCiBwsgASgC+AQiAARAIBwgAEECdEEEEKIHCyABKALsBCIABEAgJCAAQQJ0QQQQogcLIAEoAuAEIgAEQCAjIABBAnRBBBCiBwsgASgC1AQiAARAICEgAEECdEEEEKIHCyABKALIBCIABEAgICAAQQJ0QQQQogcLIAEoArwEIgAEQCAfIABBAnRBBBCiBwtBACEFIBlFDQAgGCAZQQEQogcLIBdFDQAgFiAXQQEQogcLIBVFDQAgFCAVQQEQogcLIBNFDQAgEiATQQEQogcLIA5FDQggCCAOQQEQogcMCAsgAUHYAmogA0G0AfwKAAAgASgCiAQhCAJ/QQAgASgC3AMiEkGAgICAeEYNABpBAyABLQCABCICQQJLDQAaQQIgAkEARyACQQJGGwshCyABQQA6AKwEIAEgCzYCqAQgASAINgKkBCAAIAFBpARqIgIQhAIgAiABQbACaiABKALoAiIeIAEoAuwCEKMEIAEoAqgEIQNBASEGAkAgASgCpAQiBEGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRMgASgCpAQiFEGAgICAeEYEQEEoEHEiAkUNBiACIBM2AiQgAkEPNgIgIAJBw9jBADYCHCACQQM2AgQgAkHsn8EANgIAIARFDQEgAyAEQQEQogcMAQsgASgCrAQhDCAEBEAgAyAEQQEQogcLIAFBpARqIAFBsAJqIAEoAvQCIAEoAvgCEKMEIAEoAqgEIQMCQCABKAKkBCIEQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhFSABKAKkBCIWQYCAgIB4RgRAQSgQcSICRQ0HIAIgFTYCJCACQQ82AiAgAkHS2MEANgIcIAJBAzYCBCACQeyfwQA2AgAgBEUNASADIARBARCiBwwBCyABKAKsBCENIAQEQCADIARBARCiBwsgAUGkBGogAUGwAmogASgCmAMgASgCnAMQowQgASgCqAQhAwJAIAEoAqQEIgRBgICAgHhGBEAgAyECDAELIAFBpARqIAMgASgCrAQQOSABKAKoBCEXIAEoAqQEIhhBgICAgHhGBEBBKBBxIgJFDQggAiAXNgIkIAJBDTYCICACQeHYwQA2AhwgAkEDNgIEIAJB7J/BADYCACAERQ0BIAMgBEEBEKIHDAELIAEoAqwEIRAgBARAIAMgBEEBEKIHCyABQaQEaiABQbACaiABKAKwAyABKAK0AxCjBCABKAKoBCEDAkAgASgCpAQiCUGAgICAeEYEQCADIQIMAQsgAUGkBGogAyABKAKsBBA5IAEoAqgEIRkgASgCpAQiGkGAgICAeEYEQEEoEHEiAkUNCSACIBk2AiQgAkEMNgIgIAJB7tjBADYCHCACQQM2AgQgAkHsn8EANgIAIAlFDQEgAyAJQQEQogcMAQsgASgCrAQhBCAJBEAgAyAJQQEQogcLIAFBpARqIAFBsAJqIAEoAsgDIAEoAswDEKMEIAEoAqgEIQMCQCABKAKkBCIJQYCAgIB4RgRAIAMhAgwBCyABQaQEaiADIAEoAqwEEDkgASgCqAQhGyABKAKkBCIcQYCAgIB4RgRAQSgQcSICRQ0KIAIgGzYCJCACQQo2AiAgAkH62MEANgIcIAJBAzYCBCACQeyfwQA2AgAgCUUNASADIAlBARCiBwwBCyABKAKsBCECIAkEQCADIAlBARCiBwsgAUG8BGogCEEDbCIDQbjawQAQ5QYgAUHIBGogA0HI2sEAEOUGIAFB1ARqIAhBAnRB2NrBABDlBiABQeAEaiADQejawQAQ5QYgAUHsBGogCEH42sEAEOUGAkACQAJAAkACQCALRQRAIAFBADYCgAUgAUKAgICAwAA3AvgEDAELIAFB+ARqIAhBCWxBiNvBABDlBiALQQFHDQELIAFBADYCjAUgAUKAgICAwAA3AoQFDAELIAFBhAVqIAhBD2xBmNvBABDlBiALQQJLDQELIAFBADYCrAQgAUKAgICAwAA3AqQEDAELIAFBpARqIAhBFWxBqNvBABDlBgsgAUH8AmogAUGIA2ogEyAMIBUgDSABKALABCIjIAEoAsQEIgwQygMgASgCpAMgASgCqAMgFyAQIAEoAswEIiQgASgC0AQiDRD/AiAZIAQgASgC2AQiJSABKALcBCIQEJgDIAEoAtQDIAEoAtgDIBsgAiABKALkBCImIAEoAugEIgQgASgC8AQiBSABKAL0BCIDELECIAEoAqwEIQ8gASgCqAQhHyABKAKMBSEGIAEoAogFISAgASgCgAUhCSABKAL8BCEhAkACQCASQYCAgIB4RgRAIAEoAqQEIQ4MAQsgAUHcA2ogAUHUAmogCCAhIAkgICAGIB8gDxBwIQIgASgCpAQhDiACDQELIAAgCCALICMgDCAkIA0gJSAQICYgBCAFIAMgISAJICAgBiAfIA8QkAMgDgRAIB8gDkECdEEEEKIHCyABKAKEBSIABEAgICAAQQJ0QQQQogcLIAEoAvgEIgAEQCAhIABBAnRBBBCiBwsgASgC7AQiAARAIAUgAEECdEEEEKIHCyABKALgBCIABEAgJiAAQQJ0QQQQogcLIAEoAtQEIgAEQCAlIABBAnRBBBCiBwsgASgCyAQiAARAICQgAEECdEEEEKIHCyABKAK8BCIABEAgIyAAQQJ0QQQQogcLIBwEQCAbIBxBARCiBwsgGgRAIBkgGkEBEKIHCyAYBEAgFyAYQQEQogcLIBYEQCAVIBZBARCiBwsgFARAIBMgFEEBEKIHCyABQdgCahDlBSABQZQDahDfBSABQawDahDgBSABQcQDahDfBUEAIQIMDgsgDgRAIB8gDkECdEEEEKIHCyABKAKEBSIABEAgICAAQQJ0QQQQogcLIAEoAvgEIgAEQCAhIABBAnRBBBCiBwsgASgC7AQiAARAIAUgAEECdEEEEKIHCyABKALgBCIABEAgJiAAQQJ0QQQQogcLIAEoAtQEIgAEQCAlIABBAnRBBBCiBwsgASgCyAQiAARAICQgAEECdEEEEKIHCyABKAK8BCIABEAgIyAAQQJ0QQQQogcLQQAhBiAcRQ0AIBsgHEEBEKIHCyAaRQ0AIBkgGkEBEKIHCyAYRQ0AIBcgGEEBEKIHCyAWRQ0AIBUgFkEBEKIHCyAURQ0AIBMgFEEBEKIHCyABKALkAiIABEAgHiAAQQEQogcLIAEoAvACIgAEQCABKAL0AiAAQQEQogcLIAEoApQDIgAEQCABKAKYAyAAQQEQogcLIAEoAqADIgAEQCABKAKkAyAAQQJ0QQQQogcLIAEoAqwDIgAEQCABKAKwAyAAQQEQogcLIAEoArgDIgBBgICAgHhyQYCAgIB4RwRAIAEoArwDIABBARCiBwsgASgCxAMiAARAIAEoAsgDIABBARCiBwsgASgC0AMiAARAIAEoAtQDIABBAnRBBBCiBwsgBkUgEkGAgICAeEZyDQggEgRAIAEoAuADIBJBARCiBwsgASgC6AMiAARAIAEoAuwDIABBARCiBwsgASgC9AMiAEUNCCABKAL4AyAAQQJ0QQQQogcMCAsgAUHoAGoQyAILICdFDQAgKCAnQQEQogcLICIEQCAdICJBARCiBwsgCiAHQQEQogcMDAtB2JrIABD/BwsACyABQQA2ArQEQQEhBSABQQE2AqgEIAFBsNrBADYCpAQgAUIENwKsBCABQaQEahCSByECDAELIAFByABqEI8HIQIMCAsgASgC2AIiAARAIAEoAtwCIABBARCiBwsgASgC5AIiAARAIAEoAugCIABBARCiBwsgASgCkAMiAARAIAEoApQDIABBARCiBwsgASgCtAMiAARAIAEoArgDIABBARCiBwsgJUGAgICAeHJBgICAgHhHBEAgASgCxAMgJUEBEKIHCyABKALMAyIABEAgASgC0AMgAEEBEKIHCyAFQQFzIAEoAvgDIgBBgICAgHhGcg0AIAAEQCABKAL8AyAAQQEQogcLIAEoAoQEIgBFDQAgASgCiAQgAEEBEKIHCyABQbACahDlAyAnBEAgKCAnQQEQogcLICIEQCAdICJBARCiBwsgCiAHQQEQogcgASgCMCIAIAAoAgAiAEEBazYCACAAQQFHDQogASgCMBDxAgwKCyAHRQ0CAkAgCkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgB2pPBEAgAkUNAyADIAdBJ2pLDQEMAwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIApBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAdqSQ0FIAJFIAMgB0Enak1yDQBBjI3IAEEuQbyNyAAQ6wcACyAKEKICCyAQIB1BAWoiHUcNAAsLIAFBADYC6AIgAUEBNgLcAiABQaTWwQA2AtgCIAFCBDcC4AIgAUHYAmoQkgchAgsgASgCMCIAIAAoAgAiAEEBazYCACAAQQFHDQMgASgCMBDxAgwDC0HMjMgAQS5B/IzIABDrBwALIAFBADYC6AIgAUEBNgLcAiABQailwQA2AtgCIAFCBDcC4AIgAUHYAmoQkgchAgwBCyABQQA2AugCIAFBATYC3AIgAUGMpcEANgLYAiABQgQ3AuACIAFB2AJqEJIHIQILIAFBkAVqJAAgAguDLQQZfwV9An4BeyMAQdACayIXJABCgICAgICAgIDAACABrSIkgCIlICR+QoCAgICAgICAwABSrQJ/IAFBgSBPBEBBASABQQFyZ0EfcyIGQQF2IAZBAXFqIgZ0IAEgBnZqQQF2DAELQcAAIAEgAUEBdmsiBiAGQcAATxsLIRkgJXwhJCAAQQRrIRwgAEEQayEdIABBCGohG0EBIQkCQANAQQEhDkEAIRIgASATSwRAIAAgE0ECdCIUaiEKIBOtIiUCfwJAIAEgE2siDCAZSQ0AAkAgDEECSQRAIAwhBwwBC0MAAIA/IR8CfwJAIAooAgQiBiAFKAIAQQRqKAIAIgdBCGooAgAiC0kEQCAKKAIAIQ8gB0EEaigCACIVIAZBJGxqIgcQigQhISAHLwEUIg5B//8BcUUEQCAOQRB0DAMLIA5B/wdxIQcgDkGAgAJxIQggDkGA+AFxIg5BgPgBRgRAIAhBEHQiDkGAgID8B3IgB0UNAxogDiAHQQ10ckGAgID+B3IMAwsgCEEQdCEIIA5FDQEgDkENdEGAgID8AHEgB0ENdHJBgICAwANqIAhyDAILDAcLIAhBgICA2ANyIAdnQRBrIg5BF3RrIAcgDkH//wNxQQhqdEH///8DcXILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhHwtDAACAPyEgAn8CQCALIA9LBEAgFSAPQSRsaiIHEIoEISIgBy8BFCIOQf//AXFFBEAgDkEQdAwDCyAOQf8HcSEHIA5BgIACcSEPIA5BgPgBcSIOQYD4AUYEQCAPQRB0Ig5BgICA/AdyIAdFDQMaIA4gB0ENdHJBgICA/gdyDAMLIA9BEHQhDyAORQ0BIA5BDXRBgICA/ABxIAdBDXRyQYCAgMADaiAPcgwCCyAPIAtB1MDHABCMBwALIA9BgICA2ANyIAdnQRBrIg5BF3RrIAcgDkH//wNxQQhqdEH///8DcXILviIjQwAAgD9eBEAgIxDGBUNU+C1AlEMAAIA/kpEhIAsCQAJAAkACQCAhICGSIB+UIh8gH1sgHyAiICKSICCUYEVxIhhFBEBBAiEHIAxBAkYNBSAbIBNBAnRqIQ8DQEMAAIA/IR8CfwJAIAsgDygCACIOSwRAIBUgDkEkbGoiCBCKBCEhIAgvARQiDUH//wFxRQRAIA1BEHQMAwsgDUH/B3EhCCANQYCAAnEhEiANQYD4AXEiDUGA+AFGBEAgEkEQdCINQYCAgPwHciAIRQ0DGiANIAhBDXRyQYCAgP4HcgwDCyASQRB0IRIgDUUNASANQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogEnIMAgsgDiALQdTAxwAQjAcACyASQYCAgNgDciAIZ0EQayINQRd0ayAIIA1B//8DcUEIanRB////A3FyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRIR8LQwAAgD8hIAJ/AkAgBiALSQRAIBUgBkEkbGoiBhCKBCEiIAYvARQiCEH//wFxRQRAIAhBEHQMAwsgCEH/B3EhBiAIQYCAAnEhDSAIQYD4AXEiCEGA+AFGBEAgDUEQdCIIQYCAgPwHciAGRQ0DGiAIIAZBDXRyQYCAgP4HcgwDCyANQRB0IQ0gCEUNASAIQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2ogDXIMAgsMDQsgDUGAgIDYA3IgBmdBEGsiCEEXdGsgBiAIQf//A3FBCGp0Qf///wNxcgu+IiNDAACAP14EQCAjEMYFQ1T4LUCUQwAAgD+SkSEgCyAhICGSIB+UIh8gH1sgHyAiICKSICCUYEVxDQMgD0EEaiEPIA4hBiAMIAdBAWoiB0cNAAsMAQsgDEECRg0CQQIhByAbIBNBAnRqIQ8DQEMAAIA/IR8CfwJAIAsgDygCACIOSwRAIBUgDkEkbGoiCBCKBCEhIAgvARQiDUH//wFxRQRAIA1BEHQMAwsgDUH/B3EhCCANQYCAAnEhEiANQYD4AXEiDUGA+AFGBEAgEkEQdCINQYCAgPwHciAIRQ0DGiANIAhBDXRyQYCAgP4HcgwDCyASQRB0IRIgDUUNASANQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogEnIMAgsgDiALQdTAxwAQjAcACyASQYCAgNgDciAIZ0EQayINQRd0ayAIIA1B//8DcUEIanRB////A3FyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRIR8LQwAAgD8hIAJ/AkAgBiALSQRAIBUgBkEkbGoiBhCKBCEiIAYvARQiCEH//wFxRQRAIAhBEHQMAwsgCEH/B3EhBiAIQYCAAnEhDSAIQYD4AXEiCEGA+AFGBEAgDUEQdCIIQYCAgPwHciAGRQ0DGiAIIAZBDXRyQYCAgP4HcgwDCyANQRB0IQ0gCEUNASAIQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2ogDXIMAgsMDAsgDUGAgIDYA3IgBmdBEGsiCEEXdGsgBiAIQf//A3FBCGp0Qf///wNxcgu+IiNDAACAP14EQCAjEMYFQ1T4LUCUQwAAgD+SkSEgCyAhICGSIB+UIh8gH1wgHyAiICKSICCUYHINAiAPQQRqIQ8gDiEGIAwgB0EBaiIHRw0ACwsgDCEHCyAHIBlJDQMgGEUNAiAHQQJJBEBBASEHDAMLIAdBAXYhCyAKIAdBAnQiBmohD0EAIQ4gB0EISQ0BIB0gBiAUamohBiALQfz///8HcSIOIQwDQCAKIAb9AAIAIAr9AAIAIib9DQwNDg8ICQoLBAUGBwABAgP9CwIAIAYgJiAm/Q0MDQ4PCAkKCwQFBgcAAQID/QsCACAGQRBrIQYgCkEQaiEKIAxBBGsiDA0ACyALIA5GDQIMAQsgCkEIaiEPQQAhDkEBIQtBAiEHCyAAIA5BAnQiDCAUamohBiALIA5rIQ4gDyAMa0EEayEMA0AgBigCACELIAYgDCgCADYCACAMIAs2AgAgDEEEayEMIAZBBGohBiAOQQFrIg4NAAsLIAdBAXRBAXIMAQsgDCAZIAwgGUkbQQF0IARFDQAaIApBICAMIAxBIE8bIgYgAiADQQBBACAFEDIgBkEBdEEBcgsiDkEBdiATaq18ICR+IBMgCUEBdmutICV8ICR+hXmnIRILAkACQCARQQJJDQAgHCATQQJ0IgZqIRUgACAGaiEeA0AgEUEBayIPIBdBjgJqai0AACASSQ0BAn8CQAJAIAMgF0EEaiAPQQJ0aigCACIMQQF2IgYgCUEBdiIHaiIYTyAJIAxyQQFxRXFFBEAgACATIBhrQQJ0aiERIAxBAXFFDQEMAgsgGEEBdAwCCyARIAYgAiADIAZBAXJnQQF0QT5zQQAgBRAyCyAJQQFxRQRAIBEgBkECdGogByACIAMgB0EBcmdBAXRBPnNBACAFEDILAkAgCUECSSAMQQJJcg0AIAMgByAGIAYgB0siDBsiB0kNACAFKAIAIBEgBkECdGohCSAHQQJ0IgYEQCACIAkgESAMGyAG/AoAAAsgAiAGaiEHQQRqIhooAgAhFAJAIAxFBEAgAiEMA0ACfwJAIAkoAgAiBiAUQQhqKAIAIgtJBEAgFEEEaigCACIaIAZBJGxqIg0vARwhBkEAIQpBACANLwEeIghB//8BcSIQQYD4AUsNAhpBACAGQf//AXEiFkGA+AFLDQIaIAjBQQBIDQEgBiAISSAGwUEATg0CGiAIIBZyQQBHDAILDAsLIAbBQQBIIAYgCEtxCyEWIAggBiAWGyAGIBBBgfgBSRshBgJAIA0vASAiCEH//wFxIhZBgPgBSw0AIAZB//8BcSIQQYD4AUsNACAIwUEATgRAIAbBQQBOBEAgCCAGQf//A3FLIQoMAgsgCCAQckEARyEKDAELIAbBQQBIIAggBkH//wNxSXEhCgsgDCgCACEQIA0vARQhDQJ/IAggBiAKGyAGIBZBgfgBSRsiCkH//wFxRQRAIApBEHQMAQsgCkH/B3EhBiAKQYCAAnEhCCAKQYD4AXEiCkGA+AFGBEAgCEEQdCIKQYCAgPwHciAGRQ0BGiAKIAZBDXRyQYCAgP4HcgwBCyAIQRB0IgggCkENdEGAgID8AHEgBkENdHJBgICAwANqciAKDQAaIAhBgICA2ANyIAZnQRBrIgpBF3RrIAYgCkH//wNxQQhqdEH///8DcXILvhCJBCEhQwAAgD8hHwJ/IA1BEHQgDUH//wFxRQ0AGiANQf8HcSEGIA1BgIACcSEKIA1BgPgBcSIIQYD4AUYEQCAKQRB0IgpBgICA/AdyIAZFDQEaIAogBkENdHJBgICA/gdyDAELIApBEHQiCiAIQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2pyIAgNABogCkGAgIDYA3IgBmdBEGsiCkEXdGsgBiAKQf//A3FBCGp0Qf///wNxcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEfCwJ/AkAgCyAQSwRAIBogEEEkbGoiCC8BHCEGQQAhCkEAIAgvAR4iC0H//wFxIg1BgPgBSw0CGkEAIAZB//8BcSIQQYD4AUsNAhogC8FBAEgNASAGIAtJIAbBQQBODQIaIAsgEHJBAEcMAgsgECALQdTAxwAQjAcACyAGwUEASCAGIAtLcQshECALIAYgEBsgBiANQYH4AUkbIQYCQCAILwEgIgtB//8BcSINQYD4AUsNACAGQf//AXEiEEGA+AFLDQAgC8FBAE4EQCAGwUEATgRAIAsgBkH//wNxSyEKDAILIAsgEHJBAEchCgwBCyAGwUEASCALIAZB//8DcUlxIQoLIAgvARQhCEMAAIA/ISAgESAJIAwgISAhkiAflCIfIB9bIB8CfyALIAYgChsgBiANQYH4AUkbIgtB//8BcUUEQCALQRB0DAELIAtB/wdxIQYgC0GAgAJxIQogC0GA+AFxIgtBgPgBRgRAIApBEHQiC0GAgID8B3IgBkUNARogCyAGQQ10ckGAgID+B3IMAQsgCkEQdCIKIAtBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgCw0AGiAKQYCAgNgDciAGZ0EQayILQRd0ayAGIAtB//8DcUEIanRB////A3FyC74QiQQiIiAikgJ/IAhBEHQgCEH//wFxRQ0AGiAIQf8HcSEGIAhBgIACcSELIAhBgPgBcSIKQYD4AUYEQCALQRB0IgtBgICA/AdyIAZFDQEaIAsgBkENdHJBgICA/gdyDAELIAtBEHQiCyAKQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2pyIAoNABogC0GAgIDYA3IgBmdBEGsiC0EXdGsgBiALQf//A3FBCGp0Qf///wNxcgu+IiNDAACAP14EfSAjEMYFQ1T4LUCUQwAAgD+SkQUgIAuUYEVxIgYbKAIANgIAIBFBBGohESAMIAZFQQJ0aiIMIAdGDQIgCSAGQQJ0aiIJIB5HDQALDAELIBUhCwNAAn8CQCAHQQRrIg0oAgAiBiAUQQhqKAIAIgdJBEAgFEEEaigCACAGQSRsaiIMLwEcIQZBACEKQQAgDC8BHiIHQf//AXEiCEGA+AFLDQIaQQAgBkH//wFxIhBBgPgBSw0CGiAHwUEASA0BIAYgB0kgBsFBAE4NAhogByAQckEARwwCCyAGIAdB1MDHABCMBwALIAbBQQBIIAYgB0txCyEQIAcgBiAQGyAGIAhBgfgBSRshBgJAIAwvASAiB0H//wFxIhZBgPgBSw0AIAZB//8BcSIIQYD4AUsNACAHwUEATgRAIAbBQQBOBEAgByAGQf//A3FLIQoMAgsgByAIckEARyEKDAELIAbBQQBIIAcgBkH//wNxSXEhCgsgCUEEayIQKAIAIQggDC8BFCEJAn8gByAGIAobIAYgFkGB+AFJGyIHQf//AXFFBEAgB0EQdAwBCyAHQf8HcSEGIAdBgIACcSEMIAdBgPgBcSIHQYD4AUYEQCAMQRB0IgdBgICA/AdyIAZFDQEaIAcgBkENdHJBgICA/gdyDAELIAxBEHQiDCAHQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2pyIAcNABogDEGAgIDYA3IgBmdBEGsiB0EXdGsgBiAHQf//A3FBCGp0Qf///wNxcgu+EIkEISFDAACAPyEfAn8gCUEQdCAJQf//AXFFDQAaIAlB/wdxIQYgCUGAgAJxIQcgCUGA+AFxIglBgPgBRgRAIAdBEHQiCUGAgID8B3IgBkUNARogCSAGQQ10ckGAgID+B3IMAQsgB0EQdCIHIAlBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgCQ0AGiAHQYCAgNgDciAGZ0EQayIJQRd0ayAGIAlB//8DcUEIanRB////A3FyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRIR8LAn8CQCAaKAIAIgZBCGooAgAiCSAISwRAIAZBBGooAgAgCEEkbGoiBy8BHCEGQQAhCkEAIAcvAR4iCUH//wFxIgxBgPgBSw0CGkEAIAZB//8BcSIIQYD4AUsNAhogCcFBAEgNASAGIAlJIAbBQQBODQIaIAggCXJBAEcMAgsgCCAJQdTAxwAQjAcACyAGwUEASCAGIAlLcQshCCAJIAYgCBsgBiAMQYH4AUkbIQYCQCAHLwEgIglB//8BcSIMQYD4AUsNACAGQf//AXEiCEGA+AFLDQAgCcFBAE4EQCAGwUEATgRAIAkgBkH//wNxSyEKDAILIAggCXJBAEchCgwBCyAGwUEASCAJIAZB//8DcUlxIQoLIAcvARQhB0MAAIA/ISAgCyAQIA0gISAhkiAflCIfIB9bIB8CfyAJIAYgChsgBiAMQYH4AUkbIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQYgCUGAgAJxIQwgCUGA+AFxIglBgPgBRgRAIAxBEHQiCUGAgID8B3IgBkUNARogCSAGQQ10ckGAgID+B3IMAQsgDEEQdCIMIAlBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgCQ0AGiAMQYCAgNgDciAGZ0EQayIJQRd0ayAGIAlB//8DcUEIanRB////A3FyC74QiQQiIiAikgJ/IAdBEHQgB0H//wFxRQ0AGiAHQf8HcSEGIAdBgIACcSEJIAdBgPgBcSIHQYD4AUYEQCAJQRB0IglBgICA/AdyIAZFDQEaIAkgBkENdHJBgICA/gdyDAELIAlBEHQiCSAHQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2pyIAcNABogCUGAgIDYA3IgBmdBEGsiCUEXdGsgBiAJQf//A3FBCGp0Qf///wNxcgu+IiNDAACAP14EfSAjEMYFQ1T4LUCUQwAAgD+SkQUgIAuUYEVxIgYbKAIANgIAIA0gBkECdGohByARIBAgBkVBAnRqIglHBEAgC0EEayELIAIgB0cNAQsLIAkhESACIQwLIAcgDGsiBkUNACARIAwgBvwKAAALIBhBAXRBAXILIQlBASEGIA8iEUEBSw0ACwwBCyARIQYLIBdBjgJqIAZqIBI6AAAgF0EEaiAGQQJ0aiAJNgIAIAEgE0sEQCAGQQFqIREgDkEBdiATaiETIA4hCQwBCwsgCUEBcUUEQCAAIAEgAiADIAFBAXJnQQF0QT5zQQAgBRAyCyAXQdACaiQADwsgBiALQdTAxwAQjAcAC4MtBBl/BX0CfgF7IwBB0AJrIhckAEKAgICAgICAgMAAIAGtIiSAIiUgJH5CgICAgICAgIDAAFKtAn8gAUGBIE8EQEEBIAFBAXJnQR9zIgZBAXYgBkEBcWoiBnQgASAGdmpBAXYMAQtBwAAgASABQQF2ayIGIAZBwABPGwshGSAlfCEkIABBBGshHCAAQRBrIR0gAEEIaiEbQQEhCQJAA0BBASEOQQAhEiABIBNLBEAgACATQQJ0IhRqIQogE60iJQJ/AkAgASATayIMIBlJDQACQCAMQQJJBEAgDCEHDAELQwAAgD8hHwJ/AkAgCigCBCIGIAUoAgBBBGooAgAiB0EIaigCACILSQRAIAooAgAhDyAHQQRqKAIAIhUgBkEkbGoiBxCKBCEhIAcvARQiDkH//wFxRQRAIA5BEHQMAwsgDkH/B3EhByAOQYCAAnEhCCAOQYD4AXEiDkGA+AFGBEAgCEEQdCIOQYCAgPwHciAHRQ0DGiAOIAdBDXRyQYCAgP4HcgwDCyAIQRB0IQggDkUNASAOQQ10QYCAgPwAcSAHQQ10ckGAgIDAA2ogCHIMAgsMBwsgCEGAgIDYA3IgB2dBEGsiDkEXdGsgByAOQf//A3FBCGp0Qf///wNxcgu+IiBDAACAP14EQCAgEMYFQ1T4LUCUQwAAgD+SkSEfC0MAAIA/ISACfwJAIAsgD0sEQCAVIA9BJGxqIgcQigQhIiAHLwEUIg5B//8BcUUEQCAOQRB0DAMLIA5B/wdxIQcgDkGAgAJxIQ8gDkGA+AFxIg5BgPgBRgRAIA9BEHQiDkGAgID8B3IgB0UNAxogDiAHQQ10ckGAgID+B3IMAwsgD0EQdCEPIA5FDQEgDkENdEGAgID8AHEgB0ENdHJBgICAwANqIA9yDAILIA8gC0HUwMcAEIwHAAsgD0GAgIDYA3IgB2dBEGsiDkEXdGsgByAOQf//A3FBCGp0Qf///wNxcgu+IiNDAACAP14EQCAjEMYFQ1T4LUCUQwAAgD+SkSEgCwJAAkACQAJAICEgIZIgH5QiHyAfWyAfICIgIpIgIJRgRXEiGEUEQEECIQcgDEECRg0FIBsgE0ECdGohDwNAQwAAgD8hHwJ/AkAgCyAPKAIAIg5LBEAgFSAOQSRsaiIIEIoEISEgCC8BFCINQf//AXFFBEAgDUEQdAwDCyANQf8HcSEIIA1BgIACcSESIA1BgPgBcSINQYD4AUYEQCASQRB0Ig1BgICA/AdyIAhFDQMaIA0gCEENdHJBgICA/gdyDAMLIBJBEHQhEiANRQ0BIA1BDXRBgICA/ABxIAhBDXRyQYCAgMADaiAScgwCCyAOIAtB1MDHABCMBwALIBJBgICA2ANyIAhnQRBrIg1BF3RrIAggDUH//wNxQQhqdEH///8DcXILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhHwtDAACAPyEgAn8CQCAGIAtJBEAgFSAGQSRsaiIGEIoEISIgBi8BFCIIQf//AXFFBEAgCEEQdAwDCyAIQf8HcSEGIAhBgIACcSENIAhBgPgBcSIIQYD4AUYEQCANQRB0IghBgICA/AdyIAZFDQMaIAggBkENdHJBgICA/gdyDAMLIA1BEHQhDSAIRQ0BIAhBDXRBgICA/ABxIAZBDXRyQYCAgMADaiANcgwCCwwNCyANQYCAgNgDciAGZ0EQayIIQRd0ayAGIAhB//8DcUEIanRB////A3FyC74iI0MAAIA/XgRAICMQxgVDVPgtQJRDAACAP5KRISALICEgIZIgH5QiHyAfWyAfICIgIpIgIJRgRXENAyAPQQRqIQ8gDiEGIAwgB0EBaiIHRw0ACwwBCyAMQQJGDQJBAiEHIBsgE0ECdGohDwNAQwAAgD8hHwJ/AkAgCyAPKAIAIg5LBEAgFSAOQSRsaiIIEIoEISEgCC8BFCINQf//AXFFBEAgDUEQdAwDCyANQf8HcSEIIA1BgIACcSESIA1BgPgBcSINQYD4AUYEQCASQRB0Ig1BgICA/AdyIAhFDQMaIA0gCEENdHJBgICA/gdyDAMLIBJBEHQhEiANRQ0BIA1BDXRBgICA/ABxIAhBDXRyQYCAgMADaiAScgwCCyAOIAtB1MDHABCMBwALIBJBgICA2ANyIAhnQRBrIg1BF3RrIAggDUH//wNxQQhqdEH///8DcXILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhHwtDAACAPyEgAn8CQCAGIAtJBEAgFSAGQSRsaiIGEIoEISIgBi8BFCIIQf//AXFFBEAgCEEQdAwDCyAIQf8HcSEGIAhBgIACcSENIAhBgPgBcSIIQYD4AUYEQCANQRB0IghBgICA/AdyIAZFDQMaIAggBkENdHJBgICA/gdyDAMLIA1BEHQhDSAIRQ0BIAhBDXRBgICA/ABxIAZBDXRyQYCAgMADaiANcgwCCwwMCyANQYCAgNgDciAGZ0EQayIIQRd0ayAGIAhB//8DcUEIanRB////A3FyC74iI0MAAIA/XgRAICMQxgVDVPgtQJRDAACAP5KRISALICEgIZIgH5QiHyAfXCAfICIgIpIgIJRgcg0CIA9BBGohDyAOIQYgDCAHQQFqIgdHDQALCyAMIQcLIAcgGUkNAyAYRQ0CIAdBAkkEQEEBIQcMAwsgB0EBdiELIAogB0ECdCIGaiEPQQAhDiAHQQhJDQEgHSAGIBRqaiEGIAtB/P///wdxIg4hDANAIAogBv0AAgAgCv0AAgAiJv0NDA0ODwgJCgsEBQYHAAECA/0LAgAgBiAmICb9DQwNDg8ICQoLBAUGBwABAgP9CwIAIAZBEGshBiAKQRBqIQogDEEEayIMDQALIAsgDkYNAgwBCyAKQQhqIQ9BACEOQQEhC0ECIQcLIAAgDkECdCIMIBRqaiEGIAsgDmshDiAPIAxrQQRrIQwDQCAGKAIAIQsgBiAMKAIANgIAIAwgCzYCACAMQQRrIQwgBkEEaiEGIA5BAWsiDg0ACwsgB0EBdEEBcgwBCyAMIBkgDCAZSRtBAXQgBEUNABogCkEgIAwgDEEgTxsiBiACIANBAEEAIAUQMyAGQQF0QQFyCyIOQQF2IBNqrXwgJH4gEyAJQQF2a60gJXwgJH6FeachEgsCQAJAIBFBAkkNACAcIBNBAnQiBmohFSAAIAZqIR4DQCARQQFrIg8gF0GOAmpqLQAAIBJJDQECfwJAAkAgAyAXQQRqIA9BAnRqKAIAIgxBAXYiBiAJQQF2IgdqIhhPIAkgDHJBAXFFcUUEQCAAIBMgGGtBAnRqIREgDEEBcUUNAQwCCyAYQQF0DAILIBEgBiACIAMgBkEBcmdBAXRBPnNBACAFEDMLIAlBAXFFBEAgESAGQQJ0aiAHIAIgAyAHQQFyZ0EBdEE+c0EAIAUQMwsCQCAJQQJJIAxBAklyDQAgAyAHIAYgBiAHSyIMGyIHSQ0AIAUoAgAgESAGQQJ0aiEJIAdBAnQiBgRAIAIgCSARIAwbIAb8CgAACyACIAZqIQdBBGoiGigCACEUAkAgDEUEQCACIQwDQAJ/AkAgCSgCACIGIBRBCGooAgAiC0kEQCAUQQRqKAIAIhogBkEkbGoiDS8BHCEGQQAhCkEAIA0vAR4iCEH//wFxIhBBgPgBSw0CGkEAIAZB//8BcSIWQYD4AUsNAhogCMFBAEgNASAGIAhJIAbBQQBODQIaIAggFnJBAEcMAgsMCwsgBsFBAEggBiAIS3ELIRYgCCAGIBYbIAYgEEGB+AFJGyEGAkAgDS8BICIIQf//AXEiFkGA+AFLDQAgBkH//wFxIhBBgPgBSw0AIAjBQQBOBEAgBsFBAE4EQCAIIAZB//8DcUshCgwCCyAIIBByQQBHIQoMAQsgBsFBAEggCCAGQf//A3FJcSEKCyAMKAIAIRAgDS8BFCENAn8gCCAGIAobIAYgFkGB+AFJGyIKQf//AXFFBEAgCkEQdAwBCyAKQf8HcSEGIApBgIACcSEIIApBgPgBcSIKQYD4AUYEQCAIQRB0IgpBgICA/AdyIAZFDQEaIAogBkENdHJBgICA/gdyDAELIAhBEHQiCCAKQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2pyIAoNABogCEGAgIDYA3IgBmdBEGsiCkEXdGsgBiAKQf//A3FBCGp0Qf///wNxcgu+EIkEISFDAACAPyEfAn8gDUEQdCANQf//AXFFDQAaIA1B/wdxIQYgDUGAgAJxIQogDUGA+AFxIghBgPgBRgRAIApBEHQiCkGAgID8B3IgBkUNARogCiAGQQ10ckGAgID+B3IMAQsgCkEQdCIKIAhBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgCA0AGiAKQYCAgNgDciAGZ0EQayIKQRd0ayAGIApB//8DcUEIanRB////A3FyC74iIEMAAIA/XgRAICAQxgVDVPgtQJRDAACAP5KRIR8LAn8CQCALIBBLBEAgGiAQQSRsaiIILwEcIQZBACEKQQAgCC8BHiILQf//AXEiDUGA+AFLDQIaQQAgBkH//wFxIhBBgPgBSw0CGiALwUEASA0BIAYgC0kgBsFBAE4NAhogCyAQckEARwwCCyAQIAtB1MDHABCMBwALIAbBQQBIIAYgC0txCyEQIAsgBiAQGyAGIA1BgfgBSRshBgJAIAgvASAiC0H//wFxIg1BgPgBSw0AIAZB//8BcSIQQYD4AUsNACALwUEATgRAIAbBQQBOBEAgCyAGQf//A3FLIQoMAgsgCyAQckEARyEKDAELIAbBQQBIIAsgBkH//wNxSXEhCgsgCC8BFCEIQwAAgD8hICARIAkgDCAhICGSIB+UIh8gH1sgHwJ/IAsgBiAKGyAGIA1BgfgBSRsiC0H//wFxRQRAIAtBEHQMAQsgC0H/B3EhBiALQYCAAnEhCiALQYD4AXEiC0GA+AFGBEAgCkEQdCILQYCAgPwHciAGRQ0BGiALIAZBDXRyQYCAgP4HcgwBCyAKQRB0IgogC0ENdEGAgID8AHEgBkENdHJBgICAwANqciALDQAaIApBgICA2ANyIAZnQRBrIgtBF3RrIAYgC0H//wNxQQhqdEH///8DcXILvhCJBCIiICKSAn8gCEEQdCAIQf//AXFFDQAaIAhB/wdxIQYgCEGAgAJxIQsgCEGA+AFxIgpBgPgBRgRAIAtBEHQiC0GAgID8B3IgBkUNARogCyAGQQ10ckGAgID+B3IMAQsgC0EQdCILIApBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgCg0AGiALQYCAgNgDciAGZ0EQayILQRd0ayAGIAtB//8DcUEIanRB////A3FyC74iI0MAAIA/XgR9ICMQxgVDVPgtQJRDAACAP5KRBSAgC5RgRXEiBhsoAgA2AgAgEUEEaiERIAwgBkVBAnRqIgwgB0YNAiAJIAZBAnRqIgkgHkcNAAsMAQsgFSELA0ACfwJAIAdBBGsiDSgCACIGIBRBCGooAgAiB0kEQCAUQQRqKAIAIAZBJGxqIgwvARwhBkEAIQpBACAMLwEeIgdB//8BcSIIQYD4AUsNAhpBACAGQf//AXEiEEGA+AFLDQIaIAfBQQBIDQEgBiAHSSAGwUEATg0CGiAHIBByQQBHDAILIAYgB0HUwMcAEIwHAAsgBsFBAEggBiAHS3ELIRAgByAGIBAbIAYgCEGB+AFJGyEGAkAgDC8BICIHQf//AXEiFkGA+AFLDQAgBkH//wFxIghBgPgBSw0AIAfBQQBOBEAgBsFBAE4EQCAHIAZB//8DcUshCgwCCyAHIAhyQQBHIQoMAQsgBsFBAEggByAGQf//A3FJcSEKCyAJQQRrIhAoAgAhCCAMLwEUIQkCfyAHIAYgChsgBiAWQYH4AUkbIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQYgB0GAgAJxIQwgB0GA+AFxIgdBgPgBRgRAIAxBEHQiB0GAgID8B3IgBkUNARogByAGQQ10ckGAgID+B3IMAQsgDEEQdCIMIAdBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgBw0AGiAMQYCAgNgDciAGZ0EQayIHQRd0ayAGIAdB//8DcUEIanRB////A3FyC74QiQQhIUMAAIA/IR8CfyAJQRB0IAlB//8BcUUNABogCUH/B3EhBiAJQYCAAnEhByAJQYD4AXEiCUGA+AFGBEAgB0EQdCIJQYCAgPwHciAGRQ0BGiAJIAZBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgBkENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIAZnQRBrIglBF3RrIAYgCUH//wNxQQhqdEH///8DcXILviIgQwAAgD9eBEAgIBDGBUNU+C1AlEMAAIA/kpEhHwsCfwJAIBooAgAiBkEIaigCACIJIAhLBEAgBkEEaigCACAIQSRsaiIHLwEcIQZBACEKQQAgBy8BHiIJQf//AXEiDEGA+AFLDQIaQQAgBkH//wFxIghBgPgBSw0CGiAJwUEASA0BIAYgCUkgBsFBAE4NAhogCCAJckEARwwCCyAIIAlB1MDHABCMBwALIAbBQQBIIAYgCUtxCyEIIAkgBiAIGyAGIAxBgfgBSRshBgJAIAcvASAiCUH//wFxIgxBgPgBSw0AIAZB//8BcSIIQYD4AUsNACAJwUEATgRAIAbBQQBOBEAgCSAGQf//A3FLIQoMAgsgCCAJckEARyEKDAELIAbBQQBIIAkgBkH//wNxSXEhCgsgBy8BFCEHQwAAgD8hICALIBAgDSAhICGSIB+UIh8gH1sgHwJ/IAkgBiAKGyAGIAxBgfgBSRsiCUH//wFxRQRAIAlBEHQMAQsgCUH/B3EhBiAJQYCAAnEhDCAJQYD4AXEiCUGA+AFGBEAgDEEQdCIJQYCAgPwHciAGRQ0BGiAJIAZBDXRyQYCAgP4HcgwBCyAMQRB0IgwgCUENdEGAgID8AHEgBkENdHJBgICAwANqciAJDQAaIAxBgICA2ANyIAZnQRBrIglBF3RrIAYgCUH//wNxQQhqdEH///8DcXILvhCJBCIiICKSAn8gB0EQdCAHQf//AXFFDQAaIAdB/wdxIQYgB0GAgAJxIQkgB0GA+AFxIgdBgPgBRgRAIAlBEHQiCUGAgID8B3IgBkUNARogCSAGQQ10ckGAgID+B3IMAQsgCUEQdCIJIAdBDXRBgICA/ABxIAZBDXRyQYCAgMADanIgBw0AGiAJQYCAgNgDciAGZ0EQayIJQRd0ayAGIAlB//8DcUEIanRB////A3FyC74iI0MAAIA/XgR9ICMQxgVDVPgtQJRDAACAP5KRBSAgC5RgRXEiBhsoAgA2AgAgDSAGQQJ0aiEHIBEgECAGRUECdGoiCUcEQCALQQRrIQsgAiAHRw0BCwsgCSERIAIhDAsgByAMayIGRQ0AIBEgDCAG/AoAAAsgGEEBdEEBcgshCUEBIQYgDyIRQQFLDQALDAELIBEhBgsgF0GOAmogBmogEjoAACAXQQRqIAZBAnRqIAk2AgAgASATSwRAIAZBAWohESAOQQF2IBNqIRMgDiEJDAELCyAJQQFxRQRAIAAgASACIAMgAUEBcmdBAXRBPnNBACAFEDMLIBdB0AJqJAAPCyAGIAtB1MDHABCMBwAL0jICBX4VfyMAQSBrIgokAEHYtskAKAIAIgVFBEAQkwUhBQsgBSgCACAFKAIEKAIMEQQArULGzuuGt+rtrRKFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIRCkrbdnQWEQtKBqpur+oLXp39+IgFCgOgCg0IohiABQoCAlAODQhiGIAFCgICAqAqDQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRCgICAgICAgIBEhCADQtii0e/CqeW/LX6FIgNC7dyym42liczLAIUiAULYotHvwqnlvy1+IAFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRC0oGqm6v6gtenf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhIVCi/36l8fG15eGf4UiAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhELSgaqbq/qC16d/fiIBQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEIABC2KLR78Kp5b8tfoUiAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhEKIrJGn9oiAnLB/fiIBQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEIABCz47/x7vzxtR3foUgAIkhBCADQtaCzaGQ/ZSOS4UiAULYotHvwqnlvy1+IAFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRC0oGqm6v6gtenf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhIVC/MO8p8mV1eToAIUiAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhELSgaqbq/qC16d/fiIBQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEIABC2KLR78Kp5b8tfoUiAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhEKIrJGn9oiAnLB/fiIBQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEIABCz47/x7vzxtR3foUgAIkhAiADQvzDvKfJldXk6ACFIgFC2KLR78Kp5b8tfiABQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEQtKBqpur+oLXp39+IgFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhISFQu3cspuNpYnMywCFIgBCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRC0oGqm6v6gtenf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhCAAQtii0e/CqeW/LX6FIgBCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRCiKyRp/aIgJywf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhCAAQs+O/8e788bUd36FIACJIQAgA0KL/fqXx8bXl4Z/hSIDQtii0e/CqeW/LX4gA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEhULWgs2hkP2UjkuFIgFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCABQtii0e/CqeW/LX6FIgFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRCiKyRp/aIgJywf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCABQs+O/8e788bUd36FIAGJIQFB2LbJACgCACIFRQRAEJMFIQULIAUoAgAgBSgCBCgCDBEEACEFQbC1yQApAwAhA0GwtckAQgE3AwAgCkHwmsgA/QADAP0LAhBBzLXJACgCACEMQcy1yQAgCkEcaigCADYCAEHAtckAKAIAIQdBxLXJACgCACENQby1yQAgCv0AAgz9CwIAQbi1yQBBADYCAEHwtckAKAIAIRlB9LXJACgCACEOQaS2yQAoAgAhEUGotskAKAIAIRJBsLbJACgCACETQbS2yQAoAgAhFEG8tskAKAIAIRVBwLbJACgCACEWQci2yQAoAgAhF0HMtskAKAIAIRhB6LXJACAENwMAQeC1yQAgAjcDAEHYtckAIAA3AwBB0LXJACABNwMAQaC2yQBC6Ac3AwBBqLbJAEIENwMAQbC2yQBCgICAgMAANwMAQbi2yQBCADcDAEHAtskAQgQ3AwBByLbJAEKAgICAwAA3AwBB8LXJAEHwmsgA/QADAP0LAwBBmLbJACAFrULGzuuGt+rtrRKFIgFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIRCkrbdnQWEQtKBqpur+oLXp39+IgBCgOgCg0IohiAAQoCAlAODQhiGIABCgICAqAqDQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRCgICAgICAgIBEhCABQtii0e/CqeW/LX6FIgFC7dyym42liczLAIUiAELYotHvwqnlvy1+IABCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRC0oGqm6v6gtenf34iAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhIVCi/36l8fG15eGf4UiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhELSgaqbq/qC16d/fiIAQjiGIABCgP4Dg0IohoQgAEKAgPwHg0IYhiAAQoCAgPgPg0IIhoSEIABCCIhCgICA+A+DIABCGIhCgID8B4OEIABCKIhCgP4DgyAAQjiIhISEIAJC2KLR78Kp5b8tfoUiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhEKIrJGn9oiAnLB/fiIAQjiGIABCgP4Dg0IohoQgAEKAgPwHg0IYhiAAQoCAgPgPg0IIhoSEIABCCIhCgICA+A+DIABCGIhCgID8B4OEIABCKIhCgP4DgyAAQjiIhISEIAJCz47/x7vzxtR3foUgAok3AwBBkLbJACABQtaCzaGQ/ZSOS4UiAELYotHvwqnlvy1+IABCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRC0oGqm6v6gtenf34iAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhIVC/MO8p8mV1eToAIUiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhELSgaqbq/qC16d/fiIAQjiGIABCgP4Dg0IohoQgAEKAgPwHg0IYhiAAQoCAgPgPg0IIhoSEIABCCIhCgICA+A+DIABCGIhCgID8B4OEIABCKIhCgP4DgyAAQjiIhISEIAJC2KLR78Kp5b8tfoUiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhEKIrJGn9oiAnLB/fiIAQjiGIABCgP4Dg0IohoQgAEKAgPwHg0IYhiAAQoCAgPgPg0IIhoSEIABCCIhCgICA+A+DIABCGIhCgID8B4OEIABCKIhCgP4DgyAAQjiIhISEIAJCz47/x7vzxtR3foUgAok3AwBBiLbJACABQvzDvKfJldXk6ACFIgBC2KLR78Kp5b8tfiAAQjiGIABCgP4Dg0IohoQgAEKAgPwHg0IYhiAAQoCAgPgPg0IIhoSEIABCCIhCgICA+A+DIABCGIhCgID8B4OEIABCKIhCgP4DgyAAQjiIhISEQtKBqpur+oLXp39+IgBCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhISFQu3cspuNpYnMywCFIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIRC0oGqm6v6gtenf34iAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhCACQtii0e/CqeW/LX6FIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIRCiKyRp/aIgJywf34iAEI4hiAAQoD+A4NCKIaEIABCgID8B4NCGIYgAEKAgID4D4NCCIaEhCAAQgiIQoCAgPgPgyAAQhiIQoCA/AeDhCAAQiiIQoD+A4MgAEI4iISEhCACQs+O/8e788bUd36FIAKJNwMAQYC2yQAgAUKL/fqXx8bXl4Z/hSIBQtii0e/CqeW/LX4gAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhELSgaqbq/qC16d/fiIBQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEhULWgs2hkP2UjkuFIgBCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRC0oGqm6v6gtenf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhCAAQtii0e/CqeW/LX6FIgBCOIYgAEKA/gODQiiGhCAAQoCA/AeDQhiGIABCgICA+A+DQgiGhIQgAEIIiEKAgID4D4MgAEIYiEKAgPwHg4QgAEIoiEKA/gODIABCOIiEhIRCiKyRp/aIgJywf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhCAAQs+O/8e788bUd36FIACJNwMAQdC2yQBBADYCAAJAAkACQCADUA0AAkAgDUUNACAMBEAgB0EIaiEFIAcpAwBCf4VCgIGChIiQoMCAf4MhAyAHIQgDQCADUARAA0AgCEGAAmshCCAFKQMAIAVBCGohBUKAgYKEiJCgwIB/gyIDQoCBgoSIkKDAgH9RDQALIANCgIGChIiQoMCAf4UhAwsgCCADeqdBAnRB4ANxayILQQRrIgkoAgAiBiAGKAIAQQFrIgY2AgAgBkUEQCAJKAIAENIFCyALQRxrKAIAIgkEQCALQRhrKAIAIg9BBGsoAgAiBkF4cSIQIAlBAnQiCUEEQQggBkEDcSIGG2pJDQUgBkEAIBAgCUEnaksbDQYgDxCiAgsgC0EQaygCACIJBEAgC0EMaygCACIPQQRrKAIAIgZBeHEiECAJQQJ0IglBBEEIIAZBA3EiBhtqSQ0FIAZBACAQIAlBJ2pLGw0GIA8QogILIANCAX0gA4MhAyAMQQFrIgwNAAsLIA1BBXQiBSANakEpaiIGRQ0AIAcgBWsiB0EkaygCACIFQXhxIghBBEEIIAVBA3EiBRsgBmpJDQIgBUEAIAggBkEnaksbDQMgB0EgaxCiAgsgEQRAIBJBBGsoAgAiBUF4cSIHIBFBDGwiCEEEQQggBUEDcSIFG2pJDQIgBUEAIAcgCEEnaksbDQMgEhCiAgsgEwRAIBRBBGsoAgAiBUF4cSIHIBNBA3QiCEEEQQggBUEDcSIFG2pJDQIgBUEAIAcgCEEnaksbDQMgFBCiAgsgFQRAIBZBBGsoAgAiBUF4cSIHIBVBA3QiCEEEQQggBUEDcSIFG2pJDQIgBUEAIAcgCEEnaksbDQMgFhCiAgsCQCAORQ0AIA5BA3QiBSAOakERaiIGRQ0AIBkgBWsiB0EMaygCACIFQXhxIghBBEEIIAVBA3EiBRsgBmpJDQIgBUEAIAggBkEnaksbDQMgB0EIaxCiAgsgF0UNACAYQQRrKAIAIgVBeHEiByAXQQJ0IghBBEEIIAVBA3EiBRtqSQ0BIAVBACAHIAhBJ2pLGw0CIBgQogILIApBIGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC90rAhp/A34jAEGgCmsiAyQAAkACQAJAAkACQAJAAkACQCABKQMAIh1QRQRAIAEpAwgiH1BFBEAgASkDECIeUEUEQCAdQn+FIB5aBEAgHSAfWgRAIAEsABohEyABLgEYIQEgAyAdPgIAIANBAUECIB1CgICAgBBUIgUbNgKgASADQQAgHUIgiKcgBRs2AgRBACIFRQRAIANBCGpBAEGYAfwLAAsgAyAfPgKkASADQQFBAiAfQoCAgIAQVCIHGzYCxAIgA0EAIB9CIIinIAcbNgKoASAFRQRAIANBrAFqQQBBmAH8CwALIAMgHj4CyAIgA0EBQQIgHkKAgICAEFQiBxs2AugDIANBACAeQiCIpyAHGzYCzAIgBUUEQCADQdACakEAQZgB/AsACyADQfADakEAQZwB/AsAIANBATYC7AMgA0EBNgKMBSABrCAdIB58QgF9eX1CwprB6AR+QoChzaC0AnxCIIinIgXBIRECQCABQQBOBEAgAyABELkDGiADQaQBaiABELkDGiADQcgCaiABELkDGgwBCyADQewDakEAIAFrwRC5AxoLAkAgEUEASARAIANBACARa0H//wNxIgEQ9AEgA0GkAWogARD0ASADQcgCaiABEPQBDAELIANB7ANqIAVB//8BcRD0AQsgA0H8CGogA0GkAfwKAAAgAygC6AMiByADKAKcCiIBIAEgB0kbIgVBKE0EQAJAIAVFBEBBACEFDAELAkACQCAFQQFHBEAgBUEBcSAFQT5xIQsgA0H8CGohASADQcgCaiEEA0AgASAEKAIAIgogASgCAGoiDCAGQQFxaiIPNgIAIAFBBGoiBiAEQQRqKAIAIhQgBigCAGoiBiAKIAxLIAwgD0tyaiIMNgIAIAYgFEkgBiAMS3IhBiAEQQhqIQQgAUEIaiEBIAsgCEECaiIIRw0AC0UNAQsgCEECdCIBIANB/AhqaiIEIAYgA0HIAmogAWooAgAiBiAEKAIAaiIBaiIENgIAIAEgBkkgASAES3INAQwCCyAGRQ0BCyAFQShGDQ0gA0H8CGogBUECdGpBATYCACAFQQFqIQULIAMgBTYCnAogBSADKAKMBSIPIAUgD0sbIgFBKUkEQCABQQJ0IQECQAJAAn8CQANAIAFFDQEgAUEEayIBIANB7ANqaigCACIFIAEgA0H8CGpqKAIAIgRGDQALIAQgBUkgBCAFS2sMAQtBf0EAIANB/AhqIgUgASAFakcbCyATTgRAIAMoAqABIgZBKU8NAgJAIAZFBEBBACEGDAELIAZBAnQiDEEEayIBQQJ2QQFqIgRBA3EhBQJAIAFBDEkEQCADIQFCACEdDAELIARB/P///wdxIQQgAyEBQgAhHQNAIAEgATUCAEIKfiAdfCIdPgIAIAFBBGoiCSAJNQIAQgp+IB1CIIh8Ih0+AgAgAUEIaiIJIAk1AgBCCn4gHUIgiHwiHT4CACABQQxqIgkgCTUCAEIKfiAdQiCIfCIePgIAIB5CIIghHSABQRBqIQEgBEEEayIEDQALCyAFBEAgBUECdCEEA0AgASABNQIAQgp+IB18Ih4+AgAgAUEEaiEBIB5CIIghHSAEQQRrIgQNAAsLIB5CgICAgBBUDQAgBkEoRg0RIAMgDGogHT4CACAGQQFqIQYLIAMgBjYCoAEgAygCxAIiBUEpTw0OQQAhDCADAn9BACAFRQ0AGiAFQQJ0IghBBGsiAUECdkEBaiIEQQNxIQkCQCABQQxJBEAgA0GkAWohAUIAIR4MAQsgBEH8////B3EhBCADQaQBaiEBQgAhHgNAIAEgATUCAEIKfiAefCIdPgIAIAFBBGoiCyALNQIAQgp+IB1CIIh8Ih0+AgAgAUEIaiILIAs1AgBCCn4gHUIgiHwiHT4CACABQQxqIgsgCzUCAEIKfiAdQiCIfCIdPgIAIB1CIIghHiABQRBqIQEgBEEEayIEDQALCyAJBEAgCUECdCEEA0AgASABNQIAQgp+IB58Ih0+AgAgAUEEaiEBIB1CIIghHiAEQQRrIgQNAAsLIAUgHUKAgICAEFQNABogBUEoRg0RIANBpAFqIAhqIB4+AgAgBUEBags2AsQCIAcEQCAHQQJ0IgxBBGsiAUECdkEBaiIEQQNxIQUCQCABQQxJBEAgA0HIAmohAUIAIR4MAQsgBEH8////B3EhBCADQcgCaiEBQgAhHgNAIAEgATUCAEIKfiAefCIdPgIAIAFBBGoiCSAJNQIAQgp+IB1CIIh8Ih0+AgAgAUEIaiIJIAk1AgBCCn4gHUIgiHwiHT4CACABQQxqIgkgCTUCAEIKfiAdQiCIfCIdPgIAIB1CIIghHiABQRBqIQEgBEEEayIEDQALCyAFBEAgBUECdCEEA0AgASABNQIAQgp+IB58Ih0+AgAgAUEEaiEBIB1CIIghHiAEQQRrIgQNAAsLIB1CgICAgBBUBEAgAyAHIgw2AugDDAMLIAdBKEYNESADQcgCaiAMaiAePgIAIAdBAWohDAsgAyAMNgLoAwwBCyARQQFqIREgAygCoAEhBiAHIQwLQQAiAUUEQCADQZAFaiADQewDakGkAfwKAAALIANBkAVqQQEQuQMhFCABRQRAIANBtAZqIANB7ANqQaQB/AoAAAsgA0G0BmpBAhC5AyEVIAFFBEAgA0HYB2ogA0HsA2pBpAH8CgAACwJAAkACQAJAIANB2AdqQQMQuQMiFygCoAEiFiAGIAYgFkkbIgdBKE0EQCAUKAKgASEYIBUoAqABIRlBACEJA0AgCSELIAdBAnQhAQJ/AkACQAJAA0AgAUUNASABQQRrIgEgA2ooAgAiBSABIANB2AdqaigCACIERg0ACyAEIAVLDQEMAgsgFyADQdgHaiABakYNAQsgBiEHQQAMAQsCQCAHRQ0AQQEhBkEAIQgCQCAHQQFHBEAgB0EBcSAHQT5xIQogAyIBQdgHaiEEA0AgASABKAIAIg4gBCgCAEF/c2oiBSAGQQFxaiINNgIAIAFBBGoiBiAGKAIAIhAgBEEEaigCAEF/c2oiBiAFIA5JIAUgDUtyaiIFNgIAIAYgEEkgBSAGSXIhBiAEQQhqIQQgAUEIaiEBIAogCEECaiIIRw0AC0UNAQsgAyAIQQJ0IgFqIgUgBSgCACIFIAEgF2ooAgBBf3NqIgEgBmoiBDYCACABIAVJIAEgBEtyDQEMGAsgBkUNFwsgAyAHNgKgAUEICyEKIBkgByAHIBlJGyIFQSlPDRIgBUECdCEBAkACQAJAA0AgAUUNASABQQRrIgEgA2ooAgAiBCABIANBtAZqaigCACIGRg0ACyAEIAZPDQEgByEFDAILIBUgA0G0BmogAWpGDQAgByEFDAELAkAgBUUNAEEBIQZBACEIAkAgBUEBRwRAIAVBAXEgBUE+cSEOIAMiAUG0BmohBANAIAEgASgCACINIAQoAgBBf3NqIgcgBkEBcWoiEDYCACABQQRqIgYgBigCACISIARBBGooAgBBf3NqIgYgByANSSAHIBBLcmoiBzYCACAGIBJJIAYgB0tyIQYgBEEIaiEEIAFBCGohASAOIAhBAmoiCEcNAAtFDQELIAMgCEECdCIBaiIHIAcoAgAiByABIBVqKAIAQX9zaiIBIAZqIgQ2AgAgASAHSSABIARLcg0BDBgLIAZFDRcLIAMgBTYCoAEgCkEEciEKCyAYIAUgBSAYSRsiB0EpTw0RIAdBAnQhAQJAAkACQANAIAFFDQEgAUEEayIBIANqKAIAIgQgASADQZAFamooAgAiBkYNAAsgBCAGTw0BIAUhBwwCCyAUIANBkAVqIAFqRg0AIAUhBwwBCwJAIAdFDQBBASEGQQAhCAJAIAdBAUcEQCAHQQFxIAdBPnEhDiADIgFBkAVqIQQDQCABIAEoAgAiDSAEKAIAQX9zaiIFIAZBAXFqIhA2AgAgAUEEaiIGIAYoAgAiEiAEQQRqKAIAQX9zaiIGIAUgDUkgBSAQS3JqIgU2AgAgBiASSSAFIAZJciEGIARBCGohBCABQQhqIQEgDiAIQQJqIghHDQALRQ0BCyADIAhBAnQiAWoiBSAFKAIAIgUgASAUaigCAEF/c2oiASAGaiIENgIAIAEgBUkgASAES3INAQwYCyAGRQ0XCyADIAc2AqABIApBAmohCgsgDyAHIAcgD0kbIgVBKU8NEiAFQQJ0IQECQAJAAkADQCABRQ0BIAFBBGsiASADaigCACIEIAEgA0HsA2pqKAIAIgZGDQALIAQgBk8NASAHIQUMAgsgA0HsA2oiBCABIARqRg0AIAchBQwBCwJAIAVFDQBBASEGQQAhCAJAIAVBAUcEQCAFQQFxIAVBPnEhDiADIgFB7ANqIQQDQCABIAEoAgAiDSAEKAIAQX9zaiIHIAZBAXFqIhA2AgAgAUEEaiIGIAYoAgAiEiAEQQRqKAIAQX9zaiIGIAcgDUkgByAQS3JqIgc2AgAgBiASSSAGIAdLciEGIARBCGohBCABQQhqIQEgDiAIQQJqIghHDQALRQ0BCyADIAhBAnQiAWoiByAHKAIAIgcgA0HsA2ogAWooAgBBf3NqIgEgBmoiBDYCACABIAdJIAEgBEtyDQEMGAsgBkUNFwsgAyAFNgKgASAKQQFqIQoLIAtBEUYNBCACIAtqIApBMGo6AAAgAygCxAIiByAFIAUgB0kbIgFBKU8NEyALQQFqIQkgAUECdCEBAn8CQANAIAFFDQEgAUEEayIBIANqKAIAIgQgASADQaQBamooAgAiBkYNAAsgBCAGSyAEIAZJawwBC0F/QQAgA0GkAWoiBCABIARqRxsLIQ4gA0H8CGogA0GkAfwKAAAgDCADKAKcCiIBIAEgDEkbIgpBKEsNAwJAIApFBEBBACEKDAELQQAhCEEAIQYCQAJAIApBAUcEQCAKQQFxIApBPnEhEiADQfwIaiEBIANByAJqIQQDQCABIAQoAgAiGiABKAIAaiINIAZBAXFqIhs2AgAgAUEEaiIGIARBBGooAgAiHCAGKAIAaiIGIA0gGkkgDSAbS3JqIg02AgAgBiAcSSAGIA1LciEGIARBCGohBCABQQhqIQEgEiAIQQJqIghHDQALRQ0BCyAIQQJ0IgEgA0H8CGpqIgQgBiADQcgCaiABaigCACIGIAQoAgBqIgFqIgQ2AgAgASAGSSABIARLcg0BDAILIAZFDQELIApBKEYNFSADQfwIaiAKQQJ0akEBNgIAIApBAWohCgsgAyAKNgKcCiAKIA8gCiAPSxsiAUEpTw0TIAFBAnQhASATAn8CQANAIAFFDQEgAUEEayIBIANB7ANqaigCACIEIAEgA0H8CGpqKAIAIgZGDQALIAQgBksgBCAGSWsMAQtBf0EAIANB/AhqIgQgASAEakcbCyIBTCAOIBNOcUUEQCABIBNIDQMMEAtBACEIIAMCf0EAIAVFDQAaIAVBAnQiC0EEayIBQQJ2QQFqIgRBA3EhBgJAIAFBDEkEQCADIQFCACEdDAELIARB/P///wdxIQQgAyEBQgAhHQNAIAEgATUCAEIKfiAdfCIdPgIAIAFBBGoiCiAKNQIAQgp+IB1CIIh8Ih0+AgAgAUEIaiIKIAo1AgBCCn4gHUIgiHwiHT4CACABQQxqIgogCjUCAEIKfiAdQiCIfCIePgIAIB5CIIghHSABQRBqIQEgBEEEayIEDQALCyAGBEAgBkECdCEEA0AgASABNQIAQgp+IB18Ih4+AgAgAUEEaiEBIB5CIIghHSAEQQRrIgQNAAsLIAUgHkKAgICAEFQNABogBUEoRg0VIAMgC2ogHT4CACAFQQFqCyIGNgKgAQJAIAdFDQAgB0ECdCIIQQRrIgFBAnZBAWoiBEEDcSEFAkAgAUEMSQRAIANBpAFqIQFCACEdDAELIARB/P///wdxIQQgA0GkAWohAUIAIR0DQCABIAE1AgBCCn4gHXwiHT4CACABQQRqIgsgCzUCAEIKfiAdQiCIfCIdPgIAIAFBCGoiCyALNQIAQgp+IB1CIIh8Ih0+AgAgAUEMaiILIAs1AgBCCn4gHUIgiHwiHj4CACAeQiCIIR0gAUEQaiEBIARBBGsiBA0ACwsgBQRAIAVBAnQhBANAIAEgATUCAEIKfiAdfCIePgIAIAFBBGohASAeQiCIIR0gBEEEayIEDQALCyAeQoCAgIAQVARAIAchCAwBCyAHQShGDRUgA0GkAWogCGogHT4CACAHQQFqIQgLIAMgCDYCxAICQCAMRQRAQQAhDAwBCyAMQQJ0IgdBBGsiAUECdkEBaiIEQQNxIQUCQCABQQxJBEAgA0HIAmohAUIAIR4MAQsgBEH8////B3EhBCADQcgCaiEBQgAhHgNAIAEgATUCAEIKfiAefCIdPgIAIAFBBGoiCCAINQIAQgp+IB1CIIh8Ih0+AgAgAUEIaiIIIAg1AgBCCn4gHUIgiHwiHT4CACABQQxqIgggCDUCAEIKfiAdQiCIfCIdPgIAIB1CIIghHiABQRBqIQEgBEEEayIEDQALCyAFBEAgBUECdCEEA0AgASABNQIAQgp+IB58Ih0+AgAgAUEEaiEBIB1CIIghHiAEQQRrIgQNAAsLIB1CgICAgBBUDQAgDEEoRg0VIANByAJqIAdqIB4+AgAgDEEBaiEMCyADIAw2AugDIBYgBiAGIBZJGyIHQSlJDQALCwwPCyAOIBNODQsgA0EBELkDGiAPIAMoAqABIgEgASAPSRsiAUEpTw0QIAFBAnQhASADQQRrIQUDQCABRQ0DIAEgBWooAgAiByABQQRrIgEgA0HsA2pqKAIAIgRGDQALIAQgB0sNDAwLC0EAIApBKEGMg8IAEOoHAAtBEUERQdCUwgAQjAcACyADQewDaiIHIAEgB2pHDQkMCAtBACAGQShBjIPCABDqBwALDAsLDAkLQfCRwgBBN0GAlcIAEOsHAAtBuJLCAEE2QZCVwgAQ6wcAC0HkkMIAQRxBwJTCABDrBwALQbSQwgBBHUGwlMIAEOsHAAtB2I/CAEEcQaCUwgAQ6wcACyACIAlqIQcgCSEEAkACQANAIAQiAUUNASABQQFrIgQgAmoiBS0AAEE5Rg0ACyAFIAUtAABBAWo6AAAgASAJSw0BIAEgCUYNAiAJIAFrIgVFDQIgASACakEwIAX8CwAMAgsgAkExOgAAAkAgCwRAIAsEQCACQQFqQTAgC/wLAAsgC0EPSw0BCyAHQTA6AAAgEUEBaiERIAtBAmohCQwDCyAJQRFB4JTCABCMBwALIAEgCSAJQfiEwgAQ6gcACyALQRBNDQBBACAJQRFB8JTCABDqBwALIAAgETsBCCAAIAk2AgQgACACNgIAIANBoApqJAAPC0EAIAdBKEGMg8IAEOoHAAtBACAFQShBjIPCABDqBwALQQAgAUEoQYyDwgAQ6gcAC0EoQShBjIPCABCMBwALQe+CwgBBGkGMg8IAEOsHAAvQLgIdfwd+IwBBgAJrIh8kAAJAAkACQCABQSFPBEADQCADRQRAIAFBAXYgAWoiBgRAIAAhAwNAAkACfyABIAZBAWsiBk0EQCAGIAFrDAELIAMpAgAhISADIAMgBkEDdGoiACkCADcCACAAICE3AgBBAAsiAEEBdCIFQQFyIgIgASAGIAEgBkkbIgRPDQADQCAFQQJqIgUgBEkEQCACIAMgAkEDdGooAgAgAyAFQQN0aigCAElqIQILIAMgAEEDdGoiDSgCACIFIAMgAkEDdGoiCSgCACIATw0BIAkgBTYCACANIAA2AgAgDSgCBCEAIA0gCSgCBDYCBCAJIAA2AgQgAiEAIAJBAXQiBUEBciICIARJDQALCyAGDQALCwwFCyAAIAFBA3YiBUE4bGohBiAAIAVBBXRqIQQgA0EBayEDAn8gAUHAAE8EQCAAIAQgBiAFEMMGDAELIAAgBiAEIAAoAgAiDSAEKAIAIglJIgQgCSAGKAIAIgVJcxsgBCAFIA1LcxsLIABrIQQCfwJAIAJFDQAgAigCACAAIARqIgUoAgBJDQAgACkCACEhIAAgBSkCADcCACAFICE3AgAgAEEIaiECIAAoAgAhByAAKQIIISFBACEJIABBEGoiBCAAIAFBA3RqIghBCGsiHU8EfyACBQNAIARBCGsgAiAJQQN0aiINKQIANwIAIAQoAgAhBSANIAQpAgA3AgAgBCACIAkgBSAHTWoiBkEDdGoiDSkCADcCACAEQQhqIgkoAgAhBSANIAkpAgA3AgAgBiAFIAdNaiEJIARBEGoiBCAdSQ0ACyAEQQhrCyEFIAQgCEcEfwNAIAUgAiAJQQN0aiINKQIANwIAIAQoAgAhBSANIAQpAgA3AgAgCSAFIAdNaiEJIAQhBSAEQQhqIgQgCEcNAAsgBEEIawUgBQsgAiAJQQN0aiICKQIANwIAIAIgITcCACAJICGnIAdNaiIFIAFPDQQgACkCACEhIAAgACAFQQN0aiICKQIANwIAIAIgITcCACABIAVBAWoiAmshASAAIAJBA3RqIQBBAAwBCyAAKQIAISEgACAAIARqIgUpAgA3AgAgBSAhNwIAIABBCGohDSAAKAIAIQogACkCCCEhQQAhCSAAQRBqIgQgACABQQN0aiIHQQhrIghPBH8gDQUDQCAEQQhrIA0gCUEDdGoiBikCADcCACAEKAIAIQUgBiAEKQIANwIAIAQgDSAJIAUgCklqIh1BA3RqIgYpAgA3AgAgBEEIaiIJKAIAIQUgBiAJKQIANwIAIB0gBSAKSWohCSAEQRBqIgQgCEkNAAsgBEEIawshBSAEIAdHBH8DQCAFIA0gCUEDdGoiBikCADcCACAEKAIAIQUgBiAEKQIANwIAIAkgBSAKSWohCSAEIQUgBEEIaiIEIAdHDQALIARBCGsFIAULIA0gCUEDdGoiBSkCADcCACAFICE3AgAgCSAhpyAKSWoiBCABTw0DIAApAgAhISAAIAAgBEEDdGoiBSkCADcCACAFICE3AgAgACAEIAIgAxBYIAEgBEF/c2ohASAFQQhqIQAgBQshAiABQSFPDQALCyABQQJJDQIgASABQQF2IiAgAUESSSIdGyEJIAEgIGshDSAAICBBA3RqIQMgACECA0AgCQJ/IAlBDE0EQEEBIAlBCE0NARogAkEYaiIPIAIgAigCGCIGIAIoAgAiBEkiBRspAgAhISACIAIgDyAFGygCBDYCHCACIAYgBCAEIAZJGyIQNgIYIAIgITcCACACQQhqIhogAkE4aiIUIAIoAjgiCCACKAIIIgZJIgQbKAIEIQUgAiACQThBCCAEG2opAgAiIjcCCCACIAU2AjwgAiAIIAYgBiAISRsiBzYCOCACQShBECACKAIoIgYgAigCECIESSIFG2opAgAhJSACIAJBEGoiEiACQShqIhEgBRsoAgQ2AiwgAiAGIAQgBCAGSRsiCzYCKCACICU3AhAgAkHAAEEgIAIoAkAiBiACKAIgIgRJIgUbaikCACEjIAIgAkEgaiIOIAJBQGsiFSAFGygCBDYCRCACIAYgBCAEIAZJGyIINgJAIAIgIzcCICAUIAIgByAhpyIESSIFGykCACEkIAIgAiAUIAUbKAIENgI8IAIgByAEIAQgB0kbIgw2AjggAiAkNwIAIAIgEiAOICOnIgYgJaciBEkiBRsoAgQ2AiQgAiAGIAQgBCAGSRsiCjYCICACICMgJSAFGyIhNwIQIAJBwABBGCAIIBBJIgUbaikCACElIAIgDyAVIAUbKAIENgJEIAIgCCAQIAggEEsbIgc2AkAgAiAlNwIYIAJBMEEoIAIoAjAiBCALSSIFG2opAgAhIyACIBEgAkEwaiIbIAUbKAIENgI0IAIgBCALIAQgC0sbIgs2AjAgAiAjNwIoIAIgAiASICGnIgYgJKciBEkiBRsoAgQ2AhQgAiAGIAQgBCAGSRsiFjYCECACICEgJCAFGyIkNwIAIAIgGiAPICWnIgYgIqciBEkiBRsoAgQ2AhwgAiAGIAQgBCAGSRsiCDYCGCACICUgIiAFGyIiNwIIIAIgDiARIAogI6ciBEsiBRsoAgQ2AiwgAiAEIAogBCAKSxsiCjYCKCACICMgAikCICAFGyIhNwIgIAJBwABBOCAHIAxJIgUbaikCACElIAIgFCAVIAUbKAIENgJEIAIgByAMIAcgDEsbIhA2AkAgAiAlNwI4IAIgGiAOICGnIgYgIqciBEkiBRsoAgQ2AiQgAiAGIAQgBCAGSRsiBzYCICACICEgIiAFGyIiNwIIIAJBMEEYIAggC0siBRtqKQIAISMgAiAPIBsgBRsoAgQ2AjQgAiALIAggCCALSRsiCDYCMCACICM3AhggAiARIBQgCiAlpyIESyIFGygCBDYCPCACIAQgCiAEIApLGyIMNgI4IAIgJSACKQIoIAUbIiE3AiggAiACIBogIqciBiAkpyIESSIFGygCBDYCDCACIAYgBCAEIAZJGyILNgIIIAIgIiAkIAUbNwIAIA4gEiAHIBZJIgUbKQIAISIgAiASIA4gBRsoAgQ2AiQgAiAHIBYgByAWSxsiCjYCICACICI3AhAgAiAPIBEgIaciBiAjpyIESSIFGygCBDYCLCACIAYgBCAEIAZJGyIHNgIoIAIgISAjIAUbIiE3AhggAkHAAEEwIAggEEsiBRtqKQIAISMgAiAbIBUgBRsoAgQ2AkQgAiAQIAggCCAQSRs2AkAgAiAjNwIwIAIgEiAPICGnIgYgIqciBEkiBRsoAgQ2AhwgAiAGIAQgBCAGSRsiCDYCGCACICEgIiAFGyIiNwIQIBEgDiAHIApJIgUbKQIAISQgAiAOIBEgBRsoAgQ2AiwgAiAHIAogByAKSxsiBjYCKCACICQ3AiAgAikCOCEhIAIgGyAUIAwgI6ciBEkiBRsoAgQ2AjwgAiAMIAQgBCAMSRs2AjggAiAhICMgBRsiITcCMCACIBogEiALICKnIgRLIgUbKAIENgIUIAIgBCALIAQgC0sbNgIQIAIgIiACKQIIIAUbNwIIIAIgDyAOIAggJKciBEsiBRsoAgQ2AiQgAiAEIAggBCAISxs2AiAgAiAkIAIpAhggBRs3AhggAiARIBsgBiAhpyIESyIFGygCBDYCNCACIAQgBiAEIAZLGzYCMCACICEgAikCKCAFGzcCKEEJDAELIAJB4ABqIhogAiACKAJgIgYgAigCACIESSIFGykCACEhIAIgAiAaIAUbKAIENgJkIAIgBiAEIAQgBkkbIhs2AmAgAiAhNwIAIAJB0ABBCCACKAJQIgYgAigCCCIESSIFG2opAgAhJCACIAJBCGoiFCACQdAAaiIeIAUbKAIENgJUIAIgBiAEIAQgBkkbIhU2AlAgAiAkNwIIIAJByABBECACKAJIIgYgAigCECIESSIFG2opAgAhIyACIAJBEGoiDiACQcgAaiIPIAUbKAIENgJMIAIgBiAEIAQgBkkbIhY2AkggAiAjNwIQIAJBOEEYIAIoAjgiBiACKAIYIgRJIgUbaikCACEiIAIgAkEYaiIXIAJBOGoiESAFGygCBDYCPCACIAYgBCAEIAZJGyIMNgI4IAIgIjcCGCACQdgAQSggAigCWCIGIAIoAigiBEkiBRtqKQIAISEgAiACQShqIhwgAkHYAGoiEiAFGygCBDYCXCACIAYgBCAEIAZJGyILNgJYIAIgITcCKCACQcAAQTAgAigCQCIGIAIoAjAiBEkiBRtqKQIAISEgAiACQTBqIhMgAkFAayIYIAUbKAIENgJEIAIgBiAEIAQgBkkbIgc2AkAgAiAhNwIwIAIgFCATICGnIgYgJKciBEkiBRsoAgQ2AjQgAiAGIAQgBCAGSRsiCjYCMCACICEgJCAFGyIkNwIIIAIgDiAXICKnIgYgI6ciBEkiBRsoAgQ2AhwgAiAGIAQgBCAGSRsiCDYCGCACICIgIyAFGyIiNwIQIAJBIGoiGSASIAsgAigCICIGSSIEGygCBCEFIAIgAkHYAEEgIAQbaikCACIhNwIgIAIgBTYCXCACIAsgBiAGIAtJGyIQNgJYIAJByABBOCAMIBZLIgUbaikCACEmIAIgESAPIAUbKAIENgJMIAIgFiAMIAwgFkkbIgw2AkggAiAmNwI4IAJB0ABBwAAgByAVSyIFG2opAgAhJSACIBggHiAFGygCBDYCVCACIBUgByAHIBVJGyIHNgJQIAIgJTcCQCACIAIgGSACKAIAIgYgIaciBEsiBRsoAgQ2AiQgAiAEIAYgBCAGSxsiCzYCICACICEgAikCACAFGzcCACACIBQgDiAipyIGICSnIgRJIgUbKAIENgIUIAIgBiAEIAQgBkkbIhU2AhAgAiAiICQgBRs3AgggEyAXIAggCksiBRspAgAhIyACIBcgEyAFGygCBDYCNCACIAogCCAIIApJGyIKNgIwIAIgIzcCGCACIBEgGCAlpyIGICanIgRJIgUbKAIENgJEIAIgBiAEIAQgBkkbIgg2AkAgAiAlICYgBRsiJDcCOCACQdAAQcgAIAcgDEkiBRtqKQIAISIgAiAPIB4gBRsoAgQ2AlQgAiAHIAwgByAMSxsiDDYCUCACICI3AkggAkHgAEHYACAQIBtLIgUbaikCACEhIAIgEiAaIAUbKAIENgJkIAIgGyAQIBAgG0kbIgc2AmAgAiAhNwJYIBMgGSAKIAtJIgUbKQIAISYgAiAZIBMgBRsoAgQ2AjQgAiAKIAsgCiALSxsiCzYCMCACICY3AiAgAiAcIA8gAigCKCIGICKnIgRLIgUbKAIENgJMIAIgBCAGIAQgBksbIgo2AkggAiAiIAIpAiggBRsiIjcCKCACIBggEiAIICGnIgRLIgUbKAIENgJcIAIgBCAIIAQgCEsbIgg2AlggAiAhIAIpAkAgBRsiITcCQCACQeAAQdAAIAcgDEkiBRtqKQIAIScgAiAeIBogBRsoAgQ2AmQgAiAHIAwgByAMSxs2AmAgAiAnNwJQIAIgAiAcIAIoAgAiBiAipyIESyIFGygCBDYCLCACIAQgBiAEIAZLGyIHNgIoIAIgIiACKQIAIAUbIiU3AgAgAiAXIBggIaciBiAjpyIESSIFGygCBDYCRCACIAYgBCAEIAZJGyIWNgJAIAIgISAjIAUbIiM3AhggAiAZIBEgJKciBiAmpyIESSIFGygCBDYCPCACIAYgBCAEIAZJGyIMNgI4IAIgJCAmIAUbIiQ3AiAgEiATIAggC0kiBRspAgAhJiACIBMgEiAFGygCBDYCXCACIAggCyAIIAtLGyIQNgJYIAIgJjcCMCACIA8gHiAKICenIgRLIgUbKAIENgJUIAIgBCAKIAQgCksbIgs2AlAgAiAnIAIpAkggBRsiIjcCSCACKQIIISEgAiACIBQgAigCCCIGICWnIgRJIgUbKAIENgIMIAIgBiAEIAQgBkkbIgg2AgggAiAhICUgBRs3AgAgHCAOIAcgFUkiBRspAgAhJyACIA4gHCAFGygCBDYCLCACIAcgFSAHIBVLGyIKNgIoIAIgJzcCECACIBMgDyAipyIGICanIgRJIgUbKAIENgJMIAIgBiAEIAQgBkkbIgc2AkggAiAiICYgBRsiITcCMCAYIBEgDCAWSyIFGykCACEmIAIgESAYIAUbKAIENgJEIAIgFiAMIAwgFkkbIgw2AkAgAiAmNwI4IBIgHiALIBBLIgUbKQIAISUgAiAeIBIgBRsoAgQ2AlwgAiAQIAsgCyAQSRs2AlggAiAlNwJQIAIgFCAXIAggI6ciBEsiBRsoAgQ2AhwgAiAEIAggBCAISxsiCzYCGCACICMgAikCCCAFGyIjNwIIIAIgDiAZICSnIgYgJ6ciBEkiBRsoAgQ2AiQgAiAGIAQgBCAGSRsiCDYCICACICQgJyAFGyIiNwIQIAIgHCATIAogIaciBEsiBRsoAgQ2AjQgAiAEIAogBCAKSxsiCjYCMCACICEgAikCKCAFGyIhNwIoIAIgDyAeIAcgJaciBEsiBRsoAgQ2AlQgAiAEIAcgBCAHSxs2AlAgAiAlIAIpAkggBRsiJDcCSCACIBQgDiAipyIGICOnIgRJIgUbKAIENgIUIAIgBiAEIAQgBkkbIgc2AhAgAiAiICMgBRs3AgggGSAXIAggC0kiBRspAgAhIiACIBcgGSAFGygCBDYCJCACIAggCyAIIAtLGyIINgIgIAIgIjcCGCACIBwgESAmpyIGICGnIgRJIgUbKAIENgI8IAIgBiAEIAQgBkkbIgY2AjggAiAmICEgBRsiITcCKCAYIBMgCiAMSyIFGykCACEjIAIgEyAYIAUbKAIENgJEIAIgDCAKIAogDEkbIgo2AkAgAiAjNwIwIAIgDiAXIAcgIqciBEsiBRsoAgQ2AhwgAiAEIAcgBCAHSxsiBzYCGCACICIgAikCECAFGzcCECACIBkgHCAIICGnIgRLIgUbKAIENgIsIAIgBCAIIAQgCEsbIgg2AiggAiAhIAIpAiAgBRsiIjcCICACKQI4ISEgAiATIBEgBiAjpyIESSIFGygCBDYCPCACIAYgBCAEIAZJGzYCOCACICEgIyAFGyIhNwIwIBggDyAKICSnIgZLIgQbKAIEIQUgAiAGIAogBiAKSxs2AkggAiAFNgJMIAIgJCACKQJAIAQbNwJAIAIgFyAZIAcgIqciBEsiBRsoAgQ2AiQgAiAEIAcgBCAHSxs2AiAgAiAiIAIpAhggBRs3AhggAiAcIBMgCCAhpyIESyIFGygCBDYCNCACIAQgCCAEIAhLGzYCMCACICEgAikCKCAFGzcCKEENCyIFSQ0BIAUgCUcEQCACIAlBA3RqIQYgAiAFQQN0IglqIQUDQCAFKAIAIgcgBUEIaygCAEkEQCAFNQIEISEgCSEEAn8DQCACIARqIgggCEEIaykCADcCACACIARBCEYNARogBEEIayEEIAcgCEEQaygCAEkNAAsgAiAEagsgB60gIUIghoQ3AgALIAlBCGohCSAFQQhqIgUgBkcNAAsLIB0NAyAAIAJGIA0hCSADIQINAAsgAkEIayEJIAAgAUEDdEEIayIFaiECIAUgH2ohBSAfIQ0gACEEA0AgDSADIAQgAygCACILIAQoAgAiCkkiBxspAgA3AgAgBSAJIAIgAigCACIIIAkoAgAiHUkiBhspAgA3AgAgBUEIayEFIA1BCGohDSAJQXhBACAGG2ohCSACQXhBACAIIB1PG2ohAiAEIAogC01BA3RqIQQgAyAHQQN0aiEDICBBAWsiIA0ACyAJQQhqIQkgAUEBcQR/IA0gBCADIAQgCUkiBRspAgA3AgAgAyAEIAlPQQN0aiEDIAQgBUEDdGoFIAQLIAlHIAMgAkEIakdyDQEgAUEDdCIBRQ0CIAAgHyAB/AoAAAwCCwALEIAIAAsgH0GAAmokAAvBNgIWfwR+IwBBsAVrIgIkACACQegAaiABQQhqKAIAIgM2AgAgAiABKQIAIhk3AmAgAkGAAToAbCACQQA2AlwgAkKAgICAEDcCVCAZpyEGAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAigCZCIEIANLBEADQCADIAZqLQAAIgpBCWsiAUEXS0EBIAF0QZOAgARxRXINAiAEIANBAWoiA0cNAAsgAiAENgJoIAQhAwsgAkHIAGogBiAEIANBAWoiASAEIAEgBEkbEPkBIAIoAkwhASACKAJIIQtBFBBxIgMNAQwKCyACIAM2AmgCQCAKQdsARwRAIApB+wBGDQEgAkHUAGogAkGvBWpB6MDBABDuASEFDAgLIAJB/wA6AGwgAiADQQFqNgJoIAJBAToAsAQgAiACQdQAajYCrAQgAkGYA2ogAkGsBGoQnwMgAi0AmANBAUYEQCACKAKcAyEFQQIhCAwGCwJAAkACQAJAAkACQAJAAkACQAJAAkAgAi0AmQNBAUYEQCACQQhqIAIoAqwEEJUDIAIoAgwhAyACKAIIQQFxBEAgAyEFQQIhCAwSCyACQZgDaiACQawEahCfAyACLQCYA0EBRgRAIAIoApwDIQVBAiEIDBILIAItAJkDQQFHDQMgAigCrAQQvAIiBQ0BIAJBmANqIAJBrARqEJ8DIAItAJgDQQFHDQIgAigCnAMhBUECIQgMEQtBAEH4/MAAQYD9wAAQ2wYhBQtBAiEIDA8LIAItAJkDQQFHDQIgAkGYA2ogAigCrAQQuwMgAigCmANBAUcNASACKAKcAyEFQQIhCAwOC0EBQfj8wABBgP3AABDbBiEFQQIhCAwNCyACKQOgAyEZIAJBmANqIAJBrARqEJ8DIAItAJgDQQFGBEAgAigCnAMhBUECIQgMDQsgAi0AmQNBAUcNAiACQZgDaiACKAKsBBClAiACKAKYAyIQQQJHDQEgAigCnAMhBUECIQgMDAtBAkH4/MAAQYD9wAAQ2wYhBUECIQgMCwsgAigCnAMhDyACQZgDaiIFIAJBrARqEJ8DIAItAJgDDQkgAi0AmQNBAUcNAiAFIAIoAqwEEIECIAItAJgDQQFHDQEgAigCnAMhBUECIQgMCgtBA0H4/MAAQYD9wAAQ2wYhBUECIQgMCQsgAi0AmQMhASACQZgDaiACQawEahCfAyACLQCYA0EBRgRAIAIoApwDIQVBAiEIDAkLIAItAJkDQQFHDQEgAkGYA2ogAigCrAQQpQJBAiEIIAIoApgDIgRBAkYEQCACKAKcAyEFDAkLIAIoApwDIQYgAkGYA2ohByMAQRBrIgUkACAFIAJBrARqIgwQnwMCQCAFLQAAQQFGBEAgByAFKAIENgIIIAdCAjcDAAwBCyAFLQABRQRAIAdCADcDAAwBCyAFIAwoAgAQuwMgBSgCAEEBRgRAIAcgBSgCBDYCCCAHQgI3AwAMAQsgByAFKQMINwMIIAdCATcDAAsgBUEQaiQAIAIoAqADIQcgAikDmAMiGEICUg0CIAchBQwIC0EEQfj8wABBgP3AABDbBiEFQQIhCAwHC0EFQfj8wABBgP3AABDbBiEFQQIhCAwGCwJAAkAgGKdBAXEEQCACNQKkAyEYIAJBmANqIQojAEEQayIFJAAgBUEEaiACQawEaiIMEJ8DAkAgBS0ABEEBRgRAIAogBSgCCDYCBCAKQYGAgIB4NgIADAELIAUtAAVFBEAgCkGAgICAeDYCAAwBCyAFQQRqIAwoAgAQdyAFKAIEQYCAgIB4RgRAIAogBSgCCDYCBCAKQYGAgIB4NgIADAELIAogBSkCBDcCACAKQQhqIAVBDGooAgA2AgALIAVBEGokACACKAKcAyEFIAIoApgDIgpBgICAgHhrDgIBCAILQQZB+PzAAEGA/cAAENsGIQUMBwtBB0H4/MAAQYD9wAAQ2wYhBQwGCyACIAIoAqADNgK8BCACIAU2ArgEIAIgCjYCtAQgAkGYA2oiBSACQawEaiIMEOoFIAIoApwDIQogAigCmAMiC0EERg0CIAJB8ARqIAJB0ANqKAIANgIAIAJB4ARqIAJBwANq/QACAP0LAwAgAkHQBGogAkGwA2r9AAIA/QsDACACIAL9AAKgA/0LA8AEAkACQAJAAkAgC0EDRwRAIwBBEGsiCSQAIAlBCGogDBCfAwJAIAktAAhBAUYEQCAFIAkoAgw2AgQgBUEDNgIADAELIAktAAlFBEAgBUECNgIADAELIAlBCGogDCgCABCfBCAJKAIIIgxBAkYEQCAFIAkoAgw2AgQgBUEDNgIADAELIAUgCSgCDDYCBCAFIAw2AgALIAlBEGokACACKAKcAyIJIQUgAigCmAMiFUECaw4CAggBC0EIQfj8wABBgP3AABDbBiEFDAcLIAJBmANqIQwjAEEQayIFJAAgBUEEaiACQawEaiINEJ8DAkAgBS0ABEEBRgRAIAwgBSgCCDYCBCAMQYKAgIB4NgIADAELIAUtAAVFBEAgDEGBgICAeDYCAAwBCyAFQQRqIA0oAgAQ3AIgBSgCBEGBgICAeEYEQCAMIAUoAgg2AgQgDEGCgICAeDYCAAwBCyAMIAUpAgQ3AgAgDEEIaiAFQQxqKAIANgIACyAFQRBqJAAgAigCnAMhBSACKAKYAyINQf////8Hag4CAgYBC0EJQfj8wABBgP3AABDbBiEFDAULIAetIBhCIIaEIRggAigCoAMhFiACQdgCaiACQbwEaigCADYCACACQfACaiACQdAEav0AAwD9CwMAIAJBgANqIAJB4ARq/QADAP0LAwAgAkGQA2ogAkHwBGooAgA2AgAgAiACKQK0BDcD0AIgAiAC/QADwAT9CwPgAiAFIQ4gDyEFIBAhCAwGC0EKQfj8wABBgP3AABDbBiEFDAMLIAJB/wA6AGwgAiADQQFqNgJoIAJBAToAuAQgAiACQdQAajYCtAQgAkGgA2ohE0GBgICAeCEKQYCAgIB4IQlBAiEHQQMhEEECIQhBAyEUQQIhEQJAAkADQAJAIAMhCyAGIQEgAkGYA2ogAkG0BGoQ0QIgAi0AmANBAUYEQCACKAKcAyEEDAELAn8CQAJAAkACQAJAAkAgAi0AmQNBAUYEQCACKAK0BCIDQQA2AgggAyADKAIUQQFqNgIUIAJBmANqIANBDGogAxCCAiACKAKcAyEEIAIoApgDQQJGDQgCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAqADQQRrDgoDAAUBGgQaBhoCGgsgBEGr/MAAQQUQ2wdFDQggBEGw/MAAQQUQ2wcNGSARQQJGDQlBsPzAAEEFEJ8HIQQMGwsgBEGk/MAAQQcQ2wdFDQUgBEGG6MAAQQcQ2wdFDQkgBEH3lccAQQcQ2wcNGCAKQYGAgIB4Rg0RQfeVxwBBBxCfByEEIApBgICAgHhyQYCAgIB4Rg0cIA4gCkEBEKIHDBwLIARBvvzAAEENENsHRQ0KIARBmO3AAEENENsHDRcgEEEDRg0MQZjtwABBDRCfByEEDBkLIAQoAABB9PLBqwZGDQQMFgsgBEG1/MAAQQkQ2wcNFSAIQQJGDQdBtfzAAEEJEJ8HIQQMFwsgBEH998AAQQYQ2wcNFCAJQYCAgIB4Rg0IQf33wABBBhCfByEEDBYLIARBy/zAAEELENsHDRMgB0ECRg0JQcv8wABBCxCfByEEDBULIA1FDQ1BpPzAAEEHEJ8HIQQMFAsgEg0QIAMoAgwhEgJAAkAgAygCFCIEIAMoAhAiBkkEQANAAkAgBCASai0AAEEJaw4yAAADAwADAwMDAwMDAwMDAwMDAwMDAwMAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAxIDCyADIARBAWoiBDYCFCAEIAZHDQALIAYhBAsgAkEgaiASIAYgBEEBaiIDIAYgAyAGSRsQ+QEgAigCJCEDIAIoAiAhBkEUEHEiBEUNIiAEQQM2AgAMAQsgAkEYaiASIAYgBEEBaiIDIAYgAyAGSRsQ+QEgAigCHCEDIAIoAhghBkEUEHEiBEUNISAEQQY2AgALIAQgBjYCDCAEIAM2AhAMEwsgGlBFBEBBq/zAAEEFEJ8HIQQMEwsgAkGYA2ogAxCrBSACKQOgAyEYQgEhGiALIQMgAigCmANBAUcNEyACKAKcAyEEDBILIAJBmANqIAMQrgUgCyEDIAIoApwDIgUhBCACKAKYAyIRQQJHDRIMEQsgFEEDRwRAQYbowABBBxCfByEEDBELIAJBmANqIAMQrAUgAi0AmQMhFCALIQMgAi0AmANBAUcNESACKAKcAyEEDBALIAJBmANqIAMQrgUgCyEDIAIoApwDIhUhBCACKAKYAyIIQQJHDRAMDwsgG1BFBEBBvvzAAEENEJ8HIQQMDwsgAkGYA2ogAxCrBSACKQOgAyEZQgEhGyALIQMgAigCmANBAUcNDyACKAKcAyEEDA4LIAMoAgwhCQJAAkACQAJAIAMoAhQiBCADKAIQIgZJBEADQAJAIAQgCWotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgAyAEQQFqIgQ2AhQgBCAGRw0ACyAGIQQLIAJBMGogCSAGIARBAWoiAyAGIAMgBkkbEPkBIAIoAjQhBCACKAIwIQZBFBBxIgNFDR4gA0EDNgIADAELIAJBKGogCSAGIARBAWoiAyAGIAMgBkkbEPkBIAIoAiwhBCACKAIoIQZBFBBxIgNFDR0gA0EGNgIACyADIAY2AgwgAyAENgIQDAELIAMgBEEBajYCFCACQZgDaiADEHcgAigCoAMhBiACKAKcAyEDIAIoApgDIglBgICAgHhHDQ8LQYCAgIB4IQkgAyEEDA0LIAJBmANqIAMQrwUgAigCnAMhDyACKAKYAyIQQQNHDQEgDyEEDAwLIAMoAgwhBgJAAkACQCADKAIUIgQgAygCECIHSQRAA0ACQCAEIAZqLQAAQQlrDjIAAAMDAAMDAwMDAwMDAwMDAwMDAwMDAwADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBQMLIAMgBEEBaiIENgIUIAQgB0cNAAsgByEECyACQUBrIAYgByAEQQFqIgMgByADIAdJGxD5ASACKAJEIQMgAigCQCEGQRQQcSIERQ0bIARBAzYCAAwBCyACQThqIAYgByAEQQFqIgMgByADIAdJGxD5ASACKAI8IQMgAigCOCEGQRQQcSIERQ0aIARBBjYCAAsgBCAGNgIMIAQgAzYCEAwMCyADIARBAWo2AhQgAkGYA2ogAxCfBCACKAKcAyEMIAIoApgDIgdBAkcNASAMIQQMCwsgAkHwBGogE0EwaigCADYCACACQeAEaiATQSBq/QACAP0LAwAgAkHQBGogE0EQav0AAgD9CwMAIAIgE/0AAgD9CwPABAsgASEGIAshAwwKCyACQZgDaiADEK0FIAIoAqADIRcgAigCnAMhDiALIQMgAigCmAMiCkGBgICAeEcNCSAOIQQMCgsgDUEBcUUEQEGk/MAAQQcQnAchBAwICyASRQ0CIBpQBEBBq/zAAEEFEJwHIQQMCAsgG1AEQEG+/MAAQQ0QnAchBAwICyAJQYCAgIB4Rg0DQQIhAyAQQQNHBEAgAkGoBWogAkHwBGooAgA2AgAgAkGYBWogAkHgBGr9AAIA/QsDACACQYgFaiACQdAEav0AAgD9CwMAIAIgAv0AAsAE/QsD+AQgECEDCyAIQQAgCEECRxshBiARQQAgEUECRxshCEECIBQgFEEDRhshBEGAgICAeCAKIApBgYCAgHhGGyENIAdBACAHQQJHGyEKDAoLIAJBEGogAxCQBUEBIQ0gCyEDIAIoAhQiFiEEIAIoAhBBAXFFDQcMBgtBASESIAMgBEEBajYCFCADELwCDAQLQaibxQBBBBCcByEEDAQLQf33wABBBhCcByEEQYCAgIB4IQkMAwtBqJvFAEEEEJ8HIQQMAgsgAxCgAQshBCABIQYgCyEDIARFDQELCyAKRSAKQYKAgIB4SHINACAOQQRrKAIAIgNBeHEiBkEEQQggA0EDcSIDGyAKakkNDCADQQAgBiAKQSdqSxsNDSAOEKICC0ECIQgCQCAJQYCAgIB4RgRAQYCAgIB4IQkMAQsgAQRAIAtBJGohAwNAIANBBGsoAgAiBkGAgICAeHJBgICAgHhHBEAgAygCACIOQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIKGyAGakkNDyAKQQAgByAGQSdqSxsNECAOEKICCyADQTBqIQMgAUEBayIBDQALCyAJRQRAQQAhCQwBCyALQQRrKAIAIgNBeHEiASAJQTBsIgZBBEEIIANBA3EiAxtySQ0MIANBACABIAZBJ2pLGw0NIAsQogILIAQhBQsgAiACLQBsQQFqOgBsIAJB1ABqEOIEIQcgAkHYA2ogAkGIBWr9AAMA/QsDACACQegDaiACQZgFav0AAwD9CwMAIAJB+ANqIAJBqAVqKAIANgIAIAIgDzYCxAMgAiADNgLAAyACIBk3A7gDIAIgGDcDsAMgAiAMNgKsAyACIAo2AqgDIAIgFTYCpAMgAiAGNgKgAyACIAU2ApwDIAIgBDoAmAQgAiAHNgKgBCACIBY2ApQEIAIgFzYCkAQgAiAONgKMBCACIA02AogEIAIgATYChAQgAiALNgKABCACIAk2AvwDIAIgAv0AA/gE/QsDyAMgAiAINgKYAwJAAkACQCAIQQJHBEAgBw0BIAJB8AFqIAJBoANqQdwA/AoAACACIAJBkARq/QADAP0LA+ABDAkLIAcNAUECIQgMCAsgAQRAIAtBJGohAwNAIANBBGsoAgAiBEGAgICAeHJBgICAgHhHBEAgAygCACIFQQRrKAIAIgZBeHEiCEEEQQggBkEDcSIGGyAEakkNDyAGQQAgCCAEQSdqSxsNECAFEKICCyADQTBqIQMgAUEBayIBDQALCyAJBEAgC0EEaygCACIDQXhxIgEgCUEwbCIEQQRBCCADQQNxIgMbckkNDSADQQAgASAEQSdqSxsNDiALEKICC0ECIQggDUGAgICAeHJBgICAgHhHBEAgDkEEaygCACIDQXhxIgFBBEEIIANBA3EiAxsgDWpJDQ0gA0EAIAEgDUEnaksbDQIgDhCiAgsgByEFDAcLIAJBoARqELEEQQIhCAwGCwwLCyADIAs2AgwgA0EFNgIAIAMgATYCEAwGCyAKIQULIAJBtARqIg8oAgQhEAJAIA8oAggiDARAIBBBJGohBwNAIAdBBGsoAgAiE0GAgICAeHJBgICAgHhHBEAgBygCACIUQQRrKAIAIhFBeHEiEkEEQQggEUEDcSIRGyATakkNCyARQQAgEiATQSdqSxsNDCAUEKICCyAHQTBqIQcgDEEBayIMDQALCyAPKAIAIgcEQCAQQQRrKAIAIg9BeHEiDCAHQTBsIgdBBEEIIA9BA3EiDxtySQ0JIA9BACAMIAdBJ2pLGw0KIBAQogILDAALDAELIAIoApwDIQVBAiEICyACIAItAGxBAWo6AGwgAkHUAGoQugMhByACQdgDaiACQfACav0AAwD9CwMAIAJB6ANqIAJBgANq/QADAP0LAwAgAkH4A2ogAkGQA2ooAgA2AgAgAkGEBGogAkHYAmooAgA2AgAgAiAKNgLEAyACIAs2AsADIAIgGDcDuAMgAiAZNwOwAyACIAk2AqwDIAIgFTYCqAMgAiAGNgKkAyACIAQ2AqADIAIgBTYCnAMgAiAC/QAD4AL9CwPIAyACIAIpA9ACNwL8AyACIAg2ApgDIAIgBzYCoAQgAiABOgCYBCACIAM2ApQEIAIgFjYCkAQgAiAONgKMBCACIA02AogEAkACQCAIQQJHBEAgBw0BIAJB8AFqIAJBoANqQdwA/AoAACACIAJBkARq/QADAP0LA+ABIAIoAoQEIQEgAigCgAQhCyACKAL8AyEJDAMLIAcNAUECIQgMAgsgAigCgAQhBCACKAKEBCIBBEAgBEEkaiEDA0AgA0EEaygCACIFQYCAgIB4ckGAgICAeEcEQCADKAIAIgZBBGsoAgAiCEF4cSILQQRBCCAIQQNxIggbIAVqSQ0JIAhBACALIAVBJ2pLGw0KIAYQogILIANBMGohAyABQQFrIgENAAsLIAIoAvwDIgMEQCAEQQRrKAIAIgFBeHEiBSADQTBsIgNBBEEIIAFBA3EiARtySQ0HIAFBACAFIANBJ2pLGw0IIAQQogILQQIhCAJAIA1BgICAgHhyQYCAgIB4RwRAIA5BBGsoAgAiA0F4cSIBQQRBCCADQQNxIgMbIA1qSQ0IIANBACABIA1BJ2pLGw0BIA4QogILIAchBQwCCwwHCyACQaAEahCxBEECIQgLIAhBAkYNACACQYABaiACQfABakHcAPwKAAAgAiAC/QAD4AH9CwNwAkAgAigCaCIDIAIoAmQiBEkEQCACKAJgIQYDQCADIAZqLQAAQQlrIgpBF0tBASAKdEGTgIAEcUVyDQIgBCADQQFqIgNHDQALIAIgBDYCaAsgAEEIaiACQYABakHcAPwKAAAgACAONgJ0IAAgDTYCcCAAIAE2AmwgACALNgJoIAAgCTYCZCAAIAU2AgQgACAINgIAIAAgAv0AA3D9CwN4DAMLIAIgAzYCaCACIAYgBCADQQFqIgMgBCADIARJGxD5ASACKAIEIQQgAigCACEFQRQQcSIDRQ0DIAMgBTYCDCADQRY2AgAgACADNgIEIABBAjYCACADIAQ2AhACQCABBEAgC0EkaiEDA0AgA0EEaygCACIAQYCAgIB4ckGAgICAeEcEQCADKAIAIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIABqSQ0IIAVBACAGIABBJ2pLGw0DIAQQogILIANBMGohAyABQQFrIgENAAsLIAkEQCALIAlBMGxBCBCiBwsgDUGAgICAeHJBgICAgHhGDQMgDiANQQEQogcMAwsMBQsgBSACQdQAahDrBSEDCyAAIAM2AgQgAEECNgIAIABBCGogAkGAAWpB3AD8CgAAIAAgAv0AA3D9CwN4CwJAIAIoAlQiAARAIAIoAlgiAUEEaygCACIDQXhxIgtBBEEIIANBA3EiAxsgAGpJDQMgA0EAIAsgAEEnaksbDQEgARCiAgsgAkGwBWokAA8LDAILAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL+CwCBnsJfwJAAkACQAJAAkACQAJAAn8CQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIANFBEAgAEH/AXEiDEEERg0CAkAgAEEAIAxBAkcbQf8BcUEBaw4DAwIAGQsCQAJAAkACQAJAAkACQAJAIAFB/wFxQQJrDgcAAQILAwsEBQsgBUECSQ0fQQAhAiAFQQJrIgxBAk8NBUEADBkLIAUgBUEDcGsiAEEDSQ0eIABBA2siAEEDbiEOQQAhAiAAQQNPDQVBACEFQQAMFgsgBUEESQ0dQQAgBUF8cWshAgNAIARBA2ogBP1cAAAgBkEB/W39biIG/VgAAAMgBEECaiAG/VgAAAIgBEEBaiAG/VgAAAEgBCAG/VgAAAAgBEEEaiEEIAJBBGoiAg0ACwwdCyAFIAVBBnBrIgJBBkkNHEEAIQNBACEFA0AgBEEDaiAE/VwAACAGQQH9bf1uIgb9WAAAAyAEQQJqIAb9WAAAAiAEQQFqIAb9WAAAASAEIAb9WAAAACAEQQVqIgAgAC0AACADQf4BcUEBdmoiAzoAACAEQQRqIgAgAC0AACAFQf4BcUEBdmoiBToAACAEQQZqIQQgAkEGayICQQZPDQALDBwLIAVBCEkNG0EAIAVBeHFrIQIDQCAEQQdqIAT9XQAAIAZBAf1t/W4iBv1YAAAHIARBBmogBv1YAAAGIARBBWogBv1YAAAFIARBBGogBv1YAAAEIARBA2ogBv1YAAADIARBAmogBv1YAAACIARBAWogBv1YAAABIAQgBv1YAAAAIARBCGohBCACQQhqIgINAAsMGwsgBUUgBUEBRnINGiAFQQFrIgNBA3EhASAELQAAIQJBACEAIAVBAmtBA0kNFSADQXxxIQUDQCAAIARqIgxBAWoiAyADLQAAIAJB/gFxQQF2aiIDOgAAIAxBAmoiAiACLQAAIANB/gFxQQF2aiIDOgAAIAxBA2oiAiACLQAAIANB/gFxQQF2aiIDOgAAIAxBBGoiAiACLQAAIANB/gFxQQF2aiICOgAAIAUgAEEEaiIARw0ACwwVCyAMQQF2QQFqQX5xIQVBACEDA0AgBEEBaiIAIAAtAAAgAkH+AXFBAXZqIgI6AAAgBCAELQAAIANB/gFxQQF2aiIBOgAAIARBAmoiACAALQAAIAFB/gFxQQF2aiIDOgAAIARBA2oiACAALQAAIAJB/gFxQQF2aiICOgAAIARBBGohBCAFQQJrIgUNAAsMEgsgDkEBakH+////B3EhAEEAIQNBACEFA0AgBEECaiIBIAEtAAAgAkH+AXFBAXZqIgw6AAAgBEEBaiIBIAEtAAAgA0H+AXFBAXZqIgM6AAAgBCAELQAAIAVB/gFxQQF2aiICOgAAIARBA2oiASABLQAAIAJB/gFxQQF2aiIFOgAAIARBBGoiASABLQAAIANB/gFxQQF2aiIDOgAAIARBBWoiASABLQAAIAxB/gFxQQF2aiICOgAAIARBBmohBCAAQQJrIgANAAsMDwsCQAJAIABB/wFxQQFrDgQDAgABGQsCQAJAAkACQAJAAkAgAUH/AXFBAmsOBwECAwkECQUACyAFRQ0dQQAhAEEAIQEgAyAFIAMgBUkbIgNBAUYNEyADQQFxIQ4gA0F+cSEMA0AgACAEaiINIA0tAAAgACACaiIFLQAAIAFB/wFxakEBdmoiAzoAACANQQFqIgEgAS0AACAFQQFqLQAAIANB/wFxakEBdmoiAToAACAMIABBAmoiAEcNAAsMEgsgA0EBdiIBIAVBAXYiACAAIAFLGyIDRQ0cQQAhBUEAIQADQCAEIAQtAAAgAi0AACAFQf8BcWpBAXZqIgU6AAAgBEEBaiIBIAEtAAAgAkEBai0AACAAQf8BcWpBAXZqIgA6AAAgBEECaiEEIAJBAmohAiADQQFrIgMNAAsMHAsgA0EDbiIBIAVBA24iACAAIAFLGyIDRQ0bQQAhBUEAIQBBACEBA0AgBCAELQAAIAItAAAgBUH/AXFqQQF2aiIFOgAAIARBAmoiDCAMLQAAIAJBAmotAAAgAUH/AXFqQQF2aiIBOgAAIARBAWoiDCAMLQAAIAJBAWotAAAgAEH/AXFqQQF2aiIAOgAAIARBA2ohBCACQQNqIQIgA0EBayIDDQALDBsLIANBAnYiASAFQQJ2IgAgACABSxsiA0UNGgNAIARBA2ogBP1cAAAgAv1cAAAiByAG/U4gByAG/VFBAf1t/W79biIG/VgAAAMgBEECaiAG/VgAAAIgBEEBaiAG/VgAAAEgBCAG/VgAAAAgBEEEaiEEIAJBBGohAiADQQFrIgMNAAsMGgsgA0EGbiIBIAVBBm4iACAAIAFLGyIBRQ0ZQQAhBQNAIAQgBWoiDCAMLQAAIAIgBWoiAy0AACANQf8BcWpBAXZqIg06AAAgDEEBaiIAIAAtAAAgA0EBai0AACAOQf8BcWpBAXZqIg46AAAgDEEFaiAMQQJqIgD9XAAAIANBAmr9XAAAIgcgBv1OIAcgBv1RQQH9bf1u/W4iBv1YAAADIAxBBGogBv1YAAACIAxBA2ogBv1YAAABIAAgBv1YAAAAIAVBBmohBSABQQFrIgENAAsMGQsgA0EDdiIBIAVBA3YiACAAIAFLGyIARQ0YQQAhBQNAIAQgBWoiAUEHaiAB/V0AACACIAVq/V0AACIHIAb9TiAHIAb9UUEB/W39bv1uIgb9WAAAByABQQZqIAb9WAAABiABQQVqIAb9WAAABSABQQRqIAb9WAAABCABQQNqIAb9WAAAAyABQQJqIAb9WAAAAiABQQFqIAb9WAAAASABIAb9WAAAACAFQQhqIQUgAEEBayIADQALDBgLAkACQAJAAkACQAJAIAFB/wFxQQJrDgcBAgMIBAgFAAsgBUUNHCADIAUgAyAFSRshDkEAIQNBACEFA0AgBCAELQAAIAUgAi0AACIAIAMgA0H/AXEgBUH/AXEiA2siDyAPQR91IgFzIAFrIgwgACADayINIA1BH3UiAXMgAWsiBUkiAxsgDSAPaiIBIAFBD3UiAXMgAWtB//8DcSAMIAUgAxtJG2oiAzoAACAEQQFqIQQgAkEBaiECIAAhBSAOQQFrIg4NAAsMHAsgA0EBdiIBIAVBAXYiACAAIAFLGyIDRQ0bA0AgBEEBaiAGIAIvAAD9ECIIIAcgByAG/XkgByAG/Xf9cf2JASILIAggBv15IAggBv13/XH9iQEiCf0wIAb9DQACAAAAAAAAAAAAAAAAAAD9UiAI/YkBIAb9iQEiCv2RASAH/YkBIAr9kQH9jgH9gAEgCyAJ/ZcB/TAgBv0NAAIAAAAAAAAAAAAAAAAAAP1SIAQvAAD9EP1uIgf9WAAAASAEIAf9WAAAACAEQQJqIQQgAkECaiECIAghBiADQQFrIgMNAAsMGwsgAyADQQNwayIBQQNJDRogBSAFQQNwayIAQQNJDRogAEEDayEQIAFBA2shAEEAIQNBACEFA0AgBEEBaiAGIAIvAAD9ECIIIAcgByAG/XkgByAG/Xf9cf2JASILIAggBv15IAggBv13/XH9iQEiCf0wIAb9DQACAAAAAAAAAAAAAAAAAAD9UiAI/YkBIAb9iQEiCv2RASAH/YkBIAr9kQH9jgH9gAEgCyAJ/ZcB/TAgBv0NAAIAAAAAAAAAAAAAAAAAAP1SIAQvAAD9EP1uIgf9WAAAASAEIAf9WAAAACAEQQJqIgEgAS0AACAFIAJBAmotAAAiASADIANB/wFxIAVB/wFxIgVrIg8gD0EfdSIDcyADayIOIAEgBWsiDSANQR91IgNzIANrIgxJIgUbIA0gD2oiAyADQQ91IgNzIANrQf//A3EgDiAMIAUbSRtqIgM6AAAgAEEDSQ0bIAJBA2ohAiAEQQNqIQQgAEEDayEAIBBBAksgEEEDayEQIAEhBSAIIQYNAAsMGgsgA0F8cSIBRQ0ZIAVBfHEiAEUNGUEEIABrIQBBBCABayEDA0AgBEEDaiAHIAL9XAAAIgggBiAGIAf9eSAGIAf9d/1x/YkBIgkgCCAH/XkgCCAH/Xf9cf2JASIK/TAgBv0NAAIEBgAAAAAAAAAAAAAAAP1SIAj9iQEgB/2JASIH/ZEBIAb9iQEgB/2RAf2OAf2AASAJIAr9lwH9MCAG/Q0AAgQGAAAAAAAAAAAAAAAA/VIgBP1cAAD9biIG/VgAAAMgBEECaiAG/VgAAAIgBEEBaiAG/VgAAAEgBCAG/VgAAAAgA0UNGiAEQQRqIQQgACIBQQRqIQAgA0EEaiEDIAJBBGohAiAIIQcgAQ0ACwwZCyADQQZuIgEgBUEGbiIAIAAgAUsbIhNFDRhBACEFQQAhAEEAIQEDQCAEIAVqIhFBA2ogByACIAVqIhT9XAAAIgggBiAGIAf9eSAGIAf9d/1x/YkBIgkgCCAH/XkgCCAH/Xf9cf2JASIK/TAgBv0NAAIEBgAAAAAAAAAAAAAAAP1SIAj9iQEgB/2JASIH/ZEBIAb9iQEgB/2RAf2OAf2AASAJIAr9lwH9MCAG/Q0AAgQGAAAAAAAAAAAAAAAA/VIgEf1cAAD9biIG/VgAAAMgEUECaiAG/VgAAAIgEUEBaiAG/VgAAAEgESAG/VgAAAAgEUEFaiIDIAMtAAAgDSAUQQVqLQAAIgwgACAAQf8BcSANQf8BcSIDayISIBJBH3UiAHMgAGsiDyAMIANrIhAgEEEfdSIAcyAAayINSSIDGyAQIBJqIgAgAEEPdSIAcyAAa0H//wNxIA8gDSADG0kbaiIAOgAAIBFBBGoiAyADLQAAIA4gFEEEai0AACIDIAEgAUH/AXEgDkH/AXEiDmsiEiASQR91IgFzIAFrIg8gAyAOayIQIBBBH3UiAXMgAWsiDUkiDhsgECASaiIBIAFBD3UiAXMgAWtB//8DcSAPIA0gDhtJG2oiAToAACAFQQZqIQUgDCENIAMhDiAIIQcgE0EBayITDQALDBgLIANBA3YiASAFQQN2IgAgACABSxsiAEUNF0EAIQUDQCAEIAVqIgFBB2ogByACIAVq/V0AACIIIAYgBiAH/XkgBiAH/Xf9cf2JASIJIAggB/15IAggB/13/XH9iQEiCv0wIAb9DQACBAYICgwOAAAAAAAAAAD9UiAI/YkBIAf9iQEiB/2RASAG/YkBIAf9kQH9jgH9gAEgCSAK/ZcB/TAgBv0NAAIEBggKDA4AAAAAAAAAAP1SIAH9XQAA/W4iBv1YAAAHIAFBBmogBv1YAAAGIAFBBWogBv1YAAAFIAFBBGogBv1YAAAEIAFBA2ogBv1YAAADIAFBAmogBv1YAAACIAFBAWogBv1YAAABIAEgBv1YAAAAIAVBCGohBSAIIQcgAEEBayIADQALDBcLIAMgBSADIAVJGyIBRQ0WIAFBEE8EQCAEIQMgAiEFIAFBcHEiDSEAA0AgAyAD/QAAACAF/QAAAP1u/QsAACADQRBqIQMgBUEQaiEFIABBEGsiAA0ACyABIA1GDRcLIAEgDWshAyAEIA1qIQQgAiANaiECA0AgBCAELQAAIAItAABqOgAAIARBAWohBCACQQFqIQIgA0EBayIDDQALDBYLIAFB/wFxQQJrDgcBAgMABAAFBgsACyAFQQJJDRMgBUECayIBQQF2QQFqIgBBA3EhBUEAIQIgAUEGTw0FQQAhAwwRCyAFIAVBA3BrIgBBA0kNEiAAQQNrIgBBA24hDkEAIQIgAEEDTw0FQQAhA0EAIQUMDwsgBUEESQ0RQQAhAiAFQQRrIgVBBE8NBUEAIQNBACEAQQAhAQwNCyAFIAVBBnBrIgJBBkkNEEEAIQNBACEFA0AgBEEDaiAE/VwAACAG/W4iBv1YAAADIARBAmogBv1YAAACIARBAWogBv1YAAABIAQgBv1YAAAAIARBBWoiACAALQAAIANqIgM6AAAgBEEEaiIAIAAtAAAgBWoiBToAACAEQQZqIQQgAkEGayICQQZPDQALDBALIAVBCEkND0EAIAVBeHFrIQIDQCAEQQdqIAT9XQAAIAb9biIG/VgAAAcgBEEGaiAG/VgAAAYgBEEFaiAG/VgAAAUgBEEEaiAG/VgAAAQgBEEDaiAG/VgAAAMgBEECaiAG/VgAAAIgBEEBaiAG/VgAAAEgBCAG/VgAAAAgBEEIaiEEIAJBCGoiAg0ACwwPCyAFRSAFQQFGcg0OIAVBAWsiA0EDcSEBIAQtAAAhAkEAIQAgBUECa0EDSQ0NIANBfHEhBQNAIAAgBGoiDEEBaiIDIAMtAAAgAmoiAzoAACAMQQJqIgIgAi0AACADaiIDOgAAIAxBA2oiAiACLQAAIANqIgM6AAAgDEEEaiICIAItAAAgA2oiAjoAACAFIABBBGoiAEcNAAsMDQsgAEF8cSEAQQAhAwNAIAQgBC0AACADaiIDOgAAIARBAWoiASABLQAAIAJqIgI6AAAgBEECaiIBIAEtAAAgA2oiAzoAACAEQQNqIgEgAS0AACACaiICOgAAIARBBGoiASABLQAAIANqIgM6AAAgBEEFaiIBIAEtAAAgAmoiAjoAACAEQQZqIgEgAS0AACADaiIDOgAAIARBB2oiASABLQAAIAJqIgI6AAAgBEEIaiEEIABBBGsiAA0ACwwLCyAOQQFqQf7///8HcSEAQQAhA0EAIQUDQCAEIAQtAAAgBWoiBToAACAEQQJqIgEgAS0AACACaiIMOgAAIARBAWoiASABLQAAIANqIgI6AAAgBEEDaiIBIAEtAAAgBWoiBToAACAEQQRqIgEgAS0AACACaiIDOgAAIARBBWoiASABLQAAIAxqIgI6AAAgBEEGaiEEIABBAmsiAA0ACwwJCyAFQQJ2QQFqQf7///8HcSECA0AgBEEDaiAE/VwAACAG/W4iB/1YAAADIARBAmogB/1YAAACIARBAWogB/1YAAABIAQgB/1YAAAAIARBBGoiACAA/VwAACAH/W4iBv1YAAAAIARBBWogBv1YAAABIARBBmogBv1YAAACIARBB2ogBv1YAAADIARBCGohBCACQQJrIgINAAsgBv0WAyECIAb9FgIhAyAG/RYBIQAgBv0WACEBDAcLIA5FDQoLIAAgBGoiAyADLQAAIAAgAmotAAAgAUH/AXFqQQF2ajoAAAwJCyACQf4BcUEBdiECIAVB/gFxQQF2IQUgA0H+AXFBAXYLIQMgDkEBcQ0HDAgLIAJB/gFxQQF2IQIgA0H+AXFBAXYLIQMgDEECcQ0FIAQgBC0AASACajoAASAEIAQtAAAgA2o6AAAPCyABRQ0EIAAgBGpBAWohBANAIAQgBC0AACACQf4BcUEBdmoiAjoAACAEQQFqIQQgAUEBayIBDQALDAQLIAVBBHENAyAEIAQtAAMgAmo6AAMgBCAELQACIANqOgACIAQgBC0AASAAajoAASAEIAQtAAAgAWo6AAAPCyAOQQFxDQIMAwsgBUUNAQNAIAQgBC0AACADaiIDOgAAIARBAWoiACAALQAAIAJqIgI6AAAgBEECaiEEIAVBAWsiBQ0ACwwBCyABRQ0AIAAgBGpBAWohBANAIAQgBC0AACACaiICOgAAIARBAWohBCABQQFrIgENAAsLDwsgBCAELQACIAJqOgACIAQgBC0AASADajoAASAEIAQtAAAgBWo6AAALri0EEX8EfQF+AXsjAEHAAWsiAiQAAkACQAJAAkACQCABKAKIAUECRwRAIAEoAvACIgQgASgC7AFJBEAgAUG4AmohEgNAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAugBIARBKGxqIggpAxAgASkDyAJ8IhcgASkDuAJRBEAgASgC4AIiBCAIKAIYIgZBB2pBeHFJDQEgBCAGSQ0CIAEoAtwCIQMgCC0AICIRQQFGBEAgAkEQaiADIAYQ+QIgAigCECIEQYCAgIB4RwRAIAIoAhQgAkEANgKwASACQQE2AqQBIAJBuMnBADYCoAEgAkIENwKoASACQaABahCSByEOIARFDRsgBEEBEKIHDBsLIAIoAhghDiACKAIUIg9BgICAgHhGDRogAigCHCEGIA4hAwtBCSEFAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAn8CQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAgtACJBAWsODQECAxofHR4bHB8dHgQACyAILQAhDgQEBQYHCQsgCC0AIQ4FCwoJCQwJCyAILQAhIgUOBg4NEBAPDxALIAgtACEOChIRERERERERFBMRCyAILQAhQQtrDgIcHRsLIAJBEGogAyAGQQMgASgC+AIQ+AQMAwsgAkEQaiADIAZBAyABKAL4AhDmAwwCCyACQRBqIAMgBiABKAL4AhCgAgwBCyACQRBqIAMgBiABKAL4AhD+AQsgAigCFCEHIAEoAvgCIg0EQCACKAIYIQpBACEEIAEoAoACIgsgASgC9AIiDGsiA0EAIAMgC00bIRAgASgC/AEgDEEkbGpBCGohAyAHIQVBACEGA0AgBiAQRg03IARBA2oiCSAKSyAGQdSq1aoFS3INHyADIAVBCGogBf1dAgD9VgIAAiIY/VoCCAIgAyAY/VsCAAAgBUEMaiEFIANBJGohAyAJIQQgDSAGQQFqIgZHDQALCyACKAIQIgRFDS8gB0EEaygCACIDQXhxIgUgBEECdCIEQQRBCCADQQNxIgMbakkNNiADQQAgBSAEQSdqSxsNNyAHEKICDC8LIAJBATYCpAEgAkHgycEANgKgASACQgE3AqwBIAIgCEEhaq1CgICAgJAFhDcDUCACIAJB0ABqNgKoASACQSBqIgEgAkGgAWoQsQYgARCOByEBDC0LIAJBATYCpAEgAkG8ysEANgKgASACQgE3AqwBIAIgCEEhaq1CgICAgJAFhDcDUCACIAJB0ABqNgKoASACQSxqIgEgAkGgAWoQsQYgARCOBwwDCyACQRBqIAMgBkEBIAEoAvgCEOYDDCoLIAJBEGogAyAGQQEgASgC+AIQ+AQMKQsgCCgCAEUEQCACQQA2ArABIAJBATYCpAEgAkGYysEANgKgASACQgQ3AqgBIAJBoAFqEJIHDAELIAgoAggNJyACQQA2ArABIAJBATYCpAEgAkH8ycEANgKgASACQgQ3AqgBIAJBoAFqEJIHCyEBDCgLIAJBEGogAyAGQQMgASgC+AIQ5gMMJAsgAkEQaiADIAZBAyABKAL4AhD4BAwjCyAIKAIARQRAIAJBADYCsAEgAkEBNgKkASACQZjKwQA2AqABIAJCBDcCqAEgAkGgAWoQkgcMAgsgCCgCCEUEQCACQQA2ArABIAJBATYCpAEgAkH8ycEANgKgASACQgQ3AqgBIAJBoAFqEJIHDAILIAgqAgQhEyABKAL4AiEEIAgqAgwhFCAFQQRGDSEgAkEQaiADIAZBAyAEIBMgFBD/AwwiCyACQQE2AqQBIAJB4MrBADYCoAEgAkIBNwKsASACIAhBIWqtQoCAgICQBYQ3A1AgAiACQdAAajYCqAEgAkE4aiIBIAJBoAFqELEGIAEQjgcLIQEMIwsgAkEBNgKkASACQYjLwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNQIAIgAkHQAGo2AqgBIAJBxABqIgEgAkGgAWoQsQYgARCOBwwDCyACQRBqIAMgBkEDIAEoAvgCEPgEDBwLIAJBEGogAyAGIAEoAvgCEP0BDBsLIAgoAgBFBEAgAkEANgKwASACQQE2AqQBIAJBmMrBADYCoAEgAkIENwKoASACQaABahCSBwwBCyAIKAIIDRkgAkEANgKwASACQQE2AqQBIAJB/MnBADYCoAEgAkIENwKoASACQaABahCSBwshAQweCwJAAkACQAJAIAgtACEiBEEKRwRAIAQOAgIDAQsgAkHQAGogAyAGIAEoAvgCEMUDDBoLIAJBATYCpAEgAkHEy8EANgKgASACQgE3AqwBIAIgCEEhaq1CgICAgJAFhDcDaCACIAJB6ABqNgKoASACQdwAaiIBIAJBoAFqELEGIAEQjgchAQwgCyACQRBqIAMgBkEDIAEoAvgCEPgEDAELIAJBEGogAyAGQQMgASgC+AIQ5gMLIAEoAvgCIgpBAnQiBkH/////A0sNDSAKQQR0IgRB/f///wdPDQ0CQCAERQRAQQQhBEEAIQYMAQsgBBBxIgRFDQ8gASgC+AIhCgsgAkEANgKoASACIAQ2AqQBIAIgBjYCoAEgCgRAQQAhA0EBIQcgAigCGCEFIAIoAhQhBgNAIAdBAWsiCSAFTwRAIAkhBwwYCyAFIAlrIglBACAFIAlPGyIJQQFGDRcgCUECRg0WQwAAgD8gBioCACITIBOUkyAGQQRqKgIAIhQgFJSTIAZBCGoqAgAiFSAVlJNDAAAAABDgCJEhFiACKAKgASADa0EDTQRAIAJBoAFqIANBBEEEQQQQpAUgAigCqAEhAyACKAKkASEECyAEIANBAnRqIgkgFjgCDCAJIBU4AgggCSAUOAIEIAkgEzgCACACIANBBGoiAzYCqAEgB0EDaiEHIAZBDGohBiAKQQFrIgoNAAsLIAJB2ABqIAJBqAFqKAIANgIAIAIgAikCoAE3A1AgAigCECIERQ0WIAIoAhQiA0EEaygCACIFQXhxIgcgBEECdCIEQQRBCCAFQQNxIgUbakkNJSAFQQAgByAEQSdqSxsNJiADEKICDBYLIAgtACFBC0YNEiACQQE2AqQBIAJB8MvBADYCoAEgAkIBNwKsASACIAhBIWqtQoCAgICQBYQ3AxAgAiACQRBqNgKoASACQYgBaiIBIAJBoAFqELEGIAEQjgchAQwcCyAILQAhQQxGDRAgAkEBNgKkASACQZzMwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwMQIAIgAkEQajYCqAEgAkGUAWoiASACQaABahCxBiABEI4HIQEMGwtBDyEFDAELQRUhBQsCQAJAAkACQAJAIAgtACEiBA4IAQADAwICBAQDCyACQRBqIAMgBiAFIAEoAvgCEOYDDBALIAJBEGogAyAGIAUgASgC+AIQ+AQMDwsgCCgCAEUEQCACQQA2ArABIAJBATYCpAEgAkGYysEANgKgASACQgQ3AqgBIAJBoAFqEJIHIQEMGwsgCCgCCEUEQCACQQA2ArABIAJBATYCpAEgAkH8ycEANgKgASACQgQ3AqgBIAJBoAFqEJIHIQEMGwsgCCoCBCETIAEoAvgCIQcgCCoCDCEUIARBBEYNDSACQRBqIAMgBiAFIAcgEyAUEP8DDA4LIAJBATYCpAEgAkHQzMEANgKgASACQgE3AqwBIAIgCEEhaq1CgICAgJAFhDcDUCACIAJB0ABqNgKoASACQfAAaiIBIAJBoAFqELEGIAEQjgchAQwZCyAIKAIIRQRAIAJBADYCsAEgAkEBNgKkASACQfzJwQA2AqABIAJCBDcCqAEgAkGgAWoQkgchAQwZCyABKAL4AiEHIAgqAgwhEyAEQQZGDQogAkEQaiADIAYgBSAHIBMQkAQMDAsgAkEBNgKkASACQfjMwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNQIAIgAkHQAGo2AqgBIAJB/ABqIgEgAkGgAWoQsQYgARCOByEBDBcLIAJBEGogAyAGIAEoAvgCEI4FDAELIAJBEGogAyAGIAEoAvgCENMECyACKAIQIgRFDRUgAigCFCIDQQRrKAIAIgVBeHEiByAEQQJ0IgRBBEEIIAVBA3EiBRtqSQ0cIAVBACAHIARBJ2pLGw0dIAMQogIMFQsgAiAXNwNQIAJBAjYCpAEgAkG0zcEANgKgASACQgI3AqwBIAJCgICAgKAFIhcgAkHQAGqthDcDGCACIBcgEq2ENwMQIAIgAkEQajYCqAEgAkEEaiIBIAJBoAFqELEGIAEQjgchASAAQQE6AAAgACABNgIEDBkLIABBADsBAAwYC0EAIAYgBEGAzcEAEOoHAAsgBCAJIApBxMXHABDqBwALQZDLwQAQ/wcLAAsgAkEQaiADIAYgBSAHIBMQggUMAQsgAkEQaiADIAYgBSAHIBMgFBD5BAsCQAJAAkACQAJAAkACQAJAAkACQCAILQAiQQVrDggBAgMAAAQEBAALQaT4xgBBKEGkzMEAEOsHAAsgASgCtAJFDQIgASgC+AIiDEUNAiACKAIYIQkgAigCFCEDQQAhBCABKAKYAiIKIAEoAvQCIgtrIgVBACAFIApNGyENIAEoApQCIAtBEmxqIQVBACEGA0AgBiANRg0EIARBCWoiByAJSyAGQZuOx+MBS3JFBEAgBSADEMYCIANBJGohAyAFQRJqIQUgByEEIAwgBkEBaiIGRw0BDAQLCyAEIAcgCUHUxscAEOoHAAsgASgCtAJBAkkNASABKAL4AiIMRQ0BIAIoAhghCSACKAIUIQNBACEEIAEoAqQCIgogASgC9AIiC2siBUEAIAUgCk0bIQ0gASgCoAIgC0EebGohBUEAIQYDQCAGIA1GDQQgBEEPaiIHIAlLIAZBkKLEiAFLckUEQCAFIAMQwgIgA0E8aiEDIAVBHmohBSAHIQQgDCAGQQFqIgZHDQEMAwsLIAQgByAJQfTGxwAQ6gcACyABKAK0AkEDSQ0AIAEoAvgCIgxFDQAgAigCGCEJIAIoAhQhA0EAIQQgASgCsAIiCiABKAL0AiILayIFQQAgBSAKTRshDSABKAKsAiALQSpsaiEFQQAhBgNAIAYgDUYNBCAEQRVqIgcgCUsgBkGLhsPhAEtyDQUgBSADELYCIANB1ABqIQMgBUEqaiEFIAchBCAMIAZBAWoiBkcNAAsLIAIoAhAiBEUNESACKAIUIgNBBGsoAgAiBUF4cSIHIARBAnQiBEEEQQggBUEDcSIFG2pJDRggBUEAIAcgBEEnaksbDQQgAxCiAgwRCyAGIAtqIApBxMbHABCMBwALIAYgC2ogCkHkxscAEIwHAAsgBiALaiAKQYTHxwAQjAcACyAEIAcgCUGUx8cAEOoHAAsMFAsgAkGgAWogAyAGIAEoAvgCENQEIAEoAogCIAEoAowCIAEoAvQCIAEoAvgCIAIoAqQBIgQgAigCqAEQjgMgAigCoAEiA0UNCwJAIARBBGsoAgAiBUF4cSIHIANBAnQiA0EEQQggBUEDcSIFG2pPBEAgBUEAIAcgA0EnaksbDQEgBBCiAgwNCwwTCwwTCyACQaABaiADIAYgASgC+AIQnAUgASgCiAIgASgCjAIgASgC9AIgASgC+AIgAigCpAEiBCACKAKoARC0AyACKAKgASIDRQ0KAkAgBEEEaygCACIFQXhxIgcgA0EBdCIDQQRBCCAFQQNxIgUbak8EQCAFQQAgByADQSdqSxsNASAEEKICDAwLDBILDBILIAdBAWohBwsgByAFQcTNwQAQjAcACyACKAJUIQkCQAJAAkAgASgC+AIiCgRAIAIoAlghC0EAIQYgASgCgAIiDCABKAL0AiIEayIDQQAgAyAMTRshAyABKAL8ASAEQSRsaiEFIAkhBwNAIANFDQIgBkEDaiALTw0DIAIgB/0AAgD9CwSgASAHQRBqIQcgBkEEaiEGIARBAWohBCADQQFrIQMgBSACQaABahCQAiAFQSRqIQUgCkEBayIKDQALCyACKAJQIgRFDQogCUEEaygCACIDQXhxIgUgBEECdCIEQQRBCCADQQNxIgMbakkNESADQQAgBSAEQSdqSxsNAiAJEKICDAoLIAQgDEHkwMcAEIwHAAsgBiAGQQRqIAtBpMfHABDqBwALDA8LIAJBEGogAyAGIAEoAvgCIAgqAgQgCCoCDBCqAwsgAigCFCEHAkACQCABKAL4AiINBEAgAigCGCEKQQAhBCABKAKAAiILIAEoAvQCIgxrIgNBACADIAtNGyEQIAEoAvwBIAxBJGxqIQUgByEDQQAhBgNAIAYgEEYNDyAEQQNqIgkgCksgBkHUqtWqBUtyDQIgAiAD/V0CACADQQhqKgIAIhP9IAIgE/0gA/0LBKABIANBDGohAyAFIAJBoAFqEN0CIAVBJGohBSAJIQQgDSAGQQFqIgZHDQALCyACKAIQIgRFDQcgB0EEaygCACIDQXhxIgUgBEECdCIEQQRBCCADQQNxIgMbakkNDiADQQAgBSAEQSdqSxsNASAHEKICDAcLIAQgCSAKQfDKxwAQ6gcACwwNCyACQRBqIAMgBkEDIAQgEyAUEPkECyACKAIUIQcCQAJAIAEoAvgCIg0EQCACKAIYIQpBACEEIAEoAoACIgsgASgC9AIiDGsiA0EAIAMgC00bIRAgASgC/AEgDEEkbGohBSAHIQNBACEGA0AgBiAQRg0NIARBA2oiCSAKSyAGQdSq1aoFS3INAiACIAP9XQIAIANBCGoqAgAiE/0gAiAT/SAD/QsEoAEgA0EMaiEDIAUgAkGgAWoQ5QIgBUEkaiEFIAkhBCANIAZBAWoiBkcNAAsLIAIoAhAiBEUNBSAHQQRrKAIAIgNBeHEiBSAEQQJ0IgRBBEEIIANBA3EiAxtqSQ0MIANBACAFIARBJ2pLGw0BIAcQogIMBQsgBCAJIApBtMbHABDqBwALDAsLIAJBEGogAyAGQQEgASgC+AIgCCoCBCAIKgIMEPkECyABKAL8ASABKAKAAiABKAL0AiABKAL4AiACKAIUIgQgAigCGBCrAiACKAIQIgNFDQECQCAEQQRrKAIAIgVBeHEiByADQQJ0IgNBBEEIIAVBA3EiBRtqTwRAIAVBACAHIANBJ2pLGw0BIAQQogIMAwsMCQsMCQsgAEEBOgAAIAAgATYCBCARRSAPRXINBSAOIA9BARCiBwwFCwJAAkACQCABKALgAiIDIAgoAhhBB2pBeHEiBE8EQCABQQA2AuACIAMgBGshBSAERQ0BIAMgBEYNAyAFRQ0CIAEoAtwCIgMgAyAEaiAF/AoAAAwCC0EAIAQgA0GEpMcAEOoHAAsgAyAERg0BCyABIAU2AuACCyAIKQMYIRcgASABKALwAkEBaiIENgLwAiABIAEpA7gCIBdCB3xC+P///w+DfDcDuAICQCARRSAPRXINAAJAIA5BBGsoAgAiBEF4cSIDQQRBCCAEQQNxIgQbIA9qTwRAIARBACADIA9BJ2pLGw0BIA4QogIgASgC8AIhBAwCCwwICwwICyAEIAEoAuwBSQ0ACwsgAEGAAjsBAAwCC0GMycEAEN0JAAsgAEEBOgAAIAAgDjYCBAsgAkHAAWokAA8LIAYgDGogC0HkwMcAEIwHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALozADJ38EfQF+IwBBwAxrIgMkAAJAAkACQAJAAkACQAJAIAAoAtwEIgFBgYCAgHhGBEACQCAAKALwBCIKQQRJDQACQCAAKALsBCIELwAAIAQtAAJBEHRyQfDY5QNGBEAgCkELSQ0CIApBCmshAkEAIQECQANAIAEgBGpB+MPBAEELENsHRQ0BIAIgAUEBaiIBRw0ACyAKQf//A00NAyADQQA2AugHIANBATYC3AcgA0Hww8EANgLYByADQgQ3AuAHIANB2AdqEJIHIQIMCQsgASAKSw0KIANB2AdqIAQgARD7AiADKQLcByEsIAMoAtgHQQFGBEAgLBDNByECDAkLIANB2AdqICynICxCIIinEE0gAygC2AchAiADKAKECSIEQYCAgIB4RgRAIAJFDQMMCQsgA0EIakEEciADQdgHaiIOQQRyQagB/AoAACADQcABaiADQZAJaikDACIsNwMAIAMgAykDiAk3A7gBIAMgBDYCtAEgAyACNgIIAkAgLKciCkEBcUUEQCADKAKwASEIIAMoApwBIQQgA0GYBmoiAiADQfgAahDDAyAOIAggBCACEJoBIAMoAtgHIQUgAygCtAwiDUGAgICAeEYNASADKALcByECIANBsANqIANB4AdqQeQC/AoAACADKALICiEHIAMoAsQKIQsgA0GgAmogA0HMCmpBkAH8CgAAIAMoAtwLIQkgA0HIAWogA0HgC2pB1AD8CgAAIAMpA7gMISwgA0EAOgDgByADIAk2AtwHIAMgCDYC2AcgAEH0BGogDhClBAwDCyADQZgGaiICIANBCGpBwAH8CgAAIANB2AdqIAIQaiADKALcByECIAMoAtgHIgVBgICAgHhGBEAgAkUNBAwKCyADQbADaiADQeAHakHkAvwKAAAgAygCxAohCyADKALICiEHIANBADoA4AcgAyAHNgLcByADIAs2AtgHIABB9ARqIANB2AdqEKUEQYCAgIB4IQ0MAgsgA0EIahCgAyAFIgINCAwCCyADQQA2AugHIANBATYC3AcgA0Goo8EANgLYByADQgQ3AuAHIANB2AdqEJIHIQIMBwsgACgC8AQiBCABQQtqIghJDQIgAEEANgLwBCAEIAhHBEAgBCAIayIEBEAgACgC7AQiASABIAhqIAT8CgAACyAAIAQ2AvAECwJAAkACQCAAKALcBEGAgICAeGsOAgECAAsgABC+AgwBCyAAEL0BCyAAIAI2AgQgACAFNgIAIABBCGogA0GwA2pB5AL8CgAAIAAgBzYC8AIgACALNgLsAiAAQfQCaiADQaACakGQAfwKAAAgACAJNgKEBCAAQYgEaiADQcgBakHUAPwKAAAgACAsNwPgBCAAIA02AtwEIApBAXENACADQQhqEKADC0EAIQIgACgC3AQiAUGBgICAeEYNBQsgAUGAgICAeEcNASAAKALoAiICIAAoAghPBEAgACgC8AQhAUEAIQIgAEEANgLwBCABDQQMBQsgAEH0BGohDgJAA0ACQCAAKAIEIAJBBnRqIggoAiQiDwRAIA8gACgC8AQiByAMayICTQ0BDAYLQZTGwQAQgQgACyAILQA8IQVBgIAEIQEgAiAPbiIKIAgoAiAiBCAIKAI4IhBrIgJBACACIARNGyICIAIgCksbIgJBgIAETQRAIAIiAUUNBQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFQQFrDgMCAQwACyAAIAEgDCAPIAAoAuwEIAcQkQMMCwsgACgChAFBgICAgHhHDQEMCgsgACABIBAgDCAPIAAoAuwEIAcQ5wEiAg0QIAFBA2wiCyAAKAIgIgJLDQEgASAAKAIsIgJLDQIgCyAAKAI4IgJLDQMgCyAAKAJEIgJLDQQgAUECdCIIIAAoAlAiAksNBSAAKAIcIQUgACgCKCEKIAAoAjQhBCAAKAJAIQIgA0IENwKgCCADQgI3ApgIIANCBDcCkAggA0IENwKICCADQgQ3AoAIIAMgCDYC/AcgAyALNgL0ByADIAI2AvAHIAMgCzYC7AcgAyAENgLoByADIAE2AuQHIAMgCjYC4AcgAyALNgLcByADIAU2AtgHIAMgACgCTDYC+AcgDiAQIAEgA0HYB2oQlwEMCQsgACABIAwgDyAAKALsBCAHEOgBIAFBCWwiByAAKAJcIgJLDQUgACgCWCELAkAgACgC8AIiCkECTwRAIAFBD2wiBSAAKAJoIgJNBEAgACgCZCEEIApBAkcNAkEAIQ1BBCEIDAoLQQAgBSACQYTHwQAQ6gcACyAOIBAgASALIAcQzgMMCQsgAUEVbCINIAAoAnQiAksNBiAAKAJwIQgMBwtBACALIAJB5MbBABDqBwALQQAgASACQdTGwQAQ6gcAC0EAIAsgAkHExsEAEOoHAAtBACALIAJBtMbBABDqBwALQQAgCCACQaTGwQAQ6gcAC0EAIAcgAkGUx8EAEOoHAAtBACANIAJB9MbBABDqBwALIA4gECABIAsgBxDOAyAOIBAgASAEIAUQ4gMgDUUNACAOIBAgASAIIA0Q4wMLIAAoAugCIgQgACgCCCICTw0BIAAoAgQgBEEGdGoiCiAKKAI4IAFqIgQ2AjggACgC6AIhAiAKKAIgIARGBEAgACACQQFqIgI2AugCCyABIA9sIAxqIQwgAiAAKAIISQ0ACyAAKALwBCEHDAMLIAQgAkGkx8EAEIwHAAtBACAIIARBhKTHABDqBwALAkACQAJAAkACQAJAAkACQAJAIAAoAvwDIgEEQCAAKALwBCEFIABB9ARqIRsgAEFAayEcIAAoAoAEIQIDQEGAgAQhBwJAAkACQAJAAkAgBSARayIIIAFuIgogACgC+AMiBCACayIBQQAgASAETRsiASABIApLGyIBQYCABEsNACABIgcNACAFIBFJDQFBACECIABBADYC8AQCQCARBEAgBSARRg0UIAhFDQEgACgC7AQiASABIBFqIAj8CgAAIAAgCDYC8AQMFAsgBSARRg0TCyAAIAg2AvAEDBILIAAgBxDsAUEBIQFBACEIQQAhC0EAIQUCQANAIAEhCiAAKAKoAyAALQCsAyAAKALsBCAAKALwBCAAKAL8AyAFbCARaiIGELAEISggBUEDbCIBIAAoApAEIglPDRAgAUECdCINIAAoAowEaiAoOAIAIAAoArADIAAtALQDIAAoAuwEIAAoAvAEIAYQsAQhKCABQQFqIgQgACgCkAQiCU8EQCAEIQEMEQsgBEECdCIPIAAoAowEaiAoOAIAIAAoArgDIAAtALwDIAAoAuwEIAAoAvAEIAYQsAQhKCABQQJqIgIgACgCkAQiCU8EQCACIQEMEQsgAkECdCIQIAAoAowEaiAoOAIAIAAoAvADIAAtAPQDIAAoAuwEIAAoAvAEIAYQsAQhKCAAKAKcBCIOIAVNBEAgBSAOQZTFwQAQjAcACyAAKAKYBCAFQQJ0akMAAIA/ICiMEIkEQwAAgD+SlTgCACAAKALYAyAALQDcAyAAKALsBCAAKALwBCAGELAEISggASAAKAKoBCIJTw0EIAAoAqQEIA1qIChDu26QPpRDAAAAP5I4AgAgACgC4AMgAC0A5AMgACgC7AQgACgC8AQgBhCwBCEoIAAoAqgEIgkgBE0EQCAEIQEMBQsgACgCpAQgD2ogKEO7bpA+lEMAAAA/kjgCACAAKALoAyAALQDsAyAAKALsBCAAKALwBCAGELAEISggACgCqAQiCSACTQRAIAIhAQwFCyAAKAKkBCAQaiAoQ7tukD6UQwAAAD+SOAIAIAAoAsADIAAtAMQDIAAoAuwEIAAoAvAEIAYQsAQhKAJAAkACQAJAAkAgASAAKAK0BCIJTw0AIAAoArAEIA1qICgQiQQ4AgAgACgCyAMgAC0AzAMgACgC7AQgACgC8AQgBhCwBCEoIAAoArQEIgkgBCIBTQ0AIAAoArAEIA9qICgQiQQ4AgAgACgC0AMgAC0A1AMgACgC7AQgACgC8AQgBhCwBCEoIAAoArQEIgkgAiIBTQ0AIAAoArAEIBBqICgQiQQ4AgAgACgCICAALQAkIAAoAuwEIAAoAvAEIAYQsAQhKCAAKAIoIAAtACwgACgC7AQgACgC8AQgBhCwBCEpIAAoAjAgAC0ANCAAKALsBCAAKALwBCAGELAEISogACgCOCAALQA8IAAoAuwEIAAoAvAEIAYQsAQhKyAFQQJ0IgEgACgCwAQiAkkNAQwCCyABIAlB5MXBABCMBwALIAAoArwEIAFBAnRqICggKCAolCApICmUkiAqICqUkiArICuUkpEiKJU4AgAgAUEBciIEIAAoAsAEIgJPBEAgBCEBDAELIAAoArwEIARBAnRqICkgKJU4AgAgAUECciIEIAAoAsAEIgJPBEAgBCEBDAELIAAoArwEIARBAnRqICogKJU4AgAgAUEDciIBIAAoAsAEIgJPDQAgACgCvAQgAUECdGogKyAolTgCACAALQDkAiIBQQhHDQEMAgsgASACQdTFwQAQjAcACyAALQCkAyESIAAoAqADIAAtAJwDIRQgACgCmAMgAC0AlAMhFiAAKAKQAyAALQCMAyEYIAAoAogDIAAtAIQDIRogACgCgAMgAC0A/AIhDCAAKAL4AiAALQD0AiEPIAAoAvACIAAtAOwCIQ4gACgC6AIgACgC4AIgASAAKALsBCAAKALwBCAGELAEISggBUEJbCIBIAAoAswEIgJPDQQgACgCyAQgAUECdGogKDgCACAOIAAoAuwEIAAoAvAEIAYQsAQhKCABQQFqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAPIAAoAuwEIAAoAvAEIAYQsAQhKCABQQJqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAMIAAoAuwEIAAoAvAEIAYQsAQhKCABQQNqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAaIAAoAuwEIAAoAvAEIAYQsAQhKCABQQRqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAYIAAoAuwEIAAoAvAEIAYQsAQhKCABQQVqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAWIAAoAuwEIAAoAvAEIAYQsAQhKCABQQZqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAUIAAoAuwEIAAoAvAEIAYQsAQhKCABQQdqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACASIAAoAuwEIAAoAvAEIAYQsAQhKCABQQhqIgEgACgCzAQiAk8NBCAAKALIBCABQQJ0aiAoOAIACyAALQDsASIBQQhHBEAgAC0A3AIhHSAAKALYAiAALQDUAiEfIAAoAtACIAAtAMwCISEgACgCyAIgAC0AxAIhIyAAKALAAiAALQC8AiElIAAoArgCIAAtALQCIScgACgCsAIgAC0ArAIhEyAAKAKoAiAALQCkAiEVIAAoAqACIAAtAJwCIRcgACgCmAIgAC0AlAIhGSAAKAKQAiAALQCMAiEJIAAoAogCIAAtAIQCIQ0gACgCgAIgAC0A/AEhECAAKAL4ASAALQD0ASEEIAAoAvABIAAoAugBIAEgACgC7AQgACgC8AQgBhCwBCEoIAVBD2wiASAAKALYBCIFTw0CIAAoAtQEIAFBAnRqICg4AgAgBCAAKALsBCAAKALwBCAGELAEISggAUEBaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgECAAKALsBCAAKALwBCAGELAEISggAUECaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgDSAAKALsBCAAKALwBCAGELAEISggAUEDaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgCSAAKALsBCAAKALwBCAGELAEISggAUEEaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgGSAAKALsBCAAKALwBCAGELAEISggAUEFaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgFyAAKALsBCAAKALwBCAGELAEISggAUEGaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgFSAAKALsBCAAKALwBCAGELAEISggAUEHaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgEyAAKALsBCAAKALwBCAGELAEISggAUEIaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgJyAAKALsBCAAKALwBCAGELAEISggAUEJaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgJSAAKALsBCAAKALwBCAGELAEISggAUEKaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgIyAAKALsBCAAKALwBCAGELAEISggAUELaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgISAAKALsBCAAKALwBCAGELAEISggAUEMaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgHyAAKALsBCAAKALwBCAGELAEISggAUENaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgHSAAKALsBCAAKALwBCAGELAEISggAUEOaiIBIAAoAtgEIgVPDQIgACgC1AQgAUECdGogKDgCAAsCQCAALQBEQQhHBEAgA0HYB2ogHEGoAfwKAABBACEFIAghAiALIQEDQCADQdgHaiAFaiIEKAIAIARBBGotAAAgACgC7AQgACgC8AQgBhCwBCEoIAEgACgC5AQiBE8NAiAAKALgBCACaiAoOAIAIAJBBGohAiABQQFqIQEgBUEIaiIFQagBRw0ACwsgCEHUAGohCCALQRVqIQsgCiAHIApLIgJqIQEgCiEFIAJFDQYMAQsLIAEgBEHExcEAEIwHAAsgASAFQbTFwQAQjAcAC0EAIBEgBUGEpMcAEOoHAAsgASACQaTFwQAQjAcACyABIAlB9MXBABCMBwALIAdBA2wiCSAAKAKQBCIBSw0CIAcgACgCnAQiAUsNAyAJIAAoAqgEIgFLDQQgCSAAKAK0BCIBSw0FIAdBAnQiDCAAKALABCIBSw0GIAdBCWxBACAAKAKEBCICGyINIAAoAswEIgFLDQcgB0EPbEEAIAJBAUsbIg8gACgC2AQiAUsNCCAHQRVsQQAgAkECSxsiECAAKALkBCIBSw0JIAAoAoAEIQ4gACgCjAQhCyAAKAKYBCEIIAAoAqQEIQUgACgCsAQhCiAAKAK8BCEEIAAoAsgEIQIgACgC1AQhASADQgQ3AqAIIANCAjcCmAggAyAQNgKUCCADIA82AowIIAMgATYCiAggAyANNgKECCADIAI2AoAIIAMgDDYC/AcgAyAENgL4ByADIAk2AvQHIAMgCjYC8AcgAyAJNgLsByADIAU2AugHIAMgBzYC5AcgAyAINgLgByADIAk2AtwHIAMgCzYC2AcgAyAAKALgBDYCkAggGyAOIAcgA0HYB2oQlwEgACAAKAKABCAHaiICNgKABCAAKAL8AyIBIAdsIBFqIREgACgC8AQhBSABDQALC0GExMEAEIEIAAtBACAJIAFBhMXBABDqBwALQQAgByABQfTEwQAQ6gcAC0EAIAkgAUHkxMEAEOoHAAtBACAJIAFB1MTBABDqBwALQQAgDCABQcTEwQAQ6gcAC0EAIA0gAUG0xMEAEOoHAAtBACAPIAFBpMTBABDqBwALQQAgECABQZTEwQAQ6gcACyABIAlBhMbBABCMBwALIAcgDEkNAkEAIQIgAEEANgLwBCAHIAxrIQEgDARAIAcgDEYNAiABBEAgACgC7AQiBCAEIAxqIAH8CgAACyAAIAE2AvAEDAILIAcgDEYNAQsgACABNgLwBAsgA0HADGokACACDwtBACAMIAdBhKTHABDqBwALQQAgASAKQczDwQAQ6gcAC6EwAyd/BH0BfiMAQcAMayIDJAACQAJAAkACQAJAAkACQCAAKALcBCIBQYGAgIB4RgRAAkAgACgC8AQiCkEESQ0AAkAgACgC7AQiBC8AACAELQACQRB0ckHw2OUDRgRAIApBC0kNAiAKQQprIQJBACEBAkADQCABIARqQfjDwQBBCxDbB0UNASACIAFBAWoiAUcNAAsgCkH//wNNDQMgA0EANgLoByADQQE2AtwHIANB8MPBADYC2AcgA0IENwLgByADQdgHahCSByECDAkLIAEgCksNCiADQdgHaiAEIAEQ+wIgAykC3AchLCADKALYB0EBRgRAICwQzQchAgwJCyADQdgHaiAspyAsQiCIpxBNIAMoAtgHIQIgAygChAkiBEGAgICAeEYEQCACRQ0DDAkLIANBCGpBBHIgA0HYB2oiDkEEckGoAfwKAAAgA0HAAWogA0GQCWopAwAiLDcDACADIAMpA4gJNwO4ASADIAQ2ArQBIAMgAjYCCAJAICynIgpBAXFFBEAgAygCsAEhCCADKAKcASEEIANBmAZqIgIgA0H4AGoQwwMgDiAIIAQgAhCaASADKALYByEFIAMoArQMIg1BgICAgHhGDQEgAygC3AchAiADQbADaiADQeAHakHkAvwKAAAgAygCyAohByADKALECiELIANBoAJqIANBzApqQZAB/AoAACADKALcCyEJIANByAFqIANB4AtqQdQA/AoAACADKQO4DCEsIANBADoA4AcgAyAJNgLcByADIAg2AtgHIABB9ARqIA4Q4QMMAwsgA0GYBmoiAiADQQhqQcAB/AoAACADQdgHaiACEGogAygC3AchAiADKALYByIFQYCAgIB4RgRAIAJFDQQMCgsgA0GwA2ogA0HgB2pB5AL8CgAAIAMoAsQKIQsgAygCyAohByADQQA6AOAHIAMgBzYC3AcgAyALNgLYByAAQfQEaiADQdgHahDhA0GAgICAeCENDAILIANBCGoQoAMgBSICDQgMAgsgA0EANgLoByADQQE2AtwHIANBqKPBADYC2AcgA0IENwLgByADQdgHahCSByECDAcLIAAoAvAEIgQgAUELaiIISQ0CIABBADYC8AQgBCAIRwRAIAQgCGsiBARAIAAoAuwEIgEgASAIaiAE/AoAAAsgACAENgLwBAsCQAJAAkAgACgC3ARBgICAgHhrDgIBAgALIAAQvgIMAQsgABC9AQsgACACNgIEIAAgBTYCACAAQQhqIANBsANqQeQC/AoAACAAIAc2AvACIAAgCzYC7AIgAEH0AmogA0GgAmpBkAH8CgAAIAAgCTYChAQgAEGIBGogA0HIAWpB1AD8CgAAIAAgLDcD4AQgACANNgLcBCAKQQFxDQAgA0EIahCgAwtBACECIAAoAtwEIgFBgYCAgHhGDQULIAFBgICAgHhHDQEgACgC6AIiAiAAKAIITwRAIAAoAvAEIQFBACECIABBADYC8AQgAQ0EDAULIABB9ARqIQ4CQANAAkAgACgCBCACQQZ0aiIIKAIkIg8EQCAPIAAoAvAEIgcgDGsiAk0NAQwGC0GUxsEAEIEIAAsgCC0APCEFQYCABCEBIAIgD24iCiAIKAIgIgQgCCgCOCIQayICQQAgAiAETRsiAiACIApLGyICQYCABE0EQCACIgFFDQULAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBUEBaw4DAgEMAAsgACABIAwgDyAAKALsBCAHEJEDDAsLIAAoAoQBQYCAgIB4Rw0BDAoLIAAgASAQIAwgDyAAKALsBCAHEOcBIgINECABQQNsIgsgACgCICICSw0BIAEgACgCLCICSw0CIAsgACgCOCICSw0DIAsgACgCRCICSw0EIAFBAnQiCCAAKAJQIgJLDQUgACgCHCEFIAAoAighCiAAKAI0IQQgACgCQCECIANCBDcCoAggA0ICNwKYCCADQgQ3ApAIIANCBDcCiAggA0IENwKACCADIAg2AvwHIAMgCzYC9AcgAyACNgLwByADIAs2AuwHIAMgBDYC6AcgAyABNgLkByADIAo2AuAHIAMgCzYC3AcgAyAFNgLYByADIAAoAkw2AvgHIA4gECABIANB2AdqEH4MCQsgACABIAwgDyAAKALsBCAHEOgBIAFBCWwiByAAKAJcIgJLDQUgACgCWCELAkAgACgC8AIiCkECTwRAIAFBD2wiBSAAKAJoIgJNBEAgACgCZCEEIApBAkcNAkEAIQ1BBCEIDAoLQQAgBSACQYTHwQAQ6gcACyAOIBAgASALIAcQ5gEMCQsgAUEVbCINIAAoAnQiAksNBiAAKAJwIQgMBwtBACALIAJB5MbBABDqBwALQQAgASACQdTGwQAQ6gcAC0EAIAsgAkHExsEAEOoHAAtBACALIAJBtMbBABDqBwALQQAgCCACQaTGwQAQ6gcAC0EAIAcgAkGUx8EAEOoHAAtBACANIAJB9MbBABDqBwALIA4gECABIAsgBxDmASAOIBAgASAEIAUQpwEgDUUNACAOIBAgASAIIA0QlAELIAAoAugCIgQgACgCCCICTw0BIAAoAgQgBEEGdGoiCiAKKAI4IAFqIgQ2AjggACgC6AIhAiAKKAIgIARGBEAgACACQQFqIgI2AugCCyABIA9sIAxqIQwgAiAAKAIISQ0ACyAAKALwBCEHDAMLIAQgAkGkx8EAEIwHAAtBACAIIARBhKTHABDqBwALAkACQAJAAkACQAJAAkACQAJAIAAoAvwDIgEEQCAAKALwBCEFIABB9ARqIRsgAEFAayEcIAAoAoAEIQIDQEGAgAQhBwJAAkACQAJAAkAgBSARayIIIAFuIgogACgC+AMiBCACayIBQQAgASAETRsiASABIApLGyIBQYCABEsNACABIgcNACAFIBFJDQFBACECIABBADYC8AQCQCARBEAgBSARRg0UIAhFDQEgACgC7AQiASABIBFqIAj8CgAAIAAgCDYC8AQMFAsgBSARRg0TCyAAIAg2AvAEDBILIAAgBxDsAUEBIQFBACEIQQAhC0EAIQUCQANAIAEhCiAAKAKoAyAALQCsAyAAKALsBCAAKALwBCAAKAL8AyAFbCARaiIGELAEISggBUEDbCIBIAAoApAEIglPDRAgAUECdCINIAAoAowEaiAoOAIAIAAoArADIAAtALQDIAAoAuwEIAAoAvAEIAYQsAQhKCABQQFqIgQgACgCkAQiCU8EQCAEIQEMEQsgBEECdCIPIAAoAowEaiAoOAIAIAAoArgDIAAtALwDIAAoAuwEIAAoAvAEIAYQsAQhKCABQQJqIgIgACgCkAQiCU8EQCACIQEMEQsgAkECdCIQIAAoAowEaiAoOAIAIAAoAvADIAAtAPQDIAAoAuwEIAAoAvAEIAYQsAQhKCAAKAKcBCIOIAVNBEAgBSAOQZTFwQAQjAcACyAAKAKYBCAFQQJ0akMAAIA/ICiMEIkEQwAAgD+SlTgCACAAKALYAyAALQDcAyAAKALsBCAAKALwBCAGELAEISggASAAKAKoBCIJTw0EIAAoAqQEIA1qIChDu26QPpRDAAAAP5I4AgAgACgC4AMgAC0A5AMgACgC7AQgACgC8AQgBhCwBCEoIAAoAqgEIgkgBE0EQCAEIQEMBQsgACgCpAQgD2ogKEO7bpA+lEMAAAA/kjgCACAAKALoAyAALQDsAyAAKALsBCAAKALwBCAGELAEISggACgCqAQiCSACTQRAIAIhAQwFCyAAKAKkBCAQaiAoQ7tukD6UQwAAAD+SOAIAIAAoAsADIAAtAMQDIAAoAuwEIAAoAvAEIAYQsAQhKAJAAkACQAJAAkAgASAAKAK0BCIJTw0AIAAoArAEIA1qICgQiQQ4AgAgACgCyAMgAC0AzAMgACgC7AQgACgC8AQgBhCwBCEoIAAoArQEIgkgBCIBTQ0AIAAoArAEIA9qICgQiQQ4AgAgACgC0AMgAC0A1AMgACgC7AQgACgC8AQgBhCwBCEoIAAoArQEIgkgAiIBTQ0AIAAoArAEIBBqICgQiQQ4AgAgACgCICAALQAkIAAoAuwEIAAoAvAEIAYQsAQhKCAAKAIoIAAtACwgACgC7AQgACgC8AQgBhCwBCEpIAAoAjAgAC0ANCAAKALsBCAAKALwBCAGELAEISogACgCOCAALQA8IAAoAuwEIAAoAvAEIAYQsAQhKyAFQQJ0IgEgACgCwAQiAkkNAQwCCyABIAlB5MXBABCMBwALIAAoArwEIAFBAnRqICggKCAolCApICmUkiAqICqUkiArICuUkpEiKJU4AgAgAUEBciIEIAAoAsAEIgJPBEAgBCEBDAELIAAoArwEIARBAnRqICkgKJU4AgAgAUECciIEIAAoAsAEIgJPBEAgBCEBDAELIAAoArwEIARBAnRqICogKJU4AgAgAUEDciIBIAAoAsAEIgJPDQAgACgCvAQgAUECdGogKyAolTgCACAALQDkAiIBQQhHDQEMAgsgASACQdTFwQAQjAcACyAALQCkAyESIAAoAqADIAAtAJwDIRQgACgCmAMgAC0AlAMhFiAAKAKQAyAALQCMAyEYIAAoAogDIAAtAIQDIRogACgCgAMgAC0A/AIhDCAAKAL4AiAALQD0AiEPIAAoAvACIAAtAOwCIQ4gACgC6AIgACgC4AIgASAAKALsBCAAKALwBCAGELAEISggBUEJbCIBIAAoAswEIgJPDQQgACgCyAQgAUECdGogKDgCACAOIAAoAuwEIAAoAvAEIAYQsAQhKCABQQFqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAPIAAoAuwEIAAoAvAEIAYQsAQhKCABQQJqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAMIAAoAuwEIAAoAvAEIAYQsAQhKCABQQNqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAaIAAoAuwEIAAoAvAEIAYQsAQhKCABQQRqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAYIAAoAuwEIAAoAvAEIAYQsAQhKCABQQVqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAWIAAoAuwEIAAoAvAEIAYQsAQhKCABQQZqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACAUIAAoAuwEIAAoAvAEIAYQsAQhKCABQQdqIgQgACgCzAQiAk8EQCAEIQEMBQsgACgCyAQgBEECdGogKDgCACASIAAoAuwEIAAoAvAEIAYQsAQhKCABQQhqIgEgACgCzAQiAk8NBCAAKALIBCABQQJ0aiAoOAIACyAALQDsASIBQQhHBEAgAC0A3AIhHSAAKALYAiAALQDUAiEfIAAoAtACIAAtAMwCISEgACgCyAIgAC0AxAIhIyAAKALAAiAALQC8AiElIAAoArgCIAAtALQCIScgACgCsAIgAC0ArAIhEyAAKAKoAiAALQCkAiEVIAAoAqACIAAtAJwCIRcgACgCmAIgAC0AlAIhGSAAKAKQAiAALQCMAiEJIAAoAogCIAAtAIQCIQ0gACgCgAIgAC0A/AEhECAAKAL4ASAALQD0ASEEIAAoAvABIAAoAugBIAEgACgC7AQgACgC8AQgBhCwBCEoIAVBD2wiASAAKALYBCIFTw0CIAAoAtQEIAFBAnRqICg4AgAgBCAAKALsBCAAKALwBCAGELAEISggAUEBaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgECAAKALsBCAAKALwBCAGELAEISggAUECaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgDSAAKALsBCAAKALwBCAGELAEISggAUEDaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgCSAAKALsBCAAKALwBCAGELAEISggAUEEaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgGSAAKALsBCAAKALwBCAGELAEISggAUEFaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgFyAAKALsBCAAKALwBCAGELAEISggAUEGaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgFSAAKALsBCAAKALwBCAGELAEISggAUEHaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgEyAAKALsBCAAKALwBCAGELAEISggAUEIaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgJyAAKALsBCAAKALwBCAGELAEISggAUEJaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgJSAAKALsBCAAKALwBCAGELAEISggAUEKaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgIyAAKALsBCAAKALwBCAGELAEISggAUELaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgISAAKALsBCAAKALwBCAGELAEISggAUEMaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgHyAAKALsBCAAKALwBCAGELAEISggAUENaiICIAAoAtgEIgVPBEAgAiEBDAMLIAAoAtQEIAJBAnRqICg4AgAgHSAAKALsBCAAKALwBCAGELAEISggAUEOaiIBIAAoAtgEIgVPDQIgACgC1AQgAUECdGogKDgCAAsCQCAALQBEQQhHBEAgA0HYB2ogHEGoAfwKAABBACEFIAghAiALIQEDQCADQdgHaiAFaiIEKAIAIARBBGotAAAgACgC7AQgACgC8AQgBhCwBCEoIAEgACgC5AQiBE8NAiAAKALgBCACaiAoOAIAIAJBBGohAiABQQFqIQEgBUEIaiIFQagBRw0ACwsgCEHUAGohCCALQRVqIQsgCiAHIApLIgJqIQEgCiEFIAJFDQYMAQsLIAEgBEHExcEAEIwHAAsgASAFQbTFwQAQjAcAC0EAIBEgBUGEpMcAEOoHAAsgASACQaTFwQAQjAcACyABIAlB9MXBABCMBwALIAdBA2wiCSAAKAKQBCIBSw0CIAcgACgCnAQiAUsNAyAJIAAoAqgEIgFLDQQgCSAAKAK0BCIBSw0FIAdBAnQiDCAAKALABCIBSw0GIAdBCWxBACAAKAKEBCICGyINIAAoAswEIgFLDQcgB0EPbEEAIAJBAUsbIg8gACgC2AQiAUsNCCAHQRVsQQAgAkECSxsiECAAKALkBCIBSw0JIAAoAoAEIQ4gACgCjAQhCyAAKAKYBCEIIAAoAqQEIQUgACgCsAQhCiAAKAK8BCEEIAAoAsgEIQIgACgC1AQhASADQgQ3AqAIIANCAjcCmAggAyAQNgKUCCADIA82AowIIAMgATYCiAggAyANNgKECCADIAI2AoAIIAMgDDYC/AcgAyAENgL4ByADIAk2AvQHIAMgCjYC8AcgAyAJNgLsByADIAU2AugHIAMgBzYC5AcgAyAINgLgByADIAk2AtwHIAMgCzYC2AcgAyAAKALgBDYCkAggGyAOIAcgA0HYB2oQfiAAIAAoAoAEIAdqIgI2AoAEIAAoAvwDIgEgB2wgEWohESAAKALwBCEFIAENAAsLQYTEwQAQgQgAC0EAIAkgAUGExcEAEOoHAAtBACAHIAFB9MTBABDqBwALQQAgCSABQeTEwQAQ6gcAC0EAIAkgAUHUxMEAEOoHAAtBACAMIAFBxMTBABDqBwALQQAgDSABQbTEwQAQ6gcAC0EAIA8gAUGkxMEAEOoHAAtBACAQIAFBlMTBABDqBwALIAEgCUGExsEAEIwHAAsgByAMSQ0CQQAhAiAAQQA2AvAEIAcgDGshASAMBEAgByAMRg0CIAEEQCAAKALsBCIEIAQgDGogAfwKAAALIAAgATYC8AQMAgsgByAMRg0BCyAAIAE2AvAECyADQcAMaiQAIAIPC0EAIAwgB0GEpMcAEOoHAAtBACABIApBzMPBABDqBwALiTADJ38EfQF+IwBBwAxrIgMkAAJAAkACQAJAAkACQAJAIAAoApwFIgFBgYCAgHhGBEACQCAAKAKwBSIIQQRJDQACQCAAKAKsBSIELwAAIAQtAAJBEHRyQfDY5QNGBEAgCEELSQ0CIAhBCmshAkEAIQECQANAIAEgBGpB+MPBAEELENsHRQ0BIAIgAUEBaiIBRw0ACyAIQf//A00NAyADQQA2AugHIANBATYC3AcgA0Hww8EANgLYByADQgQ3AuAHIANB2AdqEJIHIQIMCQsgASAISw0KIANB2AdqIAQgARD7AiADKQLcByEsIAMoAtgHQQFGBEAgLBDNByECDAkLIANB2AdqICynICxCIIinEE0gAygC2AchAiADKAKECSIEQYCAgIB4RgRAIAJFDQMMCQsgA0EIakEEciADQdgHaiIJQQRyQagB/AoAACADQcABaiADQZAJaikDACIsNwMAIAMgAykDiAk3A7gBIAMgBDYCtAEgAyACNgIIAkAgLKciCEEBcUUEQCADKAKwASEHIAMoApwBIQQgA0GYBmoiAiADQfgAahDDAyAJIAcgBCACEJoBIAMoAtgHIQUgAygCtAwiCkGAgICAeEYNASADKALcByECIANBsANqIANB4AdqQeQC/AoAACADKALICiELIAMoAsQKIQ4gA0GgAmogA0HMCmpBkAH8CgAAIAMoAtwLIQ0gA0HIAWogA0HgC2pB1AD8CgAAIAMpA7gMISwgA0EAOgDgByADIA02AtwHIAMgBzYC2AcgACAJEIQCDAMLIANBmAZqIgIgA0EIakHAAfwKAAAgA0HYB2ogAhBqIAMoAtwHIQIgAygC2AciBUGAgICAeEYEQCACRQ0EDAoLIANBsANqIANB4AdqQeQC/AoAACADKALECiEOIAMoAsgKIQsgA0EAOgDgByADIAs2AtwHIAMgDjYC2AcgACADQdgHahCEAkGAgICAeCEKDAILIANBCGoQoAMgBSICDQgMAgsgA0EANgLoByADQQE2AtwHIANBqKPBADYC2AcgA0IENwLgByADQdgHahCSByECDAcLIAAoArAFIgQgAUELaiIHSQ0CIABBADYCsAUgBCAHRwRAIAQgB2siBARAIAAoAqwFIgEgASAHaiAE/AoAAAsgACAENgKwBQsgAEFAayEBAkACQAJAIAAoApwFQYCAgIB4aw4CAQIACyABEL4CDAELIAEQvQELIAAgAjYCRCAAIAU2AkAgAEHIAGogA0GwA2pB5AL8CgAAIAAgCzYCsAMgACAONgKsAyAAQbQDaiADQaACakGQAfwKAAAgACANNgLEBCAAQcgEaiADQcgBakHUAPwKAAAgACAsNwOgBSAAIAo2ApwFIAhBAXENACADQQhqEKADC0EAIQIgACgCnAUiAUGBgICAeEYNBQsgAEFAayESIAFBgICAgHhHDQEgACgCqAMiAiAAKAJITwRAIAAoArAFIQFBACECIABBADYCsAUgAQ0EDAULAkADQAJAIAAoAkQgAkEGdGoiBygCJCIJBEAgCSAAKAKwBSILIAxrIgJNDQEMBgtBlMbBABCBCAALIActADwhBUGAgAQhASACIAluIgggBygCICIEIAcoAjgiDmsiAkEAIAIgBE0bIgIgAiAISxsiAkGAgARNBEAgAiIBRQ0FCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAVBAWsOAwIBDAALIBIgASAMIAkgACgCrAUgCxCRAwwLCyAAKALEAUGAgICAeEcNAQwKCyASIAEgDiAMIAkgACgCrAUgCxDnASICDRAgAUEDbCIKIAAoAmAiAksNASABIAAoAmwiAksNAiAKIAAoAngiAksNAyAKIAAoAoQBIgJLDQQgAUECdCIHIAAoApABIgJLDQUgACgCXCEFIAAoAmghCCAAKAJ0IQQgACgCgAEhAiADQgQ3AqAIIANCAjcCmAggA0IENwKQCCADQgQ3AogIIANCBDcCgAggAyAHNgL8ByADIAo2AvQHIAMgAjYC8AcgAyAKNgLsByADIAQ2AugHIAMgATYC5AcgAyAINgLgByADIAo2AtwHIAMgBTYC2AcgAyAAKAKMATYC+AcgACAOIAEgA0HYB2oQ4gEMCQsgEiABIAwgCSAAKAKsBSALEOgBIAFBCWwiByAAKAKcASICSw0FIAAoApgBIQVBACEKIAAoArADIgRBAkkEQCAAIA4gASAFIAdBBEEAQQRBABDbAwwJCyABQQ9sIgggACgCqAEiAksNBiAAIA4gASAFIAcgACgCpAEgCCAEQQJHBH8gAUEVbCIKIAAoArQBIgJLDQggACgCsAEFQQQLIAoQ2wMMCAtBACAKIAJB5MbBABDqBwALQQAgASACQdTGwQAQ6gcAC0EAIAogAkHExsEAEOoHAAtBACAKIAJBtMbBABDqBwALQQAgByACQaTGwQAQ6gcAC0EAIAcgAkGUx8EAEOoHAAtBACAIIAJBhMfBABDqBwALQQAgCiACQfTGwQAQ6gcACyAAKAKoAyIEIAAoAkgiAk8NASAAKAJEIARBBnRqIgggCCgCOCABaiIENgI4IAAoAqgDIQIgCCgCICAERgRAIAAgAkEBaiICNgKoAwsgASAJbCAMaiEMIAIgACgCSEkNAAsgACgCsAUhCwwDCyAEIAJBpMfBABCMBwALQQAgByAEQYSkxwAQ6gcACwJAAkACQAJAAkACQAJAAkACQCAAKAK8BCIBBEAgACgCsAUhBSAAQYABaiEcIAAoAsAEIQIDQEGAgAQhCQJAAkACQAJAAkAgBSAQayIHIAFuIgggACgCuAQiBCACayIBQQAgASAETRsiASABIAhLGyIBQYCABEsNACABIgkNACAFIBBJDQFBACECIABBADYCsAUCQCAQBEAgBSAQRg0UIAdFDQEgACgCrAUiASABIBBqIAf8CgAAIAAgBzYCsAUMFAsgBSAQRg0TCyAAIAc2ArAFDBILIBIgCRDsAUEBIQFBACEHQQAhDkEAIQUCQANAIAEhCCAAKALoAyAALQDsAyAAKAKsBSAAKAKwBSAAKAK8BCAFbCAQaiIGELAEISggBUEDbCIBIAAoAtAEIg1PDRAgAUECdCIRIAAoAswEaiAoOAIAIAAoAvADIAAtAPQDIAAoAqwFIAAoArAFIAYQsAQhKCABQQFqIgQgACgC0AQiDU8EQCAEIQEMEQsgBEECdCILIAAoAswEaiAoOAIAIAAoAvgDIAAtAPwDIAAoAqwFIAAoArAFIAYQsAQhKCABQQJqIgIgACgC0AQiDU8EQCACIQEMEQsgAkECdCIMIAAoAswEaiAoOAIAIAAoArAEIAAtALQEIAAoAqwFIAAoArAFIAYQsAQhKCAAKALcBCIKIAVNBEAgBSAKQZTFwQAQjAcACyAAKALYBCAFQQJ0akMAAIA/ICiMEIkEQwAAgD+SlTgCACAAKAKYBCAALQCcBCAAKAKsBSAAKAKwBSAGELAEISggASAAKALoBCINTw0EIAAoAuQEIBFqIChDu26QPpRDAAAAP5I4AgAgACgCoAQgAC0ApAQgACgCrAUgACgCsAUgBhCwBCEoIAAoAugEIg0gBE0EQCAEIQEMBQsgACgC5AQgC2ogKEO7bpA+lEMAAAA/kjgCACAAKAKoBCAALQCsBCAAKAKsBSAAKAKwBSAGELAEISggACgC6AQiDSACTQRAIAIhAQwFCyAAKALkBCAMaiAoQ7tukD6UQwAAAD+SOAIAIAAoAoAEIAAtAIQEIAAoAqwFIAAoArAFIAYQsAQhKAJAAkACQAJAAkAgASAAKAL0BCINTw0AIAAoAvAEIBFqICgQiQQ4AgAgACgCiAQgAC0AjAQgACgCrAUgACgCsAUgBhCwBCEoIAAoAvQEIg0gBCIBTQ0AIAAoAvAEIAtqICgQiQQ4AgAgACgCkAQgAC0AlAQgACgCrAUgACgCsAUgBhCwBCEoIAAoAvQEIg0gAiIBTQ0AIAAoAvAEIAxqICgQiQQ4AgAgACgCYCAALQBkIAAoAqwFIAAoArAFIAYQsAQhKCAAKAJoIAAtAGwgACgCrAUgACgCsAUgBhCwBCEpIAAoAnAgAC0AdCAAKAKsBSAAKAKwBSAGELAEISogACgCeCAALQB8IAAoAqwFIAAoArAFIAYQsAQhKyAFQQJ0IgEgACgCgAUiAkkNAQwCCyABIA1B5MXBABCMBwALIAAoAvwEIAFBAnRqICggKCAolCApICmUkiAqICqUkiArICuUkpEiKJU4AgAgAUEBciIEIAAoAoAFIgJPBEAgBCEBDAELIAAoAvwEIARBAnRqICkgKJU4AgAgAUECciIEIAAoAoAFIgJPBEAgBCEBDAELIAAoAvwEIARBAnRqICogKJU4AgAgAUEDciIBIAAoAoAFIgJPDQAgACgC/AQgAUECdGogKyAolTgCACAALQCkAyIBQQhHDQEMAgsgASACQdTFwQAQjAcACyAALQDkAyETIAAoAuADIAAtANwDIRUgACgC2AMgAC0A1AMhFyAAKALQAyAALQDMAyEZIAAoAsgDIAAtAMQDIRsgACgCwAMgAC0AvAMhDSAAKAK4AyAALQC0AyELIAAoArADIAAtAKwDIQogACgCqAMgACgCoAMgASAAKAKsBSAAKAKwBSAGELAEISggBUEJbCIBIAAoAowFIgJPDQQgACgCiAUgAUECdGogKDgCACAKIAAoAqwFIAAoArAFIAYQsAQhKCABQQFqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACALIAAoAqwFIAAoArAFIAYQsAQhKCABQQJqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACANIAAoAqwFIAAoArAFIAYQsAQhKCABQQNqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACAbIAAoAqwFIAAoArAFIAYQsAQhKCABQQRqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACAZIAAoAqwFIAAoArAFIAYQsAQhKCABQQVqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACAXIAAoAqwFIAAoArAFIAYQsAQhKCABQQZqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACAVIAAoAqwFIAAoArAFIAYQsAQhKCABQQdqIgQgACgCjAUiAk8EQCAEIQEMBQsgACgCiAUgBEECdGogKDgCACATIAAoAqwFIAAoArAFIAYQsAQhKCABQQhqIgEgACgCjAUiAk8NBCAAKAKIBSABQQJ0aiAoOAIACyAALQCsAiIBQQhHBEAgAC0AnAMhHSAAKAKYAyAALQCUAyEfIAAoApADIAAtAIwDISEgACgCiAMgAC0AhAMhIyAAKAKAAyAALQD8AiElIAAoAvgCIAAtAPQCIScgACgC8AIgAC0A7AIhFCAAKALoAiAALQDkAiEWIAAoAuACIAAtANwCIRggACgC2AIgAC0A1AIhGiAAKALQAiAALQDMAiEPIAAoAsgCIAAtAMQCIREgACgCwAIgAC0AvAIhDCAAKAK4AiAALQC0AiEEIAAoArACIAAoAqgCIAEgACgCrAUgACgCsAUgBhCwBCEoIAVBD2wiASAAKAKYBSIFTw0CIAAoApQFIAFBAnRqICg4AgAgBCAAKAKsBSAAKAKwBSAGELAEISggAUEBaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgDCAAKAKsBSAAKAKwBSAGELAEISggAUECaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgESAAKAKsBSAAKAKwBSAGELAEISggAUEDaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgDyAAKAKsBSAAKAKwBSAGELAEISggAUEEaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgGiAAKAKsBSAAKAKwBSAGELAEISggAUEFaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgGCAAKAKsBSAAKAKwBSAGELAEISggAUEGaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgFiAAKAKsBSAAKAKwBSAGELAEISggAUEHaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgFCAAKAKsBSAAKAKwBSAGELAEISggAUEIaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgJyAAKAKsBSAAKAKwBSAGELAEISggAUEJaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgJSAAKAKsBSAAKAKwBSAGELAEISggAUEKaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgIyAAKAKsBSAAKAKwBSAGELAEISggAUELaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgISAAKAKsBSAAKAKwBSAGELAEISggAUEMaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgHyAAKAKsBSAAKAKwBSAGELAEISggAUENaiICIAAoApgFIgVPBEAgAiEBDAMLIAAoApQFIAJBAnRqICg4AgAgHSAAKAKsBSAAKAKwBSAGELAEISggAUEOaiIBIAAoApgFIgVPDQIgACgClAUgAUECdGogKDgCAAsCQCAALQCEAUEIRwRAIANB2AdqIBxBqAH8CgAAQQAhBSAHIQIgDiEBA0AgA0HYB2ogBWoiBCgCACAEQQRqLQAAIAAoAqwFIAAoArAFIAYQsAQhKCABIAAoAqQFIgRPDQIgACgCoAUgAmogKDgCACACQQRqIQIgAUEBaiEBIAVBCGoiBUGoAUcNAAsLIAdB1ABqIQcgDkEVaiEOIAggCCAJSSICaiEBIAghBSACRQ0GDAELCyABIARBxMXBABCMBwALIAEgBUG0xcEAEIwHAAtBACAQIAVBhKTHABDqBwALIAEgAkGkxcEAEIwHAAsgASANQfTFwQAQjAcACyAJQQNsIg8gACgC0AQiAUsNAiAJIAAoAtwEIgFLDQMgDyAAKALoBCIBSw0EIA8gACgC9AQiAUsNBSAJQQJ0Ig0gACgCgAUiAUsNBiAJQQlsQQAgACgCxAQiAhsiESAAKAKMBSIBSw0HIAlBD2xBACACQQFLGyILIAAoApgFIgFLDQggCUEVbEEAIAJBAksbIgwgACgCpAUiAUsNCSAAKALABCEKIAAoAswEIQ4gACgC2AQhByAAKALkBCEFIAAoAvAEIQggACgC/AQhBCAAKAKIBSECIAAoApQFIQEgA0IENwKgCCADQgI3ApgIIAMgDDYClAggAyALNgKMCCADIAE2AogIIAMgETYChAggAyACNgKACCADIA02AvwHIAMgBDYC+AcgAyAPNgL0ByADIAg2AvAHIAMgDzYC7AcgAyAFNgLoByADIAk2AuQHIAMgBzYC4AcgAyAPNgLcByADIA42AtgHIAMgACgCoAU2ApAIIAAgCiAJIANB2AdqEOIBIAAgACgCwAQgCWoiAjYCwAQgACgCvAQiASAJbCAQaiEQIAAoArAFIQUgAQ0ACwtBhMTBABCBCAALQQAgDyABQYTFwQAQ6gcAC0EAIAkgAUH0xMEAEOoHAAtBACAPIAFB5MTBABDqBwALQQAgDyABQdTEwQAQ6gcAC0EAIA0gAUHExMEAEOoHAAtBACARIAFBtMTBABDqBwALQQAgCyABQaTEwQAQ6gcAC0EAIAwgAUGUxMEAEOoHAAsgASANQYTGwQAQjAcACyALIAxJDQJBACECIABBADYCsAUgCyAMayEBIAwEQCALIAxGDQIgAQRAIAAoAqwFIgQgBCAMaiAB/AoAAAsgACABNgKwBQwCCyALIAxGDQELIAAgATYCsAULIANBwAxqJAAgAg8LQQAgDCALQYSkxwAQ6gcAC0EAIAEgCEHMw8EAEOoHAAuYMAMnfwR9AX4jAEHADGsiAyQAAkACQAJAAkACQAJAAkAgACgCvAUiAUGBgICAeEYEQAJAIAAoAtAFIghBBEkNAAJAIAAoAswFIgQvAAAgBC0AAkEQdHJB8NjlA0YEQCAIQQtJDQIgCEEKayECQQAhAQJAA0AgASAEakH4w8EAQQsQ2wdFDQEgAiABQQFqIgFHDQALIAhB//8DTQ0DIANBADYC6AcgA0EBNgLcByADQfDDwQA2AtgHIANCBDcC4AcgA0HYB2oQkgchAgwJCyABIAhLDQogA0HYB2ogBCABEPsCIAMpAtwHISwgAygC2AdBAUYEQCAsEM0HIQIMCQsgA0HYB2ogLKcgLEIgiKcQTSADKALYByECIAMoAoQJIgRBgICAgHhGBEAgAkUNAwwJCyADQQhqQQRyIANB2AdqIglBBHJBqAH8CgAAIANBwAFqIANBkAlqKQMAIiw3AwAgAyADKQOICTcDuAEgAyAENgK0ASADIAI2AggCQCAspyIIQQFxRQRAIAMoArABIQcgAygCnAEhBCADQZgGaiICIANB+ABqEMMDIAkgByAEIAIQmgEgAygC2AchBSADKAK0DCIKQYCAgIB4Rg0BIAMoAtwHIQIgA0GwA2ogA0HgB2pB5AL8CgAAIAMoAsgKIQsgAygCxAohDiADQaACaiADQcwKakGQAfwKAAAgAygC3AshDSADQcgBaiADQeALakHUAPwKAAAgAykDuAwhLCADQQA6AOAHIAMgDTYC3AcgAyAHNgLYByAAIAkQ6QEMAwsgA0GYBmoiAiADQQhqQcAB/AoAACADQdgHaiACEGogAygC3AchAiADKALYByIFQYCAgIB4RgRAIAJFDQQMCgsgA0GwA2ogA0HgB2pB5AL8CgAAIAMoAsQKIQ4gAygCyAohCyADQQA6AOAHIAMgCzYC3AcgAyAONgLYByAAIANB2AdqEOkBQYCAgIB4IQoMAgsgA0EIahCgAyAFIgINCAwCCyADQQA2AugHIANBATYC3AcgA0Goo8EANgLYByADQgQ3AuAHIANB2AdqEJIHIQIMBwsgACgC0AUiBCABQQtqIgdJDQIgAEEANgLQBSAEIAdHBEAgBCAHayIEBEAgACgCzAUiASABIAdqIAT8CgAACyAAIAQ2AtAFCyAAQeAAaiEBAkACQAJAIAAoArwFQYCAgIB4aw4CAQIACyABEL4CDAELIAEQvQELIAAgAjYCZCAAIAU2AmAgAEHoAGogA0GwA2pB5AL8CgAAIAAgCzYC0AMgACAONgLMAyAAQdQDaiADQaACakGQAfwKAAAgACANNgLkBCAAQegEaiADQcgBakHUAPwKAAAgACAsNwPABSAAIAo2ArwFIAhBAXENACADQQhqEKADC0EAIQIgACgCvAUiAUGBgICAeEYNBQsgAEHgAGohEiABQYCAgIB4Rw0BIAAoAsgDIgIgACgCaE8EQCAAKALQBSEBQQAhAiAAQQA2AtAFIAENBAwFCwJAA0ACQCAAKAJkIAJBBnRqIgcoAiQiCQRAIAkgACgC0AUiCyAMayICTQ0BDAYLQZTGwQAQgQgACyAHLQA8IQVBgIAEIQEgAiAJbiIIIAcoAiAiBCAHKAI4Ig5rIgJBACACIARNGyICIAIgCEsbIgJBgIAETQRAIAIiAUUNBQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAFQQFrDgMCAQwACyASIAEgDCAJIAAoAswFIAsQkQMMCwsgACgC5AFBgICAgHhHDQEMCgsgEiABIA4gDCAJIAAoAswFIAsQ5wEiAg0QIAFBA2wiCiAAKAKAASICSw0BIAEgACgCjAEiAksNAiAKIAAoApgBIgJLDQMgCiAAKAKkASICSw0EIAFBAnQiByAAKAKwASICSw0FIAAoAnwhBSAAKAKIASEIIAAoApQBIQQgACgCoAEhAiADQgQ3AqAIIANCAjcCmAggA0IENwKQCCADQgQ3AogIIANCBDcCgAggAyAHNgL8ByADIAo2AvQHIAMgAjYC8AcgAyAKNgLsByADIAQ2AugHIAMgATYC5AcgAyAINgLgByADIAo2AtwHIAMgBTYC2AcgAyAAKAKsATYC+AcgACAOIAEgA0HYB2oQkwIMCQsgEiABIAwgCSAAKALMBSALEOgBIAFBCWwiByAAKAK8ASICSw0FIAAoArgBIQVBACEKIAAoAtADIgRBAkkEQCAAIA4gASAFIAdBBEEAQQRBABDqBAwJCyABQQ9sIgggACgCyAEiAksNBiAAIA4gASAFIAcgACgCxAEgCCAEQQJHBH8gAUEVbCIKIAAoAtQBIgJLDQggACgC0AEFQQQLIAoQ6gQMCAtBACAKIAJB5MbBABDqBwALQQAgASACQdTGwQAQ6gcAC0EAIAogAkHExsEAEOoHAAtBACAKIAJBtMbBABDqBwALQQAgByACQaTGwQAQ6gcAC0EAIAcgAkGUx8EAEOoHAAtBACAIIAJBhMfBABDqBwALQQAgCiACQfTGwQAQ6gcACyAAKALIAyIEIAAoAmgiAk8NASAAKAJkIARBBnRqIgggCCgCOCABaiIENgI4IAAoAsgDIQIgCCgCICAERgRAIAAgAkEBaiICNgLIAwsgASAJbCAMaiEMIAIgACgCaEkNAAsgACgC0AUhCwwDCyAEIAJBpMfBABCMBwALQQAgByAEQYSkxwAQ6gcACwJAAkACQAJAAkACQAJAAkACQCAAKALcBCIBBEAgACgC0AUhBSAAQaABaiEcIAAoAuAEIQIDQEGAgAQhCQJAAkACQAJAAkAgBSAQayIHIAFuIgggACgC2AQiBCACayIBQQAgASAETRsiASABIAhLGyIBQYCABEsNACABIgkNACAFIBBJDQFBACECIABBADYC0AUCQCAQBEAgBSAQRg0UIAdFDQEgACgCzAUiASABIBBqIAf8CgAAIAAgBzYC0AUMFAsgBSAQRg0TCyAAIAc2AtAFDBILIBIgCRDsAUEBIQFBACEHQQAhDkEAIQUCQANAIAEhCCAAKAKIBCAALQCMBCAAKALMBSAAKALQBSAAKALcBCAFbCAQaiIGELAEISggBUEDbCIBIAAoAvAEIg1PDRAgAUECdCIRIAAoAuwEaiAoOAIAIAAoApAEIAAtAJQEIAAoAswFIAAoAtAFIAYQsAQhKCABQQFqIgQgACgC8AQiDU8EQCAEIQEMEQsgBEECdCILIAAoAuwEaiAoOAIAIAAoApgEIAAtAJwEIAAoAswFIAAoAtAFIAYQsAQhKCABQQJqIgIgACgC8AQiDU8EQCACIQEMEQsgAkECdCIMIAAoAuwEaiAoOAIAIAAoAtAEIAAtANQEIAAoAswFIAAoAtAFIAYQsAQhKCAAKAL8BCIKIAVNBEAgBSAKQZTFwQAQjAcACyAAKAL4BCAFQQJ0akMAAIA/ICiMEIkEQwAAgD+SlTgCACAAKAK4BCAALQC8BCAAKALMBSAAKALQBSAGELAEISggASAAKAKIBSINTw0EIAAoAoQFIBFqIChDu26QPpRDAAAAP5I4AgAgACgCwAQgAC0AxAQgACgCzAUgACgC0AUgBhCwBCEoIAAoAogFIg0gBE0EQCAEIQEMBQsgACgChAUgC2ogKEO7bpA+lEMAAAA/kjgCACAAKALIBCAALQDMBCAAKALMBSAAKALQBSAGELAEISggACgCiAUiDSACTQRAIAIhAQwFCyAAKAKEBSAMaiAoQ7tukD6UQwAAAD+SOAIAIAAoAqAEIAAtAKQEIAAoAswFIAAoAtAFIAYQsAQhKAJAAkACQAJAAkAgASAAKAKUBSINTw0AIAAoApAFIBFqICgQiQQ4AgAgACgCqAQgAC0ArAQgACgCzAUgACgC0AUgBhCwBCEoIAAoApQFIg0gBCIBTQ0AIAAoApAFIAtqICgQiQQ4AgAgACgCsAQgAC0AtAQgACgCzAUgACgC0AUgBhCwBCEoIAAoApQFIg0gAiIBTQ0AIAAoApAFIAxqICgQiQQ4AgAgACgCgAEgAC0AhAEgACgCzAUgACgC0AUgBhCwBCEoIAAoAogBIAAtAIwBIAAoAswFIAAoAtAFIAYQsAQhKSAAKAKQASAALQCUASAAKALMBSAAKALQBSAGELAEISogACgCmAEgAC0AnAEgACgCzAUgACgC0AUgBhCwBCErIAVBAnQiASAAKAKgBSICSQ0BDAILIAEgDUHkxcEAEIwHAAsgACgCnAUgAUECdGogKCAoICiUICkgKZSSICogKpSSICsgK5SSkSIolTgCACABQQFyIgQgACgCoAUiAk8EQCAEIQEMAQsgACgCnAUgBEECdGogKSAolTgCACABQQJyIgQgACgCoAUiAk8EQCAEIQEMAQsgACgCnAUgBEECdGogKiAolTgCACABQQNyIgEgACgCoAUiAk8NACAAKAKcBSABQQJ0aiArICiVOAIAIAAtAMQDIgFBCEcNAQwCCyABIAJB1MXBABCMBwALIAAtAIQEIRMgACgCgAQgAC0A/AMhFSAAKAL4AyAALQD0AyEXIAAoAvADIAAtAOwDIRkgACgC6AMgAC0A5AMhGyAAKALgAyAALQDcAyENIAAoAtgDIAAtANQDIQsgACgC0AMgAC0AzAMhCiAAKALIAyAAKALAAyABIAAoAswFIAAoAtAFIAYQsAQhKCAFQQlsIgEgACgCrAUiAk8NBCAAKAKoBSABQQJ0aiAoOAIAIAogACgCzAUgACgC0AUgBhCwBCEoIAFBAWoiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIAsgACgCzAUgACgC0AUgBhCwBCEoIAFBAmoiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIA0gACgCzAUgACgC0AUgBhCwBCEoIAFBA2oiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIBsgACgCzAUgACgC0AUgBhCwBCEoIAFBBGoiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIBkgACgCzAUgACgC0AUgBhCwBCEoIAFBBWoiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIBcgACgCzAUgACgC0AUgBhCwBCEoIAFBBmoiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIBUgACgCzAUgACgC0AUgBhCwBCEoIAFBB2oiBCAAKAKsBSICTwRAIAQhAQwFCyAAKAKoBSAEQQJ0aiAoOAIAIBMgACgCzAUgACgC0AUgBhCwBCEoIAFBCGoiASAAKAKsBSICTw0EIAAoAqgFIAFBAnRqICg4AgALIAAtAMwCIgFBCEcEQCAALQC8AyEdIAAoArgDIAAtALQDIR8gACgCsAMgAC0ArAMhISAAKAKoAyAALQCkAyEjIAAoAqADIAAtAJwDISUgACgCmAMgAC0AlAMhJyAAKAKQAyAALQCMAyEUIAAoAogDIAAtAIQDIRYgACgCgAMgAC0A/AIhGCAAKAL4AiAALQD0AiEaIAAoAvACIAAtAOwCIQ8gACgC6AIgAC0A5AIhESAAKALgAiAALQDcAiEMIAAoAtgCIAAtANQCIQQgACgC0AIgACgCyAIgASAAKALMBSAAKALQBSAGELAEISggBUEPbCIBIAAoArgFIgVPDQIgACgCtAUgAUECdGogKDgCACAEIAAoAswFIAAoAtAFIAYQsAQhKCABQQFqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAMIAAoAswFIAAoAtAFIAYQsAQhKCABQQJqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACARIAAoAswFIAAoAtAFIAYQsAQhKCABQQNqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAPIAAoAswFIAAoAtAFIAYQsAQhKCABQQRqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAaIAAoAswFIAAoAtAFIAYQsAQhKCABQQVqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAYIAAoAswFIAAoAtAFIAYQsAQhKCABQQZqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAWIAAoAswFIAAoAtAFIAYQsAQhKCABQQdqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAUIAAoAswFIAAoAtAFIAYQsAQhKCABQQhqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAnIAAoAswFIAAoAtAFIAYQsAQhKCABQQlqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAlIAAoAswFIAAoAtAFIAYQsAQhKCABQQpqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAjIAAoAswFIAAoAtAFIAYQsAQhKCABQQtqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAhIAAoAswFIAAoAtAFIAYQsAQhKCABQQxqIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAfIAAoAswFIAAoAtAFIAYQsAQhKCABQQ1qIgIgACgCuAUiBU8EQCACIQEMAwsgACgCtAUgAkECdGogKDgCACAdIAAoAswFIAAoAtAFIAYQsAQhKCABQQ5qIgEgACgCuAUiBU8NAiAAKAK0BSABQQJ0aiAoOAIACwJAIAAtAKQBQQhHBEAgA0HYB2ogHEGoAfwKAABBACEFIAchAiAOIQEDQCADQdgHaiAFaiIEKAIAIARBBGotAAAgACgCzAUgACgC0AUgBhCwBCEoIAEgACgCxAUiBE8NAiAAKALABSACaiAoOAIAIAJBBGohAiABQQFqIQEgBUEIaiIFQagBRw0ACwsgB0HUAGohByAOQRVqIQ4gCCAIIAlJIgJqIQEgCCEFIAJFDQYMAQsLIAEgBEHExcEAEIwHAAsgASAFQbTFwQAQjAcAC0EAIBAgBUGEpMcAEOoHAAsgASACQaTFwQAQjAcACyABIA1B9MXBABCMBwALIAlBA2wiDyAAKALwBCIBSw0CIAkgACgC/AQiAUsNAyAPIAAoAogFIgFLDQQgDyAAKAKUBSIBSw0FIAlBAnQiDSAAKAKgBSIBSw0GIAlBCWxBACAAKALkBCICGyIRIAAoAqwFIgFLDQcgCUEPbEEAIAJBAUsbIgsgACgCuAUiAUsNCCAJQRVsQQAgAkECSxsiDCAAKALEBSIBSw0JIAAoAuAEIQogACgC7AQhDiAAKAL4BCEHIAAoAoQFIQUgACgCkAUhCCAAKAKcBSEEIAAoAqgFIQIgACgCtAUhASADQgQ3AqAIIANCAjcCmAggAyAMNgKUCCADIAs2AowIIAMgATYCiAggAyARNgKECCADIAI2AoAIIAMgDTYC/AcgAyAENgL4ByADIA82AvQHIAMgCDYC8AcgAyAPNgLsByADIAU2AugHIAMgCTYC5AcgAyAHNgLgByADIA82AtwHIAMgDjYC2AcgAyAAKALABTYCkAggACAKIAkgA0HYB2oQkwIgACAAKALgBCAJaiICNgLgBCAAKALcBCIBIAlsIBBqIRAgACgC0AUhBSABDQALC0GExMEAEIEIAAtBACAPIAFBhMXBABDqBwALQQAgCSABQfTEwQAQ6gcAC0EAIA8gAUHkxMEAEOoHAAtBACAPIAFB1MTBABDqBwALQQAgDSABQcTEwQAQ6gcAC0EAIBEgAUG0xMEAEOoHAAtBACALIAFBpMTBABDqBwALQQAgDCABQZTEwQAQ6gcACyABIA1BhMbBABCMBwALIAsgDEkNAkEAIQIgAEEANgLQBSALIAxrIQEgDARAIAsgDEYNAiABBEAgACgCzAUiBCAEIAxqIAH8CgAACyAAIAE2AtAFDAILIAsgDEYNAQsgACABNgLQBQsgA0HADGokACACDwtBACAMIAtBhKTHABDqBwALQQAgASAIQczDwQAQ6gcAC7soBBl/BX0CfgF7IwBB0AJrIhokAEKAgICAgICAgMAAIAGtIiSAIiUgJH5CgICAgICAgIDAAFKtAn8gAUGBIE8EQEEBIAFBAXJnQR9zIgZBAXYgBkEBcWoiBnQgASAGdmpBAXYMAQtBwAAgASABQQF2ayIGIAZBwABPGwshGyAlfCElIABBBGshHSAAQRBrIR4gAEEIaiEcQQEhCgJAA0BBASENQQAhEyABIBVLBEAgACAVQQJ0IhZqIRMgFa0iJAJ/AkAgASAVayIOIBtJDQACQCAOQQJJBEAgDiEHDAELQwAAgD8hIAJ/AkAgEygCBCIGIAUoAgBBBGooAgAiECgCCCIUSQRAIBMoAgAhCSAQKAIEIhEgBkEYbGoiCy0AEyIIIAstABIiDSALLQARIgcgByANSRsiByAHIAhJGyINBH1DAABAwSAQKgJEIBAtAFhBAkYiBxsiH0MAABBBIBAqAkggBxsgH5NDAAB+Q5UgDUEBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIiALQQxqLwEAIgdB//8BcUUEQCAHQRB0DAMLIAdB/wdxIQggB0GAgAJxIQ0gB0GA+AFxIgdBgPgBRgRAIA1BEHQiB0GAgID8B3IgCEUNAxogByAIQQ10ckGAgID+B3IMAwsgDUEQdCENIAdFDQEgB0ENdEGAgID8AHEgCEENdHJBgICAwANqIA1yDAILDAcLIAggCGdBEGsiB0H//wNxQQhqdEH///8DcSANQYCAgNgDciAHQRd0a3ILviIfQwAAgD9eBEAgHxDGBUNU+C1AlEMAAIA/kpEhIAtDAACAPyEhAn8CQCAJIBRJBEAgESAJQRhsaiILLQATIgggCy0AEiINIAstABEiByAHIA1JGyIHIAcgCEkbIg0EfUMAAEDBIBAqAkQgEC0AWEECRiIHGyIfQwAAEEEgECoCSCAHGyAfk0MAAH5DlSANQQFrQf8BcbOUkhCJBCIfIB+SBUMAAAAACyEjIAtBDGovAQAiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCCAHQYCAAnEhDSAHQYD4AXEiB0GA+AFGBEAgDUEQdCIHQYCAgPwHciAIRQ0DGiAHIAhBDXRyQYCAgP4HcgwDCyANQRB0IQ0gB0UNASAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogDXIMAgsgCSAUQdy7xwAQjAcACyAIIAhnQRBrIgdB//8DcUEIanRB////A3EgDUGAgIDYA3IgB0EXdGtyC74iH0MAAIA/XgRAIB8QxgVDVPgtQJRDAACAP5KRISELAkACQAJAAkAgIiAglCIfIB9bIB8gIyAhlGBFcSIPRQRAQQIhByAOQQJGDQUgHCAVQQJ0aiESA0BDAACAPyEgAn8CQCAUIBIoAgAiDUsEQCARIA1BGGxqIhgtABMiCSAYLQASIgsgGC0AESIIIAggC0kbIgggCCAJSRsiCwR9QwAAQMEgECoCRCAQLQBYQQJGIggbIh9DAAAQQSAQKgJIIAgbIB+TQwAAfkOVIAtBAWtB/wFxs5SSEIkEIh8gH5IFQwAAAAALISIgGEEMai8BACIIQf//AXFFBEAgCEEQdAwDCyAIQf8HcSEJIAhBgIACcSELIAhBgPgBcSIIQYD4AUYEQCALQRB0IghBgICA/AdyIAlFDQMaIAggCUENdHJBgICA/gdyDAMLIAtBEHQhCyAIRQ0BIAhBDXRBgICA/ABxIAlBDXRyQYCAgMADaiALcgwCCyANIBRB3LvHABCMBwALIAkgCWdBEGsiCEH//wNxQQhqdEH///8DcSALQYCAgNgDciAIQRd0a3ILviIfQwAAgD9eBEAgHxDGBUNU+C1AlEMAAIA/kpEhIAtDAACAPyEhAn8CQCAGIBRJBEAgESAGQRhsaiIJLQATIgsgCS0AEiIIIAktABEiBiAGIAhJGyIGIAYgC0kbIggEfUMAAEDBIBAqAkQgEC0AWEECRiIGGyIfQwAAEEEgECoCSCAGGyAfk0MAAH5DlSAIQQFrQf8BcbOUkhCJBCIfIB+SBUMAAAAACyEjIAlBDGovAQAiBkH//wFxRQRAIAZBEHQMAwsgBkH/B3EhCyAGQYCAAnEhCCAGQYD4AXEiBkGA+AFGBEAgCEEQdCIGQYCAgPwHciALRQ0DGiAGIAtBDXRyQYCAgP4HcgwDCyAIQRB0IQggBkUNASAGQQ10QYCAgPwAcSALQQ10ckGAgIDAA2ogCHIMAgsMDQsgCyALZ0EQayIGQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAZBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEhCyAiICCUIh8gH1sgHyAjICGUYEVxDQMgEkEEaiESIA0hBiAOIAdBAWoiB0cNAAsMAQsgDkECRg0CQQIhByAcIBVBAnRqIRIDQEMAAIA/ISACfwJAIBQgEigCACINSwRAIBEgDUEYbGoiGC0AEyIJIBgtABIiCyAYLQARIgggCCALSRsiCCAIIAlJGyILBH1DAABAwSAQKgJEIBAtAFhBAkYiCBsiH0MAABBBIBAqAkggCBsgH5NDAAB+Q5UgC0EBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIiAYQQxqLwEAIghB//8BcUUEQCAIQRB0DAMLIAhB/wdxIQkgCEGAgAJxIQsgCEGA+AFxIghBgPgBRgRAIAtBEHQiCEGAgID8B3IgCUUNAxogCCAJQQ10ckGAgID+B3IMAwsgC0EQdCELIAhFDQEgCEENdEGAgID8AHEgCUENdHJBgICAwANqIAtyDAILIA0gFEHcu8cAEIwHAAsgCSAJZ0EQayIIQf//A3FBCGp0Qf///wNxIAtBgICA2ANyIAhBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEgC0MAAIA/ISECfwJAIAYgFEkEQCARIAZBGGxqIgktABMiCyAJLQASIgggCS0AESIGIAYgCEkbIgYgBiALSRsiCAR9QwAAQMEgECoCRCAQLQBYQQJGIgYbIh9DAAAQQSAQKgJIIAYbIB+TQwAAfkOVIAhBAWtB/wFxs5SSEIkEIh8gH5IFQwAAAAALISMgCUEMai8BACIGQf//AXFFBEAgBkEQdAwDCyAGQf8HcSELIAZBgIACcSEIIAZBgPgBcSIGQYD4AUYEQCAIQRB0IgZBgICA/AdyIAtFDQMaIAYgC0ENdHJBgICA/gdyDAMLIAhBEHQhCCAGRQ0BIAZBDXRBgICA/ABxIAtBDXRyQYCAgMADaiAIcgwCCwwMCyALIAtnQRBrIgZB//8DcUEIanRB////A3EgCEGAgIDYA3IgBkEXdGtyC74iH0MAAIA/XgRAIB8QxgVDVPgtQJRDAACAP5KRISELICIgIJQiHyAfXCAfICMgIZRgcg0CIBJBBGohEiANIQYgDiAHQQFqIgdHDQALCyAOIQcLIAcgG0kNAyAPRQ0CIAdBAkkEQEEBIQcMAwsgB0EBdiENIBMgB0ECdCIGaiEIQQAhCSAHQQhJDQEgHiAGIBZqaiEOIA1B/P///wdxIgkhBgNAIBMgDv0AAgAgE/0AAgAiJv0NDA0ODwgJCgsEBQYHAAECA/0LAgAgDiAmICb9DQwNDg8ICQoLBAUGBwABAgP9CwIAIA5BEGshDiATQRBqIRMgBkEEayIGDQALIAkgDUYNAgwBCyATQQhqIQhBACEJQQEhDUECIQcLIAAgCUECdCIGIBZqaiEOIA0gCWshCSAIIAZrQQRrIQYDQCAOKAIAIQ0gDiAGKAIANgIAIAYgDTYCACAGQQRrIQYgDkEEaiEOIAlBAWsiCQ0ACwsgB0EBdEEBcgwBCyAOIBsgDiAbSRtBAXQgBEUNABogE0EgIA4gDkEgTxsiBiACIANBAEEAIAUQOCAGQQF0QQFyCyINQQF2IBVqrXwgJX4gFSAKQQF2a60gJHwgJX6FeachEwsCQAJAIAxBAkkNACAdIBVBAnQiBmohCCAAIAZqIRgDQCAMQQFrIgsgGkGOAmpqLQAAIBNJDQECfwJAAkAgAyAaQQRqIAtBAnRqKAIAIgZBAXYiDyAKQQF2IgxqIhRPIAYgCnJBAXFFcUUEQCAAIBUgFGtBAnRqIQ4gBkEBcUUNAQwCCyAUQQF0DAILIA4gDyACIAMgD0EBcmdBAXRBPnNBACAFEDgLIApBAXFFBEAgDiAPQQJ0aiAMIAIgAyAMQQFyZ0EBdEE+c0EAIAUQOAsCQCAKQQJJIAZBAklyDQAgAyAMIA8gDCAPSSIJGyIHSQ0AIAUoAgAgDiAPQQJ0aiEMIAdBAnQiBwRAIAIgDCAOIAkbIAf8CgAACyACIAdqIQdBBGoiCigCACIXKAIIIRkCQCAJRQRAIAIhBgNAQwAAgD8hIAJ/AkAgGSAMKAIAIgpLBEAgBigCACESIBcoAgQiFiAKQRhsaiIRLQATIg8gES0AEiIJIBEtABEiCiAJIApLGyIKIAogD0kbIgkEfUMAAEDBIBcqAkQgFy0AWEECRiIKGyIfQwAAEEEgFyoCSCAKGyAfk0MAAH5DlSAJQQFrQf8BcbOUkhCJBCIfIB+SBUMAAAAACyEiIBFBDGovAQAiCkH//wFxRQRAIApBEHQMAwsgCkH/B3EhDyAKQYCAAnEhCSAKQYD4AXEiCkGA+AFGBEAgCUEQdCIKQYCAgPwHciAPRQ0DGiAKIA9BDXRyQYCAgP4HcgwDCyAJQRB0IQkgCkUNASAKQQ10QYCAgPwAcSAPQQ10ckGAgIDAA2ogCXIMAgsgCiAZQdy7xwAQjAcACyAPIA9nQRBrIgpB//8DcUEIanRB////A3EgCUGAgIDYA3IgCkEXdGtyC74iH0MAAIA/XgRAIB8QxgVDVPgtQJRDAACAP5KRISALQwAAgD8hIQJ/AkAgEiAZSQRAIBYgEkEYbGoiFi0AEyIPIBYtABIiCSAWLQARIgogCSAKSxsiCiAKIA9JGyIJBH1DAABAwSAXKgJEIBctAFhBAkYiChsiH0MAABBBIBcqAkggChsgH5NDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIyAWQQxqLwEAIgpB//8BcUUEQCAKQRB0DAMLIApB/wdxIQ8gCkGAgAJxIQkgCkGA+AFxIgpBgPgBRgRAIAlBEHQiCkGAgID8B3IgD0UNAxogCiAPQQ10ckGAgID+B3IMAwsgCUEQdCEJIApFDQEgCkENdEGAgID8AHEgD0ENdHJBgICAwANqIAlyDAILIBIgGUHcu8cAEIwHAAsgDyAPZ0EQayIKQf//A3FBCGp0Qf///wNxIAlBgICA2ANyIApBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEhCyAOIAwgBiAiICCUIh8gH1sgHyAjICGUYEVxIgobKAIANgIAIA5BBGohDiAGIApFQQJ0aiIGIAdGDQIgDCAKQQJ0aiIMIBhHDQALDAELIAghCQNAQwAAgD8hIAJ/AkAgGSAHQQRrIhYoAgAiBksEQCAMQQRrIg8oAgAhEiAXKAIEIAZBGGxqIhEtABMiByARLQASIgwgES0AESIGIAYgDEkbIgYgBiAHSRsiDAR9QwAAQMEgFyoCRCAXLQBYQQJGIgYbIh9DAAAQQSAXKgJIIAYbIB+TQwAAfkOVIAxBAWtB/wFxs5SSEIkEIh8gH5IFQwAAAAALISIgEUEMai8BACIGQf//AXFFBEAgBkEQdAwDCyAGQf8HcSEHIAZBgIACcSEMIAZBgPgBcSIGQYD4AUYEQCAMQRB0IgZBgICA/AdyIAdFDQMaIAYgB0ENdHJBgICA/gdyDAMLIAxBEHQhDCAGRQ0BIAZBDXRBgICA/ABxIAdBDXRyQYCAgMADaiAMcgwCCyAGIBlB3LvHABCMBwALIAcgB2dBEGsiBkH//wNxQQhqdEH///8DcSAMQYCAgNgDciAGQRd0a3ILviIfQwAAgD9eBEAgHxDGBUNU+C1AlEMAAIA/kpEhIAtDAACAPyEhAn8CQCAKKAIAIhAoAggiBiASSwRAIBAoAgQgEkEYbGoiES0AEyIHIBEtABIiDCARLQARIgYgBiAMSRsiBiAGIAdJGyIMBH1DAABAwSAQKgJEIBAtAFhBAkYiBhsiH0MAABBBIBAqAkggBhsgH5NDAAB+Q5UgDEEBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIyARQQxqLwEAIgZB//8BcUUEQCAGQRB0DAMLIAZB/wdxIQcgBkGAgAJxIQwgBkGA+AFxIgZBgPgBRgRAIAxBEHQiBkGAgID8B3IgB0UNAxogBiAHQQ10ckGAgID+B3IMAwsgDEEQdCEMIAZFDQEgBkENdEGAgID8AHEgB0ENdHJBgICAwANqIAxyDAILIBIgBkHcu8cAEIwHAAsgByAHZ0EQayIGQf//A3FBCGp0Qf///wNxIAxBgICA2ANyIAZBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEhCyAJIA8gFiAiICCUIh8gH1sgHyAjICGUYEVxIgYbKAIANgIAIBYgBkECdGohByAOIA8gBkVBAnRqIgxHBEAgCUEEayEJIAIgB0cNAQsLIAwhDiACIQYLIAcgBmsiDEUNACAOIAYgDPwKAAALIBRBAXRBAXILIQpBASEOIAsiDEEBSw0ACwwBCyAMIQ4LIBpBjgJqIA5qIBM6AAAgGkEEaiAOQQJ0aiAKNgIAIAEgFUsEQCAOQQFqIQwgDUEBdiAVaiEVIA0hCgwBCwsgCkEBcUUEQCAAIAEgAiADIAFBAXJnQQF0QT5zQQAgBRA4CyAaQdACaiQADwsgBiAUQdy7xwAQjAcAC7soBBl/BX0CfgF7IwBB0AJrIhokAEKAgICAgICAgMAAIAGtIiSAIiUgJH5CgICAgICAgIDAAFKtAn8gAUGBIE8EQEEBIAFBAXJnQR9zIgZBAXYgBkEBcWoiBnQgASAGdmpBAXYMAQtBwAAgASABQQF2ayIGIAZBwABPGwshGyAlfCElIABBBGshHSAAQRBrIR4gAEEIaiEcQQEhCgJAA0BBASENQQAhEyABIBVLBEAgACAVQQJ0IhZqIRMgFa0iJAJ/AkAgASAVayIOIBtJDQACQCAOQQJJBEAgDiEHDAELQwAAgD8hIAJ/AkAgEygCBCIGIAUoAgBBBGooAgAiECgCCCIUSQRAIBMoAgAhCSAQKAIEIhEgBkEYbGoiCy0AEyIIIAstABIiDSALLQARIgcgByANSRsiByAHIAhJGyINBH1DAABAwSAQKgJEIBAtAFhBAkYiBxsiH0MAABBBIBAqAkggBxsgH5NDAAB+Q5UgDUEBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIiALQQxqLwEAIgdB//8BcUUEQCAHQRB0DAMLIAdB/wdxIQggB0GAgAJxIQ0gB0GA+AFxIgdBgPgBRgRAIA1BEHQiB0GAgID8B3IgCEUNAxogByAIQQ10ckGAgID+B3IMAwsgDUEQdCENIAdFDQEgB0ENdEGAgID8AHEgCEENdHJBgICAwANqIA1yDAILDAcLIAggCGdBEGsiB0H//wNxQQhqdEH///8DcSANQYCAgNgDciAHQRd0a3ILviIfQwAAgD9eBEAgHxDGBUNU+C1AlEMAAIA/kpEhIAtDAACAPyEhAn8CQCAJIBRJBEAgESAJQRhsaiILLQATIgggCy0AEiINIAstABEiByAHIA1JGyIHIAcgCEkbIg0EfUMAAEDBIBAqAkQgEC0AWEECRiIHGyIfQwAAEEEgECoCSCAHGyAfk0MAAH5DlSANQQFrQf8BcbOUkhCJBCIfIB+SBUMAAAAACyEjIAtBDGovAQAiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhCCAHQYCAAnEhDSAHQYD4AXEiB0GA+AFGBEAgDUEQdCIHQYCAgPwHciAIRQ0DGiAHIAhBDXRyQYCAgP4HcgwDCyANQRB0IQ0gB0UNASAHQQ10QYCAgPwAcSAIQQ10ckGAgIDAA2ogDXIMAgsgCSAUQdy7xwAQjAcACyAIIAhnQRBrIgdB//8DcUEIanRB////A3EgDUGAgIDYA3IgB0EXdGtyC74iH0MAAIA/XgRAIB8QxgVDVPgtQJRDAACAP5KRISELAkACQAJAAkAgIiAglCIfIB9bIB8gIyAhlGBFcSIPRQRAQQIhByAOQQJGDQUgHCAVQQJ0aiESA0BDAACAPyEgAn8CQCAUIBIoAgAiDUsEQCARIA1BGGxqIhgtABMiCSAYLQASIgsgGC0AESIIIAggC0kbIgggCCAJSRsiCwR9QwAAQMEgECoCRCAQLQBYQQJGIggbIh9DAAAQQSAQKgJIIAgbIB+TQwAAfkOVIAtBAWtB/wFxs5SSEIkEIh8gH5IFQwAAAAALISIgGEEMai8BACIIQf//AXFFBEAgCEEQdAwDCyAIQf8HcSEJIAhBgIACcSELIAhBgPgBcSIIQYD4AUYEQCALQRB0IghBgICA/AdyIAlFDQMaIAggCUENdHJBgICA/gdyDAMLIAtBEHQhCyAIRQ0BIAhBDXRBgICA/ABxIAlBDXRyQYCAgMADaiALcgwCCyANIBRB3LvHABCMBwALIAkgCWdBEGsiCEH//wNxQQhqdEH///8DcSALQYCAgNgDciAIQRd0a3ILviIfQwAAgD9eBEAgHxDGBUNU+C1AlEMAAIA/kpEhIAtDAACAPyEhAn8CQCAGIBRJBEAgESAGQRhsaiIJLQATIgsgCS0AEiIIIAktABEiBiAGIAhJGyIGIAYgC0kbIggEfUMAAEDBIBAqAkQgEC0AWEECRiIGGyIfQwAAEEEgECoCSCAGGyAfk0MAAH5DlSAIQQFrQf8BcbOUkhCJBCIfIB+SBUMAAAAACyEjIAlBDGovAQAiBkH//wFxRQRAIAZBEHQMAwsgBkH/B3EhCyAGQYCAAnEhCCAGQYD4AXEiBkGA+AFGBEAgCEEQdCIGQYCAgPwHciALRQ0DGiAGIAtBDXRyQYCAgP4HcgwDCyAIQRB0IQggBkUNASAGQQ10QYCAgPwAcSALQQ10ckGAgIDAA2ogCHIMAgsMDQsgCyALZ0EQayIGQf//A3FBCGp0Qf///wNxIAhBgICA2ANyIAZBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEhCyAiICCUIh8gH1sgHyAjICGUYEVxDQMgEkEEaiESIA0hBiAOIAdBAWoiB0cNAAsMAQsgDkECRg0CQQIhByAcIBVBAnRqIRIDQEMAAIA/ISACfwJAIBQgEigCACINSwRAIBEgDUEYbGoiGC0AEyIJIBgtABIiCyAYLQARIgggCCALSRsiCCAIIAlJGyILBH1DAABAwSAQKgJEIBAtAFhBAkYiCBsiH0MAABBBIBAqAkggCBsgH5NDAAB+Q5UgC0EBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIiAYQQxqLwEAIghB//8BcUUEQCAIQRB0DAMLIAhB/wdxIQkgCEGAgAJxIQsgCEGA+AFxIghBgPgBRgRAIAtBEHQiCEGAgID8B3IgCUUNAxogCCAJQQ10ckGAgID+B3IMAwsgC0EQdCELIAhFDQEgCEENdEGAgID8AHEgCUENdHJBgICAwANqIAtyDAILIA0gFEHcu8cAEIwHAAsgCSAJZ0EQayIIQf//A3FBCGp0Qf///wNxIAtBgICA2ANyIAhBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEgC0MAAIA/ISECfwJAIAYgFEkEQCARIAZBGGxqIgktABMiCyAJLQASIgggCS0AESIGIAYgCEkbIgYgBiALSRsiCAR9QwAAQMEgECoCRCAQLQBYQQJGIgYbIh9DAAAQQSAQKgJIIAYbIB+TQwAAfkOVIAhBAWtB/wFxs5SSEIkEIh8gH5IFQwAAAAALISMgCUEMai8BACIGQf//AXFFBEAgBkEQdAwDCyAGQf8HcSELIAZBgIACcSEIIAZBgPgBcSIGQYD4AUYEQCAIQRB0IgZBgICA/AdyIAtFDQMaIAYgC0ENdHJBgICA/gdyDAMLIAhBEHQhCCAGRQ0BIAZBDXRBgICA/ABxIAtBDXRyQYCAgMADaiAIcgwCCwwMCyALIAtnQRBrIgZB//8DcUEIanRB////A3EgCEGAgIDYA3IgBkEXdGtyC74iH0MAAIA/XgRAIB8QxgVDVPgtQJRDAACAP5KRISELICIgIJQiHyAfXCAfICMgIZRgcg0CIBJBBGohEiANIQYgDiAHQQFqIgdHDQALCyAOIQcLIAcgG0kNAyAPRQ0CIAdBAkkEQEEBIQcMAwsgB0EBdiENIBMgB0ECdCIGaiEIQQAhCSAHQQhJDQEgHiAGIBZqaiEOIA1B/P///wdxIgkhBgNAIBMgDv0AAgAgE/0AAgAiJv0NDA0ODwgJCgsEBQYHAAECA/0LAgAgDiAmICb9DQwNDg8ICQoLBAUGBwABAgP9CwIAIA5BEGshDiATQRBqIRMgBkEEayIGDQALIAkgDUYNAgwBCyATQQhqIQhBACEJQQEhDUECIQcLIAAgCUECdCIGIBZqaiEOIA0gCWshCSAIIAZrQQRrIQYDQCAOKAIAIQ0gDiAGKAIANgIAIAYgDTYCACAGQQRrIQYgDkEEaiEOIAlBAWsiCQ0ACwsgB0EBdEEBcgwBCyAOIBsgDiAbSRtBAXQgBEUNABogE0EgIA4gDkEgTxsiBiACIANBAEEAIAUQNyAGQQF0QQFyCyINQQF2IBVqrXwgJX4gFSAKQQF2a60gJHwgJX6FeachEwsCQAJAIAxBAkkNACAdIBVBAnQiBmohCCAAIAZqIRgDQCAMQQFrIgsgGkGOAmpqLQAAIBNJDQECfwJAAkAgAyAaQQRqIAtBAnRqKAIAIgZBAXYiDyAKQQF2IgxqIhRPIAYgCnJBAXFFcUUEQCAAIBUgFGtBAnRqIQ4gBkEBcUUNAQwCCyAUQQF0DAILIA4gDyACIAMgD0EBcmdBAXRBPnNBACAFEDcLIApBAXFFBEAgDiAPQQJ0aiAMIAIgAyAMQQFyZ0EBdEE+c0EAIAUQNwsCQCAKQQJJIAZBAklyDQAgAyAMIA8gDCAPSSIJGyIHSQ0AIAUoAgAgDiAPQQJ0aiEMIAdBAnQiBwRAIAIgDCAOIAkbIAf8CgAACyACIAdqIQdBBGoiCigCACIXKAIIIRkCQCAJRQRAIAIhBgNAQwAAgD8hIAJ/AkAgGSAMKAIAIgpLBEAgBigCACESIBcoAgQiFiAKQRhsaiIRLQATIg8gES0AEiIJIBEtABEiCiAJIApLGyIKIAogD0kbIgkEfUMAAEDBIBcqAkQgFy0AWEECRiIKGyIfQwAAEEEgFyoCSCAKGyAfk0MAAH5DlSAJQQFrQf8BcbOUkhCJBCIfIB+SBUMAAAAACyEiIBFBDGovAQAiCkH//wFxRQRAIApBEHQMAwsgCkH/B3EhDyAKQYCAAnEhCSAKQYD4AXEiCkGA+AFGBEAgCUEQdCIKQYCAgPwHciAPRQ0DGiAKIA9BDXRyQYCAgP4HcgwDCyAJQRB0IQkgCkUNASAKQQ10QYCAgPwAcSAPQQ10ckGAgIDAA2ogCXIMAgsgCiAZQdy7xwAQjAcACyAPIA9nQRBrIgpB//8DcUEIanRB////A3EgCUGAgIDYA3IgCkEXdGtyC74iH0MAAIA/XgRAIB8QxgVDVPgtQJRDAACAP5KRISALQwAAgD8hIQJ/AkAgEiAZSQRAIBYgEkEYbGoiFi0AEyIPIBYtABIiCSAWLQARIgogCSAKSxsiCiAKIA9JGyIJBH1DAABAwSAXKgJEIBctAFhBAkYiChsiH0MAABBBIBcqAkggChsgH5NDAAB+Q5UgCUEBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIyAWQQxqLwEAIgpB//8BcUUEQCAKQRB0DAMLIApB/wdxIQ8gCkGAgAJxIQkgCkGA+AFxIgpBgPgBRgRAIAlBEHQiCkGAgID8B3IgD0UNAxogCiAPQQ10ckGAgID+B3IMAwsgCUEQdCEJIApFDQEgCkENdEGAgID8AHEgD0ENdHJBgICAwANqIAlyDAILIBIgGUHcu8cAEIwHAAsgDyAPZ0EQayIKQf//A3FBCGp0Qf///wNxIAlBgICA2ANyIApBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEhCyAOIAwgBiAiICCUIh8gH1sgHyAjICGUYEVxIgobKAIANgIAIA5BBGohDiAGIApFQQJ0aiIGIAdGDQIgDCAKQQJ0aiIMIBhHDQALDAELIAghCQNAQwAAgD8hIAJ/AkAgGSAHQQRrIhYoAgAiBksEQCAMQQRrIg8oAgAhEiAXKAIEIAZBGGxqIhEtABMiByARLQASIgwgES0AESIGIAYgDEkbIgYgBiAHSRsiDAR9QwAAQMEgFyoCRCAXLQBYQQJGIgYbIh9DAAAQQSAXKgJIIAYbIB+TQwAAfkOVIAxBAWtB/wFxs5SSEIkEIh8gH5IFQwAAAAALISIgEUEMai8BACIGQf//AXFFBEAgBkEQdAwDCyAGQf8HcSEHIAZBgIACcSEMIAZBgPgBcSIGQYD4AUYEQCAMQRB0IgZBgICA/AdyIAdFDQMaIAYgB0ENdHJBgICA/gdyDAMLIAxBEHQhDCAGRQ0BIAZBDXRBgICA/ABxIAdBDXRyQYCAgMADaiAMcgwCCyAGIBlB3LvHABCMBwALIAcgB2dBEGsiBkH//wNxQQhqdEH///8DcSAMQYCAgNgDciAGQRd0a3ILviIfQwAAgD9eBEAgHxDGBUNU+C1AlEMAAIA/kpEhIAtDAACAPyEhAn8CQCAKKAIAIhAoAggiBiASSwRAIBAoAgQgEkEYbGoiES0AEyIHIBEtABIiDCARLQARIgYgBiAMSRsiBiAGIAdJGyIMBH1DAABAwSAQKgJEIBAtAFhBAkYiBhsiH0MAABBBIBAqAkggBhsgH5NDAAB+Q5UgDEEBa0H/AXGzlJIQiQQiHyAfkgVDAAAAAAshIyARQQxqLwEAIgZB//8BcUUEQCAGQRB0DAMLIAZB/wdxIQcgBkGAgAJxIQwgBkGA+AFxIgZBgPgBRgRAIAxBEHQiBkGAgID8B3IgB0UNAxogBiAHQQ10ckGAgID+B3IMAwsgDEEQdCEMIAZFDQEgBkENdEGAgID8AHEgB0ENdHJBgICAwANqIAxyDAILIBIgBkHcu8cAEIwHAAsgByAHZ0EQayIGQf//A3FBCGp0Qf///wNxIAxBgICA2ANyIAZBF3Rrcgu+Ih9DAACAP14EQCAfEMYFQ1T4LUCUQwAAgD+SkSEhCyAJIA8gFiAiICCUIh8gH1sgHyAjICGUYEVxIgYbKAIANgIAIBYgBkECdGohByAOIA8gBkVBAnRqIgxHBEAgCUEEayEJIAIgB0cNAQsLIAwhDiACIQYLIAcgBmsiDEUNACAOIAYgDPwKAAALIBRBAXRBAXILIQpBASEOIAsiDEEBSw0ACwwBCyAMIQ4LIBpBjgJqIA5qIBM6AAAgGkEEaiAOQQJ0aiAKNgIAIAEgFUsEQCAOQQFqIQwgDUEBdiAVaiEVIA0hCgwBCwsgCkEBcUUEQCAAIAEgAiADIAFBAXJnQQF0QT5zQQAgBRA3CyAaQdACaiQADwsgBiAUQdy7xwAQjAcAC6MsAxh/BX4BeyMAQeAGayIEJAAgBEHQAGogAUHwBPwKAAAgBEIANwPABSAEIAOtIh83A8gFAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkAgBCgCeEECRwRAIARBQGsgBCgCsAMiBq0gBCgCrAMiC61+IAQtALgFQQN0KQPYnkkQ3QYgBEIANwPQBSAEQn8gBCkDQCAEKQNIQgBSGyIcNwPYBSAcIB9SDQEgBEHwAGohDkEmIQcgBCgCrAVFBEBBASELDAgLIAQtANQERQ0DIARB4AVqIA4QjAEgBC0A4AVBKEYNAiAEKALgBSIHQQh2DAQLDAgLIARBADYC4AUgBEHABWogBEHQBWogBEHgBWpBpM3HABD3BwALIAQoAnhBAkYNBiAEKAKwAyEGIAQoAqwDIQsLIARBOGogDhCKBUIAIRwgBC0AOEEDdCkDqJ9JIAQxADkgC61+fiIdQvH/////AFoEQAwDCyAGrSAdQgd8QgOIfiIdQiCIpw0CIB2nIgtBAEgNAgJAIAMgC08EQCAEQTBqIA4QigUgBC0AMSEGIAQtADAhCSAEKALIBCAEQShqIA4QigUgBC0AKEECdCgC4J9JbCELAkACQAJAIAQtACkiB0EIaw4JAgAAAAAAAAABAAsgB0EITQRAIAtBCCAHbiIHbiIMIAsgByAMbEdqIQsMAgsMCgsgC0EBdCELCyAEKAJ4QQJHBEACQCAELQC0A0UEQCALRQ0BIAQoArgEIQwgBCgCtAQhBSAEIAQoAswEIgc2AvQFIAQgByAMIAVBAkYbIgc2AvgFIAQgCzYC8AUgBCADIAtwIgU2AuQFIAQgAyAFayIFNgLsBSAEIAI2AugFIAQgAiAFajYC4AUDQAJAIAdFBEAgBCgC9AUiB0UNByAEIAdBAWs2AvQFIAQoAuwFIgUgBCgC8AUiB0kNByAEIAUgB2s2AuwFIAQgBCgC6AUiCyAHajYC6AUgCw0BDAcLIARBADYC+AUgBEEgaiEGQQAhCQJAAkAgByAEQeAFaiIIKAIUIgtPBEAgCw0BQQAhCgwCCyAIIAsgB0F/c2o2AhRBASEMAkAgB60gCCgCECILrX4iHUIgiFBFBEBBACEKDAELQQAhCiAIKAIMIgcgHaciBU0NACAIIAcgBWsiBzYCDCAIIAgoAgggBWoiCjYCCCAHIAtJBEBBACEKDAMLIAcgC2shCSAKIAtqIQwLIAggCTYCDCAIIAw2AggMAQtBACEKQQEhCQJAAkAgC0EBa60gCCgCECILrX4iHUIgiKcNACAIKAIMIgcgHaciDE0NACAIIAcgDGsiBTYCDCAIIAgoAgggDGoiBzYCCCAFIAtJDQEgBSALayEKIAcgC2ohCQsgCCAKNgIMIAggCTYCCAtBACEKIAhBADYCFAsgBiALNgIEIAYgCjYCACAEKAIgIgtFDQYgBCgCJCEHCyAEQdAFaiAOIAQoAtAEIAsgBxB6IAQtANAFIgdBKEcEQCAELwDRBSAELQDTBUEQdHIhBiAEKQLYBSEcIAQoAtQFIQsMCgUgBCgC+AUhBwwBCwALAAsgBCgCrAMgBEEYaiAOEIoFIAQtABhBAnQoAvyfSWwhEAJAAkACQCAELQAZIgdBCGsOCQIAAAAAAAAAAQALIAdBCE0EQCAQQQggB24iBW4iByAQIAUgB2xHaiEQDAILDAwLIBBBAXQhEAsgBEGoBWoiBygCACELIAdBADYCACAEQdgFaiIYIAs2AgAgBCkDoAUhHSAEQoCAgIAQNwOgBSAEIB03A9AFAkAgBCgCeEECRwRAIARBoAVqIRYgBkKBgIyIoICAAiAJrUL/AYNCA4aIp2wiGUEDdkEfcSETIARBnAZqIRogBEHsBWohGyAEQewEaiEUIARB+ARqIRUDQCAENQKsAyEdIARBEGogDhCKBQJAAkACQAJAAkACQCAELQAQQQN0KQOYoEkgHSAEMQARfn4iHULw/////wBWDQAgHUIHfEIDiKciCUEASA0AAkAgBCgC2AUiByAJTwRAIAQoAtQFIQoMAQsgCSAHayIFIAQoAtAFIAdrSwRAIARB0AVqIAcgBUEBQQEQpAUgBCgC2AUhBwsgBCgC1AUiCiAHaiELIAVBAk8EQCAFQQFrIgUEQCALQQAgBfwLAAsgCiAFIAdqIgdqIQsLIAtBADoAACAHQQFqIQkLIAQgCTYC2AUCQAJAAkACQAJAIAQoArQEIgZBAkcEQCAEKALEBCEXIAQoAsAEIQwgBCgCvAQhCyAEKAK4BCEHIAZBAXFFDQEgB0UEQCAEKAL4BEEATgRAIARB6AVqIg8gFUEIaigCADYCACAEIBUpAgA3A+AFIARBADYCgAUgBEEBNgL8BCAEKALsBCIRBEAgBCgC8AQiDUEEaygCACIFQXhxIghBBEEIIAVBA3EiBRsgEWpJDR0gBUEAIAggEUEnaksbDR4gDRCiAgsgFCAEKQPgBTcCACAUQQhqIA8oAgA2AgALIARBgICAgHg2AvgEIAQoAnhBAkYNBgsgBC0AtgNBAnQoAuygSSAMbCEIIAQtALcDIgVBCGsOCQQCAgICAgICAwILIARB4AVqIA4Q5wQgBC0A4AVBKEcNB0ECIQYMCAsgB0UEQCAEKAL4BEEATgRAIARB6AVqIg8gFUEIaigCADYCACAEIBUpAgA3A+AFIARBADYCgAUgBEEBNgL8BCAEKALsBCIRBEAgBCgC8AQiDUEEaygCACIFQXhxIghBBEEIIAVBA3EiBRsgEWpJDRsgBUEAIAggEUEnaksbDRwgDRCiAgsgFCAEKQPgBTcCACAUQQhqIA8oAgA2AgALIARBgICAgHg2AvgECyAEKALIBCEIIAQoAtAEIQUMBQsgBUEITQRAIAhBCCAFbiINbiIFIAggBSANbEdqIQgMAgsMFgsgCEEBdCEICyAIQQFqIQUgDCEIDAILDBILQSchByAEKALQBSICRQ0DIAQoAtQFIAJBARCiBwwDCyAEQQhqIA4QigUgBC0ACEECdCgC0KBJIAhsIQgCQAJAAkAgBC0ACSINQQhrDgkCAAAAAAAAAAEACyANQQhNBEAgCEEIIA1uIg9uIg0gCCANIA9sR2ohCAwCCwwTCyAIQQF0IQgLIAggCU0EQCAEQeAFaiAOIAUgCiAIEHogBC0A4AVBKEcNAQwCC0EAIAggCUHomscAEOoHAAsgBCgC7AUhFyAEKALoBSEMIAQoAuQFIQsgBCgC4AUhB0EDIQYLIAQoAqAFIggEQCAEKAKkBSIKQQRrKAIAIgVBeHEiCUEEQQggBUEDcSIFGyAIakkNESAFQQAgCSAIQSdqSxsNEiAKEKICCyAWIAQpA9AFNwIAIBZBCGoiESAYKAIANgIAAkACQCAGQQJrDgIKAQALIAQoAsgEIQUgBCAOEIoFIAQtAABBAnQoAoihSSAMIAUgBkEBcSIKG2whBgJAAkACQCAELQABIgVBCGsOCQIAAAAAAAAAAQALIAVBCE0EQCAGQQggBW4iCW4iBSAGIAUgCWxHaiEGDAILDBILIAZBAXQhBgsgBiAEKAKoBSIFTQ0CQQAgBiAFQfiZxwAQ6gcACyAHQQh2IQYLIAytIBetQiCGhCEcDAsLAkACQAJAAkACQAJAAkAgCgRAIAQoAqQFIQkgF0H/AXFBAWshCgJAAkACQCAZQf8BcSIFQQFrDhABCQAIAAAABwAAAAAAAAAGAAsgCkEHTw0aIAVBCE8NASAEQQA2AvAFIARBATYC5AUgBEG8occANgLgBSAEQgQ3AugFIARB4AVqQeiNxQAQjQgACyAKQQdPDRkgBEIANwLMBiAEQQE6AMgGIARCh4yUoLDAwAA3A8AGIARBADYCpAYgBEEANgKQBiAEQQE6AIAGIARCADcD4AUgBCAMrSIeNwPoBSAEIAk2ArgGIAQgBiAJaiINNgK8BiAEIApBAnQoAJiORSIFQf8Bca0iIDcD8AUgBCAFQQh2IghB/wFxIgqtIh83A/gFIAQgBUEQdkH/AXEgB2wgBUEYdmogEGwiDzYCiAYgDEUgBkVyDQggBCAJQQFqIgU2ArgGIAQgCS0AACIGQQFxrUI4hiAGQQF2QQFxrUIwhoQgBkECdkEBca1CKIaEIAZBA3ZBAXGtQiCGhCAGQQR2QQFxrUIYhoQgBkEFdkEBca1CEIaEIAZBBnZBAXGtQgiGhCAGQQd2rYQiHTcCnAYgAyAPIApBA3ZqIglLBEAgHachCiAfICB8IRxBASEGA0AgAiAJaiIJIAktAAAgCiAIQX9zQQdxdHI6AAAgHkIBfSIeUA0KAn8gBkEIRwRAIAYgGmotAAAMAQsgBSANRg0LIAQgBUEBaiIJNgK4BiAEIAUtAAAiBUEBca1COIYgBUEBdkEBca1CMIaEIAVBAnZBAXGtQiiGhCAFQQN2QQFxrUIghoQgBUEEdkEBca1CGIaEIAVBBXZBAXGtQhCGhCAFQQZ2QQFxrUIIhoQgBUEHdq2EIh03ApwGQQAhBiAJIQUgHacLIQogHEIDiCEdIBynIQggBkEBaiEGIBwgIHwhHCAPIB2naiIJIANJDQALCyAJIANB+IzFABCMBwALIAxFDQcgDK0hHCATIApBAnQoAJiORSIFQf8BcWwhCCADIAVBEHZB/wFxIAdsIAVBGHZqIBBsIBMgBUEIdkH/AXFsaiIKayEFA0AgBkUNCCADIApJDQIgEyAGIAYgE0sbIg0gBUsNAyANBEAgAiAKaiAJIA38CgAACyAGIA1rIQYgCSANaiEJIAUgCGshBSAIIApqIQogHEIBfSIcQgBSDQALDAcLQcyYxwAQ3QkACyAKIAMgA0GIjsUAEOoHAAtBACANIAVB+I3FABDqBwALAkACQAJAIApBB0kEQCAMRQ0HIAytIRwgAyAKQQJ0KACYjkUiDUEQdkH/AXEgB2wgDUEYdmogEGwiCGsgDUEIdkH/AXFBAXQiBWshCiANQf8BcUEBdCENIAUgCGohCANAIAZFDQggAyAISQ0CIApBAU0NA0ECIAYgBkECTxshBSAGQQFGDQQgBiAFayEGIAIgCGogCS8AADsAACAKIA1rIQogCCANaiEIIAUgCWohCSAcQgF9IhxQRQ0ACwwHCwwXCyAIIAMgA0HYjcUAEOoHAAtBAEECIApBuI3FABDqBwALQQIgBUHIjcUAEN4JAAsgCkEHSQRAIAxFDQMgCkECdCgAmI5FIgpB/wFxIQUgDK0hHCAKQRB2Qf8BcSAHbCAKQRh2aiAQbCAKQQh2Qf8BcWohCANAIAZFDQQgAyAISwRAIAIgCGogCS0AADoAACAGQQFrIQYgBSAIaiEIIAlBAWohCSAcQgF9IhxQRQ0BDAULCyAIIANBqI3FABCMBwALDBMLIApBB0kEQCAMRSAGRXINAgJAIApBAnQoAJiORSISQRB2Qf8BcSAHbCASQRh2aiAQbCIPIBJBCHYiDUH/AXEiCkEBdmoiCCADTw0AIAIgCGoiBSAFLQAAIAktAAAiBUEEdiANQQJ0QX9zQQRxdHI6AAAgDEEBRg0DIAYgCWohDSAJQQFqIQkgBUEPcSEFIAytQgF9IR4gEkH/AXGtIh9CAoYhHSAfIAqtfEIChiEcQQEhBgNAAn8gBkECRwRAIAUhCkECDAELIAkgDUYNBSAJLQAAIgZBD3EhBSAGQQR2IQogCUEBaiEJQQELIQYgDyAcQgOIp2oiCCADTw0BIAIgCGoiCCAILQAAIAogHKdBf3NBBHF0cjoAACAcIB18IRwgHkIBfSIeUEUNAAsMAwsgCCADQZiNxQAQjAcACwwSCyAKQQdPDQMgBEIANwPABiAEQQM6AIwGIARBhogINgKIBiAEQQA2AvAFIARBADYC4AUgBCAMrSIgNwOYBiAEIAk2AoAGIAQgBiAJaiIPNgKEBiAEQQI6ALAGIAQgCkECdCgAmI5FIgVB/wFxrSIcNwOgBiAEIAVBCHYiDUH/AXEiCq0iHTcDqAYgBCAFQRB2Qf8BcSAHbCAFQRh2aiAQbCISNgK4BiAMRQ0AIARCATcDkAYgBkUNACAEIAlBAWoiBTYCgAYgBCAJLQAAIgZBA3FBGHQgBkEOdEGAgAxxciAGQQR0QYAGcXIgBkEGdiIIcjYC7AUgAyASIApBAnZqIglLBEAgDUEBdCEKQgEhHiAcQgGGIR8gHCAdfEIBhiEcQQEhBgNAIAIgCWoiCSAJLQAAIAggCkF/c0EGcXRyOgAAIB4gIFENAiAEIB5CAXwiHjcDkAYCQCAGQQRHBEAgBiAbai0AACEIDAELIAUgD0YNAyAEIAVBAWoiCTYCgAYgBCAFLQAAIgVBA3FBGHQgBUEOdEGAgAxxciAFQQR0QYAGcXIgBUEGdiIIcjYC7AVBACEGIAkhBQsgHEIDiCEdIBynIQogHCAffCEcIAZBAWohBiASIB2naiIJIANJDQALCyAJIANBiI3FABCMBwALIAdBCHYhBiAYIBEoAgA2AgAgBCAWKQIANwPQBSAEQQA2AqgFIARCgICAgBA3A6AFIAQoAnhBAkcNAAsLDAoLDA0LIARBADYC8AUgBEEBNgLkBSAEQbyhxwA2AuAFIARCBDcC6AUgBEHgBWpBvJjHABCNCAALDAcLIAutIB9CIIaEIRxBACELDAQLIARB4AVqIA4Q5wQgBC0A4AUiB0EoRg0BIAQvAOEFIAQtAOMFQRB0cgshBiAEKQLoBSEcIAQoAuQFIQsMAgtBCCEMQQIhBkEBIQtBAyEJQQEhBwJAAkACQAJAAkACQAJAAkAgBC0AuAUiBUEBaw4JAgQBAgEDBgAFBwtBDCEJDAMLQQQhBgsgBiEJIAYhDCAGIQcCQCAFQQJrDgMCBAUAC0ECIQsMBAtBBiEJCyAJIQdBAyELDAILQRAhDAtBBCELIAwhBwsCQAJAAkAgByALbkEBaw4CAgEAC0Gk+MYAQShBtM3HABDrBwALIANBfnEiBkUNACACIQcgA0ECayIDQQ5PBEAgByADQQF2QQFqIgxBeHEiBUEBdGohByAFIQsgAiEDA0AgAyAD/QAAAP0MAAAAAAAAAAAAAAAAAAAAAP0NAQADAgUEBwYJCAsKDQwPDv0LAAAgA0EQaiEDIAtBCGsiCw0ACyAFIAxGDQELIAIgBmohAwNAIAcgBy8AACICQQh0IAJBCHZyOwAAIAdBAmoiByADRw0ACwsgAEEGNgIADAILQSchBwsgBCAcNwLYBSAEIAs2AtQFIAQgB0H/AXEgBkEIdHI2AtAFIARB4AVqIARB0AVqEPwDIAAgBP0AAvQF/QsCFCAAQSRqIARBhAZqKAIANgIAIAT9AATgBSEhIAAgBCgC8AU2AhAgACAh/QsDAAsgDhDGAwJAIAFBBGsoAgAiAkF4cUH0BEH4BCACQQNxIgAbTwRAIABBACACQZgFTxsNASABEKICIARB4AZqJAAPCwwDCwwDC0GsmMcAEN0JAAtB0I/FABCBCAALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAKQQdB1I7FABCMBwAL0CsEE38EfQF+AXsjAEHAAWsiAiQAAkACQAJAAkAgASgCiAFBAkcEQCABKAKQAyIFIAEoAuwBSQRAIAFBtAJqIRMgAUH4AWohECABQdgCaiEUA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAugBIAVBKGxqIggpAxAgASkD6AJ8IhkgASkD2AJRBEAgASgCgAMiAyAIKAIYIgVBB2pBeHFJDQEgAyAFSQ0CIAEoAvwCIQMgCC0AICISQQFGBEAgAkEQaiADIAUQ+QIgAigCECIDQYCAgIB4RwRAIAIoAhQgAkEANgKwASACQQE2AqQBIAJBuMnBADYCoAEgAkIENwKoASACQaABahCSByEOIANFDR0gA0EBEKIHDB0LIAIoAhghDiACKAIUIg9BgICAgHhGDRwgAigCHCEFIA4hAwtBCSEEAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAn8CQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAgtACJBAWsODQECAxofHR4bHB8dHgQACyAILQAhDgQEBQYHCQsgCC0AIQ4FCwoJCQwJCyAILQAhIgQOBg4NEBAPDxALIAgtACEOChIRERERERERFBMRCyAILQAhQQtrDgIcHRsLIAJBEGogAyAFQQMgASgCmAMQ+AQMAwsgAkEQaiADIAVBAyABKAKYAxDmAwwCCyACQRBqIAMgBSABKAKYAxCgAgwBCyACQRBqIAMgBSABKAKYAxD+AQsgAigCFCEHIAEoApgDIg0EQCACKAIYIQpBACEGIAEoAoACIgsgASgClAMiDGsiA0EAIAMgC00bIREgASgC/AEgDEEYbGohAyAHIQRBACEFA0AgBSARRg0fIAZBA2oiCSAKSyAFQdSq1aoFS3INICADIARBCGogBP1dAgD9VgIAAiIa/VoCCAIgAyAa/VsCAAAgBEEMaiEEIANBGGohAyAJIQYgDSAFQQFqIgVHDQALCyACKAIQIgNFDTEgB0EEaygCACIGQXhxIgQgA0ECdCIDQQRBCCAGQQNxIgYbakkNNyAGQQAgBCADQSdqSxsNOCAHEKICDDELIAJBATYCpAEgAkHgycEANgKgASACQgE3AqwBIAIgCEEhaq1CgICAgJAFhDcDUCACIAJB0ABqNgKoASACQSBqIgEgAkGgAWoQsQYgARCOByEBIABBAToAACAAIAE2AgQMLwsgAkEBNgKkASACQbzKwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNQIAIgAkHQAGo2AqgBIAJBLGoiASACQaABahCxBiABEI4HDAMLIAJBEGogAyAFQQEgASgCmAMQ5gMMLAsgAkEQaiADIAVBASABKAKYAxD4BAwrCyAIKAIARQRAIAJBADYCsAEgAkEBNgKkASACQZjKwQA2AqABIAJCBDcCqAEgAkGgAWoQkgcMAQsgCCgCCA0pIAJBADYCsAEgAkEBNgKkASACQfzJwQA2AqABIAJCBDcCqAEgAkGgAWoQkgcLIQUgAEEBOgAAIAAgBTYCBAwqCyACQRBqIAMgBUEDIAEoApgDEOYDDCYLIAJBEGogAyAFQQMgASgCmAMQ+AQMJQsgCCgCAEUEQCACQQA2ArABIAJBATYCpAEgAkGYysEANgKgASACQgQ3AqgBIAJBoAFqEJIHDAILIAgoAghFBEAgAkEANgKwASACQQE2AqQBIAJB/MnBADYCoAEgAkIENwKoASACQaABahCSBwwCCyAIKgIEIRUgASgCmAMhBiAIKgIMIRYgBEEERg0jIAJBEGogAyAFQQMgBiAVIBYQ/wMMJAsgAkEBNgKkASACQeDKwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNQIAIgAkHQAGo2AqgBIAJBOGoiASACQaABahCxBiABEI4HCyEFIABBAToAACAAIAU2AgQMJQsgAkEBNgKkASACQYjLwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNQIAIgAkHQAGo2AqgBIAJBxABqIgEgAkGgAWoQsQYgARCOBwwDCyACQRBqIAMgBUEDIAEoApgDEPgEDB4LIAJBEGogAyAFIAEoApgDEP0BDB0LIAgoAgBFBEAgAkEANgKwASACQQE2AqQBIAJBmMrBADYCoAEgAkIENwKoASACQaABahCSBwwBCyAIKAIIDRsgAkEANgKwASACQQE2AqQBIAJB/MnBADYCoAEgAkIENwKoASACQaABahCSBwshBSAAQQE6AAAgACAFNgIEDCALAkACQAJAAkAgCC0AISIGQQpHBEAgBg4CAgMBCyACQdAAaiADIAUgASgCmAMQxQMMHAsgAkEBNgKkASACQcTLwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNoIAIgAkHoAGo2AqgBIAJB3ABqIgEgAkGgAWoQsQYgARCOByEBIABBAToAACAAIAE2AgQMIgsgAkEQaiADIAVBAyABKAKYAxD4BAwBCyACQRBqIAMgBUEDIAEoApgDEOYDCyABKAKYAyIKQQJ0IgVB/////wNLDQ4gCkEEdCIDQf3///8HTw0OAkAgA0UEQEEEIQlBACEFDAELIAMQcSIJRQ0QIAEoApgDIQoLIAJBADYCqAEgAiAJNgKkASACIAU2AqABIAoEQEEAIQNBASEHIAIoAhghBiACKAIUIQUDQCAHQQFrIgQgBk8EQCAEIQcMGgsgBiAEayIEQQAgBCAGTRsiBEEBRg0ZIARBAkYNGEMAAIA/IAUqAgAiFSAVlJMgBUEEaioCACIWIBaUkyAFQQhqKgIAIhcgF5STQwAAAAAQ4AiRIRggAigCoAEgA2tBA00EQCACQaABaiADQQRBBEEEEKQFIAIoAqQBIQkgAigCqAEhAwsgCSADQQJ0aiIEIBg4AgwgBCAXOAIIIAQgFjgCBCAEIBU4AgAgAiADQQRqIgM2AqgBIAdBA2ohByAFQQxqIQUgCkEBayIKDQALCyACQdgAaiACQagBaigCADYCACACIAIpAqABNwNQIAIoAhAiA0UNGCACKAIUIgZBBGsoAgAiBEF4cSIHIANBAnQiA0EEQQggBEEDcSIEG2pJDSYgBEEAIAcgA0EnaksbDScgBhCiAgwYCyAILQAhQQtGDRQgAkEBNgKkASACQfDLwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwMQIAIgAkEQajYCqAEgAkGIAWoiASACQaABahCxBiABEI4HIQEgAEEBOgAAIAAgATYCBAweCyAILQAhQQxGDRIgAkEBNgKkASACQZzMwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwMQIAIgAkEQajYCqAEgAkGUAWoiASACQaABahCxBiABEI4HIQEgAEEBOgAAIAAgATYCBAwdC0EPIQQMAQtBFSEECwJAAkACQAJAAkAgCC0AISIGDggBAAMDAgIEBAMLIAJBEGogAyAFIAQgASgCmAMQ5gMMEgsgAkEQaiADIAUgBCABKAKYAxD4BAwRCyAIKAIARQRAIAJBADYCsAEgAkEBNgKkASACQZjKwQA2AqABIAJCBDcCqAEgAkGgAWoQkgchBQwPCyAIKAIIRQRAIAJBADYCsAEgAkEBNgKkASACQfzJwQA2AqABIAJCBDcCqAEgAkGgAWoQkgchBQwPCyAIKgIEIRUgASgCmAMhByAIKgIMIRYgBkEERg0PIAJBEGogAyAFIAQgByAVIBYQ/wMMEAsgAkEBNgKkASACQdDMwQA2AqABIAJCATcCrAEgAiAIQSFqrUKAgICAkAWENwNQIAIgAkHQAGo2AqgBIAJB8ABqIgEgAkGgAWoQsQYgARCOByEFDA0LIAgoAghFBEAgAkEANgKwASACQQE2AqQBIAJB/MnBADYCoAEgAkIENwKoASACQaABahCSByEFDA0LIAEoApgDIQcgCCoCDCEVIAZBBkYNCyACQRBqIAMgBSAEIAcgFRCQBAwOCyACQQE2AqQBIAJB+MzBADYCoAEgAkIBNwKsASACIAhBIWqtQoCAgICQBYQ3A1AgAiACQdAAajYCqAEgAkH8AGoiASACQaABahCxBiABEI4HIQEgAEEBOgAAIAAgATYCBAwZCyACQRBqIAMgBSABKAKYAxCOBQwBCyACQRBqIAMgBSABKAKYAxDTBAsgAigCECIDRQ0XIAIoAhQiBkEEaygCACIEQXhxIgcgA0ECdCIDQQRBCCAEQQNxIgQbakkNHSAEQQAgByADQSdqSxsNHiAGEKICDBcLIAIgGTcDUCACQQI2AqQBIAJBtM3BADYCoAEgAkICNwKsASACQoCAgICgBSIZIAJB0ABqrYQ3AxggAiAZIBSthDcDECACIAJBEGo2AqgBIAJBBGoiASACQaABahCxBiABEI4HIQEgAEEBOgAAIAAgATYCBAwbCyAAQQA7AQAMGgtBACAFIANBgM3BABDqBwALIAUgDGogC0Hsu8cAEIwHAAsgBiAJIApB9MLHABDqBwALQZDLwQAQ/wcLAAsgAkEQaiADIAUgBCAHIBUQggUMAgsgAEEBOgAAIAAgBTYCBAwNCyACQRBqIAMgBSAEIAcgFSAWEPkECwJAAkACQAJAAkACQCAILQAiQQVrDggDAQIAAAQEBAALQaT4xgBBKEGkzMEAEOsHAAsgECABKAKUAyABKAKYAyACKAIUIAIoAhgQxwEMAgsgASgC1AJBA0kNASABKAKYAyINRQ0BQwAA/kJDAAD+QiABKgLMApUgAS0A0AJBAkYbIRYgAigCGCELIAIoAhQhBiABKAKsAiABKAKUAyIRQRVsaiEHIAEoArACIQxBACEEQQAhCQNAIAwgCSARaiIDSwRAIAlBAWohCUEAIQUgBiEDA0AgBCAFaiIKIAtPDQUgBSAHakH/AEMAAP5CQwAA/sIgFiADKgIAlCIVIBVDAAD+wl0bIhUgFUMAAP5CXhsQuQciFfwAQYB/IBVDAAAAw2AbIBVDAAD+Ql4bQQAgFSAVWxs6AAAgA0EEaiEDIAVBAWoiBUEVRw0ACyAGQdQAaiEGIARBFWohBCAHQRVqIQcgCSANRw0BDAMLCyAJQRVsIgogC08NAiADIAxBxMTHABCMBwALIBAgASgClAMgASgCmAMgAigCFCACKAIYEJYCCyACKAIQIgNFDQ0CQCACKAIUIgZBBGsoAgAiBEF4cSIHIANBAnQiA0EEQQggBEEDcSIEG2pPBEAgBEEAIAcgA0EnaksbDQEgBhCiAgwPCwwUCwwUCyAKIAtBtMTHABCMBwALIAJBoAFqIAMgBSABKAKYAxDUBCABKAKIAiABKAKMAiABKAKUAyABKAKYAyACKAKkASIDIAIoAqgBEI0DIAIoAqABIgZFDQsCQCADQQRrKAIAIgRBeHEiByAGQQJ0IgZBBEEIIARBA3EiBBtqTwRAIARBACAHIAZBJ2pLGw0BIAMQogIMDQsMEgsMEgsgAkGgAWogAyAFIAEoApgDEJwFIAEoAogCIAEoAowCIAEoApQDIAEoApgDIAIoAqQBIgMgAigCqAEQswMgAigCoAEiBkUNCgJAIANBBGsoAgAiBEF4cSIHIAZBAXQiBkEEQQggBEEDcSIEG2pPBEAgBEEAIAcgBkEnaksbDQEgAxCiAgwMCwwRCwwRCyAHQQFqIQcLIAcgBkHEzcEAEIwHAAsgAigCVCEJAkACQAJAIAEoApgDIgoEQCACKAJYIQtBACEDIAEoAoACIgwgASgClAMiBmsiBEEAIAQgDE0bIQQgASgC/AEgBkEYbGpBFGohBSAJIQcDQCAERQ0CIANBA2ogC08NAyACIAf9AAIA/QsEoAEgBUECaiACQaABahCdBCINQRB2OgAAIAUgDTsBACAHQRBqIQcgA0EEaiEDIAVBGGohBSAGQQFqIQYgBEEBayEEIApBAWsiCg0ACwsgAigCUCIDRQ0KIAlBBGsoAgAiBkF4cSIEIANBAnQiA0EEQQggBkEDcSIGG2pJDRAgBkEAIAQgA0EnaksbDQIgCRCiAgwKCyAGIAxB7LvHABCMBwALIAMgA0EEaiALQdTExwAQ6gcACwwOCyACQRBqIAMgBSABKAKYAyAIKgIEIAgqAgwQqgMLIAIoAhQhBwJAAkACQCABKAKYAyILBEAgAigCGCEKIAEoApQDIgxBGGwhBEEAIQYgByEDQQAhBQNAIAUgDGoiCSABKAKAAiINTw0CIAZBA2oiCSAKSyAFQdSq1aoFS3INAyABKAL8ASAEaiATIAP9XQIAIANBCGoqAgAiFf0gAiAV/SADEN8EIANBDGohAyAEQRhqIQQgCSEGIAsgBUEBaiIFRw0ACwsgAigCECIDRQ0IIAdBBGsoAgAiBkF4cSIEIANBAnQiA0EEQQggBkEDcSIGG2pJDQ4gBkEAIAQgA0EnaksbDQIgBxCiAgwICyAJIA1B7LvHABCMBwALIAYgCSAKQbTFxwAQ6gcACwwMCyACQRBqIAMgBUEDIAYgFSAWEPkECyAQIAEoApQDIAEoApgDIAIoAhQiAyACKAIYEKQEIAIoAhAiBkUNAwJAIANBBGsoAgAiBEF4cSIHIAZBAnQiBkEEQQggBEEDcSIEG2pPBEAgBEEAIAcgBkEnaksbDQEgAxCiAgwFCwwKCwwKCyACQRBqIAMgBUEBIAEoApgDIAgqAgQgCCoCDBD5BAsgASgC/AEgASgCgAIgASgClAMgASgCmAMgAigCFCIDIAIoAhgQqgIgAigCECIGRQ0BAkAgA0EEaygCACIEQXhxIgcgBkECdCIGQQRBCCAEQQNxIgQbak8EQCAEQQAgByAGQSdqSxsNASADEKICDAMLDAgLDAgLIBJFIA9Fcg0FIA4gD0EBEKIHDAULAkACQAJAIAEoAoADIgYgCCgCGEEHakF4cSIDTwRAIAFBADYCgAMgBiADayEEIANFDQEgAyAGRg0DIARFDQIgASgC/AIiBiADIAZqIAT8CgAADAILQQAgAyAGQYSkxwAQ6gcACyADIAZGDQELIAEgBDYCgAMLIAgpAxghGSABIAEoApADQQFqIgU2ApADIAEgASkD2AIgGUIHfEL4////D4N8NwPYAgJAIBJFIA9Fcg0AAkAgDkEEaygCACIDQXhxIgZBBEEIIANBA3EiAxsgD2pPBEAgA0EAIAYgD0EnaksbDQEgDhCiAiABKAKQAyEFDAILDAcLDAcLIAUgASgC7AFJDQALCyAAQYACOwEADAILQYzJwQAQ3QkACyAAQQE6AAAgACAONgIECyACQcABaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALqC8BBX8jAEEwayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgMtAABBAWsOIwECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjAAsgAiADQQxqNgIQIAEoAgBBlNDEAEELIAEoAgQoAgwRAAAhACACQQA6ACUgAiAAOgAkIAIgATYCICACQSBqQZ/QxABBByADQQRqQfTPxAAQjAVBptDEAEEHIANBCGpB9M/EABCMBUGM08cAQQUgAkEQakGE0MQAEIwFIAItACUiAyACLQAkIgRyIQAgBEEBcSADQQFHcg0jKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAwkCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQAMIwsgASgCAEGt0MQAQRAgASgCBCgCDBEAACEADCILIAEoAgBBvdDEAEELIAEoAgQoAgwRAAAhAAwhCyABKAIAQcjQxABBECABKAIEKAIMEQAAIQAMIAsgAiADQQFqNgIQIAEoAgBB2NDEAEEPIAEoAgQoAgwRAAAhACACQQA6ACUgAiAAOgAkIAIgATYCICACQSBqQcj7xwBBBCACQRBqQYTQxAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDR8oAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADCALIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwfCyACIANBAWo2AhAgASgCAEHn0MQAQQkgASgCBCgCDBEAACEAIAJBADoAJSACIAA6ACQgAiABNgIgIAJBIGpByPvHAEEEIAJBEGpBhNDEABCMBSACLQAlIgMgAi0AJCIEciEAIARBAXEgA0EBR3INHigCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQAMHwsgACgCAEGls8UAQQEgACgCBCgCDBEAACEADB4LIAIgA0EBajYCECABKAIAQfDQxABBCiABKAIEKAIMEQAAIQAgAkEAOgAlIAIgADoAJCACIAE2AiAgAkEgakHI+8cAQQQgAkEQakGE0MQAEIwFIAItACUiAyACLQAkIgRyIQAgBEEBcSADQQFHcg0dKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAweCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQAMHQsgAiADQQFqNgIQIAEoAgBB+tDEAEEJIAEoAgQoAgwRAAAhACACQQA6ACUgAiAAOgAkIAIgATYCICACQSBqQcj7xwBBBCACQRBqQYTQxAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDRwoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADB0LIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwcCyACIANBAWo2AhAgASgCAEGD0cQAQQ8gASgCBCgCDBEAACEAIAJBADoAJSACIAA6ACQgAiABNgIgIAJBIGpByPvHAEEEIAJBEGpBhNDEABCMBSACLQAlIgMgAi0AJCIEciEAIARBAXEgA0EBR3INGygCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQAMHAsgACgCAEGls8UAQQEgACgCBCgCDBEAACEADBsLIAIgA0EBajYCECABKAIAQZLRxABBDiABKAIEKAIMEQAAIQAgAkEAOgAlIAIgADoAJCACIAE2AiAgAkEgakHI+8cAQQQgAkEQakGE0MQAEIwFIAItACUiAyACLQAkIgRyIQAgBEEBcSADQQFHcg0aKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAwbCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQAMGgsgAiADQQhqNgIQIAEoAgBBoNHEAEEJIAEoAgQoAgwRAAAhACACQQA6ACUgAiAAOgAkIAIgATYCICACQSBqQanRxABBByADQQRqQfTPxAAQjAVBkK/HAEEIIAJBEGpB1LbEABCMBSACLQAlIgMgAi0AJCIEciEAIARBAXEgA0EBR3INGSgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQAMGgsgACgCAEGls8UAQQEgACgCBCgCDBEAACEADBkLIAIgA0EIajYCECABKAIAQbDRxABBDCABKAIEKAIMEQAAIQAgAkEAOgAlIAIgADoAJCACIAE2AiAgAkEgakGQr8cAQQggA0EEakGgwMQAEIwFQbzRxABBAyACQRBqQeS2xAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDRgoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADBkLIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwYCyACIANBCGo2AhAgASgCAEHQ0cQAQRQgASgCBCgCDBEAACEAIAJBADoAJSACIAA6ACQgAiABNgIgIAJBIGpB5NHEAEEKIANBAWpBwNHEABCMBUGQr8cAQQggA0EEakGgwMQAEIwFQbzRxABBAyACQRBqQeS2xAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDRcoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADBgLIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwXCyACIANBAWo2AhAgASgCAEGA0sQAQQsgASgCBCgCDBEAACEAIAJBADoAJSACIAA6ACQgAiABNgIgIAJBIGpBi9LEAEEMIANBAmpB8NHEABCMBUGX0sQAQQQgAkEQakGUtsQAEIwFIAItACUiAyACLQAkIgRyIQAgBEEBcSADQQFHcg0WKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAwXCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQAMFgsgASgCAEGb0sQAQQ8gASgCBCgCDBEAACEADBULIAIgA0EBajYCECABKAIAQbzSxABBFCABKAIEKAIMEQAAIQAgAkEAOgAlIAIgADoAJCACIAE2AiAgAkEgakHk0cQAQQogA0ECakHA0cQAEIwFQdDSxABBCSACQRBqQazSxAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDRQoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADBULIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwUC0EBIQAgASgCACIEQdnSxABBECABKAIEIgYoAgwiBREAAA0TIANBAWohAwJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANFSABKAIAIAMtAABBAnQiAygCxIdJIAMoAqiHSSABKAIEKAIMEQAARQ0BDBULIARB24HCAEECIAURAAANFCACIAY2AiQgAiAENgIgIAJBAToAECADLQAAQQJ0IgMoArCFSSEEIAMoAsyFSSEDIAIgAkEQajYCKCACQSBqIgUgAyAEEK8DDRQgBUHZgcIAQQIQrwMNFAsgASgCAEHejsgAQQEgASgCBCgCDBEAACEADBMLIAEoAgBB783EAEERIAEoAgQoAgwRAAAhAAwSC0EBIQAgAiADQQFqNgIMIAEoAgAiA0Hp0sQAQQ8gASgCBCIFKAIMIgQRAAANEQJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANEyACQQxqIAEQxARFDQEMEwsgA0HbgcIAQQIgBBEAAA0SIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNEiACKAIgQdmBwgBBAiACKAIkKAIMEQAADRILIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwRC0EBIQAgAiADQQFqNgIMIAEoAgAiA0H40sQAQRAgASgCBCIFKAIMIgQRAAANEAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANEiACQQxqIAEQxARFDQEMEgsgA0HbgcIAQQIgBBEAAA0RIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNESACKAIgQdmBwgBBAiACKAIkKAIMEQAADRELIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwQC0EBIQAgAiADQQFqNgIMIAEoAgAiA0GI08QAQRAgASgCBCIFKAIMIgQRAAANDwJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANESACQQxqIAEQxARFDQEMEQsgA0HbgcIAQQIgBBEAAA0QIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNECACKAIgQdmBwgBBAiACKAIkKAIMEQAADRALIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwPC0EBIQAgAiADQQFqNgIMIAEoAgAiA0GY08QAQQ4gASgCBCIFKAIMIgQRAAANDgJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANECACQQxqIAEQxARFDQEMEAsgA0HbgcIAQQIgBBEAAA0PIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNDyACKAIgQdmBwgBBAiACKAIkKAIMEQAADQ8LIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwOC0EBIQAgAiADQQFqNgIMIAEoAgAiA0Gm08QAQQsgASgCBCIFKAIMIgQRAAANDQJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANDyACQQxqIAEQxARFDQEMDwsgA0HbgcIAQQIgBBEAAA0OIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNDiACKAIgQdmBwgBBAiACKAIkKAIMEQAADQ4LIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwNC0EBIQAgAiADQQFqNgIMIAEoAgAiA0Gx08QAQRogASgCBCIFKAIMIgQRAAANDAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANDiACQQxqIAEQxARFDQEMDgsgA0HbgcIAQQIgBBEAAA0NIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNDSACKAIgQdmBwgBBAiACKAIkKAIMEQAADQ0LIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwMC0EBIQAgAiADQQFqNgIMIAEoAgAiA0HL08QAQRggASgCBCIFKAIMIgQRAAANCwJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANDSACQQxqIAEQxARFDQEMDQsgA0HbgcIAQQIgBBEAAA0MIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNDCACKAIgQdmBwgBBAiACKAIkKAIMEQAADQwLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwLC0EBIQAgAiADQQFqNgIMIAEoAgAiA0Hj08QAQRMgASgCBCIFKAIMIgQRAAANCgJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANDCACQQxqIAEQxARFDQEMDAsgA0HbgcIAQQIgBBEAAA0LIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNCyACKAIgQdmBwgBBAiACKAIkKAIMEQAADQsLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwKC0EBIQAgAiADQQFqNgIMIAEoAgAiA0H208QAQRYgASgCBCIFKAIMIgQRAAANCQJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANCyACQQxqIAEQxARFDQEMCwsgA0HbgcIAQQIgBBEAAA0KIAJBAToAHyACIAU2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNCiACKAIgQdmBwgBBAiACKAIkKAIMEQAADQoLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAAwJCyABKAIAQYzUxABBESABKAIEKAIMEQAAIQAMCAsgAiADQQFqNgIQIAEoAgBBsNTEAEESIAEoAgQoAgwRAAAhACACQQA6ACUgAiAAOgAkIAIgATYCICACQSBqQcLUxABBAyACQRBqQaDUxAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDQcoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADAgLIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwHCyABKAIAQcXUxABBDyABKAIEKAIMEQAAIQAMBgtBASEAIAEoAgAiBEHU1MQAQQ8gASgCBCIGKAIMIgURAAANBSADQQFqIQMCQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQcgAyABKAIAIAEoAgQQ1ghFDQEMBwsgBEHbgcIAQQIgBREAAA0GIAIgBjYCJCACIAQ2AiAgAkEBOgAQIAIgAkEQajYCKCADIAJBIGoiA0HggcIAENYIDQYgA0HZgcIAQQIQrwMNBgsgASgCAEHejsgAQQEgASgCBCgCDBEAACEADAULIAEoAgBB49TEAEEYIAEoAgQoAgwRAAAhAAwECyACIANBAWo2AhAgASgCAEH71MQAQSQgASgCBCgCDBEAACEAIAJBADoAJSACIAA6ACQgAiABNgIgIAJBIGpByPvHAEEEIAJBEGpBhNDEABCMBSACLQAlIgMgAi0AJCIEciEAIARBAXEgA0EBR3INAygCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQAMBAsgACgCAEGls8UAQQEgACgCBCgCDBEAACEADAMLIAIgA0EBajYCECABKAIAQZ/VxABBECABKAIEKAIMEQAAIQAgAkEAOgAlIAIgADoAJCACIAE2AiAgAkEgakHI+8cAQQQgAkEQakGE0MQAEIwFIAItACUiAyACLQAkIgRyIQAgBEEBcSADQQFHcg0CKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAwDCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQAMAgsgAiADQQFqNgIQIAEoAgBBr9XEAEEZIAEoAgQoAgwRAAAhACACQQA6ACUgAiAAOgAkIAIgATYCICACQSBqQcjVxABBCCACQRBqQYTQxAAQjAUgAi0AJSIDIAItACQiBHIhACAEQQFxIANBAUdyDQEoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADAILIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAwBCyABKAIAQdDVxABBDSABKAIEKAIMEQAAIQALIAJBMGokACAAQQFxC9wkAhd/A34jAEHABmsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABKQMAIhxQRQRAIAEpAwgiHVANASABKQMQIh5QDQIgHiAcQn+FVg0DIBwgHVQNBCABLgEYIQEgBSAcPgIMIAVBAUECIBxCgICAgBBUIgYbNgKsASAFQQAgHEIgiKcgBhs2AhAgBUEUakEAQZgB/AsAIAVBtAFqQQBBnAH8CwAgBUEBNgKwASAFQQE2AtACIAGsIBxCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciBsEhDwJAIAFBAE4EQCAFQQxqIAEQuQMaDAELIAVBsAFqQQAgAWvBELkDGgsCQCAPQQBIBEAgBUEMakEAIA9rQf//A3EQ9AEMAQsgBUGwAWogBkH//wFxEPQBCyAFQZwFaiAFQbABakGkAfwKAAAgBUGUBWohCiADIQgDQCAFKAK8BiIBQSlPDQ4CQCABRQ0AAn4gAUECdCIBQQRrIglFBEAgBUGcBWogAWohAUIADAELIAEgCmohByAJQQJ2QQFqQf7///8HcSEGQgAhHANAIAciAUEEaiIHIAc1AgAgHEIghoQiHEKAlOvcA4AiHT4CACABIAE1AgAgHCAdQoCU69wDfn1CIIaEIhxCgJTr3AOAIh0+AgAgHCAdQoCU69wDfn0hHCABQQhrIQcgBkECayIGDQALIAlBBHENASAcQiCGCyEcIAFBBGsiASAcIAE1AgCEQoCU69wDgD4CAAsgCEEJayIIQQlLDQALIAhBAnQoAqCVQkEBdCIGRQ0FIAUoArwGIgFBKU8NDSABBH8gBq0hHAJAAn4gAUECdCIBQQRrIglFBEAgBUGcBWogAWohAUIADAELIAEgBWpBlAVqIQcgCUECdkEBakH+////B3EhBkIAIR0DQCAHIgFBBGoiByAHNQIAIB1CIIaEIh0gHIAiHj4CACABIAE1AgAgHSAcIB5+fUIghoQiHSAcgCIePgIAIB0gHCAefn0hHSABQQhrIQcgBkECayIGDQALIAlBBHENASAdQiCGCyEdIAFBBGsiASAdIAE1AgCEIByAPgIACyAFKAK8BgVBAAshASAFKAKsASIJIAEgASAJSRsiDEEoSw0GAkAgDEUEQEEAIQwMAQtBACEKQQAhCAJAAkAgDEEBRwRAIAxBAXEgDEE+cSELIAVBnAVqIQEgBUEMaiEHA0AgASAHKAIAIg0gASgCAGoiBiAIQQFxaiIONgIAIAFBBGoiCCAHQQRqKAIAIhQgCCgCAGoiCCAGIA1JIAYgDktyaiIGNgIAIAggFEkgBiAISXIhCCAHQQhqIQcgAUEIaiEBIAsgCkECaiIKRw0AC0UNAQsgCkECdCIBIAVBnAVqaiIGIAVBDGogAWooAgAiByAGKAIAaiIBIAhqIgY2AgAgASAHSSABIAZLcg0BDAILIAhFDQELIAxBKEYNDyAFQZwFaiAMQQJ0akEBNgIAIAxBAWohDAsgBSAMNgK8BiAFKALQAiIQIAwgDCAQSRsiAUEpTw0NIAFBAnQhAQJAAkADQCABRQ0BIAFBBGsiASAFQZwFamooAgAiBiABIAVBsAFqaigCACIHRg0ACyAGIAdPDQEMCQsgBUGwAWoiBiABIAZqRw0ICyAPQQFqIQ8MCAtB2I/CAEEcQYCTwgAQ6wcAC0G0kMIAQR1BkJPCABDrBwALQeSQwgBBHEGgk8IAEOsHAAtBuJLCAEE2QZCUwgAQ6wcAC0HwkcIAQTdBgJTCABDrBwALQdSCwgBBG0GMg8IAEOsHAAtBACAMQShBjIPCABDqBwALIAlFBEBBACEJIAVBADYCrAEMAQsgCUECdCIKQQRrIgFBAnZBAWoiB0EDcSEGAkAgAUEMSQRAIAVBDGohAUIAIRwMAQsgB0H8////B3EhByAFQQxqIQFCACEcA0AgASABNQIAQgp+IBx8Ihw+AgAgAUEEaiIIIAg1AgBCCn4gHEIgiHwiHD4CACABQQhqIgggCDUCAEIKfiAcQiCIfCIcPgIAIAFBDGoiCCAINQIAQgp+IBxCIIh8Ih0+AgAgHUIgiCEcIAFBEGohASAHQQRrIgcNAAsLIAYEQCAGQQJ0IQcDQCABIAE1AgBCCn4gHHwiHT4CACABQQRqIQEgHUIgiCEcIAdBBGsiBw0ACwsgHUKAgICAEFoEQCAJQShGDQcgBUEMaiAKaiAcPgIAIAlBAWohCQsgBSAJNgKsAQtBACEMQQEhCyAPwSIBIATBIgZIIhsNACAPIARrwSADIAEgBmsgA0kbIgpFDQBBACIBRQRAIAVB1AJqIAVBsAFqQaQB/AoAAAsgBUHUAmpBARC5AyEUIAFFBEAgBUH4A2ogBUGwAWpBpAH8CgAACyAFQfgDakECELkDIRYgAUUEQCAFQZwFaiAFQbABakGkAfwKAAALIAVBnAVqQQMQuQMhFyAUKAKgASEYIBYoAqABIRkgFygCoAEhGkEAIQ0CQAJAAkADQAJ/AkACQCAJQSlJBEAgCUECdCEEQQAhAQJAA0AgASAERg0BIAVBDGogAWogAUEEaiEBKAIARQ0ACyAaIAkgCSAaSRsiBkEpTw0QIAZBAnQhAQJAAkADQCABRQ0BIAFBBGsiASAFQQxqaigCACIEIAEgBUGcBWpqKAIAIgdGDQALIAQgB0kNAQwFCyAXIAVBnAVqIAFqRg0ECyAJIQZBAAwECyADIApJDQECQCAKIA1GDQAgCiANayIBRQ0AIAIgDWpBMCAB/AsACyAAIA87AQggACAKNgIEDAoLDA0LIA0gCiADQfCTwgAQ6gcAC0EBIQhBACELAkACQCAGQQFHBEAgBkEBcSAGQT5xIREgBUEMaiEBIAVBnAVqIQcDQCABIAEoAgAiEiAHKAIAQX9zaiIEIAhBAXFqIgg2AgAgAUEEaiIJIAkoAgAiEyAHQQRqKAIAQX9zaiIJIAQgEkkgBCAIS3JqIgQ2AgAgCSATSSAEIAlJciEIIAdBCGohByABQQhqIQEgESALQQJqIgtHDQALRQ0BCyALQQJ0IgEgBUEMamoiBCAEKAIAIgQgASAXaigCAEF/c2oiASAIaiIHNgIAIAEgBEkgASAHS3INAQwPCyAIRQ0OCyAFIAY2AqwBQQgLIQ4gGSAGIAYgGUkbIgRBKU8NAiAEQQJ0IQECQAJAAkADQCABRQ0BIAFBBGsiASAFQQxqaigCACIHIAEgBUH4A2pqKAIAIglGDQALIAcgCU8NASAGIQQMAgsgFiAFQfgDaiABakYNACAGIQQMAQsCQCAERQ0AQQEhCEEAIQsCQCAEQQFHBEAgBEEBcSAEQT5xIRIgBUEMaiEBIAVB+ANqIQcDQCABIAEoAgAiEyAHKAIAQX9zaiIGIAhBAXFqIgg2AgAgAUEEaiIJIAkoAgAiFSAHQQRqKAIAQX9zaiIJIAYgE0kgBiAIS3JqIgY2AgAgCSAVSSAGIAlJciEIIAdBCGohByABQQhqIQEgEiALQQJqIgtHDQALRQ0BCyALQQJ0IgEgBUEMamoiBiAGKAIAIgYgASAWaigCAEF/c2oiASAIaiIHNgIAIAEgBkkgASAHS3INAQwPCyAIRQ0OCyAFIAQ2AqwBIA5BBHIhDgsgGCAEIAQgGEkbIgZBKU8NCyAGQQJ0IQECQAJAAkADQCABRQ0BIAFBBGsiASAFQQxqaigCACIHIAEgBUHUAmpqKAIAIglGDQALIAcgCU8NASAEIQYMAgsgFCAFQdQCaiABakYNACAEIQYMAQsCQCAGRQ0AQQEhCEEAIQsCQCAGQQFHBEAgBkEBcSAGQT5xIRIgBUEMaiEBIAVB1AJqIQcDQCABIAEoAgAiEyAHKAIAQX9zaiIEIAhBAXFqIgg2AgAgAUEEaiIJIAkoAgAiFSAHQQRqKAIAQX9zaiIJIAQgE0kgBCAIS3JqIgQ2AgAgCSAVSSAEIAlJciEIIAdBCGohByABQQhqIQEgEiALQQJqIgtHDQALRQ0BCyALQQJ0IgEgBUEMamoiBCAEKAIAIgQgASAUaigCAEF/c2oiASAIaiIHNgIAIAEgBEkgASAHS3INAQwPCyAIRQ0OCyAFIAY2AqwBIA5BAmohDgsgECAGIAYgEEkbIglBKU8NCiAJQQJ0IQECQAJAAkADQCABRQ0BIAFBBGsiASAFQQxqaigCACIEIAEgBUGwAWpqKAIAIgdGDQALIAQgB08NASAGIQkMAgsgBUGwAWoiBCABIARqRg0AIAYhCQwBCwJAIAlFDQBBASEIQQAhCwJAIAlBAUcEQCAJQQFxIAlBPnEhEiAFQQxqIQEgBUGwAWohBwNAIAEgASgCACITIAcoAgBBf3NqIgQgCEEBcWoiCDYCACABQQRqIgYgBigCACIVIAdBBGooAgBBf3NqIgYgBCATSSAEIAhLcmoiBDYCACAGIBVJIAQgBklyIQggB0EIaiEHIAFBCGohASASIAtBAmoiC0cNAAtFDQELIAtBAnQiASAFQQxqaiIEIAQoAgAiBCAFQbABaiABaigCAEF/c2oiASAIaiIGNgIAIAEgBEkgASAGS3INAQwPCyAIRQ0OCyAFIAk2AqwBIA5BAWohDgsgAyANTQ0BIAIgDWogDkEwajoAAAJAIAlFBEBBACEJDAELIAlBAnQiBkEEayIBQQJ2QQFqIgdBA3EhBAJAIAFBDEkEQCAFQQxqIQFCACEdDAELIAdB/P///wdxIQcgBUEMaiEBQgAhHQNAIAEgATUCAEIKfiAdfCIcPgIAIAFBBGoiCCAINQIAQgp+IBxCIIh8Ihw+AgAgAUEIaiIIIAg1AgBCCn4gHEIgiHwiHD4CACABQQxqIgggCDUCAEIKfiAcQiCIfCIcPgIAIBxCIIghHSABQRBqIQEgB0EEayIHDQALCyAEBEAgBEECdCEHA0AgASABNQIAQgp+IB18Ihw+AgAgAUEEaiEBIBxCIIghHSAHQQRrIgcNAAsLIBxCgICAgBBUDQAgCUEoRg0EIAVBDGogBmogHT4CACAJQQFqIQkLIAUgCTYCrAEgDUEBaiINIApHDQALQQAhCwwECyANIANB4JPCABCMBwALQQAgBEEoQYyDwgAQ6gcACwwFC0EAIQoLAn8CQAJAAkAgEEUNACAQQQJ0IgZBBGsiAUECdkEBaiIHQQNxIQQCQCABQQxJBEAgBUGwAWohAUIAIR0MAQsgB0H8////B3EhByAFQbABaiEBQgAhHQNAIAEgATUCAEIFfiAdfCIcPgIAIAFBBGoiCCAINQIAQgV+IBxCIIh8Ihw+AgAgAUEIaiIIIAg1AgBCBX4gHEIgiHwiHD4CACABQQxqIgggCDUCAEIFfiAcQiCIfCIcPgIAIBxCIIghHSABQRBqIQEgB0EEayIHDQALCyAEBEAgBEECdCEHA0AgASABNQIAQgV+IB18Ihw+AgAgAUEEaiEBIBxCIIghHSAHQQRrIgcNAAsLIBxCgICAgBBUBEAgECEMDAELIBBBKEYNByAFQbABaiAGaiAdPgIAIBBBAWohDAsgBSAMNgLQAiAMIAkgCSAMSRsiAUEpTw0FIAFBAnQhASAFQQhqIQcCQAJAAn8CQANAIAFFDQEgASAHaigCACIEIAFBBGsiASAFQbABamooAgAiBkYNAAsgBCAGSyAEIAZJawwBC0F/QQAgBUGwAWoiBCABIARqRxsLQf8BcQ4CAAEDC0EAIAsNAxogAyAKQQFrIgFLBEAgASACai0AAEEBcQ0BDAMLIAEgA0Gwk8IAEIwHAAsgAyAKSQ0AIAIgCmohBiAKIQcCQAJAA0AgByIBRQ0BIAFBAWsiByACaiIELQAAQTlGDQALIAQgBC0AAEEBajoAACABIApNDQEgASAKIApB+ITCABDqBwALAkAgCwRAQTEhAQwBCyACQTE6AABBMCEBIApBAWsiBEUgBEVyDQAgAkEBakEwIAT8CwALIA9BAWohDyAbIAMgCk1yDQIgBiABOgAAIApBAWohCgwCCyABIApGDQEgCiABayIERQ0BIAEgAmpBMCAE/AsADAELQQAgCiADQcCTwgAQ6gcACyADIApJDQIgCgshASAAIA87AQggACABNgIECyAAIAI2AgAgBUHABmokAA8LQQAgCiADQdCTwgAQ6gcAC0EAIAFBKEGMg8IAEOoHAAtBKEEoQYyDwgAQjAcAC0EAIAlBKEGMg8IAEOoHAAtBACAGQShBjIPCABDqBwALQe+CwgBBGkGMg8IAEOsHAAuSMgI0ex1/AkACQAJAAkACQAJAAkACQAJAIAFBAksEQCADRQ0BIAVFDQIgB0UNAyAJRQ0EIAtFDQUgAEH/ASACLQAAQYWVAWxBCHYiRSAGLQAAIkAgBC0AACJGQQxsaiBAQQNsakEIakEEdiJHQZqCAmxBCHZqQZWKAWtBBnUiQ0EAIENBAEobIkMgQ0H/AU4bOgACIABB/wEgRSAKLQAAIkMgCC0AACJLQQxsaiBDQQNsakEIakEEdiJBQaXMAWxBCHZqQZrvAGtBBnUiQkEAIEJBAEobIkIgQkH/AU4bOgAAIABB/wEgRSBHQZMybEEIdiBBQYjoAGxBCHZqa0GExABqQQZ1IkVBACBFQQBKGyJFIEVB/wFOGzoAASABQQNGDQYgAkEBaiFFIANBAWsiA0F+cSFRIABBBGohRyADQQFxIVkgAUEEayJaQXhxIlJFDQkgA0EBdiIDIkEgAUEMa0EDdiIBIAEgQUsbIkEgC0EBayJIIkIgQSBCSRsiQSAJQQFrIkkiQiBBIEJJGyJBIAdBAWsiSiJCIEEgQkkbIkEgBUEBayJCIEEgQkkbIkFBEEkNByBHIAIgAyABIAEgA0sbIgEgSCIDIAEgA0kbIgEgSSIDIAEgA0kbIgEgSiIDIAEgA0kbIgEgQiIDIAEgA0kbIgNBAXRqQQNqSSBFIAAgA0EDdGpBC2oiAUlxDQcgRyAEIANBAmoiAmpJIARBAWoiSiABSXEgRyACIAZqSSABIAZLcXIgRyACIAhqSSAIQQFqIgMgAUlxIEcgAiAKakkgASAKS3Fycg0HIAogQUEBaiIBIAFBD3EiAUEQIAEbayJEaiFVIAsgRGshQSAJIERrIUIgCCBEaiFIIAcgRGshTiAGIERqIVYgBSBEayFPIAQgRGohSSBFIERBAXQiAWohAiBRIAFrIVAgRyBEQQN0IgFqIVcgUiABayFYIEb9DyEUIED9DyEMIEv9DyETIEP9DyENIAYhASAKIUMgRSFGA0AgAEH8AGogRv0AAAAiHiAT/Q0AAgQGAAAAAAAAAAAAAAAA/YkB/akB/QyFSgAAhUoAAIVKAACFSgAAIhX9tQFBCP2tASIWIBMgA/0AAAAiE/0NDxAREhMUFRYXGBkaGxwdHv2JAf2pASIj/QwJAAAACQAAAAkAAAAJAAAAIhD9tQEgQ0EBav0AAAAiG/2JAf2pASIk/a4BIA0gG/0NDxAREhMUFRYXGBkaGxwdHv2JAf2pASAT/YkB/akBIib9rgH9DAMAAAADAAAAAwAAAAMAAAAiEf21Af2uAf0MCAAAAAgAAAAIAAAACAAAACIS/a4BQQT9rQEiF/0MJWYAACVmAAAlZgAAJWYAACIY/bUBQQj9rQH9rgH9DGbI//9myP//Zsj//2bI//8iGf2uAUEG/awB/QwAAAAAAAAAAAAAAAAAAAAAIg39uAH9DP8AAAD/AAAA/wAAAP8AAAAiD/22ASAeIA39DQgKDA4AAAAAAAAAAAAAAAD9iQH9qQEgFf21AUEI/a0BIiAgEyAN/Q0DBAUGAAAAAAAAAAAAAAAA/YkB/akBIicgEP21ASAbIA39DQQFBgcAAAAAAAAAAAAAAAD9iQH9qQEiKP2uASAbIA39DQMEBQYAAAAAAAAAAAAAAAD9iQH9qQEgEyAN/Q0EBQYHAAAAAAAAAAAAAAAA/YkB/akBIin9rgEgEf21Af2uASAS/a4BQQT9rQEiGiAY/bUBQQj9rQH9rgEgGf2uAUEG/awBIA39uAEgD/22Af2GASBG/QAAECIhIA39DQACBAYAAAAAAAAAAAAAAAD9iQH9qQEgFf21AUEI/a0BIiIgEyAN/Q0HCAkKAAAAAAAAAAAAAAAA/YkB/akBIiogEP21ASAbIA39DQgJCgsAAAAAAAAAAAAAAAD9iQH9qQEiK/2uASAbIA39DQcICQoAAAAAAAAAAAAAAAD9iQH9qQEgEyAN/Q0ICQoLAAAAAAAAAAAAAAAA/YkB/akBIiz9rgEgEf21Af2uASAS/a4BQQT9rQEiJSAY/bUBQQj9rQH9rgEgGf2uAUEG/awBIA39uAEgD/22ASAhIA39DQgKDA4AAAAAAAAAAAAAAAD9iQH9qQEgFf21AUEI/a0BIh8gEyAN/Q0LDA0OAAAAAAAAAAAAAAAA/YkB/akBIi0gEP21ASAbIA39DQwNDg8AAAAAAAAAAAAAAAD9iQH9qQEiLv2uASAbIA39DQsMDQ4AAAAAAAAAAAAAAAD9iQH9qQEgEyAN/Q0MDQ4PAAAAAAAAAAAAAAAA/YkB/akBIi/9rgEgEf21Af2uASAS/a4BQQT9rQEiMCAY/bUBQQj9rQH9rgEgGf2uAUEG/awBIA39uAEgD/22Af2GAf1mIg79WAAADyAAQfQAaiAO/VgAAA4gAEHsAGogDv1YAAANIABB5ABqIA79WAAADCAAQdwAaiAO/VgAAAsgAEHUAGogDv1YAAAKIABBzABqIA79WAAACSAAQcQAaiAO/VgAAAggAEE8aiAO/VgAAAcgAEE0aiAO/VgAAAYgAEEsaiAO/VgAAAUgAEEkaiAO/VgAAAQgAEEcaiAO/VgAAAMgAEEUaiAO/VgAAAIgAEEMaiAO/VgAAAEgAEEEaiAO/VgAAAAgAEH9AGogFiAUIEr9AAAAIhT9DQ8QERITFBUWFxgZGhscHR79iQH9qQEiMSAQ/bUBIAFBAWr9AAAAIg79iQH9qQEiMv2uASAMIA79DQ8QERITFBUWFxgZGhscHR79iQH9qQEgFP2JAf2pASIz/a4BIBH9tQH9rgEgEv2uAUEE/a0BIjT9DBMZAAATGQAAExkAABMZAAAiHP21AUEI/a0BIBf9DAg0AAAINAAACDQAAAg0AAAiF/21AUEI/a0B/a4B/bEB/QwEIgAABCIAAAQiAAAEIgAAIh39rgFBBv2sASAN/bgBIA/9tgEgICAUIA39DQMEBQYAAAAAAAAAAAAAAAD9iQH9qQEiNSAQ/bUBIA4gDf0NBAUGBwAAAAAAAAAAAAAAAP2JAf2pASI2/a4BIA4gDf0NAwQFBgAAAAAAAAAAAAAAAP2JAf2pASAUIA39DQQFBgcAAAAAAAAAAAAAAAD9iQH9qQEiN/2uASAR/bUB/a4BIBL9rgFBBP2tASI4IBz9tQFBCP2tASAaIBf9tQFBCP2tAf2uAf2xASAd/a4BQQb9rAEgDf24ASAP/bYB/YYBICIgFCAN/Q0HCAkKAAAAAAAAAAAAAAAA/YkB/akBIjkgEP21ASAOIA39DQgJCgsAAAAAAAAAAAAAAAD9iQH9qQEiOv2uASAOIA39DQcICQoAAAAAAAAAAAAAAAD9iQH9qQEgFCAN/Q0ICQoLAAAAAAAAAAAAAAAA/YkB/akBIjv9rgEgEf21Af2uASAS/a4BQQT9rQEiPCAc/bUBQQj9rQEgJSAX/bUBQQj9rQH9rgH9sQEgHf2uAUEG/awBIA39uAEgD/22ASAfIBQgDf0NCwwNDgAAAAAAAAAAAAAAAP2JAf2pASIlIBD9tQEgDiAN/Q0MDQ4PAAAAAAAAAAAAAAAA/YkB/akBIj39rgEgDiAN/Q0LDA0OAAAAAAAAAAAAAAAA/YkB/akBIBQgDf0NDA0ODwAAAAAAAAAAAAAAAP2JAf2pASI+/a4BIBH9tQH9rgEgEv2uAUEE/a0BIj8gHP21AUEI/a0BIDAgF/21AUEI/a0B/a4B/bEBIB39rgFBBv2sASAN/bgBIA/9tgH9hgH9ZiIM/VgAAA8gAEH1AGogDP1YAAAOIABB7QBqIAz9WAAADSAAQeUAaiAM/VgAAAwgAEHdAGogDP1YAAALIABB1QBqIAz9WAAACiAAQc0AaiAM/VgAAAkgAEHFAGogDP1YAAAIIABBPWogDP1YAAAHIABBNWogDP1YAAAGIABBLWogDP1YAAAFIABBJWogDP1YAAAEIABBHWogDP1YAAADIABBFWogDP1YAAACIABBDWogDP1YAAABIABBBWogDP1YAAAAIABB/gBqIBYgNP0MGoEAABqBAAAagQAAGoEAACIW/bUBQQj9rQH9rgH9DOu6///ruv//67r//+u6//8iGv2uAUEG/awBIA39uAEgD/22ASAgIDggFv21AUEI/a0B/a4BIBr9rgFBBv2sASAN/bgBIA/9tgH9hgEgIiA8IBb9tQFBCP2tAf2uASAa/a4BQQb9rAEgDf24ASAP/bYBIB8gPyAW/bUBQQj9rQH9rgEgGv2uAUEG/awBIA39uAEgD/22Af2GAf1mIgz9WAAADyAAQfYAaiAM/VgAAA4gAEHuAGogDP1YAAANIABB5gBqIAz9WAAADCAAQd4AaiAM/VgAAAsgAEHWAGogDP1YAAAKIABBzgBqIAz9WAAACSAAQcYAaiAM/VgAAAggAEE+aiAM/VgAAAcgAEE2aiAM/VgAAAYgAEEuaiAM/VgAAAUgAEEmaiAM/VgAAAQgAEEeaiAM/VgAAAMgAEEWaiAM/VgAAAIgAEEOaiAM/VgAAAEgAEEGaiAM/VgAAAAgAEEIaiAeIA39DQEDBQcAAAAAAAAAAAAAAAD9iQH9qQEgFf21AUEI/a0BIiAgJiAQ/bUBIEP9AAAAIgz9iQH9qQH9rgEgJCAj/a4BIBH9tQH9rgEgEv2uAUEE/a0BIh8gGP21AUEI/a0B/a4BIBn9rgFBBv2sASAN/bgBIA/9tgEgHiAN/Q0JCw0PAAAAAAAAAAAAAAAA/YkB/akBIBX9tQFBCP2tASIeICkgEP21ASAMIA39DQQFBgcAAAAAAAAAAAAAAAD9iQH9qQH9rgEgKCAn/a4BIBH9tQH9rgEgEv2uAUEE/a0BIiMgGP21AUEI/a0B/a4BIBn9rgFBBv2sASAN/bgBIA/9tgH9hgEgISAN/Q0BAwUHAAAAAAAAAAAAAAAA/YkB/akBIBX9tQFBCP2tASIiICwgEP21ASAMIA39DQgJCgsAAAAAAAAAAAAAAAD9iQH9qQH9rgEgKyAq/a4BIBH9tQH9rgEgEv2uAUEE/a0BIiQgGP21AUEI/a0B/a4BIBn9rgFBBv2sASAN/bgBIA/9tgEgISAN/Q0JCw0PAAAAAAAAAAAAAAAA/YkB/akBIBX9tQFBCP2tASIVIC8gEP21ASAMIA39DQwNDg8AAAAAAAAAAAAAAAD9iQH9qQH9rgEgLiAt/a4BIBH9tQH9rgEgEv2uAUEE/a0BIiEgGP21AUEI/a0B/a4BIBn9rgFBBv2sASAN/bgBIA/9tgH9hgH9ZiIM/VgAAAAgAEEQaiAM/VgAAAEgAEEYaiAM/VgAAAIgAEEgaiAM/VgAAAMgAEEoaiAM/VgAAAQgAEEwaiAM/VgAAAUgAEE4aiAM/VgAAAYgAEFAayAM/VgAAAcgAEHIAGogDP1YAAAIIABB0ABqIAz9WAAACSAAQdgAaiAM/VgAAAogAEHgAGogDP1YAAALIABB6ABqIAz9WAAADCAAQfAAaiAM/VgAAA0gAEH4AGogDP1YAAAOIABBgAFqIkAgDP1YAAAPIABBgQFqICAgMyAQ/bUBIAH9AAAAIgz9iQH9qQH9rgEgMiAx/a4BIBH9tQH9rgEgEv2uAUEE/a0BIhggHP21AUEI/a0BIB8gF/21AUEI/a0B/a4B/bEBIB39rgFBBv2sASAN/bgBIA/9tgEgHiA3IBD9tQEgDCAN/Q0EBQYHAAAAAAAAAAAAAAAA/YkB/akB/a4BIDYgNf2uASAR/bUB/a4BIBL9rgFBBP2tASIZIBz9tQFBCP2tASAjIBf9tQFBCP2tAf2uAf2xASAd/a4BQQb9rAEgDf24ASAP/bYB/YYBICIgOyAQ/bUBIAwgDf0NCAkKCwAAAAAAAAAAAAAAAP2JAf2pAf2uASA6IDn9rgEgEf21Af2uASAS/a4BQQT9rQEiHyAc/bUBQQj9rQEgJCAX/bUBQQj9rQH9rgH9sQEgHf2uAUEG/awBIA39uAEgD/22ASAVID4gEP21ASAMIA39DQwNDg8AAAAAAAAAAAAAAAD9iQH9qQH9rgEgPSAl/a4BIBH9tQH9rgEgEv2uAUEE/a0BIhAgHP21AUEI/a0BICEgF/21AUEI/a0B/a4B/bEBIB39rgFBBv2sASAN/bgBIA/9tgH9hgH9ZiIM/VgAAA8gAEH5AGogDP1YAAAOIABB8QBqIAz9WAAADSAAQekAaiAM/VgAAAwgAEHhAGogDP1YAAALIABB2QBqIAz9WAAACiAAQdEAaiAM/VgAAAkgAEHJAGogDP1YAAAIIABBwQBqIAz9WAAAByAAQTlqIAz9WAAABiAAQTFqIAz9WAAABSAAQSlqIAz9WAAABCAAQSFqIAz9WAAAAyAAQRlqIAz9WAAAAiAAQRFqIAz9WAAAASAAQQlqIAz9WAAAACAAQQpqICAgGCAW/bUBQQj9rQH9rgEgGv2uAUEG/awBIA39uAEgD/22ASAeIBkgFv21AUEI/a0B/a4BIBr9rgFBBv2sASAN/bgBIA/9tgH9hgEgIiAfIBb9tQFBCP2tAf2uASAa/a4BQQb9rAEgDf24ASAP/bYBIBUgECAW/bUBQQj9rQH9rgEgGv2uAUEG/awBIA39uAEgD/22Af2GAf1mIgz9WAAAACAAQRJqIAz9WAAAASAAQRpqIAz9WAAAAiAAQSJqIAz9WAAAAyAAQSpqIAz9WAAABCAAQTJqIAz9WAAABSAAQTpqIAz9WAAABiAAQcIAaiAM/VgAAAcgAEHKAGogDP1YAAAIIABB0gBqIAz9WAAACSAAQdoAaiAM/VgAAAogAEHiAGogDP1YAAALIABB6gBqIAz9WAAADCAAQfIAaiAM/VgAAA0gAEH6AGogDP1YAAAOIABBggFqIAz9WAAADyABQRBqIQEgQ0EQaiFDIEZBIGohRiBKQRBqIUogA0EQaiEDIEAhACAbIQ0gDiEMIERBEGsiRA0ACyAU/RYPIUYgDP0WDyFAIBP9Fg8hSyAN/RYPIUMMCAtBAEEDIAFBiOzEABDqBwALQQBBAEGY7MQAEIwHAAtBAEEAQajsxAAQjAcAC0EAQQBBuOzEABCMBwALQQBBAEHI7MQAEIwHAAtBAEEAQdjsxAAQjAcAC0EEQQNBA0G47cQAEOoHAAsgBCFJIAUhTyAGIVYgByFOIAghSCAJIUIgCyFBIAohVSBSIVggRyFXIFEhUCBFIQILIEhBAWohRCBJQQFqIUpBACEDQQAhAANAIFBFIE9BAklyIE5BAkkgQkECSXJyIEFBAU1yDQEgQ0H/AXEhASADIFdqIkhB/wEgAi0AAEGFlQFsQQh2IkkgACBVaiJTQQFqLQAAIkMgS0H/AXEiTEEJbGogASAAIERqLQAAIktqQQNsakEIakEEdiJNQaXMAWxBCHZqQZrvAGtBBnUiAUEAIAFBAEobIgEgAUH/AU4bOgAAIEhBAmpB/wEgSSAAIFZqIltBAWotAAAiASBGQf8BcSJcQQlsaiAAIEpqLQAAIkYgQEH/AXFqQQNsakEIakEEdiJAQZqCAmxBCHZqQZWKAWtBBnUiVEEAIFRBAEobIlQgVEH/AU4bOgAAIEhBAWpB/wEgSSBAQZMybEEIdiBNQYjoAGxBCHZqa0GExABqQQZ1IkBBACBAQQBKGyJAIEBB/wFOGzoAACBIQQZqQf8BIAJBAWotAABBhZUBbEEIdiJAIFstAAAgRkEJbGogASBcakEDbGpBCGpBBHYiSUGaggJsQQh2akGVigFrQQZ1Ik1BACBNQQBKGyJNIE1B/wFOGzoAACBIQQRqQf8BIEAgUy0AACBLQQlsaiBDIExqQQNsakEIakEEdiJTQaXMAWxBCHZqQZrvAGtBBnUiTEEAIExBAEobIkwgTEH/AU4bOgAAIEhBBWpB/wEgQCBJQZMybEEIdiBTQYjoAGxBCHZqa0GExABqQQZ1IkBBACBAQQBKGyJAIEBB/wFOGzoAACACQQJqIQIgUEECayFQIE9BAWshTyAAQQFqIQAgQUEBayFBIEJBAWshQiBOQQFrIU4gASFAIFggA0EIaiIDRw0ACwsCQAJAAkACQAJAIFkEQCAEIAVqQQFrIgJFDQEgBiAHakEBayIDRQ0CIAggCWpBAWsiAEUNAyAKIAtqQQFrIgRFDQQgWkEHcSIBQQJNDQUgAC0AACEFIEcgUmoiAEH/ASBFIFFqLQAAQYWVAWxBCHYiASADLQAAIgMgAi0AAEEMbGogA0EDbGpBCGpBBHYiAkGaggJsQQh2akGVigFrQQZ1IgNBACADQQBKGyIDIANB/wFOGzoAAiAAQf8BIAEgBC0AACIDIAVBDGxqIANBA2xqQQhqQQR2IgNBpcwBbEEIdmpBmu8Aa0EGdSIEQQAgBEEAShsiBCAEQf8BThs6AAAgAEH/ASABIAJBkzJsQQh2IANBiOgAbEEIdmprQYTEAGpBBnUiAEEAIABBAEobIgAgAEH/AU4bOgABCw8LQejsxAAQ3QkAC0H47MQAEN0JAAtBiO3EABDdCQALQZjtxAAQ3QkAC0EAQQMgAUGo7cQAEOoHAAvpJAMWfwN9AXsjAEHABWsiBiQAIAYgBDYCDCAGIAM2AgggBkHsAWogBRC1ASAGKALsASEFAkACQAJAAkAgBi0AiAIiB0ECRgRAIABBgICAgHg2AgAgACAFNgIEIANFIARBhAhJckUEQCAEEJsHCyACQYQISQ0BIAIQmwcMAQsgBkEkaiAGQYACaikCADcCACAGQS9qIAZBiwJqLQAAOgAAIAYgBv0AAvAB/QsCFCAGIAYvAIkCOwAtIAYgBzoALCAGIAU2AhAgBkHsAWogAiABIAZBDGpBACADQQFxGyAGQRBqELACAkACQAJAAkAgBigC7AFBAkYEQCAGKALwASEBIAZBADYCsAMgBkKAgICAEDcCqAMgBkGck8EANgL0BCAGQqCAgIAONwL4BCAGIAZBqANqNgLwBCABIAZB8ARqEK8EDQggBigCqAMhAiAGKAKsAyIFIAYoArADEOwIIQcgAgRAIAVBBGsoAgAiCEF4cSIKQQRBCCAIQQNxIggbIAJqSQ0IIAhBACAKIAJBJ2pLGw0HIAUQogILIABBgICAgHg2AgAgACAHNgIEIAEgASgCACgCABEDAAwDCyAGQTBqIAZB7AFqIgFBvAH8CgAAIAZBwAJqIAZByAFqIgMoAgA2AgAgBkG4AmogBkHAAWoiBCkCADcCACAGQccCaiAGQc8Bai0AADoAACAGIAb9AAKwAf0LAqgCIAYgBi8AzQE7AMUCIAZBADYCyAIgBiAGLQDMASICOgDEAiAGQQA2AqQCIAZCgICAgBA3ApwCIAZCATcClAIgBkIANwKMAiAGQoCAgIAQNwKEAiAGQgQ3AvwBIAZCADcC9AEgBkKAgICAwAA3AuwBIAYoAtQBIRUgBigC2AEhFiAGIAYoAmAiGzoA+AQgBiAWNgL0BCAGIBU2AvAEIAEgBkHwBGoQ6QEgAkECRwRAIAZBxQJqIQEgAyoCACEcIAQqAgAhHSAGKgLEASEeIAb9AAKwASEfIAYtAMQCQQJHBEAgBkHyBGogAUECai0AADoAACAGIAEvAAA7AfAECyABIAYvAfAEOwAAIAFBAmogBkHyBGotAAA6AAAgBiACQQFxOgDEAiAGIBw4AsACIAYgHjgCvAIgBiAdOAK4AiAGIB/9CwKoAgsgBkEANgKABCAGQoCAgIDAADcC+AMgBkEANgKMBCAGQoCAgIDAADcChAQgBkEANgKYBCAGQoCAgIDAADcCkAQgBkEANgKkBCAGQoCAgIDAADcCnAQgBkEANgKwBCAGQoCAgIDAADcCqAQgBkEANgK8BCAGQoCAgIDAADcCtAQgBkEANgLIBCAGQoCAgIDAADcCwAQgBkEANgLUBCAGQoCAgIDAADcCzAQgBkEANgLgBCAGQoCAgIAgNwLYBCAGQQA2AuwEIAZCgICAgMAANwLkBCAVRQRAQQQhF0EEIRhBBCEZQQQhAUEEIRIMAgtBBCESAkADQCAPQYCABCAVIA5rIgEgAUGAgARPGyIFQQNsIgxJBEAgDCAPayIBIAYoAvgDIA9rSwRAIAZB+ANqIA8gAUEEQQQQpAUgBigC/AMhEiAGKAKABCEPCyASIA9BAnRqIQQgAUECTwR/IAFBAnRBBGsiAgRAIARBACAC/AsACyABIA9qIgFBAWshDyASIAFBAnRqQQRrBSAEC0EANgIAIAYgD0EBaiIPNgKABCAGKAKMBCENCyAFIA1LBEAgBSANayIBIAYoAoQEIA1rSwRAIAZBhARqIA0gAUEEQQQQpAUgBigCjAQhDQsgBigCiAQiAiANQQJ0aiEEIAFBAk8EfyABQQJ0QQRrIgMEQCAEQQAgA/wLAAsgASANaiIBQQFrIQ0gAiABQQJ0akEEawUgBAtBADYCACAGIA1BAWoiDTYCjAQLIAYoApgEIgogDEkEQCAMIAprIgEgBigCkAQgCmtLBEAgBkGQBGogCiABQQRBBBCkBSAGKAKYBCEKCyAGKAKUBCICIApBAnRqIQQgAUECTwR/IAFBAnRBBGsiAwRAIARBACAD/AsACyABIApqIgFBAWshCiACIAFBAnRqQQRrBSAEC0EANgIAIAYgCkEBaiIKNgKYBAsgBigCpAQiCSAMSQRAIAwgCWsiASAGKAKcBCAJa0sEQCAGQZwEaiAJIAFBBEEEEKQFIAYoAqQEIQkLIAYoAqAEIgIgCUECdGohBCABQQJPBH8gAUECdEEEayIDBEAgBEEAIAP8CwALIAEgCWoiAUEBayEJIAIgAUECdGpBBGsFIAQLQQA2AgAgBiAJQQFqIgk2AqQECyAFQQJ0IhMgBigCsAQiB0sEQCATIAdrIgEgBigCqAQgB2tLBEAgBkGoBGogByABQQRBBBCkBSAGKAKwBCEHCyAGKAKsBCICIAdBAnRqIQQgAUECTwR/IAFBAnRBBGsiAwRAIARBACAD/AsACyABIAdqIgFBAWshByACIAFBAnRqQQRrBSAEC0EANgIAIAYgB0EBaiIHNgKwBAsCQAJAAkACQAJAAkACQAJAAkAgDCAPTQRAIAZBMGoiAiAOIAUgBigC/AMiEiAMEKIFIAUgDUsNASAGKAKIBCEBIAIgDiAFEMwDQwAAAEBDAACAPyAGLQDMAUEBcRshHEEAIQMgBigCkAEhBCAGKAKUASEIA0AgA0EEaiICIAhLDQMgAyATRg0EIAEgA2ogHCAELQADs0MAAH9DlZRDAAAAAJI4AgAgBEEQaiEEIAIiAyATRw0ACyAKIAxJDQQgBkEwaiICIA4gBSAGKAKUBCIZIAwQgQUgCSAMSQ0FIAIgDiAFIAYoAqAEIhggDBDGBCAHIBNJDQYgAiAOIAUgBigCrAQiFyATEPADQQQhEUEAIQRBACEIQQQhB0EAIQJBBCEJQQAhA0EEIQogFkUNCSAFQQlsIgMgBigCvAQiAksEQCADIAJrIgcgBigCtAQgAmtLBEAgBkG0BGogAiAHQQRBBBCkBSAGKAK8BCECCyAGKAK4BCIIIAJBAnRqIQogB0ECTwR/IAdBAnRBBGsiCQRAIApBACAJ/AsACyACIAdqIgdBAWshAiAIIAdBAnRqQQRrBSAKC0EANgIAIAYgAkEBaiICNgK8BAsgAiADSQ0HIAZBMGogDiAFIAYoArgEIgogAxD7ASAWQQFGBEBBACEIQQQhB0EAIQJBBCEJDAoLIAVBD2wiAiAGKALIBCIISwRAIAIgCGsiCSAGKALABCAIa0sEQCAGQcAEaiAIIAlBBEEEEKQFIAYoAsgEIQgLIAYoAsQEIgsgCEECdGohByAJQQJPBH8gCUECdEEEayIQBEAgB0EAIBD8CwALIAggCWoiB0EBayEIIAsgB0ECdGpBBGsFIAcLQQA2AgAgBiAIQQFqIgg2AsgECyACIAhNDQhBACACIAhBvOHBABDqBwALQQAgDCAPQZziwQAQ6gcAC0EAIAUgDUGM4sEAEOoHAAsgAyACIAhB7NHAABDqBwALIAUgBUHc0cAAEIwHAAtBACAMIApB/OHBABDqBwALQQAgDCAJQezhwQAQ6gcAC0EAIBMgB0Hc4cEAEOoHAAtBACADIAJBzOHBABDqBwALIAZBMGogDiAFIAYoAsQEIgkgAhDQASAWQQJNBEBBACEIQQQhBwwBCyAFQRVsIgggBigC1AQiB0sEQCAIIAdrIhAgBigCzAQgB2tLBEAgBkHMBGogByAQQQRBBBCkBSAGKALUBCEHCyAGKALQBCIUIAdBAnRqIQsgEEECTwR/IBBBAnRBBGsiGgRAIAtBACAa/AsACyAHIBBqIgtBAWshByAUIAtBAnRqQQRrBSALC0EANgIAIAYgB0EBaiIHNgLUBAsgByAITwRAIAZBMGogDiAFIAYoAtAEIgcgCBClAQwBC0EAIAggB0Gs4cEAEOoHAAsCQAJAIBtFBEBBAiEQDAELIAYoAuAEIgQgBUkEQCAFIARrIgsgBigC2AQgBGtLBEAgBkHYBGogBCALQQJBAhCkBSAGKALgBCEECyAGKALcBCIRIARBAXRqIRAgC0ECTwR/IAtBAXRBAmsiFARAIBBBACAU/AsACyAEIAtqIgtBAWshBCARIAtBAXRqQQJrBSAQC0EAOwEAIAYgBEEBaiIENgLgBAsgBCAFSQ0BIAZBMGogDiAFIAYoAtwEIhAgBRCSAyAGKALsBCIEIAVJBEAgBSAEayIRIAYoAuQEIARrSwRAIAZB5ARqIAQgEUEEQQQQpAUgBigC7AQhBAsgBigC6AQiFCAEQQJ0aiELIBFBAk8EfyARQQJ0QQRrIhoEQCALQQAgGvwLAAsgBCARaiILQQFrIQQgFCALQQJ0akEEawUgCwtBADYCACAGIARBAWoiBDYC7AQLIAQgBUkNAyAGQTBqIA4gBSAGKALoBCIRIAUQkwMgBSEECyAGIAQ2ArwFIAYgETYCuAUgBiAENgK0BSAGIBA2ArAFIAYgCDYCrAUgBiAHNgKoBSAGIAI2AqQFIAYgCTYCoAUgBiADNgKcBSAGIAo2ApgFIAYgEzYClAUgBiAXNgKQBSAGIAw2AowFIAYgGDYCiAUgBiAMNgKEBSAGIBk2AoAFIAYgBTYC/AQgBiABNgL4BCAGIAw2AvQEIAYgEjYC8AQgBkHsAWogDiAFIAZB8ARqEJMCIAUgDmoiDiAVTw0DDAELC0EAIAUgBEGc4cEAEOoHAAtBACAFIARBjOHBABDqBwALIAYoAuQEIgJFDQAgBigC6AQiA0EEaygCACIEQXhxIgUgAkECdCICQQRBCCAEQQNxIgQbakkNBSAEQQAgBSACQSdqSxsNBCADEKICCyAGKALYBCICBEAgBigC3AQiA0EEaygCACIEQXhxIgUgAkEBdCICQQRBCCAEQQNxIgQbakkNBSAEQQAgBSACQSdqSxsNBCADEKICCyAGKALMBCICBEAgBigC0AQiA0EEaygCACIEQXhxIgUgAkECdCICQQRBCCAEQQNxIgQbakkNBSAEQQAgBSACQSdqSxsNBCADEKICCyAGKALABCICBEAgBigCxAQiA0EEaygCACIEQXhxIgUgAkECdCICQQRBCCAEQQNxIgQbakkNBSAEQQAgBSACQSdqSxsNBCADEKICCyAGKAK0BCICBEAgBigCuAQiA0EEaygCACIEQXhxIgUgAkECdCICQQRBCCAEQQNxIgQbakkNBSAEQQAgBSACQSdqSxsNBCADEKICCyAGKAKoBCICBEAgF0EEaygCACIDQXhxIgQgAkECdCICQQRBCCADQQNxIgMbakkNBSADQQAgBCACQSdqSxsNBCAXEKICCyAGKAKcBCICBEAgGEEEaygCACIDQXhxIgQgAkECdCICQQRBCCADQQNxIgMbakkNBSADQQAgBCACQSdqSxsNBCAYEKICCyAGKAKQBCICBEAgGUEEaygCACIDQXhxIgQgAkECdCICQQRBCCADQQNxIgMbakkNBSADQQAgBCACQSdqSxsNBCAZEKICCyAGKAKEBCICBEAgAUEEaygCACIDQXhxIgQgAkECdCICQQRBCCADQQNxIgMbakkNBSADQQAgBCACQSdqSxsNBCABEKICCyAGKAL4AyIBBEAgEkEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNBSACQQAgAyABQSdqSxsNBCASEKICCyAGKALwASEBIAYoAvQBIQIgBigC7AEhAyAGQagDaiAGQfgBakHQAPwKAAAgA0GAgICAeEcNASAGQQA2AvgEIAZCgICAgBA3AvAEIAZBnJPBADYC8AEgBkKggICADjcC9AEgBiAGQfAEajYC7AEgASAGQewBahCvBA0FIAYoAvAEIQIgBigC9AQiAyAGKAL4BBDsCCEEIAIEQCADQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyACakkNBSAFQQAgByACQSdqSxsNBCADEKICCyAAQYCAgIB4NgIAIAAgBDYCBCABIAEoAgAoAgARAwAgBkEwahDAAiAGKAIMIQQgBigCCCEDCyADRSAEQYQISXINASAEEJsHDAELIAYoAsgCIQQgAEEMaiAGQagDakHQAPwKAAAgACAENgJkIAAgAjYCYCAAIAQ2AlwgACACNgIIIAAgATYCBCAAIAM2AgAgBkEwahDAAiAGKAIIRQ0AIAYoAgwiAEGECEkNACAAEJsHCyAGQcAFaiQADwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQaCexgBBNyAGQeQEakG0k8EAQdiexgAQ4AYAC5orAhx/AX4jAEHgAWsiAiQAIAJBIGogACAAKAIAKAIEEQEAIAIgAigCJCIJNgIsIAIgAigCICIENgIoAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkAgAS0ACkGAAXFFBEAgAiACQShqrUKAgICAsAGENwNoIAEoAgAgASgCBCACQgE3ApwBQQEhAyACQQE2ApQBIAJBoPjHADYCkAEgAiACQegAajYCmAEgAkGQAWoQwQMNByACQRhqIAIoAiggAigCLCgCGBEBAAJAAkAgAigCGCIFBEAgAigCHCEGIAEoAgBBp/DBAEEMIAEoAgQoAgwRAAANCiACQRBqIAUgBigCGBEBACACQcgAaq1CgICAgLABhCEeIAIoAhBBAEchB0EAIQMDQCACQQhqIAUgBigCGBEBACACKAIMIAIoAgghBCACIAY2AkwgAiAFNgJIIAJBADYCoAEgAkEBNgKUASACQczExAA2ApABIAJCBDcCmAEgASgCACABKAIEIAJBkAFqIgYQngkNAiACQQA6AHQgAiADNgJsIAIgBzYCaCACIAE2AnAgAkEBNgKUASACQaD4xwA2ApABIAJCATcCnAEgAiAeNwNYIAIgAkHYAGo2ApgBIAJB6ABqIAYQnwkNAiADQQFqIQMhBiAEIgUNAAsLAkAgACgCBCIFQQNHBEAgAEEEaiEADAELIAAgACgCACgCGBEEACIARQ0CIAAoAgAhBQtBACEDIAVBAkcNCSACQQA2AkQgAkKAgICAEDcCPCACQbTvwQA2AkwgAkKggICADjcCUCACIAJBPGo2AkgCQCAAKAIAQQFrDgIFAAQLAkACfwJAAkAgAC0AFEEDRgRAIAAoAgwhA0EAIQYMAQsgAiAAQQRqNgKQASACQZABaiEHIwBBIGsiCCQAAkACQAJAIABBFGoiBi0AACIJQQJPBEAgCUEDaw0BDAMLIAZBAjoAACAHKAIAIAdBADYCAARAIAlBAUcEQEH0uskALQAAIQRB9LrJAEEBOgAAIAggBDoAByAERQ0DIAhCADcCFCAIQoGAgIDAADcCDCAIQcCDyAA2AgggCEEHaiAIQQhqEPsHAAsjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQeCEyAA2AgggAEIENwIQIABBCGpB6ITIABCNCAALQaCEyAAQ3QkACyAIQQA2AhggCEEBNgIMIAhBmIPIADYCCCAIQgQ3AhAgCEEIakGQhMgAEI0IAAtB9LrJAEEAOgAAIAZBAzoAAAsgCEEgaiQAIAAoAgwhAyACKAJQQYCAgARxIgYNAQsgAyAAKAIQIgRJDQIgAyAEayEDIAAoAgggBEEMbGoMAQsgACgCCAshDyACQYCAgIB4NgJYIAJBkPrHACkDACIeNwJcIAIgBkEXdiIAOgBkIAIgADoAeCACQQA2AnQgAkGEjMgANgJwIAIgAkHIAGo2AmggAiACQdgAajYCbCADRQRAIB6nIQMgHkIgiKcMCAsgDyADQQxsaiEYIAJBmAFqIREgAkGXAWohGQNAAkAgDygCCCIERQRAIAJBADYCiAEgAiACQegAajYChAEgAkEDNgKQASACQQI2AtABIAJBhAFqIAJBkAFqIAJB0AFqQQAgAkEAIAIQ+AEgAigChAEiACAAKAIMQQFqNgIMRQ0BDA4LIA8oAgQiACAEQSxsaiEaA0AgAkEANgKAASACIAJB6ABqNgJ8AkACQAJAAkAgACgCIEGAgICAeEcEQCACQZABaiIEIAAoAiQiGyAAKAIoIhwQ+wJBAiETIAIoApABDQMgBCACKAKUASIIIAIoApgBIgdBpLbFAEEGEOEBAkACQCACKAKQAQRAIAIoAswBIQUgAigCyAEhBiACKALEASEJIAIoAsABIQQgAigCtAFBf0YNASACQYQBaiARIAQgCSAGIAVBABCCBAwCCwNAIAJB0AFqIAJBkAFqEJgCIAIoAtABIgRBAUYNAAsCQAJAIARBAWsOAhkBAAsgAiACKQLUATcCiAEgAkEBNgKEAQwCCyACQQA2AoQBDAELIAJBhAFqIBEgBCAJIAYgBUEBEIIECyACKAKEAUEBRw0CIAIoAogBIgRBBmoiBkUNAQJAIAYgB08EQCAGIAdHDQEMAwsgBiAIaiwAAEG/f0oNAgsgCCAHIAYgB0GstsUAELsJAAsgAkEDNgKQAQwDCyAHIAhqIQkgBiAIaiEDA0ACQCADIAlGDQACfyADLAAAIgxBAE4EQCAMQf8BcSEFIANBAWoMAQsgAy0AAUE/cSEGIAxBH3EhBSAMQV9NBEAgBUEGdCAGciEFIANBAmoMAQsgAy0AAkE/cSAGQQZ0ciEGIAxBcEkEQCAGIAVBDHRyIQUgA0EDagwBCyAFQRJ0QYCA8ABxIAMtAANBP3EgBkEGdHJyIgVBgIDEAEYNASADQQRqCyEDIAVBxwBrQXhLIAVBOmtBdk9yDQEMAgsLIARFDQECQCAEIAdPBEAgBCAHRg0CDAELIAQgCGosAABBv39MDQAgBCEHDAELIAggB0EAIARBvLbFABC7CQALAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgB0EDTwRAQfC1xQAgCEEDENsHRQ0BIAgvAABB2pwBRg0CIAdBA0YNByAIKAAAQd++6fIERw0HQXwhA0EEIQUgB0EFTw0DQQQhBwwFCyAHQQJHDQ0gCC8AAEHanAFHDQVBfiEDQQIhB0ECIQUMBAtBAyEFQX0hAyAHQQNGBEBBAyEHDAQLIAgsAANBv39KDQMgCCAHQQMgB0GUtsUAELsJAAsgCCwAAkG/f0wNAUECIQVBfiEDDAILIAgsAARBv39KDQEgCCAHQQQgB0H0tcUAELsJAAsgCCAHQQIgB0GEtsUAELsJAAsgBSAIaiIJIAMgB2oiBGohECAEIQMgCSEFAkADQCADBEAgA0EBayEDIAUsAAAgBUEBaiEFQQBODQEMAgsLIARFDQACfyAJLAAAIgNBAE4EQCADQf8BcSEDIAlBAWoMAQsgCS0AAUE/cSEGIANBH3EhBSADQV9NBEAgBUEGdCAGciEDIAlBAmoMAQsgCS0AAkE/cSAGQQZ0ciEGIANBcEkEQCAGIAVBDHRyIQMgCUEDagwBCyAFQRJ0QYCA8ABxIAktAANBP3EgBkEGdHJyIQMgCUEEagshCgJAIANBxQBGBEBBACEGDAELIANBgIDEAEYNAUEAIQYDQCADQTBrQQlLDQJBACEFAkADQAJAIANBMGsiDEEKTwRAIAUNAQwDCyAFrUIKfiIeQiCIpw0FIAogEEYgHqciAyAMaiIFIANJcg0FAn8gCiwAACINQQBOBEAgDUH/AXEhAyAKQQFqDAELIAotAAFBP3EhAyANQR9xIQwgDUFfTQRAIAxBBnQgA3IhAyAKQQJqDAELIAotAAJBP3EgA0EGdHIhAyANQXBJBEAgAyAMQQx0ciEDIApBA2oMAQsgDEESdEGAgPAAcSAKLQADQT9xIANBBnRyciEDIApBBGoLIQogA0GAgMQARw0BDAULCwNAIAogEEYNBAJ/IAosAAAiDUEATgRAIA1B/wFxIQMgCkEBagwBCyAKLQABQT9xIQMgDUEfcSEMIA1BX00EQCAMQQZ0IANyIQMgCkECagwBCyAKLQACQT9xIANBBnRyIQMgDUFwSQRAIAMgDEEMdHIhAyAKQQNqDAELIAxBEnRBgIDwAHEgCi0AA0E/cSADQQZ0cnIiA0GAgMQARg0FIApBBGoLIQogBUEBayIFDQALCyAGQQFqIQYgA0HFAEcNAAsLIBAgCmshDAwICyAHQQJLDQELQQIhByAILQAAQdIARg0BDAcLIAgvAABB36QBRgRAIAgsAAIiA0G/f0wNBCAIQQJqIQRBfiEFDAULIAgtAABB0gBHDQELIAgsAAEiA0G/f0wNASAIQQFqIQRBfyEFDAMLIAdBA0YNBEGKtcUAIAhBAxDbBw0EIAgsAAMiA0G/f0oEQCAIQQNqIQRBfSEFDAMLIAggB0EDIAdBkLXFABC7CQALIAggB0EBIAdBoLXFABC7CQALIAggB0ECIAdBsLXFABC7CQALIANBwQBrQf8BcUEZSw0BIAUgB2ohBkEAIQMDQCADIAZHBEAgAyAEaiADQQFqIQMsAABBAE4NAQwDCwsgEf0MAAAAAAAAAAAAAAAAAAAAAP0LAgAgAiAGNgKUASACIAQ2ApABAkAgAkGQAWpBABDMAUUEQCACKAKQASIFRQ0DIAIoApgBIgMgAi0AlAEgAi8AlQEgGS0AAEEQdHJBCHRyIgpPDQEgAyAFai0AAEHBAGtB/wFxQRpPDQEgAigCnAEhCSACQgA3AqABIAIgCTYCnAEgAiADNgKYASACIAo2ApQBIAIgBTYCkAEgAkGQAWpBABDMAQ0WIAIoApABIgVFDQMgAigCmAEhAyACKAKUASEKDAELDBULAkACQCADRQ0AIAMgCk8EQCADIApGDQEMAgsgAyAFaiwAAEG/f0wNAQsgCiADayEMIAMgBWohCkEAIQkMAQsgBSAKIAMgCkHQtcUAELsJAAsCfyAMRQRAQQAhFCAJIRUgBCEWIAYhFyAIIQ4gByELIAoMAQsgCi0AAEEuRw0BIAogDGohEEEuIQUgCiEDA0ACQAJ/AkAgBcBBAEgEQCADLQABQT9xIQ0gBUEfcSESIAVB/wFxIgVB3wFLDQEgEkEGdCANciEFIANBAmoMAgsgBUH/AXEhBSADQQFqDAELIAMtAAJBP3EgDUEGdHIhDSAFQfABSQRAIA0gEkEMdHIhBSADQQNqDAELIBJBEnRBgIDwAHEgAy0AA0E/cSANQQZ0cnIiBUGAgMQARg0BIANBBGoLIQMCQCAFQd///wBxQcEAa0EaSSAFQTBrQQpJciAFQSFrQQ9Jcg0AAkAgBUE6aw4nAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAAsgBUH7AGtBA0sNBAsgAyAQRg0AIAMtAAAhBQwBCwsgCSEVIAQhFiAGIRcgCCEOIAchCyAMIRQgCgshHUEBIRMLIAIgFDYCrAEgAiAdNgKoASACIAs2AqQBIAIgDjYCoAEgAiAXNgKcASACIBY2ApgBIAIgFTYClAEgAiAcNgK0ASACIBs2ArABIAIgEzYCkAELIAAoAhAiBEECRwRAIAIgACkCGDcC1AELIAIgBDYC0AEgAkH8AGogAkGQAWogAkHQAWogACgCACAAKAIEIAAoAgggACgCDBD4ASACKAJ8IgQgBCgCDEEBajYCDA0OIABBLGoiACAaRw0ACwsgGCAPQQxqIg9HDQALDAYLIAQgAyADQfSLyAAQ6gcAC0EBIQMMCAtBiPHBAEEYQaDxwQAQqwcACyAEIAEgCSgCDBECACEDDAYLIAJBPGpBzIvIAEEVEOIHDQcMBAsgAkE8akHhi8gAQRIQ4gdFDQMMBgsgAigCWCIARQ0CIABBgICAgHhHDQEgAi0AXCEDIAIoAmALIQYgA0H/AXFBA0cNASAGKAIAIQkgBkEEaigCACIEKAIAIgAEQCAJIAARAwALIAQoAgQiCwRAIAlBBGsoAgAiAEF4cSIEQQRBCCAAQQNxIgAbIAtqSQ0IIABBACAEIAtBJ2pLGw0JIAkQogILIAZBBGsoAgAiAEF4cSIEQRBBFCAAQQNxIgAbSQ0HIABBACAEQTRPGw0IIAYQogIMAQsgAigCXCAAQQEQogcLIAJBOGogAkHEAGooAgA2AgAgAiACKQI8NwMwAkACQCABKAIAQbPwwQBBAiABKAIEKAIMEQAADQACQAJAIAIoAjgiAEEQTwRAQbXwwQAgAigCNEEQENsHRQ0BCyACQQA2AqABIAJBATYClAEgAkHY8MEANgKQASACQgQ3ApgBIAEoAgAgASgCBCACQZABahCeCUUNAQwCCyACQTBqIgsoAgQhBAJAAkACQCALKAIIIgBBAU0EQCAAQQFHDQFBACEAIAtBADYCCCALKAIABH8gBAUgC0EAQQEQ+AUgCygCCCEAIAsoAgQLIABqQdMAOgAAIAsgAEEBajYCCAwDCyAELAABQb9/Sg0BC0Hc78EAQSpB4PDBABDrBwALIARB0wA6AAAgCyAANgIICyACKAI4IQALIAJBMGohDiACKAI0IQdBACELAkAgAEUNACAAIAdqIQQDQAJAIAQiAEEBayIELAAAIgZBAEgEQCAGQT9xAn8gAEECayIELQAAIgbAIglBQE4EQCAGQR9xDAELIAlBP3ECfyAAQQNrIgQtAAAiBsAiCUFATgRAIAZBD3EMAQsgCUE/cSAAQQRrIgQtAABBB3FBBnRyC0EGdHILQQZ0ciEGCwJAIAZBIEYgBkEJa0EFSXINACAGQYABSQ0BAkACQAJAAkAgBkEIdiIJQRZrDhsABQUFBQUFBQUFAQUFBQUFBQUFBQUFBQUFBQIDCyAGQYAtRg0DDAQLIAZB/wFxLQDEoUdBAnENAgwDCyAGQYDgAEcNAgwBCyAJDQEgBkH/AXEtAMShR0EBcUUNAQsgBCAHRw0BDAILCyAAIAdrIQsLAkACQCAOKAIIIgAgC08EQCALRSAAIAtNckUEQCAOKAIEIAtqLAAAQb9/TA0CCyAOIAs2AggLDAELQeSfxgBBMEHw8MEAEOsHAAsgAkEBNgKUASACQaD4xwA2ApABIAJCATcCnAEgAiAOrUKAgICAsAWENwNoIAIgAkHoAGo2ApgBIAEoAgAgASgCBCACQZABahCeCUUNAQsgAigCMCILBEAgAigCNCIEQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyALakkNByAAQQAgASALQSdqSxsNCCAEEKICC0EBIQMMAQsgAigCMCIABEAgAigCNCAAQQEQogcLQQAhAwsgAkHgAWokACADDwsCQCACKAJYIgRBgICAgHhHBEAgBEUNAiACKAJcIgNBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIARqSQ0FIABFIAEgBEEnak1yDQEMBgsgAi0AXEEDRw0BIAIoAmAiAygCACELIANBBGooAgAiASgCACIABEAgCyAAEQMACyABKAIEIgQEQCALQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyAEakkNBSAAQQAgASAEQSdqSxsNBiALEKICCyADQQRrKAIAIgBBeHEiAUEQQRQgAEEDcSIAG0kNBCAARQ0AIAFBNE8NBQsgAxCiAgtBoJ7GAEE3IAJB3wFqQczvwQBB2J7GABDgBgALAAtBqLTFAEE9IAJB3wFqQZi0xQBBwLXFABDgBgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC58jAhZ/AX0jAEGQBWsiBiQAIAYgBDYCDCAGIAM2AgggBkHsAWogBRC1ASAGKALsASEFAkACQAJAAkAgBi0AiAIiB0ECRgRAIABBgICAgHg2AgAgACAFNgIEIANFIARBhAhJckUEQCAEEJsHCyACQYQISQ0BIAIQmwcMAQsgBkEkaiAGQYACaikCADcCACAGQS9qIAZBiwJqLQAAOgAAIAYgBv0AAvAB/QsCFCAGIAYvAIkCOwAtIAYgBzoALCAGIAU2AhAgBkHsAWogAiABIAZBDGpBACADQQFxGyAGQRBqELACAkACQAJAAkAgBigC7AFBAkYEQCAGKALwASEBIAZBADYCsAMgBkKAgICAEDcCqAMgBkGck8EANgLcAyAGQqCAgIAONwLgAyAGIAZBqANqNgLYAyABIAZB2ANqEK8EDQggBigCqAMhAiAGKAKsAyIFIAYoArADEOwIIQcgAgRAIAVBBGsoAgAiCEF4cSIKQQRBCCAIQQNxIggbIAJqSQ0IIAhBACAKIAJBJ2pLGw0HIAUQogILIABBgICAgHg2AgAgACAHNgIEIAEgASgCACgCABEDAAwDCyAGQTBqIAZB7AFqIgFBvAH8CgAAIAZCgICAgCA3AogEIAZCAjcCgAQgBkIANwL4AyAGQoCAgIAgNwLwAyAGQgQ3AugDIAZCADcC4AMgBkKAgICAwAA3AtgDIAZCADcCkAQgBigC1AEhFSAGKALYASEWIAYgBigCYCIbOgD0ASAGIBY2AvABIAYgFTYC7AEgBkHYA2ogARCEAiAGQQA2AqAEIAZCgICAgMAANwKYBCAGQQA2AqwEIAZCgICAgMAANwKkBCAGQQA2ArgEIAZCgICAgMAANwKwBCAGQQA2AsQEIAZCgICAgMAANwK8BCAGQQA2AtAEIAZCgICAgMAANwLIBCAGQQA2AtwEIAZCgICAgMAANwLUBCAGQQA2AugEIAZCgICAgMAANwLgBCAGQQA2AvQEIAZCgICAgMAANwLsBCAGQQA2AoAFIAZCgICAgCA3AvgEIAZBADYCjAUgBkKAgICAwAA3AoQFIBVFBEBBBCEXQQQhGEEEIRlBBCEBQQQhEgwCC0EEIRICQANAIA9BgIAEIBUgDmsiASABQYCABE8bIgVBA2wiDEkEQCAMIA9rIgEgBigCmAQgD2tLBEAgBkGYBGogDyABQQRBBBCkBSAGKAKcBCESIAYoAqAEIQ8LIBIgD0ECdGohBCABQQJPBH8gAUECdEEEayICBEAgBEEAIAL8CwALIAEgD2oiAUEBayEPIBIgAUECdGpBBGsFIAQLQQA2AgAgBiAPQQFqIg82AqAEIAYoAqwEIQ0LIAUgDUsEQCAFIA1rIgEgBigCpAQgDWtLBEAgBkGkBGogDSABQQRBBBCkBSAGKAKsBCENCyAGKAKoBCICIA1BAnRqIQQgAUECTwR/IAFBAnRBBGsiAwRAIARBACAD/AsACyABIA1qIgFBAWshDSACIAFBAnRqQQRrBSAEC0EANgIAIAYgDUEBaiINNgKsBAsgBigCuAQiCiAMSQRAIAwgCmsiASAGKAKwBCAKa0sEQCAGQbAEaiAKIAFBBEEEEKQFIAYoArgEIQoLIAYoArQEIgIgCkECdGohBCABQQJPBH8gAUECdEEEayIDBEAgBEEAIAP8CwALIAEgCmoiAUEBayEKIAIgAUECdGpBBGsFIAQLQQA2AgAgBiAKQQFqIgo2ArgECyAGKALEBCIJIAxJBEAgDCAJayIBIAYoArwEIAlrSwRAIAZBvARqIAkgAUEEQQQQpAUgBigCxAQhCQsgBigCwAQiAiAJQQJ0aiEEIAFBAk8EfyABQQJ0QQRrIgMEQCAEQQAgA/wLAAsgASAJaiIBQQFrIQkgAiABQQJ0akEEawUgBAtBADYCACAGIAlBAWoiCTYCxAQLIAVBAnQiEyAGKALQBCIHSwRAIBMgB2siASAGKALIBCAHa0sEQCAGQcgEaiAHIAFBBEEEEKQFIAYoAtAEIQcLIAYoAswEIgIgB0ECdGohBCABQQJPBH8gAUECdEEEayIDBEAgBEEAIAP8CwALIAEgB2oiAUEBayEHIAIgAUECdGpBBGsFIAQLQQA2AgAgBiAHQQFqIgc2AtAECwJAAkACQAJAAkACQAJAAkACQCAMIA9NBEAgBkEwaiICIA4gBSAGKAKcBCISIAwQogUgBSANSw0BIAYoAqgEIQEgAiAOIAUQzANDAAAAQEMAAIA/IAYtAMwBQQFxGyEcQQAhAyAGKAKQASEEIAYoApQBIQgDQCADQQRqIgIgCEsNAyADIBNGDQQgASADaiAcIAQtAAOzQwAAf0OVlEMAAAAAkjgCACAEQRBqIQQgAiIDIBNHDQALIAogDEkNBCAGQTBqIgIgDiAFIAYoArQEIhkgDBCBBSAJIAxJDQUgAiAOIAUgBigCwAQiGCAMEMYEIAcgE0kNBiACIA4gBSAGKALMBCIXIBMQ8ANBBCERQQAhBEEAIQhBBCEHQQAhAkEEIQlBACEDQQQhCiAWRQ0JIAVBCWwiAyAGKALcBCICSwRAIAMgAmsiByAGKALUBCACa0sEQCAGQdQEaiACIAdBBEEEEKQFIAYoAtwEIQILIAYoAtgEIgggAkECdGohCiAHQQJPBH8gB0ECdEEEayIJBEAgCkEAIAn8CwALIAIgB2oiB0EBayECIAggB0ECdGpBBGsFIAoLQQA2AgAgBiACQQFqIgI2AtwECyACIANJDQcgBkEwaiAOIAUgBigC2AQiCiADEPsBIBZBAUYEQEEAIQhBBCEHQQAhAkEEIQkMCgsgBUEPbCICIAYoAugEIghLBEAgAiAIayIJIAYoAuAEIAhrSwRAIAZB4ARqIAggCUEEQQQQpAUgBigC6AQhCAsgBigC5AQiCyAIQQJ0aiEHIAlBAk8EfyAJQQJ0QQRrIhAEQCAHQQAgEPwLAAsgCCAJaiIHQQFrIQggCyAHQQJ0akEEawUgBwtBADYCACAGIAhBAWoiCDYC6AQLIAIgCE0NCEEAIAIgCEG84cEAEOoHAAtBACAMIA9BnOLBABDqBwALQQAgBSANQYziwQAQ6gcACyADIAIgCEHs0cAAEOoHAAsgBSAFQdzRwAAQjAcAC0EAIAwgCkH84cEAEOoHAAtBACAMIAlB7OHBABDqBwALQQAgEyAHQdzhwQAQ6gcAC0EAIAMgAkHM4cEAEOoHAAsgBkEwaiAOIAUgBigC5AQiCSACENABIBZBAk0EQEEAIQhBBCEHDAELIAVBFWwiCCAGKAL0BCIHSwRAIAggB2siECAGKALsBCAHa0sEQCAGQewEaiAHIBBBBEEEEKQFIAYoAvQEIQcLIAYoAvAEIhQgB0ECdGohCyAQQQJPBH8gEEECdEEEayIaBEAgC0EAIBr8CwALIAcgEGoiC0EBayEHIBQgC0ECdGpBBGsFIAsLQQA2AgAgBiAHQQFqIgc2AvQECyAHIAhPBEAgBkEwaiAOIAUgBigC8AQiByAIEKUBDAELQQAgCCAHQazhwQAQ6gcACwJAAkAgG0UEQEECIRAMAQsgBigCgAUiBCAFSQRAIAUgBGsiCyAGKAL4BCAEa0sEQCAGQfgEaiAEIAtBAkECEKQFIAYoAoAFIQQLIAYoAvwEIhEgBEEBdGohECALQQJPBH8gC0EBdEECayIUBEAgEEEAIBT8CwALIAQgC2oiC0EBayEEIBEgC0EBdGpBAmsFIBALQQA7AQAgBiAEQQFqIgQ2AoAFCyAEIAVJDQEgBkEwaiAOIAUgBigC/AQiECAFEJIDIAYoAowFIgQgBUkEQCAFIARrIhEgBigChAUgBGtLBEAgBkGEBWogBCARQQRBBBCkBSAGKAKMBSEECyAGKAKIBSIUIARBAnRqIQsgEUECTwR/IBFBAnRBBGsiGgRAIAtBACAa/AsACyAEIBFqIgtBAWshBCAUIAtBAnRqQQRrBSALC0EANgIAIAYgBEEBaiIENgKMBQsgBCAFSQ0DIAZBMGogDiAFIAYoAogFIhEgBRCTAyAFIQQLIAYgBDYCuAIgBiARNgK0AiAGIAQ2ArACIAYgEDYCrAIgBiAINgKoAiAGIAc2AqQCIAYgAjYCoAIgBiAJNgKcAiAGIAM2ApgCIAYgCjYClAIgBiATNgKQAiAGIBc2AowCIAYgDDYCiAIgBiAYNgKEAiAGIAw2AoACIAYgGTYC/AEgBiAFNgL4ASAGIAE2AvQBIAYgDDYC8AEgBiASNgLsASAGQdgDaiAOIAUgBkHsAWoQ4gEgBSAOaiIOIBVPDQMMAQsLQQAgBSAEQZzhwQAQ6gcAC0EAIAUgBEGM4cEAEOoHAAsgBigChAUiAkUNACAGKAKIBSIDQQRrKAIAIgRBeHEiBSACQQJ0IgJBBEEIIARBA3EiBBtqSQ0FIARBACAFIAJBJ2pLGw0EIAMQogILIAYoAvgEIgIEQCAGKAL8BCIDQQRrKAIAIgRBeHEiBSACQQF0IgJBBEEIIARBA3EiBBtqSQ0FIARBACAFIAJBJ2pLGw0EIAMQogILIAYoAuwEIgIEQCAGKALwBCIDQQRrKAIAIgRBeHEiBSACQQJ0IgJBBEEIIARBA3EiBBtqSQ0FIARBACAFIAJBJ2pLGw0EIAMQogILIAYoAuAEIgIEQCAGKALkBCIDQQRrKAIAIgRBeHEiBSACQQJ0IgJBBEEIIARBA3EiBBtqSQ0FIARBACAFIAJBJ2pLGw0EIAMQogILIAYoAtQEIgIEQCAGKALYBCIDQQRrKAIAIgRBeHEiBSACQQJ0IgJBBEEIIARBA3EiBBtqSQ0FIARBACAFIAJBJ2pLGw0EIAMQogILIAYoAsgEIgIEQCAXQQRrKAIAIgNBeHEiBCACQQJ0IgJBBEEIIANBA3EiAxtqSQ0FIANBACAEIAJBJ2pLGw0EIBcQogILIAYoArwEIgIEQCAYQQRrKAIAIgNBeHEiBCACQQJ0IgJBBEEIIANBA3EiAxtqSQ0FIANBACAEIAJBJ2pLGw0EIBgQogILIAYoArAEIgIEQCAZQQRrKAIAIgNBeHEiBCACQQJ0IgJBBEEIIANBA3EiAxtqSQ0FIANBACAEIAJBJ2pLGw0EIBkQogILIAYoAqQEIgIEQCABQQRrKAIAIgNBeHEiBCACQQJ0IgJBBEEIIANBA3EiAxtqSQ0FIANBACAEIAJBJ2pLGw0EIAEQogILIAYoApgEIgEEQCASQQRrKAIAIgJBeHEiAyABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0FIAJBACADIAFBJ2pLGw0EIBIQogILIAZBuANqIgQgBkHkA2oiAUEQav0AAgD9CwMAIAZByANqIgUgAUEgav0AAgD9CwMAIAYgAf0AAgD9CwOoAyAGKALcAyEBIAYoAtgDIgdBgICAgHhHDQEgBkEANgLgAyAGQoCAgIAQNwLYAyAGQZyTwQA2AvABIAZCoICAgA43AvQBIAYgBkHYA2o2AuwBIAEgBkHsAWoQrwQNBSAGKALYAyECIAYoAtwDIgMgBigC4AMQ7AghBCACBEAgA0EEaygCACIFQXhxIgdBBEEIIAVBA3EiBRsgAmpJDQUgBUEAIAcgAkEnaksbDQQgAxCiAgsgAEGAgICAeDYCACAAIAQ2AgQgASABKAIAKAIAEQMAIAZBMGoQwAIgBigCDCEEIAYoAgghAwsgA0UgBEGECElyDQEgBBCbBwwBCyAGKALgAyECIAYoApQEIQMgACAG/QADqAP9CwIMIABBLGogBf0AAwD9CwIAIABBHGogBP0AAwD9CwIAIAAgAzYCRCAAIAI2AkAgACADNgI8IAAgAjYCCCAAIAE2AgQgACAHNgIAIAZBMGoQwAIgBigCCEUNACAGKAIMIgBBhAhJDQAgABCbBwsgBkGQBWokAA8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GgnsYAQTcgBkGEBWpBtJPBAEHYnsYAEOAGAAvsWQNIfwN+AnsjAEGQBGsiBCQAIAEoAgAhAiABKAIoIQUgBEEANgJYIARBATYCTCAEQbDdxwA2AkggBEIENwJQIARByABqEJUHIQMCQAJAAkACQCAFQYCAgIB4RgRAIABBgICAgHg2AgAgACADNgIEIAEoArABIQIgASgCtAEiEgRAIAIhAANAIABBKGooAgAiAwRAIABBLGooAgAiBUEEaygCACIGQXhxIgpBBEEIIAZBA3EiBhsgA2pJDQYgBkEAIAogA0EnaksbDQcgBRCiAgsgABC/BCAAQThqIQAgEkEBayISDQALCyABKAKsASIABEAgAkEEaygCACIDQXhxIgUgAEE4bCIAQQRBCCADQQNxIgMbakkNBCADQQAgBSAAQSdqSxsNBSACEKICCyABKAKYASIABEAgASgCnAEiAkEEaygCACIDQXhxIgVBBEEIIANBA3EiAxsgAGpJDQQgA0EAIAUgAEEnaksbDQUgAhCiAgsgAUHwAGoQvwQMAQsgBEE0aiABQSRqKAIANgIAIARBJGogAUEUav0AAgD9CwIAIARBxABqIAFBNGooAgA2AgAgBCABKQIsNwI8IAQgAf0AAgT9CwIUIAMgAygCACgCABEDACAEIAU2AjggBCACNgIQIARB8ABqIAFBmAFq/QADAP0LAwAgBEHYAGogAUGAAWr9AAMA/QsDACAEQegAaiIGIAFBkAFqKQMAIko3AwAgBCAB/QADcP0LA0ggBCBKpyIjQf8BakEIdiIDNgKEAQJAAkACQAJAAkACQAJAAkACQAJAIAMgBCgCME0EQAJ/QQAgBCgCHEUNABogBCkDICAEKQMoQbjdxwBBBRCVBCFKIAQoAhQiAyBKp3EhDyBKQhmIQv8Ag0KBgoSIkKDAgAF+IUwDQAJAIAIgD2opAAAiSyBMhSJKQn+FIEpCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiSlBFBEADQCACIEp6p0EDdiAPaiADcUFsbGoiBUEMaygCAEEFRgRAQbjdxwAgBUEQaygCAEEFENsHRQ0DCyBKQgF9IEqDIkpQRQ0ACwtBACBLIEtCAYaDQoCBgoSIkKDAgH+DUEUNAhogDyAaQQhqIhpqIANxIQ8MAQsLIAVBFGsLIQIgBEEANgKoAyAEQQE2ApwDIARB1N3HADYCmAMgBEIENwKgAyAEQZgDahCVByEPIAJFDQYgDyAPKAIAKAIAEQMAIAItABAhJCACKAIMISUgBEEQaiICQdzdxwBBBRC5BSEDIARBADYCqAMgBEEBNgKcAyAEQfjdxwA2ApgDIARCBDcCoAMgBEGYA2oQlQchDyADRQ0GIA8gDygCACgCABEDACADLQAQISYgAygCDCEnIAJBgN7HAEEFELkFIQMgBEEANgKoAyAEQQE2ApwDIARBnN7HADYCmAMgBEIENwKgAyAEQZgDahCVByEPIANFDQYgDyAPKAIAKAIAEQMAIAMtABAhKCADKAIMISkgAkGk3scAQQUQuQUhAyAEQQA2AqgDIARBATYCnAMgBEHA3scANgKYAyAEQgQ3AqADIARBmANqEJUHIQ8gA0UNBiAPIA8oAgAoAgARAwAgAy0AECEqIAMoAgwhKyACQcjexwBBBRC5BSEDIARBADYCqAMgBEEBNgKcAyAEQeTexwA2ApgDIARCBDcCoAMgBEGYA2oQlQchDyADRQ0GIA8gDygCACgCABEDACADLQAQISwgAygCDCEtIAJB7N7HAEEFELkFIQMgBEEANgKoAyAEQQE2ApwDIARBiN/HADYCmAMgBEIENwKgAyAEQZgDahCVByEPIANFDQYgDyAPKAIAKAIAEQMAIAMtABAhLiADKAIMIS8gAkGQ38cAQQsQuQUhAyAEQQA2AqgDIARBATYCnAMgBEG438cANgKYAyAEQgQ3AqADIARBmANqEJUHIQ8gA0UNBiAPIA8oAgAoAgARAwAgAy0AECEwIAMoAgwhMSACQcDfxwBBCxC5BSEDIARBADYCqAMgBEEBNgKcAyAEQejfxwA2ApgDIARCBDcCoAMgBEGYA2oQlQchDyADRQ0GIA8gDygCACgCABEDACADLQAQITIgAygCDCEzIAJB8N/HAEELELkFIQMgBEEANgKoAyAEQQE2ApwDIARBmODHADYCmAMgBEIENwKgAyAEQZgDahCVByEPIANFDQYgDyAPKAIAKAIAEQMAIAMtABAhNCADKAIMITUgAkGg4McAQQsQuQUhAyAEQQA2AqgDIARBATYCnAMgBEHI4McANgKYAyAEQgQ3AqADIARBmANqEJUHIQ8gA0UNBiAPIA8oAgAoAgARAwAgAy0AECE2IAMoAgwhNyACQdDgxwBBCxC5BSEDIARBADYCqAMgBEEBNgKcAyAEQfjgxwA2ApgDIARCBDcCoAMgBEGYA2oQlQchDyADRQ0GIA8gDygCACgCABEDACADLQAQITggAygCDCE5IAJBgOHHAEELELkFIQMgBEEANgKoAyAEQQE2ApwDIARBqOHHADYCmAMgBEIENwKgAyAEQZgDahCVByEPIANFDQYgDyAPKAIAKAIAEQMAIAMtABAhOiADKAIMITtBCCEeQQghHyACQbDhxwBBBRC5BSICBEAgAigCDCE8IAItABAhHwsgBEEQakG14ccAQQUQuQUiAgRAIAIoAgwhPSACLQAQIR4LQQghGkEIISAgBEEQakG64ccAQQUQuQUiAgRAIAIoAgwhPiACLQAQISALIARBEGpBv+HHAEEFELkFIgIEQCACKAIMIT8gAi0AECEaC0EIISFBCCEiIARBEGpBxOHHAEEFELkFIgIEQCACKAIMIUAgAi0AECEiCyAEQRBqQcnhxwBBBRC5BSICBEAgAigCDCFBIAItABAhIQsgBEHIAGoiAkHO4ccAQQ8QuQUhAyAEQQA2AqgDIARBATYCnAMgBEGA4scANgKYAyAEQgQ3AqADIARBmANqEJUHIRIgA0UNBSASIBIoAgAoAgARAwAgAy0AECFCIAMoAgwhQyACQYjixwBBDxC5BSEDIARBADYCqAMgBEEBNgKcAyAEQbjixwA2ApgDIARCBDcCoAMgBEGYA2oQlQchEiADRQ0FIBIgEigCACgCABEDACADLQAQIUQgAygCDCFFIAJBwOLHAEEMELkFIQMgBEEANgKoAyAEQQE2ApwDIARB7OLHADYCmAMgBEIENwKgAyAEQZgDahCVByESIANFDQUgEiASKAIAKAIAEQMAIAMtABAhRiADKAIMIUcgAkH04scAQQwQuQUhAiAEQQA2AqgDIARBATYCnAMgBEGg48cANgKYAyAEQgQ3AqADIARBmANqEJUHIRIgAkUNBSASIBIoAgAoAgARAwAgAUE4aiEcIAItABAhSCACKAIMIUkgASgCYEGAgICAeEYNByABKAJYICNHDQggBEHUAWqtQoCAgIAQhCFKQQAhEgNAAkAgBCASNgLUASAEQQE2ApwDIARBiNDHADYCmAMgBEIBNwKkAyAEIEo3A9gBIAQgBEHYAWo2AqADIARB0ANqIARBmANqELEGIBwgBCgC1AMiAyAEKALYAxC5BSAEKALQAyECRQ0AIAIEQCADIAJBARCiBwsgBCgC1AFBAWohEgwBCwsgAgRAIAMgAkEBEKIHCyAEKALUASIDIQ8CQAJAAkACQAJAAkAgAw4ZBQEBAQEBAQEBAgEBAQEBAQEBAQEBAQEBAwALIANBLUYNAwsgBEEBNgKcAyAEQdzXxwA2ApgDIARCATcCpAMgBCBKNwPQAyAEIARB0ANqNgKgAyAEQeQBaiICIARBmANqELEGIAIQkAchAiAAQYCAgIB4NgIAIAAgAjYCBAwOC0EBIQ8MAgtBAiEPDAELQQMhDwsgBEHwAWohCkEAIQYCQAJAAkACQAJAIANB/////wFLDQAgA0EDdCICQf3///8HTw0AAkAgAkUEQEEEIQUMAQsgAyEGIAIQcSIFRQ0CCyADQQJJDQIgA0EBayIJQQdxIQcgBSECIANBAmtBB08EQCAJQXhxIQkDQCACQQA2AgAgAkE8akEBOgAAIAJBOGpBADYCACACQTRqQQE6AAAgAkEwakEANgIAIAJBLGpBAToAACACQShqQQA2AgAgAkEkakEBOgAAIAJBIGpBADYCACACQRxqQQE6AAAgAkEYakEANgIAIAJBFGpBAToAACACQRBqQQA2AgAgAkEMakEBOgAAIAJBCGpBADYCACACQQRqQQE6AAAgAkFAayECIAlBCGsiCQ0ACwsgB0UNAwNAIAJBADYCACACQQRqQQE6AAAgAkEIaiECIAdBAWsiBw0ACwwDC0Go48cAEP8HCwALIAUhAiADRQ0BCyACQQE6AAQgAkEANgIACyAKIAM2AgggCiAFNgIEIAogBjYCACABKAI4IgIpAwAhSiABKAI8IQMgBCABKAJENgKwAyAEIAI2AqgDIAQgAiADakEBajYCpAMgBCACQQhqNgKgAyAEIEpCf4VCgIGChIiQoMCAf4M3A5gDIAQoAvQBIQggBCgC+AEhCgJAA0ACQCAEQQhqIQZBACECIARBmANqIgMoAhgiBwR/AkAgAykDACJKUEUEQCADKAIQIQIMAQsgAygCECECIAMoAgghBQNAIAJBoAFrIQIgBSkDACAFQQhqIQVCgIGChIiQoMCAf4MiSkKAgYKEiJCgwIB/UQ0ACyADIAI2AhAgAyAFNgIIIEpCgIGChIiQoMCAf4UhSgsgAyAHQQFrNgIYIAMgSkIBfSBKgzcDACACIEp6p0EDdkFsbGoiA0EIayECIANBFGsFQQALIQMgBiACNgIEIAYgAzYCACAEKAIIIgJFDQAgBCgCDCEHIAIoAggiA0EHSQ0BQYDQxwAgAigCBCICQQcQ2wcNASAEQdADaiEGIAJBB2ohBQJAAkACQAJAAkACQAJAAkACQAJAIANBB2siAw4CAAECCyAGQQA6AAEMBwtBASECIAUtAABBK2sOAwQBBAELIAUtAABBK0YEQCADQQFrIQIgBUEBaiEFIANBCkkNAQwCCyADIgJBCU8NAQtBACEDA0AgBS0AAEEwayIJQQlLDQMgBUEBaiEFIAkgA0EKbGohAyACQQFrIgINAAsMAQtBACEDA0AgAkUNASAFLQAAQTBrIglBCUsNAiADrUIKfiJKQiCIpw0DIAVBAWohBSACQQFrIQIgCSBKp2oiAyAJTw0ACyAGQQI6AAEMAwsgBiADNgIEIAZBADoAAAwDCyAGQQE6AAEgBkEBOgAADAILIAZBAjoAAQsgBkEBOgAACyAELQDQAyAEKALUAyICIAQoAtQBT3INASACIApPDQIgBygCACEDIAggAkEDdGoiAiAHLQAEOgAEIAIgAzYCAAwBCwsgBEKAgICAMDcCqAJBACESIARBADYCkAIgBEEANgL8ASAEIAQoAtQBQQNuNgLYASAEIARB2AFqIhs2AqQCIARB3ANqIRYjAEEQayIMJAAgBEH8AWoiBygCLCECIAcoAgghBiAHKAIEIQogBygCACEDAkACQAJAAkACQEF/An8CQAJ/AkACQCAHKAIoIhcEQCAHKAIwIQUgA0EBcQRAIAYgCksNAyAHQQA2AgALIAIgBU8NASAHIAJBAWoiAzYCLCAHIBcoAgA2AhAgB0EBNgIAQQMhBiAHQQM2AgggByACNgIMQQAMAwsgA0EBcUUNACAGIApLDQEgB0EANgIACwJAIAcoAhRBAUcNACAHKAIYIgMgBygCHE8NAEEBIQUgByADQQFqNgIYIAcoAiAgBygCJCADbGohCSACIQNBACECDAMLIBZBADYCCCAWQoCAgIDAADcCAAwICyACIQMgCgshBUEBIQIgByAFQQFqIgo2AgQgBiAKayIJQQAgBiAJTxshECAHKAIMIAcoAhAgBWxqIQlBACAHKAIUIgVBAUcNARoLIAcoAhwiCCAHKAIYayILQQAgCCALTxsLIBBqIgggCCAQSRtBAWoiCEF/IAgbIghB/////wNLDQBBBCAIIAhBBE0bIghBAnQiC0H9////B08NACAHKAIwIRggCxBxIhFFDQEgESAJNgIAIAxBATYCDCAMIBE2AgggDCAINgIEIAcoAiQhGSAHKAIgIR0gBygCHCEVIAcoAhghCSAHKAIQIRQgBygCDCELIBdFBEAgBUUNA0EEIQ1BASEDIAYhByAKIRMgAiEIA0ACfwJAAkAgCEEBcUUEQCACIQUMAQtBACEFIAcgE0sNAQsgCSAVTw0HIAkgGWwgHWohECAJQQFqIQkgBSECQQAMAQsgEyAUbCALaiEQIBNBAWoiCiETQQELIQggDCgCBCADRgRAIAxBBGogA0F/IAYgCmsiBUEAIAUgBk0bIgUgFSAJayIIQQAgCCAVTRsiCGoiDiAFIA5LGyAIIAJBAXEiBRtBAWoiCEF/IAgbQQRBBBCkBSAKIBMgBRshEyAMKAIIIREgAiEIIAYgByAFGyEHCyANIBFqIBA2AgAgDCADQQFqIgM2AgwgDUEEaiENDAALAAsgBUUEQEEEIQhBASENIAYhBSACIQkDQCAJQQFxRSAFIApNcgR/IAMgGE8NBkEBIQIgFygCACEUQQMhBiADIQsgA0EBaiEDQQMhBUEABSAKCyEHQQEhCSAHQQFqIQogDCgCBCANRgRAIAxBBGogDSAGIAprIglBACAGIAlPG0EBakEBIAJBAXEiCRtBBEEEEKQFIAYgBSAJGyEFIAwoAgghESACIQkLIAggEWogByAUbCALajYCACAMIA1BAWoiDTYCDCAIQQRqIQgMAAsAC0EEIQhBASENIAYhDiAKIRAgAiEFA0ACfwJAAkACQCAFQQFxRQRAIAIhBwwBC0EAIQcgDiAQSw0BCyADIBhPDQFBASECIBcoAgAhFEEAIRBBAyEGIAMhCyADQQFqIQNBAyEOCyAQIBRsIAtqIRMgEEEBaiIKIRBBAQwBCyAJIBVPDQUgCSAZbCAdaiETIAlBAWohCSAHIQJBAAshBSAMKAIEIA1GBEAgDEEEaiANQX8gBiAKayIFQQAgBSAGTRsiBSAVIAlrIgdBACAHIBVNGyIHaiIRIAUgEUsbIAcgAkEBcSIFG0EBaiIHQX8gBxtBBEEEEKQFIAogECAFGyEQIAYgDiAFGyEOIAwoAgghESACIQULIAggEWogEzYCACAMIA1BAWoiDTYCDCAIQQRqIQgMAAsAC0Hg/8YAEP8HCwALIAJFDQAgBiAKayICQQAgAiAGTRshBSAKQQFqIQcgCyAKIBRsaiENQQQhCEEAIQMDQCADIAVGDQEgA0EBaiICIAwoAgRGBEAgDEEEaiACIAYgAyAHamsiCkEAIAYgCk8bQQFqIgpBfyAKG0EEQQQQpAUgDCgCCCERCyAIIBFqIA02AgAgDCADQQJqNgIMIA0gFGohDSAIQQRqIQggAiEDDAALAAsgFiAMKQIENwIAIBZBCGogDEEMaigCADYCAAsgDEEQaiQAIARCgICAgNAANwLcAiAEQQA2AsQCIARBADYCsAIgBCAbNgLYAiAEQegDaiEVQQAhCyMAQRBrIg4kACAEQbACaiIGKAIsIQIgBigCCCEKIAYoAgQhByAGKAIAIQMCQAJAAkACQAJAQX8CfwJAAn8CQAJAIAYoAigiFgRAIAYoAjAhBSADQQFxBEAgByAKSQ0DIAZBADYCAAsgAiAFTw0BIAYgAkEBaiIDNgIsIAYgFigCADYCECAGQQE2AgBBAyEKIAZBAzYCCCAGIAI2AgxBAAwDCyADQQFxRQ0AIAcgCkkNASAGQQA2AgALAkAgBigCFEEBRw0AIAYoAhgiAyAGKAIcTw0AQQEhBSAGIANBAWo2AhggBigCICAGKAIkIANsakEDaiEJIAIhA0EAIQIMAwsgFUEANgIIIBVCgICAgMAANwIADAgLIAIhAyAHCyEFQQEhAiAGIAVBAWoiBzYCBCAKIAdrIglBACAJIApNGyELIAYoAgwgBigCECAFbGpBA2ohCUEAIAYoAhQiBUEBRw0BGgsgBigCHCIIIAYoAhhrIhBBACAIIBBPGwsgC2oiCCAIIAtJG0EBaiIIQX8gCBsiCEH/////A0sNAEEEIAggCEEETRsiCEECdCILQf3///8HTw0AIAYoAjAhFyALEHEiDUUNASANIAk2AgAgDkEBNgIMIA4gDTYCCCAOIAg2AgQgBigCIEEDaiEYIAYoAiQhGSAGKAIcIRQgBigCGCEJIAYoAhAhESAGKAIMIQYgFkUEQCAFRQ0DIAZBA2ohE0EEIQxBASEDIAohECAHIQUgAiEIA0ACfwJAAkAgCEEBcUUEQCACIQYMAQtBACEGIAUgEEkNAQsgCSAUTw0HIBggCSAZbGohCyAJQQFqIQkgBiECQQAMAQsgEyAFIBFsaiELIAVBAWoiByEFQQELIQggDigCBCADRgRAIA5BBGogA0F/IAogB2siBkEAIAYgCk0bIgYgFCAJayIIQQAgCCAUTRsiCGoiDSAGIA1LGyAIIAJBAXEiBhtBAWoiCEF/IAgbQQRBBBCkBSAKIBAgBhshECAOKAIIIQ0gAiEIIAcgBSAGGyEFCyAMIA1qIAs2AgAgDiADQQFqIgM2AgwgDEEEaiEMDAALAAsgBUUEQEEEIQhBASEMIAohBSACIQkDQCAJQQFxRSAFIAdNcgR/IAMgF08NBkEBIQIgFigCACERQQMhCiADIgZBAWohA0EDIQVBAAUgBwshC0EBIQkgC0EBaiEHIA4oAgQgDEYEQCAOQQRqIAwgCiAHayIJQQAgCSAKTRtBAWpBASACQQFxIgkbQQRBBBCkBSAKIAUgCRshBSAOKAIIIQ0gAiEJCyAIIA1qIAYgCyARbGpBA2o2AgAgDiAMQQFqIgw2AgwgCEEEaiEIDAALAAtBBCEIQQEhDCAKIRMgByELIAIhBQNAAn8CQAJAAkAgBUEBcUUEQCACIQUMAQtBACEFIAsgE0kNAQsgAyAXTw0BQQEhAiAWKAIAIRFBACELQQMhCiADIgZBAWohA0EDIRMLIAYgCyARbGpBA2ohECALQQFqIgchC0EBDAELIAkgFE8NBSAYIAkgGWxqIRAgCUEBaiEJIAUhAkEACyEFIA4oAgQgDEYEQCAOQQRqIAxBfyAKIAdrIgVBACAFIApNGyIFIBQgCWsiDUEAIA0gFE0bIg1qIh0gBSAdSxsgDSACQQFxIgUbQQFqIg1BfyANG0EEQQQQpAUgByALIAUbIQsgCiATIAUbIRMgDigCCCENIAIhBQsgCCANaiAQNgIAIA4gDEEBaiIMNgIMIAhBBGohCAwACwALQeD/xgAQ/wcLAAsgAkUNACAKIAdrIgJBACACIApNGyEFIAdBAWohCSAGIAcgEWxqQQNqIQxBBCEIQQAhAwNAIAMgBUYNASADQQFqIgIgDigCBEYEQCAOQQRqIAIgCiADIAlqayIGQQAgBiAKTRtBAWoiBkF/IAYbQQRBBBCkBSAOKAIIIQ0LIAggDWogDDYCACAOIANBAmo2AgwgDCARaiEMIAhBBGohCCACIQMMAAsACyAVIA4pAgQ3AgAgFUEIaiAOQQxqKAIANgIACyAOQRBqJAAgBEKAgICA8AA3ApADIARBADYC+AIgBEEANgLkAiAEIBs2AowDIARB9ANqIRVBACELIwBBEGsiDiQAIARB5AJqIgYoAiwhAiAGKAIIIQogBigCBCEHIAYoAgAhAwJAAkACQAJAAkBBfwJ/AkACfwJAAkAgBigCKCIWBEAgBigCMCEFIANBAXEEQCAHIApJDQMgBkEANgIACyACIAVPDQEgBiACQQFqIgM2AiwgBiAWKAIANgIQIAZBATYCAEEDIQogBkEDNgIIIAYgAjYCDEEADAMLIANBAXFFDQAgByAKSQ0BIAZBADYCAAsCQCAGKAIUQQFHDQAgBigCGCIDIAYoAhxPDQBBASEFIAYgA0EBajYCGCAGKAIgIAYoAiQgA2xqQQhqIQkgAiEDQQAhAgwDCyAVQQA2AgggFUKAgICAwAA3AgAMCAsgAiEDIAcLIQVBASECIAYgBUEBaiIHNgIEIAogB2siCUEAIAkgCk0bIQsgBigCDCAGKAIQIAVsakEIaiEJQQAgBigCFCIFQQFHDQEaCyAGKAIcIgggBigCGGsiEEEAIAggEE8bCyALaiIIIAggC0kbQQFqIghBfyAIGyIIQf////8DSw0AQQQgCCAIQQRNGyIIQQJ0IgtB/f///wdPDQAgBigCMCEXIAsQcSINRQ0BIA0gCTYCACAOQQE2AgwgDiANNgIIIA4gCDYCBCAGKAIgQQhqIRsgBigCJCEYIAYoAhwhFCAGKAIYIQkgBigCECERIAYoAgwhBiAWRQRAIAVFDQMgBkEIaiETQQQhDEEBIQMgCiEQIAchBSACIQgDQAJ/AkACQCAIQQFxRQRAIAIhBgwBC0EAIQYgBSAQSQ0BCyAJIBRPDQcgGyAJIBhsaiELIAlBAWohCSAGIQJBAAwBCyATIAUgEWxqIQsgBUEBaiIHIQVBAQshCCAOKAIEIANGBEAgDkEEaiADQX8gCiAHayIGQQAgBiAKTRsiBiAUIAlrIghBACAIIBRNGyIIaiINIAYgDUsbIAggAkEBcSIGG0EBaiIIQX8gCBtBBEEEEKQFIAogECAGGyEQIA4oAgghDSACIQggByAFIAYbIQULIAwgDWogCzYCACAOIANBAWoiAzYCDCAMQQRqIQwMAAsACyAFRQRAQQQhCEEBIQwgCiEFIAIhCQNAIAlBAXFFIAUgB01yBH8gAyAXTw0GQQEhAiAWKAIAIRFBAyEKIAMiBkEBaiEDQQMhBUEABSAHCyELQQEhCSALQQFqIQcgDigCBCAMRgRAIA5BBGogDCAKIAdrIglBACAJIApNG0EBakEBIAJBAXEiCRtBBEEEEKQFIAogBSAJGyEFIA4oAgghDSACIQkLIAggDWogBiALIBFsakEIajYCACAOIAxBAWoiDDYCDCAIQQRqIQgMAAsAC0EEIQhBASEMIAohEyAHIQsgAiEFA0ACfwJAAkACQCAFQQFxRQRAIAIhBQwBC0EAIQUgCyATSQ0BCyADIBdPDQFBASECIBYoAgAhEUEAIQtBAyEKIAMiBkEBaiEDQQMhEwsgBiALIBFsakEIaiEQIAtBAWoiByELQQEMAQsgCSAUTw0FIBsgCSAYbGohECAJQQFqIQkgBSECQQALIQUgDigCBCAMRgRAIA5BBGogDEF/IAogB2siBUEAIAUgCk0bIgUgFCAJayINQQAgDSAUTRsiDWoiGSAFIBlLGyANIAJBAXEiBRtBAWoiDUF/IA0bQQRBBBCkBSAHIAsgBRshCyAKIBMgBRshEyAOKAIIIQ0gAiEFCyAIIA1qIBA2AgAgDiAMQQFqIgw2AgwgCEEEaiEIDAALAAtB4P/GABD/BwsACyACRQ0AIAogB2siAkEAIAIgCk0bIQUgB0EBaiEJIAYgByARbGpBCGohDEEEIQhBACEDA0AgAyAFRg0BIANBAWoiAiAOKAIERgRAIA5BBGogAiAKIAMgCWprIgZBACAGIApNG0EBaiIGQX8gBhtBBEEEEKQFIA4oAgghDQsgCCANaiAMNgIAIA4gA0ECajYCDCAMIBFqIQwgCEEEaiEIIAIhAwwACwALIBUgDikCBDcCACAVQQhqIA5BDGooAgA2AgALIA5BEGokACAEQdgDaiICIARB+AFqKAIANgIAIARBqANqIARB4ANq/QADAP0LAwAgBEG4A2ogBEHwA2r9AAMA/QsDACAEQaADaiACKQMANwMAIAQgBCkC8AE3A5gDIAQgBCgC1AE2AsgDIARBlAFqIQICQCAEQZgDaiIDKAIAIgVBgICAgHhHBEAgAygCKCEGIAMoAiQhCiADKAIcIQcgAygCGCEJIAMoAhAhCCADKAIMIQsgAygCBCEQIA9FBEAgBQRAIBBBBGsoAgAiA0F4cSITIAVBA3QiBUEEQQggA0EDcSIDG2pJDRIgA0EAIBMgBUEnaksbDRMgEBCiAgsgCwRAIAhBBGsoAgAiA0F4cSIFIAtBAnQiC0EEQQggA0EDcSIDG2pJDRIgA0EAIAUgC0EnaksbDRMgCBCiAgsgCQRAIAdBBGsoAgAiA0F4cSIFIAlBAnQiCUEEQQggA0EDcSIDG2pJDRIgA0EAIAUgCUEnaksbDRMgBxCiAgsgCgRAIAZBBGsoAgAiA0F4cSIFIApBAnQiCkEEQQggA0EDcSIDG2pJDRIgA0EAIAUgCkEnaksbDRMgBhCiAgsgAkGAgICAeDYCAAwCCyACIAY2AiggAiAKNgIkIAIgBzYCHCACIAk2AhggAiAINgIQIAIgCzYCDCACIBA2AgQgAiAFNgIAIAIgAykCLDcCLCACIAMoAiA2AiAgAiADKAIUNgIUIAIgAygCCDYCCAwBCyACQYCAgIB4NgIADAALIAQoApQBQYCAgIB4Rg0KIAQoAsQBIgJBCWsOEAMKCgoKCgoKCgoKCgoKCgQCCyACIApBuOPHABCMBwALIARBAjYCnAMgBEHA5McANgKYAyAEQgI3AqQDIAQgBEGEAWqtQoCAgIAQhDcD2AMgBCAEQTBqrUKAgICAEIQ3A9ADIAQgBEHQA2o2AqADIARBiAFqIgIgBEGYA2oQ7AMgAhCQByECIABBgICAgHg2AgAgACACNgIEDAkLIAJBLUYNAgwHC0EBIRIMBgtBAiESDAULQQMhEgwECyAAQYCAgIB4NgIAIAAgEjYCBAwECyAAQYCAgIB4NgIAIAAgDzYCBAwDCyAEQYCAgIB4NgKUAUEAIRIMAQsgBEEDNgKcAyAEQfjjxwA2ApgDIARCAjcCpAMgBCAGrUKAgICAEIQ3A9gDIAQgAUHYAGqtQoCAgIAQhDcD0AMgBCAEQdADajYCoAMgBEHIAWoiAiAEQZgDahCxBiACEJAHIQIgAEGAgICAeDYCACAAIAI2AgQMAQsgBCABKAKsATYCiAQgBCABKAKwASICNgKEBCAEIAI2AoAEIAQgAiABKAK0AUE4bGo2AowEIARBmANqIQZBACEKIARBgARqIgEoAgwiCSABKAIEIgNrIgJBOG4hBwJAAkACQCACQcj///99Sw0AIAdBBnQiAkH5////B08NAAJAIAJFBEBBCCECQQAhBwwBCyACEHEiAkUNAgsgASgCCCEIIAEoAgAhCyADIAlHBEAgAiEBA0AgA0E0aigCACEQIANBLGooAgAhBQJ/AkACQAJAAkAgA0EwaigCACITQQJrDgUCAwMAAQMLIAVBjNPHAEEFENsHDQJBAAwDCyAFQejSxwBBBhDbBw0BQQEMAgsgBS8AAEHz0AFHDQBBAgwBC0EDCyEOIANBEGr9AAMAIU0gA0EgaikDACFKIAP9AAMAIU4gAUEoaiADQShqKAIANgIAIAFBIGogSjcDACABQRBqIE39CwMAIAEgTv0LAwAgAUE8aiAOOgAAIAFBOGpBADYCACABQTRqIBA2AgAgAUEwaiATNgIAIAFBLGogBTYCACABQUBrIQEgCkEBaiEKIANBOGoiAyAJRw0ACwsgCARAIAtBBGsoAgAiAUF4cSIDIAhBOGwiBUEEQQggAUEDcSIBG2pJDQcgAUEAIAMgBUEnaksbDQggCxCiAgsgBiAKNgIIIAYgAjYCBCAGIAc2AgAMAgtByJXHABD/BwsACyAAQgQ3AnwgAEIANwJ0IABCgICAgMAANwJsIABCBDcCZCAAQgA3AlwgAEKAgICAwAA3AlQgAEIENwJMIABCADcCRCAAQoCAgIDAADcCPCAAQgQ3AjQgAEIANwIsIABCgICAgMAANwIkIABCBDcCHCAAQgA3AhQgAEKAgICAwAA3AgwgAEEIaiAEQaADaigCADYCACAAIAQpApgDNwIAIAAgQzYCuAEgACBFNgLAASAAIEc2AsgBIAAgSTYC0AEgACA8NgLYASAAID02AuABIAAgPjYC6AEgACA/NgLwASAAIEA2AvgBIAAgQTYCgAIgACAlNgKIAiAAICc2ApACIAAgKTYCmAIgACArNgKgAiAAIC02AqgCIAAgLzYCsAIgACAxNgK4AiAAIDM2AsACIAAgNTYCyAIgACA3NgLQAiAAIDk2AtgCIAAgOzYC4AIgAEEANgLoAiAAICM2AuwCIAAgEjYC8AIgACA6OgDkAiAAIDg6ANwCIAAgNjoA1AIgACA0OgDMAiAAIDI6AMQCIAAgMDoAvAIgACAuOgC0AiAAICw6AKwCIAAgKjoApAIgACAoOgCcAiAAICY6AJQCIAAgJDoAjAIgACAhOgCEAiAAICI6APwBIAAgGjoA9AEgACAgOgDsASAAIB46AOQBIAAgHzoA3AEgACBIOgDUASAAIEY6AMwBIAAgRDoAxAEgACBCOgC8ASAAQbQBaiAEQcQBaigCADYCACAAQaQBaiAEQbQBav0AAgD9CwIAIABBlAFqIARBpAFq/QACAP0LAgAgACAE/QAClAH9CwKEASAEQcgAahD7BiAEQRBqEPsGAkAgHCgCKCIAQYCAgIB4RwRAIAAEQCAcKAIsIgFBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIABqSQ0GIAJBACADIABBJ2pLGw0HIAEQogILIBwQvwQLDAALDAILIAQoAnAiAARAIAQoAnQiAkEEaygCACIDQXhxIgVBBEEIIANBA3EiAxsgAGpJDQMgA0EAIAUgAEEnaksbDQQgAhCiAgsgBEHIAGoQvwQgBCgCOCIABEAgBCgCPCICQQRrKAIAIgNBeHEiBUEEQQggA0EDcSIDGyAAakkNAyADQQAgBSAAQSdqSxsNBCACEKICCyAEQRBqEL8EIAEoArABIQIgASgCtAEiEgRAIAIhAANAIABBKGooAgAiAwRAIABBLGooAgAiBUEEaygCACIGQXhxIgpBBEEIIAZBA3EiBhsgA2pJDQUgBkEAIAogA0EnaksbDQYgBRCiAgsgABC/BCAAQThqIQAgEkEBayISDQALCyABKAKsASIARQ0AIAJBBGsoAgAiA0F4cSIFIABBOGwiAEEEQQggA0EDcSIDG2pJDQIgA0EAIAUgAEEnaksbDQMgAhCiAgsgASgCYCIAQYCAgIB4Rg0AIAAEQCABKAJkIgJBBGsoAgAiA0F4cSIFQQRBCCADQQNxIgMbIABqSQ0CIANBACAFIABBJ2pLGw0DIAIQogILIAFBOGoQvwQLIARBkARqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuRLwI3ext/AkACQAJAAkACQAJAAkACQCABQQJLBEAgA0UNASAFRQ0CIAdFDQMgCUUNBCALRQ0FIABB/wEgAi0AAEGFlQFsQQh2IkUgBi0AACJEIAQtAAAiSEEMbGogREEDbGpBCGpBBHYiS0GaggJsQQh2akGVigFrQQZ1IkZBACBGQQBKGyJGIEZB/wFOGzoAAiAAQf8BIEUgCi0AACJGIAgtAAAiUUEMbGogRkEDbGpBCGpBBHYiTkGlzAFsQQh2akGa7wBrQQZ1IkNBACBDQQBKGyJDIENB/wFOGzoAACAAQf8BIEUgS0GTMmxBCHYgTkGI6ABsQQh2amtBhMQAakEGdSJFQQAgRUEAShsiRSBFQf8BThs6AAEgAkEBaiFLIANBAWsiA0F+cSFVIABBA2ohRSADQQFxIVsgAUEDayIBIAFBBnAiWGsiTkEGSQ0IIANBAXYiAyIBIE5BBmsiT0EGbiJDIAEgQ0kbIgEgC0EBayJHIkMgASBDSRsiASAJQQFrIkkiQyABIENJGyIBIAdBAWsiTCJDIAEgQ0kbIgEgBUEBayJQIkMgASBDSRsiQ0EQSQ0GIEUgAiADIgEgT0EGbiIDIAEgA0kbIgEgRyIDIAEgA0kbIgEgSSIDIAEgA0kbIgEgTCIDIAEgA0kbIgEgUCIDIAEgA0kbIgFBAXRqQQNqSSBLIAAgAUEGbGpBCWoiAElxDQYgRSAEIAFBAmoiAWpJIARBAWoiRyAASXEgRSABIAZqSSAAIAZLcXIgRSABIAhqSSAIQQFqIkwgAElxIEUgASAKakkgACAKS3Fycg0GIENBAWoiAEEPcSIBQRAgARsiASBDQX9zaiFKIAogACABayIAaiFZIAsgAGshQyAJIABrIU8gACAIaiFJIAcgAGshUCAAIAZqIVogBSAAayFSIAAgBGohUyBLIABBAXQiAWohAyBVIAFrIVQgRSAAQQZsaiECIE4gAEF6bGohViBI/Q8hFiBE/Q8hEyBR/Q8hFSBG/Q8hDCAGIUYgCiFIIEUhACBLIQEDQCAAIAH9AAAAIh8gFf0NAAIEBgAAAAAAAAAAAAAAAP2JAf2pAf0MhUoAAIVKAACFSgAAhUoAACIU/bUBQQj9rQEiKiAVIEz9AAAAIhX9DQ8QERITFBUWFxgZGhscHR79iQH9qQEiJf0MCQAAAAkAAAAJAAAACQAAACIN/bUBIEhBAWr9AAAAIhn9iQH9qQEiJv2uASAMIBn9DQ8QERITFBUWFxgZGhscHR79iQH9qQEgFf2JAf2pASIn/a4B/QwDAAAAAwAAAAMAAAADAAAAIg/9tQH9rgH9DAgAAAAIAAAACAAAAAgAAAAiEP2uAUEE/a0BIhj9DCVmAAAlZgAAJWYAACVmAAAiGv21AUEI/a0B/a4B/QxmyP//Zsj//2bI//9myP//Ihv9rgFBBv2sAf0MAAAAAAAAAAAAAAAAAAAAACIM/bgB/Qz/AAAA/wAAAP8AAAD/AAAAIg79tgEgHyAM/Q0ICgwOAAAAAAAAAAAAAAAA/YkB/akBIBT9tQFBCP2tASIrIBUgDP0NAwQFBgAAAAAAAAAAAAAAAP2JAf2pASItIA39tQEgGSAM/Q0EBQYHAAAAAAAAAAAAAAAA/YkB/akBIi79rgEgGSAM/Q0DBAUGAAAAAAAAAAAAAAAA/YkB/akBIBUgDP0NBAUGBwAAAAAAAAAAAAAAAP2JAf2pASIv/a4BIA/9tQH9rgEgEP2uAUEE/a0BIhEgGv21AUEI/a0B/a4BIBv9rgFBBv2sASAM/bgBIA79tgH9DQAECAwQFBgcAAAAAAAAAAAgAf0AABAiICAM/Q0AAgQGAAAAAAAAAAAAAAAA/YkB/akBIBT9tQFBCP2tASIsIBUgDP0NBwgJCgAAAAAAAAAAAAAAAP2JAf2pASIwIA39tQEgGSAM/Q0ICQoLAAAAAAAAAAAAAAAA/YkB/akBIjH9rgEgGSAM/Q0HCAkKAAAAAAAAAAAAAAAA/YkB/akBIBUgDP0NCAkKCwAAAAAAAAAAAAAAAP2JAf2pASIy/a4BIA/9tQH9rgEgEP2uAUEE/a0BIhwgGv21AUEI/a0B/a4BIBv9rgFBBv2sASAM/bgBIA79tgEiEv0bAP0XCCAS/RsB/RcJIBL9GwL9FwogEv0bA/0XCyAgIAz9DQgKDA4AAAAAAAAAAAAAAAD9iQH9qQEgFP21AUEI/a0BIhcgFSAM/Q0LDA0OAAAAAAAAAAAAAAAA/YkB/akBIiEgDf21ASAZIAz9DQwNDg8AAAAAAAAAAAAAAAD9iQH9qQEiI/2uASAZIAz9DQsMDQ4AAAAAAAAAAAAAAAD9iQH9qQEgFSAM/Q0MDQ4PAAAAAAAAAAAAAAAA/YkB/akBIh39rgEgD/21Af2uASAQ/a4BQQT9rQEiJCAa/bUBQQj9rQH9rgEgG/2uAUEG/awBIAz9uAEgDv22ASIS/RsA/RcMIBL9GwH9Fw0gEv0bAv0XDiAS/RsD/RcPIiIgKiAWIEf9AAAAIhb9DQ8QERITFBUWFxgZGhscHR79iQH9qQEiKCAN/bUBIEZBAWr9AAAAIhL9iQH9qQEiM/2uASATIBL9DQ8QERITFBUWFxgZGhscHR79iQH9qQEgFv2JAf2pASI0/a4BIA/9tQH9rgEgEP2uAUEE/a0BIjX9DBMZAAATGQAAExkAABMZAAAiE/21AUEI/a0BIBj9DAg0AAAINAAACDQAAAg0AAAiGP21AUEI/a0B/a4B/bEB/QwEIgAABCIAAAQiAAAEIgAAIh79rgFBBv2sASAM/bgBIA79tgEgKyAWIAz9DQMEBQYAAAAAAAAAAAAAAAD9iQH9qQEiNiAN/bUBIBIgDP0NBAUGBwAAAAAAAAAAAAAAAP2JAf2pASI3/a4BIBIgDP0NAwQFBgAAAAAAAAAAAAAAAP2JAf2pASAWIAz9DQQFBgcAAAAAAAAAAAAAAAD9iQH9qQEiOP2uASAP/bUB/a4BIBD9rgFBBP2tASI5IBP9tQFBCP2tASARIBj9tQFBCP2tAf2uAf2xASAe/a4BQQb9rAEgDP24ASAO/bYB/Q0ABAgMEBQYHAAAAAAAAAAAICwgFiAM/Q0HCAkKAAAAAAAAAAAAAAAA/YkB/akBIjogDf21ASASIAz9DQgJCgsAAAAAAAAAAAAAAAD9iQH9qQEiO/2uASASIAz9DQcICQoAAAAAAAAAAAAAAAD9iQH9qQEgFiAM/Q0ICQoLAAAAAAAAAAAAAAAA/YkB/akBIjz9rgEgD/21Af2uASAQ/a4BQQT9rQEiPSAT/bUBQQj9rQEgHCAY/bUBQQj9rQH9rgH9sQEgHv2uAUEG/awBIAz9uAEgDv22ASIR/RsA/RcIIBH9GwH9FwkgEf0bAv0XCiAR/RsD/RcLIBcgFiAM/Q0LDA0OAAAAAAAAAAAAAAAA/YkB/akBIj4gDf21ASASIAz9DQwNDg8AAAAAAAAAAAAAAAD9iQH9qQEiP/2uASASIAz9DQsMDQ4AAAAAAAAAAAAAAAD9iQH9qQEgFiAM/Q0MDQ4PAAAAAAAAAAAAAAAA/YkB/akBIkD9rgEgD/21Af2uASAQ/a4BQQT9rQEiKSAT/bUBQQj9rQEgJCAY/bUBQQj9rQH9rgH9sQEgHv2uAUEG/awBIAz9uAEgDv22ASIR/RsA/RcMIBH9GwH9Fw0gEf0bAv0XDiAR/RsD/RcPIhz9DQAAAAAOHgAAAAAPHwAAAAAgFyAp/QwagQAAGoEAABqBAAAagQAAIhH9tQFBCP2tAf2uAf0M67r//+u6///ruv//67r//yIX/a4BQQb9rAEgDP24ASAO/bYBIikgICAM/Q0JCw0PAAAAAAAAAAAAAAAA/YkB/akBIBT9tQFBCP2tASIkIB0gDf21ASBI/QAAACIdIAz9DQwNDg8AAAAAAAAAAAAAAAD9iQH9qQH9rgEgIyAh/a4BIA/9tQH9rgEgEP2uAUEE/a0BIkEgGv21AUEI/a0B/a4BIBv9rgFBBv2sASAM/bgBIA79tgEiQv0NBBQAAAAACBgAAAAADBwAAP0NEBEAAAQFFhcAAAoLHB0AACAfIAz9DQEDBQcAAAAAAAAAAAAAAAD9iQH9qQEgFP21AUEI/a0BIiMgNCAN/bUBIEb9AAAAIiH9iQH9qQH9rgEgMyAo/a4BIA/9tQH9rgEgEP2uAUEE/a0BIiggE/21AUEI/a0BICcgDf21ASAd/YkB/akB/a4BICYgJf2uASAP/bUB/a4BIBD9rgFBBP2tASIlIBj9tQFBCP2tAf2uAf2xASAe/a4BQQb9rAEgDP24ASAO/bYBIB8gDP0NCQsNDwAAAAAAAAAAAAAAAP2JAf2pASAU/bUBQQj9rQEiHyA4IA39tQEgISAM/Q0EBQYHAAAAAAAAAAAAAAAA/YkB/akB/a4BIDcgNv2uASAP/bUB/a4BIBD9rgFBBP2tASImIBP9tQFBCP2tASAvIA39tQEgHSAM/Q0EBQYHAAAAAAAAAAAAAAAA/YkB/akB/a4BIC4gLf2uASAP/bUB/a4BIBD9rgFBBP2tASInIBj9tQFBCP2tAf2uAf2xASAe/a4BQQb9rAEgDP24ASAO/bYB/YYBICAgDP0NAQMFBwAAAAAAAAAAAAAAAP2JAf2pASAU/bUBQQj9rQEiFCA8IA39tQEgISAM/Q0ICQoLAAAAAAAAAAAAAAAA/YkB/akB/a4BIDsgOv2uASAP/bUB/a4BIBD9rgFBBP2tASIgIBP9tQFBCP2tASAyIA39tQEgHSAM/Q0ICQoLAAAAAAAAAAAAAAAA/YkB/akB/a4BIDEgMP2uASAP/bUB/a4BIBD9rgFBBP2tASIdIBj9tQFBCP2tAf2uAf2xASAe/a4BQQb9rAEgDP24ASAO/bYBICQgQCAN/bUBICEgDP0NDA0ODwAAAAAAAAAAAAAAAP2JAf2pAf2uASA/ID79rgEgD/21Af2uASAQ/a4BQQT9rQEiDSAT/bUBQQj9rQEgQSAY/bUBQQj9rQH9rgH9sQEgHv2uAUEG/awBIAz9uAEgDv22Af2GAf1mIhP9DQABHQAEBQYHHgAKCwwNHwAgIyAoIBH9tQFBCP2tAf2uASAX/a4BQQb9rAEgDP24ASAO/bYBIB8gJiAR/bUBQQj9rQH9rgEgF/2uAUEG/awBIAz9uAEgDv22Af2GASAUICAgEf21AUEI/a0B/a4BIBf9rgFBBv2sASAM/bgBIA79tgEgJCANIBH9tQFBCP2tAf2uASAX/a4BQQb9rAEgDP24ASAO/bYB/YYB/WYiDf0NAAECHQQFBgcIHgoLDA0OH/0LAFAgACAiIBz9DQAACxsAAAAADBwAAAAADR0gLCA9IBH9tQFBCP2tAf2uASAX/a4BQQb9rAEgDP24ASAO/bYBIg8gFCAdIBr9tQFBCP2tAf2uASAb/a4BQQb9rAEgDP24ASAO/bYBIhD9DQAAAAAMHAAAAAAAAAAAAAAgKf0bAP0XCiBC/RsA/RcL/Q0AAAIDFBUAAAgJGhsAAA4PIBP9DRoAAgMEBRsACAkKCxwADg8gDf0NABoCAwQFBhsICQoLDBwOD/0LAEAgACAiIBz9DQgYAAAAAAkZAAAAAAoaAAAgDyAQ/Q0AAAAQAAAAAAQUAAAAAAgY/Q0AARITAAAGBxgZAAAMDR4fIBP9DQABAgMYAAYHCAkZAAwNDg8gDf0NAAECAwQYBgcICQoZDA0OD/0LADAgACAiIBz9DQAAAAAGFgAAAAAHFwAAAAAgKyA5IBH9tQFBCP2tAf2uASAX/a4BQQb9rAEgDP24ASAO/bYBIg8gHyAnIBr9tQFBCP2tAf2uASAb/a4BQQb9rAEgDP24ASAO/bYBIhD9DQQUAAAAAAgYAAAAAAwcAAD9DRARAAAEBRYXAAAKCxwdAAAgE/0NAAEVAAQFBgcWAAoLDA0XACAN/Q0AAQIVBAUGBwgWCgsMDQ4X/QsAICAAICIgHP0NAAADEwAAAAAEFAAAAAAFFSAqIDUgEf21AUEI/a0B/a4BIBf9rgFBBv2sASAM/bgBIA79tgEiFCAjICUgGv21AUEI/a0B/a4BIBv9rgFBBv2sASAM/bgBIA79tgEiDP0NAAAAAAwcAAAAAAAAAAAAACAP/RsA/RcKIBD9GwD9Fwv9DQAAAgMUFQAACAkaGwAADg8gE/0NEgACAwQFEwAICQoLFAAODyAN/Q0AEgIDBAUGEwgJCgsMFA4P/QsAECAAICIgHP0NABAAAAAAAREAAAAAAhIAACAUIAz9DQAAABAAAAAABBQAAAAACBj9DQABEhMAAAYHGBkAAAwNHh8gE/0NAAECAxAABgcICREADA0ODyAN/Q0AAQIDBBAGBwgJChEMDQ4P/QsAACBGQRBqIUYgSEEQaiFIIABB4ABqIQAgAUEgaiEBIEdBEGohRyBMQRBqIUwgGSEMIBIhEyBKQRBqIkoNAAsgFv0WDyFIIBL9Fg8hRCAV/RYPIVEgDP0WDyFGDAcLQQBBAyABQYjsxAAQ6gcAC0EAQQBBmOzEABCMBwALQQBBAEGo7MQAEIwHAAtBAEEAQbjsxAAQjAcAC0EAQQBByOzEABCMBwALQQBBAEHY7MQAEIwHAAsgBCFTIAUhUiAGIVogByFQIAghSSAJIU8gCyFDIAohWSBOIVYgRSECIFUhVCBLIQMLIElBAWohTCBTQQFqIVNBACEAA0AgVEUgUkECSXIgUEECSSBPQQJJcnIgQ0EBTXINASACQQJqQf8BIAMtAABBhZUBbEEIdiJJIAAgWmoiR0EBai0AACIBIEhB/wFxIkpBCWxqIAAgU2otAAAiSCBEQf8BcWpBA2xqQQhqQQR2IkRBmoICbEEIdmpBlYoBa0EGdSJNQQAgTUEAShsiTSBNQf8BThs6AAAgRkH/AXEhTSACQf8BIEkgACBZaiJcQQFqLQAAIkYgUUH/AXEiXUEJbGogTSAAIExqLQAAIlFqQQNsakEIakEEdiJNQaXMAWxBCHZqQZrvAGtBBnUiV0EAIFdBAEobIlcgV0H/AU4bOgAAIAJBAWpB/wEgSSBEQZMybEEIdiBNQYjoAGxBCHZqa0GExABqQQZ1IkRBACBEQQBKGyJEIERB/wFOGzoAACACQQVqQf8BIANBAWotAABBhZUBbEEIdiJEIEctAAAgSEEJbGogASBKakEDbGpBCGpBBHYiSUGaggJsQQh2akGVigFrQQZ1IkdBACBHQQBKGyJHIEdB/wFOGzoAACACQQNqQf8BIEQgXC0AACBRQQlsaiBGIF1qQQNsakEIakEEdiJHQaXMAWxBCHZqQZrvAGtBBnUiSkEAIEpBAEobIkogSkH/AU4bOgAAIAJBBGpB/wEgRCBJQZMybEEIdiBHQYjoAGxBCHZqa0GExABqQQZ1IkRBACBEQQBKGyJEIERB/wFOGzoAACADQQJqIQMgVEECayFUIFJBAWshUiAAQQFqIQAgQ0EBayFDIE9BAWshTyBQQQFrIVAgASFEIAJBBmohAiBWQQZrIlZBBk8NAAsLAkACQAJAAkACQCBbBEAgBCAFakEBayICRQ0BIAYgB2pBAWsiA0UNAiAIIAlqQQFrIgBFDQMgCiALakEBayIERQ0EIFhBAk0NBSAALQAAIQUgRSBOaiIAQf8BIEsgVWotAABBhZUBbEEIdiIBIAMtAAAiAyACLQAAQQxsaiADQQNsakEIakEEdiICQZqCAmxBCHZqQZWKAWtBBnUiA0EAIANBAEobIgMgA0H/AU4bOgACIABB/wEgASAELQAAIgMgBUEMbGogA0EDbGpBCGpBBHYiA0GlzAFsQQh2akGa7wBrQQZ1IgRBACAEQQBKGyIEIARB/wFOGzoAACAAQf8BIAEgAkGTMmxBCHYgA0GI6ABsQQh2amtBhMQAakEGdSIAQQAgAEEAShsiACAAQf8BThs6AAELDwtB6OzEABDdCQALQfjsxAAQ3QkAC0GI7cQAEN0JAAtBmO3EABDdCQALQQBBAyBYQajtxAAQ6gcAC6MfARR/An8CQCACIANLBEAgASADQSpsaiIDLwEAIgJB//8BcUUEQCACQRB0DAMLIAJB/wdxIQEgAkGAgAJxIQUgAkGA+AFxIgJBgPgBRgRAIAVBEHQhAiACQYCAgPwHciABRQ0DGiACIAFBDXRyQYCAgP4HcgwDCyAFQRB0IQUgAkUNASACQQ10QYCAgPwAcSABQQ10ckGAgIDAA2ogBXIMAgsgAyACQZTBxwAQjAcACyAFQYCAgNgDciABZ0EQayICQRd0ayABIAJB//8DcUEIanRB////A3FyCyEBAn8gAy8BAiIFQf//AXFFBEAgBUEQdAwBCyAFQf8HcSECIAVBgIACcSEGIAVBgPgBcSIFQYD4AUYEQCAGQRB0IQUgBUGAgID8B3IgAkUNARogBSACQQ10ckGAgID+B3IMAQsgBkEQdCEGIAVBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAGciAFDQAaIAZBgICA2ANyIAJnQRBrIgVBF3RrIAIgBUH//wNxQQhqdEH///8DcXILIQUCfyADLwEEIgZB//8BcUUEQCAGQRB0DAELIAZB/wdxIQIgBkGAgAJxIQcgBkGA+AFxIgZBgPgBRgRAIAdBEHQhBiAGQYCAgPwHciACRQ0BGiAGIAJBDXRyQYCAgP4HcgwBCyAHQRB0IQcgBkENdEGAgID8AHEgAkENdHJBgICAwANqIAdyIAYNABogB0GAgIDYA3IgAmdBEGsiBkEXdGsgAiAGQf//A3FBCGp0Qf///wNxcgshBgJ/IAMvAQYiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhAiAHQYCAAnEhCCAHQYD4AXEiB0GA+AFGBEAgCEEQdCEHIAdBgICA/AdyIAJFDQEaIAcgAkENdHJBgICA/gdyDAELIAhBEHQhCCAHQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogCHIgBw0AGiAIQYCAgNgDciACZ0EQayIHQRd0ayACIAdB//8DcUEIanRB////A3FyCyEHAn8gAy8BCCIIQf//AXFFBEAgCEEQdAwBCyAIQf8HcSECIAhBgIACcSEJIAhBgPgBcSIIQYD4AUYEQCAJQRB0IQggCEGAgID8B3IgAkUNARogCCACQQ10ckGAgID+B3IMAQsgCUEQdCEJIAhBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAJciAIDQAaIAlBgICA2ANyIAJnQRBrIghBF3RrIAIgCEH//wNxQQhqdEH///8DcXILIQgCfyADLwEKIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQIgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQhCSAJQYCAgPwHciACRQ0BGiAJIAJBDXRyQYCAgP4HcgwBCyAKQRB0IQogCUENdEGAgID8AHEgAkENdHJBgICAwANqIApyIAkNABogCkGAgIDYA3IgAmdBEGsiCUEXdGsgAiAJQf//A3FBCGp0Qf///wNxcgshCQJ/IAMvAQwiCkH//wFxRQRAIApBEHQMAQsgCkH/B3EhAiAKQYCAAnEhCyAKQYD4AXEiCkGA+AFGBEAgC0EQdCEKIApBgICA/AdyIAJFDQEaIAogAkENdHJBgICA/gdyDAELIAtBEHQhCyAKQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogC3IgCg0AGiALQYCAgNgDciACZ0EQayIKQRd0ayACIApB//8DcUEIanRB////A3FyCyEKAn8gAy8BDiILQf//AXFFBEAgC0EQdAwBCyALQf8HcSECIAtBgIACcSEMIAtBgPgBcSILQYD4AUYEQCAMQRB0IQsgC0GAgID8B3IgAkUNARogCyACQQ10ckGAgID+B3IMAQsgDEEQdCEMIAtBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAMciALDQAaIAxBgICA2ANyIAJnQRBrIgtBF3RrIAIgC0H//wNxQQhqdEH///8DcXILIQsCfyADLwEQIgxB//8BcUUEQCAMQRB0DAELIAxB/wdxIQIgDEGAgAJxIQ0gDEGA+AFxIgxBgPgBRgRAIA1BEHQhDCAMQYCAgPwHciACRQ0BGiAMIAJBDXRyQYCAgP4HcgwBCyANQRB0IQ0gDEENdEGAgID8AHEgAkENdHJBgICAwANqIA1yIAwNABogDUGAgIDYA3IgAmdBEGsiDEEXdGsgAiAMQf//A3FBCGp0Qf///wNxcgshDAJ/IAMvARIiDUH//wFxRQRAIA1BEHQMAQsgDUH/B3EhAiANQYCAAnEhDiANQYD4AXEiDUGA+AFGBEAgDkEQdCENIA1BgICA/AdyIAJFDQEaIA0gAkENdHJBgICA/gdyDAELIA5BEHQhDiANQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogDnIgDQ0AGiAOQYCAgNgDciACZ0EQayINQRd0ayACIA1B//8DcUEIanRB////A3FyCyENAn8gAy8BFCIOQf//AXFFBEAgDkEQdAwBCyAOQf8HcSECIA5BgIACcSEPIA5BgPgBcSIOQYD4AUYEQCAPQRB0IQ4gDkGAgID8B3IgAkUNARogDiACQQ10ckGAgID+B3IMAQsgD0EQdCEPIA5BDXRBgICA/ABxIAJBDXRyQYCAgMADaiAPciAODQAaIA9BgICA2ANyIAJnQRBrIg5BF3RrIAIgDkH//wNxQQhqdEH///8DcXILIQ4CfyADLwEWIg9B//8BcUUEQCAPQRB0DAELIA9B/wdxIQIgD0GAgAJxIRAgD0GA+AFxIg9BgPgBRgRAIBBBEHQhDyAPQYCAgPwHciACRQ0BGiAPIAJBDXRyQYCAgP4HcgwBCyAQQRB0IRAgD0ENdEGAgID8AHEgAkENdHJBgICAwANqIBByIA8NABogEEGAgIDYA3IgAmdBEGsiD0EXdGsgAiAPQf//A3FBCGp0Qf///wNxcgshDwJ/IAMvARgiEEH//wFxRQRAIBBBEHQMAQsgEEH/B3EhAiAQQYCAAnEhESAQQYD4AXEiEEGA+AFGBEAgEUEQdCEQIBBBgICA/AdyIAJFDQEaIBAgAkENdHJBgICA/gdyDAELIBFBEHQhESAQQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogEXIgEA0AGiARQYCAgNgDciACZ0EQayIQQRd0ayACIBBB//8DcUEIanRB////A3FyCyEQAn8gAy8BGiIRQf//AXFFBEAgEUEQdAwBCyARQf8HcSECIBFBgIACcSESIBFBgPgBcSIRQYD4AUYEQCASQRB0IREgEUGAgID8B3IgAkUNARogESACQQ10ckGAgID+B3IMAQsgEkEQdCESIBFBDXRBgICA/ABxIAJBDXRyQYCAgMADaiASciARDQAaIBJBgICA2ANyIAJnQRBrIhFBF3RrIAIgEUH//wNxQQhqdEH///8DcXILIRECfyADLwEcIhJB//8BcUUEQCASQRB0DAELIBJB/wdxIQIgEkGAgAJxIRMgEkGA+AFxIhJBgPgBRgRAIBNBEHQhEiASQYCAgPwHciACRQ0BGiASIAJBDXRyQYCAgP4HcgwBCyATQRB0IRMgEkENdEGAgID8AHEgAkENdHJBgICAwANqIBNyIBINABogE0GAgIDYA3IgAmdBEGsiEkEXdGsgAiASQf//A3FBCGp0Qf///wNxcgshEgJ/IAMvAR4iE0H//wFxRQRAIBNBEHQMAQsgE0H/B3EhAiATQYCAAnEhFCATQYD4AXEiE0GA+AFGBEAgFEEQdCETIBNBgICA/AdyIAJFDQEaIBMgAkENdHJBgICA/gdyDAELIBRBEHQhFCATQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogFHIgEw0AGiAUQYCAgNgDciACZ0EQayITQRd0ayACIBNB//8DcUEIanRB////A3FyCyETAn8gAy8BICIUQf//AXFFBEAgFEEQdAwBCyAUQf8HcSECIBRBgIACcSEVIBRBgPgBcSIUQYD4AUYEQCAVQRB0IRQgFEGAgID8B3IgAkUNARogFCACQQ10ckGAgID+B3IMAQsgFUEQdCEVIBRBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAVciAUDQAaIBVBgICA2ANyIAJnQRBrIhRBF3RrIAIgFEH//wNxQQhqdEH///8DcXILIRQCfyADLwEiIhVB//8BcUUEQCAVQRB0DAELIBVB/wdxIQIgFUGAgAJxIRYgFUGA+AFxIhVBgPgBRgRAIBZBEHQhFSAVQYCAgPwHciACRQ0BGiAVIAJBDXRyQYCAgP4HcgwBCyAWQRB0IRYgFUENdEGAgID8AHEgAkENdHJBgICAwANqIBZyIBUNABogFkGAgIDYA3IgAmdBEGsiFUEXdGsgAiAVQf//A3FBCGp0Qf///wNxcgshFQJ/IAMvASQiFkH//wFxRQRAIBZBEHQMAQsgFkH/B3EhAiAWQYCAAnEhBCAWQYD4AXEiFkGA+AFGBEAgBEEQdCEWIBZBgICA/AdyIAJFDQEaIBYgAkENdHJBgICA/gdyDAELIARBEHQhBCAWQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogBHIgFg0AGiAEQYCAgNgDciACZ0EQayIWQRd0ayACIBZB//8DcUEIanRB////A3FyCyEWAn8gAy8BJiIEQf//AXFFBEAgBEEQdAwBCyAEQf8HcSECIARBgIACcSEXIARBgPgBcSIEQYD4AUYEQCAXQRB0IQQgBEGAgID8B3IgAkUNARogBCACQQ10ckGAgID+B3IMAQsgF0EQdCEXIARBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAXciAEDQAaIBdBgICA2ANyIAJnQRBrIgRBF3RrIAIgBEH//wNxQQhqdEH///8DcXILIQIgAAJ/IAMvASgiBEH//wFxRQRAIARBEHQMAQsgBEH/B3EhAyAEQYCAAnEhFyAEQYD4AXEiBEGA+AFGBEAgF0EQdCEEIARBgICA/AdyIANFDQEaIAQgA0ENdHJBgICA/gdyDAELIBdBEHQhFyAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogF3IgBA0AGiAXQYCAgNgDciADZ0EQayIEQRd0ayADIARB//8DcUEIanRB////A3FyCzYCUCAAIAI2AkwgACAWNgJIIAAgFTYCRCAAIBQ2AkAgACATNgI8IAAgEjYCOCAAIBE2AjQgACAQNgIwIAAgDzYCLCAAIA42AiggACANNgIkIAAgDDYCICAAIAs2AhwgACAKNgIYIAAgCTYCFCAAIAg2AhAgACAHNgIMIAAgBjYCCCAAIAU2AgQgACABNgIAC90eAg5/B30CQAJAAn8CQCAAKAIEIgMgAigCCCIHSQRAIAAoAgAhBSACKAIEIgogA0EYbGoiBC0AEyIDIAQtABIiBiAELQARIg0gBiANSxsiBiADIAZLGyIDBH1DAABAwSACKgJEIAItAFhBAkYiBhsiEUMAABBBIAIqAkggBhsgEZNDAAB+Q5UgA0EBa0H/AXGzlJIQiQQiESARkgVDAAAAAAshFiAEQQxqLwEAIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQQgA0GAgAJxIQYgA0GA+AFxIgNBgPgBRgRAIAZBEHQiA0GAgID8B3IgBEUNAxogAyAEQQ10ckGAgID+B3IMAwsgBkEQdCEGIANFDQEgA0ENdEGAgID8AHEgBEENdHJBgICAwANqIAZyDAILDAILIAQgBGdBEGsiBEH//wNxQQhqdEH///8DcSAGQYCAgNgDciAEQRd0a3ILQwAAgD8hEb4iEkMAAIA/XgRAIBIQxgVDVPgtQJRDAACAP5KRIRELQwAAgD8hEwJ/AkAgBSAHSQRAIAogBUEYbGoiBC0AEyIDIAQtABIiBSAELQARIgYgBSAGSxsiBSADIAVLGyIDBH1DAABAwSACKgJEIAItAFhBAkYiBRsiEkMAABBBIAIqAkggBRsgEpNDAAB+Q5UgA0EBa0H/AXGzlJIQiQQiEiASkgVDAAAAAAshFyAEQQxqLwEAIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQQgA0GAgAJxIQUgA0GA+AFxIgNBgPgBRgRAIAVBEHQiA0GAgID8B3IgBEUNAxogAyAEQQ10ckGAgID+B3IMAwsgBUEQdCEFIANFDQEgA0ENdEGAgID8AHEgBEENdHJBgICAwANqIAVyDAILIAUgB0Hcu8cAEIwHAAsgBCAEZ0EQayIEQf//A3FBCGp0Qf///wNxIAVBgICA2ANyIARBF3Rrcgu+IhJDAACAP14EQCASEMYFQ1T4LUCUQwAAgD+SkSETC0MAAIA/IRICfwJAIAcgACgCDCIDSwRAIAAoAgghBSAKIANBGGxqIgQtABMiAyAELQASIgYgBC0AESINIAYgDUsbIgYgAyAGSxsiAwR9QwAAQMEgAioCRCACLQBYQQJGIgYbIhRDAAAQQSACKgJIIAYbIBSTQwAAfkOVIANBAWtB/wFxs5SSEIkEIhQgFJIFQwAAAAALIRQgBEEMai8BACIDQf//AXFFBEAgA0EQdAwDCyADQf8HcSEEIANBgIACcSEGIANBgPgBcSIDQYD4AUYEQCAGQRB0IgNBgICA/AdyIARFDQMaIAMgBEENdHJBgICA/gdyDAMLIAZBEHQhBiADRQ0BIANBDXRBgICA/ABxIARBDXRyQYCAgMADaiAGcgwCCwwCCyAEIARnQRBrIgRB//8DcUEIanRB////A3EgBkGAgIDYA3IgBEEXdGtyC74iFUMAAIA/XgRAIBUQxgVDVPgtQJRDAACAP5KRIRILAn8CQCAFIAdJBEAgCiAFQRhsaiIELQATIgMgBC0AEiIFIAQtABEiBiAFIAZLGyIFIAMgBUsbIgMEfUMAAEDBIAIqAkQgAi0AWEECRiIFGyIVQwAAEEEgAioCSCAFGyAVk0MAAH5DlSADQQFrQf8BcbOUkhCJBCIVIBWSBUMAAAAACyEVIARBDGovAQAiA0H//wFxRQRAIANBEHQMAwsgA0H/B3EhBCADQYCAAnEhBSADQYD4AXEiA0GA+AFGBEAgBUEQdCIDQYCAgPwHciAERQ0DGiADIARBDXRyQYCAgP4HcgwDCyAFQRB0IQUgA0UNASADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIMAgsgBSAHQdy7xwAQjAcACyAEIARnQRBrIgRB//8DcUEIanRB////A3EgBUGAgIDYA3IgBEEXdGtyCyEEAn8CQCAHIABBDEEIIBQgEpQiEiASWyASIBUgBL4iFEMAAIA/XgR9IBQQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiCBtqIgYoAgAiA0sEQCAAIBYgEZQiESARWyARIBcgE5RgRXEiDEECdGoiDSgCACEEIAogA0EYbGoiAy0AEyIFIAMtABIiCSADLQARIg4gCSAOSxsiCSAFIAlLGyIFBH1DAABAwSACKgJEIAItAFhBAkYiCRsiEUMAABBBIAIqAkggCRsgEZNDAAB+Q5UgBUEBa0H/AXGzlJIQiQQiESARkgVDAAAAAAshFiADQQxqLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQMgBUGAgAJxIQkgBUGA+AFxIgVBgPgBRgRAIAlBEHQiBUGAgID8B3IgA0UNAxogBSADQQ10ckGAgID+B3IMAwsgCUEQdCEJIAVFDQEgBUENdEGAgID8AHEgA0ENdHJBgICAwANqIAlyDAILDAILIAMgA2dBEGsiA0H//wNxQQhqdEH///8DcSAJQYCAgNgDciADQRd0a3ILQwAAgD8hEr4iEUMAAIA/XgRAIBEQxgVDVPgtQJRDAACAP5KRIRILAn8CQCAEIAdJBEAgCiAEQRhsaiIELQATIgMgBC0AEiIFIAQtABEiCSAFIAlLGyIFIAMgBUsbIgMEfUMAAEDBIAIqAkQgAi0AWEECRiIFGyIRQwAAEEEgAioCSCAFGyARk0MAAH5DlSADQQFrQf8BcbOUkhCJBCIRIBGSBUMAAAAACyEXQQhBDCAIGyEJIARBDGovAQAiA0H//wFxRQRAIANBEHQMAwsgA0H/B3EhBCADQYCAAnEhBSADQYD4AXEiA0GA+AFGBEAgBUEQdCIDQYCAgPwHciAERQ0DGiADIARBDXRyQYCAgP4HcgwDCyAFQRB0IQUgA0UNASADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIMAgsMAwsgBCAEZ0EQayIEQf//A3FBCGp0Qf///wNxIAVBgICA2ANyIARBF3RrcgtDAACAPyERviITQwAAgD9eBEAgExDGBUNU+C1AlEMAAIA/kpEhEQsCfwJAIAcgACAJaiIJKAIAIgNLBEAgACAMRUECdGoiBSgCACEEIAogA0EYbGoiAC0AEyIDIAAtABIiCCAALQARIgwgCCAMSxsiCCADIAhLGyIDBH1DAABAwSACKgJEIAItAFhBAkYiCBsiE0MAABBBIAIqAkggCBsgE5NDAAB+Q5UgA0EBa0H/AXGzlJIQiQQiEyATkgVDAAAAAAshFCAAQQxqLwEAIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQAgA0GAgAJxIQggA0GA+AFxIgNBgPgBRgRAIAhBEHQiA0GAgID8B3IgAEUNAxogAyAAQQ10ckGAgID+B3IMAwsgCEEQdCEIIANFDQEgA0ENdEGAgID8AHEgAEENdHJBgICAwANqIAhyDAILDAILIAAgAGdBEGsiAEH//wNxQQhqdEH///8DcSAIQYCAgNgDciAAQRd0a3ILQwAAgD8hE74iFUMAAIA/XgRAIBUQxgVDVPgtQJRDAACAP5KRIRMLAn8CQCAEIAdJBEAgFiASlCISIBcgEZRgIAogBEEYbGoiAC0AEyIEIAAtABIiCCAALQARIgwgCCAMSxsiCCAEIAhLGyIEBH1DAABAwSACKgJEIAItAFhBAkYiCBsiEUMAABBBIAIqAkggCBsgEZNDAAB+Q5UgBEEBa0H/AXGzlJIQiQQiESARkgVDAAAAAAshFkUhCCASIBJbIQwgAEEMai8BACIEQf//AXFFBEAgBEEQdAwDCyAEQf8HcSEAIARBgIACcSEDIARBgPgBcSIEQYD4AUYEQCADQRB0IgRBgICA/AdyIABFDQMaIAQgAEENdHJBgICA/gdyDAMLIANBEHQhAyAERQ0BIARBDXRBgICA/ABxIABBDXRyQYCAgMADaiADcgwCCwwDCyAAIABnQRBrIgBB//8DcUEIanRB////A3EgA0GAgIDYA3IgAEEXdGtyCyEAQwAAgD8hEgJ/AkAgByAJIAUgBiAIIAxxIggbIBQgE5QiESARWyARIBYgAL4iE0MAAIA/XgR9IBMQxgVDVPgtQJRDAACAP5KRBUMAAIA/C5RgRXEiDBsiDigCACIASwRAIA0gBiAFIAwbIAgbIg8oAgAhBCAKIABBGGxqIgAtABMiAyAALQASIgsgAC0AESIQIAsgEEsbIgsgAyALSxsiAwR9QwAAQMEgAioCRCACLQBYQQJGIgsbIhFDAAAQQSACKgJIIAsbIBGTQwAAfkOVIANBAWtB/wFxs5SSEIkEIhEgEZIFQwAAAAALIRMgAEEMai8BACIDQf//AXFFBEAgA0EQdAwDCyADQf8HcSEAIANBgIACcSELIANBgPgBcSIDQYD4AUYEQCALQRB0IgNBgICA/AdyIABFDQMaIAMgAEENdHJBgICA/gdyDAMLIAtBEHQhCyADRQ0BIANBDXRBgICA/ABxIABBDXRyQYCAgMADaiALcgwCCyAAIAdB3LvHABCMBwALIAAgAGdBEGsiAEH//wNxQQhqdEH///8DcSALQYCAgNgDciAAQRd0a3ILviIRQwAAgD9eBEAgERDGBUNU+C1AlEMAAIA/kpEhEgsCfwJAIAQgB0kEQCAKIARBGGxqIgAtABMiByAALQASIgogAC0AESIEIAQgCkkbIgogByAKSxsiBwR9QwAAQMEgAioCRCACLQBYQQJGIgobIhFDAAAQQSACKgJIIAobIBGTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIhEgEZIFQwAAAAALIRYgAEEMai8BACICQf//AXFFBEAgAkEQdAwDCyACQf8HcSEAIAJBgIACcSEHIAJBgPgBcSICQYD4AUYEQCAHQRB0IgJBgICA/AdyIABFDQMaIAIgAEENdHJBgICA/gdyDAMLIAdBEHQhByACRQ0BIAJBDXRBgICA/ABxIABBDXRyQYCAgMADaiAHcgwCCwwDCyAAIABnQRBrIgBB//8DcUEIanRB////A3EgB0GAgIDYA3IgAEEXdGtyC0MAAIA/IRG+IhdDAACAP14EQCAXEMYFQ1T4LUCUQwAAgD+SkSERCyABIAYgDSAIGygCADYCACABIA4gDyATIBKUIhIgElsgEiAWIBGUYEVxIgAbKAIANgIEIAEgDyAOIAAbKAIANgIIIAEgBSAJIAwbKAIANgIMDwsgAyAHQdy7xwAQjAcACyAEIAdB3LvHABCMBwALziYCHnsTfwJAAkACQAJAAkACQAJAIAFBAksEQCADRQ0BIAVFDQIgB0UNAyAAQf8BIAItAABBhZUBbEEIdiIsIAQtAAAiKUGaggJsQQh2akGVigFrQQZ1IiZBACAmQQBKGyImICZB/wFOGzoAAiAAQf8BICwgBi0AACIqQaXMAWxBCHZqQZrvAGtBBnUiJkEAICZBAEobIiYgJkH/AU4bOgAAIABB/wEgLCApQZMybEEIdiAqQYjoAGxBCHZqa0GExABqQQZ1IixBACAsQQBKGyIsICxB/wFOGzoAASABQQNGDQQgAkEBaiEsIANBAWsiA0F+cSEyIABBBGohLyADQQFxITUgAUEEayI2QXhxIjNFDQcgA0EBdiIDIiYgAUEMa0EDdiIBIAEgJksbIiYgB0EBayInIisgJiArSRsiJiAFQQFrIisgJiArSRsiJkEQSQ0FIC8gAiADIAEgASADSxsiASAnIgMgASADSRsiASArIgMgASADSRsiAUEBdGpBA2pJICwgACABQQN0akELaiICSXENBSAvIAQgAUECaiIBakkgAiAES3EgLyABIAZqSSACIAZLcXINBSAHICZBAWoiASABQQ9xIgFBECABG2siKGshMCAGIChqISYgBSAoayExIAQgKGohKyAsIChBAXQiAWohAiAyIAFrIQMgLyAoQQN0IidqIQEgMyAnayE0ICn9DyEYICr9DyEUIAQhKSAGISogLCEnA0AgAEH8AGogJ/0AAAAiGSAU/Q0AAgQGAAAAAAAAAAAAAAAA/YkB/akB/QyFSgAAhUoAAIVKAACFSgAAIgz9tQFBCP2tASINIBQgKkEBav0AAAAiFP0NDxAREhMUFRYXGBkaGxwdHv2JASIJ/QwJAAkACQAJAAkACQAJAAkAIg79lQEgFP2JASIT/Y4BIBMgCf2OAf0MAwADAAMAAwADAAMAAwADACIP/ZUB/Y4B/QwIAAgACAAIAAgACAAIAAgAIhX9jgFBBP2NASII/akBIhD9DCVmAAAlZgAAJWYAACVmAAAiC/21AUEI/a0B/a4B/QxmyP//Zsj//2bI//9myP//IhH9rgFBBv2sAf0MAAAAAAAAAAAAAAAAAAAAACIJ/bgB/Qz/AAAA/wAAAP8AAAD/AAAAIgr9tgEgGSAJ/Q0ICgwOAAAAAAAAAAAAAAAA/YkB/akBIAz9tQFBCP2tASIbIAj9qgEiEiAL/bUBQQj9rQH9rgEgEf2uAUEG/awBIAn9uAEgCv22Af2GASAn/QAAECIcIAn9DQACBAYAAAAAAAAAAAAAAAD9iQH9qQEgDP21AUEI/a0BIhogFCAJ/Q0HCAkKCwwNDgAAAAAAAAAA/YkBIgggDv2VASAU/YoBIh39jgEgHSAI/Y4BIA/9lQH9jgEgFf2OAUEE/Y0BIgj9qQEiHyAL/bUBQQj9rQH9rgEgEf2uAUEG/awBIAn9uAEgCv22ASAcIAn9DQgKDA4AAAAAAAAAAAAAAAD9iQH9qQEgDP21AUEI/a0BIh4gCP2qASIiIAv9tQFBCP2tAf2uASAR/a4BQQb9rAEgCf24ASAK/bYB/YYB/WYiCP1YAAAPIABB9ABqIAj9WAAADiAAQewAaiAI/VgAAA0gAEHkAGogCP1YAAAMIABB3ABqIAj9WAAACyAAQdQAaiAI/VgAAAogAEHMAGogCP1YAAAJIABBxABqIAj9WAAACCAAQTxqIAj9WAAAByAAQTRqIAj9WAAABiAAQSxqIAj9WAAABSAAQSRqIAj9WAAABCAAQRxqIAj9WAAAAyAAQRRqIAj9WAAAAiAAQQxqIAj9WAAAASAAQQRqIAj9WAAAACAAQf0AaiANIBggKUEBav0AAAAiGP0NDxAREhMUFRYXGBkaGxwdHv2JASIIIA79lQEgGP2JASIg/Y4BICAgCP2OASAP/ZUB/Y4BIBX9jgFBBP2NASII/akBIiP9DBMZAAATGQAAExkAABMZAAAiFv21AUEI/a0BIBD9DAg0AAAINAAACDQAAAg0AAAiEP21AUEI/a0B/a4B/bEB/QwEIgAABCIAAAQiAAAEIgAAIhf9rgFBBv2sASAJ/bgBIAr9tgEgGyAI/aoBIiQgFv21AUEI/a0BIBIgEP21AUEI/a0B/a4B/bEBIBf9rgFBBv2sASAJ/bgBIAr9tgH9hgEgGiAYIAn9DQcICQoLDA0OAAAAAAAAAAD9iQEiCCAO/ZUBIBj9igEiIf2OASAhIAj9jgEgD/2VAf2OASAV/Y4BQQT9jQEiCP2pASIlIBb9tQFBCP2tASAfIBD9tQFBCP2tAf2uAf2xASAX/a4BQQb9rAEgCf24ASAK/bYBIB4gCP2qASIfIBb9tQFBCP2tASAiIBD9tQFBCP2tAf2uAf2xASAX/a4BQQb9rAEgCf24ASAK/bYB/YYB/WYiCP1YAAAPIABB9QBqIAj9WAAADiAAQe0AaiAI/VgAAA0gAEHlAGogCP1YAAAMIABB3QBqIAj9WAAACyAAQdUAaiAI/VgAAAogAEHNAGogCP1YAAAJIABBxQBqIAj9WAAACCAAQT1qIAj9WAAAByAAQTVqIAj9WAAABiAAQS1qIAj9WAAABSAAQSVqIAj9WAAABCAAQR1qIAj9WAAAAyAAQRVqIAj9WAAAAiAAQQ1qIAj9WAAAASAAQQVqIAj9WAAAACAAQf4AaiANICP9DBqBAAAagQAAGoEAABqBAAAiDf21AUEI/a0B/a4B/Qzruv//67r//+u6///ruv//IhL9rgFBBv2sASAJ/bgBIAr9tgEgGyAkIA39tQFBCP2tAf2uASAS/a4BQQb9rAEgCf24ASAK/bYB/YYBIBogJSAN/bUBQQj9rQH9rgEgEv2uAUEG/awBIAn9uAEgCv22ASAeIB8gDf21AUEI/a0B/a4BIBL9rgFBBv2sASAJ/bgBIAr9tgH9hgH9ZiII/VgAAA8gAEH2AGogCP1YAAAOIABB7gBqIAj9WAAADSAAQeYAaiAI/VgAAAwgAEHeAGogCP1YAAALIABB1gBqIAj9WAAACiAAQc4AaiAI/VgAAAkgAEHGAGogCP1YAAAIIABBPmogCP1YAAAHIABBNmogCP1YAAAGIABBLmogCP1YAAAFIABBJmogCP1YAAAEIABBHmogCP1YAAADIABBFmogCP1YAAACIABBDmogCP1YAAABIABBBmogCP1YAAAAIABBCGogGSAJ/Q0BAwUHAAAAAAAAAAAAAAAA/YkB/akBIAz9tQFBCP2tASIbIBMgDv2VASAq/QAAACII/YkBIhr9jgEgGiAT/Y4BIA/9lQH9jgEgFf2OAUEE/Y0BIhP9qQEiGiAL/bUBQQj9rQH9rgEgEf2uAUEG/awBIAn9uAEgCv22ASAZIAn9DQkLDQ8AAAAAAAAAAAAAAAD9iQH9qQEgDP21AUEI/a0BIhkgE/2qASIeIAv9tQFBCP2tAf2uASAR/a4BQQb9rAEgCf24ASAK/bYB/YYBIBwgCf0NAQMFBwAAAAAAAAAAAAAAAP2JAf2pASAM/bUBQQj9rQEiEyAdIA79lQEgCP2KASII/Y4BIAggHf2OASAP/ZUB/Y4BIBX9jgFBBP2NASII/akBIh0gC/21AUEI/a0B/a4BIBH9rgFBBv2sASAJ/bgBIAr9tgEgHCAJ/Q0JCw0PAAAAAAAAAAAAAAAA/YkB/akBIAz9tQFBCP2tASIMIAj9qgEiHCAL/bUBQQj9rQH9rgEgEf2uAUEG/awBIAn9uAEgCv22Af2GAf1mIgj9WAAAACAAQRBqIAj9WAAAASAAQRhqIAj9WAAAAiAAQSBqIAj9WAAAAyAAQShqIAj9WAAABCAAQTBqIAj9WAAABSAAQThqIAj9WAAABiAAQUBrIAj9WAAAByAAQcgAaiAI/VgAAAggAEHQAGogCP1YAAAJIABB2ABqIAj9WAAACiAAQeAAaiAI/VgAAAsgAEHoAGogCP1YAAAMIABB8ABqIAj9WAAADSAAQfgAaiAI/VgAAA4gAEGAAWoiLSAI/VgAAA8gAEGBAWogGyAgIA79lQEgKf0AAAAiCP2JASIL/Y4BIAsgIP2OASAP/ZUB/Y4BIBX9jgFBBP2NASIL/akBIhEgFv21AUEI/a0BIBogEP21AUEI/a0B/a4B/bEBIBf9rgFBBv2sASAJ/bgBIAr9tgEgGSAL/aoBIgsgFv21AUEI/a0BIB4gEP21AUEI/a0B/a4B/bEBIBf9rgFBBv2sASAJ/bgBIAr9tgH9hgEgEyAhIA79lQEgCP2KASII/Y4BIAggIf2OASAP/ZUB/Y4BIBX9jgFBBP2NASII/akBIg4gFv21AUEI/a0BIB0gEP21AUEI/a0B/a4B/bEBIBf9rgFBBv2sASAJ/bgBIAr9tgEgDCAI/aoBIg8gFv21AUEI/a0BIBwgEP21AUEI/a0B/a4B/bEBIBf9rgFBBv2sASAJ/bgBIAr9tgH9hgH9ZiII/VgAAA8gAEH5AGogCP1YAAAOIABB8QBqIAj9WAAADSAAQekAaiAI/VgAAAwgAEHhAGogCP1YAAALIABB2QBqIAj9WAAACiAAQdEAaiAI/VgAAAkgAEHJAGogCP1YAAAIIABBwQBqIAj9WAAAByAAQTlqIAj9WAAABiAAQTFqIAj9WAAABSAAQSlqIAj9WAAABCAAQSFqIAj9WAAAAyAAQRlqIAj9WAAAAiAAQRFqIAj9WAAAASAAQQlqIAj9WAAAACAAQQpqIBsgESAN/bUBQQj9rQH9rgEgEv2uAUEG/awBIAn9uAEgCv22ASAZIAsgDf21AUEI/a0B/a4BIBL9rgFBBv2sASAJ/bgBIAr9tgH9hgEgEyAOIA39tQFBCP2tAf2uASAS/a4BQQb9rAEgCf24ASAK/bYBIAwgDyAN/bUBQQj9rQH9rgEgEv2uAUEG/awBIAn9uAEgCv22Af2GAf1mIgn9WAAAACAAQRJqIAn9WAAAASAAQRpqIAn9WAAAAiAAQSJqIAn9WAAAAyAAQSpqIAn9WAAABCAAQTJqIAn9WAAABSAAQTpqIAn9WAAABiAAQcIAaiAJ/VgAAAcgAEHKAGogCf1YAAAIIABB0gBqIAn9WAAACSAAQdoAaiAJ/VgAAAogAEHiAGogCf1YAAALIABB6gBqIAn9WAAADCAAQfIAaiAJ/VgAAA0gAEH6AGogCf1YAAAOIABBggFqIAn9WAAADyApQRBqISkgKkEQaiEqICdBIGohJyAtIQAgKEEQayIoDQALIBj9Fg8hKSAU/RYPISoMBgtBAEEDIAFBmOvEABDqBwALQQBBAEGo68QAEIwHAAtBAEEAQbjrxAAQjAcAC0EAQQBByOvEABCMBwALQQRBA0EDQfjrxAAQ6gcACyAEISsgBSExIAYhJiAHITAgMyE0IC8hASAyIQMgLCECCwNAIANFIDFBAklyIDBBAU1yDQEgAUECakH/ASACLQAAQYWVAWxBCHYiLSApQf8BcSInQQlsICtBAWoiAC0AACIpaiAnIClqQQNsakEIakEEdiI3QZqCAmxBCHZqQZWKAWtBBnUiJ0EAICdBAEobIicgJ0H/AU4bOgAAIAFB/wEgLSAqQf8BcSIoQQlsICZBAWoiJy0AACIqaiAoICpqQQNsakEIakEEdiI4QaXMAWxBCHZqQZrvAGtBBnUiKEEAIChBAEobIiggKEH/AU4bOgAAIAFBBmpB/wEgAkEBai0AAEGFlQFsQQh2IiggKy0AACIrIClBCWxqICkgK2pBA2xqQQhqQQR2IitBmoICbEEIdmpBlYoBa0EGdSIuQQAgLkEAShsiLiAuQf8BThs6AAAgAUEEakH/ASAoICYtAAAiJiAqQQlsaiAmICpqQQNsakEIakEEdiImQaXMAWxBCHZqQZrvAGtBBnUiLkEAIC5BAEobIi4gLkH/AU4bOgAAIAFBAWpB/wEgLSA3QZMybEEIdiA4QYjoAGxBCHZqa0GExABqQQZ1Ii1BACAtQQBKGyItIC1B/wFOGzoAACABQQVqQf8BICggK0GTMmxBCHYgJkGI6ABsQQh2amtBhMQAakEGdSImQQAgJkEAShsiJiAmQf8BThs6AAAgAUEIaiEBIAJBAmohAiAwQQFrITAgMUEBayExIANBAmshAyAAISsgJyEmIDRBCGsiNA0ACwsCQAJAAkACQAJAIDUEQCAEIAVqQQFrIgFFDQIgBiAHakEBayIERQ0BIDZBB3EiAEUNAyABLQAAIQEgLyAzaiICQf8BICwgMmotAABBhZUBbEEIdiIDIAQtAAAiBEGlzAFsQQh2akGa7wBrQQZ1IgVBACAFQQBKGyIFIAVB/wFOGzoAACAAQQFGDQQgAkH/ASADIAFBkzJsQQh2IARBiOgAbEEIdmprQYTEAGpBBnUiBEEAIARBAEobIgQgBEH/AU4bOgABIABBAk0NBSACQf8BIAFBmoICbEEIdiADakGVigFrQQZ1IgBBACAAQQBKGyIAIABB/wFOGzoAAgsPC0Ho68QAEN0JAAtB2OvEABDdCQALQQBBAEHI7cQAEIwHAAtBAUEBQdjtxAAQjAcAC0ECQQJB6O3EABCMBwALtyICDX8GfiMAQdAEayICJAAgAkHQAGogAUEIaigCACIDNgIAIAIgASkCACIPNwJIIAJBgAE6AFQgAkEANgJEIAJCgICAgBA3AjwgD6chCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAkwiByADSwRAA0AgAyALai0AACIJQQlrIgFBF0tBASABdEGTgIAEcUVyDQIgByADQQFqIgNHDQALIAIgBzYCUCAHIQMLIAJBMGogCyAHIANBAWoiASAHIAEgB0kbEPkBIAIoAjQhASACKAIwIQRBFBBxIgMNAQwNCyACIAM2AlACQCAJQdsARwRAIAlB+wBGDQEgAkE8aiACQc8EakGIwcEAEO4BIQQMCwsgAkH/ADoAVCACIANBAWo2AlAgAkEBOgCUBCACIAJBPGo2ApAEIAJBmANqIAJBkARqEJ8DIAItAJgDQQFGBEAgAigCnAMhBAwFCwJAAkACQAJAAkACQAJAAkACQAJAIAItAJkDQQFGBEAgAkEQaiACKAKQBBCVAyACKAIUIQEgAigCEEEBcQRAIAEhBAwQCyACQZgDaiACQZAEahCfAyACLQCYA0EBRgRAIAIoApwDIQQMEAsgAi0AmQNBAUcNAiACQZgDaiACKAKQBBC7AyACKAKYA0EBRw0BIAIoApwDIQQMDwtBAEG0gcEAQYD9wAAQ2wYhBAwOCyACKQOgAyEPIAJBmANqIAJBkARqEJ8DIAItAJgDQQFGBEAgAigCnAMhBAwOCyACLQCZA0EBRw0CIAJBmANqIAIoApAEELsDIAIoApgDQQFHDQEgAigCnAMhBAwNC0EBQbSBwQBBgP3AABDbBiEEDAwLIAIpA6ADIRAgAkGYA2ogAkGQBGoQnwMgAi0AmANBAUYEQCACKAKcAyEEDAwLIAItAJkDQQFHDQIgAkGYA2ogAigCkAQQuwMgAigCmANBAUcNASACKAKcAyEEDAsLQQJBtIHBAEGA/cAAENsGIQQMCgsgAikDoAMhESACQZgDaiACQZAEahCfAyACLQCYA0EBRgRAIAIoApwDIQQMCgsgAi0AmQNBAUcNAiACQZgDaiACKAKQBBClAiACKAKYAyIIQQJHDQEgAigCnAMhBAwJC0EDQbSBwQBBgP3AABDbBiEEDAgLIAIoApwDIQMgAkGYA2ogAkGQBGoQnwMgAi0AmANBAUYEQCACKAKcAyEEDAgLIAItAJkDQQFHDQEgAkGYA2ogAigCkAQQgQIgAi0AmANBAUcNAiACKAKcAyEEDAcLQQRBtIHBAEGA/cAAENsGIQQMBgtBBUG0gcEAQYD9wAAQ2wYhBAwFCyACLQCZAyEOIAJBmANqIgQgAkGQBGoiCRDqBSACKAKcAyEHIAIoApgDIgtBBEYNAyACQcgEaiACQdADaigCADYCACACQbgEaiACQcADav0AAgD9CwMAIAJBqARqIAJBsANq/QACAP0LAwAgAiAC/QACoAP9CwOYBAJAAkAgC0EDRwRAIwBBEGsiBSQAIAVBBGogCRCfAwJAIAUtAARBAUYEQCAEIAUoAgg2AgQgBEGBgICAeDYCAAwBCyAFLQAFRQRAIARBgICAgHg2AgAMAQsgBUEEaiAJKAIAEHMgBSgCBEGAgICAeEYEQCAEIAUoAgg2AgQgBEGBgICAeDYCAAwBCyAEIAUpAgQ3AgAgBEEIaiAFQQxqKAIANgIACyAFQRBqJAAgAigCnAMhBCACKAKYAyIFQYCAgIB4aw4CAgcBC0EGQbSBwQBBgP3AABDbBiEEDAYLIAIoAqADIQogAkHYAmogAkHIBGooAgA2AgAgAkHIAmogAkG4BGr9AAMA/QsDACACQbgCaiACQagEav0AAwD9CwMAIAIgAv0AA5gE/QsDqAIgBCEGIAMhBAwGC0EHQbSBwQBBgP3AABDbBiEEDAQLIAJB/wA6AFQgAiADQQFqNgJQIAJBAToAlAQgAiACQTxqNgKQBCACQaADaiEIQYCAgIB4IQVBAyEKQQMhDEECIQ1BACEJAkACQAJ/A0ACQCACQZgDaiACQZAEahDRAiACLQCYA0EBRgRAIAIoApwDIQEMAQsCQAJAIAItAJkDQQFGBEAgAigCkAQiA0EANgIIIAMgAygCFEEBajYCFCACQZgDaiADQQxqIAMQggIgAigCnAMhASACKAKYA0ECRg0DAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACKAKgA0EEaw4KAgAQARAQBRADBBALIAFBq/zAAEEFENsHRQ0HIAFBsPzAAEEFENsHDQ8gDUECRg0JQbD8wABBBRCfByEBDBALIAFBpPzAAEEHENsHRQ0EIAFBhujAAEEHENsHDQ4gDEEDRg0JQYbowABBBxCfByEBDA8LIAEoAABB4sLNqwZGDQQMDQsgAUH4gMEAQQwQ2wcNDCASUA0FQfiAwQBBDBCfByEBDA0LIAFBmO3AAEENENsHDQsgCkEDRg0HQZjtwABBDRCfByEBDAwLIAFBhIHBAEEKENsHDQogBUGAgICAeEYNB0GEgcEAQQoQnwciBCAFDQ0aQQIhCEEAIQUMEQsgCUUNCEGk/MAAQQcQnwchAQwKCyATUEUEQEH0gMEAQQQQnwchAQwKCyACQZgDaiADEKsFIAIpA6ADIRFCASETIAIoApgDQQFHDQogAigCnAMhAQwJCyAUUEUEQEGr/MAAQQUQnwchAQwJCyACQZgDaiADEKsFIAIpA6ADIRBCASEUIAIoApgDQQFHDQkgAigCnAMhAQwICyACQZgDaiADEKsFIAIpA6ADIQ9CASESIAIoApgDQQFHDQggAigCnAMhAQwHCyACQZgDaiADEK4FIAIoApwDIgQhASACKAKYAyINQQJHDQcMBgsgAkGYA2ogAxCsBSACLQCZAyEMIAItAJgDQQFHDQYgAigCnAMhAQwFCyACQZgDaiADEK8FIAIoApwDIQcgAigCmAMiCkEDRgRAIAchAQwFCyACQcgEaiAIQTBqKAIANgIAIAJBuARqIAhBIGr9AAIA/QsDACACQagEaiAIQRBq/QACAP0LAwAgAiAI/QACAP0LA5gEDAULIAMoAgwhBQJAAkACQAJAIAMoAhQiASADKAIQIgZJBEADQAJAIAEgBWotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgAyABQQFqIgE2AhQgASAGRw0ACyAGIQELIAJBKGogBSAGIAFBAWoiASAGIAEgBkkbEPkBIAIoAiwhAyACKAIoIQFBFBBxIgZFDRggBkEDNgIADAELIAJBIGogBSAGIAFBAWoiASAGIAEgBkkbEPkBIAIoAiQhAyACKAIgIQFBFBBxIgZFDRcgBkEGNgIACyAGIAE2AgwgBiADNgIQDAELIAMgAUEBajYCFCACQZgDaiADEHMgAigCoAMhDiACKAKcAyEGIAIoApgDIgVBgICAgHhHDQULQQIhCEGAgICAeCEFIAYhBAwJCyAJQQFxRQRAQaT8wABBBxCcByEBDAMLIBNQBEBB9IDBAEEEEJwHIQEMAwsgFFAEQEGr/MAAQQUQnAchAQwDCyASUARAQfiAwQBBDBCcByEBDAMLQQIhCSAKQQNHBEAgAkHIA2ogAkHIBGooAgA2AgAgAkG4A2ogAkG4BGr9AAIA/QsDACACQagDaiACQagEav0AAgD9CwMAIAIgAv0AApgE/QsDmAMgCiEJCyAFQYCAgIB4RgRAQYSBwQBBChCcByEEQQIhCEGAgICAeCEFDAkLIA1BACANQQJHGyEIQQIgDCAMQQNGGyEBIAJBkANqIAJByANqKAIANgIAIAJBgANqIAJBuANq/QADAP0LAwAgAkHwAmogAkGoA2r9AAMA/QsDACACIAL9AAOYA/0LA+ACDAgLIAJBGGogAxCQBUEBIQkgAigCHCILIQEgAigCGEEBcUUNAgwBCyADEKABIgFFDQELCyAFQYCAgIB4ckGAgICAeEYNASABCyEEIAZBBGsoAgAiA0F4cSIBIAVBKGwiB0EEQQggA0EDcSIDG2pJDQ8gA0EAIAEgB0EnaksbDQEgBhCiAkECIQgMAwtBAiEIIAEhBAwCCwwOCyADIAQ2AgwgA0EFNgIAIAMgATYCEAwJCyACIAItAFRBAWo6AFQgAkE8ahDiBCEDIAJB0ANqIAJB8AJq/QADAP0LAwAgAkHgA2ogAkGAA2r9AAMA/QsDACACQfADaiACQZADaigCADYCACACIAc2ArwDIAIgCTYCuAMgAiAPNwOwAyACIBA3A6gDIAIgETcDoAMgAiAENgKcAyACIAU2AvQDIAIgBjYC+AMgAiAONgL8AyACIAs2AoAEIAIgAzYCiAQgAiABOgCEBCACIAL9AAPgAv0LA8ADIAIgCDYCmAMCQCAIQQJHBEAgAw0BIAJB0AFqIAJBoANqQdQA/AoAACACQcgBaiACQfwDaiIBQQhqKAIANgIAIAIgASkCADcDwAEMCAsgA0UNBCACQYgEahCxBEECIQgMBwtBAiEIAkAgBQRAIAZBBGsoAgAiAUF4cSIEIAVBKGwiB0EEQQggAUEDcSIBG2pJDQ0gAUEAIAQgB0EnaksbDQEgBhCiAgsgAyEEDAcLDAwLIAchBAtBAiEICyACIAItAFRBAWo6AFQgAkE8ahC6AyEDIAJB0ANqIAJBuAJq/QADAP0LAwAgAkHgA2ogAkHIAmr9AAMA/QsDACACQfADaiACQdgCaigCADYCACACIAc2ArwDIAIgCzYCuAMgAiARNwOwAyACIBA3A6gDIAIgDzcDoAMgAiAENgKcAyACIAU2AvQDIAIgBjYC+AMgAiAKNgL8AyACIAE2AoAEIAIgAzYCiAQgAiAOOgCEBCACIAL9AAOoAv0LA8ADIAIgCDYCmAMgCEECRwRAIAMNAiACQdABaiACQaADakHUAPwKAAAgAkHIAWogAkH8A2oiAUEIaigCADYCACACIAEpAgA3A8ABDAQLIAMNAgtBAiEIDAILQQIhCAJAIAUEQCAGQQRrKAIAIgFBeHEiBCAFQShsIgdBBEEIIAFBA3EiARtqSQ0IIAFBACAEIAdBJ2pLGw0BIAYQogILIAMhBAwCCwwHCyACQYgEahCxBEECIQgLIAhBAkYNACACQegAaiACQdABakHUAPwKAAAgAkHgAGoiCiACQcgBaigCADYCACACIAIpA8ABNwNYAkAgAigCUCIDIAIoAkwiAUkEQCACKAJIIQcDQCADIAdqLQAAQQlrIglBF0tBASAJdEGTgIAEcUVyDQIgASADQQFqIgNHDQALIAIgATYCUAsgAEEIaiACQegAakHUAPwKAAAgACAGNgJgIAAgBTYCXCAAIAQ2AgQgACAINgIAIABB7ABqIAooAgA2AgAgACACKQNYNwJkDAMLIAIgAzYCUCACQQhqIAcgASADQQFqIgQgASABIARLGxD5ASACKAIMIQQgAigCCCEHQRQQcSIBRQ0DIAEgBzYCDCABQRY2AgAgACABNgIEIABBAjYCACABIAQ2AhAgBUUNAiAGIAVBKGxBCBCiBwwCCyAEIAJBPGoQ6wUhAwsgACADNgIEIABBAjYCACAAQQhqIAJB6ABqQdQA/AoAACAAQewAaiACQeAAaigCADYCACAAIAIpA1g3AmQLAkAgAigCPCIABEAgAigCQCIBQQRrKAIAIgRBeHEiB0EEQQggBEEDcSIEGyAAakkNAyAEQQAgByAAQSdqSxsNASABEKICCyACQdAEaiQADwsMAgsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvGGQEgfyMAQSBrIg4kACAOQRRqIAEoAgAgACgCBCIcIAAoAggQowQgDigCGCENAkACQAJAAkACQCAOKAIUIglBgICAgHhGBEAgDSEYDAELIA4gDSAOKAIcEDkgDigCBCEYAkACQAJAAkAgDigCACIZQYCAgIB4RgRAIAlFDQUgDUEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgCWpJDQkgAUEAIAIgCUEnaksbDQggDRCiAgwFCyAOKAIMIREgDigCCCEPAkAgCQRAIA1BBGsoAgAiCkF4cSIMQQRBCCAKQQNxIgobIAlqSQ0BIApBACAMIAlBJ2pLGw0JIA0QogILIA5BFGogASgCACAAKAIQIh0gACgCFBCjBCAOKAIYIQ0CQAJAAkAgDigCFCIJQYCAgIB4RgRAIA0hAQwBCyAOIA0gDigCHBA5IA4oAgQhASAOKAIAIh5BgICAgHhHDQEgCUUNACANQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyAJakkNAiACQQAgAyAJQSdqSxsNCyANEKICCyAZBEAgGEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgGWpJDQwgAkEAIAMgGUEnaksbDQsgGBCiAgsgASEYDAcLIA4oAgghGiAJBEAgDUEEaygCACIKQXhxIgxBBEEIIApBA3EiChsgCWpJDQsgCkEAIAwgCUEnaksbDQogDRCiAgsgACgCHCESIAAoAhghIiACRQ0FAkAgAC0AJCINBEAgACgCICEQQQ9BCEEDIA1BAUsiIxsgDUECSyIkGyITQQJ0ISUgEUECdCEmQQEhCUEAIQoMAQtBACEJQQEhAwNAIAkgGk8NBiAJQQFqIBpPDQQgCUEEaiEJIAIgA0sgA0EBaiEDDQALDAYLA0AgCSENIApBAnQiCSAaTw0FIAlBAXIiCiAaTw0EICYgASAJai0AACIMIAEgCmotAAAiFEEIdHJBwP8DcUEGdiIJbCAlIAxBP3EiCmxqIScgGCAJIBFsIAogE2xqQQJ0aiEoQQAhG0EAIQkCQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkADQCAJICdqIhUgD08NGiAQIAkgKGoiFi0AACIKTQ0jIAkgIWoiCyAETw0gIAMgG2oiFyASIApBAnRqKgIAOAIAIBVBBGogD08NGyAQIBZBBGotAAAiCk0NIyALQQNqIARPDR4gF0EMaiASIApBAnRqKgIAOAIAIBVBCGogD08NHCAQIBZBCGotAAAiCk0NIyALQQZqIARPDR8gF0EYaiASIApBAnRqKgIAOAIAAkACQCAjRQ0AIBVBDGogD08NESAQIBZBDGotAAAiCk0NJCAJICBqIgsgBk8NGyAFIBtqIhcgEiAKQQJ0aioCADgCACAVQRBqIA9PDRIgECAWQRBqLQAAIgpNDSQgC0EDaiAGTw0YIBdBDGogEiAKQQJ0aioCADgCACAVQRRqIA9PDRMgECAWQRRqLQAAIgpNDSQgC0EGaiAGTw0XIBdBGGogEiAKQQJ0aioCADgCACAVQRhqIA9PDRQgECAWQRhqLQAAIgpNDSQgC0EJaiAGTw0ZIBdBJGogEiAKQQJ0aioCADgCACAVQRxqIA9PDRUgECAWQRxqLQAAIgpNDSQgC0EMaiAGTw0aIBdBMGogEiAKQQJ0aioCADgCACAkRQ0AIBVBIGogD08NASAQIBZBIGotAAAiCk0NIyAJIB9qIgsgCE8NECAHIBtqIhcgEiAKQQJ0aioCADgCACAVQSRqIA9PDQMgECAWQSRqLQAAIgpNDSMgC0EDaiAITw0PIBdBDGogEiAKQQJ0aioCADgCACAVQShqIA9PDQQgECAWQShqLQAAIgpNDSMgC0EGaiAITw0OIBdBGGogEiAKQQJ0aioCADgCACAVQSxqIA9PDQUgECAWQSxqLQAAIgpNDSMgC0EJaiAITw0NIBdBJGogEiAKQQJ0aioCADgCACAVQTBqIA9PDQYgECAWQTBqLQAAIgpNDSMgC0EMaiAITw0MIBdBMGogEiAKQQJ0aioCADgCACAVQTRqIA9PDQcgECAWQTRqLQAAIgpNDSMgC0EPaiAITw0LIBdBPGogEiAKQQJ0aioCADgCACAVQThqIA9PDQggECAWQThqLQAAIgpNDSMgC0ESaiAITw0KIBdByABqIBIgCkECdGoqAgA4AgALIBtBBGohGyAJQQFqIglBA08NJQwBCwsgESAUQQh0IAxyQcD/A3FBBnZsQQJ0IBMgDEE/cWxBAnRqIAlqQSBqDAYLIBEgFEEIdCAMckHA/wNxQQZ2bEECdCATIAxBP3FsQQJ0aiAJakEkagwFCyARIBRBCHQgDHJBwP8DcUEGdmxBAnQgEyAMQT9xbEECdGogCWpBKGoMBAsgESAUQQh0IAxyQcD/A3FBBnZsQQJ0IBMgDEE/cWxBAnRqIAlqQSxqDAMLIBEgFEEIdCAMckHA/wNxQQZ2bEECdCATIAxBP3FsQQJ0aiAJakEwagwCCyARIBRBCHQgDHJBwP8DcUEGdmxBAnQgEyAMQT9xbEECdGogCWpBNGoMAQsgESAUQQh0IAxyQcD/A3FBBnZsQQJ0IBMgDEE/cWxBAnRqIAlqQThqCyAPQcDzxwAQjAcACyALQRJqIQsMBQsgC0EPaiELDAQLIAtBDGohCwwDCyALQQlqIQsMAgsgC0EGaiELDAELIAtBA2ohCwsgCyAIQeDzxwAQjAcACyARIBRBCHQgDHJBwP8DcUEGdmxBAnQgEyAMQT9xbEECdGogCWpBDGoMBAsgESAUQQh0IAxyQcD/A3FBBnZsQQJ0IBMgDEE/cWxBAnRqIAlqQRBqDAMLIBEgFEEIdCAMckHA/wNxQQZ2bEECdCATIAxBP3FsQQJ0aiAJakEUagwCCyARIBRBCHQgDHJBwP8DcUEGdmxBAnQgEyAMQT9xbEECdGogCWpBGGoMAQsgESAUQQh0IAxyQcD/A3FBBnZsQQJ0IBMgDEE/cWxBAnRqIAlqQRxqCyAPQfDzxwAQjAcACyALQQZqIQsMAwsgC0EDaiELDAILIAtBCWohCwwBCyALQQxqIQsLIAsgBkGQ9McAEIwHAAsgESAUQQh0IAxyQcD/A3FBBnZsQQJ0IBMgDEE/cWxBAnRqIAlqDAILIBEgFEEIdCAMckHA/wNxQQZ2bEECdCATIAxBP3FsQQJ0aiAJakEEagwBCyARIBRBCHQgDHJBwP8DcUEGdmxBAnQgEyAMQT9xbEECdGogCWpBCGoLIA9BoPTHABCMBwALIAtBA2ohCwwBCyALQQZqIQsLIAsgBEHA9McAEIwHAAsgCiAQQdDzxwAQjAcACyAKIBBBgPTHABCMBwALIAogEEGw9McAEIwHAAsgH0EVaiEfIAdB1ABqIQcgBUE8aiEFICBBD2ohICADQSRqIQMgIUEJaiEhIA0gAiANSyILaiEJIA0hCiALDQALDAULDAkLDAgLIAlBAWohCgsgCiAaQbDzxwAQjAcACyAJIBpBoPPHABCMBwALAkAgIgRAIBJBBGsoAgAiAkF4cSIDICJBAnQiBEEEQQggAkEDcSICG2pJDQYgAkEAIAMgBEEnaksbDQUgEhCiAgsgHgRAIAFBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIB5qSQ0GIAJBACADIB5BJ2pLGw0FIAEQogILIBkEQCAYQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyAZakkNBiABQQAgAiAZQSdqSxsNBSAYEKICCyAAKAIAIgEEQCAcQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNBiACQQAgAyABQSdqSxsNBSAcEKICCyAAKAIMIgBFBEBBACEYDAQLIB1BBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIABqSQ0FQQAhGCABRQ0CIAIgAEEnaksNAAwCCwwDCyAAKAIAIgEEQCAcQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNBCACQQAgAyABQSdqSxsNAyAcEKICCyAAKAIMIgEEQCAAKAIQIgJBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAFqSQ0EIANBACAEIAFBJ2pLGw0DIAIQogILIAAoAhgiAUUNASAAKAIcIh1BBGsoAgAiAEF4cSICIAFBAnQiAUEEQQggAEEDcSIAG2pJDQMgAEUgAiABQSdqTXINAAwCCyAdEKICCyAOQSBqJAAgGA8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC/kjAQh/AkACQAJAAkACQAJAIABB9QFPBEAgAEHM/3tLBEBBAA8LIABBC2oiAUF4cSEFQcy6yQAoAgAiCEUNBEEfIQdBACAFayEDIABB9P//B00EQCAFQSYgAUEIdmciAGt2QQFxIABBAXRrQT5qIQcLIAdBAnRBsLfJAGooAgAiAkUEQEEAIQBBACEBDAILQQAhACAFQRkgB0EBdmtBACAHQR9HG3QhBEEAIQEDQAJAIAIoAgRBeHEiBiAFSQ0AIAYgBWsiBiADTw0AIAIhASAGIgMNAEEAIQMgASEADAQLIAIoAhQiBiAAIAYgAiAEQR12QQRxaigCECICRxsgACAGGyEAIARBAXQhBCACDQALDAELAkACQAJAAkACQEHIuskAKAIAIgJBECAAQQtqQfgDcSAAQQtJGyIFQQN2IgB2IgFBA3EEQCABQX9zQQFxIABqIgZBA3QiAEHAuMkAaiIEIABByLjJAGooAgAiASgCCCIDRg0BIAMgBDYCDCAEIAM2AggMAgsgBUHQuskAKAIATQ0IIAENAkHMuskAKAIAIgBFDQggAGhBAnRBsLfJAGooAgAiASgCBEF4cSAFayEDIAEhAgNAAkAgASgCECIADQAgASgCFCIADQAgAigCGCEHAkACQCACIAIoAgwiAEYEQCACQRRBECACKAIUIgAbaigCACIBDQFBACEADAILIAIoAggiASAANgIMIAAgATYCCAwBCyACQRRqIAJBEGogABshBANAIAQhBiABIgBBFGogAEEQaiAAKAIUIgEbIQQgAEEUQRAgARtqKAIAIgENAAsgBkEANgIACyAHRQ0GAkAgAigCHEECdEGwt8kAaiIBKAIAIAJHBEAgAiAHKAIQRwRAIAcgADYCFCAADQIMCQsgByAANgIQIAANAQwICyABIAA2AgAgAEUNBgsgACAHNgIYIAIoAhAiAQRAIAAgATYCECABIAA2AhgLIAIoAhQiAUUNBiAAIAE2AhQgASAANgIYDAYLIAAoAgRBeHEgBWsiASADIAEgA0kiARshAyAAIAIgARshAiAAIQEMAAsAC0HIuskAIAJBfiAGd3E2AgALIAEgAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBCABQQhqDwsCQEECIAB0IgRBACAEa3IgASAAdHFoIgZBA3QiAUHAuMkAaiIEIAFByLjJAGooAgAiACgCCCIDRwRAIAMgBDYCDCAEIAM2AggMAQtByLrJACACQX4gBndxNgIACyAAIAVBA3I2AgQgACAFaiIHIAEgBWsiBkEBcjYCBCAAIAFqIAY2AgBB0LrJACgCACICBEBB2LrJACgCACEBAn9ByLrJACgCACIEQQEgAkEDdnQiA3FFBEBByLrJACADIARyNgIAIAJBeHFBwLjJAGoiAwwBCyACQXhxIgJBwLjJAGohAyACQci4yQBqKAIACyEEIAMgATYCCCAEIAE2AgwgASADNgIMIAEgBDYCCAtB2LrJACAHNgIAQdC6yQAgBjYCAAwHC0HMuskAQcy6yQAoAgBBfiACKAIcd3E2AgALAkACQCADQRBPBEAgAiAFQQNyNgIEIAIgBWoiBiADQQFyNgIEIAMgBmogAzYCAEHQuskAKAIAIgFFDQFB2LrJACgCACEAAn9ByLrJACgCACIEQQEgAUEDdnQiB3FFBEBByLrJACAEIAdyNgIAIAFBeHFBwLjJAGoiBAwBCyABQXhxIgFBwLjJAGohBCABQci4yQBqKAIACyEBIAQgADYCCCABIAA2AgwgACAENgIMIAAgATYCCAwBCyACIAMgBWoiAEEDcjYCBCAAIAJqIgAgACgCBEEBcjYCBAwBC0HYuskAIAY2AgBB0LrJACADNgIACyACQQhqIgBFDQMMBAsgACABckUEQEEAIQFBAiAHdCIAQQAgAGtyIAhxIgBFDQMgAGhBAnRBsLfJAGooAgAhAAsgAEUNAQsDQCAAIAEgACgCBEF4cSIEIAVrIgYgA0kiBxshCCAAKAIQIgJFBEAgACgCFCECCyABIAggBCAFSSIAGyEBIAMgBiADIAcbIAAbIQMgAiIADQALCyABRQ0AIAVB0LrJACgCACIATSADIAAgBWtPcQ0AIAEoAhghBwJAAkAgASABKAIMIgBGBEAgAUEUQRAgASgCFCIAG2ooAgAiAg0BQQAhAAwCCyABKAIIIgIgADYCDCAAIAI2AggMAQsgAUEUaiABQRBqIAAbIQQDQCAEIQYgAiIAQRRqIABBEGogACgCFCICGyEEIABBFEEQIAIbaigCACICDQALIAZBADYCAAsCQCAHRQ0AAkACQCABKAIcQQJ0QbC3yQBqIgIoAgAgAUcEQCABIAcoAhBHBEAgByAANgIUIAANAgwECyAHIAA2AhAgAA0BDAMLIAIgADYCACAARQ0BCyAAIAc2AhggASgCECICBEAgACACNgIQIAIgADYCGAsgASgCFCICRQ0BIAAgAjYCFCACIAA2AhgMAQtBzLrJAEHMuskAKAIAQX4gASgCHHdxNgIACwJAIANBEE8EQCABIAVBA3I2AgQgASAFaiIAIANBAXI2AgQgACADaiADNgIAIANBgAJPBEAgACADEIAFDAILAn9ByLrJACgCACICQQEgA0EDdnQiBHFFBEBByLrJACACIARyNgIAIANB+AFxQcC4yQBqIgMMAQsgA0H4AXEiAkHAuMkAaiEDIAJByLjJAGooAgALIQIgAyAANgIIIAIgADYCDCAAIAM2AgwgACACNgIIDAELIAEgAyAFaiIAQQNyNgIEIAAgAWoiACAAKAIEQQFyNgIECyABQQhqIgANAQsCQAJAAkACQAJAIAVB0LrJACgCACIBSwRAIAVB1LrJACgCACIATwRAIAVBr4AEaiIBQRB2QAAiAkF/RgRAQQAPC0EAIQAgAkEQdCICRQ0HQeC6yQAgAUGAgHxxIgBBEGsgACACQQAgAGtGGyIBQeC6yQAoAgBqIgA2AgBB5LrJACAAQeS6yQAoAgAiBCAAIARLGzYCAAJAAkBB3LrJACgCACIEBEBBsLjJACEAA0AgACgCACIDIAAoAgQiBmogAkYNAiAAKAIIIgANAAsMAgtB7LrJACgCACIAQQAgACACTRtFBEBB7LrJACACNgIAC0HwuskAQf8fNgIAQbS4yQAgATYCAEGwuMkAIAI2AgBBzLjJAEHAuMkANgIAQdS4yQBByLjJADYCAEHIuMkAQcC4yQA2AgBB3LjJAEHQuMkANgIAQdC4yQBByLjJADYCAEHkuMkAQdi4yQA2AgBB2LjJAEHQuMkANgIAQey4yQBB4LjJADYCAEHguMkAQdi4yQA2AgBB9LjJAEHouMkANgIAQei4yQBB4LjJADYCAEH8uMkAQfC4yQA2AgBB8LjJAEHouMkANgIAQYS5yQBB+LjJADYCAEH4uMkAQfC4yQA2AgBBvLjJAEEANgIAQYy5yQBBgLnJADYCAEGAuckAQfi4yQA2AgBBiLnJAEGAuckANgIAQZS5yQBBiLnJADYCAEGQuckAQYi5yQA2AgBBnLnJAEGQuckANgIAQZi5yQBBkLnJADYCAEGkuckAQZi5yQA2AgBBoLnJAEGYuckANgIAQay5yQBBoLnJADYCAEGouckAQaC5yQA2AgBBtLnJAEGouckANgIAQbC5yQBBqLnJADYCAEG8uckAQbC5yQA2AgBBuLnJAEGwuckANgIAQcS5yQBBuLnJADYCAEHAuckAQbi5yQA2AgBBzLnJAEHAuckANgIAQdS5yQBByLnJADYCAEHIuckAQcC5yQA2AgBB3LnJAEHQuckANgIAQdC5yQBByLnJADYCAEHkuckAQdi5yQA2AgBB2LnJAEHQuckANgIAQey5yQBB4LnJADYCAEHguckAQdi5yQA2AgBB9LnJAEHouckANgIAQei5yQBB4LnJADYCAEH8uckAQfC5yQA2AgBB8LnJAEHouckANgIAQYS6yQBB+LnJADYCAEH4uckAQfC5yQA2AgBBjLrJAEGAuskANgIAQYC6yQBB+LnJADYCAEGUuskAQYi6yQA2AgBBiLrJAEGAuskANgIAQZy6yQBBkLrJADYCAEGQuskAQYi6yQA2AgBBpLrJAEGYuskANgIAQZi6yQBBkLrJADYCAEGsuskAQaC6yQA2AgBBoLrJAEGYuskANgIAQbS6yQBBqLrJADYCAEGouskAQaC6yQA2AgBBvLrJAEGwuskANgIAQbC6yQBBqLrJADYCAEHEuskAQbi6yQA2AgBBuLrJAEGwuskANgIAQdy6yQAgAjYCAEHAuskAQbi6yQA2AgBB1LrJACABQShrIgA2AgAgAiAAQQFyNgIEIAAgAmpBKDYCBEHouskAQYCAgAE2AgAMCAsgAiAETSADIARLcg0AIAAoAgxFDQMLQey6yQBB7LrJACgCACIAIAIgACACSRs2AgAgASACaiEDQbC4yQAhAAJAAkADQCADIAAoAgAiBkcEQCAAKAIIIgANAQwCCwsgACgCDEUNAQtBsLjJACEAA0ACQCAEIAAoAgAiA08EQCAEIAMgACgCBGoiBkkNAQsgACgCCCEADAELC0HcuskAIAI2AgBB1LrJACABQShrIgA2AgAgAiAAQQFyNgIEIAAgAmpBKDYCBEHouskAQYCAgAE2AgAgBCAGQSBrQXhxQQhrIgAgACAEQRBqSRsiA0EbNgIEIANBCGoiAEGwuMkA/QACAP0LAgBBtLjJACABNgIAQbC4yQAgAjYCAEG4uMkAIAA2AgBBvLjJAEEANgIAIANBHGohAANAIABBBzYCACAAQQRqIgAgBkkNAAsgAyAERg0HIAMgAygCBEF+cTYCBCAEIAMgBGsiAEEBcjYCBCADIAA2AgAgAEGAAk8EQCAEIAAQgAUMCAsCf0HIuskAKAIAIgFBASAAQQN2dCICcUUEQEHIuskAIAEgAnI2AgAgAEH4AXFBwLjJAGoiAAwBCyAAQfgBcSIBQcC4yQBqIQAgAUHIuMkAaigCAAshASAAIAQ2AgggASAENgIMIAQgADYCDCAEIAE2AggMBwsgACACNgIAIAAgACgCBCABajYCBCACIAVBA3I2AgQgBkEPakF4cUEIayIDIAIgBWoiAGshBSADQdy6yQAoAgBGDQMgA0HYuskAKAIARg0EIAMoAgQiAUEDcUEBRgRAIAMgAUF4cSIBENYEIAEgBWohBSABIANqIgMoAgQhAQsgAyABQX5xNgIEIAAgBUEBcjYCBCAAIAVqIAU2AgAgBUGAAk8EQCAAIAUQgAUMBgsCf0HIuskAKAIAIgFBASAFQQN2dCIEcUUEQEHIuskAIAEgBHI2AgAgBUH4AXFBwLjJAGoiBQwBCyAFQfgBcSIBQcC4yQBqIQUgAUHIuMkAaigCAAshAyAFIAA2AgggAyAANgIMIAAgBTYCDCAAIAM2AggMBQtB1LrJACAAIAVrIgE2AgBB3LrJAEHcuskAKAIAIgAgBWoiAjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGohAAwGC0HYuskAKAIAIQACQCABIAVrIgJBD00EQEHYuskAQQA2AgBB0LrJAEEANgIAIAAgAUEDcjYCBCAAIAFqIgEgASgCBEEBcjYCBAwBC0HQuskAIAI2AgBB2LrJACAAIAVqIgQ2AgAgBCACQQFyNgIEIAAgAWogAjYCACAAIAVBA3I2AgQLDAYLIAAgASAGajYCBEHcuskAQdy6yQAoAgAiAEEPakF4cSICQQhrIgQ2AgBB1LrJAEHUuskAKAIAIAFqIgEgACACa2pBCGoiAjYCACAEIAJBAXI2AgQgACABakEoNgIEQei6yQBBgICAATYCAAwDC0HcuskAIAA2AgBB1LrJAEHUuskAKAIAIAVqIgE2AgAgACABQQFyNgIEDAELQdi6yQAgADYCAEHQuskAQdC6yQAoAgAgBWoiATYCACAAIAFBAXI2AgQgACABaiABNgIACyACQQhqDwtBACEAQdS6yQAoAgAiASAFTQ0AQdS6yQAgASAFayIBNgIAQdy6yQBB3LrJACgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUEDcjYCBAwBCyAADwsgAEEIagvjHQMofwN7C30jAEGgAmsiBCQAAn0gAy0AHCIFQQJGBED9DAAAAAAAAIA/AABAwQAAEEEhLEEAIQVDAACAPyEvQwAAgD8hMkMAAIA/DAELIARBwgFqIANBH2otAAA6AAAgBCADLwAdOwHAASADKgIUIS8gAyoCECEyIAP9AAIAISwgAyoCGAshNCAEQQAQtgk2ArABIARBADYCrAEgBEIANwKkASAEQQA2AlwgBEKAgICAwAA3AlQgBEIENwJMIARCADcCRCAEQoCAgIDAADcCPCAEQQA2AiwgBEEANgIkIARBADYCHCAEQQA2AhQgBEEANgIMIARBADYCBCAEQQA2AjQgBEGAgICAeDYCbCAEQYCAgIB4NgJ4IAQgLP0LAoQBIAQgMjgClAEgBCAvOAKYASAEIDQ4ApwBIAQgBToAoAEgBEG8AWpBADoAACAEQaMBaiAEQcIBai0AADoAACAEQQA2AmggBEKAgICAwAA3AmAgBEIANwK0ASAEIAQvAcABOwChASABKAJcIRYgBCACOgDIASAEIBY2AsQBIAQgASgCCCIHNgLAASAEQQRqIARBwAFqEKUEIAIEQCAEQQE6AKABCwJAAkACQAJAQYCAMBBxIhFFDQAgEUEEayIhLQAAQQNxBEAgEUEAQYCAMPwLAAtBgIAQEHEiC0UNACALQQRrIiItAABBA3EEQCALQQBBgIAQ/AsAC0GAgDAQcSISRQ0AIBJBBGsiIy0AAEEDcQRAIBJBAEGAgDD8CwALQYCAMBBxIhNFDQAgE0EEayIkLQAAQQNxBEAgE0EAQYCAMPwLAAtBgIDAABBxIg5FDQAgDkEEayIlLQAAQQNxBEAgDkEAQYCAwAD8CwALQYCACBBxIg9FDQAgD0EEayImLQAAQQNxBEAgD0EAQYCACPwLAAtBgIAQEHEiDEUNACAMQQRrIicoAgAiBUEDcSIDBEAgDEEAQYCAEPwLAAsgBwRAIA9BAiACGyEoIAxBBCACGyEpQYCABEEAIAIbIR5DAACAPyABKgJAIAEtAFhBAkYiAxtDAAAAACABKgI8IAMbIjKTITRDAAAQQSABKgJIIAMbQwAAQMEgASoCRCADGyI1k0MAAH5DlSE2IAEoAhAhKiABKAIUIR8gASgCBCErA0BBgIAEIAcgEGsiAyADQYCABE8bIRkgByAQRwRAIBBBGGwhIEEAIQggKyEJICohFCALIRpBACEFIAwhGyAOIQogDyEcA0AgGgJ/AkAgByAIIBBqIh1LBEAgCSAgaiIDQRFqLwAAIANBE2otAAAiBkEQdHIiDUEIdiEVIANBDmovAQAiFyADQRBqLQAAIhhBEHRyQf8BcbNDAAB/Q5UhMyAD/QACACEsQwAAAAAhMEMAAAAAIS8gDUH/AXEEQCA1IDYgDUEBa0H/AXGzlJIQiQQhLwsgFUH/AXEEQCA1IDYgFUEBa0H/AXGzlJIQiQQhMAsgMiAzIDSUkiEzIDIgGLNDAAB/Q5UgNJSSITEgMiAXQQh2s0MAAH9DlSA0lJIhNyAGBH0gNSA2IAZBAWtB/wFxs5SSEIkEBUMAAAAACyE4IANBFGovAQAhBiADQRZqLQAAIQ0gBSARaiIVICz9HwA4AgAgBSASaiIXIDM4AgAgBSATaiIYIC84AgAgFUEEaiAs/R8BOAIAIBdBBGogNzgCACAYQQRqIDA4AgAgFUEIaiAs/R8COAIAIBdBCGogMTgCACAYQQhqIDg4AgBDAACAPyAGQQh2s/0TIAYgDUEQdHJB/wFxs/0gAf0MAAB/QwAAf0MAAH9DAAB/Q/3nASIsICz95AH9DAAAgL8AAIC/AACAvwAAgL/95AEiLP0fASIxi5MgLP0fACI3i5MiL4xDAAAAABDgCCEwIAogDbNDAAB/Q5VDAAAAP5RD2w9JQJQiOBCZAiIzIDEgMCAwjCI5ICz9DAAAAAAAAAAAAAAAAAAAAAD9Rv1NIiz9xwH9GwJBAXEbkiIxIC8gL5QgMSAxlCA3IDAgOSAs/RsAQQFxG5IiMCAwlJKSkSIxlZT9EyAzIDAgMZWU/SABIDMgLyAxlZT9IAIgOBCbAv0gA/0LAgAgA0EMai8BACIGQf//AXFFBEAgBkEQdAwDCyAGQf8HcSEDIAZBgIACcSENIAZBgPgBcSIGQYD4AUYEQCANQRB0IgZBgICA/AdyIANFDQMaIAYgA0ENdHJBgICA/gdyDAMLIA1BEHQhDSAGRQ0BIAZBDXRBgICA/ABxIANBDXRyQYCAgMADaiANcgwCCyAdIAdB3LvHABCMBwALIAMgA2dBEGsiA0H//wNxQQhqdEH///8DcSANQYCAgNgDciADQRd0a3ILNgIAIAIEQAJ/AkAgHSAfSQRAAn8gFCAgaiIGQRRqKAIAIgNBBEsEQCAGQQRqKAIAIQMgBkEIaigCAAwBCyAGQQRqCyEGIAMNAUEAIQNBAAwCCyAdIB9BzLvHABCMBwwHCyAGKAIACyEGIBwgAzsBACAbIAY2AgALIAlBGGohCSAUQRhqIRQgGkEEaiEaIAVBDGohBSAbQQRqIRsgCkEQaiEKIBxBAmohHCAIQQFqIgggGUkNAAsLIAQgHjYCjAIgBCApNgKIAiAEIB42AoQCIAQgKDYCgAIgBEEANgL8ASAEQoCAgIDAADcC9AEgBEKAgICAwAA3AuwBIARCgICQgMAANwLkASAEIA42AuABIARBgIAMNgLcASAEIBM2AtgBIARBgIAMNgLUASAEIBI2AtABIARBgIAENgLMASAEIAs2AsgBIARBgIAMNgLEASAEIBE2AsABIARBBGogECAZIARBwAFqEJcBIBAgGWoiECAHSQ0ACyAnKAIAIgVBA3EhAwsCQAJAIAVBeHFBhIAQQYiAECADG08EQCADQQAgBUGogBBPGw0GIAwQogIgJigCACICQXhxQYSACEGIgAggAkEDcSIDG0kNBSADQQAgAkGogAhPGw0GIA8QogIgJSgCACICQXhxQYSAwABBiIDAACACQQNxIgMbSQ0FIANBACACQaiAwABPGw0GIA4QogIgJCgCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBMQogIgIygCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBIQogIgIigCACICQXhxQYSAEEGIgBAgAkEDcSIDG0kNBSADQQAgAkGogBBPGw0GIAsQogIgISgCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBEQogIgFkUNBEGAgJABEHEiAkUNAyACQQRrIg4oAgAiBUEDcSIDBEAgAkEAQYCAkAH8CwALIAdFDQIgASgCICELIAEoAhwhD0EAIQkDQEGAgAQgByAJayIDIANBgIAETxshCiAHIAlHBEAgDyAJQQlsaiEDQQAhCCACIQUDQCALIAggCWoiDE0EQCAMIAtB/LvHABCMBwALIANBBGr9XAAAISwgA/1cAAAhLSAFQSBqIANBCGosAACyQwAA/kKVOAIAIAUgLf2HAf2nAf36Af0MAAD+QgAA/kIAAP5CAAD+Qv3nAf0LAgAgBUEQaiAs/YcB/acB/foB/QwAAP5CAAD+QgAA/kIAAP5C/ecB/QsCACAFQSRqIQUgA0EJaiEDIAhBAWoiCCAKSQ0ACwsgBEEEaiAJIAogAkGAgCQQzgMgByAJIApqIglLDQALDAELDAQLIA4oAgAiBUEDcSEDCwJAAkAgBUF4cUGEgJABQYiAkAEgAxtPBEAgA0EAIAVBqICQAU8bDQYgAhCiAiAWQQFGDQRBgIDwARBxIgJFDQMgAkEEayIOKAIAIgVBA3EiAwRAIAJBAEGAgPAB/AsACyAHRQ0CIAEoAiwhCyABKAIoIQ9BACEKA0BBgIAEIAcgCmsiAyADQYCABE8bIQkgByAKRwRAIA8gCkEPbGohA0EAIQggAiEFA0AgCyAIIApqIgxNBEAgDCALQYy8xwAQjAcACyADQQRq/VwAACEsIANBCGr9XAAAIS0gA0EMaiwAACEMIANBDWosAAAhFCAD/VwAACEuIAVBOGogA0EOaiwAALJDAAD+QpU4AgAgBUE0aiAUskMAAP5ClTgCACAFQTBqIAyyQwAA/kKVOAIAIAUgLv2HAf2nAf36Af0MAAD+QgAA/kIAAP5CAAD+Qv3nAf0LAgAgBUEgaiAt/YcB/acB/foB/QwAAP5CAAD+QgAA/kIAAP5C/ecB/QsCACAFQRBqICz9hwH9pwH9+gH9DAAA/kIAAP5CAAD+QgAA/kL95wH9CwIAIAVBPGohBSADQQ9qIQMgCEEBaiIIIAlJDQALCyAEQQRqIAogCSACQYCAPBDiAyAHIAkgCmoiCksNAAsMAQsMBAsgDigCACIFQQNxIQMLAkAgBUF4cUGEgPABQYiA8AEgAxtPBEAgA0EAIAVBqIDwAU8bDQUgAhCiAiAWQQJNDQNBgIDQAhBxIgJFDQIgAkEEayIJKAIAIgVBA3EiAwRAIAJBAEGAgNAC/AsACyAHBEAgASgCOCEKIAEoAjQhC0EAIQgDQEGAgAQgByAIayIBIAFBgIAETxshASAHIAhHBEBBACEFIAIhAwNAIARBwAFqIAsgCiAFIAhqELoGIAMgBP0ABMAB/QsCACADQRBqIAT9AATQAf0LAgAgA0EgaiAE/QAE4AH9CwIAIANBMGogBP0ABPAB/QsCACADQUBrIAT9AASAAv0LAgAgA0HQAGogBCoCkAI4AgAgA0HUAGohAyAFQQFqIgUgAUkNAAsLIARBBGogCCABIAJBgIDUABDjAyABIAhqIgggB0kNAAsgCSgCACIFQQNxIQMLIAVBeHFBhIDQAkGIgNACIAMbSQ0EIANBACAFQaiA0AJPGw0BIAIQogIMAwsMAwsMAwsACwJAIARBBGoiARCjASICBEAgAEECNgIAIAAgAjYCBCABEMACDAELIAAgBEEEakG8AfwKAAALIARBoAJqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv9IgMRfwR+AX0jAEHwAWsiAiQAIAEoAgwhBQJAAkACQAJAAkACQAJAAkACQAJAAkAgASgCFCIEIAEoAhAiA0kEQANAIAQgBWotAAAiBkEJayIHQRdLQQEgB3RBk4CABHFFcg0CIAEgBEEBaiIENgIUIAMgBEcNAAsgAyEECyACIAUgAyAEQQFqIgEgAyABIANJGxD5ASACKAIEIQMgAigCACEEQRQQcSIBRQ0BIAEgBDYCDCABQQU2AgAgACABNgIEIABBgICAgHg2AgAgASADNgIQDAYLAkACQAJAAkAgBkHbAEYEQCABIAEtABhBAWsiBjoAGCAEQQFqIQQgBkH/AXFFDQQgASAENgIUIAJBAToAYCACIAE2AlwgAkEANgJsIAJCgICAgIABNwJkIAJB2AFqIRAgAkG4AWohDkEIIREDQCACQbABaiACQdwAahCfAyACLQCwAUEBRgRAIAIoArQBIQQMCAsCQAJAAkACQAJAAkAgAi0AsQFBAUYEQCACKAJcIggoAgwhBgJAIAgoAhQiBCAIKAIQIgNJBEADQCAEIAZqLQAAIgdBCWsiBUEXS0EBIAV0QZOAgARxRXINAiAIIARBAWoiBDYCFCADIARHDQALIAMhBAsgAkHQAGogBiADIARBAWoiBCADIAMgBEsbEPkBIAIoAlQhAyACKAJQIQVBFBBxIgRFDQ4gBCAFNgIMIARBBTYCACAEIAM2AhAMDwsCQAJAIAdB2wBHBEAgB0H7AEYNASAIIAJB7wFqQdjAwQAQ7gEhBQwOCyAIIAgtABhBAWsiBToAGCAEQQFqIQQgBUH/AXFFDQsgCCAENgIUIAIgCDYC5AEgAkEBOgDoASACQbABaiACQeQBahCfAwJAAkAgAi0AsAFBAUYEQCACKAK0ASEDDAELAkACQAJAAkACQAJAAkACQAJAAkACQCACLQCxAUEBRgRAIAJBsAFqIAIoAuQBELsDIAIoArABQQFGBEAgAigCtAEhAwwNCyACKQO4ASETIAJBsAFqIAJB5AFqEJ8DIAItALABQQFGBEAgAigCtAEhAwwNCyACLQCxAUEBRw0CIAJBsAFqIAIoAuQBELsDIAIoArABQQFHDQEgAigCtAEhAwwMC0EAQcCCwQBBgP3AABDbBiEDDAsLIAIpA7gBIRQgAkGwAWogAkHkAWoQnwMgAi0AsAFBAUYEQCACKAK0ASEDDAsLIAItALEBQQFHDQIgAkGwAWogAigC5AEQ4AEgAi0AsAFBAUcNASACKAK0ASEDDAoLQQFBwILBAEGA/cAAENsGIQMMCQsgAi0AsQEhBiACQbABaiACQeQBahCfAyACLQCwAUEBRgRAIAIoArQBIQMMCQsgAi0AsQFBAUcNAiACQbABaiACKALkARDlASACLQCwAUEBRw0BIAIoArQBIQMMCAtBAkHAgsEAQYD9wAAQ2wYhAwwHCyACLQCxASEHIAJBsAFqIAJB5AFqEJ8DIAItALABQQFGBEAgAigCtAEhAwwHCyACLQCxAUEBRw0CIAJBsAFqIAIoAuQBEPEBIAItALABQQFHDQEgAigCtAEhAwwGC0EDQcCCwQBBgP3AABDbBiEDDAULIAItALEBIQkgAkGwAWogAkHkAWoQnwMgAi0AsAFBAUYEQCACKAK0ASEDDAULIAItALEBQQFHDQEgAkGwAWogAigC5AEQ0gIgAigCsAEiBEECRgRAIAIoArQBIQMMBQsgAigCtAEhBSACQbABaiACQeQBahDHBiACKAK0ASEDIAIoArABIg9BAmsOAgMEAgtBBEHAgsEAQYD9wAAQ2wYhAwwDC0EFQcCCwQBBgP3AABDbBiEDDAILIAMhDCAFIQMMAgtBBkHAgsEAQYD9wAAQ2wYhAwtBAiEECyAIIAgtABhBAWo6ABggAiAIELoDIgU2AtgBIAIgBjoA0gEgAiAHOgDRASACIAk6ANABIAIgFDcDyAEgAiATNwPAASACIAw2ArwBIAIgDzYCuAEgAiADNgK0ASACIAQ2ArABIARBAkcEQEECIQYgBQ0JIAJBoAFqIA5BEGr9AAMA/QsDACACIA79AAMA/QsDkAEgBCEGDAgLQQIhBiAFDQEMBwsgCCAILQAYQQFrIgU6ABggBEEBaiEEIAVB/wFxRQ0FIAggBDYCFCACQQE6AOgBIAIgCDYC5AFCACEVQQ4hBkENIQdBAiEFQQIhDEECIQpCACEWA0AgAkGwAWoiAyACQeQBahDRAiACLQCwAUEBRg0DAkAgAi0AsQFBAUYEQCACKALkASIEQQA2AgggBCAEKAIUQQFqNgIUIAMgBEEMaiAEEIICIAIoArQBIQMgAigCsAFBAkYNBgJAAkACQAJAAkACQAJAAkACQAJAAkACQCACKAK4AUEDaw4JAQ0DAg0ADQ0EDQsgAykAAELw5L2D18ycuvkAUQ0GIAMpAABC5dyN+8asmrfnAFINDCAHQf8BcUENRg0HQQIhBEHI/cAAQQgQnwchAwwSCyADQZOCwQBBAxDbB0UNCCADQZaCwQBBAxDbBw0LIAVBAkYNCUECIQRBloLBAEEDEJ8HIQMMEQsgA0HMgcEAQQYQ2wdFDQIMCgsgA0G1mMgAQQUQ2wcNCSAVUA0CQQIhBEG1mMgAQQUQnwchAwwPCyADQYiCwQBBCxDbBw0IIApBAkYNBEECIQRBiILBAEELEJ8HIQMMDgsgFlBFBEBBAiEEQcyBwQBBBhCfByEDDA4LIAJBsAFqIAQQqwUgAikDuAEhFEIBIRYgAigCsAFBAUcNCAwLCyACQbABaiAEEKsFIAIpA7gBIRNCASEVIAIoArABQQFHDQcMCgsgBkH/AXFBDkcEQEECIQRBsNHHAEEIEJ8HIQMMDAsgBCgCDCELAkACQAJAIAQoAhQiAyAEKAIQIgZJBEADQAJAIAMgC2otAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgBCADQQFqIgM2AhQgAyAGRw0ACyAGIQMLIAJBKGogCyAGIANBAWoiAyAGIAMgBkkbEPkBIAIoAiwhBCACKAIoIQVBFBBxIgNFDRggA0EDNgIADAELIAJBIGogCyAGIANBAWoiAyAGIAMgBkkbEPkBIAIoAiQhBCACKAIgIQVBFBBxIgNFDRcgA0EGNgIACyADIAU2AgwgAyAENgIQQQIhBAwMCyAEIANBAWo2AhQgAkGwAWogBBDgASACLQCxASEGIAItALABQQFHDQYMCQsgBCgCDCELAkACQAJAIAQoAhQiAyAEKAIQIgdJBEADQAJAIAMgC2otAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgBCADQQFqIgM2AhQgAyAHRw0ACyAHIQMLIAJBOGogCyAHIANBAWoiAyAHIAMgB0kbEPkBIAIoAjwhBCACKAI4IQVBFBBxIgNFDRcgA0EDNgIADAELIAJBMGogCyAHIANBAWoiAyAHIAMgB0kbEPkBIAIoAjQhBCACKAIwIQVBFBBxIgNFDRYgA0EGNgIACyADIAU2AgwgAyAENgIQQQIhBAwLCyAEIANBAWo2AhQgAkGwAWogBBDlASACLQCxASEHIAItALABQQFHDQUMCAsgBCgCDCEKAkACQAJAIAQoAhQiAyAEKAIQIglJBEADQAJAIAMgCmotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgBCADQQFqIgM2AhQgAyAJRw0ACyAJIQMLIAJByABqIAogCSADQQFqIgMgCSADIAlJGxD5ASACKAJMIQQgAigCSCEFQRQQcSIDRQ0WIANBAzYCAAwBCyACQUBrIAogCSADQQFqIgMgCSADIAlJGxD5ASACKAJEIQQgAigCQCEFQRQQcSIDRQ0VIANBBjYCAAsgAyAFNgIMIAMgBDYCEEECIQQMCgsgBCADQQFqNgIUIAJBsAFqIAQQ8QEgAi0AsQEhCiACLQCwAUEBRw0EDAcLIAxBAkcEQEECIQRBk4LBAEEDEJ8HIQMMCQsgAkGwAWogBBCwBUECIQQgAigCtAEiEiEDIAIoArABIgxBAkcNAwwICyACQbABaiAEELAFQQIhBCACKAK0ASIDviEXIAIoArABIgVBAkcNAgwHCyAWUARAQQIhBEHMgcEAQQYQnAchAwwHCyAVUARAQQIhBEG1mMgAQQUQnAchAwwHCyAGQf8BcUEORgRAQQIhBEGw0ccAQQgQnAchAwwHCyAHQf8BcUENRgRAQQIhBEHI/cAAQQgQnAchAwwHCyAMQQAgDEECRxshBCAFQQAgBUECRxshCSAKQQFxIQ8gEiEDDAYLIAQQoAEiA0UNAAsMAwsgEBCxBAwFCyACKAJoIQQgAigCZCEDDA4LIAIoArQBIQMLQQIhBAsgCCAILQAYQQFqOgAYIAIgCBDiBCIFNgLYASACIAY6ANIBIAIgBzoA0QEgAiAPOgDQASACIBM3A8gBIAIgFDcDwAEgAiAXOAK8ASACIAk2ArgBIAIgAzYCtAEgAiAENgKwASAEQQJHBEBBAiEGIAUNAyACQaABaiAOQRBq/QADAP0LAwAgAiAO/QADAP0LA5ABIAQhBiADIQUMAwtBAiEGIAVFBEAgAyEFDAMLIBAQsQQgAyEFDAILIAJBGGogBiADIAQgAyADIARLGxD5ASACKAIcIQMgAigCGCEFQRQQcSIEDQUMCAsgAyEFCyAGQQJGDQQgAkGAAWoiCCACQaABav0AAwD9CwMAIAIgAv0AA5AB/QsDcCACKAJkIA1GBEAjAEEgayIDJAACQCACQeQAaiIEKAIAIgdBmbPmDEsEf0EABUEEIAdBAXQiCiAKQQRNGyIKQShsIQsgAyAHBH8gAyAHQShsNgIcIAMgBCgCBDYCFEEIBUEACzYCGCADQQhqQQggCyADQRRqEIUHIAMoAghBAUcNASADKAIQIQQgAygCDAsgBEHUgsEAEJMJAAsgAygCDCEHIAQgCjYCACAEIAc2AgQgA0EgaiQAIAIoAmghEQsgESANQShsaiIDIAU2AgQgAyAGNgIAIAMgAv0AA3D9CwIIIANBGGogCP0AAwD9CwIAIAIgDUEBaiINNgJsDAALAAsgASACQe8BakH4v8EAEO4BIQQMBwsgAkEQaiAGIAMgBCADIAMgBEsbEPkBIAIoAhQhAyACKAIQIQVBFBBxIgRFDQMLIAQgBTYCDCAEQRg2AgAgBCADNgIQDAMLIAUgCBDrBSEEDAILIAJBCGogBSADIAQgAyADIARLGxD5ASACKAIMIQMgAigCCCEEQRQQcSIBRQ0AIAEgBDYCDCABQRg2AgAgACABNgIEIABBgICAgHg2AgAgASADNgIQDAULAAtBgICAgHghAyACKAJkIgVFDQAgAigCaCIGQQRrKAIAIgdBeHEiCSAFQShsIgVBBEEIIAdBA3EiBxtqSQ0EIAdBACAJIAVBJ2pLGw0FIAYQogILIAEgAS0AGEEBajoAGCACIAEQugMiBTYCvAEgAiANNgK4ASACIAQ2ArQBIAIgAzYCsAEgA0GAgICAeEcEQCAFRQ0CIAMEQCAEQQRrKAIAIgZBeHEiByADQShsIgNBBEEIIAZBA3EiBhtqSQ0HIAZBACAHIANBJ2pLGw0IIAQQogILIAUhBAwBCyAFRQ0AIAJBvAFqELEECyAEIAEQ6wUhASAAQYCAgIB4NgIAIAAgATYCBAwBCyAAIA02AgggACAENgIEIAAgAzYCAAsgAkHwAWokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvfFwIafwJ8IwBBsARrIgMkACADQgA3A5gBIANCADcDkAEgA0IANwOIASADQgA3A4ABIANCADcDeCADQgA3A3AgA0IANwNoIANCADcDYCADQgA3A1ggA0IANwNQIANCADcDSCADQgA3A0AgA0IANwM4IANCADcDMCADQgA3AyggA0IANwMgIANCADcDGCADQgA3AxAgA0IANwMIIANCADcDACADQgA3A7gCIANCADcDsAIgA0IANwOoAiADQgA3A6ACIANCADcDmAIgA0IANwOQAiADQgA3A4gCIANCADcDgAIgA0IANwP4ASADQgA3A/ABIANCADcD6AEgA0IANwPgASADQgA3A9gBIANCADcD0AEgA0IANwPIASADQgA3A8ABIANCADcDuAEgA0IANwOwASADQgA3A6gBIANCADcDoAEgA0IANwPYAyADQgA3A9ADIANCADcDyAMgA0IANwPAAyADQgA3A7gDIANCADcDsAMgA0IANwOoAyADQgA3A6ADIANCADcDmAMgA0IANwOQAyADQgA3A4gDIANCADcDgAMgA0IANwP4AiADQgA3A/ACIANCADcD6AIgA0IANwPgAiADQgA3A9gCIANCADcD0AIgA0IANwPIAiADQgA3A8ACIANB4ANqQQBB0AD8CwBBrLHJACgCACIJIQYgAkEDa0EYbSIFQQAgBUEAShsiCyEFIAtBAnRBvLHJAGohBwNAIAMgBEEDdGogBUEASAR8RAAAAAAAAAAABSAHKAIAtws5AwAgBCAGSSIKBEAgB0EEaiEHIAVBAWohBSAEIApqIgQgBk0NAQsLQQAhBQNAQQAhBCADQcACaiAFQQN0aiAdIAAgBEEDdGorAwAgAyAFIARrQQN0aisDAKKgOQMAIAUgCUkiBgRAIAUgBmoiBSAJTQ0BCwtEAAAAAAAA8H9EAAAAAAAA4H8gAiALQWhsaiIKQRhrIgJB/g9LIhAbRAAAAAAAAAAARAAAAAAAAGADIAJBuXBJIhEbRAAAAAAAAPA/IAJBgnhIIhIbIAJB/wdKIhMbQf0XIAIgAkH9F08bQf4PayAKQZcIayAQGyIVQfBoIAIgAkHwaE0bQZIPaiAKQbEHaiARGyIWIAIgEhsgExtB/wdqrUI0hr+iIR4gA0HcA2oiDiAJQQJ0aiEPQS8gCmtBH3EhF0EwIAprQR9xIRQgA0G4AmohGCACQQBKIRkgAkEBayEaIAkhBQJAA0AgA0HAAmogBSIGQQN0aisDACEdAkAgBkUNACADQeADaiEIIAYhBANAIAggHSAdRAAAAAAAAHA+ovwCtyIdRAAAAAAAAHDBoqD8AjYCACAYIARBA3RqKwMAIB2gIR0gBEEBRiIFDQEgCEEEaiEIQQEgBEEBayAFGyIEDQALCwJ/AkAgE0UEQCASDQEgAgwCCyAdRAAAAAAAAOB/oiIdRAAAAAAAAOB/oiAdIBAbIR0gFQwBCyAdRAAAAAAAAGADoiIdRAAAAAAAAGADoiAdIBEbIR0gFgshBSAdIAVB/wdqrUI0hr+iIh0gHUQAAAAAAADAP6KcRAAAAAAAACDAoqAiHSAd/AIiDLehIR0CfwJAAkACQAJ/IBlFBEAgAkUEQCAOIAZBAnRqKAIAQRd1DAILQQIhDUEAIB1EAAAAAAAA4D9mRQ0FGgwCCyAOIAZBAnRqIgUgBSgCACIFIAUgFHUiBSAUdGsiBDYCACAFIAxqIQwgBCAXdQsiDUEATA0BC0EBIQgCQCAGRQ0AQQAhBSAGQQFHBEAgBkEecSEbQQAhByADQeADaiEEA0AgBCgCACEIAn8CQCAEIAcEf0H///8HBSAIRQ0BQYCAgAgLIAhrNgIAQQAMAQtBAQshCCAEQQRqIhwoAgAhBwJ/AkAgHCAIBH8gB0UNAUGAgIAIBUH///8HCyAHazYCAEEAIQhBAQwBC0EBIQhBAAshByAEQQhqIQQgGyAFQQJqIgVHDQALCyAGQQFxRQ0AIANB4ANqIAVBAnRqIgQoAgAhBQJAIAQgCAR/IAVFDQFBgICACAVB////BwsgBWs2AgBBACEIDAELQQEhCAsCQCACQQBMDQBB////AyEEAkACQCAaDgIBAAILQf///wEhBAsgDiAGQQJ0aiIFIAUoAgAgBHE2AgALIAxBAWohDCANQQJGDQELIA0MAQtEAAAAAAAA8D8gHaEiHSAdIB6hIAhBAXEbIR1BAgshDSAdRAAAAAAAAAAAYQRAIA8hBCAGIQUCQCAJIAZBAWsiCEsNAEEAIQcDQAJAIANB4ANqIAhBAnRqKAIAIAdyIQcgCCAJTQ0AIAkgCCAIIAlLayIITQ0BCwsgBiEFIAdFDQAgBkECdCADakHcA2ohBANAIAZBAWshBiACQRhrIQIgBCgCACAEQQRrIQRFDQALDAMLA0AgBUEBaiEFIAQoAgAgBEEEayEERQ0ACyAFIAZNDQEgBkEBaiEHA0AgAyAHQQN0aiAHIAtqQQJ0KAK8sUm3OQMAQQAhBEQAAAAAAAAAACEdIANBwAJqIAdBA3RqIB0gACAEQQN0aisDACADIAcgBGtBA3RqKwMAoqA5AwAgBSAHTQ0CIAcgBSAHS2oiBiEHIAUgBk8NAAsMAQsLAkACQAJAQQAgAmsiBEH/B0wEQCAEQYJ4Tg0DIB1EAAAAAAAAYAOiIR0gBEG4cE0NAUHJByACayEEDAMLIB1EAAAAAAAA4H+iIR0gBEH+D0sNAUGBeCACayEEDAILIB1EAAAAAAAAYAOiIR1B8GggBCAEQfBoTRtBkg9qIQQMAQsgHUQAAAAAAADgf6IhHUH9FyAEIARB/RdPG0H+D2shBAsgHSAEQf8Haq1CNIa/oiIdRAAAAAAAAHBBZgRAIANB4ANqIAZBAnRqIB0gHUQAAAAAAABwPqL8ArciHUQAAAAAAABwwaKg/AI2AgAgBkEBaiEGIAohAgsgA0HgA2ogBkECdGogHfwCNgIACwJ8AkACQCACQf8HTARAIAJBgnhIDQFEAAAAAAAA8D8MAwsgAkH+D0sNASACQf8HayECRAAAAAAAAOB/DAILIAJBuHBLBEAgAkHJB2ohAkQAAAAAAABgAwwCC0HwaCACIAJB8GhNG0GSD2ohAkQAAAAAAAAAAAwBC0H9FyACIAJB/RdPG0H+D2shAkQAAAAAAADwfwsgAkH/B2qtQjSGv6IhHSAGQQFxBH8gBgUgA0HAAmogBkEDdGogHSADQeADaiAGQQJ0aigCALeiOQMAIB1EAAAAAAAAcD6iIR0gBkEBawshACAGBEAgAEEDdCADakG4AmohBCAAQQJ0IANqQdwDaiECA0AgBCAdRAAAAAAAAHA+oiIeIAIoAgC3ojkDACAEQQhqIB0gAkEEaigCALeiOQMAIARBEGshBCACQQhrIQIgHkQAAAAAAABwPqIhHSAAQQFHIABBAmshAA0ACwsgBkEBaiEKIANBwAJqIAZBA3RqIQggBiEEA0ACQCAJIAYgBCIAayIFIAUgCUsbIgdFBEBBACECRAAAAAAAAAAAIR0MAQsgB0EBakF+cSEPRAAAAAAAAAAAIR1BACEEQQAhAgNAIB0gBEHIs8kAaisDACAEIAhqIgsrAwCioCAEQdCzyQBqKwMAIAtBCGorAwCioCEdIARBEGohBCAPIAJBAmoiAkcNAAsLIANBoAFqIAVBA3RqIAdBAXEEfCAdBSAdIAJBA3QrA8izSSADQcACaiAAIAJqQQN0aisDAKKgCzkDACAIQQhrIQggAEEBayEEIAANAAsCQCAKQQNxIgBFBEBEAAAAAAAAAAAhHSAGIQIMAQsgA0GgAWogBkEDdGohBEQAAAAAAAAAACEdIAYhAgNAIAJBAWshAiAdIAQrAwCgIR0gBEEIayEEIABBAWsiAA0ACwsgBkEDTwRAIAJBA3QgA2pBiAFqIQQDQCAdIARBGGorAwCgIARBEGorAwCgIARBCGorAwCgIAQrAwCgIR0gBEEgayEEIAJBA0cgAkEEayECDQALCyABIB2aIB0gDRs5AwAgA0GwBGokACAMQQdxC/cYAxx/BHsBfSMAQSBrIg8kACAPQRRqIAEoAgAgACgCBCIbIAAoAggQowQgDygCGCEOAkACQAJAAkACQCAPKAIUIgpBgICAgHhGBEAgDiEXDAELIA8gDiAPKAIcEDkgDygCBCEXAkACQAJAAkAgDygCACIYQYCAgIB4RgRAIApFDQUgDkEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgCmpJDQkgAUEAIAIgCkEnaksbDQggDhCiAgwFCyAPKAIMIRMgDygCCCEQAkAgCgRAIA5BBGsoAgAiDUF4cSIMQQRBCCANQQNxIg0bIApqSQ0BIA1BACAMIApBJ2pLGw0JIA4QogILIA9BFGogASgCACAAKAIQIhwgACgCFBCjBCAPKAIYIQ4CQAJAAkACQAJAIA8oAhQiCkGAgICAeEYEQCAOIQEMAQsgDyAOIA8oAhwQOSAPKAIEIQEgDygCACIdQYCAgIB4Rw0BIApFDQAgDkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgCmpJDQQgAkEAIAMgCkEnaksbDQ0gDhCiAgsgGARAIBdBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIBhqSQ0OIAJBACADIBhBJ2pLGw0NIBcQogILIAEhFwwJCyAPKAIIIRkgCgRAIA5BBGsoAgAiDUF4cSIMQQRBCCANQQNxIg0bIApqSQ0NIA1BACAMIApBJ2pLGw0BIA4QogILQYAIEHEiEUUNASAAKgIcIAAqAhgiKpP9EyEnICr9EyEo/QwAAAAAAQAAAAIAAAADAAAAISZBACEKA0AgCiARaiIOICggJv37Af0MAAB/QwAAf0MAAH9DAAB/QyIp/ecBICf95gH95AH9CwIAIA5BEGogKCAm/QwEAAAABAAAAAQAAAAEAAAA/a4B/fsBICn95wEgJ/3mAf3kAf0LAgAgJv0MCAAAAAgAAAAIAAAACAAAAP2uASEmIApBIGoiCkGACEcNAAsgAkUNBwJAIAMEQEEPQQhBAyADQQJGGyADQQNGIiEbIhRBAnQhIiATQQJ0ISNBASEKQQAhDQwBC0EAIQpBASEDA0AgCiAZTw0IIApBAWogGU8NBiAKQQRqIQogAiADSyADQQFqIQMNAAsMCAsDQCAKIQ4gDUECdCIKIBlPDQcgCkEBciINIBlPDQYgIyABIApqLQAAIgwgASANai0AACINQQh0ckHA/wNxQQZ2IgpsICIgDEE/cSIVbGohJCAXIAogE2wgFCAVbGpBAnRqISVBACEaQQAhCgJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkADQAJAAkACQAJ/AkACfyATIA1BCHQgDHJBwP8DcUEGdmxBAnQgFCAMQT9xbEECdGogCmogECAKICRqIhVNDQAaAkACQAJAIAogIGoiCyISIAVPDQAgBCAaaiIWIBEgCiAlaiISLQAAQQJ0aioCADgCACAVQQRqIBBPDQICQCAFIAtBA2pLBEAgFkEMaiARIBJBBGotAABBAnRqKgIAOAIAIBVBCGogEE8NAyALQQZqIAVPDQEgFkEYaiARIBJBCGotAABBAnRqKgIAOAIAIANBAUYNCSAVQQxqIBBJDQYgEyANQQh0IAxyQcD/A3FBBnZsQQJ0IBQgDEE/cWxBAnRqIApqQQxqDAcLIAtBA2ohEgwBCyALQQZqIRILIBIgBUGQ88cAEIwHAAsgEyANQQh0IAxyQcD/A3FBBnZsQQJ0IBQgDEE/cWxBAnRqIApqQQhqDAELIBMgDUEIdCAMckHA/wNxQQZ2bEECdCAUIAxBP3FsQQJ0aiAKakEEagsgEEGA88cAEIwHAAsCQAJAAkACQAJAIAogH2oiCyAHTw0AIAYgGmoiFiARIBJBDGotAABBAnRqKgIAOAIAIBVBEGogEE8NBAJAAkAgByALQQNqSwRAIBZBDGogESASQRBqLQAAQQJ0aioCADgCACAVQRRqIBBPDQYgByALQQZqSwRAIBZBGGogESASQRRqLQAAQQJ0aioCADgCACAVQRhqIBBPDQYgC0EJaiAHTw0CIBZBJGogESASQRhqLQAAQQJ0aioCADgCACAVQRxqIBBPDQUgC0EMaiAHTw0DIBZBMGogESASQRxqLQAAQQJ0aioCADgCACAhRQ0LIBVBIGogEEkNCiATIA1BCHQgDHJBwP8DcUEGdmxBAnQgFCAMQT9xbEECdGogCmpBIGoMGgsgC0EGaiELDAMLIAtBA2ohCwwCCyALQQlqIQsMAQsgC0EMaiELCyALIAdB8PLHABCMBwALIBMgDUEIdCAMckHA/wNxQQZ2bEECdCAUIAxBP3FsQQJ0aiAKakEcagwDCyATIA1BCHQgDHJBwP8DcUEGdmxBAnQgFCAMQT9xbEECdGogCmpBGGoMAgsgEyANQQh0IAxyQcD/A3FBBnZsQQJ0IBQgDEE/cWxBAnRqIApqQRRqDAELIBMgDUEIdCAMckHA/wNxQQZ2bEECdCAUIAxBP3FsQQJ0aiAKakEQagsgEEHg8scAEIwHAAsgCiAeaiILIAlPDQggCCAaaiIWIBEgEkEgai0AAEECdGoqAgA4AgAgFUEkaiAQTw0OIAtBA2ogCU8NByAWQQxqIBEgEkEkai0AAEECdGoqAgA4AgAgFUEoaiAQTw0NIAtBBmogCU8NBiAWQRhqIBEgEkEoai0AAEECdGoqAgA4AgAgFUEsaiAQTw0MIAtBCWogCU8NBSAWQSRqIBEgEkEsai0AAEECdGoqAgA4AgAgFUEwaiAQTw0LIAtBDGogCU8NBCAWQTBqIBEgEkEwai0AAEECdGoqAgA4AgAgFUE0aiAQTw0KIAtBD2ogCU8NAyAWQTxqIBEgEkE0ai0AAEECdGoqAgA4AgAgFUE4aiAQTw0JIAtBEmogCU8NASAWQcgAaiARIBJBOGotAABBAnRqKgIAOAIACyAaQQRqIRogCkEBaiIKQQNJDQEMDwsLIAtBEmohCwwFCyALQQ9qIQsMBAsgC0EMaiELDAMLIAtBCWohCwwCCyALQQZqIQsMAQsgC0EDaiELCyALIAlB0PLHABCMBwALIBMgDUEIdCAMckHA/wNxQQZ2bEECdCAUIAxBP3FsQQJ0aiAKakE4agwFCyATIA1BCHQgDHJBwP8DcUEGdmxBAnQgFCAMQT9xbEECdGogCmpBNGoMBAsgEyANQQh0IAxyQcD/A3FBBnZsQQJ0IBQgDEE/cWxBAnRqIApqQTBqDAMLIBMgDUEIdCAMckHA/wNxQQZ2bEECdCAUIAxBP3FsQQJ0aiAKakEsagwCCyATIA1BCHQgDHJBwP8DcUEGdmxBAnQgFCAMQT9xbEECdGogCmpBKGoMAQsgEyANQQh0IAxyQcD/A3FBBnZsQQJ0IBQgDEE/cWxBAnRqIApqQSRqCyAQQcDyxwAQjAcACyAeQRVqIR4gCEHUAGohCCAGQTxqIQYgH0EPaiEfIARBJGohBCAgQQlqISAgDiACIA5LIgtqIQogDiENIAsNAAsMBwtBjI3IAEEuQbyNyAAQ6wcLAAsMCQsMCAsgCkEBaiENCyANIBlBsPLHABCMBwALIAogGUGg8scAEIwHAAsCQCARQQRrKAIAIgJBeHFBhAhBiAggAkEDcSIDG08EQCADQQAgAkGoCE8bDQUgERCiAiAdBEAgAUEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgHWpJDQcgAkEAIAMgHUEnaksbDQYgARCiAgsgGARAIBdBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIBhqSQ0HIAFBACACIBhBJ2pLGw0GIBcQogILIAAoAgAiAQRAIBtBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0HIAJBACADIAFBJ2pLGw0GIBsQogILIAAoAgwiAEUEQEEAIRcMBQsgHEEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgAGpJDQZBACEXIAFFDQMgAiAAQSdqSw0BDAMLDAULDAMLIAAoAgAiAQRAIBtBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0EIAJBACADIAFBJ2pLGw0DIBsQogILIAAoAgwiAUUNASAAKAIQIhxBBGsoAgAiAEF4cSICQQRBCCAAQQNxIgAbIAFqSQ0DIABFIAIgAUEnak1yDQAMAgsgHBCiAgsgD0EgaiQAIBcPC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAvBHAMpfwN7C30jAEGwAmsiBCQAQQAQtgkhAyAEQQAQtgk2AsABIAQgAzYCvAEgBEEANgK4ASAEQgA3ArABIARCBDcCeCAEQgA3AnAgBEKAgICAwAA3AmggBEIENwJgIARCADcCWCAEQoCAgIDAADcCUCAEQQA2AjwgBEEANgI0IARBADYCLCAEQQA2AiQgBEEANgIcIARBADYCFCAEQQA2AgwgBEEANgJIIARBgICAgHg2ApgBIARBgICAgHg2AqQBIARBzAFqQQA6AAAgBEIENwKQASAEQgA3AogBIARCgICAgMAANwKAASAEQgA3AsQBIAEoAlwhFiAEIAI6ANgBIAQgFjYC1AEgBCABKAIIIgc2AtABIARBDGogBEHQAWoQ4QMCQAJAAkACQEGAgDAQcSIRRQ0AIBFBBGsiIS0AAEEDcQRAIBFBAEGAgDD8CwALQYCAEBBxIgtFDQAgC0EEayIiLQAAQQNxBEAgC0EAQYCAEPwLAAtBgIAwEHEiEkUNACASQQRrIiMtAABBA3EEQCASQQBBgIAw/AsAC0GAgDAQcSITRQ0AIBNBBGsiJC0AAEEDcQRAIBNBAEGAgDD8CwALQYCAwAAQcSIORQ0AIA5BBGsiJS0AAEEDcQRAIA5BAEGAgMAA/AsAC0GAgAgQcSIPRQ0AIA9BBGsiJi0AAEEDcQRAIA9BAEGAgAj8CwALQYCAEBBxIgxFDQAgDEEEayInKAIAIgNBA3EiBQRAIAxBAEGAgBD8CwALIAcEQCAPQQIgAhshKCAMQQQgAhshKUGAgARBACACGyEeQwAAgD8gASoCQCABLQBYQQJGIgMbQwAAAAAgASoCPCADGyIzkyE0QwAAEEEgASoCSCADG0MAAEDBIAEqAkQgAxsiNZNDAAB+Q5UhNiABKAIQISogASgCFCEfIAEoAgQhKwNAQYCABCAHIBBrIgMgA0GAgARPGyEZIAcgEEcEQCAQQRhsISBBACEIICshCSAqIRQgCyEaQQAhAyAMIRsgDiEKIA8hHANAIBoCfwJAIAcgCCAQaiIdSwRAIAkgIGoiBUERai8AACAFQRNqLQAAIgZBEHRyIg1BCHYhFSAFQQ5qLwEAIhcgBUEQai0AACIYQRB0ckH/AXGzQwAAf0OVITIgBf0AAgAhLEMAAAAAITFDAAAAACEvIA1B/wFxBEAgNSA2IA1BAWtB/wFxs5SSEIkEIS8LIBVB/wFxBEAgNSA2IBVBAWtB/wFxs5SSEIkEITELIDMgMiA0lJIhMiAzIBizQwAAf0OVIDSUkiEwIDMgF0EIdrNDAAB/Q5UgNJSSITcgBgR9IDUgNiAGQQFrQf8BcbOUkhCJBAVDAAAAAAshOCAFQRRqLwEAIQYgBUEWai0AACENIAMgEWoiFSAs/R8AOAIAIAMgEmoiFyAyOAIAIAMgE2oiGCAvOAIAIBVBBGogLP0fATgCACAXQQRqIDc4AgAgGEEEaiAxOAIAIBVBCGogLP0fAjgCACAXQQhqIDA4AgAgGEEIaiA4OAIAQwAAgD8gBkEIdrP9EyAGIA1BEHRyQf8BcbP9IAH9DAAAf0MAAH9DAAB/QwAAf0P95wEiLCAs/eQB/QwAAIC/AACAvwAAgL8AAIC//eQBIiz9HwEiMIuTICz9HwAiN4uTIjGMQwAAAAAQ4AghLyAKIA2zQwAAf0OVQwAAAD+UQ9sPSUCUIjgQmQIiMiAwIC8gL4wiOSAs/QwAAAAAAAAAAAAAAAAAAAAA/Ub9TSIs/ccB/RsCQQFxG5IiMCAxIDGUIDAgMJQgNyAvIDkgLP0bAEEBcRuSIi8gL5SSkpEiMJWU/RMgMiAvIDCVlP0gASAyIDEgMJWU/SACIDgQmwL9IAP9CwIAIAVBDGovAQAiBkH//wFxRQRAIAZBEHQMAwsgBkH/B3EhBSAGQYCAAnEhDSAGQYD4AXEiBkGA+AFGBEAgDUEQdCIGQYCAgPwHciAFRQ0DGiAGIAVBDXRyQYCAgP4HcgwDCyANQRB0IQ0gBkUNASAGQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2ogDXIMAgsgHSAHQdy7xwAQjAcACyAFIAVnQRBrIgVB//8DcUEIanRB////A3EgDUGAgIDYA3IgBUEXdGtyCzYCACACBEACfwJAIB0gH0kEQAJ/IBQgIGoiBkEUaigCACIFQQRLBEAgBkEEaigCACEFIAZBCGooAgAMAQsgBkEEagshBiAFDQFBACEFQQAMAgsgHSAfQcy7xwAQjAcMBwsgBigCAAshBiAcIAU7AQAgGyAGNgIACyAJQRhqIQkgFEEYaiEUIBpBBGohGiADQQxqIQMgG0EEaiEbIApBEGohCiAcQQJqIRwgCEEBaiIIIBlJDQALCyAEIB42ApwCIAQgKTYCmAIgBCAeNgKUAiAEICg2ApACIARBADYCjAIgBEKAgICAwAA3AoQCIARCgICAgMAANwL8ASAEQoCAkIDAADcC9AEgBCAONgLwASAEQYCADDYC7AEgBCATNgLoASAEQYCADDYC5AEgBCASNgLgASAEQYCABDYC3AEgBCALNgLYASAEQYCADDYC1AEgBCARNgLQASAEQQxqIBAgGSAEQdABahB+IBAgGWoiECAHSQ0ACyAnKAIAIgNBA3EhBQsCQAJAIANBeHFBhIAQQYiAECAFG08EQCAFQQAgA0GogBBPGw0GIAwQogIgJigCACICQXhxQYSACEGIgAggAkEDcSIDG0kNBSADQQAgAkGogAhPGw0GIA8QogIgJSgCACICQXhxQYSAwABBiIDAACACQQNxIgMbSQ0FIANBACACQaiAwABPGw0GIA4QogIgJCgCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBMQogIgIygCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBIQogIgIigCACICQXhxQYSAEEGIgBAgAkEDcSIDG0kNBSADQQAgAkGogBBPGw0GIAsQogIgISgCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBEQogIgFkUNBEGAgJABEHEiAkUNAyACQQRrIg4oAgAiA0EDcSIFBEAgAkEAQYCAkAH8CwALIAdFDQIgASgCICELIAEoAhwhD0EAIQkDQEGAgAQgByAJayIDIANBgIAETxshCiAHIAlHBEAgDyAJQQlsaiEFQQAhCCACIQMDQCALIAggCWoiDE0EQCAMIAtB/LvHABCMBwALIAVBBGr9XAAAISwgBf1cAAAhLSADQSBqIAVBCGosAACyQwAA/kKVOAIAIAMgLf2HAf2nAf36Af0MAAD+QgAA/kIAAP5CAAD+Qv3nAf0LAgAgA0EQaiAs/YcB/acB/foB/QwAAP5CAAD+QgAA/kIAAP5C/ecB/QsCACADQSRqIQMgBUEJaiEFIAhBAWoiCCAKSQ0ACwsgBEEMaiAJIAogAkGAgCQQ5gEgByAJIApqIglLDQALDAELDAQLIA4oAgAiA0EDcSEFCwJAAkAgA0F4cUGEgJABQYiAkAEgBRtPBEAgBUEAIANBqICQAU8bDQYgAhCiAiAWQQFGDQRBgIDwARBxIgJFDQMgAkEEayIOKAIAIgNBA3EiBQRAIAJBAEGAgPAB/AsACyAHRQ0CIAEoAiwhCyABKAIoIQ9BACEKA0BBgIAEIAcgCmsiAyADQYCABE8bIQkgByAKRwRAIA8gCkEPbGohBUEAIQggAiEDA0AgCyAIIApqIgxNBEAgDCALQYy8xwAQjAcACyAFQQRq/VwAACEsIAVBCGr9XAAAIS0gBUEMaiwAACEMIAVBDWosAAAhFCAF/VwAACEuIANBOGogBUEOaiwAALJDAAD+QpU4AgAgA0E0aiAUskMAAP5ClTgCACADQTBqIAyyQwAA/kKVOAIAIAMgLv2HAf2nAf36Af0MAAD+QgAA/kIAAP5CAAD+Qv3nAf0LAgAgA0EgaiAt/YcB/acB/foB/QwAAP5CAAD+QgAA/kIAAP5C/ecB/QsCACADQRBqICz9hwH9pwH9+gH9DAAA/kIAAP5CAAD+QgAA/kL95wH9CwIAIANBPGohAyAFQQ9qIQUgCEEBaiIIIAlJDQALCyAEQQxqIAogCSACQYCAPBCnASAHIAkgCmoiCksNAAsMAQsMBAsgDigCACIDQQNxIQULAkAgA0F4cUGEgPABQYiA8AEgBRtPBEAgBUEAIANBqIDwAU8bDQUgAhCiAiAWQQJNDQNBgIDQAhBxIgJFDQIgAkEEayIJKAIAIgNBA3EiBQRAIAJBAEGAgNAC/AsACyAHBEAgASgCOCEKIAEoAjQhC0EAIQgDQEGAgAQgByAIayIBIAFBgIAETxshASAHIAhHBEBBACEDIAIhBQNAIARB0AFqIAsgCiADIAhqELoGIAUgBP0ABNAB/QsCACAFQRBqIAT9AATgAf0LAgAgBUEgaiAE/QAE8AH9CwIAIAVBMGogBP0ABIAC/QsCACAFQUBrIAT9AASQAv0LAgAgBUHQAGogBCoCoAI4AgAgBUHUAGohBSADQQFqIgMgAUkNAAsLIARBDGogCCABIAJBgIDUABCUASABIAhqIgggB0kNAAsgCSgCACIDQQNxIQULIANBeHFBhIDQAkGIgNACIAUbSQ0EIAVBACADQaiA0AJPGw0BIAIQogIMAwsMAwsMAwsACwJAIARBDGoiARDUASICBEAgAEECNgIAIAAgAjYCBCABEIoCDAELIAAgBEEMakHEAfwKAAALIARBsAJqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu+HQIQfwR+IwBB4AFrIgIkACABKAIMIQYCQAJAAkACQAJAAkACfwJAAkACQCABKAIUIgQgASgCECIDSQRAA0AgBCAGai0AACIIQQlrIgVBF0tBASAFdEGTgIAEcUVyDQIgASAEQQFqIgQ2AhQgAyAERw0ACyADIQQLIAJBCGogBiADIARBAWoiASADIAEgA0kbEPkBIAIoAgwhAyACKAIIIQFBFBBxIgVFDQEgBSABNgIMIAVBBTYCACAAIAU2AgQgAEGAgICAeDYCACAFIAM2AhAMBwsCQAJAAkACQCAIQdsARgRAIAEgAS0AGEEBayIFOgAYIARBAWohBCAFQf8BcUUNBCABIAQ2AhQgAkEBOgA4IAIgATYCNCACQQA2AkQgAkKAgICAgAE3AjwgAkHIAWohECACQaABaiEPIAJB4ABqIRFBCCEJA0AgAkGYAWogAkE0ahCfAyACLQCYAUEBRgRAIAIoApwBIQkMCAsCQAJAIAItAJkBQQFGBEAgAigCNCIHKAIMIQYCQCAHKAIUIgQgBygCECIDSQRAA0AgBCAGai0AACIIQQlrIgVBF0tBASAFdEGTgIAEcUVyDQIgByAEQQFqIgQ2AhQgAyAERw0ACyADIQQLIAJBKGogBiADIARBAWoiBSADIAMgBUsbEPkBIAIoAiwhBSACKAIoIQNBFBBxIglFDQogCSADNgIMIAlBBTYCACAJIAU2AhAMCwsCQAJAIAhB2wBHBEAgCEH7AEYNASAHIAJB3wFqQfjAwQAQ7gEhBQwKCyAHIActABhBAWsiBToAGCAEQQFqIQQgBUH/AXFFDQcgByAENgIUIAIgBzYC1AEgAkEBOgDYASACQZgBaiACQdQBahCfAwJAAn8gAi0AmAFBAUYEQCACKAKcAQwBCwJAAkACQAJAAkACQAJAIAItAJkBQQFGBEAgAkGYAWogAigC1AEQuwMgAigCmAFBAUYEQCACKAKcAQwJCyACKQOgASESIAJBmAFqIAJB1AFqEJ8DIAItAJgBQQFGBEAgAigCnAEMCQsgAi0AmQFBAUcNAiACQZgBaiACKALUARC7AyACKAKYAUEBRw0BIAIoApwBDAgLQQBBgILBAEGA/cAAENsGDAcLIAIpA6ABIRMgAkGYAWogAkHUAWoQnwMgAi0AmAFBAUYEQCACKAKcAQwHCyACLQCZAUEBRw0CIAJBmAFqIAIoAtQBEKUCIAIoApgBIgRBAkcNASACKAKcAQwGC0EBQYCCwQBBgP3AABDbBgwFCyACKAKcASEFIAJBmAFqIAJB1AFqEJ8DIAItAJgBQQFGBEAgAigCnAEMBQsgAi0AmQFBAUcNAiACQZgBaiACKALUARClAiACKAKYASIKQQJHDQEgAigCnAEMBAtBAkGAgsEAQYD9wAAQ2wYMAwsgAigCnAEhCyACQZgBaiACQdQBahCfAyACLQCYAUEBRgRAIAIoApwBDAMLIAItAJkBQQFHDQEgAkGYAWogAigC1AEQ3AIgAigCnAEiAyACKAKYASIGQYGAgIB4Rg0CGiACKAKgASEOIAMhCCAFIQMMAwtBA0GAgsEAQYD9wAAQ2wYMAQtBBEGAgsEAQYD9wAAQ2wYLIQNBAiEECyAHIActABhBAWo6ABggAiAHELoDIgU2AsgBIAIgDjYCwAEgAiAINgK8ASACIAY2ArgBIAIgEzcDsAEgAiASNwOoASACIAs2AqQBIAIgCjYCoAEgAiADNgKcASACIAQ2ApgBAkAgBEECRwRAIAUNASACQZABaiAPQSBqKQMANwMAIAJBgAFqIA9BEGr9AAMA/QsDACACIA/9AAMA/QsDcCADIQUMBgtBAiEEIAUEQCAQELEECyADIQUMBQtBAiEEIAZBgICAgHhyQYCAgIB4Rg0EIAhBBGsoAgAiA0F4cSIKQQRBCCADQQNxIgMbIAZqSQ0BIANBACAKIAZBJ2pLGw0TIAgQogIMBAsgByAHLQAYQQFrIgU6ABggBEEBaiEEIAVB/wFxRQ0CIAcgBDYCFCACQQE6ANgBIAIgBzYC1AFCACEUQQIhDkGBgICAeCEFQQIhC0IAIRUCQANAAkAgAkGYAWogAkHUAWoQ0QIgAi0AmAFBAUYEQCACKAKcASEDDAELAkAgAi0AmQFBAUYEQCACKALUASIEQQA2AgggBCAEKAIUQQFqNgIUIAJBmAFqIARBDGogBBCCAiACKAKcASEDIAIoApgBQQJGDQICQAJAAkACQAJAAkACQAJAAkAgAigCoAFBBGsOBQIAAQoDCgsgA0G1mMgAQQUQ2wdFDQQgA0Gr/MAAQQUQ2wcNCSAOQQJGDQZBq/zAAEEFEJ8HIQMMCgsgA0HMgcEAQQYQ2wdFDQIMCAsgAygAAEHiws2rBkcNByALQQJGDQNB9IDBAEEEEJ8HIQMMCAsgAykAAELm0rGr5q3YtuUAUg0GIAVBgYCAgHhGDQRBAiEEQdKBwQBBCBCfByEDIAVBgICAgHhyQYCAgIB4Rg0JIAYgBUEBEKIHDAkLIBVQRQRAQcyBwQBBBhCfByEDDAcLIAJBmAFqIAQQqwUgAigCmAFBAUYEQCACKAKcASEDDAcLIAIpA6ABIRNCASEVDAcLIBRQRQRAQbWYyABBBRCfByEDDAYLIAJBmAFqIAQQqwUgAigCmAFBAUYEQCACKAKcASEDDAYLIAIpA6ABIRJCASEUDAYLIAJBmAFqIAQQrgUgAigCnAEhDSACKAKYASILQQJHDQUgDSEDDAQLIAJBmAFqIAQQrgUgAigCnAEhCiACKAKYASIOQQJHDQQgCiEDDAMLIAJBmAFqIAQQrQUgAigCoAEhCCACKAKcASEGIAIoApgBIgVBgYCAgHhHDQNBAiEEIAYhAwwECyAVUARAQcyBwQBBBhCcByEDDAILIBRQBEBBtZjIAEEFEJwHIQMMAgsgC0EAIAtBAkcbIQRBgICAgHggBSAFQYGAgIB4RhshCyAOQQAgDkECRxshDiANIQMMAwsgBBCgASIDRQ0BCwtBAiEEIAVFIAVBgoCAgHhIcg0AIAZBBGsoAgAiCEF4cSIKQQRBCCAIQQNxIggbIAVqSQ0SIAhBACAKIAVBJ2pLGw0TIAYQogILIAcgBy0AGEEBajoAGCACIAcQ4gQiBTYCyAEgAiAINgLAASACIAY2ArwBIAIgCzYCuAEgAiASNwOwASACIBM3A6gBIAIgCjYCpAEgAiAONgKgASACIAM2ApwBIAIgBDYCmAECQAJAAkAgBEECRwRAIAUNASACQZABaiAPQSBqKQMANwMAIAJBgAFqIA9BEGr9AAMA/QsDACACIA/9AAMA/QsDcCADIQUMBwtBAiEEIAUNASADIQUMBgtBAiEEIAtBgICAgHhyQYCAgIB4Rg0FIAZBBGsoAgAiA0F4cSIIQQRBCCADQQNxIgMbIAtqSQ0TIANBACAIIAtBJ2pLGw0BIAYQogIMBQsgEBCxBCADIQUMBAsMEgsMEAsgAigCPCEIDAsLIAJBIGogBiADIAQgAyADIARLGxD5ASACKAIkIQQgAigCICEDQRQQcSIJDQQMBwsgBEECRg0EIAJB6ABqIAJBkAFqKQMANwMAIAJB2ABqIAJBgAFq/QADAP0LAwAgAiAC/QADcP0LA0ggAigCPCAMRgRAIwBBIGsiByQAAkAgAkE8aiIJKAIAIgZB1arVCksEf0EABUEEIAZBAXQiAyADQQRNGyIIQTBsIQMgByAGBH8gByAGQTBsNgIcIAcgCSgCBDYCFEEIBUEACzYCGCAHQQhqQQggAyAHQRRqEIUHIAcoAghBAUcNASAHKAIQIQkgBygCDAsgCUHUgsEAEJMJAAsgBygCDCEDIAkgCDYCACAJIAM2AgQgB0EgaiQAIAIoAkAhCQsgCSAMQTBsaiIDIAU2AgQgAyAENgIAIAMgAikDSDcCCCADQRBqIAJB0ABq/QADAP0LAgAgA0EgaiAR/QADAP0LAgAgAiAMQQFqIgw2AkQMAAsACyABIAJB3wFqQfi/wQAQ7gEhCQwICyACQRhqIAYgAyAEIAMgAyAESxsQ+QEgAigCHCEEIAIoAhghA0EUEHEiCUUNAwsgCSADNgIMIAlBGDYCACAJIAQ2AhAMAwsgBSAHEOsFIQkgAigCRAwDCyACQRBqIAYgAyAEIAMgAyAESxsQ+QEgAigCFCEDIAIoAhAhAUEUEHEiBUUNACAFIAE2AgwgBUEYNgIAIAAgBTYCBCAAQYCAgIB4NgIAIAUgAzYCEAwGCwALIAwLIQMgAigCQCEGIAMEQCAGQSRqIQQDQCAEQQRrKAIAIghBgICAgHhyQYCAgIB4RwRAIAQoAgAiCkEEaygCACIFQXhxIg1BBEEIIAVBA3EiBRsgCGpJDQcgBUEAIA0gCEEnaksbDQggChCiAgsgBEEwaiEEIANBAWsiAw0ACwtBgICAgHghCCACKAI8IgVFDQAgBkEEaygCACIDQXhxIg0gBUEwbCIFQQRBCCADQQNxIgMbckkNBCADQQAgDSAFQSdqSxsNBSAGEKICCyABIAEtABhBAWo6ABggAiABELoDIgM2AqQBIAIgDDYCoAEgAiAJNgKcASACIAg2ApgBIAhBgICAgHhHBEAgA0UNAiAMBEAgCUEkaiEEA0AgBEEEaygCACIGQYCAgIB4ckGAgICAeEcEQCAEKAIAIgpBBGsoAgAiBUF4cSINQQRBCCAFQQNxIgUbIAZqSQ0HIAVBACANIAZBJ2pLGw0IIAoQogILIARBMGohBCAMQQFrIgwNAAsLIAgEQCAJQQRrKAIAIgVBeHEiBCAIQTBsIg1BBEEIIAVBA3EiBRtySQ0FIAVBACAEIA1BJ2pLGw0GIAkQogILIAMhCQwBCyADRQ0AIAJBpAFqELEECyAJIAEQ6wUhASAAQYCAgIB4NgIAIAAgATYCBAwBCyAAIAw2AgggACAJNgIEIAAgCDYCAAsgAkHgAWokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC8EZAhh/AXsjAEHgCmsiCyQAIAtBOGoiDf0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgC0EoaiIQICP9CwMAIAtBGGoiFCAj/QsDACALICP9CwMIAn8CQCABRQ0AIAtBxABqIQ8gASEOIAAhDAJAA0AgDC0AACITQRBJBEAgC0EIaiATQQJ0aiITIBMoAgBBAWo2AgAgDEEBaiEMIA5BAWsiDg0BDAILCyATQRBBwLTEABCMBwALQQEhDkEAIQxBDyALKAJEDQEaIAsoAkBFDQAgC0FAayEPQQ4MAQtBASEOIAsoAjwEQCALQTxqIQ9BDQwBCyALKAI4BEAgDSEPQQwMAQsgCygCNARAIAtBNGohD0ELDAELIAsoAjAEQCALQTBqIQ9BCgwBCyALKAIsBEAgC0EsaiEPQQkMAQsgCygCKARAIBAhD0EIDAELIAsoAiQEQCALQSRqIQ9BBwwBCyALKAIgBEAgC0EgaiEPQQYMAQsgCygCHARAIAtBHGohD0EFDAELIAsoAhgEQCAUIQ9BBAwBCyALKAIUBEAgC0EUaiEPQQMMAQsgCygCEARAIAtBEGohD0ECDAELIAtBCGpBBHIhD0EBIQxBACEOQQELIRYCfwJAIAlFDQAgDCALKAIMQQFGcUUNAAJAIAEEQEEAIQwDQCAAIAxqLQAAQQFGDQIgASAMQQFqIgxHDQALC0HQscQAEN0JAAsgBSAMSwRAIAQgDEEBdGpBADsBACADIAxLIgAEfyACIAxBAnRqKAIABSAOCyAMQRB0IAAbQQFyIQACQANAIAYgADYCACAHQQFGDQEgBkEANgIEIAZBAiAHIAdBAk8bIgFBAnRqIQYgByABayIHDQALQQEMAwtBAUEBQfCxxAAQjAcACyAMIAVB4LHEABCMBwALIAtB+ABqICP9CwMAIAtB6ABqICP9CwMAIAtB2ABqICP9CwMAIAsgI/0LA0ggCyALKAIIIhE2AkxBACEMAkAgDgR/IAsgESALKAIMIgxqIg02AlACQCAWQQFqIg5BA0YNACALIA0gCygCECIJaiINNgJUIAkgDEEBdGohDCAOQQRGDQAgCyANIAsoAhQiCWoiDTYCWCAJIAxBAXRqIQwgDkEFRg0AIAsgDSALKAIYIglqIg02AlwgCSAMQQF0aiEMIA5BBkYNACALIA0gCygCHCIJaiINNgJgIAkgDEEBdGohDCAOQQdGDQAgCyANIAsoAiAiCWoiDTYCZCAJIAxBAXRqIQwgDkEIRg0AIAsgDSALKAIkIglqIg02AmggCSAMQQF0aiEMIA5BCUYNACALIA0gCygCKCIJaiINNgJsIAkgDEEBdGohDCAOQQpGDQAgCyANIAsoAiwiCWoiDTYCcCAJIAxBAXRqIQwgDkELRg0AIAsgDSALKAIwIglqIg02AnQgCSAMQQF0aiEMIA5BDEYNACALIA0gCygCNCIJaiINNgJ4IAkgDEEBdGohDCAOQQ1GDQAgCyANIAsoAjgiCWoiDTYCfCAJIAxBAXRqIQwgDkEORg0AIAsgDSALKAI8IglqIg02AoABIAkgDEEBdGohDCAOQQ9GDQAgCyANIAsoAkAiDmo2AoQBIA4gDEEBdGohDAsgDEEBdAUgDAsgDygCAGoiHUEBIBZ0Ih5HDQAgC0G4AWogC0H4AGr9AAMA/QsDACALQagBaiALQegAav0AAwD9CwMAIAtBmAFqIAtB2ABq/QADAP0LAwAgCyAL/QADSP0LA4gBIAtByAFqQQBBgAn8CwACQAJAIAEEQEEAIQwDQCAAIAxqLQAAIg5BD0sNAiALQYgBaiAOQQJ0aiINKAIAIg5BoAJPDQMgDSAOQQFqNgIAIAtByAFqIA5BAnRqIAw2AgAgASAMQQFqIgxHDQALC0F/IAdnIh9BH3MiF3RBf3MhGkEAIQBBASESA0ACQAJAAkACQAJAIBJBEEkEQEEBIBJ0IRUgC0EIaiASQQJ0aigCACIPBEBBoAIgESARQaACTRshECAVQQFrIQEgC0HIAWogEUECdGohDSAAIQ4DQCAQIBFGDQYgDSgCACIAIANJIhQEQCACIABBAnRqKAIAIQkLIAcgDkH//wNxIgxNDQUgBiAMQQJ0aiAJIABBEHQgFBsgEnI2AgAgACAFTw0EIAQgAEEBdGogDjsBACARQQFqIREgDUEEaiENIAEiAEH//wNxIAxHBEBBASABIA5zQRB0Z0EPc3QiAEEBayAOcSAAciEACyAAIQ4gD0EBayIPDQALCyAKDQEMBQsgEkEQQeCyxAAQjAcACyASQQFrIhlBAkkNAyASQYCEAnIhIEEBIQFBAiEMA0AgASETIAwhAQJAIBNBEEkEQCATQQJ0IgwgC0HIAGoiDmooAgAiDSALQYgBaiAMaigCACIbTw0BIBIgE2siDEEPTQRAIA4gDEECdCIMaigCACIPIAtBiAFqIAxqKAIAIhxPDQIgDSANIBtJaiEMIAtByAFqIA9BAnRqIRQDQCAMIRACQAJAAkACQAJAAkAgDUGgAkkEQCAPIQwgFCEOIAUgC0HIAWogDUECdGooAgAiDU0EQANAIAxBnwJLDQMgDigCACANckGAAkkNBSAOQQRqIQ4gHCAMQQFqIgxHDQAMCAsACyAEIA1BAXRqISEgDUEQdCAgciEiA0AgDEGfAksNAyAOKAIAIhggDXJB/wFNBEAgBSAYTQ0GIAcgIS8BACAEIBhBAXRqLwEAIBN0Qf//A3FyIglNDQcgBiAJQQJ0aiAYQRh0ICJyNgIACyAOQQRqIQ4gDEEBaiIMIBxHDQALDAYLIA1BoAJBoLPEABCMBwALQaACIA8gD0GgAk0bIQwLIAxBoAJBsLPEABCMBwALIA0gBUHAs8QAEIwHAAsgGCAFQdCzxAAQjAcACyAJIAdB4LPEABCMBwALIBAgECAbSSIOaiEMIBAhDSAODQALDAILIAxBEEGQs8QAEIwHAAsgE0EQQYCzxAAQjAcACyABIAEgGUkiDmohDCAODQALDAMLIAAgBUGQtMQAEIwHAAsgDCAHQYC0xAAQjAcACyARQaACQfCzxAAQjAcACwJAIBIgF0kiAUUNAAJAIAcgFU8EQCAVIAcgFWtLDQFBBCASdCIMRQ0CIAYgFUECdGogBiAM/AoAAAwCC0EAIBUgB0HwssQAEOoHAAsgC0EANgLYCiALQQE2AswKIAtB1JzIADYCyAogC0IENwLQCiALQcgKakHwssQAEI0IAAsgEiAXSQRAIAEgEmoiEiAXTQ0BCwsgCEEANgIIIBYgF00NAkEgIB9rIhAgFksNAkEAIQFBACENQQAhAkH//wMhAwNAAkAgC0EIaiAQQQJ0aigCACIJRQ0AQaACIBEgEUGgAk0bIRJBASAQIBdrIgp0IhRBAWsiFUGAwAFyIRhBAiAKQR9xIhl0QQJrIRNBfyAQdEF/cyEKIAtByAFqIBFBAnRqIQ4gACEMAkACQAJAA0ACQCAMIBpxIgBB//8DcSIPIANB//8DcUcEQCAHIA9NDQEgBiAPQQJ0aiANQRB0IBhyNgIAIAgoAgAgDSIBayAUSQRAIAggDSAUQQJBAhCkBSAIKAIIIQELIAgoAgQiAyABQQF0aiEPIBkEfyATBEAgD0EAIBP8CwALIAMgASAUakEBdGpBAmshDyABIBVqBSABCyECIA9BADsBACAIIAJBAWoiATYCCCAAIQMgDSECCyARIBJGDQIgDigCACIAIAVPDQMgBCAAQQF0aiAMOwEAIAIgDEH//wNxIg8gF3ZqIg0gAU8NBCAIKAIEIA1BAXRqIABBBHQgEGo7AQAgEUEBaiERIA5BBGohDiABIQ0gCiIAQf//A3EgD0cEQEEBIAAgDHNBEHRnQQ9zdCIAQQFrIAxxIAByIQALIAAhDCAJQQFrIgkNAQwFCwsgDyAHQaCyxAAQjAcACyARQaACQbCyxAAQjAcACyAAIAVBwLLEABCMBwALIA0gAUHQssQAEIwHAAsCQCAQIBZPIgwNACADQf//A3EiCSAAIBpxQf//A3FHDQAgASACTwRAIAEgAmsiCiAIKAIAIAFrSwRAIAggASAKQQJBAhCkBSAIKAIIIQELIApBAXQiDgRAIAgoAgQiDSABQQF0aiANIAJBAXRqIA78CgAACyAIIAEgCmoiATYCCCAHIAlLBEAgBiAJQQJ0aiABIAJBf3NqIAJBEHRyQYDAAXI2AgAgASENDAILIAkgB0GQssQAEIwHAAsgAiABIAFBgLLEABDqBwALIAwNAyAQIBAgFklqIhAgFk0NAAsMAgsgDkEQQaC0xAAQjAcACyAOQaACQbC0xAAQjAcACyAdIB5GCyALQeAKaiQAC9AjAiZ7E38CQAJAAkACQAJAAkAgAUECSwRAIANFDQEgBUUNAiAHRQ0DIABB/wEgAi0AAEGFlQFsQQh2IjEgBC0AACIvQZqCAmxBCHZqQZWKAWtBBnUiNEEAIDRBAEobIjQgNEH/AU4bOgACIABB/wEgMSAGLQAAIjVBpcwBbEEIdmpBmu8Aa0EGdSI0QQAgNEEAShsiNCA0Qf8BThs6AAAgAEH/ASAxIC9BkzJsQQh2IDVBiOgAbEEIdmprQYTEAGpBBnUiMUEAIDFBAEobIjEgMUH/AU4bOgABIAJBAWohNCADQQFrIgNBfnEhOyAAQQNqITEgA0EBcSE+IAFBA2siASABQQZwIjxrIjlBBkkNBiADQQF2IgMiASA5QQZrIi5BBm4iMiABIDJJGyIBIAdBAWsiMCIyIAEgMkkbIgEgBUEBayIzIjIgASAySRsiAUEQSQ0EIDEgAiADIC5BBm4iLiADIC5JGyIDIDAiLiADIC5JGyIDIDMiLiADIC5JGyIDQQF0akEDakkgNCAAIANBBmxqQQlqIgBJcQ0EIDEgBCADQQJqIgJqSSAAIARLcSAxIAIgBmpJIAAgBktxcg0EIAFBAWoiAEEPcSICQRAgAhsiAiABQX9zaiE2IAcgACACayIwayE6IAYgMGohLiAFIDBrIQMgBCAwaiEyIDQgMEEBdCIAaiECIDsgAGshASAxIDBBBmxqIQAgOSAwQXpsaiE9IC/9DyEZIDX9DyEUIAQhNSAGITAgMSEvIDQhMwNAIC8gM/0AAAAiGiAU/Q0AAgQGAAAAAAAAAAAAAAAA/YkB/akB/QyFSgAAhUoAAIVKAACFSgAAIgz9tQFBCP2tASIkIBQgMEEBav0AAAAiFP0NDxAREhMUFRYXGBkaGxwdHv2JASII/QwJAAkACQAJAAkACQAJAAkAIg39lQEgFP2JASIT/Y4BIBMgCP2OAf0MAwADAAMAAwADAAMAAwADACIO/ZUB/Y4B/QwIAAgACAAIAAgACAAIAAgAIg/9jgFBBP2NASIJ/akBIhH9DCVmAAAlZgAAJWYAACVmAAAiFf21AUEI/a0B/a4B/QxmyP//Zsj//2bI//9myP//Ihb9rgFBBv2sAf0MAAAAAAAAAAAAAAAAAAAAACII/bgB/Qz/AAAA/wAAAP8AAAD/AAAAIgr9tgEgGiAI/Q0ICgwOAAAAAAAAAAAAAAAA/YkB/akBIAz9tQFBCP2tASIlIAn9qgEiCyAV/bUBQQj9rQH9rgEgFv2uAUEG/awBIAj9uAEgCv22Af0NAAQIDBAUGBwAAAAAAAAAACAz/QAAECIhIAj9DQACBAYAAAAAAAAAAAAAAAD9iQH9qQEgDP21AUEI/a0BIiYgFCAI/Q0HCAkKCwwNDgAAAAAAAAAA/YkBIgkgDf2VASAU/YoBIhv9jgEgGyAJ/Y4BIA79lQH9jgEgD/2OAUEE/Y0BIhL9qQEiFyAV/bUBQQj9rQH9rgEgFv2uAUEG/awBIAj9uAEgCv22ASIJ/RsA/RcIIAn9GwH9FwkgCf0bAv0XCiAJ/RsD/RcLICEgCP0NCAoMDgAAAAAAAAAAAAAAAP2JAf2pASAM/bUBQQj9rQEiECAS/aoBIiAgFf21AUEI/a0B/a4BIBb9rgFBBv2sASAI/bgBIAr9tgEiCf0bAP0XDCAJ/RsB/RcNIAn9GwL9Fw4gCf0bA/0XDyIcICQgGSA1QQFq/QAAACIZ/Q0PEBESExQVFhcYGRobHB0e/YkBIgkgDf2VASAZ/YkBIhj9jgEgGCAJ/Y4BIA79lQH9jgEgD/2OAUEE/Y0BIh39qQEiJ/0MExkAABMZAAATGQAAExkAACIJ/bUBQQj9rQEgEf0MCDQAAAg0AAAINAAACDQAACIR/bUBQQj9rQH9rgH9sQH9DAQiAAAEIgAABCIAAAQiAAAiEv2uAUEG/awBIAj9uAEgCv22ASAlIB39qgEiKCAJ/bUBQQj9rQEgCyAR/bUBQQj9rQH9rgH9sQEgEv2uAUEG/awBIAj9uAEgCv22Af0NAAQIDBAUGBwAAAAAAAAAACAmIBkgCP0NBwgJCgsMDQ4AAAAAAAAAAP2JASILIA39lQEgGf2KASId/Y4BIB0gC/2OASAO/ZUB/Y4BIA/9jgFBBP2NASIe/akBIikgCf21AUEI/a0BIBcgEf21AUEI/a0B/a4B/bEBIBL9rgFBBv2sASAI/bgBIAr9tgEiC/0bAP0XCCAL/RsB/RcJIAv9GwL9FwogC/0bA/0XCyAQIB79qgEiHiAJ/bUBQQj9rQEgICAR/bUBQQj9rQH9rgH9sQEgEv2uAUEG/awBIAj9uAEgCv22ASIL/RsA/RcMIAv9GwH9Fw0gC/0bAv0XDiAL/RsD/RcPIhf9DQAAAAAOHgAAAAAPHwAAAAAgECAe/QwagQAAGoEAABqBAAAagQAAIgv9tQFBCP2tAf2uAf0M67r//+u6///ruv//67r//yIQ/a4BQQb9rAEgCP24ASAK/bYBIh4gISAI/Q0JCw0PAAAAAAAAAAAAAAAA/YkB/akBIAz9tQFBCP2tASIgIBsgDf2VASAw/QAAACIf/YoBIiL9jgEgIiAb/Y4BIA79lQH9jgEgD/2OAUEE/Y0BIiL9qgEiKiAV/bUBQQj9rQH9rgEgFv2uAUEG/awBIAj9uAEgCv22ASIr/Q0EFAAAAAAIGAAAAAAMHAAA/Q0QEQAABAUWFwAACgscHQAAIBogCP0NAQMFBwAAAAAAAAAAAAAAAP2JAf2pASAM/bUBQQj9rQEiGyAYIA39lQEgNf0AAAAiLP2JASIj/Y4BICMgGP2OASAO/ZUB/Y4BIA/9jgFBBP2NASIY/akBIiMgCf21AUEI/a0BIBMgDf2VASAf/YkBIh/9jgEgHyAT/Y4BIA79lQH9jgEgD/2OAUEE/Y0BIhP9qQEiHyAR/bUBQQj9rQH9rgH9sQEgEv2uAUEG/awBIAj9uAEgCv22ASAaIAj9DQkLDQ8AAAAAAAAAAAAAAAD9iQH9qQEgDP21AUEI/a0BIhogGP2qASIYIAn9tQFBCP2tASAT/aoBIi0gEf21AUEI/a0B/a4B/bEBIBL9rgFBBv2sASAI/bgBIAr9tgH9hgEgISAI/Q0BAwUHAAAAAAAAAAAAAAAA/YkB/akBIAz9tQFBCP2tASITIB0gDf2VASAs/YoBIgz9jgEgDCAd/Y4BIA79lQH9jgEgD/2OAUEE/Y0BIgz9qQEiDSAJ/bUBQQj9rQEgIv2pASIOIBH9tQFBCP2tAf2uAf2xASAS/a4BQQb9rAEgCP24ASAK/bYBICAgDP2qASIPIAn9tQFBCP2tASAqIBH9tQFBCP2tAf2uAf2xASAS/a4BQQb9rAEgCP24ASAK/bYB/YYB/WYiDP0NAAEdAAQFBgceAAoLDA0fACAbICMgC/21AUEI/a0B/a4BIBD9rgFBBv2sASAI/bgBIAr9tgEgGiAYIAv9tQFBCP2tAf2uASAQ/a4BQQb9rAEgCP24ASAK/bYB/YYBIBMgDSAL/bUBQQj9rQH9rgEgEP2uAUEG/awBIAj9uAEgCv22ASAgIA8gC/21AUEI/a0B/a4BIBD9rgFBBv2sASAI/bgBIAr9tgH9hgH9ZiIN/Q0AAQIdBAUGBwgeCgsMDQ4f/QsAUCAvIBwgF/0NAAALGwAAAAAMHAAAAAANHSAmICkgC/21AUEI/a0B/a4BIBD9rgFBBv2sASAI/bgBIAr9tgEiDyATIA4gFf21AUEI/a0B/a4BIBb9rgFBBv2sASAI/bgBIAr9tgEiDv0NAAAAAAwcAAAAAAAAAAAAACAe/RsA/RcKICv9GwD9Fwv9DQAAAgMUFQAACAkaGwAADg8gDP0NGgACAwQFGwAICQoLHAAODyAN/Q0AGgIDBAUGGwgJCgsMHA4P/QsAQCAvIBwgF/0NCBgAAAAACRkAAAAAChoAACAPIA79DQAAABAAAAAABBQAAAAACBj9DQABEhMAAAYHGBkAAAwNHh8gDP0NAAECAxgABgcICRkADA0ODyAN/Q0AAQIDBBgGBwgJChkMDQ4P/QsAMCAvIBwgF/0NAAAAAAYWAAAAAAcXAAAAACAlICggC/21AUEI/a0B/a4BIBD9rgFBBv2sASAI/bgBIAr9tgEiDiAaIC0gFf21AUEI/a0B/a4BIBb9rgFBBv2sASAI/bgBIAr9tgEiD/0NBBQAAAAACBgAAAAADBwAAP0NEBEAAAQFFhcAAAoLHB0AACAM/Q0AARUABAUGBxYACgsMDRcAIA39DQABAhUEBQYHCBYKCwwNDhf9CwAgIC8gHCAX/Q0AAAMTAAAAAAQUAAAAAAUVICQgJyAL/bUBQQj9rQH9rgEgEP2uAUEG/awBIAj9uAEgCv22ASIJIBsgHyAV/bUBQQj9rQH9rgEgFv2uAUEG/awBIAj9uAEgCv22ASII/Q0AAAAADBwAAAAAAAAAAAAAIA79GwD9FwogD/0bAP0XC/0NAAACAxQVAAAICRobAAAODyAM/Q0SAAIDBAUTAAgJCgsUAA4PIA39DQASAgMEBQYTCAkKCwwUDg/9CwAQIC8gHCAX/Q0AEAAAAAABEQAAAAACEgAAIAkgCP0NAAAAEAAAAAAEFAAAAAAIGP0NAAESEwAABgcYGQAADA0eHyAM/Q0AAQIDEAAGBwgJEQAMDQ4PIA39DQABAgMEEAYHCAkKEQwNDg/9CwAAIDVBEGohNSAwQRBqITAgL0HgAGohLyAzQSBqITMgNkEQaiI2DQALIBn9Fg8hLyAU/RYPITUMBQtBAEEDIAFBmOvEABDqBwALQQBBAEGo68QAEIwHAAtBAEEAQbjrxAAQjAcAC0EAQQBByOvEABCMBwALIAQhMiAFIQMgBiEuIAchOiA5IT0gMSEAIDshASA0IQILA0AgAUUgA0ECSXIgOkEBTXINASAAQQJqQf8BIAItAABBhZUBbEEIdiI2IC9B/wFxIjNBCWwgMkEBaiIwLQAAIi9qIC8gM2pBA2xqQQhqQQR2Ij9BmoICbEEIdmpBlYoBa0EGdSIzQQAgM0EAShsiMyAzQf8BThs6AAAgAEH/ASA2IDVB/wFxIjdBCWwgLkEBaiIzLQAAIjVqIDUgN2pBA2xqQQhqQQR2IkBBpcwBbEEIdmpBmu8Aa0EGdSI3QQAgN0EAShsiNyA3Qf8BThs6AAAgAEEFakH/ASACQQFqLQAAQYWVAWxBCHYiNyAyLQAAIjIgL0EJbGogLyAyakEDbGpBCGpBBHYiMkGaggJsQQh2akGVigFrQQZ1IjhBACA4QQBKGyI4IDhB/wFOGzoAACAAQQNqQf8BIDcgLi0AACIuIDVBCWxqIC4gNWpBA2xqQQhqQQR2Ii5BpcwBbEEIdmpBmu8Aa0EGdSI4QQAgOEEAShsiOCA4Qf8BThs6AAAgAEEBakH/ASA2ID9BkzJsQQh2IEBBiOgAbEEIdmprQYTEAGpBBnUiNkEAIDZBAEobIjYgNkH/AU4bOgAAIABBBGpB/wEgNyAyQZMybEEIdiAuQYjoAGxBCHZqa0GExABqQQZ1Ii5BACAuQQBKGyIuIC5B/wFOGzoAACAAQQZqIQAgAkECaiECIDpBAWshOiADQQFrIQMgAUECayEBIDAhMiAzIS4gPUEGayI9QQZPDQALCwJAAkACQAJAAkAgPgRAIAQgBWpBAWsiAEUNAiAGIAdqQQFrIgNFDQEgPEUNAyAALQAAIQAgMSA5aiIBQf8BIDQgO2otAABBhZUBbEEIdiICIAMtAAAiA0GlzAFsQQh2akGa7wBrQQZ1IgRBACAEQQBKGyIEIARB/wFOGzoAACA8QQFGDQQgAUH/ASACIABBkzJsQQh2IANBiOgAbEEIdmprQYTEAGpBBnUiA0EAIANBAEobIgMgA0H/AU4bOgABIDxBAk0NBSABQf8BIABBmoICbEEIdiACakGVigFrQQZ1IgBBACAAQQBKGyIAIABB/wFOGzoAAgsPC0Ho68QAEN0JAAtB2OvEABDdCQALQQBBAEHI7cQAEIwHAAtBAUEBQdjtxAAQjAcAC0ECQQJB6O3EABCMBwAL5CACE38CfiMAQeAAayIHJAACQAJAAkACQAJAAkACQAJ/AkACQAJAIAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASgCnAQiBiABKAKUBCIMayIIQQAgBiAITxsgAk8NACABQZwEaiERIAFB6ANqIQggAUGYBGohFSABQfADaiEOAkACQAJAAn8CQAJAA0ACQAJAAkACQCABLQDkA0UEQCAIKQMAUA0BIAhBJEEsIAEoAogEQYGAgIB4RhtqKAIAIgUgBiAFIAZJGyIJIAEoAqAESSABKAKYBCILIAEoAvgDIgVBAXZJcg0EIAEoAvQDIQoCQCAFIAtrQQ9LIAUgC09xRQRAIAUgCUkNBCAFIAlrIgUEQCAKIAkgCmogBfwKAAALIAsgCWshCwwBCyAJIAtLDQQgCyAJayILRQ0AIAogCSAKaiAL/AoAAAsgASALNgKYBCABIAYgCWs2ApwEIAEgDCAJazYClAQgASgCiARBgYCAgHhGBEAgASABKAKMBCAJazYCjAQLIAEoAvgDIQUMBAsgB0EdOgAYDA0LQYiaxwBBP0HImscAEOsHAAsgCSAFIAVBgJDFABDqBwALIAkgCyAFQfCPxQAQ6gcACyAFIAtBgEBrIgZJBEAgBiAFayIKIAEoAvADIAVrSwRAIA4gBSAKQQFBARCkBSABKAL4AyEFCyABKAL0AyIGIAVqIQkgCkECTwR/IApBAWsiCgRAIAlBACAK/AsACyAGIAUgCmoiBWoFIAkLQQA6AAAgASAFQQFqIgU2AvgDIAEoApgEIQsLAkAgCCkDACIYQv7///8PVg0AQX8gCyAYp2oiBiAGIAtJGyAFTw0AIAUgBk8EQCABIAYiBTYC+AMMAQsgBiAFayIKIAEoAvADIAVrSwRAIA4gBSAKQQFBARCkBSABKAL4AyEFCyABKAL0AyIGIAVqIQkgCkECTwR/IApBAWsiCgRAIAlBACAK/AsACyAGIAUgCmoiBWoFIAkLQQA6AAAgFSgCACELIAEgBUEBaiIFNgL4AwsgByAVNgJEIAcgETYCQCAHIAU2AjwgByABKAL0AzYCOAJ/AkACfiABKAKcAyIFIAEpA6ADIhkgBa0iGCAYIBlWG6ciBkYEQEEBIQ1BJCEFQiUMAQsgB0HIAGogASABKAKYAyAGaiAFIAZrIAdBOGoQ1gEgBykCUCEYIAcoAkwhBSAHKAJIRQRAIAEgASkDoAMgBa18NwOgAyAYpyENDAILIBinIQ0gBUH/AXFBKEYNASAHKAJYIQ8gGEIIiAshGCAHIA06ADAgByAYPgAxIAcgGEIwiDwANyAHIBhCIIg9ADUgBUEQdiEUIAVBCHYMAQtBKCEFIA1B/wFxQQZGCyEMIAsgFSgCACIKSwRAQfiaxwBBK0Gkm8cAEOsHAAsgCCAIKQMAIhkgCiALa60iGH03AwAgGCAZUQRAIBEgCjYCAAsCQCAFQf8BcSIGQShHBEAgBkEkRw0HIA1B/wFxQQFrDgMBAwQHCyAMQQFxBEAgASgCvAQiBkUNBiABQQE6AOQDIAEgBkEBazYCvAQLIAEoApwEIgYgASgClAQiDGsiBUEAIAUgBk0bIAJJDQEMCAsLIActADEMAgsgBygCNC0ACAwBCyAHKAI0LQAIC0H/AXFBJUcNASAKIAEoApQEayACSQ0BIAcoAjQhFyAHLQAwIAdBGGohCyABLQDFBCEPIwBBEGsiECQAAkACQAJAIAgoAiwiEyAIKAIQIhVJBEACQCAIKAIMIhEgE2otAAAiDkEFTwRAIAsgDjoAASALQRk6AAAMAQsgCCkCFCEYIAhCgICAgBA3AhQgEEEIaiAIQRxqIgYoAgAiCTYCACAGQQA2AgAgECAYNwMAIBACfyAJIAJBAWsiEk8EQCAQKAIEIRYgEgwBCyASIAlrIgYgECgCACAJa0sEQCAQIAkgBhDvBSAQKAIIIQkLIBAoAgQiFiAJaiEFIAZBAk8EfyAGQQFrIgYEQCAFQQAgBvwLAAsgFiAGIAlqIglqBSAFC0EAOgAAIAlBAWoLIgk2AgggEiAVIBNBAWoiBWsiBksNAiAJIBJHDQMgEgRAIBYgBSARaiAS/AoAAAtBASEJAkACQAJAIAgoAiAiBkGAgICAeHNBAiAGQQBIIgYbIgVBAWsOAgABAgsgCCgCJCIFIBNNBEAgBSARaiEJIBMgBWshBQwCCyAFIBMgE0HQkMUAEOoHAAsgCCgCKCEFIAgoAiQhCQsgCEEgaiERIA4gDyAJIAUgFiASEFogBkUEQCAIQRRqIgYgESkCADcCACAGQQhqIBFBCGooAgA2AgALIBEgECkDADcCACALQSg6AAAgCCACIBNqNgIsIBFBCGogEEEIaigCADYCAAsgEEEQaiQADAMLIBMgFUHgj8UAEIwHAAtBACASIAZBsJDFABDqBwALIAkgEkGgkMUAEN4JAAtBA0cNAiAXKAIAIQUgF0EEaigCACIIKAIAIgYEQCAFIAYRAwALIAgoAgQiBgRAIAUgBiAIKAIIEKIHCyAXQQxBBBCiBwwCC0GsmccAQStB2JnHABDrBwALIAcgDzYCJCAHIAcpAzA3AhwgByAFOgAYIAcgFEEIdjoAGyAHIAxB/wFxIBRBCHRyOwAZCyAHLQAYQShHDQIgASgClAQhCwwBCyABKAL4AyIJIAxNDQUgASgC9AMiBiAMaiIFLQAAIgpBBU8EQCAHIAo6ABkgB0EZOgAYDAILIAEtAMUEIRRBASENAkACQAJAQQIgASgCiAQiD0GAgICAeHMgD0EAThsiDkEBaw4CAAECCyABKAKMBCIIIAxNBEAgBiAIaiENIAwgCGshDgwCCyAIIAwgDEHQkMUAEOoHAAsgASgCkAQhDiABKAKMBCENCyACQQFrIgggCSAMayIGSQRAIAogFCANIA4gBUEBaiAIEFogD0EATgRAIAdB0ABqIgUgAUGIBGoiBkEIaigCADYCACABQQA2ApAEIAcgBikCADcDSCABKAL8AyIPBEAgASgCgAQiCEEEaygCACIGQXhxIg1BBEEIIAZBA3EiBhsgD2pJDQkgBkEAIA0gD0EnaksbDQogCBCiAgsgAUH8A2oiBiAHKQNINwIAIAZBCGogBSgCADYCAAsgAUGBgICAeDYCiAQgASACIAxqIgs2ApQEIAEgDEEBajYCjAQMAQtBASACIAZBkJDFABDqBwALIAsgASgC+AMiBksNB0EBIQ5BAiABKAKIBCIGQYCAgIB4cyAGQQBOGyIFQQFrDgIBAgMLIAAgB/0AAhj9CwIADB0LIAEoAowEIgYgC00EQCABKAL0AyAGaiEOIAsgBmshBQwCCyAGIAsgC0HQkMUAEOoHAAsgASgCkAQhBSABKAKMBCEOCyAHIAJBAWsiDzYCLCAHIAU2AiggBSAPRw0EIAEoAqgEIgUNGSABKAIIQQJHBEAgAS0AxgIhCCABKALABCEGIAcgAS0AxwIiBToAOCAGQYCABHEiDEEQdiICIAEoAtQBQYGAgIB4R3IhCgJAAkACQCAGQRBxBEACQAJAIAVBEEYEQAJAIAhBAWsOBhkSAwIZAAULQQEhBSAGQQFxRQ0fQYSYxQAMIAtBACEGIAhBAWsOBhcQGQUXHgQLQQEhBSAGQQFxRQ0dQYSYxQAMHgsgASgC4AFBgYCAgHhHDRhBDgwZCyAFQRBGDQwCQAJAAkAgCEEBaw4GFwEYAhceAAsgDEEAIAVBB00bDQsgAiAKcQ0NDB0LIAwNDAwcCyAMRQ0bIAVBB00NCQwbC0EBIQIgBkEBcSEGDA8LIAVBCE8NCAwHCyAFQQhJDQYMGAtBrJjHABDdCQALIAwgCUHgj8UAEIwHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQQAgCyAGQcCQxQAQ6gcACyAHQQA2AkhBACAHQShqIAdBLGogB0HIAGpB2JrHABD1BwALQQQQcSIFRQ0KIAVB9QBB9gAgChs2AgBBsJjFAAwSCyAKRQ0QC0EAIQYMBQsCQCAIQQFrDgYIAAkDCA4ECyAMRQ0BCyAKDQMLQQEhBSAGQQFxRQ0MQYSYxQAMDQtBASEFIAZBAXFFDQtBhJjFAAwMCyACIApxDQFBASEFIAZBAXFFDQpBhJjFAAwLC0H3AEH4ACAFQQhGIgIbIQ0gAiAGQQFxcg0BQfkAIQ0gBUEQRg0BIAdBADYCSEEAIAdBOGpBnJjFACAHQcgAakGgmMUAEPkHAAtB+ABB+QAgBkEBcRshDQtBBBBxIgVFDQAgBSANNgIAQbCYxQAMCAsACyAMRQ0FC0EOIAEoAuABQYGAgIB4Rg0BGiAFQRBHDQILQQ8LOgAAIABBkAY7AAEMBQsgAUEIaiECIApFBEAgB0EQaiEGIwBBgAhrIggkACAIIAIQrQIgAi0AvwIhAkGACBBxIQUCQAJAAn8gAkEIRgRAIAVFDQJBtJrFAAwBCyAFRQ0BQcyaxQALIQIgBSAIQYAI/AoAACAGIAI2AgQgBiAFNgIAIAhBgAhqJAAMAQsACyAHKAIQIQUgBygCFAwDCyAHQQhqIQYjAEGACGsiCCQAIAggAhCtAgJAQYAIEHEiAgRAIAIgCEGACPwKAAAgBkHkmsUANgIEIAYgAjYCACAIQYAIaiQADAELAAsgBygCCCEFQeSaxQAMAgtBASEFIAZBAXFFDQBBhJjFAAwBC0EBIQVByJjFAAshDQJAIAEoAqgEIgpFDQAgASgCrAQiAigCACIMBEAgCiAMEQMACyACKAIEIghFDQAgCkEEaygCACIGQXhxIgJBBEEIIAZBA3EiDBsgCGpJDQMgDEEAIAIgCEEnaksbDQQgChCiAgsgASANNgKsBCABIAU2AqgECyABKAIIQQJGDQUgBSAOIA8gAyAEIAFBCGogASgCrAQoAhQRCQACQAJAIAEoAqgDQQFGBEACQCABKAKsAyICIAEoArADTw0AIAEoArQDIgxFDQAgASgCuAMhDSABLQDAAyEUQQEhBgwCC0EHIAEtAMADIgUgBUEHTRshCEECIQMgBUECdEGYjsUAaiEOIAEoArwDIQogASgCuAMhDQNAIAUgCEYNAyABIAVBAWoiBSIUOgDAAyAOKAAAIglB/wFxIgZFDQcgASANIAlBCHZB/wFxayICQQAgAiANTRsiBCAGbiICIAQgAiAGbEdqIgw2ArQDIAlBEHZB/wFxIg9FDQhBACECIAFBADYCrAMgASAKIAlBGHZrIgRBACAEIApNGyIGIA9uIgQgBiAEIA9sR2oiBDYCsANBASEGIA5BBGohDiAERSAMRXINAAsMAQtBAiEDQQAhBiABKAKsAyICIAEoArADTw0BCyABIAJBAWo2AqwDIAYhAwsgASAUOgDUAyABIAw2AtADIAEgDTYCzAMgASACNgLIAyABIAM2AsQDIABBKDoAAAsgB0HgAGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HEjsUAEIEIAAtBtI7FABCBCAALQayYxwAQ3QkAC44aBB5/AnsBfQF+IwBBsMAAayIHJAACQAJAAkAgAiADQf8BcUECdCIEKALQhElwRQRAQQEhBSACIAQoAuCESW5BAnQiBARAQQAhBQJAIARBAE4EQCAHQQA2ArQgIAdBMGpBASAEIAdBsCBqEIUHIAcoAjBBAUcNASAHKAI4IQYgBygCNCEFCyAHIAY2ArQgIAcgBTYCsCBB4L7EAEE2IAdBsCBqQdC+xABBmL/EABDgBgALIAcoAjQhBQsgB0EANgIsIAcgBTYCKCAHIAQ2AiQCQAJAIANB/wFxQQFrDgMDAQEACyACQQNuIgNBAnQiAgRAIAIgBEsEQCAHQSRqQQAgAhDvBSAHKAIsIQYgBygCKCEFCyAFIAZqIQQgAkEBayILBEAgBEEAIAv8CwALIAQgC2pBADoAACACIAZqIQYLIAcgBjYCLCAGQQJ2IgIgAyACIANJGyIERQ0DA0AgBUEDakH/AToAACAFIAEvAQBBgAFqQYECbjoAACAFQQJqIAFBBGovAQBBgAFqQYECbjoAACAFQQFqIAFBAmovAQBBgAFqQYECbjoAACABQQZqIQEgBUEEaiEFIARBAWsiBA0ACwwDCyAHQRBqIAdBLGooAgA2AgAgByAHKQIkNwMIIAdBsCBqEO4CIAcoArAgRQRAIAdBJGpBARDRCQsCQCACIANB/wFxQQJ0KALwhEluQQJ0IhEgBygCECIFTQRAIAcoAgwhEgwBCyARIAVrIgQgBygCCCAFa0sEQCAHQQhqIAUgBBDvBSAHKAIQIQULIAcoAgwiEiAFaiELIARBAk8EfyAEQQFrIgQEQCALQQAgBPwLAAsgEiAEIAVqIgVqBSALC0EAOgAAIAVBAWohEQsgByARNgIQAn8CfwJAAkACQAJAIANB/wFxQQFrDgMBAgMACyAHQTBqQQBBgCD8CwAgB0GwIGpBAEGAIPwLACACQQNuIQ9BASEcQQMMBAsgB0EwakEAQYAg/AsAIAdBsCBqQQBBgCD8CwAgAkECdgwCCyAHQTBqQQBBgCD8CwAgB0GwIGpBAEGAIPwLAEEBIRwgAiEPQQMMAgsgB0EwakEAQYAg/AsAIAdBsCBqQQBBgCD8CwAgAkEBdgshD0EECyEUAkACQAJAIA8EQCAPQQh2IA9B/wFxQQBHaiIEQQFrIgtBACAEIAtPGyEFIAEhCyABIRUgASEWIAEhGUGAAiEXA0AgBSEdIBQgDyAXIA8gF0kbIgQgE0EIdGsiBmwiBUH//wNxQQNuIQkgFCAEIB5qbEH//wNxQQNuIQoCQAJAAkACQCAPIAxBgAJqIgggCCAPSxsiECAMayIYIBRsIg1BgQhJBEAgBEECdCEaIBQgBCAfaiIbbCEIAkACQAJAAkACQAJAAkAgA0H/AXFBAWsOAwEFAgALIBBBA2wiBiAMQQNsIglPIAIgBk9xDQIgCSAGIAJB+LzEABDqBwALIBBBAnQiBCAMQQJ0IgZPIAIgBE9xDQIgBiAEIAJBiL3EABDqBwALIBBBAXQiBiAMQQF0IglPIAIgBk9xDQMgCSAGIAJB2L3EABDqBwALIA0gBiAJayIGIAYgDUsbRQ0HIAggICAEQQNsIgRqIgYgBiAISxshCUEAIQggBSATQYB6bCAEaiIEIAQgBUsbIgpBBE8EQCAJQXxxIQYgCkF8cSEIIAdBMGohBSALIQQDQCAFIAT9BAEA/fsB/QyAAIA3gACAN4AAgDeAAIA3/eYB/QsCACAEQQhqIQQgBUEQaiEFIAZBBGsiBg0ACyAIIApGDQgLIAggCWshBiALIAhBAXRqIQUgB0EwaiAIQQJ0aiEEA0AgBCAFLwEAs0OAAIA3lDgCACAFQQJqIQUgBEEEaiEEIAZBAWoiBg0ACwwHCyANIAQgBmsiBCAEIA1LG0UNBiAIIA4gGmoiBCAEIAhLGyEJQQAhCCAFIBogE0EKdGsiBCAEIAVLGyIKQQRPBEAgCUF8cSEGIApBfHEhCCAHQTBqIQUgFSEEA0AgBSAE/QQBAP37Af0MgACAN4AAgDeAAIA3gACAN/3mAf0LAgAgBEEIaiEEIAVBEGohBSAGQQRrIgYNAAsgCCAKRg0HCyAIIAlrIQYgFSAIQQF0aiEFIAdBMGogCEECdGohBANAIAQgBS8BALNDgACAN5Q4AgAgBUECaiEFIARBBGohBCAGQQFqIgYNAAsMBgsgDCAQSw0CIA1B//8DcUEDbiIEIBggBCAYSRtFDQUgCiAbIAogG0kbIQpBACEIIAkgBiAGIAlLGyIJQQRPBEAgCkH8/wFxIQYgCUH8/wFxIQggB0EwaiEFIBYhBANAIAUgBP0EAQD9+wH9DIAAgDeAAIA3gACAN4AAgDf95gEiIiAi/Q0ICQoLDA0ODwwNDg8MDQ4P/QsCICAFICIgIv0NBAUGBwQFBgcICQoLCAkKC/0LAhAgBSAiICL9DQABAgMAAQIDAAECAwQFBgf9CwIAIARBCGohBCAFQTBqIQUgBkEEayIGDQALIAggCUYNBgsgCCAKayEGIBYgCEEBdGohBCAHQTBqIAhBDGxqIQUDQCAFQQhqIAQvAQCzQ4AAgDeUIiQ4AgAgBUEEaiAkOAIAIAUgJDgCACAEQQJqIQQgBUEMaiEFIAZBAWoiBg0ACwwFCyANQQJ2IgogBiAJa0EBdiIGIAYgCksbRQ0EQQAhBiAFQQJ2IgUgBEEBdCIEIBNBCXRrQQF2IgogBSAKSRsiBUEBRg0DIAhBAnYiBiAEICFqQQF2IgQgBCAGSxtB/v///wNxIQggBUEBcSEKQQAhBiAHQTBqIQUgGSEEA0AgBSAE/QQBAP37Af0MgACAN4AAgDeAAIA3gACAN/3mASIiICL9DQgJCgsICQoLCAkKCwwNDg/9CwIQIAUgIiAi/Q0AAQIDAAECAwABAgMEBQYH/QsCACAEQQhqIQQgBUEgaiEFIAggBkECaiIGRw0ACwwCC0EAIA1BgAhB6L3EABDqBwALIAwgECACQZi9xAAQ6gcACyAKRQ0BCyAHQTBqIAZBBHRqIgQgASAJQQF0aiAGQQJ0aiIFLwEAs0OAAIA3lCIkOAIIIAQgJDgCBCAEICQ4AgAgBCAFLwECs0OAAIA3lDgCDAsCfyAcRQRAIBhBAnQiBCANSw0FIAdBMGoMAQsgDUH//wNxQQNuIQQCQCANQQNJDQBBgAIgBCAEQYACTxshCEEBIQYgB0GwIGohBSAHQTBqIQQDQCAFIAQqAgA4AgAgBUEMakGAgID8AzYCACAFQQRqIARBBGopAgA3AgAgBiAbRg0BIARBDGohBCAFQRBqIQUgBiAISSAGQQFqIQYNAAsLIBhBAnQiBEGBCE8NAyAHQbAgagshBSAQQQJ0IgYgEUsgBiAMQQJ0IgxJcg0EIAYgDGsiDCAEIAQgDEsbBEBBACAaayEGIBIhBANAIARB/wEgBSoCAEMAAH9DlBC5ByIk/AFBACAkQwAAAABgGyAkQwAAf0NeGzoAACAEQQFqQf8BIAVBBGoqAgBDAAB/Q5QQuQciJPwBQQAgJEMAAAAAYBsgJEMAAH9DXhs6AAAgBEECaiEEIAVBCGohBSAOIAZBAmoiBkcNAAsLIBJBgAhqIRIgC0GADGohCyAgQYAGayEgIBVBgBBqIRUgDkGACGshDiAWQYAEaiEWIB5BgAJrIR4gIUGABGshISAfQYACayEfIBlBgAhqIRkgE0EBaiETIB1BAWshBSAXIgxBgAJqIRcgHQ0ACwsgACAHKQMINwIAIABBCGogB0EQaigCADYCAAwGC0EAIARBgAhBqL3EABDqBwALQQAgBCANQci9xAAQ6gcACyAMIAYgEUG4vcQAEOoHAAtB+L3EAEHFAEHAvsQAEOsHAAsCQAJAIAIgBEsEQCAHQSRqQQAgAhDvBSAHKAIoIQUgBygCLCEEDAELQQAhBCACRQ0BC0EAIQMgAkEITwRAIAQgBWohBiAEIAJBeHEiA2ohBCABIQ4gAyELA0AgBiAO/QABACIj/akB/QyAAAAAgAAAAIAAAACAAAAA/a4BIiL9GwBBgQJu/REgIv0bAUGBAm79HAEgIv0bAkGBAm79HAIgIv0bA0GBAm79HAMgI/2qAf0MgAAAAIAAAACAAAAAgAAAAP2uASIi/RsAQYECbv0RICL9GwFBgQJu/RwBICL9GwJBgQJu/RwCICL9GwNBgQJu/RwD/Q0ABAgMEBQYHAAAAAAAAAAA/VsAAAAgDkEQaiEOIAZBCGohBiALQQhrIgsNAAsgAiADRg0BCyACIANrIQ4gASADQQF0aiEGA0AgBCAFaiAGLwEAQYABakGBAm46AAAgBkECaiEGIARBAWohBCAOQQFrIg4NAAsLIAcgBDYCLAsgB0EgaiAHQSxqKAIAIgE2AgAgByAHKQIkIiU3AxggAEEIaiABNgIAIAAgJTcCAAsgB0GwwABqJAAL1BkCDn8CeyMAQUBqIgMkACADIAE2AhwgA0EANgIYIAMgATYCFCADIAA2AhAgA0EBOgAkIANBPzYCDCADQT82AiAgA0E0aiICIANBDGoiBhD9AiADIAMoAjggASADKAI0GyIBNgIcIANBADYCGCADIAE2AhQgAyAANgIQIANBAToAJCADQSM2AgwgA0EjNgIgIAIgBhD9AiADKAI4IQIgAygCNCEHIANBATsBMCADIAIgASAHGyIBNgIsIANBADYCKCADQQE6ACQgA0EuNgIgIAMgATYCHCADQQA2AhggAyABNgIUIAMgADYCECADQS42AgwCQAJAAkACQAJAA0ACQCADKAIQIQEgA0E0aiADQQxqEP0CIAMoAjRFBEACQCADLQAxDQACQCADLQAwQQFGBEAgAygCLCEAIAMoAighAQwBCyADKAIsIgAgAygCKCIBRg0BCyADKAIQIAFqIQggACABayEHDAILIAgNAUEGIQEMAwsgAygCKCEAIAMgAygCPDYCKCAAIAFqIQggAygCOCAAayEHIAMtADFBAUcNAQsLAkACQCAHQQBOBEACQCAHRQRAQQAhBkEBIQQMAQsgBxBxIgRFDQIgCCEBIAQhAAJAIAciAkEQSQ0AIAJB8P///wdxIQpBACEGA0AgBCAGaiEAIAYgCGoiAf0AAAAiEf0M//////////////////////0nIhD9FgFBAXEgEP0WAEEBcWogEP0WAkEBcWogEP0WA0EBcWogEP0WBEEBcWogEP0WBUEBcWogEP0WBkEBcWogEP0WB0EBcWogEP0WCEEBcWogEP0WCUEBcWogEP0WCkEBcWogEP0WC0EBcWogEP0WDEEBcWogEP0WDUEBcWogEP0WDkEBcWogEP0WD0EBcWpB/wFxQRBHBEAgBiEKDAILIAAgEf0Mv7+/v7+/v7+/v7+/v7+/v/1u/QwaGhoaGhoaGhoaGhoaGhoa/Sb9DCAgICAgICAgICAgICAgICD9TiAR/VD9CwAAIAZBEGohBiACQRBrIgJBD0sNAAsgAkUEQCAKIQYMAgsgBiAIaiEBIAQgBmohAAsgAiAKaiEGA0AgASwAACILQQBOBEAgAEEgQQAgC0HBAGtB/wFxQRpJGyALcjoAACAAQQFqIQAgAUEBaiEBIApBAWohCiACQQFrIgINAQwCCwsgAyAKNgIUIAMgBDYCECABIAJqIQ4gAyAHNgIMIAcgCGohDyAKIQZBACECA0ACfwJAAkACfwJAAkACQAJAIAEsAAAiAEEASARAIAEtAAFBP3EhDCAAQR9xIQsCfyAAQV9NBEAgC0EGdCAMciEAIAFBAmoMAQsgAS0AAkE/cSAMQQZ0ciEMIABBcEkEQCAMIAtBDHRyIQAgAUEDagwBCyALQRJ0QYCA8ABxIAEtAANBP3EgDEEGdHJyIQAgAUEEagsiCyACIAFraiEMIABBowdHDQECQCACIApqIgRFDQAgBCAHTwRAIAQgB0YNAQwUCyAEIAhqLAAAQUBIDRMLIAQgCGohAUEAIQUDQEGDASEJIAEgCEYNCCABQQFrIgIsAAAiAEEASARAIABBP3ECfyABQQJrIgItAAAiDcAiAEFATgRAIA1BH3EMAQsgAEE/cQJ/IAFBA2siAi0AACINwCIAQb9/SgRAIA1BD3EMAQsgAEE/cSABQQRrIgItAABBB3FBBnRyC0EGdHILQQZ0ciIAQYCAxABGDQkLIAIhAQJAAkAgBQ0AIABBgAFPBEAgAEGnAU0NASAAEOYERQ0BQYCAxAAhAkEAIQUMAgtBgIDEACECQQAhBSAAQSdrIg1BE01BAEEBIA10QYGBIHEbDQEgAEHeAGsOAwEAAQALQQEhBSAAIQILIAJBgIDEAEYNAAsCQCACQYABTwRAIAJBqQFNDQkgAhD6BA0BDAkLIAJB3wBxQcEAa0EaTw0ICwJAIARBAmoiAEUNACAAIAdPBEAgACAHRg0BDBMLIAAgCGosAABBQEgNEgsgACAIaiEBQQAhBQNAQYIBIQkgASAPRg0IAn8gASwAACIAQQBOBEAgAEH/AXEhACABQQFqDAELIAEtAAFBP3EhBCAAQR9xIQIgAEFfTQRAIAJBBnQgBHIhACABQQJqDAELIAEtAAJBP3EgBEEGdHIhBCAAQXBJBEAgBCACQQx0ciEAIAFBA2oMAQsgAkESdEGAgPAAcSABLQADQT9xIARBBnRyciIAQYCAxABGDQkgAUEEagshAQJAAkAgBQ0AIABBgAFPBEAgAEGnAU0NASAAEOYERQ0BQYCAxAAhAkEAIQUMAgtBgIDEACECQQAhBSAAQSdrIgRBE01BAEEBIAR0QYGBIHEbDQEgAEHeAGsOAwEAAQALQQEhBSAAIQILIAJBgIDEAEYNAAsgAkGAAU8EQCACQakBTQ0IIAIQ+gRFDQgMBwsgAkHfAHFBwQBrQRpJDQYMBwsgAEH/AXEhACABQQFqIgsgAiABa2ohDAwBCyAAQYABSQ0AQc0FQQAgAEHSPU8bIgEgAUHmAmoiASABQQN0KALYnkIgAEsbIgEgAUGzAWoiASABQQN0KALYnkIgAEsbIgEgAUHaAGoiASABQQN0KALYnkIgAEsbIgEgAUEtaiIBIAFBA3QoAtieQiAASxsiASABQRZqIgEgAUEDdCgC2J5CIABLGyIBIAFBC2oiASABQQN0KALYnkIgAEsbIgEgAUEGaiIBIAFBA3QoAtieQiAASxsiASABQQNqIgEgAUEDdCgC2J5CIABLGyIBIAFBAWoiASABQQN0KALYnkIgAEsbIgEgAUEBaiIBIAFBA3QoAtieQiAASxsiAUEDdCgC2J5CIgIgAEYNAQwCC0EgQQAgAEHBAGtBGkkbIAByIQBBASEFQQEMAgsCQCABIAAgAktqIgBBmQtNBEBB6QAgAEEDdCgC3J5CIgAgAEGAsANzQYCAxABrQYCQvH9JIgEbIQAgAQ0BQQEhBSAAQYABTw0CQQEMAwtBmgtBmgtBqPjCABCMBwALAn9BASAAQYABSSIFDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsLIgEgAygCDCAGIgJrSwR/IANBDGogAiABEPcFIAMoAhAhBCADKAIUBSACCyAEaiECAkAgBUUEQCAAQT9xQYB/ciEEIABBBnYhBSAAQYAQSQRAIAIgBDoAASACIAVBwAFyOgAADAILIABBDHYhCSAFQT9xQYB/ciEFIABB//8DTQRAIAIgBDoAAiACIAU6AAEgAiAJQeABcjoAAAwCCyACIAQ6AAMgAiAFOgACIAIgCUE/cUGAf3I6AAEgAiAAQRJ2QXByOgAADAELIAIgADoAAAsgAyABIAZqIgE2AhQgAygCDCABIgBrQQFNBH8gA0EMaiAAQQIQ9wUgAygCFAUgAAsgAygCECIEakHMjwI7AAAgAUECagwEC0EAIQVBAiAAQYAQSQ0AGkEDQQQgAEGAgARJGwsiASADKAIMIAYiAmtLBH8gA0EMaiACIAEQ9wUgAygCECEEIAMoAhQFIAILIARqIQICQAJAIAVFBEAgAEE/cUGAf3IhBSAAQQZ2IQkgAEGAEE8NASACIAU6AAEgAiAJQcABcjoAAAwCCyACIAA6AAAMAQsgAEEMdiENIAlBP3FBgH9yIQkgAEH//wNNBEAgAiAFOgACIAIgCToAASACIA1B4AFyOgAADAELIAIgBToAAyACIAk6AAIgAiANQT9xQYB/cjoAASACIABBEnZBcHI6AAALIAEgBmoMAgtBgwEhCQsgAygCDCAGIgFrQQFNBH8gA0EMaiABQQIQ9wUgAygCFAUgAQsgAygCECIEaiIAIAk6AAEgAEHPAToAACAGQQJqCyEGIAwhAiADIAY2AhQgCyIBIA5HDQALIAMoAhAhBCADKAIMIQcLQQYhAQJAAkACQAJAAkAgBkEDaw4EAAQBAgcLIARBkNDHAEEDENsHRQRAQQAhAQwHCyAEQaD3xwBBAxDbBw0CQQEhAQwGC0EGQQIgBEGj98cAQQUQ2wcbIQEMBQtBBkEDIARBqPfHAEEGENsHGyEBDAQLQQQhASAEQdj3xwBBAxDbB0UNAyAEQdv3xwBBAxDbB0UNA0EGQQUgBEG398cAQQMQ2wcbIQEMAwtBBEEGIAQoAABB896dmwdGGyEBDAILQcTuwQAQ/wcLAAsgB0UNACAEQQRrKAIAIgBBeHEiAkEEQQggAEEDcSIAGyAHakkNASAAQQAgAiAHQSdqSxsNAiAEEKICCyADQUBrJAAgAQ8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAIIAcgACAHQeTuwQAQuwkACyAIIAdBACAEQdTuwQAQuwkAC8sYAhN/AX4jAEEwayILJAACQAJAAkACQCAAKAIAIgYoAgAiAEUEQCALQQA2AiggCyABNgIkIAtCADcCHCALIAYpAgQ3AhQgC0EUakEBEMwBIQcMAQsgBigCCCESIAYoAgQhDgJAA0AgEiAUIgZNBEBBACEHDAMLAkACQCAORQ0AIAZBAWoiCCAGIAYgEkkbIRQgDkEBayEHQQAhAiAALQAAIhAhBCAOIQUCQAJAA0ACQAJAIATAQQBIBEAgBEEfcSEPIAAgAmoiCkEBai0AAEE/cSEJIARB/wFxIgNB3wFLDQEgD0EGdCAJciEDDAILIARB/wFxIQMMAQsgCkECai0AAEE/cSAJQQZ0ciEJIANB8AFJBEAgCSAPQQx0ciEDDAELIA9BEnRBgIDwAHEgCkEDai0AAEE/cSAJQQZ0cnIiA0GAgMQARg0ECyAAIAJqIQkgA0Ewa0EKSQRAIAIgB0YNBCAJQQFqLAAAIgRBv39MDQIgAkEBaiECIAVBAWshBQwBCwsgDiAFayICDQFBACEDDAkLIAkgBUEBIAVBqLjFABC7CQALIAAgAmosAABBv39KDQEgACAOQQAgAkG4uMUAELsJAAtBmLjFABDdCQALAkACQAJAIAJBAUYEQEEBIQMgEEEraw4DCQEJAQsgEEErRgRAIAJBAWshAyAAQQFqIQAgAkEKSQ0BDAILIAIiA0EJTw0BC0EAIQIDQCAALQAAQTBrIgdBCUsNByAAQQFqIQAgByACQQpsaiECIANBAWsiAw0ACwwBC0EAIQIgAyEHA0AgB0UNASAALQAAQTBrIgpBCUsNBkECIQMgAq1CCn4iFUIgiKcNByAAQQFqIQAgB0EBayEHIAogFadqIgIgCk8NAAsMBgsCQCACRQ0AIAIgBU8EQCACIAVGDQEMBQsgAiAJaiwAAEG/f0wNBAsgAiAJaiEAAkAgCCASRw0AIAJFIAEoAghBgICABHFFIARB/wFxQegAR3JyDQACQCACQQFHBEAgCSwAAUFASA0BCyAJQQFqIQQDQEEAIQcgACAERg0FAn8gBCwAACIKQQBOBEAgCkH/AXEhAyAEQQFqDAELIAQtAAFBP3EhAyAKQR9xIQggCkFfTQRAIAhBBnQgA3IhAyAEQQJqDAELIAQtAAJBP3EgA0EGdHIhAyAKQXBJBEAgAyAIQQx0ciEDIARBA2oMAQsgCEESdEGAgPAAcSAELQADQT9xIANBBnRyciIDQYCAxABGDQYgBEEEagshBCADQcEAa0FecUEKaiADQTBrIANBOUsbQQ9NDQALDAELIAkgAkEBIAJB4LXFABC7CQALIAYEQCABKAIAQZSzxQBBAiABKAIEKAIMEQAADQILAn8CQCACQQJJDQAgCS8AAEHfyABHDQAgCSwAAUG/f0oEQCAJQQFqIQkgAkEBawwCCyAJIAJBASACQdi4xQAQuwkACyACCyEEIAUgAmshDiABKAIEIQ0gASgCACEMA0ACQCAJIQYCQAJAAkACQCAEIghFDQACQAJAAkACQAJAAkACfwJAAkACQCAGLQAAIgRBJEcEQCAEQS5HDQsgCEEBRg0BIAYsAAEiAkG/f0wNAiACQQBIDQMgAkH/AXEMBAsgCEEBRwRAIAYsAAFBv39MDQgLIAZBAWohBSAIQQFrIQdBACEDA0AgAyAFaiEJAkAgByADayIEQQdNBEAgAyAHRg0OQQAhAgNAIAIgCWotAABBJEYNAiAEIAJBAWoiAkcNAAsMDgsgC0EIakEkIAkgBBCHBSALKAIIQQFxRQ0NIAsoAgwhAgsCQCACIANqIgIgB08NACACIAVqLQAAQSRHDQAgAkEBaiEEAkACQAJAAkAgBS0AACIHwCIDQUBIDQACQCAEIAhPBEAgBCAIRw0CIAJBAmoiBA0BQX4hAiAIIQQgBiEJDAULIAJBAmohBAsCQCAEIAhPBEAgBCAIRg0BDAQLIAQgBmosAABBQEgNAwsgBCAGaiEJIAggBGshBAJAAkACQCACDgMUAQAGCyAFLwAAQdOgAUYEQEG4ucUAIQIMBAsgBS8AAEHCoAFGBEBBsrPFACECDAQLIAUvAABB0owBRgRAQayzxQAhAgwECyAFLwAAQcyoAUYEQEGms8UAIQIMBAsgBS8AAEHHqAFGBEBBq7PFACECDAQLIAUvAABBzKABRgRAQbuzxQAhAgwECyAFLwAAQdKgAUcNAUHejsgAIQIMAwsgB0HDAEcND0G8s8UAIQIMAgtBAiECDAMLIAYgCEEBIARBmLnFABC7CQALQQEhByAMIAJBASANKAIMEQAARQ0TDBYLIAYgCCAEIAhBqLnFABC7CQALIANB9QBHDQ0gBiwAAkG/f0oNCyAFIAJBASACQby5xQAQuwkACyAHIAJBAWoiA08NAAsMCwtBASEHIAxB7LnFAEEBIA0oAgwRAABFDQMMEQsgBiAIQQEgCEHMucUAELsJAAsgBi0AAkE/cSEEIAJBH3EhAyADQQZ0IARyIAJBX00NABogBi0AA0E/cSAEQQZ0ciEEIAQgA0EMdHIgAkFwSQ0AGiADQRJ0QYCA8ABxIAYtAARBP3EgBEEGdHJyCyANKAIMIQRBLkYNAUEBIQcgDEHsucUAQQEgBBEAAA0OIAYsAAFBQEgNAgsgBkEBaiEJIAhBAWshBAwKCyAMQZSzxQBBAiAEEQAADQsCQCAIQQNPBEAgBiwAAkFASA0BCyAGQQJqIQkgCEECayEEDAoLIAYgCEECIAhB3LnFABC7CQALIAYgCEEBIAhB8LnFABC7CQALIAYgCEEBIAhBiLnFABC7CQALIAdB9QBHDQJBASECCyACIAVqIRAgAkEBayEKIAZBAmoiByEFAkADQEEAIQ8gBSAQRg0BAn8gBSwAACIRQQBOBEAgEUH/AXEhAyAFQQFqDAELIAUtAAFBP3EhAyARQR9xIRMgEUFfTQRAIBNBBnQgA3IhAyAFQQJqDAELIAUtAAJBP3EgA0EGdHIhAyARQXBJBEAgAyATQQx0ciEDIAVBA2oMAQsgE0ESdEGAgPAAcSAFLQADQT9xIANBBnRyciIDQYCAxABGDQIgBUEEagshBSADQTprQXVLIANB5wBrQXlLcg0AC0EBIQ8LQQEhAwJAAkACQAJAAkACQCACQQFrDgIFAAELIActAABBK2sOAwQBBAELAkAgBy0AAEErRgRAIAJBAmshAyAGQQNqIQcgAkELTw0BDAILIAohAyACQQpJDQELQQAhBQNAIAVB/////wBLDQMgBy0AACICQcEAa0FfcUEKaiACQTBrIAJBOUsbIgJBEE8NAyAHQQFqIQcgAiAFQQR0ciEFIANBAWsiAw0ACwwBC0EAIQUDQCAHLQAAIgJBwQBrQV9xQQpqIAJBMGsgAkE5SxsiAkEPSw0CIAdBAWohByACIAVBBHRyIQUgA0EBayIDDQALC0EAIQMMAQtBASEDCyAPQYCAxABBgIDEACAFIAVBgLADc0GAgMQAa0GAkLx/SRsgA0EBcRsiA0GAgMQARnINASALIAM2AhQgA0EgSSADQf8Aa0EhSXINASALQRRqIAEQqAVFDQUMBwsgBiAIaiEJQQAhByAGIQIDQCAHIQMgAiAJRg0BAn8gAiwAACIKQQBOBEAgAkEBaiEFIApB/wFxDAELIAItAAFBP3EhBCAKQR9xIQcgCkFfTQRAIAJBAmohBSAHQQZ0IARyDAELIAItAAJBP3EgBEEGdHIhBCAKQXBJBEAgAkEDaiEFIAQgB0EMdHIMAQsgAkEEaiEFIAdBEnRBgIDwAHEgAi0AA0E/cSAEQQZ0cnILIgRBLkcEQCADIAJrIAVqIQcgBSECIARBJEcNAQsLAkACQCADBEAgAyAISQ0BIAMgCEcNAiAMIAYgCCANKAIMEQAADQkMBQsgDCAGQQAgDSgCDBEAAA0IDAQLIAMgBmoiBCwAAEG/f0oNAgsgBiAIQQAgA0HouMUAELsJAAsgDCAGIAggDSgCDBEAAEUNBAwFCyAMIAYgAyANKAIMEQAADQQgBCwAAEFASA0BCyADIAZqIQkgCCADayEEDAELCwsgBiAIIAMgCEH4uMUAELsJAAtBASEHCyALQTBqJAAgBw8LIAkgBSACIAVByLjFABC7CQALQQEhAwsgCyADOgAvQdjmyABBKyALQS9qQYC6xQBBkLrFABDgBgALxhgDH38FfQF+IwBBEGsiEyQAIAAgASACEOkEAkACQCADKAIEIhRFBEAgAygCDCEMDAELAkAgAygCDCIMRQ0AIAMoAhQiHEUNACADKAIcIh1FDQAgAygCJCIZRQ0AIAJFDQIgAkEEdCEgIAAoAoQBISEgACgCiAEhHiAAKAJ4ISIgACgCfCEfIAMoAiAhESADKAIYIRIgAygCECEVIAMoAgghECADKAIAIRogDCEPAkACQAJAA0AgHyANIgRBBGoiDUkEQCAEIA0gH0GIv8EAEOoHAAsCQAJAAkAgDSAeTQRAAkACQCAIIBRPDQAgFCAIayIFQQAgBSAUTRsiBUEBRwRAIAVBAkcNAiAIQQJqIQgMAQsgCEEBaiEICyAIIBRBmL/BABCMBwALIA8EQAJAAkAgCCAcTw0AAkACQCAbIBxqQQFrDgIAAQMLIAhBAWohCAwBCyAIQQJqIQgLIAggHEG4v8EAEIwHAAsCQAJAIAggHU8NAAJAAkAgGyAdakEBaw4CAAEDCyAIQQFqIQgMAQsgCEECaiEICyAIIB1BqL/BABCMBwALIAQgGU8NCAJAIBkgBGsiBUEAIAUgGU0bQQFrDgMFBwgACyAXIBpqIgtBCGooAgAhBiALQQRqKAIAIQUgBCAQaigCACEOIBUgF2oiBCgCACEJIARBCGooAgAhGCAEQQRqKAIAIQogEiAXaiIEKgIAISMgBEEIaioCACEkIARBBGoqAgAhJSARIBZqIgQqAgAhJiAEQQRqKgIAIScgBEEIaikCACEoIBYgImoiByALKAIANgIAIAdBCGogBjYCACAHQQRqIAU2AgAgEyAnOAIEIBMgJjgCACATICg3AgggDkH///8DcSEFIA5BgICAgHhxIQQgDkGAgID8B3EiBkGAgID8B0YEQCAEQRB2IAVBDXZyQYAEQQAgBRtyQYD4AXIhCwwECyAEQRB2IQsgBkGAgIC4BEsNAiAGQYCAgMQDTwRAIA5BDHYgDkH/3wBxQQBHcSAGQQ12IAVBDXZqQYCAAWogC3JqIQsMBAsgBkGAgICYA0kNAyAFQYCAgARyIgVB/gAgBkEXdiIEa3YhDiAFQR0gBGsiBHZBAXEEfyAOQQMgBHRBAWsgBXFBAEdqBSAOCyALciELDAMLIAwgDEH4vsEAEIwHAAsgBCANIB5B6L7BABDqBwALIAtBgPgBciELCyAHQQxqIAtB//8DcTYCACAJQf///wNxIQUgCUGAgICAeHEhBAJAIAlBgICA/AdxIgZBgICA/AdGBEAgBEEQdiAFQQ12ckGABEEAIAUbckGA+AFyIQcMAQsgBEEQdiEHIAZBgICAuARNBEAgBkGAgIDEA08EQCAJQQx2IAlB/98AcUEAR3EgBkENdiAFQQ12akGAgAFqIAdyaiEHDAILIAZBgICAmANJDQEgBUGAgIAEciIFQf4AIAZBF3YiBGt2IQ4gBUEdIARrIgR2QQFxBH8gDkEDIAR0QQFrIAVxQQBHagUgDgsgB3IhBwwBCyAHQYD4AXIhBwsgCkH///8DcSEFIApBgICAgHhxIQQCQCAKQYCAgPwHcSILQYCAgPwHRgRAIARBEHYgBUENdnJBgARBACAFG3JBgPgBciEEDAELIARBEHYhBCALQYCAgLgETQRAIAtBgICAxANPBEAgCkEMdiAKQf/fAHFBAEdxIAtBDXYgBUENdmpBgIABaiAEcmohBAwCCyALQYCAgJgDSQ0BIAVBgICABHIiBkH+ACALQRd2IgVrdiEOIAZBHSAFayIFdkEBcQR/IA5BAyAFdEEBayAGcUEAR2oFIA4LIARyIQQMAQsgBEGA+AFyIQQLIBYgIWoiCyAHQf//A3EgBEEQdHI2AgAgGEH///8DcSEFIBhBgICAgHhxIQQCQCAYQYCAgPwHcSIHQYCAgPwHRgRAIARBEHYgBUENdnJBgARBACAFG3JBgPgBciEJDAELIARBEHYhCSAHQYCAgLgETQRAIAdBgICAxANPBEAgGEEMdiAYQf/fAHFBAEdxIAdBDXYgBUENdmpBgIABaiAJcmohCQwCCyAHQYCAgJgDSQ0BIAVBgICABHIiBkH+ACAHQRd2IgVrdiEEIAZBHSAFayIFdkEBcQR/IARBAyAFdEEBayAGcUEAR2oFIAQLIAlyIQkMAQsgCUGA+AFyIQkLICMQxgW8IgZB////A3EhBSAGQYCAgIB4cSEEAkAgBkGAgID8B3EiB0GAgID8B0YEQCAEQRB2IAVBDXZyQYAEQQAgBRtyQYD4AXIhCgwBCyAEQRB2IQogB0GAgIC4BE0EQCAHQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSAHQQ12IAVBDXZqQYCAAWogCnJqIQoMAgsgB0GAgICYA0kNASAFQYCAgARyIgZB/gAgB0EXdiIFa3YhBCAGQR0gBWsiBXZBAXEEfyAEQQMgBXRBAWsgBnFBAEdqBSAECyAKciEKDAELIApBgPgBciEKCyALQQRqIAlB//8DcSAKQRB0cjYCACAlEMYFvCIGQf///wNxIQUgBkGAgICAeHEhBAJAIAZBgICA/AdxIgdBgICA/AdGBEAgBEEQdiAFQQ12ckGABEEAIAUbckGA+AFyIQoMAQsgBEEQdiEKIAdBgICAuARNBEAgB0GAgIDEA08EQCAGQQx2IAZB/98AcUEAR3EgB0ENdiAFQQ12akGAgAFqIApyaiEKDAILIAdBgICAmANJDQEgBUGAgIAEciIGQf4AIAdBF3YiBWt2IQQgBkEdIAVrIgV2QQFxBH8gBEEDIAV0QQFrIAZxQQBHagUgBAsgCnIhCgwBCyAKQYD4AXIhCgsgJBDGBbwiBkH///8DcSEFIAZBgICAgHhxIQQCQCAGQYCAgPwHcSIHQYCAgPwHRgRAIARBEHYgBUENdnJBgARBACAFG3JBgPgBciEJDAELIARBEHYhCSAHQYCAgLgETQRAIAdBgICAxANPBEAgBkEMdiAGQf/fAHFBAEdxIAdBDXYgBUENdmpBgIABaiAJcmohCQwCCyAHQYCAgJgDSQ0BIAVBgICABHIiBkH+ACAHQRd2IgVrdiEEIAZBHSAFayIFdkEBcQR/IARBAyAFdEEBayAGcUEAR2oFIAQLIAlyIQkMAQsgCUGA+AFyIQkLIAtBCGogCkH//wNxIAlBEHRyNgIAIAtBDGogExDNBDYCACAXQQxqIRcgG0EDayEbIAhBA2ohCCAPQQFrIQ8gICAWQRBqIhZHDQEMBwsLIARBAWohBAwCCyAEQQJqIQQMAQsgBEEDaiEECyAEIBlByL/BABCMBwALIAAgASACIAMoAgAgFBDCBQsgDARAIAMoAgghBSAAIAEgAhDpBCACBEAgAkECdCEEIAAoAnhBDGohFSAAKAJ8IRogDCEIA0ACQAJAAkAgGiARQQNqSwRAIAhFDQIgBSARaigCACIQQf///wNxIQYgEEGAgICAeHEhDyAQQYCAgPwHcSISQYCAgPwHRgRAIA9BEHYgBkENdnJBgARBACAGG3JBgPgBciENDAQLIA9BEHYhDSASQYCAgLgESw0BIBJBgICAxANPBEAgEEEMdiAQQf/fAHFBAEdxIBJBDXYgBkENdmpBgIABaiANcmohDQwECyASQYCAgJgDSQ0DIAZBgICABHIiBkH+ACASQRd2Ig9rdiEQIAZBHSAPayIPdkEBcQR/IBBBAyAPdEEBayAGcUEAR2oFIBALIA1yIQ0MAwsgESARQQRqIBpByLPBABDqBwALIA1BgPgBciENDAELIAwgDEG4s8EAEIwHAAsgFSANQf//A3E2AgAgFUEQaiEVIAhBAWshCCAEIBFBBGoiEUcNAAsLIABBAToAwAELIAMoAhQiDARAIAAgASACIAMoAhAgDBCkAgsgAygCHCIMBEAgACABIAIgAygCGCAMEJ4CCyADKAIkIgxFDQAgACABIAIgAygCICAMEKAFCyAAQQE6AMABIAMoAjwhBCADKAI4IQ0gAygCNCEIIAMoAjAhDyADKAIsIgwEQCAAIAEgAiADKAIoIAwQ5gELIAgEQCAAIAEgAiAPIAgQpwELIAQEQCAAIAEgAiANIAQQlAELIAMoAkQiDARAIAAgASACIAMoAkAgDBC2BAsgAygCTCIMBEAgACABIAIgAygCSCAMELcECyATQRBqJAALuB0BBX8jAEEwayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4cAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHAALQQEhAyABKAIAIgRB86XHAEEHIAEoAgQiBigCDCIFEQAADRwgAEEEaiEAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0eIAAgARCuAkUNAQweCyAEQduBwgBBAiAFEQAADR0gAkEBOgAMIAIgBjYCGCACIAQ2AhQgAkHggcIANgIkIAIgASkCCDcCKCACIAJBDGo2AhwgAiACQRRqNgIgIAAgAkEgahCuAg0dIAIoAiBB2YHCAEECIAIoAiQoAgwRAAANHQsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDBwLQQEhAyABKAIAIgRB58nEAEEUIAEoAgQiBigCDCIFEQAADRsgAEEBaiEAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0dIAAgARDZAkUNAQwdCyAEQduBwgBBAiAFEQAADRwgAkEBOgAMIAIgBjYCGCACIAQ2AhQgAkHggcIANgIkIAIgASkCCDcCKCACIAJBDGo2AhwgAiACQRRqNgIgIAAgAkEgahDZAg0cIAIoAiBB2YHCAEECIAIoAiQoAgwRAAANHAsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDBsLQQEhAyABKAIAIgRB+8nEAEEUIAEoAgQiBigCDCIFEQAADRogAEEBaiEAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0cIAAgARDZAkUNAQwcCyAEQduBwgBBAiAFEQAADRsgAkEBOgAMIAIgBjYCGCACIAQ2AhQgAkHggcIANgIkIAIgASkCCDcCKCACIAJBDGo2AhwgAiACQRRqNgIgIAAgAkEgahDZAg0bIAIoAiBB2YHCAEECIAIoAiQoAgwRAAANGwsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDBoLIAEoAgBBj8rEAEEMIAEoAgQoAgwRAAAhAwwZC0EBIQMgASgCACIEQZvKxABBEiABKAIEIgYoAgwiBREAAA0YIABBAWohAAJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANGiAAIAEQ2QJFDQEMGgsgBEHbgcIAQQIgBREAAA0ZIAJBAToADCACIAY2AhggAiAENgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQQxqNgIcIAIgAkEUajYCICAAIAJBIGoQ2QINGSACKAIgQdmBwgBBAiACKAIkKAIMEQAADRkLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwYCyABKAIAQa3KxABBDiABKAIEKAIMEQAAIQMMFwsgASgCAEG7ysQAQRkgASgCBCgCDBEAACEDDBYLIAEoAgBB1MrEAEEYIAEoAgQoAgwRAAAhAwwVCyABKAIAQezKxABBFiABKAIEKAIMEQAAIQMMFAsgASgCAEGCy8QAQQ0gASgCBCgCDBEAACEDDBMLIAEoAgBBj8vEAEERIAEoAgQoAgwRAAAhAwwSC0EBIQMgAiAAQQFqNgIMIAEoAgAiAEGgy8QAQRggASgCBCIFKAIMIgQRAAANEQJAIAEtAApBgAFxRQRAIABBu7PFAEEBIAQRAAANEyACQQxqIAEQxARFDQEMEwsgAEHbgcIAQQIgBBEAAA0SIAJBAToAEyACIAU2AhggAiAANgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQRNqNgIcIAIgAkEUajYCICACQQxqIAJBIGoQxAQNEiACKAIgQdmBwgBBAiACKAIkKAIMEQAADRILIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwRC0EBIQMgAiAAQQFqNgIMIAEoAgAiAEG4y8QAQRQgASgCBCIFKAIMIgQRAAANEAJAIAEtAApBgAFxRQRAIABBu7PFAEEBIAQRAAANEiACQQxqIAEQxARFDQEMEgsgAEHbgcIAQQIgBBEAAA0RIAJBAToAEyACIAU2AhggAiAANgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQRNqNgIcIAIgAkEUajYCICACQQxqIAJBIGoQxAQNESACKAIgQdmBwgBBAiACKAIkKAIMEQAADRELIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwQC0EBIQMgAiAAQQFqNgIMIAEoAgAiAEHMy8QAQRUgASgCBCIFKAIMIgQRAAANDwJAIAEtAApBgAFxRQRAIABBu7PFAEEBIAQRAAANESACQQxqIAEQxARFDQEMEQsgAEHbgcIAQQIgBBEAAA0QIAJBAToAEyACIAU2AhggAiAANgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQRNqNgIcIAIgAkEUajYCICACQQxqIAJBIGoQxAQNECACKAIgQdmBwgBBAiACKAIkKAIMEQAADRALIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwPCyABKAIAQeHLxABBDCABKAIEKAIMEQAAIQMMDgsgASgCAEHty8QAQQ4gASgCBCgCDBEAACEDDA0LIAEoAgBB+8vEAEEOIAEoAgQoAgwRAAAhAwwMC0EBIQMgASgCACIEQYnMxABBDyABKAIEIgYoAgwiBREAAA0LIABBAWohAAJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANDSAAIAEQqwNFDQEMDQsgBEHbgcIAQQIgBREAAA0MIAJBAToADCACIAY2AhggAiAENgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQQxqNgIcIAIgAkEUajYCICAAIAJBIGoQqwMNDCACKAIgQdmBwgBBAiACKAIkKAIMEQAADQwLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwLCyABKAIAQZjMxABBESABKAIEKAIMEQAAIQMMCgtBASEDIAIgAEEBajYCDCABKAIAIgBBqczEAEERIAEoAgQiBSgCDCIEEQAADQkCQCABLQAKQYABcUUEQCAAQbuzxQBBASAEEQAADQsgAkEMaiABEMQERQ0BDAsLIABB24HCAEECIAQRAAANCiACQQE6ABMgAiAFNgIYIAIgADYCFCACQeCBwgA2AiQgAiABKQIINwIoIAIgAkETajYCHCACIAJBFGo2AiAgAkEMaiACQSBqEMQEDQogAigCIEHZgcIAQQIgAigCJCgCDBEAAA0KCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMCQtBASEDIAEoAgAiBEG6zMQAQRkgASgCBCIGKAIMIgURAAANCCAAQQFqIQACQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQogACABEKcERQ0BDAoLIARB24HCAEECIAURAAANCSACQQE6AAwgAiAGNgIYIAIgBDYCFCACQeCBwgA2AiQgAiABKQIINwIoIAIgAkEMajYCHCACIAJBFGo2AiAgACACQSBqEKcEDQkgAigCIEHZgcIAQQIgAigCJCgCDBEAAA0JCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMCAtBASEDIAEoAgAiBEHTzMQAQRogASgCBCIGKAIMIgURAAANByAAQQFqIQACQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQkgACABEKcERQ0BDAkLIARB24HCAEECIAURAAANCCACQQE6AAwgAiAGNgIYIAIgBDYCFCACQeCBwgA2AiQgAiABKQIINwIoIAIgAkEMajYCHCACIAJBFGo2AiAgACACQSBqEKcEDQggAigCIEHZgcIAQQIgAigCJCgCDBEAAA0ICyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMBwtBASEDIAEoAgAiBEHtzMQAQRsgASgCBCIGKAIMIgURAAANBiAAQQFqIQACQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQggACABEKcERQ0BDAgLIARB24HCAEECIAURAAANByACQQE6AAwgAiAGNgIYIAIgBDYCFCACQeCBwgA2AiQgAiABKQIINwIoIAIgAkEMajYCHCACIAJBFGo2AiAgACACQSBqEKcEDQcgAigCIEHZgcIAQQIgAigCJCgCDBEAAA0HCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMBgsgASgCAEGIzcQAQRYgASgCBCgCDBEAACEDDAULQQEhAyABKAIAIgRBns3EAEESIAEoAgQiBigCDCIFEQAADQQCQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQYgACgCCCAAKAIMIAEQtQJFDQEMBgsgBEHbgcIAQQIgBREAAA0FIAJBAToADCACIAY2AhggAiAENgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQQxqNgIcIAIgAkEUaiIENgIgIAAoAgggACgCDCACQSBqELUCDQUgBEHZgcIAQQIQrwMNBQsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAQLQQEhAyABKAIAIgRBsM3EAEEQIAEoAgQiBigCDCIFEQAADQMCQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQUgACgCCCAAKAIMIAEQtQJFDQEMBQsgBEHbgcIAQQIgBREAAA0EIAJBAToADCACIAY2AhggAiAENgIUIAJB4IHCADYCJCACIAEpAgg3AiggAiACQQxqNgIcIAIgAkEUaiIENgIgIAAoAgggACgCDCACQSBqELUCDQQgBEHZgcIAQQIQrwMNBAsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAMLIAEoAgBBwM3EAEETIAEoAgQoAgwRAAAhAwwCCyABKAIAQdPNxABBECABKAIEKAIMEQAAIQMMAQsgASgCAEHjzcQAQQwgASgCBCgCDBEAACEDCyACQTBqJAAgAwveGQMmfwp7BX4jAEEgayIIJAAgAC8BJCIEQQ9qIgtB8P8DcSEFIAtB8P8HcSEMIAAoAiAhCSAAKAIcIRIgACgCFCEGIAAoAhAhEyAAKAIIIQcgACgCBCEUAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMEQCAMQf//A3EiDEUNASAJIAVBAXYiCnAhACAGIApwIQMgBEUNAiAHIAVuIgcgAiAEQQJ0IhduIgIgAiAHSxsiJkUNEiAJIABrIRggBiADayEZIAQgDEsNESAEQQFxIScgCq0hNiAXQQhrQQN2IgAgBEEBdiICIAAgAkkbIgAgBCACa0H//wNxIhAgACAQSRsiIUF/cyAhQQFqIgBBA3EiAkEEIAIbIgJqISIgBEH+/wNxIhogACACayIdQQF0IihrISMgF0H4/w9xIhUgHUEDdCIpayEkIAEhDCAUIRFBACEHQQAhCQNAAn4gCUUgNEKAgICAEFRyRQRAIDSnIQQgNEKAgICAcINCgICAgBB9DAELIAogGUsNFCAZIAprIRkgNiE0IBMiCSAKIgRqIRNCgICAgBALITcCfiAHRSA1QoCAgIAQVHJFBEAgNachACA1QoCAgIBwg0KAgICAEH0MAQsgCiAYSw0UIBggCmshGCA2ITUgEiIHIAoiAGohEkKAgICAEAshOCAEIBBJDQQgACAQSQ0FIBQgBSAbbGohHCABIBcgG2xqIR4gNEL/////D4MgNUL/////D4MhNSAJIBBqISUgByELIAkhDQJAAkAgFUUNACAVIQYgHiEAIBohBCAcIQ4gIUEETwRAIA4gKGohDiAHIB1qIQsgCSAdaiENIAAgKWohACAJIQMgByEPICIhAiAMIQQgESEGA0AgBEEYaiAP/VwAAP2JAf2pASIv/QwlZgAAJWYAACVmAAAlZgAA/bUBQQj9rQH9DGbI//9myP//Zsj//2bI///9rgEiMCAG/V0AACItICv9DQACBAYAAAAAAAAAAAAAAAD9iQH9qQH9DIVKAACFSgAAhUoAAIVKAAAiMf21AUEI/a0BIi79rgFBBv2sAf0MAAAAAAAAAAAAAAAAAAAAACIr/bgB/Qz/AAAA/wAAAP8AAAD/AAAAIiz9tgEiKv0bAzoAACAEQRBqICr9GwI6AAAgBEEIaiAq/RsBOgAAIAQgKv0bADoAACAEQRpqIC4gA/1cAAD9iQH9qQEiMv0MGoEAABqBAAAagQAAGoEAAP21AUEI/a0B/Qzruv//67r//+u6///ruv///a4BIjP9rgFBBv2sASAr/bgBICz9tgEiKv0bAzoAACAEQRJqICr9GwI6AAAgBEEKaiAq/RsBOgAAIARBAmogKv0bADoAACAEQRxqIC0gK/0NAQMFBwAAAAAAAAAAAAAAAP2JAf2pASAx/bUBQQj9rQEiLSAw/a4BQQb9rAEgK/24ASAs/bYBIir9GwM6AAAgBEEUaiAq/RsCOgAAIARBDGogKv0bAToAACAEQQRqICr9GwA6AAAgBEEZaiAuIC/9DAg0AAAINAAACDQAAAg0AAD9tQFBCP2tASAy/QwTGQAAExkAABMZAAATGQAA/bUBQQj9rQH9rgEiLv2xAf0MBCIAAAQiAAAEIgAABCIAACIv/a4BQQb9rAEgK/24ASAs/bYBIir9GwM6AAAgBEERaiAq/RsCOgAAIARBCWogKv0bAToAACAEQQFqICr9GwA6AAAgBEEdaiAtIC79sQEgL/2uAUEG/awBICv9uAEgLP22ASIq/RsDOgAAIARBFWogKv0bAjoAACAEQQ1qICr9GwE6AAAgBEEFaiAq/RsAOgAAIARBHmogLSAz/a4BQQb9rAEgK/24ASAs/bYBIiv9GwM6AAAgBEEWaiAr/RsCOgAAIARBDmogK/0bAToAACAEQQZqICv9GwA6AAAgA0EEaiEDIA9BBGohDyAEQSBqIQQgBkEIaiEGIAJBBGoiAg0ACyAkIQYgIyEECwNAIARFDQEgDSAlRg0CIABBAmpB/wEgDi0AAEGFlQFsQQh2IgIgDS0AACIPQZqCAmxBCHZBlYoBayIDakEGdSIfQQAgH0EAShsiHyAfQf8BThs6AAAgAEH/ASALLQAAIh9BpcwBbEEIdkGa7wBrIiAgAmpBBnUiFkEAIBZBAEobIhYgFkH/AU4bOgAAIABBBmpB/wEgAyAOQQFqLQAAQYWVAWxBCHYiA2pBBnUiFkEAIBZBAEobIhYgFkH/AU4bOgAAIABBBGpB/wEgAyAgakEGdSIgQQAgIEEAShsiICAgQf8BThs6AAAgAEEBakH/ASACIB9BiOgAbEEIdiAPQZMybEEIdmoiAmtBhMQAakEGdSIPQQAgD0EAShsiDyAPQf8BThs6AAAgAEEFakH/ASADIAJrQYTEAGpBBnUiAkEAIAJBAEobIgIgAkH/AU4bOgAAIABBCGohACAOQQJqIQ4gC0EBaiELIA1BAWohDSAEQQJrIQQgBkEIayIGDQALCyAnRSALIAcgEGpGciANICVGcg0AIBUgHmoiAEH/ASAaIBxqLQAAQYWVAWxBCHYiAiANLQAAIgNBmoICbEEIdmpBlYoBa0EGdSIEQQAgBEEAShsiBCAEQf8BThs6AAIgAEH/ASACIAstAAAiBEGlzAFsQQh2akGa7wBrQQZ1IgZBACAGQQBKGyIGIAZB/wFOGzoAACAAQf8BIAIgA0GTMmxBCHYgBEGI6ABsQQh2amtBhMQAakEGdSIAQQAgAEEAShsiACAAQf8BThs6AAELIDeEITQgNSA4hCE1IAwgF2ohDCAFIBFqIREgG0EBaiIbICZJDQALDBILIAQgB0sNBCAEIARBAXZrIgMgBksNBSADIAlLDQYgAiAEQQJ0IgpJDQcgAC8BJiEVIAEgCiAUIAQgEyADIBIgAxBuIARFDQggAiAKayICIARBA3QiDXAhDyAFIBVsIgAgBUkgACAHS3INCSAMQf//A3EiDEUNCiAFQQF2IQcgASAKaiEaIAAgBWsiACAAIAVBAXQiEXAiHmshACAFIBRqIRwCQCACIA9rIiIgDUkNACAEIAxLBEAgBSAJSyAFIAZLciAAIBFJcg0BQQAgBCAFQejpxAAQ6gcACyADIAdLBEAgBSAJSyAFIAZLciAAIBFJcg0BQQAgAyAHQdjpxAAQ6gcACyAAIBFJIAUgBktyIAUgCUtyIQIgBSAHayIMIANJBEAgAg0BQQAgAyAMQcjpxAAQ6gcACyACDQAgGiAKIBwgBCATIAMgByATaiIjIAMgEiADIAcgEmoiJCADEGYgCiAaaiAKIAUgHGogBCAjIAMgEyADICQgAyASIAMQZiAiIA1rIgwgDUkNACAHQQFrIRAgBiAHayEXIAUgE2ohGCAEQQR0IRkgBEEMbCEbIAUgEmohHSALQfD/A3FBBHYiAkEGdCEhIAJBMGwhJUEAIQsgACECA0AgAiARayICIBFJIAYgC2pBAWsgEElyIAsgF2ogBUkgCSALakEBayAQSXJyDQEgCSALIAdrIgtqIAVJDQEgASAbaiAKIBQgJWogBCAOICNqIiYgAyAOIBhqIicgAyAOICRqIiggAyAOIB1qIikgAxBmIAEgGWogCiAUICFqIAQgJyADICYgAyApIAMgKCADEGYgESAUaiEUIAEgDWohASAHIA5qIQ4gDCANayIMIA1PDQALCyAPRQ0RIAYgFUEBcSAVQQF2akEBayAHbCIBSQ0LIAEgCUsNDCAEIB5LDQ0gAyAGIAFrIgJLDQ4gAyAJIAFrIgJLDQ8gGiAiaiAPIAAgHGogBCABIBNqIAMgASASaiADEG4MEQsgCEEANgIYIAhBATYCDCAIQbyhxwA2AgggCEIENwIQIAhBCGpByOrEABCNCAALIAhBADYCGCAIQQE2AgwgCEG8occANgIIIAhCBDcCECAIQQhqQdjqxAAQjQgAC0EAIBAgBEH46sQAEOoHAAtBACAQIABB6OrEABDqBwALQQAgBCAHQbjqxAAQ6gcAC0EAIAMgBkGo6sQAEOoHAAtBACADIAlBmOrEABDqBwALQQAgCiACQYjqxAAQ6gcACyAIQQA2AhggCEEBNgIMIAhBvKHHADYCCCAIQgQ3AhAgCEEIakHY6MQAEI0IAAsgBSAAIAdB+OnEABDqBwALIAhBADYCGCAIQQE2AgwgCEG8occANgIIIAhCBDcCECAIQQhqQejoxAAQjQgACyABIAYgBkG46cQAEOoHAAsgASAJIAlBqOnEABDqBwALQQAgBCAeQZjpxAAQ6gcAC0EAIAMgAkGI6cQAEOoHAAtBACADIAJB+OjEABDqBwALIAogGUsgCiAYS3INAEEAIAQgBUGI68QAEOoHAAsgCEEgaiQAC50YBCB/AX0BewF+IwBBsMAAayIHJAACQAJAAkAgAiADQf8BcUECdCIFKAKAhUlwRQRAQQEhCCACIAUoApCFSW5BAnQiDARAAkAgDEEATgRAIAdBADYCtCAgB0EwakEBIAwgB0GwIGoQhQcgBygCMEEBRw0BIAcoAjghCCAHKAI0IQQLIAcgCDYCtCAgByAENgKwIEHgvsQAQTYgB0GwIGpB0L7EAEGYv8QAEOAGAAsgBygCNCEICyAHQQA2AiwgByAINgIoIAcgDDYCJAJAAkAgA0H/AXFBAWsOAwMBAQALIAJBA24iBUECdCIOBEAgDCAOSQRAIAdBJGpBACAOEO8FIAcoAighCCAHKAIsIQQLIAQgCGohAyAOQQFrIgIEQCADQQAgAvwLAAsgAiADakEAOgAAIAQgDmohBAsgByAENgIsIARBAnYiAiAFIAIgBUkbIgJFDQNBACEFIAJBAUcEQCACQQFxIAJB/v///wNxIQIgCCEGIAEhBANAIAZBA2pB/wE6AAAgBiAELwAAOwAAIAZBAmogBEECai0AADoAACAGQQdqQf8BOgAAIAZBBmogBEEFai0AADoAACAGQQRqIARBA2ovAAA7AAAgBkEIaiEGIARBBmohBCACIAVBAmoiBUcNAAtFDQQLIAggBUECdGoiAkH/AToAAyACIAEgBUEDbGoiAS0AAjoAAiACIAEvAAA7AAAMAwsgB0EQaiAHQSxqKAIANgIAIAcgBykCJDcDCCAHQbAgahDuAiAHKAKwIEUEQCAHQSRqQQEQ0QkLAkAgAiADQf8BcUECdCgCoIVJbkECdCIRIAcoAhAiBk0EQCAHKAIMIRIMAQsgESAGayIFIAcoAgggBmtLBEAgB0EIaiAGIAUQ7wUgBygCECEGCyAHKAIMIhIgBmohBCAFQQJPBH8gBUEBayIFBEAgBEEAIAX8CwALIBIgBSAGaiIGagUgBAtBADoAACAGQQFqIRELIAcgETYCEAJ/An8CQAJAAkACQCADQf8BcUEBaw4DAQIDAAsgB0EwakEAQYAg/AsAIAdBsCBqQQBBgCD8CwAgAkEDbiENQQEhHkEDDAQLIAdBMGpBAEGAIPwLACAHQbAgakEAQYAg/AsAIAJBAnYMAgsgB0EwakEAQYAg/AsAIAdBsCBqQQBBgCD8CwBBASEeIAIhDUEDDAILIAdBMGpBAEGAIPwLACAHQbAgakEAQYAg/AsAIAJBAXYLIQ1BBAshFgJAAkACQCANBEAgDUEIdiANQf8BcUEAR2oiBEEBayIFQQAgBCAFTxshBiABIRcgASEYIAEhDCABIQ5BgAIhGgNAIAYhHyAWIA0gGiANIBpJGyITIBRBCHRrIghsIhVB//8DcUEDbiEGIBYgEyAgamxB//8DcUEDbiEEAkACQAJAAkAgDSAPQYACaiIFIAUgDUsbIhAgD2siGyAWbCILQYEISQRAIBNBAnQhHCAWIBMgIWoiHWwhCQJAAkACQAJAAkACQAJAIANB/wFxQQFrDgMBBQIACyAQQQNsIgQgD0EDbCIFTyACIARPcQ0CIAUgBCACQfi8xAAQ6gcACyAQQQJ0IgQgD0ECdCIFTyACIARPcQ0CIAUgBCACQYi9xAAQ6gcACyAQQQF0IgUgD0EBdCIKTyACIAVPcQ0DIAogBSACQdi9xAAQ6gcACyALIAQgBWsiBSAFIAtLG0UNByAJICIgE0EDbCIEaiIFIAUgCUsbIQpBACEGIBUgFEGAemwgBGoiBSAFIBVLGyIJQQRPBEAgCkF8cSEIIAlBfHEhBiAHQTBqIQQgFyEFA0AgBCAF/VwAAP2JAf2pAf37Af0MgYCAO4GAgDuBgIA7gYCAO/3mAf0LAgAgBUEEaiEFIARBEGohBCAIQQRrIggNAAsgBiAJRg0ICyAHQTBqIAZBAnRqIQQDQCAEIAYgF2otAACzQ4GAgDuUOAIAIARBBGohBCAKIAZBAWoiBkcNAAsMBwsgCyAEIAVrIgUgBSALSxtFDQYgCSAZIBxqIgUgBSAJSxshCkEAIQYgFSAcIBRBCnRrIgUgBSAVSxsiCUEETwRAIApBfHEhCCAJQXxxIQYgB0EwaiEEIBghBQNAIAQgBf1cAAD9iQH9qQH9+wH9DIGAgDuBgIA7gYCAO4GAgDv95gH9CwIAIAVBBGohBSAEQRBqIQQgCEEEayIIDQALIAYgCUYNBwsgB0EwaiAGQQJ0aiEEA0AgBCAGIBhqLQAAs0OBgIA7lDgCACAEQQRqIQQgCiAGQQFqIgZHDQALDAYLIA8gEEsNAiALQf//A3FBA24iBSAbIAUgG0kbRQ0FIAQgHSAEIB1JGyEKQQAhBCAGIAggBiAISRsiCUEETwRAIApB/P8BcSEIIAlB/P8BcSEEIAdBMGohBiAMIQUDQCAGIAX9XAAA/YkB/akB/fsB/QyBgIA7gYCAO4GAgDuBgIA7/eYBIiUgJf0NCAkKCwwNDg8MDQ4PDA0OD/0LAiAgBiAlICX9DQQFBgcEBQYHCAkKCwgJCgv9CwIQIAYgJSAl/Q0AAQIDAAECAwABAgMEBQYH/QsCACAFQQRqIQUgBkEwaiEGIAhBBGsiCA0ACyAEIAlGDQYLIAdBMGogBEEMbGohBgNAIAZBCGogBCAMai0AALNDgYCAO5QiJDgCACAGQQRqICQ4AgAgBiAkOAIAIAZBDGohBiAKIARBAWoiBEcNAAsMBQsgC0ECdiIEIAUgCmtBAXYiBSAEIAVJG0UNBEEAIQUgFUECdiIGIBNBAXQiCCAUQQl0a0EBdiIEIAQgBksbIgZBAUYNAyAJQQJ2IgQgCCAjakEBdiIFIAQgBUkbQf7///8DcSEJIAZBAXEhCEEAIQUgB0EwaiEGIA4hBANAIAYgBP1cAAD9iQH9qQH9+wH9DIGAgDuBgIA7gYCAO4GAgDv95gEiJSAl/Q0ICQoLCAkKCwgJCgsMDQ4P/QsCECAGICUgJf0NAAECAwABAgMAAQIDBAUGB/0LAgAgBEEEaiEEIAZBIGohBiAJIAVBAmoiBUcNAAsMAgtBACALQYAIQei9xAAQ6gcACyAPIBAgAkGYvcQAEOoHAAsgCEUNAQsgB0EwaiAFQQR0aiIEIAEgCmogBUEBdGoiBS0AALNDgYCAO5QiJDgCCCAEICQ4AgQgBCAkOAIAIAQgBS0AAbNDgYCAO5Q4AgwLAn8gHkUEQCAbQQJ0IgQgC0sNBSAHQTBqDAELIAtB//8DcUEDbiEFAkAgC0EDSQ0AQYACIAUgBUGAAk8bIQlBASEFIAdBsCBqIQYgB0EwaiEEA0AgBiAEKgIAOAIAIAZBDGpBgICA/AM2AgAgBkEEaiAEQQRqKQIANwIAIAUgHUYNASAEQQxqIQQgBkEQaiEGIAUgCUkgBUEBaiEFDQALCyAbQQJ0IgRBgQhPDQMgB0GwIGoLIQYgEEECdCIIIBFLIAggD0ECdCIFSXINBCAIIAVrIgUgBCAEIAVLGwRAQQAgHGshBSASIQQDQCAEQf8BIAYqAgBDAAB/Q5QQuQciJPwBQQAgJEMAAAAAYBsgJEMAAH9DXhs6AAAgBEEBakH/ASAGQQRqKgIAQwAAf0OUELkHIiT8AUEAICRDAAAAAGAbICRDAAB/Q14bOgAAIARBAmohBCAGQQhqIQYgGSAFQQJqIgVHDQALCyASQYAIaiESIBdBgAZqIRcgIkGABmshIiAYQYAIaiEYIBlBgAhrIRkgDEGAAmohDCAgQYACayEgICNBgARrISMgIUGAAmshISAOQYAEaiEOIBRBAWohFCAfQQFrIQYgGiIPQYACaiEaIB8NAAsLIAAgBykDCDcCACAAQQhqIAdBEGooAgA2AgAMBgtBACAEQYAIQai9xAAQ6gcAC0EAIAQgC0HIvcQAEOoHAAsgBSAIIBFBuL3EABDqBwALQfi9xABBxQBBwL7EABDrBwALIAcCfwJAIAIgDEsEQCAHQSRqQQAgAhDvBSAHKAIoIQggBygCLCEGDAELQQAgAkUNARoLIAIEQCAGIAhqIAEgAvwKAAALIAIgBmoLNgIsCyAHQSBqIAdBLGooAgAiATYCACAHIAcpAiQiJjcDGCAAQQhqIAE2AgAgACAmNwIACyAHQbDAAGokAAuOHgINfwF+IwBBsAFrIgIkACABKAIMIQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABKAIUIgQgASgCECIGSQRAIAFBDGohBQNAAkACQCAEIAdqLQAAIgNBCWsOJQEBCwsBCwsLCwsLCwsLCwsLCwsLCwsLAQsICwsLCwsLCwsLCwcACyADQdsAaw4hCAoKCgoKCgoKCgoFCgoKCgoKCgMKCgoKCgQKCgoKCgoJCgsgASAEQQFqIgQ2AhQgBCAGRw0ACyAGIQQLIAJBCGogByAGIARBAWoiASAGIAEgBkkbEPkBIAIoAgwhAyACKAIIIQVBFBBxIgFFDRsgASAFNgIMIAFBBTYCACAAIAE2AgQgAEGVgICAeDYCACABIAM2AhAMGgsgASAEQQFqIgU2AhQCQCAFIAZPDQAgASAEQQJqIgM2AhQgBSAHai0AAEH1AEcNGCADIAUgBiAFIAZLGyIFRg0AIAEgBEEDaiIJNgIUIAMgB2otAABB7ABHBEAgCSEDDBkLIAUgCUYNACABIARBBGoiAzYCFCAHIAlqLQAAQewARw0YIABCkoCAgAg3AwAMGgsgAkEQaiAHIAYgBRD5ASACKAIUIQEgAigCECEDQRQQcSIERQ0aIARBBTYCAAwYCyABIARBAWoiBTYCFAJAIAUgBk8NACABIARBAmoiAzYCFCAFIAdqLQAAQfIARw0VIAMgBSAGIAUgBksbIgVGDQAgASAEQQNqIgk2AhQgAyAHai0AAEH1AEcEQCAJIQMMFgsgBSAJRg0AIAEgBEEEaiIDNgIUIAcgCWotAABB5QBHDRUgAEKAgICAGDcDAAwZCyACQSBqIAcgBiAFEPkBIAIoAiQhASACKAIgIQNBFBBxIgRFDRkgBEEFNgIADBULIAEgBEEBaiIFNgIUAkAgBSAGTw0AIAEgBEECaiIDNgIUIAUgB2otAABB4QBHDRIgAyAFIAYgBSAGSxsiBUYNACABIARBA2oiCTYCFCADIAdqLQAAQewARwRAIAkhAwwTCyAFIAlGDQAgASAEQQRqIgg2AhQgByAJai0AAEHzAEcEQCAIIQMMEwsgBSAIRg0AIAEgBEEFaiIDNgIUIAcgCGotAABB5QBHDRIgAEKAgICACDcDAAwYCyACQTBqIAcgBiAFEPkBIAIoAjQhASACKAIwIQNBFBBxIgRFDRggBEEFNgIADBILIAEgBEEBajYCFCACQeAAaiABQQAQxwMgAikDYCIPQgNRDQ8gACACKQNoNwMIIABBADYCBCAAIA+nQQJ0KALM60E2AgAMFgsgAUEANgIIIAEgBEEBajYCFCACQeAAaiAFIAEQggIgAigCZCEFIAIoAmAiA0ECRg0NIAIoAmghASADQQFxRQ0EIAFBAEgNAwJAIAFFBEBBASEDDAELIAEQcSIDRQ0XCyABBEAgAyAFIAH8CgAACyAAIAE2AgwgACADNgIIIAAgATYCBCAAQYyAgIB4NgIADBULIAEgAS0AGEEBayIFOgAYIARBAWohAyAFQf8BcUUNCyABIAM2AhQgAkEBOgCUASACIAE2ApABIAJCgICAgIABNwKgAUEAIQRBCCEDQQghBgJAA0ACQCACIAQ2AqgBIAJB4ABqIAJBkAFqEJ8DAkACQCACLQBgQQFGBEAgAigCZCEFDAELIAItAGFBAUcNAiACQeAAaiACKAKQARCCASACKAJkIQUgAigCYCIMQZWAgIB4Rw0BCyACKAKkASEGIAQEQCAGIQMDQCADEP4CIANBEGohAyAEQQFrIgQNAAsLQZWAgIB4IQRBASEJIAIoAqABIgNFDQMgBkEEaygCACIIQXhxIgcgA0EEdCIDQQRBCCAIQQNxIggbckkNCCAIQQAgByADQSdqSxsNCSAGEKICDAMLIAIpA2ghDyACKAKgASAERgRAIwBBIGsiBiQAAkACQCACQaABaiIIKAIAIgdB////P0sNAEEEIAdBAXQiDSANQQRNGyINQQR0Ig5B+P///wdLDQAgBiAHBH8gBiAHQQR0NgIcIAYgCCgCBDYCFEEIBUEACzYCGCAGQQhqQQggDiAGQRRqEIUHIAYoAghBAUcNASAGKAIQIQogBigCDCELCyALIApBxKLBABCTCQALIAYoAgwhByAIIA02AgAgCCAHNgIEIAZBIGokACACKAKkASEGCyADIAZqIgggDzcCACAIQQRrIAU2AgAgCEEIayAMNgIAIANBEGohAyAEQQFqIQQMAQsLQZSAgIB4IQQgAikCpAEhDyACKAKgASEFCyABIAEtABhBAWo6ABggAiABELoDIgM2AnAgAiAPNwNoIAIgBTYCZCACIAQ2AmACQAJAIAlFBEAgAw0BIA9CIIinIQMgD6chCQwMC0GVgICAeCEEIANFDQEgAkHwAGoQsQQMAQsgAkHgAGoQ/gJBlYCAgHghBCADIQULDAkLIAEgAS0AGEEBayIFOgAYIARBAWohAyAFQf8BcUUNByABIAM2AhQgAkEBOgCAASACIAE2AnwgAkEANgKMASACQoCAgICAATcChAFBCCEFA0AgAkHgAGogAkH8AGoQ0QICQAJAIAItAGBBAUYEQCACKAJkIQYMAQsgAi0AYUUEQCAJrSEPIAIoAoQBIQQMCgsgAigCfCIIQQA2AgggCCAIKAIUQQFqNgIUIAJB4ABqIAhBDGogCBCCAiACKAJkIQYgAigCYCIDQQJGDQAgAigCaCEEAn8gA0EBcQRAIARBAEgNCgJAIARFBEBBASEDDAELIAQQcSIDRQ0aCyAEBEAgAyAGIAT8CgAACyAEIQZBjICAgHgMAQsgBCEDQY2AgIB4CyELIAIgBDYCrAEgAiADNgKoASACIAY2AqQBIAIgCzYCoAEgCCgCDCEHAkACQAJAIAgoAhQiBCAIKAIQIgNJBEADQAJAIAQgB2otAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMEAwsgCCAEQQFqIgQ2AhQgAyAERw0ACyADIQQLIAJB2ABqIAcgAyAEQQFqIgUgAyADIAVLGxD5ASACKAJcIQMgAigCWCEFQRQQcSIGRQ0aIAYgBTYCDCAGQQM2AgAgBiADNgIQDAILIAJB0ABqIAcgAyAEQQFqIgUgAyADIAVLGxD5ASACKAJUIQMgAigCUCEFQRQQcSIGRQ0ZIAYgBTYCDCAGQQY2AgAgBiADNgIQDAELIAggBEEBajYCFCACQeAAaiAIEIIBIAIoAmBBlYCAgHhHDQIgAigCZCEGCyACQaABahD+AgsgAigCiAEhAyAJBEAgAyEEA0AgBBD+AiAEQRBqEP4CIARBIGohBCAJQQFrIgkNAAsLQZWAgIB4IQQgAigChAEiBUUEQCAGIQUMCQsgAyAFQQV0QQgQogcgBiEFDAgLIAIgAv0AA2D9CwOQASACKQOoASEPIAIoAoQBIAlGBEBBACEIQQAhByMAQSBrIgMkAAJAAkAgAkGEAWoiBSgCACIEQf///x9LDQBBBCAEQQF0IgogCkEETRsiCkEFdCIMQfj///8HSw0AIAMgBAR/IAMgBEEFdDYCHCADIAUoAgQ2AhRBCAVBAAs2AhggA0EIakEIIAwgA0EUahCFByADKAIIQQFHDQEgAygCECEHIAMoAgwhCAsgCCAHQbSiwQAQkwkACyADKAIMIQQgBSAKNgIAIAUgBDYCBCADQSBqJAAgAigCiAEhBQsgBSAJQQV0aiIDIA83AgggAyAGNgIEIAMgCzYCACADIAL9AAOQAf0LAhAgAiAJQQFqIgk2AowBDAALAAsgA0Ewa0H/AXFBCk8EQCACIAcgBiAEQQFqIgMgBiADIAZJGxD5ASACKAIEIQMgAigCACEEQRQQcSIFRQ0UIAUgBDYCDCAFQQo2AgAgBSADNgIQDAkLIAJB4ABqIAFBARDHAyACKQNgIg9CA1EEQCAAIAIoAmg2AgQgAEGVgICAeDYCAAwTCyAAIAIpA2g3AwggAEEANgIEIAAgD6dBAnQoAszrQTYCAAwSC0HYmsgAEP8HAAsgACABNgIIIAAgBTYCBCAAQY2AgIB4NgIADBALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HYmsgAEP8HAAsgASABLQAYQQFqOgAYIAIgARDiBCIDNgJwIAIgBTYCZCACIAQ2AmAgAiAPNwNoAkACQCAEQZWAgIB4RwRAIAMNASAPQiCIpyEDIA+nIQkMBAsgAw0BQZWAgIB4IQQgD6chCQwDCyACQeAAahD+AkGVgICAeCEEIAMhBSAPpyEJDAILIAJB8ABqELEEQZWAgIB4IQQgD6chCQwBCyACQcgAaiAHIAYgAyAGIAMgBkkbEPkBIAIoAkwhAyACKAJIIQVBFBBxIgFFDQwgASAFNgIMIAFBGDYCACAAIAE2AgQgAEGVgICAeDYCACABIAM2AhAMCwsgBEGVgICAeEYNACAAIAM2AgwgACAJNgIIIAAgBTYCBCAAIAQ2AgAMCgsgBSABEOsFIQEgAEGVgICAeDYCACAAIAE2AgQMCQsgAkFAayAHIAYgAyAGIAMgBkkbEPkBIAIoAkQhAyACKAJAIQVBFBBxIgFFDQkgASAFNgIMIAFBGDYCACAAIAE2AgQgAEGVgICAeDYCACABIAM2AhAMCAsgAEGVgICAeDYCACAAIAU2AgQMBwsgACACKAJoNgIEIABBlYCAgHg2AgAMBgsgAkE4aiAHIAYgAxD5ASACKAI8IQEgAigCOCEDQRQQcSIERQ0GIARBCTYCAAsgBCADNgIMIAAgBDYCBCAAQZWAgIB4NgIAIAQgATYCEAwECyACQShqIAcgBiADEPkBIAIoAiwhASACKAIoIQNBFBBxIgRFDQQgBEEJNgIACyAEIAM2AgwgACAENgIEIABBlYCAgHg2AgAgBCABNgIQDAILIAJBGGogByAGIAMQ+QEgAigCHCEBIAIoAhghA0EUEHEiBEUNAiAEQQk2AgALIAQgAzYCDCAAIAQ2AgQgAEGVgICAeDYCACAEIAE2AhALIAJBsAFqJAAPCwAL2xoDE38GfQF+IwBBsAFrIgIkAAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAhQiAyABKAIQIgRJBEAgASgCDCEGAn4CQANAIAMgBmotAAAiBUEJayIHQRdLQQEgB3RBk4CABHFFcg0BIAEgA0EBaiIDNgIUIAMgBEcNAAsgBCEDQgAMAQtCgAILIAWtQhCGhEKAgrgDUQ0BCwJAIAJBKGogASgCDCIHIAQgAyAESQR/A0AgAyAHai0AACIIQQlrIgVBF0tBASAFdEGTgIAEcUVyDQIgASADQQFqIgM2AhQgAyAERw0ACyAEBSADC0EBaiIBIAQgASAESRsQ+QEgAigCLCEBIAIoAighBEEUEHEiAw0CDBALAkAgCEHbAEcEQCAIQfsARg0BIAEgAkGvAWpBmMHBABDuASEFDA4LIAEgAS0AGEEBayIFOgAYIANBAWohAyAFQf8BcUUNCyABIAM2AhQgAiABNgKkASACQQE6AKgBIAJB5ABqIAJBpAFqEJ8DIAItAGRBAUYEQCACKAJoIQRBAiEDDAoLAkACQAJAAkACQAJAAkACQAJAAkACQCACLQBlQQFGBEAgAkHkAGogAigCpAEQ0gIgAigCZCIFQQJGBEAgAigCaCEEQQIhAwwWCyACKAJoIQ8gAkHkAGogAkGkAWoQnwMgAi0AZEEBRgRAIAIoAmghBEECIQMMFgsgAi0AZUEBRw0CIAJB5ABqIAIoAqQBENICIAIoAmQiB0ECRw0BIAIoAmghBEECIQMMFQtBAEGMg8EAQYD9wAAQ2wYhBEECIQMMFAsgAioCaCEVIAJB5ABqIAJBpAFqEJ8DIAItAGRBAUYEQCACKAJoIQRBAiEDDBQLIAItAGVBAUcNAiACQeQAaiACKAKkARDSAiACKAJkIghBAkcNASACKAJoIQRBAiEDDBMLQQFBjIPBAEGA/cAAENsGIQRBAiEDDBILIAIqAmghFiACQeQAaiACQaQBahCfAyACLQBkQQFGBEAgAigCaCEEQQIhAwwSCyACLQBlQQFHDQIgAkHkAGogAigCpAEQ0gIgAigCZCIQQQJHDQEgAigCaCEEQQIhAwwRC0ECQYyDwQBBgP3AABDbBiEEQQIhAwwQCyACKgJoIRcgAkHkAGogAkGkAWoQnwMgAi0AZEEBRgRAIAIoAmghBEECIQMMEAsgAi0AZUEBRw0CIAJB5ABqIAIoAqQBENICIAIoAmQiEUECRw0BIAIoAmghBEECIQMMDwtBA0GMg8EAQYD9wAAQ2wYhBEECIQMMDgsgAioCaCEYIAJB5ABqIAJBpAFqEJ8DIAItAGRBAUYEQCACKAJoIQRBAiEDDA4LIAItAGVBAUcNASACQeQAaiACKAKkARDSAkECIQMgAigCZCISQQJGBEAgAigCaCEEDA4LIAIoAmghCiACQeQAaiACQaQBahDHBiACKAJoIQQgAigCZCILQQJrDgICDQMLQQRBjIPBAEGA/cAAENsGIQRBAiEDDAwLQQVBjIPBAEGA/cAAENsGIQRBAiEDDAsLQQZBjIPBAEGA/cAAENsGIQQMCgsgAkHkAGohCSMAQRBrIgYkACAGQQhqIAJBpAFqIgwQnwMCQCAGLQAIQQFGBEAgCSAGKAIMNgIEIAlBAToAAAwBCyAGLQAJRQRAIAlBgAY7AQAMAQsgBkEIaiAMKAIAEIECIAYtAAhBAUYEQCAJIAYoAgw2AgQgCUEBOgAADAELIAkgBi0ACToAASAJQQA6AAALIAZBEGokACACLQBkDQggAi0AZSITQQNHBEAgBCEUIA8hBCAFIQMMCgtBB0GMg8EAQYD9wAAQ2wYhBAwJCyABIAEtABhBAWsiBToAGCADQQFqIQMgBUH/AXFFDQYgASADNgIUIAJBAToAqAEgAiABNgKkAUEDIQZBAiEJQQIhDEECIQ1BAiELQQIhBUECIQ5BAiEKAn8CQANAAkAgAkHkAGoiBCACQaQBahDRAiACLQBkQQFGDQAgAi0AZUEBRw0GIAIoAqQBIgNBADYCCCADIAMoAhRBAWo2AhQgBCADQQxqIAMQggIgAigCaCEEIAIoAmRBAkYNAgJAAkACQAJAAkACQAJAAkACQAJAAkACQCACKAJsQQZrDgUAAwMDAQMLIARB4OrAAEEGENsHRQ0DIARB5urAAEEGENsHDQEgDkECRg0EQebqwABBBhCfByEEQQIMDgsgBEHs6sAAQQoQ2wdFDQQgBEH26sAAQQoQ2wdFDQUgBEGS68AAQQoQ2wcNASAGQQNGDQlBkuvAAEEKEJ8HIQRBAgwNCyAEQYDrwABBBhDbB0UNBSAEQYbrwABBBhDbB0UNBiAEQYzrwABBBhDbB0UNBwsgAxCgASIERQ0JDAoLIApBAkcEQEHg6sAAQQYQnwchBEECDAsLIAJB5ABqIAMQsAVBAiEDIAIoAmgiDyEEIAIoAmQiCkECRw0IDBALIAJB5ABqIAMQsAVBAiEDIAIoAmgiBL4hFyACKAJkIg5BAkcNBwwPCyAFQQJHBEBB7OrAAEEKEJ8HIQRBAgwJCyACQeQAaiADELAFQQIhAyACKAJoIgS+IRUgAigCZCIFQQJHDQYMDgsgC0ECRwRAQfbqwABBChCfByEEQQIMCAsgAkHkAGogAxCwBUECIQMgAigCaCIEviEWIAIoAmQiC0ECRw0FDA0LIA1BAkcEQEGA68AAQQYQnwchBEECDAcLIAJB5ABqIAMQsAVBAiEDIAIoAmgiBL4hGCACKAJkIg1BAkcNBAwMCyAMQQJHBEBBhuvAAEEGEJ8HIQRBAgwGCyACQeQAaiADELAFQQIhAyACKAJoIgS+IRkgAigCZCIMQQJHDQMMCwsgCUECRwRAQYzrwABBBhCfByEEQQIMBQsgAkHkAGogAxCwBUECIQMgAigCaCIEviEaIAIoAmQiCUECRw0CDAoLIAJB5ABqIAMQrAUgAi0AZSEGIAItAGRBAUcNAQsLIAIoAmghBAtBAgshAwwFCyABIANBAWoiBTYCFAJAIAQgBU0NACABIANBAmoiCDYCFCAFIAZqLQAAQfUARw0DIAggBSAEIAQgBUkbIgVGDQAgASADQQNqIgc2AhQgBiAIai0AAEHsAEcEQCAHIQgMBAsgBSAHRg0AIAEgA0EEaiIINgIUIAYgB2otAABB7ABHDQMgAEECNgIADA4LIAJBCGogBiAEIAUQ+QEgAigCDCEBIAIoAgghBEEUEHEiA0UNDiADQQU2AgAMAwsgAyAENgIMIANBBTYCACADIAE2AhAMCwsgCkEAIApBAkcbIQMgCUEAIAlBAkcbIRMgDEEAIAxBAkcbIRIgDUEAIA1BAkcbIQcgC0EAIAtBAkcbIQggBUEAIAVBAkcbIRAgDkEAIA5BAkcbIRFBAiAGIAZBA0YbIRQgDyEEDAILIAJBEGogBiAEIAgQ+QEgAigCFCEBIAIoAhAhBEEUEHEiA0UNCyADQQk2AgALIAMgBDYCDCAAIAM2AgQgAEEDNgIAIAMgATYCEAwJCyABIAEtABhBAWo6ABggAiABEOIEIgU2AqABIAIgFDoAnAEgAiAaOAKYASACIBM2ApQBIAIgGTgCkAEgAiASNgKMASACIBg4AogBIAIgBzYChAEgAiAWOAKAASACIAg2AnwgAiAVOAJ4IAIgEDYCdCACIBc4AnAgAiARNgJsIAIgBDYCaCACIAM2AmRBAiEHIANBAkcEQCAFDQQgAkHgAGogAkHsAGoiBUEwaigCADYCACACQdAAaiAFQSBq/QACAP0LAwAgAkFAayAFQRBq/QACAP0LAwAgAiAF/QACAP0LAzAgAyEHIAQhBQwECyAFRQRAIAQhBQwECyACQaABahCxBCAEIQUMAwsgAkEgaiAHIAQgAyAEIAMgBEkbEPkBIAIoAiAhBCACKAIkDAQLIAIoAmghBAsgASABLQAYQQFqOgAYIAIgARC6AyIFNgKgASACIBM6AJwBIAIgFDYCmAEgAiALNgKUASACIAo2ApABIAIgEjYCjAEgAiAYOAKIASACIBE2AoQBIAIgFzgCgAEgAiAQNgJ8IAIgFjgCeCACIAg2AnQgAiAVOAJwIAIgBzYCbCACIAQ2AmggAiADNgJkQQIhBwJAIANBAkcEQCAFDQIgAkHgAGogAkHsAGoiBUEwaigCADYCACACQdAAaiAFQSBq/QACAP0LAwAgAkFAayAFQRBq/QACAP0LAwAgAiAF/QACAP0LAzAgAyEHDAELIAVFDQAgAkGgAWoQsQQLIAQhBQsgB0ECRg0CIAAgAv0AAzD9CwIIIABBOGogAkHgAGooAgA2AgAgAEEoaiACQdAAav0AAwD9CwIAIABBGGogAkFAa/0AAwD9CwIAIAAgBTYCBCAAIAc2AgAMBAsgAkEYaiAHIAQgAyAEIAMgBEkbEPkBIAIoAhghBCACKAIcCyEBQRQQcSIDRQ0DIAMgBDYCDCADQRg2AgAgAyABNgIQDAELIAUgARDrBSEDCyAAQQM2AgAgACADNgIECyACQbABaiQADwsAC88XAyR/A30BeyMAQcACayIEJAACeyADLQAcIgVBAkYEQEMAAIA/IShBACEFQwAAgD8hKUMAAIA/ISr9DAAAAAAAAIA/AABAwQAAEEEMAQsgBEHiAWogA0Efai0AADoAACAEIAMvAB07AeABIAMqAhghKCADKgIUISkgAyoCECEqIAP9AAIACyErIARBABC2CTYCsAEgBEEANgKsASAEQgA3AqQBIARBADYCXCAEQoCAgIDAADcCVCAEQgQ3AkwgBEIANwJEIARCgICAgMAANwI8IARBADYCLCAEQQA2AiQgBEEANgIcIARBADYCFCAEQQA2AgwgBEEANgIEIARBADYCNCAEQYCAgIB4NgJsIARBgICAgHg2AnggBCAr/QsChAEgBCAqOAKUASAEICk4ApgBIAQgKDgCnAEgBCAFOgCgASAEQbwBakEAOgAAIARBowFqIARB4gFqLQAAOgAAIARBADYCaCAEQoCAgIDAADcCYCAEQgA3ArQBIAQgBC8B4AE7AKEBIAEoAjwhEyAEIAI6AOgBIAQgEzYC5AEgBCABKAIIIgg2AuABIARBBGogBEHgAWoQpQQgAgRAIARBAToAoAELAkACQAJAAkBBgIAwEHEiEEUNACAQQQRrIh0tAABBA3EEQCAQQQBBgIAw/AsAC0GAgBAQcSIJRQ0AIAlBBGsiHi0AAEEDcQRAIAlBAEGAgBD8CwALQYCAMBBxIhFFDQAgEUEEayIfLQAAQQNxBEAgEUEAQYCAMPwLAAtBgIAwEHEiEkUNACASQQRrIiAtAABBA3EEQCASQQBBgIAw/AsAC0GAgMAAEHEiC0UNACALQQRrIiEtAABBA3EEQCALQQBBgIDAAPwLAAtBgIAIEHEiDEUNACAMQQRrIiItAABBA3EEQCAMQQBBgIAI/AsAC0GAgBAQcSINRQ0AIA1BBGsiIygCACIFQQNxIgMEQCANQQBBgIAQ/AsACyAIBEAgDEECIAIbISQgDUEEIAIbISVBgIAEQQAgAhshGyABKAIQISYgASgCFCEcIAEoAgQhJwNAQYCABCAIIA5rIgMgA0GAgARPGyEUIAggDkcEQCAnIA5BJGxqIQMgJiAOQRhsaiEGQQAhFSAJIRZBACEFIA0hFyALIRggDCEZA0AgCCAOIBVqIhpNBEAgGiAIQdTAxwAQjAcACyADQRBqKgIAISggA0EMaioCACEpIANBCGoqAgAhKiAEQcABaiADEKQDIARB0AFqIAMQmgMgBEHgAWogAykCABDLAiAE/QAE4AEhKyAFIBBqIgogKjgCACAFIBFqIgcgBCoCwAE4AgAgBSASaiIPIAQqAtABOAIAIApBBGogKTgCACAHQQRqIAQqAsQBOAIAIA9BBGogBCoC1AE4AgAgCkEIaiAoOAIAIAdBCGogBCoCyAE4AgAgD0EIaiAEKgLYATgCACAYICv9CwIAIBYCfyADQRRqLwEAIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQogB0GAgAJxIQ8gB0GA+AFxIgdBgPgBRgRAIA9BEHQhByAHQYCAgPwHciAKRQ0BGiAHIApBDXRyQYCAgP4HcgwBCyAPQRB0IQ8gB0ENdEGAgID8AHEgCkENdHJBgICAwANqIA9yIAcNABogD0GAgIDYA3IgCmdBEGsiB0EXdGsgCiAHQf//A3FBCGp0Qf///wNxcgs2AgAgAgRAAn8CQCAaIBxJBEACfyAGQRRqKAIAIgpBBEsEQCAGQQRqKAIAIQogBkEIaigCAAwBCyAGQQRqCyEHIAoNAUEAIQpBAAwCCyAaIBxBxMDHABCMBwwHCyAHKAIACyEHIBkgCjsBACAXIAc2AgALIANBJGohAyAGQRhqIQYgFkEEaiEWIAVBDGohBSAXQQRqIRcgGEEQaiEYIBlBAmohGSAVQQFqIhUgFEkNAAsLIAQgGzYCrAIgBCAlNgKoAiAEIBs2AqQCIAQgJDYCoAIgBEEANgKcAiAEQoCAgIDAADcClAIgBEKAgICAwAA3AowCIARCgICQgMAANwKEAiAEIAs2AoACIARBgIAMNgL8ASAEIBI2AvgBIARBgIAMNgL0ASAEIBE2AvABIARBgIAENgLsASAEIAk2AugBIARBgIAMNgLkASAEIBA2AuABIARBBGogDiAUIARB4AFqEJcBIA4gFGoiDiAISQ0ACyAjKAIAIgVBA3EhAwsCQAJAIAVBeHFBhIAQQYiAECADG08EQCADQQAgBUGogBBPGw0GIA0QogIgIigCACICQXhxQYSACEGIgAggAkEDcSIDG0kNBSADQQAgAkGogAhPGw0GIAwQogIgISgCACICQXhxQYSAwABBiIDAACACQQNxIgMbSQ0FIANBACACQaiAwABPGw0GIAsQogIgICgCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBIQogIgHygCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBEQogIgHigCACICQXhxQYSAEEGIgBAgAkEDcSIDG0kNBSADQQAgAkGogBBPGw0GIAkQogIgHSgCACICQXhxQYSAMEGIgDAgAkEDcSIDG0kNBSADQQAgAkGogDBPGw0GIBAQogIgE0UNBEGAgJABEHEiAkUNAyACQQRrIgsoAgAiBUEDcSIDBEAgAkEAQYCAkAH8CwALIAhFDQIgASgCICEMIAEoAhwhDUEAIQYDQEGAgAQgCCAGayIDIANBgIAETxshCSAGIAhHBEBBACEFIAIhAwNAIARB4AFqIA0gDCAFIAZqELwBIAMgBP0ABOAB/QsCACADQRBqIAT9AATwAf0LAgAgA0EgaiAEKgKAAjgCACADQSRqIQMgBUEBaiIFIAlJDQALCyAEQQRqIAYgCSACQYCAJBDOAyAIIAYgCWoiBksNAAsMAQsMBAsgCygCACIFQQNxIQMLAkAgBUF4cUGEgJABQYiAkAEgAxtPBEAgA0EAIAVBqICQAU8bDQUgAhCiAiATQQFGDQNBgIDwARBxIgJFDQIgAkEEayILKAIAIgVBA3EiAwRAIAJBAEGAgPAB/AsACyAIBEAgASgCLCEMIAEoAighDUEAIQYDQEGAgAQgCCAGayIDIANBgIAETxshCSAGIAhHBEBBACEFIAIhAwNAIARB4AFqIA0gDCAFIAZqEIsBIAMgBP0ABOAB/QsCACADQRBqIAT9AATwAf0LAgAgA0EgaiAE/QAEgAL9CwIAIANBMGogBCoCkAI4AgAgA0E0aiAEKQKUAjcCACADQTxqIQMgBUEBaiIFIAlJDQALCyAEQQRqIAYgCSACQYCAPBDiAyAGIAlqIgYgCEkNAAsgCygCACIFQQNxIQMLIAVBeHFBhIDwAUGIgPABIAMbSQ0EIANBACAFQaiA8AFPGw0FIAIQogIgE0ECTQ0DQYCA0AIQcSICRQ0CIAJBBGsiCSgCACIFQQNxIgMEQCACQQBBgIDQAvwLAAsgCARAIAEoAjghCyABKAI0IQxBACEGA0BBgIAEIAggBmsiASABQYCABE8bIQEgBiAIRwRAQQAhBSACIQMDQCAEQeABaiAMIAsgBSAGahBsIAMgBP0ABOAB/QsCACADQRBqIAT9AATwAf0LAgAgA0EgaiAE/QAEgAL9CwIAIANBMGogBP0ABJAC/QsCACADQUBrIAT9AASgAv0LAgAgA0HQAGogBCoCsAI4AgAgA0HUAGohAyAFQQFqIgUgAUkNAAsLIARBBGogBiABIAJBgIDUABDjAyABIAZqIgYgCEkNAAsgCSgCACIFQQNxIQMLIAVBeHFBhIDQAkGIgNACIAMbSQ0EIANBACAFQaiA0AJPGw0BIAIQogIMAwsMAwsMAwsACwJAIARBBGoiAhCjASIBBEAgAEECNgIAIAAgATYCBCACEMACDAELIAAgBEEEakG8AfwKAAALIARBwAJqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvlFQMRfwF+AW8jAEHgBmsiASQAIAFBoAFqIgcgAiADKAIMEQEAAkACQAJAAkACQAJAIAEpA6ABQsvTs7K7k+HLQoUgASkDqAFC7b+ClN2syJ2df4WEUARAIAFBMGogAkHwAPwKAAAgASgClAEiA0UNASAHIAMgASgCmAEiEigCDCIIEQEAAkACQAJAAkACQCABKQOgAUKf0/elq5SA065/hSABKQOoAUKQkPj2grmEnmyFhFBFBEAgByADIAgRAQAgASkDoAFChq+1jMLkqv4xhSABKQOoAUKbq7TXwZS/hYZ/hYRQDQEgByADIAgRAQAgASkDoAFCx5uZ88LP+aS8f4UgASkDqAFC7sKNnfXyzrRehYRQDQIgByADIAgRAQAgASkDoAFC/pXph6aw4PvMAIUgASkDqAFC1cSH6oL5y8Z7hYRQDQMgByADIAgRAQAgASkDoAFC07aF9P3V/p5VhSABKQOoAUKw3b+ylJ6K/Q2FhFANBCAHIAMgCBEBACABKQOgAUKR3taAjqSFsp9/hSABKQOoAUKAxNGW34qexvsAhYRQIhMNBSABQQA2ArABIAFBATYCpAEgAUHU4MEANgKgASABQgQ3AqgBIAdB3ODBABCNCAALIAFBoAFqIANBuAX8CgAAIAFBEGogA0Ecav0AAgD9CwMAIAFBIGogA0Esav0AAgD9CwMAIAEgA/0AAgz9CwMAIAMoAjwhByADKAIIIQggAykDACEVIAEoAsgGIgQEQCABKALMBiIFQQRrKAIAIgZBeHEiCUEEQQggBkEDcSIGGyAEakkNDCAGQQAgCSAEQSdqSxsNCyAFEKICCyABQeABaiEEAkACQAJAIAEoArwGQYCAgIB4aw4CAQIACyAEEL4CDAELIAQQvQELIANBBGsoAgAiBEF4cUG8BUHABSAEQQNxIgUbSQ0LIAVFDQggBEHgBU8NCgwICyABQRBqIANBHGr9AAIA/QsDACABQSBqIANBLGr9AAIA/QsDACABIAP9AAIM/QsDACADKAKAASEJIAMoAnwhDSADKAJ0IQ4gAygCcCELIAMoAmghEiADKAJkIQQgAygCXCETIAMoAlghBSADKAJQIQwgAygCTCEGIAMoAjwhByADKAIIIQggAykCACEVIAMoAkAiCgRAIAMoAkQiD0EEaygCACIQQXhxIhFBBEEIIBBBA3EiEBsgCmpJDQsgEEEAIBEgCkEnaksbDQogDxCiAgsgBgRAIAxBBGsoAgAiCkF4cSIPQQRBCCAKQQNxIgobIAZqSQ0LIApBACAPIAZBJ2pLGw0KIAwQogILIAUEQCATQQRrKAIAIgZBeHEiDEEEQQggBkEDcSIGGyAFakkNCyAGQQAgDCAFQSdqSxsNCiATEKICCwJAIARBgICAgHhGDQAgBARAIBJBBGsoAgAiBUF4cSIGIARBAnQiBEEEQQggBUEDcSIFG2pJDQwgBUEAIAYgBEEnaksbDQsgEhCiAgsgCwRAIA5BBGsoAgAiBEF4cSIFIAtBAXQiBkEEQQggBEEDcSIEG2pJDQwgBEEAIAUgBkEnaksbDQsgDhCiAgsgDUUNACAJQQRrKAIAIgRBeHEiBSANQQJ0IgZBBEEIIARBA3EiBBtqSQ0LIARBACAFIAZBJ2pLGw0KIAkQogILIANBBGsoAgAiBEF4cUGs0wBBsNMAIARBA3EiBRtJDQogBUUgBEHQ0wBJcg0HDAkLIAFBEGogA0Ecav0AAgD9CwMAIAFBIGogA0Esav0AAgD9CwMAIAEgA/0AAgz9CwMAIAMoAjwhByADKAIIIQggAykCACEVIAMoAkAiBARAIAMoAkQiBUEEaygCACIGQXhxIglBBEEIIAZBA3EiBhsgBGpJDQogBkEAIAkgBEEnaksbDQkgBRCiAgsgA0EEaygCACIEQXhxIgVB0ABB1AAgBEEDcSIEG0kNCSAERSAFQfQASXINBgwICyABQRBqIANBHGr9AAIA/QsDACABQSBqIANBLGr9AAIA/QsDACABIAP9AAIM/QsDACADKAI8IQcgAygCCCEIIAMpAgAhFSADKAJAIgQEQCADKAJEIgVBBGsoAgAiBkF4cSIJQQRBCCAGQQNxIgYbIARqSQ0JIAZBACAJIARBJ2pLGw0IIAUQogILIANBBGsoAgAiBEF4cSIFQdAAQdQAIARBA3EiBBtJDQggBEUgBUH0AElyDQUMBwsgAUEQaiADQRxq/QACAP0LAwAgAUEgaiADQSxq/QACAP0LAwAgASAD/QACDP0LAwAgAygCPCEHIAMoAgghCCADKQIAIRUgAygCQCIEBEAgAygCRCAEQQEQogcLIANBBGsoAgAiBEF4cSIFQdAAQdQAIARBA3EiBBtJDQcgBEUgBUH0AElyDQQMBgsgAUEQaiADQZQCav0AAgD9CwMAIAFBIGogA0GkAmr9AAIA/QsDACABIAP9AAKEAv0LAwAgAygCgAIhCCADKQL4ASEVIAMoAugBIQwgAygC5AEhBiADKAKIASEKIAMoAnQhDyADKAJwIQkgAygCbCEFIAMoAmghDSADKAJkIQ4gAygCACEEIAMoArQCIQcgAygC2AIiCwRAIAMoAtwCIAtBARCiBwsCQCAEQQJGDQAgBQRAIA1BJGohBANAIARBBGsoAgAiC0GAgICAeHJBgICAgHhHBEAgBCgCACIQQQRrKAIAIhFBeHEiFEEEQQggEUEDcSIRGyALakkNCiARQQAgFCALQSdqSxsNCSAQEKICCyAEQTBqIQQgBUEBayIFDQALCyAOBEAgDSAOQTBsQQgQogcLIAlBgICAgHhyQYCAgIB4Rg0AIA8gCUEBEKIHCyADIBIgExshAyAGRSAKQQJGckUEQCAMIAZBKGxBCBCiBwsgA0EEaygCACIEQXhxQYQDQYgDIARBA3EiBRtJDQIgBUUgBEGoA0lyDQMMBQsgASADNgKkASABIAI2AqABQdjmyABBKyABQaABakHo7sAAQejvwAAQ4AYAC0Gw4MEAEN0JAAtBzIzIAEEuQfyMyAAQ6wcMAQsgAxCiAiABKAI8IgNBgICAgHhyQYCAgIB4RwRAIAEoAkAiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgA2pJDQMgBUEAIAYgA0EnaksbDQIgBBCiAgsgASgCSEGAgICAeEcEQCABQcgAahD1AgsgASgCMCIDBEAgASgCNCIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyADakkNAyAFQQAgBiADQSdqSxsNAiAEEKICCwJAIAEoAogBIgNBgICAgHhyQYCAgIB4RwRAIAEoAowBIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIANqSQ0EIAVBACAGIANBJ2pLGw0BIAQQogILQdQAEHEiA0UNASADIAg2AhQgAyAVNwIMIANBADYCCCADQoGAgIAQNwIAIAMgAf0AAwD9CwIYIAMgBzYCUCADIAg2AkwgAyAHNgJIIANBKGogAUEQav0AAwD9CwIAIANBOGogAUEgav0AAwD9CwIAIANBCGoQDSEWENoEIgcgFiYBIAJBBGsoAgAiA0F4cUH0AEH4ACADQQNxIggbSQ0DIAhBACADQZgBTxsNAiACEKICIAAgBzYCBCAAQQA2AgAgAUHgBmokAA8LDAELAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwAL5hYCDH8IfUMAAIA/IRACfwJAIAAoAgQiAyACQQhqKAIAIgVJBEAgACgCACEGIAJBBGooAgAiCSADQSRsaiICEIoEIQ8gAi8BFCIDQf//AXFFBEAgA0EQdAwDCyADQf8HcSECIANBgIACcSEEIANBgPgBcSIDQYD4AUYEQCAEQRB0IQMgA0GAgID8B3IgAkUNAxogAyACQQ10ckGAgID+B3IMAwsgBEEQdCEEIANFDQEgA0ENdEGAgID8AHEgAkENdHJBgICAwANqIARyDAILIAMgBUHUwMcAEIwHAAsgBEGAgIDYA3IgAmdBEGsiA0EXdGsgAiADQf//A3FBCGp0Qf///wNxcgu+IhFDAACAP14EQCAREMYFQ1T4LUCUQwAAgD+SkSEQC0MAAIA/IRECfwJAIAUgBksEQCAJIAZBJGxqIgIQigQhEyACLwEUIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQIgA0GAgAJxIQYgA0GA+AFxIgNBgPgBRgRAIAZBEHQhAyADQYCAgPwHciACRQ0DGiADIAJBDXRyQYCAgP4HcgwDCyAGQRB0IQYgA0UNASADQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogBnIMAgsgBiAFQdTAxwAQjAcACyAGQYCAgNgDciACZ0EQayIDQRd0ayACIANB//8DcUEIanRB////A3FyC74iEkMAAIA/XgRAIBIQxgVDVPgtQJRDAACAP5KRIRELQwAAgD8hFAJAAkACfwJAIAUgACgCDCICSwRAIAAoAgghBiAJIAJBJGxqIgIQigQhEiACLwEUIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0DGiADIAJBDXRyQYCAgP4HcgwDCyAEQRB0IQQgA0UNASADQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogBHIMAgsMAgsgBEGAgIDYA3IgAmdBEGsiA0EXdGsgAiADQf//A3FBCGp0Qf///wNxcgu+IhVDAACAP14EQCAVEMYFQ1T4LUCUQwAAgD+SkSEUCwJ/AkAgBSAGSwRAIAkgBkEkbGoiAhCKBCEVIAIvARQiA0H//wFxRQRAIANBEHQMAwsgA0H/B3EhAiADQYCAAnEhBiADQYD4AXEiA0GA+AFGBEAgBkEQdCEDIANBgICA/AdyIAJFDQMaIAMgAkENdHJBgICA/gdyDAMLIAZBEHQhBiADRQ0BIANBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAGcgwCCyAGIAVB1MDHABCMBwALIAZBgICA2ANyIAJnQRBrIgNBF3RrIAIgA0H//wNxQQhqdEH///8DcXILIQJDAACAPyEWAn8CQCAFIABBDEEIIBIgEpIgFJQiEiASWyASIBUgFZIgAr4iFEMAAIA/XgR9IBQQxgVDVPgtQJRDAACAP5KRBSAWC5RgRXEiBxtqIgYoAgAiAksEQCAAIA8gD5IgEJQiDyAPWyAPIBMgE5IgEZRgRXEiCkECdGoiDCgCACEEIAkgAkEkbGoiAhCKBCETIAIvARQiA0H//wFxRQRAIANBEHQMAwsgA0H/B3EhAiADQYCAAnEhCCADQYD4AXEiA0GA+AFGBEAgCEEQdCEDIANBgICA/AdyIAJFDQMaIAMgAkENdHJBgICA/gdyDAMLIAhBEHQhCCADRQ0BIANBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAIcgwCCwwCCyAIQYCAgNgDciACZ0EQayIDQRd0ayACIANB//8DcUEIanRB////A3FyC0MAAIA/IQ++IhBDAACAP14EQCAQEMYFQ1T4LUCUQwAAgD+SkSEPC0MAAIA/IRACfwJAIAQgBUkEQEEIQQwgBxshCCAJIARBJGxqIgIQigQhEiACLwEUIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQhAyADQYCAgPwHciACRQ0DGiADIAJBDXRyQYCAgP4HcgwDCyAEQRB0IQQgA0UNASADQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogBHIMAgsMAwsgBEGAgIDYA3IgAmdBEGsiA0EXdGsgAiADQf//A3FBCGp0Qf///wNxcgu+IhFDAACAP14EQCAREMYFQ1T4LUCUQwAAgD+SkSEQC0MAAIA/IRECfwJAIAUgACAIaiIIKAIAIgJLBEAgACAKRUECdGoiAygCACEEIAkgAkEkbGoiABCKBCEUIAAvARQiAkH//wFxRQRAIAJBEHQMAwsgAkH/B3EhACACQYCAAnEhByACQYD4AXEiAkGA+AFGBEAgB0EQdCECIAJBgICA/AdyIABFDQMaIAIgAEENdHJBgICA/gdyDAMLIAdBEHQhByACRQ0BIAJBDXRBgICA/ABxIABBDXRyQYCAgMADaiAHcgwCCwwCCyAHQYCAgNgDciAAZ0EQayICQRd0ayAAIAJB//8DcUEIanRB////A3FyC74iFUMAAIA/XgRAIBUQxgVDVPgtQJRDAACAP5KRIRELAn8CQCAEIAVJBEAgEyATkiAPlCIPIBIgEpIgEJRgRSEHIA8gD1shCiAJIARBJGxqIgAQigQhECAALwEUIgJB//8BcUUEQCACQRB0DAMLIAJB/wdxIQAgAkGAgAJxIQQgAkGA+AFxIgJBgPgBRgRAIARBEHQhAiACQYCAgPwHciAARQ0DGiACIABBDXRyQYCAgP4HcgwDCyAEQRB0IQQgAkUNASACQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2ogBHIMAgsMAwsgBEGAgIDYA3IgAGdBEGsiAkEXdGsgACACQf//A3FBCGp0Qf///wNxcgshAEMAAIA/IQ8CfwJAIAUgCCADIAYgByAKcSIHGyAUIBSSIBGUIhEgEVsgESAQIBCSIAC+IhNDAACAP14EfSATEMYFQ1T4LUCUQwAAgD+SkQUgDwuUYEVxIgobIg0oAgAiAEsEQCAMIAYgAyAKGyAHGyIOKAIAIQQgCSAAQSRsaiIAEIoEIRAgAC8BFCICQf//AXFFBEAgAkEQdAwDCyACQf8HcSEAIAJBgIACcSELIAJBgPgBcSICQYD4AUYEQCALQRB0IQIgAkGAgID8B3IgAEUNAxogAiAAQQ10ckGAgID+B3IMAwsgC0EQdCELIAJFDQEgAkENdEGAgID8AHEgAEENdHJBgICAwANqIAtyDAILIAAgBUHUwMcAEIwHAAsgC0GAgIDYA3IgAGdBEGsiAkEXdGsgACACQf//A3FBCGp0Qf///wNxcgtDAACAPyERviIPQwAAgD9eBEAgDxDGBUNU+C1AlEMAAIA/kpEhEQtDAACAPyEPAn8CQCAEIAVJBEAgCSAEQSRsaiIAEIoEIRMgAC8BFCICQf//AXFFBEAgAkEQdAwDCyACQf8HcSEAIAJBgIACcSEFIAJBgPgBcSICQYD4AUYEQCAFQRB0IQIgAkGAgID8B3IgAEUNAxogAiAAQQ10ckGAgID+B3IMAwsgBUEQdCEFIAJFDQEgAkENdEGAgID8AHEgAEENdHJBgICAwANqIAVyDAILDAMLIAVBgICA2ANyIABnQRBrIgJBF3RrIAAgAkH//wNxQQhqdEH///8DcXILviISQwAAgD9eBEAgEhDGBUNU+C1AlEMAAIA/kpEhDwsgASAGIAwgBxsoAgA2AgAgASANIA4gECAQkiARlCIQIBBbIBAgEyATkiAPlGBFcSIAGygCADYCBCABIA4gDSAAGygCADYCCCABIAMgCCAKGygCADYCDA8LIAIgBUHUwMcAEIwHAAsgBCAFQdTAxwAQjAcAC/YWAh1/BX0jAEGQAWsiASQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKALEASICQR9xRQRAIAFBADoASCABQQA2AkQgASACQQV2Ihg2AkAgACABQUBrEKUEIAFBADYCDCABQoCAgIDAADcCBCABQQA2AhggAUKAgICAwAA3AhAgAUEANgIkIAFCgICAgMAANwIcIAFBADYCMCABQoCAgIDAADcCKCABQQA2AjwgAUKAgICAwAA3AjQgAkUEQEEEIQMgABCjASEPQQQhBUEEIQZBBCESDCQLQQAhAkEEIRIDQCALQYCABCAYIBRrIgcgB0GAgARPGyIHQQNsIg5JBEAgDiALayICIAEoAgQgC2tLBEAgAUEEaiALIAJBBEEEEKQFIAEoAgghEiABKAIMIQsLIBIgC0ECdGohBSACQQJPBH8gAkECdEEEayIGBEAgBUEAIAb8CwALIAIgC2oiAkEBayELIBIgAkECdGpBBGsFIAULQQA2AgAgASALQQFqIgs2AgwgASgCGCECCyACIAdJBEAgByACayIGIAEoAhAgAmtLBEAgAUEQaiACIAZBBEEEEKQFIAEoAhghAgsgASgCFCIDIAJBAnRqIQUgBkECTwR/IAZBAnRBBGsiBARAIAVBACAE/AsACyACIAZqIgVBAWshAiADIAVBAnRqQQRrBSAFC0EANgIAIAEgAkEBaiICNgIYCyABKAIkIgwgDkkEQCAOIAxrIgYgASgCHCAMa0sEQCABQRxqIAwgBkEEQQQQpAUgASgCJCEMCyABKAIgIgMgDEECdGohBSAGQQJPBH8gBkECdEEEayIEBEAgBUEAIAT8CwALIAYgDGoiBUEBayEMIAMgBUECdGpBBGsFIAULQQA2AgAgASAMQQFqIgw2AiQLIAEoAjAiDSAOSQRAIA4gDWsiBiABKAIoIA1rSwRAIAFBKGogDSAGQQRBBBCkBSABKAIwIQ0LIAEoAiwiAyANQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgQEQCAFQQAgBPwLAAsgBiANaiIFQQFrIQ0gAyAFQQJ0akEEawUgBQtBADYCACABIA1BAWoiDTYCMAsgB0ECdCIXIAEoAjwiCEsEQCAXIAhrIgYgASgCNCAIa0sEQCABQTRqIAggBkEEQQQQpAUgASgCPCEICyABKAI4IgMgCEECdGohBSAGQQJPBH8gBkECdEEEayIEBEAgBUEAIAT8CwALIAYgCGoiBUEBayEIIAMgBUECdGpBBGsFIAULQQA2AgAgASAIQQFqIgg2AjwLIAEoAgghEiAUIBhHBEAgFEEFdCEDIAAoAsQBIQQgACgCwAEhGUEAIRYgASgCOCEVIAEoAhQhGiABKAIgIRsgASgCLCEcIAIhBSAHIQZBACERQQAhDwNAIANBA2ogBE8NGiADQQdqIARPDRsgA0ELaiAETw0cIANBD2ogBE8NHSADQRNqIARPDR4gA0EXaiAETw0fIAsgEU0NBCADIBlqIglBBGoqAAAhHiAJQQhqKgAAIR8gCUEMaioAACEgIAlBEGoqAAAhISAJQRRqKgAAISIgEiAWaiIQIAkqAAA4AgAgEUEBaiIKIAtPDQUgEEEEaiAeOAIAIBFBAmoiEyALTw0GIBBBCGogHzgCACANIBFNDQcgFiAcaiIQICA4AgAgCiANTw0IIBBBBGogITgCACANIBNNDQkgEEEIaiAiOAIAIANBGGoiECAETw0KIAwgEU0NCyAWIBtqIhAgCUEYai0AALNDAAB/Q5U4AgAgA0EZaiIdIARPDQwgCiAMTw0NIBBBBGogCUEZai0AALNDAAB/Q5U4AgAgA0EaaiIKIARPDQ4gDCATTQ0PIBBBCGogCUEaai0AALNDAAB/Q5U4AgAgA0EbaiIKIARPDRAgBUUNESAPIBpqIAlBG2otAACzQwAAf0OVOAIAIANBHGoiCiAETw0SIANBHWoiCiAETw0TIANBHmoiCiAETw0UIANBH2oiCiAETw0VIAggD00NFiAJQRxqLQAAIQogCUEeai0AACETIAlBH2otAAAhECAVIAlBHWotAACzQwAAAMOSQwAAADyUOAIAIA9BAWoiCSAITw0XIBVBBGogE7NDAAAAw5JDAAAAPJQ4AgAgD0ECaiIJIAhPDRggFUEIaiAQs0MAAADDkkMAAAA8lDgCACAPQQNqIgkgCE8NGSAVQQxqIAqzQwAAAMOSQwAAADyUOAIAIAVBAWshBSAVQRBqIRUgA0EgaiEDIBZBDGohFiARQQNqIREgD0EEaiEPIAZBAWsiBg0ACwsgCyAOSQ0eIAIgB0kNHyAMIA5JDSAgDSAOSQ0hIAggF0kNIiABKAIUIQYgASgCICEFIAEoAiwhAyABQgQ3AogBIAFCAjcCgAEgAUIENwJ4IAFCBDcCcCABQgQ3AmggASAXNgJkIAEgASgCOCIENgJgIAEgDjYCXCABIAM2AlggASAONgJUIAEgBTYCUCABIAc2AkwgASAGNgJIIAEgDjYCRCABIBI2AkAgACAUIAcgAUFAaxCXASAYIAcgFGoiFEsNAAsMIgsgAUEANgJQIAFBATYCRCABQYTawAA2AkAgAUIENwJIIAFBQGsQkgchDwwjCyARIAtBjNfAABCMBwALIAogC0Gc18AAEIwHAAsgEyALQazXwAAQjAcACyARIA1BvNfAABCMBwALIAogDUHM18AAEIwHAAsgEyANQdzXwAAQjAcACyAQIARB7NfAABCMBwALIBEgDEH818AAEIwHAAsgHSAEQYzYwAAQjAcACyAKIAxBnNjAABCMBwALIAogBEGs2MAAEIwHAAsgEyAMQbzYwAAQjAcACyAKIARBzNjAABCMBwALIAIgAkHc2MAAEIwHAAsgCiAEQezYwAAQjAcACyAKIARB/NjAABCMBwALIAogBEGM2cAAEIwHAAsgCiAEQZzZwAAQjAcACyAPIAhBrNnAABCMBwALIAkgCEG82cAAEIwHAAsgCSAIQczZwAAQjAcACyAJIAhB3NnAABCMBwALIAMgA0EEciAEQfDlwQAQ6gcACyADQQRqIANBCHIgBEHw5cEAEOoHAAsgA0EIaiADQQxyIARB8OXBABDqBwALIANBDGogA0EQciAEQfDlwQAQ6gcACyADQRBqIANBFHIgBEHw5cEAEOoHAAsgA0EUaiADQRhyIARB8OXBABDqBwALQQAgDiALQfzWwAAQ6gcAC0EAIAcgAkHs1sAAEOoHAAtBACAOIAxB3NbAABDqBwALQQAgDiANQczWwAAQ6gcAC0EAIBcgCEG81sAAEOoHAAsgASgCNCECIAAQowEhDyACRQ0AIARBBGsoAgAiAEF4cSIHIAJBAnQiAkEEQQggAEEDcSIAG2pJDQIgAEEAIAcgAkEnaksbDQMgBBCiAgsgASgCKCIABEAgA0EEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNAiACQQAgByAAQSdqSxsNAyADEKICCyABKAIcIgAEQCAFQQRrKAIAIgJBeHEiByAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0CIAJBACAHIABBJ2pLGw0DIAUQogILIAEoAhAiAARAIAZBBGsoAgAiAkF4cSIHIABBAnQiAEEEQQggAkEDcSICG2pJDQIgAkEAIAcgAEEnaksbDQMgBhCiAgsgASgCBCIARQ0AIBJBBGsoAgAiAkF4cSIHIABBAnQiAEEEQQggAkEDcSICG2pJDQEgAkEAIAcgAEEnaksbDQIgEhCiAgsgAUGQAWokACAPDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL9RYCHX8FfSMAQZABayIBJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAswBIgJBH3FFBEAgAUEAOgBIIAFBADYCRCABIAJBBXYiGDYCQCAAIAFBQGsQ4QMgAUEANgIMIAFCgICAgMAANwIEIAFBADYCGCABQoCAgIDAADcCECABQQA2AiQgAUKAgICAwAA3AhwgAUEANgIwIAFCgICAgMAANwIoIAFBADYCPCABQoCAgIDAADcCNCACRQRAQQQhAyAAENQBIQ9BBCEFQQQhBkEEIRIMJAtBACECQQQhEgNAIAtBgIAEIBggFGsiByAHQYCABE8bIgdBA2wiDkkEQCAOIAtrIgIgASgCBCALa0sEQCABQQRqIAsgAkEEQQQQpAUgASgCCCESIAEoAgwhCwsgEiALQQJ0aiEFIAJBAk8EfyACQQJ0QQRrIgYEQCAFQQAgBvwLAAsgAiALaiICQQFrIQsgEiACQQJ0akEEawUgBQtBADYCACABIAtBAWoiCzYCDCABKAIYIQILIAIgB0kEQCAHIAJrIgYgASgCECACa0sEQCABQRBqIAIgBkEEQQQQpAUgASgCGCECCyABKAIUIgMgAkECdGohBSAGQQJPBH8gBkECdEEEayIEBEAgBUEAIAT8CwALIAIgBmoiBUEBayECIAMgBUECdGpBBGsFIAULQQA2AgAgASACQQFqIgI2AhgLIAEoAiQiDCAOSQRAIA4gDGsiBiABKAIcIAxrSwRAIAFBHGogDCAGQQRBBBCkBSABKAIkIQwLIAEoAiAiAyAMQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgQEQCAFQQAgBPwLAAsgBiAMaiIFQQFrIQwgAyAFQQJ0akEEawUgBQtBADYCACABIAxBAWoiDDYCJAsgASgCMCINIA5JBEAgDiANayIGIAEoAiggDWtLBEAgAUEoaiANIAZBBEEEEKQFIAEoAjAhDQsgASgCLCIDIA1BAnRqIQUgBkECTwR/IAZBAnRBBGsiBARAIAVBACAE/AsACyAGIA1qIgVBAWshDSADIAVBAnRqQQRrBSAFC0EANgIAIAEgDUEBaiINNgIwCyAHQQJ0IhcgASgCPCIISwRAIBcgCGsiBiABKAI0IAhrSwRAIAFBNGogCCAGQQRBBBCkBSABKAI8IQgLIAEoAjgiAyAIQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgQEQCAFQQAgBPwLAAsgBiAIaiIFQQFrIQggAyAFQQJ0akEEawUgBQtBADYCACABIAhBAWoiCDYCPAsgASgCCCESIBQgGEcEQCAUQQV0IQMgACgCzAEhBCAAKALIASEZQQAhFiABKAI4IRUgASgCFCEaIAEoAiAhGyABKAIsIRwgAiEFIAchBkEAIRFBACEPA0AgA0EDaiAETw0aIANBB2ogBE8NGyADQQtqIARPDRwgA0EPaiAETw0dIANBE2ogBE8NHiADQRdqIARPDR8gCyARTQ0EIAMgGWoiCUEEaioAACEeIAlBCGoqAAAhHyAJQQxqKgAAISAgCUEQaioAACEhIAlBFGoqAAAhIiASIBZqIhAgCSoAADgCACARQQFqIgogC08NBSAQQQRqIB44AgAgEUECaiITIAtPDQYgEEEIaiAfOAIAIA0gEU0NByAWIBxqIhAgIDgCACAKIA1PDQggEEEEaiAhOAIAIA0gE00NCSAQQQhqICI4AgAgA0EYaiIQIARPDQogDCARTQ0LIBYgG2oiECAJQRhqLQAAs0MAAH9DlTgCACADQRlqIh0gBE8NDCAKIAxPDQ0gEEEEaiAJQRlqLQAAs0MAAH9DlTgCACADQRpqIgogBE8NDiAMIBNNDQ8gEEEIaiAJQRpqLQAAs0MAAH9DlTgCACADQRtqIgogBE8NECAFRQ0RIA8gGmogCUEbai0AALNDAAB/Q5U4AgAgA0EcaiIKIARPDRIgA0EdaiIKIARPDRMgA0EeaiIKIARPDRQgA0EfaiIKIARPDRUgCCAPTQ0WIAlBHGotAAAhCiAJQR5qLQAAIRMgCUEfai0AACEQIBUgCUEdai0AALNDAAAAw5JDAAAAPJQ4AgAgD0EBaiIJIAhPDRcgFUEEaiATs0MAAADDkkMAAAA8lDgCACAPQQJqIgkgCE8NGCAVQQhqIBCzQwAAAMOSQwAAADyUOAIAIA9BA2oiCSAITw0ZIBVBDGogCrNDAAAAw5JDAAAAPJQ4AgAgBUEBayEFIBVBEGohFSADQSBqIQMgFkEMaiEWIBFBA2ohESAPQQRqIQ8gBkEBayIGDQALCyALIA5JDR4gAiAHSQ0fIAwgDkkNICANIA5JDSEgCCAXSQ0iIAEoAhQhBiABKAIgIQUgASgCLCEDIAFCBDcCiAEgAUICNwKAASABQgQ3AnggAUIENwJwIAFCBDcCaCABIBc2AmQgASABKAI4IgQ2AmAgASAONgJcIAEgAzYCWCABIA42AlQgASAFNgJQIAEgBzYCTCABIAY2AkggASAONgJEIAEgEjYCQCAAIBQgByABQUBrEH4gGCAHIBRqIhRLDQALDCILIAFBADYCUCABQQE2AkQgAUGE2sAANgJAIAFCBDcCSCABQUBrEJIHIQ8MIwsgESALQYzXwAAQjAcACyAKIAtBnNfAABCMBwALIBMgC0Gs18AAEIwHAAsgESANQbzXwAAQjAcACyAKIA1BzNfAABCMBwALIBMgDUHc18AAEIwHAAsgECAEQezXwAAQjAcACyARIAxB/NfAABCMBwALIB0gBEGM2MAAEIwHAAsgCiAMQZzYwAAQjAcACyAKIARBrNjAABCMBwALIBMgDEG82MAAEIwHAAsgCiAEQczYwAAQjAcACyACIAJB3NjAABCMBwALIAogBEHs2MAAEIwHAAsgCiAEQfzYwAAQjAcACyAKIARBjNnAABCMBwALIAogBEGc2cAAEIwHAAsgDyAIQazZwAAQjAcACyAJIAhBvNnAABCMBwALIAkgCEHM2cAAEIwHAAsgCSAIQdzZwAAQjAcACyADIANBBHIgBEHw5cEAEOoHAAsgA0EEaiADQQhyIARB8OXBABDqBwALIANBCGogA0EMciAEQfDlwQAQ6gcACyADQQxqIANBEHIgBEHw5cEAEOoHAAsgA0EQaiADQRRyIARB8OXBABDqBwALIANBFGogA0EYciAEQfDlwQAQ6gcAC0EAIA4gC0H81sAAEOoHAAtBACAHIAJB7NbAABDqBwALQQAgDiAMQdzWwAAQ6gcAC0EAIA4gDUHM1sAAEOoHAAtBACAXIAhBvNbAABDqBwALIAEoAjQhAiAAENQBIQ8gAkUNACAEQQRrKAIAIgBBeHEiByACQQJ0IgJBBEEIIABBA3EiABtqSQ0CIABBACAHIAJBJ2pLGw0DIAQQogILIAEoAigiAARAIANBBGsoAgAiAkF4cSIHIABBAnQiAEEEQQggAkEDcSICG2pJDQIgAkEAIAcgAEEnaksbDQMgAxCiAgsgASgCHCIABEAgBUEEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNAiACQQAgByAAQSdqSxsNAyAFEKICCyABKAIQIgAEQCAGQQRrKAIAIgJBeHEiByAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0CIAJBACAHIABBJ2pLGw0DIAYQogILIAEoAgQiAEUNACASQQRrKAIAIgJBeHEiByAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0BIAJBACAHIABBJ2pLGw0CIBIQogILIAFBkAFqJAAgDw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+0WAh1/BX0jAEGQAWsiASQAAkACQAJAIAAoAmgiAkEfcQRAIAFBADYCUCABQQE2AkQgAUGE2sAANgJAIAFCBDcCSCABQUBrEJIHIQMMAQsgAUEAOgBIIAFBADYCRCABIAJBBXYiGDYCQCAAIAFBQGsQ6QEgAUEANgIMIAFCgICAgMAANwIEIAFBADYCGCABQoCAgIDAADcCECABQQA2AiQgAUKAgICAwAA3AhwgAUEANgIwIAFCgICAgMAANwIoIAFBADYCPCABQoCAgIDAADcCNAJAAkAgAkUEQEEEIQNBBCEFQQQhBkEEIREMAQtBACECQQQhEQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQANAIAtBgIAEIBggFGsiByAHQYCABE8bIgdBA2wiDkkEQCAOIAtrIgIgASgCBCALa0sEQCABQQRqIAsgAkEEQQQQpAUgASgCCCERIAEoAgwhCwsgESALQQJ0aiEFIAJBAk8EfyACQQJ0QQRrIgYEQCAFQQAgBvwLAAsgAiALaiICQQFrIQsgESACQQJ0akEEawUgBQtBADYCACABIAtBAWoiCzYCDCABKAIYIQILIAIgB0kEQCAHIAJrIgYgASgCECACa0sEQCABQRBqIAIgBkEEQQQQpAUgASgCGCECCyABKAIUIgMgAkECdGohBSAGQQJPBH8gBkECdEEEayIEBEAgBUEAIAT8CwALIAIgBmoiBUEBayECIAMgBUECdGpBBGsFIAULQQA2AgAgASACQQFqIgI2AhgLIAEoAiQiDCAOSQRAIA4gDGsiBiABKAIcIAxrSwRAIAFBHGogDCAGQQRBBBCkBSABKAIkIQwLIAEoAiAiAyAMQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgQEQCAFQQAgBPwLAAsgBiAMaiIFQQFrIQwgAyAFQQJ0akEEawUgBQtBADYCACABIAxBAWoiDDYCJAsgASgCMCINIA5JBEAgDiANayIGIAEoAiggDWtLBEAgAUEoaiANIAZBBEEEEKQFIAEoAjAhDQsgASgCLCIDIA1BAnRqIQUgBkECTwR/IAZBAnRBBGsiBARAIAVBACAE/AsACyAGIA1qIgVBAWshDSADIAVBAnRqQQRrBSAFC0EANgIAIAEgDUEBaiINNgIwCyAHQQJ0IhcgASgCPCIISwRAIBcgCGsiBiABKAI0IAhrSwRAIAFBNGogCCAGQQRBBBCkBSABKAI8IQgLIAEoAjgiAyAIQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgQEQCAFQQAgBPwLAAsgBiAIaiIFQQFrIQggAyAFQQJ0akEEawUgBQtBADYCACABIAhBAWoiCDYCPAsgASgCCCERAkAgFCAYRwRAIBRBBXQhAyAAKAJoIQQgACgCZCEZQQAhFiABKAI4IRUgASgCFCEaIAEoAiAhGyABKAIsIRwgAiEFIAchBkEAIRBBACESA0AgA0EDaiAETw0ZIANBB2ogBE8NGiADQQtqIARPDRsgA0EPaiAETw0cIANBE2ogBE8NHSADQRdqIARPDR4gCyAQTQ0CIAMgGWoiCUEEaioAACEeIAlBCGoqAAAhHyAJQQxqKgAAISAgCUEQaioAACEhIAlBFGoqAAAhIiARIBZqIg8gCSoAADgCACAQQQFqIgogC08NBCAPQQRqIB44AgAgEEECaiITIAtPDQUgD0EIaiAfOAIAIA0gEE0NBiAWIBxqIg8gIDgCACAKIA1PDQcgD0EEaiAhOAIAIA0gE00NCCAPQQhqICI4AgAgA0EYaiIPIARPDQkgDCAQTQ0KIBYgG2oiDyAJQRhqLQAAs0MAAH9DlTgCACADQRlqIh0gBE8NCyAKIAxPDQwgD0EEaiAJQRlqLQAAs0MAAH9DlTgCACADQRpqIgogBE8NDSAMIBNNDQ4gD0EIaiAJQRpqLQAAs0MAAH9DlTgCACADQRtqIgogBE8NDyAFRQ0QIBIgGmogCUEbai0AALNDAAB/Q5U4AgAgA0EcaiIKIARPDREgA0EdaiIKIARPDRIgA0EeaiIKIARPDRMgA0EfaiIKIARPDRQgCCASTQ0VIAlBHGotAAAhCiAJQR5qLQAAIRMgCUEfai0AACEPIBUgCUEdai0AALNDAAAAw5JDAAAAPJQ4AgAgEkEBaiIJIAhPDRYgFUEEaiATs0MAAADDkkMAAAA8lDgCACASQQJqIgkgCE8NFyAVQQhqIA+zQwAAAMOSQwAAADyUOAIAIBJBA2oiCSAITw0YIBVBDGogCrNDAAAAw5JDAAAAPJQ4AgAgBUEBayEFIBVBEGohFSADQSBqIQMgFkEMaiEWIBBBA2ohECASQQRqIRIgBkEBayIGDQALCyALIA5JDR0gAiAHSQ0eIAwgDkkNHyANIA5JDSAgCCAXSQ0hIAEoAhQhBiABKAIgIQUgASgCLCEDIAFCBDcCiAEgAUICNwKAASABQgQ3AnggAUIENwJwIAFCBDcCaCABIBc2AmQgASABKAI4IgQ2AmAgASAONgJcIAEgAzYCWCABIA42AlQgASAFNgJQIAEgBzYCTCABIAY2AkggASAONgJEIAEgETYCQCAAIBQgByABQUBrEJMCIAcgFGoiFCAYTw0iDAELCyAQIAtBjNfAABCMBwALIAogC0Gc18AAEIwHAAsgEyALQazXwAAQjAcACyAQIA1BvNfAABCMBwALIAogDUHM18AAEIwHAAsgEyANQdzXwAAQjAcACyAPIARB7NfAABCMBwALIBAgDEH818AAEIwHAAsgHSAEQYzYwAAQjAcACyAKIAxBnNjAABCMBwALIAogBEGs2MAAEIwHAAsgEyAMQbzYwAAQjAcACyAKIARBzNjAABCMBwALIAIgAkHc2MAAEIwHAAsgCiAEQezYwAAQjAcACyAKIARB/NjAABCMBwALIAogBEGM2cAAEIwHAAsgCiAEQZzZwAAQjAcACyASIAhBrNnAABCMBwALIAkgCEG82cAAEIwHAAsgCSAIQczZwAAQjAcACyAJIAhB3NnAABCMBwALIAMgA0EEciAEQfDlwQAQ6gcACyADQQRqIANBCHIgBEHw5cEAEOoHAAsgA0EIaiADQQxyIARB8OXBABDqBwALIANBDGogA0EQciAEQfDlwQAQ6gcACyADQRBqIANBFHIgBEHw5cEAEOoHAAsgA0EUaiADQRhyIARB8OXBABDqBwALQQAgDiALQfzWwAAQ6gcAC0EAIAcgAkHs1sAAEOoHAAtBACAOIAxB3NbAABDqBwALQQAgDiANQczWwAAQ6gcAC0EAIBcgCEG81sAAEOoHAAsgASgCNCIARQ0AIARBBGsoAgAiAkF4cSIHIABBAnQiAEEEQQggAkEDcSICG2pJDQMgAkEAIAcgAEEnaksbDQQgBBCiAgsgASgCKCIABEAgA0EEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNAyACQQAgByAAQSdqSxsNBCADEKICCyABKAIcIgAEQCAFQQRrKAIAIgJBeHEiByAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0DIAJBACAHIABBJ2pLGw0EIAUQogILIAEoAhAiAARAIAZBBGsoAgAiAkF4cSIHIABBAnQiAEEEQQggAkEDcSICG2pJDQMgAkEAIAcgAEEnaksbDQQgBhCiAgsgASgCBCIABEAgEUEEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNAyACQQAgByAAQSdqSxsNASAREKICC0EAIQMMAQsMAgsgAUGQAWokACADDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL7RYCHX8FfSMAQZABayIBJAACQAJAAkAgACgCSCICQR9xBEAgAUEANgJQIAFBATYCRCABQYTawAA2AkAgAUIENwJIIAFBQGsQkgchAwwBCyABQQA6AEggAUEANgJEIAEgAkEFdiIYNgJAIAAgAUFAaxCEAiABQQA2AgwgAUKAgICAwAA3AgQgAUEANgIYIAFCgICAgMAANwIQIAFBADYCJCABQoCAgIDAADcCHCABQQA2AjAgAUKAgICAwAA3AiggAUEANgI8IAFCgICAgMAANwI0AkACQCACRQRAQQQhA0EEIQVBBCEGQQQhEQwBC0EAIQJBBCERAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAA0AgC0GAgAQgGCAUayIHIAdBgIAETxsiB0EDbCIOSQRAIA4gC2siAiABKAIEIAtrSwRAIAFBBGogCyACQQRBBBCkBSABKAIIIREgASgCDCELCyARIAtBAnRqIQUgAkECTwR/IAJBAnRBBGsiBgRAIAVBACAG/AsACyACIAtqIgJBAWshCyARIAJBAnRqQQRrBSAFC0EANgIAIAEgC0EBaiILNgIMIAEoAhghAgsgAiAHSQRAIAcgAmsiBiABKAIQIAJrSwRAIAFBEGogAiAGQQRBBBCkBSABKAIYIQILIAEoAhQiAyACQQJ0aiEFIAZBAk8EfyAGQQJ0QQRrIgQEQCAFQQAgBPwLAAsgAiAGaiIFQQFrIQIgAyAFQQJ0akEEawUgBQtBADYCACABIAJBAWoiAjYCGAsgASgCJCIMIA5JBEAgDiAMayIGIAEoAhwgDGtLBEAgAUEcaiAMIAZBBEEEEKQFIAEoAiQhDAsgASgCICIDIAxBAnRqIQUgBkECTwR/IAZBAnRBBGsiBARAIAVBACAE/AsACyAGIAxqIgVBAWshDCADIAVBAnRqQQRrBSAFC0EANgIAIAEgDEEBaiIMNgIkCyABKAIwIg0gDkkEQCAOIA1rIgYgASgCKCANa0sEQCABQShqIA0gBkEEQQQQpAUgASgCMCENCyABKAIsIgMgDUECdGohBSAGQQJPBH8gBkECdEEEayIEBEAgBUEAIAT8CwALIAYgDWoiBUEBayENIAMgBUECdGpBBGsFIAULQQA2AgAgASANQQFqIg02AjALIAdBAnQiFyABKAI8IghLBEAgFyAIayIGIAEoAjQgCGtLBEAgAUE0aiAIIAZBBEEEEKQFIAEoAjwhCAsgASgCOCIDIAhBAnRqIQUgBkECTwR/IAZBAnRBBGsiBARAIAVBACAE/AsACyAGIAhqIgVBAWshCCADIAVBAnRqQQRrBSAFC0EANgIAIAEgCEEBaiIINgI8CyABKAIIIRECQCAUIBhHBEAgFEEFdCEDIAAoAkghBCAAKAJEIRlBACEWIAEoAjghFSABKAIUIRogASgCICEbIAEoAiwhHCACIQUgByEGQQAhEEEAIRIDQCADQQNqIARPDRkgA0EHaiAETw0aIANBC2ogBE8NGyADQQ9qIARPDRwgA0ETaiAETw0dIANBF2ogBE8NHiALIBBNDQIgAyAZaiIJQQRqKgAAIR4gCUEIaioAACEfIAlBDGoqAAAhICAJQRBqKgAAISEgCUEUaioAACEiIBEgFmoiDyAJKgAAOAIAIBBBAWoiCiALTw0EIA9BBGogHjgCACAQQQJqIhMgC08NBSAPQQhqIB84AgAgDSAQTQ0GIBYgHGoiDyAgOAIAIAogDU8NByAPQQRqICE4AgAgDSATTQ0IIA9BCGogIjgCACADQRhqIg8gBE8NCSAMIBBNDQogFiAbaiIPIAlBGGotAACzQwAAf0OVOAIAIANBGWoiHSAETw0LIAogDE8NDCAPQQRqIAlBGWotAACzQwAAf0OVOAIAIANBGmoiCiAETw0NIAwgE00NDiAPQQhqIAlBGmotAACzQwAAf0OVOAIAIANBG2oiCiAETw0PIAVFDRAgEiAaaiAJQRtqLQAAs0MAAH9DlTgCACADQRxqIgogBE8NESADQR1qIgogBE8NEiADQR5qIgogBE8NEyADQR9qIgogBE8NFCAIIBJNDRUgCUEcai0AACEKIAlBHmotAAAhEyAJQR9qLQAAIQ8gFSAJQR1qLQAAs0MAAADDkkMAAAA8lDgCACASQQFqIgkgCE8NFiAVQQRqIBOzQwAAAMOSQwAAADyUOAIAIBJBAmoiCSAITw0XIBVBCGogD7NDAAAAw5JDAAAAPJQ4AgAgEkEDaiIJIAhPDRggFUEMaiAKs0MAAADDkkMAAAA8lDgCACAFQQFrIQUgFUEQaiEVIANBIGohAyAWQQxqIRYgEEEDaiEQIBJBBGohEiAGQQFrIgYNAAsLIAsgDkkNHSACIAdJDR4gDCAOSQ0fIA0gDkkNICAIIBdJDSEgASgCFCEGIAEoAiAhBSABKAIsIQMgAUIENwKIASABQgI3AoABIAFCBDcCeCABQgQ3AnAgAUIENwJoIAEgFzYCZCABIAEoAjgiBDYCYCABIA42AlwgASADNgJYIAEgDjYCVCABIAU2AlAgASAHNgJMIAEgBjYCSCABIA42AkQgASARNgJAIAAgFCAHIAFBQGsQ4gEgByAUaiIUIBhPDSIMAQsLIBAgC0GM18AAEIwHAAsgCiALQZzXwAAQjAcACyATIAtBrNfAABCMBwALIBAgDUG818AAEIwHAAsgCiANQczXwAAQjAcACyATIA1B3NfAABCMBwALIA8gBEHs18AAEIwHAAsgECAMQfzXwAAQjAcACyAdIARBjNjAABCMBwALIAogDEGc2MAAEIwHAAsgCiAEQazYwAAQjAcACyATIAxBvNjAABCMBwALIAogBEHM2MAAEIwHAAsgAiACQdzYwAAQjAcACyAKIARB7NjAABCMBwALIAogBEH82MAAEIwHAAsgCiAEQYzZwAAQjAcACyAKIARBnNnAABCMBwALIBIgCEGs2cAAEIwHAAsgCSAIQbzZwAAQjAcACyAJIAhBzNnAABCMBwALIAkgCEHc2cAAEIwHAAsgAyADQQRyIARB8OXBABDqBwALIANBBGogA0EIciAEQfDlwQAQ6gcACyADQQhqIANBDHIgBEHw5cEAEOoHAAsgA0EMaiADQRByIARB8OXBABDqBwALIANBEGogA0EUciAEQfDlwQAQ6gcACyADQRRqIANBGHIgBEHw5cEAEOoHAAtBACAOIAtB/NbAABDqBwALQQAgByACQezWwAAQ6gcAC0EAIA4gDEHc1sAAEOoHAAtBACAOIA1BzNbAABDqBwALQQAgFyAIQbzWwAAQ6gcACyABKAI0IgBFDQAgBEEEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNAyACQQAgByAAQSdqSxsNBCAEEKICCyABKAIoIgAEQCADQQRrKAIAIgJBeHEiByAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0DIAJBACAHIABBJ2pLGw0EIAMQogILIAEoAhwiAARAIAVBBGsoAgAiAkF4cSIHIABBAnQiAEEEQQggAkEDcSICG2pJDQMgAkEAIAcgAEEnaksbDQQgBRCiAgsgASgCECIABEAgBkEEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNAyACQQAgByAAQSdqSxsNBCAGEKICCyABKAIEIgAEQCARQQRrKAIAIgJBeHEiByAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0DIAJBACAHIABBJ2pLGw0BIBEQogILQQAhAwwBCwwCCyABQZABaiQAIAMPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu1FgEOfwJ/AkAgAiADSwRAIAEgA0EebGoiAy8BACICQf//AXFFBEAgAkEQdAwDCyACQf8HcSEBIAJBgIACcSEFIAJBgPgBcSICQYD4AUYEQCAFQRB0IQIgAkGAgID8B3IgAUUNAxogAiABQQ10ckGAgID+B3IMAwsgBUEQdCEFIAJFDQEgAkENdEGAgID8AHEgAUENdHJBgICAwANqIAVyDAILIAMgAkGEwccAEIwHAAsgBUGAgIDYA3IgAWdBEGsiAkEXdGsgASACQf//A3FBCGp0Qf///wNxcgshAQJ/IAMvAQIiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhAiAFQYCAAnEhBiAFQYD4AXEiBUGA+AFGBEAgBkEQdCEFIAVBgICA/AdyIAJFDQEaIAUgAkENdHJBgICA/gdyDAELIAZBEHQhBiAFQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogBnIgBQ0AGiAGQYCAgNgDciACZ0EQayIFQRd0ayACIAVB//8DcUEIanRB////A3FyCyEFAn8gAy8BBCIGQf//AXFFBEAgBkEQdAwBCyAGQf8HcSECIAZBgIACcSEHIAZBgPgBcSIGQYD4AUYEQCAHQRB0IQYgBkGAgID8B3IgAkUNARogBiACQQ10ckGAgID+B3IMAQsgB0EQdCEHIAZBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAHciAGDQAaIAdBgICA2ANyIAJnQRBrIgZBF3RrIAIgBkH//wNxQQhqdEH///8DcXILIQYCfyADLwEGIgdB//8BcUUEQCAHQRB0DAELIAdB/wdxIQIgB0GAgAJxIQggB0GA+AFxIgdBgPgBRgRAIAhBEHQhByAHQYCAgPwHciACRQ0BGiAHIAJBDXRyQYCAgP4HcgwBCyAIQRB0IQggB0ENdEGAgID8AHEgAkENdHJBgICAwANqIAhyIAcNABogCEGAgIDYA3IgAmdBEGsiB0EXdGsgAiAHQf//A3FBCGp0Qf///wNxcgshBwJ/IAMvAQgiCEH//wFxRQRAIAhBEHQMAQsgCEH/B3EhAiAIQYCAAnEhCSAIQYD4AXEiCEGA+AFGBEAgCUEQdCEIIAhBgICA/AdyIAJFDQEaIAggAkENdHJBgICA/gdyDAELIAlBEHQhCSAIQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogCXIgCA0AGiAJQYCAgNgDciACZ0EQayIIQRd0ayACIAhB//8DcUEIanRB////A3FyCyEIAn8gAy8BCiIJQf//AXFFBEAgCUEQdAwBCyAJQf8HcSECIAlBgIACcSEKIAlBgPgBcSIJQYD4AUYEQCAKQRB0IQkgCUGAgID8B3IgAkUNARogCSACQQ10ckGAgID+B3IMAQsgCkEQdCEKIAlBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAKciAJDQAaIApBgICA2ANyIAJnQRBrIglBF3RrIAIgCUH//wNxQQhqdEH///8DcXILIQkCfyADLwEMIgpB//8BcUUEQCAKQRB0DAELIApB/wdxIQIgCkGAgAJxIQsgCkGA+AFxIgpBgPgBRgRAIAtBEHQhCiAKQYCAgPwHciACRQ0BGiAKIAJBDXRyQYCAgP4HcgwBCyALQRB0IQsgCkENdEGAgID8AHEgAkENdHJBgICAwANqIAtyIAoNABogC0GAgIDYA3IgAmdBEGsiCkEXdGsgAiAKQf//A3FBCGp0Qf///wNxcgshCgJ/IAMvAQ4iC0H//wFxRQRAIAtBEHQMAQsgC0H/B3EhAiALQYCAAnEhDCALQYD4AXEiC0GA+AFGBEAgDEEQdCELIAtBgICA/AdyIAJFDQEaIAsgAkENdHJBgICA/gdyDAELIAxBEHQhDCALQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogDHIgCw0AGiAMQYCAgNgDciACZ0EQayILQRd0ayACIAtB//8DcUEIanRB////A3FyCyELAn8gAy8BECIMQf//AXFFBEAgDEEQdAwBCyAMQf8HcSECIAxBgIACcSENIAxBgPgBcSIMQYD4AUYEQCANQRB0IQwgDEGAgID8B3IgAkUNARogDCACQQ10ckGAgID+B3IMAQsgDUEQdCENIAxBDXRBgICA/ABxIAJBDXRyQYCAgMADaiANciAMDQAaIA1BgICA2ANyIAJnQRBrIgxBF3RrIAIgDEH//wNxQQhqdEH///8DcXILIQwCfyADLwESIg1B//8BcUUEQCANQRB0DAELIA1B/wdxIQIgDUGAgAJxIQ4gDUGA+AFxIg1BgPgBRgRAIA5BEHQhDSANQYCAgPwHciACRQ0BGiANIAJBDXRyQYCAgP4HcgwBCyAOQRB0IQ4gDUENdEGAgID8AHEgAkENdHJBgICAwANqIA5yIA0NABogDkGAgIDYA3IgAmdBEGsiDUEXdGsgAiANQf//A3FBCGp0Qf///wNxcgshDQJ/IAMvARQiDkH//wFxRQRAIA5BEHQMAQsgDkH/B3EhAiAOQYCAAnEhDyAOQYD4AXEiDkGA+AFGBEAgD0EQdCEOIA5BgICA/AdyIAJFDQEaIA4gAkENdHJBgICA/gdyDAELIA9BEHQhDyAOQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogD3IgDg0AGiAPQYCAgNgDciACZ0EQayIOQRd0ayACIA5B//8DcUEIanRB////A3FyCyEOAn8gAy8BFiIPQf//AXFFBEAgD0EQdAwBCyAPQf8HcSECIA9BgIACcSEQIA9BgPgBcSIPQYD4AUYEQCAQQRB0IQ8gD0GAgID8B3IgAkUNARogDyACQQ10ckGAgID+B3IMAQsgEEEQdCEQIA9BDXRBgICA/ABxIAJBDXRyQYCAgMADaiAQciAPDQAaIBBBgICA2ANyIAJnQRBrIg9BF3RrIAIgD0H//wNxQQhqdEH///8DcXILIQ8CfyADLwEYIhBB//8BcUUEQCAQQRB0DAELIBBB/wdxIQIgEEGAgAJxIQQgEEGA+AFxIhBBgPgBRgRAIARBEHQhECAQQYCAgPwHciACRQ0BGiAQIAJBDXRyQYCAgP4HcgwBCyAEQRB0IQQgEEENdEGAgID8AHEgAkENdHJBgICAwANqIARyIBANABogBEGAgIDYA3IgAmdBEGsiEEEXdGsgAiAQQf//A3FBCGp0Qf///wNxcgshEAJ/IAMvARoiBEH//wFxRQRAIARBEHQMAQsgBEH/B3EhAiAEQYCAAnEhESAEQYD4AXEiBEGA+AFGBEAgEUEQdCEEIARBgICA/AdyIAJFDQEaIAQgAkENdHJBgICA/gdyDAELIBFBEHQhESAEQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogEXIgBA0AGiARQYCAgNgDciACZ0EQayIEQRd0ayACIARB//8DcUEIanRB////A3FyCyECIAACfyADLwEcIgRB//8BcUUEQCAEQRB0DAELIARB/wdxIQMgBEGAgAJxIREgBEGA+AFxIgRBgPgBRgRAIBFBEHQhBCAEQYCAgPwHciADRQ0BGiAEIANBDXRyQYCAgP4HcgwBCyARQRB0IREgBEENdEGAgID8AHEgA0ENdHJBgICAwANqIBFyIAQNABogEUGAgIDYA3IgA2dBEGsiBEEXdGsgAyAEQf//A3FBCGp0Qf///wNxcgs2AjggACACNgI0IAAgEDYCMCAAIA82AiwgACAONgIoIAAgDTYCJCAAIAw2AiAgACALNgIcIAAgCjYCGCAAIAk2AhQgACAINgIQIAAgBzYCDCAAIAY2AgggACAFNgIEIAAgATYCAAv3FQIRfwJ+IwBBIGsiCiQAAkACQAJAA0ACfyABKAKcAyICIAEpA6ADIhMgAq0iFCATIBRUG6ciBEYEQEEBIQVBJSEGQQAhB0EAIQJBACEJQQAhCyADQYB+cUEkcgwBCyAKQQhqIAEgASgCmAMgBGogAiAEa0EAENYBIAopAhAiE0IoiKchByATQiCIpyECIBNCGIinIQkgE0IQiKchCyATQgiIpyEGIAotABshDCAKLQAaIQ4gCi0AGSEIIAotABghDSAKKAIMIQQgE6chBSAEIAooAggNABogASABKQOgAyAErXw3A6ADIANBgH5xQShyCyIDQf8BcUEoRwRAIANBCHYhAQwCCwJAAkACQAJAIAVB/wFxQQFrDgIAAQQLIA1B/wFxIgRByQBGDQEgBEHmAEcgCEHkAEdyIA5B/wFxQcEARyAMQf8BcUHUAEdycg0DDAILIAZB/wFxQckARyALQf8BcUHFAEdyIAlB/wFxQc4ARyACQf8BcUHEAEdycg0CQQMhAwwDCyAIQcQARyAOQf8BcUHBAEdyIAxB/wFxQdQAR3INAQsLAn8CQCABKAIIQQJHBEBBASEHIAFBCGoiA0G4AkGgAiABLQC5AkECRiIFG2ooAgAhBCADQbQCQZwCIAUbaigCACEDIAEtAMQCIg9BAUYEQCAEQQN2IARBB3FBAEdqIQUgA0UgBEVyRQRAIANBA3YgA0EHcUEAR2ohAkEBIQ1BASEIQQEhDEEBDAQLQQEhDSAERSADQQRNcg0CIANBBGsiAkEAIAIgA00bIgJBA3YgAkEHcUEAR2ohAkECIQdBASEIQQIhDEEBDAMLIARFBEBBACENQQAhBUEAIQhBAgwDC0EAIQ0gBCEFQQEhCEEADAILQayYxwAQ3QkACyADRSAEQQVJckUEQEEDIQcgBEEEayICQQAgAiAETRsiAkEDdiACQQdxQQBHaiEFIANBAnYgA0EDcUEAR2ohAkEBIQhBAyEMQQEMAQsgBEUgA0ECTXJFBEAgA0ECayICQQAgAiADTRsiAkECdiACQQNxQQBHaiECIARBAnYgBEEDcUEAR2ohBUEEIQdBASEIQQQhDEEBDAELAkAgBEEDSQ0AIAMgA0EBdmsiAkUNACAEQQJrIgVBACAEIAVPGyIFQQJ2IAVBA3FBAEdqIQVBBSEHQQEhCEEFIQxBAQwBCwJAIAQgBEEBdmsiBUUNACADQQFrIgJBACACIANNGyICIAJBAXZrIgJFDQBBBiEHQQEhCEEGIQxBAQwBC0EAIQhBByEHIARBAWsiAkEAIAIgBE0bIgIgAkEBdmsiBUUgA0VyRQRAIAMhAkEBIQhBByEMQQEMAQsgAyECQQILIQ4gAS0AxgIiCUECdCIQKAKQlEkgA2whCwJAAkACQCABLQDHAiIGQQhrDgkCAAAAAAAAAAEACyAGQQhNBEAgC0EIIAZuIhFuIhIgCyARIBJsR2ohCwwCCwwECyALQQF0IQsLIAFBADoA5AMgASAENgLcAyABIAM2AtgDIAEgDDoA1AMgASACNgLQAyABIAM2AswDIAFBADYCyAMgASAONgLEAyABIAc6AMADIAEgBDYCvAMgASADNgK4AyABIAI2ArQDIAEgBTYCsAMgASAINgKsAyABIA02AqgDIAEgC0EBaiIFNgLgAwJAIBAoAoCVSSAGQQdqQQN2bEEBayICQQdLQa8BIAJ2QQFxRXJFBEAgAUKBhIyggMCBgAggAkEDdK2IPADFBCAPRQRAIAStIAWtfiETDAILIAlBAnQiAigCyJRJIANBA3YgA0EHcUEAR2psIQsCQAJAAkAgBkEIayIFDgkCAAAAAAAAAAEACyAGQQhNBEAgC0EIIAZuIgduIg4gCyAHIA5sR2ohCwwCCwwGCyALQQF0IQsLIAIoApyVSSADQQRrIgJBACACIANNGyICQQN2IAJBB3FBAEdqbCECAkACQAJAAkACQAJAIAUOCQABAQEBAQEBAgELIAlBAnQoAriVSSADQQJ2IANBA3FBAEdqbCEHIAJBAWohDQwECyAGQQlPDQggCUECdCgCuJVJIANBAnYgA0EDcUEAR2psIQcgAkEIIAZuIgVuIg4gAiAFIA5sR2pBAWohDSAGQQhrDgkDAgICAgICAgECCyAJQQJ0KAK4lUkgA0ECdiADQQNxQQBHamwhByACQQF0QQFyIQ0LIAdBAXQhBwwBCyAHQQggBm4iAm4iBSAHIAIgBWxHaiEHCyAJQQJ0IgUoAtSVSSADQQJrIgJBACACIANNGyICQQJ2IAJBA3FBAEdqbCECAkACQAJAAkACQAJAIAZBCGsOCQABAQEBAQEBAgELIAUoAvCVSSADIANBAXZrbCEFIARBAnYgBEEDcUEAR2ohDiACQQFqIQwMBAsgBkEJTw0IIAlBAnQoAvCVSSADIANBAXZrbCEFIARBAnYgBEEDcUEAR2ohDiACQQggBm4iDG4iCCACIAggDGxHakEBaiEMIAZBCGsOCQMCAgICAgICAQILIAUoAvCVSSADIANBAXZrbCEFIARBAnYgBEEDcUEAR2ohDiACQQF0QQFyIQwLIAVBAXQhBQwBCyAFQQggBm4iAm4iCCAFIAIgCGxHaiEFCyAJQQJ0IgIoAoyWSSADQQFrIghBACADIAhPGyIIIAhBAXZrbCEJAkACQAJAIAZBCGsiCA4JAgAAAAAAAAABAAsgBkEITQRAIAlBCCAGbiIPbiIQIAkgDyAQbEdqIQkMAgsMBgsgCUEBdCEJCyACKALklEkgA2whAgJAAkACQCAIDgkCAAAAAAAAAAEACyAGQQhNBEAgAkEIIAZuIgZuIgggAiAGIAhsR2ohAgwCCwwGCyACQQF0IQILIARBBGsiBkEAIAQgBk8bIgZBA3YgBkEHcUEAR2qtIAdBAWqtfiAEQQN2IARBB3FBAEdqrSANrSALQQFqrXx+fCAOrSAMrX58IARBAmsiB0EAIAQgB08bIgdBAnYgB0EDcUEAR2qtIAVBAWqtfnwgBCAEQQF2a60gCUEBaq1+fCAEQQFrIgVBACAEIAVPGyIEIARBAXZrrSACQQFqrX58IRMMAQsgCkEANgIYIApBATYCDCAKQbiPxQA2AgggCkIENwIQIApBCGpBwI/FABCNCAALIAFBADYC+AMCQAJAIAEoAogEIgJBgoCAgHhIIAJFckUEQCABKAKMBCIDQQRrKAIAIgRBeHEiBUEEQQggBEEDcSIEGyACakkNASAEQQAgBSACQSdqSxsNAiADEKICIAEoAtgDIQMLIAFBADYCnAQgAUIANwKUBCABQYCAgIB4NgKIBCABIBM3A+gDIAogARCKBSAKLQAAQQJ0KAKslEkgA2whAwJAAkACQCAKLQABIgJBCGsOCQIAAAAAAAAAAQALIAJBCE0EQCADQQggAm4iAm4iBCADIAIgBGxHaiEDDAILDAYLIANBAXQhAwsgAyABKAKIAyICSwRAIABBJzoAAAwECyAAQSg6AAAgASACIANrNgKIAwwDC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgACAHOwAJIAAgATsAASAAIAw6AA8gACAOOgAOIAAgCDoADSAAIA06AAwgACACOgAIIAAgCToAByAAIAs6AAYgACAGOgAFIAAgBToABCAAIAM6AAAgAEELaiAHQRB2OgAAIABBA2ogAUEQdjoAAAsgCkEgaiQADwtB0I/FABCBCAALyBUCB38HfiMAQeACayICJAACfwJAAn8CQAJAAkACQCAALQAAQQNrDgUBAAAAAgALIAAgARDKAgwFCyAAKQMIIglC/////////weDIQogCUL///////////8Ag0L/////////9/8AWARAIAlCNIinIQAgCUIAUw0CIAJBsAJqDAMLQeydxgBB753GACAJQgBZIgAbQfOdxgAgClAiAxshBEEDQQQgABtBAyADGyEADAMLIAEoAgBB8ZLGAEEEIAEoAgQoAgwRAAAMAwsgAkEtOgCwAkEBIQggAkGxAmoLIQYCfwJAAkACQAJAAkACQAJAAkAgAEH/D3EiAEUgClBxRQRAIABBAkkgCkIAUnIhBCAKQoCAgICAgIAIhCAKIAAbIglCAoYhCiAJQgGDIQ8CQAJAAkAgAEG1CGtBzHcgABsiAEEASARAIAJBkAJqQYC8xQAgACAAQYWiU2xBFHYgAEF/R2siAGoiB0EEdCIDaykDACIJIApCAoQiCxDdBiACQYACakGIvMUAIANrKQMAIg0gCxDdBiACQfABaiACKQOYAiILIAIpA4ACfCIMIAIpA4gCIAsgDFatfCAAIAdBsdm1H2xBE3ZrQfwAakH/AHFBwABzIgMQoQcgAkGwAWogCSAKIARBf3OsfCILEN0GIAJBoAFqIA0gCxDdBiACQZABaiACKQO4ASILIAIpA6ABfCIMIAIpA6gBIAsgDFatfCADEKEHIAJB4AFqIAkgChDdBiACQdABaiANIAoQ3QYgAkHAAWogAikD6AEiCSACKQPQAXwiDSACKQPYASAJIA1WrXwgAxChByACKQPAASELIAIpA5ABIQkgAikD8AEhDCAAQQJJDQFBACEDIABBP0kNAgwFCyACQYABaiAAQcHoBGxBEnYgAEEDS2siB0EEdCIDKQPg5EUiCSAKQgKEIg0Q3QYgAkHwAGogA0Ho5MUAaikDACILIA0Q3QYgAkHgAGogAikDiAEiDCACKQNwfCIOIAIpA3ggDCAOVq18IAcgAGsgB0HPpsoAbEETdmpB/QBqQf8AcUHAAHMiABChByACQSBqIAkgCiAEQX9zrHwiDBDdBiACQRBqIAsgDBDdBiACIAIpAygiDCACKQMQfCIOIAIpAxggDCAOVq18IAAQoQcgAkHQAGogCSAKEN0GIAJBQGsgCyAKEN0GIAJBMGogAikDWCIJIAIpA0B8IgsgAikDSCAJIAtWrXwgABChByACKQMwIQsgAikDACEJIAIpA2AhDCAHQRZJDQJBACEDDAQLIAwgD30hDCAPUCAEcSEDQQEhBQwECyAKQn8gAK2GQn+Fg1AhBQwCC0EAIAqnayAKQgWAp0F7bEYEQEF/IQADQCAAQQFqIQAgCkLNmbPmzJmz5kx+IgpCtObMmbPmzJkzVA0ACyAAIAdPIQVBACEDDAILIA9QRQRAQX8hAANAIABBAWohACANQs2Zs+bMmbPmTH4iDUK05syZs+bMmTNUDQALIAwgACAHT619IQxBACEDDAILIAStQn+FIAp8IQpBfyEAA0AgAEEBaiEAIApCzZmz5syZs+ZMfiIKQrTmzJmz5syZM1QNAAsgACAHTyEDDAELIAZBAmpBwo/GAC0AADoAACAGQcCPxgAvAAA7AAAgCUI/iKdBA2ohACACQbACaiEEDAkLIAMNACAFRQ0BC0EAIQQgDEIKgCIOIAlCCoAiDFYNAUEAIQAgCSEKIAshDQwCC0EAIQQgDELkAIAiCiAJQuQAgCIOVg0CQQAhACAJIQ4gDCEKIAshCQwEC0EAIQADQCADQQAgCadrIAwiCqdBdmxGcSEDIABBAWohACAFIARB/wFxRXEhBSALpyALQgqAIg2nQXZsaiEEIA0hCyAOQgqAIg4gCiIJQgqAIgxWDQALCwJAIAMEQEEAIAqnayAKQgqAIgunQXZsRg0BCyANIQkMAgsDQCAAQQFqIQAgBSAEQf8BcUVxIQUgDacgDUIKgCIJp0F2bGohBCAJIQ1BACALp2sgCyIKQgqAIgunQXZsRg0ACwwBCyALpyALQuQAgCIJp0Gcf2xqQTFLIQRBAiEADAELIA9QIANxRSAJIApRcUEEQQUgCUIBg1AbIAQgBEH/AXFBBUYbIAQgBRtB/wFxQQRLcgwBCyAKQgqAIgogDkIKgCINVgR/A0AgAEEBaiEAIAkiC0IKgCEJIApCCoAiCiANIg5CCoAiDVYNAAsgC6cgCadBdmxqQQRLBSAECyAJIA5RcgshBAJAAn8CfwJAAkACQAJ/AkACQAJAIAAgB2oiA0EATiADAn9BESAJIAStQgGDfCIJQv//g/6m3uERVg0AGkEQIAlC//+Zpuqv4wFWDQAaQQ8gCUL//+iDsd4WVg0AGkEOIAlC/7/K84SjAlYNABpBDSAJQv+flKWNHVYNABpBDCAJQv/P28P0AlYNABpBCyAJQv/Hr6AlVg0AGkEKIAlC/5Pr3ANWDQAaQQkgCUL/wdcvVg0AGkEIIAlC/6ziBFYNABpBByAJQr+EPVYNABpBBiAJQp+NBlYNABpBBSAJQo/OAFYNABpBBCAJQucHVg0AGkEDIAlC4wBWDQAaQQJBASAJQglWGwsiAGoiBUERSHFFBEAgBUEBayIEQRBJDQEgBUEEakEFSQ0CIABBAUcNBSACQbACaiIAIAhqIAmnQTBqOgAAIAZB5QA6AAEgACAIQQJyIgZqIQMgBEEASA0DIAQMBAsgCSAAIAZqEMAEIANFIAAgBU5yRQRAIAJBsAJqIABqIAhqQTAgA/wLAAsgBSAIaiIAIAJBsAJqIgRqQa7gADsAACAAQQJqIQAMCgsgCSAAIAhqQQFqIgAgAkGwAmpqEMAEIAUEQCAGIAZBAWogBfwKAAALIAUgBmpBLjoAACACQbACaiEEDAkLIAJBsAJqIAhqQTA6AAAgBkEuOgABQQIgBWshBAJAIAVBAE4NAEEDIAQgBEEDTRtBAmsiA0UNACAGQQJqQTAgA/wLAAsgCSAAIAhqIARqIgAgAkGwAmoiBGoQwAQMCAsgA0EtOgAAIANBAWohA0EBIAVrCyIAQeMASg0BIABBCUwEQCADIABBMGo6AAAgBEEfdkEBaiEADAYLIAMgAEEBdC8AuLpFOwAAIARBH3ZBAnIhAAwFCyAJIAAgCGoiACACQbACaiIHaiIDQQFqEMAEIAcgCGogBi0AAToAACAGQS46AAEgA0HlADoAASAHIABBAmoiBmohAyAEQQBIDQEgBAwCCyADIABB5ABuIgVBMGo6AAAgAyAAIAVB5ABsa0EBdC8AuLpFOwABIARBH3ZBA2ohAAwDCyADQS06AAAgA0EBaiEDQQEgBWsLIgBB4wBMBEAgAEEJTARAIAMgAEEwajoAACAEQR92QQFqDAILIAMgAEEBdC8AuLpFOwAAIARBH3ZBAnIMAQsgAyAAQeQAbiIFQTBqOgAAIAMgACAFQeQAbGtBAXQvALi6RTsAASAEQR92QQNqCyAGaiEAIAJBsAJqIQQMAQsgACAGaiEAIAJBsAJqIQQLIAIgADYCrAIgAiAENgKoAiACIAJBqAJqrUKAgICAIIQ3A6ACIAEoAgAgASgCBCACQgE3AtQCIAJBAjYCzAIgAkHspcYANgLIAiACIAJBoAJqNgLQAiACQcgCahDBAwsgAkHgAmokAAvbGAMnfwp7BX4jAEEgayIIJAAgAC8BJCIFQQ9qIgtB8P8DcSEHIAtB8P8HcSENIAAoAiAhBiAAKAIcIRIgACgCFCEKIAAoAhAhEyAAKAIIIQQgACgCBCEUAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMEQCANQf//A3EiEEUNASAGIAdBAXYiCXAhACAKIAlwIQMgBUUNAiAEIAduIgQgAiAFQQNsIhduIgIgAiAESxsiJkUNEiAGIABrIRggCiADayEZIAUgEEsNESAFQQFxIScgCa0hNyAXIBdBBnAiKGsiFUEGa0EGbiIAIAVBAXYiAiAAIAJJGyIAIAUgAmtB//8DcSIRIAAgEUkbIiFBf3MgIUEBaiIAQQNxIgJBBCACGyICaiEiIAAgAmsiGkEGbCEpIAVB/v8DcSIbIBpBAXQiKmshIyAVIBpBemxqISQgASENIBQhEEEAIQpBACEFA0ACfyAFRSA1QoCAgIAQVHJFBEAgNUKAgICAcINCgICAgBB9ITggNacMAQsgCSAZSw0UIBkgCWshGUKAgICAECE4IDchNSAJIBMiBWohEyAJCyEEAn4gCkUgNkKAgICAEFRyRQRAIDanIQAgNkKAgICAcINCgICAgBB9DAELIAkgGEsNFCAYIAlrIRggNyE2IBIiCiAJIgBqIRJCgICAgBALITkgBCARSQ0EIAAgEUkNBSAUIAcgHGxqIR0gASAXIBxsaiEeIDVC/////w+DIDZC/////w+DITYgBSARaiElIAohCyAFIQwCQAJAIBVBBkkNACAVIQYgHiEEIBshACAdIQ4gIUEETwRAIA4gKmohDiAKIBpqIQsgBSAaaiEMIAQgKWohBCANIQAgBSEDIAohDyAiIQIgECEGA0AgACAP/VwAAP2JAf2pASIt/QwlZgAAJWYAACVmAAAlZgAA/bUBQQj9rQH9DGbI//9myP//Zsj//2bI///9rgEiLyAG/V0AACIwICz9DQACBAYAAAAAAAAAAAAAAAD9iQH9qQH9DIVKAACFSgAAhUoAAIVKAAAiMf21AUEI/a0BIiv9rgFBBv2sAf0MAAAAAAAAAAAAAAAAAAAAACIs/bgB/Qz/AAAA/wAAAP8AAAD/AAAAIi79tgEgKyAt/QwINAAACDQAAAg0AAAINAAA/bUBQQj9rQEgA/1cAAD9iQH9qQEiLf0MExkAABMZAAATGQAAExkAAP21AUEI/a0B/a4BIjL9sQH9DAQiAAAEIgAABCIAAAQiAAAiM/2uAUEG/awBICz9uAEgLv22Af0NAAQIDBAUGBwAAAAAAAAAACArIC39DBqBAAAagQAAGoEAABqBAAD9tQFBCP2tAf0M67r//+u6///ruv//67r///2uASI0/a4BQQb9rAEgLP24ASAu/bYBIiv9GwD9FwggK/0bAf0XCSAr/RsC/RcKICv9GwP9FwsgMCAs/Q0BAwUHAAAAAAAAAAAAAAAA/YkB/akBIDH9tQFBCP2tASItIC/9rgFBBv2sASAs/bgBIC79tgEiK/0bAP0XDCAr/RsB/RcNICv9GwL9Fw4gK/0bA/0XDyIrIC0gMv2xASAz/a4BQQb9rAEgLP24ASAu/bYBIC0gNP2uAUEG/awBICz9uAEgLv22Af0NAAQIDBAUGBwAAAAAAAAAACIs/Q0SFgMHCw8TFwAAAAAAAAAA/VsAEAAgACArICz9DQAECAwQFAEFCQ0RFQIGCg79CwAAIABBGGohACADQQRqIQMgD0EEaiEPIAZBCGohBiACQQRqIgINAAsgJCEGICMhAAsDQCAARQ0BIAwgJUYNAiAEQQJqQf8BIA4tAABBhZUBbEEIdiICIAwtAAAiD0GaggJsQQh2QZWKAWsiA2pBBnUiH0EAIB9BAEobIh8gH0H/AU4bOgAAIARB/wEgCy0AACIfQaXMAWxBCHZBmu8AayIgIAJqQQZ1IhZBACAWQQBKGyIWIBZB/wFOGzoAACAEQQVqQf8BIAMgDkEBai0AAEGFlQFsQQh2IgNqQQZ1IhZBACAWQQBKGyIWIBZB/wFOGzoAACAEQQNqQf8BIAMgIGpBBnUiIEEAICBBAEobIiAgIEH/AU4bOgAAIARBAWpB/wEgAiAfQYjoAGxBCHYgD0GTMmxBCHZqIgJrQYTEAGpBBnUiD0EAIA9BAEobIg8gD0H/AU4bOgAAIARBBGpB/wEgAyACa0GExABqQQZ1IgJBACACQQBKGyICIAJB/wFOGzoAACAEQQZqIQQgDkECaiEOIAtBAWohCyAMQQFqIQwgAEECayEAIAZBBmsiBkEGTw0ACwsgCyAKIBFqRiAoQQNJciAnRSAMICVGcnINACAVIB5qIgBB/wEgGyAdai0AAEGFlQFsQQh2IgIgDC0AACIDQZqCAmxBCHZqQZWKAWtBBnUiBkEAIAZBAEobIgYgBkH/AU4bOgACIABB/wEgAiALLQAAIgZBpcwBbEEIdmpBmu8Aa0EGdSIEQQAgBEEAShsiBCAEQf8BThs6AAAgAEH/ASACIANBkzJsQQh2IAZBiOgAbEEIdmprQYTEAGpBBnUiAEEAIABBAEobIgAgAEH/AU4bOgABCyA4hCE1IDYgOYQhNiANIBdqIQ0gByAQaiEQIBxBAWoiHCAmSQ0ACwwSCyAEIAVJDQQgBSAFQQF2ayIDIApLDQUgAyAGSw0GIAIgBUEDbCIJSQ0HIAAvASYhFSABIAkgFCAFIBMgAyASIAMQeSAFRQ0IIAIgCWsiAiAFQQZsIgxwIQ8gByAVbCIAIAdJIAAgBEtyDQkgDUH//wNxIg1FDQogB0EBdiEEIAEgCWohGyAAIAdrIgAgACAHQQF0IhBwIh5rIQAgByAUaiEdAkAgAiAPayIiIAxJDQAgBSANSwRAIAYgB0kgByAKS3IgACAQSXINAUEAIAUgB0Ho6cQAEOoHAAsgAyAESwRAIAYgB0kgByAKS3IgACAQSXINAUEAIAMgBEHY6cQAEOoHAAsgACAQSSAHIApLciAGIAdJciECIAcgBGsiDSADSQRAIAINAUEAIAMgDUHI6cQAEOoHAAsgAg0AIBsgCSAdIAUgEyADIAQgE2oiIyADIBIgAyAEIBJqIiQgAxBrIAkgG2ogCSAHIB1qIAUgIyADIBMgAyAkIAMgEiADEGsgIiAMayINIAxJDQAgBEEBayERIAogBGshFyAHIBNqIRggBUEMbCEZIAVBCWwhGiAHIBJqIRwgC0Hw/wNxQQR2IgJBBnQhISACQTBsISVBACELIAAhAgNAIAIgEGsiAiAQSSAKIAtqQQFrIBFJciALIBdqIAdJIAYgC2pBAWsgEUlycg0BIAYgCyAEayILaiAHSQ0BIAEgGmogCSAUICVqIAUgDiAjaiImIAMgDiAYaiInIAMgDiAkaiIoIAMgDiAcaiIpIAMQayABIBlqIAkgFCAhaiAFICcgAyAmIAMgKSADICggAxBrIBAgFGohFCABIAxqIQEgBCAOaiEOIA0gDGsiDSAMTw0ACwsgD0UNESAKIBVBAXEgFUEBdmpBAWsgBGwiAUkNCyABIAZLDQwgBSAeSw0NIAMgCiABayICSw0OIAMgBiABayICSw0PIBsgImogDyAAIB1qIAUgASATaiADIAEgEmogAxB5DBELIAhBADYCGCAIQQE2AgwgCEG8occANgIIIAhCBDcCECAIQQhqQcjqxAAQjQgACyAIQQA2AhggCEEBNgIMIAhBvKHHADYCCCAIQgQ3AhAgCEEIakHY6sQAEI0IAAtBACARIARB+OrEABDqBwALQQAgESAAQejqxAAQ6gcAC0EAIAUgBEG46sQAEOoHAAtBACADIApBqOrEABDqBwALQQAgAyAGQZjqxAAQ6gcAC0EAIAkgAkGI6sQAEOoHAAsgCEEANgIYIAhBATYCDCAIQbyhxwA2AgggCEIENwIQIAhBCGpB2OjEABCNCAALIAcgACAEQfjpxAAQ6gcACyAIQQA2AhggCEEBNgIMIAhBvKHHADYCCCAIQgQ3AhAgCEEIakHo6MQAEI0IAAsgASAKIApBuOnEABDqBwALIAEgBiAGQajpxAAQ6gcAC0EAIAUgHkGY6cQAEOoHAAtBACADIAJBiOnEABDqBwALQQAgAyACQfjoxAAQ6gcACyAJIBlLIAkgGEtyDQBBACAFIAdBiOvEABDqBwALIAhBIGokAAutFgMlfwN9AXsjAEHQAmsiAyQAQQAQtgkhBCADQQAQtgk2AsABIAMgBDYCvAEgA0EANgK4ASADQgA3ArABIANCBDcCeCADQgA3AnAgA0KAgICAwAA3AmggA0IENwJgIANCADcCWCADQoCAgIDAADcCUCADQQA2AjwgA0EANgI0IANBADYCLCADQQA2AiQgA0EANgIcIANBADYCFCADQQA2AgwgA0EANgJIIANBgICAgHg2ApgBIANBgICAgHg2AqQBIANBzAFqQQA6AAAgA0IENwKQASADQgA3AogBIANCgICAgMAANwKAASADQgA3AsQBIAEoAjwhEyADIAI6APgBIAMgEzYC9AEgAyABKAIIIgg2AvABIANBDGogA0HwAWoQ4QMCQAJAAkACQEGAgDAQcSIQRQ0AIBBBBGsiHS0AAEEDcQRAIBBBAEGAgDD8CwALQYCAEBBxIglFDQAgCUEEayIeLQAAQQNxBEAgCUEAQYCAEPwLAAtBgIAwEHEiEUUNACARQQRrIh8tAABBA3EEQCARQQBBgIAw/AsAC0GAgDAQcSISRQ0AIBJBBGsiIC0AAEEDcQRAIBJBAEGAgDD8CwALQYCAwAAQcSILRQ0AIAtBBGsiIS0AAEEDcQRAIAtBAEGAgMAA/AsAC0GAgAgQcSIMRQ0AIAxBBGsiIi0AAEEDcQRAIAxBAEGAgAj8CwALQYCAEBBxIg1FDQAgDUEEayIjKAIAIgVBA3EiBARAIA1BAEGAgBD8CwALIAgEQCAMQQIgAhshJCANQQQgAhshJUGAgARBACACGyEbIAEoAhAhJiABKAIUIRwgASgCBCEnA0BBgIAEIAggDmsiBCAEQYCABE8bIRQgCCAORwRAICcgDkEkbGohBCAmIA5BGGxqIQZBACEVIAkhFkEAIQUgDSEXIAshGCAMIRkDQCAIIA4gFWoiGk0EQCAaIAhB1MDHABCMBwALIARBEGoqAgAhKCAEQQxqKgIAISkgBEEIaioCACEqIANB0AFqIAQQpAMgA0HgAWogBBCaAyADQfABaiAEKQIAEMsCIAP9AATwASErIAUgEGoiCiAqOAIAIAUgEWoiByADKgLQATgCACAFIBJqIg8gAyoC4AE4AgAgCkEEaiApOAIAIAdBBGogAyoC1AE4AgAgD0EEaiADKgLkATgCACAKQQhqICg4AgAgB0EIaiADKgLYATgCACAPQQhqIAMqAugBOAIAIBggK/0LAgAgFgJ/IARBFGovAQAiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhCiAHQYCAAnEhDyAHQYD4AXEiB0GA+AFGBEAgD0EQdCEHIAdBgICA/AdyIApFDQEaIAcgCkENdHJBgICA/gdyDAELIA9BEHQhDyAHQQ10QYCAgPwAcSAKQQ10ckGAgIDAA2ogD3IgBw0AGiAPQYCAgNgDciAKZ0EQayIHQRd0ayAKIAdB//8DcUEIanRB////A3FyCzYCACACBEACfwJAIBogHEkEQAJ/IAZBFGooAgAiCkEESwRAIAZBBGooAgAhCiAGQQhqKAIADAELIAZBBGoLIQcgCg0BQQAhCkEADAILIBogHEHEwMcAEIwHDAcLIAcoAgALIQcgGSAKOwEAIBcgBzYCAAsgBEEkaiEEIAZBGGohBiAWQQRqIRYgBUEMaiEFIBdBBGohFyAYQRBqIRggGUECaiEZIBVBAWoiFSAUSQ0ACwsgAyAbNgK8AiADICU2ArgCIAMgGzYCtAIgAyAkNgKwAiADQQA2AqwCIANCgICAgMAANwKkAiADQoCAgIDAADcCnAIgA0KAgJCAwAA3ApQCIAMgCzYCkAIgA0GAgAw2AowCIAMgEjYCiAIgA0GAgAw2AoQCIAMgETYCgAIgA0GAgAQ2AvwBIAMgCTYC+AEgA0GAgAw2AvQBIAMgEDYC8AEgA0EMaiAOIBQgA0HwAWoQfiAOIBRqIg4gCEkNAAsgIygCACIFQQNxIQQLAkACQCAFQXhxQYSAEEGIgBAgBBtPBEAgBEEAIAVBqIAQTxsNBiANEKICICIoAgAiAkF4cUGEgAhBiIAIIAJBA3EiBBtJDQUgBEEAIAJBqIAITxsNBiAMEKICICEoAgAiAkF4cUGEgMAAQYiAwAAgAkEDcSIEG0kNBSAEQQAgAkGogMAATxsNBiALEKICICAoAgAiAkF4cUGEgDBBiIAwIAJBA3EiBBtJDQUgBEEAIAJBqIAwTxsNBiASEKICIB8oAgAiAkF4cUGEgDBBiIAwIAJBA3EiBBtJDQUgBEEAIAJBqIAwTxsNBiAREKICIB4oAgAiAkF4cUGEgBBBiIAQIAJBA3EiBBtJDQUgBEEAIAJBqIAQTxsNBiAJEKICIB0oAgAiAkF4cUGEgDBBiIAwIAJBA3EiBBtJDQUgBEEAIAJBqIAwTxsNBiAQEKICIBNFDQRBgICQARBxIgJFDQMgAkEEayILKAIAIgVBA3EiBARAIAJBAEGAgJAB/AsACyAIRQ0CIAEoAiAhDCABKAIcIQ1BACEGA0BBgIAEIAggBmsiBCAEQYCABE8bIQkgBiAIRwRAQQAhBSACIQQDQCADQfABaiANIAwgBSAGahC8ASAEIAP9AATwAf0LAgAgBEEQaiAD/QAEgAL9CwIAIARBIGogAyoCkAI4AgAgBEEkaiEEIAVBAWoiBSAJSQ0ACwsgA0EMaiAGIAkgAkGAgCQQ5gEgCCAGIAlqIgZLDQALDAELDAQLIAsoAgAiBUEDcSEECwJAIAVBeHFBhICQAUGIgJABIAQbTwRAIARBACAFQaiAkAFPGw0FIAIQogIgE0EBRg0DQYCA8AEQcSICRQ0CIAJBBGsiCygCACIFQQNxIgQEQCACQQBBgIDwAfwLAAsgCARAIAEoAiwhDCABKAIoIQ1BACEGA0BBgIAEIAggBmsiBCAEQYCABE8bIQkgBiAIRwRAQQAhBSACIQQDQCADQfABaiANIAwgBSAGahCLASAEIAP9AATwAf0LAgAgBEEQaiAD/QAEgAL9CwIAIARBIGogA/0ABJAC/QsCACAEQTBqIAMqAqACOAIAIARBNGogAykCpAI3AgAgBEE8aiEEIAVBAWoiBSAJSQ0ACwsgA0EMaiAGIAkgAkGAgDwQpwEgBiAJaiIGIAhJDQALIAsoAgAiBUEDcSEECyAFQXhxQYSA8AFBiIDwASAEG0kNBCAEQQAgBUGogPABTxsNBSACEKICIBNBAk0NA0GAgNACEHEiAkUNAiACQQRrIgkoAgAiBUEDcSIEBEAgAkEAQYCA0AL8CwALIAgEQCABKAI4IQsgASgCNCEMQQAhBgNAQYCABCAIIAZrIgEgAUGAgARPGyEBIAYgCEcEQEEAIQUgAiEEA0AgA0HwAWogDCALIAUgBmoQbCAEIAP9AATwAf0LAgAgBEEQaiAD/QAEgAL9CwIAIARBIGogA/0ABJAC/QsCACAEQTBqIAP9AASgAv0LAgAgBEFAayAD/QAEsAL9CwIAIARB0ABqIAMqAsACOAIAIARB1ABqIQQgBUEBaiIFIAFJDQALCyADQQxqIAYgASACQYCA1AAQlAEgASAGaiIGIAhJDQALIAkoAgAiBUEDcSEECyAFQXhxQYSA0AJBiIDQAiAEG0kNBCAEQQAgBUGogNACTxsNASACEKICDAMLDAMLDAMLAAsCQCADQQxqIgIQ1AEiAQRAIABBAjYCACAAIAE2AgQgAhCKAgwBCyAAIANBDGpBxAH8CgAACyADQdACaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALhBQDEX8BfgFvIwBBwAdrIgEkACABQeABaiIHIAIgAygCDBEBAAJAAkACQAJAAkACQCABKQPgAULNxp63xqmo+pF/hSABKQPoAULSu7jilPu7/rd/hYRQBEAgAUHQAGogAkGQAfwKAAAgASgC1AEiA0UNASAHIAMgASgC2AEiEigCDCIIEQEAAkACQAJAAkACQCABKQPgAUKgvNiAuoLloN0AhSABKQPoAUK9y93Gj/qznlqFhFBFBEAgByADIAgRAQAgASkD4AFC5fTkmdDWtpP+AIUgASkD6AFCp8KLy4X7pZOff4WEUA0BIAcgAyAIEQEAIAEpA+ABQo+XpKuq1dCexACFIAEpA+gBQq+28uu5uLyVfYWEUA0CIAcgAyAIEQEAIAEpA+ABQsK26uerwMLK5wCFIAEpA+gBQribhIDZ35Xo6wCFhFANAyAHIAMgCBEBACABKQPgAUKy1oinj7SZ7MQAhSABKQPoAULigrnHtPHRgsMAhYRQDQQgByADIAgRAQAgASkD4AFC5YrQwKDQ0OFChSABKQPoAUL7ntmK4K7cny6FhFAiEw0FIAFBADYC8AEgAUEBNgLkASABQdTgwQA2AuABIAFCBDcC6AEgB0Hc4MEAEI0IAAsgAUHgAWogA0HYBfwKAAAgAygCCCEHIAMpAwAhFSABIANBDGpB0AD8CgAAIAMoAlwhCCABKAKoByIEBEAgASgCrAciBUEEaygCACIGQXhxIglBBEEIIAZBA3EiBhsgBGpJDQwgBkEAIAkgBEEnaksbDQsgBRCiAgsgAUHAAmohBAJAAkACQCABKAKcB0GAgICAeGsOAgECAAsgBBC+AgwBCyAEEL0BCyADQQRrKAIAIgRBeHFB3AVB4AUgBEEDcSIFG0kNCyAFRQ0IIARBgAZPDQoMCAsgAygCCCEHIAMpAgAhFSABIANBDGpB0AD8CgAAIAMoAqABIQkgAygCnAEhDiADKAKUASEPIAMoApABIQsgAygCiAEhEiADKAKEASEEIAMoAnwhEyADKAJ4IQUgAygCcCENIAMoAmwhBiADKAJcIQggAygCYCIKBEAgAygCZCIQQQRrKAIAIgxBeHEiEUEEQQggDEEDcSIMGyAKakkNCyAMQQAgESAKQSdqSxsNCiAQEKICCyAGBEAgDUEEaygCACIKQXhxIhBBBEEIIApBA3EiChsgBmpJDQsgCkEAIBAgBkEnaksbDQogDRCiAgsgBQRAIBNBBGsoAgAiBkF4cSINQQRBCCAGQQNxIgYbIAVqSQ0LIAZBACANIAVBJ2pLGw0KIBMQogILAkAgBEGAgICAeEYNACAEBEAgEkEEaygCACIFQXhxIgYgBEECdCIEQQRBCCAFQQNxIgUbakkNDCAFQQAgBiAEQSdqSxsNCyASEKICCyALBEAgD0EEaygCACIEQXhxIgUgC0EBdCIGQQRBCCAEQQNxIgQbakkNDCAEQQAgBSAGQSdqSxsNCyAPEKICCyAORQ0AIAlBBGsoAgAiBEF4cSIFIA5BAnQiBkEEQQggBEEDcSIEG2pJDQsgBEEAIAUgBkEnaksbDQogCRCiAgsgA0EEaygCACIEQXhxQczTAEHQ0wAgBEEDcSIFG0kNCiAFRSAEQfDTAElyDQcMCQsgAygCCCEHIAMpAgAhFSABIANBDGpB0AD8CgAAIAMoAlwhCCADKAJgIgQEQCADKAJkIgVBBGsoAgAiBkF4cSIJQQRBCCAGQQNxIgYbIARqSQ0KIAZBACAJIARBJ2pLGw0JIAUQogILIANBBGsoAgAiBEF4cSIFQfAAQfQAIARBA3EiBBtJDQkgBEUgBUGUAUlyDQYMCAsgAygCCCEHIAMpAgAhFSABIANBDGpB0AD8CgAAIAMoAlwhCCADKAJgIgQEQCADKAJkIgVBBGsoAgAiBkF4cSIJQQRBCCAGQQNxIgYbIARqSQ0JIAZBACAJIARBJ2pLGw0IIAUQogILIANBBGsoAgAiBEF4cSIFQfAAQfQAIARBA3EiBBtJDQggBEUgBUGUAUlyDQUMBwsgAygCCCEHIAMpAgAhFSABIANBDGpB0AD8CgAAIAMoAlwhCCADKAJgIgQEQCADKAJkIARBARCiBwsgA0EEaygCACIEQXhxIgVB8ABB9AAgBEEDcSIEG0kNByAERSAFQZQBSXINBAwGCyADKAKAAiEHIAMpAvgBIRUgAygC/AIhCyADKAL4AiEEIAMoAugBIQ0gAygC5AEhBiADKAKIASEKIAMoAnQhECADKAJwIQkgAygCbCEFIAMoAmghDiADKAJkIQ8gAygCACEMIAEgA0GEAmpB0AD8CgAAIAMoAtQCIQggBARAIAsgBEEBEKIHCwJAIAxBAkYNACAFBEAgDkEkaiEEA0AgBEEEaygCACILQYCAgIB4ckGAgICAeEcEQCAEKAIAIgxBBGsoAgAiEUF4cSIUQQRBCCARQQNxIhEbIAtqSQ0KIBFBACAUIAtBJ2pLGw0JIAwQogILIARBMGohBCAFQQFrIgUNAAsLIA8EQCAOIA9BMGxBCBCiBwsgCUGAgICAeHJBgICAgHhGDQAgECAJQQEQogcLIAMgEiATGyEDIAZFIApBAkZyRQRAIA0gBkEobEEIEKIHCyADQQRrKAIAIgRBeHFBpANBqAMgBEEDcSIFG0kNAiAFRSAEQcgDSXINAwwFCyABIAM2AuQBIAEgAjYC4AFB2ObIAEErIAFB4AFqQejuwABBsO/AABDgBgALQbDgwQAQ3QkAC0HMjMgAQS5B/IzIABDrBwwBCyADEKICIAEoAlwiA0GAgICAeHJBgICAgHhHBEAgASgCYCIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyADakkNAyAFQQAgBiADQSdqSxsNAiAEEKICCyABKAJoQYCAgIB4RwRAIAFB6ABqEPYCCyABKAJQIgMEQCABKAJUIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIANqSQ0DIAVBACAGIANBJ2pLGw0CIAQQogILAkAgASgCyAEiA0GAgICAeHJBgICAgHhHBEAgASgCzAEiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgA2pJDQQgBUEAIAYgA0EnaksbDQEgBBCiAgtB9AAQcSIDRQ0BIAMgBzYCFCADIBU3AgwgA0EANgIIIANCgYCAgBA3AgAgA0EYaiABQdAA/AoAACADIAg2AnAgAyAHNgJsIAMgCDYCaCADQQhqEA4hFhDaBCIHIBYmASACQQRrKAIAIgNBeHFBlAFBmAEgA0EDcSIIG0kNAyAIQQAgA0G4AU8bDQIgAhCiAiAAIAc2AgQgAEEANgIAIAFBwAdqJAAPCwwBCwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC+cTARB/IwBBgAprIgEkACABQcADaiIFIAIgAygCDBEBAAJAAkACQAJAIAEpA8ADQuO40dasvJKArn+FIAEpA8gDQryn3YiYlYqsoX+FhFAEQCACLQDwASISQQZHBEAgAUHMAWogAkH0AfwKAAAgASgCtAMiA0UNAiAFIAMgASgCuAMiECgCDCIEEQEAAkACQAJAAkACQCABKQPAA0KI3Nq/5u+y+dkAhSABKQPIA0Kh/ou+w+76j49/hYRQRQRAIAUgAyAEEQEAIAEpA8ADQqGi3oaJvIaD8wCFIAEpA8gDQoSEh9SDyIugQ4WEUA0BIAUgAyAEEQEAIAEpA8ADQv7e4K+u1MjsNoUgASkDyANCyt3cy/j+2PXmAIWEUA0CIAUgAyAEEQEAIAEpA8ADQrOIr+uYlayb4ACFIAEpA8gDQu3H6c+dgu7+tX+FhFANAyAFIAMgBBEBACABKQPAA0Ld9u3S0ufOw3SFIAEpA8gDQvWp6Jax1+m4+wCFhFANBCAFIAMgBBEBACABKQPAA0Lk5cLa8Onu9HCFIAEpA8gDQruhgKOGtavEywCFhFAiEQ0FIAFBADYC0AMgAUEBNgLEAyABQdTgwQA2AsADIAFCBDcCyAMgBUHc4MEAEI0IAAsgAUHAA2ogA0G4BvwKAAAgAUEIaiADQfQEakHEAfwKAAAgASgCqAgiBARAIAEoAqwIIgVBBGsoAgAiBkF4cSIHQQRBCCAGQQNxIgYbIARqSQ0LIAZBACAHIARBJ2pLGw0KIAUQogILAkACQAJAIAEoApwIQYCAgIB4aw4CAQIACyABQcADahC+AgwBCyABQcADahC9AQsgA0EEaygCACIEQXhxQbwGQcAGIARBA3EiBRtJDQogBUUNCCAEQeAGTw0JDAgLIAFBCGogA0HEAfwKAAAgAygChAIhByADKAKAAiELIAMoAvgBIQwgAygC9AEhCSADKALsASEQIAMoAugBIQQgAygC4AEhESADKALcASEFIAMoAtQBIQogAygC0AEhBiADKALEASIIBEAgAygCyAEiDUEEaygCACIOQXhxIg9BBEEIIA5BA3EiDhsgCGpJDQogDkEAIA8gCEEnaksbDQkgDRCiAgsgBgRAIApBBGsoAgAiCEF4cSINQQRBCCAIQQNxIggbIAZqSQ0KIAhBACANIAZBJ2pLGw0JIAoQogILIAUEQCARQQRrKAIAIgZBeHEiCkEEQQggBkEDcSIGGyAFakkNCiAGQQAgCiAFQSdqSxsNCSAREKICCwJAIARBgICAgHhGDQAgBARAIBBBBGsoAgAiBUF4cSIGIARBAnQiBEEEQQggBUEDcSIFG2pJDQsgBUEAIAYgBEEnaksbDQogEBCiAgsgCQRAIAxBBGsoAgAiBEF4cSIFIAlBAXQiBkEEQQggBEEDcSIEG2pJDQsgBEEAIAUgBkEnaksbDQogDBCiAgsgC0UNACAHQQRrKAIAIgRBeHEiBSALQQJ0IgZBBEEIIARBA3EiBBtqSQ0KIARBACAFIAZBJ2pLGw0JIAcQogILIANBBGsoAgAiBEF4cSIFQbDUAEG01AAgBEEDcSIEG0kNCSAERSAFQdTUAElyDQcMCAsgAUEIaiADQcQB/AoAACADKALEASIEBEAgAygCyAEiBUEEaygCACIGQXhxIgdBBEEIIAZBA3EiBhsgBGpJDQkgBkEAIAcgBEEnaksbDQggBRCiAgsgA0EEaygCACIEQXhxQdQBQdgBIARBA3EiBRtJDQggBUUgBEH4AUlyDQYMBwsgAUEIaiADQcQB/AoAACADKALEASIEBEAgAygCyAEiBUEEaygCACIGQXhxIgdBBEEIIAZBA3EiBhsgBGpJDQggBkEAIAcgBEEnaksbDQcgBRCiAgsgA0EEaygCACIEQXhxQdQBQdgBIARBA3EiBRtJDQcgBUUgBEH4AUlyDQUMBgsgAUEIaiADQcQB/AoAACADKALEASIEBEAgAygCyAEgBEEBEKIHCyADQQRrKAIAIgRBeHFB1AFB2AEgBEEDcSIFG0kNBiAFRSAEQfgBSXINBAwFCyADKAK0AiEJIAMoArACIQQgAygChAIhCiADKAKAAiEGIAMoAvwBIQUgAygC+AEhByADKAL0ASELIAMoApABIQggAygCYCENIAMoAlwhDCADKAIAIQ4gAUEIaiADQbwCakHEAfwKAAAgBARAIAkgBEEBEKIHCwJAIAhBAkYNACAFBEAgB0EkaiEEA0AgBEEEaygCACIJQYCAgIB4ckGAgICAeEcEQCAEKAIAIghBBGsoAgAiD0F4cSITQQRBCCAPQQNxIg8bIAlqSQ0JIA9BACATIAlBJ2pLGw0IIAgQogILIARBMGohBCAFQQFrIgUNAAsLIAsEQCAHIAtBMGxBCBCiBwsgBkGAgICAeHJBgICAgHhGDQAgCiAGQQEQogcLIAMgECARGyEDIAxFIA5BAkZyRQRAIA0gDEEobEEIEKIHCyADQQRrKAIAIgRBeHFBjARBkAQgBEEDcSIFG0kNBSAFRSAEQbAESXINAwwEC0HA7sAAEN0JAAsgASADNgLEAyABIAI2AsADQdjmyABBKyABQcADakHo7sAAQfjuwAAQ4AYAC0Gw4MEAEN0JAAsgAxCiAgJAIAEoApwDIgNBgICAgHhyQYCAgIB4RwRAIAEoAqADIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIANqSQ0DIAVBACAGIANBJ2pLGw0CIAQQogILIAEoAswBQQJHBEAgAUHMAWoQigILIAEoApADIgMEQCABKAKUAyIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyADakkNAyAFQQAgBiADQSdqSxsNAiAEEKICCyABKAKoAyIDQYCAgIB4ckGAgICAeEcEQCABKAKsAyIEQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyADakkNAyAFQQAgBiADQSdqSxsNAiAEEKICCyASQQJ0IgMoAvDrQSEEIAMoAtjrQSEFIAFBCGoQ0QEiBkHQ7sAAQQgQ7AgiAyAFIAQQ7AgiBBDACUG0u8kALQAABEBBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgASAANgLAA0HY5sgAQSsgAUHAA2pB2OjAAEHY7sAAEOAGAAtBuLvJAEEANgIAQbS7yQBBADoAACAEQYQITwRAIAQQmwcLIANBhAhPBEAgAxCbBwsgAkEEaygCACIDQXhxIgRB+AFB/AEgA0EDcSIDG0kNAiADQQAgBEGcAk8bDQAgAhCiAiAAIAY2AgQgAEEANgIAIAFBgApqJAAPCwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwAL5BMBEH8jAEHgCWsiASQAIAFBsANqIgUgAiADKAIMEQEAAkACQAJAAkAgASkDsANC/deLibyi8JkohSABKQO4A0KD0J+9oMfru9sAhYRQBEAgAi0A6AEiEkEGRwRAIAFBxAFqIAJB7AH8CgAAIAEoAqQDIgNFDQIgBSADIAEoAqgDIhAoAgwiBBEBAAJAAkACQAJAAkAgASkDsANCl9Ogsr+ekfVxhSABKQO4A0Lr2o7NnpPqglGFhFBFBEAgBSADIAQRAQAgASkDsANC/dnb2/Ko6/wlhSABKQO4A0KEvvuqpe/a4a9/hYRQDQEgBSADIAQRAQAgASkDsANCqqLKsbmZvbFchSABKQO4A0KTsJ7ihNW54coAhYRQDQIgBSADIAQRAQAgASkDsANCgtaMka+W1c/sAIUgASkDuANCst3rmqDTsMKlf4WEUA0DIAUgAyAEEQEAIAEpA7ADQufbvbLs97vyzQCFIAEpA7gDQoXbt7ag4bn/P4WEUA0EIAUgAyAEEQEAIAEpA7ADQo7z6KKs6L31EoUgASkDuANCno+QqKna5+CKf4WEUCIRDQUgAUEANgLAAyABQQE2ArQDIAFB1ODBADYCsAMgAUIENwK4AyAFQdzgwQAQjQgACyABQbADaiADQbAG/AoAACABQQhqIANB9ARqQbwB/AoAACABKAKYCCIEBEAgASgCnAgiBUEEaygCACIGQXhxIgdBBEEIIAZBA3EiBhsgBGpJDQsgBkEAIAcgBEEnaksbDQogBRCiAgsCQAJAAkAgASgCjAhBgICAgHhrDgIBAgALIAFBsANqEL4CDAELIAFBsANqEL0BCyADQQRrKAIAIgRBeHFBtAZBuAYgBEEDcSIFG0kNCiAFRQ0IIARB2AZPDQkMCAsgAUEIaiADQbwB/AoAACADKAL8ASEHIAMoAvgBIQsgAygC8AEhDCADKALsASEJIAMoAuQBIRAgAygC4AEhBCADKALYASERIAMoAtQBIQUgAygCzAEhCiADKALIASEGIAMoArwBIggEQCADKALAASINQQRrKAIAIg5BeHEiD0EEQQggDkEDcSIOGyAIakkNCiAOQQAgDyAIQSdqSxsNCSANEKICCyAGBEAgCkEEaygCACIIQXhxIg1BBEEIIAhBA3EiCBsgBmpJDQogCEEAIA0gBkEnaksbDQkgChCiAgsgBQRAIBFBBGsoAgAiBkF4cSIKQQRBCCAGQQNxIgYbIAVqSQ0KIAZBACAKIAVBJ2pLGw0JIBEQogILAkAgBEGAgICAeEYNACAEBEAgEEEEaygCACIFQXhxIgYgBEECdCIEQQRBCCAFQQNxIgUbakkNCyAFQQAgBiAEQSdqSxsNCiAQEKICCyAJBEAgDEEEaygCACIEQXhxIgUgCUEBdCIGQQRBCCAEQQNxIgQbakkNCyAEQQAgBSAGQSdqSxsNCiAMEKICCyALRQ0AIAdBBGsoAgAiBEF4cSIFIAtBAnQiBkEEQQggBEEDcSIEG2pJDQogBEEAIAUgBkEnaksbDQkgBxCiAgsgA0EEaygCACIEQXhxIgVBqNQAQazUACAEQQNxIgQbSQ0JIARFIAVBzNQASXINBwwICyABQQhqIANBvAH8CgAAIAMoArwBIgQEQCADKALAASIFQQRrKAIAIgZBeHEiB0EEQQggBkEDcSIGGyAEakkNCSAGQQAgByAEQSdqSxsNCCAFEKICCyADQQRrKAIAIgRBeHFBzAFB0AEgBEEDcSIFG0kNCCAFRSAEQfABSXINBgwHCyABQQhqIANBvAH8CgAAIAMoArwBIgQEQCADKALAASIFQQRrKAIAIgZBeHEiB0EEQQggBkEDcSIGGyAEakkNCCAGQQAgByAEQSdqSxsNByAFEKICCyADQQRrKAIAIgRBeHFBzAFB0AEgBEEDcSIFG0kNByAFRSAEQfABSXINBQwGCyABQQhqIANBvAH8CgAAIAMoArwBIgQEQCADKALAASAEQQEQogcLIANBBGsoAgAiBEF4cUHMAUHQASAEQQNxIgUbSQ0GIAVFIARB8AFJcg0EDAULIAMoArQCIQkgAygCsAIhBCADKAKEAiEKIAMoAoACIQYgAygC/AEhBSADKAL4ASEHIAMoAvQBIQsgAygCkAEhCCADKAJgIQ0gAygCXCEMIAMoAgAhDiABQQhqIANBvAJqQbwB/AoAACAEBEAgCSAEQQEQogcLAkAgCEECRg0AIAUEQCAHQSRqIQQDQCAEQQRrKAIAIglBgICAgHhyQYCAgIB4RwRAIAQoAgAiCEEEaygCACIPQXhxIhNBBEEIIA9BA3EiDxsgCWpJDQkgD0EAIBMgCUEnaksbDQggCBCiAgsgBEEwaiEEIAVBAWsiBQ0ACwsgCwRAIAcgC0EwbEEIEKIHCyAGQYCAgIB4ckGAgICAeEYNACAKIAZBARCiBwsgAyAQIBEbIQMgDEUgDkECRnJFBEAgDSAMQShsQQgQogcLIANBBGsoAgAiBEF4cUGEBEGIBCAEQQNxIgUbSQ0FIAVFIARBqARJcg0DDAQLQaDwwAAQ3QkACyABIAM2ArQDIAEgAjYCsANB2ObIAEErIAFBsANqQejuwABBwPDAABDgBgALQbDgwQAQ3QkACyADEKICAkAgASgCjAMiA0GAgICAeHJBgICAgHhHBEAgASgCkAMiBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgA2pJDQMgBUEAIAYgA0EnaksbDQIgBBCiAgsgASgCxAFBAkcEQCABQcQBahDAAgsgASgCgAMiAwRAIAEoAoQDIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIANqSQ0DIAVBACAGIANBJ2pLGw0CIAQQogILIAEoApgDIgNBgICAgHhyQYCAgIB4RwRAIAEoApwDIgRBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIANqSQ0DIAVBACAGIANBJ2pLGw0CIAQQogILIBJBAnQiAygC8OtBIQQgAygC2OtBIQUgAUEIahDSASIGQdDuwABBCBDsCCIDIAUgBBDsCCIEEMAJQbS7yQAtAAAEQEG0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACABIAA2ArADQdjmyABBKyABQbADakHY6MAAQbDwwAAQ4AYAC0G4u8kAQQA2AgBBtLvJAEEAOgAAIARBhAhPBEAgBBCbBwsgA0GECE8EQCADEJsHCyACQQRrKAIAIgNBeHEiBEHwAUH0ASADQQNxIgMbSQ0CIANBACAEQZQCTxsNACACEKICIAAgBjYCBCAAQQA2AgAgAUHgCWokAA8LC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAvFFwICfwF+IwBBQGoiAiQAIAEoAgQhAyABKAIAIQECfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCACIALQAAQQFrDiMBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhsjHB0eHyAhIgALIAIgAEEEajYCBCACIABBCGo2AiAgAiAAQQxqNgIkIAIgAkEkaq1CgICAgLAMhDcDGCACQoCAgIDADCIEIAJBIGqthDcDECACIAQgAkEEaq2ENwMIIAJCAzcCNCACQQQ2AiwgAkHsncUANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwrCyABQYyexQBBFiADKAIMEQAADCoLIAFBop7FAEElIAMoAgwRAAAMKQsgAUHHnsUAQR4gAygCDBEAAAwoCyACIABBAWo2AiQgAiACQSRqrUKAgICAsAyENwMIIAJCATcCNCACQQI2AiwgAkGIn8UANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwnCyACIABBAWo2AiQgAiACQSRqrUKAgICAsAyENwMIIAJCATcCNCACQQI2AiwgAkG8n8UANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwmCyACIABBAWo2AiQgAiACQSRqrUKAgICAsAyENwMIIAJCATcCNCACQQI2AiwgAkHsn8UANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwlCyACIABBAWo2AiQgAiACQSRqrUKAgICAsAyENwMIIAJCATcCNCACQQI2AiwgAkGcoMUANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwkCyACIABBAWo2AiQgAiACQSRqrUKAgICAsAyENwMIIAJCATcCNCACQQI2AiwgAkHYoMUANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwjCyACIABBAWo2AiQgAiACQSRqrUKAgICAsAyENwMIIAJCATcCNCACQQI2AiwgAkGEocUANgIoIAIgAkEIajYCMCABIAMgAkEoahDBAwwiCyACIABBBGo2AiAgAiAAQQhqNgIkIAJCgICAgNAMIgQgAkEgaq2ENwMQIAIgBCACQSRqrYQ3AwggAkICNwI0IAJBAzYCLCACQcChxQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDCELIAIgAEEEajYCICACIABBCGo2AiQgAkKAgICA0AwiBCACQSRqrYQ3AxAgAiAEIAJBIGqthDcDCCACQgI3AjQgAkEDNgIsIAJB/KHFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMIAsgAiAAQQFqNgIEIAIgAEEEajYCICACIABBCGo2AiQgAiACQQRqrUKAgICA4AyENwMYIAJCgICAgNAMIgQgAkEkaq2ENwMQIAIgBCACQSBqrYQ3AwggAkIDNwI0IAJBBDYCLCACQfSixQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDB8LIAIgAEECajYCICACIABBAWo2AiQgAiACQSBqrUKAgICA8AyENwMQIAIgAkEkaq1CgICAgMAIhDcDCCACQgI3AjQgAkEDNgIsIAJB6KPFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMHgsgAUGApMUAQSEgAygCDBEAAAwdCyACIABBAmo2AiAgAiAAQQFqNgIkIAIgAkEkaq1CgICAgPAMhDcDECACIAJBIGqtQoCAgIDgDIQ3AwggAkICNwI0IAJBAjYCLCACQdCkxQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDBwLIAIgAEEBajYCJCACIAJBJGqtQoCAgIDgDIQ3AwggAkIBNwI0IAJBAjYCLCACQYilxQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDBsLIAFBmKXFAEEYIAMoAgwRAAAMGgsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJBxKXFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMGQsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJB6KXFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMGAsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJBjKbFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMFwsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJBsKbFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMFgsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJB5KbFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMFQsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJBlKfFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMFAsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJBwKfFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMEwsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJB6KfFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMEgsgAiAAQQFqNgIkIAIgAkEkaq1CgICAgMAIhDcDCCACQgE3AjQgAkECNgIsIAJBlKjFADYCKCACIAJBCGo2AjAgASADIAJBKGoQwQMMEQsgAUGkqMUAQRsgAygCDBEAAAwQCyABQdeoxQBBNyADKAIMEQAADA8LIAAtAAFBAWsOBwcICQoLDA0GCyABQbSsxQBBHyADKAIMEQAADA0LIAIgAEEBajYCJCACIAJBJGqtQoCAgICwDIQ3AwggAkIBNwI0IAJBAjYCLCACQfisxQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDAwLIAIgAEEBajYCJCACIAJBJGqtQoCAgICwDIQ3AwggAkIBNwI0IAJBATYCLCACQZytxQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDAsLIAIgAEEBajYCJCACIAJBJGqtQoCAgICwDIQ3AwggAkIBNwI0IAJBATYCLCACQcStxQA2AiggAiACQQhqNgIwIAEgAyACQShqEMEDDAoLIAFBzK3FAEEQIAMoAgwRAAAMCQsgAiAAQQFqNgIkQQEgAUG/qMUAQRggAygCDBEAAA0IGiACQQE2AiwgAkGg+McANgIoIAJCATcCNCACIAJBJGqtQoCAgICADYQ3AwggAiACQQhqNgIwIAEgAyACQShqEJ4JDAgLIAJBADYCOCACQQE2AiwgAkG0qcUANgIoIAJCBDcCMCABIAMgAkEoahCeCQwHCyACQQA2AjggAkEBNgIsIAJB5KnFADYCKCACQgQ3AjAgASADIAJBKGoQngkMBgsgAkEANgI4IAJBATYCLCACQYyqxQA2AiggAkIENwIwIAEgAyACQShqEJ4JDAULIAJBADYCOCACQQE2AiwgAkG0qsUANgIoIAJCBDcCMCABIAMgAkEoahCeCQwECyACQQA2AjggAkEBNgIsIAJB8KrFADYCKCACQgQ3AjAgASADIAJBKGoQngkMAwsgAkEANgI4IAJBATYCLCACQayrxQA2AiggAkIENwIwIAEgAyACQShqEJ4JDAILIAJBADYCOCACQQE2AiwgAkH8q8UANgIoIAJCBDcCMCABIAMgAkEoahCeCQwBCyACQQA2AjggAkEBNgIsIAJBrKzFADYCKCACQgQ3AjAgASADIAJBKGoQngkLIAJBQGskAAvOFgIHfQ5/IwBBIGsiDiQAIAAQowUgAEHAAWpBADoAACAAQgA3ArgBIAAgAhDQBAJAAkAgACgCEEEBRw0AIAAoAhhFDQACQAJ/AkACQAJAAn8CQAJAAkACQAJAAkAgAkECdCINIhEgACgCfCISTQRAIAAoAogBIhMgEU8EQCAAKAJ4IRcgACgChAEhGCACRQ0NQQAgDWshGUEBIRVBFCEMQQMhDQJ/AkADQAJAAn8CQAJAAkACfwJAAkACQAJ/AkACQAJAAkACQAJAAkAgBCAMQRRrSwRAIAxBE2sgBE8NASAMQRJrIARPDQIgDUEDayIPIBFJDQMgDyENDAQLIAxBFGsMDwsgDEETawwKCyAMQRJrDAULQwAAf0MgA0EEaioCACIIiyIFQwAAgD9DAAD4QUMAAAAAIAMqAgAiCYsiBiAFIANBCGoqAgAiCosiCxDgCBDgCBCeBY5DAABwQZIiBSAFQwAAAABdGyIFIAVDAAD4QV4bELkH/AAiD0EPaxCwBkMAAH9DlSIFlSIHIAdDAAB/Q14bELkHIQcgFCAXaiIQQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgD0EbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACAMQRFrIARPDQsgDEEQayAETw0HIAxBD2sgBE8NAyARIA1BAmtLBEBDAAB/QyADQRBqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgA0EMaioCACIJiyIGIAUgA0EUaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIPQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAQQQRqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgD0EbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACAMQQ5rIARPDQsgDEENayAETw0HIAxBDGsgBE8NAyARIA1BAWtLBEBDAAB/QyADQRxqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgA0EYaioCACIJiyIGIAUgA0EgaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIPQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAQQQhqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgD0EbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACAMQQtrIARPDQsgDEEKayAETw0HIAxBCWsgBE8NAyANIBFPDQJDAAB/QyADQShqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgA0EkaioCACIJiyIGIAUgA0EsaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIPQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAQQQxqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgD0EbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACAMQQhrIARPDR4gDEEHayAETw0aIAxBBmsgBE8NFiANIBlqIhBBA0cNDyANQQNrDBILIA1BAWshDQwBCyANQQJrIQ0LIA0gEUGovsEAEIwHAAsgDEEJawwCCyAMQQxrDAELIAxBD2sLIARBmL7BABCMBwALIAxBCmsMAgsgDEENawwBCyAMQRBrCyAEQYi+wQAQjAcACyAMQQtrDAILIAxBDmsMAQsgDEERawsgBEH4vcEAEIwHAAtDAAB/QyADQTRqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgA0EwaioCACIJiyIGIAUgA0E4aioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIWQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAUIBhqIg9DAAB/QyAGIAWVIgYgBkMAAH9DXhsQuQf8ASAWQRt0QYCAgAhBACAJQwAAAABdG3JBgICAEEEAIAhDAAAAAF0bckGAgIAgQQAgCkMAAAAAXRtyciAH/AFBCHRyQwAAf0MgCyAFlSIFIAVDAAB/Q14bELkH/AFBEHRyNgIAIAxBBWsgBE8NDSAMQQRrIARPDQkgDEEDayAETw0FIBBBAkYNAUMAAH9DIANBQGsqAgAiCIsiBUMAAIA/QwAA+EFDAAAAACADQTxqKgIAIgmLIgYgBSADQcQAaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIWQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAPQQRqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgFkEbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACAMQQJrIARPDQwgDEEBayAETw0IIAQgDE0NByAQQQFHBEBDAAB/QyADQcwAaioCACIIiyIFQwAAgD9DAAD4QUMAAAAAIANByABqKgIAIgmLIgYgBSADQdAAaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIQQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAPQQhqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgEEEbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACAUQRBqIRQgDEEVaiEMIANB1ABqIQMgDUEEaiENIAIgFUsgFUEBaiEVDQEMEQsLIA1BAWsMAQsgDUECawsgEUHovcEAEIwHAAtBACARIBNBqL3BABDqBwALQQAgESASQbi+wQAQ6gcACyAMQQNrIQwMAQsgDEEGayEMCyAMIARB2L3BABCMBwALIAxBAWsMAgsgDEEEawwBCyAMQQdrCyAEQci9wQAQjAcACyAMQQJrDAILIAxBBWsMAQsgDEEIawsgBEG4vcEAEIwHAAsgDiAAKAIUIAFBAnQiAyABIAJqQQJ0IgIQ4QgiARC4CiIENgIAIA4gEjYCBCAEIBJHDQEgASAXIBIQ4AkgAUGECE8EQCABEJsHCyAOIAAoAhwgAyACEOEIIgAQuAoiATYCACAOIBM2AgQgASATRw0BIAAgGCATEOAJIABBhAhJDQAgABCbBwsgDkEgaiQADwsgDkEANgIIQQAgDiAOQQRqIA5BCGpB4PnEABD1BwALvhQBDn8jAEEgayIQJAACQAJAIAFBIUkEQCAAIQkgASEKDAELIAJBBGshESACQRBrIRICQAJAA0AgBEUEQCAAIAEgAiADQQEQ3QEMBQsgACABQQN2IghBHGxqIQYgACAIQQR0aiEJIARBAWshBCAQAn8gAUHAAE8EQCAAIAkgBiAIEMIGDAELIAAgBiAJIAAoAgAiCCAJKAIAIglJIgcgCSAGKAIAIgZJcxsgByAGIAhLcxsLIg0oAgAiBjYCBCANIABrQQJ2IQwCQAJAIAUEQCAFKAIAIAZPDQELIAEgA0sNAyACIAFBAnQiE2ohB0EAIQogACEGIAwhCANAIAAgCEEDayIJQQAgCCAJTxtBAnRqIg4gBksEQCANKAIAIQkDQCAKQQJ0IAIgB0EEayAGKAIAIgsgCUkiDxtqIAs2AgAgCiAPaiIKQQJ0IAIgB0EIayAGQQRqKAIAIgsgCUkiDxtqIAs2AgAgCiAPaiIKQQJ0IAIgB0EMayAGQQhqKAIAIgsgCUkiDxtqIAs2AgAgCiAPaiIKQQJ0IAIgB0EQayIHIAZBDGooAgAiCyAJSSIPG2ogCzYCACAKIA9qIQogBkEQaiIGIA5JDQALCyAAIAhBAnRqIgkgBksEQCANKAIAIQ4DQCAKQQJ0IAIgB0EEayIHIAYoAgAiCyAOSSIPG2ogCzYCACAKIA9qIQogBkEEaiIGIAlJDQALCyABIAhHBEAgB0EEayIHIApBAnRqIAYoAgA2AgAgBkEEaiEGIAEhCAwBCwsgCkECdCIOBEAgACACIA78CgAACyABIAprIQsCQCABIApGDQBBACEJIAtBBE8EQCAAIA5qIQYgEiATaiEHIAtBfHEiCSEIA0AgBiAH/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgB0EQayEHIAZBEGohBiAIQQRrIggNAAsgCSALRg0BCyARIBMgCUECdCIIa2ohBiAAIAhqIA5qIQcgCSABayAKaiEIA0AgByAGKAIANgIAIAZBBGshBiAHQQRqIQcgCEEBaiIIDQALCyAKRQ0AIAEgCk8NASAQQQA2AhggEEEBNgIMIBBBiILIADYCCCAQQgQ3AhAgEEEIakH0lMEAEI0IAAsgASADSw0CIAIgAUECdCIOaiEHQQAhCCAAIQYDQCAAIAxBA2siBUEAIAUgDE0bQQJ0aiIJIAZLBEAgDSgCACEFA0AgCEECdCACIAdBBGsgBSAGKAIAIgpPIgsbaiAKNgIAIAggC2oiCEECdCACIAdBCGsgBSAGQQRqKAIAIgpPIgsbaiAKNgIAIAggC2oiCEECdCACIAdBDGsgBSAGQQhqKAIAIgpPIgsbaiAKNgIAIAggC2oiCEECdCACIAdBEGsiByAFIAZBDGooAgAiCk8iCxtqIAo2AgAgCCALaiEIIAZBEGoiBiAJSQ0ACwsgACAMQQJ0aiIFIAZLBEAgDSgCACEJA0AgCEECdCACIAdBBGsiByAJIAYoAgAiCk8iCxtqIAo2AgAgCCALaiEIIAZBBGoiBiAFSQ0ACwsgASAMRwRAIAIgCEECdGogBigCADYCACAGQQRqIQYgCEEBaiEIIAdBBGshByABIQwMAQsLIAhBAnQiDQRAIAAgAiAN/AoAAAsgASAIRg0FIAAgDWohCUEAIQwCQCABIAhrIgpBBE8EQCAOIBJqIQYgCSEHIApBfHEiDCEFA0AgByAG/QACAP0MAAAAAAAAAAAAAAAAAAAAAP0NDA0ODwgJCgsEBQYHAAECA/0LAgAgBkEQayEGIAdBEGohByAFQQRrIgUNAAsgCiAMRg0BCyARIAxBAnQiBWsgDmohBiAAIAVqIA1qIQcgDCABayAIaiEFA0AgByAGKAIANgIAIAZBBGshBiAHQQRqIQcgBUEBaiIFDQALCyABIAhJDQNBACEFIAkhACAKIgFBIUkNBAwBCyAAIA5qIAsgAiADIAQgEEEEahCVASAKIgFBIU8NAAsgACEJDAILAAsgCCABIAFBhJXBABDqBwALIApBAkkNACAKQQF2IQEgAQJ/IApBD00EQCAKQQdLBEAgAiAJQQhBDCAJKAIMIAkoAghJIgUbaiIIKAIAIgAgCSAJKAIEIgYgCSgCACIHT0ECdGoiAygCACIEIAAgBEsbNgIMIAIgCUEMQQggBRtqIgUoAgAiDCAJIAYgB0lBAnRqIgcoAgAiBiAGIAxLIgYbNgIAIAIgCCADIAUgBhsgACAESSIEGygCACIAIAcgBSADIAQbIAYbKAIAIgMgACADSxs2AgggAiAAIAMgACADSRs2AgQgAiABQQJ0IgBqIgMgACAJaiIAQQhBDCAAKAIMIAAoAghJIggbaiIMKAIAIgQgACAAKAIEIgcgACgCACINT0ECdGoiBSgCACIGIAQgBksbNgIMIAMgAEEMQQggCBtqIggoAgAiDiAAIAcgDUlBAnRqIg0oAgAiACAAIA5LIgcbNgIAIAMgDCAFIAggBxsgBCAGSSIEGygCACIAIA0gCCAFIAQbIAcbKAIAIgQgACAESRs2AgQgAyAAIAQgACAESxs2AghBBAwCCyACIAkoAgA2AgAgAiABQQJ0IgBqIAAgCWooAgA2AgBBAQwBCyAJIAIgAiAKQQJ0aiIAEMwCIAkgAUECdCIDaiACIANqIABBIGoQzAJBCAsiAEsEQCAAQQJ0IQQgAEEBaiEGIAAhBwNAIAYhAyACIAdBAnQiBWoiBiAFIAlqKAIAIgU2AgAgBkEEaygCACIHIAVLBEAgBCEGAn8DQCACIAZqIgggBzYCACACIAZBBEYNARogBkEEayEGIAUgCEEIaygCACIHSQ0ACyACIAZqCyAFNgIACyAEQQRqIQQgAyABIANLIgVqIQYgAyEHIAUNAAsLIAIgAUECdCIDaiEFIAogAWsiBCAASwRAIAMgCWohDCAAQQJ0IQggAEEBaiEGA0AgBiEDIAUgAEECdCIAaiIGIAAgDGooAgAiADYCACAGQQRrKAIAIgcgAEsEQCAIIQYCfwNAIAUgBmoiDSAHNgIAIAUgBkEERg0BGiAGQQRrIQYgACANQQhrKAIAIgdJDQALIAUgBmoLIAA2AgALIAhBBGohCCADIAMgBEkiB2ohBiADIQAgBw0ACwsgBUEEayEIIAIgCkECdEEEayIAaiEMIAAgCWohBANAIAkgBSgCACIGIAIoAgAiByAGIAdJIg0bNgIAIAQgDCgCACIAIAgoAgAiAyAAIANLGzYCACAEQQRrIQQgCUEEaiEJIAhBfEEAIAAgA0kbaiEIIAxBfEEAIAAgA08baiEMIAIgBiAHT0ECdGohAiAFIA1BAnRqIQUgAUEBayIBDQALIAhBBGohACAKQQFxBH8gCSACIAUgACACSyIBGygCADYCACAFIAAgAk1BAnRqIQUgAiABQQJ0agUgAgsgAEYgBSAMQQRqRnENABCACAALIBBBIGokAAv/EwIKfwZ+QQghBQJAIAFBBEkNACAALQAAIgIgAC0AAUcNACABrSEOIAAtAAMhByAALQACIQMCQAJAAkACQAJ+AkACQAJAAkACQAJAAkACQCACQckAaw4FAA0NDQENCyADQSpHIAdyDQwgAUF8cUEERg0BIAA1AAQhDAwICyADIAdBKkdyDQsgAUF8cUEERg0BIAAoAAQhBAwCC0GokMgAKQMAIg2nQf8BcSICQQRGDQYgAkEDRw0KIA1CIIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0JIAMgACACKAIIEKIHDAkLQaiQyAApAwAiDadB/wFxIgJBBEcNAQsgASAEQRh0IARBgP4DcUEIdHIgBEEIdkGA/gNxIARBGHZycq0iECAOIA4gEFYbpyICa0ECSQ0BIAAgAmovAAAhAkEEIQUMAgsgAkEDRw0HIA1CIIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0GIAMgACACKAIIEKIHDAYLQQAhAkGokMgAKQMAIg1CCIghDyANpyEFIA4gDUL/AYNCBFINARoLIBBCAnwLIQwgBUH/AXEiA0EERgRAQQghBUEAIQRBqJDIACkDACIPQv8BgyERIA9CCIghECAPpyEDIAJBCHQgAkGA/gNxQQh2ckH//wNxIQcDQCAEQf//A3EgB08NBgJ+AkAgASAMIA4gDCAOVBunIgJrQQJPBEAgACACai8AAEGBJEYhCEEEIQJCACENDAELQQAhCCAQIQ0gAyECIA4gEUIEUg0BGgsgDEICfAshDCACQf8BcSICQQRHBEAgAkEDRw0HIA1CGIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0GIAMgACACKAIIEKIHDAYLAn4CQCABIAwgDiAMIA5UG6ciAmtBAk8EQCAAIAJqLwAAQYAGRiEJQQQhAkIAIQ0MAQtBACEJIBAhDSADIQIgDiARQgRSDQEaCyAMQgJ8CyEMIAJB/wFxIgJBBEcEQCACQQNHDQcgDUIYiKciASgCACEDIAFBBGooAgAiAigCACIABEAgAyAAEQMACyACKAIEIgBFDQYgAyAAIAIoAggQogcMBgsCfgJAIAEgDCAOIAwgDlQbpyICa0EETwRAIAAgAmooAABBgICACEYhCkEEIQJCACENDAELQQAhCiAQIQ0gAyECIA4gEUIEUg0BGgsgDEIEfAshDCACQf8BcSICQQRHBEAgAkEDRw0HIA1CGIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0GIAMgACACKAIIEKIHDAYLAn4CQCABIAwgDiAMIA5UG6ciAmtBAk8EQCAAIAJqLwAAIQZBBCECQgAhDQwBC0EAIQYgECENIAMhAiAOIBFCBFINARoLIAxCAnwLIQwCQCACQf8BcUEERgRAIAEgDCAOIAwgDlQbp2tBAUsiAiADQf8BcSILQQRGcg0BIAtBA0cNCCAPQiCIpyIBKAIAIQMgAUEEaigCACICKAIAIgAEQCADIAARAwALIAIoAgQiAEUNByADIAAgAigCCBCiBwwHCyACQf8BcUEDRw0HIA1CGIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0GIAMgACACKAIIEKIHDAYLIARBAWohBCAMQgJ8Ig0gDSAOIBFCBFEbIAIbIQwgCCAJcSAKcUUNAAtB/wEgBkEIdCAGQYD+A3FBCHZyQf//A3EiACAAQf8BTxtBAWsiAUH/AXFBB0sNBQwCC0EIIQUgA0EDRw0EIA9CGIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0DIAMgACACKAIIEKIHDAMLAn4CQCABIAwgDiAMIA5UG6ciAmtBAk8EQCAAIAJqLwAAIQJBBCEEDAELQQAhAkGokMgAKQMAIg1CCIghDyANpyEEIA4gDUL/AYNCBFINARoLIAxCAnwLIQwgBEH/AXEiA0EERw0BQQAhBEGokMgAKQMAIg9C/wGDIREgD0IIiCEQIA+nIQMgAkH//wNxIQcDQCAEQf//A3EgB08NBAJ+AkAgASAMIA4gDCAOVBunIgJrQQJPBEAgACACai8AAEGSAkYhCEEEIQJCACENDAELQQAhCCAQIQ0gAyECIA4gEUIEUg0BGgsgDEICfAshDCACQf8BcSICQQRHBEAgAkEDRw0FIA1CGIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0EIAMgACACKAIIEKIHDAQLAn4CQCABIAwgDiAMIA5UG6ciAmtBAk8EQCAAIAJqLwAAQQNGIQlBBCECQgAhDQwBC0EAIQkgECENIAMhAiAOIBFCBFINARoLIAxCAnwLIQwgAkH/AXEiAkEERwRAIAJBA0cNBSANQhiIpyIBKAIAIQMgAUEEaigCACICKAIAIgAEQCADIAARAwALIAIoAgQiAEUNBCADIAAgAigCCBCiBwwECwJ+AkAgASAMIA4gDCAOVBunIgJrQQRPBEAgACACaigAAEEBRiEKQQQhAkIAIQ0MAQtBACEKIBAhDSADIQIgDiARQgRSDQEaCyAMQgR8CyEMIAJB/wFxIgJBBEcEQCACQQNHDQUgDUIYiKciASgCACEDIAFBBGooAgAiAigCACIABEAgAyAAEQMACyACKAIEIgBFDQQgAyAAIAIoAggQogcMBAsCfgJAIAEgDCAOIAwgDlQbpyICa0ECTwRAIAAgAmovAAAhBkEEIQJCACENDAELQQAhBiAQIQ0gAyECIA4gEUIEUg0BGgsgDEICfAshDCACQf8BcSICQQRHBEAgAkEDRw0FIA1CGIinIgEoAgAhAyABQQRqKAIAIgIoAgAiAARAIAMgABEDAAsgAigCBCIARQ0EIAMgACACKAIIEKIHDAQLIAEgDCAOIAwgDlQbp2tBAUsiAiADQf8BcSILQQRGckUEQCALQQNHDQUgD0IgiKciASgCACEDIAFBBGooAgAiAigCACIABEAgAyAAEQMACyACKAIEIgBFDQQgAyAAIAIoAggQogcMBAsgBEEBaiEEIAxCAnwiDSANIA4gEUIEURsgAhshDCAIIAlxIApxRQ0AC0H/ASAGIAZB/wFPG0EBayIBQf8BcUEITw0DC0KAiIio4KDAgwMgAUEDdK1C+AGDiKchBQwCCyADQQNHDQEgD0IYiKciASgCACEDIAFBBGooAgAiAigCACIABEAgAyAAEQMACyACKAIEIgBFDQAgAyAAIAIoAggQogcLIAFBDEEEEKIHQQgPCyAFC4UVAiF/Dn0jAEEQayIRJAAgACABIAIQzAMCQAJAAkACQCADKAIEIhJFBEAgAygCDCEIDAELAkAgAygCDCIIRQ0AIAMoAhQiGEUNACADKAIcIhlFDQAgAygCJCIVRQ0AIAJFDQJDAAAAQEMAAIA/IAAtAJwBGyExIAJBDGwhGyAAKgKMASAAKgKIASIpkyEqIAAqAoQBIAAqAoABIiuTISwgACgCZCEaIAAoAmAhHCADKAIgIR0gAygCGCEeIAMoAhAhHyADKAIIISAgAygCACEhIAghEAJAAkACQAJAAkACQANAIBogBEEEaiILSQRAIAQgCyAaQYThwAAQ6gcACyAGIBJPDQYgEiAGayIFQQAgBSASTRsiBUEBRg0EIAVBAkYNBQJAAkACQCAQBEACQAJAIAYgGE8NAAJAAkAgFyAYakEBaw4CAAEDCyAGQQFqIQYMAQsgBkECaiEGCyAGIBhBtOHAABCMBwALAkACQCAGIBlPDQACQAJAIBcgGWpBAWsOAgABAwsgBkEBaiEGDAELIAZBAmohBgsgBiAZQZThwAAQjAcACyAEIBVPDQcCQCAVIARrIgVBACAFIBVNG0EBaw4DBAYHAAsgEyAhaiIFKAIAIQkgBUEIaigCACEUIAVBBGooAgAhCiAEICBqKgIAIBMgH2oiBCoCACEmIARBCGoqAgAhKCAEQQRqKgIAIScgEyAeaiIEKgIAIS0gBEEIaioCACEuIARBBGoqAgAhLyAWIB1qIgQqAgAhJSARIARBBGoqAgA4AgQgESAlOAIAIBEgBEEIaikCADcCCEMAAH9DQwAAAAAgJyArkyAslUMAAH9DlCIlICVDAAAAAF0bIiUgJUMAAH9DXhsQuQciMEMAAAAAYCEiIDD8ASEjQwAAf0NDAAAAACAoICuTICyVQwAAf0OUIiUgJUMAAAAAXRsiJSAlQwAAf0NeGxC5ByIoQwAAAABgISQgKPwBIQxDAAB/Q0MAAAAAICYgK5MgLJVDAAB/Q5QiJSAlQwAAAABdGyIlICVDAAB/Q14bELkHISYgMZUhJyAJQf///wNxIQUgCUGAgICAeHEhBCAJQYCAgPwHcSIHQYCAgPwHRgRAIARBEHYgBUENdnJBgARBACAFG3JBgPgBciENDAMLIARBEHYhDSAHQYCAgLgESw0BIAdBgICAxANPBEAgCUEMdiAJQf/fAHFBAEdxIAdBDXYgBUENdmpBgIABaiANcmohDQwDCyAHQYCAgJgDSQ0CIAVBgICABHIiCUH+ACAHQRd2IgVrdiEEIAlBHSAFayIFdkEBcQR/IARBAyAFdEEBayAJcUEAR2oFIAQLIA1yIQ0MAgsgCCAIQfTgwAAQjAcACyANQYD4AXIhDQsgCkH///8DcSEFIApBgICAgHhxIQQCQCAKQYCAgPwHcSIHQYCAgPwHRwRAIARBEHYhDiAHQYCAgLgETQRAIAdBgICAxANPBEAgCkEMdiAKQf/fAHFBAEdxIAdBDXYgBUENdmpBgIABaiAOcmohDgwDCyAHQYCAgJgDSQ0CIAVBgICABHIiCUH+ACAHQRd2IgVrdiEEIAlBHSAFayIFdkEBcQR/IARBAyAFdEEBayAJcUEAR2oFIAQLIA5yIQ4MAgsgDkGA+AFyIQ4MAQsgBEEQdiAFQQ12ckGABEEAIAUbckGA+AFyIQ4LIBRB////A3EhBSAUQYCAgIB4cSEEAkAgFEGAgID8B3EiB0GAgID8B0cEQCAEQRB2IQ8gB0GAgIC4BE0EQCAHQYCAgMQDTwRAIBRBDHYgFEH/3wBxQQBHcSAHQQ12IAVBDXZqQYCAAWogD3JqIQ8MAwsgB0GAgICYA0kNAiAFQYCAgARyIglB/gAgB0EXdiIFa3YhBCAJQR0gBWsiBXZBAXEEfyAEQQMgBXRBAWsgCXFBAEdqBSAECyAPciEPDAILIA9BgPgBciEPDAELIAVBDXYgBEEQdnJBgARBACAFG3JBgPgBciEPCyAREJ0EIQpBACEJQQAhBSAtQwAAAABfRQRAQf8BQwAAgD9DAAAAACAtEMYFICmTICqVIiUgJUMAAAAAXRsiJSAlQwAAgD9eG0MAAH5DlBC5ByIl/AFBACAlQwAAAABgGyAlQwAAf0NeG0EBakH/AXEhBQsgL0MAAAAAX0UEQEH/AUMAAIA/QwAAAAAgLxDGBSApkyAqlSIlICVDAAAAAF0bIiUgJUMAAIA/XhtDAAB+Q5QQuQciJfwBQQAgJUMAAAAAYBsgJUMAAH9DXhtBAWpB/wFxQQh0IQkLQQAhBCAuQwAAAABfRQRAQf8BQwAAgD9DAAAAACAuEMYFICmTICqVIiUgJUMAAAAAXRsiJSAlQwAAgD9eG0MAAH5DlBC5ByIl/AFBACAlQwAAAABgGyAlQwAAf0NeG0EBakH/AXFBEHQhBAsgFiAcaiIHQQRqIA1B//8DcSAOQRB0cjYCACAHQQxqIAUgCkEIdEGAgIB4cXIgBCAJcmo2AgAgB0EIaiAPQf//A3EgCkEQdHJB////B3EgCkGA/v8HcUEIdkEYdHI2AgAgB0H/ASAjQQAgIhsgMEMAAH9DXhtBCHRB/wEgDEEAICQbIChDAAB/Q14bQRB0ckH/ASAm/AFBACAmQwAAAABgGyAmQwAAf0NeG3JB/wFDAAB/Q0MAAAAAICdDAAB/Q5QiJSAlQwAAAABdGyIlICVDAAB/Q14bELkHIiX8AUEAICVDAAAAAGAbICVDAAB/Q14bQRh0cjYCACAWQRBqIRYgF0EDayEXIAZBA2ohBiAQQQFrIRAgCyEEIBsgE0EMaiITRw0BDAoLCyAEQQFqIQQMAgsgBEECaiEEDAELIARBA2ohBAsgBCAVQaThwAAQjAcACyAGQQFqIQYMAQsgBkECaiEGCyAGIBJBxOHAABCMBwALIAAgASACIAMoAgAgEhCjAgsgCARAIAMoAgghBCAAIAEgAhDMAyACBEBDAAAAQEMAAIA/IAAtAJwBQQFxGyEnIAJBAnQhECAAKAJkIQUgACgCYCEGIAghCwNAIAxBA2ogBU8NBCALRQ0FIAZBA2pB/wFDAAB/Q0MAAAAAIAQgDGoqAgAgJ5VDAAB/Q5QiJSAlQwAAAABdGyIlICVDAAB/Q14bELkHIiX8AUEAICVDAAAAAGAbICVDAAB/Q14bOgAAIAZBEGohBiALQQFrIQsgECAMQQRqIgxHDQALCyAAQQE6ALgBCyADKAIUIggEQCAAIAEgAiADKAIQIAgQlgQLIAMoAhwiCARAIAAgASACIAMoAhggCBDJAwsgAygCJCIIRQ0AIAAgASACIAMoAiAgCBD7BAsgAEEBOgC4ASADKAI8IQUgAygCOCEQIAMoAjQhBCADKAIwIQsgAygCLCIIBEAgACABIAIgAygCKCAIEM4DCyAEBEAgACABIAIgCyAEEOIDCyAFBEAgACABIAIgECAFEOMDCyADKAJEIggEQCAAIAEgAiADKAJAIAgQtAQLIAMoAkwiCARAIAAgASACIAMoAkggCBC1BAsgEUEQaiQADwsgDCAMQQRqIAVBuNvAABDqBwALIAggCEGo28AAEIwHAAvXFAIWfwF7IwBB0ABrIgQkACAEQRBq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAEIBj9CwMAIAEoAgQiCiABKAIIIglBAXQiBmohEyAKIQMCQAJAAkACQAJAAkACQAJAA0AgAyATRwRAIAMvAQAhAiADQQJqIQMgAkUNASACQRBPDQIgBCACQQF0aiICIAIvAQBBAWo7AQAgCEEBaiEIDAELCwJAAkACQAJAAkAgCA4CAwABCyAJBEBBACECIAohAwNAIAMvAQANAyACQQFqIQIgA0ECaiEDIAZBAmsiBg0ACwtB+O3EABDdCQALQRAhBSAEQTBqIBj9CwMAIAQgGP0LAyAgBC8BHiILBEBBDyEDDAYLIAQvARwEQEEPIQVBDiEDDAYLIAQvARoEQEEOIQVBDSEDDAYLIAQvARgEQEENIQVBDCEDDAYLIAQvARYEQEEMIQVBCyEDDAYLIAQvARQEQEELIQVBCiEDDAYLIAQvARIEQEEKIQVBCSEDDAYLIAQvARAEQEEJIQVBCCEDDAYLIAQvAQ4EQEEIIQVBByEDDAYLIAQvAQwEQEEHIQVBBiEDDAYLIAQvAQoEQEEGIQVBBSEDDAYLIAQvAQgEQEEFIQVBBCEDDAYLIAQvAQYEQEEEIQVBAyEDDAYLIAQvAQRFDQJBAyEFQQIhAwwFCyAAIAI7AQQgAEGAgICAeDYCAAwGCyAAQYGAgIB4NgIAIABBDjoABAwFCyAELwECIgJFDQFBASEDIAJBAXQhAkECIQUMAwsgAkEQQZjvxAAQjAcAC0GI7sQAEN0JAAsgBCAELwECQQF0IgI7ASQgBC8BBCACakEBdCECIANBAmoiB0EERgRAQQIhAwwBCyAEIAI7ASYgBC8BBiACakEBdCECIAdBBUYEQEEDIQMMAQsgBCACOwEoIAQvAQggAmpBAXQhAiAHQQZGBEBBBCEDDAELIAQgAjsBKiAELwEKIAJqQQF0IQIgB0EHRgRAQQUhAwwBCyAEIAI7ASwgBC8BDCACakEBdCECIAdBCEYEQEEGIQMMAQsgBCACOwEuIAQvAQ4gAmpBAXQhAiAHQQlGBEBBByEDDAELIAQgAjsBMCAELwEQIAJqQQF0IQIgB0EKRgRAQQghAwwBCyAEIAI7ATIgBC8BEiACakEBdCECIAdBC0YEQEEJIQMMAQsgBCACOwE0IAQvARQgAmpBAXQhAiAHQQxGBEBBCiEDDAELIAQgAjsBNiAELwEWIAJqQQF0IQIgB0ENRgRAQQshAwwBCyAEIAI7ATggBC8BGCACakEBdCECIAdBDkYEQEEMIQMMAQsgBCACOwE6IAQvARogAmpBAXQhAiAHQQ9GBEBBDSEDDAELIAQgAjsBPCAELwEcIAJqQQF0IQIgB0EQRgRAQQ4hAwwBCyAEIAI7AT4gAiALakEBdCECCwJ/AkACQCACQf//A3FBAiADdEH+/wNxRgRAIAVBCiADIANBCk8bIgxBAWoiA0kNASADIAVGDQJBACECQQAhCAJAIAUgA2siB0EITwRAIAQgA0EBdGohAyAHQRhxIgghAgNAIAP9AAEAIBj9jgEhGCADQRBqIQMgAkEIayICDQALIBggGCAY/Q0ICQoLDA0ODwABAAEAAQAB/Y4BIhggGCAY/Q0EBQYHAAEAAQABAAEAAQAB/Y4BIhggGCAY/Q0CAwABAAEAAQABAAEAAQAB/Y4B/RkAIQIgByAIRg0BCyAIQQF0IAxBAXRqIARqQQJqIQMgCCAMaiAFa0EBaiEFA0AgAy8BACACaiECIANBAmohAyAFQQFqIgUNAAsLIAJB//8DcSIDRQ0CIANBBHQQcSIIRQ0FIANBAXQMAwsgAEGBgICAeDYCACAAQQ46AAQMAwsgAyAFQRBBmO7EABDqBwALQQQhCEEACyEDIARBADYCTCAEIAg2AkggBCADNgJEQQQgDHQiDxBxIg1FDQEgDUEEayIWLQAAQQNxRSAPRXJFBEAgDUEAIA/8CwALQQEgDHQiDkEBayEUAkAgCUUNACAKQQJqIQIgBkECa0EBdkEBaiEXQQAhB0EAIQNBASEFIAohCUEAIQsCQANAAkAgCyEQIAkhBiACIQkgBSELAkAgBi8BACIGRQ0AAkAgBkEPTQRAIARBIGogBkEBdGoiAiACLwEAIhJBAWo7AQAgEkEIdCASQQh2ciICQQR2QY8ecSACQY8ecUEEdHIiAkECdkGz5gBxIAJBs+YAcUECdHIiAkEBdkHVqgFxIAJB1aoBcUEBdHIhAgJAAkACQCAGIAxLBEAgDiACQQAgBmtBD3F2IBRxIgJNDQEgDSACQQJ0aiICKAIAIgUNAiACIANBAWoiBzYCACAEKAJEIANGBH8gBEHEAGpByO7EABD5BSAEKAJIBSAICyADQQN0akECOwEAIAQgBzYCTCAHIQIMAwsgDiACQRAgBmt2IgVNDQUgBkEQdCAQciEQQQEgBnQiBkECdCERIA0gBUECdGohAgNAIAIgEDYCACACIBFqIQIgBSAGaiIFIA5JDQALDAULIAIgDkG47sQAEIwHAAsgAyECIAVBAWshAwsgBiAMayIRQf//A3EiBUEBayIGQQAgBSAGTxshBgNAIAYhBQJAAkACQCACIANLBEAgBCgCSCIIIANBA3RqIgYvAQBBAWsOAgoCAQsgAyACQejuxAAQjAcACyAGKAIEIRUMAQsgBkEAOwEAIAYgAiADayIVNgIEIAQoAkQiByACRgRAIARBxABqQfjuxAAQ+QUgBCgCSCEIIAQoAkQhBwsgCCACQQN0akECOwEAIAQgAkEBaiIGNgJMIAYgB0YEfyAEQcQAakGI78QAEPkFIAQoAkgFIAgLIAZBA3RqQQI7AQAgBCACQQJqIgc2AkwgByECCyAFQQFrIQYgEiARQQFrdkEBcSADaiAVaiEDIAUhESAFQf//A3ENAAsMAQsgBkEQQajuxAAQjAcACyADIAdPDQEgBCgCSCIIIANBA3RqIgMvAQBBAkkNAyADIBA7AQIgA0EBOwEAIAchAwsgC0EBaiEFIAlBAkEAIAkgE0cbaiECIAsgF0cNAQwDCwsgAyAHQdjuxAAQjAcACyAAQYGAgIB4NgIAIABBDjoABAJAIBYoAgAiAEF4cSIDQQRBCCAAQQNxIgAbIA9qTwRAIABBACADIA9BJ2pLGw0GIA0QogIgBCgCRCIARQ0DIAhBBGsoAgAiA0F4cSICIABBA3QiAEEEQQggA0EDcSIDG2pJDQUgA0EAIAIgAEEnaksbDQEgCBCiAgwDCwwECwwECyAAIAQpAkQ3AgAgACAUOwEYIAAgDjYCFCAAIA02AhAgACAONgIMIABBCGogBEHMAGooAgA2AgALAkAgASgCACIABEAgCkEEaygCACIBQXhxIgMgAEEBdCIAQQRBCCABQQNxIgEbakkNAyABQQAgAyAAQSdqSxsNASAKEKICCyAEQdAAaiQADwsMAgsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvZFQIPfwN+IwBBMGsiBSQAIAIoAgAiDyACKAIIIg1rIQYCQAJAIAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAqgBQQFrDgIBAgALAkACQEElEHEiAUUNACABQR1qQZ2dxwApAAA3AAAgAUEQakGQnccA/QAAAP0LAAAgAUGAnccA/QAAAP0LAABBDBBxIgJFDQAgAkElNgIIIAIgATYCBCACQSU2AgBBDBBxIgFFDQAgAUEoOgAIIAFB7IrBADYCBCABIAI2AgAgBSABrUIghkIDhDcCAAwBCwALDAILIAZBIE8EQCABKQO4ASESIA8hBCANIQYMCAsgBUEQav0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgBf0MAAAAAAAAAAAAAAAAAAAAAP0LAwACfyABKQO4ASISUARAQgAhEiANDAELIAEoAsABIggoAgAgCCkDCCITIAgoAgQiBK0iFCATIBRUG6dqIQcCQCAEQv////8PIBMgE0L/////D1obp2siA0EAIAMgBE0bIgRCICASIBJCIFobpyIDIAMgBEsbIgRBAUYEQCAFIActAAA6AAAMAQsgBEUNACAFIAcgBPwKAAALIAEgEiAErSIUfSISNwO4ASAIIBMgFHw3AwggDSAEIAZNDQAaIAIgDSAEQQFBARCkBSACKAIICyEIIAQEQCACKAIEIAhqIAUgBPwKAAALIAIgBCAIaiIGNgIIIARFBEBBACEDDAsLIAIoAgAhBAwHCyABKAKsASEHIA8hASANIQgCfwJAIAZBIE8NACAFIAcgAhCPBAJAQQACfyAFLQAAQQRGBEAgBSgCBAwBCyAFKQMAIhNCIIghFCATQv8Bg0IEUg0BIBSnC0UNAhogAigCACEBIAIoAgghCAwBCyATQoB+gyESDAYLQYDAACEJA0ACQCABIA9HIAEgCEdyRQRAIAUgByACEI8EAkACQAJ/IAUtAABBBEYEQCAFKAIEDAELIAUpAwAiE0IgiCEUIBNC/wGDQgRSDQEgFKcLDQEgAigCCCEIDAMLIBNCgH6DIRIMCQsgAigCCCEIIAIoAgAhAQsCQCABIAhHBEAgASAIayEMIAIoAgQhBAwBC0IBIRNCgMwAIRJCACEUIAFBIGoiBCABQQF0IgYgBCAGSxsiBkEASA0IIAUgAQR/IAUgATYCCCAFIAIoAgQ2AgBBAQVBAAs2AgQgBUEkakEBIAYgBRCFByAFKAIkQQFGDQggBSgCKCEEIAIgBjYCACACIAQ2AgQgBiABayEMIAYhAQsgBCAIaiEOIAkgDCAJIAxJGyIGIANrIgQEQCADIA5qQQAgBPwLAAsgBSAHIA4gBhDkAgJAIAUtAABBBEYNACAFKQMAIhJCIIgiFKchBEIAIRMCQAJAAkACQAJAIBKnQf8BcUEBaw4EAgEABAwLIAQtAAhBI0YNAgwKCyAELQAIQSNGDQFCAiETDAoLIBJCgP4Dg0KAxgBRDQBCASETDAkLAn8gEkL/AYNCA1EEQCAEKAIAIQsgBEEEaigCACIDKAIAIgoEQCALIAoRAwALIAMoAgQiAwRAIAtBBGsoAgAiCkF4cSIQQQRBCCAKQQNxIgobIANqTwRAIApBACAQIANBJ2pLGw0VQQAMAwsMEwtBAQwBC0ECCyEDA0ACQAJAAkACQAJAAkACQCADDgIAAQILIAsQogIMBAsgBEEEaygCACIDQXhxIgpBEEEUIANBA3EiAxtJDRYgA0EAIApBNE8bDRcgBBCiAgwBCyAFIAcgDiAGEOQCIAUtAABBBEYNBiAFKQMAIhJCIIgiFKchBAJAAkACQAJAIBKnQf8BcUEBaw4EAAECCRELIBJCgP4Dg0KAxgBRDQJCASETDBALIAQtAAhBI0YNAUICIRMMDwsgBC0ACEEjRw0NCyASQv8Bg0IDUQ0BC0ECIQMMAwsgBCgCACELIARBBGooAgAiAygCACIKBEAgCyAKEQMACyADKAIEIgMNAQtBASEDDAELIAtBBGsoAgAiCkF4cSIQQQRBCCAKQQNxIgobIANqSQ0RIApFIBAgA0Enak1yRQRADBMLQQAhAwwACwALIAIgCDYCCAwBCyAFKAIEIgQgBksEQEG0m8cAQTZB7JvHABDrBwALIAIgBCAIaiIINgIIIARFDQBBfyAJQQF0IAlBAEgbIAkgBCAGRhsgCSAJIAxNGyEJIAYgBGshAwwBCwsgCCANawshAyAHLQC0AUEBRw0JIAIoAggiASANSQ0BIAdBoAFqIAIoAgQgDWogASANaxDeASAHKAKwASAHKAKoAUYNCSAFEJMHCyAFLQAAIQMMBAsgDSABIAFB7KvHABDqBwALQgMhEwsgAiAINgIIIBJCgH6DIRILIAUgFD4CBCAFIBOnIgM6AAAgBSASpyIBQRh2OgADIAUgAUEIdjsAAQsgA0H/AXFBBEYEQCAFKAIEIQMMBAsgBSkDACEUDAELIAEoAsABIQlBgMAAIQsgBUEQaiEQQQAhCANAIAQgD0cgBCAGR3JFBEAgEP0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgBf0MAAAAAAAAAAAAAAAAAAAAAP0LAwACfyASUARAQQAhA0IAIRIgDwwBCyAJKQMIIhMgCSgCBCIErSIUIBMgFFQbpyIHIAkoAgBqIQYCQCAEQv////8PIBMgE0L/////D1obp2siA0EAIAMgBE0bIgNCICASIBJCIFobpyIOIAMgDkkbIgNBAUYEQCAFIAYtAAA6AAAMAQsgA0UNACAFIAYgA/wKAAALIAEgEiADrSIUfSISNwO4ASAJIBMgFHw3AwggDyAEIAdGDQAaIAIgDyADQQFBARCkBSACKAIICyEEIAMEQCACKAIEIARqIAUgA/wKAAALIAIgAyAEaiIGNgIIIANFDQMgAigCACEECwJAIAQgBkcEQCACKAIEIQMMAQtCgcwAIRQgBEEgaiIHIARBAXQiAyADIAdJGyIHQQBIDQIgBSAEBH8gBSAENgIIIAUgAigCBDYCAEEBBUEACzYCBCAFQSRqQQEgByAFEIUHIAUoAiRBAUYNAiAFKAIoIQMgAiAHNgIAIAIgAzYCBCAHIQQLIBJQBEAgAiAGNgIIDAMLIAMgBmohDiAJAn4gCyAEIAZrIgcgByALSxsiB60gElgEQCAJKAIEIgpC/////w8gCSkDCCIUIBRC/////w9aG6drIgNBACADIApNGyIDIAcgAyAHSRsiAwRAIA4gCSgCACAUIAqtIhMgEyAUVhunaiAD/AoAAAsgAyAMIAMgDEsbIQwgFCADrSITfAwBCyAJKAIEIgpC/////w8gCSkDCCIUIBRC/////w9aG6drIgNBACADIApNGyIDIBKnIhEgAyARSRsiAwRAIA4gCSgCACAUIAqtIhMgEyAUVhunaiAD/AoAAAsgAyAMIAMgDEsbIQwgFCADrSITfAs3AwggASASIBN9IhI3A7gBIAIgAyAGaiIGNgIIIANFDQJBf0F/IAsgCEEBakEAIAMgB0kbIghBAUobIAsgByAMRxsiC0EBdCALQQBIGyALIAcgC08bIAsgAyAHRhshCyAMIANrIQwMAAsACyAAIBQ3AgRBAQwCCyAGIA1rIQMLIAAgA603AwhBAAs2AgAgBUEwaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL6CcCMH8GfiMAQbAEayIEJAACf0EAIAMoAgwiC0UNABogAykDECADKQMYQbjTxwBBARCVBCE0IAMoAgQiBiA0p3EhBSA0QhmIQv8Ag0KBgoSIkKDAgAF+ITYgAygCACEHA0ACQCAFIAdqKQAAIjUgNoUiNEJ/hSA0QoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIjRQRQRAA0AgByA0eqdBA3YgBWogBnFBbGxqIghBDGsoAgBBAUYEQCAIQRBrKAIALQAAQfgARg0DCyA0QgF9IDSDIjRQRQ0ACwtBACA1IDVCAYaDQoCBgoSIkKDAgH+DUEUNAhogBSAKQQhqIgpqIAZxIQUMAQsLIAhBFGsLIQUgBEEANgKYAyAEQQE2AowDIARBzNPHADYCiAMgBEIENwKQAyAEQYgDahCVByEGAkACQAJAIAVFBEAgAEGAgICAeDYC3AQgACAGNgIAIAMQvwQMAQsgBiAGKAIAKAIAEQMAIAUtABAhFyAFKAIMIRgCf0EAIAtFDQAaIAMpAxAgAykDGEHU08cAQQEQlQQhNCADKAIEIgYgNKdxIQUgNEIZiEL/AINCgYKEiJCgwIABfiE2IAMoAgAhB0EAIQoDQAJAIAUgB2opAAAiNSA2hSI0Qn+FIDRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiNFBFBEADQCAHIDR6p0EDdiAFaiAGcUFsbGoiCEEMaygCAEEBRgRAIAhBEGsoAgAtAABB+QBGDQMLIDRCAX0gNIMiNFBFDQALC0EAIDUgNUIBhoNCgIGChIiQoMCAf4NQRQ0CGiAFIApBCGoiCmogBnEhBQwBCwsgCEEUawshBSAEQQA2ApgDIARBATYCjAMgBEHo08cANgKIAyAEQgQ3ApADIARBiANqEJUHIQYgBUUEQCAAQYCAgIB4NgLcBCAAIAY2AgAgAxC/BAwBCyAGIAYoAgAoAgARAwAgBS0AECEZIAUoAgwhGiADQfDTxwBBARC5BSEFIARBADYCmAMgBEEBNgKMAyAEQYTUxwA2AogDIARCBDcCkAMgBEGIA2oQlQchBiAFRQRAIABBgICAgHg2AtwEIAAgBjYCACADEL8EDAELIAYgBigCACgCABEDACAFLQAQIRsgBSgCDCEcIANBjNTHAEEHELkFIQUgBEEANgKYAyAEQQE2AowDIARBrNTHADYCiAMgBEIENwKQAyAEQYgDahCVByEGIAVFBEAgAEGAgICAeDYC3AQgACAGNgIAIAMQvwQMAQsgBiAGKAIAKAIAEQMAIAUtABAhHSAFKAIMIR4gA0G01McAQQcQuQUhBSAEQQA2ApgDIARBATYCjAMgBEHU1McANgKIAyAEQgQ3ApADIARBiANqEJUHIQYgBUUEQCAAQYCAgIB4NgLcBCAAIAY2AgAgAxC/BAwBCyAGIAYoAgAoAgARAwAgBS0AECEfIAUoAgwhICADQdzUxwBBBxC5BSEFIARBADYCmAMgBEEBNgKMAyAEQfzUxwA2AogDIARCBDcCkAMgBEGIA2oQlQchBiAFRQRAIABBgICAgHg2AtwEIAAgBjYCACADEL8EDAELIAYgBigCACgCABEDACAFLQAQISEgBSgCDCEiIANBhNXHAEEFELkFIQUgBEEANgKYAyAEQQE2AowDIARBoNXHADYCiAMgBEIENwKQAyAEQYgDahCVByEGIAVFBEAgAEGAgICAeDYC3AQgACAGNgIAIAMQvwQMAQsgBiAGKAIAKAIAEQMAIAUtABAhIyAFKAIMISQgA0Go1ccAQQUQuQUhBSAEQQA2ApgDIARBATYCjAMgBEHE1ccANgKIAyAEQgQ3ApADIARBiANqEJUHIQYgBUUEQCAAQYCAgIB4NgLcBCAAIAY2AgAgAxC/BAwBCyAGIAYoAgAoAgARAwAgBS0AECElIAUoAgwhJiADQczVxwBBBRC5BSEFIARBADYCmAMgBEEBNgKMAyAEQejVxwA2AogDIARCBDcCkAMgBEGIA2oQlQchBiAFRQRAIABBgICAgHg2AtwEIAAgBjYCACADEL8EDAELIAYgBigCACgCABEDACAFLQAQIScgBSgCDCEoIANB8NXHAEEFELkFIQUgBEEANgKYAyAEQQE2AowDIARBjNbHADYCiAMgBEIENwKQAyAEQYgDahCVByEGIAVFBEAgAEGAgICAeDYC3AQgACAGNgIAIAMQvwQMAQsgBiAGKAIAKAIAEQMAIAUtABAhKSAFKAIMISogA0GU1scAQQcQuQUhBSAEQQA2ApgDIARBATYCjAMgBEG01scANgKIAyAEQgQ3ApADIARBiANqEJUHIQYgBUUEQCAAQYCAgIB4NgLcBCAAIAY2AgAgAxC/BAwBCyAGIAYoAgAoAgARAwAgBS0AECErIAUoAgwhLCADQbzWxwBBBhC5BSEFIARBADYCmAMgBEEBNgKMAyAEQdzWxwA2AogDIARCBDcCkAMgBEGIA2oQlQchBiAFRQRAIABBgICAgHg2AtwEIAAgBjYCACADEL8EDAELIAYgBigCACgCABEDACAFLQAQIS0gBSgCDCEuIANB5NbHAEEGELkFIQUgBEEANgKYAyAEQQE2AowDIARBhNfHADYCiAMgBEIENwKQAyAEQYgDahCVByEGIAVFBEAgAEGAgICAeDYC3AQgACAGNgIAIAMQvwQMAQsgBiAGKAIAKAIAEQMAIAUtABAhLyAFKAIMITAgA0GM18cAQQYQuQUhBSAEQQA2ApgDIARBATYCjAMgBEGs18cANgKIAyAEQgQ3ApADIARBiANqEJUHIQYgBUUEQCAAQYCAgIB4NgLcBCAAIAY2AgAgAxC/BAwBCyAGIAYoAgAoAgARAwAgBEEEaq1CgICAgPABhCE0IAUtABAhMSAFKAIMITJBACEGA0ACQCAEIAY2AgQgBEEBNgKMAyAEQYjQxwA2AogDIARCATcClAMgBCA0NwMYIAQgBEEYajYCkAMgBEEIaiAEQYgDahCxBiADIAQoAgwiCyAEKAIQELkFIAQoAgghBUUNACAFBEAgCyAFQQEQogcLIAQoAgRBAWohBgwBCwsgBQRAIAsgBUEBEKIHC0EBIQZBCCEKQQghE0EIIRICQAJAAkACQAJAAkAgBCgCBCIFDhkFAQEBAQEBAQEEAQEBAQEBAQEBAQEBAQECAAsgBUEtRg0CCyAEQQE2AowDIARB3NfHADYCiAMgBEIBNwKUAyAEIDQ3AwggBCAEQQhqNgKQAyAEQSBqIgEgBEGIA2oQsQYgARCQByEBIABBgICAgHg2AtwEIAAgATYCACADEL8EDAQLQQEhDkECIQYMAQtBASEOQQMhBkEBIRELIARBiANqIQUjAEGAAWsiByQAIAdB5ABqrUKAgICAEIQhNQJAAkAgAygCDARAIAMoAgAhDyADKAIEIQ0gAykDGCE3IAMpAxAhOCAGQQJ0QYiSyQBqKAIAIRVBACEIA0AgByA1NwNYIAcgFSAIIAhB/wFxQQNuIglBA2xrQf8BcWwgCWo2AmQgB0IBNwJ0IAdBATYCbCAHQYjQxwA2AmggByAHQdgAajYCcCAHQcwAaiAHQegAahDsAyANIDggNyAHKAJQIhIgBygCVCIUEJUEIjSncSEJIDRCGYhC/wCDQoGChIiQoMCAAX4hOUEAIRADQAJAIAkgD2opAAAiNiA5hSI0Qn+FIDRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiNFBFBEADQCAPIDR6p0EDdiAJaiANcUFsbGoiDEEMaygCACAURgRAIBIgDEEQaygCACAUENsHRQ0DCyA0QgF9IDSDIjRQRQ0ACwsgNiA2QgGGg0KAgYKEiJCgwIB/g1BFDQQgCSAQQQhqIhBqIA1xIQkMAQsLIAxBBGstAAAhFCAMQQhrKAIAIQwgBygCTCIJBEAgEkEEaygCACIQQXhxIhZBBEEIIBBBA3EiEBsgCWpJDQcgEEEAIBYgCUEnaksbDQggEhCiAgsgB0EEaiIJIAhBA3RqIhIgFDoABCASIAw2AgAgCEEBaiIIQQlHDQALIAUgCUHIAPwKAAAgB0GAAWokAAwCCyAHIDU3A1ggB0EANgJkIAdCATcCdCAHQQE2AmwgB0GI0McANgJoIAcgB0HYAGo2AnAgB0HMAGogB0HoAGoQ7AMLQfTXxwAQ3QkACyAELQCMAyESIAQoAogDIRQgBEEvaiAEQY0DaiIQQcMA/AoAAAJAIA4EQCMAQbABayIHJAAgB0GUAWqtQoCAgIAQhCE1AkACQCADKAIMBEAgAygCACEMIAMoAgQhCSADKQMYITcgAykDECE4IAZBAnRBlJLJAGooAgAhFUEAIQgDQCAHIDU3A4gBIAcgCEH/AXFBA24iCyAVIAggC0EDbGtB/wFxbGpBA2o2ApQBIAdCATcCpAEgB0EBNgKcASAHQYjQxwA2ApgBIAcgB0GIAWo2AqABIAdB/ABqIAdBmAFqEOwDIAkgOCA3IAcoAoABIg4gBygChAEiExCVBCI0p3EhCyA0QhmIQv8Ag0KBgoSIkKDAgAF+ITlBACEPA0ACQCALIAxqKQAAIjYgOYUiNEJ/hSA0QoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIjRQRQRAA0AgDCA0eqdBA3YgC2ogCXFBbGxqIg1BDGsoAgAgE0YEQCAOIA1BEGsoAgAgExDbB0UNAwsgNEIBfSA0gyI0UEUNAAsLIDYgNkIBhoNCgIGChIiQoMCAf4NQRQ0EIAsgD0EIaiIPaiAJcSELDAELCyANQQRrLQAAIRMgDUEIaygCACENIAcoAnwiCwRAIA5BBGsoAgAiD0F4cSIWQQRBCCAPQQNxIg8bIAtqSQ0JIA9BACAWIAtBJ2pLGw0KIA4QogILIAdBBGoiCyAIQQN0aiIOIBM6AAQgDiANNgIAIAhBAWoiCEEPRw0ACyAFIAtB+AD8CgAAIAdBsAFqJAAMAgsgByA1NwOIASAHQQM2ApQBIAdCATcCpAEgB0EBNgKcASAHQYjQxwA2ApgBIAcgB0GIAWo2AqABIAdB/ABqIAdBmAFqEOwDC0GE2McAEN0JAAsgBC0AjAMhEyAEKAKIAyELIARB8gBqIBBB8wD8CgAAIBENASAGIQUMAgsgEQ0AIAYhBQwBCyAEQYgDaiEPIwBB4AFrIgUkACAFQcQBaq1CgICAgBCEITUCQAJAIAMoAgwEQCADKAIAIQ4gAygCBCEIIAMpAxghNyADKQMQITggBkECdEGgkskAaigCACEQQQAhBwNAIAUgNTcDuAEgBSAHQf8BcUEDbiIKIBAgByAKQQNsa0H/AXFsakEIajYCxAEgBUIBNwLUASAFQQE2AswBIAVBiNDHADYCyAEgBSAFQbgBajYC0AEgBUGsAWogBUHIAWoQ7AMgCCA4IDcgBSgCsAEiCSAFKAK0ASINEJUEIjSncSEKIDRCGYhC/wCDQoGChIiQoMCAAX4hOUEAIQwDQAJAIAogDmopAAAiNiA5hSI0Qn+FIDRCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiNFBFBEADQCAOIDR6p0EDdiAKaiAIcUFsbGoiEUEMaygCACANRgRAIAkgEUEQaygCACANENsHRQ0DCyA0QgF9IDSDIjRQRQ0ACwsgNiA2QgGGg0KAgYKEiJCgwIB/g1BFDQQgCiAMQQhqIgxqIAhxIQoMAQsLIBFBBGstAAAhDSARQQhrKAIAIREgBSgCrAEiCgRAIAlBBGsoAgAiDEF4cSIVQQRBCCAMQQNxIgwbIApqSQ0HIAxBACAVIApBJ2pLGw0IIAkQogILIAVBBGoiCiAHQQN0aiIJIA06AAQgCSARNgIAIAdBAWoiB0EVRw0ACyAPIApBqAH8CgAAIAVB4AFqJAAMAgsgBSA1NwO4ASAFQQg2AsQBIAVCATcC1AEgBUEBNgLMASAFQYjQxwA2AsgBIAUgBUG4AWo2AtABIAVBrAFqIAVByAFqEOwDC0Hk18cAEN0JAAsgBC0AjAMhCiAEKAKIAyEzIARB5QFqIARBjQNqQaMB/AoAACAGIQULIAAgCjoARCAAIDM2AkAgACApOgA8IAAgKjYCOCAAICc6ADQgACAoNgIwIAAgJToALCAAICY2AiggACAjOgAkIAAgJDYCICAAIAP9AAMA/QsDACAAQRBqIANBEGr9AAMA/QsDACAAQcUAaiAEQeUBakGjAfwKAAAgACATOgDsASAAIAs2AugBIABB7QFqIARB8gBqQfMA/AoAACAAIBI6AOQCIAAgFDYC4AIgAEHlAmogBEEvakHDAPwKAAAgAEIENwPgBCAAQgA3A9gEIABCgICAgMAANwPQBCAAQgQ3A8gEIABCADcDwAQgAEKAgICAwAA3A7gEIABCBDcDsAQgAEIANwOoBCAAQoCAgIDAADcDoAQgAEIENwOYBCAAQgA3A5AEIABCgICAgMAANwOIBCAAIAU2AoQEIABBADYCgAQgACACNgL8AyAAIAE2AvgDIAAgKzoA9AMgACAsNgLwAyAAIDE6AOwDIAAgMjYC6AMgACAvOgDkAyAAIDA2AuADIAAgLToA3AMgACAuNgLYAyAAICE6ANQDIAAgIjYC0AMgACAfOgDMAyAAICA2AsgDIAAgHToAxAMgACAeNgLAAyAAIBs6ALwDIAAgHDYCuAMgACAZOgC0AyAAIBo2ArADIAAgFzoArAMgACAYNgKoAwsgBEGwBGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC5wVBA5/An0BfAJ+IwBBIGsiAiQAAkACQAJAAkACQAJ/AkACQCAAAn8CQAJAAkACQAJAQRUgASgCACIDQYCAgIB4cyADQQBOG0EUaw4CAAEDCwJ9AkACQAJAAn0CQAJAIAEoAgwiAwRAIAJBBGogASgCCCIBEKAEIAIoAgghBiACKAIEIgdBgICAgHhGBEAgBiEBDBILIAIoAhQhCiACKAIQIQkgA0EBRg0EIAIoAhghCyACKAIMIQwCQAJAAkACQAJAAkACQAJAAkBBFSABKAIQIgVBgICAgHhzIAVBAE4bQQFrDgoLAAECAwQFBgcICgsgAS8BFLMMCwsgASgCFLMMCgsgASkDGLUMCQsgASwAFLIMCAsgAS4BFLIMBwsgASgCFLIMBgsgASkDGLQMBQsgASoCFAwECyABKwMYIhK2QwAAgD9DAACAvyASvUIAWRuYDAMLQQBB4P7AAEGA/cAAENsGIQEMEAsgAUEQaiACQR9qQdjnwAAQlQghAQwOCyABLQAUswshECADQQJGDQUCQAJAAkACQAJAAkACQAJAAkBBFSABKAIgIgVBgICAgHhzIAVBAE4bQQFrDgoLAAECAwQFBgcICgsgAS8BJLMMCwsgASgCJLMMCgsgASkDKLUMCQsgASwAJLIMCAsgAS4BJLIMBwsgASgCJLIMBgsgASkDKLQMBQsgASoCJAwECyABKwMoIhK2QwAAgD9DAACAvyASvUIAWRuYDAMLQQFB4P7AAEGA/cAAENsGIQEMCwsgAUEgaiACQR9qQdjnwAAQlQghAQwKCyABLQAkswshEQJAIANBA0cEQCACQQRqIAFBMGoQnwUgAigCBEUNASACKAIIIQEMCgtBA0Hg/sAAQYD9wAAQ2wYhAQwJCyADQQRGBEAgAigCCCEDIAIoAgwMBQsgAkEENgIEIANB/P///wBqQf////8AcUEEaiACQQRqQeiVwQAQ2wYhASAHBEAgBiAHQQEQogcLIAlFDQkgCiAJQQEQogcMCQsgASgCCCIDRQ0FIANBBXQhDiABKAIEIQ9BACEDQYCAgIB4IQcDQAJAAkACQAJAAkACQAJAAkBBFSADIA9qIgEoAgAiBEGAgICAeHMgBEEAThtBAWsODwEAAAIAAAAAAAAAAwQFBgALIAEgAkEfakHU5MAAEJUIIQQgAkEBOgAEIAIgBDYCCAwGCyACQQA6AAQgAkEEIAFBBGotAAAiBCAEQQRPGzoABQwFCyACQQA6AAQgAkIEIAFBCGopAwAiFCAUQgRaGzwABQwECyABQQhqKAIAIQQCfwJAAkACQAJAIAFBDGooAgBBBGsOAgEAAwsgBEGQ/cAAQQUQ2wcNAUEADAMLQQEgBCgAAEHt0rmbB0YNAhogBCgAAEHtwuGbB0cNAUECDAILIARBnf3AAEEFENsHDQBBAwwBC0EECyEEIAJBADoABCACIAQ6AAUMAwsgAUEEaigCACEEAn8CQAJAAkACQCABQQhqKAIAQQRrDgIBAAMLIARBkP3AAEEFENsHDQFBAAwDC0EBIAQoAABB7dK5mwdGDQIaIAQoAABB7cLhmwdHDQFBAgwCCyAEQZ39wABBBRDbBw0AQQMMAQtBBAshBCACQQA6AAQgAiAEOgAFDAILIAJBBGogAUEIaigCACABQQxqKAIAENkFDAELIAJBBGogAUEEaigCACABQQhqKAIAENkFCyACLQAEQQFGBEAgAigCCCEBQQEMCAsgAUEQaiEEAkACQAJAAkACQAJAAkACQCACLQAFDgQAAQIDBwsgB0GAgICAeEcEQEGQ/cAAQQUQnwchAUEBDA8LIAJBBGogBBCgBCACKAIIIQYgAigCBCIHQYCAgIB4RgRAIAYhAQwRCyACKAIYIQsgAigCFCEKIAIoAhAhCSACKAIMIQwMBgsgBQ0CAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAQoAgAiBUGAgICAeHMgBUEAThtBAWsOCgABAgMEBQYHCAkKCyABQRRqLQAAsyEQQQEhBQwPCyABQRRqLwEAsyEQQQEhBQwOCyABQRRqKAIAsyEQQQEhBQwNCyABQRhqKQMAtSEQQQEhBQwMCyABQRRqLAAAsiEQQQEhBQwLCyABQRRqLgEAsiEQQQEhBQwKCyABQRRqKAIAsiEQQQEhBQwJCyABQRhqKQMAtCEQQQEhBQwICyABQRRqKgIAIRBBASEFDAcLIAFBGGorAwAiErZDAACAP0MAAIC/IBK9QgBZG5ghEEEBIQUMBgsgBCACQR9qQdjnwAAQlQghAUEBDA0LIAgNAwJAAkACQAJAAkACQAJAAkACQAJAAkBBFSAEKAIAIghBgICAgHhzIAhBAE4bQQFrDgoAAQIDBAUGBwgJCgsgAUEUai0AALMhEUEBIQgMDgsgAUEUai8BALMhEUEBIQgMDQsgAUEUaigCALMhEUEBIQgMDAsgAUEYaikDALUhEUEBIQgMCwsgAUEUaiwAALIhEUEBIQgMCgsgAUEUai4BALIhEUEBIQgMCQsgAUEUaigCALIhEUEBIQgMCAsgAUEYaikDALQhEUEBIQgMBwsgAUEUaioCACERQQEhCAwGCyABQRhqKwMAIhK2QwAAgD9DAACAvyASvUIAWRuYIRFBASEIDAULIAQgAkEfakHY58AAEJUIIQFBAQwMCyANDQEgAkEEaiAEEJ8FIAIoAgghAUEBIAIoAgQNCxogAa0gAjUCDEIghoQhE0EBIQ0MAwtBlf3AAEEEEJ8HIQFBAQwKC0Gd/cAAQQUQnwchAUEBDAkLQZn9wABBBBCfByEBQQEMCAsgA0EgaiIDIA5HDQALDAILQQJB4P7AAEGA/cAAENsGIQEMBgsgASACQR9qQcTiwAAQlQghAQwGCyAHQYCAgIB4Rg0CIAIgCzYCGCACIAo2AhQgAiAJNgIQIAIgDDYCDCACIAY2AgggAiAHNgIEIAVFBEBBlf3AAEEEEJwHIQEMAgsgCEUEQEGZ/cAAQQQQnAchAQwCCyANRQRAQZ39wABBBRCcByEBDAILIBOnIQMgE0IgiKcLNgIkIAAgAzYCICAAIBE4AhwgACAQOAIYIAAgCzYCFCAAIAo2AhAgACAJNgIMIAAgDDYCCCAAIAY2AgQgACAHNgIADAULIAJBBGoQ5gVBAAwBC0GAgICAeCEHQZD9wABBBRCcByEBQQELRSAHQYCAgIB4RnINAQJAIAcEQCAGQQRrKAIAIgNBeHEiBUEEQQggA0EDcSIDGyAHakkNBSADQQAgBSAHQSdqSxsNBiAGEKICCyAJRQ0CIApBBGsoAgAiBkF4cSIDQQRBCCAGQQNxIgYbIAlqSQ0EIAZBACADIAlBJ2pLGw0AIAoQogIMAgsMBAsgBwRAIAZBBGsoAgAiA0F4cSIFQQRBCCADQQNxIgMbIAdqSQ0DIANBACAFIAdBJ2pLGw0EIAYQogILIAlFDQAgCkEEaygCACIGQXhxIgNBBEEIIAZBA3EiBhsgCWpJDQIgBkEAIAMgCUEnaksbDQMgChCiAgsgAEGBgICAeDYCACAAIAE2AgQLIAJBIGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6wUAwZ+EH8BeyMAQSBrIhAkAAJAAkACQAJAAkACQAJAAkACQCAAAn8CQAJAAkAgACgCDCISQQFqIggEQCAAKAIEIg8gD0EBaiINQQN2IglBB2wiFCAPQQhJGyIKQQF2IAhJBEAgCkEBaiIJIAggCCAJSRsiCEEPSQ0CIAhB/////wFNBEBBfyAIQQN0QQduQQFrZ3YiCEH+////AUsNCCAIQQFqIQgMBwsMDgtBACANRQ0EGiAAKAIAIQBBACEIIAkgDUEHcUEAR2oiCkEBTQ0CIAAhCCAKQf7///8DcSILIQkDQCAIIAj9AAMAIhj9TUEH/c0B/QwBAQEBAQEBAQEBAQEBAQEB/U4gGP0Mf39/f39/f39/f39/f39/f/1Q/c4B/QsDACAIQRBqIQggCUECayIJDQALIAogC0YNAyALQQN0IQggCkEBcSEKDAILDAwLQQQgCEEIcUEIaiAIQQRJGyEIDAMLIAAgCGohCANAIAggCCkDACICQn+FQgeIQoGChIiQoMCAAYMgAkL//v379+/fv/8AhHw3AwAgCEEIaiEIIApBAWsiCg0ACwsCQCANQQhPBEAgACANaiAAKQAANwAADAELIA1FDQAgAEEIaiAAIA38CgAACyABKQMAIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQhBSAAQQhqIQsgAEEIayEVIAJCf4UhBiABKQMIIQRBASEBIAAhCUEAIQgDQCAIIQogASEIAkAgACAKaiITLQAAQYABRw0AIBUgCkEDdGshFiAAIApBf3NBA3RqIRcCQANAIA8gBCAWNQIAhSIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEQtKBqpur+oLXp39+IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIQgA0LYotHvwqnlvy1+hSICQjiGIAJCgP4Dg0IohoQgAkKAgPwHg0IYhiACQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEIAZ+IgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgAiAFfoUgAomnIhFxIgwhASAAIAxqKQAAQoCBgoSIkKDAgH+DIgJQBEBBCCEOA0AgASAOaiEBIA5BCGohDiAAIAEgD3EiAWopAABCgIGChIiQoMCAf4MiAlANAAsLIAAgAnqnQQN2IAFqIA9xIgFqLAAAQQBOBEAgACkDAEKAgYKEiJCgwIB/g3qnQQN2IQELIAEgDGsgCiAMa3MgD3FBCE8EQCAAIAFqIgwtAAAgDCARQRl2Igw6AAAgCyABQQhrIA9xaiAMOgAAQf8BRg0CIAAgAUEDdGshDEF4IQEDQCABIAlqIg4oAAAhESAOIAEgDGoiDigAADYAACAOIBE2AAAgAUEEaiIBDQALDAELCyATIBFBGXYiAToAACALIA8gCkEIa3FqIAE6AAAMAQsgE0H/AToAACALIA8gCkEIa3FqQf8BOgAAIAAgAUF/c0EDdGogFykAADcAAAsgCUEIayEJIAggCCANSSIKaiEBIAoNAAsgDyAUIA9BCEkbCyASazYCCAwFCyAIQQhqIgkgCEEDdCINaiIKIAlJIApB+P///wdLcg0AIAoQcSIKRQ0BIAogDWohCyAJBEAgC0H/ASAJ/AsACyAIQQFrIgwgCEEDdkEHbCAMQQhJGyETIAAoAgAhDSASDQJBACESDAMLIBBBADYCGCAQQQE2AgwgEEHEtcQANgIIIBBCBDcCECAQQQhqQZi1xAAQjQgLAAsgC0EIaiERIAEpAwAiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhCEGIA1BCGshFCACQn+FIQcgDSkDAEJ/hUKAgYKEiJCgwIB/gyEEIAEpAwghBUEAIQggEiEBIA0hCgNAIARQBEADQCAIQQhqIQggCkEIaiIKKQMAQoCBgoSIkKDAgH+DIgJCgIGChIiQoMCAf1ENAAsgAkKAgYKEiJCgwIB/hSEECyALIAwgBSAUIAR6p0EDdiAIaiIVQQN0azUCAIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhELSgaqbq/qC16d/fiICQjiGIAJCgP4Dg0IohoQgAkKAgPwHg0IYhiACQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEIANC2KLR78Kp5b8tfoUiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhCAHfiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAIgBn6FIAKJpyIWcSIJaikAAEKAgYKEiJCgwIB/gyICUARAQQghDgNAIAkgDmohCSAOQQhqIQ4gCyAJIAxxIglqKQAAQoCBgoSIkKDAgH+DIgJQDQALCyAEQgF9IASDIQQgCyACeqdBA3YgCWogDHEiCWosAABBAE4EQCALKQMAQoCBgoSIkKDAgH+DeqdBA3YhCQsgCSALaiAWQRl2Ig46AAAgESAJQQhrIAxxaiAOOgAAIAsgCUF/c0EDdGogDSAVQX9zQQN0aikAADcDACABQQFrIgENAAsLIAAgDDYCBCAAIAs2AgAgACATIBJrNgIIIA9FDQAgDyAPQQN0QQ9qQXhxIgFqQQlqIgBFDQAgDSABayIBQQRrKAIAIghBeHEiCUEEQQggCEEDcSIIGyAAakkNASAIQQAgCSAAQSdqSxsNAiABEKICCyAQQSBqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgEEEANgIYIBBBATYCDCAQQcS1xAA2AgggEEIENwIQIBBBCGpBmLXEABCNCAALvw4BB38CQAJAIAAoAuACIgEEQCAAKALkAiIEQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKALwAiIBKAL4BiICQQRrKAIAIgRBeHFBhIABQYiAASAEQQNxIgMbSQ0AIANBACAEQaiAAU8bDQEgAhCiAiABKALgBiIEBEAgASgC5AYiAkEEaygCACIDQXhxIgYgBEEBdCIEQQRBCCADQQNxIgMbakkNASADQQAgBiAEQSdqSxsNAiACEKICCyABKAL8BiICQQRrKAIAIgRBeHFBhBBBiBAgBEEDcSIDG0kNACADQQAgBEGoEE8bDQEgAhCiAiABKALsBiIEBEAgASgC8AYiAkEEaygCACIDQXhxIgYgBEEBdCIEQQRBCCADQQNxIgMbakkNASADQQAgBiAEQSdqSxsNAiACEKICCyABQQRrKAIAIgRBeHFBrAdBsAcgBEEDcSICG0kNACACQQAgBEHQB08bDQEgARCiAgJAIAAoAghBAkYNACAAKALIASIBQYKAgIB4SCABRXJFBEAgACgCzAEiBEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpJDQIgAkEAIAMgAUEnaksbDQMgBBCiAgsgACgC1AEiAUGCgICAeEggAUVyRQRAIAAoAtgBIgRBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0CIAJBACADIAFBJ2pLGw0DIAQQogILIAAoAuABIgFBgoCAgHhIIAFFckUEQCAAKALkASIEQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNAiACQQAgAyABQSdqSxsNAyAEEKICCyAAKALsASIBQYKAgIB4SCABRXJFBEAgACgC8AEiBEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpJDQIgAkEAIAMgAUEnaksbDQMgBBCiAgsgACgC+AEiAUGCgICAeEggAUVyRQRAIAAoAvwBIgRBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0CIAJBACADIAFBJ2pLGw0DIAQQogILIAAoAoQCIgFBgoCAgHhIIAFFckUEQCAAKAKIAiIEQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNAiACQQAgAyABQSdqSxsNAyAEEKICCyAAKAKoASEEIAAoAqwBIgIEQCAEIQEDQCABKAIAIgMEQCABQQRqKAIAIgZBBGsoAgAiBUF4cSIHQQRBCCAFQQNxIgUbIANqSQ0EIAVBACAHIANBJ2pLGw0FIAYQogILIAFBDGooAgAiAwRAIAFBEGooAgAiBkEEaygCACIFQXhxIgdBBEEIIAVBA3EiBRsgA2pJDQQgBUEAIAcgA0EnaksbDQUgBhCiAgsgAUEYaiEBIAJBAWsiAg0ACwsgACgCpAEiAQRAIARBBGsoAgAiAkF4cSIDIAFBGGwiAUEEQQggAkEDcSICG2pJDQIgAkEAIAMgAUEnaksbDQMgBBCiAgsgACgCtAEhBCAAKAK4ASICBEAgBEEUaiEBA0AgAUEEaygCACIDBEAgASgCACIGQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyADakkNBCAFQQAgByADQSdqSxsNBSAGEKICCyABQRBrKAIAIgMEQCABQQxrKAIAIgZBBGsoAgAiBUF4cSIHQQRBCCAFQQNxIgUbIANqSQ0EIAVBACAHIANBJ2pLGw0FIAYQogILIAFBHGohASACQQFrIgINAAsLIAAoArABIgEEQCAEQQRrKAIAIgJBeHEiAyABQRxsIgFBBEEIIAJBA3EiAhtqSQ0CIAJBACADIAFBJ2pLGw0DIAQQogILIAAoAsABIQQgACgCxAEiAgRAIAQhAQNAIAFBEGooAgAiAwRAIAFBFGooAgAiBkEEaygCACIFQXhxIgdBBEEIIAVBA3EiBRsgA2pJDQQgBUEAIAcgA0EnaksbDQUgBhCiAgsgAUEcaigCACIDBEAgAUEgaigCACIGQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyADakkNBCAFQQAgByADQSdqSxsNBSAGEKICCyABQShqKAIAIgMEQCABQSxqKAIAIgZBBGsoAgAiBUF4cSIHQQRBCCAFQQNxIgUbIANqSQ0EIAVBACAHIANBJ2pLGw0FIAYQogILIAFBBGooAgAiAwRAIAFBCGooAgAiBkEEaygCACIFQXhxIgdBBEEIIAVBA3EiBRsgA2pJDQQgBUEAIAcgA0EnaksbDQUgBhCiAgsgAUE4aiEBIAJBAWsiAg0ACwsgACgCvAEiAEUNACAEQQRrKAIAIgFBeHEiAiAAQThsIgBBBEEIIAFBA3EiARtqSQ0BIAFBACACIABBJ2pLGw0CIAQQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALkhMDDn8BewF+IwBBEGsiDCQAAkACQAJAAkACQCAAKAIIIglFBEBBACEJQQEhCEEBIQoMAQsgACgCBCEEIAkQcSIKRQ0CIAQhCANAQQAhBQJAAn8gCEEUai8BACICQf//AXFFBEAgAkEQdAwBCyACQf8HcSEBIAJBgIACcSEGIAJBgPgBcSICQYD4AUYEQCAGQRB0IgJBgICA/AdyIAFFDQEaIAIgAUENdHJBgICA/gdyDAELIAZBEHQiBiACQQ10QYCAgPwAcSABQQ10ckGAgIDAA2pyIAINABogBkGAgIDYA3IgAWdBEGsiAkEXdGsgASACQf//A3FBCGp0Qf///wNxcgu+QwAAAABeRQ0AIAhBHGovAQAhBUEAIQICf0EAIAhBHmovAQAiAUH//wFxIgZBgPgBSw0AGkEAIAVB//8BcSIHQYD4AUsNABogAcFBAE4EQCABIAVLIAXBQQBODQEaIAEgB3JBAEcMAQsgBcFBAEggASAFSXELIQcgASAFIAcbIAUgBkGB+AFJGyEBAkAgCEEgai8BACIGQf//AXEiB0GA+AFLDQAgAUH//wFxIgVBgPgBSw0AIAbBQQBOBEAgAcFBAE4EQCAGIAFB//8DcUshAgwCCyAFIAZyQQBHIQIMAQsgAcFBAEggBiABQf//A3FJcSECC0EAIQUCfyAGIAEgAhsgASAHQYH4AUkbIgJB//8BcUUEQCACQRB0DAELIAJB/wdxIQEgAkGAgAJxIQYgAkGA+AFxIgJBgPgBRgRAIAZBEHQiAkGAgID8B3IgAUUNARogAiABQQ10ckGAgID+B3IMAQsgBkEQdCIGIAJBDXRBgICA/ABxIAFBDXRyQYCAgMADanIgAg0AGiAGQYCAgNgDciABZ0EQayICQRd0ayABIAJB//8DcUEIanRB////A3FyC74QiQRDAAAAAF5FDQAgDCAIKQIAIhAQywIgDP0ABAD9DP///3////9/////f////3/9Tv0MAACAfwAAgH8AAIB/AACAf/05/aQBQQ9HDQAgDCAQEMsCIAz9AAQAIg8gD/3mASIPIA8gD/0NCAkKCwwNDg8AAQIDAAECA/3kASIPIA8gD/0NBAUGBwABAgMAAQIDAAECA/3kAf3jAf0fAEMAAAAAXiEFCyADIApqIAU6AAAgCEEkaiEIIAkgA0EBaiIDRw0ACyAEQSRqIQMgCSAKaiEIQQAhASAKIQUCQAJAA0AgBSAIRg0EIAFBAWohBCAFLQAAQQFHDQEgBUEBaiEFIANBJGohAyAEIgEgCUcNAAtBACECDAELIAQgCUYEQEEBIQIMAQsgASAJayEBQQEhBEEBIQIDQAJAAkAgASAEagRAIAQgBWotAAANASACQQFqIQIMAgtB9KHBABDdCQALIAMgAkFcbGoiBiAD/QACAP0LAgAgBkEgaiADQSBqKAIANgIAIAZBEGogA0EQav0AAgD9CwIACyADQSRqIQMgASAEQQFqIgRqDQALCyAAIAkgAms2AggLIAAoAhQiBgRAQQAhBCAAKAIQIgEhAyAKIQUCQANAAkAgBSAIRwRAIAUtAAANAQJAIAEgBEEYbGoiASgCFCICQQVPBEAgASgCCCIBQQRrKAIAIgdBeHEiCyACQQJ0IgJBBEEIIAdBA3EiBxtqSQ0BIAdBACALIAJBJ2pLGw0KIAEQogILQQEhAiAEQQFqIAZGDQQgBCAGayEHQQEhAQNAIAMhBAJAAkAgCCABIAVqIgtHBEAgA0EYaiEDIAstAAANASACQQFqIQIgBEEsaigCACILQQVJDQIgBEEgaigCACIEQQRrKAIAIg1BeHEiDiALQQJ0IgtBBEEIIA1BA3EiDRtqSQ0MIA1BACAOIAtBJ2pLGw0NIAQQogIMAgtBpKLBABDdCQALIAQgAkFobGoiBEEoaiADQRBqKQIANwIAIARBGGogA/0AAgD9CwIACyAHIAFBAWoiAWoNAAsMBAsMBwtBpKLBABDdCQALIAVBAWohBSADQRhqIQMgBEEBaiIEIAZHDQALQQAhAgsgACAGIAJrNgIUCwJAIAAoAiAiAgRAQQAhBEESIQEgCiEFAkACQANAIAUgCEYNBCAEQQFqIQMgBS0AAEEBRw0BIAVBAWohBSABQRJqIQEgAyIEIAJHDQALQQAhAQwBCyACIANGBEBBASEBDAELIAQgAmshBiAAKAIcIAFqIQNBASEEQQEhAQNAAkACQCAIIAQgBWoiB0cEQCAHLQAADQEgAUEBaiEBDAILQYSiwQAQ3QkACyADIAFBbmxqIgcgA/0AAQD9CwEAIAdBEGogA0EQai8BADsBAAsgA0ESaiEDIAYgBEEBaiIEag0ACwsgACACIAFrNgIgCwJAIAAoAiwiAgRAQQAhBEEeIQEgCiEFAkACQANAIAUgCEYNBCAEQQFqIQMgBS0AAEEBRw0BIAVBAWohBSABQR5qIQEgAyIEIAJHDQALQQAhAQwBCyACIANGBEBBASEBDAELIAQgAmshByAAKAIoIAFqIQNBASEEQQEhAQNAAkACQCAIIAQgBWoiBkcEQCAGLQAADQEgAUEBaiEBDAILQeShwQAQ3QkACyADIAFBYmxqIgYgA/0AAQD9CwEAIAZBFmogA0EWaikBADcBACAGQRBqIANBEGopAQA3AQALIANBHmohAyAHIARBAWoiBGoNAAsLIAAgAiABazYCLAsCQCAAKAI4IgIEQEEAIQRBKiEBIAohBQJAAkADQCAFIAhGDQQgBEEBaiEDIAUtAABBAUcNASAFQQFqIQUgAUEqaiEBIAMiBCACRw0AC0EAIQEMAQsgAiADRgRAQQEhAQwBCyAEIAJrIQcgACgCNCABaiEDQQEhBEEBIQEDQAJAAkAgCCAEIAVqIgZHBEAgBi0AAA0BIAFBAWohAQwCC0GUosEAEN0JAAsgAyABQVZsaiIGIAP9AAEA/QsBACAGQShqIANBKGovAQA7AQAgBkEgaiADQSBqKQEANwEAIAZBEGogA0EQav0AAQD9CwEACyADQSpqIQMgByAEQQFqIgRqDQALCyAAIAIgAWs2AjgLAkAgCQRAIApBBGsoAgAiAEF4cSIFQQRBCCAAQQNxIgAbIAlqSQ0HIABBACAFIAlBJ2pLGw0BIAoQogILIAxBEGokAA8LDAYLQZSiwQAQ3QkAC0HkocEAEN0JAAtBhKLBABDdCQALQfShwQAQ3QkACwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6oVBAh/BH4HfQF7IwBB4AJrIgEkAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AnANFBEAgACgCACICQQJHDQogACgCiAFBAkcNCiAAKAKAAyICQQNNBEBBACECDAwLIAEgACgC/AIiBSgAACIDNgIQAkAgA0HSgpGaBEcEQCADQdKCkYIDRw0DIAJBCEkNASACIAUoAAQiBEEHakF4cUEIaiIDSQ0BIARBCGoiBiACSyAEQXdLcg0EIAFBADYC2AIgASAENgLUAiABIAVBCGo2AtACIAFBIGogAUHQAmoQWSABKAIkIQQgASgCICIGQQJGBEAgBBDOByECDA4LIAFBsAFqIAFBKGpBgAH8CgAAIAEgBDYCrAEgASAGNgKoASAAKAKAAyICIANJDQUgAEEANgKAAyACIANrIQUgA0UNBiACIANGDQggBUUNByAAKAL8AiICIAIgA2ogBfwKAAAMBwsgAUEIaiAAELkCIAEtAAhFBEAgAS0ACQ0JQQAhAgwNCyABKAIMIQIMDAtBACECDAsLIAA1AoADIQkgAEEANgKAAyAAIAkgACkD2AJ8NwPYAgwKCyABQQE2AjQgAUHMyMEANgIwIAFBATYCJCABQcTIwQA2AiAgAUEBNgIsIAEgAUEQaq1CgICAgJAEhDcD0AIgASABQdACajYCKCABQRRqIgAgAUEgahCxBiAAEI4HIQIMCQtBCCAGIAJBnMjBABDqBwALQQAgAyACQYSkxwAQ6gcACyACIANGDQELIAAgBTYCgAMLIAAgACkD2AIgA618Igk3A+ACIAAgCTcD2AICQAJAAkAgASgCpAJBAUYEQCAAIAEoApQCIgM2AogDIAAgASgCtAEgASgCwAEiAiABKAKwARsiBTYCjAMgBUUNASACIAVuIgcgBSAHbCACR2oiBSADRgRAIAEtAKgCIQMgASAEQQAgBkEBcRs2AiQgASACNgIgIAEgA0EBcSICOgAoIABB+AFqIAFBIGoQ6QEgASgC0AEiBEECRwRAAn0gAC0A0AIiA0ECRgRAQwAAQMEhDUMAABBBIQ5DAACAPyEQQQAhA0MAAIA/IRFDAACAPyESQwAAgD8hE0MAAAAADAELIAFBImogAEHTAmotAAA6AAAgASAALwDRAjsBICAAKgLMAiEQIAAqAsgCIREgACoCxAIhEiAAKgLAAiEOIAAqArwCIQ0gACoCuAIhEyAAKgK0AgshDyAAIAEqAoQCIBAgASgCgAIbOALMAiAAIAEqAvwBIBEgASgC+AEbOALIAiAAIAEqAvQBIBIgASgC8AEbOALEAiAAIAEqAuwBIA4gASgC6AEbOALAAiAAIAEqAuQBIA0gASgC4AEbOAK8AiAAIAEqAtwBIBMgASgC2AEbOAK4AiAAIAMgAS0AiAIiAyADQQJGGzoA0AIgACABKgLUASAPIARBAXEbOAK0AiAAQdMCaiABQSJqLQAAOgAAIAAgAS8BIDsA0QILIAJFDQQCfSAALQDQAkECRgRA/QwAAAAAAACAPwAAQMEAABBBIRRDAACAPyENQwAAgD8hDkMAAIA/DAELIAFBImogAEHTAmotAAA6AAAgASAALwDRAjsBICAAKgLIAiENIAAqAsQCIQ4gAP0AArQCIRQgACoCzAILIQ8gAEEBOgDQAiAAIA84AswCIAAgDTgCyAIgACAOOALEAiAAIBT9CwK0AiAAIAEvASA7ANECIABB0wJqIAFBImotAAA6AAAMBAsgASAFNgLMAiABQQI2AiQgAUHox8EANgIgIAFCAjcCLCABQoCAgIAQIgkgAEGIA2qthDcD2AIgASAJIAFBzAJqrYQ3A9ACIAEgAUHQAmo2AiggAUHAAmoiACABQSBqELEGIAAQjgchAgwCCyABQQE2AiQgAUGUyMEANgIgIAFCATcCLCABIAFBpAJqrUKAgICAEIQ3A9ACIAEgAUHQAmo2AiggAUG0AmoiACABQSBqELEGIAAQjgchAiABKAKUAiEDDAELQbTHwQAQgQgACyABKAKQAiEEIAMEQCAEQSRqIQADQCAAQQRrKAIAIgVBgICAgHhyQYCAgIB4RwRAIAAoAgAgBUEBEKIHCyAAQTBqIQAgA0EBayIDDQALCyABKAKMAiIABEAgBCAAQTBsQQgQogcLIAEoApgCIgBBgICAgHhyQYCAgIB4Rg0FIAEoApwCIABBARCiBwwFCwJAIAAoAgBBAkYNACAAKAJoIQQgACgCbCIDBEAgBEEkaiECA0AgAkEEaygCACIFQYCAgIB4ckGAgICAeEcEQCACKAIAIgZBBGsoAgAiB0F4cSIIQQRBCCAHQQNxIgcbIAVqSQ0FIAdBACAIIAVBJ2pLGw0GIAYQogILIAJBMGohAiADQQFrIgMNAAsLIAAoAmQiAwRAIAQgA0EwbEEIEKIHCyAAKAJwIgNBgICAgHhyQYCAgIB4Rg0AIAAoAnQgA0EBEKIHCyAAIAFBqAFqQYgB/AoAAAsgACgCACECDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACwJAAkACQAJAAn8CQCACQQJHBEAgACgChAMgACgCiANPDQYgACgCiAFBAkYNAUEADAILIAFBqAFqIAAQYyABKAKsAUEAIAEtAKgBIgMbIQIgAw0GIAEtAKkBQQFxRQ0GIAApA/ACIgsgACkD2AIiCVgEQCAAKAKAAyEDDAULIAAoAoADIQRBACEDIABBADYCgAMgBCALIAl9IgogBK0iDCAKIAxUGyIKpyIFayECIApQRQRAIAQgBUYNBCACRQ0DIAAoAvwCIgMgAyAFaiAC/AoAAAwDCyAEIAVHDQIMAwtBAQshAgNAAkACQAJAAkACQAJAAkACQAJAAkACQCACRQRAIAFBqAFqIAAQYyABKAKsASEDIAEtAKgBIgINAiABLQCpAUEBcUUNAiAAKQPwAiIJIAApA9gCIgtWDQEMBgsgAUGoAWogABC5AiABLQCoAUEBRgRAIAEoAqwBIQIMEQsgAS0AqQENCUEAIQIMEAsgACgCgAMhAyAAQQA2AoADIAMgCSALfSIKIAOtIgwgCiAMVBsiCqciAmshBCAKUA0BIAIgA0YNAyAERQ0CIAAoAvwCIgMgAiADaiAE/AoAAAwCCyADQQAgAhshAgwOCyACIANGDQELIAAgBDYCgAMLIAAgCiALfCILNwPYAiAJIAtWDQELAkAgACgCiAFBAkYNACAAKALkASIDRQ0AIAAoAugBIgJBBGsoAgAiBEF4cSIFIANBKGwiA0EEQQggBEEDcSIEG2pJDQIgBEEAIAUgA0EnaksbDQMgAhCiAgsgAEECNgKIASAAIAAoAoQDQQFqIgM2AoQDIAMgACgCiANJDQQMCQtBACECDAkLQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0EAIQIMAQtBASECDAALAAsgACACNgKAAyACIQMLIAAgCSAKfCIJNwPYAiAJIAtaDQBBACECDAILQQAhAiAAQQA2AoADIABBAToAnAMgACAJIAOtfDcD2AIMAQsgAEEBOgCcAyAANQKAAyEJQQAhAiAAQQA2AoADIAAgCSAAKQPYAnw3A9gCCyABQeACaiQAIAILlhoBC38jAEGAAWsiBSQAIAAoAgwhBgJAAkACQAJAAkAgACgCFCIBIAAoAhAiAkkEQCAAQQxqIQsDQAJAIAEgBmotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMEAwsgACABQQFqIgE2AhQgASACRw0ACyACIQELIAVBCGogBiACIAFBAWoiACACIAAgAkkbEPkBIAUoAgwhACAFKAIIIQJBFBBxIgFFDQQgAUEDNgIADAILIAUgBiACIAFBAWoiACACIAAgAkkbEPkBIAUoAgQhACAFKAIAIQJBFBBxIgFFDQMgAUEGNgIADAELIABBADYCCCAAIAFBAWoiATYCFAJAIAEgAk8NAANAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkAgASAGai0AACIEQQlrDiUBAQgIAQgICAgICAgICAgICAgICAgICAEIBwgICAgICAgICAgFAAsgBEHbAGsOIQUHBwcHBwcHBwcHAwcHBwcHBwcBBwcHBwcCBwcHBwcHBQcLIAAgAUEBaiIBNgIUIAEgAkcNCyACIQEMDAsgACABQQFqIgQ2AhQCQCACIARNDQAgACABQQJqIgM2AhQCQCAEIAZqLQAAQfUARw0AIAMgBCACIAIgBEkbIgRGDQEgACABQQNqIgc2AhQgAyAGai0AAEHsAEcEQCAHIQMMAQsgBCAHRg0BIAAgAUEEaiIDNgIUIAYgB2otAABB7ABGDQoLIAVB2ABqIAYgAiADEPkBIAUoAlwhACAFKAJYIQJBFBBxIgFFDQ8gAUEJNgIADA0LIAVB0ABqIAYgAiAEEPkBIAUoAlQhACAFKAJQIQJBFBBxIgFFDQ4gAUEFNgIADAwLIAAgAUEBaiIENgIUAkAgAiAETQ0AIAAgAUECaiIDNgIUAkAgBCAGai0AAEHyAEcNACADIAQgAiACIARJGyIERg0BIAAgAUEDaiIHNgIUIAMgBmotAABB9QBHBEAgByEDDAELIAQgB0YNASAAIAFBBGoiAzYCFCAGIAdqLQAAQeUARg0JCyAFQegAaiAGIAIgAxD5ASAFKAJsIQAgBSgCaCECQRQQcSIBRQ0OIAFBCTYCAAwMCyAFQeAAaiAGIAIgBBD5ASAFKAJkIQAgBSgCYCECQRQQcSIBRQ0NIAFBBTYCAAwLCyAAIAFBAWoiBDYCFAJAIAIgBE0NACAAIAFBAmoiAzYCFAJAIAQgBmotAABB4QBHDQAgAyAEIAIgAiAESRsiBEYNASAAIAFBA2oiBzYCFCADIAZqLQAAQewARwRAIAchAwwBCyAEIAdGDQEgACABQQRqIgg2AhQgBiAHai0AAEHzAEcEQCAIIQMMAQsgBCAIRg0BIAAgAUEFaiIDNgIUIAYgCGotAABB5QBGDQgLIAVB+ABqIAYgAiADEPkBIAUoAnwhACAFKAJ4IQJBFBBxIgFFDQ0gAUEJNgIADAsLIAVB8ABqIAYgAiAEEPkBIAUoAnQhACAFKAJwIQJBFBBxIgFFDQwgAUEFNgIADAoLIAAgAUEBajYCFAwDCyAAKAIAIAAoAggiA2sgCkkEQCAAIAMgCkEBQQEQpAUgACgCCCEDCyAKBEAgACgCBCADaiAJOgAAIANBAWohAwsgACADNgIIIAAgACgCFEEBajYCFEEADAULIAAgAUEBajYCFCALEP0DIgENCAwDCyAEQTBrQf8BcUEKTw0BCwJ/IwBBIGsiByQAIAAoAgwhCAJAAkACQAJAAkAgACgCFCIDIAAoAhAiBEkEQCAAIANBAWoiAjYCFCADIAhqLQAAIgFBMEYEQCACIARPDQQgAiAIai0AAEEwa0H/AXFBCkkNAwwECyABQTFrQf8BcUEITQ0BIAIhAwsgB0EYaiAIIAQgAxD5ASAHKAIcIQIgBygCGCEBQRQQcSIDRQ0EIAMgATYCDCADQQ02AgAgAyACNgIQDAMLIAIgBE8NAQNAIAIgCGotAABBMGtB/wFxQQlLDQIgACACQQFqIgI2AhQgAiAERw0AC0EAIQMMAgsgB0EIaiAIIAQgA0ECaiICIAQgAiAESRsQ+QEgBygCDCECIAcoAgghAUEUEHEiA0UNAiADIAE2AgwgA0ENNgIAIAMgAjYCEAwBC0EAIQMgAiAETw0AAkACQCACIAhqLQAAIgFB5QBGIAFBxQBGckUEQCABQS5HDQMgACACQQFqIgE2AhQgASAETw0BIAEgCGotAABBMGtB/wFxQQlLDQEgAkECaiECA0AgBCACIgFGDQMgAkEBaiECIAEgCGotAAAiBkEwa0H/AXFBCkkNAAsgACABNgIUIAZBIHJB5QBHDQMLAn8jAEEQayIDJAAgACAAKAIUIgFBAWoiAjYCFCAAKAIMIQQCQCACIAAoAhAiCE8NAAJAIAIgBGotAABBK2sOAwABAAELIAAgAUECaiICNgIUCwJAAkACQCADQQhqIAQgCCACIAhJBH8gACACQQFqIgE2AhQgAiAEai0AAEEwa0H/AXFBCU0NASABBSACCxD5ASADKAIMIQEgAygCCCEEQRQQcSICRQ0CIAIgBDYCDCACQQ02AgAgAiABNgIQDAELQQAhAiABIAhPDQADQCABIARqLQAAQTBrQf8BcUEJSw0BIAAgAUEBaiIBNgIUIAEgCEcNAAsLIANBEGokACACDAELAAshAwwCCyAHQRBqIAggBCACQQJqIgIgBCACIARJGxD5ASAHKAIUIQIgBygCECEBQRQQcSIDRQ0CIAMgATYCDCADQQ02AgAgAyACNgIQDAELIAAgBDYCFAsgB0EgaiQAIAMMAQsACyIBRQ0BDAYLIAVByABqIAYgAiABQQFqIgAgAiAAIAJJGxD5ASAFKAJMIQAgBSgCSCECQRQQcSIBRQ0GIAFBCjYCAAwECyAKBEAgACgACCEDIAkhBEEBDAELIAAoAggiAkUEQEEAIQEMBQsgACACQQFrIgM2AgggACgCBCADai0AACEEQQELIQogACgCDCEGAkACfwJAAkACQAJAIAAoAhQiASAAKAIQIgJPBEAgBCEJDAELIAAoAgQhByAEIQkDQAJAAkACQAJAAkACQCABIAZqLQAAIgRBCWsOJAEBCAgBCAgICAgICAgICAgICAgICAgIAQgICAgICAgICAgIAgALIARB3QBGDQIgBEH9AEYNAwwHCyAAIAFBAWoiATYCFCABIAJHDQQgAiEBDAULIApFDQYgACABQQFqIgE2AhQMBgsgCUH/AXFB2wBHDQQMAQsgCUH/AXFB+wBHDQMLIAAgAUEBaiIBNgIUIANFBEBBACEBDAsLIAAgA0EBayIDNgIIIAMgB2otAAAhCUEBIQogASACSQ0ACwtBAiEEAkAgCUH/AXEiAEHbAEcEQCAAQfsARw0BQQMhBAsgBUFAayAGIAIgAUEBaiIAIAIgACACSRsQ+QEgBSgCRCEAIAUoAkAhAkEUEHEiAUUNCiABIAQ2AgAMCAtBpPjGAEEoQbjnwAAQ6wcACyAKRQ0AQQcgCUH/AXEiAEHbAEYNAhogAEH7AEYNAUGk+MYAQShByOfAABDrBwALIAlB/wFxQfsARw0CIAEgAkkEQANAAkACQCABIAZqLQAAQQlrIgNBGUsNAEEBIAN0QZOAgARxDQEgA0EZRw0AIAAgAUEBajYCFCALEP0DIgENCiAAKAIMIQYCQAJAIAAoAhQiASAAKAIQIgJJBEADQAJAIAEgBmotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMEAwsgACABQQFqIgE2AhQgASACRw0ACyACIQELIAVBMGogBiACIAFBAWoiACACIAAgAkkbEPkBIAUoAjQhACAFKAIwIQJBFBBxIgFFDQ0gAUEDNgIADAsLIAVBKGogBiACIAFBAWoiACACIAAgAkkbEPkBIAUoAiwhACAFKAIoIQJBFBBxIgFFDQwgAUEGNgIADAoLIAAgAUEBaiIBNgIUDAYLIAVBGGogBiACIAFBAWoiACACIAAgAkkbEPkBIAUoAhwhACAFKAIYIQJBFBBxIgFFDQogAUERNgIADAgLIAAgAUEBaiIBNgIUIAEgAkcNAAsgAiEBCyAFQSBqIAYgAiABQQFqIgAgAiAAIAJJGxD5ASAFKAIkIQAgBSgCICECQRQQcSIBRQ0HIAFBAzYCAAwFC0EICyEDIAVBEGogBiACIAFBAWoiACACIAAgAkkbEPkBIAUoAhQhACAFKAIQIQJBFBBxIgFFDQUgASADNgIADAMLQQEhCiABIAJJDQALCyAFQThqIAYgAiABQQFqIgAgAiAAIAJJGxD5ASAFKAI8IQAgBSgCOCECQRQQcSIBRQ0CIAFBBTYCAAsgASACNgIMIAEgADYCEAsgBUGAAWokACABDwsAC+UQAgp/B30gA0EITwRAIAAgACADQQN2IgNBBHQiBWogACADQRxsIghqIAMgBBChASEAIAEgASAFaiABIAhqIAMgBBChASEBIAIgAiAFaiACIAhqIAMgBBChASECC0MAAIA/IRACfwJAIAAoAgAiBSAEKAIAQQRqKAIAIgMoAggiCEkEQCABKAIAIQYgAygCBCILIAVBGGxqIgQtABMiBSAELQASIgcgBC0AESIKIAcgCksbIgcgBSAHSxsiBwR9QwAAQMEgAyoCRCADLQBYQQJGIgUbIg9DAAAQQSADKgJIIAUbIA+TQwAAfkOVIAdBAWtB/wFxs5SSEIkEIg8gD5IFQwAAAAALIRIgBEEMai8BACIEQf//AXEiDUUEQCAEQRB0DAMLIARB/wdxIQUgBEGAgAJxIQogBEGA+AFxIglBgPgBRgRAIApBEHQiCkGAgID8B3IgBUUNAxogCiAFQQ10ckGAgID+B3IMAwsgCkEQdCEKIAlFDQEgCUENdEGAgID8AHEgBUENdHJBgICAwANqIApyDAILIAUgCEHcu8cAEIwHAAsgBSAFZ0EQayIFQf//A3FBCGp0Qf///wNxIApBgICA2ANyIAVBF3Rrcgu+Ig9DAACAP14EQCAPEMYFQ1T4LUCUQwAAgD+SkSEQC0MAAIA/IQ8CfwJAIAYgCEkEQCALIAZBGGxqIgUtABMiBiAFLQASIgogBS0AESIJIAkgCkkbIgogBiAKSxsiCgR9QwAAQMEgAyoCRCADLQBYQQJGIgYbIhFDAAAQQSADKgJIIAYbIBGTQwAAfkOVIApBAWtB/wFxs5SSEIkEIhEgEZIFQwAAAAALIRMgBUEMai8BACIFQf//AXEiDkUEQCAFQRB0DAMLIAVB/wdxIQYgBUGAgAJxIQkgBUGA+AFxIgxBgPgBRgRAIAlBEHQiCUGAgID8B3IgBkUNAxogCSAGQQ10ckGAgID+B3IMAwsgCUEQdCEJIAxFDQEgDEENdEGAgID8AHEgBkENdHJBgICAwANqIAlyDAILIAYgCEHcu8cAEIwHAAsgBiAGZ0EQayIGQf//A3FBCGp0Qf///wNxIAlBgICA2ANyIAZBF3Rrcgu+IhFDAACAP14EQCAREMYFQ1T4LUCUQwAAgD+SkSEPCyACKAIAIQkgBwR9QwAAQMEgAyoCRCADLQBYQQJGIgYbIhFDAAAQQSADKgJIIAYbIBGTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIhEgEZIFQwAAAAALIRRDAACAPyERAn8gBEEQdCANRQ0AGiAEQf8HcSEGIARBgIACcSEHIARBgPgBcSIEQYD4AUYEQCAHQRB0IgRBgICA/AdyIAZFDQEaIAQgBkENdHJBgICA/gdyDAELIAdBEHQiByAEQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2pyIAQNABogBiAGZ0EQayIEQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIARBF3Rrcgu+IhVDAACAP14EQCAVEMYFQ1T4LUCUQwAAgD+SkSERCwJ/AkAgCCAJSwRAIBIgEJQiECATIA+UYCALIAlBGGxqIgQtABMiBiAELQASIgcgBC0AESIJIAcgCUsbIgcgBiAHSxsiBgR9QwAAQMEgAyoCRCADLQBYQQJGIgcbIg9DAAAQQSADKgJIIAcbIA+TQwAAfkOVIAZBAWtB/wFxs5SSEIkEIg8gD5IFQwAAAAALIRJFIQsgECAQWyEMIARBDGovAQAiBEH//wFxIg1FBEAgBEEQdAwDCyAEQf8HcSEIIARBgIACcSEHIARBgPgBcSIJQYD4AUYEQCAHQRB0IgdBgICA/AdyIAhFDQMaIAcgCEENdHJBgICA/gdyDAMLIAdBEHQhByAJRQ0BIAlBDXRBgICA/ABxIAhBDXRyQYCAgMADaiAHcgwCCyAJIAhB3LvHABCMBwALIAggCGdBEGsiCEH//wNxQQhqdEH///8DcSAHQYCAgNgDciAIQRd0a3ILQwAAgD8hD74iEEMAAIA/XgRAIBAQxgVDVPgtQJRDAACAP5KRIQ8LIAsgDHEiCCAUIBGUIhAgEFsgECASIA+UYEVxRgR/IAIgASAIIAoEfUMAAEDBIAMqAkQgAy0AWEECRiIAGyIPQwAAEEEgAyoCSCAAGyAPk0MAAH5DlSAKQQFrQf8BcbOUkhCJBCIPIA+SBUMAAAAACwJ/IAVBEHQgDkUNABogBUH/B3EhACAFQYCAAnEhASAFQYD4AXEiAkGA+AFGBEAgAUEQdCIBQYCAgPwHciAARQ0BGiABIABBDXRyQYCAgP4HcgwBCyABQRB0IgEgAkENdEGAgID8AHEgAEENdHJBgICAwANqciACDQAaIAAgAGdBEGsiAEH//wNxQQhqdEH///8DcSABQYCAgNgDciAAQRd0a3ILviIPQwAAgD9eBH0gDxDGBUNU+C1AlEMAAIA/kpEFQwAAgD8LlCIPIA9bIA8gBgR9QwAAQMEgAyoCRCADLQBYQQJGIgAbIhBDAAAQQSADKgJIIAAbIBCTQwAAfkOVIAZBAWtB/wFxs5SSEIkEIhAgEJIFQwAAAAALAn8gBEEQdCANRQ0AGiAEQf8HcSEAIARBgIACcSEBIARBgPgBcSICQYD4AUYEQCABQRB0IgFBgICA/AdyIABFDQEaIAEgAEENdHJBgICA/gdyDAELIAFBEHQiASACQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2pyIAINABogACAAZ0EQayIAQf//A3FBCGp0Qf///wNxIAFBgICA2ANyIABBF3Rrcgu+IhBDAACAP14EfSAQEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUYEVxcxsFIAALC+oRAw1/AXsJfQJAAkACQAJAAkAgACgCCCIJRQRAQQEhBkEBIQoMAQsgACgCBCEFIAkQcSIKRQ0CQwAAEEEgACoCSCAALQBYQQJGIgQbQwAAQMEgACoCRCAEGyITk0MAAH5DlSEUIAVBFGohBgNAQQAhBAJAAn8gBkEIay8BACIBQf//AXFFBEAgAUEQdAwBCyABQf8HcSECIAFBgIACcSEHIAFBgPgBcSIBQYD4AUYEQCAHQRB0IgFBgICA/AdyIAJFDQEaIAEgAkENdHJBgICA/gdyDAELIAdBEHQiByABQQ10QYCAgPwAcSACQQ10ckGAgIDAA2pyIAENABogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAJBF3Rrcgu+QwAAAABeRQ0AIAZBAWstAAAiAiAGQQJrLQAAIgEgBkEDay0AACIHIAEgB0sbIgEgASACSRsiAkUNACATIBQgAkEBa0H/AXGzlJIQiQRDAAAAAF5FDQBDAACAPyAGLwEAIgJBCHaz/RMgAiAGQQJqLQAAIgFBEHRyQf8BcbP9IAH9DAAAf0MAAH9DAAB/QwAAf0P95wEiDiAO/eQB/QwAAIC/AACAvwAAgL8AAIC//eQBIg79HwEiD4uTIA79HwAiFYuTIhGMQwAAAAAQ4AghECABs0MAAH9DlUMAAAA/lEPbD0lAlCIWEJkCIhIgDyAQIBCMIhcgDv0MAAAAAAAAAAAAAAAAAAAAAP1G/U0iDv3HAf0bAkEBcRuSIg8gESARlCAPIA+UIBUgECAXIA79GwBBAXEbkiIQIBCUkpKRIg+VlP0TIBIgECAPlZT9IAEgEiARIA+VlP0gAiAWEJsC/SADIg79DP///3////9/////f////3/9Tv0MAACAfwAAgH8AAIB/AACAf/05/aQBQQ9HDQAgDiAO/eYBIg4gDiAO/Q0ICQoLDA0ODwABAgMAAQID/eQBIg4gDiAO/Q0EBQYHAAECAwABAgMAAQID/eQB/eMB/R8AQwAAAABeIQQLIAMgCmogBDoAACAGQRhqIQYgCSADQQFqIgNHDQALIAVBGGohAyAJIApqIQZBACEBIAohBAJAAkADQCAEIAZGDQQgAUEBaiECIAQtAABBAUcNASAEQQFqIQQgA0EYaiEDIAIiASAJRw0AC0EAIQEMAQsgAiAJRgRAQQEhAQwBCyABIAlrIQVBASECQQEhAQNAAkACQCACIAVqBEAgAiAEai0AAA0BIAFBAWohAQwCC0GUocEAEN0JAAsgAyABQWhsaiIHIAP9AAIA/QsCACAHQRBqIANBEGopAgA3AgALIANBGGohAyAFIAJBAWoiAmoNAAsLIAAgCSABazYCCAsgACgCFCIHBEBBACECIAAoAhAiASEDIAohBAJAA0ACQCAEIAZHBEAgBC0AAA0BAkAgASACQRhsaiIBKAIUIgVBBU8EQCABKAIIIgFBBGsoAgAiCEF4cSILIAVBAnQiBUEEQQggCEEDcSIIG2pJDQEgCEEAIAsgBUEnaksbDQogARCiAgtBASEFIAJBAWogB0YNBCACIAdrIQhBASEBA0AgAyECAkACQCAGIAEgBGoiC0cEQCACQRhqIQMgCy0AAA0BIAVBAWohBSACQSxqKAIAIgtBBUkNAiACQSBqKAIAIgJBBGsoAgAiDEF4cSINIAtBAnQiC0EEQQggDEEDcSIMG2pJDQwgDEEAIA0gC0EnaksbDQ0gAhCiAgwCC0GkocEAEN0JAAsgAiAFQWhsaiICQShqIANBEGopAgA3AgAgAkEYaiAD/QACAP0LAgALIAggAUEBaiIBag0ACwwECwwHC0GkocEAEN0JAAsgBEEBaiEEIANBGGohAyACQQFqIgIgB0cNAAtBACEFCyAAIAcgBWs2AhQLAkAgACgCICIFBEBBACECQQkhASAKIQQCQAJAA0AgBCAGRg0EIAJBAWohAyAELQAAQQFHDQEgBEEBaiEEIAFBCWohASADIgIgBUcNAAtBACEBDAELIAMgBUYEQEEBIQEMAQsgAiAFayEHIAAoAhwgAWohA0EBIQJBASEBA0ACQAJAIAYgAiAEaiIIRwRAIAgtAAANASABQQFqIQEMAgtB1KHBABDdCQALIAMgAUF3bGoiCCADKQAANwAAIAhBCGogA0EIai0AADoAAAsgA0EJaiEDIAcgAkEBaiICag0ACwsgACAFIAFrNgIgCwJAIAAoAiwiBQRAQQAhAkEPIQEgCiEEAkACQANAIAQgBkYNBCACQQFqIQMgBC0AAEEBRw0BIARBAWohBCABQQ9qIQEgAyICIAVHDQALQQAhAQwBCyADIAVGBEBBASEBDAELIAIgBWshByAAKAIoIAFqIQNBASECQQEhAQNAAkACQCAGIAIgBGoiCEcEQCAILQAADQEgAUEBaiEBDAILQbShwQAQ3QkACyADIAFBcWxqIgggAykAADcAACAIQQdqIANBB2opAAA3AAALIANBD2ohAyAHIAJBAWoiAmoNAAsLIAAgBSABazYCLAsCQCAAKAI4IgUEQEEAIQJBFSEBIAohBAJAAkADQCAEIAZGDQQgAkEBaiEDIAQtAABBAUcNASAEQQFqIQQgAUEVaiEBIAMiAiAFRw0AC0EAIQEMAQsgAyAFRgRAQQEhAQwBCyACIAVrIQcgACgCNCABaiEDQQEhAkEBIQEDQAJAAkAgBiACIARqIghHBEAgCC0AAA0BIAFBAWohAQwCC0HEocEAEN0JAAsgAyABQWtsaiIIIAP9AAAA/QsAACAIQQ1qIANBDWopAAA3AAALIANBFWohAyAHIAJBAWoiAmoNAAsLIAAgBSABazYCOAsCQCAJBEAgCkEEaygCACIAQXhxIgRBBEEIIABBA3EiABsgCWpJDQcgAEEAIAQgCUEnaksbDQEgChCiAgsPCwwGC0HEocEAEN0JAAtBtKHBABDdCQALQdShwQAQ3QkAC0GUocEAEN0JAAsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvcEAIcfwV9IwBBMGsiBiQAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AuAFBAUcNACAAKAKsASAAKAKwASIBQQJ0IAAoArQBIgMgAWpBAnQQ4QghASADQQJ0IgMgACgCZCIFSw0BIAAoAmAhBSAGIAEQuAoiAjYCFCAGIAM2AgggAiADRw0HIAEgBSADEOAJIAFBhAhJDQAgARCbBwsgAEIANwKwASAAQbgBakEAOgAAIAAoAmgiAUGAgICAeEYgACgCdCIDQYCAgIB4RnENAiABQYCAgIB4RyADQYCAgIB4R3FFBEAgBkEANgIoIAZBATYCHCAGQZzgwAA2AhggBkIENwIgIAZBGGoQkgchAQwGC0GAgBAhCiAAKAJkIgNB//8PTQRAQYCAECADIgFrIgUgACgCXCABa0sEQCAAQdwAaiABIAVBBEEEEKQFIAAoAmQhAQsgACgCYCICIAFBAnRqIQUgA0H//w9HBH9B/P8/IANBAnRrIggEQCAFQQAgCPwLAAsgASADayIDQf//D2ohASACIANBAnRqQfz/P2oFIAULQQA2AgAgAUEBaiEKCyAAIAo2AmQgACgCpAEiC0ECdBC2CSEQAkAgACgCMEUNACAAKAI0IgFBhAhJDQAgARCbBwsgACAQNgI0IABBATYCMCAAKAJoIhFBgICAgHhGDQQgACgCdCISQYCAgIB4Rg0DIAtFDQFDAAAAQEMAAIA/IAAtAJwBQQFxGyEhIAAqAowBIAAqAogBIh2TQwAAfkOVIR4gACgCeCEXIAAoAmwhGCAAKAJ8IRMgACgCcCEUIAAoAqwBIRkgACgCYCEOQQAhAQNAIApBgIAEIAsgAWsiAyADQYCABE8bIghBAnQiBUkEQEEAIAUgCkHo38AAEOoHAAsgBiAZIAFBAnQiFSABIAhqIgNBAnQiGhDhCCICELgKIgQ2AhQgBiAFNgIIAkAgBCAFRgRAIA4gBSACEOEJIAJBhAhPBEAgAhCbBwsgASALRg0BIAhBBHQhFiAVIBdqIRsgGCABQQF0aiEPQQAhDEEAIQgCQANAIAwgFkYEQCAIIAhBBGogBUHY38AAEOoHAAsCfyAMIA5qIg1BBGooAgAiAkH//wFxRQRAIAJBEHQMAQsgAkH/B3EhBCACQYCAAnEhByACQYD4AXEiCUGA+AFGBEAgB0EQdCIHQYCAgPwHciAERQ0BGiAHIARBDXRyQYCAgP4HcgwBCyAHQRB0IgcgCUENdEGAgID8AHEgBEENdHJBgICAwANqciAJDQAaIAdBgICA2ANyIARnQRBrIgdBF3RrIAQgB0H//wNxQQhqdEH///8DcXILIRwCfyACQYCAfHEgAkEQdiICQf//AXFFDQAaIAJB/wdxIQQgAkGAgAJxIQcgAkGA+AFxIglBgPgBRgRAIAdBEHQiB0GAgID8B3IgBEUNARogByACQQ10ckGAgID+B3IMAQsgB0EQdCICIAlBDXRBgICA/ABxIARBDXRyQYCAgMADanIgCQ0AGiACQYCAgNgDciAEZ0EQayICQRd0ayAEIAJB//8DcUEIanRB////A3FyCyEJIAYCfyANQQhqKAIAIgRB//8BcUUEQCAEQRB0DAELIARB/wdxIQIgBEGAgAJxIQcgBEGA+AFxIgRBgPgBRgRAIAdBEHQiBEGAgID8B3IgAkUNARogBCACQQ10ckGAgID+B3IMAQsgB0EQdCIHIARBDXRBgICA/ABxIAJBDXRyQYCAgMADanIgBA0AGiAHQYCAgNgDciACZ0EQayIEQRd0ayACIARB//8DcUEIanRB////A3FyCzYCECAGIAk2AgwgBiAcNgIIIA0tAAMhByANQQxqKAIAIgJBCHYhBEMAAAAAIR8gAkH/AXEEQCAdIB4gAkEBa0H/AXGzlJIQiQQhHwtDAAAAACEgIARB/wFxBEAgHSAeIARBAWtB/wFxs5SSEIkEISALIAYgAkEQdiICQf8BcQR9IB0gHiACQQFrQf8BcbOUkhCJBAVDAAAAAAs4AiAgBiAgOAIcIAYgHzgCGCABIBRJBEAgASATTw0CIA0gBkEIaiAhIAezQwAAf0OVlEMAAAAAkiAGQRhqIA8vAQAgCCAbaigCABCRAiAIQQRqIQggD0ECaiEPIAFBAWohASAWIAxBEGoiDEcNAQwECwsgASAUQbjfwAAQjAcACyABIBNByN/AABCMBwALDAgLIAYgECAVIBoQ4QgiARC4CiICNgIUIAYgBTYCCCACIAVGBEAgASAOIAUQ4AkgAUGECE8EQCABEJsHCyADIgEgC0kNAQwDCwsMBgtBACADIAVB/OvAABDqBwALIBJBgICAgHhyQYCAgIB4RwRAIAAoAngiAUEEaygCACIDQXhxIgUgEkECdCICQQRBCCADQQNxIgMbakkNBiADQQAgBSACQSdqSxsNByABEKICCyAAQYCAgIB4NgJ0IBFBgICAgHhyQYCAgIB4RwRAIAAoAmwiAUEEaygCACIDQXhxIgUgEUEBdCICQQRBCCADQQNxIgMbakkNBiADQQAgBSACQSdqSxsNByABEKICCyAAQYCAgIB4NgJoC0EAIQEgAEEANgJkIAAoAmAhAyAAKAJcIQUgAEKAgICAwAA3AlwgBUUNAiADQQRrKAIAIgBBeHEiAiAFQQJ0IgVBBEEIIABBA3EiABtqSQ0EIABBACACIAVBJ2pLGw0FIAMQogIMAgtBqN/AABDdCQALQZjfwAAQ3QkACyAGQTBqJAAgAQ8LIAZBADYCGEEAIAZBFGogBkEIaiAGQRhqQeD5xAAQ9QcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvuDwEOfyMAQYABayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAihBAkcEQCABKALUASIDIAEoAtgBQRxsaiEFAkACQANAIAMiBCAFRiIDDQFB1c3HAEEVIAQoAhQgBCgCGBCsA0UEQCAEQQBBHCADG2ohA0HqzccAQRUgBCgCFCAEKAIYEKwDRQ0BCwsgBCgCGCINQQBIDQMgBCgCFCEDAkAgDUUEQEEBIQEMAQsgDRBxIgFFDQoLIA0EQCABIAMgDfwKAAALIAQoAgBBAUYEQCAEKAIMIgdBAEgNDCAEKAIIIQMCQCAHRQRAQQEhBAwBCyAHEHEiBEUNCwsgBwRAIAQgAyAH/AoAAAsgByEDDAcLIAQoAgwiCUEASA0EIAQoAgghAwJAIAlFBEBBASEKDAELIAkQcSIKRQ0KCyAJBEAgCiADIAn8CgAACyACQThqIAogCUGAgIABEN8BQQEhBCACKAI8IQggAgJ/AkAgAigCOEEBRgRAIAhBgICAgHhHDQFBAwwCCyACKAJEIQsgAigCQCEGIAJBADYCQCACQoCAgIAQNwI4QQAhAyALBEAgAkE4akEAIAsQ7wUgAigCQCEDIAYhBQNAQQFBAiAFLAAAIgdBAE4iDhsiDCACKAI4IAMiBGtLBH8gAkE4aiAEIAwQ7wUgAigCQAUgBAsgAigCPCIEaiIPIA4EfyAHBSAPIAdBvwFxOgABIAdBwAFxQQZ2QUByCzoAACACIAMgDGoiAzYCQCAFQQFqIQUgC0EBayILDQALIAIoAjghBwsgCQRAIApBBGsoAgAiBUF4cSIOQQRBCCAFQQNxIgUbIAlqSQ0PIAVBACAOIAlBJ2pLGw0QIAoQogILIAgEQCAGQQRrKAIAIgVBeHEiCkEEQQggBUEDcSIFGyAIakkNDyAFQQAgCiAIQSdqSxsNECAGEKICCyADQQBODQgMDQsgCARAIAIoAkAiBUEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgCGpJDQ4gA0EAIAQgCEEnaksbDQ8gBRCiAgtBBAs6ACkgAkEeOgAoIAJBOGogAkEoahD8AyACQRBqIgUgAkHMAGr9AAIA/QsDACACQSBqIgQgAkHcAGooAgA2AgAgAiAC/QACPP0LAwAgAigCOCIDQQZGDQEgACAC/QADAP0LAgQgAEEkaiAEKAIANgIAIABBFGogBf0AAwD9CwIAIAAgAzYCAAwICyABKALIASIDIAEoAswBQRhsaiEFAkADQCADIgQgBUYiAQ0BQdXNxwBBFSAEKAIEIAQoAggQrANFBEAgBEEAQRggARtqIQNB6s3HAEEVIAQoAgQgBCgCCBCsA0UNAQsLIAQoAggiBkEASA0LIAQoAgQhAwJAIAZFBEBBASEBDAELIAYQcSIBRQ0KCyAGBEAgASADIAb8CgAACyAEKAIUIgVBAEgNCyAEKAIQIQQCQCAFRQRAQQEhAwwBCyAFEHEiA0UNCgsgBQRAIAMgBCAF/AoAAAsgACAFNgIMIAAgAzYCCCAAIAU2AgQgAEEGNgIAIAZFDQogAUEEaygCACIAQXhxIgNBBEEIIABBA3EiABsgBmpJDQwgAEEAIAMgBkEnaksbDQ0gARCiAgwKCyAAQoaAgICAgICAgH83AwAMCQsgAiAKIAlBfxDfASACKAIEIQwCQAJAIAIoAgBBAUYEQCAMQYCAgIB4Rg0BIAJBADYCSCACQQE2AjwgAkGoscQANgI4IAJCBDcCQCACQThqQbCxxAAQjQgACyAMQYCAgIB4Rw0BCyACQZ4GOwFkIAAgAkHkAGoQ/AMMBwsgAigCDCELIAIoAgghByACQQA2AnwgAkKAgICAEDcCdEEBIQhBACEDIAsEQCACQfQAakEAIAsQ7wUgAigCfCEGIAchBQNAQQFBAiAFLAAAIgNBAE4iDhsiDyACKAJ0IAYiBGtLBH8gAkH0AGogBCAPEO8FIAIoAnwFIAQLIAIoAngiCGoiBCAOBH8gAwUgBCADQb8BcToAASADQcABcUEGdkFAcgs6AAAgAiAGIA9qIgY2AnwgBUEBaiEFIAtBAWsiCw0ACyACKAJ0IQMLIAwEQCAHQQRrKAIAIgRBeHEiBUEEQQggBEEDcSIEGyAMakkNCyAEQQAgBSAMQSdqSxsNDCAHEKICCyAGQQBIDQMMBQtBrJjHABDdCQALQaTvwQAQ/wcMBQtB2JrIABD/BwALQdiayAAQ/wcACwJAIANFBEBBASEIDAELIAMQcSIIRQ0DCyADBEAgCCAEIAP8CgAACyADIQYgBCEKIAchCQsCQCAGRQRAQQEhBwwBCyAGEHEiB0UNAgsgBgRAIAcgCCAG/AoAAAsgAwRAIAhBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIANqSQ0FIARBACAFIANBJ2pLGw0GIAgQogILIAAgBjYCDCAAIAc2AgggACAGNgIEIABBBjYCAAsgDQRAIAFBBGsoAgAiAEF4cSIDQQRBCCAAQQNxIgAbIA1qSQ0EIABBACADIA1BJ2pLGw0FIAEQogILIAlFDQEgCkEEaygCACIAQXhxIgFBBEEIIABBA3EiABsgCWpJDQMgAEEAIAEgCUEnaksbDQQgChCiAgwBCwALIAJBgAFqJAAPC0Gk78EAEP8HAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL7Q8CIX8VfSMAQfAAayIGJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AuAFBAUcNACAAKAKsASAAKAKwASIFQQJ0IAAoArQBIgcgBWpBAnQQ4QghBSAHQQJ0IgcgACgCZCIISw0BIAAoAmAhCCAGIAUQuAoiCTYCFCAGIAc2AhggByAJRw0LIAUgCCAHEOAJIAVBhAhJDQAgBRCbBwsgAEIANwKwASAAQbgBakEAOgAAIAAoAhBFDQggACgCFCABQQJ0IAEgAmpBAnQQ4QghDQJAIAJBAnQiASAAKAJkIgVNBEAgACABNgJkIAAoAmAhCiABIQcMAQsgBSEIIAEgBWsiByAAKAJcIAVrSwRAIABB3ABqIAUgB0EEQQQQpAUgACgCZCEICyAAKAJgIgogCEECdCIJaiELIAdBAk8EQCABIAVBf3NqQQJ0IgwEQCALQQAgDPwLAAsgAkEEdCAFQQJ0ayAKaiAJakEEayELIAcgCGpBAWshCAsgC0EANgIAIAAgCEEBaiIHNgJkIAEgB0sNAgsgBiANELgKIgU2AhQgBiABNgIYIAEgBUcNCiAKIAEgDRDhCSAEQRVuIRAgBEEUa0EVbkEBaiERIARBE2tBFW5BAWohEiAEQRJrQRVuQQFqIRMgBEERa0EVbkEBaiEUIARBEGtBFW5BAWohFSAEQQ9rQRVuQQFqIRYgBEEOa0EVbkEBaiEXIARBDWtBFW5BAWohGCAEQQxrQRVuQQFqIRkgBEELa0EVbkEBaiEaIARBCmtBFW5BAWohGyAEQQlrQRVuQQFqIRwgBEEIa0EVbkEBaiEdIARBB2tBFW5BAWohHiAEQQZrQRVuQQFqIR8gBEEFa0EVbkEBaiEgIARBBGtBFW5BAWohISAEQQNrQRVuQQFqISIgBEECa0EVbkEBaiEjIARBAWtBFW5BAWohJEMAAPhBIAAqApgBlSEmQQAhBQNAIAVBAnQiACAHTw0DIABBAXIiASAHTw0EIABBAnIiCCAHTw0FIABBA3IiCSAHTw0HIAogAEECdGooAgAhACAGIAogAUECdGooAgA2AgggBiAANgIEIAYgCiAJQQJ0aigCADYCECAGIAogCEECdGooAgA2AgxBACEMIAZBHGoiDkEAQdQA/AsAIAVBFWwhASAFQQFqQQYhAEEAIQsDQCAGQQRqIABBBmsiD0EDdkH8////AXFqIiUoAgAgD0EecXYhCCAOIA9B4AFxQSBqIABJBH8gC0EPSw0IICUoAgQgDEEecXQgCHIFIAgLQRp0QRp1siAmlTgCACAAQQZqIQAgDEEGayEMIA5BBGohDiALQQFqIgtBFUcNAAsgBSAkRg0KIAYqAmwhJyAGKgJoISggBioCZCEpIAYqAmAhKiAGKgJcISsgBioCWCEsIAYqAlQhLSAGKgJQIS4gBioCTCEvIAYqAkghMCAGKgJEITEgBioCQCEyIAYqAjwhMyAGKgI4ITQgBioCNCE1IAYqAjAhNiAGKgIsITcgBioCKCE4IAYqAiQhOSAGKgIgITogAyABQQJ0aiAGKgIcOAIAIAFBAWohACAFICNGBEAgACEBDAsLIAMgAEECdGogOjgCACABQQJqIQAgBSAiRgRAIAAhAQwLCyADIABBAnRqIDk4AgAgAUEDaiEAIAUgIUYEQCAAIQEMCwsgAyAAQQJ0aiA4OAIAIAFBBGohACAFICBGBEAgACEBDAsLIAMgAEECdGogNzgCACABQQVqIQAgBSAfRgRAIAAhAQwLCyADIABBAnRqIDY4AgAgAUEGaiEAIAUgHkYEQCAAIQEMCwsgAyAAQQJ0aiA1OAIAIAFBB2ohACAFIB1GBEAgACEBDAsLIAMgAEECdGogNDgCACABQQhqIQAgBSAcRgRAIAAhAQwLCyADIABBAnRqIDM4AgAgAUEJaiEAIAUgG0YEQCAAIQEMCwsgAyAAQQJ0aiAyOAIAIAFBCmohACAFIBpGBEAgACEBDAsLIAMgAEECdGogMTgCACABQQtqIQAgBSAZRgRAIAAhAQwLCyADIABBAnRqIDA4AgAgAUEMaiEAIAUgGEYEQCAAIQEMCwsgAyAAQQJ0aiAvOAIAIAFBDWohACAFIBdGBEAgACEBDAsLIAMgAEECdGogLjgCACABQQ5qIQAgBSAWRgRAIAAhAQwLCyADIABBAnRqIC04AgAgAUEPaiEAIAUgFUYEQCAAIQEMCwsgAyAAQQJ0aiAsOAIAIAFBEGohACAFIBRGBEAgACEBDAsLIAMgAEECdGogKzgCACABQRFqIQAgBSATRgRAIAAhAQwLCyADIABBAnRqICo4AgAgAUESaiEAIAUgEkYEQCAAIQEMCwsgAyAAQQJ0aiApOAIAIAFBE2ohACAFIBFGBEAgACEBDAsLIAMgAEECdGogKDgCACABQRRqIQEgBSAQRg0KIAMgAUECdGogJzgCACIFIAJHDQALDAcLQQAgByAIQfzrwAAQ6gcAC0EAIAEgB0GM1cAAEOoHAAsgACAHQbzUwAAQjAcACyABIAdBzNTAABCMBwALIAggB0Hc1MAAEIwHAAtBBEEEQfDPxwAQjAcACyAJIAdB7NTAABCMBwALIA1BhAhJDQAgDRCbBwsgBkHwAGokAA8LIAEgBEH81MAAEIwHAAsgBkEANgIcQQAgBkEUaiAGQRhqIAZBHGpB4PnEABD1BwALvxECE38EfiMAQSBrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBFSABKAIAIgZBgICAgHhzIAZBAE4bQRRrDgIBAgALIAEgAkEfakGE48AAEJUIIQEgAEECNgIAIAAgATYCBAwKCyABKAIMIgNFDQIgAkEEaiABKAIIIgcQoAQgAigCCCEGIAIoAgQiCkGAgICAeEYEQCAGIQEMCQsgAigCFCEJIAIoAhAhBSADQQFGDQEgAigCGCEMIAIoAgwhDSACQQRqIgsgB0EQahDTAiACKAIIIQEgAigCBA0HAkACQAJAIANBAkcEQCACKQIMIRUgCyAHQSBqENMCIAIoAgghCyACKAIEBEAgCyEBDAwLIANBA0YNASACKQIMIRYCQAJAAkBBFSAHQTBqIg4oAgAiD0GAgICAeHMgD0EAThtBEGsOAwYBBgALIAJBBGogDhCfBQwBCyACQQRqIAcoAjQQnwULIAIoAgwhECACKAIIIQQgAigCBEUNAiAEIQEMCwtBAkHA/cAAQYD9wAAQ2wYhAQwKC0EDQcD9wABBgP3AABDbBiEBDAkLQQEhCAsgA0EERwRAIAJBBDYCBCADQfz///8AakH/////AHFBBGogAkEEakHolcEAENsGIQEgAEECNgIAIAAgATYCBCAKBEAgBiAKQQEQogcLIAVFDQogCSAFQQEQogcMCgsgACAWNwI0IAAgCzYCMCAAIBU3AiggACABNgIkIAAgDDYCICAAIAk2AhwgACAFNgIYIAAgDTYCFCAAIAY2AhAgACAKNgIMIAAgEDYCCCAAIAQ2AgQgACAINgIADAkLIAEoAggiBkUNAyAGQQV0IRIgASgCBCETQQAhBkECIQVBgICAgHghBwNAAkACQAJAAkACQAJAAkACQEEVIA4gE2oiASgCACIDQYCAgIB4cyADQQBOG0EBaw4PAQAAAgAAAAAAAAADBAUGAAsgASACQR9qQZTkwAAQlQghAyACQQE6AAQgAiADNgIIDAYLIAJBADoABCACQQQgAUEEai0AACIDIANBBE8bOgAFDAULIAJBADoABCACQgQgAUEIaikDACIVIBVCBFobPAAFDAQLIAFBCGooAgAhAwJ/AkACQAJAAkAgAUEMaigCAEEEaw4CAQADCyADQZD9wABBBRDbBw0BQQAMAwtBASADKAAAQe3SuZsHRg0CGiADKAAAQe3C4ZsHRw0BQQIMAgsgA0Gd/cAAQQUQ2wcNAEEDDAELQQQLIQMgAkEAOgAEIAIgAzoABQwDCyABQQRqKAIAIQMCfwJAAkACQAJAIAFBCGooAgBBBGsOAgEAAwsgA0GQ/cAAQQUQ2wcNAUEADAMLQQEgAygAAEHt0rmbB0YNAhogAygAAEHtwuGbB0cNAUECDAILIANBnf3AAEEFENsHDQBBAwwBC0EECyEDIAJBADoABCACIAM6AAUMAgsgAkEEaiABQQhqKAIAIAFBDGooAgAQ2QUMAQsgAkEEaiABQQRqKAIAIAFBCGooAgAQ2QULIAItAARBAUYEQCACKAIIIQRBASEFDAYLIAFBEGohAwJAAkACQAJAAkACQAJAIAItAAUOBAABAgMGCyAHQYCAgIB4RwRAQQEhBUGQ/cAAQQUQnwchBAwMCyACQQRqIAMQoAQgAigCCCEIIAIoAgQiB0GAgICAeEYEQCAIIQQMDQsgAigCGCEQIAIoAhQhDCACKAIQIQkgAigCDCERDAULIAYNAiACQQRqIAMQ0wIgAigCCCEEIAIoAgRBAUYEQEEBIQUMCwsgAikCDCEWQQEhBgwECyAPDQIgAkEEaiADENMCIAIoAgghCyACKAIEQQFGBEBBASEFIAshBAwKCyACKQIMIRdBASEPDAMLIAVBAkcEQEEBIQVBnf3AAEEFEJ8HIQQMCQtBACEFAkACfwJAAkBBFSADKAIAIhRBgICAgHhzIBRBAE4bQRBrDgMDAQMACyACQQRqIAMQnwUgDSACKAIMIAIoAgQiARsMAQsgAkEEaiABQRRqKAIAEJ8FIA0gAigCDCACKAIEIgEbCyENIAIoAgghCkEBIQUgAUUNACAKIQQMCQsgCq0gDa1CIIaEIRgMAgtBASEFQZX9wABBBBCfByEEDAcLQQEhBUGZ/cAAQQQQnwchBAwGCyAOQSBqIg4gEkcNAAsMAgtBAUHA/cAAQYD9wAAQ2wYhAQwFC0EAQcD9wABBgP3AABDbBiEBDAULIAdBgICAgHhGDQAgAiAQNgIYIAIgDDYCFCACIAk2AhAgAiARNgIMIAIgCDYCCCACIAc2AgQgBkEAIA8bRQRAQZn9wABBlf3AACAGG0EEEJwHIQQgAkEEahDmBUEAIQUMAgsgACAXNwI0IAAgCzYCMCAAIBY3AiggACAENgIkIAAgEDYCICAAIAw2AhwgACAJNgIYIAAgETYCFCAAIAg2AhAgACAHNgIMIABCACAYIAVBAkYiARsiFT4CBCAAQQAgBSABGzYCACAAIBVCIIg+AggMBQtBgICAgHghB0EBIQVBkP3AAEEFEJwHIQQLIAVFIAdBgICAgHhGcg0AIAcEQCAIQQRrKAIAIgFBeHEiBkEEQQggAUEDcSIBGyAHakkNBSABQQAgBiAHQSdqSxsNBiAIEKICCyAJRQ0AIAxBBGsoAgAiAUF4cSIIQQRBCCABQQNxIgEbIAlqSQ0EIAFBACAIIAlBJ2pLGw0FIAwQogILIAAgBDYCBCAAQQI2AgAMAgsgCgRAIAZBBGsoAgAiBEF4cSIIQQRBCCAEQQNxIgQbIApqSQ0DIARBACAIIApBJ2pLGw0EIAYQogILIAVFDQAgCUEEaygCACIEQXhxIghBBEEIIARBA3EiBBsgBWpJDQIgBEEAIAggBUEnaksbDQMgCRCiAgsgACABNgIEIABBAjYCAAsgAkEgaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALqBECB30QfyMAQSBrIgwkACAAEKMFIABBwAFqQQA6AAAgAEIANwK4ASAAIAIQ0AQCQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAn8CQAJAAkACQAJ/AkACQAJAAkACQCAAKAIAQQFHDQAgACgCCEUNACACQQJ0Ig0gACgCfCIRSw0SIA0gACgCiAEiEksNEyAAKAJ4IRQgACgChAEhFiAMIAAoAgQiGSABQQJ0IhcgASACakECdCIYEOEIIgEQuAoiDjYCACAMIA02AgQgDSAORw0YIBQgDSABEOEJIAFBhAhPBEAgARCbBwsgAgRAIBRBDGohGiANQQJrIRsgAkH/////A3EhFUEAIQFBACEOA0AgASAETw0WIAFBAWoiDyAETw0XIAFBAmoiDyAETw0YIBVFDRlDAAB/QyADQQRqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgAyoCACIJiyIGIAUgA0EIaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIPQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByATIBpqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgD0EbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACABQQNqIARPDQMgAUEEaiAETw0IIAFBBWogBE8NDSANIA5GDRNDAAB/QyADQRBqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgA0EMaioCACIJiyIGIAUgA0EUaioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIQQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByATIBZqIg9DAAB/QyAGIAWVIgYgBkMAAH9DXhsQuQf8ASAQQRt0QYCAgAhBACAJQwAAAABdG3JBgICAEEEAIAhDAAAAAF0bckGAgIAgQQAgCkMAAAAAXRtyciAH/AFBCHRyQwAAf0MgCyAFlSIFIAVDAAB/Q14bELkH/AFBEHRyNgIAIAFBBmogBE8NBCABQQdqIARPDQkgAUEIaiAETw0OQwAAf0MgA0EcaioCACIIiyIFQwAAgD9DAAD4QUMAAAAAIANBGGoqAgAiCYsiBiAFIANBIGoqAgAiCosiCxDgCBDgCBCeBY5DAABwQZIiBSAFQwAAAABdGyIFIAVDAAD4QV4bELkH/AAiEEEPaxCwBkMAAH9DlSIFlSIHIAdDAAB/Q14bELkHIQcgD0EEakMAAH9DIAYgBZUiBiAGQwAAf0NeGxC5B/wBIBBBG3RBgICACEEAIAlDAAAAAF0bckGAgIAQQQAgCEMAAAAAXRtyQYCAgCBBACAKQwAAAABdG3JyIAf8AUEIdHJDAAB/QyALIAWVIgUgBUMAAH9DXhsQuQf8AUEQdHI2AgAgAUEJaiAETw0FIAFBCmogBE8NCiABQQtqIARPDQ8gDiAbRg0SQwAAf0MgA0EoaioCACIIiyIFQwAAgD9DAAD4QUMAAAAAIANBJGoqAgAiCYsiBiAFIANBLGoqAgAiCosiCxDgCBDgCBCeBY5DAABwQZIiBSAFQwAAAABdGyIFIAVDAAD4QV4bELkH/AAiEEEPaxCwBkMAAH9DlSIFlSIHIAdDAAB/Q14bELkHIQcgD0EIakMAAH9DIAYgBZUiBiAGQwAAf0NeGxC5B/wBIBBBG3RBgICACEEAIAlDAAAAAF0bckGAgIAQQQAgCEMAAAAAXRtyQYCAgCBBACAKQwAAAABdG3JyIAf8AUEIdHJDAAB/QyALIAWVIgUgBUMAAH9DXhsQuQf8AUEQdHI2AgAgAUEMaiAETw0GIAFBDWogBE8NCyABQQ5qIARPDRBDAAB/QyADQTRqKgIAIgiLIgVDAACAP0MAAPhBQwAAAAAgA0EwaioCACIJiyIGIAUgA0E4aioCACIKiyILEOAIEOAIEJ4FjkMAAHBBkiIFIAVDAAAAAF0bIgUgBUMAAPhBXhsQuQf8ACIQQQ9rELAGQwAAf0OVIgWVIgcgB0MAAH9DXhsQuQchByAPQQxqQwAAf0MgBiAFlSIGIAZDAAB/Q14bELkH/AEgEEEbdEGAgIAIQQAgCUMAAAAAXRtyQYCAgBBBACAIQwAAAABdG3JBgICAIEEAIApDAAAAAF0bcnIgB/wBQQh0ckMAAH9DIAsgBZUiBSAFQwAAf0NeGxC5B/wBQRB0cjYCACADQTxqIQMgAUEPaiEBIBNBEGohEyAVQQFrIRUgDkEEaiEOIAJBAWsiAg0ACwsgDCAZIBcgGBDhCCIBELgKIgI2AgAgDCARNgIEIAIgEUcNGCABIBQgERDgCSABQYQITwRAIAEQmwcLIAwgACgCDCAXIBgQ4QgiABC4CiIBNgIAIAwgEjYCBCABIBJHDRggACAWIBIQ4AkgAEGECEkNACAAEJsHCyAMQSBqJAAPCyABQQNqDAMLIAFBBmoMAgsgAUEJagwBCyABQQxqCyAEQdi8wQAQjAcACyABQQRqDAMLIAFBB2oMAgsgAUEKagwBCyABQQ1qCyAEQei8wQAQjAcACyABQQVqDAMLIAFBCGoMAgsgAUELagwBCyABQQ5qCyAEQfi8wQAQjAcACyAOQQJqIQ4LIA4gDUGIvcEAEIwHAAtBACANIBFBmL3BABDqBwALQQAgDSASQYi8wQAQ6gcACyABIARBmLzBABCMBwALIA8gBEGovMEAEIwHAAsgDyAEQbi8wQAQjAcACyAOQQNqIA1ByLzBABCMBwALIAxBADYCCEEAIAwgDEEEaiAMQQhqQeD5xAAQ9QcAC/8SAwt/BH4CeyMAQaACayIEJAACQCABKAIQIgUoAjAgAk0EQCAAQgM3AwAgAEGEgICAeDYCCAwBCyAFKAIsIAJBuAFsaiEGAkACQCADLQAIRQRAIAYtAKABIQUgAygCACICRQ0BIAVBAXENAgtBACECIANBADYCAAwBC0EAIQIgBUEBcUUNACAAQSE2AhAgAEHknccANgIMIABBg4CAgHg2AgggAEIDNwMADAELAkACQCAGLQBoQQNGBEAgBikDYCERDAELIAEoAgQiBa0hEAJAAkAgBUL/////DyAGKQNQIg8gD0L/////D1obp2siCEEAIAUgCE8bQR1NBEBBqJDIACkDACIRpyECAkAgEUL/AYNCBFEEQCABIA9CHnw3AwggAkH/AXFBBEcNAQwDCyABIBA3AwggAkH/AXFBBEYNAgsgEUIgiKchASARQgiIpyIFIQMCQAJAAkACQCACQf8BcSIIQQFrDgMBAAACCyABLQAIIQMLIANB/wFxQSVGDQELIAQgATYCUCAEQYGAgIB4NgJIIAQgBUEIdCAIcjYCTAwFCyAEQR42AiQgBEGFnscANgIgIAQgBEEgaq1CgICAgCCENwMYIARCATcCrAEgBEEBNgKkASAEQbiexwA2AqABIAQgBEEYajYCqAEgBEHIAGogBEGgAWoQ7AMgAkH/AXFBA0cNBCABKAIAIQIgAUEEaigCACIDKAIAIgUEQCACIAURAwALIAMoAgQiBQRAIAIgBSADKAIIEKIHCyABQQxBBBCiBwwECyABIA9CHnwiETcDCCABKAIAIA8gECAPIBBUG6dqIgUoAABB0JaNIEYNAQsgBEHQAGpB5J7HACgCADYCACAEQdyexwApAgA3A0gMAgsgBTMAHCEPIAUzABohECAEQgE3A6ABIAQgDyAQIBF8fCIRNwOoASAGQeAAaiAEQaABahDIBgsgASARNwMIIAQgBikDQCIPNwNAIAQgDzcDOEGDgICAeCEFAn4CQAJAIAYvAYQBIgdBAkYEQEHgnMcAIQFBICECDAELIAQpAjwhECAPQiCIpyEKIA+nIQggBjMBICEPAn8CQAJAAkAgAgRAIA9QDQFBmIvBACEBQccAIQIMBQsgD1ANAUGFgICAeCEFDAQLIAMoAgQhBwJAIAYtAKIBIgxFBEAgBi0AiwEhCwwBCyAGLwGYAUEBcQ0CC0EADAILQgAMBAsgBi0AnQELIQ0CQCAHRQRAQfis0ZEBIQNBic+VmgIhCUGQ8dmiAyEFDAELQZDx2aIDIQVBic+VmgIhCUH4rNGRASEDA0AgBUH/AXEgAi0AACADc0H/AXFBAnQoAvC9SCADQQh2cyIDQf8BcSAJakGFiKLAAGxBAWoiCUEYdnNBAnQoAvC9SCAFQQh2cyEFIAJBAWohAiAHQQFrIgcNAAsLIAQgBTYCwAEgBCAJNgK8ASAEIAM2ArgBIAQgCjYCrAEgBCAQNwKkASAEIAg2AqABIAQgATYCsAEgBEHQAGpBADYCAEIAIRAgBEIANwNIAkACQAJAIAQpA6gBIg9QRQRAIAEoAgAhCiABKAIEIgWtIRAgBEHIAGohB0EMIQMCfgNAIAogESAQIBAgEVYbpyIIaiEJAkAgBSAIayICIA8gA60iEiAPIBJUG6ciDiACIA5JGyICQQFGBEAgByAJLQAAOgAADAELIAJFDQAgByAJIAL8CgAACyAPIAKtIhJ9IQ8gESASfCERIA8gBSAIRg0BGiADIAJrIgNFDQMgAiAHaiEHIA9QRQ0AC0IACyEQIAEgETcDCAsgBCAQNwOoAUGBgICAeCEFQaiQyAApAwAiEEL/AYNCBFENAQwCCyABIBE3AwggBCAPNwOoAQsgBEG4AWoiASAELQBIEM8GGiABIAQtAEkQzwYaIAEgBC0AShDPBhogASAELQBLEM8GGiABIAQtAEwQzwYaIAEgBC0ATRDPBhogASAELQBOEM8GGiABIAQtAE8QzwYaIAEgBC0AUBDPBhogASAELQBREM8GGiABIAQtAFIQzwYaIAEgBC0AUxDPBiECAkACQCAMBEAgAkH/AXEgDUcNAQwCCyACQf8BcSALRg0BC0GFgICAeCEFDAELIAQgAf0AAgD9CwM4IAQpAqQBIRAgBCgCoAEhCCAEKAKwASIBDQIgCCEFCyAQQiCIpyECIBCnIQELIAAgAjYCECAAIAE2AgwgACAFNgIIIABCAzcDAAwDCyAEKAK0ASEDIAQoAqwBIQogBCAE/QADOP0LAyggBi8BhAEhB0IBCyERIAYoAogBIQsCQAJAQYDAABBxIgVFDQAgEEIgiKchAiAQpyEJAn8CQAJAIAdB//8DcUEBaw4CAQQACyAEIAT9AAMo/QsDkAH9DAAAAAAAIAAAAAAAAAAAAAAgBf0cACETIAj9ESAJ/RwBIAL9HAIgCv0cAyEUQgIhD0EADAELIAQgAzYCtAEgBCABNgKwASAEIAo2AqwBIAQgAjYCqAEgBCAJNgKkASAEIAg2AqABIAQgBP0AAyj9CwO4ASAEQcgBahCZBCAEQeAAaiAEQfABav0AAwD9CwMAIARB8ABqIARBgAJq/QADAP0LAwAgBEGAAWogBEGQAmr9AAMA/QsDACAEIAT9AAPYAf0LA5ABIAQgBCkD6AE3A1ggBEHAAWr9AAQAIRQgBCgC1AEhAyAEKALQASEBIAQoArQBIQkgBP0ABKABIRMgESEPIAQpA7gBIREgBCgCsAELIQdBuAEQcSICRQ0AIAIgAzYCVCACIAE2AlAgAiAU/QsDQCACIBE3AzggAiAJNgI0IAIgBzYCMCACIBP9CwMgIAIgDzcDGCACQgA3AgwgAkKAwAA3AgQgAiAFNgIAIAIgBP0AA5AB/QsDWCACIAQpA1g3A2ggAkHwAGogBEHgAGr9AAMA/QsDACACQYABaiAEQfAAav0AAwD9CwMAIAJBkAFqIARBgAFq/QADAP0LAwAgAkEBOgC0ASACIAs2ArABIAJBADYCqAEgAkIANwOgASAAQgI3AwAgACAGNgIIIABBAjYCqAEgACACNgKsAQwDCwALIAVBgMAAQQEQogcgAEEgNgIQIABB4JzHADYCDCAAQYOAgIB4NgIIIABCAzcDAAwBCyAEIAQpAEk3AA0gBCAELQBIOgAMIAQgBC0AUzoAFyAEIAQvAFE7ABUgBCgCDCEBIAAgBCkCEDcCDCAAIAE2AgggAEIDNwMACyAEQaACaiQAC6UQAQ5/IwBBgAhrIgMkAAJAIAFBA2pBfHEgAWsiBCACSwRAQQEhDkEEIQsMAQsgASAEaiILIAIgBGsiAkF8cWohDiACQQNxIQ8gAkECdiEIIAQhAgsgAEF/cyEAAkAgAkUNAEEAIQQgAkEBRwRAIAJBAXEgAkF+cSECA0AgASAEaiIHQQFqLQAAIActAAAgAHNB/wFxQQJ0KALwvUggAEEIdnMiAHNB/wFxQQJ0KALwvUggAEEIdnMhACACIARBAmoiBEcNAAtFDQELIAEgBGotAAAgAHNB/wFxQQJ0KALwvUggAEEIdnMhAAtBACEFIAhBBW4iAUEBayICQQAgASACTxshCQJAIAhBCkkEQEEAIQcMAQtBACECIAshBEEAIQcDQAJAAkAgAiAITw0AIAggAmsiBkEAIAYgCE0bIgZBAUcEQCAGQQJHBEAgBkEDRwRAIAZBBEcNBCACQQRqIQIMAwsgAkEDaiECDAILIAJBAmohAgwBCyACQQFqIQILIAIgCEHgvcgAEIwHAAsgByAEQQhqKAIAcyIHQf8BcUECdCgC0J1IIAdBBnZB/AdxKALQpUhzIAdBDnZB/AdxKALQrUhzIAdBFnZB/AdxKALQtUhzIQcgBSAEQQRqKAIAcyIFQf8BcUECdCgC0J1IIAVBBnZB/AdxKALQpUhzIAVBDnZB/AdxKALQrUhzIAVBFnZB/AdxKALQtUhzIQUgACAEKAIAcyIAQf8BcUECdCgC0J1IIABBBnZB/AdxKALQpUhzIABBDnZB/AdxKALQrUhzIABBFnZB/AdxKALQtUhzIQAgDCAEQRBqKAIAcyIMQf8BcUECdCgC0J1IIAxBBnZB/AdxKALQpUhzIAxBDnZB/AdxKALQrUhzIAxBFnZB/AdxKALQtUhzIQwgBEEMaigCACAKcyIKQf8BcUECdCgC0J1IIApBBnZB/AdxKALQpUhzIApBDnZB/AdxKALQrUhzIApBFnZB/AdxKALQtUhzIQogAkEFaiECIARBFGohBCANQQFqIg0gCUkNAAsLIAlBBWwiAiAITQRAAkAgAiAIRg0AIAsgAkECdGoiBCgCACEJQQAiBkUEQCADQfDFyABBgAj8CgAACyADIAAgCXMiAEH/AXFBAnRqKAIAIQkgBkUEQCADQfDNyABBgAj8CgAACyADIABBBnZB/AdxaigCACENIAZFBEAgA0Hw1cgAQYAI/AoAAAsgAyAAQQ52QfwHcWooAgAhECAGRQRAIANB8N3IAEGACPwKAAALIAMgAEEWdkH8B3FqKAIAIAkgDXMgEHNzIQAgCCACayICQQFGDQAgBCgCBCEJQQBFBEAgA0HwxcgAQYAI/AoAAAsgAyAFIAlzIABzIgBB/wFxQQJ0aigCACEFIAZFBEAgA0HwzcgAQYAI/AoAAAsgAyAAQQZ2QfwHcWooAgAhCSAGRQRAIANB8NXIAEGACPwKAAALIAMgAEEOdkH8B3FqKAIAIQ0gBkUEQCADQfDdyABBgAj8CgAACyADIABBFnZB/AdxaigCACAFIAlzIA1zcyEAIAJBAkYNACAEKAIIIQZBACIFRQRAIANB8MXIAEGACPwKAAALIAMgBiAHcyAAcyIAQf8BcUECdGooAgAhByAFRQRAIANB8M3IAEGACPwKAAALIAMgAEEGdkH8B3FqKAIAIQYgBUUEQCADQfDVyABBgAj8CgAACyADIABBDnZB/AdxaigCACEJIAVFBEAgA0Hw3cgAQYAI/AoAAAsgAyAAQRZ2QfwHcWooAgAgBiAHcyAJc3MhACACQQNGDQAgBCgCDCEHQQBFBEAgA0HwxcgAQYAI/AoAAAsgAyAHIApzIABzIgBB/wFxQQJ0aigCACEHIAVFBEAgA0HwzcgAQYAI/AoAAAsgAyAAQQZ2QfwHcWooAgAhCiAFRQRAIANB8NXIAEGACPwKAAALIAMgAEEOdkH8B3FqKAIAIQYgBUUEQCADQfDdyABBgAj8CgAACyADIABBFnZB/AdxaigCACAHIApzIAZzcyEAIAJBBEYNACAEKAIQIQVBACIERQRAIANB8MXIAEGACPwKAAALIAMgBSAMcyAAcyIAQf8BcUECdGooAgAhBSAERQRAIANB8M3IAEGACPwKAAALIAMgAEEGdkH8B3FqKAIAIQcgBEUEQCADQfDVyABBgAj8CgAACyADIABBDnZB/AdxaigCACEKIARFBEAgA0Hw3cgAQYAI/AoAAAsgAyAAQRZ2QfwHcWooAgAgBSAHcyAKc3MhACACQQVGDQAgAUEUbEEBIAEgARsiBEEUbGsgC2pBFGohAiAIIARBBWxqIAFBBWxrQQVrIQEDQCACKAIAIQtBACIERQRAIANB8MXIAEGACPwKAAALIAMgACALcyIAQf8BcUECdGooAgAhCyAERQRAIANB8M3IAEGACPwKAAALIAMgAEEGdkH8B3FqKAIAIQggBEUEQCADQfDVyABBgAj8CgAACyADIABBDnZB/AdxaigCACEFIARFBEAgA0Hw3cgAQYAI/AoAAAsgAyAAQRZ2QfwHcWooAgAgCCALcyAFc3MhACACQQRqIQIgAUEBayIBDQALCwJAIA9FDQAgDi0AACAAc0H/AXFBAnQoAvC9SCAAQQh2cyEAIA9BAUYNACAOLQABIABzQf8BcUECdCgC8L1IIABBCHZzIQAgD0ECRg0AIA4tAAIgAHNB/wFxQQJ0KALwvUggAEEIdnMhAAsgA0GACGokACAAQX9zDwsgAiAIIAhB0L3IABDqBwALsB8DDn8HfgN7IwBBIGsiDyQAAkACQCABQSFPBEADQCADRQRAIAEiAiACQQF2aiIGBEAgACEDA0ACQAJ/IAIgBkEBayIGTQRAIAYgAmsMAQsgA0EQaiIA/QADACEaIAMgBkEFdGoiAf0AAwAhGyAAIAFBEGoiAP0AAwD9CwMAIAP9AAMAIRkgAyAb/QsDACABIBn9CwMAIAAgGv0LAwBBAAsiAUEBdCIFQQFyIgAgAiAGIAIgBkkbIgdPDQADQCAFQQJqIgUgB0kEQAJ/AkAgAyAAQQV0aiIEKQMIIhMgAyAFQQV0aiIFKQMIIhJSDQAgBCkDECITIAUpAxAiElINAEEAIAQpAxgiEyAFKQMYIhJRDQEaCyASIBNWCyAAaiEACyADIABBBXRqIggpAxghFyADIAFBBXRqIgQpAxghFiAEKQMIIhQhEyAIKQMIIhghEgJAIBQgGFINACAEKQMQIhMgCCkDECISUg0AIBciEiAWIhNRDQILIBIgE1gNASAIKAIUIQUgCCgCECEBIAggBCkDEDcDECAEIBg+AgggCCAUPgIIIAQgGEIgiD4CDCAIIBRCIIg+AgwgBCAXPgIYIAggFj4CGCAEKQMAIRIgBCAIKQMANwMAIAggEjcDACAEIAE2AhAgBCAFNgIUIAQgF0IgiD4CHCAIIBZCIIg+AhwgACIBQQF0IgVBAXIiACAHSQ0ACwsgBg0ACwsMBAsgACABQQN2IgVB4AFsaiEGIAAgBUEHdGohBwJAIAFBwABPBEAgACAHIAYgBRDvBCEFDAELIAcpAxghGCAAKQMYIRcgACkDCCITIRUgBykDCCISIRQCfwJAIBIgE1INACAAKQMQIhUgBykDECIUUg0AQQAgGCIUIBciFVENARoLIBQgFVYLIQQgBikDGCEWIAYpAwgiFSEUAkACQCATIBVSDQAgACkDECITIAYpAxAiFFINACAXIhMgFiIUUg0AIAAhBSAERQ0BDAILIAAhBSAEIBMgFFRzDQELIAYgBwJ/AkAgEiAVUg0AIAcpAxAiEiAGKQMQIhVSDQBBACAYIhIgFiIVUQ0BGgsgEiAVVAsgBHMbIQULIANBAWshAyAFIABrIQUCfwJAIAJFDQACQAJAIAIpAwgiEyAAIAVqIgQpAwgiElINACACKQMQIhMgBCkDECISUg0AIAIpAxgiEyAEKQMYIhJRDQELIBIgE1YNAQsgD0EQaiIQIABBEGoiDv0AAwD9CwMAIA8gAP0AAwD9CwMAIAT9AAMAIRkgDiAEQRBqIgL9AAMA/QsDACAAIBn9CwMAIAIgEP0AAwD9CwMAIAQgD/0AAwD9CwMAQSAhBSAAQSBqIQogACABQQV0IgZqIQkgDikDACEXIABBGGopAwAhFiAAQQhqKQMAIRMgAP0AAzAhGiAA/QADICEbIAApAzghFEEAIQ1BACELA0AgBSEEIAAgDWoiAkFAayEMIAJBIGohCCATIRICfwJAIBMgAkHIAGopAwAiFVINACACQdAAaikDACIVIBciElINAEEBIAJB2ABqKQMAIhUgFiISUQ0BGgsgEiAVWgsgCiALQQV0aiIF/QADACEZIAhBEGogBUEQaiIC/QADAP0LAwAgCCAZ/QsDACACIAxBEGr9AAMA/QsDACAFIAz9AAMA/QsDACAEQSBqIQUgC2ohCyAAIA1BIGoiDWoiB0FAayICIAlJDQALIBv9HQEhGCACIAlGBH8gB0EgagUgBkFAaiEHA0AgACAEaiICQSBqIQwgAkFAayEIIBMhEgJ/AkAgEyACQcgAaikDACIVUg0AIAJB0ABqKQMAIhUgFyISUg0AQQEgAkHYAGopAwAiFSAWIhJRDQEaCyASIBVaCyAKIAtBBXRqIgb9AAMAIRkgDEEQaiAGQRBqIgL9AAMA/QsDACAMIBn9CwMAIAIgCEEQav0AAwD9CwMAIAYgCP0AAwD9CwMAIAtqIQsgByAEQSBqIgRHDQALIAAgBGpBIGoLIQQgCiALQQV0aiIF/QADACEZIARBEGogBUEQaiIC/QADAP0LAwAgBCAZ/QsDACACIBr9CwMAIAUgG/0LAwACfwJAIBMgGFINACAa/R0AIhggFyITUg0AQQEgFiITIBQiGFENARoLIBMgGFoLIAtqIgQgAU8NBCAQIA79AAMA/QsDACAPIAD9AAMA/QsDACAAIARBBXRqIgX9AAMAIRkgDiAFQRBqIgL9AAMA/QsDACAAIBn9CwMAIAIgEP0AAwD9CwMAIAUgD/0AAwD9CwMAIAEgBEEBaiICayEBIAAgAkEFdGohAEEADAELIA9BEGoiDiAAQRBqIhH9AAMA/QsDACAPIAD9AAMA/QsDACAAIAVqIgT9AAMAIRkgESAEQRBqIgX9AAMA/QsDACAAIBn9CwMAIAUgDv0AAwD9CwMAIAQgD/0AAwD9CwMAQSAhBSAAQSBqIRAgACABQQV0IghqIQogESkDACEXIABBGGopAwAhFiAAQQhqKQMAIRMgAP0AAzAhGiAA/QADICEbIAApAzghFEEAIQ1BACELA0AgBSEEIAAgDWoiBUFAayEJIAVBIGohDCATIRICfwJAIAVByABqKQMAIhUgE1INACAXIhIgBUHQAGopAwAiFVINAEEAIBYiEiAFQdgAaikDACIVUQ0BGgsgEiAVVgsgECALQQV0aiIG/QADACEZIAxBEGogBkEQaiIF/QADAP0LAwAgDCAZ/QsDACAFIAlBEGr9AAMA/QsDACAGIAn9AAMA/QsDACAEQSBqIQUgC2ohCyAAIA1BIGoiDWoiBkFAayIHIApJDQALIBv9HQEhGCAHIApGBH8gBkEgagUgCEFAaiEGA0AgACAEaiIFQSBqIQkgBUFAayEMIBMhEgJ/AkAgBUHIAGopAwAiFSATUg0AIBciEiAFQdAAaikDACIVUg0AQQAgFiISIAVB2ABqKQMAIhVRDQEaCyASIBVWCyAQIAtBBXRqIgj9AAMAIRkgCUEQaiAIQRBqIgX9AAMA/QsDACAJIBn9CwMAIAUgDEEQav0AAwD9CwMAIAggDP0AAwD9CwMAIAtqIQsgBiAEQSBqIgRHDQALIAAgBGpBIGoLIQcgECALQQV0aiIE/QADACEZIAdBEGogBEEQaiIF/QADAP0LAwAgByAZ/QsDACAFIBr9CwMAIAQgG/0LAwACfwJAIBMgGFINACAXIhMgGv0dACIYUg0AQQAgFiITIBQiGFENARoLIBMgGFYLIAtqIgQgAU8NAyAOIBH9AAMA/QsDACAPIAD9AAMA/QsDACAAIARBBXRqIgf9AAMAIRkgESAHQRBqIgX9AAMA/QsDACAAIBn9CwMAIAUgDv0AAwD9CwMAIAcgD/0AAwD9CwMAIAAgBCACIAMQqgEgASAEQX9zaiEBIAdBIGohACAHCyECIAFBIU8NAAsLIAAhCiMAQYAMayIHJAACQCABIgxBAkkNAEEBIQIgACABQQF2Ig1BBXQiA2ohESADIAdqIQYCQCABQQhPBEAgACAHEK4DIBEgBhCuA0EEIQIMAQsgB0EQaiAKQRBq/QADAP0LAwAgByAK/QADAP0LAwAgBiAR/QADAP0LAwAgBkEQaiARQRBq/QADAP0LAwALIAIgDUkEQCACQQV0IQEgAkEBaiEFIAIhAANAIAAhAyAFIQAgByADQQV0IgNqIgQgAyAKaiIDKQMANwMAIARBGGogA0EYaikDACIWNwMAIARBEGogA0EQaikDADcDACAEQQhqIANBCGopAwAiEzcDAAJAAkAgBEEYaykDACIUIBMiElINACAEKQMQIhIgBEEQaykDACIUUg0AIARBCGspAwAiFCAWIhJRDQELIBIgFFoNACAEKQMQIRcgBCkDACEYIAEhBQNAAkAgBSAHaiIIIAhBIGsiA/0AAwD9CwMAIAhBEGogA0EQav0AAwD9CwMAIAVBIEYEQCAHIQMMAQsgBEEgayEEAkAgCEE4aykDACIUIBMiElINACAFIAdqQTBrKQMAIhQgFyISUg0AIAhBKGspAwAiFCAWIhJSDQAgBCEDDAELIAVBIGshBSASIBRUDQELCyADIBg3AwAgCEEIayAWNwMAIAhBEGsgFzcDACAIQRhrIBM3AwALIAFBIGohASAAIAAgDUkiA2ohBSADDQALCyAMIA1rIhAgAksEQCACQQV0IQ4gAkEBaiEFQSAhCCAGIQADQCACIQEgBSECIAYgAUEFdCIBaiIEIAEgEWoiASkDADcDACAEQRhqIAFBGGopAwAiFjcDACAEQRBqIAFBEGopAwA3AwAgBEEIaiABQQhqKQMAIhM3AwACQAJAIARBGGspAwAiFCATIhJSDQAgBCkDECISIARBEGspAwAiFFINACAEQQhrKQMAIhQgFiISUQ0BCyASIBRaDQAgBCkDECEXIAQpAwAhGCAIIQMgACEJA0ACQCAJIA5qIgUgBUEgayIB/QADAP0LAwAgBUEQaiABQRBq/QADAP0LAwAgAyAORgRAIAYhAQwBCyAEQSBrIQQCQCAFQThrKQMAIhQgEyISUg0AIAkgDmpBMGspAwAiFCAXIhJSDQAgBUEoaykDACIUIBYiElINACAEIQEMAQsgA0EgaiEDIAlBIGshCSASIBRUDQELCyABIBg3AwAgBUEIayAWNwMAIAVBEGsgFzcDACAFQRhrIBM3AwALIAhBIGshCCAAQSBqIQAgAiACIBBJIgFqIQUgAQ0ACwsgBkEgayEJIAogDEEFdEEgayIAaiEDIAAgB2ohBSAHIQQDQAJAAkACQCAGKQMIIhIgBCkDCCIUUg0AIAYpAxAiEiAEKQMQIhRSDQAgBikDGCISIAQpAxgiFFINACAKIAT9AAMA/QsDACAKQRBqIARBEGr9AAMA/QsDAAwBCyAKIAYgBCASIBRUGyIA/QADAP0LAwAgCkEQaiAAQRBq/QADAP0LAwAgEiAUWg0AIAZBIGohBgwBCyAEQSBqIQQLIApBIGohCiADAn8CQCAFKQMIIhIgCSkDCCIUUg0AIAUpAxAiEiAJKQMQIhRSDQBBACEBIAUgBSkDGCISIAkpAxgiFFENARoLIAkgBSASIBRUIgEbCyIA/QADAP0LAwAgA0EQaiAAQRBq/QADAP0LAwAgA0EgayEDIAkgAUEFdCIAayEJIAAgBWpBIGshBSANQQFrIg0NAAsgCUEgaiECIAxBAXEEfyAKIAQgBiACIARLIgEbIgD9AAMA/QsDACAKQRBqIABBEGr9AAMA/QsDACAGQQBBICABG2ohBiAEQSBBACABG2oFIAQLIAJGIAYgBUEgakZxDQAQgAgACyAHQYAMaiQADAELAAsgD0EgaiQAC/4PAhh/Bn4jAEEwayIGJAAgACgCPCERIAAoAjghAyAAKAI0IQEgACgCMCEEIAD9DAAAAAAAAAAAAQAAAAEAAAD9CwQwIAAoAkAhAiAAQQA2AkAgACgCSCEFIABBATYCSCAAKAJQIQogACgCTCELIABCADcCTCAGIAU2AgwgBiALNgIQIAYgCjYCFEGo58gAIQxBgAQhCAJAAkACQAJAIAAtAJgBQQFrDgMAAQIDCyAAQaQBaiEMQbQKIQgMAgsgAEH0KmohDEG0CiEIDAELIABBxNQAaiEMQdAEIQgLQaj3yAAhDkEgIQ0CQAJAAkACQCAALQCgAUEBaw4DAAECAwsgAEGkAWohDkG0CiENDAILIABB9CpqIQ5BtAohDQwBCyAAQcTUAGohDkHQBCENCyAAKAIMIgVBQGoiB0FBSQRAQn8gADUCnAGGQn8gADUClAGGQn+FIRwgBSAHSSEJIAJB/wFxQQlLBH8gAgUgBK0gAa1CIIaEIAMpAAAgAkEPca2GhCIapyEEIBpCIIinIQEgAyACQQN2QQFxQQdzaiEDIAJBOHILIQUgAEHIAGohEiACQYB+cSEVIAAoAkQhFiAAQQhqIRNCf4UhHkEAIAcgCRshECAcpyEUAkACQANAAkAgBCADKQAAIAWthiIZp3IhAgJAAkACQAJAAkACQAJAAkACQAJAAkAgBUH/AXEiFyAAKAKUAUkEQCAIIAIgFHEiBEsNASAEIAhBqPjIABCMBwALIAggBCAUcSIETQ0BCyAFQThyIQUgASAZQiCIp3IhDyAMIARBAnRqIgEtAAMhBCABLwEAIQkgAS0AAiIBRQ0BIAohBwwCCyAEIAhBuPjIABCMBwALIAogC08NASAGKAIMIhggCmogCToAACAGIApBAWoiBzYCFAJAIAKtIA+tQiCGhCAErYgiGSAcg6ciAiAISQRAIAUgBGshBSAMIAJBAnRqIgIvAQAhCSACLQADIQQgAi0AAiIBRQ0BIBlCIIinIQ8gGachAgwCCyACIAhByPjIABCMBwALIAcgC08NAiAHIBhqIAk6AAAgBiAKQQJqIgc2AhQgCCAZIAStiCIZIByDpyICTQ0DIAUgBGshBSAZQiCIpyEPIAwgAkECdGoiAi8BACEJIAItAAMhBCACLQACIQEgGachAgsgAyAXQQN2QQdzaiEDIAUgBGshBSACrSAPrUIghoQgBK2IIhpCIIghGSAapyEEIAFB/wFxRQ0FAkACQANAIAFBEHENAiABQcAAcQ0BIAkgGkJ/IAGtQi+DhkJ/hYOnakH//wNxIgIgCEkEQCAErSAZQiCGhCAMIAJBAnRqIgItAAMiAUE/ca2IIhpCIIghGSAapyEEIAUgAWshBSACLwEAIQkgAi0AAiIBRQ0JDAELCyACIAhB6PjIABCMBwALIAFBIHFFDQUgAEEMOgAADAgLIA0gGiABrUIPgyIdiCIZIB6DpyICSw0DIAIgDUH4+MgAEIwHAAsgCiALQbz/yAAQjAcACyAHIAtBvP/IABCMBwALIAIgCEHY+MgAEIwHAAsgDiACQQJ0aiIKLQADIQsgCi0AAiEEAn8gBSABQQ9xayIBQf8BcUEcTwRAIAEhBSADDAELIAFBOHIhBSADKQAAIAGthiAZhCEZIAMgAUH4AXFBA3ZBB3NqCyECIAovAQAhAyAFIAtrIQUgGSALrYghGwJAAkACQAJAIARBEHFFBEADQCAEQcAAcQ0DIA0gAyAbQn8gBK1CL4OGQn+Fg6dqQf//A3EiA00NAiAFIA4gA0ECdGoiAS0AAyIDayEFIBsgA0E/ca2IIRsgAS8BACEDIAEtAAIiBEEQcUUNAAsLIAkgGkJ/IB2GQn+Fg6dqIQkgBSAEQQ9xayEFIBsgBK1CD4MiGogiHUIgiCEZIB2nIQQgAyAbQn8gGoZCf4WDp2pB//8DcSIKIAdLDQIgBkEMaiAKIAlB//8DcRDsAiACIQMMBgsgAyANQYj5yAAQjAcACyAbpyEEQefQwAAhAUEWIQgMAQsCQAJAAkACQCAKIAdrIgEgACgCEE0EQCAAKAIUIgMNASAQIAFrIQcMBAsgAC0AAUEEcUUNAUHVz8AAIQFBHiEIDAQLIAEgA0sNASADIAFrIQcMAgsgBkEANgIoIAZBATYCHCAGQcT5yAA2AhggBkIENwIgIAZBGGpBzPnIABCNCAALIBAgASADayIBayEHIAEgCUH//wNxTw0AIAZBDGogEyAHIBAQlAUgCSABayEJQQAhByADIQELIAZBDGogEyAHIAEgCUH//wNxIgMgASADSRsgB2oQlAUgASADTwRAIAIhAwwECyAGQQxqIAogAyABaxDsAiACIQMMAwsgAEEeOgAADAULIABBHjoAAEHL0MAAIQFBHCEIIAMhAgwECyAHIAtPDQQgBigCDCAHaiAJOgAAIAYgB0EBajYCFAsgESADayAFQfgBcUEDdmpBDk0NACAZpyEBIAYoAhAiCyAGKAIUIgprQYMCSw0BCwtBACEBIAMhAgsgACAWNgJEIAAgETYCPCASIAYpAgw3AgAgACAVIAVBB3EiA3I2AkAgEkEIaiAGQRRqKAIANgIAIAAgAiAFQfgBcUEDdms2AjggACAEQX8gA3RBf3NxrTcDMCABBEAgACAINgKIASAAIAE2AoQBCyAGQTBqJAAPCyAHIAtBvP/IABCMBwALQeT8yABBygBBsP3IABDrBwALkBECCX8EfiMAQeACayIBJAACQAJAAkAgAC0A+ANFBEAgACgCkAEiAkECRw0CIAAoAgBBAkcNAiAAKAK4AiIDQQNLDQFBACECDAMLIAA1ArgCIQogAEEANgK4AiAAIAogACkDcHw3A3AMAgsgAEGQAWohBiABIAAoArQCIgQoAAAiAjYCEAJAAkACQAJAAkACQAJAAkAgAkHSgpGaBEcEQCACQdKCkYIDRw0CIANBCEkNASADIAQoAAQiBUEHakF4cUEIaiICSQ0BIAVBCGoiByADSyAFQXdLcg0DIAFBADYC2AIgASAFNgLUAiABIARBCGo2AtACIAFBIGogAUHQAmoQWSABKAIkIQUgASgCICIIQQJGBEAgBRDOByECDAsLIAFBsAFqIAFBKGpBgAH8CgAAIABBADYCuAIgASAFNgKsASABIAg2AqgBIAMgAmshBwJAAkAgAkUNACACIANGDQEgB0UNACAEIAIgBGogB/wKAAALIAAgBzYCuAILIAAgACkDcCACrXwiCjcDeCAAIAo3A3AgASgCpAJBAUcNBCAAIAEoApQCIgQ2ApwCIAAgASgCtAEgASgCwAEiAyABKAKwARsiAjYCoAIgAkUNBSAEIAMgAm4iBCACIARsIANHaiICRgRAIAEtAKgCIQIgASAFQQAgCEEBcRs2AiQgASADNgIgIAEgAkEBcSIDOgAoIABBvAJqIAFBIGoQpQQCQCABKALQASICQQJGDQAgAkEBcQRAIAAgASoC1AE4ArwDCyABKALYAUEBRgRAIAAgASoC3AE4AsADCyABKALgAUEBRgRAIAAgASoC5AE4AsQDCyABKALoAUEBRgRAIAAgASoC7AE4AsgDCyABKALwAUEBRgRAIAAgASoC9AE4AswDCyABKAL4AUEBRgRAIAAgASoC/AE4AtADCyABKAKAAkEBRgRAIAAgASoChAI4AtQDCyABLQCIAiICQQJGDQAgACACOgDYAwsgA0UNCCAAQQE6ANgDDAgLIAEgAjYCzAIgAUECNgIkIAFB6MfBADYCICABQgI3AiwgAUKAgICAECIKIABBnAJqrYQ3A9gCIAEgCiABQcwCaq2ENwPQAiABIAFB0AJqNgIoIAFBwAJqIgAgAUEgahCxBgwGCyABQQhqIAAQugIgAS0ACEUEQCABLQAJDQhBACECDAoLIAEoAgwhAgwJC0EAIQIMCAsgAUEBNgI0IAFBzMjBADYCMCABQQE2AiQgAUHEyMEANgIgIAFBATYCLCABIAFBEGqtQoCAgICQBIQ3A9ACIAEgAUHQAmo2AiggAUEUaiIAIAFBIGoQsQYgABCOByECDAcLQQggByADQZzIwQAQ6gcACyABQQE2AiQgAUGUyMEANgIgIAFCATcCLCABIAFBpAJqrUKAgICAEIQ3A9ACIAEgAUHQAmo2AiggAUG0AmoiACABQSBqELEGDAELQbTHwQAQgQgACyAAEI4HIQIgAUGoAWoQzwQMAwsCQAJAAkAgBigCAEECRg0AIAAoAvgBIQQgACgC/AEiAwRAIARBJGohAgNAIAJBBGsoAgAiBUGAgICAeHJBgICAgHhHBEAgAigCACIHQQRrKAIAIghBeHEiCUEEQQggCEEDcSIIGyAFakkNBCAIQQAgCSAFQSdqSxsNBSAHEKICCyACQTBqIQIgA0EBayIDDQALCyAAKAL0ASIDBEAgBCADQTBsQQgQogcLIAAoAoACIgNBgICAgHhyQYCAgIB4Rg0AIAAoAoQCIANBARCiBwsgBiABQagBakGIAfwKAAAMAgtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAYoAgAhAgsCQAJAAkACQAJ/AkAgAkECRwRAIAAoApgCIAAoApwCTw0GIAAoAgBBAkYNAUEADAILIAFBqAFqIAAQRSABKAKsAUEAIAEtAKgBIgMbIQIgAw0GIAEtAKkBQQFxRQ0GIAApA4gBIgwgACkDcCIKWARAIAAoArgCIQMMBQsgACgCuAIhBEEAIQMgAEEANgK4AiAEIAwgCn0iCyAErSINIAsgDVQbIgunIgZrIQIgC1BFBEAgBCAGRg0EIAJFDQMgACgCtAIiAyADIAZqIAL8CgAADAMLIAQgBkcNAgwDC0EBCyECA0ACQAJAAkACQAJAAkACQAJAAkACQAJAIAJFBEAgAUGoAWogABBFIAEoAqwBIQMgAS0AqAEiAg0CIAEtAKkBQQFxRQ0CIAApA4gBIgogACkDcCIMVg0BDAYLIAFBqAFqIAAQugIgAS0AqAFBAUYEQCABKAKsASECDBELIAEtAKkBDQlBACECDBALIAAoArgCIQMgAEEANgK4AiADIAogDH0iCyADrSINIAsgDVQbIgunIgJrIQQgC1ANASACIANGDQMgBEUNAiAAKAK0AiIDIAIgA2ogBPwKAAAMAgsgA0EAIAIbIQIMDgsgAiADRg0BCyAAIAQ2ArgCCyAAIAsgDHwiDDcDcCAKIAxWDQELAkAgACgCAEECRg0AIAAoAlwiA0UNACAAKAJgIgJBBGsoAgAiBEF4cSIGIANBKGwiA0EEQQggBEEDcSIEG2pJDQIgBEEAIAYgA0EnaksbDQMgAhCiAgsgAEECNgIAIAAgACgCmAJBAWoiAzYCmAIgAyAAKAKcAkkNBAwJC0EAIQIMCQtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQQAhAgwBC0EBIQIMAAsACyAAIAI2ArgCIAIhAwsgACAKIAt8Igo3A3AgCiAMWg0AQQAhAgwCC0EAIQIgAEEANgK4AiAAQQE6APgDIAAgCiADrXw3A3AMAQsgAEEBOgD4AyAANQK4AiEKQQAhAiAAQQA2ArgCIAAgCiAAKQNwfDcDcAsgAUHgAmokACACC4oQAhl/AXsjAEFAaiIJJAAgCUEQav0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgCSAh/QsDAAJAAkAgA0UNACACQQJBACADGyINaiEPIAIgA0EBdCISaiEaIBJBAmohCEEPIQsgAiEMAkACQAJAA0AgDC8BACIKBEAgCkEPSw0CIAkgCkEBdGoiDCAMLwEAQQFqOwEAIA4gCiAKIA5JGyEOIAsgCiAKIAtLGyELCyACIA1qIQwgCCANQQJqIg1HDQALIA5FDQMgCyAOTQRAIAkvAQIiCkECSw0CIAkvAQQiDEEEIApBAXRrIghB/v8DcUsNAiAJLwEGIhYgCCAMa0EBdCIIQf7/A3FLDQIgCS8BCCIbIAggFmtBAXQiCEH+/wNxSw0CIAkvAQoiHCAIIBtrQQF0IghB/v8DcUsNAiAJLwEMIg0gCCAca0EBdCIIQf7/A3FLDQIgCS8BDiIQIAggDWtBAXQiCEH+/wNxSw0CIAkvARAiESAIIBBrQQF0IghB/v8DcUsNAiAIIBFrQf//A3FBAXQiCCAJLwESIhNJDQIgCCATa0EBdCIIIAkvARQiFEkNAiAIIBRrQQF0IgggCS8BFiIVSQ0CIAggFWtBAXQiCCAJLwEYIhdJDQIgCCAXa0EBdCIIIAkvARoiGEkNAiAIIBhrQQF0IgggCS8BHCIZSQ0CIAggGWtBAXQiCCAJLwEeIh1JDQIgCCAdRiABQf8BcUEAIA5BAUYbckUEQCAAQX82AgAMBgsgCyAGIA4gBiAOSRsgBiALSRshCCAJQQA2AiAgCSAKOwEkIAkgCiAMaiIGOwEmIAkgBiAWaiIGOwEoIAkgBiAbaiIGOwEqIAkgBiAcaiIGOwEsIAkgBiANaiIGOwEuIAkgBiAQaiIGOwEwIAkgBiARaiIGOwEyIAkgBiATaiIGOwE0IAkgBiAUaiIGOwE2IAkgBiAVaiIGOwE4IAkgBiAXaiIGOwE6IAkgBiAYaiIGOwE8IAkgBiAZajsBPiASQQJrQQF2QQFqIQwgAiEGQQAhDQNAIA8hCgJAIAYvAQAiBkUNACAGQQ9NBEAgCUEgaiAGQQF0aiIGIAYvAQAiBkEBajsBACAGQaACSQRAIAcgBkEBdGogDTsBAAwCCyAGQaACQZSDyQAQjAcACyAGQRBBhIPJABCMBwALIApBAkEAIAogGkcbaiEPIAohBiAMIA1BAWoiDUcNAAtBFCEUIAFB/wFxIgEhF0EBIRhBAiEZAkACQAJAIAFBAWsOAgABAgsgCEELTw0FQbSAyQAhGUHygMkAIRhBHyEXQYECIRQMAQsgCEEJSw0EQZKByQAhGUHSgckAIRhBICEXQQAhFAtBASAIdCIVQQFrIR4gFEEBa0H//wNxIR8gAUEBayEgQQAhD0EAIRNBACEKQQAhECAIIRJBACERQX8hFgNAAkAgFCAHIAoiG0EBdGovAQAiAUsEQCABQQAgASAfSSIBGyEGQQBB4AAgARshAQwBCyABIBRrQf//A3EiBiAXSQRAIAYgGGotAAAhASAZIAZBAXRqLwEAIQYMAQsgBiAXQYSCyQAQjAcACyAEQX8gCyARayIddCIaQQEgEnQiHCAQIA8gEXZqamoiDUECdGohDCAaQQJ0IQ8gHCEKAkACQAJ/AkACQAJAAkACQAJAA0AgBSANTQ0BIAwgBjsBACAMQQNqIB06AAAgDEECaiABOgAAIAwgD2ohDCANIBpqIQ0gCiAaaiIKDQALIAtBD0sNAUGAgICAeCALQQFrdiATaiITQRh0IBNBgP4DcUEIdHIgE0EIdkGA/gNxIBNBGHZyciIBQQR2QY+evPgAcSABQY+evPgAcUEEdHIiAUECdkGz5syZA3EgAUGz5syZA3FBAnRyIgFBAXZB1arVqgVxIAFB1arVqgVxQQF0ciEPIBtBAWohCiAJIAtBAXRqIgEgAS8BAEEBayIBOwEAAkACQCABQf//A3FFBEAgCyAORg0BIBtBnwJGDQUgAyAHIApBAXRqLwEAIgFNDQYgAiABQQF0ai8BACELCyAIIAtPDQogDyAecSIBIBZHDQEMCgsgE0UNCCAFIBBJDQUgBSAQayIBIA9LBEAgBCAQQQJ0aiAPQQJ0aiIBIB06AAMgAUHAADoAAiABQQA7AQAMCQsgDyABQdSCyQAQjAcAC0EBIAsgESAIIBEbIhFrIhJ0Ig0gCyAOTw0GGiAOIBFrIRIgCSALQQF0aiEMIAshBgNAIA0gDC8BAGsiFkEATARAIAYgEWshEgwHCyAMQQJqIQwgFkEBdCENIAZBAWoiBiAOSQ0ACwwFCyANIAVBlILJABCMBwALIAtBEEGkgskAEIwHAAtBoAJBoAJBtILJABCMBwALIAEgA0HEgskAEIwHAAsgECAFIAVB5ILJABDqBwALQQEgEnQLIBVqIRUCQAJAAkAgIA4CAAECCyAVQbQKTQ0BDAgLIBVB0ARLDQcLIAEgBUkEQCAEIAFBAnRqIgYgCDoAAyAGIBI6AAIgBiAQIBxqIhA7AQAgASEWDAILIAEgBUH0gskAEIwHAAsgACAVNgIIIAAgCDYCBCAAQQA2AgAMBwsgCkGgAkcNAAtBoAJBoAJB9IHJABCMBwALQY2cyABBHEGsnMgAEOsHAAsgCkEQQaSDyQAQjAcACyAAQX82AgAMAgsgAEEBNgIADAELIABBAjYCCCAEQoCAgIqAgICgATcBACAAQoCAgIAQNwIACyAJQUBrJAALsBMEDX8KfQN7AX4jAEGgAmsiAiQAIAEqAgAhESABKgIEIQ8gAiABKgIIIhP9EyABKgIQIhD9IAAgASoCFCIS/SAB/QsEkAEgAiAS/RMgASoCDCIS/SAAIA/9IAH9CwSAASACIBD9EyAR/SAAIBL9IAH9CwRwIAL9DAAAgD8AAAAAAAAAAAAAAAD9CwTAASAC/QwAAAAAAACAPwAAAAAAAAAA/QsEsAEgAv0MAAAAAAAAAAAAAIA/AACAP/0LBKABIBGLIA+LkiATi5JDAACAPxDgCEO9N4Y1lCITIBOUIRQgAkHAAWpBBHIhASACQaABakEEciENIAJBsAFqQQRyIQUgAkGAAWohDkEgIQsCfwNAIAIqAnQiDyAPlCACKgJ4IhAgEJSSIAL9AASAASIZ/R8CIhIgEpSSIBReRQRAIBn9HwG8DAILIAIgGSAC/QAEcCIaIBKLIBCLIhEgD4siDyAPIBFdIgwbXiIDG/0LBGAgGv0fACERIBNBCEEEIAMgDHIiBBsiByACQeAAanIqAgAiEItdBEAgAiAa/QsEUAJ9AkAgAioCmAEgGf0fASIPIAQbIA8gESADG5MiDyAPXCAQIBCSIhEgEVxyRQRAIA+8IghBgICA/ANGBEAgERDcBAwDCyAIQR52QQJxIgogEbwiBkEfdnIhCQJAAkACQAJAAkACQCAGQf////8HcSIGRQRAQ9sPScAhDyAJQQJrDgICBgELIAhB/////wdxIghFDQIgCEGAgID8B0cNAyAGQYCAgPwHRw0EIAlBAnQqAoyxSQwICyARDAcLQ9sPSUAMBgtD2w/JPyARmAwFCyAGQYCAgPwHRiAIQYCAgOgAaiAGSXINAwJ9IAoEQEMAAAAAIAZBgICA6ABqIAhJDQEaCyARIA+VixDcBAshDwJAAkACQCAJQQFrDgMBAgAECyAPQy69uzOSQ9sPScCSDAYLIA+MDAULQ9sPSUAgD0MuvbszkpMMBAsgCUECdCoCnLFJIQ8LIA8MAgsgESAPkgwBC0PbD8k/IBGYCyACQdAAaiIJIAdyKgIAIRBDAAAAP5QiDxCZAiERIANBAnQgCXIqAgAiFSAPEJsCIg+UIBEgEJSTIRIgA60hHAJAIANFBEAgAiASOAJwDAELIAIgEjgCdAtBCEEEIAQbIgkgAkHwAGpyIA8gEJQgESAVlJI4AgAgAiAZ/QsEQCAPIBynQQJ0IgogAkFAayIGcioCACISlCARIAYgB3IqAgAiFZSTIRACQCADBEAgAiAQOAKEAQwBCyACIBA4AoABCyACQfAAakEYQRQgBBtqIA8gFZQgESASlJI4AgAgAiAC/QAEkAH9CwQwIA8gAkEwaiIGIApyKgIAIhKUIBEgBiAHcioCACIVlJMhEAJ/IAMEQCACIBA4ApQBIA4MAQsgAiAQOAKQASACQfAAagshBiACQfAAaiIIQShBJCAEG2ogDyAVlCARIBKUkjgCACAGIA8gAv0ABIABIhkgAv0ABHAgAxv9HwAiEJQgESAC/QAEkAEgGSAEG/0fACISlJM4AgBBIEEQIAQbIAhqIA8gEpQgESAQlJI4AgAgBiAPIAL9AASAASIZIAL9AARwIAMb/R8BIhCUIBEgAv0ABJABIBkgBBv9HwEiEpSTOAIEQSRBFCAEGyAIaiAPIBKUIBEgEJSSOAIAIAYgDyAC/QAEgAEiGSAC/QAEcCIaIAMb/R8CIhCUIBEgAv0ABJABIBkgBBv9HwIiEpSTOAIIQShBGCAEGyAIaiAPIBKUIBEgEJSSOAIAIAYgCWpBADYCAAJ/IANFBEBBIEEQIAwbIAhqQQA2AgBCACEcIAJBwAFqIQMgAkGwAWohBCACQaABagwBCyACQQA2ApQBQgEhHCAFIQQgASEDIA0LIAIgAv0ABMAB/QsEACADIA8gAiAcp0ECdHIqAgAiEJQgESACIAdyKgIAIhKUkzgCACACIAL9AASwAf0LBCAgBCAPIAJBIGoiAyAKcioCACIVlCARIAMgB3IqAgAiFpSTOAIAIAIgAv0ABKAB/QsEECAPIAJBEGoiAyAKcioCACIXlCARIAMgB3IqAgAiGJSTOAIAIAJBwAFqIAlyIBEgEJQgDyASlJI4AgAgAkGwAWogCXIgESAVlCAPIBaUkjgCACACQaABaiAJciARIBeUIA8gGJSSOAIAIBr9HwAhEQsgC0EBayILDQALIAIoAoQBCyEDIAIgAioCmAEiEjgC3AEgAiADNgLYASAC/QAEsAEhGSAC/QAEwAEhGiAC/QAEoAEhGyACIBE4AtQBIAIgGiAZ/Q0ICQoLGBkaGwABAgMAAQIDIBv9DQABAgMEBQYHGBkaGxgZGhv9CwSAAiACIBogGf0NBAUGBxQVFhcAAQIDAAECAyAb/Q0AAQIDBAUGBxQVFhcUFRYX/QsE8AEgAiAaIBn9DQABAgMQERITAAECAwABAgMgG/0NAAECAwQFBgcQERITEBESE/0LBOABIBr9HwAiDyAPlCAZ/R8AIhMgE5SSIBv9HwAiECAQlJIiFEMAAAAAXgRAIAIgECAUkSIQlTgC6AEgAiATIBCVOALkASACIA8gEJU4AuABCyAa/R8BIg8gD5QgGf0fASITIBOUkiAb/R8BIhAgEJSSIhRDAAAAAF4EQCACIBAgFJEiEJU4AvgBIAIgEyAQlTgC9AEgAiAPIBCVOALwAQsgGv0fAiIPIA+UIBn9HwIiEyATlJIgG/0fAiIQIBCUkiIUQwAAAABeBEAgAiAQIBSRIhCVOAKIAiACIBMgEJU4AoQCIAIgDyAQlTgCgAILQQAhBCACQQA2ApwCIAJBATYCmAIgAkHUAWohB0EBIQEgEbwiBSAFQR91QQF2cyIFIANBH3VBAXYgA3MiA0gEQEEBIQQgAkEBNgKcAiACQQA2ApgCIAUhAyACQdgBaiEHQQAhAQsCQCADIBK8IgUgBUEfdUEBdnMiBU4EQEECIQMMAQsgAkGYAmohAyAFIAcoAgAiB0EfdUEBdiAHc0oEfyACIAQ2ApgCIAJBnAJqBSADC0ECNgIAAkAgAigCnAIiBEECTQRAIAIoApgCIgVBA08NASABIQMgBSEBDAILIARBA0Hg98cAEIwHAAsgBUEDQfD3xwAQjAcACyAAIAJB4AFqIgUgA0EEdGr9AAQA/QsEMCAAIAFBBHQgBWr9AAQA/QsEICAAIARBBHQgBWr9AAQA/QsEECAAIAJB1AFqIgUgA0ECdGoqAgA4AgggACABQQJ0IAVqKgIAOAIEIAAgBEECdCAFaioCADgCACACQaACaiQAC7cNAgp/An4gACgCFCECIAAoAhAhBSAAKQMIIQwgACgCBCEIIAAoAgAhCSAAKAIYIgNBAEgEQCAFIAhJBEAgCSAFQQJ0aigAACEHCyAHQRh0IAdBgP4DcUEIdHIgB0EIdkGA/gNxIAdBGHZycq0gDEIghoQhDCAFQQFqIQUgA0EgaiEDCyAMQgAgAiACQQF2IgJrIgatIANBP3GthiINIAwgDVQiBBt9IQxBACEHIAMgBiACIAQbIgJnIgNBGGsiBkEAIAMgBk8bIgZrIQMgAiAGdCECAkACQCAEBEAgBSAITQ0BDAILIANBAEgEQCAFIAhJBEAgCSAFQQJ0aigAACEHCyAHQRh0IAdBgP4DcUEIdHIgB0EIdkGA/gNxIAdBGHZycq0gDEIghoQhDCAFQQFqIQUgA0EgaiEDCyAMQgAgAiACQQF2IgJrIgStIANBP3GthiINIAwgDVQiBxt9IQwgBCACIAcbIgIgAmciAkEYayIEQQAgAiAETxsiAnQhBCADIAJrIgNBAEgEQEEAIQIgBSAISQRAIAkgBUECdGooAAAhAgsgAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnKtIAxCIIaEIQwgBUEBaiEFIANBIGohAwsgDCAEIARBAXYiAmsiBq0gA0E/ca2GIg1CACAMIA1aIgQbfSEMIAIgBiAEGyICIAJnIgJBGGsiBkEAIAIgBk8bIgJ0IQYgAyACayIDQQBIBEBBACECIAUgCEkEQCAJIAVBAnRqKAAAIQILIAJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyrSAMQiCGhCEMIAVBAWohBSADQSBqIQMLIAxCACAGIAZBAXYiAmsiCq0gA0E/ca2GIg0gDCANVCIGG30hDCAKIAIgBhsiAiACZyICQRhrIgpBACACIApPGyICdCIKIApBAXYiCmsiC60gAyACayIDQQBIBEBBACECIAUgCEkEQCAJIAVBAnRqKAAAIQILIAJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyrSAMQiCGhCEMIAVBAWohBSADQSBqIQMLIANBP3GthiINIAxYIgJBAEECIAcbIARyQQJ0QQBBAiAGG3JyIQcgDCANQgAgAht9IQwgAyAKIAsgAhsiAmciA0EYayIEQQAgAyAETxsiBGshAwJ/IAIgBHQiBCABQf8BcUEERg0AGiADQQBIBEBBACECIAUgCEkEQCAJIAVBAnRqKAAAIQILIAJBGHQgAkGA/gNxQQh0ciACQQh2QYD+A3EgAkEYdnJyrSAMQiCGhCEMIAVBAWohBSADQSBqIQMLIAwgBCAEQQF2IgRrIgatIANBP3GthiINQgAgDCANWiICG30hDCADIAQgBiACGyIEZyIDQRhrIgZBACADIAZPGyIGayEDIAIgB0EBdHIhByAEIAZ0IgQgAUH/AXFBBkkNABogA0EASARAQQAhAiAFIAhJBEAgCSAFQQJ0aigAACECCyACQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZycq0gDEIghoQhDCAFQQFqIQUgA0EgaiEDCyAMIAQgBEEBdiIEayIGrSADQT9xrYYiDUIAIAwgDVoiAht9IQwgAyAEIAYgAhsiBGciA0EYayIGQQAgAyAGTxsiBmshAyACIAdBAXRyIQcgBCAGdCIEIAFB/wFxQQZGDQAaIANBAEgEQEEAIQIgBSAISQRAIAkgBUECdGooAAAhAgsgAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnKtIAxCIIaEIQwgBUEBaiEFIANBIGohAwsgDCAEIARBAXYiBGsiBq0gA0E/ca2GIg1CACAMIA1aIgIbfSEMIAMgBCAGIAIbIgRnIgNBGGsiBkEAIAMgBk8bIgZrIQMgAiAHQQF0ciEHIAQgBnQLIQQgA0EASARAQQAhAiAFIAhJBEAgCSAFQQJ0aigAACECCyACQRh0IAJBgP4DcUEIdHIgAkEIdkGA/gNxIAJBGHZycq0gDEIghoQhDCAFQQFqIQUgA0EgaiEDCyAFIAhLDQEgDEIAIAQgBEEBdiICayIIrSADQT9xrYYiDSAMIA1UIgEbfSEMIAggAiABGyICIAJnIgJBGGsiCEEAIAIgCE8bIgh0IQIgAyAIayEDIAdBACAHayABGyEHCyAAIAM2AhggACACNgIUIAAgBTYCECAAIAw3AwggBw8LIAAQtAoEf0EAIAAgARDwB0H/AXEiAWsgASAAELQKGwVBAAsLjhACDn8EfiMAQSBrIgIkAAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQEEVIAEoAgAiA0GAgICAeHMgA0EAThtBFGsOAgECAAsgASACQR9qQfTiwAAQlQghASAAQYCAgIB4NgIAIAAgATYCBAwLCyABKAIMIgVFDQMgAkEEaiABKAIIIgkQoAQgAigCCCEEIAIoAgQiB0GAgICAeEYEQCAEIQEMCgsgAigCFCEIIAIoAhAhAyAFQQFGDQIgAigCGCEKIAIoAgwhCyACQQRqIgYgCUEQahDTAiACKAIIIQEgAigCBA0IIAVBAkYNASACKQIMIRAgBiAJQSBqENMCIAIoAgghBiACKAIEBEAgBiEBDAkLAkAgBUEDRwRAIAIpAgwhESACQQRqIAlBMGoQnwUgAigCBEUNASACKAIIIQEMCgtBA0G0/8AAQYD9wAAQ2wYhAQwJCyAFQQRHBEAgAkEENgIEIAVB/P///wBqQf////8AcUEEaiACQQRqQeiVwQAQ2wYhASAAQYCAgIB4NgIAIAAgATYCBCAHBEAgBCAHQQEQogcLIANFDQsgCCADQQEQogcMCwsgAigCCCEFIAAgAigCDDYCNCAAIAU2AjAgACARNwIoIAAgBjYCJCAAIBA3AhwgACABNgIYIAAgCjYCFCAAIAg2AhAgACADNgIMIAAgCzYCCCAAIAQ2AgQgACAHNgIADAoLIAEoAggiA0UNBCADQQV0IQ0gASgCBCEBQYCAgIB4IQUDQAJAAkACQAJAAkACQAJAAkBBFSABKAIAIgNBgICAgHhzIANBAE4bQQFrDg8BAAACAAAAAAAAAAMEBQYACyABIAJBH2pBxOTAABCVCCEDIAJBAToABCACIAM2AggMBgsgAkEAOgAEIAJBBCABQQRqLQAAIgMgA0EETxs6AAUMBQsgAkEAOgAEIAJCBCABQQhqKQMAIhAgEEIEWhs8AAUMBAsgAUEIaigCACEDAn8CQAJAAkACQCABQQxqKAIAQQRrDgIBAAMLIANBkP3AAEEFENsHDQFBAAwDC0EBIAMoAABB7dK5mwdGDQIaIAMoAABB7cLhmwdHDQFBAgwCCyADQZ39wABBBRDbBw0AQQMMAQtBBAshAyACQQA6AAQgAiADOgAFDAMLIAFBBGooAgAhAwJ/AkACQAJAAkAgAUEIaigCAEEEaw4CAQADCyADQZD9wABBBRDbBw0BQQAMAwtBASADKAAAQe3SuZsHRg0CGiADKAAAQe3C4ZsHRw0BQQIMAgsgA0Gd/cAAQQUQ2wcNAEEDDAELQQQLIQMgAkEAOgAEIAIgAzoABQwCCyACQQRqIAFBCGooAgAgAUEMaigCABDZBQwBCyACQQRqIAFBBGooAgAgAUEIaigCABDZBQsgAi0ABEEBRgRAIAIoAgghBEEBDAcLIAFBEGohAwJAAkACQAJAAkACQAJAAkAgAi0ABQ4EAAECAwcLIAVBgICAgHhHBEBBkP3AAEEFEJ8HIQRBAQwOCyACQQRqIAMQoAQgAigCCCEGIAIoAgQiBUGAgICAeEYEQCAGIQQMDwsgAigCGCEOIAIoAhQhCSACKAIQIQggAigCDCEPDAYLIAoNAiACQQRqIAMQ0wIgAigCCCEEQQEgAigCBEEBRg0MGiACKQIMIRFBASEKDAULIAsNAyACQQRqIAMQ0wIgAigCCCEHIAIoAgRBAUYEQCAHIQRBAQwMCyACKQIMIRJBASELDAQLIAwNASACQQRqIAMQnwUgAigCCCEDIAIoAgRBAUYEQCADIQRBAQwLCyADrSACNQIMQiCGhCETQQEhDAwDC0GV/cAAQQQQnwchBEEBDAkLQZ39wABBBRCfByEEQQEMCAtBmf3AAEEEEJ8HIQRBAQwHCyABQSBqIQEgDUEgayINDQALDAMLQQJBtP/AAEGA/cAAENsGIQEMBgtBAUG0/8AAQYD9wAAQ2wYhAQwFC0EAQbT/wABBgP3AABDbBiEBDAULIAVBgICAgHhGDQAgAiAONgIYIAIgCTYCFCACIAg2AhAgAiAPNgIMIAIgBjYCCCACIAU2AgQCQCAKRQRAQZX9wABBBBCcByEEDAELIAtFBEBBmf3AAEEEEJwHIQQMAQsgDEUEQEGd/cAAQQUQnAchBAwBCyAAIBM3AjAgACASNwIoIAAgBzYCJCAAIBE3AhwgACAENgIYIAAgDjYCFCAAIAk2AhAgACAINgIMIAAgDzYCCCAAIAY2AgQgACAFNgIADAYLIAJBBGoQ5gVBAAwBC0GAgICAeCEFQZD9wABBBRCcByEEQQELRSAFQYCAgIB4RnINACAFBEAgBkEEaygCACIBQXhxIgdBBEEIIAFBA3EiARsgBWpJDQUgAUEAIAcgBUEnaksbDQYgBhCiAgsgCEUNACAJQQRrKAIAIgFBeHEiBkEEQQggAUEDcSIBGyAIakkNBCABQQAgBiAIQSdqSxsNBSAJEKICCyAAIAQ2AgQgAEGAgICAeDYCAAwCCyAHBEAgBEEEaygCACIGQXhxIgVBBEEIIAZBA3EiBhsgB2pJDQMgBkEAIAUgB0EnaksbDQQgBBCiAgsgA0UNACAIQQRrKAIAIgRBeHEiBkEEQQggBEEDcSIEGyADakkNAiAEQQAgBiADQSdqSxsNAyAIEKICCyAAIAE2AgQgAEGAgICAeDYCAAsgAkEgaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALxRACCH8EfiMAQeACayIBJAACQAJAAkACQAJAAkACQAJAAkACQCAALQD8AkUEQCAAKAIAIgJBAkcNCSAAKAKIAUECRw0JIAAoAuACIgNBA00EQEEAIQIMCwsgASAAKALcAiIEKAAAIgI2AhACQCACQdKCkZoERwRAIAJB0oKRggNHDQMgA0EISQ0BIAMgBCgABCIFQQdqQXhxQQhqIgJJDQEgBUEIaiIGIANLIAVBd0tyDQQgAUEANgLYAiABIAU2AtQCIAEgBEEIajYC0AIgAUEgaiABQdACahBZIAEoAiQhBSABKAIgIgdBAkYEQCAFEM4HIQIMDQsgAUGwAWogAUEoakGAAfwKAAAgAEEANgLgAiABIAU2AqwBIAEgBzYCqAEgAyACayEGAkACQCACRQ0AIAIgA0YNASAGRQ0AIAQgAiAEaiAG/AoAAAsgACAGNgLgAgsgACAAKQO4AiACrXwiCTcDwAIgACAJNwO4AiABKAKkAkEBRw0FIAAgASgClAIiAzYC6AIgACABKAK0ASABKALAASICIAEoArABGyIENgLsAiAERQ0GIAIgBG4iBiAEIAZsIAJHaiIEIANGBEAgAS0AqAIhAyABIAVBACAHQQFxGzYCJCABIAI2AiAgASADQQFxOgAoIABB+AFqIAFBIGoQhAICQCAAKAIAQQJGDQAgACgCaCEEIAAoAmwiAwRAIARBJGohAgNAIAJBBGsoAgAiBUGAgICAeHJBgICAgHhHBEAgAigCACIGQQRrKAIAIgdBeHEiCEEEQQggB0EDcSIHGyAFakkNDCAHQQAgCCAFQSdqSxsNDSAGEKICCyACQTBqIQIgA0EBayIDDQALCyAAKAJkIgMEQCAEIANBMGxBCBCiBwsgACgCcCIDQYCAgIB4ckGAgICAeEYNACAAKAJ0IANBARCiBwsgACABQagBakGIAfwKAAAMCwsgASAENgLMAiABQQI2AiQgAUHox8EANgIgIAFCAjcCLCABQoCAgIAQIgkgAEHoAmqthDcD2AIgASAJIAFBzAJqrYQ3A9ACIAEgAUHQAmo2AiggAUHAAmoiACABQSBqELEGIAAQjgchAgwJCyABQQhqIAAQuAIgAS0ACEUEQCABLQAJDQpBACECDAwLIAEoAgwhAgwLC0EAIQIMCgsgADUC4AIhCSAAQQA2AuACIAAgCSAAKQO4Anw3A7gCDAkLIAFBATYCNCABQczIwQA2AjAgAUEBNgIkIAFBxMjBADYCICABQQE2AiwgASABQRBqrUKAgICAkASENwPQAiABIAFB0AJqNgIoIAFBFGoiACABQSBqELEGIAAQjgchAgwIC0EIIAYgA0GcyMEAEOoHAAsgAUEBNgIkIAFBlMjBADYCICABQgE3AiwgASABQaQCaq1CgICAgBCENwPQAiABIAFB0AJqNgIoIAFBtAJqIgAgAUEgahCxBiAAEI4HIQIgASgClAIhAwwDC0G0x8EAEIEIAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAEoApACIQQgAwRAIARBJGohAANAIABBBGsoAgAiBUGAgICAeHJBgICAgHhHBEAgACgCACAFQQEQogcLIABBMGohACADQQFrIgMNAAsLIAEoAowCIgAEQCAEIABBMGxBCBCiBwsgASgCmAIiAEGAgICAeHJBgICAgHhGDQIgASgCnAIgAEEBEKIHDAILIAAoAgAhAgsCQAJAAkACQAJ/AkAgAkECRwRAIAAoAuQCIAAoAugCTw0GIAAoAogBQQJGDQFBAAwCCyABQagBaiAAEFsgASgCrAFBACABLQCoASIDGyECIAMNBiABLQCpAUEBcUUNBiAAKQPQAiILIAApA7gCIglYBEAgACgC4AIhAwwFCyAAKALgAiEEQQAhAyAAQQA2AuACIAQgCyAJfSIKIAStIgwgCiAMVBsiCqciBWshAiAKUEUEQCAEIAVGDQQgAkUNAyAAKALcAiIDIAMgBWogAvwKAAAMAwsgBCAFRw0CDAMLQQELIQIDQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAkUEQCABQagBaiAAEFsgASgCrAEhAyABLQCoASICDQIgAS0AqQFBAXFFDQIgACkD0AIiCSAAKQO4AiILVg0BDAYLIAFBqAFqIAAQuAIgAS0AqAFBAUYEQCABKAKsASECDBELIAEtAKkBDQlBACECDBALIAAoAuACIQMgAEEANgLgAiADIAkgC30iCiADrSIMIAogDFQbIgqnIgJrIQQgClANASACIANGDQMgBEUNAiAAKALcAiIDIAIgA2ogBPwKAAAMAgsgA0EAIAIbIQIMDgsgAiADRg0BCyAAIAQ2AuACCyAAIAogC3wiCzcDuAIgCSALVg0BCwJAIAAoAogBQQJGDQAgACgC5AEiA0UNACAAKALoASICQQRrKAIAIgRBeHEiBSADQShsIgNBBEEIIARBA3EiBBtqSQ0CIARBACAFIANBJ2pLGw0DIAIQogILIABBAjYCiAEgACAAKALkAkEBaiIDNgLkAiADIAAoAugCSQ0EDAkLQQAhAgwJC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBACECDAELQQEhAgwACwALIAAgAjYC4AIgAiEDCyAAIAkgCnwiCTcDuAIgCSALWg0AQQAhAgwCC0EAIQIgAEEANgLgAiAAQQE6APwCIAAgCSADrXw3A7gCDAELIABBAToA/AIgADUC4AIhCUEAIQIgAEEANgLgAiAAIAkgACkDuAJ8NwO4AgsgAUHgAmokACACC70PAg5/AX4jAEEgayICJAACQAJAAkACQAJAAkACQAJ/An8CQAJAAkACQAJAAkACQAJAQRUgASgCACIDQYCAgIB4cyADQQBOG0EUaw4CAAEECyABKAIMIgNFDQIgAkEEaiABKAIIIgEQoAQgAigCCCEIIAIoAgQiBkGAgICAeEYEQCAIIQMMDQsgAigCFCEJIAIoAhAhByADQQFGDQEgAigCGCELIAIoAgwhDCACQQRqIAFBEGoQ0AMgAigCCCEEIAIoAgQiBUGAgICAeEYEQCAEIQMMDAsCQAJ/IANBAkcEQCACKAIMIQ4gAkEEaiABQSBqEKUDIAItAARFDQIgAigCCAwBC0ECQYz/wABBgP3AABDbBgshAyAFRQ0MIARBBGsoAgAiAUF4cSIKIAVBAnQiBUEEQQggAUEDcSIBG2pJDRAgAUEAIAogBUEnaksbDQ8gBBCiAgwMCyADQQNGBEAgAi0ABSEPDAsLIAJBAzYCBCADQf3///8AakH/////AHFBA2ogAkEEakHolcEAENsGIQMgBgRAIAggBkEBEKIHCyAHBEAgCSAHQQEQogcLIAVFDQwgBCAFQQJ0QQQQogcMDAsgASgCCCIDRQRAQYCAgIB4IQUMBgsgA0EFdCEKIAEoAgQhAUGAgICAeCEGQYCAgIB4IQUDQAJAAkACQAJAAkACQAJAAkBBFSABKAIAIgNBgICAgHhzIANBAE4bQQFrDg8BAAACAAAAAAAAAAMEBQYACyABIAJBH2pBlOXAABCVCCEDIAJBAToABCACIAM2AggMBgsgAkEAOgAEIAJBAyABQQRqLQAAIgMgA0EDTxs6AAUMBQsgAkEAOgAEIAJCAyABQQhqKQMAIhAgEEIDWhs8AAUMBAsgAUEIaigCACEDAn8CQAJAAkACQCABQQxqKAIAQQVrDgQAAwMBAwsgA0GQ/cAAQQUQ2wcNAUEADAMLIAMpAABC496Rq6bs27frAFINAUEBDAILIANB6P7AAEEFENsHDQBBAgwBC0EDCyEDIAJBADoABCACIAM6AAUMAwsgAUEEaigCACEDAn8CQAJAAkACQCABQQhqKAIAQQVrDgQAAwMBAwsgA0GQ/cAAQQUQ2wcNAUEADAMLIAMpAABC496Rq6bs27frAFINAUEBDAILIANB6P7AAEEFENsHDQBBAgwBC0EDCyEDIAJBADoABCACIAM6AAUMAgsgAkEEaiABQQhqKAIAIAFBDGooAgAQygUMAQsgAkEEaiABQQRqKAIAIAFBCGooAgAQygULIAItAARBAUYNBSABQRBqIQMCQAJAAkACQCACLQAFQQFrDgMBAgMACyAGQYCAgIB4RwRAQZD9wABBBRCfByEDQQEMCwsgAkEEaiADEKAEIAIoAgghAyACKAIEIgZBgICAgHhGBEBBgICAgHghBkEBDAsLIAIoAhghCyACKAIUIQkgAigCECEHIAIoAgwhDCADIQgMAgsgBUGAgICAeEcEQEGY/sAAQQgQnwchA0EBDAoLIAJBBGogAxDQAyACKAIIIQQgAigCBCIFQYCAgIB4RgRAQQEhCiAEIQMMDAsgAigCDCEODAELIA1FBEAgAkEEaiADEKUDIAItAARBAUYNByACLQAFIQ9BASENDAELQej+wABBBRCfByEDQQEMCAsgAUEgaiEBIApBIGsiCg0ACwwDC0EBQYz/wABBgP3AABDbBiEDDAkLQQBBjP/AAEGA/cAAENsGIQMMCQsgASACQR9qQcTjwAAQlQghAwwICyAGQYCAgIB4Rg0BIAIgCzYCGCACIAk2AhQgAiAHNgIQIAIgDDYCDCACIAg2AgggAiAGNgIEAkAgBUGAgICAeEYiAUUEQCANDQdB6P7AAEEFEJwHIQMgBUUNASAEIAVBAnRBBBCiBwwBC0GY/sAAQQgQnAchAwsgAkEEahDmBUEADAMLIAIoAgghA0EBDAELQYCAgIB4IQZBkP3AAEEFEJwHIQNBAQshAUEBCyEKIAVB/////wdxRSABRXINAAJAIARBBGsoAgAiAUF4cSILIAVBAnQiBUEEQQggAUEDcSIBG2pPBEAgAUEAIAsgBUEnaksbDQEgBBCiAgwCCwwHCwwFCyAKRSAGQYCAgIB4RnINAgJAIAYEQCAIQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyAGakkNByABQQAgBCAGQSdqSxsNBiAIEKICCyAHRQ0DIAlBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAdqSQ0GIAFBACAEIAdBJ2pLGw0AIAkQogIMAwsMBAsgACAENgIcIAAgBTYCGCAAIAs2AhQgACAJNgIQIAAgBzYCDCAAIAw2AgggACAINgIEIAAgBjYCACAAIA6tIA+tQv8Bg0IghoQ3AiAMAgsgBgRAIAhBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAZqSQ0EIAFBACAEIAZBJ2pLGw0DIAgQogILIAdFDQAgCUEEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgB2pJDQMgAUEAIAQgB0EnaksbDQIgCRCiAgsgAEGBgICAeDYCACAAIAM2AgQLIAJBIGokAA8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC4YRAg1/AX4jAEHgAGsiAiQAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAgAiBEGAgICAeHMgBEEAThtBFGsOAgECAAsgASACQRhqQZTjwAAQlQghASAAQYCAgIB4NgIAIAAgATYCBAwHCyABKAIMIgZFDQICQCABKAIIIgUoAgBBlICAgHhGBEACQCAFKAIMIgEEQCACQcgAaiAFKAIIEKgDIAIoAkgiBEGAgICAeEcNASACKAJMIQEMCQtBACACQRhqQYTiwAAQ2wYhAQwICyACKAJMIQcgAUEBRg0BIAJBATYCSCABQQFrQf////8AcUEBaiACQcgAakHolcEAENsGIQEgBEUNByAHIARBARCiBwwHCyAFIAJBGGpBhOLAABCVCCEBDAYLIAZBAUYNASACKAJQIQkgAkHIAGoiAyAFQRBqEKECIAIoAkwhASACKAJIDQQgAkEQaiACQdgAaigCADYCACACIAIpAlA3AwgCQCAGQQJHBEAgAyAFQSBqEKECIAIoAkwhBSACKAJIRQ0BIAUhAQwGC0ECQZD+wABBgP3AABDbBiEBDAULIAJBMGoiAyACQdgAaigCADYCACACQUBrIgggAkEQaigCADYCACACIAIpAlA3AyggAiACKQMINwM4IAZBA0cEQCACQQM2AkggBkH9////AGpB/////wBxQQNqIAJByABqQeiVwQAQ2wYhASAAQYCAgIB4NgIAIAAgATYCBCAERQ0HIAcgBEEBEKIHDAcLIAAgAikDODcCECAAIAIpAyg3AiAgACAFNgIcIAAgATYCDCAAIAk2AgggACAHNgIEIAAgBDYCACAAQRhqIAgoAgA2AgAgAEEoaiADKAIANgIADAYLIAEoAgQhBCABKAIIIQEgAkEANgIUIAIgBCABQQV0aiIMNgIMAkACQAJAIAFFDQAgAkHQAGohCkGAgICAeCEIA0AgAiAEQSBqIgE2AgggAiACKAIUQQFqNgIUIAIgBEEQaiINNgIQAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRUgBCgCACIDQYCAgIB4cyADQQBOG0EBaw4PAA4OAQ4ODg4ODg4CAwQFDgsgBC0ABA4DCgUHDwsgBCkDCCIPQgJWDQ4gD6dBAWsOAgQGCQsgBCgCCCEDAkAgBCgCDEEEaw4CAAgOCyADKAAAQe3SuZsHRg0DIAMoAABB7cLhmwdGDQUMDQsgBCgCBCEDAkAgBCgCCEEEaw4CAAYNCyADKAAAQe3SuZsHRg0CIAMoAABB7cLhmwdGDQQMDAsgBCgCCCEDAkACQCAEKAIMQQRrDgIBAA0LIAMtAABB5gBHDQwgAy0AAUHpAEcNDCADLQACQewARw0MIAMtAANB5QBHDQwgAy0ABEHzAEcNDAwHCyADLQAAQe0ARw0LAkACQCADLQABQeEAaw4JAQ0NDQ0NDQ0ADQsgAy0AAkHuAEcNDCADLQADQfMARg0CDAwLIAMtAAJB+ABHDQsgAy0AA0HzAEYNAwwLCyAEKAIEIQMCQAJAIAQoAghBBGsOAgEADAsgAy0AAEHmAEcNCyADLQABQekARw0LIAMtAAJB7ABHDQsgAy0AA0HlAEcNCyADLQAEQfMARw0LDAYLIAMtAABB7QBHDQoCQCADLQABQeEAaw4JAgsLCwsLCwsACwsgAy0AAkHuAEcNCiADLQADQfMARw0KCyAGRQ0FQZX9wABBBBCfBwwICyADLQACQfgARw0IIAMtAANB8wBHDQgLIAtFDQRBmf3AAEEEEJ8HDAYLIANBkP3AAEEFENsHRQ0BDAYLIANBkP3AAEEFENsHDQULIAhBgICAgHhHBEBBkP3AAEEFEJ8HDAQLIAJByABqIAJBCGoQsgUgAigCTCEHIAIoAkgiCEGAgICAeEYEQCAHIQUMCQsgAigCUCEOIAIoAgwhDCACKAIIIQEMBQsgAkEANgIQIAJByABqIA0QoQIgAigCTCIFIAIoAkhBAUYNAhogAkEwaiAKQQhqKAIANgIAIAIgCikCADcDKEEBIQYMBAsgAkEANgIQIAJByABqIA0QoQIgAigCTCEJIAkgAigCSEEBRg0BGiACQUBrIApBCGooAgA2AgAgAiAKKQIANwM4QQEhCwwDCyAEIAJBGGpBhOXAABCVCAshBSAIQYCAgIB4ckGAgICAeEYNBAJAIAdBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAhqTwRAIAFBACAEIAhBJ2pLGw0BIAcQogIMBgtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAJBADYCEAsgDCABIgRHDQALIAhBgICAgHhGDQAgBkEAIAsbDQJBmf3AAEGV/cAAIAYbQQQQnAchBSAIRQ0BIAcgCEEBEKIHDAELQZD9wABBBRCcByEFCyAAIAU2AgQgAEGAgICAeDYCACAAIAIpA0g3AhAgAEEYaiACQdAAaigCADYCAAwDCyACQSBqIAJBQGsoAgA2AgAgAkHQAGogAkEwaigCACIBNgIAIAIgAikDODcDGCACIAIpAygiDzcDSCAAIAU2AgwgACAONgIIIAAgBzYCBCAAIAg2AgAgACAPNwIQIABBGGogATYCACAAIAk2AhwMAgtBAUGQ/sAAQYD9wAAQ2wYhAQwCC0EAQZD+wABBgP3AABDbBiEBDAILIAAgAikDGDcCICAAQShqIAJBIGooAgA2AgAMAgsgBEUNACAHQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyAEakkNAiAFQQAgBiAEQSdqSxsNAyAHEKICCyAAIAE2AgQgAEGAgICAeDYCAAsgAkHgAGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+EOAgR/A34jAEGwBWsiBiQAIAYgAjYCECAGIAE2AgwgBiAFNgIYIAYgBDYCFAJAAkACQAJAIAMoAgxFDQAgAykDECADKQMYIAQgBRCVBCEKIAMoAgQiASAKp3EhAiAKQhmIQv8Ag0KBgoSIkKDAgAF+IQwgAygCACEHA0AgAiAHaikAACILIAyFIgpCf4UgCkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIKUEUEQANAAkAgBSAHIAp6p0EDdiACaiABcUFobGoiCEEQaygCAEcNACAEIAhBFGsoAgAgBRDbBw0AQQAhAwwFCyAKQgF9IAqDIgpQRQ0ACwsgCyALQgGGg0KAgYKEiJCgwIB/g1BFDQEgAiAJQQhqIglqIAFxIQIMAAsACyAGIAZBFGqtQoCAgIAghCIKNwNAIAYgBkEMaq1CgICAgCCENwM4IAZCAjcCzAMgBkECNgLEAyAGQdTvxwA2AsADIAYgBkE4aiIENgLIAyAGQZgFaiIHIAZBwANqIgEQ7AMgBkEANgIkIAZCgICAgBA3AhwgBigCmAUhAiAEIAAgBigCnAUiBSAGKAKgBRDbAQJAAkACQAJAAkACQCAGKQM4QgNSBEAgASAEQcgB/AoAACAHIAEgBkEcahDXASAGKAKYBUEBRgRAIAYpApwFENIHIQMgARDDAQwCCyAGKAIYIgBBAEgNAiAGKAIUIQQCQCAARQRAQQEhAQwBCyAAEHEiAUUNBAsgAARAIAEgBCAA/AoAAAsgBiAANgKgBSAGIAE2ApwFIAYgADYCmAUgBkEoaiADIAZBmAVqIAZBHGoQ8gIgBigCKCIAQYCAgIB4ckGAgICAeEcEQCAGKAIsIgFBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIABqSQ0KIANBACAEIABBJ2pLGw0JIAEQogILIAZBwANqEMMBQQAhAwwFCwJAAkACQAJAQQEgBigCQCIEQf////8HaiAEQYCAgIB4TRsOAgABAwsgBi0AREEDRw0CIAYoAkgiASgCACEEIAFBBGooAgAiBygCACIIBEAgBCAIEQMACyAHKAIEIgcEQCAEQQRrKAIAIghBeHEiCUEEQQggCEEDcSIIGyAHakkNDCAIQQAgCSAHQSdqSxsNCyAEEKICCyABQQRrKAIAIgRBeHEiB0EQQRQgBEEDcSIEG0kNCyAERSAHQTRJcg0BDAoLIARBgICAgHhyQYCAgIB4Rg0BIAYoAkQiAUEEaygCACIHQXhxIghBBEEIIAdBA3EiBxsgBGpJDQogB0UNACAIIARBJ2pLDQkLIAEQogILIAZBwANqIAAgBigCFCAGKAIYENsBIAYgCjcDKCAGQgE3AqQFIAZBAjYCnAUgBkGA8McANgKYBSAGIAZBKGo2AqAFIAZBjAVqIAZBmAVqEOwDIAYpA8ADIgpCA1IEQCAGKALIAyEBIAZBhAJqIAZBzANqQbwB/AoAACAGKAKMBSIABEAgBigCkAUiBEEEaygCACIHQXhxIghBBEEIIAdBA3EiBxsgAGpJDQogB0EAIAggAEEnaksbDQkgBBCiAgsgBiABNgJAIAYgCjcDOCAGQcQAaiAGQYQCakG8AfwKAAAgBkHAA2ogBkE4aiIAIAZBHGoQ1wEgBigCwANBAUYEQCAGKQLEAxDSByEDIAAQwwEMAgsgBigCGCIAQQBIDQQgBigCFCEEAkAgAEUEQEEBIQEMAQsgABBxIgFFDQQLIAAEQCABIAQgAPwKAAALIAYgADYCyAMgBiABNgLEAyAGIAA2AsADIAZBmAVqIAMgBkHAA2ogBkEcahDyAiAGKAKYBSIAQYCAgIB4ckGAgICAeEcEQCAGKAKcBSIBQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyAAakkNCiADQQAgBCAAQSdqSxsNCSABEKICCyAGQThqEMMBIAJFBEBBACEDDAgLIAVBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIAJqSQ0JQQAhAyAARSABIAJBJ2pNcg0GDAgLIwBBMGsiACQAIAAQ5AggAEEgaiIDIAZBjAVqIgFBCGooAgA2AgAgAEEsaiAGQcgDaiIEQQhqKAIANgIAIAAgASkCADcDGCAAIAQpAgA3AiRBNBBxIgFFBEAACyABQcC1xwA2AgAgASAAKQIANwIEIAEgACkDGDcCHCABQQxqIABBCGr9AAIA/QsCACABQSRqIAP9AAMA/QsCACAAQTBqJAAgASEDCyAGKAIcIgBFDQMgBigCICIBQQRrKAIAIgRBeHEiB0EEQQggBEEDcSIEGyAAakkNByAEQQAgByAAQSdqSxsNBiABEKICDAMLQdiayAAQ/wcLAAtB2JrIABD/BwALIAJFDQEgBUEEaygCACIAQXhxIgFBBEEIIABBA3EiABsgAmpPBEAgAEUgASACQSdqTXINAQwDCwwDCyAFEKICCyAGQbAFaiQAIAMPC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAumDwQRfwF8B30BbyMAQSBrIgIkACACIAE2AgACQAJAIAElARAQRQRAIAIgAkEfakH8hcEAEIADIQMgAEECOgAcIAAgAzYCACABIgNBgwhLDQEMAgtBAiEHAkADQCADIQUgBEFAaiEEAkACfwJAAkADQCAEQdzrwABqKAIAIgYgBEHg68AAaigCACIQEM8DIgghAyABJQEgAyUBEBEhGxDaBCIDIBsmAQJAIAMlARASBEAgCCUBIAElARATRQ0BCyAEQcgAaiEEAkACQAJAAkAgEEEGaw4FAAcHBwEHC0EAIAZB4OrAAEEGENsHRQ0HGiAGQebqwABBBhDbBw0BQQEMBwtBAiAGQezqwABBChDbB0UNBhogBkH26sAAQQoQ2wcNAUEDDAYLQQQgBkGA68AAQQYQ2wdFDQUaIAZBhuvAAEEGENsHDQNBBQwFCyAGQZLrwABBChDbBw0DQQcMBAsgA0GECE8EQCADEJsHCyAIQYQITwRAIAgQmwcLIARBCGoiBA0ACyAFIQMMAwtBBiAGQYzrwABBBhDbB0UNARoLQQgLIQUgCEGECE8EQCAIEJsHCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUOCAECAwQFBgcIAAsgA0GECEkNESADEJsHDBELIAkNByACIAM2AgQgAkEIaiADEK8KAn0gAigCCCIFBEAgAisDECITtkMAAIA/QwAAgL8gE71CAFkbmAwBCyACQQRqIAJBH2pB2OfAABCAA74LIRQgA0GECE8EQCADEJsHCyAFRQ0IQQEhCQwQCyAKDQ0gAiADNgIEIAJBCGogAxCvCgJ9IAIoAggiBQRAIAIrAxAiE7ZDAACAP0MAAIC/IBO9QgBZG5gMAQsgAkEEaiACQR9qQdjnwAAQgAO+CyEVIANBhAhPBEAgAxCbBwsgBQRAQQEhCgwQCyAAIBU4AgBBACEEDBILIAsNCyACIAM2AgQgAkEIaiADEK8KAn0gAigCCCIFBEAgAisDECITtkMAAIA/QwAAgL8gE71CAFkbmAwBCyACQQRqIAJBH2pB2OfAABCAA74LIRYgA0GECE8EQCADEJsHCyAFBEBBASELDA8LIAAgFjgCAEEAIQQMEQsgDA0JIAIgAzYCBCACQQhqIAMQrwoCfSACKAIIIgUEQCACKwMQIhO2QwAAgD9DAACAvyATvUIAWRuYDAELIAJBBGogAkEfakHY58AAEIADvgshFyADQYQITwRAIAMQmwcLIAUEQEEBIQwMDgsgACAXOAIAQQAhBAwQCyANDQcgAiADNgIEIAJBCGogAxCvCgJ9IAIoAggiBQRAIAIrAxAiE7ZDAACAP0MAAIC/IBO9QgBZG5gMAQsgAkEEaiACQR9qQdjnwAAQgAO+CyEYIANBhAhPBEAgAxCbBwsgBQRAQQEhDQwNCyAAIBg4AgBBACEEDA8LIA4NBSACIAM2AgQgAkEIaiADEK8KAn0gAigCCCIFBEAgAisDECITtkMAAIA/QwAAgL8gE71CAFkbmAwBCyACQQRqIAJBH2pB2OfAABCAA74LIRkgA0GECE8EQCADEJsHCyAFBEBBASEODAwLIAAgGTgCAEEAIQQMDgsgDw0DIAIgAzYCBCACQQhqIAMQrwoCfSACKAIIIgUEQCACKwMQIhO2QwAAgD9DAACAvyATvUIAWRuYDAELIAJBBGogAkEfakHY58AAEIADvgshGiADQYQITwRAIAMQmwcLIAUEQEEBIQ8MCwsgACAaOAIAQQAhBAwNCyAHQQJHBEAgAEGS68AAQQoQngc2AgAMCQsgAiADNgIIAkAgAxC6CiIHQf///wdHIgUEQCAFIAdBAEdxIREMAQsgAkEIaiACQR9qQYyGwQAQgAMhEgsgA0GECE8EQCADEJsHCyAFRQRAIAAgEjYCAEEAIQQMDQsgESEHDAkLIABB4OrAAEEGEJ4HNgIADAcLIAAgFDgCAEEAIQQMCgsgAEGM68AAQQYQngc2AgAMBQsgAEGG68AAQQYQngc2AgAMBAsgAEGA68AAQQYQngc2AgAMAwsgAEH26sAAQQoQngc2AgAMAgsgAEHs6sAAQQoQngc2AgAMAQsgAEHm6sAAQQYQngc2AgALQQEhBAwDCyAEQcAARw0BCwsgCUUEQCAAQeDqwABBBhCdBzYCAEEAIQQMAQsgCkUEQCAAQebqwABBBhCdBzYCAEEAIQQMAQsgC0UEQCAAQezqwABBChCdBzYCAEEAIQQMAQsgDEUEQCAAQfbqwABBChCdBzYCAEEAIQQMAQsgDUUEQCAAQYDrwABBBhCdBzYCAEEAIQQMAQsgDkUEQCAAQYbrwABBBhCdBzYCAEEAIQQMAQsgD0UEQCAAQYzrwABBBhCdBzYCAEEAIQQMAQsgB0ECRgRAIABBkuvAAEEKEJ0HNgIAQQAhBAwBCyAAIAc6ABwgACAaOAIYIAAgGTgCFCAAIBg4AhAgACAXOAIMIAAgFjgCCCAAIBU4AgQgACAUOAIAIAEiA0GDCEsNAQwCCyAAQQI6ABwgAUGECE8EQCABEJsHCyAEQQFzIANBhAhJcg0BCyADEJsHCyACQSBqJAALiA4CDn8FfSACIAFBAnRBBGsiCmohDSAAIApqIQsgACABQQF2Ig9BAnRqIgpBBGshDCADQQRqIRADQEMAAIA/IRMCfwJAIAooAgAiBCAQKAIAIgMoAggiBkkEQCAAKAIAIQkgAygCBCIIIARBGGxqIgQtABMiBSAELQASIgcgBC0AESIOIAcgDksbIgcgBSAHSxsiBQR9QwAAQMEgAyoCRCADLQBYQQJGIgcbIhJDAAAQQSADKgJIIAcbIBKTQwAAfkOVIAVBAWtB/wFxs5SSEIkEIhIgEpIFQwAAAAALIRUgBEEMai8BACIFQf//AXFFBEAgBUEQdAwDCyAFQf8HcSEEIAVBgIACcSEHIAVBgPgBcSIFQYD4AUYEQCAHQRB0IgVBgICA/AdyIARFDQMaIAUgBEENdHJBgICA/gdyDAMLIAdBEHQhByAFRQ0BIAVBDXRBgICA/ABxIARBDXRyQYCAgMADaiAHcgwCCyAEIAZB3LvHABCMBwALIAQgBGdBEGsiBEH//wNxQQhqdEH///8DcSAHQYCAgNgDciAEQRd0a3ILviISQwAAgD9eBEAgEhDGBUNU+C1AlEMAAIA/kpEhEwtDAACAPyESAn8CQCAGIAlLBEAgCCAJQRhsaiIELQATIgUgBC0AEiIGIAQtABEiCSAGIAlLGyIGIAUgBksbIgUEfUMAAEDBIAMqAkQgAy0AWEECRiIGGyIUQwAAEEEgAyoCSCAGGyAUk0MAAH5DlSAFQQFrQf8BcbOUkhCJBCIUIBSSBUMAAAAACyEUIARBDGovAQAiBEH//wFxRQRAIARBEHQMAwsgBEH/B3EhAyAEQYCAAnEhBSAEQYD4AXEiBEGA+AFGBEAgBUEQdCIEQYCAgPwHciADRQ0DGiAEIANBDXRyQYCAgP4HcgwDCyAFQRB0IQUgBEUNASAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogBXIMAgsgCSAGQdy7xwAQjAcACyADIANnQRBrIgNB//8DcUEIanRB////A3EgBUGAgIDYA3IgA0EXdGtyC74iFkMAAIA/XgRAIBYQxgVDVPgtQJRDAACAP5KRIRILIAIgCiAAIBUgE5QiEyATWyATIBQgEpRgRXEiBxsoAgA2AgBDAACAPyETAn8CQCALKAIAIgQgECgCACIDKAIIIgZJBEAgDCgCACEJIAMoAgQiDiAEQRhsaiIELQATIgUgBC0AEiIIIAQtABEiESAIIBFLGyIIIAUgCEsbIgUEfUMAAEDBIAMqAkQgAy0AWEECRiIIGyISQwAAEEEgAyoCSCAIGyASk0MAAH5DlSAFQQFrQf8BcbOUkhCJBCISIBKSBUMAAAAACyEVIARBDGovAQAiBUH//wFxRQRAIAVBEHQMAwsgBUH/B3EhBCAFQYCAAnEhCCAFQYD4AXEiBUGA+AFGBEAgCEEQdCIFQYCAgPwHciAERQ0DGiAFIARBDXRyQYCAgP4HcgwDCyAIQRB0IQggBUUNASAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogCHIMAgsgBCAGQdy7xwAQjAcACyAEIARnQRBrIgRB//8DcUEIanRB////A3EgCEGAgIDYA3IgBEEXdGtyC74iEkMAAIA/XgRAIBIQxgVDVPgtQJRDAACAP5KRIRMLQwAAgD8hEgJ/AkAgBiAJSwRAIA4gCUEYbGoiBC0AEyIFIAQtABIiBiAELQARIgkgBiAJSxsiBiAFIAZLGyIFBH1DAABAwSADKgJEIAMtAFhBAkYiBhsiFEMAABBBIAMqAkggBhsgFJNDAAB+Q5UgBUEBa0H/AXGzlJIQiQQiFCAUkgVDAAAAAAshFCAHRSEGIARBDGovAQAiBEH//wFxRQRAIARBEHQMAwsgBEH/B3EhAyAEQYCAAnEhBSAEQYD4AXEiBEGA+AFGBEAgBUEQdCIEQYCAgPwHciADRQ0DGiAEIANBDXRyQYCAgP4HcgwDCyAFQRB0IQUgBEUNASAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogBXIMAgsgCSAGQdy7xwAQjAcACyADIANnQRBrIgNB//8DcUEIanRB////A3EgBUGAgIDYA3IgA0EXdGtyC74iFkMAAIA/XgRAIBYQxgVDVPgtQJRDAACAP5KRIRILIAdBAnQgCmohCiAGQQJ0IABqIQAgAkEEaiECIA0gDCALIBUgE5QiEyATWyATIBQgEpRgRXEiAxsoAgA2AgAgDCADQQJ0IgNrIQwgAyALakEEayELIA1BBGshDSAPQQFrIg8NAAsgDEEEaiEDIAFBAXEEfyACIAAgCiAAIANJIgEbKAIANgIAIAogACADT0ECdGohCiAAIAFBAnRqBSAACyADRyAKIAtBBGpHckUEQA8LEIAIAAvnEAILfwF+IwBBIGsiAyQAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAgAiBEGAgICAeHMgBEEAThtBFGsOAgECAAsgASADQRRqQeTjwAAQlQghASAAQYCAgIB4NgIAIAAgATYCBAwHCwJAAkACfwJAIAEoAgwiCARAAkAgASgCCCIFKAIAQZSAgIB4RgRAAkAgBSgCDCIEBEAgA0EEaiAFKAIIEKgDIAMoAgQiAUGAgICAeEcNASADKAIIIQQMBwtBACADQRRqQYTiwAAQ2wYhBAwGCyADKAIIIQIgBEEBRg0BIANBATYCBCAEQQFrQf////8AcUEBaiADQQRqQeiVwQAQ2wYhBCABRQ0FIAIgAUEBEKIHDAULIAUgA0EUakGE4sAAEJUIIQQMBAsgCEEBRg0BIAMoAgwhCUGAgICAeCEGAkACfwJAAkBBFSAFQRBqIgooAgAiC0GAgICAeHMgC0EAThtBEGsOAwMBAwALIANBBGogChCoA0GBgICAeCADKAIEIgQgBEGBgICAeEwbDAELIANBBGogBSgCFBCoA0GBgICAeCADKAIEIgQgBEGBgICAeEwbCyEGIAMoAgwhByADKAIIIgQgBkH/////B2pBAkkNAxoLIAhBAkYNBCADQQI2AgQgCEH+////AGpB/////wBxQQJqIANBBGpB6JXBABDbBiEFIABBgICAgHg2AgAgACAFNgIEIAEEQCACIAFBARCiBwsgBkGAgICAeHJBgICAgHhGDQsgBCAGQQEQogcMCwtBAEHs/cAAQYD9wAAQ2wYhBAwCC0EBQez9wABBgP3AABDbBgshBCABRQ0AIAJBBGsoAgAiBkF4cSIFQQRBCCAGQQNxIgYbIAFqSQ0KIAZBACAFIAFBJ2pLGw0JIAIQogILIAAgBDYCBCAAQYCAgIB4NgIADAcLIAAgBzYCFCAAIAQ2AhAgACAGNgIMIAAgCTYCCCAAIAI2AgQgACABNgIADAYLIAEoAgghBCABKAIEIQEgA0IANwIMIAMgATYCBCADIAEgBEEFdGoiCjYCCCAERQRAQYGAgIB4IQUMAgtBgICAgHghB0GBgICAeCEFA0AgAyABQSBqIgQ2AgQgAyADKAIQQQFqNgIQIAMgAUEQaiILNgIMAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAgAiAkGAgICAeHMgAkEAThtBAWsODwAGBgEGBgYGBgYGAgMEBQYLIAEtAAQiAkUNCEEBQQIgAkEBRhshAgwLCyABKQMIIg1QDQdBAUECIA1CAVEbIQIMCgsgASgCCCECIAEoAgxBBWsOBAULCwcLCyABKAIEIQICQCABKAIIQQVrDgQECwsACwsgAikAAELl3I37xqyat+cAUQ0JDAoLIAEoAgghAgJAAkAgASgCDEEFaw4EAAsLAQsLIAItAABB5gBHDQogAi0AAUHpAEcNCiACLQACQewARw0KIAItAANB5QBHDQogAi0ABEHzAEcNCgwFCyACLQAAQeUARw0JIAItAAFB7gBHDQkgAi0AAkHjAEcNCSACLQADQe8ARw0JIAItAARB5ABHDQkgAi0ABUHpAEcNCSACLQAGQe4ARw0JIAItAAdB5wBGDQgMCQsgASgCBCECAkACQCABKAIIQQVrDgQACgoBCgsgAi0AAEHmAEcNCSACLQABQekARw0JIAItAAJB7ABHDQkgAi0AA0HlAEcNCSACLQAEQfMARw0JDAQLIAItAABB5QBHDQggAi0AAUHuAEcNCCACLQACQeMARw0IIAItAANB7wBHDQggAi0ABEHkAEcNCCACLQAFQekARw0IIAItAAZB7gBHDQggAi0AB0HnAEYNBwwICyABIANBFGpB5OTAABCVCCEBDA0LIAJBkP3AAEEFENsHDQYMAQsgAkGQ/cAAQQUQ2wcNBQsgB0GAgICAeEYNAUGQ/cAAQQUQnwchAQwKCyACKQAAQuXcjfvGrJq35wBRDQIMAwsgA0EUaiADQQRqELIFIAMoAhghASADKAIUIgdBgICAgHhGBEBBgICAgHghBwwJCyADKAIcIQwgAygCCCEKIAMoAgQhBCABIQYMBAsgAkECRg0BCyAFQYGAgIB4Rg0BQcj9wABBCBCfByEBIAVBgICAgHhyQYCAgIB4Rg0IDAcLIANBADYCDAwBCyADQQA2AgxBgICAgHghBQJ/AkACQEEVIAsoAgAiAkGAgICAeHMgAkEAThtBEGsOAwMBAwALIANBFGogCxCoAyAIIAMoAhwgAygCFCIBQYCAgIB4RhshCEGBgICAeCABIAFBgYCAgHhMGwwBCyADQRRqIAEoAhQQqAMgCCADKAIcIAMoAhQiAUGAgICAeEYbIQhBgYCAgHggASABQYGAgIB4TBsLIQUgAygCGCIJIQEgBUGBgICAeEYNBgsgCiAEIgFHDQALDAALIAdBgICAgHhGDQAgACAINgIUIAAgCTYCECAAIAw2AgggACAGNgIEIAAgBzYCACAAQYCAgIB4IAUgBUGBgICAeEYbNgIMDAQLQYCAgIB4IQdBkP3AAEEFEJwHIQELIAVFIAVBgoCAgHhIcg0BCyAJQQRrKAIAIgRBeHEiAkEEQQggBEEDcSIEGyAFakkNAyAEQQAgAiAFQSdqSxsNAiAJEKICCyAHQYCAgIB4ckGAgICAeEcEQCAGQQRrKAIAIgRBeHEiBUEEQQggBEEDcSIEGyAHakkNAyAEQQAgBSAHQSdqSxsNAiAGEKICCyAAQgA3AhAgACABNgIEIABBgICAgHg2AgALIANBIGokAA8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC7QPAgl/BH4jAEHgAmsiASQAAkACQAJAIAAtAIAERQRAIAAoApABIgJBAkcNAiAAKAIAQQJHDQIgACgCuAIiA0EDSw0BQQAhAgwDCyAANQK4AiEKIABBADYCuAIgACAKIAApA3B8NwNwDAILIABBkAFqIQggASAAKAK0AiIEKAAAIgI2AhACQAJAAkACQAJAAkACQAJAAkAgAkHSgpGaBEcEQCACQdKCkYIDRw0CIANBCEkNASADIAQoAAQiBUEHakF4cUEIaiICSQ0BIAVBCGoiBiADSyAFQXdLcg0DIAFBADYC2AIgASAFNgLUAiABIARBCGo2AtACIAFBIGogAUHQAmoQWSABKAIkIQUgASgCICIHQQJGBEAgBRDOByECDAwLIAFBsAFqIAFBKGpBgAH8CgAAIABBADYCuAIgASAFNgKsASABIAc2AqgBIAMgAmshBgJAAkAgAkUNACACIANGDQEgBkUNACAEIAIgBGogBvwKAAALIAAgBjYCuAILIAAgACkDcCACrXwiCjcDeCAAIAo3A3AgASgCpAJBAUcNBCAAIAEoApQCIgQ2ApwCIAAgASgCtAEgASgCwAEiAyABKAKwARsiAjYCoAIgAkUNBSAEIAMgAm4iBCACIARsIANHaiICRgRAIAEtAKgCIQIgASAFQQAgB0EBcRs2AiQgASADNgIgIAEgAkEBcToAKCAAQbwCaiABQSBqEOEDAkAgACgCkAFBAkYNACAAKAL4ASEEIAAoAvwBIgMEQCAEQSRqIQIDQCACQQRrKAIAIgVBgICAgHhyQYCAgIB4RwRAIAIoAgAiBkEEaygCACIHQXhxIglBBEEIIAdBA3EiBxsgBWpJDQsgB0EAIAkgBUEnaksbDQwgBhCiAgsgAkEwaiECIANBAWsiAw0ACwsgACgC9AEiAwRAIAQgA0EwbEEIEKIHCyAAKAKAAiIDQYCAgIB4ckGAgICAeEYNACAAKAKEAiADQQEQogcLIAggAUGoAWpBiAH8CgAADAoLIAEgAjYCzAIgAUECNgIkIAFB6MfBADYCICABQgI3AiwgAUKAgICAECIKIABBnAJqrYQ3A9gCIAEgCiABQcwCaq2ENwPQAiABIAFB0AJqNgIoIAFBwAJqIgAgAUEgahCxBgwICyABQQhqIAAQtwIgAS0ACEUEQCABLQAJDQlBACECDAsLIAEoAgwhAgwKC0EAIQIMCQsgAUEBNgI0IAFBzMjBADYCMCABQQE2AiQgAUHEyMEANgIgIAFBATYCLCABIAFBEGqtQoCAgICQBIQ3A9ACIAEgAUHQAmo2AiggAUEUaiIAIAFBIGoQsQYgABCOByECDAgLQQggBiADQZzIwQAQ6gcACyABQQE2AiQgAUGUyMEANgIgIAFCATcCLCABIAFBpAJqrUKAgICAEIQ3A9ACIAEgAUHQAmo2AiggAUG0AmoiACABQSBqELEGDAMLQbTHwQAQgQgAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgABCOByECIAFBqAFqEM8EDAILIAgoAgAhAgsCQAJAAkACQAJ/AkAgAkECRwRAIAAoApgCIAAoApwCTw0GIAAoAgBBAkYNAUEADAILIAFBqAFqIAAQNiABKAKsAUEAIAEtAKgBIgMbIQIgAw0GIAEtAKkBQQFxRQ0GIAApA4gBIgwgACkDcCIKWARAIAAoArgCIQMMBQsgACgCuAIhBEEAIQMgAEEANgK4AiAEIAwgCn0iCyAErSINIAsgDVQbIgunIgVrIQIgC1BFBEAgBCAFRg0EIAJFDQMgACgCtAIiAyADIAVqIAL8CgAADAMLIAQgBUcNAgwDC0EBCyECA0ACQAJAAkACQAJAAkACQAJAAkACQAJAIAJFBEAgAUGoAWogABA2IAEoAqwBIQMgAS0AqAEiAg0CIAEtAKkBQQFxRQ0CIAApA4gBIgogACkDcCIMVg0BDAYLIAFBqAFqIAAQtwIgAS0AqAFBAUYEQCABKAKsASECDBELIAEtAKkBDQlBACECDBALIAAoArgCIQMgAEEANgK4AiADIAogDH0iCyADrSINIAsgDVQbIgunIgJrIQQgC1ANASACIANGDQMgBEUNAiAAKAK0AiIDIAIgA2ogBPwKAAAMAgsgA0EAIAIbIQIMDgsgAiADRg0BCyAAIAQ2ArgCCyAAIAsgDHwiDDcDcCAKIAxWDQELAkAgACgCAEECRg0AIAAoAlwiA0UNACAAKAJgIgJBBGsoAgAiBEF4cSIFIANBKGwiA0EEQQggBEEDcSIEG2pJDQIgBEEAIAUgA0EnaksbDQMgAhCiAgsgAEECNgIAIAAgACgCmAJBAWoiAzYCmAIgAyAAKAKcAkkNBAwJC0EAIQIMCQtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQQAhAgwBC0EBIQIMAAsACyAAIAI2ArgCIAIhAwsgACAKIAt8Igo3A3AgCiAMWg0AQQAhAgwCC0EAIQIgAEEANgK4AiAAQQE6AIAEIAAgCiADrXw3A3AMAQsgAEEBOgCABCAANQK4AiEKQQAhAiAAQQA2ArgCIAAgCiAAKQNwfDcDcAsgAUHgAmokACACC5sMAgh/BH4gACgCFCEDIAAoAhAhBSAAKQMIIQsgACgCBCEJIAAoAgAhCCAAKAIYIgJBAEgEQCAFIAlJBEAgCCAFQQJ0aigAACEGCyAGQRh0IAZBgP4DcUEIdHIgBkEIdkGA/gNxIAZBGHZycq0gC0IghoQhCyAFQQFqIQUgAkEgaiECCyALIAMgA0EBdiIDayIErSACQT9xrYYiDEIAIAsgDFoiBht9IQogAiADIAQgBhsiA2ciAkEYayIEQQAgAiAETxsiBGshAiADIAR0IQQCQCABQf8BcUECSQ0AIAJBAEgEQEEAIQYgBSAJSQRAIAggBUECdGooAAAhBgsgBkEYdCAGQYD+A3FBCHRyIAZBCHZBgP4DcSAGQRh2cnKtIApCIIaEIQogBUEBaiEFIAJBIGohAgsgCiAEIARBAXYiBmsiBK0gAkE/ca2GIg1CACAKIA1aIgMbfSEKIAIgBiAEIAMbIgZnIgJBGGsiBEEAIAIgBE8bIgRrIQIgBiAEdCEEIANBAkEAIAsgDFobciEGIAFB/wFxQQJGDQAgAkEASARAQQAhAyAFIAlJBEAgCCAFQQJ0aigAACEDCyADQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZycq0gCkIghoQhCiAFQQFqIQUgAkEgaiECCyAKIAQgBEEBdiIEayIHrSACQT9xrYYiC0IAIAogC1oiAxt9IQogAiAEIAcgAxsiBGciAkEYayIHQQAgAiAHTxsiB2shAiAEIAd0IQQgAyAGQQF0ciEGIAFB/wFxQQRJDQAgAkEASARAQQAhAyAFIAlJBEAgCCAFQQJ0aigAACEDCyADQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZycq0gCkIghoQhCiAFQQFqIQUgAkEgaiECCyAKIAQgBEEBdiIEayIHrSACQT9xrYYiC0IAIAogC1oiAxt9IQogAiAEIAcgAxsiBGciAkEYayIHQQAgAiAHTxsiB2shAiAEIAd0IQQgAyAGQQF0ciEGIAFB/wFxQQRGDQAgAkEASARAQQAhAyAFIAlJBEAgCCAFQQJ0aigAACEDCyADQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZycq0gCkIghoQhCiAFQQFqIQUgAkEgaiECCyAKIAQgBEEBdiIEayIHrSACQT9xrYYiC0IAIAogC1oiAxt9IQogAiAEIAcgAxsiBGciAkEYayIHQQAgAiAHTxsiB2shAiAEIAd0IQQgAyAGQQF0ciEGIAFB/wFxQQZJDQAgAkEASARAQQAhAyAFIAlJBEAgCCAFQQJ0aigAACEDCyADQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZycq0gCkIghoQhCiAFQQFqIQUgAkEgaiECCyAKIAQgBEEBdiIEayIHrSACQT9xrYYiC0IAIAogC1oiAxt9IQogAiAEIAcgAxsiBGciAkEYayIHQQAgAiAHTxsiB2shAiAEIAd0IQQgAyAGQQF0ciEGIAFB/wFxQQZGDQAgAkEASARAQQAhAyAFIAlJBEAgCCAFQQJ0aigAACEDCyADQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZycq0gCkIghoQhCiAFQQFqIQUgAkEgaiECCyAKIAQgBEEBdiIEayIHrSACQT9xrYYiC0IAIAogC1oiAxt9IQogAiAEIAcgAxsiBGciAkEYayIHQQAgAiAHTxsiB2shAiAEIAd0IQQgAyAGQQF0ciEGIAFB/wFxQQhJDQAgAkEASARAQQAhAyAFIAlJBEAgCCAFQQJ0aigAACEDCyADQRh0IANBgP4DcUEIdHIgA0EIdkGA/gNxIANBGHZycq0gCkIghoQhCiAFQQFqIQUgAkEgaiECCyAKIAQgBEEBdiIEayIIrSACQT9xrYYiC0IAIAogC1oiAxt9IQogAiAEIAggAxsiBGciAkEYayIIQQAgAiAITxsiCGshAiAEIAh0IQQgAyAGQQF0ciEGCyAFIAlNBEAgACACNgIYIAAgBDYCFCAAIAU2AhAgACAKNwMIIAYPCyAAIAEQ8AcLyA0CDH8BfiMAQdAAayIIJAAgCEEQaiAAKAIEIgYgACgCCCICQficxgBBCRDhAQJAAkACQCAIKAIQQQFGBEAgCEEYaiEHIAgoAkwhAyAIKAJIIQkgCCgCRCEEIAgoAkAhBSAIKAI0QX9GDQEgCEEEaiAHIAUgBCAJIANBABDeAwwCCyAIAn9BACAILQAeDQAaIAgtAB0hCgJAIAgoAhgiAQRAIAgoAkAhDAJAIAgoAkQiBSABTQRAIAEgBUYNAQwHCyABIAxqLAAAQUBIDQYLIAEgDGoiB0EBaywAACIEQQBIBEAgBEE/cQJ/IAdBAmstAAAiCcAiC0G/f0oEQCAJQR9xDAELIAtBP3ECfyAHQQNrLQAAIgPAIglBv39KBEAgA0EPcQwBCyAJQT9xIAdBBGstAABBB3FBBnRyC0EGdHILQQZ0ciEECyAKQQFxDQECf0F/IARBgAFJDQAaQX4gBEGAEEkNABpBfUF8IARBgIAESRsLIAFqIgFFBEBBACEBDAILAkAgASAFTwRAIAEgBUcNBwwBCyABIAxqLAAAQUBIDQYLIAEgDGoiCUEBaywAAEEATg0BIAlBAmssAAAaDAELQQAiASAKQQFxRQ0BGgsgCCABNgIIQQELNgIEDAELIAhBBGogByAFIAQgCSADQQEQ3gMLAkACQAJAAkAgCCgCBEEBRgRAIAgoAggiCUEJaiIFIQEDQAJAIAFFDQAgASACTwRAIAEgAkYNAQwHCyABIAZqLAAAQUBIDQYLAkAgASACRgR/IAIFIAEgBmotAABBMGtB/wFxQQpJDQEgAQshBCABRQ0DAkAgAiAETQRAIAIgBEcNAQwFCyAEIAZqLAAAQb9/Sg0ECyAGIAIgBCACQZSdxgAQuwkACyABQQFqIQEMAAsAC0EAIQoMAQtBACEKIAIgBGtBCEkNACAEIAZqIgcpAABCoMa949aum7cgUg0AIARBCGoiCyEDAkACQAJAAkADQAJAIANFDQAgAiADTQRAIAIgA0YNAQwICyADIAZqLAAAQUBIDQcLAkACQAJAIAIgA0YEQCACIQMMAQsgAyAGai0AAEEwa0H/AXFBCkkNASACIANLDQgLIAQgBUkNAyAFRQ0BIAUgBmosAABBv39KDQEMAwsgA0EBaiEDDAELCyABBEAgBywAAEFASA0BCyAFIAZqIQECQAJAAkAgBCAFayIEDgIHAAELQQEhByABLQAAQStrDgMGAQYBCyABLQAAQStGBEAgBEEBayEHIAFBAWohASAEQQpJDQEMAwsgBCEHIARBCU8NAgtBACEEA0AgAS0AAEEwayIFQQlLDQQgAUEBaiEBIAUgBEEKbGohBCAHQQFrIgcNAAsMAgsgBiACIAUgBEG8ncYAELsJAAtBACEEA0AgB0UNASABLQAAQTBrIgVBCUsNAiAErUIKfiINQiCIpw0CIAFBAWohASAHQQFrIQcgBSANp2oiBCAFTw0ACwwBCwJAAkAgAyALSQ0AIAsEQCACIAtNBEAgAiADRg0DDAILIAIgA0cNASAGIAtqLAAAQUBIDQEMAgsgAiADRg0BCyAGIAIgCyADQcydxgAQuwkACyAGIAtqIQECQAJAAkACQAJAIAIgC2siBQ4CBgABC0EBIQMgAS0AAEEraw4DBQEFAQsgAS0AAEErRgRAIAVBAWshAyABQQFqIQEgBUEKSQ0BDAILIAUiA0EJTw0BC0EAIQUDQCABLQAAQTBrIgdBCUsNBCABQQFqIQEgByAFQQpsaiEFIANBAWsiAw0ACwwBC0EAIQUDQCADRQ0BIAEtAABBMGsiB0EJSw0DIAWtQgp+Ig1CIIinDQMgAUEBaiEBIANBAWshAyAHIAcgDadqIgVNDQALDAILQQEhCiACIAlJDQEgCUUEQCAJIQIMAgsgAiAJTQRAIAkhAgwCCyAJIgIgBmosAABBv39KDQFB5J/GAEEwQdydxgAQ6wcACwsCQAJAAkACQCAAKAIAIgMgAk0NACACRQRAIAZBBGsoAgAiAEF4cSIJQQRBCCAAQQNxIgAbIANqSQ0CIABBACAJIANBJ2pLGw0DIAYQogJBASEGDAELIAYgA0EBIAIQuwIiBkUNAwtBFBBxIgBFDQIgACACNgIIIAAgBjYCBCAAQQA2AgAgACAFQQAgChs2AhAgACAEQQAgChs2AgwgCEHQAGokACAADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwsACyAGIAIgAyACQaydxgAQuwkACyAGIAIgASACQYSdxgAQuwkACyAMIAVBACABQfylxgAQuwkAC4kOAw5/BH4BeyMAQSBrIgokAAJAAkACQCAAKAIMIgsgAWoiASALTwRAAkAgACgCBCIIIAhBAWoiCUEDdiIDQQdsIg4gCEEISRsiBkEBdiABSQRAAkACQAJAAkACfyAGQQFqIgMgASABIANJGyIBQQ9PBEAgAUH/////AUsNC0F/IAFBA3RBB25BAWtndkEBagwBC0EEIAFBCHFBCGogAUEESRsLIgGtQhR+IhFCIIinDQAgEadBB2pBeHEiAyABQQhqIgZqIgUgA0kgBUH4////B0tyDQAgBRBxIgVFDQEgAyAFaiEEIAYEQCAEQf8BIAb8CwALIAFBAWsiCSABQQN2QQdsIAlBCEkbIQwgACgCACEFIAsNAkEAIQsMAwsgCkEANgIYIApBATYCDCAKQcS1xAA2AgggCkIENwIQIApBCGpBmLXEABCNCAsACyAEQQhqIQ0gBUEUayEOIAUpAwBCf4VCgIGChIiQoMCAf4MhESACKQMIIRMgAikDACEUQQAhASALIQIgBSEGA0AgEVAEQANAIAFBCGohASAGQQhqIgYpAwBCgIGChIiQoMCAf4MiEUKAgYKEiJCgwIB/UQ0ACyARQoCBgoSIkKDAgH+FIRELIAQgCSAUIBMgDiAReqdBA3YgAWoiD0FsbGoiA0EEaigCACADQQhqKAIAEJUEpyIQcSIDaikAAEKAgYKEiJCgwIB/gyISUARAQQghBwNAIAMgB2ohAyAHQQhqIQcgBCADIAlxIgNqKQAAQoCBgoSIkKDAgH+DIhJQDQALCyARQgF9IBGDIREgBCASeqdBA3YgA2ogCXEiA2osAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhAwsgAyAEaiAQQRl2Igc6AAAgDSADQQhrIAlxaiAHOgAAIAQgA0F/c0EUbGoiA0EQaiAFIA9Bf3NBFGxqIgdBEGooAAA2AAAgAyAH/QAAAP0LAAAgAkEBayICDQALCyAAIAk2AgQgACAENgIAIAAgDCALazYCCCAIRQ0BIAggCEEUbEEbakF4cSIBakEJaiIARQ0BIAUgAWsiAUEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAGpJDQMgAkEAIAMgAEEnaksbDQQgARCiAgwBCyAAIAkEfyAAKAIAIQACQAJAIAMgCUEHcUEAR2oiBUECSQRAIAUhBgwBCyAFQQFxIQYgBUH+////A3EiBEEDdCEHIAQhAyAAIQEDQCABIAH9AAMAIhX9TUEH/c0B/QwBAQEBAQEBAQEBAQEBAQEB/U4gFf0Mf39/f39/f39/f39/f39/f/1Q/c4B/QsDACABQRBqIQEgA0ECayIDDQALIAQgBUYNAQsgACAHaiEBA0AgASABKQMAIhFCf4VCB4hCgYKEiJCgwIABgyARQv/+/fv379+//wCEfDcDACABQQhqIQEgBkEBayIGDQALCwJAIAlBCE8EQCAAIAlqIAApAAA3AAAMAQsgCUUNACAAQQhqIAAgCfwKAAALIABBCGohBSACKQMIIRIgAikDACETQQEhA0EAIQEDQCABIQYgAyEBAkAgACAGaiIMLQAAQYABRw0AIAAgBkF/c0EUbGohAyAAIAZBbGxqIgJBDGshDyACQRBrIRADQCAIIBMgEiAQKAIAIA8oAgAQlQSnIg1xIgQhAiAAIARqKQAAQoCBgoSIkKDAgH+DIhFQBEBBCCEHA0AgAiAHaiECIAdBCGohByAAIAIgCHEiAmopAABCgIGChIiQoMCAf4MiEVANAAsLIAAgEXqnQQN2IAJqIAhxIgJqLAAAQQBOBEAgACkDAEKAgYKEiJCgwIB/g3qnQQN2IQILIAIgBGsgBiAEa3MgCHFBCE8EQCAAIAJqIgQtAAAgBCANQRl2IgQ6AAAgBSACQQhrIAhxaiAEOgAAIAAgAkF/c0EUbGohAkH/AUYEQCAMQf8BOgAAIAUgCCAGQQhrcWpB/wE6AAAgAkEQaiADQRBqKAAANgAAIAIgA/0AAAD9CwAADAMLIAMoAAAhBCADIAIoAAA2AAAgAiAENgAAIAIoAAQhBCACIAMoAAQ2AAQgAyAENgAEIAMoAAghBCADIAIoAAg2AAggAiAENgAIIAIoAAwhBCACIAMoAAw2AAwgAyAENgAMIAMoABAhBCADIAIoABA2ABAgAiAENgAQDAELCyAMIA1BGXYiAjoAACAFIAggBkEIa3FqIAI6AAALIAEgASAJSSICaiEDIAINAAsgCCAOIAhBCEkbBUEACyALazYCCAsgCkEgaiQADwsMAgtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIApBADYCGCAKQQE2AgwgCkHEtcQANgIIIApCBDcCECAKQQhqQZi1xAAQjQgAC8cNAQh/An8CQCACIANLBEAgASADQRJsaiIDLwEAIgJB//8BcUUEQCACQRB0DAMLIAJB/wdxIQEgAkGAgAJxIQUgAkGA+AFxIgJBgPgBRgRAIAVBEHQhAiACQYCAgPwHciABRQ0DGiACIAFBDXRyQYCAgP4HcgwDCyAFQRB0IQUgAkUNASACQQ10QYCAgPwAcSABQQ10ckGAgIDAA2ogBXIMAgsgAyACQfTAxwAQjAcACyAFQYCAgNgDciABZ0EQayICQRd0ayABIAJB//8DcUEIanRB////A3FyCyEBAn8gAy8BAiIFQf//AXFFBEAgBUEQdAwBCyAFQf8HcSECIAVBgIACcSEGIAVBgPgBcSIFQYD4AUYEQCAGQRB0IQUgBUGAgID8B3IgAkUNARogBSACQQ10ckGAgID+B3IMAQsgBkEQdCEGIAVBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAGciAFDQAaIAZBgICA2ANyIAJnQRBrIgVBF3RrIAIgBUH//wNxQQhqdEH///8DcXILIQUCfyADLwEEIgZB//8BcUUEQCAGQRB0DAELIAZB/wdxIQIgBkGAgAJxIQcgBkGA+AFxIgZBgPgBRgRAIAdBEHQhBiAGQYCAgPwHciACRQ0BGiAGIAJBDXRyQYCAgP4HcgwBCyAHQRB0IQcgBkENdEGAgID8AHEgAkENdHJBgICAwANqIAdyIAYNABogB0GAgIDYA3IgAmdBEGsiBkEXdGsgAiAGQf//A3FBCGp0Qf///wNxcgshBgJ/IAMvAQYiB0H//wFxRQRAIAdBEHQMAQsgB0H/B3EhAiAHQYCAAnEhCCAHQYD4AXEiB0GA+AFGBEAgCEEQdCEHIAdBgICA/AdyIAJFDQEaIAcgAkENdHJBgICA/gdyDAELIAhBEHQhCCAHQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogCHIgBw0AGiAIQYCAgNgDciACZ0EQayIHQRd0ayACIAdB//8DcUEIanRB////A3FyCyEHAn8gAy8BCCIIQf//AXFFBEAgCEEQdAwBCyAIQf8HcSECIAhBgIACcSEJIAhBgPgBcSIIQYD4AUYEQCAJQRB0IQggCEGAgID8B3IgAkUNARogCCACQQ10ckGAgID+B3IMAQsgCUEQdCEJIAhBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAJciAIDQAaIAlBgICA2ANyIAJnQRBrIghBF3RrIAIgCEH//wNxQQhqdEH///8DcXILIQgCfyADLwEKIglB//8BcUUEQCAJQRB0DAELIAlB/wdxIQIgCUGAgAJxIQogCUGA+AFxIglBgPgBRgRAIApBEHQhCSAJQYCAgPwHciACRQ0BGiAJIAJBDXRyQYCAgP4HcgwBCyAKQRB0IQogCUENdEGAgID8AHEgAkENdHJBgICAwANqIApyIAkNABogCkGAgIDYA3IgAmdBEGsiCUEXdGsgAiAJQf//A3FBCGp0Qf///wNxcgshCQJ/IAMvAQwiCkH//wFxRQRAIApBEHQMAQsgCkH/B3EhAiAKQYCAAnEhBCAKQYD4AXEiCkGA+AFGBEAgBEEQdCEKIApBgICA/AdyIAJFDQEaIAogAkENdHJBgICA/gdyDAELIARBEHQhBCAKQQ10QYCAgPwAcSACQQ10ckGAgIDAA2ogBHIgCg0AGiAEQYCAgNgDciACZ0EQayIKQRd0ayACIApB//8DcUEIanRB////A3FyCyEKAn8gAy8BDiIEQf//AXFFBEAgBEEQdAwBCyAEQf8HcSECIARBgIACcSELIARBgPgBcSIEQYD4AUYEQCALQRB0IQQgBEGAgID8B3IgAkUNARogBCACQQ10ckGAgID+B3IMAQsgC0EQdCELIARBDXRBgICA/ABxIAJBDXRyQYCAgMADaiALciAEDQAaIAtBgICA2ANyIAJnQRBrIgRBF3RrIAIgBEH//wNxQQhqdEH///8DcXILIQIgAAJ/IAMvARAiBEH//wFxRQRAIARBEHQMAQsgBEH/B3EhAyAEQYCAAnEhCyAEQYD4AXEiBEGA+AFGBEAgC0EQdCEEIARBgICA/AdyIANFDQEaIAQgA0ENdHJBgICA/gdyDAELIAtBEHQhCyAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogC3IgBA0AGiALQYCAgNgDciADZ0EQayIEQRd0ayADIARB//8DcUEIanRB////A3FyCzYCICAAIAI2AhwgACAKNgIYIAAgCTYCFCAAIAg2AhAgACAHNgIMIAAgBjYCCCAAIAU2AgQgACABNgIAC/sJAQd/IAAoAgQhAgJAAkAgACgCCCIFBEAgAiEBA0AgAUEoaigCACIGBEAgAUEsaigCACIHQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyAGakkNAyADQQAgBCAGQSdqSxsNBCAHEKICCyABEL8EIAFBQGshASAFQQFrIgUNAAsLIAAoAgAiAwRAIAJBBGsoAgAiAUF4cSIEIANBBnQiA0EEQQggAUEDcSIBG3JJDQEgAUEAIAQgA0EncksbDQIgAhCiAgsCQCAAKAKEASIBQYCAgIB4Rg0AIAEEQCAAKAKIASIEQQRrKAIAIgJBeHEiAyABQQN0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACADIAFBJ2pLGw0DIAQQogILIAAoApABIgEEQCAAKAKUASIEQQRrKAIAIgJBeHEiAyABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACADIAFBJ2pLGw0DIAQQogILIAAoApwBIgEEQCAAKAKgASIEQQRrKAIAIgJBeHEiAyABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACADIAFBJ2pLGw0DIAQQogILIAAoAqgBIgFFDQAgACgCrAEiBEEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAIMIgEEQCAAKAIQIgRBBGsoAgAiAkF4cSIDIAFByABsIgFBBEEIIAJBA3EiAhtqSQ0BIAJBACADIAFBJ2pLGw0CIAQQogILIAAoAhgiAQRAIAAoAhwiBEEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAIkIgEEQCAAKAIoIgRBBGsoAgAiAkF4cSIDIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAMgAUEnaksbDQIgBBCiAgsgACgCMCIBBEAgACgCNCIEQQRrKAIAIgJBeHEiAyABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACADIAFBJ2pLGw0CIAQQogILIAAoAjwiAQRAIAAoAkAiBEEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAJIIgEEQCAAKAJMIgRBBGsoAgAiAkF4cSIDIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAMgAUEnaksbDQIgBBCiAgsgACgCVCIBBEAgACgCWCIEQQRrKAIAIgJBeHEiAyABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACADIAFBJ2pLGw0CIAQQogILIAAoAmAiAQRAIAAoAmQiBEEEaygCACICQXhxIgMgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAJsIgEEQCAAKAJwIgRBBGsoAgAiAkF4cSIDIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAMgAUEnaksbDQIgBBCiAgsgACgCeCICBEAgACgCfCIDQQRrKAIAIgBBeHEiASACQQJ0IgJBBEEIIABBA3EiABtqSQ0BIABBACABIAJBJ2pLGw0CIAMQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL1A0CF38BeyABQeTRAGohEiABQYAEaiETIAFBgM8AaiEUIAFBgB1qIRUgAUGg0QBqIRYgAUGANmohFyABQe3RAGohGCMAQfAAayIIQTBqIRkgAS0A61EhBCAIQRhqIRECfwNAAkACQAJAAkACQAJAIARB/wFxIgsOAwABAgMLIBH9DAAAAAAAAAAAAAAAAAAAAAAiGv0LAwAgCCAa/QsDCEEAIQUgCEEsakEAQcQA/AsAA0AgASAFaiIDQbAEav0MHgMeAx4DHgMeAx4DHgMeAyIa/QsCACADQaAEaiAa/QsCACADQZAEaiAa/QsCACADQYAEaiAa/QsCACAFQUBrIgVBgBBHDQALQaACIQQgEyEMIBQhDwwDCyAR/QwAAAAAAAAAAAAAAAAAAAAAIhr9CwMAIAggGv0LAwhBACEFIAhBLGpBAEHEAPwLAANAIAEgBWoiA0GwHWr9DB4DHgMeAx4DHgMeAx4DHgMiGv0LAgAgA0GgHWogGv0LAgAgA0GQHWogGv0LAgAgA0GAHWogGv0LAgAgBUFAayIFQYAQRw0AC0EgIQQgFSEMIBYhDwwCCyAR/QwAAAAAAAAAAAAAAAAAAAAAIhr9CwMAIAggGv0LAwhBACEFIAhBLGpBAEHEAPwLAANAIAEgBWoiA0GwNmr9DB4DHgMeAx4DHgMeAx4DHgMiGv0LAgAgA0GgNmogGv0LAgAgA0GQNmogGv0LAgAgA0GANmogGv0LAgAgBUFAayIFQYAQRw0AC0ETIQQgFyEMIBghDwwCC0EDDAMLIAxBgBBqQQBBgAn8CwALQRwhCUEDIBIgC0EBdGovAQAiECAESw0BGiAQBEAgECEFIA8hBANAQQMgBC0AACIDQQ9LDQMaIAhBCGogA0EBdGoiAyADLwEAQQFqOwEAIARBAWohBCAFQQFrIgUNAAsLQQAhBEEBIQNBACEFQQAhCgNAAkACfyADRQRAIARBD0sNAiAEQQFqDAELIARBECAEayIGIAMgAyAGSxsiBiAEaiIHIAQgB0sbIgRBD0sNASAGIANrIQYDQCAGBEAgBkEBaiEGIARBAWoiBEEQRw0BDAMLC0EAIQMgBEEBagsgGSAEQQJ0aiAFIAhBCGogBEEBdGovAQAiBGpBAXQiBTYCACAEIApqIQohBAwBCwsgBUGAgARHBEBBASALQQJGIApB//8DcUEBS3INAhoLIAxBgBBqIQ1B//8DIQlBACEKA0AgCiAQSQRAIApBAWohBANAIAohCyAEIQoCQCALIA9qLQAAQQ9xIgdFDQAgCEEsaiAHQQJ0aiIDIAMoAgAiA0EBajYCAAJ/IANBf0EgIAdrdnEiA0GABE8EQCADQQh0IANBgP4DcUEIdnIiA0EEdkGPHnEgA0GPHnFBBHRyIgNBAnZBs+YAcSADQbPmAHFBAnRyIgNBAXZB1aoBcSADQdWqAXFBAXRyDAELIANBAXQvAZT/RAtB//8DcUEQIAdrdiEFIAdBCk0EQCAFQf8HSw0BIAdBCXQgC3IhA0EBIAd0IgZBAXQhCyAMIAVBAXRqIQQDQCAEIAM7AQAgBCALaiEEIAUgBmoiBUGACEkNAAsMAQsgDCAFQf8HcUEBdGoiAy8BACIGQZ4GRwR/IAkFIAMgCTsBACAJIgZBAmsLIQMCQCAHQQtGBEAgBUEJdiEODAELQQohCUEDIAVBCnYiDkEBcSAGQX9zakH//wNxIgRBvwRLDQYaIA0gBEEBdGoiBC8BACIGBH8gAwUgBCADOwEAIAMhBiADQQJrCyEEIAdBDUkEQCAEIQMMAQtBAyAFQQt2Ig5BAXEgBkF/c2pB//8DcSIDQb8ESw0GGiANIANBAXRqIgMvAQAiBgR/IAQFIAMgBDsBACAEIQYgBEECawshAyAHQQ1GDQBBAyAFQQx2Ig5BAXEgBkF/c2pB//8DcSIEQb8ESw0GGiANIARBAXRqIgQvAQAiBgR/IAMFIAQgAzsBACADIQYgA0ECawshBCAHQQ9HBEAgBCEDDAELQQMgBUENdiIOQQFxIAZBf3NqQf//A3EiA0G/BEsNBhogDSADQQF0aiIDLwEAIgYEQCAEIQMMAQsgAyAEOwEAIARBAmshAyAEIQYLIA5BAXZBAXEgBkF/c2pB//8DcSIEQb8ESwRAQQohCUEDDAYLIA0gBEEBdGogCzsBACADIQkMAwsgCiAKIBBJIgNqIQQgAw0ACwsLAkACQAJAIAEtAOtRIgMOAwABAgELIAJBADYCDEEMIQlBAQwDCyABIANBAWsiBDoA61EMAQsLIAJBADYCDEEKIQlBAQshBCAAIAk6AAEgACAEOgAAC6IOBAp/A30BewF+IwBB0ARrIgokAAJAAkACQAJAAnsgAxC5CiISBEBDAACAPyEUQwAAgD8hFUMAAIA/IRb9DAAAAAAAAIA/AABAwQAAEEEMAQsgCkHQAWogAxC1ASAKLQDsASINQQJGBEAgCigC0AEhCyAAQQA2AgAgACALNgIEQQEhDQwCCyAKQQ5qIApB7wFqLQAAOgAAIAogCi8A7QE7AQwgCioC6AEhFCAKKgLkASEVIAoqAuABIRYgCv0ABNABCyEXQQYhDAJAAkACQAJAAkAgASgCACILQYCAgIB4Rg0AIApBEGogASgCBCIOIAEoAggQkQUgCi0AEEEBRgRAIAooAhQhDCAKQQA2ApwDIApCgICAgBA3ApQDIApBnJPBADYC1AEgCkKggICADjcC2AEgCiAKQZQDajYC0AEgDCAKQdABahCvBA0CIAooApQDIQ0gCigCmAMiDyAKKAKcAxDsCCERIA0EQCAPQQRrKAIAIhBBeHEiE0EEQQggEEEDcSIQGyANakkNCSAQQQAgEyANQSdqSxsNCiAPEKICC0EAIQ0gAEEANgIAIAAgETYCBCAMIAwoAgAoAgARAwAgC0UNBiAOQQRrKAIAIgBBeHEiDEEEQQggAEEDcSIAGyALakkNCCAAQQAgDCALQSdqSxsNCSAOEKICDAYLIAotABEhDCALRQ0AIA5BBGsoAgAiAUF4cSIPQQRBCCABQQNxIgEbIAtqSQ0HIAFBACAPIAtBJ2pLGw0IIA4QogILQQQhAUEAIQtBABC2CSEQQQAhDkEEIQ8CQCAEQQFxRQ0AIApB0AFqIAUQlwYgCigC2AEhESAKKALUASEPIAooAtABIQ4gBUGECEkNACAFEJsHC0EAIQUCQCAGQQFxRQ0AIApB0AFqIAcQlwYgCigC2AEhBSAKKALUASEBIAooAtABIQsgB0GECEkNACAHEJsHC0EEIQdBACEGQQAhBAJAIAhBAXFFDQAgCkHQAWogCRCXBiAKKALYASEEIAooAtQBIQcgCigC0AEhBiAJQYQISQ0AIAkQmwcLIAogDToA7AIgCiAUOALoAiAKIBU4AuQCIAogFjgC4AIgCiAX/QsC0AIgCkGAgICAeDYCxAIgCkKAgICAgICAgIB/NwK0AiAKQoCAgIDAADcCrAIgCiAENgKoAiAKIAc2AqQCIAogBjYCoAIgCiAFNgKcAiAKIAE2ApgCIAogCzYClAIgCiARNgKQAiAKIA82AowCIAogDjYCiAIgCkEANgKAAiAKQQA2AvgBIApBADYC8AEgCkEANgLoASAKQQA2AuABIApBADYC2AEgCkEANgLQASAKQYgDakEAOgAAQQIhCSAKQe8CaiAKQQ5qLQAAOgAAIApBADYC+AIgCiAQNgL8AiAKQgA3AvACIApCADcCgAMgCiAKLwEMOwDtAiACKAIAIQQgAigCBCEGIAIoAgghAQJ/IAxBBkcEQCAKIAwgCkHQAWoQ1QMgCigCBCEFIAooAgAMAQsgCkGUA2ogCkHUAWpBuAH8CgAAQQAhCUEACyEIQYCAgIB4IQcgBEGAgICAeEcEQCABQQBIDQICQCABRQRAQQEhBwwBCyABEHEiB0UNBAsgAQRAIAcgBiAB/AoAAAsgB60gAa1CIIaEIRggASEHCyAKQRhqIgIgCkGUA2pBuAH8CgAAQewBEHEiAUUNAiABIAk2AgAgAUEEaiACQbgB/AoAACABIAw6AOgBIAEgBTYC5AEgASAINgLgASABQYCAgIB4NgLUASABIBg3AswBIAEgBzYCyAEgAUEANgLEASABQoCAgIAQNwK8ASAAQZDwwAA2AgwgAEEBNgIIIABB+O/AADYCBCAAIAE2AgAgEkUgA0GECElyDQMgAxCbBwwDC0GgnsYAQTcgCkHPBGpBtJPBAEHYnsYAEOAGAAtB2JrIABD/BwsACyAEQYCAgIB4ckGAgICAeEYNAQJAIAZBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIARqTwRAIABBACABIARBJ2pLGw0BIAYQogIMAwsMAwsMAwsgCEUgCUGECElyRQRAIAkQmwcLIAZFIAdBhAhJckUEQCAHEJsHCyAERSAFQYQISXJFBEAgBRCbBwsgEkUgA0GECElyRQRAIAMQmwcLIAIoAgAiAEGAgICAeHJBgICAgHhHBEAgAigCBCICQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyAAakkNAiADQQAgBCAAQSdqSxsNAyACEKICCyANIAEoAgAiAEGAgICAeEdxRSAARXINACABKAIEIgFBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIABqSQ0BIAJBACADIABBJ2pLGw0CIAEQogILIApB0ARqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvLDQMPfwR+AXsjAEEgayIKJAACQAJAAkAgACgCDCILQQFqIgMEQAJAIAAoAgQiCCAIQQFqIglBA3YiAkEHbCIOIAhBCEkbIgZBAXYgA0kEQAJAAkACQAJAAn8gBkEBaiICIAMgAiADSxsiA0EPTwRAIANB/////wFLDQtBfyADQQN0QQduQQFrZ3ZBAWoMAQtBBCADQQhxQQhqIANBBEkbCyIDrUIYfiIRQiCIpw0AIBGnIgIgA0EIaiIGaiIFIAJJIAVB+P///wdLcg0AIAUQcSIFRQ0BIAIgBWohBCAGBEAgBEH/ASAG/AsACyADQQFrIgkgA0EDdkEHbCAJQQhJGyEMIAAoAgAhBSALDQJBACELDAMLIApBADYCGCAKQQE2AgwgCkHEtcQANgIIIApCBDcCECAKQQhqQZi1xAAQjQgLAAsgBEEIaiENIAVBGGshDiAFKQMAQn+FQoCBgoSIkKDAgH+DIREgASkDCCETIAEpAwAhFEEAIQMgCyEBIAUhBgNAIBFQBEADQCADQQhqIQMgBkEIaiIGKQMAQoCBgoSIkKDAgH+DIhFCgIGChIiQoMCAf1ENAAsgEUKAgYKEiJCgwIB/hSERCyAEIAkgFCATIA4gEXqnQQN2IANqIg9BaGxqEPgDpyIQcSICaikAAEKAgYKEiJCgwIB/gyISUARAQQghBwNAIAIgB2ohAiAHQQhqIQcgBCACIAlxIgJqKQAAQoCBgoSIkKDAgH+DIhJQDQALCyARQgF9IBGDIREgBCASeqdBA3YgAmogCXEiAmosAABBAE4EQCAEKQMAQoCBgoSIkKDAgH+DeqdBA3YhAgsgAiAEaiAQQRl2Igc6AAAgDSACQQhrIAlxaiAHOgAAIAQgAkF/c0EYbGoiAkEQaiAFIA9Bf3NBGGxqIgdBEGopAAA3AAAgAiAH/QAAAP0LAAAgAUEBayIBDQALCyAAIAk2AgQgACAENgIAIAAgDCALazYCCCAIRQ0BIAggCEEYbEEfakF4cSIBakEJaiIARQ0BIAUgAWsiAUEEaygCACIDQXhxIgJBBEEIIANBA3EiAxsgAGpJDQMgA0EAIAIgAEEnaksbDQQgARCiAgwBCyAAIAkEfyAAKAIAIQACQAJAIAIgCUEHcUEAR2oiBUECSQRAIAUhBgwBCyAFQQFxIQYgBUH+////A3EiBEEDdCEHIAQhAiAAIQMDQCADIAP9AAMAIhX9TUEH/c0B/QwBAQEBAQEBAQEBAQEBAQEB/U4gFf0Mf39/f39/f39/f39/f39/f/1Q/c4B/QsDACADQRBqIQMgAkECayICDQALIAQgBUYNAQsgACAHaiEDA0AgAyADKQMAIhFCf4VCB4hCgYKEiJCgwIABgyARQv/+/fv379+//wCEfDcDACADQQhqIQMgBkEBayIGDQALCwJAIAlBCE8EQCAAIAlqIAApAAA3AAAMAQsgCUUNACAAQQhqIAAgCfwKAAALIABBCGohBSAAQRhrIQ8gASkDCCESIAEpAwAhE0EBIQJBACEDA0AgAyEGIAIhAwJAIAAgBmoiDC0AAEGAAUcNACAPIAZBaGxqIRAgACAGQX9zQRhsaiECA0AgCCATIBIgEBD4A6ciDXEiBCEBIAAgBGopAABCgIGChIiQoMCAf4MiEVAEQEEIIQcDQCABIAdqIQEgB0EIaiEHIAAgASAIcSIBaikAAEKAgYKEiJCgwIB/gyIRUA0ACwsgACAReqdBA3YgAWogCHEiAWosAABBAE4EQCAAKQMAQoCBgoSIkKDAgH+DeqdBA3YhAQsgASAEayAGIARrcyAIcUEITwRAIAAgAWoiBC0AACAEIA1BGXYiBDoAACAFIAFBCGsgCHFqIAQ6AAAgACABQX9zQRhsaiEBQf8BRgRAIAxB/wE6AAAgBSAIIAZBCGtxakH/AToAACABQRBqIAJBEGopAAA3AAAgASAC/QAAAP0LAAAMAwsgAikAACERIAIgASkAADcAACABIBE3AAAgASkACCERIAEgAikACDcACCACIBE3AAggAigAECEEIAIgASgAEDYAECABKAAUIQcgASACKAAUNgAUIAIgBzYAFCABIAQ2ABAMAQsLIAwgDUEZdiIBOgAAIAUgCCAGQQhrcWogAToAAAsgAyADIAlJIgFqIQIgAQ0ACyAIIA4gCEEISRsFQQALIAtrNgIICyAKQSBqJAAPCwwCC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgCkEANgIYIApBATYCDCAKQcS1xAA2AgggCkIENwIQIApBCGpBmLXEABCNCAALgg0CCX8HfSADQQhPBEAgACAAIANBA3YiA0EEdCIGaiAAIANBHGwiB2ogAyAEEMEBIQAgASABIAZqIAEgB2ogAyAEEMEBIQEgAiACIAZqIAIgB2ogAyAEEMEBIQILQwAAgD8hDgJ/AkAgACgCACIDIAQoAgBBBGooAgAiBEEIaigCACIHSQRAIAEoAgAhBiAEQQRqKAIAIgkgA0EkbGoiCBCKBCEQIAgvARQiBEH//wFxIgxFBEAgBEEQdAwDCyAEQf8HcSEDIARBgIACcSEFIARBgPgBcSIKQYD4AUYEQCAFQRB0IQUgBUGAgID8B3IgA0UNAxogBSADQQ10ckGAgID+B3IMAwsgBUEQdCEFIApFDQEgCkENdEGAgID8AHEgA0ENdHJBgICAwANqIAVyDAILIAMgB0HUwMcAEIwHAAsgBUGAgIDYA3IgA2dBEGsiBUEXdGsgAyAFQf//A3FBCGp0Qf///wNxcgu+Ig9DAACAP14EQCAPEMYFQ1T4LUCUQwAAgD+SkSEOC0MAAIA/IRICfwJAIAYgB0kEQCAJIAZBJGxqIgoQigQhDyAKLwEUIgZB//8BcSINRQRAIAZBEHQMAwsgBkH/B3EhAyAGQYCAAnEhBSAGQYD4AXEiC0GA+AFGBEAgBUEQdCEFIAVBgICA/AdyIANFDQMaIAUgA0ENdHJBgICA/gdyDAMLIAVBEHQhBSALRQ0BIAtBDXRBgICA/ABxIANBDXRyQYCAgMADaiAFcgwCCyAGIAdB1MDHABCMBwALIAVBgICA2ANyIANnQRBrIgVBF3RrIAMgBUH//wNxQQhqdEH///8DcXILviIRQwAAgD9eBEAgERDGBUNU+C1AlEMAAIA/kpEhEgsgAigCACEFIAgQigQhEUMAAIA/IRMCfyAEQRB0IAxFDQAaIARB/wdxIQMgBEGAgAJxIQggBEGA+AFxIgRBgPgBRgRAIAhBEHQhBCAEQYCAgPwHciADRQ0BGiAEIANBDXRyQYCAgP4HcgwBCyAIQRB0IQggBEENdEGAgID8AHEgA0ENdHJBgICAwANqIAhyIAQNABogCEGAgIDYA3IgA2dBEGsiBEEXdGsgAyAEQf//A3FBCGp0Qf///wNxcgu+IhRDAACAP14EQCAUEMYFQ1T4LUCUQwAAgD+SkSETCwJ/AkAgBSAHSQRAIBAgEJIgDpQiDiAPIA+SIBKUYEUhCCAOIA5bIQsgCSAFQSRsaiIHEIoEIRAgBy8BFCIDQf//AXEiDEUEQCADQRB0DAMLIANB/wdxIQQgA0GAgAJxIQUgA0GA+AFxIglBgPgBRgRAIAVBEHQhBSAFQYCAgPwHciAERQ0DGiAFIARBDXRyQYCAgP4HcgwDCyAFQRB0IQUgCUUNASAJQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIMAgsgBSAHQdTAxwAQjAcACyAFQYCAgNgDciAEZ0EQayIFQRd0ayAEIAVB//8DcUEIanRB////A3FyC0MAAIA/IQ6+Ig9DAACAP14EQCAPEMYFQ1T4LUCUQwAAgD+SkSEOCyAIIAtxIgUgESARkiATlCIPIA9bIA8gECAQkiAOlGBFcUYEfyAKEIoEIRBDAACAPyEPAn8gBkEQdCANRQ0AGiAGQf8HcSEAIAZBgIACcSEEIAZBgPgBcSIGQYD4AUYEQCAEQRB0IQQgBEGAgID8B3IgAEUNARogBCAAQQ10ckGAgID+B3IMAQsgBEEQdCEEIAZBDXRBgICA/ABxIABBDXRyQYCAgMADaiAEciAGDQAaIARBgICA2ANyIABnQRBrIgRBF3RrIAAgBEH//wNxQQhqdEH///8DcXILviIOQwAAgD9eBEAgDhDGBUNU+C1AlEMAAIA/kpEhDwtDAACAPyEOIAIgASAFIBAgEJIgD5QiECAQWyAQIAcQigQiEiASkgJ/IANBEHQgDEUNABogA0H/B3EhACADQYCAAnEhBCADQYD4AXEiA0GA+AFGBEAgBEEQdCEDIANBgICA/AdyIABFDQEaIAMgAEENdHJBgICA/gdyDAELIARBEHQhBCADQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2ogBHIgAw0AGiAEQYCAgNgDciAAZ0EQayIDQRd0ayAAIANB//8DcUEIanRB////A3FyC74iEUMAAIA/XgR9IBEQxgVDVPgtQJRDAACAP5KRBSAOC5RgRXFzGwUgAAsLww0DBHsIfwF+AkACQAJAAkBBfyAELQC/AiILQQ9xdCIJQf8BcUH/AUcEQEH/ASAJQX9zIg9B/wFxbiEMQQEgC3RBlgJxRSALQQhLcg0BIAQoAtABIQogBCgCzAEhDSAEKALUASEQQQggC25BAXStIAGtfiIRQiCIUCARpyADSXENAiAAIAFqIQ4gA0F+cSEEAkAgC0EIRwRAIARFDQZBCCALayEJIA1BgYCAgHhGBEBBACEKQQAgBGshAUF/IQQDQCAEQQBIBEAgACAORg0EIAAtAAAhCiAJIQQgAEEBaiEACyACQQFqQf8BOgAAIAIgCiAEdiAPcSAMbDoAACAEIAtrIQQgAkECaiECIAFBAmoiAQ0ACwwHCyAQBEBBACADQX5xayEBQQAhA0F/IQQDQCAEQQBIBEAgACAORg0EIAAtAAAhAyAJIQQgAEEBaiEACyACIANB/wFxIAR2IA9xIg0gDGw6AAAgAkEBakF/QQAgDSAKLQAARxs6AAAgBCALayEEIAJBAmohAiABQQJqIgENAAsMBwsgAUUNAUEAQQBBkJnFABCMBwALIAFFDQUgDUGBgICAeEYEQCADQQF2IgMgAUEBayIBIAEgA0sbIgFBEEkgACACIAFBAXRqQQJqSSAAIAFqQQFqIAJLcXJFBEAgACABQQFqIgEgAUEPcSIBQRAgARtrIglqIAQgCUEBdCIDayEEIAIgA2ogDP0PIQYDQCACQR9qQf8BOgAAIAJBHWpB/wE6AAAgAkEbakH/AToAACACQRlqQf8BOgAAIAJBF2pB/wE6AAAgAkEVakH/AToAACACQRNqQf8BOgAAIAJBEWpB/wE6AAAgAkEPakH/AToAACACQQ1qQf8BOgAAIAJBC2pB/wE6AAAgAkEJakH/AToAACACQQdqQf8BOgAAIAJBBWpB/wE6AAAgAkEDakH/AToAACACQQFqQf8BOgAAIAJBHmogAP0AAAAiBf0WDyAG/RYPbDoAACACQRxqIAX9Fg4gBv0WDmw6AAAgAkEaaiAF/RYNIAb9Fg1sOgAAIAJBGGogBf0WDCAG/RYMbDoAACACQRZqIAX9FgsgBv0WC2w6AAAgAkEUaiAF/RYKIAb9FgpsOgAAIAJBEmogBf0WCSAG/RYJbDoAACACQRBqIAX9FgggBv0WCGw6AAAgAkEOaiAF/RYHIAb9FgdsOgAAIAJBDGogBf0WBiAG/RYGbDoAACACQQpqIAX9FgUgBv0WBWw6AAAgAkEIaiAF/RYEIAb9FgRsOgAAIAJBBmogBf0WAyAG/RYDbDoAACACQQRqIAX9FgIgBv0WAmw6AAAgAkECaiAF/RYBIAb9FgFsOgAAIAIgBf0WACAG/RYAbDoAACAAQRBqIQAgAkEgaiECIAlBEGsiCQ0ACyECIQALA0AgBEUNByACQQFqQf8BOgAAIAIgAC0AACAMbDoAACAEQQJrIQQgAkECaiECIA4gAEEBaiIARw0ACwwGCyAQBEAgA0EBdiIDIAFBAWsiASABIANLGyIBQQ9NDQUgAiAAIAFqQQFqSSAAIAIgAUEBdGpBAmoiA0lxIAIgCkEBakkgAyAKS3FyDQUgACABQQFqIgEgAUEPcSIBQRAgARtrIglqIAQgCUEBdCIDayEEIAIgA2ohAyAK/QcAACEHIAz9DyEGA0AgAiAA/QAAACIF/RYAIAb9FgBs/Q8gBf0WASAG/RYBbP0XASAF/RYCIAb9FgJs/RcCIAX9FgMgBv0WA2z9FwMgBf0WBCAG/RYEbP0XBCAF/RYFIAb9FgVs/RcFIAX9FgYgBv0WBmz9FwYgBf0WByAG/RYHbP0XByAF/RYIIAb9Fghs/RcIIAX9FgkgBv0WCWz9FwkgBf0WCiAG/RYKbP0XCiAF/RYLIAb9Fgts/RcLIAX9FgwgBv0WDGz9FwwgBf0WDSAG/RYNbP0XDSAF/RYOIAb9Fg5s/RcOIAX9Fg8gBv0WD2z9Fw8iCCAFIAf9JCIF/Q0IGAkZChoLGwwcDR0OHg8f/QsAECACIAggBf0NABABEQISAxMEFAUVBhYHF/0LAAAgAEEQaiEAIAJBIGohAiAJQRBrIgkNAAshACADIQIMBQsgBEUNBUEAQQBBkJnFABCMBwALQfyWxQBBIkGgl8UAEKsHAAtBgJnFABCBCAALQbCXxQBBNEHkl8UAEOsHAAtBhJbFAEHlAEHslsUAEOsHAAsDQCAERQ0BIAIgAC0AACIBIAxsOgAAIAJBAWpBf0EAIAEgCi0AAEcbOgAAIARBAmshBCACQQJqIQIgAEEBaiIAIA5HDQALCwu+DAIGfwR+IwBBwAFrIgQkAAJAAkACQCAAKQMAQgJRDQAgACgCqAEhASAAQQA2AqgBAkACQAJAAkAgAUEBaw4CAQIACyAEQQhqIQICQAJAQSUQcSIBRQ0AIAFBHWpBnZ3HACkAADcAACABQRBqQZCdxwD9AAAA/QsAACABQYCdxwD9AAAA/QsAAEEMEHEiA0UNACADQSU2AgggAyABNgIEIANBJTYCAEEMEHEiAUUNACABQSg6AAggAUG4nccANgIEIAEgAzYCACACQQA2AhAgAiABrUIghkIDhDcDAAwBCwALDAILIARBGGogAEHAAWopAwA3AwAgBCAA/QADsAH9CwMIDAELIAAoAqwBIgFBQGshAiABKAIkIQMgASgCICEFAkAgASkDGCIHQgJSBEAgASkDOCEIIARBMGogAUEQaikDADcDACAEQegAaiACQQhq/QADAP0LAwAgBEGoAWogAUGIAWr9AAMA/QsDACAEQZgBaiABQfgAav0AAwD9CwMAIARBuAFqIAFBmAFqKQMANwMAIAQgAf0AAwD9CwMgIAQgAf0AAyj9CwNIIAQgAikDADcDYCAEIAH9AANY/QsDeCAEIAH9AANo/QsDiAEgBEEYaiAEQdAAaikDADcDACAEIAM2AkQgBCAFNgJAIAQgBzcDOCAEIAg3A1ggBCAE/QADQP0LAwggBCgCJCEDIAQoAiAhBSAEQfgAahCEBQwBCyAEQRhqIAJBEGopAwA3AwAgBCAC/QADAP0LAwgLIAMEQCAFQQRrKAIAIgJBeHEiBkEEQQggAkEDcSICGyADakkNAyACQQAgBiADQSdqSxsNBCAFEKICCyABQQRrKAIAIgNBeHFBvAFBwAEgA0EDcSICG0kNAiACQQAgA0HgAU8bDQMgARCiAgsCQCAEKAIYIgEEQCAEKQMQIghQDQEgASkDCCEHIAEoAgQiA60hCQNAAkAgByADIAcgCSAHIAlUG6ciAmsiBUKAwAAgCCAIQoDAAFobpyIGIAUgBkkbrSIKfCEHIAIgA0YNACAIIAp9IghCAFINAQsLIAEgBzcDCAwBCyAELQAIQQNHDQAgBCgCDCIBKAIAIQMgAUEEaigCACICKAIAIgUEQCADIAURAwALIAIoAgQiAgRAIANBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIAJqSQ0DIAVBACAGIAJBJ2pLGw0EIAMQogILIAFBBGsoAgAiA0F4cSICQRBBFCADQQNxIgMbSQ0CIANBACACQTRPGw0DIAEQogILIAAoAiwiAQRAIAAoAigiA0EEaygCACICQXhxIgVBBEEIIAJBA3EiAhsgAWpJDQIgAkEAIAUgAUEnaksbDQMgAxCiAgsgACgCNCIBBEAgACgCMCIDQQRrKAIAIgJBeHEiBUEEQQggAkEDcSICGyABakkNAiACQQAgBSABQSdqSxsNAyADEKICCwJAIAAoAowBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAoAowBEN0FCwJAIAAoApABIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAoApABEN0FCyAAKAI8IgEEQCAAKAI4IgNBBGsoAgAiAkF4cSIFQQRBCCACQQNxIgIbIAFqSQ0CIAJBACAFIAFBJ2pLGw0DIAMQogILIAAoAngiAUUNACAAKAJ8IgNBBGsoAgAiAkF4cSIFIAFBBXQiAUEEQQggAkEDcSICG3JJDQEgAkEAIAUgAUEnaksbDQIgAxCiAgsgACgCqAFBAk8EQAJAIAAoAqwBIgApAxhCAlEEQCAAKAIkIgFFDQEgACgCICIDQQRrKAIAIgJBeHEiBUEEQQggAkEDcSICGyABakkNAyACQQAgBSABQSdqSxsNBCADEKICDAELIAAoAgQiAQRAIAAoAgAiA0EEaygCACICQXhxIgVBBEEIIAJBA3EiAhsgAWpJDQMgAkEAIAUgAUEnaksbDQQgAxCiAgsgAEHYAGoQhAULIABBBGsoAgAiAUF4cUG8AUHAASABQQNxIgMbSQ0BIANBACABQeABTxsNAiAAEKICCyAEQcABaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALuQ4DBX8CfQF+IwBBIGsiAiQAAkAgASgCACIEQYy1xABBBCABKAIEIgMoAgwiBREAAARAQQEhAwwBCwJAAkACQCABKAIIIgZBgICABHFFBEBBASEDIARBu7PFAEEBIAURAAANBCAGQYCAgAFxIQUgACoCACEHIAZBgICAgAFxDQEgAEEEaiEEIAeLIghDyhsOWmAgB0MAAAAAXCAIQxe30ThdcXJFBEAgASAHIAVBAEdBARD3AkUNAwwFCyABIAcgBUEARxDPAkUNAgwECyAEQduBwgBBAiAFEQAABEBBASEDDAQLIAJBAToADyACIAM2AgQgAiAENgIAIAJB4IHCADYCFCACIAEpAggiCTcCGCAJpyIEQYCAgAFxIQMgAiACQQ9qNgIIIAIgAjYCECAAKgIAIQcCQAJAIARBgICAgAFxRQRAIAeLIghDyhsOWmAgB0MAAAAAXCAIQxe30ThdcXINASACQRBqIAcgA0EAR0EBEPcCDQUMAgsgAkEQaiAHIANBAEcgCUIwiKcQvQJFDQEMBAsgAkEQaiAHIANBAEcQzwINAwsgAigCEEHZgcIAQQIgAigCFCgCDBEAAARAQQEhAwwECyAAQQRqIQQMAQsgASAHIAVBAEcgAS8BDhC9Ag0CIABBBGohBAsCQAJAAkACQAJAIAEoAggiA0GAgIAEcUUEQCABKAIAQeeQxgBBAiABKAIEKAIMEQAABEBBASEDDAgLIANBgICAAXEhBSAEKgIAIQcgA0GAgICAAXENASAAQQhqIQQgB4siCEPKGw5aYCAHQwAAAABcIAhDF7fROF1xckUEQEEBIQMgASAHIAVBAEdBARD3AkUNBQwICyABIAcgBUEARxDPAkUNBEEBIQMMBwsgASkCACEJIAJBAToADyACIAk3AgAgAkHggcIANgIUIAIgASkCCCIJNwIYIAmnIgVBgICAAXEhAyACIAJBD2o2AgggAiACNgIQIAQqAgAhByAFQYCAgIABcUUNASACQRBqIAcgA0EARyAJQjCIpxC9AkUNAgwECyABIAcgBUEARyABLwEOEL0CBEBBASEDDAYLIABBCGohBAwCCyAHiyIIQ8obDlpgIAdDAAAAAFwgCEMXt9E4XXFyRQRAIAJBEGogByADQQBHQQEQ9wINAwwBCyACQRBqIAcgA0EARxDPAg0CCyACKAIQQdmBwgBBAiACKAIUKAIMEQAARQRAIABBCGohBAwBC0EBIQMMAwsCQAJAAkACQAJAIAEoAggiA0GAgIAEcUUEQCABKAIAQeeQxgBBAiABKAIEKAIMEQAABEBBASEDDAkLIANBgICAAXEhBSAEKgIAIQcgA0GAgICAAXENASAAQQxqIQQgB4siCEPKGw5aYCAHQwAAAABcIAhDF7fROF1xckUEQEEBIQMgASAHIAVBAEdBARD3AkUNBQwJCyABIAcgBUEARxDPAkUNBEEBIQMMCAsgASkCACEJIAJBAToADyACIAk3AgAgAkHggcIANgIUIAIgASkCCCIJNwIYIAmnIgVBgICAAXEhAyACIAJBD2o2AgggAiACNgIQIAQqAgAhByAFQYCAgIABcUUNASACQRBqIAcgA0EARyAJQjCIpxC9AkUNAgwECyABIAcgBUEARyABLwEOEL0CBEBBASEDDAcLIABBDGohBAwCCyAHiyIIQ8obDlpgIAdDAAAAAFwgCEMXt9E4XXFyRQRAIAJBEGogByADQQBHQQEQ9wINAwwBCyACQRBqIAcgA0EARxDPAg0CCyACKAIQQdmBwgBBAiACKAIUKAIMEQAARQRAIABBDGohBAwBC0EBIQMMBAsCQAJAAkACQAJAIAEoAggiA0GAgIAEcUUEQCABKAIAQeeQxgBBAiABKAIEKAIMEQAABEBBASEDDAoLIANBgICAAXEhACAEKgIAIQcgA0GAgICAAXENASAHiyIIQ8obDlpgIAdDAAAAAFwgCEMXt9E4XXFyRQRAQQEhAyABIAcgAEEAR0EBEPcCRQ0FDAoLQQEhAyABIAcgAEEARxDPAkUNBAwJCyABKQIAIQkgAkEBOgAPIAIgCTcCACACQeCBwgA2AhQgAiABKQIIIgk3AhggCaciA0GAgIABcSEAIAIgAkEPajYCCCACIAI2AhAgBCoCACEHIANBgICAgAFxRQ0BIAJBEGogByAAQQBHIAlCMIinEL0CRQ0CDAQLQQEhAyABIAcgAEEARyABLwEOEL0CDQcMAgsgB4siCEPKGw5aYCAHQwAAAABcIAhDF7fROF1xckUEQCACQRBqIAcgAEEAR0EBEPcCDQMMAQsgAkEQaiAHIABBAEcQzwINAgsgAigCEEHZgcIAQQIgAigCFCgCDBEAAEUNAEEBIQMMBQsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAQLQQEhAwwDC0EBIQMMAgtBASEDDAELQQEhAwsgAkEgaiQAIAML6A4CC38BfiMAQSBrIgMkAEGAgICAeCEHAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAgAiBEGAgICAeHMgBEEAThtBFGsOAgECAAsgASADQRRqQaTjwAAQlQghASAAQYCAgIB4NgIAIAAgATYCBAwKCyABKAIMIgVFDQECQCABKAIIIgEoAgBBlICAgHhGBEACQCABKAIMIgIEQCADQQRqIAEoAggQqAMgAygCBCIEQYCAgIB4Rw0BIAMoAgghAQwMC0EAIANBFGpBhOLAABDbBiEBDAsLIAMoAgghCCACQQFGDQEgA0EBNgIEIAJBAWtB/////wBxQQFqIANBBGpB6JXBABDbBiEBIARFDQogCCAEQQEQogcMCgsgASADQRRqQYTiwAAQlQghAQwJCwJAAn8gBUEBRwRAIAMoAgwhBiADQQRqIgcgAUEQahDQAyADKAIIIgEgAygCBCICQYCAgIB4Rg0BGiAFQQJGDQIgA0ECNgIEIAVB/v///wBqQf////8AcUECaiAHQeiVwQAQ2wYhBSAAQYCAgIB4NgIAIAAgBTYCBCAEBEAgCCAEQQEQogcLIAJFDQwgASACQQJ0QQQQogcMDAtBAUHsgMEAQYD9wAAQ2wYLIQEgBEUNCSAIQQRrKAIAIgVBeHEiAkEEQQggBUEDcSIFGyAEakkNDCAFQQAgAiAEQSdqSxsNCyAIEKICDAkLIAAgAygCDDYCFCAAIAE2AhAgACACNgIMIAAgBjYCCCAAIAg2AgQgACAENgIADAkLIAEoAgghBCABKAIEIQEgA0IANwIMIAMgATYCBCADIAEgBEEFdGoiCTYCCCAERQ0CQYCAgIB4IQYDQCADIAFBIGoiBDYCBCADIAMoAhBBAWo2AhAgAyABQRBqIgo2AgwCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRUgASgCACICQYCAgIB4cyACQQBOG0EBaw4PAAsLAQsLCwsLCwsCAwQFCwsgAS0ABCIBRQ0HQQFBAiABQQFGGyEBDAsLIAEpAwgiDVANBkEBQQIgDUIBURshAQwKCyABKAIIIQIgASgCDEEFaw4EBAsLBgsLIAEoAgQhAgJAIAEoAghBBWsOBAMLCwALCyACKQAAQuPekaum7Nu36wBRDQkMCgsgASgCCCECAkACQCABKAIMQQVrDgQACwsBCwsgAi0AAEHmAEcNCiACLQABQekARw0KIAItAAJB7ABHDQogAi0AA0HlAEcNCiACLQAEQfMARw0KDAQLIAItAABB4wBHDQkgAi0AAUHvAEcNCSACLQACQeQARw0JIAItAANB5QBHDQkgAi0ABEHiAEcNCSACLQAFQe8ARw0JIAItAAZB7wBHDQkgAi0AB0HrAEYNCAwJCyABKAIEIQICQAJAIAEoAghBBWsOBAAKCgEKCyACLQAAQeYARw0JIAItAAFB6QBHDQkgAi0AAkHsAEcNCSACLQADQeUARw0JIAItAARB8wBHDQkMAwsgAi0AAEHjAEcNCCACLQABQe8ARw0IIAItAAJB5ABHDQggAi0AA0HlAEcNCCACLQAEQeIARw0IIAItAAVB7wBHDQggAi0ABkHvAEcNCCACLQAHQesARg0HDAgLIAJBkP3AAEEFENsHDQcMAQsgAkGQ/cAAQQUQ2wcNBgsgBkGAgICAeEYNAUGQ/cAAQQUQnwchBAwMCyACKQAAQuPekaum7Nu36wBRDQMMBAsgA0EUaiADQQRqELIFIAMoAhghBCADKAIUIgZBgICAgHhGBEBBgICAgHghBgwLCyADKAIcIQsgAygCCCEJIAQhCCADKAIEDAULIAEgA0EUakH048AAEJUIIQQMCQsgAUECRg0BCyAHQYCAgIB4Rg0BQZj+wABBCBCfByEEIAdFDQkMCAsgA0EANgIMIAQMAQsgA0EANgIMIANBFGogChDQAyADKAIYIQUgAygCFCIHQYCAgIB4RgRAIAUhBAwICyADKAIcIQwgBAsiASAJRw0ACwwBC0EAQeyAwQBBgP3AABDbBiEBDAYLIAZBgICAgHhGDQAgB0GAgICAeEYEQEGY/sAAQQgQnAchBCAGRQ0FIAggBkEBEKIHDAULIAAgDDYCFCAAIAU2AhAgACAHNgIMIAAgCzYCCCAAIAg2AgQgACAGNgIADAYLQYCAgIB4IQZBkP3AAEEFEJwHIQQLIAdBgICAgHhyQYCAgIB4Rg0BCyAFQQRrKAIAIgFBeHEiAiAHQQJ0IgdBBEEIIAFBA3EiARtqSQ0FIAFBACACIAdBJ2pLGw0EIAUQogILIAZBgICAgHhyQYCAgIB4Rg0AIAhBBGsoAgAiAUF4cSIFQQRBCCABQQNxIgEbIAZqSQ0EIAFBACAFIAZBJ2pLGw0DIAgQogILIAAgBDYCBCAAQYCAgIB4NgIADAELIAAgATYCBCAAQYCAgIB4NgIACyADQSBqJAAPC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAvoDgILfwF+IwBBIGsiAyQAQYCAgIB4IQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQRUgASgCACIEQYCAgIB4cyAEQQBOG0EUaw4CAQIACyABIANBFGpB5OLAABCVCCEBIABBgICAgHg2AgAgACABNgIEDAoLIAEoAgwiBUUNAQJAIAEoAggiASgCAEGUgICAeEYEQAJAIAEoAgwiAgRAIANBBGogASgCCBCoAyADKAIEIgRBgICAgHhHDQEgAygCCCEBDAwLQQAgA0EUakGE4sAAENsGIQEMCwsgAygCCCEIIAJBAUYNASADQQE2AgQgAkEBa0H/////AHFBAWogA0EEakHolcEAENsGIQEgBEUNCiAIIARBARCiBwwKCyABIANBFGpBhOLAABCVCCEBDAkLAkACfyAFQQFHBEAgAygCDCEGIANBBGoiByABQRBqENADIAMoAggiASADKAIEIgJBgICAgHhGDQEaIAVBAkYNAiADQQI2AgQgBUH+////AGpB/////wBxQQJqIAdB6JXBABDbBiEFIABBgICAgHg2AgAgACAFNgIEIAQEQCAIIARBARCiBwsgAkUNDCABIAJBAnRBBBCiBwwMC0EBQbz+wABBgP3AABDbBgshASAERQ0JIAhBBGsoAgAiBUF4cSICQQRBCCAFQQNxIgUbIARqSQ0MIAVBACACIARBJ2pLGw0LIAgQogIMCQsgACADKAIMNgIUIAAgATYCECAAIAI2AgwgACAGNgIIIAAgCDYCBCAAIAQ2AgAMCQsgASgCCCEEIAEoAgQhASADQgA3AgwgAyABNgIEIAMgASAEQQV0aiIJNgIIIARFDQJBgICAgHghBgNAIAMgAUEgaiIENgIEIAMgAygCEEEBajYCECADIAFBEGoiCjYCDAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBFSABKAIAIgJBgICAgHhzIAJBAE4bQQFrDg8ACwsBCwsLCwsLCwIDBAULCyABLQAEIgFFDQdBAUECIAFBAUYbIQEMCwsgASkDCCINUA0GQQFBAiANQgFRGyEBDAoLIAEoAgghAiABKAIMQQVrDgQECwsGCwsgASgCBCECAkAgASgCCEEFaw4EAwsLAAsLIAIpAABC496Rq6bs27frAFENCQwKCyABKAIIIQICQAJAIAEoAgxBBWsOBAALCwELCyACLQAAQeYARw0KIAItAAFB6QBHDQogAi0AAkHsAEcNCiACLQADQeUARw0KIAItAARB8wBHDQoMBAsgAi0AAEHjAEcNCSACLQABQe8ARw0JIAItAAJB5ABHDQkgAi0AA0HlAEcNCSACLQAEQeIARw0JIAItAAVB7wBHDQkgAi0ABkHvAEcNCSACLQAHQesARg0IDAkLIAEoAgQhAgJAAkAgASgCCEEFaw4EAAoKAQoLIAItAABB5gBHDQkgAi0AAUHpAEcNCSACLQACQewARw0JIAItAANB5QBHDQkgAi0ABEHzAEcNCQwDCyACLQAAQeMARw0IIAItAAFB7wBHDQggAi0AAkHkAEcNCCACLQADQeUARw0IIAItAARB4gBHDQggAi0ABUHvAEcNCCACLQAGQe8ARw0IIAItAAdB6wBGDQcMCAsgAkGQ/cAAQQUQ2wcNBwwBCyACQZD9wABBBRDbBw0GCyAGQYCAgIB4Rg0BQZD9wABBBRCfByEEDAwLIAIpAABC496Rq6bs27frAFENAwwECyADQRRqIANBBGoQsgUgAygCGCEEIAMoAhQiBkGAgICAeEYEQEGAgICAeCEGDAsLIAMoAhwhCyADKAIIIQkgBCEIIAMoAgQMBQsgASADQRRqQbTkwAAQlQghBAwJCyABQQJGDQELIAdBgICAgHhGDQFBmP7AAEEIEJ8HIQQgB0UNCQwICyADQQA2AgwgBAwBCyADQQA2AgwgA0EUaiAKENADIAMoAhghBSADKAIUIgdBgICAgHhGBEAgBSEEDAgLIAMoAhwhDCAECyIBIAlHDQALDAELQQBBvP7AAEGA/cAAENsGIQEMBgsgBkGAgICAeEYNACAHQYCAgIB4RgRAQZj+wABBCBCcByEEIAZFDQUgCCAGQQEQogcMBQsgACAMNgIUIAAgBTYCECAAIAc2AgwgACALNgIIIAAgCDYCBCAAIAY2AgAMBgtBgICAgHghBkGQ/cAAQQUQnAchBAsgB0GAgICAeHJBgICAgHhGDQELIAVBBGsoAgAiAUF4cSICIAdBAnQiB0EEQQggAUEDcSIBG2pJDQUgAUEAIAIgB0EnaksbDQQgBRCiAgsgBkGAgICAeHJBgICAgHhGDQAgCEEEaygCACIBQXhxIgVBBEEIIAFBA3EiARsgBmpJDQQgAUEAIAUgBkEnaksbDQMgCBCiAgsgACAENgIEIABBgICAgHg2AgAMAQsgACABNgIEIABBgICAgHg2AgALIANBIGokAA8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC5kOAgJ9A38CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACRSAAKAJcQQJJckUEQEMAAP5CQwAA/kIgACoCUJUgAC0AWEECRhshBiAAKAIoIAFBD2xqIQkgACgCLCEIQQAhAANAIAEgCE8NECAAIARPDREgACAJaiIHQf8AQwAA/kJDAAD+wiAGIAMqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQFqIARPDQ8gB0EBakH/AEMAAP5CQwAA/sIgBiADQQRqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEECaiAETw0OIAdBAmpB/wBDAAD+QkMAAP7CIAYgA0EIaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIABBA2ogBE8NDSAHQQNqQf8AQwAA/kJDAAD+wiAGIANBDGoqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQRqIARPDQwgB0EEakH/AEMAAP5CQwAA/sIgBiADQRBqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEEFaiAETw0LIAdBBWpB/wBDAAD+QkMAAP7CIAYgA0EUaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIABBBmogBE8NCiAHQQZqQf8AQwAA/kJDAAD+wiAGIANBGGoqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQdqIARPDQkgB0EHakH/AEMAAP5CQwAA/sIgBiADQRxqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEEIaiAETw0IIAdBCGpB/wBDAAD+QkMAAP7CIAYgA0EgaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIABBCWogBE8NByAHQQlqQf8AQwAA/kJDAAD+wiAGIANBJGoqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQpqIARPDQYgB0EKakH/AEMAAP5CQwAA/sIgBiADQShqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEELaiAETw0FIAdBC2pB/wBDAAD+QkMAAP7CIAYgA0EsaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIABBDGogBE8NBCAHQQxqQf8AQwAA/kJDAAD+wiAGIANBMGoqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQ1qIARPDQMgB0ENakH/AEMAAP5CQwAA/sIgBiADQTRqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEEOaiAETw0CIAdBDmpB/wBDAAD+QkMAAP7CIAYgA0E4aioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIANBPGohAyAAQQ9qIQAgAUEBaiEBIAJBAWsiAg0ACwsPCyAAQQ5qIQAMDgsgAEENaiEADA0LIABBDGohAAwMCyAAQQtqIQAMCwsgAEEKaiEADAoLIABBCWohAAwJCyAAQQhqIQAMCAsgAEEHaiEADAcLIABBBmohAAwGCyAAQQVqIQAMBQsgAEEEaiEADAQLIABBA2ohAAwDCyAAQQJqIQAMAgsgAEEBaiEADAELIAAgBE8NACABIAhBpMTHABCMBwALIAAgBEGUxMcAEIwHAAvYDQIEfwF+IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQCAAKAIAQQFrDgUBAgMEBQALIABBBGohAyABKAIEIQQgASgCACEBIAAoAhQEQCACIABBFGo2AgQgAiACQQRqrUKAgICAkAeENwMQIAIgA61CgICAgKAHhDcDCCACQgI3AiQgAkECNgIcIAJBwMHEADYCGCACIAJBCGo2AiAgASAEIAJBGGoQwQMMBwsgAy0AAEEDRgRAIAFBlcHEAEEMIAQoAgwRAAAMBwsgAiADrUKAgICAoAeENwMIIAJCATcCJCACQQE2AhwgAkG4wcQANgIYIAIgAkEIajYCICABIAQgAkEYahDBAwwGCyAAQQRqIQMgACgCFARAIAIgAEEUajYCBCACIAJBBGqtQoCAgICQB4Q3AxAgAiADrUKAgICAoAeENwMIIAEoAgAgASgCBCACQgI3AiQgAkECNgIcIAJB8MHEADYCGCACIAJBCGo2AiAgAkEYahDBAwwGCyACIAOtQoCAgICgB4Q3AwggASgCACABKAIEIAJCATcCJCACQQE2AhwgAkHowcQANgIYIAIgAkEIajYCICACQRhqEMEDDAULIAEoAgQhAyABKAIAIQQCQAJAAkACQAJAAkACQEEDIAAoAgQiAUGAgICAeHMgAUEAThtBAWsOBQECBQMEAAsgBEGQwsQAQTggAygCDBEAAEUNBUEBDAoLIARByMLEAEHBACADKAIMEQAARQ0EQQEMCQsgAiAAQQhqNgIEIAIgAkEEaq1CgICAgLAHhDcDCCACQgE3AiQgAkECNgIcIAJBtMPEADYCGCACIAJBCGo2AiAgBCADIAJBGGoQwQNFDQNBAQwICyAEQejDxABBJSADKAIMEQAARQ0CQQEMBwsgAiAAQQhqNgIAIAIgAEEMajYCBCACQoCAgICwByIGIAKthDcDECACIAYgAkEEaq2ENwMIIAJCAjcCJCACQQI2AhwgAkG8xMQANgIYIAIgAkEIajYCICAEIAMgAkEYahDBA0UNAUEBDAYLIAIgAEEEajYCBCACIAJBBGqtQoCAgIDAB4Q3AwggAkIBNwIkIAJBATYCHCACQeDDxAA2AhggAiACQQhqNgIgQQEgBCADIAJBGGoQwQMNBRoLQQAgACgCEEUNBBogAiAAQRBqNgIEIAIgAkEEaq1CgICAgJAHhDcDCCACQgE3AiQgAkEBNgIcIAJBzMTEADYCGCACIAJBCGo2AiAgBCADIAJBGGoQwQMMBAsgASgCACEDIAEoAgQoAgwhAQJAAkACQEECIAApAwgiBqdBAmsgBkIBWBtBAWsOAgECAAsgA0G4v8QAQRggAREAAAwFCyADQfj4xABBFSABEQAADAQLIANB0L/EAEHPACABEQAADAMLIABBBGohBCABKAIEIQMgASgCACEBAkACQAJAAkACQEEDIAAtABQiBUEEayAFQQNNG0H/AXFBAWsOBAECAwQACyACIABBFWo2AgQgAiACQQRqrUKAgICA0AeENwMQIAIgBK1CgICAgKAHhDcDCCACQgI3AiQgAkEDNgIcIAJB8MXEADYCGCACIAJBCGo2AiAgASADIAJBGGoQwQMMBgsgAiAAQRVqNgIEIAIgAkEEaq1CgICAgNAHhDcDCCACQgE3AiQgAkECNgIcIAJBxMbEADYCGCACIAJBCGo2AiAgASADIAJBGGoQwQMMBQsgAiAAQRVqNgIEIAIgAkEEaq1CgICAgLAHhDcDCCACQgE3AiQgAkECNgIcIAJBoMfEADYCGCACIAJBCGo2AiAgASADIAJBGGoQwQMMBAsgAEEUaiEAAkACQAJAIAVBAmsOAgECAAsgAiAANgIEIAIgAkEEaq1CgICAgOAHhDcDCCACQgE3AiQgAkECNgIcIAJBuMjEADYCGCACIAJBCGo2AiAgASADIAJBGGoQwQMMBQsgAiAANgIEIAIgAkEEaq1CgICAgOAHhDcDCCACQgE3AiQgAkECNgIcIAJB7MfEADYCGCACIAJBCGo2AiAgASADIAJBGGoQwQMMBAsgAUH8x8QAQSggAygCDBEAAAwDCyACIABBGGo2AgAgAC0ABEEDRg0BIAIgBDYCBCACIAKtQoCAgIDAB4Q3AxAgAiACQQRqrUKAgICA4AeENwMIIAJCAjcCJCACQQI2AhwgAkG4ycQANgIYIAIgAkEIajYCICABIAMgAkEYahDBAwwCCyAAQQRqIAEQngQMAQsgAiACrUKAgICAwAeENwMIIAJCATcCJCACQQE2AhwgAkH4yMQANgIYIAIgAkEIajYCICABIAMgAkEYahDBAwsgAkEwaiQAC+kNAQF/IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsOHAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwACyACIABBBGo2AgwgAiACQQxqrUKAgICA0AaENwMQIAEoAgAgASgCBCACQgE3AiQgAkEBNgIcIAJB9PLEADYCGCACIAJBEGo2AiAgAkEYahDBAwwcCyACIABBAWo2AgwgAiACQQxqrUKAgICAoAiENwMQIAEoAgAgASgCBCACQQE2AiwgAkGc88QANgIoIAJBATYCJCACQQE2AhwgAkGU88QANgIYIAIgAkEQajYCICACQRhqEMEDDBsLIAIgAEEBajYCDCACIAJBDGqtQoCAgICgCIQ3AxAgASgCACABKAIEIAJBATYCLCACQZzzxAA2AiggAkEBNgIkIAJBATYCHCACQczzxAA2AhggAiACQRBqNgIgIAJBGGoQwQMMGgsgASgCAEHU88QAQR0gASgCBCgCDBEAAAwZCyACIABBAWo2AgwgAiACQQxqrUKAgICAoAiENwMQIAEoAgAgASgCBCACQQE2AiwgAkGc88QANgIoIAJBATYCJCACQQE2AhwgAkGI9MQANgIYIAIgAkEQajYCICACQRhqEMEDDBgLIAEoAgBBkPTEAEERIAEoAgQoAgwRAAAMFwsgASgCAEGh9MQAQSYgASgCBCgCDBEAAAwWCyABKAIAQcf0xABBGiABKAIEKAIMEQAADBULIAEoAgBB4fTEAEEZIAEoAgQoAgwRAAAMFAsgASgCAEH69MQAQQ8gASgCBCgCDBEAAAwTCyABKAIAQYn1xABBEyABKAIEKAIMEQAADBILIAIgAEEBajYCDCACIAJBDGqtQoCAgICwCIQ3AxAgASgCACABKAIEIAJBATYCLCACQZzzxAA2AiggAkEBNgIkIAJBATYCHCACQbj1xAA2AhggAiACQRBqNgIgIAJBGGoQwQMMEQsgAiAAQQFqNgIMIAIgAkEMaq1CgICAgMAIhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBATYCHCACQeT1xAA2AhggAiACQRBqNgIgIAJBGGoQwQMMEAsgAiAAQQFqNgIMIAIgAkEMaq1CgICAgMAIhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBATYCHCACQYj2xAA2AhggAiACQRBqNgIgIAJBGGoQwQMMDwsgASgCAEGQ9sQAQRQgASgCBCgCDBEAAAwOCyABKAIAQaT2xABBESABKAIEKAIMEQAADA0LIAEoAgBBtfbEAEERIAEoAgQoAgwRAAAMDAsgAiAAQQFqNgIMIAIgAkEMaq1CgICAgNAIhDcDECABKAIAIAEoAgQgAkEBNgIsIAJBnPPEADYCKCACQQE2AiQgAkEBNgIcIAJB3PbEADYCGCACIAJBEGo2AiAgAkEYahDBAwwLCyABKAIAQeT2xABBGCABKAIEKAIMEQAADAoLIAIgAEEBajYCDCACIAJBDGqtQoCAgIDACIQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkGY98QANgIYIAIgAkEQajYCICACQRhqEMEDDAkLIAIgAEEBajYCDCACIAJBDGqtQoCAgIDgCIQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkHE98QANgIYIAIgAkEQajYCICACQRhqEMEDDAgLIAIgAEEBajYCDCACIAJBDGqtQoCAgIDgCIQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkHw98QANgIYIAIgAkEQajYCICACQRhqEMEDDAcLIAIgAEEBajYCDCACIAJBDGqtQoCAgIDgCIQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkGc+MQANgIYIAIgAkEQajYCICACQRhqEMEDDAYLIAEoAgBBpPjEAEEYIAEoAgQoAgwRAAAMBQsgAiAAQQRqNgIMIAIgAkEMaq1CgICAgMAHhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBATYCHCACQdT4xAA2AhggAiACQRBqNgIgIAJBGGoQwQMMBAsgAiAAQQRqNgIMIAIgAkEMaq1CgICAgMAHhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBATYCHCACQfD4xAA2AhggAiACQRBqNgIgIAJBGGoQwQMMAwsgASgCAEH4+MQAQRUgASgCBCgCDBEAAAwCCyABKAIAQY35xABBEiABKAIEKAIMEQAADAELIAEoAgBBn/nEAEEOIAEoAgQoAgwRAAALIAJBMGokAAvZDAILfwV9QwAAgD8hDwJ/AkAgASgCACIIIAJBBGooAgAiBSgCCCIHSQRAIAFBBGsiCygCACEBIAUoAgQiCSAIQRhsaiIDLQATIgQgAy0AEiIGIAMtABEiCiAGIApLGyIGIAQgBksbIgQEfUMAAEDBIAUqAkQgBS0AWEECRiIGGyIOQwAAEEEgBSoCSCAGGyAOk0MAAH5DlSAEQQFrQf8BcbOUkhCJBCIOIA6SBUMAAAAACyERIANBDGovAQAiBEH//wFxRQRAIARBEHQMAwsgBEH/B3EhAyAEQYCAAnEhBiAEQYD4AXEiBEGA+AFGBEAgBkEQdCIEQYCAgPwHciADRQ0DGiAEIANBDXRyQYCAgP4HcgwDCyAGQRB0IQYgBEUNASAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogBnIMAgsgCCAHQdy7xwAQjAcACyADIANnQRBrIgNB//8DcUEIanRB////A3EgBkGAgIDYA3IgA0EXdGtyC74iDkMAAIA/XgRAIA4QxgVDVPgtQJRDAACAP5KRIQ8LQwAAgD8hDgJ/AkAgASAHSQRAIAkgAUEYbGoiAy0AEyIEIAMtABIiByADLQARIgYgBiAHSRsiByAEIAdLGyIEBH1DAABAwSAFKgJEIAUtAFhBAkYiBxsiEEMAABBBIAUqAkggBxsgEJNDAAB+Q5UgBEEBa0H/AXGzlJIQiQQiECAQkgVDAAAAAAshECADQQxqLwEAIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQUgA0GAgAJxIQQgA0GA+AFxIgNBgPgBRgRAIARBEHQiA0GAgID8B3IgBUUNAxogAyAFQQ10ckGAgID+B3IMAwsgBEEQdCEEIANFDQEgA0ENdEGAgID8AHEgBUENdHJBgICAwANqIARyDAILIAEgB0Hcu8cAEIwHAAsgBSAFZ0EQayIFQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAVBF3Rrcgu+IhJDAACAP14EQCASEMYFQ1T4LUCUQwAAgD+SkSEOCyARIA+UIg8gD1wgDyAQIA6UYHJFBEAgAkEEaiEJIAhBGGwhCgNAAkAgCyICQQRqIAE2AgAgACACRg0AQwAAgD8hDwJ/AkAgCSgCACIFKAIIIgcgCEsEQCACQQRrIgsoAgAhASAFKAIEIgwgCmoiAy0AEyIEIAMtABIiBiADLQARIg0gBiANSxsiBiAEIAZLGyIEBH1DAABAwSAFKgJEIAUtAFhBAkYiBhsiDkMAABBBIAUqAkggBhsgDpNDAAB+Q5UgBEEBa0H/AXGzlJIQiQQiDiAOkgVDAAAAAAshESADQQxqLwEAIgRB//8BcUUEQCAEQRB0DAMLIARB/wdxIQMgBEGAgAJxIQYgBEGA+AFxIgRBgPgBRgRAIAZBEHQiBEGAgID8B3IgA0UNAxogBCADQQ10ckGAgID+B3IMAwsgBkEQdCEGIARFDQEgBEENdEGAgID8AHEgA0ENdHJBgICAwANqIAZyDAILIAggB0Hcu8cAEIwHAAsgAyADZ0EQayIDQf//A3FBCGp0Qf///wNxIAZBgICA2ANyIANBF3Rrcgu+Ig5DAACAP14EQCAOEMYFQ1T4LUCUQwAAgD+SkSEPC0MAAIA/IQ4CfwJAIAEgB0kEQCAMIAFBGGxqIgMtABMiBCADLQASIgcgAy0AESIGIAYgB0kbIgcgBCAHSxsiBAR9QwAAQMEgBSoCRCAFLQBYQQJGIgcbIhBDAAAQQSAFKgJIIAcbIBCTQwAAfkOVIARBAWtB/wFxs5SSEIkEIhAgEJIFQwAAAAALIRAgA0EMai8BACIDQf//AXFFBEAgA0EQdAwDCyADQf8HcSEFIANBgIACcSEEIANBgPgBcSIDQYD4AUYEQCAEQRB0IgNBgICA/AdyIAVFDQMaIAMgBUENdHJBgICA/gdyDAMLIARBEHQhBCADRQ0BIANBDXRBgICA/ABxIAVBDXRyQYCAgMADaiAEcgwCCyABIAdB3LvHABCMBwALIAUgBWdBEGsiBUH//wNxQQhqdEH///8DcSAEQYCAgNgDciAFQRd0a3ILviISQwAAgD9eBEAgEhDGBUNU+C1AlEMAAIA/kpEhDgsgESAPlCIPIA9cDQAgDyAQIA6UYEUNAQsLIAIgCDYCAAsLkAwCCX8BfSMAQYABayIIJAACfwJAIAAoAggiBiABSwRAIAAoAgQgAUEYbGoiBi0AEyIFIAYtABIiByAGLQARIgkgByAJSxsiByAFIAdLGyIFBH1DAABAwSAAKgJEIAAtAFhBAkYiBxsiDkMAABBBIAAqAkggBxsgDpNDAAB+Q5UgBUEBa0H/AXGzlJIQiQQiDiAOkgVDAAAAAAshDiAGQQxqLwEAIgVB//8BcUUEQCAFQRB0DAMLIAVB/wdxIQYgBUGAgAJxIQcgBUGA+AFxIgVBgPgBRgRAIAdBEHQiBUGAgID8B3IgBkUNAxogBSAGQQ10ckGAgID+B3IMAwsgB0EQdCEHIAVFDQEgBUENdEGAgID8AHEgBkENdHJBgICAwANqIAdyDAILIAEgBkHcu8cAEIwHAAsgBiAGZ0EQayIGQf//A3FBCGp0Qf///wNxIAdBgICA2ANyIAZBF3RrcgshBgJAAkACQCAOIAa+Ig5DAACAP14EfSAOEMYFQ1T4LUCUQwAAgD+SkQVDAACAPwuUIANdRQRAIAggACgCECIFIAAoAhQiByABEOcCAkAgCCgCJCIGQQlPBEAgCCgCBCIKDQEgCCgCCCIAQQRrKAIAIgFBeHEiAiAGQQJ0IgRBBEEIIAFBA3EiARtqSQ0EIAFBACACIARBJ2pLGw0FIAAQogIMAwsgBiIKRQ0CCyAIQShqIAIoAggiCSAJIApqEIwDIAUgByABAn8gCCgCTCIKQQlPBEAgCCgCLCEKIAgoAjAMAQsgCEEsagsgChDUAiAIQQRqIQECfyAGQQlJBEAgCEEkaiEFIAEMAQsgASEFIAgoAggLIQcCQCAFKAIAIgVBAkkNACAFQRVPBEAgByAFEMEFDAELIAdBBGohBgJAIAVBAXEEQCAGIQkgByEGDAELIAcoAgQiCSAHKAIAIgtJBEAgByAJNgIAIAcgCzYCBAsgB0EIaiEJCyAFQQJGDQAgByAFQQJ0aiENIAlBBGohDANAIAkoAgAiCiAGKAIAIgVJBEAgCSELAn8DQCALIAU2AgAgByAGIAdGDQEaIAYhCyAKIAZBBGsiBigCACIFSQ0ACyAGQQRqCyAKNgIAIAkoAgAhCgsgCiAJKAIEIgtLBEAgDCEFA0ACQCAFIAo2AgAgByAFQQRrIgZGBEAgByEGDAELIAVBCGshCiAGIQUgCyAKKAIAIgpJDQELCyAGIAs2AgALIAlBBGohBiAMQQhqIQwgCUEIaiIJIA1HDQALCyAIKAIkIgchBSAHQQlPBEAgCCgCBCEFIAgoAgghAQsgBQRAIAVBAnQhBiACKAIIIgVBAnQhBwNAIAEoAgAhCSACKAIAIAVGBEAgAkGA5sEAEIsGCyABQQRqIQEgAigCBCAHaiAJNgIAIAIgBUEBaiIFNgIIIAdBBGohByAGQQRrIgYNAAsgCCgCJCEHCyAIKAIEIQUgCEHwAGogCEEgaigCADYCACAIQegAaiAIQRhqKQIANwIAIAggCP0AAgj9CwJYIAggBSAHIAdBCEsiARsiBjYCfCAIIAdBACABGzYCdCAIQQAgBSABGzYCVAJAAkAgBgRAIAdBCU8EQCAIKAJYIgYhAQNAIAAgASgCACACIAMgBBDLASABQQRqIQEgBUEBayIFDQALDAILIAhB1ABqIQFBACEFA0AgCCAFQQFqIgU2AnggACABKAIAIAIgAyAEEMsBIAFBBGohASAFIAdHDQALDAILIAdBCUkNASAIKAJYIQYLIAZBBGsoAgAiAEF4cSIBIAdBAnQiAkEEQQggAEEDcSIAG2pJDQMgAEEAIAEgAkEnaksbDQQgBhCiAgsgCCgCTCIAQQlJDQEgCCgCMCIBQQRrKAIAIgJBeHEiBCAAQQJ0IgBBBEEIIAJBA3EiAhtqSQ0CIAJBACAEIABBJ2pLGw0DIAEQogIMAQsgBCgCCCIAIAQoAgBGBEAgBEGQ5sEAEIsGCyAEKAIEIABBAnRqIAE2AgAgBCAAQQFqNgIICyAIQYABaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALshADB38BfgF7IwBBMGsiAyQAAkACQCAAKAIAIgZFBEAgACgCECIARQ0BIABBk7PFAEEBEJcDIQQMAgsgACAAKAIMQQFqIgQ2AgwCQAJAAkACQAJAAkACQAJAIARB9QNPBEAgACgCECIBRQ0BIAFB+rLFAEEZEJcDRQ0BDAgLAkACQAJAAkAgACgCCCICIAAoAgQiCE8EQCAAKAIQIgFFDQEgAUHqssUAQRAQlwMNDAwBC0EBIQQgACACQQFqIgc2AggCQAJAAkACQAJAAkAgAiAGai0AACIFQckAaw4GAgEBAQgFAAsCQCAFQcIAaw4CAwQACyAFQdgAaw4CBwsACyAAKAIQIgFFDQQgAUHqssUAQRAQlwNFDQQMEQsgACABEMwBDRAgAQ0GDAwLIwBBIGsiAiQAAkACQCAAKAIARQRAIAAoAhAiAUUNASABQZOzxQBBARCXAyEBDAILIAIgABCvBiACKAIARQRAIAAoAhAiBQRAQQEhASAFQfqyxQBB6rLFACACLQAEQQFxIgUbQRlBECAFGxCXAw0DCyAAIAL9AAIA/QsCAAwBCyAAKAIQRQ0AIAD9AAIAIQogACAC/QACAP0LAgAgAiAK/QsDECAAIAFBAXEQzAEhASAAIAL9AAMQ/QsCAAwBC0EAIQELIAJBIGokACABRQ0MDA8LIANBIGogAEHzABCsBiADLQAgQQFGBEAgAy0AISEBIAAoAhAiAgRAIAJB+rLFAEHqssUAIAFBAXEiAhtBGUEQIAIbEJcDDRALIAAgAToABAwKCyAAKAIARQRAIAAoAhAiAEUNDiAAQZOzxQBBARCXAyEEDA8LIAMpAyghCSADQSBqIAAQ7wIgAygCIEUEQCADLQAkIQEgACgCECICBEAgAkH6ssUAQeqyxQAgAUEBcSICG0EZQRAgAhsQlwMNEAsgACABOgAEDAoLIAMgA/0AAiD9CwMAIAAoAhAiAUUNCyADIAEQiwINDCAAKAIQIgFFIAlQcg0LIAEoAghBgICABHENCyABKAIAQeiyxQBBASABKAIEKAIMEQAADQ4gACgCECMAQRBrIgIkAEERIQEDQCABIAJqQQJrIAmnQQ9xLQDctkU6AAAgAUEBayEBIAlCD1YgCUIEiCEJDQALQQFBhLTFAEECIAEgAmpBAWtBESABaxDIAyACQRBqJAANDiAAKAIQIgEoAgBB6bLFAEEBIAEoAgQoAgwRAAANDgwLCyAHIAhJBEAgACACQQJqNgIIIAYgB2otAAAiAkHBAGtB/wFxQRpJDQIgAkHhAGtBgIDEACECQf8BcUEaSQ0CCyAAKAIQIgFFDQAgAUHqssUAQRAQlwMNCwtBACEEIABBADoABCAAQQA2AgAMDAtBASEEIAAgARDMAQ0LAkAgACgCAA0AIAAoAhAiAUUNCyABQZSzxQBBAhCXAw0MIAAoAgANAEEAIQQgACgCECIARQ0MIABBk7PFAEEBEJcDIQQMDAsgA0EgaiAAQfMAEKwGIAMtACBBAUYEQCADLQAhIQEgACgCECICBEAgAkH6ssUAQeqyxQAgAUEBcSICG0EZQRAgAhsQlwMNDQsgACABOgAEDAcLIAAoAgBFBEAgACgCECIARQ0LIABBk7PFAEEBEJcDIQQMDAsgAykDKCEJIANBIGogABDvAiADKAIgRQRAIAMtACQhASAAKAIQIgIEQCACQfqyxQBB6rLFACABQQFxIgIbQRlBECACGxCXAw0NCyAAIAE6AAQMBwsgAyAD/QACIP0LAxACQAJAAkAgAkGAgMQARwRAIAAoAhAiAQRAIAFBlrPFAEEDEJcDDQ4LIAJBwwBGDQEgAkHTAEYNAiADIAI2AiAgACgCECIBRQ0DIANBIGogARCoBQ0NDAMLIAMoAhQgAygCHHJFDQsgACgCECIBRQ0LIAFBlLPFAEECEJcDDQ4gACgCECIBRQ0LIANBEGogARCLAkUNCwwOCyAAKAIQIgFFDQEgAUGZs8UAQQcQlwMNCwwBCyAAKAIQIgFFDQAgAUGgs8UAQQQQlwMNCgsgACgCECECIAMoAhQgAygCHHJFDQUgAkUNCCACQdD4xwBBARCXAw0LIAAoAhAiAUUNCCADQRBqIAEQiwINCyAAKAIQIQIMBQsgA0EgaiAAQfMAEKwGIAMtACBBAUcNAiADLQAhIQEgACgCECICBEAgAkH6ssUAQeqyxQAgAUEBcSICG0EZQRAgAhsQlwMNCwsgACABOgAEDAULIAAoAhAiAUUNBSABQZSzxQBBAhCXA0UNBQwJCyAAQQE6AAQMAwsjAEEQayIBJAAgACgCECECIABBADYCECAAQQAQzAEEQEGotMUAQT0gAUEPakGYtMUAQei0xQAQ4AYACyAAIAI2AhAgAUEQaiQACyAAKAIQIgEEQCABQaazxQBBARCXAw0HCyAAEIYCDQQgBUHNAEcEQCAAKAIQIgEEQCABQaezxQBBBBCXAw0GCyAAQQAQzAENBwsgACgCECIBRQ0DIAFBq7PFAEEBEJcDRQ0DDAYLIAJFDQIgAkGks8UAQQEQlwMNBSAAKAIQIQEgAyAJNwMgIAFFDQIgA0EgaiABEIUFDQUgACgCECIBRQ0CIAFBpbPFAEEBEJcDRQ0CDAULQQAhBCAAQQA2AgAMBAsgACgCECIBBEAgAUGms8UAQQEQlwMNBAsgABDuBA0DIAAoAhAiAUUNACABQauzxQBBARCXAw0DC0EAIQQgACgCAEUNAiAAIAAoAgxBAWs2AgwMAgtBASEEDAELQQAhBAsgA0EwaiQAIAQLkB4CFH8CfiMAQeAAayIIJAAgAUFAayEKAkACQCABLQBgIgdBB0sNACAIQdAAaiAKEI4CAkAgCC0AUCIHQR1GBEAgAS0AYCIHQQhPDQJBDyEHDAELIAggCCkBUjcDACAIIAhB2ABqKQEANwEGIAgtAFEhAQsgACABOgABIAAgBzoAACAAIAgpAwA3AQIgAEEIaiAIKQEGNwEADAELIAEgB0EIayIHOgBgIAEgASkDQCIaQgiIIhs3A0ACQAJAAkACQCAapyIGQf8BcUEvRgRAIAdB/wFxQQ1LDQQgCEHQAGogChCOAiAILQBQIgdBHUcNASABLQBgIgdBDk8NA0EPIQcMAgsgACAGOgABIABBCzoAAAwECyAIQRhqIAhB3ABqKAIANgIAIAggCCkCVDcDECAILwFSIQEgCC0AUSEKCyAAIAE7AQIgACAKOgABIAAgBzoAACAAIAgpAxA3AgQgAEEMaiAIQRhqKAIANgIADAILIAopAwAhGwsgASAHQQ5rIgc6AGAgASAbQg6IIho3A0AgASAbp0H//wBxQQFqIgY7AXQgB0H/AXFBDU0EQCAIQdAAaiAKEI4CAkACQCAILQBQIgdBHUYEQCABLQBgIgdBDk8NAkEPIQcMAQsgCEEoaiAIQdwAaigCADYCACAIIAgpAlQ3AyAgCC8BUiEBIAgtAFEhCgsgACABOwECIAAgCjoAASAAIAc6AAAgACAIKQMgNwIEIABBDGogCEEoaigCADYCAAwCCyABKQNAIRogAS8BdCEGCyABIAdBDmsiBzoAYCABIBpCDogiGzcDQCABIBqnQf//AHFBAWoiCTsBdgJAIAIgBkH//wNxRyADIAlHckUEQCAHQf8BcUUEQCAIQdAAaiAKEI4CAkACQCAILQBQIgdBHUYEQCABLQBgIgcNAkEPIQcMAQsgCCAIKQFSNwMwIAggCEHYAGopAQA3ATYgCC0AUSEBCyAAIAE6AAEgACAHOgAAIAAgCCkDMDcBAiAAQQhqIAgpATY3AQAMBAsgCikDACEbCyABIAdBAWsiAjoAYCABIBtCAYgiGjcDQAJAAkAgB0H/AXFBA00EQCAIQdAAaiAKEI4CIAgtAFAiB0EdRw0BIAEtAGAiAkEDSQRAQQ8hBwwDCyAKKQMAIRoLIAEgAkEDazoAYCABIBpCA4g3A0AgGqdBB3EiAkUNAyAAIAI6AAEgAEEMOgAADAQLIAggCCkBUjcDQCAIIAhB2ABqKQEANwFGIAgtAFEhAQsgACAIKQNANwECIABBCGogCCkBRjcBACAAIAE6AAEgACAHOgAADAILIABBFzoAAAwBCyAIQdAAaiELQQAhByMAQeAAayIGJAAgASIDQegAaiEZIANBQGshESADLwF0IRICQAJAA0ACQAJAAkACQAJAAkACQCADLQBgIgkNACAGQcwAaiAREI4CIAsCfyAGLQBMIglBHUYEQCADLQBgIgkNAkEPIQlBAQwBCyAGIAYpAU43AwAgBiAGQdQAaikBADcBBiAGLQBNCzoAASALIAk6AAAgCyAGKQMANwECIAtBCGogBikBBjcBAAwBCyADIAlBAWsiAjoAYCADIAMpA0AiG0IBiCIaNwNAIBtCAYNQRQRAIAlBAk0EQCAGQcwAaiAREI4CAkACQCAGLQBMIglBHUYEQCADLQBgIgJBAk8NAkEPIQkMAQsgBiAGKQFONwMQIAYgBkHUAGopAQA3ARYgBi0ATSEQCyALIBA6AAEgCyAJOgAAIAsgBikDEDcBAiALQQhqIAYpARY3AQAMAwsgESkDACEaCyADIAJBAms6AGAgAyAaQgKINwNAIAMgGqdBA3EiEEEEdGoiDS0AAEEERwRAIAtBEDoAAAwCCyADKAJwIgIgAygCaEYEQCAZQYj7xgAQpwYLIAMoAmwgAmogEDoAACADIAJBAWo2AnACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgEEEBaw4DARECAAsgAy0AYCIJQQJLDQQgBkHMAGogERCOAiAGLQBMIglBHUcNAiADLQBgIglBA08NBEEPIQkMAwsgAy0AYCIJQQJLDQYgBkHMAGogERCOAiAGLQBMIglBHUcNBCADLQBgIglBA08NBkEPIQkMBQsgAy0AYCIJQQdLDQggBkHMAGogERCOAiAGLQBMIglBHUcNBiADLQBgIglBCE8NCEEPIQkMBwsgBiAGKQFONwMgIAYgBkHUAGopAQA3ASYgBi0ATSEXCyALIBc6AAEgCyAJOgAAIAsgBikDIDcBAiALQQhqIAYpASY3AQAMCAsgAyAJQQNrOgBgIAMgAykDQCIaQgOINwNAQX8gGqdBB3EiF0ECaiIPdEF/cyICIBJB//8DcWogD3YiCiACIAMvAXZqIA92IglsIgJBAnQhDAJAIAJFBEBBASEHDAELIAwQcSIHRQ0KIAdBBGstAABBA3FFIAxFcg0AIAdBACAM/AsACyAGQcwAaiADIAogCUEAIAcgDBA6IAYtAEwiCkEdRg0LIAsgBikATTcAASALQQhqIAZB1ABqKQAANwAAIAsgCjoAACACRQ0HIAdBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAxqSQ0MIAJBACADIAxBJ2pLGw0OIAcQogIMBwsgBiAGKQFONwMwIAYgBkHUAGopAQA3ATYgBi0ATSEYCyALIBg6AAEgCyAJOgAAIAsgBikDMDcBAiALQQhqIAYpATY3AQAMBQsgAyAJQQNrOgBgIAMgAykDQCIaQgOINwNAQX8gGqdBB3EiGEECaiIPdEF/cyICIBJB//8DcWogD3YiCiACIAMvAXZqIA92IglsIgJBAnQhDAJAIAJFBEBBASEHDAELIAwQcSIHRQ0HIAdBBGstAABBA3FFIAxFcg0AIAdBACAM/AsACyAGQcwAaiADIAogCUEAIAcgDBA6IAYtAEwiCkEdRg0IIAsgBikATTcAASALQQhqIAZB1ABqKQAANwAAIAsgCjoAACACRQ0EIAdBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAxqSQ0JIAJBACADIAxBJ2pLGw0FIAcQogIMBAsgBkHIAGogBkHYAGooAgA2AgAgBiAGKQJQNwNAIAYvAU4hDiAGLQBNIQMLIAsgDjsBAiALIAM6AAEgCyAJOgAAIAsgBikDQDcCBCALQQxqIAZByABqKAIANgIADAILIAMgCUEIazoAYCADIAMpA0AiGkIIiDcDQCAapyICQf8BcSIOQQFqIhNBAnQiDBBxIgdFDQMgB0EEayIULQAAQQNxRSAMRXJFBEAgB0EAIAz8CwALIAZBzABqIAMgE0EBQQAgByAMEDogBi0ATCIKQR1HBEAgCyAGKQBNNwABIAtBCGogBkHUAGopAAA3AAAgCyAKOgAAIBQoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAxqSQ0HIAJBACADIAxBJ2pLGw0JIAcQogIMAgsgEkH//wNxQQECf0EDIA5BAkkNABpBAiAOQQRJDQAaIA5BEEkLIgp0akEBayAKdiISQf//A00EQCAORQRAQQEhE0EAIQ4MBwtBBCEJIAJBAnRB/AdxIhVBAWsiAiAMIAIgDEkbIgJBBE8EQCACQQFqIgpBA3EiCUEEIAkbIgkgAkF/c2ohFiAKIAlrQQRqIQkgByECA0AgAkEEaiIKIAL9XAAAIAr9XAAA/W79WgAAACAKIQIgFkEEaiIWDQALCyAVQQhqIQIgFUEEaiEKA0AgAiAJRg0GIAkgFGoiFUEEaiIWIBUtAAAgFi0AAGo6AAAgCUEBaiIJIApHDQALDAYLQdjmyABBKyAGQd8AakGY+8YAQaj7xgAQ4AYACyALQR06AAAgCyASOwECCyAGQeAAaiQADAcLQYyNyABBLkG8jcgAEOsHCwALIAlBBGsgDEG4+8YAEIwHAAsCQAJAIA0tAAAiAkEERiACQQJGcg0AIA0oAgQiAkUNACANKAIIIgpBBGsoAgAiCUF4cSIUQQRBCCAJQQNxIgkbIAJqSQ0BIAlBACAUIAJBJ2pLGw0EIAoQogILIA0gDDYCDCANIAc2AgggDSAMNgIEIA0gEzsBAiANIA86AAEgDSAQOgAADAILCwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAgtAFAiAkEdRwRAIAAgCCkCVDcCBCAAQQxqIAhB3ABqKAIANgIAIAgtAFEhASAAIAgvAVI7AQIgACABOgABIAAgAjoAAAwBCyAFIAgvAVIiCSABLwF2IgJsQQJ0IgNPBEAgCEHQAGogASAJIAJBASAEIAMQOiAILQBQIgJBHUcEQCAAIAgpAFE3AAEgAEEIaiAIQdgAaikAADcAACAAIAI6AAAMAgsgASgCcCICBEAgBEEEaiELIAEoAmwiDCACaiEGA0ACQAJAAkACQAJAAkACQAJAIAZBAWsiBi0AACICQQRJBEAgASACQQR0aiICLQAAQQFrDgQEBQIBAwsgAkEEQaj6xgAQjAcAC0G4+sYAEN0JAAsgBCAFIAEvAXQiCSABLwF2IgMgAi8BAiACKAIIIAIoAgwQSiADIAlsQQJ0IQMMBQsgAyAFSw0DIAhB0ABqIAQgAyAJIAEvAXYgAi0AASACKAIIIAIoAgwQTiAILQBQIgJBHUYNBCAAIAgpAFE3AAEgAEEIaiAIQdgAaikAADcAACAAIAI6AAAMCAsgAyAFSw0BIAQgAyAJIAItAAEgAigCCCACKAIMEJcCDAMLIAMgBU0EQCADQXxxIgpFDQMgA0EEayICQQRxBH8gBAUgBCAELQABIgcgBC0AAGo6AAAgBCAHIAQtAAJqOgACIAJBBEkNBCAKQQRrIQogCwshBwNAIAcgB0EBai0AACICIActAABqOgAAIAdBAmoiDSACIA0tAABqOgAAIAdBBGoiAiAHQQVqLQAAIg0gAi0AAGo6AAAgB0EGaiICIA0gAi0AAGo6AAAgB0EIaiEHIApBCGsiCg0ACwwDC0EAIAMgBUHo+sYAEOoHAAtBACADIAVB2PrGABDqBwALQQAgAyAFQcj6xgAQ6gcACyAGIAxHDQALCyAAQR06AAAMAQtBACADIAVB+PrGABDqBwALIAhB4ABqJAAL7g4CDH8DfiMAQTBrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAQRUgASgCACIEQYCAgIB4cyAEQQBOG0EUaw4CAQIACyABIAJBL2pB1OPAABCVCCEBIABBgICAgHg2AgAgACABNgIEDAYLIAEoAgwiBkUNAgJAIAEoAggiBSgCAEGUgICAeEYEQAJAIAUoAgwiAQRAIAJBHGogBSgCCBCoAyACKAIcIgRBgICAgHhHDQEgAigCICEBDAgLQQAgAkEvakGE4sAAENsGIQEMBwsgAigCICEHIAFBAUYNASACQQE2AhwgAUEBa0H/////AHFBAWogAkEcakHolcEAENsGIQEgBEUNBiAHIARBARCiBwwGCyAFIAJBL2pBhOLAABCVCCEBDAULIAZBAUYNASACKAIkIQkgAkEcaiIDIAVBEGoQ0wIgAigCICEBIAIoAhwNAwJAIAZBAkcEQCACKQIkIQ4gAyAFQSBqENMCIAIoAiAhBSACKAIcRQ0BIAUhAQwFC0ECQcSAwQBBgP3AABDbBiEBDAQLIAZBA0cEQCACQQM2AhwgBkH9////AGpB/////wBxQQNqIAJBHGpB6JXBABDbBiEBIABBgICAgHg2AgAgACABNgIEIARFDQYgByAEQQEQogcMBgsgACACKQIkNwIcIAAgBTYCGCAAIA43AhAgACABNgIMIAAgCTYCCCAAIAc2AgQgACAENgIADAULIAEoAgQhBCABKAIIIQEgAkEANgIYIAIgBCABQQV0aiILNgIQAkACQCABRQ0AQYCAgIB4IQgDQCACIARBIGoiATYCDCACIAIoAhhBAWo2AhggAiAEQRBqIgw2AhQCQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBFSAEKAIAIgNBgICAgHhzIANBAE4bQQFrDg8ADg4BDg4ODg4ODgIDBAUOCyAELQAEDgMKBQcPCyAEKQMIIg5CAlYNDiAOp0EBaw4CBAYJCyAEKAIIIQMCQCAEKAIMQQRrDgIACA4LIAMoAABB7dK5mwdGDQMgAygAAEHtwuGbB0YNBQwNCyAEKAIEIQMCQCAEKAIIQQRrDgIABg0LIAMoAABB7dK5mwdGDQIgAygAAEHtwuGbB0YNBAwMCyAEKAIIIQMCQAJAIAQoAgxBBGsOAgEADQsgAy0AAEHmAEcNDCADLQABQekARw0MIAMtAAJB7ABHDQwgAy0AA0HlAEcNDCADLQAEQfMARw0MDAcLIAMtAABB7QBHDQsCQAJAIAMtAAFB4QBrDgkBDQ0NDQ0NDQANCyADLQACQe4ARw0MIAMtAANB8wBGDQIMDAsgAy0AAkH4AEcNCyADLQADQfMARg0DDAsLIAQoAgQhAwJAAkAgBCgCCEEEaw4CAQAMCyADLQAAQeYARw0LIAMtAAFB6QBHDQsgAy0AAkHsAEcNCyADLQADQeUARw0LIAMtAARB8wBHDQsMBgsgAy0AAEHtAEcNCgJAIAMtAAFB4QBrDgkCCwsLCwsLCwALCyADLQACQe4ARw0KIAMtAANB8wBHDQoLIAZFDQVBlf3AAEEEEJ8HDAgLIAMtAAJB+ABHDQggAy0AA0HzAEcNCAsgCkUNBEGZ/cAAQQQQnwcMBgsgA0GQ/cAAQQUQ2wdFDQEMBgsgA0GQ/cAAQQUQ2wcNBQsgCEGAgICAeEcEQEGQ/cAAQQUQnwcMBAsgAkEcaiACQQxqELIFIAIoAiAhByACKAIcIghBgICAgHhGBEAgByEFDAkLIAIoAiQhDSACKAIQIQsgAigCDCEBDAULIAJBADYCFCACQRxqIAwQ0wIgAigCICIFIAIoAhxBAUYNAhogAikCJCEPQQEhBgwECyACQQA2AhQgAkEcaiAMENMCIAIoAiAhCSAJIAIoAhxBAUYNARogAikCJCEQQQEhCgwDCyAEIAJBL2pBhOTAABCVCAshBSAIQYCAgIB4ckGAgICAeEYNBAJAIAdBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAhqTwRAIAFBACAEIAhBJ2pLGw0BIAcQogIMBgtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAJBADYCFAsgCyABIgRHDQALIAhBgICAgHhGDQAgBkEAIAobRQRAQZn9wABBlf3AACAGG0EEEJwHIQUgCEUNAiAHIAhBARCiBwwCCyAAIBA3AhwgACAJNgIYIAAgDzcCECAAIAU2AgwgACANNgIIIAAgBzYCBCAAIAg2AgAMBgtBkP3AAEEFEJwHIQULIAAgBTYCBCAAQYCAgIB4NgIADAQLQQFBxIDBAEGA/cAAENsGIQEMAQtBAEHEgMEAQYD9wAAQ2wYhAQwBCyAERQ0AIAdBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIARqSQ0CIAVBACAGIARBJ2pLGw0DIAcQogILIAAgATYCBCAAQYCAgIB4NgIACyACQTBqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAukDAISfgh/IwBB4ABrIhUkAAJAAn8CQAJAAkACQAJAAkACQCABKQMAIgNQRQRAIAEpAwgiBFANASABKQMQIgVQDQIgBSADQn+FVg0DIAMgBFQNBCADIAV8IgVCgICAgICAgIAgWg0FIBUgAS8BGCIBOwE4IBUgAyAEfSIHNwMwIBUgByAFeSIEhiIIIASIIgY3A0AgBiAHUg0JIBUgATsBOCAVIAM3AzAgFSADIARCP4MiB4YiBiAHiCIHNwNAIAMgB1INCUGgfyABIASnayIXa8FB0ABsQbCnBWpBzhBtIgFB0QBPDQYgFUEgaiABQQR0IgEpA4iFQiIDIAUgBIYQ3QYgFUEQaiADIAgQ3QYgFSADIAYQ3QZCAUEAIBcgAS8BkIVCamtBP3GtIgaGIghCAX0hCiAVKQMQQj+HIQwgFSkDAEI/iCEOIBUpAwghDyABLwGShUIhFyAVKQMYIRAgFSkDKCITIBUpAyBCP4giFHwiEUIBfCIJIAaIpyIWQZDOAE8EQCAWQcCEPUkNCCAWQYDC1y9PBEBBCEEJIBZBgJTr3ANJIgEbIRlBgMLXL0GAlOvcAyABGwwKC0EGQQcgFkGAreIESSIBGyEZQcCEPUGAreIEIAEbDAkLIBZB5ABPBEBBAkEDIBZB6AdJIgEbIRlB5ABB6AcgARsMCQtBCkEBIBZBCUsiGRsMCAtB2I/CAEEcQaSQwgAQ6wcAC0G0kMIAQR1B1JDCABDrBwALQeSQwgBBHEGAkcIAEOsHAAtBuJLCAEE2QfCSwgAQ6wcAC0HwkcIAQTdBqJLCABDrBwALQZCRwgBBLUHAkcIAEOsHAAsgAUHRAEGYj8IAEIwHAAtBBEEFIBZBoI0GSSIBGyEZQZDOAEGgjQYgARsLIQEgCSAKgyEEIA4gD3whCyAZIBdrQQFqIRsgDCAQfSAJfEIBfCINIAqDIQUCQAJAAkACQAJAAkACQAJAAkADQCACIBhqIBYgAW4iHEEwaiIaOgAAIBhBAWohFyANIBYgASAcbGsiFq0gBoYiEiAEfCIDVg0CIBggGUYEQCAXIQFCASEDA0AgAyEHIAFBEUYNBSABIAJqIARCCn4iBCAGiKdBMGoiGDoAACABQQFqIQEgA0IKfiEDIAVCCn4iBSAEIAqDIgRYDQALIAUgBH0iCiAIVCEWIAMgCSALfX4iCSADfCEGIAQgCSADfSIJWg0HIAggClgNAgwHCyABQQpJIBchGCABQQpuIQFFDQALQdCRwgAQgQgACyABIAJqQQFrIRcgBSAIfSELIAggCX0hDUIAIAR9IQoDQCAEIAh8IgMgCVQgCSAKfCAEIA18WnJFBEBBACEWDAYLIBcgGEEBayIYOgAAIAogC3wiDCAIVCEWIAMgCVoNBiAKIAh9IQogAyEEIAggDFgNAAsMBQsgDSADfSIFIAGtIAaGIgdUIQEgCSALfSIGQgF8IQggBSAHVCADIAZCAX0iCVpyDQEgAiAXakEBayEYIAwgEXwgEH0gBCAHfCIEIBJ8fUICfCEKIBEgC30gA30hCyAEIA58IA98IBR9IBN9IBJ8IQZCACEEA0AgAyAHfCIFIAlUIAQgC3wgBlpyRQRAQQAhAQwDCyAYIBpBAWsiGjoAACAEIAp8IgwgB1QhASAFIAlaDQMgBiAHfCEGIAQgB30hBCAFIQMgByAMWA0ACwwCC0ERQRFB4JHCABCMBwALIAMhBQsCQCAFIAhaIAFyDQAgCCAFIAd8IgNYIAggBX0gAyAIfVRxDQAgAEEANgIADAQLIAUgDUIEfVggBUICWnFFBEAgAEEANgIADAQLIAAgGzsBCCAAIBc2AgQMAgsgBCEDCwJAIAMgBlogFnINACAGIAMgCHwiBFggBiADfSAEIAZ9VHENACAAQQA2AgAMAgsgAyAFIAdCWH58WCADIAdCFH5acUUEQCAAQQA2AgAMAgsgACAbOwEIIAAgATYCBAsgACACNgIACyAVQeAAaiQADwsgFUEANgJIIwBBEGsiACQAIAAgFUEwajYCDCAAIBVBQGs2AghBACAAQQhqQfCHwwAgAEEMakHwh8MAIBVByABqQeSWwgAQ8gQAC9ELAhd/AX0jAEEgayIHJAACQAJAAkACQAJAAkACQAJAIAAtALgBQQFHDQAgACgCrAEgACgCsAEiBUECdCAAKAK0ASIGIAVqQQJ0EOEIIQUgBkECdCIGIAAoAmQiCEsNASAAKAJgIQggByAFELgKIgs2AgAgByAGNgIEIAYgC0cNByAFIAggBhDgCSAFQYQISQ0AIAUQmwcLIABCADcCsAEgAEG4AWpBADoAAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAghFDQAgACgCDCABQQJ0IAEgAmpBAnQQ4QghCwJAIAJBAnQiASAAKAJkIgZNBEAgACABNgJkIAAoAmAhCCABIQUMAQsgASAGIgVrIgkgACgCXCAFa0sEQCAAQdwAaiAFIAlBBEEEEKQFIAAoAmQhBQsgACgCYCIIIAVBAnQiDGohCiAJQQJPBEAgASAGQX9zakECdCINBEAgCkEAIA38CwALIAJBBHQgBkECdGsgCGogDGpBBGshCiAFIAlqQQFrIQULIApBADYCACAAIAVBAWoiBTYCZCABIAVLDRILIAcgCxC4CiIGNgIAIAcgATYCBCABIAZHDRYgCCABIAsQ4QkgAkEPbCEMIARBD25BD2whDSAEQQFrQQ9uQQ9sQQ9qIQ4gBEECa0EPbkEPbEEPaiEPIARBA2tBD25BD2xBD2ohECAEQQRrQQ9uQQ9sQQ9qIREgBEEFa0EPbkEPbEEPaiESIARBBmtBD25BD2xBD2ohEyAEQQdrQQ9uQQ9sQQ9qIRQgBEEIa0EPbkEPbEEPaiEVIARBCWtBD25BD2xBD2ohFiAEQQprQQ9uQQ9sQQ9qIRcgBEELa0EPbkEPbEEPaiEYIARBDGtBD25BD2xBD2ohGSAEQQ1rQQ9uQQ9sQQ9qIRogBEEOa0EPbkEPbEEPaiEbQwAA/kIgACoClAGVIRxBACEBQQAhAANAIAEgBU8NEyABQQFqIgIgBU8NFCABQQJqIgIgBU8NFSABQQNqIgIgBU8NFiAAIA5GDRAgCEEEaigCACECIAhBDGooAgAhCSAIQQhqKAIAIQYgAyAIKAIAIgrAsiAclTgCACAAIA9GDQ8gA0EEaiAKQQh2wLIgHJU4AgAgACAQRg0OIANBCGogCkEQdsCyIByVOAIAIAAgEUYNDSADQQxqIApBGHWyIByVOAIAIAAgEkYNDCADQRBqIALAsiAclTgCACAAIBNGDQsgA0EUaiACQQh2wLIgHJU4AgAgACAURg0KIANBGGogAkEQdsCyIByVOAIAIAAgFUYNCSADQRxqIAJBGHWyIByVOAIAIAAgFkYNCCADQSBqIAbAsiAclTgCACAAIBdGDQcgA0EkaiAGQQh2wLIgHJU4AgAgACAYRg0GIANBKGogBkEQdsCyIByVOAIAIAAgGUYNBSADQSxqIAZBGHWyIByVOAIAIAAgGkYNBCADQTBqIAnAsiAclTgCACAAIBtGDQMgA0E0aiAJQQh2wLIgHJU4AgAgACANRg0CIANBOGogCUEQdsCyIByVOAIAIAhBEGohCCABQQRqIQEgA0E8aiEDIAwgAEEPaiIARw0ACyALQYQISQ0AIAsQmwcLIAdBIGokAA8LIABBDmohAAwNCyAAQQ1qIQAMDAsgAEEMaiEADAsLIABBC2ohAAwKCyAAQQpqIQAMCQsgAEEJaiEADAgLIABBCGohAAwHCyAAQQdqIQAMBgsgAEEGaiEADAULIABBBWohAAwECyAAQQRqIQAMAwsgAEEDaiEADAILIABBAmohAAwBCyAAQQFqIQALIAAgBEGc1MAAEIwHAAtBACAGIAhB/OvAABDqBwALQQAgASAFQazUwAAQ6gcACyABIAVB3NPAABCMBwALIAIgBUHs08AAEIwHAAsgAiAFQfzTwAAQjAcACyACIAVBjNTAABCMBwALIAdBADYCCEEAIAcgB0EEaiAHQQhqQeD5xAAQ9QcAC9gQAQR/IwBBEGsiAyQAEL8JIgRBsOjAAEEJEOwIIgIgACgCpAG4ELcJIgEQwAkCQAJAAkACQAJAAkACQAJAAkACQAJAAkBBtLvJAC0AAEUEQEG4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECE8EQCACEJsHCyAEQbnowABBCRDsCCICIAAoAqgBuBC3CSIBEMAJQbS7yQAtAAANAUG4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECE8EQCACEJsHCyAEQcLowABBCxDsCCICIAAoAqwBuBC3CSIBEMAJQbS7yQAtAAANAkG4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECE8EQCACEJsHCyAEQc3owABBBBDsCCICIAAoArABENsJIgEQwAlBtLvJAC0AAA0DQbi7yQBBADYCAEG0u8kAQQA6AAAgAUGECE8EQCABEJsHCyACQYQITwRAIAIQmwcLIARB0ejAAEEEEOwIIgIgACgCtAEQ2wkiARDACUG0u8kALQAADQRBuLvJAEEANgIAQbS7yQBBADoAACABQYQITwRAIAEQmwcLIAJBhAhPBEAgAhCbBwsCQCAAKAIAQQFHDQAgBEH458AAQQMQ7AgiAiAAKAIEENsJIgEQwAlBtLvJAC0AAA0GQbi7yQBBADYCAEG0u8kAQQA6AAAgAUGECE8EQCABEJsHCyACQYQISQ0AIAIQmwcLAkAgACgCCEUNACAEQfvnwABBAxDsCCICIAAoAgwQ2wkiARDACUG0u8kALQAADQdBuLvJAEEANgIAQbS7yQBBADoAACABQYQITwRAIAEQmwcLIAJBhAhJDQAgAhCbBwsCQCAAKAIQRQ0AIARB/ufAAEEEEOwIIgIgACgCFBDbCSIBEMAJQbS7yQAtAAANCEG4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECEkNACACEJsHCwJAIAAoAhhFDQAgBEGC6MAAQQQQ7AgiAiAAKAIcENsJIgEQwAlBtLvJAC0AAA0JQbi7yQBBADYCAEG0u8kAQQA6AAAgAUGECE8EQCABEJsHCyACQYQISQ0AIAIQmwcLAkAgACgCIEUNACAEQajpwABBCBDsCCICIAAoAiQQ2wkiARDACUG0u8kALQAADQpBuLvJAEEANgIAQbS7yQBBADoAACABQYQITwRAIAEQmwcLIAJBhAhJDQAgAhCbBwsCQCAAKAIoRQ0AIARBwOnAAEEIEOwIIgIgACgCLBDbCSIBEMAJQbS7yQAtAAANC0G4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECEkNACACEJsHCwJAIAAoAjBFDQAQwQkiAiAAKAI0ENsJIgEQ4gkgAUGECE8EQCABEJsHCyACIAAoAjgQ2wkiARDiCSABQYQITwRAIAEQmwcLIARB2OnAAEEIEOwIIgEgAhDACUG0u8kALQAADQxBuLvJAEEANgIAQbS7yQBBADoAACACQYQITwRAIAIQmwcLIAFBhAhJDQAgARCbBwsCQCAAKAI8RQ0AIARBhujAAEEHEOwIIgIgACgCQBDbCSIBEMAJQbS7yQAtAAANDUG4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECEkNACACEJsHCyAAEIoCIANBEGokACAEDwtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABBwOrAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQbDqwAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEGg6sAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABBkOrAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQYDqwAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEHo6MAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABB+OjAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQYjpwAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEGY6cAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABBsOnAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQcjpwAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEHg6cAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABB8OnAABDgBgAL2BABBX8jAEEQayIDJAAQvwkiBUGw6MAAQQkQ7AgiASAAKAKgAbgQtwkiAhDACQJAAkACQAJAAkACQAJAAkACQAJAAkBBtLvJAC0AAEUEQEG4u8kAQQA2AgBBtLvJAEEAOgAAIAJBhAhPBEAgAhCbBwsgAUGECE8EQCABEJsHCyAFQbnowABBCRDsCCIBIAAoAqQBuBC3CSICEMAJQbS7yQAtAAANAUG4u8kAQQA2AgBBtLvJAEEAOgAAIAJBhAhPBEAgAhCbBwsgAUGECE8EQCABEJsHCyAFQcLowABBCxDsCCIBIAAoAqgBuBC3CSICEMAJQbS7yQAtAAANAkG4u8kAQQA2AgBBtLvJAEEAOgAAIAJBhAhPBEAgAhCbBwsgAUGECE8EQCABEJsHCyAFQaDswABBBhDsCCIBIAAoAqwBEMAJQbS7yQAtAAANA0G4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsCQCAAKAIAQQFHDQAgBUH458AAQQMQ7AgiASAAKAIEENsJIgIQwAlBtLvJAC0AAA0FQbi7yQBBADYCAEG0u8kAQQA6AAAgAkGECE8EQCACEJsHCyABQYQISQ0AIAEQmwcLAkAgACgCCEUNACAFQfvnwABBAxDsCCIBIAAoAgwQ2wkiAhDACUG0u8kALQAADQZBuLvJAEEANgIAQbS7yQBBADoAACACQYQITwRAIAIQmwcLIAFBhAhJDQAgARCbBwsCQCAAKAIQRQ0AIAVBjOzAAEEDEOwIIgEgACgCFBDbCSICEMAJQbS7yQAtAAANB0G4u8kAQQA2AgBBtLvJAEEAOgAAIAJBhAhPBEAgAhCbBwsgAUGECEkNACABEJsHCwJAIAAoAhhFDQAgBUGo6cAAQQgQ7AgiASAAKAIcENsJIgIQwAlBtLvJAC0AAA0IQbi7yQBBADYCAEG0u8kAQQA6AAAgAkGECE8EQCACEJsHCyABQYQISQ0AIAEQmwcLAkAgACgCIEUNACAFQcDpwABBCBDsCCIBIAAoAiQQ2wkiAhDACUG0u8kALQAADQlBuLvJAEEANgIAQbS7yQBBADoAACACQYQITwRAIAIQmwcLIAFBhAhJDQAgARCbBwsCQCAAKAIoRQ0AIAVB2OnAAEEIEOwIIgEgACgCLBDbCSICEMAJQbS7yQAtAAANCkG4u8kAQQA2AgBBtLvJAEEAOgAAIAJBhAhPBEAgAhCbBwsgAUGECEkNACABEJsHCwJAIAAoAjBFDQAgBUGG6MAAQQcQ7AgiASAAKAI0ENsJIgIQwAlBtLvJAC0AAA0LQbi7yQBBADYCAEG0u8kAQQA6AAAgAkGECE8EQCACEJsHCyABQYQISQ0AIAEQmwcLQZjtwABBDRDsCCECEL8JIQEgACoCgAG7ELcJIQQgAUHg6sAAQQYQzwMgBBDjCCAAKgKEAbsQtwkhBCABQebqwABBBhDPAyAEEOMIIAAqAogBuxC3CSEEIAFB7OrAAEEKEM8DIAQQ4wggACoCjAG7ELcJIQQgAUH26sAAQQoQzwMgBBDjCCAAKgKQAbsQtwkhBCABQYDrwABBBhDPAyAEEOMIIAAqApQBuxC3CSEEIAFBhuvAAEEGEM8DIAQQ4wggACoCmAG7ELcJIQQgAUGM68AAQQYQzwMgBBDjCCAALQCcASEEIAFBkuvAAEEKEM8DQYIIQYMIIAQbEOMIIAUgAiABEMAJQbS7yQAtAAANC0G4u8kAQQA2AgBBtLvJAEEAOgAAIAFBhAhPBEAgARCbBwsgAkGECE8EQCACEJsHCyAAEMACIANBEGokACAFDwtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABB6O3AABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQdjtwAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEHI7cAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABBuO3AABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQajswAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEG47MAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABByOzAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQdjswAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEHo7MAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgAyAANgIMQdjmyABBKyADQQxqQdjowABB+OzAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIAMgADYCDEHY5sgAQSsgA0EMakHY6MAAQYjtwAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AgxB2ObIAEErIANBDGpB2OjAAEGo7cAAEOAGAAvODAIDfhB/IwBBIGsiDSQAAkACQEHMtckAKAIARQ0AQcS1yQAoAgAiCUHYtckAKQMAIgQgAK2FIgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRC0oGqm6v6gtenf34iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCAFQtii0e/CqeW/LX6FIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgBEIIiEKAgID4D4MgBEIYiEKAgPwHg4QgBEIoiEKA/gODIARCOIiEhIRB0LXJACkDACIFQn+FfiIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISEIAQgBUI4hiAFQoD+A4NCKIaEIAVCgID8B4NCGIYgBUKAgID4D4NCCIaEhCAFQgiIQoCAgPgPgyAFQhiIQoCA/AeDhCAFQiiIQoD+A4MgBUI4iISEhH6FIASJIgSncSEHIARCGYhC/wCDQoGChIiQoMCAAX4hBkHAtckAKAIAIgtBIGshCgNAIAcgC2opAAAiBSAGhSIEQn+FIARCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBFBFBEADQCAAIAogBHqnQQN2IAdqIAlxIgxBBXRrKAIARg0EIARCAX0gBIMiBFBFDQALCyAFIAVCAYaDQoCBgoSIkKDAgH+DUEUNASAHIAhBCGoiCGogCXEhBwwACwALQbjzwAAQ3QkACyALQQAgDGtBBXRqQQRrKAIAIgwoAghFBEAgDEF/NgIIQQAhB0HQtskAKAIAIhBFBEBByLbJACgCAEH//w9NBEBByLbJAEEAQYCAEEEEQQQQpAVB0LbJACgCACEHC0HMtskAKAIAIAdBAnRqIgBBAEH8/z/8CwBB0LbJACAHQYCAEGoiEDYCACAAQfz/P2pBADYCAAsgASACaiIAIAwoAhQiCEsEQCAIIQkgACAIQQF0IgogACAKSxsiDiAIayIAIAwoAgwgCGtLBEAgDEEMaiAIIABBBEEQEKQFIAwoAhQhCQsgDCgCECEPIABBA3EiCgRAIAkgCmohCyAPIAlBBHRqIQcgCiEAA0AgB0IANwIAIAdBBmpCADcBACAHQRBqIQcgAEEBayIADQALIAshCSAOIAggCmprIQALIAggDmtBfE0EQCAPIAlBBHRqIQcgCSELA0AgB0IANwIAIAdBBmpCADcBACAHQRBqQgA3AgAgB0EWakIANwEAIAdBIGpCADcCACAHQSZqQgA3AQAgB0EwakIANwIAIAdBNmpCADcBACAHQUBrIQcgC0EEaiELIABBBGsiAA0ACwsgDCALNgIUCyACBEAgAUEEdCEUQQAhCUHMtskAKAIAIQ8DQAJAAkACQCAQQYCABCACIAkiAGsiCSAJQYCABE8bIgpBAnQiC08EQCANIAMgAEECdCAAIApqIglBAnQQ4QgiCBC4CiIHNgIAIA0gCzYCBCAHIAtHDQEgDyALIAgQ4QkgCEGECE8EQCAIEJsHCyAAIAJGDQMgCkEEdCERIAAgAWohCiAUIABBBHRqIRVBACEHQQAhAANAIAAgEUYNAyAMKAIUIgggCksEQCAAIA9qIg4oAgAhEiAOQQRqKAIAIRMgDkEIaigCACEWIAwoAhAgFWogAGoiCCAOQQxqKAIANgIAIAhBDGogFjsBACAIQQpqIBNBEHY7AQAgCEEIaiATOwEAIAhBBmogEkEQdjsBACAIQQRqIBI7AQAgB0EEaiEHIApBAWohCiARIABBEGoiAEYNBQwBCwsgCiAIQcjzwAAQjAcAC0EAIAsgEEHY88AAEOoHAAsgDUEANgIIQQAgDSANQQRqIA1BCGpB4PnEABD1BwALIAcgC0H488AAEIwHAAsgAiAJSw0ACwsgDCAMKAIIQQFqNgIIIA1BIGokAA8LQejzwAAQsAoAC/ELAR1/IwBBMGsiASQAIAAQowUgAEHAAWpBADoAACAAQgA3ArgBAkACQAJAAkACQAJAIAAoAowBIgVBgICAgHhGIAAoApgBIgJBgICAgHhGcUUEQCAFQYCAgIB4RyACQYCAgIB4R3FFBEAgAUEANgIoIAFBATYCHCABQZzgwAA2AhggAUIENwIgIAFBGGoQkgchAgwECyAAQYCABBDQBCAAKAKoASIKQQJ0ELYJIQ8CQCAAKAI8RQ0AIAAoAkAiAkGECEkNACACEJsHCyAAIA82AkAgAEEBNgI8IAAoAowBIhBBgICAgHhGDQIgACgCmAEiEUGAgICAeEYNAQJAIApFDQAgACgCnAEhGSAAKAKQASEaIAAoAqABIRIgACgClAEhEyAAKAK0ASEbIAAoArABIRwgACgCiAEhFCAAKAKEASEVIAAoAnwhFiAAKAJ4IQtBACECA0AgFkGAgAQgCiACayIFIAVBgIAETxsiCEECdCIDSQRAQQAgAyAWQYi7wQAQ6gcACwJAIAMgFE0EQCABIBwgAkECdCIMIAIgCGoiBUECdCIXEOEIIgQQuAoiBzYCFCABIAM2AgggAyAHRgRAIAsgAyAEEOEJIARBhAhPBEAgBBCbBwsgASAbIAwgFxDhCCIEELgKIgc2AhQgASADNgIIIAMgB0YEQCAVIAMgBBDhCSAEQYQITwRAIAQQmwcLIAIgCkYNAyAIQQR0IRggDCAZaiEdIBogAkEBdGohDUEAIQRBACEIAkADQCAEIBhGBEAgCCAIQQRqIANB6LrBABDqBwALIAEgBCALaiIOKQIANwIIIAEgDkEIaioCADgCEAJ/IA5BDGooAgAiBkH//wFxRQRAIAZBEHQMAQsgBkH/B3EhByAGQYCAAnEhCSAGQYD4AXEiBkGA+AFGBEAgCUEQdCEGIAZBgICA/AdyIAdFDQEaIAYgB0ENdHJBgICA/gdyDAELIAlBEHQhCSAGQQ10QYCAgPwAcSAHQQ10ckGAgIDAA2ogCXIgBg0AGiAJQYCAgNgDciAHZ0EQayIGQRd0ayAHIAZB//8DcUEIanRB////A3FyCyEHIAFBGGoiBiAEIBVqEJYDIAIgE0kEQCACIBJPDQIgDiABQQhqIAe+IAYgDS8BACAIIB1qKAIAEJECIAhBBGohCCANQQJqIQ0gAkEBaiECIBggBEEQaiIERw0BDAYLCyACIBNByLrBABCMBwALIAIgEkHYusEAEIwHAAsMCQsMCAtBACADIBRB+LrBABDqBwALIAEgDyAMIBcQ4QgiAhC4CiIENgIUIAEgAzYCCCADIARGBEAgAiALIAMQ4AkgAkGECE8EQCACEJsHCyAFIgIgCkkNAQwCCwsMBQsgEUGAgICAeHJBgICAgHhHBEAgACgCnAEiAkEEaygCACIFQXhxIgMgEUECdCIEQQRBCCAFQQNxIgUbakkNBiAFQQAgAyAEQSdqSxsNByACEKICCyAAQYCAgIB4NgKYASAQQYCAgIB4ckGAgICAeEcEQCAAKAKQASICQQRrKAIAIgVBeHEiAyAQQQF0IgRBBEEIIAVBA3EiBRtqSQ0GIAVBACADIARBJ2pLGw0HIAIQogILIABBgICAgHg2AowBC0EAIQIgAEEANgJ8IAAoAnghBSAAKAJ0IQMgAEKAgICAwAA3AnQgAwRAIAVBBGsoAgAiBEF4cSIIIANBAnQiA0EEQQggBEEDcSIEG2pJDQUgBEEAIAggA0EnaksbDQYgBRCiAgsgAEEANgKIASAAKAKEASEFIAAoAoABIQMgAEKAgICAwAA3AoABIANFDQIgBUEEaygCACIAQXhxIgQgA0ECdCIDQQRBCCAAQQNxIgAbakkNBCAAQQAgBCADQSdqSxsNBSAFEKICDAILQbi6wQAQ3QkAC0GousEAEN0JAAsgAUEwaiQAIAIPCyABQQA2AhhBACABQRRqIAFBCGogAUEYakHg+cQAEPUHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL3hgDB38BfgF7IwBBIGsiBiQAAkACQCAAKAIAIgdFBEAgACgCECIARQ0BIABBk7PFAEEBEJcDIQIMAgsCQAJAAkACQAJAIAAoAggiAiAAKAIEIgVPBEAgACgCECIBRQ0BIAFB6rLFAEEQEJcDRQ0BDAULIAAgAkEBaiIENgIIIAIgB2otAAAhAyAAIAAoAgxBAWoiCDYCDCAIQfUDTwRAIAAoAhAiAQRAIAFB+rLFAEEZEJcDDQYLIABBAToABAwCCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIANB0QBrDikLCgEPARABAQEBAQEBAQEBBAcIAQkBAQMEAwEEAwQDAgEBBAMBAQEEAwALIANBwQBrDgINBAALIAAoAhAiAUUNESABQeqyxQBBEBCXAw0VDBELIAAoAhAiAUUNE0EBIQIgAUGSssUAQQEQlwNFDRMMFgsgACADEIYFDRMMEgsgBCAFTw0QIAQgB2otAABB7gBGDQEMEAsjAEEgayICJAACQAJAIAAoAgBFBEAgACgCECIBRQ0BIAFBk7PFAEEBEJcDIQEMAgsgAiAAEK8GIAIoAgBFBEAgACgCECIDBEBBASEBIANB+rLFAEHqssUAIAItAARBAXEiAxtBGUEQIAMbEJcDDQMLIAAgAv0AAgD9CwIADAELIAAoAhBFDQAgAP0AAgAhCiAAIAL9AAIA/QsCACACIAr9CwMQIAAgAUEBcRDVASEBIAAgAv0AAxD9CwIADAELQQAhAQsgAkEgaiQAIAENEQwQCyAAIAJBAmo2AgggACgCECIBRQ0OQQEhAiABQeqzxQBBARCXA0UNDgwSCyAGQRhqIAAQyAUgBigCGCIBRQRAIAYtABwhASAAKAIQIgMEQEEBIQIgA0H6ssUAQeqyxQAgAUEBcSIDG0EZQRAgAxsQlwMNEwsgACABOgAEDA0LIAZBCGogASAGKAIcEMIEAkACQAJAIAYoAghBAUcNACAGKQMQIglCAVYNACAJp0EBaw0BDAILIAAoAhAiAUUNDSABQeqyxQBBEBCXAw0RDA0LIAAoAhAiAUUNDyABQfKzxQBBBRCXAw0QDA8LIAAoAhAiAUUNDiABQfezxQBBBBCXAw0PDA4LIAZBGGogABDIBSAGKAIYIgFFBEAgBi0AHCEBIAAoAhAiAwRAQQEhAiADQfqyxQBB6rLFACABQQFxIgMbQRlBECADGxCXAw0SCyAAIAE6AAQMDAsgBkEIaiABIAYoAhwQwgQCQCAGKAIIIAYpAxAiCUKAgICAEFRxRQ0AQYCAxAAgCaciASABQYCwA3NBgIDEAGtBgJC8f0kbIgFBgIDEAEYNACAAKAIQIQMjAEEgayICJAACf0EAIANFDQAaAkAgAygCAEEnIAMoAgQoAhARAgANAANAAkACQAJ/AkACQCABQSJHBEAgAUGAgMQARgRAIAMoAgBBJyADKAIEKAIQEQIADAkLAkACQAJAAkACQAJAIAFBJkwEQCABQQlrDgUBAwYGAgULIAFBJ0YNAyABQdwARw0FIAJCADcBAiACQdy4ATsBAAwICyACQgA3AQIgAkHc6AE7AQAMBwsgAkIANwECIAJB3OQBOwEADAYLIAJCADcBAiACQdzcATsBAAwFCyACQgA3AQIgAkHczgA7AQAMBAsgAUUNAgsCQAJAIAFBgAZPBEAgARDlBA0BCyABEOECDQELIAJBEGogARDWBSACQQhqIgUgAkEYaiIHLwAAOwEAIAIgAikAEDcDACACLQAaIQEgAi0AGyEEIAcgBS8BADsBACACIAIpAwA3AxAgAUH/AXEgBEH/AXFJDQUMBgsgAiABNgIAQYEBIQRBgAEMAwtBgIDEACEBIAMoAgBBIiADKAIEKAIQEQIARQ0FDAYLIAJCADcBAiACQdzgADsBAAtBAiEEQQALIQEgAkEYaiACQQhqLwEAOwEAIAIgAikDADcDEAsgBEH/AXEhByABQf8BcSEEIAMoAgAhASADKAIEKAIQIQUgAigCECEIA0AgASAHQYABTQR/IAJBEGogBGotAAAFIAgLIAURAgANAyAHIARBAWoiBEcNAAsLQYCAxAAhAQwACwALQQELIAJBIGokAA0PDA4LIAAoAhAiAUUNCiABQeqyxQBBEBCXAw0ODAoLAkAgAQ0AIAAoAhAiA0UNAEEBIQIgA0H7s8UAQQEQlwMNEAsgACgCECIDBEBBASECIANBsrPFAEEBEJcDDRALIAAQwQINDQwICyAEIAVPDQAgBCAHai0AAEHlAEYNAQsCQCABDQAgACgCECIERQ0AQQEhAiAEQfuzxQBBARCXAw0OCyAAKAIQIgQEQEEBIQIgBEGss8UAQQEQlwMNDgsgA0HSAEcNAQwFCyAAIAJBAmo2AgggABDBAg0KDAkLIAAoAhAiAkUNAyACQa6zxQBBBBCXAw0JDAMLAkAgAQ0AIAAoAhAiA0UNAEEBIQIgA0H7s8UAQQEQlwMNCwsgACgCECIDBEBBASECIANB6LLFAEEBEJcDDQsLIAAQyQYNCCAAKAIQIgNFDQdBASECIANB6bLFAEEBEJcDRQ0DDAoLAkAgAQ0AIAAoAhAiA0UNAEEBIQIgA0H7s8UAQQEQlwMNCgsgACgCECIDBEBBASECIANBu7PFAEEBEJcDDQoLQQAhAgJ/AkAgACgCACIDRQ0AA0ACQCAAKAIIIgQgACgCBE8NACADIARqLQAAQcUARw0AIAAgBEEBajYCCAwCCwJAIAJFDQAgACgCECIDRQ0AIANB55DGAEECEJcDRQ0AQQEMAwtBASAAQQEQ1QENAhogAkEBaiECIAAoAgAiAw0ACwtBAAshAyAGIAI2AgQgBiADNgIAQQEhAiAGKAIAQQFxDQkgBigCBEEBRgRAIAAoAhAiA0UNByADQbyzxQBBARCXAw0KCyAAKAIQIgNFDQYgA0HejsgAQQEQlwNFDQIMCQsCQCABDQAgACgCECIDRQ0AQQEhAiADQfuzxQBBARCXAw0JC0EBIQIgAEEBEMwBDQggACgCACIERQRAIAAoAhAiAEUNCCAAQZOzxQBBARCXAyECDAkLIAAoAggiAyAAKAIETwRAIAAoAhAiAUUNAyABQeqyxQBBEBCXA0UNAwwJCyAAIANBAWo2AggCQAJAAkAgAyAEai0AAEHTAGsOAwIBBAALIAAoAhAiAUUNBCABQeqyxQBBEBCXAw0IDAQLIAAoAhAiAwRAIANBu7PFAEEBEJcDDQoLIAAQyQYNByAAKAIQIgNFDQYgA0HejsgAQQEQlwNFDQIMCQsgACgCECICBEAgAkH8s8UAQQMQlwMNBwtBASECQQAhByMAQSBrIgMkAAJAAkACQCAAKAIAIgRFDQADQAJAIAAoAggiBSAAKAIETw0AIAQgBWotAABBxQBHDQAgACAFQQFqNgIIDAILAkACQCAHRQ0AIAAoAhAiBEUNACAEQeeQxgBBAhCXAw0EIAAoAgANACAAKAIQIgVFDQFBASEEIAVBk7PFAEEBEJcDRQ0BDAULIAMgAEHzABCsBiADLQAAQQFGBEAgAy0AASEHIAAoAhAiBQRAQQEhBCAFQfqyxQBB6rLFACAHQQFxIgUbQRlBECAFGxCXAw0GCyAAIAc6AAQgAEEANgIADAMLIAAoAgBFBEAgACgCECIFRQ0BQQEhBCAFQZOzxQBBARCXA0UNAQwFCyADIAAQ7wIgAygCAEUEQCADLQAEIQcgACgCECIFBEBBASEEIAVB+rLFAEHqssUAIAdBAXEiBRtBGUEQIAUbEJcDDQYLIAAgBzoABCAAQQA2AgAMAwsgAyAD/QACAP0LAxACQCAAKAIQIgRFDQAgA0EQaiAEEIsCDQQgACgCECIERQ0AIARB3fjHAEECEJcDDQQLQQEhBCAAQQEQ1QENBAsgB0EBayEHIAAoAgAiBA0ACwtBACEEDAELQQEhBAsgA0EgaiQAIAQNCCAAKAIQIgNFDQUgA0H/s8UAQQIQlwNFDQEMCAtBASECIABBARDVAQ0HCyABDQMgACgCECIBRQ0DQQEhAiABQaWzxQBBARCXA0UNAwwGC0EAIQIgAEEAOgAEIABBADYCAAwFC0EAIQIgAEEANgIADAQLIAAgAxCGBQ0BC0EAIQIgACgCAEUNAiAAIAAoAgxBAWs2AgwMAgtBASECDAELQQAhAgsgBkEgaiQAIAIL/gwBFn8jAEFAaiIFJAACQCABLQD4AkEIRwRAAkACQCADBEAgAUHIAmohFCABQf0CaiEPIAVBIGpBBXIhFSAFQRBqIREgAUHgAmohGSADIQkDQCAFQR5qIhYgD0ECaiISLQAAOgAAIAEtAPgCIQ4gAUEIOgD4AiAFIA8vAAA7ARwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgDkEIRwRAIAEoAoQDIQggASgCgAMhECABKAD5AiETIA5BBmtB/wFxQQFqQQAgDkEFSxtBAWsOAgIDAQtBgJHFABDdCQALIBUgDy8AADsAACAVQQJqIBItAAA6AAAgBSATNgAhIAUgDjoAICAFIBA2AjQgCEUgCUEET3ENAyAJQQQgCGsiBiAGIAlLGyIGIAhqIgcgCEkgB0EFT3INBiAGBEAgBUE0aiAIaiACIAb8CgAACyAHQQRGBEAgBUEIaiABIAVBIGogBUE0aiAEIAYQNQwFCyABIAc2AoQDIAEgBSgCNDYCgAMgASAFKQMgNwP4AiAFQQA6ABAgBSAGNgIMIAVBADYCCAwECyABKALcAiIGRQ0EIAEoAuACIAEoAugCayIHIAkgByAJSRsiByAGIAYgB0sbIQsgAS0AkQNFBEAgFCACIAsQ3gELIAEtAOwCDQ4gASgC6AIiCiABKALgAiIHRwRAIAohBgwOCyABKAKIAyIGRQ0BIAEgBiAGIAogBiAKSRsiDWs2AogDQQAhB0EAIQYgCkUNDSAKIA1qIgdBAE4EfyAFIAo2AjwgBUEBNgI4IAUgASgC5AI2AjQgBUEoakEBIAcgBUE0ahCFByAFKAIoQQFHDQcgBSgCMCEMIAUoAiwFIAYLIAxBoJHFABCTCQALIAEoAtwCIgYgCSAGIAlJGyIKIQcgBA0GDAcLIAVBJzoADAwHCyAFQQhqIAEgBUEgaiACIARBBBA1CyAFKAIIQQFxDQYgBS0AECEGDAsLIAFCADcDgAMgAUEEOgD4AkEAIQYgEUEAOgAAIAVCADcDCAwKCyAIIAdBBEGQkcUAEOoHAAsgBSgCLCEGIAEgBzYC4AIgASAGNgLkAiABKALoAiEGDAYLIAEoAvACIg0tAKMHQQdGDQACQCABLQD0Ag0AIAEtAPUCQQFxRQ0AIA1BAToApgcLIAQoAgQiCyAEKAIMIgwoAgAiGkGAQGsiByAHIAtLGyIXIAQoAggiGCgCACIHSQ0DIAVBNGogDSACIAogBCgCACAHaiAXIAdrIBogB2tBABBCIAUtADRFBEAgBSgCOCEHIAwgDCgCACAFKAI8aiIMNgIAAkAgDS0AowdBB0cEQCAMQYCAAkkNASAMQYCAAmsiDCAYKAIATQ0BCyAYIAw2AgALIAFBAToA9AIMAQsgBSAFLQA1OgANIAVBHDoADAwBCyABLQCRA0UEQCAHIApLDQQgFCACIAcQ3gEgASgC3AIhBgsgASAGIAdrNgLcAgJAIAYgB0YEQEEEIQ5BACEQQQAhCAwBCyAPIAUvARw7AAAgEiAWLQAAOgAACyABIAg2AoQDIAEgEzYA+QIgASAOOgD4AiABIBA2AoADQQUhBiAFQQU6ABAgBSAHNgIMIAVBADYCCAwGCyAFQQE2AggLIAAgBf0AAwj9CwIAIABBEGogBUEYaigCADYCAAwKCyAHIBcgC0HwkMUAEOoHAAtBACAHIApBsJHFABDqBwALIAcgBmsgC0kEQCAZIAYgCxDvBSABKALoAiEGCyALBEAgASgC5AIgBmogAiAL/AoAAAsgASAGIAtqNgLoAgsgASABKALcAiIMIAtrNgLcAkEEIQpBACEGQQAhB0EAIQ0gCyAMRwRAIA8gBS8BHDsAACASIBYtAAA6AAAgDiEKIAghDSAQIQcLIAEgDTYChAMgASATNgD5AiABIAo6APgCIAEgBzYCgAMgBUEAOgAQIAUgCzYCDCAFQQA2AggLIAUoAgwhCCAGQf8BcQ0DIAggCUsNAiACIAhqIQIgCSAIayIJDQALCyAAQQA6AAggACADNgIEIABBADYCAAwDCyAIIAkgCUHklcUAEOoHAAsgCCAJTQRAIABBADYCACAAIBEpAgA3AgggAEEQaiARQQhqKAIANgIAIAAgAyAJayAIajYCBAwCCyAIIAkgCUH0lcUAEOoHAAsgAEECNgIIIABBJjoABCAAQQE2AgALIAVBQGskAAvlDAIOfwN+IwBBIGsiAyQAAkACQCAAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAIAEoAqgBQQFrDgIBAgALIANBEGohBQJAAkBBJRBxIgFFDQAgAUEdakGdnccAKQAANwAAIAFBEGpBkJ3HAP0AAAD9CwAAIAFBgJ3HAP0AAAD9CwAAQQwQcSICRQ0AIAJBJTYCCCACIAE2AgQgAkElNgIAQQwQcSIBRQ0AIAFBKDoACCABQbidxwA2AgQgASACNgIAIAUgAa1CIIZCA4Q3AgAMAQsACwwCCyADQRBqIAFBsAFqIAIQ8wEMAQsgASgCrAEhCiACKAIAIhAhBSACKAIIIgwhBwJ/AkAgECAMa0EgTw0AIANBEGogCiACEI8EAkBBAAJ/IAMtABBBBEYEQCADKAIUDAELIAMpAxAiEUIgiCETIBFC/wGDQgRSDQEgE6cLRQ0CGiACKAIAIQUgAigCCCEHDAELIBFCgH6DIRIMBgtBgMAAIQtBACEBA0ACQCAFIBBHIAUgB0dyRQRAIANBEGogCiACEI8EAkACQAJ/IAMtABBBBEYEQCADKAIUDAELIAMpAxAiEUIgiCETIBFC/wGDQgRSDQEgE6cLDQEgAigCCCEHDAMLIBFCgH6DIRIMCQsgAigCCCEHIAIoAgAhBQsCQCAFIAdHBEAgBSAHayENIAIoAgQhBAwBC0IBIRFCgMwAIRJCACETIAVBIGoiCCAFQQF0IgQgBCAISRsiCEEASA0IIAMgBQR/IAMgBTYCGCADIAIoAgQ2AhBBAQVBAAs2AhQgA0EEakEBIAggA0EQahCFByADKAIEQQFGDQggAygCCCEEIAIgCDYCACACIAQ2AgQgCCAFayENIAghBQsgBCAHaiEOIAsgDSALIA1JGyIIIAFrIgQEQCABIA5qQQAgBPwLAAsgA0EQaiAKIA4gCBDkAgJAIAMtABBBBEYNACADKQMQIhJCIIgiE6chBEIAIRECQAJAAkACQAJAIBKnQf8BcUEBaw4EAgEABAwLIAQtAAhBI0YNAgwKCyAELQAIQSNGDQFCAiERDAoLIBJCgP4Dg0KAxgBRDQBCASERDAkLAn8gEkL/AYNCA1EEQCAEKAIAIQEgBEEEaigCACIGKAIAIgkEQCABIAkRAwALIAYoAgQiBgRAIAFBBGsoAgAiCUF4cSIPQQRBCCAJQQNxIgkbIAZqSQ0RIAlBACAPIAZBJ2pLGw0SIAEQogILIARBBGsoAgAiAUF4cSIGQRBBFCABQQNxIgEbSQ0QIAFBACAGQTRPG0UEQEEADAILDBELQQELIQEDQAJAAkAgAUUEQCAEEKICDAELIANBEGogCiAOIAgQ5AIgAy0AEEEERg0EIAMpAxAiEkIgiCITpyEEAkACQAJAAkAgEqdB/wFxQQFrDgQAAQIHDwsgEkKA/gODQoDGAFENAkIBIREMDgsgBC0ACEEjRg0BQgIhEQwNCyAELQAIQSNHDQsLIBJC/wGDQgNRDQELQQEhAQwBCyAEKAIAIQEgBEEEaigCACIGKAIAIgkEQCABIAkRAwALIAYoAgQiBgRAIAFBBGsoAgAiCUF4cSIPQQRBCCAJQQNxIgkbIAZqSQ0QIAlBACAPIAZBJ2pLGw0RIAEQogILIARBBGsoAgAiAUF4cSIGQRBBFCABQQNxIgEbSQ0PIAFFIAZBNElyRQRADBELQQAhAQwACwALIAIgBzYCCAwBCyADKAIUIgEgCEsEQEG0m8cAQTZB7JvHABDrBwALIAIgASAHaiIHNgIIIAFFDQBBfyALQQF0IAtBAEgbIAsgASAIRhsgCyALIA1NGyELIAggAWshAQwBCwsgByAMawshASAKLQC0AUEBRw0GIAIoAggiBSAMSQ0BIApBoAFqIAIoAgQgDGogBSAMaxDeASAKKAKwASAKKAKoAUYNBiADQRBqEJMHCyADLQAQIQEMBAsgDCAFIAVB7KvHABDqBwALQgMhEQsgAiAHNgIIIBJCgH6DIRILIAMgEz4CFCADIBGnIgE6ABAgAyASpyICQRh2OgATIAMgAkEIdjsAEQsgAUH/AXFBBEcNASADKAIUIQELIAAgAa03AwhBAAwBCyAAIAMpAxA3AgRBAQs2AgAgA0EgaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALtAwCDH8BfiMAQeAEayIJJABBBiELAkACQAJAAkACQAJAAkAgASgCACIKQYCAgIB4Rg0AIAlBEGogASgCBCIMIAEoAggQkQUgCS0AEEEBRgRAIAkoAhQhASAJQQA2AqQDIAlCgICAgBA3ApwDIAlBnJPBADYC3AEgCUKggICADjcC4AEgCSAJQZwDajYC2AEgASAJQdgBahCvBA0CIAkoApwDIQsgCSgCoAMiDSAJKAKkAxDsCCEPIAsEQCANQQRrKAIAIg5BeHEiEEEEQQggDkEDcSIOGyALakkNByAOQQAgECALQSdqSxsNCCANEKICCyAAQQA2AgAgACAPNgIEIAEgASgCACgCABEDACAKBEAgDEEEaygCACIAQXhxIgFBBEEIIABBA3EiABsgCmpJDQcgAEEAIAEgCkEnaksbDQggDBCiAgsgB0UgCEGECElyRQRAIAgQmwcLIAVFIAZBhAhJckUEQCAGEJsHCyADRSAEQYQISXJFBEAgBBCbBwsgAigCACIAQYCAgIB4ckGAgICAeEYNBSACKAIEIgFBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIABqSQ0GIAJBACADIABBJ2pLGw0HIAEQogIMBQsgCS0AESELIApFDQAgDEEEaygCACIBQXhxIg1BBEEIIAFBA3EiARsgCmpJDQUgAUEAIA0gCkEnaksbDQYgDBCiAgtBBCEBQQAhCkEAELYJIRNBABC2CSEUQQAhDEEEIQ0CQCADQQFxRQ0AIAlB2AFqIAQQlwYgCSgC4AEhDyAJKALcASENIAkoAtgBIQwgBEGECEkNACAEEJsHC0EAIQQCQCAFQQFxRQ0AIAlB2AFqIAYQlwYgCSgC4AEhBCAJKALcASEBIAkoAtgBIQogBkGECEkNACAGEJsHC0EEIQZBACEFQQAhA0EEIRACQCAHQQFxRQ0AIAlBnANqIAhBABDoCCIHEJcGIAlB2AFqIAhBARDoCCISEJcGIAkoAuABIREgCSgC3AEhECAJKALYASEOIAkoAqQDIQMgCSgCoAMhBiAJKAKcAyEFIBJBhAhPBEAgEhCbBwsgB0GECE8EQCAHEJsHCyAIQYQISQ0AIAgQmwcLIAkgFDYCjAMgCSATNgKIAyAJQQA2AoQDIAlCADcC/AIgCUGAgICAeDYC8AIgCUGAgICAeDYC5AIgCUIENwLcAiAJQgA3AtQCIAlCgICAgMAANwLMAiAJIBE2AsgCIAkgEDYCxAIgCSAONgLAAiAJIAM2ArwCIAkgBjYCuAIgCSAFNgK0AiAJIAQ2ArACIAkgATYCrAIgCSAKNgKoAiAJIA82AqQCIAkgDTYCoAIgCSAMNgKcAiAJQQA2ApQCIAlBADYCiAIgCUEANgKAAiAJQQA2AvgBIAlBADYC8AEgCUEANgLoASAJQQA2AuABIAlBADYC2AEgCUGYA2pBADoAACAJQgA3ApADIAIoAgAhAyACKAIEIQUgAigCCCEBAn8gC0EGRwRAIAlBCGogCyAJQdgBahDUAyAJKAIMIQQgCSgCCCEHQQIMAQsgCUGcA2ogCUHcAWpBwAH8CgAAQQAhB0EACyEGQYCAgIB4IQggA0GAgICAeEcEQCABQQBIDQICQCABRQRAQQEhCAwBCyABEHEiCEUNBAsgAQRAIAggBSAB/AoAAAsgCK0gAa1CIIaEIRUgASEICyAJQRhqIgIgCUGcA2pBwAH8CgAAQfQBEHEiAUUNAiABIAY2AgAgAUEEaiACQcAB/AoAACABIAs6APABIAEgBDYC7AEgASAHNgLoASABQYCAgIB4NgLcASABIBU3AtQBIAEgCDYC0AEgAUEANgLMASABQoCAgIAQNwLEASAAQbDuwAA2AgwgAEEBNgIIIABBmO7AADYCBCAAIAE2AgAgA0GAgICAeHJBgICAgHhGDQMgBUEEaygCACIAQXhxIgFBBEEIIABBA3EiABsgA2pJDQQgAEEAIAEgA0EnaksbDQUgBRCiAgwDC0GgnsYAQTcgCUHfBGpBtJPBAEHYnsYAEOAGAAtB2JrIABD/BwsACyAJQeAEaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL/Q0BBX8jAEEwayICJAACQAJAAkACQAJAAkACQAJAIAAoAgBBAWsOBQECAwQFAAtBASEDIAEoAgAiBEHUpccAQQggASgCBCIGKAIMIgURAAANBiAAQQRqIQACQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQggACABEIQGRQ0BDAgLIARB24HCAEECIAURAAANByACQQE6ACggAiAGNgIMIAIgBDYCCCACQeCBwgA2AhggAiABKQIINwIcIAIgAkEoajYCECACIAJBCGo2AhQgACACQRRqEIQGDQcgAigCFEHZgcIAQQIgAigCGCgCDBEAAA0HCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMBgtBASEDIAEoAgAiBEHcpccAQQggASgCBCIGKAIMIgURAAANBSAAQQRqIQACQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQcgACABEIUGRQ0BDAcLIARB24HCAEECIAURAAANBiACQQE6ACggAiAGNgIMIAIgBDYCCCACQeCBwgA2AhggAiABKQIINwIcIAIgAkEoajYCECACIAJBCGo2AhQgACACQRRqEIUGDQYgAigCFEHZgcIAQQIgAigCGCgCDBEAAA0GCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMBQtBASEDIAEoAgAiBEHkpccAQQkgASgCBCIGKAIMIgURAAANBCAAQQRqIQACQCABLQAKQYABcUUEQCAEQbuzxQBBASAFEQAADQYgACABEIYGRQ0BDAYLIARB24HCAEECIAURAAANBSACQQE6ACggAiAGNgIMIAIgBDYCCCACQeCBwgA2AhggAiABKQIINwIcIAIgAkEoajYCECACIAJBCGo2AhQgACACQRRqEIYGDQUgAigCFEHZgcIAQQIgAigCGCgCDBEAAA0FCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMBAtBASEDIAEoAgAiBEHtpccAQQYgASgCBCIGKAIMIgURAAANAyAAQQhqIQACQAJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANBiACIAA2AgggASgCAEGMpscAQQogASgCBCgCDBEAACEAIAJBADoAGSACIAA6ABggAiABNgIUIAJBFGpByPvHAEEEIAJBCGpB/KXHABCMBSEAIAItABgiBEEBcSACLQAZIgVBAUdyRQRAIAAoAgAiAC0ACkGAAXENAiAAKAIAQf+zxQBBAiAAKAIEKAIMEQAARQ0DDAcLIAUNBiAEQQFxRQ0CDAYLIARB24HCAEECIAURAAANBSACIAY2AgwgAiAENgIIIAJBAToAByACQeCBwgA2AhggAiABKQIINwIcIAIgAkEHajYCECACIAJBCGoiAzYCFCACIAA2AiQgA0GMpscAQQoQrwMhACACQQA6AC0gAiAAOgAsIAIgAkEUajYCKCACQShqQcj7xwBBBCACQSRqQfylxwAQjAUhAAJAAkAgAi0ALCIDQQFxIAItAC0iBEEBR3JFBEAgACgCACIALQAKQYABcQ0BIAAoAgBB/7PFAEECIAAoAgQoAgwRAAANBwwCCyAEDQYgA0EBcUUNAQwGCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAADQULIAIoAhRB2YHCAEECIAIoAhgoAgwRAABFDQFBASEDDAULIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAANBAsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAMLQQEhAyABKAIAIgRBjYvIAEELIAEoAgQiBigCDCIFEQAADQIgAEEEaiEAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0EIAAgARCHBkUNAQwECyAEQduBwgBBAiAFEQAADQMgAkEBOgAoIAIgBjYCDCACIAQ2AgggAkHggcIANgIYIAIgASkCCDcCHCACIAJBKGo2AhAgAiACQQhqNgIUIAAgAkEUahCHBg0DIAIoAhRB2YHCAEECIAIoAhgoAgwRAAANAwsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAILQQEhAyABKAIAIgRB86XHAEEHIAEoAgQiBigCDCIFEQAADQEgAEEEaiEAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0DIAAgARCuAkUNAQwDCyAEQduBwgBBAiAFEQAADQIgAkEBOgAoIAIgBjYCDCACIAQ2AgggAkHggcIANgIYIAIgASkCCDcCHCACIAJBKGo2AhAgAiACQQhqNgIUIAAgAkEUahCuAg0CIAIoAhRB2YHCAEECIAIoAhgoAgwRAAANAgsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAELQQEhAwsgAkEwaiQAIAMLrgsCCn8CfSMAQYABayIIJAACfwJAIAAoAggiBSABSwRAIAAoAgQgAUEkbGoiBRCKBCEPIAUvARQiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhBiAHQYCAAnEhBSAHQYD4AXEiB0GA+AFGBEAgBUEQdCEFIAVBgICA/AdyIAZFDQMaIAUgBkENdHJBgICA/gdyDAMLIAVBEHQhBSAHRQ0BIAdBDXRBgICA/ABxIAZBDXRyQYCAgMADaiAFcgwCCyABIAVB1MDHABCMBwALIAVBgICA2ANyIAZnQRBrIgVBF3RrIAYgBUH//wNxQQhqdEH///8DcXILIQZDAACAPyEQAkACQAJAIA8gD5IgBr4iD0MAAIA/XgR9IA8QxgVDVPgtQJRDAACAP5KRBSAQC5QgA11FBEAgCCAAKAIQIgogACgCFCIGIAEQ6AICQCAIKAIkIgVBCU8EQCAIKAIEIgkNASAIKAIIIgRBBGsoAgAiAEF4cSICIAVBAnQiAUEEQQggAEEDcSIAG2pJDQQgAEEAIAIgAUEnaksbDQUgBBCiAgwDCyAFIglFDQILIAhBKGogAigCCCIHIAcgCWoQjAMgCiAGIAECfyAIKAJMIglBCU8EQCAIKAIsIQkgCCgCMAwBCyAIQSxqCyAJEOQFIAhBBGohAQJ/IAVBCUkEQCAIQSRqIQYgAQwBCyABIQYgCCgCCAshBwJAIAYoAgAiC0ECSQ0AIAtBFU8EQCAHIAsQwQUMAQsgB0EEaiEFAkAgC0EBcQRAIAUhCiAHIQUMAQsgBygCBCIMIAcoAgAiBkkEQCAHIAw2AgAgByAGNgIECyAHQQhqIQoLIAtBAkYNACAHIAtBAnRqIQ4gCkEEaiELA0AgCigCACIJIAUoAgAiBkkEQCAKIQwCfwNAIAwgBjYCACAHIAUgB0YNARogBSEMIAkgBUEEayIFKAIAIgZJDQALIAVBBGoLIAk2AgAgCigCACEJCyAJIAooAgQiDUsEQCALIQYDQAJAIAYgCTYCACAHIAZBBGsiBUYEQCAHIQUMAQsgBkEIayEMIAUhBiANIAwoAgAiCUkNAQsLIAUgDTYCAAsgCkEEaiEFIAtBCGohCyAKQQhqIgogDkcNAAsLIAgoAiQiByEGIAdBCU8EQCAIKAIEIQYgCCgCCCEBCyAGBEAgBkECdCEFIAIoAggiBkECdCEHA0AgASgCACEMIAIoAgAgBkYEQCACQYDmwQAQiwYLIAFBBGohASACKAIEIAdqIAw2AgAgAiAGQQFqIgY2AgggB0EEaiEHIAVBBGsiBQ0ACyAIKAIkIQcLIAgoAgQhBiAIQfAAaiAIQSBqKAIANgIAIAhB6ABqIAhBGGopAgA3AgAgCCAI/QACCP0LAlggCCAGIAcgB0EISyIFGyIBNgJ8IAggB0EAIAUbNgJ0IAhBACAGIAUbNgJUAkACQCABBEAgB0EJTwRAIAgoAlgiBSEBA0AgACABKAIAIAIgAyAEENoBIAFBBGohASAGQQFrIgYNAAsMAgsgCEHUAGohAUEAIQYDQCAIIAZBAWoiBjYCeCAAIAEoAgAgAiADIAQQ2gEgAUEEaiEBIAYgB0cNAAsMAgsgB0EJSQ0BIAgoAlghBQsgBUEEaygCACIAQXhxIgIgB0ECdCIBQQRBCCAAQQNxIgAbakkNAyAAQQAgAiABQSdqSxsNBCAFEKICCyAIKAJMIgFBCUkNASAIKAIwIgRBBGsoAgAiAEF4cSICIAFBAnQiAUEEQQggAEEDcSIAG2pJDQIgAEEAIAIgAUEnaksbDQMgBBCiAgwBCyAEKAIIIgAgBCgCAEYEQCAEQZDmwQAQiwYLIAQoAgQgAEECdGogATYCACAEIABBAWo2AggMAAsgCEGAAWokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9QNAwp/A34CeyMAQZACayIEJAACQAJAAkACQAJAAkACQAJAAkAgASgCECIFKAIwIgcOAgUBAAsgBSkDGCAFKQMgIAIgAxCVBCEOIAUoAjgiCSAOp3EhBiAOQhmIQv8Ag0KBgoSIkKDAgAF+IRAgBSgCNCILQQRrIQwgBSgCLCEIA0AgBiALaikAACIPIBCFIg5Cf4UgDkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIOUEUEQANAIAwgDnqnQQN2IAZqIAlxQQJ0aygCACIFIAdPDQQgCCAFQbgBbGoiDUGsAWooAgAgA0YEQCACIA1BqAFqKAIAIAMQ2wdFDQcLIA5CAX0gDoMiDlBFDQALCyAPIA9CAYaDQoCBgoSIkKDAgH+DUEUNBSAKQQhqIgogBmogCXEhBgwACwALIAMgBSgCLCIIQawBaigCAEYNAQwDCyAFIAdBkJvIABCMBwALIAIgCCgCqAEgAxDbBw0BQQAhBQsgBSAHTwRAIABCAzcDACAAQYSAgIB4NgIIDAQLIAggBUG4AWxqIgMtAKABDQECQCADLQBoQQNGBEAgAykDYCEODAELIAEoAgQiAq0hDwJAAkACQCACQv////8PIAMpA1AiDiAOQv////8PWhunayIFQQAgAiAFTxtBHU0EQEGokMgAKQMAIhCnIQMCQCAQQv8Bg0IEUQRAIAEgDkIefDcDCCADQf8BcUEERw0BDAMLIAEgDzcDCCADQf8BcUEERg0CCyAQQiCIpyECIBBCCIinIgUhAQJAAkACQAJAIANB/wFxIgZBAWsOAwEAAAILIAItAAghAQsgAUH/AXFBJUYNAQsgBCACNgIwIARBgYCAgHg2AiggBCAFQQh0IAZyNgIsDAMLIARBHjYCRCAEQYWexwA2AkAgBCAEQUBrrUKAgICAIIQ3AzggBEIBNwKcASAEQQE2ApQBIARBuJ7HADYCkAEgBCAEQThqNgKYASAEQShqIARBkAFqEOwDIANB/wFxQQNHDQIgAigCACEBIAJBBGooAgAiAygCACIFBEAgASAFEQMACyADKAIEIgUEQCABIAUgAygCCBCiBwsgAkEMQQQQogcMAgsgASAOQh58IhA3AwggASgCACAOIA8gDiAPVBunaiICKAAAQdCWjSBGDQILIARBMGpB5J7HACgCADYCACAEQdyexwApAgA3AygLIAQgBCkAKTcAHSAEIAQtACg6ABwgBCAELQAzOgAnIAQgBC8AMTsAJSAEKAIcIQEgACAEKQIgNwIMIAAgATYCCCAAQgM3AwAMBQsgAjMAHCEOIAIzABohDyAEQgE3A5ABIAQgDiAPIBB8fCIONwOYASADQeAAaiAEQZABahDIBgsgASAONwMIIAQgAykDQCIONwMQIAQgDjcDCAJAIAMvAYQBIglBAkYEf0GDgICAeAUgAy8BIEUNAUGFgICAeAshCCAAQSA2AhAgAEHgnMcANgIMIAAgCDYCCCAAQgM3AwAMBAsgBCkCDCEPIAMoAogBIQpBgMAAEHEiCEUNAiAOQiCIpyECIA6nIQUgD0IgiKchBiAPpyEHAn4gCUUEQP0MAAAAAAAgAAAAAAAAAAAAACAI/RwAIREgBf0RIAf9HAEgBv0cAiAC/RwDIRJBACEHQgIhD0IADAELIAQgATYCoAEgBCACNgKcASAEIAY2ApgBIAQgBzYClAEgBCAFNgKQASAEQbgBahCZBCAEQdAAaiAEQeABav0AAwD9CwMAIARB4ABqIARB8AFq/QADAP0LAwAgBEHwAGogBEGAAmr9AAMA/QsDACAEIAT9AAPIAf0LA4ABIAQgBCkD2AE3A0ggBCgCxAEhBSAEKALAASEBIAT9AASwASESIAQoAqQBIQYgBCgCoAEhByAE/QAEkAEhEUIAIQ8gBCkDqAELIQ5BuAEQcSICRQ0CIAIgBTYCVCACIAE2AlAgAiAS/QsDQCACIA43AzggAiAGNgI0IAIgBzYCMCACIBH9CwMgIAIgDzcDGCACQgA3AgwgAkKAwAA3AgQgAiAINgIAIAIgBP0AA4AB/QsDWCACIAQpA0g3A2ggAkHwAGogBEHQAGr9AAMA/QsDACACQYABaiAEQeAAav0AAwD9CwMAIAJBkAFqIARB8ABq/QADAP0LAwAgAkEBOgC0ASACIAo2ArABIAJBADYCqAEgAkIANwOgASAAQgI3AwAgACADNgIIIABBAjYCqAEgACACNgKsAQwDCyAAQgM3AwAgAEGEgICAeDYCCAwCCyAAQSE2AhAgAEHknccANgIMIABBg4CAgHg2AgggAEIDNwMADAELAAsgBEGQAmokAAv2CQENfyMAQSBrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAIAEoAihBAkcEQCABKALkAUE4bCECIAEoAuABQRhqIQMDQCADIQEgAkUNBCACQThrIQIgAUE4aiEDQcTNxwBBESABQQRrKAIAIAEoAgAQrANFDQALIAFBGGsiASgCGCIIQQBIDQEgASgCFCEDAkAgCEUEQEEBIQwMAQsgCBBxIgxFDQgLIAgEQCAMIAMgCPwKAAALIAEoAiQiCUEASA0IIAEoAiAhAwJAIAlFBEBBASENDAELIAkQcSINRQ0ICyAJBEAgDSADIAn8CgAACyABKAIwIgpBAEgNCCABKAIsIQMCQCAKRQRAQQEhDgwBCyAKEHEiDkUNCAsgCgRAIA4gAyAK/AoAAAsgASgCAEEBRgRAIAEoAgwiA0EASA0JIAEoAgghAQJAIANFBEBBASEGDAELIAMQcSIGRQ0JCyADBEAgBiABIAP8CgAACyADIQEMBQsgASgCDCICQQBIDQIgASgCCCEBAkAgAkUEQEEBIQcMAQsgAhBxIgdFDQgLIAIEQCAHIAEgAvwKAAALIAVBEGogByACQYCAgAEQ3wEgBSgCFCEDAkACQCAFKAIQQQFGBEAgA0GAgICAeEcNAUEDIQEMAgsgBUEQaiAFKAIYIgYgBSgCHCIBEPsCIAUoAhBBAUYEQEEAIQEgA0UNAiAGQQRrKAIAIgRBeHEiC0EEQQggBEEDcSIEGyADakkNDCAEQQAgCyADQSdqSxsNDSAGEKICDAILIAIEQCAHQQRrKAIAIgRBeHEiC0EEQQggBEEDcSIEGyACakkNDCAEQQAgCyACQSdqSxsNDSAHEKICCyABQQBODQYMCgsgAwRAIAUoAhgiAUEEaygCACIGQXhxIgRBBEEIIAZBA3EiBhsgA2pJDQsgBkEAIAQgA0EnaksbDQwgARCiAgtBBCEBCyAFIAE6AAEgBUEeOgAAIAAgBRD8AwwFC0GsmMcAEN0JAAtBpO/BABD/BwwFC0HYmsgAEP8HAAsgAEKGgICAgICAgIB/NwMADAILAkAgAUUEQEEBIQcgAUUiAkUEQEEBIAYgAfwKAAALIAINAUEBQQEgAfwKAAAMAQsgARBxIgJFDQMgAUUiBEUEQCACIAYgAfwKAAALIAEQcSIHRQ0DIARFBEAgByACIAH8CgAACyACQQRrKAIAIgRBeHEiC0EEQQggBEEDcSIEGyABakkNBSAEQQAgCyABQSdqSxsNBiACEKICCyAAIAE2AgwgACAHNgIIIAAgATYCBCAAQQY2AgAgBiEHIAMhAgsgCARAIAxBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIAhqSQ0EIABBACABIAhBJ2pLGw0FIAwQogILIAkEQCANQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyAJakkNBCAAQQAgASAJQSdqSxsNBSANEKICCyAKBEAgDkEEaygCACIAQXhxIgFBBEEIIABBA3EiABsgCmpJDQQgAEEAIAEgCkEnaksbDQUgDhCiAgsgAkUNACAHQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyACakkNAyAAQQAgASACQSdqSxsNBCAHEKICCyAFQSBqJAAPCwALQaTvwQAQ/wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvaCgMTfwJ+AXsjAEHQAmsiDyQAQoCAgICAgICAwAAgAa0iGIAiGSAYfkKAgICAgICAgMAAUq0CfyABQYEgTwRAQQEgAUEBcmdBH3MiBUEBdiAFQQFxaiIFdCABIAV2akEBdgwBC0HAACABIAFBAXZrIgUgBUHAAE8bCyERIBl8IRkgAEEEayEWIABBEGshFyAAQQhqIRRBASEJA0BBASEKQQAhEiABIAxLBEAgACAMQQJ0IhBqIQ0gDK0iGAJ/AkAgASAMayIKIBFJDQACQCAKQQJJBEAgCiEGDAELAkACQAJAAkACQCANKAIEIgUgDSgCAEkiDkUEQEECIQYgCkECRg0GIBQgDEECdGohCANAIAUgCCgCACIFSw0DIAhBBGohCCAKIAZBAWoiBkcNAAsMAQsgCkECRg0CQQIhBiAUIAxBAnRqIQgDQCAFIAgoAgAiBU0NAiAIQQRqIQggCiAGQQFqIgZHDQALCyAKIQYLIAYgEUkNBCAORQ0DIAZBAk8NAUEBIQYMAwsgDUEIaiEKQQAhCEEBIQ5BAiEGDAELIAZBAXYhDiANIAZBAnQiBWohCkEAIQggBkEISQ0AIBcgBSAQamohByAOQfz///8HcSIIIQUDQCANIAf9AAIAIA39AAIAIhr9DQwNDg8ICQoLBAUGBwABAgP9CwIAIAcgGiAa/Q0MDQ4PCAkKCwQFBgcAAQID/QsCACAHQRBrIQcgDUEQaiENIAVBBGsiBQ0ACyAIIA5GDQELIAAgCEECdCIFIBBqaiEHIA4gCGshCCAKIAVrQQRrIQUDQCAHKAIAIQogByAFKAIANgIAIAUgCjYCACAFQQRrIQUgB0EEaiEHIAhBAWsiCA0ACwsgBkEBdEEBcgwBCyAKIBEgCiARSRtBAXQgBEUNABogDUEgIAogCkEgTxsiBSACIANBAEEAEJUBIAVBAXRBAXILIgpBAXYgDGqtfCAZfiAMIAlBAXZrrSAYfCAZfoV5pyESCwJAAkAgC0ECSQ0AIBYgDEECdCIFaiEOIAAgBWohDQNAIAtBAWsiECAPQY4CamotAAAgEkkNAQJ/AkACQCADIA9BBGogEEECdGooAgAiBUEBdiIHIAlBAXYiBmoiE08gBSAJckEBcUVxRQRAIAAgDCATa0ECdGohCyAFQQFxRQ0BDAILIBNBAXQMAgsgCyAHIAIgAyAHQQFyZ0EBdEE+c0EAEJUBCyAJQQFxRQRAIAsgB0ECdGogBiACIAMgBkEBcmdBAXRBPnNBABCVAQsCQCAJQQJJIAVBAklyDQAgAyAGIAcgBiAHSSIGGyIFSQ0AIAsgB0ECdGohCSAFQQJ0IgUEQCACIAkgCyAGGyAF/AoAAAsgAiAFaiEHAkAgBkUEQCACIQUDQCALIAkoAgAiFSAFKAIAIgggCCAVSyIGGzYCACALQQRqIQsgBSAIIBVNQQJ0aiIFIAdGDQIgCSAGQQJ0aiIJIA1HDQALDAELIA4hBgNAAkAgBiAHQQRrIgcoAgAiCCAJQQRrIgUoAgAiCSAIIAlLGzYCACAHIAggCUlBAnRqIQcgBSAIIAlPQQJ0aiIJIAtGDQAgBkEEayEGIAIgB0cNAQsLIAkhCyACIQULIAcgBWsiBkUNACALIAUgBvwKAAALIBNBAXRBAXILIQlBASEHIBAiC0EBSw0ACwwBCyALIQcLIA9BjgJqIAdqIBI6AAAgD0EEaiAHQQJ0aiAJNgIAIAEgDEsEQCAHQQFqIQsgCkEBdiAMaiEMIAohCQwBCwsgCUEBcUUEQCAAIAEgAiADIAFBAXJnQQF0QT5zQQAQlQELIA9B0AJqJAAL4wsBA38gACAAKQMAIAKtfDcDACAAKAIIQX9zIQQgAkHAAE8EQANAIAFBM2otAAAgAUEjai0AACABQRNqLQAAIAEtAAAgBEH/AXFzQQJ0KAKYhUQgAUEBai0AACAEQQh2Qf8BcXNBAnQoApj9QyABQQJqLQAAIARBEHZB/wFxc0ECdCgCmPVDIAFBA2otAAAgBEEYdnNBAnQoApjtQyABQQRqLQAAQQJ0KAKY5UMgAUEFai0AAEECdCgCmN1DIAFBBmotAABBAnQoApjVQyABQQdqLQAAQQJ0KAKYzUMgAUEIai0AAEECdCgCmMVDIAFBCWotAABBAnQoApi9QyABQQpqLQAAQQJ0KAKYtUMgAUELai0AAEECdCgCmK1DIAFBDGotAABBAnQoApilQyABQQ1qLQAAQQJ0KAKYnUMgAUEPai0AAEECdCgCmI1DIAFBDmotAABBAnQoApiVQ3Nzc3Nzc3Nzc3Nzc3NzcyIDQRh2c0ECdCgCmO1DIAFBFGotAABBAnQoApjlQyABQRVqLQAAQQJ0KAKY3UMgAUEWai0AAEECdCgCmNVDIAFBF2otAABBAnQoApjNQyABQRhqLQAAQQJ0KAKYxUMgAUEZai0AAEECdCgCmL1DIAFBGmotAABBAnQoApi1QyABQRtqLQAAQQJ0KAKYrUMgAUEcai0AAEECdCgCmKVDIAFBHWotAABBAnQoApidQyABQR9qLQAAQQJ0KAKYjUMgAUEeai0AAEECdCgCmJVDc3Nzc3Nzc3Nzc3NzIAFBEmotAAAgA0EQdkH/AXFzQQJ0KAKY9UNzIAFBEWotAAAgA0EIdkH/AXFzQQJ0KAKY/UNzIAFBEGotAAAgA0H/AXFzQQJ0KAKYhURzIgNBGHZzQQJ0KAKY7UMgAUEkai0AAEECdCgCmOVDIAFBJWotAABBAnQoApjdQyABQSZqLQAAQQJ0KAKY1UMgAUEnai0AAEECdCgCmM1DIAFBKGotAABBAnQoApjFQyABQSlqLQAAQQJ0KAKYvUMgAUEqai0AAEECdCgCmLVDIAFBK2otAABBAnQoApitQyABQSxqLQAAQQJ0KAKYpUMgAUEtai0AAEECdCgCmJ1DIAFBL2otAABBAnQoApiNQyABQS5qLQAAQQJ0KAKYlUNzc3Nzc3Nzc3Nzc3MgAUEiai0AACADQRB2Qf8BcXNBAnQoApj1Q3MgAUEhai0AACADQQh2Qf8BcXNBAnQoApj9Q3MgAUEgai0AACADQf8BcXNBAnQoApiFRHMiA0EYdnNBAnQoApjtQyABQTRqLQAAQQJ0KAKY5UMgAUE1ai0AAEECdCgCmN1DIAFBNmotAABBAnQoApjVQyABQTdqLQAAQQJ0KAKYzUMgAUE4ai0AAEECdCgCmMVDIAFBOWotAABBAnQoApi9QyABQTpqLQAAQQJ0KAKYtUMgAUE7ai0AAEECdCgCmK1DIAFBPGotAABBAnQoApilQyABQT1qLQAAQQJ0KAKYnUMgAUE+ai0AAEECdCgCmJVDIAFBP2otAABBAnQoApiNQ3Nzc3Nzc3Nzc3NzcyABQTJqLQAAIANBEHZB/wFxc0ECdCgCmPVDcyABQTFqLQAAIANBCHZB/wFxc0ECdCgCmP1DcyABQTBqLQAAIANB/wFxc0ECdCgCmIVEcyEEIAFBQGshASACQUBqIgJBP0sNAAsLAkAgAkUNAAJAIAJBA3EiBUUEQCABIQMMAQsgASEDA0AgAy0AACAEc0H/AXFBAnQoApiNQyAEQQh2cyEEIANBAWohAyAFQQFrIgUNAAsLIAJBBEkNACABIAJqIQEDQCADLQAAIARzQf8BcUECdCgCmI1DIARBCHZzIgIgA0EBai0AAHNB/wFxQQJ0KAKYjUMgAkEIdnMiAiADQQJqLQAAc0H/AXFBAnQoApiNQyACQQh2cyICIANBA2otAABzQf8BcUECdCgCmI1DIAJBCHZzIQQgA0EEaiIDIAFHDQALCyAAIARBf3M2AggLjQoBB38jAEHAB2siBCQAAkACQAJAQYCAARBxIgVFDQAgBUEAQYCAAfwLAEGAEBBxIgZFDQAgBkEAQYAQ/AsAIARBpAdqQQA7AQAgBEEANgKgByAEQQA2ApQHIARBADYCiAcgBEEAOgCEByAEQQA2AoAHIAQgBjYC/AYgBCAFNgL4BiAEQgI3A/AGIARCADcD6AYgBEKAgICAIDcD4AYgBEEAQdgG/AsAIARBADoApgcgBEEBNgLcBiAEQSQ2AtgGQYAIIAMgA0GACE8bIQVBASEIAkAgA0UNACAFEHEiCEUNASAIQQRrLQAAQQNxRSAFRXINACAIQQAgBfwLAAsgBCAFNgKwByAEIAg2AqwHIAQgBTYCqAcCQAJAA0AgBEG0B2ogBCABIAlqIAIgCWsgCCAFIAdBARBCIAQtALQHBEAgACAELQC1BzoACCAAQoGAgICAgICAgH83AgAgBCgCqAciAARAIAhBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIABqSQ0GIAFBACACIABBJ2pLGw0HIAgQogILIAQoAvgGIgFBBGsoAgAiAEF4cUGEgAFBiIABIABBA3EiAhtJDQUgAkEAIABBqIABTxsNBiABEKICIAQoAuAGIgAEQCAEKALkBiIBQQRrKAIAIgJBeHEiAyAAQQF0IgBBBEEIIAJBA3EiAhtqSQ0GIAJBACADIABBJ2pLGw0HIAEQogILIAQoAvwGIgFBBGsoAgAiAEF4cUGEEEGIECAAQQNxIgIbSQ0FIAJBACAAQagQTxsNBgwDCyAELQCjByIGQQdHIAQoArwHIAdqIgcgA0dxRQRAIAUgB0kEQCAHIAVrIgEgBCgCqAcgBWtLBEAgBEGoB2ogBSABQQFBARCkBSAEKAKwByEFCyAEKAKsByICIAVqIQcgAUECTwR/IAFBAWsiAQRAIAdBACAB/AsACyACIAEgBWoiBWoFIAcLQQA6AAAgBUEBaiEHIAQtAKMHIQYLIAAgBCkCqAc3AgQgAEEMaiAHNgIAIAAgBkH/AXFBB0c2AgAgBCgC+AYiAUEEaygCACIAQXhxQYSAAUGIgAEgAEEDcSICG08NAkHMjMgAQS5B/IzIABDrBwALIAQoArgHIAlqIQkgBAJ/IAUgAyAHQYCAAmoiBiADIAZJGyIGTwRAIAYMAQsgBiAFayIKIAQoAqgHIAVrSwRAIARBqAdqIAUgCkEBQQEQpAUgBCgCrAchCCAEKAKwByEFCyAFIAhqIQYgCkECTwR/IApBAWsiCgRAIAZBACAK/AsACyAIIAUgCmoiBWoFIAYLQQA6AAAgBUEBagsiBTYCsAcgAiAJTw0ACyAJIAIgAkHAscQAEOoHAAsgAkEAIABBqIABTxsNAyABEKICIAQoAuAGIgAEQCAEKALkBiIBQQRrKAIAIgJBeHEiAyAAQQF0IgBBBEEIIAJBA3EiAhtqSQ0DIAJBACADIABBJ2pLGw0EIAEQogILIAQoAvwGIgFBBGsoAgAiAEF4cUGEEEGIECAAQQNxIgIbSQ0CIAJBACAAQagQTxsNAwsgARCiAiAEKALsBiIABEAgBCgC8AYiAUEEaygCACICQXhxIgMgAEEBdCIAQQRBCCACQQNxIgIbakkNAiACQQAgAyAAQSdqSxsNAyABEKICCyAEQcAHaiQADwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvQDAEHfyMAQUBqIgQkACABKAIMIQUCQAJAAkACQAJAAkAgASgCFCICIAEoAhAiA0kEQANAIAIgBWotAAAiB0EJayIGQRlLDQNBASAGdEGTgIAEcUUEQCAGQRlHDQQgBEE4aiABEKIDIAQtADhBAUcNAyAAIAQoAjw2AgQgAEEBOgAADAgLIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECCyAEQQhqIAUgAyACQQFqIgEgAyABIANJGxD5ASAEKAIMIQIgBCgCCCEDQRQQcSIBRQ0CIAEgAzYCDCABQQU2AgAgACABNgIEIABBAToAACABIAI2AhAMBQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQtADlBAWsODQECAwQFBgcICQoLDA0ACyAAQQA6AAEgAEEAOgAADBELIABBAToAASAAQQA6AAAMEAsgAEECOgABIABBADoAAAwPCyAAQQM6AAEgAEEAOgAADA4LIABBBDoAASAAQQA6AAAMDQsgAEEFOgABIABBADoAAAwMCyAAQQY6AAEgAEEAOgAADAsLIABBBzoAASAAQQA6AAAMCgsgAEEIOgABIABBADoAAAwJCyAAQQk6AAEgAEEAOgAADAgLIABBCjoAASAAQQA6AAAMBwsgAEELOgABIABBADoAAAwGCyAAQQw6AAEgAEEAOgAADAULIABBDToAASAAQQA6AAAMBAsCQCAHQfsARgRAIAEgAS0AGEEBayIGOgAYIAJBAWohAiAGQf8BcQ0BIARBEGogBSADIAIgAyACIANJGxD5ASAEKAIUIQIgBCgCECEDQRQQcSIBRQ0CIAEgAzYCDCABQRg2AgAgACABNgIEIABBAToAACABIAI2AhAMBQsgBCAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCBCECIAQoAgAhA0EUEHEiAUUNASABIAM2AgwgAUEKNgIAIAAgATYCBCAAQQE6AAAgASACNgIQDAQLIAEgAjYCFCAEQThqIAEQogMgBC0AOEEBRgRAIAQoAjwhAgwCCyABKAIMIQUCQAJAIAEoAhQiAiABKAIQIgNJBEAgBC0AOSEGA0ACQCACIAVqLQAAQQlrDjIAAAMDAAMDAwMDAwMDAwMDAwMDAwMDAwADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBAMLIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECCyAEQSBqIAUgAyACQQFqIgIgAyACIANJGxD5ASAEKAIkIQMgBCgCICEFQRQQcSICRQ0CIAIgBTYCDCACQQM2AgAgAiADNgIQDAMLIARBGGogBSADIAJBAWoiAiADIAIgA0kbEPkBIAQoAhwhAyAEKAIYIQVBFBBxIgJFDQEgAiAFNgIMIAJBBjYCACACIAM2AhAMAgsgASACQQFqNgIUIAEQhwQhAiABIAEtABhBAWo6ABgCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkEBaw4NAAECAwQFBgcICQoLDA0LQQFBgAIgAhsMDQtBAUGABCACGwwMC0EBQYAGIAIbDAsLQQFBgAggAhsMCgtBAUGACiACGwwJC0EBQYAMIAIbDAgLQQFBgA4gAhsMBwtBAUGAECACGwwGC0EBQYASIAIbDAULQQFBgBQgAhsMBAtBAUGAFiACGwwDC0EBQYAYIAIbDAILQQFBgBogAhsMAQsgAkEARwsiBUEBcQ0CIAEoAgwhBgJAIAEoAhQiAiABKAIQIgNJBEAgBUEIdiEFA0AgAiAGai0AACIHQQlrIghBF0tBASAIdEGTgIAEcUVyDQIgASACQQFqIgI2AhQgAiADRw0ACyADIQILIARBMGogBiADIAIQ+QEgBCgCNCECIAQoAjAhA0EUEHEiAUUNASABIAM2AgwgAUEDNgIAIAAgATYCBCAAQQE6AAAgASACNgIQDAQLIAdB/QBGBEAgACAFOgABIABBADoAACABIAJBAWo2AhQMBAsgBEEoaiAGIAMgAhD5ASAEKAIsIQIgBCgCKCEDQRQQcSIBRQ0AIAEgAzYCDCABQQo2AgAgACABNgIEIABBAToAACABIAI2AhAMAwsAC0EBIQUgASABLQAYQQFqOgAYCyAAIAI2AgQgACAFNgIACyAEQUBrJAALkAsDCn8CewF+QQEhDUEBIQkCQAJAAkACQAJAAkACQAJAIARBAUcEQEEBIQZBASEHA0AgBSAKaiIJIARPDQIgByEIAkAgAyAGai0AACIGIAMgCWotAAAiCUkEQCAFIAdqQQFqIgcgCmshDUEAIQUMAQsgBiAJRwRAQQEhDSAIQQFqIQdBACEFIAghCgwBC0EAIAVBAWoiByAHIA1GIgYbIQUgB0EAIAYbIAhqIQcLIAUgB2oiBiAESQ0AC0EBIQZBASEHQQAhBUEBIQkDQCAFIAtqIgwgBE8NAyAHIQgCQCADIAZqLQAAIgYgAyAMai0AACIMSwRAIAUgB2pBAWoiByALayEJQQAhBQwBCyAGIAxHBEBBASEJIAhBAWohB0EAIQUgCCELDAELQQAgBUEBaiIHIAcgCUYiBhshBSAHQQAgBhsgCGohBwsgBSAHaiIGIARJDQALCyAEIAogCyAKIAtLIgcbIgtJDQIgDSAJIAcbIgcgC2oiBSAHSSAEIAVJcg0DAn8gAyADIAdqIAsQ2wcEQAJAAkAgBEECSQRAQQAhCAwBCyADIQUgBEEecSIIIQcDQEIBIAUvAAD9EP0MPz8/Pz8/Pz8/Pz8/Pz8/P/1O/YkB/akB/ckBIhD9HQCG/RJCASAQ/R0Bhv0eASAP/VAhDyAFQQJqIQUgB0ECayIHDQALIA8gDyAP/Q0ICQoLDA0ODwABAgMEBQYH/VD9HQAhESAEIAhGDQELIAMgCGohBSAEIAhrIQcDQEIBIAUxAACGIBGEIREgBUEBaiEFIAdBAWsiBw0ACwsgBCALayIHIAsgByALSxtBAWohB0F/IQUgCyEKQX8MAQtBASEKQQAhBUEBIQZBACENA0AgBCAGIgggBWoiDEsEQCAEIAVrIAZBf3NqIgYgBE8NByAEIAVBf3NqIA1rIgkgBE8NCAJAIAMgBmotAAAiBiADIAlqLQAAIglJBEAgDEEBaiIGIA1rIQpBACEFDAELIAYgCUcEQCAIQQFqIQZBACEFQQEhCiAIIQ0MAQtBACAFQQFqIgYgBiAKRiIJGyEFIAZBACAJGyAIaiEGCyAHIApHDQELC0EBIQpBACEFQQEhBkEAIQkDQCAEIAYiCCAFaiIOSwRAIAQgBWsgBkF/c2oiBiAETw0JIAQgBUF/c2ogCWsiDCAETw0KAkAgAyAGai0AACIGIAMgDGotAAAiDEsEQCAOQQFqIgYgCWshCkEAIQUMAQsgBiAMRwRAIAhBAWohBkEAIQVBASEKIAghCQwBC0EAIAVBAWoiBiAGIApGIgwbIQUgBkEAIAwbIAhqIQYLIAcgCkcNAQsLIAQgCSANIAkgDUsbayEKQQAhBQJ/AkACQAJAAkAgBw4CAAIBCyAHDAMLIAMhCCAHQX5xIgUhBgNAQgEgCC8AAP0Q/Qw/Pz8/Pz8/Pz8/Pz8/Pz8//U79iQH9qQH9yQEiEP0dAIb9EkIBIBD9HQGG/R4BIA/9UCEPIAhBAmohCCAGQQJrIgYNAAsgDyAPIA/9DQgJCgsMDQ4PAAECAwQFBgf9UP0dACERIAUgB0YNAQsDQEIBIAMgBWoxAACGIBGEIREgByAFQQFqIgVHDQALC0EACyEFIAQLIQggACAENgI8IAAgAzYCOCAAIAI2AjQgACABNgIwIAAgCDYCKCAAIAU2AiQgACACNgIgIABBADYCHCAAIAc2AhggACAKNgIUIAAgCzYCECAAIBE3AwggAEEBNgIADwsgCSAEQdSawgAQjAcACyAMIARB1JrCABCMBwALQQAgCyAEQZSbwgAQ6gcACyAHIAUgBEGEm8IAEOoHAAsgBiAEQeSawgAQjAcACyAJIARB9JrCABCMBwALIAYgBEHkmsIAEIwHAAsgDCAEQfSawgAQjAcAC9wLBBV/AX4BfQF7IwBB0ABrIgQkACAEIAI2AgggBCABNgIEAkAgAygCBCIPIAJBA2wiBU8EQCACIAMoAgwiDU0EQCAFIAMoAhQiEE0EQCAFIAMoAhwiEU0EQCADKAIkIhIgAkECdCIFTwRAAkAgACgCCCITIAEgAmpPBEAgAg0BQQAhBQwHCyAEIBM2AiwgBEEDNgIUIARB+MnHADYCECAEQgM3AhwgBEKAgICAECIZIARBLGqthDcDQCAEIBkgBEEIaq2ENwM4IAQgGSAEQQRqrYQ3AzAgBCAEQTBqNgIYIARBEGpBkMrHABCNCAALIAAoAgQgAUEkbGohAiADKAIgIRQgAygCGCEVIAMoAhAhFiADKAIIIRcgAygCACEYAkACQANAAkACQAJAAkAgEyABIA5qIgVLBEAgCEEDaiIFIA9LDQEgAkEQaiAMIBhqIgZBCGogBv1dAgD9VgIAAiIb/VoCAAIgAkEIaiAb/VsCAAAgDSAORg0DIAsgF2ooAgAiCkH///8DcSEJIApBgICAgHhxIQYgCkGAgID8B3EiB0GAgID8B0YEQCAJQQ12IAZBEHZyQYAEQQAgCRtyQYD4AXIhBgwFCyAGQRB2IQYgB0GAgIC4BEsNAiAHQYCAgMQDTwRAIApBDHYgCkH/3wBxQQBHcSAHQQ12IAlBDXZqQYCAAWogBnJqIQYMBQsgB0GAgICYA0kNBCAJQYCAgARyIgpB/gAgB0EXdiIJa3YhByAKQR0gCWsiCXZBAXEEfyAHQQMgCXRBAWsgCnFBAEdqBSAHCyAGciEGDAQLIAUgE0HkwMcAEIwHAAsgCCAFIA9B4MrHABDqBwALIAZBgPgBciEGDAELIA0gDUGgyscAEIwHAAsgAkEUaiAGOwEAIAUgEEsNASAEIAwgFmoiBv1dAgAgBkEIaioCACIa/SACIBr9IAP9CwQwIAIgBEEwaiIHEOUCIAUgEUsNAiAEIAwgFWoiCP1dAgAgCEEIaioCACIa/SACIBr9IAP9CwQwIAIgBxDdAiASIAtBA2pLBEAgBCAU/QACAP0LBDAgDEEMaiEMIBRBEGohFCALQQRqIQsgAiAHEJACIAJBJGohAiAFIQggDkEBaiIOIAQoAggiBU8NCQwBCwsgCyALQQRqIBJBsMrHABDqBwALIAggBSAQQdDKxwAQ6gcACyAIIAUgEUHAyscAEOoHAAsgBCASNgIMIAQgBTYCLCAEQQI2AjQgBEG0yccANgIwIARCAjcCPCAEQoCAgIAQIhkgBEEsaq2ENwMYIAQgGSAEQQxqrYQ3AxAgBCAEQRBqNgI4IARBMGpBxMnHABCNCAALIAQgETYCDCAEIAU2AiwgBEECNgI0IARB/MjHADYCMCAEQgI3AjwgBEKAgICAECIZIARBLGqthDcDGCAEIBkgBEEMaq2ENwMQIAQgBEEQajYCOCAEQTBqQYzJxwAQjQgACyAEIBA2AgwgBCAFNgIsIARBAjYCNCAEQcTIxwA2AjAgBEICNwI8IARCgICAgBAiGSAEQSxqrYQ3AxggBCAZIARBDGqthDcDECAEIARBEGo2AjggBEEwakHUyMcAEI0IAAsgBCANNgIsIARBAjYCNCAEQYzIxwA2AjAgBEICNwI8IARCgICAgBAiGSAEQQhqrYQ3AxggBCAZIARBLGqthDcDECAEIARBEGo2AjggBEEwakGcyMcAEI0IAAsgBCAPNgIMIAQgBTYCLCAEQQI2AjQgBEHQx8cANgIwIARCAjcCPCAEQoCAgIAQIhkgBEEsaq2ENwMYIAQgGSAEQQxqrYQ3AxAgBCAEQRBqNgI4IARBMGpB4MfHABCNCAALIAAgASAFIAMoAiggAygCLCADKAIwIAMoAjQgAygCOCADKAI8ENsDAkAgAygCRCICRQ0AIAMoAkwiCEUNACAAKAIQIgYgACgCFCIAIAEgBSADKAJIIAgQjgMgBiAAIAEgBSADKAJAIAIQtAMLIARB0ABqJAALqwwCDH0EfwJAAkACQAJAAkAgBARAQwAA/kIgBZUhBQNAIBJBD2oiFSADSyAUQZCixIgBS3INA0MAAP5CQwAA/sIgBSACQTBqKgIAlCIHIAdDAAD+wl0bIgcgB0MAAP5CXhsQuQchB0MAAP5CQwAA/sIgBSACQTRqKgIAlCIIIAhDAAD+wl0bIgggCEMAAP5CXhsQuQchCEMAAP5CQwAA/sIgBSACQThqKgIAlCIJIAlDAAD+wl0bIgkgCUMAAP5CXhsQuQchCUMAAP5CQwAA/sIgBSACQSBqKgIAlCIKIApDAAD+wl0bIgogCkMAAP5CXhsQuQchCkMAAP5CQwAA/sIgBSACQSRqKgIAlCILIAtDAAD+wl0bIgsgC0MAAP5CXhsQuQchC0MAAP5CQwAA/sIgBSACQShqKgIAlCIMIAxDAAD+wl0bIgwgDEMAAP5CXhsQuQchDEMAAP5CQwAA/sIgBSACQSxqKgIAlCINIA1DAAD+wl0bIg0gDUMAAP5CXhsQuQchDUMAAP5CQwAA/sIgBSACQRBqKgIAlCIOIA5DAAD+wl0bIg4gDkMAAP5CXhsQuQchDkMAAP5CQwAA/sIgBSACQRRqKgIAlCIPIA9DAAD+wl0bIg8gD0MAAP5CXhsQuQchD0MAAP5CQwAA/sIgBSACQRhqKgIAlCIQIBBDAAD+wl0bIhAgEEMAAP5CXhsQuQchEEMAAP5CQwAA/sIgBSACQRxqKgIAlCIRIBFDAAD+wl0bIhEgEUMAAP5CXhsQuQchESABIBNNDQQgAEH/AEMAAP5CQwAA/sIgBSACKgIAlCIGIAZDAAD+wl0bIgYgBkMAAP5CXhsQuQciBvwAQYB/IAZDAAAAw2AbIAZDAAD+Ql4bQQAgBiAGWxtB/wFxQf8AQwAA/kJDAAD+wiAFIAJBBGoqAgCUIgYgBkMAAP7CXRsiBiAGQwAA/kJeGxC5ByIG/ABBgH8gBkMAAADDYBsgBkMAAP5CXhtBACAGIAZbG0H/AXFBCHRyQf8AQwAA/kJDAAD+wiAFIAJBCGoqAgCUIgYgBkMAAP7CXRsiBiAGQwAA/kJeGxC5ByIG/ABBgH8gBkMAAADDYBsgBkMAAP5CXhtBACAGIAZbG0H/AXFBEHRyQf8AQwAA/kJDAAD+wiAFIAJBDGoqAgCUIgYgBkMAAP7CXRsiBiAGQwAA/kJeGxC5ByIG/ABBgH8gBkMAAADDYBsgBkMAAP5CXhtBACAGIAZbG0EYdHI2AgAgE0EBaiISIAFPDQUgAEEEakH/ACAO/ABBgH8gDkMAAADDYBsgDkMAAP5CXhtBACAOIA5bG0H/AXFB/wAgD/wAQYB/IA9DAAAAw2AbIA9DAAD+Ql4bQQAgDyAPWxtB/wFxQQh0ckH/ACAQ/ABBgH8gEEMAAADDYBsgEEMAAP5CXhtBACAQIBBbG0H/AXFBEHRyQf8AIBH8AEGAfyARQwAAAMNgGyARQwAA/kJeG0EAIBEgEVsbQRh0cjYCACATQQJqIhIgAU8NBiAAQQhqQf8AIAr8AEGAfyAKQwAAAMNgGyAKQwAA/kJeG0EAIAogClsbQf8BcUH/ACAL/ABBgH8gC0MAAADDYBsgC0MAAP5CXhtBACALIAtbG0H/AXFBCHRyQf8AIAz8AEGAfyAMQwAAAMNgGyAMQwAA/kJeG0EAIAwgDFsbQf8BcUEQdHJB/wAgDfwAQYB/IA1DAAAAw2AbIA1DAAD+Ql4bQQAgDSANWxtBGHRyNgIAIBNBA2oiEiABTw0CIABBDGpB/wAgB/wAQYB/IAdDAAAAw2AbIAdDAAD+Ql4bQQAgByAHWxtB/wFxQf8AIAj8AEGAfyAIQwAAAMNgGyAIQwAA/kJeG0EAIAggCFsbQf8BcUEIdHJB/wAgCfwAQYB/IAlDAAAAw2AbIAlDAAD+Ql4bQQAgCSAJWxtB/wFxQRB0cjYCACAAQRBqIQAgE0EEaiETIAJBPGohAiAVIRIgBCAUQQFqIhRHDQALCw8LIBIgAUHwzscAEIwHAAsgEiAVIANBgM/HABDqBwALIBMgAUHAzscAEIwHAAsgEiABQdDOxwAQjAcACyASIAFB4M7HABCMBwAL9AoCDH8FfSACIAFBAnRBBGsiBmohDCAAIAZqIQogACABQQF2Ig1BAnRqIgZBBGshCyADQQRqIQ4DQEMAAIA/IRACfwJAIAYoAgAiAyAOKAIAIgRBCGooAgAiBUkEQCAAKAIAIQkgBEEEaigCACIHIANBJGxqIgMQigQhEiADLwEUIgRB//8BcUUEQCAEQRB0DAMLIARB/wdxIQMgBEGAgAJxIQggBEGA+AFxIgRBgPgBRgRAIAhBEHQhBCAEQYCAgPwHciADRQ0DGiAEIANBDXRyQYCAgP4HcgwDCyAIQRB0IQggBEUNASAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogCHIMAgsgAyAFQdTAxwAQjAcACyAIQYCAgNgDciADZ0EQayIEQRd0ayADIARB//8DcUEIanRB////A3FyC74iEUMAAIA/XgRAIBEQxgVDVPgtQJRDAACAP5KRIRALQwAAgD8hEQJ/AkAgBSAJSwRAIAcgCUEkbGoiAxCKBCETIAMvARQiBEH//wFxRQRAIARBEHQMAwsgBEH/B3EhAyAEQYCAAnEhBSAEQYD4AXEiBEGA+AFGBEAgBUEQdCEEIARBgICA/AdyIANFDQMaIAQgA0ENdHJBgICA/gdyDAMLIAVBEHQhBSAERQ0BIARBDXRBgICA/ABxIANBDXRyQYCAgMADaiAFcgwCCyAJIAVB1MDHABCMBwALIAVBgICA2ANyIANnQRBrIgRBF3RrIAMgBEH//wNxQQhqdEH///8DcXILviIUQwAAgD9eBEAgFBDGBUNU+C1AlEMAAIA/kpEhEQsgAiAGIAAgEiASkiAQlCIQIBBbIBAgEyATkiARlGBFcSIIGygCADYCAEMAAIA/IRACfwJAIAooAgAiAyAOKAIAIgRBCGooAgAiBUkEQCALKAIAIQkgBEEEaigCACIPIANBJGxqIgMQigQhEiADLwEUIgRB//8BcUUEQCAEQRB0DAMLIARB/wdxIQMgBEGAgAJxIQcgBEGA+AFxIgRBgPgBRgRAIAdBEHQhBCAEQYCAgPwHciADRQ0DGiAEIANBDXRyQYCAgP4HcgwDCyAHQRB0IQcgBEUNASAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2ogB3IMAgsgAyAFQdTAxwAQjAcACyAHQYCAgNgDciADZ0EQayIEQRd0ayADIARB//8DcUEIanRB////A3FyC74iEUMAAIA/XgRAIBEQxgVDVPgtQJRDAACAP5KRIRALQwAAgD8hEQJ/AkAgBSAJSwRAIAhFIQcgDyAJQSRsaiIDEIoEIRMgAy8BFCIEQf//AXFFBEAgBEEQdAwDCyAEQf8HcSEDIARBgIACcSEFIARBgPgBcSIEQYD4AUYEQCAFQRB0IQQgBEGAgID8B3IgA0UNAxogBCADQQ10ckGAgID+B3IMAwsgBUEQdCEFIARFDQEgBEENdEGAgID8AHEgA0ENdHJBgICAwANqIAVyDAILIAkgBUHUwMcAEIwHAAsgBUGAgIDYA3IgA2dBEGsiBEEXdGsgAyAEQf//A3FBCGp0Qf///wNxcgu+IhRDAACAP14EQCAUEMYFQ1T4LUCUQwAAgD+SkSERCyAIQQJ0IAZqIQYgB0ECdCAAaiEAIAJBBGohAiAMIAsgCiASIBKSIBCUIhAgEFsgECATIBOSIBGUYEVxIgMbKAIANgIAIAsgA0ECdCIDayELIAMgCmpBBGshCiAMQQRrIQwgDUEBayINDQALIAtBBGohAyABQQFxBH8gAiAAIAYgACADSSIBGygCADYCACAGIAAgA09BAnRqIQYgACABQQJ0agUgAAsgA0cgBiAKQQRqR3JFBEAPCxCACAALrgwBB38jAEFAaiIEJAAgASgCDCEFAkACQAJAAkACQAJAIAEoAhQiAiABKAIQIgNJBEADQCACIAVqLQAAIgdBCWsiBkEZSw0DQQEgBnRBk4CABHFFBEAgBkEZRw0EIARBOGogARCxAyAELQA4QQFHDQMgACAEKAI8NgIEIABBAToAAAwICyABIAJBAWoiAjYCFCACIANHDQALIAMhAgsgBEEIaiAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCDCECIAQoAgghA0EUEHEiAUUNAiABIAM2AgwgAUEFNgIAIAAgATYCBCAAQQE6AAAgASACNgIQDAULAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBC0AOUEBaw4MAQIDBAUGBwgJCgsMAAsgAEEAOgABIABBADoAAAwQCyAAQQE6AAEgAEEAOgAADA8LIABBAjoAASAAQQA6AAAMDgsgAEEDOgABIABBADoAAAwNCyAAQQQ6AAEgAEEAOgAADAwLIABBBToAASAAQQA6AAAMCwsgAEEGOgABIABBADoAAAwKCyAAQQc6AAEgAEEAOgAADAkLIABBCDoAASAAQQA6AAAMCAsgAEEJOgABIABBADoAAAwHCyAAQQo6AAEgAEEAOgAADAYLIABBCzoAASAAQQA6AAAMBQsgAEEMOgABIABBADoAAAwECwJAIAdB+wBGBEAgASABLQAYQQFrIgY6ABggAkEBaiECIAZB/wFxDQEgBEEQaiAFIAMgAiADIAIgA0kbEPkBIAQoAhQhAiAEKAIQIQNBFBBxIgFFDQIgASADNgIMIAFBGDYCACAAIAE2AgQgAEEBOgAAIAEgAjYCEAwFCyAEIAUgAyACQQFqIgEgAyABIANJGxD5ASAEKAIEIQIgBCgCACEDQRQQcSIBRQ0BIAEgAzYCDCABQQo2AgAgACABNgIEIABBAToAACABIAI2AhAMBAsgASACNgIUIARBOGogARCxAyAELQA4QQFGBEAgBCgCPCECDAILIAEoAgwhBQJAAkAgASgCFCICIAEoAhAiA0kEQCAELQA5IQYDQAJAIAIgBWotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMEAwsgASACQQFqIgI2AhQgAiADRw0ACyADIQILIARBIGogBSADIAJBAWoiAiADIAIgA0kbEPkBIAQoAiQhAyAEKAIgIQVBFBBxIgJFDQIgAiAFNgIMIAJBAzYCACACIAM2AhAMAwsgBEEYaiAFIAMgAkEBaiICIAMgAiADSRsQ+QEgBCgCHCEDIAQoAhghBUEUEHEiAkUNASACIAU2AgwgAkEGNgIAIAIgAzYCEAwCCyABIAJBAWo2AhQgARCHBCECIAEgAS0AGEEBajoAGAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBkEBaw4MAAECAwQFBgcICQoLDAtBAUGAAiACGwwMC0EBQYAEIAIbDAsLQQFBgAYgAhsMCgtBAUGACCACGwwJC0EBQYAKIAIbDAgLQQFBgAwgAhsMBwtBAUGADiACGwwGC0EBQYAQIAIbDAULQQFBgBIgAhsMBAtBAUGAFCACGwwDC0EBQYAWIAIbDAILQQFBgBggAhsMAQsgAkEARwsiBUEBcQ0CIAEoAgwhBgJAIAEoAhQiAiABKAIQIgNJBEAgBUEIdiEFA0AgAiAGai0AACIHQQlrIghBF0tBASAIdEGTgIAEcUVyDQIgASACQQFqIgI2AhQgAiADRw0ACyADIQILIARBMGogBiADIAIQ+QEgBCgCNCECIAQoAjAhA0EUEHEiAUUNASABIAM2AgwgAUEDNgIAIAAgATYCBCAAQQE6AAAgASACNgIQDAQLIAdB/QBGBEAgACAFOgABIABBADoAACABIAJBAWo2AhQMBAsgBEEoaiAGIAMgAhD5ASAEKAIsIQIgBCgCKCEDQRQQcSIBRQ0AIAEgAzYCDCABQQo2AgAgACABNgIEIABBAToAACABIAI2AhAMAwsAC0EBIQUgASABLQAYQQFqOgAYCyAAIAI2AgQgACAFNgIACyAEQUBrJAALuQsCCX8HfSMAQSBrIggkACAAEKMFIABBwAFqQQA6AAAgAEIANwK4ASACQQJ0IgYhBSAAKAJ8IgcgBkkEQCAGIAciBWsiCyAAKAJ0IAVrSwRAIABB9ABqIAUgC0EEQQQQpAUgACgCfCEFCyAAKAJ4Ig0gBUECdCIMaiEJIAtBAk8EQCAGIAdBf3NqQQJ0IgoEQCAJQQAgCvwLAAsgAkEEdCAHQQJ0ayANaiAMakEEayEJIAUgC2pBAWshBQsgCUEANgIAIAVBAWohBQsgACAFNgJ8AkACQAJAIAAoAgBBAUcNACAFIAZJDQIgACgCeCELAkAgAkUNACACQf////8DcSEJQQAhDCALIQcgAiENQQghBQJ/AkACQAJ/AkACQAJAA0ACQAJAAkAgBCAFQQhrSwRAIAVBB2sgBE8NASAFQQZrIARPDQIgCQ0DIAwgBkHou8EAEIwHAAsgBUEIawwKCyAFQQdrDAYLIAVBBmshBQwCC0MAAH9DIANBBGoqAgAiEYsiDkMAAIA/QwAA+EFDAAAAACADKgIAIhKLIg8gDiADQQhqKgIAIhOLIhQQ4AgQ4AgQngWOQwAAcEGSIg4gDkMAAAAAXRsiDiAOQwAA+EFeGxC5B/wAIgpBD2sQsAZDAAB/Q5UiDpUiECAQQwAAf0NeGxC5ByEQIAdDAAB/QyAPIA6VIg8gD0MAAH9DXhsQuQf8ASAKQRt0QYCAgAhBACASQwAAAABdG3JBgICAEEEAIBFDAAAAAF0bckGAgIAgQQAgE0MAAAAAXRtyciAQ/AFBCHRyQwAAf0MgFCAOlSIOIA5DAAB/Q14bELkH/AFBEHRyNgIAIAVBBWsgBE8NBiAFQQRrIARPDQMgBCAFQQNrSwRAQwAAf0MgA0EQaioCACIRiyIOQwAAgD9DAAD4QUMAAAAAIANBDGoqAgAiEosiDyAOIANBFGoqAgAiE4siFBDgCBDgCBCeBY5DAABwQZIiDiAOQwAAAABdGyIOIA5DAAD4QV4bELkH/AAiCkEPaxCwBkMAAH9DlSIOlSIQIBBDAAB/Q14bELkHIRAgB0EEakMAAH9DIA8gDpUiDyAPQwAAf0NeGxC5B/wBIApBG3RBgICACEEAIBJDAAAAAF0bckGAgIAQQQAgEUMAAAAAXRtyQYCAgCBBACATQwAAAABdG3JyIBD8AUEIdHJDAAB/QyAUIA6VIg4gDkMAAH9DXhsQuQf8AUEQdHI2AgAgBUECayAETw0GIAVBAWsgBE8NAyAEIAVNDQJDAAB/QyADQRxqKgIAIhGLIg5DAACAP0MAAPhBQwAAAAAgA0EYaioCACISiyIPIA4gA0EgaioCACITiyIUEOAIEOAIEJ4FjkMAAHBBkiIOIA5DAAAAAF0bIg4gDkMAAPhBXhsQuQf8ACIKQQ9rELAGQwAAf0OVIg6VIhAgEEMAAH9DXhsQuQchECAHQQhqQwAAf0MgDyAOlSIPIA9DAAB/Q14bELkH/AEgCkEbdEGAgIAIQQAgEkMAAAAAXRtyQYCAgBBBACARQwAAAABdG3JBgICAIEEAIBNDAAAAAF0bcnIgEPwBQQh0ckMAAH9DIBQgDpUiDiAOQwAAf0NeGxC5B/wBQRB0cjYCACAMQQRqIQwgB0EQaiEHIAlBAWshCSAFQQlqIQUgA0EkaiEDIA1BAWsiDQ0BDAkLCyAFQQNrIQULIAUgBEHYu8EAEIwHAAsgBUEBawwBCyAFQQRrCyAEQci7wQAQjAcACyAFQQJrDAELIAVBBWsLIARBuLvBABCMBwALIAggACgCBCABQQJ0IAEgAmpBAnQQ4QgiABC4CiIBNgIAIAggBjYCBCABIAZHDQEgACALIAYQ4AkgAEGECEkNACAAEJsHCyAIQSBqJAAPCyAIQQA2AghBACAIIAhBBGogCEEIakHg+cQAEPUHAAtBACAGIAVB+LvBABDqBwALrAsCIH8XfSMAQTBrIgckACAAIAEQ7QEgAUEMbCEcIAAtANQBIR0gAC0AzAEhHiAALQDEASEfIAAtALwBISAgACgCTCELIAAoAlAhCSAAKAIoISEgACgCLCETIAAoAjQhIiAAKAI4IQwgACgCQCEjIAAoAkQhDSAAKAIcISQgACgCICEOIAAoAtABIRQgACgCyAEhFSAAKALAASEWIAAoArgBIRcgACgCECElIAAoAhQhJkEAIQECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkADQCAHIAIgGGoiADYCAAJAAkACQCAmIABBCHYiAEsEQCAgIAUgBiADIBdqEI8FIQggHyAFIAYgAyAWahCPBSEPIB4gBSAGIAMgFWoQjwUhGSAdIAUgBiADIBRqEI8FIREgJSAAQcgAbGoiACoCCCEsIAAqAhQhNSAAKgIEIS0gACoCECE2IAAqAgAhLiAAKgIMITdDAACAPyAPQRR2Qf8HcbNDAMB/RJVDAAAAv5JD8wS1P5QiKCAolJMgD0EKdkH/B3GzQwDAf0SVQwAAAL+SQ/MEtT+UIikgKZSTIA9B/wdxs0MAwH9ElUMAAAC/kkPzBLU/lCIqICqUk0MAAAAAEOAIkSEnICghKyAPQR52IhoOAgMBAgsgB0EBNgIUIAdBgN3HADYCECAHQgE3AhwgByAHrUKAgICAEIQ3AyggByAHQShqNgIYIAdBBGoiACAHQRBqELEGIAAQkAchAAwSCyAnISsMAQsgKSErCyABIA5PDQIgACoCMCEvIAAqAjwhOCAAKgIgITAgACoCLCE5IAAqAhghMSAAKgIkITogACoCOCEyIAAqAkQhOyAAKgI0ITMgACoCQCE8IAAqAhwhNCAAKgIoIT0gEiAkaiIbIC4gCEEVdrNDAOD/RJUgNyAuk5SSOAIAIAFBAWoiACAOTw0DIBtBBGogLSAIQQt2Qf8HcbNDAMB/RJUgNiAtk5SSOAIAIAFBAmoiECAOTw0EIBtBCGogLCAIQf8PcbNDAOD/RJUgNSAsk5SSOAIAIAEgDU8NBSASICNqIgggMSAZQRV2s0MA4P9ElSA6IDGTlJIQiQQ4AgAgACANTw0GIAhBBGogNCAZQQt2Qf8HcbNDAMB/RJUgPSA0k5SSEIkEOAIAIA0gEE0NByAIQQhqIDAgGUH/D3GzQwDg/0SVIDkgMJOUkhCJBDgCACABIAxPDQggEiAiaiIIIC8gEUEYdrNDAAB/Q5UgOCAvk5SSOAIAIAAgDE8NCSAIQQRqIDMgEUEQdkH/AXGzQwAAf0OVIDwgM5OUkjgCACAMIBBNDQogCEEIaiAyIBFBCHZB/wFxs0MAAH9DlSA7IDKTlJI4AgAgEyAYRg0LIAogIWogEUH/AXGzQwAAf0OVOAIAIAkgCk0NDCALICs4AgAgCkEBaiIAIAlPDQ0gC0EEaiAnICogGkECRhsgKSAPQQBIGzgCACAKQQJqIgAgCU8NDiALQQhqICcgKiAaQQNGGzgCACAKQQNqIgAgCU8NASALQQxqICcgKCAPQYCAgIAESRs4AgAgGEEBaiEYIAQgF2ohFyAEIBZqIRYgBCAVaiEVIAQgFGohFCABQQNqIQEgC0EQaiELIApBBGohCiAcIBJBDGoiEkcNAAtBACEADA4LIAAgCUHU3McAEIwHAAsgASAOQYTbxwAQjAcACyAAIA5BlNvHABCMBwALIBAgDkGk28cAEIwHAAsgASANQbTbxwAQjAcACyAAIA1BxNvHABCMBwALIBAgDUHU28cAEIwHAAsgASAMQeTbxwAQjAcACyAAIAxB9NvHABCMBwALIBAgDEGE3McAEIwHAAsgEyATQZTcxwAQjAcACyAKIAlBpNzHABCMBwALIAAgCUG03McAEIwHAAsgACAJQcTcxwAQjAcACyAHQTBqJAAgAAvFCgImfwF9AkACQAJAAkACQAJAAkACQCAAKAKEAUGAgICAeEYNACAAKAK0ASIGIAAoAoABIgdLBEAgBiAHayIGIAAoAnggB2tLBEAgAEH4AGogByAGQQRBBBCkBSAAKAKAASEHCyAAKAJ8IgkgB0ECdGohCCAGQQJPBH8gBkECdEEEayINBEAgCEEAIA38CwALIAYgB2oiBkEBayEHIAkgBkECdGpBBGsFIAgLQQA2AgAgACAHQQFqNgKAAQsgACABEO0BIAAoAoQBQYCAgIB4Rg0AIAAoAogBIhFBCEEAIAAoAowBIhIbIglqIRkgESASQQN0IgZqIRogACgCfCENIAAoAoABIQsgACgC8AIiGwRAIAAoAqwBIhxBBEEAIAAoArABIh0bIghqISIgACgCoAEiHkEEQQAgACgCpAEiHxsiB2ohIyAAKAKUASIgQQRBACAAKAKYASIhGyIKaiEkIBwgHUECdCIMaiElIB4gH0ECdCIOaiEmICAgIUECdCIPaiEnIAAoAnAhEyAAKAJ0IRQgACgCZCEVIAAoAmghFiAAKAJYIRcgACgCXCEYIAwgCGtBAnZBAWohKCAOIAdrQQJ2QQFqISkgDyAKa0ECdkEBaiEqIAYgCWtBA3ZBAWohK0EAIQxBACEOQQAhD0EBIQBBACEKA0AgCiEGIAAhCiASBEAgAyAGbCACaiEHQQAhACANIQkgGSEGIBEhCANAIAgtAAQgBCAFIAcgCCgCAGoQvQQhLCAAIAtGDQogCSAsOAIAIAlBBGohCSAGQQhBACAGIgggGkcbaiEGICsgAEEBaiIARw0ACwsgIQRAIBggDyAPIBhJGyEQICohACAXIQggDyEHICQhCSAgIQYDQCAGKAIAIgYgC08NCCAHIBBGDQkgCCANIAZBAnRqKgIAQwAAAEGUQwAAf0OVQwAAgMCSOAIAIAhBBGohCCAHQQFqIQdBBEEAIAkiBiAnRxsgBmohCSAAQQFrIgANAAsLAkAgG0EBRg0AIB8EQCAWIA4gDiAWSRshECApIQAgFSEIIA4hByAjIQkgHiEGA0AgBigCACIGIAtPDQcgByAQRg0IIAggDSAGQQJ0aioCAEMAAABBlEMAAH9DlUMAAIDAkjgCACAIQQRqIQggB0EBaiEHQQRBACAJIgYgJkcbIAZqIQkgAEEBayIADQALCyAdRSAbQQJNcg0AIBQgDCAMIBRJGyEQICghACATIQggDCEHICIhCSAcIQYDQCAGKAIAIgYgC08NCyAHIBBGDQUgCCANIAZBAnRqKgIAQwAAAEGUQwAAf0OVQwAAgMCSOAIAIAhBBGohCCAHQQFqIQdBBEEAIAkiBiAlRxsgBmohCSAAQQFrIgANAAsLIBNB1ABqIRMgDEEVaiEMIBVBPGohFSAOQQ9qIQ4gF0EkaiEXIA9BCWohDyAKIAEgCksiBmohACAGDQALDAELIBJFDQAgBkEIa0EDdkEBaiEMQQEhAEEAIQcDQCAAIQogAyAHbCACaiEHIA0hCUEAIQAgGSEGIBEhCANAIAgtAAQgBCAFIAcgCCgCAGoQvQQhLCAAIAtGDQggCSAsOAIAIAlBBGohCSAGQQhBACAGIgggGkcbaiEGIAwgAEEBaiIARw0ACyAKIAEgCksiBmohACAKIQcgBg0ACwsPCyAHIBRB4OTHABCMBwALIAYgC0Hw5McAEIwHAAsgByAWQYDlxwAQjAcACyAGIAtBkOXHABCMBwALIAcgGEGg5ccAEIwHAAsgACALQbDlxwAQjAcACyAGIAtB0OTHABCMBwALoAoCB38BeyAAIAEoAgQ2AlwCQAJAAkAgAS0ACEUEQCABKAIAIgWzQwAAwD+UjfwBIgIgACgCACAAKAIIIgFrSwRAIAAgASACQQRBGBCkBQsgACgCDCAAKAIUIgFrIAJJBEAgAEEMaiABIAJBBEEYEKQFCyAAKAJcIgNFDQEgACgCGCAAKAIgIgFrIAJJBEAgAEEYaiABIAJBAUEJEKQFIAAoAlwhAwsgA0ECSQ0BIAAoAiQgACgCLCIBayACSQR/IABBJGogASACQQFBDxCkBSAAKAJcBSADC0EDSQ0BIAIgACgCMCAAKAI4IgFrTQ0BIABBMGogASACQQFBFRCkBQwBCyABKAIAIgUgACgCFCICTQRAIAAgBTYCFCACIAVGDQEgACgCECAFQRhsaiEBA0AgAUEUaigCACIDQQVPBEAgAUEIaigCACIGQQRrKAIAIgRBeHEiCCADQQJ0IgNBBEEIIARBA3EiBBtqSQ0EIARBACAIIANBJ2pLGw0FIAYQogILIAFBGGohASAFIAJBAWsiAkcNAAsMAQsgAiEEIAUgAmsiByAAKAIMIAJrSwRAIABBDGogAiAHQQRBGBCkBSAAKAIUIQQLIAAoAhAhBiAHQQNxIgMEQCADIARqIAUgAmsgA2shByAGIARBGGxqIQEDQCABQQA2AgAgAUEUakEANgIAIAFBGGohASADQQFrIgMNAAshBAsgAiAFa0F8TQRAIAYgBEEYbGohAQNAIAFBADYCACABQdwAakEANgIAIAFBxABqQgA3AgAgAUEsakIANwIAIAFBFGpCADcCACABQeAAaiEBIARBBGohBCAHQQRrIgcNAAsLIAAgBDYCFAsCQCAAKAIIIgYgBSICTw0AIAIgBiICayIEIAAoAgAgAmtLBEAgACACIARBBEEYEKQFIAAoAgghAgsgACgCBCEHIARBA3EiAwRAIAIgA2ogBSAGayADayEEIAcgAkEYbGohAQNAIAH9DAAAAAAAAAAAAAAAAAAAAAD9CwIAIAFBD2pCADcAACABQRhqIQEgA0EBayIDDQALIQILIAYgBWtBfEsNACAHIAJBGGxqIQEDQCAB/QwAAAAAAAAAAAAAAAAAAAAA/QsCACABQQ9qQgA3AAAgAUEYaiAJ/QsCACABQSdqQgA3AAAgAUEwaiAJ/QsCACABQT9qQgA3AAAgAUHIAGogCf0LAgAgAUHXAGpCADcAACABQeAAaiEBIAJBBGohAiAEQQRrIgQNAAsLIAAgAjYCCAJAIAAoAlwiAUUNACAAIAAoAiAiAyAFTwR/IAUFIAUgA2siBCAAKAIYIANrSwRAIABBGGogAyAEQQFBCRCkBSAAKAIgIQMgACgCXCEBCyAEQQlsIgIEQCAAKAIcIANBCWxqQQAgAvwLAAsgAyAEags2AiAgAUECSQ0AIAAgACgCLCIDIAVPBH8gBQUgBSADayIEIAAoAiQgA2tLBEAgAEEkaiADIARBAUEPEKQFIAAoAiwhAyAAKAJcIQELIARBD2wiAgRAIAAoAiggA0EPbGpBACAC/AsACyADIARqCzYCLCABQQNJDQAgACAAKAI4IgEgBUkEfyAFIAFrIgUgACgCMCABa0sEQCAAQTBqIAEgBUEBQRUQpAUgACgCOCEBCyAFQRVsIgIEQCAAKAI0IAFBFWxqQQAgAvwLAAsgASAFagUgBQs2AjgLDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALqQoBDX8jAEEwayIJJAACQAJAAkAgBUEDSQRAIANBB0sNAiAERSITLQC0q0YiCEEHSw0DQQEhCgJAAkACQAJAIAEgA0EobGpBmAFqIgMgASgC8AQgBEGgCGxqIhQgCEGEAWxqIAVBLGxqIgFBCyABKAAAEMgEQf8BcSIFDgwBAAAAAAAAAAAAAAIACyAFQQFrQQRPBEAgBUEFa0H/AXEiCEEFSw0FAn9BACAIQQxsIgEtAPyrRiIFRQ0AGiABLQCGrEYhCiABLQCFrEYhCyABLQCErEYhDCABLQCDrEYhDSABLQCCrEYhDiABLQCBrEYhDyABLQCArEYhECABLQD/q0YhESABLQD+q0YhEiABLQD9q0YhASADIAUQmQUiBSABRQ0AGiADIAEQmQVBAkEAIAUbciIFIBJFDQAaIAMgEhCZBSAFQQF0ciIFIBFFDQAaIAMgERCZBSAFQQF0ciIFIBBFDQAaIAMgEBCZBSAFQQF0ciIFIA9FDQAaIAMgDxCZBSAFQQF0ciIFIA5FDQAaIAMgDhCZBSAFQQF0ciIFIA1FDQAaIAMgDRCZBSAFQQF0ciIFIAxFDQAaIAMgDBCZBSAFQQF0ciIFIAtFDQAaIAMgCxCZBSAFQQF0ciIFIApFDQAaIAMgChCZBSAFQQF0cgsgCC0AxKxGaiEFCyATLQDKrEYhCCADEKoFIQEgCEEPSw0CQQAhCiACIAhBAnRqIAcgBiAIG8FBACAFayAFIAEbbDYCAEEBQQIgBUEBRhtBACAFGyEFC0EBQQIgBBshBANAIARBtKvGAGotAAAiCEEITw0GIApBAnQhAUEBIQtBASEKAkACQCADIBQgCEGEAWxqIAVBLGxqIgVBCyABIAVqKAAAEMgEQf8BcSIFDgwBAAAAAAAAAAAAAAMACyAFQQFrQQRPBEAgBUEFa0H/AXEiCEEGTw0GAn9BACAIQQxsIgEtAPyrRiIFRQ0AGiABLQCGrEYhCiABLQCFrEYhDCABLQCErEYhDSABLQCDrEYhDiABLQCCrEYhDyABLQCBrEYhECABLQCArEYhESABLQD/q0YhEiABLQD+q0YhEyABLQD9q0YhASADIAUQmQUiBSABRQ0AGiADIAEQmQVBAkEAIAUbciIFIBNFDQAaIAMgExCZBSAFQQF0ciIFIBJFDQAaIAMgEhCZBSAFQQF0ciIFIBFFDQAaIAMgERCZBSAFQQF0ciIFIBBFDQAaIAMgEBCZBSAFQQF0ciIFIA9FDQAaIAMgDxCZBSAFQQF0ciIFIA5FDQAaIAMgDhCZBSAFQQF0ciIFIA1FDQAaIAMgDRCZBSAFQQF0ciIFIAxFDQAaIAMgDBCZBSAFQQF0ciIFIApFDQAaIAMgChCZBSAFQQF0cgsgCC0AxKxGaiEFCyAEQcqsxgBqLQAAIQggAxCqBSEBIAhBD0sNA0EAIQogAiAIQQJ0aiAHIAYgCBvBQQAgBWsgBSABG2w2AgBBAUECIAVBAUYbQQAgBRshBQsgBEEBaiIEQRBHDQALC0EPIQUgACADLQAjQfIBRwR/IAAgCzoAAUEdBSAFCzoAACAJQTBqJAAPCyAIQRBB3KzGABCMBwALQfCqxgBBIUGUq8YAEOsHAAsgCSAFOgAPIAlBATYCFCAJQeSrxgA2AhAgCUIBNwIcIAkgCUEPaq1CgICAgMAOhDcDKCAJIAlBKGo2AhggCUEQakHsq8YAEI0IAAsgA0EIQaSrxgAQjAcACyAIQQhBxKvGABCMBwALkAsCCH8BfiMAQZABayIDJAACfyACRQRAIANBEGogA0EcaigCADYCACADIAMpAhQ3AwggACgCACEFIAEhBiABIAJqDAELQQEhBAJ/IAEsAAAiBUEATgRAIAVB/wFxIQUgAUEBagwBCyABLQABQT9xIQcgBUEfcSEGIAVBX00EQCAGQQZ0IAdyIQUgAUECagwBCyABLQACQT9xIAdBBnRyIQcgBUFwSQRAIAcgBkEMdHIhBSABQQNqDAELIAZBEnRBgIDwAHEgAS0AA0E/cSAHQQZ0cnIhBSABQQRqCyEGIANBFGogBUGBggQQgQMgA0EQaiADQRxqKAIAIgc2AgAgAyADKQIUIgs3AwggAy0AISEIIAMtACAhCSAAKAIAIQUgA0GIAWogBzYCACADIAs3A4ABIAEgAmoLIQcgA0HIAGogA0GIAWooAgA2AgAgAyADKQOAATcCQCADIAc2AnwgAyAGNgJ4QQAhACADQQA2AmQgA0EANgJQIAMgCDoATSADIAk6AEwgAyAENgI8IANBADYCKCADQQA2AhQCQAJAIAQEQCADQRhqIgQgA0FAa/0AAgD9CwIAIAMtACQhAQJAIAMtACUiAkGBAU8EQCABIAJPDQEgBCgCACEEIAUoAgAhCCAFKAIEKAIQIQkDQCAIIAQgCRECAA0EIAFBAWoiAUH/AXEgAkkNAAsgAiEBDAELIAEgAk8NACABIAIgASACSxshAiAFKAIAIQggBSgCBCgCECEJA0AgCCABIARqLQAAIAkRAgANAyACIAFBAWoiAUcNAAsgAiEBCyADIAE6ACQLIAYgB0YNASADQdQAaiIJIQAgBSgCBCEIIAUoAgAhBQNAAkACfwJAAkACfyAGLAAAIgFBAE4EQCABQf8BcSEEIAZBAWoMAQsgBi0AAUE/cSEEIAFBH3EhAiABQV9NBEAgAkEGdCAEciEEIAZBAmoMAQsgBi0AAkE/cSAEQQZ0ciEEIAFBcEkEQCAEIAJBDHRyIQQgBkEDagwBCyACQRJ0QYCA8ABxIAYtAANBP3EgBEEGdHJyIgRBgIDEAEYNASAGQQRqCyEGAkACQAJAAkACQAJAAkACQAJAAkAgBA4oAgEBAQEBAQEBAwUBAQQBAQEBAQEBAQEBAQEBAQEBAQEBAQcBAQEBCAALIARB3ABGDQULIAQQ4QINByADQQA6AIIBIANBADsBgAEgAyAEQRR2LQDctkU6AIMBIAMgBEEEdkEPcS0A3LZFOgCHASADIARBCHZBD3EtANy2RToAhgEgAyAEQQx2QQ9xLQDctkU6AIUBIAMgBEEQdkEPcS0A3LZFOgCEASAEQQFyZ0ECdiIBIANBgAFqIgpqIgJB+wA6AAAgAkEBa0H1ADoAACAKIAFBAmsiAWpB3AA6AAAgA0H9ADoAiQEgAyAEQQ9xLQDctkU6AIgBQQoMCgsgA0IANwGCASADQdzgADsBgAEMCAsgA0IANwGCASADQdzoATsBgAEMBwsgA0IANwGCASADQdzkATsBgAEMBgsgA0IANwGCASADQdzcATsBgAEMBQsgA0IANwGCASADQdy4ATsBgAEMBAsgA0IANwGCASADQdzEADsBgAEMAwsgA0IANwGCASADQdzOADsBgAEMAgsgAyAENgKAASAAIAMpAoABNwIAIABBCGogA0GIAWovAQA7AQAgBSAJKAIAIAgoAhARAgBFDQMMBQtBACEADAULQQAhAUECCyEEIAAgAykCgAE3AgAgAEEIaiADQYgBai8BADsBACABIAQgASAESxsiAkH/AXEhBCAIKAIQIQoDQCAFIAAgAWotAAAgChECAA0DIAQgAUEBaiIBRw0ACyADIAI6AGALIAYgB0cNAAtBACEADAELQQEhAAsgA0GQAWokACAAC+MJAQZ/IAFBA2wiBCAAKAKQBCICSwRAIAQgAmsiBSAAKAKIBCACa0sEQCAAQYgEaiACIAVBBEEEEKQFIAAoApAEIQILIAAoAowEIgYgAkECdGohAyAFQQJPBH8gBUECdEEEayIHBEAgA0EAIAf8CwALIAIgBWoiA0EBayECIAYgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgKQBAsgACgCnAQiAiABSQRAIAEgAmsiBSAAKAKUBCACa0sEQCAAQZQEaiACIAVBBEEEEKQFIAAoApwEIQILIAAoApgEIgYgAkECdGohAyAFQQJPBH8gBUECdEEEayIHBEAgA0EAIAf8CwALIAIgBWoiA0EBayECIAYgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgKcBAsgACgCqAQiAiAESQRAIAQgAmsiBSAAKAKgBCACa0sEQCAAQaAEaiACIAVBBEEEEKQFIAAoAqgEIQILIAAoAqQEIgYgAkECdGohAyAFQQJPBH8gBUECdEEEayIHBEAgA0EAIAf8CwALIAIgBWoiA0EBayECIAYgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgKoBAsgACgCtAQiAiAESQRAIAQgAmsiBCAAKAKsBCACa0sEQCAAQawEaiACIARBBEEEEKQFIAAoArQEIQILIAAoArAEIgUgAkECdGohAyAEQQJPBH8gBEECdEEEayIGBEAgA0EAIAb8CwALIAIgBGoiA0EBayECIAUgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgK0BAsgAUECdCICIAAoAsAEIgRLBEAgAiAEayICIAAoArgEIARrSwRAIABBuARqIAQgAkEEQQQQpAUgACgCwAQhBAsgACgCvAQiBSAEQQJ0aiEDIAJBAk8EfyACQQJ0QQRrIgYEQCADQQAgBvwLAAsgAiAEaiICQQFrIQQgBSACQQJ0akEEawUgAwtBADYCACAAIARBAWo2AsAECwJAAkAgACgChAQiBEUNACABQQlsIgMgACgCzAQiAksEQCADIAJrIgQgACgCxAQgAmtLBEAgAEHEBGogAiAEQQRBBBCkBSAAKALMBCECCyAAKALIBCIFIAJBAnRqIQMgBEECTwR/IARBAnRBBGsiBgRAIANBACAG/AsACyACIARqIgNBAWshAiAFIANBAnRqQQRrBSADC0EANgIAIAAgAkEBajYCzAQgACgChAQhBAsgBEEBTQ0AIAFBD2wiAyAAKALYBCICSwR/IAMgAmsiBCAAKALQBCACa0sEQCAAQdAEaiACIARBBEEEEKQFIAAoAtgEIQILIAAoAtQEIgUgAkECdGohAyAEQQJPBH8gBEECdEEEayIGBEAgA0EAIAb8CwALIAIgBGoiA0EBayECIAUgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgLYBCAAKAKEBAUgBAtBAk0NACABQRVsIgIgACgC5AQiAUsNAQsPCyACIAFrIgMgACgC3AQgAWtLBEAgAEHcBGogASADQQRBBBCkBSAAKALkBCEBCyAAKALgBCIEIAFBAnRqIQIgA0ECTwR/IANBAnRBBGsiBQRAIAJBACAF/AsACyABIANqIgJBAWshASAEIAJBAnRqQQRrBSACC0EANgIAIAAgAUEBajYC5AQLtwkBBn8gAUEDbCIEIAAoAiAiAksEQCAEIAJrIgUgACgCGCACa0sEQCAAQRhqIAIgBUEEQQQQpAUgACgCICECCyAAKAIcIgYgAkECdGohAyAFQQJPBH8gBUECdEEEayIHBEAgA0EAIAf8CwALIAIgBWoiA0EBayECIAYgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgIgCyAAKAIsIgIgAUkEQCABIAJrIgUgACgCJCACa0sEQCAAQSRqIAIgBUEEQQQQpAUgACgCLCECCyAAKAIoIgYgAkECdGohAyAFQQJPBH8gBUECdEEEayIHBEAgA0EAIAf8CwALIAIgBWoiA0EBayECIAYgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgIsCyAAKAI4IgIgBEkEQCAEIAJrIgUgACgCMCACa0sEQCAAQTBqIAIgBUEEQQQQpAUgACgCOCECCyAAKAI0IgYgAkECdGohAyAFQQJPBH8gBUECdEEEayIHBEAgA0EAIAf8CwALIAIgBWoiA0EBayECIAYgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgI4CyAAKAJEIgIgBEkEQCAEIAJrIgQgACgCPCACa0sEQCAAQTxqIAIgBEEEQQQQpAUgACgCRCECCyAAKAJAIgUgAkECdGohAyAEQQJPBH8gBEECdEEEayIGBEAgA0EAIAb8CwALIAIgBGoiA0EBayECIAUgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgJECyABQQJ0IgIgACgCUCIESwRAIAIgBGsiAiAAKAJIIARrSwRAIABByABqIAQgAkEEQQQQpAUgACgCUCEECyAAKAJMIgUgBEECdGohAyACQQJPBH8gAkECdEEEayIGBEAgA0EAIAb8CwALIAIgBGoiAkEBayEEIAUgAkECdGpBBGsFIAMLQQA2AgAgACAEQQFqNgJQCwJAAkAgACgC8AIiBEUNACABQQlsIgMgACgCXCICSwRAIAMgAmsiBCAAKAJUIAJrSwRAIABB1ABqIAIgBEEEQQQQpAUgACgCXCECCyAAKAJYIgUgAkECdGohAyAEQQJPBH8gBEECdEEEayIGBEAgA0EAIAb8CwALIAIgBGoiA0EBayECIAUgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgJcIAAoAvACIQQLIARBAU0NACABQQ9sIgMgACgCaCICSwR/IAMgAmsiBCAAKAJgIAJrSwRAIABB4ABqIAIgBEEEQQQQpAUgACgCaCECCyAAKAJkIgUgAkECdGohAyAEQQJPBH8gBEECdEEEayIGBEAgA0EAIAb8CwALIAIgBGoiA0EBayECIAUgA0ECdGpBBGsFIAMLQQA2AgAgACACQQFqNgJoIAAoAvACBSAEC0ECTQ0AIAFBFWwiAiAAKAJ0IgFLDQELDwsgAiABayIDIAAoAmwgAWtLBEAgAEHsAGogASADQQRBBBCkBSAAKAJ0IQELIAAoAnAiBCABQQJ0aiECIANBAk8EfyADQQJ0QQRrIgUEQCACQQAgBfwLAAsgASADaiICQQFrIQEgBCACQQJ0akEEawUgAgtBADYCACAAIAFBAWo2AnQL9AoBCH8jAEGAAWsiBCQAIAAoAgwhBgJAAkACQAJAAkACQAJAIAAoAhQiCCAAKAIQIgNJBEACQAJAAkACQAJAAkACQAJAAkAgBiAIai0AACIFQdsAaw4hBAgICAgICAgICAgDCAgICAgICAEICAgICAIICAgICAgFAAsgBUEiaw4MBgcHBwcHBwcHBwcFBwsgACAIQQFqIgU2AhQCQCADIAVNDQAgACAIQQJqIgc2AhQgBSAGai0AAEH1AEcNDSADIQUgAyAHRg0AIAAgCEEDaiIJNgIUIAYgB2otAABB7ABHBEAgCSEHDA4LIAMgCUYNACAAIAhBBGoiBzYCFCAGIAlqLQAAQewARw0NIARBBzoAcCAEQfAAaiABIAIQ3wYgABDrBSEDDA4LIARBEGogBiADIAUQ+QEgBCgCFCEAIAQoAhAhAUEUEHEiA0UNDiADIAE2AgwgA0EFNgIAIAMgADYCEAwNCyAAIAhBAWoiBTYCFAJAIAMgBU0NACAAIAhBAmoiBzYCFCAFIAZqLQAAQfIARw0LIAMhBSADIAdGDQAgACAIQQNqIgk2AhQgBiAHai0AAEH1AEcEQCAJIQcMDAsgAyAJRg0AIAAgCEEEaiIHNgIUIAYgCWotAABB5QBHDQsgBEGAAjsBcCAEQfAAaiABIAIQ3wYgABDrBSEDDA0LIARBIGogBiADIAUQ+QEgBCgCJCEAIAQoAiAhAUEUEHEiA0UNDSADIAE2AgwgA0EFNgIAIAMgADYCEAwMCyAAIAhBAWoiBTYCFAJAIAMgBU0NACAAIAhBAmoiBzYCFCAFIAZqLQAAQeEARw0JIAMhBSADIAdGDQAgACAIQQNqIgk2AhQgBiAHai0AAEHsAEcEQCAJIQcMCgsgAyAJRg0AIAAgCEEEaiIKNgIUIAYgCWotAABB8wBHBEAgCiEHDAoLIAMgCkYNACAAIAhBBWoiBzYCFCAGIApqLQAAQeUARw0JIARBADsBcCAEQfAAaiABIAIQ3wYgABDrBSEDDAwLIARBMGogBiADIAUQ+QEgBCgCNCEAIAQoAjAhAUEUEHEiA0UNDCADIAE2AgwgA0EFNgIAIAMgADYCEAwLCyAEQQo6AHAgBEHwAGogASACEN8GIAAQ6wUhAwwKCyAEQQs6AHAgBEHwAGogASACEN8GIAAQ6wUhAwwJCyAAIAhBAWo2AhQgBEFAayIFIABBABDHAyAEKQNAQgNRDQQgBSABIAIQhAcgABDrBSEDDAgLIABBADYCCCAAIAhBAWo2AhQgBEHkAGogAEEMaiAAEIICIAQoAmghAyAEKAJkQQJGDQcgBCAEKAJsNgJ4IAQgAzYCdCAEQQU6AHAgBEHwAGogASACEN8GIAAQ6wUhAwwHCyAFQTBrQf8BcUEKSQ0BCyAEQQhqIAYgAyAIQQFqIgEgAyABIANJGxD5ASAEKAIMIQIgBCgCCCEDQRQQcSIBRQ0GIAEgAzYCDCABQQo2AgAgASACNgIQIAEgABDrBSEDDAULIARB0ABqIABBARDHAyAEKQNQQgNRBEAgBCgCWCEDDAULIARB0ABqIAEgAhCEByAAEOsFIQMMBAsgBCgCSCEDDAMLIARBOGogBiADIAcQ+QEgBCgCPCEAIAQoAjghAUEUEHEiA0UNAyADIAE2AgwgA0EJNgIAIAMgADYCEAwCCyAEQShqIAYgAyAHEPkBIAQoAiwhACAEKAIoIQFBFBBxIgNFDQIgAyABNgIMIANBCTYCACADIAA2AhAMAQsgBEEYaiAGIAMgBxD5ASAEKAIcIQAgBCgCGCEBQRQQcSIDRQ0BIAMgATYCDCADQQk2AgAgAyAANgIQCyAEQYABaiQAIAMPCwAL2wsBBX8jAEEwayICJABBASEDAkACQAJAAkACQAJAAkBBASAALQAAIgRBJGsgBEEjTRtB/wFxQQFrDgMBAgMACyABKAIAIgRB86XHAEEHIAEoAgQiBigCDCIFEQAADQUgAEEEaiEAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0HIAAgARCuAkUNAQwHCyAEQduBwgBBAiAFEQAADQYgAkEBOgAoIAIgBjYCCCACIAQ2AgQgAkHggcIANgIYIAIgASkCCDcCHCACIAJBKGo2AgwgAiACQQRqNgIUIAAgAkEUahCuAg0GIAIoAhRB2YHCAEECIAIoAhgoAgwRAAANBgsgASgCAEHejsgAQQEgASgCBCgCDBEAACEDDAULIAEoAgAiBEHQt8cAQQYgASgCBCIGKAIMIgURAAANBAJAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0HIAIgADYCBCABKAIAQdzJxABBCyABKAIEKAIMEQAAIQAgAkEAOgAZIAIgADoAGCACIAE2AhQgAkEUakGQwcQAQQUgAkEEakHMycQAEIwFIQAgAi0AGCIEQQFxIAItABkiBUEBR3JFBEAgACgCACIALQAKQYABcQ0CIAAoAgBB/7PFAEECIAAoAgQoAgwRAABFDQMMCAsgBQ0HIARBAXFFDQIMBwsgBEHbgcIAQQIgBREAAA0GIAIgBjYCCCACIAQ2AgQgAkEBOgATIAJB4IHCADYCGCACIAEpAgg3AhwgAiACQRNqNgIMIAIgAkEEaiIDNgIUIAIgADYCJCADQdzJxABBCxCvAyEAIAJBADoALSACIAA6ACwgAiACQRRqNgIoIAJBKGpBkMHEAEEFIAJBJGpBzMnEABCMBSEAAkACQCACLQAsIgNBAXEgAi0ALSIEQQFHckUEQCAAKAIAIgAtAApBgAFxDQEgACgCAEH/s8UAQQIgACgCBCgCDBEAAA0IDAILIAQNByADQQFxRQ0BDAcLIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAANBgsgAigCFEHZgcIAQQIgAigCGCgCDBEAAEUNAUEBIQMMBgsgACgCAEGls8UAQQEgACgCBCgCDBEAAA0FCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMBAsgASgCACIEQeSlxwBBCSABKAIEIgYoAgwiBREAAA0DIABBBGohAAJAAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0GIAIgADYCBCABKAIAQZCqxwBBDiABKAIEKAIMEQAAIQAgAkEAOgAZIAIgADoAGCACIAE2AhQgAkEUakGQwcQAQQUgAkEEakGAwcQAEIwFIQAgAi0AGCIEQQFxIAItABkiBUEBR3JFBEAgACgCACIALQAKQYABcQ0CIAAoAgBB/7PFAEECIAAoAgQoAgwRAABFDQMMBwsgBQ0GIARBAXFFDQIMBgsgBEHbgcIAQQIgBREAAA0FIAIgBjYCCCACIAQ2AgQgAkEBOgATIAJB4IHCADYCGCACIAEpAgg3AhwgAiACQRNqNgIMIAIgAkEEaiIDNgIUIAIgADYCJCADQZCqxwBBDhCvAyEAIAJBADoALSACIAA6ACwgAiACQRRqNgIoIAJBKGpBkMHEAEEFIAJBJGpBgMHEABCMBSEAAkACQCACLQAsIgNBAXEgAi0ALSIEQQFHckUEQCAAKAIAIgAtAApBgAFxDQEgACgCAEH/s8UAQQIgACgCBCgCDBEAAA0GDAILIAQNBSADQQFxRQ0BDAULIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAANBAsgAigCFEHZgcIAQQIgAigCGCgCDBEAAEUNAUEBIQMMBQsgACgCAEGls8UAQQEgACgCBCgCDBEAAA0ECyABKAIAQd6OyABBASABKAIEKAIMEQAAIQMMAwsgASgCAEGfzsQAQQ4gASgCBCgCDBEAACEDDAILQQEhAwwBC0EBIQMLIAJBMGokACADC8MKAw5/A3sCfiMAQaABayIHJAAgByACNgIEIAcgACgCCCIDNgIIAkACQAJAAkACQAJAAkACQAJAAkAgAiADRgRAIAdBDGogASACEPEDIAcoAhAhAQJAIAcoAhQiDEUNACABIAxBA3RqIQogACgCBCEGIAEhAwNAIAMoAgAiBCACTw0DIANBBGooAgAiBSACTw0MIAYgBEEkbGoiBEEgaiIIKAIAIQkgBiAFQSRsaiIF/QACACESIAVBEGoiC/0AAgAhESAIIAVBIGoiCCgCADYCACAEQRBqIg39AAIAIRMgDSAR/QsCACAE/QACACERIAQgEv0LAgAgCyAT/QsCACAFIBH9CwIAIAggCTYCACADQQhqIgMgCkcNAAsgACgCFCICBEAgACgCECEEIAEhAwNAIAMoAgAiBSACTw0NIANBBGooAgAiBiACTw0FIAQgBUEYbGoiBUEQaiIIKQIAIRQgBCAGQRhsaiIG/QACACESIAggBkEQaiIIKQIANwIAIAX9AAIAIREgBSAS/QsCACAIIBQ3AgAgBiAR/QsCACADQQhqIgMgCkcNAAsLIAAoAiAiAgRAIAAoAhwhBCABIQMDQCADKAIAIgUgAk8NDSADQQRqKAIAIgYgAk8NBiAEIAVBEmxqIgVBEGoiCC8BACEJIAQgBkESbGoiBv0AAQAhEiAIIAZBEGoiCC8BADsBACAF/QABACERIAUgEv0LAQAgCCAJOwEAIAYgEf0LAQAgA0EIaiIDIApHDQALCyAAKAIsIgUEQCAAKAIoIQYgASECA0AgAigCACIDIAVPDQcgAkEEaigCACIEIAVPDQggBiADQR5saiIDQRBqIggpAQAhFCADQRZqKQEAIRUgBiAEQR5saiIEQRxqLwEAIQkgBEEYaigBACELIAT9AAEAIRIgCCAEQRBqIggpAQA3AQAgA/0AAQAhESADIBL9CwEAIANBGGogCzYBACADQRxqIAk7AQAgB0GGAWoiAyAVNwEAIAdBgAFqIgkgFDcDACAEIBH9CwEAIAggCSkDADcBACAEQRZqIAMpAQA3AQAgAkEIaiICIApHDQALCyAAKAI4IgNFIAxFcg0AIAAoAjQhBSABIQIDQCACKAIAIgAgA08NCCACQQRqKAIAIgQgA08NCSAHQZgBaiIMIAUgAEEqbGoiAEEoaiIGLwEAOwEAIAdBkAFqIgggAEEgaiIJKQEANwMAIAdBgAFqIgsgAEEQaiIN/QABAP0LAwAgBSAEQSpsaiIEQRBqIg79AAEAIRIgBP0AAQAhESAEQShqIg8vAQAhECAJIARBIGoiCSkBADcBACAGIBA7AQAgAP0AAQAhEyAAIBH9CwEAIA0gEv0LAQAgByAT/QsDcCAJIAgpAwA3AQAgDyAMLwEAOwEAIAQgB/0AA3D9CwEAIA4gC/0AAwD9CwEAIAJBCGoiAiAKRw0ACwsgBygCDCIABEAgAUEEaygCACICQXhxIgMgAEEDdCIAQQRBCCACQQNxIgIbakkNCSACQQAgAyAAQSdqSxsNCiABEKICCyAHQaABaiQADwsgB0EANgJwQQAgB0EEaiAHQQhqIAdB8ABqQaTBxwAQ9QcACyAEIAJBwPbHABCMBwALIAYgAkHA9scAEIwHAAsgBiACQcD2xwAQjAcACyADIAVBwPbHABCMBwALIAQgBUHA9scAEIwHAAsgACADQcD2xwAQjAcACyAEIANBwPbHABCMBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAFIAJBwPbHABCMBwAL4AoCB38BfiMAQdAAayIEJAAgAAJ/AkACQAJAAkACQAJAIAEoAhQiAiABKAIQIgNJBEAgASgCDCEIAn4CQANAIAIgCGotAAAiBUEJayIHQRdLQQEgB3RBk4CABHFFcg0BIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECQgAMAQtCgAILIAWtQhCGhEKAgrgDUQ0BCyAEQSBqIAEoAgwiBSADIAIgA0kEfwNAIAIgBWotAAAiBkEJayIHQRlLDQNBASAHdEGTgIAEcUUEQCAHQRlHDQQgARDMBCICDQUMCAsgASACQQFqIgI2AhQgAiADRw0ACyADBSACC0EBaiIBIAMgASADSRsQ+QEgBCgCJCECIAQoAiAhA0EUEHEiAUUNBCABIAM2AgwgAUEFNgIAIAEgAjYCECAAIAE2AgQMAwsgASACQQFqIgY2AhQCQAJAAkAgAyAGTQ0AIAEgAkECaiIFNgIUIAYgCGotAABB9QBHDQEgBSAGIAMgAyAGSRsiBkYNACABIAJBA2oiBzYCFCAFIAhqLQAAQewARwRAIAchBQwCCyAGIAdGDQAgASACQQRqIgU2AhQgByAIai0AAEHsAEcNASAAQQA6AAFBAAwICyAEQQhqIAggAyAGEPkBIAQoAgwhBiAEKAIIIQFBFBBxIgJFDQUgAkEFNgIADAELIARBEGogCCADIAUQ+QEgBCgCFCEGIAQoAhAhAUEUEHEiAkUNBCACQQk2AgALIAIgATYCDCAAIAI2AgQgAiAGNgIQDAILIAZB+wBHBEAgBEEYaiAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCHCECIAQoAhghA0EUEHEiAUUNAyABIAM2AgwgAUEKNgIAIAEgAjYCECAAIAE2AgQMAgsgASABLQAYQQFrIgc6ABggAkEBaiECIAdB/wFxRQRAIARBKGogBSADIAIgAyACIANJGxD5ASAEKAIsIQIgBCgCKCEDQRQQcSIBRQ0DIAEgAzYCDCABQRg2AgAgASACNgIQIAAgATYCBAwCCyABIAI2AhQCQCABEMwEIgJFBEAgASgCDCEFAkACQCABKAIUIgIgASgCECIDSQRAA0ACQCACIAVqLQAAQQlrDjIAAAMDAAMDAwMDAwMDAwMDAwMDAwMDAwADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBgMLIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECCyAEQThqIAUgAyACQQFqIgIgAyACIANJGxD5ASAEKAI8IQYgBCgCOCEDQRQQcSICRQ0GIAJBAzYCAAwBCyAEQTBqIAUgAyACQQFqIgIgAyACIANJGxD5ASAEKAI0IQYgBCgCMCEDQRQQcSICRQ0FIAJBBjYCAAsgAiADNgIMIAIgBjYCEAsgASABLQAYQQFqOgAYIAAgAjYCBAwCCyABIAJBAWo2AhQgARCHBCECIAEgAS0AGEEBajoAGCACDQAgASgCDCEFAkAgASgCFCICIAEoAhAiA0kEQANAIAIgBWotAAAiB0EJayIGQRdLQQEgBnRBk4CABHFFcg0CIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECCyAEQcgAaiAFIAMgAhD5ASAEKAJMIQIgBCgCSCEDQRQQcSIBRQ0DIAEgAzYCDCABQQM2AgAgASACNgIQIAAgATYCBAwCCyAHQf0ARgRAIAEgAkEBajYCFAwECyAEQUBrIAUgAyACEPkBIAQoAkQhASAEKAJAIQNBFBBxIgJFDQIgAiADNgIMIAJBCjYCACACIAE2AhALIAAgAjYCBAtBAQwCCwALIABBAToAAUEACzoAACAEQdAAaiQAC/kKAwV/An0BfiMAQSBrIgIkAAJAIAEoAgAiBEGQtcQAQQUgASgCBCIDKAIMIgURAAAEQEEBIQMMAQsCQAJAAkAgASgCCCIGQYCAgARxRQRAQQEhAyAEQbuzxQBBASAFEQAADQQgBkGAgIABcSEFIAAqAgAhByAGQYCAgIABcQ0BIABBBGohBCAHiyIIQ8obDlpgIAdDAAAAAFwgCEMXt9E4XXFyRQRAIAEgByAFQQBHQQEQ9wJFDQMMBQsgASAHIAVBAEcQzwJFDQIMBAsgBEHbgcIAQQIgBREAAARAQQEhAwwECyACQQE6AA8gAiADNgIEIAIgBDYCACACQeCBwgA2AhQgAiABKQIIIgk3AhggCaciBEGAgIABcSEDIAIgAkEPajYCCCACIAI2AhAgACoCACEHAkACQCAEQYCAgIABcUUEQCAHiyIIQ8obDlpgIAdDAAAAAFwgCEMXt9E4XXFyDQEgAkEQaiAHIANBAEdBARD3Ag0FDAILIAJBEGogByADQQBHIAlCMIinEL0CRQ0BDAQLIAJBEGogByADQQBHEM8CDQMLIAIoAhBB2YHCAEECIAIoAhQoAgwRAAAEQEEBIQMMBAsgAEEEaiEEDAELIAEgByAFQQBHIAEvAQ4QvQINAiAAQQRqIQQLAkACQAJAAkACQCABKAIIIgNBgICABHFFBEAgASgCAEHnkMYAQQIgASgCBCgCDBEAAARAQQEhAwwICyADQYCAgAFxIQUgBCoCACEHIANBgICAgAFxDQEgAEEIaiEEIAeLIghDyhsOWmAgB0MAAAAAXCAIQxe30ThdcXJFBEBBASEDIAEgByAFQQBHQQEQ9wJFDQUMCAsgASAHIAVBAEcQzwJFDQRBASEDDAcLIAEpAgAhCSACQQE6AA8gAiAJNwIAIAJB4IHCADYCFCACIAEpAggiCTcCGCAJpyIFQYCAgAFxIQMgAiACQQ9qNgIIIAIgAjYCECAEKgIAIQcgBUGAgICAAXFFDQEgAkEQaiAHIANBAEcgCUIwiKcQvQJFDQIMBAsgASAHIAVBAEcgAS8BDhC9AgRAQQEhAwwGCyAAQQhqIQQMAgsgB4siCEPKGw5aYCAHQwAAAABcIAhDF7fROF1xckUEQCACQRBqIAcgA0EAR0EBEPcCDQMMAQsgAkEQaiAHIANBAEcQzwINAgsgAigCEEHZgcIAQQIgAigCFCgCDBEAAEUEQCAAQQhqIQQMAQtBASEDDAMLAkACQAJAAkACQCABKAIIIgNBgICABHFFBEAgASgCAEHnkMYAQQIgASgCBCgCDBEAAARAQQEhAwwJCyADQYCAgAFxIQAgBCoCACEHIANBgICAgAFxDQEgB4siCEPKGw5aYCAHQwAAAABcIAhDF7fROF1xckUEQEEBIQMgASAHIABBAEdBARD3AkUNBQwJC0EBIQMgASAHIABBAEcQzwJFDQQMCAsgASkCACEJIAJBAToADyACIAk3AgAgAkHggcIANgIUIAIgASkCCCIJNwIYIAmnIgNBgICAAXEhACACIAJBD2o2AgggAiACNgIQIAQqAgAhByADQYCAgIABcUUNASACQRBqIAcgAEEARyAJQjCIpxC9AkUNAgwEC0EBIQMgASAHIABBAEcgAS8BDhC9Ag0GDAILIAeLIghDyhsOWmAgB0MAAAAAXCAIQxe30ThdcXJFBEAgAkEQaiAHIABBAEdBARD3Ag0DDAELIAJBEGogByAAQQBHEM8CDQILIAIoAhBB2YHCAEECIAIoAhQoAgwRAABFDQBBASEDDAQLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwDC0EBIQMMAgtBASEDDAELQQEhAwsgAkEgaiQAIAML2AkDEH8EfgF7IwBBMGsiBiQAAkACQCACKAIAIg4gAigCCCILayIHQSBPBEAgASkDCCEUIA4hBSALIQcMAQsgBkEQav0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgBiAX/QsDAAJ/IAEpAwgiFVAEQCALDAELIAEoAhAiDygCACAPKQMIIhMgDygCBCIErSIWIBMgFlQbp2ohCAJAIARC/////w8gEyATQv////8PWhunayIFQQAgBCAFTxsiBEIgIBUgFUIgWhunIgUgBCAFSRsiA0EBRgRAIAYgCC0AADoAAAwBCyADRQ0AIAYgCCAD/AoAAAsgASAVIAOtIhZ9IhQ3AwggDyATIBZ8NwMIIAsgAyAHTQ0AGiACIAsgA0EBQQEQpAUgAigCCAshBSADBEAgAigCBCAFaiAGIAP8CgAACyACIAMgBWoiBzYCCCADBEAgAigCACEFDAELIABBBDoAACAAQQA2AgQMAQsgASgCECEJQYDAACEQIAZBEGohDwJAA0ACQCAFIAdHIAUgDkdyRQRAIA/9DAAAAAAAAAAAAAAAAAAAAAD9CwMAIAYgF/0LAwACfyAUUARAQQAhA0IAIRQgDgwBCyAJKQMIIhUgCSgCBCIMrSIWIBUgFlQbpyIHIAkoAgBqIQgCQCAMQv////8PIBUgFUL/////D1obp2siBUEAIAUgDE0bIgRCICAUIBRCIFobpyIFIAQgBUkbIgNBAUYEQCAGIAgtAAA6AAAMAQsgA0UNACAGIAggA/wKAAALIAEgFCADrSIWfSIUNwMIIAkgFSAWfDcDCCAOIAcgDEYNABogAiAOIANBAUEBEKQFIAIoAggLIQUgAwRAIAIoAgQgBWogBiAD/AoAAAsgAiADIAVqIgc2AgggA0UEQCAAQQQ6AAAgACAHIAtrNgIEDAULIAIoAgAhBQsCQCAFIAdHBEAgAigCBCEDDAELIAVBIGoiCCAFQQF0IgQgBCAISRsiBEEASA0BQQAhAyAGIAUEfyAGIAU2AgggBiACKAIENgIAQQEFIAMLNgIEIAZBJGpBASAEIAYQhQcgBigCJEEBRg0BIAYoAighAyACIAQ2AgAgAiADNgIEIAQhBQsgFFAEQCACIAc2AggMAwsgAyAHaiESIAkCfiAQIAUgB2siBCAEIBBLGyINrSAUWARAIAkoAgQiCEL/////DyAJKQMIIhMgE0L/////D1obp2siBEEAIAQgCE0bIgQgDSAEIA1JGyIDBEAgEiAJKAIAIBMgCK0iFiATIBZUG6dqIAP8CgAACyADIAogAyAKSxshCiATIAOtIhV8DAELIAkoAgQiDEL/////DyAJKQMIIhMgE0L/////D1obp2siBEEAIAQgDE0bIgggFKciBCAEIAhLGyIDBEAgEiAJKAIAIBMgDK0iFiATIBZUG6dqIAP8CgAACyADIAogAyAKSxshCiATIAOtIhV8CzcDCCABIBQgFX0iFDcDCCACIAMgB2oiBzYCCCADRQ0CQX9BfyAQIBFBAWpBACADIA1JGyIRQQFKGyAQIAogDUcbIgRBAXQgBEEASBsgBCAEIA1NGyAEIAMgDUYbIRAgCiADayEKDAELCyAAQoHMADcCAAwBCyAAQQQ6AAAgACAHIAtrNgIECyAGQTBqJAALggkCBn8DfgJAAkACQCABQQhPBEAgAUEHcSICRQ0BIAAoAqABIgRBKU8NAiAERQRAIABBADYCoAEMAgsgBEECdCIGQQRrIgNBAnZBAWoiBUEDcSEHIAJBAnQoAqCVQiACdq0hCgJAIANBDEkEQCAAIQIMAQsgBUH8////B3EhAyAAIQIDQCACIAI1AgAgCn4gCXwiCD4CACACQQRqIgUgBTUCACAKfiAIQiCIfCIIPgIAIAJBCGoiBSAFNQIAIAp+IAhCIIh8Igg+AgAgAkEMaiIFIAU1AgAgCn4gCEIgiHwiCD4CACAIQiCIIQkgAkEQaiECIANBBGsiAw0ACwsgBwRAIAdBAnQhAwNAIAIgAjUCACAKfiAJfCIIPgIAIAJBBGohAiAIQiCIIQkgA0EEayIDDQALCyAAIAhCgICAgBBaBH8gBEEoRg0EIAAgBmogCT4CACAEQQFqBSAECzYCoAEMAQsgACgCoAEiBEEpTw0BIARFBEAgAEEANgKgAQ8LIAFBAnQ1AqCVQiEKIARBAnQiB0EEayICQQJ2QQFqIgNBA3EhAQJAIAJBDEkEQCAAIQIMAQsgA0H8////B3EhAyAAIQIDQCACIAI1AgAgCn4gCXwiCD4CACACQQRqIgYgBjUCACAKfiAIQiCIfCIIPgIAIAJBCGoiBiAGNQIAIAp+IAhCIIh8Igg+AgAgAkEMaiIGIAY1AgAgCn4gCEIgiHwiCD4CACAIQiCIIQkgAkEQaiECIANBBGsiAw0ACwsgAQRAIAFBAnQhAwNAIAIgAjUCACAKfiAJfCIIPgIAIAJBBGohAiAIQiCIIQkgA0EEayIDDQALCyAAIAhCgICAgBBaBH8gBEEoRg0DIAAgB2ogCT4CACAEQQFqBSAECzYCoAEPCwJAIAFBCHEEQCAAKAKgASIEQSlPDQICQCAERQRAQQAhBAwBCyAEQQJ0IgZBBGsiAkECdkEBaiIDQQNxIQcCQCACQQxJBEBCACEIIAAhAgwBCyADQfz///8HcSEDQgAhCCAAIQIDQCACIAI1AgBC4esXfiAIfCIIPgIAIAJBBGoiBSAFNQIAQuHrF34gCEIgiHwiCD4CACACQQhqIgUgBTUCAELh6xd+IAhCIIh8Igg+AgAgAkEMaiIFIAU1AgBC4esXfiAIQiCIfCIJPgIAIAlCIIghCCACQRBqIQIgA0EEayIDDQALCyAHBEAgB0ECdCEDA0AgAiACNQIAQuHrF34gCHwiCT4CACACQQRqIQIgCUIgiCEIIANBBGsiAw0ACwsgCUKAgICAEFQNACAEQShGDQIgACAGaiAIPgIAIARBAWohBAsgACAENgKgAQsgAUEQcQRAIABByJXCAEECEPMCCyABQSBxBEAgAEHQlcIAQQMQ8wILIAFBwABxBEAgAEHclcIAQQUQ8wILIAFBgAFxBEAgAEHwlcIAQQoQ8wILIAFBgAJxBEAgAEGYlsIAQRMQ8wILIAAgARC5AxoPCwwBC0EAIARBKEGMg8IAEOoHAAtBKEEoQYyDwgAQjAcAC5oKAgl/Bn4jAEEgayIFJAACQAJAIAEtAAgiBkECRg0AIAIgASkDACIMNwMIIAVCADcDEAJAAkACQAJAAkACQCABKAKYASIDQQlJBEAgASkDGEJ/IAwgA618Ig4gDCAOVhtUDQQgASgClAEhCCACKAIEIgStIQ0gBEL/////DyAMIAxC/////w9aG6drIgdBACAEIAdPGyADTwRAIAIoAgAgDCANIAwgDVQbp2ohBCADQQFHBEAgA0UNAyAFQRBqIAQgA/wKAAAMAwsgBSAELQAAOgAQDAILQaiQyAApAwAiD0IIiCEQIA+nIQcgD0L/AYNCBFINAwwCC0EAIANBCEHMisEAEOoHAAtBBCEHCyAOIQ0LIAIgDTcDCAJAIAdB/wFxIgRBBEcEQCAFIAetQv8BgyAQQgiGhCINNwMYIBBCGIinIQMCfwJAAkAgBEEBaw4DAAEBBAsgEKcMAQsgAy0ACAtB/wFxQSVHDQEgBkEBcUUEQCAFQRhqEM4FDAQLIABBADYCACAAQgA3AwggBUEYahDOBQwGCyAIIAVBEGogAxDbBw0BIAIgDDcDCCABQQI6AAggACAMNwMQIABCATcDCCAAQQA2AgAMBQsgACANNwMIIABCgYCAgJCAgICAfzcDAAwECyAGQQFxDQELIAFBAjoACAwBCyAAQQA2AgAgAEIANwMIDAELAkACQAJAAkAgASkDoAEiDCABKQMQVA0AIAFBIGohCUGokMgAKQMAIg5C/wGDIREgDkIIiCEQIAEpAxghDSACKAIAIQogDqchBiACKAIEIgutIQ4DQCAMIA1aDQFCfyAMIAEoAqwBIgOtfCIPIAwgD1YbIg8gDFgNAQJAAkAgAgJ+AkACQAJAIA0gDyANIA9UGyAMfSIPpyIEIANNBEAgASgCqAEhByABKAKwAQ0FIAsgDCAOIAwgDlQbpyIDayAESQ0CIAMgCmohAyAEQQFGDQEgBARAIAcgAyAE/AoAAAtBBCEDDAMLQQAgBCADQbyKwQAQ6gcACyAHIAMtAAA6AABBBCEDDAELIAYhAyAOIBFCBFINARoLIA9C/////w+DIAx8CzcDCCADQf8BcSIDQQRHBEAgEEIYiKchASAQpyICIQQCQAJAAkAgA0EBaw4DAQACCgsgAS0ACCEECyAEQf8BcUElRg0FDAgLIAEtAAhBJUcNByABKAIAIQIgAUEEaigCACIDKAIAIgYEQCACIAYRAwALIAMoAgQiBgRAIAIgBiADKAIIEKIHCyABQQxBBBCiBwwEC0EAIQMgASgCsAFFDQELIAQgASgCtAEiA0kNAyADIAdqIQcgBCADayEECyAFQgE3AhggASgCmAEiCCAETQRAIAVBCGogCSAFQRhqIAcgBCABKAKUASAIIAEoAogBEQoAIAUoAghBAXENBAsgAUEANgKwAUJ/IAEpA6ABIg0gATUCrAEgCEEBayIDQQAgAyAITRutfXwiDCAMIA1UGyIMIAEpAxgiDVQEQCABIAw3A6ABIAwgASkDEFoNAQwCCwsgASANNwMQCyAAQgA3AwggAEEANgIADAMLIAMgBCAEQeCbyAAQ6gcACyAFKAIMIQYgAUEBNgKwASAAQgE3AwggASADIAZqIAhqNgK0ASACIAatIAwgA618fCINNwMIIAAgDTcDECAAQQA2AgAMAQsgACABNgIMIABBgYCAgHg2AgQgACACQQh0IANyNgIIIABBATYCAAsgBUEgaiQAC6MJAg5/AnsCQAJ/AkACQAJAIAEoAiAiESAETQRAIAMgBGoiECARayEKIAQgEUgEQCADIQIMAwsgECAGayEMIAH9AAQQIRUgAf0ABAAhFiABLQAlIQ0gAS0AJCEOIAZBBEkNASAGQQNxQQJrIRIgBSAGQXxxakECaiETIAMhAgNAAkAgAiAOav0AAAAgFv0jIAIgDWr9AAAAIBX9I/1O/WQiC0UNAANAIAUhByAGIQkgDCACIAtoIg9qIghJDQECQANAIAcoAAAgCCIUKAAARw0BIAhBBGohCCAHQQRqIQcgCUEEayIJQQNLDQALIAlBAUsEQCAHLwAAIAgvAABHDQEgFEEGaiEIIBIhCSATIQcLIAlFDQcgBy0AACAILQAARg0HCyALQQFrIAtxIgsNAAsLIAJBEGoiAiAKTQ0ACwwCCwJAIAQgBkkNACADIARqAkAgBkUEQAwBCyADIAZqIQQgAyEHA0AgBy0AACAIQQF0aiEIIAdBAWoiByAESQ0ACwsgASgCZCEEIAEoAmAhASAGayECIAMhBwNAAkAgASAIRw0AIAcgBSAGELsGRQ0AIAcgA2sMBgsgAiAHTQ0BIAYgB2otAAAgCCAEIActAABsa0EBdGohCCAHQQFqIQcMAAsAC0EAIQMMBAsCQCAGQQJPBEAgBkECRg0BIAMhAgNAAkAgAiAOav0AAAAgFv0jIAIgDWr9AAAAIBX9I/1O/WQiB0UNAANAIAwgAiAHaCIPaiIJSQ0BIAUvAAAgCS8AAEYEQCAFLQACIAktAAJGDQcLIAdBAWsgB3EiBw0ACwsgAkEQaiICIApNDQALDAILIAYEQCADIQIDQAJAIAIgDmr9AAAAIBb9IyACIA1q/QAAACAV/SP9Tv1kIgdFDQADQCAMIAIgB2giD2oiCUkNASAFLQAAIAktAABGDQYgB0EBayAHcSIHDQALCyACQRBqIgIgCk0NAAsMAgsgAyECA0AgAiAOav0AAAAgFv0jIAIgDWr9AAAAIBX9I/1O/WQiBwRAIAwgAiAHaCIPak8NBAsgAkEQaiICIApNDQALDAELIAMhAgNAAkAgAiAOav0AAAAgFv0jIAIgDWr9AAAAIBX9I/1O/WQiB0UNAANAIAwgAiAHaCIPaiIJSQ0BIAUvAAAgCS8AAEYNBCAHQQFrIAdxIgcNAAsLIAJBEGoiAiAKTQ0ACwtBACEDIAYgECACa0sgAiAQT3INAiAKIAEtACRq/QAAACAB/QAEAP0jIAogAS0AJWr9AAAAIAH9AAQQ/SP9Tv1kQX8gAiAKa3RxIgtFDQIgECAGayEBIAZBBEkhAgJAA0AgCiALaCISaiIHIAFLDQQgBiEJIAUhCAJAIAJFBEADQCAIKAAAIAcoAABHDQIgB0EEaiEHIAhBBGohCCAJQQRrIglBA0sNAAsLIAlBAUsEQCAILwAAIAcvAABHDQEgCUECayEJIAhBAmohCCAHQQJqIQcLIAlFDQIgCC0AACAHLQAARg0CCyALQQFrIAtxIgsNAAsMAwsgEiAEIBFragwBCyACIANrIA9qCyEHQQEhAwsgACAHNgIEIAAgAzYCAAv7CQIHfwR9IwBBsAFrIgUkAAJ/AkAgASgCCCIGIAJLBEAgASgCBCACQRhsaiIGQRFqLwAAIAZBE2otAAAiB0EQdHIiCEEIdiEJQwAAEEEgASoCSCABLQBYQQJGIgobIQ1DAABAwSABKgJEIAobIQwgCEH/AXEEQCAMIA0gDJNDAAB+Q5UgCEEBa0H/AXGzlJIQiQQhDgsgCUH/AXEEQCAMIA0gDJNDAAB+Q5UgCUEBa0H/AXGzlJIQiQQhDwsgBwR9IAwgDSAMk0MAAH5DlSAHQQFrQf8BcbOUkhCJBAVDAAAAAAshDCAOIA+UQ4/CzT8QtwohDSAOIAyUQ4/CzT8QtwohDiAPIAyUQ4/CzT8QtwogDSAOkpJDAABAQJVD5kAfPxC3CkPbD0lBlCEMIAZBDGovAQAiB0H//wFxRQRAIAdBEHQMAwsgB0H/B3EhBiAHQYCAAnEhCCAHQYD4AXEiB0GA+AFGBEAgCEEQdCIHQYCAgPwHciAGRQ0DGiAHIAZBDXRyQYCAgP4HcgwDCyAIQRB0IQggB0UNASAHQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2ogCHIMAgsgAiAGQdy7xwAQjAcACyAGIAZnQRBrIgZB//8DcUEIanRB////A3EgCEGAgIDYA3IgBkEXdGtyCyEGIAVBCGogASgCECIJIAEoAhQiCiACEOcCIAwgBr6UIQ0CQAJ/AkACQCAFKAIsIgZBCU8EQCAFKAIMIgdFDQEgBUEANgIwIAVBADYCVCAFKAIQDAMLIAYNAQsgAEEBNgIoIAAgAjYCCCAAQQA2AgQgACANOAIADAILIAVBADYCMCAFQQA2AlQgBiEHIAVBDGoLIQggB0ECdCELIAVBiAFqIQdDAACA/yEMA0AgBUGEAWogASAIKAIAIAMgBBD3ASAFQeAAaiAHQQhq/QACAP0LAwAgBUHwAGogB0EYav0AAgD9CwMAIAUgBykCADcDWCAIQQRqIQggBSoChAEhDiAFQTBqIAVB2ABqEP8BIAwgDhDgCCEMIAtBBGsiCw0ACyADKAIIIQECQAJAAkACQAJAIAQgDJQgDV8EQCABIAJNDQEgAygCBCACakEBOgAACyABIAJNDQEgAygCBCACai0AAEUEQCAJIAogAkEEQQAQ1AIgACAMOAIAIABBJGogBUHQAGopAgA3AgAgAEEUaiAFQUBr/QACAP0LAgAgACAF/QACMP0LAgQMBgsgCSAKIAIgBSgCVCIIQQlJBH8gBUE0agUgBSgCNCIIQYCABE8NAyAFKAI4CyAIENQCIABBATYCKCAAIAI2AgggAEEANgIEIAAgDTgCACAFKAJUIgBBCUkNBSAFKAI4IgFBBGsoAgAiAkF4cSIDIABBAnQiAEEEQQggAkEDcSICG2pJDQMgAkEAIAMgAEEnaksbDQQgARCiAgwFCyACIAFB7OrBABCMBwALIAIgAUH86sEAEIwHAAtBjOvBAEEtQbzrwQAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsCQAJAIAZBCU8EQCAFKAIQIgBBBGsoAgAiAUF4cSICIAZBAnQiA0EEQQggAUEDcSIBG2pJDQEgAUEAIAIgA0EnaksbDQIgABCiAgsgBUGwAWokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6UKAgZ/AX4jAEHgAGsiByQAIAAoAgQhCyAAKAIAIQggB0EANgIMAn8CQCAILQAQQQFHDQAgCCgCACEJAkACQAJAIAtFBEAgByAIQQxqrUKAgICAEIQ3A0AgCUEEaigCACEKIAkoAgAgB0EBNgIkIAdB8PjHADYCICAHQQE2AhwgB0ECNgIUIAdB4PjHADYCECAHIAdBQGsiDDYCGCAKIAdBEGoQwQMNAiAILQAQQQFHDQEgCCgCACEJIAdCgICAgKABNwNIIAcgB0EMaq1CgICAgMAFhDcDQCAJQQRqKAIAIQogCSgCACAHQQE2AiQgB0Go+McANgIgIAdBAjYCHCAHQQI2AhQgB0GM+ccANgIQIAcgDDYCGCAKIAdBEGoQwQMNAgwBCyAJKAIAQZz5xwBBBiAJQQRqKAIAKAIMEQAADQEgCC0AEEEBRw0AIAgoAgAhCSAHQoCAgIDQATcDSCAHQqD4x4CgATcDQCAJQQRqKAIAIQogCSgCACAHQQE2AiQgB0Go+McANgIgIAdBAjYCHCAHQQE2AhQgB0Gg+McANgIQIAcgB0FAazYCGCAKIAdBEGoQwQMNAQsCQAJAIAEoAgBBA0cEQEKAgICA0AUhDSAILQAQRQ0BIAdBMGogAUEgaikCADcDACAHQSBqIAFBEGr9AAIA/QsDACAHIAH9AAIA/QsDECAIKAIAIQEgByANIAdBEGqthDcDOCABQQRqKAIAIQkgASgCACAHQgE3AkwgB0EBNgJEIAdBoPjHADYCQCAHIAdBOGo2AkggCSAHQUBrEMEDRQ0CDAMLIAgoAgAiASgCAEGi+ccAQQkgAUEEaigCACgCDBEAAA0CDAELIAdBMGogAUEgaikCADcDACAHQSBqIAFBEGr9AAIA/QsDACAHIAH9AAIA/QsDECAIKAIAIQEgByANIAdBEGqthDcDOCABQQRqKAIAIQkgASgCACAHQQE2AlQgB0Gs+ccANgJQIAdBATYCTCAHQQE2AkQgB0Gg+McANgJAIAcgB0E4ajYCSCAJIAdBQGsQwQMNAQsgCCgCACIBKAIAQdz4xwBBASABKAIEKAIMEQAADQAgA0EBcUUgAigCAEECRnINAiAHIAQ2AlwCQCAILQAQQQFGBEAgCCgCACEBIAdCgICAgKABNwNIIAdCoPjHgKABNwNAIAFBBGooAgAhAyABKAIAIAdBATYCJCAHQaj4xwA2AiAgB0ECNgIcIAdBATYCFCAHQaD4xwA2AhAgByAHQUBrNgIYIAMgB0EQahDBAw0BCyAIKAIAIgEoAgBBwPjHAEEQIAFBBGooAgAoAgwRAAANACAIKAIEIAgoAgghAyAHQRxqIAJBCGooAgA2AgAgByAIKAIAIgQ2AhAgByACKQIANwIUIAQgB0EUaiADKAIQEQAADQAgCCgCACEBIAdCgICAgBAiDSAHQdwAaq2ENwNAIAFBBGooAgAhAiABKAIAIAdCATcCHCAHQQE2AhQgB0HU+McANgIQIAcgB0FAayIDNgIYIAIgB0EQahDBAw0AIAVBAXFFDQIgByAGNgI4IAgoAgAhASAHIA0gB0E4aq2ENwNAIAFBBGooAgAhAiABKAIAIAdCATcCHCAHQQE2AhQgB0HU+McANgIQIAcgAzYCGCACIAdBEGoQwQNFDQILQQEMAwtBAQwCC0EBIAgoAgAiAigCAEHc+McAQQEgAkEEaigCACgCDBEAAA0BGgsgACALQQFqNgIEQQALIAdB4ABqJAAL7gsCCH8FewJAAkACQCACIANPBEAgA0UNAiABIANqIQUgA0EPTQRAA0AgASAFTw0EIAVBAWsiBS0AAEEKRw0ADAMLAAsgBUEQayIE/QAAAP0MCgoKCgoKCgoKCgoKCgoKCiIM/SP9ZCIGBEAgBCAGZ0Efc2ohBQwCCwJAAkACQAJAAkAgA0HAAEkgAyAFQQ9xayIFQcAASXINAANAIAEgBWoiBEEwayIG/QAEACAM/SMiDSAEQUBqIgj9AAQAIAz9IyIO/VAgBEEgayIH/QAEACAM/SMiD/1QIARBEGsiBP0ABAAgDP0jIhD9UP1kRQRAIAVBQGoiBUFAa0GAAU8NAQwCCwsgEP1kIgUNAyAP/WQiBA0EIA39ZCIEDQEgCCAO/WRna0EfaiEFDAYLA0AgBUEPTARAQQAhByAFQQBKDQNBACEEDAkLIAEgBUEQayIFaiIE/QAAACAM/SP9ZCIGRQ0ACyAEIAZnQR9zaiEFDAULIAYgBGdBH3NqIQUMBAtBACEEIAH9AAAAIAz9I/1kIgVFDQUgASAFZ2tBH2ohBQwDCyAEIAVnQR9zaiEFDAILIAcgBGdBH3NqIQUMAQtBACADIAJB6JzGABDqBwALIAUgAWsiCUEBaiEHIAIgCUsEQCABIAdqIgogAU0EQEEAIQQMAwsgCUEOTQRAQQAhBAJAIAlBA0kEQCABIQUMAQsgASAHQRxxIgJqIQX9DAAAAAAAAAAAAAAAAAAAAAAhDCACIQQDQCAMIAH9XAAA/QwKCgoKCgoKCgoKCgoKCgoK/SMgDP0NAAAAAAEAAAACAAAAAwAAAP0MAQAAAAEAAAABAAAAAQAAAP1O/a4BIQwgAUEEaiEBIARBBGsiBA0ACyAMIAwgDP0NCAkKCwwNDg8AAQIDAAECA/2uASIMIAwgDP0NBAUGBwABAgMAAQIDAAECA/2uAf0bACEEIAIgB0YNBAsDQCAEIAUtAABBCkZqIQQgBUEBaiIFIApHDQALDAMLQQAhAgJAAkAgAUFwcUEQaiIEIAFBAWoiBiAEIAZLGyABayILQQRJBEAgASEGDAELIAEgC0F8cSIIaiEG/QwAAAAAAAAAAAAAAAAAAAAAIQwgCCECA0AgDCAB/VwAAP0MCgoKCgoKCgoKCgoKCgoKCv0jIAz9DQAAAAABAAAAAgAAAAMAAAD9DAEAAAABAAAAAQAAAAEAAAD9Tv2uASEMIAFBBGohASACQQRrIgINAAsgDCAMIAz9DQgJCgsMDQ4PAAECAwABAgP9rgEiDCAMIAz9DQQFBgcAAQIDAAECAwABAgP9rgH9GwAhAiAIIAtGDQELA0AgAiAGLQAAQQpGaiECIAZBAWoiBiAESQ0ACwsCQCAJQT9JDQAgBCAKQUBqIgFLDQADQCAE/QAEAP0MCgoKCgoKCgoKCgoKCgoKCiIM/SP9ZGkgAmogBEEQav0ABAAgDP0j/WRpaiAEQSBq/QAEACAM/SP9ZGlqIARBMGr9AAQAIAz9I/1kaWohAiAEQUBrIgQgAU0NAAsLIApBEGsiASAETwRAA0AgBP0AAAD9DAoKCgoKCgoKCgoKCgoKCgr9I/1kaSACaiECIARBEGoiBCABTQ0ACwtBACEGAkAgBCAKTw0AAkAgBSAEa0EBaiIJQQRJBEAgBCEBDAELIAQgCUF8cSIIaiEB/QwAAAAAAAAAAAAAAAAAAAAAIQwgCCEFA0AgDCAE/VwAAP0MCgoKCgoKCgoKCgoKCgoKCv0jIAz9DQAAAAABAAAAAgAAAAMAAAD9DAEAAAABAAAAAQAAAAEAAAD9Tv2uASEMIARBBGohBCAFQQRrIgUNAAsgDCAMIAz9DQgJCgsMDQ4PAAECAwABAgP9rgEiDCAMIAz9DQQFBgcAAQIDAAECAwABAgP9rgH9GwAhBiAIIAlGDQELA0AgBiABLQAAQQpGaiEGIAFBAWoiASAKRw0ACwsgAiAGaiEEDAILQQAgByACQdicxgAQ6gcACwsgACADIAdrNgIEIAAgBEEBajYCAAvFCQIJfwV9QwAAgD8hDgJ/AkAgASgCACIHIAJBBGooAgAiBEEIaigCACIFSQRAIAFBBGsiCSgCACEBIARBBGooAgAiCCAHQSRsaiIEEIoEIQwgBC8BFCIDQf//AXFFBEAgA0EQdAwDCyADQf8HcSEEIANBgIACcSEGIANBgPgBcSIDQYD4AUYEQCAGQRB0IQMgA0GAgID8B3IgBEUNAxogAyAEQQ10ckGAgID+B3IMAwsgBkEQdCEGIANFDQEgA0ENdEGAgID8AHEgBEENdHJBgICAwANqIAZyDAILIAcgBUHUwMcAEIwHAAsgBkGAgIDYA3IgBGdBEGsiA0EXdGsgBCADQf//A3FBCGp0Qf///wNxcgu+Ig1DAACAP14EQCANEMYFQ1T4LUCUQwAAgD+SkSEOC0MAAIA/IQ0CfwJAIAEgBUkEQCAIIAFBJGxqIgQQigQhDyAELwEUIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQQgA0GAgAJxIQUgA0GA+AFxIgNBgPgBRgRAIAVBEHQhAyADQYCAgPwHciAERQ0DGiADIARBDXRyQYCAgP4HcgwDCyAFQRB0IQUgA0UNASADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIMAgsgASAFQdTAxwAQjAcACyAFQYCAgNgDciAEZ0EQayIDQRd0ayAEIANB//8DcUEIanRB////A3FyC74iEEMAAIA/XgRAIBAQxgVDVPgtQJRDAACAP5KRIQ0LIAwgDJIgDpQiDCAMXCAMIA8gD5IgDZRgckUEQCACQQRqIQggB0EkbCEKA0ACQCAJIgJBBGogATYCACAAIAJGDQBDAACAPyEOAn8CQCAIKAIAIgRBCGooAgAiBSAHSwRAIAJBBGsiCSgCACEBIARBBGooAgAiCyAKaiIEEIoEIQwgBC8BFCIDQf//AXFFBEAgA0EQdAwDCyADQf8HcSEEIANBgIACcSEGIANBgPgBcSIDQYD4AUYEQCAGQRB0IQMgA0GAgID8B3IgBEUNAxogAyAEQQ10ckGAgID+B3IMAwsgBkEQdCEGIANFDQEgA0ENdEGAgID8AHEgBEENdHJBgICAwANqIAZyDAILIAcgBUHUwMcAEIwHAAsgBkGAgIDYA3IgBGdBEGsiA0EXdGsgBCADQf//A3FBCGp0Qf///wNxcgu+Ig1DAACAP14EQCANEMYFQ1T4LUCUQwAAgD+SkSEOC0MAAIA/IQ0CfwJAIAEgBUkEQCALIAFBJGxqIgQQigQhDyAELwEUIgNB//8BcUUEQCADQRB0DAMLIANB/wdxIQQgA0GAgAJxIQUgA0GA+AFxIgNBgPgBRgRAIAVBEHQhAyADQYCAgPwHciAERQ0DGiADIARBDXRyQYCAgP4HcgwDCyAFQRB0IQUgA0UNASADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIMAgsgASAFQdTAxwAQjAcACyAFQYCAgNgDciAEZ0EQayIDQRd0ayAEIANB//8DcUEIanRB////A3FyC74iEEMAAIA/XgRAIBAQxgVDVPgtQJRDAACAP5KRIQ0LIAwgDJIgDpQiDCAMXA0AIAwgDyAPkiANlGBFDQELCyACIAc2AgALC/YIAg9/AX0jAEEgayIIJAACQAJAAkACQAJAAkAgAC0AuAFBAUcNACAAKAKsASAAKAKwASIFQQJ0IAAoArQBIgYgBWpBAnQQ4QghBSAGQQJ0IgYgACgCZCIHSw0BIAAoAmAhByAIIAUQuAoiCTYCACAIIAY2AgQgBiAJRw0FIAUgByAGEOAJIAVBhAhJDQAgBRCbBwsgAEIANwKwASAAQbgBakEAOgAAAkACQAJAAkACQAJAAkACQAJAAkAgACgCAEUNACAAKAIEIAFBAXQgASACakEBdBDhCCEJAkAgAkECdCIHIAAoAmQiBk0EQCAAIAc2AmQgAkEBdCEFIAAoAmAhAQwBCyAHIAYiBWsiCiAAKAJcIAVrSwRAIABB3ABqIAUgCkEEQQQQpAUgACgCZCEFCyAAKAJgIgEgBUECdCIMaiELIApBAk8EQCAHIAZBf3NqQQJ0IgcEQCALQQAgB/wLAAsgAkEEdCAGQQJ0ayABaiAMakEEayELIAUgCmpBAWshBQsgC0EANgIAIAAgBUEBaiIHNgJkIAJBAXQiBSAHSw0MCyAIIAkQuAoiBjYCACAIIAU2AgQgBSAGRw0OIAEgBSAJEOEJIAJBCWwhCiAEQQluQQlsIQsgBEEBa0EJbkEJbEEJaiEMIARBAmtBCW5BCWxBCWohDSAEQQNrQQluQQlsQQlqIQ4gBEEEa0EJbkEJbEEJaiEPIARBBWtBCW5BCWxBCWohECAEQQZrQQluQQlsQQlqIREgBEEHa0EJbkEJbEEJaiESIARBCGtBCW5BCWxBCWohE0MAAHxCIAAqApABlSEUQQAhBUEAIQADQCAFIAdPDQ0gBUEBaiICIAdPDQ4gACAMRg0KIAFBBGooAgAhAiADIAEoAgAiBkEZdEEZdbIgFJU4AgAgACANRg0JIANBBGogBkESdEEZdbIgFJU4AgAgACAORg0IIANBCGogBkELdEEZdbIgFJU4AgAgACAPRg0HIANBDGogBkEEdEEZdbIgFJU4AgAgACAQRg0GIANBEGogAkEddCAGQQN2ckEZdbIgFJU4AgAgACARRg0FIANBFGogAkEWdEEZdbIgFJU4AgAgACASRg0EIANBGGogAkEPdEEZdbIgFJU4AgAgACATRg0DIANBHGogAkEIdEEZdbIgFJU4AgAgACALRg0CIANBIGogAkEBdEEZdbIgFJU4AgAgAUEIaiEBIAVBAmohBSADQSRqIQMgCiAAQQlqIgBHDQALIAlBhAhJDQAgCRCbBwsgCEEgaiQADwsgAEEIaiEADAcLIABBB2ohAAwGCyAAQQZqIQAMBQsgAEEFaiEADAQLIABBBGohAAwDCyAAQQNqIQAMAgsgAEECaiEADAELIABBAWohAAsgACAEQbzTwAAQjAcAC0EAIAYgB0H868AAEOoHAAtBACAFIAdBzNPAABDqBwALIAUgB0Gc08AAEIwHAAsgAiAHQazTwAAQjAcACyAIQQA2AghBACAIIAhBBGogCEEIakHg+cQAEPUHAAvbCQIGfwR+IwBBwAFrIgIkAAJAAkACQCAAKQMAQgJSBEAgACgCqAEhASAAQQA2AqgBAkACQAJAAkAgAUEBaw4CAQIACyACQQhqIQMCQAJAQSUQcSIBRQ0AIAFBHWpBnZ3HACkAADcAACABQRBqQZCdxwD9AAAA/QsAACABQYCdxwD9AAAA/QsAAEEMEHEiBEUNACAEQSU2AgggBCABNgIEIARBJTYCAEEMEHEiAUUNACABQSg6AAggAUHsisEANgIEIAEgBDYCACADQQA2AhAgAyABrUIghkIDhDcDAAwBCwALDAILIAJBGGogAEHAAWopAwA3AwAgAiAA/QADsAH9CwMIDAELIAAoAqwBIgFBQGshAyABKAIkIQQgASgCICEFAkAgASkDGCIHQgJSBEAgASkDOCEIIAJBMGogAUEQaikDADcDACACQegAaiADQQhq/QADAP0LAwAgAkGoAWogAUGIAWr9AAMA/QsDACACQZgBaiABQfgAav0AAwD9CwMAIAJBuAFqIAFBmAFqKQMANwMAIAIgAf0AAwD9CwMgIAIgAf0AAyj9CwNIIAIgAykDADcDYCACIAH9AANY/QsDeCACIAH9AANo/QsDiAEgAkEYaiACQdAAaikDADcDACACIAQ2AkQgAiAFNgJAIAIgBzcDOCACIAg3A1ggAiAC/QADQP0LAwggAigCJCEEIAIoAiAhBSACQfgAahCEBQwBCyACQRhqIANBEGopAwA3AwAgAiAD/QADAP0LAwgLIAQEQCAFQQRrKAIAIgNBeHEiBkEEQQggA0EDcSIDGyAEakkNBCADQQAgBiAEQSdqSxsNBSAFEKICCyABQQRrKAIAIgRBeHFBvAFBwAEgBEEDcSIDG0kNAyADQQAgBEHgAU8bDQQgARCiAgsCQCACKAIYIgEEQCACKQMQIghQDQEgASkDCCEHIAEoAgQiBK0hCQNAAkAgByAEIAcgCSAHIAlUG6ciA2siBUKAwAAgCCAIQoDAAFobpyIGIAUgBkkbrSIKfCEHIAMgBEYNACAIIAp9IghCAFINAQsLIAEgBzcDCCAAEOoDDAMLIAItAAhBA0cNACACKAIMIgEoAgAhBCABQQRqKAIAIgMoAgAiBQRAIAQgBREDAAsgAygCBCIDBEAgBEEEaygCACIFQXhxIgZBBEEIIAVBA3EiBRsgA2pJDQQgBUEAIAYgA0EnaksbDQUgBBCiAgsgAUEEaygCACIEQXhxIgNBEEEUIARBA3EiBBtJDQMgBEEAIANBNE8bDQQgARCiAgsgABDqAwwBCyAAKAKoAUECSQ0AAkAgACgCrAEiACkDGEICUQRAIAAoAiQiAUUNASAAKAIgIgRBBGsoAgAiA0F4cSIFQQRBCCADQQNxIgMbIAFqSQ0DIANBACAFIAFBJ2pLGw0EIAQQogIMAQsgACgCBCIBBEAgACgCACIEQQRrKAIAIgNBeHEiBUEEQQggA0EDcSIDGyABakkNAyADQQAgBSABQSdqSxsNBCAEEKICCyAAQdgAahCEBQsgAEEEaygCACIBQXhxQbwBQcABIAFBA3EiBBtJDQEgBEEAIAFB4AFPGw0CIAAQogILIAJBwAFqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvrCAIOfwF9IwBBEGsiBiQAAkACQCADQQNsIgdB/////wNLDQAgA0EMbCIEQf3///8HTw0AAkAgBEUEQEEEIQpBACEHDAELIAQQcSIKRQ0CCyAGQQA2AgwgBiAKNgIIIAYgBzYCBAJ/AkACQAJAAkACQCADBEAgASADQQF0Ig5qIQ8gASADQQJ0IhBqIRFBACEHIAMhDUEIIQsDQCACIAdNBEAgByEEDAQLIAdBAWogAk8NBCAGKAIEIQwCfyABIAdqIgRBAWotAABBCHQiCCAELQAAciIEQf//AXEEQCAEQf8HcSEEIAhBgIACcSEFIAhBgPgBcSIIQYD4AUcEQCAFQRB0IgUgCEENdEGAgID8AHEgBEENdHJBgICAwANqciAIDQIaIAVBgICA2ANyIARnQRBrIghBF3RrIAQgCEH//wNxQQhqdEH///8DcXIMAgsgBUEQdCIIIARBDXRyQYCAgP4HciAEDQEaIAhBgICA/AdyDAELIARBEHQLvhCJBCESIAkgDEYEQCAGQQRqQfzoxwAQ+gUgBigCCCEKCyAKIAtqQQhrIBI4AgAgBiAJQQFqIgg2AgwgByAOaiIEIAJPDQMgBEEBaiACTw0FIAYoAgQhDAJ/IAcgD2oiBEEBai0AAEEIdCIFIAQtAAByIgRB//8BcQRAIARB/wdxIQQgBUGAgAJxIQkgBUGA+AFxIgVBgPgBRwRAIAlBEHQiCSAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2pyIAUNAhogCUGAgIDYA3IgBGdBEGsiBUEXdGsgBCAFQf//A3FBCGp0Qf///wNxcgwCCyAJQRB0IgUgBEENdHJBgICA/gdyIAQNARogBUGAgID8B3IMAQsgBEEQdAu+EIkEIRIgCCAMRgRAIAZBBGpB/OjHABD6BSAGKAIIIQoLIAogC2pBBGsgEjgCACAGIAhBAWoiCDYCDCAHIBBqIgQgAk8NAiAEQQFqIAJPDQYgBigCBCEMAn8gByARaiIEQQFqLQAAQQh0IgUgBC0AAHIiBEH//wFxBEAgBEH/B3EhBCAFQYCAAnEhCSAFQYD4AXEiBUGA+AFHBEAgCUEQdCIJIAVBDXRBgICA/ABxIARBDXRyQYCAgMADanIgBQ0CGiAJQYCAgNgDciAEZ0EQayIFQRd0ayAEIAVB//8DcUEIanRB////A3FyDAILIAlBEHQiBSAEQQ10ckGAgID+B3IgBA0BGiAFQYCAgPwHcgwBCyAEQRB0C74QiQQhEiAIIAxGBEAgBkEEakH86McAEPoFIAYoAgghCgsgCiALaiASOAIAIAYgCEEBaiIJNgIMIAdBAmohByALQQxqIQsgDUEBayINDQALCyAAIAYpAgQ3AgAgAEEIaiAGQQxqKAIANgIAIAZBEGokAA8LIANBAnQgB2ohBAsgBCACQdzoxwAQjAcACyAHQQFqDAILIARBAWoMAQsgA0ECdCAHakEBagsgAkHs6McAEIwHAAtBzOjHABD/BwsAC/YIARN/IwBBEGsiByQAAkACQCADQQNsIgxB/////wNLDQAgA0EMbCIEQf3///8HTw0AAkAgBEUEQEEEIQoMAQsgDCELIAQQcSIKRQ0CCyAHQQA2AgwgByAKNgIIIAcgCzYCBAJAAkACQAJAAkAgAwRAIAIgA2siBEEAIAIgBE8bIQ0gAiAMayIEQQAgAiAETxshDiABIANqIQ8gASAMaiEQIAEgA0ECdCIRaiESIAEgA0EFbCITaiEUIAEgA0EBdCIVaiEWQQghCwNAIAIgBkYEQCAGIQQMBwsgBiAORg0FAn8gBiAQai0AAEEIdCIFIAEgBmotAAByIgRB//8BcQRAIARB/wdxIQQgBUGAgAJxIQggBUGA+AFxIgVBgPgBRwRAIAhBEHQhCCAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogCHIgBQ0CGiAIQYCAgNgDciAEZ0EQayIFQRd0ayAEIAVB//8DcUEIanRB////A3FyDAILIAhBEHQhBSAEQQ10IAVyQYCAgP4HciAEDQEaIAVBgICA/AdyDAELIARBEHQLIQQgBygCBCAJRgRAIAdBBGpBvOrHABD6BSAHKAIIIQoLIAogC2pBCGsgBDYCACAHIAlBAWoiCTYCDCAGIA1GDQMgBiARaiACTw0CAn8gBiASai0AAEEIdCIFIAYgD2otAAByIgRB//8BcQRAIARB/wdxIQQgBUGAgAJxIQggBUGA+AFxIgVBgPgBRwRAIAhBEHQhCCAFQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogCHIgBQ0CGiAIQYCAgNgDciAEZ0EQayIFQRd0ayAEIAVB//8DcUEIanRB////A3FyDAILIAhBEHQhBSAEQQ10IAVyQYCAgP4HciAEDQEaIAVBgICA/AdyDAELIARBEHQLIQQgBygCBCAJRgRAIAdBBGpBvOrHABD6BSAHKAIIIQoLIAogC2pBBGsgBDYCACAHIAlBAWoiCTYCDCAGIBVqIgQgAk8NBiAGIBNqIAJPDQQCfyAGIBRqLQAAQQh0IgUgBiAWai0AAHIiBEH//wFxBEAgBEH/B3EhBCAFQYCAAnEhCCAFQYD4AXEiBUGA+AFHBEAgCEEQdCEIIAVBDXRBgICA/ABxIARBDXRyQYCAgMADaiAIciAFDQIaIAhBgICA2ANyIARnQRBrIgVBF3RrIAQgBUH//wNxQQhqdEH///8DcXIMAgsgCEEQdCEFIARBDXQgBXJBgICA/gdyIAQNARogBUGAgID8B3IMAQsgBEEQdAshBCAHKAIEIAlGBEAgB0EEakG86scAEPoFIAcoAgghCgsgCiALaiAENgIAIAcgCUEBaiIJNgIMIAtBDGohCyADIAZBAWoiBkcNAAsLIAAgBykCBDcCACAAQQhqIAdBDGooAgA2AgAgB0EQaiQADwsgA0ECdCAGaiEEDAMLIAMgBmohBAwCCyADQQVsIAZqIQQMAQsgBiAMaiEECyAEIAJBzOrHABCMBwALQazqxwAQ/wcLAAuYCQINfwF+IwBB8ABrIgIkAEEIIQQgASgCBCEFIAFBBEEkIAEoAiQiA0EISyIGG2pBADYCACACQRhqIAFBCGr9AAIA/QsDACACQShqIAFBGGr9AAIA/QsDACACQQA2AjggAiAFIAMgBhsiCDYCPCACIAEpAgA3AxAgAEEkaiELAkACQAJAAkACQAJAIAggACgCJCIBQQggAUEISyIGGyAAKAIEIAEgBhsiBmtLBEACQAJAIAYgCGoiASAGSQ0AQX8gAUEBa2d2QQAgAUECTxsiAUF/Rg0AIAJBCGogACABQQFqEOgDIAIoAggiAUGBgICAeEYNASABDQMLQdiVxwBBEUHUzMcAEOsHAAsgCygCACEBCyAAQQRqIgYhDCALIQkgAUEJTwRAIAAoAgghDCAGIQkgASEECwJAAkACQAJAIAQgCSgCACIFTQRAIAUhBAwBCyACKAIYIQogAigCNCIOQQhNBEAgAkEQakEEciEDIAUgBGshDSAMIAVBAnRqIQdBACEBA0AgASAIRg0DIAIgAUEBaiIBNgI4IAcgAygCADYCACADQQRqIQMgB0EEaiEHIAEgDWoNAAsMAQsgCEUNA0EAIQECQCAEQQFrIg0gBWsiBCAIQQFrIgMgAyAESxsiBEEESQ0AIAVBAnQgDGoiAyAKa0EQSQ0AIAohByAEQQFqIgEgAUEDcSIBQQQgARtrIgEhBANAIAMgB/0AAgD9CwIAIAdBEGohByADQRBqIQMgBEEEayIEDQALIAEgBWohBQsgDCAFQQJ0aiEDIAogAUECdGohBwNAAkAgAyAHKAIANgIAIAVBAWohBCABQQFqIQEgBSANRg0AIANBBGohAyAHQQRqIQcgBCEFIAEgCEcNAQwECwsgAiABNgI4CyAJIAQ2AgAgAkHoAGogAkE4aikDACIPNwMAIAJB4ABqIAJBMGopAwA3AwAgAkHQAGogAkEgav0AAwD9CwMAIAIgAv0AAxD9CwNAIA+nIgEgAigCbEcEQCACQUBrQQRyIQQDQCACIAFBAWo2AmggBCEDIAIoAmRBCU8EfyACKAJIBSADCyABQQJ0aigCACEJAn8gCygCACIHQQlJBEAgByEBIAYhBUEIIQcgCwwBCyAAKAIEIQEgACgCCCEFIAYLIQMgASAHRgR/IAAQzQYgACgCCCEFIAYhAyAAKAIEBSABC0ECdCAFaiAJNgIAIAMgAygCAEEBajYCACACKAJoIgEgAigCbEcNAAsLIAIoAmQiAUEJSQ0IIAIoAkgiA0EEaygCACIAQXhxIgYgAUECdCIBQQRBCCAAQQNxIgAbakkNBCAAQQAgBiABQSdqSxsNBSADEKICDAgLIAEgBWohBAsgCSAENgIAIA5BCUkNBgsgCkEEaygCACIAQXhxIgYgDkECdCIBQQRBCCAAQQNxIgAbakkNAyAAQQAgBiABQSdqSxsNBCAKEKICDAULAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyACQfAAaiQAC6YNAwZ/BHsCfSABKgIAIRMgACoCACESAkACQAJAAkACQAJAAkACQEGACBBxIg1FDQAgEyASk/0TIQ8gEv0TIRD9DAAAAAABAAAAAgAAAAMAAAAhDgNAIAggDWoiCiAQIA8gDv37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kAf0Mu26QPrtukD67bpA+u26QPv3mAf0MAAAAPwAAAD8AAAA/AAAAP/3kAf0LAgAgCkEQaiAQIA8gDv0MBAAAAAQAAAAEAAAABAAAAP2uAf37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kAf0Mu26QPrtukD67bpA+u26QPv3mAf0MAAAAPwAAAD8AAAA/AAAAP/3kAf0LAgAgDv0MCAAAAAgAAAAIAAAACAAAAP2uASEOIAhBIGoiCEGACEcNAAsgASoCBCAAKgIEIRJBgAgQcSIKRQ0AIBKT/RMhDyAS/RMhEP0MAAAAAAEAAAACAAAAAwAAACEOQQAhCANAIAggCmoiCyAQIA8gDv37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kAf0Mu26QPrtukD67bpA+u26QPv3mAf0MAAAAPwAAAD8AAAA/AAAAP/3kAf0LAgAgC0EQaiAQIA8gDv0MBAAAAAQAAAAEAAAABAAAAP2uAf37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kAf0Mu26QPrtukD67bpA+u26QPv3mAf0MAAAAPwAAAD8AAAA/AAAAP/3kAf0LAgAgDv0MCAAAAAgAAAAIAAAACAAAAP2uASEOIAhBIGoiCEGACEcNAAsgASoCCCAAKgIIIRJBgAgQcSILRQ0AIBKT/RMhDyAS/RMhEP0MAAAAAAEAAAACAAAAAwAAACEOQQAhCANAIAggC2oiDCAQIA8gDv37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kAf0Mu26QPrtukD67bpA+u26QPv3mAf0MAAAAPwAAAD8AAAA/AAAAP/3kAf0LAgAgDEEQaiAQIA8gDv0MBAAAAAQAAAAEAAAABAAAAP2uAf37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kAf0Mu26QPrtukD67bpA+u26QPv3mAf0MAAAAPwAAAD8AAAA/AAAAP/3kAf0LAgAgDv0MCAAAAAgAAAAIAAAACAAAAP2uASEOIAhBIGoiCEGACEcNAAsgASoCDCAAKgIMIRJBgAgQcSIBRQ0AIBKT/RMhECAS/RMhEf0MAAAAAAEAAAACAAAAAwAAACEOQQAhCANAIAEgCGr9DAAAgD8AAIA/AACAPwAAgD/9DAAAgD8AAIA/AACAPwAAgD8gESAQIA79+wH9DAAAf0MAAH9DAAB/QwAAf0P95wH95gH95AH94QEiD/0fABCJBP0TIA/9HwEQiQT9IAEgD/0fAhCJBP0gAiAP/R8DEIkE/SAD/eQB/ecB/QsCACAO/QwEAAAABAAAAAQAAAAEAAAA/a4BIQ4gCEEQaiIIQYAIRw0ACyAHRQ0HQQAhAEEAIQgDQCADIAhNBEAgCCADQZDwxwAQjAcACyAAIAVPDQIgBCANIAIgCGoiDC0AAEECdGoqAgA4AgAgCEEBaiIJIANPDQMgAEEBaiIJIAVPDQQgBEEEaiAKIAxBAWotAABBAnRqKgIAOAIAIAhBAmoiCSADTw0FIABBAmoiCSAFTw0GIARBCGogCyAMQQJqLQAAQQJ0aioCADgCACAIQQNqIgkgA08NByAGIAhqIAEgDEEDai0AAEECdGoqAgA4AgAgBEEMaiEEIABBA2ohACAIQQRqIQggB0EBayIHDQALDAcLAAsgACAFQaDwxwAQjAcACyAJIANBsPDHABCMBwALIAkgBUHA8McAEIwHAAsgCSADQdDwxwAQjAcACyAJIAVB4PDHABCMBwALIAkgA0Hw8McAEIwHAAsCQCABQQRrKAIAIgBBeHFBhAhBiAggAEEDcSICG08EQAJAIAJBACAAQagITxsNAiABEKICIAtBBGsoAgAiAEF4cUGECEGICCAAQQNxIgEbSQ0AIAFBACAAQagITxsNAiALEKICIApBBGsoAgAiAEF4cUGECEGICCAAQQNxIgEbSQ0AIAFBACAAQagITxsNAiAKEKICIA1BBGsoAgAiAEF4cUGECEGICCAAQQNxIgEbSQ0AIAFBACAAQagITxsNAiANEKICDwsLQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC7kJAgh/AX4jAEFAaiIFJAACQCAAAn8CQAJAAkAgASgCFCIEIAEoAhAiAkkEQCABKAIMIQkCfgJAA0AgBCAJai0AACIIQQlrIgNBF0tBASADdEGTgIAEcUVyDQEgASAEQQFqIgQ2AhQgAiAERw0ACyACIQRCAAwBC0KAAgsgCK1CEIaEQoCCuANRDQELIAVBEGogASgCDCIGIAIgAiAESwR/A0AgBCAGai0AACIIQQlrIgNBF0tBASADdEGTgIAEcUVyDQMgASAEQQFqIgQ2AhQgAiAERw0ACyACBSAEC0EBaiIBIAIgASACSRsQ+QEgBSgCFCEDIAUoAhAhAUEUEHEiAkUNBCACIAE2AgwgAkEFNgIAIAIgAzYCECAAIAI2AgQMAgsgASAEQQFqIgY2AhQCQAJAAkAgAiAGTQ0AIAEgBEECaiIDNgIUIAYgCWotAABB9QBHDQEgAyAGIAIgAiAGSRsiBkYNACABIARBA2oiCDYCFCADIAlqLQAAQewARwRAIAghAwwCCyAGIAhGDQAgASAEQQRqIgM2AhQgCCAJai0AAEHsAEcNASAAQQI6AAFBAAwFCyAFIAkgAiAGEPkBIAUoAgQhBiAFKAIAIQFBFBBxIgRFDQUgBEEFNgIADAELIAVBCGogCSACIAMQ+QEgBSgCDCEGIAUoAgghAUEUEHEiBEUNBCAEQQk2AgALIAQgATYCDCAAIAQ2AgQgBCAGNgIQDAELAkAgCEHmAGsiAwRAIANBDkcEQCAAIAEgBUE/akGMhsEAEO4BIAEQ6wU2AgQMAwsgASAEQQFqIgc2AhQCQCACIAdNDQAgASAEQQJqIgM2AhQgBiAHai0AAEHyAEcNAiADIAcgAiACIAdJGyIHRg0AIAEgBEEDaiIINgIUIAMgBmotAABB9QBHBEAgCCEDDAMLIAcgCEYNACABIARBBGoiAzYCFCAGIAhqLQAAQeUARw0CIABBAToAAUEADAQLIAVBGGogBiACIAcQ+QEgBSgCHCEDIAUoAhghAUEUEHEiAkUNBCACIAE2AgwgAkEFNgIAIAIgAzYCECAAIAI2AgQMAgsgASAEQQFqIgc2AhQCQAJAIAIgB00NACABIARBAmoiAzYCFCAGIAdqLQAAQeEARw0BIAMgByACIAIgB0kbIgdGDQAgASAEQQNqIgk2AhQgAyAGai0AAEHsAEcEQCAJIQMMAgsgByAJRg0AIAEgBEEEaiIINgIUIAYgCWotAABB8wBHBEAgCCEDDAILIAcgCEYNACABIARBBWoiAzYCFCAGIAhqLQAAQeUARw0BIABBADoAAUEADAQLIAVBKGogBiACIAcQ+QEgBSgCLCEDIAUoAighAUEUEHEiAkUNBCACIAE2AgwgAkEFNgIAIAIgAzYCECAAIAI2AgQMAgsgBUEwaiAGIAIgAxD5ASAFKAI0IQMgBSgCMCEBQRQQcSICRQ0DIAIgATYCDCACQQk2AgAgAiADNgIQIAAgAjYCBAwBCyAFQSBqIAYgAiADEPkBIAUoAiQhAyAFKAIgIQFBFBBxIgJFDQIgAiABNgIMIAJBCTYCACACIAM2AhAgACACNgIEC0EBCzoAACAFQUBrJAAPCwALvRMBCX8jAEEgayIHJAACQAJAAkADQAJAIAEoAgghAyABEM8FAkACQCABKAIIIgQgASgCBCIGRwRAIAQgBk8NASABKAIAIgggBGotAAAiBUHcAEcEQCAFQSJHBEAgASAEQQFqNgIIIAdBEDYCFCAAIAEgB0EUahDyBgwJCwJAAkACQCACKAIIIgUEQCADIARLDQIgBCADayIGIAIoAgAgBWtLBEAgAiAFIAYQ+AUgAigCCCEFCyACKAIEIQkgBgRAIAUgCWogAyAIaiAG/AoAAAsgASAEQQFqNgIIIAIgBSAGaiICNgIIIAdBCGogCSACEPsCIAcoAggNASAHKAIQIQMgBygCDCEBDAsLAkAgAyAETQRAIAEgBEEBajYCCCAHQQhqIAMgCGogBCADaxD7AiAHKAIIRQRAIAcoAhAhAyAHKAIMIQEMDAsgB0EPNgIUIAcgASAHQRRqEPUGIAcoAgAiAUUNASAHKAIEIQMMCwsgAyAEIAZBqJzGABDqBwALIAAgBygCBDYCBCAAQQI2AgAMCwsgB0EPNgIUIAcgASAHQRRqEPUGIAcoAgAiAUUNASAHKAIEIQMMCQsgAyAEIAZBuJzGABDqBwALIAAgBygCBDYCBCAAQQI2AgAMCAsCQCADIARNBEAgBCADayIJIAIoAgAgAigCCCIKa0sEQCACIAogCRD4BSACKAIIIQoLIAIoAgQhBSAJBEAgBSAKaiADIAhqIAn8CgAACyABIARBAWoiCzYCCCACIAkgCmoiAzYCCAJAAkACQAJAAkACQAJAAkACQAJAAn8gBiALSwRAIAEgBEECajYCCCAIIAtqLQAADAELIAdBBDYCFCAHQQhqIAEgB0EUahDzBiAHLQAIDQwgBy0ACQtB/wFxQSJrDlQCAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAABQAAAAYAAAAAAAAABwAAAAgACQEACyAHQQw2AhQgASAHQRRqEIsHIQMMDgsjAEEgayIEJAACQAJAAkAgASgCBCIDIAEoAggiBk8EQAJAIAMgBmtBA00EQCABIAM2AgggBEEENgIUIARBDGogASAEQRRqEPQGIAMhBQwBCyABIAZBBGoiBTYCCCABKAIAIAZqIgYtAAFBAXQvAYiURiAGLQAAQQF0LwGImEZywUEIdCAGLQACQQF0LgGImEZyIAYtAANBAXQuAYiURnIiBkEATgRAIARBADsBDCAEIAY7AQ4MAQsgBEEMNgIUIARBDGogASAEQRRqEPQGCyAELwEMQQFGBEAgBCgCECEDDAQLIAQvAQ4iBkGA+ANxQYC4A0YNASAGQYDIAGpB//8DcUGA+ANPBEAgASgCACEJAn8gAyAFSwRAIAUgCWotAAAMAQsgBEEENgIUIARBDGogASAEQRRqEPMGIAQtAAxBAUYEQCAEKAIQIQMMBgsgBC0ADQsgASAFQQFqIgg2AghB3ABGBEACfyADIAhLBEAgCCAJai0AAAwBCyAEQQQ2AhQgBEEMaiABIARBFGoQ8wYgBC0ADEEBRgRAIAQoAhAhAwwHCyAELQANCyAFQQJqIQhB9QBGBEAgAyAISQ0FAkAgAyAIa0EDTQRAIAEgAzYCCCAEQQQ2AhQgBEEMaiABIARBFGoQ9AYMAQsgASAFQQZqNgIIIAggCWoiAy0AAUEBdC8BiJRGIAMtAABBAXQvAYiYRnLBQQh0IAMtAAJBAXQuAYiYRnIgAy0AA0EBdC4BiJRGciIDQQBOBEAgBEEAOwEMIAQgAzsBDgwBCyAEQQw2AhQgBEEMaiABIARBFGoQ9AYLIAQvAQxBAUYEQCAEKAIQIQMMBwsgBC8BDiIFQYBAa0H//wNxQYD4A08EQCAFQYDIAGpB//8DcSAGQYDQAGpB//8DcUEKdHIiCEGAgARqIQYgAigCACACKAIIIgNrQQNNBEAgAiADQQQQ+AUgAigCCCEDCyACIANBBGo2AgggAigCBCADaiIDIAZBEnZB8AFyOgAAIANBA2ogBUE/cUGAAXI6AAAgAyAIQQZ2QT9xQYABcjoAAiADIAZBDHZBP3FBgAFyOgABQQAhAwwHCyAEQRQ2AhQgASAEQRRqEIsHIQMMBgsgASAINgIIIARBFzYCFCABIARBFGoQiwchAwwFCyAEQRc2AhQgASAEQRRqEIsHIQMMBAsgBkGAAU8EQCACKAIAIAIoAggiA2tBA00EQCACIANBBBD4BSACKAIIIQMLIAIoAgQgA2ohBQJ/IAZBgBBJBEAgBkEGdkFAciEIQQIMAQsgBSAGQQZ2QT9xQYABcjoAASAGQQx2QWByIQhBAwshCSAFIAg6AAAgAiADIAlqNgIIIAUgCWpBAWsgBkE/cUGAAXI6AABBACEDDAQLIAIoAggiAyACKAIARgRAIAJB+JPGABCnBgsgAiADQQFqNgIIIAIoAgQgA2ogBjoAAEEAIQMMAwsgBiADIANByKXGABDqBwALIARBFDYCFCABIARBFGoQiwchAwwBCyAIIAMgA0HIpcYAEOoHAAsgBEEgaiQAIANFDQ4MDQsgAigCACADRgRAIAJB+JLGABCnBiACKAIEIQULIAIgA0EBajYCCCADIAVqQSI6AAAMCwsgAigCACADRgRAIAJBiJPGABCnBiACKAIEIQULIAIgA0EBajYCCCADIAVqQdwAOgAADAoLIAIoAgAgA0YEQCACQZiTxgAQpwYgAigCBCEFCyACIANBAWo2AgggAyAFakEvOgAADAkLIAIoAgAgA0YEQCACQaiTxgAQpwYgAigCBCEFCyACIANBAWo2AgggAyAFakEIOgAADAgLIAIoAgAgA0YEQCACQbiTxgAQpwYgAigCBCEFCyACIANBAWo2AgggAyAFakEMOgAADAcLIAIoAgAgA0YEQCACQciTxgAQpwYgAigCBCEFCyACIANBAWo2AgggAyAFakEKOgAADAYLIAIoAgAgA0YEQCACQdiTxgAQpwYgAigCBCEFCyACIANBAWo2AgggAyAFakENOgAADAULIAIoAgAgA0YEQCACQeiTxgAQpwYgAigCBCEFCyACIANBAWo2AgggAyAFakEJOgAADAQLIAMgBCAGQcicxgAQ6gcACyAHKAIMIQMMAwsgB0EENgIUIAAgASAHQRRqEPIGDAYLIAQgBkGYnMYAEIwHAAsMAQsLIABBAjYCACAAIAM2AgQMAgsgACADNgIIIAAgATYCBCAAQQA2AgAMAQsgACADNgIIIAAgATYCBCAAQQE2AgALIAdBIGokAAvFBwEEfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAOBQECAw0EAAsgAC0ABEEDRw0MIAAoAggiAygCACEAIANBBGooAgAiASgCACICBEAgACACEQMACyABKAIEIgEEQCAAQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNDyACQQAgBCABQSdqSxsNDiAAEKICCyADQQRrKAIAIgBBeHEiAUEQQRQgAEEDcSIAG0kNDiAARSABQTRJcg0LDA0LAkAgAC0ABEEBaw4CAAAKCyAAKAIIIgMNCAwJCwJAIAAtAARBAWsOAgAABwsgACgCCCIDDQUMBgsgACgCBCIDQQBKBEAgACgCCCIBQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyADakkNDCACQQAgBCADQSdqSxsNCyABEKICCyAAKAIQIgNFDQkgACgCFCIAKAIAIgEEQCADIAERAwALIAAoAgQiAEUNCSADQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyAAakkNCyABRQ0IIAIgAEEnaksNCgwICwJAIAAtAARBAWsOAgAAAgsgACgCCCIDDQAMAQsgACgCDCIBQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyADakkNCSACQQAgBCADQSdqSxsNCCABEKICCwJAQQMgAC0AFCIDQQRrIANBA00bQf8BcQ4EBwcHAAELIANBAWsOAgAABgsgACgCGCIBRQ0FIAAoAhwiA0EEaygCACIAQXhxIgJBBEEIIABBA3EiABsgAWpPBEAgAEUgAiABQSdqTXINBQwHCwwHCyAAKAIMIgFBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIANqSQ0GIAJBACAEIANBJ2pLGw0FIAEQogILIAAoAhQiA0UNAyAAKAIYIgAoAgAiAQRAIAMgAREDAAsgACgCBCIARQ0DIANBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIABqSQ0FIAFFIAIgAEEnak1yDQIMBAsgACgCDCIBQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyADakkNBCACQQAgBCADQSdqSxsNAyABEKICCyAAKAIUIgNFDQEgACgCGCIAKAIAIgEEQCADIAERAwALIAAoAgQiAEUNASADQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyAAakkNAyABRSACIABBJ2pNcg0ADAILIAMQogILDwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALmgkCCH8BeyAAIAEoAgQiAjYCPCABKAIAIgUhAyAAKAIIIgcgBUkEQCAFIAciA2siBiAAKAIAIANrSwRAIAAgAyAGQQRBJBCkBSAAKAIIIQMLIAAoAgQhCSAGQQNxIgQEQCADIARqIAUgB2sgBGshBiAJIANBJGxqIQIDQCAC/QwAAAAAAAAAAAAAAAAAAAAA/QsCACACQSBqQQA7AQAgAkEQaiAK/QsCACACQSRqIQIgBEEBayIEDQALIQMLIAcgBWtBfE0EQCAJIANBJGxqIQIDQCAC/QwAAAAAAAAAAAAAAAAAAAAA/QsCACACQSBqQQA7AQAgAkEQaiAK/QsCACACQSRqIAr9CwIAIAJBNGogCv0LAgAgAkHEAGpBADsBACACQcgAaiAK/QsCACACQdgAaiAK/QsCACACQegAakEAOwEAIAJB7ABqIAr9CwIAIAJB/ABqIAr9CwIAIAJBjAFqQQA7AQAgAkGQAWohAiADQQRqIQMgBkEEayIGDQALCyAAKAI8IQILIABBADYCICAAIAM2AggCQAJ/AkACQCACRQRAIABBADYCLAwBCyAFBEBBACEEIAAoAhggBUkEQCAAQRhqQQAgBUECQRIQpAUgACgCICEEIAAoAjwhAgsgBUESbCIDBEAgACgCHCAEQRJsakEAIAP8CwALIABBADYCLCAAIAQgBWo2AiAgAkEBTQ0BQQAhBCAAKAIkIAVJBEAgAEEkakEAIAVBAkEeEKQFIAAoAiwhBCAAKAI8IQILIAVBHmwiAwRAIAAoAiggBEEebGpBACAD/AsACyAAQQA2AjggACAEIAVqNgIsIAJBAk0NBEEAIQQgACgCMCAFSQRAIABBMGpBACAFQQJBKhCkBSAAKAI4IQQLIAVBKmwiAwRAIAAoAjQgBEEqbGpBACAD/AsACyAEIAVqIQQgAEE4agwDC0EAIQQgAEEANgIsIAJBAUcNAQsgAEEANgI4DAILIABBADYCOCACQQJNDQEgAEE4agsgBDYCAAsgACgCFCEEIABBADYCFCAAKAIQIQcCQAJAAkACQCAEBEAgByECA0AgAkEUaigCACIDQQVPBEAgAkEIaigCACIIQQRrKAIAIgZBeHEiCSADQQJ0IgNBBEEIIAZBA3EiBhtqSQ0DIAZBACAJIANBJ2pLGw0EIAgQogILIAJBGGohAiAEQQFrIgQNAAsLIAEtAAhFDQMgBUUEQEEAIQMMAwtBACEDIAAoAgwgBUkEQCAAQQxqQQAgBUEEQRgQpAUgACgCECEHIAAoAhQhAwsgBUEBayAFQQNxIgQEQCAFQXxxIQUgAyAEaiAHIANBGGxqIQIDQCACQQA2AgAgAkEUakEANgIAIAJBGGohAiAEQQFrIgQNAAshAwtBA0kNAiAHIANBGGxqIQIDQCACQQA2AgAgAkHcAGpBADYCACACQcQAakIANwIAIAJBLGpCADcCACACQRRqQgA3AgAgAkHgAGohAiADQQRqIQMgBUEEayIFDQALDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAAIAM2AhQLC8gGAQR/AkACQCAAKAIMIgIEQCAAKAIQIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAhgiAgRAIAAoAhwiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsgACgCPCICBEAgACgCQCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAJIIgIEQCAAKAJMIgNBBGsoAgAiAUF4cSIEIAJBAnQiAkEEQQggAUEDcSIBG2pJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsgACgCVCICBEAgACgCWCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAJgIgJBgICAgHhyQYCAgIB4RwRAIAAoAmQiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsgACgCbCICBEAgACgCcCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAJ4IgIEQCAAKAJ8IgNBBGsoAgAiAUF4cSIEIAJBAnQiAkEEQQggAUEDcSIBG2pJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsCQCAAKAKEASICQYCAgIB4Rg0AIAIEQCAAKAKIASIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNAiABQQAgBCACQSdqSxsNAyADEKICCyAAKAKQASICBEAgACgClAEiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQIgAUEAIAQgAkEnaksbDQMgAxCiAgsgACgCnAEiAkUNACAAKAKgASIAQQRrKAIAIgNBeHEiASACQQJ0IgJBBEEIIANBA3EiAxtqSQ0BIANBACABIAJBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL3xADB38CfgF7IwBBIGsiBSQAAkACQCAAKAIAIgJFBEAgACgCECIARQ0BIABBk7PFAEEBEJcDIQIMAgsCQAJAAkACQAJAAkACQCAAKAIIIgQgACgCBCIGTwRAIAAoAhAiAkUNASACQeqyxQBBEBCXA0UNAQwHCyAAIARBAWoiATYCCCAFQQhqIAIgBGotAAAiAxDnByAFKAIIIgcEQCAAKAIQIgBFDQggACAHIAUoAgwQlwMhAgwJCyAAIAAoAgxBAWoiBzYCDCAHQfUDTwRAIAAoAhAiAgRAIAJB+rLFAEEZEJcDDQgLIABBAToABAwGCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIANBwQBrDhcCBg8FDwQPDw8PDw8PDwEBAAACAw8PBw8LIAAoAhAiBARAQQEhAiAEQayzxQBBARCXAw0VIAAoAgAiAkUNCSAAKAIEIQYgACgCCCEBCyABIAZPDQggASACai0AAEHMAEcNCCAAIAFBAWo2AgggBUEQaiAAENkEIAUtABBFDQcgBS0AESEBIAAoAhAiAwRAQQEhAiADQfqyxQBB6rLFACABQQFxIgMbQRlBECADGxCXAw0VCyAAIAE6AAQMEQsgACgCECIBBEBBASECIAFBsrPFAEEBEJcDDRQLIANB0ABHDQggACgCECICRQ0JIAJBs7PFAEEGEJcDDREMCQsgACgCECIBBEBBASECIAFB6LLFAEEBEJcDDRMLQQEhAiAAEIYCDRIgA0HBAEYEQCAAKAIQIgEEQCABQbmzxQBBAhCXAw0UCyAAQQEQ1QENEwsgACgCECIBRQ0OIAFB6bLFAEEBEJcDDRIMDgsgACgCECIBBEBBASECIAFBu7PFAEEBEJcDDRILIAUgABC3BkEBIQIgBSgCAEEBcQ0RIAUoAgRBAUYEQCAAKAIQIgFFDQ4gAUG8s8UAQQEQlwMNEgsgACgCECIBRQ0NIAFB3o7IAEEBEJcDDREMDQtBACECIwBBEGsiASQAAkACQAJAAkAgACgCAEUEQCAAKAIQIgMNAQwECyABIABBxwAQrAYgAS0AAEEBRgRAIAEtAAEhAyAAKAIQIgQEQEEBIQIgBEH6ssUAQeqyxQAgA0EBcSIEG0EZQRAgBBsQlwMNBQsgACADOgAEQQAhAiAAQQA2AgAMBAsgACgCECICBEAgASkDCCIJUA0DIAJB+bTFAEEEEJcDDQIDQCAIIAlRBEAgACgCECIDRQ0FQQEhAiADQf20xQBBAhCXA0UNBQwGCwJAIAhQDQAgACgCECICRQ0AIAJB55DGAEECEJcDDQQLQQEhAiAAIAAoAhRBAWo2AhQgCEIBfCEIIABCARCCBkUNAAsMBAsgABDOAiECDAMLIANBk7PFAEEBEJcDIQIMAgtBASECDAELIAAQzgIhAiAAIAAoAhQgCadrNgIUCyABQRBqJAAgAg0ODAwLIAAoAhAiAgRAIAJBvbPFAEEEEJcDDQ4LQQEhAkEAIQEjAEEQayIDJAACQAJAAkACQCAAKAIARQRAIAAoAhAiBA0BDAQLIAMgAEHHABCsBiADLQAAQQFGBEAgAy0AASEEIAAoAhAiBgRAQQEhASAGQfqyxQBB6rLFACAEQQFxIgYbQRlBECAGGxCXAw0FCyAAIAQ6AARBACEBIABBADYCAAwECyAAKAIQIgEEQCADKQMIIglQDQMgAUH5tMUAQQQQlwMNAgNAIAggCVEEQCAAKAIQIgRFDQVBASEBIARB/bTFAEECEJcDRQ0FDAYLAkAgCFANACAAKAIQIgFFDQAgAUHnkMYAQQIQlwMNBAtBASEBIAAgACgCFEEBajYCFCAIQgF8IQggAEIBEIIGRQ0ACwwECyAAEPkDIQEMAwsgBEGTs8UAQQEQlwMhAQwCC0EBIQEMAQsgABD5AyEBIAAgACgCFCAJp2s2AhQLIANBEGokACABDQ8gACgCACIDRQ0GIAAoAggiASAAKAIETw0GIAEgA2otAABBzABHDQYgACABQQFqNgIIIAVBEGogABDZBCAFLQAQRQ0IIAUtABEhASAAKAIQIgMEQCADQfqyxQBB6rLFACABQQFxIgMbQRlBECADGxCXAw0QCyAAIAE6AAQMDAsjAEEgayICJAACQAJAIAAoAgBFBEAgACgCECIBRQ0BIAFBk7PFAEEBEJcDIQEMAgsgAiAAEK8GIAIoAgBFBEAgACgCECIDBEBBASEBIANB+rLFAEHqssUAIAItAARBAXEiAxtBGUEQIAMbEJcDDQMLIAAgAv0AAgD9CwIADAELIAAoAhBFDQAgAP0AAgAhCiAAIAL9AAIA/QsCACACIAr9CwMQIAAQhgIhASAAIAL9AAMQ/QsCAAwBC0EAIQELIAJBIGokACABDQwMCgtBASECIAAQhgINDSAAKAIQIgEEQCABQcGzxQBBBBCXAw0OCyAAEK0EDQ0MCQsgBSkDGCIIUA0AIAAgCBCCBg0KIAAoAhAiAUUNAEEBIQIgAUGts8UAQQEQlwMNDAsgA0HSAEYNBiAAKAIQIgJFDQYgAkGus8UAQQQQlwMNCQwGCyAAKAIQIgJFDQAgAkGus8UAQQQQlwMNCAsgABCGAg0HDAULIAAoAhAiAUUNACABQeqyxQBBEBCXAw0IC0EAIQIgAEEAOgAEIABBADYCAAwHCyAFKQMYIghQDQIgACgCECICBEAgAkHwyccAQQMQlwMNBQsgACAIEIIGDQQMAgsgACAENgIIIABBABDMAQ0DDAELIAAQhgINAgtBACECIAAoAgBFDQMgACAAKAIMQQFrNgIMDAMLQQAhAiAAQQA2AgAMAgtBASECDAELQQAhAgsgBUEgaiQAIAILsB0DB34PfwF7IAEoAgQiCiACKQMQIgYgAikDCCIIIAIpAwAiCSABKQMYhSIDQtii0e/CqeW/LX4gA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEhYUiA0LYotHvwqnlvy1+IANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIWFIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCADQtii0e/CqeW/LX6FIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgASkDECIEQn+FfiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAMgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH6FIAOJIgencSEMIAdCGYhC/wCDQoGChIiQoMCAAX4hBSABKAIAIQ0CQANAAkAgDCANaikAACIEIAWFIgNCf4UgA0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIDUEUEQANAAkAgDSADeqdBA3YgDGogCnFBBnRrIgtBQGopAwAgCVINACALQThrKQMAIAhSDQAgC0EwaykDACAGUQ0DCyADQgF9IAODIgNQRQ0ACwsgBCAEQgGGg0KAgYKEiJCgwIB/g1BFDQIgDCAPQQhqIg9qIApxIQwMAQsLIAAgATYCBCAAIAs2AgAgAEEANgIgDwsgASgCCEUEQAJAIwBBIGsiESQAIBEgAUEQajYCACABKAIMIQwgESARNgIEAkACQAJAAkACQAJAAkACQAJ/AkAgDEEBaiILBEAgASgCBCIUIBRBAWpBA3ZBB2wgFEEISRsiCkEBdiALSQRAIApBAWoiCiALIAogC0sbIgtBD0kNAiALQf////8BTQRAQX8gC0EDdEEHbkEBa2d2IgtB/v//H0sNBSALQQFqDAQLDAsLIBFBBGohFkEAIQogASINIA0oAgRBAWoiEAR/IA0oAgAhDwJAIBBBA3YgEEEHcUEAR2oiDEECTwRAIAxB/v///wNxIg4hCyAPIQoDQCAKIAr9AAMAIhn9TUEH/c0B/QwBAQEBAQEBAQEBAQEBAQEB/U4gGf0Mf39/f39/f39/f39/f39/f/1Q/c4B/QsDACAKQRBqIQogC0ECayILDQALIAwgDkYNASAOQQN0IQogDEEBcSEMCyAKIA9qIQoDQCAKIAopAwAiA0J/hUIHiEKBgoSIkKDAgAGDIANC//79+/fv37//AIR8NwMAIApBCGohCiAMQQFrIgwNAAsLAkAgEEEITwRAIA8gEGogDykAADcAAAwBCyAQRQ0AIA9BCGogDyAQ/AoAAAtBASELQQAhDANAIAwhDyALIQwCQCAPIA0oAgAiC2otAABBgAFHDQAgCyAPQX9zQQZ0aiESA0AgFiANIA8QtAIhAyANKAIEIg4gA6ciFXEiEyEKIA0oAgAiCyATaikAAEKAgYKEiJCgwIB/gyIDUARAQQghFANAIAogFGohCiAUQQhqIRQgCyAKIA5xIgpqKQAAQoCBgoSIkKDAgH+DIgNQDQALCyALIAN6p0EDdiAKaiAOcSIKaiwAAEEATgRAIAspAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAKIBNrIA8gE2tzIA5xQQhPBEAgCiALaiITLQAAIBMgFUEZdiITOgAAIA0oAgAgCkEIayAOcWpBCGogEzoAACALIApBf3NBBnRqIQtB/wFGBEAgDSgCBCEKIA0oAgAgD2pB/wE6AAAgDSgCACAKIA9BCGtxakEIakH/AToAACALIBJBwAD8CgAADAMLIBIgC0HAABCwAwwBCwsgCyAPaiAVQRl2Igs6AAAgDSgCACAOIA9BCGtxakEIaiALOgAACyAMIAwgEEkiCmohCyAKDQALIA0oAgQiDCAMQQFqQQN2QQdsIAxBCEkbBUEACyANKAIMazYCCAwHCwwJC0EEIAtBCHFBCGogC0EESRsLIgtBCGoiCiALQQZ0Ig9qIg0gCkkgDUH4////B0tyDQAgDRBxIg1FDQEgDSAPaiEQIAoEQCAQQf8BIAr8CwALIAtBAWsiEyALQQN2QQdsIBNBCEkbIRUgASgCACENIAwNAkEAIQwMAwsgEUEANgIYIBFBATYCDCARQcS1xAA2AgggEUIENwIQIBFBCGpBmLXEABCNCAsACyAQQQhqIRYgDSkDAEJ/hUKAgYKEiJCgwIB/gyEGQQAhCiAMIQsgDSEPA0AgBlAEQANAIApBCGohCiAPQQhqIg8pAwBCgIGChIiQoMCAf4MiA0KAgYKEiJCgwIB/UQ0ACyADQoCBgoSIkKDAgH+FIQYLIBAgEyANIAZ6p0EDdiAKaiIXQQZ0ayIOQUBqKQMAIBEoAgAiEikDCIUiA0LYotHvwqnlvy1+IA5BOGspAwCFIANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIUiA0LYotHvwqnlvy1+IA5BMGspAwCFIANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIANC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCASKQMAIgRCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgAyAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoUgA4mnIhhxIg5qKQAAQoCBgoSIkKDAgH+DIgNQBEBBCCESA0AgDiASaiEOIBJBCGohEiAQIA4gE3EiDmopAABCgIGChIiQoMCAf4MiA1ANAAsLIAZCAX0gBoMhBiAQIAN6p0EDdiAOaiATcSIOaiwAAEEATgRAIBApAwBCgIGChIiQoMCAf4N6p0EDdiEOCyAOIBBqIBhBGXYiEjoAACAWIA5BCGsgE3FqIBI6AAAgECAOQX9zQQZ0aiIOQTBqIA0gF0F/c0EGdGoiEkEwav0AAAD9CwAAIA5BIGogEkEgav0AAAD9CwAAIA5BEGogEkEQav0AAAD9CwAAIA4gEv0AAAD9CwAAIAtBAWsiCw0ACwsgASATNgIEIAEgEDYCACABIBUgDGs2AgggFEUNACAUIBRBBnRBxwBqQUBxIgtqQQlqIgxFDQAgDSALayILQQRrKAIAIgpBeHEiDUEEQQggCkEDcSIKGyAMakkNASAKQQAgDSAMQSdqSxsNAiALEKICCyARQSBqJAAMAwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIBFBADYCGCARQQE2AgwgEUHEtcQANgIIIBFCBDcCECARQQhqQZi1xAAQjQgACwsgACAHNwMAIAAgAikDADcDCCAAQRBqIAJBCGr9AAMA/QsDACAAIAE2AiALkwoBBn8jAEEwayICJAACQAJAAkACQAJAAkBBAyAAKAIAIgQtAAAiAEEEayAAQQNNG0H/AXFBAWsOBAECAwQAC0EBIQAgASgCACIDQbK3xwBBBSABKAIEIgYoAgwiBREAAA0EIARBAWohBAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAURAAANBiAEIAEQxQINBiABKAIAIQMgASgCBCgCDCEFDAELIANB24HCAEECIAURAAANBSACQQE6ACwgAiAGNgIUIAIgAzYCECACQeCBwgA2AiAgAiABKQIINwIkIAIgAkEsajYCGCACIAJBEGo2AhwgBCACQRxqEMUCDQUgAigCHEHZgcIAQQIgAigCICgCDBEAAA0FCyADQd6OyABBASAFEQAAIQAMBAtBASEAIAEoAgAiA0G3t8cAQQsgASgCBCIGKAIMIgURAAANAyAEQQFqIQQCQCABLQAKQYABcUUEQCADQbuzxQBBASAFEQAADQUgBCABEMUCDQUgASgCACEDIAEoAgQoAgwhBQwBCyADQduBwgBBAiAFEQAADQQgAkEBOgAsIAIgBjYCFCACIAM2AhAgAkHggcIANgIgIAIgASkCCDcCJCACIAJBLGo2AhggAiACQRBqNgIcIAQgAkEcahDFAg0EIAIoAhxB2YHCAEECIAIoAiAoAgwRAAANBAsgA0HejsgAQQEgBREAACEADAMLQQEhACABKAIAIgNBwrfHAEEOIAEoAgQiBygCDCIFEQAADQIgBEEBaiEGAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0EIAIgBjYCHCABIARBBGpByKjHACAEQQJqQdioxwAgBEEDakHoqMcAIAJBHGpB+KjHABDuBQ0EIAEoAgAhAyABKAIEKAIMIQUMAQsgA0HbgcIAQQIgBREAAA0DIAJBAToADyACIAc2AhQgAiADNgIQIAJB4IHCADYCICACIAEpAgg3AiQgAiACQQ9qNgIYIAIgAkEQajYCHCACIAY2AiwgAkEcaiAEQQRqQcioxwAgBEECakHYqMcAIARBA2pB6KjHACACQSxqQfioxwAQ7gUNAyACKAIcQdmBwgBBAiACKAIgKAIMEQAADQMLIANB3o7IAEEBIAURAAAhAAwCC0EBIQAgASgCACIDQdC3xwBBBiABKAIEIgYoAgwiBREAAA0BAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0DIAQgARCUA0UNAQwDCyADQduBwgBBAiAFEQAADQIgAkEBOgAsIAIgBjYCFCACIAM2AhAgAkHggcIANgIgIAIgASkCCDcCJCACIAJBLGo2AhggAiACQRBqIgE2AhwgBCACQRxqEJQDDQIgAUHZgcIAQQIQrwMNAgsgA0HejsgAQQEgBREAACEADAELQQEhACABKAIAIgNB1rfHAEEOIAEoAgQiBigCDCIFEQAADQACQCABLQAKQYABcUUEQCADQbuzxQBBASAFEQAADQIgBEEIaigCACAEQQxqKAIAIAEQtQJFDQEMAgsgA0HbgcIAQQIgBREAAA0BIAJBAToALCACIAY2AhQgAiADNgIQIAJB4IHCADYCICACIAEpAgg3AiQgAiACQSxqNgIYIARBCGooAgAgBEEMaigCACACIAJBEGoiBjYCHCACQRxqELUCDQEgBkHZgcIAQQIQrwMNAQsgA0HejsgAQQEgBREAACEACyACQTBqJAAgAAv6CAMKfwJ+AnsjAEHwAGsiByQAIAcgAjYCACAHIAAoAggiAzYCBAJAAkACQAJAAkACQAJAAkAgAiADRgRAIAdBJGogASACEPEDIAcoAighAQJAIAcoAiwiCkUNACABIApBA3RqIQkgACgCBCEFIAEhAwNAIAMoAgAiBCACTw0JIANBBGooAgAiBiACTw0KIAUgBEEYbGoiBEEQaiIIKQIAIQ0gBSAGQRhsaiIG/QACACEPIAggBkEQaiIIKQIANwIAIAT9AAIAIRAgBCAP/QsCACAIIA03AgAgBiAQ/QsCACADQQhqIgMgCUcNAAsgACgCFCICBEAgACgCECEFIAEhAwNAIAMoAgAiBCACTw0KIANBBGooAgAiBiACTw0LIAUgBEEYbGoiBEEQaiIIKQIAIQ0gBSAGQRhsaiIG/QACACEPIAggBkEQaiIIKQIANwIAIAT9AAIAIRAgBCAP/QsCACAIIA03AgAgBiAQ/QsCACADQQhqIgMgCUcNAAsLIAAoAiAiAgRAIAAoAhwhBSABIQMDQCADKAIAIgQgAk8NCiADQQRqKAIAIgYgAk8NCyAFIARBCWxqIgQpAAAhDSAFIAZBCWxqIgZBCGoiCC0AACELIAQgBikAADcAACAEQQhqIgQtAAAhDCAEIAs6AAAgCCAMOgAAIAYgDTcAACADQQhqIgMgCUcNAAsLIAAoAiwiBARAIAAoAighBiABIQIDQCACKAIAIgMgBE8NBCACQQRqKAIAIgUgBE8NBSAGIANBD2xqIgNBB2opAAAhDSADKQAAIQ4gBiAFQQ9saiIFQQhqKAAAIQggBUEMai8AACELIAVBDmotAAAhDCADIAUpAAA3AAAgA0EOaiAMOgAAIANBDGogCzsAACADQQhqIAg2AAAgByAONwMIIAcgDTcADyAFQQdqIAcpAA83AAAgBSAHKQMINwAAIAJBCGoiAiAJRw0ACwsgACgCOCIDRSAKRXINACAAKAI0IQQgASECA0AgAigCACIAIANPDQUgAkEEaigCACIFIANPDQYgB0EVaiIKIAQgAEEVbGoiAEENaikAADcAACAEIAVBFWxqIgX9AAAAIQ8gBUEUai0AACEGIABBEGogBUEQaigAADYAACAAQRRqIAY6AAAgAP0AAAAhECAAIA/9CwAAIAcgEP0LAwggBSAH/QADCP0LAAAgBUENaiAKKQAANwAAIAJBCGoiAiAJRw0ACwsgBygCJCIABEAgAUEEaygCACICQXhxIgMgAEEDdCIAQQRBCCACQQNxIgIbakkNBiACQQAgAyAAQSdqSxsNByABEKICCyAHQfAAaiQADwsgB0EANgIIQQAgByAHQQRqIAdBCGpBrLzHABD1BwALIAMgBEHA9scAEIwHAAsgBSAEQcD2xwAQjAcACyAAIANBwPbHABCMBwALIAUgA0HA9scAEIwHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAQgAkHA9scAEIwHAAsgBiACQcD2xwAQjAcAC7gHAQR/IAAoArABIgFBhAhPBEAgARCbBwsgACgCtAEiAUGECE8EQCABEJsHCwJAIAAoAgBFDQAgACgCBCIBQYQISQ0AIAEQmwcLAkAgACgCCEUNACAAKAIMIgFBhAhJDQAgARCbBwsCQCAAKAIQRQ0AIAAoAhQiAUGECEkNACABEJsHCwJAIAAoAhhFDQAgACgCHCIBQYQISQ0AIAEQmwcLAkAgACgCIEUNACAAKAIkIgFBhAhJDQAgARCbBwsCQCAAKAIoRQ0AIAAoAiwiAUGECEkNACABEJsHCwJAIAAoAjBFDQAgACgCNCIBQYQITwRAIAEQmwcLIAAoAjgiAUGECEkNACABEJsHCwJAAkAgACgCRCIBBEAgACgCSCIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAlAiAQRAIAAoAlQiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAJcIgEEQCAAKAJgIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCaCIBBEAgACgCbCIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgACgCPEUNACAAKAJAIgFBhAhJDQAgARCbBwsgACgCjAEiAUGAgICAeHJBgICAgHhHBEAgACgCkAEiA0EEaygCACICQXhxIgQgAUEBdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAKYASIBQYCAgIB4ckGAgICAeEcEQCAAKAKcASIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAnQiAQRAIAAoAngiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAKAASIBBEAgACgChAEiAEEEaygCACIDQXhxIgIgAUECdCIBQQRBCCADQQNxIgMbakkNASADQQAgAiABQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6QIAhN/An4jAEGQBGsiByQAIAdBDGpBAEGABPwLAAJAIAAoAgwiEUUEQCABKAIAIAAoAgAgACgCBCABKAIEKAIMEQAAIQAMAQsgACgCACEOIAAoAggiDy0AACEKAkACQCAAKAIEIhBFDQAgDiAQaiELIAdBDGohAiAOIQADQAJ/IAAsAAAiBkEATgRAIAZB/wFxIQQgAEEBagwBCyAALQABQT9xIQUgBkEfcSEEIAZBX00EQCAEQQZ0IAVyIQQgAEECagwBCyAALQACQT9xIAVBBnRyIQUgBkFwSQRAIAUgBEEMdHIhBCAAQQNqDAELIARBEnRBgIDwAHEgAC0AA0E/cSAFQQZ0cnIiBEGAgMQARg0CIABBBGoLIQAgA0GAAUYNAiACIAQ2AgAgAkEEaiECIANBAWohAyAAIAtHDQALCyAPIBFqIRIgA0ECdCIAQQRqIQwgACAHakEIaiELQbwFIRNByAAhFCAPIQRBgAEhDQNAIARBAWohBEEAIQJBJCEAQQEhCUEBIQZBACEFA0ACQCACQQFxBEAgBCASRg0EIAQtAAAhAiAEQQFqIQQMAQsgCiECIAlBAXFFDQMLIAJB4QBrIglB/wFxQRpPBEAgAkEwa0H/AXFBCUsNAyACQRZrIQkLIAatIhYgCUH/AXEiBq1+IhVCIIinDQIgFaciAiAFaiIFIAJJDQIgBkEaQQEgACAUayICQQAgACACTxsiAiACQQFNGyICIAJBGk8bIgJPBEAgAEEkaiEAIBZBJCACa61+IhWnIQZBACEJQQEhAiAVQiCIUA0BDAMLCyAFIAhqIgYgBUkNASAGIANBAWoiAm4iCiANaiINIApJIA1BgLADc0GAgMQAa0GAkLx/SXIgA0H/AEtyDQEgCyEAAkAgBiACIApsayIIIANPBEAgCEGAAUkNASAIQYABQZiyxQAQjAcACwNAIABBBGogACgCADYCACAAQQRrIQAgA0EBayIDIAhLDQALCyAHQQxqIAhBAnRqIA02AgAgBCASRwRAIAQtAAAhCkEAIQMCQCAFIBNuIgAgAm4gAGoiAEHIA0kEQCAAIQUMAQsDQCADQSRqIQMgAEHX/ABLIABBI24iBSEADQALCyAIQQFqIQggAyAFQSRsQfz/A3EgBUEmakH//wNxbmohFCALQQRqIQsgDEEEaiEMQQIhEyACIQMMAQsLIAdBDGohAwNAIAcgAygCADYCjAQgB0GMBGogARCoBSIADQIgA0EEaiEDIAxBBGsiDA0ACwwBC0EBIQAgASgCACICQei3xQBBCSABKAIEKAIMIgERAAANACAQBEAgAiAOIBAgAREAAA0BIAJB6rPFAEEBIAERAAANAQsgAiAPIBEgAREAAA0AIAJBpbPFAEEBIAERAAAhAAsgB0GQBGokACAAC6cJAgN+Bn9BsLXJACgCAEUEQBBWCwJAAkACQAJAQbi1yQAoAgBFBEBBuLXJAEF/NgIAQcS1yQAoAgAiBUHYtckAKQMAIgEgAK2FIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRC0oGqm6v6gtenf34iAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhCACQtii0e/CqeW/LX6FIgFCOIYgAUKA/gODQiiGhCABQoCA/AeDQhiGIAFCgICA+A+DQgiGhIQgAUIIiEKAgID4D4MgAUIYiEKAgPwHg4QgAUIoiEKA/gODIAFCOIiEhIRB0LXJACkDACICQn+FfiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIAEgAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhH6FIAGJIgGncSEEIAFCGYhC/wCDQoGChIiQoMCAAX4hA0HAtckAKAIAIgZBIGshCQJAA0ACQCAEIAZqKQAAIgIgA4UiAUJ/hSABQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgFQRQRAA0AgACAJIAF6p0EDdiAEaiAFcSIIQQV0aygCAEYNAiABQgF9IAGDIgFQRQ0ACwsgAiACQgGGg0KAgYKEiJCgwIB/g1BFDQIgBCAHQQhqIgdqIAVxIQQMAQsLQYABIQAgBiAIaiIEKQAAIgEgAUIBhoNCgIGChIiQoMCAf4N6p0EDdiAGIAhBCGsgBXFqIgUpAAAiASABQgGGg0KAgYKEiJCgwIB/g3mnQQN2akEHTQRAQci1yQBByLXJACgCAEEBajYCAEH/ASEACyAEIAA6AAAgBUEIaiAAOgAAQcy1yQBBzLXJACgCAEEBazYCACAGQQAgCGtBBXRqIgBBHGsoAgAiBEGAgICAeEYNACAAQQxrKAIAIQYgAEEQaygCACEFIABBGGsoAgAhCCAAQQRrKAIAIgAgACgCAEEBayIHNgIAIAdFBEAgABDSBQsgBARAIAhBBGsoAgAiAEF4cSIHIARBAnQiBEEEQQggAEEDcSIAG2pJDQMgAEEAIAcgBEEnaksbDQQgCBCiAgsgBUUNACAGQQRrKAIAIgBBeHEiBCAFQQJ0IgVBBEEIIABBA3EiABtqSQ0EIABBACAEIAVBJ2pLGw0FIAYQogILQbi1yQBBuLXJACgCAEEBajYCAA8LQayKwQAQsAoAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALzAYBBH8CQAJAAkAgACgCACIBQYCAgIB4Rg0AIAEEQCAAKAIEIgNBBGsoAgAiAkF4cSIEIAFBA3QiAUEEQQggAkEDcSICG2pJDQIgAkEAIAQgAUEnaksbDQMgAxCiAgsgACgCDCIBRQ0AIAAoAhAiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAhwiAUGAgICAeEYNACABBEAgACgCICIDQQRrKAIAIgJBeHEiBCABQQN0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACAEIAFBJ2pLGw0DIAMQogILIAAoAigiAUUNACAAKAIsIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAAKAI4IgFBgICAgHhGDQAgAQRAIAAoAjwiA0EEaygCACICQXhxIgQgAUEDdCIBQQRBCCACQQNxIgIbakkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAJEIgFFDQAgACgCSCIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgACgCVCIBQYCAgIB4Rg0AIAEEQCAAKAJYIgNBBGsoAgAiAkF4cSIEIAFBA3QiAUEEQQggAkEDcSICG2pJDQIgAkEAIAQgAUEnaksbDQMgAxCiAgsgACgCYCIBRQ0AIAAoAmQiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAnAiAUGAgICAeEYNACABBEAgACgCdCIDQQRrKAIAIgJBeHEiBCABQQN0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACAEIAFBJ2pLGw0DIAMQogILIAAoAnwiAUUNACAAKAKAASIAQQRrKAIAIgNBeHEiAiABQQJ0IgFBBEEIIANBA3EiAxtqSQ0BIANBACACIAFBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALtwcCCn4GfwJAIAEpAxAiA1ANACABKAIYIg4oAgAiECAOKQMIIgQgDigCBCIMrSIHIAQgB1QbpyIPaiENAkACQCADIAxC/////w8gBCAEQv////8PWhunayIRQQAgDCARTxutIgIgAiADVhtCB1gEQCAMIA9GDQMgAS0AICIPQTdLDQMgDTEAACEIIA4gBEIBfCIGNwMIIANCAX0hAiAPrUL/AYMiCkIIfCEEIAEpAwAgCCAKhoQhCCADQgFRDQIgAiAMIAYgByAGIAdUG6ciDWutIgUgAiAFVBtQIA9BL0tyDQIgDSAQajEAACAOIAYgAkIAUq0iC3wiBTcDCCAKQhB8IQYgAiALfSECIASGIAiEIQggA0IDVARAIAYhBAwDCyACIAwgBSAHIAUgB1QbpyINa60iBCACIARUG1AEQCAGIQQMAwsgD0EnSwRAIAYhBAwDCyANIBBqMQAAIA4gBSACQgBSrSIDfCIFNwMIIApCGHwhBCACIAN9IQMgBoYgCIQhCCACQgJUBEAgAyECDAMLIAMgDCAFIAcgBSAHVBunIg1rrSICIAIgA1YbUARAIAMhAgwDCyAPQR9LBEAgAyECDAMLIA0gEGoxAAAgDiAFIANCAFKtIgJ8IgU3AwggCkIghCEGIAMgAn0hAiAEhiAIhCEIIANCAlQEQCAGIQQMAwsgAiAMIAUgByAFIAdUG6ciDWutIgQgAiAEVBtQBEAgBiEEDAMLIA9BF0sEQCAGIQQMAwsgDSAQajEAACAOIAUgAkIAUq0iA3wiBTcDCCAKQih8IQQgAiADfSEDIAaGIAiEIQggAkICVARAIAMhAgwDCyADIAwgBSAHIAUgB1QbpyINa60iAiACIANWG1AEQCADIQIMAwsgBkIvVgRAIAMhAgwDCyANIBBqMQAAIA4gBSADQgBSrSICfCIFNwMIIApCMHwhBiADIAJ9IQIgBIYgCIQhCCADQgJUBEAgBiEEDAMLIAIgDCAFIAcgBSAHVBunIgxrrSIEIAIgBFQbUARAIAYhBAwDCyAPQQdNDQEgBiEEDAILIAEgAS0AICIMQThyOgAgIAEgASkDACANKQAAIAxBP3GthoQ3AwAgASADIANBPyAMa0H4AXFBA3atIgIgAiADVhsiAn03AxAgDiACIAR8NwMIDAILIAwgEGoxAAAgDiAFIAJCAFKtIgd8NwMIIApCOIQhBCACIAd9IQIgBoYgCIQhCAsgASAEPAAgIAEgCDcDACABIAI3AxALIABBHToAAAvtBwIGfwh+AkAgASgCCCIFQQhqKQMAIghQDQAgBUEQaigCACIGKAIAIAYpAwgiDSAGKAIEIgStIgkgCSANVhunIgNqIQICQAJAIAggBEL/////DyANIA1C/////w9aG6drIgdBACAEIAdPG60iCSAIIAlUG0IHWARAIAMgBEYNAyABLQAMIgRBN0sNAyACMQAAIQkgBUEIaiIHIgIgCEIBfTcDACAGIA1CAXw3AwggBK1C/wGDIg5CCHwhCCABKQMAIAkgDoaEIQsgAikDACIJUA0CIAVBEGooAgAiAigCBCIDIAIpAwgiCiADrSIMIAogDFQbpyIDRiAEQS9Lcg0CIAIoAgAgA2oxAAAgBiANQgJ8NwMIIAciAiAJQgF9NwMAIA5CEHwhCSAIhiALhCELIAIpAwAiCFAEQCAJIQgMAwsgBUEQaigCACICKAIEIgMgAikDCCIKIAOtIgwgCiAMVBunIgNGBEAgCSEIDAMLIARBJ0sEQCAJIQgMAwsgAigCACADajEAACAGIA1CA3w3AwggBUEIaiIHIgIgCEIBfTcDACAOQhh8IQggCYYgC4QhCyACKQMAIglQDQIgBUEQaigCACICKAIEIgMgAikDCCIKIAOtIgwgCiAMVBunIgNGIARBH0tyDQIgAigCACADajEAACAGIA1CBHw3AwggByICIAlCAX03AwAgDkIghCEJIAiGIAuEIQsgAikDACIIUARAIAkhCAwDCyAFQRBqKAIAIgIoAgQiAyACKQMIIgogA60iDCAKIAxUG6ciA0YEQCAJIQgMAwsgBEEXSwRAIAkhCAwDCyACKAIAIANqMQAAIAYgDUIFfDcDCCAFQQhqIgciAiAIQgF9NwMAIA5CKHwhCCAJhiALhCELIAIpAwAiClANAiAFQRBqKAIAIgIoAgQiAyACKQMIIgwgA60iDyAMIA9UG6ciA0YgCUIvVnINAiACKAIAIANqMQAAIAYgDUIGfDcDCCAHIgIgCkIBfTcDACAOQjB8IQkgCIYgC4QhCyACKQMAIghQBEAgCSEIDAMLIAVBEGooAgAiAigCBCIDIAIpAwgiCiADrSIMIAogDFQbpyIDRgRAIAkhCAwDCyAEQQdNDQEgCSEIDAILIAEgAS0ADCIEQThyOgAMIAEgASkDACACKQAAIARBP3GthoQ3AwAgBUEIaiAIIAhBPyAEa0H4AXFBA3atIgkgCCAJVBsiCH03AwAgBiAIIA18NwMIDAILIAIoAgAgA2oxAAAgBiANQgd8NwMIIAVBCGogCEIBfTcDACAOQjiEIQggCYYgC4QhCwsgASAIPAAMIAEgCzcDAAsgAEEdOgAAC/YHAgV/A34gASgCACICQf///wNxIQUgAkGAgICAeHEhBiABKAIEIQMCfiAGQRB2IAVBDXZyQYAEQQAgBRtyQYD4AXKtIAJBgICA/AdxIgRBgICA/AdGDQAaIAZBEHYhBgJAIARBgICAuARNBEAgBEENdiAFQQ12akGAgAFqIAZyrSACQQx2IAJB/98AcUEAR3GtfCAEQYCAgMQDTw0CGiAEQYCAgJgDSQ0BIAVBgICABHIiAkH+ACAEQRd2IgVrdiEEIAJBHSAFayIFdkEBcQR/IARBAyAFdEEBayACcUEAR2oFIAQLIAZyrQwCCyAGQYD4AXKtDAELIAatCyEHIAEoAgghBCADQf///wNxIQUgA0GAgICAeHEhBgJ+IANBgICA/AdxIgJBgICA/AdHBEAgBkEQdiEGIAJBgICAuARNBEAgAkENdiAFQQ12akGAgAFqIAZyrSADQQx2IANB/98AcUEAR3GtfCACQYCAgMQDTw0CGiACQYCAgJgDTwRAIAVBgICABHIiBUH+ACACQRd2IgJrdiEDIAVBHSACayICdkEBcQR/IANBAyACdEEBayAFcUEAR2oFIAMLIAZyrQwDCyAGrQwCCyAGQYD4AXKtDAELIAZBEHYgBUENdnJBgARBACAFG3JBgPgBcq0LIQggASgCDCEBIARB////A3EhAiAEQYCAgIB4cSEFAn4gBEGAgID8B3EiA0GAgID8B0cEQCAFQRB2IQUgA0GAgIC4BE0EQCADQQ12IAJBDXZqQYCAAWogBXKtIARBDHYgBEH/3wBxQQBHca18IANBgICAxANPDQIaIANBgICAmANPBEAgAkGAgIAEciIEQf4AIANBF3YiAmt2IQMgBEEdIAJrIgJ2QQFxBH8gA0EDIAJ0QQFrIARxQQBHagUgAwsgBXKtDAMLIAWtDAILIAVBgPgBcq0MAQsgBUEQdiACQQ12ckGABEEAIAIbckGA+AFyrQshCSABQf///wNxIQQgAUGAgICAeHEhAiAAIAdC//8DgyAIQhCGQoCA/P8PgyAJQiCGQoCAgIDw/z+DAn4gAUGAgID8B3EiA0GAgID8B0cEQCACQRB2IQIgA0GAgIC4BE0EQCADQQ12IARBDXZqQYCAAWogAnKtIAFBDHYgAUH/3wBxQQBHca18IANBgICAxANPDQIaIANBgICAmANPBEAgBEGAgIAEciIEQf4AIANBF3YiA2t2IQEgBEEdIANrIgN2QQFxBH8gAUEDIAN0QQFrIARxQQBHagUgAQsgAnKtDAMLIAKtDAILIAJBgPgBcq0MAQsgAkEQdiAEQQ12ckGABEEAIAQbckGA+AFyrQtCMIaEhIQ3AgALvwgCBX8BfSABKAIAIglB////A3EhBiAJQYCAgIB4cSEKAkAgCUGAgID8B3EiB0GAgID8B0YEQCAKQRB2IAZBDXZyQYAEQQAgBhtyQYD4AXIhCgwBCyAKQRB2IQogB0GAgIC4BE0EQCAHQYCAgMQDTwRAIAlBDHYgCUH/3wBxQQBHcSAHQQ12IAZBDXZqQYCAAWogCnJqIQoMAgsgB0GAgICYA0kNASAGQYCAgARyIglB/gAgB0EXdiIGa3YhByAJQR0gBmsiBnZBAXEEfyAHQQMgBnRBAWsgCXFBAEdqBSAHCyAKciEKDAELIApBgPgBciEKCyABKAIEIgZB////A3EhCCAGQYCAgIB4cSEJAkAgBkGAgID8B3EiB0GAgID8B0cEQCAJQRB2IQkgB0GAgIC4BE0EQCAHQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSAHQQ12IAhBDXZqQYCAAWogCXJqIQkMAwsgB0GAgICYA0kNAiAIQYCAgARyIgZB/gAgB0EXdiIIa3YhByAGQR0gCGsiCHZBAXEEfyAHQQMgCHRBAWsgBnFBAEdqBSAHCyAJciEJDAILIAlBgPgBciEJDAELIAlBEHYgCEENdnJBgARBACAIG3JBgPgBciEJCyABKAIIIgZB////A3EhCCAGQYCAgIB4cSEHAkAgBkGAgID8B3EiAUGAgID8B0cEQCAHQRB2IQcgAUGAgIC4BE0EQCABQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSABQQ12IAhBDXZqQYCAAWogB3JqIQcMAwsgAUGAgICYA0kNAiAIQYCAgARyIgZB/gAgAUEXdiIIa3YhASAGQR0gCGsiCHZBAXEEfyABQQMgCHRBAWsgBnFBAEdqBSABCyAHciEHDAILIAdBgPgBciEHDAELIAdBEHYgCEENdnJBgARBACAIG3JBgPgBciEHC0MAAABAIQsgAyoCACADKgIEkiADKgIIkkMAAEBAlSACQwAAgD9fBH0gCwUgAkMAAIBAlEMAAEDAkkMAAIC/kkMzMzM/lEMAAIA/kiICIAKSC5S8IgZB////A3EhCCAGQYCAgIB4cSEDAkAgBkGAgID8B3EiAUGAgID8B0YEQCADQRB2IAhBDXZyQYAEQQAgCBtyQYD4AXIhAwwBCyADQRB2IQMgAUGAgIC4BE0EQCABQYCAgMQDTwRAIAZBDHYgBkH/3wBxQQBHcSABQQ12IAhBDXZqQYCAAWogA3JqIQMMAgsgAUGAgICYA0kNASAIQYCAgARyIgZB/gAgAUEXdiIIa3YhASAGQR0gCGsiCHZBAXEEfyABQQMgCHRBAWsgBnFBAEdqBSABCyADciEDDAELIANBgPgBciEDCyAAIAU2AgwgACAEQf//A3E2AgggACAHQf//A3EgA0EQdHI2AgQgACAKQf//A3EgCUEQdHI2AgALlSEDBX4RfwF7IAGtQYi2yQApAwAiAiAArYUiA0LYotHvwqnlvy1+hSADQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEQtKBqpur+oLXp39+IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhISFIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCACQtii0e/CqeW/LX6FIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIRBgLbJACkDACIDQn+FfiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAIgA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhH6FIAKJIQZB+LXJACgCAEUEQAJAIwBBIGsiDyQAAkACQAJAAkACfwJAAkACQAJAQfi1yQACfwJAAkACQEH8tckAKAIAQQFqIgkEQEH0tckAKAIAIgcgB0EBaiINQQN2IgtBB2wgB0EISRsiB0EBdiAJSQRAIAdBAWoiByAJIAcgCUsbIglBD0kNAiAJQf////8BTQRAQX8gCUEDdEEHbkEBa2d2IglB/v///wFLDQggCUEBaiEIDAcLDA4LQQAgDUUNBBpB8LXJACgCACEKIAsgDUEHcUEAR2oiCUEBTQ0CIAohCCAJQf7///8DcSILIQcDQCAIIAj9AAMAIhj9TUEH/c0B/QwBAQEBAQEBAQEBAQEBAQEB/U4gGP0Mf39/f39/f39/f39/f39/f/1Q/c4B/QsDACAIQRBqIQggB0ECayIHDQALIAkgC0YNAyALQQN0IQggCUEBcSEJDAILDAwLQQQgCUEIcUEIaiAJQQRJGyEIDAMLIAggCmohCANAIAggCCkDACICQn+FQgeIQoGChIiQoMCAAYMgAkL//v379+/fv/8AhHw3AwAgCEEIaiEIIAlBAWsiCQ0ACwsCQCANQQhPBEAgCiANaiAKKQAANwAADAELIA1FDQAgCkEIaiAKIA38CgAAC0EBIQdBACEJA0AgCSEKIAchCQJAIApB8LXJACgCACIHai0AAEGAAUcNACAHIAxqIRMgByAKQX9zQQN0aiEUQQAgCmtBA3QhFQJAA0BB9LXJACgCACILQYi2yQApAwAiAiAHIBVqIghBCGs1AgCFIgNC2KLR78Kp5b8tfiAIQQRrNQIAhSADQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEQtKBqpur+oLXp39+IgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhISFIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCACQtii0e/CqeW/LX6FIgJCOIYgAkKA/gODQiiGhCACQoCA/AeDQhiGIAJCgICA+A+DQgiGhIQgAkIIiEKAgID4D4MgAkIYiEKAgPwHg4QgAkIoiEKA/gODIAJCOIiEhIRBgLbJACkDACIDQn+FfiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIAIgA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhH6FIAKJpyIScSIOIQggByAOaikAAEKAgYKEiJCgwIB/gyICUARAQQghEANAIAggEGohCCAQQQhqIRAgByAIIAtxIghqKQAAQoCBgoSIkKDAgH+DIgJQDQALCyAHIAJ6p0EDdiAIaiALcSIIaiwAAEEATgRAIAcpAwBCgIGChIiQoMCAf4N6p0EDdiEICyAIIA5rIAogDmtzIAtxQQhPBEAgByAIaiIOLQAAIA4gEkEZdiIOOgAAQfC1yQAoAgAgCEEIayALcWpBCGogDjoAAEH/AUYNAiAHIAhBA3RrIQhBeCEHA0AgByATaiILKAAAIQ4gCyAHIAhqIgsoAAA2AAAgCyAONgAAIAdBBGoiBw0AC0HwtckAKAIAIQcMAQsLIAcgCmogEkEZdiIHOgAAQfC1yQAoAgAgCyAKQQhrcWpBCGogBzoAAAwBC0H0tckAKAIAIQtB8LXJACgCACAKakH/AToAAEHwtckAKAIAIAsgCkEIa3FqQQhqQf8BOgAAIAcgCEF/c0EDdGogFCkAADcAAAsgDEEIayEMIAkgCSANSSIIaiEHIAgNAAtB9LXJACgCACIJIAlBAWpBA3ZBB2wgCUEISRsLQfy1yQAoAgBrNgIADAULIAhBCGoiCSAIQQN0IgpqIgcgCUkgB0H4////B0tyDQAgBxBxIgdFDQEgByAKaiEKIAkEQCAKQf8BIAn8CwALIAhBAWsiDSAIQQN2QQdsIA1BCEkbIRBB8LXJACgCACEHQfy1yQAoAgAiDg0CQQAMAwsgD0EANgIYIA9BATYCDCAPQcS1xAA2AgggD0IENwIQIA9BCGpBmLXEABCNCAsACyAKQQhqIRIgBykDAEJ/hUKAgYKEiJCgwIB/gyEFQQAhCCAHIQkDQCAFUARAA0AgCEEIaiEIIAlBCGoiCSkDAEKAgYKEiJCgwIB/gyICQoCBgoSIkKDAgH9RDQALIAJCgIGChIiQoMCAf4UhBQsgCiANQYi2yQApAwAiAiAHIAV6p0EDdiAIaiITQQN0ayIMQQhrNQIAhSIDQtii0e/CqeW/LX4gDEEEazUCAIUgA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCACQgiIQoCAgPgPgyACQhiIQoCA/AeDhCACQiiIQoD+A4MgAkI4iISEhELSgaqbq/qC16d/fiICQjiGIAJCgP4Dg0IohoQgAkKAgPwHg0IYhiACQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEhSICQjiGIAJCgP4Dg0IohoQgAkKAgPwHg0IYhiACQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEQtKBqpur+oLXp39+IgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgAkLYotHvwqnlvy1+hSICQjiGIAJCgP4Dg0IohoQgAkKAgPwHg0IYhiACQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEQYC2yQApAwAiA0J/hX4iBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhCACIANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIR+hSACiaciFHEiDGopAABCgIGChIiQoMCAf4MiAlAEQEEIIQsDQCALIAxqIQwgC0EIaiELIAogDCANcSIMaikAAEKAgYKEiJCgwIB/gyICUA0ACwsgBUIBfSAFgyEFIAogAnqnQQN2IAxqIA1xIgxqLAAAQQBOBEAgCikDAEKAgYKEiJCgwIB/g3qnQQN2IQwLIAogDGogFEEZdiILOgAAIBIgDEEIayANcWogCzoAACAKIAxBf3NBA3RqIAcgE0F/c0EDdGopAAA3AwAgDkEBayIODQALQfC1yQAoAgAhB0H8tckAKAIACyEIQfC1yQAgCjYCAEH0tckAKAIAIQlB9LXJACANNgIAQfi1yQAgECAIazYCACAJRQ0AIAkgCUEDdEEPakF4cSIIakEJaiIJRQ0AIAcgCGsiB0EEaygCACIIQXhxIgpBBEEIIAhBA3EiCBsgCWpJDQEgCEEAIAogCUEnaksbDQIgBxCiAgsgD0EgaiQADAMLQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAPQQA2AhggD0EBNgIMIA9BxLXEADYCCCAPQgQ3AhAgD0EIakGYtcQAEI0IAAsLQfS1yQAoAgAiCCAGp3EhCSAGQhmIIgRC/wCDQoGChIiQoMCAAX4hBUHwtckAKAIAIQcDQAJ/AkACQCAHIAlqKQAAIgMgBYUiAkJ/hSACQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgJQRQRAA0AgByACeqdBA3YgCWogCHFBA3RrIgxBCGsoAgAgAEYEQEEBIQogASAMQQRrKAIARg0DCyACQgF9IAKDIgJQRQ0ACwsgA0KAgYKEiJCgwIB/gyECIBZFBEAgAlANAiACeqdBA3YgCWogCHEhEQtBASACIANCAYaDUA0CGkEAIQogByARaiwAACIJQQBOBEAgByAHKQMAQoCBgoSIkKDAgH+DeqdBA3YiEWotAAAhCQsgByARaiAEp0H/AHEiDDoAACAHIBFBCGsgCHFqQQhqIAw6AABB+LXJAEH4tckAKAIAIAlBAXFrNgIAQfy1yQBB/LXJACgCAEEBajYCACAHIBFBA3RrIglBCGsgADYCACAJQQRrIAE2AgALIAoPC0EACyEWIBdBCGoiFyAJaiAIcSEJDAALAAuECQMZfwR9AXsjAEEQayIOJAACQAJAAkACQAJAIAIEQCAAKAIIIhEgAWsiBUEAIAUgEU0bIRZDAACAPyAAKgJAIAAtAFhBAkYiBRtDAAAAACAAKgI8IAUbIh+TISAgAkEMbCEXIABBPGohGCAAKAIEIAFBGGxqIQYgAygCICEPIAMoAiQhEiADKAIYIRkgAygCHCETIAMoAhAhGiADKAIUIRQgAygCCCEbIAMoAgwhECADKAIAIRwgAygCBCEVA0ACQAJAAkACQCANIBZHBEAgB0EDaiIFIBVLDQEgBiAMIBxqIgRBCGogBP1dAgD9VgIAAiIh/VoCCAIgBiAh/VsCAAAgDSAQRg0DIAsgG2ooAgAiCkH///8DcSEIIApBgICAgHhxIQQgCkGAgID8B3EiCUGAgID8B0YEQCAIQQ12IARBEHZyQYAEQQAgCBtyQYD4AXIhBAwFCyAEQRB2IQQgCUGAgIC4BEsNAiAJQYCAgMQDTwRAIApBDHYgCkH/3wBxQQBHcSAJQQ12IAhBDXZqQYCAAWogBHJqIQQMBQsgCUGAgICYA0kNBCAIQYCAgARyIgpB/gAgCUEXdiIIa3YhCSAKQR0gCGsiCHZBAXEEfyAJQQMgCHRBAWsgCnFBAEdqBSAJCyAEciEEDAQLIAEgDWogEUHsu8cAEIwHAAsgByAFIBVBpMXHABDqBwALIARBgPgBciEEDAELIBAgEEHkxMcAEIwHAAsgBkEMaiAEOwEAIAUgFEsNBEMAAH9DQwAAAAAgDCAaaiIEQQRqKgIAIB+TICCVQwAAf0OUIh0gHUMAAAAAXRsiHSAdQwAAf0NeGxC5ByEdIAZBDmpB/wFDAAB/Q0MAAAAAIARBCGoqAgAgH5MgIJVDAAB/Q5QiHiAeQwAAAABdGyIeIB5DAAB/Q14bELkHIh78AUEAIB5DAAAAAGAbIB5DAAB/Q14bQRB0Qf8BIB38AUEAIB1DAAAAAGAbIB1DAAB/Q14bQQh0ckH/AUMAAH9DQwAAAAAgBCoCACAfkyAglUMAAH9DlCIdIB1DAAAAAF0bIh0gHUMAAH9DXhsQuQciHfwBQQAgHUMAAAAAYBsgHUMAAH9DXhtyIgQ7AQAgBkEQaiAEQRB2OgAAIAUgE0sNBSAGIBggDCAZaiIH/V0CACAHQQhqKgIAIh39IAIgHf0gAxDfBCALQQNqIBJPDQIgDiAP/QACAP0LBAAgBkEWaiAOEJ0EIgdBEHY6AAAgBkEUaiAHOwEAIA1BAWohDSAPQRBqIQ8gBkEYaiEGIAtBBGohCyAFIQcgFyAMQQxqIgxHDQALCyAAIAEgAiADKAIoIAMoAiwgAygCMCADKAI0IAMoAjggAygCPBDqBCADKAJEIgVFDQQgAygCTCIHDQEMBAsgCyALQQRqIBJBhMXHABDqBwALIAAoAhAiBiAAKAIUIgAgASACIAMoAkggBxCNAyAGIAAgASACIAMoAkAgBRCzAwwCCyAHIAUgFEGUxccAEOoHAAsgByAFIBNB9MTHABDqBwALIA5BEGokAAvXBwIHfwN9IAEoAggiAkEDdCEGIAEoAgQhBCABKAIAIQcgACgCCCIDIQEgACgCACADayACSQRAIAAgAyACQQRBCBCkBSAAKAIIIQELIAAoAgQhBSAGBEAgBSABQQN0aiAEIAb8CgAACyAAIAEgAmoiAjYCCAJAAkACQAJAIAcEQCAEQQRrKAIAIgBBeHEiASAHQQN0IgZBBEEIIABBA3EiABtqSQ0BIABBACABIAZBJ2pLGw0CIAQQogILIAIgA0YNAwJAAkAgAiADayIAIANNBEAgAkEBdCEBIAJBgBBLDQEgASAAQR8gA2drbE8NAgsgAkECSQ0FDAQLIAEgAEELbEkNAwsgAiADTQ0DA0AgBSADQQN0aiIAKAIEIQQgACoCACEKAkAgA0UEQEEAIQEMAQsgAyEAIAogClwEQANAAkAgBSAAQQFrIgdBAXYiAUEDdGoiBioCACIJIAlbIAkgCmBFcQ0AIAQgBkEEaigCAEsNACAAIQEMAwsgBSAAQQN0aiAGKQIANwIAIAEhACAHQQJPDQAMAgsACwNAIAUgAEEBayIHQQF2IgFBA3RqIgYqAgAiCSAJWyAJIApgRXFBfyAJIApfGyIIQQBMIAQgBkEEaigCAE0gCBsEQCAAIQEMAgsgBSAAQQN0aiAGKQIANwIAIAEhACAHQQFLDQALCyAFIAFBA3RqIgAgBDYCBCAAIAo4AgAgA0EBaiIDIAJHDQALDAMLQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyACQQJrIQYgAkEBdiEDA0AgA0EBayIDQQF0IgRBAXIhACAFIANBA3RqIgEoAgQhByABKgIAIQogAyEBAkACQCAEIAZPDQADQAJAIAogBSAAIARBA3QgBWoiAkEQaioCACIJIAlbIAkgBSAAQQN0aiIEKgIAIgtgRXEiCCAIQX8gCSALXxsgCyALXBsiCEEATCAEQQRqKAIAIAJBFGooAgBNIAgbaiICQQN0aiIAKgIAIglgRSAKIApbcUUEQCAJIApgRSAJIAlbcSAHIABBBGooAgBPcg0BCyAFIAFBA3RqIAApAgA3AgAgAkEBdCIEQQFyIQAgAiEBIAQgBkkNAQwCCwsgASEADAELIAQgBkcEQCABIQAMAQsCQCAKIApcIAogBSAAQQN0aiICKgIAIglgciIEIAkgCVwgCSAKYHJxRQRAIARFDQEgASEADAILIAcgAkEEaigCAEkNACABIQAMAQsgBSABQQN0aiACKQIANwIACyAFIABBA3RqIgAgBzYCBCAAIAo4AgAgAw0ACwsL4wgDB38EfQF7IwBBsAFrIgUkAAJ/AkAgASgCCCIHIAJLBEAgBUGAAWogASgCBCACQSRsaiIHEJoDIAX9AASAASIQ/R8AIgwgEP0fASINlEOPws0/ELcKIQ4gDCAQ/R8CIgyUQ4/CzT8QtwohDyANIAyUQ4/CzT8QtwogDiAPkpJDAABAQJVD5kAfPxC3CkPbD0lBlCEMIAcvARQiBkH//wFxRQRAIAZBEHQMAwsgBkH/B3EhByAGQYCAAnEhCCAGQYD4AXEiBkGA+AFGBEAgCEEQdCEGIAZBgICA/AdyIAdFDQMaIAYgB0ENdHJBgICA/gdyDAMLIAhBEHQhCCAGRQ0BIAZBDXRBgICA/ABxIAdBDXRyQYCAgMADaiAIcgwCCyACIAdB1MDHABCMBwALIAhBgICA2ANyIAdnQRBrIgZBF3RrIAcgBkH//wNxQQhqdEH///8DcXILIQggBUEIaiABKAIQIgkgASgCFCIKIAIQ6AIgDCAIvpQhDQJAAn8CQAJAIAUoAiwiBkEJTwRAIAUoAgwiB0UNASAFQQA2AjAgBUEANgJUIAUoAhAMAwsgBg0BCyAAQQE2AiggACACNgIIIABBADYCBCAAIA04AgAMAgsgBUEANgIwIAVBADYCVCAGIQcgBUEMagshCCAHQQJ0IQsgBUGEAWohB0MAAID/IQwDQCAFQYABaiABIAgoAgAgAyAEEJUCIAVB4ABqIAdBCGr9AAIA/QsDACAFQfAAaiAHQRhq/QACAP0LAwAgBSAHKQIANwNYIAhBBGohCCAFKgKAASEOIAVBMGogBUHYAGoQ/wEgDCAOEOAIIQwgC0EEayILDQALIAMoAgghAQJAAkACQAJAAkAgBCAMlCANXwRAIAEgAk0NASADKAIEIAJqQQE6AAALIAEgAk0NASADKAIEIAJqLQAARQRAIAkgCiACQQRBABDkBSAAIAw4AgAgAEEkaiAFQdAAaikCADcCACAAQRRqIAVBQGv9AAIA/QsCACAAIAX9AAIw/QsCBAwGCyAJIAogAiAFKAJUIghBCUkEfyAFQTRqBSAFKAI0IghBgIAETw0DIAUoAjgLIAgQ5AUgAEEBNgIoIAAgAjYCCCAAQQA2AgQgACANOAIAIAUoAlQiAEEJSQ0FIAUoAjgiAUEEaygCACICQXhxIgMgAEECdCIAQQRBCCACQQNxIgIbakkNAyACQQAgAyAAQSdqSxsNBCABEKICDAULIAIgAUHs6sEAEIwHAAsgAiABQfzqwQAQjAcAC0GM68EAQS1BvOvBABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACwJAAkAgBkEJTwRAIAUoAhAiAEEEaygCACIBQXhxIgIgBkECdCIDQQRBCCABQQNxIgEbakkNASABQQAgAiADQSdqSxsNAiAAEKICCyAFQbABaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL9wgCAn0DfwJAAkACQAJAAkACQAJAAkACQAJAIAAoAlxFIAJFckUEQEMAAP5CQwAA/kIgACoCTJUgAC0AWEECRhshBiAAKAIcIAFBCWxqIQkgACgCICEIQQAhAANAIAEgCE8NCiAAIARPDQsgACAJaiIHQf8AQwAA/kJDAAD+wiAGIAMqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQFqIARPDQkgB0EBakH/AEMAAP5CQwAA/sIgBiADQQRqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEECaiAETw0IIAdBAmpB/wBDAAD+QkMAAP7CIAYgA0EIaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIABBA2ogBE8NByAHQQNqQf8AQwAA/kJDAAD+wiAGIANBDGoqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQRqIARPDQYgB0EEakH/AEMAAP5CQwAA/sIgBiADQRBqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEEFaiAETw0FIAdBBWpB/wBDAAD+QkMAAP7CIAYgA0EUaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIABBBmogBE8NBCAHQQZqQf8AQwAA/kJDAAD+wiAGIANBGGoqAgCUIgUgBUMAAP7CXRsiBSAFQwAA/kJeGxC5ByIF/ABBgH8gBUMAAADDYBsgBUMAAP5CXhtBACAFIAVbGzoAACAAQQdqIARPDQMgB0EHakH/AEMAAP5CQwAA/sIgBiADQRxqKgIAlCIFIAVDAAD+wl0bIgUgBUMAAP5CXhsQuQciBfwAQYB/IAVDAAAAw2AbIAVDAAD+Ql4bQQAgBSAFWxs6AAAgAEEIaiAETw0CIAdBCGpB/wBDAAD+QkMAAP7CIAYgA0EgaioCAJQiBSAFQwAA/sJdGyIFIAVDAAD+Ql4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbOgAAIANBJGohAyAAQQlqIQAgAUEBaiEBIAJBAWsiAg0ACwsPCyAAQQhqIQAMCAsgAEEHaiEADAcLIABBBmohAAwGCyAAQQVqIQAMBQsgAEEEaiEADAQLIABBA2ohAAwDCyAAQQJqIQAMAgsgAEEBaiEADAELIAAgBE8NACABIAhBhMTHABCMBwALIAAgBEH0w8cAEIwHAAuOCQISfwl7IwBBIGsiBiQAAkACQCACQf//A3EiCUEBIAN0akEBayADdiICQf//A00EQCAJRQ0BIAEgASAJQQJ0IgdwayIBIAdPBEAgA0EfcSIOQR1LDQMgByAOQQJqdkEEIA50IghBAWsgB3FBAEdqIREgAkECdCEVIAEgB2shDwNAAkACQCAVIBAgDnZsIgIgBU0EQCAFIAJrQQJ2IgEgESABIBFJGyIWRQ0CIAIgBGohF0EAIQsgACEJIAchDAwBCyACIAUgBUHI2MQAEOoHAAsDQCAIIAcgCCALbCICayIBIAEgCEsbIgEEQCAAIAJqIQIgFyALQQJ0aiIDLAAAIRIgAywAASETIAMsAAIhFCABQYGAgIB8bEEEayIDQSBPBEBBfCAIIAwgCCAMSRtB/////wNsa0ECdiADQQJ2QQFqIgpBB3EiA0EIIAMbIgNrQQFqIQ0gAiAKIANrQQJ0IgNqIQIgASADayEBIBL9ESEcIBP9ESEdIBT9ESEeIAkhAwNAIANBDGogHiAD/QAAACIfIBj9DQEFCQ0AAAAAAAAAAAAAAAD9hwH9pwEiGv21AUEF/a0BIB8gGP0NAAQIDAAAAAAAAAAAAAAAAP2JAf2pAf2uASIZ/RsDOgAAIANBCGogGf0bAjoAACADQQRqIBn9GwE6AAAgAyAZ/RsAOgAAIANBHGogHiADQRBqIgr9AAAAIiAgGf0NAQUJDQAAAAAAAAAAAAAAAP2HAf2nASIY/bUBQQX9rQEgICAZ/Q0ABAgMAAAAAAAAAAAAAAAA/YkB/akB/a4BIhv9GwM6AAAgA0EYaiAb/RsCOgAAIANBFGogG/0bAToAACAKIBv9GwA6AAAgA0EOaiAdIBr9tQFBBf2tASAfIBn9DQIAAAAGAAAACgAAAA4AAAD9rgEgGUEY/asBQRj9rAEgHP21AUEF/a0B/a4BIhr9GwM6AAAgA0EKaiAa/RsCOgAAIANBBmogGv0bAToAACADQQJqIBr9GwA6AAAgA0EeaiAdIBj9tQFBBf2tASAgIBr9DQIAAAAGAAAACgAAAA4AAAD9rgEgG0EY/asBQRj9rAEgHP21AUEF/a0B/a4BIhj9GwM6AAAgA0EaaiAY/RsCOgAAIANBFmogGP0bAToAACADQRJqIBj9GwA6AAAgA0EgaiEDIA1BCGsiDQ0ACwsDQCACIAItAAAgAkEBaiwAACINIBRsQQV2aiIKOgAAIAJBAmoiAyADLQAAIA0gE2xBBXZqIArAIBJsQQV2ajoAACACQQRqIQIgAUEEayIBDQALCyAIIAlqIQkgDCAIayEMIAtBAWoiCyAWRw0ACwsgEEEBaiEQIAAgB2ohACAPQQAgByAHIA9LIgEbayEPIAFFDQALCyAGQSBqJAAPC0HY5sgAQSsgBkEfakHY2MQAQaj7xgAQ4AYACyAGQQA2AhQgBkEBNgIIIAZBvKHHADYCBCAGQgQ3AgwgBkEEakGo2MQAEI0IAAsgBkEANgIUIAZBATYCCCAGQbyhxwA2AgQgBkIENwIMIAZBBGpBuNjEABCNCAAL/gcCE38BfgJAAkACQAJAIAEoAgBBAUYEQCABKAIcIgUgASgCNCIERwRAIAEoAjAhCyAEIQMgBSABKAI8IghBAWsiEGoiAiAETw0CIAEoAjghDSAFIAtqIREgBSAIaiEGIAEoAhgiAyAFaiEOIAggA2shEiAFIAEoAhAiDGtBAWohEyABKQMIIRUgASgCJCIPQX9GIQkgDyEHIAUhAwNAIAMgBUcNAwJAAkAgFSACIAtqMQAAiKdBAXFFBEAgASAGNgIcIAYhAyAJDQJBACECDAELIAwgByAMIAcgDEsbIAkbIgogCCAIIApJGyEUIAohAwJAAkACQANAIAMiAiAURgRAQQAgByAJGyEKIAwhAgNAIAIgCk0EQCABIAY2AhwgD0F/RwRAIAFBADYCJAsgACAGNgIIIAAgBTYCBCAAQQA2AgAPCyACQQFrIgIgCE8NBSACIAVqIgMgBE8NAyACIA1qLQAAIAMgC2otAABGDQALIAEgDjYCHCASIQIgDiEDIAlFDQUMBgsgAiAFaiAETw0CIAJBAWohAyACIA1qLQAAIAIgEWotAABGDQALIAIgE2ohAyAJDQRBACECDAMLIAMgBEH4nscAEIwHAAsgBCAFIApqIgAgACAESRsgBEGIn8cAEIwHAAsgAiAIQeiexwAQjAcACyABIAI2AiQgAiEHCyADIBBqIgIgBEkNAAsgBCEDDAMLIABBAjYCAA8LAkAgAS0ADkUEQCABIAEtAAwiBUEBczoADCABKAI0IQIgASgCMCEEIAEoAgQiA0UNAQJAIAIgA00EQCACIANHDQEMAwsgAyAEaiwAAEG/f0oNAgsgBCACIAMgAkHUuMcAELsJAAsgAEECNgIADwsCQAJAIAIgA0cEQAJ/IAMgBGoiBCwAACICQQBOBEAgAkH/AXEMAQsgBC0AAUE/cSEGIAJBH3EhByAHQQZ0IAZyIAJBX00NABogBC0AAkE/cSAGQQZ0ciEGIAYgB0EMdHIgAkFwSQ0AGiAHQRJ0QYCA8ABxIAQtAANBP3EgBkEGdHJyCyEEQQEhAiAFQQFxRQ0BDAILIAVBAXENASAAQQI2AgAgAUEBOgAODwsCQCAEQYABSQ0AQQIhAiAEQYAQSQ0AQQNBBCAEQYCABEkbIQILIAAgAzYCBCAAQQE2AgAgACACIANqIgA2AgggASAANgIEDwsgACADNgIIIAAgAzYCBCAAQQA2AgAPCyADRQ0BCyADIQIDQAJAIAIgBE8EQCACIARGDQQMAQsgAiALaiwAAEG/f0wNACACIQQMAwsgAkEBaiICDQALC0EAIQQLIAAgBDYCCCAAIAU2AgQgAEEBNgIAIAEgAyAEIAMgBEsbNgIcC7QKAgN8A38jAEEQayIFJAAgALshAQJAIAC8IgZB/////wdxIgRB25+k+gNPBEAgBEHSp+2DBE8EQCAEQdbjiIcETwRAAkACQAJAAkAgBEH////7B00EQCAFQgA3AwgCQCAEQdqfpO4ETQRAIAEgAUSDyMltMF/kP6JEAAAAAAAAOEOgRAAAAAAAADjDoCICRAAAAFD7Ifm/oqAgAkRjYhphtBBRvqKgIQEgAvwCIQQMAQsgBSAEIARBF3ZBlgFrIgRBF3Rrvrs5AwAgBSAFQQhqIAQQdCEEIAZBAE4EQCAFKwMIIQEMAQtBACAEayEEIAUrAwiaIQELIARBA3FBAWsOAwMEAQILIAAgAJMhAAwHCyABIAGiIgFEgV4M/f//37+iRAAAAAAAAPA/oCABIAGiIgJEQjoF4VNVpT+ioCABIAKiIAFEaVDu4EKT+T6iRCceD+iHwFa/oKKgtowhAAwGCyABIAEgAaIiAqIiAyACIAKioiACRKdGO4yHzcY+okR058ri+QAqv6CiIAEgAyACRLL7bokQEYE/okR3rMtUVVXFv6CioKC2IQAMBQsgASABoiIBRIFeDP3//9+/okQAAAAAAADwP6AgASABoiICREI6BeFTVaU/oqAgASACoiABRGlQ7uBCk/k+okQnHg/oh8BWv6CioLYhAAwECyABIAGiIgIgAZqiIgMgAiACoqIgAkSnRjuMh83GPqJEdOfK4vkAKr+goiADIAJEsvtuiRARgT+iRHesy1RVVcW/oKIgAaGgtiEADAMLIARB4Nu/hQRPBEBEGC1EVPshGcBEGC1EVPshGUAgBkEAThsgAaAiAiACIAKiIgGiIgMgASABoqIgAUSnRjuMh83GPqJEdOfK4vkAKr+goiACIAMgAUSy+26JEBGBP6JEd6zLVFVVxb+goqCgtiEADAMLIAZBAE4EQCABRNIhM3982RLAoCIBIAGiIgFEgV4M/f//37+iRAAAAAAAAPA/oCABIAGiIgJEQjoF4VNVpT+ioCABIAKiIAFEaVDu4EKT+T6iRCceD+iHwFa/oKKgtowhAAwDCyABRNIhM3982RJAoCIBIAGiIgFEgV4M/f//37+iRAAAAAAAAPA/oCABIAGiIgJEQjoF4VNVpT+ioCABIAKiIAFEaVDu4EKT+T6iRCceD+iHwFa/oKKgtiEADAILIARB5JfbgARPBEBEGC1EVPshCcBEGC1EVPshCUAgBkEAThsgAaAiAiACoiIBIAKaoiIDIAEgAaKiIAFEp0Y7jIfNxj6iRHTnyuL5ACq/oKIgAyABRLL7bokQEYE/okR3rMtUVVXFv6CiIAKhoLYhAAwCCyAGQQBOBEAgAUQYLURU+yH5v6AiASABoiIBRIFeDP3//9+/okQAAAAAAADwP6AgASABoiICREI6BeFTVaU/oqAgASACoiABRGlQ7uBCk/k+okQnHg/oh8BWv6CioLYhAAwCCyABRBgtRFT7Ifk/oCIBIAGiIgFEgV4M/f//37+iRAAAAAAAAPA/oCABIAGiIgJEQjoF4VNVpT+ioCABIAKiIAFEaVDu4EKT+T6iRCceD+iHwFa/oKKgtowhAAwBCyAEQYCAgMwDTwRAIAEgAaIiAiABoiIDIAIgAqKiIAJEp0Y7jIfNxj6iRHTnyuL5ACq/oKIgAyACRLL7bokQEYE/okR3rMtUVVXFv6CiIAGgoLYhAAwBCyAFIABDAACAA5QgAEMAAIB7kiAEQYCAgARJGzgCCCAFKgIIGgsgBUEQaiQAIAALxgcBDn4gACAANQIgIgIgADUCACIEfCIFIAA0AhAiAUL7nAF+QhCHIAF8IAA0AjAiA0KMlQJ+QhCHfCIGfT4CMCAAIAFCjJUCfkIQhyADIANC+5wBfkIQh3x9IgEgBCACfSIDfD4CECAAIAUgBnw+AgAgACADIAF9PgIgIAAgADQCFCIBQoyVAn5CEIcgADQCNCIDQvucAX5CEIcgA3x9IgIgADUCBCIEIAA1AiQiBX0iBnw+AhQgACAGIAJ9PgIkIAAgBCAFfCICIAEgAUL7nAF+QhCHfCADQoyVAn5CEId8IgR9PgI0IAAgADUCKCIFIAA1AggiBnwiByAANAIYIgFC+5wBfkIQhyABfCAANAI4IgNCjJUCfkIQh3wiCH0+AjggACAGIAV9IgUgAUKMlQJ+QhCHIAMgA0L7nAF+QhCHfH0iBn0iCj4CKCAAIAA1AiwiCyAANQIMIgx8IgkgADQCHCIBQvucAX5CEIcgAXwgADQCPCIDQoyVAn5CEId8Ig19PgI8IAAgByAIfMQiByAANAIAIgh8QgR8Ig4gAiAEfMQiAkL7nAF+QhCHIAJ8IAkgDXzEIgRCjJUCfkIQh3wiCX1CA4g+AgwgACAJIA58QgOIPgIAIAAgCCAHfUIEfCIHIAJCjJUCfkIQhyAEQvucAX5CEIcgBHx9IgJ9QgOIPgIIIAAgAiAHfEIDiD4CBCAAIAUgBnzEIgQgADQCECIFfEIEfCIGIAA0AhQiAkL7nAF+QhCHIAJ8IAFCjJUCfkIQhyADIANC+5wBfkIQh3x9IgMgDCALfSIHfMQiAUKMlQJ+QhCHfCIIfUIDiD4CHCAAIAYgCHxCA4g+AhAgACAFIAR9QgR8IgQgAkKMlQJ+QhCHIAFC+5wBfkIQhyABfH0iAX1CA4g+AhggACABIAR8QgOIPgIUIAAgCsQiAiAANAIgIgR8QgR8IgUgADQCJCIBQvucAX5CEIcgAXwgByADfcQiA0KMlQJ+QhCHfCIGfUIDiD4CLCAAIAUgBnxCA4g+AiAgACAEIAJ9QgR8IgIgAUKMlQJ+QhCHIANC+5wBfkIQhyADfH0iAX1CA4g+AiggACABIAJ8QgOIPgIkIAAgADQCOCICIAA0AjAiBHxCBHwiBSAANAI0IgFC+5wBfkIQhyABfCAANAI8IgNCjJUCfkIQh3wiBn1CA4g+AjwgACAFIAZ8QgOIPgIwIAAgBCACfUIEfCICIAFCjJUCfkIQhyADIANC+5wBfkIQh3x9IgF9QgOIPgI4IAAgASACfEIDiD4CNAuMCgIDfAN/IwBBEGsiBSQAIAC7IQECfQJAAkAgALwiBkH/////B3EiBEHbn6T6A08EQCAEQdKn7YMETwRAIARB1uOIhwRPBEACQAJAAkACQCAEQf////sHTQRAIAVCADcDCAJAIARB2p+k7gRNBEAgASABRIPIyW0wX+Q/okQAAAAAAAA4Q6BEAAAAAAAAOMOgIgJEAAAAUPsh+b+ioCACRGNiGmG0EFG+oqAhASAC/AIhBAwBCyAFIAQgBEEXdkGWAWsiBEEXdGu+uzkDACAFIAVBCGogBBB0IQQgBkEATgRAIAUrAwghAQwBC0EAIARrIQQgBSsDCJohAQsgBEEDcUEBaw4DAwQBAgsgACAAkwwJCyABIAEgAaIiAqIiAyACIAKioiACRKdGO4yHzcY+okR058ri+QAqv6CiIAEgAyACRLL7bokQEYE/okR3rMtUVVXFv6CioKC2DAgLIAEgAaIiAUSBXgz9///fv6JEAAAAAAAA8D+gIAEgAaIiAkRCOgXhU1WlP6KgIAEgAqIgAURpUO7gQpP5PqJEJx4P6IfAVr+goqC2DAcLIAEgAaIiAiABmqIiAyACIAKioiACRKdGO4yHzcY+okR058ri+QAqv6CiIAMgAkSy+26JEBGBP6JEd6zLVFVVxb+goiABoaC2DAYLIAEgAaIiAUSBXgz9///fv6JEAAAAAAAA8D+gIAEgAaIiAkRCOgXhU1WlP6KgIAEgAqIgAURpUO7gQpP5PqJEJx4P6IfAVr+goqC2jAwFCyAEQd/bv4UESw0CIAZBAE4EQCABRNIhM3982RLAoCICIAIgAqIiAaIiAyABIAGioiABRKdGO4yHzcY+okR058ri+QAqv6CiIAIgAyABRLL7bokQEYE/okR3rMtUVVXFv6CioKC2DAULRNIhM3982RLAIAGhIgIgAiACoiIBoiIDIAEgAaKiIAFEp0Y7jIfNxj6iRHTnyuL5ACq/oKIgAiADIAFEsvtuiRARgT+iRHesy1RVVcW/oKKgoLYMBAsgBEHjl9uABEsNAiAGQQBOBEBEGC1EVPsh+T8gAaEiAiACIAKiIgGiIgMgASABoqIgAUSnRjuMh83GPqJEdOfK4vkAKr+goiACIAMgAUSy+26JEBGBP6JEd6zLVFVVxb+goqCgtgwECyABRBgtRFT7Ifk/oCICIAIgAqIiAaIiAyABIAGioiABRKdGO4yHzcY+okR058ri+QAqv6CiIAIgAyABRLL7bokQEYE/okR3rMtUVVXFv6CioKC2DAMLIARBgICAzANPBEAgASABoiIBRIFeDP3//9+/okQAAAAAAADwP6AgASABoiICREI6BeFTVaU/oqAgASACoiABRGlQ7uBCk/k+okQnHg/oh8BWv6CioLYMAwsgBSAAQwAAgHuSOAIIIAUqAggaQwAAgD8MAgtEGC1EVPshGcBEGC1EVPshGUAgBkEAThsgAaAiASABoiIBRIFeDP3//9+/okQAAAAAAADwP6AgASABoiICREI6BeFTVaU/oqAgASACoiABRGlQ7uBCk/k+okQnHg/oh8BWv6CioLYMAQtEGC1EVPshCcBEGC1EVPshCUAgBkEAThsgAaAiASABoiIBRIFeDP3//9+/okQAAAAAAADwP6AgASABoiICREI6BeFTVaU/oqAgASACoiABRGlQ7uBCk/k+okQnHg/oh8BWv6CioLaMCyAFQRBqJAALgQgDBX8DewZ9IAAvAQYhAwJ/IAAvAQQiAkH//wFxRQRAIAJBEHQMAQsgAkH/B3EhBiACQYCAAnEhBCACQYD4AXEiAkGA+AFGBEAgBEEQdCECIAJBgICA/AdyIAZFDQEaIAIgBkENdHJBgICA/gdyDAELIARBEHQhBCACQQ10QYCAgPwAcSAGQQ10ckGAgIDAA2ogBHIgAg0AGiAGIAZnQRBrIgZB//8DcUEIanRB////A3EgBEGAgIDYA3IgBkEXdGtyCyEGIAAvAQghAgJ/IANB//8BcQRAIANB/wdxIQQgA0GAgAJxIQUgA0GA+AFxIgNBgPgBRwRAIAVBEHQhBSADQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogBXIgAw0CGiAEIARnQRBrIgNB//8DcUEIanRB////A3EgBUGAgIDYA3IgA0EXdGtyDAILIAVBEHQhAyADIARBDXRyQYCAgP4HciAEDQEaIANBgICA/AdyDAELIANBEHQLIQMgAf0ABAAhByABKgJEIQsgASoCQCEOIAEqAjwhDCABKgI4IQ0gAf0ABBAhCSABKgI0QwAAgD8CfyACQf//AXEEQCACQf8HcSEEIAJBgIACcSEFIAJBgPgBcSICQYD4AUcEQCAFQRB0IQUgAkENdEGAgID8AHEgBEENdHJBgICAwANqIAVyIAINAhogBCAEZ0EQayICQf//A3FBCGp0Qf///wNxIAVBgICA2ANyIAJBF3RrcgwCCyAFQRB0IQIgAiAEQQ10ckGAgID+B3IgBA0BGiACQYCAgPwHcgwBCyACQRB0C/0RIAb9HAAgA/0cASAH/eUBIgcgB/3mASIIIAf9DQgJCgsAAQIDAAECAwABAgMgCCAIIAf9DQQFBgcAAQIDAAECAwABAgP95AH95AH94wH9HwBDvTeGNRDgCJUiDwJ/IAAvAQoiAUH//wFxRQRAIAFBEHQMAQsgAUH/B3EhACABQYCAAnEhAyABQYD4AXEiAUGA+AFGBEAgA0EQdCEBIAFBgICA/AdyIABFDQEaIAEgAEENdHJBgICA/gdyDAELIANBEHQhAyABQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2ogA3IgAQ0AGiAAIABnQRBrIgBB//8DcUEIanRB////A3EgA0GAgIDYA3IgAEEXdGtyC76UlAJ9IA0gCSAH/eYBIgcgB/0NCAkKCwABAgMAAQIDAAECAyAHIAcgB/0NBAUGBwABAgMAAQIDAAECA/3kAf3kAf0fACIKQwAAAABfDQAaQwAAgD8gCiAPlCIKIA5gDQAaIA0gDCANkyAKIAuVlJIgCiALYEUNABogDEMAAIA/IAyTIAogC5MgDiALk5WUkguUC6UIAQl/IwBBIGsiByQAIARBfHEiBiADaiEFAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACIANJIgkgAiADayADIAJrIgggAiADSxtBAUZxRQRAIAFBA2siBkEAIAEgBk8bIgYgBSAFIAZLGyEKIAlBACAIQQNLGw0BIAMgCkkNAiADIQUMDgsgA0EBayICIAFPDQMgASAFSSADIAVLcg0EIAYEQCAAIANqIAAgAmotAAAgBvwLAAsgBUEBayECDA0LIAMgCkkNASADIQUMDAsgACADaiELIAAgAmohDEEAIQYDQCADIAZqQQNqIAFPDQQgAiAGaiIFQQNqIAFPDQUgASAFTQ0GIAYgC2oiCCAGIAxqIgktAAA6AAAgBUEBaiINIAFPDQcgCEEBaiAJQQFqLQAAOgAAIAEgBUECaiIFSwRAIAhBAmogCUECai0AADoAACAIQQNqIAlBA2otAAA6AAAgAyAGQQRqIgZqIgUgCk8NDAwBCwsgBSABQfyIxQAQjAcACyABQQRrIQYgAyEFA0AgAkEDaiIDIAFPDQcgAkF8Tw0IIAUgBksNCSAAIAVqIAAgAmooAAA2AAAgAkEEaiECIAogBUEEaiIFSw0ACwwKCyACIAFBpIfFABCMBwALIAMgBSABQbSHxQAQ6gcAC0HEh8UAQS9B9IfFABDrBwALQYSIxQBByABBzIjFABDrBwALIAUgAUHciMUAEIwHAAsgDSABQeyIxQAQjAcAC0EAIAMgAUG8jMUAEOoHAAsgAiACQQRqIAFBvIzFABDqBwALIAdBADYCGCAHQQE2AgwgB0HUnMgANgIIIAdCBDcCECAHQQhqQbyMxQAQjQgACyACIAZqIQILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIARBA3FBAWsOAwABAg4LIAEgAksNCiACIAFBjInFABCMBwALIAVBAWoiBiABTw0BIAJBAWoiAyABTw0CIAEgAk0NAyABIAVLDQogBSABQdSKxQAQjAcACyAFQQJqIgYgAU8NAyACQQJqIgMgAU8NBCABIAJNDQUgASAFTQ0GIAAgBWogACACai0AADoAACACQQFqIgIgAU8NByAFQQFqIgUgAUkNCSAFIAFBrIzFABCMBwALQayJxQBBL0HcicUAEOsHAAtB7InFAEHIAEG0isUAEOsHAAsgAiABQcSKxQAQjAcAC0HkisUAQS9BlIvFABDrBwALQaSLxQBByABB7IvFABDrBwALIAIgAUH8i8UAEIwHAAsgBSABQYyMxQAQjAcACyACIAFBnIzFABCMBwALIAEgBUsEQCACIQMgBSEGDAILIAUgAUGcicUAEIwHAAsgACAFaiAAIAJqLQAAOgAACyAAIAZqIAAgA2otAAA6AAALIAdBIGokAAvPBwIJfwJ9IAAgASACEOkEAkACQCACBEAgACgChAFBCGohASAAKAKIASEMQQEhCgNAAkACQCAMIAtBA2pLBEAgCkEBayIGIgUgBE8EQCAGIQoMBwsgBCAFayIFQQAgBCAFTxsiBUEBRg0GIAVBAkYNBSADKgIAEMYFvCIHQf///wNxIQggB0GAgICAeHEhBSABQQRrIgkvAQAhDSADQQRqKgIAIQ4gB0GAgID8B3EiBkGAgID8B0YEQCAFQRB2IAhBDXZyQYAEQQAgCBtyQYD4AXIhBQwDCyAFQRB2IQUgBkGAgIC4BEsNASAGQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAGQQ12IAhBDXZqQYCAAWogBXJqIQUMAwsgBkGAgICYA0kNAiAIQYCAgARyIgdB/gAgBkEXdiIIa3YhBiAHQR0gCGsiCHZBAXEEfyAGQQMgCHRBAWsgB3FBAEdqBSAGCyAFciEFDAILIAsgC0EEaiAMQdi/wQAQ6gcACyAFQYD4AXIhBQsgA0EIaioCACAJIAVBEHQgDXI2AgAgDhDGBbwiB0H///8DcSEIIAdBgICAgHhxIQUCQCAHQYCAgPwHcSIGQYCAgPwHRgRAIAVBEHYgCEENdnJBgARBACAIG3JBgPgBciEFDAELIAVBEHYhBSAGQYCAgLgETQRAIAZBgICAxANPBEAgB0EMdiAHQf/fAHFBAEdxIAZBDXYgCEENdmpBgIABaiAFcmohBQwCCyAGQYCAgJgDSQ0BIAhBgICABHIiB0H+ACAGQRd2IghrdiEGIAdBHSAIayIIdkEBcQR/IAZBAyAIdEEBayAHcUEAR2oFIAYLIAVyIQUMAQsgBUGA+AFyIQULEMYFvCIIQf///wNxIQkgCEGAgICAeHEhBwJAIAhBgICA/AdxIgZBgICA/AdGBEAgB0EQdiAJQQ12ckGABEEAIAkbckGA+AFyIQcMAQsgB0EQdiEHIAZBgICAuARNBEAgBkGAgIDEA08EQCAIQQx2IAhB/98AcUEAR3EgBkENdiAJQQ12akGAgAFqIAdyaiEHDAILIAZBgICAmANJDQEgCUGAgIAEciIIQf4AIAZBF3YiCWt2IQYgCEEdIAlrIgl2QQFxBH8gBkEDIAl0QQFrIAhxQQBHagUgBgsgB3IhBwwBCyAHQYD4AXIhBwsgASAFQf//A3EgB0EQdHI2AgAgAUEQaiEBIAtBBGohCyAKQQNqIQogA0EMaiEDIAJBAWsiAg0ACwsgAEEBOgDAAQ8LIApBAWohCgsgCiAEQei/wQAQjAcAC6IdAwV+EX8Be0HYtckAKQMAIgMgAa2FIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQtii0e/CqeW/LX6FIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRB0LXJACkDACIEQn+FfiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAMgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH6FIAOJIQdByLXJACgCAEUEQAJAIwBBIGsiDiQAAkACQAJAAkACfwJAAkACQAJAQci1yQACfwJAAkACQEHMtckAKAIAQQFqIggEQEHEtckAKAIAIgkgCUEBaiIMQQN2Ig1BB2wgCUEISRsiCUEBdiAISQRAIAlBAWoiCSAIIAggCUkbIghBD0kNAiAIQf////8BTQRAQX8gCEEDdEEHbkEBa2d2IghB/v//P0sNCCAIQQFqIQoMBwsMDgtBACAMRQ0EGkHAtckAKAIAIQsgDSAMQQdxQQBHaiIIQQFNDQIgCyEKIAhB/v///wNxIg0hCQNAIAogCv0AAwAiGf1NQQf9zQH9DAEBAQEBAQEBAQEBAQEBAQH9TiAZ/Qx/f39/f39/f39/f39/f39//VD9zgH9CwMAIApBEGohCiAJQQJrIgkNAAsgCCANRg0DIA1BA3QhCiAIQQFxIQgMAgsMDAtBBCAIQQhxQQhqIAhBBEkbIQoMAwsgCiALaiEKA0AgCiAKKQMAIgNCf4VCB4hCgYKEiJCgwIABgyADQv/+/fv379+//wCEfDcDACAKQQhqIQogCEEBayIIDQALCwJAIAxBCE8EQCALIAxqIAspAAA3AAAMAQsgDEUNACALQQhqIAsgDPwKAAALQQEhCUEAIQgDQCAIIQsgCSEIAkAgC0HAtckAKAIAIglqLQAAQYABRw0AIAkgC0F/c0EFdGohD0EAIAtrQQV0IRQDQEHEtckAKAIAIg1B2LXJACkDACIDIAkgFGpBIGs1AgCFIgRCOIYgBEKA/gODQiiGhCAEQoCA/AeDQhiGIARCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAEQtii0e/CqeW/LX6FIgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRB0LXJACkDACIEQn+FfiIFQjiGIAVCgP4Dg0IohoQgBUKAgPwHg0IYhiAFQoCAgPgPg0IIhoSEIAVCCIhCgICA+A+DIAVCGIhCgID8B4OEIAVCKIhCgP4DgyAFQjiIhISEIAMgBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCAEQgiIQoCAgPgPgyAEQhiIQoCA/AeDhCAEQiiIQoD+A4MgBEI4iISEhH6FIAOJpyITcSIQIQogCSAQaikAAEKAgYKEiJCgwIB/gyIDUARAQQghEQNAIAogEWohCiARQQhqIREgCSAKIA1xIgpqKQAAQoCBgoSIkKDAgH+DIgNQDQALCyAJIAN6p0EDdiAKaiANcSIKaiwAAEEATgRAIAkpAwBCgIGChIiQoMCAf4N6p0EDdiEKCyAKIBBrIAsgEGtzIA1xQQhPBEAgCSAKaiIQLQAAIBAgE0EZdiIQOgAAQcC1yQAoAgAgCkEIayANcWpBCGogEDoAACAJIApBf3NBBXRqIQlB/wFGBEBBxLXJACgCACEKQcC1yQAoAgAgC2pB/wE6AABBwLXJACgCACAKIAtBCGtxakEIakH/AToAACAJQRBqIA9BEGr9AAAA/QsAACAJIA/9AAAA/QsAAAwDCyAPIAlBIBCwA0HAtckAKAIAIQkMAQsLIAkgC2ogE0EZdiIJOgAAQcC1yQAoAgAgDSALQQhrcWpBCGogCToAAAsgCCAIIAxJIgpqIQkgCg0AC0HEtckAKAIAIgggCEEBakEDdkEHbCAIQQhJGwtBzLXJACgCAGs2AgAMBQsgCkEIaiIIIApBBXQiC2oiCSAISSAJQfj///8HS3INACAJEHEiCUUNASAJIAtqIQsgCARAIAtB/wEgCPwLAAsgCkEBayINIApBA3ZBB2wgDUEISRshEUHAtckAKAIAIQlBzLXJACgCACIQDQJBAAwDCyAOQQA2AhggDkEBNgIMIA5BxLXEADYCCCAOQgQ3AhAgDkEIakGYtcQAEI0ICwALIAtBCGohEyAJQSBrIRQgCSkDAEJ/hUKAgYKEiJCgwIB/gyEGQQAhCiAJIQgDQCAGUARAA0AgCkEIaiEKIAhBCGoiCCkDAEKAgYKEiJCgwIB/gyIDQoCBgoSIkKDAgH9RDQALIANCgIGChIiQoMCAf4UhBgsgCyANQdi1yQApAwAiAyAUIAZ6p0EDdiAKaiIVQQV0azUCAIUiBEI4hiAEQoD+A4NCKIaEIARCgID8B4NCGIYgBEKAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIDQjiGIANCgP4Dg0IohoQgA0KAgPwHg0IYhiADQoCAgPgPg0IIhoSEIANCCIhCgICA+A+DIANCGIhCgID8B4OEIANCKIhCgP4DgyADQjiIhISEIARC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhEHQtckAKQMAIgRCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgAyAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoUgA4mnIhZxIgxqKQAAQoCBgoSIkKDAgH+DIgNQBEBBCCEPA0AgDCAPaiEMIA9BCGohDyALIAwgDXEiDGopAABCgIGChIiQoMCAf4MiA1ANAAsLIAZCAX0gBoMhBiALIAN6p0EDdiAMaiANcSIMaiwAAEEATgRAIAspAwBCgIGChIiQoMCAf4N6p0EDdiEMCyALIAxqIBZBGXYiDzoAACATIAxBCGsgDXFqIA86AAAgCyAMQX9zQQV0aiIMQRBqIAkgFUF/c0EFdGoiD0EQav0AAAD9CwAAIAwgD/0AAAD9CwAAIBBBAWsiEA0AC0HAtckAKAIAIQlBzLXJACgCAAshCkHAtckAIAs2AgBBxLXJACgCACEIQcS1yQAgDTYCAEHItckAIBEgCms2AgAgCEUNACAIIAhBBXRBJ2pBYHEiCmpBCWoiCEUNACAJIAprIglBBGsoAgAiCkF4cSILQQRBCCAKQQNxIgobIAhqSQ0BIApBACALIAhBJ2pLGw0CIAkQogILIA5BIGokAAwDC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgDkEANgIYIA5BATYCDCAOQcS1xAA2AgggDkIENwIQIA5BCGpBmLXEABCNCAALC0HEtckAKAIAIgogB6dxIQggB0IZiCIFQv8Ag0KBgoSIkKDAgAF+IQZBwLXJACgCACEJA0ACfwJAAkAgCCAJaikAACIEIAaFIgNCf4UgA0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIDUEUEQANAIAEgCSADeqdBA3YgCGogCnFBBXRrIgtBIGsoAgBGDQIgA0IBfSADgyIDUEUNAAsLIARCgIGChIiQoMCAf4MhAyAXRQRAIANQDQIgA3qnQQN2IAhqIApxIRILQQEgAyAEQgGGg1ANAhogCSASaiwAACIIQQBOBEAgCSAJKQMAQoCBgoSIkKDAgH+DeqdBA3YiEmotAAAhCAsgCSASaiAFp0H/AHEiCzoAACAJIBJBCGsgCnFqQQhqIAs6AABByLXJAEHItckAKAIAIAhBAXFrNgIAIABBgICAgHg2AgBBzLXJAEHMtckAKAIAQQFqNgIAIAkgEkEFdGsiCEEcayIAQRhqIAJBGGooAgA2AgAgACACKQIANwIAIAhBIGsgATYCACAAQQhqIAJBCGr9AAIA/QsCAA8LIAAgC0EcayIB/QACAP0LAgAgASACKQIANwIAIABBGGogAUEYaiIIKAIANgIAIABBEGogAUEQaikCADcCACABQQhqIAJBCGr9AAIA/QsCACAIIAJBGGooAgA2AgAPC0EACyEXIBhBCGoiGCAIaiAKcSEIDAALAAupBwEffyMAQRBrIgYkAAJAAkAgA0EDbCIKQf////8DSw0AIANBDGwiBEH9////B08NAAJAIARFBEBBBCEHDAELIAohCCAEEHEiB0UNAgsgBkEANgIMIAYgBzYCCCAGIAg2AgQCQAJAAkACQAJAAkACQAJAAkACQAJAIAMEQCACIANrIgRBACACIARPGyENIAIgCmsiBEEAIAIgBE8bIQ4gAiADQQlsIgtrIgRBACACIARPGyEPIAIgA0EGbCIMayIEQQAgAiAETxshECABIANqIREgASAKaiESIAEgA0ECdCITaiEUIAEgA0EHbCIVaiEWIAEgA0EKbCIXaiEYIAEgA0EBdCIZaiEaIAEgA0EFbCIbaiEcIAEgA0EDdCIdaiEeIAEgA0ELbCIfaiEgIAEgDGohISABIAtqISJBCCEIQQAhBANAIAIgBEYEQCAEIQUMDQsgBCAORg0JIAQgEEYNCiAEIA9GDQsgASAEai0AACAEIBJqLQAAQQh0ciAEICFqLQAAQRB0ciAEICJqLQAAQRh0ciEJIAYoAgQgBUYEQCAGQQRqQezqxwAQ+gUgBigCCCEHCyAHIAhqQQhrIAk2AgAgBiAFQQFqIgU2AgwgBCANRg0FIAQgE2ogAk8NAiAEIBVqIAJPDQMgBCAXaiACTw0EIAQgEWotAAAgBCAUai0AAEEIdHIgBCAWai0AAEEQdHIgBCAYai0AAEEYdHIhCSAGKAIEIAVGBEAgBkEEakHs6scAEPoFIAYoAgghBwsgByAIakEEayAJNgIAIAYgBUEBaiIJNgIMIAQgGWoiBSACTw0MIAQgG2ogAk8NBiAEIB1qIAJPDQcgBCAfaiACTw0IIAQgGmotAAAgBCAcai0AAEEIdHIgBCAeai0AAEEQdHIgBCAgai0AAEEYdHIhBSAGKAIEIAlGBEAgBkEEakHs6scAEPoFIAYoAgghBwsgByAIaiAFNgIAIAYgCUEBaiIFNgIMIAhBDGohCCADIARBAWoiBEcNAAsLIAAgBikCBDcCACAAQQhqIAZBDGooAgA2AgAgBkEQaiQADwsgA0ECdCAEaiEFDAkLIANBB2wgBGohBQwICyADQQpsIARqIQUMBwsgAyAEaiEFDAYLIANBBWwgBGohBQwFCyADQQN0IARqIQUMBAsgA0ELbCAEaiEFDAMLIAQgCmohBQwCCyAEIAxqIQUMAQsgBCALaiEFCyAFIAJB/OrHABCMBwALQdzqxwAQ/wcLAAuwCAMDfwF8BH0jAEEQayICJAACQCABKAIAQZSAgIB4RgRAAn0CQCAAAn8CQAJAAkACfQJAAkACQAJ9AkACQCABKAIMIgQEQAJ9AkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAggiASgCACIDQYCAgIB4cyADQQBOG0EBaw4KCgABAgMEBQYHCAkLIAEvAQSzDAoLIAEoAgSzDAkLIAEpAwi1DAgLIAEsAASyDAcLIAEuAQSyDAYLIAEoAgSyDAULIAEpAwi0DAQLIAEqAgQMAwsgASsDCCIFtkMAAIA/QwAAgL8gBb1CAFkbmAwCCyABIAJBD2pB2OfAABCVCAwNCyABLQAEswshBiAEQQFGDQQCQAJAAkACQAJAAkACQAJAAkBBFSABKAIQIgNBgICAgHhzIANBAE4bQQFrDgoLAAECAwQFBgcICgsgAS8BFLMMCwsgASgCFLMMCgsgASkDGLUMCQsgASwAFLIMCAsgAS4BFLIMBwsgASgCFLIMBgsgASkDGLQMBQsgASoCFAwECyABKwMYIgW2QwAAgD9DAACAvyAFvUIAWRuYDAMLQQAgAkEPakGk4sAAENsGDAoLIAFBEGogAkEPakHY58AAEJUIDAkLIAEtABSzCyEHIARBAkYNBAJAAkACQAJAAkACQAJAAkACQEEVIAEoAiAiA0GAgICAeHMgA0EAThtBAWsOCgsAAQIDBAUGBwgKCyABLwEkswwLCyABKAIkswwKCyABKQMotQwJCyABLAAksgwICyABLgEksgwHCyABKAIksgwGCyABKQMotAwFCyABKgIkDAQLIAErAygiBbZDAACAP0MAAIC/IAW9QgBZG5gMAwtBASACQQ9qQaTiwAAQ2wYMBgsgAUEgaiACQQ9qQdjnwAAQlQgMBQsgAS0AJLMLIQggBEEDRg0CAkACQAJAAkACQAJAAkACQAJAQRUgASgCMCIDQYCAgIB4cyADQQBOG0EBaw4KDQABAgMEBQYHCAoLIAEvATSzDA0LIAEoAjSzDAwLIAEpAzi1DAsLIAEsADSyDAoLIAEuATSyDAkLIAEoAjSyDAgLIAEpAzi0DAcLIAEqAjQMBgsgASsDOCIFtkMAAIA/QwAAgL8gBb1CAFkbmAwFC0ECIAJBD2pBpOLAABDbBgwCCyABQTBqIAJBD2pB2OfAABCVCAwBC0EDIAJBD2pBpOLAABDbBgs2AgQgAEEBNgIADAMLIAEtADSzCyEJIARBBEcEQCACQQQ2AgggBEH8////AGpB/////wBxQQRqIAJBCGpB6JXBABDbBiEBIABBATYCACAAIAE2AgQMAgsgACAJOAIQIAAgCDgCDCAAIAc4AgggACAGOAIEIABBADYCAAwBCyABIAJBD2pBpOLAABCVCCEBIABBATYCACAAIAE2AgQLIAJBEGokAAvGCAEFfyAAQQhrIgEgAEEEaygCACIDQXhxIgBqIQICQAJAIANBAXENACADQQJxRQ0BIAEoAgAiAyAAaiEAIAEgA2siAUHYuskAKAIARgRAIAIoAgRBA3FBA0cNAUHQuskAIAA2AgAgAiACKAIEQX5xNgIEIAEgAEEBcjYCBCACIAA2AgAPCyABIAMQ1gQLAkACQAJAAkACQAJAAkAgAigCBCIDQQJxRQRAIAJB3LrJACgCAEYNAiACQdi6yQAoAgBGDQMgAiADQXhxIgIQ1gQgASAAIAJqIgBBAXI2AgQgACABaiAANgIAIAFB2LrJACgCAEcNAUHQuskAIAA2AgAPCyACIANBfnE2AgQgASAAQQFyNgIEIAAgAWogADYCAAsgAEGAAkkNAkEfIQIgAUIANwIQIABB////B00EQCAAQSYgAEEIdmciAmt2QQFxIAJBAXRrQT5qIQILIAEgAjYCHCACQQJ0QbC3yQBqIQNBASACdCIEQcy6yQAoAgBxDQMgAyABNgIAIAEgAzYCGCABIAE2AgwgASABNgIIQcy6yQBBzLrJACgCACAEcjYCAAwEC0HcuskAIAE2AgBB1LrJAEHUuskAKAIAIABqIgA2AgAgASAAQQFyNgIEQdi6yQAoAgAgAUYEQEHQuskAQQA2AgBB2LrJAEEANgIACyAAQei6yQAoAgAiAk0NBUHcuskAKAIAIgBFDQVB1LrJACgCACIDQSlJDQRBsLjJACEBA0AgACABKAIAIgVPBEAgACAFIAEoAgRqSQ0GCyABKAIIIQEMAAsAC0HYuskAIAE2AgBB0LrJAEHQuskAKAIAIABqIgA2AgAgASAAQQFyNgIEIAAgAWogADYCAA8LAn9ByLrJACgCACICQQEgAEEDdnQiA3FFBEBByLrJACACIANyNgIAIABB+AFxQcC4yQBqIgAMAQsgAEH4AXEiAkHAuMkAaiEAIAJByLjJAGooAgALIQIgACABNgIIIAIgATYCDCABIAA2AgwgASACNgIIDwsCQAJAIAAgAygCACIDKAIEQXhxRgRAIAMhAgwBCyAAQRkgAkEBdmtBACACQR9HG3QhBANAIAMgBEEddkEEcWoiBSgCECICRQ0CIARBAXQhBCACIQMgAigCBEF4cSAARw0ACwsgAigCCCIAIAE2AgwgAiABNgIIIAFBADYCGCABIAI2AgwgASAANgIIDAELIAVBEGogATYCACABIAM2AhggASABNgIMIAEgATYCCAtBACEBQfC6yQBB8LrJACgCAEEBayIANgIAIAANAUG4uMkAKAIAIgAEQANAIAFBAWohASAAKAIIIgANAAsLQfC6yQBB/x8gASABQf8fTRs2AgAPC0G4uMkAKAIAIgEEQANAIARBAWohBCABKAIIIgENAAsLQfC6yQBB/x8gBCAEQf8fTRs2AgAgAiADTw0AQei6yQBBfzYCAAsLrgcBCX8gACABIAIQzAMCQAJAIAIEQCAAKAJgQQhqIQwgACgCZCENQQEhCgNAAkACQCANIAtBA2pLBEAgCkEBayIBIARPBEAgASEKDAcLIAQgAWsiAUEAIAEgBE0bIgFBAUYNBiABQQJGDQUgAygCACIHQf///wNxIQUgB0GAgICAeHEhCSADQQRqKAIAIQEgB0GAgID8B3EiBkGAgID8B0YEQCAJQRB2IAVBDXZyQYAEQQAgBRtyQYD4AXIhCQwDCyAJQRB2IQkgBkGAgIC4BEsNASAGQYCAgMQDTwRAIAdBDHYgB0H/3wBxQQBHcSAGQQ12IAVBDXZqQYCAAWogCXJqIQkMAwsgBkGAgICYA0kNAiAFQYCAgARyIgVB/gAgBkEXdiIGa3YhByAFQR0gBmsiBnZBAXEEfyAHQQMgBnRBAWsgBXFBAEdqBSAHCyAJciEJDAILIAsgC0EEaiANQYjbwAAQ6gcACyAJQYD4AXIhCQsgA0EIaigCACEHIAFB////A3EhCCABQYCAgIB4cSEGAkAgAUGAgID8B3EiBUGAgID8B0cEQCAGQRB2IQYgBUGAgIC4BE0EQCAFQYCAgMQDTwRAIAFBDHYgAUH/3wBxQQBHcSAFQQ12IAhBDXZqQYCAAWogBnJqIQYMAwsgBUGAgICYA0kNAiAIQYCAgARyIghB/gAgBUEXdiIFa3YhASAIQR0gBWsiBXZBAXEEfyABQQMgBXRBAWsgCHFBAEdqBSABCyAGciEGDAILIAZBgPgBciEGDAELIAZBEHYgCEENdnJBgARBACAIG3JBgPgBciEGCyAHQf///wNxIQggB0GAgICAeHEhAQJAIAdBgICA/AdxIgVBgICA/AdHBEAgAUEQdiEBIAVBgICAuARNBEAgBUGAgIDEA08EQCAHQQx2IAdB/98AcUEAR3EgBUENdiAIQQ12akGAgAFqIAFyaiEBDAMLIAVBgICAmANJDQIgCEGAgIAEciIIQf4AIAVBF3YiBWt2IQcgCEEdIAVrIgV2QQFxBH8gB0EDIAV0QQFrIAhxQQBHagUgBwsgAXIhAQwCCyABQYD4AXIhAQwBCyABQRB2IAhBDXZyQYAEQQAgCBtyQYD4AXIhAQsgDCABOwEAIAxBBGsgCUH//wNxIAZBEHRyNgIAIAxBEGohDCALQQRqIQsgCkEDaiEKIANBDGohAyACQQFrIgINAAsLIABBAToAuAEPCyAKQQFqIQoLIAogBEGY28AAEIwHAAutBwEJfyAAIAEgAhDpBAJAAkAgAgRAIAAoAoQBIQwgACgCiAEhDUEBIQkDQAJAAkAgDSALQQNqSwRAIAlBAWsiASAETwRAIAEhCQwHCyAEIAFrIgFBACABIARNGyIBQQFGDQYgAUECRg0FIAMoAgAiCEH///8DcSEHIAhBgICAgHhxIQYgA0EEaigCACEBIAhBgICA/AdxIgVBgICA/AdGBEAgBkEQdiAHQQ12ckGABEEAIAcbckGA+AFyIQYMAwsgBkEQdiEGIAVBgICAuARLDQEgBUGAgIDEA08EQCAIQQx2IAhB/98AcUEAR3EgBUENdiAHQQ12akGAgAFqIAZyaiEGDAMLIAVBgICAmANJDQIgB0GAgIAEciIIQf4AIAVBF3YiB2t2IQUgCEEdIAdrIgd2QQFxBH8gBUEDIAd0QQFrIAhxQQBHagUgBQsgBnIhBgwCCyALIAtBBGogDUGYu8EAEOoHAAsgBkGA+AFyIQYLIANBCGooAgAhCCABQf///wNxIQogAUGAgICAeHEhBQJAIAFBgICA/AdxIgdBgICA/AdGBEAgBUEQdiAKQQ12ckGABEEAIAobckGA+AFyIQUMAQsgBUEQdiEFIAdBgICAuARNBEAgB0GAgIDEA08EQCABQQx2IAFB/98AcUEAR3EgB0ENdiAKQQ12akGAgAFqIAVyaiEFDAILIAdBgICAmANJDQEgCkGAgIAEciIKQf4AIAdBF3YiB2t2IQEgCkEdIAdrIgd2QQFxBH8gAUEDIAd0QQFrIApxQQBHagUgAQsgBXIhBQwBCyAFQYD4AXIhBQsgDCAGQf//A3EgBUEQdHI2AgAgCEH///8DcSEFIAhBgICAgHhxIQECQCAIQYCAgPwHcSIGQYCAgPwHRgRAIAFBEHYgBUENdnJBgARBACAFG3JBgPgBciEBDAELIAFBEHYhASAGQYCAgLgETQRAIAZBgICAxANPBEAgCEEMdiAIQf/fAHFBAEdxIAZBDXYgBUENdmpBgIABaiABcmohAQwCCyAGQYCAgJgDSQ0BIAVBgICABHIiCEH+ACAGQRd2IgZrdiEFIAhBHSAGayIGdkEBcQR/IAVBAyAGdEEBayAIcUEAR2oFIAULIAFyIQEMAQsgAUGA+AFyIQELIAxBBGogATsBACAMQRBqIQwgC0EEaiELIAlBA2ohCSADQQxqIQMgAkEBayICDQALCyAAQQE6AMABDwsgCUEBaiEJCyAJIARBqLvBABCMBwALqggCB38CfiMAQUBqIgIkAAJAAkACQAJAAkAgASgCFCIDIAEoAhAiBEkEQCABKAIMIQgCfgJAA0AgAyAIai0AACIFQQlrIgZBF0tBASAGdEGTgIAEcUVyDQEgASADQQFqIgM2AhQgAyAERw0ACyAEIQNCAAwBC0KAAgsgBa1CEIaEQoCCuANRDQELAkACQAJAIAJBEGogASgCDCIFIAQgAyAESQR/A0ACQCADIAVqLQAAIgZBCWsOJQAABAQABAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAMECyABIANBAWoiAzYCFCADIARHDQALIAQFIAMLQQFqIgEgBCABIARJGxD5ASACKAIUIQEgAigCECEEQRQQcSIDRQ0EIAMgBDYCDCADQQU2AgAgAyABNgIQDAYLIAEgA0EBajYCFCACQRhqIAFBABDHAyACKQMYIgpCA1ENBCACKQMgIQkCQAJAAkAgCqdBAWsOAgABAgsgCUKAgICAEFQNAyACQQE6ACggAiAJNwMwIAJBKGogAkE/akGY58AAEN4GIAEQ6wUhAwwHCyAJQoCAgIAQVA0CIAJBAjoAKCACIAk3AzAgAkEoaiACQT9qQZjnwAAQ3gYgARDrBSEDDAYLIAJBAzoAKCACIAk3AzAgAkEoaiACQT9qQZjnwAAQ3wYgARDrBSEDDAULIAZBMGtB/wFxQQpPBEAgASACQT9qQZjnwAAQ7gEgARDrBSEDDAULIAJBGGogAUEBEMcDIAIpAxgiCkIDUQRAIAIoAiAhAwwFCyACKQMgIQkCfwJAAkACQCAKp0EBaw4CAAECCyAJQoCAgIAQVA0DIAJBAToAKCACIAk3AzAgAkEoaiACQT9qQZjnwAAQ3gYMAgsgCUKAgICAEFQNAiACQQI6ACggAiAJNwMwIAJBKGogAkE/akGY58AAEN4GDAELIAJBAzoAKCACIAk3AzAgAkEoaiACQT9qQZjnwAAQ3wYLIAEQ6wUhAwwECyAAIAk+AgQgAEEBNgIADAQLIAEgA0EBaiIHNgIUAkACQAJAIAQgB00NACABIANBAmoiBTYCFCAHIAhqLQAAQfUARw0BIAUgByAEIAQgB0kbIgdGDQAgASADQQNqIgY2AhQgBSAIai0AAEHsAEcEQCAGIQUMAgsgBiAHRg0AIAEgA0EEaiIFNgIUIAYgCGotAABB7ABHDQEgAEEANgIADAYLIAIgCCAEIAcQ+QEgAigCBCEEIAIoAgAhAUEUEHEiA0UNAiADQQU2AgAMAQsgAkEIaiAIIAQgBRD5ASACKAIMIQQgAigCCCEBQRQQcSIDRQ0BIANBCTYCAAsgAyABNgIMIAAgAzYCBCAAQQI2AgAgAyAENgIQDAMLAAsgAigCICEDCyAAQQI2AgAgACADNgIECyACQUBrJAALmAcCDn8CfiMAQdAAayICJAAgACgCCCEDIAAoAgQhBQJAAn9BASABKAIAIghBIiABKAIEIgooAhAiCxECAA0AGiACIAM2AgggAiAFNgIEIAJBL2qtQoCAgICAB4QhEANAAkAgAkEMaiACQQRqEO0DIAgCfwJAIAIoAgwiBQRAIAIoAhghDCACKAIUIQ1BACACKAIQIgNFDQIaIAMgBWohD0EAIQAgBSEBQQAhBwNAAn8gASwAACIEQQBOBEAgBEH/AXEhBCABQQFqDAELIAEtAAFBP3EhBiAEQR9xIQkgBEFfTQRAIAlBBnQgBnIhBCABQQJqDAELIAEtAAJBP3EgBkEGdHIhBiAEQXBJBEAgBiAJQQx0ciEEIAFBA2oMAQsgCUESdEGAgPAAcSABLQADQT9xIAZBBnRyciEEIAFBBGoLIQkgAkEcaiAEQYGCBBCBAyACLQApIAItAChrQf8BcUEBRwRAAkACQCAAIAdLDQACQCAARQ0AIAAgA08EQCAAIANHDQIMAQsgACAFaiwAAEG/f0wNAQsCQCAHRQ0AIAMgB00EQCADIAdGDQEMAgsgBSAHaiwAAEG/f0wNAQsgCCAAIAVqIAcgAGsgCigCDBEAAEUNAQwHCyAFIAMgACAHQYCKwwAQuwkACyACQThqIAJBJGopAgA3AwAgAiACKQIcIhE3AzAgAi0APCEAAkAgAi0APSIGQYEBTwRAIBGnIQ4DQCAAQf8BcSAGTw0CIABBAWohACAIIA4gCxECAEUNAAsMBwsgACAGIAAgBksbIQYDQCAAIAZGDQEgAkEwaiAAaiEOIABBAWohACAIIA4tAAAgCxECAEUNAAsMBgsCf0EBIARBgAFJDQAaQQIgBEGAEEkNABpBA0EEIARBgIAESRsLIAdqIQALIAcgAWsgCWohByAJIgEgD0cNAAsMAQsgCEEiIAsRAgAMBAtBACAARQ0AGiAAIANPBEAgAyAAIANGDQEaDAULIAAgBWosAABBQEgNBCAACyIBIAVqIAMgAWsgCigCDBEAAA0AIAxFDQEDQCACIA0tAAA6AC8gAkEBNgJEIAJB6InDADYCQCACQQE2AjQgAkHgicMANgIwIAJBATYCPCACIBA3A0ggAiACQcgAajYCOCAIIAogAkEwahDBAw0BIA1BAWohDSAMQQFrIgwNAAsMAQsLQQELIAJB0ABqJAAPCyAFIAMgACADQcyJwwAQuwkAC+MHAwZ/B30BeyMAQZABayICJAAgAiAAKAIAIgb9AAIAIg8gD/0NAAECAwQFBgcICQoLCAkKC/0LBAAgAgJ/IA/9GQYiA0H//wFxRQRAIANBEHQMAQsgA0H/B3EhBCADQYCAAnEhBSADQYD4AXEiA0GA+AFGBEAgBUEQdCIDQYCAgPwHciAERQ0BGiADIARBDXRyQYCAgP4HcgwBCyAFQRB0IgUgA0ENdEGAgID8AHEgBEENdHJBgICAwANqciADDQAaIAQgBGdBEGsiBEH//wNxQQhqdEH///8DcSAFQYCAgNgDciAEQRd0a3ILNgIcIAJDAAAAACAAKAIEIgAqAgAgAC0AHEECRiIEGyIIIAZBEGotAAAiA7NDAAB/Q5VDAACAPyAAKgIEIAQbIAiTIgmUkv0TIAggBkEOai8BACIFIANBEHRyQf8BcbNDAAB/Q5UgCZSS/SAAIAggBUEIdrNDAAB/Q5UgCZSS/SAB/QsEICAGQRFqLwAAIAZBE2otAAAiA0EQdHIiBUEIdiEHQwAAEEEgACoCDCAEGyEJQwAAQMEgACoCCCAEGyEIIAVB/wFxBEAgCCAJIAiTQwAAfkOVIAVBAWtB/wFxs5SSEIkEIQsLIAdB/wFxBEAgCCAJIAiTQwAAfkOVIAdBAWtB/wFxs5SSEIkEIQoLIAIgAwR9IAggCSAIk0MAAH5DlSADQQFrQf8BcbOUkhCJBAVDAAAAAAv9EyAL/SAAIAr9IAH9CwQwQwAAgD8gBkEUai8BACIAQQh2s/0TIAAgBkEWai0AACIGQRB0ckH/AXGz/SAB/QwAAH9DAAB/QwAAf0MAAH9D/ecBIg8gD/3kAf0MAACAvwAAgL8AAIC/AACAv/3kASIP/R8BIgqLkyAP/R8AIgyLkyIIjEMAAAAAEOAIIQkgAiAGs0MAAH9DlUMAAAA/lEPbD0lAlCINEJkCIgsgCiAJIAmMIg4gD/0MAAAAAAAAAAAAAAAAAAAAAP1G/U0iD/3HAf0bAkEBcRuSIgogCCAIlCAKIAqUIAwgCSAOIA/9GwBBAXEbkiIJIAmUkpKRIgqVlP0TIAsgCSAKlZT9IAEgCyAIIAqVlP0gAiANEJsC/SAD/QsEQCACIAJBQGutQoCAgIDAAoQ3A3AgAiACQTBqrUKAgICAoAKENwNoIAIgAkEgaq1CgICAgKAChDcDYCACIAJBHGqtQoCAgIDQAoQ3A1ggAiACrUKAgICAoAKENwNQIAEoAgAgASgCBCACQgU3AoQBIAJBBjYCfCACQeCqxwA2AnggAiACQdAAajYCgAEgAkH4AGoQwQMgAkGQAWokAAuyBwEJfyMAQdAAayIBJABBgYDEACECAkACQCAAKAIEIgQgACgCECIDSQ0AIAAgBCADayIENgIEIAAgACgCACICIANqIgg2AgACQAJAIANBAkYEQCACLQAAIgNBwQBrQV9xQQpqIANBMGsgA0E5SxsiBUEPSw0EIAItAAEiA0HBAGtBX3FBCmogA0EwayADQTlLGyIDQRBPDQQgBUEEdCADciIFwEEATg0BQYCAxAAhAiAFQf8BcSIDQcABSQ0DAn9BAiADQeABSQ0AGkEDIANB8AFJDQAaIANB+AFPDQRBBAshA0EAIQIgAUEAOgATIAFBADsAESABIAU6ABAgASADNgIMIANBAXRBAmshCSABIAFBEGo2AgggAUERaiEFA0AgBEECSQRAQYCAxAAhAgwFCyAAIARBAmsiBDYCBCAAIAIgCGoiBkECajYCACAGLQAAIgdBwQBrQV9xQQpqIAdBMGsgB0E5SxsiB0EPSw0FIAZBAWotAAAiBkHBAGtBX3FBCmogBkEwayAGQTlLGyIGQRBPDQUgBSAHQQR0IAZyOgAAIAVBAWohBSAJIAJBAmoiAkcNAAsMAgtBpPjGAEEoQbywxQAQ6wcAC0EBIQMgAUEBNgIMIAFBADoAEyABQQA7ABEgASAFOgAQIAEgAUEQajYCCAsgAUE4aiABQRBqIAMQ+wJBgIDEACECIAEoAjgNACABKAI8IQAgASABKAJAIgI2AhggASAANgIUIAAgAmohAwJAIAJFDQAgAwJ/IAAsAAAiAkEATgRAIAJB/wFxIQIgAEEBagwBCyAALQABQT9xIQUgAkEfcSEEIAJBX00EQCAEQQZ0IAVyIQIgAEECagwBCyAALQACQT9xIAVBBnRyIQUgAkFwSQRAIAUgBEEMdHIhAiAAQQNqDAELIARBEnRBgIDwAHEgAC0AA0E/cSAFQQZ0cnIhAiAAQQRqCyIERwRAIAQsAAAaDAELIAJBgIDEAEcNAQsgAQJ/QQAhAiADIABrIgRBEE8EQCAAIAQQxwIMAQsgACADRwRAA0AgAiAALAAAQb9/SmohAiAAQQFqIQAgBEEBayIEDQALCyACCzYCNCABQQQ2AiAgAUG8scUANgIcIAFCAzcCKCABIAFBNGqtQoCAgIAQhDcDSCABIAFBFGqtQoCAgICgDYQ3A0AgASABQQhqrUKAgICAsA2ENwM4IAEgAUE4ajYCJCABQRxqQdyxxQAQjQgACyABQdAAaiQAIAIPC0GssMUAEN0JAAvpBwIGfQZ/AkACQAJAIAQEQEMAAHxCIAWVIQUgAUEBdiEQIAFBAWpBAXYhEQNAIAxBCWoiDyADSyANQZuOx+MBS3INA0MAAHxCQwAAfMIgBSACQSBqKgIAlCIHIAdDAAB8wl0bIgcgB0MAAHxCXhsQuQchB0MAAHxCQwAAfMIgBSACQRxqKgIAlCIIIAhDAAB8wl0bIgggCEMAAHxCXhsQuQchCEMAAHxCQwAAfMIgBSACQRBqKgIAlCIJIAlDAAB8wl0bIgkgCUMAAHxCXhsQuQchCUMAAHxCQwAAfMIgBSACQRRqKgIAlCIKIApDAAB8wl0bIgogCkMAAHxCXhsQuQchCkMAAHxCQwAAfMIgBSACQRhqKgIAlCILIAtDAAB8wl0bIgsgC0MAAHxCXhsQuQchCyANIBFGDQQgAEH/AEMAAHxCQwAAfMIgBSACKgIAlCIGIAZDAAB8wl0bIgYgBkMAAHxCXhsQuQciBvwAQYB/IAZDAAAAw2AbIAZDAAD+Ql4bQQAgBiAGWxtB/wBxQf8AQwAAfEJDAAB8wiAFIAJBBGoqAgCUIgYgBkMAAHzCXRsiBiAGQwAAfEJeGxC5ByIG/ABBgH8gBkMAAADDYBsgBkMAAP5CXhtBACAGIAZbG0H/AHFBB3RyQf8AQwAAfEJDAAB8wiAFIAJBCGoqAgCUIgYgBkMAAHzCXRsiBiAGQwAAfEJeGxC5ByIG/ABBgH8gBkMAAADDYBsgBkMAAP5CXhtBACAGIAZbG0H/AHFBDnRyQf8AQwAAfEJDAAB8wiAFIAJBDGoqAgCUIgYgBkMAAHzCXRsiBiAGQwAAfEJeGxC5ByIG/ABBgH8gBkMAAADDYBsgBkMAAP5CXhtBACAGIAZbG0H/AHFBFXRyQf8AIAn8AEGAfyAJQwAAAMNgGyAJQwAA/kJeG0EAIAkgCVsbQf8AcSIMQRx0cjYCACANIBBGDQIgAEEEakH/ACAI/ABBgH8gCEMAAADDYBsgCEMAAP5CXhtBACAIIAhbG0H/AHFBEXRB/wAgB/wAQYB/IAdDAAAAw2AbIAdDAAD+Ql4bQQAgByAHWxtB/wBxQRh0ckH/ACAK/ABBgH8gCkMAAADDYBsgCkMAAP5CXhtBACAKIApbG0H/AHFBA3QgDEEEdnJB/wAgC/wAQYB/IAtDAAAAw2AbIAtDAAD+Ql4bQQAgCyALWxtB/wBxQQp0cnI2AgAgAEEIaiEAIA5BAmohDiACQSRqIQIgDyEMIAQgDUEBaiINRw0ACwsPCyAOQQFqIAFBoM7HABCMBwALIAwgDyADQbDOxwAQ6gcACyAOIAFBkM7HABCMBwAL/AoCC3sIfyADBEAgBSABIAJrIhFBACABIBFPGyIWIAUgFkkbIhEgA0EBayISIBEgEkkbQQFqIhJBBEsEQCAC/REhDv0MAAAAAAEAAAACAAAAAwAAACELIAQhESASIBJBA3EiE0EEIBMbayITIRIDQCAAIAsgDv2uASIM/RsAQRhsaiAR/QACACIG/Qz//38A//9/AP//fwD//38A/U4iB0EN/a0BIAb9DAAAAIAAAACAAAAAgAAAAID9TkEQ/a0BIgj9UCIJIAf9DAAAAAAAAAAAAAAAAAAAAAD9OP0MAAIAAAACAAAAAgAAAAIAAP1O/VAgBv0NAAEEBQgJDA0AAQABAAEAAf0MAHwAfAB8AHwAfAB8AHwAfCIN/VAgCCAG/Q0AAQQFCAkMDQABAAEAAQABIA39UCAJIAb9DAAAgH8AAIB/AACAfwAAgH8iDf1OIglBDf2tAf0MAEAAAABAAAAAQAAAAEAAAP2uAf1QIAb9DQABBAUICQwNAAEAAQABAAEgBv0MABAAAAAQAAAAEAAAABAAAP1OIAr9OCAG/Qz/LwAA/y8AAP8vAAD/LwAA/U4gCv04/U79DAEAAAABAAAAAQAAAAEAAAD9TiAG/Q0AAQQFCAkMDQABAAEAAQAB/Y4BIAj9DAAAgPoAAID6AACA+gAAgPoiCCAH/QwAAIAAAACAAAAAgAAAAIAA/VAiBv0bAP0MfgAAAH4AAAB+AAAAfgAAACAJQRf9rQEiD/2xASIH/RsAdv0RIAb9GwEgB/0bAXb9HAEgBv0bAiAH/RsCdv0cAiAG/RsDIAf9GwN2/RwDIAn9DAAAgMcAAIDHAACAxwAAgMf9rgEiECAI/ToiCEEB/QwdAAAAHQAAAB0AAAAdAAAAIA/9sQH9DB8AAAAfAAAAHwAAAB8AAAD9TiIH/RsAIhV0/RFBASAH/RsBIhR0/RwBQQEgB/0bAiIXdP0cAkEBIAf9GwMiGHT9HAMgBv1OIAr9OP1QQQMgFXT9EUEDIBR0/RwBQQMgF3T9HAJBAyAYdP0cA/0M//////////////////////2uASAG/U4gCv04/U79sQEgCP1S/VAgBv0NAAEEBQgJDA0AAQABAAEAASAQ/QwBAIAOAQCADgEAgA4BAIAO/TogBv0NAAEEBQgJDA0AAQABAAEAAf1SIAn9DAAAAEcAAABHAAAARwAAAEf9PCAG/Q0AAQQFCAkMDQABAAEAAQAB/VIgCSAN/TcgBv0NAAEEBQgJDA0AAQABAAEAAf1SIgb9WQEMACAAIAz9GwFBGGxqIAb9WQEMASAAIAz9GwJBGGxqIAb9WQEMAiAAIAz9GwNBGGxqIAb9WQEMAyARQRBqIREgC/0MBAAAAAQAAAAEAAAABAAAAP2uASELIBJBBGsiEg0ACwsgBCATQQJ0aiERIAIgE2pBGGwgAGpBDGohEgNAAkACQCATIBZHBEAgBSATRwRAIBEoAgAiFUH///8DcSEUIBVBgICAgHhxIQQgFUGAgID8B3EiAEGAgID8B0YEQCAUQQ12IARBEHZyQYAEQQAgFBtyQYD4AXIhBAwECyAEQRB2IQQgAEGAgIC4BEsNAiAAQYCAgMQDTwRAIBVBDHYgFUH/3wBxQQBHcSAAQQ12IBRBDXZqQYCAAWogBHJqIQQMBAsgAEGAgICYA0kNAyAUQYCAgARyIhVB/gAgAEEXdiIUa3YhACAVQR0gFGsiFHZBAXEEfyAAQQMgFHRBAWsgFXFBAEdqBSAACyAEciEEDAMLIAUgBUGEw8cAEIwHAAsgAiATaiABQey7xwAQjAcACyAEQYD4AXIhBAsgEiAEOwEAIBJBGGohEiARQQRqIREgAyATQQFqIhNHDQALCwv8CgILewh/IAMEQCAFIAEgAmsiEUEAIAEgEU8bIhYgBSAWSRsiESADQQFrIhIgESASSRtBAWoiEkEESwRAIAL9ESEO/QwAAAAAAQAAAAIAAAADAAAAIQsgBCERIBIgEkEDcSITQQQgExtrIhMhEgNAIAAgCyAO/a4BIgz9GwBBJGxqIBH9AAIAIgb9DP//fwD//38A//9/AP//fwD9TiIHQQ39rQEgBv0MAAAAgAAAAIAAAACAAAAAgP1OQRD9rQEiCP1QIgkgB/0MAAAAAAAAAAAAAAAAAAAAAP04/QwAAgAAAAIAAAACAAAAAgAA/U79UCAG/Q0AAQQFCAkMDQABAAEAAQAB/QwAfAB8AHwAfAB8AHwAfAB8Ig39UCAIIAb9DQABBAUICQwNAAEAAQABAAEgDf1QIAkgBv0MAACAfwAAgH8AAIB/AACAfyIN/U4iCUEN/a0B/QwAQAAAAEAAAABAAAAAQAAA/a4B/VAgBv0NAAEEBQgJDA0AAQABAAEAASAG/QwAEAAAABAAAAAQAAAAEAAA/U4gCv04IAb9DP8vAAD/LwAA/y8AAP8vAAD9TiAK/Tj9Tv0MAQAAAAEAAAABAAAAAQAAAP1OIAb9DQABBAUICQwNAAEAAQABAAH9jgEgCP0MAACA+gAAgPoAAID6AACA+iIIIAf9DAAAgAAAAIAAAACAAAAAgAD9UCIG/RsA/Qx+AAAAfgAAAH4AAAB+AAAAIAlBF/2tASIP/bEBIgf9GwB2/REgBv0bASAH/RsBdv0cASAG/RsCIAf9GwJ2/RwCIAb9GwMgB/0bA3b9HAMgCf0MAACAxwAAgMcAAIDHAACAx/2uASIQIAj9OiIIQQH9DB0AAAAdAAAAHQAAAB0AAAAgD/2xAf0MHwAAAB8AAAAfAAAAHwAAAP1OIgf9GwAiFXT9EUEBIAf9GwEiFHT9HAFBASAH/RsCIhd0/RwCQQEgB/0bAyIYdP0cAyAG/U4gCv04/VBBAyAVdP0RQQMgFHT9HAFBAyAXdP0cAkEDIBh0/RwD/Qz//////////////////////a4BIAb9TiAK/Tj9Tv2xASAI/VL9UCAG/Q0AAQQFCAkMDQABAAEAAQABIBD9DAEAgA4BAIAOAQCADgEAgA79OiAG/Q0AAQQFCAkMDQABAAEAAQAB/VIgCf0MAAAARwAAAEcAAABHAAAAR/08IAb9DQABBAUICQwNAAEAAQABAAH9UiAJIA39NyAG/Q0AAQQFCAkMDQABAAEAAQAB/VIiBv1ZARQAIAAgDP0bAUEkbGogBv1ZARQBIAAgDP0bAkEkbGogBv1ZARQCIAAgDP0bA0EkbGogBv1ZARQDIBFBEGohESAL/QwEAAAABAAAAAQAAAAEAAAA/a4BIQsgEkEEayISDQALCyAEIBNBAnRqIREgAiATakEkbCAAakEUaiESA0ACQAJAIBMgFkcEQCAFIBNHBEAgESgCACIVQf///wNxIRQgFUGAgICAeHEhBCAVQYCAgPwHcSIAQYCAgPwHRgRAIBRBDXYgBEEQdnJBgARBACAUG3JBgPgBciEEDAQLIARBEHYhBCAAQYCAgLgESw0CIABBgICAxANPBEAgFUEMdiAVQf/fAHFBAEdxIABBDXYgFEENdmpBgIABaiAEcmohBAwECyAAQYCAgJgDSQ0DIBRBgICABHIiFUH+ACAAQRd2IhRrdiEAIBVBHSAUayIUdkEBcQR/IABBAyAUdEEBayAVcUEAR2oFIAALIARyIQQMAwsgBSAFQdTFxwAQjAcACyACIBNqIAFB5MDHABCMBwALIARBgPgBciEECyASIAQ7AQAgEkEkaiESIBFBBGohESADIBNBAWoiE0cNAAsLC7wJAgJ/AXsjAEHQAGsiAiQAIAJBDmpBADoAACACQR5qQQA6AAAgAkEmakEAOgAAIAJBLmpBADoAACACQTZqQQA6AAAgAkE+akEAOgAAIAJBxgBqQQA6AAAgAkEAOwEMIAJBFmpBADoAACACQQA7ARwgAkEAOwEkIAJBADsBLCACQQA7ATQgAkEAOwE8IAJBADsBRCACQQA7ARQgAkHOAGpBADoAACACQQA7AUxBgCEQcSIDBEAgA0HI1cYAQYAh/AoAACAAQQE2AnAgAP0MAAAAAAAAAAAAAAAAAAAAAP0LAnQgAEL/gYCAgH83AoQBIABBADYCoAUgAEHyAToAkwEgAEEANgKYBCAAQoCAgIAQNwOQBCAAQQA6AKYFIABBADsBpAUgAEKAgICAEDcDACAAQgA3AwggAEIBNwMQIABCgICAgBA3AxggAEHoA2ogAUEQaikDADcDACAAIAH9AAMA/QsD2AMgACACKAIINgKMASAAQY8BaiACKAALNgAAIABBJ2pCADcAACAAQgA3AyAgAEIANwMwIABBN2pCADcAACAAQgA3A0AgAEHHAGpCADcAACAAQgA3A1AgAEHXAGpCADcAACAAQgA3A2AgAEHnAGpCADcAACAAIAT9CwPwAyAAQYAEaiAE/QsDACAAQQE2ApgBIAAgBP0LApwBIABC/4GAgIB/NwKsASAAQbcBaiACKAATNgAAIAAgAigCEDYCtAEgACAE/QsCxAEgAEEBNgLAASAAQfIBOgC7ASAAQv+BgICAfzcC1AEgAEHyAToA4wEgACAE/QsC7AEgAEEBNgLoASAAQv+BgICAfzcC/AEgAEEBNgKQAiAAIAT9CwKUAiAAQfIBOgCLAiAAQd8BaiACKAAbNgAAIAAgAigCGDYC3AEgAEGHAmogAigAIzYAACAAIAIoAiA2AoQCIABC/4GAgIB/NwKkAiAAQa8CaiACKAArNgAAIAAgAigCKDYCrAIgACAE/QsCvAIgAEEBNgK4AiAAQfIBOgCzAiAAQv+BgICAfzcCzAIgAEHXAmogAigAMzYAACAAIAIoAjA2AtQCIAAgBP0LAuQCIABBATYC4AIgAEHyAToA2wIgAEL/gYCAgH83AvQCIABB/wJqIAIoADs2AAAgACACKAI4NgL8AiAAIAT9CwKMAyAAQQE2AogDIABB8gE6AIMDIABC/4GAgIB/NwKcAyAAQacDaiACKABDNgAAIAAgAigCQDYCpAMgACAE/QsCtAMgAEEBNgKwAyAAQfIBOgCrAyAAQv+BgICAfzcCxAMgAEHPA2ogAigASzYAACAAIAIoAkg2AswDIABBAToApwUgAEHyAToA0wMgAEH8BGpB0PbGACgAADYAACAAQcj2xgApAAA3APQEIABBADoAqAUgACADNgLwBCAAQQA6AIAFIABCADcCpAQgAEKAgICAEDcCnAQgAEGYBWpCADcBACAAQZIFakIANwEAIAAgBP0LAYIFIABBADYC7AQgAEKAgICAEDcC5AQgAEIBNwLcBCAAQgA3AtQEIABCgICAgBA3AswEIABCATcCxAQgAEIANwK8BCAAQoCAgIAQNwK0BCAAQgE3AqwEIAJB0ABqJAAPCwAL2AcCDH8BeyMAQYAIayIGJAACQAJAAkAgASgC2AFBgYCAgHhHBEAgASgC3AEhAiABKALgASEHIAEoAtABIQsgASgC1AEhDCABKALMASENQQAhAQNAIAEgBmr9DAAAAP8AAAD/AAAA/wAAAP/9CwAAIAFBEGoiAUGACEcNAAsgB0EDbiEKIAdBBE8EQCAHQQRrIgFBC00EQEGAAiEEIAYhASAHIQMMAwtBgAJBgAIgAUEDbiIBIAFBgAJPG0EBaiIBIAFBA3EiAUEEIAEbayIFayEEIAcgBUF9bGohAyACIAVBA2xqIAYgBUECdGohASAGIQgDQCAIIAJBCWogAkEGaiACQQNqIAL9XAAA/VYAAAH9VgAAAv1WAAAD/QsAACACQQxqIQIgCEEQaiEIIAVBBGsiBQ0ACyECDAILIAYhASAHIQMgB0UNAwwCC0GgmcUAQRRBtJnFABCrBwALA0AgBEUEQEEAQQBB9JnFABCMBwALIAEgAigAADYAACABQQRqIQEgBEEBayEEIAJBA2ohAiADQQNrIgNBA0sNAAsgBA0AQQBBAEHEmcUAEIwHAAsgA0EDRgRAIAEgAi8AADsAACABQQJqIAJBAmotAAA6AAAMAQtBAEEDIANB1JnFABDqBwALAkBBAEEAIAwgDUGBgICAeEYiARsiAyADIApLIgMbIghFDQBBAUEBIAsgAxsgARshA0GAAiAIIAhBgAJPGyEJQQAhBSAIQRBPBEAgCUHwA3EhBSAJQQJ0QUBxIQtBACEBIAMhBANAIAEgBmoiAkE/aiAE/QAAACIO/VgAAA8gAkE7aiAO/VgAAA4gAkE3aiAO/VgAAA0gAkEzaiAO/VgAAAwgAkEvaiAO/VgAAAsgAkEraiAO/VgAAAogAkEnaiAO/VgAAAkgAkEjaiAO/VgAAAggAkEfaiAO/VgAAAcgAkEbaiAO/VgAAAYgAkEXaiAO/VgAAAUgAkETaiAO/VgAAAQgAkEPaiAO/VgAAAMgAkELaiAO/VgAAAIgAkEHaiAO/VgAAAEgAkEDaiAO/VgAAAAgBEEQaiEEIAsgAUFAayIBRw0ACyAFIAlGDQELIAkgBWshBCADIAVqIQIgBUECdCAGakEDaiEBA0AgASACLQAAOgAAIAJBAWohAiABQQRqIQEgBEEBayIEDQALCyAHQYMGSQRAIAggCkcEQCAKQQJ0IAhBAnQiB2shASAGIAdqQQNqIQIDQCACQf8BOgAAIAJBBGohAiABQQRrIgENAAsLIAAgBkGACPwKAAAgBkGACGokAA8LIAggCkGAAkHkmcUAEOoHAAvSCAEEfyMAQSBrIgIkAAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4DAQIDAAsgAiAAKAIENgIEIAEoAgBBoPvHAEECIAEoAgQoAgwRAAAhACACQQA6AA0gAiAAOgAMIAIgATYCCCACQQhqQbT7xwBBBCACQQRqQaT7xwAQjAUgAkEpOgATQcj7xwBBBCACQRNqQbj7xwAQjAVBFBBxIgBFDQQgAEEQakHcgsgAKAAANgAAIABBzILIAP0AAAD9CwAAIAJBFDYCHCACIAA2AhggAkEUNgIUQdz7xwBBByACQRRqQcz7xwAQjAUhASACLQANIgMgAi0ADCIEciEAAkAgBEEBcSADQQFHcg0AIAEoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEADAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAAsgAigCFCIBRQ0DIAIoAhgiA0EEaygCACIEQXhxIgVBBEEIIARBA3EiBBsgAWpJDQUgBEEAIAUgAUEnaksbDQYgAxCiAgwDCyAALQABIQNBASEAIAEoAgBB4/vHAEEEIAEoAgQoAgwRAAANAgJAIAEtAApBgAFxRQRAIAEoAgBBu7PFAEEBIAEoAgQoAgwRAAANBCABKAIAIANBAnQiAygCpKhJIAMoAvymSSABKAIEKAIMEQAARQ0BDAQLIAEoAgBB24HCAEECIAEoAgQoAgwRAAANAyACQQE6AAggAiABKQIANwIUIANBAnQiAygCzKlJIQQgAygC9KpJIQMgAiACQQhqNgIcIAJBFGoiBSADIAQQrwMNAyAFQdmBwgBBAhCvAw0DCyABKAIAQd6OyABBASABKAIEKAIMEQAAIQAMAgsgACgCBCEAIAEoAgBB5/vHAEEFIAEoAgQoAgwRAAAhAyACQQA6ABkgAiADOgAYIAIgATYCFCACQRRqQcj7xwBBBCAAQQhqQbj7xwAQjAVB3PvHAEEHIABB7PvHABCMBSACLQAZIgMgAi0AGCIEciEAIARBAXEgA0EBR3INASgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQAMAgsgACgCAEGls8UAQQEgACgCBCgCDBEAACEADAELIAIgACgCBCIANgIIIAEoAgBBjPzHAEEGIAEoAgQoAgwRAAAhAyACQQA6ABkgAiADOgAYIAIgATYCFCACQRRqQcj7xwBBBCAAQQhqQbj7xwAQjAVBupjIAEEFIAJBCGpB/PvHABCMBSACLQAZIgMgAi0AGCIEciEAIARBAXEgA0EBR3INACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQAMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEACyACQSBqJAAgAEEBcQ8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALvQcDCX8CfAJ+IwBBMGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQCABKAIUIgYgASgCECIFSQRAIAEoAgwiCSAGai0AACIHQS5GDQEgB0HFAEYgB0HlAEZyDQILIAJFDQJCASEPDAgLIAEgBkEBaiIGNgIUIAUgBk0NAyAGIAVrIQcCQANAIAYgCWotAAAiCkEwayILQf8BcSIMQQpPBEAgCEUNBiAKQSByQeUARwRAIAghBwwGCyAEQSBqIAEgAiADIAgQ2AIMCAsgDEEFSyADQpmz5syZs+bMGVJyIANCmLPmzJmz5swZVnENASABIAZBAWoiBjYCFCAIQQFrIQggA0IKfiALrUL/AYN8IQMgBSAGRw0ACyAFIQYgB0UNBQwDCyAEQSBqIAEgAiADIAgQ6AYMBQsgBEEgaiABIAIgA0EAENgCIAQoAiBFDQUgACAEKAIkNgIIIABCAzcDAAwHC0IAIAN9IhBCAFMEQEICIQ8gECEDDAYLIAO6vUKAgICAgICAgIB/hCEDDAULIAO6IQ0CQAJAAkAgByAHQR91IgFzIAFrIgFBtQJPBEADQCANRAAAAAAAAAAAYQ0EIAdBAE4NAiANRKDI64XzzOF/oyENIAdBtAJqIgcgB0EfdSIBcyABayIBQbUCTw0ACwsgAUEDdCsDoIJHIQ4gB0EATg0BIA0gDqMhDQwCCyAEQRBqIAkgBSAGEPkBIAQoAhQhAiAEKAIQIQVBFBBxIgFFDQggASAFNgIMIAFBDjYCACABIAI2AhAgBCABNgIkIARBATYCIAwECyANIA6iIg2ZRAAAAAAAAPB/Yg0AIARBCGogCSAFIAYQ+QEgBCgCDCECIAQoAgghBUEUEHEiAUUNByABIAU2AgwgAUEONgIAIAEgAjYCECAEIAE2AiQgBEEBNgIgDAMLIAQgDSANmiACGzkDKCAEQQA2AiAMAgsgBSAGTQ0AIARBGGogCSAFIAZBAWoiASAFIAEgBUkbEPkBIAQoAhwhAiAEKAIYIQVBFBBxIgFFDQUgASAFNgIMIAFBDTYCACABIAI2AhAgBCABNgIkIARBATYCIAwBCyAEIAkgBSAGQQFqIgEgBSABIAVJGxD5ASAEKAIEIQIgBCgCACEFQRQQcSIBRQ0EIAEgBTYCDCABQQU2AgAgASACNgIQIAQgATYCJCAEQQE2AiALIAQoAiBFDQAgACAEKAIkNgIIIABCAzcDAAwCCyAEKQMoIQMLIAAgAzcDCCAAIA83AwALIARBMGokAA8LAAvqBwENfyMAQUBqIgUkAEEAELYJIQYgBUEQakEAOgAAIAVBPGogBEEYaigCADYCACAFQTRqIARBEGopAgA3AgAgBUEaaiAEQR9qLQAAOgAAIAVCADcDCCAFIAT9AAIA/QsCJCAFIAQvAB07ARggBC0AHCEPIAEQuAohECAGQYQITwRAIAYQmwcLAkAgA0UEQAwBC0H458AAQQMQ7AghBCADKAIAIgogBBDiCCEIQbS7yQAtAAAhA0G0u8kAQQA6AABBuLvJACgCAEG4u8kAQQA2AgAgCCADGyELAkACQAJAIANFBEAgCxC5CkUEQEEBIQkMBAsgC0GDCEsNAQwCCyALQYQISQ0CCyALEJsHCwsgBEGECE8EQCAEEJsHCyAKQfvnwABBAxDsCCIDEOIIIQhBtLvJAC0AACEEQbS7yQBBADoAAEG4u8kAKAIAQbi7yQBBADYCACAIIAQbIQYCfwJAAkAgBEUEQCAGELkKRQRAQQEhDUECDAQLIAZBgwhLDQEMAgsgCSAGQYQISQ0CGgsgBhCbBwsgCQshCCADQYQITwRAIAMQmwcLIApBjOzAAEEDEOwIIgQQ4gghA0G0u8kALQAAIQdBtLvJAEEAOgAAQbi7yQAoAgBBuLvJAEEANgIAIAMgBxshAwJAAkACQCAHRQRAIAMQuQpFBEBBASEMQQMhCAwECyADQYMISw0BDAILIANBhAhJDQILIAMQmwcLCyAEQYQITwRAIAQQmwcLQQAhByAKQYbowABBBxDsCCIKEOIIIQRBtLvJAC0AACEOQbS7yQBBADoAAEG4u8kAKAIAQbi7yQBBADYCACAEIA4bIQQCQAJAAkAgDkUEQCAEELkKRQRAQQEhD0EBIQcMBAsgBEGDCEsNAQwCCyAEQYQISQ0CCyAEEJsHCwsgCkGECEkNACAKEJsHCyAAQYCAgIB4NgJ0IABBgICAgHg2AmggAEIENwJgIABCADcCWCAAQoCAgIDAADcCUCAAQgQ3AkggAEIANwJAIABCgICAgMAANwI4IAAgBDYCNCAAIAc2AjAgAEEANgIoIABBADYCICAAQQA2AhggACADNgIUIAAgDDYCECAAIAY2AgwgACANNgIIIAAgCzYCBCAAIAk2AgAgACAPOgCcASAAIAE2AqwBIAAgCDYCqAEgACACNgKkASAAIBBBAnY2AqABIABBmAFqIAVBPGooAgA2AgAgAEGIAWogBUEsav0AAgD9CwIAIAAgBf0AAhz9CwJ4IAAgBS8BGDsAnQEgAEGfAWogBUEaai0AADoAACAAIAUpAwg3ArABIABBuAFqIAVBEGotAAA6AAAgBUFAayQAC8cHAgZ/AnsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAFFBEBBBCELDAELIAFBAnQQcSILRQ0BIAFBBE8EQCABQXxxIgwhCQNAIAggC2ogACAIav0AAgD9DLtukD67bpA+u26QPrtukD795gH9DAAAAD8AAAA/AAAAPwAAAD/95AH9CwIAIAhBEGohCCAJQQRrIgkNAAsgASAMRg0BCyAMQQJ0IQggASAMayEJA0AgCCALaiAAIAhqKgIAQ7tukD6UQwAAAD+SOAIAIAhBBGohCCAJQQFrIgkNAAsLQYAIEHEiAEUNAP0MAAAAAAEAAAACAAAAAwAAACEOQQAhCANAIAAgCGoiCSAO/fsB/QwAAH9DAAB/QwAAf0MAAH9DIg/95wH9CwIAIAlBEGogDv0MBAAAAAQAAAAEAAAABAAAAP2uAf37ASAP/ecB/QsCACAO/QwIAAAACAAAAAgAAAAIAAAA/a4BIQ4gCEEgaiIIQYAIRw0ACwJAAkAgBwRAQQAhCUEAIQgDQCADIAhNDQUgASACIAhqIgwtAAAiCk0NBiAFIAlNDQcgBCALIApBAnRqKgIAOAIAIAhBAWoiCiADTw0IIAEgDEEBai0AACIKTQ0JIAlBAWoiDSAFTw0KIARBBGogCyAKQQJ0aioCADgCACAIQQJqIgogA08NCyABIAxBAmotAAAiCk0NDCAJQQJqIg0gBU8NDSAEQQhqIAsgCkECdGoqAgA4AgAgCEEDaiIKIANPDQ4gBiAIaiAAIAxBA2otAABBAnRqKgIAOAIAIARBDGohBCAJQQNqIQkgCEEEaiEIIAdBAWsiBw0ACyAAQQRrKAIAIgJBeHFBhAhBiAggAkEDcSIDG0kNDiADQQAgAkGoCE8bDQ8gABCiAgwBCyAAQQRrKAIAIgJBeHFBhAhBiAggAkEDcSIDG0kNDSADQQAgAkGoCE8bDQ4gABCiAiABRQ0BCyALQQRrKAIAIgBBeHEiAiABQQJ0IgFBBEEIIABBA3EiABtqSQ0MIABBACACIAFBJ2pLGw0NIAsQogILDwsACyAIIANBgPHHABCMBwALIAogAUGQ8ccAEIwHAAsgCSAFQaDxxwAQjAcACyAKIANBsPHHABCMBwALIAogAUHA8ccAEIwHAAsgDSAFQdDxxwAQjAcACyAKIANB4PHHABCMBwALIAogAUHw8ccAEIwHAAsgDSAFQYDyxwAQjAcACyAKIANBkPLHABCMBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9kGAg1/An0gAEGstskAKAIAIgcEfyMAQRBrIQhBrLbJACAHQQFrIgY2AgBBqLbJACgCACIFIAZBDGxqIgQoAgghASAEKAIEIQMgBCgCACEEAkAgBkUEQCABIQogAyELIAQhDAwBCyAFKAAAIQwgBSAENgAAIAUoAAQhCyAFIAM2AAQgBUEIaiIDKAAAIQogAyABNgAAIAhBCGogAygCADYCACAIIAUpAgA3AwBBASEBIAdBBE8EQCAGQQJrIgFBACABIAZNGyEGQQEhAQNAAn8gBSABQQxsaiIDQQxqIgQqAgAiDiAOWyAOIAMqAgAiD2BFcSIJIAlBfyAOIA9fGyAPIA9cGyIJBEAgCUEATAwBCyADKAIEIgkgBCgCBCINRwRAIAkgDU0MAQsgAygCCCAEKAIITQshAyAFIAJBDGxqIgQgBSABIANqIgJBDGxqIgEpAgA3AgAgBEEIaiABQQhqKAIANgIAIAJBAXQiA0EBciEBIAMgBkkNAAsLAkAgB0ECayABRwRAIAIhAQwBCyAFIAJBDGxqIgIgBSABQQxsaiIDKQIANwIAIAJBCGogA0EIaigCADYCAAsgBSABQQxsaiICIAgpAwA3AgAgAkEIaiAIQQhqKAIAIgg2AgAgAigCBCEDIAIqAgAhDgJAIAFFBEBBACEBDAELIA4gDlsEQANAAkAgBSABIgJBAWsiBkEBdiIBQQxsaiIEKgIAIg8gD1sgDiAPX0VxQX8gDiAPYBsiBwRAIAdBAEoNASACIQEMBAsgBCgCBCIHIANHBEAgAyAHSw0BIAIhAQwECyAIIAQoAghLDQAgAiEBDAMLIAUgAkEMbGoiAiAEKQIANwIAIAJBCGogBEEIaigCADYCACAGQQFLDQAMAgsACwNAAkAgBSABIgJBAWsiBkEBdiIBQQxsaiIEKgIAIg8gD1sgDiAPX0VxDQAgBCgCBCIHIANHBEAgAyAHSw0BIAIhAQwDCyAIIAQoAghLDQAgAiEBDAILIAUgAkEMbGoiAiAEKQIANwIAIAJBCGogBEEIaigCADYCACAGQQJPDQALCyAFIAFBDGxqIgEgCDYCCCABIAM2AgQgASAOOAIACyAAIAo2AgwgACALNgIIIAAgDDYCBEEBBSABCzYCAAuWCAMGfwR7An0gBUEDbiEKIAEqAgAhESAAKgIAIRACQAJAAkACQAJAAkACQAJAQYAIEHEiCEUNACARIBCT/RMhDiAQ/RMhD/0MAAAAAAEAAAACAAAAAwAAACEMA0AgBiAIaiAPIA4gDP37Af0MAAB/QwAAf0MAAH9DAAB/Q/3nAf3mAf3kASIN/R8AEIkE/RMgDf0fARCJBP0gASAN/R8CEIkE/SACIA39HwMQiQT9IAP9CwIAIAz9DAQAAAAEAAAABAAAAAQAAAD9rgEhDCAGQRBqIgZBgAhHDQALIAEqAgQgACoCBCEQQYAIEHEiCUUNACAQk/0TIQ4gEP0TIQ/9DAAAAAABAAAAAgAAAAMAAAAhDEEAIQYDQCAGIAlqIA8gDiAM/fsB/QwAAH9DAAB/QwAAf0MAAH9D/ecB/eYB/eQBIg39HwAQiQT9EyAN/R8BEIkE/SABIA39HwIQiQT9IAIgDf0fAxCJBP0gA/0LAgAgDP0MBAAAAAQAAAAEAAAABAAAAP2uASEMIAZBEGoiBkGACEcNAAsgASoCCCAAKgIIIRBBgAgQcSIARQ0AIBCT/RMhDiAQ/RMhD/0MAAAAAAEAAAACAAAAAwAAACEMQQAhBgNAIAAgBmogDyAOIAz9+wH9DAAAf0MAAH9DAAB/QwAAf0P95wH95gH95AEiDf0fABCJBP0TIA39HwEQiQT9IAEgDf0fAhCJBP0gAiAN/R8DEIkE/SAD/QsCACAM/QwEAAAABAAAAAQAAAAEAAAA/a4BIQwgBkEQaiIGQYAIRw0ACwJAIAVBA08EQEEAIQZBACEBA0AgAyAGTQ0EIAEgBU8NBSAEIAggAiAGaiILLQAAQQJ0aioCADgCACAGQQFqIgcgA08NBiABQQFqIgcgBU8NByAEQQRqIAkgC0EBai0AAEECdGoqAgA4AgAgBkECaiIHIANPDQggAUECaiIHIAVPDQIgBEEIaiAAIAtBAmotAABBAnRqKgIAOAIAIAZBBGohBiAEQQxqIQQgAUEDaiEBIApBAWsiCg0ACwsgAEEEaygCACIBQXhxQYQIQYgIIAFBA3EiAhtJDQcgAkEAIAFBqAhPGw0IIAAQogIgCUEEaygCACIAQXhxQYQIQYgIIABBA3EiARtJDQcgAUEAIABBqAhPGw0IIAkQogIgCEEEaygCACIAQXhxQYQIQYgIIABBA3EiARtJDQcgAUEAIABBqAhPGw0IIAgQogIPCyAHIAVBoPXHABCMBwsACyAGIANB0PTHABCMBwALIAEgBUHg9McAEIwHAAsgByADQfD0xwAQjAcACyAHIAVBgPXHABCMBwALIAcgA0GQ9ccAEIwHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALggcBA34gASgCACACQQZ0ayIBQUBqKQMAIAAoAgAoAgAiACkDCIUiA0LYotHvwqnlvy1+IAFBOGspAwCFIANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIUiA0LYotHvwqnlvy1+IAFBMGspAwCFIANCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIRC0oGqm6v6gtenf34iA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhIUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhELSgaqbq/qC16d/fiIEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEIANC2KLR78Kp5b8tfoUiA0I4hiADQoD+A4NCKIaEIANCgID8B4NCGIYgA0KAgID4D4NCCIaEhCADQgiIQoCAgPgPgyADQhiIQoCA/AeDhCADQiiIQoD+A4MgA0I4iISEhCAAKQMAIgRCf4V+IgVCOIYgBUKA/gODQiiGhCAFQoCA/AeDQhiGIAVCgICA+A+DQgiGhIQgBUIIiEKAgID4D4MgBUIYiEKAgPwHg4QgBUIoiEKA/gODIAVCOIiEhIQgAyAEQjiGIARCgP4Dg0IohoQgBEKAgPwHg0IYhiAEQoCAgPgPg0IIhoSEIARCCIhCgICA+A+DIARCGIhCgID8B4OEIARCKIhCgP4DgyAEQjiIhISEfoUgA4kLwwYBDH8jAEEQayIJJABBASELAkAgAigCACIKQSIgAigCBCIMKAIQIg0RAgANAAJAAkAgAUUEQEEAIQFBACECDAELIAAhBSABIQYDQCAFIAZqIQ5BACECAkACQANAIAIgBWoiBy0AACIIQf8Aa0H/AXFBoQFJIAhBIkZyIAhB3ABGcg0BIAYgAkEBaiICRw0ACyADIAZqIQMMAQsgAiADaiEDAkACQCAHLAAAIgJBAE4EQCAHQQFqIQUgAkH/AXEhAgwBCyAHLQABQT9xIQUgAkEfcSEGIAJBX00EQCAGQQZ0IAVyIQIgB0ECaiEFDAELIActAAJBP3EgBUEGdHIhCCACQXBJBEAgCCAGQQx0ciECIAdBA2ohBQwBCyAHQQRqIQUgBkESdEGAgPAAcSAHLQADQT9xIAhBBnRyciICQYCAxABGDQELIAkgAkGBgAQQgQMCQCAJLQANIgYgCS0ADCIHayIIQf8BcUEBRg0AAkACQAJAIAMgBEkNAAJAIARFDQAgASAETQRAIAEgBEcNAgwBCyAAIARqLAAAQb9/TA0BCwJAIANFDQAgASADTQRAIAEgA0YNAQwCCyAAIANqLAAAQb9/TA0BCyAKIAAgBGogAyAEayAMKAIMIgQRAABFDQEMAgsgACABIAQgA0GogcIAELsJAAsCQCAGQYEBTwRAIAogCSgCACANEQIADQIMAQsgCiAHIAlqIAggBBEAAA0BCyACQYABSQRAIANBAWohBAwCCyACQYAQSQRAIANBAmohBAwCC0EDQQQgAkGAgARJGyADaiEEDAELDAYLAn9BASACQYABSQ0AGkECIAJBgBBJDQAaQQNBBCACQYCABEkbCyADaiEDCyAOIAVrIgYNAQsLIAMgBEkNAUEAIQICQCAERQ0AIAEgBE0EQCAEIAEiAkcNAwwBCyAEIgIgAGosAABBv39MDQILIANFBEBBACEBDAELIAEgA00EQCABIANGDQEgAiEEDAILIAAgA2osAABBv39MBEAgAiEEDAILIAMhAQsgCiAAIAJqIAEgAmsgDCgCDBEAAA0BIApBIiANEQIAIQsMAQsgACABIAQgA0G4gcIAELsJAAsgCUEQaiQAIAsLzwYBCH8jAEEwayEIA0AgASgCACIEQf///wNxIQMgBEGAgICAeHEhBgJAIARBgICA/AdxIgJBgICA/AdGBEAgA0ENdiAGQRB2ckGABEEAIAMbckGA+AFyIQYMAQsgBkEQdiEGIAJBgICAuARNBEAgAkGAgIDEA08EQCAEQQx2IARB/98AcUEAR3EgAkENdiADQQ12akGAgAFqIAZyaiEGDAILIAJBgICAmANJDQEgA0GAgIAEciIEQf4AIAJBF3YiA2t2IQIgBEEdIANrIgN2QQFxBH8gAkEDIAN0QQFrIARxQQBHagUgAgsgBnIhBgwBCyAGQYD4AXIhBgsgAUEEaigCACIDQf///wNxIQUgA0GAgICAeHEhBAJAIANBgICA/AdxIgJBgICA/AdHBEAgBEEQdiEEIAJBgICAuARNBEAgAkGAgIDEA08EQCADQQx2IANB/98AcUEAR3EgAkENdiAFQQ12akGAgAFqIARyaiEEDAMLIAJBgICAmANJDQIgBUGAgIAEciIDQf4AIAJBF3YiBWt2IQIgA0EdIAVrIgV2QQFxBH8gAkEDIAV0QQFrIANxQQBHagUgAgsgBHIhBAwCCyAEQYD4AXIhBAwBCyAFQQ12IARBEHZyQYAEQQAgBRtyQYD4AXIhBAsgAUEIaigCACIFQf///wNxIQcgBUGAgICAeHEhAwJAIAVBgICA/AdxIgJBgICA/AdHBEAgA0EQdiEDIAJBgICAuARNBEAgAkGAgIDEA08EQCAFQQx2IAVB/98AcUEAR3EgAkENdiAHQQ12akGAgAFqIANyaiEDDAMLIAJBgICAmANJDQIgB0GAgIAEciIFQf4AIAJBF3YiB2t2IQIgBUEdIAdrIgd2QQFxBH8gAkEDIAd0QQFrIAVxQQBHagUgAgsgA3IhAwwCCyADQYD4AXIhAwwBCyAHQQ12IANBEHZyQYAEQQAgBxtyQYD4AXIhAwsgCEEGaiAJaiICIAY7AQAgAkEEaiADOwEAIAJBAmogBDsBACABQQxqIQEgCUEGaiIJQSpHDQALIAAgCP0AAQb9CwEAIABBKGogCEEuai8BADsBACAAQSBqIAhBJmopAQA3AQAgAEEQaiAIQRZq/QABAP0LAQALogcCCH8CfiMAQZACayICJAACQCABKAK4AiIDQQNNBEAgAEEAOwEADAELIAIgASgCtAIiBSgAACIENgIIAkACQAJAAkAgBEHSgpGaBEYEQCADQQhJBEAgAEEAOgABIABBADoAAAwGCyADIAUoAAQiBkEHakF4cSIIQRBqIgRJDQEgBkEIaiIHIANLIAZBd0tyDQIgAkEANgKAAiACIAY2AvwBIAIgBUEIajYC+AEgAkEYaiACQfgBahBvIAIoAhwhBiACKAIYIglBAkYEQCAAIAYQzgc2AgQgAEEBOgAADAYLIAJBkAFqIAJBIGpB6AD8CgAAIAIgBjYCjAEgAiAJNgKIASAIQQhqIgggBEsNAyABQQA2ArgCIAMgBGshByAFIAhqKQAAIQsCQAJAIARFDQAgAyAERg0BIAdFDQAgBSAEIAVqIAf8CgAACyABIAc2ArgCCyABIAEpA3AgBK18Igo3A3AgASAKIAt8NwOIASABIAo3A4ABAkAgAigC8AFBAUYEQCABIAIpA5ABPgKoAiABIAIoApgBIgM2AqwCIAEoApABQQJGDQEMBgsgAkEBNgIcIAJBhMnBADYCGCACQgE3AiQgAiACQfABaq1CgICAgBCENwOIAiACIAJBiAJqNgIgIAJB+AFqIgEgAkEYahCxBiABEI4HIQEgAigC5AEiAwRAIAIoAugBIANBKGxBCBCiBwsgACABNgIEIABBAToAAAwGCyABQQA2AqgCIAIgAi0A9AFBAXE6ACAgAiAGQQAgCUEBcRs2AhwgAiADNgIYIAFBvAJqIAJBGGoQ4QMMBAsgAkEBNgIsIAJBzMjBADYCKCACQQE2AhwgAkGQzsEANgIYIAJBATYCJCACIAJBCGqtQoCAgICQBIQ3A/gBIAIgAkH4AWo2AiAgAkEMaiIBIAJBGGoQsQYgACABEI4HNgIEIABBAToAAAwECyAAQQA6AAEgAEEAOgAADAMLQQggByADQeTNwQAQ6gcACyAIIAQgA0HUzcEAEOoHAAsgAUEANgKkAgJAIAEoAgBBAkYNACABKAJcIgNFDQACQCABKAJgIgRBBGsoAgAiBUF4cSIGIANBKGwiA0EEQQggBUEDcSIFG2pPBEAgBUEAIAYgA0EnaksbDQEgBBCiAgwCC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgASACQYgBakHwAPwKAAAgAEGAAjsBAAsgAkGQAmokAAumBwIIfwJ+IwBBkAJrIgIkAAJAAkACQCABKALgAiIDQQNNBEAgAEEAOwEADAELIAIgASgC3AIiBSgAACIENgIIAkACQAJAAkAgBEHSgpGaBEYEQCADQQhJBEAgAEEAOgABIABBADoAAAwGCyADIAUoAAQiBkEHakF4cSIIQRBqIgRJDQEgBkEIaiIHIANLIAZBd0tyDQIgAkEANgKAAiACIAY2AvwBIAIgBUEIajYC+AEgAkEYaiACQfgBahBvIAIoAhwhBiACKAIYIglBAkYEQCAAIAYQzgc2AgQgAEEBOgAADAYLIAJBkAFqIAJBIGpB6AD8CgAAIAIgBjYCjAEgAiAJNgKIASAIQQhqIgggBEsNAyABQQA2AuACIAMgBGshByAFIAhqKQAAIQsCQAJAIARFDQAgAyAERg0BIAdFDQAgBSAEIAVqIAf8CgAACyABIAc2AuACCyABIAEpA7gCIAStfCIKNwO4AiABIAogC3w3A9ACIAEgCjcDyAIgAigC8AFBAUYEQCABIAIpA5ABPgL0AiABIAIoApgBIgM2AvgCIAEoAgBBAkcNBSABQQA2AvQCIAIgAi0A9AFBAXE6ACAgAiAGQQAgCUEBcRs2AhwgAiADNgIYIAFB+AFqIAJBGGoQhAIMBQsgAkEBNgIcIAJBhMnBADYCGCACQgE3AiQgAiACQfABaq1CgICAgBCENwOIAiACIAJBiAJqNgIgIAJB+AFqIgEgAkEYahCxBiABEI4HIQEgAigC5AEiAwRAIAIoAugBIANBKGxBCBCiBwsgACABNgIEIABBAToAAAwFCyACQQE2AiwgAkHMyMEANgIoIAJBATYCHCACQZDOwQA2AhggAkEBNgIkIAIgAkEIaq1CgICAgJAEhDcD+AEgAiACQfgBajYCICACQQxqIgEgAkEYahCxBiAAIAEQjgc2AgQgAEEBOgAADAQLIABBADoAASAAQQA6AAAMAwtBCCAHIANB5M3BABDqBwALIAggBCADQdTNwQAQ6gcACyABQQA2AvACAkAgASgCiAFBAkYNACABKALkASIDRQ0AIAEoAugBIgRBBGsoAgAiBUF4cSIGIANBKGwiA0EEQQggBUEDcSIFG2pJDQIgBUEAIAYgA0EnaksbDQMgBBCiAgsgAUGIAWogAkGIAWpB8AD8CgAAIABBgAI7AQALIAJBkAJqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAumBwIIfwJ+IwBBkAJrIgIkAAJAAkACQCABKAKAAyIDQQNNBEAgAEEAOwEADAELIAIgASgC/AIiBSgAACIENgIIAkACQAJAAkAgBEHSgpGaBEYEQCADQQhJBEAgAEEAOgABIABBADoAAAwGCyADIAUoAAQiBkEHakF4cSIIQRBqIgRJDQEgBkEIaiIHIANLIAZBd0tyDQIgAkEANgKAAiACIAY2AvwBIAIgBUEIajYC+AEgAkEYaiACQfgBahBvIAIoAhwhBiACKAIYIglBAkYEQCAAIAYQzgc2AgQgAEEBOgAADAYLIAJBkAFqIAJBIGpB6AD8CgAAIAIgBjYCjAEgAiAJNgKIASAIQQhqIgggBEsNAyABQQA2AoADIAMgBGshByAFIAhqKQAAIQsCQAJAIARFDQAgAyAERg0BIAdFDQAgBSAEIAVqIAf8CgAACyABIAc2AoADCyABIAEpA9gCIAStfCIKNwPYAiABIAogC3w3A/ACIAEgCjcD6AIgAigC8AFBAUYEQCABIAIpA5ABPgKUAyABIAIoApgBIgM2ApgDIAEoAgBBAkcNBSABQQA2ApQDIAIgAi0A9AFBAXE6ACAgAiAGQQAgCUEBcRs2AhwgAiADNgIYIAFB+AFqIAJBGGoQ6QEMBQsgAkEBNgIcIAJBhMnBADYCGCACQgE3AiQgAiACQfABaq1CgICAgBCENwOIAiACIAJBiAJqNgIgIAJB+AFqIgEgAkEYahCxBiABEI4HIQEgAigC5AEiAwRAIAIoAugBIANBKGxBCBCiBwsgACABNgIEIABBAToAAAwFCyACQQE2AiwgAkHMyMEANgIoIAJBATYCHCACQZDOwQA2AhggAkEBNgIkIAIgAkEIaq1CgICAgJAEhDcD+AEgAiACQfgBajYCICACQQxqIgEgAkEYahCxBiAAIAEQjgc2AgQgAEEBOgAADAQLIABBADoAASAAQQA6AAAMAwtBCCAHIANB5M3BABDqBwALIAggBCADQdTNwQAQ6gcACyABQQA2ApADAkAgASgCiAFBAkYNACABKALkASIDRQ0AIAEoAugBIgRBBGsoAgAiBUF4cSIGIANBKGwiA0EEQQggBUEDcSIFG2pJDQIgBUEAIAYgA0EnaksbDQMgBBCiAgsgAUGIAWogAkGIAWpB8AD8CgAAIABBgAI7AQALIAJBkAJqJAAPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuiBwIIfwJ+IwBBkAJrIgIkAAJAIAEoArgCIgNBA00EQCAAQQA7AQAMAQsgAiABKAK0AiIFKAAAIgQ2AggCQAJAAkACQCAEQdKCkZoERgRAIANBCEkEQCAAQQA6AAEgAEEAOgAADAYLIAMgBSgABCIGQQdqQXhxIghBEGoiBEkNASAGQQhqIgcgA0sgBkF3S3INAiACQQA2AoACIAIgBjYC/AEgAiAFQQhqNgL4ASACQRhqIAJB+AFqEG8gAigCHCEGIAIoAhgiCUECRgRAIAAgBhDOBzYCBCAAQQE6AAAMBgsgAkGQAWogAkEgakHoAPwKAAAgAiAGNgKMASACIAk2AogBIAhBCGoiCCAESw0DIAFBADYCuAIgAyAEayEHIAUgCGopAAAhCwJAAkAgBEUNACADIARGDQEgB0UNACAFIAQgBWogB/wKAAALIAEgBzYCuAILIAEgASkDcCAErXwiCjcDcCABIAogC3w3A4gBIAEgCjcDgAECQCACKALwAUEBRgRAIAEgAikDkAE+AqgCIAEgAigCmAEiAzYCrAIgASgCkAFBAkYNAQwGCyACQQE2AhwgAkGEycEANgIYIAJCATcCJCACIAJB8AFqrUKAgICAEIQ3A4gCIAIgAkGIAmo2AiAgAkH4AWoiASACQRhqELEGIAEQjgchASACKALkASIDBEAgAigC6AEgA0EobEEIEKIHCyAAIAE2AgQgAEEBOgAADAYLIAFBADYCqAIgAiACLQD0AUEBcToAICACIAZBACAJQQFxGzYCHCACIAM2AhggAUG8AmogAkEYahClBAwECyACQQE2AiwgAkHMyMEANgIoIAJBATYCHCACQZDOwQA2AhggAkEBNgIkIAIgAkEIaq1CgICAgJAEhDcD+AEgAiACQfgBajYCICACQQxqIgEgAkEYahCxBiAAIAEQjgc2AgQgAEEBOgAADAQLIABBADoAASAAQQA6AAAMAwtBCCAHIANB5M3BABDqBwALIAggBCADQdTNwQAQ6gcACyABQQA2AqQCAkAgASgCAEECRg0AIAEoAlwiA0UNAAJAIAEoAmAiBEEEaygCACIFQXhxIgYgA0EobCIDQQRBCCAFQQNxIgUbak8EQCAFQQAgBiADQSdqSxsNASAEEKICDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyABIAJBiAFqQfAA/AoAACAAQYACOwEACyACQZACaiQAC+oGAQV/AkACQAJAAkACQAJAAkAgAEEEayIHKAIAIghBeHEiBEEEQQggCEEDcSIFGyABak8EQCAFQQAgAUEnaiIGIARJGw0BAkAgAkEJTwRAIAIgAxDBBCICDQFBAA8LQQAhAiADQcz/e0sNCEEQIANBC2pBeHEgA0ELSRshASAAQQhrIQYgBUUEQCAGRSABQYACSXIgBCABa0GAgAhLIAEgBE9ycg0HIAAPCyAEIAZqIQUCQCABIARLBEAgBUHcuskAKAIARg0BQdi6yQAoAgAgBUcEQCAFKAIEIghBAnENCSAIQXhxIgggBGoiBCABSQ0JIAUgCBDWBCAEIAFrIgVBEE8EQCAHIAEgBygCAEEBcXJBAnI2AgAgASAGaiIBIAVBA3I2AgQgBCAGaiIEIAQoAgRBAXI2AgQgASAFEOMCDAkLIAcgBCAHKAIAQQFxckECcjYCACAEIAZqIgEgASgCBEEBcjYCBAwIC0HQuskAKAIAIARqIgQgAUkNCAJAIAQgAWsiBUEPTQRAIAcgCEEBcSAEckECcjYCACAEIAZqIgEgASgCBEEBcjYCBEEAIQVBACEBDAELIAcgASAIQQFxckECcjYCACABIAZqIgEgBUEBcjYCBCAEIAZqIgQgBTYCACAEIAQoAgRBfnE2AgQLQdi6yQAgATYCAEHQuskAIAU2AgAMBwsgBCABayIEQQ9NDQYgByABIAhBAXFyQQJyNgIAIAEgBmoiASAEQQNyNgIEIAUgBSgCBEEBcjYCBCABIAQQ4wIMBgtB1LrJACgCACAEaiIEIAFLDQQMBgsgAyABIAEgA0sbIgMEQCACIAAgA/wKAAALIAcoAgAiA0F4cSIHIAFBBEEIIANBA3EiARtqSQ0CIAFFIAYgB09yDQZBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcACyAHIAEgCEEBcXJBAnI2AgAgASAGaiIFIAQgAWsiAUEBcjYCBEHUuskAIAE2AgBB3LrJACAFNgIACyAGRQ0AIAAPCyADEHEiAUUNASADQXxBeCAHKAIAIgJBA3EbIAJBeHFqIgIgAiADSxsiAgRAIAEgACAC/AoAAAsgASECCyAAEKICCyACC68HAQZ/IwBBQGoiAyQAIAAoAgwhBAJAAkACQCAAKAIUIgEgACgCECICSQRAA0AgASAEai0AACIGQQlrIgVBGUsNAkEBIAV0QZOAgARxRQRAIAVBGUcNAyAAEMsEIQEMBAsgACABQQFqIgE2AhQgASACRw0ACyACIQELIANBEGogBCACIAFBAWoiACACIAAgAkkbEPkBIAMoAhQhACADKAIQIQJBFBBxIgFFDQIgASACNgIMIAFBBTYCACABIAA2AhAMAQsgBkH7AEYEQCAAIAAtABhBAWsiBToAGCABQQFqIQEgBUH/AXEEQCAAIAE2AhQCQCAAEMsEIgFFBEAgACgCDCEEAkACQCAAKAIUIgEgACgCECICSQRAA0ACQCABIARqLQAAQQlrDjIAAAMDAAMDAwMDAwMDAwMDAwMDAwMDAwADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBgMLIAAgAUEBaiIBNgIUIAEgAkcNAAsgAiEBCyADQShqIAQgAiABQQFqIgEgAiABIAJJGxD5ASADKAIsIQIgAygCKCEEQRQQcSIBRQ0HIAFBAzYCAAwBCyADQSBqIAQgAiABQQFqIgEgAiABIAJJGxD5ASADKAIkIQIgAygCICEEQRQQcSIBRQ0GIAFBBjYCAAsgASAENgIMIAEgAjYCEAsgACAALQAYQQFqOgAYDAMLIAAgAUEBajYCFCAAEIcEIQEgACAALQAYQQFqOgAYIAENAiAAKAIMIQQCQCAAKAIUIgEgACgCECICSQRAA0AgASAEai0AACIFQQlrIgZBF0tBASAGdEGTgIAEcUVyDQIgACABQQFqIgE2AhQgASACRw0ACyACIQELIANBOGogBCACIAEQ+QEgAygCPCEAIAMoAjghAkEUEHEiAUUNBCABIAI2AgwgAUEDNgIAIAEgADYCEAwDCyAFQf0ARgRAIAAgAUEBajYCFEEAIQEMAwsgA0EwaiAEIAIgARD5ASADKAI0IQAgAygCMCECQRQQcSIBRQ0DIAEgAjYCDCABQQo2AgAgASAANgIQDAILIANBGGogBCACIAEgAiABIAJJGxD5ASADKAIcIQAgAygCGCECQRQQcSIBRQ0CIAEgAjYCDCABQRg2AgAgASAANgIQDAELIANBCGogBCACIAFBAWoiACACIAAgAkkbEPkBIAMoAgwhACADKAIIIQJBFBBxIgFFDQEgASACNgIMIAFBCjYCACABIAA2AhALIANBQGskACABDwsAC6IHAgd/A34jAEHwCGsiBCQAIAG8IQcCf0EDIAGLQwAAgH9bDQAaQQIgB0GAgID8B3EiBUGAgID8B0YNABogB0H///8DcSIIQYCAgARyIAdBAXRB/v//B3EgB0EXdkH/AXEiBhsiCa0iC0IBgyEMIAVFBEBBBCAIRQ0BGiAGQZYBayEGQgEhDSAMUAwBC0KAgIAQIAtCAYYgCUGAgIAERiIIGyELQgJCASAIGyENQeh+Qel+IAgbIAZqIQYgDFALIQUgA0H//wNxIQggBCAGOwHoCCAEIA03A+AIIARCATcD2AggBCALNwPQCCAEIAU6AOoIAn8CQCAFQf8BcUEBTQRAQXRBBSAGwSIFQQBIGyAFbCIFQcD9AEkNAUHDhMIAQSVB6ITCABDrBwALAkACQCAFQf8BcSIJQQJHBEBBASEFQeqzxQBByIHCACAHQQBIIgYbQeqzxQBBASAGGyACGyEGQQEgB0EfdiACGyECIAlBBEcNAUECIQUgBEECOwGQCCADQf//A3ENAkEBIQUgBEEBNgKYCCAEQZiwxQA2ApQIIARBkAhqDAQLIARBAzYCmAggBEHzncYANgKUCCAEQQI7AZAIQQEhBkEAIQJBASEFIARBkAhqDAMLIARBAzYCmAggBEHsncYANgKUCCAEQQI7AZAIIARBkAhqDAILIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBuYPCADYClAggBEGQCGoMAQtB6rPFAEEBIAdBAEgiCRshCkHqs8UAQciBwgAgCRsgB0EfdiEHIARBkAhqIAsgBiAEQRBqIAVBBHZBFWoiBkGAgH5BACADayADwUEASBsiBRDpAiAFwSEFAkAgBCgCkAgEQCAEQcgIaiAEQZgIaigCADYCACAEIAQpApAINwPACAwBCyAEQcAIaiAEQdAIaiAEQRBqIAYgBRBlCyAKIAIbIQZBASAHIAIbIQIgBSAELgHICCIHSARAIARBCGogBCgCwAggBCgCxAggByAIIARBkAhqEOwEIAQoAgwhBSAEKAIIDAELQQIhBSAEQQI7AZAIIANB//8DcUUEQEEBIQUgBEEBNgKYCCAEQZiwxQA2ApQIIARBkAhqDAELIAQgCDYCoAggBEEAOwGcCCAEQQI2ApgIIARBuYPCADYClAggBEGQCGoLIQMgBCAFNgLMCCAEIAM2AsgIIAQgAjYCxAggBCAGNgLACCAAIARBwAhqEL4DIARB8AhqJAALiAUBBH8gABC/BAJAAkAgACgCiAQiAQRAIAAoAowEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgClAQiAQRAIAAoApgEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCoAQiAQRAIAAoAqQEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCrAQiAQRAIAAoArAEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCuAQiAQRAIAAoArwEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCxAQiAQRAIAAoAsgEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgC0AQiAQRAIAAoAtQEIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgC3AQiAQRAIAAoAuAEIgBBBGsoAgAiA0F4cSICIAFBAnQiAUEEQQggA0EDcSIDG2pJDQEgA0EAIAIgAUEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv7BAEEfwJAAkAgACgCBCIBBEAgACgCACIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAiwiAQRAIAAoAigiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAJUIgEEQCAAKAJQIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCfCIBBEAgACgCeCIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAqQBIgEEQCAAKAKgASIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAswBIgEEQCAAKALIASIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAvQBIgEEQCAAKALwASIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoApwCIgEEQCAAKAKYAiIAQQRrKAIAIgNBeHEiAiABQQJ0IgFBBEEIIANBA3EiAxtqSQ0BIANBACACIAFBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL3AUBBH8gACgCrAEiAUGECE8EQCABEJsHCwJAIAAoAgBFDQAgACgCBCIBQYQISQ0AIAEQmwcLAkAgACgCCEUNACAAKAIMIgFBhAhJDQAgARCbBwsCQCAAKAIQRQ0AIAAoAhQiAUGECEkNACABEJsHCwJAIAAoAhhFDQAgACgCHCIBQYQISQ0AIAEQmwcLAkAgACgCIEUNACAAKAIkIgFBhAhJDQAgARCbBwsCQCAAKAIoRQ0AIAAoAiwiAUGECEkNACABEJsHCwJAAkAgACgCOCIBBEAgACgCPCIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAkQiAQRAIAAoAkgiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAJQIgEEQCAAKAJUIgNBBGsoAgAiAkF4cSIEIAFBAnQiAUEEQQggAkEDcSICG2pJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAAKAIwRQ0AIAAoAjQiAUGECEkNACABEJsHCyAAKAJoIgFBgICAgHhyQYCAgIB4RwRAIAAoAmwiA0EEaygCACICQXhxIgQgAUEBdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAJ0IgFBgICAgHhyQYCAgIB4RwRAIAAoAngiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAJcIgEEQCAAKAJgIgBBBGsoAgAiA0F4cSICIAFBAnQiAUEEQQggA0EDcSIDG2pJDQEgA0EAIAIgAUEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuIBwEHfyMAQUBqIgEkAAJAAkAgACgCAEUEQCAAKAIQIgBFDQEgAEGTs8UAQQEQlwMhAgwCCyABQQxqIAAQyAUCQAJ/IAEoAgwiBEUEQCABLQAQIQQgACgCECIDBEBBASECIANB+rLFAEHqssUAIARBAXEiAxtBGUEQIAMbEJcDDQULIAAgBDoABEEADAELAkAgASgCECICQQFxDQAgAUKAgICAIDcCGCABIAQ2AgwgASACNgIQIAEgAiAEaiIFNgIUA0ACQCABQQxqEKgCQYCAxABrDgICAAELCyAAKAIQIgNFDQMgAygCAEEiIAMoAgQoAhARAgANAiABQoCAgIAgNwIYIAEgBTYCFCABIAI2AhAgASAENgIMA0ACQAJ/AkACQAJAIAFBDGoQqAIiAEGBgMQARwRAIABBgIDEAEYNASAAQSdHBEACQAJAAkACQAJAAkAgAEEhTARAIABBCWsOBQEDBgYCBQsgAEEiRg0DIABB3ABHDQUgAUIANwEiIAFB3LgBOwEgDAoLIAFCADcBIiABQdzoATsBIAwJCyABQgA3ASIgAUHc5AE7ASAMCAsgAUIANwEiIAFB3NwBOwEgDAcLIAFCADcBIiABQdzEADsBIAwGCyAARQ0ECwJAAkAgAEGABk8EQCAAEOUEDQELIAAQ4QINAQsgAUEwaiAAENYFIAFBKGogAUE4ai8AADsBACABIAEpADA3AyAgAS0AOiEAIAEtADshAiABQThqIAFBKGovAQA7AQAgASABKQMgNwMwIABB/wFxIAJB/wFxTw0IDAcLIAEgADYCIEGBASECQYABDAULIAMoAgBBJyADKAIEKAIQEQIADQkMBgsgAygCAEEiIAMoAgQoAhARAgAhAgwKC0HY5sgAQSsgAUEwakHstsUAQcy2xQAQ4AYACyABQgA3ASIgAUHc4AA7ASALQQIhAkEACyEAIAFBOGogAUEoai8BADsBACABIAEpAyA3AzALIAJB/wFxIQUgAEH/AXEhAiADKAIAIQYgAygCBCgCECEHIAEoAjAhBANAIAQhACAGIAVBgAFNBH8gAUEwaiACai0AAAUgAAsgBxECAA0EIAJBAWoiAiAFRw0ACwwACwALIAAoAhAiBARAIARB6rLFAEEQEJcDDQILIABBADoABEEACyECIAAgAjYCAAwCC0EBIQIMAQtBACECCyABQUBrJAAgAgu9BgEIfyMAQSBrIQgDQCABKAIAIgRB////A3EhAyAEQYCAgIB4cSEGAkAgBEGAgID8B3EiAkGAgID8B0YEQCADQQ12IAZBEHZyQYAEQQAgAxtyQYD4AXIhBgwBCyAGQRB2IQYgAkGAgIC4BE0EQCACQYCAgMQDTwRAIARBDHYgBEH/3wBxQQBHcSACQQ12IANBDXZqQYCAAWogBnJqIQYMAgsgAkGAgICYA0kNASADQYCAgARyIgRB/gAgAkEXdiIDa3YhAiAEQR0gA2siA3ZBAXEEfyACQQMgA3RBAWsgBHFBAEdqBSACCyAGciEGDAELIAZBgPgBciEGCyABQQRqKAIAIgNB////A3EhBSADQYCAgIB4cSEEAkAgA0GAgID8B3EiAkGAgID8B0cEQCAEQRB2IQQgAkGAgIC4BE0EQCACQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSACQQ12IAVBDXZqQYCAAWogBHJqIQQMAwsgAkGAgICYA0kNAiAFQYCAgARyIgNB/gAgAkEXdiIFa3YhAiADQR0gBWsiBXZBAXEEfyACQQMgBXRBAWsgA3FBAEdqBSACCyAEciEEDAILIARBgPgBciEEDAELIAVBDXYgBEEQdnJBgARBACAFG3JBgPgBciEECyABQQhqKAIAIgVB////A3EhByAFQYCAgIB4cSEDAkAgBUGAgID8B3EiAkGAgID8B0cEQCADQRB2IQMgAkGAgIC4BE0EQCACQYCAgMQDTwRAIAVBDHYgBUH/3wBxQQBHcSACQQ12IAdBDXZqQYCAAWogA3JqIQMMAwsgAkGAgICYA0kNAiAHQYCAgARyIgVB/gAgAkEXdiIHa3YhAiAFQR0gB2siB3ZBAXEEfyACQQMgB3RBAWsgBXFBAEdqBSACCyADciEDDAILIANBgPgBciEDDAELIAdBDXYgA0EQdnJBgARBACAHG3JBgPgBciEDCyAIQQJqIAlqIgIgBjsBACACQQRqIAM7AQAgAkECaiAEOwEAIAFBDGohASAJQQZqIglBHkcNAAsgACAI/QABAv0LAQAgAEEWaiAIQRhqKQEANwEAIABBEGogCEESaikBADcBAAuBCQEEfyMAQTBrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgMtAABBAWsOHAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwACyABKAIAQaWtxwBBAiABKAIEKAIMEQAAIQAMHAsgASgCAEGnrccAQQIgASgCBCgCDBEAACEADBsLIAEoAgBBqa3HAEEDIAEoAgQoAgwRAAAhAAwaCyABKAIAQaytxwBBBCABKAIEKAIMEQAAIQAMGQsgASgCAEGwrccAQQUgASgCBCgCDBEAACEADBgLIAEoAgBBta3HAEECIAEoAgQoAgwRAAAhAAwXCyABKAIAQbetxwBBAyABKAIEKAIMEQAAIQAMFgsgASgCAEG6rccAQQQgASgCBCgCDBEAACEADBULIAEoAgBBvq3HAEEFIAEoAgQoAgwRAAAhAAwUCyABKAIAQcOtxwBBAiABKAIEKAIMEQAAIQAMEwsgASgCAEHFrccAQQMgASgCBCgCDBEAACEADBILIAEoAgBByK3HAEEEIAEoAgQoAgwRAAAhAAwRCyABKAIAQcytxwBBBSABKAIEKAIMEQAAIQAMEAsgASgCAEHRrccAQQYgASgCBCgCDBEAACEADA8LIAEoAgBB163HAEECIAEoAgQoAgwRAAAhAAwOCyABKAIAQdmtxwBBAyABKAIEKAIMEQAAIQAMDQsgASgCAEHcrccAQQQgASgCBCgCDBEAACEADAwLIAEoAgBB4K3HAEEFIAEoAgQoAgwRAAAhAAwLCyABKAIAQeWtxwBBAyABKAIEKAIMEQAAIQAMCgsgASgCAEHorccAQQQgASgCBCgCDBEAACEADAkLIAEoAgBB7K3HAEEFIAEoAgQoAgwRAAAhAAwICyABKAIAQfGtxwBBBiABKAIEKAIMEQAAIQAMBwsgASgCAEH3rccAQQQgASgCBCgCDBEAACEADAYLIAEoAgBB+63HAEEFIAEoAgQoAgwRAAAhAAwFCyABKAIAQYCuxwBBBiABKAIEKAIMEQAAIQAMBAsgASgCAEGGrscAQQcgASgCBCgCDBEAACEADAMLIAEoAgBBja7HAEEFIAEoAgQoAgwRAAAhAAwCCyABKAIAQZKuxwBBBiABKAIEKAIMEQAAIQAMAQtBASEAIAIgA0EBajYCDCABKAIAIgNBpqvHAEEHIAEoAgQiBSgCDCIEEQAADQACQCABLQAKQYABcUUEQCADQbuzxQBBASAEEQAADQIgAkEMaiABEMQEDQIgASgCACEDIAEoAgQoAgwhBAwBCyADQduBwgBBAiAEEQAADQEgAkEBOgAfIAIgBTYCFCACIAM2AhAgAkHggcIANgIkIAIgASkCCDcCKCACIAJBH2o2AhggAiACQRBqNgIgIAJBDGogAkEgahDEBA0BIAIoAiBB2YHCAEECIAIoAiQoAgwRAAANAQsgA0HejsgAQQEgBBEAACEACyACQTBqJAAgAAuDBwMIfwN9AXsjAEEQayIHJAAgB0EEaiABEKsGIAcoAgghCAJ/AkACQCAAKAIIIgIEQCAHKAIMIQRDAACAPyAAKgJAIAAtAFhBAkYiBRtDAAAAACAAKgI8IAUbIguTIQwgAkECdCEJIAAoAgRBDGohBUEAIQADQCAEIABBA2oiAk0EQCACIARB0NvBABCMBwALIAQgAGsiAkEAIAIgBE0bIgJBAUYNAyACQQJGDQIgACAIaiIDLQAAs/0TIANBAWotAACz/SAB/QwAAH9DAAB/QwAAf0MAAH9D/ecBIQ0gA0EDai0AALNDAAB/Q5W8IgJB////A3EhBiADQQJqLQAAs0MAAH9DlSEKAkAgAkGAgID8B3EiA0GAgID8B0YEQCAGQQ12QYAEQQAgBhtyQYD4AXIhAgwBCyADQYCAgLgESwRAQYD4ASECDAELIAJBgICAxANPBEAgA0ENdiAGQQ12aiACQQx2IAJB/98AcUEAR3FqQYCAAWohAgwBCyACQYCAgJgDSQRAQQAhAgwBCyAGQYCAgARyIgZB/gAgAkEXdiIDa3YhAiAGQR0gA2siA3ZBAXFFDQAgAkEDIAN0QQFrIAZxQQBHaiECCyAFIAI7AQAgBUECakH/AUMAAH9DQwAAAAAgCiALkyAMlUMAAH9DlCIKIApDAAAAAF0bIgogCkMAAH9DXhsQuQciCvwBQQAgCkMAAAAAYBsgCkMAAH9DXhtBEHRB/wFDAAB/Q0MAAAAAIA39HwEgC5MgDJVDAAB/Q5QiCiAKQwAAAABdGyIKIApDAAB/Q14bELkHIgr8AUEAIApDAAAAAGAbIApDAAB/Q14bQQh0ckH/AUMAAH9DQwAAAAAgDf0fACALkyAMlUMAAH9DlCIKIApDAAAAAF0bIgogCkMAAH9DXhsQuQciCvwBQQAgCkMAAAAAYBsgCkMAAH9DXhtyIgI7AQAgBUEEaiACQRB2OgAAIAVBGGohBSAJIABBBGoiAEcNAAsLAkACQCAHKAIEIgAEQCAIQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyAAakkNASACQQAgBCAAQSdqSxsNAiAIEKICCyABQYQITwRAIAEQmwcLIAdBEGokAA8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAAQQJqDAELIABBAWoLIARB4NvBABCMBwAL8AgBBX8jAEEgayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4cAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHAALIAEoAgBBpa3HAEECIAEoAgQoAgwRAAAhAgwcCyABKAIAQaetxwBBAiABKAIEKAIMEQAAIQIMGwsgASgCAEGprccAQQMgASgCBCgCDBEAACECDBoLIAEoAgBBrK3HAEEEIAEoAgQoAgwRAAAhAgwZCyABKAIAQbCtxwBBBSABKAIEKAIMEQAAIQIMGAsgASgCAEG1rccAQQIgASgCBCgCDBEAACECDBcLIAEoAgBBt63HAEEDIAEoAgQoAgwRAAAhAgwWCyABKAIAQbqtxwBBBCABKAIEKAIMEQAAIQIMFQsgASgCAEG+rccAQQUgASgCBCgCDBEAACECDBQLIAEoAgBBw63HAEECIAEoAgQoAgwRAAAhAgwTCyABKAIAQcWtxwBBAyABKAIEKAIMEQAAIQIMEgsgASgCAEHIrccAQQQgASgCBCgCDBEAACECDBELIAEoAgBBzK3HAEEFIAEoAgQoAgwRAAAhAgwQCyABKAIAQdGtxwBBBiABKAIEKAIMEQAAIQIMDwsgASgCAEHXrccAQQIgASgCBCgCDBEAACECDA4LIAEoAgBB2a3HAEEDIAEoAgQoAgwRAAAhAgwNCyABKAIAQdytxwBBBCABKAIEKAIMEQAAIQIMDAsgASgCAEHgrccAQQUgASgCBCgCDBEAACECDAsLIAEoAgBB5a3HAEEDIAEoAgQoAgwRAAAhAgwKCyABKAIAQeitxwBBBCABKAIEKAIMEQAAIQIMCQsgASgCAEHsrccAQQUgASgCBCgCDBEAACECDAgLIAEoAgBB8a3HAEEGIAEoAgQoAgwRAAAhAgwHCyABKAIAQfetxwBBBCABKAIEKAIMEQAAIQIMBgsgASgCAEH7rccAQQUgASgCBCgCDBEAACECDAULIAEoAgBBgK7HAEEGIAEoAgQoAgwRAAAhAgwECyABKAIAQYauxwBBByABKAIEKAIMEQAAIQIMAwsgASgCAEGNrscAQQUgASgCBCgCDBEAACECDAILIAEoAgBBkq7HAEEGIAEoAgQoAgwRAAAhAgwBC0EBIQIgASgCACIEQaarxwBBByABKAIEIgYoAgwiBREAAA0AIABBAWohAAJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANAiAAIAEQygQNAiABKAIAIQQgASgCBCgCDCEFDAELIARB24HCAEECIAURAAANASADQQE6AA8gAyAGNgIEIAMgBDYCACADQeCBwgA2AhQgAyABKQIINwIYIAMgA0EPajYCCCADIAM2AhAgACADQRBqEMoEDQEgAygCEEHZgcIAQQIgAygCFCgCDBEAAA0BCyAEQd6OyABBASAFEQAAIQILIANBIGokACACC60GAQh/IwBBIGshCANAIAEoAgAiBEH///8DcSEDIARBgICAgHhxIQYCQCAEQYCAgPwHcSICQYCAgPwHRgRAIANBDXYgBkEQdnJBgARBACADG3JBgPgBciEGDAELIAZBEHYhBiACQYCAgLgETQRAIAJBgICAxANPBEAgBEEMdiAEQf/fAHFBAEdxIAJBDXYgA0ENdmpBgIABaiAGcmohBgwCCyACQYCAgJgDSQ0BIANBgICABHIiBEH+ACACQRd2IgNrdiECIARBHSADayIDdkEBcQR/IAJBAyADdEEBayAEcUEAR2oFIAILIAZyIQYMAQsgBkGA+AFyIQYLIAFBBGooAgAiA0H///8DcSEFIANBgICAgHhxIQQCQCADQYCAgPwHcSICQYCAgPwHRwRAIARBEHYhBCACQYCAgLgETQRAIAJBgICAxANPBEAgA0EMdiADQf/fAHFBAEdxIAJBDXYgBUENdmpBgIABaiAEcmohBAwDCyACQYCAgJgDSQ0CIAVBgICABHIiA0H+ACACQRd2IgVrdiECIANBHSAFayIFdkEBcQR/IAJBAyAFdEEBayADcUEAR2oFIAILIARyIQQMAgsgBEGA+AFyIQQMAQsgBUENdiAEQRB2ckGABEEAIAUbckGA+AFyIQQLIAFBCGooAgAiBUH///8DcSEHIAVBgICAgHhxIQMCQCAFQYCAgPwHcSICQYCAgPwHRwRAIANBEHYhAyACQYCAgLgETQRAIAJBgICAxANPBEAgBUEMdiAFQf/fAHFBAEdxIAJBDXYgB0ENdmpBgIABaiADcmohAwwDCyACQYCAgJgDSQ0CIAdBgICABHIiBUH+ACACQRd2IgdrdiECIAVBHSAHayIHdkEBcQR/IAJBAyAHdEEBayAFcUEAR2oFIAILIANyIQMMAgsgA0GA+AFyIQMMAQsgB0ENdiADQRB2ckGABEEAIAcbckGA+AFyIQMLIAhBDmogCWoiAiAGOwEAIAJBBGogAzsBACACQQJqIAQ7AQAgAUEMaiEBIAlBBmoiCUESRw0ACyAAIAj9AAEO/QsBACAAQRBqIAhBHmovAQA7AQALzwgCB3sKfyABIAAgAEEDakF8cSIKayILaiIMQQNxIQ1BACEBIAAgCkcEQANAIAEgACwAAEG/f0pqIQEgAEEBaiEAIAtBAWoiCw0ACwsCQCANRQ0AIAogDEF8cWoiACwAAEG/f0ohCSANQQFGDQAgCSAALAABQb9/SmohCSANQQJGDQAgCSAALAACQb9/SmohCQsgDEECdiELIAEgCWohDAJAA0AgCiEJIAtFDQFBwAEgCyALQcABTxsiDkEDcSEPAkAgDkECdCIQQfAHcSIRRQRAQQAhAQwBC0EAIQEgCSEAIBBBEGsiCkEwTwRAIAAgCkEEdkEBaiISQfz///8BcSINQQR0aiEA/QwAAAAAAAAAAAAAAAAAAAAAIQIgDSEKIAkhAQNAIAH9AAIAIgMgAf0AAhAiBP0NDA0ODxwdHh8AAQIDAAECAyAB/QACICIGIAH9AAIwIgf9DQABAgMAAQIDDA0ODxwdHh/9DQABAgMEBQYHGBkaGxwdHh8iBf1NQQf9rQEgBUEG/a0B/VD9DAEBAQEBAQEBAQEBAQEBAQEiBf1OIAMgBP0NCAkKCxgZGhsAAQIDAAECAyAGIAf9DQABAgMAAQIDCAkKCxgZGhv9DQABAgMEBQYHGBkaGxwdHh8iCP1NQQf9rQEgCEEG/a0B/VAgBf1OIAMgBP0NBAUGBxQVFhcAAQIDAAECAyAGIAf9DQABAgMAAQIDBAUGBxQVFhf9DQABAgMEBQYHGBkaGxwdHh8iCP1NQQf9rQEgCEEG/a0B/VAgBf1OIAMgBP0NAAECAxAREhMAAQIDAAECAyAGIAf9DQABAgMAAQIDAAECAxAREhP9DQABAgMEBQYHGBkaGxwdHh8iA/1NQQf9rQEgA0EG/a0B/VAgBf1OIAL9rgH9rgH9rgH9rgEhAiABQUBrIQEgCkEEayIKDQALIAIgAiAD/Q0ICQoLDA0ODwABAgMAAQID/a4BIgIgAiAC/Q0EBQYHAAECAwABAgMAAQID/a4B/RsAIQEgDSASRg0BCyAJIBFqIQoDQCAAQQhq/V0CACIC/U1BB/2tASACQQb9rQH9UP0MAQEBAQEBAQEBAQEBAQEBASIC/U4iA/0bASAA/V0CACIE/U1BB/2tASAEQQb9rQH9UCAC/U4iAv0bASAC/RsAIAFqaiAD/RsAamohASAAQRBqIgAgCkcNAAsLIAsgDmshCyAJIBBqIQogAUEIdkH/gfwHcSABQf+B/AdxakGBgARsQRB2IAxqIQwgD0UNAAsCfyAJIA5B/AFxQQJ0aiIBKAIAIgBBf3NBB3YgAEEGdnJBgYKECHEiACAPQQFGDQAaIAAgASgCBCIAQX9zQQd2IABBBnZyQYGChAhxaiIAIA9BAkYNABogACABKAIIIgBBf3NBB3YgAEEGdnJBgYKECHFqCyIAQQh2Qf+BHHEgAEH/gfwHcWpBgYAEbEEQdiAMaiEMCyAMC+sEAQR/AkACQCAAKAIAIgIEQCAAKAIEIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAgwiAgRAIAAoAhAiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsgACgCOCICBEAgACgCPCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAJcIgIEQCAAKAJgIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAmgiAkGAgICAeHJBgICAgHhHBEAgACgCbCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAJ0IgIEQCAAKAJ4IgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILAkAgACgCoAEiAkGAgICAeEYNACACBEAgACgCpAEiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQIgAUEAIAQgAkEnaksbDQMgAxCiAgsgACgCrAEiAkUNACAAKAKwASIAQQRrKAIAIgNBeHEiAUEEQQggA0EDcSIDGyACakkNASADQQAgASACQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC90GAQZ/QeS0yQAoAgAiAiAASQRAIAAgAiIBayIDQdy0yQAoAgAgAWtLBEBB3LTJACABIANBBEEEEKQFQeS0yQAoAgAhAQtB4LTJACgCACIFIAFBAnRqIQQgA0ECTwRAIAAgAkF/c2pBAnQiBgRAIARBACAG/AsACyAAIAFqQQJ0IAJBAnRrIAVqQQRrIQQgASADakEBayEBCyAEQQA2AgBB5LTJACABQQFqNgIAC0HwtMkAKAIAIgIgAEkEQCAAIAIiAWsiA0HotMkAKAIAIAFrSwRAQei0yQAgASADQQRBBBCkBUHwtMkAKAIAIQELQey0yQAoAgAiBSABQQJ0aiEEIANBAk8EQCAAIAJBf3NqQQJ0IgYEQCAEQQAgBvwLAAsgACABakECdCACQQJ0ayAFakEEayEEIAEgA2pBAWshAQsgBEEANgIAQfC0yQAgAUEBajYCAAtBlLXJACgCACICIABJBEAgACACIgFrIgNBjLXJACgCACABa0sEQEGMtckAIAEgA0EEQQQQpAVBlLXJACgCACEBC0GQtckAKAIAIgUgAUECdGohBCADQQJPBEAgACACQX9zakECdCIGBEAgBEEAIAb8CwALIAAgAWpBAnQgAkECdGsgBWpBBGshBCABIANqQQFrIQELIARBADYCAEGUtckAIAFBAWo2AgALQfy0yQAoAgAiAkH//wNNBEAgAiEAQYCABCACayIBQfS0yQAoAgAgAmtLBEBB9LTJACACIAFBBEEEEKQFQfy0yQAoAgAhAAtB+LTJACgCACIEIABBAnQiA2ohASACQf//A0cEQEH8/w8gAkECdCIFayIGBEAgAUEAIAb8CwALIAMgBWsgBGpB/P8PaiEBIAAgAmtB//8DaiEACyABQQA2AgBB/LTJACAAQQFqNgIAC0GItckAKAIAIgJB//8DTQRAIAIhAEGAgAQgAmsiAUGAtckAKAIAIAJrSwRAQYC1yQAgAiABQQRBBBCkBUGItckAKAIAIQALQYS1yQAoAgAiBCAAQQJ0IgNqIQEgAkH//wNHBEBB/P8PIAJBAnQiBWsiBgRAIAFBACAG/AsACyADIAVrIARqQfz/D2ohASAAIAJrQf//A2ohAAsgAUEANgIAQYi1yQAgAEEBajYCAAsLjgcCAX8BfCMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsOEQECAwQFBgcICQoLDA0ODxARAAsgAiAALQABOgAIIAIgAkEIaq1CgICAgMABhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBAjYCHCACQfSQxgA2AhggAiACQRBqNgIgIAJBGGoQwQMMEQsgAiAAKQMINwMIIAIgAkEIaq1CgICAgKAFhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBAjYCHCACQZCRxgA2AhggAiACQRBqNgIgIAJBGGoQwQMMEAsgAiAAKQMINwMIIAIgAkEIaq1CgICAgNANhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBAjYCHCACQZCRxgA2AhggAiACQRBqNgIgIAJBGGoQwQMMDwsgACsDCCEDIAIgAkEQaq1CgICAgOANhDcDCCACIAM5AxAgASgCACABKAIEIAJCATcCJCACQQI2AhwgAkHspcYANgIYIAIgAkEIajYCICACQRhqEMEDDA4LIAIgACgCBDYCCCACIAJBCGqtQoCAgIDwDYQ3AxAgASgCACABKAIEIAJCATcCJCACQQI2AhwgAkGskcYANgIYIAIgAkEQajYCICACQRhqEMEDDA0LIAIgACkCBDcCCCACIAJBCGqtQoCAgICADoQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkHEkcYANgIYIAIgAkEQajYCICACQRhqEMEDDAwLIAEoAgBBzJHGAEEKIAEoAgQoAgwRAAAMCwsgASgCAEHWkcYAQQogASgCBCgCDBEAAAwKCyABKAIAQeCRxgBBDCABKAIEKAIMEQAADAkLIAEoAgBB7JHGAEEOIAEoAgQoAgwRAAAMCAsgASgCAEH6kcYAQQggASgCBCgCDBEAAAwHCyABKAIAQYKSxgBBAyABKAIEKAIMEQAADAYLIAEoAgBBhZLGAEEEIAEoAgQoAgwRAAAMBQsgASgCAEGJksYAQQwgASgCBCgCDBEAAAwECyABKAIAQZWSxgBBDyABKAIEKAIMEQAADAMLIAEoAgBBpJLGAEENIAEoAgQoAgwRAAAMAgsgASgCAEGxksYAQQ4gASgCBCgCDBEAAAwBCyABKAIAIAAoAgQgACgCCCABKAIEKAIMEQAACyACQTBqJAAL9AUCBX8BfiABQiCIIAFCEIinIQUCfyABpyIDQf//AXFFBEAgA0EQdAwBCyADQf8HcSEGIANBgIACcSECIANBgPgBcSIDQYD4AUYEQCACQRB0IQMgA0GAgID8B3IgBkUNARogAyAGQQ10ckGAgID+B3IMAQsgAkEQdCECIANBDXRBgICA/ABxIAZBDXRyQYCAgMADaiACciADDQAaIAYgBmdBEGsiBkH//wNxQQhqdEH///8DcSACQYCAgNgDciAGQRd0a3ILIQYgAUIwiCEBpyEDAn8gBUH//wFxBEAgBUH/B3EhAiAFQYCAAnEhBCAFQYD4AXEiBUGA+AFHBEAgBEEQdCEEIAVBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAEciAFDQIaIAIgAmdBEGsiBUH//wNxQQhqdEH///8DcSAEQYCAgNgDciAFQRd0a3IMAgsgBEEQdCEFIAUgAkENdHJBgICA/gdyIAINARogBUGAgID8B3IMAQsgBUEQdAshBSABpyECIAAgBv0RIAX9HAECfyADQf//AXEEQCADQf8HcSEEIANBgIACcSEAIANBgPgBcSIDQYD4AUcEQCAAQRB0IQAgA0ENdEGAgID8AHEgBEENdHJBgICAwANqIAByIAMNAhogBCAEZ0EQayIDQf//A3FBCGp0Qf///wNxIABBgICA2ANyIANBF3RrcgwCCyAAQRB0IQMgAyAEQQ10ckGAgID+B3IgBA0BGiADQYCAgPwHcgwBCyADQRB0C/0cAgJ/IAJB//8BcQRAIAJB/wdxIQQgAkGAgAJxIQAgAkGA+AFxIgJBgPgBRwRAIABBEHQhACACQQ10QYCAgPwAcSAEQQ10ckGAgIDAA2ogAHIgAg0CGiAEIARnQRBrIgJB//8DcUEIanRB////A3EgAEGAgIDYA3IgAkEXdGtyDAILIABBEHQhAiACIARBDXRyQYCAgP4HciAEDQEaIAJBgICA/AdyDAELIAJBEHQL/RwD/QsEAAuOBgENfyAAIAAoAgQiCCAAKAIAIgNJQQJ0aiIFIABBDEEIIAAoAgwgACgCCEkiBBtqIgkgACADIAhNQQJ0aiIIIABBCEEMIAQbaiIDKAIAIAgoAgBJIgQbIAkoAgAiCyAFKAIAIgpJIgUbIgYoAgAhDCADIAggCSAFGyAEGyIHKAIAIQ0gAiALIAogBRsiCTYCACACIAcgBiAMIA1LIgUbKAIANgIEIAIgBiAHIAUbKAIANgIIIAJBDGoiCyAIIAMgBBsoAgAiCDYCACAAQRBqIgMgACgCFCIFIAAoAhAiBklBAnRqIgcgA0EMQQggACgCHCAAKAIYSSIKG2oiBCADIAUgBk9BAnRqIgAgA0EIQQwgChtqIgUoAgAgACgCAEkiBhsgBCgCACIKIAcoAgAiDEkiAxsiBygCACENIAUgACAEIAMbIAYbIgQoAgAhDiACQRBqIg8gCiAMIAMbIgM2AgAgAkEUaiAEIAcgDSAOSyIKGygCADYCACACQRhqIAcgBCAKGygCADYCACACQRxqIgcgACAFIAYbKAIAIgA2AgAgASAD/REgDyADIAlJQQJ0aiIFKAIAIgT9HAEgBSAEIAIgAyAJT0ECdGoiBigCACICSUECdGoiBSgCACID/RwCIAUgAyAGIAIgBE1BAnRqIgYoAgAiBElBAnRqIgooAgAiBf0cAyAJ/REgAv0cASAE/RwCIAYgAyAET0ECdGoiDCgCACIC/RwD/bcB/QsCACABIAdBfEEAIAAgCE8baiIBQXxBACABKAIAIgEgC0F8QQAgACAISRtqIgQoAgAiCU8baiIDQXxBACADKAIAIgMgBEF8QQAgASAJSRtqIgcoAgAiBE8baiILKAIAIgb9ESAD/RwBIAH9HAIgAP0cAyAHQXxBACADIARJG2oiASgCACIA/REgBP0cASAJ/RwCIAj9HAP9uQH9CwIQAkAgDCACIAVNQQJ0aiABQXxBACAAIAZLG2pBBGpGBEAgCiACIAVLQQJ0aiALQXxBACAAIAZNG2pBBGpGDQELEIAIAAsLrQYCBX8EfSMAQSBrIgQkAEEBIQUCQAJAAkAgAiACQQRBAyADQQFxGyIHbiIGIAdsRgRAIAZBAnQiBwRAQQAhBQJAIAdBAE4EQCAEQQA2AhggBEEIakEBIAcgBEEUahCFByAEKAIIQQFHDQEgBCgCECEGIAQoAgwhBQsgBCAGNgIYIAQgBTYCFEHgvsQAQTYgBEEUakHQvsQAQZi/xAAQ4AYACyAEKAIMIQULQQAhBiAEQQA2AhwgBCAFNgIYIAQgBzYCFCADQQFxDQEgAkEDbiIDQQJ0IgIEQCACIAdLBEAgBEEUakEAIAIQ7wUgBCgCHCEGIAQoAhghBQsgBSAGaiEHIAJBAWsiCARAIAdBACAI/AsACyAHIAhqQQA6AAAgAiAGaiEGCyAEIAY2AhwgBkECdiICIAMgAiADSRsiA0UNAgNAIAFBCGoqAgAhCyABQQRqKgIAIQpDAAB/QyEJIAEqAgAiDEMAAIA/XQR9IAxDAAAAABDgCEMAAH9DlAUgCQsQuQciDEMAAIC/XkUgDEMAAIBDXUVyDQQgCkMAAIA/XQR9IApDAAAAABDgCEMAAH9DlAUgCQsQuQciCkMAAIC/XkUgCkMAAIBDXUVyDQQgC0MAAIA/XQR9IAtDAAAAABDgCEMAAH9DlAUgCQsQuQciCUMAAIC/XkUgCUMAAIBDXUVyDQQgBSAM/AE6AAAgBUEDakH/AToAACAFQQJqIAn8AToAACAFQQFqIAr8AToAACABQQxqIQEgBUEEaiEFIANBAWsiAw0ACwwCC0H4vcQAQcUAQcC+xAAQ6wcACwJAAkAgAiAHSwRAIARBFGpBACACEO8FIAQoAhghBSAEKAIcIQMMAQtBACEDIAJFDQELA0BDAAB/QyEJIAEqAgAiC0MAAIA/XQR9IAtDAAAAABDgCEMAAH9DlAUgCQsQuQciCUMAAIC/XkUgCUMAAIBDXUVyDQMgAyAFaiAJ/AE6AAAgAUEEaiEBIANBAWohAyACQQFrIgINAAsLIAQgAzYCHAsgACAEKQIUNwIAIABBCGogBEEcaigCADYCACAEQSBqJAAPC0Gov8QAEN0JAAvABgEGfyMAQfAAayICJAACfwJAAkACQCAAKAIAIgFFDQACQCAAKAIIIgMgACgCBCIFTw0AIAEgA2otAABB1QBHDQBBASEEIAAgA0EBaiIDNgIICwJAAkACQCADIAVJBEAgASADai0AAEHLAEYNAQsgBEUNA0EAIQMMAQsgACADQQFqIgY2AggCQAJAIAUgBk0NACABIAZqLQAAQcMARw0AIAAgA0ECajYCCEEBIQFBxbPFACEDDAELIAJByABqIAAQ7wIgAigCSCIDRQRAIAItAEwhASAAKAIQIgQEQEEBIARB+rLFAEHqssUAIAFBAXEiBBtBGUEQIAQbEJcDDQgaCyAAIAE6AAQgAEEANgIAQQAMBwsgAigCTCIBBEAgAigCVEUNAQsgACgCECIBBEAgAUHqssUAQRAQlwMNBQsgAEEAOgAEIABBADYCAEEADAYLIARFDQELIAAoAhAiBARAIARBxrPFAEEHEJcDDQMLIANFDQELIAAoAhAiBARAIARBzbPFAEEIEJcDDQILIAJBATsBRCACIAE2AkAgAkEANgI8IAJBAToAOCACQd8ANgI0IAIgATYCMCACQQA2AiwgAiABNgIoIAIgAzYCJCACQd8ANgIgIAJBGGogAkEgahCuBCACKAIYIgEEQCAEBEAgBCABIAIoAhwQlwMNAwsgAkHIAGogAkEgakEo/AoAACAEIQEDQCABIQMCQANAIAMhBSACQRBqIAJByABqEK4EIAIoAhAiBkUNAUEAIQMgBUUNAAsgAigCFCEDIAVB6rPFAEEBEJcDDQRBACEBIARFDQEgBCIBIAYgAxCXAw0EDAELCyABRQ0BIAFB6LPFAEECEJcDRQ0BDAILQdizxQAQ3QkACyAAKAIQIgEEQCABQeuzxQBBAxCXAw0BCyACQQhqIAAQtwZBASACKAIIQQFxDQIaIAAoAhAiAQRAQQEgAUHejsgAQQEQlwMNAxoLIAAoAgAiA0UNASAAKAIIIgEgACgCBE8NASABIANqLQAAQfUARw0BIAAgAUEBajYCCEEADAILQQEMAQsgACgCECIBBEBBASABQe6zxQBBBBCXAw0BGgsgABCGAgsgAkHwAGokAAvLBgIIfwN+IwBBoAFrIgMkACABvCEEAn9BAyABi0MAAIB/Ww0AGkECIARBgICA/AdxIgdBgICA/AdGDQAaIARB////A3EiBUGAgIAEciAEQQF0Qf7//wdxIARBF3ZB/wFxIgYbIgitIgtCAYMhDCAHRQRAQQQgBUUNARogBkGWAWshBkIBIQ0gDFAMAQtCgICAECALQgGGIAhBgICABEYiBRshC0ICQgEgBRshDUHofkHpfiAFGyAGaiEGIAxQCyEHIAMgBjsBiAEgAyANNwOAASADQgE3A3ggAyALNwNwIAMgBzoAigECQAJAAkACQAJAAkACQAJAIAdB/wFxQQFNBEAgA0HgAGogA0HwAGogA0EHahDPASADKAJgRQ0BIANBmAFqIANB6ABqKAIANgIAIAMgAykCYDcDkAEMAgsgB0H/AXEiBUECRg0CIANBAjsBGEEBIQdB6rPFAEHIgcIAIARBAEgiBhtB6rPFAEEBIAYbIAIbIQZBASAEQR92IAIbIQIgBUEERg0DIANBAzYCICADQeydxgA2AhwMBwsgA0GQAWogA0HwAGogA0EHahBXCyADKAKUASIHRQ0CIAMoApABIgYtAABBME0NA0Hqs8UAQQEgBEEASCIFGyEIQeqzxQBByIHCACAFGyEJIARBH3YhCiADLgGYASEFIAMgBjYCHCADQQI7ARggA0EBNgIgIAdBAUYEQCADQSRqIQRBAyEHDAULIANBPGohBCADQQI7ATAgA0HsucUANgIoIANBAjsBJCADIAdBAWs2AjggA0EBNgIsIAMgBkEBajYCNEEFIQcMBAsgA0EDNgIgIANB853GADYCHCADQQI7ARhBASEGQQAhAkEBIQcMBAsgA0EDNgIgIANBu4PCADYCHAwDC0G+g8IAQSFBoITCABDrBwALQfCDwgBBH0GwhMIAEOsHAAsgCSAIIAIbIQZBASAKIAIbIQIgBEEBOwEMIARBAjsBACAEQQEgBWsgBUEBayAFQQBMIgUbOwEOIARBAkEBIAUbNgIIIARBwYTCAEHAhMIAIAUbNgIECyADIAc2AmwgAyACNgJkIAMgBjYCYCADIANBGGo2AmggACADQeAAahC+AyADQaABaiQAC8QHAg1/AnsjAEEwayICJAAgAS0AASIFIAEtAAAiBkEBdGohDEECIQ1BAiIDBEAgAUECaiEEA0AgDUEBdCENIAQtAAAgDEEBdGohDCAEQQFqIQQgA0EBayIDDQALCyABQQRqIQMgAkEAOgASIAJBAToAEwJ/IAUtAPD5RCAGLQDw+URPBEBBASEKIAUhCCAGIQVBAAwBCyACQQA6ABMgAkEBOgASIAYhCEEBCyEGQQIhBCACQQI2AiQgAkKAgICA8B83AhwgAiADNgIYIAIgATYCFAJAAkADQAJAAkACQCAERQRAIAIoAiAiA0UNBiACIANBAWs2AiAgAigCFCIEIAIoAhhHDQEMBgsgAkEANgIkIAJBCGohCwJAAkACQCAEIAJBFGoiAygCDCIHTwRAIAcNAQwCCyADIAcgBEF/c2o2AgwgAyADKAIAIgkgBGoiB0EBaiADKAIEIg4gBCAOIAlrIglJGzYCACAEIAlPDQEgAyADKAIIIARqIgRBAWo2AggMAgsgAyADKAIAIgkgB0EBayIEakEBaiADKAIEIg4gBCAOIAlrIglJGzYCACAEIAlJBEAgAyADKAIIIAdqNgIIC0EAIQcgA0EANgIMDAELQQAhBwsgCyAHNgIEIAsgBDYCACACKAIMIgRFDQUgAigCCCEDDAELIAIgBEEBajYCFCACIAIoAhwiA0EBajYCHAsgBC0AACIELQDw+UQiByAFQf8BcSILLQDw+URPBEACQCAEIAtGDQAgByAIQf8BcS0A8PlETw0AIANBgAJPDQIgAiADOgATIAMhCiAEIQgLIAIoAiQhBAwCCyACIAY6ABMgA0H/AUsNAiACIAM6ABIgBiEKIAMhBiAFIQggBCEFIAIoAiQhBAwBCwtB2ObIAEErIAJBL2pBiJbIAEHYmMgAEOAGAAtB2ObIAEErIAJBL2pBiJbIAEHomMgAEOAGAAsgBkH/AXEiCCAKQf8BcUYEQCACQQA2AhRBASACQRJqIAJBE2ogAkEUakHImMgAEPkHAAsCQCAIQQRJBEAgCkH/AXEiBUEETw0BIAEgBWr9BwAAIQ8gASAIav0HAAAhECAAQQQ2AnggACABNgJ0IABBADYCcCAAQRw2AmggACANNgJkIAAgDDYCYCAAQRo2AjAgACAKOgAlIAAgBjoAJCAAQQQgBSAGQf8BcSIBIAEgBUkbQRBqIgEgAUEETRs2AiAgACAP/QsEECAAIBD9CwQAIAJBMGokAA8LIAhBBEGImsgAEIwHAAsgBUEEQZiayAAQjAcAC58GAQd/IwBBMGsiBCQAIAEoAgAiBygCDCEGAkACQAJAIAcoAhQiAyAHKAIQIgJJBEADQCADIAZqLQAAIghBCWsiBUEXS0EBIAV0QZOAgARxRXINAiAHIANBAWoiAzYCFCACIANHDQALIAIhAwtBASEFIARBKGogBiACIANBAWoiASACIAEgAkkbEPkBIAQoAiwhAyAEKAIoIQFBFBBxIgJFDQIgAiABNgIMIAJBAzYCACAAIAI2AgQgAiADNgIQDAELIAhB/QBGBEBBACEFIABBADoAAQwBCwJAIAEtAARFBEAgA0EBaiEDIAhBLEYEQCAHIAM2AhQgAiADSwRAA0AgAyAGai0AACIBQQlrIgVBGUsNBEEBIAV0QZOAgARxRQRAIAVBGUcNBSAAQQE6AAFBACEFDAYLIAcgA0EBaiIDNgIUIAIgA0cNAAsgAiEDC0EBIQUgBEEQaiAGIAIgA0EBaiIBIAIgASACSRsQ+QEgBCgCFCEDIAQoAhAhAUEUEHEiAkUNBCACIAE2AgwgAkEFNgIAIAAgAjYCBCACIAM2AhAMAwsgBEEgaiAGIAIgAyACIAIgA0sbEPkBIAQoAiQhAyAEKAIgIQFBFBBxIgJFDQMgAiABNgIMIAJBCDYCACAAIAI2AgQgAiADNgIQQQEhBQwCC0EAIQUgAUEAOgAEIAhBIkcEQEEBIQUgBCAGIAIgA0EBaiIBIAIgASACSRsQ+QEgBCgCBCEDIAQoAgAhAUEUEHEiAkUNAyACIAE2AgwgAkERNgIAIAAgAjYCBCACIAM2AhAMAgsgAEEBOgABDAELQQEhBSABQf0ARwRAIARBCGogBiACIANBAWoiASACIAEgAkkbEPkBIAQoAgwhAyAEKAIIIQFBFBBxIgJFDQIgAiABNgIMIAJBETYCACAAIAI2AgQgAiADNgIQDAELIARBGGogBiACIANBAWoiASACIAEgAkkbEPkBIAQoAhwhAyAEKAIYIQFBFBBxIgJFDQEgAiABNgIMIAJBFTYCACAAIAI2AgQgAiADNgIQCyAAIAU6AAAgBEEwaiQADwsAC8gGAgd/An4jAEEwayIDJAACQAJAAkAgASgCFCICIAEoAhAiBEkEQCABKAIMIQgCfgJAA0AgAiAIai0AACIFQQlrIgZBF0tBASAGdEGTgIAEcUVyDQEgASACQQFqIgI2AhQgAiAERw0ACyAEIQJCAAwBC0KAAgsgBa1CEIaEQoCCuANRDQELIAACfQJAAkACQAJAAkAgA0EQaiABKAIMIgUgBCACIARJBH8DQAJAIAIgBWotAAAiBkEJaw4lAAAEBAAEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEAwQLIAEgAkEBaiICNgIUIAIgBEcNAAsgBAUgAgtBAWoiASAEIAEgBEkbEPkBIAMoAhQhBCADKAIQIQFBFBBxIgJFDQggAiABNgIMIAJBBTYCACACIAQ2AhAMAwsgASACQQFqNgIUIANBGGogAUEAEMcDIAMpAxgiCkIDUQ0BIAMpAyAhCQJAAkAgCqdBAWsOAgABBQsgCbUMBQsgCbQMBAsgBkEwa0H/AXFBCk8EQCABIANBL2pB2OfAABDuASABEOsFIQIMAgsgA0EYaiABQQEQxwMgAykDGCIKQgNRDQAgAykDICEJAkACQAJAIAqnQQFrDgIBAgALIAm/tkMAAIA/QwAAgL8gCUIAWRuYDAULIAm1DAQLIAm0DAMLIAMoAiAhAgsgAEECNgIAIAAgAjYCBAwDCyAJv7ZDAACAP0MAAIC/IAlCAFkbmAs4AgQgAEEBNgIADAELIAEgAkEBaiIHNgIUAkACQAJAIAQgB00NACABIAJBAmoiBTYCFCAHIAhqLQAAQfUARw0BIAUgByAEIAQgB0kbIgdGDQAgASACQQNqIgY2AhQgBSAIai0AAEHsAEcEQCAGIQUMAgsgBiAHRg0AIAEgAkEEaiIFNgIUIAYgCGotAABB7ABHDQEgAEEANgIADAMLIAMgCCAEIAcQ+QEgAygCBCEEIAMoAgAhAUEUEHEiAkUNAyACQQU2AgAMAQsgA0EIaiAIIAQgBRD5ASADKAIMIQQgAygCCCEBQRQQcSICRQ0CIAJBCTYCAAsgAiABNgIMIAAgAjYCBCAAQQI2AgAgAiAENgIQCyADQTBqJAAPCwALzQYDA38BfAN9IwBBEGsiAiQAAkAgASgCAEGUgICAeEYEQAJ9AkAgAAJ/AkACQAJAAn0CQAJAIAEoAgwiBARAAn0CQAJAAkACQAJAAkACQAJAAkACQAJAQRUgASgCCCIBKAIAIgNBgICAgHhzIANBAE4bQQFrDgoKAAECAwQFBgcICQsgAS8BBLMMCgsgASgCBLMMCQsgASkDCLUMCAsgASwABLIMBwsgAS4BBLIMBgsgASgCBLIMBQsgASkDCLQMBAsgASoCBAwDCyABKwMIIgW2QwAAgD9DAACAvyAFvUIAWRuYDAILIAEgAkEPakHY58AAEJUIDAkLIAEtAASzCyEGIARBAUYNBAJAAkACQAJAAkACQAJAAkACQEEVIAEoAhAiA0GAgICAeHMgA0EAThtBAWsOCgsAAQIDBAUGBwgKCyABLwEUswwLCyABKAIUswwKCyABKQMYtQwJCyABLAAUsgwICyABLgEUsgwHCyABKAIUsgwGCyABKQMYtAwFCyABKgIUDAQLIAErAxgiBbZDAACAP0MAAIC/IAW9QgBZG5gMAwtBACACQQ9qQfThwAAQ2wYMBgsgAUEQaiACQQ9qQdjnwAAQlQgMBQsgAS0AFLMLIQcgBEECRg0CAkACQAJAAkACQAJAAkACQAJAQRUgASgCICIDQYCAgIB4cyADQQBOG0EBaw4KDQABAgMEBQYHCAoLIAEvASSzDA0LIAEoAiSzDAwLIAEpAyi1DAsLIAEsACSyDAoLIAEuASSyDAkLIAEoAiSyDAgLIAEpAyi0DAcLIAEqAiQMBgsgASsDKCIFtkMAAIA/QwAAgL8gBb1CAFkbmAwFC0EBIAJBD2pB9OHAABDbBgwCCyABQSBqIAJBD2pB2OfAABCVCAwBC0ECIAJBD2pB9OHAABDbBgs2AgQgAEEBNgIADAMLIAEtACSzCyEIIARBA0cEQCACQQM2AgggBEH9////AGpB/////wBxQQNqIAJBCGpB6JXBABDbBiEBIABBATYCACAAIAE2AgQMAgsgACAIOAIMIAAgBzgCCCAAIAY4AgQgAEEANgIADAELIAEgAkEPakH04cAAEJUIIQEgAEEBNgIAIAAgATYCBAsgAkEQaiQAC+4FAQp/IwBBQGoiBSQAIAVBADYCKCAFQQA2AjxBBCEHIAVBLGohCSAFQTxqIQwCQAJAAkACfyAEQQVJBEAgCSEKIAwMAQsgBUEIaiAFQShqQX8gBEEBa2d2QQFqEPUDIAUoAggiBkGBgICAeEcEQCAGDQJB2JXHAEERQdTMxwAQ6wcACyAFKAI8IgdBBUkEQCAHIQYgCSEKQQQhByAMDAELIAUoAiwhBiAFKAIwIQogCQshCyADIARBAnRqIQ0CQAJAIAsgBiAHSQR/AkAgBEH/////A3EiCCAHIAZBf3NqIgQgBCAISxsiCEEHTQ0AIAZBAnQgCmoiBCADa0EQSQ0AIAYgCEEBaiIIIAhBA3EiCEEEIAgbayIOaiEGIAMgDkECdGoDQCAEIAP9AAIA/QsCACADQRBqIQMgBEEQaiEEIA5BBGsiDg0ACyEDCyAKIAZBAnRqIQQDQCADIA1GDQIgBCADKAIANgIAIARBBGohBCADQQRqIQMgByAGQQFqIgZHDQALIAcFIAYLNgIAIAMgDUYNAQNAAn8gBSgCPCIHQQVJBEAgByEEIAkhC0EEIQcgDAwBCyAFKAIsIQQgBSgCMCELIAkLIQYgAygCACEKIAQgB0YEfyAFQShqENQGIAUoAjAhCyAJIQYgBSgCLAUgBAtBAnQgC2ogCjYCACAGIAYoAgBBAWo2AgAgA0EEaiIDIA1HDQALDAELIAsgBjYCAAsgBUEgaiAFQThqKQIANwMAIAUgBf0AAij9CwMQIAEgAksEQCAAIAJBGGxqIgQoAhQiAUEFTwRAIAQoAggiA0EEaygCACIAQXhxIgIgAUECdCIBQQRBCCAAQQNxIgAbakkNAyAAQQAgAiABQSdqSxsNBCADEKICCyAEIAX9AAMQ/QsCACAEQRBqIAVBIGopAwA3AgAgBUFAayQADwsgAiABQby7xwAQjAcLAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALigYCEX8BfiMAQTBrIgUkACAFQQxqrUKAgICAEIQhFCAALQAMIQwgACgCBCERIAAoAgAhECAAKAIIIglBBGohCgJ/A0ACQCANIhINACAEIQtBASENAkACfyACIAZPBEADQCABIAZqIQcCQAJAAkACQAJAAkACQAJAIAIgBmsiCEEITwRAIAdBA2pBfHEiBCAHRg0BIAQgB2shBEEAIQMDQCADIAdqLQAAQQpGDQkgBCADQQFqIgNHDQALIAQgCEEIayIDSw0DDAILIAIgBkYNA0EAIQMDQCADIAdqLQAAQQpGDQggA0EBaiIDIAhHDQALDAULIAhBCGshA0EAIQQLA0BBgIKECCAEIAdqIg8oAgAiE0GKlKjQAHNrIBNyQYCChAggD0EEaigCACIPQYqUqNAAc2sgD3JxQYCBgoR4cUGAgYKEeEcNASAEQQhqIgQgA00NAAsLIAQgCEcNAQsgAiEGIAsMBgsgBCAHaiEHIAIgBGsgBmshCEEAIQMDQCADIAdqLQAAQQpGDQIgCCADQQFqIgNHDQALCyACIQYgCwwECyADIARqIQMLIAMgBmoiA0EBaiEGAkAgAiADTQ0AIAEgA2otAABBCkcNAEEAIQ0gBiEEDAQLIAIgBk8NAAsLIAsLIQQgAiEDCwJAIAxBAXFFBEAgAEEBOgAMIBAEQCAFIBE2AgwgBSAUNwMQIAooAgAhCCAJKAIAIQwgBUEBNgIsIAVBiPDBADYCKCAFQQE2AiQgBUECNgIcIAVB4PjHADYCGCAFIAVBEGo2AiBBASAMIAggBUEYahDBAw0FGgwCCyAJKAIAQbyLwwBBBCAKKAIAKAIMEQAADQIMAQsgDkUNACAJKAIAQQogCigCACgCEBECAA0BIBAEQCAJKAIAQaDwwQBBByAKKAIAKAIMEQAADQIMAQsgCSgCAEG8i8MAQQQgCigCACgCDBEAAA0BCyAOQQFqIQ5BASEMIAkoAgAgASALaiADIAtrIAooAgAoAgwRAABFDQELCyASQQFzCyAFQTBqJABBAXEL4gYCBX8BfiMAQTBrIgIkACAAKAIAIQAgASgCACIDQeiyxQBBASABKAIEIgQoAgwiBREAACEGIAIgADYCDAJAAkACQAJAAkACQAJAIAYNAAJAIAEtAApBgAFxRQRAIAJBDGogARDEBCACIABBAWo2AgxFDQEMAwsgA0Hc+McAQQEgBREAAA0BIAJBAToAHyACIAQ2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNASACKAIgQdmBwgBBAiACKAIkKAIMEQAAIAIgAEEBajYCDA0CCwJAIAEtAApBgAFxBEAgASkCACEHIAJBAToAHyACIAc3AhAgAkHggcIANgIkIAIgASkCCDcCKCACIAJBH2o2AhggAiACQRBqNgIgIAJBDGogAkEgahDEBA0DIAIoAiBB2YHCAEECIAIoAiQoAgwRAAAgAiAAQQJqNgIMRQ0BDAcLIAEoAgBB55DGAEECIAEoAgQoAgwRAAANAiACQQxqIAEQxAQgAiAAQQJqNgIMDQYLAkAgAS0ACkGAAXEEQCABKQIAIQcgAkEBOgAfIAIgBzcCECACQeCBwgA2AiQgAiABKQIINwIoIAIgAkEfajYCGCACIAJBEGo2AiAgAkEMaiACQSBqEMQEDQcgAigCIEHZgcIAQQIgAigCJCgCDBEAACACIABBA2o2AgxFDQEMBgsgASgCAEHnkMYAQQIgASgCBCgCDBEAAA0GIAJBDGogARDEBCACIABBA2o2AgwNBQsgAS0ACkGAAXFFDQIgASgCACEDIAEoAgQhBEEBIQAgAkEBOgAfIAIgBDYCFCACIAM2AhAgAkHggcIANgIkIAIgASkCCDcCKCACIAJBH2o2AhggAiACQRBqNgIgIAJBDGogAkEgahDEBA0EIAIoAiBB2YHCAEECIAIoAiQoAgwRAABFDQMMBgsgAiAAQQFqNgIMCyACIABBAmo2AgwMAwsgASgCAEHnkMYAQQIgASgCBCgCDBEAAA0BQQEhACACQQxqIAEQxAQNAyABKAIEIQQgASgCACEDCyADQemyxQBBASAEKAIMEQAAIQAMAgtBASEADAELIAIgAEEDajYCDEEBIQALIAJBMGokACAAC4IGAQF/AkACQCABIAMgBWwgBGoiA0kNAAJAIAEgA2siBEEDTQ0AIAAgA2oiBEH/ASACKAIAIAQtAABqIgZBACAGQQBKGyIGIAZB/wFOGzoAACAEQf8BIAIoAgQgBC0AAWoiBkEAIAZBAEobIgYgBkH/AU4bOgABIARB/wEgAigCCCAELQACaiIGQQAgBkEAShsiBiAGQf8BThs6AAIgBEH/ASACKAIMIAQtAANqIgRBACAEQQBKGyIEIARB/wFOGzoAAyABIAMgBWoiA0kNASABIANrIgRBBEkNACAAIANqIgRB/wEgAigCECAELQAAaiIGQQAgBkEAShsiBiAGQf8BThs6AAAgBEH/ASACKAIUIAQtAAFqIgZBACAGQQBKGyIGIAZB/wFOGzoAASAEQf8BIAIoAhggBC0AAmoiBkEAIAZBAEobIgYgBkH/AU4bOgACIARB/wEgAigCHCAELQADaiIEQQAgBEEAShsiBCAEQf8BThs6AAMgASADIAVqIgNJDQEgASADayIEQQRJDQAgACADaiIEQf8BIAIoAiAgBC0AAGoiBkEAIAZBAEobIgYgBkH/AU4bOgAAIARB/wEgAigCJCAELQABaiIGQQAgBkEAShsiBiAGQf8BThs6AAEgBEH/ASACKAIoIAQtAAJqIgZBACAGQQBKGyIGIAZB/wFOGzoAAiAEQf8BIAIoAiwgBC0AA2oiBEEAIARBAEobIgQgBEH/AU4bOgADIAEgAyAFaiIDSQ0BIAEgA2siBEEETw0CC0EAQQQgBEGY4sQAEOoHAAsgAyABIAFBqOLEABDqBwALIAAgA2oiAEH/ASACKAIwIAAtAABqIgFBACABQQBKGyIBIAFB/wFOGzoAACAAQf8BIAIoAjQgAC0AAWoiAUEAIAFBAEobIgEgAUH/AU4bOgABIABB/wEgAigCOCAALQACaiIBQQAgAUEAShsiASABQf8BThs6AAIgAEH/ASACKAI8IAAtAANqIgBBACAAQQBKGyIAIABB/wFOGzoAAwuBBgIHfwJ8IwBBIGsiBiQAQQEhCSABIAEoAhQiB0EBaiIFNgIUAkAgBSABKAIQIghPDQACQAJAIAEoAgwgBWotAABBK2sOAwECAAILQQAhCQsgASAHQQJqIgU2AhQLAkAgAAJ/AkACQAJAAn8CQAJAIAUgCEkEQCABIAVBAWoiBzYCFCABKAIMIgogBWotAABBMGtB/wFxIgVBCk8NAQJAIAcgCE8NAANAIAcgCmotAABBMGtB/wFxIgtBCk8NASABIAdBAWoiBzYCFCAFQcyZs+YARyALQQdLciAFQcuZs+YASnENBiAFQQpsIAtqIQUgByAIRw0ACyAIIQcLIAkNAiAEIAVrIgFBH3VBgICAgHhzIAEgASAESCAFQQBKcxsMAwsgBkEYaiABKAIMIAggBRD5ASAGKAIcIQIgBigCGCEEQRQQcSIBRQ0EIAEgBDYCDCABQQU2AgAgACABNgIEIABBATYCACABIAI2AhAMBwsgBkEQaiAKIAggBxD5ASAGKAIUIQIgBigCECEEQRQQcSIBRQ0DIAEgBDYCDCABQQ02AgAgACABNgIEIABBATYCACABIAI2AhAMBgsgBCAFaiIBQR91QYCAgIB4cyABIAVBAEggASAESHMbCyEFIAO6IQwCQAJAAkAgBSAFQR91IgFzIAFrIgFBtQJPBEADQCAMRAAAAAAAAAAAYQ0HIAVBAE4NAiAMRKDI64XzzOF/oyEMIAVBtAJqIgUgBUEfdSIBcyABayIBQbUCTw0ACwsgAUEDdCsDoIJHIQ0gBUEATg0BIAwgDaMhDAwFCyAGQQhqIAogCCAHEPkBIAYoAgwhAiAGKAIIIQQMAQsgDCANoiIMmUQAAAAAAADwf2INAyAGIAogCCAHEPkBIAYoAgQhAiAGKAIAIQQLQRQQcSIBRQ0BIAEgBDYCDCABQQ42AgAgACABNgIEIAEgAjYCEEEBDAMLIAAgASACIANQIAkQ7AUMAwsACyAAIAwgDJogAhs5AwhBAAs2AgALIAZBIGokAAvbBgIFfwF+IwBBMGsiAiQAIAEoAgAiA0HossUAQQEgASgCBCIEKAIMIgURAAAhBiACIAA2AgwCQAJAAkACQAJAAkACQCAGDQACQCABLQAKQYABcUUEQCACQQxqIAEQxAQgAiAAQQFqNgIMRQ0BDAMLIANB3PjHAEEBIAURAAANASACQQE6AB8gAiAENgIUIAIgAzYCECACQeCBwgA2AiQgAiABKQIINwIoIAIgAkEfajYCGCACIAJBEGo2AiAgAkEMaiACQSBqEMQEDQEgAigCIEHZgcIAQQIgAigCJCgCDBEAACACIABBAWo2AgwNAgsCQCABLQAKQYABcQRAIAEpAgAhByACQQE6AB8gAiAHNwIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNAyACKAIgQdmBwgBBAiACKAIkKAIMEQAAIAIgAEECajYCDEUNAQwHCyABKAIAQeeQxgBBAiABKAIEKAIMEQAADQIgAkEMaiABEMQEIAIgAEECajYCDA0GCwJAIAEtAApBgAFxBEAgASkCACEHIAJBAToAHyACIAc3AhAgAkHggcIANgIkIAIgASkCCDcCKCACIAJBH2o2AhggAiACQRBqNgIgIAJBDGogAkEgahDEBA0HIAIoAiBB2YHCAEECIAIoAiQoAgwRAAAgAiAAQQNqNgIMRQ0BDAYLIAEoAgBB55DGAEECIAEoAgQoAgwRAAANBiACQQxqIAEQxAQgAiAAQQNqNgIMDQULIAEtAApBgAFxRQ0CIAEoAgAhAyABKAIEIQRBASEAIAJBAToAHyACIAQ2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNBCACKAIgQdmBwgBBAiACKAIkKAIMEQAARQ0DDAYLIAIgAEEBajYCDAsgAiAAQQJqNgIMDAMLIAEoAgBB55DGAEECIAEoAgQoAgwRAAANAUEBIQAgAkEMaiABEMQEDQMgASgCBCEEIAEoAgAhAwsgA0HpssUAQQEgBCgCDBEAACEADAILQQEhAAwBCyACIABBA2o2AgxBASEACyACQTBqJAAgAAuOBgIGfwV+QQQhAyABKAIIIgRBBGooAgAhBSABAn4gBEEIaigCACIGIAEpAwAiCiAGrSIJIAkgClYbp0YEQEGokMgAKQMAIg1CCIghCyANpyEDIAkgDUL/AYNCBFINARoLIApCAXwLIgw3AwAgA0H/AXFBBEcEQCAAQoGAgICQgICAgH83AgAgACADrUL/AYMgC0IIhoQ3AggPCyABAn4CQCAGIAwgCSAJIAxWG6ciA2tBBE8EQCADIAVqKAAAIQZBBCEDQgAhCwwBC0EAIQZBqJDIACkDACINQgiIIQsgDachAyAJIA1C/wGDQgRSDQEaCyAMQgR8CyIKNwMAIANB/wFxQQRHBEAgACADOgAIIABCgYCAgJCAgICAfzcCACAAIAunIgE7AAkgACALQhiIPgIMIABBC2ogAUEQdjoAAA8LAkACQAJAAkAgAkH//wNxIgdBBU8EQCAHQQVrIgIEQCACEHEiAwRAIANBBGstAABBA3FFIAJFckUEQCADQQAgAvwLAAsgBEEIaigCACIFrSEJIAVC/////w8gCiAKQv////8PWhunayIIQQAgBSAITxsgAk8EQCAEQQRqKAIAIAogCSAJIApWG6dqIQQgAkEBRw0EIAMgBC0AADoAAAwFC0GokMgAKQMAIgtCCIghDCALpyEEIAtC/wGDQgRSDQYMBQsACyAFIAogCSAJIApWG6dqIQRBASEDDAELIAD9DAEAAAAAAACAXAgSACAAAAD9CwIADwsgAkUNACADIAQgAvwKAAALQgAhDEEEIQQLIAogAq18IQkLIAEgCTcDAAJAAkACQCAEQf8BcUEERwRAIABCgYCAgJCAgICAfzcCACAAIAStQv8BgyAMQgiGhDcCCCACRQ0BIANBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIAJqSQ0CIABBACABIAdBImpLGw0DIAMQogIPCyAAIAY2AgwgACACNgIIIAAgAzYCBCAAQQA2AgALDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALhwcBBn8jAEEwayICJAACQAJAAkACQAJAAkACQEEDIAAoAgAiA0GAgICAeHMgA0EAThtBAWsOBQECAwQFAAsgASgCAEGkrscAQREgASgCBCgCDBEAACEDDAULIAEoAgBBta7HAEENIAEoAgQoAgwRAAAhAwwEC0EBIQMgASgCACIEQdSuxwBBDyABKAIEIgcoAgwiBREAAA0DIABBBGohBgJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANBSACIAY2AhwgASAAQQdqQcioxwAgAEEFakHYqMcAIABBBmpB6KjHACACQRxqQfioxwAQ7gVFDQEMBQsgBEHbgcIAQQIgBREAAA0EIAJBAToADyACIAc2AhQgAiAENgIQIAJB4IHCADYCICACIAEpAgg3AiQgAiACQQ9qNgIYIAIgAkEQajYCHCACIAY2AiwgAkEcaiAAQQdqQcioxwAgAEEFakHYqMcAIABBBmpB6KjHACACQSxqQfioxwAQ7gUNBCACKAIcQdmBwgBBAiACKAIgKAIMEQAADQQLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwDC0EBIQMgASgCACIEQeOuxwBBByABKAIEIgYoAgwiBREAAA0CAkAgAS0ACkGAAXFFBEAgBEG7s8UAQQEgBREAAA0EIAAoAgQgACgCCCABELUCRQ0BDAQLIARB24HCAEECIAURAAANAyACQQE6ACwgAiAGNgIUIAIgBDYCECACQeCBwgA2AiAgAiABKQIINwIkIAIgAkEsajYCGCACIAJBEGoiBDYCHCAAKAIEIAAoAgggAkEcahC1Ag0DIARB2YHCAEECEK8DDQMLIAEoAgBB3o7IAEEBIAEoAgQoAgwRAAAhAwwCCyABKAIAQequxwBBCiABKAIEKAIMEQAAIQMMAQsgAiAAQQhqNgIQIAEoAgBBhK/HAEEMIAEoAgQoAgwRAAAhAyACQQA6ACEgAiADOgAgIAIgATYCHCACQRxqQZCvxwBBCCAAQQRqQfSuxwAQjAVBmK/HAEEFIAJBEGpBxK7HABCMBSACLQAhIgEgAi0AICIEciEDIARBAXEgAUEBR3INACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQMMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEDCyACQTBqJAAgA0EBcQufBgIHfwF+IwBBMGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkAgASgCFCICIAEoAhAiA0kEQCABKAIMIQcCfgJAA0AgAiAHai0AACIFQQlrIghBF0tBASAIdEGTgIAEcUVyDQEgASACQQFqIgI2AhQgAiADRw0ACyADIQJCAAwBC0KAAgsgBa1CEIaEQoCCuANRDQELAkAgBEEYaiABKAIMIgcgAyACIANJBH8gAUEMaiEIA0ACQCACIAdqLQAAQQlrIgVBGU0EQEEBIAV0QZOAgARxDQEgBUEZRg0ECyABIARBL2pBtOLAABDuASABEOsFIQIMDAsgASACQQFqIgI2AhQgAiADRw0ACyADBSACC0EBaiIBIAMgASADSRsQ+QEgBCgCHCEDIAQoAhghAUEUEHEiAkUNByACIAE2AgwgAkEFNgIAIAIgAzYCEAwJCyABQQA2AgggASACQQFqNgIUIARBIGogCCABEIICIAQoAiQhAiAEKAIgIgFBAkYNCCAEKAIoIQMCQCABQQFxBEAgA0EASA0DIANFDQEMBwsgA0EASA0DIAMNBgtBASEBDAcLIAEgAkEBaiIGNgIUAkAgAyAGTQ0AIAEgAkECaiIFNgIUIAYgB2otAABB9QBHDQMgBSAGIAMgAyAGSRsiBkYNACABIAJBA2oiCDYCFCAFIAdqLQAAQewARwRAIAghBQwECyAGIAhGDQAgASACQQRqIgU2AhQgByAIai0AAEHsAEcNAyAAQYCAgIB4NgIADAkLIARBCGogByADIAYQ+QEgBCgCDCEGIAQoAgghAUEUEHEiAkUNBSACQQU2AgAMAwtB2JrIABD/BwALQdiayAAQ/wcACyAEQRBqIAcgAyAFEPkBIAQoAhQhBiAEKAIQIQFBFBBxIgJFDQIgAkEJNgIACyACIAE2AgwgACACNgIEIABBgYCAgHg2AgAgAiAGNgIQDAQLIAMQcSIBDQELAAsgAwRAIAEgAiAD/AoAAAsgACADNgIIIAAgATYCBCAAIAM2AgAMAQsgAEGBgICAeDYCACAAIAI2AgQLIARBMGokAAvyBQIFfwJ9IAEqAgAQxgW8IgJB////A3EhAyACQYCAgIB4cSEFIAEqAgQCQCACQYCAgPwHcSIEQYCAgPwHRgRAIANBDXYgBUEQdnJBgARBACADG3JBgPgBciEFDAELIAVBEHYhBSAEQYCAgLgETQRAIARBgICAxANPBEAgAkEMdiACQf/fAHFBAEdxIARBDXYgA0ENdmpBgIABaiAFcmohBQwCCyAEQYCAgJgDSQ0BIANBgICABHIiAkH+ACAEQRd2IgNrdiEEIAJBHSADayIDdkEBcQR/IARBAyADdEEBayACcUEAR2oFIAQLIAVyIQUMAQsgBUGA+AFyIQULIAEqAgghCBDGBbwiAkH///8DcSEDIAJBgICAgHhxIQQCQCACQYCAgPwHcSIBQYCAgPwHRwRAIARBEHYhBCABQYCAgLgETQRAIAFBgICAxANPBEAgAkEMdiACQf/fAHFBAEdxIAFBDXYgA0ENdmpBgIABaiAEcmohBAwDCyABQYCAgJgDSQ0CIANBgICABHIiAkH+ACABQRd2IgNrdiEBIAJBHSADayIDdkEBcQR/IAFBAyADdEEBayACcUEAR2oFIAELIARyIQQMAgsgBEGA+AFyIQQMAQsgA0ENdiAEQRB2ckGABEEAIAMbckGA+AFyIQQLIAgQxgW8IgNB////A3EhBiADQYCAgIB4cSECAkAgA0GAgID8B3EiAUGAgID8B0cEQCACQRB2IQIgAUGAgIC4BE0EQCABQYCAgMQDTwRAIANBDHYgA0H/3wBxQQBHcSABQQ12IAZBDXZqQYCAAWogAnJqIQIMAwsgAUGAgICYA0kNAiAGQYCAgARyIgNB/gAgAUEXdiIGa3YhASADQR0gBmsiBnZBAXEEfyABQQMgBnRBAWsgA3FBAEdqBSABCyACciECDAILIAJBgPgBciECDAELIAZBDXYgAkEQdnJBgARBACAGG3JBgPgBciECCyAAIAI7ASAgACAEOwEeIAAgBTsBHAu7BwIFewd/IAJB//8DcSECIAFB//8DcSEKIAQgBEGgK3AiC2siDUGgK08EQCANIQwgAyEBA0D9DAAAAAAAAAAAAAAAAAAAAAAiBSAC/RwAIQYgBSAKQa0BbP0cACEHQQAhBANAIAEgBGoiAv0AAAAiCP2JAf0MIAAfAB4AHQAcABsAGgAZAP26ASAG/a4BIAj9igH9DBgAFwAWABUAFAATABIAEQD9ugH9rgEgAkEQav0AAAAiCf2JAf0MEAAPAA4ADQAMAAsACgAJAP26Af2uASAJ/YoB/QwIAAcABgAFAAQAAwACAAEA/boB/a4BIQYgBSAH/a4BIQcgCP19/X8gBf2uASAJ/X39f/2uASEFIARBIGoiBEGgK0cNAAsgBiAHQQX9qwH9rgEiBv0bASAG/RsAaiAG/RsCaiAG/RsDakHx/wNwIQIgAUGgK2ohASAF/RsAIApqIAX9GwFqIAX9GwJqIAX9GwNqQfH/A3AhCiAMQaArayIMQZ8rSw0ACwsgAyANaiEDIAtBIE8EQP0MAAAAAAAAAAAAAAAAAAAAACIFIAL9HAAhBkEAIAtB4D9xIgFrIQIgBSAKIAtBBXZs/RwAIQcgAyEEA0AgBP0AAAAiCP2JAf0MIAAfAB4AHQAcABsAGgAZAP26ASAG/a4BIAj9igH9DBgAFwAWABUAFAATABIAEQD9ugH9rgEgBEEQav0AAAAiCf2JAf0MEAAPAA4ADQAMAAsACgAJAP26Af2uASAJ/YoB/QwIAAcABgAFAAQAAwACAAEA/boB/a4BIQYgBEEgaiEEIAUgB/2uASEHIAj9ff1/IAX9rgEgCf19/X/9rgEhBSACQSBqIgINAAsgASADaiEDIAtBH3EhCyAF/RsAIApqIAX9GwFqIAX9GwJqIAX9GwNqIQogBiAHQQX9qwH9rgEiBv0bASAG/RsAaiAG/RsCaiAG/RsDaiECCwJAIAtFDQACQCALQQdxIgxFBEAgAyEEDAELIAMhAQNAIAogAS0AAGoiCiACaiECIAFBAWoiBCEBIAxBAWsiDA0ACwsgC0EISQ0AIAMgC2ohAQNAIAogBC0AAGoiAyAEQQFqLQAAaiIMIARBAmotAABqIg0gBEEDai0AAGoiCyAEQQRqLQAAaiIOIARBBWotAABqIg8gBEEGai0AAGoiECAEQQdqLQAAaiIKIBAgDyAOIAsgDSAMIAIgA2pqampqampqIQIgBEEIaiIEIAFHDQALCyAAIAJB8f8DcDsBAiAAIApB8f8DcDsBAAuzBwIFewh/IABB//8DcSEJIABBEHYhCCACIAJBoCtwIgprIgxBoCtPBEAgDCELIAEhAgNA/QwAAAAAAAAAAAAAAAAAAAAAIgMgCP0cACEEIAMgCUGtAWz9HAAhBUEAIQADQCAAIAJqIgj9AAAAIgb9iQH9DCAAHwAeAB0AHAAbABoAGQD9ugEgBP2uASAG/YoB/QwYABcAFgAVABQAEwASABEA/boB/a4BIAhBEGr9AAAAIgf9iQH9DBAADwAOAA0ADAALAAoACQD9ugH9rgEgB/2KAf0MCAAHAAYABQAEAAMAAgABAP26Af2uASEEIAMgBf2uASEFIAb9ff1/IAP9rgEgB/19/X/9rgEhAyAAQSBqIgBBoCtHDQALIAQgBUEF/asB/a4BIgT9GwEgBP0bAGogBP0bAmogBP0bA2pB8f8DcCEIIAJBoCtqIQIgA/0bACAJaiAD/RsBaiAD/RsCaiAD/RsDakHx/wNwIQkgC0GgK2siC0GfK0sNAAsLIAEgDGohASAKQSBPBED9DAAAAAAAAAAAAAAAAAAAAAAiAyAI/RwAIQRBACAKQeA/cSICayEIIAMgCSAKQQV2bP0cACEFIAEhAANAIAD9AAAAIgb9iQH9DCAAHwAeAB0AHAAbABoAGQD9ugEgBP2uASAG/YoB/QwYABcAFgAVABQAEwASABEA/boB/a4BIABBEGr9AAAAIgf9iQH9DBAADwAOAA0ADAALAAoACQD9ugH9rgEgB/2KAf0MCAAHAAYABQAEAAMAAgABAP26Af2uASEEIABBIGohACADIAX9rgEhBSAG/X39fyAD/a4BIAf9ff1//a4BIQMgCEEgaiIIDQALIAQgBUEF/asB/a4BIgT9GwEgBP0bAGogBP0bAmogBP0bA2ohCCAKQR9xIQogA/0bACAJaiAD/RsBaiAD/RsCaiAD/RsDaiEJIAEgAmohAQsCQCAKRQ0AAkAgCkEHcSILRQRAIAEhAAwBCyABIQIDQCAJIAItAABqIgkgCGohCCACQQFqIgAhAiALQQFrIgsNAAsLIApBCEkNACABIApqIQEDQCAJIAAtAABqIgIgAEEBai0AAGoiCyAAQQJqLQAAaiIMIABBA2otAABqIgogAEEEai0AAGoiDSAAQQVqLQAAaiIOIABBBmotAABqIg8gAEEHai0AAGoiCSAPIA4gDSAKIAwgCyACIAhqampqampqaiEIIABBCGoiACABRw0ACwsgCUHx/wNwIAhB8f8DcEEQdHILrAcCAn8BeyMAQYDSAGsiAyQAAkACQAJAAkACQAJAAkACQCABQf8BcUEBaw4FAAIDBAUBC0GAgAgQcSIERQ0FIARBBGstAABBA3EEQCAEQQBBgIAI/AsACyADQUBrQQBBwNEA/AsAQajTABBxIgFFDQUgAUGAgICAeDYCZCABQgE3AlwgAUKAgAg3AlQgASAENgJQIAFCgICAgICAgAE3AkggAUKAgICAEDcCQCABIAL9AAIA/QsCACABQTBqIAJBMGr9AAIA/QsCACABQSBqIAJBIGr9AAIA/QsCACABQRBqIAJBEGr9AAIA/QsCACABQegAaiADQQxqQfTRAPwKAAAgAUHc0gBqQQBBwQD8CwAgAUEAOwGkUyABQQA2AqBTQajewQAhAgwGC0G4BRBxIgFFDQQgAUEANgKwBSABQoCAgIAQNwOoBSABQYGAgIB4NgKcBSABIAL9AAIA/QsCACABQTBqIAJBMGr9AAIA/QsCACABQSBqIAJBIGr9AAIA/QsCACABQRBqIAJBEGr9AAIA/QsCAEGQ3sEAIQIMBQtBzAAQcSIBRQ0DIAFBADYCSCABQoCAgIAQNwJAIAEgAv0AAgD9CwIAIAFBMGogAkEwav0AAgD9CwIAIAFBIGogAkEgav0AAgD9CwIAIAFBEGogAkEQav0AAgD9CwIAQcDewQAhAgwEC0HMABBxIgFFDQIgAUEANgJIIAFCgICAgBA3AkAgASAC/QACAP0LAgAgAUEwaiACQTBq/QACAP0LAgAgAUEgaiACQSBq/QACAP0LAgAgAUEQaiACQRBq/QACAP0LAgBB2N7BACECDAMLQcwAEHEiAUUNASABQQA2AkggAUKAgICAEDcCQCABIAL9AAIA/QsCACABQTBqIAJBMGr9AAIA/QsCACABQSBqIAJBIGr9AAIA/QsCACABQRBqIAJBEGr9AAIA/QsCAEHw3sEAIQIMAgtBgAMQcSIBRQ0AIAFBAjYCiAEgAUECNgIAIAH9DAAAAAAAAAAAAAAAAAAAAAD9CwO4AiABIAX9CwPgAiABIAL9AAIA/QsC+AEgAUHIAmogBf0LAwAgAUHYAmpCgICAgBA3AwAgAUH1AmpCADcAACABQfACakIANwMAIAFBiAJqIAJBEGr9AAIA/QsCACABQZgCaiACQSBq/QACAP0LAgAgAUGoAmogAkEwav0AAgD9CwIAQYjfwQAhAgwBCwALIAAgAjYCBCAAIAE2AgAgA0GA0gBqJAALkgYBBn8CQAJAAkACQAJAAkAgAEEgSQ0AIABB/wBJBEBBASEDDAYLAkAgAEGAgARPBEAgAEGAgAhJDQEgAEHg//8AcUHgzQpHIABB/v//AHFBnvAKR3EgAEHwgzhJcSAA/RH9DMBI/f9QMf3/EBT9/wAI/f/9rgH9DPn////x////8P///132///9PP1TQX9zcSAAQYCADGtBnnRJcSAAQdCmDGtBe0lxIABBgII4a0GwxVRJcSEDDAcLIABBCHZB/wFxIQUDQCABQQJqIQYgAiABLQC7gUMiA2ohBCAFIAEtALqBQyIBRwRAIAEgBUsNByAEIQIgBiIBQdAARw0BDAcLIAIgBEsgBEGiAktyDQUgAkGKgsMAaiEBA0AgA0UEQCAEIQIgBiIBQdAARw0CDAgLIANBAWshAyABLQAAIAFBAWohASAAQf8BcUcNAAsLDAELIABBCHZB/wFxIQUDQCABQQJqIQYgAiABLQCt+0IiA2ohBCAFIAEtAKz7QiIBRwRAIAEgBUsNBCAEIQIgBiIBQdgARw0BDAQLIAIgBEsgBEHQAUtyDQIgAkGE/MIAaiEBA0AgA0UEQCAEIQIgBiIBQdgARw0CDAULIANBAWshAyABLQAAIAFBAWohASAAQf8BcUcNAAsLC0EAIQMMBAsgAiAEQdABQeiGwwAQ6gcACyAAQf//A3EhAkEBIQNBACEBA0AgAUEBaiEEAkAgASwA1P1CIgBBAE4EQCAEIQEMAQsgBEHmA0cEQCABQdX9wgBqLQAAIABB/wBxQQh0ciEAIAFBAmohAQwBC0HYhsMAEN0JAAsgAiAAayICQQBIDQMgA0EBcyEDIAFB5gNHDQALDAILIAIgBEGiAkHohsMAEOoHAAtBASEDQQAhAQNAIAFBAWohBAJAIAEsAKyEQyICQQBOBEAgBCEBDAELIARBqQJHBEAgAUGthMMAai0AACACQf8AcUEIdHIhAiABQQJqIQEMAQtB2IbDABDdCQALIAAgAmsiAEEASA0BIANBAXMhAyABQakCRw0ACwsgA0EBcQvCBgILfwR7IwBBIGsiCSQAAkACQAJAAkACQCADIAQgBWwiCmoiC0EBayIGIAFNBEAgBEEBayAFbCADaiIEQQFrIgcgBk8NASAEIAZLDQIgASAGayEMIAQgBkYEQCABIAprIANrIQRBACEAIAIhAwNAIAAgDE8NBSACIARLDQYgBCAFayEEIAAgBWohACADQQFrIgMNAAsMBgsgACAGaiEOIAAgB2otAAAhDyAAIARqIQ0gBiAEayIBIAIgASACSRsiBkEBcSEQIAZBEHEhAyAAIAtqIQtBACEHA0AgBSAHbCIAIAxPDQQgAiAMIABBAWoiAWsiBEsNBSAAIA5qLQAAIA9rIQogASAOaiEEQQAhAQJAIAZBEEkgB0EBaiIHIAVsQRBJckUEQCAEIAr9ESIRIA39AAAAIhL9iQH9qQH9rgH9DAAAAAAAAAAAAAAAAAAAAAD9uAH9DP8AAAD/AAAA/wAAAP8AAAAiFP22ASARIBIgEf0NBAUGBwAAAAAAAAAAAAAAAP2JAf2pAf2uASAT/bgBIBT9tgH9hgEgESASIBH9DQgJCgsAAAAAAAAAAAAAAAD9iQH9qQH9rgEgE/24ASAU/bYBIBEgEiAR/Q0MDQ4PAAAAAAAAAAAAAAAA/YkB/akB/a4BIBP9uAEgFP22Af2GAf1m/QsAACAGIAMiAUYNAQsgAUEBciEAIBAEQCABIARqQf8BIAogASANai0AAGoiAUEAIAFBAEobIgEgAUH/AU4bOgAAIAAhAQsgACAGRg0AIAEgC2ohACABIA1qIQQgBiABayEBA0AgAEH/ASAKIAQtAABqIghBACAIQQBKGyIIIAhB/wFOGzoAACAAQQFqQf8BIAogBEEBai0AAGoiCEEAIAhBAEobIgggCEH/AU4bOgAAIABBAmohACAEQQJqIQQgAUECayIBDQALCyAFIAtqIQsgAiAHRw0ACwwFCyAJQQA2AhggCUEBNgIMIAlBiILIADYCCCAJQgQ3AhAgCUEIakHo4sQAEI0IAAsgByAGQfjixAAQjAcACyAEIAYgBkGo48QAEOoHAAsgACAMQYjjxAAQjAcAC0EAIAIgBEGY48QAEOoHAAsgCUEgaiQAC78GAQR/IAAgAWohAgJAAkAgACgCBCIDQQFxDQAgA0ECcUUNASAAKAIAIgMgAWohASAAIANrIgBB2LrJACgCAEYEQCACKAIEQQNxQQNHDQFB0LrJACABNgIAIAIgAigCBEF+cTYCBCAAIAFBAXI2AgQgAiABNgIADAILIAAgAxDWBAsCQAJAAkAgAigCBCIDQQJxRQRAIAJB3LrJACgCAEYNAiACQdi6yQAoAgBGDQMgAiADQXhxIgMQ1gQgACABIANqIgFBAXI2AgQgACABaiABNgIAIABB2LrJACgCAEcNAUHQuskAIAE2AgAPCyACIANBfnE2AgQgACABQQFyNgIEIAAgAWogATYCAAsgAUGAAk8EQEEfIQIgAEIANwIQIAFB////B00EQCABQSYgAUEIdmciA2t2QQFxIANBAXRrQT5qIQILIAAgAjYCHCACQQJ0QbC3yQBqIQRBASACdCIDQcy6yQAoAgBxRQRAIAQgADYCACAAIAQ2AhggACAANgIMIAAgADYCCEHMuskAQcy6yQAoAgAgA3I2AgAPCwJAAkAgASAEKAIAIgMoAgRBeHFGBEAgAyECDAELIAFBGSACQQF2a0EAIAJBH0cbdCEFA0AgAyAFQR12QQRxaiIEKAIQIgJFDQIgBUEBdCEFIAIhAyACKAIEQXhxIAFHDQALCyACKAIIIgEgADYCDCACIAA2AgggAEEANgIYIAAgAjYCDCAAIAE2AggPCyAEQRBqIAA2AgAgACADNgIYIAAgADYCDCAAIAA2AggPCwJ/Qci6yQAoAgAiAkEBIAFBA3Z0IgNxRQRAQci6yQAgAiADcjYCACABQfgBcUHAuMkAaiIBDAELIAFB+AFxIgNBwLjJAGohASADQci4yQBqKAIACyECIAEgADYCCCACIAA2AgwgACABNgIMIAAgAjYCCA8LQdy6yQAgADYCAEHUuskAQdS6yQAoAgAgAWoiATYCACAAIAFBAXI2AgQgAEHYuskAKAIARw0BQdC6yQBBADYCAEHYuskAQQA2AgAPC0HYuskAIAA2AgBB0LrJAEHQuskAKAIAIAFqIgE2AgAgACABQQFyNgIEIAAgAWogATYCAAsL3HkDH38IfgJ7IwBBEGsiFSQAAkAgASkDGEICUgRAIAFBGGohIiABQcgAaiERIAEoAgwhCSABKAIIIQsDQCABKAIAIQcCQCAJIAtLDQAgASgCBCIIIAEoAhAiBmsiBQRAIAYgB2pBACAF/AsACyAVICIgByAIEKYDIBUtAABBBEYEQCAIIBUoAgQiCU8EQCABIAg2AhAgASAJNgIMQQAhCyABQQA2AggMAgtBtJvHAEE2QeybxwAQ6wcACyAVKAIEIQYgFSgCACEFIBUxAAAgASAINgIQIAFCADcDCEEAIQlBACELQgRRDQAgACAGNgIEIAAgBTYCAAwDCyABKQNQISkgASkDSCEqQQRBACAJIAtGIiAbISEjAEEwayIMJAAgESADNgIwIBEgCSALayIGNgIkIBEgAjYCLCARIAcgC2oiHzYCICARKAI8IgQtAAAiBUEMRgRAIARBDToAAEENIQULIBEpAxghJyARKQMQISggBCADNgJ0IAQgBjYCcCAEQQA2AlAgBCADNgJMIAQgAjYCSCAEIB82AjggBCAhOgAEIAQgBiAfajYCPCAEQcEAaiEUIARBCGohGSAEQYTsAGohDiAEQYTnAGohGiAEQaQBaiEdIARB9CpqIRsgBEHE1ABqIRcgBEHIAGohEwJAAkACQAJAA0AgBSEGQRIhBUEBIQgCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAGQf8BcUEBaw4eHBsaDQwLCgkCARkYCBcdBx8WFRQGBRMSHgARECEPDgsgBCgCJCIJIAQoAiAiECAEKAIcIg1qIgtPDQMgBCgCOCEGIAQtAEAhBSAEKQMwISMDQEJ/IAQ1ApQBhkJ/hSElIAQoAjwhEiAELQCYASEIAkACQAJAAkACQAJAAkACQAJAAkACQANAICMgJYOnIQ9BgAQhCkGo58gAIQcCQAJAAkACQCAIQQFrDgMAAQIDC0G0CiEKIB0hBwwCC0G0CiEKIBshBwwBC0HQBCEKIBchBwsgCiAPTQ0BIAcgD0ECdGooAQAiCkEYdiIPIAVB/wFxSwRAIAYgEkYNECAGMQAAISQgBCAFQQhqIgc6AEAgBCAGQQFqIgY2AjggBCAkIAWthiAjhCIjNwMwIAchBQwBCwsgCkH//wNxIgdBEE8EQCAFQf8BcSEIAkACQAJAAkAgB0EQaw4CAQIACwJAIAggD0EHaiIKTwRAIAUhBwwBCyAGIQgDQCAIIBJGDRQgBCAIQQFqIgY2AjggBCAFQQhqIgc6AEAgBCAIMQAAIAWthiAjhCIjNwMwIAYhCCAKIAciBUH/AXFLDQALCyAEIAcgD2tBB2siBToAQCAEICMgD62IIiRCB4giIzcDMCALICSnQf8AcUELaiILIAlqIgdJDQogCUHAAksNCyALQcACIAlrIghLDQwgC0EBdCIIBEAgGiAJQQF0akEAIAj8CwALIAQgBzYCJCAHIQkMDgsCQCAIIA9BAmoiCk8EQCAFIQcMAQsgBiEIA0AgCCASRg0TIAQgCEEBaiIGNgI4IAQgBUEIaiIHOgBAIAQgCDEAACAFrYYgI4QiIzcDMCAGIQggCiAHIgVB/wFxSw0ACwsgBCAHIA9rIgU6AEAgBCAjIA+tiCIkNwMwIAkNASAEQRo2AogBIARB5IDAADYChAEMLgsCQCAIIA9BA2oiCk8EQCAFIQcMAQsgBiEIA0AgCCASRg0SIAQgCEEBaiIGNgI4IAQgBUEIaiIHOgBAIAQgCDEAACAFrYYgI4QiIzcDMCAGIQggCiAHIgVB/wFxSw0ACwtBfSEIIAQgByAPa0EDayIFOgBAIAQgIyAPrYgiJEIDiCIjNwMwIAsgJKdBB3FBA2oiCiAJaiIHSQ0FIAlBwAJLDQYgCkHAAiAJayIISw0HIApBAXQiCARAIBogCUEBdGpBACAI/AsACyAEIAc2AiQgByEJDAwLIAlBAWshByAJQcACSw0CIBogB0EBdGovAQAhDSAEIAVBAmsiBToAQCAEICRCAogiIzcDMCALICSnQQNxIghBA2oiCiAJakkEQCAEQRo2AogBIARB5IDAADYChAEMLQsgCkHAAiAJayIHSw0DIBogCUEBdGohByAIQQJq/REiK/0MAAAAAAEAAAACAAAAAwAAAP1AIiz9GwBBAXEEQCAHIA07AQALICz9GwFBAXEEQCAHQQJqIA07AQALICz9GwJBAXEEQCAHQQRqIA07AQALICz9GwNBAXEEQCAHQQZqIA07AQALICv9DAQAAAAFAAAABgAAAAcAAAD9QCIr/RsAQQFxBEAgB0EIaiANOwEACyAr/RsBQQFxBEAgB0EKaiANOwEACyAr/RsCQQFxBEAgB0EMaiANOwEACyAr/RsDQQFxBEAgB0EOaiANOwEACyAEIAQoAiQgCmoiCTYCJCAEKAIgIRAgBCgCHCENDAsLIAQgBSAPayIFOgBAIAQgIyAPrYgiIzcDMCAJQcACSQ0JIAlBwAJB1PzIABCMBwALIA8gCkHc+cgAEIwHAAsgB0HAAkH0+8gAEIwHAAtBACAKIAdBhPzIABDqBwALIARBGjYCiAEgBEHkgMAANgKEAUEeIQYMKAsgCUHAAkHAAkGk/MgAEOoHAAtBACAKIAhBlPzIABDqBwALIARBGjYCiAEgBEHkgMAANgKEAQwkCyAJQcACQcACQcT8yAAQ6gcAC0EAIAsgCEG0/MgAEOoHAAsgBCAJQQFqIgc2AiQgGiAJQQF0aiAKOwEAIAchCQsgCSANIBBqIgtJDQALDAMLQXwhCAwfC0F+IQgMHgtBACEIQRohBgwdCyAELwGEa0UEQCAEQSU2AogBIARB7c7AADYChAEMHAsCQAJAAkAgDUHBAkkEQCAMQRhqIgZBASAaIA0gG0G0CkEKIA4QrQEgDCgCGA0BIAwoAiAhBSAEIAwoAhw2ApQBIARBAjoAmAEgBCAFNgIoIAQoAhwiCEHAAksNAiAEKAIgIgdBwAIgCGsiBUsNAyAGQQIgGiAIQQF0aiAHIBdB0ARBCSAOEK0BIAwoAhhFBEAgDCgCICEGIAwoAhwhBSAEQQM6AKABIAQgBTYCnAEgBCAGIAQoAihqNgIoQREhBSAELQAEQQZHDR9BACEIQREhBgwhCyAEQRY2AogBIARBzoDAADYChAEMHwtBACANQcACQeT7yAAQ6gcACyAEQRw2AogBIARBgIDAADYChAEMHQsgCEHAAkHAAkHU+8gAEOoHAAtBACAHIAVBxPvIABDqBwALQRchBSAEKAJgIglFDRkgBCkDMCEjAkAgBC0AQCIIIAlPBEAgCCEKDAELIAQoAjghBiAEKAI8IQsDQCAGIAtGBEBBACEIQRYhBgweCyAEIAZBAWoiBzYCOCAEIAhBCGoiCjoAQCAEIAYxAAAgCK2GICOEIiM3AzAgByEGIAkgCiIIQf8BcUsNAAsLIAQgCiAJazoAQCAEICMgCa2INwMwIAQgBCgCZCAJajYCZCAEIAQoAlwgI0J/IAlBP3GthkJ/hYOnajYCXAwZC0J/IAQ1ApwBhkJ/hSElIAQoAjghBiAELQBAIQUgBCgCPCEPIAQpAzAhIyAELQCgASEQAkACQAJAAkADQCAjICWDpyEIQSAhCkGo98gAIQcCQAJAAkACQCAQQQFrDgMAAQIDC0G0CiEKIB0hBwwCC0G0CiEKIBshBwwBC0HQBCEKIBchBwsgCCAKTw0CAkACQCAHIAhBAnRqKAEAIghBGHYiCyAFQf8BcUsEQCAGIA9HDQEMBwsgCEEQdiIJQf8BcUEPTQ0BIAshBwwDCyAGMQAAISQgBCAFQQhqIgc6AEAgBCAGQQFqIgY2AjggBCAkIAWthiAjhCIjNwMwIAchBQwBCwsgC0EfcSENIAhB//8DcSEKQn8gCSALakE/ca2GQn+FISUDQCAjICWDpyANdiAKaiEIQSAhB0Go98gAIQkCQAJAAkACQCAQQQFrDgMAAQIDC0G0CiEHIB0hCQwCC0G0CiEHIBshCQwBC0HQBCEHIBchCQsgByAITQ0DIAkgCEECdGooAQAiCEEYdiIHIAtqQf8BcSAFQf8BcUsEQCAGIA9GDQUgBjEAACEkIAQgBUEIaiIHOgBAIAQgBkEBaiIGNgI4IAQgJCAFrYYgI4QiIzcDMCAHIQUMAQsLIAQgBCgCZCALajYCZCAFIAtrIQUgCEEQdiEJICMgC62IISMLIAQgBSAHazoAQCAEICMgB62INwMwIAlBwABxRQRAIAQgCUEPcTYCYCAEIAhB//8DcTYCXEEWIQUMHAsgBEEWNgKIASAEQefQwAA2AoQBDBwLIAggCkHs+cgAEIwHAAsgCCAHQez5yAAQjAcAC0EAIQhBFSEGDBoLQQshBSAELQADIgtFDRcCQCAELQBAIgpBH0sNAEEAIQhBECEGIAQoAjgiDSAEKAI8IglGDRogBCANQQFqIgc2AjggBCAKrSImQgh8IiM8AEAgBCAEKQMwIA0xAAAgJoaEIiQ3AzAgCkEXSw0AIAcgCUYNGiAEIA1BAmoiBzYCOCAEICZCEHwiJTwAQCAEIA0xAAEgI4YgJIQiJDcDMCAKQQ9LDQAgByAJRg0aIAQgDUEDaiIHNgI4IAQgJkIYfCIjPABAIAQgDTEAAiAlhiAkhCIkNwMwIApBB0sNACAHIAlGDRogBCANQQRqNgI4IAQgCkEgcjoAQCAEIA0xAAMgI4YgJIQ3AzALIAQgBCgCUCIHIAQoAlRqNgJUIAQoAnghBgJ/AkACQCALQQRxBEAgBkUEQCAEIAQoAnwgBCgCSCAHEN8CNgJ8IAQpAzAhIwwCCyAEIAQoAoABIAQoAkggBxCpASIGNgJ8IAQgBjYCgAEgBCgCeCEGCyAEKQMwISMgBg0BCyAjpyIGQRh0IAZBgP4DcUEIdHIgBkEIdkGA/gNxIAZBGHZycgwBCyAjpwshBiAEIAQoAkwgBCgCUGs2AnQCQCAELQADQQRxBEAgBiAEKAJ8Rw0BCyAEQQA6AEAgBEIANwMwDBgLIARBFTYCiAEgBEHAz8AANgKEAQwYCyAELQABIgZBAXEEQCAEIAQtAEAiBUH4AXE6AEAgBCAEKQMwIAVBB3GtiDcDMEEQIQUMFwsgBCkDMCEjIAQtAEAiBUECTQRAIAQoAjgiByAEKAI8RgRAQQAhCEENIQYMGgsgBCAHQQFqNgI4IAcxAAAgBa2GICOEISMgBUEIciEFCyAEIAVBAWs6AEAgBCAjQgGIIiQ3AzAgBCAjp0EBcSAGcjoAAQJAAkACQAJAICSnQQNxQQFrDgMBAgMACyAEIAVBA2s6AEAgBCAjQgOINwMwQQ4hBQwZC0EAIQggBEEAOgCgASAEQQU2ApwBIARBADoAmAEgBEEJNgKUASAEIAVBA2s6AEAgBCAjQgOINwMwQREhBUERIQYgBC0ABEEGRw0YDBoLIAQgBUEDazoAQCAEICNCA4g3AzBBGCEFDBcLIARBEzYCiAEgBEG40MAANgKEAUF9IQggBCAFQQNrOgBAIAQgI0IDiDcDMEEeIQYMGAsCQCAEKAJ4IgpBgARxBEACQCAELQBAIgtBD0sNAEEAIQhBCCEGIAQoAjgiCSAEKAI8IgdGDRogBCAJQQFqIgU2AjggBCALrSIkQgh8IiM8AEAgBCAEKQMwIAkxAAAgJIaEIiQ3AzAgC0EHSw0AIAUgB0YNGiAEIAlBAmo2AjggBCALQRByOgBAIAQgCTEAASAjhiAkhDcDMAsgBC0AA0EEcQRAIAQvAXwgBCgCMEcNAgsgBEEAOgBAIARCADcDMAsgBCgCjAEiBQRAIAUgCkEJdkEBcTYCLCAEKAKMAUEBNgIwIAQoAnghCgtBDCEFIAQtAANBBHFFIApFcg0WIARCADcCfAwWCyAEQRQ2AogBIARB88/AADYChAEMFgsCQCAEKAJ4Ig9BgCBxBEBBByEGIAQoAnANAUEAIQgMGAtBCCEFIAQoAowBIgZFDRUgBkEANgIkDBULAkAgBCgCPCIIIAQoAjgiCUYEQEEAIQcMAQsgCCAJayEHQQAhBQNAIAUgCWotAAAEQCAJIAVBAWoiBWogCEcNAQwCCwsgBUEBaiEHCwJAIAQoAowBIgVFDQAgBSgCJCIIRQ0AIAUoAigiBSAEKAJYIgtPBEAgBSALayIFIAcgBSAHSRsiBQRAIAggC2ogCSAF/AoAAAsgBCAEKAJYIAVqNgJYIAQoAnghDwwBC0GA+8gAQRJBlPvIABCrBwALAkAgD0GABHFFDQAgBC0AA0EEcUUNACAEIAQoAnwgCSAHEKkBNgJ8C0EBIQoCQCAHRQ0AIAcgCWpBAWsiBUUNACAFLQAAQQBHIQoLIAQgBCgCPCIIIAQoAjggB2oiBSAFIAhLGyIHNgI4QQghBSAKRSAHIAhHcg0UQQAhCAwWCwJAAkAgBCgCeCIPQYAQcQRAQQYhBiAEKAJwDQFBACEIDBgLIAQoAowBIgVFDQEgBUEANgIcDAELAkAgBCgCPCIIIAQoAjgiCUYEQEEAIQcMAQsgCCAJayEHQQAhBQNAIAUgCWotAAAEQCAJIAVBAWoiBWogCEcNAQwCCwsgBUEBaiEHCwJAIAQoAowBIgVFDQAgBSgCHCIIRQ0AIAUoAiAiBSAEKAJYIgtPBEAgBSALayIFIAcgBSAHSRsiBQRAIAggC2ogCSAF/AoAAAsgBCAEKAJYIAVqNgJYIAQoAnghDwwBC0Hc+sgAQRJB8PrIABCrBwALAkAgD0GABHFFDQAgBC0AA0EEcUUNACAEIAQoAnwgCSAHEKkBNgJ8C0EBIQoCQCAHRQ0AIAcgCWpBAWsiBUUNACAFLQAAQQBHIQoLIAQgBCgCPCIIIAQoAjggB2oiBSAFIAhLGyIFNgI4IApFIAUgCEdyDQBBACEIDBYLIARBADYCWEEHIQUMEwsCQCAEKAJ4IghBgAhxRQ0AIAQoAjwgBCgCOCIHayIGIAQoAlgiBSAFIAZLGyIKBEACQCAEKAKMASIJRQ0AIAkoAhAiBkUNACAKIAkoAhgiCyAJKAIUIAVrIghrIgVBACAFIAtNGyIFIAUgCksbIgUEQCAGIAsgCCAIIAtLG2ogByAF/AoAAAsgBCgCeCEICwJAIAhBgARxRQ0AIAQtAANBBHFFDQAgBCgCPCAEKAI4IgZrIgUgCk8EQCAEIAQoAnwgBiAKEKkBNgJ8DAELQQAgCiAFQcz6yAAQ6gcACyAEIAQoAnAgCms2AnAgBCAEKAJYIAprIgU2AlggBCAEKAI8IgcgBCgCOCAKaiIGIAYgB0sbNgI4CyAFRQ0AQQAhCEEFIQYMFQsgBEEANgJYQQYhBQwSCwJAAkAgBCgCeCILQYAIcQRAIAQpAzAhIwJAIAQtAEAiCUEPSw0AQQAhCEEEIQYgBCgCOCIKIAQoAjwiB0YNFyAEIApBAWoiBTYCOCAEIAmtIiVCCHwiJDwAQCAEIAoxAAAgJYYgI4QiIzcDMCAJQQdLDQAgBSAHRg0XIAQgCkECajYCOCAEIAlBEHI6AEAgBCAKMQABICSGICOEIiM3AzALIAQgI6ciBjYCWCAEKAKMASIFBH8gBSAGNgIUIAQoAngFIAsLQYAEcUUNAiAELQADQQRxDQEMAgtBBSEFIAQoAowBIgZFDRMgBkEANgIQDBMLIAwgBCkDMD0BGCAEIAQoAnwgDEEYakECEKkBNgJ8CyAEQQA6AEAgBEIANwMwQQUhBQwRC0ENIQUgBC0AAyIHRQ0QIAQpAzAhIwJAAkAgBC0AQCIIQQ9LDQAgBCgCOCILIAQoAjwiBkYNASAEIAtBAWoiBTYCOCAEIAitIiVCCHwiJDwAQCAEIAsxAAAgJYYgI4QiIzcDMCAIQQdLDQAgBSAGRg0BIAQgC0ECajYCOCAEIAhBEHI6AEAgBCALMQABICSGICOEIiM3AzALAkAgB0ECcUEAICNCn5YCURtFBEAgBCgCjAEiBQR/IAVBfzYCMCAELQADBSAHC0EBcQRAIAQpAzAiI0IIhkKA/gODICNCCIh8Qh+CUA0CCyAEQRc2AogBIARBks/AADYChAEMFAsgBC0AAkUEQCAEQQ86AAILIAxBn5YCOwAYIARBACAMQRhqQQIQqQE2AnwgBEEAOgBAIARCADcDMEEBIQUMEgsgI0IPg0IIUQRAIAQgI0IEiCIkNwMwIAQgBC0AQEEEazoAQCAkp0EPcSIGQQhqIQcgBC0AAiIFBH8gBQUgBCAHOgACIAcLIAdJIAZBB0tyRQRAIARCgICAgBA3A3ggBEEAOgBAIARCADcDMCAEQQEgB3Q2ApABQQxBGyAjQoDAAINQGyEFDBMLIARBFDYCiAEgBEGH0MAANgKEAQwTCyAEQRs2AogBIARB/dDAADYChAEMEgtBACEGQQAhCAwSCyAEQR02AogBIARBm9DAADYChAEMEAtBAiEIIAQtAAFBAnFFBEBBHCEGDBELIARBATYCfEEMIQUMDgsgBCkDMCEjAkAgBC0AQCILQR9LDQBBACEIQRshBiAEKAI4IgkgBCgCPCIHRg0QIAQgCUEBaiIFNgI4IAQgC60iJkIIfCIkPABAIAQgCTEAACAmhiAjhCIjNwMwIAtBF0sNACAFIAdGDRAgBCAJQQJqIgU2AjggBCAmQhB8IiU8AEAgBCAJMQABICSGICOEIiM3AzAgC0EPSw0AIAUgB0YNECAEIAlBA2oiBTYCOCAEICZCGHwiJDwAQCAEIAkxAAIgJYYgI4QiIzcDMCALQQdLDQAgBSAHRg0QIAQgCUEEajYCOCAEIAtBIHI6AEAgBCAJMQADICSGICOEIiM3AzALIARBADoAQCAEQgA3AzAgBCAjpyIFQRh0IAVBgP4DcUEIdHIgBUEIdkGA/gNxIAVBGHZycjYCfEEcIQUMDQsgBCkDMCEjAkAgBC0AQCIFQQ1LDQBBACEIQRghBiAEKAI4IgkgBCgCPCILRg0PIAQgCUEBaiIHNgI4IAQgBa0iJEIIfCIlPABAIAQgCTEAACAkhiAjhCIjNwMwIAVBBUsEQCAlpyEFDAELIAcgC0YNDyAEIAlBAmo2AjggBCAFQRByIgU6AEAgBCAJMQABICWGICOEIiM3AzALIAQgBUEOazoAQCAEICNCDog3AzAgBCAjpyIHQR9xIgZBgQJqNgIcIAQgB0EFdkEfcSIFQQFqNgIgIAQgB0EKdkEPcUEEajYCGCAGQR1LIAVBHUtyRQRAIARBADYCJEEZIQUMDQsgBEEkNgKIASAEQazOwAA2AoQBDA0LA0AgBCgCTCIGIAQoAlAiB0YEQEEAIQhBFyEGDA8LIAYgB2shCgJAIAcgBCgCXCIGTwRAIBMgBiAKIAQoAlgiBiAGIApLGyIGEOwCDAELIAYgB2siCSAEKAIQTQRAIAQoAgwiBkFAaiIHQUFPDREgEyAZIAdBACAGIAdPGyAJIAQoAhQiBmsiC2sgBiAJayAGIAlJIgYbIgggCCAKIAQoAlgiByALIAkgBhsiBiAGIAdLGyIGIAYgCksbIgZqEJQFDAELIAQtAAFBBHEEQEEeIQYgBEEeNgKIASAEQdXPwAA2AoQBQX0hCAwQCyAMQQA2AiggDEEBNgIcIAxBxPnIADYCGCAMQgQ3AiAgDEEYakGk+8gAEI0IAAsgBCAEKAJYIgcgBms2AlggBiAHRw0ACwwLCwJAIAQoAmAiCUUEQCAEKAJYIQUMAQsgBCkDMCEjAkAgBC0AQCIGIAlPBEAgBiEIDAELIAQoAjghBSAEKAI8IQsDQCAFIAtGBEBBACEIQRQhBgwQCyAEIAVBAWoiBzYCOCAEIAZBCGoiCDoAQCAEIAUxAAAgBq2GICOEIiM3AzAgByEFIAkgCCIGQf8BcUsNAAsLIAQgCCAJazoAQCAEICMgCa2INwMwIAQgBCgCZCAJajYCZCAEIAQoAlggI0J/IAlBP3GthkJ/hYOnaiIFNgJYCyAEIAU2AmhBFSEFDAoLIAQoAlAiByAEKAJMIgZGBEBBACEIQRMhBgwMCyAGIAdLBEAgBCgCWCEGIAQgB0EBajYCUCAEKAJIIAdqIAY6AAAMCgsgByAGQbz/yAAQjAcACyAEQRI6AAACQCAEKAI8IgggBCgCOCILa0EPSQ0AIAQoAkwgBCgCUGtBgwJNDQAgBBCrASAELQAAIgVBEkcNCSAEKAI8IQggBCgCOCELCyAMQQhqIBNBCGooAgA2AgAgBEEANgJQIBMpAgAhJCAEQgE3A0ggDCAkNwMAIAwgFCgAADYCECAMIBRBA2ooAAA2ABNBqOfIACEJQYAEIR4CQAJAAkACQCAELQCYAUEBaw4DAAECAwtBtAohHiAdIQkMAgtBtAohHiAbIQkMAQtB0AQhHiAXIQkLQaj3yAAhD0EgIQcCQAJAAkACQCAELQCgAUEBaw4DAAECAwtBtAohByAdIQ8MAgtBtAohByAbIQ8MAQtB0AQhByAXIQ8LIAQtAEAhECAEKQMwISMCQAJAA0BBEiEKA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAKQf8BcUETaw4FBAEIAgsACyAIIAtrQQ9PBEAgDCgCBCAMKAIIa0GDAksNDAsgBEEANgJkIAshBiAQIQUgHiAjQn8gBDUClAGGQn+FIiaDpyIKSw0CDBgLIAQoAmAiCkUEQCAEKAJYIQUMBgsgCyEFIAogECIGQf8BcUsNAyAFIQ0MBAtBFyEKIAQoAmAiDUUNEyALIQUgDSAQIgZB/wFxSw0GIAUhEgwHCwNAIAkgCkECdGoiDS0AAyIKIAVB/wFxTQ0SIAYgCEcEQCAFrSElIAYxAAAhJCAGQQFqIQYgBUEIaiEFIB4gJCAlhiAjhCIjICaDpyIKTQ0XDAELC0ESIQYgBEESOgAAIBMgDCkDADcCACAEIAg2AjwgBCAINgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCACAEIBAgCEEDdGogC0EDdGs6AEBBACEIDCALIAwoAggiBiAMKAIEIgVHBEAgBSAGTQ0JIAwoAgAgBmogBCgCWDoAACAMIAZBAWo2AggMEwtBEyEGIARBEzoAACATIAwpAwA3AgAgBCAQOgBAIAQgCDYCPCAEIAs2AjggBCAjNwMwIBQgDCgCEDYAACAUQQNqIAwoABM2AAAgE0EIaiAMQQhqKAIANgIAQQAhCAwfCwNAIAUgCEYNCSAFMQAAIAathiAjhCEjIAVBAWoiDSEFIAogBkEIaiIGQf8BcUsNAAsLIAQgBCgCZCAKajYCZCAEIAQoAlggI0J/IApBP3GthkJ/hYOnaiIFNgJYIAYgCmshECAjIAqtiCEjIA0hCwsgBCAFNgJoQRUhCgwOCyALIQYgECEFIAcgI0J/IAQ1ApwBhkJ/hSImg6ciCk0NCwNAIA8gCkECdGoiDS0AAyIKIAVB/wFxTQ0LIAYgCEcEQCAFrSElIAYxAAAhJCAGQQFqIQYgBUEIaiEFIAcgJCAlhiAjhCIjICaDpyIKTQ0NDAELC0EVIQYgBEEVOgAAIBMgDCkDADcCACAEIAg2AjwgBCAINgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCACAEIBAgCEEDdGogC0EDdGs6AEBBACEIDBsLA0AgBSAIRg0GIAUxAAAgBq2GICOEISMgBUEBaiISIQUgDSAGQQhqIgZB/wFxSw0ACwsgBCAEKAJkIA1qNgJkIAQgBCgCXCAjQn8gDUE/ca2GQn+Fg6dqNgJcIAYgDWshECAjIA2tiCEjIBIhCwwLCyAMKAIEIgUgDCgCCCIGRg0EIAUgBmshFiAGIAQoAlwiBU8EQCAMIAUgFiAEKAJYIgUgBSAWSxsiBRDsAgwHCyAFIAZrIhIgBCgCEE0EQCAEKAIMIgVBQGoiBkFBTw0aIAwgGSAGQQAgBSAGTxsgEiAEKAIUIgVrIg1rIAUgEmsgBSASSSIFGyIKIAogFiAEKAJYIgYgDSASIAUbIgUgBSAGSxsiBSAFIBZLGyIFahCUBQwHCyAELQABQQRxRQ0FIBMgDCkDADcCACAEIBA6AEAgBCAINgI8IAQgCzYCOCAEICM3AzAgFCAMKAIQNgAAQR4hBiAEQR42AogBIARB1c/AADYChAEgBEEeOgAAIBRBA2ogDCgAEzYAACATQQhqIAxBCGooAgA2AgBBfSEIDBgLIARBEjoAACATIAwpAwA3AgAgBCAQOgBAIAQgCDYCPCAEIAs2AjggBCAjNwMwIBQgDCgCEDYAACAUQQNqIAwoABM2AAAgE0EIaiAMQQhqKAIANgIAIAQQqwEgBC0AACEFDBULIAYgBUG8/8gAEIwHAAtBFCEGIARBFDoAACATIAwpAwA3AgAgBCAINgI8IAQgCDYCOCAEICM3AzAgFCAMKAIQNgAAIBRBA2ogDCgAEzYAACATQQhqIAxBCGooAgA2AgAgBCAQIAhBA3RqIAtBA3RrOgBAQQAhCAwVC0EWIQYgBEEWOgAAIBMgDCkDADcCACAEIAg2AjwgBCAINgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCACAEIBAgCEEDdGogC0EDdGs6AEBBACEIDBQLQRchBiAEQRc6AAAgEyAMKQMANwIAIAQgEDoAQCAEIAg2AjwgBCALNgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCAEEAIQgMEwsgDEEANgIoIAxBATYCHCAMQcT5yAA2AhggDEIENwIgIAxBGGpBvPrIABCNCAALIAQgBCgCWCIGIAVrNgJYQRJBFyAFIAZGGyEKDAMLIA0vAQAhEgJAAkAgDS0AAiIcQQ9LBEAgCiENDAELICNCfyAKIBxqQT9xrYZCf4UiJoOnIAp2IBJqIg0gB08NASAKQR9xIRYCQANAIA8gDUECdGoiGC0AAyINIApqQf8BcSAFQf8BcU0NASAGIAhHBEAgBa0hJSAGMQAAIAZBAWohBiAFQQhqIQUgJYYgI4QiIyAmg6cgFnYgEmoiDSAHTw0EDAELC0EVIQYgBEEVOgAAIBMgDCkDADcCACAEIAg2AjwgBCAINgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCACAEIBAgCEEDdGogC0EDdGs6AEBBACEIDBMLIBgtAAIhHCAYLwEAIRIgBCAEKAJkIApqNgJkIAUgCmshBSAjIAqtiCEjCyAFIA1rIRAgIyANrYghIyAcQcAAcUUEQCAEIBxBD3E2AmAgBCASQf//A3E2AlxBFiEKIAYhCwwECyATIAwpAwA3AgAgBCAQOgBAIAQgCDYCPCAEIAY2AjggBCAjNwMwIBQgDCgCEDYAACAEQRY2AogBIARB59DAADYChAFBHiEGIARBHjoAACAUQQNqIAwoABM2AAAgE0EIaiAMQQhqKAIANgIAQX0hCAwRCyANIAdBrPrIABCMBwALIAogB0Gc+sgAEIwHAAsgDS8BACESAkAgDS0AAiIcRQRAQQAhDSAGIQtBACEcDAELQQAhDSAcQQ9LBEAgBiELDAELAkAgHiAjQn8gCiAcakE/ca2GQn+FIiaDp0H//wNxIApBD3EiGHYgEmpB//8DcSINTQ0AAkADQCAJIA1BAnRqIg0tAAMiFiAKakH/AXEgBUH/AXFNDQEgBiAIRwRAIAWtISUgBjEAACEkIAZBAWohBiAFQQhqIQUgHiAkICWGICOEIiMgJoOnQf//A3EgGHYgEmpB//8DcSINTQ0DDAELC0ESIQYgBEESOgAAIBMgDCkDADcCACAEIAg2AjwgBCAINgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCACAEIBAgCEEDdGogC0EDdGs6AEBBACEIDBELIAUgCmshBSAjIAqtiCEjIA0tAAIhHCANLwEAIRIgCiENIAYhCyAWIQoMAQsgDSAeQYz6yAAQjAcACyAEIBJB//8DcTYCWCAEIA0gCkH/AXFqNgJkIAUgCmshECAjIAqtiCEjQRMhCiAcRQ0AIBxBIHENAiAcQcAAcUUEQCAEIBxBD3E2AmBBFCEKDAELCwtBHiEGIARBHjoAACATIAwpAwA3AgAgBCAQOgBAIAQgCDYCPCAEIAs2AjggBCAjNwMwIBQgDCgCEDYAACAEQRw2AogBIARBy9DAADYChAEgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCAEF9IQgMDAtBDCEFIARBDDoAACAEQX82AmQgEyAMKQMANwIAIAQgEDoAQCAEIAg2AjwgBCALNgI4IAQgIzcDMCAUIAwoAhA2AAAgFEEDaiAMKAATNgAAIBNBCGogDEEIaigCADYCAAwJCyAKIB5B/PnIABCMBwALIAQgBC0AQCIHQfgBcToAQCAEIAQpAzAgB0EHca2IIiM3AzACQCAHQR9LDQBBACEIQQ4hBiAEKAI4IgkgBCgCPCILRg0KIAQgCUEBaiIFNgI4IAQgB61CGIMiJkIIfCIkPABAIAQgCTEAACAmhiAjhCIjNwMwIAdBGHEiB0EYRg0AIAUgC0YNCiAEIAlBAmoiBTYCOCAEICZCEHwiJTwAQCAEIAkxAAEgJIYgI4QiIzcDMCAHQQ9LDQAgBSALRg0KIAQgCUEDaiIFNgI4IAQgJkIYfCIkPABAIAQgCTEAAiAlhiAjhCIjNwMwIAcNACAFIAtGDQogBEEgOgBAIAQgCUEEajYCOCAEIAkxAAMgJIYgI4QiIzcDMAsgI0IQiCAjhUL//wODQv//A1EEQEEAIQggBEEAOgBAIARCADcDMCAEICOnQf//A3E2AlhBDyEFIAQtAARBBkcNCEEOIQYMCgsgBEEdNgKIASAEQdDOwAA2AoQBDAgLQQ0hBSAELQAEQQVrQf8BcUECTw0GQQAhCEEMIQYMCAtBHSEGIAQtAAMiB0UNByAEKAJ4RQ0HAkAgBC0AQCIJQR9LDQBBACEIQQshBiAEKAI4IhcgBCgCPCILRg0IIAQgF0EBaiIFNgI4IAQgCa0iJkIIfCIjPABAIAQgBCkDMCAXMQAAICaGhCIkNwMwIAlBF0sNACAFIAtGDQggBCAXQQJqIgU2AjggBCAmQhB8IiU8AEAgBCAXMQABICOGICSEIiQ3AzAgCUEPSw0AIAUgC0YNCCAEIBdBA2oiBTYCOCAEICZCGHwiIzwAQCAEIBcxAAIgJYYgJIQiJDcDMCAJQQdLDQAgBSALRg0IIAQgF0EEajYCOCAEIAlBIHI6AEAgBCAXMQADICOGICSENwMwCwJAIAdBBHEEQCAEKAJUIAQoAjBHDQELIARBADoAQCAEQgA3AzBBHSEGQQEhCAwICyAEQRc2AogBIARBqc/AADYChAEMBgsCQCAELQBAIgtBD0sNAEEAIQhBAyEGIAQoAjgiCSAEKAI8IgdGDQcgBCAJQQFqIgU2AjggBCALrSIkQgh8IiM8AEAgBCAEKQMwIAkxAAAgJIaEIiQ3AzAgC0EHSw0AIAUgB0YNByAEIAlBAmo2AjggBCALQRByOgBAIAQgCTEAASAjhiAkhDcDMAsgBCgCjAEiBQRAIAUgBC0AMDYCCCAEKAKMASAEKQMwQgiIPgIMCwJAIAQtAHlBAnFFDQAgBC0AA0EEcUUNACAMIAQpAzA9ARggBCAEKAJ8IAxBGGpBAhCpATYCfAsgBEEAOgBAIARCADcDMEEEIQUMBAsCQCAELQBAIgtBH0sNAEEAIQhBAiEGIAQoAjgiCSAEKAI8IgdGDQYgBCAJQQFqIgU2AjggBCALrSImQgh8IiM8AEAgBCAEKQMwIAkxAAAgJoaEIiQ3AzAgC0EXSw0AIAUgB0YNBiAEIAlBAmoiBTYCOCAEICZCEHwiJTwAQCAEIAkxAAEgI4YgJIQiJDcDMCALQQ9LDQAgBSAHRg0GIAQgCUEDaiIFNgI4IAQgJkIYfCIjPABAIAQgCTEAAiAlhiAkhCIkNwMwIAtBB0sNACAFIAdGDQYgBCAJQQRqNgI4IAQgC0EgcjoAQCAEIAkxAAMgI4YgJIQ3AzALIAQoAowBIgUEQCAFIAQpAzA+AgQLAkAgBC0AeUECcUUNACAELQADQQRxRQ0AIAwgBCkDMD4CGCAEIAQoAnwgDEEYakEEEKkBNgJ8CyAEQQA6AEAgBEIANwMwQQMhBQwDCyAEKQMwISMCQCAELQBAIgtBD0sNAEEAIQggBCgCOCIJIAQoAjwiB0YEQEEBIQYMBgtBASEGIAQgCUEBaiIFNgI4IAQgC60iJUIIfCIkPABAIAQgCTEAACAlhiAjhCIjNwMwIAtBB0sNACAFIAdGDQUgBCAJQQJqNgI4IAQgC0EQcjoAQCAEIAkxAAEgJIYgI4QiIzcDMAsgBCAjpyIGNgJ4AkACQCAGQf8BcUEIRgRAIAZBgMADcQ0BIAQoAowBIgUEfyAFIAZBCHZBAXE2AgAgBCgCeAUgBgtBgARxRQ0CIAQtAANBBHFFDQIgBCgCfCEFIAwgBCkDMD0AGCAEIAUgDEEYakECEKkBNgJ8DAILIARBGzYCiAEgBEH90MAANgKEAQwFCyAEQRk2AogBIARBtYDAADYChAEMBAsgBEEAOgBAIARCADcDMEECIQUMAgtBDCEFIAQoAlgiCkUNASAEKAI4IQ8gBCgCPCEHIAQoAlAhCCAEKAJIIQsgBCgCTCEJAkADQCAHIA9rIgcgBCgCTCAIayIGIAogBiAKSRsiBiAGIAdLGyINRQRAQQAhCEEPIQYMBgsgCCAJTQRAIA0gCSAIayIGSw0CIA0EQCAIIAtqIA8gDfwKAAALIAQgCCANaiIINgJQIAQgBCgCWCANayIKNgJYIAQgBCgCPCIHIAQoAjggDWoiBiAGIAdLGyIPNgI4IApFDQQMAQsLIAggCSAJQdz/yAAQ6gcAC0EAIA0gBkHM/8gAEOoHAAsCQCAEKAIkIgUgBCgCGCILTw0AQRMgBSAFQRNNGyENIAQoAjghCiAEKQMwISQgBC0AQCEGIAQoAjwhCQJAA0ACQCAGQf8BcUECSwRAICQhIyAGIQgMAQsgCSAKRgRAQQAhCEEZIQYMBwsgBCAKQQFqIgc2AjggBCAGQQhyIgg6AEAgBCAKMQAAIAathiAkhCIjNwMwIAchCgsgBSANRg0BIAQgCEEDayIGOgBAIAQgI0IDiCIkNwMwIAQgBUEBaiIHNgIkIBogBUGD58gAai0AAEEBdGogI6dBB3E7AQAgByIFIAtHDQALIAshBQwBCyANQRNBtPvIABCMBwALIAVBEk0EQAJAIAVBC00EQCAFQYPnyABqIQYgBUETIAVrIgtBGHEiB2ohBSAHIQgDQCAaIAb9XQAAIiv9iQH9qQEiLP0bAEEBdGpBADsBACAaICz9GwFBAXRqQQA7AQAgGiAs/RsCQQF0akEAOwEAIBogLP0bA0EBdGpBADsBACAaICsgLP0NBAUGBwAAAAAAAAAAAAAAAP2JAf2pASIr/RsAQQF0akEAOwEAIBogK/0bAUEBdGpBADsBACAaICv9GwJBAXRqQQA7AQAgGiAr/RsDQQF0akEAOwEAIAZBCGohBiAIQQhrIggNAAsgByALRg0BCwNAIBogBUGD58gAai0AAEEBdGpBADsBACAFQQFqIgVBE0cNAAsLIARBEzYCJAsgDEEYakEAIBpBEyAdQbQKQQcgDhCtASAMKAIYRQRAIAwoAhwhBiAMKAIgIQUgBEEBOgCYASAEIAU2AiggBCAGNgKUASAEQQA2AiRBGiEFDAELCyAEQRk2AogBIARBnIDAADYChAELQX0hCEEeIQYLIAQgBjoAACARKAIgIQkgESARKAI8Ig4oAjgiHTYCICARIA4oAjwgHWs2AiQgESAOKAJMIgUgDigCUCIGazYCMCARIAYgDigCSCIPaiIHNgIsIBEgESgCKCAdIAlrajYCKCAOIA4oAnQgBiAFa2oiFiAOKAJUaiIFNgJUIBEgBTYCNCARIA4oAnwiFzYCUAJAAkACQAJAAkACQAJAAkACQAJAAkAgDkEMaigCACISQUBqQUFJBEACQCASQcAASw0AIBZFDQwgDi0AACIFQR5LDQBBASAFdCIFQYCMgIAEcQ0MIAVBgJAEcUUNACAOLQAEQQRGDQwLIAYgFkkNASAOLQADQQRxIQYgDigCeCELIBJBQGoiBUEAIAUgEk0bIhggFksEQCAWIBYgGCAOKAIUIhBrIhsgFiAbSRsiGWshDSAPIBlqIQogBkUEQCAQIBJLDQQgEiAQayIFIBlJBEBBACAZIAVBwP3IABDqBwALIA4oAgghBSAZBEAgBSAQaiAPIBn8CgAACyAWIBtNDQogDUUNDCAFIAogDfwKAAAMDAsgECASSw0EIBkgEiAQayIFSw0FIA4oAggiBiAQaiEFIAtFDQcMCAsgDyAWIBhrIgVqIRsCQCAGBEAgCw0BIBcgDyAFEN8CIQUgGARAIA4oAgggGyAY/AoAAAsgDiAFIBsgGBDfAjYCfAwHCyAYRQ0GIA4oAgggGyAY/AoAAAwGCyAOKAKAASAPIAUQqQEhBiAOKAIIIA4gBiAbIBgQqQE2AoABIBhFDQUgGyAY/AoAAAwFCwwLC0EAIBYgBkGkgMkAEOoHAAsgECASIBJB0P3IABDqBwALIBAgEiASQfD9yAAQ6gcAC0EAIBkgBUHg/cgAEOoHAAsgDiAYNgIQIA5BADYCFAwFCyAZBEAgBSAPIBn8CgAACyAOIBcgDyAZEN8CIgU2AnwgFiAbTQ0BIA0EQCAGIAogDfwKAAALIA4gBSAKIA0Q3wI2AnwMAwsgDiAOKAKAASAPIBkQqQE2AoABIBkEQCAFIA8gGfwKAAALIBYgG0sNAQsgDiAQIBlqIgVBACAFIBhHGzYCFCAYIA4oAhAiBU0NAiAOIAUgGWo2AhAMAgsgDiAOKAKAASAKIA0QqQE2AoABIA1FDQAgBiAKIA38CgAACyAOIBg2AhAgDiANNgIUCyAOKAKEASIGBEACQCAOKAKIASIFBEAgBSAGakEBay0AAEUNAQtB7P/IAEElQZSAyQAQ6wcACyARIAY2AjgLIBEgDi0AAEEMa0H/AXEiBUEGSQR/IAVBAnQoAriESQVBAAsgDi0AQCAOLQABQQZ0QcAAcXJyNgJMIBEgESkDECAdIB9rrXwiIzcDECARIBEpAxggByACa618IiQ3AxgCQAJAAkACQAJAAkACQCAIRQRAIBZFIAkgHUZxICFB/wFxQQRGcg0BCwJAAkAgCEEEag4HBQUFAQMABAILQQIhCAwCCyAMQQA2AiggDEEBNgIcIAxBwObIADYCGCAMQgQ3AiAgDEEYakHI5sgAEI0IAAtBASEICyARIBEpAwAgIyAofXw3AwAgESARKQMIICQgJ318NwMIDAMLIBEgESkDACAjICh9fDcDACARIBEpAwggJCAnfXw3AwgMAQsgESARKQMAICMgKH18NwMAIBEgESkDCCAkICd9fDcDCAJAIAhBAmsOAgECAAsgESgCOCIGBH8gDEEYaiAGAkAgBi0AAEUEQEEAIQcMAQsgBkEBaiEGQQAhBwNAIAYgB2ogB0EBaiEHLQAADQALCyAHEPsCIAwoAiAhBkEAIAwoAhwgDCgCGBsFQQALIQUgFSAGNgIIIBUgBTYCBCAVQQA2AgAMAgsgFSAXNgIEIBVBATYCAAwBCyAVQQI2AgAgFSAIOgAECyAMQTBqJAAMAQtB5PzIAEHKAEGw/cgAEOsHAAsgFS0ABCEHIBUoAgAgASABKAIMIgkgASgCCCABKQNIICp9p2oiBSAFIAlLGyILNgIIQQJHBEACQEEWEHEiAUUNACABQci2xwD9AAAA/QsAACABQQ5qQda2xwApAAA3AABBDBBxIgJFDQAgAkEWNgIIIAIgATYCBCACQRY2AgBBDBBxIgFFDQAgAUEUOgAIIAFBuJ/GADYCBCABIAI2AgAgACABrUIghkIDhDcCAAwECwALIAEpA1AgKX2nIQUCQAJAAkAgB0EBaw4CAQIACyAgIANFcg0BIAVFDQIMAQsgICADRXINACAFRQ0BCwsgAEEEOgAAIAAgBTYCBAwBCwJAAkACQCABKAIoIgsgASgCLCIJRiABKAIkIgggA01xRQRAIAEoAiAhByAJIAtLDQIgCCABKAIwIgZrIgUEQCAGIAdqQQAgBfwLAAsgFSABQThqIAcgCBCmAyAVLQAAQQRHDQEgCCAVKAIEIglPBEAgASAINgIwIAEgCTYCLEEAIQsMAwtBtJvHAEE2QeybxwAQ6wcACyABQgA3AyggACABQThqIAIgAxCmAwwDCyAVKAIEIQYgFSgCACEFIBUxAAAgASAINgIwIAFCADcDKEEAIQlBACELQgRSDQELIAcgC2ohBgJAIAkgC2siBSADIAMgBUsbIgNBAUYEQCACIAYtAAA6AAAMAQsgA0UNACACIAYgA/wKAAALIAAgAzYCBCAAQQQ6AAAgASAJIAMgC2oiACAAIAlLGzYCKAwBCyAAIAY2AgQgACAFNgIACyAVQRBqJAAL5AUBBX8gASgCACICQf///wNxIQMgAkGAgICAeHEhBiABKAIEIQQCQCACQYCAgPwHcSIFQYCAgPwHRgRAIANBDXYgBkEQdnJBgARBACADG3JBgPgBciEGDAELIAZBEHYhBiAFQYCAgLgETQRAIAVBgICAxANPBEAgAkEMdiACQf/fAHFBAEdxIAVBDXYgA0ENdmpBgIABaiAGcmohBgwCCyAFQYCAgJgDSQ0BIANBgICABHIiAkH+ACAFQRd2IgNrdiEFIAJBHSADayIDdkEBcQR/IAVBAyADdEEBayACcUEAR2oFIAULIAZyIQYMAQsgBkGA+AFyIQYLIAEoAgghASAEQf///wNxIQMgBEGAgICAeHEhBQJAIARBgICA/AdxIgJBgICA/AdHBEAgBUEQdiEFIAJBgICAuARNBEAgAkGAgIDEA08EQCAEQQx2IARB/98AcUEAR3EgAkENdiADQQ12akGAgAFqIAVyaiEFDAMLIAJBgICAmANJDQIgA0GAgIAEciIDQf4AIAJBF3YiAmt2IQQgA0EdIAJrIgJ2QQFxBH8gBEEDIAJ0QQFrIANxQQBHagUgBAsgBXIhBQwCCyAFQYD4AXIhBQwBCyADQQ12IAVBEHZyQYAEQQAgAxtyQYD4AXIhBQsgAUH///8DcSEDIAFBgICAgHhxIQQCQCABQYCAgPwHcSICQYCAgPwHRwRAIARBEHYhBCACQYCAgLgETQRAIAJBgICAxANPBEAgAUEMdiABQf/fAHFBAEdxIAJBDXYgA0ENdmpBgIABaiAEcmohBAwDCyACQYCAgJgDSQ0CIANBgICABHIiA0H+ACACQRd2IgJrdiEBIANBHSACayICdkEBcQR/IAFBAyACdEEBayADcUEAR2oFIAELIARyIQQMAgsgBEGA+AFyIQQMAQsgA0ENdiAEQRB2ckGABEEAIAMbckGA+AFyIQQLIAAgBDsBGiAAIAU7ARggACAGOwEWC9cFAwR+CH8BeyABKQMQIAEpAxggAhDyAyEFIAEoAghFBEAgASABQRBqEMABCyABKAIEIgwgBadxIQkgBUIZiCIIQv8Ag0KBgoSIkKDAgAF+IQcgASgCACEKAkACQCACLQAAIhBBC0cEQANAIAkgCmopAAAiBiAHhSIFQn+FIAVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBVBFBEADQCAQIAogBXqnQQN2IAlqIAxxQWhsaiIPQRhrLQAARg0EIAVCAX0gBYMiBVBFDQALCyAGQoCBgoSIkKDAgH+DIQUCfwJAIA1FBEAgBVANASAFeqdBA3YgCWogDHEhCwsgBSAGQgGGg0IAUg0FQQEMAQtBAAshDSAOQQhqIg4gCWogDHEhCQwACwALIAIoAAEhEANAIAkgCmopAAAiBiAHhSIFQn+FIAVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiBVBFBEADQCAKIAV6p0EDdiAJaiAMcUFobGoiD0EYay0AAEELRgRAIBAgD0EXaygAAEYNBAsgBUIBfSAFgyIFUEUNAAsLIAZCgIGChIiQoMCAf4MhBQJ/AkAgDUUEQCAFUA0BIAV6p0EDdiAJaiAMcSELCyAFIAZCAYaDQgBSDQRBAQwBC0EACyENIA5BCGoiDiAJaiAMcSEJDAALAAsgD0EQayIB/QADACERIA9BCGsgBDcDACABIAM3AwAgACAR/QsDCCAAQgE3AwAPCyAKIAtqLAAAIglBAE4EQCAKIAopAwBCgIGChIiQoMCAf4N6p0EDdiILai0AACEJCyAKIAtqIAinQf8AcSINOgAAIAogC0EIayAMcWpBCGogDToAACABIAEoAgggCUEBcWs2AgggASABKAIMQQFqNgIMIAogC0FobGoiAUEIayAENwMAIAFBEGsgAzcDACABQRhrIAI1AAAgAkEEajEAAEIghoQ3AwAgAEIANwMAC8IFAQl/IwBBMGsiBCQAAkACQAJ/AkACQCACIANLBEAgASADQRhsaiIGKAIUIgJBBE0EQEEAIQEgBEEANgIIIARBADYCLCAGQQRqIgMgAkECdGohCUEIIQUgBEEMaiIGIQogBEEsaiILDAQLIAYoAgghAyAGKAIEIQJBACEBIARBADYCCCAEQQA2AiwgAyACQQJ0aiEJIARBDGohBiAEQSxqIQsgAkEJSQ0CIAQgBEEIakF/IAJBAWtndkEBahD2AyAEKAIAIgFBgYCAgHhHBEAgAQ0CQdiVxwBBEUHUzMcAEOsHAAsgBCgCLCIFQQlJBEAgBSEBDAMLIAQoAgwhASAEKAIQIQogBgwDCyADIAJBrLvHABCMBwsACyAGIQpBCCEFIAsLIgwgASAFSQR/AkAgCSADayIHQQJ2IgggBSABQX9zaiICIAIgCEsbIghBB00gB0EDcXINACABQQJ0IApqIgIgA2tBEEkNACABIAhBAWoiCCAIQQNxIghBBCAIG2siB2ohASADIAdBAnRqA0AgAiAD/QACAP0LAgAgA0EQaiEDIAJBEGohAiAHQQRrIgcNAAshAwsgCiABQQJ0aiECA0AgAyAJRg0CIAIgAygCADYCACACQQRqIQIgA0EEaiEDIAUgAUEBaiIBRw0ACyAFBSABCzYCACADIAlGDQEDQAJ/IAQoAiwiBUEJSQRAIAUhAiAGIQdBCCEFIAsMAQsgBCgCDCECIAQoAhAhByAGCyEBIAMoAgAhDCACIAVGBEAgBEEIahDVBiAEKAIMIQIgBCgCECEHIAYhAQsgByACQQJ0aiAMNgIAIAEgASgCAEEBajYCACADQQRqIgMgCUcNAAsMAQsgDCABNgIACyAAIAT9AAII/QsCACAAQSBqIARBKGopAgA3AgAgAEEQaiAEQRhq/QACAP0LAgAgBEEwaiQAC8IFAQl/IwBBMGsiBCQAAkACQAJ/AkACQCACIANLBEAgASADQRhsaiIGKAIUIgJBBE0EQEEAIQEgBEEANgIIIARBADYCLCAGQQRqIgMgAkECdGohCUEIIQUgBEEMaiIGIQogBEEsaiILDAQLIAYoAgghAyAGKAIEIQJBACEBIARBADYCCCAEQQA2AiwgAyACQQJ0aiEJIARBDGohBiAEQSxqIQsgAkEJSQ0CIAQgBEEIakF/IAJBAWtndkEBahD2AyAEKAIAIgFBgYCAgHhHBEAgAQ0CQdiVxwBBEUHUzMcAEOsHAAsgBCgCLCIFQQlJBEAgBSEBDAMLIAQoAgwhASAEKAIQIQogBgwDCyADIAJBpMDHABCMBwsACyAGIQpBCCEFIAsLIgwgASAFSQR/AkAgCSADayIHQQJ2IgggBSABQX9zaiICIAIgCEsbIghBB00gB0EDcXINACABQQJ0IApqIgIgA2tBEEkNACABIAhBAWoiCCAIQQNxIghBBCAIG2siB2ohASADIAdBAnRqA0AgAiAD/QACAP0LAgAgA0EQaiEDIAJBEGohAiAHQQRrIgcNAAshAwsgCiABQQJ0aiECA0AgAyAJRg0CIAIgAygCADYCACACQQRqIQIgA0EEaiEDIAUgAUEBaiIBRw0ACyAFBSABCzYCACADIAlGDQEDQAJ/IAQoAiwiBUEJSQRAIAUhAiAGIQdBCCEFIAsMAQsgBCgCDCECIAQoAhAhByAGCyEBIAMoAgAhDCACIAVGBEAgBEEIahDVBiAEKAIMIQIgBCgCECEHIAYhAQsgByACQQJ0aiAMNgIAIAEgASgCAEEBajYCACADQQRqIgMgCUcNAAsMAQsgDCABNgIACyAAIAT9AAII/QsCACAAQSBqIARBKGopAgA3AgAgAEEQaiAEQRhq/QACAP0LAgAgBEEwaiQAC9MFAgl/BX4jAEEQayILJAACQAJ/AkACQCABUEUEQEGgfyACIAF5Ig+nayIGa8FB0ABsQbCnBWpBzhBtIgJB0QBPDQEgCyACQQR0IgIpA4iFQiABIA+GEN0GQgFBQCAGIAIvAZCFQmprIgdBP3GtIg+GIhFCAX0iEiALKQMIIAspAwBCP4h8IgGDIhBQRQRAIAIvAZKFQiEIIAEgD4inIgZBkM4ATwRAIAZBwIQ9SQ0EIAZBgMLXL08EQEEIQQkgBkGAlOvcA0kiAhshCUGAwtcvQYCU69wDIAIbDAYLQQZBByAGQYCt4gRJIgIbIQlBwIQ9QYCt4gQgAhsMBQsgBkHkAE8EQEECQQMgBkHoB0kiAhshCUHkAEHoByACGwwFC0EKQQEgBkEJSyIJGwwECyAAQQA2AgAMBAtB2I/CAEEcQfSPwgAQ6wcACyACQdEAQZiPwgAQjAcAC0EEQQUgBkGgjQZJIgIbIQlBkM4AQaCNBiACGwshAgJAAkACQCAJIAhrQQFqwSIIIAXBIgpKBEAgB0H//wNxIQ0gCCAFa8EgBCAIIAprIARJGyIKQQFrIQ5BACEHA0AgAyAHaiAGIAJuIgxBMGo6AAAgBiACIAxsayEGIAcgDkYNAyAHIAlGDQIgB0EBaiEHIAJBCkkgAkEKbiECRQ0AC0GEkMIAEIEIAAsgACADIARBACAIIAUgAUIKgCACrSAPhiARELIEDAMLIAdBAWohAiANQQFrQT9xrSETQgEhAQNAIAEgE4hQRQRAIABBADYCAAwECyACIARGDQIgAiADaiAQQgp+IhAgD4inQTBqOgAAIAFCCn4hASAQIBKDIRAgCiACQQFqIgJHDQALIAAgAyAEIAogCCAFIBAgESABELIEDAILIAAgAyAEIAogCCAFIAatIA+GIBB8IAKtIA+GIBEQsgQMAQsgBCAEQZSQwgAQjAcACyALQRBqJAAL8QQBDH8jAEEgayIEJAACQAJAAkAgACgCACIBQQNGIAFBAklyDQACQAJAIAAtABRBAWsOAgIAAQsgBEEANgIYIARBATYCDCAEQbzLxwA2AgggBEIENwIQIARBCGpBxMvHABCNCAALIAAoAgghCiAAKAIMIgwEQANAIAogB0EMbGoiBSgCBCELIAUoAggiCQRAIAtBJGohAQNAIAFBBGsoAgAiAkGAgICAeHJBgICAgHhHBEAgASgCACIGQQRrKAIAIgNBeHEiCEEEQQggA0EDcSIDGyACakkNByADQQAgCCACQSdqSxsNBiAGEKICCwJAIAFBFGsoAgAiBkECRg0AIAFBEGshAgJAIAZFBEAgAigCACICRQ0CIAFBDGsoAgAiBkEEaygCACIDQXhxIghBBEEIIANBA3EiAxsgAmpJDQkgA0UgCCACQSdqTXINAQwICyACKAIAIgJFDQEgAUEMaygCACIGQQRrKAIAIgNBeHEiCCACQQF0IgJBBEEIIANBA3EiAxtqSQ0IIANFDQAgCCACQSdqSw0HCyAGEKICCyABQSxqIQEgCUEBayIJDQALCyAFKAIAIgEEQCALQQRrKAIAIgVBeHEiCSABQSxsIgFBBEEIIAVBA3EiBRtqSQ0FIAVBACAJIAFBJ2pLGw0EIAsQogILIAdBAWoiByAMRw0ACwsgACgCBCIARQ0AIApBBGsoAgAiAUF4cSIHIABBDGwiAEEEQQggAUEDcSIBG2pJDQIgAUEAIAcgAEEnaksbDQEgChCiAgsgBEEgaiQADwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALtwgCBX8DfiMAQUBqIgEkACABQQY2AgQgAUGQgsgANgIAQai3yQAtAABBA0cEQAJAIwBBIGsiAiQAAkACQAJAAkBBqLfJAC0AAEECaw4CAwEAC0Got8kAQQI6AABBgAgQcSIDRQ0BQai3yQBBAzoAAEGYt8kAIAM2AgBBkLfJAEKAgICAgIABNwMAQYC3yQBCADcDAEGgt8kAQQA6AABBnLfJAEEANgIAQYy3yQBBADoAAEGIt8kAQQA2AgALIAJBIGokAAwCCwALIAJBADYCGCACQQE2AgwgAkGYg8gANgIIIAJCBDcCECACQQhqQZCEyAAQjQgACwsCQAJAAkACQAJAAkACQAJAQfi6yQApAwAiBlAEQEGAu8kAKQMAIQcDQCAHQn9RDQJBgLvJACAHQgF8IgZBgLvJACkDACIIIAcgCFEiAhs3AwAgCCEHIAJFDQALQfi6yQAgBjcDAAsCQEGAt8kAKQMAIAZSBEBBjLfJAC0AACECQQEhA0GMt8kAQQE6AAAgASACOgAYIAINA0GAt8kAIAY3AwAMAQtBiLfJACgCACICQX9GDQMgAkEBaiEDC0GIt8kAIAM2AgAgAUGAt8kANgIQIAAoAgQaIAFBBDoAGCABIAFBEGo2AiACQAJAIAFBGGpBiPvHACAAEMEDBEAgAS0AGEEERw0BIAFBADYCOCABQQE2AiwgAUHw+scANgIoIAFCBDcCMCABQShqQfj6xwAQjQgACyABQQQ6AAggASgCHCEAIAEtABgiAkEETSACQQNHcQ0BIAAoAgAhAiAAQQRqKAIAIgMoAgAiBARAIAIgBBEDAAsgAygCBCIDBEAgAkEEaygCACIEQXhxIgVBBEEIIARBA3EiBBsgA2pJDQYgBEEAIAUgA0EnaksbDQcgAhCiAgsgAEEEaygCACICQXhxIgNBEEEUIAJBA3EiAhtJDQcgAkEAIANBNE8bDQggABCiAgwBCyABIAEpAxg3AwgLIAEoAhAiACAAKAIIQQFrIgI2AgggAkUEQCAAQQA6AAwgAEIANwMACyABLQAIQQRHDQcgAUFAayQADwsjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQbCFyAA2AgggAEIENwIQIABBCGpBuIXIABCNCAALIAFCADcCNCABQoGAgIDAADcCLCABQcCDyAA2AiggAUEYaiABQShqEPsHAAtB2IPIAEEmQYCEyAAQqwcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAEgASkDCDcDECABQQI2AiwgAUGsgsgANgIoIAFCAjcCNCABIAFBEGqtQoCAgIDgAoQ3AyAgASABrUKAgICAoAGENwMYIAEgAUEYajYCMCABQShqQbyCyAAQjQgAC9UFAQl/IwBBIGsiCCQAIAAgACgCCCIEIAJqIgM2AgggACgCBCIJIANBEGoiByAHIAlLGyEDIAAoAgAhBQJAAkACQAJAAkACQAJAAkACQAJAAkAgASACTwRAIAEgBEsNASAEIAFrIQAgByAJTwRAIAAgAmoiASADSw0DIAAgAUsNBCAEIAMgAmtLDQUgAkUNCiAEIAVqIAAgBWogAvwKAAAMCgsgAkUNCSAEIAVqIgMgACAFaiIA/QAAAP0LAAAgAkERSQ0JIAAgAmohAkEAIAFrIQEgA0EQaiEAA0AgACAAIAFq/QAAAP0LAAAgAEEQaiIAIAFqIAJJDQALDAkLIAFBAUcEQEEAIQAgASADIAQgAWsiCSADIAlLG2ogBGsiBiADIARrIgdBACADIAdPGyIHIAYgB0kbIgYgAkEBayIKIAYgCkkbIgpBAWoiBkERSSABQQ9Ncg0IIAZBD3EiAEEQIAAbIgAgCkF/c2ohCkEAIAFrIQsgBCAFaiEBIAYgAGshAANAIAEgASALav0AAAD9CwAAIAFBEGohASAKQRBqIgoNAAsMCAsgBEEBayIAIANPDQQgAyAESQ0FIAIgAyAEayIBSw0GIAJFDQggBCAFaiAAIAVqLQAAIAL8CwAMCAtB8P7IAEEJQfz+yAAQqwcAC0EAIAEgA0Hg/sgAEOoHAAsgACABIANB4P7IABDqBwALIAhBADYCGCAIQQE2AgwgCEHUnMgANgIIIAhCBDcCECAIQQhqQeD+yAAQjQgACyAAIANBkP7IABCMBwALIAQgAyADQbD+yAAQ6gcAC0EAIAIgAUGg/sgAEOoHAAsgBSAJaiEBIAQgBWohBQNAIAAgCWoiBiADTw0CIAAgB0YNAyAAIAVqIAAgAWotAAA6AAAgAEEBaiIAIAJHDQALCyAIQSBqJAAPCyAGIANBwP7IABCMBwALIAAgBGogA0HQ/sgAEIwHAAuVBgEFfyMAQcDSAGsiAyQAAkACQAJAAkAgAkEJTQRAIABBgICAgHg2AgAMAQsCQAJAIAEtAABBH0cNACABLQABQYsBRw0AIAEtAAJBCEcNAEEKIQQgAS0AAyIFQQRxRQ0BIAJBDEkEQCAAQYCAgIB4NgIADAMLIAIgAS8ACkEMaiIETw0BIABBgICAgHg2AgAMAgsgA0EANgIcIANBATYCECADQbztxwA2AgwgA0IENwIUIANBDGoQlQchASAAQYGAgIB4NgIAIAAgATYCBAwBCyAFQQhxBEACQCACIARLBEADQCABIARqLQAARQ0CIAIgBEEBaiIERw0ACwsgAEGAgICAeDYCAAwCCyAEQQFqIQQLAkAgBUEQcUUNACACIARLBEADQCABIARqLQAARQRAIARBAWohBAwDCyACIARBAWoiBEcNAAsLIABBgICAgHg2AgAMAQsCQAJAIAVBAnEEQCACIARBAmoiBEkNAQsgAiAESw0BIABBgICAgHg2AgAMAgsgAEGAgICAeDYCAAwBC0EEEHEiBUUNASAFQQRrIgYtAABBA3EEQCAFQQA2AAALIANBDGoiB0EAQYHSAPwLACADQaDSAGogByABIARqIAIgBGsgBUEEQQBBBhBEIAMgAy0ApFIiAToAk1ICQAJAAkACQCABDgMBAgEACyABQf8BRwRAIANBATYCpFIgA0GY98cANgKgUiADQgE3AqxSIAMgA0GT0gBqrUKAgICA4ASENwO4UiADIANBuNIAajYCqFIgA0GU0gBqIgEgA0Gg0gBqELEGIAEQkAchASAAQYGAgIB4NgIAIAAgATYCBAwDCyAAQQA2AgggAEKAgICAEDcCAAwCCyADKAKoUiEBIAAgBTYCBCAAQQQ2AgAgAEEEIAEgAUEETxs2AggMAgsgAEGAgICAeDYCAAsgBigCACIAQXhxIgFBCEEMIABBA3EiABtJDQIgAEEAIAFBLE8bDQMgBRCiAgsgA0HA0gBqJAAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC64DAhp9A3xDAACAPyEMRAAAAAAAAPA/RAAAAODTDtU/IhujIhxEAAAAAAAA8D9EAAAAwJoD1D8iHaEgG6GitiELQwAAgD8hDUMAAIA/IQFDmpkZPiIIQ8P1qD4iA5QiDkMAAIA/Q5qZmT4iCZNDmpkZPyIEkyIClCAJQ4/CdT0iBZQiD0MAAIA/QwrXIz8iCpMgA5MiBpQgCiAElCIQQwAAgD8gCJMgBZMiB5SSkiAIIASUIhEgBpSTIAkgA5QiEiAHlJMgCiAFlCITIAKUkyIUQwAAAABcBEAgECASk0MAAIA/IBSVIgGUIQwgDiATkyABlCEVIA8gEZMgAZQhFiAJIAaUIAogApSTIAGUIRcgAyAClCAEIAaUkyABlCEYIAogB5QgCCAGlJMgAZQhDSAFIAaUIAMgB5STIAGUIRkgCCAClCAJIAeUkyABlCEaIAQgB5QgBSAClJMgAZQhAQsgACAFIBggHCAdorYiApQgF5IgDCALlJKUOAIMIAAgBCAZIAKUIA2SIBUgC5SSlDgCCCAAIAMgASAClCAaIBYgC5SSkpQ4AgQgAEEBNgIAC5kFAgZ/AX4CQCABKAIIIgIgASgCBCIETw0AIAEoAgAgAmotAABB9QBHDQBBASEHIAEgAkEBaiICNgIICwJAAkAgAiAESQRAIAEoAgAiBiACai0AAEEwayIDQf8BcSIFQQpJDQELDAELIAEgAkEBaiICNgIIAkACQCAFRQRAQQAhAwwBCyADQf8BcSEDA0AgAiAERgRAIAQhAgwDCyACIAZqLQAAQTBrQf8BcSIFQQlLDQEgASACQQFqIgI2AgggA61CCn4iCEIgiFAEQCAFIAinIgVqIgMgBU8NAQsLDAILIAIgBE8NACACIAZqLQAAQd8ARw0AIAEgAkEBaiICNgIICwJAAkACQAJAIAIgAiADaiIFTQRAIAEgBTYCCCAEIAVJDQUgAkUNAiACIARJDQEMAgsMBAsgAiAGaiwAAEG/f0wNAQsgBUUgBCAFTXJFBEAgBSAGaiwAAEG/f0wNAQsgAiAGaiEEIAcNASAAQgE3AgggACADNgIEIAAgBDYCAA8LIAYgBCACIAVBuLLFABC7CQALIAIgBmpBAWshBiADIQECfwNAIAEiAkUEQEEAIQEgBCEFQQEMAgsgAkEBayEBIAIgBmotAABB3wBHDQALAkACQCABRQ0AAkAgASADTwRAIAEgA0cNASACDQJBACEGDAMLIAEgBGosAABBv39KDQELIAQgA0EAIAFByLLFABC7CQALAkAgAiADTwRAIAMhBiACIANHDQEMAgsgAiAEaiwAAEG/f0wNACACIQYMAQsgBCADIAIgA0HYssUAELsJAAsgBCAGaiEFIAMgBmshAyAECyECIANFBEAMAQsgACADNgIMIAAgBTYCCCAAIAE2AgQgACACNgIADwsgAEEANgIAIABBADoABAvbBQIKfwF+IwBBIGsiAyQAAn8CQAJAIAIEQANAIAEgBWosAABBAE4EQCAFQQFqIgUgAkcNAQwDCwsgA0EANgIQIANCgICAgBA3AwggA0EIakEAIAIQ7wUgAygCECEFIAEhByACIQgDQCAFIQYgBywAACIEQQBIBEAgBEH/AHFBAnQoApysSSEEC0EBQQJBAyAEQYAQSSIMGyAEQYABSSIJGyIKIAMoAgggBWtLBH8gA0EIaiAFIAoQ7wUgAygCEAUgBgsgAygCDGohBgJAIAlFBEAgBEEGdiEJIARBP3FBgH9yIQsgDARAIAYgCzoAASAGIAlBwAFyOgAADAILIAYgCzoAAiAGIAlBgAFyOgABIAYgBEEMdkHgAXI6AAAMAQsgBiAEOgAACyADIAUgCmoiBTYCECAHQQFqIQcgCEEBayIIDQALIAMpAwghDUEADAMLIANBADYCECADIAE2AgwMAQsgA0EIaiIGIAEgAhD7AiADKAIIRQ0AIAMgAykCDCINQiCIPgIYIAMgDT4CFCADIAI2AhAgAyABNgIMIAMgAjYCCEHY5sgAQSsgBkG4msgAQciayAAQ4AYACyACrSABrUIghoQhDSACIQVBAQshByANQiCIpyEEAkACQAJAAkACQAJAAkAgBSANpyIITw0AIAVFBEAgBEEEaygCACIGQXhxIgpBBEEIIAZBA3EiBhsgCGpJDQIgBkEAIAogCEEnaksbDQMgBBCiAkEBIQQMAQsgBCAIQQEgBRC7AiIERQ0DCyACRSAHcg0FIAFBBGsoAgAiB0F4cSIIQQRBCCAHQQNxIgcbIAJqSQ0DIAdBACAIIAJBJ2pLGw0EIAEQogIMBQtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgACAFNgIEIAAgBDYCACADQSBqJAALpAQBB38CQAJAIAAoAjgiBQRAIAAoAjQgBUECdEELakF4cSIBayIEQQRrKAIAIgJBeHEiAyABIAVqQQlqIgFBBEEIIAJBA3EiAhtqSQ0BIAJBACADIAFBJ2pLGw0CIAQQogILIAAoAiwhAiAAKAIwIgYEQCACIQEDQCABQawBaigCACIHBEAgAUGoAWooAgAiBUEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgB2pJDQMgA0EAIAQgB0EnaksbDQQgBRCiAgsgARDqAyABQbgBaiEBIAZBAWsiBg0ACwsgACgCKCIDBEAgAkEEaygCACIBQXhxIgQgA0G4AWwiA0EEQQggAUEDcSIBG2pJDQEgAUEAIAQgA0EnaksbDQIgAhCiAgsgACgCTCIEBEAgACgCSCIDQQRrKAIAIgJBeHEiAUEEQQggAkEDcSICGyAEakkNASACQQAgASAEQSdqSxsNAiADEKICCwJAIAAoAmAiBEUNACAAKAJkIgNFDQAgBEEEaygCACICQXhxIgFBBEEIIAJBA3EiAhsgA2pJDQEgAkEAIAEgA0EnaksbDQIgBBCiAgsCQCAAQX9GDQAgACAAKAIEIgJBAWs2AgQgAkEBRw0AIABBBGsoAgAiAUF4cUHsAEHwACABQQNxIgIbSQ0BIAJBACABQZABTxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6kTAxh/BX4BeyMAQSBrIhMkACABKQMQIAEpAxggAigCBCIWIAIoAggiGRCVBCEeIAEoAghFBEACQCABQRBqIRAjAEEgayIMJAACQAJAAkAgASgCDCIUQQFqIgQEQAJAIAEoAgQiCiAKQQFqIhFBA3YiCEEHbCIXIApBCEkbIgVBAXYgBEkEQAJAAkACQAJAAn8gBUEBaiIFIAQgBCAFSRsiBUEPTwRAIAVB/////wFLDQtBfyAFQQN0QQduQQFrZ3ZBAWoMAQtBBCAFQQhxQQhqIAVBBEkbCyIHrUIYfiIcQiCIpw0AIBynIgQgB0EIaiIIaiIFIARJIAVB+P///wdLcg0AIAUQcSIFRQ0BIAQgBWohCyAIBEAgC0H/ASAI/AsACyAHQQFrIg8gB0EDdkEHbCAPQQhJGyEVIAEoAgAhByAUDQJBACEUDAMLIAxBADYCGCAMQQE2AgwgDEHEtcQANgIIIAxCBDcCECAMQQhqQZi1xAAQjQgLAAsgC0EIaiEXIAdBGGshGCAHKQMAQn+FQoCBgoSIkKDAgH+DIR0gECkDCCEfIBApAwAhIEEAIQUgFCEGIAchCANAIB1QBEADQCAFQQhqIQUgCEEIaiIIKQMAQoCBgoSIkKDAgH+DIhxCgIGChIiQoMCAf1ENAAsgHEKAgYKEiJCgwIB/hSEdCyALIA8gICAfIBggHXqnQQN2IAVqIhBBaGxqIgRBBGooAgAgBEEIaigCABCVBKciCXEiBGopAABCgIGChIiQoMCAf4MiHFAEQEEIIQ0DQCAEIA1qIQQgDUEIaiENIAsgBCAPcSIEaikAAEKAgYKEiJCgwIB/gyIcUA0ACwsgHUIBfSAdgyEdIAsgHHqnQQN2IARqIA9xIgRqLAAAQQBOBEAgCykDAEKAgYKEiJCgwIB/g3qnQQN2IQQLIAQgC2ogCUEZdiIJOgAAIBcgBEEIayAPcWogCToAACALIARBf3NBGGxqIglBEGogByAQQX9zQRhsaiIEQRBqKQAANwAAIAkgBP0AAAD9CwAAIAZBAWsiBg0ACwsgASAPNgIEIAEgCzYCACABIBUgFGs2AgggCkUNASAKIApBGGxBH2pBeHEiBWpBCWoiBkUNASAHIAVrIgRBBGsoAgAiBUF4cSIIQQRBCCAFQQNxIgUbIAZqSQ0DIAVBACAIIAZBJ2pLGw0EIAQQogIMAQsgASARBH8gASgCACEJAkACQCAIIBFBB3FBAEdqIgZBAkkEQCAGIQgMAQsgBkEBcSEIIAZB/v///wNxIgdBA3QhDSAHIQQgCSEFA0AgBSAF/QADACIh/U1BB/3NAf0MAQEBAQEBAQEBAQEBAQEBAf1OICH9DH9/f39/f39/f39/f39/f3/9UP3OAf0LAwAgBUEQaiEFIARBAmsiBA0ACyAGIAdGDQELIAkgDWohBQNAIAUgBSkDACIcQn+FQgeIQoGChIiQoMCAAYMgHEL//v379+/fv/8AhHw3AwAgBUEIaiEFIAhBAWsiCA0ACwsCQCARQQhPBEAgCSARaiAJKQAANwAADAELIBFFDQAgCUEIaiAJIBH8CgAACyAJQQhqIQsgECkDCCEfIBApAwAhIEEBIQRBACEFA0AgBSEIIAQhBQJAIAggCWoiDy0AAEGAAUcNACAJIAhBf3NBGGxqIQ4gCSAIQWhsaiIEQRBrIRggBEEUayEQA0AgCiAgIB8gECgCACAYKAIAEJUEpyIVcSIHIQYgByAJaikAAEKAgYKEiJCgwIB/gyIdUARAQQghDQNAIAYgDWohBCANQQhqIQ0gCSAEIApxIgZqKQAAQoCBgoSIkKDAgH+DIh1QDQALCyAJIB16p0EDdiAGaiAKcSIGaiwAAEEATgRAIAkpAwBCgIGChIiQoMCAf4N6p0EDdiEGCyAGIAdrIAggB2tzIApxQQhPBEAgBiAJaiIELQAAIAQgFUEZdiIEOgAAIAsgBkEIayAKcWogBDoAACAJIAZBf3NBGGxqIQZB/wFGBEAgD0H/AToAACALIAogCEEIa3FqQf8BOgAAIAZBEGogDkEQaikAADcAACAGIA79AAAA/QsAAAwDCyAOKQAAIRwgDiAGKQAANwAAIAYgHDcAACAGKQAIIRwgBiAOKQAINwAIIA4gHDcACCAOKAAQIQcgDiAGKAAQNgAQIAYoABQhBCAGIA4oABQ2ABQgDiAENgAUIAYgBzYAEAwBCwsgDyAVQRl2IgQ6AAAgCyAKIAhBCGtxaiAEOgAACyAFIAUgEUkiCGohBCAIDQALIAogFyAKQQhJGwVBAAsgFGs2AggLIAxBIGokAAwECwwCC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgDEEANgIYIAxBATYCDCAMQcS1xAA2AgggDEIENwIQIAxBCGpBmLXEABCNCAALCyABKAIEIgggHqdxIQcgHkIZiCIfQv8Ag0KBgoSIkKDAgAF+ISAgASgCACEEA0ACQAJAAkACQAJAAkAgBCAHaikAACIeICCFIhxCf4UgHEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIcUEUEQANAIAQgHHqnQQN2IAdqIAhxQWhsaiIFQRBrKAIAIBlGBEAgFiAFQRRrKAIAIBkQ2wdFDQMLIBxCAX0gHIMiHFBFDQALCyAeQoCBgoSIkKDAgH+DIRwgGkUEQCAcUA0DIBx6p0EDdiAHaiAIcSESCyAcIB5CAYaDUARAQQEhGgwGCyAEIBJqLAAAIgdBAE4EQCAEIAQpAwBCgIGChIiQoMCAf4N6p0EDdiISai0AACEHCyAEIBJqIB+nQf8AcSIFOgAAIAQgEkEIayAIcWpBCGogBToAACATQRBqIgUgAkEIaigCADYCACATQRxqIANBCGooAgA2AgAgASABKAIIIAdBAXFrNgIIIAEgASgCDEEBajYCDCAEIBJBaGxqQRhrIgEgAikCADcCACATIAMpAgA3AhQgAUEIaiAFKQMANwIAIAFBEGogE0EYaikDADcCACAAQYCAgIB4NgIADAELIAAgBUEMayIBKQIANwIAIAEgAykCADcCACAAQQhqIAFBCGoiACgCADYCACAAIANBCGooAgA2AgAgAigCACICRQ0AIBZBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIAJqSQ0CIABBACABIAJBJ2pLGw0DIBYQogILIBNBIGokAA8LQQAhGgwCC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgG0EIaiIbIAdqIAhxIQcMAAsAC44FAgx/A34jAEGgAWsiCCQAIAhBAEGgAfwLAAJAAkAgAiAAKAKgASIFTQRAIAVBKU8NAiAFQQFqIQwgBUECdCEJIAEgAkECdGohDQJAA0AgCCAGQQJ0aiEDA0AgBiECIAMhBCABIA1GDQQgA0EEaiEDIAJBAWohBiABKAIAIQcgAUEEaiILIQEgB0UNAAsgB60hEUIAIQ8gCSEHIAIhASAAIQMDQCABQShPDQIgBCAPIAQ1AgB8IAM1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0ACwJAIAogEEKAgICAEFoEfyACIAVqIgFBKE8NASAIIAFBAnRqIA8+AgAgDAUgBQsgAmoiASABIApJGyEKIAshAQwBCwsgAUEoQYyDwgAQjAcACyABQShBjIPCABCMBwALIAJBAWohDSACQQJ0IQwgACAFQQJ0aiEOIAAhAwJAA0AgCCAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQMgBEEEaiEGIAdBAWohByADKAIAIQkgA0EEaiIFIQMgCUUNAAsgCa0hEUIAIQ8gDCEJIAshAyABIQYDQCADQShPDQIgBCAPIAQ1AgB8IAY1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIAlBBGsiCQ0ACwJAIAogEEKAgICAEFoEfyACIAtqIgNBKE8NASAIIANBAnRqIA8+AgAgDQUgAgsgC2oiAyADIApJGyEKIAUhAwwBCwsgA0EoQYyDwgAQjAcACyADQShBjIPCABCMBwALIAAgCEGgAfwKAAAgACAKNgKgASAIQaABaiQADwtBACAFQShBjIPCABDqBwALpQUCBX8EfgJAAkACQAJAAkAgAkUEQEEBIQUMAQsgAhBxIgVFDQEgBUEEay0AAEEDcUUgAkVyDQAgBUEAIAL8CwALIAEoAgQiA60hCCADQv////8PIAEpAwgiCSAJQv////8PWhunayIEQQAgAyAETxsgAk8EQCABKAIAIAkgCCAIIAlWG6dqIQMgAkEBRwRAIAJFDQMgBSADIAL8CgAADAMLIAUgAy0AADoAAAwCC0GokMgAKQMAIgtCCIghCiALpyEDIAtC/wGDQgRSDQMMAgsAC0EEIQMLIAkgAq18IQgLIAEgCDcDCAJAAkACQAJAIANB/wFxIgZBBEcEQCAKQhiIpyEBIAqnIgchBAJAAkACQAJAIAZBAWsOAwEAAgMLIAEtAAghBAsgBEH/AXFBJUcNASAAQTI2AgggAEHfi8EANgIEIABBgICAgHg2AgAMBAsgAS0ACEElRg0CCyAAIAE2AgggAEGBgICAeDYCACAAIANB/wFxIAdBCHRyNgIEDAILIAAgAjYCCCAAIAU2AgQgAEGGgICAeDYCAA8LIABBMjYCCCAAQd+LwQA2AgQgAEGAgICAeDYCACABKAIAIQAgAUEEaigCACIDKAIAIgQEQCAAIAQRAwALIAMoAgQiAwRAIABBBGsoAgAiBEF4cSIGQQRBCCAEQQNxIgQbIANqSQ0CIARBACAGIANBJ2pLGw0DIAAQogILIAFBBGsoAgAiAEF4cSIDQRBBFCAAQQNxIgAbSQ0BIABBACADQTRPGw0CIAEQogILIAIEQCAFQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyACakkNASAAQQAgASACQSdqSxsNAiAFEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC40EAQd/AkACQCAAKAIAIgEEQCAAKAIEIgRBBGsoAgAiAkF4cSIDIAFBJGwiAUEEQQggAkEDcSICG2pJDQEgAkEAIAMgAUEnaksbDQIgBBCiAgsgACgCECECIAAoAhQiBQRAIAIhAQNAIAFBFGooAgAiBEEFTwRAIAFBCGooAgAiBkEEaygCACIDQXhxIgcgBEECdCIEQQRBCCADQQNxIgMbakkNAyADQQAgByAEQSdqSxsNBCAGEKICCyABQRhqIQEgBUEBayIFDQALCyAAKAIMIgMEQCACQQRrKAIAIgFBeHEiBCADQRhsIgNBBEEIIAFBA3EiARtqSQ0BIAFBACAEIANBJ2pLGw0CIAIQogILIAAoAhgiAQRAIAAoAhwiBEEEaygCACICQXhxIgMgAUESbCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAIkIgEEQCAAKAIoIgRBBGsoAgAiAkF4cSIDIAFBHmwiAUEEQQggAkEDcSICG2pJDQEgAkEAIAMgAUEnaksbDQIgBBCiAgsgACgCMCICBEAgACgCNCIDQQRrKAIAIgBBeHEiASACQSpsIgJBBEEIIABBA3EiABtqSQ0BIABBACABIAJBJ2pLGw0CIAMQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALjQQBB38CQAJAIAAoAgAiAQRAIAAoAgQiBEEEaygCACICQXhxIgMgAUEYbCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAIQIQIgACgCFCIFBEAgAiEBA0AgAUEUaigCACIEQQVPBEAgAUEIaigCACIGQQRrKAIAIgNBeHEiByAEQQJ0IgRBBEEIIANBA3EiAxtqSQ0DIANBACAHIARBJ2pLGw0EIAYQogILIAFBGGohASAFQQFrIgUNAAsLIAAoAgwiAwRAIAJBBGsoAgAiAUF4cSIEIANBGGwiA0EEQQggAUEDcSIBG2pJDQEgAUEAIAQgA0EnaksbDQIgAhCiAgsgACgCGCIBBEAgACgCHCIEQQRrKAIAIgJBeHEiAyABQQlsIgFBBEEIIAJBA3EiAhtqSQ0BIAJBACADIAFBJ2pLGw0CIAQQogILIAAoAiQiAQRAIAAoAigiBEEEaygCACICQXhxIgMgAUEPbCIBQQRBCCACQQNxIgIbakkNASACQQAgAyABQSdqSxsNAiAEEKICCyAAKAIwIgIEQCAAKAI0IgNBBGsoAgAiAEF4cSIBIAJBFWwiAkEEQQggAEEDcSIAG2pJDQEgAEEAIAEgAkEnaksbDQIgAxCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvLBQIGfwN+IwBBgAFrIgQkACABvCEGAn9BAyABi0MAAIB/Ww0AGkECIAZBgICA/AdxIgVBgICA/AdGDQAaIAZB////A3EiCEGAgIAEciAGQQF0Qf7//wdxIAZBF3ZB/wFxIgcbIgmtIgpCAYMhCyAFRQRAQQQgCEUNARogB0GWAWshB0IBIQwgC1AMAQtCgICAECAKQgGGIAlBgICABEYiCBshCkICQgEgCBshDEHofkHpfiAIGyAHaiEHIAtQCyEFIAQgBzsBeCAEIAw3A3AgBEIBNwNoIAQgCjcDYCAEIAU6AHoCfwJAAkACQAJAAkAgBUH/AXFBAU0EQCADQf//A3EhA0Hqs8UAQQEgBkEASCIFGyEHQeqzxQBByIHCACAFGyEFIAZBH3YhBiAEQSBqIARB4ABqIARBD2oQzwEgBCgCIEUNASAEQdgAaiAEQShqKAIANgIAIAQgBCkCIDcDUAwCCyAFQf8BcSIIQQJGDQJBASEFQeqzxQBByIHCACAGQQBIIgcbQeqzxQBBASAHGyACGyEHQQEgBkEfdiACGyEGIAhBBEcNA0ECIQUgBEECOwEgIANB//8DcQ0EQQEhBSAEQQE2AiggBEGYsMUANgIkIARBIGoMBQsgBEHQAGogBEHgAGogBEEPahBXCyAFIAcgAhshB0EBIAYgAhshBiAEIAQoAlAgBCgCVCAELwFYIAMgBEEgahDsBCAEKAIEIQUgBCgCAAwDCyAEQQM2AiggBEHzncYANgIkIARBAjsBIEEBIQdBACEGQQEhBSAEQSBqDAILIARBAzYCKCAEQeydxgA2AiQgBEECOwEgIARBIGoMAQsgBEEBNgIwIARBADsBLCAEQQI2AiggBEG5g8IANgIkIARBIGoLIQIgBCAFNgJcIAQgAjYCWCAEIAY2AlQgBCAHNgJQIAAgBEHQAGoQvgMgBEGAAWokAAv3BAEIfwJAIAMtAAMiByADLQAEIgtrIgggCEEfdSIIcyAIa0EBdCADLQACIgggAy0ABSIKayIEIARBH3UiBXMgBWtBAXZqIAJB/wFxSw0AIAFB/wFxIgEgAy0AACADLQABIgJrIgUgBUEfdSIFcyAFa0kNACABIgUgAiAIayIGIAZBH3UiBnMgBmtB/wFxSQ0AIAUgCCAHayIGIAZBH3UiBnMgBmsiBkH/AXFJDQAgBSADLQAHIAMtAAYiBWsiCSAJQR91IglzIAlrSQ0AIAEgBSAKayIJIAlBH3UiCXMgCWtB/wFxSQ0AIAEgCiALayIBIAFBH3UiAXMgAWsiAUH/AXFJDQAgAEH/AXEiACAGQf8BcU8gAUH/AXEgAE1xRQRAQQEgAxDiBRoPCyADQf8BIAVB/wBBgH8gCyAHa0EDbEH/AEGAfyAEIARBgH9MGyIAIABB/wBOG2oiACAAQYB/TBsiACAAQf8AThsiAEEJbEE/akEHdSIBayIEQQAgBEEAShsiBCAEQf8BThs6AAYgA0H/AEGAfyAKIABBEmxBP2pBB3UiCmtBgAFrIgQgBEGAf0wbIgQgBEH/AE4bQYABczoABSADQf8AQYB/IAcgAEEbbEE/akEHdSIAakGAAWsiByAHQYB/TBsiByAHQf8AThtBgAFzOgADIANB/wBBgH8gCyAAa0GAAWsiACAAQYB/TBsiACAAQf8AThtBgAFzOgAEIANB/wBBgH8gCCAKakGAAWsiACAAQYB/TBsiACAAQf8AThtBgAFzOgACIANB/wBBgH8gASACakGAAWsiACAAQYB/TBsiACAAQf8AThtBgAFzOgABCwvDBQIHfwF7IwBB0NEAayIDJABBASEHAkACQAJAIAJBAXQiBEEATgRAAkAgAkUNACAEEHEiB0UNAiAHQQRrLQAAQQNxRSAERXINACAHQQAgBPwLAAsgAyAENgIMIAMgBzYCCCADIAQ2AgRBhNIAEHEiBUUNASAFQQA2AuRRIAVB6NEAakEAOwEAIANBkM8AakEAQcAC/AsAIAVB/NEAakEANgAAIAX9DAAAAAAAAAAAAAAAAAAAAAD9CwDtUSADQRBqIgZBAEGAzwD8CwAgBSAGQcDRAPwKAAAgBUHg0QBqQQA2AgAgBUHQ0QBqIAr9CwIAIAUgCv0LAsBRIAVBADoAgFIgBUEAOgDsUSAFQQA7AepRA0AgA0EQaiAFIAEgAiAHIAQgCEEEEEQgAygCGCAIaiEIIAMtABQiBkECRwRAIAYEQCAAIAMpAgQ3AgAgACAGOgAMIABBCGogA0EMaigCADYCAAwGCyAEIAhPBEAgAyAINgIMCyAAIAMpAgQ3AgQgAEGAgICAeDYCACAAQQxqIANBDGooAgA2AgAMBQsgAiADKAIQIgZJDQMgASAGaiEBIAIgBmshAiADIAQEfyAEIQYgAygCBCAEayAESQRAIANBBGogBCAEEPgFIAMoAgghByADKAIMIQYLIAYgB2ohCSAEQQFHBH8gBEEBayIEBEAgCUEAIAT8CwALIAcgBCAGaiIGagUgCQtBADoAACAGQQFqBSAEQQF0CyIENgIMDAALAAtBwPzEABD/BwsACyAAIAMpAgQ3AgAgAEECOgAMIABBCGogA0EMaigCADYCAAsCQCAFQQRrKAIAIgBBeHEiAUGI0gBBjNIAIABBA3EiABtPBEAgAEEAIAFBrNIATxsNASAFEKICIANB0NEAaiQADwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALowUBCH8CQAJAAkACQAJAAkACQCABIAIgAyAEIAUgBhDAAwRAIAUgBkEBdCIIayIBIARPDQIgBSAGayICIARPDQMgAEH/AXEiDCABIANqIgotAAAiASACIANqIgstAAAiAmsiByAHQR91IgdzIAdrSQ0GIAUgBmoiByAETw0EIAQgBU0NBSAMIAMgB2oiDS0AACIHIAMgBWoiDi0AACIJayIAIABBH3UiAHMgAGtJDQYgBkF9bCAFaiIAIARPDQcgBSAIaiIFIARPDQEgACADaiIELQAAIQYgAyAFaiIDLQAAIQUgDkH/AEGAfyAJQf8AQYB/IAkgAmtBA2xB/wBBgH8gASAHayIAIABBgH9MGyIAIABB/wBOG2oiACAAQYB/TBsiACAAQf8AThsiAEEbbEE/akEHdSIJa0GAAWsiCCAIQYB/TBsiCCAIQf8AThtBgAFzOgAAIAtB/wBBgH8gAiAJakGAAWsiAiACQYB/TBsiAiACQf8AThtBgAFzOgAAIA1B/wBBgH8gByAAQRJsQT9qQQd1IgJrQYABayIHIAdBgH9MGyIHIAdB/wBOG0GAAXM6AAAgCkH/AEGAfyABIAJqQYABayIBIAFBgH9MGyIBIAFB/wBOG0GAAXM6AAAgA0H/AEGAfyAFIABBCWxBP2pBB3UiAGtBgAFrIgEgAUGAf0wbIgEgAUH/AE4bQYABczoAACAEQf8AQYB/IAAgBmpBgAFrIgAgAEGAf0wbIgAgAEH/AE4bQYABczoAAAsPCyAFIARB2NfEABCMBwALIAEgBEHo18QAEIwHAAsgAiAEQfjXxAAQjAcACyAHIARBiNjEABCMBwALIAUgBEGY2MQAEIwHAAtBASADIAQgBSAGEOgEGg8LIAAgBEHI18QAEIwHAAvMBQIGfwJ+AkAgAkUNACACQQdrIgNBACACIANPGyEHIAFBA2pBfHEgAWshCEEAIQMDQAJAAkACQCABIANqLQAAIgXAIgZBAE4EQCAIIANrQQNxDQEgAyAHTw0CA0AgASADaiIEQQRqKAIAIAQoAgByQYCBgoR4cQ0DIANBCGoiAyAHSQ0ACwwCC0KAgICAgCAhCkKAgICAECEJAkACQAJ+AkACQAJAAkACQAJAAkACQAJAIAUtAPSWQkECaw4DAAECCgsgA0EBaiIEIAJJDQJCACEKQgAhCQwJC0IAIQogA0EBaiIEIAJJDQJCACEJDAgLQgAhCiADQQFqIgQgAkkNAkIAIQkMBwsgASAEaiwAAEG/f0oNBgwHCyABIARqLAAAIQQCQAJAIAVB4AFrIgUEQCAFQQ1GBEAMAgUMAwsACyAEQWBxQaB/Rg0EDAMLIARBn39KDQIMAwsgBkEfakH/AXFBDE8EQCAGQX5xQW5HDQIgBEFASA0DDAILIARBQEgNAgwBCyABIARqLAAAIQQCQAJAAkACQCAFQfABaw4FAQAAAAIACyAGQQ9qQf8BcUECSyAEQUBOcg0DDAILIARB8ABqQf8BcUEwTw0CDAELIARBj39KDQELIAIgA0ECaiIETQRAQgAhCQwFCyABIARqLAAAQb9/Sg0CQgAhCSADQQNqIgQgAk8NBCABIARqLAAAQUBIDQVCgICAgIDgAAwDC0KAgICAgCAMAgtCACEJIANBAmoiBCACTw0CIAEgBGosAABBv39MDQMLQoCAgICAwAALIQpCgICAgBAhCQsgACAKIAOthCAJhDcCBCAAQQE2AgAPCyAEQQFqIQMMAgsgA0EBaiEDDAELIAIgA00NAANAIAEgA2osAABBAEgNASACIANBAWoiA0cNAAsMAgsgAiADSw0ACwsgACACNgIIIAAgATYCBCAAQQA2AgALiwUCB38CewJAAn8CQCABKAIgIgUgA00EQCACIANqIgggBWshByADIAVIBEAgAiEEDAILIAH9AAQQIQsgAf0ABAAhDCABLQAlIQkgAS0AJCEGIAIhBANAIAQgBmr9AAAAIAz9IyAEIAlq/QAAACAL/SP9Tv1kIgoEQCAKaCAEIAJragwECyAHIARBEGoiBE8NAAsMAQsgA0UNAiABLQA0IQUCQAJAAkAgA0EETwRAQYCChAggBUGBgoQIbCIHIAIoAABzIgRrIARyQYCBgoR4cUGAgYKEeEcEQCACIQQDQCAFIAQtAABGDQUgBEEBaiEEIANBAWsiAw0ACwwHCyACQQQgAkEDcSIIayIGaiEEIANBCUkNASAEIAIgA2oiA0EIayIISw0CA0BBgIKECCAEKAIAIAdzIgZrIAZyQYCBgoR4cUGAgYKEeEcNA0GAgoQIIARBBGooAgAgB3MiBmsgBnJBgIGChHhxQYCBgoR4Rw0DIARBCGoiBCAITQ0ACwwCCyAFIAIiBC0AAEYNAiADQQFGDQUgBC0AASAFRgRAIARBAWohBAwDCyADQQJGDQUgBSACLQACRw0FIAJBAmohBAwCCyADIAZNDQQgAyAIakEEayEDA0AgBSAELQAARg0CIARBAWohBCADQQFrIgMNAAsMBAsgAyAETQ0DA0AgBSAELQAARg0BIARBAWoiBCADRw0ACwwDCyAEIAJrIgIgAS0ANWsiAUEAIAEgAk0bDAELQQAhCSAEIAhPDQEgByABLQAkav0AAAAgAf0ABAD9IyAHIAEtACVq/QAAACAB/QAEEP0j/U79ZCIERQ0BIARoIAMgBWtqCyEEQQEhCQsgACAENgIEIAAgCTYCAAuLBQEQfyMAQRBrIgokAAJAIAEoAhAiBiABKAIMIgNJDQAgBiABKAIIIg5LDQAgASgCBCELIAFBFGoiECABLQAYIgdqQQFrLQAAIQgCQCAHQQVPBEADQCADIAtqIQQCQCAGIANrIgVBB00EQCADIAZGDQRBACECA0AgAiAEai0AACAIRg0CIAUgAkEBaiICRw0ACwwECyAKQQhqIAggBCAFEIcFIAooAghBAXFFDQMgCigCDCECCyABIAIgA2pBAWoiAzYCDCADIA5NIAMgB09xRQRAIAMgBk0NAQwECwtBACAHQQRB5LjHABDqBwALIAhBgYKECGwhDwNAIAMgC2ohBQJAAkACQAJAIAYgA2siCUEITwRAIAVBA2pBfHEiAiAFRg0BIAIgBWshBEEAIQIDQCACIAVqLQAAIAhGDQUgBCACQQFqIgJHDQALIAQgCUEIayICSw0DDAILIAMgBkYNBUEAIQIDQCACIAVqLQAAIAhGDQQgAkEBaiICIAlHDQALDAULIAlBCGshAkEAIQQLA0BBgIKECCAEIAVqIgwoAgAgD3MiEWsgEXJBgIKECCAMQQRqKAIAIA9zIgxrIAxycUGAgYKEeHFBgIGChHhHDQEgBEEIaiIEIAJNDQALCyAEIAlGDQIgBCAFaiEFIAYgBGsgA2shCUEAIQIDQCAIIAIgBWotAABHBEAgAkEBaiICIAlHDQEMBAsLIAIgBGohAgsgASACIANqQQFqIgM2AgwCQCADIAdJIAMgDktyRQRAIAsgAyAHayICaiAQIAcQ2wdFDQELIAMgBk0NAQwDCwsgACADNgIIIAAgAjYCBEEBIQ0MAQsgASAGNgIMCyAAIA02AgAgCkEQaiQAC7oEAQR/AkACQAJAAkACQAJAAkACQAJAAkBBFSAAKAIAIgRBgICAgHhzIARBAE4bDhUHBwcHBwcHBwcHBwcBBwIHBwMHBAUACyAAKAIEIQIgACgCCCIABEAgAiEBA0AgARD+AiABQRBqEP4CIAFBIGohASAAQQFrIgANAAsLIARFDQYgAkEEaygCACIAQXhxIgMgBEEFdCIBQQRBCCAAQQNxIgAbckkNCCAARQ0FIAMgAUEnaksNBwwFCyAAKAIEIgNFDQUgACgCCCICQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyADakkNByAARSABIANBJ2pNcg0EDAYLIAAoAgQiA0UNBCAAKAIIIgJBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIANqSQ0GIABFIAEgA0Enak1yDQMMBQsgACgCBCICEP4CIAJBBGsoAgAiAUF4cUEUQRggAUEDcSIAG0kNBSAARSABQThJcg0CDAQLIAAoAgQiAhD+AiACQQRrKAIAIgFBeHFBFEEYIAFBA3EiABtJDQQgAEUgAUE4SXINAQwDCyAAKAIIIQIgACgCDCIDBEAgAiEBA0AgARD+AiABQRBqIQEgA0EBayIDDQALCyAAKAIEIgFFDQEgAkEEaygCACIAQXhxIgMgAUEEdCIBQQRBCCAAQQNxIgAbckkNAyAARSADIAFBJ2pNcg0ADAILIAIQogILDwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALtAUCB38BeyAFQQNuIQwCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAQRAIAFBAnQiChBxIglFDQUCQCABQQRPBEAgACEIIAkhByABQXxxIgshBgNAIAcgCP0AAgAiDf0fABCJBP0TIA39HwEQiQT9IAEgDf0fAhCJBP0gAiAN/R8DEIkE/SAD/QsCACAIQRBqIQggB0EQaiEHIAZBBGsiBg0ACyABIAtGDQELIAEgC2shBiAAIAtBAnQiB2ohCCAHIAlqIQcDQCAHIAgqAgAQiQQ4AgAgCEEEaiEIIAdBBGohByAGQQFrIgYNAAsLIAVBA08NAQwCC0EEIQkgBUEDSQ0CC0EAIQhBACEHA0AgAyAITQ0HIAEgAiAIaiIALQAAIgZNDQggBSAHTQ0JIAQgCSAGQQJ0aioCADgCACAIQQFqIgYgA08NCiABIABBAWotAAAiBk0NCyAHQQFqIgogBU8NDCAEQQRqIAkgBkECdGoqAgA4AgAgCEECaiIGIANPDQ0gASAAQQJqLQAAIgBNDQ4gB0ECaiIGIAVPDQMgBEEIaiAJIABBAnRqKgIAOAIAIAhBBGohCCAEQQxqIQQgB0EDaiEHIAxBAWsiDA0ACyABQQJ0IQoLIAlBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIApqSQ0DIABBACABIApBJ2pLGw0EIAkQogILDwsgBiAFQbD2xwAQjAcLAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAggA0Gw9ccAEIwHAAsgBiABQcD1xwAQjAcACyAHIAVB0PXHABCMBwALIAYgA0Hg9ccAEIwHAAsgBiABQfD1xwAQjAcACyAKIAVBgPbHABCMBwALIAYgA0GQ9scAEIwHAAsgACABQaD2xwAQjAcAC6QFAwd/AX4BbyMAQTBrIgMkAAJAAn8CQCAAKAIAIgQlAUGBCCUBECNFBEBBAiAEELoKIgVBAEcgBUH///8HRiIFGyEIQQEhByAFDQFBAAwCCyADQQc6ABggA0EYaiABIAIQ0AUhAAwCCyADQRhqIAQQrwogAygCGARAIAMpAyAhCkEDDAELIANBGGogBCUBECQgAygCGCIFBEAgAygCHCIErSEKQQAhB0EFDAELAkACQCAEJQEQJQRAIANBGGogBBCrBiADKQIcIQogAygCGCEGDAELIAQlARAmRQ0BIAQlARAnIQsQ2gQiBCALJgEgA0EYaiAEEKsGIAMpAhwhCiADKAIYIQYgBEGECEkNACAEEJsHCyAGQYCAgIB4Rg0AIAqnIQVBASEJIApCIIghCkEGDAELIAMgAK1CgICAgIAEhDcDECADQgE3AiQgA0EBNgIcIANBoPjHADYCGCADIANBEGo2AiAgA0EEaiADQRhqEOwDQYCAgIB4IQYgAygCCCEFIAMoAgQhBCADNQIMIQpBACEHQRELIQAgAyAKNwMgIAMgBTYCHCADIAg6ABkgAyAAOgAYIANBGGogASACENAFIQACQAJAAkACQAJAIAlFBEAgByAERXINBgwBCyAGBEAgBUEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgBmpJDQIgAUEAIAIgBkEnaksbDQMgBRCiAgsgBEUgB3INBQsgBUEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgBGpJDQIgAUEAIAIgBEEnaksbDQMgBRCiAgwEC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIANBMGokACAAC+YFAQN/IwBBIGsiAyQAIAACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAQ4oAgEBAQEBAQEBAwUBAQQBAQEBAQEBAQEBAQEBAQEBAQEBAQgBAQEBBwALIAFB3ABGDQULIAJBAXFFIAFB/wVNcg0HIAEQ5QRFDQcgA0EOakEAOgAAIANBADsBDCADIAFBFHYtANy2RToADyADIAFBBHZBD3EtANy2RToAEyADIAFBCHZBD3EtANy2RToAEiADIAFBDHZBD3EtANy2RToAESADIAFBEHZBD3EtANy2RToAECABQQFyZ0ECdiICIANBDGoiBWoiBEH7ADoAACAEQQFrQfUAOgAAIAUgAkECayICakHcADoAACADQRRqIgQgAUEPcS0A3LZFOgAAIAAgAykBDDcAACADQf0AOgAVDAgLIABCADcBAiAAQdzgADsBAAwKCyAAQgA3AQIgAEHc6AE7AQAMCQsgAEIANwECIABB3OQBOwEADAgLIABCADcBAiAAQdzcATsBAAwHCyAAQgA3AQIgAEHcuAE7AQAMBgsgAkGAAnFFDQEgAEIANwECIABB3M4AOwEADAULIAJB////B3FBgIAETw0DCyABEOECDQEgA0EYakEAOgAAIANBADsBFiADIAFBFHYtANy2RToAGSADIAFBBHZBD3EtANy2RToAHSADIAFBCHZBD3EtANy2RToAHCADIAFBDHZBD3EtANy2RToAGyADIAFBEHZBD3EtANy2RToAGiABQQFyZ0ECdiICIANBFmoiBWoiBEH7ADoAACAEQQFrQfUAOgAAIAUgAkECayICakHcADoAACADQR5qIgQgAUEPcS0A3LZFOgAAIAAgAykBFjcAACADQf0AOgAfCyAAQQhqIAQvAQA7AABBCgwDCyAAIAE2AgBBgAEhAkGBAQwCCyAAQgA3AQIgAEHcxAA7AQALQQAhAkECCzoADSAAIAI6AAwgA0EgaiQAC9MEAgZ+BH8gACAAKAI4IAJqNgI4AkAgACgCPCILRQRADAELQQQhCQJ+QQggC2siCiACIAIgCksbIgxBBEkEQEEAIQlCAAwBCyABNQAACyEDIAwgCUEBcksEQCABIAlqMwAAIAlBA3SthiADhCEDIAlBAnIhCQsgACAAKQMwIAkgDEkEfiABIAlqMQAAIAlBA3SthiADhAUgAwsgC0EDdEE4ca2GhCIDNwMwIAIgCk8EQCAAIAApAxggA4UiBCAAKQMIfCIGIAApAxAiBUINiSAFIAApAwB8IgWFIgd8IgggB0IRiYU3AxAgACAIQiCJNwMIIAAgBiAEQhCJhSIEQhWJIAQgBUIgiXwiBIU3AxggACADIASFNwMADAELIAAgAiALajYCPA8LIAIgCmsiAkEHcSEJIAJBeHEiAiAKSwRAIAApAwghBCAAKQMQIQMgACkDGCEGIAApAwAhBQNAIAQgBiABIApqKQAAIgeFIgZ8IgQgAyAFfCIFIANCDYmFIgN8IgggA0IRiYUhAyAEIAZCEImFIgRCFYkgBCAFQiCJfCIFhSEGIAhCIIkhBCAFIAeFIQUgCkEIaiIKIAJJDQALIAAgAzcDECAAIAY3AxggACAENwMIIAAgBTcDAAtBBCECAn4gCUEESQRAQQAhAkIADAELIAEgCmo1AAALIQMgCSACQQFySwRAIAEgCmogAmozAAAgAkEDdK2GIAOEIQMgAkECciECCyAAIAIgCUkEfiABIAIgCmpqMQAAIAJBA3SthiADhAUgAws3AzAgACAJNgI8C5MFAwJ7BX8BfgJAAkACQEF/IAQtAL8CIgdBD3F0IgRB/wFxQf8BRwRAQf8BIARBf3MiC0H/AXFuIQhBASAHdEGWAnFFIAdBCEtyDQFBCCAHbq0gAa1+IgxCIIhQIAynIANJcQ0CIAAgAWohCQJAIAdBCEcEQCADRQ0BQQggB2shBEF/IQEDQCABQQBIBEAgACAJRg0HIAAtAAAhCiAEIQEgAEEBaiEACyACIAogAXYgC3EgCGw6AAAgASAHayEBIAJBAWohAiADQQFrIgMNAAsMAQsgAUUNACADIAFBAWsiASABIANLG0EBaiIBQRFPBEAgAiABIAFBD3EiAUEQIAEbayIBaiADIAFrIQMgACABaiEHIAj9DyEFA0AgAiAA/QAAACIG/RYAIAX9FgBs/Q8gBv0WASAF/RYBbP0XASAG/RYCIAX9FgJs/RcCIAb9FgMgBf0WA2z9FwMgBv0WBCAF/RYEbP0XBCAG/RYFIAX9FgVs/RcFIAb9FgYgBf0WBmz9FwYgBv0WByAF/RYHbP0XByAG/RYIIAX9Fghs/RcIIAb9FgkgBf0WCWz9FwkgBv0WCiAF/RYKbP0XCiAG/RYLIAX9Fgts/RcLIAb9FgwgBf0WDGz9FwwgBv0WDSAF/RYNbP0XDSAG/RYOIAX9Fg5s/RcOIAb9Fg8gBf0WD2z9Fw/9CwAAIABBEGohACACQRBqIQIgAUEQayIBDQALIQIgByEACwNAIANFDQEgAiAALQAAIAhsOgAAIAJBAWohAiADQQFrIQMgAEEBaiIAIAlHDQALCw8LQfSXxQAQgQgAC0Gwl8UAQTRB5JfFABDrBwALQYSWxQBB5QBB7JbFABDrBwALQfyWxQBBIkGgl8UAEKsHAAvkBAIIfwR9IAEoAggiCEUEQCAAQQA2AgAPCyABIAhBAWsiAjYCCCABKAIEIgMgAkEDdGoiASgCBCEFIAEqAgAhCgJAIAJFBEAgBSEJIAohDQwBCyADKAIEIQkgAyAFNgIEIAMqAgAhDSADIAo4AgBBACEBQQEhBCAIQQRPBEAgAkECayIBQQAgASACTRshB0EAIQIDQCADIAJBA3RqIAMgBCADIARBA3RqIgJBCGoqAgAiDCAMWyAMIAIqAgAiC2BFcSIBIAFBfyALIAxgGyALIAtcGyIBQQBMIAJBBGooAgAgAkEMaigCAE0gARtqIgFBA3RqKQIANwIAIAFBAXQiBkEBciEEIAEhAiAGIAdJDQALCwJAAkAgCEECayAERgRAIAMgAUEDdGogAyAEQQN0aiIBKQIANwIAIAEgBTYCBCABIAo4AgAgBCEBDAELIAMgAUEDdGoiAiAFNgIEIAIgCjgCACABDQBBACECDAELIAogClsEQANAIAMgAUEBayIGQQF2IgJBA3RqIgcqAgAiCyALWyAKIAtfRXFBfyAKIAtgGyIEQQBMIAUgB0EEaigCAE0gBBsEQCABIQIMAwsgAyABQQN0aiAHKQIANwIAIAIhASAGQQFLDQAMAgsACwNAAkAgAyABQQFrIgRBAXYiAkEDdGoiBioCACILIAtbIAogC19FcQ0AIAUgBkEEaigCAEsNACABIQIMAgsgAyABQQN0aiAGKQIANwIAIAIhASAEQQJPDQALCyADIAJBA3RqIgEgBTYCBCABIAo4AgALIAAgCTYCCCAAIA04AgQgAEEBNgIAC4kGAQV/IwBBIGsiAiQAQQEhBAJAAkACQAJAAkACQEEBIAAoAgAiA0H/////B2ogA0GAgICAeE0bQQFrDgQBAgMEAAsgASgCACIDQcSjxwBBAiABKAIEIgYoAgwiBREAAA0EIABBBGohAAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAURAAANBiAAIAEQrgINBiABKAIAIQMgASgCBCgCDCEFDAELIANB24HCAEECIAURAAANBSACQQE6AA8gAiAGNgIEIAIgAzYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgACACQRBqEK4CDQUgAigCEEHZgcIAQQIgAigCFCgCDBEAAA0FCyADQd6OyABBASAFEQAAIQQMBAsgASgCACIDQcajxwBBDiABKAIEIgYoAgwiBREAAA0DAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0FIAAoAgQgACgCCCABELUCRQ0BDAULIANB24HCAEECIAURAAANBCACQQE6AA8gAiAGNgIEIAIgAzYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgACgCBCAAKAIIIAJBEGoQtQINBCACQdmBwgBBAhCvAw0ECyADQd6OyABBASAFEQAAIQQMAwsgASgCACIDQdSjxwBBEiABKAIEIgYoAgwiBREAAA0CAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0EIAAoAgQgACgCCCABELUCRQ0BDAQLIANB24HCAEECIAURAAANAyACQQE6AA8gAiAGNgIEIAIgAzYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgACgCBCAAKAIIIAJBEGoQtQINAyACQdmBwgBBAhCvAw0DCyADQd6OyABBASAFEQAAIQQMAgsgASgCAEHmo8cAQQwgASgCBCgCDBEAACEEDAELIAEoAgBB8qPHAEEPIAEoAgQoAgwRAAAhBAsgAkEgaiQAIAQL8QMBBH8gABDAAgJAAkAgACgCvAEiAQRAIAAoAsABIgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAsgBIgEEQCAAKALMASIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKALUASIBBEAgACgC2AEiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAAKALgASIBQYCAgIB4Rg0AIAEEQCAAKALkASIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACAEIAFBJ2pLGw0DIAMQogILIAAoAuwBIgEEQCAAKALwASIDQQRrKAIAIgJBeHEiBCABQQF0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACAEIAFBJ2pLGw0DIAMQogILIAAoAvgBIgFFDQAgACgC/AEiAEEEaygCACIDQXhxIgIgAUECdCIBQQRBCCADQQNxIgMbakkNASADQQAgAiABQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+sDAQR/IAAQ9gICQAJAIAAoAmAiAQRAIAAoAmQiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCbCIBBEAgACgCcCIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKAJ4IgEEQCAAKAJ8IgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgACgChAEiAUGAgICAeEYNACABBEAgACgCiAEiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAKQASIBBEAgACgClAEiA0EEaygCACICQXhxIgQgAUEBdCIBQQRBCCACQQNxIgIbakkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAKcASIBRQ0AIAAoAqABIgBBBGsoAgAiA0F4cSICIAFBAnQiAUEEQQggA0EDcSIDG2pJDQEgA0EAIAIgAUEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvmAwEEfyAAEPUCAkACQCAAKAJAIgEEQCAAKAJEIgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAkwiAQRAIAAoAlAiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCWCIBBEAgACgCXCIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAmQiAUGAgICAeEYNACABBEAgACgCaCIDQQRrKAIAIgJBeHEiBCABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0CIAJBACAEIAFBJ2pLGw0DIAMQogILIAAoAnAiAQRAIAAoAnQiA0EEaygCACICQXhxIgQgAUEBdCIBQQRBCCACQQNxIgIbakkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAJ8IgFFDQAgACgCgAEiAEEEaygCACIDQXhxIgIgAUECdCIBQQRBCCADQQNxIgMbakkNASADQQAgAiABQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC/EDAQR/IAAQigICQAJAIAAoAsQBIgEEQCAAKALIASIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAKALQASIBBEAgACgC1AEiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgC3AEiAQRAIAAoAuABIgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgACgC6AEiAUGAgICAeEYNACABBEAgACgC7AEiA0EEaygCACICQXhxIgQgAUECdCIBQQRBCCACQQNxIgIbakkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAL0ASIBBEAgACgC+AEiA0EEaygCACICQXhxIgQgAUEBdCIBQQRBCCACQQNxIgIbakkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAKAAiIBRQ0AIAAoAoQCIgBBBGsoAgAiA0F4cSICIAFBAnQiAUEEQQggA0EDcSIDG2pJDQEgA0EAIAIgAUEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv7BAEQfyMAQdAAayITJAAgAQRAIAJBAUYhIgNAAkACQAJAAkACQEGAgAQgASAYIhZrIhggGEGAgARPGyIXQQNsIhsgFkEDbCIcaiIUIBtJIAQgFElyRQRAIBYgF2oiGCAXSSAMIBhJcg0BIAogFEkNAiAGIBRJDQMCQCAXQQJ0IiAgFkECdCIdaiIUICBJIAggFElyRQRAQQAhHkEEIRkgAg0BQQQhFUEAIRRBACEfQQQhIQwHCyAdIBQgCEGo18EAEOoHAAsCQCAXQQlsIh8gFkEJbCIUaiIVIB9JIA4gFUlyRQRAIA0gFEECdGohISAiRQ0BQQQhFUEAIRQMBwsgFCAVIA5BmNfBABDqBwALIBdBD2wiFCAWQQ9sIhVqIhogFEkgECAaSXINBCAPIBVBAnRqIRUgAkEDRw0FIBdBFWwiHiAWQRVsIhlqIhogHkkgEiAaSXJFBEAgESAZQQJ0aiEZDAYLIBkgGiASQfjWwQAQ6gcACyAcIBQgBEHo18EAEOoHAAsgFiAYIAxB2NfBABDqBwALIBwgFCAKQcjXwQAQ6gcACyAcIBQgBkG418EAEOoHAAsgFSAaIBBBiNfBABDqBwALIBNCBDcCSCATQgI3AkAgEyAeNgI8IBMgGTYCOCATIBQ2AjQgEyAVNgIwIBMgHzYCLCATICE2AiggEyAgNgIkIBMgByAdQQJ0ajYCICATIBs2AhwgEyAFIBxBAnQiFGo2AhggEyAbNgIUIBMgCSAUajYCECATIBc2AgwgEyALIB1qNgIIIBMgGzYCBCATIAMgFGo2AgAgACAWIBcgExCXASABIBhLDQALCyAAEKMBIBNB0ABqJAAL+gQBEH8jAEHQAGsiEyQAIAEEQCACQQFGISIDQAJAAkACQAJAAkBBgIAEIAEgGCIWayIYIBhBgIAETxsiF0EDbCIbIBZBA2wiHGoiFCAbSSAEIBRJckUEQCAWIBdqIhggF0kgDCAYSXINASAKIBRJDQIgBiAUSQ0DAkAgF0ECdCIgIBZBAnQiHWoiFCAgSSAIIBRJckUEQEEAIR5BBCEZIAINAUEEIRVBACEUQQAhH0EEISEMBwsgHSAUIAhBqNfBABDqBwALAkAgF0EJbCIfIBZBCWwiFGoiFSAfSSAOIBVJckUEQCANIBRBAnRqISEgIkUNAUEEIRVBACEUDAcLIBQgFSAOQZjXwQAQ6gcACyAXQQ9sIhQgFkEPbCIVaiIaIBRJIBAgGklyDQQgDyAVQQJ0aiEVIAJBA0cNBSAXQRVsIh4gFkEVbCIZaiIaIB5JIBIgGklyRQRAIBEgGUECdGohGQwGCyAZIBogEkH41sEAEOoHAAsgHCAUIARB6NfBABDqBwALIBYgGCAMQdjXwQAQ6gcACyAcIBQgCkHI18EAEOoHAAsgHCAUIAZBuNfBABDqBwALIBUgGiAQQYjXwQAQ6gcACyATQgQ3AkggE0ICNwJAIBMgHjYCPCATIBk2AjggEyAUNgI0IBMgFTYCMCATIB82AiwgEyAhNgIoIBMgIDYCJCATIAcgHUECdGo2AiAgEyAbNgIcIBMgBSAcQQJ0IhRqNgIYIBMgGzYCFCATIAkgFGo2AhAgEyAXNgIMIBMgCyAdajYCCCATIBs2AgQgEyADIBRqNgIAIAAgFiAXIBMQfiABIBhLDQALCyAAENQBIBNB0ABqJAALhAUCC38BeyMAQTBrIgQkACAEQQA2AgggBEEANgIsIARBDGohCCAEQSxqIQtBCCEHAkACQAJAAkACQAJ/IAIgAWsiCUEAIAIgCU8bIglBCUkEQCAIIQogCwwBCwJAIAlBAWtnIgMEQCAEIARBCGpBfyADdkEBahDoAyAEKAIAIgNBgYCAgHhGDQEgAw0DC0HYlccAQRFB1MzHABDrBwALIAQoAiwiB0EJSQRAIAchAyAIIQpBCCEHIAsMAQsgBCgCDCEDIAQoAhAhCiAICyEJIAMgB08NAiAHIANBf3NqIgUgAiABIAEgAkkbIg0gAWsiBiAFIAZJG0EBaiIGQQRNDQEgCiADQQJ0aiEFIAH9Ef0MAAAAAAEAAAACAAAAAwAAAP2uASEOIAYgBkEDcSIGQQQgBhtrIgwhBgNAIAUgDv0LAgAgBUEQaiEFIA79DAQAAAAEAAAABAAAAAQAAAD9rgEhDiAGQQRrIgYNAAsgASAMaiEBIAMgDGohAwwBCwALIAogA0ECdGohBQNAIAEgDUYNAiAFIAE2AgAgBUEEaiEFIAFBAWohASAHIANBAWoiA0cNAAsgByEDCyAJIAM2AgAgASACTw0BA0ACfyAEKAIsIgZBCUkEQCAGIQUgCCEHQQghBiALDAELIAQoAgwhBSAEKAIQIQcgCAshAyAFIAZGBEAgBEEIahDNBiAEKAIMIQUgBCgCECEHIAghAwsgByAFQQJ0aiABNgIAIAMgAygCAEEBajYCACABQQFqIgEgAkcNAAsMAQsgCSADNgIACyAAIAT9AAII/QsCACAAQSBqIARBKGopAgA3AgAgAEEQaiAEQRhq/QACAP0LAgAgBEEwaiQAC94EAQt/IwBBEGsiDSQAIAMEQANAAkACQAJAAkAgBSALRwRAIAIgC2ohBiAEIAtBAnRqKAIAIg5FBEAgASAGTQ0CIAAgBkEYbGoiCEEEQRQgCCgCFEEESyIGG2ooAgBFDQUgCEEEaiAIQRRqIAYbQQA2AgAMBQsgASAGSw0CIAYgAUHUw8cAEIwHAAsgBSAFQbTDxwAQjAcACyAGIAFBxMPHABCMBwwBCyAAIAZBGGxqIgooAhQiByEGIAdBBU8EQCAKKAIEIQYLIApBFGohDCAKQQRqIQggCkEEQRQgB0EESyIJG2ooAgAEQCAIIAwgCRtBADYCACAMKAIAIQcLQQEgBiAGQQFNGyEJIAciBkEFTwRAIAgoAgAhBgsgBiAJTwRAIAYgCU0NAiAJIAggDCAHQQRLGyIGKAIATw0CIAYgCTYCAAwCCwJAIAkgBmsiDyAHQQQgB0EESyIGGyAIKAIAIAcgBhsiBmtNDQACQCAGIAYgD2oiBksNAEF/IAZBAWtndkEAIAZBAk8bIgZBf0YNACANQQhqIAogBkEBahD1AyANKAIIIgZBgYCAgHhGDQEgBg0CC0HYlccAQRFB1MzHABDrBwALA0ACfyAMKAIAIhBBBUkEQCAQIQcgCCEJQQQhECAMDAELIAooAgQhByAKKAIIIQkgCAshBiAHIBBGBEAgChDUBiAKKAIEIQcgCigCCCEJIAghBgsgCSAHQQJ0aiAONgIAIAYgBigCAEEBajYCACAOQQFqIQ4gD0EBayIPDQALDAELAAsgC0EBaiILIANHDQALCyANQRBqJAAL3gQBC38jAEEQayINJAAgAwRAA0ACQAJAAkACQCAFIAtHBEAgAiALaiEGIAQgC0ECdGooAgAiDkUEQCABIAZNDQIgACAGQRhsaiIIQQRBFCAIKAIUQQRLIgYbaigCAEUNBSAIQQRqIAhBFGogBhtBADYCAAwFCyABIAZLDQIgBiABQaTGxwAQjAcACyAFIAVBhMbHABCMBwALIAYgAUGUxscAEIwHDAELIAAgBkEYbGoiCigCFCIHIQYgB0EFTwRAIAooAgQhBgsgCkEUaiEMIApBBGohCCAKQQRBFCAHQQRLIgkbaigCAARAIAggDCAJG0EANgIAIAwoAgAhBwtBASAGIAZBAU0bIQkgByIGQQVPBEAgCCgCACEGCyAGIAlPBEAgBiAJTQ0CIAkgCCAMIAdBBEsbIgYoAgBPDQIgBiAJNgIADAILAkAgCSAGayIPIAdBBCAHQQRLIgYbIAgoAgAgByAGGyIGa00NAAJAIAYgBiAPaiIGSw0AQX8gBkEBa2d2QQAgBkECTxsiBkF/Rg0AIA1BCGogCiAGQQFqEPUDIA0oAggiBkGBgICAeEYNASAGDQILQdiVxwBBEUHUzMcAEOsHAAsDQAJ/IAwoAgAiEEEFSQRAIBAhByAIIQlBBCEQIAwMAQsgCigCBCEHIAooAgghCSAICyEGIAcgEEYEQCAKENQGIAooAgQhByAKKAIIIQkgCCEGCyAJIAdBAnRqIA42AgAgBiAGKAIAQQFqNgIAIA5BAWohDiAPQQFrIg8NAAsMAQsACyALQQFqIgsgA0cNAAsLIA1BEGokAAv2BAEQfyMAQdAAayITJAAgAQRAIAJBAUYhIgNAAkACQAJAAkACQEGAgAQgASAYIhZrIhggGEGAgARPGyIXQQNsIhsgFkEDbCIcaiIUIBtJIAQgFElyRQRAIBYgF2oiGCAXSSAMIBhJcg0BIAogFEkNAiAGIBRJDQMCQCAXQQJ0IiAgFkECdCIdaiIUICBJIAggFElyRQRAQQAhHkEEIRkgAg0BQQQhFUEAIRRBACEfQQQhIQwHCyAdIBQgCEGo18EAEOoHAAsCQCAXQQlsIh8gFkEJbCIUaiIVIB9JIA4gFUlyRQRAIA0gFEECdGohISAiRQ0BQQQhFUEAIRQMBwsgFCAVIA5BmNfBABDqBwALIBdBD2wiFCAWQQ9sIhVqIhogFEkgECAaSXINBCAPIBVBAnRqIRUgAkEDRw0FIBdBFWwiHiAWQRVsIhlqIhogHkkgEiAaSXJFBEAgESAZQQJ0aiEZDAYLIBkgGiASQfjWwQAQ6gcACyAcIBQgBEHo18EAEOoHAAsgFiAYIAxB2NfBABDqBwALIBwgFCAKQcjXwQAQ6gcACyAcIBQgBkG418EAEOoHAAsgFSAaIBBBiNfBABDqBwALIBNCBDcCSCATQgI3AkAgEyAeNgI8IBMgGTYCOCATIBQ2AjQgEyAVNgIwIBMgHzYCLCATICE2AiggEyAgNgIkIBMgByAdQQJ0ajYCICATIBs2AhwgEyAFIBxBAnQiFGo2AhggEyAbNgIUIBMgCSAUajYCECATIBc2AgwgEyALIB1qNgIIIBMgGzYCBCATIAMgFGo2AgAgACAWIBcgExCTAiABIBhLDQALCyATQdAAaiQAC/YEARB/IwBB0ABrIhMkACABBEAgAkEBRiEiA0ACQAJAAkACQAJAQYCABCABIBgiFmsiGCAYQYCABE8bIhdBA2wiGyAWQQNsIhxqIhQgG0kgBCAUSXJFBEAgFiAXaiIYIBdJIAwgGElyDQEgCiAUSQ0CIAYgFEkNAwJAIBdBAnQiICAWQQJ0Ih1qIhQgIEkgCCAUSXJFBEBBACEeQQQhGSACDQFBBCEVQQAhFEEAIR9BBCEhDAcLIB0gFCAIQajXwQAQ6gcACwJAIBdBCWwiHyAWQQlsIhRqIhUgH0kgDiAVSXJFBEAgDSAUQQJ0aiEhICJFDQFBBCEVQQAhFAwHCyAUIBUgDkGY18EAEOoHAAsgF0EPbCIUIBZBD2wiFWoiGiAUSSAQIBpJcg0EIA8gFUECdGohFSACQQNHDQUgF0EVbCIeIBZBFWwiGWoiGiAeSSASIBpJckUEQCARIBlBAnRqIRkMBgsgGSAaIBJB+NbBABDqBwALIBwgFCAEQejXwQAQ6gcACyAWIBggDEHY18EAEOoHAAsgHCAUIApByNfBABDqBwALIBwgFCAGQbjXwQAQ6gcACyAVIBogEEGI18EAEOoHAAsgE0IENwJIIBNCAjcCQCATIB42AjwgEyAZNgI4IBMgFDYCNCATIBU2AjAgEyAfNgIsIBMgITYCKCATICA2AiQgEyAHIB1BAnRqNgIgIBMgGzYCHCATIAUgHEECdCIUajYCGCATIBs2AhQgEyAJIBRqNgIQIBMgFzYCDCATIAsgHWo2AgggEyAbNgIEIBMgAyAUajYCACAAIBYgFyATEOIBIAEgGEsNAAsLIBNB0ABqJAALggcCBn8SfSAAQQxqIQcDQCAALQCMAiAEIAUgAiAAKAKIAmoQvQQhEiAALQCUAiAEIAUgAiAAKAKQAmoQvQQhEyAALQCcAiAEIAUgAiAAKAKYAmoQvQQhFCAALQCkAiAEIAUgAiAAKAKgAmoQvQQhFSAALQCsAiAEIAUgAiAAKAKoAmoQvQQhFiAALQC0AiAEIAUgAiAAKAKwAmoQvQQhFyAALQC8AiAEIAUgAiAAKAK4AmoQvQQhGCAALQDEAiAEIAUgAiAAKALAAmoQvQQhGSAALQDMAiAEIAUgAiAAKALIAmoQvQQhGiAALQDUAiAEIAUgAiAAKALQAmoQvQQhGyAALQDcAiAEIAUgAiAAKALYAmoQvQQhHCAALQDkAiAEIAUgAiAAKALgAmoQvQQhHUMAAAAAIQxDAAAAACENIAAtANwBIgZBCEcEQCAGIAQgBSACIAAoAtgBahC9BCENCyAALQDkASIGQQhHBEAgBiAEIAUgAiAAKALgAWoQvQQhDAtDAAAAACEOIAAtAOwBIgZBCEcEQCAGIAQgBSACIAAoAugBahC9BCEOC0MAAIA/IQ9DAACAPyEQIAAtAPQBIgZBCEcEQCAGIAQgBSACIAAoAvABahC9BCEQCyAALQD8ASIGQQhHBEAgBiAEIAUgAiAAKAL4AWoQvQQhDwtDAACAPyERIAAtAIQCIgZBCEcEQCAGIAQgBSACIAAoAoACahC9BCERCyAAKAIUIgogACgCDEYEQCMAQSBrIgYkAAJAIAcoAgAiCEG4nI4HSwR/QQAFQQQgCEEBdCIJIAlBBE0bIglByABsIQsgBiAIBH8gBiAIQcgAbDYCHCAGIAcoAgQ2AhRBBAVBAAs2AhggBkEIakEEIAsgBkEUahCFByAGKAIIQQFHDQEgBigCECEHIAYoAgwLIAdB9NrHABCTCQALIAYoAgwhCCAHIAk2AgAgByAINgIEIAZBIGokAAsgACgCECAKQcgAbGoiBiAROAJEIAYgDzgCQCAGIBA4AjwgBiAOOAI4IAYgDDgCNCAGIA04AjAgBiAdOAIsIAYgHDgCKCAGIBs4AiQgBiAaOAIgIAYgGTgCHCAGIBg4AhggBiAXOAIUIAYgFjgCECAGIBU4AgwgBiAUOAIIIAYgEzgCBCAGIBI4AgAgACAKQQFqNgIUIAIgA2ohAiABQQFrIgENAAsL6QQBCX8jAEEgayIHJAACQAJAAkACQAJAIAAtALgBQQFHDQAgACgCrAEgACgCsAEiBkECdCAAKAK0ASIFIAZqQQJ0EOEIIQYgBUECdCIFIAAoAmQiCEsNASAAKAJgIQggByAGELgKIgk2AgAgByAFNgIEIAUgCUcNBCAGIAggBRDgCSAGQYQISQ0AIAYQmwcLIABCADcCsAEgAEG4AWpBADoAAAJAAkAgACgCMEUNACAAKAI0IAFBAnQgASACakECdBDhCCEJAkAgAkECdCIBIAAoAmQiBk0EQCAAIAE2AmQgACgCYCEIIAEhAgwBCyAGIQUgASAGayIKIAAoAlwgBmtLBEAgAEHcAGogBiAKQQRBBBCkBSAAKAJkIQULIAAoAmAiCCAFQQJ0IgxqIQsgCkECTwRAIAEgBkF/c2pBAnQiDQRAIAtBACAN/AsACyACQQR0IAZBAnRrIAhqIAxqQQRrIQsgBSAKakEBayEFCyALQQA2AgAgACAFQQFqIgI2AmQgASACSw0ECyAHIAkQuAoiADYCACAHIAE2AgQgACABRw0FIAggASAJEOEJIAhBCGohCCAEQQJ0IQZBACEAA0AgAEECaiIFIAJPDQUgACAGRg0CIAMgCCgCADsBACAIQRBqIQggA0ECaiEDIAEgAEEEaiIARw0ACyAJQYQISQ0AIAkQmwcLIAdBIGokAA8LIAQgBEGM0sAAEIwHAAtBACAFIAhB/OvAABDqBwALQQAgASACQZzSwAAQ6gcACyAFIAJB/NHAABCMBwALIAdBADYCCEEAIAcgB0EEaiAHQQhqQeD5xAAQ9QcAC+UEAQl/IwBBIGsiByQAAkACQAJAAkACQCAALQC4AUEBRw0AIAAoAqwBIAAoArABIgZBAnQgACgCtAEiBSAGakECdBDhCCEGIAVBAnQiBSAAKAJkIghLDQEgACgCYCEIIAcgBhC4CiIJNgIAIAcgBTYCBCAFIAlHDQQgBiAIIAUQ4AkgBkGECEkNACAGEJsHCyAAQgA3ArABIABBuAFqQQA6AAACQAJAIAAoAjBFDQAgACgCNCABQQJ0IAEgAmpBAnQQ4QghCQJAIAJBAnQiASAAKAJkIgZNBEAgACABNgJkIAAoAmAhCCABIQIMAQsgBiEFIAEgBmsiCiAAKAJcIAZrSwRAIABB3ABqIAYgCkEEQQQQpAUgACgCZCEFCyAAKAJgIgggBUECdCIMaiELIApBAk8EQCABIAZBf3NqQQJ0Ig0EQCALQQAgDfwLAAsgAkEEdCAGQQJ0ayAIaiAMakEEayELIAUgCmpBAWshBQsgC0EANgIAIAAgBUEBaiICNgJkIAEgAksNBAsgByAJELgKIgA2AgAgByABNgIEIAAgAUcNBSAIIAEgCRDhCSAIQQxqIQggBEECdCEGQQAhAANAIABBA2oiBSACTw0FIAAgBkYNAiAAIANqIAgoAgA2AgAgCEEQaiEIIAEgAEEEaiIARw0ACyAJQYQISQ0AIAkQmwcLIAdBIGokAA8LIAQgBEG80sAAEIwHAAtBACAFIAhB/OvAABDqBwALQQAgASACQczSwAAQ6gcACyAFIAJBrNLAABCMBwALIAdBADYCCEEAIAcgB0EEaiAHQQhqQeD5xAAQ9QcAC9QFAQV/IwBBIGsiAiQAAkACQAJAAkACQCAALQAAQQFrDgMBAgMAC0EBIQQgASgCACIDQZCrxwBBBSABKAIEIgYoAgwiBREAAA0DAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0FIAMgAC0AAUECdCIAKALolkkgACgCqJZJIAURAABFDQEMBQsgA0HbgcIAQQIgBREAAA0EIAIgBjYCFCACIAM2AhAgAkEBOgAAIAAtAAFBAnQiACgCqJdJIQEgACgC6JdJIQAgAiACNgIYIAJBEGoiBiAAIAEQrwMNBCAGQdmBwgBBAhCvAw0ECyADQd6OyABBASAFEQAAIQQMAwtBASEEIAEoAgAiA0GVq8cAQQQgASgCBCIGKAIMIgURAAANAgJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAURAAANBCAAQQhqKAIAIABBDGooAgAgARC1AkUNAQwECyADQduBwgBBAiAFEQAADQMgAkEBOgAPIAIgBjYCBCACIAM2AgAgAkHggcIANgIUIAIgASkCCDcCGCAAQQhqKAIAIABBDGooAgAgAiACQQ9qNgIIIAIgAjYCECACQRBqELUCDQMgAkHZgcIAQQIQrwMNAwsgA0HejsgAQQEgBREAACEEDAILQQEhBCABKAIAIgNBmavHAEENIAEoAgQiBigCDCIFEQAADQEgAEEEaiEAAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0DIAAgARCmAkUNAQwDCyADQduBwgBBAiAFEQAADQIgAkEBOgAPIAIgBjYCBCACIAM2AgAgAkHggcIANgIUIAIgASkCCDcCGCACIAJBD2o2AgggAiACNgIQIAAgAkEQahCmAg0CIAJB2YHCAEECEK8DDQILIANB3o7IAEEBIAURAAAhBAwBCyABKAIAQaarxwBBByABKAIEKAIMEQAAIQQLIAJBIGokACAEC8UFAgV/An4jAEEwayICJAAgASgCDCEGAkACQAJAAkACQCABKAIUIgMgASgCECIFSQRAA0ACQCADIAZqLQAAIgRBCWsOJQAABAQABAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAMECyABIANBAWoiAzYCFCADIAVHDQALIAUhAwtBASEEIAIgBiAFIANBAWoiASAFIAEgBUkbEPkBIAIoAgQhASACKAIAIQVBFBBxIgNFDQIgAyAFNgIMIANBBTYCACADIAE2AhAMBAtBASEEIAEgA0EBajYCFCACQQhqIAFBABDHAyACKQMIIghCA1ENAiACKQMQIQcCfwJAAkACQAJAIAinQQFrDgIAAQMLIAdCgICAgBBUDQEgAkEBOgAYIAIgBzcDICACQRhqIAJBL2pBqOfAABDeBgwDCyAHQoCAgIAQVA0AIAJBAjoAGCACIAc3AyAgAkEYaiACQS9qQajnwAAQ3gYMAgsgB6chA0EAIQQMBQsgAkEDOgAYIAIgBzcDICACQRhqIAJBL2pBqOfAABDfBgsgARDrBSEDDAMLIARBMGtB/wFxQQpPBEBBASEEIAEgAkEvakGo58AAEO4BIAEQ6wUhAwwDC0EBIQQgAkEIaiABQQEQxwMgAikDCCIIQgNRBEAgAigCECEDDAMLIAIpAxAhBwJ/AkACQAJAAkAgCKdBAWsOAgABAwsgB0KAgICAEFQNASACQQE6ABggAiAHNwMgIAJBGGogAkEvakGo58AAEN4GDAMLIAdCgICAgBBUDQAgAkECOgAYIAIgBzcDICACQRhqIAJBL2pBqOfAABDeBgwCCyAHpyEDQQAhBAwECyACQQM6ABggAiAHNwMgIAJBGGogAkEvakGo58AAEN8GCyABEOsFIQMMAgsACyACKAIQIQMLIAAgAzYCBCAAIAQ2AgAgAkEwaiQAC8AEAQV/IAEoAgghAwJ/IAEoAgQiAkEQdiIBQf//AXFFBEAgAkGAgHxxDAELIAFB/wdxIQIgAUGAgAJxIQQgAUGA+AFxIgVBgPgBRgRAIARBEHQiBEGAgID8B3IgAkUNARogBCABQQ10ckGAgID+B3IMAQsgBEEQdCIBIAVBDXRBgICA/ABxIAJBDXRyQYCAgMADanIgBQ0AGiACIAJnQRBrIgJB//8DcUEIanRB////A3EgAUGAgIDYA3IgAkEXdGtyCyEGIANBEHYhAQJ/IANB//8BcQRAIANB/wdxIQIgA0GAgAJxIQQgA0GA+AFxIgVBgPgBRwRAIARBEHQiBCAFQQ10QYCAgPwAcSACQQ10ckGAgIDAA2pyIAUNAhogAiACZ0EQayICQf//A3FBCGp0Qf///wNxIARBgICA2ANyIAJBF3RrcgwCCyAEQRB0IgQgAkENdHJBgICA/gdyIAINARogBEGAgID8B3IMAQsgA0EQdAshBSAAAn8gAUH//wFxBEAgAUH/B3EhAyABQYCAAnEhAiABQYD4AXEiBEGA+AFHBEAgAkEQdCIBIARBDXRBgICA/ABxIANBDXRyQYCAgMADanIgBA0CGiADIANnQRBrIgNB//8DcUEIanRB////A3EgAUGAgIDYA3IgA0EXdGtyDAILIAFBDXQgAkEQdCIBckGAgID+B3IgAw0BGiABQYCAgPwHcgwBCyADQYCAfHELvhCJBDgCCCAAIAW+EIkEOAIEIAAgBr4QiQQ4AgAL5wQCB38BewJAAkAgACgCCCIHQYCAgMABcUUNAAJAAkACQAJAIAdBgICAgAFxBEAgAC8BDiIDDQFBACECDAILIAJBEE8EQCABIAIQxwIhAwwECyACRQRAQQAhAgwECyACQQNxIQUCQCACQQRJBEAMAQsgAkEMcSEGA0AgAyABIARq/VwAAP0Mv7+/v7+/v7+/v7+/v7+/v/0nIgr9GwBBAXFqIAr9hwH9pwEiCv0bAWsgCv0bAmsgCv0bA2shAyAGIARBBGoiBEcNAAsLIAVFDQMgASAEaiEEA0AgAyAELAAAQb9/SmohAyAEQQFqIQQgBUEBayIFDQALDAMLIAEgAmohCUEAIQIgASEEIAMhBQNAIAQiBiAJRg0CAn8gBEEBaiAELAAAIghBAE4NABogBkECaiAIQWBJDQAaIAZBA2ogCEFwSQ0AGiAGQQRqCyIEIAZrIAJqIQIgBUEBayIFDQALC0EAIQULIAMgBWshAwsgAyAALwEMIgRPDQAgBCADayEGQQAhA0EAIQUCQAJAAkAgB0EddkEDcUEBaw4CAAECCyAGIQUMAQsgBkH+/wNxQQF2IQULIAdB////AHEhCCAAKAIEIQcgACgCACEAA0AgA0H//wNxIAVB//8DcUkEQEEBIQQgA0EBaiEDIAAgCCAHKAIQEQIARQ0BDAMLC0EBIQQgACABIAIgBygCDBEAAA0BIAYgBWtB//8DcSEBQQAhAwNAIAEgA0H//wNxTQRAQQAPCyADQQFqIQMgACAIIAcoAhARAgBFDQALDAELIAAoAgAgASACIAAoAgQoAgwRAAAhBAsgBAvoBQMIfwV9BHsCQAJAAkACQEGACBBxIgUEQCADQQJ2IQr9DAAAAAABAAAAAgAAAAMAAAAhEQNAIAQgBWoiByAR/fsB/QwAAH9DAAB/QwAAf0MAAH9DIhL95wH9DAAAAL8AAAC/AAAAvwAAAL8iE/3kAf0M8wS1P/MEtT/zBLU/8wS1PyIU/eYB/QsCACAHQRBqIBH9DAQAAAAEAAAABAAAAAQAAAD9rgH9+wEgEv3nASAT/eQBIBT95gH9CwIAIBH9DAgAAAAIAAAACAAAAAgAAAD9rgEhESAEQSBqIgRBgAhHDQALIANBBEkNBEEAIQQDQAJAAkACQAJAIAEgBEsEQCAEQQFqIgcgAU8NASAEQQJqIgggAU8NAkMAAIA/IAUgACAEaiIGLQAAQQJ0aioCACIOIA6UIAUgBkEBai0AAEECdGoqAgAiDyAPlJIgBSAGQQJqLQAAQQJ0aioCACIQIBCUkpNDAAAAABDgCCEMAkAgASAEQQNqIglLBEAgDJEhDSAOIQwgBkEDai0AACIGQfwBayILDgIGAQULIAkgAUGE78cAEIwHAAsgDSEMDAQLIAQgAUHU7scAEIwHAAsgByABQeTuxwAQjAcACyAIIAFB9O7HABCMBwALIA8hDAsgAyAETQ0CIAIgDDgCACADIAdNDQMgAkEEaiAPIA0gECALQQJGGyAGQf4BSRs4AgAgAyAITQ0EIAJBCGogDSAQIAZB/wFGGzgCACADIAlLBEAgAkEMaiAOIA0gCxs4AgAgAkEQaiECIARBBGohBCAKQQFrIgoNAQwGCwsgCSADQcTvxwAQjAcLAAsgBCADQZTvxwAQjAcACyAHIANBpO/HABCMBwALIAggA0G078cAEIwHAAsCQCAFQQRrKAIAIgBBeHFBhAhBiAggAEEDcSIBG08EQCABQQAgAEGoCE8bDQEgBRCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC8YEAQp/IwBBIGsiBCQAIARBADYCCCAEQQA2AhxBBCEGIARBDGohCCAEQRxqIQsCQAJAAkACQAJAAn8gAiABayIFQRFJBEAgCCEJIAsMAQsgBCAEQQhqQX8gBUECdkEBa2d2QQFqEPUDIAQoAgAiA0GBgICAeEcEQCADDQJB2JXHAEERQdTMxwAQ6wcACyAEKAIcIgZBBUkEQCAGIQMgCCEJQQQhBiALDAELIAQoAgwhAyAEKAIQIQkgCAshCiADIAZPDQIgBUEDcSAFQQJ2IgUgBiADQX9zaiIHIAUgB0kbIgdBB01yDQEgA0ECdCAJaiIFIAFrQRBJDQEgAyAHQQFqIgcgB0EDcSIHQQQgBxtrIgxqIQMgASAMQQJ0agNAIAUgAf0AAgD9CwIAIAFBEGohASAFQRBqIQUgDEEEayIMDQALIQEMAQsACyAJIANBAnRqIQUDQCABIAJGDQIgBSABKAIANgIAIAVBBGohBSABQQRqIQEgBiADQQFqIgNHDQALIAYhAwsgCiADNgIAIAEgAkYNAQNAAn8gBCgCHCIGQQVJBEAgBiEFIAghCkEEIQYgCwwBCyAEKAIMIQUgBCgCECEKIAgLIQMgASgCACEJIAUgBkYEQCAEQQhqENQGIAQoAgwhBSAEKAIQIQogCCEDCyAKIAVBAnRqIAk2AgAgAyADKAIAQQFqNgIAIAFBBGoiASACRw0ACwwBCyAKIAM2AgALIAAgBP0AAgj9CwIAIABBEGogBEEYaikCADcCACAEQSBqJAALtgQBBH8gAS8BHiECAn8gAS8BHCIEQf//AXFFBEAgBEEQdAwBCyAEQf8HcSEDIARBgIACcSEFIARBgPgBcSIEQYD4AUYEQCAFQRB0IgRBgICA/AdyIANFDQEaIAQgA0ENdHJBgICA/gdyDAELIAVBEHQiBSAEQQ10QYCAgPwAcSADQQ10ckGAgIDAA2pyIAQNABogAyADZ0EQayIDQf//A3FBCGp0Qf///wNxIAVBgICA2ANyIANBF3RrcgshBSABLwEgIQECfyACQf//AXEEQCACQf8HcSEDIAJBgIACcSEEIAJBgPgBcSICQYD4AUcEQCAEQRB0IgQgAkENdEGAgID8AHEgA0ENdHJBgICAwANqciACDQIaIAMgA2dBEGsiAkH//wNxQQhqdEH///8DcSAEQYCAgNgDciACQRd0a3IMAgsgBEEQdCICIANBDXRyQYCAgP4HciADDQEaIAJBgICA/AdyDAELIAJBEHQLIQMgAAJ/IAFB//8BcQRAIAFB/wdxIQAgAUGAgAJxIQIgAUGA+AFxIgFBgPgBRwRAIAJBEHQiAiABQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2pyIAENAhogACAAZ0EQayIAQf//A3FBCGp0Qf///wNxIAJBgICA2ANyIABBF3RrcgwCCyACQRB0IgEgAEENdHJBgICA/gdyIAANARogAUGAgID8B3IMAQsgAUEQdAu+EIkE/RMgBb4QiQT9IAAgA74QiQT9IAH9CwQAC/gDAQd/IABBvAJqEMACAkACQCAAKAKwAiIBBEAgACgCtAIiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAAKAKQAUECRg0AIAAoAvgBIQMgACgC/AEiAgRAIANBJGohAQNAIAFBBGsoAgAiBEGAgICAeHJBgICAgHhHBEAgASgCACIGQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyAEakkNBCAFQQAgByAEQSdqSxsNBSAGEKICCyABQTBqIQEgAkEBayICDQALCyAAKAL0ASIBBEAgA0EEaygCACICQXhxIgQgAUEwbCIBQQRBCCACQQNxIgIbckkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAKAAiIBQYCAgIB4ckGAgICAeEYNACAAKAKEAiIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAgBBAkYNACAAKAJcIgFFDQAgACgCYCIAQQRrKAIAIgNBeHEiAiABQShsIgFBBEEIIANBA3EiAxtqSQ0BIANBACACIAFBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL9QMBB38gAEH4AWoQ9gICQAJAIAAoAvgCIgEEQCAAKAL8AiIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAgBBAkYNACAAKAJoIQMgACgCbCICBEAgA0EkaiEBA0AgAUEEaygCACIEQYCAgIB4ckGAgICAeEcEQCABKAIAIgZBBGsoAgAiBUF4cSIHQQRBCCAFQQNxIgUbIARqSQ0EIAVBACAHIARBJ2pLGw0FIAYQogILIAFBMGohASACQQFrIgINAAsLIAAoAmQiAQRAIANBBGsoAgAiAkF4cSIEIAFBMGwiAUEEQQggAkEDcSICG3JJDQIgAkEAIAQgAUEnaksbDQMgAxCiAgsgACgCcCIBQYCAgIB4ckGAgICAeEYNACAAKAJ0IgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgACgCiAFBAkYNACAAKALkASIBRQ0AIAAoAugBIgBBBGsoAgAiA0F4cSICIAFBKGwiAUEEQQggA0EDcSIDG2pJDQEgA0EAIAIgAUEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv1AwEHfyAAQfgBahD1AgJAAkAgACgC2AIiAQRAIAAoAtwCIgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgACgCAEECRg0AIAAoAmghAyAAKAJsIgIEQCADQSRqIQEDQCABQQRrKAIAIgRBgICAgHhyQYCAgIB4RwRAIAEoAgAiBkEEaygCACIFQXhxIgdBBEEIIAVBA3EiBRsgBGpJDQQgBUEAIAcgBEEnaksbDQUgBhCiAgsgAUEwaiEBIAJBAWsiAg0ACwsgACgCZCIBBEAgA0EEaygCACICQXhxIgQgAUEwbCIBQQRBCCACQQNxIgIbckkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAJwIgFBgICAgHhyQYCAgIB4Rg0AIAAoAnQiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAAKAKIAUECRg0AIAAoAuQBIgFFDQAgACgC6AEiAEEEaygCACIDQXhxIgIgAUEobCIBQQRBCCADQQNxIgMbakkNASADQQAgAiABQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC/gDAQd/IABBvAJqEIoCAkACQCAAKAKwAiIBBEAgACgCtAIiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAAKAKQAUECRg0AIAAoAvgBIQMgACgC/AEiAgRAIANBJGohAQNAIAFBBGsoAgAiBEGAgICAeHJBgICAgHhHBEAgASgCACIGQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyAEakkNBCAFQQAgByAEQSdqSxsNBSAGEKICCyABQTBqIQEgAkEBayICDQALCyAAKAL0ASIBBEAgA0EEaygCACICQXhxIgQgAUEwbCIBQQRBCCACQQNxIgIbckkNAiACQQAgBCABQSdqSxsNAyADEKICCyAAKAKAAiIBQYCAgIB4ckGAgICAeEYNACAAKAKEAiIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAgBBAkYNACAAKAJcIgFFDQAgACgCYCIAQQRrKAIAIgNBeHEiAiABQShsIgFBBEEIIANBA3EiAxtqSQ0BIANBACACIAFBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL6gQBB38jAEEgayIEJAAgASgCACIHKAIMIQYCQAJAAkAgBygCFCICIAcoAhAiA0kEQANAIAIgBmotAAAiCEEJayIFQRdLQQEgBXRBk4CABHFFcg0CIAcgAkEBaiICNgIUIAIgA0cNAAsgAyECC0EBIQUgBEEYaiAGIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCHCEDIAQoAhghAUEUEHEiAkUNAiACIAE2AgwgAkECNgIAIAAgAjYCBCACIAM2AhAMAQsgCEHdAEYEQEEAIQUgAEEAOgABDAELAkAgAS0ABEUEQCACQQFqIQIgCEEsRgRAIAcgAjYCFCACIANJBEADQCACIAZqLQAAIgVBCWsiAUEXS0EBIAF0QZOAgARxRXINBCAHIAJBAWoiAjYCFCACIANHDQALIAMhAgtBASEFIAQgBiADIAJBAWoiASADIAEgA0kbEPkBIAQoAgQhAyAEKAIAIQFBFBBxIgJFDQQgAiABNgIMIAJBBTYCACAAIAI2AgQgAiADNgIQDAMLIARBEGogBiADIAIgAyACIANJGxD5ASAEKAIUIQMgBCgCECEBQRQQcSICRQ0DIAIgATYCDCACQQc2AgAgACACNgIEIAIgAzYCEEEBIQUMAgsgAEEBOgABQQAhBSABQQA6AAQMAQsgBUHdAEcEQCAAQQE6AAFBACEFDAELQQEhBSAEQQhqIAYgAyACQQFqIgEgAyABIANJGxD5ASAEKAIMIQMgBCgCCCEBQRQQcSICRQ0BIAIgATYCDCACQRU2AgAgACACNgIEIAIgAzYCEAsgACAFOgAAIARBIGokAA8LAAvlAwEHfyAAKAKwASEBAkACQCAAKAK0ASIFBEAgASECA0AgAkEoaigCACIGBEAgAkEsaigCACIHQQRrKAIAIgRBeHEiA0EEQQggBEEDcSIEGyAGakkNAyAEQQAgAyAGQSdqSxsNBCAHEKICCyACEL8EIAJBOGohAiAFQQFrIgUNAAsLIAAoAqwBIgQEQCABQQRrKAIAIgJBeHEiAyAEQThsIgRBBEEIIAJBA3EiAhtqSQ0BIAJBACADIARBJ2pLGw0CIAEQogILIAAoApgBIgMEQCAAKAKcASIEQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyADakkNASABQQAgAiADQSdqSxsNAiAEEKICCyAAQfAAahC/BCAAKAIoIgNBgICAgHhHBEAgAwRAIAAoAiwiBEEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgA2pJDQIgAUEAIAIgA0EnaksbDQMgBBCiAgsgABC/BAsgACgCYCIDQYCAgIB4RwRAIAMEQCAAKAJkIgRBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIANqSQ0CIAFBACACIANBJ2pLGw0DIAQQogILIABBOGoQvwQLDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALzwQBB38jAEEQayIGJAACfwJAIAIoAgQiA0UNACAAIAIoAgAgAyABKAIMEQAARQ0AQQEMAQsgAigCDCIDBEAgAigCCCIFIANBDGxqIQcgBkEMaiEIA0ACQAJAAkACQCAFLwEAQQFrDgICAQALAkAgBSgCBCICQcEATwRAIAFBDGooAgAhAwNAQQEgAEGCgsIAQcAAIAMRAAANCBogAkFAaiICQcAASw0ACwwBCyACRQ0DIAFBDGooAgAhAwsgAEGCgsIAIAIgAxEAAEUNAkEBDAULIAAgBSgCBCAFKAIIIAFBDGooAgARAABFDQFBAQwECyAFLwECIQIgCEEAOgAAIAZBADYCCAJAAkAgAkUEQCAGIAJBMHI6AAhBASEDDAELIAJB9v8XaiACQZz/H2pxIAJBmPg3aiACQfCxH2pxcyIEQRF2QQFqIQMgBEGAgChPDQEgBkEIaiADaiIEQQFrIAIgAkEKbiIJQQpsa0EwcjoAACADQQFGDQAgBEECayAJQQpwQTByOgAAIANBAkYNACAEQQNrIAJB5ABuQQpwQTByOgAAIANBA0YNACAEQQRrIAJB6AduQQpwQTByOgAAIANBBEYNACAEQQVrIAJBkM4AbkEwcjoAACADQQVGDQAgBEEGa0EwOgAAIANBBkYNACAEQQdrQTA6AAAgA0EHRg0AIARBCGtBMDoAAAsgACAGQQhqIAMgAUEMaigCABEAAEUNAUEBDAQLQQAgA0EFQcSCwgAQ6gcACyAFQQxqIgUgB0cNAAsLQQALIAZBEGokAAuhBQEGfyMAQSBrIgMkACABKAIMIQUCQAJAAn8CQAJAIAEoAhQiAiABKAIQIgRJBEAgAUEMaiEHA0AgAiAFai0AAEEJayIGQRlLDQJBASAGdEGTgIAEcUUEQCAGQRlHDQMgAUEANgIIIAEgAkEBajYCFCADQRRqIAcgARCCAiADKAIYIQIgAygCFEECRw0EIABBAToAACAAIAI2AgQMBgsgASACQQFqIgI2AhQgAiAERw0ACyAEIQILIANBCGogBSAEIAJBAWoiASAEIAEgBEkbEPkBIAMoAgwhBCADKAIIIQFBFBBxIgJFDQQgAiABNgIMIAJBBTYCACAAIAI2AgQgAEEBOgAAIAIgBDYCEAwDCyABIANBFGpBmMDBABDuAQwBCwJAAn8CQAJAAkACQAJAAkACQAJAIAMoAhwiBEEDaw4JAgkBAAkHCQkECQsgAkGUg8EAQQYQ2wcNAkEADAcLIAJBmoPBAEEFENsHDQdBAQwGCyACQZ+DwQBBAxDbBw0CQQIMBQsgAkHB/8AAQQYQ2wcNBUEDDAQLIAJBooPBAEELENsHDQFBBAwDC0EFIAJB+OfAAEEDENsHRQ0CGkEGIAJB++fAAEEDENsHRQ0CGiACQYzswABBAxDbBw0DQQcMAgtBCCACQa2DwQBBCxDbB0UNARogAkG4g8EAQQsQ2wcNAkEJDAELQQogAikAAELz0MX5teybsuUAUQ0AGkELIAIpAABC89DJ+bXsm7LlAFENABpBDCACKQAAQvPQzfm17Juy5QBRDQAaIAIpAABC89D94pbM2LLsAFINAUENCyECIABBADoAACAAIAI6AAEMAgsgAiAEQeSDwQBBDhDMBgsgARDrBSEBIABBAToAACAAIAE2AgQLIANBIGokAA8LAAvIBQEFfyMAQSBrIgIkAAJAAkACQAJAAkAgAC0AAEEBaw4DAQIDAAtBASEEIAEoAgAiA0GQq8cAQQUgASgCBCIGKAIMIgURAAANAwJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAURAAANBSADIAAtAAFBAnQiACgCuJxJIAAoAvibSSAFEQAARQ0BDAULIANB24HCAEECIAURAAANBCACIAY2AhQgAiADNgIQIAJBAToAACAALQABQQJ0IgAoAvicSSEBIAAoAridSSEAIAIgAjYCGCACQRBqIgYgACABEK8DDQQgBkHZgcIAQQIQrwMNBAsgA0HejsgAQQEgBREAACEEDAMLQQEhBCABKAIAIgNBlavHAEEEIAEoAgQiBigCDCIFEQAADQICQCABLQAKQYABcUUEQCADQbuzxQBBASAFEQAADQQgACgCCCAAKAIMIAEQtQJFDQEMBAsgA0HbgcIAQQIgBREAAA0DIAJBAToADyACIAY2AgQgAiADNgIAIAJB4IHCADYCFCACIAEpAgg3AhggAiACQQ9qNgIIIAIgAjYCECAAKAIIIAAoAgwgAkEQahC1Ag0DIAJB2YHCAEECEK8DDQMLIANB3o7IAEEBIAURAAAhBAwCC0EBIQQgASgCACIDQZmrxwBBDSABKAIEIgYoAgwiBREAAA0BIABBBGohAAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAURAAANAyAAIAEQpgJFDQEMAwsgA0HbgcIAQQIgBREAAA0CIAJBAToADyACIAY2AgQgAiADNgIAIAJB4IHCADYCFCACIAEpAgg3AhggAiACQQ9qNgIIIAIgAjYCECAAIAJBEGoQpgINAiACQdmBwgBBAhCvAw0CCyADQd6OyABBASAFEQAAIQQMAQsgASgCAEGmq8cAQQcgASgCBCgCDBEAACEECyACQSBqJAAgBAu2BAEEfyABLwEYIQQCfyABLwEWIgJB//8BcUUEQCACQRB0DAELIAJB/wdxIQUgAkGAgAJxIQMgAkGA+AFxIgJBgPgBRgRAIANBEHQhAiACQYCAgPwHciAFRQ0BGiACIAVBDXRyQYCAgP4HcgwBCyADQRB0IQMgAkENdEGAgID8AHEgBUENdHJBgICAwANqIANyIAINABogBSAFZ0EQayIFQf//A3FBCGp0Qf///wNxIANBgICA2ANyIAVBF3RrcgshBSABLwEaIQECfyAEQf//AXEEQCAEQf8HcSECIARBgIACcSEDIARBgPgBcSIEQYD4AUcEQCADQRB0IQMgBEENdEGAgID8AHEgAkENdHJBgICAwANqIANyIAQNAhogAiACZ0EQayIEQf//A3FBCGp0Qf///wNxIANBgICA2ANyIARBF3RrcgwCCyADQRB0IQQgBCACQQ10ckGAgID+B3IgAg0BGiAEQYCAgPwHcgwBCyAEQRB0CyEEIAACfyABQf//AXEEQCABQf8HcSECIAFBgIACcSEDIAFBgPgBcSIBQYD4AUcEQCADQRB0IQMgAUENdEGAgID8AHEgAkENdHJBgICAwANqIANyIAENAhogAiACZ0EQayIBQf//A3FBCGp0Qf///wNxIANBgICA2ANyIAFBF3RrcgwCCyADQRB0IQEgASACQQ10ckGAgID+B3IgAg0BGiABQYCAgPwHcgwBCyABQRB0C/0RIAX9HAAgBP0cAf0LBAALoQUCAn8BfiMAQSBrIgIkAAJAAkACQAJAAkACQAJAAkACQAJAQRUgASgCACIDQYCAgIB4cyADQQBOG0EBaw4IAQIDBAUGBwgACyABIAJBH2pB6OfAABCVCCEBIABBAToAACAAIAE2AgQMCAsgAEEAOgAAIAAgAS0ABDoAAQwHCyABLwEEIgFB/wFNBEAgACABOgABIABBADoAAAwHCyACQQE6AAggAiABrTcDECAAIAJBCGogAkEfakHo58AAEN4GNgIEIABBAToAAAwGCyABKAIEIgFB/wFNBEAgACABOgABIABBADoAAAwGCyACQQE6AAggAiABrTcDECAAIAJBCGogAkEfakHo58AAEN4GNgIEIABBAToAAAwFCyABKQMIIgRC/wFYBEAgACAEPAABIABBADoAAAwFCyACQQE6AAggAiAENwMQIAAgAkEIaiACQR9qQejnwAAQ3gY2AgQgAEEBOgAADAQLIAEsAAQiAUEASARAIAJBAjoACCACIAGsNwMQIAAgAkEIaiACQR9qQejnwAAQ3gY2AgQgAEEBOgAADAQLIAAgAToAASAAQQA6AAAMAwsgAS8BBCIBQYACTwRAIAJBAjoACCACIAGtwzcDECAAIAJBCGogAkEfakHo58AAEN4GNgIEIABBAToAAAwDCyAAIAE6AAEgAEEAOgAADAILIAEoAgQiAUGAAk8EQCACQQI6AAggAiABrDcDECAAIAJBCGogAkEfakHo58AAEN4GNgIEIABBAToAAAwCCyAAIAE6AAEgAEEAOgAADAELIAACfyABKQMIIgRCgAJaBEAgAkECOgAIIAIgBDcDECAAIAJBCGogAkEfakHo58AAEN4GNgIEQQEMAQsgACAEPAABQQALOgAACyACQSBqJAALxgQCBn8DfgJAIAEoAgBBAUYEQCABKQMQIgpQBEAMAgsgASgCGCIGKAIAIAYpAwgiCyAGKAIEIgWtIgwgCyAMVBunaiEHAkAgBUL/////DyALIAtC/////w9aG6drIgRBACAEIAVNGyIFIAogA60iDCAKIAxUG6ciBCAEIAVLGyIEQQFGBEAgAiAHLQAAOgAADAELIARFDQAgAiAHIAT8CgAACyABIAogBK0iCn03AxAgBiAKIAt8NwMIIARFBEBBACEEDAILQQEgBGshCCADQQFrIQYgASgCJCEJIAEoAiAhByABKAIoIQMDQAJAIAIgAi0AACADQQNyIgVB/v8DcSAFbEGA/gNxQQh2cyIFOgAAIANB/wFxIAkgBSAHc0H/AXFBAnQoAvC9SCAHQQh2cyIHQf8BcWpBhYiiwABsQQFqIglBGHZzQQJ0KALwvUggA0EIdnMhAyAIRQ0AIAhBAWohCCACQQFqIQIgBiIFQQFrIQYgBQ0BCwsgASAJNgIkIAEgBzYCICABIAM2AigMAQsgASkDECIKUARADAELIAEoAhgiBigCACAGKQMIIgsgBigCBCIFrSIMIAsgDFQbp2ohBwJAIAVC/////w8gCyALQv////8PWhunayIEQQAgBCAFTRsiBSAKIAOtIgwgCiAMVBunIgMgAyAFSxsiBEEBRgRAIAIgBy0AADoAAAwBCyAERQ0AIAIgByAE/AoAAAsgASAKIAStIgp9NwMQIAYgCiALfDcDCAsgAEEEOgAAIAAgBDYCBAubBQIFfwF+IwBBMGsiAiQAIAAoAgAhACABKAIAIgNB6LLFAEEBIAEoAgQiBCgCDCIFEQAAIQYgAiAANgIMAkACQAJAAkACQCAGDQACQCABLQAKQYABcUUEQCACQQxqIAEQxAQgAiAAQQFqNgIMRQ0BDAMLIANB3PjHAEEBIAURAAANASACQQE6AB8gAiAENgIUIAIgAzYCECACQeCBwgA2AiQgAiABKQIINwIoIAIgAkEfajYCGCACIAJBEGo2AiAgAkEMaiACQSBqEMQEDQEgAigCIEHZgcIAQQIgAigCJCgCDBEAACACIABBAWo2AgwNAgsCQCABLQAKQYABcQRAIAEpAgAhByACQQE6AB8gAiAHNwIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNAyACKAIgQdmBwgBBAiACKAIkKAIMEQAAIAIgAEECajYCDEUNAQwECyABKAIAQeeQxgBBAiABKAIEKAIMEQAADQIgAkEMaiABEMQEIAIgAEECajYCDA0DCyABLQAKQYABcQRAIAEoAgAhAyABKAIEIQRBASEAIAJBAToAHyACIAQ2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNAyACKAIgQdmBwgBBAiACKAIkKAIMEQAADQUMBAsgASgCAEHnkMYAQQIgASgCBCgCDBEAAA0CQQEhACACQQxqIAEQxAQNBCABKAIEIQQgASgCACEDDAMLIAIgAEEBajYCDAsgAiAAQQJqNgIMC0EBIQAMAQsgA0HpssUAQQEgBCgCDBEAACEACyACQTBqJAAgAAudBQEDfyMAQTBrIgMkAAJAAkACQAJAAkACQAJAAkACQAJAAkBBFSABKAIAIgJBgICAgHhzIAJBAE4bQQxrDgQBAgMEAAsgASADQS9qQbTiwAAQlQghASAAQYCAgIB4NgIAIAAgATYCBAwECyABKAIMIgJBAEgNBCABKAIIIQQCQCACRQRAQQEhAQwBCyACEHEiAUUNBgsgAgRAIAEgBCAC/AoAAAsgACACNgIIIAAgATYCBCAAIAI2AgAMAwsgASgCCCICQQBIDQUgASgCBCEEAkAgAkUEQEEBIQEMAQsgAhBxIgFFDQULIAIEQCABIAQgAvwKAAALIAAgAjYCCCAAIAE2AgQgACACNgIADAILIANBDGogASgCCCICIAEoAgwiARD7AiADKAIMQQFGBEAgAyABNgIgIAMgAjYCHCADQQY6ABggA0EYaiADQS9qQbTiwAAQ3gYhASAAQYCAgIB4NgIAIAAgATYCBAwCCyADKAIUIgJBAEgNBSADKAIQIQQCQCACRQRAQQEhAQwBCyACEHEiAUUNBAsgAgRAIAEgBCAC/AoAAAsgACACNgIIIAAgATYCBCAAIAI2AgAMAQsgA0EMaiABKAIEIgIgASgCCCIBEPsCIAMoAgxBAUYEQCADIAE2AiAgAyACNgIcIANBBjoAGCADQRhqIANBL2pBtOLAABDeBiEBIABBgICAgHg2AgAgACABNgIEDAELIAMoAhQiAkEASA0FIAMoAhAhBAJAIAJFBEBBASEBDAELIAIQcSIBRQ0DCyACBEAgASAEIAL8CgAACyAAIAI2AgggACABNgIEIAAgAjYCAAsgA0EwaiQADwtB2JrIABD/BwsAC0HYmsgAEP8HAAtB2JrIABD/BwALQdiayAAQ/wcAC5MEAQZ/IAMgAyACQQNqQXxxIAJrIghrQQdxQQAgAyAITxsiBWshCQJ/AkACQCADIAVPBEACQCAFRQ0AAn8gBUEBayACIANqIgZBAWsiBC0AACABQf8BcUYNABogAiAJaiIHIARGDQEgBUECayAGQQJrIgQtAAAgAUH/AXFGDQAaIAQgB0YNASAFQQNrIAZBA2siBC0AACABQf8BcUYNABogBCAHRg0BIAVBBGsgBkEEayIELQAAIAFB/wFxRg0AGiAEIAdGDQEgBUEFayAGQQVrIgQtAAAgAUH/AXFGDQAaIAQgB0YNASAFQQZrIAZBBmsiBC0AACABQf8BcUYNABogBCAHRg0BIAVBB2sgBkEHayIELQAAIAFB/wFxRg0AGiAEIAdGDQEgBUF4cgsgCWohBAwDCyAIIAMgAyAISxshBiABQf8BcUGBgoQIbCEFA0AgBiAJIgRJBEAgBEEIayEJQYCChAggAiAEaiIHQQhrKAIAIAVzIghrIAhyQYCChAggB0EEaygCACAFcyIIayAIcnFBgIGChHhxQYCBgoR4Rg0BCwsgAyAESQ0BIAJBAWshAyABQf8BcSECA0BBACAERQ0EGiADIARqIQEgBEEBayEEIAIgAS0AAEcNAAsMAgsgCSADIANBjJ7CABDqBwALQQAgBCADQZyewgAQ6gcAC0EBCyEJIAAgBDYCBCAAIAk2AgALwwQCCn8BfSMAQRBrIgYkAAJAAkAgA0EDbCIHQf////8DSw0AIANBDGwiCEH9////B08NAAJAIAhFBEBBBCEIQQAhBwwBCyAIEHEiCEUNAgsgBkEANgIMIAYgCDYCCCAGIAc2AgQCQAJAAkAgAwRAIAIgA2siB0EAIAIgB08bIQwgASADaiENIAEgA0EBdCIOaiEPIAUgBJNDAAB+Q5UhBUEIIQpBACEHA0AgAiAHRg0EIAEgB2otAAAiCwR9IAQgBSALQQFrQf8BcbOUkhCJBAVDAAAAAAshECAGKAIEIAlGBEAgBkEEakG86McAEPoFIAYoAgghCAsgCCAKakEIayAQOAIAIAYgCUEBaiIJNgIMIAcgDEYNAyAHIA1qLQAAIgsEfSAEIAUgC0EBa0H/AXGzlJIQiQQFQwAAAAALIRAgBigCBCAJRgRAIAZBBGpBvOjHABD6BSAGKAIIIQgLIAggCmpBBGsgEDgCACAGIAlBAWoiCTYCDCAHIA5qIAJPDQIgByAPai0AACILBH0gBCAFIAtBAWtB/wFxs5SSEIkEBUMAAAAACyEQIAYoAgQgCUYEQCAGQQRqQbzoxwAQ+gUgBigCCCEICyAIIApqIBA4AgAgBiAJQQFqIgk2AgwgCkEMaiEKIAMgB0EBaiIHRw0ACwsgACAGKQIENwIAIABBCGogBkEMaigCADYCACAGQRBqJAAPCyADQQF0IAdqIQcMAQsgAyAHaiEHCyAHIAJBrOjHABCMBwALQZzoxwAQ/wcLAAuUBQIFfwF+IwBBMGsiAiQAIAEoAgAiA0HossUAQQEgASgCBCIEKAIMIgURAAAhBiACIAA2AgwCQAJAAkACQAJAIAYNAAJAIAEtAApBgAFxRQRAIAJBDGogARDEBCACIABBAWo2AgxFDQEMAwsgA0Hc+McAQQEgBREAAA0BIAJBAToAHyACIAQ2AhQgAiADNgIQIAJB4IHCADYCJCACIAEpAgg3AiggAiACQR9qNgIYIAIgAkEQajYCICACQQxqIAJBIGoQxAQNASACKAIgQdmBwgBBAiACKAIkKAIMEQAAIAIgAEEBajYCDA0CCwJAIAEtAApBgAFxBEAgASkCACEHIAJBAToAHyACIAc3AhAgAkHggcIANgIkIAIgASkCCDcCKCACIAJBH2o2AhggAiACQRBqNgIgIAJBDGogAkEgahDEBA0DIAIoAiBB2YHCAEECIAIoAiQoAgwRAAAgAiAAQQJqNgIMRQ0BDAQLIAEoAgBB55DGAEECIAEoAgQoAgwRAAANAiACQQxqIAEQxAQgAiAAQQJqNgIMDQMLIAEtAApBgAFxBEAgASgCACEDIAEoAgQhBEEBIQAgAkEBOgAfIAIgBDYCFCACIAM2AhAgAkHggcIANgIkIAIgASkCCDcCKCACIAJBH2o2AhggAiACQRBqNgIgIAJBDGogAkEgahDEBA0DIAIoAiBB2YHCAEECIAIoAiQoAgwRAAANBQwECyABKAIAQeeQxgBBAiABKAIEKAIMEQAADQJBASEAIAJBDGogARDEBA0EIAEoAgQhBCABKAIAIQMMAwsgAiAAQQFqNgIMCyACIABBAmo2AgwLQQEhAAwBCyADQemyxQBBASAEKAIMEQAAIQALIAJBMGokACAAC7IEAQV/IwBB0ABrIgQkAAJAAkACQCABIANPBEAgASADRg0BDAMLIARBEGogAiADIAAgARDhAQJAIAQoAhBBAUYEQCAEQRhqIQAgBCgCTCEBIAQoAkghAiAEKAJEIQMgBCgCQCEFIAQoAjRBf0YNASAEQQRqIAAgBSADIAIgAUEAEIgEIAQoAgQhBQwEC0EAIQMCQCAELQAeDQAgBC0AHCEIIAQoAkQhACAEKAJAIQICQCAEKAIUIgFFDQAgACABTQRAIAAgAUYNAQwFCyABIAJqLAAAQUBIDQQLAkAgACABRwRAAn8gASACaiIFLAAAIgNBAEgEQCAFLQABQT9xIQYgA0EfcSEHIAdBBnQgBnIgA0FgSQ0BGiAFLQACQT9xIAZBBnRyIQYgBiAHQQx0ciADQXBJDQEaIAdBEnRBgIDwAHEgBS0AA0E/cSAGQQZ0cnIMAQsgA0H/AXELIQNBASEFIAhBAXENAQJAIANBgAFJDQBBAiEFIANBgBBJDQBBA0EEIANBgIAESRshBQsCQCABIAVqIgFFDQAgACABTQRAIAAgAUcNBwwBCyABIAJqLAAAQUBIDQYLIAAgAUYNASABIAJqLAAAGgwBCyAIQQFxRQ0BC0EBIQMLIAQgAzYCBCAEKAIEIQUMAwsgBEEEaiAAIAUgAyACIAFBARCIBCAEKAIEIQUMAgsgACACIAEQ2wdFIQUMAQsgAiAAIAEgAEHUuMcAELsJAAsgBEHQAGokACAFC9oEAwd/AX0BeyMAQSBrIgUkACAFQQRqIAIQqwYgBSgCCCEJAkACQAJAIAEEQCAFKAIMIQhBASEEA0AgBEECaiIDIAhPDQICQCAIIARBAWtrIgNBACADIAhNGyIDQQFHBH8gA0ECRw0BIARBAWoFIAQLIAhB4NvBABCMBwALIAQgCWoiA0EBay0AALP9EyADLQAAs/0gAf0MAAB/QwAAf0MAAH9DAAB/Q/3nASADQQFqLQAAs0MAAH9DlSIK/SACIAr9IAMhCyADQQJqLQAAs0MAAH9DlbwiA0H///8DcSEGAkAgA0GAgID8B3EiB0GAgID8B0YEQCAGQQ12QYAEQQAgBhtyQYD4AXIhAwwBCyAHQYCAgLgESwRAQYD4ASEDDAELIANBgICAxANPBEAgB0ENdiAGQQ12aiADQQx2IANB/98AcUEAR3FqQYCAAWohAwwBCyADQYCAgJgDSQRAQQAhAwwBCyAGQYCAgARyIgZB/gAgA0EXdiIHa3YhAyAGQR0gB2siB3ZBAXFFDQAgA0EDIAd0QQFrIAZxQQBHaiEDCyAAQRRqIAM7AQAgBSAL/QsEECAAIAVBEGoQ5QIgBEEEaiEEIABBJGohACABQQFrIgENAAsLIAUoAgQiAARAIAlBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIABqSQ0CIAFBACAEIABBJ2pLGw0DIAkQogILIAJBhAhPBEAgAhCbBwsgBUEgaiQADwsgAyAIQdDbwQAQjAcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvoBAICfgZ/An8CQCAAKQMoIgIgACkDCCIDUg0AIAApAzAiAiAAKQMQIgNSDQBBACAAKQM4IgIgACkDGCIDUQ0BGgsgAiADVAshBQJ/AkAgACkDaCICIAApA0giA1INACAAKQNwIgIgACkDUCIDUg0AIAApA3giAiAAKQNYIgNSDQBBAyEEQcAADAELQQJBAyACIANUIgYbIQRB4ABBwAAgBhsLIQcgACAEQQV0aiEGIAAgBUEBc0EFdGohBAJ/AkAgACAHaiIIKQMIIgIgACAFQQV0aiIAKQMIIgNSDQAgCCkDECICIAApAxAiA1INAEEAIAgpAxgiAiAAKQMYIgNRDQEaCyACIANUCyEHAkACfwJAIAYpAwgiAiAEKQMIIgNSDQAgBikDECICIAQpAxAiA1INACAGKQMYIgIgBCkDGCIDUg0AIAQgCCAHGyEFIAggACAHGyEJIAAgBCAHGwwBCyAIIAAgBxshCSACIANUBEAgACAIIAcbIQAgBiEFDAILIAQgCCAHGyEFIAAgBCAHGwshACAGIQQLAkACQCAFKQMIIgIgACkDCCIDUg0AIAUpAxAiAiAAKQMQIgNSDQAgBSkDGCICIAApAxgiA1INACAFIQYMAQsgACAFIAIgA1QiBxshBiAFIAAgBxshAAsgASAJ/QADAP0LAwAgAUEQaiAJQRBq/QADAP0LAwAgAUEwaiAAQRBq/QADAP0LAwAgASAA/QADAP0LAyAgAUHQAGogBkEQav0AAwD9CwMAIAEgBv0AAwD9CwNAIAFB8ABqIARBEGr9AAMA/QsDACABIAT9AAMA/QsDYAuyBAEMfyABQQFrIQ0gACgCBCEJIAAoAgAhCiAAKAIIIQsCQANAIAYNAQJ/AkAgAiAESQ0AA0AgASAEaiEFAkACQAJAAkACQCACIARrIgZBB00EQCACIARHDQEgAiEEDAcLIAVBA2pBfHEiACAFRg0BIAAgBWshA0EAIQADQCAAIAVqLQAAQQpGDQUgAyAAQQFqIgBHDQALIAMgBkEIayIASw0DDAILQQAhAANAIAAgBWotAABBCkYNBCAGIABBAWoiAEcNAAsgAiEEDAULIAZBCGshAEEAIQMLA0BBgIKECCADIAVqIgcoAgAiDkGKlKjQAHNrIA5yQYCChAggB0EEaigCACIHQYqUqNAAc2sgB3JxQYCBgoR4cUGAgYKEeEcNASADQQhqIgMgAE0NAAsLIAMgBkYEQCACIQQMAwsgAyAFaiEGIAIgA2sgBGshB0EAIQACQANAIAAgBmotAABBCkYNASAHIABBAWoiAEcNAAsgAiEEDAMLIAAgA2ohAAsgACAEaiIDQQFqIQQCQCACIANNDQAgACAFai0AAEEKRw0AQQAhBiAEIgUMAwsgAiAETw0ACwsgAiAIRg0CQQEhBiAIIQUgAgshAAJAIAstAAAEQCAKQbyLwwBBBCAJKAIMEQAADQELQQAhAyAAIAhHBEAgACANai0AAEEKRiEDCyAAIAhrIQAgASAIaiEHIAsgAzoAACAFIQggCiAHIAAgCSgCDBEAAEUNAQsLQQEhDAsgDAvTBAIIfwF7IAJBAnYhBgJAAkAgAkEgSQ0AIAEgAkH8AHEiA2ogAEsgASAAIANqSXENACAA/QAAACELIAAgAf0AAAD9CwAAIAEgC/0LAAACQCAGQRxxIgRBBEYNACAA/QAAECELIAAgAf0AABD9CwAQIAEgC/0LABAgBEEIRg0AIAD9AAAgIQsgACAB/QAAIP0LACAgASAL/QsAICAEQQxGDQAgAP0AADAhCyAAIAH9AAAw/QsAMCABIAv9CwAwCyAEIAZGDQELIAQhByAGQQNxIgMEQCADIARqIQcgACAEQQJ0IghqIQkgASAIaiEIA0AgCSgAACEFIAkgCCgAADYAACAIIAU2AAAgCUEEaiEJIAhBBGohCCADQQFrIgMNAAsLIAQgBmtBfEsNACAHQQJ0IQkgBiAHayEIIAAhAyABIQQDQCADIAlqIgcoAAAhBSAHIAQgCWoiBigAADYAACAGIAU2AAAgBkEEaiIFKAAAIQogBSAHQQRqIgUoAAA2AAAgBSAKNgAAIAdBCGoiBSgAACEKIAUgBkEIaiIFKAAANgAAIAUgCjYAACAGQQxqIgYoAAAhBSAGIAdBDGoiBygAADYAACAHIAU2AAAgA0EQaiEDIARBEGohBCAIQQRrIggNAAsLAkAgAkEDcSIDRQ0AIAEgAkH8AHEiBGohASAAIARqIQAgACADQQFGBH9BAAUgAC8AACEDIAAgAS8AADsAACABIAM7AAAgAkEBcUUNAUECCyIDaiIALQAAIQIgACABIANqIgAtAAA6AAAgACACOgAACwuIBQEGfyMAQSBrIgMkACABKAIMIQUCQAJAAn8CQAJAIAEoAhQiAiABKAIQIgRJBEAgAUEMaiEHA0AgAiAFai0AAEEJayIGQRlLDQJBASAGdEGTgIAEcUUEQCAGQRlHDQMgAUEANgIIIAEgAkEBajYCFCADQRRqIAcgARCCAiADKAIYIQIgAygCFEECRw0EIABBAToAACAAIAI2AgQMBgsgASACQQFqIgI2AhQgAiAERw0ACyAEIQILIANBCGogBSAEIAJBAWoiASAEIAEgBEkbEPkBIAMoAgwhBCADKAIIIQFBFBBxIgJFDQQgAiABNgIMIAJBBTYCACAAIAI2AgQgAEEBOgAAIAIgBDYCEAwDCyABIANBFGpBiMDBABDuAQwBCwJAAn8CQAJAAkACQAJAAkACQAJAAkAgAygCHCIEQQJrDgoCAAoKBgcDCgoBCgtBACACQYKQxgBBAxDbB0UNCBogAkHUhMEAQQMQ2wcNB0EBDAgLQQIgAkHXhMEAQQsQ2wdFDQcaIAJB4oTBAEELENsHDQhBAwwHCyACLwAAQfLwAEcNAUEEDAYLIAIpAABC8vD8otaMm7rhAFINAUEFDAULIAIvAABB8/AARw0FQQYMBAsgAikAAELz8Pyi1oybuuEAUg0EQQcMAwtBCCACQYGFwQBBBhDbB0UNAhogAkGHhcEAQQYQ2wcNA0EJDAILIAJBjYXBAEEHENsHDQJBCgwBC0ELIAJBh7LFAEEDENsHRQ0AGiACQYWQxgBBAxDbBw0BQQwLIQIgAEEAOgAAIAAgAjoAAQwCCyACIARBlIXBAEENEMwGCyABEOsFIQEgAEEBOgAAIAAgATYCBAsgA0EgaiQADwsAC8MEAQZ/IwBBEGsiBSQAIAVBADoACiAFQQA7AQgCQAJAAkACQAJAAkACQAJAIAIoAggiBkECdCADRgRAIAIoAgQhByACKAIAIQQMAQsgBkUEQCAAQRI6AAAgAigCACIARQ0HIAIoAgQiAUEEaygCACICQXhxIgMgAEECdCIAQQRBCCACQQNxIgIbakkNCCACQQAgAyAAQSdqSxsNAiABEKICDAcLIAIoAgAhBCAFIAIoAgQiByAGQQFrIgZBAnQiAmooAAA2AgwgAyACayIIQQRPDQIgCEUNACAFQQhqIAVBDGogCPwKAAALAkAgBCAGTQ0AIARBAnQhAiAGRQRAIAdBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAJqSQ0IIANBACAEIAJBJ2pLGw0EIAcQogJBASEHDAELIAcgAkEBIAZBAnQQuwIiB0UNBAsgASgCBCICBEAgASgCACIDQQRrKAIAIgRBeHEiCSACQQJ0IgJBBEEIIARBA3EiBBtqSQ0HIARBACAJIAJBJ2pLGw0FIAMQogILIAFBeDYCGCABQoCAgIDwHzcDECABQgA3AwggASAGNgIEIAEgBzYCACABIAUvAQg7ASAgASAIOgAjIABBHToAACABQSJqIAUtAAo6AAAMBQtBjI3IAEEuQbyNyAAQ6wcAC0EAIAhBA0GI4sQAEOoHAAtBjI3IAEEuQbyNyAAQ6wcLAAtBjI3IAEEuQbyNyAAQ6wcACyAFQRBqJAAPC0HMjMgAQS5B/IzIABDrBwALrwQBDH8jAEEQayIOJAACQAJAIAMEQCABIAJrIgZBACABIAZPGyERA0AgAiALaiEGAn8CQCALIBFHBEAgACAGQRhsaiIIKAIUIgdBBUkNASAIKAIEIQwgCCgCCAwCCyAGIAFBlMPHABCMBwALIAchDCAIQQRqCyAIQRRqIQ0gCEEEaiEKQfDlyAAgDBsoAgAhDCAIQQRBFCAHQQRLIgYbaigCAARAIAogDSAGG0EANgIACyAFIAtGDQIgBCALQQF0ai8BACEHIA0oAgAiCSEGIAlBBU8EQCAKKAIAIQYLAkAgBiAHTwRAIAYgB00NASAKIA0gCUEESxsiBigCACAHTQ0BIAYgBzYCAAwBCwJAIAcgBmsiDyAJQQQgCUEESyIGGyAKKAIAIAkgBhsiBmtNDQACQCAGIAYgD2oiBksNAEF/IAZBAWtndkEAIAZBAk8bIgZBf0YNACAOQQhqIAggBkEBahD1AyAOKAIIIgZBgYCAgHhGDQEgBg0GC0HYlccAQRFB1MzHABDrBwALA0ACfyANKAIAIglBBUkEQCAJIQcgCiEQQQQhCSANDAELIAgoAgQhByAIKAIIIRAgCgshBiAHIAlGBEAgCBDUBiAIKAIEIQcgCCgCCCEQIAohBgsgECAHQQJ0aiAMNgIAIAYgBigCAEEBajYCACAMQQFqIQwgD0EBayIPDQALCyALQQFqIgsgA0cNAAsLIA5BEGokAA8LIAUgBUGkw8cAEIwHCwALrwQBDH8jAEEQayIOJAACQAJAIAMEQCABIAJrIgZBACABIAZPGyERA0AgAiALaiEGAn8CQCALIBFHBEAgACAGQRhsaiIIKAIUIgdBBUkNASAIKAIEIQwgCCgCCAwCCyAGIAFB5MXHABCMBwALIAchDCAIQQRqCyAIQRRqIQ0gCEEEaiEKQfDlyAAgDBsoAgAhDCAIQQRBFCAHQQRLIgYbaigCAARAIAogDSAGG0EANgIACyAFIAtGDQIgBCALQQF0ai8BACEHIA0oAgAiCSEGIAlBBU8EQCAKKAIAIQYLAkAgBiAHTwRAIAYgB00NASAKIA0gCUEESxsiBigCACAHTQ0BIAYgBzYCAAwBCwJAIAcgBmsiDyAJQQQgCUEESyIGGyAKKAIAIAkgBhsiBmtNDQACQCAGIAYgD2oiBksNAEF/IAZBAWtndkEAIAZBAk8bIgZBf0YNACAOQQhqIAggBkEBahD1AyAOKAIIIgZBgYCAgHhGDQEgBg0GC0HYlccAQRFB1MzHABDrBwALA0ACfyANKAIAIglBBUkEQCAJIQcgCiEQQQQhCSANDAELIAgoAgQhByAIKAIIIRAgCgshBiAHIAlGBEAgCBDUBiAIKAIEIQcgCCgCCCEQIAohBgsgECAHQQJ0aiAMNgIAIAYgBigCAEEBajYCACAMQQFqIQwgD0EBayIPDQALCyALQQFqIgsgA0cNAAsLIA5BEGokAA8LIAUgBUH0xccAEIwHCwAL0wQCB38BfiMAQdAAayIBJAACQCAAEF0iAw0AIAAoAtwEIgJBgYCAgHhGIgRFBEACQAJAIAJBgICAgHhGBEBBACAAIAQbIQUgACgCCCIGQQZ0IQMgACgCBCIHQTxqIQICQANAIAIhBCADRQ0BIANBQGohAyACQUBrIQIgBC0AAEEBRw0ACyAEQTxrIgIoAjggAigCICIERw0DIAQgACgC7AJHDQMLIAZBBnQhAyAHQTxqIQIDQCACIQQgA0UNAiADQUBqIQMgAkFAayECIAQtAABBAkcNAAsgBEE8ayICKAI4IAIoAiBGDQEgAUECNgIsIAFBiKPBADYCKCABQgI3AjQgAUKAgICAECIIIAJBOGqthDcDSCABIAggAkEgaq2ENwNAIAEgAUFAazYCMCABQRxqIgAgAUEoahCxBiAAEI4HIQMMBAsgACgCgAQgACgC+ANGDQAgAUECNgIsIAFB5KLBADYCKCABQgI3AjQgAUKAgICAECIIIABBgARqrYQ3A0ggASAIIABB+ANqrYQ3A0AgASABQUBrNgIwIAFBBGoiACABQShqELEGIAAQjgchAwwDCyAAQfQEahDUASEDDAILIAFBAjYCLCABQeSiwQA2AiggAUICNwI0IAFCgICAgBAiCCACQThqrYQ3A0ggASAIIAVB7AJqrYQ3A0AgASABQUBrNgIwIAFBEGoiACABQShqELEGIAAQjgchAwwBCyABQQA2AjggAUEBNgIsIAFBqKPBADYCKCABQgQ3AjAgAUEoahCSByEDCyABQdAAaiQAIAML0wQCB38BfiMAQdAAayIBJAACQCAAEFwiAw0AIAAoAtwEIgJBgYCAgHhGIgRFBEACQAJAIAJBgICAgHhGBEBBACAAIAQbIQUgACgCCCIGQQZ0IQMgACgCBCIHQTxqIQICQANAIAIhBCADRQ0BIANBQGohAyACQUBrIQIgBC0AAEEBRw0ACyAEQTxrIgIoAjggAigCICIERw0DIAQgACgC7AJHDQMLIAZBBnQhAyAHQTxqIQIDQCACIQQgA0UNAiADQUBqIQMgAkFAayECIAQtAABBAkcNAAsgBEE8ayICKAI4IAIoAiBGDQEgAUECNgIsIAFBiKPBADYCKCABQgI3AjQgAUKAgICAECIIIAJBOGqthDcDSCABIAggAkEgaq2ENwNAIAEgAUFAazYCMCABQRxqIgAgAUEoahCxBiAAEI4HIQMMBAsgACgCgAQgACgC+ANGDQAgAUECNgIsIAFB5KLBADYCKCABQgI3AjQgAUKAgICAECIIIABBgARqrYQ3A0ggASAIIABB+ANqrYQ3A0AgASABQUBrNgIwIAFBBGoiACABQShqELEGIAAQjgchAwwDCyAAQfQEahCjASEDDAILIAFBAjYCLCABQeSiwQA2AiggAUICNwI0IAFCgICAgBAiCCACQThqrYQ3A0ggASAIIAVB7AJqrYQ3A0AgASABQUBrNgIwIAFBEGoiACABQShqELEGIAAQjgchAwwBCyABQQA2AjggAUEBNgIsIAFBqKPBADYCKCABQgQ3AjAgAUEoahCSByEDCyABQdAAaiQAIAMLzgQCB38BfiMAQdAAayIBJAACQCAAEF4iAg0AIAAoApwFIgNBgYCAgHhGIgJFBEACQCADQYCAgIB4RgRAQQAgAEFAayACGyEFIAAoAkgiBkEGdCEEIAAoAkQiB0E8aiEDAkADQCADIQIgBEUNASAEQUBqIQQgAkFAayEDIAItAABBAUcNAAsgAkE8ayIDKAI4IAMoAiAiAkcNAiACIAAoAqwDRw0CCyAGQQZ0IQQgB0E8aiEDA0AgAyEAQQAhAiAERQ0EIARBQGohBCAAQUBrIQMgAC0AAEECRw0ACyAAQTxrIgAoAjggACgCIEYNAyABQQI2AiwgAUGIo8EANgIoIAFCAjcCNCABQoCAgIAQIgggAEE4aq2ENwNIIAEgCCAAQSBqrYQ3A0AgASABQUBrNgIwIAFBHGoiACABQShqELEGIAAQjgchAgwDC0EAIQIgACgCwAQgACgCuARGDQIgAUECNgIsIAFB5KLBADYCKCABQgI3AjQgAUKAgICAECIIIABBwARqrYQ3A0ggASAIIABBuARqrYQ3A0AgASABQUBrNgIwIAFBBGoiACABQShqELEGIAAQjgchAgwCCyABQQI2AiwgAUHkosEANgIoIAFCAjcCNCABQoCAgIAQIgggA0E4aq2ENwNIIAEgCCAFQewCaq2ENwNAIAEgAUFAazYCMCABQRBqIgAgAUEoahCxBiAAEI4HIQIMAQsgAUEANgI4IAFBATYCLCABQaijwQA2AiggAUIENwIwIAFBKGoQkgchAgsgAUHQAGokACACC88EAgd/AX4jAEHQAGsiASQAAkAgABBfIgINACAAKAK8BSIDQYGAgIB4RiICRQRAAkAgA0GAgICAeEYEQEEAIABB4ABqIAIbIQUgACgCaCIGQQZ0IQQgACgCZCIHQTxqIQMCQANAIAMhAiAERQ0BIARBQGohBCACQUBrIQMgAi0AAEEBRw0ACyACQTxrIgMoAjggAygCICICRw0CIAIgACgCzANHDQILIAZBBnQhBCAHQTxqIQMDQCADIQBBACECIARFDQQgBEFAaiEEIABBQGshAyAALQAAQQJHDQALIABBPGsiACgCOCAAKAIgRg0DIAFBAjYCLCABQYijwQA2AiggAUICNwI0IAFCgICAgBAiCCAAQThqrYQ3A0ggASAIIABBIGqthDcDQCABIAFBQGs2AjAgAUEcaiIAIAFBKGoQsQYgABCOByECDAMLQQAhAiAAKALgBCAAKALYBEYNAiABQQI2AiwgAUHkosEANgIoIAFCAjcCNCABQoCAgIAQIgggAEHgBGqthDcDSCABIAggAEHYBGqthDcDQCABIAFBQGs2AjAgAUEEaiIAIAFBKGoQsQYgABCOByECDAILIAFBAjYCLCABQeSiwQA2AiggAUICNwI0IAFCgICAgBAiCCADQThqrYQ3A0ggASAIIAVB7AJqrYQ3A0AgASABQUBrNgIwIAFBEGoiACABQShqELEGIAAQjgchAgwBCyABQQA2AjggAUEBNgIsIAFBqKPBADYCKCABQgQ3AjAgAUEoahCSByECCyABQdAAaiQAIAILtgQBCn8CQAJAIAFBgApJBEAgAUEFdiEHAkACQCAAKAKgASIEBEAgBEEBayECIARBAnQgAGpBBGshBSAEIAdqQQJ0IABqQQRrIQMgBEEpSSEEA0AgBEUNAiACIAdqIgZBKE8NAyADIAUoAgA2AgAgA0EEayEDIAVBBGshBSACQQFrIgJBf0cNAAsLIAFBH3EhBgJAIAFBIEkNACAHQQJ0IgFFDQAgAEEAIAH8CwALIAAoAqABIgUgB2ohASAGRQRAIAAgATYCoAEgAA8LIAFBAWsiA0EnSw0DIAEhBCAAIANBAnRqKAIAQSAgBmsiCHYiA0UNBCABQSdNBEAgACABQQJ0aiADNgIAIAFBAWohBAwFCyABQShBjIPCABCMBwALIAJBKEGMg8IAEIwHAAsgBkEoQYyDwgAQjAcAC0Gcg8IAQR1BjIPCABDrBwALIANBKEGMg8IAEIwHAAsCQCAHQQFqIgogAU8NAAJAIAVBAWsiCUEESQRAIAEhAwwBCyABIAlBfHEiBWshAyABQQJ0IABqQRRrIQIgBSEBA0AgAkEEaiILIAL9AAIAIAj9rQEgC/0AAgAgBv2rAf1Q/QsCACACQRBrIQIgAUEEayIBDQALIAUgCUYNAQsgA0ECdCAAakEIayECA0AgAkEEaiIBIAEoAgAgBnQgAigCACAIdnI2AgAgAkEEayECIAogA0EBayIDSQ0ACwsgACAHQQJ0aiIBIAEoAgAgBnQ2AgAgACAENgKgASAAC+YEAgZ/AX4jAEEwayIDJAAgACgCDCEEAkACQAJAAkACQAJAIAAoAhQiASAAKAIQIgJJBEADQAJAIAEgBGotAAAiBUEJaw4kAAAEBAAEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQGAwsgACABQQFqIgE2AhQgASACRw0ACyACIQELIANBEGogBCACIAFBAWoiACACIAAgAkkbEPkBIAMoAhQhAiADKAIQIQBBFBBxIgFFDQUgASAANgIMIAFBAjYCACABIAI2AhAMBAsgBUHdAEYNAQsgA0EIaiAEIAIgAUEBaiIAIAIgACACSRsQ+QEgAygCDCECIAMoAgghAEEUEHEiAUUNAyABIAA2AgwgAUEWNgIAIAEgAjYCEAwCCyAAIAFBAWo2AhRBACEBDAELIAAgAUEBaiIBNgIUAkAgASACSQRAAn4CQANAIAEgBGotAAAiBkEJayIFQRdLQQEgBXRBk4CABHFFcg0BIAAgAUEBaiIBNgIUIAEgAkcNAAsgAiEBQgAMAQtCgAILIQcgAyAHIAatQhCGhCIHNwMoIAdCgIL0AlINASADQRhqIAQgAiABQQFqIgAgAiAAIAJJGxD5ASADKAIcIQIgAygCGCEAQRQQcSIBRQ0DIAEgADYCDCABQRU2AgAgASACNgIQDAILIANCADcDKAsgA0EgaiAEIAIgAUEBaiIAIAIgACACSRsQ+QEgAygCJCECIAMoAiAhAEEUEHEiAUUNASABIAA2AgwgAUEWNgIAIAEgAjYCECAHQv8Bg1ANACADQShqQQRyELEECyADQTBqJAAgAQ8LAAuVBQIFfwJ+IwBBMGsiAiQAIAEoAgwhBQJAAkACQAJAAkAgASgCFCIDIAEoAhAiBEkEQANAAkAgAyAFai0AACIGQQlrDiUAAAQEAAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQDBAsgASADQQFqIgM2AhQgAyAERw0ACyAEIQMLIAIgBSAEIANBAWoiASAEIAEgBEkbEPkBIAIoAgQhAyACKAIAIQRBFBBxIgFFDQIgASAENgIMIAFBBTYCACAAIAE2AgQgAEEBNgIAIAEgAzYCEAwECyABIANBAWo2AhQgAkEIaiABQQAQxwMgAikDCCIIQgNRDQIgAikDECEHAkACfwJAAkAgCKdBAWsOAgMAAQsgB0IAWQ0CIAJBAjoAGCACIAc3AyAgAkEYaiACQS9qQYjnwAAQ3gYMAQsgAkEDOgAYIAIgBzcDICACQRhqIAJBL2pBiOfAABDfBgsgARDrBSEBIABBATYCACAAIAE2AgQMBAsgAEEANgIAIAAgBzcDCAwDCyAGQTBrQf8BcUEKTwRAIAEgAkEvakGI58AAEO4BIAEQ6wUhASAAQQE2AgAgACABNgIEDAMLIAJBCGogAUEBEMcDIAIpAwgiCEIDUQRAIAAgAigCEDYCBCAAQQE2AgAMAwsgAikDECEHAkACfwJAAkAgCKdBAWsOAgMAAQsgB0IAWQ0CIAJBAjoAGCACIAc3AyAgAkEYaiACQS9qQYjnwAAQ3gYMAQsgAkEDOgAYIAIgBzcDICACQRhqIAJBL2pBiOfAABDfBgsgARDrBSEBIABBATYCACAAIAE2AgQMAwsgAEEANgIAIAAgBzcDCAwCCwALIAAgAigCEDYCBCAAQQE2AgALIAJBMGokAAuJBAACQAJAAkACQAJAAkACQAJAIANB/wFxQQFrDgMBAAMGCyAAIAFyDQEMBAsgAEUNAiAFIAEgAmwgAGpBAnRBAWsiAEsNBSAAIAVByPHEABCMBwALIAFFBEAgBSAAQQJ0QQFrIgBLDQUgACAFQdjxxAAQjAcACyABQQFrIAJsIABqQQJ0QQNyIgAgBUkNBCAAIAVB6PHEABCMBwALAkACQAJ/IAAEQCABRQRAIAUgAEECdEEBayIASwRAIAAgBGotAAAMAwsgACAFQYjyxAAQjAcACwJAIAUgASACbCAAakECdEEBayIDSwRAIAFBAWsgAmwgAGpBAnQiAEEDciIBIAVPDQEgBSAAQQFrIgBLBEAgAyAEai0AACEDIAAgBGotAAAhACABIARqLQAAIQEMBgsgACAFQbjyxAAQjAcACyADIAVBmPLEABCMBwALIAEgBUGo8sQAEIwHAAsgAUUEQEEAIQNBACEBQQAhAAwDCyACIAFBAWtsQQJ0QQNyIgAgBU8NASAAIARqLQAACyIDIgEhAAwBCyAAIAVB+PHEABCMBwALQf8BIAFB/wFxIANB/wFxaiAAQf8BcWsiAEEAIABBAEobIgAgAEH/AU4bDwsgAUUNACAFIAIgAUEBa2xBAnRBA3IiAEsNAiAAIAVBuPHEABCMBwALQQAhAwsgAw8LIAAgBGotAAALrgQCBX8EfiMAQSBrIgIkAEEEIQMgASgCBCIErSEIIAECfgJAIARC/////w8gASkDCCIHIAdC/////w9aG6drIgZBACAEIAZPG0EETwRAIAEoAgAgByAIIAcgCFQbp2ooAAAhBQwBC0GokMgAKQMAIglCCIghCiAJpyEDIAggCUL/AYNCBFINARoLIAdCBHwLIgk3AwgCQCADQf8BcUEERwRAIABBEmogAkEWai8BADsBACACIAOtQv8BgyAKQgiGhDcCDCACQQRqIAJBDWotAAAiAToAACAAIAIpAQ43AQogAiACKAAJIgM2AgAgAEEJaiABOgAAIAAgAzYABSAAQQA6AAQgAEEBNgIADAELIAJBCGpBAXIgBRCYBCACQRxqIAJBDWotAAA6AAAgAiACKAAJIgM2AgAgAiADNgIYAkACQCAEIAkgCCAIIAlWG6ciA2tBBE8EQCABKAIAIANqKAAAIQRBBCEDQgAhBwwBC0EAIQRBqJDIACkDACIKQgiIIQcgCqchAyAKQv8Bg0IEUg0BCyAJQgR8IQgLIAEgCDcDCCADQf8BcUEERwRAIAAgAzoACCAAQQA6AAQgAEEBNgIAIAAgB6ciATsACSAAIAdCGIg+AgwgAEELaiABQRB2OgAADAELIAAgAigCGDYAECAAQQA2AgAgACAErTcDCCAAQRRqIAJBHGotAAA6AAAgAEF/IAQgBEEBcWoiACAAIARJG603AxgLIAJBIGokAAvdBAIHfwF+IwBBEGsiAyQAAkAgAC8BDCICRQRAIAAoAgAgACgCBCABEKEDIQEMAQsgAyAB/QACAP0LAwACQAJ/IAApAggiCaciB0GAgIAIcUUEQCADKAIEDAELIAAoAgAgAygCACADKAIEIgEgACgCBCgCDBEAAA0BIAAgB0GAgID/eXFBsICAgAJyIgc2AgggA0IBNwMAIAIgAUH//wNxayIBQQAgASACTRshAkEACyEIAkAgAygCDCIFRQRADAELIAMoAgghAQNAAn8CQAJAAkACQCABLwEAQQFrDgIBAgALIAFBBGooAgAMAwsgAUECai8BACIEDQFBAQwCCyABQQhqKAIADAELIARB9v8XaiAEQZz/H2pxIARBmPg3aiAEQfCxH2pxc0ERdkEBagsgAUEMaiEBIAZqIQYgBUEBayIFDQALCwJAIAYgCGoiASACQf//A3FJBEAgAiABayEFQQAhAUEAIQICQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgBSECDAELIAVB/v8DcUEBdiECCyAHQf///wBxIQggACgCBCEGIAAoAgAhBANAIAFB//8DcSACQf//A3FPDQIgAUEBaiEBIAQgCCAGKAIQEQIARQ0ACwwCCyAAKAIAIAAoAgQgAxChAyEBIAAgCTcCCAwCCyAEIAYgAxChAw0AIAUgAmtB//8DcSEFQQAhAgNAIAUgAkH//wNxTQRAQQAhASAAIAk3AggMAwtBASEBIAJBAWohAiAEIAggBigCEBECAEUNAAsgACAJNwIIDAELQQEhAQsgA0EQaiQAIAELogQBB38jAEHQAGsiAiQAIAAgAToAbCAAKAIYIQMgAEGAgICAeDYCGAJAAkAgA0GAgICAeEcEQCACQRxqIABBJGr9AAIA/QsCACACQSxqIABBNGr9AAIA/QsCACACQTxqIABBxABq/QACAP0LAgAgAkHMAGogAEHUAGooAgA2AgAgAiADNgIQIAIgACkCHDcCFCACQQhqIAEgAkEQahDgAgJAIAIoAggiASAAKAIEIAAoAgggAigCDCIDKAIQEQAAIggEQCADKAIAIgAEQCABIAARAwALIAMoAgQiAEUNASABQQRrKAIAIgNBeHEiBUEEQQggA0EDcSIDGyAAakkNAyADQQAgBSAAQSdqSxsNBCABEKICDAELIABBADYCCCAAKAJYIgVBgICAgHhyQYCAgIB4RwRAIAAoAlwiBkEEaygCACIEQXhxIgdBBEEIIARBA3EiBBsgBWpJDQMgBEEAIAcgBUEnaksbDQQgBhCiAgsgAEGAgICAeDYCWAJAIAAoAmQiBUUNACAAKAJoIgYoAgAiBARAIAUgBBEDAAsgBigCBCIGRQ0AIAVBBGsoAgAiBEF4cSIHQQRBCCAEQQNxIgQbIAZqSQ0DIARBACAHIAZBJ2pLGw0EIAUQogILIAAgAzYCaCAAIAE2AmQLIAJB0ABqJAAgCA8LQezgwQAQ3QkAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuGBAEHfwJAAkACQAJAAkACQAJAIAMgBCAFayIGSwRAIAMgBE0NASAEIAVBAXQiCmsiCCADTw0CIAQgBWoiByADTw0DAkAgAiAGai0AACILIAIgBGotAAAiDGsiBiAGQR91IgZzIAZrQQF0Qf4DcSACIAhqLQAAIgYgAiAHai0AACIIayIHIAdBH3UiB3MgB2tBAXZqIAFB/wFxSw0AIAQgBUECdGsiASADTw0FIAQgBUEDbCIHayIFIANPDQYgAEH/AXEiACABIAJqLQAAIAIgBWotAAAiAWsiBSAFQR91IgVzIAVrSQ0AIAAgASAGayIBIAFBH3UiAXMgAWtB/wFxSQ0AIAYgC2siASABQR91IgFzIAFrQf8BcSAASw0AIAQgB2oiASADTw0HIAQgCmoiBCADTw0IIAAiAyABIAJqLQAAIAIgBGotAAAiAWsiAiACQR91IgJzIAJrSQ0AIAMgASAIayIBIAFBH3UiAXMgAWtB/wFxSQ0AIAggDGsiACAAQR91IgBzIABrQf8BcSADTSEJCyAJDwsgBiADQYjXxAAQjAcACyAEIANBmNfEABCMBwALIAggA0Go18QAEIwHAAsgByADQbjXxAAQjAcACyABIANByNbEABCMBwALIAUgA0HY1sQAEIwHAAsgASADQejWxAAQjAcACyAEIANB+NbEABCMBwALuAQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACADQqCAgIAONwIIAn8CQAJAAkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAAQQN0IgBqIQQgAEEIa0EDdkEBaiEGIAIoAgAhAANAAkAgAEEEaigCACIFRQ0AIAMoAgAgACgCACAFIAMoAgQoAgwRAABFDQBBAQwFC0EBIAEoAgAgAyABQQRqKAIAEQIADQQaIABBCGohACAEIAFBCGoiAUcNAAsMAgsgAEEYbCEKIABBAWtB/////wFxQQFqIQYgAigCCCEEIAIoAgAhAANAAkAgAEEEaigCACIBRQ0AIAMoAgAgACgCACABIAMoAgQoAgwRAABFDQBBAQwEC0EAIQdBACEIAkACQAJAIAUgCWoiAUEIai8BAEEBaw4CAQIACyABQQpqLwEAIQgMAQsgBCABQQxqKAIAQQN0ai8BBCEICwJAAkACQCABLwEAQQFrDgIBAgALIAFBAmovAQAhBwwBCyAEIAFBBGooAgBBA3RqLwEEIQcLIAMgBzsBDiADIAg7AQwgAyABQRRqKAIANgIIQQEgBCABQRBqKAIAQQN0aiIBKAIAIAMgASgCBBECAA0DGiAAQQhqIQAgBUEYaiIFIApHDQALDAELCwJAIAYgAigCBE8NACADKAIAIAIoAgAgBkEDdGoiACgCACAAKAIEIAMoAgQoAgwRAABFDQBBAQwBC0EACyADQRBqJAALpQQCBX8EfSABKAIAIgIgASgCBEYEf0EABSABIAJBBGo2AgACfwJAIAIoAgAiAiABKAIIIgEoAggiA0kEQCABKAIEIAJBGGxqIgJBEWovAAAgAkETai0AACIDQRB0ciIEQQh2IQVDAAAQQSABKgJIIAEtAFhBAkYiBhshCEMAAEDBIAEqAkQgBhshByAEQf8BcQRAIAcgCCAHk0MAAH5DlSAEQQFrQf8BcbOUkhCJBCEJCyAFQf8BcQRAIAcgCCAHk0MAAH5DlSAFQQFrQf8BcbOUkhCJBCEKCyADBH0gByAIIAeTQwAAfkOVIANBAWtB/wFxs5SSEIkEBUMAAAAACyEHIAJBDGovAQAiAkH//wFxRQRAIAJBEHQMAwsgAkH/B3EhASACQYCAAnEhAyACQYD4AXEiAkGA+AFGBEAgA0EQdCICQYCAgPwHciABRQ0DGiACIAFBDXRyQYCAgP4HcgwDCyADQRB0IQMgAkUNASACQQ10QYCAgPwAcSABQQ10ckGAgIDAA2ogA3IMAgsgAiADQdy7xwAQjAcACyABIAFnQRBrIgFB//8DcUEIanRB////A3EgA0GAgIDYA3IgAUEXdGtyCyEBIAkgCpRDj8LNPxC3CiEIIAkgB5RDj8LNPxC3CiEJIAogB5RDj8LNPxC3CiAIIAmSkkMAAEBAlUPmQB8/ELcKQ9sPSUGUIAG+lCEHQQELIQEgACAHOAIEIAAgATYCAAu8BAMBfg5/AXsjAEEgayIEJAAgAf0AAxAhEQJAAkACfyABKAIEIgpFBEBB6JrIACELQQAhCkEADAELAkACQAJAIApBAWqtQhR+IgJCIIinDQAgAqdBB2pBeHEiBSAKQQlqIghqIgMgBUkgA0H4////B0tyDQAgAw0BQQghAwwCCyAEQQA2AhggBEEBNgIMIARBxLXEADYCCCAEQgQ3AhAgBEEIakGYtcQAEI0IDAQLIAMQcSIDRQ0DCyADIAVqIQsgASgCACEJIAgEQCALIAkgCPwKAAALIAEoAgwiDQRAIAtBFGshECAJQQhqIQMgCSkDAEJ/hUKAgYKEiJCgwIB/gyECIA0hCCAJIQUDQCACUARAA0AgBUGgAWshBSADKQMAIANBCGohA0KAgYKEiJCgwIB/gyICQoCBgoSIkKDAgH9RDQALIAJCgIGChIiQoMCAf4UhAgsgCSAFIAJ6p0EDdkFsbGoiDGtBbG0hBiAMQQxrKAIAIgdBAEgNAyAMQRBrKAIAIQ4CQCAHRQRAQQEhDwwBCyAHEHEiD0UNBQsgBwRAIA8gDiAH/AoAAAsgAkIBfSACgyECIAxBCGsoAgAhDiAQIAZBFGxqIgYgDEEEay0AADoAECAGIA42AgwgBiAHNgIIIAYgDzYCBCAGIAc2AgAgCEEBayIIDQALCyABKAIICyEDIAAgDTYCDCAAIAM2AgggACAKNgIEIAAgCzYCACAAIBH9CwMQIARBIGokAA8LQaTvwQAQ/wcACwALvgQBBn8jAEEwayIDJAAgAyACNgIIIAMgATYCBCADQSBqIANBBGoQ7QMCQAJAAkAgAygCICIGBEAgAygCJCEBIAMoAixFBEAgACABNgIIIAAgBjYCBCAAQYCAgIB4NgIADAQLIAJBAEgNAQJAIAJFBEBBASEEDAELIAIQcSIERQ0DCyADQQA2AhQgAyAENgIQIAMgAjYCDCABIAJLBEAgA0EMakEAIAEQ9wUgAygCECEEIAMoAhQhBSADKAIMIQILIAEEQCAEIAVqIAYgAfwKAAALIAMgASAFaiIBNgIUIAIgAWtBAk0EQCADQQxqIAFBAxD3BSADKAIQIQQgAygCFCEBCyABIARqIgJBxPnHAC8AACIFOwAAIAJBAmpBxvnHAC0AACIGOgAAIAMgAUEDaiICNgIUIAMgAykCBDcCGANAAkAgA0EgaiADQRhqEO0DIAMoAiAiB0UNACADKAIsIAMoAiQiASADKAIMIAJrSwRAIANBDGogAiABEPcFIAMoAhAhBCADKAIUIQILIAEEQCACIARqIAcgAfwKAAALIAMgASACaiICNgIURQ0BIAMoAgwgAmtBAk0EQCADQQxqIAJBAxD3BSADKAIQIQQgAygCFCECCyACIARqIgEgBTsAACABQQJqIAY6AAAgAyACQQNqIgI2AhQMAQsLIAAgAykCDDcCACAAQQhqIANBFGooAgA2AgAMAwsgAEEANgIIIABCgICAgBg3AgAMAgtBlO7BABD/BwsACyADQTBqJAAL2QQDBX8BewZ9IwBBEGsiBSQAAkACQAJAAkAgA0ECdCIGQf////8DSw0AIANBBHQiB0H9////B08NAAJAIAdFBEBBBCEIQQAhBgwBCyAHEHEiCEUNAgsgBUEANgIMIAUgCDYCCCAFIAY2AgQCQCADBEBBACEGQQAhBwNAIAIgBk0NBSAGQQFqIgQgAk8NBiAGQQJqIgQgAk8NAkMAAIA/IAEgBmoiBC0AALP9EyAEQQFqLQAAs/0gAf0MAAB/QwAAf0MAAH9DAAB/Q/3nASIJIAn95AH9DAAAgL8AAIC/AACAvwAAgL/95AEiCf0fACIKi5MgCf0fASINi5MiC4xDAAAAABDgCCEMIARBAmotAACzQwAAf0OVQwAAAD+UQ9sPSUCUIg4QmQIiDyALIAsgC5QgCiAMIAyMIgogCf0MAAAAAAAAAAAAAAAAAAAAAP1G/U0iCf0bAEEBcRuSIgsgC5QgDSAMIAogCf3HAf0bAkEBcRuSIgwgDJSSkpEiCpWUIQ0gBSgCBCAOEJsCIQ4gB2tBA00EQCAFQQRqIAdBBEEEQQQQpAUgBSgCCCEIIAUoAgwhBwsgCCAHQQJ0aiIEIA44AgwgBCANOAIIIAQgDyAMIAqVlDgCBCAEIA8gCyAKlZQ4AgAgBSAHQQRqIgc2AgwgBkEDaiEGIANBAWsiAw0ACwsgACAFKQIENwIAIABBCGogBUEMaigCADYCACAFQRBqJAAPCyAEIAJBvOvHABCMBwALQYzrxwAQ/wcLAAsgBiACQZzrxwAQjAcACyAEIAJBrOvHABCMBwALuAMBBH8gABCdAQJAAkAgACgC8AMiAgRAIAAoAvQDIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAogEIgJBgoCAgHhIIAJFckUEQCAAKAKMBCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAL8AyICBEAgACgCgAQiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsCQCAAKAKoBCICRQ0AIAAoAqwEIgMoAgAiAQRAIAIgAREDAAsgAygCBCIDRQ0AIAJBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIANqSQ0BIAFBACAEIANBJ2pLGw0CIAIQogILIAAoArAEIgIEQCAAKAK0BCIAQQRrKAIAIgNBeHEiAUEEQQggA0EDcSIDGyACakkNASADQQAgASACQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4kJAg9/AX4jAEEwayIHJAACQAJAAkACQAJAIAEoAhQiBSABKAIQIghJBEAgASAFQQFqIgQ2AhQgASgCDCIGIAVqLQAAIgNBMEcNAiAEIAhJBEAgBCAGai0AAEEwa0H/AXFBCkkNAgsgACABIAJCABCvAgwFCyAHQRhqIAEoAgwgCCAFEPkBIAcoAhwhAiAHKAIYIQFBFBBxIgNFDQIgAyABNgIMIANBBTYCACAAIAM2AgggAEIDNwMAIAMgAjYCEAwECyAHQQhqIAYgCCAFQQJqIgEgCCABIAhJGxD5ASAHKAIMIQIgBygCCCEBQRQQcSIDRQ0BIAMgATYCDCADQQ02AgAgACADNgIIIABCAzcDACADIAI2AhAMAwsgA0Exa0H/AXFBCU8EQCAHQRBqIAYgCCAEEPkBIAcoAhQhAiAHKAIQIQFBFBBxIgNFDQEgAyABNgIMIANBDTYCACAAIAM2AgggAEIDNwMAIAMgAjYCEAwDCyADQTBrrUL/AYMhEiAEIAhPDQEDQCAEIAZqLQAAQTBrIgVB/wFxIgNBCk8NAiADQQVLIBJCmbPmzJmz5swZUnIgEkKZs+bMmbPmzBlacUUEQCABIARBAWoiBDYCFCASQgp+IAWtQv8Bg3whEiAEIAhHDQEMAwsLIAdBIGohCUEAIQYjAEEQayILJAACQAJAAkACQAJAIAEiBSgCECIKIAEoAhQiA00NACAKIANrIQEgBSgCDCEMIAMhBANAIAQgDGotAAAiCEEwa0H/AXFBCk8EQCAIQS5GDQMgCEHFAEcgCEHlAEdxDQIgCSAFIAIgEiAGEO4DDAQLIAUgBEEBaiIENgIUIAZBAWoiBiABRw0ACyABIQYLIAkgBSACIBIgBhDwBAwBCyAFIARBAWoiBDYCFAJAIAQgCk8NACAGIAxqIQ4gBCAKayEPIAMgCmsgBmpBAWohEEEAIQQCQANAIAMgBmohDSADIA5qQQFqLQAAIhFBMGsiCEH/AXEiAUEKTwRAIARFBEAgDUEBaiEEDAQLIAQgBmohASARQSByQeUARwRAIAkgBSACIBIgARDwBAwFCyAJIAUgAiASIAEQ7gMMBAsgAUEFSyASQpmz5syZs+bMGVJyIBJCmLPmzJmz5swZVnENASAFIA1BAmo2AhQgA0EBaiEDIBJCCn4gCK1C/wGDfCESIBAgBEEBayIERw0ACyAJIAUgAiASIAYgD2oQ8AQMAgsgCSAFIAIgEiAEIAZqEOgGDAELIAtBCGogDCAKIARBAWoiASAKIAEgCkkbEPkBIAsoAgwhAiALKAIIIQFBFBBxIQMgBCAKSQRAIANFDQIgAyABNgIMIANBDTYCACAJIAM2AgQgCUEBNgIAIAMgAjYCEAwBCyADRQ0BIAMgATYCDCADQQU2AgAgCSADNgIEIAlBATYCACADIAI2AhALIAtBEGokAAwBCwALIAcoAiBBAUYEQCAAIAcoAiQ2AgggAEIDNwMADAMLIAAgBysDKDkDCCAAQgA3AwAMAgsACyAAIAEgAiASEK8CCyAHQTBqJAALwwQCBn8BfgJ/IAFFBEAgACgCCCEGQS0hCyAFQQFqDAELQStBgIDEACAAKAIIIgZBgICAAXEiARshCyABQRV2IAVqCyEHAkAgBkGAgIAEcUUEQEEAIQIMAQsCf0EAIANFDQAaIAIsAABBv39KIgEgA0EBRg0AGiABIAIsAAFBv39KagsgB2ohBwsCQCAALwEMIgkgB0sEQAJAAkAgBkGAgIAIcUUEQCAJIAdrIQlBACEBQQAhBwJAAkACQCAGQR12QQNxQQFrDgMAAQACCyAJIQcMAQsgCUH+/wNxQQF2IQcLIAZB////AHEhCiAAKAIEIQggACgCACEAA0AgAUH//wNxIAdB//8DcU8NAkEBIQYgAUEBaiEBIAAgCiAIKAIQEQIARQ0ACwwECyAAIAApAggiDKdBgICA/3lxQbCAgIACcjYCCEEBIQYgACgCACIIIAAoAgQiCiALIAIgAxDzBw0DQQAhASAJIAdrQf//A3EhAgNAIAFB//8DcSACTw0CIAFBAWohASAIQTAgCigCEBECAEUNAAsMAwtBASEGIAAgCCALIAIgAxDzBw0CIAAgBCAFIAgoAgwRAAANAiAJIAdrQf//A3EhAkEAIQEDQCACIAFB//8DcU0EQEEADwsgAUEBaiEBIAAgCiAIKAIQEQIARQ0ACwwCCyAIIAQgBSAKKAIMEQAADQEgACAMNwIIQQAPC0EBIQYgACgCACIBIAAoAgQiACALIAIgAxDzBw0AIAEgBCAFIAAoAgwRAAAhBgsgBgu7BAIGfwV9IAAgASACEMwDAkACQAJAIAIEQCAAKAJgQQxqIQEgACoCjAEgACoCiAEiDpMhDyAAKAJkIQlBASEGA0AgB0EDaiAJTw0CIAZBAWsiBSAETwRAIAUhBgwFCyAEIAVrIgVBACAEIAVPGyIFQQFGDQQgBUECRg0DIANBCGoqAgAhCyADQQRqKgIAIQxBACEFQQAhCCADKgIAIg1DAAAAAF9FBEBB/wFDAACAP0MAAAAAIA0QxgUgDpMgD5UiDSANQwAAAABdGyINIA1DAACAP14bQwAAfkOUELkHIg38AUEAIA1DAAAAAGAbIA1DAAB/Q14bQQFqQf8BcSEICyAMQwAAAABfRQRAQf8BQwAAgD9DAAAAACAMEMYFIA6TIA+VIgwgDEMAAAAAXRsiDCAMQwAAgD9eG0MAAH5DlBC5ByIM/AFBACAMQwAAAABgGyAMQwAAf0NeG0EBakH/AXFBCHQhBQsgASALQwAAAABfBH8gCgVB/wFDAACAP0MAAAAAIAsQxgUgDpMgD5UiCyALQwAAAABdGyILIAtDAACAP14bQwAAfkOUELkHIgv8AUEAIAtDAAAAAGAbIAtDAAB/Q14bQQFqQf8BcUEQdAsgBSAIcnIgAS0AA0EYdHI2AgAgAUEQaiEBIAdBBGohByAGQQNqIQYgA0EMaiEDIAJBAWsiAg0ACwsgAEEBOgC4AQ8LIAcgB0EEaiAJQdThwAAQ6gcACyAGQQFqIQYLIAYgBEHk4cAAEIwHAAvOBAMFfwN7B30CQAJAAkACQAJAAkACQAJAAkAgB0EDTwRAIAdBA24hCSABKgIAIAAqAgAiEZMhEiAB/V0CBCAA/V0CBCIO/eUBIQ9BACEBQQAhAANAIAEgA08NAyABIAVPDQQgAUEBaiIIIANPDQUgBSAITQ0GIAFBAmoiCCADTw0HIAUgCE0NCCABIARqIggtAAAhCyABIAJqIgotAAAhDCAOIA8gCkEBai0AACAIQQFqLQAAQQh0crNDAP9/R5X9EyAKQQJqLQAAIAhBAmotAABBCHRys0MA/39Hlf0gAf3mAf3kASIN/R8AIhOLEIkEIRQgDf0fASIVixCJBCEWIAAgB08NCSAGQwAAwH9DAACAPyARIAtBCHQgDHKzQwD/f0eVIBKUkiIQmCAQIBBcGyAQixCJBEMAAIC/kpQ4AgAgAEEBaiIIIAdPDQogBkEEakMAAMB/QwAAgD8gE5ggDSAN/UIiDf0bAEEBcRsgFEMAAIC/kpQ4AgAgAEECaiIIIAdPDQIgBkEIakMAAMB/QwAAgD8gFZggDf3HAf0bAkEBcRsgFkMAAIC/kpQ4AgAgAUEEaiEBIAZBDGohBiAAQQNqIQAgCUEBayIJDQALCw8LIAggB0HE7scAEIwHAAsgASADQcTtxwAQjAcACyABIAVB1O3HABCMBwALIAggA0Hk7ccAEIwHAAsgCCAFQfTtxwAQjAcACyAIIANBhO7HABCMBwALIAggBUGU7scAEIwHAAsgACAHQaTuxwAQjAcACyAIIAdBtO7HABCMBwALiAQBBX8jAEEgayIEJABBovnHACEFQQkhAwJAAkAgAigCAEEBcQ0AIARBEGogAigCBCACKAIIEPsCQaL5xwAgBCgCFCAEKAIQIgIbIQUgAg0AIAQoAhgiAw0AIAFBAUEAEJcDIQIMAQsgBCADNgIMIAQgBTYCCCABKAIEIQUgASgCACEDA0ACQCAEQRBqIARBCGoQ7QMgBCgCECIGRQ0AIAQoAhQhByAEKAIcRQRAIAEgBiAHEJcDIQIMAwtBASECIAMgBiAHIAUoAgwRAAANAiADQf3/AyAFKAIQEQIARQ0BDAILC0EAIQILAkACQAJAAkAgACgCACIBQYCAgIB4RwRAIAFFDQIgACgCBCIFQQRrKAIAIgBBeHEiA0EEQQggAEEDcSIAGyABakkNBCAARSADIAFBJ2pNcg0BDAMLIAAtAARBA0cNASAAKAIIIgUoAgAhACAFQQRqKAIAIgEoAgAiAwRAIAAgAxEDAAsgASgCBCIBBEAgAEEEaygCACIDQXhxIgZBBEEIIANBA3EiAxsgAWpJDQQgA0EAIAYgAUEnaksbDQMgABCiAgsgBUEEaygCACIAQXhxIgFBEEEUIABBA3EiABtJDQMgAEUNACABQTRPDQILIAUQogILIARBIGokACACDwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALgwQBCX8jAEEgayIFJAACQAJAAkACQCABIAAoArABIgNGIAAoArQBIgQgAkZxDQACQCAALQC4AUUEQCAAKAJkIQQMAQsgACgCrAEgA0ECdCADIARqQQJ0EOEIIQMgBEECdCIGIAAoAmQiBEsNAiAAKAJgIQcgBSADELgKIgg2AgAgBSAGNgIEIAYgCEcNBCADIAcgBhDgCSAAQQA6ALgBIANBhAhJDQAgAxCbBwsgAkECdCIGIQMgBCAGSQRAIAYgBCIDayIHIAAoAlwgA2tLBEAgAEHcAGogAyAHQQRBBBCkBSAAKAJkIQMLIAAoAmAiCSADQQJ0IgpqIQggB0ECTwRAIAYgBEF/c2pBAnQiCwRAIAhBACAL/AsACyACQQR0IARBAnRrIAlqIApqQQRrIQggAyAHakEBayEDCyAIQQA2AgAgA0EBaiEDCyAAIAM2AmQgACgCrAEgAUECdCABIAJqQQJ0EOEIIQQgAyAGSQ0CIAAoAmAgBSAEELgKIgc2AgAgBSAGNgIEIAYgB0cNAyAGIAQQ4QkgAEEAOgC4ASAAIAI2ArQBIAAgATYCsAEgBEGECEkNACAEEJsHCyAFQSBqJAAPC0EAIAYgBEH868AAEOoHAAtBACAGIANBkOzAABDqBwALIAVBADYCCEEAIAUgBUEEaiAFQQhqQeD5xAAQ9QcAC8gEAgJ/AX0jAEEgayIDJAAgASgCBCgCACABKAIAKAIAaiABKAIIKAIQIAJsaiECIAACfwJAAkACQAJAAkAgASgCDCgCAA4CAAECCwJAIAJBe0sNACABKAIUIAJBBGpJDQAgACABKAIQIAJqKgAAOAIEDAQLIANBADYCGCADQQE2AgwgA0HI28EANgIIIANCBDcCECAAIANBCGoQkgc2AgRBAQwECwJAIAJBfU0EQCABKAIUIAJBAmpPDQELIANBADYCGCADQQE2AgwgA0HI28EANgIIIANCBDcCECAAIANBCGoQkgc2AgRBAQwECyABKAIQIAJqIgEtAAFBCHQiAiABLQAAciIBQf//AXFFBEAgACABQRB0NgIEDAMLIAFB/wdxIQEgAkGAgAJxIQQgAkGA+AFxIgJBgPgBRgRAIARBEHQhAiABRQRAIAAgAkGAgID8B3I2AgQMBAsgACABQQ10IAJyQYCAgP4HcjYCBAwDCyAEQRB0IQQgAkUNASAAIAJBDXRBgICA/ABxIAFBDXRyQYCAgMADaiAEcjYCBAwCCyABKAIUIAJNBEAgA0EANgIYIANBATYCDCADQZCzwQA2AgggA0IENwIQIAAgA0EIahCSBzYCBEEBDAMLIAAgASgCGCoCACIFIAEoAhAgAmotAACzQwAAf0OVIAEoAhwqAgAgBZOUkjgCBAwBCyAAIARBgICA2ANyIAFnQRBrIgJBF3RrIAEgAkH//wNxQQhqdEH///8DcXI2AgQLQQALNgIAIANBIGokAAuKBAEIfyMAQSBrIgckAAJAAkACQAJAIAAtALgBRQRAIAAoAmQhBQwBCyAAKAKsASAAKAKwASIFQQJ0IAUgACgCtAEiBWpBAnQQ4QghBiAFQQJ0IgggACgCZCIFSw0BIAAoAmAhCSAHIAYQuAoiCjYCACAHIAg2AgQgCCAKRw0DIAYgCSAIEOAJIAZBhAhJDQAgBhCbBwsgAEIANwKwASAAQbgBakEAOgAAIAUgAkECdCIISQRAIAUhBiAIIAVrIgkgACgCXCAFa0sEQCAAQdwAaiAFIAlBBEEEEKQFIAAoAmQhBgsgACgCYCILIAZBAnQiDGohCiAJQQJPBEAgCCAFQX9zakECdCIIBEAgCkEAIAj8CwALIAJBBHQgBUECdGsgC2ogDGpBBGshCiAGIAlqQQFrIQYLIApBADYCACAGQQFqIQgLIAAgCDYCZAJAIAAoAgBBAUcNACACQQF0IgUgCEsNAiAAKAJgIgYgBSADIAQgAiAAKgKQARCpAiAAKAIEIAFBAXQgASACakEBdBDhCCIAELgKIQEgByAFNgIEIAcgATYCACABIAVHDQMgACAGIAUQ4AkgAEGECEkNACAAEJsHCyAHQSBqJAAPC0EAIAggBUH868AAEOoHAAtBACAFIAhBxODAABDqBwALIAdBADYCCEEAIAcgB0EEaiAHQQhqQeD5xAAQ9QcAC/8UAxN/A34Be0HgtskAKAIARQRAAkBB4LbJACgCAEHgtskAQgE3AgBB7LbJACgCACECQei2yQAoAgAhBEHotskAQfCayAApAwA3AgBB9LbJACgCACEFQfC2yQBB+JrIACkDADcCAEUgAkVyDQAgBQRAIARBCGohDSAEKQMAQn+FQoCBgoSIkKDAgH+DIRUgBCEDA0AgFVAEQANAIANB4ABrIQMgDSkDACANQQhqIQ1CgIGChIiQoMCAf4MiFUKAgYKEiJCgwIB/UQ0ACyAVQoCBgoSIkKDAgH+FIRULIAMgFXqnQQN2QXRsakEEaygCACIHQYQITwRAIAcQmwcLIBVCAX0gFYMhFSAFQQFrIgUNAAsLIAIgAkEMbEETakF4cSIFakEJaiIDRQ0AAkAgBCAFayIEQQRrKAIAIgJBeHEiBUEEQQggAkEDcSICGyADak8EQCACQQAgBSADQSdqSxsNASAEEKICDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACwtB5LbJACgCAEUEQEHktskAQX82AgBB7LbJACgCACIDIABxIQQgAEEZdiITrUKBgoSIkKDAgAF+IRdB6LbJACgCACECAkACQANAIAIgBGopAAAiFiAXhSIVQn+FIBVCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiFVBFBEADQCAAIAIgFXqnQQN2IARqIANxQXRsaiIFQQxrKAIARgRAIAVBCGsoAgAgAUYNBAsgFUIBfSAVgyIVUEUNAAsLIBYgFkIBhoNCgIGChIiQoMCAf4NQBEAgBCAGQQhqIgZqIANxIQQMAQsLQfC2yQAoAgBFBEACQEEAIQIjAEEgayIJJAACQAJAAkBB9LbJACgCACINQQFqIgQEQAJAQey2yQAoAgAiCiAKQQFqIg5BA3YiA0EHbCAKQQhJGyIPQQF2IARJBEACQAJAAn8gD0EBaiIDIAQgAyAESxsiBEEPTwRAIARB/////wFLDQlBfyAEQQN0QQduQQFrZ3ZBAWoMAQtBBCAEQQhxQQhqIARBBEkbCyIErUIMfiIVQiCIpw0AIBWnIgNBeEsNACADQQdqQXhxIgMgBEEIaiIGaiICIANJIAJB+P///wdLcg0AIAIQcSICRQ0BIAIgA2ohBSAGBEAgBUH/ASAG/AsACyAEQQFrIgsgBEEDdkEHbCALQQhJGyEMQei2yQAoAgAhBiANBEAgBUEMayEPIAVBCGohECAGQQxrIREgBikDAEJ/hUKAgYKEiJCgwIB/gyEVIAYhA0EAIQQgDSECA0AgFVAEQANAIARBCGohBCADQQhqIgMpAwBCgIGChIiQoMCAf4MiFUKAgYKEiJCgwIB/UQ0ACyAVQoCBgoSIkKDAgH+FIRULIAUgBiAVeqdBA3YgBGoiEkF0bGoiB0EMaygCACIIIAdBCGsoAgAgCBsiFCALcSIHaikAAEKAgYKEiJCgwIB/gyIWUARAQQghCANAIAcgCGohByAIQQhqIQggBSAHIAtxIgdqKQAAQoCBgoSIkKDAgH+DIhZQDQALCyAVQgF9IBWDIRUgBSAWeqdBA3YgB2ogC3EiB2osAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhBwsgBSAHaiAUQRl2Igg6AAAgECAHQQhrIAtxaiAIOgAAIA8gB0F0bGoiB0EIaiARIBJBdGxqIghBCGooAAA2AAAgByAIKQAANwAAIAJBAWsiAg0ACwtB7LbJACALNgIAQei2yQAgBTYCAEHwtskAIAwgDWs2AgAgCkUNAyAKIA5BDGxBB2pBeHEiA2pBCWoiBEUNAyAGIANrIgNBBGsoAgAiBkF4cSICQQRBCCAGQQNxIgYbIARqSQ0FIAZBACACIARBJ2pLGw0GIAMQogIMAwsgCUEANgIYIAlBATYCDCAJQcS1xAA2AgggCUIENwIQIAlBCGpBmLXEABCNCAsACyAOBEBB6LbJACgCACEFAkACQCADIA5BB3FBAEdqIgdBAkkEQCAHIQMMAQsgB0EBcSEDIAdB/v///wNxIghBA3QhAiAIIQYgBSEEA0AgBCAE/QADACIY/U1BB/3NAf0MAQEBAQEBAQEBAQEBAQEBAf1OIBj9DH9/f39/f39/f39/f39/f3/9UP3OAf0LAwAgBEEQaiEEIAZBAmsiBg0ACyAHIAhGDQELIAIgBWohBANAIAQgBCkDACIVQn+FQgeIQoGChIiQoMCAAYMgFUL//v379+/fv/8AhHw3AwAgBEEIaiEEIANBAWsiAw0ACwsgBUEIaiELAkAgDkEITwRAIAUgDmogBSkAADcAAAwBCyAORQ0AIAsgBSAO/AoAAAtBASEGQQAhBANAIAQhAyAGIQQCQCADIAVqIhAtAABBgAFHDQAgBSADQXRsaiICQQRrIREgAkEIayEGIAJBDGshBwNAIAcoAgAiAiAGKAIAIAIbIhIgCnEiDCECIAUgDGopAABCgIGChIiQoMCAf4MiFVAEQEEIIQgDQCACIAhqIQIgCEEIaiEIIAUgAiAKcSICaikAAEKAgYKEiJCgwIB/gyIVUA0ACwsgBSAVeqdBA3YgAmogCnEiAmosAABBAE4EQCAFKQMAQoCBgoSIkKDAgH+DeqdBA3YhAgsgAiAMayADIAxrcyAKcUEITwRAIAIgBWoiCC0AACAIIBJBGXYiCDoAACALIAJBCGsgCnFqIAg6AAAgBSACQXRsaiIIQQxrIQJB/wFGBEAgEEH/AToAACALIANBCGsgCnFqQf8BOgAAIAJBCGogB0EIaigAADYAACACIAcpAAA3AAAMAwsgBygAACEMIAcgAigAADYAACACIAw2AAAgBigAACECIAYgCEEIayIMKAAANgAAIAwgAjYAACARKAAAIQIgESAIQQRrIggoAAA2AAAgCCACNgAADAELCyAQIBJBGXYiBjoAACALIANBCGsgCnFqIAY6AAALIAQgBCAOSSIDaiEGIAMNAAsLQfC2yQAgDyANazYCAAsgCUEgaiQADAQLDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAJQQA2AhggCUEBNgIMIAlBxLXEADYCCCAJQgQ3AhAgCUEIakGYtcQAEI0IAAsLIAAgARDsCCEEQei2yQAoAgAiAkHstskAKAIAIgUgAHEiA2opAABCgIGChIiQoMCAf4MiFVAEQEEIIQYDQCADIAZqIQMgBkEIaiEGIAIgAyAFcSIDaikAAEKAgYKEiJCgwIB/gyIVUA0ACwsgAiAVeqdBA3YgA2ogBXEiA2osAAAiBkEATgRAIAIgAikDAEKAgYKEiJCgwIB/g3qnQQN2IgNqLQAAIQYLIAIgA2ogEzoAACACIANBCGsgBXFqQQhqIBM6AABB8LbJAEHwtskAKAIAIAZBAXFrNgIAQfS2yQBB9LbJACgCAEEBajYCACACIANBdGxqIgNBBGsgBDYCACADQQhrIAE2AgAgA0EMayAANgIADAELIAVBBGsoAgAhBAsgBBDbCUHktskAQeS2yQAoAgBBAWo2AgAPC0G4psYAELAKAAu/BAMGfwF8AX0jAEEQayICJAACQAJAIAEoAgBBlICAgHhGBEBBBCEDAkAgASgCDCIEBEAgASgCCCEBQYCAECAEIARBgIAQTxsiA0ECdBBxIgVFDQQgBEEEdCEGIAJBADYCCCACIAU2AgQgAiADNgIAQQAhA0EAIQQCQANAAn0CQAJAAkACQAJAAkACQAJAAkACQAJAQRUgASgCACIHQYCAgIB4cyAHQQBOG0EBaw4KCgABAgMEBQYHCAkLIAFBBGovAQCzDAoLIAFBBGooAgCzDAkLIAFBCGopAwC1DAgLIAFBBGosAACyDAcLIAFBBGouAQCyDAYLIAFBBGooAgCyDAULIAFBCGopAwC0DAQLIAFBBGoqAgAMAwsgAUEIaisDACIItkMAAIA/QwAAgL8gCL1CAFkbmAwCCyABIAJBD2pB2OfAABCVCCEDIAIoAgAiAQRAIAIoAgQgAUECdEEEEKIHCwwDCyABQQRqLQAAswshCSABQRBqIQEgAigCACAERgRAIAJB1ILBABD6BSACKAIEIQULIAMgBWogCTgCACACIARBAWoiBDYCCCADQQRqIQMgBkEQayIGDQALIAIoAgQhAyACKAIAIgFBgICAgHhHDQILIAAgBDYCCCAAIAM2AgQgAEGAgICAeDYCAAwDC0EAIQFBACEECyAAIAQ2AgggACADNgIEIAAgATYCAAwBCyABIAJBD2pB+L/BABCVCCEBIABBgICAgHg2AgAgACABNgIECyACQRBqJAAPCwAL7AQBA38jAEEgayIDJAACQAJAAkAgAC0A8AFBBkcEQCAAKALoASIFRQ0BIAUgASACIAAoAuwBKAIQEQAAIQIMAwsgACgCxAEgACgCzAEiBGsgAkkEQCAAQcQBaiAEIAJBAUEBEKQFIAAoAswBIQQLIAAoAsgBIQUgAgRAIAQgBWogASAC/AoAAAsgACACIARqIgE2AswBQQAhAiABQQRJDQICQAJAAkACQCAFLwAAIAUtAAJBEHRyIgRBn5YiRwRAIARB8NjlA0YEQCAAQQAQ3wMhAgwICyAEIAUtAANBGHRyIgFB0JaNIEYNASABQdKCkYIDRyABQdKCkZoER3ENBCAAQQUQ3wMhAgwHCyAAKALcAUGAgICAeEYNASAAKALkASEBDAILIAAoAtABQYCAgIB4Rg0CIAAoAtQBIAAoAtgBEHxB/wFxQQRHDQIgAEEEEN8DIQIMBQsgA0EIaiAFIAEQ7QIgAygCDCEFIAMoAggiBEGBgICAeEYEQCAFIQIMBQsgACADKAIQIgE2AuQBIAAgBTYC4AEgACAENgLcASAEQYCAgIB4Rg0ECyABQQRJDQAgACgC4AEoAABBzo7NggVHDQAgAEEBEN8DIQIMAwsgACgC0AFBgICAgHhGDQEgACgC1AEgACgC2AEQfEH/AXEiAUEGRwRAIAAgARDfAyECDAMLIANBADYCGCADQQE2AgwgA0GUqsEANgIIIANCBDcCECADQQhqEJIHIQIMAgtB8KnBABDdCQALIANBADYCGCADQQE2AgwgA0GUqsEANgIIIANCBDcCECADQQhqEJIHIQILIANBIGokACACC+wEAQN/IwBBIGsiAyQAAkACQAJAIAAtAOgBQQZHBEAgACgC4AEiBUUNASAFIAEgAiAAKALkASgCEBEAACECDAMLIAAoArwBIAAoAsQBIgRrIAJJBEAgAEG8AWogBCACQQFBARCkBSAAKALEASEECyAAKALAASEFIAIEQCAEIAVqIAEgAvwKAAALIAAgAiAEaiIBNgLEAUEAIQIgAUEESQ0CAkACQAJAAkAgBS8AACAFLQACQRB0ciIEQZ+WIkcEQCAEQfDY5QNGBEAgAEEAEN0DIQIMCAsgBCAFLQADQRh0ciIBQdCWjSBGDQEgAUHSgpGCA0cgAUHSgpGaBEdxDQQgAEEFEN0DIQIMBwsgACgC1AFBgICAgHhGDQEgACgC3AEhAQwCCyAAKALIAUGAgICAeEYNAiAAKALMASAAKALQARB8Qf8BcUEERw0CIABBBBDdAyECDAULIANBCGogBSABEO0CIAMoAgwhBSADKAIIIgRBgYCAgHhGBEAgBSECDAULIAAgAygCECIBNgLcASAAIAU2AtgBIAAgBDYC1AEgBEGAgICAeEYNBAsgAUEESQ0AIAAoAtgBKAAAQc6OzYIFRw0AIABBARDdAyECDAMLIAAoAsgBQYCAgIB4Rg0BIAAoAswBIAAoAtABEHxB/wFxIgFBBkcEQCAAIAEQ3QMhAgwDCyADQQA2AhggA0EBNgIMIANBlKrBADYCCCADQgQ3AhAgA0EIahCSByECDAILQfCpwQAQ3QkACyADQQA2AhggA0EBNgIMIANBlKrBADYCCCADQgQ3AhAgA0EIahCSByECCyADQSBqJAAgAgv8AwEEfyMAQRBrIgQkAAJAAkACQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BIAAgARCLBUUNAkEBIQIMAwsgACgCACECQQkhAwNAIAMgBGpBBmogAkEPcS0A3LZFOgAAIANBAWshAyACQRBJIAJBBHYhAkUNAAtBASECIAFBAUGEtMUAQQIgAyAEakEHakEJIANrEMgDRQ0BDAILIAAoAgAhAkEJIQMDQCADIARqQQZqIAJBD3EtAMmBQjoAACADQQFrIQMgAkEPSyACQQR2IQINAAtBASECIAFBAUGEtMUAQQIgAyAEakEHakEJIANrEMgDDQELIAEoAgBBsIrDAEECIAEoAgQoAgwRAAAEQEEBIQIMAQsgAEEEaiEAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENASAAIAEQiwUhAgwCCyAAKAIAIQJBCSEDA0AgAyAEakEGaiACQQ9xLQDctkU6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALIAFBAUGEtMUAQQIgAyAEakEHakEJIANrEMgDIQIMAQsgACgCACECQQkhAwNAIAMgBGpBBmogAkEPcS0AyYFCOgAAIANBAWshAyACQQ9LIAJBBHYhAg0ACyABQQFBhLTFAEECIAMgBGpBB2pBCSADaxDIAyECCyAEQRBqJAAgAgvyBAICfwF7IwBBgNIAayIDJAACQAJAAkACQAJAAkACQAJAIAFB/wFxQQFrDgUAAgMEBQELQYCACBBxIgRFDQUgBEEEay0AAEEDcQRAIARBAEGAgAj8CwALIANBQGtBAEHA0QD8CwBBrNQAEHEiAUUNBSABIAJBxAH8CgAAIAFBgICAgHg2AugBIAFCATcC4AEgAUKAgAg3AtgBIAEgBDYC1AEgAUKAgICAgICAATcCzAEgAUKAgICAEDcCxAEgAUHsAWogA0EMakH00QD8CgAAIAFB4NMAakEAQcEA/AsAIAFBADsBqFQgAUEANgKkVEG438EAIQIMBgtBuAYQcSIBRQ0EIAFBADYC8AQgAUKAgICAEDcD6AQgAUGBgICAeDYC3AQgAUH0BGogAkHEAfwKAABBoN/BACECDAULQdABEHEiAUUNAyABIAJBxAH8CgAAIAFBADYCzAEgAUKAgICAEDcCxAFB0N/BACECDAQLQdABEHEiAUUNAiABIAJBxAH8CgAAIAFBADYCzAEgAUKAgICAEDcCxAFB6N/BACECDAMLQdABEHEiAUUNASABIAJBxAH8CgAAIAFBADYCzAEgAUKAgICAEDcCxAFBgODBACECDAILQYgEEHEiAUUNACABQQI2AgAgAf0MAAAAAAAAAAAAAAAAAAAAAP0LA3AgAUIANwOYAiABQQI2ApABIAFCATcCtAIgAUGAAWogBf0LAwAgAUGgAmogBf0LAwAgAUGwAmpBADYCACABQbwCaiACQcQB/AoAACABQQA6AIAEQZjgwQAhAgwBCwALIAAgAjYCBCAAIAE2AgAgA0GA0gBqJAAL8gQCAn8BeyMAQYDSAGsiAyQAAkACQAJAAkACQAJAAkACQCABQf8BcUEBaw4FAAIDBAUBC0GAgAgQcSIERQ0FIARBBGstAABBA3EEQCAEQQBBgIAI/AsACyADQUBrQQBBwNEA/AsAQaTUABBxIgFFDQUgASACQbwB/AoAACABQYCAgIB4NgLgASABQgE3AtgBIAFCgIAINwLQASABIAQ2AswBIAFCgICAgICAgAE3AsQBIAFCgICAgBA3ArwBIAFB5AFqIANBDGpB9NEA/AoAACABQdjTAGpBAEHBAPwLACABQQA7AaBUIAFBADYCnFRBmN3BACECDAYLQbAGEHEiAUUNBCABQQA2AvAEIAFCgICAgBA3A+gEIAFBgYCAgHg2AtwEIAFB9ARqIAJBvAH8CgAAQYDdwQAhAgwFC0HIARBxIgFFDQMgASACQbwB/AoAACABQQA2AsQBIAFCgICAgBA3ArwBQbDdwQAhAgwEC0HIARBxIgFFDQIgASACQbwB/AoAACABQQA2AsQBIAFCgICAgBA3ArwBQcjdwQAhAgwDC0HIARBxIgFFDQEgASACQbwB/AoAACABQQA2AsQBIAFCgICAgBA3ArwBQeDdwQAhAgwCC0GABBBxIgFFDQAgAUECNgIAIAH9DAAAAAAAAAAAAAAAAAAAAAD9CwNwIAFCADcDmAIgAUECNgKQASABQgE3ArQCIAFBgAFqIAX9CwMAIAFBoAJqIAX9CwMAIAFBsAJqQQA2AgAgAUG8AmogAkG8AfwKAAAgAUEAOgD4A0H43cEAIQIMAQsACyAAIAI2AgQgACABNgIAIANBgNIAaiQAC9kEAQN/IwBBIGsiAyQAAkACQAJAIAAtAIwBQQZHBEAgACgChAEiBUUNASAFIAEgAiAAKAKIASgCEBEAACECDAMLIAAoAgAgACgCCCIEayACSQRAIAAgBCACQQFBARCkBSAAKAIIIQQLIAAoAgQhBSACBEAgBCAFaiABIAL8CgAACyAAIAIgBGoiATYCCEEAIQIgAUEESQ0CAkACQAJAAkAgBS8AACAFLQACQRB0ciIEQZ+WIkcEQCAEQfDY5QNGBEAgAEEAEOADIQIMCAsgBCAFLQADQRh0ciIBQdCWjSBGDQEgAUHSgpGCA0cgAUHSgpGaBEdxDQQgAEEFEOADIQIMBwsgACgCeEGAgICAeEYNASAAKAKAASEBDAILIAAoAgxBgICAgHhGDQIgACgCECAAKAIUEHxB/wFxQQRHDQIgAEEEEOADIQIMBQsgA0EIaiAFIAEQ7QIgAygCDCEFIAMoAggiBEGBgICAeEYEQCAFIQIMBQsgACADKAIQIgE2AoABIAAgBTYCfCAAIAQ2AnggBEGAgICAeEYNBAsgAUEESQ0AIAAoAnwoAABBzo7NggVHDQAgAEEBEOADIQIMAwsgACgCDEGAgICAeEYNASAAKAIQIAAoAhQQfEH/AXEiAUEGRwRAIAAgARDgAyECDAMLIANBADYCGCADQQE2AgwgA0GUqsEANgIIIANCBDcCECADQQhqEJIHIQIMAgtB8KnBABDdCQALIANBADYCGCADQQE2AgwgA0GUqsEANgIIIANCBDcCECADQQhqEJIHIQILIANBIGokACACC9QEAQN/IwBBIGsiAyQAAkACQAJAIAAtAGxBBkcEQCAAKAJkIgVFDQEgBSABIAIgACgCaCgCEBEAACECDAMLIAAoAgAgACgCCCIEayACSQRAIAAgBCACQQFBARCkBSAAKAIIIQQLIAAoAgQhBSACBEAgBCAFaiABIAL8CgAACyAAIAIgBGoiATYCCEEAIQIgAUEESQ0CAkACQAJAAkAgBS8AACAFLQACQRB0ciIEQZ+WIkcEQCAEQfDY5QNGBEAgAEEAEL8DIQIMCAsgBCAFLQADQRh0ciIBQdCWjSBGDQEgAUHSgpGCA0cgAUHSgpGaBEdxDQQgAEEFEL8DIQIMBwsgACgCWEGAgICAeEYNASAAKAJgIQEMAgsgACgCDEGAgICAeEYNAiAAKAIQIAAoAhQQfEH/AXFBBEcNAiAAQQQQvwMhAgwFCyADQQhqIAUgARDtAiADKAIMIQUgAygCCCIEQYGAgIB4RgRAIAUhAgwFCyAAIAMoAhAiATYCYCAAIAU2AlwgACAENgJYIARBgICAgHhGDQQLIAFBBEkNACAAKAJcKAAAQc6OzYIFRw0AIABBARC/AyECDAMLIAAoAgxBgICAgHhGDQEgACgCECAAKAIUEHxB/wFxIgFBBkcEQCAAIAEQvwMhAgwDCyADQQA2AhggA0EBNgIMIANBlKrBADYCCCADQgQ3AhAgA0EIahCSByECDAILQfCpwQAQ3QkACyADQQA2AhggA0EBNgIMIANBlKrBADYCCCADQgQ3AhAgA0EIahCSByECCyADQSBqJAAgAgv8AwMFfwF7AX4CQAJAAkACQCAFLQC/AiIGQQhLQQEgBnRBlgJxRXJFBEBBCCAGbkECdK0gAq1+IgxCIIhQIAynIARJcQ0BIAEgAmohCCAEQXxxIQUgBkEIRgRAIAJFDQUgBEECdiIEIAJBAWsiAiACIARLGyICQQNNDQQgASACQQFqIgIgAkEDcSICQQQgAhtrIgJqIAMgAkECdCIGaiEHIAUgBmshBQNAIAMgACAB/VwAAP2JAf2pASIL/RsDQQJ0aiAAIAv9GwJBAnRqIAAgC/0bAUECdGogACAL/RsAQQJ0av1cAAD9VgAAAf1WAAAC/VYAAAP9CwAAIAFBBGohASADQRBqIQMgAkEEayICDQALIQEgByEDDAQLIAVFDQRBfyAGdEF/cyEKQQggBmshB0EAIARBfHFrIQJBfyEFA0AgBUEASARAIAEgCEYNBCABLQAAIQkgByEFIAFBAWohAQsgAyAAIAkgBXYgCnFBAnRqKAAANgAAIAUgBmshBSADQQRqIQMgAkEEaiICDQALDAQLQbCXxQBBNEHkl8UAEOsHAAtBhJbFAEHlAEHslsUAEOsHAAtB/JbFAEEiQaCXxQAQqwcACwNAIAVFDQEgAyAAIAEtAABBAnRqKAAANgAAIANBBGohAyAFQQRrIQUgAUEBaiIBIAhHDQALCwvjBAICfwF7IwBBgNIAayIDJAACQAJAAkACQAJAAkACQAJAIAFB/wFxQQFrDgUAAgMEBQELQYCACBBxIgRFDQUgBEEEay0AAEEDcQRAIARBAEGAgAj8CwALIANBQGtBAEHA0QD8CwBByNMAEHEiAUUNBSABIAJB4AD8CgAAIAFBgICAgHg2AoQBIAFCATcCfCABQoCACDcCdCABIAQ2AnAgAUKAgICAgICAATcCaCABQoCAgIAQNwJgIAFBiAFqIANBDGpB9NEA/AoAACABQfzSAGpBAEHBAPwLACABQQA7AcRTIAFBADYCwFNBiNzBACECDAYLQdgFEHEiAUUNBCABIAJB4AD8CgAAIAFBADYC0AUgAUKAgICAEDcDyAUgAUGBgICAeDYCvAVB8NvBACECDAULQewAEHEiAUUNAyABIAJB4AD8CgAAIAFBADYCaCABQoCAgIAQNwJgQaDcwQAhAgwEC0HsABBxIgFFDQIgASACQeAA/AoAACABQQA2AmggAUKAgICAEDcCYEG43MEAIQIMAwtB7AAQcSIBRQ0BIAEgAkHgAPwKAAAgAUEANgJoIAFCgICAgBA3AmBB0NzBACECDAILQaADEHEiAUUNACABQQI2AogBIAFBAjYCACABQfgBaiACQeAA/AoAACABQegCav0MAAAAAAAAAAAAAAAAAAAAAP0LAwAgASAF/QsD2AIgAUIANwOAAyABQfgCakKAgICAEDcDACABQYgDaiAF/QsDACABQZUDakIANwAAQejcwQAhAgwBCwALIAAgAjYCBCAAIAE2AgAgA0GA0gBqJAALqAQCCn8BfSMAQRBrIggkAAJAAkACQAJAAkACQCAEBEBDAAD4QSAFlSEQA0AgCUEVbCIGQRVqIgcgA0sgCUGLhsPhAEtyDQQgCUECdCEHIAlBAWohCSAI/QwAAAAAAAAAAAAAAAAAAAAA/QsDAEEAIQtBBiEKIAIhBkEAIQwDQCAIIApBBmsiDkEDdkH8////AXFqIg1B/wBDAAD4QUMAAPjBIBAgBioCAJQiBSAFQwAA+MFdGyIFIAVDAAD4QV4bELkHIgX8AEGAfyAFQwAAAMNgGyAFQwAA/kJeG0EAIAUgBVsbQT9xIg8gDkEecXQgDSgCAHI2AgAgDkHgAXFBIGogCkkEQCAMQRBPDQUgDSANKAIEIA8gC0EecXZyNgIECyAGQQRqIQYgCkEGaiEKIAtBBmshCyAMQQFqIgxBFUcNAAsgASAHTQ0FIAgoAgwhCiAIKAIIIQsgCCgCBCEMIAAgB0ECdGogCCgCADYCACAHQQFyIgYgAU8NBiAAIAZBAnRqIAw2AgAgB0ECciIGIAFPDQcgACAGQQJ0aiALNgIAIAdBA3IiBiABTw0CIAAgBkECdGogCjYCACACQdQAaiECIAQgCUcNAAsLIAhBEGokAA8LIAYgAUHAz8cAEIwHAAtBBEEEQeDPxwAQjAcACyAGIAcgA0HQz8cAEOoHAAsgByABQZDPxwAQjAcACyAGIAFBoM/HABCMBwALIAYgAUGwz8cAEIwHAAv9AwEGfwJAAkACQAJAAkACQAJAIARFIAJFcg0AIAAoAjxFDQAgACgCICINIAFrIgpBACAKIA1NGyEOIAAoAhwgAUESbGohCgNAIAkgDkYNAiALQQlqIgwgBEsgCUGbjsfjAUtyDQMgCiADEMYCIANBJGohAyAKQRJqIQogDCELIAIgCUEBaiIJRw0ACwsCQCAGRSACRXINACAAKAI8QQJJDQBBACEEIAAoAiwiCyABayIDQQAgAyALTRshDCAAKAIoIAFBHmxqIQNBACEJA0AgCSAMRg0EIARBD2oiCiAGSyAJQZCixIgBS3INBSADIAUQwgIgBUE8aiEFIANBHmohAyAKIQQgAiAJQQFqIglHDQALCwJAIAhFIAJFcg0AIAAoAjxBA0kNAEEAIQogACgCOCIEIAFrIgNBACADIARNGyEFIAAoAjQgAUEqbGohA0EAIQkDQCAFIAlGDQYgCkEVaiIAIAhLIAlBi4bD4QBLcg0HIAMgBxC2AiAHQdQAaiEHIANBKmohAyAAIQogAiAJQQFqIglHDQALCw8LIAEgCWogDUHExscAEIwHAAsgCyAMIARB1MbHABDqBwALIAEgCWogC0HkxscAEIwHAAsgBCAKIAZB9MbHABDqBwALIAEgCWogBEGEx8cAEIwHAAsgCiAAIAhBlMfHABDqBwALxQQCBX8BfiMAQTBrIgIkAAJAAkAgACgCACIDQQJHBEBBASEEAkACfwJAIANBAXEEQCACIABBBGo2AgAgASgCCCACIAE2AgwgAkKAgICAgMjQBzcCBCACrUKAgICAoA+EIQdBgICABHENASACIAc3AxAgAkIBNwIkIAJBATYCHCACQaD4xwA2AhggAiACQRBqNgIgIAJBBGpBoLrFACACQRhqEMEDDAILIAEoAgAiAyAAKAIQIAAoAhQgASgCBCgCDCIBEQAADQUMBAsgAiAHNwMQIAJBATYCLCACQaz5xwA2AiggAkEBNgIkIAJBATYCHCACQaD4xwA2AhggAiACQRBqNgIgIAJBBGpBoLrFACACQRhqEMEDCyIDQQAgAigCBCIFG0UEQCADDQQgBUUNAUGgt8UAQTcgAkEYakGQt8UAQdi3xQAQ4AYACyABKAIAQfy2xQBBFCABKAIEKAIMEQAADQMLIAEoAgAhAyABKAIEKAIMIQEMAQsCQAJAAkAgACgCJCIERQ0AIAAoAiAhAANAIAJBGGogACAEEPsCAkAgAigCGEEBRgRAIAItACEhAyACLQAgIQUgAigCHCEGIAFBxPnHAEEDEJcDRQ0BDAULIAEgAigCHCACKAIgEJcDDQQMAgsgBUEBcUUNASAEIAMgBmoiA0kNAiAAIANqIQAgBCADayIEDQALC0EAIQQMAwsgAyAEIARByPnHABDqBwALQQEhBAwBCyADIAAoAhggACgCHCABEQAAIQQLIAJBMGokACAEC+MDAQd/IwBB0AFrIgUkACAAIAE6AOgBIAAoAgAhAiAAQQI2AgACQAJAIAJBAkcEQCAFIAI2AhQgBUEYaiAAQQRqQbgB/AoAACAFQQhqIAEgBUEUahDVAwJAIAUoAggiASAAKALAASAAKALEASAFKAIMIgIoAhARAAAiCARAIAIoAgAiAARAIAEgABEDAAsgAigCBCIARQ0BIAFBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIABqSQ0DIAJBACAEIABBJ2pLGw0EIAEQogIMAQsgAEEANgLEASAAKALUASIEQYCAgIB4ckGAgICAeEcEQCAAKALYASIGQQRrKAIAIgNBeHEiB0EEQQggA0EDcSIDGyAEakkNAyADQQAgByAEQSdqSxsNBCAGEKICCyAAQYCAgIB4NgLUAQJAIAAoAuABIgRFDQAgACgC5AEiBigCACIDBEAgBCADEQMACyAGKAIEIgZFDQAgBEEEaygCACIDQXhxIgdBBEEIIANBA3EiAxsgBmpJDQMgA0EAIAcgBkEnaksbDQQgBBCiAgsgACACNgLkASAAIAE2AuABCyAFQdABaiQAIAgPC0Hs4MEAEN0JAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL+wMCD38BfiADIAEoAhgiCiAFayIJSwRAQQAgASgCDCIIayEQIAQgCGohESAIIAUgBSAISRsiEiAIayETIAEoAiAhDSABKAIQIQ8gASkDACEWA0ACQAJAIBYgAiAJajEAAIhCAYNQBEAgASAJNgIYIAUhByAJIQogBg0CDAELIAggDSAIIAggDUsbIAYbIgdBAWsgBUkhDAJAAkACQAJAA0AgB0UEQCAQIAUgDSAGGyIHIAggByAISxtqIQ4gCCAJaiEHIBMhCyARIQwDQCAORQRAIAEgCTYCGCAGRQRAIAEgBTYCIAsgACAKNgIIIAAgCTYCBCAAQQE2AgAPCyALRQ0DIAMgB00NBCAOQQFrIQ4gC0EBayELIAIgB2ohFCAMLQAAIAxBAWohDCAHQQFqIQcgFC0AAEYNAAsgCiAPayEKIA8hByAGRQ0GDAcLIAdBAWshByAMRQ0EIAcgCWoiCyADTw0DIAQgB2otAAAgAiALai0AAEYNAAsgByAKaiAIayEKIAUhByAGRQ0EDAULIBIgBUHonsYAEIwHAAsgAyAIIAlqIgAgACADSRsgA0H4nsYAEIwHAAsgCyADQZifxgAQjAcACyAHIAVBiJ/GABCMBwALIAEgBzYCICAHIQ0LIAogBWsiCSADSQ0ACwsgAUEANgIYIABBADYCAAvgAwEHfyMAQdABayIFJAAgACABOgDwASAAKAIAIQIgAEECNgIAAkACQCACQQJHBEAgBSACNgIMIAVBEGogAEEEakHAAfwKAAAgBSABIAVBDGoQ1AMCQCAFKAIAIgEgACgCyAEgACgCzAEgBSgCBCICKAIQEQAAIggEQCACKAIAIgAEQCABIAARAwALIAIoAgQiAEUNASABQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyAAakkNAyACQQAgBCAAQSdqSxsNBCABEKICDAELIABBADYCzAEgACgC3AEiBEGAgICAeHJBgICAgHhHBEAgACgC4AEiBkEEaygCACIDQXhxIgdBBEEIIANBA3EiAxsgBGpJDQMgA0EAIAcgBEEnaksbDQQgBhCiAgsgAEGAgICAeDYC3AECQCAAKALoASIERQ0AIAAoAuwBIgYoAgAiAwRAIAQgAxEDAAsgBigCBCIGRQ0AIARBBGsoAgAiA0F4cSIHQQRBCCADQQNxIgMbIAZqSQ0DIANBACAHIAZBJ2pLGw0EIAQQogILIAAgAjYC7AEgACABNgLoAQsgBUHQAWokACAIDwtB7ODBABDdCQALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+UDAQd/IwBB8ABrIgUkACAAIAE6AIwBIAAoAhghAiAAQYCAgIB4NgIYAkACQCACQYCAgIB4RwRAIAUgAjYCECAFQRRqIABBHGpB3AD8CgAAIAVBCGogASAFQRBqENkDAkAgBSgCCCIBIAAoAgQgACgCCCAFKAIMIgIoAhARAAAiCARAIAIoAgAiAARAIAEgABEDAAsgAigCBCIARQ0BIAFBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIABqSQ0DIAJBACAEIABBJ2pLGw0EIAEQogIMAQsgAEEANgIIIAAoAngiBEGAgICAeHJBgICAgHhHBEAgACgCfCIGQQRrKAIAIgNBeHEiB0EEQQggA0EDcSIDGyAEakkNAyADQQAgByAEQSdqSxsNBCAGEKICCyAAQYCAgIB4NgJ4AkAgACgChAEiBEUNACAAKAKIASIGKAIAIgMEQCAEIAMRAwALIAYoAgQiBkUNACAEQQRrKAIAIgNBeHEiB0EEQQggA0EDcSIDGyAGakkNAyADQQAgByAGQSdqSxsNBCAEEKICCyAAIAI2AogBIAAgATYChAELIAVB8ABqJAAgCA8LQezgwQAQ3QkAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuRBAEGfyAAIAEoAgAiBDYCqAEgACABKAIEIgc2AqwBIABBASAEQRZ2IARB////AXFBAEdqIgIgAkEBTRtBgBAgBEELdiAEQf8PcUEAR2oiAiACQYAQTxtBASAEG2wiAkELdDYCpAEgAkENdCIFELYJIQIgACgCsAEiA0GECE8EQCADEJsHCyAAIAI2ArABIAUQtgkhAiAAKAK0ASIDQYQITwRAIAMQmwcLIAAgAjYCtAEgBwR/IAUQtgkhA0EBBUEACyECAkAgACgCAEUNACAAKAIEIgZBhAhJDQAgBhCbBwsgACADNgIEIAAgAjYCACAHQQJJBH9BAAUgBRC2CSEDQQELIQICQCAAKAIIRQ0AIAAoAgwiBkGECEkNACAGEJsHCyAAIAM2AgwgACACNgIIIAdBA0kEf0EABSAFELYJIQNBAQshAgJAIAAoAhBFDQAgACgCFCIGQYQISQ0AIAYQmwcLIAAgAzYCFCAAIAI2AhAgB0EDSQR/QQAFIAUQtgkhBUEBCyECAkAgACgCGEUNACAAKAIcIgNBhAhJDQAgAxCbBwsgACAFNgIcIAAgAjYCGEEBIQICQCABLQAIQQFHBEBBACECDAELIARBAnQQtgkhBAsCQCAAKAI8RQ0AIAAoAkAiAUGECEkNACABEJsHCyAAQgA3ArgBIAAgBDYCQCAAIAI2AjwgAEHAAWpBADoAAAvsAwEIfyMAQSBrIgckAAJAAkACQCAALQC4AUUEQCAAKAJkIQUMAQsgACgCrAEgACgCsAEiBUECdCAFIAAoArQBIgVqQQJ0EOEIIQggBUECdCIGIAAoAmQiBUsNASAAKAJgIQkgByAIELgKIgo2AgAgByAGNgIEIAYgCkcNAiAIIAkgBhDgCSAIQYQISQ0AIAgQmwcLIABCADcCsAEgAEG4AWpBADoAACAFIAJBAnQiBkkEQCAFIQggBiAFayIJIAAoAlwgBWtLBEAgAEHcAGogBSAJQQRBBBCkBSAAKAJkIQgLIAAoAmAiCyAIQQJ0IgxqIQogCUECTwRAIAYgBUF/c2pBAnQiBgRAIApBACAG/AsACyACQQR0IAVBAnRrIAtqIAxqQQRrIQogCCAJakEBayEICyAKQQA2AgAgCEEBaiEGCyAAIAY2AmQCQCAAKAIIQQFHDQAgACgCYCIFIAYgAyAEIAIgACoClAEQ4wEgACgCDCABQQJ0IAEgAmpBAnQQ4QgiABC4CiEBIAcgBjYCBCAHIAE2AgAgASAGRw0CIAAgBSAGEOAJIABBhAhJDQAgABCbBwsgB0EgaiQADwtBACAGIAVB/OvAABDqBwALIAdBADYCCEEAIAcgB0EEaiAHQQhqQeD5xAAQ9QcAC+wDAQh/IwBBIGsiByQAAkACQAJAIAAtALgBRQRAIAAoAmQhBQwBCyAAKAKsASAAKAKwASIFQQJ0IAUgACgCtAEiBWpBAnQQ4QghCCAFQQJ0IgYgACgCZCIFSw0BIAAoAmAhCSAHIAgQuAoiCjYCACAHIAY2AgQgBiAKRw0CIAggCSAGEOAJIAhBhAhJDQAgCBCbBwsgAEIANwKwASAAQbgBakEAOgAAIAUgAkECdCIGSQRAIAUhCCAGIAVrIgkgACgCXCAFa0sEQCAAQdwAaiAFIAlBBEEEEKQFIAAoAmQhCAsgACgCYCILIAhBAnQiDGohCiAJQQJPBEAgBiAFQX9zakECdCIGBEAgCkEAIAb8CwALIAJBBHQgBUECdGsgC2ogDGpBBGshCiAIIAlqQQFrIQgLIApBADYCACAIQQFqIQYLIAAgBjYCZAJAIAAoAhBBAUcNACAAKAJgIgUgBiADIAQgAiAAKgKYARDaAyAAKAIUIAFBAnQgASACakECdBDhCCIAELgKIQEgByAGNgIEIAcgATYCACABIAZHDQIgACAFIAYQ4AkgAEGECEkNACAAEJsHCyAHQSBqJAAPC0EAIAYgBUH868AAEOoHAAsgB0EANgIIQQAgByAHQQRqIAdBCGpB4PnEABD1BwALvQUAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCAEEBaw4YAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYAAsgASgCACAAKAIEIAAoAgggASgCBCgCDBEAAA8LIABBBGogARCeBA8LIAEoAgBB7KDGAEEYIAEoAgQoAgwRAAAPCyABKAIAQYShxgBBGyABKAIEKAIMEQAADwsgASgCAEGfocYAQRogASgCBCgCDBEAAA8LIAEoAgBBuaHGAEEZIAEoAgQoAgwRAAAPCyABKAIAQdKhxgBBDCABKAIEKAIMEQAADwsgASgCAEHeocYAQRMgASgCBCgCDBEAAA8LIAEoAgBB8aHGAEETIAEoAgQoAgwRAAAPCyABKAIAQYSixgBBDiABKAIEKAIMEQAADwsgASgCAEGSosYAQQ4gASgCBCgCDBEAAA8LIAEoAgBBoKLGAEEMIAEoAgQoAgwRAAAPCyABKAIAQayixgBBDiABKAIEKAIMEQAADwsgASgCAEG6osYAQQ4gASgCBCgCDBEAAA8LIAEoAgBByKLGAEETIAEoAgQoAgwRAAAPCyABKAIAQduixgBBGiABKAIEKAIMEQAADwsgASgCAEH1osYAQT4gASgCBCgCDBEAAA8LIAEoAgBBs6PGAEEUIAEoAgQoAgwRAAAPCyABKAIAQcejxgBBNCABKAIEKAIMEQAADwsgASgCAEH7o8YAQSwgASgCBCgCDBEAAA8LIAEoAgBBp6TGAEEkIAEoAgQoAgwRAAAPCyABKAIAQcukxgBBDiABKAIEKAIMEQAADwsgASgCAEHZpMYAQRMgASgCBCgCDBEAAA8LIAEoAgBB7KTGAEEcIAEoAgQoAgwRAAAPCyABKAIAQYilxgBBGCABKAIEKAIMEQAAC7gDAgl/AX4CQAJAAkAgACgCBCIHRQ0AIAAoAgwiCARAIAAoAgAiAUEIaiEDIAEpAwBCf4VCgIGChIiQoMCAf4MhCgNAIApQBEADQCABQcABayEBIAMpAwAgA0EIaiEDQoCBgoSIkKDAgH+DIgpCgIGChIiQoMCAf1ENAAsgCkKAgYKEiJCgwIB/hSEKCyABIAp6p0EDdkFobGoiAkEYaygCACIEBEAgAkEUaygCACIFQQRrKAIAIgZBeHEiCUEEQQggBkEDcSIGGyAEakkNBCAGQQAgCSAEQSdqSxsNBSAFEKICCyACQQxrKAIAIgQEQCACQQhrKAIAIgJBBGsoAgAiBUF4cSIGQQRBCCAFQQNxIgUbIARqSQ0EIAVBACAGIARBJ2pLGw0FIAIQogILIApCAX0gCoMhCiAIQQFrIggNAAsLIAdBGGwiASAHakEhaiIDRQ0AIAAoAgAgAWsiAEEcaygCACIBQXhxIgJBBEEIIAFBA3EiARsgA2pJDQEgAUEAIAIgA0EnaksbDQIgAEEYaxCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvjAwELfyMAQRBrIgYkAAJAAkAgAyAEbCIHQf////8DSw0AIAdBAnQiCUH9////B08NAAJAIAlFBEBBBCELQQAhBwwBCyAJEHEiC0UNAgsgBkEANgIMIAYgCzYCCCAGIAc2AgQCQCAEBEAgBEEBdCEPA0AgDEECdCEOIA1BAXQhByANQQFqIQ0gAyEJA0AgB0EBaiACTw0DAn8gASAHai8AACIFQf//AXEEQCAFQf8HcSEIIAVBgIACcSEKIAVBgPgBcSIFQYD4AUcEQCAKQRB0IQogBUENdEGAgID8AHEgCEENdHJBgICAwANqIApyIAUNAhogCkGAgIDYA3IgCGdBEGsiBUEXdGsgCCAFQf//A3FBCGp0Qf///wNxcgwCCyAKQRB0IQUgBSAIQQ10ckGAgID+B3IgCA0BGiAFQYCAgPwHcgwBCyAFQRB0CyEIIAYoAgQgDEYEQCAGQQRqQazmxwAQ+gUgBigCCCELCyALIA5qIAg2AgAgBiAMQQFqIgw2AgwgDkEEaiEOIAcgD2ohByAJQQFrIgkNAAsgBCANRw0ACwsgACAGKQIENwIAIABBCGogBkEMaigCADYCACAGQRBqJAAPCyAHIAdBAmogAkG85scAEOoHAAtBnObHABD/BwsAC8wDAQV7QQAhBQJAIARFDQAgAS0AACECAkAgBEEPTQRAIAMhAQNAIAEtAAAgAkYNAiABQQFqIQEgBEEBayIEDQALDAILIAL9DyIHIAP9AAAA/SP9ZCIBBEAgAyABaGohAQwBCyADIARqIQYgA0FwcUEQaiEBAkACQAJAIARBwABJDQAgASAGQUBqIgRLDQAgAyADQQ9xa0FAayEBA0AgByABQSBr/QAEAP0jIgggByABQTBrIgL9AAQA/SMiCf1QIAcgAUEQa/0ABAD9IyIK/VAgByAB/QAEAP0jIgv9UP1kDQIgAUEQaiABQUBrIQEgBE0NAAsgAUEwayEBCyABIAZBEGsiBEsNAQNAIAcgAf0AAAD9I/1kIgJFBEAgBCABQRBqIgFPDQEMAwsLIAEgAmhqIQEMAgsCQCAJ/WQiAUUEQCAI/WQiAQ0BIAr9ZCIBRQRAIAv9ZGggAkEwamohAQwECyABaCACQSBqaiEBDAMLIAIgAWhqIQEMAgsgAWggAkEQamohAQwBCyABIAZPDQEgByAGQRBrIgH9AAAA/SP9ZCICBEAgASACaGohAQwBCwwBCyABIANrIQFBASEFCyAAIAE2AgQgACAFNgIAC5gEAQd/IwBBEGsiCCQAIAFBBGohBAJAAkACQAJAAn8gASgCJCIDQQlJBEBBCCEGIAQhByABQSRqDAELIAEoAgghByADIQYgBAsoAgAiCSACTQRAAkACQAJAAkACQCACQQlPBEBBgYCAgHghBSACIAZGDQpBACEFIAJB/////wNLIAJBAnQiBEH8////B0tyDQogA0EJSQ0CIAZBAnQhAyAGQf////8DTQ0BIAMhBAwKC0GBgICAeCEFIANBCUkNCSABQQA2AgAgCUECdCICBEAgBCAHIAL8CgAACyABIAk2AiQgBkECdCIBQf3///8HSSAGQf////8DTXENBCAIIAE2AgwgCEEANgIIQdjmyABBKyAIQQhqQcikwQBBxMzHABDgBgALIANB/f///wdJDQEgAyEEDAgLIAQQcSIDDQFBBCEFDAcLQQQhBSAHIANBBCAEELsCIgNFDQYMBQsgCUECdCIFRQ0EIAMgByAF/AoAAAwECyAHQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiAHEKICDAQLQfTMxwBBIEGUzccAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAEgAjYCJCABIAM2AgggASAJNgIEIAFBATYCAEGBgICAeCEFCyAAIAQ2AgQgACAFNgIAIAhBEGokAAuYBAEHfyMAQRBrIggkAEEEIQQgAUEEaiEFAkACQAJAAkACfyABKAIUIgNBBUkEQCAFIQYgAUEUagwBCyABKAIIIQYgAyEEIAULKAIAIgkgAk0EQAJAAkACQAJAAkAgAkEFTwRAQYGAgIB4IQcgAiAERg0KQQAhByACQf////8DSyACQQJ0IgVB/P///wdLcg0KIANBBUkNAiAEQQJ0IQMgBEH/////A00NASADIQUMCgtBgYCAgHghByADQQVJDQkgAUEANgIAIAlBAnQiAgRAIAUgBiAC/AoAAAsgASAJNgIUIARBAnQiAUH9////B0kgBEH/////A01xDQQgCCABNgIMIAhBADYCCEHY5sgAQSsgCEEIakHIpMEAQcTMxwAQ4AYACyADQf3///8HSQ0BIAMhBQwICyAFEHEiBA0BQQQhBwwHC0EEIQcgBiADQQQgBRC7AiIERQ0GDAULIAlBAnQiA0UNBCAEIAYgA/wKAAAMBAsgBkEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAMgAUEnaksbDQIgBhCiAgwEC0H0zMcAQSBBlM3HABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyABIAI2AhQgASAENgIIIAEgCTYCBCABQQE2AgBBgYCAgHghBwsgACAFNgIEIAAgBzYCACAIQRBqJAALmgMBBH8CQAJAIAAoAiwiAQRAIAAoAigiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCNCIBBEAgACgCMCIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAoAowBIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAoAowBEN0FCwJAIAAoApABIgFFDQAgASABKAIAIgFBAWs2AgAgAUEBRw0AIAAoApABEN0FCyAAKAI8IgEEQCAAKAI4IgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILIAAoAngiAQRAIAAoAnwiAEEEaygCACIDQXhxIgIgAUEFdCIBQQRBCCADQQNxIgMbckkNASADQQAgAiABQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC50DAQp/IAAoAgAhAwJAAkACQCAAKAIMIgJFDQAgACgCBCEFIAMgACgCCCIBIANBACABIANPG2siASACaiACIAMgAWsiB0sbIgQgAUcEQCAEIAFrIQQgBSABQQxsaiEBA0AgASgCACIGBEAgAUEEaigCACIJQQRrKAIAIghBeHEiCiAGQQJ0IgZBBEEIIAhBA3EiCBtqSQ0EIAhBACAKIAZBJ2pLGw0FIAkQogILIAFBDGohASAEQQFrIgQNAAsLIAIgB00NACACIAdrIgFBACABIAJNGyEBA0AgBSgCACICBEAgBUEEaigCACIHQQRrKAIAIgRBeHEiBiACQQJ0IgJBBEEIIARBA3EiBBtqSQ0DIARBACAGIAJBJ2pLGw0EIAcQogILIAVBDGohBSABQQFrIgENAAsLIAMEQCAAKAIEIgBBBGsoAgAiAUF4cSICIANBDGwiA0EEQQggAUEDcSIBG2pJDQEgAUEAIAIgA0EnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuTBAMHfwF7AX4jAEEwayIEJAAgASgCACEIAkACQAJAAkACQAJAAkACQCABKAIEIgcEQAJAIAdBBE8EQCAIQRxqIQMgB0F8cSIFIQIDQCADIANBCGsgA0EQayADQRhr/VwCAP1WAgAB/VYCAAL9VgIAAyAJ/a4BIQkgA0EgaiEDIAJBBGsiAg0ACyAJIAkgCf0NCAkKCwwNDg8AAQIDAAECA/2uASIJIAkgCf0NBAUGBwABAgMAAQIDAAECA/2uAf0bACECIAUgB0YNAQsgByAFayEGIAVBA3QgCGpBBGohAwNAIAMoAgAgAmohAiADQQhqIQMgBkEBayIGDQALCyABKAIMIgMNAUEAIQMMBAsgASgCDCIDRQ0BDAILIAJBD0sNASADIQYgCCgCBA0BC0EBIQVBACECDAILIAJBACACQQBKG0EBdCECCyACQQBIDQECQCACRQRAQQEhBUEAIQIMAQsgAhBxIgVFDQMLIAMhBgsgBEEANgIQIAQgBTYCDCAEIAI2AgggASkCECEKIAEoAgghASAEIAo3AiQgBCAGNgIgIAQgATYCHCAEIAc2AhggBCAINgIUIARBCGpBjO/BACAEQRRqEMEDDQIgACAEKQIINwIAIABBCGogBEEQaigCADYCACAEQTBqJAAPC0GU7sEAEP8HCwALQZj6xwBB1gAgBEEvakGk7sEAQbTuwQAQ4AYAC/IDAQh/IAEoAgQiBQRAIAEoAgAhBANAAkAgA0EBaiECAn8gAiADIARqLQAAIgjAIglBAE4NABoCQAJAAkACQAJAAkACQAJAAkACQAJAIAgtAPSWQkECaw4DAAECDAtBm9HAACACIARqIAIgBU8bLAAAQUBODQsgA0ECagwKC0Gb0cAAIAIgBGogAiAFTxssAAAhByAIQeABayIGRQ0BIAZBDUYNAgwDC0Gb0cAAIAIgBGogAiAFTxssAAAhBiAIQfABaw4FBAMDAwUDCyAHQWBxQaB/Rw0IDAYLIAdBn39KDQcMBQsgCUEfakH/AXFBDE8EQCAJQX5xQW5HIAdBQE5yDQcMBQsgB0FATg0GDAQLIAlBD2pB/wFxQQJLIAZBQE5yDQUMAgsgBkHwAGpB/wFxQTBPDQQMAQsgBkGPf0oNAwtBm9HAACAEIANBAmoiAmogAiAFTxssAABBv39KDQJBm9HAACAEIANBA2oiAmogAiAFTxssAABBv39KDQIgA0EEagwBC0Gb0cAAIAQgA0ECaiICaiACIAVPGywAAEFATg0BIANBA2oLIgMiAiAFSQ0BCwsgACADNgIEIAAgBDYCACABIAUgAms2AgQgASACIARqNgIAIAAgAiADazYCDCAAIAMgBGo2AggPCyAAQQA2AgAL+AMBB38jAEEQayIHJABBASEJIAEgASgCFCIFQQFqIgY2AhQCQCAGIAEoAhAiCE8NAAJAAkAgASgCDCAGai0AAEEraw4DAQIAAgtBACEJCyABIAVBAmoiBjYCFAsCQAJAAkACfwJAAkAgBiAISQRAIAEgBkEBaiIFNgIUIAEoAgwiCiAGai0AAEEwa0H/AXEiBkEKTw0BAkAgBSAITw0AA0AgBSAKai0AAEEwa0H/AXEiC0EKTw0BIAEgBUEBaiIFNgIUIAZBzJmz5gBHIAtBB0tyIAZBy5mz5gBKcQ0GIAZBCmwgC2ohBiAFIAhHDQALCyAJDQIgBCAGayIFQR91QYCAgIB4cyAFIAZBAEogBCAFSnMbDAMLIAdBCGogASgCDCAIIAYQ+QEgBygCDCECIAcoAgghBEEUEHEiAUUNBCABIAQ2AgwgAUEFNgIAIAAgATYCBCAAQQE2AgAgASACNgIQDAULIAcgCiAIIAUQ+QEgBygCBCECIAcoAgAhBEEUEHEiAUUNAyABIAQ2AgwgAUENNgIAIAAgATYCBCAAQQE2AgAgASACNgIQDAQLIAQgBmoiBUEfdUGAgICAeHMgBSAGQQBIIAQgBUpzGwshBSAAIAEgAiADIAUQ8AQMAgsgACABIAIgA1AgCRDsBQwBCwALIAdBEGokAAvyAwEGfyMAQRBrIgIkACACQQA2AgQCfyABQYABTwRAIAFBP3FBgH9yIQMgAUEGdiEEIAFBgBBJBEAgAiADOgAFIAIgBEHAAXI6AARBAgwCCyABQQx2IQYgBEE/cUGAf3IhBCABQf//A00EQCACIAM6AAYgAiAEOgAFIAIgBkHgAXI6AARBAwwCCyACIAM6AAcgAiAEOgAGIAIgBkE/cUGAf3I6AAUgAiABQRJ2QXByOgAEQQQMAQsgAiABOgAEQQELIQEgAkEIaiAAKAIIKAIAIAJBBGogARCRBAJAAkACQAJAIAItAAgiBkEERwRAIAAoAgQhASAALQAAIgNBBE0gA0EDR3FFBEAgASgCACEDIAFBBGooAgAiBCgCACIFBEAgAyAFEQMACyAEKAIEIgQEQCADQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyAEakkNAyAFQQAgByAEQSdqSxsNBCADEKICCyABQQRrKAIAIgNBeHEiBEEQQRQgA0EDcSIDG0kNBCADQQAgBEE0TxsNBSABEKICCyAAIAIpAwg3AgALIAJBEGokACAGQQRHDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+sDAgd9CX8gACABIAIQzAMgAkEEdCEOIARBAnQiAUFwcSEPIAFBDGpBcHEhECABQQhqQXBxIRFBAiAEIARBAk0bQQJ0QQRqQXBxIRIgACgCYCETIAAoAmQhDUEAIQFBACEAAkACQAJAAkACQANAIAFBBGoiAiANSw0CQwAAgD8gACATaiIMQQhqKAIAIhRBEHZB/wFxs0MAAH9DlSIGIAaSQwAAgL+SIgWLkyAUQRh2s0MAAH9DlSIGIAaSQwAAgL+SIgqLkyIGjEMAAAAAEOAIIQcgDEEPai0AALNDAAB/Q5VDAAAAP5RD2w9JQJQiCBCZAiEJIAgQmwIhCCAAIBBGDQMgACADaiIMIAkgBSAHjCILIAcgBUMAAAAAYBuSIgUgBiAGlCAFIAWUIAogCyAHIApDAAAAAGAbkiIHIAeUkpKRIgWVlDgCACAAIBFGDQQgDEEEaiAJIAcgBZWUOAIAIAAgEkYNBSAMQQhqIAkgBiAFlZQ4AgAgACAPRg0BIAxBDGogCDgCACACIQEgDiAAQRBqIgBHDQALDwsgAUEDaiAEQczVwAAQjAcACyABIAIgDUHc1cAAEOoHAAsgASAEQZzVwAAQjAcACyABQQFqIARBrNXAABCMBwALIAFBAmogBEG81cAAEIwHAAufBQEPfyMAQRBrIgQkAAJAAkACQAJAIAIEQCACQQJ0IgkQcSIIBEAgCEEEayIQLQAAQQNxRSAJRXJFBEAgCEEAIAn8CwALIAkhBgNAIAEoAgAiAyACTw0FIAggA0ECdGogBTYCACABQQRqIQEgBUEBaiEFIAZBBGsiBg0AC0EAIQYgBEEANgIMIARCgICAgMAANwIEQQQhA0EAIQUCQANAIAUgCCAFQQJ0aiILKAIAIgFHBEAgBkEDdCEMA0AgBCgCBCAGRgRAIwBBIGsiAyQAAkACQCAEQQRqIgcoAgAiCkH/////AEsNAEEEIApBAXQiDSANQQRNGyINQQN0IhFB/P///wdLDQAgAyAKBH8gAyAKQQN0NgIcIAMgBygCBDYCFEEEBUEACzYCGCADQQhqQQQgESADQRRqEIUHIAMoAghBAUcNASADKAIQIQ8gAygCDCEOCyAOIA9B4PbHABCTCQALIAMoAgwhCiAHIA02AgAgByAKNgIEIANBIGokACAEKAIIIQMLIAMgDGoiByAFNgIAIAdBBGogATYCACAEIAZBAWoiBjYCDCABIAJPDQMgCygCACEHIAsgCCABQQJ0aiIBKAIANgIAIAEgBzYCACAMQQhqIQwgCygCACIBIAVHDQALCyAFQQFqIgUgAkcNAAsgACAEKQIENwIAIABBCGogBEEMaigCADYCACAQKAIAIgBBeHEiAUEEQQggAEEDcSIAGyAJakkNAyAAQQAgASAJQSdqSxsNBCAIEKICDAYLIAEgAkHw9scAEIwHCwALIABCgICAgMAANwIAIABBCGpBADYCAAwDC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgAyACQdD2xwAQjAcACyAEQRBqJAAL5QMCBH8EfiMAQdAAayIDJAAgA/0MAAAAAAAAAAAAAAAAAAAAAP0LAzggAyABNwMwIAMgAULzytHLp4zZsvQAhTcDICADIAFC7d6R85bM3LfkAIU3AxggAyAANwMoIAMgAELh5JXz1uzZvOwAhTcDECADIABC9crNg9es27fzAIU3AwggAyACLQAAIgU2AkwgA0EIaiIEIANBzABqIgZBBBCCAyAFQQtGBEAgA0EENgJMIAQgBkEEEIIDIAQgAkEBakEEEIIDCyADKQMIIQEgAykDGCEAIAM1AkAhCSADKQM4IQcgAykDICADKQMQIQogA0HQAGokACAHIAlCOIaEIgmFIgdCEIkgByAKfCIHhSIIQhWJIAggACABfCIBQiCJfCIIhSIKQhCJIAogByAAQg2JIAGFIgB8IgFCIIlC/wGFfCIHhSIKQhWJIAogASAAQhGJhSIAIAggCYV8IgFCIIl8IgmFIghCEIkgCCABIABCDYmFIgAgB3wiAUIgiXwiB4UiCEIViSAIIAEgAEIRiYUiACAJfCIBQiCJfCIJhSIIQhCJIAggAEINiSABhSIAIAd8IgFCIIl8IgeFQhWJIABCEYkgAYUiAEINiSAAIAl8hSIAQhGJhSAAIAd8IgBCIImFIACFC/oDAgd/AX4jAEEwayICJAACQAJAAkACQAJAAkAgACgCBCIDDgMBAwIAC0EBIQQgASgCACIFQeCQxgBBByABKAIEIgYoAgwiBxEAAA0EIAIgACgCACIANgIUIAIgAkEUaq1CgICAgNAAhCIJNwMAIAJCATcCJCACQQI2AhwgAkGwkMYANgIYIAIgAjYCICAFIAYgAkEYahDBAw0DQQAhBCADQQN0IgFBCGsiA0UNBCAAIAFqIQggA0EDdiEDIABBCGoiAEEIQQAgAUEIRxtqIQEDQCACIAA2AhQgBUHnkMYAQQIgBxEAAA0EIAIgCTcDACACQgE3AiQgAkECNgIcIAJBsJDGADYCGCACIAI2AiAgBSAGIAJBGGoQwQMNBCABQQhBACABIgAgCEcbaiEBIANBAWsiAw0ACwwEC0GQkMYAQQ5BoJDGABDrBwALIAJCgICAgCAiCSAAKAIAIgCthDcDACACIAkgAEEIaq2ENwMIIAEoAgAgASgCBCACQgI3AiQgAkEDNgIcIAJByJDGADYCGCACIAI2AiAgAkEYahDBAyEEDAILIAIgADUCAEKAgICAIIQ3AwAgASgCACABKAIEIAJCATcCJCACQQI2AhwgAkGwkMYANgIYIAIgAjYCICACQRhqEMEDIQQMAQtBASEECyACQTBqJAAgBAuVBAEHfyMAQRBrIgkkAEEgIQQgASgChAEiAyEGIAFBBGoiBSEHIANBIU8EQCABKAIEIQYgASgCCCEHIAMhBAsCQAJAAkACQCACIAZPBEACQAJAAkACQAJAIAJBIU8EQEGBgICAeCEIIAIgBEYNCkEAIQggAkH/////A0sgAkECdCIFQfz///8HS3INCiADQSFJDQIgBEECdCEDIARB/////wNNDQEgAyEFDAoLQYGAgIB4IQggA0EhSQ0JIAFBADYCACAGQQJ0IgIEQCAFIAcgAvwKAAALIAEgBjYChAEgBEECdCIDQf3///8HSSAEQf////8DTXENBCAJIAM2AgwgCUEANgIIQdjmyABBKyAJQQhqQbTMxwBBxMzHABDgBgALIANB/f///wdJDQEgAyEFDAgLIAUQcSIEDQFBBCEIDAcLQQQhCCAHIANBBCAFELsCIgRFDQYMBQsgBkECdCIDRQ0EIAQgByAD/AoAAAwECyAHQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyADakkNASABQQAgAiADQSdqSxsNAiAHEKICDAQLQfTMxwBBIEGUzccAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAEgAjYChAEgASAENgIIIAEgBjYCBCABQQE2AgBBgYCAgHghCAsgACAFNgIEIAAgCDYCACAJQRBqJAALkgQBB38jAEEQayIJJABBBCEEIAEoAhQiAyEGIAFBBGoiBSEHIANBBU8EQCABKAIEIQYgASgCCCEHIAMhBAsCQAJAAkACQCACIAZPBEACQAJAAkACQAJAIAJBBU8EQEGBgICAeCEIIAIgBEYNCkEAIQggAkH/////A0sgAkECdCIFQfz///8HS3INCiADQQVJDQIgBEECdCEDIARB/////wNNDQEgAyEFDAoLQYGAgIB4IQggA0EFSQ0JIAFBADYCACAGQQJ0IgIEQCAFIAcgAvwKAAALIAEgBjYCFCAEQQJ0IgNB/f///wdJIARB/////wNNcQ0EIAkgAzYCDCAJQQA2AghB2ObIAEErIAlBCGpBtMzHAEHEzMcAEOAGAAsgA0H9////B0kNASADIQUMCAsgBRBxIgQNAUEEIQgMBwtBBCEIIAcgA0EEIAUQuwIiBEUNBgwFCyAGQQJ0IgNFDQQgBCAHIAP8CgAADAQLIAdBBGsoAgAiAUF4cSICQQRBCCABQQNxIgEbIANqSQ0BIAFBACACIANBJ2pLGw0CIAcQogIMBAtB9MzHAEEgQZTNxwAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgASACNgIUIAEgBDYCCCABIAY2AgQgAUEBNgIAQYGAgIB4IQgLIAAgBTYCBCAAIAg2AgAgCUEQaiQAC5IEAQd/IwBBEGsiCSQAQQghBCABKAIkIgMhBiABQQRqIgUhByADQQlPBEAgASgCBCEGIAEoAgghByADIQQLAkACQAJAAkAgAiAGTwRAAkACQAJAAkACQCACQQlPBEBBgYCAgHghCCACIARGDQpBACEIIAJB/////wNLIAJBAnQiBUH8////B0tyDQogA0EJSQ0CIARBAnQhAyAEQf////8DTQ0BIAMhBQwKC0GBgICAeCEIIANBCUkNCSABQQA2AgAgBkECdCICBEAgBSAHIAL8CgAACyABIAY2AiQgBEECdCIDQf3///8HSSAEQf////8DTXENBCAJIAM2AgwgCUEANgIIQdjmyABBKyAJQQhqQbTMxwBBxMzHABDgBgALIANB/f///wdJDQEgAyEFDAgLIAUQcSIEDQFBBCEIDAcLQQQhCCAHIANBBCAFELsCIgRFDQYMBQsgBkECdCIDRQ0EIAQgByAD/AoAAAwECyAHQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyADakkNASABQQAgAiADQSdqSxsNAiAHEKICDAQLQfTMxwBBIEGUzccAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAEgAjYCJCABIAQ2AgggASAGNgIEIAFBATYCAEGBgICAeCEICyAAIAU2AgQgACAINgIAIAlBEGokAAuPAwEEfwJAAkACQCAALQAAIgFBBEYgAUECRnINACAAKAIEIgFFDQAgACgCCCIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCwJAIAAtABAiAUEERiABQQJGcg0AIAAoAhQiAUUNACAAKAIYIgNBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0BIAJBACAEIAFBJ2pLGw0CIAMQogILAkAgAC0AICIBQQRGIAFBAkZyDQAgACgCJCIBRQ0AIAAoAigiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsCQCAALQAwIgFBBEYgAUECRnINACAAKAI0IgFFDQAgACgCOCIAQQRrKAIAIgNBeHEiAkEEQQggA0EDcSIDGyABakkNASADQQAgAiABQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC98DAgR/BH4jAEHQAGsiAyQAIAP9DAAAAAAAAAAAAAAAAAAAAAD9CwM4IAMgATcDMCADIAFC88rRy6eM2bL0AIU3AyAgAyABQu3ekfOWzNy35ACFNwMYIAMgADcDKCADIABC4eSV89bs2bzsAIU3AxAgAyAAQvXKzYPXrNu38wCFNwMIIAMgAi0AACIFNgJMIANBCGoiBCADQcwAaiIGEIsEIAVBC0YEQCADQQQ2AkwgBCAGEIsEIAQgAkEBahCLBAsgAykDCCEBIAMpAxghACADNQJAIQkgAykDOCEHIAMpAyAgAykDECEKIANB0ABqJAAgByAJQjiGhCIJhSIHQhCJIAcgCnwiB4UiCEIViSAIIAAgAXwiAUIgiXwiCIUiCkIQiSAKIAcgAEINiSABhSIAfCIBQiCJQv8BhXwiB4UiCkIViSAKIAEgAEIRiYUiACAIIAmFfCIBQiCJfCIJhSIIQhCJIAggASAAQg2JhSIAIAd8IgFCIIl8IgeFIghCFYkgCCABIABCEYmFIgAgCXwiAUIgiXwiCYUiCEIQiSAIIABCDYkgAYUiACAHfCIBQiCJfCIHhUIViSAAQhGJIAGFIgBCDYkgACAJfIUiAEIRiYUgACAHfCIAQiCJhSAAhQuOBAEFfyMAQSBrIgMkAAJAAkACQCAAKAIAIgFFDQADQAJAIAAoAggiAiAAKAIETw0AIAEgAmotAABBxQBHDQAgACACQQFqNgIIDAILAkAgBEUNACAAKAIQIgFFDQAgAUHwyccAQQMQlwMNAwsgABCJBUH/AXEiAUECRg0CA0ACQAJAAkACQAJAIAAoAgAiBUUNACAAKAIIIgIgACgCBE8NACACIAVqLQAAQfAARw0AIAAgAkEBajYCCCABQQFxDQEgACgCECIBRQ0CIAFBprPFAEEBEJcDDQgMAgsgAUEBcUUNAiAAKAIQIgJFDQJBASEBIAJBq7PFAEEBEJcDRQ0CDAgLIAAoAhAiAUUNACABQeeQxgBBAhCXAw0GCyAAKAIADQEgACgCECICRQ0AQQEhASACQZOzxQBBARCXAw0GCyAEQQFqIQQgACgCACIBDQIMAwsgAyAAEO8CIAMoAgBFBEAgAy0ABCEEIAAoAhAiAgRAQQEhASACQfqyxQBB6rLFACAEQQFxIgIbQRlBECACGxCXAw0GCyAAIAQ6AARBACEBIABBADYCAAwFCyADIAP9AAIA/QsDEAJAIAAoAhAiAUUNACADQRBqIAEQiwINBCAAKAIQIgFFDQAgAUGBtMUAQQMQlwMNBAtBASEBIAAQhgJFDQALCwwBC0EAIQEMAQtBASEBCyADQSBqJAAgAQvTAwEEfwJAAkACQAJAAkAgAkEHTQRAIAINAQwFCyABQQNqQXxxIgQgAUYNASAEIAFrIQUgASAEayEGQQEhAyABIQQDQCAELQAAQS5GDQUgBEEBaiEEIAZBAWoiBg0ACyAFIAJBCGsiA0sNAwwCC0EBIQMgAS0AAEEuRg0DIAJBAUYEQEEAIQMMBAsgAS0AAUEuRg0DIAJBAkYEQEEAIQMMBAsgAS0AAkEuRg0DIAJBA0YEQEEAIQMMBAsgAS0AA0EuRg0DIAJBBEYEQEEAIQMMBAsgAS0ABEEuRg0DIAJBBUYEQEEAIQMMBAsgAS0ABUEuRg0DQQAhAyACQQZGDQMgAS0ABkEuRiEDDAMLIAJBCGshAwsDQEGAgoQIIAEgBWoiBCgCACIGQa7cuPECc2sgBnJBgIKECCAEQQRqKAIAIgRBrty48QJzayAEcnFBgIGChHhxQYCBgoR4Rw0BIAVBCGoiBSADTQ0ACwsgAiAFRgRAQQAhAwwBCyABIAVqIQQgBUF/cyACaiEGA0AgBC0AAEEuRiIDDQEgBEEBaiEEIAYiBUEBayEGIAUNAAsLIAAgAyAALQAEcjoABCAAKAIAIgAoAgAgASACIAAoAgQoAgwRAAAL/wMBBn8jAEHQA2siAiQAIAEtAFgiA0ECRwRAIAJBIGogAUHUAGooAgA2AgAgAkEYaiABQcwAaikCADcDACACQQZqIAFB2wBqLQAAOgAAIAIgAf0AAjz9CwMIIAIgAS8AWTsBBAsgAkH4AWogAkEgaigCADYCACACQfABaiACQRhqKQMANwMAIAJB/wFqIAJBBmotAAA6AAAgAiAC/QADCP0LA+ABIAIgAzoA/AEgAiACLwEEOwD9ASACQSRqIAFBASACQeABaiIBEHICQAJAAkACfyACKAIkQQJGBEAgAigCKCEDIAJBADYCyAMgAkKAgICAEDcCwAMgAkGck8EANgLkASACQqCAgIAONwLoASACIAJBwANqNgLgASADIAEQrwQNAiACKALAAyEEIAIoAsQDIgYgAigCyAMQ7AghASAEBEAgBkEEaygCACIFQXhxIgdBBEEIIAVBA3EiBRsgBGpJDQQgBUEAIAcgBEEnaksbDQUgBhCiAgsgAyADKAIAKAIAEQMAQQEMAQsgAkGEAmoiASACQSRqQbwB/AoAACABENIBIQFBAAshAyAAIAE2AgQgACADNgIAIAJB0ANqJAAPC0GgnsYAQTcgAkHPA2pBtJPBAEHYnsYAEOAGAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALogQBBH8jAEEwayICJAACQAJAAkACQAJAAkACQAJAAkACQAJAQQEgAS0AACIDQSRrIANBI00bQf8BcUEBaw4DAwECAAsgAEEFNgIAIAAgASkCBDcCBAwJCyACIAH9AAIA/QsDACACQQA2AhggAkKAgICAEDcCECACQey1xAA2AiAgAkKggICADjcCJCACIAJBEGo2AhwgAiACQRxqEOEEDQIgACACKQIQNwIEIABBDGogAkEYaigCADYCACAAQQI2AgAgAEEANgIQIAItAABBJEcNCCACLQAEQQNHDQggAigCCCIAKAIAIQEgAEEEaigCACIDKAIAIgQEQCABIAQRAwALIAMoAgQiAwRAIAFBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIANqSQ0EIARBACAFIANBJ2pLGw0FIAEQogILIABBBGsoAgAiAUF4cSIDQRBBFCABQQNxIgEbSQ0FIAFBACADQTRPGw0GIAAQogIMCAsgAEEDNgIAIABCAzcDCAwHC0EQEHEiA0UNBSAAQbC7xAA2AhggACADNgIUIABBADsBBCAAQQA2AgAgAyAB/QACAP0LAgAMBgtBoJ7GAEE3IAJBL2pBhLbEAEHYnsYAEOAGAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACwALIAJBMGokAAu9BAEFfyMAQSBrIgEkAAJAAkACQAJAAkADQCAAEM8FIAAoAggiAiAAKAIEIgNGDQEgAiADTw0CIAAoAgAiBSACai0AACIEQdwARwRAIARBIkcEQCABQRA2AhQgACABQRRqEIsHIQAMBwsgACACQQFqNgIIQQAhAAwGCyAAIAJBAWoiBDYCCAJAAkACfyADIARLBEAgACACQQJqIgI2AgggBCAFai0AAAwBCyABQQQ2AhQgAUEMaiAAIAFBFGoQ8wYgAS0ADA0GIAQhAiABLQANC0Eiaw5UAgAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAIAAAACAAAAAAAAAAIAAAACAAIBAAsgAUEMNgIUIAAgAUEUahCLByEADAYLIAIgA0sNBAJAIAMgAmtBA00EQCAAIAM2AgggAUEENgIUIAFBDGogACABQRRqEPQGDAELIAAgAkEEajYCCCACIAVqIgItAAFBAXQvAYiURiACLQAAQQF0LwGImEZyIAItAAJBAXQvAYiYRnIgAi0AA0EBdC8BiJRGcsFBAE4EQCABQQA7AQwMAQsgAUEMNgIUIAFBDGogACABQRRqEPQGCyABLwEMQQFHDQALIAEoAhAhAAwECyABQQQ2AhQgACABQRRqEIsHIQAMAwsgAiADQbilxgAQjAcACyABKAIQIQAMAQsgAiADIANByKXGABDqBwALIAFBIGokACAAC+EDAwJ/BX4BeyAAKQM4IQcgACkDKCIEIQYCQAJAAkACQAJAAkAgBCAAKQMIIgVSDQAgACkDMCIGIAApAxAiBVINACAHIQYgByAAKQMYIgVRDQELIAUgBlgNACAAQTBqIQJBAiEDA0AgAkEoaikDACEGIAJBGGopAwAiCCEFAkAgBCAIUg0AIAJBIGopAwAiBSACKQMAIgRSDQAgByEEIAYiBSAHUQ0DCyAEIAVYDQIgAkEgaiECIAYhByAIIQQgASADQQFqIgNHDQALDAILIABBMGohAkECIQMDQAJAIAJBKGopAwAhBiACQRhqKQMAIgghBQJAAkAgBCAIUg0AIAJBIGopAwAiBSACKQMAIgRSDQAgByEEIAYiBSAHUQ0BCyAEIAVWDQELIAJBIGohAiAGIQcgCCEEIAEgA0EBaiIDRw0BDAULCyABIANGDQMMAgsgASADRw0BCyABQQF2IQMgAUEFdCAAakEgayECA0AgAP0AAwAhCSAAIAL9AAMA/QsDACACIAn9CwMAIABBEGoiAf0AAwAhCSABIAJBEGoiAf0AAwD9CwMAIAEgCf0LAwAgAkEgayECIABBIGohACADQQFrIgMNAAsMAQsgACABQQAgAUEBcmdBAXRBPnMQqgELC9YDAQt/IwBBEGsiCCQAAkACQAJAAkAgAyAEbCIHQf////8DSw0AIAdBAnQiCkH9////B08NAAJAIApFBEBBBCELQQAhBwwBCyAKEHEiC0UNAgsgCEEANgIMIAggCzYCCCAIIAc2AgQgAxBxIgxFDQEgDEEEayIQKAIAIglBA3EiB0UgA0VyRQRAIAxBACAD/AsACwJAIAQEQCAGIAWTIQZBACEHA0AgDUECdCEOIAdBAWogAyEPIAwhCQNAIAIgB00NAyAJIAEgB2otAAAgCS0AAGoiEToAACAIKAIEIA1GBEAgCEEEakGs6ccAEPoFIAgoAgghCwsgCyAOaiAFIAYgEUH/AXGzQwAAf0OVlJI4AgAgCCANQQFqIg02AgwgCUEBaiEJIA5BBGohDiAEIAdqIQcgD0EBayIPDQALIgcgBEcNAAsgECgCACIJQQNxIQcLIAAgCCkCBDcCACAAQQhqIAhBDGooAgA2AgAgCUF4cSIAQQRBCCAHGyADakkNAyAHQQAgACADQSdqSxsNBCAMEKICIAhBEGokAA8LIAcgAkGc6ccAEIwHAAtBjOnHABD/BwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuOAwEEfwJAAkAgACgCDCICQYCAgIB4ckGAgICAeEcEQCAAKAIQIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAhhBgICAgHhHBEAgAEEYahD2AgsgACgCACICBEAgACgCBCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAJ4IgJBgICAgHhyQYCAgIB4RwRAIAAoAnwiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsCQCAAKAKEASICRQ0AIAAoAogBIgAoAgAiAwRAIAIgAxEDAAsgACgCBCIARQ0AIAJBBGsoAgAiA0F4cSIBQQRBCCADQQNxIgMbIABqSQ0BIANBACABIABBJ2pLGw0CIAIQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALjAMBBH8CQAJAIAAoAgwiAkGAgICAeHJBgICAgHhHBEAgACgCECIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAIYQYCAgIB4RwRAIABBGGoQ9QILIAAoAgAiAgRAIAAoAgQiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsgACgCWCICQYCAgIB4ckGAgICAeEcEQCAAKAJcIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILAkAgACgCZCICRQ0AIAAoAmgiACgCACIDBEAgAiADEQMACyAAKAIEIgBFDQAgAkEEaygCACIDQXhxIgFBBEEIIANBA3EiAxsgAGpJDQEgA0EAIAEgAEEnaksbDQIgAhCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvJAwINfwF+An8gAyAFQQFrIg0gASgCFCIIaiIHSwRAIAUgASgCECIOayEPIAEoAhwhCyABKAIIIQogASkDACEUA0ACQCABAn8CQCAUIAIgB2oxAACIQgGDUARAIAEgBSAIaiIINgIUIAYNAwwBCyAKIAsgCiAKIAtJGyAGGyIJIAUgBSAJSRshDCACIAhqIRAgCSEHAkACQAJAA0AgByAMRgRAQQAgCyAGGyEMIAohBwNAIAcgDE0EQCABIAUgCGoiAjYCFCAGRQRAIAFBADYCHAsgACACNgIIIAAgCDYCBEEBDAwLIAdBAWsiByAFTw0FIAcgCGoiCSADTw0DIAQgB2otAAAgAiAJai0AAEYNAAsgASAIIA5qIgg2AhQgDyAGRQ0GGgwHCyAHIAhqIhEgA08NAiAHIBBqIRIgBCAHaiAHQQFqIQctAAAgEi0AAEYNAAsgESAKa0EBaiEIIAZFDQMMBQsgCSADQfiexwAQjAcACyADIAggCWoiACAAIANJGyADQYifxwAQjAcACyAHIAVB6J7HABCMBwALQQALIgc2AhwgByELCyAIIA1qIgcgA0kNAAsLIAEgAzYCFEEACyEHIAAgBzYCAAvtAwIFfwF7QQJBAyACQQhGGyEJAkACQCAFBEAgAUEBayADbiEGIAMhByACIQoDQCAGRQ0CIAZBAWshBiAIIAAgB2otAABqIQggAyAHaiEHIApBAWsiCg0ACyAJQQFqIQkLIARFDQECeyAA/VwAAf2JAf2pASAA/VwABf2JAf2pAf2uASILIAJBHHEiBkEIRg0AGiALIAD9XAAJ/YkB/akB/a4BIgsgBkEMRg0AGiALIAD9XAAN/YkB/akB/a4BCyILIAsgC/0NCAkKCwwNDg8AAQIDAAECA/2uASILIAsgC/0NBAUGBwABAgMAAQIDAAECA/2uAf0bACEHIAIgBkcEQCACIAZrIQogACAGakEBaiEGA0AgByAGLQAAaiEHIAZBAWohBiAKQQFrIgoNAAsLIAlBAWohCSAHIAhqIQgMAQsgByABQdjixAAQjAcAC0EBIAlBAWt0IAhqIAl2IgcgB0GAfyAFGyAEGyEEIANBAWohCCABQQFrIgUgA2shBiAFIANuIQVBACEHAkACQANAIAUgB0YNAiACIAZNBEAgAgRAIAAgCGogBCAC/AsACyAGIANrIQYgAyAIaiEIIAIgB0EBaiIHRg0CDAELC0EAIAIgBkG44sQAEOoHAAsPCyAIIAEgAUHI4sQAEOoHAAvdAwIEfgZ/IAEpAxAgASkDGCACEPIDIQUgASgCBCIJIAWncSEHIAVCGYhC/wCDQoGChIiQoMCAAX4hBiABKAIAIQoCQAJAIAItAAAiC0ELRwRAA0AgByAKaikAACIEIAaFIgNCf4UgA0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIDUEUEQANAIAogA3qnQQN2IAdqIAlxQWhsaiIMQRhrLQAAIAtGDQQgA0IBfSADgyIDUEUNAAsLIAQgBEIBhoNCgIGChIiQoMCAf4NCAFINAyAHIAhBCGoiCGogCXEhBwwACwALIAIoAAEhCwNAIAcgCmopAAAiBCAGhSIDQn+FIANCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiA1BFBEADQCAKIAN6p0EDdiAHaiAJcUFobGoiDEEYay0AAEELRgRAIAxBF2soAAAgC0YNBAsgA0IBfSADgyIDUEUNAAsLIAQgBEIBhoNCgIGChIiQoMCAf4NQRQ0CIAcgCEEIaiIIaiAJcSEHDAALAAsgAEEMOgAMIAAgATYCBCAAIAw2AgAPCyABKAIIRQRAIAEgAUEQahDAAQsgACABNgIIIAAgBTcDACAAIAIoAAA2AAwgAEEQaiACQQRqLQAAOgAAC40DAQR/AkACQCAAKALQASICQYCAgIB4ckGAgICAeEcEQCAAKALUASIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAIAQQJHBEAgABCKAgsgACgCxAEiAgRAIAAoAsgBIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAtwBIgJBgICAgHhyQYCAgIB4RwRAIAAoAuABIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILAkAgACgC6AEiAkUNACAAKALsASIAKAIAIgMEQCACIAMRAwALIAAoAgQiAEUNACACQQRrKAIAIgNBeHEiAUEEQQggA0EDcSIDGyAAakkNASADQQAgASAAQSdqSxsNAiACEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC40DAQR/AkACQCAAKALIASICQYCAgIB4ckGAgICAeEcEQCAAKALMASIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAIAQQJHBEAgABDAAgsgACgCvAEiAgRAIAAoAsABIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIAAoAtQBIgJBgICAgHhyQYCAgIB4RwRAIAAoAtgBIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILAkAgACgC4AEiAkUNACAAKALkASIAKAIAIgMEQCACIAMRAwALIAAoAgQiAEUNACACQQRrKAIAIgNBeHEiAUEEQQggA0EDcSIDGyAAakkNASADQQAgASAAQSdqSxsNAiACEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9wDAQd/IwBBIGsiAyQAIAAoAgwhBAJAAkACQCAAKAIUIgEgACgCECICSQRAA0AgASAEai0AACIFQQlrIgdBF0tBASAHdEGTgIAEcUVyDQIgACABQQFqIgE2AhQgASACRw0ACyACIQELIAMgBCACIAFBAWoiACACIAAgAkkbEPkBIAMoAgQhACADKAIAIQJBFBBxIgFFDQIgASACNgIMIAFBBTYCACABIAA2AhAMAQsgBUHuAEYEQCAAIAFBAWoiBjYCFAJAIAIgBk0NACAAIAFBAmoiBTYCFAJAIAQgBmotAABB9QBHDQAgBSAGIAIgAiAGSRsiBkYNASAAIAFBA2oiBzYCFCAEIAVqLQAAQewARwRAIAchBQwBCyAGIAdGDQEgACABQQRqIgU2AhRBACEBIAQgB2otAABB7ABGDQMLIANBEGogBCACIAUQ+QEgAygCFCEAIAMoAhAhAkEUEHEiAUUNAyABIAI2AgwgAUEJNgIAIAEgADYCEAwCCyADQQhqIAQgAiAGEPkBIAMoAgwhACADKAIIIQJBFBBxIgFFDQIgASACNgIMIAFBBTYCACABIAA2AhAMAQsgACADQR9qQcjAwQAQ7gEgABDrBSEBCyADQSBqJAAgAQ8LAAvGAwINfwF+IAMgBUEBayINIAEoAhQiCGoiB0sEQCAFIAEoAhAiDmshDyABKAIcIQsgASgCCCEKIAEpAwAhFANAAkAgAQJ/AkAgFCACIAdqMQAAiEIBg1AEQCABIAUgCGoiCDYCFCAGDQMMAQsgCiALIAogCiALSRsgBhsiCSAFIAUgCUkbIQwgAiAIaiEQIAkhBwJAAkACQANAIAcgDEYEQEEAIAsgBhshDCAKIQcDQCAHIAxNBEAgASAFIAhqIgI2AhQgBkUEQCABQQA2AhwLIAAgAjYCCCAAIAg2AgQgAEEBNgIADwsgB0EBayIHIAVPDQUgByAIaiIJIANPDQMgBCAHai0AACACIAlqLQAARg0ACyABIAggDmoiCDYCFCAPIAZFDQYaDAcLIAcgCGoiESADTw0CIAcgEGohEiAEIAdqIAdBAWohBy0AACASLQAARg0ACyARIAprQQFqIQggBkUNAwwFCyAJIANB+J7HABCMBwALIAMgCCAJaiIAIAAgA0kbIANBiJ/HABCMBwALIAcgBUHonscAEIwHAAtBAAsiBzYCHCAHIQsLIAggDWoiByADSQ0ACwsgASADNgIUIABBADYCAAvzAwIEfwJ9IwBBEGshAiAAvCIDQR92IQQCQAJ9IAACfwJAAkACQAJAIANB/////wdxIgFB0Ni6lQRPBEAgAUGAgID8B0sEQCAADwsgA0EASCIDRSABQZfkxZUES3ENAiADRQ0BIAJDAACAgCAAlTgCCCACKgIIGiABQbTjv5YETQ0BDAcLIAFBmOTF9QNNBEAgAUGAgIDIA00NA0EAIQEgAAwGCyABQZKrlPwDTQ0DCyAAQzuquD+UIARBAnQqAuSwSZL8AAwDCyAAQwAAAH+UDwsgAiAAQwAAAH+SOAIMIAIqAgwaIABDAACAP5IPCyAERSAEawsiAbIiBUMAcjG/lJIiACAFQ46+vzWUIgaTCyEFIAAgBSAFIAUgBZQiACAAQxVSNbuUQ4+qKj6SlJMiAJRDAAAAQCAAk5UgBpOSQwAAgD+SIQUgAUUNAAJAAkACQCABQf8ATARAIAFBgn9ODQMgBUMAAIAMlCEFIAFBm35NDQEgAUHmAGohAQwDCyAFQwAAAH+UIQUgAUH+AUsNASABQf8AayEBDAILIAVDAACADJQhBUG2fSABIAFBtn1NG0HMAWohAQwBCyAFQwAAAH+UIQVB/QIgASABQf0CTxtB/gFrIQELIAUgAUEXdEGAgID8A2pBgICA/AdxvpQhBQsgBQuiAwEFfyAALwEcIQECf0EAIAAvAR4iAkH//wFxIgNBgPgBSw0AGkEAIAFB//8BcSIEQYD4AUsNABogAsFBAE4EQCABIAJJIAHBQQBODQEaIAIgBHJBAEcMAQsgAcFBAEggASACS3ELIQQgAiABIAQbIAEgA0GB+AFJGyEBAkAgAC8BICIAQf//AXEiAkGA+AFLDQAgAUH//wFxIgNBgPgBSw0AIADBQQBOBEAgAcFBAE4EQCAAIAFB//8DcUshBQwCCyAAIANyQQBHIQUMAQsgAcFBAEggACABQf//A3FJcSEFCwJ/IAAgASAFGyABIAJBgfgBSRsiAUH//wFxRQRAIAFBEHQMAQsgAUH/B3EhACABQYCAAnEhAiABQYD4AXEiAUGA+AFGBEAgAkEQdCIBQYCAgPwHciAARQ0BGiABIABBDXRyQYCAgP4HcgwBCyACQRB0IgIgAUENdEGAgID8AHEgAEENdHJBgICAwANqciABDQAaIAJBgICA2ANyIABnQRBrIgFBF3RrIAAgAUH//wNxQQhqdEH///8DcXILvhCJBAugAwIGfwZ+QQQhAyAAIAAoAjhBBGo2AjhBBCECAn4CQCAAKAI8IgRFDQBBCCAEayIFQQQgBUEESSIHGyEGAn4gBwRAQQAhAkIADAELIAE1AAALIQggBiACQQFySwRAIAEgAmozAAAgAkEDdK2GIAiEIQggAkECciECCyAAIAApAzAgAiAGSQR+IAEgAmoxAAAgAkEDdK2GIAiEBSAICyAEQQN0QThxrYaEIgg3AzAgBUEFTwRAIAAgBEEEajYCPA8LIAAgACkDGCAIhSIJIAApAwh8IgsgACkDECIKQg2JIAogACkDAHwiCoUiDHwiDSAMQhGJhTcDECAAIA1CIIk3AwggACALIAlCEImFIglCFYkgCSAKQiCJfCIJhTcDGCAAIAggCYU3AwAgBEEEayECIARBCEYNAEEAIQNCAAwBC0EAIQUgATUAAAshCCACIANBAXJLBEAgASAFaiADajMAACADQQN0rYYgCIQhCCADQQJyIQMLIAAgAiADSwR+IAEgAyAFamoxAAAgA0EDdK2GIAiEBSAICzcDMCAAIAI2AjwL3wMCBX8BfiMAQTBrIgQkAAJAAkACQAJAAkACQAJAIAEgAigCLBETACIIQv////8PVg0AIAinIgNBAEgNACADQQF2IQcCQCADQf7///8HcSIGRQRAQQIhAwwBCyAGEHEiA0UNAiADQQRrLQAAQQNxRSAGRXJFBEAgA0EAIAb8CwALIAchBQsgBEEIaiABIAMgBiACKAI0EQYAIAQoAghBBkcEQCAAIAT9AAMI/QsDACAAQSBqIARBKGopAwA3AwAgAEEQaiAEQRhq/QADAP0LAwAgBUUNByADQQRrKAIAIgBBeHEiASAFQQF0IgJBBEEIIABBA3EiABtqSQ0DIABBACABIAJBJ2pLGw0EIAMQogIMBwsgACAHNgIMIAAgAzYCCCAAIAU2AgQgAEEGNgIADAYLIABCAzcDCCAAQQM2AgAgAigCACIABEAgASAAEQMACyACKAIEIgBFDQUgAUEEaygCACICQXhxIgVBBEEIIAJBA3EiAhsgAGpJDQMgAkEAIAUgAEEnaksbDQQgARCiAgwFCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgBEEwaiQAC98DAgV/AX4jAEEwayIEJAACQAJAAkACQAJAAkACQCABIAIoAiwREwAiCEL/////D1YNACAIpyIDQQBIDQAgA0ECdiEHAkAgA0H8////B3EiBkUEQEEEIQMMAQsgBhBxIgNFDQIgA0EEay0AAEEDcUUgBkVyRQRAIANBACAG/AsACyAHIQULIARBCGogASADIAYgAigCNBEGACAEKAIIQQZHBEAgACAE/QADCP0LAwAgAEEgaiAEQShqKQMANwMAIABBEGogBEEYav0AAwD9CwMAIAVFDQcgA0EEaygCACIAQXhxIgEgBUECdCICQQRBCCAAQQNxIgAbakkNAyAAQQAgASACQSdqSxsNBCADEKICDAcLIAAgBzYCDCAAIAM2AgggACAFNgIEIABBBjYCAAwGCyAAQgM3AwggAEEDNgIAIAIoAgAiAARAIAEgABEDAAsgAigCBCIARQ0FIAFBBGsoAgAiAkF4cSIFQQRBCCACQQNxIgIbIABqSQ0DIAJBACAFIABBJ2pLGw0EIAEQogIMBQsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIARBMGokAAveAwEKfyMAQSBrIgMkACADQQA2AhAgA0KAgICAwAA3AgggA0EANgIcIANCgICAgMAANwIUIAEoAgghByABKAIAIQgCQAJAAkAgASgCBCIGIAEoAgwiCkcEQCACKAIIIQsgAigCBCEJIAIoAgAhDEEEIQIDQCAGQQRqKAIAIgEgCUEIaigCACIFTw0CAkAgCUEEaigCACABQSRsaiAMLQAAQQJ0QQxxaioCCCALKgIAXUUEQCADKAIUIARGBEAgA0EUakHEk8EAEIsGIAMoAhghAgsgAiAEQQJ0aiABNgIAIAMgBEEBaiIENgIcDAELIAMoAhAiBSADKAIIRgRAIANBCGpB1JPBABCLBgsgAygCDCAFQQJ0aiABNgIAIAMgBUEBajYCEAsgBkEIaiIGIApHDQALCyAHBEAgCEEEaygCACIBQXhxIgIgB0EDdCIEQQRBCCABQQNxIgEbakkNAiABQQAgAiAEQSdqSxsNAyAIEKICCyAAIAMpAgg3AgAgACADKQIUNwIMIABBCGogA0EQaigCADYCACAAQRRqIANBHGooAgA2AgAgA0EgaiQADwsgASAFQdTAxwAQjAcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv7AwIGfwF7IwBBMGsiBCQAIARBGGr9DAAAAAAAAAAAAAAAAAAAAAD9CwMAIAQgCf0LAwgCQAJAAkACQAJAAkADQAJAIARBKGogASAEQQhqQSAQ5AICQAJAIAQtACgiA0EERwRAAkAgA0EBaw4DAgADCgsgBCgCLC0ACEEjRg0EDAkLIAQoAiwiA0EhTw0CIAIoAgAgAigCCCIBayADSQRAIAIgASADQQFBARCkBSACKAIIIQELIAMEQCACKAIEIAFqIARBCGogA/wKAAALIAAgAzYCBCACIAEgA2o2AgggAEEEOgAADAkLIAQtAClBI0YNAgwHCyAEKAIsIgMtAAhBI0cNBiADKAIAIQUgA0EEaigCACIGKAIAIgcEQCAFIAcRAwALIAYoAgQiBgRAIAVBBGsoAgAiB0F4cSIIQQRBCCAHQQNxIgcbIAZqSQ0DIAdBACAIIAZBJ2pLGw0EIAUQogILIANBBGsoAgAiBUF4cSIGQRBBFCAFQQNxIgUbSQ0EIAVBACAGQTRPGw0FIAMQogIMAQsLQQAgA0EgQfybxwAQ6gcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAAgBCkDKDcCAAsgBEEwaiQAC8kDAQt/IwBBEGsiByQAAkACQAJAAkAgAyAEbCIGQf////8DSw0AIAZBAnQiCUH9////B08NAAJAIAlFBEBBBCEKQQAhBgwBCyAJEHEiCkUNAgsgB0EANgIMIAcgCjYCCCAHIAY2AgQgAxBxIgtFDQEgC0EEayIPKAIAIghBA3EiBkUgA0VyRQRAIAtBACAD/AsACwJAIAQEQEEAIQYDQCAMQQJ0IQ0gBkEBaiADIQ4gCyEIA0AgAiAGTQ0DIAggASAGai0AACAILQAAaiIQOgAAIAcoAgQgDEYEQCAHQQRqQdzpxwAQ+gUgBygCCCEKCyAKIA1qIAUgEMCyQwAA/kKVlDgCACAHIAxBAWoiDDYCDCAIQQFqIQggDUEEaiENIAQgBmohBiAOQQFrIg4NAAsiBiAERw0ACyAPKAIAIghBA3EhBgsgACAHKQIENwIAIABBCGogB0EMaigCADYCACAIQXhxIgBBBEEIIAYbIANqSQ0DIAZBACAAIANBJ2pLGw0EIAsQogIgB0EQaiQADwsgBiACQczpxwAQjAcAC0G86ccAEP8HCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC94DAQN/IwBBIGsiBSQAIAEoAhBFBEAgAUF/NgIQIAVBCiACIAMQqQMCQAJAIAUoAgBBAXEEQCADIAUoAgRBAWoiBE8NASAFQQA2AhggBUEBNgIMIAVBiILIADYCCCAFQgQ3AhAgBUEIakHMjcgAEI0IAAsCQCABKAIcIgRFBEBBACEEDAELIAEoAhggBGpBAWstAABBCkcNAEEAIQQgAUEANgIcIAFBADoAIAsgASgCFCAEayADTQRAIAAgAUEUaiACIAMQ/QYMAgsgAwRAIAEoAhggBGogAiAD/AoAAAsgAEEEOgAAIAEgAyAEajYCHAwBCwJAIAEoAhwiBkUNAAJAAkAgASgCFCAGayAETQRAIAVBCGogAUEUaiACIAQQ/QYgBS0ACEEERg0BIAAgBSkDCDcCAAwECyAEBEAgASgCGCAGaiACIAT8CgAACyABIAQgBmoiBjYCHAwBCyABKAIcIQYLIAZFDQAgAUEANgIcIAFBADoAIAsgAiAEaiEGIAMgBGsiAiABKAIUTwRAIAAgAUEUaiAGIAIQ/QYMAQsgAgRAIAEoAhggBiAC/AoAAAsgAEEEOgAAIAEgAjYCHAsgASABKAIQQQFqNgIQIAVBIGokAA8LQaiHyAAQsAoAC5cDAQV/AkACQAJAAkACQCABRQRAIABFDQEgAEEIayIBKAIAQQFHDQIgACgCECEGIAAoAgwhBSAAKAIIIQQgACgCBCECIAFBADYCAAJAIAFBf0YNACAAQQRrIgMgAygCAEEBayIDNgIAIAMNACAAQQxrKAIAIgBBeHEiA0EgQSQgAEEDcSIAG0kNBSAAQQAgA0HEAE8bDQYgARCiAgsgBCgCACIABEAgAiAAEQMACyAEKAIEIgAEQCACQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyAAakkNBSABQQAgBCAAQSdqSxsNBiACEKICCyAGKAIAIgAEQCAFIAARAwALIAYoAgQiAEUNAyAFQQRrKAIAIgFBeHEiAkEEQQggAUEDcSIBGyAAakkNBCABQQAgAiAAQSdqSxsNBSAFEKICDAMLIABFDQAgAEEIayIAIAAoAgBBAWsiATYCACABDQIgABDXBA8LEI4KAAtBjNrAAEE/EI8KAAsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvnBAIHfwJ9Qay2yQAoAgAiAkGktskAKAIARgRAIwBBIGsiASQAAkBBpLbJACgCACIEQdWq1SpNBH9BBCAEQQF0IgMgA0EETRsiA0EMbCEGIAEgBAR/IAEgBEEMbDYCHCABQai2yQAoAgA2AhRBBAVBAAs2AhggAUEIakEEIAYgAUEUahCFByABKAIIQQFHDQEgASgCECEDIAEoAgwFQQALIANByJXBABCTCQALQai2yQAgASgCDDYCAEGktskAIAM2AgAgAUEgaiQAC0GotskAKAIAIgEgAkEMbGoiAyAAKQIANwIAIANBCGoiBCAAQQhqKAIANgIAQay2yQAgAkEBajYCACAEKAIAIQYgAygCBCEEIAMqAgAhCAJAIAJFDQAgCCAIWwRAIAIhBQNAAkAgASAFIgBBAWsiA0EBdiIFQQxsaiICKgIAIgkgCVsgCCAJX0VxQX8gCCAJYBsiBwRAIAdBAEoNASAAIQUMBAsgAigCBCIHIARHBEAgBCAHSw0BIAAhBQwECyAGIAIoAghLDQAgACEFDAMLIAEgAEEMbGoiACACKQIANwIAIABBCGogAkEIaigCADYCACADQQFLDQALDAELIAIhBQNAAkAgASAFIgBBAWsiA0EBdiIFQQxsaiICKgIAIgkgCVsgCCAJX0VxDQAgAigCBCIHIARHBEAgBCAHSw0BIAAhBQwDCyAGIAIoAghLDQAgACEFDAILIAEgAEEMbGoiACACKQIANwIAIABBCGogAkEIaigCADYCACADQQJPDQALCyABIAVBDGxqIgAgBjYCCCAAIAQ2AgQgACAIOAIAC5UDAQV/AkAgAy0AAyIGIAMtAAQiCGsiBSAFQR91IgVzIAVrQQF0IAMtAAIiBSADLQAFIgdrIgQgBEEfdSIEcyAEa0EBdmogAkH/AXFLDQAgAy0AACADLQABIgJrIgQgBEEfdSIEcyAEayABQf8BcSIESw0AIAIgBWsiAiACQR91IgJzIAJrQf8BcSAESw0AIAQgBSAGayICIAJBH3UiAnMgAmsiAkH/AXFJDQAgBCIFIAMtAAcgAy0ABiIGayIEIARBH3UiBHMgBGtJDQAgBSAGIAdrIgYgBkEfdSIGcyAGa0H/AXFJDQAgByAIayIBIAFBH3UiAXMgAWsiAUH/AXEgBUsNACAAQf8BcSACQf8BcUkEQEEBIAMQ4gUaDwsgAEH/AXEiACABQf8BcSIBSSADEOIFIQIgACABSQ0AIANB/wEgAy0ABSACQQFqQQF1IgBrIgFBACABQQBKGyIBIAFB/wFOGzoABSADQf8AQYB/IAAgAy0AAmpBgAFrIgAgAEGAf0wbIgAgAEH/AE4bQYABczoAAgsLxwMCAn8EfiMAQdAAayIEJAAgBP0MAAAAAAAAAAAAAAAAAAAAAP0LAzggBCABNwMwIAQgAULzytHLp4zZsvQAhTcDICAEIAFC7d6R85bM3LfkAIU3AxggBCAANwMoIAQgAELh5JXz1uzZvOwAhTcDECAEIABC9crNg9es27fzAIU3AwggBEEIaiIFIAIgAxCCAyAEQf8BOgBPIAUgBEHPAGpBARCCAyAEKQMIIQEgBCkDGCEAIARBQGs1AgAhCCAEKQM4IQYgBCkDICAEKQMQIQkgBEHQAGokACAGIAhCOIaEIgiFIgZCEIkgBiAJfCIGhSIHQhWJIAcgACABfCIBQiCJfCIHhSIJQhCJIAkgBiAAQg2JIAGFIgB8IgFCIIlC/wGFfCIGhSIJQhWJIAkgASAAQhGJhSIAIAcgCIV8IgFCIIl8IgiFIgdCEIkgByABIABCDYmFIgAgBnwiAUIgiXwiBoUiB0IViSAHIAEgAEIRiYUiACAIfCIBQiCJfCIIhSIHQhCJIAcgAEINiSABhSIAIAZ8IgFCIIl8IgaFQhWJIABCEYkgAYUiAEINiSAAIAh8hSIAQhGJhSAAIAZ8IgBCIImFIACFC9wDAgN9BH8gACABIAIQzAMCQAJAAkAgAgRAIAAqAoQBIAAqAoABIgaTIQcgACgCYCEBIAAoAmQhC0EBIQgDQCAKQQNqIAtPDQIgCEEBayIJIARPBEAgCSEIDAULIAQgCWsiCUEAIAQgCU8bIglBAUYNBCAJQQJGDQNDAAB/Q0MAAAAAIAMqAgAgBpMgB5VDAAB/Q5QiBSAFQwAAAABdGyIFIAVDAAB/Q14bELkHIQUgASABLQADQRh0Qf8BIAX8AUEAIAVDAAAAAGAbIAVDAAB/Q14bckH/AUMAAH9DQwAAAAAgA0EEaioCACAGkyAHlUMAAH9DlCIFIAVDAAAAAF0bIgUgBUMAAH9DXhsQuQciBfwBQQAgBUMAAAAAYBsgBUMAAH9DXhtBCHRyQf8BQwAAf0NDAAAAACADQQhqKgIAIAaTIAeVQwAAf0OUIgUgBUMAAAAAXRsiBSAFQwAAf0NeGxC5ByIF/AFBACAFQwAAAABgGyAFQwAAf0NeG0EQdHI2AgAgAUEQaiEBIApBBGohCiAIQQNqIQggA0EMaiEDIAJBAWsiAg0ACwsgAEEBOgC4AQ8LIAogCkEEaiALQaTgwAAQ6gcACyAIQQFqIQgLIAggBEG04MAAEIwHAAvVAwEKfyMAQSBrIgMkACADQQA2AhAgA0KAgICAwAA3AgggA0EANgIcIANCgICAgMAANwIUIAEoAgghByABKAIAIQgCQAJAAkAgASgCBCIGIAEoAgwiCkcEQCACKAIIIQsgAigCBCEJIAIoAgAhDEEEIQIDQCAGQQRqKAIAIgEgCSgCCCIFTw0CAkAgCSgCBCABQRhsaiAMLQAAQQJ0aioCACALKgIAXUUEQCADKAIUIARGBEAgA0EUakHEk8EAEIsGIAMoAhghAgsgAiAEQQJ0aiABNgIAIAMgBEEBaiIENgIcDAELIAMoAhAiBSADKAIIRgRAIANBCGpB1JPBABCLBgsgAygCDCAFQQJ0aiABNgIAIAMgBUEBajYCEAsgBkEIaiIGIApHDQALCyAHBEAgCEEEaygCACIBQXhxIgIgB0EDdCIEQQRBCCABQQNxIgEbakkNAiABQQAgAiAEQSdqSxsNAyAIEKICCyAAIAMpAgg3AgAgACADKQIUNwIMIABBCGogA0EQaigCADYCACAAQRRqIANBHGooAgA2AgAgA0EgaiQADwsgASAFQdy7xwAQjAcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv5AwEEfyABQRh2IQIgAUEQdiEDQQghBSABQQh2IQQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQf8BcUHBAGsOGAIPDw8EDw8PAw8PDw8PDw8PBg8PDwEABQ8LIAJB0ABHIARB/wFxQcUAR3IgA0H/AXFBwgBHcg0OIABBAToAAA8LIARB/wFxQdAARyADQf8BcUE4R3INDSACQcwAaw4NBw0NDQ0NDQ0NDQ0NCAYLIARB/wFxQcwAaw4DCQwIDAsgAkHQAEcgBEH/AXFBwwBHcg0LIANB/wFxQcMARg0DDAsLIAJBxgBHIARB/wFxQdgAR3IgA0H/AXFByQBHcg0KIABBCToAAA8LIAJBIEcgBEH/AXFBzQBHciADQf8BcUHQAEdyDQkgAEEKOgAADwsgBEH/AXFByQBHIAJBxgBHciADQf8BcUHGAEdyDQhBACEFCyAAIAU6AAAPCyACQSBHDQYgAEECOgAADwsgAEEDOgAADwsgAEEEOgAADwsgA0H/AXFByQBrDgUBAwMDAgMLIAJByABHIANB/wFxQdAAR3INAiAAQQc6AAAPCyACQc0ARw0BIABBBToAAA8LIAJBxgBHDQAgAEEGOgAADwsgACACOgAEIAAgAzoAAyAAIAQ6AAIgACABOgABIABBCzoAAAuYBQEDfyMAQeApayICJAAgAkEPakEAQdAp/AsAQcAAQYDyAhDBBCIDBEAgA0E/akFAcSIBQgA3AjAgAUHAgAI2AgwgAUEAOgAEIAFBgAg2AgAgAUIANwMQIAH9DAAAAAAAAAAAAAAAAAAAAAD9CwMYIAFBADYCKCABQQE2AkggAUEAOgBAIAFCgYCAgBA3AjggAf0MAAAAAAAAAAAAAAAAAAAAAP0LAkwgAUEAOgCgASABQQA2ApwBIAFBIDYCbCAB/QwAAAAAAAAAAAAAAAAAAAAA/QsEcCABIAFBgPEAajYCCCABQdwAav0MAAAAAAAAAAAAAAAAAAAAAP0LAgAgAUGAAWpCADcDACABQZEBakIANwAAIAFCADcCjAEgAUGhAWogAkEMakHTKfwKAAAgAUH0KmpBAEHYxQD8CwAgAUGA8gI2AshwIAEgAzYCxHAgAUHUAGpBADYCACABQQA2AhQgAUL/////HzcDeCABQYCIPDYCACABQQA6AKABIAFBADYCnAEgAUKAgAI3A5ABIAFBADoAQCABQQE2AjggAUIANwMwIAFB5ABqQX82AgAgAEHUAGpBADYCACAAQgA3AkwgAEE4akEANgIAIABBMGpCADcDACAAQSBq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAAQRBq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAA/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAAQQA2AkggAEEdNgJEIABBHjYCQCAAIAE2AjwgAkHgKWokAA8LIAJBfDYCCCACQQA2AgwjAEEQayIAJAAgAEHw5cgANgIMIAAgAkEIajYCCEEAIABBCGpB7JzIACAAQQxqQeycyAAgAkEMakGY58gAEPIEAAuvAwEIfwJAAkACQCAAKAIIIgQgACgCFCICTQRAIAAgBDYCFCACIARGDQEgAiAEayEFIAAoAhAgBEEYbGohAQNAIAFBFGooAgAiAEEFTwRAIAFBCGooAgAiA0EEaygCACICQXhxIgcgAEECdCIAQQRBCCACQQNxIgIbakkNBCACQQAgByAAQSdqSxsNBSADEKICCyABQRhqIQEgBUEBayIFDQALDAELIAIhAyAEIAJrIgYgACgCDCACa0sEQCAAQQxqIAIgBkEEQRgQpAUgACgCFCEDCyAAKAIQIQggBkEDcSIFBEAgAyAFaiAEIAJrIAVrIQYgCCADQRhsaiEBA0AgAUEANgIAIAFBFGpBADYCACABQRhqIQEgBUEBayIFDQALIQMLIAIgBGtBfE0EQCAIIANBGGxqIQEDQCABQQA2AgAgAUHcAGpBADYCACABQcQAakIANwIAIAFBLGpCADcCACABQRRqQgA3AgAgAUHgAGohASADQQRqIQMgBkEEayIGDQALCyAAIAM2AhQLDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALkwQCBn8BfiMAQTBrIgIkACACQQhqrUKAgICAoAyEIQggASgCBCEEIAEoAgAhBUEAIQEDQCACAn8CQAJAAkACQAJAAkACQAJAAkACQCAAIAFqLQAAIgMOKAAHBwcHBwcHBwEDBwcCBwcHBwcHBwcHBwcHBwcHBwcHBwcEBwcHBwUGCyACQgA3AQogAkHc4AA7AQgMCAsgAkIANwEKIAJB3OgBOwEIDAcLIAJCADcBCiACQdzkATsBCAwGCyACQgA3AQogAkHc3AE7AQgMBQsgAkIANwEKIAJB3MQAOwEIDAQLIAJCADcBCiACQdzOADsBCAwDCyADQdwARg0BCyADEOECRQRAIAJBIGoiBiADQQ9xLQDctkU6AAAgAkGw4MCBAzYAGyACIANBBHYtANy2RToAHyADQQFyZ0ECdiIDIAJBGGoiB2pB+wA6AAAgByADQQJrIgNqQdzqATsAACACQRpqQQA6AAAgAkH9ADoAISACQRBqIAYvAQA7AQAgAkEAOwEYIAIgAikBGDcDCEEKDAMLIAIgAzYCCEGAASEDQYEBDAILIAJCADcBCiACQdy4ATsBCAtBACEDQQILOgAVIAIgAzoAFCACIAg3AwAgAkIBNwIkIAJBATYCHCACQaD4xwA2AhggAiACNgIgIAUgBCACQRhqEMEDIgNFBEAgAUEBaiIBQQRHDQELCyACQTBqJAAgAwu0AwICfgt/IwBBIGsiBCQAIAFBCGohDQJAAkADQCANKAIAQQJHDQECfyABKAKcAyIFIAEpA6ADIgMgBa0iAiACIANWG6ciBkYEQEEBIQhBJSEJQQAhCkEAIQtBACEMQQAhBSAHQYB+cUEkcgwBCyAEQQxqIAEgASgCmAMgBmogBSAGa0EAENYBIAQpAhQiAkIoiKchCiACQiCIpyELIAJCGIinIQwgAkIQiKchBSACQgiIpyEJIAQoAhwhDiAEKAIQIQYgAqchCCAGIAQoAgwNABogASABKQOgAyAGrXw3A6ADIAdBgH5xQShyCyIHQf8BcUEoRwRAIAAgCjsACSAAIA42AgwgACALOgAIIAAgDDoAByAAIAU6AAYgACAJOgAFIAAgCDoABCAAIAc6AAAgAEELaiAKQRB2OgAAIABBA2ogB0EYdjoAACAAIAdBCHY7AAEMAwsgCEH/AXFBAkcgCUH/AXFByQBHciAFQf8BcUHFAEcgDEH/AXFBzgBHcnIgC0H/AXFBxABHcg0AC0Gk+MYAQShBnJjHABDrBwALIABBKDoAACAAIA02AgQLIARBIGokAAvuAwEJfQJ9IAAqAgwiA0MAAAAAXUUEQCAAKgIEIQUgACoCACEGIAAqAggMAQsgA4whAyAAKgIEjCEFIAAqAgCMIQYgACoCCIwLIQhDAACAPyEEQwAAgD8gAyADQwAAgD9eGxD2BCICIAKSIglDAAAAP5QQmQIiAotDvTeGNV1FBEAgBSAClSEHIAYgApUhBCAIIAKVIQELIAcgB4sgBIuSIAGLkiIDlSECIAQgA5UhAwJAIAFDAAAAAF1FBEAgAiEBDAELQwAAgD8gA4uTIgEgAYwgAkMAAAAAYBshAUMAAIA/IAKLkyICIAKMIANDAAAAAGAbIQMLQf8BQwAAf0NDAAAAACAJQ9sPSUCVQwAAf0OUIgIgAkMAAAAAXRsiAiACQwAAf0NeGxC5ByIC/AFBACACQwAAAABgGyACQwAAf0NeG0EQdEH/AUMAAH9DQwAAAAAgAUMAAIA/kkMAAAA/lEMAAH9DlCIBIAFDAAAAAF0bIgEgAUMAAH9DXhsQuQciAfwBQQAgAUMAAAAAYBsgAUMAAH9DXhtBCHRyQf8BQwAAf0NDAAAAACADQwAAgD+SQwAAAD+UQwAAf0OUIgEgAUMAAAAAXRsiASABQwAAf0NeGxC5ByIB/AFBACABQwAAAABgGyABQwAAf0NeG3IL4wMBBH8jAEFAaiICJAACQAJAAkACQAJAAkACQAJAIAAtAABBAWsOAwECAwALIAIgACgCBDYCBEEUEHEiAEUNBCAAQRBqQdyCyAAoAAA2AAAgAEHMgsgA/QAAAP0LAAAgAkEUNgIQIAIgADYCDCACQRQ2AgggAiACQQRqrUKAgICA8AGENwMgIAIgAkEIaq1CgICAgJAIhDcDGCABKAIAIAEoAgQgAkICNwI0IAJBAzYCLCACQZCHyAA2AiggAiACQRhqNgIwIAJBKGoQwQMhACACKAIIIgFFDQMgAigCDCIEQQRrKAIAIgNBeHEiBUEEQQggA0EDcSIDGyABakkNBSADQQAgBSABQSdqSxsNBiAEEKICDAMLIAIgAC0AAUECdCIAKAKspEk2AhwgAiAAKALUpUk2AhggAiACQRhqrUKAgICAoAGENwMIIAEoAgAgASgCBCACQgE3AjQgAkEBNgIsIAJBoPjHADYCKCACIAJBCGo2AjAgAkEoahDBAyEADAILIAEgACgCBCIAKAIAIAAoAgQQlwMhAAwBCyAAKAIEIgAoAgAgASAAKAIEKAIQEQIAIQALIAJBQGskACAADwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuxAwIHfwF+IwBBIGsiAyQAAkAgAAJ/AkAgASgCFCICIAEoAhAiBUkEQCABKAIMIQcCfgJAA0AgAiAHai0AACIGQQlrIghBF0tBASAIdEGTgIAEcUVyDQEgASACQQFqIgI2AhQgAiAFRw0ACyAFIQJCAAwBC0KAAgsgBq1CEIaEQoCCuANRDQELIANBGGogARCVAyADKAIYIAAgAygCHDYCBEEBagwBCyABIAJBAWoiBDYCFAJAAkAgBCAFTw0AIAEgAkECaiIGNgIUAkAgBCAHai0AAEH1AEcNACAGIAQgBSAEIAVLGyIERg0BIAEgAkEDaiIINgIUIAYgB2otAABB7ABHBEAgCCEGDAELIAQgCEYNASABIAJBBGoiBjYCFEEAIAcgCGotAABB7ABGDQMaCyADQRBqIAcgBSAGEPkBIAMoAhQhBCADKAIQIQFBFBBxIgJFDQMgAkEJNgIADAELIANBCGogByAFIAQQ+QEgAygCDCEEIAMoAgghAUEUEHEiAkUNAiACQQU2AgALIAIgATYCDCAAIAI2AgQgAiAENgIQQQILNgIAIANBIGokAA8LAAv3AwEGfyMAQRBrIgIkAAJAAkACQAJAAkAgASgCAEGUgICAeEYEQCABKAIMIgNFDQEgAiABKAIIIgQQqAMgAigCACIBQYCAgIB4RgRAIAIoAgQhAwwFCyACKAIEIQUCQCADQQFHBEAgAigCCCEHIAIgBEEQahCoAyACKAIAIgRBgICAgHhHDQEgAigCBCEDIAFFDQYgBUEEaygCACIEQXhxIgZBBEEIIARBA3EiBBsgAWpJDQQgBEEAIAYgAUEnaksbDQUgBRCiAgwGC0EBIAJBD2pBlOLAABDbBiEDIAFFDQUgBSABQQEQogcMBQsgAigCBCEGIANBAkcEQCACQQI2AgAgA0H+////AGpB/////wBxQQJqIAJB6JXBABDbBiEDIABBgICAgHg2AgAgACADNgIEIAEEQCAFIAFBARCiBwsgBEUNBiAGIARBARCiBwwGCyAAIAIoAgg2AhQgACAGNgIQIAAgBDYCDCAAIAc2AgggACAFNgIEIAAgATYCAAwFCyABIAJBD2pBlOLAABCVCCEBIABBgICAgHg2AgAgACABNgIEDAQLQQAgAkEPakGU4sAAENsGIQMMAgtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAAgAzYCBCAAQYCAgIB4NgIACyACQRBqJAALxQMCBH8BfiMAQTBrIgUkAAJAAkACQAJAAkACQAJAIAEgAigCLBETACIHQv////8PVg0AIAenIgNBAEgNAAJAIAdQIgYEQEEBIQQMAQsgAxBxIgRFDQIgBEEEay0AAEEDcUUgA0VyDQAgBEEAIAP8CwALIAVBCGogASAEIAMgAigCNBEGACAFKAIIQQZHBEAgACAF/QADCP0LAwAgAEEgaiAFQShqKQMANwMAIABBEGogBUEYav0AAwD9CwMAIAYNByAEQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyADakkNAyAAQQAgASADQSdqSxsNBCAEEKICDAcLIAAgAzYCDCAAIAQ2AgggACADNgIEIABBBjYCAAwGCyAAQgM3AwggAEEDNgIAIAIoAgAiAARAIAEgABEDAAsgAigCBCIARQ0FIAFBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIABqSQ0DIAJBACADIABBJ2pLGw0EIAEQogIMBQsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIAVBMGokAAvfAwIFfwF+IwBBIGsiAiQAIAAoAgghBCAAKAIEIQVBASEDIAEoAgBB6LLFAEEBIAEoAgQoAgwRAAAhAAJAIARFBEAgACEDDAELAkAgAA0AIAEtAApBgAFxBEAgASgCACIAQdz4xwBBASABKAIEIgYoAgwRAAANASACQQE6AA8gAiAGNgIEIAIgADYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgBSACQRBqELoFDQEgAigCEEHZgcIAQQIgAigCFCgCDBEAACEDDAELIAUgARC6BSEDCyAEQQFGDQAgBUEEaiEAIARBAnRBBGshBANAAn9BASADQQFxDQAaAkAgAS0ACkGAAXEEQCABKQIAIQcgAkEBOgAPIAIgBzcCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgACACQRBqELoFRQ0BQQEMAgtBASABKAIAQeeQxgBBAiABKAIEKAIMEQAADQEaIAAgARC6BQwBCyACKAIQQdmBwgBBAiACKAIUKAIMEQAACyEDIABBBGohACAEQQRrIgQNAAsLQQEhACADRQRAIAEoAgBB6bLFAEEBIAEoAgQoAgwRAAAhAAsgAkEgaiQAIAALzAMCBX8DfiMAQTBrIgQkACAEIAM2AgwgBCACNgIIAkACQAJAAkAgASgCDEUNACABKQMQIAEpAxggAiADEJUEIQkgASgCBCIHIAmncSEFIAlCGYhC/wCDQoGChIiQoMCAAX4hCyABKAIAIQEDQAJAIAEgBWopAAAiCiALhSIJQn+FIAlCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiCVBFBEADQCABIAl6p0EDdiAFaiAHcUFobGoiBkEQaygCACADRgRAIAIgBkEUaygCACADENsHRQ0DCyAJQgF9IAmDIglQRQ0ACwsgCiAKQgGGg0KAgYKEiJCgwIB/g1BFDQIgBSAIQQhqIghqIAdxIQUMAQsLIAZBBGsoAgAiAUEASA0CIAZBCGsoAgAhAgJAIAFFBEBBASEDDAELIAEQcSIDRQ0ECyABBEAgAyACIAH8CgAACyAAIAE2AgggACADNgIEIAAgATYCAAwBCyAEQQI2AhQgBEHo1sEANgIQIARCATcCHCAEIARBCGqtQoCAgIAghDcDKCAEIARBKGo2AhggBEEQahCSByEBIABBgICAgHg2AgAgACABNgIECyAEQTBqJAAPC0HYmsgAEP8HCwAL1QMCBH0FfwJAAkAgAgRAIAAoAggiCyABayIJQQAgCSALTRshDUMAAIA/IAAqAkAgAC0AWEECRiIJG0MAAAAAIAAqAjwgCRsiB5MhCCAAKAIEIAFBGGxqQQ5qIQpBACEJQQAhAANAIAAgDUYNAyAJQQNqIgwgBEsgAEHUqtWqBUtyDQJDAAB/Q0MAAAAAIANBBGoqAgAgB5MgCJVDAAB/Q5QiBSAFQwAAAABdGyIFIAVDAAB/Q14bELkHIQUgCkH/AUMAAH9DQwAAAAAgA0EIaioCACAHkyAIlUMAAH9DlCIGIAZDAAAAAF0bIgYgBkMAAH9DXhsQuQciBvwBQQAgBkMAAAAAYBsgBkMAAH9DXhtBEHRB/wEgBfwBQQAgBUMAAAAAYBsgBUMAAH9DXhtBCHRyQf8BQwAAf0NDAAAAACADKgIAIAeTIAiVQwAAf0OUIgUgBUMAAAAAXRsiBSAFQwAAf0NeGxC5ByIF/AFBACAFQwAAAABgGyAFQwAAf0NeG3IiCTsBACAKQQJqIAlBEHY6AAAgA0EMaiEDIApBGGohCiAMIQkgAiAAQQFqIgBHDQALCw8LIAkgDCAEQeTDxwAQ6gcACyAAIAFqIAtB7LvHABCMBwALuQMBB38gACABKAIAIgQ2AqQBIAAgASgCBCIFNgKoASAAQQEgBEEWdiAEQf///wFxQQBHaiICIAJBAU0bQYAQIARBC3YgBEH/D3FBAEdqIgIgAkGAEE8bQQEgBBtsIgJBC3QiBjYCoAEgAkENdCIHELYJIQIgACgCrAEiCEGECE8EQCAIEJsHCyAAIAI2AqwBIAUEQCAGQQF0ELYJIQJBASEDCwJAIAAoAgBFDQAgACgCBCIGQYQISQ0AIAYQmwcLIAAgAjYCBCAAIAM2AgAgBUECSQR/QQAFIAcQtgkhAkEBCyEDAkAgACgCCEUNACAAKAIMIgZBhAhJDQAgBhCbBwsgACACNgIMIAAgAzYCCCAFQQNJBH9BAAUgBxC2CSEDQQELIQICQCAAKAIQRQ0AIAAoAhQiBUGECEkNACAFEJsHCyAAIAM2AhQgACACNgIQQQEhAgJAIAEtAAgiAUEBRwRAQQAhAgwBCyAEQQJ0ELYJIQQLAkAgACgCMEUNACAAKAI0IgNBhAhJDQAgAxCbBwsgAEIANwKwASAAIAE6AJwBIAAgBDYCNCAAIAI2AjAgAEG4AWpBADoAAAvjAwIEfwF+IwBBIGsiAiQAIAAoAgghBCAAKAIEIQUgASgCAEHossUAQQEgASgCBCgCDBEAACEDAkAgBEUEQCADIQAMAQsCf0EBIAMNABogAS0ACkGAAXEEQEEBIAEoAgAiA0Hc+McAQQEgASgCBCIAKAIMEQAADQEaIAJBAToADyACIAA2AgQgAiADNgIAIAJB4IHCADYCFCACIAEpAgg3AhggAiACQQ9qNgIIIAIgAjYCEEEBIAUgAkEQahDKBA0BGiACKAIQQdmBwgBBAiACKAIUKAIMEQAADAELIAUgARDKBAshACAEQQFGDQAgBUEBaiEDIARBAWshBANAIABBAXEhBQJ/QQEgBQ0AGgJAIAEtAApBgAFxBEAgASkCACEGIAJBAToADyACIAY3AgAgAkHggcIANgIUIAIgASkCCDcCGCACIAJBD2o2AgggAiACNgIQIAMgAkEQahDKBEUNAUEBDAILQQEgASgCAEHnkMYAQQIgASgCBCgCDBEAAA0BGiADIAEQygQMAQsgAigCEEHZgcIAQQIgAigCFCgCDBEAAAshACADQQFqIQMgBEEBayIEDQALC0EBIQMgAEUEQCABKAIAQemyxQBBASABKAIEKAIMEQAAIQMLIAJBIGokACADC4sDAQR/IwBBEGsiAyQAAn8CQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BQQMhAiAALAAAIgQgBMBBB3UiAHMgAGsiAEH/AXEiBUEKTwRAQQEhAiADIABBAXQiACAAQThqIAVB5ABJG0H+AXEvALi6RTsADCAFQeMASyEAC0EAIAQgAEH/AXEiABtFBEAgAkEBayICIANBC2pqIABBAXQtALm6RToAAAsgASAEQQBOQQFBACADQQtqIAJqQQMgAmsQyAMMAgsgAC0AACECQQMhAANAIAAgA2pBB2ogAkEPcUHctsUAai0AADoAACACQf8BcSIEQQR2IQIgAEEBayEAIARBD0sNAAsgAUEBQYS0xQBBAiAAIANqQQhqQQMgAGsQyAMMAQsgAC0AACECQQMhAANAIAAgA2pBDGogAkEPcUHJgcIAai0AADoAACACQf8BcSIEQQR2IQIgAEEBayEAIARBD0sNAAsgAUEBQYS0xQBBAiAAIANqQQ1qQQMgAGsQyAMLIANBEGokAAuuAwIDfgR/IAAoAgxFBEBBAA8LIAApAxAgACkDGCABEPIDIQIgACgCBCIGIAKncSEFIAJCGYhC/wCDQoGChIiQoMCAAX4hBCAAKAIAIQcCQAJAIAEtAAAiCEELRwRAQQAhAQNAIAUgB2opAAAiAyAEhSICQn+FIAJCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiAlBFBEADQCAIIAcgAnqnQQN2IAVqIAZxQWhsaiIAQRhrLQAARg0FIAJCAX0gAoMiAlBFDQALCyADIANCAYaDQoCBgoSIkKDAgH+DQgBSDQIgBSABQQhqIgFqIAZxIQUMAAsACyABKAABIQhBACEBA0AgBSAHaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyICUEUEQANAIAcgAnqnQQN2IAVqIAZxQWhsaiIAQRhrLQAAQQtGBEAgCCAAQRdrKAAARg0FCyACQgF9IAKDIgJQRQ0ACwsgAyADQgGGg0KAgYKEiJCgwIB/g1BFDQEgBSABQQhqIgFqIAZxIQUMAAsAC0EAIQALIABBGGtBACAAGwvPAwIDfwF+IwBBIGsiAiQAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAgAiBEGAgICAeHMgBEEAThtBAWsOCAECAwQFBgcIAAtBASEDIAEgAkEfakGY58AAEJUIIQEMCQsgAS0ABCEBDAgLIAEvAQQhAQwHCyABKAIEIQEMBgsgASkDCCIFQv////8PWARAIAWnIQEMBQtBASEDIAJBAToACCACIAU3AxAgAkEIaiACQR9qQZjnwAAQ3gYhAQwFCyABLAAEIgFBAEgEQCACQQI6AAggAiABrDcDECACQQhqIAJBH2pBmOfAABDeBiEBQQEhAwwFCyABQf8BcSEBDAMLIAEuAQQiAUEASARAIAJBAjoACCACIAGsNwMQIAJBCGogAkEfakGY58AAEN4GIQFBASEDDAQLIAFB//8DcSEBDAILIAEoAgQiAUEATg0BIAJBAjoACCACIAGsNwMQIAJBCGogAkEfakGY58AAEN4GIQFBASEDDAILIAEpAwgiBUKAgICAEFoEQCACQQI6AAggAiAFNwMQIAJBCGogAkEfakGY58AAEN4GIQFBASEDDAILIAWnIQELCyAAIAE2AgQgACADNgIAIAJBIGokAAvPAwIDfwF+IwBBIGsiAiQAAkACQAJAAkACQAJAAkACQAJAAkACQEEVIAEoAgAiBEGAgICAeHMgBEEAThtBAWsOCAECAwQFBgcIAAtBASEDIAEgAkEfakGo58AAEJUIIQEMCQsgAS0ABCEBDAgLIAEvAQQhAQwHCyABKAIEIQEMBgsgASkDCCIFQv////8PWARAIAWnIQEMBQtBASEDIAJBAToACCACIAU3AxAgAkEIaiACQR9qQajnwAAQ3gYhAQwFCyABLAAEIgFBAEgEQCACQQI6AAggAiABrDcDECACQQhqIAJBH2pBqOfAABDeBiEBQQEhAwwFCyABQf8BcSEBDAMLIAEuAQQiAUEASARAIAJBAjoACCACIAGsNwMQIAJBCGogAkEfakGo58AAEN4GIQFBASEDDAQLIAFB//8DcSEBDAILIAEoAgQiAUEATg0BIAJBAjoACCACIAGsNwMQIAJBCGogAkEfakGo58AAEN4GIQFBASEDDAILIAEpAwgiBUKAgICAEFoEQCACQQI6AAggAiAFNwMQIAJBCGogAkEfakGo58AAEN4GIQFBASEDDAILIAWnIQELCyAAIAE2AgQgACADNgIAIAJBIGokAAv6AgEEfwJAAkACQAJAAkACQAJAIAAtAAAOGgAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAECBAsgAC0ABEEDRw0DIAAoAggiACgCACECIABBBGooAgAiASgCACIDBEAgAiADEQMACyABKAIEIgEEQCACQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyABakkNBiADQQAgBCABQSdqSxsNBSACEKICCyAAQQRrKAIAIgJBeHEiAUEQQRQgAkEDcSICG0kNBSACRSABQTRJcg0CDAQLIAAoAgQiAkUNAiAAKAIIIgBBBGsoAgAiAUF4cSIDQQRBCCABQQNxIgEbIAJqSQ0EIAFFIAMgAkEnak1yDQEMAwsgACgCBCICRQ0BIAAoAggiAEEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAmpJDQMgAUUgAyACQSdqTXINAAwCCyAAEKICCw8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC6gDAwV/AXsBfiMAQZABayICJAAgASgCBCEFIAEoAgAgAiAAKAIAIgT9AAIIIgcgB/0NAAECAwQFBgcICQoLCAkKC/0LBAAgAgJ/IAf9GQYiAUH//wFxRQRAIAFBEHQMAQsgAUH/B3EhACABQYCAAnEhAyABQYD4AXEiAUGA+AFGBEAgA0EQdCEBIAFBgICA/AdyIABFDQEaIAEgAEENdHJBgICA/gdyDAELIANBEHQhAyABQQ10QYCAgPwAcSAAQQ10ckGAgIDAA2ogA3IgAQ0AGiAAIABnQRBrIgBB//8DcUEIanRB////A3EgA0GAgIDYA3IgAEEXdGtyCzYCHCACQSBqIgAgBBCkAyACQTBqIgEgBBCaAyACQUBrIgMgBCkCABDLAiACIAOtQoCAgIDAAoQ3A3AgAkKAgICAoAIiCCABrYQ3A2ggAiAIIACthDcDYCACIAJBHGqtQoCAgIDQAoQ3A1ggAiAIIAKthDcDUCACQgU3AoQBIAJBBjYCfCACQZynxwA2AnggAiACQdAAajYCgAEgBSACQfgAahDBAyACQZABaiQAC8oDAQN/AkAgACgCACIDRQRAIAAoAhAiAEUNASAAQZOzxQBBARCXAw8LAkACfwJAAkAgACgCCCIBIAAoAgRPBEAgACgCECICRQ0BIAJB6rLFAEEQEJcDRQ0BQQEPC0EBIQIgACABQQFqNgIIAkACQAJAAkAgASADai0AAEHOAGsOBQIDAAABAAsgACgCECIBRQ0DIAFB6rLFAEEQEJcDRQ0DDAYLIABBABDVAQ0FIAAoAhAiAQRAIAFB/7TFAEEDEJcDDQYLIABBABDVAUUNBgwFCyAAKAIQIgBFDQUgAEGFtcUAQQUQlwNFDQUMBAsgACAAKAIMQQFqIgE2AgwgAUH0A0sNASAAEK0EDQMDQCAAKAIAIgMEQAJAIAAoAggiASAAKAIETw0AIAEgA2otAABBxQBHDQAgACABQQFqNgIIIAAgACgCDEEBazYCDAwHCyAAKAIQIgEEQCABQYK1xQBBAxCXAw0GCyAAEK0ERQ0BDAULCyAAKAIQIgFFDQAgAUHqssUAQRAQlwMNAwsgAEEAOgAEQQAMAQsgACgCECIBBEAgAUH6ssUAQRkQlwMNAgsgAEEBOgAEQQALIQIgACACNgIACyACDwtBAAuPAwENfyMAQRBrIgYkAAJAIAEtACUNACABKAIEIQcCQCABKAIQIgQgASgCCCIMSw0AIAQgASgCDCICSQ0AIAFBFGoiDSABLQAYIgVqQQFrLQAAIQkgBUEFSSEOA0ACQCACIAdqIQoCQCAEIAJrIgtBB00EQCACIARGDQJBACEDA0AgAyAKai0AACAJRg0CIAsgA0EBaiIDRw0ACwwCCyAGQQhqIAkgCiALEIcFIAYoAghBAXFFDQEgBigCDCEDCyABIAIgA2pBAWoiAjYCDAJAIAIgBUkgAiAMS3INACAOBEAgByACIAVrIgNqIA0gBRDbBw0BIAEoAhwhBCABIAI2AhwgBCAHaiEIIAMgBGshAwwFC0EAIAVBBEHkuMcAEOoHAAsgAiAETQ0BDAILCyABIAQ2AgwLIAFBAToAJQJAIAEtACRBAUYEQCABKAIgIQIgASgCHCEBDAELIAEoAiAiAiABKAIcIgFGDQELIAEgB2ohCCACIAFrIQMLIAAgAzYCBCAAIAg2AgAgBkEQaiQAC70DAgZ/AX4jAEHQAGsiAiQAIAJBIGogACAAKAIAKAIEEQEAIAIgAkEwaq1CgICAgLABhDcDKCACIAIpAyA3AjAgASgCACEFIAEoAgQhBiACQgE3AkRBASEDIAJBATYCPCACQaD4xwA2AjggAiACQShqNgJAAkAgBSAGIAJBOGoQwQMNACABLQAKQYABcUUEQEEAIQMMAQsgAkEYaiAAIAAoAgAoAgQRAQAgAkEQaiACKAIYIAIoAhwoAhgRAQAgAigCECIERQRAQQAhAwwBCyACQQhqIAQgAigCFCIHKAIYEQEAIAIoAgwhACACKAIIIQEgAiAHNgIsIAIgBDYCKCACQQE2AjwgAkGA8cEANgI4IAJCATcCRCACIAJBKGqtQoCAgICwAYQiCDcDMCACIAJBMGo2AkAgBSAGIAJBOGoQngkNAANAIAFFBEBBACEDDAILIAIgASAAKAIYEQEAIAIoAgQgAigCACACIAA2AiwgAiABNgIoIAJBATYCPCACQYDxwQA2AjggAkIBNwJEIAIgCDcDMCACIAJBMGo2AkAhASEAIAUgBiACQThqEJ4JRQ0ACwsgAkHQAGokACADC5QDACAAIARqIQACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQf8BcUEBaw4HBwABAgMEBQYLIABBfU0gAEECaiIBIANNcQ0HIAAgASADQbTZxwAQ6gcACyAAQX1NIABBAmoiASADTXENByAAIAEgA0HE2ccAEOoHAAsgAEF7TSAAQQRqIgEgA01xDQcgACABIANB1NnHABDqBwALIABBe00gAEEEaiIBIANNcQ0HIAAgASADQeTZxwAQ6gcACyAAQXtNIABBBGoiASADTXENByAAIAEgA0H02ccAEOoHAAsgAEF3TSAAQQhqIgEgA01xDQcgACABIANBhNrHABDqBwALIAAgA0kNCCAAIANBlNnHABCMBwALIAAgA0kNBiAAIANBpNnHABCMBwALIAAgAmouAACyDwsgACACai8AALMPCyAAIAJqKAAAsg8LIAAgAmooAACzDwsgACACaioAAA8LIAAgAmorAAC2DwsgACACai0AALNDAAB/Q5UPCyAAIAJqLAAAskMAAH9DlQvSAgEFfwJAAkACQAJAAkACQCAAKAIAIgAoAgAOAgABAwsgACgCCCIBRQ0CIAAoAgQiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQQgAkUgBCABQSdqTXINAQwDCyAALQAEQQNHDQEgACgCCCIDKAIAIQEgA0EEaigCACICKAIAIgQEQCABIAQRAwALIAIoAgQiAgRAIAFBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIAJqSQ0EIARBACAFIAJBJ2pLGw0DIAEQogILIANBBGsoAgAiAUF4cSICQRBBFCABQQNxIgEbSQ0DIAFFDQAgAkE0Tw0CCyADEKICCyAAQQRrKAIAIgNBeHEiAUEYQRwgA0EDcSIDG0kNASADQQAgAUE8TxsNACAAEKICDwtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALkgMBBH8CQAJAAkACQAJAAkAgByAIVgRAIAcgCH0gCFgNAyAGIAcgBn1UIAcgBkIBhn0gCEIBhlpxDQIgBiAIWA0GIAcgBiAIfSIGfSAGVg0GIAIgA08NAUEAIAMgAkG4j8IAEOoHAAsgAEEANgIADwsgASADaiEMIAMhCgJAAkACQANAIAoiCUUNASAJQQFrIgogAWoiCy0AAEE5Rg0ACyALIAstAABBAWo6AAAgAyAJTw0BIAkgAyADQfiEwgAQ6gcACwJAIANFBEBBMSEKDAELIAFBMToAAEEwIQogA0EBayIJRSAJRXINACABQQFqQTAgCfwLAAsgBEEBasEiBCAFwUwgAiADTXINASAMIAo6AAAgA0EBaiEDDAELIAMgCUYNACADIAlrIgVFDQAgASAJakEwIAX8CwALIAIgA0kNAgwDCyACIANPDQJBACADIAJByI/CABDqBwALIABBADYCAA8LQQAgAyACQaiPwgAQ6gcACyAAIAQ7AQggACADNgIEIAAgATYCAA8LIABBADYCAAu8AwIFfwF+IwBBIGsiAiQAAkACQAJAAkACQCABLQCYASIDQQhHDQAgAkEJOgAQIAIgASACQRBqIAEoAoABEOQEAkAgAi0AACIDQR1GBEAgAigCBCIEQYCAgIB4Rw0BQQAhAyABQQA6AJgBDAILIAIpAgQhBwJ/IANFBEAgAiAHNwMQIAenIQMgAikCFCEHQQUMAQsgAigCDCEEQRAQcSIBRQ0EIAEgAzoAACABIAQ2AgwgASAHNwIEIAEgAkEBciIDLwAAOwABIAFBA2ogA0ECai0AADoAACACQYAGOwEQIAIoAhAhA0EACyEEIABB7LvEADYCGCAAIAE2AhQgACAHQiCIPgIMIAAgBz4CCCAAIAM2AgQgACAENgIADAILIAIpAgggASACKAIIIAIoAgwQlgFB/wFxIgFBACABQQhHGyIDOgCYASAERQ0ApyIBQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyAEakkNAyAFQQAgBiAEQSdqSxsNBCABEKICCyAAQQY2AgAgACADOgAECyACQSBqJAAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC5QDAQZ/AkAgACgCaEGAgICAeEcNAAJAAkAgACgCpAEiBUEASA0AIAVBAXQiBkH/////B08NAAJ/IAZFBEBBAiEHQQAMAQsgBhBxIgdFDQIgB0EEay0AAEEDcUUgBkVyRQRAIAdBACAG/AsACyAFCyEGIAAgBTYCcCAAIAc2AmwgACAGNgJoDAILQbjewAAQ/wcLAAsCQAJAIAIEQEEAIQUgACgCbCEHIAAoAnAiCSABayIAQQAgACAJTRsiCiACQQFrIgAgACAKSxsiACAEIAAgBEkbIghBB0sEQCAHIAFBAXRqIQAgAyEGIAhBAWoiBSAFQQdxIgVBCCAFG2siBSEIA0AgACAG/QABAP0LAQAgBkEQaiEGIABBEGohACAIQQhrIggNAAsLIAMgBUEBdGohACAHIAEgBWpBAXRqIQYDQCAEIAVGDQMgBSAKRg0CIAYgAC8BADsBACAGQQJqIQYgAEECaiEAIAIgBUEBaiIFRw0ACwsPCyABIAVqIAlB2N7AABCMBwALIAQgBEHI3sAAEIwHAAuYAwEGfwJAIAAoAnRBgICAgHhHDQACQAJAIAAoAqQBIgVB/////wNLDQAgBUECdCIGQf3///8HTw0AAn8gBkUEQEEEIQdBAAwBCyAGEHEiB0UNAiAHQQRrLQAAQQNxRSAGRXJFBEAgB0EAIAb8CwALIAULIQYgACAFNgJ8IAAgBzYCeCAAIAY2AnQMAgtB6N7AABD/BwsACwJAAkAgAgRAQQAhBSAAKAJ4IQcgACgCfCIJIAFrIgBBACAAIAlNGyIKIAJBAWsiACAAIApLGyIAIAQgACAESRsiCEEDSwRAIAcgAUECdGohACADIQYgCEEBaiIFIAVBA3EiBUEEIAUbayIFIQgDQCAAIAb9AAIA/QsCACAGQRBqIQYgAEEQaiEAIAhBBGsiCA0ACwsgAyAFQQJ0aiEAIAcgASAFakECdGohBgNAIAQgBUYNAyAFIApGDQIgBiAAKAIANgIAIAZBBGohBiAAQQRqIQAgAiAFQQFqIgVHDQALCw8LIAEgBWogCUGI38AAEIwHAAsgBCAEQfjewAAQjAcAC5oDAQZ/AkAgACgCjAFBgICAgHhHDQACQAJAIAAoAqgBIgVBAEgNACAFQQF0IgZB/////wdPDQACfyAGRQRAQQIhB0EADAELIAYQcSIHRQ0CIAdBBGstAABBA3FFIAZFckUEQCAHQQAgBvwLAAsgBQshBiAAIAU2ApQBIAAgBzYCkAEgACAGNgKMAQwCC0HIucEAEP8HCwALAkACQCACBEBBACEFIAAoApABIQcgACgClAEiCSABayIAQQAgACAJTRsiCiACQQFrIgAgACAKSxsiACAEIAAgBEkbIghBB0sEQCAHIAFBAXRqIQAgAyEGIAhBAWoiBSAFQQdxIgVBCCAFG2siBSEIA0AgACAG/QABAP0LAQAgBkEQaiEGIABBEGohACAIQQhrIggNAAsLIAMgBUEBdGohACAHIAEgBWpBAXRqIQYDQCAEIAVGDQMgBSAKRg0CIAYgAC8BADsBACAGQQJqIQYgAEECaiEAIAIgBUEBaiIFRw0ACwsPCyABIAVqIAlB6LnBABCMBwALIAQgBEHYucEAEIwHAAueAwEGfwJAIAAoApgBQYCAgIB4Rw0AAkACQCAAKAKoASIFQf////8DSw0AIAVBAnQiBkH9////B08NAAJ/IAZFBEBBBCEHQQAMAQsgBhBxIgdFDQIgB0EEay0AAEEDcUUgBkVyRQRAIAdBACAG/AsACyAFCyEGIAAgBTYCoAEgACAHNgKcASAAIAY2ApgBDAILQfi5wQAQ/wcLAAsCQAJAIAIEQEEAIQUgACgCnAEhByAAKAKgASIJIAFrIgBBACAAIAlNGyIKIAJBAWsiACAAIApLGyIAIAQgACAESRsiCEEDSwRAIAcgAUECdGohACADIQYgCEEBaiIFIAVBA3EiBUEEIAUbayIFIQgDQCAAIAb9AAIA/QsCACAGQRBqIQYgAEEQaiEAIAhBBGsiCA0ACwsgAyAFQQJ0aiEAIAcgASAFakECdGohBgNAIAQgBUYNAyAFIApGDQIgBiAAKAIANgIAIAZBBGohBiAAQQRqIQAgAiAFQQFqIgVHDQALCw8LIAEgBWogCUGYusEAEIwHAAsgBCAEQYi6wQAQjAcAC40DAQV/IwBBIGsiBiQAAkACQAJAAkAgASgCCCIDQQpJDQACQAJAIAEoAgQiBC0AAEEfRw0AIAQtAAFBiwFHDQAgBC0AAkEIRw0AQQohAiAELQADIgVBBHEEQCADQQxJDQMgAyAELwAKQQxqIgJJDQMLIAVBCHFFDQEgAiADTw0CA0AgAiAEai0AAEUEQCACQQFqIQIMAwsgAyACQQFqIgJHDQALDAILIAZBADYCGEEBIQUgBkEBNgIMIAZBvO3HADYCCCAGQgQ3AhAgACAGQQhqEJUHNgIEDAMLIAVBEHEEQCACIANPDQEDQCACIARqLQAABEAgAyACQQFqIgJHDQEMAwsLIAJBAWohAgsgBUECcUUNASADIAJBAmoiAk8NAQtBACEFIABBADoAAQwBCyACIANLDQFBACEFIAFBADYCCCACIANHBEAgAyACayIDBEAgBCACIARqIAP8CgAACyABIAM2AggLIABBAToAAQsgACAFOgAAIAZBIGokAA8LQQAgAiADQYSkxwAQ6gcAC88DAQV/IwBBIGsiAiQAIAAoAgAiA0EIaiEFQQEhAAJAIAMoAgBBAUYEQCABKAIAIgNByMnEAEEDIAEoAgQiBigCDCIEEQAADQECQCABLQAKQYABcUUEQCADQbuzxQBBASAEEQAADQMgBSABEPIFRQ0BDAMLIANB24HCAEECIAQRAAANAiACQQE6AA8gAiAGNgIEIAIgAzYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgBSACQRBqEPIFDQIgAkHZgcIAQQIQrwMNAgsgA0HejsgAQQEgBBEAACEADAELIAEoAgAiA0H8nMgAQQIgASgCBCIGKAIMIgQRAAANAAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANAiAFIAEQxAUNAiABKAIAIQMgASgCBCgCDCEEDAELIANB24HCAEECIAQRAAANASACQQE6AA8gAiAGNgIEIAIgAzYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgBSACQRBqEMQFDQEgAigCEEHZgcIAQQIgAigCFCgCDBEAAA0BCyADQd6OyABBASAEEQAAIQALIAJBIGokACAAC6ADAQJ/IwBB0ABrIgckACAHQQBB0AD8CwACQCACRQRAIAdC//79+/fv37//ADcDAAwBCyABQQN0IgggBE0EQCAEIAhGDQFBCCAEIAhrIgQgBEEITxsiBEUNASAHIAMgCGogBPwKAAAMAQsgCCAEIARByOjEABDqBwALIAACfyABRQRAIAdBgQE6AEcgB0GBAToAPiAHQYEBOgA1IAdBgQE6ACwgB0GBAToAIyAHQYEBOgAaIAdBgQE6ABEgB0GBAToACEGBf0H/ACACGwwBCwJAIAYEQCAGQQFrIgFFDQEgByAFLQABOgAIIAFBAUYNASAHIAUtAAI6ABEgAUECRg0BIAcgBS0AAzoAGiABQQNGDQEgByAFLQAEOgAjIAFBBEYNASAHIAUtAAU6ACwgAUEFRg0BIAcgBS0ABjoANSABQQZGDQEgByAFLQAHOgA+IAFBB0YNASAHIAUtAAg6AEcMAQtBAUEAQQBBuOjEABDqBwALQYF/Qf8AIAIbIAJFDQAaIAUtAAALOgAAIABBAWogB0HQAPwKAAAgB0HQAGokAAuDAwEBfyMAQSBrIgUkACAAAn8CQCAERQRAIANBBGogAksgA0F7S3JFBEAgACABIANqKgAAOAIEDAILIAVBADYCGCAFQQE2AgwgBUHI28EANgIIIAVCBDcCECAAIAVBCGoQkgc2AgRBAQwCCyADQX1NIANBAmogAk1xRQRAIAVBADYCGCAFQQE2AgwgBUHI28EANgIIIAVCBDcCECAAIAVBCGoQkgc2AgRBAQwCCyAAAn8gASADaiIBLQABQQh0IgIgAS0AAHIiAUH//wFxRQRAIAFBEHQMAQsgAUH/B3EhASACQYCAAnEhAyACQYD4AXEiAkGA+AFGBEAgA0EQdCECIAJBgICA/AdyIAFFDQEaIAFBDXQgAnJBgICA/gdyDAELIANBEHQhAyACQQ10QYCAgPwAcSABQQ10ckGAgIDAA2ogA3IgAg0AGiADQYCAgNgDciABZ0EQayICQRd0ayABIAJB//8DcUEIanRB////A3FyCzYCBAtBAAs2AgAgBUEgaiQAC4QDAgJ/AXsCQAJAIARBBE8EQCACIARBBGtBA24iBSACIAVJGyIFQQNNDQEgAiAFQQFqIgIgAkEDcSICQQQgAhtrIgZrIQIgASAGaiAEIAZBfWxqIQQgAyAGQQNsaiEHA0AgAyAAIAH9XAAA/YkB/akBIgj9GwBBAnRqKAAANgAAIANBA2ogACAI/RsBQQJ0aigAADYAACADQQZqIAAgCP0bAkECdGooAAA2AAAgA0EJaiAAIAj9GwNBAnRqKAAANgAAIAFBBGohASADQQxqIQMgBkEEayIGDQALIQEgByEDDAELIAQNAQ8LA0AgAkUEQEEAQQBBpJrFABCMBwALIAMgACABLQAAQQJ0aigAADYAACADQQNqIQMgAkEBayECIAFBAWohASAEQQNrIgRBA0sNAAsLAkAgAgRAIARBA0cNASADIAAgAS0AAEECdGoiAC8AADsAACADQQJqIABBAmotAAA6AAAPC0EAQQBBhJrFABCMBwALQQBBAyAEQZSaxQAQ6gcAC4EDAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB/wFxQQFrDgcHAAECAwQFBgsgA0F9TSADQQJqIgAgAk1xDQcgAyAAIAJBtNjHABDqBwALIANBfU0gA0ECaiIAIAJNcQ0HIAMgACACQcTYxwAQ6gcACyADQXtNIANBBGoiACACTXENByADIAAgAkHU2McAEOoHAAsgA0F7TSADQQRqIgAgAk1xDQcgAyAAIAJB5NjHABDqBwALIANBe00gA0EEaiIAIAJNcQ0HIAMgACACQfTYxwAQ6gcACyADQXdNIANBCGoiACACTXENByADIAAgAkGE2ccAEOoHAAsgAiADTQ0HIAEgA2osAACyDwsgAiADSw0HIAMgAkGk2McAEIwHAAsgASADai4AALIPCyABIANqLwAAsw8LIAEgA2ooAACyDwsgASADaigAALMPCyABIANqKgAADwsgASADaisAALYPCyADIAJBlNjHABCMBwALIAEgA2otAACzC58DAgF+CH8CQAJAAkACQAJAIAAoAgQiBEUNACAAKAIMIggEQCAAKAIAIgJBCGohAyACKQMAQn+FQoCBgoSIkKDAgH+DIQEDQCABUARAA0AgAkGABGshAiADKQMAIANBCGohA0KAgYKEiJCgwIB/gyIBQoCBgoSIkKDAgH9RDQALIAFCgIGChIiQoMCAf4UhAQsgAiABeqdBA3RBwAdxayIFQQRrKAIAIgZBCU8EQCAFQSBrKAIAIgVBBGsoAgAiB0F4cSIJIAZBAnQiBkEEQQggB0EDcSIHG2pJDQQgB0EAIAkgBkEnaksbDQUgBRCiAgsgAUIBfSABgyEBIAhBAWsiCA0ACwsgBEEGdCICIARqQckAaiIDRQ0AIAAoAgAgAmsiAEHEAGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIANqSQ0DIAJBACAEIANBJ2pLGw0EIABBQGoQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC5cDAgh/AX4CQAJAAkACQAJAIAAoAgQiA0UNACAAKAIMIgYEQCAAKAIAIgFBCGohAiABKQMAQn+FQoCBgoSIkKDAgH+DIQkDQCAJUARAA0AgAUGgAWshASACKQMAIAJBCGohAkKAgYKEiJCgwIB/gyIJQoCBgoSIkKDAgH9RDQALIAlCgIGChIiQoMCAf4UhCQsgASAJeqdBA3ZBbGxqIgRBFGsoAgAiBwRAIARBEGsoAgAiBEEEaygCACIFQXhxIghBBEEIIAVBA3EiBRsgB2pJDQQgBUEAIAggB0EnaksbDQUgBBCiAgsgCUIBfSAJgyEJIAZBAWsiBg0ACwsgAyADQRRsQRtqQXhxIgFqQQlqIgJFDQAgACgCACABayIAQQRrKAIAIgFBeHEiA0EEQQggAUEDcSIBGyACakkNAyABQQAgAyACQSdqSxsNBCAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuZAwEFfwJAIABCgICAgBBUBEAgASECDAELIAFBCGsiAiAAIABCgMLXL4AiAEKAvqjQD358pyIDQZDOAG4iBEGQzgBwIgVB5ABuIgZBAXQvALi6RTsAACABQQRrIAMgBEGQzgBsayIDQf//A3FB5ABuIgRBAXQvALi6RTsAACABQQZrIAUgBkHkAGxrQf//A3FBAXQvALi6RTsAACABQQJrIAMgBEHkAGxrQf//A3FBAXQvALi6RTsAAAsCQCAApyIBQZDOAEkEQCABIQMMAQsgAkEEayECA0AgAiABQZDOAG4iA0HwsX9sIAFqIgRB5ABuIgVBAXQvALi6RTsAACACQQJqIAQgBUHkAGxrQQF0LwC4ukU7AAAgAkEEayECIAFB/8HXL0sgAyEBDQALIAJBBGohAgsCQCADQeMATQRAIAMhAQwBCyACQQJrIgIgAyADQf//A3FB5ABuIgFB5ABsa0H//wNxQQF0LwC4ukU7AAALIAFBCU0EQCACQQFrIAFBMHI6AAAPCyACQQJrIAFBAXQvALi6RTsAAAvpAgEFfwJAIAFBzf97QRAgACAAQRBNGyIAa08NACAAQRAgAUELakF4cSABQQtJGyIEakEMahBxIgJFDQAgAkEIayEBAkAgAEEBayIDIAJxRQRAIAEhAAwBCyACQQRrIgUoAgAiBkF4cSACIANqQQAgAGtxQQhrIgIgAEEAIAIgAWtBEE0baiIAIAFrIgJrIQMgBkEDcQRAIAAgAyAAKAIEQQFxckECcjYCBCAAIANqIgMgAygCBEEBcjYCBCAFIAIgBSgCAEEBcXJBAnI2AgAgASACaiIDIAMoAgRBAXI2AgQgASACEOMCDAELIAEoAgAhASAAIAM2AgQgACABIAJqNgIACwJAIAAoAgQiAUEDcUUNACABQXhxIgIgBEEQak0NACAAIAQgAUEBcXJBAnI2AgQgACAEaiIBIAIgBGsiBEEDcjYCBCAAIAJqIgIgAigCBEEBcjYCBCABIAQQ4wILIABBCGohAwsgAwvbAgIEfwF+IwBB0ABrIgQkACAEIAEgAkGYsMUAQQEQ4QEDQCAEQcQAaiAEEJgCIAQoAkQiA0UNAAsCQCAAIAICfyADQQJHBEAgBCgCSAwBCyACCyIDa0EQTQR+IAIgA0cEQCABIAJqIQYgASADaiEDA0ACfyADLAAAIgFBAE4EQCABQf8BcSECIANBAWoMAQsgAy0AAUE/cSEFIAFBH3EhAiABQV9NBEAgAkEGdCAFciECIANBAmoMAQsgAy0AAkE/cSAFQQZ0ciEFIAFBcEkEQCAFIAJBDHRyIQIgA0EDagwBCyACQRJ0QYCA8ABxIAMtAANBP3EgBUEGdHJyIQIgA0EEagshAyACQcEAa0FfcUEKaiACQTBrIAJBOUsbIgFBEE8NAyABrSAHQgSGhCEHIAMgBkcNAAsLIAAgBzcDCEIBBSAHCzcDACAEQdAAaiQADwtBnLDFABDdCQALmgMDA38EfQF7IwBBEGsiBCQAIAEoAgAiAiABKAIERgR/QQAFIAEgAkEEajYCAAJ/AkAgAigCACICIAEoAggiASgCCCIDSQRAIAQgASgCBCACQSRsaiIBEJoDIAT9AAQAIQkgAS8BFCICQf//AXFFBEAgAkEQdAwDCyACQf8HcSEBIAJBgIACcSEDIAJBgPgBcSICQYD4AUYEQCADQRB0IQIgAkGAgID8B3IgAUUNAxogAiABQQ10ckGAgID+B3IMAwsgA0EQdCEDIAJFDQEgAkENdEGAgID8AHEgAUENdHJBgICAwANqIANyDAILIAIgA0HUwMcAEIwHAAsgASABZ0EQayIBQf//A3FBCGp0Qf///wNxIANBgICA2ANyIAFBF3RrcgshASAJ/R8AIgUgCf0fASIGlEOPws0/ELcKIQcgBSAJ/R8CIgWUQ4/CzT8QtwohCCAGIAWUQ4/CzT8QtwogByAIkpJDAABAQJVD5kAfPxC3CkPbD0lBlCABvpQhBUEBCyEBIAAgBTgCBCAAIAE2AgAgBEEQaiQAC/ACAQN/IwBBEGsiAyQAIAAoAgAhAAJ/AkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENAUEDIQIgAC0AACIAIQQgAEEKTwRAIAMgACAAQeQAbiIEQeQAbGtB/wFxQQF0LwC4ukU7AAxBASECC0EAIAAgBBtFBEAgAkEBayICIANBC2pqIARBAXQtALm6RToAAAsgAUEBQQFBACADQQtqIAJqQQMgAmsQyAMMAgsgAC0AACECQQMhAANAIAAgA2pBB2ogAkEPcUHctsUAai0AADoAACACQf8BcSIEQQR2IQIgAEEBayEAIARBD0sNAAsgAUEBQYS0xQBBAiAAIANqQQhqQQMgAGsQyAMMAQsgAC0AACECQQMhAANAIAAgA2pBDGogAkEPcUHJgcIAai0AADoAACACQf8BcSIEQQR2IQIgAEEBayEAIARBD0sNAAsgAUEBQYS0xQBBAiAAIANqQQ1qQQMgAGsQyAMLIANBEGokAAuHAwEGf0EBIQdBASEFAkACfwJAAkACQAJAIAQtAL4CQQFrDgYAAQUCAAMFCwALQQMhBUEBIQhBACEHDAMLQQEhBkEAIQdBAgwBC0EAIQdBBAshBQsCQCADIAVBAWoiCW4iAyABIAVBAXQiAW4iCiADIApJGyIDRQ0AAkAgBCgCzAFBgYCAgHhGDQAgBCgC1AEgAUcNACAEKALQASEEA0AgAiAALQAAOgAAAkAgBw0AIAJBAWogAEECai0AADoAACAGDQAgAkECaiAAQQRqLQAAOgAAIAgNACACQQNqIABBBmotAAA6AAALIAIgBWpBf0EAIAAgBCABENsHGzoAACAAIAFqIQAgAiAJaiECIANBAWsiAw0ACwwBCwNAIAIgAC0AADoAAAJAIAcNACACQQFqIABBAmotAAA6AAAgBg0AIAJBAmogAEEEai0AADoAACAIDQAgAkEDaiAAQQZqLQAAOgAACyACIAVqQf8BOgAAIAAgAWohACACIAlqIQIgA0EBayIDDQALCwv/AgIFfQV/IAAgASACEMwDIAJBA2whDSAAKAJgQQxqIQFBAiAEIARBAk0bQQNuQQNsIQ4gACoCjAEgACoCiAEiBZNDAAB+Q5UhBiAAKAJkIQpBACECQQAhAAJAAkACQAJAA0AgAkEEaiILIApLDQIgASgCACICQQh2IQxDAAAAACEHQwAAAAAhCCACQf8BcQRAIAUgBiACQQFrQf8BcbOUkhCJBCEICyAMQf8BcQRAIAUgBiAMQQFrQf8BcbOUkhCJBCEHCyACQRB2IgJB/wFxBH0gBSAGIAJBAWtB/wFxs5SSEIkEBUMAAAAACyEJIAAgBE8NAyADIAg4AgAgAEEBaiICIARPDQQgA0EEaiAHOAIAIAAgDkYNASADQQhqIAk4AgAgAUEQaiEBIANBDGohAyALIQIgDSAAQQNqIgBHDQALDwsgAEECaiAEQYzWwAAQjAcACyACIAsgCkGc1sAAEOoHAAsgACAEQezVwAAQjAcACyACIARB/NXAABCMBwALrgMAAn8CQAJAAkACQAJAIAJBA2sOBQMEAQIABAsgAS0AAEH2AEcNAyABLQABQeUARw0DIAEtAAJB8gBHDQMgAS0AA0HzAEcNAyABLQAEQekARw0DIAEtAAVB7wBHDQMgAS0ABkHuAEcNA0EADAQLAkACQAJAIAEtAABB4wBrDg8ABQUFBQUFBQUFAQUFBQIFCyABLQABQe8ARw0EIAEtAAJB9QBHDQQgAS0AA0HuAEcNBCABLQAEQfQARw0EQQEMBQsgAS0AAUHlAEcNAyABLQACQeEARw0DIAEtAANB7gBHDQMgAS0ABEHzAEcNA0ECDAQLIAEtAAFB9QBHDQIgAS0AAkHhAEcNAiABLQADQfQARw0CIAEtAARB8wBHDQJBBAwDCyABLQAAQfMARw0BIAEtAAFB4wBHDQEgAS0AAkHhAEcNASABLQADQewARw0BIAEtAARB5QBHDQEgAS0ABUHzAEcNAUEDDAILIAEtAABB8wBHDQAgAS0AAUHoAEcNAEEFQQZBByABLQACIgFBzgBGGyABQTBGGwwBC0EHCyEBIABBADoAACAAIAE6AAELrgMCCX8CfiADQRB2IQcgA0EIdiEKIAAoAhghBSAAKAIUIQggACgCECEJIAApAwghDSAAKAIEIQsgACgCACEMIAMhBgNAIAVBAEgEQEEAIQQgCSALSQRAIAwgCUECdGooAAAhBAsgBEEYdCAEQYD+A3FBCHRyIARBCHZBgP4DcSAEQRh2cnKtIA1CIIaEIQ0gCUEBaiEJIAVBIGohBQsgBSAIQQFrIAdB/wFxbEEIdkEBaiIEIAggBGsgDSAErSAFQT9xrYYiDlQiBBsiCGciBUEYayIHQQAgBSAHTxsiB2shBSAIIAd0IQggDUIAIA4gBBt9IQ0gBiAKIAQbIgZB/wFxIgQgAkkEQCABIARBAnRqIgYtAAIhByAGLQABIQogBi0AACEGDAELCyAJIAtNBEAgACAFNgIYIAAgCDYCFCAAIAk2AhAgACANNwMIIAZB/wBxDwsCfyADQRh2IQMCQANAIAIgA00NASACIAEgA0ECdGoiAy0AASADLQAAIAAgAy0AAhDRBBsiBkH/AXEiA0sNAAsgBkH/AHEMAQsgAyACQfjhxAAQjAcAC0H/AXELowMCCn8DfiMAQRBrIgUkAAJAAkACQAJAAkACQAJAIAEoAhAiBCgCMCIHDgIFAQALIAQpAxggBCkDICACIAMQlQQhDiAEKAI4IgggDqdxIQYgDkIZiEL/AINCgYKEiJCgwIABfiEQIAQoAjQiCkEEayELIAQoAiwhDANAIAYgCmopAAAiDyAQhSIOQn+FIA5CgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiDlBFBEADQCALIA56p0EDdiAGaiAIcUECdGsoAgAiBCAHTw0EIAwgBEG4AWxqIg1BrAFqKAIAIANGBEAgAiANQagBaigCACADENsHRQ0HCyAOQgF9IA6DIg5QRQ0ACwsgDyAPQgGGg0KAgYKEiJCgwIB/g1BFDQUgCUEIaiIJIAZqIAhxIQYMAAsACyADIAQoAiwiBEGsAWooAgBGDQEMAwsgBCAHQZCbyAAQjAcACyACIAQoAqgBIAMQ2wcNAUEAIQQLIAVBADoADCAFQQA2AgQgACABIAQgBUEEahCoAQwBCyAAQgM3AwAgAEGEgICAeDYCCAsgBUEQaiQAC+kCAQN/IwBBEGsiAyQAAn8CQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BQQMhAiAALQAAIgAhBCAAQQpPBEAgAyAAIABB5ABuIgRB5ABsa0H/AXFBAXQvALi6RTsADEEBIQILQQAgACAEG0UEQCACQQFrIgIgA0ELamogBEEBdC0AubpFOgAACyABQQFBAUEAIANBC2ogAmpBAyACaxDIAwwCCyAALQAAIQJBAyEAA0AgACADakEHaiACQQ9xQdy2xQBqLQAAOgAAIAJB/wFxIgRBBHYhAiAAQQFrIQAgBEEPSw0ACyABQQFBhLTFAEECIAAgA2pBCGpBAyAAaxDIAwwBCyAALQAAIQJBAyEAA0AgACADakEMaiACQQ9xQcmBwgBqLQAAOgAAIAJB/wFxIgRBBHYhAiAAQQFrIQAgBEEPSw0ACyABQQFBhLTFAEECIAAgA2pBDWpBAyAAaxDIAwsgA0EQaiQAC4sDAQZ/IwBBIGsiAiQAIAAoAgwhBQJAAkACfwJAAkACQCAAKAIUIgEgACgCECIDSQRAIABBDGohBANAIAEgBWotAABBCWsiBkEZSw0CQQEgBnRBk4CABHFFBEAgBkEZRw0DIABBADYCCCAAIAFBAWo2AhQgAkEUaiAEIAAQggIgAigCGCEBIAIoAhQiA0ECRg0HIAIoAhwhBCADQQFxRQ0FIARBBkcNBEEGIQQgAUG8gcEAQQYQ2wcNBEEAIQEMBwsgACABQQFqIgE2AhQgASADRw0ACyADIQELIAJBCGogBSADIAFBAWoiACADIAAgA0kbEPkBIAIoAgwhAyACKAIIIQBBFBBxIgFFDQUgASAANgIMIAFBBTYCACABIAM2AhAMBAsgACACQRRqQajAwQAQ7gEMAgsgASAEQcSBwQBBARDMBgwBCwJAIARBBkcNAEEGIQQgAUG8gcEAQQYQ2wcNAEEAIQEMAgsgASAEQcSBwQBBARDMBgsgABDrBSEBCyACQSBqJAAgAQ8LAAuHAwEGfyMAQSBrIgIkACAAKAIMIQUCQAJAAn8CQAJAAkAgACgCFCIBIAAoAhAiA0kEQCAAQQxqIQQDQCABIAVqLQAAQQlrIgZBGUsNAkEBIAZ0QZOAgARxRQRAIAZBGUcNAyAAQQA2AgggACABQQFqNgIUIAJBFGogBCAAEIICIAIoAhghASACKAIUIgNBAkYNByACKAIcIQQgA0EBcUUNBSAEQQJHDQRBAiEEIAEvAABB5/QBRw0EQQAhAQwHCyAAIAFBAWoiATYCFCABIANHDQALIAMhAQsgAkEIaiAFIAMgAUEBaiIAIAMgACADSRsQ+QEgAigCDCEDIAIoAgghAEEUEHEiAUUNBSABIAA2AgwgAUEFNgIAIAEgAzYCEAwECyAAIAJBFGpBuMDBABDuAQwCCyABIARBoIbBAEEBEMwGDAELAkAgBEECRw0AQQIhBCABLwAAQef0AUcNAEEAIQEMAgsgASAEQaCGwQBBARDMBgsgABDrBSEBCyACQSBqJAAgAQ8LAAunAwEJfQJ9IAAqAgwiA0MAAAAAXUUEQCAAKgIEIQQgACoCACEFIAAqAggMAQsgA4whAyAAKgIEjCEEIAAqAgCMIQUgACoCCIwLIQhDAACAPyEBQwAAgD8gAyADQwAAgD9eGxD2BCICIAKSIglDAAAAP5QQmQIiAotDvTeGNV1FBEAgCCAClSEGIAQgApUhByAFIAKVIQELIAcgB4sgAYuSIAaLkiIDlSECIAEgA5UhAwJAIAZDAAAAAF1FBEAgAiEBDAELQwAAgD8gA4uTIgEgAYwgAkMAAAAAYBshAUMAAIA/IAKLkyICIAKMIANDAAAAAGAbIQMLQwDwf0VDAAAAACAJQ9sPSUCVQwDwf0WUIgIgAkMAAAAAXRsiAiACQwDwf0VeGxC5ByECQwDAf0RDAAAAACABQwAAAD+UQwAAAD+SQwDAf0SUIgEgAUMAAAAAXRsiASABQwDAf0ReGxC5B/wBQQp0IAL8AUEUdHJDAMB/REMAAAAAIANDAAAAP5RDAAAAP5JDAMB/RJQiASABQwAAAABdGyIBIAFDAMB/RF4bELkH/AFyC+kCAgd/AX4CQAJAAkAgACgCCCIFIAAoAgBJIgNFBEAgAEEQaiECQQIhBANAIAUgAigCACIFSw0CIAJBCGohAiABIARBAWoiBEcNAAsMAgsgAEEQaiECQQIhBANAIAUgAigCACIFTQ0BIAJBCGohAiABIARBAWoiBEcNAAsMAQsgASAERw0BCwJAIANFDQAgAUEBdkH+////B3EhByAAIAFBA3QiBWohBkEAIQRBACECA0AgACAFakEIayIDKQIAIQkgAyAAIARqIgMpAgA3AgAgAyAJNwIAIANBCGoiAykCACEJIAMgBiACIgNB/v///wFzQQN0aiIIKQIANwIAIAggCTcCACAFQRBrIQUgBEEQaiEEIAcgAkECaiICRw0ACyABQQJxRQ0AIAAgAkEDdGoiACkCACEJIAAgBkF9IANrQQN0aiIAKQIANwIAIAAgCTcCAAsPCyAAIAFBACABQQFyZ0EBdEE+cxBYC8ECAQd/IAAoAmghAwJAAkAgACgCbCICBEAgA0EkaiEBA0AgAUEEaygCACIEQYCAgIB4ckGAgICAeEcEQCABKAIAIgZBBGsoAgAiBUF4cSIHQQRBCCAFQQNxIgUbIARqSQ0DIAVBACAHIARBJ2pLGw0EIAYQogILIAFBMGohASACQQFrIgINAAsLIAAoAmQiAQRAIANBBGsoAgAiAkF4cSIEIAFBMGwiAUEEQQggAkEDcSICG3JJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgACgCcCIBQYCAgIB4ckGAgICAeEcEQCAAKAJ0IgBBBGsoAgAiA0F4cSICQQRBCCADQQNxIgMbIAFqSQ0BIANBACACIAFBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL0gIBCH8gAUECdCIDIQIgACAAKAJ8IgQgA0kEfyADIAQiAmsiBSAAKAJ0IAJrSwRAIABB9ABqIAIgBUEEQQQQpAUgACgCfCECCyAAKAJ4IgcgAkECdCIIaiEGIAVBAk8EQCADIARBf3NqQQJ0IgkEQCAGQQAgCfwLAAsgAUEEdCAIaiAEQQJ0ayAHakEEayEGIAIgBWpBAWshAgsgBkEANgIAIAJBAWoFIAILNgJ8IAAgACgCiAEiBCADSQR/IAMgBCICayIFIAAoAoABIAJrSwRAIABBgAFqIAIgBUEEQQQQpAUgACgCiAEhAgsgACgChAEiByACQQJ0IghqIQYgBUECTwRAIAMgBEF/c2pBAnQiAwRAIAZBACAD/AsACyABQQR0IAhqIARBAnRrIAdqQQRrIQYgAiAFakEBayECCyAGQQA2AgAgAkEBagUgAws2AogBC+cCAgN/An4CQCAAKAIYIgNBAE4EQCAAKQMIIQUMAQsCQCAAKAIQIgIgACgCBE8EQCAALAAjIgJBAEwEQCACDQIgAEH/AToAIyAAIAApAwhCCIYiBTcDCCADQQhqIQMMAwsgACACQQFrOgAjIAAtACAhAiAAIAAvACE7ASAgACACOgAiIAAgAq1C/wGDIAApAwhCCIaEIgU3AwggA0EIaiEDDAILIAAgAkEBajYCECAAIAAoAgAgAkECdGooAAAiAkEYdCACQYD+A3FBCHRyIAJBCHZBgP4DcSACQRh2cnKtIAApAwhCIIaEIgU3AwggA0EgaiEDDAELIABB8gE6ACNBAA8LIAUgACgCFCICQQFrIAFB/wFxbEEIdkEBaiIBrSADQT9xrYYiBloiBARAIAAgBSAGfTcDCCACIAFrIQELIAAgAyABZyIDQRhrIgJBACACIANNGyIDazYCGCAAIAEgA3Q2AhQgBAvgAgIFfwF+AkACQCAFLQC/AiIGQQhLQQEgBnRBlgJxRXJFBEBBCCAGbkEDbK0gAq1+IgtCIIhQIAunIARJcQ0BIAQgBEEDcGshBAJAIAZBCEYEQCACRQ0BA0AgBEEDSQ0CIAMgACABLQAAQQJ0aiIFLQAAOgAAIANBAWogBS8AATsAACADQQNqIQMgBEEDayEEIAFBAWohASACQQFrIgINAAsMAQsgBEEDSQ0AIAEgAmohCEF/IAZ0QX9zIQlBCCAGayEFQX8hAgNAIAJBAEgEQCABIAhGDQUgAS0AACEHIAUhAiABQQFqIQELIAMgACAHIAJ2IAlxQQJ0aiIKLQAAOgAAIANBAWogCi8AATsAACADQQNqIQMgAiAGayECIARBA2siBEEDTw0ACwsPC0Gwl8UAQTRB5JfFABDrBwALQYSWxQBB5QBB7JbFABDrBwALQfyWxQBBIkGgl8UAEKsHAAv4AgEFfyMAQRBrIgYkAAJAAkAgA0H/////A0sNACADQQJ0IgRB/f///wdPDQACQCAERQRAQQQhCAwBCyADIQcgBBBxIghFDQILIAZBADYCDCAGIAg2AgggBiAHNgIEAkACQAJAAkAgAwRAQQAhBEEAIQcDQCACIARNDQIgBEEBaiIFIAJPDQMgBEECaiIFIAJPDQQgBEEDaiIFIAJPDQUgASAEaiIFQQFqLQAAQQh0IAUtAAByIAVBAmotAABBEHRyIAVBA2otAABBGHRyIQUgBigCBCAHRgRAIAZBBGpBjOjHABD6BSAGKAIIIQgLIAQgCGogBTYCACAGIAdBAWoiBzYCDCAEQQRqIQQgAyAHRw0ACwsgACAGKQIENwIAIABBCGogBkEMaigCADYCACAGQRBqJAAPCyAEIAJBzOfHABCMBwALIAUgAkHc58cAEIwHAAsgBSACQeznxwAQjAcACyAFIAJB/OfHABCMBwALQbznxwAQ/wcLAAv4AgEFfyMAQRBrIgYkAAJAAkAgA0H/////A0sNACADQQJ0IgRB/f///wdPDQACQCAERQRAQQQhCAwBCyADIQcgBBBxIghFDQILIAZBADYCDCAGIAg2AgggBiAHNgIEAkACQAJAAkAgAwRAQQAhBEEAIQcDQCACIARNDQIgBEEBaiIFIAJPDQMgBEECaiIFIAJPDQQgBEEDaiIFIAJPDQUgASAEaiIFQQFqLQAAQQh0IAUtAAByIAVBAmotAABBEHRyIAVBA2otAABBGHRyIQUgBigCBCAHRgRAIAZBBGpBnOzHABCLBiAGKAIIIQgLIAQgCGogBTYCACAGIAdBAWoiBzYCDCAEQQRqIQQgAyAHRw0ACwsgACAGKQIENwIAIABBCGogBkEMaigCADYCACAGQRBqJAAPCyAEIAJB3OvHABCMBwALIAUgAkHs68cAEIwHAAsgBSACQfzrxwAQjAcACyAFIAJBjOzHABCMBwALQczrxwAQ/wcLAAvkAgEIfwJAIAMgBC0AvgJBAnQoAtCPSSIFQQJqIgduIgMgASAFbiIBIAEgA0sbIgFFDQACQCAEKALMAUGBgICAeEYNACAEKALUASAFRw0AIAQoAtABIQMDQCAFBEAgAiAAIAX8CgAACyACIAVqIgRBAWpBf0EAIAAgAyAFENsHGyIGOgAAIAQgBjoAACAAIAVqIQAgAiAHaiECIAFBAWsiAQ0ACwwBC0EAIQMgAUEBRwRAIAFBAXEgAUF+cSEJIAVBAXQiBkEEaiEKIAIhASAAIQQDQCAFRSILRQRAIAEgBCAF/AoAAAsgASAFaiIMQf//AzsAACALRQRAIAxBAmogBCAFaiAF/AoAAAsgASAGakECakH//wM7AAAgASAKaiEBIAQgBmohBCAJIANBAmoiA0cNAAtFDQELIAIgAyAHbGohASAFBEAgASAAIAMgBWxqIAX8CgAACyABIAVqQf//AzsAAAsLggMBBH8gACgCDCECAkACQAJAIAFBgAJPBEAgACgCGCEDAkACQCAAIAJGBEAgAEEUQRAgACgCFCICG2ooAgAiAQ0BQQAhAgwCCyAAKAIIIgEgAjYCDCACIAE2AggMAQsgAEEUaiAAQRBqIAIbIQQDQCAEIQUgASICQRRqIAJBEGogAigCFCIBGyEEIAJBFEEQIAEbaigCACIBDQALIAVBADYCAAsgA0UNAgJAIAAoAhxBAnRBsLfJAGoiASgCACAARwRAIAMoAhAgAEYNASADIAI2AhQgAg0DDAQLIAEgAjYCACACRQ0EDAILIAMgAjYCECACDQEMAgsgACgCCCIAIAJHBEAgACACNgIMIAIgADYCCA8LQci6yQBByLrJACgCAEF+IAFBA3Z3cTYCAA8LIAIgAzYCGCAAKAIQIgEEQCACIAE2AhAgASACNgIYCyAAKAIUIgBFDQAgAiAANgIUIAAgAjYCGA8LDwtBzLrJAEHMuskAKAIAQX4gACgCHHdxNgIAC7ACAQR/IAAoAgwhASAAKAIQIgIoAgAiAwRAIAEgAxEDAAsCQAJAIAIoAgQiAgRAIAFBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAJqSQ0BIANBACAEIAJBJ2pLGw0CIAEQogILIAAoAhQhASAAKAIYIgIoAgAiAwRAIAEgAxEDAAsgAigCBCICBEAgAUEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgAmpJDQEgA0EAIAQgAkEnaksbDQIgARCiAgsCQCAAQX9GDQAgACAAKAIEQQFrIgE2AgQgAQ0AIABBBGsoAgAiAUF4cSICQSBBJCABQQNxIgEbSQ0BIAFBACACQcQATxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6QDAQJ/AkACfwJAIAAoAgBBgICAgHhHBEAgAyABIAIgBCAAKAIEIAAoAggQtAEiBQ0DIAMgASACIAQgACgCECAAKAIUELQBIgUNAyADIAEgAiAEIAAoAjwgACgCQBC0ASIFDQMgAyABIAIgBCAAKAJgIAAoAmQQtAEiBQ0DIAMgASACIAQgACgCeCAAKAJ8ELQBIgUNAyAAKAKgAUGAgICAeEcNAUEADwsgAyABIAIgBCAAKAIUIAAoAhgQtAEiBQ0CIAMgASACIAQgACgCICAAKAIkELQBIgUNAiADIAEgAiAEIAAoAkQgACgCSBC0ASIFDQIgAyABIAIgBCAAKAJcIAAoAmAQtAEiBQ0CIAMgASACIAQgACgCdCAAKAJ4ELQBIgUNAiAAKAKIAUGAgICAeEYEQEEADwsgAyABIAIgBCAAKAKMASAAKAKQARC0ASIFDQJBmAEhBkGcAQwBCyADIAEgAiAEIAAoAqQBIAAoAqgBELQBIgUNAUGwASEGQbQBCyEFIAMgASACIAQgACAGaigCACAAIAVqKAIAELQBIQULIAULzQICB38CfiMAQRBrIgQkACABKAIAIQYCQAJAIAEoAggiAiABKAIEIgdJBEAgAiAGai0AAEHfAEYNAQsgAiAHIAIgB0sbIQgCQANAAkAgAiAHSQRAIAIgBmotAABB3wBGDQMLAkACQCACIAhGDQIgAiAGai0AACIFQTBrIgNB/wFxQQpJDQEgBUHhAGtB/wFxQRpJDQAgBUHBAGtB/wFxQRpPDQIgBUEdayEDDAELIAVB1wBrIQMLIAEgAkEBaiICNgIIIAQgCUI+EN0GIAQpAwhQRQRADAELIAQpAwAiCiADrUL/AYN8IgkgCloNAQsLIABBADoAAUEBIQMMAgtBASEDIAEgAkEBajYCCCAJQn9SBEAgACAJQgF8NwMIQQAhAwwCCyAAQQA6AAEMAQsgAEIANwMIIAEgAkEBajYCCAsgACADOgAAIARBEGokAAuWAwEFfyMAQSBrIgIkAAJAQaC7yQAoAgBFBEBBoLvJAEF/NgIAAn8CQAJAAkBBrLvJACgCACIBQai7yQAoAgAiAEYEQCABQaS7yQAoAgAiAEcNAdBvQYABIAEgAUGAAU0bIgP8DwEiAEF/Rw0CDAYLIAAgAU0NBUGgtMkAKAIAIAFBAnRqKAIAIQBBAAwDCyAAIAFNDQRBoLTJACgCACEADAELAkBBsLvJACgCACIERQRAQbC7yQAgADYCAAwBCyABIARqIABHDQQLIAEgA2oiA0H/////AUsNA0EAIQAgAiABBH8gAiABQQJ0NgIcIAJBoLTJACgCADYCFEEEBSAACzYCGCACQQhqIANBAnQgAkEUahCBByACKAIIQQFGDQNBoLTJACACKAIMIgA2AgBBpLvJACADNgIACyAAIAFBAnRqIAFBAWoiADYCAEGou8kAIAA2AgBBoLvJACgCAEEBagshA0Gsu8kAIAA2AgBBoLvJACADNgIAQbC7yQAoAgAgAkEgaiQAIAFqDwtB8I7IABCwCgALAAvXAgEJfwJAIAMgBC0AvgJBAnQoArSPSSIFQQFqIgZuIgMgASAFbiIBIAEgA0sbIgFFDQACQCAEKALMAUGBgICAeEYNACAEKALUASAFRw0AIAQoAtABIQMDQCAFBEAgAiAAIAX8CgAACyACIAVqQX9BACAAIAMgBRDbBxs6AAAgACAFaiEAIAIgBmohAiABQQFrIgENAAsMAQtBACEDIAFBAUcEQCABQQFxIAFBfnEhCSAFQQF0IgdBAmohCiAHQQFyIQsgAiEBIAAhBANAIAVFIgxFBEAgASAEIAX8CgAACyABIAVqIg1B/wE6AAAgDEUEQCANQQFqIAQgBWogBfwKAAALIAEgC2pB/wE6AAAgASAKaiEBIAQgB2ohBCAJIANBAmoiA0cNAAtFDQELIAIgAyAGbGohASAFBEAgASAAIAMgBWxqIAX8CgAACyABIAVqQf8BOgAACwv/AgIDfQN/IwBBEGshBSAAvCEGAkAgAIsiAbwiBEH////jBE0EQAJ/AkACQCAEQYCAgPcDTwRAIARBgIDg/ANJDQIgBEGAgPCABEkNAUMAAIC/IAGVIQBBAwwDC0F/IARBgICAzANPDQIaIARBgICABE8NBCAFIAAgAJQ4AgwgBSoCDBogAA8LIAFDAADAv5IgAUMAAMA/lEMAAIA/kpUhAEECDAELIARBgIDA+QNPBEAgAUMAAIC/kiABQwAAgD+SlSEAQQEMAQsgASABkkMAAIC/kiABQwAAAECSlSEAQQALIQUgACAAlCICIAKUIgEgAUNHEtq9lEOYyky+kpQhAyACIAEgAUMlrHw9lEMN9RE+kpRDqaqqPpKUIQEgBEGAgID3A08EQCAFQQJ0IgQqAuywSSAAIAMgAZKUIAQqAvywSZMgAJOTIgAgAIwgBkEAThsPCyAAIAAgAyABkpSTIQAMAQsgACAAXA0AQ9oPyT9D2g/JvyAGQQBOGw8LIAAL8AIBAn8jAEEwayICJAACfwJAAkACQAJAAkBBASAAKAIAIgNB/////wdqIANBgICAgHhNG0EBaw4EAQIDBAALIAIgAEEEajYCDCACIAJBDGqtQoCAgIDQBoQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkG4lsgANgIYIAIgAkEQajYCICACQRhqEMEDDAQLIAIgADYCDCACIAJBDGqtQoCAgICwD4Q3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkHYlsgANgIYIAIgAkEQajYCICACQRhqEMEDDAMLIAIgAEEEajYCDCACIAJBDGqtQoCAgIDAD4Q3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkH8lsgANgIYIAIgAkEQajYCICACQRhqEMEDDAILIAEoAgBBhJfIAEEjIAEoAgQoAgwRAAAMAQsgASgCAEGnl8gAQR4gASgCBCgCDBEAAAsgAkEwaiQAC/cCAgV/AX4jAEEwayIBJAAgACkCECEGIAAoAgwhAyAAKAIIIQQgACgCACECAkACQAJAAkACfwJAAkACQAJAAkAgACgCBCIADgIAAQILIAMNAUEBIQNBACEAQQEhAgwDCyADRQ0BCyABIAY3AiggASADNgIkIAEgBDYCICABIAA2AhwgASACNgIYIAFBDGogAUEYahDsAyABKAIMIQAgASgCECECIAEoAhQMAgsgAigCBCIAQQBIDQIgAigCACEDIABFBEBBASECQQAhAAwBCyAAEHEiAkUNAwsgAARAIAIgAyAA/AoAAAsgASAANgIUIAEgAjYCECABIAA2AgwgAAshAyACIAMQ6wggAARAIAJBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIABqSQ0DIARBACAFIABBJ2pLGw0EIAIQogILIAFBMGokAA8LQdiayAAQ/wcLAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALhQMCA30Cf0MAABBBIAEqAgwgAS0AHEECRiIGGyEFQwAAQMEgASoCCCAGGyEEQQAhAUEAIQYgAv0fACIDQwAAAABfRQRAQf8BQwAAgD9DAAAAACADEMYFIASTIAUgBJOVIgMgA0MAAAAAXRsiAyADQwAAgD9eG0MAAH5DlBC5ByID/AFBACADQwAAAABgGyADQwAAf0NeG0EBaiEGCyAC/R8BIgNDAAAAAF9FBEBB/wFDAACAP0MAAAAAIAMQxgUgBJMgBSAEk5UiAyADQwAAAABdGyIDIANDAACAP14bQwAAfkOUELkHIgP8AUEAIANDAAAAAGAbIANDAAB/Q14bQQFqIQELIABBE2ogAv0fAiIDQwAAAABfBH8gBwVB/wFDAACAP0MAAAAAIAMQxgUgBJMgBSAEk5UiBCAEQwAAAABdGyIEIARDAACAP14bQwAAfkOUELkHIgT8AUEAIARDAAAAAGAbIARDAAB/Q14bQQFqCzoAACAAIAZB/wFxIAFBCHRyOwARC9gCAQF/AkACQAJAAkAgASACIAMgBCAFIAYQwANFDQAgBSAGQQF0ayIBIARPDQECQCAEIAUgBmsiAksEQCABIANqIgEtAAAgAiADai0AAGsiAiACQR91IgJzIAJrIABB/wFxTQ0BQQEgAyAEIAUgBhDoBBoPCyACIARB+NfEABCMBwALIAUgBmoiAiAETw0CIAQgBU0NAyAAQf8BcSIHIAIgA2oiAC0AACADIAVqLQAAayICIAJBH3UiAnMgAmsiAkkgAyAEIAUgBhDoBCEDIAIgB0sNACAAQf8BIAAtAAAgA0EBakEBdSIAayICQQAgAkEAShsiAiACQf8BThs6AAAgAUH/AEGAfyAAIAEtAABqQYABayIAIABBgH9MGyIAIABB/wBOG0GAAXM6AAALDwsgASAEQejXxAAQjAcACyACIARBiNjEABCMBwALIAUgBEGY2MQAEIwHAAvZAgECfyMAQTBrIgIkAAJ/AkACQAJAAkBBASAALQAAIgNBJGsgA0EjTRtB/wFxQQFrDgMBAgMACyACIABBBGo2AgwgAiACQQxqrUKAgICA0AaENwMQIAEoAgAgASgCBCACQgE3AiQgAkEBNgIcIAJBoPjHADYCGCACIAJBEGo2AiAgAkEYahDBAwwDCyACIAA2AgwgAiACQQxqrUKAgICA4AaENwMQIAEoAgAgASgCBCACQgE3AiQgAkEBNgIcIAJBoPjHADYCGCACIAJBEGo2AiAgAkEYahDBAwwCCyACIABBBGo2AgggAiACQQxqrUKAgICA8AaENwMQIAIgAkEIajYCDCABKAIAIAEoAgQgAkIBNwIkIAJBATYCHCACQaD4xwA2AhggAiACQRBqNgIgIAJBGGoQwQMMAQsgASgCAEHcrcUAQRMgASgCBCgCDBEAAAsgAkEwaiQAC4UDAQV/IwBBIGsiAyQAIAAoAgwhBAJAAkACQAJAAkACQCAAKAIUIgEgACgCECICSQRAA0ACQCABIARqLQAAIgVBCWsOJAAABAQABAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBgMLIAAgAUEBaiIBNgIUIAEgAkcNAAsgAiEBCyADQRBqIAQgAiABQQFqIgAgAiAAIAJJGxD5ASADKAIUIQIgAygCECEAQRQQcSIBRQ0FIAEgADYCDCABQQM2AgAgASACNgIQDAQLIAVB/QBGDQELIANBCGogBCACIAFBAWoiACACIAAgAkkbEPkBIAMoAgwhAiADKAIIIQBBFBBxIgFFDQMgASAANgIMIAFBFjYCACABIAI2AhAMAgsgACABQQFqNgIUQQAhAQwBCyADQRhqIAQgAiABQQFqIgAgAiAAIAJJGxD5ASADKAIcIQIgAygCGCEAQRQQcSIBRQ0BIAEgADYCDCABQRU2AgAgASACNgIQCyADQSBqJAAgAQ8LAAu8AgEEfwJAAkACQAJAAkACQEEBIAAoAgAiAUH/////B2ogAUGAgICAeE0bDgIAAQMLIAAtAARBA0cNAiAAKAIIIgAoAgAhASAAQQRqKAIAIgIoAgAiAwRAIAEgAxEDAAsgAigCBCICBEAgAUEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgAmpJDQUgA0EAIAQgAkEnaksbDQQgARCiAgsgAEEEaygCACIBQXhxIgJBEEEUIAFBA3EiARtJDQQgAUUgAkE0SXINAQwDCyABQYCAgIB4ckGAgICAeEYNASAAKAIEIgBBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0DIAJFIAMgAUEnak1yDQAMAgsgABCiAgsPC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAvmAgIEfgN/AkACQAJAIAFB2ABqIAIQqAQiAgRAIAIpAxAiBSACKQMIIgR9IgcgA61WBEAgAEEaOgAADwsgB6ciAkEASA0BQQEhAwJAIAQgBVEiCQ0AIAIQcSIDRQ0DIANBBGstAABBA3FFIAJFcg0AIANBACAC/AsACyABKAJMIgitIQYgAiAIQv////8PIAQgBEL/////D1obp2siCkEAIAggCk8bTQRAIAEoAkggBCAGIAQgBlQbp2ohCAJAIAdCAVIEQCACRQ0BIAMgCCAC/AoAAAwBCyADIAgtAAA6AAALIAEgBTcDUAwECyABIAUgBkGokMgAKQMAIgRC/wGDQgRRIgEbNwNQIAENAyAAIAQ3AgQgAEEAOgAAIAlFBEAgAyACQQEQogcLDwsgAEEdOgAAIABBgICAgHg2AgQPC0HU9sYAEP8HCwALIAAgAjYCDCAAIAM2AgggACACNgIEIABBHToAAAvFAgEFf0ERQQAgAEGvsARPGyICIAJBCHIiASAAQQt0IgIgAUECdCgCzPlCQQt0SRsiASABQQRyIgEgAUECdCgCzPlCQQt0IAJLGyIBIAFBAnIiASABQQJ0KALM+UJBC3QgAksbIgEgAUEBaiIBIAFBAnQoAsz5QkELdCACSxsiASABQQFqIgEgAUECdCgCzPlCQQt0IAJLGyIBQQJ0KALM+UJBC3QiBCACRiACIARLaiABaiIEQQJ0IgJBzPnCAGohBSACKALM+UJBFXYhAkHvBSEBAkAgBEEgTQRAIAUoAgRBFXYhASAERQ0BCyAFQQRrKAIAQf///wBxIQMLAkAgASACQX9zakUNACAAIANrIQMgAUEBayEBQQAhAANAIAAgAkH7+MEAai0AAGoiACADSw0BIAEgAkEBaiICRw0ACwsgAkEBcQvFAgEFf0ESQQAgAEGwuARPGyICIAJBCXIiASAAQQt0IgIgAUECdCgCuPhCQQt0SRsiASABQQVqIgEgAUECdCgCuPhCQQt0IAJLGyIBIAFBAmoiASABQQJ0KAK4+EJBC3QgAksbIgEgAUEBaiIBIAFBAnQoArj4QkELdCACSxsiASABQQFqIgEgAUECdCgCuPhCQQt0IAJLGyIBQQJ0KAK4+EJBC3QiBCACRiACIARLaiABaiIEQQJ0IgJBuPjCAGohBSACKAK4+EJBFXYhAkH/BiEBAkAgBEEjTQRAIAUoAgRBFXYhASAERQ0BCyAFQQRrKAIAQf///wBxIQMLAkAgASACQX9zakUNACAAIANrIQMgAUEBayEBQQAhAANAIAAgAkH88cEAai0AAGoiACADSw0BIAEgAkEBaiICRw0ACwsgAkEBcQvuAgIDfwJ+IwBBIGsiBCQAAkAgASgCxANBAkYEQAJAIAACfgJAIAEtAOQDRQRAA0AgASgCnAMiAiABKQOgAyIFIAKtIgYgBSAGVBunIgNGBEBBASEDQSQhAkIlDAQLIARBDGogASABKAKYAyADaiACIANrQQAQ1gEgBCkCFCEFIAQoAhAhAgJAIAQoAgxFBEAgASABKQOgAyACrXw3A6ADIAWnIQMMAQsgBachAyACQf8BcUEoRw0DCyADQf8BcUEGRw0ACyABKAK8BCICRQ0FIAFBAToA5AMgASACQQFrNgK8BAsgAEEoOgAADAILIAQoAhwhASAFQgiICyIFPgAFIAAgATYCDCAAIAM6AAQgACACOgAAIABBC2ogBUIwiDwAACAAQQlqIAVCIIg9AAAgACACQRB2OwECIAAgAkEIdjoAAQsgBEEgaiQADwtB3JjHAEHAAEGcmccAEOsHAAtBrJnHAEErQdiZxwAQ6wcAC8sCAQR/AkACQAJAIAIgAyAEQQF0ayIGSwRAIAMgBGsiBSACTw0BIAIgA00NAiADIARqIgQgAk8NAyABIAVqIgctAAAhAiABIANqIggtAAAhBUEAIQMgCEH/AEGAfyAFQfsAQYB/IAAEf0H/AEGAfyABIAZqLQAAIAEgBGotAABrIgAgAEGAf0wbIgAgAEH/AE4bBSADCyAFIAJrQQNsaiIAIABBgH9MGyIAIABB+wBOG0EEakEDdSIBa0GAAWsiAyADQYB/TBsiAyADQf8AThtBgAFzOgAAIAdB/wBBgH8gAkH8ACAAIABB/ABOG0EDakEDdWpBgAFrIgAgAEGAf0wbIgAgAEH/AE4bQYABczoAACABDwsgBiACQYjWxAAQjAcACyAFIAJBmNbEABCMBwALIAMgAkGo1sQAEIwHAAsgBCACQbjWxAAQjAcAC8kCAQd/IwBBIGsiAyQAAkACQAJAAkAgASAAKAK4AUYEQCAAKAK8ASACRg0BCyAAEKMFIAAgAhDQBCAAKAKwASABQQJ0IgUgASACakECdCIGEOEIIQggAkECdCIEIAAoAnwiB0sNASAAKAJ4IAMgCBC4CiIJNgIAIAMgBDYCBCAEIAlHDQMgBCAIEOEJIAAoArQBIAUgBhDhCCEFIAQgACgCiAEiBksNAiAAKAKEASADIAUQuAoiBzYCACADIAQ2AgQgBCAHRw0DIAQgBRDhCSAAQQA6AMABIAAgAjYCvAEgACABNgK4ASAFQYQITwRAIAUQmwcLIAhBhAhJDQAgCBCbBwsgA0EgaiQADwtBACAEIAdBoOjAABDqBwALQQAgBCAGQZDowAAQ6gcACyADQQA2AghBACADIANBBGogA0EIakHg+cQAEPUHAAvUAgICfQJ/IAQEQCAAIAEgAiADIAQQlgILIAYEQCAAIAEgAiAFIAYQxwELAkACQAJAIAhFIAJFcg0AIAAoAlxBA0kNAEMAAP5CQwAA/kIgACoCVJUgAC0AWEECRhshCiAAKAI0IAFBFWxqIQUgACgCOCEMQQAhBANAIAEgC2oiACAMTw0CIAtBAWohC0EAIQAgByEGA0AgACAEaiIDIAhPDQQgACAFakH/AEMAAP5CQwAA/sIgCiAGKgIAlCIJIAlDAAD+wl0bIgkgCUMAAP5CXhsQuQciCfwAQYB/IAlDAAAAw2AbIAlDAAD+Ql4bQQAgCSAJWxs6AAAgBkEEaiEGIABBAWoiAEEVRw0ACyAHQdQAaiEHIARBFWohBCAFQRVqIQUgAiALRw0ACwsPCyALQRVsIgMgCE8NACAAIAxBxMTHABCMBwALIAMgCEG0xMcAEIwHAAvcAgIEfwF+IwBBQGoiAiQAIAAoAgAhACACQQA2AhggAkKAgICAEDcCECACQfidxgA2AiwgAkKggICADjcCMCACIAJBEGoiAzYCKAJAAkAgACACQShqIgQQ5ANFBEAgAkEIaiACQRhqKAIANgIAIAIgAikCEDcDACACQoCAgIAQIgYgAEEQaq2ENwMgIAIgBiAAQQxqrYQ3AxggAiACrUKAgICAkA6ENwMQIAEoAgAgASgCBCACQgM3AjQgAkEENgIsIAJBrKDGADYCKCACIAM2AjAgBBDBAyACKAIAIgAEQCACKAIEIgRBBGsoAgAiA0F4cSIFQQRBCCADQQNxIgMbIABqSQ0CIANBACAFIABBJ2pLGw0DIAQQogILIAJBQGskAA8LQaCexgBBNyACQZCexgBB2J7GABDgBgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC/ACAQF/AkAgAgRAIAEtAABBME0NASAFQQI7AQACQAJAAkACQCADwSIGQQBKBEAgBSABNgIEIAIgA0H//wNxIgNLDQIgBUEAOwEMIAUgAjYCCCAFIAMgAms2AhAgBA0BQQIhAQwECyAFIAI2AiAgBSABNgIcIAVBAjsBGCAFQQA7AQwgBUECNgIIIAVBuYPCADYCBCAFQQAgBmsiAzYCEEEDIQEgAiAETw0DIAQgAmsiAiADTQ0DIAIgBmohBAwCCyAFQQE2AiAgBUHsucUANgIcIAVBAjsBGAwBCyAFQQI7ARggBUEBNgIUIAVB7LnFADYCECAFQQI7AQwgBSADNgIIIAUgAiADayICNgIgIAUgASADajYCHCACIARPBEBBAyEBDAILIAQgAmshBAsgBSAENgIoIAVBADsBJEEEIQELIAAgATYCBCAAIAU2AgAPC0G+g8IAQSFB4IPCABDrBwALQfCDwgBBH0GQhMIAEOsHAAuaAgEEfwJAAkACQAJAIAAoAgAiAUGAgICAeEcEQCABRQ0CIAAoAgQiAEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpJDQQgAkUgAyABQSdqTXINAQwDCyAALQAEQQNHDQEgACgCCCIAKAIAIQEgAEEEaigCACICKAIAIgMEQCABIAMRAwALIAIoAgQiAgRAIAFBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAJqSQ0EIANBACAEIAJBJ2pLGw0DIAEQogILIABBBGsoAgAiAUF4cSICQRBBFCABQQNxIgEbSQ0DIAFFDQAgAkE0Tw0CCyAAEKICCw8LQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC9gCAQZ/IwBBEGsiBCQAAn8CQAJAAkAgACgCACIDRQ0AA0ACQCAAKAIIIgEgACgCBCIFTw0AIAEgA2otAABBxQBHDQAgACABQQFqNgIIDAILAkACQAJAAkAgAkUNACAAKAIQIgZFDQAgBkHnkMYAQQIQlwMNByAAKAIAIgNFDQEgACgCCCEBIAAoAgQhBQsgASAFTw0AAkAgASADai0AAEHLAGsOAgIAAQsgACABQQFqNgIIIAQgABDZBCAELQAADQUgACAEKQMIEIIGDQYMAgsgABCGAg0FDAELIAAgAUEBajYCCEEBIABBABDVAQ0FGgsgAkEBayECIAAoAgAiAw0ACwtBAAwCCyAELQABIQEgACgCECICBEBBASACQfqyxQBB6rLFACABQQFxIgIbQRlBECACGxCXAw0CGgsgACABOgAEIABBADYCAEEADAELQQELIARBEGokAAu6AgIHfgJ/IANBCE8EQCAAIAAgA0EDdiILQQd0IgxqIAAgC0HgAWwiA2ogCxDvBCEAIAEgASAMaiABIANqIAsQ7wQhASACIAIgDGogAiADaiALEO8EIQILIAEpAxghCCAAKQMYIQogACkDCCIGIQQgASkDCCIHIQUCfwJAIAYgB1INACAAKQMQIgQgASkDECIFUg0AIAghBUEAIAoiBCAIUQ0BGgsgBCAFVAshAyACKQMYIQkgAikDCCIEIQUCQAJAAkAgBCAGUg0AIAApAxAiBiACKQMQIgVSDQAgCSEFIAkgCiIGUg0AIANFDQEMAgsgAyAFIAZWcw0BCyACIAECfwJAIAQgB1INACABKQMQIgcgAikDECIEUg0AIAghB0EAIAkiBCAIUQ0BGgsgBCAHVgsgA3MbIQALIAALuAICAnwCfyMAQRBrIgckACADuiEFIAACfwJAAkACQAJAIAQgBEEfdSIIcyAIayIIQbUCTwRAA0AgBUQAAAAAAAAAAGENBSAEQQBODQIgBUSgyOuF88zhf6MhBSAEQbQCaiIEIARBH3UiCHMgCGsiCEG1Ak8NAAsLIAhBA3QrA6CCRyEGIARBAE4NASAFIAajIQUMAwsgB0EIaiABKAIMIAEoAhAgASgCFBD5ASAHKAIMIQIgBygCCCEEDAELIAUgBqIiBZlEAAAAAAAA8H9iDQEgByABKAIMIAEoAhAgASgCFBD5ASAHKAIEIQIgBygCACEEC0EUEHEiAQRAIAEgBDYCDCABQQ42AgAgACABNgIEIAEgAjYCEEEBDAILAAsgACAFIAWaIAIbOQMIQQALNgIAIAdBEGokAAuzAgIFfwF9IAAoAggiAyAAKAIARgRAIABByJXBABD5BQsgACADQQFqNgIIIAAoAgQiBCADQQN0aiIAIAI2AgQgACABOAIAAkAgA0UEQEEAIQAMAQsgASABWwRAA0AgBCADQQFrIgZBAXYiAEEDdGoiBSoCACIIIAhbIAEgCF9FcUF/IAEgCGAbIgdBAEwgAiAFQQRqKAIATSAHGwRAIAMhAAwDCyAEIANBA3RqIAUpAgA3AgAgACEDIAZBAUsNAAwCCwALA0ACQCAEIANBAWsiBkEBdiIAQQN0aiIFKgIAIgggCFsgASAIX0VxDQAgAiAFQQRqKAIASw0AIAMhAAwCCyAEIANBA3RqIAUpAgA3AgAgACEDIAZBAk8NAAsLIAQgAEEDdGoiACACNgIEIAAgATgCAAujAgIBfwF+IwBB8ABrIgckACAHIAI2AgwgByABNgIIIAcgBDYCFCAHIAM2AhAgB0ECNgIcIAdBxojDAEHEiMMAIABBAXEbNgIYAkAgBSgCAARAIAdBMGogBUEQaikCADcDACAHIAX9AAIA/QsDICAHQQQ2AlwgB0GsicMANgJYIAdCBDcCZCAHQoCAgICQASIIIAdBEGqthDcDUCAHIAggB0EIaq2ENwNIIAcgB0Egaq1CgICAgIAGhDcDQAwBCyAHQQM2AlwgB0H4iMMANgJYIAdCAzcCZCAHQoCAgICQASIIIAdBEGqthDcDSCAHIAggB0EIaq2ENwNACyAHIAdBGGqtQoCAgICgAYQ3AzggByAHQThqNgJgIAdB2ABqIAYQjQgAC64CAgR/A34jAEEgayIDJABBFCECAkAgACkDACIIIAhCP4ciBoUgBn0iB0LoB1QEQCAHIQYMAQsDQCADQQxqIAJqIgBBBGsgByAHQpDOAIAiBkKQzgB+faciBEH//wNxQeQAbiIFQQF0LwC4ukU7AAAgAEECayAEIAVB5ABsa0H//wNxQQF0LwC4ukU7AAAgAkEEayECIAdC/6ziBFYgBiEHDQALCyAGQglWBEAgAkECayICIANBDGpqIAanIgAgAEH//wNxQeQAbiIAQeQAbGtB//8DcUEBdC8AuLpFOwAAIACtIQYLIAhQRSAGUHFFBEAgAkEBayICIANBDGpqIAanQQF0LQC5ukU6AAALIAEgCEIAWUEBQQAgA0EMaiACakEUIAJrEMgDIANBIGokAAvBAgEBfyMAQTBrIgIkAAJ/AkACQAJAAkAgAC0AAEEBaw4DAQIDAAsgAiAAQQFqNgIMIAIgAkEMaq1CgICAgPAHhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBATYCHCACQaD4xwA2AhggAiACQRBqNgIgIAJBGGoQwQMMAwsgAiAAQQRqNgIMIAIgAkEMaq1CgICAgMAHhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBAjYCHCACQbCQxgA2AhggAiACQRBqNgIgIAJBGGoQwQMMAgsgAiAAQQRqNgIMIAIgAkEMaq1CgICAgIAIhDcDECABKAIAIAEoAgQgAkIBNwIkIAJBAjYCHCACQdjExAA2AhggAiACQRBqNgIgIAJBGGoQwQMMAQsgASgCAEHoxMQAQQkgASgCBCgCDBEAAAsgAkEwaiQAC60CAQd/IwBBEGsiBCQAQQohAgJAIAAoAgAiBSAFQR91IgBzIABrIgBB6AdJBEAgACEDDAELA0AgBEEGaiACaiIGQQRrIAAgAEGQzgBuIgNBkM4AbGsiB0H//wNxQeQAbiIIQQF0LwC4ukU7AAAgBkECayAHIAhB5ABsa0H//wNxQQF0LwC4ukU7AAAgAkEEayECIABB/6ziBEsgAyEADQALCwJAIANBCU0EQCADIQAMAQsgAkECayICIARBBmpqIAMgA0H//wNxQeQAbiIAQeQAbGtB//8DcUEBdC8AuLpFOwAAC0EAIAUgABtFBEAgAkEBayICIARBBmpqIABBAXQtALm6RToAAAsgASAFQX9zQR92QQFBACAEQQZqIAJqQQogAmsQyAMgBEEQaiQAC+ACAgF9An8CQAJ9IAC8IgNB/////wdxIgJB////+wNNBEAgAkGAgID4A08EQCADQQBOBEBDAACAPyAAk0MAAAA/lCIAkSIBIAAgACAAQ2vTDbyUQ7oTL72SlEN1qio+kpQgAEOu5TS/lEMAAIA/kpWUIAAgAbxBgGBxviIAIACUkyABIACSlZIgAJIiACAAkg8LQ9oPyT8gAEMAAIA/kkMAAAA/lCIAkSIBIAEgACAAIABDa9MNvJRDuhMvvZKUQ3WqKj6SlCAAQ67lNL+UQwAAgD+SlZRDaCGis5KSkyIAIACSDwtD2g/JPyACQYGAgJQDSQ0BGkNoIaIzIAAgACAAlCIBIAEgAUNr0w28lEO6Ey+9kpRDdaoqPpKUIAFDruU0v5RDAACAP5KVlJMgAJND2g/JP5IPCyACQYCAgPwDRg0BQwAAAAAgACAAk5ULDwtDAAAAAEPaD0lAIANBAE4bC4ECAQV/IABBBGoQ6gICQAJAIAAtABxBA0YEQCAAKAIgIgIoAgAhASACQQRqKAIAIgMoAgAiBARAIAEgBBEDAAsgAygCBCIDBEAgAUEEaygCACIEQXhxIgVBBEEIIARBA3EiBBsgA2pJDQIgBEEAIAUgA0EnaksbDQMgARCiAgsgAkEEaygCACIBQXhxIgNBEEEUIAFBA3EiARtJDQEgAUEAIANBNE8bDQIgAhCiAgsgAEEEaygCACICQXhxIgFBKEEsIAJBA3EiAhtJDQAgAkEAIAFBzABPGw0BIAAQogIPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu4AgIIfwF9IwBBEGsiBSQAAkACQCADIARsIgZB/////wNLDQAgBkECdCIHQf3///8HTw0AAkAgB0UEQEEEIQhBACEGDAELIAcQcSIIRQ0CCyAFQQA2AgwgBSAINgIIIAUgBjYCBAJAIAQEQCAEQQJ0IQwDQCAJQQJ0IQsgCkECdCEGIApBAWohCiADIQcDQCAGQQNqIAJPDQMgASAGaioAACENIAUoAgQgCUYEQCAFQQRqQdzmxwAQ+gUgBSgCCCEICyAIIAtqIA04AgAgBSAJQQFqIgk2AgwgC0EEaiELIAYgDGohBiAHQQFrIgcNAAsgBCAKRw0ACwsgACAFKQIENwIAIABBCGogBUEMaigCADYCACAFQRBqJAAPCyAGIAZBBGogAkHs5scAEOoHAAtBzObHABD/BwsAC7gCAgd/AX0jAEEQayIIJAACQAJAIAMgBGwiB0H/////A0sNACAHQQJ0IglB/f///wdPDQACQCAJRQRAQQQhCkEAIQcMAQsgCRBxIgpFDQILIAhBADYCDCAIIAo2AgggCCAHNgIEAkAgBARAIAYgBZMhDkEAIQcDQCALQQJ0IQwgB0EBaiADIQ0DQCACIAdNDQMgBSAOIAEgB2otAACzQwAAf0OVlJIhBiAIKAIEIAtGBEAgCEEEakHM7McAEPoFIAgoAgghCgsgCiAMaiAGOAIAIAggC0EBaiILNgIMIAxBBGohDCAEIAdqIQcgDUEBayINDQALIgcgBEcNAAsLIAAgCCkCBDcCACAAQQhqIAhBDGooAgA2AgAgCEEQaiQADwsgByACQbzsxwAQjAcAC0Gs7McAEP8HCwALqwIBBX9BC0EAIABBgI8ETxsiAiACQQVqIgEgAEELdCICIAFBAnQoAtT6QkELdEkbIgEgAUEDaiIBIAFBAnQoAtT6QkELdCACSxsiASABQQFqIgEgAUECdCgC1PpCQQt0IAJLGyIBIAFBAWoiASABQQJ0KALU+kJBC3QgAksbIgFBAnQoAtT6QkELdCIEIAJGIAIgBEtqIAFqIgRBAnQiAkHU+sIAaiEFIAIoAtT6QkEVdiECQbsCIQECQCAEQRRNBEAgBSgCBEEVdiEBIARFDQELIAVBBGsoAgBB////AHEhAwsCQCABIAJBf3NqRQ0AIAAgA2shAyABQQFrIQFBACEAA0AgACACQer+wQBqLQAAaiIAIANLDQEgASACQQFqIgJHDQALCyACQQFxC7YCAQZ/IwBBEGsiBiQAIAAgASACEMwDAkAgAgRAIAAoAmAhCSAAKAJkIQhBACEBA0AgAUEDaiAITw0CAkACQCABIARPDQAgBCABayIFQQAgBCAFTxsiBUEBRwRAAkACQCAFQQJrDgIBAAQLIAFBA2ohAQwCCyABQQJqIQEMAQsgAUEBaiEBCyABIARB5ODAABCMBwALIAYgAyAHaiIFKgIAOAIAIAYgBUEMaioCADgCDCAGIAVBBGopAgA3AgQgByAJaiIFQQ9qIAYQnQQiCkEQdjoAACAFQQhqIgUgBS8BACAKQRB0IgVBgID8B3FyIAVBgICAeHFyNgIAIAdBEGohByABQQRqIQEgAkEBayICDQALCyAAQQE6ALgBIAZBEGokAA8LIAEgAUEEaiAIQdTgwAAQ6gcAC9kCAQN/IwBBEGsiAiQAIAEoAgBBjJvFAEEJIAEoAgQoAgwRAAAhAyACQQA6AAUgAiADOgAEIAIgATYCACACIAAoAAAiADYCCCACQaibxQBBBCACQQhqQZibxQAQjAUgAiAAQX9zQQV2QQFxOgAMQbybxQBBCCACQQxqQaybxQAQjAUgAiAAQQ12QQFxOgANQcSbxQBBByACQQ1qQaybxQAQjAUgAiAAQRV2QQFxOgAOQcubxQBBCCACQQ5qQaybxQAQjAUgAiAAQR12QQFxOgAPQdObxQBBCCACQQ9qQaybxQAQjAUhACACLQAFIgMgAi0ABCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXEL9wEBBH8CQAJAIAAoAgAiAgRAIAAoAgQiA0EEaygCACIBQXhxIgRBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAQgAkEnaksbDQIgAxCiAgsgACgCDCICBEAgACgCECIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAKAIYIgIEQCAAKAIcIgBBBGsoAgAiA0F4cSIBQQRBCCADQQNxIgMbIAJqSQ0BIANBACABIAJBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALsQICBX8DfiAALQAMQQxHBEAgAEEQajEAAEIghiEJIAA1AgwhCiAAKAIIIgUoAgAiAyAFKAIEIgYgACkDAKciB3EiAGopAABCgIGChIiQoMCAf4MiCFAEQEEIIQQDQCAAIARqIQAgBEEIaiEEIAMgACAGcSIAaikAAEKAgYKEiJCgwIB/gyIIUA0ACwsgAyAIeqdBA3YgAGogBnEiAGosAAAiBEEATgRAIAMgAykDAEKAgYKEiJCgwIB/g3qnQQN2IgBqLQAAIQQLIAAgA2ogB0EZdiIHOgAAIAMgAEEIayAGcWpBCGogBzoAACAFIAUoAgggBEEBcWs2AgggBSAFKAIMQQFqNgIMIAMgAEFobGoiAEEIayACNwMAIABBEGsgATcDACAAQRhrIAkgCoQ3AwALC7oCAQV/IwBBEGsiBSQAIAVBCGogACgCCCgCACABIAIQkQQCQAJAAkACQCAFLQAIIgZBBEcEQCAAKAIEIQEgAC0AACICQQRNIAJBA0dxRQRAIAEoAgAhAiABQQRqKAIAIgMoAgAiBARAIAIgBBEDAAsgAygCBCIDBEAgAkEEaygCACIEQXhxIgdBBEEIIARBA3EiBBsgA2pJDQMgBEEAIAcgA0EnaksbDQQgAhCiAgsgAUEEaygCACICQXhxIgNBEEEUIAJBA3EiAhtJDQQgAkEAIANBNE8bDQUgARCiAgsgACAFKQMINwIACyAFQRBqJAAgBkEERw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu6AgEEf0EfIQIgAEIANwIQIAFB////B00EQCABQSYgAUEIdmciA2t2QQFxIANBAXRrQT5qIQILIAAgAjYCHCACQQJ0QbC3yQBqIQRBASACdCIDQcy6yQAoAgBxRQRAIAQgADYCACAAIAQ2AhggACAANgIMIAAgADYCCEHMuskAQcy6yQAoAgAgA3I2AgAPCwJAAkAgASAEKAIAIgMoAgRBeHFGBEAgAyECDAELIAFBGSACQQF2a0EAIAJBH0cbdCEFA0AgAyAFQR12QQRxaiIEKAIQIgJFDQIgBUEBdCEFIAIhAyACKAIEQXhxIAFHDQALCyACKAIIIgEgADYCDCACIAA2AgggAEEANgIYIAAgAjYCDCAAIAE2AggPCyAEQRBqIAA2AgAgACADNgIYIAAgADYCDCAAIAA2AggLtQICAn0FfyAAIAEgAhDMAyACQQNsIQkgACoChAEgACoCgAEiBZMhBkECIAQgBEECTRtBA25BA2whCiAAKAJgIQIgACgCZCEHQQAhAUEAIQACQAJAAkACQANAIAFBBGoiCCAHSw0CIAAgBE8NAyADIAUgBiACKAIAIgFB/wFxs0MAAH9DlZSSOAIAIABBAWoiCyAETw0EIANBBGogBSAGIAFBCHZB/wFxs0MAAH9DlZSSOAIAIAAgCkYNASADQQhqIAUgBiABQRB2Qf8BcbNDAAB/Q5WUkjgCACACQRBqIQIgA0EMaiEDIAghASAJIABBA2oiAEcNAAsPCyAAQQJqIARB/NLAABCMBwALIAEgCCAHQYzTwAAQ6gcACyAAIARB3NLAABCMBwALIAsgBEHs0sAAEIwHAAuuAgIHfwF9IwBBEGsiByQAAkACQCADIARsIgZB/////wNLDQAgBkECdCIIQf3///8HTw0AAkAgCEUEQEEEIQlBACEGDAELIAgQcSIJRQ0CCyAHQQA2AgwgByAJNgIIIAcgBjYCBAJAIAQEQEEAIQYDQCAKQQJ0IQsgBkEBaiADIQwDQCACIAZNDQMgBSABIAZqLAAAskMAAP5ClZQhDSAHKAIEIApGBEAgB0EEakH87McAEPoFIAcoAgghCQsgCSALaiANOAIAIAcgCkEBaiIKNgIMIAtBBGohCyAEIAZqIQYgDEEBayIMDQALIgYgBEcNAAsLIAAgBykCBDcCACAAQQhqIAdBDGooAgA2AgAgB0EQaiQADwsgBiACQezsxwAQjAcAC0Hc7McAEP8HCwAL0wIBBn8jAEGwA2siAiQAIAJBCGogAUEBEI8BAkACQAJAAn8gAigCCEECRgRAIAIoAgwhAyACQQA2ApgDIAJCgICAgBA3ApADIAJBnJPBADYCoAMgAkKggICADjcCpAMgAiACQZADajYCnAMgAyACQZwDahCvBA0CIAIoApADIQQgAigClAMiBiACKAKYAxDsCCEBIAQEQCAGQQRrKAIAIgVBeHEiB0EEQQggBUEDcSIFGyAEakkNBCAFQQAgByAEQSdqSxsNBSAGEKICCyADIAMoAgAoAgARAwBBAQwBCyACQcwBaiIBIAJBCGpBxAH8CgAAIAEQ0QEhAUEACyEDIAAgATYCBCAAIAM2AgAgAkGwA2okAA8LQaCexgBBNyACQa8DakG0k8EAQdiexgAQ4AYAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAveAgEEfyMAQTBrIgEkACAAKAIsIgL9DAEAAAAAAAAAAAAAAAAAAAD9CwMIIABBADYCLCAAKAI4IQQgACgCNCEDIAIoAsRwIQAgASACKALIcCICNgIMIAEgADYCCAJAAkACQAJAAkAgAEUNACADQR1HBEAgBCAAQQRrKAAAIAMRAQAMAQsgAkUNASACQcH///8HTw0CIABBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAJqSQ0DIANBACAEIAJBJ2pLGw0EIAAQogILIAFBMGokAA8LIAFCATcCHCABQQE2AhQgAUH4g8kANgIQIAEgAUEIaq1CgICAgPADhDcDKCABIAFBKGo2AhhBASABQQxqQfDlyAAgAUEQakGAhMkAEPUHAAtB2ObIAEErIAFBEGpBtIPJAEHEg8kAEOAGAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALnQICBH8DfiMAQSBrIgMkAEEUIQIgACkDACIIIQYgCELoB1oEQCAIIQcDQCADQQxqIAJqIgBBBGsgByAHQpDOAIAiBkKQzgB+faciBEH//wNxQeQAbiIFQQF0LwC4ukU7AAAgAEECayAEIAVB5ABsa0H//wNxQQF0LwC4ukU7AAAgAkEEayECIAdC/6ziBFYgBiEHDQALCyAGQglWBEAgAkECayICIANBDGpqIAanIgAgAEH//wNxQeQAbiIAQeQAbGtB//8DcUEBdC8AuLpFOwAAIACtIQYLIAhQRSAGUHFFBEAgAkEBayICIANBDGpqIAanQQF0LQC5ukU6AAALIAFBAUEBQQAgA0EMaiACakEUIAJrEMgDIANBIGokAAu7AgEDfyMAQSBrIgIkAAJ/AkACQAJAIAAoAgBFBEAgACgCECIADQEMAwsgAkEIaiAAEMgFIAIoAggiA0UEQCACLQAMIQMgACgCECIEBEBBASAEQfqyxQBB6rLFACADQQFxIgQbQRlBECAEGxCXAw0FGgsgACADOgAEIABBADYCAEEADAQLIAJBCGogAyACKAIMIgQQwgQCQCACKAIIQQFGBEAgAiACKQMQNwMYIAAoAhAiAEUNBCACQRhqIAAQhQUNAQwDCyAAKAIQIgBFDQMgAEGEtMUAQQIQlwMNACAAIAMgBBCXA0UNAgtBAQwDCyAAQZOzxQBBARCXAwwCCyAALQAKQYABcQ0AIAIgARDnByACKAIAIgEEQCAAIAEgAigCBBCXAwwCC0GItMUAEN0JAAtBAAsgAkEgaiQAC6MCAQV/AkACQAJAIAIgAkEDakF8cSIERwRAIAQgAmshBUEAIQQgAUH/AXEhB0EBIQYDQCACIARqLQAAIAdGDQQgBSAEQQFqIgRHDQALIAUgA0EIayIGSw0CDAELIANBCGshBgsgAUH/AXFBgYKECGwhBANAQYCChAggAiAFaiIHKAIAIARzIghrIAhyQYCChAggB0EEaigCACAEcyIHayAHcnFBgIGChHhxQYCBgoR4Rw0BIAVBCGoiBSAGTQ0ACwsCQCADIAVGDQAgAyAFayEDIAIgBWohAkEAIQQgAUH/AXEhAQNAIAEgAiAEai0AAEcEQCAEQQFqIgQgA0cNAQwCCwsgBCAFaiEEQQEhBgwBC0EAIQYLIAAgBDYCBCAAIAY2AgALqAIBBn8gACgCCCABTwRAIAAgATYCCAsCQAJAAkACQAJAIAAoAhQiAkUgASACS3INACAAIAE2AhQgASACRg0AIAIgAWshBSAAKAIQIAFBGGxqIQIDQCACQRRqKAIAIgNBBU8EQCACQQhqKAIAIgZBBGsoAgAiBEF4cSIHIANBAnQiA0EEQQggBEEDcSIEG2pJDQMgBEEAIAcgA0EnaksbDQQgBhCiAgsgAkEYaiECIAVBAWsiBQ0ACwsgACgCICICRQ0DIAEgAk0NAgwDC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgACABNgIgCyAAKAIsIgJFIAEgAktyRQRAIAAgATYCLAsgACgCOCICRSABIAJLckUEQCAAIAE2AjgLC8UCAgN/AXsjAEEgayICJAACQAJAAkAgACgCACIDRQ0AIAAoAggiASAAKAIETw0AAkACQAJAIAEgA2otAAAiA0HJAEcEQCADQcIARw0EIAAgAUEBajYCCCACIAAQrwYgAigCAA0BIAAoAhAiAUUNAiABQfqyxQBB6rLFACACLQAEQQFxIgEbQRlBECABGxCXA0UNAkECIQEMBgsgACABQQFqNgIIQQIhASAAQQAQzAFFDQQMBQsgACgCEEUNASAA/QACACEEIAAgAv0AAgD9CwIAIAIgBP0LAxAgABCJBSAAIAL9AAMQ/QsCAEH/AXEhAQwECyAAIAL9AAIA/QsCAAtBACEBDAILQQJBACAAQQAQzAEbIQEMAQsgACgCECIDBEAgA0Gms8UAQQEQlwMNAQtBAkEBIAAQ7gQbIQELIAJBIGokACABC78CAQR/AkACQAJAIAEoAghBAkcEQCABKALABCICRQRAIAEtAMcCIQMgAS0AxgIhAgwECyACQZCABHEhBAJAIAJBAXEgAS0AxwIiAyIFQRBGcUUEQCAERQ0BQQggBSAFQQhNGyADIAQbIQMMAwtBCCEDIAQNAiABLQDGAiECDAQLIAEtAMYCIQIMAgtBrJjHABDdCQALAkACQAJAIAEoAtQBQYGAgIB4RwRAQQQhAiABLQDGAiIBDgQEAQMDAQsgAkGAgARxIQICQAJAIAEtAMYCIgEOBAACAQMCCyACRQRAQQAhAgwFC0EEIQIMBAsgAg0CQQIhAQsgASECDAILIAINAEECIQIMAQtBBiECCyADQf8BcSIBQRBNQQBBASABdEGWggRxGw0AQeiZxwAQ3QkACyAAIAM6AAEgACACOgAAC5kCAQd/IwBBEGsiBCQAQQohAiAAKAIAIgUhAyAFQegHTwRAIAUhAANAIARBBmogAmoiBkEEayAAIABBkM4AbiIDQZDOAGxrIgdB//8DcUHkAG4iCEEBdC8AuLpFOwAAIAZBAmsgByAIQeQAbGtB//8DcUEBdC8AuLpFOwAAIAJBBGshAiAAQf+s4gRLIAMhAA0ACwsCQCADQQlNBEAgAyEADAELIAJBAmsiAiAEQQZqaiADIANB//8DcUHkAG4iAEHkAGxrQf//A3FBAXQvALi6RTsAAAtBACAFIAAbRQRAIAJBAWsiAiAEQQZqaiAAQQF0LQC5ukU6AAALIAFBAUEBQQAgBEEGaiACakEKIAJrEMgDIARBEGokAAvQAgEEfyMAQSBrIgUkAEEBIQcCQCAALQAEDQAgAC0ABSEIIAAoAgAiBi0ACkGAAXFFBEAgBigCAEHnkMYAQfyzxQAgCEEBcSIIG0ECQQMgCBsgBigCBCgCDBEAAA0BIAYoAgAgASACIAYoAgQoAgwRAAANASAGKAIAQd34xwBBAiAGKAIEKAIMEQAADQEgAyAGIAQoAgwRAgAhBwwBCyAIQQFxRQRAIAYoAgBB+IHCAEEDIAYoAgQoAgwRAAANAQsgBUEBOgAPIAVB4IHCADYCFCAFIAYpAgA3AgAgBSAGKQIINwIYIAUgBUEPajYCCCAFIAU2AhAgBSABIAIQrwMNACAFQd34xwBBAhCvAw0AIAMgBUEQaiAEKAIMEQIADQAgBSgCEEHZgcIAQQIgBSgCFCgCDBEAACEHCyAAQQE6AAUgACAHOgAEIAVBIGokACAAC8ACAgN/AX4jAEEgayICJAAgAkEJOgAQIAIgASACQRBqIAEoAoABEOQEAkACQCACLQAAIgNBHUcEQCACKQIEIQUCfyADRQRAIAIgBTcDECAFpyEDIAIpAhQhBUEFDAELIAIoAgwhBEEQEHEiAUUNAyABIAM6AAAgASAENgIMIAEgBTcCBCABIAJBAXIiAy8AADsAASABQQNqIANBAmotAAA6AAAgAkGABjsBECACKAIQIQNBAAshBCAAQey7xAA2AhggACABNgIUIAAgBTcDCCAAIAM2AgQgACAENgIADAELIAIpAgghBUEAIQMgAigCBCIEQYCAgIB4RwRAIAIoAgggAigCDBCWAUH/AXEiA0EAIANBCEcbIQMLIAAgBTcDCCAAIAQ2AgQgASADOgCYASAAQQY2AgALIAJBIGokAA8LAAuhAgEGfyMAQRBrIgQkAAJAAkAgA0H/////A0sNACADQQJ0IgVB/f///wdPDQACQCAFRQRAQQQhBwwBCyADIQYgBRBxIgdFDQILIARBADYCDCAEIAc2AgggBCAGNgIEAkACQCADBEBBACEFQQAhBgNAIAIgBU0NAiAFQQFqIgkgAk8NAyABIAVqLwAAIQkgBCgCBCAGRgRAIARBBGpBnOrHABD6BSAEKAIIIQcLIAcgCGogCTYCACAEIAZBAWoiBjYCDCAIQQRqIQggBUECaiEFIAMgBkcNAAsLIAAgBCkCBDcCACAAQQhqIARBDGooAgA2AgAgBEEQaiQADwsgBSACQfzpxwAQjAcACyAJIAJBjOrHABCMBwALQezpxwAQ/wcLAAucAgACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEH/AXFBAWsOBwUAAQICAgMECyADQX1NIANBAmoiACACTXENBSADIAAgAkG02scAEOoHAAsgA0F9TSADQQJqIgAgAk1xDQUgAyAAIAJBxNrHABDqBwALIANBe00gA0EEaiIAIAJNcQ0FIAMgACACQdTaxwAQ6gcACyADQXdNIANBCGoiACACTXENBSADIAAgAkHk2scAEOoHAAsgAiADTQ0FIAEgA2osAAAPCyACIANLDQUgAyACQaTaxwAQjAcACyABIANqLgAADwsgASADai8AAA8LIAEgA2ooAAAPCyABIANqKwAA/AMPCyADIAJBlNrHABCMBwALIAEgA2otAAALzQIBBH8jAEEgayIEJAAgASgCDCEFAkAgAAJ/AkACQAJAIAEoAhQiAiABKAIQIgNJBEADQAJAIAIgBWotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgASACQQFqIgI2AhQgAiADRw0ACyADIQILIARBEGogBSADIAJBAWoiASADIAEgA0kbEPkBIAQoAhQhASAEKAIQIQNBFBBxIgJFDQQgAkEDNgIADAELIARBCGogBSADIAJBAWoiASADIAEgA0kbEPkBIAQoAgwhASAEKAIIIQNBFBBxIgJFDQMgAkEGNgIACyACIAM2AgwgAiABNgIQQQEMAQsgASACQQFqNgIUIARBGGogARCVAyAEKAIcIQIgBCgCGAs2AgAgACACNgIEIARBIGokAA8LAAu2AgEBfyMAQUBqIgMkACADIAI2AhAgAyABNgIMIAACfwJAAkACQAJAAkACQAJAIAJBA2sOBwAFAQIFBQMFCyABQZDQxwBBAxDbB0UEQCAAQQA6AAFBAAwHCyABQaD3xwBBAxDbBw0DIABBAToAAUEADAYLIAFBo/fHAEEFENsHDQMgAEECOgABQQAMBQsgAUGo98cAQQYQ2wcNAiAAQQM6AAFBAAwECyABQa73xwBBCRDbBw0BIABBBDoAAUEADAMLIAFBt/fHAEEDENsHRQ0BCyADQQE2AiQgA0HQ98cANgIgIANCATcCLCADIANBDGqtQoCAgIAghDcDOCADIANBOGo2AiggA0EUaiIBIANBIGoQ7AMgACABEJAHNgIEQQEMAQsgAEEFOgABQQALOgAAIANBQGskAAuNAgEGfyAAKAIIIgQhAgJ/QQEgAUGAAUkNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsiBiAAKAIAIARrSwR/IAAgBCAGQQFBARCkBSAAKAIIBSACCyAAKAIEaiECAkAgAUGAAU8EQCABQT9xQYB/ciEFIAFBBnYhAyABQYAQSQRAIAIgBToAASACIANBwAFyOgAADAILIAFBDHYhByADQT9xQYB/ciEDIAFB//8DTQRAIAIgBToAAiACIAM6AAEgAiAHQeABcjoAAAwCCyACIAU6AAMgAiADOgACIAIgB0E/cUGAf3I6AAEgAiABQRJ2QXByOgAADAELIAIgAToAAAsgACAEIAZqNgIIQQALrQIBBn8CQAJAAkACQAJAQQQQcSIBRQ0AIAFBmJXBADYCAEEIEHEiAEUNACAAIAE2AgAgAEG4lcEANgIEQdi2yQBB2LbJACgCACIBIAAgARs2AgAgAUUEQCAADwsgACgCACECIAAoAgQiAygCACIEBEAgAiAEEQMACyADKAIEIgMEQCACQQRrKAIAIgRBeHEiBUEEQQggBEEDcSIEGyADakkNAiAEQQAgBSADQSdqSxsNAyACEKICCyAAQQRrKAIAIgJBeHFBDEEQIAJBA3EiAxtJDQMgA0EAIAJBME8bDQQgABCiAiABDwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALoQIBBn8CQAJAAkACQAJAIAAoAgQiBCAAKAIIIgVrIgggAyACayIGQRBqSQRAIAEoAggiByABKAIEIglLDQUgAiADSyADIAdLcg0BIAQgBUkNAiAGIAhNDQNBACAGIAhBjP/IABDqBwALIAIgA0YNAyAAKAIAIAVqIgQgASgCACIBIAJqIgL9AAAA/QsAACACQRBqIgIgASADaiIBTw0DIARBEGohAwNAIAMgAv0AAAD9CwAAIANBEGohAyACQRBqIgIgAUkNAAsMAwsgAiADIAdBrP/IABDqBwALIAUgBCAEQZz/yAAQ6gcACyAGRQ0AIAAoAgAgBWogASgCACACaiAG/AoAAAsgACAFIAZqNgIIDwtBACAHIAlBgP7IABDqBwALrgICBX8BfiMAQUBqIgIkACABKAIAQYCAgIB4RgRAIAEoAgwgAkEANgIkIAJCgICAgBA3AhwoAgAiAykCECEHIAMoAgwhBCADKAIIIQUgAygCACEGIAMoAgQhAyACIAc3AjggAiAENgI0IAIgBTYCMCACIAM2AiwgAiAGNgIoIAJBHGpBzIXIACACQShqEMEDGiACQRhqIAJBJGooAgAiAzYCACACIAIpAhwiBzcDECABQQhqIAM2AgAgASAHNwIACyABKQIAIQcgAUKAgICAEDcCACACQQhqIgMgAUEIaiIBKAIANgIAIAFBADYCACACIAc3AwBBDBBxIgFFBEAACyABIAIpAwA3AgAgAUEIaiADKAIANgIAIABB3I3IADYCBCAAIAE2AgAgAkFAayQAC4kCAQZ/IAAoAggiBCECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIGIAAoAgAgBGtLBH8gACAEIAYQ9wUgACgCCAUgAgsgACgCBGohAgJAIAFBgAFPBEAgAUE/cUGAf3IhBSABQQZ2IQMgAUGAEEkEQCACIAU6AAEgAiADQcABcjoAAAwCCyABQQx2IQcgA0E/cUGAf3IhAyABQf//A00EQCACIAU6AAIgAiADOgABIAIgB0HgAXI6AAAMAgsgAiAFOgADIAIgAzoAAiACIAdBP3FBgH9yOgABIAIgAUESdkFwcjoAAAwBCyACIAE6AAALIAAgBCAGajYCCEEAC4kCAQZ/IAAoAggiBCECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIGIAAoAgAgBGtLBH8gACAEIAYQ+AUgACgCCAUgAgsgACgCBGohAgJAIAFBgAFPBEAgAUE/cUGAf3IhBSABQQZ2IQMgAUGAEEkEQCACIAU6AAEgAiADQcABcjoAAAwCCyABQQx2IQcgA0E/cUGAf3IhAyABQf//A00EQCACIAU6AAIgAiADOgABIAIgB0HgAXI6AAAMAgsgAiAFOgADIAIgAzoAAiACIAdBP3FBgH9yOgABIAIgAUESdkFwcjoAAAwBCyACIAE6AAALIAAgBCAGajYCCEEAC4kCAQZ/IAAoAggiBCECAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIGIAAoAgAgBGtLBH8gACAEIAYQ7wUgACgCCAUgAgsgACgCBGohAgJAIAFBgAFPBEAgAUE/cUGAf3IhBSABQQZ2IQMgAUGAEEkEQCACIAU6AAEgAiADQcABcjoAAAwCCyABQQx2IQcgA0E/cUGAf3IhAyABQf//A00EQCACIAU6AAIgAiADOgABIAIgB0HgAXI6AAAMAgsgAiAFOgADIAIgAzoAAiACIAdBP3FBgH9yOgABIAIgAUESdkFwcjoAAAwBCyACIAE6AAALIAAgBCAGajYCCEEAC/gBAgR/An4gACgCECECIAApAwghBiAAKAIEIQUgACgCGCIEQQBIBEAgAiAFSQRAIAAoAgAgAkECdGooAAAhAwsgA0EYdCADQYD+A3FBCHRyIANBCHZBgP4DcSADQRh2cnKtIAZCIIaEIQYgBEEgaiEEIAJBAWohAgsgAiAFTQRAIAAoAhQhAyAAIAI2AhAgACAGIANBAWsgAUH/AXFsQQh2QQFqIgGtIARBP3GthiIHQgAgBiAHWiICG303AwggACAEIAMgAWsgASACGyIBZyIEQRhrIgNBACADIARNGyIEazYCGCAAIAEgBHQ2AhQgAg8LIAAgARDRBAuUAgEEfyMAQRBrIgIkACACQQA2AgwCfyABQYABTwRAIAFBP3FBgH9yIQMgAUEGdiEEIAFBgBBJBEAgAiADOgANIAIgBEHAAXI6AAxBAgwCCyABQQx2IQUgBEE/cUGAf3IhBCABQf//A00EQCACIAM6AA4gAiAEOgANIAIgBUHgAXI6AAxBAwwCCyACIAM6AA8gAiAEOgAOIAIgBUE/cUGAf3I6AA0gAiABQRJ2QXByOgAMQQQMAQsgAiABOgAMQQELIQEgACAAKAIEIgMgAWs2AgQgACAAKAIAIAEgA0tyIgQ2AgBBASEDIARFBEAgACgCCCIAKAIAIAJBDGogASAAKAIEKAIMEQAAIQMLIAJBEGokACADC4ICAQV/IwBBEGsiAyQAAkAgAC4BACIFIAXBQQ91IgBzIABrIgJB//8DcSIEQegHTwRAQQEhACADIAIgBEGQzgBuIgJBkM4AbGsiBEH//wNxQeQAbiIGQQF0LwC4ukU7AAwgAyAEIAZB5ABsa0H//wNxQQF0LwC4ukU7AA4MAQtBBSEAIARBCkkNACADIAIgAkH//wNxQeQAbiICQeQAbGtB//8DcUEBdC8AuLpFOwAOQQMhAAtBACAFIAJB//8DcSICG0UEQCAAQQFrIgAgA0ELamogAkEBdC0AubpFOgAACyABIAVBAE5BAUEAIANBC2ogAGpBBSAAaxDIAyADQRBqJAALugMBDH8jAEEQayIFJAACQAJAIANBAEgNACADQQF0IgRB/////wdPDQACQCAERQRAQQIhBAwBCyADIQcgBBBxIgRFDQILIAVBADYCDCAFIAQ2AgggBSAHNgIEAkACQCADBEBBACEHA0AgAiAGTQ0CIAZBAWoiCCACTw0DIAEgBmovAAAhDSAFKAIEIAdGBEBBACEJIwBBIGsiBCQAAkACQEEEIAVBBGoiCCgCACIOQQF0IgsgC0EETRsiDEEASA0AIAxBAXQiD0H+////B0sNACAEIA4EfyAEIAs2AhwgBCAIKAIENgIUQQIFQQALNgIYIARBCGpBAiAPIARBFGoQhQcgBCgCCEEBRw0BIAQoAhAhCiAEKAIMIQkLIAkgCkGs58cAEJMJAAsgBCgCDCEJIAggDDYCACAIIAk2AgQgBEEgaiQAIAUoAgghBAsgBCAGaiANOwEAIAUgB0EBaiIHNgIMIAZBAmohBiADIAdHDQALCyAAIAUpAgQ3AgAgAEEIaiAFQQxqKAIANgIAIAVBEGokAA8LIAYgAkGM58cAEIwHAAsgCCACQZznxwAQjAcAC0H85scAEP8HCwALuwIBBX8jAEEgayICJAACQCAAKAIAIgQoAgAEQEEBIQAgASgCACIDQcOYyABBBCABKAIEIgYoAgwiBREAAA0BAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBREAAA0DIAQoAgAgASAEQQRqKAIAKAIMEQIADQMgASgCACEDIAEoAgQoAgwhBQwBCyADQduBwgBBAiAFEQAADQIgAkEBOgAPIAIgBjYCBCACIAM2AgAgAkHggcIANgIUIAIgASkCCDcCGCACIAJBD2o2AgggAiACNgIQIAQoAgAgAkEQaiAEQQRqKAIAKAIMEQIADQIgAigCEEHZgcIAQQIgAigCFCgCDBEAAA0CCyADQd6OyABBASAFEQAAIQAMAQsgASgCAEG/mMgAQQQgASgCBCgCDBEAACEACyACQSBqJAAgAAuhAgICfwJ9AkACQCAAvCIBQYCAgAROBEAgAUH////7B0sNAUGBfyECQwAAAAAhACABQYCAgPwDRg0BDAILIABDAAAAAFsEQEMAAIC/IAAgAJSVDwsgAUEATgRAIABDAAAATJS8IQFB6H4hAgwCCyAAIACTQwAAAACVIQALIAAPCyABQY32qwJqIgFB////A3FB84nU+QNqvkMAAIC/kiIAIAAgAEMAAAA/lJQiA5O8QYBgcb4iBEMAsLg/lCAAIASTIAOTIAAgAEMAAABAkpUiACADIAAgAJQiACAAIACUIgBD7umRPpRDqqoqP5KUIAAgAEMmnng+lEMTzsw+kpSSkpSSIgBDALC4P5QgACAEkkPUmji5lJKSIAFBF3YgAmqykguaAgEEfyMAQSBrIgIkAAJAIAACfwJAIAEoAgBBlICAgHhGBEAgASgCDCIERQRADAILIAJBEGogASgCCCIFEKkEQQEhAyACKAIUIgEgAigCEEEBcQ0CGiAEQQFGDQEgAkEIaiAFQRBqEKkEIAIoAgwhAyADIAIoAghBAXENAhogBEECRwRAIAJBAjYCHCAEQf7///8AakH/////AHFBAmogAkEcakHolcEAENsGIQEgAEEBNgIAIAAgATYCBAwECyAAIAM2AgggACABNgIEIABBADYCAAwDCyABIAJBHGpBlOLAABCVCCEBIABBATYCACAAIAE2AgQMAgsgAyACQRxqQZTiwAAQ2wYLNgIEIABBATYCAAsgAkEgaiQAC4sCAQV/IwBBEGsiBiQAIAAgASACEOkEAkAgAgRAIAAoAoQBQQxqIQkgACgCiAEhCEEAIQEDQCABQQNqIAhPDQICQAJAIAEgBE8NACAEIAFrIgVBACAEIAVPGyIFQQFHBEACQAJAIAVBAmsOAgEABAsgAUEDaiEBDAILIAFBAmohAQwBCyABQQFqIQELIAEgBEHYvsEAEIwHAAsgBiADIAdqIgUqAgA4AgAgBiAFQQxqKgIAOAIMIAYgBUEEaikCADcCBCAHIAlqIAYQzQQ2AgAgB0EQaiEHIAFBBGohASACQQFrIgINAAsLIABBAToAwAEgBkEQaiQADwsgASABQQRqIAhByL7BABDqBwALwQICA38BfiMAQRBrIgIkAAJAAkACQAJAQQIgACgCACIAKQMAIgWnQQJrIAVCAVgbQQFrDgIBAgALIAEoAgBBranHAEEOIAEoAgQoAgwRAAAhAQwCCyABKAIAQbupxwBBEiABKAIEKAIMEQAAIQEMAQsgAiAAQSBqNgIEIAEoAgBBjYvIAEELIAEoAgQoAgwRAAAhAyACQQA6AA0gAiADOgAMIAIgATYCCCACQQhqQfCpxwBBBiAAQdCpxwAQjAVB9qnHAEEJIAJBBGpB4KnHABCMBSACLQANIgMgAi0ADCIEciEBIARBAXEgA0EBR3INACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQuwBgEKfyMAQRBrIggkAAJAAkACQAJAIAIEQCAAIAEgAhDMAyACQQNsIQxBAiAEIARBAk0bQQNuQQNsIQ0gACgCYCEBIAAoAmQhCkEAIQBBACECA0AgAEEEaiILIApLDQMgCEEEaiEJAn8gASgCBCIAQf//AXFFBEAgAEEQdAwBCyAAQf8HcSEFIABBgIACcSEGIABBgPgBcSIHQYD4AUYEQCAGQRB0IgZBgICA/AdyIAVFDQEaIAYgBUENdHJBgICA/gdyDAELIAZBEHQiBiAHQQ10QYCAgPwAcSAFQQ10ckGAgIDAA2pyIAcNABogBkGAgIDYA3IgBWdBEGsiBkEXdGsgBSAGQf//A3FBCGp0Qf///wNxcgshDgJ/IABBgIB8cSAAQRB2IgBB//8BcUUNABogAEH/B3EhBSAAQYCAAnEhBiAAQYD4AXEiB0GA+AFGBEAgBkEQdCIGQYCAgPwHciAFRQ0BGiAGIABBDXRyQYCAgP4HcgwBCyAGQRB0IgAgB0ENdEGAgID8AHEgBUENdHJBgICAwANqciAHDQAaIABBgICA2ANyIAVnQRBrIgBBF3RrIAUgAEH//wNxQQhqdEH///8DcXILIQcgCQJ/IAEoAggiBUH//wFxRQRAIAVBEHQMAQsgBUH/B3EhACAFQYCAAnEhBiAFQYD4AXEiBUGA+AFGBEAgBkEQdCIFQYCAgPwHciAARQ0BGiAFIABBDXRyQYCAgP4HcgwBCyAGQRB0IgYgBUENdEGAgID8AHEgAEENdHJBgICAwANqciAFDQAaIAZBgICA2ANyIABnQRBrIgVBF3RrIAAgBUH//wNxQQhqdEH///8DcXILNgIIIAkgBzYCBCAJIA42AgAgAiAETw0EIAMgCCoCBDgCACACQQFqIgAgBE8NBSADQQRqIAgqAgg4AgAgAiANRg0CIANBCGogCCoCDDgCACABQRBqIQEgA0EMaiEDIAshACAMIAJBA2oiAkcNAAsLIAhBEGokAA8LIAJBAmogBEG80cAAEIwHAAsgACALIApBzNHAABDqBwALIAIgBEGc0cAAEIwHAAsgACAEQazRwAAQjAcAC4ACAQd/IwBBIGsiASQAAkAgAC0AwAEEQCAAKAKwASAAKAK4ASICQQJ0IgUgACgCvAEgAmpBAnQiBhDhCCECIAAoAnghByAAKAJ8IQMgAhC4CiEEIAEgAzYCBCABIAQ2AgAgAyAERw0BIAIgByADEOAJIAJBhAhPBEAgAhCbBwsgACgCtAEgBSAGEOEIIQIgACgChAEhBSAAKAKIASEDIAIQuAohBCABIAM2AgQgASAENgIAIAMgBEcNASACIAUgAxDgCSACQYQITwRAIAIQmwcLIABBADoAwAELIAFBIGokAA8LIAFBADYCCEEAIAEgAUEEaiABQQhqQeD5xAAQ9QcAC/oBAgR/AX4jAEEgayIFJAACQAJAIAIgASACaiIGSwRAQQAhAQwBC0EAIQEgAyAEakEBa0EAIANrca0gBiAAKAIAIgdBAXQiAiACIAZJGyICQQhBBCAEQQFGGyIGIAIgBksbIgatfiIJQiCIUEUNACAJpyIIQYCAgIB4IANrSw0AQQAhAiAFIAcEfyAFIAQgB2w2AhwgBSAAKAIENgIUIAMFIAILNgIYIAVBCGogAyAIIAVBFGoQhQcgBSgCCEEBRw0BIAUoAhAhAiAFKAIMIQELIAEgAkGclsgAEJMJAAsgBSgCDCEBIAAgBjYCACAAIAE2AgQgBUEgaiQAC6ECAAJ/AkACQAJAAkAgAkEDaw4EAgMAAQMLAkACQAJAIAEtAABB7QBrDgUBBQUFAAULIAEtAAFB9QBGDQEMBAsgAS0AAUHlAEcNAyABLQACQeEARw0DIAEtAANB7gBHDQMgAS0ABEHzAEcNA0EADAQLIAEtAAJB4QBHDQIgAS0AA0H0AEcNAiABLQAEQfMARw0CQQIMAwsgAS0AAEHzAEcNASABLQABQeMARw0BIAEtAAJB4QBHDQEgAS0AA0HsAEcNASABLQAEQeUARw0BIAEtAAVB8wBHDQFBAQwCCyABLQAAQfMARw0AIAEtAAFB6ABHDQBBA0EEQQUgAS0AAiIBQc4ARhsgAUEwRhsMAQtBBQshASAAQQA6AAAgACABOgABC5oCAQJ/IwBBQGoiASQAAkAgABBBIgINACAALQChVEUEQCABQQA2AjggAUEBNgIsIAFB5KPBADYCKCABQgQ3AjAgAUEoahCSByECDAELAkAgACgC4AFBgICAgHhHBEAgAC0AlAIiAkEJRg0BIAJBBUYEQCAAKAKMAkUNAgsgAUECNgIsIAFBnKTBADYCKCABQgI3AjQgASAAQYwCaq1CgICAgBCENwMgIAEgAEGUAmqtQoCAgICwBIQ3AxggASABQRhqNgIwIAFBDGoiACABQShqELEGIAAQjgchAgwCCyABQQA2AjggAUEBNgIsIAFBwKTBADYCKCABQgQ3AjAgAUEoahCSByECDAELIAAQowEhAgsgAUFAayQAIAILmgIBAn8jAEFAaiIBJAACQCAAEEAiAg0AIAAtAKlURQRAIAFBADYCOCABQQE2AiwgAUHko8EANgIoIAFCBDcCMCABQShqEJIHIQIMAQsCQCAAKALoAUGAgICAeEcEQCAALQCcAiICQQlGDQEgAkEFRgRAIAAoApQCRQ0CCyABQQI2AiwgAUGcpMEANgIoIAFCAjcCNCABIABBlAJqrUKAgICAEIQ3AyAgASAAQZwCaq1CgICAgLAEhDcDGCABIAFBGGo2AjAgAUEMaiIAIAFBKGoQsQYgABCOByECDAILIAFBADYCOCABQQE2AiwgAUHApMEANgIoIAFCBDcCMCABQShqEJIHIQIMAQsgABDUASECCyABQUBrJAAgAgv7AQEDfyMAQRBrIgIkACAAKAIAIQACfyABLQALQRhxRQRAIAEoAgAgACABKAIEKAIQEQIADAELIAJBADYCDCABIAJBDGoCfyAAQYABTwRAIABBP3FBgH9yIQMgAEEGdiEBIABBgBBJBEAgAiADOgANIAIgAUHAAXI6AAxBAgwCCyAAQQx2IQQgAUE/cUGAf3IhASAAQf//A00EQCACIAM6AA4gAiABOgANIAIgBEHgAXI6AAxBAwwCCyACIAM6AA8gAiABOgAOIAIgBEE/cUGAf3I6AA0gAiAAQRJ2QXByOgAMQQQMAQsgAiAAOgAMQQELEJcDCyACQRBqJAAL7QEBA38jAEEQayIDJAAgACgCACEAAn8CQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BIAAgARCLBQwCCyAAKAIAIQBBCSECA0AgAiADakEGaiAAQQ9xLQDctkU6AAAgAkEBayECIABBD0sgAEEEdiEADQALIAFBAUGEtMUAQQIgAiADakEHakEJIAJrEMgDDAELIAAoAgAhAEEJIQIDQCACIANqQQZqIABBD3EtAMmBQjoAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQYS0xQBBAiACIANqQQdqQQkgAmsQyAMLIANBEGokAAvrAQIEfwJ+IAAoAhAhAiAAKQMIIQUgACgCBCEEIAAoAhgiA0EASARAIAIgBEkEQCAAKAIAIAJBAnRqKAAAIQELIAFBGHQgAUGA/gNxQQh0ciABQQh2QYD+A3EgAUEYdnJyrSAFQiCGhCEFIANBIGohAyACQQFqIQILIAIgBE0EQCAAKAIUIQEgACACNgIQIAAgBSABIAFBAXYiAWsiBK0gA0E/ca2GIgZCACAFIAZaIgIbfTcDCCAAIAMgASAEIAIbIgFnIgNBGGsiBEEAIAMgBE8bIgNrNgIYIAAgASADdDYCFCACDwsgABC0Cgu7AgEEfyMAQRBrIgQkACABKAIMIQUCQAJAAkACQAJAIAEoAhQiAiABKAIQIgNJBEADQAJAIAIgBWotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgASACQQFqIgI2AhQgAiADRw0ACyADIQILIARBCGogBSADIAJBAWoiASADIAEgA0kbEPkBIAQoAgwhASAEKAIIIQNBFBBxIgJFDQQgAkEDNgIADAELIAQgBSADIAJBAWoiASADIAEgA0kbEPkBIAQoAgQhASAEKAIAIQNBFBBxIgJFDQMgAkEGNgIACyACIAM2AgwgACACNgIEIABBATYCACACIAE2AhAMAQsgASACQQFqNgIUIAAgARC7AwsgBEEQaiQADwsAC7sCAQR/IwBBEGsiBCQAIAEoAgwhBQJAAkACQAJAAkAgASgCFCICIAEoAhAiA0kEQANAAkAgAiAFai0AAEEJaw4yAAADAwADAwMDAwMDAwMDAwMDAwMDAwMAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwUDCyABIAJBAWoiAjYCFCACIANHDQALIAMhAgsgBEEIaiAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCDCEBIAQoAgghA0EUEHEiAkUNBCACQQM2AgAMAQsgBCAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCBCEBIAQoAgAhA0EUEHEiAkUNAyACQQY2AgALIAIgAzYCDCAAIAI2AgQgAEEBOgAAIAIgATYCEAwBCyABIAJBAWo2AhQgACABEIECCyAEQRBqJAAPCwALvwIBBH8jAEEQayIEJAAgASgCDCEFAkACQAJAAkACQCABKAIUIgIgASgCECIDSQRAA0ACQCACIAVqLQAAQQlrDjIAAAMDAAMDAwMDAwMDAwMDAwMDAwMDAwADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBQMLIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECCyAEQQhqIAUgAyACQQFqIgEgAyABIANJGxD5ASAEKAIMIQEgBCgCCCEDQRQQcSICRQ0EIAJBAzYCAAwBCyAEIAUgAyACQQFqIgEgAyABIANJGxD5ASAEKAIEIQEgBCgCACEDQRQQcSICRQ0DIAJBBjYCAAsgAiADNgIMIAAgAjYCBCAAQYGAgIB4NgIAIAIgATYCEAwBCyABIAJBAWo2AhQgACABENwCCyAEQRBqJAAPCwALuwIBBH8jAEEQayIEJAAgASgCDCEFAkACQAJAAkACQCABKAIUIgIgASgCECIDSQRAA0ACQCACIAVqLQAAQQlrDjIAAAMDAAMDAwMDAwMDAwMDAwMDAwMDAwADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBQMLIAEgAkEBaiICNgIUIAIgA0cNAAsgAyECCyAEQQhqIAUgAyACQQFqIgEgAyABIANJGxD5ASAEKAIMIQEgBCgCCCEDQRQQcSICRQ0EIAJBAzYCAAwBCyAEIAUgAyACQQFqIgEgAyABIANJGxD5ASAEKAIEIQEgBCgCACEDQRQQcSICRQ0DIAJBBjYCAAsgAiADNgIMIAAgAjYCBCAAQQI2AgAgAiABNgIQDAELIAEgAkEBajYCFCAAIAEQpQILIARBEGokAA8LAAu7AgEEfyMAQRBrIgQkACABKAIMIQUCQAJAAkACQAJAIAEoAhQiAiABKAIQIgNJBEADQAJAIAIgBWotAABBCWsOMgAAAwMAAwMDAwMDAwMDAwMDAwMDAwMDAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFAwsgASACQQFqIgI2AhQgAiADRw0ACyADIQILIARBCGogBSADIAJBAWoiASADIAEgA0kbEPkBIAQoAgwhASAEKAIIIQNBFBBxIgJFDQQgAkEDNgIADAELIAQgBSADIAJBAWoiASADIAEgA0kbEPkBIAQoAgQhASAEKAIAIQNBFBBxIgJFDQMgAkEGNgIACyACIAM2AgwgACACNgIEIABBAzYCACACIAE2AhAMAQsgASACQQFqNgIUIAAgARCDAQsgBEEQaiQADwsAC7sCAQR/IwBBEGsiBCQAIAEoAgwhBQJAAkACQAJAAkAgASgCFCICIAEoAhAiA0kEQANAAkAgAiAFai0AAEEJaw4yAAADAwADAwMDAwMDAwMDAwMDAwMDAwMAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwUDCyABIAJBAWoiAjYCFCACIANHDQALIAMhAgsgBEEIaiAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCDCEBIAQoAgghA0EUEHEiAkUNBCACQQM2AgAMAQsgBCAFIAMgAkEBaiIBIAMgASADSRsQ+QEgBCgCBCEBIAQoAgAhA0EUEHEiAkUNAyACQQY2AgALIAIgAzYCDCAAIAI2AgQgAEECNgIAIAIgATYCEAwBCyABIAJBAWo2AhQgACABENICCyAEQRBqJAAPCwALqQIBBX8jAEEgayICJABBASEDAkAgACgCACIELQAAQQFGBEAgASgCACIAQcOYyABBBCABKAIEIgYoAgwiBREAAA0BIARBAWohBAJAIAEtAApBgAFxRQRAIABBu7PFAEEBIAURAAANAyAEIAEQygQNAyABKAIAIQAgASgCBCgCDCEFDAELIABB24HCAEECIAURAAANAiACQQE6AA8gAiAGNgIEIAIgADYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgBCACQRBqEMoEDQIgAigCEEHZgcIAQQIgAigCFCgCDBEAAA0CCyAAQd6OyABBASAFEQAAIQMMAQsgASgCAEG/mMgAQQQgASgCBCgCDBEAACEDCyACQSBqJAAgAwutAgEDfyMAQRBrIgIkACABKAIIIQMgAUEANgIIAkACQCADBEAgAygCAEGUgICAeEYEQAJAIAACfyADKAIMIgQEQCACIAMoAggQqAMgAigCACIBQYCAgIB4Rw0CIAIoAgQMAQtBACACQQ9qQYTiwAAQ2wYLNgIEIABBgICAgHg2AgAMBAsgAigCBCEDIARBAUYNAiACQQE2AgAgBEEBa0H/////AHFBAWogAkHolcEAENsGIQQgAEGAgICAeDYCACAAIAQ2AgQgAUUNAyADIAFBARCiBwwDCyADIAJBD2pBhOLAABCVCCEBIABBgICAgHg2AgAgACABNgIEDAILQcvawABBLEH42sAAEKsHAAsgACACKAIINgIIIAAgAzYCBCAAIAE2AgALIAJBEGokAAupAgEFfyMAQSBrIgIkAEEBIQMCQCAAKAIAIgQoAgBBAUYEQCABKAIAIgBBw5jIAEEEIAEoAgQiBigCDCIFEQAADQEgBEEIaiEEAkAgAS0ACkGAAXFFBEAgAEG7s8UAQQEgBREAAA0DIAQgARDEBQ0DIAEoAgAhACABKAIEKAIMIQUMAQsgAEHbgcIAQQIgBREAAA0CIAJBAToADyACIAY2AgQgAiAANgIAIAJB4IHCADYCFCACIAEpAgg3AhggAiACQQ9qNgIIIAIgAjYCECAEIAJBEGoQxAUNAiACKAIQQdmBwgBBAiACKAIUKAIMEQAADQILIABB3o7IAEEBIAURAAAhAwwBCyABKAIAQb+YyABBBCABKAIEKAIMEQAAIQMLIAJBIGokACADC5ECAQN/IwBBQGoiASQAAkAgABA9IgINACAALQClU0UEQCABQQA2AjggAUEBNgIsIAFB5KPBADYCKCABQgQ3AjAgAUEoahCSByECDAELIAAoAmRBgICAgHhHBEBBACECIAAtAJgBIgNBCUYNASADQQVGBEAgACgCkAFFDQILIAFBAjYCLCABQZykwQA2AiggAUICNwI0IAEgAEGQAWqtQoCAgIAQhDcDICABIABBmAFqrUKAgICAsASENwMYIAEgAUEYajYCMCABQQxqIgAgAUEoahCxBiAAEI4HIQIMAQsgAUEANgI4IAFBATYCLCABQcCkwQA2AiggAUIENwIwIAFBKGoQkgchAgsgAUFAayQAIAILkgIBA38jAEFAaiIBJAACQCAAED4iAg0AIAAtAMVTRQRAIAFBADYCOCABQQE2AiwgAUHko8EANgIoIAFCBDcCMCABQShqEJIHIQIMAQsgACgChAFBgICAgHhHBEBBACECIAAtALgBIgNBCUYNASADQQVGBEAgACgCsAFFDQILIAFBAjYCLCABQZykwQA2AiggAUICNwI0IAEgAEGwAWqtQoCAgIAQhDcDICABIABBuAFqrUKAgICAsASENwMYIAEgAUEYajYCMCABQQxqIgAgAUEoahCxBiAAEI4HIQIMAQsgAUEANgI4IAFBATYCLCABQcCkwQA2AiggAUIENwIwIAFBKGoQkgchAgsgAUFAayQAIAILiAIBAn8jAEHwAGsiAyQAAkACQAJAAkACQCABRQRAIABFDQEgAEEIayIBKAIAQQFHDQQgA0EIaiAAQQRqQegA/AoAACABQQA2AgACQCABQX9GDQAgAEEEayICIAIoAgBBAWsiAjYCACACDQAgAEEMaygCACIAQXhxIgJB+ABB/AAgAEEDcSIAG0kNAyAAQQAgAkGcAU8bDQQgARCiAgsgA0EIahD2AgwFCyAARQ0AIABBCGsiACAAKAIAQQFrIgE2AgAgAQ0EIAAQ5AYMBAsQjgoAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBjNrAAEE/EI8KAAsgA0HwAGokAAuIAgECfyMAQdAAayIDJAACQAJAAkACQAJAIAFFBEAgAEUNASAAQQhrIgEoAgBBAUcNBCADQQhqIABBBGpByAD8CgAAIAFBADYCAAJAIAFBf0YNACAAQQRrIgIgAigCAEEBayICNgIAIAINACAAQQxrKAIAIgBBeHEiAkHYAEHcACAAQQNxIgAbSQ0DIABBACACQfwATxsNBCABEKICCyADQQhqEPUCDAULIABFDQAgAEEIayIAIAAoAgBBAWsiATYCACABDQQgABDjBgwECxCOCgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0GM2sAAQT8QjwoACyADQdAAaiQAC+cBAQN/IwBBEGsiAyQAIAMgACgCACIANgIEAn8CQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BIANBBGogARCLBQwCC0EJIQIDQCACIANqQQZqIABBD3EtANy2RToAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQYS0xQBBAiACIANqQQdqQQkgAmsQyAMMAQtBCSECA0AgAiADakEGaiAAQQ9xLQDJgUI6AAAgAkEBayECIABBD0sgAEEEdiEADQALIAFBAUGEtMUAQQIgAiADakEHakEJIAJrEMgDCyADQRBqJAALgwICA34EfyAAKAIMRQRAQQAPCyAAKQMQIAApAxggASACEJUEIQMgACgCBCIHIAOncSEGIANCGYhC/wCDQoGChIiQoMCAAX4hBSAAKAIAIQgDQAJAIAYgCGopAAAiBCAFhSIDQn+FIANCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiA1BFBEADQCAIIAN6p0EDdiAGaiAHcUFsbGoiAEEMaygCACACRgRAIAEgAEEQaygCACACENsHRQ0DCyADQgF9IAODIgNQRQ0ACwtBACEAIAQgBEIBhoNCgIGChIiQoMCAf4NQRQ0AIAYgCUEIaiIJaiAHcSEGDAELCyAAQRRrQQAgABsL5gEBA38jAEEQayIDJAACfwJAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxDQEgACABEIsFDAILIAAoAgAhAEEJIQIDQCACIANqQQZqIABBD3EtANy2RToAACACQQFrIQIgAEEPSyAAQQR2IQANAAsgAUEBQYS0xQBBAiACIANqQQdqQQkgAmsQyAMMAQsgACgCACEAQQkhAgNAIAIgA2pBBmogAEEPcS0AyYFCOgAAIAJBAWshAiAAQQ9LIABBBHYhAA0ACyABQQFBhLTFAEECIAIgA2pBB2pBCSACaxDIAwsgA0EQaiQAC7QCAQN/IwBBEGsiAiQAAkACQAJAAkAgACgCACIAKAIAQQFrDgIBAgALIAIgAEEIajYCBCABKAIAQfHExABBDyABKAIEKAIMEQAAIQMgAkEAOgANIAIgAzoADCACIAE2AgggAkEIakGQr8cAQQggAEEEakGgwMQAEIwFQYDFxABBBiACQQRqQeS2xAAQjAUgAi0ADSIDIAItAAwiBHIhASAEQQFxIANBAUdyDQIoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAMLIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQwCCyABKAIAQYbFxABBFSABKAIEKAIMEQAAIQEMAQsgASgCAEGbxcQAQRUgASgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQukAgEFfyMAQSBrIgIkAEEBIQMCQCAAKAIAQQFGBEAgASgCACIEQcOYyABBBCABKAIEIgYoAgwiBREAAA0BIABBBGohAAJAIAEtAApBgAFxRQRAIARBu7PFAEEBIAURAAANAyAAIAEQugUNAyABKAIAIQQgASgCBCgCDCEFDAELIARB24HCAEECIAURAAANAiACQQE6AA8gAiAGNgIEIAIgBDYCACACQeCBwgA2AhQgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgACACQRBqELoFDQIgAigCEEHZgcIAQQIgAigCFCgCDBEAAA0CCyAEQd6OyABBASAFEQAAIQMMAQsgASgCAEG/mMgAQQQgASgCBCgCDBEAACEDCyACQSBqJAAgAwvmAQEDfyMAQRBrIgMkAAJ/AkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENASAAIAEQ9QQMAgsgACgCACEAQQkhAgNAIAIgA2pBBmogAEEPcS0A3LZFOgAAIAJBAWshAiAAQQ9LIABBBHYhAA0ACyABQQFBhLTFAEECIAIgA2pBB2pBCSACaxDIAwwBCyAAKAIAIQBBCSECA0AgAiADakEGaiAAQQ9xLQDJgUI6AAAgAkEBayECIABBD0sgAEEEdiEADQALIAFBAUGEtMUAQQIgAiADakEHakEJIAJrEMgDCyADQRBqJAAL4gECBH8EfiABKAIEIgOtIQYCQAJAIANC/////w8gASkDCCIHIAdC/////w9aG6drIgRBACADIARPG0EDTwRAIAEoAgAgByAGIAYgB1Ybp2oiAi0AAUEIdCEDIAItAAJBEHQhBCACLQAAIQVBBCECDAELQaiQyAApAwAiCUIIiCEIIAmnIQJBACEDQQAhBCAJQv8Bg0IEUg0BCyAHQgN8IQYLIAEgBjcDCCACQf8BcUEERwRAIAAgAq1C/wGDIAhCCIaENwIEIABBADoAAA8LIAAgAyAFciAEcjYCBCAAQR06AAAL8QECAX4CfyMAQRBrIgMkACAAKAIAIQACfwJAIAEoAggiBEGAgIAQcUUEQCAEQYCAgCBxDQEgACABEIUFDAILIAApAwAhAkERIQADQCAAIANqQQJrIAKnQQ9xLQDctkU6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUGEtMUAQQIgACADakEBa0ERIABrEMgDDAELIAApAwAhAkERIQADQCAAIANqQQJrIAKnQQ9xLQDJgUI6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUGEtMUAQQIgACADakEBa0ERIABrEMgDCyADQRBqJAALggIBBH8CQAJAAkACQCAAKAIIIgFBgICAgHhyQYCAgIB4RwRAIAAoAgwiAkEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgAWpJDQEgA0EAIAQgAUEnaksbDQIgAhCiAgsCQCAAKAJcIgFFDQAgAUEYbCICIAFqQSFqIgFFDQAgACgCWCACayIAQRxrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNAyACQQAgAyABQSdqSxsNBCAAQRhrEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuCAgEEfyMAQYAgayIEJAACQAJAAkACQAJAQYCJ+gAgASABQYCJ+gBPGyICIAEgAUEBdmsiAyACIANLGyICQYEITwRAIANB/////wNLDQJBMCACIAJBME0bIgVBAnQiA0H9////B08NAiADEHEiAkUNAyAAIAEgAiAFIAFBwQBJEN0BIAJBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIANqSQ0EIABBACABIANBJ2pLGw0FIAIQogIMAQsgACABIARBgAggAUHBAEkQ3QELIARBgCBqJAAPC0HYlcEAEP8HCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+gBAQR/IAAgASACEOkEAkACQAJAIAIEQCAAKAJ4IQEgACgCfCEIQQEhBQNAIAdBA2ogCE8NAiAFQQFrIgYgBE8EQCAGIQUMBQsgBCAGayIGQQAgBCAGTxsiBkEBRg0EIAZBAkYNAyABIAMqAgA4AgAgAUEIaiADQQhqKAIANgIAIAFBBGogA0EEaioCADgCACABQRBqIQEgB0EEaiEHIAVBA2ohBSADQQxqIQMgAkEBayICDQALCyAAQQE6AMABDwsgByAHQQRqIAhBmLPBABDqBwALIAVBAWohBQsgBSAEQaizwQAQjAcAC/oBAQR/IAAoAgQhAwJAAkACQAJAIAAtAAAiAEEETSAAQQNHcUUEQCADKAIAIQAgA0EEaigCACIBKAIAIgIEQCAAIAIRAwALIAEoAgQiAQRAIABBBGsoAgAiAkF4cSIEQQRBCCACQQNxIgIbIAFqSQ0CIAJBACAEIAFBJ2pLGw0DIAAQogILIANBBGsoAgAiAEF4cSIBQRBBFCAAQQNxIgAbSQ0DIABBACABQTRPGw0EIAMQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+oBAgF+An8jAEEQayIDJAACfwJAIAEoAggiBEGAgIAQcUUEQCAEQYCAgCBxDQEgACABEIUFDAILIAApAwAhAkERIQADQCAAIANqQQJrIAKnQQ9xLQDctkU6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUGEtMUAQQIgACADakEBa0ERIABrEMgDDAELIAApAwAhAkERIQADQCAAIANqQQJrIAKnQQ9xLQDJgUI6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUGEtMUAQQIgACADakEBa0ERIABrEMgDCyADQRBqJAAL+wEBBH8CQAJAAkACQAJAIAAtAABBJEcNACAALQAEQQNHDQAgACgCCCIAKAIAIQEgAEEEaigCACICKAIAIgMEQCABIAMRAwALIAIoAgQiAgRAIAFBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAJqSQ0CIANBACAEIAJBJ2pLGw0DIAEQogILIABBBGsoAgAiAUF4cSICQRBBFCABQQNxIgEbSQ0DIAFBACACQTRPGw0EIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4cCAgJ/An0CQAJAIAC8IgFBgICABE4EQCABQf////sHSw0BQYF/IQJDAAAAACEAIAFBgICA/ANGDQEMAgsgAEMAAAAAWwRAQwAAgL8gACAAlJUPCyABQQBOBEAgAEMAAABMlLwhAUHofiECDAILIAAgAJNDAAAAAJUhAAsgAA8LIAFBjfarAmoiAUEXdiACarIiA0OAcTE/lCABQf///wNxQfOJ1PkDar5DAACAv5IiACADQ9H3FzeUIAAgAEMAAABAkpUiAyAAIABDAAAAP5SUIgQgAyADlCIAIAAgAJQiAEPu6ZE+lEOqqio/kpQgACAAQyaeeD6UQxPOzD6SlJKSlJIgBJOSkguBAgIEfwF+IwBBMGsiASQAIAApAhAhBSAAKAIMIQIgACgCCCEEIAAoAgAhAwJAAkACQAJAAkACQAJAAkAgACgCBCIADgIAAQILIAINAUEBIQNBACEAQQEhAgwDCyACRQ0BCyABIAU3AiggASACNgIkIAEgBDYCICABIAA2AhwgASADNgIYIAFBDGogAUEYahDsAwwCCyADKAIEIgBBAEgNAiADKAIAIQMgAEUEQEEBIQJBACEADAELIAAQcSICRQ0DCyAABEAgAiADIAD8CgAACyABIAA2AhQgASACNgIQIAEgADYCDAsgAUEMahC6ASABQTBqJAAPC0HYmsgAEP8HCwAL4wEBCH8gASgCCCICIAEoAgQiAyACIANLGyEIIAEoAgAhBSACIQYCQAJAA0AgCCAGIgRGDQEgASAEQQFqIgY2AgggBCAFai0AACIHQeEAayEJIAdBMGtB/wFxQQpJIAlB/wFxQQZJcg0ACyAHQd8ARw0AAkAgAgRAIAIgA08EQCACIANHDQIgAyAETw0EDAILIAIgBWosAABBQEggAyAESXINAQwDCyADIARPDQILIAUgAyACIARBqLLFABC7CQALIABBADYCACAAQQA6AAQPCyAAIAQgAms2AgQgACACIAVqNgIAC/cBAQR/IABBBGoQ6gICQAJAAkACQCAALQAcQQNGBEAgACgCICIAKAIAIQEgAEEEaigCACICKAIAIgMEQCABIAMRAwALIAIoAgQiAgRAIAFBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAJqSQ0CIANBACAEIAJBJ2pLGw0DIAEQogILIABBBGsoAgAiAUF4cSICQRBBFCABQQNxIgEbSQ0DIAFBACACQTRPGw0EIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4QCAAJ/AkACQAJAIAJBBWsOBAACAgECCwJAAkACQCABLQAAQeIAaw4FAAQEBAEECyABLQABQeEARg0BDAMLIAEtAAFB6QBHDQIgAS0AAkHsAEcNAiABLQADQeUARw0CIAEtAARB8wBHDQJBAAwDCyABLQACQe4ARw0BIAEtAANB5ABHDQEgAS0ABEHzAEcNAUECDAILIAEtAABB4wBHDQAgAS0AAUHvAEcNACABLQACQeQARw0AIAEtAANB5QBHDQAgAS0ABEHiAEcNACABLQAFQe8ARw0AIAEtAAZB7wBHDQAgAS0AB0HrAEcNAEEBDAELQQMLIQEgAEEAOgAAIAAgAToAAQvxAQEEfyMAQTBrIgIkACACQRhqIgMgACgCACUBECkgAiACQQxqrUKAgICAsAWENwMAIAIgAigCHCIANgIUIAIgAigCGDYCECACIAA2AgwgASgCACABKAIEIAJCATcCJCACQQI2AhwgAkHgjsgANgIYIAIgAjYCICADEMEDIQECQAJAIAIoAgwiAARAIAIoAhAiA0EEaygCACIEQXhxIgVBBEEIIARBA3EiBBsgAGpJDQEgBEEAIAUgAEEnaksbDQIgAxCiAgsgAkEwaiQAIAEPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuJAgEDfwJAAkACQAJAAkAgASkCAEL117zJyMzWszqFIAEpAghC/tvLm/Plucb1AIWEUEUEQCAAQQRqEOoCIAAoAhwiAUUNASAAKAIgIgJBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAFqSQ0CIANBACAEIAFBJ2pLGw0DIAIQogIMAQsgAEEEahDqAiAAQShqEOMECyAAQQRrKAIAIgFBeHEiAkE4QTwgAUEDcSIBG0kNAiABQQAgAkHcAE8bDQMgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuOAgEDfwJAAkACQAJAIAEpAgBC7bqtts2F1PXjAIUgASkCCEL4gpm9le7Gxbl/hYRQRQRAIAAoAiQhAiAAQQRqEOoCIABBBGsoAgAiA0F4cUEsQTAgA0EDcSIEG0kNASAEQQAgA0HQAE8bDQIgABCiAiACIAEgAigCACgCFBEBAA8LIABBBGoQ6gIgACgCJCIBIAEoAgAoAgARAwAgAEEEaygCACIBQXhxQSxBMCABQQNxIgIbSQ0CIAJBACABQdAATxsNAyAAEKICDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+8BAQR/AkACQAJAAkAgAC0AAEEDRgRAIAAoAgQiACgCACEBIABBBGooAgAiAigCACIDBEAgASADEQMACyACKAIEIgIEQCABQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyACakkNAiADQQAgBCACQSdqSxsNAyABEKICCyAAQQRrKAIAIgFBeHEiAkEQQRQgAUEDcSIBG0kNAyABQQAgAkE0TxsNBCAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvPAgIGfwF+AkACQCAAKAIIIgEgACgCBCICRg0AIAEgAk8NASAAKAIAIgQgAWotAAAiA0EiRiADQdwARnIgA0EfTXINACAEIAFBAWoiBWohA0EAIAIgBWtBeHEiBmshAgNAIAMhASACRQRAIAAgBSAGajYCCAJAIAAoAggiASAAKAIEIgJPDQAgACgCACEEA0AgASAEai0AACIDQSJGIANB3ABGciADQSBJcg0BIAAgAUEBaiIBNgIIIAEgAkcNAAsLDwsgAkEIaiECIAFBCGohAyABKQAAIgdCf4UgB0LcuPHixYuXrtwAhUKBgoSIkKDAgAF9IAdCosSIkaLEiJEihUKBgoSIkKDAgAF9IAdCoMCAgYKEiJAgfYSEg0KAgYKEiJCgwIB/gyIHUA0ACyAAIAEgBGsgB3qnQQN2ajYCCAsPCyABIAJBiJzGABCMBwAL6wEBA38jAEFAaiIDJAAgAyACNgIEIAMgATYCACADIAOtQoCAgIAwhDcDECADIACtQoCAgICwDoQ3AwggA0ICNwI0IANBAjYCLCADQaimxgA2AiggAyADQQhqNgIwIANBHGogA0EoahDsAyADKAIcIQAgAygCICIBIAMoAiQQ6wghAgJAAkAgAARAIAFBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIABqSQ0BIARBACAFIABBJ2pLGw0CIAEQogILIANBQGskACACDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALiAIBA38jAEEQayICJAACQCAAKAIAIgAoAgAEQCACIABBCGo2AgQgASgCAEHw1cQAQQogASgCBCgCDBEAACEDIAJBADoADSACIAM6AAwgAiABNgIIIAJBCGpByKrHAEEGIABB4NXEABCMBUH61cQAQQ4gAkEEakGAwsQAEIwFIAItAA0iAyACLQAMIgRyIQEgBEEBcSADQQFHcg0BKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAQwCCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQEMAQsgASgCAEGeqscAQRAgASgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQvrAQEEfwJAAkACQAJAIABBDGooAgAiAQRAIABBEGooAgAiAkEEaygCACIDQXhxIgQgAUEEdCIBQQRBCCADQQNxIgMbckkNASADQQAgBCABQSdqSxsNAiACEKICCwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEEaygCACIBQXhxQRxBICABQQNxIgIbSQ0DIAJBACABQcAATxsNBCAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAv/AQEBfyMAQTBrIgIkAAJAIAApAwBC////////////AINCgICAgICAgPj/AFoEQCACIACtQoCAgIDwAoQ3AxAgASgCACABKAIEIAJCATcCJCACQQE2AhwgAkGg+McANgIYIAIgAkEQajYCICACQRhqEMEDIQAMAQsgAkEAOgAMIAIgATYCCCACIACtQoCAgIDwAoQ3AxAgAkIBNwIkQQEhACACQQE2AhwgAkGg+McANgIYIAIgAkEQajYCICACQQhqQcSSxgAgAkEYahDBAw0AIAItAAxFBEAgASgCAEG/ksYAQQIgASgCBCgCDBEAAA0BC0EAIQALIAJBMGokACAAC+sBAQR/AkACQAJAAkAgASgCKEECRwRAAkAgASgCpAJBgYCAgHhGDQAgASgCrAIiAkEASA0CIAIEQCABKAKoAiEDIAIQcSIBRQ0EIAIEQCABIAMgAvwKAAALIAEgAhCWASABQQRrKAIAIgRBeHEiBUEEQQggBEEDcSIEGyACakkNBSAEQQAgBSACQSdqSxsNBiABEKICQf8BcSICQQhHDQELQQAhAgsgAEEGNgIAIAAgAjoABA8LQayYxwAQ3QkAC0HYmsgAEP8HCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+cBAQF/IwBBEGsiBiQAAkACQAJAIAEEQCAGQQRqIAEgAyAEIAUgAigCEBEHACAGKAIIIQECQCAGKAIEIgMgBigCDCICTQ0AIANBAnQhAyACRQRAIAFBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIANqSQ0DIARBACAFIANBJ2pLGw0EIAEQogJBBCEBDAELIAEgA0EEIAJBAnQQuwIiAUUNBAsgACACNgIEIAAgATYCACAGQRBqJAAPC0Gt+cQAQTIQjwoAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHCwAL6AEBBH8jAEEQayICQQhqQQA6AAAgAkEAOwEGIAIgAUEUdi0A3LZFOgAJIAIgAUEEdkEPcS0A3LZFOgANIAIgAUEIdkEPcS0A3LZFOgAMIAIgAUEMdkEPcS0A3LZFOgALIAIgAUEQdkEPcS0A3LZFOgAKIAFBAXJnQQJ2IgMgAkEGaiIFaiIEQfsAOgAAIARBAWtB9QA6AAAgBSADQQJrIgNqQdwAOgAAIAJBDmoiBCABQQ9xLQDctkU6AAAgAEEKOgALIAAgAzoACiAAIAIpAQY3AAAgAkH9ADoADyAAQQhqIAQvAQA7AAAL5AECA38BfiMAQSBrIgIkACACQQg6ABsgAkEIaiABIAJBG2ogASgCgAEQ5AQCQCAAAn8gAi0ACCIDQR1HBEAgAikCDCEFIANFBEAgACAFNwIEQQUMAgsgAigCFCEEQRAQcSIBRQ0CIAEgAzoAACABIAQ2AgwgASAFNwIEIABB7LvEADYCGCAAIAE2AhQgAEGABjsBBCABIAJBCGpBAXIiAy8AADsAASABQQNqIANBAmotAAA6AABBAAwBCyAAIAIpAgw3AgQgAEEMaiACQRRqKAIANgIAQQYLNgIAIAJBIGokAA8LAAvkAQIDfwF+IwBBIGsiAiQAIAJBCjoAGyACQQhqIAEgAkEbaiABKAKAARDkBAJAIAACfyACLQAIIgNBHUcEQCACKQIMIQUgA0UEQCAAIAU3AgRBBQwCCyACKAIUIQRBEBBxIgFFDQIgASADOgAAIAEgBDYCDCABIAU3AgQgAEHsu8QANgIYIAAgATYCFCAAQYAGOwEEIAEgAkEIakEBciIDLwAAOwABIAFBA2ogA0ECai0AADoAAEEADAELIAAgAikCDDcCBCAAQQxqIAJBFGooAgA2AgBBBgs2AgAgAkEgaiQADwsAC4gCAAJ/AkACQAJAIAJBBGsOAgEAAgsCQCABLQAAQeYAayICBEAgAkENRgRADAIFDAQLAAsgAS0AAUHpAEcNAiABLQACQewARw0CIAEtAANB5QBHDQIgAS0ABEHzAEcNAkEADAMLIAEtAAFB6ABHDQEgAS0AAkHhAEcNASABLQADQfAARw0BIAEtAARB5QBHDQFBAwwCCyABLQAAQe0ARw0AAkACQAJAIAEtAAFB4QBrDgkAAwMDAwMDAwEDCyABLQACQfgARg0BDAILIAEtAAJB7gBHDQEgAS0AA0HzAEcNAUEBDAILIAEtAANB8wBHDQBBAgwBC0EECyEBIABBADoAACAAIAE6AAEL0QEBA38jAEEQayICJAAgAkEANgIMIAAgAkEMagJ/IAFBgAFPBEAgAUE/cUGAf3IhAyABQQZ2IQAgAUGAEEkEQCACIAM6AA0gAiAAQcABcjoADEECDAILIAFBDHYhBCAAQT9xQYB/ciEAIAFB//8DTQRAIAIgAzoADiACIAA6AA0gAiAEQeABcjoADEEDDAILIAIgAzoADyACIAA6AA4gAiAEQT9xQYB/cjoADSACIAFBEnZBcHI6AAxBBAwBCyACIAE6AAxBAQsQ6wEgAkEQaiQAC9EBAQN/IwBBEGsiAiQAIAJBADYCDCAAIAJBDGoCfyABQYABTwRAIAFBP3FBgH9yIQMgAUEGdiEAIAFBgBBJBEAgAiADOgANIAIgAEHAAXI6AAxBAgwCCyABQQx2IQQgAEE/cUGAf3IhACABQf//A00EQCACIAM6AA4gAiAAOgANIAIgBEHgAXI6AAxBAwwCCyACIAM6AA8gAiAAOgAOIAIgBEE/cUGAf3I6AA0gAiABQRJ2QXByOgAMQQQMAQsgAiABOgAMQQELENUCIAJBEGokAAvlAQECfyMAQRBrIgUkAAJAAkACQCABBEAgBUEEaiABIAMgBCACKAIQEQYAIAUoAgghAQJAIAUoAgQiAyAFKAIMIgJNDQAgA0ECdCEDIAJFBEAgAUEEaygCACIEQXhxIgZBBEEIIARBA3EiBBsgA2pJDQMgBEEAIAYgA0EnaksbDQQgARCiAkEEIQEMAQsgASADQQQgAkECdBC7AiIBRQ0ECyAAIAI2AgQgACABNgIAIAVBEGokAA8LQa35xABBMhCPCgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcLAAvkAQEEfwJAAkACQAJAIAAoAggiAQRAIAAoAgwiAkEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgAWpJDQEgA0EAIAQgAUEnaksbDQIgAhCiAgsCQCAAQX9GDQAgACAAKAIEIgFBAWs2AgQgAUEBRw0AIABBBGsoAgAiAUF4cSICQRhBHCABQQNxIgEbSQ0DIAFBACACQTxPGw0EIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+gBAQR/IwBBMGsiAiQAIAJBKGoiAyABQUBrKQMANwMAIAJBGGoiBSABQTBq/QADAP0LAwAgAiAB/QADIP0LAwgCQAJAQSgQcSIEBEAgBCAC/QADCP0LAwAgBEEgaiADKQMANwMAIARBEGogBf0AAwD9CwMAIAFBBGoQ6gIgAUEEaygCACIDQXhxQcwAQdAAIANBA3EiBRtJDQEgBUEAIANB8ABPGw0CIAEQogIgAEHsr8cANgIEIAAgBDYCACACQTBqJAAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC94BAQR/AkACQAJAAkAgACgCACIBBEAgACgCBCICQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyABakkNASADQQAgBCABQSdqSxsNAiACEKICCyAAKAIMIgEEQCAAKAIQIgBBBGsoAgAiAkF4cSIDIAFBAnQiAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgAUEnaksbDQQgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwAL5wEBBH8CQAJAAkACQCAAKAIAIgEEQCAAKAIEIgJBBGsoAgAiA0F4cSIEQQRBCCADQQNxIgMbIAFqSQ0BIANBACAEIAFBJ2pLGw0CIAIQogILIAAoAgwiAUGAgICAeHJBgICAgHhHBEAgACgCECIAQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABakkNAyACQQAgAyABQSdqSxsNBCAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvQAQEDfwJAAkACQCACIAMgBGsiBUsEQCACIANNDQEgAyAEQQF0ayIGIAJPDQIgAyAEaiIHIAJPDQMgASAFai0AACABIANqLQAAayIFIAVBH3UiBXMgBWtBAXRB/gNxIAEgBmotAAAgASAHai0AAGsiBSAFQR91IgVzIAVrQQF2aiAAQf8BcU0EQEEBIAEgAiADIAQQ6AQaCw8LIAUgAkGI18QAEIwHAAsgAyACQZjXxAAQjAcACyAGIAJBqNfEABCMBwALIAcgAkG418QAEIwHAAvGAQEDfyABQf8AQYB/QfwAQYB/IAAEf0H/AEGAfyABLQACIAEtAAVrIgAgAEGAf0wbIgAgAEH/AE4bBSADCyABLQAEIgQgAS0AAyICa0EDbGoiACAAQYB/TBsiACAAQfwAThtBA2pBA3UgAmpBgAFrIgIgAkGAf0wbIgIgAkH/AE4bQYABczoAAyABQf8AQYB/IARB+wAgACAAQfsAThtBBGpBA3UiAGtBgAFrIgEgAUGAf0wbIgEgAUH/AE4bQYABczoABCAAC+8BAQR/IwBBIGsiACQAQaL5xwAhA0EJIQQCQAJAIAIoAgANACAAQRBqIAIoAgQgAigCCBD7AkGi+ccAIAAoAhQgACgCECICGyEDIAINACAAKAIYIgQNACABQQFBABCXAyECDAELIAAgBDYCDCAAIAM2AgggASgCBCEDIAEoAgAhBANAAkAgAEEQaiAAQQhqEO0DIAAoAhAiBUUNACAAKAIUIQYgACgCHEUEQCABIAUgBhCXAyECDAMLQQEhAiAEIAUgBiADKAIMEQAADQIgBEH9/wMgAygCEBECAEUNAQwCCwtBACECCyAAQSBqJAAgAgvSAQEBfyMAQSBrIgUkACAFQQhqIAMgAyAEQQJ0ahCZAwJAAkAgASACSwRAIAAgAkEYbGoiACgCFCIBQQVPBEAgACgCCCICQQRrKAIAIgNBeHEiBCABQQJ0IgFBBEEIIANBA3EiAxtqSQ0CIANBACAEIAFBJ2pLGw0DIAIQogILIAAgBf0AAgj9CwIAIABBEGogBUEYaikCADcCACAFQSBqJAAPCyACIAFBtMDHABCMBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9kBAQR/AkACQAJAAkAgACgCDCIBBEAgACgCECICQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyABakkNASADQQAgBCABQSdqSxsNAiACEKICCyAAKAIYIgEEQCAAKAIcIgBBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0DIAJBACADIAFBJ2pLGw0EIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9kBAQR/AkACQAJAAkAgACgCACIBBEAgACgCBCICQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyABakkNASADQQAgBCABQSdqSxsNAiACEKICCyAAKAIMIgEEQCAAKAIQIgBBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0DIAJBACADIAFBJ2pLGw0EIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC+8BAQN/IwBBEGsiAiQAAkAgACgCAARAIAIgADYCBCABKAIAQcCqxwBBCCABKAIEKAIMEQAAIQAgAkEAOgANIAIgADoADCACIAE2AgggAkEIakHIqscAQQYgAkEEakHolsEAEIwFIAItAA0iAyACLQAMIgRyIQEgBEEBcSADQQFHcg0BKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAQwCCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQEMAQsgASgCAEGeqscAQRAgASgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQvvAQEDfyMAQRBrIgIkAAJAIAAoAgAEQCACIAA2AgQgASgCAEHAqscAQQggASgCBCgCDBEAACEAIAJBADoADSACIAA6AAwgAiABNgIIIAJBCGpByKrHAEEGIAJBBGpBsKrHABCMBSACLQANIgMgAi0ADCIEciEBIARBAXEgA0EBR3INASgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAgsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBDAELIAEoAgBBnqrHAEEQIAEoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXEL+AEBA38jAEEQayICJAAgAiAANgIEIAEoAgBB7aXHAEEGIAEoAgQoAgwRAAAhAyACQQA6AA0gAiADOgAMIAIgATYCCCACQQhqQbimxwBBDyAAQRBqQZimxwAQjAVBx6bHAEEQIABBGGpBmKbHABCMBUHXpscAQQkgAkEEakGopscAEIwFIQEgAi0ADSIDIAItAAwiBHIhAAJAIARBAXEgA0EBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAwBCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQALIAJBEGokACAAQQFxC8wBAQF/IwBBQGoiAiQAIAJBBGogARCfAwJAIAItAARBAUYEQCAAIAIoAgg2AgQgAEEENgIADAELIAItAAVFBEAgAEEDNgIADAELIAJBBGogASgCABCDASACKAIEQQNGBEAgACACKAIINgIEIABBBDYCAAwBCyAAIAL9AAIE/QsCACAAQThqIAJBPGooAgA2AgAgAEEwaiACQTRqKQIANwIAIABBIGogAkEkav0AAgD9CwIAIABBEGogAkEUav0AAgD9CwIACyACQUBrJAAL1wEBA38jAEEQayIDJAACQAJAAkACQCAAKAIMBEAgACEBDAELIANBCGogASgCDCABKAIQIAEoAhQQ+QEgAygCDCECIAMoAgghBEEUEHEiAUUNASABIAApAgA3AgAgAUEIaiAAQQhqKAIANgIAIAEgAjYCECABIAQ2AgwgAEEEaygCACICQXhxIgRBGEEcIAJBA3EiAhtJDQIgAkEAIARBPE8bDQMgABCiAgsgA0EQaiQAIAEPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC9gBAQJ/IwBBEGsiBSQAIAACfwJAIANBASAEGwRAIAEoAhQiAyABKAIQIgRPDQEgASgCDCEGA0AgAyAGai0AAEEwa0H/AXFBCk8NAiABIANBAWoiAzYCFCADIARHDQALDAELIAVBCGogASgCDCABKAIQIAEoAhQQ+QEgBSgCDCECIAUoAgghA0EUEHEiAQRAIAEgAzYCDCABQQ42AgAgACABNgIEIAEgAjYCEEEBDAILAAsgAEQAAAAAAAAAAEQAAAAAAAAAgCACGzkDCEEACzYCACAFQRBqJAAL1QEBBH8gAEEEahDqAgJAAkACQAJAIAAoAhwiAQRAIAAoAiAiAkEEaygCACIDQXhxIgRBBEEIIANBA3EiAxsgAWpJDQEgA0EAIAQgAUEnaksbDQIgAhCiAgsgAEEoahDjBCAAQQRrKAIAIgFBeHEiAkE4QTwgAUEDcSIBG0kNAiABQQAgAkHcAE8bDQMgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAvtAQECfyMAQRBrIgkkACAAKAIAQYipxwBBBCAAKAIEKAIMEQAAIQogCUEAOgANIAkgCjoADCAJIAA2AgggCUEIakGMqccAQQkgASACEIwFQZWpxwBBCCADIAQQjAVBnanHAEEGIAUgBhCMBUGjqccAQQogByAIEIwFIQEgCS0ADSICIAktAAwiA3IhAAJAIANBAXEgAkEBR3INACABKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAAwBCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQALIAlBEGokACAAQQFxC7wBAQN/IwBBIGsiAyQAAkACf0EAIAIgASACaiIESw0AGkEAQQggBCAAKAIAIgJBAXQiASABIARJGyIEIARBCE0bIgRBAEgNABpBACEBIAMgAgR/IAMgAjYCHCADIAAoAgQ2AhRBAQUgAQs2AhggA0EIakEBIAQgA0EUahCFByADKAIIQQFHDQEgAygCECEFIAMoAgwLIAVBnJbIABCTCQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAvpAQEDfyMAQRBrIgIkACACIAAoAgAiADYCBCABKAIAQeynxwBBBiABKAIEKAIMEQAAIQMgAkEAOgANIAIgAzoADCACIAE2AgggAkEIakHyp8cAQQQgAEEEakG0lsEAEIwFQfanxwBBBSACQQRqQcSWwQAQjAUhACACLQANIgMgAi0ADCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXELxwEBAX8jAEEwayICJAACfyAALQAEQQFGBEAgAiAALQAFOgAHIAJBAjYCHCACQfiKwwA2AhggAkICNwIkIAIgAK1CgICAgBCENwMQIAIgAkEHaq1CgICAgPAEhDcDCCACIAJBCGo2AiAgASgCACABKAIEIAJBGGoQwQMMAQsgAkEBNgIcIAJBtIvDADYCGCACQgE3AiQgAiAArUKAgICAEIQ3AwggAiACQQhqNgIgIAEoAgAgASgCBCACQRhqEMEDCyACQTBqJAAL5gEBBH8jAEEgayIAJABBASECAkAgASgCACIDQaiayABBDyABKAIEIgUoAgwiBBEAAA0AAkAgAS0ACkGAAXFFBEAgA0G7s8UAQQEgBBEAAA0CIAFBmJbIAEECEJcDRQ0BDAILIANB24HCAEECIAQRAAANASAAQQE6AA8gACAFNgIEIAAgAzYCACAAQeCBwgA2AhQgACABKQIINwIYIAAgAEEPajYCCCAAIAA2AhAgAEEQakGYlsgAQQIQlwMNASAAQdmBwgBBAhCvAw0BCyADQd6OyABBASAEEQAAIQILIABBIGokACACC+YBAQR/IwBBIGsiACQAQQEhAgJAIAEoAgAiA0HY8sQAQREgASgCBCIFKAIMIgQRAAANAAJAIAEtAApBgAFxRQRAIANBu7PFAEEBIAQRAAANAiABQZiWyABBAhCXA0UNAQwCCyADQduBwgBBAiAEEQAADQEgAEEBOgAPIAAgBTYCBCAAIAM2AgAgAEHggcIANgIUIAAgASkCCDcCGCAAIABBD2o2AgggACAANgIQIABBEGpBmJbIAEECEJcDDQEgAEHZgcIAQQIQrwMNAQsgA0HejsgAQQEgBBEAACECCyAAQSBqJAAgAgvpAQEDfyMAQRBrIgIkACACIAAoAgAiADYCBCABKAIAQeynxwBBBiABKAIEKAIMEQAAIQMgAkEAOgANIAIgAzoADCACIAE2AgggAkEIakHyp8cAQQQgAEEEakHMp8cAEIwFQfanxwBBBSACQQRqQdynxwAQjAUhACACLQANIgMgAi0ADCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXEL2AECBX8BfiMAQTBrIgIkACABKAIAQYCAgIB4RgRAIAEoAgwgAkEANgIUIAJCgICAgBA3AgwoAgAiAykCECEHIAMoAgwhBCADKAIIIQUgAygCACEGIAMoAgQhAyACIAc3AiggAiAENgIkIAIgBTYCICACIAM2AhwgAiAGNgIYIAJBDGpBzIXIACACQRhqEMEDGiACQQhqIAJBFGooAgAiAzYCACACIAIpAgwiBzcDACABQQhqIAM2AgAgASAHNwIACyAAQdyNyAA2AgQgACABNgIAIAJBMGokAAvpAQEDfyMAQRBrIgIkACACIAAoAgAiAEEEajYCBCABKAIAQeiXyABBCSABKAIEKAIMEQAAIQMgAkEAOgANIAIgAzoADCACIAE2AgggAkEIakHxl8gAQQsgAEHIl8gAEIwFQfyXyABBCSACQQRqQdiXyAAQjAUhACACLQANIgMgAi0ADCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXELugEBA38jAEEgayIDJAACQAJ/QQAgAiABIAJqIgRLDQAaQQBBCCAEIAAoAgAiAkEBdCIBIAEgBEkbIgQgBEEITRsiBEEASA0AGkEAIQEgAyACBH8gAyACNgIcIAMgACgCBDYCFEEBBSABCzYCGCADQQhqIAQgA0EUahDdByADKAIIQQFHDQEgAygCECEFIAMoAgwLIAVB/O7BABCTCQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAu6AQEDfyMAQSBrIgMkAAJAAn9BACACIAEgAmoiBEsNABpBAEEIIAQgACgCACICQQF0IgEgASAESRsiBCAEQQhNGyIEQQBIDQAaQQAhASADIAIEfyADIAI2AhwgAyAAKAIENgIUQQEFIAELNgIYIANBCGogBCADQRRqEN0HIAMoAghBAUcNASADKAIQIQUgAygCDAsgBUGclsgAEJMJAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC7wBAQV/IwBBIGsiAiQAIAAoAgAiBEH/////AEsEQEEAQQAgARCTCQALAkBBBCAEQQF0IgUgBUEETRsiBUEDdCIGQfz///8HTQR/IAIgBAR/IAIgBEEDdDYCHCACIAAoAgQ2AhRBBAUgAws2AhggAkEIakEEIAYgAkEUahCFByACKAIIQQFHDQEgAigCECEDIAIoAgwFIAMLIAMgARCTCQALIAIoAgwhASAAIAU2AgAgACABNgIEIAJBIGokAAu8AQEFfyMAQSBrIgIkACAAKAIAIgRB/////wFLBEBBAEEAIAEQkwkACwJAQQQgBEEBdCIFIAVBBE0bIgVBAnQiBkH8////B00EfyACIAQEfyACIARBAnQ2AhwgAiAAKAIENgIUQQQFIAMLNgIYIAJBCGpBBCAGIAJBFGoQhQcgAigCCEEBRw0BIAIoAhAhAyACKAIMBSADCyADIAEQkwkACyACKAIMIQEgACAFNgIAIAAgATYCBCACQSBqJAALuwEBBX8jAEEgayICJAAgACgCACIEQf///x9LBEBBAEEAIAEQkwkACwJAQQQgBEEBdCIFIAVBBE0bIgVBBXQiBkH4////B00EfyACIAQEfyACIARBBXQ2AhwgAiAAKAIENgIUQQgFIAMLNgIYIAJBCGpBCCAGIAJBFGoQhQcgAigCCEEBRw0BIAIoAhAhAyACKAIMBSADCyADIAEQkwkACyACKAIMIQEgACAFNgIAIAAgATYCBCACQSBqJAAL5AEBA38jAEEQayICJAAgAiAAQQRqNgIEIAEoAgBB6JfIAEEJIAEoAgQoAgwRAAAhAyACQQA6AA0gAiADOgAMIAIgATYCCCACQQhqQfGXyABBCyAAQbSWwQAQjAVB/JfIAEEJIAJBBGpB1JbBABCMBSEAIAItAA0iAyACLQAMIgRyIQECQCAEQQFxIANBAUdyDQAgACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQvkAQEDfyMAQRBrIgIkACABKAIAQef7xwBBBSABKAIEKAIMEQAAIQMgAkEAOgAJIAIgAzoACCACIAE2AgQgAiAANgIMIAJBBGpB7LXHAEEHIAJBDGpBiKDBABCMBUGEtscAQQYgAEEIakGYoMEAEIwFIQAgAi0ACSIDIAItAAgiBHIhAQJAIARBAXEgA0EBR3INACAAKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAQwBCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQELIAJBEGokACABQQFxC+QBAQN/IwBBEGsiAiQAIAEoAgBB5/vHAEEFIAEoAgQoAgwRAAAhAyACQQA6AAkgAiADOgAIIAIgATYCBCACIAA2AgwgAkEEakHstccAQQcgAkEMakGIoMEAEIwFQYS2xwBBBiAAQQhqQaigwQAQjAUhACACLQAJIgMgAi0ACCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXEL5AEBA38jAEEQayICJAAgAiAANgIEIAEoAgBB7KfHAEEGIAEoAgQoAgwRAAAhAyACQQA6AA0gAiADOgAMIAIgATYCCCACQQhqQfKnxwBBBCAAQQRqQaDAxAAQjAVB9qfHAEEFIAJBBGpBsMDEABCMBSEAIAItAA0iAyACLQAMIgRyIQECQCAEQQFxIANBAUdyDQAgACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQuvAQEEfyMAQRBrIgMkAEEDIQIgACgCACwAACIEIATAQQd1IgBzIABrIgBB/wFxIgVBCk8EQEEBIQIgAyAAQQF0IgAgAEE4aiAFQeQASRtB/gFxLwC4ukU7AA4gBUHjAEshAAtBACAEIABB/wFxIgAbRQRAIAJBAWsiAiADQQ1qaiAAQQF0LQC5ukU6AAALIAEgBEEATkEBQQAgA0ENaiACakEDIAJrEMgDIANBEGokAAvkAQEDfyMAQRBrIgIkACACIABBBGo2AgQgASgCAEHol8gAQQkgASgCBCgCDBEAACEDIAJBADoADSACIAM6AAwgAiABNgIIIAJBCGpB8ZfIAEELIABBmJzFABCMBUH8l8gAQQkgAkEEakGonMUAEIwFIQAgAi0ADSIDIAItAAwiBHIhAQJAIARBAXEgA0EBR3INACAAKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAQwBCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQELIAJBEGokACABQQFxC8kBAgN/AX4jAEEQayIEJAACQCAAKAIQIgNFBEAMAQtBASECIANB+LTFAEEBEJcDDQAgAVAEQCADQZKyxQBBARCXAyECDAELAkAgASAANQIUIgVYBEAgBSABfSIBQhpUDQEgA0GSssUAQQEQlwMNAiAEIAE3AwggBEEIaiADEIUFIQIMAgsgA0HqssUAQRAQlwMNAUEAIQIgAEEAOgAEIABBADYCAAwBCyAEIAGnQeEAajYCBCAEQQRqIAMQqAUhAgsgBEEQaiQAIAILuwEBBX8jAEEgayICJAAgACgCACIEQf///x9LBEBBAEEAIAEQkwkACwJAQQQgBEEBdCIFIAVBBE0bIgVBBXQiBkH8////B00EfyACIAQEfyACIARBBXQ2AhwgAiAAKAIENgIUQQQFIAMLNgIYIAJBCGpBBCAGIAJBFGoQhQcgAigCCEEBRw0BIAIoAhAhAyACKAIMBSADCyADIAEQkwkACyACKAIMIQEgACAFNgIAIAAgATYCBCACQSBqJAAL5AEBA38jAEEQayICJAAgAiAAQRBqNgIEIAEoAgBBnKjHAEENIAEoAgQoAgwRAAAhAyACQQA6AA0gAiADOgAMIAIgATYCCCACQQhqQamoxwBBBiAAQfynxwAQjAVBr6jHAEEKIAJBBGpBjKjHABCMBSEAIAItAA0iAyACLQAMIgRyIQECQCAEQQFxIANBAUdyDQAgACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQvkAQEDfyMAQRBrIgIkACACIABBEGo2AgQgASgCAEG5qMcAQQ0gASgCBCgCDBEAACEDIAJBADoADSACIAM6AAwgAiABNgIIIAJBCGpBqajHAEEGIABB/KfHABCMBUGvqMcAQQogAkEEakGMqMcAEIwFIQAgAi0ADSIDIAItAAwiBHIhAQJAIARBAXEgA0EBR3INACAAKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAQwBCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQELIAJBEGokACABQQFxC+QBAQN/IwBBEGsiAiQAIAIgAEEMajYCBCABKAIAQZCqxwBBDiABKAIEKAIMEQAAIQMgAkEAOgANIAIgAzoADCACIAE2AgggAkEIakHI+8cAQQQgAEGAqscAEIwFQa+oxwBBCiACQQRqQYyoxwAQjAUhACACLQANIgMgAi0ADCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXEL5AEBA38jAEEQayICJAAgAiAAQRBqNgIEIAEoAgBBuKzHAEEQIAEoAgQoAgwRAAAhAyACQQA6AA0gAiADOgAMIAIgATYCCCACQQhqQamoxwBBBiAAQfynxwAQjAVByPvHAEEEIAJBBGpBqKzHABCMBSEAIAItAA0iAyACLQAMIgRyIQECQCAEQQFxIANBAUdyDQAgACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQvkAQEDfyMAQRBrIgIkACABKAIAQef7xwBBBSABKAIEKAIMEQAAIQMgAkEAOgAJIAIgAzoACCACIAE2AgQgAiAANgIMIAJBBGpB7LXHAEEHIAJBDGpB3LXHABCMBUGEtscAQQYgAEEMakH0tccAEIwFIQAgAi0ACSIDIAItAAgiBHIhAQJAIARBAXEgA0EBR3INACAAKAIAIgAtAApBgAFxRQRAIAAoAgBB/7PFAEECIAAoAgQoAgwRAAAhAQwBCyAAKAIAQaWzxQBBASAAKAIEKAIMEQAAIQELIAJBEGokACABQQFxC74BAgN/AX4jAEEQayIDJAAgACgCACEAAkAgASkCCCIFpyICQYCAgARxRQ0AIAJBgICAwABxBEAgAkGAgIAIciECDAELIAFBCjsBDCACQYCAgMgAciECCyABIAJBgICABHI2AghBCSECA0AgAiADakEGaiAAQQ9xLQDctkU6AAAgAkEBayECIABBEEkgAEEEdiEARQ0ACyABQQFBhLTFAEECIAIgA2pBB2pBCSACaxDIAyABIAU3AgggA0EQaiQAC+QBAQN/IwBBEGsiAiQAIAIgAEEMajYCBCABKAIAQaiYyABBDSABKAIEKAIMEQAAIQMgAkEAOgANIAIgAzoADCACIAE2AgggAkEIakG1mMgAQQUgAEGImMgAEIwFQbqYyABBBSACQQRqQZiYyAAQjAUhACACLQANIgMgAi0ADCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXELugEBBX8jAEEgayICJAAgACgCACIEQf////8BSwRAQQBBACABEJMJAAsCQEEEIARBAXQiBSAFQQRNGyIFQQJ0IgZB/P///wdNBH8gAiAEBH8gAiAEQQJ0NgIcIAIgACgCBDYCFEEEBSADCzYCGCACQQhqIAYgAkEUahCBByACKAIIQQFHDQEgAigCECEDIAIoAgwFIAMLIAMgARCTCQALIAIoAgwhASAAIAU2AgAgACABNgIEIAJBIGokAAvLAQEEfyAAQQRqEOoCAkACQAJAAkAgACgCHCIBBEAgACgCICICQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyABakkNASADQQAgBCABQSdqSxsNAiACEKICCyAAQQRrKAIAIgFBeHFBLEEwIAFBA3EiAhtJDQIgAkEAIAFB0ABPGw0DIAAQogIPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALrAEBBH8jAEEQayIDJABBAyECIAAsAAAiBCAEwEEHdSIAcyAAayIAQf8BcSIFQQpPBEBBASECIAMgAEEBdCIAIABBOGogBUHkAEkbQf4BcS8AuLpFOwAOIAVB4wBLIQALQQAgBCAAQf8BcSIAG0UEQCACQQFrIgIgA0ENamogAEEBdC0AubpFOgAACyABIARBAE5BAUEAIANBDWogAmpBAyACaxDIAyADQRBqJAAL1AEAAkACQCABBEAgACAELQAIOgAAIAFBAWsiAUEHTQRAQQBBCCABQcjjxAAQ6gcACyAAIAQtABE6AAEgACAELQAaOgACIAAgBC0AIzoAAyAAIAQtACw6AAQgACAELQA1OgAFIAAgBC0APjoABiAAIAQtAEc6AAcgACAELQBQOgAIIAMgBUEDdCIASQ0CIAMgAGsiAUEHSw0BQQBBCCABQdjjxAAQ6gcAC0EAQQBBuOPEABCMBwALIAAgAmogBCkASTcAAA8LIAAgAyADQejjxAAQ6gcAC9ABAgF/AX4jAEEwayICJAACfwJAAkACQCAAKAIAKAIAIgAoAgBBAWsOAgECAAsgAiAAKAIENgIAIAIgACgCCDYCBCACQoCAgIAQIgMgAkEEaq2ENwMQIAIgAyACrYQ3AwggASgCACABKAIEIAJCAjcCJCACQQI2AhwgAkHYnMUANgIYIAIgAkEIajYCICACQRhqEMEDDAILIAEoAgBB6JzFAEEdIAEoAgQoAgwRAAAMAQsgASgCAEGFncUAQTEgASgCBCgCDBEAAAsgAkEwaiQAC7cBAgN/BH4gASgCBCICrSEFAkACQCACQv////8PIAEpAwgiBiAGQv////8PWhunayIEQQAgAiAETxtBAk8EQCABKAIAIAYgBSAFIAZWG6dqLwAAIQNBBCECDAELQaiQyAApAwAiCEIIiCEHIAinIQIgCEL/AYNCBFINAQsgBkICfCEFCyABIAU3AwggAkH/AXFBBEcEQCAAIAKtQv8BgyAHQgiGhDcCAA8LIABBBDoAACAAIAM7AQILtwECBH4Ef0EEIQYgASgCBCIIrSECAkACQCAIQv////8PIAEpAwgiAyADQv////8PWhunayIJQQAgCCAJTxtBBE8EQCABKAIAIAMgAiACIANWG6dqKAAAIQcMAQtBqJDIACkDACIFQgiIIQQgBachBiAFQv8Bg0IEUg0BCyADQgR8IQILIAEgAjcDCCAGQf8BcUEERwRAIAAgBq1C/wGDIARCCIaENwIADwsgAEEEOgAAIAAgBzYCBAugCAMDfwF+AW8jAEEgayIFJABBlLvJAEGUu8kAKAIAIgZBAWo2AgACQCAGQQBIDQBBkLvJAC0AAEUEQEGQu8kAQQE6AABBjLvJAEGMu8kAKAIAQQFqNgIAQZi7yQAoAgAiBkEASA0BQZi7yQAgBkEBajYCAEGYu8kAQZy7yQAoAgAEfyAFQQhqIAAgASgCFBEBACAFIAQ6AB0gBSADOgAcIAUgAjYCGCAFIAUpAwg3AhAgBUEQaiEAIwBB0ABrIgIkACACQQA2AgwgAkKAgICAEDcCBAJAAkACQAJAAkAgAkEEaiIEQZiMyABBDBDiBw0AIAIgACgCCCIBKQIANwIQIAIgAUEMaq1CgICAgBCENwMoIAIgAUEIaq1CgICAgBCENwMgIAIgAkEQaq1CgICAgKABhDcDGCACQgM3AjwgAkEDNgI0IAJBpIzIADYCMCACIAJBGGo2AjggBEHU8cEAIAJBMGoiBBDBAw0AIAQgACgCACIBIAAoAgQoAgwiBREBACABIQACQCACKQMwQu26rbbNhdT14wCFIAIpAzhC+IKZvZXuxsW5f4WEUAR/QQQFIAQgACAFEQEAIAIpAzBC9de8ycjM1rM6hSACKQM4Qv7by5vz5bnG9QCFhEIAUg0BIABBBGohAEEICyABaigCACEBIAAoAgAhACACQQRqIgRByIXIAEECEOIHDQEgBCAAIAEQ4gcNAQsgAkE4aiACQQxqKAIAIgA2AgAgAiACKQIEIgg3AzAgCKciBiAAa0EJTQRAIAJBMGogAEEKEPgFIAIoAjAhBiACKAI4IQALIAIoAjQiBCAAaiIBQcjxwQApAAA3AAAgAUEIakHQ8cEALwAAOwAAIAIgAEEKaiIANgI4ECAhCRDaBCIBIAkmASACQRhqIAElARAhIAIoAhghByACKAIcIgUgBiAAa0sEQCACQTBqIAAgBRD4BSACKAIwIQYgAigCNCEEIAIoAjghAAsgBQRAIAAgBGogByAF/AoAAAsgAiAAIAVqIgA2AjggBiAAa0EBTQRAIAJBMGogAEECEPgFIAIoAjQhBCACKAI4IQALIAAgBGpBihQ7AAAgAiAAQQJqIgA2AjggACACKAIwIgZJBEAgBCAGQQEgABC7AiIERQ0CCyAEIAAQIiAFBEAgB0EEaygCACIAQXhxIgRBBEEIIABBA3EiABsgBWpJDQMgAEEAIAQgBUEnaksbDQQgBxCiAgsgAUGECE8EQCABEJsHCyACQdAAaiQADAQLQaCexgBBNyACQTBqQezxwQBB2J7GABDgBgsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBmLvJACgCAEEBawUgBgs2AgBBkLvJAEEAOgAAIANFDQEACyAFIAAgASgCGBEBAAsAC7YBAQZ/IwBBIGsiASQAAkACQCAAKAIAIgNB////H0sNAEEEIANBAXQiBCAEQQRNGyIEQQV0IgVB+P///wdLDQAgASADBH8gASADQQV0NgIcIAEgACgCBDYCFEEIBSACCzYCGCABQQhqQQggBSABQRRqEIUHIAEoAghBAUcNASABKAIQIQYgASgCDCECCyACIAZByOPBABCTCQALIAEoAgwhAiAAIAQ2AgAgACACNgIEIAFBIGokAAvFAQEEfyMAQSBrIgMkACADQRhqIgIgAUEsaikCADcDACADIAH9AAIc/QsDCAJAAkBBGBBxIgQEQCAEIAP9AAMI/QsCACAEQRBqIAIpAwA3AgAgAUEEahDqAiABQQRrKAIAIgJBeHEiBUE4QTwgAkEDcSICG0kNASACQQAgBUHcAE8bDQIgARCiAiAAQaCxxwA2AgQgACAENgIAIANBIGokAA8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALrgEBBX8jAEEgayIBJAACQCAAKAIAIgJBksmkEksEf0EABUEEIAJBAXQiAyADQQRNGyIEQRxsIQVBACEDIAEgAgR/IAEgAkEcbDYCHCABIAAoAgQ2AhRBBAUgAws2AhggAUEIakEEIAUgAUEUahCFByABKAIIQQFHDQEgASgCECEAIAEoAgwLIABB0OXBABCTCQALIAEoAgwhAiAAIAQ2AgAgACACNgIEIAFBIGokAAuwAQEFfwJAAkAgACgCBCICIAAoAgAiAUcEQCACIAFrIQIgAUEMbCAAakEMaiEAA0AgAEEEaygCACIBBEAgACgCACIEQQRrKAIAIgNBeHEiBSABQQJ0IgFBBEEIIANBA3EiAxtqSQ0DIANBACAFIAFBJ2pLGw0EIAQQogILIABBDGohACACQQFrIgINAAsLDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALwgEBBn8jAEEgayICJAACQAJAAkAgARC4CiIEQf////8DSw0AIARBAnQiA0H9////B08NAAJAIANFBEBBBCEDDAELIAQhBiADEHEiA0UNAgsgARC4CiEFIAEQuAohByACIAU2AgQgAiAHNgIAIAUgB0cNAiADIAUgARDhCSAAIAQ2AgggACADNgIEIAAgBjYCACACQSBqJAAPC0Hg+cQAEP8HCwALIAJBADYCCEEAIAIgAkEEaiACQQhqQeD5xAAQ9QcAC78BAQR/IwBBEGsiAiQAIAJBCGoiAyABQSRqKAIANgIAIAIgASkCHDcDAAJAAkBBDBBxIgQEQCAEIAIpAwA3AgAgBEEIaiADKAIANgIAIAFBBGoQ6gIgAUEEaygCACIDQXhxQSxBMCADQQNxIgUbSQ0BIAVBACADQdAATxsNAiABEKICIABB+JjBADYCBCAAIAQ2AgAgAkEQaiQADwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAu/AQEEfyMAQRBrIgIkACACQQhqIgMgAUEkaigCADYCACACIAEpAhw3AwACQAJAQQwQcSIEBEAgBCACKQMANwIAIARBCGogAygCADYCACABQQRqEOoCIAFBBGsoAgAiA0F4cUEsQTAgA0EDcSIFG0kNASAFQQAgA0HQAE8bDQIgARCiAiAAQbyYwQA2AgQgACAENgIAIAJBEGokAA8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALvwEBBH8jAEEQayICJAAgAkEIaiIDIAFBJGooAgA2AgAgAiABKQIcNwMAAkACQEEMEHEiBARAIAQgAikDADcCACAEQQhqIAMoAgA2AgAgAUEEahDqAiABQQRrKAIAIgNBeHFBLEEwIANBA3EiBRtJDQEgBUEAIANB0ABPGw0CIAEQogIgAEG0mcEANgIEIAAgBDYCACACQRBqJAAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC78BAQR/IwBBEGsiAiQAIAJBCGoiAyABQSRqKAIANgIAIAIgASkCHDcDAAJAAkBBDBBxIgQEQCAEIAIpAwA3AgAgBEEIaiADKAIANgIAIAFBBGoQ6gIgAUEEaygCACIDQXhxQSxBMCADQQNxIgUbSQ0BIAVBACADQdAATxsNAiABEKICIABBrJrBADYCBCAAIAQ2AgAgAkEQaiQADwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuvAQEDfyAAAn8CQAJAIAIgBEsEQEEKIQYDQCABIARBA3RqIggvAQAiBwRAIAdBAmsNAwwECyAGQQFqIQYgA0EBcSEHIANBAXYhAyAIKAIEIAQgB2pqIgQgAkkNAAsLIAQgAkHctcQAEIwHAAtBDyAFLQAgIgEgBkH/AXFJDQEaIAUgASAGazoAICAAIAgvAQI7AQIgBSAFKQMAIAatiDcDACAAQR06AAAPC0EOCzoAAAuvAQEDfyAAAn8CQAJAIAIgBEsEQEEKIQYDQCABIARBA3RqIggvAQAiBwRAIAdBAmsNAwwECyAGQQFqIQYgA0EBcSEHIANBAXYhAyAIKAIEIAQgB2pqIgQgAkkNAAsLIAQgAkHctcQAEIwHAAtBDyAFLQAMIgEgBkH/AXFJDQEaIAUgASAGazoADCAAIAgvAQI7AQIgBSAFKQMAIAatiDcDACAAQR06AAAPC0EOCzoAAAvQAQEDfyMAQRBrIgIkACACIAA2AgQgASgCAEGQzsQAQQ8gASgCBCgCDBEAACEAIAJBADoADSACIAA6AAwgAiABNgIIIAJBCGpByPvHAEEEIAJBBGpBgM7EABCMBSEAIAItAA0iAyACLQAMIgRyIQECQCAEQQFxIANBAUdyDQAgACgCACIALQAKQYABcUUEQCAAKAIAQf+zxQBBAiAAKAIEKAIMEQAAIQEMAQsgACgCAEGls8UAQQEgACgCBCgCDBEAACEBCyACQRBqJAAgAUEBcQuwAQEFfyMAQSBrIgEkAAJAIAAoAgAiAkHQjtQDSwR/QQAFQQQgAkEBdCIDIANBBE0bIgRBjAFsIQVBACEDIAEgAgR/IAEgAkGMAWw2AhwgASAAKAIENgIUQQQFIAMLNgIYIAFBCGpBBCAFIAFBFGoQhQcgASgCCEEBRw0BIAEoAhAhACABKAIMCyAAQfD/xgAQkwkACyABKAIMIQIgACAENgIAIAAgAjYCBCABQSBqJAAL0AEBA38jAEEQayICJAAgAiAANgIEIAEoAgBBmK3HAEENIAEoAgQoAgwRAAAhACACQQA6AA0gAiAAOgAMIAIgATYCCCACQQhqQcj7xwBBBCACQQRqQYitxwAQjAUhACACLQANIgMgAi0ADCIEciEBAkAgBEEBcSADQQFHcg0AIAAoAgAiAC0ACkGAAXFFBEAgACgCAEH/s8UAQQIgACgCBCgCDBEAACEBDAELIAAoAgBBpbPFAEEBIAAoAgQoAgwRAAAhAQsgAkEQaiQAIAFBAXELvwEBBH8jAEEQayICJAAgAkEIaiIDIAFBJGooAgA2AgAgAiABKQIcNwMAAkACQEEMEHEiBARAIAQgAikDADcCACAEQQhqIAMoAgA2AgAgAUEEahDqAiABQQRrKAIAIgNBeHFBLEEwIANBA3EiBRtJDQEgBUEAIANB0ABPGw0CIAEQogIgAEHksMcANgIEIAAgBDYCACACQRBqJAAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC6wBAQV/IwBBIGsiAiQAIAAoAgAiA0HVqtUqSwRAQQBBACABEJMJAAtBBCADQQF0IgQgBEEETRsiBUEMbCEGQQAhBCACIAMEfyACIANBDGw2AhwgAiAAKAIENgIUQQQFIAQLNgIYIAJBCGpBBCAGIAJBFGoQhQcgAigCCEEBRgRAIAIoAgwgAigCECABEJMJAAsgAigCDCEBIAAgBTYCACAAIAE2AgQgAkEgaiQAC6cDAQh/IwBBEGsiAyQAIAAoAgQhBSAAKAIAIQBBASEHIAEoAgBB6LLFAEEBIAEoAgQoAgwRAAAhAiADQQA6AAkgAyACOgAIIAMgATYCBAJAAkAgBQRAA0AgAyAANgIMIANBDGohCCMAQSBrIgEkAEEBIQYCQCADQQRqIgQtAAQNACAELQAFIQkCQCAEKAIAIgItAApBgAFxRQRAIAlBAXFFDQEgAigCAEHnkMYAQQIgAigCBCgCDBEAAEUNAQwCCyAJQQFxRQRAIAIoAgBB3PjHAEEBIAIoAgQoAgwRAAANAgsgAUEBOgAPIAFB4IHCADYCFCABIAIpAgA3AgAgASACKQIINwIYIAEgAUEPajYCCCABIAE2AhAgCCABQRBqEO8HDQEgASgCEEHZgcIAQQIgASgCFCgCDBEAACEGDAELIAggAhDvByEGCyAEQQE6AAUgBCAGOgAEIAFBIGokACAAQQFqIQAgBUEBayIFDQALIAMtAAhFDQEMAgsgAg0BCyADKAIEIgAoAgBB6bLFAEEBIAAoAgQoAgwRAAAhBwsgA0EQaiQAIAcLnQEBBH8gACgCACECIAAgARCiBgJAIAAoAggiBSACIAAoAgwiA2tNDQAgAiAFayIBIAMgAWsiA0sgACgCACIEIAJrIANPcUUEQCAEIAFrIQIgAUEMbCIBBEAgACgCBCIEIAJBDGxqIAQgBUEMbGogAfwKAAALIAAgAjYCCA8LIANBDGwiAUUNACAAKAIEIgAgAkEMbGogACAB/AoAAAsLxAEBBH8jAEEQayIEJAACQAJAAkACQAJAAkACQAJAIAEoAgBBAWsOBQECBwcDAAsgASgCFCIDDQMMBgsgASgCFCIDDQMMBQsgASgCECIDDQMMBAsgAS0ABEEDRw0DIARBCGogASgCCCIBKAIAIAEoAgQoAhgRAQAgBCgCDCEFIAQoAgghAgwDCyABKAIYIQUgAyECDAILIAEoAhghBSADIQIMAQsgASgCFCEFIAMhAgsgACAFNgIEIAAgAjYCACAEQRBqJAALnQEBBH8jAEEgayIBJAACQEEIIAAoAgAiBEEBdCIDIANBCE0bIgNBAE4EfyABIAQEfyABIAQ2AhwgASAAKAIENgIUQQEFIAILNgIYIAFBCGpBASADIAFBFGoQhQcgASgCCEEBRw0BIAEoAhAhAiABKAIMBSACCyACQfznwQAQkwkACyABKAIMIQIgACADNgIAIAAgAjYCBCABQSBqJAALmAEBBH8jAEEgayICJAACQEEIIAAoAgAiBUEBdCIEIARBCE0bIgRBAE4EfyACIAUEfyACIAU2AhwgAiAAKAIENgIUQQEFIAMLNgIYIAJBCGogBCACQRRqEN0HIAIoAghBAUcNASACKAIQIQMgAigCDAUgAwsgAyABEJMJAAsgAigCDCEBIAAgBDYCACAAIAE2AgQgAkEgaiQAC64BAQN/IwBBEGsiAyQAAkACQAJAAkAgAEUgAUVyDQAgACgCACIARQ0AIABBwf///wdPDQEgAUEEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAGpJDQIgAkEAIAQgAEEnaksbDQMgARCiAgsgA0EQaiQADwtB2ObIAEErIANBD2pBtIPJAEHEg8kAEOAGAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALmQECAn8EfgJAAkAgASgCBCICIAEpAwgiBSACrSIEIAQgBVYbpyICRwRAIAEoAgAgAmotAAAhA0EEIQIMAQtBqJDIACkDACIHQgiIIQYgB6chAiAHQv8Bg0IEUg0BCyAFQgF8IQQLIAEgBDcDCCACQf8BcUEERwRAIAAgAq1C/wGDIAZCCIaENwIADwsgAEEEOgAAIAAgAzoAAQu0AQACfwJAAkACQAJAAkACQCACQQNrDgUEBQECAAULIAFBpPzAAEEHENsHDQRBAAwFC0EBIAFBq/zAAEEFENsHRQ0EGiABQbz/wABBBRDbBw0BQQIMBAsgAUHB/8AAQQYQ2wcNAkEDDAMLIAFBx//AAEEFENsHDQFBBAwCC0EFIAFBzP/AAEEDENsHRQ0BGiABQc//wABBAxDbBw0AQQYMAQtBBwshASAAQQA6AAAgACABOgABC6gBAQV/IwBBIGsiAiQAAkACQCABELsKIgNBAE4EQAJAIANFBEBBASEEDAELIAMQcSIERQ0CCyABELsKIQUgARC7CiEGIAIgBTYCBCACIAY2AgAgBSAGRw0CIAQgBSABEOMJIAAgAzYCCCAAIAQ2AgQgACADNgIAIAJBIGokAA8LQeD5xAAQ/wcLAAsgAkEANgIIQQAgAiACQQRqIAJBCGpB4PnEABD1BwALowECAn8BfiMAQRBrIgMkAAJAAkACQCABKAIIIgQgASgCBEkEQCABKAIAIARqLQAAIAJB/wFxRg0BCyAAQgA3AwgMAQtBASECIAEgBEEBajYCCCADIAEQ2QQgAy0AAEUEQCADKQMIIgVCf1IEQCAAIAVCAXw3AwgMAgsgAEEAOgABDAILIAAgAy0AAToAAQwBC0EAIQILIAAgAjoAACADQRBqJAALqAECBX8BfiMAQSBrIgIkAAJ/IAAoAgBBgICAgHhHBEAgASgCACAAKAIEIAAoAgggASgCBCgCDBEAAAwBCyABKAIEIQMgASgCACAAKAIMKAIAIgApAhAhByAAKAIMIQQgACgCCCEFIAAoAgAhBiAAKAIEIQAgAiAHNwIYIAIgBDYCFCACIAU2AhAgAiAANgIMIAIgBjYCCCADIAJBCGoQwQMLIAJBIGokAAuTAQIBfwF+IwBBMGsiAiQAAn8gACgCACIAKAIMRQRAIAAgARDkAwwBCyACQoCAgIAQIgMgAEEQaq2ENwMQIAIgAyAAQQxqrYQ3AwggAiAArUKAgICAoA6ENwMAIAEoAgAgASgCBCACQgM3AiQgAkEDNgIcIAJBoKXGADYCGCACIAI2AiAgAkEYahDBAwsgAkEwaiQAC6MBAgJ/AX4jAEEQayICJAAgASgCCCEDIAIgARDZBAJAIAItAABBAUYEQCACLQABIQEgAEEANgIAIAAgAToABAwBCyACKQMIIgQgA0EBa61UBEAgASgCDEEBaiIDQfQDTQRAIAAgAzYCDCAAIAQ+AgggACABKQIANwIADAILIABBADYCACAAQQE6AAQMAQsgAEEANgIAIABBADoABAsgAkEQaiQAC6UBAAJAAkACQCABQf8ATARAIAFBgn9ODQMgAEMAAIAMlCEAIAFBm35NDQEgAUHmAGohAQwDCyAAQwAAAH+UIQAgAUH+AUsNASABQf8AayEBDAILIABDAACADJQhAEG2fSABIAFBtn1NG0HMAWohAQwBCyAAQwAAAH+UIQBB/QIgASABQf0CTxtB/gFrIQELIAAgAUEXdEGAgID8A2pBgICA/AdxvpQLqAEBAn8gASgCDCECAkACQAJAAkACQAJAAkAgASgCBA4CAAECCyACDQFBASEDQQAhAUEBIQIMAwsgAkUNAQsgACABEOwDDwsgASgCACICKAIEIgFBAEgNASACKAIAIQMgAUUEQEEBIQJBACEBDAELIAEQcSICRQ0CCyABBEAgAiADIAH8CgAACyAAIAE2AgggACACNgIEIAAgATYCAA8LQdiayAAQ/wcLAAuNAQEDfyMAQRBrIgMkAEEDIQIgACgCAC0AACIAIQQgAEEKTwRAIAMgACAAQeQAbiIEQeQAbGtB/wFxQQF0LwC4ukU7AA5BASECC0EAIAAgBBtFBEAgAkEBayICIANBDWpqIARBAXQtALm6RToAAAsgAUEBQQFBACADQQ1qIAJqQQMgAmsQyAMgA0EQaiQAC4oBAQN/IwBBEGsiAyQAQQMhAiAALQAAIgAhBCAAQQpPBEAgAyAAIABB5ABuIgRB5ABsa0H/AXFBAXQvALi6RTsADkEBIQILQQAgACAEG0UEQCACQQFrIgIgA0ENamogBEEBdC0AubpFOgAACyABQQFBAUEAIANBDWogAmpBAyACaxDIAyADQRBqJAALlQEDA3wBfgF/IAC7IAG7oiIDIAK7IgSgIgW9IgZC/////wGDQoCAgIABUiAGQoCAgICAgID4/wCDQoCAgICAgID4/wBRciAEIAUgA6FhIAUgBKEgA2FxcgR8IAUFIAZCAX0gBkIBhCAGQgBTIgcgAyAEIAWhoCADIAWhIASgIAcgAyAEY3MbRAAAAAAAAAAAY3Mbvwu2C6QBAQR/IAAQ9gICQAJAIAAoAsgFIgEEQCAAKALMBSIDQQRrKAIAIgJBeHEiBEEEQQggAkEDcSICGyABakkNASACQQAgBCABQSdqSxsNAiADEKICCyAAQeAAaiEBAkACQAJAIAAoArwFQYCAgIB4aw4CAQIACyABEL4CDwsgARC9AQsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAujAQEEfyAAEPUCAkACQCAAKAKoBSIBBEAgACgCrAUiA0EEaygCACICQXhxIgRBBEEIIAJBA3EiAhsgAWpJDQEgAkEAIAQgAUEnaksbDQIgAxCiAgsgAEFAayEBAkACQAJAIAAoApwFQYCAgIB4aw4CAQIACyABEL4CDwsgARC9AQsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuWAQEDfwJ/AkACQCABKAIAIgNFBEAMAQsDQAJAIAEoAggiBCABKAIETw0AIAMgBGotAABBxQBHDQAgASAEQQFqNgIIDAILAkAgAkUNACABKAIQIgNFDQAgA0HnkMYAQQIQlwMNAwsgARCGAg0CIAJBAWohAiABKAIAIgMNAAsLQQAMAQtBAQshASAAIAI2AgQgACABNgIAC6YBAgJ/AX4CQAJAAkACQCABKAIoQQJHBEAgASgCmAJBgYCAgHhHDQFBgICAgHghAgwCC0GsmMcAEN0JAAsgASgCoAIiAkEASA0BIAEoApwCIQMCQCACRQRAQQEhAQwBCyACEHEiAUUNAwsgAgRAIAEgAyAC/AoAAAsgAa0gAq1CIIaEIQQLIAAgBDcDCCAAIAI2AgQgAEEGNgIADwtB2JrIABD/BwsAC6YBAgJ/AX4CQAJAAkACQCABKAIoQQJHBEAgASgCpAJBgYCAgHhHDQFBgICAgHghAgwCC0GsmMcAEN0JAAsgASgCrAIiAkEASA0BIAEoAqgCIQMCQCACRQRAQQEhAQwBCyACEHEiAUUNAwsgAgRAIAEgAyAC/AoAAAsgAa0gAq1CIIaEIQQLIAAgBDcDCCAAIAI2AgQgAEEGNgIADwtB2JrIABD/BwsAC8cBAQF7IAIgA0sEQCAAIAEgA0EVbGoiASwAFLJDAAD+QpU4AlAgACAB/VwAAP2HAf2nAf36Af0MAAD+QgAA/kIAAP5CAAD+QiIE/ecB/QsCACAAIAH9XAAE/YcB/acB/foBIAT95wH9CwIQIAAgAf1cAAj9hwH9pwH9+gEgBP3nAf0LAiAgACAB/VwADP2HAf2nAf36ASAE/ecB/QsCMCAAIAH9XAAQ/YcB/acB/foBIAT95wH9CwJADwsgAyACQZy8xwAQjAcAC38BAX8gAkEETwRAA0AgACgAACABKAAARwRAQQAPCyABQQRqIQEgAEEEaiEAIAJBBGsiAkEDSw0ACwtBASEDIAJBAUsEQCAALwAAIAEvAABHBEBBAA8LIAJBAmshAiABQQJqIQEgAEECaiEACyACBH8gAC0AACABLQAARgUgAwsLoAEBBH8gAEH0BGoQwAICQAJAIAAoAugEIgIEQCAAKALsBCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCwJAAkACQCAAKALcBEGAgICAeGsOAgECAAsgABC+Ag8LIAAQvQELDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALoAEBBH8gAEH0BGoQigICQAJAIAAoAugEIgIEQCAAKALsBCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCwJAAkACQCAAKALcBEGAgICAeGsOAgECAAsgABC+Ag8LIAAQvQELDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALmgEBA38gASgCICECIAEoAhwhAwJAAkBBCBBxIgQEQCAEIAI2AgQgBCADNgIAIAFBBGoQ6gIgAUEEaygCACICQXhxIgNBKEEsIAJBA3EiAhtJDQEgAkEAIANBzABPGw0CIAEQogIgAEGAmMEANgIEIAAgBDYCAA8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALjgEBA38jAEEQayIBJAAgAUEAOgAPAkACQEEBEHEiAgRAIAAgAUEPaq03AwAgACACrTcDCCACQQRrKAIAIgBBeHEiA0EFQQkgAEEDcSIAG0kNASAAQQAgA0EpTxsNAiACEKICIAFBEGokAA8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALjgEBBH8jAEEQayICJAACf0EBIAEoAgAiA0EnIAEoAgQiBSgCECIBEQIADQAaIAIgACgCAEGBAhCBAwJAIAItAA0iAEGBAU8EQCADIAIoAgAgARECAEUNAUEBDAILIAMgAiACLQAMIgRqIAAgBGsgBSgCDBEAAEUNAEEBDAELIANBJyABEQIACyACQRBqJAALmgEBA38gASgCICECIAEoAhwhAwJAAkBBCBBxIgQEQCAEIAI2AgQgBCADNgIAIAFBBGoQ6gIgAUEEaygCACICQXhxIgNBKEEsIAJBA3EiAhtJDQEgAkEAIANBzABPGw0CIAEQogIgAEGwr8cANgIEIAAgBDYCAA8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALgAEBAn8gA0EITwRAIAAgACADQQN2IgNBBHQiBGogACADQRxsIgVqIAMQwgYhACABIAEgBGogASAFaiADEMIGIQEgAiACIARqIAIgBWogAxDCBiECCyAAIAIgASAAKAIAIgAgASgCACIBSSIDIAEgAigCACICSXMbIAMgACACSXMbC4ABAQJ/IANBCE8EQCAAIAAgA0EDdiIDQQV0IgRqIAAgA0E4bCIFaiADEMMGIQAgASABIARqIAEgBWogAxDDBiEBIAIgAiAEaiACIAVqIAMQwwYhAgsgACACIAEgACgCACIAIAEoAgAiAUkiAyABIAIoAgAiAklzGyADIAAgAklzGwt+AQJ/IAAgACgCCCIDIAFJBH8gASADayIEIAAoAgAgA2tLBEAgACADIARBAUEBEKQFIAAoAgghAwsgACgCBCIAIANqIQEgBEECTwR/IARBAWsiBARAIAEgAiAE/AsACyAAIAMgBGoiA2oFIAELIAI6AAAgA0EBagUgAQs2AggLkAEBAX8jAEEwayICJAACf0EBIAEoAgBBIiABKAIEKAIQEQIADQAaIAIgATYCDCACIACtQoCAgIDQAIQ3AxAgAkIBNwIkIAJBATYCHCACQaD4xwA2AhggAiACQRBqNgIgQQEgAkEMakG4oMEAIAJBGGoQwQMNABogASgCAEEiIAEoAgQoAhARAgALIAJBMGokAAuQAQEBfyMAQTBrIgIkAAJ/QQEgASgCAEEiIAEoAgQoAhARAgANABogAiABNgIMIAIgAK1CgICAgMAHhDcDECACQgE3AiQgAkEBNgIcIAJBoPjHADYCGCACIAJBEGo2AiBBASACQQxqQeS3xwAgAkEYahDBAw0AGiABKAIAQSIgASgCBCgCEBECAAsgAkEwaiQAC48BAQF/IwBBEGsiAiQAIAJBCGogARCfAwJAIAItAAhBAUYEQCAAIAIoAgw2AgQgAEEDNgIADAELIAItAAlFBEAgAEECNgIADAELIAJBCGogASgCABDSAiACKAIIIgFBAkYEQCAAIAIoAgw2AgQgAEEDNgIADAELIAAgAioCDDgCBCAAIAE2AgALIAJBEGokAAuSAQICfwF+IwBBIGsiAiQAAkACQCAALQAIIgNBA0cEQCADQQFLDQIgAEECOgAIIAEoAgAgAUIANwMARQ0BIAEpAwghBCAAQQM6AAggACAENwMACyACQSBqJAAPC0HQnMcAEN0JAAsgAkEANgIYIAJBATYCDCACQZiDyAA2AgggAkIENwIQIAJBCGpBwJzHABCNCAALhQEBA38CfwJAIAAoAgAiAUUNAANAAkAgACgCCCIDIAAoAgRPDQAgASADai0AAEHFAEcNACAAIANBAWo2AggMAgsCQCACRQ0AIAAoAhAiAUUNACABQeeQxgBBAhCXA0UNAEEBDwtBASAAQQEQ1QENAhogAkEBayECIAAoAgAiAQ0ACwtBAAsLhwEBA38gACgCACECIAAoAgQiACgCACIBBEAgAiABEQMACwJAAkAgACgCBCIABEAgAkEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAGpJDQEgAUEAIAMgAEEnaksbDQIgAhCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuUAQICfgF/IAEpAgAgASkCCCEDIABBBGoQ6gJC7bqtts2F1PXjAIUgA0L4gpm9le7Gxbl/hYRQBEAgAEEkahCxBAsCQCAAQQRrKAIAIgFBeHFBLEEwIAFBA3EiBBtPBEAgBEEAIAFB0ABPGw0BIAAQogIPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAt/AQF/IwBBQGoiBCQAIAQgATYCDCAEIAA2AgggBCADNgIsIAQgAjYCKCAEQQI2AhQgBEH45sAANgIQIARCAjcCHCAEIARBKGqtQoCAgIDAAIQ3AzggBCAEQQhqrUKAgICAIIQ3AzAgBCAEQTBqNgIYIARBEGoQxwUgBEFAayQAC4oBAQJ/IwBBEGsiAiQAAkACQCAAKAIkIgFBCU8EQCAAKAIEIgFBf0YNAQtBfyABZ3ZBACABGyIBQX9GDQAgAkEIaiAAIAFBAWoQ6AMgAigCCCIAQYGAgIB4RwRAIAANAkHYlccAQRFB1MzHABDrBwALIAJBEGokAA8LQdiVxwBBEUHkzMcAEKsHCwALigEBAn8jAEEQayICJAACQAJAIAAoAhQiAUEFTwRAIAAoAgQiAUF/Rg0BC0F/IAFndkEAIAEbIgFBf0YNACACQQhqIAAgAUEBahDpAyACKAIIIgBBgYCAgHhHBEAgAA0CQdiVxwBBEUHUzMcAEOsHAAsgAkEQaiQADwtB2JXHAEERQeTMxwAQqwcLAAuEAQECfyAAIAEgACgCCCIDQQNyIgJB/v8DcSACbEGA/gNxQQh2cyIBIAAoAgAiAnNB/wFxQQJ0KALwvUggAkEIdnMiAjYCACAAIAAoAgQgAkH/AXFqQYWIosAAbEEBaiICNgIEIAAgA0H/AXEgAkEYdnNBAnQoAvC9SCADQQh2czYCCCABC44BAgN/AX4gASkCHCEFAkACQEEIEHEiAwRAIAMgBTcCACABQQRqEOoCIAFBBGsoAgAiAkF4cSIEQShBLCACQQNxIgIbSQ0BIAJBACAEQcwATxsNAiABEKICIABBxJfBADYCBCAAIAM2AgAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC44BAgN/AX4gASkCHCEFAkACQEEIEHEiAwRAIAMgBTcCACABQQRqEOoCIAFBBGsoAgAiAkF4cSIEQShBLCACQQNxIgIbSQ0BIAJBACAEQcwATxsNAiABEKICIABBiJbBADYCBCAAIAM2AgAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4IBAQF/IwBBMGsiAiQAIAIgACgCACgCACIANgIYIAIgAGg2AhwgAkEDNgIEIAJByIvDADYCACACQgI3AgwgAiACQRxqrUKAgICAsAaENwMoIAIgAkEYaq1CgICAgMAGhDcDICACIAJBIGo2AgggASgCACABKAIEIAIQwQMgAkEwaiQAC4sBAQJ/IwBBEGsiAiQAAkACQCAAKAKEASIBQSFPBEAgACgCBCIBQX9GDQELQX8gAWd2QQAgARsiAUF/Rg0AIAJBCGogACABQQFqEPQDIAIoAggiAEGBgICAeEcEQCAADQJB2JXHAEERQdTMxwAQ6wcACyACQRBqJAAPC0HYlccAQRFB5MzHABCrBwsAC4oBAQJ/IwBBEGsiAiQAAkACQCAAKAIUIgFBBU8EQCAAKAIEIgFBf0YNAQtBfyABZ3ZBACABGyIBQX9GDQAgAkEIaiAAIAFBAWoQ9QMgAigCCCIAQYGAgIB4RwRAIAANAkHYlccAQRFB1MzHABDrBwALIAJBEGokAA8LQdiVxwBBEUHkzMcAEKsHCwALigEBAn8jAEEQayICJAACQAJAIAAoAiQiAUEJTwRAIAAoAgQiAUF/Rg0BC0F/IAFndkEAIAEbIgFBf0YNACACQQhqIAAgAUEBahD2AyACKAIIIgBBgYCAgHhHBEAgAA0CQdiVxwBBEUHUzMcAEOsHAAsgAkEQaiQADwtB2JXHAEERQeTMxwAQqwcLAAuOAQIDfwF+IAEpAhwhBQJAAkBBCBBxIgMEQCADIAU3AgAgAUEEahDqAiABQQRrKAIAIgJBeHEiBEEoQSwgAkEDcSICG0kNASACQQAgBEHMAE8bDQIgARCiAiAAQailxwA2AgQgACADNgIADwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAuKAQEDfyABKAIcIQICQAJAQQQQcSIDBEAgAyACNgIAIAFBBGoQ6gIgAUEEaygCACICQXhxQSRBKCACQQNxIgQbSQ0BIARBACACQcgATxsNAiABEKICIABB8JnBADYCBCAAIAM2AgAPCwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4oBAQN/IAEtABwhAgJAAkBBARBxIgMEQCADIAI6AAAgAUEEahDqAiABQQRrKAIAIgJBeHFBJEEoIAJBA3EiBBtJDQEgBEEAIAJByABPGw0CIAEQogIgAEGosMcANgIEIAAgAzYCAA8LAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALbQEDfyMAQRBrIgIkACAALQAAIQNBAyEAA0AgACACakEMaiADQQ9xQcmBwgBqLQAAOgAAIAMiBEEEdiEDIABBAWshACAEQQ9LDQALIAFBAUGEtMUAQQIgACACakENakEDIABrEMgDIAJBEGokAAt7AQF/IwBBIGsiAiQAAn8gACgCAEEBRgRAIAEoAgBBw4/GAEEVIAEoAgQoAgwRAAAMAQsgAiAArUKAgICAEIQ3AwAgASgCACABKAIEIAJCATcCFCACQQI2AgwgAkHwj8YANgIIIAIgAjYCECACQQhqEMEDCyACQSBqJAALdwEBfyMAQUBqIgMkACADIAI2AhQgAyABNgIQIAMgADYCDCADQQI2AhwgA0Gk5sAANgIYIANCAjcCJCADIANBEGqtQoCAgIAwhDcDOCADIANBDGqtQoCAgIAQhDcDMCADIANBMGo2AiAgA0EYahDHBSADQUBrJAALfwEEfyAAQQRqEOoCAkACQCAAKAIcIgIEQCAAKAIgIgNBBGsoAgAiAUF4cSIEQQRBCCABQQNxIgEbIAJqSQ0BIAFBACAEIAJBJ2pLGw0CIAMQogILIABBKGoQ4wQPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtiAQR+IAAgAkL/////D4MiAyABQv////8PgyIEfiIFIAQgAkIgiCICfiIEIAMgAUIgiCIGfnwiAUIghnwiAzcDACAAIAMgBVStIAIgBn4gASAEVK1CIIYgAUIgiIR8fDcDCAt6AQF/IwBBQGoiAyQAIAMgAjYCBCADIAE2AgAgAyAA/QADAP0LAyAgA0ECNgIMIANB3KDGADYCCCADQgI3AhQgAyADrUKAgICAMIQ3AzggAyADQSBqrUKAgICA4ACENwMwIAMgA0EwajYCECADQQhqEMcFIANBQGskAAt6AQF/IwBBQGoiAyQAIAMgAjYCBCADIAE2AgAgAyAA/QADAP0LAyAgA0ECNgIMIANBqKbGADYCCCADQgI3AhQgAyADrUKAgICAMIQ3AzggAyADQSBqrUKAgICA4ACENwMwIAMgA0EwajYCECADQQhqEMcFIANBQGskAAt8AQF/IwBBQGoiBSQAIAUgATYCDCAFIAA2AgggBSADNgIUIAUgAjYCECAFQQI2AhwgBUHg+McANgIYIAVCAjcCJCAFIAVBEGqtQoCAgICQAYQ3AzggBSAFQQhqrUKAgICAoAGENwMwIAUgBUEwajYCICAFQRhqIAQQjQgAC2oBA38jAEEQayIDJAAgACgCACgCACEAQQkhAgNAIAIgA2pBBmogAEEPcS0A3LZFOgAAIAJBAWshAiAAQQ9LIABBBHYhAA0ACyABQQFBhLTFAEECIAIgA2pBB2pBCSACaxDIAyADQRBqJAALjAEAAn8CQAJAAkACQAJAIAJBA2sOBAMEAAEECyABQbz/wABBBRDbBw0BQQAMBAsgAUHB/8AAQQYQ2wcNAkEBDAMLIAFBx//AAEEFENsHDQFBAgwCC0EDIAFBzP/AAEEDENsHRQ0BGiABQc//wABBAxDbBw0AQQQMAQtBBQshAiAAQQA6AAAgACACOgABC4IBAQJ/IABBDGoQ9QICQAJAAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQQRrKAIAIgFBeHEiAkHYAEHcACABQQNxIgEbSQ0BIAFBACACQfwATxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC4IBAQJ/IABBDGoQ9gICQAJAAkAgAEF/Rg0AIAAgACgCBEEBayIBNgIEIAENACAAQQRrKAIAIgFBeHEiAkH4AEH8ACABQQNxIgEbSQ0BIAFBACACQZwBTxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC3wBAX8CQAJAIAFB/////wNLDQAgAUECdCIDQf3///8HTw0AAn8gA0UEQEEEIQJBAAwBCyADEHEiAkUNAiACQQRrLQAAQQNxRSADRXJFBEAgAkEAIAP8CwALIAELIQMgACABNgIIIAAgAjYCBCAAIAM2AgAPCyACEP8HCwALZwEDfyMAQRBrIgMkACAAKAIAIQBBCSECA0AgAiADakEGaiAAQQ9xLQDctkU6AAAgAkEBayECIABBD0sgAEEEdiEADQALIAFBAUGEtMUAQQIgAiADakEHakEJIAJrEMgDIANBEGokAAuCAQEDfwJAAkACQAJAIAAtAABBAWsOAgAAAQsgACgCBCICRQ0AIAAoAggiAEEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAMgAkEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAt3AQR/AkACQCABKAIUIgUgASgCECIGTw0AIAEoAgwhBwNAIAUgB2otAAAiCEEwa0H/AXFBCU0EQCABIAVBAWoiBTYCFCAFIAZHDQEMAgsLIAhBIHJB5QBGDQELIAAgASACIAMgBBDwBA8LIAAgASACIAMgBBDuAwuCAQAgASgCKEECRwRAAkACQCACKAIQQQFGBEAgASgC3AIgAigCFEsNAQsgAigCGEEBRw0BIAEoAuACIAIoAhxNDQELIABCAjcDCCAAQQM2AgAPCyAAQQY2AgAgASAC/QADAP0LAwAgAUEQaiACQRBq/QADAP0LAwAPC0GsmMcAEN0JAAt3AQN/IABBBGoQ6gICQAJAIAAoAhwiAgRAIAAoAiAiAEEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAMgAkEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAt0AQJ/AkACQCAABEAgAEEIayIDIAMoAgBBAWoiBDYCACAERQ0BIAAoAgANAiAAQX82AgAgAEEEaiABIAJBAEcQMCAAIAAoAgBBAWo2AgAgAyADKAIAQQFrIgA2AgAgAEUEQCADEOQGCw8LEI4KCwALEJAKAAt0AQJ/AkACQCAABEAgAEEIayIDIAMoAgBBAWoiBDYCACAERQ0BIAAoAgANAiAAQX82AgAgAEEEaiABIAJBAEcQLyAAIAAoAgBBAWo2AgAgAyADKAIAQQFrIgA2AgAgAEUEQCADEOMGCw8LEI4KCwALEJAKAAt1AgF/AX4jAEEQayIFJAAgAUUEQEGt+cQAQTIQjwoACyAFQQhqIAEgAyAEIAIoAhARBgAgACAFKQMIIganIgFB/wFxNgIIIAAgBkIgiKdBACABQQFxIgIbNgIEIABBACABQQh2Qf8BcSACGzYCACAFQRBqJAALdQIBfwF+IwBBEGsiBSQAIAFFBEBBrfnEAEEyEI8KAAsgBUEIaiABIAMgBCACKAIQEQYAIAAgBSkDCCIGpyICQQJGIgE2AgggACAGQiCIpyIDQQAgARs2AgQgAEEAIANBgAggAkEBcRsgARs2AgAgBUEQaiQAC3ABAX8CQAJAIAJBAk8EQCACQQF2IQZBACEAQQAhBQNAIAAgAk8NAiAEIAVGDQMgAyAFaiAAIAFqLQAAOgAAIABBAmohACAFQQFqIgUgBkcNAAsLDwsgACACQeCYxQAQjAcACyAEIARB8JjFABCMBwALdwEEfwJAAkAgACgCACICBEAgACgCBCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAQQxqEOMEDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALcwIBfwF+IwBBEGsiBCQAIAFFBEBBrfnEAEEyEI8KAAsgBEEIaiABIAMgAigCEBEFACAAIAQpAwgiBaciAUH/AXE2AgggACAFQiCIp0EAIAFBAXEiAhs2AgQgAEEAIAFBCHZB/wFxIAIbNgIAIARBEGokAAt6AQN/IwBBEGsiAyQAIANBCGogASgCACABKAIEIAEoAggQ+QEgAygCDCEEIAMoAgghBUEUEHEiAUUEQAALIAEgBTYCDCAAIAE2AgQgAEECNgIAIAEgAikCADcCACABIAQ2AhAgAUEIaiACQQhqKAIANgIAIANBEGokAAt6AQN/IwBBEGsiAyQAIANBCGogASgCACABKAIEIAEoAggQ+QEgAygCDCEEIAMoAgghBUEUEHEiAUUEQAALIAEgBTYCDCAAIAE2AgQgAEEBOgAAIAEgAikCADcCACABIAQ2AhAgAUEIaiACQQhqKAIANgIAIANBEGokAAt6AQN/IwBBEGsiAyQAIANBCGogASgCACABKAIEIAEoAggQ+QEgAygCDCEEIAMoAgghBUEUEHEiAUUEQAALIAEgBTYCDCAAIAE2AgQgAEEBOwEAIAEgAikCADcCACABIAQ2AhAgAUEIaiACQQhqKAIANgIAIANBEGokAAt6AQN/IwBBEGsiAyQAIANBCGogASgCACABKAIEIAEoAggQ+QEgAygCDCEEIAMoAgghBUEUEHEiAUUEQAALIAEgBTYCDCAAIAE2AgQgAEEANgIAIAEgAikCADcCACABIAQ2AhAgAUEIaiACQQhqKAIANgIAIANBEGokAAt9AQN/AkACQCAAKAIAIgJBgICAgHhyQYCAgIB4RwRAIAAoAgQiAEEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAMgAkEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAt2AQN/IAAQigICQAJAIAAoAsQBIgIEQCAAKALIASIAQQRrKAIAIgFBeHEiA0EEQQggAUEDcSIBGyACakkNASABQQAgAyACQSdqSxsNAiAAEKICCw8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC3YBA38gABDAAgJAAkAgACgCvAEiAgRAIAAoAsABIgBBBGsoAgAiAUF4cSIDQQRBCCABQQNxIgEbIAJqSQ0BIAFBACADIAJBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALdAEDfyAAEPYCAkACQCAAKAJgIgIEQCAAKAJkIgBBBGsoAgAiAUF4cSIDQQRBCCABQQNxIgEbIAJqSQ0BIAFBACADIAJBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALdAEDfyAAEPUCAkACQCAAKAJAIgIEQCAAKAJEIgBBBGsoAgAiAUF4cSIDQQRBCCABQQNxIgEbIAJqSQ0BIAFBACADIAJBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALdAEEfwJAAkAgACgCKCICBEAgACgCLCIDQQRrKAIAIgFBeHEiBEEEQQggAUEDcSIBGyACakkNASABQQAgBCACQSdqSxsNAiADEKICCyAAEL8EDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALdAEDfyAAEPcDAkACQCAAKAJoIgIEQCAAKAJsIgBBBGsoAgAiAUF4cSIDQQRBCCABQQNxIgEbIAJqSQ0BIAFBACADIAJBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALbQECfyABKAIIIgRFIAMgASgCACIFIARrTXJFBEAgAUEANgIIIAFBADoADEEAIQQLIAMgBUkEQCADBEAgASgCBCAEaiACIAP8CgAACyAAQQQ6AAAgASADIARqNgIIDwsgAEIENwIAIAFBADoADAtvAQJ/AkACQCAABEAgAEEIayICIAIoAgBBAWoiAzYCACADRQ0BIAAoAgANAiAAQX82AgAgAEEEaiABEC0gACAAKAIAQQFqNgIAIAIgAigCAEEBayIANgIAIABFBEAgAhDkBgsPCxCOCgsACxCQCgALbwECfwJAAkAgAARAIABBCGsiAiACKAIAQQFqIgM2AgAgA0UNASAAKAIADQIgAEF/NgIAIABBBGogARAuIAAgACgCAEEBajYCACACIAIoAgBBAWsiADYCACAARQRAIAIQ4wYLDwsQjgoLAAsQkAoAC3IBA38CQAJAIAAoAgAiAkEASgRAIAAoAgQiAEEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAMgAkEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAttAQF/An8CQAJ/AkAgAigCBARAIAIoAggiA0UEQCABDQIMBAsgAigCACADQQQgARC7AgwCCyABRQ0CCyABEHELIgJBBCACGyEDIAJFDAELQQQhA0EACyECIAAgATYCCCAAIAM2AgQgACACNgIAC3cCAn0CfyABKAIIIgVBgICAAXEhBCAAKgIAIQIgBUGAgICAAXFFBEAgAosiA0PKGw5aYCACQwAAAABcIANDF7fROF1xckUEQCABIAIgBEEAR0EBEPcCDwsgASACIARBAEcQzwIPCyABIAIgBEEARyABLwEOEL0CC28BA38CQAJAIAAoAgAiAgRAIAAoAgQiAEEEaygCACIBQXhxIgNBBEEIIAFBA3EiARsgAmpJDQEgAUEAIAMgAkEnaksbDQIgABCiAgsPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAt9AwF/AX4BfCMAQRBrIgMkAAJAAkACQAJAIAAoAgBBAWsOAgECAAsgACsDCCEFIANBAzoAACADIAU5AwgMAgsgACkDCCEEIANBAToAACADIAQ3AwgMAQsgACkDCCEEIANBAjoAACADIAQ3AwgLIAMgASACEN8GIANBEGokAAtnAQF/An8CfwJAIAMoAgQEQCADKAIIIgRFBEAgAg0CQQAMBAsgAygCACAEIAEgAhC7AgwCCyACDQBBAAwCCyACEHELIgMgASADGyEBIANFCyEDIAAgAjYCCCAAIAE2AgQgACADNgIAC3EBAn8gAEEEahDqAiAAKAIkIgEgASgCACgCABEDAAJAIABBBGsoAgAiAUF4cUEsQTAgAUEDcSICG08EQCACQQAgAUHQAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC2sBAn8jAEEgayIBJAACfyAALQBsQQZHBEAgACgCZCICBEAgAiAAKAJoKAIUEQQADAILQZyqwQAQ3QkACyABQQA2AhggAUEBNgIMIAFBlKrBADYCCCABQgQ3AhAgAUEIahCSBwsgAUEgaiQAC24BAn8jAEEgayIBJAACfyAALQDoAUEGRwRAIAAoAuABIgIEQCACIAAoAuQBKAIUEQQADAILQZyqwQAQ3QkACyABQQA2AhggAUEBNgIMIAFBlKrBADYCCCABQgQ3AhAgAUEIahCSBwsgAUEgaiQAC24BAn8jAEEgayIBJAACfyAALQCMAUEGRwRAIAAoAoQBIgIEQCACIAAoAogBKAIUEQQADAILQZyqwQAQ3QkACyABQQA2AhggAUEBNgIMIAFBlKrBADYCCCABQgQ3AhAgAUEIahCSBwsgAUEgaiQAC24BAn8jAEEgayIBJAACfyAALQDwAUEGRwRAIAAoAugBIgIEQCACIAAoAuwBKAIUEQQADAILQZyqwQAQ3QkACyABQQA2AhggAUEBNgIMIAFBlKrBADYCCCABQgQ3AhAgAUEIahCSBwsgAUEgaiQAC24BA38jAEEQayICJAAgAkEIaiAAKAIAIAAoAgQgACgCCBD5ASACKAIMIQMgAigCCCEEQRQQcSIARQRAAAsgACAENgIMIAAgASkCADcCACAAIAM2AhAgAEEIaiABQQhqKAIANgIAIAJBEGokACAAC2kCAX8BfiMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBAjYCDCADQbSIwwA2AgggA0ICNwIUIANCgICAgBAiBCADrYQ3AyggAyAEIANBBGqthDcDICADIANBIGo2AhAgA0EIaiACEI0IAAtmAQN/IwBBEGsiAiQAAkAgASgCACIEKAIAQQFHDQAgBC0ABEEDRw0AIAJBCGogBCgCCCIBKAIAIAEoAgQoAhgRAQAgAigCDCEBIAIoAgghAwsgACABNgIEIAAgAzYCACACQRBqJAALaQECfyMAQSBrIgIkACACQQhqEOQIQSgQcSIBRQRAAAsgAUGYn8EANgIAIAEgAikCCDcCBCABIAApAgA3AhwgAUEMaiACQRBq/QACAP0LAgAgAUEkaiAAQQhqKAIANgIAIAJBIGokACABC2kBAn8jAEEgayICJAAgAkEIahDkCEEoEHEiAUUEQAALIAFB/J7BADYCACABIAIpAgg3AgQgASAAKQIANwIcIAFBDGogAkEQav0AAgD9CwIAIAFBJGogAEEIaigCADYCACACQSBqJAAgAQtpAQJ/IwBBIGsiAiQAIAJBCGoQ5AhBKBBxIgFFBEAACyABQaS1xwA2AgAgASACKQIINwIEIAEgACkCADcCHCABQQxqIAJBEGr9AAIA/QsCACABQSRqIABBCGooAgA2AgAgAkEgaiQAIAELagEBfyMAQRBrIgYkACABRQRAQa35xABBMhCPCgALIAZBCGogASADIAQgBSACKAIQEQcAIAYoAgwhASAAIAYoAggiAjYCCCAAIAFBACACQQFxIgIbNgIEIABBACABIAIbNgIAIAZBEGokAAtnAQJ/IwBBEGsiAiQAIAAoAgwhAQJ/AkACQAJAIAAoAgQOAgABAgsgAQ0BQQFBABC0BwwCCyABDQAgACgCACIAKAIAIAAoAgQQtAcMAQsgAkEEaiIBIAAQ7AMgARCOBwsgAkEQaiQAC24BAn8CQEEQEHEiAUUNACABQfWVyAD9AAAA/QsAAEEMEHEiAkUNACACQRA2AgggAiABNgIEIAJBEDYCAEEMEHEiAUUNACABQRU6AAggAUHgtMQANgIEIAEgAjYCACAAIAGtQiCGQgOENwIADwsAC2gBAX8jAEEQayIFJAAgAUUEQEGt+cQAQTIQjwoACyAFQQhqIAEgAyAEIAIoAhARBgAgBSgCDCEBIAAgBSgCCCICNgIIIAAgAUEAIAJBAXEiAhs2AgQgAEEAIAEgAhs2AgAgBUEQaiQAC2cBAn8jAEEQayICJAAgACgCDCEBAn8CQAJAAkAgACgCBA4CAAECCyABDQFBAUEAELcHDAILIAENACAAKAIAIgAoAgAgACgCBBC3BwwBCyACQQRqIgEgABDsAyABEJAHCyACQRBqJAALZQEBfwJAAkAgAQRAIABBBGsoAgAiAkF4cSIDQQRBCCACQQNxIgIbIAFqSQ0BIAJBACADIAFBJ2pLGw0CIAAQogILDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALZwECfyAAQQRqEOoCIABBJGoQsQQCQCAAQQRrKAIAIgFBeHFBLEEwIAFBA3EiAhtPBEAgAkEAIAFB0ABPGw0BIAAQogIPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtnAQJ/IABBBGoQ6gIgAEEcahCxBAJAIABBBGsoAgAiAUF4cUEkQSggAUEDcSICG08EQCACQQAgAUHIAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC2cBAn8gAEEEahDqAiAAQRxqEOMEAkAgAEEEaygCACIBQXhxQSxBMCABQQNxIgIbTwRAIAJBACABQdAATxsNASAAEKICDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALaQECfyAAQQRqEOoCIABBIGoQgwICQCAAQQRrKAIAIgFBeHFBzABB0AAgAUEDcSICG08EQCACQQAgAUHwAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC3wBAX8CQAJAIABBhAhPBEAgANBvJgFBoLvJACgCAA0CIABBsLvJACgCACIBSQ0BIAAgAWsiAEGou8kAKAIATw0BQaC0yQAoAgAgAEECdGpBrLvJACgCADYCAEGsu8kAIAA2AgBBoLvJAEEANgIACw8LAAtBgI/IABCwCgALXgEBfyMAQTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQYTmwAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgCCENwMoIAIgAkEoajYCGCACQRBqEMcFIAJBMGokAAteAQF/IwBBMGsiAiQAIAIgATYCDCACIAA2AgggAkECNgIUIAJBhObAADYCECACQgE3AhwgAiACQQhqrUKAgICAIIQ3AyggAiACQShqNgIYIAJBEGoQ3gQgAkEwaiQAC14BAX8jAEEwayICJAAgAiABNgIMIAIgADYCCCACQQI2AhQgAkHI5sAANgIQIAJCATcCHCACIAJBCGqtQoCAgIAghDcDKCACIAJBKGo2AhggAkEQahDeBCACQTBqJAALXgEBfyMAQTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQcjmwAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgCCENwMoIAIgAkEoajYCGCACQRBqEMcFIAJBMGokAAtcAAJAIAFBAE4EQAJAIAFFBEBBASECDAELIAEQcSICRQ0CIAJBBGstAABBA3FFIAFFcg0AIAJBACAB/AsACyAAIAE2AgggACACNgIEIAAgATYCAA8LIAIQ/wcLAAtWAQF+AkAgA0HAAHFFBEAgA0UNASACQQAgA2tBP3GthiABIANBP3GtIgSIhCEBIAIgBIghAgwBCyACIANBP3GtiCEBQgAhAgsgACABNwMAIAAgAjcDCAteAQF/AkAgAEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEAIAMgAUEnaksbDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC2cBAn8jAEEgayICJAAgAkEIahDkCEEoEHEiAUUEQAALIAFB0J/BADYCACABIAIpAgg3AgQgASAANgIkIAFBIjYCICABQbzWwQA2AhwgAUEMaiACQRBq/QACAP0LAgAgAkEgaiQAIAELYQEBfyAAQQRqEOoCAkAgAEEEaygCACIBQXhxIgJBKEEsIAFBA3EiARtPBEAgAUEAIAJBzABPGw0BIAAQogIPC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAthAQJ/IABBBGoQ6gICQCAAQQRrKAIAIgFBeHEiAkEoQSwgAUEDcSIBG08EQCABQQAgAkHMAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC2ICAX8CfiMAQRBrIgEkACAAKAIoQQJGBEBBrJjHABDdCQALIAEgADUC4AIgADUC3AJ+IAAtAOgEQQN0KQOInkkQ3QYgASkDCCECIAEpAwAhAyABQRBqJABCfyADIAJCAFIbC18BAX8gAEEEahDqAgJAIABBBGsoAgAiAUF4cUEsQTAgAUEDcSICG08EQCACQQAgAUHQAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC18BAn8gAEEEahDqAgJAIABBBGsoAgAiAUF4cUEkQSggAUEDcSICG08EQCACQQAgAUHIAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC18BAX8gAEEEahDqAgJAIABBBGsoAgAiAUF4cUEkQSggAUEDcSICG08EQCACQQAgAUHIAE8bDQEgABCiAg8LQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC2EBAX8gAEEEahDqAgJAIABBBGsoAgAiAUF4cUHMAEHQACABQQNxIgIbTwRAIAJBACABQfAATxsNASAAEKICDwtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALWwEBfyMAQTBrIgMkACADIAE2AgwgAyAANgIIIANBATYCFCADQaD4xwA2AhAgA0IBNwIcIAMgA0EIaq1CgICAgKABhDcDKCADIANBKGo2AhggA0EQaiACEI0IAAtiAQJ/IwBBIGsiASQAAkAgABC4ASICDQAgAC0AgARFBEAgAUEANgIYIAFBATYCDCABQcSjwQA2AgggAUIENwIQIAFBCGoQkgchAgwBCyAAQbwCahDUASECCyABQSBqJAAgAgtiAQJ/IwBBIGsiASQAAkAgABCsASICDQAgAC0A+ANFBEAgAUEANgIYIAFBATYCDCABQcSjwQA2AgggAUIENwIQIAFBCGoQkgchAgwBCyAAQbwCahCjASECCyABQSBqJAAgAgtcAQF/IwBBEGsiBiQAIAFFBEBBrfnEAEEyEI8KAAsgBkEIaiABIAMgBCAFIAIoAhARMwAgBigCDCEBIAAgBigCCCICNgIEIAAgAUEAIAJBAXEbNgIAIAZBEGokAAtcAQF/IwBBEGsiBiQAIAFFBEBBrfnEAEEyEI8KAAsgBkEIaiABIAMgBCAFIAIoAhARBwAgBigCDCEBIAAgBigCCCICNgIEIAAgAUEAIAJBAXEbNgIAIAZBEGokAAtcAQF/IwBBEGsiBiQAIAFFBEBBrfnEAEEyEI8KAAsgBkEIaiABIAMgBCAFIAIoAhARNAAgBigCDCEBIAAgBigCCCICNgIEIAAgAUEAIAJBAXEbNgIAIAZBEGokAAtcAQF/IwBBEGsiBiQAIAFFBEBBrfnEAEEyEI8KAAsgBkEIaiABIAMgBCAFIAIoAhARNQAgBigCDCEBIAAgBigCCCICNgIEIAAgAUEAIAJBAXEbNgIAIAZBEGokAAtYAQJ/IwBBEGsiAiQAIAEtAABBA0cEf0EABSACQQhqIAEoAgQiASgCACABKAIEKAIkEQEAIAIoAgwhAyACKAIICyEBIAAgAzYCBCAAIAE2AgAgAkEQaiQAC1gBAn8jAEEQayICJAAgAS0AAEEDRwR/QQAFIAJBCGogASgCBCIBKAIAIAEoAgQoAhgRAQAgAigCDCEDIAIoAggLIQEgACADNgIEIAAgATYCACACQRBqJAALXQECfyMAQSBrIgMkACADQQhqEOQIQSQQcSICRQRAAAsgAkG0n8EANgIAIAIgAykCCDcCBCACIAE2AiAgAiAANgIcIAJBDGogA0EQav0AAgD9CwIAIANBIGokACACC1gBAn8jAEEgayIDJAAgABC4CiEEIAMgAjYCBCADIAQ2AgAgAiAERwRAIANBADYCCEEAIAMgA0EEaiADQQhqQeD5xAAQ9QcACyAAIAEgAhDgCSADQSBqJAALWgEBfyMAQRBrIgUkACABRQRAQa35xABBMhCPCgALIAVBCGogASADIAQgAigCEBEGACAFKAIMIQEgACAFKAIIIgI2AgQgACABQQAgAkEBcRs2AgAgBUEQaiQAC10BAn8jAEEgayIDJAAgA0EIahDkCEEkEHEiAkUEQAALIAJBiLXHADYCACACIAMpAgg3AgQgAiABNgIgIAIgADYCHCACQQxqIANBEGr9AAIA/QsCACADQSBqJAAgAgtYAQF/IwBBEGsiBCQAIAFFBEBBrfnEAEEyEI8KAAsgBEEIaiABIAMgAigCEBEFACAEKAIMIQEgACAEKAIIIgI2AgQgACABQQAgAkEBcRs2AgAgBEEQaiQAC1QBAn8CQCAAQ////z4gAJiSIgC8IgJBF3ZB/wFxIgFBlQFLDQBBgICAgHhBgICAfCABQf8Aa3UgAUH/AEkbIgFBf3MgAnFFDQAgASACcb4hAAsgAAtXAQF/IAAoAugEIAAoAvAEIgNrIAJJBEAgAEHoBGogAyACQQFBARCkBSAAKALwBCEDCyACBEAgACgC7AQgA2ogASAC/AoAAAsgACACIANqNgLwBCAAEFwLVwEBfyAAKAKoBSAAKAKwBSIDayACSQRAIABBqAVqIAMgAkEBQQEQpAUgACgCsAUhAwsgAgRAIAAoAqwFIANqIAEgAvwKAAALIAAgAiADajYCsAUgABBeC1cBAX8gACgC6AQgACgC8AQiA2sgAkkEQCAAQegEaiADIAJBAUEBEKQFIAAoAvAEIQMLIAIEQCAAKALsBCADaiABIAL8CgAACyAAIAIgA2o2AvAEIAAQXQtXAQF/IAAoAsgFIAAoAtAFIgNrIAJJBEAgAEHIBWogAyACQQFBARCkBSAAKALQBSEDCyACBEAgACgCzAUgA2ogASAC/AoAAAsgACACIANqNgLQBSAAEF8LWAEBfyAAKAKwAiAAKAK4AiIDayACSQRAIABBsAJqIAMgAkEBQQEQpAUgACgCuAIhAwsgAgRAIAAoArQCIANqIAEgAvwKAAALIAAgAiADajYCuAIgABCsAQtYAQF/IAAoArACIAAoArgCIgNrIAJJBEAgAEGwAmogAyACQQFBARCkBSAAKAK4AiEDCyACBEAgACgCtAIgA2ogASAC/AoAAAsgACACIANqNgK4AiAAELgBC1gBAX8gACgC2AIgACgC4AIiA2sgAkkEQCAAQdgCaiADIAJBAUEBEKQFIAAoAuACIQMLIAIEQCAAKALcAiADaiABIAL8CgAACyAAIAIgA2o2AuACIAAQsQELWAEBfyAAKAL4AiAAKAKAAyIDayACSQRAIABB+AJqIAMgAkEBQQEQpAUgACgCgAMhAwsgAgRAIAAoAvwCIANqIAEgAvwKAAALIAAgAiADajYCgAMgABCfAQtXAQF/IAAoArwBIAAoAsQBIgNrIAJJBEAgAEG8AWogAyACQQFBARCkBSAAKALEASEDCyACBEAgACgCwAEgA2ogASAC/AoAAAsgACACIANqNgLEASAAEEELVwEBfyAAKALEASAAKALMASIDayACSQRAIABBxAFqIAMgAkEBQQEQpAUgACgCzAEhAwsgAgRAIAAoAsgBIANqIAEgAvwKAAALIAAgAiADajYCzAEgABBAC1IBAX8gACgCYCAAKAJoIgNrIAJJBEAgAEHgAGogAyACQQFBARCkBSAAKAJoIQMLIAIEQCAAKAJkIANqIAEgAvwKAAALIAAgAiADajYCaCAAED4LUQEBfyAAKAJAIAAoAkgiA2sgAkkEQCAAQUBrIAMgAkEBQQEQpAUgACgCSCEDCyACBEAgACgCRCADaiABIAL8CgAACyAAIAIgA2o2AkggABA9C1ABA38CQAJAIAAEQCAAQQhrIgEgASgCACICQQFqIgM2AgAgA0UNASAAKAIAQf////8HTw0CIAAoAhggASACNgIAQQBHDwsQjgoLAAsQkAoAC00BAX8jAEEQayICJAAgAiAAKAIAIgA2AgwgASAAQQNqQcDAxAAgAEEBakHQwMQAIABBAmpB4MDEACACQQxqQfDAxAAQ7gUgAkEQaiQAC00BAX8jAEEQayICJAAgAiAAKAIAIgA2AgwgASAAQQNqQcioxwAgAEEBakHYqMcAIABBAmpB6KjHACACQQxqQfioxwAQ7gUgAkEQaiQAC08BAX8gACgCQCAAKAJIIgNrIAJJBEAgAEFAayADIAJBAUEBEKQFIAAoAkghAwsgAgRAIAAoAkQgA2ogASAC/AoAAAsgACACIANqNgJIQQALVQEBfyAAKALEASAAKALMASIDayACSQRAIABBxAFqIAMgAkEBQQEQpAUgACgCzAEhAwsgAgRAIAAoAsgBIANqIAEgAvwKAAALIAAgAiADajYCzAFBAAtVAQF/IAAoArwBIAAoAsQBIgNrIAJJBEAgAEG8AWogAyACQQFBARCkBSAAKALEASEDCyACBEAgACgCwAEgA2ogASAC/AoAAAsgACACIANqNgLEAUEAC1ABAX8gACgCYCAAKAJoIgNrIAJJBEAgAEHgAGogAyACQQFBARCkBSAAKAJoIQMLIAIEQCAAKAJkIANqIAEgAvwKAAALIAAgAiADajYCaEEAC1YBAn8jAEEgayICJAAgAkEIahDkCEEkEHEiAUUEQAALIAFBqJ7BADYCACABIAIpAgg3AgQgASAANwIcIAFBDGogAkEQav0AAgD9CwIAIAJBIGokACABC1YBAn8jAEEgayICJAAgAkEIahDkCEEgEHEiAUUEQAALIAFB4J7BADYCACABIAIpAgg3AgQgASAANgIcIAFBDGogAkEQav0AAgD9CwIAIAJBIGokACABC1YBAn8jAEEgayICJAAgAkEIahDkCEEkEHEiAUUEQAALIAFBxJ7BADYCACABIAIpAgg3AgQgASAANwIcIAFBDGogAkEQav0AAgD9CwIAIAJBIGokACABC00AIwBBEGsiACQAIAEgAmwiAQR/IAFBwf///wdPBEBB2ObIAEErIABBD2pBtIPJAEHUg8kAEOAGAAtBwAAgARDBBAVBAAsgAEEQaiQAC1YBAn8jAEEgayICJAAgAkEIahDkCEEgEHEiAUUEQAALIAFBtLTHADYCACABIAIpAgg3AgQgASAAOgAcIAFBDGogAkEQav0AAgD9CwIAIAJBIGokACABC1YBAn8jAEEgayICJAAgAkEIahDkCEEkEHEiAUUEQAALIAFB7LTHADYCACABIAIpAgg3AgQgASAANwIcIAFBDGogAkEQav0AAgD9CwIAIAJBIGokACABC1cBAn8jAEEgayIBJAACQCAAEJ8BIgINAEEAIQIgAC0AnAMNACABQQA2AhggAUEBNgIMIAFBxKPBADYCCCABQgQ3AhAgAUEIahCSByECCyABQSBqJAAgAgtXAQJ/IwBBIGsiASQAAkAgABCxASICDQBBACECIAAtAPwCDQAgAUEANgIYIAFBATYCDCABQcSjwQA2AgggAUIENwIQIAFBCGoQkgchAgsgAUEgaiQAIAILTQEDfwJAAkAgAARAIABBCGsiASABKAIAIgJBAWoiAzYCACADRQ0BIAAoAgBB/////wdPDQIgACgCDCABIAI2AgAPCxCOCgsACxCQCgALSAEBfyMAQRBrIgIkACACIAA2AgwgASAAQQNqQcioxwAgAEEBakHYqMcAIABBAmpB6KjHACACQQxqQfioxwAQ7gUgAkEQaiQAC0wBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEKQFIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIQQALYwECfgJ/IAEpAgAiAkLa/Zb/6ejo+sEAhSABKQIIIgNC1vuGkcjA4r/+AIWEUEUEQEEAIAJC7bqtts2F1PXjAIUgA0L4gpm9le7Gxbl/hYRCAFINARogAEEcag8LIABBJGoLC2ABAn4CfyABKQIAIgJC96nT7vKhs5V7hSABKQIIIgNClrmj2vbEh9QnhYRQRQRAQQAgAkL117zJyMzWszqFIANC/tvLm/Plucb1AIWEQgBSDQEaIABBHGoPCyAAQShqCwtAAAJAIAFpQQFHIABBgICAgHggAWtLcg0AIAAEQAJ/IAFBCU8EQCABIAAQwQQMAQsgABBxCyIBRQ0BCyABDwsAC0MBA38CQCACRQ0AA0AgAC0AACIEIAEtAAAiBUYEQCAAQQFqIQAgAUEBaiEBIAJBAWsiAg0BDAILCyAEIAVrIQMLIAMLpzsEIX8DfgJ7B30jAEEQayImJAAjAEHgAGsiGiQAIBogATgCCCAaIAQ2AhAgGiAANgIMAn8CfwJAAkACQAJAIARBBHQgCEYEQCAEIApHDQEgBCAMRw0CIAQgDkcNAyAEIBBHDQQgBCASRgRAIBogBjYCVCAaIAU2AlAgGiAENgJIIBogETYCRCAaIAQ2AkAgGiAPNgI8IBogBDYCOCAaIA02AjQgGiAENgIwIBogCzYCLCAaIAQ2AiggGiAJNgIkIBogCDYCICAaIAc2AhwgGiAENgIYIBogAzYCFCAaIBpBEGo2AlwgGiAaQQhqNgJYIBogGkEMajYCTCAaQRRqIQAjAEFAaiIWJABBsLXJACgCAEUEQBBWCwJAAkACQAJAAkACQEG4tckAKAIARQRAIAAoAkghMiAAKAJEISsgACgCQCEsIAAoAjwhGCAAKAI4ITMgACgCNCEtIAAoAjAhJCAAKAIsIS4gACgCKCEcIAAoAiQhLyAAKAIgIR0gACgCHCEwIAAoAhghGyAAKAIUITEgACgCECEXIAAoAgwhKiAAKAIIISEgACgCBCEgIAAoAgAhGUG4tckAQX82AgACQCAgQZqz5gxJBEACQCAgQdAAbCInRQRAQRAhIwwBCyAgIShBECAnEMEEIiNFDQILAkAgIARAA0ACQAJAQcy1yQAoAgBFDQBBACElQcS1yQAoAgAiHkHYtckAKQMAIjQgGSATQQJ0IilqKAIAIiKthSI1QjiGIDVCgP4Dg0IohoQgNUKAgPwHg0IYhiA1QoCAgPgPg0IIhoSEIDRCCIhCgICA+A+DIDRCGIhCgID8B4OEIDRCKIhCgP4DgyA0QjiIhISEQtKBqpur+oLXp39+IjRCOIYgNEKA/gODQiiGhCA0QoCA/AeDQhiGIDRCgICA+A+DQgiGhIQgNEIIiEKAgID4D4MgNEIYiEKAgPwHg4QgNEIoiEKA/gODIDRCOIiEhIQgNULYotHvwqnlvy1+hSI2QjiGIDZCgP4Dg0IohoQgNkKAgPwHg0IYhiA2QoCAgPgPg0IIhoSEIDZCCIhCgICA+A+DIDZCGIhCgID8B4OEIDZCKIhCgP4DgyA2QjiIhISEQdC1yQApAwAiNEJ/hX4iNUI4hiA1QoD+A4NCKIaEIDVCgID8B4NCGIYgNUKAgID4D4NCCIaEhCA1QgiIQoCAgPgPgyA1QhiIQoCA/AeDhCA1QiiIQoD+A4MgNUI4iISEhCA2IDRCOIYgNEKA/gODQiiGhCA0QoCA/AeDQhiGIDRCgICA+A+DQgiGhIQgNEIIiEKAgID4D4MgNEIYiEKAgPwHg4QgNEIoiEKA/gODIDRCOIiEhIR+hSA2iSI1p3EhFSA1QhmIQv8Ag0KBgoSIkKDAgAF+ITRBwLXJACgCACIfQSBrIQADQCAVIB9qKQAAIjYgNIUiNUJ/hSA1QoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIjVQRQRAA0AgIiAAIDV6p0EDdiAVaiAecSIUQQV0aygCAEYNBCA1QgF9IDWDIjVQRQ0ACwsgNiA2QgGGg0KAgYKEiJCgwIB/g1BFDQEgFSAlQQhqIiVqIB5xIRUMAAsAC0HU+sAAEN0JAAsgE0EEdCIlQQhyIR4CQAJAAkACQAJAAkACQCAqICVBC3IiAE8EQCAlQQxyIRUgJUEPciIAICpLDQEgEyAxRg0CIBMgMEYNAyATIC9GDQQgEyAuRg0FICEgHkECdGoiACoCCCE8IAD9XQIAITggISAVQQJ0aiIAKgIIIT0gAP1dAgAhNyAXIClqKgIAIT8gGyApaioCACE6IB0gKWoqAgAhAUMAAIA/ITkgHCApaioCACI7QwAAAABeDQYMBwsgHiAAICpB1PvAABDqBwALIBUgACAqQcT7wAAQ6gcACyAxIDFB5PrAABCMBwALIDAgMEH0+sAAEIwHAAsgLyAvQYT7wAAQjAcACyAuIC5BlPvAABCMBwALQwAANEMgOyA7QwAANENeG0MAAAA/lEM1+o48lBCbAiE5CwJAAkAgEyAtRwRAIB9BACAUa0EFdGohFUMAAIA/IT4gJCApaioCACI7QwAAAABeDQEMAgsgLSAtQaT7wAAQjAcAC0MAADRDIDsgO0MAADRDXhtDAAAAP5RDNfqOPJQQmwIhPgsgFUEEaygCACIUKAIIIgBB/////wdPDQIgFCAAQQFqNgIIICMgE0HQAGxqIgAgPiA5EN8IOAJEIAAgOTgCQCAAIAE4AjwgACA6OAI4IAAgPzgCNCAAICI2AjAgACAVQRBrNgIsIAAgFUEcazYCKCAAIBRBCGo2AiQgACAUQQxqNgIgIAAgNyA9/SACID39IAP9CwQAIAAgOCA8/SACIjf94QEgN/0NAAECAwQFBgcICQoLCAkKCyA3IDz9IAMiNyA3/eYBIjcgN/0NCAkKCwABAgMAAQIDAAECAyA3IDcgN/0NBAUGBwABAgMAAQIDAAECA/3kAf3kAf3jASA3/Q0AAQIDAAECAwABAgMAAQID/ecB/QsEECATQQFqIhMgIEcNAAsLQbi2yQBBADYCAEGstskAQQA2AgAgMygCACIAQbC2yQAoAgBLBEBBsLbJAEEAIABBBEEIEKQFC0HEtskAQQA2AgBB/LXJACgCAARAQfi1yQBB9LXJACgCACIUBH8gFEEJaiIABEBB8LXJACgCAEH/ASAA/AsACyAUIBRBAWpBA3ZBB2wgFEEISRsFQQALNgIAQfy1yQBBADYCAAtBACEZQQAhGyAgBEAgIyAnaiEdICNB0ABqIRcgIEEBa0H/////AHFBAWohGyAjIQBBACETA0AgEyAsRg0HIBgoAgAiFEEQdEEAIBRBf0cbIhwgACgCICIVKAIIIhRPDQYgFSgCBCAcQQR0aiAAEJwCIQEgFiAcNgIwIBYgATgCKCAWIBM2AiwgFkEoahCTBCAAKAIwQQAQkgJFBEAgACgCMCEUQcS2yQAoAgAiFUG8tskAKAIARgRAQby2yQBBxPrAABD5BQtBwLbJACgCACAVQQN0aiIAQQA2AgQgACAUNgIAQcS2yQAgFUEBajYCAAsgGEEEaiEYQdAAQQAgFyIAIB1HGyAAaiEXIBsgE0EBaiITRw0ACwsCQEGstskAKAIAIhVFBEBDAACAfyE5QQAhJwwBC0MAAIB/ITlBACEnA0ACQCArKgIAITogOUGotskAKAIAIgAqAgAiARDfCCE5IAEgOl8NAANAAkACQAJAAkAgICAAKAIEIh5LBEAgACgCCCIkICMgHkHQAGxqIh8oAiAiFCgCCCIATw0BIBQoAgQgJEEEdGoiAC8BDCIYRQRAIBZBKGoQsgJBuLbJACgCACIUQbC2yQAoAgBGBEBBsLbJAEHE9sAAEPkFC0G0tskAKAIAIBRBA3RqIgAgJDYCBCAAIB42AgBBuLbJACAUQQFqNgIAICdBAWohJwwECyAYIBtqQQFrIhQgMygCAEsNBiAAKAIAIQAgFkEoahCyAiAfKAIwIABBEHYiHBCSAkUEQCAfKAIwIRlBxLbJACgCACIXQby2yQAoAgBGBEBBvLbJAEHU9sAAEPkFC0HAtskAKAIAIBdBA3RqIhMgHDYCBCATIBk2AgBBxLbJACAXQQFqNgIACyAAIBhqIhdBAWtBEHYiHSAcRg0CIB8oAjAgHRCSAg0CIB8oAjAhGUHEtskAKAIAIhVBvLbJACgCAEYEQEG8tskAQeT2wAAQ+QULQcC2yQAoAgAgFUEDdGoiEyAdNgIEIBMgGTYCAEHEtskAIBVBAWo2AgAMAgsgHiAgQaT2wAAQjAcACyAkIABBtPbAABCMBwALAkACQAJAIB8oAiwiEygCCCIZIB1LBEAgGSAcTQRAIBwgGUH09sAAEIwHAAsgEygCBCITIBxBAnRqKAIAQX9GDQMgEyAdQQJ0aigCAEF/Rg0DIAAgF08NBQNAIABBEHYiFyAfKAIsIhkoAggiE08NAiAAQf//A3EgGSgCBCAXQQJ0aigCAEEQdHIiFyAfKAIgIhkoAggiE08NAwJAIBkoAgQgF0EEdGogHxCcAiIBICsqAgBfRQRAIBYgFzYCMCAWIB42AiwgFiABOAIoIBZBKGoQkwQMAQtBuLbJACgCACIZQbC2yQAoAgBGBEBBsLbJAEG098AAEPkFC0G0tskAKAIAIBlBA3RqIhMgFzYCBCATIB42AgBBuLbJACAZQQFqNgIACyAAQQFqIQAgGEEBayIYDQALDAULQbi2yQAoAgAiFEGwtskAKAIARgRAQbC2yQBBxPfAABD5BQtBtLbJACgCACAUQQN0aiIAICQ2AgQgACAeNgIAQbi2yQAgFEEBajYCAAwDCyAXIBNBlPfAABCMBwALIBcgE0Gk98AAEIwHAAtBuLbJACgCACIUQbC2yQAoAgBGBEBBsLbJAEGE98AAEPkFC0G0tskAKAIAIBRBA3RqIgAgJDYCBCAAIB42AgBBuLbJACAUQQFqNgIAC0EAIRlBrLbJACgCACIVDQMMBAtBACEZQay2yQAoAgAiFUUNAyArKgIAITogOUGotskAKAIAIgAqAgAiARDfCCE5IBQhGyABIDpfRQ0ACwsLIBUhGQtBACEbQay2yQBBADYCAEG4tskAKAIAIiQhEyAZBEAgGUEMbCEYQai2yQAoAgBBCGohACAkQQN0IRUDQCAAQQRrKAIAIR0gACgCACEXQbC2yQAoAgAgE0YEQEGwtskAQZT6wAAQ+QULQbS2yQAoAgAgFWoiFCAdNgIAIBRBBGogFzYCAEG4tskAIBNBAWoiEzYCACAAQQxqIQAgFUEIaiEVIBhBDGsiGA0ACwsgFkEANgIQIBZCgICAgMAANwIIQQQhGCAyKAIAIhcEQCAWQQhqQQAgF0EEQQQQpAUgFigCDCIYIBYoAhAiE0ECdGohFCAXQQFHBH8gF0ECdEEEayIABEAgFEEAIAD8CwALIBMgF2oiAEEBayETIBggAEECdGpBBGsFIBQLQQA2AgAgE0EBaiEbQbi2yQAoAgAhEwsgFiAbNgIQAkACQAJAAkACQAJAIBMEQCATQQN0IRNBtLbJACgCACEAA0AgACgCACIUIBtPDQIgGCAUQQJ0aiIUIBQoAgBBAWo2AgAgAEEIaiEAIBNBCGsiEw0ACwsgMigCACIAQavVqtUATw0BQQAhFwJAIABBDGwiFEUEQEEEIRVBACEADAELIBQQcSIVRQ0JCyAWQQA2AhwgFiAVNgIYIBYgADYCFCAWKAIIIRwgGwRAIBtBAnQhG0EIIR8gGCEAA0AgACgCACITQf////8DSw0EIBNBAnQiFEH9////B08NBAJAIBRFBEBBBCEdQQAhEwwBCyAUEHEiHUUNCwsgAEEEaiEAIBYoAhQgF0YEQCMAQSBrIiEkAAJAIBZBFGoiIigCACIeQdWq1SpLBH9BAAVBBCAeQQF0IhQgFEEETRsiFUEMbCEUICEgHgR/ICEgHkEMbDYCHCAhICIoAgQ2AhRBBAVBAAs2AhggIUEIakEEIBQgIUEUahCFByAhKAIIQQFHDQEgISgCECEiICEoAgwLICJB9PnAABCTCQALICEoAgwhFCAiIBU2AgAgIiAUNgIEICFBIGokACAWKAIYIRULIBUgH2oiFEEANgIAIBRBBGsgHTYCACAUQQhrIBM2AgAgFiAXQQFqIhc2AhwgH0EMaiEfIBtBBGsiGw0ACwsgHARAIBhBBGsoAgAiAEF4cSITIBxBAnQiFEEEQQggAEEDcSIAG2pJDQ4gAEEAIBMgFEEnaksbDQ8gGBCiAgsgFigCGCEUAkBBuLbJACgCACIABEAgAEEDdCEYQbS2yQAoAgAhEwNAIBMoAgAiGyAXTw0CIBNBBGooAgAhACAUIBtBDGxqIhUoAggiGyAVKAIARgRAIBVB1PnAABD6BQsgFSgCBCAbQQJ0aiAANgIAIBUgG0EBajYCCCATQQhqIRMgGEEIayIYDQALCxDBCSEiIBdFDQ0gFCAXQQxsaiEYICNBMGohGyAUQQxqIQBBfyElIBQhEwNAIBMoAghB//8AakGAgP//A3EQtgkiHkEAIBMoAggQ4QghHyATKAIEIRUgEygCCCEcIB8QuAohHSAWIBw2AiQgFiAdNgIgIBwgHUcNBSAfIBUgHBDgCSAfQYQITwRAIB8QmwcLEL8JIRwCQCAlQQFqIiUgIEcEQCAbKAIAIRUgHEGw8sAAQQUQ7AgiHSAVuBC3CSIVEMAJQbS7yQAtAABFDQFBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgFiAANgIoQdjmyABBKyAWQShqQdjowABBtPnAABDgBgALICAgIEGE+cAAEIwHAAtBuLvJAEEANgIAQbS7yQBBADoAACAVQYQITwRAIBUQmwcLIB1BhAhPBEAgHRCbBwsgHEG56MAAQQkQ7AgiFSATKAIIuBC3CSITEMAJQbS7yQAtAAANBkG4u8kAQQA2AgBBtLvJAEEAOgAAIBNBhAhPBEAgExCbBwsgFUGECE8EQCAVEJsHCyAcQaj0wABBBxDsCCITIB4QwAlBtLvJAC0AAA0HQbi7yQBBADYCAEG0u8kAQQA6AAAgHkGECE8EQCAeEJsHCyATQYQITwRAIBMQmwcLICIgHBDiCSAcQYQITwRAIBwQmwcLIAAiEyAYRiIADQ4gG0HQAGohGyATQQBBDCAAG2ohACATDQALDA0LIBsgF0HE+cAAEIwHAAsgFCAbQYT6wAAQjAcAC0HU98AAEP8HAAtB5PnAABD/BwALIBZBADYCKEEAIBZBIGogFkEkaiAWQShqQeD5xAAQ9QcAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACAWIAA2AihB2ObIAEErIBZBKGpB2OjAAEGk+cAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgFiAANgIoQdjmyABBKyAWQShqQdjowABBlPnAABDgBgALQbT7wAAQsQoAC0Hg/8YAEP8HCwALQayKwQAQsAoACyAcIBRBtPrAABCMBwALICwgLEGk+sAAEIwHAAsQwQkhHUHEtskAKAIAIgAEQCAAQQN0IRhBwLbJACgCACETA0AgE0EEaigCACEbIBMoAgAhABDBCSIVIAC4ELcJIgAQ4gkgAEGECE8EQCAAEJsHCyAVIBu4ELcJIgAQ4gkgAEGECE8EQCAAEJsHCyAdIBUQ4gkgFUGECE8EQCAVEJsHCyATQQhqIRMgGEEIayIYDQALCxC/CSIYQeT3wABBChDsCCITIDm7ELcJIgAQwAkCQAJAAkACQAJAAkBBtLvJAC0AAEUEQEG4u8kAQQA2AgBBtLvJAEEAOgAAIABBhAhPBEAgABCbBwsgE0GECE8EQCATEJsHCyAYQe73wABBDxDsCCIAICIQwAlBtLvJAC0AAA0BQbi7yQBBADYCAEG0u8kAQQA6AAAgIkGECE8EQCAiEJsHCyAAQYQITwRAIAAQmwcLIBhB/ffAAEEGEOwIIgAgHRDACUG0u8kALQAADQJBuLvJAEEANgIAQbS7yQBBADoAACAdQYQITwRAIB0QmwcLIABBhAhPBEAgABCbBwsgGEGD+MAAQQoQ7AgiEyAkuBC3CSIAEMAJQbS7yQAtAAANA0G4u8kAQQA2AgBBtLvJAEEAOgAAIABBhAhPBEAgABCbBwsgE0GECE8EQCATEJsHCyAYQY34wABBDBDsCCITIBm4ELcJIgAQwAlBtLvJAC0AAA0EQbi7yQBBADYCAEG0u8kAQQA6AAAgAEGECE8EQCAAEJsHCyATQYQITwRAIBMQmwcLIBhBmfjAAEEJEOwIIhMgJ7cQtwkiABDACUG0u8kALQAADQVBuLvJAEEANgIAQbS7yQBBADoAACAAQYQITwRAIAAQmwcLIBNBhAhPBEAgExCbBwsgFwRAIBQhAANAIAAoAgAiGQRAIABBBGooAgAiFUEEaygCACITQXhxIhsgGUECdCIZQQRBCCATQQNxIhMbakkNCiATQQAgGyAZQSdqSxsNCyAVEKICCyAAQQxqIQAgF0EBayIXDQALCyAWKAIUIhMEQCAUQQRrKAIAIgBBeHEiGSATQQxsIhNBBEEIIABBA3EiABtqSQ0IIABBACAZIBNBJ2pLGw0JIBQQogILAkAgIEUNACAgQQNxIRNBACEVICBBBE8EQCAjQZQCaiEAICBB/P//D3EhGQNAIABB8AFrKAIAIhQgFCgCAEEBazYCACAAQaABaygCACIUIBQoAgBBAWs2AgAgAEHQAGsoAgAiFCAUKAIAQQFrNgIAIAAoAgAiFCAUKAIAQQFrNgIAIABBwAJqIQAgGSAVQQRqIhVHDQALCyATRQ0AIBVB0ABsICNqQSRqIQADQCAAKAIAIhQgFCgCAEEBazYCACAAQdAAaiEAIBNBAWsiEw0ACwsgKARAICNBBGsoAgAiAEF4cSITIChB0ABsIhRBBEEIIABBA3EiABtySQ0IIABBACATIBRBJ2pLGw0HICMQogILQbi1yQBBuLXJACgCAEEBajYCACAaIBg2AgQgGkEANgIAIBZBQGskAAwJC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACAWIAA2AihB2ObIAEErIBZBKGpB2OjAAEH0+MAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgFiAANgIoQdjmyABBKyAWQShqQdjowABB5PjAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIBYgADYCKEHY5sgAQSsgFkEoakHY6MAAQdT4wAAQ4AYAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACAWIAA2AihB2ObIAEErIBZBKGpB2OjAAEHE+MAAEOAGAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgFiAANgIoQdjmyABBKyAWQShqQdjowABBtPjAABDgBgALQbS7yQBBADoAAEG4u8kAKAIAIQBBuLvJAEEANgIAIBYgADYCKEHY5sgAQSsgFkEoakHY6MAAQaT4wAAQ4AYACwwBC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgGigCBCEAIBooAgAMBwtBgPXAAEEYEOwIDAULQYT2wABBHhDsCAwEC0Hr9cAAQRkQ7AgMAwtBzfXAAEEeEOwIDAILQbH1wABBHBDsCAwBC0GY9cAAQRkQ7AgLIQBBAQshGQJAAkACQCASBEAgEUEEaygCACIoQXhxIhMgEkECdCIUQQRBCCAoQQNxIhIbakkNASASQQAgEyAUQSdqSxsNAiAREKICCyAQBEAgD0EEaygCACIUQXhxIhIgEEECdCIRQQRBCCAUQQNxIhAbakkNASAQQQAgEiARQSdqSxsNAiAPEKICCyAOBEAgDUEEaygCACIRQXhxIhAgDkECdCIPQQRBCCARQQNxIg4bakkNASAOQQAgECAPQSdqSxsNAiANEKICCyAMBEAgC0EEaygCACIPQXhxIg4gDEECdCINQQRBCCAPQQNxIgwbakkNASAMQQAgDiANQSdqSxsNAiALEKICCyAKBEAgCUEEaygCACINQXhxIgwgCkECdCILQQRBCCANQQNxIgobakkNASAKQQAgDCALQSdqSxsNAiAJEKICCyAIBEAgB0EEaygCACILQXhxIgogCEECdCIJQQRBCCALQQNxIggbakkNASAIQQAgCiAJQSdqSxsNAiAHEKICCyAGBEAgBUEEaygCACIJQXhxIgggBkECdCIHQQRBCCAJQQNxIgYbakkNASAGQQAgCCAHQSdqSxsNAiAFEKICCyAEBEAgA0EEaygCACIHQXhxIgYgBEECdCIFQQRBCCAHQQNxIgQbakkNASAEQQAgBiAFQSdqSxsNAiADEKICCyAmIBlBAXEiAzYCCCAmIABBACADGzYCBCAmQQAgACADGzYCACAaQeAAaiQADAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAmKAIAICYoAgQgJigCCCAmQRBqJAALTQEBfwJ/AkAgAigCBEUNACACKAIIIgNFDQAgAigCACADQQEgARC7AgwBCyABEHELIQIgACABNgIIIAAgAkEBIAIbNgIEIAAgAkU2AgALSwIBfwJ+IwBBEGsiASQAIAEgADUCiAEgADUChAF+QgRCAyAALQCTARsQ3QYgASkDCCECIAEpAwAhAyABQRBqJABCfyADIAJCAFIbC08AAkACQCACKAIQQQFGBEAgASgChAEgAigCFEsNAQsgAigCGEEBRw0BIAEoAogBIAIoAhxNDQELIABCAjcDCCAAQQM2AgAPCyAAQQY2AgALUAEBfyMAQRBrIgIkACACQQhqIAEgASgCACgCBBEBACACIAIoAgggAigCDCgCGBEBACACKAIEIQEgACACKAIANgIAIAAgATYCBCACQRBqJAALSAEBfyAAKAIAIAAoAggiA2sgAkkEQCAAIAMgAhD3BSAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0gBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQ+AUgACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtIAQF/IAAoAgAgACgCCCIDayACSQRAIAAgAyACEO8FIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIQQALRQEBfwJAIAFBAE4EfyABRQRAQQEhAkEAIQEMAgsgARBxIgINAUEBBSACCyABQcDowQAQkwkACyAAIAI2AgQgACABNgIAC08BAn8gACgCBCECIAAoAgAhAwJAIAAoAggiAC0AAEUNACADQbyLwwBBBCACKAIMEQAARQ0AQQEPCyAAIAFBCkY6AAAgAyABIAIoAhARAgALSgECfyAAIAAoAgQiAyACazYCBCAAIAAoAgAgAiADS3IiBDYCAEEBIQMgBAR/IAMFIAAoAggiACgCACABIAIgACgCBCgCDBEAAAsLSAEBfwJAIAFB4QBrIgFB/wFxQRlLBEBBACEBDAELIAFBAnRB/AdxIgIoAtSQSSEBIAIoAuyPSSECCyAAIAI2AgQgACABNgIAC0kCAn8BfSABKAIIIgNBgICAAXEhAiAAKgIAIQQgA0GAgICAAXFFBEAgASAEIAJBAEdBABD3Ag8LIAEgBCACQQBHIAEvAQ4QvQILRwECfyAALQANIgJBgAFNBEAgASgCACAAIAAtAAwiA2ogAiADayABKAIEKAIMEQAADwsgASgCACAAKAIAIAEoAgQoAhARAgALyQIAAkAgACACTQRAIAAgAU0gASACS3INASMAQTBrIgIkACACIAE2AgQgAiAANgIAIAJBAjYCDCACQfydwgA2AgggAkICNwIUIAIgAkEEaq1CgICAgBCENwMoIAIgAq1CgICAgBCENwMgIAIgAkEgajYCECACQQhqIAMQjQgACyMAQTBrIgEkACABIAI2AgQgASAANgIAIAFBAjYCDCABQaidwgA2AgggAUICNwIUIAEgAUEEaq1CgICAgBCENwMoIAEgAa1CgICAgBCENwMgIAEgAUEgajYCECABQQhqIAMQjQgACyMAQTBrIgAkACAAIAI2AgQgACABNgIAIABBAjYCDCAAQcidwgA2AgggAEICNwIUIAAgAEEEaq1CgICAgBCENwMoIAAgAK1CgICAgBCENwMgIAAgAEEgajYCECAAQQhqIAMQjQgAC0IBAX8jAEEgayIDJAAgA0EANgIQIANBATYCBCADQgQ3AgggAyABNgIcIAMgADYCGCADIANBGGo2AgAgAyACEI0IAAuJDQMHfwV+AXwgASgCCCIDQYCAgAFxIQIgACsDACEOIANBgICAgAFxRQRAIAJBAEchA0EAIQIjAEGAAWsiACQAIA69IQkCf0EDIA6ZRAAAAAAAAPB/YQ0AGkECIAlCgICAgICAgPj/AIMiCkKAgICAgICA+P8AUQ0AGiAJQv////////8HgyINQoCAgICAgIAIhCAJQgGGQv7///////8PgyAJQjSIp0H/D3EiAhsiC0IBgyEMIApQBEBBBCANUA0BGiACQbMIayECQgEhCiAMUAwBC0KAgICAgICAICALQgGGIAtCgICAgICAgAhRIgUbIQtCAkIBIAUbIQpBy3dBzHcgBRsgAmohAiAMUAshBSAAIAI7AXggACAKNwNwIABCATcDaCAAIAs3A2AgACAFOgB6An8CQAJAAkACQCAFQf8BcSICQQFNBEBB6rPFAEEBIAlCAFMiAhshBUHqs8UAQciBwgAgAhshAiAJQj+IpyEGIABBIGogAEHgAGogAEEPahDPASAAKAIgRQ0BIABB2ABqIABBKGooAgA2AgAgACAAKQIgNwNQDAILIAJBAkYNAiAAQQI7ASBBASECQeqzxQBByIHCACAJQgBTIgQbQeqzxQBBASAEGyADGyEEIAlCP4inIANyIQMgBUH/AXFBBEYNAyAAQQM2AiggAEHsncYANgIkIABBIGoMBAsgAEHQAGogAEHgAGogAEEPahBXCyACIAUgAxshBCADIAZyIQMgACAAKAJQIAAoAlQgAC8BWEEAIABBIGoQ7AQgACgCBCECIAAoAgAMAgsgAEEDNgIoIABB853GADYCJCAAQQI7ASBBASEEQQAhA0EBIQIgAEEgagwBCyAAQQE2AiggAEGYsMUANgIkIABBIGoLIQUgACACNgJcIAAgBTYCWCAAIAM2AlQgACAENgJQIAEgAEHQAGoQvgMgAEGAAWokAA8LIAJBAEchBSABLwEOIQBBACEDIwBB8AhrIgIkACAOvSEJAn9BAyAOmUQAAAAAAADwf2ENABpBAiAJQoCAgICAgID4/wCDIgtCgICAgICAgPj/AFENABogCUL/////////B4MiDUKAgICAgICACIQgCUIBhkL+////////D4MgCUI0iKdB/w9xIgMbIgpCAYMhDCALUARAQQQgDVANARogA0GzCGshA0IBIQsgDFAMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIEGyEKQgJCASAEGyELQct3Qcx3IAQbIANqIQMgDFALIQQgAiADOwHoCCACIAs3A+AIIAJCATcD2AggAiAKNwPQCCACIAQ6AOoIAn8CQCAEQf8BcSIGQQFNBEBBdEEFIAPBIgRBAEgbIARsIgRBwP0ASQ0BQcOEwgBBJUHohMIAEOsHAAsCQAJAIAZBAkcEQEEBIQNB6rPFAEHIgcIAIAlCAFMiBhtB6rPFAEEBIAYbIAUbIQYgCUI/iKcgBXIhBSAEQf8BcUEERw0BQQIhAyACQQI7AZAIIAANAkEBIQMgAkEBNgKYCCACQZiwxQA2ApQIIAJBkAhqDAQLIAJBAzYCmAggAkHzncYANgKUCCACQQI7AZAIQQEhBkEAIQVBASEDIAJBkAhqDAMLIAJBAzYCmAggAkHsncYANgKUCCACQQI7AZAIIAJBkAhqDAILIAIgADYCoAggAkEAOwGcCCACQQI2ApgIIAJBuYPCADYClAggAkGQCGoMAQtB6rPFAEEBIAlCAFMiBhshB0Hqs8UAQciBwgAgBhsgCUI/iKchCCACQZAIaiAKIAMgAkEQaiAEQQR2QRVqIgRBgIB+QQAgAGsgAMFBAEgbIgMQ6QIgA8EhAwJAIAIoApAIBEAgAkHICGogAkGYCGooAgA2AgAgAiACKQKQCDcDwAgMAQsgAkHACGogAkHQCGogAkEQaiAEIAMQZQsgByAFGyEGIAUgCHIhBSADIAIuAcgIIgRIBEAgAkEIaiACKALACCACKALECCAEIAAgAkGQCGoQ7AQgAigCDCEDIAIoAggMAQtBAiEDIAJBAjsBkAggAEUEQEEBIQMgAkEBNgKYCCACQZiwxQA2ApQIIAJBkAhqDAELIAIgADYCoAggAkEAOwGcCCACQQI2ApgIIAJBuYPCADYClAggAkGQCGoLIQAgAiADNgLMCCACIAA2AsgIIAIgBTYCxAggAiAGNgLACCABIAJBwAhqEL4DIAJB8AhqJAALQwEBfyMAQRBrIgIkACACQQhqIAEoAggiASABKAIAKAIEEQEAIAIoAgwhASAAIAIoAgg2AgAgACABNgIEIAJBEGokAAtBAAJAIAAoAiQiACgCBEEDRwRAIABBBGohAAwBCyAAIAAoAgAoAhgRBAAiAA0AQYjxwQBBGEGg8cEAEKsHAAsgAAuhAQEDfyAAKAIAIQAgASgCCCIDQYCAgBBxRQRAIANBgICAIHFFBEAgACABELMGDwsgACABENkGDwsgAC0AACEAIwBBEGsiBCQAQQMhAgNAIAIgBGpBDGogAEEPcUHctsUAai0AADoAACAAIgNBBHYhACACQQFrIQIgA0EPSw0ACyABQQFBhLTFAEECIAIgBGpBDWpBAyACaxDIAyAEQRBqJAALMgECfyABQf8BcSEDQQAhAQNAIAAQtAogAkEBdHIhAiABQQFqIgFB/wFxIANJDQALIAILOAEBfyMAQRBrIgIkACACQQhqIAAgACgCACgCBBEBACACKAIIIAEgAigCDCgCEBECACACQRBqJAAL7g8CA34VfyMAQRBrIhMkACMBQQFrIhYkASAWIAgmASAAIRogAiEbQbC1yQAoAgBFBEAQVgsCQAJAAkBBuLXJACgCAEUEQEG4tckAQX82AgAgFiUBEB4hHgJAIAcgBSADIAEgASADSxsiACAAIAVLGyIAIAAgB0sbIh9FDQADQCAXIgAgHkYNASAWJQEgABAfIQgQ2gQiGCAIJgECQAJAQcy1yQAoAgBFDQAgAEEBaiEXIAYgAEECdCIAaigCACERIAAgBGooAgAhDyAAIBtqKAIAIRxBACEMQcS1yQAoAgAiAkHYtckAKQMAIgkgACAaaigCACIdrYUiCkI4hiAKQoD+A4NCKIaEIApCgID8B4NCGIYgCkKAgID4D4NCCIaEhCAJQgiIQoCAgPgPgyAJQhiIQoCA/AeDhCAJQiiIQoD+A4MgCUI4iISEhELSgaqbq/qC16d/fiIJQjiGIAlCgP4Dg0IohoQgCUKAgPwHg0IYhiAJQoCAgPgPg0IIhoSEIAlCCIhCgICA+A+DIAlCGIhCgID8B4OEIAlCKIhCgP4DgyAJQjiIhISEIApC2KLR78Kp5b8tfoUiCUI4hiAJQoD+A4NCKIaEIAlCgID8B4NCGIYgCUKAgID4D4NCCIaEhCAJQgiIQoCAgPgPgyAJQhiIQoCA/AeDhCAJQiiIQoD+A4MgCUI4iISEhEHQtckAKQMAIgpCf4V+IgtCOIYgC0KA/gODQiiGhCALQoCA/AeDQhiGIAtCgICA+A+DQgiGhIQgC0IIiEKAgID4D4MgC0IYiEKAgPwHg4QgC0IoiEKA/gODIAtCOIiEhIQgCSAKQjiGIApCgP4Dg0IohoQgCkKAgPwHg0IYhiAKQoCAgPgPg0IIhoSEIApCCIhCgICA+A+DIApCGIhCgID8B4OEIApCKIhCgP4DgyAKQjiIhISEfoUgCYkiCadxIQ0gCUIZiEL/AINCgYKEiJCgwIABfiELQcC1yQAoAgAiAEEgayEOA0AgACANaikAACIKIAuFIglCf4UgCUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIJUEUEQANAIB0gDiAJeqdBA3YgDWogAnEiFEEFdGsoAgBGDQQgCUIBfSAJgyIJUEUNAAsLIAogCkIBhoNCgIGChIiQoMCAf4NQRQ0BIA0gDEEIaiIMaiACcSENDAALAAtB6PLAABDdCQALIA9BEHYhDSARQRB2IBFB//8DcUEAR2oiGSAcQRB2Ig9qIhIgAEEAIBRrQQV0aiIOQRRrIhQoAgAiAksEQCASIAIiAGsiDCAOQRxrIhAoAgAgAGtLBEAgECAAIAxBBEEEEKQFIBQoAgAhAAsgDkEYaygCACIVIABBAnRqIRAgDEECTwR/IAJBf3MgEmpBAnQiAgRAIBBB/wEgAvwLAAsgACAMaiICQQFrIQAgFSACQQJ0akEEawUgEAtBfzYCACAUIABBAWo2AgALIA0gGWoiECAOQQhrIhIoAgAiAksEQCAQIAIiAGsiDCAOQRBrIhUoAgAgAGtLBEAgFSAAIAxBBEEEEKQFIBIoAgAhAAsgDkEMaygCACIgIABBAnRqIRUgDEECTwR/IAJBf3MgEGpBAnQiAgRAIBVB/wEgAvwLAAsgACAMaiICQQFrIQAgICACQQJ0akEEawUgFQtBfzYCACASIABBAWo2AgALAkACQAJAAkACQAJAAkAgGCICELkKRQRAIBENAUEAIREMBQsgEQRAIA9BAnQhDCANQQJ0IQAgDkEMayEYIA5BGGshDgNAIA8gFCgCACIRTw0DIA4oAgAgDGpBfzYCACANIBIoAgAiEU8NBCAYKAIAIABqQX82AgAgDEEEaiEMIA9BAWohDyAAQQRqIQAgDUEBaiENIBlBAWsiGQ0ACwsgAkGDCEsNBQwGCyAPQQJ0IQwgDUECdCEAIA5BDGshGCAOQRhrIQ4DQCAPIBQoAgAiEE8NAyAOKAIAIAxqIA02AgAgEigCACIQIA1LBEAgGCgCACAAaiAPNgIAIAxBBGohDCAPQQFqIQ8gAEEEaiEAIA1BAWohDSAZQQFrIhlFDQUMAQsLIA0gEEGI88AAEIwHAAsgDyARQZjzwAAQjAcACyANIBFBqPPAABCMBwALIA8gEEH48sAAEIwHAAsgHSAcIBEgAhDTASACQYQISQ0BCyACEJsHCyAXIB9HDQALCxC/CSEAQbi1yQBBuLXJACgCAEEBajYCACAHBEAgBkEEaygCACICQXhxIhcgB0ECdCIHQQRBCCACQQNxIgIbakkNAiACQQAgFyAHQSdqSxsNAyAGEKICCyAFBEAgBEEEaygCACICQXhxIgYgBUECdCIFQQRBCCACQQNxIgIbakkNAiACQQAgBiAFQSdqSxsNAyAEEKICCyADBEAgG0EEaygCACICQXhxIgQgA0ECdCIDQQRBCCACQQNxIgIbakkNAiACQQAgBCADQSdqSxsNAyAbEKICCwJAIAEEQCAaQQRrKAIAIgJBeHEiAyABQQJ0IgFBBEEIIAJBA3EiAhtqSQ0DIAJBACADIAFBJ2pLGw0BIBoQogILIBNCADcCBCATIAA2AgAMBAsMAgtBrIrBABCwCgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAW0G9BAfwRASAWQQFqJAEgEygCACATKAIEIBMoAgggE0EQaiQACzgAAkAgAkGAgMQARg0AIAAgAiABKAIQEQIARQ0AQQEPCyADRQRAQQAPCyAAIAMgBCABKAIMEQAAC+ACAgR/An4jAEEQayIJJAAQ2gQiCyAEJgEjAEEwayIIJABBgICAgHghCgJAIABFBEBBgICAgHghAQwBCyAArSABrUIghoQhDAsgAgRAIAKtIAOtQiCGhCENIAMhCgsgCCAMNwIcIAggATYCGCAIIA03AiggCCAKNgIkIAZBAEchACAFQQBHIQECQCAHRQRAIAhBCGogCEEYaiAIQSRqIAsgASAFIAAgBkEAQQAQvwEMAQsgCEEIaiAIQRhqIAhBJGogCyABIAUgACAGQQEgBxC/AQsCQAJAAn8gCCgCCEUEQEEBIQAgCCgCDAwBC0EcEHEiAUUNAUEAIQAgAUEANgIIIAFCgYCAgBA3AgAgASAI/QACCP0LAgwgAUEIagshASAJIAA2AgggCSABQQAgABs2AgQgCUEAIAEgABs2AgAgCEEwaiQADAELAAsgCSgCACAJKAIEIAkoAgggCUEQaiQACzkBAX8jAEEQayIFJAAgBSACNgIMIAUgATYCCCAAIAVBCGpB4IfDACAFQQxqQeCHwwAgAyAEEPIEAAtEACABKQIAQu26rbbNhdT14wCFIAEpAghC+IKZvZXuxsW5f4WEUEUEQCAAKAIkIgAgASAAKAIAKAIQEQIADwsgAEEcags5AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AghBACAEQQhqQcS2xAAgBEEMakHEtsQAIAIgAxDyBAAL4AEBBH8jAEEQayICJAAgAiAANgIMIwBBEGsiACQAIAEoAgBBmK3HAEENIAEoAgQoAgwRAAAhAyAAQQA6AA0gACADOgAMIAAgATYCCCAAQQhqQcj7xwBBBCACQQxqQfS3xQAQjAUhAyAALQANIgQgAC0ADCIFciEBAkAgBUEBcSAEQQFHcg0AIAMoAgAiAS0ACkGAAXFFBEAgASgCAEH/s8UAQQIgASgCBCgCDBEAACEBDAELIAEoAgBBpbPFAEEBIAEoAgQoAgwRAAAhAQsgAEEQaiQAIAFBAXEgAkEQaiQACzkBAX8jAEEQayIFJAAgBSACNgIMIAUgATYCCCAAIAVBCGpB3JzIACAFQQxqQdycyAAgAyAEEPIEAAs8AQJ/IAEoAgQhAiABKAIAIQNBCBBxIgFFBEAACyABIAI2AgQgASADNgIAIABBvIzIADYCBCAAIAE2AgALPwEBfyMAQRBrIgIkACACQZvRwAA2AgwgAiAANgIIQQAgAkEIakHohsgAIAJBDGpB6IbIACABQciDyAAQ8gQAC5EDAQV/IwBBEGsiCCQAENoEIgogASYBIAAhCxDaBCIAIAYmASAFIQkjAEHgAWsiByQAIAJBAEchBQJAIAlFBEAgB0H4AGogCyAKIAUgAiAAEGcgBygCfCEFIAcoAngiAEGAgICAeEYEQEEBIQIMAgsgB0EYaiAHQYABakHgAPwKAAAgByAFNgIUIAcgADYCECAHQRBqIgAgAyAEQQBHEDAgByAAEPsDIAcoAgQhBSAHKAIAIQIgABD2AgwBCyAHQfgAaiALIAogBSACIAAQZyAHKAJ8IQUgBygCeCIAQYCAgIB4RgRAIAlBhAhPBEAgCRCbBwtBASECDAELIAdBGGogB0GAAWpB4AD8CgAAIAcgBTYCFCAHIAA2AhAgB0EQaiIAIAkQxAIgACADIARBAEcQMCAHQQhqIAAQ+wMgBygCDCEFIAcoAgghAiAAEPYCCyAIIAJBAXEiADYCCCAIIAVBACAAGzYCBCAIQQAgBSAAGzYCACAHQeABaiQAIAgoAgAgCCgCBCAIKAIIIAhBEGokAAv6AwEFfyMAQRBrIggkABDaBCIHIAEmARDaBCIJIAImASAHIQojAEGgAWsiByQAIANBAEchCwJAIAZFBEAgB0HYAGogACAKIAkgCyADEDsgBygCXCEAIAcoAlgiA0GAgICAeEYEQEEBIQMMAgsgB0HIAGogB0GQAWr9AAIA/QsCACAHQThqIAdBgAFq/QACAP0LAgAgB0EoaiAHQfAAav0AAgD9CwIAIAcgB/0AAmD9CwIYIAcgADYCFCAHIAM2AhAgB0EQaiIGIAQgBUEARxAvIAcgBhCDBSAHKAIEIQAgBygCACEDIAYQ9QIMAQsgB0HYAGogACAKIAkgCyADEDsgBygCXCEAIAcoAlgiA0GAgICAeEYEQCAGQYQITwRAIAYQmwcLQQEhAwwBCyAHQcgAaiAHQZABav0AAgD9CwIAIAdBOGogB0GAAWr9AAIA/QsCACAHQShqIAdB8ABq/QACAP0LAgAgByAH/QACYP0LAhggByAANgIUIAcgAzYCECAAIAcoAhggBhCtAyAHQRBqIgYgBCAFQQBHEC8gB0EIaiAGEIMFIAcoAgwhACAHKAIIIQMgBhD1AgsgCCADQQFxIgM2AgggCCAAQQAgAxs2AgQgCEEAIAAgAxs2AgAgB0GgAWokACAIKAIAIAgoAgQgCCgCCCAIQRBqJAAL0wICA38CfiMAQRBrIggkACMAQTBrIgckAEGAgICAeCEJAkAgAEUEQEGAgICAeCEBDAELIACtIAGtQiCGhCEKCyACBEAgAq0gA61CIIaEIQsgAyEJCyAHIAo3AhwgByABNgIYIAcgCzcCKCAHIAk2AiQgBUEARyEAIARBAEchAQJAIAZFBEAgB0EIaiAHQRhqIAdBJGogASAEIAAgBUEAQQAQ2AEMAQsgB0EIaiAHQRhqIAdBJGogASAEIAAgBUEBIAYQ2AELAkACQAJ/IAcoAghFBEBBASEAIAcoAgwMAQtBHBBxIgFFDQFBACEAIAFBADYCCCABQoGAgIAQNwIAIAEgB/0AAgj9CwIMIAFBCGoLIQEgCCAANgIIIAggAUEAIAAbNgIEIAhBACABIAAbNgIAIAdBMGokAAwBCwALIAgoAgAgCCgCBCAIKAIIIAhBEGokAAs3AQF/IwBBIGsiASQAIAFBADYCGCABQQE2AgwgAUH07sEANgIIIAFCBDcCECABQQhqIAAQjQgACzoBAX8jAEEgayIAJAAgAEEANgIYIABBATYCDCAAQdycwgA2AgggAEIENwIQIABBCGpB5JzCABCNCAALNwEBfyMAQSBrIgEkACABQQA2AhggAUEBNgIMIAFBlIfDADYCCCABQgQ3AhAgAUEIaiAAEI0IAAs3AQF/IwBBIGsiASQAIAFBADYCGCABQQE2AgwgAUHYh8MANgIIIAFCBDcCECABQQhqIAAQjQgAC/ADAQV/IwBBEGsiByQAENoEIgYgASYBENoEIgggAiYBIAYhCSMAQaABayIGJAAgA0EARyEKAkAgBUUEQCAGQdgAaiAAIAkgCCAKIAMQOyAGKAJcIQAgBigCWCIDQYCAgIB4RgRAQQEhAwwCCyAGQcgAaiAGQZABav0AAgD9CwIAIAZBOGogBkGAAWr9AAIA/QsCACAGQShqIAZB8ABq/QACAP0LAgAgBiAG/QACYP0LAhggBiAANgIUIAYgAzYCECAGQRBqIgUgBBAuIAYgBRCDBSAGKAIEIQAgBigCACEDIAUQ9QIMAQsgBkHYAGogACAJIAggCiADEDsgBigCXCEAIAYoAlgiA0GAgICAeEYEQCAFQYQITwRAIAUQmwcLQQEhAwwBCyAGQcgAaiAGQZABav0AAgD9CwIAIAZBOGogBkGAAWr9AAIA/QsCACAGQShqIAZB8ABq/QACAP0LAgAgBiAG/QACYP0LAhggBiAANgIUIAYgAzYCECAAIAYoAhggBRCtAyAGQRBqIgUgBBAuIAZBCGogBRCDBSAGKAIMIQAgBigCCCEDIAUQ9QILIAcgA0EBcSIDNgIIIAcgAEEAIAMbNgIEIAdBACAAIAMbNgIAIAZBoAFqJAAgBygCACAHKAIEIAcoAgggB0EQaiQAC4cDAQV/IwBBEGsiByQAENoEIgkgASYBIAAhChDaBCIAIAUmASAEIQgjAEHgAWsiBiQAIAJBAEchBAJAIAhFBEAgBkH4AGogCiAJIAQgAiAAEGcgBigCfCEEIAYoAngiAEGAgICAeEYEQEEBIQIMAgsgBkEYaiAGQYABakHgAPwKAAAgBiAENgIUIAYgADYCECAGQRBqIgAgAxAtIAYgABD7AyAGKAIEIQQgBigCACECIAAQ9gIMAQsgBkH4AGogCiAJIAQgAiAAEGcgBigCfCEEIAYoAngiAEGAgICAeEYEQCAIQYQITwRAIAgQmwcLQQEhAgwBCyAGQRhqIAZBgAFqQeAA/AoAACAGIAQ2AhQgBiAANgIQIAZBEGoiACAIEMQCIAAgAxAtIAZBCGogABD7AyAGKAIMIQQgBigCCCECIAAQ9gILIAcgAkEBcSIANgIIIAcgBEEAIAAbNgIEIAdBACAEIAAbNgIAIAZB4AFqJAAgBygCACAHKAIEIAcoAgggB0EQaiQAC8ECAQR/IwBBEGsiASQAQdy2yQAtAABBA0cEQCABQQE6AA8gAUEPaiECIwBBIGsiACQAAkACQAJAAkACQAJAAkACQAJAQdy2yQAtAABBAWsOAwQDAQALQdy2yQBBAjoAACACLQAAIAJBADoAAEUNBEGUu8kAKAIAQf////8HcQRAQYy7yQAoAgANBgtBmLvJACgCAA0BQdy2yQBBAzoAAEGcu8kAQQE2AgALIABBIGokAAwGCwALIABBADYCGCAAQQE2AgwgAEGYg8gANgIIDAMLIABBADYCGCAAQQE2AgwgAEGUisEANgIIDAILQZyKwQAQ3QkACyAAQQA2AhggAEEBNgIMIABB0IbIADYCCCAAQgQ3AhAgAEEIakHYhsgAEI0IAAsgAEIENwIQIABBCGpB0OrAABCNCAALCyABQRBqJAALLgACQCADaUEBRyABQYCAgIB4IANrS3JFBEAgACABIAMgAhC7AiIADQELAAsgAAvzCgIJfwJ+IwBBEGsiCSQAENoEIgogBCYBIAMhCCMAQeACayIFJABBgICAgHghAwJAIABFBEBBgICAgHghAQwBCyAArSABrUIghoQhDgsgAgRAIAKtIAitQiCGhCEPIAghAwsgD6chCEEGIQcCQAJAAkACQAJAIAkCfwJAAkACQAJAIAFBgICAgHhGDQAgBUEUaiAOpyIAIA5CIIinEJEFIAUtABRBAUYEQCAFKAIYIQYgBUEANgL8ASAFQoCAgIAQNwL0ASAFQZyTwQA2AoQCIAVCoICAgA43AogCIAUgBUH0AWo2AoACIAYgBUGAAmoQrwQNAiAFKAL0ASEHIAUoAvgBIgsgBSgC/AEQ7AghAiAHBEAgC0EEaygCACIMQXhxIg1BBEEIIAxBA3EiDBsgB2pJDQkgDEEAIA0gB0EnaksbDQogCxCiAgsgBiAGKAIAKAIAEQMAIAEEQCAAQQRrKAIAIgZBeHEiB0EEQQggBkEDcSIGGyABakkNCSAGQQAgByABQSdqSxsNCiAAEKICCyAKQYQISQ0EIAoQmwcMBAsgBS0AFSEHIAFFDQAgAEEEaygCACICQXhxIgZBBEEIIAJBA3EiAhsgAWpJDQcgAkEAIAYgAUEnaksbDQggABCiAgtBAiEBIAoQuQoiDEUEQCAFQYACaiAKELUBIAUoAoACIQIgBS0AnAIiAUECRg0DIAVBMGogBUGUAmopAgA3AwAgBUEeaiAFQZ8Cai0AADoAACAFIAX9AAKEAv0LAyAgBSAFLwCdAjsBHAsgBUGTAWogBUEeai0AADoAACAFQYgBaiAFQTBqKQMANwIAIAUgBS8BHDsAkQEgBSACNgJ0IAVBADYCcCAFQoCAgIAQNwJoIAVCATcCYCAFQgA3AlggBUKAgICAEDcCUCAFQgQ3AkggBUIANwJAIAVCgICAgMAANwI4IAUgBf0AAyD9CwJ4IAVBADYClAEgBSABOgCQAQJ/IAdBBkcEQCAFQQhqIAcgBUE4ahDZAyAFKAIMIQYgBSgCCCELQYCAgIB4DAELIAVBgAJqIAVBPGpB3AD8CgAAQQALIQ1BgICAgHghASADQYCAgIB4RwRAIA9CIIinIQFBASECIA9CgICAgBBaBEAgARBxIgJFDQcLIAEEQCACIAggAfwKAAALIAKtIA9CgICAgHCDhCEOCyAFQZgBaiICIAVBgAJqQdwA/AoAAEGQARBxIgBFDQUgACANNgIYIAAgDjcCECAAIAE2AgwgAEEANgIIIABCgICAgBA3AgAgAEEcaiACQdwA/AoAACAAIAc6AIwBIAAgBjYCiAEgACALNgKEASAAQYCAgIB4NgJ4IAxFIApBhAhJcg0BIAoQmwcMAQtBoJ7GAEE3IAVB3wJqQbSTwQBB2J7GABDgBgALAkAgA0GAgICAeHJBgICAgHhHBEAgCEEEaygCACIBQXhxIgJBBEEIIAFBA3EiARsgA2pJDQYgAUEAIAIgA0EnaksbDQEgCBCiAgtBHBBxIgFFDQQgAUGg78AANgIYIAFBATYCFCABQYjvwAA2AhAgASAANgIMIAFBADYCCCABQoGAgIAQNwIAIAFBCGohAkEADAILDAULIANBgICAgHhyQYCAgIB4RwRAIAhBBGsoAgAiAEF4cSIBQQRBCCAAQQNxIgAbIANqSQ0EIABBACABIANBJ2pLGw0CIAgQogILQQELIgA2AgggCSACQQAgABs2AgQgCUEAIAIgABs2AgAgBUHgAmokAAwEC0GMjcgAQS5BvI3IABDrBwsAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgCSgCACAJKAIEIAkoAgggCUEQaiQACzcBAX9BASEAIAEoAgAiAkGlgcIAQQMgASgCBCgCDCIBEQAABH8gAAUgAkH7gcIAQQcgAREAAAsL9wEBBH8jAEEQayIFJAAQ2gQiBiABJgEQ2gQiBCADJgEgAiEHIAQhAiMAQdAAayIEJAACQCAHRQRAIARBCGogACAGQQBBACACEGkMAQsgBEEIaiAAIAZBASAHIAIQaQsCQAJAIAUCfyAEKAIIQYCAgIB4RgRAIAQoAgwhAEEBDAELQdQAEHEiAEUNASAAQQA2AgggAEKBgICAEDcCACAAQQxqIARBCGpByAD8CgAAIABBCGohAEEACyICNgIIIAUgAEEAIAIbNgIEIAVBACAAIAIbNgIAIARB0ABqJAAMAQsACyAFKAIAIAUoAgQgBSgCCCAFQRBqJAAL9QEBBH8jAEEQayIFJAAQ2gQiBCABJgEQ2gQiBiACJgEgBCEHIwBB0ABrIgQkAAJAIANFBEAgBEEIaiAAIAcgBkEAQQAQOwwBCyAEQQhqIAAgByAGQQEgAxA7CwJAAkACfyAEKAIIQYCAgIB4RgRAQQEhACAEKAIMDAELQdQAEHEiA0UNAUEAIQAgA0EANgIIIANCgYCAgBA3AgAgA0EMaiAEQQhqQcgA/AoAACADQQhqCyEDIAUgADYCCCAFIANBACAAGzYCBCAFQQAgAyAAGzYCACAEQdAAaiQADAELAAsgBSgCACAFKAIEIAUoAgggBUEQaiQAC5oLAgh/An4jAEEQayIIJAAgAiEHIwBB4AFrIgQkAEGAgICAeCECAkAgAEUEQEGAgICAeCEBDAELIACtIAGtQiCGhCEMCyAHBEAgB60gA61CIIaEIQ0gAyECC0GAgICAeCEDIA2nIQcCQAJAAkAgCAJ/AkACQAJAAkACQAJAIAFBgICAgHhHBEAgBEEQaiAMpyIAIAxCIIinEJEFIAQtABBBAUYEQCAEKAIUIQUgBEEANgKcASAEQoCAgIAQNwKUASAEQZyTwQA2AqQBIARCoICAgA43AqgBIAQgBEGUAWo2AqABIAUgBEGgAWoQrwQNBCAEKAKUASEGIAQoApgBIgogBCgCnAEQ7AghAyAGBEAgCkEEaygCACIJQXhxIgtBBEEIIAlBA3EiCRsgBmpJDQogCUEAIAsgBkEnaksbDQsgChCiAgsgBSAFKAIAKAIAEQMAIAEEQCAAQQRrKAIAIgVBeHEiBkEEQQggBUEDcSIFGyABakkNCiAFQQAgBiABQSdqSxsNCyAAEKICCyACQYCAgIB4ckGAgICAeEYNByAHQQRrKAIAIgBBeHEiAUEEQQggAEEDcSIAGyACakkNCSAAQQAgASACQSdqSxsNCiAHEKICQQEMCAsgBC0AESEFIAEEQCAAQQRrKAIAIgNBeHEiBkEEQQggA0EDcSIDGyABakkNCSADQQAgBiABQSdqSxsNBSAAEKICCyAEQoCAgIAgNwJIIARCAjcCQCAEQgA3AjggBEKAgICAIDcCMCAEQgQ3AiggBEIANwIgIARCgICAgMAANwIYIARCADcCUCAEQQhqIAUgBEEYahDgAkGAgICAeCEGIAQoAgwhCSAEKAIIIQpBgICAgHghAyACQYCAgIB4Rw0BDAILIARBLGoiAEIANwIAIARBPGoiAUKAgICAIDcCACAEQcwAakICNwIAIARCgICAgMAANwIkIARCBDcCHCAEQQA2AlQgBEICNwI0IARCADcCRCAEQdgBakEANgIAIARB0AFqQgI3AwAgBEHAAWogAf0AAgD9CwMAIARBsAFqIAD9AAIA/QsDACAEIAT9AAIc/QsDoAFBBiEFIAJBgICAgHhGDQELIA1CIIinIQNBASEBIA1CgICAgBBaBEAgAxBxIgFFDQQLIAMEQCABIAcgA/wKAAALIAGtIA1CgICAgHCDhCEMCyAEQZABaiIBIARB2AFqKAIANgIAIARBiAFqIARB0AFqKQMANwMAIARB+ABqIARBwAFq/QADAP0LAwAgBEHoAGogBEGwAWr9AAMA/QsDACAEIAT9AAOgAf0LA1hB8AAQcSIARQ0CIAAgBjYCGCAAIAw3AhAgACADNgIMIABBADYCCCAAQoCAgIAQNwIAIAAgBCkDWDcCHCAAIAU6AGwgACAJNgJoIAAgCjYCZCAAQYCAgIB4NgJYIABBJGogBEHgAGr9AAMA/QsCACAAQTRqIARB8ABq/QADAP0LAgAgAEHEAGogBEGAAWr9AAMA/QsCACAAQdQAaiABKAIANgIAIAJBgICAgHhyQYCAgIB4RwRAIAdBBGsoAgAiAUF4cSIDQQRBCCABQQNxIgEbIAJqSQ0GIAFBACADIAJBJ2pLGw0HIAcQogILQRwQcSICRQ0CIAJB2O/AADYCGCACQQE2AhQgAkHA78AANgIQIAIgADYCDCACQQA2AgggAkKBgICAEDcCACACQQhqIQNBAAwEC0GgnsYAQTcgBEHfAWpBtJPBAEHYnsYAEOAGAAtBjI3IAEEuQbyNyAAQ6wcLAAtBAQsiATYCCCAIIANBACABGzYCBCAIQQAgAyABGzYCACAEQeABaiQADAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyAIKAIAIAgoAgQgCCgCCCAIQRBqJAAL9wEBBH8jAEEQayIFJAAQ2gQiBiABJgEQ2gQiBCADJgEgAiEHIAQhAiMAQfAAayIEJAACQCAHRQRAIARBCGogACAGQQBBACACEGcMAQsgBEEIaiAAIAZBASAHIAIQZwsCQAJAIAUCfyAEKAIIQYCAgIB4RgRAIAQoAgwhAEEBDAELQfQAEHEiAEUNASAAQQA2AgggAEKBgICAEDcCACAAQQxqIARBCGpB6AD8CgAAIABBCGohAEEACyICNgIIIAUgAEEAIAIbNgIEIAVBACAAIAIbNgIAIARB8ABqJAAMAQsACyAFKAIAIAUoAgQgBSgCCCAFQRBqJAAL/AECAn8BfiMAQRBrIgIkACACQQE7AQwgAiABNgIIIAIgADYCBCMAQRBrIgEkACACQQRqIgApAgAhBCABIAA2AgwgASAENwIEIwBBEGsiACQAIAFBBGoiASgCACICKAIMIQMCQAJAAkACQCACKAIEDgIAAQILIAMNAUEBIQJBACEDDAILIAMNACACKAIAIgIoAgQhAyACKAIAIQIMAQsgAEGAgICAeDYCACAAIAE2AgwgAEGAhsgAIAEoAgQgASgCCCIALQAIIAAtAAkQkgYACyAAIAM2AgQgACACNgIAIABB5IXIACABKAIEIAEoAggiAC0ACCAALQAJEJIGAAsnACACIARGBEAgBARAIAMgASAE/AoAAAsPCyAEIAJB/JrFABDeCQALJgEBfyMAQRBrIgIkACABKAIEGiAAQYj7xwAgARDBAyACQRBqJAALMwAgASgCACAAKAIAKAIAQQJ0IgBB2LDJAGooAgAgAEG0sMkAaigCACABKAIEKAIMEQAAC+AFAQt/IwBBEGsiBSQAENoEIgYgASYBIwBBsANrIgIkAAJAAkACQAJAAkACQCAABEAgAEEIayIHIAcoAgBBAWoiAzYCACADRQ0BIAAoAgAiBEH/////B08NAiAAIARBAWo2AgBBAiEDAkAgBhC5CiIKRQRAIAJB5AFqIAYQtQEgAigC5AEhBCACLQCAAiIDQQJGBEBBASEDDAILIAJBIGogAkH4AWopAgA3AwAgAkEOaiACQYMCai0AADoAACACIAL9AALoAf0LAxAgAiACLwCBAjsBDAsgAkHwAWogAkEYav0AAwD9CwIAIAJBgwJqIAJBDmotAAA6AAAgAiAENgLkASACIAIpAxA3AugBIAIgAzoAgAIgAiACLwEMOwCBAiACQShqIABBBGpBACACQeQBaiIEEIQBAkAgAigCKEECRgRAIAIoAiwhAyACQQA2AqgDIAJCgICAgBA3AqADIAJBnJPBADYC6AEgAkKggICADjcC7AEgAiACQaADajYC5AEgAyAEEK8EDQYgAigCoAMhCCACKAKkAyILIAIoAqgDEOwIIQQgCARAIAtBBGsoAgAiCUF4cSIMQQRBCCAJQQNxIgkbIAhqSQ0IIAlBACAMIAhBJ2pLGw0JIAsQogILIAMgAygCACgCABEDAEEBIQMgBkGECEkNAiAKDQEMAgsgAkHkAWoiAyACQShqQbwB/AoAACADENIBIQRBACEDIApFIAZBhAhJcg0BCyAGEJsHCyAAIAAoAgBBAWs2AgAgByAHKAIAQQFrIgA2AgAgAEUEQCAHEOMGCyAFIAM2AgggBSAEQQAgAxs2AgQgBUEAIAQgAxs2AgAgAkGwA2okAAwGCxCOCgsACxCQCgALQaCexgBBNyACQa8DakG0k8EAQdiexgAQ4AYAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgBSgCACAFKAIEIAUoAgggBUEQaiQAC+AFAQt/IwBBEGsiBSQAENoEIgYgASYBIwBBsANrIgIkAAJAAkACQAJAAkACQCAABEAgAEEIayIHIAcoAgBBAWoiAzYCACADRQ0BIAAoAgAiBEH/////B08NAiAAIARBAWo2AgBBAiEDAkAgBhC5CiIKRQRAIAJB5AFqIAYQtQEgAigC5AEhBCACLQCAAiIDQQJGBEBBASEDDAILIAJBIGogAkH4AWopAgA3AwAgAkEOaiACQYMCai0AADoAACACIAL9AALoAf0LAxAgAiACLwCBAjsBDAsgAkHwAWogAkEYav0AAwD9CwIAIAJBgwJqIAJBDmotAAA6AAAgAiAENgLkASACIAIpAxA3AugBIAIgAzoAgAIgAiACLwEMOwCBAiACQShqIABBBGpBASACQeQBaiIEEIQBAkAgAigCKEECRgRAIAIoAiwhAyACQQA2AqgDIAJCgICAgBA3AqADIAJBnJPBADYC6AEgAkKggICADjcC7AEgAiACQaADajYC5AEgAyAEEK8EDQYgAigCoAMhCCACKAKkAyILIAIoAqgDEOwIIQQgCARAIAtBBGsoAgAiCUF4cSIMQQRBCCAJQQNxIgkbIAhqSQ0IIAlBACAMIAhBJ2pLGw0JIAsQogILIAMgAygCACgCABEDAEEBIQMgBkGECEkNAiAKDQEMAgsgAkHkAWoiAyACQShqQbwB/AoAACADENIBIQRBACEDIApFIAZBhAhJcg0BCyAGEJsHCyAAIAAoAgBBAWs2AgAgByAHKAIAQQFrIgA2AgAgAEUEQCAHEOMGCyAFIAM2AgggBSAEQQAgAxs2AgQgBUEAIAQgAxs2AgAgAkGwA2okAAwGCxCOCgsACxCQCgALQaCexgBBNyACQa8DakG0k8EAQdiexgAQ4AYAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgBSgCACAFKAIEIAUoAgggBUEQaiQAC58RAwx/A34CfSMAQRBrIg0kACMAQSBrIgQkAEGwtckAKAIARQRAEFYLAkACQAJAAkACfwJAAkBBuLXJACgCAEUEQEG4tckAQX82AgACQAJAQcy1yQAoAgBFDQBBxLXJACgCACIJQdi1yQApAwAiDiAArYUiD0I4hiAPQoD+A4NCKIaEIA9CgID8B4NCGIYgD0KAgID4D4NCCIaEhCAOQgiIQoCAgPgPgyAOQhiIQoCA/AeDhCAOQiiIQoD+A4MgDkI4iISEhELSgaqbq/qC16d/fiIOQjiGIA5CgP4Dg0IohoQgDkKAgPwHg0IYhiAOQoCAgPgPg0IIhoSEIA5CCIhCgICA+A+DIA5CGIhCgID8B4OEIA5CKIhCgP4DgyAOQjiIhISEIA9C2KLR78Kp5b8tfoUiEEI4hiAQQoD+A4NCKIaEIBBCgID8B4NCGIYgEEKAgID4D4NCCIaEhCAQQgiIQoCAgPgPgyAQQhiIQoCA/AeDhCAQQiiIQoD+A4MgEEI4iISEhEHQtckAKQMAIg5Cf4V+Ig9COIYgD0KA/gODQiiGhCAPQoCA/AeDQhiGIA9CgICA+A+DQgiGhIQgD0IIiEKAgID4D4MgD0IYiEKAgPwHg4QgD0IoiEKA/gODIA9COIiEhIQgECAOQjiGIA5CgP4Dg0IohoQgDkKAgPwHg0IYhiAOQoCAgPgPg0IIhoSEIA5CCIhCgICA+A+DIA5CGIhCgID8B4OEIA5CKIhCgP4DgyAOQjiIhISEfoUgEIkiD6dxIQMgD0IZiEL/AINCgYKEiJCgwIABfiEOQcC1yQAoAgAiBkEgayECA0AgAyAGaikAACIQIA6FIg9Cf4UgD0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIPUEUEQANAIAAgAiAPeqdBA3YgA2ogCXEiBUEFdGsoAgBGDQQgD0IBfSAPgyIPUEUNAAsLIBAgEEIBhoNCgIGChIiQoMCAf4NQRQ0BIAMgCEEIaiIIaiAJcSEDDAALAAtBiPTAABDdCQALIAZBACAFa0EFdGpBBGsoAgAiCigCCCIAQf////8HTw0BIAogAEEBajYCCCAKKAIUBEAgCigCEEEKai8BACIAQf//AXFFBEAgAEEQdAwFCyAAQf8HcSECIABBgIACcSEFIABBgPgBcSIAQYD4AUYEQCAFQRB0IgBBgICA/AdyIAJFDQUaIAAgAkENdHJBgICA/gdyDAULIAVBEHQhBSAARQ0DIABBDXRBgICA/ABxIAJBDXRyQYCAgMADaiAFcgwEC0EAQQBBmPTAABCMBwwEC0GsisEAELAKAAtB8PTAABCxCgALIAIgAmdBEGsiAEH//wNxQQhqdEH///8DcSAFQYCAgNgDciAAQRd0a3ILQwAAoD8hEUMAAKA/QwAAgD8gASABQR91IgBzIABrIgJBAXEbIRIgAkECTwRAA0AgEiARIBGUIhGUIBIgAkECcRshEiACQQNLIAJBAXYhAg0ACwtBBBBxIgVFDQC+QwAAgD8gEpUgEiABQQBIG5UhESAFQQA2AgAgBEEANgIQIARCgICAgMAANwIIQQQhC0EBIQhBASEDAkADQCAEQQA2AhwgBEKAgICAwAA3AhQgBSADQQJ0aiEGIAUhAANAIAAoAgAiByAKKAIUIgFPBEAgByABQcD0wAAQjAcACwJAIBECfyAKKAIQIAdBBHRqIglBCmovAQAiAUH//wFxRQRAIAFBEHQMAQsgAUH/B3EhAyABQYCAAnEhAiABQYD4AXEiAUGA+AFGBEAgAkEQdCIBQYCAgPwHciADRQ0BGiABIANBDXRyQYCAgP4HcgwBCyACQRB0IgIgAUENdEGAgID8AHEgA0ENdHJBgICAwANqciABDQAaIAMgA2dBEGsiAUH//wNxQQhqdEH///8DcSACQYCAgNgDciABQRd0a3ILvmBFBEAgCSgCACIDIAMgCS8BDCIBak8NASAEKAIcIgJBAnQhBwNAIAQoAhQgAkYEQCAEQRRqQdD0wAAQ+gULIAQoAhggB2ogAzYCACAEIAJBAWoiAjYCHCADQQFqIQMgB0EEaiEHIAFBAWsiAQ0ACwwBCyAEKAIIIAxGBEAgBEEIakHg9MAAEPoFIAQoAgwhCwsgCyAMQQJ0aiAHNgIAIAQgDEEBaiIMNgIQCyAAQQRqIgAgBkcNAAsCQCAIBEAgBUEEaygCACIAQXhxIgIgCEECdCIBQQRBCCAAQQNxIgAbakkNASAAQQAgAiABQSdqSxsNBiAFEKICCyAEKAIYIQUgBCgCFCEIIAQoAhwiA0UNAgwBCwsMAgsgDBC2CSELIAQoAgwhACAEKAIIIQkgDARAIAxBAnQhB0EAIQMgACECA0AgCyUBIAMgAigCABAaIANBAWohAyACQQRqIQIgB0EEayIHDQALCyAJBEAgAEEEaygCACIBQXhxIgYgCUECdCICQQRBCCABQQNxIgEbakkNAiABQQAgBiACQSdqSxsNAyAAEKICCxC/CSIGQaj0wABBBxDsCCIAIAsQwAkCQEG0u8kALQAARQRAQbi7yQBBADYCAEG0u8kAQQA6AAAgC0GECE8EQCALEJsHCyAAQYQITwRAIAAQmwcLIAgEQCAFQQRrKAIAIgBBeHEiAiAIQQJ0IgFBBEEIIABBA3EiABtqSQ0EIABBACACIAFBJ2pLGw0CIAUQogILIAogCigCCEEBazYCCCANQgA3AgQgDSAGNgIAQbi1yQBBuLXJACgCAEEBajYCACAEQSBqJAAMBQtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgBCAANgIUQdjmyABBKyAEQRRqQdjowABBsPTAABDgBgALDAILAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALIA0oAgAgDSgCBCANKAIIIA1BEGokAAuWCQILfwF7IwBBEGsiCCQAENoEIgsgASYBIAAhBiMAQUBqIgQkAEGwtckAKAIARQRAEFYLAkACQAJAAkACQEG4tckAKAIARQRAQbi1yQBBfzYCACAGQf////8ASw0BIAZBBHQiAEH9////B08NAUGgtskAKAIAIQwCQAJAIABFBEBBBCEADAELIAYhBSAAEHEiAEUNAQtBGBBxIglFDQAgBkEQdiAGQf//A3FBAEdqIQMgCUEANgIUIAkgADYCECAJIAU2AgwgCUEANgIIIAlCgYCAgBA3AgAgBkUEQEEEIQpBBCEHDAcLIANBAnQiBxBxIgpFDQACQCADQQRPBED9DAAAAAABAAAAAgAAAAMAAAAhDSAKIQAgA0H8P3EiAiEFA0AgACAN/QsCACAAQRBqIQAgDf0MBAAAAAQAAAAEAAAABAAAAP2uASENIAVBBGsiBQ0ACyACIANGDQELIAogAkECdGohAANAIAAgAjYCACAAQQRqIQAgAyACQQFqIgJHDQALIAcQcSIHRQ0BQQAhAiADQQRJDQUMBAsgBxBxIgcNAwsAC0GsisEAELAKAAtByPLAABD/BwAL/QwAAAAAAQAAAAIAAAADAAAAIQ0gByEAIANB/D9xIgIhBQNAIAAgDf0LAgAgAEEQaiEAIA39DAQAAAAEAAAABAAAAAQAAAD9rgEhDSAFQQRrIgUNAAsgAiADRg0BCyAHIAJBAnRqIQADQCAAIAI2AgAgAEEEaiEAIAMgAkEBaiICRw0ACwsgAyECCyAEIAM2AjggBCAHNgI0IAQgAzYCMCAEIAM2AiwgBCAKNgIoIAQgAjYCJCAEIAk2AjwgBEEIaiAMIARBJGoQnwICQAJAAkACQAJAAkACQCAEKAIIIgBBgICAgHhGDQAgBCgCICICIAIoAgBBAWsiAzYCACADRQRAIAIQ0gULIAAEQCAEKAIMIgJBBGsoAgAiA0F4cSIFIABBAnQiAEEEQQggA0EDcSIDG2pJDQIgA0EAIAUgAEEnaksbDQMgAhCiAgsgBCgCFCIARQ0AIAQoAhgiAkEEaygCACIDQXhxIgUgAEECdCIAQQRBCCADQQNxIgMbakkNAyADQQAgBSAAQSdqSxsNBCACEKICC0GgtskAQaC2yQAoAgBBAWo2AgAgDEEAIAYgCxDTARC/CSICQbDywABBBRDsCCIAIAy4ELcJIgYQwAlBtLvJAC0AAA0EQbi7yQBBADYCAEG0u8kAQQA6AAAgBkGECE8EQCAGEJsHCyAAQYQITwRAIAAQmwcLQbi1yQBBuLXJACgCAEEBajYCACALQYQITwRAIAsQmwcLIAhCADcCBCAIIAI2AgAgBEFAayQADAULQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBtLvJAEEAOgAAQbi7yQAoAgAhAEG4u8kAQQA2AgAgBCAANgIkQdjmyABBKyAEQSRqQdjowABB2PLAABDgBgALIAgoAgAgCCgCBCAIKAIIIAhBEGokAAvLAwEDfyMAQRBrIgMkAEEIIQQCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkBBFSAAKAIAIgVBgICAgHhzIAVBAE4bQQFrDhUBAgMEBQYHCAkKCwwNDg8UFBAREhMACyADIAAtAAQ6AAEgA0EAOgAADBYLIAMgADEABDcDCAwTCyADIAAzAQQ3AwgMEgsgAyAANQIENwMIDBELIAMgACkDCDcDCAwQCyADIAAwAAQ3AwgMEAsgAyAAMgEENwMIDA8LIAMgADQCBDcDCAwOCyADIAApAwg3AwgMDQsgAyAAKgIEuzkDCCADQQM6AAAMDQsgAyAAKwMIOQMIIANBAzoAAAwMCyADIAAoAgQ2AgQgA0EEOgAADAsLIAMgACkDCDcCBCADQQU6AAAMCgsgAyAAKQIENwIEIANBBToAAAwJCyADIAApAwg3AgQgA0EGOgAADAgLIAMgACkCBDcCBCADQQY6AAAMBwsgA0EHOgAADAYLIANBCToAAAwFCyADQQo6AAAMBAtBCyEECyADIAQ6AAAMAgsgA0EBOgAADAELIANBAjoAAAsgAyABIAIQ3wYgA0EQaiQACy8AIAEoAgAgAC0AAEEEakH/AXFBAnQiACgCgO1BIAAoAuTsQSABKAIEKAIMEQAACy8AIAEoAgAgAC0AAEEBa0H/AXFBAnQiACgCwItJIAAoAviKSSABKAIEKAIMEQAACy8AIAEoAgAgAC0AAEEBa0H/AXFBAnQiACgC4IxJIAAoAoiMSSABKAIEKAIMEQAACy8AIAEoAgAgAC0AAEEBa0H/AXFBAnQiACgCgJpJIAAoAriZSSABKAIEKAIMEQAACy8AIAEoAgAgAC0AAEEBa0H/AXFBAnQiACgCoJtJIAAoAsiaSSABKAIEKAIMEQAACy8AIAEoAgAgAC0AAEEEakH/AXFBAnQiACgCwKFJIAAoAqShSSABKAIEKAIMEQAAC+0DAQp/IwBBEGsiAyQAIwBBoANrIgEkAAJAAkACQAJAAkACQCAABEAgAEEIayIEIAQoAgBBAWoiAjYCACACRQ0BIAAoAgAiAkH/////B08NAiAAIAJBAWo2AgAgAUEIaiAAQQRqQQAQdgJ/IAEoAggiCUECRgRAIAEoAgwhAiABQQA2ApgDIAFCgICAgBA3ApADIAFBnJPBADYC0AEgAUKggICADjcC1AEgASABQZADajYCzAEgAiABQcwBahCvBA0FIAEoApADIQUgASgClAMiCCABKAKYAxDsCCEHIAUEQCAIQQRrKAIAIgZBeHEiCkEEQQggBkEDcSIGGyAFakkNByAGQQAgCiAFQSdqSxsNCCAIEKICCyACIAIoAgAoAgARAwBBAAwBCyABQcwBaiICIAFBCGpBxAH8CgAAIAIQ0QELIQIgACAAKAIAQQFrNgIAIAQgBCgCAEEBayIANgIAIABFBEAgBBDkBgsgAyAHNgIEIAMgAjYCACADIAlBAkY2AgggAUGgA2okAAwGCxCOCgsACxCQCgALQaCexgBBNyABQZ8DakG0k8EAQdiexgAQ4AYAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgAygCACADKAIEIAMoAgggA0EQaiQAC5oFAQp/IwBBEGsiAyQAIwBBsANrIgEkAAJAAkACQAJAAkACQCAABEAgAEEIayIFIAUoAgBBAWoiAjYCACACRQ0BIAAoAgAiAkH/////B08NAiAAIAJBAWo2AgAgAC0AXCICQQJHBEAgAUEgaiAAQdgAaigCADYCACABQRhqIABB0ABqKQIANwMAIAFBBmogAEHfAGotAAA6AAAgASAA/QACQP0LAwggASAALwBdOwEECyABQfgBaiABQSBqKAIANgIAIAFB8AFqIAFBGGopAwA3AwAgAUH/AWogAUEGai0AADoAACABIAH9AAMI/QsD4AEgASACOgD8ASABIAEvAQQ7AP0BIAFBJGogAEEEakEAIAFB4AFqIgQQcgJ/IAEoAiQiCUECRgRAIAEoAighAiABQQA2AqgDIAFCgICAgBA3AqADIAFBnJPBADYC5AEgAUKggICADjcC6AEgASABQaADajYC4AEgAiAEEK8EDQUgASgCoAMhBCABKAKkAyIIIAEoAqgDEOwIIQcgBARAIAhBBGsoAgAiBkF4cSIKQQRBCCAGQQNxIgYbIARqSQ0HIAZBACAKIARBJ2pLGw0IIAgQogILIAIgAigCACgCABEDAEEADAELIAFB4AFqIgIgAUEkakG8AfwKAAAgAhDSAQshAiAAIAAoAgBBAWs2AgAgBSAFKAIAQQFrIgA2AgAgAEUEQCAFEOQGCyADIAc2AgQgAyACNgIAIAMgCUECRjYCCCABQbADaiQADAYLEI4KCwALEJAKAAtBoJ7GAEE3IAFBrwNqQbSTwQBB2J7GABDgBgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyADKAIAIAMoAgQgAygCCCADQRBqJAAL7QMBCn8jAEEQayIDJAAjAEGgA2siASQAAkACQAJAAkACQAJAIAAEQCAAQQhrIgQgBCgCAEEBaiICNgIAIAJFDQEgACgCACICQf////8HTw0CIAAgAkEBajYCACABQQhqIABBBGpBARB2An8gASgCCCIJQQJGBEAgASgCDCECIAFBADYCmAMgAUKAgICAEDcCkAMgAUGck8EANgLQASABQqCAgIAONwLUASABIAFBkANqNgLMASACIAFBzAFqEK8EDQUgASgCkAMhBSABKAKUAyIIIAEoApgDEOwIIQcgBQRAIAhBBGsoAgAiBkF4cSIKQQRBCCAGQQNxIgYbIAVqSQ0HIAZBACAKIAVBJ2pLGw0IIAgQogILIAIgAigCACgCABEDAEEADAELIAFBzAFqIgIgAUEIakHEAfwKAAAgAhDRAQshAiAAIAAoAgBBAWs2AgAgBCAEKAIAQQFrIgA2AgAgAEUEQCAEEOQGCyADIAc2AgQgAyACNgIAIAMgCUECRjYCCCABQaADaiQADAYLEI4KCwALEJAKAAtBoJ7GAEE3IAFBnwNqQbSTwQBB2J7GABDgBgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyADKAIAIAMoAgQgAygCCCADQRBqJAAL5AEBBX8jAEEQayIBJAAjAEEQayIDJAACQAJAAkAgAARAIABBCGsiBCAEKAIAQQFqIgI2AgAgAkUNASAAKAIAIgJB/////wdPDQIgACACQQFqNgIAIANBCGogAEEEahD7AyADKAIMIQIgAygCCCEFIAAgACgCAEEBazYCACAEIAQoAgBBAWsiADYCACAARQRAIAQQ5AYLIAEgBTYCCCABIAJBACAFQQFxIgAbNgIEIAFBACACIAAbNgIAIANBEGokAAwDCxCOCgsACxCQCgALIAEoAgAgASgCBCABKAIIIAFBEGokAAvuAwEKfyMAQRBrIgMkACMAQaADayIBJAACQAJAAkACQAJAAkAgAARAIABBCGsiBCAEKAIAQQFqIgI2AgAgAkUNASAAKAIAIgJB/////wdPDQIgACACQQFqNgIAIAFBCGogAEEEakEAEI8BAn8gASgCCCIJQQJGBEAgASgCDCECIAFBADYCmAMgAUKAgICAEDcCkAMgAUGck8EANgLQASABQqCAgIAONwLUASABIAFBkANqNgLMASACIAFBzAFqEK8EDQUgASgCkAMhBSABKAKUAyIIIAEoApgDEOwIIQcgBQRAIAhBBGsoAgAiBkF4cSIKQQRBCCAGQQNxIgYbIAVqSQ0HIAZBACAKIAVBJ2pLGw0IIAgQogILIAIgAigCACgCABEDAEEADAELIAFBzAFqIgIgAUEIakHEAfwKAAAgAhDRAQshAiAAIAAoAgBBAWs2AgAgBCAEKAIAQQFrIgA2AgAgAEUEQCAEEOMGCyADIAc2AgQgAyACNgIAIAMgCUECRjYCCCABQaADaiQADAYLEI4KCwALEJAKAAtBoJ7GAEE3IAFBnwNqQbSTwQBB2J7GABDgBgALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACyADKAIAIAMoAgQgAygCCCADQRBqJAAL5AEBBX8jAEEQayIBJAAjAEEQayIDJAACQAJAAkAgAARAIABBCGsiBCAEKAIAQQFqIgI2AgAgAkUNASAAKAIAIgJB/////wdPDQIgACACQQFqNgIAIANBCGogAEEEahCDBSADKAIMIQIgAygCCCEFIAAgACgCAEEBazYCACAEIAQoAgBBAWsiADYCACAARQRAIAQQ4wYLIAEgBTYCCCABIAJBACAFQQFxIgAbNgIEIAFBACACIAAbNgIAIANBEGokAAwDCxCOCgsACxCQCgALIAEoAgAgASgCBCABKAIIIAFBEGokAAvuBQELfyMAQRBrIgckACMAQTBrIgEkAAJAAkACQAJAAkAgAARAIABBCGsiBSgCAEEBRw0BIAAoAhAhAyAAKAIMIQggACgCCCEEIAAoAgQhAiAFQQA2AgACQCAFQX9GDQAgAEEEayIGIAYoAgBBAWsiBjYCACAGDQAgAEEMaygCACIAQXhxIgZBIEEkIABBA3EiABtJDQQgAEEAIAZBxABPGw0FIAUQogILAkAgAiAEKAIUEQQAIgAEQCABQQA2AhggAUKAgICAEDcCECABQZyTwQA2AiAgAUKggICADjcCJCABIAFBEGo2AhwgACABQRxqEK8EDQQgASgCECEFIAEoAhQiCiABKAIYEOwIIQYgBQRAIApBBGsoAgAiCUF4cSILQQRBCCAJQQNxIgkbIAVqSQ0GIAlBACALIAVBJ2pLGw0HIAoQogILIAAgACgCACgCABEDACAEKAIAIgAEQCACIAARAwALIAQoAgQiAARAIAJBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIABqSQ0GIARBACAFIABBJ2pLGw0HIAIQogILIAMoAgAiAARAIAggABEDAAsgAygCBCIABEAgCEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAGpJDQYgAkEAIAMgAEEnaksbDQcgCBCiAgtBASEADAELIAFBCGogCCACIAQgAygCDBEGACABKAIMIQYgASgCCCEAIAMoAgQiAkUNACAIQQRrKAIAIgNBeHEiBEEEQQggA0EDcSIDGyACakkNBCADQQAgBCACQSdqSxsNBSAIEKICCyAHIABBAXEiADYCCCAHIAZBACAAGzYCBCAHQQAgBiAAGzYCACABQTBqJAAMBQsQjgoAC0GM2sAAQT8QjwoAC0GgnsYAQTcgAUEvakG0k8EAQdiexgAQ4AYAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgBygCACAHKAIEIAcoAgggB0EQaiQAC4EMAgN+CH8jAEEQayIIJAAjAEFAaiIGJABBsLXJACgCAEUEQBBWCwJAAkACQAJAAkACQAJAAkACQAJAQbi1yQAoAgBFBEBBuLXJAEF/NgIAQcy1yQAoAgBFDQhBxLXJACgCACIHQdi1yQApAwAiASAArYUiAkI4hiACQoD+A4NCKIaEIAJCgID8B4NCGIYgAkKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhELSgaqbq/qC16d/fiIBQjiGIAFCgP4Dg0IohoQgAUKAgPwHg0IYhiABQoCAgPgPg0IIhoSEIAFCCIhCgICA+A+DIAFCGIhCgID8B4OEIAFCKIhCgP4DgyABQjiIhISEIAJC2KLR78Kp5b8tfoUiAUI4hiABQoD+A4NCKIaEIAFCgID8B4NCGIYgAUKAgID4D4NCCIaEhCABQgiIQoCAgPgPgyABQhiIQoCA/AeDhCABQiiIQoD+A4MgAUI4iISEhEHQtckAKQMAIgJCf4V+IgNCOIYgA0KA/gODQiiGhCADQoCA/AeDQhiGIANCgICA+A+DQgiGhIQgA0IIiEKAgID4D4MgA0IYiEKAgPwHg4QgA0IoiEKA/gODIANCOIiEhIQgASACQjiGIAJCgP4Dg0IohoQgAkKAgPwHg0IYhiACQoCAgPgPg0IIhoSEIAJCCIhCgICA+A+DIAJCGIhCgID8B4OEIAJCKIhCgP4DgyACQjiIhISEfoUgAYkiAadxIQQgAUIZiEL/AINCgYKEiJCgwIABfiEDQcC1yQAoAgAiCUEgayEKA0ACQCAEIAlqKQAAIgIgA4UiAUJ/hSABQoGChIiQoMCAAX2DQoCBgoSIkKDAgH+DIgFQRQRAA0AgACAKIAF6p0EDdiAEaiAHcSILQQV0aygCAEYNAiABQgF9IAGDIgFQRQ0ACwsgAiACQgGGg0KAgYKEiJCgwIB/g1BFDQogBCAFQQhqIgVqIAdxIQQMAQsLIAlBACALa0EFdGoiBEEEayIHKAIAIgAgACgCAEEBaiIANgIAIABFDQEgBEEcaygCACIAQf////8DSw0CIABBAnQiBUH9////B08NAiAHKAIAIQoCQCAFRQRAQQQhBUEAIQAMAQsgBRBxIgVFDQILIARBEGsoAgAiBEH/////A0sNAyAEQQJ0IgdB/f///wdPDQMCQCAHRQRAQQQhB0EAIQQMAQsgBxBxIgdFDQILQaC2yQBBoLbJACgCACIJQQFqNgIAIAZBADYCOCAGIAc2AjQgBiAENgIwIAZBADYCLCAGIAU2AiggBiAANgIkIAYgCjYCPCAGQQhqIAkgBkEkahCfAgJAIAYoAggiAEGAgICAeEYNACAGKAIgIgQgBCgCAEEBayIFNgIAIAVFBEAgBBDSBQsgAARAIAYoAgwiBEEEaygCACIFQXhxIgcgAEECdCIAQQRBCCAFQQNxIgUbakkNBiAFQQAgByAAQSdqSxsNByAEEKICCyAGKAIUIgBFDQAgBigCGCIEQQRrKAIAIgVBeHEiByAAQQJ0IgBBBEEIIAVBA3EiBRtqSQ0HIAVBACAHIABBJ2pLGw0IIAQQogILEL8JIgVBsPLAAEEFEOwIIgAgCbgQtwkiBBDACUG0u8kALQAADQlBuLvJAEEANgIAQbS7yQBBADoAACAEQYQITwRAIAQQmwcLIABBhAhPBEAgABCbBwsgCEIANwIEIAggBTYCAEG4tckAQbi1yQAoAgBBAWo2AgAgBkFAayQADAoLQayKwQAQsAoLAAtB9PvAABD/BwALQYT8wAAQ/wcAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQeT7wAAQ3QkAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACAGIAA2AiRB2ObIAEErIAZBJGpB2OjAAEGU/MAAEOAGAAsgCCgCACAIKAIEIAgoAgggCEEQaiQAC7QGAQZ/IwBBEGsiBSQAIwBBQGoiAyQAQbC1yQAoAgBFBEAQVgsCQAJAAkACQAJAAkACQAJAQbi1yQAoAgBFBEBBuLXJAEF/NgIAIABB/////wBLDQEgAEEEdCIBQf3///8HTw0BQaC2yQAoAgAhBgJAIAFFBEBBBCEEDAELIAAhAiABEHEiBEUNAwtBGBBxIgFFDQIgAUEANgIUIAEgBDYCECABIAI2AgwgAUEANgIIIAFCgYCAgBA3AgACQCAARQRAQQQhBEEAIQBBBCECDAELIABB//8DakEQdiIAQQJ0IgIQcSIERQ0DIAIQcSICRQ0DCyADQQA2AjggAyACNgI0IAMgADYCMCADQQA2AiwgAyAENgIoIAMgADYCJCADIAE2AjwgA0EIaiAGIANBJGoQnwICQCADKAIIIgBBgICAgHhGDQAgAygCICICIAIoAgBBAWsiATYCACABRQRAIAIQ0gULIAAEQCADKAIMIgJBBGsoAgAiAUF4cSIEIABBAnQiAEEEQQggAUEDcSIBG2pJDQUgAUEAIAQgAEEnaksbDQYgAhCiAgsgAygCFCIARQ0AIAMoAhgiAkEEaygCACIBQXhxIgQgAEECdCIAQQRBCCABQQNxIgEbakkNBiABQQAgBCAAQSdqSxsNByACEKICC0GgtskAQaC2yQAoAgBBAWo2AgAQvwkiAUGw8sAAQQUQ7AgiACAGuBC3CSICEMAJQbS7yQAtAAANB0G4u8kAQQA2AgBBtLvJAEEAOgAAIAJBhAhPBEAgAhCbBwsgAEGECE8EQCAAEJsHCyAFQgA3AgQgBSABNgIAQbi1yQBBuLXJACgCAEEBajYCACADQUBrJAAMCAtBrIrBABCwCgALQaDywAAQ/wcLAAtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcAC0G0u8kAQQA6AABBuLvJACgCACEAQbi7yQBBADYCACADIAA2AiRB2ObIAEErIANBJGpB2OjAAEG48sAAEOAGAAsgBSgCACAFKAIEIAUoAgggBUEQaiQACyYAAkAgAARAIAAoAgBB/////wdPDQEgACgCaA8LEI4KAAsQkAoACyYAAkAgAARAIAAoAgBB/////wdPDQEgACgCZA8LEI4KAAsQkAoACyYAAkAgAARAIAAoAgBB/////wdPDQEgACgCSA8LEI4KAAsQkAoACyYAAkAgAARAIAAoAgBB/////wdPDQEgACgCRA8LEI4KAAsQkAoACykAIAAgAC0ABCABQS5GcjoABCAAKAIAIgAoAgAgASAAKAIEKAIQEQIACy4AIAEoAgBB68LHAEHgwscAIAAoAgAtAAAiABtBCUELIAAbIAEoAgQoAgwRAAALrAgBDn8jAEEQayIKJAAQ2gQiBiABJgEjAEEwayICJAACQAJAAkACQAJAAkACQAJAIAAiCQRAIABBCGsiCyALKAIAQQFqIgA2AgAgAEUNASAJKAIADQIgCUF/NgIAIAlBCGooAgAhDSAJKAIEIQ5BmLXJACgCAEUEQAJAQaS1yQAoAgAhB0GgtckAKAIAIQBBoLXJAEKAgICAEDcCAEGYtckAKAIAIQRBmLXJAEIBNwIAQai1yQBBADYCAAJAAkAgBEUgAEVyRQRAIAdBBGsoAgAiBEF4cSIFQQRBCCAEQQNxIgQbIABqSQ0BIARBACAFIABBJ2pLGw0CIAcQogILDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACwtBnLXJACgCAA0DQZy1yQBBfzYCAAJAQYCAwAAgBhC7CiIAIABBgIDAAE8bIgRBqLXJACgCACIATQRAQaS1yQAoAgAhBQwBCyAEIABrIgNBoLXJACgCACAAa0sEQEGgtckAIAAgA0EBQQEQpAVBqLXJACgCACEAC0GktckAKAIAIgUgAGohByADQQJPBH8gA0EBayIDBEAgB0EAIAP8CwALIAUgACADaiIAagUgBwtBADoAACAAQQFqIQQLQQAhAEGotckAIAQ2AgACQAJAAkADQCAAIgcgBhC7CiIPTw0BIAAgBCAGELsKIABrIgMgAyAESxsiCGohACAGJQEgByAAEBghARDaBCIDIAEmASADELsKIQwgAiAINgIIIAIgDDYCFCAIIAxHDQggBSAIIAMQ4wkgA0GECE8EQCADEJsHCyAOIAUgCCANKAIQEQAAIghFDQALIAJBADYCECACQoCAgIAQNwIIIAJBnJPBADYCHCACQqCAgIAONwIgIAIgAkEIajYCGCAIIAJBGGoQrwQNCCACKAIIIQAgAigCDCIEIAIoAhAQ7AghAyAABEAgBEEEaygCACIFQXhxIgxBBEEIIAVBA3EiBRsgAGpJDQogBUEAIAwgAEEnaksbDQsgBBCiAgsgCCAIKAIAKAIAEQMAQQEhAEGctckAQZy1yQAoAgBBAWo2AgAgBkGDCEsNAQwCC0EAIQBBnLXJAEGctckAKAIAQQFqNgIAIAZBhAhJDQELIAcgD0khACAGEJsHCyAJIAkoAgBBAWo2AgAgCyALKAIAQQFrIgY2AgAgBkUEQCALENcECyAKIAA2AgQgCiADQQAgABs2AgAgAkEwaiQADAgLEI4KCwALEJAKAAtBrIrBABCwCgALIAJBADYCGEEAIAJBFGogAkEIaiACQRhqQeD5xAAQ9QcAC0GgnsYAQTcgAkEUakG0k8EAQdiexgAQ4AYAC0HMjMgAQS5B/IzIABDrBwALQYyNyABBLkG8jcgAEOsHAAsgCigCACAKKAIEIApBEGokAAshAAJAIAAEQCAAKAIADQEgACABNgJoDwsQjgoACxCQCgALIQACQCAABEAgACgCAA0BIAAgATYCZA8LEI4KAAsQkAoACyEAAkAgAARAIAAoAgANASAAIAE2AkgPCxCOCgALEJAKAAshAAJAIAAEQCAAKAIADQEgACABNgJEDwsQjgoACxCQCgALLAAgASgCACAAKAIALQAAaEECdCIAKAL0h0kgACgC4IdJIAEoAgQoAgwRAAALLAAgASgCACAAKAIALQAAaEECdCIAKAKEjkkgACgC8I1JIAEoAgQoAgwRAAALLgAgAEEcakEAIAEpAgBC2v2W/+no6PrBAIUgASkCCELW+4aRyMDiv/4AhYRQGwssACAAQRxqQQAgASkCAELtwsSbx9P/rT+FIAEpAghC/J7N1v6Dwrh+hYRQGwsuACAAQRxqQQAgASkCAELtuq22zYXU9eMAhSABKQIIQviCmb2V7sbFuX+FhFAbCywAIABBHGpBACABKQIAQvep0+7yobOVe4UgASkCCEKWuaPa9sSH1CeFhFAbCysAIAEoAgAgACgCAC0AAEECdCIAKALohkkgACgCqIZJIAEoAgQoAgwRAAALKQAgASgCACAALQAAaEECdCIAKAKciEkgACgCiIhJIAEoAgQoAgwRAAALKwAgASgCACAAKAIALQAAQQJ0IgAoAqiJSSAAKALoiEkgASgCBCgCDBEAAAslACAARQRAQa35xABBMhCPCgALIAAgAiADIAQgBSABKAIQEQ8ACysAIAEoAgAgACgCAC0AAEECdCIAKALUjUkgACgCuI1JIAEoAgQoAgwRAAALKwAgASgCACAAKAIALQAAQQJ0IgAoAtiOSSAAKAKYjkkgASgCBCgCDBEAAAsrACABKAIAIAAoAgAtAABBAnQiACgC0JFJIAAoAryRSSABKAIEKAIMEQAACy0AIABBHGpBACABKQIAQp6ptofpq8f75ACFIAEpAghChJXY5rmb/qdphYRQGwsrACABKAIAIAAoAgAtAABBAnQiACgC+JFJIAAoAuSRSSABKAIEKAIMEQAACy0AIABBHGpBACABKQIAQvXXvMnIzNazOoUgASkCCEL+28ub8+W5xvUAhYRQGwsuACAAQSBqQQAgASkCAELhypSvjYKC2fIAhSABKQIIQqbKhrK+ypOwu3+FhFAbCy0AIABBHGpBACABKQIAQpLXooDhkqzi9QCFIAEpAghClJ2A4Jq0sLALhYRQGwslACAAQYiWwQA2AgQgACABQQRqQQAgASgCAEGBgICAeEYbNgIACygAIAEoAgAgAC0AAEECdCIAKAK87EEgACgClOxBIAEoAgQoAgwRAAALKAAgASgCACAALQAAQQJ0IgAoAtDtQSAAKAKc7UEgASgCBCgCDBEAAAshACAAQcDOxAA2AgQgACABQQRqQQAgAS0AAEEkRhs2AgALKAAgASgCACAALQAAQQJ0IgAoAsyISSAAKAKwiEkgASgCBCgCDBEAAAsoACABKAIAIAAtAABBAnQiACgCsIpJIAAoAuiJSSABKAIEKAIMEQAACyMAIABFBEBBrfnEAEEyEI8KAAsgACACIAMgBCABKAIQEQsACyMAIABFBEBBrfnEAEEyEI8KAAsgACACIAMgBCABKAIQEQYACyMAIABFBEBBrfnEAEEyEI8KAAsgACACIAMgBCABKAIQEWUACyMAIABFBEBBrfnEAEEyEI8KAAsgACACIAMgBCABKAIQEWYACyMAIABFBEBBrfnEAEEyEI8KAAsgACACIAMgBCABKAIQEWcACygAIAEoAgAgAC0AAEECdCIAKALwmEkgACgCqJhJIAEoAgQoAgwRAAALIgAgASgCKEECRwRAIAAgASkC3AI3AwAPC0GsmMcAEN0JAAslACAAQailxwA2AgQgACABQQRqQQAgASgCAEGBgICAeEYbNgIACygAIAEoAgAgAC0AAEECdCIAKAKEo0kgACgC3KFJIAEoAgQoAgwRAAALJwAgACgCAC0AAEUEQCABQfKzxQBBBRCXAw8LIAFB97PFAEEEEJcDCyQAIAAtAABFBEAgAUHys8UAQQUQlwMPCyABQfezxQBBBBCXAwshACAARQRAQa35xABBMhCPCgALIAAgAiADIAEoAhARBQALIQAgAEUEQEGt+cQAQTIQjwoACyAAIAIgAyABKAIQEQAACyEAIAEoAgAgAC0AAEECdCgCiOxBQQEgASgCBCgCDBEAAAsiACABIAAtAABBAnQiACgCiIZJIAAoAuiFSSACKAIMEQAACx4AIABBwM7EADYCBCAAQQAgAUEEaiABLQAAGzYCAAscACABIAAoAgAiAEEEaigCACAAQQhqKAIAEJcDCx8AIABFBEBBrfnEAEEyEI8KAAsgACACIAEoAhARAgALthQBEn8Q2gQiCyABJgECfyAAIQ0Q2gQiEiACJgEgCyETIwBBQGoiByQAIAsQuAohAEHUtMkAKAIARQRAAkBBkLXJACgCACELQYy1yQAoAgAhBEGMtckAQoCAgIDAADcCAEGEtckAKAIAIQhBhLXJAEIENwIAQYC1yQAoAgAhA0H8tMkAQgA3AgBB+LTJACgCACEGQfS0yQAoAgAhDkH0tMkAQoCAgIDAADcCAEHstMkAKAIAIQVB7LTJAEIENwIAQei0yQAoAgAhDEHktMkAQgA3AgBB4LTJACgCACEKQdy0yQAoAgAhEEHctMkAQoCAgIDAADcCAEHUtMkAKAIAQdS0yQBCATcCAEGUtckAQQA2AgBFDQACQAJAIBAEQCAKQQRrKAIAIglBeHEiDyAQQQJ0IhBBBEEIIAlBA3EiCRtqSQ0BIAlBACAPIBBBJ2pLGw0CIAoQogILIAwEQCAFQQRrKAIAIgpBeHEiECAMQQJ0IgxBBEEIIApBA3EiChtqSQ0BIApBACAQIAxBJ2pLGw0CIAUQogILIA4EQCAGQQRrKAIAIgVBeHEiDCAOQQJ0Ig5BBEEIIAVBA3EiBRtqSQ0BIAVBACAMIA5BJ2pLGw0CIAYQogILIAMEQCAIQQRrKAIAIgZBeHEiDiADQQJ0IgNBBEEIIAZBA3EiBhtqSQ0BIAZBACAOIANBJ2pLGw0CIAgQogILIARFDQIgC0EEaygCACIIQXhxIgMgBEECdCIEQQRBCCAIQQNxIggbakkNACAIQQAgAyAEQSdqSxsNASALEKICDAILQcyMyABBLkH8jMgAEOsHAAtBjI3IAEEuQbyNyAAQ6wcACwsCQAJAQdi0yQAoAgBFBEBB2LTJAEF/NgIAIAAQyQIgE0EAIA0Q4QghEEHktMkAKAIAIgsgDU8EQEHgtMkAKAIAIQsgByAQELgKIgQ2AgwgByANNgIYIAQgDUYEQCALIA0gEBDhCSAAEMkCQeS0yQAoAgAiACANTwRAQeC0yQAoAgAhC0H4tMkAKAIAIQQCQEH8tMkAKAIAIgpFDQAgCkECdCIARQ0AIARBACAA/AsAC0GEtckAKAIAIQ4CQEGItckAKAIAIgxFDQAgDEECdCIARQ0AIA5BACAA/AsACyANQQJ0IQggDQRAIAghAyALIQADQAJAIAAoAgAiBkGAgID8B08NACAKIAZBf3MiBUH//wNxIgZLBEAgBCAGQQJ0aiIGIAYoAgBBAWo2AgAgDCAFQRB2IgZLBEAgDiAGQQJ0aiIGIAYoAgBBAWo2AgAMAgsgBiAMQYDywAAQjAcACyAGIApB8PHAABCMBwALIABBBGohACADQQRrIgMNAAsLAkAgCkUEQEEAIQMMAQsgCkEBa0H/////A3EiAEEBaiIDQQdxIQUCQCAAQQdJBEBBACEDIAQhAAwBCyADQfj///8HcSEGQQAhAyAEIQADQCAAKAIAIQkgACADNgIAIABBBGoiDygCACERIA8gAyAJaiIDNgIAIABBCGoiCSgCACEPIAkgAyARaiIDNgIAIABBDGoiCSgCACERIAkgAyAPaiIDNgIAIABBEGoiCSgCACEPIAkgAyARaiIDNgIAIABBFGoiCSgCACERIAkgAyAPaiIDNgIAIABBGGoiCSgCACEPIAkgAyARaiIDNgIAIABBHGoiCSgCACERIAkgAyAPaiIDNgIAIAMgEWohAyAAQSBqIQAgBkEIayIGDQALCyAFRQ0AA0AgACgCACEGIAAgAzYCACAAQQRqIQAgAyAGaiEDIAVBAWsiBQ0ACwsgByADNgIAIA0EQCAIIAtqIQ8gC0EEaiEGIAhBBGtBAnZBAWohEUGQtckAKAIAIRRBlLXJACgCACEJQQAhBSALIQgDQCAGIQACQCAIKAIAIghBgICA/AdPDQACQCAKIAhBf3NB//8DcSIISwRAIAQgCEECdGoiCCgCACIGIAlPDQEgFCAGQQJ0aiAFNgIAIAggCCgCAEEBajYCAAwCCyAIIApB0PHAABCMBwALIAYgCUHg8cAAEIwHAAsgAEEEQQAgACAPRxtqIQYgACEIIBEgBUEBaiIFRw0ACwsCQCAMRQ0AIAxBAWtB/////wNxIgRBAWoiCEEHcSEGQQAhBSAOIQAgBEEHTwRAIAhB+P///wdxIQgDQCAAKAIAIQQgACAFNgIAIABBBGoiCigCACEJIAogBCAFaiIENgIAIABBCGoiBSgCACEKIAUgBCAJaiIENgIAIABBDGoiBSgCACEJIAUgBCAKaiIENgIAIABBEGoiBSgCACEKIAUgBCAJaiIENgIAIABBFGoiBSgCACEJIAUgBCAKaiIENgIAIABBGGoiBSgCACEKIAUgBCAJaiIENgIAIABBHGoiBSgCACEJIAUgBCAKaiIENgIAIAQgCWohBSAAQSBqIQAgCEEIayIIDQALCyAGRQ0AA0AgACgCACAAIAU2AgAgAEEEaiEAIAVqIQUgBkEBayIGDQALCyADRQ0EQZS1yQAoAgAiBEUNBEGQtckAKAIAIQAgA0EBayEGIARBAnRBBGshBEHstMkAKAIAIQ9B8LTJACgCACEFA0ACQAJAIA0gACgCACIISwRAIAsgCEECdGooAgBBf3NBEHYiCiAMTw0BIA4gCkECdGoiCigCACIJIAVJDQIgCSAFQcDxwAAQjAcACyAIIA1BoPHAABCMBwALIAogDEGw8cAAEIwHAAsgDyAJQQJ0aiAINgIAIAogCigCAEEBajYCACAGRQ0FIAZBAWshBiAAQQRqIQAgBCAEQQRrIQQNAAsMBAtBACANIABBkPLAABDqBwALDAMLQQAgDSALQYjuwAAQ6gcAC0GsisEAELAKAAsCQCAMQYCABE8EQCAOKAL8/w8gA0YNASAHIA5B/P8Paq1CgICAgBCENwMgIAcgB61CgICAgBCENwMYIAdCAjcCNCAHQQI2AiwgB0Hw8MAANgIoIAcgB0EYaiIANgIwIAdBDGoiCyAHQShqIgQQ7AMgBygCECEDIAcoAgwiCEGAgICAeEYNASAHIAcoAhQ2AhQgByADNgIQIAcgCDYCDCAHQQE2AiwgB0Gg+McANgIoIAdCATcCNCAHIAutQoCAgICwBYQ3AwAgByAHNgIwIAAgBBCxBiAHKAIcIAcoAiAQjwoAC0H//wMgDEGQ8cAAEIwHAAsCQCADRQ0AAkBB8LTJACgCACIAIANPBEBB7LTJACgCACEEIBJBACADEOEIIgAQuAohCyAHIAM2AhggByALNgIMIAMgC0cNASAAIAQgAxDgCSAAQYQISQ0CIAAQmwcMAgtBACADIABB+O3AABDqBwALDAELIBBBhAhPBEAgEBCbBwtB2LTJAEHYtMkAKAIAQQFqNgIAIBJBhAhPBEAgEhCbBwsgE0GECE8EQCATEJsHCyAHQUBrJAAgAwwBCyAHQQA2AihBACAHQQxqIAdBGGogB0EoakHg+cQAEPUHAAsLjxEBDX8Q2gQiAyABJgECfyAAIQkQ2gQiDSACJgEgAyEOIwBBQGoiBCQAIAMQvAohB0GotMkAKAIARQRAAkBBzLTJACgCACEAQci0yQAoAgAhA0HItMkAQoCAgIDAADcCAEHAtMkAKAIAIQZBwLTJAEIENwIAQby0yQAoAgAhCEG4tMkAQgA3AgBBtLTJACgCACEFQbC0yQAoAgAhCkGwtMkAQoCAgIAgNwIAQai0yQAoAgBBqLTJAEIBNwIAQdC0yQBBADYCAEUNAAJAAkAgCgRAIAVBBGsoAgAiC0F4cSIMIApBAXQiCkEEQQggC0EDcSILG2pJDQEgC0EAIAwgCkEnaksbDQIgBRCiAgsgCARAIAZBBGsoAgAiBUF4cSIKIAhBAnQiCEEEQQggBUEDcSIFG2pJDQEgBUEAIAogCEEnaksbDQIgBhCiAgsgA0UNAiAAQQRrKAIAIgZBeHEiCCADQQJ0IgNBBEEIIAZBA3EiBhtqSQ0AIAZBACAIIANBJ2pLGw0BIAAQogIMAgtBzIzIAEEuQfyMyAAQ6wcAC0GMjcgAQS5BvI3IABDrBwALCwJAAkACQEGstMkAKAIARQRAQay0yQBBfzYCAEG4tMkAKAIAIgMgB0kEQCAHIANrIgBBsLTJACgCACADa0sEQEGwtMkAIAMgAEECQQIQpAVBuLTJACgCACEDC0G0tMkAKAIAIgggA0EBdGohBiAAQQJPBH8gAEEBdEECayIFBEAgBkEAIAX8CwALIAAgA2oiAEEBayEDIAggAEEBdGpBAmsFIAYLQQA7AQBBuLTJACADQQFqNgIAC0HEtMkAKAIAIgMgB0kEQCAHIAMiAGsiBkG8tMkAKAIAIABrSwRAQby0yQAgACAGQQRBBBCkBUHEtMkAKAIAIQALQcC0yQAoAgAiBSAAQQJ0aiEIIAZBAk8EfyAHIANBf3NqQQJ0IgMEQCAIQQAgA/wLAAsgACAGaiIDQQFrIQAgBSADQQJ0akEEawUgCAtBADYCAEHEtMkAIABBAWo2AgALQdC0yQAoAgAiA0GA+AFNBEBBgfgBIAMiAGsiB0HItMkAKAIAIABrSwRAQci0yQAgACAHQQRBBBCkBUHQtMkAKAIAIQALQcy0yQAoAgAiBiAAQQJ0aiEHIANBgPgBRwR/QYDgByADQQJ0ayIIBEAgB0EAIAj8CwALIAYgACADa0ECdGpBgOAHagUgBwtBADYCAAsgDiUBQQAgCRAcIQEQ2gQiCCABJgEgCUG4tMkAKAIAIgBLDQFBACEGQbS0yQAoAgAhByAEIAgQvAoiADYCDCAEIAk2AhggACAJRw0DIAcgCSAIJQEQHUHQtMkAQQA2AgBByLTJACgCAEGA+AFNBEBByLTJAEEAQYH4AUEEQQQQpAVB0LTJACgCACEGC0HMtMkAKAIAIgogBkECdGoiAEEAQYDgB/wLAEHQtMkAIAZBgfgBaiIPNgIAIABBgOAHakEANgIAIAcgCUEBdCILaiEMAkAgCUUNACAHQQJqIQACfyALQQJrIgNBAnEEQCAAIQMgBwwBCyAHLwEAIgVB//cBTQRAIAogBUECdGoiBSAFKAIAQQFqNgIACyADRQ0BIABBAkEAIAtBAkcbaiEDIAALIQUDQCAFLwEAIgBBgPgBSQRAIAogAEECdGoiACAAKAIAQQFqNgIACyADQQJBACADIAxHG2ohBSADLwEAIgBB//cBTQRAIAogAEECdGoiACAAKAIAQQFqNgIACyAFQQBBAiAFIAxGIgAbaiEDIABFDQALCyAKIA9BAnRqQQhrIgUoAgAhAyAFQQA2AgAgBkEDcUEBRwRAIAZBAWtBA3EhAANAIAVBBGsiBSgCACEGIAUgAzYCACAEIAMgBmoiAzYCACAAQQFrIgANAAsLIAVBEGshBQNAIAVBDGoiACgCACEGIAAgAzYCACAEIAMgBmoiADYCACAFQQhqIgMoAgAhBiADIAA2AgAgBCAAIAZqIgA2AgAgBUEEaiIDKAIAIQYgAyAANgIAIAQgACAGaiIANgIAIAUoAgAhAyAFIAA2AgAgBCAAIANqIgM2AgAgBSAKRyAFQRBrIQUNAAsgCUUNAiAHQQJqIQYgC0ECa0EBdkEBaiELQcC0yQAoAgAhD0HEtMkAKAIAIQlBACEAA0AgBy8BACIHQYD4AUkEQCAJIAogB0ECdGoiBygCACIFTQRAIAUgCUGA8cAAEIwHAAsgDyAFQQJ0aiAANgIAIAcgBygCAEEBajYCAAsgBkECQQAgBiIHIAxHG2ohBiALIABBAWoiAEcNAAsMAgtBrIrBABCwCgALQQAgCSAAQezrwAAQ6gcACwJAIAooAgAgA0YNACAEIAqtQoCAgIAQhDcDICAEIAStQoCAgIAQhDcDGCAEQgI3AjQgBEECNgIsIARB8PDAADYCKCAEIARBGGoiADYCMCAEQQxqIgkgBEEoaiIHEOwDIAQoAhAhAyAEKAIMIgZBgICAgHhGDQAgBCAEKAIUNgIUIAQgAzYCECAEIAY2AgwgBEEBNgIsIARBoPjHADYCKCAEQgE3AjQgBCAJrUKAgICAsAWENwMAIAQgBDYCMCAAIAcQsQYgBCgCHCAEKAIgEI8KAAsCQCADRQ0AAkBBxLTJACgCACIAIANPBEBBwLTJACgCACEHIA1BACADEOEIIgAQuAohCSAEIAM2AhggBCAJNgIMIAMgCUcNASAAIAcgAxDgCSAAQYQISQ0CIAAQmwcMAgtBACADIABB3OvAABDqBwALDAELIAhBhAhPBEAgCBCbBwtBrLTJAEGstMkAKAIAQQFqNgIAIA1BhAhPBEAgDRCbBwsgDkGECE8EQCAOEJsHCyAEQUBrJAAgAwwBCyAEQQA2AihBACAEQQxqIARBGGogBEEoakHg+cQAEPUHAAsLHAAgAEEEahDqAiAAKAIkIgAgACgCACgCABEDAAscACAAKAIAIgAoAgAgASAAQQRqKAIAKAIQEQIACxwAIAAoAgAiACgCACABIABBBGooAgAoAgwRAgALFAAgACAAIAEgACABXRsgASABXBsLFAAgASABIAAgACABXRsgACAAXBsLGwEBbyAAJQEgASACEAAhAxDaBCIAIAMmASAACxsBAW8gACUBIAElARAJIQIQ2gQiACACJgEgAAscAQFvIAAlASABJQEgARCbByACJQEgAhCbBxALCx8AQYi7yQAtAABFBEBBiLvJAEEBOgAACyAAQQE2AgALHQAgASAALQAAQQJ0IgAoAqSESSAAKAKQhEkQlwMLHAAgASgCACAAKAIAIAAoAgQgASgCBCgCDBEAAAsZACABIAAoAgAiACgCACAAQQRqKAIAEJcDCxkBAW8gACUBIAEQDCECENoEIgAgAiYBIAALFwAgACgCACABIAAoAgRBDGooAgARAgALFQAgACgCACIAQYQITwRAIAAQmwcLCxcBAW8gACABEA8hAhDaBCIAIAImASAACxcBAW8gACABECwhAhDaBCIAIAImASAACxYAIAEgACgCACIAKAIAIAAoAgQQlwMLGQAgASgCAEGQl8cAQRMgASgCBCgCDBEAAAsZACABKAIAQdmXxwBBFyABKAIEKAIMEQAACxkAIAEoAgBB6ZLGAEEIIAEoAgQoAgwRAAALGQAgASgCAEGjl8cAQRAgASgCBCgCDBEAAAsZACABKAIAQaTlwABBFCABKAIEKAIMEQAACxkAIAEoAgBB5ZLGAEEEIAEoAgQoAgwRAAALGQAgASgCAEGilscAQQwgASgCBCgCDBEAAAsZACABKAIAQYWQxgBBAyABKAIEKAIMEQAACxkAIAEoAgBB8JfHAEEUIAEoAgQoAgwRAAALGQAgASgCAEH+lccAQQwgASgCBCgCDBEAAAsZACABKAIAQbOXxwBBEiABKAIEKAIMEQAACxkAIAEoAgBBxZfHAEEUIAEoAgQoAgwRAAALGQAgASgCAEHylscAQQ8gASgCBCgCDBEAAAsZACABKAIAQciCwQBBCiABKAIEKAIMEQAACxkAIAEoAgBBhJjHAEEXIAEoAgQoAgwRAAALGQAgASgCAEHM5cAAQRQgASgCBCgCDBEAAAsZACABKAIAQYCQxgBBAiABKAIEKAIMEQAACxkAIAEoAgBBxpbHAEEOIAEoAgQoAgwRAAALGQAgASgCAEGLkMYAQQUgASgCBCgCDBEAAAsZACABKAIAQYKQxgBBAyABKAIEKAIMEQAACxkAIAEoAgBBupbHAEEMIAEoAgQoAgwRAAALGQAgASgCAEG45cAAQRQgASgCBCgCDBEAAAsZACABKAIAQeOWxwBBDyABKAIEKAIMEQAACxkAIAEoAgBBgZfHAEEPIAEoAgQoAgwRAAALGQAgASgCAEHUlscAQQ8gASgCBCgCDBEAAAsZACABKAIAQYiQxgBBAyABKAIEKAIMEQAACxkAIAEoAgBB4OXAAEEUIAEoAgQoAgwRAAALGQAgASgCAEHcksYAQQkgASgCBCgCDBEAAAsZACABKAIAQemVxwBBDiABKAIEKAIMEQAACxkAIAEoAgBBlpbHAEEMIAEoAgQoAgwRAAALGQAgASgCAEGulscAQQwgASgCBCgCDBEAAAsZACABKAIAQYqWxwBBDCABKAIEKAIMEQAACxIAIABBBGoQ6gIgAEEkahCxBAsSACAAQQRqEOoCIABBHGoQ4wQLEgAgAEEEahDqAiAAQRxqELEECxYAIABB8JnBADYCBCAAIAFBCGo2AgALGQAgASgCAEHn+8cAQQUgASgCBCgCDBEAAAsOACAABEAACyACEP8HAAsWACAAQcSXwQA2AgQgACABQRxqNgIACxYAIABBgJjBADYCBCAAIAFBHGo2AgALFgAgAEG8mMEANgIEIAAgAUEcajYCAAsWACAAQfiYwQA2AgQgACABQRxqNgIACxYAIABBtJnBADYCBCAAIAFBHGo2AgALFgAgAEGIlsEANgIEIAAgAUEcajYCAAsWACAAQfCZwQA2AgQgACABQRxqNgIACxYAIABBrJrBADYCBCAAIAFBHGo2AgALEwAgACAAIAAoAgAiAGo2AgAgAAsUACABKAIEGiAAQYzvwQAgARDBAwsRACACKAIEGiAAIAEgAhDBAwsUACABKAIEGiAAQbDxwQAgARDBAwsUACABKAIEGiAAQbTvwQAgARDBAwsUACABKAIEGiAAQdTxwQAgARDBAwsUACABKAIEGiAAQeCBwgAgARDBAwsUACABKAIEGiAAQey1xAAgARDBAwsUACABIAIgAyAEIAUgACgCABEHAAsUACABKAIEGiAAQaC6xQAgARDBAwsZACABKAIAQYS4xQBBEiABKAIEKAIMEQAACxQAIAEoAgQaIABBxJLGACABEMEDCxQAIAEoAgQaIABB+J3GACABEMEDCxYAIABBqLDHADYCBCAAIAFBHGo2AgALFgAgAEHksMcANgIEIAAgAUEcajYCAAsWACAAQbCvxwA2AgQgACABQRxqNgIACxYAIABB7K/HADYCBCAAIAFBIGo2AgALGQAgASgCAEGYrscAQQwgASgCBCgCDBEAAAsSACAAQQRqEOoCIABBIGoQgwILFgAgAEGopccANgIEIAAgAUEcajYCAAsWACAAQaCxxwA2AgQgACABQRxqNgIACxYAIABBnLbHADYCBCAAIAFBDGo2AgALFAAgASgCBBogAEHkt8cAIAEQwQMLFAAgASgCBBogAEHMhcgAIAEQwQMLFgAgASAAKAIAIgAoAgQgACgCCBCXAwsZACABKAIAQcSdyABBCyABKAIEKAIMEQAACxUBAW8gABAEIQEQ2gQiACABJgEgAAsXAgFvAX8gABArIQEQ2gQiAiABJgEgAgsUACAAKAIAIgAgACgCACgCABEDAAsUACAAKAIIIgAgACgCACgCABEDAAsUACAAKAIAIAEgACgCBCgCEBECAAuTBwEDfyMAQfAAayIFJAAgBSADNgIMIAUgAjYCCAJ/AkACQAJAAkAgAUGBAk8EQEH9ASEGA0AgACAGaiIHQQNqLAAAQb9/Sg0DIAdBAmosAABBv39KDQIgB0EBaiwAAEG/f0oNBCAHLAAAQb9/Sg0FIAZBBGsiBkF9Rw0AC0EAIQYMBAsgBSABNgIUIAUgADYCEEEBDAQLIAZBAmohBgwCCyAGQQNqIQYMAQsgBkEBaiEGCyAFIAA2AhAgBSAGNgIUQQVBACABIAZLIgYbIQdB9JjCAEEBIAYbCyEGIAUgBzYCHCAFIAY2AhgCQAJAIAUgASACTwR/IAEgA08NASADBSACCzYCKCAFQQM2AjQgBUG8msIANgIwIAVCAzcCPCAFIAVBGGqtQoCAgICgAYQ3A1ggBSAFQRBqrUKAgICAoAGENwNQIAUgBUEoaq1CgICAgBCENwNIDAELIAIgA00EQCACRSABIAJNckUEQCADIAIgACACaiwAAEG/f0obIQMLIAUgAzYCIAJ/AkACQCABIANNDQBBACEHAkAgA0UNAANAIAAgA2osAABBv39KBEAgAyEHDAILIANBAWsiAw0ACwsgASAHRg0AAkACQCAAIAdqIgIsAAAiA0EASARAIAItAAFBP3EhACADQR9xIQEgA0FfSw0BIAFBBnQgAHIhBgwCCyAFIANB/wFxNgIkQQEMBAsgAi0AAkE/cSAAQQZ0ciEAIANBcEkEQCAAIAFBDHRyIQYMAQsgAUESdEGAgPAAcSACLQADQT9xIABBBnRyciIGQYCAxABGDQELIAUgBjYCJCAGQYABTw0BQQEMAgsgBBDdCQALQQIgBkGAEEkNABpBA0EEIAZBgIAESRsLIQAgBSAHNgIoIAUgACAHajYCLCAFQQU2AjQgBUH8mcIANgIwIAVCBTcCPCAFIAVBGGqtQoCAgICgAYQ3A2ggBSAFQRBqrUKAgICAoAGENwNgIAUgBUEoaq1CgICAgOAFhDcDWCAFIAVBJGqtQoCAgIDwBYQ3A1AgBSAFQSBqrUKAgICAEIQ3A0gMAQsgBUEENgI0IAVBnJnCADYCMCAFQgQ3AjwgBSAFQRhqrUKAgICAoAGENwNgIAUgBUEQaq1CgICAgKABhDcDWCAFIAVBDGqtQoCAgIAQhDcDUCAFIAVBCGqtQoCAgIAQhDcDSAsgBSAFQcgAajYCOCAFQTBqIAQQjQgACxQAIAAoAgAgASAAKAIEKAIMEQIACxEAIAAgASACIAMgBCAFENIECxIAIABBEUEQIAEtAJMBGzoAAAsVAgFvAX8QBSEAENoEIgEgACYBIAELEQAgACUBIAElASACJQEQBhoLFQIBbwF/EAchABDaBCIBIAAmASABC30BA38Q2gQiAyABJgECQAJAAkAgAARAIABBCGsiAiACKAIAQQFqIgQ2AgAgBEUNASAAKAIADQIgAEF/NgIAIABBBGogAxDEAiAAIAAoAgBBAWo2AgAgAiACKAIAQQFrIgA2AgAgAEUEQCACEOQGCwwDCxCOCgsACxCQCgALC4gBAQN/ENoEIgMgASYBAkACQAJAIAAEQCAAQQhrIgIgAigCAEEBaiIENgIAIARFDQEgACgCAA0CIABBfzYCACAAQQhqKAIAIABBDGooAgAgAxCtAyAAIAAoAgBBAWo2AgAgAiACKAIAQQFrIgA2AgAgAEUEQCACEOMGCwwDCxCOCgsACxCQCgALCxEAIAEgACgCACAAKAIEEJcDCxMAIABBKDYCBCAAQZifxwA2AgALEQAgASAAKAIEIAAoAggQlwMLEwAgAEHomsEANgIEIAAgATYCAAsTACAAQaSbwQA2AgQgACABNgIACxMAIABB4JvBADYCBCAAIAE2AgALEwAgAEGMnMEANgIEIAAgATYCAAsTACAAQcicwQA2AgQgACABNgIACxMAIABBhJ3BADYCBCAAIAE2AgALEwAgAEHAncEANgIEIAAgATYCAAsTACAAQfydwQA2AgQgACABNgIACxEAIAAoAgQgACgCCCABELUCCxEAIAEoAgAgASgCBCAAEMEDCxwAIABBmLvP7AM2AgggAELQ5+byk+vFmz83AgALEQAgACgCACAAKAIEIAEQtQILEwAgAEHMs8cANgIEIAAgATYCAAsTACAAQdyxxwA2AgQgACABNgIACxMAIABBiLTHADYCBCAAIAE2AgALEwAgAEHUsscANgIEIAAgATYCAAsTACAAQZiyxwA2AgQgACABNgIACxMAIABBkLPHADYCBCAAIAE2AgALEwAgAEG8jMgANgIEIAAgATYCAAsWAEG4u8kAIAA2AgBBtLvJAEEBOgAACxEBAX8Q2gQiASAAJQEmASABCw4AIAAlASABJQFBABAWCw8AQayewgBBKyAAEOsHAAtpAQF/IwBBMGsiAyQAIAMgADYCBCADIAE2AgAgA0EDNgIMIANB+JvCADYCCCADQgI3AhQgAyADQQRqrUKAgICAEIQ3AyggAyADrUKAgICAEIQ3AyAgAyADQSBqNgIQIANBCGogAhCNCAALEgAgACABLQDoBC0A+J1JOgAACwwAIAAlASABIAIQAgsMACAAIAEgAiUBEAMLDQAgACUBIAElARAIGgsMACAAIAEgAiUBEBkLEQAgAEGohsEA/QACAP0LAgALEQAgAEG4hsEA/QACAP0LAgALEQAgAEHIhsEA/QACAP0LAgALEQAgAEHYhsEA/QACAP0LAgALEQAgAEHohsEA/QACAP0LAgALEQAgAEH4hsEA/QACAP0LAgALEQAgAEGIh8EA/QACAP0LAgALEQAgAEGYh8EA/QACAP0LAgALEQAgAEGoh8EA/QACAP0LAgALEQAgAEG4h8EA/QACAP0LAgALEQAgAEHIh8EA/QACAP0LAgALEQAgAEHYh8EA/QACAP0LAgALEQAgAEHoh8EA/QACAP0LAgALEQAgAEH4h8EA/QACAP0LAgALEQAgAEGIiMEA/QACAP0LAgALEQAgAEGYiMEA/QACAP0LAgALEQAgAEGoiMEA/QACAP0LAgALEQAgAEG4iMEA/QACAP0LAgALEQAgAEHIiMEA/QACAP0LAgALEQAgAEHYiMEA/QACAP0LAgALEQAgAEHoiMEA/QACAP0LAgALEQAgAEH4iMEA/QACAP0LAgALEQAgAEGIicEA/QACAP0LAgALEQAgAEGYicEA/QACAP0LAgALEQAgAEGoicEA/QACAP0LAgALEQAgAEG4icEA/QACAP0LAgALEQAgAEHIicEA/QACAP0LAgALEQAgAEHYicEA/QACAP0LAgALDgAgAEG4oMEAIAEQwQMLDgAgAEGck8EAIAEQwQMLCgAgAEEEahDqAgsKACAAQQhqELEECxEAIABB8KDHAP0AAgD9CwIACxEAIABB5JPBAP0AAgD9CwIACxEAIABB9JPBAP0AAgD9CwIACxEAIABBhJTBAP0AAgD9CwIACxEAIABBlJTBAP0AAgD9CwIACxEAIABBpJTBAP0AAgD9CwIACxEAIABBtJTBAP0AAgD9CwIACxEAIABBxJTBAP0AAgD9CwIACxEAIABB1JTBAP0AAgD9CwIACxEAIABB5JTBAP0AAgD9CwIACw0AQeyNyABBGxCPCgALCQAgACABECgACw4AQYeOyABBzwAQjwoACwsAIAAoAgAgARBoCw4AIAFBsorDAEEYEJcDCw4AIAFBkIrDAEEgEJcDCxEAIABBkKHHAP0AAgD9CwIACw4AIAFBmJbIAEECEJcDCxEAIABBtLbEAP0AAgD9CwIACwwAIAAoAgAgARD8BAsRACAAQaS2xAD9AAIA/QsCAAsMACAAKAIAIAEQpgILDAAgACgCACABEPQECwwAIAAoAgAgARCeBAsMACAAKAIAIAEQiwULEQAgAEHgn8cA/QACAP0LAgALEQAgAEHQn8cA/QACAP0LAgALEQAgAEHgoMcA/QACAP0LAgALEQAgAEGAoMcA/QACAP0LAgALEQAgAEGgoMcA/QACAP0LAgALEQAgAEHAn8cA/QACAP0LAgALEQAgAEHAoMcA/QACAP0LAgALDQAgACABKQKEATcDAAsLACAALQCTAUECcgsKACAAQSBqEMYDCxEAIABB8J/HAP0AAgD9CwIACxEAIABBsKDHAP0AAgD9CwIACxEAIABB0KDHAP0AAgD9CwIACxEAIABBkKDHAP0AAgD9CwIACxEAIABBgKHHAP0AAgD9CwIACxEAIABBgPjHAP0AAgD9CwIACwwAIAAgASkCADcDAAsRACAAQZD4xwD9AAIA/QsCAAsKACAAIAElARAUC00BAX8jAEEwayIBJAAgAUEBNgIMIAFBoPjHADYCCCABQgE3AhQgASABQS9qrUKAgICAkAaENwMgIAEgAUEgajYCECABQQhqIAAQjQgAC00BAX8jAEEwayIBJAAgAUEBNgIMIAFBoPjHADYCCCABQgE3AhQgASABQS9qrUKAgICAoAaENwMgIAEgAUEgajYCECABQQhqIAAQjQgACwkAIABCATcDAAsJACAAQQA2AgALCgAgAEGAARDRBAsIACAAIAEQaAsSACAAQoaAgICAgICAgH83AwAL2QsCBX0GfwJ9QwAAgD8hAgJAAkACQAJAIAC8IgpBgICA/ANGDQAgAbwiCUH/////B3EiCEUNAAJ/AkAgAIsiA7wiB0GAgID8B0sgCEGAgID8B0tyRQRAIApBAE4NAUECIAhB////2wRLDQIaIAhBgICA/ANJDQFBACAIQZYBIAhBF3ZrIgt2IgwgC3QgCEcNAhpBAiAMQQFxawwCCyAAIAGSDAYLQQALIQsCQAJAAkACQCAIQYCAgPwDRwRAIAhBgICA/AdHDQECQAJAIAdBgICA/ANKIAdBgICA/ANIa0H/AXEOAgcBAAtDAAAAACABjCAJQQBOGwwKCyABQwAAAAAgCUEAThsMCQsgCUEASA0BIAAMCAsCQCAJQYCAgPgDRwRAIAlBgICAgARHDQEgACAAlAwJCyAKQQBODQILAkACQAJAAkAgB0EAIAdB/////wNxQYCAgPwDRxtFBEBDAACAPyADlSADIAlBAEgbIQIgCkEATg0IIAcgC2pBgICA/ANHDQEgAiACkyIAIACVDAwLQwAAgD8hBSAKQQBODQMgCw4CAQIDCyACjCACIAtBAUYbDAoLIAAgAJMiACAAlQwJC0MAAIC/IQULIAhBgICA6ARNBEAgA0MAAIBLlLwgByAHQYCAgARJIggbIgdB////A3EiCkGAgID8A3IhCyAHQRd1Qel+QYF/IAgbaiEIQQAhBwJAIApB8ojzAEkNACAKQdfn9gJJBEBBASEHDAELIApBgICA+ANyIQsgCEEBaiEICyAHQQJ0IgoqApC0SUMAAIA/IAoqAoi0SSIAIAu+IgSSlSICIAQgAJMiAyALQQF2QYDg//8BcSAHQRV0akGAgICCAmq+IgYgAyAClCIDvEGAYHG+IgKUkyAAIAaTIASSIAKUk5QiACACIAKUIgRDAABAQJIgACADIAKSlCADIAOUIgAgAJQgACAAIAAgACAAQ0LxUz6UQ1UybD6SlEMFo4s+kpRDq6qqPpKUQ7dt2z6SlEOamRk/kpSSIgaSvEGAYHG+IgCUIAMgBiAAQwAAQMCSIASTk5SSIgMgAyACIACUIgKSvEGAYHG+IgAgApOTQ084dj+UIABDxiP2uJSSkiICIAoqApi0SSIEIAIgAEMAQHY/lCIAkpIgCLIiApK8QYBgcb4iAyACkyAEkyAAk5MhAgwDCyAHQfj///sDTwRAIAdBh4CA/ANNBEAgA0MAAIC/kiIAQ3Cl7DaUIAAgAJRDAAAAPyAAIABDAACAvpRDq6qqPpKUk5RDO6q4v5SSIgIgAiAAQwCquD+UIgCSvEGAYHG+IgMgAJOTIQIMBAsgCUEATA0GDAcLIAlBAE4NBQwGC0MAAIA/IACVDAYLIACRDAULAkACQCADIAlBgGBxviIElCIAIAEgApQgASAEkyADlJIiAZIiArwiCUGAgICYBEwEQCAJQYCAgJgERg0BIAK8Qf////8HcSIHQYCA2JgESw0EIAEgAiAAk19FIAlBgIDYmHxHcg0CDAULDAULIAFDPKo4M5IgAiAAk14NBCACvEH/////B3EhBwtBACEIIAUCfSAHQYCAgPgDSwR/QQBBgICABCAHQRd2QQJqdiAJaiIHQf///wNxQYCAgARyQRYgB0EXdiIKa3YiCGsgCCAJQQBIGyEIIAEgAEGAgIB8IApBAWp1IAdxvpMiAJK8BSAJC0GAgH5xviICQwByMT+UIgUgAkOMvr81lCABIAIgAJOTQxhyMT+UkiICkiIAIAAgACAAIACUIgEgASABIAEgAUNMuzEzlEMO6t21kpRDVbOKOJKUQ2ELNruSlEOrqio+kpSTIgGUIAFDAAAAwJKVIAIgACAFk5MiASAAIAGUkpOTQwAAgD+SIgC8IAhBF3RqIglBgICABE4EQCAJvgwBCyAAIAgQsAYLlCECCyACDAMLIAVDYEKiDZRDYEKiDZQMAgsgBUNgQqINlENgQqINlAwBCyAFQ8rySXGUQ8rySXGUCwsIACAAJQEQAQsIACAAJQEQCgsIACAAJQEQFQsIACAAJQEQFwsIACAAJQEQGwsIACAALQDoBAsHABAqEIUICwQAQQALBABBAQsCAAsLtK4JiAEAQYCAwAAL8WFpbnZhbGlkIGxpdGVyYWwvbGVuZ3RocyBzZXQAaW52YWxpZCBjb2RlIGxlbmd0aHMgc2V0AHVua25vd24gaGVhZGVyIGZsYWdzIHNldABpbnZhbGlkIGRpc3RhbmNlcyBzZXQAaW52YWxpZCBiaXQgbGVuZ3RoIHJlcGVhdAAvVXNlcnMvZG1hcmNvcy9EZXZlbG9wbWVudC9zcGFyay9ydXN0L3NwYXJrLWxpYi9zcmMvc3B6LnJzAGxpYnJhcnkvY29yZS9zcmMvc3RyL2xvc3N5LnJzAC9Vc2Vycy9kbWFyY29zL0RldmVsb3BtZW50L3NwYXJrL3J1c3Qvc3BhcmstbGliL3NyYy9wbHkucnMAL3J1c3QvZGVwcy9ydXN0Yy1kZW1hbmdsZS0wLjEuMjYvc3JjL2xlZ2FjeS5ycwAvcnVzdGMvZjgyOTdlMzUxYTQwYzE0MzlhNDY3YmJiYjY4NzkwODgwNDdmNTBiMy9saWJyYXJ5L2NvcmUvc3JjL2l0ZXIvYWRhcHRlcnMvc3RlcF9ieS5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL21lbWNoci0yLjcuNi9zcmMvYXJjaC9hbGwvdHdvd2F5LnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjYuMy9zcmMvaW5mbGF0ZS93aW5kb3cucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS13ZWJwLTAuMi40L3NyYy95dXYucnMAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwBsaWJyYXJ5L2NvcmUvc3JjL3NsaWNlL3NvcnQvc2hhcmVkL3NtYWxsc29ydC5ycwAvcnVzdGMvZjgyOTdlMzUxYTQwYzE0MzlhNDY3YmJiYjY4NzkwODgwNDdmNTBiMy9saWJyYXJ5L2NvcmUvc3JjL3NsaWNlL3NvcnQvc3RhYmxlL3F1aWNrc29ydC5ycwBzcGFyay13b3JrZXItcnMvc3JjL3NvcnQucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9hbGxvYy9zcmMvYm94ZWQvY29udmVydC5ycwBsaWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hbnlob3ctMS4wLjk4L3NyYy9mbXQucnMAbGlicmFyeS9jb3JlL3NyYy9udW0vZGl5X2Zsb2F0LnJzAC9Vc2Vycy9kbWFyY29zL0RldmVsb3BtZW50L3NwYXJrL3J1c3Qvc3BhcmstbGliL3NyYy90c3BsYXQucnMAL1VzZXJzL2RtYXJjb3MvRGV2ZWxvcG1lbnQvc3BhcmsvcnVzdC9zcGFyay1saWIvc3JjL2tzcGxhdC5ycwAvVXNlcnMvZG1hcmNvcy9EZXZlbG9wbWVudC9zcGFyay9ydXN0L3NwYXJrLWxpYi9zcmMvYW50aXNwbGF0LnJzAC9Vc2Vycy9kbWFyY29zL0RldmVsb3BtZW50L3NwYXJrL3J1c3Qvc3BhcmstbGliL3NyYy9nc3BsYXQucnMAL1VzZXJzL2RtYXJjb3MvRGV2ZWxvcG1lbnQvc3BhcmsvcnVzdC9zcGFyay1saWIvc3JjL2NzcGxhdC5ycwBzcGFyay13b3JrZXItcnMvc3JjL2V4dF9zcGxhdHMucnMAc3Bhcmstd29ya2VyLXJzL3NyYy9wYWNrZWRfc3BsYXRzLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvZmRlZmxhdGUtMC4zLjcvc3JjL2RlY29tcHJlc3MucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS13ZWJwLTAuMi40L3NyYy9sb3NzbGVzcy5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlX2NvcmUtMS4wLjIyOC9zcmMvZGUvaW1wbHMucnMAL1VzZXJzL2RtYXJjb3MvRGV2ZWxvcG1lbnQvc3BhcmsvcnVzdC9zcGFyay1saWIvc3JjL3NvZ3MucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNi4zL3NyYy9pbmZsYXRlL2luZnRyZWVzLnJzAGxpYnJhcnkvc3RkL3NyYy9zeXMvc3luYy9tdXRleC9ub190aHJlYWRzLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvc3RkL3NyYy9zeXMvc3luYy9vbmNlL25vX3RocmVhZHMucnMAbGlicmFyeS9hbGxvYy9zcmMvc3RyLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRlcmF0b3IucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9hbnlob3ctMS4wLjk4L3NyYy9lcnJvci5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlX2pzb24tMS4wLjE0NS9zcmMvZXJyb3IucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS0wLjI1LjEwL3NyYy9jb2xvci5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL21lbWNoci0yLjcuNi9zcmMvYXJjaC9nZW5lcmljL3BhY2tlZHBhaXIucnMAbGlicmFyeS9jb3JlL3NyYy9zbGljZS9tZW1jaHIucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS13ZWJwLTAuMi40L3NyYy9sb29wX2ZpbHRlci5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC42LjMvc3JjL2luZmxhdGUvd3JpdGVyLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvY29yZS9zcmMvc2xpY2UvaXRlci5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2luZGV4bWFwLTIuMTMuMC9zcmMvaW5uZXIucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9taW5pel9veGlkZS0wLjguOS9zcmMvaW5mbGF0ZS9vdXRwdXRfYnVmZmVyLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcG5nLTAuMTguMS9zcmMvZGVjb2Rlci91bmZpbHRlcmluZ19idWZmZXIucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS0wLjI1LjEwL3NyYy9pbWFnZXMvYnVmZmVyLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcG5nLTAuMTguMS9zcmMvZGVjb2Rlci9yZWFkX2RlY29kZXIucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS13ZWJwLTAuMi40L3NyYy92cDhfYXJpdGhtZXRpY19kZWNvZGVyLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvaW1hZ2UtMC4yNS4xMC9zcmMvY29kZWNzL3dlYnAvZGVjb2Rlci5ycwAvVXNlcnMvZG1hcmNvcy9EZXZlbG9wbWVudC9zcGFyay9ydXN0L3NwYXJrLWxpYi9zcmMvZGVjb2Rlci5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ltYWdlLXdlYnAtMC4yLjQvc3JjL2RlY29kZXIucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96aXAtNy4yLjAvc3JjL3JlYWQvbWFnaWNfZmluZGVyLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvY29yZS9zcmMvY21wLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemlwLTcuMi4wL3NyYy9leHRyYV9maWVsZHMvZXh0ZW5kZWRfdGltZXN0YW1wLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvaW1hZ2UtMC4yNS4xMC9zcmMvbWV0YWRhdGEvY2ljcC5ycwBsaWJyYXJ5L3N0ZC9zcmMvaW8vc3RkaW8ucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9jb3JlL3NyYy9zdHIvcGF0dGVybi5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BuZy0wLjE4LjEvc3JjL2NvbW1vbi5ycwAvcnVzdGMvZjgyOTdlMzUxYTQwYzE0MzlhNDY3YmJiYjY4NzkwODgwNDdmNTBiMy9saWJyYXJ5L2NvcmUvc3JjL29wcy9mdW5jdGlvbi5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9mbHQyZGVjL3N0cmF0ZWd5L2RyYWdvbi5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2ZkZWZsYXRlLTAuMy43L3NyYy9odWZmbWFuLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvaW1hZ2Utd2VicC0wLjIuNC9zcmMvaHVmZm1hbi5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9iaWdudW0ucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS13ZWJwLTAuMi40L3NyYy9sb3NzbGVzc190cmFuc2Zvcm0ucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wbmctMC4xOC4xL3NyYy9kZWNvZGVyL3RyYW5zZm9ybS5ycwBsaWJyYXJ5L3N0ZC9zcmMvaW8vYnVmZmVyZWQvbGluZXdyaXRlcnNoaW0ucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wbmctMC4xOC4xL3NyYy9kZWNvZGVyL3N0cmVhbS5ycwAvcnVzdGMvZjgyOTdlMzUxYTQwYzE0MzlhNDY3YmJiYjY4NzkwODgwNDdmNTBiMy9saWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL2xvY2FsLnJzAGxpYnJhcnkvc3RkL3NyYy9zeW5jL2xhenlfbG9jay5ycwBsaWJyYXJ5L3N0ZC9zcmMvc3luYy9yZWVudHJhbnRfbG9jay5ycwAvcnVzdGMvZjgyOTdlMzUxYTQwYzE0MzlhNDY3YmJiYjY4NzkwODgwNDdmNTBiMy9saWJyYXJ5L3N0ZC9zcmMvc3luYy9vbmNlX2xvY2sucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS0wLjI1LjEwL3NyYy9jb2RlY3MvcG5nLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5ycwBsaWJyYXJ5L3N0ZC9zcmMvcGFuaWNraW5nLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvY29yZS9zcmMvaW8vYm9ycm93ZWRfYnVmLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMTcvc3JjL2V4dGVybnJlZi5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BuZy0wLjE4LjEvc3JjL2RlY29kZXIvdHJhbnNmb3JtL3BhbGV0dGUucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNi4zL3NyYy9pbmZsYXRlLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemxpYi1ycy0wLjYuMy9zcmMvYWxsb2NhdGUucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9taW5pel9veGlkZS0wLjguOS9zcmMvaW5mbGF0ZS9jb3JlLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvaW1hZ2UtMC4yNS4xMC9zcmMvaW8vaW1hZ2VfcmVhZGVyX3R5cGUucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96bGliLXJzLTAuNi4zL3NyYy9zdGFibGUucnMAbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAvVXNlcnMvZG1hcmNvcy9EZXZlbG9wbWVudC9zcGFyay9ydXN0L3NwYXJrLWxpYi9zcmMvY2h1bmtfdHJlZS5ycwBzcGFyay13b3JrZXItcnMvc3JjL2xvZF90cmVlLnJzAHNwYXJrLWxpYi9zcmMvc3BsYXRfZW5jb2RlLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtMS4wLjIyOC9zcmMvcHJpdmF0ZS9kZS5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlX2pzb24tMS4wLjE0NS9zcmMvZGUucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9zdGQvc3JjL3N5bmMvcG9pc29uL29uY2UucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAbGlicmFyeS9zdGQvc3JjL2JhY2t0cmFjZS5ycwAvcnVzdC9kZXBzL2hhc2hicm93bi0wLjE1LjUvc3JjL3Jhdy9tb2QucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9oYXNoYnJvd24tMC4xNi4xL3NyYy9yYXcvbW9kLnJzAGxpYnJhcnkvY29yZS9zcmMvZm10L21vZC5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL21lbWNoci0yLjcuNi9zcmMvYXJjaC9hbGwvcGFja2VkcGFpci9tb2QucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9wbmctMC4xOC4xL3NyYy9kZWNvZGVyL21vZC5ycwAvcnVzdGMvZjgyOTdlMzUxYTQwYzE0MzlhNDY3YmJiYjY4NzkwODgwNDdmNTBiMy9saWJyYXJ5L2FsbG9jL3NyYy9jb2xsZWN0aW9ucy9iaW5hcnlfaGVhcC9tb2QucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9zdGQvc3JjL2lvL21vZC5ycwBsaWJyYXJ5L3N0ZC9zcmMvLi4vLi4vYmFja3RyYWNlL3NyYy9zeW1ib2xpemUvbW9kLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvbWluaXpfb3hpZGUtMC44Ljkvc3JjL2luZmxhdGUvbW9kLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfY29yZS0xLjAuMjI4L3NyYy9kZS9tb2QucnMAbGlicmFyeS9zdGQvc3JjL3RocmVhZC9tb2QucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAL3J1c3RjL2Y4Mjk3ZTM1MWE0MGMxNDM5YTQ2N2JiYmI2ODc5MDg4MDQ3ZjUwYjMvbGlicmFyeS9hbGxvYy9zcmMvdmVjL21vZC5ycwBsaWJyYXJ5L2NvcmUvc3JjL251bS9mbHQyZGVjL21vZC5ycwAvVXNlcnMvZG1hcmNvcy9EZXZlbG9wbWVudC9zcGFyay9ydXN0L3NwYXJrLWxpYi9zcmMvdGlueV9sb2QucnMAL1VzZXJzL2RtYXJjb3MvRGV2ZWxvcG1lbnQvc3BhcmsvcnVzdC9zcGFyay1saWIvc3JjL2JoYXR0X2xvZC5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3psaWItcnMtMC42LjMvc3JjL2NyYzMyL2JyYWlkLnJzAC9ydXN0Yy9mODI5N2UzNTFhNDBjMTQzOWE0NjdiYmJiNjg3OTA4ODA0N2Y1MGIzL2xpYnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0ZWQucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9pbWFnZS13ZWJwLTAuMi40L3NyYy9leHRlbmRlZC5ycwAvVXNlcnMvZG1hcmNvcy9EZXZlbG9wbWVudC9zcGFyay9ydXN0L3NwYXJrLWxpYi9zcmMvcmFkLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGVfanNvbi0xLjAuMTQ1L3NyYy9yZWFkLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvemlwLTcuMi4wL3NyYy9yZWFkLnJzAC9ydXN0L2RlcHMvZGxtYWxsb2MtMC4yLjEwL3NyYy9kbG1hbGxvYy5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3ppcC03LjIuMC9zcmMvc3BlYy5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3BuZy0wLjE4LjEvc3JjL2RlY29kZXIvemxpYi5ycwBzcGFyay13b3JrZXItcnMvc3JjL2xpYi5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2NvbnNvbGVfZXJyb3JfcGFuaWNfaG9vay0wLjEuNy9zcmMvbGliLnJzAC9ydXN0L2RlcHMvcnVzdGMtZGVtYW5nbGUtMC4xLjI2L3NyYy9saWIucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9zZXJkZS13YXNtLWJpbmRnZW4tMC42LjUvc3JjL2xpYi5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2pzLXN5cy0wLjMuOTQvc3JjL2xpYi5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NtYWxsdmVjLTEuMTUuMS9zcmMvbGliLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcG5nLTAuMTguMS9zcmMvdGV4dF9tZXRhZGF0YS5ycwBsaWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvdW5pY29kZV9kYXRhLnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvaW1hZ2Utd2VicC0wLjIuNC9zcmMvdnA4LnJzAC9Vc2Vycy9kbWFyY29zLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcG5nLTAuMTguMS9zcmMvYWRhbTcucnMAL1VzZXJzL2RtYXJjb3MvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi96aXAtNy4yLjAvc3JjL2NwNDM3LnJzAHNwYXJrLWxpYi9zcmMvc3ltbWF0My5ycwAvVXNlcnMvZG1hcmNvcy8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3ppcC03LjIuMC9zcmMvY3JjMzIucnMAL3J1c3QvZGVwcy9ydXN0Yy1kZW1hbmdsZS0wLjEuMjYvc3JjL3YwLnJzAHRvbyBtYW55IGxlbmd0aCBvciBkaXN0YW5jZSBzeW1ib2xzAGludmFsaWQgc3RvcmVkIGJsb2NrIGxlbmd0aHMAaW52YWxpZCBjb2RlIC0tIG1pc3NpbmcgZW5kLW9mLWJsb2NrAGluY29ycmVjdCBoZWFkZXIgY2hlY2sAaW5jb3JyZWN0IGxlbmd0aCBjaGVjawBpbmNvcnJlY3QgZGF0YSBjaGVjawBpbnZhbGlkIGRpc3RhbmNlIHRvbyBmYXIgYmFjawBoZWFkZXIgY3JjIG1pc21hdGNoAGludmFsaWQgd2luZG93IHNpemUAcmVwZWF0ZWQgY2FsbCB3aXRoIGJhZCBzdGF0ZQBpbnZhbGlkIGJsb2NrIHR5cGUAaW52YWxpZCBsaXRlcmFsL2xlbmd0aCBjb2RlAGludmFsaWQgZGlzdGFuY2UgY29kZQB1bmtub3duIGNvbXByZXNzaW9uIG1ldGhvZABJSSoA7AUQACQAAABEAwAADQAAAOwFEAAkAAAARQMAAA0AAADsBRAAJAAAAEYDAAANAAAA7AUQACQAAABDAwAAQQAAAOwFEAAkAAAATwMAAA0AAADsBRAAJAAAAE8DAAA+AAAA7AUQACQAAAC4AwAAIQAAAOwFEAAkAAAAuAMAAA0AAADsBRAAJAAAALYDAAAlAAAA7AUQACQAAADGAwAAIQAAAOwFEAAkAAAAxgMAAA0AAADsBRAAJAAAAMQDAAAlAAAA7AUQACQAAABZAwAADQAAAOwFEAAkAAAAWgMAAA0AAADsBRAAJAAAAFsDAAANAAAA7AUQACQAAABYAwAAOwAAAOwFEAAkAAAAhAMAACUAAADsBRAAJAAAAIQDAAA2AAAA7AUQACQAAACGAwAAHQAAAOwFEAAkAAAAgAMAACUAAADsBRAAJAAAAJYDAAAlAAAA7AUQACQAAACWAwAANgAAAOwFEAAkAAAAlgMAAEsAAADsBRAAJAAAAJYDAABgAAAA7AUQACQAAACYAwAAHgAAAOwFEAAkAAAAkgMAACUAAADsBRAAJAAAAKgDAAAlAAAA7AUQACQAAACoAwAANgAAAOwFEAAkAAAAqAMAAEsAAADsBRAAJAAAAKgDAABgAAAA7AUQACQAAACqAwAAHgAAAOwFEAAkAAAApAMAACUAAADsBRAAJAAAAHEDAAANAAAA7AUQACQAAAByAwAADQAAAOwFEAAkAAAAcwMAAA0AAADsBRAAJAAAAHQDAAANAAAA7AUQACQAAABwAwAAPQAAAOwFEAAkAAAAZQMAAA0AAADsBRAAJAAAAGYDAAANAAAA7AUQACQAAABnAwAADQAAAOwFEAAkAAAAZAMAAD8AAACmAxAAUgAAAFIAAAATAAAADQUQAEAAAAB2AAAAIAAAAA0FEABAAAAAdQAAACIAAAANBRAAQAAAAHQAAAAeAAAADQUQAEAAAABzAAAAJgAAAA0FEABAAAAAcgAAACQAAAANBRAAQAAAAFQAAAAXAAAADQUQAEAAAABVAAAAFwAAAA0FEABAAAAAVgAAABcAAAANBRAAQAAAAFgAAAAWAAAADQUQAEAAAABZAAAAFgAAAA0FEABAAAAAWgAAABYAAAANBRAAQAAAAFwAAAAqAAAADQUQAEAAAABcAAAAFAAAAA0FEABAAAAAXQAAACoAAAANBRAAQAAAAF0AAAAUAAAADQUQAEAAAABeAAAAKgAAAA0FEABAAAAAXgAAABQAAAANBRAAQAAAAGAAAAApAAAADQUQAEAAAABgAAAAGAAAAA0FEABAAAAAYgAAACYAAAANBRAAQAAAAGMAAAAmAAAADQUQAEAAAABkAAAAJgAAAA0FEABAAAAAZQAAACYAAAANBRAAQAAAAGgAAAAVAAAADQUQAEAAAABpAAAAFQAAAA0FEABAAAAAagAAABUAAAANBRAAQAAAAGsAAAAVAAAASW52YWxpZCAuc3BsYXQgZmlsZSBzaXpl7CwQABgAAABhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWRNYXBBY2Nlc3M6Om5leHRfdmFsdWUgY2FsbGVkIGJlZm9yZSBuZXh0X2tleQD6GRAAYwAAAGYKAAAfAAAA7AUQACQAAADuAQAAOAAAAOwFEAAkAAAA7gEAAFkAAADsBRAAJAAAAPcBAABHAAAA7AUQACQAAAD3AQAAOQAAAOwFEAAkAAAAZAIAAC4AAADsBRAAJAAAAGQCAAAfAAAA7AUQACQAAABlAgAAHwAAAOwFEAAkAAAAWQIAACoAAADsBRAAJAAAAIQCAAA2AAAA7AUQACQAAACEAgAAIwAAAOwFEAAkAAAAeAIAACoAAADsBRAAJAAAAKQCAAA2AAAA7AUQACQAAACkAgAAIwAAAOwFEAAkAAAAmAIAACoAAADsBRAAJAAAANQCAAAlAAAA7AUQACQAAADYAgAAPAAAAOwFEAAkAAAA2AIAAB0AAADsBRAAJAAAANICAAAyAAAA7AUQACQAAADDAgAAIQAAAOwFEAAkAAAAxwIAADgAAADsBRAAJAAAAMcCAAAZAAAA7AUQACQAAADBAgAALgAAAOwFEAAkAAAAtAIAAB0AAADsBRAAJAAAALcCAAAsAAAA7AUQACQAAAC3AgAAEQAAAOwFEAAkAAAAuAIAADAAAADsBRAAJAAAALICAAAqAAAA7AUQACQAAADjAgAAJgAAAOwFEAAkAAAA5wIAACAAAADsBRAAJAAAAOcCAAATAAAA7AUQACQAAADtAgAAJgAAAOwFEAAkAAAA8QIAACAAAADsBRAAJAAAAPECAAATAAAA7AUQACQAAAB/AQAANgAAAOwFEAAkAAAAgAEAADYAAADsBRAAJAAAAI0BAAAzAAAA7AUQACQAAACOAQAAMwAAAOwFEAAkAAAAigEAAEQAAADsBRAAJAAAAIUBAAApAAAATWlzc2luZyBjaGlsZF9jb3VudHMgb3IgY2hpbGRfc3RhcnRz+C8QACQAAADsBRAAJAAAAAACAAA1AAAA7AUQACQAAAAAAgAAVgAAAOwFEAAkAAAAMAIAACoAAADsBRAAJAAAABsCAAA2AAAA7AUQACQAAAAbAgAAVwAAAOwFEAAkAAAAxgEAABUAAADsBRAAJAAAAMQBAAAlAAAA7AUQACQAAADIAQAAKAAAAOwFEAAkAAAAyQEAACgAAADsBRAAJAAAAMcBAAAoAAAA7AUQACQAAADFAQAAKAAAAOwFEAAkAAAAEgIAADcAAADsBRAAJAAAABICAABYAEH84cAACwUBAAAAfQBBjOLAAAsFAQAAAH4AQZziwAALBQEAAAB/AEGs4sAACwUBAAAAgABBvOLAAAsFAQAAAIEAQcziwAALBQEAAACCAEHc4sAACwUBAAAAgwBB7OLAAAsFAQAAAIQAQfziwAALBQEAAACFAEGM48AACwUBAAAAhgBBnOPAAAsFAQAAAIcAQazjwAALBQEAAACIAEG848AACwUBAAAAiQBBzOPAAAsFAQAAAIoAQdzjwAALBQEAAACLAEHs48AACwUBAAAAjABB/OPAAAsFAQAAAI0AQYzkwAALBQEAAACNAEGc5MAACwUBAAAAjQBBrOTAAAsFAQAAAI0AQbzkwAALBQEAAACNAEHM5MAACwUBAAAAjQBB3OTAAAsFAQAAAI0AQezkwAALBQEAAACNAEH85MAACwUBAAAAjQBBjOXAAAsFAQAAAI0AQZzlwAAL6QEBAAAAjQAAAGFuIGFycmF5IG9mIGxlbmd0aCAxYW4gYXJyYXkgb2YgbGVuZ3RoIDJhbiBhcnJheSBvZiBsZW5ndGggM2FuIGFycmF5IG9mIGxlbmd0aCA0bWlzc2luZyBmaWVsZCBgAPQyEAAPAAAA6JIRAAEAAABpbnZhbGlkIGxlbmd0aCAAFDMQAA8AAAAakxEACwAAAGR1cGxpY2F0ZSBmaWVsZCBgAAAANDMQABEAAADokhEAAQAAAHVua25vd24gdmFyaWFudCBgYCwgZXhwZWN0ZWQgAAAAWDMQABEAAABpMxAADABBkOfAAAsFAQAAAI4AQaDnwAALBQEAAACPAEGw58AACyUBAAAAkAAAAF4aEABgAAAAoAQAACIAAABeGhAAYAAAAJYEAAAmAEHg58AACwUBAAAAkQBB8OfAAAu9BgEAAACSAAAAc2gxc2gyc2gzYXNoM2Jsb2RUcmVlAAAAygUQACEAAAC4AAAAMAAAAMoFEAAhAAAAtgAAADAAAABtYXhTcGxhdHNudW1TcGxhdHNtYXhTaERlZ3JlZWV4dDBleHQxAAAAkwAAAAQAAAAEAAAAIAAAAMoFEAAhAAAATAAAAFMAAADKBRAAIQAAAE8AAABTAAAAygUQACEAAABSAAAAVQAAAMoFEAAhAAAAVQAAAFUAAABzaDFDb2Rlc8oFEAAhAAAAWAAAAF4AAABzaDJDb2Rlc8oFEAAhAAAAWwAAAF4AAABzaDNDb2Rlc8oFEAAhAAAAYQAAAFkAAADKBRAAIQAAAGQAAABcAAAAygUQACEAAABKAAAAZwAAAMoFEAAhAAAASQAAAGcAAADKBRAAIQAAAEgAAABtAAAAygUQACEAAABHAAAAaAAAAMoFEAAhAAAARgAAAGgAAAArIxAAbQAAAJUAAAAOAAAAcmdiTWlucmdiTWF4bG5TY2FsZU1pbmxuU2NhbGVNYXhzaDFNYXhzaDJNYXhzaDNNYXhsb2RPcGFjaXR5YDUQAAYAAABmNRAABgAAAGw1EAAKAAAAdjUQAAoAAACANRAABgAAAIY1EAAGAAAAjDUQAAYAAACSNRAACgAAABAjEAAaAAAAOQAAAC0AAAAQIxAAGgAAAC4AAAAzAAAA7AUQACQAAACKAAAAJwAAAHNoMwDsBRAAJAAAAJsAAAAuAAAAcGFja2VkAADsBRAAJAAAAEUAAABTAAAA7AUQACQAAABIAAAAUwAAAOwFEAAkAAAASwAAAFMAAADsBRAAJAAAAE4AAABeAAAA7AUQACQAAABRAAAAXgAAAOwFEAAkAAAAVAAAAF4AAADsBRAAJAAAAFcAAABcAAAAc3BsYXRFbmNvZGluZwAAAOwFEAAkAAAAWQAAAHwAAADsBRAAJAAAAEMAAABLAAAA7AUQACQAAABCAAAAbQAAAOwFEAAkAAAAQQAAAGgAAADsBRAAJAAAAEAAAABoAAAAECMQABoAAABWAAAALQAAABAjEAAaAAAASwAAADMAAACUAAAA9AAAAAQAAACVAAAAlgAAAJcAQbjuwAALZQEAAACYAAAAECMQABoAAACXAAAAKwAAAGZpbGVUeXBlECMQABoAAACZAAAAaAAAAJkAAAAIAAAABAAAAJoAAAAQIxAAGgAAAJYAAABYAAAAmwAAAJAAAAAEAAAAnAAAAJ0AAACeAEGo78AACy0BAAAAnwAAABAjEAAaAAAAkAEAAFsAAACgAAAAcAAAAAQAAAChAAAAogAAAKMAQeDvwAALLQEAAACkAAAAECMQABoAAAARAQAAWwAAAKUAAADsAAAABAAAAKYAAACnAAAAqABBmPDAAAvhFQEAAACpAAAAECMQABoAAAB5AAAAKwAAABAjEAAaAAAAewAAAGgAAAAQIxAAGgAAAHgAAABbAAAARXhwZWN0ZWQgIGFjdGl2ZSBzcGxhdHMgYnV0IGdvdCBQOBAACQAAAFk4EAAXAAAAigMQABsAAAAzAAAAFQAAAIoDEAAbAAAApwAAABMAAACKAxAAGwAAAJ8AAAATAAAAigMQABsAAACiAAAAHQAAAIoDEAAbAAAAogAAABEAAACKAxAAGwAAAJAAAAAgAAAAigMQABsAAACQAAAAFAAAAIoDEAAbAAAAfAAAABgAAACKAxAAGwAAAH0AAAAYAAAAigMQABsAAAB0AAAAGQAAALwZEAAfAAAA4wAAABYAAABsb2RJZAAAALwZEAAfAAAA7AAAAFQAAAC8GRAAHwAAAAkBAAAWAAAAvBkQAB8AAAATAQAAVAAAALwZEAAfAAAAJAEAAD0AAAC8GRAAHwAAADcBAAArAAAAvBkQAB8AAAA4AQAAKwAAALwZEAAfAAAAMgEAACsAAAC8GRAAHwAAADMBAAArAAAAvBkQAB8AAAC7AAAAMQAAALwZEAAfAAAA2QAAABMAAAC8GRAAHwAAAMoAAAAnAAAAvBkQAB8AAAC8AAAAJgAAALwZEAAfAAAAzwAAADYAAAC8GRAAHwAAAHcBAAAvAAAAvBkQAB8AAAB6AQAAHwAAAGluZGljZXMAvBkQAB8AAACWAQAAVgAAALwZEAAfAAAAgwEAACQAAAC8GRAAHwAAAIkBAAAjAAAAvBkQAB8AAACGAQAAIgAAALwZEAAfAAAAeAEAACYAAABJbnZhbGlkIGNvbmVfZm92cyBsZW5ndGhJbnZhbGlkIGNvbmVfZm92MHMgbGVuZ3RoSW52YWxpZCBjb25lX2ZvdmVhdGVzIGxlbmd0aEludmFsaWQgYmVoaW5kX2ZvdmVhdGVzIGxlbmd0aEludmFsaWQgbG9kX3NjYWxlcyBsZW5ndGhJbnZhbGlkIHZpZXdfdG9fb2JqZWN0cyBsZW5ndGgAALwZEAAfAAAA5wEAACYAAAC8GRAAHwAAAOkBAABDAAAAvBkQAB8AAADtAQAAGAAAALwZEAAfAAAA+wEAABkAAAC8GRAAHwAAAAACAAAZAAAAvBkQAB8AAAAHAgAAKwAAALwZEAAfAAAACwIAABgAAAC8GRAAHwAAABECAAAvAAAAvBkQAB8AAAATAgAAPgAAALwZEAAfAAAAFQIAABwAAAC8GRAAHwAAAAQCAAAYAAAAvBkQAB8AAAArAgAAJAAAAHBpeGVsTGltaXRpbnN0YW5jZUluZGljZXNjaHVua3NvdXRwdXRTaXplZnJvbnRpZXJTaXplbGVhZkNvdW50AAC8GRAAHwAAAFQCAABcAAAAvBkQAB8AAABTAgAAYgAAALwZEAAfAAAAUgIAAF4AAAC8GRAAHwAAAFECAABZAAAAvBkQAB8AAABQAgAAaAAAALwZEAAfAAAATwIAAGIAAAC8GRAAHwAAAD4CAAAjAAAAvBkQAB8AAABBAgAAWgAAALwZEAAfAAAAQAIAAHIAAAC8GRAAHwAAAD8CAABYAAAAvBkQAB8AAAAxAgAAHQAAALwZEAAfAAAAMQIAADMAAAC8GRAAHwAAAC0CAAAjAAAAvBkQAB8AAAAtAgAAHgAAALwZEAAfAAAAKAIAABwAAAC8GRAAHwAAACICAAAUAAAAvBkQAB8AAADSAQAAHQAAALwZEAAfAAAA1QEAADoAAAC8GRAAHwAAANoBAAAZAAAAvBkQAB8AAAC7AQAAMwAAALwZEAAfAAAAwAEAAB0AAAC8GRAAHwAAAMEBAAAiAAAAvBkQAB8AAADCAQAAIAAAALwZEAAfAAAAwwEAACAAAAC8GRAAHwAAAMQBAAAfAAAAvBkQAB8AAADGAQAAHQAAALwZEAAfAAAAvwEAADwAAAC8GRAAHwAAAL4BAAA9AAAAvBkQAB8AAAD1AAAAOgAAALwZEAAfAAAA9wAAAB0AAAC8GRAAHwAAAPgAAAAdAAAAvBkQAB8AAAD/AAAAWAAAAHZlcnNpb25jb3VudG1heFNoY2h1bmtTaXplYWxsQ2h1bmtCeXRlc3NoQ29kZUNvdW50c3RydWN0IFJhZE1ldGEgd2l0aCAxMSBlbGVtZW50cwAAAFY+EAAfAAAAAAAAAAgAAAAEAAAAqgAAAGZpbGVzbWluc21heHNzaGFwZXN0cnVjdCBNZWFucyB3aXRoIDQgZWxlbWVudHMAAKI+EAAcAAAAZW5jb2RpbmdzdHJ1Y3QgUXVhdHMgd2l0aCAyIGVsZW1lbnRz0D4QABwAAABzdHJ1Y3QgU2gwVjEgd2l0aCAzIGVsZW1lbnRz9D4QABwAAABjb2RlYm9va3N0cnVjdCBTaDBWMiB3aXRoIDIgZWxlbWVudHMgPxAAHAAAAHN0cnVjdCBTaE5WMSB3aXRoIDQgZWxlbWVudHNEPxAAHAAAAGJhbmRzc3RydWN0IFNoTlYyIHdpdGggMyBlbGVtZW50cwAAAG0/EAAcAAAAc3RydWN0IE1lYW5zVjEgd2l0aCA0IGVsZW1lbnRzAACUPxAAHgAAAG1lYW5zc2NhbGVzcXVhdHNzaDBzaE5zdHJ1Y3QgUGNTb2dzVjEgd2l0aCA1IGVsZW1lbnRzAAAA0j8QAB8AAABzdHJ1Y3QgUGNTb2dzVjIgd2l0aCA3IGVsZW1lbnRzAPw/EAAfAAAAc3RydWN0IFNjYWxlc1YxIHdpdGggMyBlbGVtZW50cwAkQBAAHwAAAHN0cnVjdCBTY2FsZXNWMiB3aXRoIDIgZWxlbWVudHMATEAQAB8AAABiYXNlcGF5bG9hZEJ5dGVzcHJvcGVydGllc3N0cnVjdCBSYWRDaHVua01ldGEgd2l0aCA4IGVsZW1lbnRzAAAAjkAQACMAAABnc3BsYXQAALxAEAAGAAAAb2Zmc2V0ZmlsZW5hbWVzdHJ1Y3QgUmFkQ2h1bmtSYW5nZSB3aXRoIDUgZWxlbWVudHMAANpAEAAkAAAAY29tcHJlc3Npb25taW5tYXhzdHJ1Y3QgUmFkQ2h1bmtQcm9wZXJ0eSB3aXRoIDcgZWxlbWVudHMZQRAAJwAAAGEgc2VxdWVuY2UAANsGEABmAAAAjQQAABwAAABzdHJ1Y3QgU2V0U3BsYXRFbmNvZGluZyB3aXRoIDggZWxlbWVudHMAZEEQACcAAABjZW50ZXJhbHBoYXJnYm9yaWVudGF0aW9uY2hpbGRfY291bnRjaGlsZF9zdGFydHNoMV9jb2Rlc2gyX2NvZGVzaDNfY29kZXNoX2xhYmVsAJRBEAAGAAAAmkEQAAUAAACfQRAAAwAAAME/EAAGAAAAokEQAAsAAAD4MxAAAwAAAPszEAADAAAADDYQAAMAAACtQRAACwAAALhBEAALAAAAw0EQAAgAAADLQRAACAAAANNBEAAIAAAA20EQAAgAAABmMTZmMzJfbGVieXRlc2YxNl9sZWJ5dGVzcjhyOF9kZWx0YXM4czhfZGVsdGFsbl8wcjhsbl9mMTZvY3Q4OHI4AogRAAMAAABUQhAAAwAAAFdCEAALAAAAYkIQAAsAAABtQhAAAgAAAG9CEAAIAAAAd0IQAAIAAAB5QhAACAAAAIFCEAAGAAAAh0IQAAYAAACNQhAABwAAAAdZEQADAAAABYgRAAMAQYSGwQALBQEAAACrAEGUhsEAC50NAQAAAKwAAABnegAAHEMQAAIAAACGV40hJKv8MZsV7Rqk/AqGIZHXkOAZBnMEwoE6QC5Aw02j52ZMofSR0h1OTNnv/LcqkTKWy/Ri3BOYR0yo5sJKZQUUCIJCw8J7T1YBdnE/LlNbgd6v+j3VsO5PRvEo+g1lOjkDtdomfifhYlnYlyaf521Pxr7v5E2F7c0GCuf+P/3rIsETwTMoA+inBzqud1sRrxXgIBVknwBi1PJVeIx7Aisj8rJUn2yy7loDmsKEpY45WsRC9+oSngcEldKewYpCm/q8AgqVZ7gNAZD9VtBrMivi9KBl2ERiQe5Ii0cFQ/5K+mCCgfdMVeJBLcgvjfuPC2mlqkI9RC+bfJ3D8Sr9x01mLnzmSbxuYaNTlztp3pcpSPbzROrxa62j6ZmoBdH97HYrR635JQTfXlV6a8Ovn+m9tKIApq4QCN4uyBE87DPEa42psDZg7WP62RG4/bUIrvZnfsvyWSH/wjd06x+Py+lMtpuEl8Ltn4DSZSE7nX4v+OWiItk2yi53ifdj62Zde1sqPTuH9PUU2hK7pnF7Y1zUyuJJAK68UxeBqShYoeSyUAtPu+nwuxBgZKitiEsgHhagE5RBXb1l1/jQzzzaT25jZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAADoRBAAKgAAAL8aEABTAAAAnAAAADIAAABzFBAATwAAAC8CAAAmAAAATw8QAGYAAACkAAAAKgAAAE8PEABmAAAABAEAACUAAACtAAAADAAAAAQAAACuAAAArQAAAAwAAAAEAAAArwAAAK4AAABcRRAAsAAAALEAAACyAAAAsAAAALMAAABBRVMgZW5jcnlwdGVkIGZpbGVzIGNhbm5vdCBiZSBkZWNyeXB0ZWQgd2l0aG91dCB0aGUgYWVzLWNyeXB0byBmZWF0dXJlLlZhcmlhYmxlLWxlbmd0aCBmaWVsZCBleHRlbmRzIGJleW9uZCBmaWxlIGJvdW5kYXJ5QUVTIGVuY3J5cHRpb24gd2l0aG91dCBBRVMgZXh0cmEgZGF0YSBmaWVsZEFyY2hpdmUgaGVhZGVyIGlzIHRvbyBsYXJnZQDOIRAAWQAAAOYCAAAZAAAAziEQAFkAAADqAgAAEwAAAE92ZXJzaXplZCBjZW50cmFsIGRpcmVjdG9yeVN1cHBvcnQgZm9yIG11bHRpLWRpc2sgZmlsZXMgaXMgbm90IGltcGxlbWVudGVkemlwOjp0eXBlczo6WmlwQ2VudHJhbEVudHJ5QmxvY2sAAFBLAQJJbnZhbGlkIENlbnRyYWwgRGlyZWN0b3J5IGhlYWRlcnppcDo6c3BlYzo6WmlwMzJDREVCbG9ja1BLBQZJbnZhbGlkIGRpZ2l0YWwgc2lnbmF0dXJlIGhlYWRlcgAAAIAkRxAAIAAAAHppcDo6c3BlYzo6WmlwNjRDREVMb2NhdG9yQmxvY2tJbnZhbGlkIHppcDY0IGxvY2F0b3IgZGlnaXRhbCBzaWduYXR1cmUgaGVhZGVyAAAAAAAAgG9HEAAuAAAAemlwOjpzcGVjOjpaaXA2NENERUJsb2NrUEsGBkludmFsaWQgRU9DRDY0OiBpbmNvbnNpc3RlbnQgbGVuZ3RoSW52YWxpZCBFT0NENjQ6IGluY29uc2lzdGVuY3kgd2l0aCBMb2NhdG9yIGRhdGFJbnZhbGlkIEVPQ0Q2NDogaW5jb25zaXN0ZW50IG51bWJlciBvZiBmaWxlc0NvdWxkIG5vdCBmaW5kIEVPQ0Q2NE11bHRpLWRpc2sgWklQIGZpbGVzIGFyZSBub3Qgc3VwcG9ydGVkSW52YWxpZCBFT0NENjQgTG9jYXRvciBDRCBvZmZzZXRObyBDREZIIGZvdW5kSW52YWxpZCBDREZIIG9mZnNldCBpbiBFT0NESW52YWxpZCBFT0NEIGNvbW1lbnQgbGVuZ3RoQ291bGQgbm90IGZpbmQgRU9DREVPQ0QgY29tbWVudCBleGNlZWRzIGZpbGUgYm91bmRhcnkAAABTIhAAWQAAABACAAAkAAAARU9DRDY0IGV4dGVuc2libGUgZGF0YSBzZWN0b3IgZXhjZWVkcyBmaWxlIGJvdW5kYXJ5RU9DRDY0IGV4dGVuZHMgYmV5b25kIEVPQ0Q2NCBsb2NhdG9yTG93IEVPQ0Q2NCByZWNvcmQgc2l6ZQAAALQAAAAMAAAABAAAALUAAAC2AAAAtwBBvJPBAAu5LAEAAAC4AAAAiggQAFgAAACtCAAAGwAAAIoIEABYAAAAqwgAABoAAADavuWfRqP1Qda9IYIEin9+bSFxc5z+Wz98T9PqHwhx/v/RdU8UjvBwCSevxkboy2vj/HVWg7aPELisF+ETauo3Bro1G72r6e53M2YWY4Y3fVerifDxfVD/AOsyEUOUJRdr73nJEJIZqhTGMt1wo/d9s9Z0rBITht2/xAQ7FZjtPv983P/+/w1gGQswk0k0V9UqAxAAXwAAAEoAAAAfAAAAKgMQAF8AAABEAAAAFwAAAAAAAADTCKOFiGo/JERzcAMuihkT0DGfKSI4CaSJbE7smPouCAAAAAAEAAAABAAAALkAAAD4HBAAYAAAAK4CAAATAAAAExsQAEoAAABfAwAACQAAAAAAAAAEAAAABAAAALoAAAC7AAAACAAAAAQAAAAWAAAAuwAAAAgAAAAEAAAAvAAAABYAAAD4ShAAvQAAAL4AAACyAAAAvwAAALMAAAAAAAAABAAAAAQAAADAAAAAAAAAAAQAAAAEAAAAwQAAAAAAAAAEAAAABAAAAMIAAABYWVoAAAAAAAQAAAAEAAAAwwAAAENlbnRlcnNBbHBoYXNTY2FsZXNRdWF0c1NoRXh0ZW5zaW9uQ2hpbGRDb3VudHNDaGlsZFN0YXJ0cwAAAAAAAAAIAAAABAAAAMQAAAAAAAAACAAAAAQAAADFAAAAxAAAALRLEACwAAAAxgAAALIAAACwAAAAswAAAAAAAAAIAAAABAAAAMcAAAAAAAAACAAAAAQAAABwAAAAxwAAAPBLEACwAAAAyAAAALIAAACwAAAAswAAAMkAAAAMAAAABAAAAMoAAADJAAAADAAAAAQAAADLAAAAygAAACxMEADMAAAAzQAAALIAAADOAAAAswAAAK0AAAAMAAAABAAAAM8AAACtAAAADAAAAAQAAADQAAAAzwAAAGhMEACwAAAA0QAAALIAAACwAAAAswAAANIAAAAMAAAABAAAANMAAADSAAAADAAAAAQAAADUAAAA0wAAAKRMEADVAAAA1gAAALIAAADXAAAAswAAANgAAAAEAAAABAAAANkAAADYAAAABAAAAAQAAADaAAAA2QAAAOBMEADbAAAA3AAAALIAAADdAAAAswAAAN4AAAAMAAAABAAAANMAAADeAAAADAAAAAQAAADfAAAA0wAAABxNEADgAAAA4QAAALIAAADgAAAAswAAAOIAAAAoAAAABAAAAOMAAADiAAAAKAAAAAQAAADkAAAA4wAAAFhNEADlAAAA5gAAAOcAAADoAAAA6QAAAOoAAAAgAAAABAAAAOMAAADqAAAAIAAAAAQAAADkAAAA4wAAAJRNEADlAAAA6wAAAOcAAADoAAAA6QAAAOwAAAAoAAAABAAAAOMAAADsAAAAKAAAAAQAAADkAAAA4wAAANBNEADlAAAA7QAAAOcAAADoAAAA6QAAAO4AAAAkAAAABAAAAOQAAADjAAAAdE4QAOUAAADvAAAA5wAAAOgAAADpAAAA8AAAACQAAAAEAAAA4wAAAPAAAAAkAAAABAAAAOQAAADjAAAAOE4QAOUAAADxAAAA5wAAAOgAAADpAAAA7gAAACQAAAAEAAAA4wAAAO4AAAAkAAAABAAAAOQAAADjAAAAdE4QAOUAAADyAAAA5wAAAOgAAADpAAAA8wAAACgAAAAEAAAA4wAAAPMAAAAoAAAABAAAAOQAAADjAAAAsE4QAOUAAAD0AAAA5wAAAOgAAADpAAAA9QAAACgAAAAEAAAA4wAAAPUAAAAoAAAABAAAAOQAAADjAAAA7E4QAOUAAAD2AAAA5wAAAOgAAADpAAAA9wAAAPgAAAD5AAAA+gAAAPsAAAD8AAAA/QAAAP4AAAD/AAAAAAEAAAEBAAACAQAA/AAAAP0AAAADAQAABAEAAAUBAAAGAQAABwEAAAgBAAD9AAAACQEAAAoBAAALAQAADAEAAA0BAAAOAQAA/QAAAA8BAAAQAQAAEQEAABIBAAATAQAADgEAAP0AAAD3AAAAFAEAABUBAAAWAQAAFwEAAPwAAAD9AAAAGAEAABkBAAAaAQAAGwEAABwBAAAdAQAA/QAAAB4BAAAfAQAAIAEAACEBAAAiAQAAIwEAACQBAAAAAAAABAAAAAQAAAAlAQAAJgEAAAQAAAAEAAAAJwEAANgAAAAEAAAABAAAANoAAAAAAAAABAAAAAQAAAAoAQAAKQEAACoBAABGMzJGMTZGMzJMZUJ5dGVzRjE2TGVCeXRlc1I4UjhEZWx0YVM4UzhEZWx0YUxuMFI4TG5GMTZPY3Q4OFI4VTE2VTMyAIwFEAA9AAAASQEAADIAAACMBRAAPQAAAEwBAAA7AAAAjAUQAD0AAABUAQAAMQAAAIwFEAA9AAAAWAEAADEAAACMBRAAPQAAAFABAAAxAAAATgUQAD0AAADzAQAAMQAAAE4FEAA9AAAA6AEAADIAAABOBRAAPQAAAO8BAAAxAAAATgUQAD0AAAD3AQAAMQAAAE4FEAA9AAAA6wEAADsAAAD6GRAAYwAAAPMBAAAVAAAA+hkQAGMAAADjAQAAFQAAACBzcGxhdHMsIGdvdCAAAABQOBAACQAAAFRREAANAAAAIFNIIHJlY29yZHMsIGdvdCAAAABQOBAACQAAAHRREAARAAAASW52YWxpZCBQTFkgZmlsZZhREAAQAAAASW5jb21wbGV0ZSBSQUQgY2h1bmuwURAAFAAAAFRydW5jYXRlZCBnemlwIHN0cmVhbQAAAMxREAAVAAAASW5jb21wbGV0ZSBTUFogc3RyZWFtOiBzdGFnZSA9ICwgc2hfZGVncmVlID0gAAAA7FEQAB8AAAALUhAADgAAAEludmFsaWQgU1BaIHN0cmVhbQAALFIQABIAAAAAAAAACAAAAAQAAAArAQAAiiQQAF4AAAD4BQAAHAAAAIokEABeAAAA+wUAABYAAABOb3QgYSBaSVAvU09HUyBmaWxlAHhSEAATAAAAU09HUyBmaWxlIHRvbyBzbWFsbACUUhAAEwAAAMoFEAAhAAAAnQMAAA0AAADKBRAAIQAAAJ8DAAANAAAAygUQACEAAACcAwAAQAAAAMoFEAAhAAAAqAMAAA0AAADKBRAAIQAAAKgDAAA9AAAAygUQACEAAAAwBAAAIwAAAMoFEAAhAAAAMAQAAA0AAADKBRAAIQAAAC4EAAAnAAAAygUQACEAAAA+BAAAIwAAAMoFEAAhAAAAPgQAAA0AAADKBRAAIQAAADwEAAAnAAAAygUQACEAAACyAwAADQAAAMoFEAAhAAAAsQMAADoAAADKBRAAIQAAAN4DAAA3AAAAygUQACEAAADfAwAAEQAAAMoFEAAhAAAA2QMAACcAAADKBRAAIQAAAPMDAAAoAAAAygUQACEAAAD3AwAAMwAAAMoFEAAhAAAA+AMAAA0AAADKBRAAIQAAAP0DAAA3AAAAygUQACEAAAD+AwAAEQAAAMoFEAAhAAAA/wMAABEAAADKBRAAIQAAAAAEAAARAAAAygUQACEAAADyAwAAKAAAAMoFEAAhAAAAEgQAACgAAADKBRAAIQAAAB4EAAA3AAAAygUQACEAAAAfBAAAEQAAAMoFEAAhAAAAIAQAABEAAADKBRAAIQAAACEEAAARAAAAygUQACEAAAAXBAAANwAAAMoFEAAhAAAAGAQAABEAAADKBRAAIQAAABEEAAAoAAAAygUQACEAAADKAwAADQAAAMoFEAAhAAAAyQMAADwAAADKBRAAIQAAAL4DAAANAAAAygUQACEAAAC9AwAAPgAAAKwOEAA+AAAABQIAACEAAABVbmtub3duIGZpbGUgdHlwZQAAAABVEAARAAAArA4QAD4AAAANAgAAHQAAAAwAAAAMAAAAEAAAAAQAAAAEAAAADAAAABgAAAAoAAAALAAAAAEAAAAGAAAABgAAAAgAAAAEAAAAAgAAAAYAAAAMAAAAFAAAABgAAAD/fwAABgAAAAYAAAAIAAAABAAAAAEAAAAGAAAADAAAABQAAAAYAAAA/38AAAAAAAAJAAAAGAAAAC0AAABTZWN0aW9uIGRhdGEgc2l6ZSBvdmVyZmxvdwAAtFUQABoAAADPBBAAPQAAAOAAAAAoAAAAzwQQAD0AAADiAAAAJgAAAM8EEAA9AAAA5AAAACkAAADPBBAAPQAAAOUAAAA5AAAAzwQQAD0AAADmAAAAOQAAAM8EEAA9AAAA5wAAADkAAADPBBAAPQAAAGkBAABZAAAAzwQQAD0AAABpAQAANgAAAM8EEAA9AAAAaAEAAFkAAADPBBAAPQAAAGgBAAA2AAAAzwQQAD0AAABnAQAAWAAAAM8EEAA9AAAAZwEAADYAAADPBBAAPQAAAGYBAABGAAAAzwQQAD0AAABmAQAAJAAAAM8EEAA9AAAAYwEAAEgAAADPBBAAPQAAAGMBAAAqAAAAzwQQAD0AAABiAQAASgAAAM8EEAA9AAAAYgEAACgAAADPBBAAPQAAAPYAAAAVAAAAzwQQAD0AAAALAQAAFwAAAM8EEAA9AAAAEQEAABcAAADPBBAAPQAAABcBAAAXAAAAzwQQAD0AAAAqAQAAFQAAAM8EEAA9AAAAKwEAABUAAADPBBAAPQAAACwBAAAVAAAAzwQQAD0AAAAtAQAAFQAAAM8EEAA9AAAAMQEAAB8AAADPBBAAPQAAADIBAAAfAAAAzwQQAD0AAAAzAQAAHwAAAM8EEAA9AAAANAEAAB4AAADPBBAAPQAAADQBAAAYAAAAGAAAAB8AAAAmAAAAGQAAACAAAAAnAAAAGgAAACEAAAAoAAAAGwAAACIAAAApAAAAHAAAACMAAAAqAAAAHQAAACQAAAArAAAAHgAAACUAAAAsAAAAzwQQAD0AAABTAQAAIAAAAM8EEAA9AAAATQEAACAAAADPBBAAPQAAAEgBAAAcAAAAzwQQAD0AAADdAAAAJAAAAEJ1Y2tldCBhcnJheSBvdXQgb2YgYm91bmRzAABcWBAAGgAAAFRydW5jYXRlZCBrc3BsYXQgZmlsZQAAAIBYEAAVAAAAVW5leHBlY3RlZCBlbmQgb2YgZmlsZSB3aGlsZSByZWFkaW5nIHNlY3Rpb24gaGVhZGVyc6BYEAA0AAAAU2VjdGlvbiBzaXplIG92ZXJmbG93AAAA3FgQABUAAABJbnZhbGlkIGNvbXByZXNzaW9uIGxldmVsIAAA/FgQABoAAABVbnN1cHBvcnRlZCAua3NwbGF0IHZlcnNpb246IAAAACBZEAAdAAAA7FwRAAEAAABGaWxlIHRvbyBzbWFsbCBmb3Iga3NwbGF0IGhlYWRlclBZEAAgAAAAU0ggYnl0ZSBvdXQgb2YgYm91bmRzAAAAeFkQABUAAADKBRAAIQAAAPgBAAA3AAAAygUQACEAAAD4AQAAWAAAAMoFEAAhAAAAAQIAAEYAAADKBRAAIQAAAAECAAA4AAAAygUQACEAAACUAgAANgAAAMoFEAAhAAAAlAIAACMAAADKBRAAIQAAAIgCAAA2AAAAygUQACEAAACIAgAARQAAAMoFEAAhAAAAiAIAAFgAAADKBRAAIQAAAIgCAAAVAAAAygUQACEAAACDAgAALAAAAMoFEAAhAAAAvgIAADYAAADKBRAAIQAAAL4CAAAjAAAAygUQACEAAADAAgAAJwAAAMoFEAAhAAAArwIAADgAAADKBRAAIQAAAK8CAABHAAAAygUQACEAAACvAgAAWgAAAMoFEAAhAAAArwIAABUAAADKBRAAIQAAALICAABCAAAAygUQACEAAACyAgAAUQAAAMoFEAAhAAAAsgIAAGQAAADKBRAAIQAAAKoCAAAyAAAAygUQACEAAACpAgAAMgAAAMoFEAAhAAAA9AIAAD8AAADKBRAAIQAAAPQCAAAmAAAAygUQACEAAADxAgAAOQAAAMoFEAAhAAAA8QIAACYAAADKBRAAIQAAAOMCAAA+AAAAygUQACEAAADjAgAATQAAAMoFEAAhAAAA4wIAAGAAAADKBRAAIQAAAOMCAAAVAAAAygUQACEAAADfAgAAOAAAAMoFEAAhAAAA3wIAAEcAAADKBRAAIQAAAN8CAABaAAAAygUQACEAAADfAgAAFQAAAMoFEAAhAAAA2gIAAC4AAADKBRAAIQAAANkCAAAuAAAAygUQACEAAAAnAwAAKQAAAMoFEAAhAAAALgMAAEsAAADKBRAAIQAAAC4DAAAhAAAAygUQACEAAAArAwAARQAAAMoFEAAhAAAAKwMAACEAAADKBRAAIQAAABQDAAAhAAAAygUQACEAAAAXAwAANgAAAMoFEAAhAAAAFwMAABUAAADKBRAAIQAAABkDAABAAAAAygUQACEAAAASAwAAMgAAAMoFEAAhAAAABAMAAB0AAADKBRAAIQAAAAgDAAA2AAAAygUQACEAAAAIAwAAFQAAAMoFEAAhAAAAAgMAAC4AAADKBRAAIQAAADsDAAAmAAAAygUQACEAAAA/AwAAIAAAAMoFEAAhAAAAPwMAABMAAADKBRAAIQAAAEUDAAAmAAAAygUQACEAAABJAwAAIAAAAMoFEAAhAAAASQMAABMAAADKBRAAIQAAAJ8BAAA2AAAAygUQACEAAACgAQAANgAAAMoFEAAhAAAArwEAADMAAADKBRAAIQAAALABAAAzAAAAygUQACEAAACsAQAAQwAAAMoFEAAhAAAApgEAAC0AAADKBRAAIQAAAKUBAAAtAAAAygUQACEAAAAKAgAANAAAAMoFEAAhAAAACgIAAFUAAADKBRAAIQAAAD8CAAA2AAAAygUQACEAAAA/AgAAPwAAAMoFEAAhAAAAPwIAAEwAAADKBRAAIQAAAD8CAAAVAAAAygUQACEAAAA6AgAALAAAAMoFEAAhAAAATAIAADIAAADKBRAAIQAAAFECAAA4AAAAygUQACEAAABRAgAAQQAAAMoFEAAhAAAAUQIAAE4AAADKBRAAIQAAAFECAAAVAAAAygUQACEAAABUAgAAQgAAAMoFEAAhAAAAVAIAAEsAAADKBRAAIQAAAFQCAABYAAAAygUQACEAAABUAgAAGQAAAMoFEAAhAAAASwIAADIAAADKBRAAIQAAAGMCAAAyAAAAygUQACEAAABsAgAAQgAAAMoFEAAhAAAAbAIAAEsAAADKBRAAIQAAAGwCAABYAAAAygUQACEAAABsAgAAGQAAAMoFEAAhAAAAaAIAADwAAADKBRAAIQAAAGgCAABFAAAAygUQACEAAABoAgAAUgAAAMoFEAAhAAAAaAIAABkAAADKBRAAIQAAAGICAAAyAAAAygUQACEAAAAlAgAANQAAAMoFEAAhAAAAJQIAAFYAAADKBRAAIQAAAM8BAAAnAAAAygUQACEAAADRAQAAFQAAAMoFEAAhAAAAzgEAACcAAADKBRAAIQAAANABAAAoAAAAygUQACEAAADTAQAAKAAAAMoFEAAhAAAA0gEAACgAAADKBRAAIQAAANQBAAAoAAAAygUQACEAAAAcAgAANgAAAMoFEAAhAAAAHAIAAFcAQYDAwQALBgEAAAAsAQBBkMDBAAsGAQAAAC0BAEGgwMEACwYBAAAALQEAQbDAwQALBgEAAAAtAQBBwMDBAAsGAQAAAC0BAEHQwMEACwYBAAAALgEAQeDAwQALBgEAAAAvAQBB8MDBAAsGAQAAADABAEGAwcEACwYBAAAAMQEAQZDBwQALBgEAAAAyAQBBoMHBAAutBwEAAAAzAQAAehkQAEEAAACaAQAADQAAAHoZEABBAAAAnQEAAA0AAAB6GRAAQQAAALMBAAAZAAAAb3V0cHV0IGJhdGNoIGNodW5rLCBjaHVua19yZWwgPSDYYBAAIAAAAG9jdGFudCBsZW5ndGhzOiAAYRAAEAAAAFz8EQABAAAAehkQAEEAAADjAQAAGQAAAHoZEABBAAAA2gEAACEAAABzcGxpdCBheGlzPSwgZXh0ZW50PSwgc3BsaXQ9LCBhLmxlbj0sIGIubGVuPUBhEAALAAAAS2EQAAkAAABUYRAACAAAAFxhEAAIAAAAZGEQAAgAAABc/BEAAQAAAHoZEABBAAAAzQEAAB0AAAB6GRAAQQAAAOgBAAAFAAAAehkQAEEAAADhAQAATgAAANcAEAA6AAAAPQAAADYAAABQTFkgaGVhZGVyIHRvbyBsYXJnZdxhEAAUAAAAZW5kX2hlYWRlcgoA1wAQADoAAABjAAAAHQAAANcAEAA6AAAAnQAAACQAAADXABAAOgAAAJwAAAAkAAAA1wAQADoAAACbAAAAJAAAANcAEAA6AAAAmgAAACYAAADXABAAOgAAAJkAAAAoAAAA1wAQADoAAACYAAAAJAAAANcAEAA6AAAAlwAAACwAAADXABAAOgAAAJYAAAAqAAAA1wAQADoAAAB0AAAAIgAAANcAEAA6AAAAhAAAACYAAADXABAAOgAAAIoAAAAmAAAA1wAQADoAAACQAAAAJgAAANcAEAA6AAAAfgAAACMAAADXABAAOgAAAHkAAAAkAAAA1wAQADoAAAB2AAAAIgAAANcAEAA6AAAAcQAAACUAAADXABAAOgAAALkAAAAdAAAA1wAQADoAAADOAAAALgAAANcAEAA6AAAAzQAAADAAAADXABAAOgAAAMwAAAAsAAAA1wAQADoAAADLAAAANAAAANcAEAA6AAAAygAAADIAAADXABAAOgAAANoAAABJAAAA1wAQADoAAADZAAAASQAAANcAEAA6AAAA2AAAACsAAADXABAAOgAAAOQAAAAvAAAAMCEQADoAAADvBQAAKwAAAEludmFsaWQgY2h1bmsgY291bnQ6IGV4cGVjdGVkICwgZ290IMRjEAAeAAAA4mMQAAYAAABVbnN1cHBvcnRlZCBSQUQgdmVyc2lvbjogAAAA+GMQABkAAAAwIRAAOgAAANcFAABAAAAASW52YWxpZCBSQUQgbWFnaWM6IDB4AAAALGQQABUAAAACAEHWyMEACwEIAEHgyMEAC8ElIAAA6VVuc3VwcG9ydGVkIFJBRCBjaHVuayB2ZXJzaW9uOiAAZGQQAB8AAAAwIRAAOgAAAEQGAAAvAAAARmFpbGVkIHRvIGRlY29tcHJlc3MgZ3ogZGF0YZxkEAAcAAAAVW5zdXBwb3J0ZWQgY2VudGVyIGVuY29kaW5nOiAAAADAZBAAHQAAAFByb3BlcnR5IG1pc3NpbmcgbWF46GQQABQAAABQcm9wZXJ0eSBtaXNzaW5nIG1pbgRlEAAUAAAAVW5zdXBwb3J0ZWQgYWxwaGEgZW5jb2Rpbmc6ICBlEAAcAAAAVW5zdXBwb3J0ZWQgcmdiIGVuY29kaW5nOiAAAERlEAAaAAAAVW5zdXBwb3J0ZWQgc2NhbGVzIGVuY29kaW5nOiAAAABoZRAAHQAAADAhEAA6AAAAqAYAAC8AAABVbnN1cHBvcnRlZCBvcmllbnRhdGlvbiBlbmNvZGluZzogAACgZRAAIgAAAFVuc3VwcG9ydGVkIGNoaWxkIGNvdW50IGVuY29kaW5nOiAAAMxlEAAiAAAAVW5zdXBwb3J0ZWQgY2hpbGQgc3RhcnQgZW5jb2Rpbmc6IAAA+GUQACIAAAAwIRAAOgAAAN0GAAAeAAAAVW5zdXBwb3J0ZWQgc2ggZW5jb2Rpbmc6IAAAADRmEAAZAAAAVW5zdXBwb3J0ZWQgc2ggbGFiZWwgZW5jb2Rpbmc6IABYZhAAHwAAADAhEAA6AAAAUwYAACQAAABQcm9wZXJ0eSBvZmZzZXQgbWlzbWF0Y2g6IGV4cGVjdGVkIACQZhAAIwAAAOJjEAAGAAAAMCEQADoAAACqBgAASAAAADAhEAA6AAAAOAYAADsAAAAwIRAAOgAAADcGAABFAAAASW52YWxpZCBSQUQgY2h1bmsgbWFnaWM6IDB4APRmEAAbAAAAVW5zdXBwb3J0ZWQgU1BaIHZlcnNpb246IAAAABhnEAAZAAAASW52YWxpZCBTUFogbWFnaWM6IDB4AAAAPGcQABUAAAB+ABAAOgAAAHkAAAApAAAAfgAQADoAAAB6AAAAKQAAAH4AEAA6AAAAewAAACkAAAB+ABAAOgAAAHsAAABPAAAAfgAQADoAAAB6AAAATwAAAH4AEAA6AAAAeQAAAE8AAAB+ABAAOgAAAIEAAAApAAAAfgAQADoAAACCAAAAKQAAAH4AEAA6AAAAgwAAACkAAAB+ABAAOgAAAIMAAABPAAAAfgAQADoAAACCAAAATwAAAH4AEAA6AAAAgQAAAE8AAAB+ABAAOgAAAJ4AAAA2AAAAfgAQADoAAACeAAAAJQAAAH4AEAA6AAAAuQAAADsAAAB+ABAAOgAAALkAAAAlAAAAfgAQADoAAAC6AAAAOwAAAH4AEAA6AAAAugAAACUAAAB+ABAAOgAAALsAAAA7AAAAfgAQADoAAAC7AAAAJQAAAH4AEAA6AAAA1QAAADwAAAB+ABAAOgAAANUAAAAlAAAAfgAQADoAAADWAAAAPAAAAH4AEAA6AAAA1gAAACUAAAB+ABAAOgAAANcAAAA8AAAAfgAQADoAAADXAAAAJQAAAH4AEAA6AAAA8wAAADQAAAB+ABAAOgAAAPQAAAAwAAAAfgAQADoAAAD1AAAAMAAAAH4AEAA6AAAA9gAAADAAAAB+ABAAOgAAAA4BAAApAAAAfgAQADoAAAAPAQAAKQAAAH4AEAA6AAAAEAEAACkAAAB+ABAAOgAAABEBAAApAAAAfgAQADoAAAAXAQAAMQAAAH4AEAA6AAAAGAEAADEAAAB+ABAAOgAAABkBAAAxAAAAfgAQADoAAAAcAQAAKQAAAH4AEAA6AAAAHQEAACkAAAB+ABAAOgAAAB4BAAApAAAAfgAQADoAAAAfAQAAKQAAAH4AEAA6AAAAMgEAACsAAAB+ABAAOgAAAFoBAABEAAAAfgAQADoAAABZAQAARAAAAH4AEAA6AAAAWAEAACoAAAB+ABAAOgAAAE8BAABlAAAAfgAQADoAAABPAQAANQAAAH4AEAA6AAAASAEAAGQAAAB+ABAAOgAAAEgBAAA1AAAAfgAQADoAAABCAQAAUwAAAH4AEAA6AAAAQgEAADEAAAB+ABAAOgAAAHsBAAApAAAAfgAQADoAAAB7AQAARwAAAH4AEAA6AAAAlQEAACsAAAB+ABAAOgAAAJUBAABJAAAAfgAQADoAAAC6AQAAJwAAAH4AEAA6AAAAyAEAAEEAAAB+ABAAOgAAAMEBAAAhAAAAbWV0YS5qc29ubWV0YS5qc29uIG5vdCBmb3VuZCBpbiBTT0dTIHppcAVrEAAfAAAAAQAAAAAAAABMUhEAAQAAAEZhaWxlZCB0byBwYXJzZSBtZXRhLmpzb24gZm9yIFNPR1MgaW4gY2FjaGUA5PcRAA0AAABeaxAACQAAAEIHEAA7AAAAMwIAADIAAABCBxAAOwAAADICAAAyAAAAQgcQADsAAAAxAgAAMgAAAEIHEAA7AAAAMAIAABwAAABCBxAAOwAAAC8CAAAeAAAAQgcQADsAAAAuAgAAGgAAAEIHEAA7AAAALQIAACIAAABCBxAAOwAAACwCAAAgAAAAZGF0YSBkaWQgbm90IG1hdGNoIGFueSB2YXJpYW50IG9mIHVudGFnZ2VkIGVudW0gUGNTb2dzUm9vdHF1YXRlcm5pb25fcGFja2VkZGVjb2RlIG1lYW5zWzBdZGVjb2RlIG1lYW5zWzFdZGVjb2RlIHNjYWxlc2RlY29kZSBxdWF0c2RlY29kZSBzaDBCBxAAOwAAABwBAAAWAAAAQgcQADsAAAAdAQAAFQAAAEIHEAA7AAAAHgEAABQAAABCBxAAOwAAAB8BAAATAAAAQgcQADsAAAAgAQAAFwAAAEIHEAA7AAAAIQEAADUAAABCBxAAOwAAACIBAAA1AAAAQgcQADsAAAAjAQAANQAAAFVuc3VwcG9ydGVkIHF1YXRlcm5pb24gZW5jb2RpbmcgaW4gU09HUyB2MQAABG0QACoAAABCBxAAOwAAAM0AAAAWAAAAQgcQADsAAADOAAAAFQAAAEIHEAA7AAAAzwAAABQAAABCBxAAOwAAANAAAAATAAAAQgcQADsAAADRAAAAFwAAAEIHEAA7AAAA0gAAADUAAABCBxAAOwAAANMAAAA1AAAAQgcQADsAAADUAAAANQAAAFVuZXhwZWN0ZWQgRU9GAAC4bRAADgAAAJEEEAA9AAAAdQAAABsAAACRBBAAPQAAAHYAAABBAAAANAEAANgCAAAIAAAANQEAADYBAAA3AQAAOAEAAMgpAAAEAAAAOQEAADoBAAA7AQAAPAEAAGwAAAAEAAAAPQEAAD4BAAA/AQAAPAEAAGwAAAAEAAAAQAEAAD4BAABBAQAAPAEAAGwAAAAEAAAAQgEAAD4BAABDAQAARAEAAKABAAAIAAAARQEAAEYBAABHAQAASAEAADADAAAIAAAASQEAAEoBAABLAQAATAEAACQqAAAEAAAATQEAAE4BAABPAQAAUAEAAMgAAAAEAAAAUQEAAFIBAABTAQAAUAEAAMgAAAAEAAAAVAEAAFIBAABVAQAAUAEAAMgAAAAEAAAAVgEAAFIBAABXAQAAWAEAAAACAAAIAAAAWQEAAFoBAABbAQAAXAEAALgCAAAIAAAAXQEAAF4BAABfAQAAYAEAAKgpAAAEAAAAYQEAAGIBAABjAQAAZAEAAEwAAAAEAAAAZQEAAGYBAABnAQAAZAEAAEwAAAAEAAAAaAEAAGYBAABpAQAAZAEAAEwAAAAEAAAAagEAAGYBAABrAQAAbAEAAIABAAAIAAAAbQEAAG4BAABvAQAAcAEAADgDAAAIAAAAcQEAAHIBAABzAQAAdAEAACwqAAAEAAAAdQEAAHYBAAB3AQAAeAEAANAAAAAEAAAAeQEAAHoBAAB7AQAAeAEAANAAAAAEAAAAfAEAAHoBAAB9AQAAeAEAANAAAAAEAAAAfgEAAHoBAAB/AQAAgAEAAAgCAAAIAAAAgQEAAIIBAACDAQAArA4QAD4AAACkAQAAJAAAAEludmFsaWQgZGVjb2RlciB0eXBlQHAQABQAAACsDhAAPgAAAL4BAAAJAAAArA4QAD4AAADDAQAAKQAAAKwOEAA+AAAAwAIAABwAAACsDhAAPgAAALsCAABBAAAArA4QAD4AAAC5AgAAQQAAAKwOEAA+AAAArQIAADUAAACsDhAAPgAAAKgCAAA1AAAArA4QAD4AAACkAgAAMQAAAKwOEAA+AAAAoAIAAC8AAACsDhAAPgAAAJ8CAAAxAAAArA4QAD4AAACeAgAALQAAAKwOEAA+AAAAnQIAADUAAACsDhAAPgAAAJwCAAAzAAAAhh8QAD8AAACYAAAAFQAAAHRpbnlfbG9kOjpjb21wdXRlX2xvZF90cmVlOiBzcGxhdHMubGVuPSwgbG9kX2Jhc2U9LCBtZXJnZV9maWx0ZXI9AAAAPHEQACcAAABjcRAACwAAAG5xEAAPAAAAbGV2ZWxfbWluOiAsIGZlYXR1cmVfc2l6ZVswXTogAACYcRAACwAAAKNxEAATAAAAhh8QAD8AAAA0AAAAFAAAAExldmVsOiAsIHN0ZXA6ICwgZnJvbnRpZXI6ICAvIAAA2HEQAAcAAADfcRAACAAAAOdxEAAMAAAA83EQAAMAAABTb3J0ZWQgYWN0aXZlOiAAGHIQAA8AAABNZXJnZWQ6IDByEAAIAAAA83EQAAMAAACGHxAAPwAAAHIAAAAXAAAAAQAAAIYfEAA/AAAAiQAAABMAAABSb290IGluZGV4OiBschAADAAAAFJvb3Q6IAAAgHIQAAYAAACGHxAAPwAAAIcAAAAFAAAAhh8QAD8AAABnAAAAKAAAAIYfEAA/AAAAZwAAAB0AAACGHxAAPwAAAGMAAAAdAAAAhh8QAD8AAABkAAAAGAAAAIYfEAA/AAAAYQAAAFAAAAANBRAAQAAAAM8AAAAdAAAAxh8QAEAAAADYAAAAFQAAAMYfEABAAAAAygAAABYAAABiaGF0dF9sb2Q6OmNvbXB1dGVfbG9kX3RyZWU6IGluaXRpYWxfbGVuPQAAACBzEAApAAAAxh8QAEAAAAAYAAAAGQAAACwgIyBhY3RpdmU6ICwgIyBzcGxhdHM6INhxEAAHAAAA33EQAAgAAADncRAADAAAAPNxEAADAAAAZHMQAAwAAABwcxAADAAAAMYfEABAAAAARQAAABoAAADGHxAAQAAAAHwAAAAdAAAAxh8QAEAAAABoAAAANwAAAMYfEABAAAAAawAAABoAAADGHxAAQAAAAGwAAABBAAAAxh8QAEAAAABvAAAAGwAAAMYfEABAAAAAcwAAACEAAADGHxAAQAAAAFQAAAAtAAAAUm9vdCBzcGxhdDogLHQQAAwAAADGHxAAQAAAAJEAAAAZAAAAxh8QAEAAAACVAAAADgAAAE91dHB1dCBzZXQ6IGB0EAAMAAAA83EQAAMAAABMb0QgZ3Jvd3RoIGZhY3RvcjogAHx0EAATAAAAxh8QAEAAAADgAAAADQAAAFBydW5pbmcgZnJvbSBsaW1pdF9zaXplPSwgIyBmcm9udGllcj0AAACodBAAGAAAAMB0EAANAAAAxh8QAEAAAADyAAAABQAAAFRydW5jYXRlZCB0byBvdXRwdXRfY291bnQ9AADwdBAAGgAAAEF2ZXJhZ2UgY2hpbGRyZW4gcGVyIGludGVyaW9yIHNwbGF0OiAAAAAUdRAAJQAAAFJvb3QgI2NoaWxkcmVuOiBEdRAAEAAAAMYfEABAAAAA9gAAABUAAADGHxAAQAAAAK8AAAAaAAAAxh8QAEAAAACyAAAAGQAAAGFzc2VydGlvbiBmYWlsZWQ6IG5ld19jaGlsZHJlbi5sZW4oKSA8PSA2NTUzNQAAAMYfEABAAAAAswAAABEAAAAKAACABAAAgAgAAIAQ6BEAoPsRAKP7EQCo+xEArvsRALf7EQADAAAAAwAAAAUAAAAGAAAACQAAAAMAAABkSxAAZUsQAGZLEAAHAAAABgAAAAMAAAAGAAAABQAAAAIAAAAJAAAACwAAAAsAAAAEAAAAeEsQAH9LEAD6TREAhUsQAItLEACQSxAAkksQAJtLEACmSxAAk9sRABgAAAAIAAAADwAAAAYAAAAEAAAADgAAAA0AAABe2xEAdtsRAH7bEQCN2xEAk9sRAJfbEQCl2xEAAwAAAAMAAAAKAAAACgAAAAIAAAAHAAAAAgAAAAcAAAAFAAAABQAAAAcAAAADAAAAAwAAAFBQEABTUBAAVlAQAGBQEABqUBAAbFAQAHNQEAB1UBAAfFAQAIFQEACGUBAAjVAQAJBQEADWAxAAIgAAAFIAAAATAAAA8hUQABsAAADoAQAAFwBBrO7BAAueAQEAAACEAQAA+QMQABgAAACKAgAADgAAAHEIEAAYAAAAggIAABMAAABxCBAAGAAAAJ8BAAA/AAAAcQgQABgAAACgAQAAMwAAANjKEQARAAAA9B4QACAAAAAqAgAAEQAAAIUBAAAMAAAABAAAAIYBAACHAQAAiAEAAEMbEAAaAAAAvQEAAB0AAAC0AAAADAAAAAQAAACJAQAAigEAAIsBAEHU78EACzUBAAAAuAAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYuaXNfY2hhcl9ib3VuZGFyeShuKQAAAgBBkvDBAAsBBQBBnPDBAAvOASAAAKggICAgICAgCgpDYXVzZWQgYnk6CgpzdGFjayBiYWNrdHJhY2U6U3RhY2sgYmFja3RyYWNlOgoAAEV4EAARAAAAEgQQAFwAAAA2AAAAHwAAABIEEABcAAAAPAAAABsAAABd/BEAAgAAAGJhY2t0cmFjZSBjYXB0dXJlIGZhaWxlZOMIEABeAAAAZwQAAA4AAAAAAAAAEAAAAAQAAACMAQAAjQEAAI4BAAAKClN0YWNrOgoKAAC0AAAADAAAAAQAAACJAQAAigEAAI8BAEH08cEAC4AYAQAAALgAAACoAQQBAQEEAQICAMAEAgQBCQIBAfsHzwEFATEtAQEBAgECAQEsAQsGCgsBASMBChUQAWUIAQoBBCEBAQEeG1sLOgsEAQIBGBgrAywBBwIFCSk6NwEBAQQIBAEDBwoCDQEPAToBBAQIARQCGgECAjkBBAIEAgIDAwEeAgMBCwI5AQQFAQIEARQCFgYBAToBAgEBBAgBBwILAh4BPQEMATIBAwE3AQEDBQMBBAcCCwIdAToBAgEGAQUCFAIcAjkCBAQIARQCHQFIAQcDAQFaAQIHCwliAQIJCQEBB0kCGwEBAQEBNw4BBQECBQsBJAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAV4BAAMAAx0CHgIeAkACAQcIAQILAwEFAS0FMwFBAiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEnAQgfMQQwAQEFAQEFASgJDAIgBAICAQM4AQECAwEBAzoIAgJABlIDAQ0BBwQBBgEDAjI/DQEiZQABAQMLAw0DDQMNAgwFCAIKAQIBAgUxBQEKAQENARANMyEAAnEDfQEPAWAgLwEAASQEAwUFAV0GXQMAAQAGAAFiBAEKAQEcBFACDiJOARcDZwMDAggBAwEEARkCBQGXAhoSDQEmCBkLLgMwAQIEAgIRARUCQgYCAgICDAEIASMBCwEzAQEDAgIFAgEBGwEOAgUCAQFkBQkDeQECAQQBAAGTEQAQAwEMECIBAgGpAQcBBgELASMBAQEvAS0CQwEVAwAB4gGVBQAGASoBCQADAQIFBCgDBAGlAgAEJgEaBQEBAAJPBEYLMQR7ATYPKQECAgoDMQQCAgIBBAEKATIDJAUBCD4BDAI0CQoEAgFfAwIBAQIGAQIBnQEDCBUCOQIDASUHAwVGBg0BAQEBAQ4CVQgCAwEBFwFUBgEBBAIBAu4EBgIBAhsCVQgCAQECagEBAQIGAQFlAQEBAgQBBQAJAQIAAgEBBAGQBAICBAEgCigGAgQIAQkGAgMuDQECAAcBBgEBUhYCBwECAQJ6BgMBAQIBBwEBSAIDAQEBAAILAjQFBQEBARcBABEGDwAMAwMABTsHCQQAAygCAAE/EUACAQIABAEHAQIAAgEEAC4CFwADCRACBx4ElAMANwQyCAEOARYFAQ8ABwERAgcBAgEFBT4hAaAOAAE9BAAF/gIAB20IAAUAAR5ggPAAAHAABwAtAQEBAgECAQFICzAVEAFlBwIGAgIBBCMBHhtbCzoJCQEYBAEJAQMBBSsDOwkqGAEgNwEBAQQIBAEDBwoCHQE6AQEBAgQIAQkBCgIaAQICOQEEAgQCAgMDAR4CAwELAjkBBAUBAgQBFAIWBgEBOgEBAgEECAEHAwoCHgE7AQEBDAEJASgBAwE3AQEDBQMBBAcCCwIdAToBAgIBAQMDAQQHAgsCHAI5AgEBAgQIAQkBCgIdAUgBBAECAwEBCAFRAQIHDAhiAQIJCwdJAhsBAQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwEAAwAEHAMdAh4CQAIBBwgBAgsJAS0DAQF1AiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEwHzEEMAoEAyYJDAIgBAIGOAEBAgMBAQU4CAICmAMBDQEHBAEGAQMCxkAAAcMhAAONAWAgAAZpAgAEAQogAlACAAEDAQQBGQIFAZcCGhINASYIGQsBASwDMAECBAICAgEkAUMGAgICAgwBCAEvATMBAQMCAgUCAQEqAggB7gECAQQBAAEAEBAQAAIAAeIBlQUAAwECBQQoAwQBpQIABEEFAAJPBEYLMQR7ATYPKQECAgoDMQQCAgcBPQMkBQEIPgEMAjQJAQEIBAIBXwMCBAYBAgGdAQMIFQI5AgEBAQEMAQkBDgcDBUMBAgYBAQIBAQMEAwEBDgJVCAIDAQEXAVEBAgYBAQIBAQIBAusBAgQGAgECGwJVCAIBAQJqAQEBAghlAQEBAgQBBQAJAQL1AQoEBAGQBAICBAEgCigGAgQIAQkGAgMuDQECAAcBBgEBUhYCBwECAQJ6BgMBAQIBBwEBSAIDAQEBAAILAjQFBQMXAQABBg8ADAMDAAU7BwABPwRRAQsCAAIALgIXAAUDBggIAgceBJQDADcEMggBDgEWBQEPAAcBEQIHAQIBBWQBoAcAAT0EAAT+AgAHbQcAYIDwAKoBCgEEAQUXAR8BwwEEBNABJAcCHgVgASoEAgICBAEBBgEBAwEBARQBUwGLCKYBJgkpACYBAQUBAisBBABWAgYACwUrAgNAwEAAAgYCJgIGAggBAQEBAQEBHwI1AQcBAQMDAQcDBAIGBA0FAwEHdAENARANZQEEAQIKAQEDBQYBAQEBAQEEAQYEAQIEBQUEAREgAwIANADlBgQDAgwmAQEFAQAuEh6EZgMEAT4CAgEBAQgVBQEDACsBDgZQAAcMBQAaBhoAUGAkBCR0CwEPAQcBAgELAQ8BBwECAAECAwEqAQkAMw0zXRYKFgBAAEAAVQFHAQICAQICAgQBDAEBAQcBQQEEAggBBwEcAQQBBQEBAwcBAAIZARkBHwEZAR8BGQEfARkBHwEZAQgACgEUBgYAPgBEABoGGgYaAEFueQocEAAbAAAArwoAACYAAAAKHBAAGwAAALgKAAAaAAAAKzAxMjM0NTY3ODlBQkNERUYsCigKAAAAAAAAAAwAAAAEAAAAkAEAAJEBAACSAQAAIHsKIHsgLi4gfTAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAocEAAbAAAANQcAAB8AAABhc3NlcnRpb24gZmFpbGVkOiBvdGhlciA+IDBhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvdwAAAOoSEAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBkaWdpdHMgPCA0MDAuMGUwYXNzZXJ0aW9uIGZhaWxlZDogIWJ1Zi5pc19lbXB0eSgpAGIfEAAjAAAAtwAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBidWZbMF0gPiBiJzAnAGIfEAAjAAAAuAAAAAUAAABiHxAAIwAAAAYBAAAFAAAAYh8QACMAAAAHAQAABQAAAGVlLWFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBtYXhsZW5iHxAAIwAAAHoCAAANAAAAYh8QACMAAACZAAAADgAAAN9FGj0DzxrmwfvM/gAAAADKxprHF/5wq9z71P4AAAAAT9y8vvyxd//2+9z+AAAAAAzWa0HvkVa+Efzk/gAAAAA8/H+QrR/QjSz87P4AAAAAg5pVMShcUdNG/PT+AAAAALXJpq2PrHGdYfz8/gAAAADLi+4jdyKc6nv8BP8AAAAAbVN4QJFJzK6W/Az/AAAAAFfOtl15EjyCsfwU/wAAAAA3VvtNNpQQwsv8HP8AAAAAT5hIOG/qlpDm/CT/AAAAAMc6giXLhXTXAP0s/wAAAAD0l7+Xzc+GoBv9NP8AAAAA5awqF5gKNO81/Tz/AAAAAI6yNSr7ZziyUP1E/wAAAAA7P8bS39TIhGv9TP8AAAAAus3TGidE3cWF/VT/AAAAAJbJJbvOn2uToP1c/wAAAACEpWJ9JGys27r9ZP8AAAAA9tpfDVhmq6PV/Wz/AAAAACbxw96T+OLz7/10/wAAAAC4gP+qqK21tQr+fP8AAAAAi0p8bAVfYocl/oT/AAAAAFMwwTRg/7zJP/6M/wAAAABVJrqRjIVOllr+lP8AAAAAvX4pcCR3+d90/pz/AAAAAI+45bifvd+mj/6k/wAAAACUfXSIz1+p+Kn+rP8AAAAAz5uoj5NwRLnE/rT/AAAAAGsVD7/48AiK3/68/wAAAAC2MTFlVSWwzfn+xP8AAAAArH970MbiP5kU/8z/AAAAAAY7KyrEEFzkLv/U/wAAAADTknNpmSQkqkn/3P8AAAAADsoAg/K1h/1j/+T/AAAAAOsaEZJkCOW8fv/s/wAAAADMiFBvCcy8jJn/9P8AAAAALGUZ4lgXt9Gz//z/AEH+icIACwVAnM7/BABBjIrCAAvoDRCl1Ojo/wwAAAAAAAAAYqzF63itAwAUAAAAAACECZT4eDk/gR4AHAAAAAAAsxUHyXvOl8A4ACQAAAAAAHBc6nvOMn6PUwAsAAAAAABogOmrpDjS1W0ANAAAAAAARSKaFyYnT5+IADwAAAAAACf7xNQxomPtogBEAAAAAACorciMOGXesL0ATAAAAAAA22WrGo4Ix4PYAFQAAAAAAJodcUL5HV3E8gBcAAAAAABY5xumLGlNkg0BZAAAAAAA6o1wGmTuAdonAWwAAAAAAEp375qZo22iQgF0AAAAAACFa320e3gJ8lwBfAAAAAAAdxjdeaHkVLR3AYQAAAAAAMLFm1uShluGkgGMAAAAAAA9XZbIxVM1yKwBlAAAAAAAs6CX+ly0KpXHAZwAAAAAAONfoJm9n0be4QGkAAAAAAAljDnbNMKbpfwBrAAAAAAAXJ+Yo3KaxvYWArQAAAAAAM6+6VRTv9y3MQK8AAAAAADiQSLyF/P8iEwCxAAAAAAApXhc05vOIMxmAswAAAAAAN9TIXvzWhaYgQLUAAAAAAA6MB+X3LWg4psC3AAAAAAAlrPjXFPR2ai2AuQAAAAAADxEp6TZfJv70ALsAAAAAAAQRKSnTEx2u+sC9AAAAAAAGpxAtu+Oq4sGA/wAAAAAACyEV6YQ7x/QIAMEAQAAAAApMZHp5aQQmzsDDAEAAAAAnQycofubEOdVAxQBAAAAACn0O2LZICiscAMcAQAAAACFz6d6XktEgIsDJAEAAAAALd2sA0DkIb+lAywBAAAAAI//RF4vnGeOwAM0AQAAAABBuIycnRcz1NoDPAEAAAAAqRvjtJLbGZ71A0QBAAAAANl337puv5brDwRMAQAAAADLAhAALgAAAH0AAAAVAAAAywIQAC4AAADvAgAAJgAAAMsCEAAuAAAA4wIAACYAAADLAhAALgAAAMwCAAAmAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ID4gMMsCEAAuAAAA3AEAAAUAAADLAhAALgAAADMCAAARAAAAywIQAC4AAABsAgAACQAAAMsCEAAuAAAAqQAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1pbnVzID4gMAAAAMsCEAAuAAAAqgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLnBsdXMgPiAwywIQAC4AAACrAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCArIGQucGx1cyA8ICgxIDw8IDYxKQAAAMsCEAAuAAAArwAAAAUAAADLAhAALgAAAAoBAAARAAAAywIQAC4AAABAAQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX3N1YihkLm1pbnVzKS5pc19zb21lKCkAywIQAC4AAACtAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX2FkZChkLnBsdXMpLmlzX3NvbWUoKQAAywIQAC4AAACsAAAABQAAAPQREAAvAAAACwEAAAUAAAD0ERAALwAAAAwBAAAFAAAA9BEQAC8AAAANAQAABQAAAPQREAAvAAAAcgEAACQAAAD0ERAALwAAAHcBAAAvAAAA9BEQAC8AAACEAQAAEgAAAPQREAAvAAAAZgEAAA0AAAD0ERAALwAAAEwBAAAiAAAA9BEQAC8AAAAPAQAABQAAAPQREAAvAAAADgEAAAUAAAD0ERAALwAAAHYAAAAFAAAA9BEQAC8AAAB3AAAABQAAAPQREAAvAAAAeAAAAAUAAAD0ERAALwAAAMIAAAAJAAAA9BEQAC8AAAD7AAAADQAAAPQREAAvAAAAAgEAABIAAAD0ERAALwAAAHoAAAAFAAAA9BEQAC8AAAB5AAAABQAAAAEAAAAKAAAAZAAAAOgDAAAQJwAAoIYBAEBCDwCAlpgAAOH1BQDKmjvBb/KGIwAAAIHvrIVbQW0t7gQAAAEfar9k7Thu7Zen2vT5P+kDTxgAAT6VLgmZ3wP9OBUPL+R0I+z1z9MI3ATE2rDNvBl/M6YDJh/pTgIAAAF8Lphbh9O+cp/Z2IcvFRLGUN5rcG5Kzw/YldVucbImsGbGrSQ2FR1a00I8DlT/Y8BzVcwX7/ll8ii8VffH3IDc7W70zu/cX/dTBQBvBBAAIQAAAC4AAAAJAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAQbaYwgALMwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMDAwMDAwMDAwMDAwMDAwMEBAQEBABB9JjCAAv1cFsuLi5dYmVnaW4gPD0gZW5kICggPD0gKSB3aGVuIHNsaWNpbmcgYAB5jBAADgAAAIeMEAAEAAAAi4wQABAAAADokhEAAQAAAGJ5dGUgaW5kZXggIGlzIG5vdCBhIGNoYXIgYm91bmRhcnk7IGl0IGlzIGluc2lkZSAgKGJ5dGVzICkgb2YgYAC8jBAACwAAAMeMEAAmAAAA7YwQAAgAAAD1jBAABgAAAOiSEQABAAAAIGlzIG91dCBvZiBib3VuZHMgb2YgYAAAvIwQAAsAAAAkjRAAFgAAAOiSEQABAAAAJhEQAB8AAABnBgAAFQAAACYREAAfAAAAlQYAABUAAAAmERAAHwAAAJYGAAAVAAAAJhEQAB8AAAB0BQAAKAAAACYREAAfAAAAdAUAABIAAABjb3B5X2Zyb21fc2xpY2U6IHNvdXJjZSBzbGljZSBsZW5ndGggKCkgZG9lcyBub3QgbWF0Y2ggZGVzdGluYXRpb24gc2xpY2UgbGVuZ3RoICgAAACkjRAAJgAAAMqNEAArAAAAXgcSAAEAAAB1c2VyLXByb3ZpZGVkIGNvbXBhcmlzb24gZnVuY3Rpb24gZG9lcyBub3QgY29ycmVjdGx5IGltcGxlbWVudCBhIHRvdGFsIG9yZGVyEI4QAEwAAAD6AhAALwAAAFwDAAAFAAAAcmFuZ2Ugc3RhcnQgaW5kZXggIG91dCBvZiByYW5nZSBmb3Igc2xpY2Ugb2YgbGVuZ3RoIHSOEAASAAAAho4QACIAAAByYW5nZSBlbmQgaW5kZXgguI4QABAAAACGjhAAIgAAAHNsaWNlIGluZGV4IHN0YXJ0cyBhdCAgYnV0IGVuZHMgYXQgANiOEAAWAAAA7o4QAA0AAAB1ChAAIAAAAIQAAAAeAAAAdQoQACAAAACgAAAACQAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9uZWAgdmFsdWUAwAAAAOAAAADBAAAA4QAAAMIAAADiAAAAwwAAAOMAAADEAAAA5AAAAMUAAADlAAAAxgAAAOYAAADHAAAA5wAAAMgAAADoAAAAyQAAAOkAAADKAAAA6gAAAMsAAADrAAAAzAAAAOwAAADNAAAA7QAAAM4AAADuAAAAzwAAAO8AAADQAAAA8AAAANEAAADxAAAA0gAAAPIAAADTAAAA8wAAANQAAAD0AAAA1QAAAPUAAADWAAAA9gAAANgAAAD4AAAA2QAAAPkAAADaAAAA+gAAANsAAAD7AAAA3AAAAPwAAADdAAAA/QAAAN4AAAD+AAAAAAEAAAEBAAACAQAAAwEAAAQBAAAFAQAABgEAAAcBAAAIAQAACQEAAAoBAAALAQAADAEAAA0BAAAOAQAADwEAABABAAARAQAAEgEAABMBAAAUAQAAFQEAABYBAAAXAQAAGAEAABkBAAAaAQAAGwEAABwBAAAdAQAAHgEAAB8BAAAgAQAAIQEAACIBAAAjAQAAJAEAACUBAAAmAQAAJwEAACgBAAApAQAAKgEAACsBAAAsAQAALQEAAC4BAAAvAQAAMAEAAAAAQAAyAQAAMwEAADQBAAA1AQAANgEAADcBAAA5AQAAOgEAADsBAAA8AQAAPQEAAD4BAAA/AQAAQAEAAEEBAABCAQAAQwEAAEQBAABFAQAARgEAAEcBAABIAQAASgEAAEsBAABMAQAATQEAAE4BAABPAQAAUAEAAFEBAABSAQAAUwEAAFQBAABVAQAAVgEAAFcBAABYAQAAWQEAAFoBAABbAQAAXAEAAF0BAABeAQAAXwEAAGABAABhAQAAYgEAAGMBAABkAQAAZQEAAGYBAABnAQAAaAEAAGkBAABqAQAAawEAAGwBAABtAQAAbgEAAG8BAABwAQAAcQEAAHIBAABzAQAAdAEAAHUBAAB2AQAAdwEAAHgBAAD/AAAAeQEAAHoBAAB7AQAAfAEAAH0BAAB+AQAAgQEAAFMCAACCAQAAgwEAAIQBAACFAQAAhgEAAFQCAACHAQAAiAEAAIkBAABWAgAAigEAAFcCAACLAQAAjAEAAI4BAADdAQAAjwEAAFkCAACQAQAAWwIAAJEBAACSAQAAkwEAAGACAACUAQAAYwIAAJYBAABpAgAAlwEAAGgCAACYAQAAmQEAAJwBAABvAgAAnQEAAHICAACfAQAAdQIAAKABAAChAQAAogEAAKMBAACkAQAApQEAAKYBAACAAgAApwEAAKgBAACpAQAAgwIAAKwBAACtAQAArgEAAIgCAACvAQAAsAEAALEBAACKAgAAsgEAAIsCAACzAQAAtAEAALUBAAC2AQAAtwEAAJICAAC4AQAAuQEAALwBAAC9AQAAxAEAAMYBAADFAQAAxgEAAMcBAADJAQAAyAEAAMkBAADKAQAAzAEAAMsBAADMAQAAzQEAAM4BAADPAQAA0AEAANEBAADSAQAA0wEAANQBAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN4BAADfAQAA4AEAAOEBAADiAQAA4wEAAOQBAADlAQAA5gEAAOcBAADoAQAA6QEAAOoBAADrAQAA7AEAAO0BAADuAQAA7wEAAPEBAADzAQAA8gEAAPMBAAD0AQAA9QEAAPYBAACVAQAA9wEAAL8BAAD4AQAA+QEAAPoBAAD7AQAA/AEAAP0BAAD+AQAA/wEAAAACAAABAgAAAgIAAAMCAAAEAgAABQIAAAYCAAAHAgAACAIAAAkCAAAKAgAACwIAAAwCAAANAgAADgIAAA8CAAAQAgAAEQIAABICAAATAgAAFAIAABUCAAAWAgAAFwIAABgCAAAZAgAAGgIAABsCAAAcAgAAHQIAAB4CAAAfAgAAIAIAAJ4BAAAiAgAAIwIAACQCAAAlAgAAJgIAACcCAAAoAgAAKQIAACoCAAArAgAALAIAAC0CAAAuAgAALwIAADACAAAxAgAAMgIAADMCAAA6AgAAZSwAADsCAAA8AgAAPQIAAJoBAAA+AgAAZiwAAEECAABCAgAAQwIAAIABAABEAgAAiQIAAEUCAACMAgAARgIAAEcCAABIAgAASQIAAEoCAABLAgAATAIAAE0CAABOAgAATwIAAHADAABxAwAAcgMAAHMDAAB2AwAAdwMAAH8DAADzAwAAhgMAAKwDAACIAwAArQMAAIkDAACuAwAAigMAAK8DAACMAwAAzAMAAI4DAADNAwAAjwMAAM4DAACRAwAAsQMAAJIDAACyAwAAkwMAALMDAACUAwAAtAMAAJUDAAC1AwAAlgMAALYDAACXAwAAtwMAAJgDAAC4AwAAmQMAALkDAACaAwAAugMAAJsDAAC7AwAAnAMAALwDAACdAwAAvQMAAJ4DAAC+AwAAnwMAAL8DAACgAwAAwAMAAKEDAADBAwAAowMAAMMDAACkAwAAxAMAAKUDAADFAwAApgMAAMYDAACnAwAAxwMAAKgDAADIAwAAqQMAAMkDAACqAwAAygMAAKsDAADLAwAAzwMAANcDAADYAwAA2QMAANoDAADbAwAA3AMAAN0DAADeAwAA3wMAAOADAADhAwAA4gMAAOMDAADkAwAA5QMAAOYDAADnAwAA6AMAAOkDAADqAwAA6wMAAOwDAADtAwAA7gMAAO8DAAD0AwAAuAMAAPcDAAD4AwAA+QMAAPIDAAD6AwAA+wMAAP0DAAB7AwAA/gMAAHwDAAD/AwAAfQMAAAAEAABQBAAAAQQAAFEEAAACBAAAUgQAAAMEAABTBAAABAQAAFQEAAAFBAAAVQQAAAYEAABWBAAABwQAAFcEAAAIBAAAWAQAAAkEAABZBAAACgQAAFoEAAALBAAAWwQAAAwEAABcBAAADQQAAF0EAAAOBAAAXgQAAA8EAABfBAAAEAQAADAEAAARBAAAMQQAABIEAAAyBAAAEwQAADMEAAAUBAAANAQAABUEAAA1BAAAFgQAADYEAAAXBAAANwQAABgEAAA4BAAAGQQAADkEAAAaBAAAOgQAABsEAAA7BAAAHAQAADwEAAAdBAAAPQQAAB4EAAA+BAAAHwQAAD8EAAAgBAAAQAQAACEEAABBBAAAIgQAAEIEAAAjBAAAQwQAACQEAABEBAAAJQQAAEUEAAAmBAAARgQAACcEAABHBAAAKAQAAEgEAAApBAAASQQAACoEAABKBAAAKwQAAEsEAAAsBAAATAQAAC0EAABNBAAALgQAAE4EAAAvBAAATwQAAGAEAABhBAAAYgQAAGMEAABkBAAAZQQAAGYEAABnBAAAaAQAAGkEAABqBAAAawQAAGwEAABtBAAAbgQAAG8EAABwBAAAcQQAAHIEAABzBAAAdAQAAHUEAAB2BAAAdwQAAHgEAAB5BAAAegQAAHsEAAB8BAAAfQQAAH4EAAB/BAAAgAQAAIEEAACKBAAAiwQAAIwEAACNBAAAjgQAAI8EAACQBAAAkQQAAJIEAACTBAAAlAQAAJUEAACWBAAAlwQAAJgEAACZBAAAmgQAAJsEAACcBAAAnQQAAJ4EAACfBAAAoAQAAKEEAACiBAAAowQAAKQEAAClBAAApgQAAKcEAACoBAAAqQQAAKoEAACrBAAArAQAAK0EAACuBAAArwQAALAEAACxBAAAsgQAALMEAAC0BAAAtQQAALYEAAC3BAAAuAQAALkEAAC6BAAAuwQAALwEAAC9BAAAvgQAAL8EAADABAAAzwQAAMEEAADCBAAAwwQAAMQEAADFBAAAxgQAAMcEAADIBAAAyQQAAMoEAADLBAAAzAQAAM0EAADOBAAA0AQAANEEAADSBAAA0wQAANQEAADVBAAA1gQAANcEAADYBAAA2QQAANoEAADbBAAA3AQAAN0EAADeBAAA3wQAAOAEAADhBAAA4gQAAOMEAADkBAAA5QQAAOYEAADnBAAA6AQAAOkEAADqBAAA6wQAAOwEAADtBAAA7gQAAO8EAADwBAAA8QQAAPIEAADzBAAA9AQAAPUEAAD2BAAA9wQAAPgEAAD5BAAA+gQAAPsEAAD8BAAA/QQAAP4EAAD/BAAAAAUAAAEFAAACBQAAAwUAAAQFAAAFBQAABgUAAAcFAAAIBQAACQUAAAoFAAALBQAADAUAAA0FAAAOBQAADwUAABAFAAARBQAAEgUAABMFAAAUBQAAFQUAABYFAAAXBQAAGAUAABkFAAAaBQAAGwUAABwFAAAdBQAAHgUAAB8FAAAgBQAAIQUAACIFAAAjBQAAJAUAACUFAAAmBQAAJwUAACgFAAApBQAAKgUAACsFAAAsBQAALQUAAC4FAAAvBQAAMQUAAGEFAAAyBQAAYgUAADMFAABjBQAANAUAAGQFAAA1BQAAZQUAADYFAABmBQAANwUAAGcFAAA4BQAAaAUAADkFAABpBQAAOgUAAGoFAAA7BQAAawUAADwFAABsBQAAPQUAAG0FAAA+BQAAbgUAAD8FAABvBQAAQAUAAHAFAABBBQAAcQUAAEIFAAByBQAAQwUAAHMFAABEBQAAdAUAAEUFAAB1BQAARgUAAHYFAABHBQAAdwUAAEgFAAB4BQAASQUAAHkFAABKBQAAegUAAEsFAAB7BQAATAUAAHwFAABNBQAAfQUAAE4FAAB+BQAATwUAAH8FAABQBQAAgAUAAFEFAACBBQAAUgUAAIIFAABTBQAAgwUAAFQFAACEBQAAVQUAAIUFAABWBQAAhgUAAKAQAAAALQAAoRAAAAEtAACiEAAAAi0AAKMQAAADLQAApBAAAAQtAAClEAAABS0AAKYQAAAGLQAApxAAAActAACoEAAACC0AAKkQAAAJLQAAqhAAAAotAACrEAAACy0AAKwQAAAMLQAArRAAAA0tAACuEAAADi0AAK8QAAAPLQAAsBAAABAtAACxEAAAES0AALIQAAASLQAAsxAAABMtAAC0EAAAFC0AALUQAAAVLQAAthAAABYtAAC3EAAAFy0AALgQAAAYLQAAuRAAABktAAC6EAAAGi0AALsQAAAbLQAAvBAAABwtAAC9EAAAHS0AAL4QAAAeLQAAvxAAAB8tAADAEAAAIC0AAMEQAAAhLQAAwhAAACItAADDEAAAIy0AAMQQAAAkLQAAxRAAACUtAADHEAAAJy0AAM0QAAAtLQAAoBMAAHCrAAChEwAAcasAAKITAAByqwAAoxMAAHOrAACkEwAAdKsAAKUTAAB1qwAAphMAAHarAACnEwAAd6sAAKgTAAB4qwAAqRMAAHmrAACqEwAAeqsAAKsTAAB7qwAArBMAAHyrAACtEwAAfasAAK4TAAB+qwAArxMAAH+rAACwEwAAgKsAALETAACBqwAAshMAAIKrAACzEwAAg6sAALQTAACEqwAAtRMAAIWrAAC2EwAAhqsAALcTAACHqwAAuBMAAIirAAC5EwAAiasAALoTAACKqwAAuxMAAIurAAC8EwAAjKsAAL0TAACNqwAAvhMAAI6rAAC/EwAAj6sAAMATAACQqwAAwRMAAJGrAADCEwAAkqsAAMMTAACTqwAAxBMAAJSrAADFEwAAlasAAMYTAACWqwAAxxMAAJerAADIEwAAmKsAAMkTAACZqwAAyhMAAJqrAADLEwAAm6sAAMwTAACcqwAAzRMAAJ2rAADOEwAAnqsAAM8TAACfqwAA0BMAAKCrAADREwAAoasAANITAACiqwAA0xMAAKOrAADUEwAApKsAANUTAAClqwAA1hMAAKarAADXEwAAp6sAANgTAACoqwAA2RMAAKmrAADaEwAAqqsAANsTAACrqwAA3BMAAKyrAADdEwAArasAAN4TAACuqwAA3xMAAK+rAADgEwAAsKsAAOETAACxqwAA4hMAALKrAADjEwAAs6sAAOQTAAC0qwAA5RMAALWrAADmEwAAtqsAAOcTAAC3qwAA6BMAALirAADpEwAAuasAAOoTAAC6qwAA6xMAALurAADsEwAAvKsAAO0TAAC9qwAA7hMAAL6rAADvEwAAv6sAAPATAAD4EwAA8RMAAPkTAADyEwAA+hMAAPMTAAD7EwAA9BMAAPwTAAD1EwAA/RMAAIkcAACKHAAAkBwAANAQAACRHAAA0RAAAJIcAADSEAAAkxwAANMQAACUHAAA1BAAAJUcAADVEAAAlhwAANYQAACXHAAA1xAAAJgcAADYEAAAmRwAANkQAACaHAAA2hAAAJscAADbEAAAnBwAANwQAACdHAAA3RAAAJ4cAADeEAAAnxwAAN8QAACgHAAA4BAAAKEcAADhEAAAohwAAOIQAACjHAAA4xAAAKQcAADkEAAApRwAAOUQAACmHAAA5hAAAKccAADnEAAAqBwAAOgQAACpHAAA6RAAAKocAADqEAAAqxwAAOsQAACsHAAA7BAAAK0cAADtEAAArhwAAO4QAACvHAAA7xAAALAcAADwEAAAsRwAAPEQAACyHAAA8hAAALMcAADzEAAAtBwAAPQQAAC1HAAA9RAAALYcAAD2EAAAtxwAAPcQAAC4HAAA+BAAALkcAAD5EAAAuhwAAPoQAAC9HAAA/RAAAL4cAAD+EAAAvxwAAP8QAAAAHgAAAR4AAAIeAAADHgAABB4AAAUeAAAGHgAABx4AAAgeAAAJHgAACh4AAAseAAAMHgAADR4AAA4eAAAPHgAAEB4AABEeAAASHgAAEx4AABQeAAAVHgAAFh4AABceAAAYHgAAGR4AABoeAAAbHgAAHB4AAB0eAAAeHgAAHx4AACAeAAAhHgAAIh4AACMeAAAkHgAAJR4AACYeAAAnHgAAKB4AACkeAAAqHgAAKx4AACweAAAtHgAALh4AAC8eAAAwHgAAMR4AADIeAAAzHgAANB4AADUeAAA2HgAANx4AADgeAAA5HgAAOh4AADseAAA8HgAAPR4AAD4eAAA/HgAAQB4AAEEeAABCHgAAQx4AAEQeAABFHgAARh4AAEceAABIHgAASR4AAEoeAABLHgAATB4AAE0eAABOHgAATx4AAFAeAABRHgAAUh4AAFMeAABUHgAAVR4AAFYeAABXHgAAWB4AAFkeAABaHgAAWx4AAFweAABdHgAAXh4AAF8eAABgHgAAYR4AAGIeAABjHgAAZB4AAGUeAABmHgAAZx4AAGgeAABpHgAAah4AAGseAABsHgAAbR4AAG4eAABvHgAAcB4AAHEeAAByHgAAcx4AAHQeAAB1HgAAdh4AAHceAAB4HgAAeR4AAHoeAAB7HgAAfB4AAH0eAAB+HgAAfx4AAIAeAACBHgAAgh4AAIMeAACEHgAAhR4AAIYeAACHHgAAiB4AAIkeAACKHgAAix4AAIweAACNHgAAjh4AAI8eAACQHgAAkR4AAJIeAACTHgAAlB4AAJUeAACeHgAA3wAAAKAeAAChHgAAoh4AAKMeAACkHgAApR4AAKYeAACnHgAAqB4AAKkeAACqHgAAqx4AAKweAACtHgAArh4AAK8eAACwHgAAsR4AALIeAACzHgAAtB4AALUeAAC2HgAAtx4AALgeAAC5HgAAuh4AALseAAC8HgAAvR4AAL4eAAC/HgAAwB4AAMEeAADCHgAAwx4AAMQeAADFHgAAxh4AAMceAADIHgAAyR4AAMoeAADLHgAAzB4AAM0eAADOHgAAzx4AANAeAADRHgAA0h4AANMeAADUHgAA1R4AANYeAADXHgAA2B4AANkeAADaHgAA2x4AANweAADdHgAA3h4AAN8eAADgHgAA4R4AAOIeAADjHgAA5B4AAOUeAADmHgAA5x4AAOgeAADpHgAA6h4AAOseAADsHgAA7R4AAO4eAADvHgAA8B4AAPEeAADyHgAA8x4AAPQeAAD1HgAA9h4AAPceAAD4HgAA+R4AAPoeAAD7HgAA/B4AAP0eAAD+HgAA/x4AAAgfAAAAHwAACR8AAAEfAAAKHwAAAh8AAAsfAAADHwAADB8AAAQfAAANHwAABR8AAA4fAAAGHwAADx8AAAcfAAAYHwAAEB8AABkfAAARHwAAGh8AABIfAAAbHwAAEx8AABwfAAAUHwAAHR8AABUfAAAoHwAAIB8AACkfAAAhHwAAKh8AACIfAAArHwAAIx8AACwfAAAkHwAALR8AACUfAAAuHwAAJh8AAC8fAAAnHwAAOB8AADAfAAA5HwAAMR8AADofAAAyHwAAOx8AADMfAAA8HwAANB8AAD0fAAA1HwAAPh8AADYfAAA/HwAANx8AAEgfAABAHwAASR8AAEEfAABKHwAAQh8AAEsfAABDHwAATB8AAEQfAABNHwAARR8AAFkfAABRHwAAWx8AAFMfAABdHwAAVR8AAF8fAABXHwAAaB8AAGAfAABpHwAAYR8AAGofAABiHwAAax8AAGMfAABsHwAAZB8AAG0fAABlHwAAbh8AAGYfAABvHwAAZx8AAIgfAACAHwAAiR8AAIEfAACKHwAAgh8AAIsfAACDHwAAjB8AAIQfAACNHwAAhR8AAI4fAACGHwAAjx8AAIcfAACYHwAAkB8AAJkfAACRHwAAmh8AAJIfAACbHwAAkx8AAJwfAACUHwAAnR8AAJUfAACeHwAAlh8AAJ8fAACXHwAAqB8AAKAfAACpHwAAoR8AAKofAACiHwAAqx8AAKMfAACsHwAApB8AAK0fAAClHwAArh8AAKYfAACvHwAApx8AALgfAACwHwAAuR8AALEfAAC6HwAAcB8AALsfAABxHwAAvB8AALMfAADIHwAAch8AAMkfAABzHwAAyh8AAHQfAADLHwAAdR8AAMwfAADDHwAA2B8AANAfAADZHwAA0R8AANofAAB2HwAA2x8AAHcfAADoHwAA4B8AAOkfAADhHwAA6h8AAHofAADrHwAAex8AAOwfAADlHwAA+B8AAHgfAAD5HwAAeR8AAPofAAB8HwAA+x8AAH0fAAD8HwAA8x8AACYhAADJAwAAKiEAAGsAAAArIQAA5QAAADIhAABOIQAAYCEAAHAhAABhIQAAcSEAAGIhAAByIQAAYyEAAHMhAABkIQAAdCEAAGUhAAB1IQAAZiEAAHYhAABnIQAAdyEAAGghAAB4IQAAaSEAAHkhAABqIQAAeiEAAGshAAB7IQAAbCEAAHwhAABtIQAAfSEAAG4hAAB+IQAAbyEAAH8hAACDIQAAhCEAALYkAADQJAAAtyQAANEkAAC4JAAA0iQAALkkAADTJAAAuiQAANQkAAC7JAAA1SQAALwkAADWJAAAvSQAANckAAC+JAAA2CQAAL8kAADZJAAAwCQAANokAADBJAAA2yQAAMIkAADcJAAAwyQAAN0kAADEJAAA3iQAAMUkAADfJAAAxiQAAOAkAADHJAAA4SQAAMgkAADiJAAAySQAAOMkAADKJAAA5CQAAMskAADlJAAAzCQAAOYkAADNJAAA5yQAAM4kAADoJAAAzyQAAOkkAAAALAAAMCwAAAEsAAAxLAAAAiwAADIsAAADLAAAMywAAAQsAAA0LAAABSwAADUsAAAGLAAANiwAAAcsAAA3LAAACCwAADgsAAAJLAAAOSwAAAosAAA6LAAACywAADssAAAMLAAAPCwAAA0sAAA9LAAADiwAAD4sAAAPLAAAPywAABAsAABALAAAESwAAEEsAAASLAAAQiwAABMsAABDLAAAFCwAAEQsAAAVLAAARSwAABYsAABGLAAAFywAAEcsAAAYLAAASCwAABksAABJLAAAGiwAAEosAAAbLAAASywAABwsAABMLAAAHSwAAE0sAAAeLAAATiwAAB8sAABPLAAAICwAAFAsAAAhLAAAUSwAACIsAABSLAAAIywAAFMsAAAkLAAAVCwAACUsAABVLAAAJiwAAFYsAAAnLAAAVywAACgsAABYLAAAKSwAAFksAAAqLAAAWiwAACssAABbLAAALCwAAFwsAAAtLAAAXSwAAC4sAABeLAAALywAAF8sAABgLAAAYSwAAGIsAABrAgAAYywAAH0dAABkLAAAfQIAAGcsAABoLAAAaSwAAGosAABrLAAAbCwAAG0sAABRAgAAbiwAAHECAABvLAAAUAIAAHAsAABSAgAAciwAAHMsAAB1LAAAdiwAAH4sAAA/AgAAfywAAEACAACALAAAgSwAAIIsAACDLAAAhCwAAIUsAACGLAAAhywAAIgsAACJLAAAiiwAAIssAACMLAAAjSwAAI4sAACPLAAAkCwAAJEsAACSLAAAkywAAJQsAACVLAAAliwAAJcsAACYLAAAmSwAAJosAACbLAAAnCwAAJ0sAACeLAAAnywAAKAsAAChLAAAoiwAAKMsAACkLAAApSwAAKYsAACnLAAAqCwAAKksAACqLAAAqywAAKwsAACtLAAAriwAAK8sAACwLAAAsSwAALIsAACzLAAAtCwAALUsAAC2LAAAtywAALgsAAC5LAAAuiwAALssAAC8LAAAvSwAAL4sAAC/LAAAwCwAAMEsAADCLAAAwywAAMQsAADFLAAAxiwAAMcsAADILAAAySwAAMosAADLLAAAzCwAAM0sAADOLAAAzywAANAsAADRLAAA0iwAANMsAADULAAA1SwAANYsAADXLAAA2CwAANksAADaLAAA2ywAANwsAADdLAAA3iwAAN8sAADgLAAA4SwAAOIsAADjLAAA6ywAAOwsAADtLAAA7iwAAPIsAADzLAAAQKYAAEGmAABCpgAAQ6YAAESmAABFpgAARqYAAEemAABIpgAASaYAAEqmAABLpgAATKYAAE2mAABOpgAAT6YAAFCmAABRpgAAUqYAAFOmAABUpgAAVaYAAFamAABXpgAAWKYAAFmmAABapgAAW6YAAFymAABdpgAAXqYAAF+mAABgpgAAYaYAAGKmAABjpgAAZKYAAGWmAABmpgAAZ6YAAGimAABppgAAaqYAAGumAABspgAAbaYAAICmAACBpgAAgqYAAIOmAACEpgAAhaYAAIamAACHpgAAiKYAAImmAACKpgAAi6YAAIymAACNpgAAjqYAAI+mAACQpgAAkaYAAJKmAACTpgAAlKYAAJWmAACWpgAAl6YAAJimAACZpgAAmqYAAJumAAAipwAAI6cAACSnAAAlpwAAJqcAACenAAAopwAAKacAACqnAAArpwAALKcAAC2nAAAupwAAL6cAADKnAAAzpwAANKcAADWnAAA2pwAAN6cAADinAAA5pwAAOqcAADunAAA8pwAAPacAAD6nAAA/pwAAQKcAAEGnAABCpwAAQ6cAAESnAABFpwAARqcAAEenAABIpwAASacAAEqnAABLpwAATKcAAE2nAABOpwAAT6cAAFCnAABRpwAAUqcAAFOnAABUpwAAVacAAFanAABXpwAAWKcAAFmnAABapwAAW6cAAFynAABdpwAAXqcAAF+nAABgpwAAYacAAGKnAABjpwAAZKcAAGWnAABmpwAAZ6cAAGinAABppwAAaqcAAGunAABspwAAbacAAG6nAABvpwAAeacAAHqnAAB7pwAAfKcAAH2nAAB5HQAAfqcAAH+nAACApwAAgacAAIKnAACDpwAAhKcAAIWnAACGpwAAh6cAAIunAACMpwAAjacAAGUCAACQpwAAkacAAJKnAACTpwAAlqcAAJenAACYpwAAmacAAJqnAACbpwAAnKcAAJ2nAACepwAAn6cAAKCnAAChpwAAoqcAAKOnAACkpwAApacAAKanAACnpwAAqKcAAKmnAACqpwAAZgIAAKunAABcAgAArKcAAGECAACtpwAAbAIAAK6nAABqAgAAsKcAAJ4CAACxpwAAhwIAALKnAACdAgAAs6cAAFOrAAC0pwAAtacAALanAAC3pwAAuKcAALmnAAC6pwAAu6cAALynAAC9pwAAvqcAAL+nAADApwAAwacAAMKnAADDpwAAxKcAAJSnAADFpwAAggIAAManAACOHQAAx6cAAMinAADJpwAAyqcAAMunAABkAgAAzKcAAM2nAADQpwAA0acAANanAADXpwAA2KcAANmnAADapwAA26cAANynAACbAQAA9acAAPanAAAh/wAAQf8AACL/AABC/wAAI/8AAEP/AAAk/wAARP8AACX/AABF/wAAJv8AAEb/AAAn/wAAR/8AACj/AABI/wAAKf8AAEn/AAAq/wAASv8AACv/AABL/wAALP8AAEz/AAAt/wAATf8AAC7/AABO/wAAL/8AAE//AAAw/wAAUP8AADH/AABR/wAAMv8AAFL/AAAz/wAAU/8AADT/AABU/wAANf8AAFX/AAA2/wAAVv8AADf/AABX/wAAOP8AAFj/AAA5/wAAWf8AADr/AABa/wAAAAQBACgEAQABBAEAKQQBAAIEAQAqBAEAAwQBACsEAQAEBAEALAQBAAUEAQAtBAEABgQBAC4EAQAHBAEALwQBAAgEAQAwBAEACQQBADEEAQAKBAEAMgQBAAsEAQAzBAEADAQBADQEAQANBAEANQQBAA4EAQA2BAEADwQBADcEAQAQBAEAOAQBABEEAQA5BAEAEgQBADoEAQATBAEAOwQBABQEAQA8BAEAFQQBAD0EAQAWBAEAPgQBABcEAQA/BAEAGAQBAEAEAQAZBAEAQQQBABoEAQBCBAEAGwQBAEMEAQAcBAEARAQBAB0EAQBFBAEAHgQBAEYEAQAfBAEARwQBACAEAQBIBAEAIQQBAEkEAQAiBAEASgQBACMEAQBLBAEAJAQBAEwEAQAlBAEATQQBACYEAQBOBAEAJwQBAE8EAQCwBAEA2AQBALEEAQDZBAEAsgQBANoEAQCzBAEA2wQBALQEAQDcBAEAtQQBAN0EAQC2BAEA3gQBALcEAQDfBAEAuAQBAOAEAQC5BAEA4QQBALoEAQDiBAEAuwQBAOMEAQC8BAEA5AQBAL0EAQDlBAEAvgQBAOYEAQC/BAEA5wQBAMAEAQDoBAEAwQQBAOkEAQDCBAEA6gQBAMMEAQDrBAEAxAQBAOwEAQDFBAEA7QQBAMYEAQDuBAEAxwQBAO8EAQDIBAEA8AQBAMkEAQDxBAEAygQBAPIEAQDLBAEA8wQBAMwEAQD0BAEAzQQBAPUEAQDOBAEA9gQBAM8EAQD3BAEA0AQBAPgEAQDRBAEA+QQBANIEAQD6BAEA0wQBAPsEAQBwBQEAlwUBAHEFAQCYBQEAcgUBAJkFAQBzBQEAmgUBAHQFAQCbBQEAdQUBAJwFAQB2BQEAnQUBAHcFAQCeBQEAeAUBAJ8FAQB5BQEAoAUBAHoFAQChBQEAfAUBAKMFAQB9BQEApAUBAH4FAQClBQEAfwUBAKYFAQCABQEApwUBAIEFAQCoBQEAggUBAKkFAQCDBQEAqgUBAIQFAQCrBQEAhQUBAKwFAQCGBQEArQUBAIcFAQCuBQEAiAUBAK8FAQCJBQEAsAUBAIoFAQCxBQEAjAUBALMFAQCNBQEAtAUBAI4FAQC1BQEAjwUBALYFAQCQBQEAtwUBAJEFAQC4BQEAkgUBALkFAQCUBQEAuwUBAJUFAQC8BQEAgAwBAMAMAQCBDAEAwQwBAIIMAQDCDAEAgwwBAMMMAQCEDAEAxAwBAIUMAQDFDAEAhgwBAMYMAQCHDAEAxwwBAIgMAQDIDAEAiQwBAMkMAQCKDAEAygwBAIsMAQDLDAEAjAwBAMwMAQCNDAEAzQwBAI4MAQDODAEAjwwBAM8MAQCQDAEA0AwBAJEMAQDRDAEAkgwBANIMAQCTDAEA0wwBAJQMAQDUDAEAlQwBANUMAQCWDAEA1gwBAJcMAQDXDAEAmAwBANgMAQCZDAEA2QwBAJoMAQDaDAEAmwwBANsMAQCcDAEA3AwBAJ0MAQDdDAEAngwBAN4MAQCfDAEA3wwBAKAMAQDgDAEAoQwBAOEMAQCiDAEA4gwBAKMMAQDjDAEApAwBAOQMAQClDAEA5QwBAKYMAQDmDAEApwwBAOcMAQCoDAEA6AwBAKkMAQDpDAEAqgwBAOoMAQCrDAEA6wwBAKwMAQDsDAEArQwBAO0MAQCuDAEA7gwBAK8MAQDvDAEAsAwBAPAMAQCxDAEA8QwBALIMAQDyDAEAUA0BAHANAQBRDQEAcQ0BAFINAQByDQEAUw0BAHMNAQBUDQEAdA0BAFUNAQB1DQEAVg0BAHYNAQBXDQEAdw0BAFgNAQB4DQEAWQ0BAHkNAQBaDQEAeg0BAFsNAQB7DQEAXA0BAHwNAQBdDQEAfQ0BAF4NAQB+DQEAXw0BAH8NAQBgDQEAgA0BAGENAQCBDQEAYg0BAIINAQBjDQEAgw0BAGQNAQCEDQEAZQ0BAIUNAQCgGAEAwBgBAKEYAQDBGAEAohgBAMIYAQCjGAEAwxgBAKQYAQDEGAEApRgBAMUYAQCmGAEAxhgBAKcYAQDHGAEAqBgBAMgYAQCpGAEAyRgBAKoYAQDKGAEAqxgBAMsYAQCsGAEAzBgBAK0YAQDNGAEArhgBAM4YAQCvGAEAzxgBALAYAQDQGAEAsRgBANEYAQCyGAEA0hgBALMYAQDTGAEAtBgBANQYAQC1GAEA1RgBALYYAQDWGAEAtxgBANcYAQC4GAEA2BgBALkYAQDZGAEAuhgBANoYAQC7GAEA2xgBALwYAQDcGAEAvRgBAN0YAQC+GAEA3hgBAL8YAQDfGAEAQG4BAGBuAQBBbgEAYW4BAEJuAQBibgEAQ24BAGNuAQBEbgEAZG4BAEVuAQBlbgEARm4BAGZuAQBHbgEAZ24BAEhuAQBobgEASW4BAGluAQBKbgEAam4BAEtuAQBrbgEATG4BAGxuAQBNbgEAbW4BAE5uAQBubgEAT24BAG9uAQBQbgEAcG4BAFFuAQBxbgEAUm4BAHJuAQBTbgEAc24BAFRuAQB0bgEAVW4BAHVuAQBWbgEAdm4BAFduAQB3bgEAWG4BAHhuAQBZbgEAeW4BAFpuAQB6bgEAW24BAHtuAQBcbgEAfG4BAF1uAQB9bgEAXm4BAH5uAQBfbgEAf24BAADpAQAi6QEAAekBACPpAQAC6QEAJOkBAAPpAQAl6QEABOkBACbpAQAF6QEAJ+kBAAbpAQAo6QEAB+kBACnpAQAI6QEAKukBAAnpAQAr6QEACukBACzpAQAL6QEALekBAAzpAQAu6QEADekBAC/pAQAO6QEAMOkBAA/pAQAx6QEAEOkBADLpAQAR6QEAM+kBABLpAQA06QEAE+kBADXpAQAU6QEANukBABXpAQA36QEAFukBADjpAQAX6QEAOekBABjpAQA66QEAGekBADvpAQAa6QEAPOkBABvpAQA96QEAHOkBAD7pAQAd6QEAP+kBAB7pAQBA6QEAH+kBAEHpAQAg6QEAQukBACHpAQBD6QEATSUQACgAAAAAAwAAHQAAALACAABdE2ABEhfgIL0fICF8LOAuBTAgMxWgoDT4pCA2DKZgNh77oDYA/qBC/QEhQ4AH4UYBCqFHJA1hSKsO4UkvGOFKOxlhWjAc4VrzHmFeMDQhYh5hoWPwaiFkQG2hZE9vYWXwr+FlnbzhZgDPoWdn0SFoANqhaADg4Wmu4mFr6+RhbdDo4W3782FuAQDubvABP28AAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvgLQD+IDae/2A2/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFVAM9hVmXRoVYA2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9doBAAAKATYAaAHKAHFh8gCLYkQAkALKASQKbgEjCrYBQA++AWIf+gFwAEIRiAB6EYgAxhG6AYYRxAbmEdANShHabW4R0A34EiMOBhJQDpISYw8WEmivGyJgAGAQEDAQQCBQcHAggICQIKBQsCDgQQARECEgUTHBQBFQIXAhkNHAUdCB8BJAFqBGsCrwOxArwCzwLRAtQM1QnWAtcC2gHgBeEC5wToAu4g8AT4AvoE+wEMJzs+Tk+Pnp6fe4uTlqKyuoaxBgcJNj0+VvPQ0QQUGDY3Vld/qq6vvTXgEoeJjp4EDQ4REikxNDpFRklKTk9kZYqMjY+2wcPExsvWXLa3GxwHCAoLFBc2OTqoqdjZCTeQkagHCjs+ZmmPkhFvX7/u71pi9Pz/U1Samy4vJyhVnaCho6SnqK26vMQGCwwVHTo/RVGmp8zNoAcZGiIlPj/n7O//xcYEICMlJigzODpISkxQU1VWWFpcXmBjZWZrc3h9f4qkqq+wwNCur25v3d6TXiJ7BQMELQNmAwEvLoCCHQMxDxwEJAkeBSsFRAQOKoCqBiQEJAQoCDQLTgM0DIE3CRYKCBg7RTkDYwgJMBYFIQMbBQFAOARLBS8ECgcJB0AgJwQMCTYDOgUaBwQMB1BJNzMNMwcuCAoGJgMdCAKA0FIQAzcsCCoWGiYcFBcJTgQkCUQNGQcKBkgIJwl1C0I+KgY7BQoGUQYBBRADBQtZCAIdYh5ICAqApl4iRQsKBg0TOgYKBhQcLAQXgLk8ZFMMSAkKRkUbSAhTDUkHCoC2Ig4KBkYKHQNHSTcDDggKBjkHCoE2GQc7Ax1VAQ8yDYObZnULgMSKTGMNhDAQFgqPmwWCR5q5OobGgjkHKgRcBiYKRgooBROBsDqAxltlSwQ5BxFABQsCDpf4CITWKQqi54EzDwEdBg4ECIGMiQRrBQ0DCQcQj2CA+gaBtExHCXQ8gPYKcwhwFUZ6FAwUDFcJGYCHgUcDhUIPFYRQHwYGgNUrBT4hAXAtAxoEAoFAHxE6BQGB0CqA1isEAYHggPcpTAQKBAKDEURMPYDCPAYBBFUFGzQCgQ4sBGQMVgqArjgdDSwECQcCDgaAmoPYBBEDDQN3BF8GDAQBDwwEOAgKBigILAQCPoFUDB0DCgU4BxwGCQeA+oQGAAEDBQUGBgIHBggHCREKHAsZDBoNEA4MDwQQAxISEwkWARcEGAEZAxoHGwEcAh8WIAMrAy0LLgEwBDECMgGnBKkCqgSrCPoC+wX9Av4D/wmteHmLjaIwV1iLjJAc3Q4PS0z7/C4vP1xdX+KEjY6RkqmxurvFxsnK3uTl/wAEERIpMTQ3Ojs9SUpdhI6SqbG0urvGys7P5OUABA0OERIpMTQ6O0VGSUpeZGWEkZudyc7PDREpOjtFSVdbXF5fZGWNkam0urvFyd/k5fANEUVJZGWAhLK8vr/V1/Dxg4WLpKa+v8XHz9rbSJi9zcbOz0lOT1dZXl+Jjo+xtre/wcbH1xEWF1tc9vf+/4Btcd7fDh9ubxwdX31+rq9Nu7wWFx4fRkdOT1haXF5+f7XF1NXc8PH1cnOPdHWWJi4vp6+3v8fP19+aAECXmDCPH87P0tTO/05PWlsHCA8QJy/u725vNz0/QkWQkVNndcjJ0NHY2ef+/wAgXyKC3wSCRAgbBAYRgawOgKsFHwiBHAMZCAEELwQ0BAcDAQcGBxEKUA8SB1UHAwQcCgkDCAMHAwIDAwMMBAUDCwYBDhUFTgcbB1cHAgYXDFAEQwMtAwEEEQYPDDoEHSVfIG0EaiWAyAWCsAMaBoL9A1kHFgkYCRQMFAxqBgoGGgZZBysFRgosBAwEAQMxCywEGgYLA4CsBgoGLzGA9Ag8Aw8DPgU4CCsFgv8RGAgvES0DIQ8hD4CMBIKaFgsViJQFLwU7BwIOGAmAviJ0DIDWGoEQBYDhCfKeAzcJgVwUgLgIgN0VOwMKBjgIRggMBnQLHgNaBFkJgIMYHAoWCUwEgIoGq6QMFwQxoQSB2iYHDAUFgKYQgfUHASAqBkwEgI0EgL4DGwMPDQAAAFQZEAAlAAAAGgAAADYAAABUGRAAJQAAAAoAAAArAAAAYXR0ZW1wdCB0byBkaXZpZGUgYnkgemVybwAAAHjDEAAZAAAAYXR0ZW1wdCB0byBjYWxjdWxhdGUgdGhlIHJlbWFpbmRlciB3aXRoIGEgZGl2aXNvciBvZiB6ZXJvAAAAnMMQADkAAAAAAAAABAAAAAQAAACTAQAAAAAAAAQAAAAEAAAAlAEAAGluZGV4IG91dCBvZiBib3VuZHM6IHRoZSBsZW4gaXMgIGJ1dCB0aGUgaW5kZXggaXMgAAAAxBAAIAAAACDEEAASAAAAPT0hPWFzc2VydGlvbiBgbGVmdCAgcmlnaHRgIGZhaWxlZAogIGxlZnQ6IAogcmlnaHQ6IEjEEAAQAAAAWMQQABcAAABvxBAACQAAACByaWdodGAgZmFpbGVkOiAKICBsZWZ0OiAAAABIxBAAEAAAAJDEEAAQAAAAoMQQAAkAAABvxBAACQAAALkAEAAdAAAAhgAAACMAAABceAAA3MQQAAIAAAACAEHyicMACwECAEH8icMAC7mMASAAAOm5ABAAHQAAAH8AAAArAAAAUmVmQ2VsbCBhbHJlYWR5IG11dGFibHkgYm9ycm93ZWQuLlJlZkNlbGwgYWxyZWFkeSBib3Jyb3dlZGludmFsaWQgdXRmLTggc2VxdWVuY2Ugb2YgIGJ5dGVzIGZyb20gaW5kZXggAABKxRAAGgAAAGTFEAASAAAAaW5jb21wbGV0ZSB1dGYtOCBieXRlIHNlcXVlbmNlIGZyb20gaW5kZXggAACIxRAAKgAAACAgICAgKDEgPDwgAAEAAAAAAAAAwMUQAAcAAABeBxIAAQAAAGNhbm5vdCBwYXJzZSBpbnRlZ2VyIGZyb20gZW1wdHkgc3RyaW5naW52YWxpZCBkaWdpdCBmb3VuZCBpbiBzdHJpbmdudW1iZXIgdG9vIGxhcmdlIHRvIGZpdCBpbiB0YXJnZXQgdHlwZW51bWJlciB0b28gc21hbGwgdG8gZml0IGluIHRhcmdldCB0eXBlbnVtYmVyIHdvdWxkIGJlIHplcm8gZm9yIG5vbi16ZXJvIHR5cGUAAAAAAAAAljAHdyxhDu66UQmZGcRtB4/0anA1pWPpo5VknjKI2w6kuNx5HunV4IjZ0pcrTLYJvXyxfgctuOeRHb+QZBC3HfIgsGpIcbnz3kG+hH3U2hrr5N1tUbXU9MeF04NWmGwTwKhrZHr5Yv3syWWKT1wBFNlsBmNjPQ/69Q0IjcggbjteEGlM5EFg1XJxZ6LR5AM8R9QES/2FDdJrtQql+qi1NWyYskLWybvbQPm8rONs2DJ1XN9Fzw3W3Fk90ausMNkmOgDeUYBR18gWYdC/tfS0ISPEs1aZlbrPD6W9uJ64AigIiAVfstkMxiTpC7GHfG8vEUxoWKsdYcE9LWa2kEHcdgZx2wG8INKYKhDV74mFsXEftbYGpeS/nzPUuOiiyQd4NPkAD46oCZYYmA7huw1qfy09bQiXbGSRAVxj5vRRa2tiYWwc2DBlhU4AYvLtlQZse6UBG8H0CIJXxA/1xtmwZVDptxLquL6LfIi5/N8d3WJJLdoV83zTjGVM1PtYYbJNzlG1OnQAvKPiMLvUQaXfSteV2D1txNGk+/TW02rpaUP82W40RohnrdC4YNpzLQRE5R0DM19MCqrJfA3dPHEFUKpBAicQEAu+hiAMySW1aFezhW8gCdRmuZ/kYc4O+d5emMnZKSKY0LC0qNfHFz2zWYENtC47XL23rWy6wCCDuO22s7+aDOK2A5rSsXQ5R9Xqr3fSnRUm2wSDFtxzEgtj44Q7ZJQ+am0NqFpqegvPDuSd/wmTJ64ACrGeB31Ekw/w0qMIh2jyAR7+wgZpXVdi98tnZYBxNmwZ5wZrbnYb1P7gK9OJWnraEMxK3Wdv37n5+e++jkO+txfVjrBg6KPW1n6T0aHEwtg4UvLfT/Fnu9FnV7ym3Qa1P0s2skjaKw3YTBsKr/ZKAzZgegRBw+9g31XfZ6jvjm4xeb5pRoyzYcsag2a8oNJvJTbiaFKVdwzMA0cLu7kWAiIvJgVVvju6xSgLvbKSWrQrBGqzXKf/18Ixz9C1i57ZLB2u3luwwmSbJvJj7JyjanUKk20CqQYJnD82DuuFZwdyE1cABYJKv5UUerjiriuxezgbtgybjtKSDb7V5bfv3Hwh39sL1NLThkLi1PH4s91oboPaH80WvoFbJrn24Xewb3dHtxjmWgiIcGoP/8o7BmZcCwER/55lj2muYvjT/2thRc9sFnjiCqDu0g3XVIMETsKzAzlhJmen9xZg0E1HaUnbd24+SmrRrtxa1tlmC99A8DvYN1OuvKnFnrvef8+yR+n/tTAc8r29isK6yjCTs1Omo7QkBTbQupMG180pV95Uv2fZIy56ZrO4SmHEAhtoXZQrbyo3vgu0oY4MwxvfBVqN7wItAAAAAEExGxmCYjYyw1MtKwTFbGRF9Hd9hqdaVseWQU8IitnISbvC0Yro7/rL2fTjDE+1rE1+rrWOLYOezxyYh1ESwkoQI9lT03D0eJJB72FV164uFOa1N9e1mByWhIMFWZgbghipAJvb+i2wmss2qV1dd+YcbGz/3z9B1J4OWs2iJISV4xWfjCBGsqdhd6m+puHo8efQ8+gkg97DZbLF2qquXV3rn0ZEKMxrb2n9cHauazE571oqICwJBwttOBwS8zZG37IHXcZxVHDtMGVr9PfzKru2wjGidZEciTSgB5D7vJ8Xuo2EDnneqSU477I8/3nzc75I6Gp9G8VBPCreWAVPefBEfmLphy1PwsYcVNsBihWUQLsOjYPoI6bC2Ti/DcWgOEz0uyGPp5YKzpaNEwkAzFxIMddFi2L6bspT4XdUXbu6FWygo9Y/jYiXDpaRUJjX3hGpzMfS+uHsk8v69VzXYnId5nlr3rVUQJ+ET1lYEg4WGSMVD9pwOCSbQSM9p2v9ZeZa5nwlCctXZDjQTqOukQHin4oYIcynM2D9vCqv4SSt7tA/tC2DEp9ssgmGqyRIyeoVU9ApRn77aHdl4vZ5Py+3SCQ2dBsJHTUqEgTyvFNLs41IUnDeZXkx735g/vPm57/C/f58kdDVPaDLzPo2ioO7B5GaeFS8sTllp6hLmIM7CqmYIsn6tQmIy64QT13vXw5s9EbNP9ltjA7CdEMSWvMCI0HqwXBswYBBd9hH1zaXBuYtjsW1AKWEhBu8GopBcVu7WmiY6HdD2dlsWh5PLRVffjYMnC0bJ90cAD4SAJi5UzGDoJBirovRU7WSFsX03Vf078SUp8Lv1ZbZ9um8B66ojRy3a94xnCrvKoXteWvKrEhw028bXfguKkbh4TbeZqAHxX9jVOhUImXzTeXzsgKkwqkbZ5GEMCagnym4rsXk+Z/e/TrM89Z7/ejPvGupgP1aspk+CZ+yfziEq7AkHCzxFQc1MkYqHnN3MQe04XBI9dBrUTaDRnp3sl1jTtf6yw/m4dLMtcz5jYTX4EoSlq8LI422yHCgnYlBu4RGXSMDB2w4GsQ/FTGFDg4oQphPZwOpVH7A+nlVgctiTB/FOIFe9COYnacOs9yWFaobAFTlWjFP/JliYtfYU3nOF0/hSVZ++lCVLdd71BzMYhOKjS1Su5Y0kei7H9DZoAbs835ercJlR26RSGwvoFN16DYSOqkHCSNqVCQIK2U/EeR5p5alSLyPZhuRpCcqir3gvMvyoY3Q62Le/cAj7+bZveG8FPzQpw0/g4omfrKRP7kk0HD4FctpO0bmQnp3/Vu1a2Xc9Fp+xTcJU+52OEj3sa4JuPCfEqEzzD+Kcv0kkwAAAAA3asIBbtSEA1m+RgLcqAkH68LLBrJ8jQSFFk8FuFETDo870Q/WhZcN4e9VDGT5GglTk9gICi2eCj1HXAtwoyYcR8nkHR53oh8pHWAerAsvG5th7RrC36sY9bVpGcjyNRL/mPcTpiaxEZFMcxAUWjwVIzD+FHqOuBZN5HoX4EZNONcsjzmOksk7ufgLOjzuRD8LhIY+UjrAPGVQAj1YF142b32cNzbD2jUBqRg0hL9XMbPVlTDqa9My3QERM5DlaySnj6kl/jHvJ8lbLSZMTWIjeyegIiKZ5iAV8yQhKLR4Kh/euitGYPwpcQo+KPQccS3DdrMsmsj1Lq2iNy/AjZpw9+dYca5ZHnOZM9xyHCWTdytPUXZy8Rd0RZvVdXjciX5Ptkt/FggNfSFiz3ykdIB5kx5CeMqgBHr9ysZ7sC68bIdEfm3e+jhv6ZD6bmyGtWtb7HdqAlIxaDU482kIf69iPxVtY2arK2FRwelg1NemZeO9ZGS6AyJmjWngZyDL10gXoRVJTh9TS3l1kUr8Y95PywkcTpK3Wkyl3ZhNmJrERq/wBkf2TkBFwSSCREQyzUFzWA9AKuZJQh2Mi0NQaPFUZwIzVT68dVcJ1rdWjMD4U7uqOlLiFHxQ1X6+Ueg54lrfUyBbhu1mWbGHpFg0ketdA/spXFpFb15tL61fgBs14bdx9+Duz7Hi2aVz41yzPOZr2f7nMme45QUNeuQ4SibvDyDk7laeouxh9GDt5OIv6NOI7emKNqvrvVxp6vC4E/3H0tH8nmyX/qkGVf8sEBr6G3rY+0LEnvl1rlz4SOkA83+DwvImPYTwEVdG8ZRBCfSjK8v1+pWN983/T/ZgXXjZVze62A6J/No54z7bvPVx3oufs9/SIfXd5Us33NgMa9fvZqnWttjv1IGyLdUEpGLQM86g0Wpw5tNdGiTSEP5exSeUnMR+KtrGSUAYx8xWV8L7PJXDooLTwZXoEcCor03Ln8WPysZ7ycjxEQvJdAdEzENths0a08DPLbkCzkCWr5F3/G2QLkIrkhko6ZOcPqaWq1Rkl/LqIpXFgOCU+Me8n8+tfp6WEzicoXn6nSRvtZgTBXeZSrsxm33R85owNYmNB19LjF7hDY5pi8+P7J2Aitv3QouCSQSJtSPGiIhkmoO/DliC5rAegNHa3IFUzJOEY6ZRhToYF4cNctWGoNDiqZe6IKjOBGaq+W6kq3x4665LEimvEqxvrSXGrawYgfGnL+szpnZVdaRBP7elxCn4oPNDOqGq/XyjnZe+otBzxLXnGQa0vqdAtonNgrcM282yO7EPs2IPSbFVZYuwaCLXu19IFboG9lO4MZyRubSK3ryD4By92l5av+00mL4AAAAAZWe8uIvICarur7USV5dijzLw3jfcX2sluTjXne8otMWKTwh9ZOC9bwGHAde4v9ZK3dhq8jN33+BWEGNYn1cZUPowpegUnxD6cfisQsjAe9+tp8dnQwhydSZvzs1wf62VFRgRLfu3pD+e0BiHJ+jPGkKPc6KsIMawyUd6CD6vMqBbyI4YtWc7CtAAh7JpOFAvDF/sl+LwWYWHl+U90YeGZbTgOt1aT4/PPygzd4YQ5Orjd1hSDdjtQGi/Ufih+CvwxJ+XSCowIlpPV57i9m9Jf5MI9cd9p0DVGMD8bU7QnzUrtyONxRiWn6B/KicZR/26fCBBApKP9BD36EioPVgUm1g/qCO2kB0x0/ehiWrPdhQPqMqs4Qd/voRgwwbScKBetxcc5lm4qfQ83xVMhefC0eCAfmkOL8t7a0h3w6IPDcvHaLFzKccEYUyguNn1mG9EkP/T/H5QZu4bN9pWTSe5DihABbbG77Cko4gMHBqw24F/12c5kXjSK/QfbpMD9yY7ZpCag4g/L5HtWJMpVGBEtDEH+AzfqE0eus/xpuzfkv6JuC5GZxebVAJwJ+y7SPBx3i9MyTCA+dtV50VjnKA/a/nHg9MXaDbBcg+Kecs3XeSuUOFcQP9UTiWY6PZziIuuFu83FvhAggSdJz68JB/pIUF4VZmv1+CLyrBcMzu2We1e0eVVsH5QR9UZ7P9sITtiCUaH2ufpMsiCjo5w1J7tKLH5UZBfVuSCOjFYOoMJj6fmbjMfCMGGDW2mOrWk4UC9wYb8BS8pSRdKTvWv83YiMpYRnop4viuYHdmXIEvJ9HgurkjAwAH90qVmQWocXpb3eTkqT5eWn13y8SPlBRlrTWB+1/WO0WLn67beX1KOCcI36bV62UYAaLwhvNDqMd+Ij1ZjMGH51iIEnmqavaa9B9jBAb82brStUwkIFZpOch3/Kc6lEYZ7t3Thxw/N2RCSqL6sKkYRGTgjdqWAdWbG2BABemD+rs9ym8lzyiLxpFdHlhjvqTmt/cxeEUUG7k12Y4nxzo0mRNzoQfhkUXkv+TQek0HasSZTv9aa6+nG+bOMoUULYg7wGQdpTKG+UZs82zYnhDWZkpZQ/i4umblUJvze6J4ScV2MdxbhNM4uNqmrSYoRReY/AyCBg7t2keDjE/ZcW/1Z6UmYPlXxIQaCbERhPtSqzovGz6k3fjhBf9ZdJsNus4l2fNbuysRv1h1ZCrGh4eQeFPOBeahL12nLE7IOd6tcocK5OcZ+AYD+qZzlmRUkCzagNm5RHI6nFmaGwnHaPizebyxJudOU8IEECZXmuLF7SQ2jHi6xG0g+0kMtWW77w/bb6aaRZ1EfqbDMes4MdJRhuWbxBgXeAAAAALApYD1gU8B60HqgR8CmgPVwj+DIoPVAjxDcILLBS3AwcWIQDaEYsEoRMdB3Ae3wxbHEkPhhvjC/0ZdQgoKX4GAyvoBd4sQgGlLtQCdCMWCV8hgAqCJioO+SS8DSQ9yQUPP18G0jj1Aqk6YwF4N6EKUzU3CY4ynQ31MAsOIEL8HBtAah/GR8AbvUVWGGxIlBNHSgIQmk2oFOFPPhc8VksfF1TdHMpTdxixUeEbYFwjEEtetROWWR8X7VuJFDhrghoTaRQZzm6+HbVsKB5kYeoVT2N8FpJk1hLpZkARNH81GR99oxrCegkeuXifHWh1XRZDd8sVnnBhEeVy9xI0lY81j5cZNlKQszIpkiUx+J/nOtOdcTkOmts9dZhNPqiBODaDg641XoQEMSWGkjL0i1A534nGOgKObD55jPo9rLzxM4e+ZzBauc00IbtbN/C2mTzbtA8/BrOlO32xMzigqEYwi6rQM1atejctr+w0/KIuP9eguDwKpxI4caWEO6TXcymf1eUqQtJPLjnQ2S3o3Rsmw9+NJR7YJyFl2rEiuMPEKpPBUilOxvgtNcRuLuTJrCXPyzomEsyQImnOBiG8/g0vl/ybLEr7MSgx+acr4PRlIMv28yMW8VknbfPPJLDquiyb6CwvRu+GKz3tECjs4NIjx+JEIBrl7iRh53gnuSsOaxIpmGjPLjJstCykb2UhZmROI/BnkyRaY+gmzGA1P7loHj0va8M6hW+4OBNsaTXRZ0I3R2SfMO1g5DJ7YzECcG0aAOZuxwdMarwF2mltCBhiRgqOYZsNJGXgD7JmPRbHbhYUUW3LE/tpsBFtamEcr2FKHjlilxmTZuwbBWU5afJ3AmtkdN9sznCkblhzdWOaeF5hDHuDZqZ/+GQwfCV9RXQOf9N303h5c6h673B5dy17UnW7eI9yEXz0cId/IUCMcQpCGnLXRbB2rEcmdX1K5H5WSHJ9i0/YefBNTnotVDtyBlatcdtRB3WgU5F2cV5TfVpcxX6HW296/Fn5eS2+gV6WvBddS7u9WTC5K1rhtOlRyrZ/Uhex1VZss0NVsao2XZqooF5HrwpaPK2cWe2gXlLGoshRG6ViVWCn9Fa1l/9YnpVpW0OSw184kFVc6Z2XV8KfAVQfmKtQZJo9U7mDSFuSgd5YT4Z0XDSE4l/liSBUzou2VxOMHFNojopQvfx9Qob+60Fb+UFFIPvXRvH2FU3a9INOB/MpSnzxv0mh6MpBiupcQlft9kYs72BF/eKiTtbgNE0L555JcOUISqXVA0SO15VHU9A/QyjSqUD532tL0t39SA/aV0x02MFPqcG0R4LDIkRfxIhAJMYeQ/XL3EjeyUpLA87gT3jMdkygAAAACl01zLC6HITa5ylIYWQpGbs5HNUB3jWda4MAUdbYJT7MhRDydmI5uhw/DHanvAwnfeE568cGEKOtWyVvGbAtYDPtGKyJCjHk41cEKFjUBHmCiTG1OG4Y/VIzLTHvaAhe9TU9kk/SFNoljyEWngwhR0RRFIv+tj3DlOsIDyNgWsB5PW8Mw9pGRKmHc4gSBHPZyFlGFXK+b10Y41qRpbh//r/lSjIFAmN6b19WttTcVucOgWMrtGZKY947f69q0HegQI1CbPpqaySQN17oK7ReufHpa3VLDkI9IVN38ZwIUp6GVWdSPLJOGlbve9btbHuHNzFOS43WZwPni1LPVsClgPydkExGerkELCeMyJekjJlN+blV9x6QHZ1DpdEgGIC+OkW1coCinDrq/6n2UXypp4shnGsxxrUjW5uA7+9wiODFLb0sf8qUZBWXoaiuFKH5dEmUNc6uvX2k84ixGait3gP1mBK5ErFa00+ElmjMhMeykbELCHaYQ2IrrY/VoP9Aj/3KjDUa48RfR9YI5MTWWT6Z45WEfsrd7iP/EVN42n5JJe+y88LG+pmf8zYiHPNn+EHGq0Km7+Mo+9ovnBDSILZN5+wMqs6kZvf7aN10+zkHKc71vc7nvdeT0nFqyPcecJXC0spy65qgL95WG6zeB8Hx68t7FsKDEUv3T62BSwHn3H7NXTtXhTdmYkmM5WIYVrhX1OxffpyGAktQO1luPyEEW/Ob43K78b5Hd0o9RyaQYHLqKodbokDabm70MWZh3mxTrWSLeuUO1k8ptVVPeG8IerTV71P8v7JmMALpQ18YtHaTolNf28gOahdzjWpGqdBfihM3dsJ5akMOzuERwZS8JA0uWw1FRAY4if+FONgl2A0Unz8kXPViEZBIOTT/UmQBM+iDKHuC3h23OV0d5uMAKCpZ5wFiM7o0rodRPKGtDAltF+sgJX22FenGNRW4HGggdKaPCTzM0jzwcYkZn2vULFPRMwUbu24w1wDtMIbasAVKYFcsAgoKGc67Qe6BERzbTav78gXBpsfJeiXHmKB48lQan9sccMLu0M2Zy7/XxP5zbSPXOwd+4ve8/eKmZqDXatxH/iK2GsvuAvHD4Sis9i2SS99l+BbqqUOV6viZyN80Iy/2fElyw7D0Kebf7nTTE1ST+ls+zs+XhU3Pxl8Q+grl99NCj6rmjjghtEFifIGN2JuoxbLGnQkJRZ1Y0xiolGn/gdwDorQQvvmRf6SkpLMeQ437dB64N8+duGYVwI2qryek4sV6kS5xkZkhW8ys7eErhaWLdrBpMPWwOOqohfRQT6y8OhKZcIdJvB+dFInTJ/Ogm02ulVf2LZUGLHCgypaXiYL8yrxOQAAAAAtAt3pikRn5edGugxEyRP9KcvOFI6NdBjjj6nxWdO7zPTRZiVTl9wpPpUBwJ0aqDHwGHXYV17P1DpcEj2zpzeZ3qXqcHnjUHwU4Y2Vt24kZNps+Y19KkOBECieaKp0jFUHdlG8oDDrsM0yNlluvZ+oA79CQaT5+E3J+yWkZw5vc8oMspptSgiWAEjVf6PHfI7OxaFnaYMbawSBxoK+3dS/E98JVrSZs1rZm26zehTHQhcWGquwUKCn3VJ9TlSpWOo5q4UDnu0/D/Pv4uZQYEsXPWKW/pokLPL3JvEbTXrjJuB4Ps9HPoTDKjxZKomz8NvksS0yQ/eXPi71SteeXULRM1+fOJQZJTT5G/jdWpRRLDeWjMWQ0DbJ/dLrIEeO+R3qjCT0Tcqe+CDIQxGDR+rg7kU3CUkDjQUkAVDsrfp1SMD4qKFnvhKtCrzPRKkzZrXEMbtcY3cBUA513Lm0Kc6EGSsTbb5tqWHTb3SIcODdeR3iAJC6pLqc16ZndXlTLaLUUfBLcxdKRx4Vl669mj5f0JjjtnfeWboa3IRToICWbg2CS4eqxPGLx8YsYmRJhZMJS1h6rg3idsMPP59K9Bo7J/bH0oCwfd7tsqA3Tj0JxiM/1C+EeW4j6XuzylMnoff+JXweWWPGEjRhG/uX7rIK+uxv412q1e8wqAgGvLqFohG4WEu2/uJH2/w/rnhzll8VcUu2sjfxut81LFNlaT5uyGvjh28tWYsCL4RioaAtk8yi8Hpr5Ep2BuaXn48dsjviH2/SRVnV3ihbCDeL1KHG5tZ8L0GQxiMskhvKls4J9zvM1B6cim4S8Yiz+1IHGgo/BcfjmEN97/VBoAZbtOrR9rY3OFHwjTQ88lDdn335LPJ/JMVVOZ7JODtDIIJnUR0vZYz0iCM2+OUh6xFGrkLgK6yfCYzqJQXh6PjsaBPdSAURAKGiV7qtz1VnRGzazrUB2BNcpp6pUMucdLlxwGaE3MK7bXuEAWEWhtyItQl1edgLqJB/TRKcEk/PdaLnx3MP5RqaqKOglsWhfX9mLtSOCywJZ6xqs2vBaG6CezR8v9Y2oVZxcBtaHHLGs7/9b0LS/7KrdbkIpxi71U6RQPDq/EItA1sElw82BkrmlYnjF/iLPv5fzYTyMs9ZG4iTSyYlkZbPgtcsw+/V8SpMWljbIViFMoYePz7rHOLXRemoAOjrdelPrc/lIq8SDIEgu/3sImYUS2TcGCZmAfGcOhPMMTjOJZZ+dCn7fKnAWPMAMTXx3diSt2fU/7W6PXZOn5kbTEJwvAr4fNEIJZVyh4xkH4VRjbjD64HVwTZob50kVcKf+bxl2UOwCNueWatUN6jGVupBYRBQTQwSjaSAAAAAJ4Aqsx9ByVC4wePjvoOSoRkDuBIhwlvxhkJxQq1G+XTKxtPH8gcwJFWHGpdTxWvV9EVBZsyEooVrBIg2Ssxu3y1MRGwVjaePsg2NPLRP/H4Tz9bNKw41LoyOH52niperwAq9GPjLXvtfS3RIWQkFCv6JL7nGSMxaYcjm6VWYnb5yGLcNStlU7u1Zfl3rGw8fTJslrHRaxk/T2uz8+N5kyp9eTnmnn62aAB+HKQZd9muh3dzYmRw/Oz6cFYgfVPNheNTZ0kAVOjHnlRCC4ddhwEZXS3N+lqiQ2RaCI/ISChWVkiCmrVPDRQrT6fYMkZi0qxGyB5PQUeQ0UHtXO3CnSlzwjflkMW4aw7FEqcXzNeticx9YWrL8u/0y1gjWNl4+sbZ0jYl3l24u973dKLXMn4815iy39AXPEHQvfDG8yZVWPOMmbv0Axcl9KnbPP1s0aL9xh1B+kmT3/rjX3Pow4bt6GlKDu/mxJDvTAiJ5okCF+YjzvThrEBq4QaMu6Dr0CWgQRzGp86SWKdkXkGuoVTfrguYPKmEFqKpLtoOuw4DkLukz3O8K0HtvIGN9LVEh2q17kuJsmHFF7LLCZCRUKwOkfpg7ZZ17nOW3yJqnxoo9J+w5BeYP2qJmJWmJYq1f7uKH7NYjZA9xo068d+E//tBhFU3ooPauTyDcHXahTtTRIWRn6eCHhE5grTdIItx176L2xtdjFSVw4z+WW+e3oDxnnRMEpn7woyZUQ6VkJQEC5A+yOiXsUZ2lxuK8bSAL2+0KuOMs6VtErMPoQu6yquVumBndr3v6ei9RSVEr2X82q/PMDmoQL6nqOpyvqEveCChhbTDpgo6Xaag9oznTaoS5+dm8eBo6G/gwiR26Qcu6Omt4gvuImyV7oigOfyoeaf8ArVE+4072vsn98Py4v1d8kgxvvXHvyD1bXOn1vbWOdZcGtrR05RE0XlYXdi8UsPYFp4g35kQvt8z3BLNEwWMzbnJb8o2R/HKnIvow1mBdsPzTZXEfMMLxNYPN0emeqlHDLZKQIM41EAp9M1J7P5TSUYysE7JvC5OY3CCXEOpHFzpZf9bZuthW8wneFIJLeZSo+EFVSxvm1WGoxx2HQaCdrfKYXE4RP9xkojmeFeCeHj9Tpt/csAFf9gMqW341TdtUhnUat2XSmp3W1NjslHNYxidLmSXE7BkPd9hJdCD/yV6Txwi9cGCIl8NmyuaBwUrMMvmLL9FeCwVidQ+NVBKPp+cqTkQEjc5ut4uMH/UsDDVGFM3WpbNN/BaShRr/9QUwTM3E069qRPkcbAaIXsuGou3zR0EOVMdrvX/D44sYQ8k4IIIq24cCAGiBQHEqJsBbmR4BuHq5gZLJgAAAABDFHsXhij2LsU8jTkMUexdT0WXSop5GnPJbWFkGKLYu1u2o6yeii6V3Z5VghTzNOZX50/xktvCyNHPud9xQsCsMla7u/dqNoK0fk2VfRMs8T4HV+b7O9rfuC+hyGngGBcq9GMA78juOazclS5lsfRKJqWPXeOZAmSgjXlzo4LxguCWipUlqgesZr58u6/THd/sx2bIKfvr8WrvkOa7ICk5+DRSLj0I3xd+HKQAt3HFZPRlvnMxWTNKck1IXdLAMS6R1Eo5VOjHABf8vBfekd1znYWmZFi5K10brVBKymLplYl2koJMSh+7D15krMYzBciFJ37fQBvz5gMPiPEHA5LeRBfpyYErZPDCPx/nC1J+g0hGBZSNeoitzm7zuh+hSmVctTFymYm8S9qdx1wT8KY4UOTdL5XYUBbWzCsBdkFScjVVKWXwaaRcs33fS3oQvi85BMU4/DhIAb8sMxZu44rJLffx3ujLfOer3wfwYrJmlCGmHYPkmpC6p47rraSBY1znlRhLIqmVcmG97mWo0I8B68T0Fi74eS9t7AI4vCO75/83wPA6C03JeR823rByV7rzZiytNlqhlHVO2oPVw6PwltfY51PrVd4Q/y7J2ZJPrZqGNLpfurmDHK7ClM1he0uOdQBcS0mNZQhd9nLBMJcWgiTsAUcYYTgEDBovTwBVZgwULnHJKKNIijzYX0NRuTsARcIsxXlPFYZtNAJXoo3dFLb2ytGKe/OSngDkW/NhgBjnGpfd25euns/suT5Clcp9Vu7duGpj5Pt+GPMyE3mXcQcCgLQ7j7n3L/SuJuBNcWX0NmagyLtf49zASCqxoSxppdo7rJlXAu+NLBXsgqTkr5bf82qqUsopvind4NNIuaPHM65m+76XJe/FgPQgfF+3NAdIcgiKcTEc8Wb4cZACu2XrFX5ZZiw9TR07ncBkSN7UH18b6JJmWPzpcZGRiBXShfMCF7l+O1StBSyFYrzzxnbH5ANKSt1AXjHKiTNQrsonK7kPG6aATA/dl0gDx7gLF7yvzisxlo0/SoFEUivlB0ZQ8sJ63cuBbqbcUKEfAxO1ZBTWiektlZ2SOlzw814f5IhJ2tgFcJnMfmc5QQcUelV8A79p8Tr8fYotNRDrSXYEkF6zOB1n8CxmcCHj369i96S4p8spgeTfUpYtsjPybqZI5auaxdzojr7L64E2OqiVTS1tqcAULr27A+fQ2mekxKFwYfgsSSLsV17zI+6BsDeVlnULGK82H2O4/3IC3Lxmect5WvTyOk6P5ZrD9pbZ142BHOsAuF//e6+WkhrL1YZh3BC67OVTrpfygmEuLcF1VToESdgDR12jFI4wwnDNJLlnCBg0XksMT0kAAAAAPmvC7z3Q9QQDuzfreqDrCUTLKeZHcB4NeRvc4vRA1xPKKxX8yZAiF/f74PiO4DwasIv+9bMwyR6NWwvx6IGuJ9bqbMjVUVsj6zqZzJIhRS6sSofBr/GwKpGacsUcwXk0Iqq72yERjDAfek7fZmGSPVgKUNJbsWc5Zdql1tADXU/uaJ+g7dOoS9O4aqSqo7ZGlMh0qZdzQ0KpGIGtJEOKXBooSLMZk39YJ/i9t17jYVVgiKO6YzOUUV1YVr44gvNoBukxhwVSBmw7OcSDQiIYYXxJ2o5/8u1lQZkviszCJHvyqeaU8RLRf895E5C2Ys9yiAkNnYuyOna12fiZoAe6np5seHGd10+ao7yNddqnUZfkzJN453ekk9kcZnxUR22NaiyvYmmXmIlX/FpmLueGhBCMRGsTN3OALVyxb0iGFLl27dZWdVbhvUs9I1IyJv+wDE09Xw/2CrQxnchbvMbDqoKtAUWBFjauv330QcZmKKP4DepM+7bdp8XdH0hwBOfRTm8lPk3UEtVzv9A6CqQM2DTPzjc3dPncCR87M4REMMK6L/ItuZTFxof/Byn+5NvLwI8ZJMM0Ls/9X+wgmIVJ9qbuixmlVbzymz5+HeIlov/cTmAQ3/VX++GelRRsxZ7lUq5cClEVa+FvfqkOFmV17CgOtwMrtYDoFd5CBwEJBeY/YscJPNnw4gKyMg17qe7vRcIsAEZ5G+t4EtkE9UnS9csiEBrImSfx9vLlHo/pOfyxgvsTsjnM+IxSDhfpiKvB1+NpLtRYXsXqM5wqkyhAyK1Dgieu+LXMkJN3Ix3IfNIjo749IBiJ1h5zSzlnaJfbWQNVNFq4Yt9k06Aw0QpYqe9hmkbs2q2t0rFvQquqs6CVwXFPlnpGpKgRhEslSo+6GyFNVRiaer4m8bhRX+pks2GBplxiOpG3XFFTWDmL9o4H4DRhBFsDijowwWVDKx2HfUDfaH776INAkCpszcshnfOg43LwG9SZznAWdrdrypSJAAh7irs/kLTQ/X+hDr94n2V9l5zeSnyitYiT265UceXFlp7mfqF12BVjmlVOaGtrJaqEaJ6db1b1X4Av7oNiEYVBjRI+dmYsVbSJSY8RX3fk07B0X+RbSjQmtDMv+lYNRDi5Dv8PUjCUzb29z8ZMg6QEo4AfM0i+dPGnx28tRfkE76r6v9hBxNQarnEN4jdPZiDYTN0XM3K21dwLrQk+NcbL0TZ9/DoIFj7VhU01JLsm98u4ncAghvYCz//t3i3BhhzCwj0rKfxW6caZjEwQp+eO/6RcuRSaN3v74yynGd1HZfbe/FId4JeQ8m3MmwNTp1nsUBxuB253rOgXbHAKKQey5Sq8hQ4U10fhAAAAAMDfjsHBuWxYAWbimYJz2bBCrFdxQ8q16IMVOylF4cO6hT5Ne4RYr+JEhyEjx5IaCgdNlMsGK3ZSxvT4k8vE9q4LG3hvCn2a9sqiFDdJty8eiWih34gOQ0ZI0c2HjiU1FE76u9VPnFlMj0PXjQxW7KTMiWJlze+A/A0wDj3Xj5yGF1ASRxY28N7W6X4fVfxFNpUjy/eURSluVJqnr5JuXzxSsdH9U9czZJMIvaUQHYaM0MIITdGk6tQRe2QVHEtqKNyU5Ond8gZwHS2IsZ44s5he5z1ZX4HfwJ9eUQFZqqmSmXUnU5gTxcpYzEsL29lwIhsG/uMaYBx62r+Su+8ZSNYvxsYXLqAkju5/qk9tapFmrbUfp6zT/T5sDHP/qviLbGonBa1rQec0q55p9SiLUtzoVNwd6TI+hCntsEUk3b545AIwueVk0iAlu1zhpq5nyGZx6QlnFwuQp8iFUWE8fcKh4/MDoIURmmBan1vjT6RyI5AqsyL2yCriKUbrOJbUUPhJWpH5L7gIOfA2ybrlDeB6OoMhe1xhuLuD73l9dxfqvaiZK7zOe7J8EfVz/wTOWj/bQJs+vaIC/mIsw/NSIv4zjaw/MutOpvI0wGdxIftOsf51j7CYlxZwRxnXtrPhRHZsb4V3Co0ct9UD3TTAOPT0H7Y19XlUrDWm2m2fNeF3X+pvtl6MjS+eUwPuHUY4x92Ztgbc/1SfHCDaXtrUIs0aC6wMG21OlduywFRYp/t9mHh1vJkelyVZwRnkVPEX2ZQumRiVSHuBVZf1QNaCzmkWXUCoFzuiMdfkLPARENRj0c9aotCpuDsQdjb6k2MN01O8gxJS2mGLkgXvSki6ffGIZfMwiQMRqUncn2jKyaRBChYqgAtwyBnLr0bYDVu+S82EMIrM4tITDD1c0o8oZ/tP9+k6TpELo45OhWKDfotfQ6EFnkLH5weCGGnGAQ1S78HS3C7AtD63AGuwdsafSOUGQMYkByYkvcf5qnxE7JFVhDMflIVV/Q1FinPMcCypobDzJ2CxlcX5cUpLOPJfcBEygP7QM+YcSfM5kog1zWob9RLk2vR0BkM0q4iCt76zq3dhPWp2B9/ztthRMrvoXw97N9HOelEzV7qOvZY5m4a/+UQIfvgi6uc4/WQm/gmctT7WEnQ/sPDt/29+LHx6RQW8pcvEvcMpXX0cp5ynozUnZ3y75mYaWX+mxde+JdDsl+UPYlbkaYDPJLYODuJC9p0inXhcI/uaxeMkFARgMS8toO6h7KGIQ3VhV820bGfDiay4TUit3q/RbQEhEO4UGjkuy5T4L612Ye9y+KAphgAz6VmO8ug/bGso4OKqq/XZg2sqV0JqTLXbqpM7GgAAAABvTKWbn5477PDSnnd/OwYDEHejmOClPe+P6Zh0/nYMBpE6qZ1h6DfqDqSScYFNCgXuAa+eHtMx6XGflHL87RgMk6G9l2NzI+AMP4Z7g9YeD+yau5QcSCXjcwSAeAKbFApt17GRnQUv5vJJin19oBIJEuy3kuI+KeWNcox++NsxGJeXlINnRQr0CAmvb4fgNxvorJKAGH4M93cyqWwGrT0eaeGYhZkzBvL2f6NpeZY7HRbanobmCADxiUSlagQ2KRRreoyPm6gS+PTkt2N7DS8XFEGKjOSTFPuL37Fg+kAlEpUMgIll3h7+CpK7ZYV7IxHqN4aKGuUY/XWpvWbwt2Mwn/vGq28pWNwAZf1Hj4xlM+DAwKgQEl7ff177RA7BbzZhjcqtkV9U2v4T8UFx+mk1HrbMru5kUtmBKPdCDFp7PGMW3qeTxEDQ/IjlS3NhfT8cLdik7P9G04Oz40jyLHc6nWDSoW2yTNYC/ulNjRdxOeJb1KISiUrVfcXvTghsUihnIPezl/JpxPi+zF93V1QrGBvxsOjJb8eHhcpc9hpeLplW+7VphGXCBsjAWYkhWC3mbf22Fr9jwXnzxlr0gUokm83vv2sfccgEU9RTi7pMJ+T26bwUJHfLe2jSUAr3RiJlu+O5lWl9zvol2FV1zEAhGoDluupSe82FHt5W4G/HYI8jYvt/8fyMEL1ZF59UwWPwGGT4AMr6j2+GXxQeGctmcVVu/YGH8Iruy1URYSLNZQ5uaP7+vPaJkfBTEhyC32xzznr3gxzkgOxQQRtjudlvDPV89Pwn4oOTa0cY4vTTao24dvF9auiGEiZNHZ3P1Wnyg3DyAlHuhW0dSx4YtPZ4d/hT44cqzZToZmgPZ4/wewjDVeD4EcuXl11uDObC+n6Jjl/leVzBkhYQZAmZ+fx99rVZ5gZnx5FpK2IK5FnudIsVS+97x9WYFItwA5ti6Hf0Lk3sBPzTm2uwdgAaL+JydWNH6YWx2Z7q/XwFZRTkcQpYQer6it+dlcZ6BhDYpFB/lAHLj0afvOAKOidv46JTAK8HyPB9mb+fMTwk7q6oVoHiDc1xMJO6Hnw2IZGVrlX+2QvODguVuWFHMCLsNbxcg3kZx3Orh7Ac5yIrkw66X/xCH8QMkIGzY9wkKBJDsFp9DxXBjd2LtuKRLi1teLZZAjQTwvLmjbWdqigu6AOVSIdPMNN3na6kGNELP5c4k0v4dDbQCKaop2fqDTwWdZlOeTk81YnroqLmpwc5aU6fTQYCOtb20KShmZwBOhTujUR7oijfi3C2qOQ8EzNr1YtHBJku3PRLsKubBxUw6piBQoXUJNl1BrquGkofNZWjh0H67yLaCj28rWVxGTYAAAAAhdmW3Uu1XGDObMq9lmq5wBOzLx3d3+WgWAZzfW3TA1roCpWHJmZfOqO/yef7ubqafmAsR7AM5vo11XAn2qYHtF9/kWmRE1vUFMrNCUzMvnTJFSipB3niFIKgdMm3dQTuMqySM/zAWI55Gc5TIR+9LqTGK/NqquFO73N3k/VLfrNwkuhuvv4i0zsntA5jIcdz5vhRriiUmxOtTQ3OmJh96R1B6zTTLSGJVvS3VA7yxCmLK1L0RUeYScCeDpQv7XkHqjTv2mRYJWfhgbO6uYfAxzxeVhryMpynd+sKekI+el3H5+yACYsmPYxSsODUVMOdUY1VQJ/hn/0aOAkgq5GNvS5IG2DgJNHdZf1HAD37NH24IqKgdk5oHfOX/sDGQo7nQ5sYOo330ocILkRaUCg3J9XxofobnWtHnkT9mnE3ign07hzUOoLWab9bQLTnXTPJYoSlFKzob6kpMfl0HOSJU5k9H45XUdUz0ohD7oqOMJMPV6ZOwTts80Ti+i5e2vMO2wNl0xVvr26QtjmzyLBKzk1p3BODBRauBtyAczMJ8FS20GaJeLysNP1lOumlY0mUILrfSe7WFfRrD4MphHz0ugGlYmfPyajaShA+BxIWTXqXz9unWaMRGtx6h8fpr/fgbHZhPaIaq4Anwz1df8VOIPoc2P00cBJAsamEnRclaqCS/Px9XJA2wNlJoB2BT9NgBJZFvcr6jwBPIxndevZp+v8v/ycxQzWatJqjR+yc0DppRUbnpymMWiLwGofNg20USFr7yYY2MXQD76epW+nU1N4wQgkQXIi0lYUeaaBQbk4lifiT6+UyLm48pPM2OteOs+NBU32Pi+74Vh0z4m4UE2e3gs6p20hzLALernQErdPx3TsOP7Hxs7poZ26PvRdJCmSBlMQISylB0d30GdeuiZwOOFRSYvLp17tkNDjIE6e9EYV6c31Px/ak2RquoqpnK3s8uuUX9gdgzmDaVRsQ/dDChiAerkydm3faQMNxqT1GqD/giMT1XQ0dY4C8tOcdOW1xwPcBu31y2C2gKt5e3a8HyABhawK95LKUYNFn5EdUvnKamtK4Jx8LLvpHDV2HwtTLWgy4AeeJYZc6ZhLgqePLdnQtp7zJqH4qFPB4WWl1oc+0u80FCT4Uk9QLwePzjhh1LkB0v5PFrSlOnataMxhyzO7WHgZTU8eQjkn/ma7MJg9zAkrFzoeTUxPflSBuWky2s5QgfA4R+erTJCya9KH1DClvmcaU6kBQSbJGIzQ3n7Xp+fN/VHwq6YmTWZ4aFoAIx9jswnpdNVSnBTMn2oDqsQdOhnu6y1/tZ/6KnUB7UwudtT/BIDDmV/1o4CSA7TmyXSNVeOCmjO49AAAAAHbhD52txG7h2yVhfBuPrBltbqOEtkvC+MCqzWU2HlkzQP9WrpvaN9LtOzhPLZH1Kltw+reAVZvL9rSUVmw8smYa3b37wfjch7cZ0xp3sx5/AVIR4tp3cJ6sln8DWiLrVSzD5Mj35oW0gQeKKUGtR0w3TEjR7GkprZqIJjDYeGTNrplrUHW8CiwDXQWxw/fI1LUWx0luM6Y1GNKpqO5mPf6YhzJjQ6JTHzVDXIL16ZHngwieelgt/wYuzPCbtETWq8Kl2TYZgLhKb2G316/LerLZKnUvAg8UU3TuG86CWo+Y9LuABS+e4XlZf+7kmdUjge80LBw0EU1gQvBC/fH3uUGHFrbcXDPXoCrS2D3qeBVYnJkaxUe8e7kxXXQkx+ngcrEI7+9qLY6THMyBDtxmTGuqh0P2caIiigdDLRedywsn6yoEujAPZcZG7mpbhkSnPvClqKMrgMnfXWHGQqvVUhTdNF2JBhE89XDwM2iwWv4NxrvxkB2ekOxrf59xKY/djF9u0hGES7Nt8qq88DIAcZVE4X4In8QfdOklEOkfkYS/aXCLIrJV6l7EtOXDBB4opnL/Jzup2kZH3ztJ2kWzb+ozUmB36HcBC56WDpZePMPzKN3MbvP4rRKFGaKPc6022QVMOUTeaVg4qIhXpWgimsAew5Vdxeb0IbMH+7zi73ODlA58Hk8rHWI5yhL/+WDfmo+B0AdUpLF7IkW+5tTxKrCiECUteTVEUQ/US8zPfoapuZ+JNGK66EgUW+fVjtPB5fgyzngjF68EVfagmZVcbfzjvWJhOJgDHU55DIC4zZjWziyXSxUJ9jdj6Pmqo0I0z9WjO1IOhloueGdVszqXF05MdhjTl1N5r+GydjIhGLtXV/m0yozc1bb6PdorDIlOfXpoQeChTSCc16wvARcG4mRh5+35usKMhcwjgxhWq6UoIEqqtftvy8mNjsRUTSQJMTvFBqzg4GfQlgFoTWC1/BsWVPOGzXGS+ruQnWd7OlACDdtfn9b+PuOgHzF+ExjKwmX5xV++3KQjyD2rvgiXZtt+dmlGpVMIOtOyB6clBpPxU+ecbIjC/RD+I/KNPok/6EhoMHWTTVEJ5axelH8keKQJxXc50uAWRaQBGdhkq9S9EkrbIMlvuly/jrXBSTohlz/bLgrk/k92kh9A61K1jY4kVIIT/3Hjb4mQ7PLLYK4PvYGhkmakwO4QRc9z0O8CFqYODYt9K2z3C8pjav1+9zyLn/ihULqZ3SZblkDm8VslkBBUuEs1NcQ91DpZp1wcadG9E/QKmHKIfHl9FbzTsHDKMr/tERfekWf20QyRQkVa56NKxzyGK7tKZyQmis3pQ/ws5t4nCYeiUeiIPwAAAADo2/u5kbGGqHlqfRFjZXyKi76HM/LU+iIaDwGbh8yJz28XcnYWfQ9n/qb03uSp9UUMcg78dRhz7Z3DiFRPn2JEp0SZ/d4u5Ow29R9VLPoezsQh5Xe9S5hmVZBj38hT64sgiBAyWeJtI7E5lpqrNpcBQ+1suDqHEanSXOoQnj7FiHblPjEPj0Mg51S4mf1buQIVgEK7bOo/qoQxxBMZ8kxH8Sm3/ohDyu9gmDFWepcwzZJMy3TrJrZlA/1N3NGhp8w5elx1QBAhZKjL2t2yxNtGWh8g/yN1Xe7LrqZXVm0uA7621brH3KirLwdTEjUIUond06kwpLnUIUxiL5h9e/vKlaAAc+zKfWIEEYbbHh6HQPbFfPmPrwHoZ3T6Ufq3cgUSbIm8awb0rYPdDxSZ0g6PcQn1NghjiCfguHOeMuSZjto/YjejVR8mS47kn1GB5QS5Wh69wDBjrCjrmBW1KBBBXfPr+CSZlunMQm1Q1k1syz6Wl3JH/OpjrycR2uNFPkILnsX7cvS46povQ1OAIELIaPu5cRGRxGD5Sj/ZZIm3jYxSTDT1ODElHePKnAfsywfvNzC+ll1Nr36Gthas2lwGRAGnvz1r2q7VsCEXz78gjCdk2zVeDqYkttVdnSsW1cnDzS5wuqdTYVJ8qNhIc6lDoKhS+tnCL+sxGdRSu/CHTlMrfPcqQQHmwpr6X9iV+8QwTgB9SSR9bKH/htU8PA6B1Of1OK2NiClFVnOQX1lyC7eCibLO6PSjJjMPGvRv5QoctB6zZd5joo0FmBuXCpmAf9FiOQa7HyjuYOSRc6NsxZt4l3ziEuptCskR1BDGEE/4Hev2gXeW52msbV4lzkLGzRW5f7R/xG5cpD/XRqs+TK5wxfXXGrjkP8FDXaICywlK2TCwM7NNodtothjBZ7eDKbxMOlDWMSu4DcqSalEggoKK2zv74KYqEztdkwk0XAjh76exmIXaoHBeIRntnalNBUZS9HwsL+WU99RcjvjVx2YjLn4fSVNv95Ko1saLfIQuUIc9Vzr6LL/hAZWl7gAOTTX7tzRfhqbchH0fQUf1S6mcDvLQ9nPjOC2IWiIiicHK+XJ4s5MPaVtI9NCJFB7AYc/leRilmGjwfmPR6nFiSgKqmfN7wOTikxsfWw7Ylw/mA2y2n2kRp3ey6h5tveuFhWYQPPwMbS0U15aUWLW5DLBuQrXJBD+kId/EHTvQxYbTCz4/qmFDLkK6uJffeTDDN6LLek7ItmumE03SvBxMSVTHt/AtrcrhxXYxWBcq20j/8SDxhptd4G5Apll0T6fCnJRce+X+IWoNJdrTkOZSh3g9qT4BV9Qv6YwvlvODLg0bWNW0YjKopYrpUxwAAAAAkZFormMloIfytMgph0wx1BbdWXrkaZFTdfj5/U+fE3PeDnvdLLqz9L0r21rI0yKnWUJKCav2giA6Z+qOnj4n5g+vT0j9G4dhbIrvzxlyFjKI436cele2tevG3hvRoTSVQDBcO7KElBIjFfy8Vu0FQcd8be81yKXGpFnNaH17Pxfs6le5Hl6fkI/P9z76Nw7Da6ZmbZkSrkQIg8bqMuQsZKN1RMpRwYzjwFDkTbWoHbAkOXUe1o29N0cc1ZnjRRjxctRwX4BguHYR8dDYZAkpJfWYQYsHLImilr3hDKzaC4I9S2Msz/+rBV5uw6srljpWugdS+EizmtHZIvJ/+vZ+LmtnFoCZ096pCEK2B326T/rsKydUHp/vfY8Oh9O1aW1dJPgF89ZMzdpH3aV0MiVciaO0NCdRAPwOwJGUoGTIWcj1WTFmB+35T5Z8keHjhGgcchUAsoChyJsRMKA1K1dKu7rGIhVIcuo82eOCkqwbe289ihPBzz7b6F6vs0aHjUE5Fhwpl+So4b51OYkQAMFw7ZFQGENj5NBq8nW4xMgSUkpZgzrkqzfyzTqmmmNPXmOe3s8LMCx7wxm96qu3GbNm34giDnF6lsZY6weu9p7/VwsPbj+l/dr3jGxLnyJWLHWsx70dAjUJ1SukmL2F0WBEeEDxLNayReT/I9SMUfTt/VxlfJXyl8hd2wZZNXVzocyI4jCkJhCEbA+BFQShu3LuLyrjhoHYV06oScYmBjw+3/utr7dVXxt/fM6KF9Jq09q6+0KyFAn2ej2YZxKT7Z/rbnwOg8COukvpHysjRyVMycm03aFnRmlpTtf4AeCiAPgdM5GQs8ElWJpQtDA0iZbCSxgHquXqs2LMeyIKYg7a85+fS5sxbf9TGPxuO7bGCdE4V5i5lqUscb80vRkRQUXg7NDUiEIiYEBrs/EoxReo5a2GOY0DdI1FKuUcLYSQ5NR5AXW81/PBdP5iUBxQWDf23smmnnA7ElZZqoM+9997xwpO6q+kvF5njS3PDyMOG4Nyn4rr3G0+I/X8r0tbiVeyphjG2gjqchIhe+N6j0GEkAHQFfivIqEwhrMwWCjGyKHVV1nJe6XtAVI0fGn8kCWklAG0zDrzAAQTYpFsvRdplUCG+P3udEw1x+XdXWnfurfnTivfSbyfF2AtDn/OWPaGM8ln7p070ya0qkJOGnNgvGXi8dTLEEUc4oHUdEz0LI2xZb3lH5cJLTYGmEWYPP+vFq1ux7hf2g+RzktnP7uznsIqIvZs2JY+RUkHVuvtXpuDfM/zLY57OwQf6lOqahKqV/uDwvkJNwrQmKZifqLBiPAzUOBeweQod1B1QNkljbkktBzRikaoGaPXOXENEQYQAGQAAACgAAAAHAAAAACBAAAAgQEAAIECAACBAwAAgQQAAIEFAACBBgAAgQcAAIEIAACBCQAAgQoAAIELAACBDAAAgQ0AAIEOAACBDwAAgRAAAIERAACBEgAAgRMAAIEUAACBFQAAgRYAAIEXAACBGAAAgRkAAIEaAACBGwAAgRwAAIEdAACBHgAAgR8AAIEgAACBIQAAgSIAAIEjAACBJAAAgSUAAIEmAACBJwAAgSgAAIEpAACBKgAAgSsAAIEsAACBLQAAgS4AAIEvAACBMAAAgTEAAIEyAACBMwAAgTQAAIE1AACBNgAAgTcAAIE4AACBOQAAgToAAIE7AACBPAAAgT0AAIE+AACBPwAAgUAAAIFBAACBQgAAgUMAAIFEAACBRQAAgUYAAIFHAACBSAAAgUkAAIFKAACBSwAAgUwAAIFNAACBTgAAgU8AAIFQAACBUQAAgVIAAIFTAACBVAAAgVUAAIFWAACBVwAAgVgAAIFZAACBWgAAgVsAAIFcAACBXQAAgV4AAIFfAACBYAAAgWEAAIFiAACBYwAAgWQAAIFlAACBZgAAgWcAAIFoAACBaQAAgWoAAIFrAACBbAAAgW0AAIFuAACBbwAAgXAAAIFxAACBcgAAgXMAAIF0AACBdQAAgXYAAIF3AACBeAAAgXkAAIF6AACBewAAgXwAAIF9AACBfgAAgX8AAIGAAACBgQAAgYIAAIGDAACBhAAAgYUAAIGGAACBhwAAgYgAAIGJAACBigAAgYsAAIGMAACBjQAAgY4AAIGPAACBkAAAgZEAAIGSAACBkwAAgZQAAIGVAACBlgAAgZcAAIGYAACBmQAAgZoAAIGbAACBnAAAgZ0AAIGeAACBnwAAgaAAAIGhAACBogAAgaMAAIGkAACBpQAAgaYAAIGnAACBqAAAgakAAIGqAACBqwAAgawAAIGtAACBrgAAga8AAIGwAACBsQAAgbIAAIGzAACBtAAAgbUAAIG2AACBtwAAgbgAAIG5AACBugAAgbsAAIG8AACBvQAAgb4AAIG/AACBwAAAgcEAAIHCAACBwwAAgcQAAIHFAACBxgAAgccAAIHIAACByQAAgcoAAIHLAACBzAAAgc0AAIHOAACBzwAAgdAAAIHRAACB0gAAgdMAAIHUAACB1QAAgdYAAIHXAACB2AAAgdkAAIHaAACB2wAAgdwAAIHdAACB3gAAgd8AAIHgAACB4QAAgeIAAIHjAACB5AAAgeUAAIHmAACB5wAAgegAAIHpAACB6gAAgesAAIHsAACB7QAAge4AAIHvAACB8AAAgfEAAIHyAACB8wAAgfQAAIH1AACB9gAAgfcAAIH4AACB+QAAgfoAAIH7AACB/AAAgf0AAIH+AACB/wAAQAAAAAADAAAABAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAQsAAAENAAABDwAAAREAAAITAAACFwAAAhsAAAIfAAADIwAAAysAAAMzAAADOwAABEMAAARTAAAEYwAABHMAAAWDAAAFowAABcMAAAXjAAAAAgEAQAAAAEAAABEGEABkAAAAngEAABcAQdmWxAAL4AKAAQAAgAIAAIADAACABAAAgQUAAIEHAACCCQAAgg0AAIMRAACDGQAAhCEAAIQxAACFQQAAhWEAAIaBAACGwQAAhwEBAIeBAQCIAQIAiAEDAIkBBACJAQYAigEIAIoBDACLARAAiwEYAIwBIACMATAAjQFAAI0BYAAAAAAAAAAAEQYQAGQAAACcAQAAGgAAABEGEABkAAAA6gEAABEAAAARBhAAZAAAAOsBAAARAAAAEQYQAGQAAADwAQAAFQAAABEGEABkAAAA8QEAABUAAAARBhAAZAAAAB4CAAA5AAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADQAAAA8AAAARAAAAEwAAABcAAAAbAAAAHwAAACMAAAArAAAAMwAAADsAAABDAAAAUwAAAGMAAABzAAAAgwAAAKMAAADDAAAA4wAAAAIBAAARBhAAZAAAADUCAAAdAEHEmcQAC74cAQEBAQICAgIDAwMDBAQEBAUFBQUAAAAAEQYQAGQAAABXAgAAOgAAAAAAAAABAQICAwMEBAUFBgYHBwgICQkKCgsLDAwNDQAAEQYQAGQAAAByAgAAHAAAABEGEABkAAAAiQIAABwAAAARBhAAZAAAAIYCAAA0AAAAEQYQAGQAAACGAgAAGQAAABEGEABkAAAAfAIAABgAAAARBhAAZAAAAIACAAAgAAAAEQYQAGQAAAAoAgAAHQAAABEGEABkAAAA9gEAABkAAAARBhAAZAAAAPcBAAAZAAAAEQYQAGQAAADOAgAAOQAAABEGEABkAAAA4wIAABkAAAARBhAAZAAAAAkDAAA6AAAAEQYQAGQAAAAnAwAAHAAAABEGEABkAAAAPgMAABwAAAARBhAAZAAAADsDAAA0AAAAEQYQAGQAAAA7AwAAGQAAABEGEABkAAAAMQMAABgAAAARBhAAZAAAADUDAAAgAAAAEQYQAGQAAADWAgAAGQAAABEGEABkAAAAuwIAABUAAAARBhAAZAAAALUCAAAVAAAAEQYQAGQAAACuAgAAFQAAAAWAAQAFhwEBBYMRAAWLARAFgQUABYkBBAWFQQAFjQFABYADAAWIAQIFhCEABYwBIAWCCQAFigEIBYaBAAUAAAAFgAIABYeBAQWDGQAFiwEYBYEHAAWJAQYFhWEABY0BYAWABAAFiAEDBYQxAAWMATAFgg0ABYoBDAWGwQAFAAAAB0AAAAiBUAAIgRAACARzAAcCHwAIgXAACIEwAAmBwAAHAAoACIFgAAiBIAAJgaAACIEAAAiBgAAIgUAACYHgAAcABgAIgVgACIEYAAmBkAAHAzsACIF4AAiBOAAJgdAABwERAAiBaAAIgSgACYGwAAiBCAAIgYgACIFIAAmB8AAHAAQACIFUAAiBFAAIBeMABwMrAAiBdAAIgTQACYHIAAcBDQAIgWQACIEkAAmBqAAIgQQACIGEAAiBRAAJgegABwAIAAiBXAAIgRwACYGYAAcEUwAIgXwACIE8AAmB2AAHAhcACIFsAAiBLAAJgbgACIEMAAiBjAAIgUwACYH4AAcAAwAIgVIACIESAAgFowAHAyMACIFyAAiBMgAJgcQABwELAAiBYgAIgSIACYGkAAiBAgAIgYIACIFCAAmB5AAHAAcACIFaAAiBGgAJgZQABwRDAAiBegAIgToACYHUAAcCEwAIgWoACIEqAAmBtAAIgQoACIGKAAiBSgAJgfQABwAFAAiBVgAIgRYACEAAAAcDMwAIgXYACIE2AAmBzAAHAQ8ACIFmAAiBJgAJgawACIEGAAiBhgAIgUYACYHsAAcACQAIgV4ACIEeAAmBnAAHBGMACIF+AAiBPgAJgdwABwIbAAiBbgAIgS4ACYG8AAiBDgAIgY4ACIFOAAmB/AAHQAAACIFRAAiBEQAIBYMABwIfAAiBcQAIgTEACYHCAAcACgAIgWEACIEhAAmBogAIgQEACIGBAAiBQQAJgeIABwAGAAiBWQAIgRkACYGSAAcDOwAIgXkACIE5AAmB0gAHAREACIFpAAiBKQAJgbIACIEJAAiBiQAIgUkACYHyAAcABAAIgVUACIEVAAgAAgEHAysACIF1AAiBNQAJgcoABwENAAiBZQAIgSUACYGqAAiBBQAIgYUACIFFAAmB6gAHAAgACIFdAAiBHQAJgZoABwRTAAiBfQAIgT0ACYHaAAcCFwAIgW0ACIEtAAmBugAIgQ0ACIGNAAiBTQAJgfoABwADAAiBUwAIgRMACAXDAAcDIwAIgXMACIEzAAmBxgAHAQsACIFjAAiBIwAJgaYACIEDAAiBgwAIgUMACYHmAAcABwAIgVsACIEbAAmBlgAHBEMACIF7AAiBOwAJgdYABwITAAiBawAIgSsACYG2AAiBCwAIgYsACIFLAAmB9gAHAAUACIFXAAiBFwAIQAAABwMzAAiBdwAIgTcACYHOAAcBDwAIgWcACIEnAAmBrgAIgQcACIGHAAiBRwAJge4ABwAJAAiBXwAIgR8ACYGeAAcEYwAIgX8ACIE/AAmB3gAHAhsACIFvAAiBLwAJgb4ACIEPAAiBjwAIgU8ACYH+AAdAAAAIgVAACIEQAAgEcwAHAh8ACIFwAAiBMAAJgcEABwAKAAiBYAAIgSAACYGhAAiBAAAIgYAACIFAAAmB4QAHAAYACIFYAAiBGAAJgZEABwM7AAiBeAAIgTgACYHRAAcBEQAIgWgACIEoAAmBsQAIgQgACIGIAAiBSAAJgfEABwAEAAiBVAAIgRQACAXjAAcDKwAIgXQACIE0AAmByQAHAQ0ACIFkAAiBJAAJgakACIEEAAiBhAAIgUQACYHpAAcACAAIgVwACIEcAAmBmQAHBFMACIF8AAiBPAAJgdkABwIXAAiBbAAIgSwACYG5AAiBDAAIgYwACIFMAAmB+QAHAAMACIFSAAiBEgAIBaMABwMjAAiBcgAIgTIACYHFAAcBCwAIgWIACIEiAAmBpQAIgQIACIGCAAiBQgAJgeUABwAHAAiBWgAIgRoACYGVAAcEQwAIgXoACIE6AAmB1QAHAhMACIFqAAiBKgAJgbUACIEKAAiBigAIgUoACYH1AAcABQAIgVYACIEWAAhAAAAHAzMACIF2AAiBNgAJgc0ABwEPAAiBZgAIgSYACYGtAAiBBgAIgYYACIFGAAmB7QAHAAkACIFeAAiBHgAJgZ0ABwRjAAiBfgAIgT4ACYHdAAcCGwAIgW4ACIEuAAmBvQAIgQ4ACIGOAAiBTgAJgf0AB0AAAAiBUQAIgREACAWDAAcCHwAIgXEACIExAAmBwwAHAAoACIFhAAiBIQAJgaMACIEBAAiBgQAIgUEACYHjAAcABgAIgVkACIEZAAmBkwAHAzsACIF5AAiBOQAJgdMABwERAAiBaQAIgSkACYGzAAiBCQAIgYkACIFJAAmB8wAHAAQACIFVAAiBFQAIAAIBBwMrAAiBdQAIgTUACYHLAAcBDQAIgWUACIElAAmBqwAIgQUACIGFAAiBRQAJgesABwAIAAiBXQAIgR0ACYGbAAcEUwAIgX0ACIE9AAmB2wAHAhcACIFtAAiBLQAJgbsACIENAAiBjQAIgU0ACYH7AAcAAwAIgVMACIETAAgFwwAHAyMACIFzAAiBMwAJgccABwELAAiBYwAIgSMACYGnAAiBAwAIgYMACIFDAAmB5wAHAAcACIFbAAiBGwAJgZcABwRDAAiBewAIgTsACYHXAAcCEwAIgWsACIErAAmBtwAIgQsACIGLAAiBSwAJgfcABwAFAAiBVwAIgRcACEAAAAcDMwAIgXcACIE3AAmBzwAHAQ8ACIFnAAiBJwAJga8ACIEHAAiBhwAIgUcACYHvAAcACQAIgV8ACIEfAAmBnwAHBGMACIF/AAiBPwAJgd8ABwIbAAiBbwAIgS8ACYG/AAiBDwAIgY8ACIFPAAmB/wARBhAAZAAAAH0BAAAOAAAAEQYQAGQAAAB3AQAAFgAAABEGEABkAAAAXwEAAB0AAAARBhAAZAAAAHIBAAAZAAAAEQYQAGQAAABNAQAAFQAAABAAAAARAAAAEgAAAAAAAAAIAAAABwAAAAkAAAAGAAAACgAAAAUAAAALAAAABAAAAAwAAAADAAAADQAAAAIAAAAOAAAAAQAAAA8AAAARBhAAZAAAACEBAAAhAAAAEQYQAGQAAAAhAQAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IG91dHB1dF9wb3NpdGlvbiA8PSBvdXRwdXQubGVuKCkAAAARBhAAZAAAAHoDAAAJAAAAEQYQAGQAAACLAwAALAAAABEGEABkAAAAiwMAABEAAAARBhAAZAAAAM4DAAAbAAAAEQYQAGQAAAD1AwAAKAAAABEGEABkAAAA4QMAADQAAAARBhAAZAAAAPADAAAgAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogSW1wb3NzaWJsZSB0byBhbGxvY2F0ZSBtb3JlIHRoYW4gaXNpemU6Ok1BWCBieXRlcwBMGBEAWwAAABEGEABkAAAADAQAAA0AAAARBhAAZAAAADEEAAAgAAAAJBIQAGEAAAAuAAAAPwAAACQSEABhAAAALwAAAA0AAAAkEhAAYQAAADcAAAARAAAAJBIQAGEAAACrAAAAIQAAACQSEABhAAAArQAAABEAAAAkEhAAYQAAAJcAAAAVAAAAJBIQAGEAAACfAAAAHgAAACQSEABhAAAAowAAABEAAAAkEhAAYQAAAKQAAAAgAAAAJBIQAGEAAABgAAAAFQAAACQSEABhAAAAhgAAABsAAAAkEhAAYQAAAHEAAAAjAAAAJBIQAGEAAAByAAAAJwAAACQSEABhAAAAcwAAACQAAAAkEhAAYQAAAHQAAAAkAAAAJBIQAGEAAAB2AAAALQAAACQSEABhAAAAdwAAAC0AAAAkEhAAYQAAAH0AAAAdAAAAJBIQAGEAAABhAAAAGgAAACQSEABhAAAAZAAAAA0AAAAkEhAAYQAAAGoAAAANAAAAJBIQAGEAAABSAAAAGAAAACQSEABhAAAAUgAAAAkAAAAkEhAAYQAAAB4AAAAJAAAAlQEAAAwAAAAEAAAArgAAAJUBAAAMAAAABAAAAK8AAACuAAAAUBoRALAAAACxAAAAsgAAALAAAACzAAAAUXVhdFZlYzNBAAAAexsQACoAAAAlAAAAKAAAAEhhc2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3eoGhEAHAAAAKYbEABjAAAAJQAAACgAAACGEhAAYwAAALYAAAAUAAAAtAAAAAwAAAAEAAAAlgEAAJcBAACYAQBBjLbEAAvlAQEAAAC4AAAAAAAAAAQAAAAEAAAAQwAAANi+U74bejIVKG+jYzyrkBLstSCZsW0qQUjvlFj4BjMjAAAAAAQAAAAEAAAAmQEAAAAAAAAEAAAABAAAAJoBAAAAAAAABAAAAAQAAACaAQAAiVBORw0KGgr/2P9HSUY4OWFHSUY4N2FSSUZGAAAAAFdFQlD/////AAAAAE1NACpERFMgQk0AAAEAIz9SQURJQU5DRQAAAABmdHlwYXZpZv//AAB2LzEBcW9pZlAxUDJQM1A0UDVQNlA3ZmFyYmZlbGQAAAB0GxEACAAAAAEAQfy3xAAL2SB8GxEAAwAAAAEAAAAAAAAAAQAAAH8bEQAGAAAAAQAAAAAAAAACAAAAhRsRAAYAAAABAAAAAAAAAAIAAACLGxEADAAAAJcbEQAIAAAAAwAAAJ8bEQAEAAAAAQAAAAAAAAAFAAAAmCgQAAQAAAABAAAAAAAAAAUAAACjGxEABAAAAAEAAAAAAAAABwAAAKcbEQACAAAAAQAAAAAAAAAIAAAAqRsRAAQAAAABAAAAAAAAAAkAAACtGxEACgAAAAEAAAAAAAAACgAAALcbEQAMAAAAwxsRAAQAAAANAAAAxxsRAAQAAAABAAAAAAAAAAsAAADLGxEABAAAAAEAAAAAAAAADgAAAM8bEQACAAAAAQAAAAAAAAAEAAAA0RsRAAIAAAABAAAAAAAAAAQAAADTGxEAAgAAAAEAAAAAAAAABAAAANUbEQACAAAAAQAAAAAAAAAEAAAA1xsRAAIAAAABAAAAAAAAAAQAAADZGxEAAgAAAAEAAAAAAAAABAAAANsbEQACAAAAAQAAAAAAAAAEAAAA3RsRAAgAAAABAAAAAAAAAAwAAACbAQAAEAAAAAQAAACcAQAAmwEAABAAAAAEAAAAnQEAAJwBAACgHREAsAAAAJ4BAACyAAAAnwEAALMAAACgAQAAEAAAAAQAAAChAQAAoAEAABAAAAAEAAAAogEAAKEBAADcHREAowEAAKQBAACyAAAApQEAALMAAAD6DBAAZgAAANECAABDAAAA+gwQAGYAAADSAgAAEwAAAGNhc3RfcGl4ZWxzIHJldHVybmVkIHRoZSByaWdodCBudW1iZXIgb2YgcGl4ZWxzAPoMEABmAAAAlwYAAA4AAABzEBAAZgAAAEcEAAA2AAAAcxAQAGYAAABKBAAANwAAAHMQEABmAAAATQQAADsAAABzEBAAZgAAAGIEAAAdAAAAcxAQAGYAAAB6BAAAQwAAAHMQEABmAAAAcQQAAB0AAABzEBAAZgAAAFAEAAA8AAAAcxAQAGYAAABDBAAAJwAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZmZlci5sZW4oKS5pc19tdWx0aXBsZV9vZihmcm9tX2xheW91dC5jaGFubmVscygpKQAAAHMQEABmAAAAnAQAAAkAAAAAAAAACAAAAAQAAACmAQAAaW5wdXQgbGF5b3V0IGFscmVhZHkgYWxsb2NhdGVkIHdpdGggYXBwcm9wcmlhdGUgbGF5b3V0AABzEBAAZgAAAKIEAAAOAAAApgkQAF4AAAAOAgAAPwAAAEltYWdlIHNpemUgZXhjZWVkcyBsaW1pdFRoZSBmb2xsb3dpbmcgc3RyaWN0IGxpbWl0cyBhcmUgc3BlY2lmaWVkIGJ1dCBub3Qgc3VwcG9ydGVkIGJ5IHRoZSBvcGVydGF0aW9uOiAAAAAAAAQAAAAEAAAAwAAAAAAAAAAEAAAABAAAAMEAAAAAAAAAAQAAAAEAAACnAQAAAAAAAAEAAAABAAAAqAEAAAAAAAABAAAAAQAAAKkBAAAAAAAABAAAAAQAAACqAQAAAAAAAAQAAAAEAAAAqwEAAGlubmVyRm9ybWF0IGVycm9yRm9ybWF0IGVycm9yIGRlY29kaW5nIAChIBEAFgAAAKEgEQAWAAAAXfwRAAIAAABGb3JtYXQgZXJyb3IgZW5jb2RpbmcgAADQIBEAFgAAANAgEQAWAAAAyAISAAIAAAAAAAAABAAAAAQAAACsAQAAVGhlIEltYWdlJ3MgZGltZW5zaW9ucyBhcmUgZWl0aGVyIHRvbyBzbWFsbCBvciB0b28gbGFyZ2VUaGUgZW5kIHRoZSBpbWFnZSBzdHJlYW0gaGFzIGJlZW4gcmVhY2hlZCBkdWUgdG8gYSBwcmV2aW91cyBlcnJvclRoZSBDSUNQICBjYW4gbm90IGJlIHVzZWQgZm9yIFJHQiBpbWFnZXMAAACJIREACQAAAJIhEQAfAAAAVGhlIHBhcmFtZXRlciBpcyBtYWxmb3JtZWQ6IMQhEQAcAAAAVGhlIGVuZCBvZiB0aGUgaW1hZ2UgaGFzIGJlZW4gcmVhY2hlZFRoZSBjb2xvciBzcGFjZSAgZG9lcyBub3QgbWF0Y2ggdGhlIGV4cGVjdGVkIAAADSIRABAAAAAdIhEAHQAAAFz8EQABAAAAYC4AAFQiEQACAAAA6JIRAAEAAABgVW5rbm93bmBJbWFnZUJ1ZmZlclNpemVhY3R1YWxQb2xsZWRBZnRlckVuZE9mSW1hZ2VQb2xsZWRBZnRlckZhdGFsRXJyb3JUaGUgZW5jb2RlciBvciBkZWNvZGVyIGZvciAgZG9lcyBub3Qgc3VwcG9ydCB0aGUgY29sb3IgdHlwZSBgAAAAsCIRABsAAADLIhEAIgAAAOiSEQABAAAAQ29udmVydGluZyB3aXRoIHRoZSB0ZXhlbCBtZW1vcnkgbGF5b3V0ICBpcyBub3Qgc3VwcG9ydGVkAAAACCMRACgAAAAwIxEAEQAAAFRoZSBjb2xvcmltZXRyaWMgaW50ZXJwcmV0YXRpb24gb2YgYSBDSUNQIGNvbG9yIHNwYWNlIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIGBUIxEATAAAAOiSEQABAAAAVGhlIGZpbGUgZXh0ZW5zaW9uICB3YXMgbm90IHJlY29nbml6ZWQgYXMgYW4gaW1hZ2UgZm9ybWF0AAAAsCMRABMAAADDIxEAJgAAAFRoZSBpbWFnZSBmb3JtYXQgY291bGQgbm90IGJlIGRldGVybWluZWRUaGUgaW1hZ2UgZm9ybWF0IAAAACQkEQARAAAAMCMRABEAAABUaGUgZGVjb2RlciBkb2VzIG5vdCBzdXBwb3J0IHRoZSBmb3JtYXQgZmVhdHVyZSBIJBEAMAAAAFRoZSBkZWNvZGVyIGZvciAgZG9lcyBub3Qgc3VwcG9ydCB0aGUgZm9ybWF0IGZlYXR1cmVzIAAAgCQRABAAAACQJBEAJgAAAEVycgAAAAAABAAAAAQAAACtAQAARm9ybWF0RXJyb3JSaWZmU2lnbmF0dXJlSW52YWxpZFdlYnBTaWduYXR1cmVJbnZhbGlkQ2h1bmtNaXNzaW5nQ2h1bmtIZWFkZXJJbnZhbGlkUmVzZXJ2ZWRCaXRTZXRJbnZhbGlkQWxwaGFQcmVwcm9jZXNzaW5nSW52YWxpZENvbXByZXNzaW9uTWV0aG9kQWxwaGFDaHVua1NpemVNaXNtYXRjaEltYWdlVG9vTGFyZ2VGcmFtZU91dHNpZGVJbWFnZUxvc3NsZXNzU2lnbmF0dXJlSW52YWxpZFZlcnNpb25OdW1iZXJJbnZhbGlkSW52YWxpZENvbG9yQ2FjaGVCaXRzSHVmZm1hbkVycm9yQml0U3RyZWFtRXJyb3JUcmFuc2Zvcm1FcnJvclZwOE1hZ2ljSW52YWxpZE5vdEVub3VnaEluaXREYXRhQ29sb3JTcGFjZUludmFsaWRMdW1hUHJlZGljdGlvbk1vZGVJbnZhbGlkSW50cmFQcmVkaWN0aW9uTW9kZUludmFsaWRDaHJvbWFQcmVkaWN0aW9uTW9kZUludmFsaWRJbmNvbnNpc3RlbnRJbWFnZVNpemVzVW5zdXBwb3J0ZWRGZWF0dXJlSW52YWxpZFBhcmFtZXRlck1lbW9yeUxpbWl0RXhjZWVkZWRJbnZhbGlkQ2h1bmtTaXplTm9Nb3JlRnJhbWVzSW52YWxpZERpbWVuc2lvbnMAAAAABAAAAAQAAACuAQAAVHJ5UmVzZXJ2ZUVycm9yTGltaXRzRXhjZWVkZWQAAAC7AAAACAAAAAQAAAAWAAAAuwAAAAgAAAAEAAAAvAAAABYAAAAwJxEAvQAAAL4AAACyAAAAvwAAALMAAABVbnJlcHJlc2VudGFibGVJbnZhbGlkS2V5d29yZFNpemVNaXNzaW5nTnVsbFNlcGFyYXRvckluZmxhdGlvbkVycm9yT3V0T2ZEZWNvbXByZXNzaW9uU3BhY2VJbnZhbGlkQ29tcHJlc3Npb25GbGFnTWlzc2luZ0NvbXByZXNzaW9uRmxhZwAAAAAAAAQAAAAEAAAAwAAAAAAAAAAEAAAABAAAAGMAAABDcmNNaXNtYXRjaGNyY192YWxjcmNfc3VtSW52YWxpZFNpZ25hdHVyZU1pc3NpbmdGY3RsTWlzc2luZ0ltYWdlRGF0YUNodW5rQmVmb3JlSWhkckFmdGVySWRhdEJlZm9yZVBsdGVBZnRlclBsdGVPdXRzaWRlUGx0ZUlkYXREdXBsaWNhdGVDaHVua0FwbmdPcmRlcnByZXNlbnRTaG9ydFBhbGV0dGVsZW4AAAAAAAEAAAABAAAArwEAAEludmFsaWRTYml0Q2h1bmtTaXplY29sb3JfdHlwZQAAAAAAAAEAAAABAAAAsAEAAEludmFsaWRTYml0c2FtcGxlX2RlcHRoc2JpdFBhbGV0dGVSZXF1aXJlZAAAAAAAAAQAAAAEAAAAsQEAAEludmFsaWRDb2xvckJpdERlcHRoYml0X2RlcHRoQ29sb3JXaXRoQmFkVHJuc0ludmFsaWRCaXREZXB0aEludmFsaWRDb2xvclR5cGVJbnZhbGlkRGlzcG9zZU9wSW52YWxpZEJsZW5kT3BJbnZhbGlkVW5pdEludmFsaWRTcmdiUmVuZGVyaW5nSW50ZW50VW5rbm93bkNvbXByZXNzaW9uTWV0aG9kVW5rbm93bkZpbHRlck1ldGhvZFVua25vd25JbnRlcmxhY2VNZXRob2RCYWRTdWJGcmFtZUJvdW5kcwAAAAAAAAAEAAAABAAAALIBAABDb3JydXB0RmxhdGVTdHJlYW1lcnJOb01vcmVJbWFnZURhdGFCYWRUZXh0RW5jb2RpbmdGZGF0U2hvcnRlclRoYW5Gb3VyQnl0ZXNVbmV4cGVjdGVkUmVzdGFydE9mRGF0YUNodW5rU2VxdWVuY2VDaHVua0xlbmd0aFdyb25nVW5yZWNvZ25pemVkQ3JpdGljYWxDaHVua3R5cGVfc3RyQmFkR2FtbWFWYWx1ZQAAAAAAAAAIAAAABAAAALMBAABBbGxvY0Vycm9ybm9uX2V4aGF1c3RpdmWWChAAZwAAACIAAAASAAAAlgoQAGcAAAAjAAAAEgAAAJYKEABnAAAAJAAAABIAAACWChAAZwAAACUAAAASAAAAlgoQAGcAAABsAAAAEQAAAJYKEABnAAAAbAAAAC0AAACWChAAZwAAAG8AAAARAAAAlgoQAGcAAABvAAAALQAAAJYKEABnAAAAVQAAABQAAACWChAAZwAAAFUAAAAsAAAAlgoQAGcAAABWAAAAGgAAAJYKEABnAAAAVgAAADYAAACWChAAZwAAAN8AAAAaAAAAlgoQAGcAAADlAAAAGgAAAJYKEABnAAAAhAAAAAoAAACWChAAZwAAAIQAAAAmAAAAlgoQAGcAAACFAAAAEQAAAJYKEABnAAAAhQAAACkAAAAJExAAbgAAAGoBAAAgAAAACRMQAG4AAAByAQAADgAAAAkTEABuAAAAbwEAACoAQeDYxAALtQIBAAAAtAEAAAkTEABuAAAAJQAAABUAAAAJExAAbgAAADEAAAAdAAAACRMQAG4AAAAqAAAAEQAAAAkTEABuAAAAKgAAADwAAABhc3NlcnRpb24gZmFpbGVkOiByYW5nZS5lbmQgPD0gaW1hZ2VfZGF0YS5sZW4oKQAJExAAbgAAAEwAAAAFAAAACRMQAG4AAABUAAAABQAAAAkTEABuAAAAVwAAADQAAAAJExAAbgAAAFwAAAAFAAAACRMQAG4AAABfAAAANAAAAAkTEABuAAAAZAAAAAUAAAAJExAAbgAAAGcAAAA0AAAACRMQAG4AAABsAAAABQAAAAkTEABuAAAAbwAAADQAAAAJExAAbgAAAHQAAAAyAAAACRMQAG4AAAB4AAAAEwAAAAkTEABuAAAAdwAAABkAQaDbxAALhRgBAAAAtQEAAAkTEABuAAAAdgAAACAAAAAJExAAbgAAAHQAAAAkAAAACRMQAG4AAACJAAAABQAAAAkTEABuAAAAjQAAADEAAAAJExAAbgAAAI0AAABEAAAACRMQAG4AAACSAAAAMgAAAAkTEABuAAAAlQAAAC4AAAAJExAAbgAAAJUAAAATAAAACRMQAG4AAACUAAAAIAAAAAkTEABuAAAAkgAAACQAAAAJExAAbgAAALQAAAAFAAAACRMQAG4AAAC4AAAADQAAAAkTEABuAAAAuQAAAA0AAAAJExAAbgAAAL8AAAAFAAAACRMQAG4AAADDAAAADQAAAAkTEABuAAAAxAAAAA0AAAAJExAAbgAAAMoAAAAyAAAACRMQAG4AAADPAAAAGQAAAAkTEABuAAAAzgAAABMAAAAJExAAbgAAAM0AAAAYAAAACRMQAG4AAADLAAAAIAAAAAkTEABuAAAAygAAACQAAAAJExAAbgAAAOEAAAAyAAAACRMQAG4AAADlAAAAEwAAAAkTEABuAAAA6wAAABMAAAAJExAAbgAAAOwAAAATAAAACRMQAG4AAADtAAAAEwAAAAkTEABuAAAA7gAAABMAAAAJExAAbgAAAOIAAAATAAAACRMQAG4AAADhAAAAJAAAAAkTEABuAAAAGwEAADIAAAAJExAAbgAAAB8BAAATAAAACRMQAG4AAAAeAQAAGAAAAAkTEABuAAAAHAEAACAAAAAJExAAbgAAABsBAAAkAAAACRMQAG4AAABAAQAAMgAAAAkTEABuAAAARAEAAC4AAAAJExAAbgAAAEQBAAATAAAACRMQAG4AAABDAQAANwAAAAkTEABuAAAAQwEAABgAAAAJExAAbgAAAEEBAAAgAAAACRMQAG4AAABAAQAAJAAAAGFzc2VydGlvbiBmYWlsZWQ6IHRhYmxlX3NpemUgPiAwCRMQAG4AAACXAQAABQAAAAkTEABuAAAAowEAAEIAAAAJExAAbgAAACgCAAAiAAAACRMQAG4AAAA8AgAAOQAAAAkTEABuAAAAIwIAADgAAAAJExAAbgAAACMCAAAcAAAACRMQAG4AAAAYAgAAOgAAAAkTEABuAAAAGAIAABgAAAAJExAAbgAAAPMBAAAfAAAAzA0QAHIAAABtAQAAGAAAAMwNEAByAAAAWgAAABgAAAB2JRAAXwAAAKIIAAAlAAAAdiUQAF8AAACiCAAAHgAAAHYlEABfAAAA8AgAACIAAAB2JRAAXwAAAPAIAAAKAAAAdiUQAF8AAADdCAAAHgAAAHYlEABfAAAACgkAAB4AAAB2JRAAXwAAAAsJAAAXAAAAdiUQAF8AAAAPCQAAJgAAAHYlEABfAAAAEgkAACIAAAB2JRAAXwAAAAwJAAAdAAAAdiUQAF8AAACBCAAABQAAAHYlEABfAAAAhAgAACYAAAB2JRAAXwAAAIgIAAArAAAAdiUQAF8AAACICAAAIAAAAHYlEABfAAAAJQgAAEUAAAB2JRAAXwAAADgIAAAxAAAAdiUQAF8AAAAiCAAAHgAAAHYlEABfAAAAHAgAAEEAAAAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZABoAGwAcAB0AHgAfACAAIQAiACMAJAAlACYAJwAoACkAKgArACwALQAuAC8AMAAxADIAMwA0ADUANgA3ADgAOQA6ADwAPgBAAEIARABGAEgASgBMAE4AUABSAFQAVgBYAFoAXABeAGAAYgBkAGYAaABqAGwAbgBwAHIAdAB3AHoAfQCAAIMAhgCJAIwAjwCSAJUAmACbAJ4AoQCkAKcAqgCtALEAtQC5AL0AwQDFAMkAzQDRANUA2QDdAOEA5QDqAO8A9QD5AP4AAwEIAQ0BEgEXARwBBAAFAAYABwAIAAkACgAKAAsADAANAA4ADwAQABEAEQASABMAFAAUABUAFQAWABYAFwAXABgAGQAZABoAGwAcAB0AHgAfACAAIQAiACMAJAAlACUAJgAnACgAKQAqACsALAAtAC4ALgAvADAAMQAyADMANAA1ADYANwA4ADkAOgA7ADwAPQA+AD8AQABBAEIAQwBEAEUARgBHAEgASQBKAEsATABMAE0ATgBPAFAAUQBSAFMAVABVAFYAVwBYAFkAWwBdAF8AYABiAGQAZQBmAGgAagBsAG4AcAByAHQAdgB6AHwAfgCAAIIAhACGAIgAigCMAI8AkQCUAJcAmgCdAHYlEABfAAAAaAgAADAAAAB2JRAAXwAAAFwIAAA7AAAAawIQAF8AAABgAAAANQAAAGsCEABfAAAAYwAAAEEAAABrAhAAXwAAAJUAAAAZAAAAawIQAF8AAACUAAAAGQAAAGsCEABfAAAAkwAAABkAAABrAhAAXwAAAJAAAAAkAAAAawIQAF8AAACPAAAAJAAAAGsCEABfAAAAeAAAABUAAABrAhAAXwAAAHcAAAAVAAAAawIQAF8AAAB2AAAAFQAAAGsCEABfAAAAYwAAACUAAABrAhAAXwAAAF0AAAAlAAAAawIQAF8AAABcAAAAHgAAAGsCEABfAAAAWwAAAB4AAABrAhAAXwAAAFoAAAAeAAAAawIQAF8AAAAvAQAACgAAAGsCEABfAAAANgEAAAoAAABrAhAAXwAAAD4BAAATAAAAawIQAF8AAAA9AQAAEwAAAGsCEABfAAAAPAEAABMAAABrAhAAXwAAAOYAAAAjAAAAawIQAF8AAADnAAAAFwAAAGsCEABfAAAA6QAAABcAAABrAhAAXwAAAOoAAAAXAAAAawIQAF8AAAAMAQAAJQAAAGsCEABfAAAADQEAACUAAABrAhAAXwAAAO8AAAApAAAAawIQAF8AAAClAAAAIwAAAGsCEABfAAAApgAAABcAAABrAhAAXwAAAKgAAAAuAAAAawIQAF8AAACoAAAARgAAAGsCEABfAAAAqQAAAC4AAABrAhAAXwAAAKkAAABGAAAAawIQAF8AAADQAAAAKQAAAGsCEABfAAAA0QAAACkAAABrAhAAXwAAANMAAAApAAAAawIQAF8AAADUAAAAKQAAAGsCEABfAAAA1gAAABwAAABrAhAAXwAAAK0AAAAqAAAAawIQAF8AAAAeAQAABQAAAGsCEABfAAAAHwEAAAUAAABrAhAAXwAAACABAAAFAAAAhhIQAGMAAAA3AAAASQAAAIYSEABjAAAAPgAAAE4AAACGEhAAYwAAAE0AAAApAAAAhhIQAGMAAABZAAAAGAAAAIYSEABjAAAAZgAAACgAAACGEhAAYwAAAG0AAAAaAAAAhhIQAGMAAACHAAAAGwAAAIYSEABjAAAAdQAAACQAAACGEhAAYwAAAHwAAAAiAAAAhhIQAGMAAAB9AAAAIgAAAIYSEABjAAAALwAAAA0AAADLIBAAZAAAADYAAAAUAAAAyyAQAGQAAABhAAAAQQAAAMsgEABkAAAAYQAAADEAAADLIBAAZAAAAFQAAABBAAAAyyAQAGQAAABUAAAAMQAAAMsgEABkAAAAjAAAADUAAADLIBAAZAAAAIwAAAAlAAAAyyAQAGQAAACLAAAAKAAAAMsgEABkAAAAiwAAAB8AAADLIBAAZAAAAIMAAABWAAAAyyAQAGQAAACDAAAARwAAAMsgEABkAAAAgwAAACMAAADLIBAAZAAAAIMAAAATAAAAyyAQAGQAAAB0AAAAMgAAAMsgEABkAAAAdQAAADkAAADLIBAAZAAAAHUAAAApAAAAyyAQAGQAAAB0AAAAIwAAAMsgEABkAAAApAAAABEAAADLIBAAZAAAAKcAAAARAAAAyyAQAGQAAACvAAAAEQAAAMsgEABkAAAAsgAAABEAAADLIBAAZAAAALoAAAAfAAAAyyAQAGQAAAC/AAAAHwAAAMsgEABkAAAAxAAAACAAAADLIBAAZAAAAMYAAAAfAAAAyyAQAGQAAADIAAAAJAAAAHYGEABkAAAAsgIAADsAAABUcnlGcm9tU2xpY2VFcnJvcklPIEVycm9yOiAAaTkRAAoAAABJbnZhbGlkIFJJRkYgc2lnbmF0dXJlOiB8OREAGAAAAAIAAAAAAAAAAgBBsPPEAAvtCSAAAOJJbnZhbGlkIFdlYlAgc2lnbmF0dXJlOiC0OREAGAAAAEFuIGV4cGVjdGVkIGNodW5rIHdhcyBtaXNzaW5nSW52YWxpZCBDaHVuayBoZWFkZXI6IADxOREAFgAAAFJlc2VydmVkIGJpdHMgc2V0QWxwaGEgY2h1bmsgcHJlcHJvY2Vzc2luZyBmbGFnIGludmFsaWRJbnZhbGlkIGNvbXByZXNzaW9uIG1ldGhvZEFscGhhIGNodW5rIHNpemUgbWlzbWF0Y2hJbWFnZSB0b28gbGFyZ2VGcmFtZSBvdXRzaWRlIGltYWdlSW52YWxpZCBsb3NzbGVzcyBzaWduYXR1cmU6IJw6EQAcAAAASW52YWxpZCBsb3NzbGVzcyB2ZXJzaW9uIG51bWJlcjogAAAAwDoRACEAAABJbnZhbGlkIGNvbG9yIGNhY2hlIGJpdHM6IAAA7DoRABoAAABJbnZhbGlkIEh1ZmZtYW4gY29kZUNvcnJ1cHQgYml0c3RyZWFtSW52YWxpZCB0cmFuc2Zvcm1JbnZhbGlkIFZQOCBtYWdpYzogAAAARjsRABMAAABOb3QgZW5vdWdoIFZQOCBpbml0IGRhdGFJbnZhbGlkIFZQOCBjb2xvciBzcGFjZTogAAAAfDsRABkAAABJbnZhbGlkIFZQOCBsdW1hIHByZWRpY3Rpb24gbW9kZTogAACgOxEAIgAAAEludmFsaWQgVlA4IGludHJhIHByZWRpY3Rpb24gbW9kZTogAMw7EQAjAAAASW52YWxpZCBWUDggY2hyb21hIHByZWRpY3Rpb24gbW9kZTog+DsRACQAAABJbmNvbnNpc3RlbnQgaW1hZ2Ugc2l6ZXNVbnN1cHBvcnRlZCBmZWF0dXJlOiAAAAA8PBEAFQAAAEludmFsaWQgcGFyYW1ldGVyOiAAXDwRABMAAABNZW1vcnkgbGltaXQgZXhjZWVkZWRJbnZhbGlkIGNodW5rIHNpemVObyBtb3JlIGZyYW1lc2Nsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBvciBhZnRlciBiZWluZyBkcm9wcGVkAC0kEABcAAAAhTUAAAEAAAA3NDMyMTAvLi1n8kJD5SwrKikoJyYlJCMiITggHx4dHP+UpJWIoJut3d6GeujK1+DQ3My7t7OxqLLI4sOauK5+eL+dwqq9oqGWwY6Jq7C5p7pwr8C8nIyPe4WAk4qSct+X+dju7P3j2ub3h7Tx6fb054v18/vrycTw1pi2zbV/G9TT0tXkxamfg6xpUGJgYVHPkXRzkIKZeWuEbW58b1Jsdo1xgXd9pXVcalNIY11BT6bto8e+4dHLxtnbzur4nu//////////////////////////////////////////////////////////////////////////////////////mwEQAGcAAADZAQAAHQAAAJsBEABnAAAA2gEAABkAAACbARAAZwAAADECAAAbAAAAmwEQAGcAAAAyAgAAHQAAABYMEAByAAAAKgAAABMAAADYHRAAaAAAANMAAAAcAAAAHBgQAGkAAABrBgAAGgAAABwYEABpAAAAawYAADYAAAAcGBAAaQAAAF4GAAAoAAAAFgwQAHIAAAAgAAAACQAAABwYEABpAAAAcwcAAD4AQaj9xAAL2RoBAQEBAgICAgMDAwMEBAQEBQUFBQAAAAADAAQABQAGAAcACAAJAAoACwANAA8AEQATABcAGwAfACMAKwAzADsAQwBTAGMAcwCDAKMAwwDjAAIBAAIAAgACHBgQAGkAAADZBwAATQAAABwYEABpAAAAPAYAAC0AAAAcGBAAaQAAADwGAAAZAAAAHBgQAGkAAACEBgAAIAAAAAEBAQAEAAEAAgADAAQABQAHAAkADQARABkAIQAxAEEAYQCBAMEAAQGBAQECAQMBBAEGAQgBDAEQARgBIAEwAUABYAAAHBgQAGkAAAARAgAAKAAAAAAAAIAAQADAACAAoABgAOAAEACQAFAA0AAwALAAcADwAAgAiABIAMgAKACoAGgA6AAYAJgAWADYADgAuAB4APgABACEAEQAxAAkAKQAZADkABQAlABUANQANAC0AHQA9AAMAIwATADMACwArABsAOwAHACcAFwA3AA8ALwAfAD8AAIAggBCAMIAIgCiAGIA4gASAJIAUgDSADIAsgByAPIACgCKAEoAygAqAKoAagDqABoAmgBaANoAOgC6AHoA+gAGAIYARgDGACYApgBmAOYAFgCWAFYA1gA2ALYAdgD2AA4AjgBOAM4ALgCuAG4A7gAeAJ4AXgDeAD4AvgB+AP4AAQCBAEEAwQAhAKEAYQDhABEAkQBRANEAMQCxAHEA8QAJAIkASQDJACkAqQBpAOkAGQCZAFkA2QA5ALkAeQD5AAUAhQBFAMUAJQClAGUA5QAVAJUAVQDVADUAtQB1APUADQCNAE0AzQAtAK0AbQDtAB0AnQBdAN0APQC9AH0A/QADAIMAQwDDACMAowBjAOMAEwCTAFMA0wAzALMAcwDzAAsAiwBLAMsAKwCrAGsA6wAbAJsAWwDbADsAuwB7APsABwCHAEcAxwAnAKcAZwDnABcAlwBXANcANwC3AHcA9wAPAI8ATwDPAC8ArwBvAO8AHwCfAF8A3wA/AL8AfwD/gACAgIBAgMCAIICggGCA4IAQgJCAUIDQgDCAsIBwgPCACICIgEiAyIAogKiAaIDogBiAmIBYgNiAOIC4gHiA+IAEgISARIDEgCSApIBkgOSAFICUgFSA1IA0gLSAdID0gAyAjIBMgMyALICsgGyA7IAcgJyAXIDcgDyAvIB8gPyAAoCCgEKAwoAigKKAYoDigBKAkoBSgNKAMoCygHKA8oAKgIqASoDKgCqAqoBqgOqAGoCagFqA2oA6gLqAeoD6gAaAhoBGgMaAJoCmgGaA5oAWgJaAVoDWgDaAtoB2gPaADoCOgE6AzoAugK6AboDugB6AnoBegN6APoC+gH6A/oABgIGAQYDBgCGAoYBhgOGAEYCRgFGA0YAxgLGAcYDxgAmAiYBJgMmAKYCpgGmA6YAZgJmAWYDZgDmAuYB5gPmABYCFgEWAxYAlgKWAZYDlgBWAlYBVgNWANYC1gHWA9YANgI2ATYDNgC2ArYBtgO2AHYCdgF2A3YA9gL2AfYD9gAOAg4BDgMOAI4CjgGOA44ATgJOAU4DTgDOAs4BzgPOAC4CLgEuAy4ArgKuAa4DrgBuAm4BbgNuAO4C7gHuA+4AHgIeAR4DHgCeAp4BngOeAF4CXgFeA14A3gLeAd4D3gA+Aj4BPgM+AL4CvgG+A74AfgJ+AX4DfgD+Av4B/gP8cGBAAaQAAAIYCAAAdAAAAHBgQAGkAAAAiBAAAFAAAABwYEABpAAAAIwQAABIAAABhc3NlcnRpb24gZmFpbGVkOiBvdXRfcG9zICsgMyA8IG91dF9zbGljZS5sZW4oKQAcGBAAaQAAADYEAAANAAAAYXNzZXJ0aW9uIGZhaWxlZDogKHNvdXJjZV9wb3MgKyAzKSAmIG91dF9idWZfc2l6ZV9tYXNrIDwgb3V0X3NsaWNlLmxlbigpHBgQAGkAAAA3BAAADQAAABwYEABpAAAAOQQAACIAAAAcGBAAaQAAADoEAAAmAAAAHBgQAGkAAAA7BAAAJgAAABwYEABpAAAARAQAACMAAAAcGBAAaQAAAEQEAAAOAAAAYXNzZXJ0aW9uIGZhaWxlZDogb3V0X3BvcyArIDEgPCBvdXRfc2xpY2UubGVuKCkAHBgQAGkAAABGBAAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IChzb3VyY2VfcG9zICsgMSkgJiBvdXRfYnVmX3NpemVfbWFzayA8IG91dF9zbGljZS5sZW4oKRwYEABpAAAARwQAAA0AAAAcGBAAaQAAAEgEAAAiAAAAHBgQAGkAAABIBAAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IG91dF9wb3MgKyAyIDwgb3V0X3NsaWNlLmxlbigpABwYEABpAAAATAQAAA0AAABhc3NlcnRpb24gZmFpbGVkOiAoc291cmNlX3BvcyArIDIpICYgb3V0X2J1Zl9zaXplX21hc2sgPCBvdXRfc2xpY2UubGVuKCkcGBAAaQAAAE0EAAANAAAAHBgQAGkAAABOBAAAIgAAABwYEABpAAAATgQAAA0AAAAcGBAAaQAAAE8EAAAmAAAAHBgQAGkAAABPBAAADQAAABwYEABpAAAALAQAABcAAAAAAAAACAAAAAQAAAC2AQAAdW5yZWFjaGFibGUA6SQQAGMAAAC1AAAAJgAAANYlEABbAAAAbAEAABEAAADWJRAAWwAAAHUBAAARAAAA1iUQAFsAAAB+AQAAEQAAANYlEABbAAAAiAEAABEAAADWJRAAWwAAAI8BAAAfAAAA1iUQAFsAAACPAQAAJQAAANYlEABbAAAAjwEAABQAAADWJRAAWwAAAJcBAABCAAAA1iUQAFsAAACYAQAAHwAAANYlEABbAAAAmAEAABQAAAAIAAgACAQIAAQACAQEAgQAAgAEAgIBAgABAAIB1iUQAFsAAABuAAAADgAAANYlEABbAAAAaAAAAA4AAADWJRAAWwAAAEMAAAAJAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogTm90IGEgcG9zc2libGUgYnl0ZSByb3VuZGVkIHBpeGVsIHdpZHRoAAAAZEcRAFEAAABGERAAXAAAAFEDAAASAAAARhEQAFwAAABCAAAAHQAAAIkMEABwAAAA9QAAACYAAACJDBAAcAAAAOQAAAAeAAAAiQwQAHAAAADmAAAAHgAAAIkMEABwAAAADwEAABsAAACJDBAAcAAAADQBAAAOAAAAiQwQAHAAAAA0AQAASQAAAIkMEABwAAAAiAAAACgAAACJDBAAcAAAAGYBAAAxAAAArSIQAGIAAACeAAAAJwAAAK0iEABiAAAA5QAAACEAAAAOFBAAZAAAAM4CAAAnAAAADhQQAGQAAADjAgAAHgAAAA4UEABkAAAAGAMAACcAAAAOFBAAZAAAADMDAAA3AAAADhQQAGQAAADVBAAAJwAAAA4UEABkAAAAhQcAACcAAAAOFBAAZAAAAKAFAAAnAAAADhQQAGQAAAD9BQAAJwAAAA4UEABkAAAAcgYAACcAAAAOFBAAZAAAAIoGAAAnAAAADhQQAGQAAADMBAAAHAAAAA4UEABkAAAAzQUAACcAAAAOFBAAZAAAAHUHAAAcAAAADhQQAGQAAAB1BwAALwAAAA4UEABkAAAAcwcAACYAAAAOFBAAZAAAAHEHAAAZAAAADhQQAGQAAABqBwAAMAAAAA4UEABkAAAAaAcAAC4AAAAOFBAAZAAAADgGAAAnAAAADhQQAGQAAACDBQAAJwAAAA4UEABkAAAA+AQAACcAAAAOFBAAZAAAAAUFAAAnAAAADhQQAGQAAADmBQAAJwAAAA4UEABkAAAAOQcAAA4AAAAOFBAAZAAAADsHAAAOAAAADhQQAGQAAABGBQAAJwAAAA4UEABkAAAATAcAABwAAAAOFBAAZAAAAEwHAAA8AAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogVW5yZWNvZ25pemVkIGNodW5rICBzaG91bGQgaGF2ZSBiZWVuIGNhdWdodCBpbiBzdGFydF9jaHVua0BKEQA9AAAAfUoRACcAAAAOFBAAZAAAAGkEAAASAAAADhQQAGQAAAAnBAAAKgAAAA4UEABkAAAApgYAACcAAAAOFBAAZAAAALgCAAA8AAAADhQQAGQAAAC6AgAAHwAAAGFzc2VydGlvbiBmYWlsZWQ6ICg4IC8gYml0X2RlcHRoIGFzIHVzaXplICogY2hhbm5lbHMpLnNhdHVyYXRpbmdfbXVsKGlucHV0LmxlbigpKSA+PQogICAgb3V0cHV0LmxlbigpAAAAeBMQAGcAAABiAAAABQAAAGlucHV0IGZvciB1bnBhY2sgYml0cyBpcyBub3QgZW1wdHkAAHgTEABnAAAAfgAAACUAAABhc3NlcnRpb24gZmFpbGVkOiBtYXRjaGVzIShiaXRfZGVwdGgsIDEgfCAyIHwgNCB8IDgpeBMQAGcAAABfAAAABQAAAHgTEABnAAAAtgAAABoAQYyYxQALOgEAAAC3AQAAuAEAALkBAAAQAAAAeBMQAGcAAABCAAAAEQAAAAAAAAAEAAAABAAAALoBAAC7AQAAuwEAQdCYxQALxRsBAAAAvAEAAL0BAAC+AQAAeBMQAGcAAABVAAAAHAAAAHgTEABnAAAAVQAAAAkAAAB4ExAAZwAAAL0AAAAaAAAAeBMQAGcAAADBAAAAGQAAAENhbGxlciBzaG91bGQgdmVyaWZ56RYQAG8AAAAoAAAAKwAAAOkWEABvAAAASgAAAA0AAADpFhAAbwAAAEoAAAA9AAAA6RYQAG8AAABWAAAAHQAAAOkWEABvAAAARAAAAA0AAADpFhAAbwAAAGcAAAAiAAAA6RYQAG8AAABoAAAADwAAAOkWEABvAAAAYAAAACIAAAAAAAAAAAQAAAEAAAC/AQAAwAEAAMABAAAAAAAAAAQAAAEAAADBAQAAwgEAAMIBAAAAAAAAAAQAAAEAAADDAQAAxAEAAMQBAAB4ExAAZwAAAFAAAAATAAAAQ2h1bmtUeXBlAAAAAAAAAAQAAAABAAAAxQEAAHR5cGUAAAAAAQAAAAEAAADGAQAAY3JpdGljYWxwcml2YXRlcmVzZXJ2ZWRzYWZlY29weU9uZVR3b0ZvdXJFaWdodFNpeHRlZW5HcmF5c2NhbGVSZ2JJbmRleGVkR3JheXNjYWxlQWxwaGFSZ2JhAAAAAAAABAAAAAQAAADAAAAAAAAAAAQAAAAEAAAAwgAAAHdyb25nIGRhdGEgc2l6ZSwgZXhwZWN0ZWQgIGdvdCAAOE4RABoAAABSThEABQAAAEVuZCBvZiBpbWFnZSBoYXMgYmVlbiByZWFjaGVkQSBmYXRhbCBkZWNvZGluZyBlcnJvciBoYXMgYmVlbiBlbmNvdW50ZWQgZWFybGllckNSQyBlcnJvcjogZXhwZWN0ZWQgMHggaGF2ZSAweCB3aGlsZSBkZWNvZGluZyAgY2h1bmsuALZOEQAWAAAAzE4RAAgAAADUThEAEAAAAOROEQAHAAAASW52YWxpZCBQTkcgc2lnbmF0dXJlLmZjVEwgY2h1bmsgbWlzc2luZyBiZWZvcmUgZmRBVCBjaHVuay5JREFUIG9yIGZkQVQgY2h1bmsgaXMgbWlzc2luZy4gY2h1bmsgYXBwZWFyZWQgYmVmb3JlIElIRFIgY2h1bmsAAAEAAAAAAAAAZU8RACEAAABDaHVuayAgaXMgaW52YWxpZCBhZnRlciBJREFUIGNodW5rLgCYTxEABgAAAJ5PEQAdAAAAIGlzIGludmFsaWQgYmVmb3JlIFBMVEUgY2h1bmsuAACYTxEABgAAAMxPEQAeAAAAIGlzIGludmFsaWQgYWZ0ZXIgUExURSBjaHVuay4AAACYTxEABgAAAPxPEQAdAAAAIG11c3QgYXBwZWFyIGJldHdlZW4gUExURSBhbmQgSURBVCBjaHVua3MuAACYTxEABgAAACxQEQAqAAAAIG11c3QgYXBwZWFyIGF0IG1vc3Qgb25jZS4AAJhPEQAGAAAAaFARABoAAABTZXF1ZW5jZSBpcyBub3QgaW4gb3JkZXIsIGV4cGVjdGVkICMgZ290ICMAAJRQEQAkAAAAuFARAAYAAADsXBEAAQAAAE5vdCBlbm91Z2ggcGFsZXR0ZSBlbnRyaWVzLCBleHBlY3QgANhQEQAjAAAAUk4RAAUAAADsXBEAAQAAAFRoZSBzaXplIG9mIHRoZSBzQklUIGNodW5rIHNob3VsZCBiZSAgYnl0ZShzKSwgYnV0ICBieXRlKHMpIHdlcmUgcHJvdmlkZWQgZm9yIHRoZSAgY29sb3IgdHlwZS4AABRREQAlAAAAOVERAA4AAABHUREAHwAAAGZREQAMAAAASW52YWxpZCBzQklUIHZhbHVlIC4gSXQgbXVzdCBiZSBncmVhdGVyIHRoYW4gemVybyBhbmQgbGVzcyB0aGFuIHRoZSBzYW1wbGUgZGVwdGggAAAAlFERABMAAACnUREAPgAAAOxcEQABAAAATWlzc2luZyBwYWxldHRlIG9mIGluZGV4ZWQgaW1hZ2UuSW52YWxpZCBjb2xvci9kZXB0aCBjb21iaW5hdGlvbiBpbiBoZWFkZXI6IC8AAAAhUhEAKwAAAExSEQABAAAAVHJhbnNwYXJlbmN5IGNodW5rIGZvdW5kIGZvciBjb2xvciB0eXBlIGBSEQAoAAAA7FwRAAEAAABJbnZhbGlkIGltYWdlIGRpbWVuc2lvbnNJbnZhbGlkIGJpdCBkZXB0aCAAALBSEQASAAAA7FwRAAEAAABJbnZhbGlkIGNvbG9yIHR5cGUgANRSEQATAAAA7FwRAAEAAABJbnZhbGlkIGRpc3Bvc2Ugb3AgAPhSEQATAAAA7FwRAAEAAABJbnZhbGlkIGJsZW5kIG9wIAAAABxTEQARAAAA7FwRAAEAAABJbnZhbGlkIHBoeXNpY2FsIHBpeGVsIHNpemUgdW5pdCAAAABAUxEAIQAAAOxcEQABAAAASW52YWxpZCBzUkdCIHJlbmRlcmluZyBpbnRlbnQgAAB0UxEAHgAAAOxcEQABAAAAVW5rbm93biBjb21wcmVzc2lvbiBtZXRob2QgAKRTEQAbAAAA7FwRAAEAAABVbmtub3duIGZpbHRlciBtZXRob2QgAADQUxEAFgAAAOxcEQABAAAAVW5rbm93biBpbnRlcmxhY2UgbWV0aG9kIAAAAPhTEQAZAAAA7FwRAAEAAABTdWIgZnJhbWUgaXMgb3V0LW9mLWJvdW5kcy5Db3JydXB0IGRlZmxhdGUgc3RyZWFtLiBJREFUIG9yIGZEQVQgY2h1bmsgZG9lcyBub3QgaGF2ZSBlbm91Z2ggZGF0YSBmb3IgaW1hZ2UuVW5yZXByZXNlbnRhYmxlIGRhdGEgaW4gdEVYdCBjaHVuay4AAACOVBEAIwAAAEtleXdvcmQgZW1wdHkgb3IgbG9uZ2VyIHRoYW4gNzkgYnl0ZXMuAAC8VBEAJgAAAE5vIG51bGwgc2VwYXJhdG9yIGluIHRFWHQgY2h1bmsu7FQRACAAAABJbnZhbGlkIGNvbXByZXNzZWQgdGV4dCBkYXRhLgAAABRVEQAdAAAAT3V0IG9mIGRlY29tcHJlc3Npb24gc3BhY2UuIFRyeSB3aXRoIGEgbGFyZ2VyIGxpbWl0LjxVEQA0AAAAVXNpbmcgYW4gdW5yZWNvZ25pemVkIGJ5dGUgYXMgY29tcHJlc3Npb24gbWV0aG9kLgAAAHhVEQAxAAAAVXNpbmcgYSBmbGFnIHRoYXQgaXMgbm90IDAgb3IgMjU1IGFzIGEgY29tcHJlc3Npb24gZmxhZyBmb3IgaVRYdCBjaHVuay4AtFURAEcAAABObyBjb21wcmVzc2lvbiBmbGFnIGluIHRoZSBpVFh0IGNodW5rLgAABFYRACYAAABmZEFUIGNodW5rIHNob3J0ZXIgdGhhbiA0IGJ5dGVzVW5leHBlY3RlZCByZXN0YXJ0IG9mICBjaHVuayBzZXF1ZW5jZVNWEQAWAAAAaVYRAA8AAABDaHVuayBsZW5ndGggd3Jvbmc6IIhWEQAUAAAAVW5yZWNvZ25pemVkIGNyaXRpY2FsIGNodW5rOiAAAACkVhEAHQAAAEJhZCBnYW1tYSB2YWx1ZS5saW1pdHMgYXJlIGV4Y2VlZGVkQmFkWmxpYkhlYWRlckluc3VmZmljaWVudElucHV0SW52YWxpZEJsb2NrVHlwZUludmFsaWRVbmNvbXByZXNzZWRCbG9ja0xlbmd0aEludmFsaWRIbGl0SW52YWxpZEhkaXN0SW52YWxpZENvZGVMZW5ndGhSZXBlYXRCYWRDb2RlTGVuZ3RoSHVmZm1hblRyZWVCYWRMaXRlcmFsTGVuZ3RoSHVmZm1hblRyZWVCYWREaXN0YW5jZUh1ZmZtYW5UcmVlSW52YWxpZExpdGVyYWxMZW5ndGhDb2RlSW52YWxpZERpc3RhbmNlQ29kZUlucHV0U3RhcnRzV2l0aFJ1bkRpc3RhbmNlVG9vRmFyQmFja1dyb25nQ2hlY2tzdW1FeHRyYUlucHV0MAAAAAEnEAAqAAAAHgEAADEAAAABJxAAKgAAADQBAABHAAAAAScQACoAAAAxAQAAFgAAAGludGVybmFsIGVycm9yOiBlbnRlcmVkIHVucmVhY2hhYmxlIGNvZGU6IHN0cjo6ZnJvbV91dGY4KCkgPSAgd2FzIGV4cGVjdGVkIHRvIGhhdmUgMSBjaGFyLCBidXQgIGNoYXJzIHdlcmUgZm91bmRMWBEAOQAAAIVYEQAEAAAAiVgRACIAAACrWBEAEQAAAAEnEAAqAAAAXAEAABoAAABib29sc3RyaThpMTZpMzJpNjRpMTI4aXNpemV1MTZ1MTI4ZjY0IV8uLi4AAAEnEAAqAAAAigAAAA0AAAABJxAAKgAAAL8BAAAfAAAAAScQACoAAAAeAgAAHgAAAAEnEAAqAAAAIwIAACIAAAABJxAAKgAAACQCAAAlAAAAW117aW52YWxpZCBzeW50YXh9e3JlY3Vyc2lvbiBsaW1pdCByZWFjaGVkfT86Ojo6e2Nsb3N1cmVzaGltI308IGFzID4mIG11dCAqY29uc3QgOyAoLGR5biAgaXMgQ3Vuc2FmZSBleHRlcm4gIgAAAAEnEAAqAAAA1AMAAC0AAAAiIC1mbiggLT4gZmFsc2V0cnVleyB7ICB9ID0gMHgAAAEnEAAqAAAA7QQAAC0AQaC0xQAL4AcBAAAAxwEAAGBmbXQ6OkVycm9yYHMgc2hvdWxkIGJlIGltcG9zc2libGUgd2l0aG91dCBhIGBmbXQ6OkZvcm1hdHRlcmAAAAABJxAAKgAAAIcCAAARAAAAJ2Zvcjw+IC4uPSB8ICFudWxsX19SAAAAAScQACoAAAAyAAAAEwAAAAEnEAAqAAAALwAAABMAAAABJxAAKgAAACsAAAATAAAAAScQACoAAABLAAAADgAAAAEnEAAqAAAAWgAAACgAAAASARAALgAAAGYAAAAcAAAAX1pOABIBEAAuAAAAPQAAAAsAAAASARAALgAAADoAAAALAAAAEgEQAC4AAAA2AAAACwAAAC5sbHZtLgAAmSMQACsAAABiAAAAGwAAAJkjEAArAAAAaQAAABMAAACjERAAUAAAAKYAAAAFAAAAMDEyMzQ1Njc4OWFiY2RlZgAAAAAAAAAAAQAAAMgBAAB7c2l6ZSBsaW1pdCByZWFjaGVkfQAAAAAAAAAAAQAAAMkBAABgZm10OjpFcnJvcmAgZnJvbSBgU2l6ZUxpbWl0ZWRGbXRBZGFwdGVyYCB3YXMgZGlzY2FyZGVkAJkjEAArAAAAUwEAAB4AAABwdW55Y29kZXsAAAAAAAAABAAAAAQAAADKAQAAU2l6ZUxpbWl0RXhoYXVzdGVkAAASARAALgAAAG8AAAAnAAAAEgEQAC4AAABwAAAAHQAAABIBEAAuAAAAcgAAACEAAAASARAALgAAAHMAAAAaAAAAEgEQAC4AAAB+AAAAHQAAABIBEAAuAAAAtAAAACYAAAASARAALgAAALUAAAAhAAAAEgEQAC4AAACKAAAASQAAABIBEAAuAAAAiwAAAB8AAAASARAALgAAAIsAAAAvAAAAQAAAABIBEAAuAAAAnQAAADUAAAASARAALgAAAIIAAAAsAAAAEgEQAC4AAACEAAAAJQAAAC4AAAASARAALgAAAIcAAAAlAAAAAAAAAAEAAAABAAAAywEAABIBEAAuAAAAcgAAAEgAAAAAAAAADAAAAAQAAADMAQAAzQEAAM4BAAAwMDAxMDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgyODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OQBBj7zFAAsBEABBn7zFAAsBFABBr7zFAAsBGQBBvrzFAAsCQB8AQc68xQALAogTAEHevMUACwJqGABB7bzFAAsDgIQeAEH9vMUACwPQEhMAQY29xQALA4TXFwBBnb3FAAsDZc0dAEGsvcUACwQgX6ASAEG8vcUACwTodkgXAEHMvcUACwSilBodAEHbvcUACwVA5ZwwEgBB673FAAsFkB7EvBYAQfu9xQALBTQm9WscAEGKvsUACwaA4Dd5wxEAQZq+xQALBqDYhVc0FgBBqr7FAAsGyE5nbcEbAEG6vsUACwY9kWDkWBEAQcm+xQALB0CMtXgdrxUAQdm+xQALB1Dv4tbkGhsAQem+xQAL+CWS1U0Gz/AQAAAAAAAAAACA9krhxwItFQAAAAAAAAAAILSd2XlDeBoAAAAAAAAAAJSQAigsKosQAAAAAAAAAAC5NAMyt/StFAAAAAAAAABA5wGE/uRx2RkAAAAAAAAAiDCBEh8v5ycQAAAAAAAAAKp8Idfm+uAxFAAAAAAAAIDU2+mMoDlZPhkAAAAAAACgyVIksAiI740fAAAAAAAABL6zFm4FtbW4EwAAAAAAAIWtYJzJRiLjphgAAAAAAEDm2HgDfNjqm9AeAAAAAADoj4crgk3HcmFCEwAAAAAA4nNptuIgec/5EhgAAAAAgNrQA2QbaVdDuBceAAAAAJCIYoIesaEWKtPOEgAAAAC0KvsiZh1KnPSHghcAAAAAYfW5q7+kXMPxKWMdAAAAoFw5VMv35hkaN/pdEgAAAMizRym+tWCg4MR49RYAAAC6oJmzLeN4yBj21rIcAABAdARAkPyNS33PWcbvEQAAUJEFULR7cZ5cQ/C3axYAAKT1BmSh2g3GM1TspQYcAICGWYTepKjIW6C0syeEEQAg6G8lFs7SunLIoaAx5RUAKOLLrpuBh2mPOsoIfl4bAFltP00BsfShmWR+xQ4bEUCvSI+gQd1xCsD93XbSYRUQ2xqzCJJUDg0wfZUUR7oa6sjwb0Xb9CgIPm7dbGy0ECT77MsWEjIzis3JFIiH4RTtOeh+nJb+v+xA/Blq6RkaNCRRzyEe//eTqD1Q4jFQEEFtJUOq5f71uBJN5Fo+ZBSSyO7TFJ9+M2dXYJ3xTX0ZtnrqCNpGXgBBbbgEbqHcH7KMkkVI7DqgSETzwuTk6RPeL/dWWqdJyFoVsPMdXuQY1vu07DARXHqxGpxwpXUdH2Ud8ZO+innsrpBhZodpchO/ZO04bu2Xp9r0+T/pA08Y770ox8nofVERcviP48RiHrV2eRx+se7SSkf7OQ67/RJi1Jej3V2qhx0ZesjRKb0Xe8l9DFX1lOlkn5g6RnSsHe2dzidVGf0Rn2Of5KvIixJoRcJxql981oY8x93Wui4XwtYyDpV3G4yoCzmVjGn6HDnG3yi9KpFXSadD3feBHBLItxdzbHV1rRuRlNR1oqMWuqXdj8fS0phitblJE4tMHJSH6rm8w4OfXREUDuzWrxF5KWXoq7RkB7UVmRGnzBsW13N+4tbhPUkiW//V0L+iG2YIj00mrcZt9Zi/heK3RRGAyvLgb1g4yTJ/LyfbJZcVIH0v2Ytuhnv/XvvwUe/8GjSuvWcXBTStXxudNpMV3hDBGa1BXQaBmDdiRAT4mhUVMmAYkvRHoX7FelUFtgFbGh88T9v4zCRvu2xVwxHheBAnCyMSNwDuSurHKjRWGZcU8M2r1kSAqd3keTXBq9+8GbZgKwYr8IkKL2zBWMsLFhDkOLbHNWwszTrH8S6+jhsUHcejOUOHd4AJOa66bXIiGeS4DAgUaZXgS8dZKQkPax+O8weFrGFdbI8c2Lll6aITcvBJphe6dEezI04ov6OLGI9s3I+d6FEZoKxh8q6Mrh7Zw+l5YjHTD+QLfVftFy0TzzRkGLv9xxPdTlyt6F34FwNCfd4p/blYlGKz2GJ19h1CSQ4rOj50t5wdcMddCboSktvRtchNUeUDJUw5tYtoF3dSRuM6oaXeRC6fh6KuQh2K8wvOxIQnC+t8w5QlrUkSbfCOAfZl8c0lXPT5bhjcFois8oFzv21BL3NxuIoekxzVqzcxqJfkiP3nRrMW89sRypaFPZK9Hev8oRhg3O9SFn385sz2LOUlfMoeeNOr5xvOXRBAGjyvl40+Eytky3ARQnUU0CALm/0wDtg1Pf7MFZKSGQTpzQE9vRFOg8w9QBub+4+isSAhRhbLENKfJggRgvozC95oqdfb/ZTGRzBKFSP5AI4Vw5PNUj06uFm8nBq2m8B47Vl8wFNmJBO49aEQo8Lw1mhwm7Dof+0XJnPKFEzzrAyDTMLc4t/one8P/RkPGOzn0W/5ye2LscL1KT4QEx7nYcbLdzzp7l0zc7RNFJjlYPq3vpWLo2o1AJAhYRn+Hvn4ZS57bkzFQgD0abkfX7Obu//8DMVPuymAOOLTEzeggqo/PFC2Iyo0oMbayBhESCOVT0vko6w0QUh4EfseKw02vRGvbubrwCgt6+pcE3WQgyzWWgrgJvFy+KUlNBiTdKS3i/EMmHCtj3YPL0Ee3MjGUvcWCF9mzBmqab3oEhN7eCe1HMr2fz+gFMTsohfXmVZx4qN89F9PyBn1p4sdJiDWhm3mzfibMR0w+Uh3EjCoi+gIYAH3An4kfDcbFRc8kq4iC7jBtIOdLVsFYtocZRut9QYT+VBygvxYQ30IEj9iGLPIVzflDqM7L5ScihbPet7fui2FntKLCju5Qy0cwQzry5Q8E6Njl+bEU0qcEfHP5f65C9iLPD0gtuhcAxbuQ59+qA7OrotMqOMiNIQbdYojTynJQE3XL0nOlaAyERJt7KJz+5AgzXvbQbtIfxVWiKeLUDq1aMBaUhLqGt8aNrVIV3JEcUG4eHNL0nDLEIPiGu2Olc1R5lZQ3gZN/hQkm2Go8vpA5p9s5JVI4D0a9wA9qdec6O/jw65dLaxmEDRBjJMNxOLr3HQatThXgBSBUW/4EHXbJhQSYeIGbaAZ8ZJFmyopSZhMq3xNJEQEEK33FkJ1c1u+H9bbYC1VBRSYtZySUlDyrafLErl4qgYZ/+JDN2fkbpmRflfnFlVIH99tioLATuX/Gq+WUC41jRNXCS2jcKLev+FavOR5gnAYrUv4ywxL1i+acetdGKOMHkwve//n7uVdACezOu/lFxMf+1n/oWpfdcDwXwlr390X53kwf0pFt5Lw7LfLRVfVHTBMfo9Oi7JbFvRSn4tWpRI8310zIi6f8huxJ4curE4XC1c1wKr5Ru9infEoOlciHWdWIbgKXIzVXQKXWYR2NRIBrClmDXPvSvXC/G8l1MIWARe0v9BPq52y8/vLLolzHGCO0HfiEYuiT3h9P701yBH5scQVW9Yti2PWXI8sQzoWd9412/FL+W38CzSz99PIGwqrASl3z7vEfYcA0HqEXRHNFULzVMPqNV2pAISZ5bQVQJsSMCp0ZYO00wDl/x4iGwihC16aaB/SUIQg719T9RBKiY71wEKnBmWl6Oo3qDIVnSvyMnETUUi+zqLlRVJ/GkJb178mrDLtNsGFr2uTjxASMs1vMFd/qIQxZ5tGeLMUl37Ai/wsn9Ll/UBCWFbgGR5PWNcdfKOjr55oKfc1LBDmYi5NJVuMjFvGwvN0QzcUn/t5oO5xr2/yd7MwUhRFGYd6mEhqTpsL71XgvGZZlh+UTF9tAhFBZ7U1DDbg970Tuh+3CENVEcEiQ49D2HWtGKjn5MqTqlVx6xNzVE7T2B7JEM9enIrVJnPsx/QQhEcT+9SCdkPtivCP5/kxFWUZGDqKI1SUqK3sc2F4flq+Hx5kNpa0XInsc+g8C4/41tMS/cO74bOr55AiDM6ytsyIF/20KtqgliE1K4+BX+T/ah0esVqIJP40AXv5sLvu32ISZV1xqq09gsHZN51q6pf7Fr+0DRUZzeIx0IVEBeV9uhz3kCitL8AtH6LTSiOvjvQRNbVymDsw+aaKiB3sWrJxFoJij35KfLdQreokp/EeDhyRnRmPrq1yUqwSdwhX04gR9gTgMhpZD2dX15TKLAjrFTMGmL9gL9NALQ06/TfKZRvgA793nP2DSDxIRP5inh8R2MSulQP9pFpLWtW9+4VnFQ52GntEPE4x3rBKrXpnwRrJifDMquXQ3oquTqys4LgQO6wsgBUfhZYtWmLX1xjnFErXN+DaZib8uPA6zQ3fIBqO5iLMSACYnXPWRKBoi1QQMqAr/1oA/oQQDFbIQq5pFD6I9r5xgD2mFI9retMZhBlOKrQujuDMz9lyBllIIOUfcJow3VgM4CHIB6Q3LTTvEw3BfBRvD1gqugmNhTgB6xhQ8ZvZShPutChM8KaGwSUf0nYByA7MFHGZL1Yo9Jh3E4bUAXoS/1nNf7trMjF/VRioSYIY136wwF+qBn/93moeCW5Rb0ZPbth7KmRvXssCE4vJJQsY44nOGjU9CzZ+wxfuO+8N3lssgmGCDI7DXbQddYW1yGq5W/F80cc4mrqQEtLm4nrFp7It3MX5xkDpNBeGoJvZtlEfOVM3uPiQIwIdVEQBSBKTswOUInObOlYhEmmVAdrWd6AEOetPQsmrqRbD+oGQzJXIRQfm45K7FlQcujxR2p9dnYvEb847NY60EeiL5dAHtYSutQvCisKxIRbj7h7FSeIlGqOOci0zHqobTVUzG26tV/AlmWf831JKEaEqAKLJmG1sb3+B+5fnnBVJNYAK/P6IR0vfYfp9IQQbTiGQhl2ftQyPK3287pTiEKEpNOg0B+PPcnacayo6GxUKNEEiAsnbgw+Ugwa1CGIahsBoVaFdabKJPBIkcUV9EKfwwqoJtQMfrMsWbc2WnBTRrHMVTKLEJpd+XMiAvMMZA0xojW/lOngezzl90FUaEANfwnDLnkkW5kKInETrIBTE9vJMfgbcm59TqsMVJikZdrQv4B0I04KH6JQ0m29zH8nQHawS5cOxVBHdAMElqBP8RCVXV9403qlVFEExL5IYO5buLO0VwlUUa1mR/bq2HuUdFTy0TZm17OLXet40MhNeZRpLIaH/4qfbjRkWwv4Xtv7gnWmJv9uRUvGfm3L+HTGfrALitVcpm9P2Q6EHvxL+xleDWqOt84GI9JSJyW4XvbgtJDEMmXCiqjH663tKHXaTnLaep1+GpQpffHONThJUuENkhpH3507NdlvQMOIWaaZU/ed19aGigFRyBL2aHAHoVP6waTmlZdB0xyK24BECIuo9HcSHDn8EUnmr41gWgqpkjSS1KdKehaZXlhzvG5HqXtg2EVpDgxPI9t1xdRE2pXaOhJUwFGQYenRVztIVg04UsuW6PBl9npjR6oFHGxKxTI/P9MUvDmP/wjKxDBFW3R9zA3K3u9E7v3N/3U8VrNTnT4ROpSrGCq9Q39SjGuvk8LESUafau2ZtkgtlphAmHm1eVyVR0WrACHdO/s8UsGUINq1upYWF8MoU4v0DGo4/xUEsZYdzU9b+TK1+QhBxjzZSdz5pUOiLPqBYHlMUTjPEJhWOg2TiLk7I7uVnGSJAdXCacaT9mrphemrfwR8VSEmGAMeG3qAUfYyiK9kTGprbp8B4KBbJWZwvi3bPGKGA0tHwlrJbO3CD+y1UAx9kkCODVp5PGSUmMr2cFGITfnTsI+yFo1+ur37sw5k6GJ2R5yxnZ4z3mVue5zRASR4CuxB8oMC3OkD5whAhyO0Sw+kUm8iwZUmQt/NUKTqpFzMk2sH6HL9bdKUwqrOIkx2gVii5HHJXuWhnXkpwNXwSSGxy56NOredCAfZczEIbF1oHT+FMopihk4EzdH8T4hyYZNEMcGX/RPwwoKgvTA0Svr0FEMw+P1Y7PciSO5+QFi4tBxR/Ds8rikx6dwrHNBw9fIRsD2lhW9ZvrIpm/KARTJulR1PDOfLLi1ctgDsJFh8CjxkoNMjuvm6tOGCKixtTYfkPmSA9VTdlbCN8NjcRqLn3U79ojCqFfkcsGwSFFRKo9Sjvgi91Jl5Z9yFF5hoLiZl51bE9Cdjalzo1688QTuv/10oejQuO0T2JAuYDFSLm/43dZXCO8UWNK4PfRBrV7794qj8G+bZLOPuxC2sQyuvvFpXPR7ekXgZ6ns6FFL3mq1x6wxnlTfaHGEZCpxk2cOt5LBowr/D5VM9riQgQQ0xmmLcg/NpsOCrDxqsKFFTff37lKLsRiMb0c7hWDRkq1x/eHvMpFir48ZBmrFAfeubTSvM32k0aO5cawGuSExngiB3wxVDh4Ak9IbAGdxgfGOskbPekGVlMjClcyJQeE+8Sl6MaB7C3r/eZOf0cE9iq13xM4QicpZt1AIg85BeOlQ2cnxkLA48CkwCqS90deX2IwQPw5mGZ4VtASk+qEtec6rEErGC6/9ly0BzjVBcNRGXeBdf4qH+QjwTkGyodiEr/qmOGm8lPutmCblE6Eiodv5X8ZwK84yiQI8rlyBZ05C67+wEDqxwzdKw8H3scyU79VD3h4erxn8jrhfPMEXuiPKqMWZpl7se6ZmcwQBYay8vU7+8A/+l5aUCBPNAb8F7/5PWVYD8y7EHI0CViEaw2P15zuzjPPmdS+kSvuhVXBM81UOoGgw4B5zgWWykbtmKhIXJS5BGpYJDj7dj5EGS7CaoOZ11W03h0XClPOBU9KoxU0sD0KwiXkbPzYoYaZprXdIP4eBtl/jpQ2P2TEACBDVKkNldi/r1JZE79uBRA4ZBmTQTt+n0tXP2hPOcZyIwaYLAi1LxunFk+5YUwEPovIXhcKwlsigPwjV6nPBT4eymWM3YLB20EbDE20UsZ9tqze8BTzkiIBce9g8WeH9poUE1Y9IAtdWOcVnI7wxMQg6RgbjHheFJ8Q+xOCrQYAQBB7+TFAAufOSCamZmZmZmZmZmZmZmZmZkZFa5H4XoUrkfhehSuR+F6FN4kBoGVQ4ts5/up8dJNYhCW1AloImx4eqUsQxzr4jYaq0Nuhhvw+WGE8GjjiLX4FCI2WDhJ88e0No3ttaD3xhBqI43ADlKmh1dIr7ya8tcaiE/XZqVBuJ/fOYww4o55FQemEh9RAS3mspTWJugLLhGkCVHLgWiu1re6vdfZ33wb6jqnojTt8d5flWR54X/9FbvIhej28Cd/GRHqLYGZlxH4DdZAvrQMZcKBdklowiUck3HeM5iQcOoBmyuhhpuEFkPBfingpvMhmxVW556vAxI3NTEPzdeFaSu8idiXstIc+ZBaP9ffNyGJltRGRvUOF/pzSMxF5l/noKtD0tFdchJdhg16PD1mpTSs0rZPyYMdsZ7XlGOXHlFdI0KSDKGcF8FLed2C337afU+bDgq04xJorFti0ZhkKpblXhcQIDkeU/Digafgtu5EUbISQLMtGKkmT85STZJYaqeOqJnCVxNBpH6wt3tQJ6rYfdr10PIeNFBlwF/JplK7E8uuxEDCGJCm6plM1OsOyQ888jaazhOAChHDrVN5sUEZYFC+9rAfZwh0AovcLcFnR7Om/l5aGVKgKTVvsCQ0hp/C6/5LSBTbGe6Q8lkdkJ5/aIll1jkQXymwtB3D+0yXMqeo1SP2GbK6WV2xNZY9rFsfunfpxBQoYuF9J16rl1ZJTPuSh50QDZ1oydjJq/LwDnr4t6WVGj4Xujp6obxbWnIuLZOERBXLRfsuyBrKr66Oi4pCnQMRRQmSsab33LJK5Hiqnfs4GwShQcHrkn31boMtVbEvxxUDtGdniXVkxFicV3cnJmwR0uyl2NuIbW30xiXyCz3gG9sj60YWB76KwzgeKKP9TBZJtlXSEWz+bpxgS1NPMdcRDorvtk8Tl7FgZ0WFGIKLHKWhv/hyD6wnGrlqN60B1hYeTplgwnJWueFgVSwkzkQSlRbCzQMeV/U1zrsTbeM6HaurAQsDGKwqK9gvdopPYhdWiTRvAuC8u1UT88RuDLUSiajtsdDMx5LvHrjUSnruHQe6V45ACtPb8kuTEG/78RcGyN9xANWofPVvD9pY/CcT1gxm6TO7p/q7TLIpjmCmHhHXhIcp/FKVyaOOVAsahRgOrNDSusmoqgeD2HZvrp0T46waHl7c2t2l0cBXsrBiH0+KSEtLsEh+UUGarI7AGxnZodPV1Vlty9rN4ValMxYUe4HcdxF7Vzzi1+er6sIRECrPYFmCXvLGNiamrKoEthm7pYBHaBj1a8VR61ZVnZEUloQABu15KiPRpyLf3X10EFYHNKPhj93RgQzRMZb8UxpFbPboGnPkpzQ9p/RE/Q8Vnlb4U+IoHVNdl1JdapfZEGJXjbkD22HrLvJQlRC/9RroRaTHz0hOvFhb2t2mZZEVIGuDbNnTcWOt4uEXHx5BEc0Rn60ohhyfSAQD82RjmxsL2xi+U2uw5QadNY8d6RUWohVHyw+J8+prSpFy5CCrETe8cXhM27hERqobhG0BRRxfY8HG1hXHAwVVSQO+mp0WGenNa0XeODY3dwdp/q4XEsFBFkaiY8FWWFhyDpex8hzOZ6vRgRwB33kT9XESjigXpexVQc4WNH9h3JDBDtiGEm5HVjV9JCBlAsfnaOSMpB0lOXj3MB2A6gFsuSAd17YXhPos+fOwmbs0I2FNF6z4Ejn3RyhTTlxfVDhoFfKsWh4uLNO5dQt9f0NgU0RbikgYWCPcx/fVMJnPGak2fDttEybS+XKMibSOso8O8fkrFR+4QS6PowcqciimC/THvN0Y+pq+pU85u8GGHtZcBpfkE/b3MAkZwl6c1zDw+tYk1B/4X1oHFGjlSXmNJi/fg3YZYObhBRAgUW7HClK/5c9eFBqFgdEMgNrxBW8OmYTZSxD11GiCFADET9bk4/Sg9RIaK3ftAaqZadkRtxz3s/fbFLzFigGIFO6tdJKwxVz5rxAsCd5opu18SVTqgG+UKLMaJNTkU7hXyjoQVZq/diBcFYN2HUNgeTtic6qu/16AFhGevcjRZvUrnbgQsTLLM1cbf2RtQVLEvH1gDfSOolzfFcy2imfbaf3K5j3D2E59fxHfindyxQ8vq9cvBY7kLv8bgNWSWwRz8oisjGo+Hb9lFmZEQknQKPXTVj1VmEr/6hGjoANCTUGIuVeVu/MQMqsc6eYCaNfNOWF5d/zCQFvvFlRSAiB5cWHnLfnJaM0VWRKGUJ2ZjrVopXxbdnQVVlsd0qZK4T6RIFH9FcX23UR8Fw4fohr/QE2nykQ3krHQyRJKy2n3ZM6uCxFuWFBPtA8eOzzuxVDYizyn8XlzP5AMGMnJ8TfaeQnKhfTHwjJAPRPbQum/9sKoqW+6DJ63Zsge45u6zCvPUyEmlXB+LFKgGIJJlXCJcqkauN0mZfB0sxOddYgaD4R194wvPgjnh4UfF16ge3I2kV8KJpgG7J83Gd/kGZZb+EAZ1YRGBfB/LBRM6kerr8YA4RA3BdGMmSMQR90/RUykZ87nJNW0R4/SGQaxzJ3W6VLYH7fdw59yqBQ4JwpLRe7beRksfmkZwoYQWdipEaLjXymPRjAPjzZxGnoTu6eBHLO6pWvz2NheJxUvqZXsmuMoYlGJj63gS+wQF3Xv4Pc4Dp3oDkyvmqwTG3kqWRqTLdiwU3LWJeJWqRUuVUdID755jdzB3reBRVQRfLsL2n6WjxWUnJeMzwi6G5cv1hT/EaZ3drDf1nJtLhZ5jN5D/6dR+ZHzsnj1vb4Rjq390v4/HMIc7LdaImNkHNiKZEIyM7ABF/BfFbW1thZGooObjsJZAaxZ5t2QxCsSowM5XxcE9s6swqP8GtQSHYOcLUysaV5yvZscykhDQhec44rWiVQY9f3iFggHaZsSxgWrvQ9Uje4va/EM2HTFHQVrIv5ydte+jCLBcEYq0RcEvE7LKMUS/9ZOZ41ruw0ToPl9eHQ7Ucskfth7El98Hk1h/vkpyQ0JtzGt/EF/YxgKgcuUIdTXoMUnJMo0zIITd854VM+5v2dvDG1DIa03H/lxLd2llMwfWXCKz01X+RjH9L19Ud3Wf3rzoT8+rPoTC+4vyeguvv/DuJwy/Xn3H9Yk86AgvzFmNvoWwv3Hkhl4HVwaGswnuF77qwHLbHUUYOR8e64JU5MYybxnovBdEJmglMWwQuse9HSUP2rnLxrh5nYEJwKJ5Vwq3TKIH/MU5+srnYXOoLew7rAooH/CENjf32FvSgFZtEpOdDPM0BqtTObnJdXN4CmiPpCP1nMV8dZRhlF3cU3utMvZcngpEehX6dbovuh7sFSsj4SNdRsgEyHfUzK6/FndiQxqpPcVgELnGEMoyGOuSm5w7umSEWZq2Cc4DQ0GFxFKGhdDHhzrIa3sLKQ9axJ0bnsSnH4WVk5XvfAc/ojbXFj8QeP+ESNKJWK0lJZBX2GNYDYFyxzp1B3oKaqrZ3/nPU340AgXh90XILshVrkyuWTX+XNtEqWVjGYraSPC6sE68sLsex0d3tYeibqCzrs0YlsCV5YXGBjfSwdiNaX89rTiAazeElnzZHnYnIg7lPGHNzYTMR7h9YPHRkpt/NxaBsaRQicYGisDBp9uVzAXr57Rp5tSE5De0TzLfSUaJRgxHKaS6h5A5acwPP4dSLd5WuOEqLsYAFGGwMkxS9PFx66CnVPJE820o81C6RFSCaYX0ciFqB+kkBw+AiHbdAe430A6nlMZUA1KywG0FfcFYBln++RCFKcKCAmbKd74N7N6UvyDNRDX3QyokUIwjlm4KreTOe8ZE0sKIA4CjT7h+e74QmG/FA88CIA+mz1l58dY+psamRDkLA0AZPjIbqUMjpD5kI4a6iOkmen504u3o3FAYdo+FbscUOG6lKk8+YL0mRoV/xArYbObxLp1x47RIMNduzEbiRopFmqVxNILDudosWLBFaF7uhGId9Dbbz4fhyeCZxGbkl0cQL+ALOZjmD4/0NgbSXXkSTPMM71RtkZl/wxHFtRdUG6P1o/Kp14FUcxw0hFTybPjS1cZRNn9bk6t54McqTr2ggl5RwPhlyWliuzPFrr7xGjUYGzPgHmE6m7wPxIq+QcOhzR65Zr10xBLGjMdIpQ5C2yQLlHiKkPaCBVcF7Wpx9W8povagVXP4dMQsBKHD9kiLnHfkJxV5QJTgeYdbAwUT4taTNoW3h3PqJrrF4qjqaWie6OueH6xpSDiIhOpBamial/SfSeXtaKaNp4eVNEggoh/25cfrPdOFZJ+GHengM4GZnx5TCPG2N10mBPxCwHkCnAtj61royeWVFofWtYAUKJZJAy+77UfeBAVGRVFmtmBFB1w/vL3svnZEBR3ansUm0MXwP5bxiguew0Q8kOS7cQF8szKLAoOfSuvGcKcDr7QN1sKb72hccoijBTO4z7Lc/lICIyXtCfVG3AQsJ9keOxbDtqsJVQMVflMGsB/UGDwrz57vbep1hBhChUzZkCA87/LlZcs7t5zGtUQUnDNZlJmrO9YR7BkuZDuGttZpLgOhSMmR2zztvqmixVJrraT2NCCHmwjKV+VhTwRdbCKH/Qanv2sOKj+7giUG/dZ1bIpr7GXvZOGmCUHEBYse3f1uiWOrJfcnhMebKYRE8VYIisJfXq/Lf64yXk9HHZqrU7voP1hzFfLYKGUlxbF7r0LWRr+5wkTCedN3RISOrH8RVtdY6bchA7Yr/vqHMiNMGuvShyFsNA+E/NiIhfU1ya88m7j0Cbay3XC6IEShoykxuoXn7TXKUaJnaecHWtwUAXv3xgqRu4EoReGsBeJ89mdJbPgVGuLnU15nvMSdFL2Ym/rzYd4RS98KJdSHl2oXoK/IgvTxmq/yYYSQhjkuUtozBs8D5+I/zrSDmgTbSl5QHosYBiY2piRg+QMHyQhlDPIVrNGE+ITDjYd1xi2TUMpoHiPONy03KSRSt8Tiq9rqGYnf1pgIWGhgqrLH6K/77nrhTIVTbRNtJu7bxlOmYxhidGOqj2QpPbiYlkUDOHWGqGn2O7K2bYrT4JHEEWbJF6bcid+EfaK37EDDBoESR0YSfWF/g34OxlbadYU0KBKE9Rdnsuk+S8UfIerEE0BEVJTyWPfOlzmufkLrBpxZ9p0D6EcGS+wHvv6b1YVwVJIKtmAsK0lwEsvL/MRETRRDaqONOcVCc0Ssn7rTxvEDXHuPl0fq20KDygyidkVnaSNi2UXGbxXCAwgKNR6EZQ6fBI88vQsWQ3gzNm59xtDlZbb/PTD8OA9s3Dhx18WAxESFpddNloay/UmgTnmEQToHPAk/FaQkN4iCzWPoxzQ7OOMHTDf2aZLgqJdP+kW2iODPbFZf+Hros5OsTJUElw5OC+1wstoedF95E6EUx3jLWC/XTXWU5SnZFByA3YXHIvmZbEqeKl27Lamjs/EEvpE12+1qiYP8ROL132yBx5iat+/KiJSPydDb6xkKAYYToh/mYhO22UfnPKJUCA4E0oNzCh0SsVvZZPqD7QzwB47pAmH9qFqWYQPInP2wpkYlrYHbPjn7q022bT1kTWuE1ZXDODzP35JJPW6IoMifR9FrNZM9v9k1OmQleho6DAZ0Yl4Pfj/g0Puc0TtUyAnFHShk5fGzJzP8Y8D8Q9NHxBSArklpEdhfxyzBeh/rssZDzXHt+nSTcwWXNHs//GiFNmQ0l8hDws9ErDaIzNbghDB51CZaEurYVCzKgaFK2oaZ7lAFLqiIk5AXFVrarwhFVOUAN2U6E4LzUlEvO7J5xBR7QDIh9oXEkip08ZKdgwb2r0AoGxIRttsh9xr1ZGjFa9kzUy9BgVJip/j792nTxGxOuJ6yAoIqEP/OOYvprIb9C7o+zmiOVNp/5Me84QoFl3y7C/7tMd1h/8PsvUDuhEu6kfmkSHZIj//f7Yi01wc8lQGhUGBerVl//+R6KiwFvVDODcBAWLEtzIz24btJhLun/PxAWg2OlmE65GkFQsdixn2J5u5Xvvgabx0UBE8F9Z6Xobi+n4v54djXUB0lhJWkf3W0PeX5XHZOGLNhr0dq9rKeA2TeYTBei3oPdLKF1YVby1xQmHQmsiKhjGoCBMiIhivTmpoTZHaqj1PQHQe6LR58j6IU6TarohkPwBdGIddYSj/bNzprlhtUMyZfROklWgNZa5gqeSNSBp6XC8fg0TtPbe+s7qDcaCuYbDyGDadijEsMvYuNsHmvudZ9RPwYXeCEx295Imb15c/9u4fWk4sNal9yoOhr9/fMviLGRWlVvcg/qGc5/KyTML5bxSqHRL5szEbSrkoj3CblFkQ3ZW2wey1XkP1DeWAxe0oGkreXgFXXuU1xKQdZwSL7RTVsRgBrH63xGkdflLQCL4QIrZam3mXJaEPLzC3s6fJGoFeFUlhrLdN2Vjz+MIfbhWbS0QHgSPG163g9ZM15iQRK6zTPpsFPVlJNFaGIj1uG7yJ3MsVnv3gbcMRBYLK8RVjoeNvERj+syRpQTebO44R0ZvSf7VZY4YHdTUlxcUWHA7jDjORFOnR0pD3UDeeeBYLHD+P2na6dHUNxkAsGPoReMYx5ZAk9+27SKNn4FnDHC0FW7dAHSyLydO1H02uAhckBHxfzX1Wb9QPK+Zwi2gSBm3GmEjJ8H7tshE9ThJ0HZ+9nuAGocCYV8Kn/aQOkBfmyktN0oAAR3mb7MpQpdkSokR5SB3OANiOxa1EgQgpHoLQLW0X2DMTP9FXnZrTIBjOpiQkeUb2qGWnrEoVdk0TfaQ6oI49vXRvpXp3iFbiHmRQleY+MWRdjLf7xQYStRi3pqrry422SnAsltFrDsQTV6SqEhMWJBEaR/DoEhegH9/p7g7cRIPaFGzzU0LfTBmAIb/YfJ0C4kMjKUNofz0UM4Eyev19aE42HFTPuTIxELjOUJCVyUBKvca5SylR6BnGC6emd9QzCDHSx2+H2rkUawnsHsZ2KaCNDtO/0q6UEN/brGSjV0IASRe4/x1+hxoZ4yPqtd8BzaASYJmxMTkVrrUciJFMznBNdeatJ476EOJVlKa1reMar7twSQx9Khvod0OFxFfpe/JijQc9l7sVh/k1BGp5h8mOtQoGZN9iEXHCvAYQj6V15Ih31mxl0RsnNcprpqW39+nTkqvwHUEWH8ShvB4exl/uDw9WjbHNEWXTAmFkY6P/FrOxiUhPfBxR3JtNUBzpMt8ojtQG2ckWDn1JcXPjII+yINh2BRQ7EnwuD4KFBZt+6s1Z8TtTKx3KvqUBnjevy+7XR/Qv3FUXoZiENEv5WAm/rGzDjBarEjAuMDEgZWxlbWVudCBpbiBzZXF1ZW5jZSBlbGVtZW50cyBpbiBzZXF1ZW5jZQAAAAEAAAAAAAAA2IcRABUAAAB1OGYzMnUzMnU2NHVzaXplZXhwbGljaXQgcGFuaWMAAEEeEABkAAAAJAkAABIAAADokhEAAQAAAOiSEQABAAAAYCBvciBgAADokhEAAQAAAECIEQAGAAAA6JIRAAEAAABvbmUgb2YgLCBib29sZWFuIGAAAGmIEQAJAAAA6JIRAAEAAABpbnRlZ2VyIGAAAACEiBEACQAAAOiSEQABAAAAY2hhcmFjdGVyIGAAoIgRAAsAAADokhEAAQAAAHN0cmluZyAAvIgRAAcAAABieXRlIGFycmF5dW5pdCB2YWx1ZU9wdGlvbiB2YWx1ZW5ld3R5cGUgc3RydWN0c2VxdWVuY2VtYXBlbnVtdW5pdCB2YXJpYW50bmV3dHlwZSB2YXJpYW50dHVwbGUgdmFyaWFudHN0cnVjdCB2YXJpYW50LjAAAAAAAAAACAAAAAQAAADPAQAA0AEAANEBAABhIGJvb2xlYW51bml0YSBzdHJpbmdudWxsAAAAayEQAGIAAAByAwAAGQAAAGshEABiAAAAcwMAABoAAABrIRAAYgAAAHQDAAAZAAAAayEQAGIAAAB1AwAAGQAAAGshEABiAAAAdgMAABkAAABrIRAAYgAAAHcDAAAZAAAAayEQAGIAAAB4AwAAGQAAAGshEABiAAAAeQMAABkAAABrIRAAYgAAANQDAAARAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAABAAIAAwAEAAUABgAHAAgACQD//////////////////woACwAMAA0ADgAPAP////////////////////////////////////////////////////////////////////8KAAsADAANAA4ADwD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AABAAIAAwAEAAUABgAHAAgACQAP//////////////////oACwAMAA0ADgAPAA/////////////////////////////////////////////////////////////////////6AAsADAANAA4ADwAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////2shEABiAAAAswEAABoAAABrIRAAYgAAAAACAAATAAAAayEQAGIAAAAFAgAAMwAAAGshEABiAAAACQIAAD4AAABrIRAAYgAAAA8CAAA6AAAAayEQAGIAAACrAQAAPQAAAGshEABiAAAApgEAAEUAAAAgYXQgbGluZSAAAABCCRAAYwAAAPcBAAAhAAAAQgkQAGMAAAD7AQAADAAAACBjb2x1bW4gQgkQAGMAAAACAgAAIQAAAEIJEABjAAAACwIAACoAAABCCRAAYwAAAA8CAAAsAAAAQgkQAGMAAAAUAgAACQAAAGluZi1pbmZOYU4AALQAAAAMAAAABAAAAIkBAACKAQAA0gEAQZiexgAL5Q0BAAAAuAAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkAwhUQAEsAAAAFCwAADgAAAPYQEABPAAAAPAYAABQAAAD2EBAATwAAADwGAAAhAAAA9hAQAE8AAAAwBgAAFAAAAPYQEABPAAAAMAYAACEAAACtAAAADAAAAAQAAACuAAAArQAAAAwAAAAEAAAArwAAAK4AAACojxEAsAAAALEAAACyAAAAsAAAALMAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobmV3X2xlbilFcnJvcigsIGxpbmU6ICwgY29sdW1uOiAUkBEABgAAABqQEQAIAAAAIpARAAoAAABeBxIAAQAAAGludmFsaWQgdmFsdWU6IABMkBEADwAAABqTEQALAAAARU9GIHdoaWxlIHBhcnNpbmcgYSBsaXN0RU9GIHdoaWxlIHBhcnNpbmcgYW4gb2JqZWN0RU9GIHdoaWxlIHBhcnNpbmcgYSBzdHJpbmdFT0Ygd2hpbGUgcGFyc2luZyBhIHZhbHVlZXhwZWN0ZWQgYDpgZXhwZWN0ZWQgYCxgIG9yIGBdYGV4cGVjdGVkIGAsYCBvciBgfWBleHBlY3RlZCBpZGVudGV4cGVjdGVkIHZhbHVlZXhwZWN0ZWQgYCJgaW52YWxpZCBlc2NhcGVpbnZhbGlkIG51bWJlcm51bWJlciBvdXQgb2YgcmFuZ2VpbnZhbGlkIHVuaWNvZGUgY29kZSBwb2ludGNvbnRyb2wgY2hhcmFjdGVyIChcdTAwMDAtXHUwMDFGKSBmb3VuZCB3aGlsZSBwYXJzaW5nIGEgc3RyaW5na2V5IG11c3QgYmUgYSBzdHJpbmdpbnZhbGlkIHZhbHVlOiBleHBlY3RlZCBrZXkgdG8gYmUgYSBudW1iZXIgaW4gcXVvdGVzZmxvYXQga2V5IG11c3QgYmUgZmluaXRlIChnb3QgTmFOIG9yICsvLWluZilsb25lIGxlYWRpbmcgc3Vycm9nYXRlIGluIGhleCBlc2NhcGV0cmFpbGluZyBjb21tYXRyYWlsaW5nIGNoYXJhY3RlcnN1bmV4cGVjdGVkIGVuZCBvZiBoZXggZXNjYXBlcmVjdXJzaW9uIGxpbWl0IGV4Y2VlZGVkAQAAAAAAAAB4jhEACQAAAKSOEQAIAAAAayEQAGIAAABcAgAAEwAAAGshEABiAAAAbgIAABkAAABmbG9hdGluZyBwb2ludCBgYAAAANiSEQAQAAAA6JIRAAEAAAD2EBAATwAAAL0EAAAkAAAAaW52YWxpZCB0eXBlOiAsIGV4cGVjdGVkIAAAAAyTEQAOAAAAGpMRAAsAAADFIxAAZwAAADUAAAAOAAAAZgsQAE4AAAAjCAAAEQAAAD8OEABsAAAAOQAAAAkAAAB2JRAAXwAAAKUGAABLAAAAdiUQAF8AAACrBgAASwAAAHYlEABfAAAAqwYAADEAAAB2JRAAXwAAAKUGAAAxAAAAdiUQAF8AAACZBgAASQAAAHYlEABfAAAAmQYAADEAAAB2JRAAXwAAANYGAABLAAAAdiUQAF8AAADdBgAASwAAAHYlEABfAAAA3QYAADEAAAB2JRAAXwAAANYGAAAxAAAAdiUQAF8AAADJBgAATQAAAHYlEABfAAAAyQYAADUAAAB2JRAAXwAAALsGAABNAAAAdiUQAF8AAAC7BgAANQAAAHYlEABfAAAAjQYAAEkAAAB2JRAAXwAAAI0GAAAxAAAAdiUQAF8AAADFBwAAKgAAAHYlEABfAAAAogcAABUAAAB2JRAAXwAAAKwHAAAhAAAAdiUQAF8AAAC6BwAAIgAAAHYlEABfAAAAsQcAACEAAAB2JRAAXwAAAAcEAAAdAAAAdiUQAF8AAAAaBAAAGgAAAHYlEABfAAAAHAQAAAkAAAB2JRAAXwAAABsEAAAxAAAAdiUQAF8AAAATBAAAEQAAAHYlEABfAAAAEgQAAC0AAAC7AAAACAAAAAQAAAC8AAAAUmVhZGluZyBmcm9tICZbdThdIGNhbid0IGZhaWwgYW5kIHRoZSBjaHVuayBpcyBjb21wbGV0ZQB2JRAAXwAAAA0EAAAWAAAAYXNzZXJ0aW9uIGZhaWxlZDogY29tcGxleGl0eSA8PSAyAAAAdiUQAF8AAADTBQAACQAAAHYlEABfAAAA1wUAABwAAAAAAQIDBgQFBgYGBgYGBgYHdiUQAF8AAADhBQAAGQAAAHVua25vd24gdG9rZW46IADUlREADwAAAHYlEABfAAAAAwYAABYAAACfAEGIrMYACwKlkQBBlKzGAAsDrZSMAEGgrMYAC/VOsJuMhwAAAAAAAAAAtJ2NhoIAAAAAAAAA/v7z5sSxmYyFgoEABQcLEyNDAAEECAUCAwYJDA0KBwsODwAAdiUQAF8AAAAVBgAADQAAAHYlEABfAAAAsQQAABEAAAB2JRAAXwAAALMEAAARAAAAdiUQAF8AAAC1BAAAEQAAAE5vbi1rZXlmcmFtZSBmcmFtZXMAdiUQAF8AAADFBAAAJQAAAHYlEABfAAAAcwUAABsAAAB2JRAAXwAAAHUFAAAxAAAAdiUQAF8AAAB5BQAANwAAAHYlEABfAAAAgQUAAFYAAAB2JRAAXwAAAIEFAAAvAAAAdiUQAF8AAAB5BQAAKwAAAHYlEABfAAAAKAYAACYAAAB2JRAAXwAAACoGAAAXAAAAdiUQAF8AAAAvBgAAFQAAAAUAAAAHAAAAdiUQAF8AAABXBgAAIAAAAHYlEABfAAAAXgYAAC4AAAB2JRAAXwAAAF4GAAAmAAAAdiUQAF8AAABqBgAAHQAAAHYlEABfAAAAQQYAACoAAAB2JRAAXwAAAEIGAAAbAAAAdiUQAF8AAABNBgAAGQAAAHYlEABfAAAAvAUAAEoAAAB2JRAAXwAAAL4FAAA1AAAAdiUQAF8AAAC+BQAAJQAAAHYlEABfAAAAvAUAADoAAABWUDggaW50ZXItcHJlZGljdGlvboQBkQACA5wBgIGjAoKDgAN2JRAAXwAAADUFAAAvAAAAgAHnAIECeAGCAzACBAZZA4MFcwSFhnEFhAd4BocImAeIiXAIgAGYAIECswGCA0ACBAZ+A4MFqgSFhnYFhAcuBocIRgeIiV8IgAGvAIECRQGCA48CBAZQA4MFVQSFhlIFhAdIBocImweIiWcIgAE4AIECOgGCAwoCBAarA4MF2gSFhr0FhAcRBocIDQeIiZgIgAGQAIECRwGCAwoCBAYmA4MFqwSFhtUFhAeQBocIIgeIiRoIgAFyAIECGgGCAxECBAajA4MFLASFhsMFhAcVBocICgeIia0IgAF5AIECGAGCA1ACBAbDA4MFGgSFhj4FhAcsBocIQAeIiVUIgAGqAIECLgGCAzcCBAYTA4MFiASFhqAFhAchBocIzgeIiUcIgAE/AIECFAGCAwgCBAZyA4MFcgSFhtAFhAcMBocICQeIieIIgAFRAIECKAGCAwsCBAZgA4MFtgSFhlQFhAcdBocIEAeIiSQIgAGGAIECtwGCA1kCBAaJA4MFYgSFhmUFhAdqBocIpQeIiZQIgAFIAIECuwGCA2QCBAaCA4MFnQSFhm8FhAcgBocISweIiVAIgAFCAIECZgGCA6cCBAZjA4MFSgSFhj4FhAcoBocI6geIiYAIgAEpAIECNQGCAwkCBAayA4MF8QSFho0FhAcaBocICAeIiWsIgAFoAIECTwGCAwwCBAYbA4MF2QSFhv8FhAdXBocIEQeIiQcIgAFKAIECKwGCAxoCBAaSA4MFSQSFhqYFhAcxBocIFweIiZ0IgAFBAIECJgGCA2kCBAagA4MFMwSFhjQFhAcfBocIcweIiYAIgAFXAIECRAGCA0cCBAYsA4MFcgSFhjMFhAcPBocIugeIiRcIgAEvAIECKQGCAw4CBAZuA4MFtgSFhrcFhAcVBocIEQeIicIIgAFCAIECLQGCAxkCBAZmA4MFxQSFhr0FhAcXBocIEgeIiRYIgAFYAIECWAGCA5MCBAaWA4MFKgSFhi4FhActBocIxAeIic0IgAErAIECYQGCA7cCBAZ1A4MFVQSFhiYFhAcjBocIsweIiT0IgAEnAIECNQGCA8gCBAZXA4MFGgSFhhUFhAcrBocI6AeIiasIgAE4AIECIgGCAzMCBAZoA4MFcgSFhmYFhAcdBocIXQeIiU0IgAFrAIECNgGCAyACBAYaA4MFMwSFhgEFhAdRBocIKweIiR8IgAEnAIECHAGCA1UCBAarA4MFOgSFhqUFhAdaBocIYgeIiUAIgAEiAIECFgGCA3QCBAbOA4MFFwSFhiIFhAcrBocIpgeIiUkIgAFEAIECGQGCA2oCBAYWA4MFQASFhqsFhAckBocI4QeIiXIIgAEiAIECEwGCAxUCBAZmA4MFhASFhrwFhAcQBocITAeIiXwIgAE+AIECEgGCA04CBAZfA4MFVQSFhjkFhAcyBocIMAeIiTMIgAHBAIECZQGCAyMCBAafA4MF1wSFhm8FhAdZBocILgeIiW8IgAE8AIEClAGCAx8CBAasA4MF2wSFhuQFhAcVBocIEgeIiW8IgAFwAIECcQGCA00CBAZVA4MFswSFhv8FhAcmBocIeAeIiXIIgAEoAIECKgGCAwECBAbEA4MF9QSFhtEFhAcKBocIGQeIiW0IgAFkAIECUAGCAwgCBAYrA4MFmgSFhgEFhAczBocIGgeIiUcIgAFYAIECKwGCAx0CBAaMA4MFpgSFhtUFhAclBocIKweIiZoIgAE9AIECPwGCAx4CBAabA4MFQwSFhi0FhAdEBocIAQeIidEIgAGOAIECTgGCA04CBAYQA4MF/wSFhoAFhAciBocIxQeIiasIgAEpAIECKAGCAwUCBAZmA4MF0wSFhrcFhAcEBocIAQeIid0IgAEzAIECMgGCAxECBAaoA4MF0QSFhsAFhAcXBocIGQeIiVIIgAF9AIECYgGCAyoCBAZYA4MFaASFhlUFhAd1BocIrweIiVIIgAFfAIECVAGCAzUCBAZZA4MFgASFhmQFhAdxBocIZQeIiS0IgAFLAIECTwGCA3sCBAYvA4MFMwSFhoAFhAdRBocIqweIiQEIgAE5AIECEQGCAwUCBAZHA4MFZgSFhjkFhAc1BocIKQeIiTEIgAFzAIECFQGCAwICBAYKA4MFZgSFhv8FhAemBocIFweIiQYIgAEmAIECIQGCAw0CBAZ5A4MFOQSFhkkFhAcaBocIAQeIiVUIgAEpAIECCgGCA0MCBAaKA4MFTQSFhm4FhAdaBocILweIiXIIgAFlAIECHQGCAxACBAYKA4MFVQSFhoAFhAdlBocIxAeIiRoIgAE5AIECEgGCAwoCBAZmA4MFZgSFhtUFhAciBocIFAeIiSsIgAF1AIECFAGCAw8CBAYkA4MFowSFhoAFhAdEBocIAQeIiRoIgAGKAIECHwGCAyQCBAarA4MFGwSFhqYFhAcmBocILAeIieUIgAFDAIECVwGCAzoCBAapA4MFUgSFhnMFhAcaBocIOweIibMIgAE/AIECOwGCA1oCBAa0A4MFOwSFhqYFhAddBocISQeIiZoIgAEoAIECKAGCAxUCBAZ0A4MFjwSFhtEFhAciBocIJweIia8IgAE5AIECLgGCAxYCBAYYA4MFgASFhgEFhAc2BocIEQeIiSUIgAEvAIECDwGCAxACBAa3A4MFIgSFht8FhAcxBocILQeIibcIgAEuAIECEQGCAyECBAa3A4MFBgSFhmIFhAcPBocIIAeIibcIgAFBAIECIAGCA0kCBAZzA4MFHASFhoAFhAcXBocIgAeIic0IgAEoAIECAwGCAwkCBAZzA4MFMwSFhsAFhAcSBocIBgeIid8IgAFXAIECJQGCAwkCBAZzA4MFOwSFhk0FhAdABocIFQeIiS8IgAFoAIECNwGCAywCBAbaA4MFCQSFhjYFhAc1BocIggeIieIIgAFAAIECWgGCA0YCBAbNA4MFKASFhikFhAcXBocIGgeIiTkIgAE2AIECOQGCA3ACBAa4A4MFBQSFhikFhAcmBocIpgeIidUIgAEeAIECIgGCAxoCBAaFA4MFmASFhnQFhAcKBocIIAeIiYYIgAFLAIECIAGCAwwCBAYzA4MFwASFhv8FhAegBocIKweIiTMIgAEnAIECEwGCAzUCBAbdA4MFGgSFhnIFhAcgBocISQeIif8IgAEfAIECCQGCA0ECBAbqA4MFAgSFhg8FhAcBBocIdgeIiUkIgAFYAIECHwGCAyMCBAZDA4MFZgSFhlUFhAc3BocIugeIiVUIgAE4AIECFQGCAxcCBAZvA4MFOwSFhs0FhActBocIJQeIicAIgAE3AIECJgGCA0YCBAZ8A4MFSQSFhmYFhAcBBocIIgeIiWIIgAFmAIECPQGCA0cCBAYlA4MFIgSFhjUFhAcfBocI8weIicAIgAFFAIECPAGCA0cCBAYmA4MFSQSFhncFhAccBocI3geIiSUIgAFEAIECLQGCA4ACBAYiA4MFAQSFhi8FhAcLBocI9QeIiasIgAE+AIECEQGCAxMCBAZGA4MFkgSFhlUFhAc3BocIPgeIiUYIgAFLAIECDwGCAwkCBAYJA4MFQASFhv8FhAe4BocIdweIiRAIgAElAIECKwGCAyUCBAaaA4MFZASFhqMFhAdVBocIoAeIiQEIgAE/AIECCQGCA1wCBAaIA4MFHASFhkAFhAcgBocIyQeIiVUIgAFWAIECBgGCAxwCBAYFA4MFQASFhv8FhAcZBocI+AeIiQEIgAE4AIECCAGCAxECBAaEA4MFiQSFhv8FhAc3BocIdAeIiYAIgAE6AIECDwGCAxQCBAZSA4MFhwSFhjkFhAcaBocIeQeIiSgIgAGkAIECMgGCAx8CBAaJA4MFmgSFhoUFhAcZBocIIweIidoIgAEzAIECZwGCAywCBAaDA4MFgwSFhnsFhAcfBocIBgeIiZ4IgAFWAIECKAGCA0ACBAaHA4MFlASFhuAFhActBocItweIiYAIgAEWAIECGgGCAxECBAaDA4MF8ASFhpoFhAcOBocIAQeIidEIgAFTAIECDAGCAw0CBAY2A4MFwASFhv8FhAdEBocILweIiRwIgAEtAIECEAGCAxUCBAZbA4MFQASFht4FhAcHBocIAQeIicUIgAE4AIECFQGCAycCBAabA4MFPASFhooFhAcXBocIZgeIidUIgAFVAIECGgGCA1UCBAZVA4MFgASFhoAFhAcgBocIkgeIiasIgAESAIECCwGCAwcCBAY/A4MFkASFhqsFhAcEBocIBAeIifYIgAEjAIECGwGCAwoCBAaSA4MFrgSFhqsFhAcMBocIGgeIiYAIgAG+AIECUAGCAyMCBAZjA4MFtASFhlAFhAd+BocINgeIiS0IgAFVAIECfgGCAy8CBAZXA4MFsASFhjMFhAcpBocIFAeIiSAIgAFlAIECSwGCA4ACBAaLA4MFdgSFhpIFhAd0BocIgAeIiVUIgAE4AIECKQGCAw8CBAawA4MF7ASFhlUFhAclBocICQeIiT4IgAGSAIECJAGCAxMCBAYeA4MFqwSFhv8FhAdhBocIGweIiRQIgAFHAIECHgGCAxECBAZ3A4MFdgSFhv8FhAcRBocIEgeIiYoIgAFlAIECJgGCAzwCBAaKA4MFNwSFhkYFhAcrBocIGgeIiY4IgAGKAIECLQGCAz0CBAY+A4MF2wSFhgEFhAdRBocIvAeIiUAIgAEgAIECKQGCAxQCBAZ1A4MFlwSFho4FhAcUBocIFQeIiaMIgAFwAIECEwGCAwwCBAY9A4MFwwSFhoAFhAcwBocIBAeIiRgIdiUQAF8AAAA/BQAAJQAAAIABjgCBAnIBgoO3AnYlEABfAAAAUQUAABEAAAB2JRAAXwAAAFIFAAARAAAAdiUQAF8AAABTBQAAEQAAAP///////////////////////////////////////////7D2////////////3/H8///////////5/f3////////////0/P//////////6v7+///////////9///////////////2/v//////////7/3+///////////+//7////////////4/v//////////+//+///////////////////////////9/v//////////+/7+///////////+//7////////////+/f/+////////+v/+//7////////+/////////////////////////////////////////////////////////9n/////////////4fzx/f///v/////q+vH6/f/9/v/////+////////////3/7+///////////u/f7+///////////4/v//////////+f7////////////////////////////9////////////9/7////////////////////////////9/v///////////P/////////////////////////////+/v///////////f/////////////////////////////+/f//////////+v/////////////+/////////////////////////////////////////////////////////7r7+v//////////6vv0/v/////////7+/P9/v/+///////9/v//////////7P3+///////////7/f3+/v/////////+/v///////////v7+///////////////////////////+/////////////v7////////////+/////////////////////////////v////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////j/////////////+v78/v/////////4/vn9///////////9/f//////////9v39///////////8/vv+/v/////////+/P//////////+P79///////////9//7+///////////7/v//////////9fv+///////////9/f7////////////7/f///////////P3+/////////////v/////////////8////////////+f/+//////////////7//////////////f//////////+v///////////////////////////////////////////v///////////////////////////3YlEABfAAAAVwcAABcAAACLAYAAgAKAAYEDgAIEBoADggWABIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosBgACAAoABgQOAAgQGgAOCBYAEg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwGAAIACgAGBA4ACBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAf0AgAKIAYED/gIEBv8DggXkBIOE2wUHCIAGhYaABwkKgAiHiIAJiYqACosBvQCAAoEBgQPyAgQG/wOCBeMEg4TVBQcI/waFhtsHCQqACIeIgAmJioAKiwFqAIACfgGBA+MCBAb8A4IF1gSDhNEFBwj/BoWG/wcJCoAIh4iACYmKgAqLAQEAgAJiAYED+AIEBv8DggXsBIOE4gUHCP8GhYb/BwkKgAiHiIAJiYqACosBtQCAAoUBgQPuAgQG/gOCBd0Eg4TqBQcI/waFhpoHCQqACIeIgAmJioAKiwFOAIAChgGBA8oCBAb3A4IFxgSDhLQFBwj/BoWG2wcJCoAIh4iACYmKgAqLAQEAgAK5AYED+QIEBv8DggXzBIOE/wUHCIAGhYaABwkKgAiHiIAJiYqACosBuACAApYBgQP3AgQG/wOCBewEg4TgBQcIgAaFhoAHCQqACIeIgAmJioAKiwFNAIACbgGBA9gCBAb/A4IF7ASDhOYFBwiABoWGgAcJCoAIh4iACYmKgAqLAQEAgAJlAYED+wIEBv8DggXxBIOE/wUHCIAGhYaABwkKgAiHiIAJiYqACosBqgCAAosBgQPxAgQG/AOCBewEg4TRBQcI/waFhv8HCQqACIeIgAmJioAKiwElAIACdAGBA8QCBAbzA4IF5ASDhP8FBwj/BoWG/wcJCoAIh4iACYmKgAqLAQEAgALMAYED/gIEBv8DggX1BIOE/wUHCIAGhYaABwkKgAiHiIAJiYqACosBzwCAAqABgQP6AgQG/wOCBe4Eg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwFmAIACZwGBA+cCBAb/A4IF0wSDhKsFBwiABoWGgAcJCoAIh4iACYmKgAqLAQEAgAKYAYED/AIEBv8DggXwBIOE/wUHCIAGhYaABwkKgAiHiIAJiYqACosBsQCAAocBgQPzAgQG/wOCBeoEg4ThBQcIgAaFhoAHCQqACIeIgAmJioAKiwFQAIACgQGBA9MCBAb/A4IFwgSDhOAFBwiABoWGgAcJCoAIh4iACYmKgAqLAQEAgAIBAYED/wIEBoADggWABIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosB9gCAAgEBgQP/AgQGgAOCBYAEg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwH/AIACgAGBA4ACBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAcYAgAIjAYED7QIEBt8DggXBBIOEuwUHCKIGhYagBwkKkQiHiJsJiYo+CosBgwCAAi0BgQPGAgQG3QOCBawEg4SwBQcI3AaFhp0HCQr8CIeI3QmJigEKiwFEAIACLwGBA5ICBAbQA4IFlQSDhKcFBwjdBoWGogcJCv8Ih4jfCYmKgAqLAQEAgAKVAYED8QIEBv8DggXdBIOE4AUHCP8GhYb/BwkKgAiHiIAJiYqACosBuACAAo0BgQPqAgQG/QOCBd4Eg4TcBQcI/waFhscHCQqACIeIgAmJioAKiwFRAIACYwGBA7UCBAbyA4IFsASDhL4FBwj5BoWGygcJCv8Ih4j/CYmKgAqLAQEAgAKBAYED6AIEBv0DggXWBIOExQUHCPIGhYbEBwkK/wiHiP8JiYqACosBYwCAAnkBgQPSAgQG+gOCBckEg4TGBQcI/waFhsoHCQqACIeIgAmJioAKiwEXAIACWwGBA6MCBAbyA4IFqgSDhLsFBwj3BoWG0gcJCv8Ih4j/CYmKgAqLAQEAgALIAYED9gIEBv8DggXqBIOE/wUHCIAGhYaABwkKgAiHiIAJiYqACosBbQCAArIBgQPxAgQG/wOCBecEg4T1BQcI/waFhv8HCQqACIeIgAmJioAKiwEsAIACggGBA8kCBAb9A4IFzQSDhMAFBwj/BoWG/wcJCoAIh4iACYmKgAqLAQEAgAKEAYED7wIEBvsDggXbBIOE0QUHCP8GhYalBwkKgAiHiIAJiYqACosBXgCAAogBgQPhAgQG+wOCBdoEg4S+BQcI/waFhv8HCQqACIeIgAmJioAKiwEWAIACZAGBA64CBAb1A4IFugSDhKEFBwj/BoWGxwcJCoAIh4iACYmKgAqLAQEAgAK2AYED+QIEBv8DggXoBIOE6wUHCIAGhYaABwkKgAiHiIAJiYqACosBfACAAo8BgQPxAgQG/wOCBeMEg4TqBQcIgAaFhoAHCQqACIeIgAmJioAKiwEjAIACTQGBA7UCBAb7A4IFwQSDhNMFBwj/BoWGzQcJCoAIh4iACYmKgAqLAQEAgAKdAYED9wIEBv8DggXsBIOE5wUHCP8GhYb/BwkKgAiHiIAJiYqACosBeQCAAo0BgQPrAgQG/wOCBeEEg4TjBQcI/waFhv8HCQqACIeIgAmJioAKiwEtAIACYwGBA7wCBAb7A4IFwwSDhNkFBwj/BoWG4AcJCoAIh4iACYmKgAqLAQEAgAIBAYED+wIEBv8DggXVBIOE/wUHCIAGhYaABwkKgAiHiIAJiYqACosBywCAAgEBgQP4AgQG/wOCBf8Eg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwGJAIACAQGBA7ECBAb/A4IF4ASDhP8FBwiABoWGgAcJCoAIh4iACYmKgAqLAf0AgAIJAYED+AIEBvsDggXPBIOE0AUHCP8GhYbABwkKgAiHiIAJiYqACosBrwCAAg0BgQPgAgQG8wOCBcEEg4S5BQcI+QaFhsYHCQr/CIeI/wmJioAKiwFJAIACEQGBA6sCBAbdA4IFoQSDhLMFBwjsBoWGpwcJCv8Ih4jqCYmKgAqLAQEAgAJfAYED9wIEBv0DggXUBIOEtwUHCP8GhYb/BwkKgAiHiIAJiYqACosB7wCAAloBgQP0AgQG+gOCBdMEg4TRBQcI/waFhv8HCQqACIeIgAmJioAKiwGbAIACTQGBA8MCBAb4A4IFvASDhMMFBwj/BoWG/wcJCoAIh4iACYmKgAqLAQEAgAIYAYED7wIEBvsDggXaBIOE2wUHCP8GhYbNBwkKgAiHiIAJiYqACosByQCAAjMBgQPbAgQG/wOCBcQEg4S6BQcIgAaFhoAHCQqACIeIgAmJioAKiwFFAIACLgGBA74CBAbvA4IFyQSDhNoFBwj/BoWG5AcJCoAIh4iACYmKgAqLAQEAgAK/AYED+wIEBv8DggX/BIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosB3wCAAqUBgQP5AgQG/wOCBdUEg4T/BQcIgAaFhoAHCQqACIeIgAmJioAKiwGNAIACfAGBA/gCBAb/A4IF/wSDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAQEAgAIQAYED+AIEBv8DggX/BIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosBvgCAAiQBgQPmAgQG/wOCBewEg4T/BQcIgAaFhoAHCQqACIeIgAmJioAKiwGVAIACAQGBA/8CBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAQEAgALiAYED/wIEBoADggWABIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosB9wCAAsABgQP/AgQGgAOCBYAEg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwHwAIACgAGBA/8CBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAQEAgAKGAYED/AIEBv8DggX/BIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosB1QCAAj4BgQP6AgQG/wOCBf8Eg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwE3AIACXQGBA/8CBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAYAAgAKAAYEDgAIEBoADggWABIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosBgACAAoABgQOAAgQGgAOCBYAEg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwGAAIACgAGBA4ACBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAqLAcoAgAIYAYED1QIEBusDggW6BIOEvwUHCNwGhYagBwkK8AiHiK8JiYr/CosBfgCAAiYBgQO2AgQG6AOCBakEg4S4BQcI5AaFhq4HCQr/CIeIuwmJioAKiwE9AIACLgGBA4oCBAbbA4IFlwSDhLIFBwjwBoWGqgcJCv8Ih4jYCYmKgAqLAQEAgAJwAYED5gIEBvoDggXHBIOEvwUHCPcGhYafBwkK/wiHiP8JiYqACosBpgCAAm0BgQPkAgQG/AOCBdMEg4TXBQcI/waFhq4HCQqACIeIgAmJioAKiwEnAIACTQGBA6ICBAboA4IFrASDhLQFBwj1BoWGsgcJCv8Ih4j/CYmKgAqLAQEAgAI0AYED3AIEBvYDggXGBIOExwUHCPkGhYbcBwkK/wiHiP8JiYqACosBfACAAkoBgQO/AgQG8wOCBbcEg4TBBQcI+gaFht0HCQr/CIeI/wmJioAKiwEYAIACRwGBA4ICBAbbA4IFmgSDhKoFBwjzBoWGtgcJCv8Ih4j/CYmKgAqLAQEAgAK2AYED4QIEBvkDggXbBIOE8AUHCP8GhYbgBwkKgAiHiIAJiYqACosBlQCAApYBgQPiAgQG/AOCBdgEg4TNBQcI/waFhqsHCQqACIeIgAmJioAKiwEcAIACbAGBA6oCBAbyA4IFtwSDhMIFBwj+BoWG3wcJCv8Ih4j/CYmKgAqLAQEAgAJRAYED5gIEBvwDggXMBIOEywUHCP8GhYbABwkKgAiHiIAJiYqACosBewCAAmYBgQPRAgQG9wOCBbwEg4TEBQcI/waFhukHCQqACIeIgAmJioAKiwEUAIACXwGBA5kCBAbzA4IFpASDhK0FBwj/BoWGywcJCoAIh4iACYmKgAqLAQEAgALeAYED+AIEBv8DggXYBIOE1QUHCIAGhYaABwkKgAiHiIAJiYqACosBqACAAq8BgQP2AgQG/AOCBesEg4TNBQcI/waFhv8HCQqACIeIgAmJioAKiwEvAIACdAGBA9cCBAb/A4IF0wSDhNQFBwj/BoWG/wcJCoAIh4iACYmKgAqLAQEAgAJ5AYED7AIEBv0DggXUBIOE1gUHCP8GhYb/BwkKgAiHiIAJiYqACosBjQCAAlQBgQPVAgQG/AOCBckEg4TKBQcI/waFhtsHCQqACIeIgAmJioAKiwEqAIACUAGBA6ACBAbwA4IFogSDhLkFBwj/BoWGzQcJCoAIh4iACYmKgAqLAQEAgAIBAYED/wIEBoADggWABIOEgAUHCIAGhYaABwkKgAiHiIAJiYqACosB9ACAAgEBgQP/AgQGgAOCBYAEg4SABQcIgAaFhoAHCQqACIeIgAmJioAKiwHuAIACAQGBA/8CBAaAA4IFgASDhIAFBwiABoWGgAcJCoAIh4iACYmKgAoBAv8AgIH/AYKD/wLrDhAAYwAAAHoCAAAgAAAA6w4QAGMAAAApAwAAJQAAAOsOEABjAAAAMAMAACYAAADrDhAAYwAAAEgDAAAmAAAA6w4QAGMAAABmAwAAIgAAAOsOEABjAAAAcAMAACwAAADrDhAAYwAAAI8DAAA1AAAA6w4QAGMAAACRAwAAJQAAAOsOEABjAAAAkQMAABMAAADrDhAAYwAAAIsDAABAAAAA6w4QAGMAAACLAwAAEQAAAOsOEABjAAAAWgMAAEQAAADrDhAAYwAAAFkDAAAjAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZQMAAAAAAAAA6w4QAGMAAACvAgAAIAAAAAIAAAAABwAAAAAAAOsOEABjAAAA3AIAAFQAAADrDhAAYwAAANwCAAAZAAAABgAAAAAAAADrDhAAYwAAAKUCAAA3AAAABQAAAAAJAAAAAAoAAAAAAOsOEABjAAAAAQIAAEcAAACGEhAAYwAAAO8AAAAiAAAAhhIQAGMAAADUAAAAIgAAAMsgEABkAAAAOwEAAB0AAADLIBAAZAAAADIBAAAYAAAAyyAQAGQAAAA1AQAAGQAAAHYGEABkAAAAxAIAABkAAAB2BhAAZAAAAIIAAAAdAAAAdgYQAGQAAACCAAAAUAAAAHYGEABkAAAAiAAAAB0AAAB2BhAAZAAAAJMAAAAhAAAAdgYQAGQAAACaAAAAPAAAAHYGEABkAAAAfAAAABUAAAB2BhAAZAAAANIAAAAiAEGg+8YAC/kGAQAAALQBAAB2BhAAZAAAADkAAAAKAAAAdgYQAGQAAAAgAQAANgAAAHYGEABkAAAA5gEAADkAAAB2BhAAZAAAAO4BAAAZAAAAdgYQAGQAAAD1AQAAOQAAAHYGEABkAAAAyQIAABkAAAB2BhAAZAAAAF0CAAAiAAAAdgYQAGQAAABkAgAALgAAAHYGEABkAAAAZAIAACEAAAB2BhAAZAAAAF0CAAAVAAAAdgYQAGQAAAA7AgAARAAAAHYGEABkAAAAPQIAADIAAAB2BhAAZAAAAD0CAAAdAAAAdgYQAGQAAAA7AgAALgAAAHYGEABkAAAASwIAADMAAAB2BhAAZAAAAEsCAAAdAAAAdgYQAGQAAABCAgAAHgAAAGFzc2VydGlvbiBmYWlsZWQ6IHN0ZXAgIT0gMABBARAAWQAAACMAAAAJAAAAdgYQAGQAAABQAgAANwAAAHYGEABkAAAAUAIAACoAAAB2BhAAZAAAAEYCAAAmAAAAdgYQAGQAAAAkAgAAEQAAAHYGEABkAAAAJQIAABEAAAB2BhAAZAAAACYCAAARAAAAdgYQAGQAAAAnAgAAEQAAAHYGEABkAAAACgIAADYAAAB2BhAAZAAAAAoCAAAhAAAAdgYQAGQAAACHAgAAQgAAABEAAAASAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAAEAAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAB2BhAAZAAAAIkBAAApAAAAiggQAFgAAADrBwAACQAAAHYGEABkAAAAVwEAAB0AAAAYAQABAAEAASgAAAEBAAEB/wEAAgIAAQL/AgIB/gECAv4CAAMDAAED/wMDAf0BAgP+AwMC/QIABAQAAQT/BAQB/AEDA/0DAgT+BAQC/AIABQME/QQEA/wDBQABBf8FBQH7AQIF/gUFAvsCBAT8BAMF/QUFA/sDAAYGAAEG/wYGAfoBAgb+BgYC+gIEBfwFBQT7BAMG/QYGA/oDAAcHAAEH/wcFBfsFBwH5AQQG/AYGBPoEAgf+BwcC+QIDB/0HBwP5AwUG+wYGBfoFCAAEB/wHBwT5BAgBCAIGBvoGCAMFB/sHBwX5BQgEBgf6BwcG+QYIBQcH+QcIBggHAAB2BhAAZAAAAJUCAAAmAAAAdgYQAGQAAADSAQAAIQBBpoLHAAupH/A/AAAAAAAAJEAAAAAAAABZQAAAAAAAQI9AAAAAAACIw0AAAAAAAGr4QAAAAACAhC5BAAAAANASY0EAAAAAhNeXQQAAAABlzc1BAAAAIF+gAkIAAADodkg3QgAAAKKUGm1CAABA5ZwwokIAAJAexLzWQgAANCb1awxDAIDgN3nDQUMAoNiFVzR2QwDITmdtwatDAD2RYORY4UNAjLV4Ha8VRFDv4tbkGktEktVNBs/wgET2SuHHAi21RLSd2XlDeOpEkQIoLCqLIEU1AzK39K1URQKE/uRx2YlFgRIfL+cnwEUh1+b64DH0ReqMoDlZPilGJLAIiO+NX0YXbgW1tbiTRpzJRiLjpshGA3zY6pvQ/kaCTcdyYUIzR+Mgec/5EmhHG2lXQ7gXnkexoRYq087SRx1KnPSHggdIpVzD8SljPUjnGRo3+l1ySGGg4MR49aZIecgY9tay3EhMfc9Zxu8RSZ5cQ/C3a0ZJxjNU7KUGfElcoLSzJ4SxSXPIoaAx5eVJjzrKCH5eG0qaZH7FDhtRSsD93XbSYYVKMH2VFEe6uko+bt1sbLTwSs7JFIiH4SRLQfwZaukZWkupPVDiMVCQSxNN5Fo+ZMRLV2Cd8U19+UttuARuodwvTETzwuTk6WNMFbDzHV7kmEwbnHCldR3PTJFhZodpcgNN9fk/6QNPOE1y+I/jxGJuTUf7OQ67/aJNGXrI0Sm9102fmDpGdKwNTmSf5KvIi0JOPcfd1roud04MOZWMafqsTqdD3feBHOJOkZTUdaKjFk+1uUkTi0xMTxEUDuzWr4FPFpkRp8wbtk9b/9XQv6LrT5m/heK3RSFQfy8n2yWXVVBf+/BR7/yKUBudNpMV3sBQYkQE+JoV9VB7VQW2AVsqUW1VwxHheGBRyCo0VhmXlFF6NcGr37zJUWzBWMsLFgBSx/Euvo4bNFI5rrptciJpUsdZKQkPa59SHdi5Zemi01IkTii/o4sIU61h8q6Mrj5TDH1X7Rctc1NPXK3oXfinU2Oz2GJ19t1THnDHXQm6ElQlTDm1i2hHVC6fh6KuQn1UfcOUJa1JslRc9PluGNzmVHNxuIoekxxV6EazFvPbUVWiGGDc71KGVcoeeNOr57tVPxMrZMtw8VUO2DU9/swlVhJOg8w9QFtWyxDSnyYIkVb+lMZHMErFVj06uFm8nPpWZiQTuPWhMFeA7Rcmc8pkV+Done8P/ZlXjLHC9Sk+0FfvXTNztE0EWGs1AJAhYTlYxUIA9Gm5b1i7KYA44tOjWCo0oMbayNhYNUFIeBH7DlnBKC3r6lxDWfFy+KUlNHhZrY92Dy9BrlnMGappvejiWT+gFMTsohdaT8gZ9aeLTVoyHTD5SHeCWn4kfDcbFbdani1bBWLa7FqC/FhDfQgiW6M7L5ScilZbjAo7uUMtjFuX5sRTSpzBWz0gtuhcA/ZbTajjIjSEK1wwSc6VoDJhXHzbQbtIf5VcW1IS6hrfylx5c0vScMsAXVdQ3gZN/jRdbeSVSOA9al3Erl0trGagXXUatThXgNRdEmHiBm2gCV6rfE0kRARAXtbbYC1VBXRezBK5eKoGqV5/V+cWVUjfXq+WUC41jRNfW7zkeYJwSF9y610Yo4x+XyezOu/lF7Nf8V8Ja9/d51/tt8tFV9UdYPRSn4tWpVJgsSeHLqxOh2Cd8Sg6VyK9YAKXWYR2NfJgw/xvJdTCJmH0+8suiXNcYXh9P701yJFh1lyPLEM6xmEMNLP308j7YYcA0HqEXTFiqQCEmeW0ZWLUAOX/HiKbYoQg719T9dBipejqN6gyBWPPouVFUn86Y8GFr2uTj3BjMmebRnizpGP+QEJYVuDZY59oKfc1LBBkxsLzdEM3RGR4szBSFEV5ZFbgvGZZlq9kNgw24Pe942RDj0PYda0YZRRzVE7T2E5l7Mf0EIRHg2Xo+TEVZRm4ZWF4flq+H+5lPQuP+NbTImYMzrK2zIhXZo+BX+T/ao1m+bC77t9iwmY4nWrql/v2ZoZEBeV9uixn1Eojr470YWeJHexasnGWZ+skp/EeDsxnE3cIV9OIAWjXlMosCOs1aA06/TfKZWtoSET+Yp4foWha1b37hWfVaLFKrXpnwQppr06srOC4QGlaYtfXGOd0afE6zQ3fIKpp1kSgaItU4GkMVshCrmkUao9retMZhElqcwZZSCDlf2oIpDctNO+zagqNhTgB6+hqTPCmhsElH2swVij0mHdTa7trMjF/VYhrqgZ//d5qvmsqZG9eywLzazU9CzZ+wydsggyOw120XWzRxziaupCSbMb5xkDpNMdsN7j4kCMC/Wwjc5s6ViEybetPQsmrqWZt5uOSuxZUnG1wzjs1jrTRbQzCisKxIQZuj3ItMx6qO26ZZ/zfUkpxbn+B+5fnnKVu32H6fSEE224sfbzulOIQb3acayo6G0VvlIMGtQhiem89EiRxRX2wb8wWbc2WnORvf1zIgLzDGXDPOX3QVRpQcEOInETrIIRwVKrDFSYpuXDplDSbb3PvcBHdAMElqCNxVhRBMS+SWHFrWZH9uraOcePXet40MsNx3I0ZFsL+93FT8Z+bcv4tctT2Q6EHv2JyifSUiclul3KrMfrre0rNcgtffHONTgJzzXZb0DDiNnOBVHIEvZpsc9B0xyK24KFzBFJ5q+NY1nOGpleWHO8LdBTI9t1xdUF0GHp0Vc7SdXSemNHqgUerdGP/wjKxDOF0PL9zf91PFXULr1Df1KNKdWdtkgtlpoB1wAh3Tv7PtHXxyhTi/QPqddb+TK1+QiB2jD6gWB5TVHYvTsju5WeJdrthemrfwb92FX2MoivZ83ZanC+Lds8od3CD+y1UA193JjK9nBRik3ewfuzDmTrId1ye5zRASf53+cIQIcjtMni481QpOqlneKUwqrOIk514Z15KcDV80ngB9lzMQhsHeYIzdH8T4jx5MaCoL0wNcnk9yJI7n5CmeU16dwrHNNx5cKyKZvygEXqMVy2AOwlGem+tOGCKi3t6ZWwjfDY3sXp/RywbBIXlel5Z9yFF5hp725c6NevPUHvSPYkC5gOFe0aNK4PfRLp7TDj7sQtr8HtfBnqezoUkfPaHGEZCp1l8+lTPa4kIkHw4KsPGqwrEfMf0c7hWDfl8+PGQZqxQL307lxrAa5JjfQo9IbAGd5h9TIwpXMiUzn2w95k5/RwDfpx1AIg85Dd+A5MAqkvdbX7iW0BKT6qiftpy0BzjVNd+kI8E5BsqDX+62YJuUTpCfymQI8rlyHZ/M3SsPB97rH+gyOuF88zhf2wgEABeAAAANAAAAAUAAABjYXBhY2l0eSBvdmVyZmxvd3N0cnVjdCBSYWRNZXRhY29tbWVudHN0cnVjdCBNZWFuc3N0cnVjdCBRdWF0c3N0cnVjdCBTaDBWMXN0cnVjdCBTaDBWMnN0cnVjdCBTaE5WMXN0cnVjdCBTaE5WMnN0cnVjdCBNZWFuc1Yxc3RydWN0IFBjU29nc1Yxc3RydWN0IFBjU29nc1Yyc3RydWN0IFNjYWxlc1Yxc3RydWN0IFNjYWxlc1Yyc3RydWN0IFJhZENodW5rTWV0YWZpZWxkIGlkZW50aWZpZXJ2YXJpYW50IGlkZW50aWZpZXJzdHJ1Y3QgUmFkQ2h1bmtSYW5nZXN0cnVjdCBSYWRDaHVua1Byb3BlcnR5c3RydWN0IFNwbGF0RW5jb2RpbmdzdHJ1Y3QgU2V0U3BsYXRFbmNvZGluZwBhDRAAagAAAFMAAAARAAAAlhwQAGEAAACQAQAAHQAAAJYcEABhAAAA3AEAABIAAACWHBAAYQAAANIBAAA8AAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5zdWJmcmFtZS5jdXJyZW50X2ludGVybGFjZV9pbmZvLmlzX25vbmUoKZYcEABhAAAA9gEAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLnJlbWFpbmluZ19mcmFtZXMgPiAwAJYcEABhAAAA6wEAAAkAAACWHBAAYQAAAJMCAAAyAAAAlhwQAGEAAAAYAgAALwAAAGFzc2VydGlvbiBmYWlsZWQ6IHNlbGYudW5maWx0ZXJpbmdfYnVmZmVyLnJlbWFpbmluZ19ieXRlcygpID4gMACWHBAAYQAAAMUCAAANAAAAlhwQAGEAAABkAgAACQAAAJYcEABhAAAAPQIAAC8AAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmZpbGxlZCA+PSBvbGRfZmlsbGVkAIkMEABwAAAAywAAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBuIDw9IHNlbGYuYnVmLmluaXQgLSBzZWxmLmJ1Zi5maWxsZWQAACsWEABTAAAAFQEAAAkAAABZHRAASQAAALIBAAAxAAAAZmFpbGVkIHRvIHdyaXRlIHdob2xlIGJ1ZmZlcgzOEQAcAAAAFwAAAAAAAAACAAAAKM4RAL8aEABTAAAA1wAAABQAAAAMFRAAUQAAABMBAAA0AAAAQ29tcHJlc3Npb24gbWV0aG9kIG5vdCBzdXBwb3J0ZWRaaXBGaWxlUmVhZGVyIHdhcyBpbiBhbiBpbnZhbGlkIHN0YXRlAAAAlQEAAAwAAAAEAAAArgAAAJUBAAAMAAAABAAAAK8AAACuAAAAqM4RALAAAACxAAAAsgAAALAAAACzAAAAUGFzc3dvcmQgcmVxdWlyZWQgdG8gZGVjcnlwdCBmaWxlemlwOjp0eXBlczo6WmlwTG9jYWxFbnRyeUJsb2NrVW5leHBlY3RlZCBlbmQgb2YgAAAAI88RABIAAABJbnZhbGlkIGxvY2FsIGZpbGUgaGVhZGVyAAAAAAAAgEDPEQAZAAAA9hAQAE8AAADlBQAAFAAAAPYQEABPAAAA5QUAACEAAAD2EBAATwAAANkFAAAhAAAAZGVzY3JpcHRpb24oKSBpcyBkZXByZWNhdGVkOyB1c2UgRGlzcGxheWEl5dUQCLJyJqVB5lNOYLu3YMlDFkWcWdPLt2N5tvGTnpTtkF4d92SECtac2/hP6ZKrCBCWsMR1lA4ArKHBYAvultNCS+lyfu61WbhEXZQN99TULQ/NKvuW3EhrJx6oJ5vAhnDA2TRZiJNz7ns6ComwWwWDRyX9uCwPDcu76FvOgSCGdqPjOHuPGk7mBcFPRW6AeG5vqeWBl2M43tLhuPy4q2M1b+Kp5RZJwg3YjwC9DMeBlfRG5Tdfwe0RkUxjSWHeUmBVehZdDw0+xzKJpb4P8jsUtxWblZwAKdrJrQkbY2h1bmsgc2l6ZSBtdXN0IGJlIG5vbi16ZXJvAKDQEQAbAAAAAgICAgICAgICAgIAQeyhxwALCAICAAAAAAACAEGjoscACwECAEHJoscACwEBAEHkoscACwEBAEHEo8cAC61VSW9JbnZhbGlkQXJjaGl2ZVVuc3VwcG9ydGVkQXJjaGl2ZUZpbGVOb3RGb3VuZEludmFsaWRQYXNzd29yZAAAABUfEABMAAAAFAsAACQAAACGGBAAbQAAACIBAABHAAAA/wAAANMBAABwAgAACAAAANQBAADVAQAA1gEAANcBAADYAQAA2QEAANoBAADbAQAA3AEAAN0BAADeAQAA3wEAAKAAAAAIAAAA4AEAAOEBAADiAQAA4wEAAOQBAADlAQAA5gEAAOcBAADoAQAA6QEAAOoBAAC7AAAACAAAAAQAAAAWAAAAuwAAAAgAAAAEAAAAvAAAABYAAACY0hEAvQAAAL4AAACyAAAAvwAAALMAAABEZWNvZGluZ0VuY29kaW5nUGFyYW1ldGVyTGltaXRzSW9FcnJvcgAAAAAAAAQAAAAEAAAA6wEAAExpbWl0RXJyb3IAAAAAAAAIAAAABAAAAOwBAAAAAAAABAAAAAQAAADtAQAAbWF4X2ltYWdlX3dpZHRobWF4X2ltYWdlX2hlaWdodG1heF9hbGxvY0dzcGxhdChjZW50ZXI6ICwgb3BhY2l0eTogLCByZ2I6ICwgc2NhbGVzOiAsIHF1YXRlcm5pb246IAAAAGDTEQAPAAAAb9MRAAsAAAB60xEABwAAAIHTEQAKAAAAi9MRAA4AAABeBxIAAQAAAAAAAAAEAAAABAAAAMAAAAAAAAAABAAAAAQAAADBAAAATGF5b3V0c2l6ZWFsaWduAO4BAAAQAAAABAAAAO8BAAAAAAAABAAAAAQAAADwAQAARGVjb2RpbmdFcnJvcmZvcm1hdHVuZGVybHlpbmdFbmNvZGluZ0Vycm9yAAAAAAAAAQAAAAEAAADxAQAAAAAAAAEAAAABAAAA8gEAAAAAAAABAAAAAQAAAPMBAAAAAAAABAAAAAQAAACqAQAAQ2ljcHByaW1hcmllc3RyYW5zZmVybWF0cml4ZnVsbF9yYW5nZURpbWVuc2lvbkVycm9ySW5zdWZmaWNpZW50TWVtb3J5AAAAAAAAACAAAAAIAAAA9AEAAAAAAAAEAAAABAAAAPUBAABsaW1pdHNzdXBwb3J0ZWQA9gEAAAwAAAAEAAAA9wEAAFBhcmFtZXRlckVycm9yQ2FwYWNpdHlPdmVyZmxvdwAAAAAAAAQAAAAEAAAA+AEAAEFsbG9jRXJybGF5b3V0Q3NwbGF0KGNlbnRlcjogAAAATtURAA8AAABv0xEACwAAAHrTEQAHAAAAgdMRAAoAAACL0xEADgAAAF4HEgABAAAARXhhY3ROYW1lUGF0aEV4dGVuc2lvblVua25vd25pbnZhbGlkIHNlZWsgdG8gYSBuZWdhdGl2ZSBvciBvdmVyZmxvd2luZyBwb3NpdGlvbgCt1REAMgAAABQAAACmJhAAWgAAAD0AAAAkAAAARW1wdHlJbnZhbGlkRGlnaXRQb3NPdmVyZmxvd05lZ092ZXJmbG93WmVybwAAAAAABAAAAAQAAAD5AQAAVW5zdXBwb3J0ZWRFcnJvclBuZ0pwZWdHaWZXZWJQUG5tVGlmZlRnYURkc0JtcEljb0hkck9wZW5FeHJGYXJiZmVsZEF2aWZRb2lQY3gAAAAAAAAABAAAAAQAAAD6AQAAUGFyc2VJbnRFcnJvckE4TDFMYTFSZ2IxUmdiYTFMMkxhMlJnYjJSZ2JhMkw0TGE0UmdiNFJnYmE0UmdiNXgxTDhMYThSZ2I4UmdiYThMMTZMYTE2UmdiMTZSZ2JhMTZCZ3I4QmdyYThSZ2IzMkZSZ2JhMzJGQ215azhDbXlrMTZMaW1pdFN1cHBvcnREaW1lbnNpb25NaXNtYXRjaEZhaWxlZEFscmVhZHkAAAAAAAAEAAAABAAAAPsBAABSZ2JDaWNwUmVxdWlyZWRHZW5lcmljTm9Nb3JlRGF0YQAAAAAEAAAAAQAAAPwBAABDaWNwTWlzbWF0Y2hleHBlY3RlZGZvdW5kAAAAAAAAAAgAAAAEAAAAxwAAAAAAAAAIAAAABAAAAHAAAADHAAAAoNcRALAAAADIAAAAsgAAALAAAACzAAAA/QEAACgAAAAIAAAA/gEAAP0BAAAoAAAACAAAAP8BAAD+AQAA3NcRAAACAAABAgAAAgIAAAMCAAAEAgAAAAAAAAEAAAABAAAABQIAAAAAAAABAAAAAQAAAAYCAAAFAgAAGNgRAAcCAAAIAgAACQIAAAcCAAAKAgAAlQEAAAwAAAAEAAAACwIAAJUBAAAMAAAABAAAANAAAAALAgAAVNgRALAAAADRAAAAsgAAALAAAACzAAAADAIAABgAAAAEAAAADQIAAAwCAAAYAAAABAAAAA4CAAANAgAAkNgRAA8CAAAQAgAAsgAAAA8CAACzAAAAEQIAACgAAAAEAAAA4wAAABECAAAoAAAABAAAAOQAAADjAAAAzNgRAOUAAADtAAAA5wAAAOgAAADpAAAA8AAAACQAAAAEAAAA4wAAAPAAAAAkAAAABAAAAOQAAADjAAAACNkRAOUAAADxAAAA5wAAAOgAAADpAAAAEgIAAEgAAAAIAAAAEwIAABICAABIAAAACAAAABQCAAATAgAARNkRABUCAAAWAgAAFwIAABgCAAAZAgAAGgIAADQAAAAEAAAA4wAAABoCAAA0AAAABAAAAOQAAADjAAAAgNkRAOUAAAAbAgAA5wAAAOgAAADpAAAAHAIAACAAAAAEAAAA4wAAABwCAAAgAAAABAAAAOQAAADjAAAAvNkRAOUAAAAdAgAA5wAAAOgAAADpAAAA7gAAACQAAAAEAAAA4wAAAO4AAAAkAAAABAAAAOQAAADjAAAA+NkRAOUAAADvAAAA5wAAAOgAAADpAAAAHgIAAB8CAAAgAgAAIQIAACICAAAIAQAA/QAAACMCAAAkAgAAJQIAACYCAAAnAgAAKAIAAP0AAAD+AAAAKQIAACoCAAArAgAAAgEAAPwAAAD9AAAA9wAAACwCAAAtAgAALgIAABcBAAD8AAAA/QAAAC8CAAAwAgAAMQIAADICAAATAQAADgEAAP0AAAAzAgAANAIAADUCAAA2AgAANwIAADgCAAD9AAAAAAAAAAQAAAAEAAAAOQIAAGNvbnRleHQAOgIAAAwAAAAEAAAAywAAAHNvdXJjZQAAOgIAAAwAAAAEAAAAygAAADoCAAAMAAAABAAAAMsAAADKAAAADNsRADsCAADNAAAAsgAAADwCAACzAAAAY29ycnVwdCBkZWZsYXRlIHN0cmVhbUZhaWxlZENhbm5vdE1ha2VQcm9ncmVzc0JhZFBhcmFtQWRsZXIzMk1pc21hdGNoRmFpbGVkRG9uZU5lZWRzTW9yZUlucHV0SGFzTW9yZU91dHB1dENvbG9yQ29sb3JMYXlvdXRDb2xvcnNwYWNlQ2ljcEZvcm1hdEdlbmVyaWNGZWF0dXJlAAAAAAQAAAAEAAAAKAEAACkBAAA9AgAAU1JnYlVuc3BlY2lmaWVkUmdiTVJnYkJCdDYwMVJnYjI0MG1HZW5lcmljRmlsbVJnYjIwMjBYeXpTbXB0ZVJwNDMxU21wdGVScDQzMkluZHVzdHJ5MjIAAPYQEABPAAAAaQQAACQAAAD2EBAATwAAAM4BAAA3AAAAYXNzZXJ0aW9uIGZhaWxlZDogc2NhbGVzLnguaXNfZmluaXRlKCkgJiYgc2NhbGVzLnkuaXNfZmluaXRlKCkgJiYgc2NhbGVzLnouaXNfZmluaXRlKCkAALIFEAAXAAAA8AAAAAkAAACyBRAAFwAAAPcAAAAVAAAAsgUQABcAAAD4AAAAFwAAALIFEAAXAAAABQEAABYAAACyBRAAFwAAABIBAAAWAAAAsgUQABcAAAAfAQAAFgAAALIFEAAXAAAAGAEAACUAAACyBRAAFwAAABkBAAAkAAAAsgUQABcAAAALAQAAJQAAALIFEAAXAAAADAEAACQAAACyBRAAFwAAAP0AAAAlAAAAsgUQABcAAAD+AAAAJAAAALIFEAAXAAAA4gAAACEAAACyBRAAFwAAANgAAAAhAAAAsgUQABcAAAAqAQAAFgAAALIFEAAXAAAAJgEAABYAAACyBRAAFwAAAC4BAAAXAAAAsgUQABcAAAC6AAAAKAAAALIFEAAXAAAAvgAAAC8AAACyBRAAFwAAADYBAAARAAAAsgUQABcAAAA6AQAAEQAAALIFEAAXAAAAPgEAABEAAACyBRAAFwAAAH4BAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDogdG90YWxfY292Lnh4KCkuaXNfZmluaXRlKCkgJiYgdG90YWxfY292Lnl5KCkuaXNfZmluaXRlKCkgJiYKICAgIHRvdGFsX2Nvdi56eigpLmlzX2Zpbml0ZSgpdAUQABcAAABjAQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IHRvdGFsX2Nvdi54eSgpLmlzX2Zpbml0ZSgpICYmIHRvdGFsX2Nvdi54eigpLmlzX2Zpbml0ZSgpICYmCiAgICB0b3RhbF9jb3YueXooKS5pc19maW5pdGUoKXQFEAAXAAAAZAEAAAkAAAB0BRAAFwAAAGgBAAAJAAAAdAUQABcAAACXAQAAFQAAAHQFEAAXAAAAmAEAABcAAAB0BRAAFwAAAKQBAAAWAAAAdAUQABcAAACxAQAAFgAAAHQFEAAXAAAAvgEAABYAAAB0BRAAFwAAALcBAAAlAAAAdAUQABcAAAC4AQAAJAAAAHQFEAAXAAAAqgEAACUAAAB0BRAAFwAAAKsBAAAkAAAAdAUQABcAAACdAQAAJQAAAHQFEAAXAAAAngEAACQAAAB0BRAAFwAAAEsBAAAlAAAAdAUQABcAAABMAQAAIQAAAHQFEAAXAAAAQgEAACEAAAB0BRAAFwAAAMkBAAAWAAAAdAUQABcAAADFAQAAFgAAAHQFEAAXAAAAzQEAABcAAAB0BRAAFwAAABQBAAAVAAAAdAUQABcAAAAYAQAAGQAAAHQFEAAXAAAA1gEAABEAAAB0BRAAFwAAANoBAAARAAAAdAUQABcAAADeAQAAEQAAAHQFEAAXAAAAGgIAAAkAAABJZGVudGl0eUJ0NzA5VXNGQ0NCdDQ3MEJHU21wdGUxNzBtU21wdGUyNDBtWUNnQ29CdDIwMjBOb25Db25zdGFudEJ0MjAyMENvbnN0YW50U21wdGUyMDg1Q2hyb21hdGljaXR5RGVyaXZlZE5vbkNvbnN0YW50Q2hyb21hdGljaXR5RGVyaXZlZENvbnN0YW50QnQyMTAwSXB0UHFDMllDZ0NvUmVZQ2dDb1JvTmFycm93UmFuZ2VGdWxsUmFuZ2WyBRAAFwAAABUCAABIAAAAsgUQABcAAAAbAgAAMAAAALIFEAAXAAAAcQIAADEAAACyBRAAFwAAAHMCAAAxAAAAsgUQABcAAAB9AgAAIwAAALIFEAAXAAAAfwIAAB4AAACyBRAAFwAAAIECAAAqAAAAsgUQABcAAAAiAgAAQgAAALIFEAAXAAAATwIAAC4AAACyBRAAFwAAAE8CAAAdAAAAsgUQABcAAABcAgAALgAAALIFEAAXAAAAXAIAAB0AAACyBRAAFwAAAGkCAAAuAAAAsgUQABcAAABpAgAAHQAAALIFEAAXAAAAOAIAAEkAAACyBRAAFwAAAAQCAAAfAAAAsgUQABcAAAAGAgAAPAAAALIFEAAXAAAABwIAAD4AAACyBRAAFwAAAAUCAAA3AAAAsgUQABcAAAADAgAAPQAAALIFEAAXAAAAMQIAAEcAAAB0BRAAFwAAABwDAABIAAAAdAUQABcAAAAiAwAAMAAAAHQFEAAXAAAAbQMAADEAAAB0BRAAFwAAAG8DAAAxAAAAdAUQABcAAAB5AwAAIwAAAHQFEAAXAAAAewMAAB4AAAB0BRAAFwAAAH0DAAAqAAAAdAUQABcAAAApAwAAQgAAAHQFEAAXAAAAVAMAABkAAAB0BRAAFwAAAFQDAAA3AAAAdAUQABcAAABdAwAAGQAAAHQFEAAXAAAAXQMAADcAAAB0BRAAFwAAAGYDAAAZAAAAdAUQABcAAABmAwAANwAAAHQFEAAXAAAAQAMAAEkAAABjZW50ZXIgYXJyYXkgdG9vIHNtYWxsOiAgPCAAtOMRABgAAADM4xEAAwAAAHQFEAAXAAAAAAMAAAkAAABvcGFjaXR5IGFycmF5IHRvbyBzbWFsbDogAAAA8OMRABkAAADM4xEAAwAAAHQFEAAXAAAAAQMAAAkAAAByZ2IgYXJyYXkgdG9vIHNtYWxsOiAAAAAs5BEAFQAAAMzjEQADAAAAdAUQABcAAAACAwAACQAAAHNjYWxlIGFycmF5IHRvbyBzbWFsbDogAGTkEQAXAAAAzOMRAAMAAAB0BRAAFwAAAAMDAAAJAAAAcXVhdCBhcnJheSB0b28gc21hbGw6IAAAnOQRABYAAADM4xEAAwAAAHQFEAAXAAAABAMAAAkAAABiYXNlICsgY291bnQgb3V0IG9mIGJvdW5kczogICsgID4gAADU5BEAHAAAAPDkEQADAAAA8+QRAAMAAAB0BRAAFwAAAAUDAAAJAAAAdAUQABcAAAALAwAAHwAAAHQFEAAXAAAADgMAAD4AAAB0BRAAFwAAAA0DAAA8AAAAdAUQABcAAAAMAwAANwAAAHQFEAAXAAAACgMAAD0AAAB0BRAAFwAAADkDAABHAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogaW52YWxpZCBPbmNlIHN0YXRlgOURADwAAAAVCBAAWwAAADUAAAASAAAAQnQ0NzBNTGluZWFyTG9nMTAwTG9nU3FydEllYzYxOTY2XzJfNEJ0MTM2MUJ0MjAyMF8xMGJpdEJ0MjAyMF8xMmJpdFNtcHRlMjA4NFNtcHRlNDI4QnQyMTAwSGxnAAAAAAAAAAgAAAAEAAAAPgIAAIokEABeAAAAVgEAAC4AAACKJBAAXgAAAEUBAAA2AAAAiiQQAF4AAADSBAAADgAAAGFzc2VydGlvbiBmYWlsZWQ6IG5ld19jYXAgPj0gbGVuiiQQAF4AAACdBAAADQAAAF4VEABjAAAA8gAAAAkAAABeFRAAYwAAAP8AAAASAAAAWE1MOmNvbS5hZG9iZS54bXBSYXcgcHJvZmlsZSB0eXBlIGlwdGNSYXcgcHJvZmlsZSB0eXBlIDhiaW0AZgsQAE4AAACDBwAAEQAAANwZEAAdAAAATwEAAAkAAADcGRAAHQAAAFABAAAJAAAA3BkQAB0AAABOAQAALwAAANwZEAAdAAAAbwEAAAkAAADcGRAAHQAAAHABAAAJAAAA3BkQAB0AAABxAQAACQAAANwZEAAdAAAAcgEAAAkAAADcGRAAHQAAAG4BAAAvAAAA3BkQAB0AAACMAQAACQAAANwZEAAdAAAAjQEAAAkAAADcGRAAHQAAAI4BAAAJAAAA3BkQAB0AAACPAQAACQAAANwZEAAdAAAAiwEAAC8AAADcGRAAHQAAAJ4BAAANAAAA3BkQAB0AAADYAQAAFQAAAGZfcmVzdF8AAOgRAAcAAABwbHlJbnZhbGlkIFBMWSBoZWFkZXIAAAAT6BEAEgAAAP0AEAAUAAAAdgEAABUAAABiaW5hcnlfbGl0dGxlX2VuZGlhbjEuMFVuc3VwcG9ydGVkIFBMWSB2ZXJzaW9uOiBX6BEAGQAAAFVuc3VwcG9ydGVkIFBMWSBmb3JtYXQ6IHjoEQAYAAAAZWxlbWVudAD9ABAAFAAAAIUBAAAeAAAAcHJvcGVydHlQTFkgbGlzdCBwcm9wZXJ0aWVzIGFyZSBub3Qgc3VwcG9ydGVkAAAAuOgRACUAAABQcm9wZXJ0eSBvdXRzaWRlIG9mIGVsZW1lbnQA6OgRABsAAABJbnZhbGlkIHByb3BlcnR5IGxpbmU6IAAM6REAFwAAAGVuZF9oZWFkZXIAAP0AEAAUAAAAngEAABIAAABNaXNzaW5nIFBMWSBmb3JtYXQgbGluZQBI6REAFwAAAHZlcnRleE1pc3NpbmcgdmVydGV4IGVsZW1lbnRu6REAFgAAAGNodW5rVW5zdXBwb3J0ZWQgUExZIGhlYWRlciBsaW5lOiAAAJHpEQAdAAAAeE1pc3NpbmcgeCBwcm9wZXJ0eQC56REAEgAAAHlNaXNzaW5nIHkgcHJvcGVydHkA1ekRABIAAAB6TWlzc2luZyB6IHByb3BlcnR5APHpEQASAAAAc2NhbGVfME1pc3Npbmcgc2NhbGVfMCBwcm9wZXJ0eQAT6hEAGAAAAHNjYWxlXzFNaXNzaW5nIHNjYWxlXzEgcHJvcGVydHkAO+oRABgAAABzY2FsZV8yTWlzc2luZyBzY2FsZV8yIHByb3BlcnR5AGPqEQAYAAAAcm90XzFNaXNzaW5nIHJvdF8wIHByb3BlcnR5AInqEQAWAAAAcm90XzJNaXNzaW5nIHJvdF8xIHByb3BlcnR5AK3qEQAWAAAAcm90XzNNaXNzaW5nIHJvdF8yIHByb3BlcnR5ANHqEQAWAAAAcm90XzBNaXNzaW5nIHJvdF8zIHByb3BlcnR5APXqEQAWAAAAb3BhY2l0eU1pc3Npbmcgb3BhY2l0eSBwcm9wZXJ0eQAb6xEAGAAAAGZfZGNfME1pc3NpbmcgZl9kY18wIHByb3BlcnR5AAAAQusRABcAAABmX2RjXzFNaXNzaW5nIGZfZGNfMSBwcm9wZXJ0eQAAAGrrEQAXAAAAZl9kY18yTWlzc2luZyBmX2RjXzIgcHJvcGVydHkAAACS6xEAFwAAAEludmFsaWQgbnVtYmVyIG9mIGZfcmVzdCBwcm9wZXJ0aWVzOiAAAAC06xEAJQAAAP0AEAAUAAAAggMAACgAAAD9ABAAFAAAAHADAAAoAAAA/QAQABQAAAB5AwAAKAAAAP0AEAAUAAAA/QMAACYAAAD9ABAAFAAAAP4DAAAnAAAA/QAQABQAAAAABAAAKgAAAP0AEAAUAAAABAQAACoAAAD9ABAAFAAAAAgEAAAqAAAA/QAQABQAAAAMBAAAKgAAAP0AEAAUAAAA9gMAACoAAAD9ABAAFAAAAPoDAAAqAAAA/QAQABQAAADeAwAAJgAAAP0AEAAUAAAA3wMAACcAAAD9ABAAFAAAAOEDAAAqAAAA/QAQABQAAADlAwAAKgAAAP0AEAAUAAAA6QMAACoAAAD9ABAAFAAAAO0DAAAqAAAA/QAQABQAAADXAwAAKQAAAP0AEAAUAAAA2wMAACkAAAD9ABAAFAAAACYEAAAmAAAA/QAQABQAAAAlBAAAJwAAAP0AEAAUAAAAIgQAACoAAAD9ABAAFAAAAB4EAAAqAAAA/QAQABQAAAAVBAAAKgAAAP0AEAAUAAAAKAQAACoAAAD9ABAAFAAAALcCAAAZAAAA/QAQABQAAADkAgAAHAAAAP0AEAAUAAAA5QIAABwAAAD9ABAAFAAAAOYCAAAcAAAA/QAQABQAAADnAgAAGwAAAP0AEAAUAAAA6AIAABsAAAD9ABAAFAAAAOkCAAAbAAAA/QAQABQAAADqAgAAGQAAAP0AEAAUAAAA6wIAABkAAAD9ABAAFAAAAOwCAAAZAAAA/QAQABQAAADtAgAAHQAAAP0AEAAUAAAA7gIAABoAAAD9ABAAFAAAAO8CAAAaAAAA/QAQABQAAADwAgAAGgAAAP0AEAAUAAAA8QIAABoAAABNaXNzaW5nIFBMWSBjaHVuayBmb3Igc3BsYXQgZO4RABwAAABNaXNzaW5nIGNodW5rIGVsZW1lbnQgZm9yIFN1cGVyU3BsYXQgUExZiO4RACgAAABtaW5feE1pc3NpbmcgbWluX3ggcHJvcGVydHkAve4RABYAAABtaW5feU1pc3NpbmcgbWluX3kgcHJvcGVydHkA4e4RABYAAABtaW5fek1pc3NpbmcgbWluX3ogcHJvcGVydHkABe8RABYAAABtYXhfeE1pc3NpbmcgbWF4X3ggcHJvcGVydHkAKe8RABYAAABtYXhfeU1pc3NpbmcgbWF4X3kgcHJvcGVydHkATe8RABYAAABtYXhfek1pc3NpbmcgbWF4X3ogcHJvcGVydHkAce8RABYAAABtaW5fc2NhbGVfeE1pc3NpbmcgbWluX3NjYWxlX3ggcHJvcGVydHkAm+8RABwAAABtaW5fc2NhbGVfeU1pc3NpbmcgbWluX3NjYWxlX3kgcHJvcGVydHkAy+8RABwAAABtaW5fc2NhbGVfek1pc3NpbmcgbWluX3NjYWxlX3ogcHJvcGVydHkA++8RABwAAABtYXhfc2NhbGVfeE1pc3NpbmcgbWF4X3NjYWxlX3ggcHJvcGVydHkAK/ARABwAAABtYXhfc2NhbGVfeU1pc3NpbmcgbWF4X3NjYWxlX3kgcHJvcGVydHkAW/ARABwAAABtYXhfc2NhbGVfek1pc3NpbmcgbWF4X3NjYWxlX3ogcHJvcGVydHkAi/ARABwAAABtaW5fcm1pbl9nbWluX2JtYXhfcm1heF9nbWF4X2JwYWNrZWRfcG9zaXRpb25NaXNzaW5nIHBhY2tlZF9wb3NpdGlvbiBwcm9wZXJ0eQAAAN3wEQAgAAAAcGFja2VkX3JvdGF0aW9uTWlzc2luZyBwYWNrZWRfcm90YXRpb24gcHJvcGVydHkAF/ERACAAAABwYWNrZWRfc2NhbGVNaXNzaW5nIHBhY2tlZF9zY2FsZSBwcm9wZXJ0eQAAAEzxEQAdAAAAcGFja2VkX2NvbG9yTWlzc2luZyBwYWNrZWRfY29sb3IgcHJvcGVydHkAAACA8REAHQAAAP0AEAAUAAAAPgIAADAAAAD9ABAAFAAAAEICAAAfAAAAU0ggZWxlbWVudCBjb3VudCAoKSBtdXN0IG1hdGNoIHZlcnRleCBjb3VudCAoAAAAyPERABIAAADa8REAGwAAAF4HEgABAAAATm90IGVub3VnaCBjaHVuayByZWNvcmRzOiBoYXZlICwgbmVlZCBhdCBsZWFzdCAAEPIRAB8AAAAv8hEAEAAAAP0AEAAUAAAAFgMAAD0AAAD9ABAAFAAAABYDAAAhAAAA/QAQABQAAAAQAwAAPQAAAP0AEAAUAAAAEAMAACEAAAD9ABAAFAAAAAoDAAA9AAAA/QAQABQAAAAKAwAAIQAAAP0AEAAUAAAABAMAAB8AAAD9ABAAFAAAAD8BAAAZAAAAY2hhcnVjaGFyc2hvcnR1c2hvcnRpbnRmbG9hdGRvdWJsZVVuc3VwcG9ydGVkIFBMWSBwcm9wZXJ0eSB0eXBlOiAAAADy8hEAHwAAAFYhEAAUAAAA4QMAABYAAABWIRAAFAAAAOUDAAAUAAAAViEQABQAAADlAwAAMAAAAFYhEAAUAAAAyQMAABYAAABWIRAAFAAAAM0DAAAUAAAAViEQABQAAADNAwAAMAAAAFYhEAAUAAAA6gQAABYAAABWIRAAFAAAAO4EAAAtAAAAViEQABQAAADuBAAAOgAAAFYhEAAUAAAA7gQAABQAAABWIRAAFAAAAA8FAAAWAAAAViEQABQAAAATBQAALQAAAFYhEAAUAAAAEwUAADoAAABWIRAAFAAAABMFAABLAAAAViEQABQAAAATBQAAXAAAAFYhEAAUAAAAEwUAABQAAABWIRAAFAAAAKgEAAAWAAAAViEQABQAAACsBAAAJwAAAFYhEAAUAAAArAQAABQAAABWIRAAFAAAAMAEAAAWAAAAViEQABQAAADEBAAALQAAAFYhEAAUAAAAxAQAADoAAABWIRAAFAAAAMQEAAAUAAAAViEQABQAAABvBAAAFgAAAFYhEAAUAAAAdAQAAC4AAABWIRAAFAAAAHYEAAAUAAAAViEQABQAAACNBAAAFgAAAFYhEAAUAAAAkgQAAC4AAABWIRAAFAAAAJQEAAAUAAAAViEQABQAAAD2BAAAFgAAAFYhEAAUAAAA+gQAAC0AAABWIRAAFAAAAPoEAAA6AAAAViEQABQAAAD6BAAAFAAAAFYhEAAUAAAAFQQAABYAAABWIRAAFAAAABoEAAAUAAAAViEQABQAAAAaBAAAPwAAAFYhEAAUAAAA+wMAABYAAABWIRAAFAAAAAAEAAAUAAAAViEQABQAAAAABAAAPwAAAFYhEAAUAAAA1QQAABYAAABWIRAAFAAAANgEAAA5AAAAViEQABQAAADYBAAARgAAAFYhEAAUAAAA2AQAAFcAAABWIRAAFAAAACcFAAAWAAAAViEQABQAAAArBQAALQAAAFYhEAAUAAAAKwUAADoAAABWIRAAFAAAACsFAABLAAAAViEQABQAAAArBQAAXAAAAFYhEAAUAAAAKwUAABQAAABWIRAAFAAAADsEAAAWAAAAViEQABQAAAA/BAAAGgAAAFYhEAAUAAAAPwQAABQAAABWIRAAFAAAAFQEAAAWAAAAViEQABQAAABYBAAAGwAAAFYhEAAUAAAAWAQAABQAAABJbnZhbGlkIFNIIGRlZ3JlZTogAIz2EQATAAAASW52YWxpZCBnemlwIGhlYWRlcgCo9hEAEwAAAGgHEAAVAAAATwEAABwAAABoBxAAFQAAAE8BAAA1AAAAaAcQABUAAABQAQAAHAAAAGgHEAAVAAAAUAEAADkAAABoBxAAFQAAAFEBAAAcAAAAaAcQABUAAABRAQAAOQAAAGgHEAAVAAAAWQEAAAkAAABoBxAAFQAAAFoBAAAJAAAAaAcQABUAAABbAQAACQAAAGgHEAAVAAAAiAEAACEAAABoBxAAFQAAAIkBAAAhAAAAaAcQABUAAACKAQAAIQAAAGgHEAAVAAAAjAEAAB8AAABoBxAAFQAAAJIBAAAJAAAAaAcQABUAAACTAQAACQAAAGgHEAAVAAAAlAEAAAkAAABoBxAAFQAAAJUBAAAJAAAAAQAAAAAAAAABAAAAAAAAAE1pc3NpbmcgZmlsZSAgaW4gU09HUyB6aXAAAADk9xEADQAAAPH3EQAMAAAAaAcQABUAAAC4AQAAIgAAAGgHEAAVAAAAuAEAAAkAAABoBxAAFQAAALkBAAAmAAAAaAcQABUAAAC5AQAACQAAAGgHEAAVAAAAugEAACYAAABoBxAAFQAAALoBAAAJAAAAaAcQABUAAAC7AQAAJQAAAGgHEAAVAAAAoQEAACoAAABoBxAAFQAAAKEBAAAhAAAAaAcQABUAAAChAQAACQAAAGgHEAAVAAAAogEAAC4AAABoBxAAFQAAAKIBAAAlAAAAaAcQABUAAACiAQAACQAAAGgHEAAVAAAAowEAAC4AAABoBxAAFQAAAKMBAAAlAAAAaAcQABUAAACjAQAACQAAAGgHEAAVAAAApAEAACsAAABoBxAAFQAAAPwBAAAgAAAAaAcQABUAAAD8AQAAOwAAAGgHEAAVAAAADgIAAEQAAABoBxAAFQAAAA4CAAAVAAAAaAcQABUAAAAJAgAARAAAAGgHEAAVAAAACQIAABUAAABoBxAAFQAAAAQCAABDAAAAaAcQABUAAAAEAgAAFQAAAGgHEAAVAAAA0QEAACAAAABoBxAAFQAAANEBAAA7AAAAaAcQABUAAADjAQAARAAAAGgHEAAVAAAA4wEAADUAAABoBxAAFQAAAOMBAAAVAAAAaAcQABUAAADeAQAARAAAAGgHEAAVAAAA3gEAADUAAABoBxAAFQAAAN4BAAAVAAAAaAcQABUAAADZAQAAQwAAAGgHEAAVAAAA2QEAADQAAABoBxAAFQAAANkBAAAVAAAAaAcQABUAAAB7AQAAJAAAAGgHEAAVAAAAewEAAAkAAABoBxAAFQAAAHwBAAAoAAAAaAcQABUAAAB8AQAACQAAAGgHEAAVAAAAfQEAACgAAABoBxAAFQAAAH0BAAAJAAAAaAcQABUAAABmAQAAKAAAAGgHEAAVAAAAZgEAAB8AAABoBxAAFQAAAGYBAAAJAAAAaAcQABUAAABnAQAALAAAAGgHEAAVAAAAZwEAACMAAABoBxAAFQAAAGcBAAAJAAAAaAcQABUAAABoAQAALAAAAGgHEAAVAAAAaAEAACMAAABoBxAAFQAAAGgBAAAJAAAAtwQQABcAAACgAAAADgAAALcEEAAXAAAAkAAAABQAAAC3BBAAFwAAAJcAAAATAAAAtwQQABcAAACYAAAAGQAAAERlY29tcHJlc3Npb24gZmFpbGVkOiAAAID7EQAWAAAAc3B6c3BsYXRrc3BsYXRwY3NvZ3N6aXByYWRJbnZhbGlkIGZpbGUgdHlwZTogAAAAuvsRABMAAABzb2d6aXAAAI0mEAAYAAAA9gAAABwAAACNJhAAGAAAAPYAAAAqAAAAbV3L1ixQ62N4QaZXcRuLufUrL4lkWmc6/u1yMy/njHUBAAAAAAAAAAIAAAAAAAAAAQAAAAEAAAAAAAAAIAAA6CAgICAgICAgICAgICBhdCA6AAAAUPwRAAEAAAAKOiAAAQAAAAAAAABd/BEAAgAAAAIAQfr4xwALAQQAQYT5xwALMSAAAOggLSAAAQAAAAAAAACI/BEAAwAAACAgICAgIDx1bmtub3duPgACAAAAAAAAAAIAQcD5xwALxRwgAIDg77+9AKMdEAA0AAAAZwEAADAAAABvcGVyYXRpb24gbm90IHN1cHBvcnRlZCBvbiB0aGlzIHBsYXRmb3Jt2PwRACgAAAAkAAAAAAAAAAIAAAAA/REAYSBmb3JtYXR0aW5nIHRyYWl0IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHdoZW4gdGhlIHVuZGVybHlpbmcgc3RyZWFtIGRpZCBub3QAABj9EQBWAAAAiR0QABkAAACIAgAAEQAAAD8CAAAMAAAABAAAAEACAABBAgAAQgIAAE9zAAAAAAAABAAAAAQAAABDAgAAY29kZQAAAAABAAAAAQAAAEQCAABraW5khQEAAAwAAAAEAAAARQIAAG1lc3NhZ2VLaW5kRXJyb3IAAAAACAAAAAQAAABGAgAAAAAAAAQAAAAEAAAARwIAAEN1c3RvbWVudGl0eSBub3QgZm91bmRwZXJtaXNzaW9uIGRlbmllZGNvbm5lY3Rpb24gcmVmdXNlZGNvbm5lY3Rpb24gcmVzZXRob3N0IHVucmVhY2hhYmxlbmV0d29yayB1bnJlYWNoYWJsZWNvbm5lY3Rpb24gYWJvcnRlZG5vdCBjb25uZWN0ZWRhZGRyZXNzIGluIHVzZWFkZHJlc3Mgbm90IGF2YWlsYWJsZW5ldHdvcmsgZG93bmJyb2tlbiBwaXBlZW50aXR5IGFscmVhZHkgZXhpc3Rzb3BlcmF0aW9uIHdvdWxkIGJsb2Nrbm90IGEgZGlyZWN0b3J5aXMgYSBkaXJlY3RvcnlkaXJlY3Rvcnkgbm90IGVtcHR5cmVhZC1vbmx5IGZpbGVzeXN0ZW0gb3Igc3RvcmFnZSBtZWRpdW1maWxlc3lzdGVtIGxvb3Agb3IgaW5kaXJlY3Rpb24gbGltaXQgKGUuZy4gc3ltbGluayBsb29wKXN0YWxlIG5ldHdvcmsgZmlsZSBoYW5kbGVpbnZhbGlkIGlucHV0IHBhcmFtZXRlcmludmFsaWQgZGF0YXRpbWVkIG91dHdyaXRlIHplcm9ubyBzdG9yYWdlIHNwYWNlc2VlayBvbiB1bnNlZWthYmxlIGZpbGVxdW90YSBleGNlZWRlZGZpbGUgdG9vIGxhcmdlcmVzb3VyY2UgYnVzeWV4ZWN1dGFibGUgZmlsZSBidXN5ZGVhZGxvY2tjcm9zcy1kZXZpY2UgbGluayBvciByZW5hbWV0b28gbWFueSBsaW5rc2ludmFsaWQgZmlsZW5hbWVhcmd1bWVudCBsaXN0IHRvbyBsb25nb3BlcmF0aW9uIGludGVycnVwdGVkdW5zdXBwb3J0ZWR1bmV4cGVjdGVkIGVuZCBvZiBmaWxlb3V0IG9mIG1lbW9yeWluIHByb2dyZXNzb3RoZXIgZXJyb3J1bmNhdGVnb3JpemVkIGVycm9ybWlkID4gbGVu/wASAAkAAABzdGRvdXRmYWlsZWQgcHJpbnRpbmcgdG8gAAAAFgESABMAAABd/BEAAgAAANoQEAAbAAAAjQQAAAkAAABvcGVyYXRpb24gc3VjY2Vzc2Z1bG9uZS10aW1lIGluaXRpYWxpemF0aW9uIG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vyc2l2ZWx5YAESADgAAABjYW5ub3QgcmVjdXJzaXZlbHkgYWNxdWlyZSBtdXRleKABEgAgAAAA6AcQACwAAAATAAAACQAAAGxvY2sgY291bnQgb3ZlcmZsb3cgaW4gcmVlbnRyYW50IG11dGV4AADlFBAAJgAAACMBAAAtAAAA7xoQACMAAADXAAAAFAAAAO8aEAAjAAAA1wAAADEAAABMYXp5TG9jayBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAAAwAhIALgAAAMMUEAAhAAAAlwEAAAUAAABmYWlsZWQgdG8gZ2VuZXJhdGUgdW5pcXVlIHRocmVhZCBJRDogYml0c3BhY2UgZXhoYXVzdGVkAHgCEgA3AAAAph4QAB0AAADUBAAADQAAADoKAACFAQAADAAAAAQAAABIAgAASQIAAEoCAAAAAAAACAAAAAQAAABLAgAATAIAAE0CAABOAgAATwIAABAAAAAEAAAAUAIAAFECAABSAgAAUwIAAGNhbm5vdCBtb2RpZnkgdGhlIHBhbmljIGhvb2sgZnJvbSBhIHBhbmlja2luZyB0aHJlYWQcAxIANAAAAA4WEAAcAAAAkAAAAAkAAAAAAAAABAAAAAQAAABUAgAAV291bGRCbG9jayAob3MgZXJyb3IgAAAAAQAAAAAAAACCAxIACwAAAF4HEgABAAAA2hAQABsAAABcAwAAFAAAAE5vdEZvdW5kUGVybWlzc2lvbkRlbmllZENvbm5lY3Rpb25SZWZ1c2VkQ29ubmVjdGlvblJlc2V0SG9zdFVucmVhY2hhYmxlTmV0d29ya1VucmVhY2hhYmxlQ29ubmVjdGlvbkFib3J0ZWROb3RDb25uZWN0ZWRBZGRySW5Vc2VBZGRyTm90QXZhaWxhYmxlTmV0d29ya0Rvd25Ccm9rZW5QaXBlQWxyZWFkeUV4aXN0c05vdEFEaXJlY3RvcnlJc0FEaXJlY3RvcnlEaXJlY3RvcnlOb3RFbXB0eVJlYWRPbmx5RmlsZXN5c3RlbUZpbGVzeXN0ZW1Mb29wU3RhbGVOZXR3b3JrRmlsZUhhbmRsZUludmFsaWRJbnB1dEludmFsaWREYXRhVGltZWRPdXRXcml0ZVplcm9TdG9yYWdlRnVsbE5vdFNlZWthYmxlUXVvdGFFeGNlZWRlZEZpbGVUb29MYXJnZVJlc291cmNlQnVzeUV4ZWN1dGFibGVGaWxlQnVzeURlYWRsb2NrQ3Jvc3Nlc0RldmljZXNUb29NYW55TGlua3NJbnZhbGlkRmlsZW5hbWVBcmd1bWVudExpc3RUb29Mb25nSW50ZXJydXB0ZWRVbnN1cHBvcnRlZFVuZXhwZWN0ZWRFb2ZPdXRPZk1lbW9yeUluUHJvZ3Jlc3NPdGhlclVuY2F0ZWdvcml6ZWR1bnN1cHBvcnRlZCBiYWNrdHJhY2VkaXNhYmxlZCBiYWNrdHJhY2UAXhsQABwAAACKAQAAHQAAAFUCAAAQAAAABAAAAFYCAABXAgAAcGFuaWNrZWQgYXQgAQAAAAAAAABQ/BEAAQAAAFD8EQABAAAAAAAAAAgAAAAEAAAAWAIAAGFzc2VydGlvbiBmYWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQAACgiEAAqAAAAsQQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA8PSBzaXplICsgbWF4X292ZXJoZWFkAAAoIhAAKgAAALcEAAANAAAA4BMQAC0AAAAWAQAAKQAAAIUBAAAMAAAABAAAAFkCAABudWxsIHBvaW50ZXIgcGFzc2VkIHRvIHJ1c3RyZWN1cnNpdmUgdXNlIG9mIGFuIG9iamVjdCBkZXRlY3RlZCB3aGljaCB3b3VsZCBsZWFkIHRvIHVuc2FmZSBhbGlhc2luZyBpbiBydXN0SnNWYWx1ZSgpAFYHEgAIAAAAXgcSAAEAAAB/FhAAaQAAAHwAAAARAAAAfxYQAGkAAACJAAAAEQAAAFpJUDY0IGZvb3RlciBpbmRpY2F0ZXMgbW9yZSBmaWxlcyBvbiB0aGlzIGRpc2sgdGhhbiBpbiB0aGUgd2hvbGUgYXJjaGl2ZUludmFsaWQgY2VudHJhbCBkaXJlY3Rvcnkgc2l6ZSBvciBvZmZzZXRmYWlsZWQgdG8gZmlsbCB3aG9sZSBidWZmZXIAAAgSABsAAAAlAAAAAgAAABwIEgBDUkMzMiBjaGVja3N1bSBmYWlsZWQgb24gVW5pY29kZSBleHRyYSBmaWVsZFVuaWNvZGUgZXh0cmEgZmllbGQgaXMgdG9vIHNtYWxsRXh0ZW5kZWQgdGltZXN0YW1wIGZpZWxkIGlzIGVtcHR5AAAA/g8QAHQAAABKAAAAJAAAAGZsYWdzIGFuZCBsZW4gZG9uJ3QgbWF0Y2ggaW4gZXh0ZW5kZWQgdGltZXN0YW1wIGZpZWxkTlRGUyBleHRyYSBmaWVsZCBoYXMgYW4gdW5zdXBwb3J0ZWQgYXR0cmlidXRlIHNpemVOVEZTIGV4dHJhIGZpZWxkIGhhcyBhbiB1bnN1cHBvcnRlZCBhdHRyaWJ1dGUgdGFnTlRGUyBleHRyYSBmaWVsZCBoYXMgYW4gdW5zdXBwb3J0ZWQgbGVuZ3RoAADOIRAAWQAAAAQGAAA6AAAARXh0cmEgZmllbGQgY29udGVudCBleGNlZWRzIGRlY2xhcmVkIGxlbmd0aADOIRAAWQAAAAYGAAA7AAAAWklQNjQgZXh0cmEgZmllbGQgdHJ1bmNhdGVkWklQNjQgZXh0cmEtZGF0YSBmaWVsZCBpcyB0aGUgd3JvbmcgbGVuZ3RoAAAAziEQAFkAAABeBgAAEgAAAEFFUyBleHRyYSBmaWVsZCB0cnVuY2F0ZWRJbnZhbGlkIEFFUyBlbmNyeXB0aW9uIHN0cmVuZ3RoSW52YWxpZCBBRVMgdmVuZG9yIHZlcnNpb25JbnZhbGlkIEFFUyB2ZW5kb3JBRVMgZXh0cmEgZGF0YSBmaWVsZCBoYXMgYW4gdW5zdXBwb3J0ZWQgbGVuZ3RoAADOIRAAWQAAAIgGAAAfAAAARXh0cmEgZmllbGQgY29udGVudCB0cnVuY2F0ZWRFeHRyYSBmaWVsZCBoZWFkZXIgdHJ1bmNhdGVkSW52YWxpZCBjaGVja3N1bQBBkJbIAAvjBAEAAAC0AQAAKCkAAMQeEABQAAAAKgIAABEAAABpL28gZXJyb3I6IAAsCxIACwAAAGludmFsaWQgWmlwIGFyY2hpdmU6IAAAAEALEgAVAAAAdW5zdXBwb3J0ZWQgWmlwIGFyY2hpdmU6IAAAAGALEgAZAAAAc3BlY2lmaWVkIGZpbGUgbm90IGZvdW5kIGluIGFyY2hpdmVwcm92aWRlZCBwYXNzd29yZCBpcyBpbmNvcnJlY3QAAAAAAAAABAAAAAQAAADAAAAAAAAAAAQAAAAEAAAAwgAAAFV0ZjhFcnJvcnZhbGlkX3VwX3RvZXJyb3JfbGVuAAAAWgIAAAwAAAAEAAAAWwIAAAAAAAAEAAAABAAAAFwCAABGcm9tVXRmOEVycm9yYnl0ZXNlcnJvck5vbmVTb21lACYcEABvAAAAwwAAAAkAAAAmHBAAbwAAALwAAAAqAAAAJhwQAG8AAAC5AAAAKgAAAJsBEABnAAAAdAEAACkAAACbARAAZwAAAHkBAAAcAAAAmwEQAGcAAAB5AQAALQAAAJsBEABnAAAAgAEAADAAAACbARAAZwAAAEsBAAApAAAAmwEQAGcAAABRAQAAHAAAAJsBEABnAAAAUQEAAC0AAACbARAAZwAAAFkBAAAkAAAAmwEQAGcAAABZAQAAMQAAAAUKEABvAAAAOgAAABsAAAAFChAAbwAAADsAAAAbAAAAVHJ5RnJvbUludEVycm9yAF0CAAAUAAAABAAAAF4CAAAyJhAAWgAAAB8AAAAsAAAAExsQAEoAAAC9AQAAHQAAAP//////////aA0SAEGAm8gAC7FotQsQAGAAAABzAAAAFgAAALULEABgAAAALgAAACMAAAC1CxAAYAAAAEMBAAAWAAAAtQsQAGAAAABPAQAAOAAAALULEABgAAAA6AEAABYAAAC1CxAAYAAAACYAAAAPAAAATw8QAGYAAAAdAAAAEQAAAE8PEABmAAAARgAAABEAAABJbnZhbGlkIFVURi04YXNzZXJ0aW9uIGZhaWxlZDogbWluIDw9IG1heAAAALYPEABHAAAARAQAAAkAAABkZXN0IGlzIG91dCBvZiBib3VuZHMAAAA8DhIAFQAAAAAAAAAEAAAABAAAAEMAAAAAAAAABAAAAAQAAABfAgAAT2tTdHJlYW1FbmROZWVkRGljdEVyck5vU3RyZWFtRXJyb3JEYXRhRXJyb3JNZW1FcnJvckJ1ZkVycm9yVmVyc2lvbkVycm9yTGF5b3V0RXJyb3IAAAAAAEY7Z2WMds7Kyk2pr1nr7U4f0Ior1Z0jhJOmROGy1tud9O28+D6gFVd4m3Iy6z02060GUbZnS/gZIXCffCWrxuBjkKGFqd0IKu/mb098QCuuOntMy/A25WS2DYIBl30dfdFGehgbC9O3XTC00s6W8DOIrZdWQuA++QTbWZwLUPwaTWubf4cmMtDBHVW1UrsRVBSAdjHezd+emPa4+7mGJ4f/vUDiNfDpTXPLjijgbcrJplatrGwbBAMqIGNmLvs6+mjAXZ+ijfQw5LaTVXcQ17QxK7DR+2YZfr1dfhucLeFn2haGAhBbL61WYEjIxcYMKYP9a0xJsMLjD4ulhhag+DVQm59QmtY2/9ztUZpPSxV7CXByHsM927GFBrzUpHYjqOJNRM0oAO1ibjuKB/2dzua7pqmDcesALDfQZ0kzCz7VdTBZsL998B/5Rpd6auDTmyzbtP7mlh1RoK16NIHd5UjH5oItDasrgkuQTOfYNggGng1vY1RAxswSe6GpHfAEL1vLY0qRhsrl172tgEQb6WECII4EyG0nq45WQM6vJt+y6R241yNQEXhla3Yd9s0y/LD2VZl6u/w2PICbUzhbws9+YKWqtC0MBfIWa2BhsC+BJ4tI5O3G4Uur/YYuio0ZUsy2fjcG+9eYQMCw/dNm9ByVXZN5XxA61hkrXbMsQPFranuWDqA2P6HmDVjEdascJTOQe0D53dLvv+a1ip6WKvbYrU2TEuDkPFTbg1nHfce4gUag3UsLCXINMG4XCes3i0/QUO6FnflBw6aeJFAA2sUWO72g3HYUD5pNc2q7PewW/QaLczdLItxxcEW54tYBWKTtZj1uoM+SKJuo9ycQDXFhK2oUq2bDu+1dpN5+++A/OMCHWvKNLvW0tkmQlcbW7NP9sYkZsBgmX4t/Q8wtO6KKFlzHQFv1aAZgkg0Cu8uRRICs9I7NBVvI9mI+W1Am3x1rQbrXJugVkR2PcLBtEAz2VndpPBvexnoguaPphv1Cr72aJ2XwM4gjy1TtOuAJXnzbbju2lseU8K2g8WML5BAlMIN1730q2qlGTb+INtLDzg21pgRAHAlCe3ts0d0/jZfmWOhdq/FHG5CWIh9Lz75ZcKjbkz0BdNUGZhFGoCLwAJtFlcrW7DqM7YtfrZ0UI+umc0Yh69rpZ9C9jPR2+W2yTZ4IeAA3pz47UMIxsPVEd4uSIb3GO477/VzraFsYCi5gf2/kLdbAohaxpYNmLtnFXUm8DxDgE0krh3bajcOXnLak8lb7DV0QwGo4FBszpFIgVMGYbf1u3laaC03w3uoLy7mPwYYQIIe9d0Wmzeg54PaPXCq7JvNsgEGW/yYFd7kdYhJzUMu9NWus2AAAAABYgOLX8Qa0dKmGVqPiDWjpuo2KPhML3J1Liz5KhR2hCd2dQ950GxV9LJv3qmcQyeA/kCs3lhZ9lM6Wn0MKO0ITUrugxPs99mejvRSw6DYq+rC2yC0ZMJ6OQbB8WY8m4xrXpgHNfiBXbiagtbltK4vzNatpJJwtP4fErd1QFHaEJkz2ZvHlcDBSvfDShfZ77M+u+w4YB31Yu1/9umyRayUvyevH+GBtkVs47XOMc2ZNxivmrxGCYPmy2uAbZR5NxjVGzSTi70tyQbfLkJb8QK7cpMBMCw1GGqhVxvh/m1BnPMPQhetqVtNIMtYxn3ldD9Uh3e0CiFu7odDbWXYo7AhNcGzqmtnqvDmBal7uyuFgpJJhgnM759TQY2c2B63xqUT1cUuTXPcdMAR3/+dP/MGtF3wjer76ddnmepcOItdKXnpXqInT0f4qi1Ec/cDaIreYWsBgMdyWw2lcdBSnyutX/0oJgFbMXyMOTL30RceDvh1HYWm0wTfK7EHVHTyajGtkGm68zZw4H5Uc2sjel+SChhcGVS+RUPZ3EbIhuYctYuEHz7VIgZkWEAF7wVuKRYsDCqdcqozx//IMEyg2oc54biEsr8enegyfJ5jb1KymkYwsREYlqhLlfSrwMrO8b3HrPI2mQrrbBRo6OdJRsQeYCTHlT6C3s+z4N1E7UNgRmghY802h3qXu+V5HObLVeXPqVZukQ9PNBxtTL9DVxbCTjUVSRCTDBOd8Q+YwN8jYem9IOq3GzmwOnk6O2VrjU4kCY7Feq+Xn/fNlBSq47jtg4G7Zt0nojxQRaG3D3/7ygId+EFcu+Eb0dnikIz3zmmllc3i+zPUuHZR1zMpErpW8HC53a7WoIcjtKMMfpqP9Vf4jH4JXpUkhDyWr9sGzNLWZM9ZiMLWAwWg1YhYjvlxcez6+i9K46CiKOAr/TpXXrxYVNXi/k2Pb5xOBDKyYv0b0GF2RXZ4LMgUe6eXLiHamkwiUcTqOwtJiDiAFKYUeT3EF/JjYg6o7gANI7Hg0GdcgtPsAiTKto9GyT3SaOXE+wrmT6Ws/xUozvyed/Sm43qWpWgkMLwyqVK/ufR8k0DdHpDLg7iJkQ7aihpRyD1vEKo+5E4MJ77DbiQ1nkAIzLciC0fphBIdZOYRljvcS+s2vkhgaBhROuV6UrG4VH5IkTZ9w8+QZJlC8mcSHbEKd8TTCfyadRCmFxcTLUo5P9RjWzxfPf0lBbCfJo7vpXzz4sd/eLxhZiIxA2WpbC1JUEVPStsb6VOBlotQCsmZ53+I++T01l39rls//iUGEdLcL3PRV3HVyA38t8uGo42R+67vknDwSYsqfSuIoSAFpFgJZ6fTV8G+idqjvQKEAAAAA4bZS74Nr1AVi3YbqBteoC+dh+uSFvHwOZAou4QyuURftGAP4j8WFEm5z1/0Kefkc68+r84kSLRlopH/2GFyjLvnq8cGbN3creoElxB6LCyX/PVnKneDfIHxWjc8U8vI59USg1peZJjx2L3TTEiVaMvOTCN2RTo43cPjc2DC4Rl3RDhSys9OSWFJlwLc2b+5W19m8ubUEOlNUsmi8PBYXSt2gRaW/fcNPXsuRoDrBv0Hbd+2uuaprRFgcOaso5OVzyVK3nKuPMXZKOWOZLjNNeM+FH5etWJl9TO7LkiRKtGTF/OaLpyFgYUaXMo4inRxvwytOgKH2yGpAQJqFYHCNuoHG31XjG1m/Aq0LUGanJbGHEXde5czxtAR6o1ts3tytjWiOQu+1CKgOA1pHagl0pou/JknpYqCjCNTyTHgsLpSZmnx7+0f6kRrxqH5++4afn03UcP2QUpocJgB1dIJ/g5U0LWz36auGFl/5aXJV14iT44Vn8T4DjRCIUWJQyMvnsX6ZCNOjH+IyFU0NVh9j7LepMQPVdLfpNMLlBlxmmvC90Mgf3w1O9T67HBpasTL7uwdgFNna5v44bLQRSJRoyakiOibL/7zMKknuI05DwMKv9ZItzSgUxyyeRihEOjnepYxrMcdR7dsm5780Qu2R1aNbwzrBhkXQIDAXP4Hma65gUDlBAo2/q+M77USHMcOlZoeRSgRaF6Dl7EVPjUg6uWz+aFYOI+6875W8U4ufkrJqKcBdCPRGt+lCFFiZusiAeAyabxrRHIX7Z05qn21gi37bMmQcBrSO/bDmYZUUmZd0ost4Fn9NkvfJH32TwzGccnVjcxCo5ZnxHrd2sV4t81DofxwyNfn204OrGbeJhfhWP9cXNOJR/dVUAxK98HzkXEYuCz6bqOHfLfoOuyfU71qRhgA4TADq2fpSBakCjt1ItNwyKmla2MvfCDev1SbWTmN0OSy+8tPNCKA8pazfykQajSUmxwvPx3FZIKN7d8FCzSUuIBCjxMGm8SvhluYUACC0+2L9MhGDS2D+50FOHwb3HPBkKpoahZzI9e04twMMjuXsblNjBo/lMenr7x8ICllN52iEyw2JMpni+cpFOhh8F9V6oZE/mxfD0P8d7TEeq7/efHY5NJ3Aa9v1ZBQtFNJGwnYPwCiXuZLH87O8JhIF7slw2GgjkW46zNEuoEkwmPKmUkV0TLPzJqPX+QhCNk9arVSS3Ee1JI6o3YDxXjw2o7Fe6yVbv113tNtXWVU64Qu6WDyNULmK37/JcgNnKMRRiEoZ12Krr4WNz6WrbC4T+YNMzn9prXgthsXcUnAkagCfRreGdacB1JrDC/p7Ir2olEBgLn6h1nyRAAAAAEPLpofHkDzUhFuaU88nCHOM7K70CLc0p0t8kiCeTxDm3YS2YVnfLDIaFIq1UWgYlRKjvhKW+CRB1TOCxn2ZURc+UveQugltw/nCy0Syvllk8XX/43UuZbA25cM349ZB8aAd53YkRn0lZ43boizxSYJvOu8F62F1Vqiq09H6MqMuufkFqT2in/p+aTl9NRWrXXbeDdryhZeJsU4xDmR9s8gnthVPo+2PHOAmKZurWru76JEdPGzKh28vASHoh6vyOcRgVL5AO87tA/BoakiM+koLR1zNjxzGnszXYBkZ5OLfWi9EWN503gudv3iM1sPqrJUITCsRU9Z4Uphw//RlRl23ruDaM/V6iXA+3A47Qk4ueInoqfzScvq/GdR9aipWuynh8Dytumpv7nHM6KUNXsjmxvhPYp1iHCFWxJuJ/BdKyjexzU5sK54Np40ZRtsfOQUQub6BSyPtwoCFahezB6xUeKEr0CM7eJPonf/YlA/fm1+pWB8EMwtcz5WMDlflc02cQ/TJx9mnigx/IMFw7QCCu0uHBuDR1EUrd1OQGPWV09NTEleIyUEUQ2/GXz/95hz0W2GYr8Ey22RntXPOtGQwBRLjtF6IsPeVLje86bwX/yIakHt5gMM4siZE7YGkgq5KAgUqEZhWado+0SKmrPFhbQp25TaQJab9NqLoy4y6qwAqPS9bsG5skBbpJ+yEyWQnIk7gfLgdo7cemnaEnFw1TzrbsRSgiPLfBg+5o5Qv+mgyqH4zqPs9+A58lVLdrdaZeypSwuF5EQlH/lp11d4ZvnNZneXpCt4uT40LHc1LSNZrzMyN8Z+PRlcYxDrFOIfxY78DqvnsQGFfaxL5L5RRMokT1WkTQJaitcfd3ifnnhWBYBpOGzNZhb20jLY/cs99mfVLJgOmCO2lIUORNwEAWpGGhAEL1cfKrVJvYH6DLKvYBKjwQlfrO+TQoEd28OOM0Hdn10okJBzso/EvbmWy5MjiNr9SsXV09DY+CGYWfcPAkfmYWsK6U/xFHK7K519lbGDbPvYzmPVQtNOJwpSQQmQTFBn+QFfSWMeC4doBwSp8hkVx5tUGukBSTcbScg4NdPWKVu6myZ1IIWE3m/Ai/D13pqenJOVsAaOuEJOD7ds1BGmAr1cqSwnQ/3iLFryzLZE46LfCeyMRRTBfg2VzlCXi98+/sbQEGTbmnGnJpVfPTiEMVR1ix/OaKbthumpwxz3uK11ureD76XjTeS87GN+ov0NF+/yI43y39HFc9D/X23BkTYgzr+sPmwU43tjOnllclQQKH16ijVQiMK0X6ZYqk7IMedB5qv4FSig4RoGOv8LaFOyBEbJrym0gS4mmhswN/RyfTja6GAcgEABkAAAAdAAAACcAAAAHIBAAZAAAAGsAAAAzAAAAAAAAAJYwB3csYQ7uulEJmRnEbQeP9GpwNaVj6aOVZJ4yiNsOpLjceR7p1eCI2dKXK0y2Cb18sX4HLbjnkR2/kGQQtx3yILBqSHG5895BvoR91Noa6+TdbVG11PTHhdODVphsE8Coa2R6+WL97Mllik9cARTZbAZjYz0P+vUNCI3IIG47XhBpTORBYNVycWei0eQDPEfUBEv9hQ3Sa7UKpfqotTVsmLJC1sm720D5vKzjbNgydVzfRc8N1txZPdGrrDDZJjoA3lGAUdfIFmHQv7X0tCEjxLNWmZW6zw+lvbieuAIoCIgFX7LZDMYk6Quxh3xvLxFMaFirHWHBPS1mtpBB3HYGcdsBvCDSmCoQ1e+JhbFxH7W2BqXkv58z1LjooskHeDT5AA+OqAmWGJgO4bsNan8tPW0Il2xkkQFcY+b0UWtrYmFsHNgwZYVOAGLy7ZUGbHulARvB9AiCV8QP9cbZsGVQ6bcS6ri+i3yIufzfHd1iSS3aFfN804xlTNT7WGGyTc5RtTp0ALyj4jC71EGl30rXldg9bcTRpPv01tNq6WlD/NluNEaIZ63QuGDacy0EROUdAzNfTAqqyXwN3TxxBVCqQQInEBALvoYgDMkltWhXs4VvIAnUZrmf5GHODvneXpjJ2SkimNCwtKjXxxc9s1mBDbQuO1y9t61susAgg7jttrO/mgzitgOa0rF0OUfV6q930p0VJtsEgxbccxILY+OEO2SUPmptDahaanoLzw7knf8JkyeuAAqxngd9RJMP8NKjCIdo8gEe/sIGaV1XYvfLZ2WAcTZsGecGa252G9T+4CvTiVp62hDMSt1nb9+5+fnvvo5DvrcX1Y6wYOij1tZ+k9GhxMLYOFLy30/xZ7vRZ1e8pt0GtT9LNrJI2isN2EwbCq/2SgM2YHoEQcPvYN9V32eo745uMXm+aUaMs2HLGoNmvKDSbyU24mhSlXcMzANHC7u5FgIiLyYFVb47usUoC72yklq0KwRqs1yn/9fCMc/QtYue2Swdrt5bsMJkmybyY+yco2p1CpNtAqkGCZw/Ng7rhWcHchNXAAWCSr+VFHq44q4rsXs4G7YMm47Skg2+1eW379x8Id/bC9TS04ZC4tTx+LPdaG6D2h/NFr6BWya59uF3sG93R7cY5loIiHBqD//KOwZmXAsBEf+eZY9prmL40/9rYUXPbBZ44gqg7tIN11SDBE7CswM5YSZnp/cWYNBNR2lJ23duPkpq0a7cWtbZZgvfQPA72DdTrrypxZ673n/Pskfp/7UwHPK9vYrCusowk7NTpqO0JAU20LqTBtfNKVfeVL9n2SMuemazuEphxAIbaF2UK28qN74LtKGODMMb3wVaje8CLQAAAABlZ7y4i8gJqu6vtRJXl2KPMvDeN9xfayW5ONed7yi0xYpPCH1k4L1vAYcB17i/1krd2GryM3ff4FYQY1ifVxlQ+jCl6BSfEPpx+KxCyMB7362nx2dDCHJ1Jm/OzXB/rZUVGBEt+7ekP57QGIcn6M8aQo9zoqwgxrDJR3oIPq8yoFvIjhi1ZzsK0ACHsmk4UC8MX+yX4vBZhYeX5T3Rh4ZltOA63VpPj88/KDN3hhDk6uN3WFIN2O1AaL9R+KH4K/DEn5dIKjAiWk9XnuL2b0l/kwj1x32nQNUYwPxtTtCfNSu3I43FGJafoH8qJxlH/bp8IEECko/0EPfoSKg9WBSbWD+oI7aQHTHT96GJas92FA+oyqzhB3++hGDDBtJwoF63FxzmWbip9DzfFUyF58LR4IB+aQ4vy3trSHfDog8Ny8dosXMpxwRhTKC42fWYb0SQ/9P8flBm7hs32lZNJ7kOKEAFtsbvsKSjiAwcGrDbgX/XZzmReNIr9B9ukwP3JjtmkJqDiD8vke1YkylUYES0MQf4DN+oTR66z/Gm7N+S/om4LkZnF5tUAnAn7LtI8HHeL0zJMID521XnRWOcoD9r+ceD0xdoNsFyD4p5yzdd5K5Q4VxA/1ROJZjo9nOIi64W7zcW+ECCBJ0nPrwkH+khQXhVma/X4IvKsFwzO7ZZ7V7R5VWwflBH1Rns/2whO2IJRofa5+kyyIKOjnDUnu0osflRkF9W5II6MVg6gwmPp+ZuMx8IwYYNbaY6taThQL3BhvwFLylJF0pO9a/zdiIylhGeini+K5gd2ZcgS8n0eC6uSMDAAf3SpWZBahxelvd5OSpPl5afXfLxI+UFGWtNYH7X9Y7RYufrtt5fUo4JwjfptXrZRgBovCG80Oox34iPVmMwYfnWIgSeapq9pr0H2MEBvzZutK1TCQgVmk5yHf8pzqURhnu3dOHHD83ZEJKovqwqRhEZOCN2pYB1ZsbYEAF6YP6uz3KbyXPKIvGkV0eWGO+pOa39zF4RRQbuTXZjifHOjSZE3OhB+GRReS/5NB6TQdqxJlO/1prr6cb5s4yhRQtiDvAZB2lMob5RmzzbNieENZmSllD+Li6ZuVQm/N7onhJxXYx3FuE0zi42qatJihFF5j8DIIGDu3aR4OMT9lxb/VnpSZg+VfEhBoJsRGE+1KrOi8bPqTd+OEF/1l0mw26ziXZ81u7KxG/WHVkKsaHh5B4U84F5qEvXacsTsg53q1yhwrk5xn4BgP6pnOWZFSQLNqA2blEcjqcWZobCcdo+LN5vLEm505TwgQQJlea4sXtJDaMeLrEbSD7SQy1ZbvvD9tvpppFnUR+psMx6zgx0lGG5ZvEGBd4AAAAAN2rCAW7UhANZvkYC3KgJB+vCywayfI0EhRZPBbhREw6PO9EP1oWXDeHvVQxk+RoJU5PYCAotngo9R1wLcKMmHEfJ5B0ed6IfKR1gHqwLLxubYe0awt+rGPW1aRnI8jUS/5j3E6YmsRGRTHMQFFo8FSMw/hR6jrgWTeR6F+BGTTjXLI85jpLJO7n4Czo87kQ/C4SGPlI6wDxlUAI9WBdeNm99nDc2w9o1AakYNIS/VzGz1ZUw6mvTMt0BETOQ5Wskp4+pJf4x7yfJWy0mTE1iI3snoCIimeYgFfMkISi0eCof3rorRmD8KXEKPij0HHEtw3azLJrI9S6tojcvwI2acPfnWHGuWR5zmTPcchwlk3crT1F2cvEXdEWb1XV43Il+T7ZLfxYIDX0hYs98pHSAeZMeQnjKoAR6/crGe7AuvGyHRH5t3vo4b+mQ+m5shrVrW+x3agJSMWg1OPNpCH+vYj8VbWNmqythUcHpYNTXpmXjvWRkugMiZo1p4Gcgy9dIF6EVSU4fU0t5dZFK/GPeT8sJHE6St1pMpd2YTZiaxEav8AZH9k5ARcEkgkREMs1Bc1gPQCrmSUIdjItDUGjxVGcCM1U+vHVXCda3VozA+FO7qjpS4hR8UNV+vlHoOeJa31MgW4btZlmxh6RYNJHrXQP7KVxaRW9ebS+tX4AbNeG3cffg7s+x4tmlc+Ncszzma9n+5zJnuOUFDXrkOEom7w8g5O5WnqLsYfRg7eTiL+jTiO3pijar671caerwuBP9x9LR/J5sl/6pBlX/LBAa+ht62PtCxJ75da5c+EjpAPN/g8LyJj2E8BFXRvGUQQn0oyvL9fqVjffN/0/2YF142Vc3utgOifzaOeM+27z1cd6Ln7Pf0iH13eVLN9zYDGvX72ap1rbY79SBsi3VBKRi0DPOoNFqcObTXRok0hD+XsUnlJzEfiraxklAGMfMVlfC+zyVw6KC08GV6BHAqK9Ny5/Fj8rGe8nI8RELyXQHRMxDbYbNGtPAzy25As5Alq+Rd/xtkC5CK5IZKOmTnD6mlqtUZJfy6iKVxYDglPjHvJ/PrX6elhM4nKF5+p0kb7WYEwV3mUq7MZt90fOaMDWJjQdfS4xe4Q2OaYvPj+ydgIrb90KLgkkEibUjxoiIZJqDvw5YguawHoDR2tyBVMyThGOmUYU6GBeHDXLVhqDQ4qmXuiCozgRmqvlupKt8eOuuSxIprxKsb60lxq2sGIHxpy/rM6Z2VXWkQT+3pcQp+KDzQzqhqv18o52XvqLQc8S15xkGtL6nQLaJzYK3DNvNsjuxD7NiD0mxVWWLsGgi17tfSBW6BvZTuDGckbm0it68g+AcvdpeWr/tNJi+AAAAAEExGxmCYjYyw1MtKwTFbGRF9Hd9hqdaVseWQU8IitnISbvC0Yro7/rL2fTjDE+1rE1+rrWOLYOezxyYh1ESwkoQI9lT03D0eJJB72FV164uFOa1N9e1mByWhIMFWZgbghipAJvb+i2wmss2qV1dd+YcbGz/3z9B1J4OWs2iJISV4xWfjCBGsqdhd6m+puHo8efQ8+gkg97DZbLF2qquXV3rn0ZEKMxrb2n9cHauazE571oqICwJBwttOBwS8zZG37IHXcZxVHDtMGVr9PfzKru2wjGidZEciTSgB5D7vJ8Xuo2EDnneqSU477I8/3nzc75I6Gp9G8VBPCreWAVPefBEfmLphy1PwsYcVNsBihWUQLsOjYPoI6bC2Ti/DcWgOEz0uyGPp5YKzpaNEwkAzFxIMddFi2L6bspT4XdUXbu6FWygo9Y/jYiXDpaRUJjX3hGpzMfS+uHsk8v69VzXYnId5nlr3rVUQJ+ET1lYEg4WGSMVD9pwOCSbQSM9p2v9ZeZa5nwlCctXZDjQTqOukQHin4oYIcynM2D9vCqv4SSt7tA/tC2DEp9ssgmGqyRIyeoVU9ApRn77aHdl4vZ5Py+3SCQ2dBsJHTUqEgTyvFNLs41IUnDeZXkx735g/vPm57/C/f58kdDVPaDLzPo2ioO7B5GaeFS8sTllp6hLmIM7CqmYIsn6tQmIy64QT13vXw5s9EbNP9ltjA7CdEMSWvMCI0HqwXBswYBBd9hH1zaXBuYtjsW1AKWEhBu8GopBcVu7WmiY6HdD2dlsWh5PLRVffjYMnC0bJ90cAD4SAJi5UzGDoJBirovRU7WSFsX03Vf078SUp8Lv1ZbZ9um8B66ojRy3a94xnCrvKoXteWvKrEhw028bXfguKkbh4TbeZqAHxX9jVOhUImXzTeXzsgKkwqkbZ5GEMCagnym4rsXk+Z/e/TrM89Z7/ejPvGupgP1aspk+CZ+yfziEq7AkHCzxFQc1MkYqHnN3MQe04XBI9dBrUTaDRnp3sl1jTtf6yw/m4dLMtcz5jYTX4EoSlq8LI422yHCgnYlBu4RGXSMDB2w4GsQ/FTGFDg4oQphPZwOpVH7A+nlVgctiTB/FOIFe9COYnacOs9yWFaobAFTlWjFP/JliYtfYU3nOF0/hSVZ++lCVLdd71BzMYhOKjS1Su5Y0kei7H9DZoAbs835ercJlR26RSGwvoFN16DYSOqkHCSNqVCQIK2U/EeR5p5alSLyPZhuRpCcqir3gvMvyoY3Q62Le/cAj7+bZveG8FPzQpw0/g4omfrKRP7kk0HD4FctpO0bmQnp3/Vu1a2Xc9Fp+xTcJU+52OEj3sa4JuPCfEqEzzD+Kcv0kkwAAAACWMAd3LGEO7rpRCZkZxG0Hj/RqcDWlY+mjlWSeMojbDqS43Hke6dXgiNnSlytMtgm9fLF+By2455Edv5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwGY2M9D/r1DQiNyCBuO14QaUzkQWDVcnFnotHkAzxH1ARL/YUN0mu1CqX6qLU1bJiyQtbJu9tA+bys42zYMnVc30XPDdbcWT3Rq6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8by8RTGhYqx1hwT0tZraQQdx2BnHbAbwg0pgqENXviYWxcR+1tgal5L+fM9S46KLJB3g0+QAPjqgJlhiYDuG7DWp/LT1tCJdsZJEBXGPm9FFra2JhbBzYMGWFTgBi8u2VBmx7pQEbwfQIglfED/XG2bBlUOm3Euq4vot8iLn83x3dYkkt2hXzfNOMZUzU+1hhsk3OUbU6dAC8o+Iwu9RBpd9K15XYPW3E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX0wKqsl8Dd08cQVQqkECJxAQC76GIAzJJbVoV7OFbyAJ1Ga5n+Rhzg753l6YydkpIpjQsLSo18cXPbNZgQ20LjtcvbetbLrAIIO47bazv5oM4rYDmtKxdDlH1eqvd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2oWmp6C88O5J3/CZMnrgAKsZ4HfUSTD/DSowiHaPIBHv7CBmldV2L3y2dlgHE2bBnnBmtudhvU/uAr04laetoQzErdZ2/fufn5776OQ763F9WOsGDoo9bWfpPRocTC2DhS8t9P8We70WdXvKbdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72DfVd9nqO+ObjF5vmlGjLNhyxqDZryg0m8lNuJoUpV3DMwDRwu7uRYCIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO64VnB3ITVwAFgkq/lRR6uOKuK7F7OBu2DJuO0pINvtXlt+/cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd7Bvd0e3GOZaCIhwag//yjsGZlwLARH/nmWPaa5i+NP/a2FFz2wWeOIKoO7SDddUgwROwrMDOWEmZ6f3FmDQTUdpSdt3bj5KatGu3FrW2WYL30DwO9g3U668qcWeu95/z7JH6f+1MBzyvb2KwrrKMJOzU6ajtCQFNtC6kwbXzSlX3lS/Z9kjLnpms7hKYcQCG2hdlCtvKje+C7ShjgzDG98FWo3vAi0AAAAAaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogdGhlIHJ1c3QgQVBJIGRvZXMgbm90IHVzZSBmaWxlcwAAAPQyEgBJAAAA9BgQAF8AAAChAAAAIgAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUQERIACAcJBgoFCwQMAw0CDgEPAABZFxAAYAAAAJMAAAAJAAAAAABgB1AAAAgQAAAIcwAUCB8AEgdwAAAIMAAACMAAAAkKABAHYAAACCAAAAigAAAJAAAACIAAAAhAAAAI4AAACQYAEAdYAAAIGAAACJAAAAk7ABMHeAAACDgAAAjQAAAJEQARB2gAAAgoAAAIsAAACQgAAAiIAAAISAAACPAAAAkEABAHVAAACBQAAAjjABUIKwATB3QAAAg0AAAIyAAACQ0AEQdkAAAIJAAACKgAAAkEAAAIhAAACEQAAAjoAAAJCAAQB1wAAAgcAAAImAAACVMAFAd8AAAIPAAACNgAAAkXABIHbAAACCwAAAi4AAAJDAAACIwAAAhMAAAI+AAACQMAEAdSAAAIEgAACKMAFQgjABMHcgAACDIAAAjEAAAJCwARB2IAAAgiAAAIpAAACQIAAAiCAAAIQgAACOQAAAkHABAHWgAACBoAAAiUAAAJQwAUB3oAAAg6AAAI1AAACRMAEgdqAAAIKgAACLQAAAkKAAAIigAACEoAAAj0AAAJBQAQB1YAAAgWAAAIAABACDMAEwd2AAAINgAACMwAAAkPABEHZgAACCYAAAisAAAJBgAACIYAAAhGAAAI7AAACQkAEAdeAAAIHgAACJwAAAljABQHfgAACD4AAAjcAAAJGwASB24AAAguAAAIvAAACQ4AAAiOAAAITgAACPwAAAkAAGAHUQAACBEAAAiDABUIHwASB3EAAAgxAAAIwgAACQoAEAdhAAAIIQAACKIAAAkBAAAIgQAACEEAAAjiAAAJBgAQB1kAAAgZAAAIkgAACTsAEwd5AAAIOQAACNIAAAkRABEHaQAACCkAAAiyAAAJCQAACIkAAAhJAAAI8gAACQQAEAdVAAAIFQAACAIBEAgrABMHdQAACDUAAAjKAAAJDQARB2UAAAglAAAIqgAACQUAAAiFAAAIRQAACOoAAAkIABAHXQAACB0AAAiaAAAJUwAUB30AAAg9AAAI2gAACRcAEgdtAAAILQAACLoAAAkNAAAIjQAACE0AAAj6AAAJAwAQB1MAAAgTAAAIwwAVCCMAEwdzAAAIMwAACMYAAAkLABEHYwAACCMAAAimAAAJAwAACIMAAAhDAAAI5gAACQcAEAdbAAAIGwAACJYAAAlDABQHewAACDsAAAjWAAAJEwASB2sAAAgrAAAItgAACQsAAAiLAAAISwAACPYAAAkFABAHVwAACBcAAAgAAEAIMwATB3cAAAg3AAAIzgAACQ8AEQdnAAAIJwAACK4AAAkHAAAIhwAACEcAAAjuAAAJCQAQB18AAAgfAAAIngAACWMAFAd/AAAIPwAACN4AAAkbABIHbwAACC8AAAi+AAAJDwAACI8AAAhPAAAI/gAACQAAYAdQAAAIEAAACHMAFAgfABIHcAAACDAAAAjBAAAJCgAQB2AAAAggAAAIoQAACQAAAAiAAAAIQAAACOEAAAkGABAHWAAACBgAAAiRAAAJOwATB3gAAAg4AAAI0QAACREAEQdoAAAIKAAACLEAAAkIAAAIiAAACEgAAAjxAAAJBAAQB1QAAAgUAAAI4wAVCCsAEwd0AAAINAAACMkAAAkNABEHZAAACCQAAAipAAAJBAAACIQAAAhEAAAI6QAACQgAEAdcAAAIHAAACJkAAAlTABQHfAAACDwAAAjZAAAJFwASB2wAAAgsAAAIuQAACQwAAAiMAAAITAAACPkAAAkDABAHUgAACBIAAAijABUIIwATB3IAAAgyAAAIxQAACQsAEQdiAAAIIgAACKUAAAkCAAAIggAACEIAAAjlAAAJBwAQB1oAAAgaAAAIlQAACUMAFAd6AAAIOgAACNUAAAkTABIHagAACCoAAAi1AAAJCgAACIoAAAhKAAAI9QAACQUAEAdWAAAIFgAACAAAQAgzABMHdgAACDYAAAjNAAAJDwARB2YAAAgmAAAIrQAACQYAAAiGAAAIRgAACO0AAAkJABAHXgAACB4AAAidAAAJYwAUB34AAAg+AAAI3QAACRsAEgduAAAILgAACL0AAAkOAAAIjgAACE4AAAj9AAAJAABgB1EAAAgRAAAIgwAVCB8AEgdxAAAIMQAACMMAAAkKABAHYQAACCEAAAijAAAJAQAACIEAAAhBAAAI4wAACQYAEAdZAAAIGQAACJMAAAk7ABMHeQAACDkAAAjTAAAJEQARB2kAAAgpAAAIswAACQkAAAiJAAAISQAACPMAAAkEABAHVQAACBUAAAgCARAIKwATB3UAAAg1AAAIywAACQ0AEQdlAAAIJQAACKsAAAkFAAAIhQAACEUAAAjrAAAJCAAQB10AAAgdAAAImwAACVMAFAd9AAAIPQAACNsAAAkXABIHbQAACC0AAAi7AAAJDQAACI0AAAhNAAAI+wAACQMAEAdTAAAIEwAACMMAFQgjABMHcwAACDMAAAjHAAAJCwARB2MAAAgjAAAIpwAACQMAAAiDAAAIQwAACOcAAAkHABAHWwAACBsAAAiXAAAJQwAUB3sAAAg7AAAI1wAACRMAEgdrAAAIKwAACLcAAAkLAAAIiwAACEsAAAj3AAAJBQAQB1cAAAgXAAAIAABACDMAEwd3AAAINwAACM8AAAkPABEHZwAACCcAAAivAAAJBwAACIcAAAhHAAAI7wAACQkAEAdfAAAIHwAACJ8AAAljABQHfwAACD8AAAjfAAAJGwASB28AAAgvAAAIvwAACQ8AAAiPAAAITwAACP8AAAkBABAFAQEXBREAEwUBEBsFBQARBQEEGQVBABUFAUAdBQMAEAUBAhgFIQAUBQEgHAUJABIFAQgaBYEAFgUAAEAFAgAQBYEBFwUZABMFARgbBQcAEQUBBhkFYQAVBQFgHQUEABAFAQMYBTEAFAUBMBwFDQASBQEMGgXBABYFAABABVkXEABgAAAAwgcAABEAAABZFxAAYAAAAMAHAAARAAAAWRcQAGAAAADJBwAAFAAAAFkXEABgAAAAzgcAABgAAABZFxAAYAAAAFEIAAAYAAAAWRcQAGAAAADdBwAAGAAAAFkXEABgAAAARQgAACAAAABJTkZMQVRFX0FMTE9XX0lOVkFMSURfRElTVEFOQ0VfVE9PRkFSX0FSUlIAAJg8EgAqAAAAWRcQAGAAAAAICAAAIQAAAFkXEABgAAAAHQIAAAkAAABZFxAAYAAAACECAAAJAAAAWRcQAGAAAACCAgAAJAAAAFkXEABgAAAAkgIAACgAAABZFxAAYAAAAO4CAAAkAAAAWRcQAGAAAAD/AgAAJQAAAFkXEABgAAAAWAMAACEAAABZFxAAYAAAAGAEAABEAAAAbmFtZSBvdXQgb2YgYm91bmRzAABZFxAAYAAAAIkEAAAqAAAAY29tbSBvdXQgb2YgYm91bmRzAABZFxAAYAAAAMIEAAAqAAAAWRcQAGAAAAAkBgAAJQAAAFkXEABgAAAAZAYAADMAAABZFxAAYAAAAOIGAAA0AAAAWRcQAGAAAADiBgAAJwAAAFkXEABgAAAA0wYAACcAAABZFxAAYAAAAJ4GAAAvAAAAWRcQAGAAAACnBgAAOwAAAFkXEABgAAAAtQYAADsAAABZFxAAYAAAALUGAAAuAAAAWRcQAGAAAADDBgAAOwAAAFkXEABgAAAAwwYAAC4AAABZFxAAYAAAAJMGAAAlAAAAYXNzZXJ0aW9uIGZhaWxlZDogc2VsZi5idWYuaXNfZW1wdHkoKSB8fCBzZWxmLmJ1Zi5sZW4oKSA+PSBTZWxmOjpwYWRkaW5nKCkAAAMCEABnAAAALwAAAAkAAAADAhAAZwAAAIgAAAA1AAAAAwIQAGcAAACIAAAAKAAAAAMCEABnAAAAgQAAAEQAAAADAhAAZwAAAIEAAAA3AAAAAwIQAGcAAABPAAAAHQAAAP4KEABnAAAAEQEAACMAAAD+ChAAZwAAABIBAAAjAAAA/goQAGcAAAASAQAAGAAAAP4KEABnAAAAGQEAACwAAAD+ChAAZwAAABkBAAAZAAAA/goQAGcAAABQAQAAEQAAAGluIGJvdW5kcwAAAP4KEABnAAAASAEAADoAAAD+ChAAZwAAALUAAAAzAAAA/goQAGcAAAC1AAAAJAAAAP4KEABnAAAAtAAAACkAAAD+ChAAZwAAAFsAAAAJAAAA/goQAGcAAABkAAAALwAAAP4KEABnAAAAZAAAACAAAABhc3NlcnRpb24gZmFpbGVkOiBtc2cuZW5kc193aXRoKCdcMCcpAAAAWRcQAGAAAACSCQAACQAAAFkXEABgAAAAiQkAACMAAAADAAQABQAGAAcACAAJAAoACwANAA8AEQATABcAGwAfACMAKwAzADsAQwBTAGMAcwCDAKMAwwDjAAIBAAAAABAQEBAQEBAQERERERISEhITExMTFBQUFBUVFRUQTcoAAQACAAMABAAFAAcACQANABEAGQAhADEAQQBhAIEAwQABAYEBAQIBAwEEAQYBCAEMARABGAEgATABQAFgAAAAABAQEBARERISExMUFBUVFhYXFxgYGRkaGhsbHBwdHUBAAAB+BxAAaQAAAIsAAAAXAAAAfgcQAGkAAACOAAAAFQAAAH4HEABpAAAApgAAAA0AAAB+BxAAaQAAALMAAAAJAAAAfgcQAGkAAAC4AAAAGAAAAH4HEABpAAAAuAAAABMAAAB+BxAAaQAAAPAAAAAJAAAAfgcQAGkAAADwAAAADgAAAH4HEABpAAAA3gAAAA0AAAB+BxAAaQAAAGcAAAAaAAAAfgcQAGkAAABpAAAADQAAAH4HEABpAAAANwAAAA0AQbyDyQALfQEAAABgAgAAuhcQAGEAAAC0AAAAGQAAALoXEABhAAAAdwAAAD4AAABpbnZhbGlkIHNpemUgZm9yIAAAAORBEgARAAAAuhcQAGEAAACCAQAAEQAAACYAAAAdAAAAJgAAACYAAAAmAAAA4MUQAAbGEAAjxhAAScYQAG/GEACAAEHFhMkAC/AHAQAAAAAAAAABAAADAAAABAAAAAEAAAACAAAAAwAAAAQAAAABAAAAAgAAAAMAAAAEAAAAAQAAAAIAAAADAAAABAAAAAEAAAACAAAAAwAAAAQAAAABAAAAAgAAAAMAAAAEAAAAAQAAAAIAAAAJAAAAAAAAAAMAAAAHAAAADgAAAAAAAAAEAAAA8U0RAAAAAAD6TREA/U0RAAROEQAAAAAAEk4RAA8AAAASAAAAFAAAAA4AAAAXAAAAGAAAABYAAAAWAAAAbCcRAHsnEQCNJxEAoScRAK8nEQBUJREAxicRANwnEQANAAAAEQAAABAAAAAeAAAACwAAAAwAAAAXAAAAGAAAABsAAAAWAAAAGAAAABMAAAASAAAAEgAAAA0AAAAKAAAA71YRAPxWEQANVxEAHVcRADtXEQBGVxEAUlcRAGlXEQCBVxEAnFcRALJXEQDKVxEA3VcRAO9XEQABWBEADlgRAAkAAAAAAAAAAwAAAAcAAAAOAAAAAAAAAAQAAADxTREAAAAAAPpNEQD9TREABE4RAAAAAAASThEAAwAAAAMAAAAEAAAABQAAAAcAAADbTREA3k0RAOFNEQDlTREA6k0RAAMAAAADAAAABAAAAAUAAAAHAAAA200RAN5NEQDhTREA5U0RAOpNEQAJAAAAAAAAAAMAAAAHAAAADgAAAAAAAAAEAAAA8U0RAAAAAAD6TREA/U0RAAROEQAAAAAAEk4RAAMAAAAEAAAAAwAAAAQAAAADAAAABAAAAAMAAAADAAAAAwAAAAMAAAADAAAABwAAAAgAAAAEAAAAAwAAAAMAAABI1hEAS9YRAE/WEQBS1hEAVtYRAFnWEQBd1hEAYNYRAGPWEQBm1hEAadYRAGzWEQBz1hEAe9YRAH/WEQCC1hEACAAAAAUAAAALAAAAAAAAAAUAAAAHAAAACQAAAAkAAAAFAAAAEQAAAA4AAAAJAAAAHgAAABsAAAAGAAAABwAAAAcAAAAHAAAAtOARALzgEQAA3BEAAAAAAMHgEQDG4BEAzeARANbgEQDf4BEA5OARAPXgEQAD4READOERACrhEQBF4REAS+ERAFLhEQBZ4REABQAAAAsAAAAAAAAABgAAAAcAAAAFAAAACQAAAAYAAAAGAAAABwAAAAwAAAAGAAAABAAAAAwAAAAMAAAACQAAAAgAAAAJAAAAvOARAADcEQAAAAAA1OURAMbgEQAT3BEA1uARANrlEQDg5REA5uURAO3lEQD55REA/NsRAP/lEQAL5hEAF+YRACDmEQAo5hEABAAAAAsAAAAAAAAABAAAAAQAAAAFAAAABwAAAAsAAAAHAAAAAwAAAAoAAAAKAEHcjMkACzMKAAAA/NsRAADcEQAAAAAAC9wRAA/cEQAT3BEAGNwRAB/cEQAq3BEAMdwRADTcEQA+3BEAQbSNyQAL9QJI3BEACQAAAAAAAAADAAAABwAAAA4AAAAAAAAABAAAAPFNEQAAAAAA+k0RAP1NEQAEThEAAAAAABJOEQADAAAAAwAAAAQAAAAFAAAABwAAANtNEQDeTREA4U0RAOVNEQDqTREADQAAABEAAAAQAAAAHgAAAAsAAAAMAAAAFwAAABgAAAAbAAAAFgAAABgAAAATAAAAEgAAABIAAAANAAAACgAAAO9WEQD8VhEADVcRAB1XEQA7VxEARlcRAFJXEQBpVxEAgVcRAJxXEQCyVxEAylcRAN1XEQDvVxEAAVgRAA5YEQABAAAAAAAAAAMAAAADAAAAAgAAAAAAAAAEAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAIAAAAAAAAABgAAAAIAAAAEAAAAAAAAAAgAAAACAAAABAAAAAQAAAADAAAAAwAAAAMAAAAAAAAAAgAAAAUAAAAFAAAAAAAAAAMAAAADAAAABAAAAAQAAAABAEG0kMkAC18DAAAAAwAAAAIAAAADAAAAAAAAAAMAAAADAAAAAQAAAPNYEQDsWBEA0PIRAA5ZEQDwWBEAAogRAAAAAAAAiBEAAlkRAAuIEQAAAAAA+FgRAAWIEQD+WBEAClkRABJZEQBBnJHJAAuVAfVYEQAHWREAGAsSABNZEQAAAAAA+1gRAAiIEQARWREABQAAAAwAAAALAAAACwAAAAQAAAD81REAAdYRAA3WEQAY1hEAI9YRAAUAAAAMAAAACwAAAAsAAAAEAAAA/NURAAHWEQAN1hEAGNYRACPWEQADAAAACAAAAA8AAAADAAAACAAAAA8AAAADAAAACAAAAA8AAAABAEHAkskACxEDAAAAAAAAAAEAAAAAAAAAAgBB4JLJAAsJBAAAAAAAAAABAEH4kskACxEDAAAAAAAAAAEAAAAAAAAAAgBBmJPJAAsJBAAAAAAAAAABAEGwk8kACxEDAAAAAAAAAAEAAAAAAAAAAgBB0JPJAAsJBAAAAAAAAAABAEHok8kACxEDAAAAAAAAAAEAAAAAAAAAAgBBiJTJAAvtBgQAAAAAAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAEAAAAAAAAAAwAAAAEAAAACAAAAAAAAAAQAAAABAAAAAAAAAAMAAAABAAAAAgAAAAAAAAAEAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAEAAAAAAAAAAwAAAAEAAAACAAAAAAAAAAQAAAABAAAAAAAAAAMAAAABAAAAAgAAAAAAAAAEAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAEAAAAAAAAAAwAAAAEAAAACAAAAAAAAAAQAAAABAAAAAAAAAAMAAAABAAAAAgAAAAAAAAAEAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAMAAAAEAAAAAwAAAAQAAAADAAAABAAAAAMAAAADAAAAAwAAAAMAAAADAAAABwAAAAgAAAAEAAAAAwAAAAMAAABI1hEAS9YRAE/WEQBS1hEAVtYRAFnWEQBd1hEAYNYRAGPWEQBm1hEAadYRAGzWEQBz1hEAe9YRAH/WEQCC1hEAAwAAAAQAAAADAAAABAAAAAMAAAAEAAAAAwAAAAMAAAADAAAAAwAAAAMAAAAHAAAACAAAAAQAAAADAAAAAwAAAEjWEQBL1hEAT9YRAFLWEQBW1hEAWdYRAF3WEQBg1hEAY9YRAGbWEQBp1hEAbNYRAHPWEQB71hEAf9YRAILWEQAIAAAABQAAAAsAAAAAAAAABQAAAAcAAAAJAAAACQAAAAUAAAARAAAADgAAAAkAAAAeAAAAGwAAAAYAAAAHAAAABwAAAAcAAAC04BEAvOARAADcEQAAAAAAweARAMbgEQDN4BEA1uARAN/gEQDk4BEA9eARAAPhEQAM4REAKuERAEXhEQBL4REAUuERAFnhEQAFAAAACwAAAAAAAAAGAAAABwAAAAUAAAAJAAAABgAAAAYAAAAHAAAADAAAAAYAAAAEAAAADAAAAAwAAAAJAAAACAAAAAkAAAC84BEAANwRAAAAAADU5REAxuARABPcEQDW4BEA2uURAODlEQDm5REA7eURAPnlEQD82xEA/+URAAvmEQAX5hEAIOYRACjmEQAEAAAACwAAAAAAAAAEAAAABAAAAAUAAAAHAAAACwAAAAcAAAADAAAACgAAAAoAQZybyQALMwoAAAD82xEAANwRAAAAAAAL3BEAD9wRABPcEQAY3BEAH9wRACrcEQAx3BEANNwRAD7cEQBB9JvJAAu1A0jcEQADAAAABAAAAAMAAAAEAAAAAwAAAAQAAAADAAAAAwAAAAMAAAADAAAAAwAAAAcAAAAIAAAABAAAAAMAAAADAAAASNYRAEvWEQBP1hEAUtYRAFbWEQBZ1hEAXdYRAGDWEQBj1hEAZtYRAGnWEQBs1hEAc9YRAHvWEQB/1hEAgtYRAAMAAAAEAAAAAwAAAAQAAAADAAAABAAAAAMAAAADAAAAAwAAAAMAAAADAAAABwAAAAgAAAAEAAAAAwAAAAMAAABI1hEAS9YRAE/WEQBS1hEAVtYRAFnWEQBd1hEAYNYRAGPWEQBm1hEAadYRAGzWEQBz1hEAe9YRAH/WEQCC1hEADg8QERITFBUYGQAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAYAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAACAAAAAAAAAAQAAAAAAAAABgAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAEAAAAAAAAAABAEG4n8kACxEDAAAAAAAAAAEAAAAAAAAAAgBB2J/JAAtBBAAAAAAAAAABAAAAAAAAAAMAAAABAAAAAgAAAAAAAAAEAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAEAQaigyQALEQMAAAAAAAAAAQAAAAAAAAACAEHIoMkAC9gTBAAAAAAAAAABAAAAAAAAAAMAAAABAAAAAgAAAAAAAAAEAAAAAQAAAAAAAAADAAAAAQAAAAIAAAAAAAAABAAAAAEAAAAAAAAAAwAAAAEAAAACAAAAAAAAAAQAAAAYAAAACAAAAA8AAAAGAAAABAAAAA4AAAANAAAAXtsRAHbbEQB+2xEAjdsRAJPbEQCX2xEApdsRAAgAAAAQAAAAEQAAAA8AAAAPAAAAEgAAABEAAAAMAAAACQAAABAAAAALAAAACgAAAA0AAAAKAAAADQAAAAwAAAARAAAAEgAAAA4AAAAWAAAADAAAAAsAAAAIAAAACQAAAAsAAAALAAAADQAAAAwAAAAMAAAAEgAAAAgAAAAOAAAADAAAAA8AAAATAAAACwAAAAsAAAANAAAACwAAAAoAAAAFAAAADQAAALgDEgDAAxIA0AMSAOEDEgDwAxIA/wMSABEEEgAiBBIALgQSADcEEgBHBBIAUgQSAFwEEgB4AxIAaQQSAHYEEgCCBBIAkwQSAKUEEgCzBBIAyQQSANUEEgDgBBIA6AQSAPEEEgD8BBIABwUSABQFEgAgBRIALAUSAD4FEgBGBRIAVAUSAGAFEgBvBRIAggUSAI0FEgCYBRIApQUSALAFEgC6BRIAvwUSABAAAAARAAAAEgAAABAAAAAQAAAAEwAAABIAAAANAAAADgAAABUAAAAMAAAACwAAABUAAAAVAAAADwAAAA4AAAATAAAAJgAAADgAAAAZAAAAFwAAAAwAAAAJAAAACgAAABAAAAAXAAAADgAAAA4AAAANAAAAFAAAAAgAAAAbAAAADgAAABAAAAAWAAAAFQAAAAsAAAAWAAAADQAAAAsAAAALAAAAEwAAABL+EQAi/hEAM/4RAEX+EQBV/hEAZf4RAHj+EQCK/hEAl/4RAKX+EQC6/hEAxv4RANH+EQDm/hEA+/4RAAr/EQAY/xEAK/8RAFH/EQCJ/xEAov8RALn/EQDF/xEAzv8RANj/EQDo/xEA//8RAA0AEgAbABIAKAASADwAEgBEABIAXwASAG0AEgB9ABIAkwASAKgAEgCzABIAyQASANYAEgDhABIA7AASAAgAAAAQAAAAEQAAAA8AAAAPAAAAEgAAABEAAAAMAAAACQAAABAAAAALAAAACgAAAA0AAAAKAAAADQAAAAwAAAARAAAAEgAAAA4AAAAWAAAADAAAAAsAAAAIAAAACQAAAAsAAAALAAAADQAAAAwAAAAMAAAAEgAAAAgAAAAOAAAADAAAAA8AAAATAAAACwAAAAsAAAANAAAACwAAAAoAAAAFAAAADQAAALgDEgDAAxIA0AMSAOEDEgDwAxIA/wMSABEEEgAiBBIALgQSADcEEgBHBBIAUgQSAFwEEgB4AxIAaQQSAHYEEgCCBBIAkwQSAKUEEgCzBBIAyQQSANUEEgDgBBIA6AQSAPEEEgD8BBIABwUSABQFEgAgBRIALAUSAD4FEgBGBRIAVAUSAGAFEgBvBRIAggUSAI0FEgCYBRIApQUSALAFEgC6BRIAvwUSAAgAAAAQAAAAEQAAAA8AAAAPAAAAEgAAABEAAAAMAAAACQAAABAAAAALAAAACgAAAA0AAAAKAAAADQAAAAwAAAARAAAAEgAAAA4AAAAWAAAADAAAAAsAAAAIAAAACQAAAAsAAAALAAAADQAAAAwAAAAMAAAAEgAAAAgAAAAOAAAADAAAAA8AAAATAAAACwAAAAsAAAANAAAACwAAAAoAAAAFAAAADQAAALgDEgDAAxIA0AMSAOEDEgDwAxIA/wMSABEEEgAiBBIALgQSADcEEgBHBBIAUgQSAFwEEgB4AxIAaQQSAHYEEgCCBBIAkwQSAKUEEgCzBBIAyQQSANUEEgDgBBIA6AQSAPEEEgD8BBIABwUSABQFEgAgBRIALAUSAD4FEgBGBRIAVAUSAGAFEgBvBRIAggUSAI0FEgCYBRIApQUSALAFEgC6BRIAvwUSAMcAAAD8AAAA6QAAAOIAAADkAAAA4AAAAOUAAADnAAAA6gAAAOsAAADoAAAA7wAAAO4AAADsAAAAxAAAAMUAAADJAAAA5gAAAMYAAAD0AAAA9gAAAPIAAAD7AAAA+QAAAP8AAADWAAAA3AAAAKIAAACjAAAApQAAAKcgAACSAQAA4QAAAO0AAADzAAAA+gAAAPEAAADRAAAAqgAAALoAAAC/AAAAECMAAKwAAAC9AAAAvAAAAKEAAACrAAAAuwAAAJElAACSJQAAkyUAAAIlAAAkJQAAYSUAAGIlAABWJQAAVSUAAGMlAABRJQAAVyUAAF0lAABcJQAAWyUAABAlAAAUJQAANCUAACwlAAAcJQAAACUAADwlAABeJQAAXyUAAFolAABUJQAAaSUAAGYlAABgJQAAUCUAAGwlAABnJQAAaCUAAGQlAABlJQAAWSUAAFglAABSJQAAUyUAAGslAABqJQAAGCUAAAwlAACIJQAAhCUAAIwlAACQJQAAgCUAALEDAADfAAAAkwMAAMADAACjAwAAwwMAALUAAADEAwAApgMAAJgDAACpAwAAtAMAAB4iAADGAwAAtQMAACkiAABhIgAAsQAAAGUiAABkIgAAICMAACEjAAD3AAAASCIAALAAAAAZIgAAtwAAABoiAAB/IAAAsgAAAKAlAACgAAAADAAAAAgAAAAIAAAACQAAAAsAAAAFAAAAAgAAAAkAAAAIAAAAuA4SALAOEgCoDhIAnw4SAJQOEgCPDhIAfA4SAH4OEgCHDhIAAAAAPwAAAL84Y+0+2g9JP16Yez/aD8k/aTesMWghIjO0DxQzaCGiM9sPST/bD0m/5MsWQOTLFsAAAAAAAAAAgNsPSUDbD0nAAwAAAAQAAAAEAAAABgAAAIP5ogBETm4A/CkVANFXJwDdNPUAYtvAADyZlQBBkEMAY1H+ALveqwC3YcUAOm4kANJNQgBJBuAACeouAByS0QDrHf4AKbEcAOg+pwD1NYIARLsuAJzphAC0JnAAQX5fANaROQBTgzkAnPQ5AItfhAAo+b0A+B87AN7/lwAPmAUAES/vAApaiwBtH20Az342AAnLJwBGT7cAnmY/AC3qXwC6J3UA5evHAD178QD3OQcAklKKAPtr6gAfsV8ACF2NADADVgB7/EYA8KtrACC8zwA29JoA46kdAF5hkQAIG+YAhZllAKAUXwCNQGgAgNj/ACdzTQAGBjEAylYVAMmocwB74mAAa4zAAAAAAAAAAABA+yH5PwAAAAAtRHQ+AAAAgJhG+DwAAABgUcx4OwAAAICDG/A5AAAAQCAlejgAAACAIoLjNgAAAAAd82k1AACAPwAAwD8AAAAA3M/RNQAAAAAAwBU/AEGgtMkACwEEAHAJcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2VkLWJ5AwVydXN0Yx0xLjkxLjAgKGY4Mjk3ZTM1MSAyMDI1LTEwLTI4KQZ3YWxydXMGMC4yNi4xDHdhc20tYmluZGdlbgcwLjIuMTE3AHQPdGFyZ2V0X2ZlYXR1cmVzBysPbXV0YWJsZS1nbG9iYWxzKxNub250cmFwcGluZy1mcHRvaW50KwdzaW1kMTI4KwtidWxrLW1lbW9yeSsIc2lnbi1leHQrD3JlZmVyZW5jZS10eXBlcysKbXVsdGl2YWx1ZQ==",self.location.href));const A=HQ();(typeof Q=="string"||typeof Request=="function"&&Q instanceof Request||typeof URL=="function"&&Q instanceof URL)&&(Q=fetch(Q));const{instance:I}=await rQ(await Q,A);return xQ(I)}var ag={},PQ=function(Q,A,I,g,B){var C=new Worker(ag[A]||(ag[A]=URL.createObjectURL(new Blob([Q+\';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})\'],{type:"text/javascript"}))));return C.onmessage=function(E){var D=E.data,i=D.$e$;if(i){var o=new Error(i[0]);o.code=i[1],o.stack=i[2],B(o,null)}else B(null,D)},C.postMessage(I,g),C},v=Uint8Array,ZA=Uint16Array,Yg=Int32Array,XI=new v([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),VI=new v([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),Kg=new v([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),tg=function(Q,A){for(var I=new ZA(31),g=0;g<31;++g)I[g]=A+=1<>1|(m&21845)<<1;xA=(xA&52428)>>2|(xA&13107)<<2,xA=(xA&61680)>>4|(xA&3855)<<4,MI[m]=((xA&65280)>>8|(xA&255)<<8)>>1}for(var WA=function(Q,A,I){for(var g=Q.length,B=0,C=new ZA(A);B>i]=o}else for(D=new ZA(g),B=0;B>15-Q[B]);return D},GI=new v(288),m=0;m<144;++m)GI[m]=8;for(var m=144;m<256;++m)GI[m]=9;for(var m=256;m<280;++m)GI[m]=7;for(var m=280;m<288;++m)GI[m]=8;for(var xg=new v(32),m=0;m<32;++m)xg[m]=5;var rg=WA(GI,9,1),ng=WA(xg,5,1),UI=function(Q){for(var A=Q[0],I=1;IA&&(A=Q[I]);return A},hA=function(Q,A,I){var g=A/8|0;return(Q[g]|Q[g+1]<<8)>>(A&7)&I},cI=function(Q,A){var I=A/8|0;return(Q[I]|Q[I+1]<<8|Q[I+2]<<16)>>(A&7)},jI=function(Q){return(Q+7)/8|0},rA=function(Q,A,I){return(A==null||A<0)&&(A=0),(I==null||I>Q.length)&&(I=Q.length),new v(Q.subarray(A,I))},Pg=["unexpected EOF","invalid block type","invalid length/literal","invalid distance","stream finished","no stream handler",,"no callback","invalid UTF-8 data","extra field too long","date not in range 1980-2099","filename too long","stream finishing","invalid zip data"],_=function(Q,A,I){var g=new Error(A||Pg[Q]);if(g.code=Q,Error.captureStackTrace&&Error.captureStackTrace(g,_),!I)throw g;return g},mI=function(Q,A,I,g){var B=Q.length,C=g?g.length:0;if(!B||A.f&&!A.l)return I||new v(0);var E=!I,D=E||A.i!=2,i=A.i;E&&(I=new v(B*3));var o=function(GA){var RA=I.length;if(GA>RA){var kA=new v(Math.max(RA*2,GA));kA.set(I),I=kA}},w=A.f||0,G=A.p||0,R=A.b||0,y=A.l,k=A.d,F=A.m,s=A.n,h=B*8;do{if(!y){w=hA(Q,G,1);var J=hA(Q,G+1,3);if(G+=3,J)if(J==1)y=rg,k=ng,F=9,s=5;else if(J==2){var K=hA(Q,G,31)+257,p=hA(Q,G+10,15)+4,c=K+hA(Q,G+5,31)+1;G+=14;for(var U=new v(c),r=new v(19),a=0;a>4;if(S<16)U[a++]=S;else{var n=0,T=0;for(S==16?(T=3+hA(Q,G,3),G+=2,n=U[a-1]):S==17?(T=3+hA(Q,G,7),G+=3):S==18&&(T=11+hA(Q,G,127),G+=7);T--;)U[a++]=n}}var W=U.subarray(0,K),X=U.subarray(K);F=UI(W),s=UI(X),y=WA(W,F,1),k=WA(X,s,1)}else _(1);else{var S=jI(G)+4,N=Q[S-4]|Q[S-3]<<8,M=S+N;if(M>B){i&&_(0);break}D&&o(R+N),I.set(Q.subarray(S,M),R),A.b=R+=N,A.p=G=M*8,A.f=w;continue}if(G>h){i&&_(0);break}}D&&o(R+131072);for(var z=(1<>4;if(G+=n&15,G>h){i&&_(0);break}if(n||_(2),O<256)I[R++]=O;else if(O==256){u=G,y=null;break}else{var V=O-254;if(O>264){var a=O-257,b=XI[a];V=hA(Q,G,(1<>4;e||_(3),G+=e&15;var X=dg[d];if(d>3){var b=VI[d];X+=cI(Q,G)&(1<h){i&&_(0);break}D&&o(R+131072);var CA=R+V;if(R>>0},uI=function(Q,A){return gA(Q,A)+gA(Q,A+4)*4294967296},XQ=function(Q){(Q[0]!=31||Q[1]!=139||Q[2]!=8)&&_(6,"invalid gzip data");var A=Q[3],I=10;A&4&&(I+=(Q[10]|Q[11]<<8)+2);for(var g=(A>>3&1)+(A>>4&1);g>0;g-=!Q[I++]);return I+(A&2)},zI=function(){function Q(A,I){typeof A=="function"&&(I=A,A={}),this.ondata=I;var g=A&&A.dictionary&&A.dictionary.subarray(-32768);this.s={i:0,b:g?g.length:0},this.o=new v(32768),this.p=new v(0),g&&this.o.set(g)}return Q.prototype.e=function(A){if(this.ondata||_(5),this.d&&_(4),!this.p.length)this.p=A;else if(A.length){var I=new v(this.p.length+A.length);I.set(this.p),I.set(A,this.p.length),this.p=I}},Q.prototype.c=function(A){this.s.i=+(this.d=A||!1);var I=this.s.b,g=mI(this.p,this.s,this.o);this.ondata(rA(g,I,this.s.b),this.d),this.o=rA(g,this.s.b-32768),this.s.b=this.o.length,this.p=rA(this.p,this.s.p/8|0),this.s.p&=7},Q.prototype.push=function(A,I){this.e(A),this.c(I)},Q}();function VQ(Q,A,I){return I||(I=A,A={}),typeof I!="function"&&_(7),TQ(Q,A,[ZQ],function(g){return pg(LI(g.data[0],eg(g.data[1])))},1,I)}function LI(Q,A){return mI(Q,{i:2},A&&A.out,A&&A.dictionary)}var WQ=function(){function Q(A,I){this.v=1,this.r=0,zI.call(this,A,I)}return Q.prototype.push=function(A,I){if(zI.prototype.e.call(this,A),this.r+=A.length,this.v){var g=this.p.subarray(this.v-1),B=g.length>3?XQ(g):4;if(B>g.length){if(!I)return}else this.v>1&&this.onmember&&this.onmember(this.r-g.length);this.p=g.subarray(B),this.v=0}zI.prototype.c.call(this,I),this.s.f&&!this.s.l&&!I&&(this.v=jI(this.s.p)+9,this.s={i:0},this.o=new v(0),this.push(new v(0),I))},Q}(),vI=typeof TextDecoder<"u"&&new TextDecoder;try{vI.decode(eQ,{stream:!0})}catch{}var jQ=function(Q){for(var A="",I=0;;){var g=Q[I++],B=(g>127)+(g>223)+(g>239);if(I+B>Q.length)return{s:A,r:rA(Q,I-1)};B?B==3?(g=((g&15)<<18|(Q[I++]&63)<<12|(Q[I++]&63)<<6|Q[I++]&63)-65536,A+=String.fromCharCode(55296|g>>10,56320|g&1023)):B&1?A+=String.fromCharCode((g&31)<<6|Q[I++]&63):A+=String.fromCharCode((g&15)<<12|(Q[I++]&63)<<6|Q[I++]&63):A+=String.fromCharCode(g)}};function mQ(Q,A){if(A){for(var I="",g=0;g65558)return E(_(13,0,1),null),B;var i=MA(Q,D+8);if(i){var o=i,w=gA(Q,D+16),G=w==4294967295||o==65535;if(G){var R=gA(Q,D-12);G=gA(Q,R)==101075792,G&&(o=i=gA(Q,R+32),w=gA(Q,R+48))}for(var y=A&&A.filter,k=function(s){var h=lg(Q,w,G),J=h[0],S=h[1],N=h[2],M=h[3],K=h[4],p=h[5],c=bg(Q,p);w=K;var U=function(a,H){a?(B(),E(a,null)):(H&&(C[M]=H),--i||E(null,C))};if(!y||y({name:M,size:S,originalSize:N,compression:J}))if(!J)U(null,rA(Q,c,c+S));else if(J==8){var r=Q.subarray(c,c+S);if(N<524288||S>.8*N)try{U(null,LI(r,{out:new v(N)}))}catch(a){U(a,null)}else g.push(VQ(r,{size:N},U))}else U(_(14,"unknown compression type "+J,1),null);else U(null,null)},F=0;F65558)&&_(13);var B=MA(Q,g+8);if(!B)return{};var C=gA(Q,g+16),E=C==4294967295||B==65535;if(E){var D=gA(Q,g-12);E=gA(Q,D)==101075792,E&&(B=gA(Q,D+32),C=gA(Q,D+48))}for(var i=A&&A.filter,o=0;o=0?1:-1,S=1-h*h;if(S>Number.EPSILON){const M=Math.sqrt(S),K=Math.atan2(M,h*J);s=Math.sin(s*K)/M,D=Math.sin(D*K)/M}const N=D*J;if(i=i*s+R*N,o=o*s+y*N,w=w*s+k*N,G=G*s+F*N,s===1-D){const M=1/Math.sqrt(i*i+o*o+w*w+G*G);i*=M,o*=M,w*=M,G*=M}}A[I]=i,A[I+1]=o,A[I+2]=w,A[I+3]=G}static multiplyQuaternionsFlat(A,I,g,B,C,E){const D=g[B],i=g[B+1],o=g[B+2],w=g[B+3],G=C[E],R=C[E+1],y=C[E+2],k=C[E+3];return A[I]=D*k+w*G+i*y-o*R,A[I+1]=i*k+w*R+o*G-D*y,A[I+2]=o*k+w*y+D*R-i*G,A[I+3]=w*k-D*G-i*R-o*y,A}get x(){return this._x}set x(A){this._x=A,this._onChangeCallback()}get y(){return this._y}set y(A){this._y=A,this._onChangeCallback()}get z(){return this._z}set z(A){this._z=A,this._onChangeCallback()}get w(){return this._w}set w(A){this._w=A,this._onChangeCallback()}set(A,I,g,B){return this._x=A,this._y=I,this._z=g,this._w=B,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(A){return this._x=A.x,this._y=A.y,this._z=A.z,this._w=A.w,this._onChangeCallback(),this}setFromEuler(A,I=!0){const g=A._x,B=A._y,C=A._z,E=A._order,D=Math.cos,i=Math.sin,o=D(g/2),w=D(B/2),G=D(C/2),R=i(g/2),y=i(B/2),k=i(C/2);switch(E){case"XYZ":this._x=R*w*G+o*y*k,this._y=o*y*G-R*w*k,this._z=o*w*k+R*y*G,this._w=o*w*G-R*y*k;break;case"YXZ":this._x=R*w*G+o*y*k,this._y=o*y*G-R*w*k,this._z=o*w*k-R*y*G,this._w=o*w*G+R*y*k;break;case"ZXY":this._x=R*w*G-o*y*k,this._y=o*y*G+R*w*k,this._z=o*w*k+R*y*G,this._w=o*w*G-R*y*k;break;case"ZYX":this._x=R*w*G-o*y*k,this._y=o*y*G+R*w*k,this._z=o*w*k-R*y*G,this._w=o*w*G+R*y*k;break;case"YZX":this._x=R*w*G+o*y*k,this._y=o*y*G+R*w*k,this._z=o*w*k-R*y*G,this._w=o*w*G-R*y*k;break;case"XZY":this._x=R*w*G-o*y*k,this._y=o*y*G-R*w*k,this._z=o*w*k+R*y*G,this._w=o*w*G+R*y*k;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+E)}return I===!0&&this._onChangeCallback(),this}setFromAxisAngle(A,I){const g=I/2,B=Math.sin(g);return this._x=A.x*B,this._y=A.y*B,this._z=A.z*B,this._w=Math.cos(g),this._onChangeCallback(),this}setFromRotationMatrix(A){const I=A.elements,g=I[0],B=I[4],C=I[8],E=I[1],D=I[5],i=I[9],o=I[2],w=I[6],G=I[10],R=g+D+G;if(R>0){const y=.5/Math.sqrt(R+1);this._w=.25/y,this._x=(w-i)*y,this._y=(C-o)*y,this._z=(E-B)*y}else if(g>D&&g>G){const y=2*Math.sqrt(1+g-D-G);this._w=(w-i)/y,this._x=.25*y,this._y=(B+E)/y,this._z=(C+o)/y}else if(D>G){const y=2*Math.sqrt(1+D-g-G);this._w=(C-o)/y,this._x=(B+E)/y,this._y=.25*y,this._z=(i+w)/y}else{const y=2*Math.sqrt(1+G-g-D);this._w=(E-B)/y,this._x=(C+o)/y,this._y=(i+w)/y,this._z=.25*y}return this._onChangeCallback(),this}setFromUnitVectors(A,I){let g=A.dot(I)+1;return g<1e-8?(g=0,Math.abs(A.x)>Math.abs(A.z)?(this._x=-A.y,this._y=A.x,this._z=0,this._w=g):(this._x=0,this._y=-A.z,this._z=A.y,this._w=g)):(this._x=A.y*I.z-A.z*I.y,this._y=A.z*I.x-A.x*I.z,this._z=A.x*I.y-A.y*I.x,this._w=g),this.normalize()}angleTo(A){return 2*Math.acos(Math.abs(oA(this.dot(A),-1,1)))}rotateTowards(A,I){const g=this.angleTo(A);if(g===0)return this;const B=Math.min(1,I/g);return this.slerp(A,B),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(A){return this._x*A._x+this._y*A._y+this._z*A._z+this._w*A._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let A=this.length();return A===0?(this._x=0,this._y=0,this._z=0,this._w=1):(A=1/A,this._x=this._x*A,this._y=this._y*A,this._z=this._z*A,this._w=this._w*A),this._onChangeCallback(),this}multiply(A){return this.multiplyQuaternions(this,A)}premultiply(A){return this.multiplyQuaternions(A,this)}multiplyQuaternions(A,I){const g=A._x,B=A._y,C=A._z,E=A._w,D=I._x,i=I._y,o=I._z,w=I._w;return this._x=g*w+E*D+B*o-C*i,this._y=B*w+E*i+C*D-g*o,this._z=C*w+E*o+g*i-B*D,this._w=E*w-g*D-B*i-C*o,this._onChangeCallback(),this}slerp(A,I){if(I===0)return this;if(I===1)return this.copy(A);const g=this._x,B=this._y,C=this._z,E=this._w;let D=E*A._w+g*A._x+B*A._y+C*A._z;if(D<0?(this._w=-A._w,this._x=-A._x,this._y=-A._y,this._z=-A._z,D=-D):this.copy(A),D>=1)return this._w=E,this._x=g,this._y=B,this._z=C,this;const i=1-D*D;if(i<=Number.EPSILON){const y=1-I;return this._w=y*E+I*this._w,this._x=y*g+I*this._x,this._y=y*B+I*this._y,this._z=y*C+I*this._z,this.normalize(),this}const o=Math.sqrt(i),w=Math.atan2(o,D),G=Math.sin((1-I)*w)/o,R=Math.sin(I*w)/o;return this._w=E*G+this._w*R,this._x=g*G+this._x*R,this._y=B*G+this._y*R,this._z=C*G+this._z*R,this._onChangeCallback(),this}slerpQuaternions(A,I,g){return this.copy(A).slerp(I,g)}random(){const A=2*Math.PI*Math.random(),I=2*Math.PI*Math.random(),g=Math.random(),B=Math.sqrt(1-g),C=Math.sqrt(g);return this.set(B*Math.sin(A),B*Math.cos(A),C*Math.sin(I),C*Math.cos(I))}equals(A){return A._x===this._x&&A._y===this._y&&A._z===this._z&&A._w===this._w}fromArray(A,I=0){return this._x=A[I],this._y=A[I+1],this._z=A[I+2],this._w=A[I+3],this._onChangeCallback(),this}toArray(A=[],I=0){return A[I]=this._x,A[I+1]=this._y,A[I+2]=this._z,A[I+3]=this._w,A}fromBufferAttribute(A,I){return this._x=A.getX(I),this._y=A.getY(I),this._z=A.getZ(I),this._w=A.getW(I),this._onChangeCallback(),this}toJSON(){return this.toArray()}_onChange(A){return this._onChangeCallback=A,this}_onChangeCallback(){}*[Symbol.iterator](){yield this._x,yield this._y,yield this._z,yield this._w}}class x{constructor(A=0,I=0,g=0){x.prototype.isVector3=!0,this.x=A,this.y=I,this.z=g}set(A,I,g){return g===void 0&&(g=this.z),this.x=A,this.y=I,this.z=g,this}setScalar(A){return this.x=A,this.y=A,this.z=A,this}setX(A){return this.x=A,this}setY(A){return this.y=A,this}setZ(A){return this.z=A,this}setComponent(A,I){switch(A){case 0:this.x=I;break;case 1:this.y=I;break;case 2:this.z=I;break;default:throw new Error("index is out of range: "+A)}return this}getComponent(A){switch(A){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+A)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(A){return this.x=A.x,this.y=A.y,this.z=A.z,this}add(A){return this.x+=A.x,this.y+=A.y,this.z+=A.z,this}addScalar(A){return this.x+=A,this.y+=A,this.z+=A,this}addVectors(A,I){return this.x=A.x+I.x,this.y=A.y+I.y,this.z=A.z+I.z,this}addScaledVector(A,I){return this.x+=A.x*I,this.y+=A.y*I,this.z+=A.z*I,this}sub(A){return this.x-=A.x,this.y-=A.y,this.z-=A.z,this}subScalar(A){return this.x-=A,this.y-=A,this.z-=A,this}subVectors(A,I){return this.x=A.x-I.x,this.y=A.y-I.y,this.z=A.z-I.z,this}multiply(A){return this.x*=A.x,this.y*=A.y,this.z*=A.z,this}multiplyScalar(A){return this.x*=A,this.y*=A,this.z*=A,this}multiplyVectors(A,I){return this.x=A.x*I.x,this.y=A.y*I.y,this.z=A.z*I.z,this}applyEuler(A){return this.applyQuaternion(Vg.setFromEuler(A))}applyAxisAngle(A,I){return this.applyQuaternion(Vg.setFromAxisAngle(A,I))}applyMatrix3(A){const I=this.x,g=this.y,B=this.z,C=A.elements;return this.x=C[0]*I+C[3]*g+C[6]*B,this.y=C[1]*I+C[4]*g+C[7]*B,this.z=C[2]*I+C[5]*g+C[8]*B,this}applyNormalMatrix(A){return this.applyMatrix3(A).normalize()}applyMatrix4(A){const I=this.x,g=this.y,B=this.z,C=A.elements,E=1/(C[3]*I+C[7]*g+C[11]*B+C[15]);return this.x=(C[0]*I+C[4]*g+C[8]*B+C[12])*E,this.y=(C[1]*I+C[5]*g+C[9]*B+C[13])*E,this.z=(C[2]*I+C[6]*g+C[10]*B+C[14])*E,this}applyQuaternion(A){const I=this.x,g=this.y,B=this.z,C=A.x,E=A.y,D=A.z,i=A.w,o=2*(E*B-D*g),w=2*(D*I-C*B),G=2*(C*g-E*I);return this.x=I+i*o+E*G-D*w,this.y=g+i*w+D*o-C*G,this.z=B+i*G+C*w-E*o,this}project(A){return this.applyMatrix4(A.matrixWorldInverse).applyMatrix4(A.projectionMatrix)}unproject(A){return this.applyMatrix4(A.projectionMatrixInverse).applyMatrix4(A.matrixWorld)}transformDirection(A){const I=this.x,g=this.y,B=this.z,C=A.elements;return this.x=C[0]*I+C[4]*g+C[8]*B,this.y=C[1]*I+C[5]*g+C[9]*B,this.z=C[2]*I+C[6]*g+C[10]*B,this.normalize()}divide(A){return this.x/=A.x,this.y/=A.y,this.z/=A.z,this}divideScalar(A){return this.multiplyScalar(1/A)}min(A){return this.x=Math.min(this.x,A.x),this.y=Math.min(this.y,A.y),this.z=Math.min(this.z,A.z),this}max(A){return this.x=Math.max(this.x,A.x),this.y=Math.max(this.y,A.y),this.z=Math.max(this.z,A.z),this}clamp(A,I){return this.x=oA(this.x,A.x,I.x),this.y=oA(this.y,A.y,I.y),this.z=oA(this.z,A.z,I.z),this}clampScalar(A,I){return this.x=oA(this.x,A,I),this.y=oA(this.y,A,I),this.z=oA(this.z,A,I),this}clampLength(A,I){const g=this.length();return this.divideScalar(g||1).multiplyScalar(oA(g,A,I))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this.z=Math.trunc(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(A){return this.x*A.x+this.y*A.y+this.z*A.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(A){return this.normalize().multiplyScalar(A)}lerp(A,I){return this.x+=(A.x-this.x)*I,this.y+=(A.y-this.y)*I,this.z+=(A.z-this.z)*I,this}lerpVectors(A,I,g){return this.x=A.x+(I.x-A.x)*g,this.y=A.y+(I.y-A.y)*g,this.z=A.z+(I.z-A.z)*g,this}cross(A){return this.crossVectors(this,A)}crossVectors(A,I){const g=A.x,B=A.y,C=A.z,E=I.x,D=I.y,i=I.z;return this.x=B*i-C*D,this.y=C*E-g*i,this.z=g*D-B*E,this}projectOnVector(A){const I=A.lengthSq();if(I===0)return this.set(0,0,0);const g=A.dot(this)/I;return this.copy(A).multiplyScalar(g)}projectOnPlane(A){return Ag.copy(this).projectOnVector(A),this.sub(Ag)}reflect(A){return this.sub(Ag.copy(A).multiplyScalar(2*this.dot(A)))}angleTo(A){const I=Math.sqrt(this.lengthSq()*A.lengthSq());if(I===0)return Math.PI/2;const g=this.dot(A)/I;return Math.acos(oA(g,-1,1))}distanceTo(A){return Math.sqrt(this.distanceToSquared(A))}distanceToSquared(A){const I=this.x-A.x,g=this.y-A.y,B=this.z-A.z;return I*I+g*g+B*B}manhattanDistanceTo(A){return Math.abs(this.x-A.x)+Math.abs(this.y-A.y)+Math.abs(this.z-A.z)}setFromSpherical(A){return this.setFromSphericalCoords(A.radius,A.phi,A.theta)}setFromSphericalCoords(A,I,g){const B=Math.sin(I)*A;return this.x=B*Math.sin(g),this.y=Math.cos(I)*A,this.z=B*Math.cos(g),this}setFromCylindrical(A){return this.setFromCylindricalCoords(A.radius,A.theta,A.y)}setFromCylindricalCoords(A,I,g){return this.x=A*Math.sin(I),this.y=g,this.z=A*Math.cos(I),this}setFromMatrixPosition(A){const I=A.elements;return this.x=I[12],this.y=I[13],this.z=I[14],this}setFromMatrixScale(A){const I=this.setFromMatrixColumn(A,0).length(),g=this.setFromMatrixColumn(A,1).length(),B=this.setFromMatrixColumn(A,2).length();return this.x=I,this.y=g,this.z=B,this}setFromMatrixColumn(A,I){return this.fromArray(A.elements,I*4)}setFromMatrix3Column(A,I){return this.fromArray(A.elements,I*3)}setFromEuler(A){return this.x=A._x,this.y=A._y,this.z=A._z,this}setFromColor(A){return this.x=A.r,this.y=A.g,this.z=A.b,this}equals(A){return A.x===this.x&&A.y===this.y&&A.z===this.z}fromArray(A,I=0){return this.x=A[I],this.y=A[I+1],this.z=A[I+2],this}toArray(A=[],I=0){return A[I]=this.x,A[I+1]=this.y,A[I+2]=this.z,A}fromBufferAttribute(A,I){return this.x=A.getX(I),this.y=A.getY(I),this.z=A.getZ(I),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){const A=Math.random()*Math.PI*2,I=Math.random()*2-1,g=Math.sqrt(1-I*I);return this.x=g*Math.cos(A),this.y=I,this.z=g*Math.sin(A),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}}const Ag=new x,Vg=new nA;class oI{constructor(A,I,g,B,C,E,D,i,o){oI.prototype.isMatrix3=!0,this.elements=[1,0,0,0,1,0,0,0,1],A!==void 0&&this.set(A,I,g,B,C,E,D,i,o)}set(A,I,g,B,C,E,D,i,o){const w=this.elements;return w[0]=A,w[1]=B,w[2]=D,w[3]=I,w[4]=C,w[5]=i,w[6]=g,w[7]=E,w[8]=o,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(A){const I=this.elements,g=A.elements;return I[0]=g[0],I[1]=g[1],I[2]=g[2],I[3]=g[3],I[4]=g[4],I[5]=g[5],I[6]=g[6],I[7]=g[7],I[8]=g[8],this}extractBasis(A,I,g){return A.setFromMatrix3Column(this,0),I.setFromMatrix3Column(this,1),g.setFromMatrix3Column(this,2),this}setFromMatrix4(A){const I=A.elements;return this.set(I[0],I[4],I[8],I[1],I[5],I[9],I[2],I[6],I[10]),this}multiply(A){return this.multiplyMatrices(this,A)}premultiply(A){return this.multiplyMatrices(A,this)}multiplyMatrices(A,I){const g=A.elements,B=I.elements,C=this.elements,E=g[0],D=g[3],i=g[6],o=g[1],w=g[4],G=g[7],R=g[2],y=g[5],k=g[8],F=B[0],s=B[3],h=B[6],J=B[1],S=B[4],N=B[7],M=B[2],K=B[5],p=B[8];return C[0]=E*F+D*J+i*M,C[3]=E*s+D*S+i*K,C[6]=E*h+D*N+i*p,C[1]=o*F+w*J+G*M,C[4]=o*s+w*S+G*K,C[7]=o*h+w*N+G*p,C[2]=R*F+y*J+k*M,C[5]=R*s+y*S+k*K,C[8]=R*h+y*N+k*p,this}multiplyScalar(A){const I=this.elements;return I[0]*=A,I[3]*=A,I[6]*=A,I[1]*=A,I[4]*=A,I[7]*=A,I[2]*=A,I[5]*=A,I[8]*=A,this}determinant(){const A=this.elements,I=A[0],g=A[1],B=A[2],C=A[3],E=A[4],D=A[5],i=A[6],o=A[7],w=A[8];return I*E*w-I*D*o-g*C*w+g*D*i+B*C*o-B*E*i}invert(){const A=this.elements,I=A[0],g=A[1],B=A[2],C=A[3],E=A[4],D=A[5],i=A[6],o=A[7],w=A[8],G=w*E-D*o,R=D*i-w*C,y=o*C-E*i,k=I*G+g*R+B*y;if(k===0)return this.set(0,0,0,0,0,0,0,0,0);const F=1/k;return A[0]=G*F,A[1]=(B*o-w*g)*F,A[2]=(D*g-B*E)*F,A[3]=R*F,A[4]=(w*I-B*i)*F,A[5]=(B*C-D*I)*F,A[6]=y*F,A[7]=(g*i-o*I)*F,A[8]=(E*I-g*C)*F,this}transpose(){let A;const I=this.elements;return A=I[1],I[1]=I[3],I[3]=A,A=I[2],I[2]=I[6],I[6]=A,A=I[5],I[5]=I[7],I[7]=A,this}getNormalMatrix(A){return this.setFromMatrix4(A).invert().transpose()}transposeIntoArray(A){const I=this.elements;return A[0]=I[0],A[1]=I[3],A[2]=I[6],A[3]=I[1],A[4]=I[4],A[5]=I[7],A[6]=I[2],A[7]=I[5],A[8]=I[8],this}setUvTransform(A,I,g,B,C,E,D){const i=Math.cos(C),o=Math.sin(C);return this.set(g*i,g*o,-g*(i*E+o*D)+E+A,-B*o,B*i,-B*(-o*E+i*D)+D+I,0,0,1),this}scale(A,I){return this.premultiply(Ig.makeScale(A,I)),this}rotate(A){return this.premultiply(Ig.makeRotation(-A)),this}translate(A,I){return this.premultiply(Ig.makeTranslation(A,I)),this}makeTranslation(A,I){return A.isVector2?this.set(1,0,A.x,0,1,A.y,0,0,1):this.set(1,0,A,0,1,I,0,0,1),this}makeRotation(A){const I=Math.cos(A),g=Math.sin(A);return this.set(I,-g,0,g,I,0,0,0,1),this}makeScale(A,I){return this.set(A,0,0,0,I,0,0,0,1),this}equals(A){const I=this.elements,g=A.elements;for(let B=0;B<9;B++)if(I[B]!==g[B])return!1;return!0}fromArray(A,I=0){for(let g=0;g<9;g++)this.elements[g]=A[g+I];return this}toArray(A=[],I=0){const g=this.elements;return A[I]=g[0],A[I+1]=g[1],A[I+2]=g[2],A[I+3]=g[3],A[I+4]=g[4],A[I+5]=g[5],A[I+6]=g[6],A[I+7]=g[7],A[I+8]=g[8],A}clone(){return new this.constructor().fromArray(this.elements)}}const Ig=new oI,Wg={};function jg(Q){Q in Wg||(Wg[Q]=!0,console.warn(Q))}const mg=new oI().set(.4123908,.3575843,.1804808,.212639,.7151687,.0721923,.0193308,.1191948,.9505322),ug=new oI().set(3.2409699,-1.5373832,-.4986108,-.9692436,1.8759675,.0415551,.0556301,-.203977,1.0569715);function AB(){const Q={enabled:!0,workingColorSpace:Tg,spaces:{},convert:function(B,C,E){return this.enabled===!1||C===E||!C||!E||(this.spaces[C].transfer===_I&&(B.r=jA(B.r),B.g=jA(B.g),B.b=jA(B.b)),this.spaces[C].primaries!==this.spaces[E].primaries&&(B.applyMatrix3(this.spaces[C].toXYZ),B.applyMatrix3(this.spaces[E].fromXYZ)),this.spaces[E].transfer===_I&&(B.r=mA(B.r),B.g=mA(B.g),B.b=mA(B.b))),B},workingToColorSpace:function(B,C){return this.convert(B,this.workingColorSpace,C)},colorSpaceToWorking:function(B,C){return this.convert(B,C,this.workingColorSpace)},getPrimaries:function(B){return this.spaces[B].primaries},getTransfer:function(B){return B===_Q?Xg:this.spaces[B].transfer},getToneMappingMode:function(B){return this.spaces[B].outputColorSpaceConfig.toneMappingMode||"standard"},getLuminanceCoefficients:function(B,C=this.workingColorSpace){return B.fromArray(this.spaces[C].luminanceCoefficients)},define:function(B){Object.assign(this.spaces,B)},_getMatrix:function(B,C,E){return B.copy(this.spaces[C].toXYZ).multiply(this.spaces[E].fromXYZ)},_getDrawingBufferColorSpace:function(B){return this.spaces[B].outputColorSpaceConfig.drawingBufferColorSpace},_getUnpackColorSpace:function(B=this.workingColorSpace){return this.spaces[B].workingColorSpaceConfig.unpackColorSpace},fromWorkingColorSpace:function(B,C){return jg("THREE.ColorManagement: .fromWorkingColorSpace() has been renamed to .workingToColorSpace()."),Q.workingToColorSpace(B,C)},toWorkingColorSpace:function(B,C){return jg("THREE.ColorManagement: .toWorkingColorSpace() has been renamed to .colorSpaceToWorking()."),Q.colorSpaceToWorking(B,C)}},A=[.64,.33,.3,.6,.15,.06],I=[.2126,.7152,.0722],g=[.3127,.329];return Q.define({[Tg]:{primaries:A,whitePoint:g,transfer:Xg,toXYZ:mg,fromXYZ:ug,luminanceCoefficients:I,workingColorSpaceConfig:{unpackColorSpace:UA},outputColorSpaceConfig:{drawingBufferColorSpace:UA}},[UA]:{primaries:A,whitePoint:g,transfer:_I,toXYZ:mg,fromXYZ:ug,luminanceCoefficients:I,outputColorSpaceConfig:{drawingBufferColorSpace:UA}}}),Q}const cA=AB();function jA(Q){return Q<.04045?Q*.0773993808:Math.pow(Q*.9478672986+.0521327014,2.4)}function mA(Q){return Q<.0031308?Q*12.92:1.055*Math.pow(Q,.41666)-.055}class zg{constructor(A=new x(1/0,1/0,1/0),I=new x(-1/0,-1/0,-1/0)){this.isBox3=!0,this.min=A,this.max=I}set(A,I){return this.min.copy(A),this.max.copy(I),this}setFromArray(A){this.makeEmpty();for(let I=0,g=A.length;I=this.min.x&&A.x<=this.max.x&&A.y>=this.min.y&&A.y<=this.max.y&&A.z>=this.min.z&&A.z<=this.max.z}containsBox(A){return this.min.x<=A.min.x&&A.max.x<=this.max.x&&this.min.y<=A.min.y&&A.max.y<=this.max.y&&this.min.z<=A.min.z&&A.max.z<=this.max.z}getParameter(A,I){return I.set((A.x-this.min.x)/(this.max.x-this.min.x),(A.y-this.min.y)/(this.max.y-this.min.y),(A.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(A){return A.max.x>=this.min.x&&A.min.x<=this.max.x&&A.max.y>=this.min.y&&A.min.y<=this.max.y&&A.max.z>=this.min.z&&A.min.z<=this.max.z}intersectsSphere(A){return this.clampPoint(A.center,HA),HA.distanceToSquared(A.center)<=A.radius*A.radius}intersectsPlane(A){let I,g;return A.normal.x>0?(I=A.normal.x*this.min.x,g=A.normal.x*this.max.x):(I=A.normal.x*this.max.x,g=A.normal.x*this.min.x),A.normal.y>0?(I+=A.normal.y*this.min.y,g+=A.normal.y*this.max.y):(I+=A.normal.y*this.max.y,g+=A.normal.y*this.min.y),A.normal.z>0?(I+=A.normal.z*this.min.z,g+=A.normal.z*this.max.z):(I+=A.normal.z*this.max.z,g+=A.normal.z*this.min.z),I<=-A.constant&&g>=-A.constant}intersectsTriangle(A){if(this.isEmpty())return!1;this.getCenter(yI),YI.subVectors(this.max,yI),uA.subVectors(A.a,yI),zA.subVectors(A.b,yI),vA.subVectors(A.c,yI),PA.subVectors(zA,uA),fA.subVectors(vA,zA),TA.subVectors(uA,vA);let I=[0,-PA.z,PA.y,0,-fA.z,fA.y,0,-TA.z,TA.y,PA.z,0,-PA.x,fA.z,0,-fA.x,TA.z,0,-TA.x,-PA.y,PA.x,0,-fA.y,fA.x,0,-TA.y,TA.x,0];return!gg(I,uA,zA,vA,YI)||(I=[1,0,0,0,1,0,0,0,1],!gg(I,uA,zA,vA,YI))?!1:(KI.crossVectors(PA,fA),I=[KI.x,KI.y,KI.z],gg(I,uA,zA,vA,YI))}clampPoint(A,I){return I.copy(A).clamp(this.min,this.max)}distanceToPoint(A){return this.clampPoint(A,HA).distanceTo(A)}getBoundingSphere(A){return this.isEmpty()?A.makeEmpty():(this.getCenter(A.center),A.radius=this.getSize(HA).length()*.5),A}intersect(A){return this.min.max(A.min),this.max.min(A.max),this.isEmpty()&&this.makeEmpty(),this}union(A){return this.min.min(A.min),this.max.max(A.max),this}applyMatrix4(A){return this.isEmpty()?this:(tA[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(A),tA[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(A),tA[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(A),tA[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(A),tA[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(A),tA[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(A),tA[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(A),tA[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(A),this.setFromPoints(tA),this)}translate(A){return this.min.add(A),this.max.add(A),this}equals(A){return A.min.equals(this.min)&&A.max.equals(this.max)}toJSON(){return{min:this.min.toArray(),max:this.max.toArray()}}fromJSON(A){return this.min.fromArray(A.min),this.max.fromArray(A.max),this}}const tA=[new x,new x,new x,new x,new x,new x,new x,new x],HA=new x,aI=new zg,uA=new x,zA=new x,vA=new x,PA=new x,fA=new x,TA=new x,yI=new x,YI=new x,KI=new x,XA=new x;function gg(Q,A,I,g,B){for(let C=0,E=Q.length-3;C<=E;C+=3){XA.fromArray(Q,C);const D=B.x*Math.abs(XA.x)+B.y*Math.abs(XA.y)+B.z*Math.abs(XA.z),i=A.dot(XA),o=I.dot(XA),w=g.dot(XA);if(Math.max(-Math.max(i,o,w),Math.min(i,o,w))>D)return!1}return!0}const vg={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},pA={h:0,s:0,l:0},tI={h:0,s:0,l:0};function Qg(Q,A,I){return I<0&&(I+=1),I>1&&(I-=1),I<1/6?Q+(A-Q)*6*I:I<1/2?A:I<2/3?Q+(A-Q)*6*(2/3-I):Q}class Bg{constructor(A,I,g){return this.isColor=!0,this.r=1,this.g=1,this.b=1,this.set(A,I,g)}set(A,I,g){if(I===void 0&&g===void 0){const B=A;B&&B.isColor?this.copy(B):typeof B=="number"?this.setHex(B):typeof B=="string"&&this.setStyle(B)}else this.setRGB(A,I,g);return this}setScalar(A){return this.r=A,this.g=A,this.b=A,this}setHex(A,I=UA){return A=Math.floor(A),this.r=(A>>16&255)/255,this.g=(A>>8&255)/255,this.b=(A&255)/255,cA.colorSpaceToWorking(this,I),this}setRGB(A,I,g,B=cA.workingColorSpace){return this.r=A,this.g=I,this.b=g,cA.colorSpaceToWorking(this,B),this}setHSL(A,I,g,B=cA.workingColorSpace){if(A=$Q(A,1),I=oA(I,0,1),g=oA(g,0,1),I===0)this.r=this.g=this.b=g;else{const C=g<=.5?g*(1+I):g+I-g*I,E=2*g-C;this.r=Qg(E,C,A+1/3),this.g=Qg(E,C,A),this.b=Qg(E,C,A-1/3)}return cA.colorSpaceToWorking(this,B),this}setStyle(A,I=UA){function g(C){C!==void 0&&parseFloat(C)<1&&console.warn("THREE.Color: Alpha component of "+A+" will be ignored.")}let B;if(B=/^(\\w+)\\(([^\\)]*)\\)/.exec(A)){let C;const E=B[1],D=B[2];switch(E){case"rgb":case"rgba":if(C=/^\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*(?:,\\s*(\\d*\\.?\\d+)\\s*)?$/.exec(D))return g(C[4]),this.setRGB(Math.min(255,parseInt(C[1],10))/255,Math.min(255,parseInt(C[2],10))/255,Math.min(255,parseInt(C[3],10))/255,I);if(C=/^\\s*(\\d+)\\%\\s*,\\s*(\\d+)\\%\\s*,\\s*(\\d+)\\%\\s*(?:,\\s*(\\d*\\.?\\d+)\\s*)?$/.exec(D))return g(C[4]),this.setRGB(Math.min(100,parseInt(C[1],10))/100,Math.min(100,parseInt(C[2],10))/100,Math.min(100,parseInt(C[3],10))/100,I);break;case"hsl":case"hsla":if(C=/^\\s*(\\d*\\.?\\d+)\\s*,\\s*(\\d*\\.?\\d+)\\%\\s*,\\s*(\\d*\\.?\\d+)\\%\\s*(?:,\\s*(\\d*\\.?\\d+)\\s*)?$/.exec(D))return g(C[4]),this.setHSL(parseFloat(C[1])/360,parseFloat(C[2])/100,parseFloat(C[3])/100,I);break;default:console.warn("THREE.Color: Unknown color model "+A)}}else if(B=/^\\#([A-Fa-f\\d]+)$/.exec(A)){const C=B[1],E=C.length;if(E===3)return this.setRGB(parseInt(C.charAt(0),16)/15,parseInt(C.charAt(1),16)/15,parseInt(C.charAt(2),16)/15,I);if(E===6)return this.setHex(parseInt(C,16),I);console.warn("THREE.Color: Invalid hex color "+A)}else if(A&&A.length>0)return this.setColorName(A,I);return this}setColorName(A,I=UA){const g=vg[A.toLowerCase()];return g!==void 0?this.setHex(g,I):console.warn("THREE.Color: Unknown color "+A),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(A){return this.r=A.r,this.g=A.g,this.b=A.b,this}copySRGBToLinear(A){return this.r=jA(A.r),this.g=jA(A.g),this.b=jA(A.b),this}copyLinearToSRGB(A){return this.r=mA(A.r),this.g=mA(A.g),this.b=mA(A.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(A=UA){return cA.workingToColorSpace(BA.copy(this),A),Math.round(oA(BA.r*255,0,255))*65536+Math.round(oA(BA.g*255,0,255))*256+Math.round(oA(BA.b*255,0,255))}getHexString(A=UA){return("000000"+this.getHex(A).toString(16)).slice(-6)}getHSL(A,I=cA.workingColorSpace){cA.workingToColorSpace(BA.copy(this),I);const g=BA.r,B=BA.g,C=BA.b,E=Math.max(g,B,C),D=Math.min(g,B,C);let i,o;const w=(D+E)/2;if(D===E)i=0,o=0;else{const G=E-D;switch(o=w<=.5?G/(E+D):G/(2-E-D),E){case g:i=(B-C)/G+(B(Q.PLY="ply",Q.SPZ="spz",Q.SPLAT="splat",Q.KSPLAT="ksplat",Q.PCSOGS="pcsogs",Q.PCSOGSZIP="pcsogszip",Q.RAD="rad",Q))(wA||{});function QB(Q){var C;let A=!1;const I=Q.split(`\n`).map(E=>{const D=E.trimEnd();return A?D:D.length>0?(A=!0,D):null}).filter(E=>E!=null);for(;I.length>0&&I[I.length-1].length===0;)I.pop();if(I.length===0)return[];const g=(C=I[0].match(/^\\s*/))==null?void 0:C[0];if(!g)return I;const B=new RegExp(`^${g}`);return I.map(E=>E.replace(B,""))}function BB(Q){return QB(Q).join(`\n`)}const Cg=new Float32Array(1),QQ=new Uint32Array(Cg.buffer),Eg="Float16Array"in globalThis,RI=Eg?new globalThis.Float16Array(1):null,BQ=new Uint16Array(RI==null?void 0:RI.buffer);function CB(Q){const A=Math.sqrt(Q.reduce((I,g)=>I+g*g,0));return Q.map(I=>I/A)}const $A=Eg?EB:DB,AA=Eg?iB:wB;function EB(Q){return RI[0]=Q,BQ[0]}function DB(Q){Cg[0]=Q;const A=QQ[0],I=A>>31&1,g=A>>23&255,B=A&8388607,C=I<<15;if(g===255)return B!==0?C|32767:C|31744;const E=g-127+15;if(E>=31)return C|31744;if(E<=0){if(E<-10)return C;const i=(B|8388608)>>1-E+13;return C|i}const D=B>>13;return C|E<<10|D}function iB(Q){return BQ[0]=Q,RI[0]}function wB(Q){const A=Q>>15&1,I=Q>>10&31,g=Q&1023;let B;if(I===0)if(g===0)B=A<<31;else{let C=g,E=-14;for(;(C&1024)===0;)C<<=1,E--;C&=1023;const D=E+127,i=C<<13;B=A<<31|D<<23|i}else if(I===31)g===0?B=A<<31|2139095040:B=A<<31|2143289344;else{const C=I-15+127,E=g<<13;B=A<<31|C<<23|E}return QQ[0]=B,Cg[0]}function SA(Q){return Math.max(0,Math.min(255,Math.round(Q*255)))}function GB(Q){const A=[],I=new Set;function g(B){B&&typeof B=="object"&&!I.has(B)&&(I.add(B),B instanceof ArrayBuffer?A.push(B):ArrayBuffer.isView(B)?A.push(B.buffer):Array.isArray(B)?B.forEach(g):Object.values(B).forEach(g))}return g(Q),A}function Dg(Q,A,I,g,B,C,E,D,i,o,w,G,R,y,k,F,s){const h=(s==null?void 0:s.rgbMin)??0,S=((s==null?void 0:s.rgbMax)??1)-h,N=SA((y-h)/S),M=SA((k-h)/S),K=SA((F-h)/S),p=SA(s!=null&&s.lodOpacity?.5*R:R),c=GQ(DQ.set(i,o,w,G)),U=c&255,r=c>>>8&255,a=c>>>16&255,H=(s==null?void 0:s.lnScaleMin)??_g,t=254/(((s==null?void 0:s.lnScaleMax)??$g)-H),Y=C<_A?0:Math.min(255,Math.max(1,Math.round((Math.log(C)-H)*t)+1)),n=E<_A?0:Math.min(255,Math.max(1,Math.round((Math.log(E)-H)*t)+1)),T=D<_A?0:Math.min(255,Math.max(1,Math.round((Math.log(D)-H)*t)+1)),W=$A(I),X=$A(g),z=$A(B),j=A*4;Q[j]=N|M<<8|K<<16|p<<24,Q[j+1]=W|X<<16,Q[j+2]=z|U<<16|r<<24,Q[j+3]=Y|n<<8|T<<16|a<<24}function CQ(Q,A,I,g,B){const C=$A(I),E=$A(g),D=$A(B),i=A*4;Q[i+1]=C|E<<16,Q[i+2]=D|Q[i+2]&4294901760}function EQ(Q,A,I,g,B,C){const E=(C==null?void 0:C.lnScaleMin)??_g,i=254/(((C==null?void 0:C.lnScaleMax)??$g)-E),o=I<_A?0:Math.min(255,Math.max(1,Math.round((Math.log(I)-E)*i)+1)),w=g<_A?0:Math.min(255,Math.max(1,Math.round((Math.log(g)-E)*i)+1)),G=B<_A?0:Math.min(255,Math.max(1,Math.round((Math.log(B)-E)*i)+1)),R=A*4;Q[R+3]=o|w<<8|G<<16|Q[R+3]&4278190080}const DQ=new nA;function iQ(Q,A,I,g,B,C){const E=GQ(DQ.set(I,g,B,C)),D=E&255,i=E>>>8&255,o=E>>>16&255,w=A*4;Q[w+2]=Q[w+2]&65535|D<<16|i<<24,Q[w+3]=Q[w+3]&16777215|o<<24}function oB(Q,A,I,g,B,C,E){const D=(E==null?void 0:E.rgbMin)??0,o=((E==null?void 0:E.rgbMax)??1)-D,w=SA((I-D)/o),G=SA((g-D)/o),R=SA((B-D)/o),y=SA(E!=null&&E.lodOpacity?.5*C:C),k=A*4;Q[k]=w|G<<8|R<<16|y<<24}function yB(Q,A,I,g,B,C){const E=(C==null?void 0:C.rgbMin)??0,i=((C==null?void 0:C.rgbMax)??1)-E,o=SA((I-E)/i),w=SA((g-E)/i),G=SA((B-E)/i),R=A*4;Q[R]=o|w<<8|G<<16|Q[R]&4278190080}function RB(Q,A,I){const g=SA(I),B=A*4;Q[B]=Q[B]&16777215|g<<24}new x,new x,new Bg;function kB(Q){const A=AQ,I=Math.max(gQ,Math.min(IQ,Math.ceil(Q/A))),g=Math.ceil(Q/(A*I)),B=A*I*g;return{width:A,height:I,depth:g,maxSplats:B}}function qI(Q){const A=AQ,I=Math.max(gQ,Math.min(IQ,Math.ceil(Q/A))),g=Math.ceil(Q/(A*I));return A*I*g}BB(`\n precision highp float;\n\n in vec3 position;\n\n void main() {\n gl_Position = vec4(position.xy, 0.0, 1.0);\n }\n`);const FB=new nA,wQ=new x;function GQ(Q){const A=FB.copy(Q).normalize();A.w<0&&A.set(-A.x,-A.y,-A.z,-A.w);const I=2*Math.acos(A.w),g=Math.sqrt(A.x*A.x+A.y*A.y+A.z*A.z),B=g<1e-6?wQ.set(1,0,0):wQ.set(A.x,A.y,A.z).divideScalar(g),C=Math.abs(B.x)+Math.abs(B.y)+Math.abs(B.z);let E=B.x/C,D=B.y/C;if(B.z<0){const y=E;E=(1-Math.abs(D))*(E>=0?1:-1),D=(1-Math.abs(y))*(D>=0?1:-1)}const i=E*.5+.5,o=D*.5+.5,w=Math.round(i*255),G=Math.round(o*255);return Math.round(I*(255/Math.PI))<<16|G<<8|w}function dI(Q,A,I,g){const B=Math.round(Math.max(-127,Math.min(127,Q*127))),C=Math.round(Math.max(-127,Math.min(127,A*127))),E=Math.round(Math.max(-127,Math.min(127,I*127))),D=Math.round(Math.max(-127,Math.min(127,g*127)));return B&255|(C&255)<<8|(E&255)<<16|(D&255)<<24}function xI(Q,A,I,g){const C=63/((g==null?void 0:g.sh1Max)??1),E=A*2;for(let D=0;D<9;++D){const i=I[D]*C,o=Math.round(Math.max(-63,Math.min(63,i)))&127,w=D*7,G=w+7,R=Math.floor(w/32),y=w-R*32,k=o<R*32+32){const F=o>>>32-y&4294967295;Q[E+R+1]|=F}}}function rI(Q,A,I,g){const C=1/((g==null?void 0:g.sh2Max)??1);Q[A*4+0]=dI(I[0]*C,I[1]*C,I[2]*C,I[3]*C),Q[A*4+1]=dI(I[4]*C,I[5]*C,I[6]*C,I[7]*C),Q[A*4+2]=dI(I[8]*C,I[9]*C,I[10]*C,I[11]*C),Q[A*4+3]=dI(I[12]*C,I[13]*C,I[14]*C,0)}function nI(Q,A,I,g){const C=31/((g==null?void 0:g.sh3Max)??1),E=A*4;for(let D=0;D<21;++D){const i=I[D]*C,o=Math.round(Math.max(-31,Math.min(31,i)))&63,w=D*6,G=w+6,R=Math.floor(w/32),y=w-R*32,k=o<R*32+32){const F=o>>>32-y&4294967295;Q[E+R+1]|=F}}}function hB(Q,A){const I=[];let g=0,B=null;const C=new WQ((i,o)=>{if(I.push(i),g+=i.length,o||g>=A){const w=new Uint8Array(g);let G=0;for(const R of I)w.set(R,G),G+=R.length;B=w.slice(0,A)}}),E=1024;let D=0;for(;B==null&&D{I=C,g=qI(I),B=new Uint32Array(g*4)},(C,E,D,i,o,w,G,R,y,k,F,s,h,J,S)=>{Dg(B,C,E,D,i,o,w,G,R,y,k,F,s,h,J,S,A)}),{packedArray:B,numSplats:I}}const PI={0:{bytesPerCenter:12,bytesPerScale:12,bytesPerRotation:16,bytesPerColor:4,bytesPerSphericalHarmonicsComponent:4,scaleOffsetBytes:12,rotationOffsetBytes:24,colorOffsetBytes:40,sphericalHarmonicsOffsetBytes:44,scaleRange:1},1:{bytesPerCenter:6,bytesPerScale:6,bytesPerRotation:8,bytesPerColor:4,bytesPerSphericalHarmonicsComponent:2,scaleOffsetBytes:6,rotationOffsetBytes:12,colorOffsetBytes:20,sphericalHarmonicsOffsetBytes:24,scaleRange:32767},2:{bytesPerCenter:6,bytesPerScale:6,bytesPerRotation:8,bytesPerColor:4,bytesPerSphericalHarmonicsComponent:1,scaleOffsetBytes:6,rotationOffsetBytes:12,colorOffsetBytes:20,sphericalHarmonicsOffsetBytes:24,scaleRange:32767}},yQ={0:0,1:9,2:24,3:45};function NB(Q,A,I,g){var F;let E=0;const D=new DataView(Q.buffer,E,4096);E+=4096;const i=D.getUint8(0),o=D.getUint8(1);if(i!==0||o<1)throw new Error(`Unsupported .ksplat version: ${i}.${o}`);const w=D.getUint32(4,!0);D.getUint32(16,!0);const G=D.getUint16(20,!0);if(G<0||G>2)throw new Error(`Invalid .ksplat compression level: ${G}`);const R=D.getFloat32(36,!0)||-1.5,y=D.getFloat32(40,!0)||1.5;let k=4096+w*1024;for(let s=0;s=1?new Float32Array(3*3):void 0,kA=Y>=2?new Float32Array(5*3):void 0,qA=Y>=3?new Float32Array(7*3):void 0,FA=p/2/U,sA=k+q,NA=k+t,P=new DataView(Q.buffer,NA,d),DA=new Float32Array(Q.buffer,sA,K*3),$=new Uint32Array(Q.buffer,k,H);let Z=r,bA=a;for(let iA=0;iA=bA+KA&&(Z+=1,bA+=KA),JA=Z}const IA=G===0?P.getFloat32(f+0,!0):(P.getUint16(f+0,!0)-U)*FA+DA[3*JA+0],l=G===0?P.getFloat32(f+4,!0):(P.getUint16(f+2,!0)-U)*FA+DA[3*JA+1],aA=G===0?P.getFloat32(f+8,!0):(P.getUint16(f+4,!0)-U)*FA+DA[3*JA+2],FI=G===0?P.getFloat32(f+u+0,!0):AA(P.getUint16(f+u+0,!0)),hI=G===0?P.getFloat32(f+u+4,!0):AA(P.getUint16(f+u+2,!0)),Rg=G===0?P.getFloat32(f+u+8,!0):AA(P.getUint16(f+u+4,!0)),kg=G===0?P.getFloat32(f+O+0,!0):AA(P.getUint16(f+O+0,!0)),Fg=G===0?P.getFloat32(f+O+4,!0):AA(P.getUint16(f+O+2,!0)),hg=G===0?P.getFloat32(f+O+8,!0):AA(P.getUint16(f+O+4,!0)),Sg=G===0?P.getFloat32(f+O+12,!0):AA(P.getUint16(f+O+6,!0)),sg=P.getUint8(f+V+0)/255,Ng=P.getUint8(f+V+1)/255,Jg=P.getUint8(f+V+2)/255,Mg=P.getUint8(f+V+3)/255;if(I(iA,IA,l,aA,FI,hI,Rg,Fg,hg,Sg,kg,Mg,sg,Ng,Jg),Y>=1&&RA){for(const[KA,VA]of EA.entries())RA[KA]=h(f,VA);if(kA)for(const[KA,VA]of yA.entries())kA[KA]=h(f,VA);if(qA)for(const[KA,VA]of GA.entries())qA[KA]=h(f,VA);g==null||g(iA,RA,kA,qA)}}k+=CA}}function JB(Q,A){var J;let B=0;const C=new DataView(Q.buffer,B,4096);B+=4096;const E=C.getUint8(0),D=C.getUint8(1);if(E!==0||D<1)throw new Error(`Unsupported .ksplat version: ${E}.${D}`);const i=C.getUint32(4,!0),o=C.getUint32(16,!0),w=C.getUint16(20,!0);if(w<0||w>2)throw new Error(`Invalid .ksplat compression level: ${w}`);const G=C.getFloat32(36,!0)||-1.5,R=C.getFloat32(40,!0)||1.5,y=o,k=qI(y),F=new Uint32Array(k*4),s={};let h=4096+i*1024;for(let S=0;S=1?new Float32Array(3*3):void 0,sA=W>=2?new Float32Array(5*3):void 0,NA=W>=3?new Float32Array(7*3):void 0,P=r/2/H,DA=h+n,$=h+T,Z=new DataView(Q.buffer,$,yA),bA=new Float32Array(Q.buffer,DA,U*3),iA=new Uint32Array(Q.buffer,h,Y);let f=q,JA=t;for(let IA=0;IA=JA+lA&&(f+=1,JA+=lA),aA=f}const FI=w===0?Z.getFloat32(l+0,!0):(Z.getUint16(l+0,!0)-H)*P+bA[3*aA+0],hI=w===0?Z.getFloat32(l+4,!0):(Z.getUint16(l+2,!0)-H)*P+bA[3*aA+1],Rg=w===0?Z.getFloat32(l+8,!0):(Z.getUint16(l+4,!0)-H)*P+bA[3*aA+2],kg=w===0?Z.getFloat32(l+b+0,!0):AA(Z.getUint16(l+b+0,!0)),Fg=w===0?Z.getFloat32(l+b+4,!0):AA(Z.getUint16(l+b+2,!0)),hg=w===0?Z.getFloat32(l+b+8,!0):AA(Z.getUint16(l+b+4,!0)),Sg=w===0?Z.getFloat32(l+e+0,!0):AA(Z.getUint16(l+e+0,!0)),sg=w===0?Z.getFloat32(l+e+4,!0):AA(Z.getUint16(l+e+2,!0)),Ng=w===0?Z.getFloat32(l+e+8,!0):AA(Z.getUint16(l+e+4,!0)),Jg=w===0?Z.getFloat32(l+e+12,!0):AA(Z.getUint16(l+e+6,!0)),Mg=Z.getUint8(l+d+0)/255,KA=Z.getUint8(l+d+1)/255,VA=Z.getUint8(l+d+2)/255,XB=Z.getUint8(l+d+3)/255;if(Dg(F,IA,FI,hI,Rg,kg,Fg,hg,sg,Ng,Jg,Sg,XB,Mg,KA,VA,A),W>=1){if(FA){s.sh1||(s.sh1=new Uint32Array(y*2));for(const[lA,SI]of RA.entries())FA[lA]=N(l,SI);xI(s.sh1,IA,FA,A)}if(sA){s.sh2||(s.sh2=new Uint32Array(y*4));for(const[lA,SI]of kA.entries())sA[lA]=N(l,SI);rI(s.sh2,IA,sA,A)}if(NA){s.sh3||(s.sh3=new Uint32Array(y*4));for(const[lA,SI]of qA.entries())NA[lA]=N(l,SI);nI(s.sh3,IA,NA,A)}}}h+=GA}return{packedArray:F,numSplats:y,extra:s}}const RQ=["char","uchar","short","ushort","int","uint","float","double"],II=class II{constructor({fileBytes:A}){this.header="",this.littleEndian=!0,this.elements={},this.comments=[],this.data=null,this.numSplats=0,this.fileBytes=A instanceof ArrayBuffer?new Uint8Array(A):A}async parseHeader(){const I=new ReadableStream({start:E=>{E.enqueue(this.fileBytes.slice(0,65536)),E.close()}}).pipeThrough(new TextDecoderStream).getReader();this.header="";const g=`end_header\n`;for(;;){const{value:E,done:D}=await I.read();if(D)throw new Error("Failed to read header");this.header+=E;const i=this.header.indexOf(g);if(i>=0){this.header=this.header.slice(0,i+g.length);break}}const B=new TextEncoder().encode(this.header).length;this.data=new DataView(this.fileBytes.buffer,B),this.elements={};let C=null;this.comments=[],this.header.trim().split(`\n`).forEach((E,D)=>{const i=E.trim();if(D===0){if(i!=="ply")throw new Error("Invalid PLY header");return}if(i.length===0)return;const o=i.split(" ");switch(o[0]){case"format":if(o[1]==="binary_little_endian")this.littleEndian=!0;else if(o[1]==="binary_big_endian")this.littleEndian=!1;else throw new Error(`Unsupported PLY format: ${o[1]}`);if(o[2]!=="1.0")throw new Error(`Unsupported PLY version: ${o[2]}`);break;case"end_header":break;case"comment":this.comments.push(i.slice(8));break;case"element":{const w=o[1];C={name:w,count:Number.parseInt(o[2]),properties:{}},this.elements[w]=C;break}case"property":if(C==null)throw new Error("Property must be inside an element");o[1]==="list"?C.properties[o[4]]={isList:!0,type:o[3],countType:o[2]}:C.properties[o[2]]={isList:!1,type:o[1]};break}}),this.elements.vertex&&(this.numSplats=this.elements.vertex.count)}parseData(A){let I=0;const g=this.data;if(g==null)throw new Error("No data to parse");for(const B in this.elements){const C=this.elements[B],{count:E,properties:D}=C,i=cB(D),o=HB(D,this.littleEndian),w=A(C)??(()=>{});for(let G=0;G[0,1,2].map((N,M)=>S+M*h/3)),D=new Array(5).fill(null).flatMap((J,S)=>[0,1,2].map((N,M)=>3+S+M*h/3)),i=new Array(7).fill(null).flatMap((J,S)=>[0,1,2].map((N,M)=>8+S+M*h/3)),o=C>=1?new Float32Array(3*3):void 0,w=C>=2?new Float32Array(5*3):void 0,G=C>=3?new Float32Array(7*3):void 0}function y(h,J){if(!o)throw new Error("Missing sh1");const S=J.f_rest;for(let N=0;N{const{min_x:n,min_y:T,min_z:W,max_x:X,max_y:z,max_z:j,min_scale_x:u,min_scale_y:O,min_scale_z:V,max_scale_x:b,max_scale_y:e,max_scale_z:d,min_r:CA,min_g:EA,min_b:yA,max_r:GA,max_g:RA,max_b:kA}=Y;B.push({min_x:n,min_y:T,min_z:W,max_x:X,max_y:z,max_z:j,min_scale_x:u,min_scale_y:O,min_scale_z:V,max_scale_x:b,max_scale_y:e,max_scale_z:d,min_r:CA,min_g:EA,min_b:yA,max_r:GA,max_g:RA,max_b:kA})}}function F(h){if(I&&h.name==="sh")return C=wg(h.properties),R(),y;if(h.name!=="vertex")return null;const{packed_position:J,packed_rotation:S,packed_scale:N,packed_color:M}=h.properties;if(!J||!S||!N||!M)throw new Error("Missing PLY properties: packed_position, packed_rotation, packed_scale, packed_color");const K=Math.sqrt(2);return(p,c)=>{const U=B[p>>>8];if(U==null)throw new Error("Missing PLY chunk");const{min_x:r,min_y:a,min_z:H,max_x:q,max_y:t,max_z:Y,min_scale_x:n,min_scale_y:T,min_scale_z:W,max_scale_x:X,max_scale_y:z,max_scale_z:j,min_r:u,min_g:O,min_b:V,max_r:b,max_g:e,max_b:d}=U,{packed_position:CA,packed_rotation:EA,packed_scale:yA,packed_color:GA}=c,RA=(CA>>>21&2047)/2047*(q-r)+r,kA=(CA>>>11&1023)/1023*(t-a)+a,qA=(CA&2047)/2047*(Y-H)+H,FA=((EA>>>20&1023)/1023-.5)*K,sA=((EA>>>10&1023)/1023-.5)*K,NA=((EA&1023)/1023-.5)*K,P=Math.sqrt(Math.max(0,1-FA*FA-sA*sA-NA*NA)),DA=EA>>>30,$=DA===0?FA:DA===1?P:sA,Z=DA<=1?sA:DA===2?P:NA,bA=DA<=2?NA:P,iA=DA===0?P:FA,f=Math.exp((yA>>>21&2047)/2047*(X-n)+n),JA=Math.exp((yA>>>11&1023)/1023*(z-T)+T),IA=Math.exp((yA&2047)/2047*(j-W)+W),l=(GA>>>24&255)/255*((b??1)-(u??0))+(u??0),aA=(GA>>>16&255)/255*((e??1)-(O??0))+(O??0),FI=(GA>>>8&255)/255*((d??1)-(V??0))+(V??0),hI=(GA&255)/255;A(p,RA,kA,qA,f,JA,IA,$,Z,bA,iA,hI,l,aA,FI)}}const s=h=>{if(h.name==="chunk")return k(h);if(g)return F(h);if(h.name!=="vertex")return null;const{x:J,y:S,z:N,scale_0:M,scale_1:K,scale_2:p,rot_0:c,rot_1:U,rot_2:r,rot_3:a,opacity:H,f_dc_0:q,f_dc_1:t,f_dc_2:Y,red:n,green:T,blue:W,alpha:X}=h.properties;if(!J||!S||!N)throw new Error("Missing PLY properties: x, y, z");const z=M&&K&&p,j=c&&U&&r&&a,u=X!=null?eI[X.type]:1,O=n!=null?eI[n.type]:1,V=T!=null?eI[T.type]:1,b=W!=null?eI[W.type]:1;return C=wg(h.properties),R(),(e,d)=>{const CA=z?Math.exp(d.scale_0):II.defaultPointScale,EA=z?Math.exp(d.scale_1):II.defaultPointScale,yA=z?Math.exp(d.scale_2):II.defaultPointScale,GA=j?d.rot_1:0,RA=j?d.rot_2:0,kA=j?d.rot_3:0,qA=j?d.rot_0:1,FA=H!=null?1/(1+Math.exp(-d.opacity)):X!=null?d.alpha/u:1,sA=q!=null?d.f_dc_0*pI+.5:n!=null?d.red/O:1,NA=t!=null?d.f_dc_1*pI+.5:T!=null?d.green/V:1,P=Y!=null?d.f_dc_2*pI+.5:W!=null?d.blue/b:1;if(A(e,d.x,d.y,d.z,CA,EA,yA,GA,RA,kA,qA,FA,sA,NA,P),I&&o){const DA=d.f_rest;if(o)for(let $=0;${const y=AI[R.countType](g,I,this.littleEndian);I+=LA[R.countType],I+=y*LA[R.type]});else{if(w)if(G==="f_dc_0"||G==="f_dc_1"||G==="f_dc_2"){const y=Number.parseInt(G.slice(5));i.push(()=>{const k=(A[o+y]/255-.5)/pI;kQ[R.type](g,I,this.littleEndian,k)})}else G==="opacity"&&i.push(()=>{const y=Math.max(-100,Math.min(100,-Math.log(1/(A[o+3]/255)-1)));kQ[R.type](g,I,this.littleEndian,y)});i.push(()=>{I+=LA[R.type]})}for(let G=0;GQ.getInt8(A),uchar:(Q,A,I)=>Q.getUint8(A),short:(Q,A,I)=>Q.getInt16(A,I),ushort:(Q,A,I)=>Q.getUint16(A,I),int:(Q,A,I)=>Q.getInt32(A,I),uint:(Q,A,I)=>Q.getUint32(A,I),float:(Q,A,I)=>Q.getFloat32(A,I),double:(Q,A,I)=>Q.getFloat64(A,I)},kQ={char:(Q,A,I,g)=>{Q.setInt8(A,g)},uchar:(Q,A,I,g)=>{Q.setUint8(A,g)},short:(Q,A,I,g)=>{Q.setInt16(A,g,I)},ushort:(Q,A,I,g)=>{Q.setUint16(A,g,I)},int:(Q,A,I,g)=>{Q.setInt32(A,g,I)},uint:(Q,A,I,g)=>{Q.setUint32(A,g,I)},float:(Q,A,I,g)=>{Q.setFloat32(A,g,I)},double:(Q,A,I,g)=>{Q.setFloat64(A,g,I)}},LA={char:1,uchar:1,short:2,ushort:2,int:4,uint:4,float:4,double:8},eI={char:127,uchar:255,short:32767,ushort:65535,int:2147483647,uint:4294967295,float:1,double:1},MB={0:0,9:1,24:2,45:3},UB={0:0,1:9,2:24,3:45},ig=/^f_rest_([0-9]{1,2})$/;function cB(Q){const A={};for(const[I,g]of Object.entries(Q))ig.test(I)?A.f_rest=new Array(wg(Q)):A[I]=g.isList?[]:0;return A}function HB(Q,A){return YB(Q)?KB(Q,A):tB(Q,A)}const LB=(()=>{try{new Function("return 42;")}catch{return!1}return!0})(),aB=/^[a-zA-Z0-9_]+$/;function YB(Q){if(!LB)return!1;for(const[A,I]of Object.entries(Q))if(!aB.test(A)||I.isList&&!RQ.includes(I.countType)||!RQ.includes(I.type))return!1;return!0}function KB(Q,A){const I=["let list;"];for(const[B,C]of Object.entries(Q)){const E=B.match(ig);if(E){const D=+E[1];I.push(`\n item.f_rest[${D}] = PARSE_FIELD[\'${C.type}\'](data, offset, ${A});\n offset += ${LA[C.type]};\n `)}else C.isList?I.push(`\n list = item[\'${B}\'];\n list.length = PARSE_FIELD[\'${C.countType}\'](data, offset, ${A});\n offset += ${LA[C.countType]};\n for (let i = 0; i < list.length; i++) {\n list[i] = PARSE_FIELD[\'${C.type}\'](data, offset, ${A});\n offset += ${LA[C.type]};\n }\n `):I.push(`\n item[\'${B}\'] = PARSE_FIELD[\'${C.type}\'](data, offset, ${A});\n offset += ${LA[C.type]};\n `)}I.push("return offset;");const g=new Function("data","offset","item","PARSE_FIELD",I.join(`\n`));return(B,C,E)=>g(B,C,E,AI)}function tB(Q,A){const I=[];for(const[g,B]of Object.entries(Q)){const C=g.match(ig);if(C){const E=+C[1];I.push((D,i,o)=>(o.f_rest[E]=AI[B.type](D,i,A),i+LA[B.type]))}else B.isList?I.push((E,D,i)=>{const o=i[g];o.length=AI[B.countType](E,D,A);let w=D+LA[B.countType];for(let G=0;G(i[g]=AI[B.type](E,D,A),D+LA[B.type]))}return(g,B,C)=>{let E=B;for(let D=0;D3)throw new Error(`Unsupported SPZ version: ${this.version}`);this.numSplats=A.getUint32(8,!0),this.shDegree=A.getUint8(12),this.fractionalBits=A.getUint8(13),this.flags=A.getUint8(14),this.flagAntiAlias=(this.flags&1)!==0,this.flagLod=(this.flags&128)!==0,this.reserved=A.getUint8(15),this.headerParsed=!0,this.parsed=!1}async parseSplats(A,I,g,B,C,E,{childCounts:D,childStarts:i}={}){if(!this.headerParsed)throw new Error("SPZ file header must be parsed first");if(this.parsed)throw new Error("SPZ file already parsed");if(this.parsed=!0,this.version===1){const o=await this.reader.read(this.numSplats*3*2),w=new Uint16Array(o.buffer);for(let G=0;G>8)/o,k=((w[R+5]<<24|w[R+4]<<16|w[R+3]<<8)>>8)/o,F=((w[R+8]<<24|w[R+7]<<16|w[R+6]<<8)>>8)/o;A==null||A(G,y,k,F)}}else throw new Error("Unreachable");{const o=await this.reader.read(this.numSplats);for(let w=0;w>>30;let J=F,S=0;for(let M=3;M>=0;--M)if(M!==h){const K=J&s,p=J>>>9&1;J=J>>>10,y[M]=o*(K/s),y[M]=p===0?y[M]:-y[M],S+=y[M]*y[M]}const N=1-S;y[h]=Math.sqrt(Math.max(N,0)),C==null||C(G,y[0],y[1],y[2],y[3])}}else{const o=await this.reader.read(this.numSplats*3);for(let w=0;w=1){const o=new Float32Array(9),w=this.shDegree>=2?new Float32Array(5*3):void 0,G=this.shDegree>=3?new Float32Array(7*3):void 0,R=await this.reader.read(this.numSplats*hQ[this.shDegree]*3);let y=0;for(let k=0;k=1?9:0)+(I>=2?15:0)+(I>=3?21:0),E=16+A*C;this.buffer=new ArrayBuffer(E),this.view=new DataView(this.buffer),this.view.setUint32(0,qB,!0),this.view.setUint32(4,dB,!0),this.view.setUint32(8,A,!0),this.view.setUint8(12,I),this.view.setUint8(13,g),this.view.setUint8(14,B?xB:0),this.view.setUint8(15,0),this.numSplats=A,this.shDegree=I,this.fractionalBits=g,this.fraction=1<>8&255),this.view.setUint8(y+2,E>>16&255),this.view.setUint8(y+3,i&255),this.view.setUint8(y+4,i>>8&255),this.view.setUint8(y+5,i>>16&255),this.view.setUint8(y+6,w&255),this.view.setUint8(y+7,w>>8&255),this.view.setUint8(y+8,w>>16&255)}setAlpha(A,I){const g=16+this.numSplats*9+A;this.view.setUint8(g,Math.max(0,Math.min(255,Math.round(I*255))))}static scaleRgb(A){const I=((A-.5)/(SQ/.15)+.5)*255;return Math.max(0,Math.min(255,Math.round(I)))}setRgb(A,I,g,B){const C=16+this.numSplats*10+A*3;this.view.setUint8(C,eA.scaleRgb(I)),this.view.setUint8(C+1,eA.scaleRgb(g)),this.view.setUint8(C+2,eA.scaleRgb(B))}setScale(A,I,g,B){const C=16+this.numSplats*13+A*3;this.view.setUint8(C,Math.max(0,Math.min(255,Math.round((Math.log(I)+10)*16)))),this.view.setUint8(C+1,Math.max(0,Math.min(255,Math.round((Math.log(g)+10)*16)))),this.view.setUint8(C+2,Math.max(0,Math.min(255,Math.round((Math.log(B)+10)*16))))}setQuat(A,...I){const g=16+this.numSplats*16+A*4,B=CB(I);let C=0;for(let i=1;i<4;++i)Math.abs(B[i])>Math.abs(B[C])&&(C=i);const E=B[C]<0?1:0;let D=C;for(let i=0;i<4;++i)if(i!==C){const o=(B[i]<0?1:0)^E,w=Math.floor(511*(Math.abs(B[i])/Math.SQRT1_2)+.5);D=D<<10|o<<9|w}this.view.setUint8(g,D&255),this.view.setUint8(g+1,D>>8&255),this.view.setUint8(g+2,D>>16&255),this.view.setUint8(g+3,D>>>24&255)}static quantizeSh(A,I){const g=Math.round(A*128)+128,B=1<<8-I,C=Math.floor((g+B/2)/B)*B;return Math.max(0,Math.min(255,C))}setSh(A,I,g,B){const C=hQ[this.shDegree]||0,E=16+this.numSplats*20+A*C*3;for(let D=0;D<9;++D)this.view.setUint8(E+D,eA.quantizeSh(I[D],5));if(g){const D=E+9;for(let i=0;i<15;++i)this.view.setUint8(D+i,eA.quantizeSh(g[i],4));if(B){const i=D+15;for(let o=0;o<21;++o)this.view.setUint8(i+o,eA.quantizeSh(B[o],4))}}}async finalize(){const A=new Uint8Array(this.buffer),g=new ReadableStream({async start(E){E.enqueue(A),E.close()}}).pipeThrough(new CompressionStream("gzip")),C=await new Response(g).arrayBuffer();return console.log("Compressed",A.length,"bytes to",C.byteLength,"bytes"),new Uint8Array(C)}}async function rB(Q){var w,G,R;const A=new eB,{inputs:I,clipXyz:g,maxSh:B,fractionalBits:C=12,opacityThreshold:E}=Q;for(const y of I){let k=function(c){return c.multiplyScalar(S),c.applyQuaternion(N),c.add(M),c},F=function(c){return c.multiplyScalar(S),c},s=function(c){return c.premultiply(N),c},h=function(c){return!K||K.containsPoint(c)},J=function(c){return E!==void 0?c>=E:!0};const S=((w=y.transform)==null?void 0:w.scale)??1,N=new nA().fromArray(((G=y.transform)==null?void 0:G.quaternion)??[0,0,0,1]),M=new x().fromArray(((R=y.transform)==null?void 0:R.translate)??[0,0,0]),K=g?new zg(new x().fromArray(g.min),new x().fromArray(g.max)):void 0;let p=y.fileType;switch(p||(p=nB(y.fileBytes),!p&&y.pathOrUrl&&(p=fB(y.pathOrUrl))),p){case wA.PLY:{const c=new fI({fileBytes:y.fileBytes});await c.parseHeader();let U=null;c.parseSplats((r,a,H,q,t,Y,n,T,W,X,z,j,u,O,V)=>{const b=k(new x(a,H,q));if(h(b)&&J(j)){U=A.pushSplat(),A.setCenter(U,b.x,b.y,b.z);const e=F(new x(t,Y,n));A.setScale(U,e.x,e.y,e.z);const d=s(new nA(T,W,X,z));A.setQuaternion(U,d.x,d.y,d.z,d.w),A.setOpacity(U,j),A.setColor(U,u,O,V)}else U=null},(r,a,H,q)=>{a&&U!==null&&A.setSh1(U,a),H&&U!==null&&A.setSh2(U,H),q&&U!==null&&A.setSh3(U,q)});break}case wA.SPZ:{const c=new FQ({fileBytes:y.fileBytes});await c.parseHeader();const U=new Int32Array(c.numSplats);U.fill(-1);const r=new Float32Array(c.numSplats*3),a=new x;c.parseSplats((H,q,t,Y)=>{const n=k(new x(q,t,Y));r[H*3]=n.x,r[H*3+1]=n.y,r[H*3+2]=n.z},(H,q)=>{a.fromArray(r,H*3),h(a)&&J(q)&&(U[H]=A.pushSplat(),A.setCenter(U[H],a.x,a.y,a.z),A.setOpacity(U[H],q))},(H,q,t,Y)=>{U[H]>=0&&A.setColor(U[H],q,t,Y)},(H,q,t,Y)=>{if(U[H]>=0){const n=F(new x(q,t,Y));A.setScale(U[H],n.x,n.y,n.z)}},(H,q,t,Y,n)=>{if(U[H]>=0){const T=s(new nA(q,t,Y,n));A.setQuaternion(U[H],T.x,T.y,T.z,T.w)}},(H,q,t,Y)=>{U[H]>=0&&(A.setSh1(U[H],q),t&&A.setSh2(U[H],t),Y&&A.setSh3(U[H],Y))});break}case wA.SPLAT:oQ(y.fileBytes,c=>{},(c,U,r,a,H,q,t,Y,n,T,W,X,z,j,u)=>{const O=k(new x(U,r,a));if(h(O)&&J(X)){const V=A.pushSplat();A.setCenter(V,O.x,O.y,O.z);const b=F(new x(H,q,t));A.setScale(V,b.x,b.y,b.z);const e=s(new nA(Y,n,T,W));A.setQuaternion(V,e.x,e.y,e.z,e.w),A.setOpacity(V,X),A.setColor(V,z,j,u)}});break;case wA.KSPLAT:{let c=null;NB(y.fileBytes,U=>{},(U,r,a,H,q,t,Y,n,T,W,X,z,j,u,O)=>{const V=k(new x(r,a,H));if(h(V)&&J(z)){c=A.pushSplat(),A.setCenter(c,V.x,V.y,V.z);const b=F(new x(q,t,Y));A.setScale(c,b.x,b.y,b.z);const e=s(new nA(n,T,W,X));A.setQuaternion(c,e.x,e.y,e.z,e.w),A.setOpacity(c,z),A.setColor(c,j,u,O)}else c=null},(U,r,a,H)=>{c!==null&&(A.setSh1(c,r),a&&A.setSh2(c,a),H&&A.setSh3(c,H))});break}default:throw new Error(`transcodeSpz not implemented for ${p}`)}}const D=Math.min(B??3,A.sh3?3:A.sh2?2:A.sh1?1:0),i=new eA({numSplats:A.numSplats,shDegree:D,fractionalBits:C,flagAntiAlias:!0});for(let y=0;y=1&&i.setSh(y,A.sh1.slice(y*9,(y+1)*9),D>=2&&A.sh2?A.sh2.slice(y*15,(y+1)*15):void 0,D>=3&&A.sh3?A.sh3.slice(y*21,(y+1)*21):void 0)}return{fileBytes:await i.finalize(),clippedCount:i.clippedCount}}function nB(Q){const I=new DataView(Q.buffer).getUint32(0,!0);if((I&16777215)===7957616)return wA.PLY;if((I&16777215)===559903){const g=hB(Q,4);return new DataView(g.buffer).getUint32(0,!0)===1347635022?wA.SPZ:void 0}if(I===67324752)return sQ(Q)?wA.PCSOGSZIP:void 0;if(I===809779538)return wA.RAD}function PB(Q){const A=Q.split(/[?#]/,1)[0],I=Math.max(A.lastIndexOf("/"),A.lastIndexOf("\\\\")),g=A.slice(I+1),B=g.lastIndexOf(".");return B<=0||B===g.length-1?"":g.slice(B+1).toLowerCase()}function fB(Q){const A=PB(Q);if(A==="ply")return wA.PLY;if(A==="spz")return wA.SPZ;if(A==="splat")return wA.SPLAT;if(A==="ksplat")return wA.KSPLAT;if(A==="sog")return wA.PCSOGSZIP;if(A==="rad")return wA.RAD}function pB(Q){try{let A;if(typeof Q=="string")A=Q;else{const B=Q instanceof ArrayBuffer?new Uint8Array(Q):Q;if(B.length>65536)return;A=new TextDecoder().decode(B)}const I=JSON.parse(A);if(!I||typeof I!="object"||Array.isArray(I))return;const g=I.version===2;for(const B of["means","scales","quats","sh0"]){if(!I[B]||typeof I[B]!="object"||Array.isArray(I[B]))return;if(g){if(!I[B].files||(B==="scales"||B==="sh0")&&!I[B].codebook||B==="means"&&(!I[B].mins||!I[B].maxs))return}else if(!I[B].shape||!I[B].files||B!=="quats"&&(!I[B].mins||!I[B].maxs))return}return I}catch{return}}function sQ(Q){try{const A=Q instanceof ArrayBuffer?new Uint8Array(Q):Q;let I=null;const g=vQ(A,{filter:({name:C})=>C.split(/[\\\\/]/).pop()==="meta.json"?(I=C,!0):!1});if(!I)return;const B=pB(g[I]);return B?{name:I,json:B}:void 0}catch{return}}class eB{constructor({maxSplats:A=1}={}){this.numSplats=0,this.maxSplats=kB(A).maxSplats,this.centers=new Float32Array(this.maxSplats*3),this.scales=new Float32Array(this.maxSplats*3),this.quaternions=new Float32Array(this.maxSplats*4),this.opacities=new Float32Array(this.maxSplats),this.colors=new Float32Array(this.maxSplats*3)}pushSplat(){const A=this.numSplats;return this.ensureIndex(A),this.numSplats+=1,A}unpushSplat(A){if(A===this.numSplats-1)this.numSplats-=1;else throw new Error("Cannot unpush splat from non-last position")}ensureCapacity(A){if(A>this.maxSplats){const I=Math.max(A,this.maxSplats*2),g=new Float32Array(I*3),B=new Float32Array(I*3),C=new Float32Array(I*4),E=new Float32Array(I),D=new Float32Array(I*3);if(g.set(this.centers),B.set(this.scales),C.set(this.quaternions),E.set(this.opacities),D.set(this.colors),this.centers=g,this.scales=B,this.quaternions=C,this.opacities=E,this.colors=D,this.sh1){const i=new Float32Array(I*9);i.set(this.sh1),this.sh1=i}if(this.sh2){const i=new Float32Array(I*15);i.set(this.sh2),this.sh2=i}if(this.sh3){const i=new Float32Array(I*21);i.set(this.sh3),this.sh3=i}this.maxSplats=I}}ensureIndex(A){this.ensureCapacity(A+1)}setCenter(A,I,g,B){this.centers[A*3]=I,this.centers[A*3+1]=g,this.centers[A*3+2]=B}setScale(A,I,g,B){this.scales[A*3]=I,this.scales[A*3+1]=g,this.scales[A*3+2]=B}setQuaternion(A,I,g,B,C){this.quaternions[A*4]=I,this.quaternions[A*4+1]=g,this.quaternions[A*4+2]=B,this.quaternions[A*4+3]=C}setOpacity(A,I){this.opacities[A]=I}setColor(A,I,g,B){this.colors[A*3]=I,this.colors[A*3+1]=g,this.colors[A*3+2]=B}setSh1(A,I){this.sh1||(this.sh1=new Float32Array(this.maxSplats*9));for(let g=0;g<9;++g)this.sh1[A*9+g]=I[g]}setSh2(A,I){this.sh2||(this.sh2=new Float32Array(this.maxSplats*15));for(let g=0;g<15;++g)this.sh2[A*15+g]=I[g]}setSh3(A,I){this.sh3||(this.sh3=new Float32Array(this.maxSplats*21));for(let g=0;g<21;++g)this.sh3[A*21+g]=I[g]}}async function NQ(Q,A,I){const g="version"in Q;if(!g&&Q.quats.encoding!=="quaternion_packed")throw new Error("Unsupported quaternion encoding");const B=g?Q.count:Q.means.shape[0],C=qI(B),E=new Uint32Array(C*4),D={},i=Promise.all([kI(A[Q.means.files[0]]),kI(A[Q.means.files[1]])]).then(y=>{for(let k=0;k{let k,F,s;g?k=F=s=Q.scales.codebook.map(h=>Math.exp(h)):(k=new Array(256).fill(0).map((h,J)=>Q.scales.mins[0]+(Q.scales.maxs[0]-Q.scales.mins[0])*(J/255)).map(h=>Math.exp(h)),F=new Array(256).fill(0).map((h,J)=>Q.scales.mins[1]+(Q.scales.maxs[1]-Q.scales.mins[1])*(J/255)).map(h=>Math.exp(h)),s=new Array(256).fill(0).map((h,J)=>Q.scales.mins[2]+(Q.scales.maxs[2]-Q.scales.mins[2])*(J/255)).map(h=>Math.exp(h)));for(let h=0;h{const k=Math.sqrt(2),F=new Array(256).fill(0).map((s,h)=>(h/255-.5)*k);for(let s=0;s{const k=.28209479177387814;let F,s,h,J;g?(F=s=h=Q.sh0.codebook.map(S=>k*S+.5),J=new Array(256).fill(0).map((S,N)=>N/255)):(F=new Array(256).fill(0).map((S,N)=>Q.sh0.mins[0]+(Q.sh0.maxs[0]-Q.sh0.mins[0])*(N/255)).map(S=>k*S+.5),s=new Array(256).fill(0).map((S,N)=>Q.sh0.mins[1]+(Q.sh0.maxs[1]-Q.sh0.mins[1])*(N/255)).map(S=>k*S+.5),h=new Array(256).fill(0).map((S,N)=>Q.sh0.mins[2]+(Q.sh0.maxs[2]-Q.sh0.mins[2])*(N/255)).map(S=>k*S+.5),J=new Array(256).fill(0).map((S,N)=>Q.sh0.mins[3]+(Q.sh0.maxs[3]-Q.sh0.mins[3])*(N/255)).map(S=>1/(1+Math.exp(-S))));for(let S=0;S=3:Q.shN.shape[1]>=45,k=g?Q.shN.bands>=2:Q.shN.shape[1]>=24,F=g?Q.shN.bands>=1:Q.shN.shape[1]>=9;F&&(D.sh1=new Uint32Array(B*2)),k&&(D.sh2=new Uint32Array(B*4)),y&&(D.sh3=new Uint32Array(B*4));const s=new Float32Array(9),h=new Float32Array(15),J=new Float32Array(21),S=Q.shN,N=Promise.all([Gg(A[Q.shN.files[0]]),Gg(A[Q.shN.files[1]])]).then(([M,K])=>{const p="codebook"in S?S.codebook:new Array(256).fill(0).map((c,U)=>S.mins+(S.maxs-S.mins)*(U/255));for(let c=0;c>>6)*M.width+a;for(let t=0;t<3;++t){if(F)for(let Y=0;Y<3;++Y)s[Y*3+t]=p[M.rgba[(q+Y)*4+t]];if(k)for(let Y=0;Y<5;++Y)h[Y*3+t]=p[M.rgba[(q+3+Y)*4+t]];if(y)for(let Y=0;Y<7;++Y)J[Y*3+t]=p[M.rgba[(q+8+Y)*4+t]]}F&&xI(D.sh1,c,s,I),k&&rI(D.sh2,c,h,I),y&&nI(D.sh3,c,J,I)}});R.push(N)}return await Promise.all(R),{packedArray:E,numSplats:B,extra:D}}let bI=null;async function Gg(Q){if(!bI&&(bI=new OffscreenCanvas(1,1).getContext("webgl2"),!bI))throw new Error("Failed to create WebGL2 context");const A=new Blob([Q]),I=await createImageBitmap(A,{premultiplyAlpha:"none"}),g=bI,B=g.createTexture();g.bindTexture(g.TEXTURE_2D,B),g.pixelStorei(g.UNPACK_FLIP_Y_WEBGL,!0),g.texImage2D(g.TEXTURE_2D,0,g.RGBA,g.RGBA,g.UNSIGNED_BYTE,I),g.texParameteri(g.TEXTURE_2D,g.TEXTURE_MAG_FILTER,g.NEAREST),g.texParameteri(g.TEXTURE_2D,g.TEXTURE_MIN_FILTER,g.NEAREST);const C=g.createFramebuffer();g.bindFramebuffer(g.FRAMEBUFFER,C),g.framebufferTexture2D(g.FRAMEBUFFER,g.COLOR_ATTACHMENT0,g.TEXTURE_2D,B,0);const E=new Uint8Array(I.width*I.height*4);return g.readPixels(0,0,I.width,I.height,g.RGBA,g.UNSIGNED_BYTE,E),g.deleteTexture(B),g.deleteFramebuffer(C),{rgba:E,width:I.width,height:I.height}}async function kI(Q){const{rgba:A}=await Gg(Q);return A}async function bB(Q,A){var R;const I=sQ(Q);if(!I)throw new Error("Invalid PC SOGS zip file");const{name:g,json:B}=I,C=g.lastIndexOf("/"),E=g.lastIndexOf("\\\\"),D=g.slice(0,Math.max(C,E)+1),i=new Map,o=[...B.means.files,...B.scales.files,...B.quats.files,...B.sh0.files,...((R=B.shN)==null?void 0:R.files)??[]];for(const y of o)i.set(D+y,y);const w=await new Promise((y,k)=>{zQ(Q,{filter:({name:F})=>i.has(F)},(F,s)=>{F?k(F):y(s)})}),G={};for(const[y,k]of i.entries())G[k]=w[y];return await NQ(B,G,A)}async function JQ(Q){const{name:A,args:I,id:g}=Q.data;let B,C;try{switch(A){case"unpackPly":{const{packedArray:E,fileBytes:D,splatEncoding:i}=I,o=await lB({packedArray:E,fileBytes:D,splatEncoding:i});B={id:g,numSplats:o.numSplats,packedArray:o.packedArray,extra:o.extra};break}case"decodeSpz":{const{fileBytes:E,splatEncoding:D}=I,i=await OB(E,D);B={id:g,numSplats:i.numSplats,packedArray:i.packedArray,extra:i.extra};break}case"decodeAntiSplat":{const{fileBytes:E,splatEncoding:D}=I,i=sB(E,D);B={id:g,numSplats:i.numSplats,packedArray:i.packedArray};break}case"decodeKsplat":{const{fileBytes:E,splatEncoding:D}=I,i=JB(E,D);B={id:g,numSplats:i.numSplats,packedArray:i.packedArray,extra:i.extra};break}case"decodePcSogs":{const{fileBytes:E,extraFiles:D,splatEncoding:i}=I,o=JSON.parse(new TextDecoder().decode(E)),w=await NQ(o,D,i);B={id:g,numSplats:w.numSplats,packedArray:w.packedArray,extra:w.extra};break}case"decodePcSogsZip":{const{fileBytes:E,splatEncoding:D}=I,i=await bB(E,D);B={id:g,numSplats:i.numSplats,packedArray:i.packedArray,extra:i.extra};break}case"sortSplats":{const{totalSplats:E,readback:D,ordering:i}=I;B={id:g,readback:D,...ZB({totalSplats:E,readback:D,ordering:i})};break}case"sortDoubleSplats":{const{numSplats:E,readback:D,ordering:i}=I;B={id:g,readback:D,ordering:i,activeSplats:cQ(E,D,i)};break}case"sort32Splats":{const{numSplats:E,readback:D,ordering:i}=I;B={id:g,readback:D,ordering:i,activeSplats:UQ(E,D,i)};break}case"transcodeSpz":{const E=I,D=await rB(E);B={id:g,fileBytes:D,input:E};break}default:throw new Error(`Unknown name: ${A}`)}}catch(E){C=E,console.error(C)}self.postMessage({id:g,result:B,error:C},{transfer:GB(B)})}async function lB({packedArray:Q,fileBytes:A,splatEncoding:I}){const g=new fI({fileBytes:A});await g.parseHeader();const B=g.numSplats,C={};return g.parseSplats((E,D,i,o,w,G,R,y,k,F,s,h,J,S,N)=>{Dg(Q,E,D,i,o,w,G,R,y,k,F,s,h,J,S,N,I)},(E,D,i,o)=>{D&&(C.sh1||(C.sh1=new Uint32Array(B*2)),xI(C.sh1,E,D,I)),i&&(C.sh2||(C.sh2=new Uint32Array(B*4)),rI(C.sh2,E,i,I)),o&&(C.sh3||(C.sh3=new Uint32Array(B*4)),nI(C.sh3,E,o,I))}),{packedArray:Q,numSplats:B,extra:C}}async function OB(Q,A){const I=new FQ({fileBytes:Q});await I.parseHeader();const g=I.numSplats,B=qI(g),C=new Uint32Array(B*4),E={};let D={};if(I.flagLod){const i=new Uint16Array(g),o=new Uint32Array(g);E.childCounts=i,E.childStarts=o,D={childCounts:(w,G)=>{i[w]=G},childStarts:(w,G)=>{o[w]=G}}}return await I.parseSplats((i,o,w,G)=>{CQ(C,i,o,w,G)},(i,o)=>{RB(C,i,o)},(i,o,w,G)=>{yB(C,i,o,w,G,A)},(i,o,w,G)=>{EQ(C,i,o,w,G,A)},(i,o,w,G,R)=>{iQ(C,i,o,w,G,R)},(i,o,w,G)=>{o&&(E.sh1||(E.sh1=new Uint32Array(g*2)),xI(E.sh1,i,o,A)),w&&(E.sh2||(E.sh2=new Uint32Array(g*4)),rI(E.sh2,i,w,A)),G&&(E.sh3||(E.sh3=new Uint32Array(g*4)),nI(E.sh3,i,G,A))},D),{packedArray:C,numSplats:g,extra:E}}const og=31744,lI=og+1;let YA=null;function ZB({totalSplats:Q,readback:A,ordering:I}){YA||(YA=new Uint32Array(lI)),YA.fill(0);const g=A.map(i=>new Uint32Array(i.buffer)),B=g[0].length,C=Math.ceil(Q/B);let E=0;for(let i=0;i { + (self.URL || self.webkitURL).revokeObjectURL(A); + }), I; + } catch { + return new Worker( + "data:text/javascript;charset=utf-8," + encodeURIComponent(vB), + { + name: Q == null ? void 0 : Q.name + } + ); + } finally { + A && (self.URL || self.webkitURL).revokeObjectURL(A); + } +} +var KA = Uint8Array, VI = Uint16Array, so = Int32Array, zB = new KA([ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 0, + /* unused */ + 0, + 0, + /* impossible */ + 0 +]), _B = new KA([ + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + /* unused */ + 0, + 0 +]), Go = new KA([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), $B = function(Q, A) { + for (var I = new VI(31), g = 0; g < 31; ++g) + I[g] = A += 1 << Q[g - 1]; + for (var B = new so(I[30]), g = 1; g < 30; ++g) + for (var C = I[g]; C < I[g + 1]; ++C) + B[C] = C - I[g] << 5 | g; + return { b: I, r: B }; +}, AC = $B(zB, 2), IC = AC.b, yo = AC.r; +IC[28] = 258, yo[258] = 28; +var ho = $B(_B, 0), Ro = ho.b, HQ = new VI(32768); +for (var yA = 0; yA < 32768; ++yA) { + var NI = (yA & 43690) >> 1 | (yA & 21845) << 1; + NI = (NI & 52428) >> 2 | (NI & 13107) << 2, NI = (NI & 61680) >> 4 | (NI & 3855) << 4, HQ[yA] = ((NI & 65280) >> 8 | (NI & 255) << 8) >> 1; +} +var sg = function(Q, A, I) { + for (var g = Q.length, B = 0, C = new VI(A); B < g; ++B) + Q[B] && ++C[Q[B] - 1]; + var E = new VI(A); + for (B = 1; B < A; ++B) + E[B] = E[B - 1] + C[B - 1] << 1; + var D; + if (I) { + D = new VI(1 << A); + var i = 15 - A; + for (B = 0; B < g; ++B) + if (Q[B]) + for (var w = B << 4 | Q[B], s = A - Q[B], o = E[Q[B] - 1]++ << s, y = o | (1 << s) - 1; o <= y; ++o) + D[HQ[o] >> i] = w; + } else + for (D = new VI(g), B = 0; B < g; ++B) + Q[B] && (D[B] = HQ[E[Q[B] - 1]++] >> 15 - Q[B]); + return D; +}, Ng = new KA(288); +for (var yA = 0; yA < 144; ++yA) + Ng[yA] = 8; +for (var yA = 144; yA < 256; ++yA) + Ng[yA] = 9; +for (var yA = 256; yA < 280; ++yA) + Ng[yA] = 7; +for (var yA = 280; yA < 288; ++yA) + Ng[yA] = 8; +var gC = new KA(32); +for (var yA = 0; yA < 32; ++yA) + gC[yA] = 5; +var ko = /* @__PURE__ */ sg(Ng, 9, 1), Fo = /* @__PURE__ */ sg(gC, 5, 1), RQ = function(Q) { + for (var A = Q[0], I = 1; I < Q.length; ++I) + Q[I] > A && (A = Q[I]); + return A; +}, II = function(Q, A, I) { + var g = A / 8 | 0; + return (Q[g] | Q[g + 1] << 8) >> (A & 7) & I; +}, kQ = function(Q, A) { + var I = A / 8 | 0; + return (Q[I] | Q[I + 1] << 8 | Q[I + 2] << 16) >> (A & 7); +}, QC = function(Q) { + return (Q + 7) / 8 | 0; +}, vI = function(Q, A, I) { + return (A == null || A < 0) && (A = 0), (I == null || I > Q.length) && (I = Q.length), new KA(Q.subarray(A, I)); +}, So = [ + "unexpected EOF", + "invalid block type", + "invalid length/literal", + "invalid distance", + "stream finished", + "no stream handler", + , + "no callback", + "invalid UTF-8 data", + "extra field too long", + "date not in range 1980-2099", + "filename too long", + "stream finishing", + "invalid zip data" + // determined by unknown compression method +], PA = function(Q, A, I) { + var g = new Error(A || So[Q]); + if (g.code = Q, Error.captureStackTrace && Error.captureStackTrace(g, PA), !I) + throw g; + return g; +}, BC = function(Q, A, I, g) { + var B = Q.length, C = g ? g.length : 0; + if (!B || A.f && !A.l) + return I || new KA(0); + var E = !I, D = E || A.i != 2, i = A.i; + E && (I = new KA(B * 3)); + var w = function(aA) { + var wA = I.length; + if (aA > wA) { + var GA = new KA(Math.max(wA * 2, aA)); + GA.set(I), I = GA; + } + }, s = A.f || 0, o = A.p || 0, y = A.b || 0, h = A.l, k = A.d, R = A.m, F = A.n, S = B * 8; + do { + if (!h) { + s = II(Q, o, 1); + var a = II(Q, o + 1, 3); + if (o += 3, a) + if (a == 1) + h = ko, k = Fo, R = 9, F = 5; + else if (a == 2) { + var U = II(Q, o, 31) + 257, J = II(Q, o + 10, 15) + 4, t = U + II(Q, o + 5, 31) + 1; + o += 14; + for (var H = new KA(t), K = new KA(19), Y = 0; Y < J; ++Y) + K[Go[Y]] = II(Q, o + Y * 3, 7); + o += J * 3; + for (var L = RQ(K), q = (1 << L) - 1, n = sg(K, L, 1), Y = 0; Y < t; ) { + var r = n[II(Q, o, q)]; + o += r & 15; + var M = r >> 4; + if (M < 16) + H[Y++] = M; + else { + var p = 0, m = 0; + for (M == 16 ? (m = 3 + II(Q, o, 3), o += 2, p = H[Y - 1]) : M == 17 ? (m = 3 + II(Q, o, 7), o += 3) : M == 18 && (m = 11 + II(Q, o, 127), o += 7); m--; ) + H[Y++] = p; + } + } + var IA = H.subarray(0, U), X = H.subarray(U); + R = RQ(IA), F = RQ(X), h = sg(IA, R, 1), k = sg(X, F, 1); + } else + PA(1); + else { + var M = QC(o) + 4, c = Q[M - 4] | Q[M - 3] << 8, N = M + c; + if (N > B) { + i && PA(0); + break; + } + D && w(y + c), I.set(Q.subarray(M, N), y), A.b = y += c, A.p = o = N * 8, A.f = s; + continue; + } + if (o > S) { + i && PA(0); + break; + } + } + D && w(y + 131072); + for (var EA = (1 << R) - 1, j = (1 << F) - 1, gA = o; ; gA = o) { + var p = h[kQ(Q, o) & EA], W = p >> 4; + if (o += p & 15, o > S) { + i && PA(0); + break; + } + if (p || PA(2), W < 256) + I[y++] = W; + else if (W == 256) { + gA = o, h = null; + break; + } else { + var u = W - 254; + if (W > 264) { + var Y = W - 257, b = zB[Y]; + u = II(Q, o, (1 << b) - 1) + IC[Y], o += b; + } + var T = k[kQ(Q, o) & j], f = T >> 4; + T || PA(3), o += T & 15; + var X = Ro[f]; + if (f > 3) { + var b = _B[f]; + X += kQ(Q, o) & (1 << b) - 1, o += b; + } + if (o > S) { + i && PA(0); + break; + } + D && w(y + 131072); + var FA = y + u; + if (y < X) { + var sA = C - X, SA = Math.min(X, FA); + for (sA + y < 0 && PA(3); y < SA; ++y) + I[y] = g[sA + y]; + } + for (; y < FA; ++y) + I[y] = I[y - X]; + } + } + A.l = h, A.p = gA, A.b = y, A.f = s, h && (s = 1, A.m = R, A.d = k, A.n = F); + } while (!s); + return y != I.length && E ? vI(I, 0, y) : I.subarray(0, y); +}, ao = /* @__PURE__ */ new KA(0), sI = function(Q, A) { + return Q[A] | Q[A + 1] << 8; +}, QI = function(Q, A) { + return (Q[A] | Q[A + 1] << 8 | Q[A + 2] << 16 | Q[A + 3] << 24) >>> 0; +}, FQ = function(Q, A) { + return QI(Q, A) + QI(Q, A + 4) * 4294967296; +}, No = function(Q) { + (Q[0] != 31 || Q[1] != 139 || Q[2] != 8) && PA(6, "invalid gzip data"); + var A = Q[3], I = 10; + A & 4 && (I += (Q[10] | Q[11] << 8) + 2); + for (var g = (A >> 3 & 1) + (A >> 4 & 1); g > 0; g -= !Q[I++]) + ; + return I + (A & 2); +}, SQ = /* @__PURE__ */ function() { + function Q(A, I) { + typeof A == "function" && (I = A, A = {}), this.ondata = I; + var g = A && A.dictionary && A.dictionary.subarray(-32768); + this.s = { i: 0, b: g ? g.length : 0 }, this.o = new KA(32768), this.p = new KA(0), g && this.o.set(g); + } + return Q.prototype.e = function(A) { + if (this.ondata || PA(5), this.d && PA(4), !this.p.length) + this.p = A; + else if (A.length) { + var I = new KA(this.p.length + A.length); + I.set(this.p), I.set(A, this.p.length), this.p = I; + } + }, Q.prototype.c = function(A) { + this.s.i = +(this.d = A || !1); + var I = this.s.b, g = BC(this.p, this.s, this.o); + this.ondata(vI(g, I, this.s.b), this.d), this.o = vI(g, this.s.b - 32768), this.s.b = this.o.length, this.p = vI(this.p, this.s.p / 8 | 0), this.s.p &= 7; + }, Q.prototype.push = function(A, I) { + this.e(A), this.c(I); + }, Q; +}(); +function co(Q, A) { + return BC(Q, { i: 2 }, A && A.out, A && A.dictionary); +} +var Mo = /* @__PURE__ */ function() { + function Q(A, I) { + this.v = 1, this.r = 0, SQ.call(this, A, I); + } + return Q.prototype.push = function(A, I) { + if (SQ.prototype.e.call(this, A), this.r += A.length, this.v) { + var g = this.p.subarray(this.v - 1), B = g.length > 3 ? No(g) : 4; + if (B > g.length) { + if (!I) + return; + } else this.v > 1 && this.onmember && this.onmember(this.r - g.length); + this.p = g.subarray(B), this.v = 0; + } + SQ.prototype.c.call(this, I), this.s.f && !this.s.l && !I && (this.v = QC(this.s.p) + 9, this.s = { i: 0 }, this.o = new KA(0), this.push(new KA(0), I)); + }, Q; +}(), LQ = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), Jo = 0; +try { + LQ.decode(ao, { stream: !0 }), Jo = 1; +} catch { +} +var Uo = function(Q) { + for (var A = "", I = 0; ; ) { + var g = Q[I++], B = (g > 127) + (g > 223) + (g > 239); + if (I + B > Q.length) + return { s: A, r: vI(Q, I - 1) }; + B ? B == 3 ? (g = ((g & 15) << 18 | (Q[I++] & 63) << 12 | (Q[I++] & 63) << 6 | Q[I++] & 63) - 65536, A += String.fromCharCode(55296 | g >> 10, 56320 | g & 1023)) : B & 1 ? A += String.fromCharCode((g & 31) << 6 | Q[I++] & 63) : A += String.fromCharCode((g & 15) << 12 | (Q[I++] & 63) << 6 | Q[I++] & 63) : A += String.fromCharCode(g); + } +}; +function to(Q, A) { + if (A) { + for (var I = "", g = 0; g < Q.length; g += 16384) + I += String.fromCharCode.apply(null, Q.subarray(g, g + 16384)); + return I; + } else { + if (LQ) + return LQ.decode(Q); + var B = Uo(Q), C = B.s, I = B.r; + return I.length && PA(8), C; + } +} +var Ho = function(Q, A) { + return A + 30 + sI(Q, A + 26) + sI(Q, A + 28); +}, Lo = function(Q, A, I) { + var g = sI(Q, A + 28), B = to(Q.subarray(A + 46, A + 46 + g), !(sI(Q, A + 8) & 2048)), C = A + 46 + g, E = QI(Q, A + 20), D = I && E == 4294967295 ? Yo(Q, C) : [E, QI(Q, A + 24), QI(Q, A + 42)], i = D[0], w = D[1], s = D[2]; + return [sI(Q, A + 10), i, w, B, C + sI(Q, A + 30) + sI(Q, A + 32), s]; +}, Yo = function(Q, A) { + for (; sI(Q, A) != 1; A += 4 + sI(Q, A + 2)) + ; + return [FQ(Q, A + 12), FQ(Q, A + 4), FQ(Q, A + 20)]; +}; +function Ko(Q, A) { + for (var I = {}, g = Q.length - 22; QI(Q, g) != 101010256; --g) + (!g || Q.length - g > 65558) && PA(13); + var B = sI(Q, g + 8); + if (!B) + return {}; + var C = QI(Q, g + 16), E = C == 4294967295 || B == 65535; + if (E) { + var D = QI(Q, g - 12); + E = QI(Q, D) == 101075792, E && (B = QI(Q, D + 32), C = QI(Q, D + 48)); + } + for (var i = A && A.filter, w = 0; w < B; ++w) { + var s = Lo(Q, C, E), o = s[0], y = s[1], h = s[2], k = s[3], R = s[4], F = s[5], S = Ho(Q, F); + C = R, (!i || i({ + name: k, + size: y, + originalSize: h, + compression: o + })) && (o ? o == 8 ? I[k] = co(Q.subarray(S, S + y), { out: new KA(h) }) : PA(14, "unknown compression type " + o) : I[k] = vI(Q, S, S + y)); + } + return I; +} +const pA = -12, fA = 9, eo = Math.exp(pA), ro = Math.exp(fA), CC = -30, xI = Math.exp(CC), VQ = 11, XQ = 11, EC = 11, no = VQ + XQ, P = 1 << VQ, XA = 1 << XQ, DC = 1 << EC, WQ = 1, qo = P - 1, xo = XA - 1, lo = DC - 1, po = !0, fo = !0; +var hA = /* @__PURE__ */ ((Q) => (Q.PLY = "ply", Q.SPZ = "spz", Q.SPLAT = "splat", Q.KSPLAT = "ksplat", Q.PCSOGS = "pcsogs", Q.PCSOGSZIP = "pcsogszip", Q.RAD = "rad", Q))(hA || {}); +const cg = { + rgbMin: 0, + rgbMax: 1, + lnScaleMin: pA, + lnScaleMax: fA, + sh1Max: 1, + sh2Max: 1, + sh3Max: 1, + lodOpacity: !1 +}, xk = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + DEFAULT_SPLAT_ENCODING: cg, + LN_SCALE_MAX: fA, + LN_SCALE_MIN: pA, + LN_SCALE_ZERO: CC, + SCALE_MAX: ro, + SCALE_MIN: eo, + SCALE_ZERO: xI, + SPLAT_TEX_DEPTH: DC, + SPLAT_TEX_DEPTH_BITS: EC, + SPLAT_TEX_DEPTH_MASK: lo, + SPLAT_TEX_HEIGHT: XA, + SPLAT_TEX_HEIGHT_BITS: XQ, + SPLAT_TEX_HEIGHT_MASK: xo, + SPLAT_TEX_LAYER_BITS: no, + SPLAT_TEX_MIN_HEIGHT: WQ, + SPLAT_TEX_WIDTH: P, + SPLAT_TEX_WIDTH_BITS: VQ, + SPLAT_TEX_WIDTH_MASK: qo, + SplatFileType: hA, + USE_COMPILED_PARSER_FUNCTION: fo, + WASM_SPLAT_SORT: po +}, Symbol.toStringTag, { value: "Module" })); +function uI(Q) { + return Q === "bool" || Q === "bvec2" || Q === "bvec3" || Q === "bvec4"; +} +function TI(Q) { + return Q === "int" || Q === "uint" || Q === "float"; +} +function xA(Q) { + return Q === "int" || Q === "ivec2" || Q === "ivec3" || Q === "ivec4"; +} +function lA(Q) { + return Q === "uint" || Q === "uvec2" || Q === "uvec3" || Q === "uvec4"; +} +function Mg(Q) { + return Q === "float" || Q === "vec2" || Q === "vec3" || Q === "vec4"; +} +function iC(Q) { + return Q === "mat2" || Q === "mat2x2" || Q === "mat2x3" || Q === "mat2x4" || Q === "mat3" || Q === "mat3x2" || Q === "mat3x3" || Q === "mat3x4" || Q === "mat4" || Q === "mat4x2" || Q === "mat4x3" || Q === "mat4x4"; +} +function HI(Q) { + return Mg(Q) || iC(Q); +} +function gg(Q) { + return Q === "vec2" || Q === "ivec2" || Q === "uvec2"; +} +function Qg(Q) { + return Q === "vec3" || Q === "ivec3" || Q === "uvec3"; +} +function Jg(Q) { + return Q === "vec4" || Q === "ivec4" || Q === "uvec4"; +} +function bo(Q) { + return gg(Q) || Qg(Q) || Jg(Q); +} +function KI(Q) { + return Q === "mat2" || Q === "mat2x2"; +} +function eI(Q) { + return Q === "mat3" || Q === "mat3x3"; +} +function rI(Q) { + return Q === "mat4" || Q === "mat4x4"; +} +function wC(Q) { + switch (Q) { + case "vec2": + return "float"; + case "vec3": + return "float"; + case "vec4": + return "float"; + case "ivec2": + return "int"; + case "ivec3": + return "int"; + case "ivec4": + return "int"; + case "uvec2": + return "uint"; + case "uvec3": + return "uint"; + case "uvec4": + return "uint"; + default: + throw new Error(`Invalid vector type: ${Q}`); + } +} +function oC(Q) { + switch (Q) { + case "vec2": + case "ivec2": + case "uvec2": + return 2; + case "vec3": + case "ivec3": + case "uvec3": + return 3; + case "vec4": + case "ivec4": + case "uvec4": + return 4; + default: + throw new Error(`Invalid vector type: ${Q}`); + } +} +function Po(Q) { + if (TI(Q)) + return "float"; + if (gg(Q)) + return "vec2"; + if (Qg(Q)) + return "vec3"; + if (Jg(Q)) + return "vec4"; + throw new Error(`Invalid vector type: ${Q}`); +} +function sC(Q) { + if (TI(Q)) + return "uint"; + if (gg(Q)) + return "uvec2"; + if (Qg(Q)) + return "uvec3"; + if (Jg(Q)) + return "uvec4"; + throw new Error(`Invalid vector type: ${Q}`); +} +function uo(Q) { + if (TI(Q)) + return "int"; + if (gg(Q)) + return "ivec2"; + if (Qg(Q)) + return "ivec3"; + if (Jg(Q)) + return "ivec4"; + throw new Error(`Invalid vector type: ${Q}`); +} +function GC(Q) { + if (typeof Q == "string") + return Q; + if (typeof Q == "object" && Q.type) + return Q.type; + throw new Error(`Invalid DynoType: ${String(Q)}`); +} +function MA(Q) { + return Math.trunc(Q).toString(); +} +function JA(Q) { + return `${Math.max(0, Math.trunc(Q)).toString()}u`; +} +function AA(Q) { + return Q === Number.POSITIVE_INFINITY ? "INFINITY" : Q === Number.NEGATIVE_INFINITY ? "-INFINITY" : Number.isInteger(Q) ? Q.toFixed(1) : Q.toString(); +} +function CA(Q) { + return Q instanceof UI ? Q.type : Q.dynoOut().type; +} +class UI { + constructor(A) { + this.__isDynoValue = !0, this.type = A; + } +} +class V extends UI { + constructor(A, I) { + super(A.outTypes[I]), this.dyno = A, this.key = I; + } +} +class zI extends UI { + constructor(A, I) { + super(A), this.literal = I; + } + getLiteral() { + return this.literal; + } +} +function ug(Q, A) { + return new zI(Q, A); +} +class yC extends zI { + constructor(A, I) { + super(A, ""), this.value = I; + } + getLiteral() { + const { type: A, value: I } = this; + switch (A) { + case "bool": + return I ? "true" : "false"; + case "uint": + return JA(I); + case "int": + return MA(I); + case "float": + return AA(I); + case "bvec2": { + const g = I; + return `bvec2(${g[0]}, ${g[1]})`; + } + case "uvec2": { + if (I instanceof G.Vector2) + return `uvec2(${JA(I.x)}, ${JA(I.y)})`; + const g = I; + return `uvec2(${JA(g[0])}, ${JA(g[1])})`; + } + case "ivec2": { + if (I instanceof G.Vector2) + return `ivec2(${MA(I.x)}, ${MA(I.y)})`; + const g = I; + return `ivec2(${MA(g[0])}, ${MA(g[1])})`; + } + case "vec2": { + if (I instanceof G.Vector2) + return `vec2(${AA(I.x)}, ${AA(I.y)})`; + const g = I; + return `vec2(${AA(g[0])}, ${AA(g[1])})`; + } + case "bvec3": { + const g = I; + return `bvec3(${g[0]}, ${g[1]}, ${g[2]})`; + } + case "uvec3": { + if (I instanceof G.Vector3) + return `uvec3(${JA(I.x)}, ${JA(I.y)}, ${JA(I.z)})`; + const g = I; + return `uvec3(${JA(g[0])}, ${JA(g[1])}, ${JA(g[2])})`; + } + case "ivec3": { + if (I instanceof G.Vector3) + return `ivec3(${MA(I.x)}, ${MA(I.y)}, ${MA(I.z)})`; + const g = I; + return `ivec3(${MA(g[0])}, ${MA(g[1])}, ${MA(g[2])})`; + } + case "vec3": { + if (I instanceof G.Vector3) + return `vec3(${AA(I.x)}, ${AA(I.y)}, ${AA(I.z)})`; + const g = I; + return `vec3(${AA(g[0])}, ${AA(g[1])}, ${AA(g[2])})`; + } + case "bvec4": { + const g = I; + return `bvec4(${g[0]}, ${g[1]}, ${g[2]}, ${g[3]})`; + } + case "uvec4": { + if (I instanceof G.Vector4) + return `uvec4(${JA(I.x)}, ${JA(I.y)}, ${JA(I.z)}, ${JA(I.w)})`; + const g = I; + return `uvec4(${JA(g[0])}, ${JA(g[1])}, ${JA(g[2])}, ${JA(g[3])})`; + } + case "ivec4": { + if (I instanceof G.Vector4) + return `ivec4(${MA(I.x)}, ${MA(I.y)}, ${MA(I.z)}, ${MA(I.w)})`; + const g = I; + return `ivec4(${MA(g[0])}, ${MA(g[1])}, ${MA(g[2])}, ${MA(g[3])})`; + } + case "vec4": { + if (I instanceof G.Vector4) + return `vec4(${AA(I.x)}, ${AA(I.y)}, ${AA(I.z)}, ${AA(I.w)})`; + if (I instanceof G.Quaternion) + return `vec4(${AA(I.x)}, ${AA(I.y)}, ${AA(I.z)}, ${AA(I.w)})`; + const g = I; + return `vec4(${AA(g[0])}, ${AA(g[1])}, ${AA(g[2])}, ${AA(g[3])})`; + } + case "mat2": + case "mat2x2": { + const g = I, B = g instanceof G.Matrix2 ? g.elements : I, C = new Array(4).fill(0).map((E, D) => AA(B[D])); + return `${A}(${C.join(", ")})`; + } + case "mat2x3": { + const g = I, B = new Array(6).fill(0).map((C, E) => AA(g[E])); + return `${A}(${B.join(", ")})`; + } + case "mat2x4": { + const g = I, B = new Array(8).fill(0).map((C, E) => AA(g[E])); + return `${A}(${B.join(", ")})`; + } + case "mat3": + case "mat3x3": { + const g = I, B = g instanceof G.Matrix3 ? g.elements : I, C = new Array(9).fill(0).map((E, D) => AA(B[D])); + return `${A}(${C.join(", ")})`; + } + case "mat3x2": { + const g = I, B = new Array(6).fill(0).map((C, E) => AA(g[E])); + return `${A}(${B.join(", ")})`; + } + case "mat3x4": { + const g = I, B = new Array(12).fill(0).map((C, E) => AA(g[E])); + return `${A}(${B.join(", ")})`; + } + case "mat4": + case "mat4x4": { + const g = I, B = g instanceof G.Matrix4 ? g.elements : I, C = new Array(16).fill(0).map((E, D) => AA(B[D])); + return `${A}(${C.join(", ")})`; + } + case "mat4x2": { + const g = I, B = new Array(8).fill(0).map((C, E) => AA(g[E])); + return `${A}(${B.join(", ")})`; + } + case "mat4x3": { + const g = I, B = new Array(12).fill(0).map((C, E) => AA(g[E])); + return `${A}(${B.join(", ")})`; + } + default: + throw new Error(`Type not implemented: ${String(A)}`); + } + } +} +function v(Q, A) { + return new yC(Q, A); +} +function Dg(Q) { + const A = String(Q); + if (uI(Q)) + return `${A}(false)`; + if (HI(Q)) + return `${A}(0.0)`; + if (xA(Q)) + return `${A}(0)`; + if (lA(Q)) + return `${A}(0u)`; + throw new Error(`Type not implemented: ${A}`); +} +function To(Q) { + const A = String(Q); + if (uI(Q)) + return `${A}(true)`; + if (HI(Q)) + return `${A}(1.0)`; + if (xA(Q)) + return `${A}(1)`; + if (lA(Q)) + return `${A}(1u)`; + throw new Error(`Type not implemented: ${A}`); +} +function Oo(Q) { + const A = String(Q); + if (uI(Q)) + return `${A}(true)`; + if (HI(Q)) + return `${A}(-1.0)`; + if (xA(Q)) + return `${A}(-1)`; + if (lA(Q)) + return `${A}(0xFFFFFFFFu)`; + throw new Error(`Type not implemented: ${A}`); +} +const KB = " "; +class hC { + constructor({ indent: A } = {}) { + this.globals = /* @__PURE__ */ new Set(), this.statements = [], this.uniforms = {}, this.declares = /* @__PURE__ */ new Set(), this.updaters = [], this.sequence = 0, this.indent = KB, this.indent = A ?? KB; + } + nextSequence() { + return this.sequence++; + } +} +class d { + constructor({ + inTypes: A, + outTypes: I, + inputs: g, + update: B, + globals: C, + statements: E, + generate: D + }) { + this.inTypes = A ?? {}, this.outTypes = I ?? {}, this.inputs = g ?? {}, this.update = B, this.globals = C, this.statements = E, this.generate = D ?? (({ inputs: i, outputs: w, compile: s }) => { + var o, y; + return { + globals: (o = this.globals) == null ? void 0 : o.call(this, { inputs: i, outputs: w, compile: s }), + statements: (y = this.statements) == null ? void 0 : y.call(this, { inputs: i, outputs: w, compile: s }) + }; + }); + } + get outputs() { + const A = {}; + for (const I in this.outTypes) + A[I] = new V(this, I); + return A; + } + apply(A) { + return Object.assign(this.inputs, A), this.outputs; + } + compile({ + inputs: A, + outputs: I, + compile: g + }) { + const B = [ + `// ${this.constructor.name}(${Object.values(A).join(", ")}) => (${Object.values(I).join(", ")})` + ], C = []; + for (const w in I) { + const s = I[w]; + s && !g.declares.has(s) && (g.declares.add(s), C.push(w)); + } + const { globals: E, statements: D, uniforms: i } = this.generate({ + inputs: A, + outputs: I, + compile: g + }); + for (const w of E ?? []) + g.globals.add(w); + for (const w in i) + g.uniforms[w] = i[w]; + this.update && g.updaters.push(this.update); + for (const w of C) { + const s = I[w]; + s && (g.uniforms[s] || B.push(`${jQ(s, this.outTypes[w])};`)); + } + return D != null && D.length && (B.push("{"), B.push(...D.map((w) => g.indent + w)), B.push("}")), B; + } +} +class hI extends d { + constructor({ + inTypes: A, + outTypes: I, + inputs: g, + update: B, + globals: C, + construct: E + }) { + super({ + inTypes: A, + outTypes: I, + inputs: g, + update: B, + globals: C, + generate: (D) => this.generateBlock(D) + }), this.construct = E; + } + generateBlock({ + inputs: A, + outputs: I, + compile: g + }) { + var k, R; + const B = {}, C = {}; + for (const F in A) + A[F] != null && (B[F] = new zI(this.inTypes[F], A[F])); + for (const F in I) + I[F] != null && (C[F] = new UI(this.outTypes[F])); + const E = { roots: [] }, D = this.construct(B, C, E); + for (const F of ((k = this.globals) == null ? void 0 : k.call(this, { inputs: A, outputs: I, compile: g })) ?? []) + g.globals.add(F); + const i = [], w = /* @__PURE__ */ new Map(); + function s(F, S, a) { + let M = w.get(F); + if (!M) { + M = { + sequence: g.nextSequence(), + outNames: /* @__PURE__ */ new Map(), + newOuts: /* @__PURE__ */ new Set() + }, w.set(F, M); + for (const c in F.inputs) { + let N = F.inputs[c]; + for (; N; ) { + if (N instanceof UI) { + N instanceof V && s(N.dyno, N.key); + break; + } + if (typeof N.dynoOut != "function") + throw new Error( + `dynoOut is not a function for ${N.constructor.name}` + ); + N = N.dynoOut(); + } + } + i.push(F); + } + S && (a || M.newOuts.add(S), M.outNames.set(S, a ?? `${S}_${M.sequence}`)); + } + for (const F of E.roots) + s(F); + for (const F in C) { + let S = (D == null ? void 0 : D[F]) ?? C[F]; + for (; S; ) { + if (S instanceof UI) { + S instanceof V && s(S.dyno, S.key, I[F]); + break; + } + S = S.dynoOut(); + } + C[F] = S; + } + const o = []; + for (const F of i) { + const S = {}, a = {}; + for (const N in F.inputs) { + let U = F.inputs[N]; + for (; U; ) { + if (U instanceof UI) { + if (U instanceof zI) + S[N] = U.getLiteral(); + else if (U instanceof V) { + const J = (R = w.get(U.dyno)) == null ? void 0 : R.outNames.get(U.key); + if (!J) + throw new Error( + `Source not found for ${U.dyno.constructor.name}.${U.key}` + ); + S[N] = J; + } + break; + } + U = U.dynoOut(); + } + } + const M = w.get(F) ?? { outNames: /* @__PURE__ */ new Map() }; + for (const [N, U] of M.outNames.entries()) + a[N] = U; + const c = F.compile({ inputs: S, outputs: a, compile: g }); + o.push(c); + } + const y = []; + for (const F in I) + C[F] instanceof zI && y.push( + `${I[F]} = ${C[F].getLiteral()};` + ); + return y.length > 0 && o.push(y), { statements: o.flatMap((F, S) => S === 0 ? F : ["", ...F]) }; + } +} +function cA(Q, A, I, { update: g, globals: B } = {}) { + return new hI({ inTypes: Q, outTypes: A, construct: I, update: g, globals: B }); +} +function AQ({ + inTypes: Q, + outTypes: A, + inputs: I, + update: g, + globals: B, + statements: C, + generate: E +}) { + return new d({ + inTypes: Q, + outTypes: A, + inputs: I, + update: g, + globals: B, + statements: C, + generate: E + }); +} +function jQ(Q, A, I) { + const g = typeof A == "string" ? A : A.type; + if (!g) + throw new Error(`Invalid DynoType: ${String(A)}`); + return `${g} ${Q}${I != null ? `[${I}]` : ""}`; +} +function z(Q) { + var C; + let A = !1; + const I = Q.split(` +`).map((E) => { + const D = E.trimEnd(); + return A ? D : D.length > 0 ? (A = !0, D) : null; + }).filter((E) => E != null); + for (; I.length > 0 && I[I.length - 1].length === 0; ) + I.pop(); + if (I.length === 0) + return []; + const g = (C = I[0].match(/^\s*/)) == null ? void 0 : C[0]; + if (!g) + return I; + const B = new RegExp(`^${g}`); + return I.map((E) => E.replace(B, "")); +} +function oA(Q) { + return z(Q).join(` +`); +} +class e extends d { + constructor({ + a: A, + outKey: I, + outTypeFunc: g + }) { + const B = { a: CA(A) }, C = g(CA(A)), E = { [I]: C }; + super({ inTypes: B, outTypes: E, inputs: { a: A } }), this.outKey = I; + } + dynoOut() { + return new V(this, this.outKey); + } +} +class DA extends d { + constructor({ + a: A, + b: I, + outKey: g, + outTypeFunc: B + }) { + const C = { a: CA(A), b: CA(I) }, E = B(CA(A), CA(I)), D = { [g]: E }; + super({ inTypes: C, outTypes: D, inputs: { a: A, b: I } }), this.outKey = g; + } + dynoOut() { + return new V(this, this.outKey); + } +} +class OI extends d { + constructor({ + a: A, + b: I, + c: g, + outKey: B, + outTypeFunc: C + }) { + const E = { a: CA(A), b: CA(I), c: CA(g) }, D = C(CA(A), CA(I), CA(g)), i = { [B]: D }; + super({ inTypes: E, outTypes: i, inputs: { a: A, b: I, c: g } }), this.outKey = B; + } + dynoOut() { + return new V(this, this.outKey); + } +} +const RC = Number.parseInt(G.REVISION), kC = RC >= 179, Ug = new Float32Array(1), IQ = new Uint32Array(Ug.buffer), vQ = "Float16Array" in globalThis, Gg = vQ ? new globalThis.Float16Array(1) : null, FC = new Uint16Array(Gg == null ? void 0 : Gg.buffer); +function SC(Q) { + const A = Math.sqrt(Q.reduce((I, g) => I + g * g, 0)); + return Q.map((I) => I / A); +} +function qg(Q) { + return Ug[0] = Q, IQ[0]; +} +function xg(Q) { + return IQ[0] = Q, Ug[0]; +} +const VA = vQ ? mo : Zo, NA = vQ ? Vo : Xo; +function mo(Q) { + return Gg[0] = Q, FC[0]; +} +function Zo(Q) { + Ug[0] = Q; + const A = IQ[0], I = A >> 31 & 1, g = A >> 23 & 255, B = A & 8388607, C = I << 15; + if (g === 255) + return B !== 0 ? C | 32767 : C | 31744; + const E = g - 127 + 15; + if (E >= 31) + return C | 31744; + if (E <= 0) { + if (E < -10) + return C; + const i = (B | 8388608) >> 1 - E + 13; + return C | i; + } + const D = B >> 13; + return C | E << 10 | D; +} +function Vo(Q) { + return FC[0] = Q, Gg[0]; +} +function Xo(Q) { + const A = Q >> 15 & 1, I = Q >> 10 & 31, g = Q & 1023; + let B; + if (I === 0) + if (g === 0) + B = A << 31; + else { + let C = g, E = -14; + for (; (C & 1024) === 0; ) + C <<= 1, E--; + C &= 1023; + const D = E + 127, i = C << 13; + B = A << 31 | D << 23 | i; + } + else if (I === 31) + g === 0 ? B = A << 31 | 2139095040 : B = A << 31 | 2143289344; + else { + const C = I - 15 + 127, E = g << 13; + B = A << 31 | C << 23 | E; + } + return IQ[0] = B, Ug[0]; +} +function jA(Q) { + return Math.max(0, Math.min(255, Math.round(Q * 255))); +} +function lg(Q) { + return Math.max(-127, Math.min(127, Math.round(Q * 127))); +} +function Wo(Q) { + return Q / 255; +} +function jo(Q) { + return Q / 127; +} +class vo { + // Create a DataCache with a given function that fetches data not in the cache. + constructor({ + asyncFetch: A, + dispose: I, + maxItems: g = 5 + }) { + this.asyncFetch = A, this.dispose = I, this.maxItems = g, this.items = [], this.pending = /* @__PURE__ */ new Map(); + } + has(A) { + return this.items.some((I) => I.key === A); + } + getImmediate(A) { + const I = this.items.findIndex((g) => g.key === A); + if (I >= 0) { + const g = this.items.splice(I, 1)[0]; + return this.items.push(g), g.data; + } + } + // Fetch data for the key, returning cached data if available. + async getFetch(A) { + const I = this.getImmediate(A); + if (I !== void 0) + return I; + let g = this.pending.get(A); + return g || (g = this.asyncFetch(A).then((B) => { + for (this.pending.delete(A), this.items.push({ key: A, data: B }); this.items.length > this.maxItems; ) { + const C = this.items.shift(); + C && this.dispose && this.dispose(C.data); + } + return B; + }), this.pending.set(A, g), g); + } +} +function zo(Q, A) { + const I = Object.entries(Q).map(([g, B]) => [ + g, + A(B, g) + ]); + return Object.fromEntries(I); +} +function _o(Q, A) { + const I = Object.entries(Q).map(([g, B]) => [g, A(B, g)]).filter(([g, B]) => B !== void 0); + return Object.fromEntries(I); +} +function zQ(Q) { + const A = [], I = /* @__PURE__ */ new Set(); + function g(B) { + B && typeof B == "object" && !I.has(B) && (I.add(B), B instanceof ArrayBuffer ? A.push(B) : ArrayBuffer.isView(B) ? A.push(B.buffer) : Array.isArray(B) ? B.forEach(g) : Object.values(B).forEach(g)); + } + return g(Q), A; +} +function YQ(Q, A) { + return new Array(Q).fill(null).map((I, g) => A(g)); +} +class aC { + constructor({ + // Allocate a new item with the given args + allocate: A, + // Dispose of an item (optional, if GC is enough) + dispose: I, + // Check if an existing item in the list is valid for the given args, + // allowing you to store heterogeneous items in the list. + valid: g + }) { + this.items = [], this.allocate = A, this.dispose = I, this.valid = g; + } + // Allocate a new item from the free list, first checking if a existing item + // on the freelist is valid for the given args. + alloc(A) { + for (; ; ) { + const I = this.items.pop(); + if (!I) + break; + if (this.valid(I, A)) + return I; + this.dispose && this.dispose(I); + } + return this.allocate(A); + } + free(A) { + this.items.push(A); + } + disposeAll() { + let A; + for (A = this.items.pop(); A; ) + this.dispose && this.dispose(A), A = this.items.pop(); + } +} +function KQ(Q, A, I, g, B, C, E, D, i, w, s, o, y, h, k, R) { + const F = A * 4, [S, a] = Q; + S[F] = qg(I), S[F + 1] = qg(g), S[F + 2] = qg(B), S[F + 3] = VA(y), a[F] = VA(h) | VA(k) << 16, a[F + 1] = VA(R) | VA(Math.log(C)) << 16, a[F + 2] = VA(Math.log(E)) | VA(Math.log(D)) << 16, a[F + 3] = YC(i, w, s, o); +} +function eQ(Q, A) { + const I = _Q, g = A * 4, [B, C] = Q; + return I.center.x = xg(B[g]), I.center.y = xg(B[g + 1]), I.center.z = xg(B[g + 2]), I.opacity = NA(B[g + 3] & 65535), I.color.r = NA(C[g] & 65535), I.color.g = NA(C[g] >>> 16), I.color.b = NA(C[g + 1] & 65535), I.scales.x = Math.exp(NA(C[g + 1] >>> 16)), I.scales.y = Math.exp(NA(C[g + 2] & 65535)), I.scales.z = Math.exp(NA(C[g + 2] >>> 16)), KC(C[g + 3], I.quaternion), I; +} +function rQ(Q, A, I, g, B, C, E, D, i, w, s, o, y, h, k, R, F) { + const S = (F == null ? void 0 : F.rgbMin) ?? 0, M = ((F == null ? void 0 : F.rgbMax) ?? 1) - S, c = jA((h - S) / M), N = jA((k - S) / M), U = jA((R - S) / M), J = jA(F != null && F.lodOpacity ? 0.5 * y : y), t = gB( + NC.set(i, w, s, o) + ), H = t & 255, K = t >>> 8 & 255, Y = t >>> 16 & 255, L = (F == null ? void 0 : F.lnScaleMin) ?? pA, n = 254 / (((F == null ? void 0 : F.lnScaleMax) ?? fA) - L), r = C < xI ? 0 : Math.min( + 255, + Math.max( + 1, + Math.round((Math.log(C) - L) * n) + 1 + ) + ), p = E < xI ? 0 : Math.min( + 255, + Math.max( + 1, + Math.round((Math.log(E) - L) * n) + 1 + ) + ), m = D < xI ? 0 : Math.min( + 255, + Math.max( + 1, + Math.round((Math.log(D) - L) * n) + 1 + ) + ), IA = VA(I), X = VA(g), EA = VA(B), j = A * 4; + Q[j] = c | N << 8 | U << 16 | J << 24, Q[j + 1] = IA | X << 16, Q[j + 2] = EA | H << 16 | K << 24, Q[j + 3] = r | p << 8 | m << 16 | Y << 24; +} +function $o(Q, A, I, g, B) { + const C = VA(I), E = VA(g), D = VA(B), i = A * 4; + Q[i + 1] = C | E << 16, Q[i + 2] = D | Q[i + 2] & 4294901760; +} +function As(Q, A, I, g, B, C) { + const E = (C == null ? void 0 : C.lnScaleMin) ?? pA, i = 254 / (((C == null ? void 0 : C.lnScaleMax) ?? fA) - E), w = I < xI ? 0 : Math.min( + 255, + Math.max( + 1, + Math.round((Math.log(I) - E) * i) + 1 + ) + ), s = g < xI ? 0 : Math.min( + 255, + Math.max( + 1, + Math.round((Math.log(g) - E) * i) + 1 + ) + ), o = B < xI ? 0 : Math.min( + 255, + Math.max( + 1, + Math.round((Math.log(B) - E) * i) + 1 + ) + ), y = A * 4; + Q[y + 3] = w | s << 8 | o << 16 | Q[y + 3] & 4278190080; +} +const NC = new G.Quaternion(); +function Is(Q, A, I, g, B, C) { + const E = gB( + NC.set(I, g, B, C) + ), D = E & 255, i = E >>> 8 & 255, w = E >>> 16 & 255, s = A * 4; + Q[s + 2] = Q[s + 2] & 65535 | D << 16 | i << 24, Q[s + 3] = Q[s + 3] & 16777215 | w << 24; +} +function gs(Q, A, I, g, B, C, E) { + const D = (E == null ? void 0 : E.rgbMin) ?? 0, w = ((E == null ? void 0 : E.rgbMax) ?? 1) - D, s = jA((I - D) / w), o = jA((g - D) / w), y = jA((B - D) / w), h = jA(E != null && E.lodOpacity ? 0.5 * C : C), k = A * 4; + Q[k] = s | o << 8 | y << 16 | h << 24; +} +function Qs(Q, A, I, g, B, C) { + const E = (C == null ? void 0 : C.rgbMin) ?? 0, i = ((C == null ? void 0 : C.rgbMax) ?? 1) - E, w = jA((I - E) / i), s = jA((g - E) / i), o = jA((B - E) / i), y = A * 4; + Q[y] = w | s << 8 | o << 16 | Q[y] & 4278190080; +} +function Bs(Q, A, I) { + const g = jA(I), B = A * 4; + Q[B] = Q[B] & 16777215 | g << 24; +} +const Cs = new G.Vector3(), Es = new G.Vector3(), Ds = new G.Quaternion(), is = new G.Color(), _Q = { + center: Cs, + scales: Es, + quaternion: Ds, + color: is, + opacity: 0 +}; +function nQ(Q, A, I) { + const g = _Q, B = A * 4, C = Q[B], E = Q[B + 1], D = Q[B + 2], i = Q[B + 3], w = (I == null ? void 0 : I.rgbMin) ?? 0, o = ((I == null ? void 0 : I.rgbMax) ?? 1) - w; + g.color.set( + w + (C & 255) / 255 * o, + w + (C >>> 8 & 255) / 255 * o, + w + (C >>> 16 & 255) / 255 * o + ), g.opacity = (C >>> 24 & 255) / 255, I != null && I.lodOpacity && (g.opacity = 2 * g.opacity), g.center.set( + NA(E & 65535), + NA(E >>> 16 & 65535), + NA(D & 65535) + ); + const y = (I == null ? void 0 : I.lnScaleMin) ?? pA, k = (((I == null ? void 0 : I.lnScaleMax) ?? fA) - y) / 254, R = i & 255; + g.scales.x = R === 0 ? 0 : Math.exp(y + (R - 1) * k); + const F = i >>> 8 & 255; + g.scales.y = F === 0 ? 0 : Math.exp(y + (F - 1) * k); + const S = i >>> 16 & 255; + g.scales.z = S === 0 ? 0 : Math.exp(y + (S - 1) * k); + const a = D >>> 16 & 65535 | i >>> 8 & 16711680; + return LC(a, g.quaternion), g; +} +function BA(Q) { + const A = P, I = Math.max( + WQ, + Math.min(XA, Math.ceil(Q / A)) + ), g = Math.ceil(Q / (A * I)), B = A * I * g; + return { width: A, height: I, depth: g, maxSplats: B }; +} +function ws(Q) { + const A = P, I = Math.max( + WQ, + Math.min(XA, Math.ceil(Q / A)) + ), g = Math.ceil(Q / (A * I)); + return A * I * g; +} +function Tg() { + return navigator.platform.toLowerCase().startsWith("win") ? !1 : navigator.maxTouchPoints > 0 ? !0 : /Mobi|Android|iPhone|iPad|iPod|Opera Mini|IEMobile/.test( + navigator.userAgent + ); +} +function $Q() { + return /Android/.test(navigator.userAgent) || /Tizen/.test(navigator.userAgent); +} +function AB() { + return !!navigator.xr && /Oculus/.test(navigator.userAgent); +} +function os() { + return AB() && /Quest 2/.test(navigator.userAgent); +} +function Rg() { + return /iPhone|iPad/.test(navigator.userAgent); +} +function cC() { + return !!navigator.xr && Rg() && /Safari/.test(navigator.userAgent) && Tg(); +} +function ss(Q, A, I) { + const g = new Uint8Array(A * 4); + for (let B = 0; B < I / 2; B++) { + const C = B * A * 4, E = (I - 1 - B) * A * 4; + g.set(Q.subarray(C, C + A * 4)), Q.set( + Q.subarray(E, E + A * 4), + C + ), Q.set(g, E); + } + return Q; +} +function Gs(Q, A, I) { + const g = document.createElement("canvas"); + g.width = A, g.height = I; + const B = g.getContext("2d"); + if (!B) + throw new Error("Can't get 2d context"); + const C = B.createImageData(A, I); + return C.data.set(Q), B.putImageData(C, 0, 0), g.toDataURL("image/png"); +} +function IB(Q) { + const A = new G.Clock(Q.autoStart); + return A.startTime = Q.startTime, A.oldTime = Q.oldTime, A.elapsedTime = Q.elapsedTime, A.running = Q.running, A; +} +function ys(Q) { + return Object.fromEntries( + Object.entries(Q).filter(([A, I]) => I !== void 0) + ); +} +const MC = oA(` + precision highp float; + + in vec3 position; + + void main() { + gl_Position = vec4(position.xy, 0.0, 1.0); + } +`); +function JC(Q) { + const A = new G.Vector3(); + for (const I of Q) + A.add(I); + return A.divideScalar(Q.length); +} +function UC(Q) { + if (Q.length === 0) + return new G.Quaternion(); + const A = Q[0].clone(); + for (let I = 1; I < Q.length; I++) + Q[I].dot(Q[0]) < 0 ? (A.x -= Q[I].x, A.y -= Q[I].y, A.z -= Q[I].z, A.w -= Q[I].w) : (A.x += Q[I].x, A.y += Q[I].y, A.z += Q[I].z, A.w += Q[I].w); + return A.normalize(); +} +function tC(Q, A) { + const I = new G.Vector3(0, 0, 0).applyMatrix4(Q), g = new G.Vector3(0, 0, 0).applyMatrix4(A), B = new G.Vector3(0, 0, -1).applyMatrix4(Q).sub(I).normalize(), C = new G.Vector3(0, 0, -1).applyMatrix4(A).sub(g).normalize(), E = I.distanceTo(g), D = B.dot(C); + return { distance: E, coincidence: D }; +} +function hs({ + matrix1: Q, + matrix2: A, + maxDistance: I +}) { + const g = new G.Vector3(0, 0, 0).applyMatrix4(Q), B = new G.Vector3(0, 0, 0).applyMatrix4(A); + return g.distanceTo(B) <= I; +} +function Rs({ + matrix1: Q, + matrix2: A, + maxDistance: I, + minCoincidence: g +}) { + const { distance: B, coincidence: C } = tC(Q, A); + return B <= I && (g == null || C >= g); +} +function HC(Q, A) { + const [I, g] = [new G.Vector3(), new G.Quaternion()], [B, C] = [new G.Vector3(), new G.Quaternion()]; + Q.decompose(I, g, new G.Vector3()), A.decompose(B, C, new G.Vector3()); + const E = I.distanceTo(B), D = Math.abs(g.dot(C)); + return { distance: E, coorient: D }; +} +function Og({ + matrix1: Q, + matrix2: A, + maxDistance: I, + minCoorient: g +}) { + const { distance: B, coorient: C } = HC(Q, A); + return B <= I && (g == null || C >= g); +} +function ks(Q, A = 1e-3) { + return Math.abs(Q) < A ? 0 : Math.sign(Q); +} +function Fs(Q) { + const A = Q.w < 0, I = lg(A ? -Q.x : Q.x), g = lg(A ? -Q.y : Q.y), B = lg(A ? -Q.z : Q.z), C = I & 255, E = g & 255, D = B & 255; + return C | E << 8 | D << 16; +} +function Ss(Q, A) { + const I = Q << 24 >> 24, g = Q << 16 >> 24, B = Q << 8 >> 24; + A.set(I / 127, g / 127, B / 127, 0); + const C = A.x * A.x + A.y * A.y + A.z * A.z; + return A.w = Math.sqrt(Math.max(0, 1 - C)), A; +} +const as = new G.Quaternion(), dQ = new G.Vector3(); +function gB(Q) { + const A = as.copy(Q).normalize(); + A.w < 0 && A.set(-A.x, -A.y, -A.z, -A.w); + const I = 2 * Math.acos(A.w), g = Math.sqrt( + A.x * A.x + A.y * A.y + A.z * A.z + ), B = g < 1e-6 ? dQ.set(1, 0, 0) : dQ.set(A.x, A.y, A.z).divideScalar(g), C = Math.abs(B.x) + Math.abs(B.y) + Math.abs(B.z); + let E = B.x / C, D = B.y / C; + if (B.z < 0) { + const h = E; + E = (1 - Math.abs(D)) * (E >= 0 ? 1 : -1), D = (1 - Math.abs(h)) * (D >= 0 ? 1 : -1); + } + const i = E * 0.5 + 0.5, w = D * 0.5 + 0.5, s = Math.round(i * 255), o = Math.round(w * 255); + return Math.round(I * (255 / Math.PI)) << 16 | o << 8 | s; +} +function LC(Q, A) { + const I = Q & 255, g = Q >>> 8 & 255, B = Q >>> 16 & 255, C = I / 255, E = g / 255; + let D = (C - 0.5) * 2, i = (E - 0.5) * 2; + const w = 1 - (Math.abs(D) + Math.abs(i)), s = Math.max(-w, 0); + D += D >= 0 ? -s : s, i += i >= 0 ? -s : s; + const o = dQ.set(D, i, w).normalize(), h = B / 255 * Math.PI * 0.5, k = Math.sin(h), R = Math.cos(h); + return A.set(o.x * k, o.y * k, o.z * k, R), A; +} +function Ns(Q) { + const A = Q.clone().normalize(), I = 2 * (A.w * A.x + A.y * A.z), g = 1 - 2 * (A.x * A.x + A.y * A.y), B = Math.atan2(I, g), C = 2 * (A.w * A.y - A.z * A.x), E = Math.abs(C) >= 1 ? Math.sign(C) * (Math.PI / 2) : Math.asin(C), D = 2 * (A.w * A.z + A.x * A.y), i = 1 - 2 * (A.y * A.y + A.z * A.z), w = Math.atan2(D, i), s = (B + Math.PI) / (2 * Math.PI), o = (E + Math.PI) / (2 * Math.PI), y = (w + Math.PI) / (2 * Math.PI), h = Math.round(s * 255), k = Math.round(o * 255); + return Math.round(y * 255) << 16 | k << 8 | h; +} +function cs(Q, A) { + const I = Q & 255, g = Q >>> 8 & 255, B = Q >>> 16 & 255, C = I / 255, E = g / 255, D = B / 255, i = C * (2 * Math.PI) - Math.PI, w = E * (2 * Math.PI) - Math.PI, s = D * (2 * Math.PI) - Math.PI, o = Math.cos(i * 0.5), y = Math.sin(i * 0.5), h = Math.cos(w * 0.5), k = Math.sin(w * 0.5), R = Math.cos(s * 0.5), F = Math.sin(s * 0.5); + return A.w = o * h * R + y * k * F, A.x = y * h * R - o * k * F, A.y = o * k * R + y * h * F, A.z = o * h * F - y * k * R, A.normalize(), A; +} +function YC(Q, A, I, g) { + const B = Math.sqrt(Q * Q + A * A + I * I + g * g), C = (g < 0 ? -Q : Q) / B, E = (g < 0 ? -A : A) / B, D = (g < 0 ? -I : I) / B, i = (g < 0 ? -g : g) / B, w = 2 * Math.acos(i), s = Math.sqrt(C * C + E * E + D * D), o = s < 1e-6 ? 1 : C / s, y = s < 1e-6 ? 0 : E / s, h = s < 1e-6 ? 0 : D / s, k = Math.abs(o) + Math.abs(y) + Math.abs(h); + let R = o / k, F = y / k; + if (h < 0) { + const U = R; + R = (1 - Math.abs(F)) * (R >= 0 ? 1 : -1), F = (1 - Math.abs(U)) * (F >= 0 ? 1 : -1); + } + const S = R * 0.5 + 0.5, a = F * 0.5 + 0.5, M = Math.round(S * 1023), c = Math.round(a * 1023); + return Math.round(w * (4095 / Math.PI)) << 20 | c << 10 | M; +} +function KC(Q, A) { + const I = Q & 1023, g = Q >>> 10 & 1023, B = Q >>> 20 & 4095, C = I / 1023, E = g / 1023; + let D = (C - 0.5) * 2, i = (E - 0.5) * 2; + const w = 1 - (Math.abs(D) + Math.abs(i)), s = Math.max(-w, 0); + D += D >= 0 ? -s : s, i += i >= 0 ? -s : s; + const o = Math.sqrt(D * D + i * i + w * w), y = o < 1e-6 ? 0 : D / o, h = o < 1e-6 ? 0 : i / o, k = o < 1e-6 ? 0 : w / o, F = B / 4095 * Math.PI * 0.5, S = Math.sin(F), a = Math.cos(F); + return A.set(y * S, h * S, k * S, a), A; +} +function Lg(Q, A, I, g) { + const B = Math.round(Math.max(-127, Math.min(127, Q * 127))), C = Math.round(Math.max(-127, Math.min(127, A * 127))), E = Math.round(Math.max(-127, Math.min(127, I * 127))), D = Math.round(Math.max(-127, Math.min(127, g * 127))); + return B & 255 | (C & 255) << 8 | (E & 255) << 16 | (D & 255) << 24; +} +function Ms(Q, A, I, g) { + const C = 63 / ((g == null ? void 0 : g.sh1Max) ?? 1), E = A * 2; + for (let D = 0; D < 9; ++D) { + const i = I[D] * C, w = Math.round(Math.max(-63, Math.min(63, i))) & 127, s = D * 7, o = s + 7, y = Math.floor(s / 32), h = s - y * 32, k = w << h & 4294967295; + if (Q[E + y] |= k, o > y * 32 + 32) { + const R = w >>> 32 - h & 4294967295; + Q[E + y + 1] |= R; + } + } +} +function Js(Q, A, I, g) { + const C = 1 / ((g == null ? void 0 : g.sh2Max) ?? 1); + Q[A * 4 + 0] = Lg( + I[0] * C, + I[1] * C, + I[2] * C, + I[3] * C + ), Q[A * 4 + 1] = Lg( + I[4] * C, + I[5] * C, + I[6] * C, + I[7] * C + ), Q[A * 4 + 2] = Lg( + I[8] * C, + I[9] * C, + I[10] * C, + I[11] * C + ), Q[A * 4 + 3] = Lg( + I[12] * C, + I[13] * C, + I[14] * C, + 0 + ); +} +function Us(Q, A, I, g) { + const C = 31 / ((g == null ? void 0 : g.sh3Max) ?? 1), E = A * 4; + for (let D = 0; D < 21; ++D) { + const i = I[D] * C, w = Math.round(Math.max(-31, Math.min(31, i))) & 63, s = D * 6, o = s + 6, y = Math.floor(s / 32), h = s - y * 32, k = w << h & 4294967295; + if (Q[E + y] |= k, o > y * 32 + 32) { + const R = w >>> 32 - h & 4294967295; + Q[E + y + 1] |= R; + } + } +} +function lI(Q, A, I) { + const g = Math.abs(Q), B = Math.abs(A), C = Math.abs(I), E = Math.max(g, B, C), D = Math.floor(Math.log2(E)), i = Math.max(0, Math.min(31, D + 15)), w = 2 ** (i - 15) / 255, s = Math.round(Math.max(0, Math.min(255, g / w))), o = Math.round(Math.max(0, Math.min(255, B / w))), y = Math.round(Math.max(0, Math.min(255, C / w))), h = i << 3 | ((Q < 0 ? 1 : 0) | (A < 0 ? 2 : 0) | (I < 0 ? 4 : 0)); + return s | o << 8 | y << 16 | h << 24; +} +function ts(Q) { + const A = _Q.color, g = 2 ** ((Q >>> 27 & 31) - 15) / 255, B = (Q & 255) * g, C = (Q >>> 8 & 255) * g, E = (Q >>> 16 & 255) * g; + return A.r = Q & 16777216 ? -B : B, A.g = Q & 33554432 ? -C : C, A.b = Q & 67108864 ? -E : E, A; +} +function Hs(Q, A, I) { + const g = A * 4; + for (let B = 0; B < 3; ++B) { + const C = B * 3; + Q[g + B] = lI(I[C], I[C + 1], I[C + 2]); + } +} +function Ls(Q, A, I, g, B) { + const C = I * 4; + for (let E = 0; E < 3; ++E) { + const D = E * 3; + Q[C + E] = lI(g[D], g[D + 1], g[D + 2]); + } + Q[C + 3] = lI(B[0], B[1], B[2]); + for (let E = 1; E < 5; ++E) { + const D = E * 5; + A[C + (E - 1)] = lI( + B[D], + B[D + 1], + B[D + 2] + ); + } +} +function Ys(Q, A, I, g) { + const B = I * 4; + for (let C = 0; C < 4; ++C) { + const E = C * 3; + Q[B + C] = lI( + g[E], + g[E + 1], + g[E + 2] + ); + } + for (let C = 4; C < 7; ++C) { + const E = C * 3; + A[B + (C - 4)] = lI( + g[E], + g[E + 1], + g[E + 2] + ); + } +} +function eC(Q, A) { + const I = []; + let g = 0, B = null; + const C = new Mo((i, w) => { + if (I.push(i), g += i.length, w || g >= A) { + const s = new Uint8Array(g); + let o = 0; + for (const y of I) + s.set(y, o), o += y.length; + B = s.slice(0, A); + } + }), E = 1024; + let D = 0; + for (; B == null && D < Q.length; ) { + const i = Q.slice(D, D + E); + C.push(i, !1), D += E; + } + if (B == null && (C.push(new Uint8Array(), !0), B == null)) + throw new Error("Failed to decompress partial gzip"); + return B; +} +class rC { + constructor({ + fileBytes: A, + chunkBytes: I = 64 * 1024 + }) { + this.fileBytes = A, this.chunkBytes = I, this.chunks = [], this.totalBytes = 0; + const g = new DecompressionStream("gzip"), B = new Blob([A]).stream().pipeThrough(g); + this.reader = B.getReader(); + } + async read(A) { + for (; this.totalBytes < A; ) { + const { value: C, done: E } = await this.reader.read(); + if (E) + break; + this.chunks.push(C), this.totalBytes += C.length; + } + if (this.totalBytes < A) + throw new Error( + `Unexpected EOF: needed ${A}, got ${this.totalBytes}` + ); + const I = new Uint8Array(this.totalBytes); + let g = 0; + for (const C of this.chunks) + I.set(C, g), g += C.length; + const B = I.subarray(0, A); + return this.chunks = [I.subarray(A)], this.totalBytes -= A, B; + } +} +const lk = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + DataCache: vo, + FreeList: aC, + GunzipReader: rC, + IDENT_VERTEX_SHADER: MC, + Sint8ToFloat: jo, + Uint8ToFloat: Wo, + averagePositions: JC, + averageQuaternions: UC, + cloneClock: IB, + coinciDist: tC, + computeMaxSplats: ws, + coorientDist: HC, + decodeExtRgb: ts, + decodeExtSplat: eQ, + decodeQuatEulerXyz888: cs, + decodeQuatOctXy1010R12: KC, + decodeQuatOctXy88R8: LC, + decodeQuatXyz888: Ss, + decompressPartialGzip: eC, + encodeExt3Rgb: Ys, + encodeExtRgb: lI, + encodeExtSh12Rgb: Ls, + encodeExtSh1Rgb: Hs, + encodeExtSplat: KQ, + encodeQuatEulerXyz888: Ns, + encodeQuatOctXy1010R12: YC, + encodeQuatOctXy88R8: gB, + encodeQuatXyz888: Fs, + encodeSh1Rgb: Ms, + encodeSh2Rgb: Js, + encodeSh3Rgb: Us, + epsilonSign: ks, + flipPixels: ss, + floatBitsToUint: qg, + floatToSint8: lg, + floatToUint8: jA, + fromHalf: NA, + getTextureSize: BA, + getTransferable: zQ, + isAndroid: $Q, + isIos: Rg, + isMobile: Tg, + isOculus: AB, + isQuest2: os, + isVisionPro: cC, + mapFilterObject: _o, + mapObject: zo, + newArray: YQ, + normalize: SC, + omitUndefined: ys, + pixelsToPngUrl: Gs, + setPackedSplat: rQ, + setPackedSplatCenter: $o, + setPackedSplatOpacity: Bs, + setPackedSplatQuat: Is, + setPackedSplatRgb: Qs, + setPackedSplatRgba: gs, + setPackedSplatScales: As, + threeMrtArray: kC, + threeRevision: RC, + toHalf: VA, + uintBitsToFloat: xg, + unpackSplat: nQ, + withinCoinciDist: Rs, + withinCoorientDist: Og, + withinDist: hs +}, Symbol.toStringTag, { value: "Module" })); +class Ks { + constructor() { + this.messages = {}, this.messageIdNext = 0, this.worker = new oo(), this.worker.onmessage = (A) => this.onMessage(A); + } + makeMessageId() { + return ++this.messageIdNext; + } + makeMessagePromiseId() { + const A = this.makeMessageId(), I = new Promise((g, B) => { + this.messages[A] = { resolve: g, reject: B }; + }); + return { id: A, promise: I }; + } + onMessage(A) { + const { id: I, result: g, error: B } = A.data, C = this.messages[I]; + C && (delete this.messages[I], B ? C.reject(B) : C.resolve(g)); + } + // Invoke an RPC on the worker with the given name and arguments. + // The normal usage of a worker is to run one activity at a time, + // but this function allows for concurrent calls, tagging each request + // with a unique message Id and awaiting a response to that same Id. + // The method will automatically transfer any ArrayBuffers in the + // arguments to the worker. If you'd like to transfer a copy of a + // buffer then you must clone it before passing to this function. + async call(A, I) { + const { id: g, promise: B } = this.makeMessagePromiseId(); + return this.worker.postMessage( + { name: A, args: I, id: g }, + { transfer: zQ(I) } + ), B; + } +} +let nC = 4, mg = 0; +const dC = [], qC = []; +async function es() { + const Q = dC.shift(); + if (Q) + return Q; + if (mg < nC) { + const A = new Ks(); + return mg += 1, A; + } + return new Promise((A) => { + qC.push(A); + }); +} +function rs(Q) { + if (mg > nC) { + mg -= 1; + return; + } + const A = qC.shift(); + if (A) { + A(Q); + return; + } + dC.push(Q); +} +async function nI(Q) { + const A = await es(); + try { + return await Q(A); + } finally { + rs(A); + } +} +const ns = new Bo(-1, 1, 1, -1, 0, 1); +class ds extends Co { + constructor() { + super(), this.setAttribute("position", new tB([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new tB([0, 2, 0, 0, 2, 0], 2)); + } +} +const qs = new ds(); +class QB { + /** + * Constructs a new full screen quad. + * + * @param {?Material} material - The material to render te full screen quad with. + */ + constructor(A) { + this._mesh = new Qo(qs, A); + } + /** + * Frees the GPU-related resources allocated by this instance. Call this + * method whenever the instance is no longer used in your app. + */ + dispose() { + this._mesh.geometry.dispose(); + } + /** + * Renders the full screen quad. + * + * @param {WebGLRenderer} renderer - The renderer. + */ + render(A) { + A.render(this._mesh, ns); + } + /** + * The quad's material. + * + * @type {?Material} + */ + get material() { + return this._mesh.material; + } + set material(A) { + this._mesh.material = A; + } +} +const xC = '(function(){"use strict";class a{static __wrap(A){A=A>>>0;const g=Object.create(a.prototype);return g.__wbg_ptr=A,IA.register(g,g.__wbg_ptr,g),g}__destroy_into_raw(){const A=this.__wbg_ptr;return this.__wbg_ptr=0,IA.unregister(this),A}free(){const A=this.__destroy_into_raw();C.__wbg_chunkdecoder_free(A,0)}finish(){const A=this.__destroy_into_raw(),g=C.chunkdecoder_finish(A);if(g[2])throw w(g[1]);return w(g[0])}push(A){const g=C.chunkdecoder_push(this.__wbg_ptr,A);if(g[1])throw w(g[0])}}Symbol.dispose&&(a.prototype[Symbol.dispose]=a.prototype.free);class Z{static __wrap(A){A=A>>>0;const g=Object.create(Z.prototype);return g.__wbg_ptr=A,gA.register(g,g.__wbg_ptr,g),g}__destroy_into_raw(){const A=this.__wbg_ptr;return this.__wbg_ptr=0,gA.unregister(this),A}free(){const A=this.__destroy_into_raw();C.__wbg_csplatarray_free(A,0)}bhatt_lod(A){C.csplatarray_bhatt_lod(this.__wbg_ptr,A)}has_lod(){return C.csplatarray_has_lod(this.__wbg_ptr)!==0}inject_rgba8(A){C.csplatarray_inject_rgba8(this.__wbg_ptr,A)}len(){return C.csplatarray_len(this.__wbg_ptr)>>>0}tiny_lod(A,g){C.csplatarray_tiny_lod(this.__wbg_ptr,A,g)}to_extsplats(){const A=C.csplatarray_to_extsplats(this.__wbg_ptr);if(A[2])throw w(A[1]);return w(A[0])}to_extsplats_lod(){const A=C.csplatarray_to_extsplats_lod(this.__wbg_ptr);if(A[2])throw w(A[1]);return w(A[0])}to_packedsplats(){const A=C.csplatarray_to_packedsplats(this.__wbg_ptr);if(A[2])throw w(A[1]);return w(A[0])}to_packedsplats_lod(){const A=C.csplatarray_to_packedsplats_lod(this.__wbg_ptr);if(A[2])throw w(A[1]);return w(A[0])}get maxShDegree(){return C.__wbg_get_csplatarray_maxShDegree(this.__wbg_ptr)>>>0}get numSplats(){return C.__wbg_get_csplatarray_numSplats(this.__wbg_ptr)>>>0}set maxShDegree(A){C.__wbg_set_csplatarray_maxShDegree(this.__wbg_ptr,A)}set numSplats(A){C.__wbg_set_csplatarray_numSplats(this.__wbg_ptr,A)}}Symbol.dispose&&(Z.prototype[Symbol.dispose]=Z.prototype.free);class T{static __wrap(A){A=A>>>0;const g=Object.create(T.prototype);return g.__wbg_ptr=A,QA.register(g,g.__wbg_ptr,g),g}__destroy_into_raw(){const A=this.__wbg_ptr;return this.__wbg_ptr=0,QA.unregister(this),A}free(){const A=this.__destroy_into_raw();C.__wbg_gsplatarray_free(A,0)}get maxShDegree(){return C.__wbg_get_gsplatarray_maxShDegree(this.__wbg_ptr)>>>0}get numSplats(){return C.__wbg_get_gsplatarray_numSplats(this.__wbg_ptr)>>>0}bhatt_lod(A){C.gsplatarray_bhatt_lod(this.__wbg_ptr,A)}has_lod(){return C.gsplatarray_has_lod(this.__wbg_ptr)!==0}inject_rgba8(A){C.gsplatarray_inject_rgba8(this.__wbg_ptr,A)}len(){return C.gsplatarray_len(this.__wbg_ptr)>>>0}tiny_lod(A,g){C.gsplatarray_tiny_lod(this.__wbg_ptr,A,g)}to_extsplats(){const A=C.gsplatarray_to_extsplats(this.__wbg_ptr);if(A[2])throw w(A[1]);return w(A[0])}to_extsplats_lod(){const A=C.gsplatarray_to_extsplats_lod(this.__wbg_ptr);if(A[2])throw w(A[1]);return w(A[0])}to_packedsplats(A){const g=C.gsplatarray_to_packedsplats(this.__wbg_ptr,A);if(g[2])throw w(g[1]);return w(g[0])}to_packedsplats_lod(A){const g=C.gsplatarray_to_packedsplats_lod(this.__wbg_ptr,A);if(g[2])throw w(g[1]);return w(g[0])}set maxShDegree(A){C.__wbg_set_gsplatarray_maxShDegree(this.__wbg_ptr,A)}set numSplats(A){C.__wbg_set_gsplatarray_numSplats(this.__wbg_ptr,A)}}Symbol.dispose&&(T.prototype[Symbol.dispose]=T.prototype.free);function wA(I,A,g,Q,B,D){const E=C.bhatt_lod_extsplats(I,A,g,R(Q)?0:M(Q),B,R(D)?0:M(D));if(E[2])throw w(E[1]);return w(E[0])}function GA(I,A,g,Q,B,D){const E=C.bhatt_lod_packedsplats(I,A,R(g)?0:M(g),Q,R(B)?0:M(B),D);if(E[2])throw w(E[1]);return w(E[0])}function oA(I,A,g){var Q=R(I)?0:U(I,C.__wbindgen_malloc,C.__wbindgen_realloc),B=k,D=R(A)?0:U(A,C.__wbindgen_malloc,C.__wbindgen_realloc),E=k;const i=C.decode_to_csplatarray(Q,B,D,E,g);if(i[2])throw w(i[1]);return a.__wrap(i[0])}function yA(I,A,g,Q,B){var D=R(I)?0:U(I,C.__wbindgen_malloc,C.__wbindgen_realloc),E=k,i=R(A)?0:U(A,C.__wbindgen_malloc,C.__wbindgen_realloc),y=k;const o=C.decode_to_extsplats(D,E,i,y,R(g)?0:M(g),R(Q)?0:M(Q),R(B)?0:M(B));if(o[2])throw w(o[1]);return a.__wrap(o[0])}function RA(I,A){var g=R(I)?0:U(I,C.__wbindgen_malloc,C.__wbindgen_realloc),Q=k,B=R(A)?0:U(A,C.__wbindgen_malloc,C.__wbindgen_realloc),D=k;const E=C.decode_to_gsplatarray(g,Q,B,D);if(E[2])throw w(E[1]);return a.__wrap(E[0])}function kA(I,A,g,Q,B,D){var E=R(I)?0:U(I,C.__wbindgen_malloc,C.__wbindgen_realloc),i=k,y=R(A)?0:U(A,C.__wbindgen_malloc,C.__wbindgen_realloc),o=k;const G=C.decode_to_packedsplats(E,i,y,o,g,R(Q)?0:M(Q),R(B)?0:M(B),R(D)?0:M(D));if(G[2])throw w(G[1]);return a.__wrap(G[0])}function FA(I){C.dispose_lod_tree(I)}function NA(I,A){const g=C.get_lod_tree_level(I,A);if(g[2])throw w(g[1]);return w(g[0])}function SA(I,A){const g=C.init_lod_tree(I,A);if(g[2])throw w(g[1]);return w(g[0])}function JA(I){const A=C.new_lod_tree(I);if(A[2])throw w(A[1]);return w(A[0])}function MA(I){const A=C.new_shared_lod_tree(I);if(A[2])throw w(A[1]);return w(A[0])}function hA(I,A,g){return C.sort32_splats(I,A,g)>>>0}function sA(I,A,g){return C.sort_splats(I,A,g)>>>0}function UA(I,A,g,Q,B,D,E){const i=C.tiny_lod_extsplats(I,A,g,R(Q)?0:M(Q),B,D,R(E)?0:M(E));if(i[2])throw w(i[1]);return w(i[0])}function HA(I,A,g,Q,B,D,E){const i=C.tiny_lod_packedsplats(I,A,R(g)?0:M(g),Q,B,R(D)?0:M(D),E);if(i[2])throw w(i[1]);return w(i[0])}function LA(I,A,g,Q,B,D,E,i,y,o,G){const S=O(Q,C.__wbindgen_malloc),J=k,h=O(B,C.__wbindgen_malloc),L=k,c=r(D,C.__wbindgen_malloc),H=k,s=r(E,C.__wbindgen_malloc),F=k,N=r(i,C.__wbindgen_malloc),d=k,x=r(y,C.__wbindgen_malloc),m=k,e=r(o,C.__wbindgen_malloc),K=k,Y=r(G,C.__wbindgen_malloc),f=k,p=C.traverse_lod_trees(I,A,R(g)?4294967297:Math.fround(g),S,J,h,L,c,H,s,F,N,d,x,m,e,K,Y,f);if(p[2])throw w(p[1]);return w(p[0])}function cA(I,A,g,Q,B){const D=O(I,C.__wbindgen_malloc),E=k,i=O(A,C.__wbindgen_malloc),y=k,o=O(g,C.__wbindgen_malloc),G=k,S=O(Q,C.__wbindgen_malloc),J=k,h=C.update_lod_trees(D,E,i,y,o,G,S,J,B);if(h[2])throw w(h[1]);return w(h[0])}function YA(){return{__proto__:null,"./spark_worker_rs_bg.js":{__proto__:null,__wbg_Error_2e59b1b37a9a34c3:function(A,g){return Error(z(A,g))},__wbg___wbindgen_boolean_get_a86c216575a75c30:function(A){const g=A,Q=typeof g=="boolean"?g:void 0;return R(Q)?16777215:Q?1:0},__wbg___wbindgen_debug_string_dd5d2d07ce9e6c57:function(A,g){const Q=_(g),B=U(Q,C.__wbindgen_malloc,C.__wbindgen_realloc),D=k;q().setInt32(A+4,D,!0),q().setInt32(A+0,B,!0)},__wbg___wbindgen_in_4bd7a57e54337366:function(A,g){return A in g},__wbg___wbindgen_is_falsy_c6ddfae1bb56d5ef:function(A){return!A},__wbg___wbindgen_is_object_40c5a80572e8f9d3:function(A){const g=A;return typeof g=="object"&&g!==null},__wbg___wbindgen_is_undefined_c0cca72b82b86f4d:function(A){return A===void 0},__wbg___wbindgen_jsval_loose_eq_3a72ae764d46d944:function(A,g){return A==g},__wbg___wbindgen_number_get_7579aab02a8a620c:function(A,g){const Q=g,B=typeof Q=="number"?Q:void 0;q().setFloat64(A+8,R(B)?0:B,!0),q().setInt32(A+0,!R(B),!0)},__wbg___wbindgen_string_get_914df97fcfa788f2:function(A,g){const Q=g,B=typeof Q=="string"?Q:void 0;var D=R(B)?0:U(B,C.__wbindgen_malloc,C.__wbindgen_realloc),E=k;q().setInt32(A+4,E,!0),q().setInt32(A+0,D,!0)},__wbg___wbindgen_throw_81fc77679af83bc6:function(A,g){throw new Error(z(A,g))},__wbg_csplatarray_new:function(A){return Z.__wrap(A)},__wbg_error_a6fa202b58aa1cd3:function(A,g){let Q,B;try{Q=A,B=g,console.error(z(A,g))}finally{C.__wbindgen_free(Q,B,1)}},__wbg_get_4848e350b40afc16:function(A,g){return A[g>>>0]},__wbg_get_f96702c6245e4ef9:function(){return EA(function(A,g){return Reflect.get(A,g)},arguments)},__wbg_get_unchecked_7d7babe32e9e6a54:function(A,g){return A[g>>>0]},__wbg_get_with_ref_key_6412cf3094599694:function(A,g){return A[g]},__wbg_gsplatarray_new:function(A){return T.__wrap(A)},__wbg_instanceof_ArrayBuffer_ff7c1337a5e3b33a:function(A){let g;try{g=A instanceof ArrayBuffer}catch{g=!1}return g},__wbg_instanceof_Uint8Array_4b8da683deb25d72:function(A){let g;try{g=A instanceof Uint8Array}catch{g=!1}return g},__wbg_length_0c32cb8543c8e4c8:function(A){return A.length},__wbg_length_1e701798fdcaa3b4:function(A){return A.length},__wbg_length_6e821edde497a532:function(A){return A.length},__wbg_length_a4ca9e78359b5f1f:function(A){return A.length},__wbg_new_227d7c05414eb861:function(){return new Error},__wbg_new_4f9fafbb3909af72:function(){return new Object},__wbg_new_a560378ea1240b14:function(A){return new Uint8Array(A)},__wbg_new_f3c9df4f38f3f798:function(){return new Array},__wbg_new_with_length_41a22191b9bdfd66:function(A){return new Uint32Array(A>>>0)},__wbg_prototypesetcall_3e05eb9545565046:function(A,g,Q){Uint8Array.prototype.set.call(aA(A,g),Q)},__wbg_prototypesetcall_64c287a27cc24d27:function(A,g,Q){Uint16Array.prototype.set.call(KA(A,g),Q)},__wbg_prototypesetcall_e42275e601e14eeb:function(A,g,Q){Uint32Array.prototype.set.call(BA(A,g),Q)},__wbg_push_6bdbc990be5ac37b:function(A,g){return A.push(g)},__wbg_set_448126769bf7c181:function(A,g,Q){A.set(BA(g,Q))},__wbg_set_6be42768c690e380:function(A,g,Q){A[g]=Q},__wbg_set_81b4174352e6a095:function(A,g,Q){A.set(g,Q>>>0)},__wbg_set_8ee2d34facb8466e:function(){return EA(function(A,g,Q){return Reflect.set(A,g,Q)},arguments)},__wbg_set_index_338a66e40fc45dee:function(A,g,Q){A[g>>>0]=Q>>>0},__wbg_stack_3b0d974bbf31e44f:function(A,g){const Q=g.stack,B=U(Q,C.__wbindgen_malloc,C.__wbindgen_realloc),D=k;q().setInt32(A+4,D,!0),q().setInt32(A+0,B,!0)},__wbg_subarray_0f98d3fb634508ad:function(A,g,Q){return A.subarray(g>>>0,Q>>>0)},__wbg_subarray_517cd0f1811ab872:function(A,g,Q){return A.subarray(g>>>0,Q>>>0)},__wbg_subarray_d51e89458b3fdbf6:function(A,g,Q){return A.subarray(g>>>0,Q>>>0)},__wbindgen_cast_0000000000000001:function(A){return A},__wbindgen_cast_0000000000000002:function(A,g){return z(A,g)},__wbindgen_init_externref_table:function(){const A=C.__wbindgen_externrefs,g=A.grow(4);A.set(0,void 0),A.set(g+0,void 0),A.set(g+1,null),A.set(g+2,!0),A.set(g+3,!1)}}}}const IA=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(I=>C.__wbg_chunkdecoder_free(I>>>0,1)),gA=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(I=>C.__wbg_csplatarray_free(I>>>0,1)),QA=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(I=>C.__wbg_gsplatarray_free(I>>>0,1));function M(I){const A=C.__externref_table_alloc();return C.__wbindgen_externrefs.set(A,I),A}function _(I){const A=typeof I;if(A=="number"||A=="boolean"||I==null)return`${I}`;if(A=="string")return`"${I}"`;if(A=="symbol"){const B=I.description;return B==null?"Symbol":`Symbol(${B})`}if(A=="function"){const B=I.name;return typeof B=="string"&&B.length>0?`Function(${B})`:"Function"}if(Array.isArray(I)){const B=I.length;let D="[";B>0&&(D+=_(I[0]));for(let E=1;E1)Q=g[1];else return toString.call(I);if(Q=="Object")try{return"Object("+JSON.stringify(I)+")"}catch{return"Object"}return I instanceof Error?`${I.name}: ${I.message}\n${I.stack}`:Q}function KA(I,A){return I=I>>>0,dA().subarray(I/2,I/2+A)}function BA(I,A){return I=I>>>0,CA().subarray(I/4,I/4+A)}function aA(I,A){return I=I>>>0,l().subarray(I/1,I/1+A)}let t=null;function q(){return(t===null||t.buffer.detached===!0||t.buffer.detached===void 0&&t.buffer!==C.memory.buffer)&&(t=new DataView(C.memory.buffer)),t}let n=null;function qA(){return(n===null||n.byteLength===0)&&(n=new Float32Array(C.memory.buffer)),n}function z(I,A){return I=I>>>0,tA(I,A)}let X=null;function dA(){return(X===null||X.byteLength===0)&&(X=new Uint16Array(C.memory.buffer)),X}let V=null;function CA(){return(V===null||V.byteLength===0)&&(V=new Uint32Array(C.memory.buffer)),V}let W=null;function l(){return(W===null||W.byteLength===0)&&(W=new Uint8Array(C.memory.buffer)),W}function EA(I,A){try{return I.apply(this,A)}catch(g){const Q=M(g);C.__wbindgen_exn_store(Q)}}function R(I){return I==null}function O(I,A){const g=A(I.length*4,4)>>>0;return CA().set(I,g/4),k=I.length,g}function r(I,A){const g=A(I.length*4,4)>>>0;return qA().set(I,g/4),k=I.length,g}function U(I,A,g){if(g===void 0){const i=j.encode(I),y=A(i.length,1)>>>0;return l().subarray(y,y+i.length).set(i),k=i.length,y}let Q=I.length,B=A(Q,1)>>>0;const D=l();let E=0;for(;E127)break;D[B+E]=i}if(E!==Q){E!==0&&(I=I.slice(E)),B=g(B,Q,Q=E+I.length*3,1)>>>0;const i=l().subarray(B+E,B+Q),y=j.encodeInto(I,i);E+=y.written,B=g(B,Q,E,1)>>>0}return k=E,B}function w(I){const A=C.__wbindgen_externrefs.get(I);return C.__externref_table_dealloc(I),A}let v=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0});v.decode();const xA=2146435072;let $=0;function tA(I,A){return $+=A,$>=xA&&(v=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),v.decode(),$=A),v.decode(l().subarray(I,I+A))}const j=new TextEncoder;"encodeInto"in j||(j.encodeInto=function(I,A){const g=j.encode(I);return A.set(g),{read:I.length,written:g.length}});let k=0,C;function PA(I,A){return C=I.exports,t=null,n=null,X=null,V=null,W=null,C.__wbindgen_start(),C}async function bA(I,A){if(typeof Response=="function"&&I instanceof Response){if(typeof WebAssembly.instantiateStreaming=="function")try{return await WebAssembly.instantiateStreaming(I,A)}catch(B){if(I.ok&&g(I.type)&&I.headers.get("Content-Type")!=="application/wasm")console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n",B);else throw B}const Q=await I.arrayBuffer();return await WebAssembly.instantiate(Q,A)}else{const Q=await WebAssembly.instantiate(I,A);return Q instanceof WebAssembly.Instance?{instance:Q,module:I}:Q}function g(Q){switch(Q){case"basic":case"cors":case"default":return!0}return!1}}async function fA(I){if(C!==void 0)return C;I!==void 0&&(Object.getPrototypeOf(I)===Object.prototype?{module_or_path:I}=I:console.warn("using deprecated parameters for the initialization function; pass a single object instead")),I===void 0&&(I=new URL("data:application/wasm;base64,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",self.location.href));const A=YA();(typeof I=="string"||typeof Request=="function"&&I instanceof Request||typeof URL=="function"&&I instanceof URL)&&(I=fetch(I));const{instance:g}=await bA(await I,A);return PA(g)}const pA={sortSplats16:OA,sortSplats32:rA,loadPackedSplats:ZA,loadExtSplats:TA,tinyLodPackedSplats:nA,qualityLodPackedSplats:XA,tinyLodExtSplats:VA,qualityLodExtSplats:WA,newLodTree:lA,newSharedLodTree:jA,initLodTree:mA,disposeLodTree:eA,updateLodTrees:zA,traverseLodTrees:vA,getLodTreeLevel:uA,nextChunk:_A};async function DA(I){const{id:A,name:g,args:Q}=I.data;try{const B=pA[g];if(!B)throw new Error(`Unknown worker RPC: ${g}`);const E=await B(Q,{sendStatus:i=>{self.postMessage({id:A,status:i},{transfer:AA(i)})}});self.postMessage({id:A,result:E},{transfer:AA(E)})}catch(B){console.warn(`Worker error: ${B}`),self.postMessage({id:A,error:B},{transfer:AA(B)})}}function OA({numSplats:I,readback:A,ordering:g}){return{activeSplats:sA(I,A,g),readback:A,ordering:g}}function rA({numSplats:I,readback:A,ordering:g}){return{activeSplats:hA(I,A,g),readback:A,ordering:g}}async function u({decoder:I,fileBytes:A,url:g,requestHeader:Q,withCredentials:B,chunked:D,chunkedLength:E,sendStatus:i}){if(A)for(let G=0;G{iA=h});i({nextChunk:!0});const J=await S;if(J.length===0)break;I.push(J),o+=J.length,i({progress:{loaded:o,total:G}})}G===0&&i({progress:{loaded:o,total:o}})}else throw new Error("No url or fileBytes provided");return I.finish()}function P(I){return{numSplats:I.numSplats,packedArray:I.packed,extra:{sh1:I.sh1,sh2:I.sh2,sh3:I.sh3,sh1Codes:I.sh1Codes,sh2Codes:I.sh2Codes,sh3Codes:I.sh3Codes,lodTree:I.lodTree},splatEncoding:I.splatEncoding}}async function ZA({url:I,requestHeader:A,withCredentials:g,fileBytes:Q,fileType:B,pathName:D,chunked:E,chunkedLength:i,encoding:y,lod:o,lodBase:G,lodAbove:S,nonLod:J,sh1Codes:h,sh2Codes:L,sh3Codes:c},{sendStatus:H}){if(!o){const Y=kA(B,D??I,y,h,L,c),f=await u({decoder:Y,fileBytes:Q,url:I,requestHeader:A,withCredentials:g,chunked:E,chunkedLength:i,sendStatus:H}),p=P(f);return p.splatEncoding.lodOpacity?{lodSplats:p}:p}const s=oA(B,D??I,y),F=await u({decoder:s,fileBytes:Q,url:I,requestHeader:A,withCredentials:g,chunked:E,chunkedLength:i,sendStatus:H});if(F.has_lod())return{lodSplats:P(F.to_packedsplats_lod())};if(S!==void 0&&F.len() ${F.len()} (${e} ms)`);const K=F.to_packedsplats_lod();return N.lodSplats=P(K),N}function b(I){return{numSplats:I.numSplats,extArrays:[I.ext0,I.ext1],extra:{sh1:I.sh1,sh2:I.sh2,sh3a:I.sh3a,sh3b:I.sh3b,sh1Codes:I.sh1Codes,sh2Codes:I.sh2Codes,sh3Codes:I.sh3Codes,lodTree:I.lodTree}}}async function TA({url:I,requestHeader:A,withCredentials:g,fileBytes:Q,fileType:B,pathName:D,chunked:E,chunkedLength:i,lod:y,lodBase:o,lodAbove:G,nonLod:S,sh1Codes:J,sh2Codes:h,sh3Codes:L},{sendStatus:c}){if(!y){const K=yA(B,D??I,J,h,L),Y=await u({decoder:K,fileBytes:Q,url:I,requestHeader:A,withCredentials:g,chunked:E,chunkedLength:i,sendStatus:c}),f=b(Y);return f.extra.lodTree?{lodSplats:f}:f}const H=RA(B,D??I),s=await u({decoder:H,fileBytes:Q,url:I,requestHeader:A,withCredentials:g,chunked:E,chunkedLength:i,sendStatus:c});if(s.has_lod())return{lodSplats:b(s.to_extsplats_lod())};if(G!==void 0&&s.len() ${s.len()} (${m} ms)`);const e=s.to_extsplats_lod();return F.lodSplats=b(e),F}async function nA({numSplats:I,packedArray:A,extra:g,lodBase:Q,rgba:B,encoding:D}){const E=Math.max(1.1,Math.min(2,Q??1.5)),i=performance.now(),o=HA(I,A,g,E,!1,B,D),G=performance.now()-i,S=P(o);return console.log(`Tiny LoD: ${I} -> ${S.numSplats} (${G} ms)`),S}async function XA({numSplats:I,packedArray:A,extra:g,lodBase:Q,rgba:B,encoding:D}){const E=Math.max(1.1,Math.min(2,Q??1.75)),i=performance.now(),y=GA(I,A,g,E,B,D),o=performance.now()-i,G=P(y);return console.log(`Bhatt LoD: ${I} -> ${G.numSplats} (${o} ms)`),G}async function VA({numSplats:I,extArrays:A,extra:g,lodBase:Q,rgba:B,encoding:D}){const E=Math.max(1.1,Math.min(2,Q??1.5)),i=performance.now(),o=UA(I,A[0],A[1],g,E,!1,B),G=performance.now()-i,S=b(o);return console.log(`Tiny LoD: ${I} -> ${S.numSplats} (${G} ms)`),S}async function WA({numSplats:I,extArrays:A,extra:g,lodBase:Q,rgba:B,encoding:D}){const E=Math.max(1.1,Math.min(2,Q??1.75)),i=performance.now(),y=wA(I,A[0],A[1],g,E,B),o=performance.now()-i,G=b(y);return console.log(`Bhatt LoD: ${I} -> ${G.numSplats} (${o} ms)`),G}function lA({capacity:I}){const{lodId:A}=JA(I);return{lodId:A}}function jA({lodId:I}){const{lodId:A}=MA(I);return{lodId:A}}function mA({numSplats:I,lodTree:A}){const{lodId:g,chunkToPage:Q}=SA(I,A);return{lodId:g,chunkToPage:Q}}function eA({lodId:I}){FA(I)}function zA({ranges:I}){const A=new Uint32Array(I.map(({lodId:E})=>E)),g=new Uint32Array(I.map(({pageBase:E})=>E)),Q=new Uint32Array(I.map(({chunkBase:E})=>E)),B=new Uint32Array(I.map(({count:E})=>E)),D=I.map(({lodTreeData:E})=>E);cA(A,g,Q,B,D)}function vA({maxSplats:I,pixelScaleLimit:A,lastPixelLimit:g,instances:Q}){const B=Object.entries(Q),D=new Uint32Array(B.map(([F,N])=>N.lodId)),E=new Uint32Array(B.map(([F,N])=>N.rootPage??4294967295)),i=new Float32Array(B.flatMap(([F,N])=>{if(N.viewToObjectCols.length!==16)throw new Error("Incorrect array size for viewToObjectCols");return N.viewToObjectCols})),y=new Float32Array(B.map(([F,N])=>N.lodScale)),o=new Float32Array(B.map(([F,N])=>N.behindFoveate)),G=new Float32Array(B.map(([F,N])=>N.coneFov0)),S=new Float32Array(B.map(([F,N])=>N.coneFov)),J=new Float32Array(B.map(([F,N])=>N.coneFoveate)),h=LA(I,A,g,D,E,i,y,o,J,G,S),{instanceIndices:L,chunks:c,pixelLimit:H}=h;return{keyIndices:B.reduce((F,[N,d],x)=>(F[N]=L[x],F),{}),chunks:c,pixelLimit:H}}function uA({lodId:I,level:A}){return NA(I,A)}let iA=I=>{};async function _A({chunk:I}){iA(I)}function AA(I){const A=[],g=new Set;function Q(B){B&&typeof B=="object"&&!g.has(B)&&(g.add(B),B instanceof ArrayBuffer?A.push(B):ArrayBuffer.isView(B)?A.push(B.buffer):Array.isArray(B)?B.forEach(Q):Object.values(B).forEach(Q))}return Q(I),A}async function $A(){const I=[],A=g=>{I.push(g)};self.addEventListener("message",A),await fA(),self.removeEventListener("message",A),self.addEventListener("message",DA);for(const g of I)DA(g);I.length=0}$A().catch(console.error)})();\n//# sourceMappingURL=worker-C9LcsNvD.js.map\n', eB = typeof self < "u" && self.Blob && new Blob([xC], { type: "text/javascript;charset=utf-8" }); +function xs(Q) { + let A; + try { + if (A = eB && (self.URL || self.webkitURL).createObjectURL(eB), !A) throw ""; + const I = new Worker(A, { + name: Q == null ? void 0 : Q.name + }); + return I.addEventListener("error", () => { + (self.URL || self.webkitURL).revokeObjectURL(A); + }), I; + } catch { + return new Worker( + "data:text/javascript;charset=utf-8," + encodeURIComponent(xC), + { + name: Q == null ? void 0 : Q.name + } + ); + } finally { + A && (self.URL || self.webkitURL).revokeObjectURL(A); + } +} +const _g = class _g { + constructor() { + this.queue = null, this.messages = {}, this.worker = new xs(), this.worker.onmessage = (A) => this.onMessage(A); + } + onMessage(A) { + var D; + const { id: I, result: g, error: B, status: C } = A.data, E = this.messages[I]; + E && (B !== void 0 ? (delete this.messages[I], E.reject(B)) : C !== void 0 ? (D = E.onStatus) == null || D.call(E, C) : (delete this.messages[I], E.resolve(g))); + } + tryExclusive(A) { + return this.queue == null ? this.exclusive(A) : null; + } + async exclusive(A) { + const I = this.queue; + I != null ? await new Promise((g) => { + I.push(() => g(void 0)); + }) : this.queue = []; + try { + return await A(this); + } finally { + this.queue != null && (this.queue.length === 0 ? this.queue = null : this.queue.shift()()); + } + } + async call(A, I, g = {}) { + const B = ++_g.currentId, C = new Promise((E, D) => { + this.messages[B] = { resolve: E, reject: D, onStatus: g.onStatus }; + }); + return this.worker.postMessage( + { id: B, name: A, args: I }, + { transfer: zQ(I) } + ), await C; + } + dispose() { + this.worker.terminate(); + const A = Object.values(this.messages); + this.messages = {}; + for (const I of A) + I.reject(new Error("Worker terminate")); + } +}; +_g.currentId = 0; +let kg = _g; +class ls { + constructor(A = 4) { + this.numWorkers = 0, this.freelist = [], this.queue = [], this.maxWorkers = A; + } + async withWorker(A) { + const I = await this.allocWorker(); + try { + return await A(I); + } finally { + this.freeWorker(I); + } + } + async allocWorker() { + const A = this.freelist.pop(); + if (A) + return A; + if (this.numWorkers < this.maxWorkers) { + const I = new kg(); + return this.numWorkers += 1, I; + } + return new Promise((I) => { + this.queue.push(I); + }); + } + freeWorker(A) { + if (this.numWorkers > this.maxWorkers) { + this.numWorkers -= 1; + return; + } + const I = this.queue.shift(); + if (I) { + I(A); + return; + } + this.freelist.push(A); + } +} +const gQ = new ls(), Z = { type: "Gsplat" }, eA = { type: "CovSplat" }, tg = { type: "PackedSplats" }, BB = { type: "ExtSplats" }, lC = { type: "CovSplats" }, ps = (Q) => new bC({ packedSplats: Q }), _I = (Q, A) => new uC({ packedSplats: Q, index: A }), pC = (Q, A, I, g) => new TC({ packedSplats: Q, index: A, base: I, count: g }), fs = (Q) => new OC({ extSplats: Q }), fC = (Q, A) => new mC({ extSplats: Q, index: A }), bs = (Q) => new ZC({ covsplats: Q }), Ps = (Q, A) => new VC({ covSplats: Q, index: A }), Zg = (Q) => new XC({ gsplat: Q }), uA = (Q) => new WC({ gsplat: Q }), CI = ({ + gsplat: Q, + flags: A, + index: I, + center: g, + scales: B, + quaternion: C, + rgba: E, + rgb: D, + opacity: i, + x: w, + y: s, + z: o, + r: y, + g: h, + b: k +}) => new jC({ + gsplat: Q, + flags: A, + index: I, + center: g, + scales: B, + quaternion: C, + rgba: E, + rgb: D, + opacity: i, + x: w, + y: s, + z: o, + r: y, + g: h, + b: k +}), qQ = (Q) => new zC({ gsplat: Q }), CB = (Q, { + scale: A, + rotate: I, + translate: g, + recolor: B +}) => new _C({ gsplat: Q, scale: A, rotate: I, translate: g, recolor: B }), EB = (Q) => new IE({ index: Q }), xQ = (Q) => new gE({ index: Q }), HA = oA(` + struct Gsplat { + vec3 center; + uint flags; + vec3 scales; + int index; + vec4 quaternion; + vec4 rgba; + }; + const uint GSPLAT_FLAG_ACTIVE = 1u << 0u; + + bool isGsplatActive(uint flags) { + return (flags & GSPLAT_FLAG_ACTIVE) != 0u; + } +`), LI = oA(` + struct CovSplat { + vec3 center; + uint flags; + vec4 rgba; + vec3 xxyyzz; + int index; + vec3 xyxzyz; + }; + + bool isCovSplatActive(uint flags) { + return (flags & GSPLAT_FLAG_ACTIVE) != 0u; + } +`), QQ = oA(` + struct PackedSplats { + usampler2DArray textureArray; + int numSplats; + vec4 rgbMinMaxLnScaleMinMax; + bool lodOpacity; + }; +`); +class bC extends e { + constructor({ + packedSplats: A + }) { + super({ a: A, outKey: "numSplats", outTypeFunc: () => "int" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.numSplats} = ${I.a}.numSplats;` + ]; + } +} +const PC = oA(` + bool readPackedArray(usampler2DArray texture, int numSplats, vec4 rgbMinMaxLnScaleMinMax, int index, out Gsplat gsplat) { + if ((index >= 0) && (index < numSplats)) { + uvec4 packed = texelFetch(texture, splatTexCoord(index), 0); + unpackSplatEncoding(packed, gsplat.center, gsplat.scales, gsplat.quaternion, gsplat.rgba, rgbMinMaxLnScaleMinMax); + return true; + } else { + return false; + } + } +`); +class uC extends d { + constructor({ + packedSplats: A, + index: I + }) { + super({ + inTypes: { packedSplats: tg, index: "int" }, + outTypes: { gsplat: Z }, + inputs: { packedSplats: A, index: I }, + globals: () => [HA, QQ, PC], + statements: ({ inputs: g, outputs: B }) => { + const { gsplat: C } = B; + if (!C) + return []; + const { packedSplats: E, index: D } = g; + let i; + return E && D ? i = z(` + ${C}.flags = 0u; + if (readPackedArray(${E}.textureArray, ${E}.numSplats, ${E}.rgbMinMaxLnScaleMinMax, ${D}, ${C})) { + if (${E}.lodOpacity) { + ${C}.rgba.a = 2.0 * ${C}.rgba.a; + } + bool zeroSize = all(equal(${C}.scales, vec3(0.0, 0.0, 0.0))); + ${C}.flags = zeroSize ? 0u : GSPLAT_FLAG_ACTIVE; + } + `) : i = [`${C}.flags = 0u;`], i.push(`${C}.index = ${D ?? "0"};`), i; + } + }); + } + dynoOut() { + return new V(this, "gsplat"); + } +} +class TC extends d { + constructor({ + packedSplats: A, + index: I, + base: g, + count: B + }) { + super({ + inTypes: { + packedSplats: tg, + index: "int", + base: "int", + count: "int" + }, + outTypes: { gsplat: Z }, + inputs: { packedSplats: A, index: I, base: g, count: B }, + globals: () => [HA, QQ, PC], + statements: ({ inputs: C, outputs: E }) => { + const { gsplat: D } = E; + if (!D) + return []; + const { packedSplats: i, index: w, base: s, count: o } = C; + let y; + return i && w && s && o ? y = z(` + ${D}.flags = 0u; + if (readPackedArray(${i}.textureArray, ${i}.numSplats, ${i}.rgbMinMaxLnScaleMinMax, ${w}, ${D})) { + if (${i}.lodOpacity) { + ${D}.rgba.a = 2.0 * ${D}.rgba.a; + } + bool zeroSize = all(equal(${D}.scales, vec3(0.0, 0.0, 0.0))); + ${D}.flags = zeroSize ? 0u : GSPLAT_FLAG_ACTIVE; + } + `) : y = [`${D}.flags = 0u;`], y.push(`${D}.index = ${w ?? "0"};`), y; + } + }); + } + dynoOut() { + return new V(this, "gsplat"); + } +} +const DB = oA(` + struct ExtSplats { + usampler2DArray textureArray1; + usampler2DArray textureArray2; + int numSplats; + }; +`); +class OC extends e { + constructor({ extSplats: A }) { + super({ a: A, outKey: "numSplats", outTypeFunc: () => "int" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.numSplats} = ${I.a}.numSplats;` + ]; + } +} +const us = oA(` + void readExtArrays(usampler2DArray texture1, usampler2DArray texture2, int numSplats, int index, out Gsplat gsplat) { + gsplat.flags = 0u; + if ((index >= 0) && (index < numSplats)) { + ivec3 coord = splatTexCoord(index); + uvec4 packed1 = texelFetch(texture1, coord, 0); + uvec4 packed2 = texelFetch(texture2, coord, 0); + unpackSplatExt(packed1, packed2, gsplat.center, gsplat.scales, gsplat.quaternion, gsplat.rgba); + gsplat.flags = all(equal(gsplat.scales, vec3(0.0, 0.0, 0.0))) ? 0u : GSPLAT_FLAG_ACTIVE; + gsplat.index = index; + } + } +`); +class mC extends d { + constructor({ + extSplats: A, + index: I + }) { + super({ + inTypes: { extSplats: BB, index: "int" }, + outTypes: { gsplat: Z }, + inputs: { extSplats: A, index: I }, + globals: () => [HA, DB, us], + statements: ({ inputs: g, outputs: B }) => { + const { gsplat: C } = B; + if (!C) + return [`${C}.flags = 0u;`]; + const { extSplats: E, index: D } = g; + return E && D ? z(` + readExtArrays(${E}.textureArray1, ${E}.textureArray2, ${E}.numSplats, ${D}, ${C}); + `) : [`${C}.flags = 0u;`]; + } + }); + } + dynoOut() { + return new V(this, "gsplat"); + } +} +class ZC extends e { + constructor({ covsplats: A }) { + super({ a: A, outKey: "numSplats", outTypeFunc: () => "int" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.numSplats} = ${I.a}.numSplats;` + ]; + } +} +const Ts = oA(` + void readCovArrays(usampler2DArray texture1, usampler2DArray texture2, int numSplats, int index, out CovSplat covsplat) { + covsplat.flags = 0u; + if ((index >= 0) && (index < numSplats)) { + ivec3 coord = splatTexCoord(index); + uvec4 packed1 = texelFetch(texture1, coord, 0); + uvec4 packed2 = texelFetch(texture2, coord, 0); + unpackSplatExtCov(packed1, packed2, covsplat.center, covsplat.rgba, covsplat.xxyyzz, covsplat.xyxzyz); + covsplat.flags = (all(equal(covsplat.xxyyzz, vec3(0.0))) && all(equal(covsplat.xyxzyz, vec3(0.0)))) ? 0u : GSPLAT_FLAG_ACTIVE; + gsplat.index = index; + } + } +`); +class VC extends d { + constructor({ + covSplats: A, + index: I + }) { + super({ + inTypes: { covSplats: lC, index: "int" }, + outTypes: { covsplat: eA }, + inputs: { covSplats: A, index: I }, + globals: () => [HA, LI, Ts], + statements: ({ inputs: g, outputs: B }) => { + const { covsplat: C } = B; + if (!C) + return [`${C}.flags = 0u;`]; + const { covSplats: E, index: D } = g; + return E && D ? z(` + readCovArrays(${E}.textureArray, ${E}.numSplats, ${D}, ${C}); + `) : [`${C}.flags = 0u;`]; + } + }); + } + dynoOut() { + return new V(this, "covsplat"); + } +} +class XC extends d { + constructor({ gsplat: A }) { + super({ + inTypes: { gsplat: Z }, + outTypes: { covsplat: eA }, + inputs: { gsplat: A }, + globals: () => [HA, LI], + statements: ({ inputs: I, outputs: g }) => { + const { gsplat: B } = I, { covsplat: C } = g; + return B ? z(` + ${C}.flags = 0u; + if (isGsplatActive(${B}.flags)) { + ${C}.flags = ${B}.flags; + ${C}.index = ${B}.index; + ${C}.rgba = ${B}.rgba; + ${C}.center = ${B}.center; + mat3 m = scaleQuaternionToMatrix(${B}.scales, ${B}.quaternion); + m = m * transpose(m); + ${C}.xxyyzz = vec3(m[0][0], m[1][1], m[2][2]); + ${C}.xyxzyz = vec3(m[0][1], m[0][2], m[1][2]); + } + `) : [`${C}.flags = 0u;`]; + } + }); + } + dynoOut() { + return new V(this, "covsplat"); + } +} +class WC extends d { + constructor({ gsplat: A }) { + super({ + inTypes: { gsplat: Z }, + outTypes: { + flags: "uint", + active: "bool", + index: "int", + center: "vec3", + scales: "vec3", + quaternion: "vec4", + rgba: "vec4", + rgb: "vec3", + opacity: "float", + x: "float", + y: "float", + z: "float", + r: "float", + g: "float", + b: "float" + }, + inputs: { gsplat: A }, + globals: () => [HA], + statements: ({ inputs: I, outputs: g }) => { + const { gsplat: B } = I, { + flags: C, + active: E, + index: D, + center: i, + scales: w, + quaternion: s, + rgba: o, + rgb: y, + opacity: h, + x: k, + y: R, + z: F, + r: S, + g: a, + b: M + } = g; + return [ + C ? `${C} = ${B ? `${B}.flags` : "0u"};` : null, + E ? `${E} = isGsplatActive(${B ? `${B}.flags` : "0u"});` : null, + D ? `${D} = ${B ? `${B}.index` : "0"};` : null, + i ? `${i} = ${B ? `${B}.center` : "vec3(0.0, 0.0, 0.0)"};` : null, + w ? `${w} = ${B ? `${B}.scales` : "vec3(0.0, 0.0, 0.0)"};` : null, + s ? `${s} = ${B ? `${B}.quaternion` : "vec4(0.0, 0.0, 0.0, 1.0)"};` : null, + o ? `${o} = ${B ? `${B}.rgba` : "vec4(0.0, 0.0, 0.0, 0.0)"};` : null, + y ? `${y} = ${B ? `${B}.rgba.rgb` : "vec3(0.0, 0.0, 0.0)"};` : null, + h ? `${h} = ${B ? `${B}.rgba.a` : "0.0"};` : null, + k ? `${k} = ${B ? `${B}.center.x` : "0.0"};` : null, + R ? `${R} = ${B ? `${B}.center.y` : "0.0"};` : null, + F ? `${F} = ${B ? `${B}.center.z` : "0.0"};` : null, + S ? `${S} = ${B ? `${B}.rgba.r` : "0.0"};` : null, + a ? `${a} = ${B ? `${B}.rgba.g` : "0.0"};` : null, + M ? `${M} = ${B ? `${B}.rgba.b` : "0.0"};` : null + ].filter(Boolean); + } + }); + } +} +class jC extends d { + constructor({ + gsplat: A, + flags: I, + index: g, + center: B, + scales: C, + quaternion: E, + rgba: D, + rgb: i, + opacity: w, + x: s, + y: o, + z: y, + r: h, + g: k, + b: R + }) { + super({ + inTypes: { + gsplat: Z, + flags: "uint", + index: "int", + center: "vec3", + scales: "vec3", + quaternion: "vec4", + rgba: "vec4", + rgb: "vec3", + opacity: "float", + x: "float", + y: "float", + z: "float", + r: "float", + g: "float", + b: "float" + }, + outTypes: { gsplat: Z }, + inputs: { + gsplat: A, + flags: I, + index: g, + center: B, + scales: C, + quaternion: E, + rgba: D, + rgb: i, + opacity: w, + x: s, + y: o, + z: y, + r: h, + g: k, + b: R + }, + globals: () => [HA], + statements: ({ inputs: F, outputs: S }) => { + const { gsplat: a } = S; + if (!a) + return []; + const { + gsplat: M, + flags: c, + index: N, + center: U, + scales: J, + quaternion: t, + rgba: H, + rgb: K, + opacity: Y, + x: L, + y: q, + z: n, + r, + g: p, + b: m + } = F; + return [ + `${a}.flags = ${c ?? (M ? `${M}.flags` : "0u")};`, + `${a}.index = ${N ?? (M ? `${M}.index` : "0")};`, + `${a}.center = ${U ?? (M ? `${M}.center` : "vec3(0.0, 0.0, 0.0)")};`, + `${a}.scales = ${J ?? (M ? `${M}.scales` : "vec3(0.0, 0.0, 0.0)")};`, + `${a}.quaternion = ${t ?? (M ? `${M}.quaternion` : "vec4(0.0, 0.0, 0.0, 1.0)")};`, + `${a}.rgba = ${H ?? (M ? `${M}.rgba` : "vec4(0.0, 0.0, 0.0, 0.0)")};`, + K ? `${a}.rgba.rgb = ${K};` : null, + Y ? `${a}.rgba.a = ${Y};` : null, + L ? `${a}.center.x = ${L};` : null, + q ? `${a}.center.y = ${q};` : null, + n ? `${a}.center.z = ${n};` : null, + r ? `${a}.rgba.r = ${r};` : null, + p ? `${a}.rgba.g = ${p};` : null, + m ? `${a}.rgba.b = ${m};` : null + ].filter(Boolean); + } + }); + } + dynoOut() { + return new V(this, "gsplat"); + } +} +const vC = oA(` + vec3 gsplatNormal(vec3 scales, vec4 quaternion) { + float minScale = min(scales.x, min(scales.y, scales.z)); + vec3 normal; + if (scales.z == minScale) { + normal = vec3(0.0, 0.0, 1.0); + } else if (scales.y == minScale) { + normal = vec3(0.0, 1.0, 0.0); + } else { + normal = vec3(1.0, 0.0, 0.0); + } + return quatVec(quaternion, normal); + } +`); +class zC extends e { + constructor({ gsplat: A }) { + super({ a: A, outKey: "normal", outTypeFunc: () => "vec3" }), this.globals = () => [HA, vC], this.statements = ({ inputs: I, outputs: g }) => [ + `${g.normal} = gsplatNormal(${I.a}.scales, ${I.a}.quaternion);` + ]; + } +} +class _C extends d { + constructor({ + gsplat: A, + scale: I, + rotate: g, + translate: B, + recolor: C + }) { + super({ + inTypes: { + gsplat: Z, + scale: "float", + rotate: "vec4", + translate: "vec3", + recolor: "vec4" + }, + outTypes: { gsplat: Z }, + inputs: { gsplat: A, scale: I, rotate: g, translate: B, recolor: C }, + globals: () => [HA], + statements: ({ inputs: E, outputs: D, compile: i }) => { + const { gsplat: w } = D; + if (!w || !E.gsplat) + return []; + const { scale: s, rotate: o, translate: y, recolor: h } = E, k = i.indent; + return [ + `${w} = ${E.gsplat};`, + `if (isGsplatActive(${w}.flags)) {`, + s ? `${k}${w}.center *= ${s};` : null, + o ? `${k}${w}.center = quatVec(${o}, ${w}.center);` : null, + y ? `${k}${w}.center += ${y};` : null, + s ? `${k}${w}.scales *= ${s};` : null, + o ? `${k}${w}.quaternion = quatQuat(${o}, ${w}.quaternion);` : null, + h ? `${k}${w}.rgba *= ${h};` : null, + "}" + ].filter(Boolean); + } + }); + } + dynoOut() { + return new V(this, "gsplat"); + } +} +const Vg = (Q) => new $C({ covsplat: Q }), iB = ({ + covsplat: Q, + flags: A, + index: I, + center: g, + rgba: B, + rgb: C, + opacity: E, + x: D, + y: i, + z: w, + r: s, + g: o, + b: y +}) => new AE({ + covsplat: Q, + flags: A, + index: I, + center: g, + rgba: B, + rgb: C, + opacity: E, + x: D, + y: i, + z: w, + r: s, + g: o, + b: y +}); +class $C extends d { + constructor({ covsplat: A }) { + super({ + inTypes: { covsplat: eA }, + outTypes: { + flags: "uint", + active: "bool", + index: "int", + center: "vec3", + rgba: "vec4", + rgb: "vec3", + opacity: "float", + x: "float", + y: "float", + z: "float", + r: "float", + g: "float", + b: "float" + }, + inputs: { covsplat: A }, + globals: () => [LI], + statements: ({ inputs: I, outputs: g }) => { + const { covsplat: B } = I, { + flags: C, + active: E, + index: D, + center: i, + rgba: w, + rgb: s, + opacity: o, + x: y, + y: h, + z: k, + r: R, + g: F, + b: S + } = g; + return [ + C ? `${C} = ${B ? `${B}.flags` : "0u"};` : null, + E ? `${E} = isCovSplatActive(${B ? `${B}.flags` : "0u"});` : null, + D ? `${D} = ${B ? `${B}.index` : "0"};` : null, + i ? `${i} = ${B ? `${B}.center` : "vec3(0.0, 0.0, 0.0)"};` : null, + w ? `${w} = ${B ? `${B}.rgba` : "vec4(0.0, 0.0, 0.0, 0.0)"};` : null, + s ? `${s} = ${B ? `${B}.rgba.rgb` : "vec3(0.0, 0.0, 0.0)"};` : null, + o ? `${o} = ${B ? `${B}.rgba.a` : "0.0"};` : null, + y ? `${y} = ${B ? `${B}.center.x` : "0.0"};` : null, + h ? `${h} = ${B ? `${B}.center.y` : "0.0"};` : null, + k ? `${k} = ${B ? `${B}.center.z` : "0.0"};` : null, + R ? `${R} = ${B ? `${B}.rgba.r` : "0.0"};` : null, + F ? `${F} = ${B ? `${B}.rgba.g` : "0.0"};` : null, + S ? `${S} = ${B ? `${B}.rgba.b` : "0.0"};` : null + ].filter(Boolean); + } + }); + } +} +class AE extends d { + constructor({ + covsplat: A, + flags: I, + index: g, + center: B, + rgba: C, + rgb: E, + opacity: D, + x: i, + y: w, + z: s, + r: o, + g: y, + b: h + }) { + super({ + inTypes: { + covsplat: eA, + flags: "uint", + index: "int", + center: "vec3", + rgba: "vec4", + rgb: "vec3", + opacity: "float", + x: "float", + y: "float", + z: "float", + r: "float", + g: "float", + b: "float" + }, + outTypes: { covsplat: eA }, + inputs: { + covsplat: A, + flags: I, + index: g, + center: B, + rgba: C, + rgb: E, + opacity: D, + x: i, + y: w, + z: s, + r: o, + g: y, + b: h + }, + globals: () => [LI], + statements: ({ inputs: k, outputs: R }) => { + const { covsplat: F } = R; + if (!F) + return []; + const { + covsplat: S, + flags: a, + index: M, + center: c, + rgba: N, + rgb: U, + opacity: J, + x: t, + y: H, + z: K, + r: Y, + g: L, + b: q + } = k; + return [ + `${F}.flags = ${a ?? (S ? `${S}.flags` : "0u")};`, + `${F}.index = ${M ?? (S ? `${S}.index` : "0")};`, + `${F}.center = ${c ?? (S ? `${S}.center` : "vec3(0.0, 0.0, 0.0)")};`, + `${F}.rgba = ${N ?? (S ? `${S}.rgba` : "vec4(0.0, 0.0, 0.0, 0.0)")};`, + U ? `${F}.rgba.rgb = ${U};` : null, + J ? `${F}.rgba.a = ${J};` : null, + t ? `${F}.center.x = ${t};` : null, + H ? `${F}.center.y = ${H};` : null, + K ? `${F}.center.z = ${K};` : null, + Y ? `${F}.rgba.r = ${Y};` : null, + L ? `${F}.rgba.g = ${L};` : null, + q ? `${F}.rgba.b = ${q};` : null, + `${F}.xxyyzz = ${S ? `${S}.xxyyzz` : "vec3(0.0, 0.0, 0.0)"};`, + `${F}.xyxzyz = ${S ? `${S}.xyxzyz` : "vec3(0.0, 0.0, 0.0)"};` + ].filter(Boolean); + } + }); + } + dynoOut() { + return new V(this, "covsplat"); + } +} +class IE extends d { + constructor({ index: A }) { + super({ + inTypes: { index: "int" }, + outTypes: { coord: "ivec3" }, + inputs: { index: A }, + statements: ({ inputs: I, outputs: g }) => { + const { index: B } = I, { coord: C } = g; + return !B || !C ? [] : [`${C} = splatTexCoord(${B});`]; + } + }); + } + dynoOut() { + return new V(this, "coord"); + } +} +class gE extends d { + constructor({ index: A }) { + super({ + inTypes: { index: "int" }, + outTypes: { coord: "ivec3" }, + inputs: { index: A }, + statements: ({ inputs: I, outputs: g }) => { + const { index: B } = I, { coord: C } = g; + return !B || !C ? [] : [`${C} = pagedSplatTexCoord(${B});`]; + } + }); + } + dynoOut() { + return new V(this, "coord"); + } +} +const wB = (Q, A) => new DE({ gsplat: Q, rgbMinMaxLnScaleMinMax: A }), QE = (Q, A) => new iE({ covsplat: Q, rgbMinMaxLnScaleMinMax: A }), BE = (Q) => new wE({ gsplat: Q }), lQ = (Q) => new oE({ covsplat: Q }), CE = (Q, A, I, g) => new ms({ gsplat: Q, viewCenter: A, viewDir: I, sortRadial: g }), EE = (Q, A, I, g) => new Zs({ covsplat: Q, viewCenter: A, viewDir: I, sortRadial: g }), Os = (Q) => new oB({ rgba8: Q }); +class DE extends d { + constructor({ + gsplat: A, + rgbMinMaxLnScaleMinMax: I + }) { + super({ + inTypes: { gsplat: Z, rgbMinMaxLnScaleMinMax: "vec4" }, + inputs: { gsplat: A, rgbMinMaxLnScaleMinMax: I }, + globals: () => [HA], + statements: ({ inputs: g, outputs: B }) => { + const { gsplat: C, rgbMinMaxLnScaleMinMax: E } = g; + return C && E ? z(` + if (isGsplatActive(${C}.flags)) { + target = packSplatEncoding(${C}.center, ${C}.scales, ${C}.quaternion, ${C}.rgba, ${E}); + } else { + target = uvec4(0u, 0u, 0u, 0u); + } + `) : ["target = uvec4(0u, 0u, 0u, 0u);"]; + } + }); + } +} +class iE extends d { + constructor({ + covsplat: A, + rgbMinMaxLnScaleMinMax: I + }) { + super({ + inTypes: { covsplat: eA, rgbMinMaxLnScaleMinMax: "vec4" }, + inputs: { covsplat: A, rgbMinMaxLnScaleMinMax: I }, + globals: () => [LI], + statements: ({ inputs: g }) => { + const { covsplat: B, rgbMinMaxLnScaleMinMax: C } = g; + return B && C ? z(` + if (isCovSplatActive(${B}.flags)) { + target = packSplatCovEncoding(${B}.center, ${B}.rgba, ${B}.xxyyzz, ${B}.xyxzyz, ${C}); + } else { + target = uvec4(0u); + } + `) : ["target = uvec4(0u);"]; + } + }); + } +} +class wE extends d { + constructor({ + gsplat: A + }) { + super({ + inTypes: { gsplat: Z }, + inputs: { gsplat: A }, + globals: () => [HA], + statements: ({ inputs: I }) => { + const { gsplat: g } = I; + return g ? z(` + if (isGsplatActive(${g}.flags)) { + packSplatExt(target, target2, ${g}.center, ${g}.scales, ${g}.quaternion, ${g}.rgba); + } else { + target = uvec4(0u); + target2 = uvec4(0u); + } + `) : ["target = uvec4(0u);", "target2 = uvec4(0u);"]; + } + }); + } +} +class oE extends d { + constructor({ + covsplat: A + }) { + super({ + inTypes: { covsplat: eA }, + inputs: { covsplat: A }, + globals: () => [LI], + statements: ({ inputs: I }) => { + const { covsplat: g } = I; + return g ? z(` + if (isCovSplatActive(${g}.flags)) { + packSplatExtCov(target, target2, ${g}.center, ${g}.rgba, ${g}.xxyyzz, ${g}.xyxzyz); + } else { + target = uvec4(0u); + target2 = uvec4(0u); + } + `) : ["target = uvec4(0u);", "target2 = uvec4(0u);"]; + } + }); + } +} +class ms extends d { + constructor({ + gsplat: A, + viewCenter: I, + viewDir: g, + sortRadial: B + }) { + super({ + inTypes: { + gsplat: Z, + viewCenter: "vec3", + viewDir: "vec3", + sortRadial: "bool" + }, + inputs: { gsplat: A, viewCenter: I, viewDir: g, sortRadial: B }, + globals: () => [HA], + statements: ({ inputs: C }) => { + const { gsplat: E, viewCenter: D, viewDir: i, sortRadial: w } = C; + return E && D && i && w ? z(` + float metric = 1.0 / 0.0; + if (isGsplatActive(${E}.flags)) { + vec3 center = ${E}.center - ${D}; + if (${w}) { + metric = length(center); + } else { + float bias = 100.0; // reduce popping + metric = dot(center, ${i}) + bias; + } + } + target3 = floatToVec4(metric); + `) : []; + } + }); + } +} +class Zs extends d { + constructor({ + covsplat: A, + viewCenter: I, + viewDir: g, + sortRadial: B + }) { + super({ + inTypes: { + covsplat: eA, + viewCenter: "vec3", + viewDir: "vec3", + sortRadial: "bool" + }, + inputs: { covsplat: A, viewCenter: I, viewDir: g, sortRadial: B }, + globals: () => [LI], + statements: ({ inputs: C }) => { + const { covsplat: E, viewCenter: D, viewDir: i, sortRadial: w } = C; + return E && D && i && w ? z(` + float metric = 1.0 / 0.0; + if (isCovSplatActive(${E}.flags)) { + vec3 center = ${E}.center - ${D}; + if (${w}) { + metric = length(center); + } else { + float bias = 100.0; // reduce popping + metric = dot(center, ${i}) + bias; + } + } + target3 = floatToVec4(metric); + `) : []; + } + }); + } +} +class oB extends d { + constructor({ rgba8: A }) { + super({ + inTypes: { rgba8: "vec4" }, + inputs: { rgba8: A }, + statements: ({ inputs: I, outputs: g }) => [ + `target = ${I.rgba8 ?? "vec4(0.0, 0.0, 0.0, 0.0)"};` + ] + }); + } + dynoOut() { + return new V(this, "rgba8"); + } +} +const Vs = (Q, A, I) => new x({ key: Q, type: A, value: I }), Xs = (Q = !1, A) => new bI({ key: A, value: Q }), Ws = (Q = 0, A) => new sE({ key: A, value: Q }), js = (Q = 0, A) => new EI({ key: A, value: Q }), wI = (Q = 0, A) => new pI({ key: A, value: Q }), vs = (Q, A) => new GE({ key: A, value: Q }), zs = (Q, A) => new yE({ key: A, value: Q }), _s = (Q, A) => new hE({ key: A, value: Q }), $s = (Q, A) => new RE({ key: A, value: Q }), AG = (Q, A) => new kE({ key: A, value: Q }), IG = (Q, A) => new FE({ key: A, value: Q }), gG = (Q, A) => new SE({ key: A, value: Q }), cI = (Q, A) => new DI({ key: A, value: Q }), QG = (Q, A) => new aE({ key: A, value: Q }), BG = (Q, A) => new NE({ key: A, value: Q }), CG = (Q, A) => new cE({ key: A, value: Q }), EG = (Q, A) => new mI({ key: A, value: Q }), DG = (Q, A) => new ME({ key: A, value: Q }), iG = (Q, A) => new JE({ key: A, value: Q }), wG = (Q, A) => new UE({ key: A, value: Q }), oG = (Q, A) => new tE({ key: A, value: Q }), sG = (Q, A) => new sB({ key: A, value: Q }), GG = (Q, A) => new HE({ key: A, value: Q }), yG = (Q, A) => new LE({ key: A, value: Q }), hG = (Q, A) => new YE({ key: A, value: Q }), RG = (Q, A) => new KE({ key: A, value: Q }), kG = (Q, A) => new eE({ key: A, value: Q }), FG = (Q, A) => new rE({ key: A, value: Q }), SG = (Q, A) => new nE({ key: A, value: Q }), aG = (Q, A) => new BQ({ key: A, value: Q }), NG = (Q, A) => new dE({ key: A, value: Q }), cG = (Q, A) => new qE({ key: A, value: Q }), MG = (Q, A) => new dA({ key: A, value: Q }), JG = (Q, A) => new xE({ key: Q, value: A }), UG = (Q, A) => new lE({ key: A, value: Q }), tG = (Q, A) => new pE({ key: A, value: Q }), HG = (Q, A) => new fE({ key: A, value: Q }), LG = (Q, A) => new bE({ key: A, value: Q }), YG = (Q, A) => new PE({ key: A, value: Q }), KG = (Q, A) => new uE({ key: A, value: Q }), eG = (Q, A) => new TE({ key: A, value: Q }), rG = (Q, A) => new OE({ key: A, value: Q }), nG = (Q, A) => new mE({ key: A, value: Q }), dG = (Q, A) => new ZE({ key: A, value: Q }); +class x extends d { + constructor({ + key: A, + type: I, + count: g, + value: B, + update: C, + globals: E + }) { + A = A ?? "value", super({ + outTypes: { [A]: I }, + update: () => { + if (C) { + const D = C(this.value); + D !== void 0 && (this.value = D); + } + this.uniform.value = this.value; + }, + generate: ({ inputs: D, outputs: i }) => { + const w = (E == null ? void 0 : E({ inputs: D, outputs: i })) ?? [], s = {}, o = i[A]; + return o && (w.push(`uniform ${jQ(o, I, g)};`), s[o] = this.uniform), { globals: w, uniforms: s }; + } + }), this.type = I, this.count = g, this.value = B, this.uniform = { value: B }, this.outKey = A; + } + dynoOut() { + return new V(this, this.outKey); + } +} +class bI extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "bool", value: I, update: g }); + } +} +class sE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "uint", value: I, update: g }); + } +} +class EI extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "int", value: I, update: g }); + } +} +class pI extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "float", value: I, update: g }); + } +} +class GE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "bvec2", value: I, update: g }); + } +} +class yE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "uvec2", value: I, update: g }); + } +} +class hE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "ivec2", value: I, update: g }); + } +} +class RE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "vec2", value: I, update: g }); + } +} +class kE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "bvec3", value: I, update: g }); + } +} +class FE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "uvec3", value: I, update: g }); + } +} +class SE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "ivec3", value: I, update: g }); + } +} +class DI extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "vec3", value: I, update: g }); + } +} +class aE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "bvec4", value: I, update: g }); + } +} +class NE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "uvec4", value: I, update: g }); + } +} +class cE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "ivec4", value: I, update: g }); + } +} +class mI extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "vec4", value: I, update: g }); + } +} +class ME extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat2", value: I, update: g }); + } +} +class JE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat2x2", value: I, update: g }); + } +} +class UE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat2x3", value: I, update: g }); + } +} +class tE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat2x4", value: I, update: g }); + } +} +class sB extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat3", value: I, update: g }); + } +} +class HE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat3x2", value: I, update: g }); + } +} +class LE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat3x3", value: I, update: g }); + } +} +class YE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat3x4", value: I, update: g }); + } +} +class KE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat4", value: I, update: g }); + } +} +class eE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat4x2", value: I, update: g }); + } +} +class rE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat4x3", value: I, update: g }); + } +} +class nE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "mat4x4", value: I, update: g }); + } +} +class BQ extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "usampler2D", value: I, update: g }); + } +} +class dE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "isampler2D", value: I, update: g }); + } +} +class qE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "sampler2D", value: I, update: g }); + } +} +class dA extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "usampler2DArray", value: I, update: g }); + } +} +class xE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "isampler2DArray", value: I, update: g }); + } +} +class lE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "sampler2DArray", value: I, update: g }); + } +} +class pE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "usampler3D", value: I, update: g }); + } +} +class fE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "isampler3D", value: I, update: g }); + } +} +class bE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "sampler3D", value: I, update: g }); + } +} +class PE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "usamplerCube", value: I, update: g }); + } +} +class uE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "isamplerCube", value: I, update: g }); + } +} +class TE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "samplerCube", value: I, update: g }); + } +} +class OE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "sampler2DShadow", value: I, update: g }); + } +} +class mE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "sampler2DArrayShadow", value: I, update: g }); + } +} +class ZE extends x { + constructor({ + key: A, + value: I, + update: g + }) { + super({ key: A, type: "samplerCubeShadow", value: I, update: g }); + } +} +class CQ { + constructor({ + graph: A, + inputs: I, + outputs: g, + template: B, + consoleLog: C + }) { + this.graph = A, this.template = B, this.inputs = I ?? {}, this.outputs = g ?? {}; + const E = new hC({ indent: this.template.indent }); + for (const i in this.outputs) + this.outputs[i] && E.declares.add(this.outputs[i]); + const D = A.compile({ + inputs: this.inputs, + outputs: this.outputs, + compile: E + }); + this.shader = B.generate({ globals: E.globals, statements: D }), this.uniforms = E.uniforms, this.updaters = E.updaters, C && (console.log("*** COMPILED SHADER", this.shader), console.log("*** UNIFORMS", this.uniforms)); + } + prepareMaterial() { + return qG(this); + } + update() { + for (const A of this.updaters) + A(); + } +} +class Fg { + constructor(A) { + const I = A.match(/^([ \t]*)\{\{\s*GLOBALS\s*\}\}/m), g = A.match(/^([ \t]*)\{\{\s*STATEMENTS\s*\}\}/m); + if (!I || !g) + throw new Error( + "Template must contain {{ GLOBALS }} and {{ STATEMENTS }}" + ); + this.before = A.substring(0, I.index), this.between = A.substring( + I.index + I[0].length, + g.index + ), this.after = A.substring( + g.index + g[0].length + ), this.indent = g[1]; + } + generate({ + globals: A, + statements: I + }) { + return this.before + Array.from(A).join(` + +`) + this.between + I.map((g) => this.indent + g).join(` +`) + this.after; + } +} +const rB = /* @__PURE__ */ new WeakMap(); +function qG(Q) { + let A = rB.get(Q); + return A || (A = new G.RawShaderMaterial({ + glslVersion: G.GLSL3, + vertexShader: MC, + fragmentShader: Q.shader, + uniforms: Q.uniforms + }), rB.set(Q, A), A); +} +function GB(Q, A, I = "add") { + const g = () => { + throw new Error(`Invalid ${I} types: ${Q}, ${A}`); + }; + if (Q === A) return Q; + if (Q === "int") { + if (xA(A)) return A; + g(); + } + if (A === "int") { + if (xA(Q)) return Q; + g(); + } + if (Q === "uint") { + if (lA(A)) return A; + g(); + } + if (A === "uint") { + if (lA(Q)) return Q; + g(); + } + if (Q === "float") { + if (HI(A)) return A; + g(); + } + if (A === "float") { + if (HI(Q)) return Q; + g(); + } + throw new Error(`Invalid ${I} types: ${Q}, ${A}`); +} +function xG(Q, A) { + return GB(Q, A, "sub"); +} +function lG(Q, A) { + const I = () => { + throw new Error(`Invalid mul types: ${Q}, ${A}`); + }, g = (B) => B; + if (Q === "int") { + if (xA(A)) return g(A); + I(); + } + if (A === "int") { + if (xA(Q)) return g(Q); + I(); + } + if (Q === "uint") { + if (lA(A)) return g(A); + I(); + } + if (A === "uint") { + if (lA(Q)) return g(Q); + I(); + } + if (Q === "float") { + if (HI(A)) return g(A); + I(); + } + if (A === "float") { + if (HI(Q)) return g(Q); + I(); + } + if (xA(Q) || lA(Q) || xA(A) || lA(A)) { + if (Q === A) return g(Q); + I(); + } + if (Q === "vec2") { + if (A === "vec2" || KI(A)) return g("vec2"); + if (A === "mat3x2") return g("vec3"); + if (A === "mat4x2") return g("vec4"); + I(); + } + if (Q === "vec3") { + if (A === "mat2x3") return g("vec2"); + if (A === "vec3" || eI(A)) return g("vec3"); + if (A === "mat4x3") return g("vec4"); + I(); + } + if (Q === "vec4") { + if (A === "mat2x4") return g("vec2"); + if (A === "mat3x4") return g("vec3"); + if (A === "vec4" || rI(A)) return g("vec4"); + I(); + } + if (A === "vec2") { + if (KI(Q)) return g("vec2"); + if (Q === "mat2x3") return g("vec3"); + if (Q === "mat2x4") return g("vec4"); + I(); + } + if (A === "vec3") { + if (Q === "mat3x2") return g("vec2"); + if (eI(Q)) return g("vec3"); + if (Q === "mat3x4") return g("vec4"); + I(); + } + if (A === "vec4") { + if (Q === "mat4x2") return g("vec2"); + if (Q === "mat4x3") return g("vec3"); + if (rI(Q)) return g("vec4"); + I(); + } + if (KI(Q)) { + if (KI(A)) return g("mat2"); + if (A === "mat3x2") return g("mat3x2"); + if (A === "mat4x2") return g("mat4x2"); + I(); + } + if (Q === "mat2x3") { + if (KI(A)) return g("mat2x3"); + if (A === "mat3x2") return g("mat3"); + if (A === "mat4x2") return g("mat4x3"); + I(); + } + if (Q === "mat2x4") { + if (KI(A)) return g("mat2x4"); + if (A === "mat3x2") return g("mat3x4"); + if (A === "mat4x2") return g("mat4"); + I(); + } + if (Q === "mat3x2") { + if (A === "mat2x3") return g("mat2"); + if (eI(A)) return g("mat3x2"); + if (A === "mat4x3") return g("mat4x2"); + I(); + } + if (eI(Q)) { + if (A === "mat2x3") return g("mat2x3"); + if (eI(A)) return g("mat3"); + if (A === "mat4x3") return g("mat4x3"); + I(); + } + if (Q === "mat3x4") { + if (A === "mat2x3") return g("mat2x4"); + if (eI(A)) return g("mat3x4"); + if (A === "mat4x3") return g("mat4"); + I(); + } + if (Q === "mat4x2") { + if (A === "mat2x4") return g("mat2"); + if (A === "mat3x4") return g("mat3x2"); + if (rI(A)) return g("mat4x2"); + I(); + } + if (Q === "mat4x3") { + if (A === "mat2x4") return g("mat2x3"); + if (A === "mat3x4") return g("mat3"); + if (rI(A)) return g("mat4x3"); + I(); + } + if (rI(Q)) { + if (A === "mat2x4") return g("mat2x4"); + if (A === "mat3x4") return g("mat3x4"); + if (rI(A)) return g("mat4"); + I(); + } + throw new Error(`Invalid mul types: ${Q}, ${A}`); +} +function pG(Q, A) { + return GB(Q, A, "div"); +} +function fG(Q, A) { + if (Q === A) return Q; + if (Q === "int") { + if (xA(A)) return A; + } else if (A === "int") { + if (xA(Q)) return Q; + } else if (Q === "uint") { + if (lA(A)) return A; + } else if (A === "uint" && lA(Q)) + return Q; + throw new Error(`Invalid imod types: ${Q}, ${A}`); +} +function bG(Q, A) { + if (Q === A || A === "float") return Q; + throw new Error(`Invalid mod types: ${Q}, ${A}`); +} +function PG(Q) { + return Q; +} +function uG(Q) { + return Q; +} +function TG(Q) { + return Q; +} +function OG(Q) { + return Q; +} +function mG(Q) { + return Q; +} +function ZG(Q) { + return Q; +} +function VG(Q) { + return Q; +} +function XG(Q) { + return Q; +} +function WG(Q) { + return Q; +} +function jG(Q) { + return Q; +} +function vG(Q) { + return Q; +} +function zG(Q) { + return Q; +} +function _G(Q) { + return Q; +} +function $G(Q) { + return Q; +} +function A0(Q) { + return Q; +} +function I0(Q) { + return Q; +} +function VE(Q, A, I = "min") { + if (Q === A) return Q; + if (A === "float") { + if (Mg(Q)) return Q; + } else if (A === "int") { + if (xA(Q)) return Q; + } else if (A === "uint" && lA(Q)) + return Q; + throw new Error(`Invalid ${I} types: ${Q}, ${A}`); +} +function g0(Q, A) { + return VE(Q, A, "max"); +} +function Q0(Q, A, I) { + if (A === "float") { + if (Mg(Q)) return Q; + } else if (A === "int") { + if (xA(Q)) return Q; + } else if (A === "uint" && lA(Q)) + return Q; + throw new Error(`Invalid clamp types: ${Q}, ${A}`); +} +function B0(Q, A, I) { + if (I === Q || I === "float" || I === "bool" && Q === "float" || I === "bvec2" && Q === "vec2" || I === "bvec3" && Q === "vec3" || I === "bvec4" && Q === "vec4") return Q; + throw new Error(`Invalid mix types: ${Q}, ${A}, ${I}`); +} +function C0(Q, A) { + if (Q === A || A === "float") return A; + throw new Error(`Invalid step types: ${Q}, ${A}`); +} +function E0(Q, A, I) { + if (Q === A && (Q === I || Q === "float")) + return I; + throw new Error(`Invalid smoothstep types: ${Q}, ${A}, ${I}`); +} +function XE(Q, A = "isNan") { + if (Q === "float") return "bool"; + if (Q === "vec2") return "bvec2"; + if (Q === "vec3") return "bvec3"; + if (Q === "vec4") return "bvec4"; + throw new Error(`Invalid ${A} types: ${Q}`); +} +function D0(Q) { + return XE(Q, "isInf"); +} +const qA = (Q, A) => new zE({ a: Q, b: A }), iI = (Q, A) => new _E({ a: Q, b: A }), kA = (Q, A) => new $E({ a: Q, b: A }), pg = (Q, A) => new AD({ a: Q, b: A }), pQ = (Q, A) => new ID({ a: Q, b: A }), WE = (Q, A) => new gD({ a: Q, b: A }), i0 = (Q) => new QD({ a: Q }).outputs, yB = (Q) => new BD({ a: Q }), w0 = (Q) => new CD({ a: Q }), o0 = (Q) => new ED({ a: Q }), s0 = (Q) => new DD({ a: Q }), G0 = (Q) => new iD({ a: Q }), y0 = (Q) => new wD({ a: Q }), h0 = (Q) => new oD({ a: Q }), fg = (Q) => new sD({ a: Q }), R0 = (Q, A) => new GD({ a: Q, b: A }), k0 = (Q) => new yD({ a: Q }), F0 = (Q) => new hD({ a: Q }), S0 = (Q) => new RD({ a: Q }), a0 = (Q) => new kD({ a: Q }), N0 = (Q) => new FD({ a: Q }), c0 = (Q) => new SD({ a: Q }), M0 = (Q) => new aD({ a: Q }), J0 = (Q, A) => new ND({ a: Q, b: A }), jE = (Q, A) => new cD({ a: Q, b: A }), U0 = (Q, A, I) => new MD({ a: Q, min: A, max: I }), vE = (Q, A, I) => new JD({ a: Q, b: A, t: I }), t0 = (Q, A) => new UD({ edge: Q, x: A }), H0 = (Q, A, I) => new tD({ edge0: Q, edge1: A, x: I }), L0 = (Q) => new HD({ a: Q }), Y0 = (Q) => new LD({ a: Q }); +class zE extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "sum", outTypeFunc: GB }), this.statements = ({ inputs: g, outputs: B }) => [`${B.sum} = ${g.a} + ${g.b};`]; + } +} +class _E extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "difference", outTypeFunc: xG }), this.statements = ({ inputs: g, outputs: B }) => [`${B.difference} = ${g.a} - ${g.b};`]; + } +} +class $E extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "product", outTypeFunc: lG }), this.statements = ({ inputs: g, outputs: B }) => [`${B.product} = ${g.a} * ${g.b};`]; + } +} +class AD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "quotient", outTypeFunc: pG }), this.statements = ({ inputs: g, outputs: B }) => [`${B.quotient} = ${g.a} / ${g.b};`]; + } +} +class ID extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "remainder", outTypeFunc: fG }), this.statements = ({ inputs: g, outputs: B }) => [`${B.remainder} = ${g.a} % ${g.b};`]; + } +} +class gD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "remainder", outTypeFunc: bG }), this.statements = ({ inputs: g, outputs: B }) => [`${B.remainder} = mod(${g.a}, ${g.b});`]; + } +} +class QD extends d { + constructor({ a: A }) { + const I = { a: CA(A) }, g = I.a, B = { + fract: g, + integer: g + }; + super({ inTypes: I, outTypes: B, inputs: { a: A } }), this.statements = ({ inputs: C, outputs: E }) => [`${E.fract} = modf(${C.a}, ${E.integer});`]; + } +} +class BD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "neg", outTypeFunc: PG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.neg} = -${I.a};`]; + } +} +class CD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "abs", outTypeFunc: uG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.abs} = abs(${I.a});`]; + } +} +class ED extends e { + constructor({ a: A }) { + super({ a: A, outKey: "sign", outTypeFunc: TG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.sign} = sign(${I.a});`]; + } +} +class DD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "floor", outTypeFunc: OG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.floor} = floor(${I.a});`]; + } +} +class iD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "ceil", outTypeFunc: mG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.ceil} = ceil(${I.a});`]; + } +} +class wD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "trunc", outTypeFunc: ZG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.trunc} = trunc(${I.a});`]; + } +} +class oD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "round", outTypeFunc: VG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.round} = round(${I.a});`]; + } +} +class sD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "fract", outTypeFunc: XG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.fract} = fract(${I.a});`]; + } +} +class GD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "power", outTypeFunc: WG }), this.statements = ({ inputs: g, outputs: B }) => [`${B.power} = pow(${g.a}, ${g.b});`]; + } +} +class yD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "exp", outTypeFunc: jG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.exp} = exp(${I.a});`]; + } +} +class hD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "exp2", outTypeFunc: vG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.exp2} = exp2(${I.a});`]; + } +} +class RD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "log", outTypeFunc: zG }), this.statements = ({ inputs: I, outputs: g }) => [`${g.log} = log(${I.a});`]; + } +} +class kD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "log2", outTypeFunc: _G }), this.statements = ({ inputs: I, outputs: g }) => [`${g.log2} = log2(${I.a});`]; + } +} +class FD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "sqr", outTypeFunc: $G }), this.statements = ({ inputs: I, outputs: g }) => [`${g.sqr} = ${I.a} * ${I.a};`]; + } +} +class SD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "sqrt", outTypeFunc: A0 }), this.statements = ({ inputs: I, outputs: g }) => [`${g.sqrt} = sqrt(${I.a});`]; + } +} +class aD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "inversesqrt", outTypeFunc: I0 }), this.statements = ({ inputs: I, outputs: g }) => [`${g.inversesqrt} = inversesqrt(${I.a});`]; + } +} +class ND extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "min", outTypeFunc: VE }), this.statements = ({ inputs: g, outputs: B }) => [`${B.min} = min(${g.a}, ${g.b});`]; + } +} +class cD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "max", outTypeFunc: g0 }), this.statements = ({ inputs: g, outputs: B }) => [`${B.max} = max(${g.a}, ${g.b});`]; + } +} +class MD extends OI { + constructor({ + a: A, + min: I, + max: g + }) { + super({ + a: A, + b: I, + c: g, + outKey: "clamp", + outTypeFunc: Q0 + }), this.statements = ({ inputs: B, outputs: C }) => { + const { a: E, b: D, c: i } = B; + return [`${C.clamp} = clamp(${E}, ${D}, ${i});`]; + }; + } +} +class JD extends OI { + constructor({ a: A, b: I, t: g }) { + super({ a: A, b: I, c: g, outKey: "mix", outTypeFunc: B0 }), this.statements = ({ inputs: B, outputs: C }) => { + const { a: E, b: D, c: i } = B; + return [`${C.mix} = mix(${E}, ${D}, ${i});`]; + }; + } +} +class UD extends DA { + constructor({ edge: A, x: I }) { + super({ + a: A, + b: I, + outKey: "step", + outTypeFunc: C0 + }), this.statements = ({ inputs: g, outputs: B }) => { + const { a: C, b: E } = g; + return [`${B.step} = step(${C}, ${E});`]; + }; + } +} +class tD extends OI { + constructor({ + edge0: A, + edge1: I, + x: g + }) { + super({ + a: A, + b: I, + c: g, + outKey: "smoothstep", + outTypeFunc: E0 + }), this.statements = ({ inputs: B, outputs: C }) => { + const { a: E, b: D, c: i } = B; + return [`${C.smoothstep} = smoothstep(${E}, ${D}, ${i});`]; + }; + } +} +class HD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "isNan", outTypeFunc: XE }), this.statements = ({ inputs: I, outputs: g }) => [`${g.isNan} = isNan(${I.a});`]; + } +} +class LD extends e { + constructor({ a: A }) { + super({ a: A, outKey: "isInf", outTypeFunc: D0 }), this.statements = ({ inputs: I, outputs: g }) => [`${g.isInf} = isInf(${I.a});`]; + } +} +const K0 = (Q, A) => new KD({ a: Q, b: A }), e0 = (Q, A) => new eD({ a: Q, b: A }), r0 = (Q, A) => new rD({ a: Q, b: A }), n0 = (Q) => new nD({ a: Q }), d0 = (Q, A) => new mD({ a: Q, b: A }), q0 = (Q, A) => new ZD({ a: Q, b: A }), x0 = (Q, A) => new dD({ a: Q, b: A }), l0 = (Q, A) => new qD({ a: Q, b: A }), p0 = (Q, A) => new xD({ a: Q, b: A }), YD = (Q, A) => new lD({ a: Q, b: A }), f0 = (Q, A) => new pD({ a: Q, b: A }), b0 = (Q, A) => new fD({ a: Q, b: A }), P0 = (Q) => new bD({ a: Q }), u0 = (Q) => new PD({ a: Q }), hB = (Q, A, I) => new uD({ cond: Q, t: A, f: I }), T0 = (Q) => new OD({ a: Q }); +class KD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: (g, B) => g, outKey: "and" }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.and === "bool" ? [`${B.and} = ${g.a} && ${g.b};`] : [`${B.and} = ${g.a} & ${g.b};`]; + } +} +class eD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: (g, B) => g, outKey: "or" }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.or === "bool" ? [`${B.or} = ${g.a} || ${g.b};`] : [`${B.or} = ${g.a} | ${g.b};`]; + } +} +class rD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: (g, B) => g, outKey: "xor" }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.xor === "bool" ? [`${B.xor} = ${g.a} ^^ ${g.b};`] : [`${B.xor} = ${g.a} ^ ${g.b};`]; + } +} +class nD extends e { + constructor({ a: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "not" }), this.statements = ({ inputs: I, outputs: g }) => this.outTypes.not === "bool" ? [`${g.not} = !${I.a};`] : [`${g.not} = not(${I.a});`]; + } +} +class dD extends DA { + constructor({ a: A, b: I }) { + super({ + a: A, + b: I, + outTypeFunc: (g, B) => EQ(g, "lessThan"), + outKey: "lessThan" + }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.lessThan === "bool" ? [`${B.lessThan} = ${g.a} < ${g.b};`] : [`${B.lessThan} = lessThan(${g.a}, ${g.b});`]; + } +} +class qD extends DA { + constructor({ a: A, b: I }) { + super({ + a: A, + b: I, + outTypeFunc: (g, B) => EQ(g, "lessThanEqual"), + outKey: "lessThanEqual" + }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.lessThanEqual === "bool" ? [`${B.lessThanEqual} = ${g.a} <= ${g.b};`] : [ + `${B.lessThanEqual} = lessThanEqual(${g.a}, ${g.b});` + ]; + } +} +class xD extends DA { + constructor({ a: A, b: I }) { + super({ + a: A, + b: I, + outTypeFunc: (g, B) => EQ(g, "greaterThan"), + outKey: "greaterThan" + }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.greaterThan === "bool" ? [`${B.greaterThan} = ${g.a} > ${g.b};`] : [ + `${B.greaterThan} = greaterThan(${g.a}, ${g.b});` + ]; + } +} +class lD extends DA { + constructor({ a: A, b: I }) { + super({ + a: A, + b: I, + outTypeFunc: (g, B) => EQ(g, "greaterThanEqual"), + outKey: "greaterThanEqual" + }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.greaterThanEqual === "bool" ? [`${B.greaterThanEqual} = ${g.a} >= ${g.b};`] : [ + `${B.greaterThanEqual} = greaterThanEqual(${g.a}, ${g.b});` + ]; + } +} +class pD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: TD, outKey: "equal" }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.equal === "bool" ? [`${B.equal} = ${g.a} == ${g.b};`] : [`${B.equal} = equal(${g.a}, ${g.b});`]; + } +} +class fD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: O0, outKey: "notEqual" }), this.statements = ({ inputs: g, outputs: B }) => this.outTypes.notEqual === "bool" ? [`${B.notEqual} = ${g.a} != ${g.b};`] : [`${B.notEqual} = notEqual(${g.a}, ${g.b});`]; + } +} +class bD extends e { + constructor({ a: A }) { + super({ a: A, outTypeFunc: (I) => "bool", outKey: "any" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.any} = any(${I.a});`]; + } +} +class PD extends e { + constructor({ a: A }) { + super({ a: A, outTypeFunc: (I) => "bool", outKey: "all" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.all} = all(${I.a});`]; + } +} +class uD extends OI { + constructor({ + cond: A, + t: I, + f: g + }) { + super({ + a: A, + b: I, + c: g, + outKey: "select", + outTypeFunc: (B, C, E) => C + }), this.statements = ({ inputs: B, outputs: C }) => { + const { a: E, b: D, c: i } = B; + return [`${C.select} = (${E}) ? (${D}) : (${i});`]; + }; + } +} +function EQ(Q, A) { + if (TI(Q)) + return "bool"; + if (Q === "ivec2" || Q === "uvec2" || Q === "vec2") + return "bvec2"; + if (Q === "ivec3" || Q === "uvec3" || Q === "vec3") + return "bvec3"; + if (Q === "ivec4" || Q === "uvec4" || Q === "vec4") + return "bvec4"; + throw new Error(`Invalid ${A} type: ${Q}`); +} +function TD(Q, A = "equal") { + if (TI(Q)) + return "bool"; + if (uI(Q)) + return Q; + if (Q === "ivec2" || Q === "uvec2" || Q === "vec2") + return "bvec2"; + if (Q === "ivec3" || Q === "uvec3" || Q === "vec3") + return "bvec3"; + if (Q === "ivec4" || Q === "uvec4" || Q === "vec4") + return "bvec4"; + throw new Error(`Invalid ${A} type: ${Q}`); +} +function O0(Q) { + return TD(Q, "notEqual"); +} +function m0(Q) { + if (uI(Q)) + return "bool"; + if (xA(Q)) + return "int"; + if (lA(Q)) + return "uint"; + throw new Error(`Invalid compXor type: ${Q}`); +} +class OD extends e { + constructor({ a: A }) { + const I = m0(CA(A)); + super({ a: A, outTypeFunc: (g) => I, outKey: "compXor" }), this.statements = ({ inputs: g, outputs: B }) => { + if (TI(this.outTypes.compXor)) + return [`${B.compXor} = ${g.a};`]; + const E = (gg(I) ? ["x", "y"] : Qg(I) ? ["x", "y", "z"] : ["x", "y", "z", "w"]).map((i) => `${g.a}.${i}`), D = uI(I) ? "^^" : "^"; + return [`${B.compXor} = ${E.join(` ${D} `)};`]; + }; + } +} +class mD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: (g, B) => g, outKey: "shr" }), this.statements = ({ inputs: g, outputs: B }) => [`${B.shr} = ${g.a} >> ${g.b};`]; + } +} +class ZD extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outTypeFunc: (g, B) => g, outKey: "shl" }), this.statements = ({ inputs: g, outputs: B }) => [`${B.shl} = ${g.a} << ${g.b};`]; + } +} +const Z0 = (Q) => new _D({ value: Q }), V0 = (Q) => new $D({ value: Q }), X0 = (Q) => new Ai({ value: Q }), VD = (Q) => new Ii({ value: Q }), W0 = (Q) => new gi({ value: Q }), j0 = (Q) => new Qi({ value: Q }), v0 = (Q) => new Bi({ value: Q }), z0 = (Q) => new Ci({ value: Q }), _0 = (Q) => new Ei({ value: Q }), $0 = (Q) => new Di({ value: Q }), Ay = (Q) => new ii({ value: Q }), Iy = (Q) => new wi({ value: Q }), gy = (Q) => new oi({ value: Q }), XD = (Q) => new si({ value: Q }), fI = (Q) => new Gi({ value: Q }), WD = (Q) => new yi({ value: Q }), Qy = (Q) => new hi({ value: Q }), By = (Q) => new Ri({ value: Q }), Cy = (Q) => new ki({ value: Q }), jD = (Q) => new Fi({ value: Q }), vD = (Q) => new Si({ value: Q }), Ey = (Q) => new ai({ value: Q }), Dy = (Q) => new Ni({ value: Q }), iy = (Q) => new ci({ value: Q }), wy = (Q) => new Mi({ value: Q }), oy = (Q) => new Ji({ value: Q }), sy = (Q) => new Ui({ value: Q }), zD = (Q) => new ti({ value: Q }), Gy = (Q) => new Hi({ value: Q }), fQ = (Q) => new Li({ value: Q }); +class tA extends e { + constructor({ + value: A, + outType: I, + outKey: g + }) { + super({ a: A, outTypeFunc: () => I, outKey: g }), this.statements = ({ inputs: B, outputs: C }) => [ + `${C[g]} = ${GC(I)}(${B.a});` + ]; + } +} +class _D extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "bool", outKey: "bool" }); + } +} +class $D extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "int", outKey: "int" }); + } +} +class Ai extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "uint", outKey: "uint" }); + } +} +class Ii extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "float", outKey: "float" }); + } +} +class gi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "bvec2", outKey: "bvec2" }); + } +} +class Qi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "bvec3", outKey: "bvec3" }); + } +} +class Bi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "bvec4", outKey: "bvec4" }); + } +} +class Ci extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "ivec2", outKey: "ivec2" }); + } +} +class Ei extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "ivec3", outKey: "ivec3" }); + } +} +class Di extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "ivec4", outKey: "ivec4" }); + } +} +class ii extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "uvec2", outKey: "uvec2" }); + } +} +class wi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "uvec3", outKey: "uvec3" }); + } +} +class oi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "uvec4", outKey: "uvec4" }); + } +} +class si extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "vec2", outKey: "vec2" }); + } +} +class Gi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "vec3", outKey: "vec3" }); + } +} +class yi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "vec4", outKey: "vec4" }); + } +} +class hi extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "mat2", outKey: "mat2" }); + } +} +class Ri extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "mat3", outKey: "mat3" }); + } +} +class ki extends tA { + constructor({ + value: A + }) { + super({ value: A, outType: "mat4", outKey: "mat4" }); + } +} +class Fi extends e { + constructor({ value: A }) { + super({ a: A, outKey: "int", outTypeFunc: () => "int" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.int} = floatBitsToInt(${I.a});`]; + } +} +class Si extends e { + constructor({ value: A }) { + super({ a: A, outKey: "uint", outTypeFunc: () => "uint" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.uint} = floatBitsToUint(${I.a});`]; + } +} +class ai extends e { + constructor({ value: A }) { + super({ a: A, outKey: "float", outTypeFunc: () => "float" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.float} = intBitsToFloat(${I.a});`]; + } +} +class Ni extends e { + constructor({ value: A }) { + super({ a: A, outKey: "float", outTypeFunc: () => "float" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.float} = uintBitsToFloat(${I.a});`]; + } +} +class ci extends e { + constructor({ value: A }) { + super({ a: A, outKey: "uint", outTypeFunc: () => "uint" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.uint} = packSnorm2x16(${I.a});`]; + } +} +class Mi extends e { + constructor({ value: A }) { + super({ a: A, outKey: "vec2", outTypeFunc: () => "vec2" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.vec2} = unpackSnorm2x16(${I.a});`]; + } +} +class Ji extends e { + constructor({ value: A }) { + super({ a: A, outKey: "uint", outTypeFunc: () => "uint" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.uint} = packUnorm2x16(${I.a});`]; + } +} +class Ui extends e { + constructor({ value: A }) { + super({ a: A, outKey: "vec2", outTypeFunc: () => "vec2" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.vec2} = unpackUnorm2x16(${I.a});`]; + } +} +class ti extends e { + constructor({ value: A }) { + super({ a: A, outKey: "uint", outTypeFunc: () => "uint" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.uint} = packHalf2x16(${I.a});`]; + } +} +class Hi extends e { + constructor({ value: A }) { + super({ a: A, outKey: "vec2", outTypeFunc: () => "vec2" }), this.statements = ({ inputs: I, outputs: g }) => [`${g.vec2} = unpackHalf2x16(${I.a});`]; + } +} +class Li extends e { + constructor({ value: A }) { + super({ a: A, outKey: "rgba8", outTypeFunc: () => "vec4" }), this.statements = ({ inputs: I, outputs: g }) => [ + `uvec4 uRgba = uvec4(${I.a} & 0xffu, (${I.a} >> 8u) & 0xffu, (${I.a} >> 16u) & 0xffu, (${I.a} >> 24u) & 0xffu);`, + `${g.rgba8} = vec4(uRgba) / 255.0;` + ]; + } +} +const yy = (Q) => new Ki({ a: Q }), hy = (Q, A) => new ei({ a: Q, b: A }), Yi = (Q, A) => new ri({ a: Q, b: A }), Ry = (Q, A) => new ni({ a: Q, b: A }), Sg = (Q) => new di({ a: Q }), ky = (Q, A, I) => new li({ a: Q, b: A, c: I }), Fy = (Q, A) => new pi({ incident: Q, normal: A }), Sy = (Q, A, I) => new fi({ incident: Q, normal: A, eta: I }), $I = (Q) => new mi({ vector: Q }), yI = ({ + vector: Q, + vectorType: A, + x: I, + y: g, + z: B, + w: C, + r: E, + g: D, + b: i, + a: w +}) => new Zi({ vector: Q, vectorType: A, x: I, y: g, z: B, w: C, r: E, g: D, b: i, a: w }), ay = (Q) => new qi({ a: Q }), Ny = (Q, A) => new xi({ a: Q, b: A }), cy = (Q, A) => new Vi({ vector: Q, select: A }), My = (Q, A) => new bi({ a: Q, b: A }), Jy = (Q, A) => new Pi({ a: Q, b: A }), Uy = (Q) => new ui({ a: Q }), ty = (Q) => new Ti({ a: Q }), Hy = (Q) => new Oi({ a: Q }); +class Ki extends e { + constructor({ a: A }) { + super({ a: A, outTypeFunc: (I) => "float", outKey: "length" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.length} = length(${I.a});` + ]; + } +} +class ei extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "distance", outTypeFunc: (g, B) => "float" }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.distance} = distance(${g.a}, ${g.b});` + ]; + } +} +class ri extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "dot", outTypeFunc: (g, B) => "float" }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.dot} = dot(${g.a}, ${g.b});` + ]; + } +} +class ni extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "cross", outTypeFunc: (g, B) => "vec3" }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.cross} = cross(${g.a}, ${g.b});` + ]; + } +} +class di extends e { + constructor({ a: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "normalize" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.normalize} = normalize(${I.a});` + ]; + } +} +function Ly(Q) { + if (Q === "vec3") + return "vec2"; + if (Q === "vec4") + return "vec3"; + throw new Error("Invalid type"); +} +class qi extends e { + constructor({ a: A }) { + super({ + a: A, + outTypeFunc: (I) => Ly(I), + outKey: "projected" + }), this.statements = ({ inputs: I, outputs: g }) => { + if (this.inTypes.a === "vec3") + return [`${g.projected} = ${I.a}.xy / ${I.a}.z;`]; + if (this.inTypes.a === "vec4") + return [`${g.projected} = ${I.a}.xyz / ${I.a}.w;`]; + throw new Error("Invalid type"); + }; + } +} +function Yy(Q) { + if (Q === "float") return "vec2"; + if (Q === "vec2") return "vec3"; + if (Q === "vec3") return "vec4"; + throw new Error("Invalid type"); +} +class xi extends DA { + constructor({ a: A, b: I }) { + const g = CA(A), B = Yy(g); + super({ a: A, b: I, outKey: "extend", outTypeFunc: () => B }), this.statements = ({ inputs: C, outputs: E }) => [ + `${E.extend} = ${B}(${C.a}, ${C.b});` + ]; + } +} +class li extends OI { + constructor({ a: A, b: I, c: g }) { + super({ + a: A, + b: I, + c: g, + outKey: "forward", + outTypeFunc: (B, C, E) => B + }), this.statements = ({ inputs: B, outputs: C }) => [ + `${C.forward} = faceforward(${B.a}, ${B.b}, ${B.c});` + ]; + } +} +class pi extends DA { + constructor({ + incident: A, + normal: I + }) { + super({ + a: A, + b: I, + outKey: "reflection", + outTypeFunc: (g, B) => g + }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.reflection} = reflect(${g.a}, ${g.b});` + ]; + } +} +class fi extends OI { + constructor({ + incident: A, + normal: I, + eta: g + }) { + super({ + a: A, + b: I, + c: g, + outKey: "refraction", + outTypeFunc: (B, C, E) => B + }), this.statements = ({ inputs: B, outputs: C }) => [ + `${C.refraction} = refract(${B.a}, ${B.b}, ${B.c});` + ]; + } +} +class bi extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "product", outTypeFunc: (g, B) => g }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.product} = matrixCompMult(${A}, ${I});` + ]; + } +} +function Ky(Q, A) { + if (Q === "vec2") { + if (A === "vec2") return "mat2"; + if (A === "vec3") return "mat3x2"; + if (A === "vec4") return "mat4x2"; + } + if (Q === "vec3") { + if (A === "vec2") return "mat2x3"; + if (A === "vec3") return "mat3"; + if (A === "vec4") return "mat4x3"; + } + if (Q === "vec4") { + if (A === "vec2") return "mat2x4"; + if (A === "vec3") return "mat3x4"; + if (A === "vec4") return "mat4"; + } + throw new Error(`Invalid outer type: ${Q}, ${A}`); +} +class Pi extends DA { + constructor({ a: A, b: I }) { + super({ a: A, b: I, outKey: "outer", outTypeFunc: Ky }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.outer} = outerProduct(${g.a}, ${g.b});` + ]; + } +} +function ey(Q) { + if (Q === "mat2") return "mat2"; + if (Q === "mat3") return "mat3"; + if (Q === "mat4") return "mat4"; + if (Q === "mat2x2") return "mat2x2"; + if (Q === "mat2x3") return "mat3x2"; + if (Q === "mat2x4") return "mat4x2"; + if (Q === "mat3x2") return "mat2x3"; + if (Q === "mat3x3") return "mat3x3"; + if (Q === "mat3x4") return "mat4x3"; + if (Q === "mat4x2") return "mat2x4"; + if (Q === "mat4x3") return "mat3x4"; + if (Q === "mat4x4") return "mat4x4"; + throw new Error(`Invalid transpose type: ${Q}`); +} +class ui extends e { + constructor({ a: A }) { + super({ a: A, outKey: "transpose", outTypeFunc: ey }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.transpose} = transpose(${I.a});` + ]; + } +} +class Ti extends e { + constructor({ a: A }) { + super({ a: A, outKey: "det", outTypeFunc: (I) => "float" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.det} = determinant(${I.a});` + ]; + } +} +class Oi extends e { + constructor({ a: A }) { + super({ a: A, outKey: "inverse", outTypeFunc: (I) => I }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.inverse} = inverse(${A});` + ]; + } +} +function ry(Q) { + const A = (I) => I; + switch (Q) { + case "vec2": + return A({ x: "float", y: "float", r: "float", g: "float" }); + case "vec3": + return A({ + x: "float", + y: "float", + z: "float", + r: "float", + g: "float", + b: "float" + }); + case "vec4": + return A({ + x: "float", + y: "float", + z: "float", + w: "float", + r: "float", + g: "float", + b: "float", + a: "float" + }); + case "ivec2": + return A({ x: "int", y: "int", r: "int", g: "int" }); + case "ivec3": + return A({ + x: "int", + y: "int", + z: "int", + r: "int", + g: "int", + b: "int" + }); + case "ivec4": + return A({ + x: "int", + y: "int", + z: "int", + w: "int", + r: "int", + g: "int", + b: "int", + a: "int" + }); + case "uvec2": + return A({ x: "uint", y: "uint", r: "uint", g: "uint" }); + case "uvec3": + return A({ + x: "uint", + y: "uint", + z: "uint", + r: "uint", + g: "uint", + b: "uint" + }); + case "uvec4": + return A({ + x: "uint", + y: "uint", + z: "uint", + w: "uint", + r: "uint", + g: "uint", + b: "uint", + a: "uint" + }); + default: + throw new Error(`Invalid vector type: ${Q}`); + } +} +class mi extends d { + constructor({ vector: A }) { + const g = { vector: CA(A) }, B = ry(g.vector); + super({ inTypes: g, outTypes: B, inputs: { vector: A } }), this.statements = ({ inputs: C, outputs: E }) => { + const { x: D, y: i, z: w, w: s, r: o, g: y, b: h, a: k } = E, { vector: R } = C; + return [ + D ? `${D} = ${R}.x;` : null, + i ? `${i} = ${R}.y;` : null, + w ? `${w} = ${R}.z;` : null, + s ? `${s} = ${R}.w;` : null, + o ? `${o} = ${R}.r;` : null, + y ? `${y} = ${R}.g;` : null, + h ? `${h} = ${R}.b;` : null, + k ? `${k} = ${R}.a;` : null + ].filter(Boolean); + }; + } +} +class Zi extends d { + constructor({ + vector: A, + vectorType: I, + x: g, + y: B, + z: C, + w: E, + r: D, + g: i, + b: w, + a: s + }) { + if (!A && !I) + throw new Error("Either vector or vectorType must be provided"); + const o = I ?? CA(A), y = wC(o), h = oC(o), k = { + vector: o, + x: y, + y, + r: y, + g: y + }, R = { vector: A, x: g, y: B, r: D, g: i }; + h >= 3 && (Object.assign(k, { z: y, b: y }), Object.assign(R, { z: C, b: w })), h >= 4 && (Object.assign(k, { w: y, a: y }), Object.assign(R, { w: E, a: s })), super({ inTypes: k, outTypes: { vector: o }, inputs: R }), this.statements = ({ inputs: F, outputs: S }) => { + const { vector: a } = S, { + vector: M, + x: c, + y: N, + z: U, + w: J, + r: t, + g: H, + b: K, + a: Y + } = F, L = [ + `${a}.x = ${c ?? t ?? (M ? `${M}.x` : Dg(y))};`, + `${a}.y = ${N ?? H ?? (M ? `${M}.y` : Dg(y))};` + ]; + return h >= 3 && L.push( + `${a}.z = ${U ?? K ?? (M ? `${M}.z` : Dg(y))};` + ), h >= 4 && L.push( + `${a}.w = ${J ?? Y ?? (M ? `${M}.w` : Dg(y))};` + ), L; + }; + } + dynoOut() { + return new V( + this, + "vector" + ); + } +} +function ny(Q, A) { + let I = null; + if (Mg(Q) ? I = A.length === 1 ? "float" : A.length === 2 ? "vec2" : A.length === 3 ? "vec3" : A.length === 4 ? "vec4" : null : xA(Q) ? I = A.length === 1 ? "int" : A.length === 2 ? "ivec2" : A.length === 3 ? "ivec3" : A.length === 4 ? "ivec4" : null : lA(Q) && (I = A.length === 1 ? "uint" : A.length === 2 ? "uvec2" : A.length === 3 ? "uvec3" : A.length === 4 ? "uvec4" : null), I == null) + throw new Error(`Invalid swizzle: ${A}`); + return I; +} +class Vi extends e { + constructor({ vector: A, select: I }) { + super({ + a: A, + outKey: "swizzle", + outTypeFunc: (g) => ny(g, I) + }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.swizzle} = ${g.a}.${I};` + ]; + } +} +const dy = (Q, A, I) => new $i({ index: Q, from: A, to: I }), qy = (Q) => new Bg({ value: Q }), xy = (Q) => new zA({ state: Q }), ly = (Q) => new _A({ state: Q }), Xi = (Q) => new Aw({ value: Q }), Wi = (Q) => new Iw({ value: Q }), ji = (Q) => new gw({ value: Q }), vi = (Q) => new Qw({ value: Q }), py = (Q) => new Bw({ value: Q }), fy = (Q) => new Cw({ value: Q }), zi = (Q) => new Ew({ value: Q }), bQ = (Q) => new Dw({ value: Q }), _i = (Q, A, I) => new iw({ z: Q, zNear: A, zFar: I }).outputs.depth, by = (Q) => new ww({ index: Q }); +class $i extends d { + constructor({ + from: A, + to: I, + index: g + }) { + super({ + inTypes: { from: "int", to: "int", index: "int" }, + outTypes: { index: "int" }, + inputs: { from: A, to: I, index: g }, + statements: ({ inputs: B, outputs: C }) => [ + `${C.index} = ${B.index} - ${B.from} + ${B.to};` + ] + }); + } + dynoOut() { + return new V(this, "index"); + } +} +class zA extends d { + constructor({ state: A }) { + const I = CA(A); + super({ + inTypes: { state: I }, + outTypes: { state: "uint" }, + inputs: { state: A }, + globals: () => [ + oA(` + uint pcg_next(uint state) { + return state * 747796405u + 2891336453u; + } + `) + ], + statements: ({ inputs: g, outputs: B }) => { + const C = I === "uint" ? `${g.state}` : I === "int" ? `uint(${g.state})` : `floatBitsToUint(${g.state})`; + return [`${B.state} = pcg_next(${C});`]; + } + }); + } + dynoOut() { + return new V(this, "state"); + } +} +class _A extends d { + constructor({ state: A }) { + super({ + inTypes: { state: "uint" }, + outTypes: { hash: "uint" }, + inputs: { state: A }, + globals: () => [ + oA(` + uint pcg_hash(uint state) { + uint hash = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u; + return (hash >> 22u) ^ hash; + } + `) + ], + statements: ({ inputs: I, outputs: g }) => [ + `${g.hash} = pcg_hash(${I.state});` + ] + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Bg extends d { + constructor({ value: A }) { + const I = CA(A), g = sC(I); + super({ + inTypes: { value: I }, + outTypes: { state: "uint" }, + inputs: { value: A }, + globals: () => [ + oA(` + uint pcg_mix(uint value) { + return value; + } + uint pcg_mix(uvec2 value) { + return value.x + 0x9e3779b9u * value.y; + } + uint pcg_mix(uvec3 value) { + return value.x + 0x9e3779b9u * value.y + 0x85ebca6bu * value.z; + } + uint pcg_mix(uvec4 value) { + return value.x + 0x9e3779b9u * value.y + 0x85ebca6bu * value.z + 0xc2b2ae35u * value.w; + } + `) + ], + statements: ({ inputs: B, outputs: C }) => { + const E = lA(I) ? `${B.value}` : xA(I) ? `${g}(${B.value})` : `floatBitsToUint(${B.value})`; + return [ + `${g} bits = ${E};`, + `${C.state} = pcg_mix(bits);` + ]; + } + }); + } + dynoOut() { + return new V(this, "state"); + } +} +class Aw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "uint" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + let g = new Bg({ value: I }).outputs.state; + return g = new zA({ state: g }).outputs.state, new _A({ state: g }).outputs; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Iw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "uvec2" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + let g = new Bg({ value: I }).outputs.state; + g = new zA({ state: g }).outputs.state; + const B = new _A({ state: g }).outputs.hash; + g = new zA({ state: g }).outputs.state; + const C = new _A({ state: g }).outputs.hash; + return { hash: yI({ vectorType: "uvec2", x: B, y: C }) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class gw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "uvec3" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + let g = new Bg({ value: I }).outputs.state; + g = new zA({ state: g }).outputs.state; + const B = new _A({ state: g }).outputs.hash; + g = new zA({ state: g }).outputs.state; + const C = new _A({ state: g }).outputs.hash; + g = new zA({ state: g }).outputs.state; + const E = new _A({ state: g }).outputs.hash; + return { hash: yI({ vectorType: "uvec3", x: B, y: C, z: E }) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Qw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "uvec4" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + let g = new Bg({ value: I }).outputs.state; + g = new zA({ state: g }).outputs.state; + const B = new _A({ state: g }).outputs.hash; + g = new zA({ state: g }).outputs.state; + const C = new _A({ state: g }).outputs.hash; + g = new zA({ state: g }).outputs.state; + const E = new _A({ state: g }).outputs.hash; + g = new zA({ state: g }).outputs.state; + const D = new _A({ state: g }).outputs.hash; + return { hash: yI({ vectorType: "uvec4", x: B, y: C, z: E, w: D }) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Bw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "float" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + const g = Xi(I); + return { hash: kA(VD(g), v("float", 1 / 2 ** 32)) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Cw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "vec2" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + const g = Wi(I); + return { hash: kA(XD(g), v("float", 1 / 2 ** 32)) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Ew extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "vec3" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + const g = ji(I); + return { hash: kA(fI(g), v("float", 1 / 2 ** 32)) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class Dw extends hI { + constructor({ value: A }) { + super({ + inTypes: { value: CA(A) }, + outTypes: { hash: "vec4" }, + inputs: { value: A }, + construct: ({ value: I }) => { + if (!I) + throw new Error("value is required"); + const g = vi(I); + return { hash: kA(WD(g), v("float", 1 / 2 ** 32)) }; + } + }); + } + dynoOut() { + return new V(this, "hash"); + } +} +class iw extends d { + constructor({ + z: A, + zNear: I, + zFar: g + }) { + super({ + inTypes: { z: "float", zNear: "float", zFar: "float" }, + outTypes: { depth: "float" }, + inputs: { z: A, zNear: I, zFar: g }, + statements: ({ inputs: B, outputs: C }) => [ + `float clamped = clamp(${B.z}, ${B.zNear}, ${B.zFar});`, + `${C.depth} = (log2(clamped + 1.0) - log2(${B.zNear} + 1.0)) / (log2(${B.zFar} + 1.0) - log2(${B.zNear} + 1.0));` + ] + }); + } + dynoOut() { + return new V(this, "depth"); + } +} +class ww extends d { + constructor({ index: A }) { + super({ + inTypes: { index: "int" }, + outTypes: { color: "vec3" }, + inputs: { index: A }, + statements: ({ inputs: I, outputs: g }) => [ + `${g.color} = debugColorHue(uint(${I.index}));` + ] + }); + } + dynoOut() { + return new V(this, "color"); + } +} +const ow = (Q, { + scale: A, + scales: I, + rotate: g, + translate: B +}) => new Gw({ position: Q, scale: A, scales: I, rotate: g, translate: B }).outputs.position, sw = (Q, { + scale: A, + scales: I, + rotate: g +}) => new yw({ dir: Q, scale: A, scales: I, rotate: g }).outputs.dir, Py = (Q, { rotate: A }) => new hw({ quaternion: Q, rotate: A }).outputs.quaternion; +class Gw extends d { + constructor({ + position: A, + scale: I, + scales: g, + rotate: B, + translate: C + }) { + super({ + inTypes: { + position: "vec3", + scale: "float", + scales: "vec3", + rotate: "vec4", + translate: "vec3" + }, + outTypes: { position: "vec3" }, + inputs: { position: A, scale: I, scales: g, rotate: B, translate: C }, + statements: ({ inputs: E, outputs: D }) => { + const { position: i } = D; + if (!i) + return []; + const { scale: w, scales: s, rotate: o, translate: y } = E; + return [ + `${i} = ${E.position ?? "vec3(0.0, 0.0, 0.0)"};`, + w ? `${i} *= ${w};` : null, + s ? `${i} *= ${s};` : null, + o ? `${i} = quatVec(${o}, ${i});` : null, + y ? `${i} += ${y};` : null + ].filter(Boolean); + } + }); + } +} +class yw extends d { + constructor({ + dir: A, + scale: I, + scales: g, + rotate: B + }) { + super({ + inTypes: { dir: "vec3", scale: "float", scales: "vec3", rotate: "vec4" }, + outTypes: { dir: "vec3" }, + inputs: { dir: A, scale: I, scales: g, rotate: B }, + statements: ({ inputs: C, outputs: E }) => { + const { dir: D } = E; + if (!D) + return []; + const { scale: i, scales: w, rotate: s } = C; + return [ + `${D} = ${C.dir ?? "vec3(0.0, 0.0, 0.0)"};`, + i ? `${D} *= ${i};` : null, + w ? `${D} *= ${w};` : null, + s ? `${D} = quatVec(${s}, ${D});` : null + ].filter(Boolean); + } + }); + } +} +class hw extends d { + constructor({ + quaternion: A, + rotate: I + }) { + super({ + inTypes: { quaternion: "vec4", rotate: "vec4" }, + outTypes: { quaternion: "vec4" }, + inputs: { quaternion: A, rotate: I }, + statements: ({ inputs: g, outputs: B }) => { + const { quaternion: C } = B; + return C ? [ + `${C} = ${g.quaternion ?? "vec4(0.0, 0.0, 0.0, 1.0)"};`, + I ? `${C} = quatQuat(${g.rotate}, ${C});` : null + ].filter(Boolean) : []; + } + }); + } +} +const uy = () => { + throw new Error("Not implemented"); +}, Ty = () => { + throw new Error("Not implemented"); +}, Oy = () => { + throw new Error("Not implemented"); +}, my = () => { + throw new Error("Not implemented"); +}, Zy = () => { + throw new Error("Not implemented"); +}, Vy = () => { + throw new Error("Not implemented"); +}, Xy = (Q, A) => new Rw({ texture: Q, lod: A }), Wy = (Q, A, I) => new kw({ texture: Q, coord: A, bias: I }), jy = (Q, A, I) => new Fw({ texture: Q, coord: A, lod: I }); +class Rw extends d { + constructor({ texture: A, lod: I }) { + const g = CA(A); + super({ + inTypes: { texture: g, lod: "int" }, + outTypes: { size: Sw(g) }, + inputs: { texture: A, lod: I }, + statements: ({ inputs: B, outputs: C }) => [ + `${C.size} = textureSize(${B.texture}, ${B.lod ?? "0"});` + ] + }); + } + dynoOut() { + return new V(this, "size"); + } +} +class kw extends d { + constructor({ + texture: A, + coord: I, + bias: g + }) { + const B = CA(A); + super({ + inTypes: { + texture: B, + coord: vy(B), + bias: "float" + }, + outTypes: { sample: aw(B) }, + inputs: { texture: A, coord: I, bias: g }, + statements: ({ inputs: C, outputs: E }) => [ + `${E.sample} = texture(${C.texture}, ${C.coord}${C.bias ? `, ${C.bias}` : ""});` + ] + }); + } + dynoOut() { + return new V(this, "sample"); + } +} +class Fw extends d { + constructor({ + texture: A, + coord: I, + lod: g + }) { + const B = CA(A); + super({ + inTypes: { + texture: B, + coord: Sw(B), + lod: "int" + }, + outTypes: { texel: aw(B) }, + inputs: { texture: A, coord: I, lod: g }, + statements: ({ inputs: C, outputs: E }) => [ + `${E.texel} = texelFetch(${C.texture}, ${C.coord}, ${C.lod ?? "0"});` + ] + }); + } + dynoOut() { + return new V(this, "texel"); + } +} +function Sw(Q) { + switch (Q) { + case "sampler2D": + case "usampler2D": + case "isampler2D": + case "samplerCube": + case "usamplerCube": + case "isamplerCube": + case "sampler2DShadow": + case "samplerCubeShadow": + return "ivec2"; + case "sampler3D": + case "usampler3D": + case "isampler3D": + case "sampler2DArray": + case "usampler2DArray": + case "isampler2DArray": + case "sampler2DArrayShadow": + return "ivec3"; + default: + throw new Error(`Invalid texture type: ${Q}`); + } +} +function vy(Q) { + switch (Q) { + case "sampler2D": + case "usampler2D": + case "isampler2D": + return "vec2"; + case "sampler3D": + case "usampler3D": + case "isampler3D": + case "samplerCube": + case "usamplerCube": + case "isamplerCube": + case "sampler2DArray": + case "usampler2DArray": + case "isampler2DArray": + case "sampler2DShadow": + return "vec3"; + case "samplerCubeShadow": + case "sampler2DArrayShadow": + return "vec4"; + default: + throw new Error(`Invalid texture type: ${Q}`); + } +} +function aw(Q) { + switch (Q) { + case "sampler2D": + case "sampler2DArray": + case "sampler3D": + case "samplerCube": + case "sampler2DShadow": + return "vec4"; + case "usampler2D": + case "usampler2DArray": + case "usampler3D": + case "usamplerCube": + return "uvec4"; + case "isampler2D": + case "isampler2DArray": + case "isampler3D": + case "isamplerCube": + return "ivec4"; + case "samplerCubeShadow": + case "sampler2DArrayShadow": + return "float"; + default: + throw new Error(`Invalid texture type: ${Q}`); + } +} +const zy = (Q) => new Nw({ degrees: Q }), _y = (Q) => new cw({ radians: Q }), PQ = (Q) => new Mw({ radians: Q }), $y = (Q) => new Jw({ radians: Q }), Ah = (Q) => new Uw({ radians: Q }), Ih = (Q) => new tw({ sin: Q }), gh = (Q) => new Hw({ cos: Q }), Qh = (Q) => new Lw({ tan: Q }), Bh = (Q, A) => new Yw({ y: Q, x: A }), Ch = (Q) => new Kw({ x: Q }), Eh = (Q) => new ew({ x: Q }), Dh = (Q) => new rw({ x: Q }), ih = (Q) => new nw({ x: Q }), wh = (Q) => new dw({ x: Q }), oh = (Q) => new qw({ x: Q }); +class Nw extends e { + constructor({ degrees: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "radians" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.radians} = radians(${I.a});` + ]; + } +} +class cw extends e { + constructor({ radians: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "degrees" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.degrees} = degrees(${I.a});` + ]; + } +} +class Mw extends e { + constructor({ radians: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "sin" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.sin} = sin(${I.a});` + ]; + } +} +class Jw extends e { + constructor({ radians: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "cos" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.cos} = cos(${I.a});` + ]; + } +} +class Uw extends e { + constructor({ radians: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "tan" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.tan} = tan(${I.a});` + ]; + } +} +class tw extends e { + constructor({ sin: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "asin" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.asin} = asin(${I.a});` + ]; + } +} +class Hw extends e { + constructor({ cos: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "acos" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.acos} = acos(${I.a});` + ]; + } +} +class Lw extends e { + constructor({ tan: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "atan" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.atan} = atan(${I.a});` + ]; + } +} +class Yw extends DA { + constructor({ y: A, x: I }) { + super({ + a: A, + b: I, + outTypeFunc: (g, B) => g, + outKey: "atan2" + }), this.statements = ({ inputs: g, outputs: B }) => [ + `${B.atan2} = atan2(${g.a}, ${g.b});` + ]; + } +} +class Kw extends e { + constructor({ x: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "sinh" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.sinh} = sinh(${I.a});` + ]; + } +} +class ew extends e { + constructor({ x: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "cosh" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.cosh} = cosh(${I.a});` + ]; + } +} +class rw extends e { + constructor({ x: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "tanh" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.tanh} = tanh(${I.a});` + ]; + } +} +class nw extends e { + constructor({ x: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "asinh" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.asinh} = asinh(${I.a});` + ]; + } +} +class dw extends e { + constructor({ x: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "acosh" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.acosh} = acosh(${I.a});` + ]; + } +} +class qw extends e { + constructor({ x: A }) { + super({ a: A, outTypeFunc: (I) => I, outKey: "atanh" }), this.statements = ({ inputs: I, outputs: g }) => [ + `${g.atanh} = atanh(${I.a});` + ]; + } +} +const pk = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + Abs: CD, + Acos: Hw, + Acosh: dw, + Add: zE, + All: PD, + And: KD, + Any: bD, + Asin: tw, + Asinh: nw, + Atan: Lw, + Atan2: Yw, + Atanh: qw, + BVec2: gi, + BVec3: Qi, + BVec4: Bi, + BinaryOp: DA, + Bool: _D, + Ceil: iD, + Clamp: MD, + Combine: Zi, + CombineCovSplat: AE, + CombineGsplat: jC, + CompMult: bi, + CompXor: OD, + Compilation: hC, + Cos: Jw, + Cosh: ew, + CovSplat: eA, + Cross: ni, + DebugColorHue: ww, + Degrees: cw, + Determinant: Ti, + Distance: ei, + Div: AD, + Dot: ri, + Dyno: d, + DynoBlock: hI, + DynoBool: bI, + DynoBvec2: GE, + DynoBvec3: kE, + DynoBvec4: aE, + DynoConst: yC, + DynoFloat: pI, + DynoInt: EI, + DynoIsampler2D: dE, + DynoIsampler2DArray: xE, + DynoIsampler3D: fE, + DynoIsamplerCube: uE, + DynoIvec2: hE, + DynoIvec3: SE, + DynoIvec4: cE, + DynoLiteral: zI, + DynoMat2: ME, + DynoMat2x2: JE, + DynoMat2x3: UE, + DynoMat2x4: tE, + DynoMat3: sB, + DynoMat3x2: HE, + DynoMat3x3: LE, + DynoMat3x4: YE, + DynoMat4: KE, + DynoMat4x2: eE, + DynoMat4x3: rE, + DynoMat4x4: nE, + DynoOutput: V, + DynoProgram: CQ, + DynoProgramTemplate: Fg, + DynoRemapIndex: $i, + DynoSampler2D: qE, + DynoSampler2DArray: lE, + DynoSampler2DArrayShadow: mE, + DynoSampler2DShadow: OE, + DynoSampler3D: bE, + DynoSamplerCube: TE, + DynoSamplerCubeShadow: ZE, + DynoUint: sE, + DynoUniform: x, + DynoUsampler2D: BQ, + DynoUsampler2DArray: dA, + DynoUsampler3D: pE, + DynoUsamplerCube: PE, + DynoUvec2: yE, + DynoUvec3: FE, + DynoUvec4: NE, + DynoValue: UI, + DynoVec2: RE, + DynoVec3: DI, + DynoVec4: mI, + Equal: pD, + Exp: yD, + Exp2: hD, + ExtendVec: xi, + FaceForward: li, + Float: Ii, + FloatBitsToInt: Fi, + FloatBitsToUint: Si, + Floor: DD, + Fract: sD, + GreaterThan: xD, + GreaterThanEqual: lD, + Gsplat: Z, + GsplatNormal: zC, + GsplatToCovSplat: XC, + Hash: Aw, + Hash2: Iw, + Hash3: gw, + Hash4: Qw, + HashFloat: Bw, + HashVec2: Cw, + HashVec3: Ew, + HashVec4: Dw, + IMod: ID, + IVec2: Ci, + IVec3: Ei, + IVec4: Di, + Int: $D, + IntBitsToFloat: ai, + Inverse: Oi, + InverseSqrt: aD, + IsInf: LD, + IsNan: HD, + Length: Ki, + LessThan: dD, + LessThanEqual: qD, + Log: RD, + Log2: kD, + Mat2: hi, + Mat3: Ri, + Mat4: ki, + Max: cD, + Min: ND, + Mix: JD, + Mod: gD, + Modf: QD, + Mul: $E, + Neg: BD, + Normalize: di, + NormalizedDepth: iw, + Not: nD, + NotEqual: fD, + NumCovSplats: ZC, + NumExtSplats: OC, + NumPackedSplats: bC, + Or: eD, + Outer: Pi, + OutputCovSplat: iE, + OutputExtCovSplat: oE, + OutputExtendedSplat: wE, + OutputPackedSplat: DE, + OutputRgba8: oB, + PackHalf2x16: ti, + PackSnorm2x16: ci, + PackUnorm2x16: Ji, + PagedSplatTexCoord: gE, + PcgHash: _A, + PcgMix: Bg, + PcgNext: zA, + Pow: GD, + ProjectH: qi, + Radians: Nw, + ReadCovSplat: VC, + ReadExtSplat: mC, + ReadPackedSplat: uC, + ReadPackedSplatRange: TC, + ReflectVec: pi, + RefractVec: fi, + Round: oD, + Select: uD, + Shl: ZD, + Shr: mD, + Sign: ED, + SimpleCast: tA, + Sin: Mw, + Sinh: Kw, + Smoothstep: tD, + SplatTexCoord: IE, + Split: mi, + SplitCovSplat: $C, + SplitGsplat: WC, + Sqr: FD, + Sqrt: SD, + Step: UD, + Sub: _E, + Swizzle: Vi, + TCovSplats: lC, + TExtSplats: BB, + TPackedSplats: tg, + Tan: Uw, + Tanh: rw, + TexelFetch: Fw, + Texture: kw, + TextureSize: Rw, + TransformDir: yw, + TransformGsplat: _C, + TransformPosition: Gw, + TransformQuaternion: hw, + Transpose: ui, + TrinaryOp: OI, + Trunc: wD, + UVec2: ii, + UVec3: wi, + UVec4: oi, + Uint: Ai, + UintBitsToFloat: Ni, + UintToRgba8: Li, + UnaryOp: e, + UnpackHalf2x16: Hi, + UnpackSnorm2x16: Mi, + UnpackUnorm2x16: Ui, + Vec2: si, + Vec3: Gi, + Vec4: yi, + Xor: rD, + abs: w0, + acos: gh, + acosh: wh, + add: qA, + all: u0, + and: K0, + any: P0, + arrayIndex: Zy, + arrayLength: Vy, + asin: Ih, + asinh: ih, + atan: Qh, + atan2: Bh, + atanh: oh, + bool: Z0, + bvec2: W0, + bvec3: j0, + bvec4: v0, + ceil: G0, + clamp: U0, + combine: yI, + combineCovSplat: iB, + combineGsplat: CI, + comment: my, + compMult: My, + compXor: T0, + cos: $y, + cosh: Eh, + cross: Ry, + debugColorHue: by, + defineCovSplat: LI, + defineExtSplats: DB, + defineGsplat: HA, + defineGsplatNormal: vC, + definePackedSplats: QQ, + degrees: _y, + determinant: ty, + distance: hy, + div: pg, + dot: Yi, + dyno: AQ, + dynoBlock: cA, + dynoBool: Xs, + dynoBvec2: vs, + dynoBvec3: AG, + dynoBvec4: QG, + dynoConst: v, + dynoDeclare: jQ, + dynoFloat: wI, + dynoFor: Oy, + dynoIf: uy, + dynoInt: js, + dynoIsampler2D: NG, + dynoIsampler2DArray: JG, + dynoIsampler3D: HG, + dynoIsamplerCube: KG, + dynoIvec2: _s, + dynoIvec3: gG, + dynoIvec4: CG, + dynoLiteral: ug, + dynoMat2: DG, + dynoMat2x2: iG, + dynoMat2x3: wG, + dynoMat2x4: oG, + dynoMat3: sG, + dynoMat3x2: GG, + dynoMat3x3: yG, + dynoMat3x4: hG, + dynoMat4: RG, + dynoMat4x2: kG, + dynoMat4x3: FG, + dynoMat4x4: SG, + dynoSampler2D: cG, + dynoSampler2DArray: UG, + dynoSampler2DArrayShadow: nG, + dynoSampler2DShadow: rG, + dynoSampler3D: LG, + dynoSamplerCube: eG, + dynoSamplerCubeShadow: dG, + dynoSwitch: Ty, + dynoUint: Ws, + dynoUsampler2D: aG, + dynoUsampler2DArray: MG, + dynoUsampler3D: tG, + dynoUsamplerCube: YG, + dynoUvec2: zs, + dynoUvec3: IG, + dynoUvec4: BG, + dynoVec2: $s, + dynoVec3: cI, + dynoVec4: EG, + equal: f0, + exp: k0, + exp2: F0, + extendVec: Ny, + faceforward: ky, + float: VD, + floatBitsToInt: jD, + floatBitsToUint: vD, + floor: s0, + fract: fg, + greaterThan: p0, + greaterThanEqual: YD, + gsplatNormal: qQ, + gsplatToCovSplat: Zg, + hash: Xi, + hash2: Wi, + hash3: ji, + hash4: vi, + hashFloat: py, + hashVec2: fy, + hashVec3: zi, + hashVec4: bQ, + imod: pQ, + int: V0, + intBitsToFloat: Ey, + inverse: Hy, + inversesqrt: M0, + isAllFloatType: HI, + isBoolType: uI, + isFloatType: Mg, + isInf: Y0, + isIntType: xA, + isMat2: KI, + isMat3: eI, + isMat4: rI, + isMatFloatType: iC, + isNan: L0, + isScalarType: TI, + isUintType: lA, + isVector2Type: gg, + isVector3Type: Qg, + isVector4Type: Jg, + isVectorType: bo, + ivec2: z0, + ivec3: _0, + ivec4: $0, + length: yy, + lessThan: x0, + lessThanEqual: l0, + literalNegOne: Oo, + literalOne: To, + literalZero: Dg, + log: S0, + log2: a0, + mat2: Qy, + mat3: By, + mat4: Cy, + max: jE, + min: J0, + mix: vE, + mod: WE, + modf: i0, + mul: kA, + neg: yB, + normalize: Sg, + normalizedDepth: _i, + not: n0, + notEqual: b0, + numCovSplats: bs, + numExtSplats: fs, + numPackedSplats: ps, + numberAsFloat: AA, + numberAsInt: MA, + numberAsUint: JA, + or: e0, + outer: Jy, + outputCovSplat: QE, + outputCovSplatDepth: EE, + outputExtCovSplat: lQ, + outputExtendedSplat: BE, + outputPackedSplat: wB, + outputRgba8: Os, + outputSplatDepth: CE, + packHalf2x16: zD, + packSnorm2x16: iy, + packUnorm2x16: oy, + pagedSplatTexCoord: xQ, + pcgHash: ly, + pcgMix: qy, + pcgNext: xy, + pow: R0, + projectH: ay, + radians: zy, + readCovSplat: Ps, + readExtSplat: fC, + readPackedSplat: _I, + readPackedSplatRange: pC, + reflectVec: Fy, + refractVec: Sy, + remapIndex: dy, + round: h0, + sameSizeIvec: uo, + sameSizeUvec: sC, + sameSizeVec: Po, + select: hB, + shl: q0, + shr: d0, + sign: o0, + sin: PQ, + sinh: Ch, + smoothstep: H0, + splatTexCoord: EB, + split: $I, + splitCovSplat: Vg, + splitGsplat: uA, + sqr: N0, + sqrt: c0, + step: t0, + sub: iI, + swizzle: cy, + tan: Ah, + tanh: Dh, + texelFetch: jy, + texture: Wy, + textureSize: Xy, + transformDir: sw, + transformGsplat: CB, + transformPos: ow, + transformQuat: Py, + transpose: Uy, + trunc: y0, + typeLiteral: GC, + uint: X0, + uintBitsToFloat: Dy, + uintToRgba8: fQ, + uniform: Vs, + unindent: oA, + unindentLines: z, + unpackHalf2x16: Gy, + unpackSnorm2x16: wy, + unpackUnorm2x16: sy, + uvec2: Ay, + uvec3: Iy, + uvec4: gy, + valType: CA, + vec2: XD, + vec3: fI, + vec4: WD, + vectorDim: oC, + vectorElementType: wC, + xor: r0 +}, Symbol.toStringTag, { value: "Module" })), rA = class rA { + constructor(A = {}) { + this.maxSplats = 0, this.numSplats = 0, this.extra = {}, this.maxSh = 3, this.isInitialized = !1, this.extArrays = [new Uint32Array(0), new Uint32Array(0)], this.textures = [rA.emptyTexture, rA.emptyTexture], this.extra = {}, this.dyno = new sh({ extSplats: this }), this.dynoNumSh = new EI({ + key: "numSh", + value: 0, + update: () => Math.min(this.getNumSh(), this.maxSh) + }), this.initialized = Promise.resolve(this), this.reinitialize(A); + } + reinitialize(A) { + this.isInitialized = !1, this.extra = {}, this.maxSplats = A.maxSplats ?? 0, this.lod = A.lod, this.nonLod = A.nonLod, A.url || A.fileBytes || A.stream || A.construct ? this.initialized = this.asyncInitialize(A).then(() => (this.isInitialized = !0, this)) : (this.initialize(A), this.isInitialized = !0, this.initialized = Promise.resolve(this)); + } + initialize(A) { + this.extra = A.extra ?? {}, this.lodSplats = A.lodSplats, A.extArrays ? (this.extArrays = A.extArrays, this.maxSplats = Math.floor( + Math.min(this.extArrays[0].length / 4, this.extArrays[1].length / 4) + ), this.numSplats = A.numSplats ?? this.maxSplats, this.maxSplats = Math.floor(this.maxSplats / P) * P, this.numSplats = Math.min( + this.maxSplats, + A.numSplats ?? Number.POSITIVE_INFINITY + ), this.updateTextures()) : (this.maxSplats = A.maxSplats ?? 0, this.numSplats = 0, this.extArrays = [new Uint32Array(0), new Uint32Array(0)]); + } + async asyncInitialize(A) { + const { + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + construct: i, + lod: w, + nonLod: s, + lodAbove: o + } = A; + this.lod = w, this.nonLod = s; + const y = new bw(); + if ((g || I || E) && await y.loadInternalAsync({ + extSplats: this, + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + onProgress: A.onProgress, + lodAbove: o + }), i) { + const h = i(this); + h instanceof Promise && await h; + } + } + // Call this when you are finished with the PackedSplats and want to free + // any buffers it holds. + dispose() { + this.textures[0] !== rA.emptyTexture && (this.textures[0].dispose(), this.textures[0].source.data = null, this.textures[0] = rA.emptyTexture), this.textures[1] !== rA.emptyTexture && (this.textures[1].dispose(), this.textures[1].source.data = null, this.textures[1] = rA.emptyTexture), this.extArrays = [new Uint32Array(0), new Uint32Array(0)]; + for (const A in this.extra) { + const I = this.extra[A]; + if (I instanceof x) { + const g = I.value; + g != null && g.isTexture && (g.dispose(), g.source.data = null); + } + } + this.extra = {}, this.disposeLodSplats(); + } + prepareFetchSplat() { + } + getNumSplats() { + return this.numSplats; + } + hasRgbDir() { + return Math.min(this.getNumSh(), this.maxSh) > 0; + } + getNumSh() { + return this.extra.sh1 ? this.extra.sh2 ? !this.extra.sh3a || !this.extra.sh3b ? 2 : 3 : 1 : 0; + } + setMaxSh(A) { + this.maxSh = A; + } + fetchSplat({ + index: A, + viewOrigin: I + }) { + let g = fC(this.dyno, A); + if (this.hasRgbDir() && I) { + const B = uA(g).outputs.center, C = Sg(iI(B, I)), { sh1Texture: E, sh2Texture: D, sh3TextureA: i, sh3TextureB: w } = this.ensureShTextures(); + let { rgb: s } = xw({ + coord: EB(A), + viewDir: C, + numSh: this.dynoNumSh, + sh1Texture: E, + sh2Texture: D, + sh3TextureA: i, + sh3TextureB: w + }); + s = qA(s, uA(g).outputs.rgb), g = CI({ gsplat: g, rgb: s }); + } + return g; + } + ensureShTextures() { + if (!this.extra.sh1) + return {}; + let A = this.extra.sh1Texture; + if (!A) { + let C = this.extra.sh1; + const { width: E, height: D, depth: i, maxSplats: w } = BA( + C.length / 4 + ); + if (C.length < w * 4) { + const o = new Uint32Array(w * 4); + o.set(C), this.extra.sh1 = o, C = o; + } + const s = YI( + C, + E, + D, + i, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ); + A = new dA({ + value: s, + key: "sh1" + }), this.extra.sh1Texture = A; + } + if (!this.extra.sh2) + return { sh1Texture: A }; + let I = this.extra.sh2Texture; + if (!I) { + let C = this.extra.sh2; + const { width: E, height: D, depth: i, maxSplats: w } = BA( + C.length / 4 + ); + if (C.length < w * 4) { + const o = new Uint32Array(w * 4); + o.set(C), this.extra.sh2 = o, C = o; + } + const s = YI( + C, + E, + D, + i, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ); + I = new dA({ + value: s, + key: "sh2" + }), this.extra.sh2Texture = I; + } + if (!this.extra.sh3a || !this.extra.sh3b) + return { sh1Texture: A, sh2Texture: I }; + let g = this.extra.sh3TextureA; + if (!g) { + let C = this.extra.sh3a; + const { width: E, height: D, depth: i, maxSplats: w } = BA( + C.length / 4 + ); + if (C.length < w * 4) { + const o = new Uint32Array(w * 4); + o.set(C), this.extra.sh3a = o, C = o; + } + const s = YI( + C, + E, + D, + i, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ); + g = new dA({ + value: s, + key: "sh3" + }), this.extra.sh3TextureA = g; + } + let B = this.extra.sh3TextureB; + if (!B) { + let C = this.extra.sh3b; + const { width: E, height: D, depth: i, maxSplats: w } = BA( + C.length / 4 + ); + if (C.length < w * 4) { + const o = new Uint32Array(w * 4); + o.set(C), this.extra.sh3b = o, C = o; + } + const s = YI( + C, + E, + D, + i, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ); + B = new dA({ + value: s, + key: "sh3b" + }), this.extra.sh3TextureB = B; + } + return { sh1Texture: A, sh2Texture: I, sh3TextureA: g, sh3TextureB: B }; + } + // Ensures that this.extArrays can fit numSplats Gsplats. If it's too small, + // resize exponentially and copy over the original data. + // + // Typically you don't need to call this, because calling this.setSplat(index, ...) + // and this.pushSplat(...) will automatically call ensureSplats() so we have + // enough splats. + ensureSplats(A) { + const I = A <= this.maxSplats ? this.maxSplats : ( + // Grow exponentially to avoid frequent reallocations + Math.max(A, 2 * this.maxSplats) + ), g = this.extArrays[0] ? this.extArrays[0].length / 4 : 0; + if (!this.extArrays[0] || I > g) { + this.maxSplats = BA(I).maxSplats; + const B = new Uint32Array(this.maxSplats * 4), C = new Uint32Array(this.maxSplats * 4); + this.extArrays[0] && (B.set(this.extArrays[0]), C.set(this.extArrays[1])), this.extArrays[0] = B, this.extArrays[1] = C; + } + return this.extArrays; + } + // Unpack the 16-byte Gsplat data at index into the Three.js components + // center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, + // opacity: number 0..1, color: THREE.Color 0..1. + getSplat(A) { + if (A >= this.numSplats) + throw new Error("Invalid index"); + return eQ(this.extArrays, A); + } + // Set all ExtSplat components at index with the provided Gsplat attributes + // (can be the same objects returned by getSplat). Ensures there is capacity + // for at least index+1 Gsplats. + setSplat(A, I, g, B, C, E) { + const D = this.ensureSplats(A + 1); + KQ( + D, + A, + I.x, + I.y, + I.z, + g.x, + g.y, + g.z, + B.x, + B.y, + B.z, + B.w, + C, + E.r, + E.g, + E.b + ), this.numSplats = Math.max(this.numSplats, A + 1); + } + // Effectively calls this.setSplat(this.numSplats++, center, ...), useful on + // construction where you just want to iterate and create a collection of Gsplats. + pushSplat(A, I, g, B, C) { + const E = this.ensureSplats(this.numSplats + 1); + KQ( + E, + this.numSplats, + A.x, + A.y, + A.z, + I.x, + I.y, + I.z, + g.x, + g.y, + g.z, + g.w, + B, + C.r, + C.g, + C.b + ), ++this.numSplats; + } + // Iterate over Gsplats index 0..=(this.numSplats-1), unpack each Gsplat + // and invoke the callback function with the Gsplat attributes. + forEachSplat(A) { + if (this.numSplats) + for (let I = 0; I < this.numSplats; ++I) { + const g = eQ(this.extArrays, I); + A( + I, + g.center, + g.scales, + g.quaternion, + g.opacity, + g.color + ); + } + } + // Check if source texture needs to be created/updated + updateTextures() { + if (this.textures[0] !== rA.emptyTexture) { + const { width: A, height: I, depth: g } = this.textures[0].image; + this.maxSplats !== A * I * g && (this.textures[0].dispose(), this.textures[0] = rA.emptyTexture, this.textures[1].dispose(), this.textures[1] = rA.emptyTexture); + } + if (this.textures[0] === rA.emptyTexture) { + const { width: A, height: I, depth: g } = BA(this.maxSplats); + this.textures[0] = YI( + this.extArrays[0], + A, + I, + g, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ), this.textures[1] = YI( + this.extArrays[1], + A, + I, + g, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ); + } else this.extArrays[0].buffer !== this.textures[0].image.data.buffer && (this.textures[0].image.data = new Uint8Array(this.extArrays[0].buffer), this.textures[1].image.data = new Uint8Array(this.extArrays[1].buffer), this.textures[0].needsUpdate = !0, this.textures[1].needsUpdate = !0); + } + extractSplats(A, I) { + const g = BA(A.length).maxSplats, B = new rA({ maxSplats: g }); + for (let C = 0; C < A.length; C++) { + const E = this.getSplat(A[C]); + if (I) { + let D = (A[C] >>> 16) * 0.61803398875; + D = D - Math.floor(D); + const i = Math.max(0, Math.min(1, Math.abs(D * 6 - 3) - 1)), w = Math.max(0, Math.min(1, Math.abs(D * 6 + 1) - 1)), s = Math.max(0, Math.min(1, Math.abs(D * 6 - 1) - 1)); + E.color.r *= i, E.color.g *= w, E.color.b *= s; + } + B.pushSplat( + E.center, + E.scales, + E.quaternion, + E.opacity, + E.color + ); + } + return B; + } + disposeLodSplats() { + this.lodSplats && (this.lodSplats.dispose(), this.lodSplats = void 0); + } + async createLodSplats({ + rgbaArray: A, + quality: I + } = {}) { + const g = typeof this.lod == "number" ? Math.max(1.1, Math.min(2, this.lod)) : I ? 1.75 : 1.5, B = [this.extArrays[0].slice(), this.extArrays[1].slice()], C = A ? (await A.getArray()).slice() : void 0, E = { + sh1: this.extra.sh1 ? this.extra.sh1.slice() : void 0, + sh2: this.extra.sh2 ? this.extra.sh2.slice() : void 0, + sh3: this.extra.sh3 ? this.extra.sh3.slice() : void 0 + }, D = await gQ.withWorker(async (w) => await w.call( + I ? "qualityLodExtSplats" : "tinyLodExtSplats", + { + numSplats: this.numSplats, + extArrays: B, + extra: E, + lodBase: g, + rgba: C + } + )), i = new rA(D); + this.lodSplats && this.lodSplats.dispose(), this.lodSplats = i, this.nonLod = !0, this.lod = I ? "quality" : !0; + } +}; +rA.emptyArray = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 4), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGBAIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RGBA32UI", E.needsUpdate = !0, E; +})(), rA.emptyTexture = YI( + null, + 1, + 1, + 1, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" +), rA.emptyUint32x4 = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 4), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGBAIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RGBA32UI", E.needsUpdate = !0, E; +})(); +let GI = rA; +class sh extends x { + constructor({ extSplats: A } = {}) { + super({ + key: "extSplats", + type: BB, + globals: () => [DB], + value: { + textureArray1: GI.emptyTexture, + textureArray2: GI.emptyTexture, + numSplats: 0 + }, + update: (I) => { + var g, B, C; + return I.textureArray1 = ((g = this.extSplats) == null ? void 0 : g.textures[0]) ?? GI.emptyTexture, I.textureArray2 = ((B = this.extSplats) == null ? void 0 : B.textures[1]) ?? GI.emptyTexture, I.numSplats = ((C = this.extSplats) == null ? void 0 : C.numSplats) ?? 0, I; + } + }), this.extSplats = A; + } +} +const Gh = oA(` + vec3 evaluateExtSH1(uvec4 packed, vec3 viewDir) { + vec3 sh1_0 = decodeExtRgb(packed.x); + vec3 sh1_1 = decodeExtRgb(packed.y); + vec3 sh1_2 = decodeExtRgb(packed.z); + + return sh1_0 * (-0.4886025 * viewDir.y) + + sh1_1 * (0.4886025 * viewDir.z) + + sh1_2 * (-0.4886025 * viewDir.x); + } +`), yh = oA(` + vec3 evaluateExtSH12(uvec4 packed1, uvec4 packed2, vec3 viewDir) { + vec3 sh1_0 = decodeExtRgb(packed1.x); + vec3 sh1_1 = decodeExtRgb(packed1.y); + vec3 sh1_2 = decodeExtRgb(packed1.z); + + vec3 sh2_0 = decodeExtRgb(packed1.w); + vec3 sh2_1 = decodeExtRgb(packed2.x); + vec3 sh2_2 = decodeExtRgb(packed2.y); + vec3 sh2_3 = decodeExtRgb(packed2.z); + vec3 sh2_4 = decodeExtRgb(packed2.w); + + vec3 sh1Rgb = sh1_0 * (-0.4886025 * viewDir.y) + + sh1_1 * (0.4886025 * viewDir.z) + + sh1_2 * (-0.4886025 * viewDir.x); + + vec3 sh2Rgb = sh2_0 * (1.0925484 * viewDir.x * viewDir.y) + + sh2_1 * (-1.0925484 * viewDir.y * viewDir.z) + + sh2_2 * (0.3153915 * (2.0 * viewDir.z * viewDir.z - viewDir.x * viewDir.x - viewDir.y * viewDir.y)) + + sh2_3 * (-1.0925484 * viewDir.x * viewDir.z) + + sh2_4 * (0.5462742 * (viewDir.x * viewDir.x - viewDir.y * viewDir.y)); + + return sh1Rgb + sh2Rgb; + } +`), hh = oA(` + vec3 evaluateExtSH3(uvec4 packedA, uvec4 packedB, vec3 viewDir) { + vec3 sh3_0 = decodeExtRgb(packedA.x); + vec3 sh3_1 = decodeExtRgb(packedA.y); + vec3 sh3_2 = decodeExtRgb(packedA.z); + vec3 sh3_3 = decodeExtRgb(packedA.w); + vec3 sh3_4 = decodeExtRgb(packedB.x); + vec3 sh3_5 = decodeExtRgb(packedB.y); + vec3 sh3_6 = decodeExtRgb(packedB.z); + + float xx = viewDir.x * viewDir.x; + float yy = viewDir.y * viewDir.y; + float zz = viewDir.z * viewDir.z; + float xy = viewDir.x * viewDir.y; + float yz = viewDir.y * viewDir.z; + float zx = viewDir.z * viewDir.x; + + return sh3_0 * (-0.5900436 * viewDir.y * (3.0 * xx - yy)) + + sh3_1 * (2.8906114 * xy * viewDir.z) + + + sh3_2 * (-0.4570458 * viewDir.y * (4.0 * zz - xx - yy)) + + sh3_3 * (0.3731763 * viewDir.z * (2.0 * zz - 3.0 * xx - 3.0 * yy)) + + sh3_4 * (-0.4570458 * viewDir.x * (4.0 * zz - xx - yy)) + + sh3_5 * (1.4453057 * viewDir.z * (xx - yy)) + + sh3_6 * (-0.5900436 * viewDir.x * (xx - 3.0 * yy)); + } +`); +function xw({ + coord: Q, + viewDir: A, + numSh: I, + sh1Texture: g, + sh2Texture: B, + sh3TextureA: C, + sh3TextureB: E +}) { + return new d({ + inTypes: { + coord: "ivec3", + viewDir: "vec3", + numSh: "int", + sh1Texture: "usampler2DArray", + sh2Texture: "usampler2DArray", + sh3TextureA: "usampler2DArray", + sh3TextureB: "usampler2DArray" + }, + outTypes: { rgb: "vec3" }, + inputs: { + coord: Q, + viewDir: A, + numSh: I, + sh1Texture: g, + sh2Texture: B, + sh3TextureA: C, + sh3TextureB: E + }, + globals: () => [ + Gh, + yh, + hh + ], + statements: ({ inputs: D, outputs: i }) => { + const w = ["vec3 rgb = vec3(0.0);"]; + return D.sh1Texture && (D.sh2Texture ? (w.push( + ...z(` + if (${D.numSh} == 1) { + rgb = evaluateExtSH1(texelFetch(${D.sh1Texture}, ${D.coord}, 0), ${D.viewDir}); + } else if (${D.numSh} >= 2) { + rgb = evaluateExtSH12(texelFetch(${D.sh1Texture}, ${D.coord}, 0), texelFetch(${D.sh2Texture}, ${D.coord}, 0), ${D.viewDir}); + `) + ), D.sh3TextureA && D.sh3TextureB && w.push( + ...z(` + if (${D.numSh} >= 3) { + rgb += evaluateExtSH3(texelFetch(${D.sh3TextureA}, ${D.coord}, 0), texelFetch(${D.sh3TextureB}, ${D.coord}, 0), ${D.viewDir}); + } + `) + ), w.push("}")) : w.push( + ...z(` + if (${D.numSh} >= 1) { + rgb = evaluateExtSH1(texelFetch(${D.sh1Texture}, ${D.coord}, 0), ${D.viewDir}); + } + `) + )), w.push(`${i.rgb} = rgb;`), w; + } + }).outputs; +} +function YI(Q, A, I, g, B, C, E) { + const D = new G.DataArrayTexture( + Q, + A, + I, + g + ); + return D.format = B, D.type = C, D.internalFormat = E, D.needsUpdate = !0, D; +} +function nB(Q) { + const A = RA.decode_rad_header(Q); + if (A[2]) + throw lB(A[1]); + return lB(A[0]); +} +function Rh() { + return RA.get_raycast_buffer(); +} +function kh() { + return RA.get_raycast_buffer2(); +} +function Fh(Q, A, I, g, B, C, E, D, i, w) { + return RA.raycast_ext_buffers(Q, A, I, g, B, C, E, D, i, w); +} +function Sh(Q, A, I, g, B, C, E, D, i, w, s, o, y) { + return RA.raycast_packed_buffer(Q, A, I, g, B, C, E, D, i, w, s, o, y); +} +function ah() { + return { + __proto__: null, + "./spark_rs_bg.js": { + __proto__: null, + __wbg_Error_2e59b1b37a9a34c3: function(A, I) { + return Error(Yg(A, I)); + }, + __wbg___wbindgen_throw_81fc77679af83bc6: function(A, I) { + throw new Error(Yg(A, I)); + }, + __wbg_error_a6fa202b58aa1cd3: function(A, I) { + let g, B; + try { + g = A, B = I, console.error(Yg(A, I)); + } finally { + RA.__wbindgen_free(g, B, 1); + } + }, + __wbg_length_0c32cb8543c8e4c8: function(A) { + return A.length; + }, + __wbg_length_1e701798fdcaa3b4: function(A) { + return A.length; + }, + __wbg_length_fd4646b401926788: function(A) { + return A.length; + }, + __wbg_new_227d7c05414eb861: function() { + return new Error(); + }, + __wbg_new_4f9fafbb3909af72: function() { + return new Object(); + }, + __wbg_new_f3c9df4f38f3f798: function() { + return new Array(); + }, + __wbg_new_with_length_26bffbe236bf73f9: function(A) { + return new Float32Array(A >>> 0); + }, + __wbg_prototypesetcall_3e05eb9545565046: function(A, I, g) { + Uint8Array.prototype.set.call(ch(A, I), g); + }, + __wbg_prototypesetcall_e42275e601e14eeb: function(A, I, g) { + Uint32Array.prototype.set.call(qB(A, I), g); + }, + __wbg_set_6be42768c690e380: function(A, I, g) { + A[I] = g; + }, + __wbg_set_6c60b2e8ad0e9383: function(A, I, g) { + A[I >>> 0] = g; + }, + __wbg_set_8ee2d34facb8466e: function() { + return Uh(function(A, I, g) { + return Reflect.set(A, I, g); + }, arguments); + }, + __wbg_set_a98c8da6557e63de: function(A, I, g) { + A.set(dB(I, g)); + }, + __wbg_stack_3b0d974bbf31e44f: function(A, I) { + const g = I.stack, B = th(g, RA.__wbindgen_malloc, RA.__wbindgen_realloc), C = uQ; + xB().setInt32(A + 4, C, !0), xB().setInt32(A + 0, B, !0); + }, + __wbg_subarray_d51e89458b3fdbf6: function(A, I, g) { + return A.subarray(I >>> 0, g >>> 0); + }, + __wbindgen_cast_0000000000000001: function(A) { + return A; + }, + __wbindgen_cast_0000000000000002: function(A, I) { + return dB(A, I); + }, + __wbindgen_cast_0000000000000003: function(A, I) { + return qB(A, I); + }, + __wbindgen_cast_0000000000000004: function(A, I) { + return Yg(A, I); + }, + __wbindgen_cast_0000000000000005: function(A) { + return BigInt.asUintN(64, A); + }, + __wbindgen_init_externref_table: function() { + const A = RA.__wbindgen_externrefs, I = A.grow(4); + A.set(0, void 0), A.set(I + 0, void 0), A.set(I + 1, null), A.set(I + 2, !0), A.set(I + 3, !1); + } + } + }; +} +function Nh(Q) { + const A = RA.__externref_table_alloc(); + return RA.__wbindgen_externrefs.set(A, Q), A; +} +function dB(Q, A) { + return Q = Q >>> 0, Mh().subarray(Q / 4, Q / 4 + A); +} +function qB(Q, A) { + return Q = Q >>> 0, Jh().subarray(Q / 4, Q / 4 + A); +} +function ch(Q, A) { + return Q = Q >>> 0, yg().subarray(Q / 1, Q / 1 + A); +} +let dI = null; +function xB() { + return (dI === null || dI.buffer.detached === !0 || dI.buffer.detached === void 0 && dI.buffer !== RA.memory.buffer) && (dI = new DataView(RA.memory.buffer)), dI; +} +let ig = null; +function Mh() { + return (ig === null || ig.byteLength === 0) && (ig = new Float32Array(RA.memory.buffer)), ig; +} +function Yg(Q, A) { + return Q = Q >>> 0, Lh(Q, A); +} +let wg = null; +function Jh() { + return (wg === null || wg.byteLength === 0) && (wg = new Uint32Array(RA.memory.buffer)), wg; +} +let og = null; +function yg() { + return (og === null || og.byteLength === 0) && (og = new Uint8Array(RA.memory.buffer)), og; +} +function Uh(Q, A) { + try { + return Q.apply(this, A); + } catch (I) { + const g = Nh(I); + RA.__wbindgen_exn_store(g); + } +} +function th(Q, A, I) { + if (I === void 0) { + const D = hg.encode(Q), i = A(D.length, 1) >>> 0; + return yg().subarray(i, i + D.length).set(D), uQ = D.length, i; + } + let g = Q.length, B = A(g, 1) >>> 0; + const C = yg(); + let E = 0; + for (; E < g; E++) { + const D = Q.charCodeAt(E); + if (D > 127) break; + C[B + E] = D; + } + if (E !== g) { + E !== 0 && (Q = Q.slice(E)), B = I(B, g, g = E + Q.length * 3, 1) >>> 0; + const D = yg().subarray(B + E, B + g), i = hg.encodeInto(Q, D); + E += i.written, B = I(B, g, E, 1) >>> 0; + } + return uQ = E, B; +} +function lB(Q) { + const A = RA.__wbindgen_externrefs.get(Q); + return RA.__externref_table_dealloc(Q), A; +} +let bg = new TextDecoder("utf-8", { ignoreBOM: !0, fatal: !0 }); +bg.decode(); +const Hh = 2146435072; +let aQ = 0; +function Lh(Q, A) { + return aQ += A, aQ >= Hh && (bg = new TextDecoder("utf-8", { ignoreBOM: !0, fatal: !0 }), bg.decode(), aQ = A), bg.decode(yg().subarray(Q, Q + A)); +} +const hg = new TextEncoder(); +"encodeInto" in hg || (hg.encodeInto = function(Q, A) { + const I = hg.encode(Q); + return A.set(I), { + read: Q.length, + written: I.length + }; +}); +let uQ = 0, RA; +function Yh(Q, A) { + return RA = Q.exports, dI = null, ig = null, wg = null, og = null, RA.__wbindgen_start(), RA; +} +async function Kh(Q, A) { + if (typeof Response == "function" && Q instanceof Response) { + if (typeof WebAssembly.instantiateStreaming == "function") + try { + return await WebAssembly.instantiateStreaming(Q, A); + } catch (B) { + if (Q.ok && I(Q.type) && Q.headers.get("Content-Type") !== "application/wasm") + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", B); + else + throw B; + } + const g = await Q.arrayBuffer(); + return await WebAssembly.instantiate(g, A); + } else { + const g = await WebAssembly.instantiate(Q, A); + return g instanceof WebAssembly.Instance ? { instance: g, module: Q } : g; + } + function I(g) { + switch (g) { + case "basic": + case "cors": + case "default": + return !0; + } + return !1; + } +} +async function lw(Q) { + if (RA !== void 0) return RA; + Q !== void 0 && (Object.getPrototypeOf(Q) === Object.prototype ? { module_or_path: Q } = Q : console.warn("using deprecated parameters for the initialization function; pass a single object instead")), Q === void 0 && (Q = new URL("data:application/wasm;base64,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")); + const A = ah(); + (typeof Q == "string" || typeof Request == "function" && Q instanceof Request || typeof URL == "function" && Q instanceof URL) && (Q = fetch(Q)); + const { instance: I, module: g } = await Kh(await Q, A); + return Yh(I); +} +var eh = `precision highp float; +precision highp int; +precision highp sampler2D; +precision highp usampler2D; +precision highp isampler2D; +precision highp sampler2DArray; +precision highp usampler2DArray; +precision highp isampler2DArray; +precision highp sampler3D; +precision highp usampler3D; +precision highp isampler3D; + +#include + +uniform uint targetLayer; +uniform int targetBase; +uniform int targetCount; + +out uvec4 target; + +{{ GLOBALS }} + +void produceSplat(int _index) { + {{ STATEMENTS }} +} + +void main() { + int targetIndex = int(targetLayer << SPLAT_TEX_LAYER_BITS) + int(uint(gl_FragCoord.y) << SPLAT_TEX_WIDTH_BITS) + int(gl_FragCoord.x); + int index = targetIndex - targetBase; + + target = uvec4(0u, 0u, 0u, 0u); + if ((index >= 0) && (index < targetCount)) { + produceSplat(index); + } +}`, rh = `precision highp float; +precision highp int; +precision highp sampler2D; +precision highp usampler2D; +precision highp isampler2D; +precision highp sampler2DArray; +precision highp usampler2DArray; +precision highp isampler2DArray; +precision highp sampler3D; +precision highp usampler3D; +precision highp isampler3D; + +#include + +uniform uint targetLayer; +uniform int targetBase; +uniform int targetCount; + +layout(location = 0) out uvec4 target; +layout(location = 1) out vec4 target3; + +{{ GLOBALS }} + +void produceSplat(int _index) { + {{ STATEMENTS }} +} + +void main() { + int targetIndex = int(targetLayer << SPLAT_TEX_LAYER_BITS) + int(uint(gl_FragCoord.y) << SPLAT_TEX_WIDTH_BITS) + int(gl_FragCoord.x); + int index = targetIndex - targetBase; + + + target = uvec4(0u, 0u, 0u, 0u); + + + target3 = floatToVec4(1.0 / 0.0); + + if ((index >= 0) && (index < targetCount)) { + produceSplat(index); + } +}`, nh = `precision highp float; +precision highp int; +precision highp sampler2D; +precision highp usampler2D; +precision highp isampler2D; +precision highp sampler2DArray; +precision highp usampler2DArray; +precision highp isampler2DArray; +precision highp sampler3D; +precision highp usampler3D; +precision highp isampler3D; + +#include + +uniform uint targetLayer; +uniform int targetBase; +uniform int targetCount; + +layout(location = 0) out uvec4 target; +layout(location = 1) out uvec4 target2; +layout(location = 2) out vec4 target3; + +{{ GLOBALS }} + +void produceSplat(int _index) { + {{ STATEMENTS }} +} + +void main() { + int targetIndex = int(targetLayer << SPLAT_TEX_LAYER_BITS) + int(uint(gl_FragCoord.y) << SPLAT_TEX_WIDTH_BITS) + int(gl_FragCoord.x); + int index = targetIndex - targetBase; + + + target = uvec4(0u, 0u, 0u, 0u); + target2 = uvec4(0u, 0u, 0u, 0u); + + + target3 = floatToVec4(1.0 / 0.0); + + if ((index >= 0) && (index < targetCount)) { + produceSplat(index); + } +}`, dh = `precision highp float; +precision highp int; +precision highp sampler2D; +precision highp usampler2D; +precision highp isampler2D; +precision highp sampler2DArray; +precision highp usampler2DArray; +precision highp isampler2DArray; +precision highp sampler3D; +precision highp usampler3D; +precision highp isampler3D; + +#include + +uniform uint targetLayer; +uniform int targetBase; +uniform int targetCount; + +out vec4 target; + +{{ GLOBALS }} + +void computeReadback(int _index) { + {{ STATEMENTS }} +} + +void main() { + int targetIndex = int(targetLayer << SPLAT_TEX_LAYER_BITS) + int(uint(gl_FragCoord.y) << SPLAT_TEX_WIDTH_BITS) + int(gl_FragCoord.x); + int index = targetIndex - targetBase; + + if ((index >= 0) && (index < targetCount)) { + computeReadback(index); + } else { + target = vec4(0.0, 0.0, 0.0, 0.0); + } +}`, qh = `precision highp float; +precision highp int; + +#include + +uniform float near; +uniform float far; +uniform bool encodeLinear; +uniform float time; +uniform bool debugFlag; +uniform float maxStdDev; +uniform float minAlpha; +uniform bool stochastic; +uniform bool disableFalloff; +uniform float falloff; + +uniform bool splatTexEnable; +uniform sampler3D splatTexture; +uniform mat2 splatTexMul; +uniform vec2 splatTexAdd; +uniform float splatTexNear; +uniform float splatTexFar; +uniform float splatTexMid; + +out vec4 fragColor; + +in vec4 vRgba; +in vec2 vSplatUv; +in vec3 vNdc; +flat in uint vSplatIndex; + +void main() { + vec4 rgba = vRgba; + + float z = dot(vSplatUv, vSplatUv); + if (!splatTexEnable) { + if (z > (maxStdDev * maxStdDev)) { + discard; + } + } else { + vec2 uv = splatTexMul * vSplatUv + splatTexAdd; + float ndcZ = vNdc.z; + float depth = (2.0 * near * far) / (far + near - ndcZ * (far - near)); + float clampedFar = max(splatTexFar, splatTexNear); + float clampedDepth = clamp(depth, splatTexNear, clampedFar); + float logDepth = log2(clampedDepth + 1.0); + float logNear = log2(splatTexNear + 1.0); + float logFar = log2(clampedFar + 1.0); + + float texZ; + if (splatTexMid > 0.0) { + float clampedMid = clamp(splatTexMid, splatTexNear, clampedFar); + float logMid = log2(clampedMid + 1.0); + texZ = (clampedDepth <= clampedMid) ? + (0.5 * ((logDepth - logNear) / (logMid - logNear))) : + (0.5 * ((logDepth - logMid) / (logFar - logMid)) + 0.5); + } else { + texZ = (logDepth - logNear) / (logFar - logNear); + } + + vec4 modulate = texture(splatTexture, vec3(uv, 1.0 - texZ)); + rgba *= modulate; + } + + rgba.a *= mix(1.0, exp(-0.5 * z), falloff); + + if (rgba.a < minAlpha) { + discard; + } + if (encodeLinear) { + rgba.rgb = srgbToLinear(rgba.rgb); + } + + if (stochastic) { + const bool STEADY = false; + uint uTime = STEADY ? 0u : floatBitsToUint(time); + uvec2 coord = uvec2(gl_FragCoord.xy); + uint state = uTime + 0x9e3779b9u * coord.x + 0x85ebca6bu * coord.y + 0xc2b2ae35u * uint(vSplatIndex); + state = state * 747796405u + 2891336453u; + uint hash = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u; + hash = (hash >> 22u) ^ hash; + float rand = float(hash) / 4294967296.0; + if (rand < rgba.a) { + fragColor = vec4(rgba.rgb, 1.0); + } else { + discard; + } + } else { + #ifdef PREMULTIPLIED_ALPHA + fragColor = vec4(rgba.rgb * rgba.a, rgba.a); + #else + fragColor = rgba; + #endif + } +}`, xh = `precision highp float; +precision highp int; +precision highp usampler2DArray; + +#include + +attribute uint splatIndex; + +out vec4 vRgba; +out vec2 vSplatUv; +out vec3 vNdc; +flat out uint vSplatIndex; + +uniform vec2 renderSize; +uniform uint numSplats; +uniform vec4 renderToViewQuat; +uniform vec3 renderToViewPos; +uniform float maxStdDev; +uniform float minPixelRadius; +uniform float maxPixelRadius; +uniform float time; +uniform float deltaTime; +uniform bool debugFlag; +uniform float minAlpha; +uniform bool stochastic; +uniform bool enable2DGS; +uniform float blurAmount; +uniform float preBlurAmount; +uniform float focalDistance; +uniform float apertureAngle; +uniform float clipXY; +uniform float focalAdjustment; + +uniform usampler2DArray packedSplats; +uniform vec4 rgbMinMaxLnScaleMinMax; + +void main() { + + gl_Position = vec4(0.0, 0.0, 2.0, 1.0); + + if (uint(gl_InstanceID) >= numSplats) { + return; + } + + ivec3 texCoord; + if (stochastic) { + texCoord = ivec3( + uint(gl_InstanceID) & SPLAT_TEX_WIDTH_MASK, + (uint(gl_InstanceID) >> SPLAT_TEX_WIDTH_BITS) & SPLAT_TEX_HEIGHT_MASK, + (uint(gl_InstanceID) >> SPLAT_TEX_LAYER_BITS) + ); + } else { + if (splatIndex == 0xffffffffu) { + + return; + } + texCoord = ivec3( + splatIndex & SPLAT_TEX_WIDTH_MASK, + (splatIndex >> SPLAT_TEX_WIDTH_BITS) & SPLAT_TEX_HEIGHT_MASK, + splatIndex >> SPLAT_TEX_LAYER_BITS + ); + } + uvec4 packed = texelFetch(packedSplats, texCoord, 0); + + vec3 center, scales; + vec4 quaternion, rgba; + unpackSplatEncoding(packed, center, scales, quaternion, rgba, rgbMinMaxLnScaleMinMax); + + if (rgba.a < minAlpha) { + return; + } + bvec3 zeroScales = equal(scales, vec3(0.0)); + if (all(zeroScales)) { + return; + } + + + vec3 viewCenter = quatVec(renderToViewQuat, center) + renderToViewPos; + + + if (viewCenter.z >= 0.0) { + return; + } + + + vec4 clipCenter = projectionMatrix * vec4(viewCenter, 1.0); + + + if (abs(clipCenter.z) >= clipCenter.w) { + return; + } + + + float clip = clipXY * clipCenter.w; + if (abs(clipCenter.x) > clip || abs(clipCenter.y) > clip) { + return; + } + + + vSplatIndex = splatIndex; + + + vec4 viewQuaternion = quatQuat(renderToViewQuat, quaternion); + + if (enable2DGS && any(zeroScales)) { + vRgba = rgba; + vSplatUv = position.xy * maxStdDev; + + vec3 offset; + if (zeroScales.z) { + offset = vec3(vSplatUv.xy * scales.xy, 0.0); + } else if (zeroScales.y) { + offset = vec3(vSplatUv.x * scales.x, 0.0, vSplatUv.y * scales.z); + } else { + offset = vec3(0.0, vSplatUv.xy * scales.yz); + } + + vec3 viewPos = viewCenter + quatVec(viewQuaternion, offset); + gl_Position = projectionMatrix * vec4(viewPos, 1.0); + vNdc = gl_Position.xyz / gl_Position.w; + return; + } + + + vec3 ndcCenter = clipCenter.xyz / clipCenter.w; + + + mat3 RS = scaleQuaternionToMatrix(scales, viewQuaternion); + mat3 cov3D = RS * transpose(RS); + + + vec2 scaledRenderSize = renderSize * focalAdjustment; + vec2 focal = 0.5 * scaledRenderSize * vec2(projectionMatrix[0][0], projectionMatrix[1][1]); + + mat3 J; + if(isOrthographic) { + J = mat3( + focal.x, 0.0, 0.0, + 0.0, focal.y, 0.0, + 0.0, 0.0, 0.0 + ); + } else { + float invZ = 1.0 / viewCenter.z; + vec2 J1 = focal * invZ; + vec2 J2 = -(J1 * viewCenter.xy) * invZ; + J = mat3( + J1.x, 0.0, J2.x, + 0.0, J1.y, J2.y, + 0.0, 0.0, 0.0 + ); + } + + + + + + + + + mat3 cov2D = transpose(J) * cov3D * J; + float a = cov2D[0][0]; + float d = cov2D[1][1]; + float b = cov2D[0][1]; + + + a += preBlurAmount; + d += preBlurAmount; + + float fullBlurAmount = blurAmount; + if ((focalDistance > 0.0) && (apertureAngle > 0.0)) { + float focusRadius = maxPixelRadius; + if (viewCenter.z < 0.0) { + float focusBlur = abs((-viewCenter.z - focalDistance) / viewCenter.z); + float apertureRadius = focal.x * tan(0.5 * apertureAngle); + focusRadius = focusBlur * apertureRadius; + } + fullBlurAmount = clamp(sqr(focusRadius), blurAmount, sqr(maxPixelRadius)); + } + + + float detOrig = a * d - b * b; + a += fullBlurAmount; + d += fullBlurAmount; + float det = a * d - b * b; + + + float blurAdjust = sqrt(max(0.0, detOrig / det)); + rgba.a *= blurAdjust; + if (rgba.a < minAlpha) { + return; + } + + + float eigenAvg = 0.5 * (a + d); + float eigenDelta = sqrt(max(0.0, eigenAvg * eigenAvg - det)); + float eigen1 = eigenAvg + eigenDelta; + float eigen2 = eigenAvg - eigenDelta; + + vec2 eigenVec1 = normalize(vec2((abs(b) < 0.001) ? 1.0 : b, eigen1 - a)); + vec2 eigenVec2 = vec2(eigenVec1.y, -eigenVec1.x); + + float scale1 = min(maxPixelRadius, maxStdDev * sqrt(eigen1)); + float scale2 = min(maxPixelRadius, maxStdDev * sqrt(eigen2)); + if (scale1 < minPixelRadius && scale2 < minPixelRadius) { + return; + } + + + vec2 pixelOffset = position.x * eigenVec1 * scale1 + position.y * eigenVec2 * scale2; + vec2 ndcOffset = (2.0 / scaledRenderSize) * pixelOffset; + vec3 ndc = vec3(ndcCenter.xy + ndcOffset, ndcCenter.z); + + vRgba = rgba; + vSplatUv = position.xy * maxStdDev; + vNdc = ndc; + gl_Position = vec4(ndc.xy * clipCenter.w, clipCenter.zw); +}`, lh = `const float LN_SCALE_MIN = -12.0; +const float LN_SCALE_MAX = 9.0; + +const uint SPLAT_TEX_WIDTH_BITS = 11u; +const uint SPLAT_TEX_HEIGHT_BITS = 11u; +const uint SPLAT_TEX_DEPTH_BITS = 11u; +const uint SPLAT_TEX_LAYER_BITS = SPLAT_TEX_WIDTH_BITS + SPLAT_TEX_HEIGHT_BITS; + +const uint SPLAT_TEX_WIDTH = 1u << SPLAT_TEX_WIDTH_BITS; +const uint SPLAT_TEX_HEIGHT = 1u << SPLAT_TEX_HEIGHT_BITS; +const uint SPLAT_TEX_DEPTH = 1u << SPLAT_TEX_DEPTH_BITS; + +const uint SPLAT_TEX_WIDTH_MASK = SPLAT_TEX_WIDTH - 1u; +const uint SPLAT_TEX_HEIGHT_MASK = SPLAT_TEX_HEIGHT - 1u; +const uint SPLAT_TEX_DEPTH_MASK = SPLAT_TEX_DEPTH - 1u; + +const uint F16_INF = 0x7c00u; +const float PI = 3.1415926535897932384626433832795; + +const float INFINITY = 1.0 / 0.0; +const float NEG_INFINITY = -INFINITY; + +float sqr(float x) { + return x * x; +} + +float pow4(float x) { + float x2 = x * x; + return x2 * x2; +} + +float pow8(float x) { + float x4 = pow4(x); + return x4 * x4; +} + +vec3 srgbToLinear(vec3 rgb) { + return pow(rgb, vec3(2.2)); +} + +vec3 linearToSrgb(vec3 rgb) { + return pow(rgb, vec3(1.0 / 2.2)); +} + +uint encodeQuatOctXy88R8(vec4 q) { + + if (q.w < 0.0) { + q = -q; + } + + float theta = 2.0 * acos(q.w); + float halfTheta = theta * 0.5; + float s = sin(halfTheta); + + vec3 axis = (abs(s) < 1e-6) ? vec3(1.0, 0.0, 0.0) : q.xyz / s; + + + + float sum = abs(axis.x) + abs(axis.y) + abs(axis.z); + vec2 p = vec2(axis.x, axis.y) / sum; + + if (axis.z < 0.0) { + float oldPx = p.x; + p.x = (1.0 - abs(p.y)) * (p.x >= 0.0 ? 1.0 : -1.0); + p.y = (1.0 - abs(oldPx)) * (p.y >= 0.0 ? 1.0 : -1.0); + } + + float u_f = p.x * 0.5 + 0.5; + float v_f = p.y * 0.5 + 0.5; + + uint quantU = uint(clamp(round(u_f * 255.0), 0.0, 255.0)); + uint quantV = uint(clamp(round(v_f * 255.0), 0.0, 255.0)); + + + + uint angleInt = uint(clamp(round((theta / 3.14159265359) * 255.0), 0.0, 255.0)); + + + return (angleInt << 16u) | (quantV << 8u) | quantU; +} + +vec4 decodeQuatOctXy88R8(uint encoded) { + + uint quantU = encoded & uint(0xFFu); + uint quantV = (encoded >> 8u) & uint(0xFFu); + uint angleInt = encoded >> 16u; + + + float u_f = float(quantU) / 255.0; + float v_f = float(quantV) / 255.0; + vec2 f = vec2(u_f * 2.0 - 1.0, v_f * 2.0 - 1.0); + + vec3 axis = vec3(f.xy, 1.0 - abs(f.x) - abs(f.y)); + float t = max(-axis.z, 0.0); + axis.x += (axis.x >= 0.0) ? -t : t; + axis.y += (axis.y >= 0.0) ? -t : t; + axis = normalize(axis); + + + float theta = (float(angleInt) / 255.0) * 3.14159265359; + float halfTheta = theta * 0.5; + float s = sin(halfTheta); + float w = cos(halfTheta); + + return vec4(axis * s, w); +} + +uint encodeQuatOctXy1010R12(vec4 q) { + + if (q.w < 0.0) { + q = -q; + } + + float halfTheta = acos(q.w); + float theta = 2.0 * halfTheta; + float s = sin(halfTheta); + + vec3 axis = (abs(s) < 1e-6) ? vec3(1.0, 0.0, 0.0) : q.xyz / s; + + + + float sum = abs(axis.x) + abs(axis.y) + abs(axis.z); + vec2 p = vec2(axis.x, axis.y) / sum; + + if (axis.z < 0.0) { + float oldPx = p.x; + p.x = (1.0 - abs(p.y)) * (p.x >= 0.0 ? 1.0 : -1.0); + p.y = (1.0 - abs(oldPx)) * (p.y >= 0.0 ? 1.0 : -1.0); + } + + float u_f = p.x * 0.5 + 0.5; + float v_f = p.y * 0.5 + 0.5; + + uint quantU = uint(clamp(round(u_f * 1023.0), 0.0, 1023.0)); + uint quantV = uint(clamp(round(v_f * 1023.0), 0.0, 1023.0)); + + + + uint angleInt = uint(clamp(round((theta / PI) * 4095.0), 0.0, 4095.0)); + + + return (angleInt << 20u) | (quantV << 10u) | quantU; +} + +vec4 decodeQuatOctXy1010R12(uint encoded) { + + uint quantU = encoded & uint(0x3FFu); + uint quantV = (encoded >> 10u) & uint(0x3FFu); + uint angleInt = encoded >> 20u; + + + float u_f = float(quantU) / 1023.0; + float v_f = float(quantV) / 1023.0; + vec2 f = vec2(u_f * 2.0 - 1.0, v_f * 2.0 - 1.0); + + vec3 axis = vec3(f.xy, 1.0 - abs(f.x) - abs(f.y)); + float t = max(-axis.z, 0.0); + axis.x += (axis.x >= 0.0) ? -t : t; + axis.y += (axis.y >= 0.0) ? -t : t; + axis = normalize(axis); + + + float theta = (float(angleInt) / 4095.0) * PI; + float halfTheta = theta * 0.5; + float s = sin(halfTheta); + float w = cos(halfTheta); + + return vec4(axis * s, w); +} + +uvec4 packSplatEncoding( + vec3 center, vec3 scales, vec4 quaternion, vec4 rgba, vec4 rgbMinMaxLnScaleMinMax +) { + float rgbMin = rgbMinMaxLnScaleMinMax.x; + float rgbMax = rgbMinMaxLnScaleMinMax.y; + vec3 encRgb = (rgba.rgb - vec3(rgbMin)) / (rgbMax - rgbMin); + uvec4 uRgba = uvec4(round(clamp(vec4(encRgb, rgba.a) * 255.0, 0.0, 255.0))); + + uint uQuat = encodeQuatOctXy88R8(quaternion); + + + uvec3 uQuat3 = uvec3(uQuat & 0xffu, (uQuat >> 8u) & 0xffu, (uQuat >> 16u) & 0xffu); + + + float lnScaleMin = rgbMinMaxLnScaleMinMax.z; + float lnScaleMax = rgbMinMaxLnScaleMinMax.w; + float lnScaleScale = 254.0 / (lnScaleMax - lnScaleMin); + uvec3 uScales = uvec3( + (scales.x == 0.0) ? 0u : uint(round(clamp((log(scales.x) - lnScaleMin) * lnScaleScale, 0.0, 254.0))) + 1u, + (scales.y == 0.0) ? 0u : uint(round(clamp((log(scales.y) - lnScaleMin) * lnScaleScale, 0.0, 254.0))) + 1u, + (scales.z == 0.0) ? 0u : uint(round(clamp((log(scales.z) - lnScaleMin) * lnScaleScale, 0.0, 254.0))) + 1u + ); + + + uint word0 = uRgba.r | (uRgba.g << 8u) | (uRgba.b << 16u) | (uRgba.a << 24u); + uint word1 = packHalf2x16(center.xy); + uint word2 = packHalf2x16(vec2(center.z, 0.0)) | (uQuat3.x << 16u) | (uQuat3.y << 24u); + uint word3 = uScales.x | (uScales.y << 8u) | (uScales.z << 16u) | (uQuat3.z << 24u); + return uvec4(word0, word1, word2, word3); +} + +uvec4 packSplat(vec3 center, vec3 scales, vec4 quaternion, vec4 rgba) { + return packSplatEncoding(center, scales, quaternion, rgba, vec4(0.0, 1.0, LN_SCALE_MIN, LN_SCALE_MAX)); +} + +void unpackSplatEncoding(uvec4 packed, out vec3 center, out vec3 scales, out vec4 quaternion, out vec4 rgba, vec4 rgbMinMaxLnScaleMinMax) { + uint word0 = packed.x, word1 = packed.y, word2 = packed.z, word3 = packed.w; + + uvec4 uRgba = uvec4(word0 & 0xffu, (word0 >> 8u) & 0xffu, (word0 >> 16u) & 0xffu, (word0 >> 24u) & 0xffu); + float rgbMin = rgbMinMaxLnScaleMinMax.x; + float rgbMax = rgbMinMaxLnScaleMinMax.y; + rgba = (vec4(uRgba) / 255.0); + rgba.rgb = rgba.rgb * (rgbMax - rgbMin) + rgbMin; + + center = vec4( + unpackHalf2x16(word1), + unpackHalf2x16(word2 & 0xffffu) + ).xyz; + + uvec3 uScales = uvec3(word3 & 0xffu, (word3 >> 8u) & 0xffu, (word3 >> 16u) & 0xffu); + float lnScaleMin = rgbMinMaxLnScaleMinMax.z; + float lnScaleMax = rgbMinMaxLnScaleMinMax.w; + float lnScaleScale = (lnScaleMax - lnScaleMin) / 254.0; + scales = vec3( + (uScales.x == 0u) ? 0.0 : exp(lnScaleMin + float(uScales.x - 1u) * lnScaleScale), + (uScales.y == 0u) ? 0.0 : exp(lnScaleMin + float(uScales.y - 1u) * lnScaleScale), + (uScales.z == 0u) ? 0.0 : exp(lnScaleMin + float(uScales.z - 1u) * lnScaleScale) + ); + + uint uQuat = ((word2 >> 16u) & 0xFFFFu) | ((word3 >> 8u) & 0xFF0000u); + quaternion = decodeQuatOctXy88R8(uQuat); + + +} + +void unpackSplat(uvec4 packed, out vec3 center, out vec3 scales, out vec4 quaternion, out vec4 rgba) { + unpackSplatEncoding(packed, center, scales, quaternion, rgba, vec4(0.0, 1.0, LN_SCALE_MIN, LN_SCALE_MAX)); +} + +uvec4 packSplatCovEncoding( + vec3 center, vec4 rgba, vec3 xxyyzz, vec3 xyxzyz, vec4 rgbMinMaxLnScaleMinMax +) { + float rgbMin = rgbMinMaxLnScaleMinMax.x; + float rgbMax = rgbMinMaxLnScaleMinMax.y; + vec3 encRgb = (rgba.rgb - vec3(rgbMin)) / (rgbMax - rgbMin); + uvec4 uRgba = uvec4(round(clamp(vec4(encRgb, rgba.a) * 255.0, 0.0, 255.0))); + + float lnScaleMin = rgbMinMaxLnScaleMinMax.z; + float lnScaleMax = rgbMinMaxLnScaleMinMax.w; + float diagScale = 255.0 / (2.0 * (lnScaleMax - lnScaleMin)); + uvec3 uXxyyzz = uvec3(round(clamp((log(xxyyzz) - 2.0 * lnScaleMin) * diagScale, 0.0, 255.0))); + + vec3 xyxzyzCor = vec3( + clamp(xyxzyz.x / sqrt(xxyyzz.x * xxyyzz.y), -1.0, 1.0), + clamp(xyxzyz.y / sqrt(xxyyzz.x * xxyyzz.z), -1.0, 1.0), + clamp(xyxzyz.z / sqrt(xxyyzz.y * xxyyzz.z), -1.0, 1.0) + ); + ivec3 iXyxzyzCor = ivec3(round(xyxzyzCor * 127.0)); + + + uint word0 = uRgba.r | (uRgba.g << 8u) | (uRgba.b << 16u) | (uRgba.a << 24u); + uint word1 = packHalf2x16(center.xy); + uint word2 = packHalf2x16(vec2(center.z, 0.0)) | + ((uint(iXyxzyzCor.y) & 0xffu) << 16u) | + ((uint(iXyxzyzCor.z) & 0xffu) << 24u); + uint word3 = + uXxyyzz.x | (uXxyyzz.y << 8u) | (uXxyyzz.z << 16u) | + ((uint(iXyxzyzCor.x) & 0xffu) << 24u); + return uvec4(word0, word1, word2, word3); +} + +void unpackSplatCovEncoding(uvec4 packed, out vec3 center, out vec4 rgba, out vec3 xxyyzz, out vec3 xyxzyz, vec4 rgbMinMaxLnScaleMinMax) { + uint word0 = packed.x, word1 = packed.y, word2 = packed.z, word3 = packed.w; + + uvec4 uRgba = uvec4(word0 & 0xffu, (word0 >> 8u) & 0xffu, (word0 >> 16u) & 0xffu, (word0 >> 24u) & 0xffu); + float rgbMin = rgbMinMaxLnScaleMinMax.x; + float rgbMax = rgbMinMaxLnScaleMinMax.y; + rgba = (vec4(uRgba) / 255.0); + rgba.rgb = rgba.rgb * (rgbMax - rgbMin) + rgbMin; + + center = vec3( + unpackHalf2x16(word1), + unpackHalf2x16(word2 & 0xffffu).x + ); + + uvec3 uXxyyzz = uvec3(word3 & 0xffu, (word3 >> 8u) & 0xffu, (word3 >> 16u) & 0xffu); + ivec3 iXyxzyzCor = ivec3(int(word3) >> 24, int(word2 << 8u) >> 24, int(word2) >> 24); + + float lnScaleMin = rgbMinMaxLnScaleMinMax.z; + float lnScaleMax = rgbMinMaxLnScaleMinMax.w; + float diagScale = 2.0 * (lnScaleMax - lnScaleMin) / 255.0; + xxyyzz = exp(2.0 * lnScaleMin + vec3(uXxyyzz) * diagScale); + + vec3 xyxzyzCor = vec3(iXyxzyzCor) / 127.0; + xyxzyz = xyxzyzCor * vec3( + sqrt(xxyyzz.x * xxyyzz.y), + sqrt(xxyyzz.x * xxyyzz.z), + sqrt(xxyyzz.y * xxyyzz.z) + ); +} + +void packSplatExtCov( + out uvec4 packed, out uvec4 packed2, + vec3 center, vec4 rgba, vec3 xxyyzz, vec3 xyxzyz +) { + packed.x = floatBitsToUint(center.x); + packed.y = floatBitsToUint(center.y); + packed.z = floatBitsToUint(center.z); + packed.w = packHalf2x16(vec2(rgba.a, rgba.b)); + packed2.x = packHalf2x16(rgba.rg); + + vec3 xyxzyzCor = vec3( + clamp(xyxzyz.x / sqrt(xxyyzz.x * xxyyzz.y), -1.0, 1.0), + clamp(xyxzyz.y / sqrt(xxyyzz.x * xxyyzz.z), -1.0, 1.0), + clamp(xyxzyz.z / sqrt(xxyyzz.y * xxyyzz.z), -1.0, 1.0) + ); + xyxzyzCor = sign(xyxzyzCor) * clamp(log(abs(xyxzyzCor)), -100.0, -0.0000001); + xxyyzz = log(xxyyzz); + + packed2.y = packHalf2x16(vec2(xxyyzz.x, xxyyzz.y)); + packed2.z = packHalf2x16(vec2(xxyyzz.z, xyxzyzCor.x)); + packed2.w = packHalf2x16(vec2(xyxzyzCor.y, xyxzyzCor.z)); +} + +void unpackSplatExtCov( + uvec4 packed, uvec4 packed2, + out vec3 center, out vec4 rgba, out vec3 xxyyzz, out vec3 xyxzyz +) { + center.x = uintBitsToFloat(packed.x); + center.y = uintBitsToFloat(packed.y); + center.z = uintBitsToFloat(packed.z); + + vec2 ab = unpackHalf2x16(packed.w); + vec2 rg = unpackHalf2x16(packed2.x); + rgba = vec4(rg, ab.y, ab.x); + + vec2 xxyy = unpackHalf2x16(packed2.y); + vec2 zzxy = unpackHalf2x16(packed2.z); + vec2 xzyz = unpackHalf2x16(packed2.w); + xxyyzz = exp(vec3(xxyy.x, xxyy.y, zzxy.x)); + xyxzyz = vec3(zzxy.y, xzyz.x, xzyz.y); + xyxzyz = -sign(xyxzyz) * exp(-abs(xyxzyz)); + xyxzyz *= vec3( + sqrt(xxyyzz.x * xxyyzz.y), + sqrt(xxyyzz.x * xxyyzz.z), + sqrt(xxyyzz.y * xxyyzz.z) + ); +} + +void packSplatExt( + out uvec4 packed, out uvec4 packed2, + vec3 center, vec3 scales, vec4 quaternion, vec4 rgba +) { + packed.x = floatBitsToUint(center.x); + packed.y = floatBitsToUint(center.y); + packed.z = floatBitsToUint(center.z); + packed.w = packHalf2x16(vec2(rgba.a, 0.0)); + + packed2.x = packHalf2x16(rgba.rg); + packed2.y = packHalf2x16(vec2(rgba.b, log(scales.x))); + packed2.z = packHalf2x16(log(scales.yz)); + packed2.w = encodeQuatOctXy1010R12(quaternion); +} + +vec4 unpackSplatExtCenterAlpha(uvec4 packed) { + return vec4( + uintBitsToFloat(packed.x), + uintBitsToFloat(packed.y), + uintBitsToFloat(packed.z), + unpackHalf2x16(packed.w).x + ); +} + +float unpackSplatExtAlpha(uvec4 packed) { + return unpackHalf2x16(packed.w).x; +} + +void unpackSplatExt( + uvec4 packed, uvec4 packed2, + out vec3 center, out vec3 scales, out vec4 quaternion, out vec4 rgba +) { + center.x = uintBitsToFloat(packed.x); + center.y = uintBitsToFloat(packed.y); + center.z = uintBitsToFloat(packed.z); + rgba.a = unpackHalf2x16(packed.w).x; + + rgba.rg = unpackHalf2x16(packed2.x); + vec2 split = unpackHalf2x16(packed2.y); + rgba.b = split.x; + scales.x = exp(split.y); + scales.yz = exp(unpackHalf2x16(packed2.z)); + quaternion = decodeQuatOctXy1010R12(packed2.w); +} + +uint encodeExtRgb(vec3 rgb) { + vec3 absRgb = abs(rgb); + float maxAbs = max(absRgb.r, max(absRgb.g, absRgb.b)); + + int base = clamp(int(floor(log2(maxAbs))) + 15, 0, 31); + float divisor = exp2(float(base - 15)) / 255.0; + + uvec3 uRgb = uvec3(round(clamp(absRgb / divisor, 0.0, 255.0))); + uint expSigns = (uint(base) << 3u) | ((rgb.r < 0.0 ? 0x1u : 0u) | (rgb.g < 0.0 ? 0x2u : 0u) | (rgb.b < 0.0 ? 0x4u : 0u)); + return uRgb.r | (uRgb.g << 8u) | (uRgb.b << 16u) | (expSigns << 24u); +} + +vec3 decodeExtRgb(uint encoded) { + uint biasedBase = (encoded >> 27u) & 0x1fu; + float divisor = exp2(float(int(biasedBase) - 15)) / 255.0; + + vec3 rgb = vec3(uvec3(encoded & 0xffu, (encoded >> 8u) & 0xffu, (encoded >> 16u) & 0xffu)); + rgb *= divisor; + + return vec3( + ((encoded & 0x1000000u) != 0u) ? -rgb.r : rgb.r, + ((encoded & 0x2000000u) != 0u) ? -rgb.g : rgb.g, + ((encoded & 0x4000000u) != 0u) ? -rgb.b : rgb.b + ); +} + +vec3 quatVec(vec4 q, vec3 v) { + + vec3 t = 2.0 * cross(q.xyz, v); + return v + q.w * t + cross(q.xyz, t); +} + +vec4 quatQuat(vec4 q1, vec4 q2) { + return vec4( + q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, + q1.w * q2.y - q1.x * q2.z + q1.y * q2.w + q1.z * q2.x, + q1.w * q2.z + q1.x * q2.y - q1.y * q2.x + q1.z * q2.w, + q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z + ); +} + +mat3 quaternionToMatrix(vec4 q) { + return mat3( + (1.0 - 2.0 * (q.y * q.y + q.z * q.z)), + (2.0 * (q.x * q.y + q.w * q.z)), + (2.0 * (q.x * q.z - q.w * q.y)), + (2.0 * (q.x * q.y - q.w * q.z)), + (1.0 - 2.0 * (q.x * q.x + q.z * q.z)), + (2.0 * (q.y * q.z + q.w * q.x)), + (2.0 * (q.x * q.z + q.w * q.y)), + (2.0 * (q.y * q.z - q.w * q.x)), + (1.0 - 2.0 * (q.x * q.x + q.y * q.y)) + ); +} + +mat3 scaleQuaternionToMatrix(vec3 s, vec4 q) { + + return mat3( + s.x * (1.0 - 2.0 * (q.y * q.y + q.z * q.z)), + s.x * (2.0 * (q.x * q.y + q.w * q.z)), + s.x * (2.0 * (q.x * q.z - q.w * q.y)), + s.y * (2.0 * (q.x * q.y - q.w * q.z)), + s.y * (1.0 - 2.0 * (q.x * q.x + q.z * q.z)), + s.y * (2.0 * (q.y * q.z + q.w * q.x)), + s.z * (2.0 * (q.x * q.z + q.w * q.y)), + s.z * (2.0 * (q.y * q.z - q.w * q.x)), + s.z * (1.0 - 2.0 * (q.x * q.x + q.y * q.y)) + ); +} + +vec4 slerp(vec4 q1, vec4 q2, float t) { + + float cosHalfTheta = dot(q1, q2); + + + if (abs(cosHalfTheta) >= 0.999) { + return q1; + } + + + + if (cosHalfTheta < 0.0) { + q2 = -q2; + cosHalfTheta = -cosHalfTheta; + } + + + float halfTheta = acos(cosHalfTheta); + float sinHalfTheta = sqrt(1.0 - cosHalfTheta * cosHalfTheta); + + + float ratioA = sin((1.0 - t) * halfTheta) / sinHalfTheta; + float ratioB = sin(t * halfTheta) / sinHalfTheta; + + + return q1 * ratioA + q2 * ratioB; +} + +ivec3 splatTexCoord(int index) { + uint x = uint(index) & SPLAT_TEX_WIDTH_MASK; + uint y = (uint(index) >> SPLAT_TEX_WIDTH_BITS) & SPLAT_TEX_HEIGHT_MASK; + uint z = uint(index) >> SPLAT_TEX_LAYER_BITS; + return ivec3(x, y, z); +} + +ivec3 pagedSplatTexCoord(int index) { + return ivec3(index & 255, (index >> 8) & 255, index >> 16); +} + +vec4 uintToVec4(uint u32) { + uvec4 bytes = uvec4( + u32 & 0xFFu, + (u32 >> 8u) & 0xFFu, + (u32 >> 16u) & 0xFFu, + (u32 >> 24u) & 0xFFu + ); + return vec4(bytes) / 255.0; +} + +vec4 floatToVec4(float f) { + uint u32 = floatBitsToUint(f); + return uintToVec4(u32); +} + +vec3 debugColorHue(uint i) { + + float hue = fract(float(i) * 0.61803398875); + + vec3 rgb = clamp(abs(mod(hue*6.0 + vec3(0.0,4.0,2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0); + return mix(vec3(1.0), rgb, 0.85); +}`, ph = `precision highp float; +precision highp int; + +#include + +uniform float near; +uniform float far; +uniform bool encodeLinear; +uniform float time; +uniform bool debugFlag; +uniform float maxStdDev; +uniform float minAlpha; +uniform bool disableFalloff; +uniform float falloff; + +out vec4 fragColor; + +in vec4 vRgba; +in vec2 vSplatUv; +in vec3 vNdc; +flat in uint vSplatIndex; +flat in float adjustedStdDev; + +#include + +void main() { + vec4 rgba = vRgba; + + float z2 = dot(vSplatUv, vSplatUv); + if (z2 > (adjustedStdDev * adjustedStdDev)) { + discard; + } + + if (false) { + + float a = rgba.a; + float shifted = sqrt(z2) - max(0.0, a - 1.0); + float exponent = -0.5 * max(1.0, a) * sqr(max(0.0, shifted)); + float min1a = min(1.0, a); + rgba.a = mix(min1a, min1a * exp(exponent), falloff); + } else { + + if (rgba.a <= 1.0) { + rgba.a = mix(rgba.a, rgba.a * exp(-0.5 * z2), falloff); + } else { + float a = exp((rgba.a*rgba.a - 1.0) / 2.718281828459045); + float alpha = 1.0 - pow(1.0 - exp(-0.5 * z2), a); + rgba.a = mix(1.0, alpha, falloff); + } + } + + if (rgba.a < minAlpha) { + discard; + } + if (encodeLinear) { + rgba.rgb = srgbToLinear(rgba.rgb); + } + + #ifdef PREMULTIPLIED_ALPHA + fragColor = vec4(rgba.rgb * rgba.a, rgba.a); + #else + fragColor = rgba; + #endif + + #include +}`, fh = `precision highp float; +precision highp int; +precision highp usampler2DArray; + +#include + +out vec4 vRgba; +out vec2 vSplatUv; +out vec3 vNdc; +flat out uint vSplatIndex; +flat out float adjustedStdDev; + +uniform vec2 renderSize; +uniform vec4 renderToViewQuat; +uniform vec3 renderToViewPos; +uniform mat3 renderToViewBasis; +uniform float maxStdDev; +uniform float minPixelRadius; +uniform float maxPixelRadius; +uniform bool enableExtSplats; +uniform bool enableCovSplats; +uniform float time; +uniform float deltaTime; +uniform bool debugFlag; +uniform float minAlpha; +uniform bool enable2DGS; +uniform bool lodInflate; +uniform float blurAmount; +uniform float preBlurAmount; +uniform float focalDistance; +uniform float apertureAngle; +uniform float clipXY; +uniform float focalAdjustment; + +uniform usampler2D ordering; +uniform usampler2DArray extSplats; +uniform usampler2DArray extSplats2; + +bool isPerspectiveMatrix( mat4 m ) { + return m[ 2 ][ 3 ] == -1.0; +} + +#include + +void main() { + + gl_Position = vec4(0.0, 0.0, 2.0, 1.0); + + ivec2 orderingCoord = ivec2((gl_InstanceID >> 2) & 4095, gl_InstanceID >> 14); + uint splatIndex = texelFetch(ordering, orderingCoord, 0)[gl_InstanceID & 3]; + if (splatIndex == 0xffffffffu) { + + return; + } + + ivec3 texCoord = splatTexCoord(int(splatIndex)); + vec3 center, scales, xxyyzz, xyxzyz; + vec4 quaternion, rgba; + mat3 cov3D; + bvec3 zeroScales = bvec3(false); + + if (enableExtSplats) { + uvec4 ext1 = texelFetch(extSplats, texCoord, 0); + float alpha = unpackSplatExtAlpha(ext1); + if ((alpha == 0.0) || (alpha < minAlpha)) { + return; + } + uvec4 ext2 = texelFetch(extSplats2, texCoord, 0); + + if (!enableCovSplats) { + unpackSplatExt(ext1, ext2, center, scales, quaternion, rgba); + zeroScales = equal(scales, vec3(0.0)); + if (all(zeroScales)) { + return; + } + } else { + unpackSplatExtCov(ext1, ext2, center, rgba, xxyyzz, xyxzyz); + if (all(equal(xxyyzz, vec3(0.0))) && all(equal(xyxzyz, vec3(0.0)))) { + return; + } + } + } else { + uvec4 packed = texelFetch(extSplats, texCoord, 0); + if (!enableCovSplats) { + unpackSplatEncoding(packed, center, scales, quaternion, rgba, vec4(0.0, 1.0, LN_SCALE_MIN, LN_SCALE_MAX)); + zeroScales = equal(scales, vec3(0.0)); + if (all(zeroScales)) { + return; + } + } else { + unpackSplatCovEncoding(packed, center, rgba, xxyyzz, xyxzyz, vec4(0.0, 1.0, LN_SCALE_MIN, LN_SCALE_MAX)); + if (all(equal(xxyyzz, vec3(0.0))) && all(equal(xyxzyz, vec3(0.0)))) { + return; + } + } + + rgba.a *= 2.0; + if ((rgba.a == 0.0) || (rgba.a < minAlpha)) { + return; + } + } + + adjustedStdDev = maxStdDev; + if (rgba.a > 1.0) { + + rgba.a = min(rgba.a * 4.0 - 3.0, 5.0); + + if (lodInflate) { + + float opacity = exp((rgba.a * rgba.a - 1.0) / 2.718281828459045); + float rescale = pow(opacity, 1.0 / 3.0); + scales *= rescale; + rgba.a = 1.0; + } + + + adjustedStdDev = maxStdDev + 0.7 * (rgba.a - 1.0); + } + + + vec3 viewCenter = (!enableCovSplats ? quatVec(renderToViewQuat, center) : (renderToViewBasis * center)) + renderToViewPos; + + + if (viewCenter.z >= 0.0) { + return; + } + + + vec4 clipCenter = projectionMatrix * vec4(viewCenter, 1.0); + + + if (abs(clipCenter.z) >= clipCenter.w) { + return; + } + + + float clip = clipXY * clipCenter.w; + if (abs(clipCenter.x) > clip || abs(clipCenter.y) > clip) { + return; + } + + vRgba = rgba; + vSplatUv = position.xy * adjustedStdDev; + + + vSplatIndex = splatIndex; + + if (!enableCovSplats) { + + vec4 viewQuaternion = quatQuat(renderToViewQuat, quaternion); + + if (enable2DGS && any(zeroScales)) { + vec3 offset; + if (zeroScales.z) { + offset = vec3(vSplatUv.xy * scales.xy, 0.0); + } else if (zeroScales.y) { + offset = vec3(vSplatUv.x * scales.x, 0.0, vSplatUv.y * scales.z); + } else { + offset = vec3(0.0, vSplatUv.xy * scales.yz); + } + + vec3 viewPos = viewCenter + quatVec(viewQuaternion, offset); + gl_Position = projectionMatrix * vec4(viewPos, 1.0); + vNdc = gl_Position.xyz / gl_Position.w; + + #include + return; + } + + + mat3 RS = scaleQuaternionToMatrix(scales, viewQuaternion); + cov3D = RS * transpose(RS); + } else { + cov3D = mat3( + xxyyzz.x, xyxzyz.x, xyxzyz.y, + xyxzyz.x, xxyyzz.y, xyxzyz.z, + xyxzyz.y, xyxzyz.z, xxyyzz.z + ); + cov3D = renderToViewBasis * cov3D * transpose(renderToViewBasis); + } + + + vec2 scaledRenderSize = renderSize * focalAdjustment; + vec2 focal = 0.5 * scaledRenderSize * vec2(projectionMatrix[0][0], projectionMatrix[1][1]); + + mat3 J; + if (isOrthographic) { + J = mat3( + focal.x, 0.0, 0.0, + 0.0, focal.y, 0.0, + 0.0, 0.0, 0.0 + ); + } else { + float invZ = 1.0 / viewCenter.z; + vec2 J1 = focal * invZ; + vec2 J2 = -(J1 * viewCenter.xy) * invZ; + J = mat3( + J1.x, 0.0, J2.x, + 0.0, J1.y, J2.y, + 0.0, 0.0, 0.0 + ); + } + + + + mat3 cov2D = transpose(J) * cov3D * J; + float a = cov2D[0][0]; + float d = cov2D[1][1]; + float b = cov2D[0][1]; + + + a += preBlurAmount; + d += preBlurAmount; + + float fullBlurAmount = blurAmount; + if ((focalDistance > 0.0) && (apertureAngle > 0.0)) { + float focusRadius = maxPixelRadius; + if (viewCenter.z < 0.0) { + float focusBlur = abs((-viewCenter.z - focalDistance) / viewCenter.z); + float apertureRadius = focal.x * tan(0.5 * apertureAngle); + focusRadius = focusBlur * apertureRadius; + } + fullBlurAmount = clamp(sqr(focusRadius), blurAmount, sqr(maxPixelRadius)); + } + + + float detOrig = a * d - b * b; + a += fullBlurAmount; + d += fullBlurAmount; + float det = a * d - b * b; + + + float blurAdjust = sqrt(max(0.0, detOrig / det)); + rgba.a *= blurAdjust; + if (rgba.a < minAlpha) { + return; + } + vRgba.a = rgba.a; + + + float eigenAvg = 0.5 * (a + d); + float eigenDelta = sqrt(max(0.0, eigenAvg * eigenAvg - det)); + float eigen1 = eigenAvg + eigenDelta; + float eigen2 = eigenAvg - eigenDelta; + + vec2 eigenVec1 = (abs(b) > 0.001) ? normalize(vec2(b, eigen1 - a)) + : ((a >= d) ? vec2(1.0, 0.0) : vec2(0.0, 1.0)); + vec2 eigenVec2 = vec2(eigenVec1.y, -eigenVec1.x); + + float scale1 = min(maxPixelRadius, adjustedStdDev * sqrt(eigen1)); + float scale2 = min(maxPixelRadius, adjustedStdDev * sqrt(eigen2)); + if (scale1 < minPixelRadius && scale2 < minPixelRadius) { + return; + } + + + vec2 pixelOffset = position.x * eigenVec1 * scale1 + position.y * eigenVec2 * scale2; + vec2 ndcOffset = (2.0 / scaledRenderSize) * pixelOffset; + + + vec3 ndcCenter = clipCenter.xyz / clipCenter.w; + vec3 ndc = vec3(ndcCenter.xy + ndcOffset, ndcCenter.z); + + vNdc = ndc; + gl_Position = vec4(ndc.xy * clipCenter.w, clipCenter.zw); + + #include +}`; +let NQ = null; +function Ag() { + return NQ || (G.ShaderChunk.splatDefines = lh, NQ = { + oldSplatVertex: xh, + oldSplatFragment: qh, + splatVertex: fh, + splatFragment: ph, + computeVec4Template: dh, + computeUvec4Vec4Template: rh, + computeUvec4x2Vec4Template: nh, + computeUvec4Template: eh + }), NQ; +} +const WA = class WA { + constructor({ renderer: A } = {}) { + this.renderer = A, this.capacity = 0, this.count = 0; + } + dispose() { + this.target && (this.target.dispose(), this.target = void 0); + } + // Ensure we have a buffer large enough for the readback of count indices. + // Pass in previous bufer of the desired type. + static ensureBuffer(A, I) { + const B = Math.ceil(Math.max(1, A) / P) * P * 4; + if (I.byteLength >= B) + return I; + const C = new ArrayBuffer(B); + if (I instanceof ArrayBuffer) + return C; + const E = I.constructor; + return new E(C); + } + ensureBuffer(A, I) { + return WA.ensureBuffer(A, I); + } + // Ensure our render target is large enough for the readback of capacity indices. + ensureCapacity(A) { + const { width: I, height: g, depth: B, maxSplats: C } = BA(A); + (!this.target || C > this.capacity) && (this.dispose(), this.capacity = C, this.target = new G.WebGLArrayRenderTarget(I, g, B, { + depthBuffer: !1, + stencilBuffer: !1, + generateMipmaps: !1, + magFilter: G.NearestFilter, + minFilter: G.NearestFilter + }), this.target.texture.format = G.RGBAFormat, this.target.texture.type = G.UnsignedByteType, this.target.texture.internalFormat = "RGBA8", this.target.scissorTest = !0); + } + // Get a program and THREE.RawShaderMaterial for a given Rgba8Readback, + // generating it if necessary and caching the result. + prepareProgramMaterial(A) { + let I = WA.readbackProgram.get(A); + if (!I) { + const B = cA( + { index: "int" }, + { rgba8: "vec4" }, + ({ index: C }) => (A.inputs.index = C, { rgba8: new oB({ rgba8: A.outputs.rgba8 }) }) + ); + WA.programTemplate || (WA.programTemplate = new Fg( + Ag().computeVec4Template + )), I = new CQ({ + graph: B, + inputs: { index: "_index" }, + outputs: { rgba8: "target" }, + template: WA.programTemplate + }), Object.assign(I.uniforms, { + targetLayer: { value: 0 }, + targetBase: { value: 0 }, + targetCount: { value: 0 } + }), WA.readbackProgram.set(A, I); + } + const g = I.prepareMaterial(); + return WA.fullScreenQuad.material = g, { program: I, material: g }; + } + saveRenderState(A) { + return { + target: A.getRenderTarget(), + xrEnabled: A.xr.enabled, + autoClear: A.autoClear + }; + } + resetRenderState(A, I) { + A.setRenderTarget(I.target), A.xr.enabled = I.xrEnabled, A.autoClear = I.autoClear; + } + process({ + count: A, + material: I + }) { + const g = this.renderer; + if (!g) + throw new Error("No renderer"); + if (!this.target) + throw new Error("No target"); + const B = P * XA; + I.uniforms.targetBase.value = 0, I.uniforms.targetCount.value = A; + let C = 0; + for (; C < A; ) { + const E = Math.floor(C / B), D = E * B, i = Math.min( + XA, + Math.ceil((A - D) / P) + ); + I.uniforms.targetLayer.value = E, this.target.scissor.set(0, 0, P, i), g.setRenderTarget(this.target, E), g.xr.enabled = !1, g.autoClear = !1, WA.fullScreenQuad.render(g), C += P * i; + } + this.count = A; + } + async read({ + readback: A + }) { + const I = this.renderer; + if (!I) + throw new Error("No renderer"); + if (!this.target) + throw new Error("No target"); + const g = Math.ceil(this.count / P) * P; + if (A.byteLength < g * 4) + throw new Error( + `Readback buffer too small: ${A.byteLength} < ${g * 4}` + ); + const B = new Uint8Array( + A instanceof ArrayBuffer ? A : A.buffer + ), C = P * XA; + let E = 0; + const D = []; + for (; E < this.count; ) { + const i = Math.floor(E / C), w = i * C, s = Math.min( + XA, + Math.ceil((this.count - w) / P) + ); + I.setRenderTarget(this.target, i); + const o = P * s * 4, y = B.subarray( + w * 4, + w * 4 + o + ), h = I == null ? void 0 : I.readRenderTargetPixelsAsync( + this.target, + 0, + 0, + P, + s, + y + ); + D.push(h), E += P * s; + } + return Promise.all(D).then(() => A); + } + // Perform render operation to run the Rgba8Readback program + // but don't perform the readback yet. + render({ + reader: A, + count: I, + renderer: g + }) { + if (this.renderer = g || this.renderer, !this.renderer) + throw new Error("No renderer"); + this.ensureCapacity(I); + const { program: B, material: C } = this.prepareProgramMaterial(A); + B.update(); + const E = this.saveRenderState(this.renderer); + this.process({ count: I, material: C }), this.resetRenderState(this.renderer, E); + } + // Perform a readback of the render target, returning a buffer of the + // given type. + async readback({ + readback: A + }) { + if (!this.renderer) + throw new Error("No renderer"); + const I = this.saveRenderState(this.renderer), g = this.read({ readback: A }); + return this.resetRenderState(this.renderer, I), g; + } + // Perform a render and readback operation for the given Rgba8Readback, + // and readback buffer (call ensureBuffer first). + async renderReadback({ + reader: A, + count: I, + renderer: g, + readback: B + }) { + if (this.renderer = g || this.renderer, !this.renderer) + throw new Error("No renderer"); + this.ensureCapacity(I); + const { program: C, material: E } = this.prepareProgramMaterial(A); + C.update(); + const D = this.saveRenderState(this.renderer); + this.process({ count: I, material: E }); + const i = this.read({ readback: B }); + return this.resetRenderState(this.renderer, D), i; + } + getTexture() { + var A; + return (A = this.target) == null ? void 0 : A.texture; + } +}; +WA.programTemplate = null, WA.readbackProgram = /* @__PURE__ */ new WeakMap(), WA.fullScreenQuad = new QB( + new G.RawShaderMaterial({ visible: !1 }) +); +let Ig = WA; +const nA = class nA { + constructor(A = {}) { + if (this.capacity = 0, this.count = 0, this.array = null, this.readback = null, this.source = null, this.needsUpdate = !0, this.dyno = new x({ + key: "rgbaArray", + type: RB, + globals: () => [pw], + value: { + texture: nA.getEmpty(), + count: 0 + }, + update: (I) => (I.texture = this.getTexture(), I.count = this.count, I) + }), A.array) { + this.array = A.array; + const I = Math.floor(this.array.length / 4); + this.capacity = Math.ceil(I / P) * P, this.capacity > I && (this.array = new Uint8Array(this.capacity * 4), this.array.set(A.array)), this.count = Math.min( + I, + A.count ?? Number.POSITIVE_INFINITY + ); + } else + this.capacity = A.capacity ?? 0, this.count = 0; + } + // Free up resources + dispose() { + this.readback && (this.readback.dispose(), this.readback = null), this.source && (this.source.dispose(), this.source = null); + } + // Ensure that our array is large enough to hold capacity RGBA8 values. + ensureCapacity(A) { + var I; + if (!this.array || A > (((I = this.array) == null ? void 0 : I.length) ?? 0) / 4) { + this.capacity = BA(A).maxSplats; + const g = new Uint8Array(this.capacity * 4); + this.array && g.set(this.array), this.array = g; + } + return this.array; + } + // Get the THREE.DataArrayTexture from either the readback or the source. + getTexture() { + var I; + let A = (I = this.readback) == null ? void 0 : I.getTexture(); + return (this.source || this.array) && (A = this.maybeUpdateSource()), A ?? nA.getEmpty(); + } + // Create or get a THREE.DataArrayTexture from the data array. + maybeUpdateSource() { + if (!this.array) + throw new Error("No array"); + if (this.needsUpdate || !this.source) { + if (this.needsUpdate = !1, this.source) { + const { width: A, height: I, depth: g } = this.source.image; + this.capacity !== A * I * g && (this.source.dispose(), this.source = null); + } + if (this.source) + this.array.buffer !== this.source.image.data.buffer && (this.source.image.data = new Uint8Array(this.array.buffer)); + else { + const { width: A, height: I, depth: g } = BA(this.capacity); + this.source = new G.DataArrayTexture( + this.array, + A, + I, + g + ), this.source.format = G.RGBAFormat, this.source.type = G.UnsignedByteType, this.source.internalFormat = "RGBA8", this.source.needsUpdate = !0; + } + this.source.needsUpdate = !0; + } + return this.source; + } + // Generate the RGBA8 values from a Rgba8Readback dyno program. + render({ + reader: A, + count: I, + renderer: g + }) { + this.readback || (this.readback = new Ig({ renderer: g })), this.readback.render({ reader: A, count: I, renderer: g }), this.capacity = this.readback.capacity, this.count = this.readback.count; + } + // Extract the RGBA8 values from a PackedSplats collection. + fromPackedSplats({ + packedSplats: A, + base: I, + count: g, + renderer: B + }) { + const { dynoSplats: C, dynoBase: E, dynoCount: D, reader: i } = nA.makeDynos(); + return C.packedSplats = A, E.value = I, D.value = g, this.render({ reader: i, count: g, renderer: B }), this; + } + // Read back the RGBA8 values from the readback buffer. + async read() { + if (!this.readback) + throw new Error("No readback"); + return (!this.array || this.array.length < this.count * 4) && (this.array = new Uint8Array(this.capacity * 4)), (await this.readback.readback({ readback: this.array })).subarray(0, this.count * 4); + } + async getArray() { + if (this.readback) + return await this.read(); + if (this.array) + return this.array; + throw new Error("No array"); + } + // Can be used where you need an uninitialized THREE.DataArrayTexture like + // a uniform you will update with the result of this.getTexture() later. + static getEmpty() { + if (!nA.emptySource) { + const A = new Uint8Array(4); + nA.emptySource = new G.DataArrayTexture(A, 1, 1, 1), nA.emptySource.format = G.RGBAFormat, nA.emptySource.type = G.UnsignedByteType, nA.emptySource.internalFormat = "RGBA8", nA.emptySource.needsUpdate = !0; + } + return nA.emptySource; + } + // Create a dyno program that can extract RGBA8 values from a PackedSplats + static makeDynos() { + if (!nA.dynos) { + const A = new MB(), I = new EI({ value: 0 }), g = new EI({ value: 0 }), B = cA( + { index: "int" }, + { rgba8: "vec4" }, + ({ index: C }) => { + if (!C) + throw new Error("index is undefined"); + C = qA(C, I); + const E = pC( + A, + C, + I, + g + ); + return { rgba8: uA(E).outputs.rgba }; + } + ); + nA.dynos = { dynoSplats: A, dynoBase: I, dynoCount: g, reader: B }; + } + return nA.dynos; + } +}; +nA.emptySource = null, nA.dynos = null; +let TQ = nA; +const RB = { type: "RgbaArray" }, pw = oA(` + struct RgbaArray { + sampler2DArray texture; + int count; + }; +`); +function fk(Q, A) { + return new d({ + inTypes: { rgba: RB, index: "int" }, + outTypes: { rgba: "vec4" }, + inputs: { rgba: Q, index: A }, + globals: () => [pw], + statements: ({ inputs: g, outputs: B }) => z(` + if ((${g.index} >= 0) && (${g.index} < ${g.rgba}.count)) { + ${B.rgba} = texelFetch(${g.rgba}.texture, splatTexCoord(${g.index}), 0); + } else { + ${B.rgba} = vec4(0.0, 0.0, 0.0, 0.0); + } + `) + }).outputs.rgba; +} +var bh = /* @__PURE__ */ ((Q) => (Q.ALL = "all", Q.PLANE = "plane", Q.SPHERE = "sphere", Q.BOX = "box", Q.ELLIPSOID = "ellipsoid", Q.CYLINDER = "cylinder", Q.CAPSULE = "capsule", Q.INFINITE_CONE = "infinite_cone", Q))(bh || {}); +function Ph(Q) { + switch (Q) { + case "all": + return 0; + case "plane": + return 1; + case "sphere": + return 2; + case "box": + return 3; + case "ellipsoid": + return 4; + case "cylinder": + return 5; + case "capsule": + return 6; + case "infinite_cone": + return 7; + default: + throw new Error(`Unknown SDF type: ${Q}`); + } +} +var uh = /* @__PURE__ */ ((Q) => (Q.MULTIPLY = "multiply", Q.SET_RGB = "set_rgb", Q.ADD_RGBA = "add_rgba", Q))(uh || {}); +function Th(Q) { + switch (Q) { + case "multiply": + return 0; + case "set_rgb": + return 1; + case "add_rgba": + return 2; + default: + throw new Error(`Unknown blend mode: ${Q}`); + } +} +class Oh extends G.Object3D { + constructor(A = {}) { + super(); + const { type: I, invert: g, opacity: B, color: C, displace: E, radius: D } = A; + this.type = I ?? "sphere", this.invert = g ?? !1, this.opacity = B ?? 1, this.color = C ?? new G.Color(1, 1, 1), this.displace = E ?? new G.Vector3(0, 0, 0), this.radius = D ?? 0; + } +} +const $g = class $g extends G.Object3D { + constructor(A = {}) { + const { + name: I, + rgbaBlendMode: g = "multiply", + sdfSmooth: B = 0, + softEdge: C = 0, + invert: E = !1, + sdfs: D = null + } = A; + super(), this.rgbaBlendMode = g, this.sdfSmooth = B, this.softEdge = C, this.invert = E, this.sdfs = D, this.ordering = $g.nextOrdering++, this.name = I ?? `Edit ${this.ordering}`; + } + addSdf(A) { + this.sdfs == null && (this.sdfs = []), this.sdfs.includes(A) || this.sdfs.push(A); + } + removeSdf(A) { + this.sdfs != null && (this.sdfs = this.sdfs.filter((I) => I !== A)); + } +}; +$g.nextOrdering = 1; +let ag = $g; +class mh { + constructor({ maxSdfs: A, maxEdits: I }) { + this.maxSdfs = Math.max(16, A ?? 0), this.numSdfs = 0, this.sdfData = new Uint32Array(this.maxSdfs * 8 * 4), this.sdfFloatData = new Float32Array(this.sdfData.buffer), this.sdfTexture = this.newSdfTexture(this.sdfData, this.maxSdfs), this.dynoSdfArray = new x({ + key: "sdfArray", + type: kB, + globals: () => [FB], + value: { + numSdfs: 0, + sdfTexture: this.sdfTexture + }, + update: (g) => (g.numSdfs = this.numSdfs, g.sdfTexture = this.sdfTexture, g) + }), this.maxEdits = Math.max(16, I ?? 0), this.numEdits = 0, this.editData = new Uint32Array(this.maxEdits * 4), this.editFloatData = new Float32Array(this.editData.buffer), this.dynoNumEdits = new EI({ value: 0 }), this.dynoEdits = this.newEdits(this.editData, this.maxEdits); + } + newSdfTexture(A, I) { + const g = new G.DataTexture( + A, + 8, + I, + G.RGBAIntegerFormat, + G.UnsignedIntType + ); + return g.internalFormat = "RGBA32UI", g.needsUpdate = !0, g; + } + newEdits(A, I) { + return new x({ + key: "edits", + type: "uvec4", + count: I, + globals: () => [SB], + value: A + }); + } + // Ensure our SDF texture and edits uniform array have enough capacity. + // Reallocate if not. + ensureCapacity({ + maxSdfs: A, + maxEdits: I + }) { + let g = !1; + return A > this.sdfTexture.image.height && (this.sdfTexture.dispose(), this.maxSdfs = Math.max(this.maxSdfs * 2, A), this.sdfData = new Uint32Array(this.maxSdfs * 8 * 4), this.sdfFloatData = new Float32Array(this.sdfData.buffer), this.sdfTexture = this.newSdfTexture(this.sdfData, this.maxSdfs)), I > (this.dynoEdits.count ?? 0) && (this.maxEdits = Math.max(this.maxEdits * 2, I), this.editData = new Uint32Array(this.maxEdits * 4), this.editFloatData = new Float32Array(this.editData.buffer), this.dynoEdits = this.newEdits(this.editData, this.maxEdits), g = !0), g; + } + updateEditData(A, I) { + const g = this.editData[A] !== I; + return this.editData[A] = I, g; + } + updateEditFloatData(A, I) { + ZI[0] = I; + const g = this.editFloatData[A] !== ZI[0]; + return g && (this.editFloatData[A] = ZI[0]), g; + } + encodeEdit(A, { + sdfFirst: I, + sdfCount: g, + invert: B, + rgbaBlendMode: C, + softEdge: E, + sdfSmooth: D + }) { + const i = A * 4; + let w = !1; + return w = this.updateEditData(i + 0, C | (B ? 256 : 0)) || w, w = this.updateEditData(i + 1, I | g << 16) || w, w = this.updateEditFloatData(i + 2, E) || w, w = this.updateEditFloatData(i + 3, D) || w, w; + } + updateSdfData(A, I) { + const g = this.sdfData[A] !== I; + return this.sdfData[A] = I, g; + } + updateSdfFloatData(A, I) { + ZI[0] = I; + const g = this.sdfFloatData[A] !== ZI[0]; + return g && (this.sdfFloatData[A] = ZI[0]), g; + } + encodeSdf(A, { + sdfType: I, + invert: g, + center: B, + quaternion: C, + scale: E, + sizes: D + }, i) { + const w = A * 32, s = I | (g ? 256 : 0); + let o = !1; + o = this.updateSdfFloatData(w + 0, (B == null ? void 0 : B.x) ?? 0) || o, o = this.updateSdfFloatData(w + 1, (B == null ? void 0 : B.y) ?? 0) || o, o = this.updateSdfFloatData(w + 2, (B == null ? void 0 : B.z) ?? 0) || o, o = this.updateSdfData(w + 3, s) || o, o = this.updateSdfFloatData(w + 4, (C == null ? void 0 : C.x) ?? 0) || o, o = this.updateSdfFloatData(w + 5, (C == null ? void 0 : C.y) ?? 0) || o, o = this.updateSdfFloatData(w + 6, (C == null ? void 0 : C.z) ?? 0) || o, o = this.updateSdfFloatData(w + 7, (C == null ? void 0 : C.w) ?? 0) || o, o = this.updateSdfFloatData(w + 8, (E == null ? void 0 : E.x) ?? 0) || o, o = this.updateSdfFloatData(w + 9, (E == null ? void 0 : E.y) ?? 0) || o, o = this.updateSdfFloatData(w + 10, (E == null ? void 0 : E.z) ?? 0) || o, o = this.updateSdfData(w + 11, 0) || o, o = this.updateSdfFloatData(w + 12, (D == null ? void 0 : D.x) ?? 0) || o, o = this.updateSdfFloatData(w + 13, (D == null ? void 0 : D.y) ?? 0) || o, o = this.updateSdfFloatData(w + 14, (D == null ? void 0 : D.z) ?? 0) || o, o = this.updateSdfFloatData(w + 15, (D == null ? void 0 : D.w) ?? 0) || o; + const y = Math.min(4, i.length); + for (let h = 0; h < y; ++h) { + const k = w + 16 + h * 4; + o = this.updateSdfFloatData(k + 0, i[h].x) || o, o = this.updateSdfFloatData(k + 1, i[h].y) || o, o = this.updateSdfFloatData(k + 2, i[h].z) || o, o = this.updateSdfFloatData(k + 3, i[h].w) || o; + } + return o; + } + // Update the SDFs and edits from an array of SplatEdits and their + // associated SplatEditSdfs, updating it for the dyno shader program. + update(A) { + const I = A.reduce((o, { sdfs: y }) => o + y.length, 0), g = this.ensureCapacity({ + maxEdits: A.length, + maxSdfs: I + }), B = [new G.Vector4(), new G.Vector4()], C = new G.Vector3(), E = new G.Quaternion(), D = new G.Vector3(), i = new G.Vector4(); + let w = 0, s = g; + A.length !== this.dynoNumEdits.value && (this.dynoNumEdits.value = A.length, this.numEdits = A.length, s = !0); + for (const [o, { edit: y, sdfs: h }] of A.entries()) { + s = this.encodeEdit(o, { + sdfFirst: w, + sdfCount: h.length, + invert: y.invert, + rgbaBlendMode: Th(y.rgbaBlendMode), + softEdge: y.softEdge, + sdfSmooth: y.sdfSmooth + }) || s; + let k = !1; + for (const R of h) + i.set(R.scale.x, R.scale.y, R.scale.z, R.radius), R.scale.setScalar(1), R.updateMatrixWorld(), R.matrixWorld.clone().invert().decompose(C, E, D), R.scale.set(i.x, i.y, i.z), R.updateMatrixWorld(), B[0].set(R.color.r, R.color.g, R.color.b, R.opacity), B[1].set(R.displace.x, R.displace.y, R.displace.z, 1), k = this.encodeSdf( + w, + { + sdfType: Ph(R.type), + invert: R.invert, + center: C, + quaternion: E, + scale: D, + sizes: i + }, + B + ) || k, w += 1; + this.numSdfs = w, k && (this.sdfTexture.needsUpdate = !0), s || (s = k); + } + return { updated: s, dynoUpdated: g }; + } + // Modify a Gsplat in a dyno shader program using the current edits and SDFs. + modify(A) { + return Zh( + A, + this.dynoSdfArray, + this.dynoNumEdits, + this.dynoEdits + ); + } + modifyCov(A) { + return Vh( + A, + this.dynoSdfArray, + this.dynoNumEdits, + this.dynoEdits + ); + } +} +const kB = { type: "SdfArray" }, FB = oA(` + struct SdfArray { + int numSdfs; + usampler2D sdfTexture; + }; + + void unpackSdfArray( + usampler2D sdfTexture, int sdfIndex, out uint flags, + out vec3 center, out vec4 quaternion, out vec3 scale, out vec4 sizes, + int numValues, out vec4 values[4] + ) { + uvec4 temp = texelFetch(sdfTexture, ivec2(0, sdfIndex), 0); + flags = temp.w; + center = vec3(uintBitsToFloat(temp.x), uintBitsToFloat(temp.y), uintBitsToFloat(temp.z)); + + temp = texelFetch(sdfTexture, ivec2(1, sdfIndex), 0); + quaternion = vec4(uintBitsToFloat(temp.x), uintBitsToFloat(temp.y), uintBitsToFloat(temp.z), uintBitsToFloat(temp.w)); + + temp = texelFetch(sdfTexture, ivec2(2, sdfIndex), 0); + scale = vec3(uintBitsToFloat(temp.x), uintBitsToFloat(temp.y), uintBitsToFloat(temp.z)); + + temp = texelFetch(sdfTexture, ivec2(3, sdfIndex), 0); + sizes = vec4(uintBitsToFloat(temp.x), uintBitsToFloat(temp.y), uintBitsToFloat(temp.z), uintBitsToFloat(temp.w)); + + for (int i = 0; i < numValues; ++i) { + temp = texelFetch(sdfTexture, ivec2(4 + i, sdfIndex), 0); + values[i] = vec4(uintBitsToFloat(temp.x), uintBitsToFloat(temp.y), uintBitsToFloat(temp.z), uintBitsToFloat(temp.w)); + } + } + + const uint SDF_FLAG_TYPE = 0xFFu; + const uint SDF_FLAG_INVERT = 1u << 8u; + + const uint SDF_TYPE_ALL = 0u; + const uint SDF_TYPE_PLANE = 1u; + const uint SDF_TYPE_SPHERE = 2u; + const uint SDF_TYPE_BOX = 3u; + const uint SDF_TYPE_ELLIPSOID = 4u; + const uint SDF_TYPE_CYLINDER = 5u; + const uint SDF_TYPE_CAPSULE = 6u; + const uint SDF_TYPE_INFINITE_CONE = 7u; + + float evaluateSdfArray( + usampler2D sdfTexture, int numSdfs, int sdfFirst, int sdfCount, vec3 pos, + float smoothK, int numValues, out vec4 outValues[4] + ) { + float distanceAccum = (smoothK == 0.0) ? 1.0 / 0.0 : 0.0; + float maxExp = -1.0 / 0.0; + for (int i = 0; i < numValues; ++i) { + outValues[i] = vec4(0.0); + } + + uint flags; + vec3 center, scale; + vec4 quaternion, sizes; + vec4 values[4]; + + int sdfLast = min(sdfFirst + sdfCount, numSdfs); + for (int index = sdfFirst; index < sdfLast; ++index) { + unpackSdfArray(sdfTexture, index, flags, center, quaternion, scale, sizes, numValues, values); + uint sdfType = flags & SDF_FLAG_TYPE; + vec3 sdfPos = quatVec(quaternion, pos * scale) + center; + + float distance; + switch (sdfType) { + case SDF_TYPE_ALL: + distance = -1.0 / 0.0; + break; + case SDF_TYPE_PLANE: { + distance = sdfPos.z; + break; + } + case SDF_TYPE_SPHERE: { + distance = length(sdfPos) - sizes.w; + break; + } + case SDF_TYPE_BOX: { + vec3 q = abs(sdfPos) - sizes.xyz + sizes.w; + distance = length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0) - sizes.w; + break; + } + case SDF_TYPE_ELLIPSOID: { + vec3 sizes = sizes.xyz; + float k0 = length(sdfPos / sizes); + float k1 = length(sdfPos / dot(sizes, sizes)); + distance = k0 * (k0 - 1.0) / k1; + break; + } + case SDF_TYPE_CYLINDER: { + vec2 d = abs(vec2(length(sdfPos.xz), sdfPos.y)) - sizes.wy; + distance = min(max(d.x, d.y), 0.0) + length(max(d, 0.0)); + break; + } + case SDF_TYPE_CAPSULE: { + sdfPos.y -= clamp(sdfPos.y, -0.5 * sizes.y, 0.5 * sizes.y); + distance = length(sdfPos) - sizes.w; + break; + } + case SDF_TYPE_INFINITE_CONE: { + float angle = 0.25 * PI * sizes.w; + vec2 c = vec2(sin(angle), cos(angle)); + vec2 q = vec2(length(sdfPos.xy), -sdfPos.z); + float d = length(q - c * max(dot(q, c), 0.0)); + distance = d * (((q.x * c.y - q.y * c.x) < 0.0) ? -1.0 : 1.0); + break; + } + } + + if ((flags & SDF_FLAG_INVERT) != 0u) { + distance = -distance; + } + + if (smoothK == 0.0) { + if (distance < distanceAccum) { + distanceAccum = distance; + for (int i = 0; i < numValues; ++i) { + outValues[i] = values[i]; + } + } + } else { + float scaledDistance = -distance / smoothK; + if (scaledDistance > maxExp) { + float scale = exp(maxExp - scaledDistance); + distanceAccum *= scale; + for (int i = 0; i < numValues; ++i) { + outValues[i] *= scale; + } + maxExp = scaledDistance; + } + + float weight = exp(scaledDistance - maxExp); + distanceAccum += weight; + for (int i = 0; i < numValues; ++i) { + outValues[i] += weight * values[i]; + } + } + } + + if (smoothK == 0.0) { + return distanceAccum; + } else { + // Very distant SDFs may result in 0 accumulation + if (distanceAccum == 0.0) { + return 1.0 / 0.0; + } + for (int i = 0; i < numValues; ++i) { + outValues[i] /= distanceAccum; + } + return (-log(distanceAccum) - maxExp) * smoothK; + } + } + + float modulateSdfArray( + usampler2D sdfTexture, int numSdfs, int sdfFirst, int sdfCount, vec3 pos, + float smoothK, int numValues, out vec4 values[4], + float softEdge, bool invert + ) { + float distance = evaluateSdfArray(sdfTexture, numSdfs, sdfFirst, sdfCount, pos, smoothK, numValues, values); + if (invert) { + distance = -distance; + } + + return (softEdge == 0.0) ? ((distance < 0.0) ? 1.0 : 0.0) + : clamp(-distance / softEdge + 0.5, 0.0, 1.0); + } +`), SB = oA(` + const uint EDIT_FLAG_BLEND = 0xFFu; + const uint EDIT_BLEND_MULTIPLY = 0u; + const uint EDIT_BLEND_SET_RGB = 1u; + const uint EDIT_BLEND_ADD_RGBA = 2u; + const uint EDIT_FLAG_INVERT = 0x100u; + + void decodeEdit( + uvec4 packedEdit, out int sdfFirst, out int sdfCount, + out bool invert, out uint rgbaBlendMode, out float softEdge, out float sdfSmooth + ) { + rgbaBlendMode = packedEdit.x & EDIT_FLAG_BLEND; + invert = (packedEdit.x & EDIT_FLAG_INVERT) != 0u; + + sdfFirst = int(packedEdit.y & 0xFFFFu); + sdfCount = int(packedEdit.y >> 16u); + + softEdge = uintBitsToFloat(packedEdit.z); + sdfSmooth = uintBitsToFloat(packedEdit.w); + } + + void applyRgbaDisplaceEdit( + usampler2D sdfTexture, int numSdfs, int sdfFirst, int sdfCount, inout vec3 pos, + float smoothK, float softEdge, bool invert, uint rgbaBlendMode, inout vec4 rgba + ) { + vec4 values[4]; + float modulate = modulateSdfArray(sdfTexture, numSdfs, sdfFirst, sdfCount, pos, smoothK, 2, values, softEdge, invert); + // On Android, moving values[0] is necessary to work around a compiler bug. + vec4 sdfRgba = values[0]; + vec4 sdfDisplaceScale = values[1]; + + vec4 target; + switch (rgbaBlendMode) { + case EDIT_BLEND_MULTIPLY: + target = rgba * sdfRgba; + break; + case EDIT_BLEND_SET_RGB: + target = vec4(sdfRgba.rgb, rgba.a * sdfRgba.a); + break; + case EDIT_BLEND_ADD_RGBA: + target = rgba + sdfRgba; + break; + default: + // Debug output if blend mode not set + target = vec4(fract(pos), 1.0); + } + rgba = mix(rgba, target, modulate); + pos += sdfDisplaceScale.xyz * modulate; + } + + void applyPackedRgbaDisplaceEdit(uvec4 packedEdit, usampler2D sdfTexture, int numSdfs, inout vec3 pos, inout vec4 rgba) { + int sdfFirst, sdfCount; + bool invert; + uint rgbaBlendMode; + float softEdge, sdfSmooth; + decodeEdit(packedEdit, sdfFirst, sdfCount, invert, rgbaBlendMode, softEdge, sdfSmooth); + applyRgbaDisplaceEdit(sdfTexture, numSdfs, sdfFirst, sdfCount, pos, sdfSmooth, softEdge, invert, rgbaBlendMode, rgba); + } +`); +function Zh(Q, A, I, g) { + return new d({ + inTypes: { + gsplat: Z, + sdfArray: kB, + numEdits: "int", + rgbaDisplaceEdits: "uvec4" + }, + outTypes: { gsplat: Z }, + globals: () => [FB, SB], + inputs: { gsplat: Q, sdfArray: A, numEdits: I, rgbaDisplaceEdits: g }, + statements: ({ inputs: C, outputs: E }) => { + const { sdfArray: D, numEdits: i, rgbaDisplaceEdits: w } = C, { gsplat: s } = E; + return z(` + ${s} = ${C.gsplat}; + if (isGsplatActive(${s}.flags)) { + for (int editIndex = 0; editIndex < ${i}; ++editIndex) { + applyPackedRgbaDisplaceEdit( + ${w}[editIndex], ${D}.sdfTexture, ${D}.numSdfs, + ${s}.center, ${s}.rgba + ); + } + } + `); + } + }).outputs.gsplat; +} +function Vh(Q, A, I, g) { + return new d({ + inTypes: { + covsplat: eA, + sdfArray: kB, + numEdits: "int", + rgbaDisplaceEdits: "uvec4" + }, + outTypes: { covsplat: eA }, + globals: () => [FB, SB], + inputs: { covsplat: Q, sdfArray: A, numEdits: I, rgbaDisplaceEdits: g }, + statements: ({ inputs: C, outputs: E }) => { + const { sdfArray: D, numEdits: i, rgbaDisplaceEdits: w } = C, { covsplat: s } = E; + return z(` + ${s} = ${C.covsplat}; + if (isCovSplatActive(${s}.flags)) { + for (int editIndex = 0; editIndex < ${i}; ++editIndex) { + applyPackedRgbaDisplaceEdit( + ${w}[editIndex], ${D}.sdfTexture, ${D}.numSdfs, + ${s}.center, ${s}.rgba + ); + } + } + `); + } + }).outputs.covsplat; +} +const ZI = new Float32Array(1); +class Xh { + constructor(A) { + this.modifier = A, this.cache = /* @__PURE__ */ new Map(); + } + apply(A) { + let I = this.cache.get(A); + return I || (I = cA( + { index: "int" }, + { gsplat: Z }, + ({ index: g }) => { + const { gsplat: B } = A.apply({ index: g }); + return this.modifier.apply({ gsplat: B }); + } + ), this.cache.set(A, I)), I; + } +} +class XI { + // Create the dyno uniforms that parameterize the transform, setting them + // to initial values that are different from any valid transform. + constructor() { + this.scale = new pI({ value: Number.NEGATIVE_INFINITY }), this.rotate = new mI({ + value: new G.Quaternion( + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY + ) + }), this.translate = new DI({ + value: new G.Vector3( + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY + ) + }); + } + // Apply the transform to a Vec3 position in a dyno program. + apply(A) { + return ow(A, { + scale: this.scale, + rotate: this.rotate, + translate: this.translate + }); + } + applyDir(A) { + return sw(A, { + rotate: this.rotate + }); + } + // Apply the transform to a Gsplat in a dyno program. + applyGsplat(A) { + return CB(A, { + scale: this.scale, + rotate: this.rotate, + translate: this.translate + }); + } + // Update the uniforms to match the given transform matrix. + updateFromMatrix(A) { + const I = new G.Vector3(), g = new G.Quaternion(), B = new G.Vector3(); + A.decompose(B, g, I); + const C = (I.x + I.y + I.z) / 3; + let E = !1; + return C !== this.scale.value && (this.scale.value = C, E = !0), B.equals(this.translate.value) || (this.translate.value.copy(B), E = !0), g.equals(this.rotate.value) || (this.rotate.value.copy(g), E = !0), E; + } + // Update this transform to match the object's to-world transform. + update(A) { + return A.updateMatrixWorld(), this.updateFromMatrix(A.matrixWorld); + } +} +class Kg { + constructor() { + this.basis = new sB({ value: new G.Matrix3() }), this.offset = new DI({ value: new G.Vector3() }); + } + // Apply the transform to a Vec3 position in a dyno program. + apply(A) { + const I = kA(this.basis, A); + return qA(I, this.offset); + } + applyDir(A) { + return kA(this.basis, A); + } + // Apply the transform to a Gsplat in a dyno program. + applyCovSplat(A) { + return new d({ + inTypes: { covsplat: eA, basis: "mat3", offset: "vec3" }, + outTypes: { covsplat: eA }, + inputs: { covsplat: A, basis: this.basis, offset: this.offset }, + statements: ({ inputs: I, outputs: g }) => { + const { covsplat: B, basis: C, offset: E } = I; + return !B || !C || !E ? [`${g.covsplat}.flags = 0u;`] : z(` + ${g.covsplat}.flags = 0u; + if (isCovSplatActive(${B}.flags)) { + ${g.covsplat}.flags = ${B}.flags; + ${g.covsplat}.index = ${B}.index; + ${g.covsplat}.rgba = ${B}.rgba; + + ${g.covsplat}.center = ${C} * ${B}.center + ${E}; + + mat3 cov = mat3( + ${B}.xxyyzz.x, ${B}.xyxzyz.x, ${B}.xyxzyz.y, + ${B}.xyxzyz.x, ${B}.xxyyzz.y, ${B}.xyxzyz.z, + ${B}.xyxzyz.y, ${B}.xyxzyz.z, ${B}.xxyyzz.z + ); + cov = ${C} * cov * transpose(${C}); + ${g.covsplat}.xxyyzz = vec3(cov[0][0], cov[1][1], cov[2][2]); + ${g.covsplat}.xyxzyz = vec3(cov[0][1], cov[0][2], cov[1][2]); + } + `); + } + }).outputs.covsplat; + } + // Update the uniforms to match the given transform matrix. + updateFromMatrix(A) { + const I = new G.Matrix3().setFromMatrix4(A), g = new G.Vector3().setFromMatrixColumn(A, 3), B = !I.equals(this.basis.value) || !g.equals(this.offset.value); + return B && (this.basis.value.copy(I), this.offset.value.copy(g)), B; + } + // Update this transform to match the object's to-world transform. + update(A) { + return A.updateMatrixWorld(), this.updateFromMatrix(A.matrixWorld); + } +} +class PI extends G.Object3D { + constructor({ + numSplats: A, + generator: I, + covGenerator: g, + construct: B, + update: C + }) { + if (super(), this.numSplats = A ?? 0, this.generator = I, this.covGenerator = g, this.frameUpdate = C, this.version = 0, this.mappingVersion = 0, B) { + const E = B(this); + Object.assign(this, E); + } + } + updateVersion() { + this.version += 1; + } + updateMappingVersion() { + this.mappingVersion += 1, this.version += 1; + } + set needsUpdate(A) { + A && this.updateVersion(); + } +} +const QA = class QA { + constructor({ + extSplats: A, + covSplats: I + } = {}) { + if (this.time = 0, this.deltaTime = 0, this.viewToWorld = new G.Matrix4(), this.viewOrigin = new G.Vector3(), this.viewDirection = new G.Vector3(), this.maxSplats = 0, this.numSplats = 0, this.target = null, this.mapping = [], this.version = -1, this.mappingVersion = -1, this.readback = null, this.readbackSplats = [], !kC) + throw new Error("Spark requires THREE.js r179 or above"); + this.extSplats = A ?? !0, this.covSplats = I ?? !1; + } + dispose() { + this.target && (this.target.dispose(), this.target = null); + } + // Returns a THREE.DataArrayTexture representing the NewSplatAccumulator + // content as 2 x Uint32x4 data array textures (2048 x 2048 x 2048 in size) + getTextures() { + return this.target ? this.target.textures : QA.emptyTextures; + } + // Given an array of splatCounts (.numSplats for each + // SplatGenerator/SplatMesh in the scene), compute a + // "mapping layout" in the composite array of generated outputs. + generateMapping(A) { + let I = 0; + const g = A.map((B) => { + const C = I, E = Math.ceil(B / P) * P; + return I += E, { base: C, count: B }; + }); + return { maxSplats: I, mapping: g }; + } + // Ensures our NewSplatAccumulator.target render target has enough space + // to generate maxSplats total Gsplats, and reallocate if not large enough. + ensureGenerate({ maxSplats: A }) { + if (this.target && (A ?? 1) <= this.maxSplats) + return !1; + this.dispose(); + const I = BA(A ?? 1), { width: g, height: B, depth: C } = I; + if (this.maxSplats = I.maxSplats, this.target = new G.WebGLArrayRenderTarget(g, B, C, { + depthBuffer: !1, + stencilBuffer: !1, + generateMipmaps: !1, + magFilter: G.NearestFilter, + minFilter: G.NearestFilter, + format: G.RGBAIntegerFormat, + type: G.UnsignedIntType + }), this.target.scissorTest = !0, this.extSplats) { + const E = this.target.texture.clone(), D = this.target.texture.clone(); + D.format = G.RGBAFormat, D.type = G.UnsignedByteType, D.internalFormat = "RGBA8", this.target.textures = [this.target.texture, E, D]; + } else { + const E = this.target.texture.clone(); + E.format = G.RGBAFormat, E.type = G.UnsignedByteType, E.internalFormat = "RGBA8", this.target.textures = [this.target.texture, E]; + } + return !0; + } + saveRenderState(A) { + return { + target: A.getRenderTarget(), + xrEnabled: A.xr.enabled, + autoClear: A.autoClear + }; + } + resetRenderState(A, I) { + A.setRenderTarget(I.target), A.xr.enabled = I.xrEnabled, A.autoClear = I.autoClear; + } + // Get a program and THREE.RawShaderMaterial for a given GsplatGenerator, + // generating it if necessary and caching the result. + prepareProgramMaterial(A, I) { + const g = A ?? I; + if (!g) + throw new Error("Either generator or covGenerator must be provided"); + let B = QA.generatorProgram.get(g); + if (!B) { + const E = cA( + { index: "int" }, + {}, + ({ index: D }, i, { roots: w }) => { + if (A && (A.inputs.index = D), I && (I.inputs.index = D), this.extSplats) + if (this.covSplats) + if (I) { + const s = lQ(I.outputs.covsplat); + w.push(s); + } else if (A) { + const s = Zg(A.outputs.gsplat), o = lQ(s); + w.push(o); + } else + throw new Error("Generator must be provided"); + else if (A) { + const s = BE(A.outputs.gsplat); + w.push(s); + } else + throw new Error("Generator must be provided"); + else { + if (this.covSplats) { + let s; + if (I) + s = I.outputs.covsplat; + else if (A) + s = Zg(A.outputs.gsplat); + else + throw new Error("Generator must be provided"); + const o = iI( + Vg(s).outputs.center, + QA.viewCenterUniform + ), y = kA( + Vg(s).outputs.opacity, + v("float", 0.5) + ); + s = iB({ + covsplat: s, + center: o, + opacity: y + }); + const h = QE( + s, + v("vec4", [0, 1, pA, fA]) + ); + w.push(h); + } else if (A) { + const s = iI( + uA(A.outputs.gsplat).outputs.center, + QA.viewCenterUniform + ), o = kA( + uA(A.outputs.gsplat).outputs.opacity, + v("float", 0.5) + ), y = CI({ + gsplat: A.outputs.gsplat, + center: s, + opacity: o + }), h = wB( + y, + v("vec4", [0, 1, pA, fA]) + ); + w.push(h); + } else + throw new Error("Generator must be provided"); + if (!A) + throw new Error("Generator must be provided"); + } + if (A) { + const s = CE( + A.outputs.gsplat, + QA.viewCenterUniform, + QA.viewDirUniform, + QA.sortRadialUniform + ); + w.push(s); + } + if (I) { + const s = EE( + I.outputs.covsplat, + QA.viewCenterUniform, + QA.viewDirUniform, + QA.sortRadialUniform + ); + w.push(s); + } + } + ); + B = new CQ({ + graph: E, + inputs: { index: "_index" }, + outputs: {}, + template: this.extSplats ? QA.programExtTemplate : QA.programTemplate + // consoleLog: true, + }), QA.generatorProgram.set(g, B); + } + Object.assign(B.uniforms, { + targetLayer: { value: 0 }, + targetBase: { value: 0 }, + targetCount: { value: 0 } + }); + const C = B.prepareMaterial(); + return QA.fullScreenQuad.material = C, { program: B, material: C }; + } + generate({ + generator: A, + covGenerator: I, + base: g, + count: B, + renderer: C + }) { + if (!this.target) + throw new Error("Target must be initialized with ensureGenerate"); + if (g + B > this.maxSplats) + throw new Error("Base + count exceeds maxSplats"); + const { program: E, material: D } = this.prepareProgramMaterial( + A, + I + ); + E.update(); + const i = this.saveRenderState(C), w = Math.ceil((g + B) / P) * P, s = P * XA; + for (D.uniforms.targetBase.value = g, D.uniforms.targetCount.value = B; g < w; ) { + const o = Math.floor(g / s); + D.uniforms.targetLayer.value = o; + const y = o * s, h = Math.floor((g - y) / P), k = Math.min( + XA, + Math.ceil((w - y) / P) + ); + this.target.scissor.set( + 0, + h, + P, + k - h + ), C.setRenderTarget(this.target, o), C.xr.enabled = !1, C.autoClear = !1, QA.fullScreenQuad.render(C), g += P * (k - h); + } + return this.resetRenderState(C, i), { nextBase: w }; + } + prepareGenerate({ + renderer: A, + scene: I, + time: g, + camera: B, + sortRadial: C, + renderSize: E, + previous: D, + lodInstances: i + }) { + var M; + this.viewToWorld.copy(B.matrixWorld), B.getWorldPosition(this.viewOrigin), B.getWorldDirection(this.viewDirection), QA.viewCenterUniform.value.copy(this.viewOrigin), QA.viewDirUniform.value.copy(this.viewDirection), QA.sortRadialUniform.value = C, this.time = g, this.deltaTime = g - D.time; + const w = []; + I.traverse((c) => { + c instanceof PI && (!B.layers || B.layers.test(c.layers)) && w.push(c); + }); + const s = /* @__PURE__ */ new Set(); + I.traverseVisible((c) => { + if (c instanceof ag) { + let N = c.parent; + for (; N != null && !(N instanceof vA); ) + N = N.parent; + N == null && s.add(c); + } + }); + const o = Array.from(s); + for (const c of w) + try { + (M = c.frameUpdate) == null || M.call(c, { + renderer: A, + object: c, + time: this.time, + deltaTime: this.deltaTime, + viewToWorld: this.viewToWorld, + camera: B, + renderSize: E, + globalEdits: o, + lodIndices: i && c instanceof vA ? i.get(c) : void 0 + }); + } catch (N) { + console.error("frameUpdate error", N), c.generator = void 0, c.covGenerator = void 0, c.generatorError = N; + } + const y = []; + I.traverseVisible((c) => { + c instanceof PI && (!B.layers || B.layers.test(c.layers)) && y.push(c); + }); + const h = y.map( + (c) => c.numSplats + ), { maxSplats: k, mapping: R } = this.generateMapping(h), F = D.mapping.reduce((c, N) => (c.set(N.node, N), c), /* @__PURE__ */ new Map()); + this.mapping = [], this.numSplats = 0, R.forEach(({ base: c, count: N }, U) => { + const J = y[U], t = F.get(J); + t && t.count !== J.numSplats && J.updateMappingVersion(); + const { generator: H, covGenerator: K } = J; + if ((H || K) && N > 0) { + const { version: Y, mappingVersion: L } = J; + this.mapping.push({ + node: J, + generator: H, + covGenerator: K, + version: Y, + mappingVersion: L, + base: c, + count: N + }), this.numSplats = Math.max(this.numSplats, c + N); + } + }); + const { splatsUpdated: S, mappingUpdated: a } = D.checkVersions( + this.mapping + ); + return this.version = D.version + (S ? 1 : 0), this.mappingVersion = D.mappingVersion + (a ? 1 : 0), { + sameMapping: !a, + version: this.version, + mappingVersion: this.mappingVersion, + visibleGenerators: y, + generate: () => { + this.ensureGenerate({ maxSplats: k }); + for (const { node: c, base: N, count: U } of this.mapping) { + const { generator: J, covGenerator: t } = c; + (J || t) && U > 0 && this.generate({ generator: J, covGenerator: t, base: N, count: U, renderer: A }); + } + }, + readback: async () => { + const c = this.getTextures(); + this.readbackSplats.length === 0 && (this.readbackSplats = [ + new dA({ value: c[0], key: "extSplats" }), + new dA({ value: c[1], key: "extSplats" }) + ]), this.readbackSplats[0].value = c[0], this.readbackSplats[1].value = c[1], this.readback || (this.readback = new Ig({ renderer: A })); + const N = this.readback, U = this.extSplats ? 8 : 4, J = N.ensureBuffer( + this.numSplats * U, + new Uint32Array(0) + ), t = cA( + { index: "int" }, + { rgba8: "vec4" }, + ({ index: H }) => ({ rgba8: new d({ + inTypes: { + index: "int", + extSplats1: "usampler2DArray", + extSplats2: "usampler2DArray" + }, + outTypes: { rgba8: "vec4" }, + inputs: { + index: H, + extSplats1: this.readbackSplats[0], + extSplats2: this.readbackSplats[1] + }, + statements: ({ inputs: Y, outputs: L }) => this.extSplats ? z(` + int indexDiv8 = ${Y.index} >> 3; + ivec3 coord = splatTexCoord(indexDiv8); + uvec4 packed; + if ((${Y.index} & 4) == 0) { + packed = texelFetch(${Y.extSplats1}, coord, 0); + } else { + packed = texelFetch(${Y.extSplats2}, coord, 0); + } + + int indexMod4 = ${Y.index} & 3; + uint data = (indexMod4 == 0) ? packed.x + : (indexMod4 == 1) ? packed.y + : (indexMod4 == 2) ? packed.z + : packed.w; + ${L.rgba8} = uintToVec4(data); + `) : z(` + int indexDiv4 = ${Y.index} >> 2; + ivec3 coord = splatTexCoord(indexDiv4); + uvec4 packed = texelFetch(${Y.extSplats1}, coord, 0); + + int indexMod4 = ${Y.index} & 3; + uint data = (indexMod4 == 0) ? packed.x + : (indexMod4 == 1) ? packed.y + : (indexMod4 == 2) ? packed.z + : packed.w; + ${L.rgba8} = uintToVec4(data); + `) + }).outputs.rgba8 }) + ); + return await N.renderReadback({ + reader: t, + count: this.numSplats * U, + renderer: A, + readback: J + }); + } + }; + } + // Check if this accumulator has exactly the same generator mapping as + // the previous one. If so, we can reuse the Gsplat sort order. + checkVersions(A) { + if (this.mapping.length !== A.length) + return { splatsUpdated: !0, mappingUpdated: !0 }; + const I = this.mapping.some((B, C) => { + const E = A[C]; + return B.node !== E.node || B.base !== E.base || B.count !== E.count || B.mappingVersion !== E.mappingVersion; + }); + return I ? { splatsUpdated: !0, mappingUpdated: !0 } : { splatsUpdated: this.mapping.some((B, C) => B.version !== A[C].version), mappingUpdated: I }; + } +}; +QA.viewCenterUniform = new DI({ value: new G.Vector3() }), QA.viewDirUniform = new DI({ value: new G.Vector3() }), QA.sortRadialUniform = new bI({ value: !0 }), QA.emptyTexture = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 4), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGBAIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RGBA32UI", E.needsUpdate = !0, E; +})(), QA.emptyTextures = [QA.emptyTexture, QA.emptyTexture], QA.programExtTemplate = new Fg( + Ag().computeUvec4x2Vec4Template +), QA.programTemplate = new Fg( + Ag().computeUvec4Vec4Template +), QA.generatorProgram = /* @__PURE__ */ new WeakMap(), QA.fullScreenQuad = new QB( + new G.RawShaderMaterial({ visible: !1 }) +); +let qI = QA; +class Wh extends G.InstancedBufferGeometry { + constructor() { + super(), this.setAttribute("position", new G.BufferAttribute(jh, 3)), this.setIndex(new G.BufferAttribute(vh, 1)); + } +} +const jh = new Float32Array([ + -1, + -1, + 0, + 1, + -1, + 0, + 1, + 1, + 0, + -1, + 1, + 0 +]), vh = new Uint16Array([0, 1, 2, 0, 2, 3]), iA = class iA extends G.Mesh { + constructor(A) { + if (!A) + throw new Error("SparkRenderer options are required"); + if (!A.renderer) + throw new Error("renderer is required in SparkRenderer options"); + const I = iA.makeUniforms(); + Object.assign(I, A.extraUniforms ?? {}); + const g = Ag(), B = A.premultipliedAlpha ?? !0, C = new Wh(), E = new G.ShaderMaterial({ + glslVersion: G.GLSL3, + vertexShader: A.vertexShader ?? g.splatVertex, + fragmentShader: A.fragmentShader ?? g.splatFragment, + uniforms: I, + premultipliedAlpha: B, + transparent: A.transparent ?? !0, + depthTest: A.depthTest ?? !0, + depthWrite: A.depthWrite ?? !1, + side: G.DoubleSide, + allowOverride: !1 + }); + super(C, E), this.renderSize = new G.Vector2(), this.lastFrame = -1, this.updateTimeoutId = -1, this.orderingTexture = null, this.maxSplats = 0, this.activeSplats = 0, this.accumulators = [], this.sorting = !1, this.sortDirty = !1, this.lastSortTime = 0, this.sortWorker = null, this.sortTimeoutId = -1, this.sortedCenter = new G.Vector3().setScalar(Number.NEGATIVE_INFINITY), this.sortedDir = new G.Vector3().setScalar(0), this.readback32 = new Uint32Array(0), this.lastLodRaycastTime = 0, this.lodWorker = null, this.lodMeshes = [], this.lodDirty = !1, this.lodIds = /* @__PURE__ */ new Map(), this.lodIdToSplats = /* @__PURE__ */ new Map(), this.lodInitQueue = [], this.lodInstances = /* @__PURE__ */ new Map(), this.lodUpdates = [], this.lastTraverseTime = 0, this.pagerId = 0, this.superXY = 1, this.flushAfterGenerate = !1, this.flushAfterRead = !1, this.readPause = 1, this.sortPause = 0, this.sortDelay = 0, this.pageSizeWarning = !1, this.material = E, this.uniforms = I, this.frustumCulled = !1, this.renderer = A.renderer, this.onDirty = A.onDirty, this.dirty = !0, this.premultipliedAlpha = B, this.autoUpdate = A.autoUpdate ?? !0, this.preUpdate = A.preUpdate ?? !0, this.maxStdDev = A.maxStdDev ?? Math.sqrt(8), this.minPixelRadius = A.minPixelRadius ?? 0, this.maxPixelRadius = A.maxPixelRadius ?? 512, this.accumExtSplats = A.accumExtSplats ?? !1, this.covSplats = A.covSplats ?? !1, this.minAlpha = A.minAlpha ?? 0.5 * (1 / 255), this.enable2DGS = A.enable2DGS ?? !1, this.preBlurAmount = A.preBlurAmount ?? 0, this.blurAmount = A.blurAmount ?? 0.3, this.focalDistance = A.focalDistance ?? 0, this.apertureAngle = A.apertureAngle ?? 0, this.falloff = A.falloff ?? 1, this.clipXY = A.clipXY ?? 1.4, this.focalAdjustment = A.focalAdjustment ?? 1, this.encodeLinear = A.encodeLinear ?? !1, this.sortRadial = A.sortRadial ?? !0, this.minSortIntervalMs = A.minSortIntervalMs ?? 0, this.enableLod = A.enableLod ?? !0, this.enableDriveLod = A.enableDriveLod ?? this.enableLod, this.enableLodFetching = A.enableLodFetching ?? !0, this.lodSplatCount = A.lodSplatCount, this.lodSplatScale = A.lodSplatScale ?? 1, this.lodRenderScale = A.lodRenderScale ?? 1, this.lodInflate = A.lodInflate ?? !1, this.pagedExtSplats = A.pagedExtSplats ?? !1; + const D = Tg() ? Rg() ? 96 : 128 : 256; + this.maxPagedSplats = A.maxPagedSplats ?? D * 65536, this.numLodFetchers = A.numLodFetchers ?? 3, this.behindFoveate = A.behindFoveate ?? 0.2, this.coneFov0 = A.coneFov0 ?? 90, this.coneFov = A.coneFov ?? 120, this.coneFoveate = A.coneFoveate ?? 0.4, this.lodRaycast = A.lodRaycast === void 0 ? Tg() ? 1e4 : 25e3 : A.lodRaycast, this.lodRaycastIntervalMs = A.lodRaycastIntervalMs ?? 500, this.clock = A.clock ? IB(A.clock) : new G.Clock(); + const i = { + extSplats: this.accumExtSplats, + covSplats: this.covSplats + }; + if (this.display = new qI(i), this.current = this.display, this.accumulators.push(new qI(i)), this.accumulators.push(new qI(i)), A.target) { + const { + width: w, + height: s, + doubleBuffer: o, + superXY: y, + ...h + } = A.target, k = Math.max(1, Math.min(4, y ?? 1)); + if (w * k > 8192 || s * k > 8192) + throw new Error("Target size too large"); + this.superXY = k; + const R = w * k, F = s * k, S = { + format: G.RGBAFormat, + type: G.UnsignedByteType, + colorSpace: G.SRGBColorSpace, + ...h + }; + this.target = new G.WebGLRenderTarget( + R, + F, + S + ), o && (this.backTarget = new G.WebGLRenderTarget( + R, + F, + S + )), this.encodeLinear = A.encodeLinear ?? !0; + } + } + static makeUniforms() { + return { + // // number of active splats to render + // numSplats: { value: 0 }, + // Size of render viewport in pixels + renderSize: { value: new G.Vector2() }, + // Near and far plane distances + near: { value: 0.1 }, + far: { value: 1e3 }, + // SplatAccumulator to view transformation quaternion + renderToViewQuat: { value: new G.Quaternion() }, + // SplatAccumulator to view transformation translation + renderToViewPos: { value: new G.Vector3() }, + renderToViewBasis: { value: new G.Matrix3() }, + renderToViewOffset: { value: new G.Vector3() }, + // Maximum distance (in stddevs) from Gsplat center to render + maxStdDev: { value: 1 }, + // Minimum pixel radius for splat rendering + minPixelRadius: { value: 0 }, + // Maximum pixel radius for splat rendering + maxPixelRadius: { value: 512 }, + // Minimum alpha value for splat rendering + minAlpha: { value: 0.00196078431372549 }, + // Enable interpreting 0-thickness Gsplats as 2DGS + enable2DGS: { value: !1 }, + // Enable ray-splat max response evaluation + // enableRayEval: { value: false }, + // Inflate LoD splats so that opacity <= 1.0 + lodInflate: { value: !1 }, + // Add to projected 2D splat covariance diagonal (thickens and brightens) + preBlurAmount: { value: 0 }, + // Add to 2D splat covariance diagonal and adjust opacity (anti-aliasing) + blurAmount: { value: 0.3 }, + // Depth-of-field distance to focal plane + focalDistance: { value: 0 }, + // Full-width angle of aperture opening (in radians) + apertureAngle: { value: 0 }, + // Modulate Gaussian kernal falloff. 0 means "no falloff, flat shading", + // 1 is normal e^-x^2 falloff. + falloff: { value: 1 }, + // Clip Gsplats that are clipXY times beyond the +-1 frustum bounds + clipXY: { value: 1.4 }, + // Debug renderSize scale factor + focalAdjustment: { value: 1 }, + // Whether to encode Gsplat with linear RGB (for environment mapping) + encodeLinear: { value: !1 }, + // Back-to-front sort ordering of splat indices + ordering: { type: "t", value: iA.emptyOrdering }, + enableExtSplats: { value: !1 }, + enableCovSplats: { value: !1 }, + // Gsplat collection to render + extSplats: { type: "t", value: qI.emptyTexture }, + extSplats2: { type: "t", value: qI.emptyTexture }, + // Time in seconds for time-based effects + time: { value: 0 }, + // Delta time in seconds since last frame + deltaTime: { value: 0 }, + // Debug flag that alternates each frame + debugFlag: { value: !1 } + }; + } + dispose() { + this.target && (this.target.dispose(), this.target = void 0), this.backTarget && (this.backTarget.dispose(), this.backTarget = void 0), this.orderingTexture && (this.orderingTexture.dispose(), this.orderingTexture = null); + const A = /* @__PURE__ */ new Set(); + A.add(this.display), A.add(this.current); + for (const g of this.accumulators) + A.add(g); + for (const g of A) + g.dispose(); + const I = this.lodInstances.values(); + this.lodInstances.clear(); + for (const g of I) + g.texture.dispose(); + this.sortWorker && (this.sortWorker.dispose(), this.sortWorker = null), this.lodWorker && (this.lodWorker.dispose(), this.lodWorker = null), this.pager && (this.pager.dispose(), this.pager = void 0); + } + setDirty() { + var A; + this.dirty || (this.dirty = !0, (A = this.onDirty) == null || A.call(this)); + } + onBeforeRender(A, I, g) { + var h; + const B = iA.sparkOverride ?? this, C = A.info.render.frame, E = C !== B.lastFrame; + if (B.lastFrame = C, B.target) + B.renderSize.set(B.target.width, B.target.height); + else { + const k = A.getDrawingBufferSize(B.renderSize); + if (A.xr.isPresenting && k.x === 1 && k.y === 1) { + const R = (h = A.xr.getSession()) == null ? void 0 : h.renderState.baseLayer; + R && (k.x = R.framebufferWidth, k.y = R.framebufferHeight); + } + } + this.uniforms.renderSize.value.copy(B.renderSize); + const D = g; + this.uniforms.near.value = D.near, this.uniforms.far.value = D.far; + const i = this.geometry; + i.instanceCount = B.activeSplats; + const w = new G.Matrix4(); + this.display.extSplats || w.makeTranslation(B.display.viewOrigin); + const y = g.matrixWorld.clone().invert().multiply(w); + if (y.decompose( + this.uniforms.renderToViewPos.value, + this.uniforms.renderToViewQuat.value, + new G.Vector3() + ), this.uniforms.renderToViewBasis.value.setFromMatrix4(y), this.uniforms.maxStdDev.value = B.maxStdDev, this.uniforms.minPixelRadius.value = B.minPixelRadius, this.uniforms.maxPixelRadius.value = B.maxPixelRadius, this.uniforms.minAlpha.value = B.minAlpha, this.uniforms.enable2DGS.value = B.enable2DGS, this.uniforms.lodInflate.value = B.lodInflate, this.uniforms.preBlurAmount.value = B.preBlurAmount, this.uniforms.blurAmount.value = B.blurAmount, this.uniforms.focalDistance.value = B.focalDistance, this.uniforms.apertureAngle.value = B.apertureAngle, this.uniforms.falloff.value = B.falloff, this.uniforms.clipXY.value = B.clipXY, this.uniforms.focalAdjustment.value = B.focalAdjustment, this.uniforms.encodeLinear.value = B.encodeLinear, this.uniforms.ordering.value = B.orderingTexture ?? iA.emptyOrdering, this.uniforms.enableExtSplats.value = this.display.extSplats, this.uniforms.enableCovSplats.value = this.display.covSplats, this.display.extSplats) { + const k = B.display.getTextures(); + this.uniforms.extSplats.value = k[0], this.uniforms.extSplats2.value = k[1]; + } else { + const k = B.display.getTextures(); + this.uniforms.extSplats.value = k[0], this.uniforms.extSplats2.value = k[0]; + } + if (this.uniforms.time.value = B.display.time, this.uniforms.deltaTime.value = B.display.deltaTime, this.uniforms.debugFlag.value = performance.now() / 1e3 % 2 < 1, B.autoUpdate && E) { + const k = B.preUpdate && !A.xr.isPresenting, R = A.xr.isPresenting ? A.xr.getCamera() : g; + k ? B.updateInternal({ + scene: I, + camera: R, + autoUpdate: !0 + }) : B.updateTimeoutId === -1 && (B.updateTimeoutId = setTimeout(() => { + B.updateTimeoutId = -1, B.updateInternal({ + scene: I, + camera: R, + autoUpdate: !0 + }); + }, 1)); + } + B.dirty = !1; + } + clearSplats() { + this.activeSplats = 0, this.display.numSplats = 0, this.setDirty(); + } + async update({ + scene: A, + camera: I + }) { + await this.updateInternal({ scene: A, camera: I, autoUpdate: !1 }); + } + // /** + // * Provide additional cameras to prefetch paged splat chunks without + // * affecting main LOD selection. + // */ + // setPrefetchCameras(cameras?: THREE.Camera[], lodScaleMultiplier = 1.0) { + // const next = cameras?.filter(Boolean) ?? []; + // const sameCameras = + // this.prefetchCameras.length === next.length && + // this.prefetchCameras.every((camera, index) => camera === next[index]); + // if (sameCameras && this.prefetchLodScale === lodScaleMultiplier) { + // return; + // } + // this.prefetchCameras = next; + // this.prefetchLodScale = lodScaleMultiplier; + // this.invalidatePrefetchCache(); + // } + // /** + // * Invalidate the prefetch meshes cache. Call this when SplatMeshes are + // * added or removed from the scene. + // */ + // invalidatePrefetchCache() { + // this.prefetchMeshesCacheScene = undefined; + // } + async updateInternal({ + scene: A, + camera: I, + autoUpdate: g + }) { + const B = this.renderer, C = this.time ?? this.clock.getElapsedTime(), E = I.getWorldPosition(new G.Vector3()), D = I.getWorldDirection(new G.Vector3()), i = E.distanceTo(this.sortedCenter) > 1e-3 || D.dot(this.sortedDir) < 0.999, w = this.accumulators.pop(); + if (!w) + throw new Error("No next accumulator"); + if (w === this.current) + throw new Error( + "Next accumulator is the same as the current accumulator" + ); + const { version: s, mappingVersion: o, visibleGenerators: y, generate: h } = w.prepareGenerate({ + renderer: B, + scene: A, + time: C, + camera: I, + sortRadial: this.sortRadial ?? !0, + renderSize: this.renderSize, + previous: this.current, + lodInstances: this.enableLod ? this.lodInstances : void 0 + }); + let k = !0; + const R = i || s !== this.current.version, F = o !== this.display.mappingVersion; + g && !R && (k = !1), F && this.sorting && (k = !1), k ? (h(), this.flushAfterGenerate && B.getContext().flush(), this.display.mappingVersion === w.mappingVersion ? (this.accumulators.push(this.display), this.display = w) : this.display !== this.current && this.accumulators.push(this.current), this.current = w, this.sortDirty = !0, this.setDirty()) : this.accumulators.push(w), this.enableDriveLod && this.driveLod({ visibleGenerators: y, camera: I, scene: A }), await this.driveSort(); + } + async driveSort() { + if (this.sorting || !this.sortDirty) + return; + this.sortTimeoutId !== -1 && (clearTimeout(this.sortTimeoutId), this.sortTimeoutId = -1); + const A = performance.now(), I = this.lastSortTime ? this.lastSortTime + this.minSortIntervalMs : A; + if (A < I) { + this.sortTimeoutId = setTimeout(() => { + this.sortTimeoutId = -1, this.driveSort(); + }, I - A); + return; + } + this.sorting = !0, this.sortDirty = !1, this.lastSortTime = A, this.readPause > 0 && await new Promise((o) => setTimeout(o, this.readPause)); + const g = this.current; + this.sortedCenter.copy(g.viewOrigin), this.sortedDir.copy(g.viewDirection); + const { numSplats: B, maxSplats: C } = g, E = Math.max(1, Math.ceil(C / 16384)), D = E * 16384; + this.maxSplats = Math.max(this.maxSplats, D); + const i = new Uint32Array(this.maxSplats), w = Ig.ensureBuffer(C, this.readback32); + this.readback32 = w, await this.readbackDepth({ + current: g, + renderer: this.renderer, + numSplats: B, + readback: w + }), this.sortPause > 0 && await new Promise((o) => setTimeout(o, this.sortPause)), this.sortWorker || (this.sortWorker = new kg()); + const s = await this.sortWorker.call("sortSplats32", { + numSplats: B, + readback: w, + ordering: i + }); + if (this.sortDelay > 0 && await new Promise((o) => setTimeout(o, this.sortDelay)), this.readback32 = s.readback, this.activeSplats = s.activeSplats, this.orderingTexture && E > this.orderingTexture.image.height && (this.orderingTexture.dispose(), this.orderingTexture = null), this.orderingTexture) { + const o = this.renderer, y = o.getContext(); + if (!o.properties.has(this.orderingTexture)) + this.orderingTexture.needsUpdate = !0; + else { + const k = o.properties.get(this.orderingTexture).__webglTexture; + if (!k) + throw new Error("ordering texture not found"); + o.state.activeTexture(y.TEXTURE0), o.state.bindTexture(y.TEXTURE_2D, k), y.bindBuffer(y.PIXEL_UNPACK_BUFFER, null), y.pixelStorei(y.UNPACK_FLIP_Y_WEBGL, !1), y.texSubImage2D( + y.TEXTURE_2D, + 0, + 0, + 0, + 4096, + E, + y.RGBA_INTEGER, + y.UNSIGNED_INT, + // data, + s.ordering + ), o.state.bindTexture(y.TEXTURE_2D, null); + } + } else { + const o = new G.DataTexture( + s.ordering, + 4096, + E, + G.RGBAIntegerFormat, + G.UnsignedIntType + ); + o.internalFormat = "RGBA32UI", o.needsUpdate = !0, this.orderingTexture = o; + } + this.current.mappingVersion === g.mappingVersion && this.current.mappingVersion !== this.display.mappingVersion && (this.accumulators.push(this.display), this.display = this.current), this.sorting = !1, this.setDirty(), this.driveSort(); + } + ensureLodWorker() { + return this.lodWorker || (this.lodWorker = new kg()), this.lodWorker; + } + defaultSplatTarget() { + return AB() ? 5e5 : cC() ? 75e4 : $Q() ? 1e6 : Rg() ? 15e5 : 25e5; + } + driveLod({ + visibleGenerators: A, + camera: I, + scene: g + }) { + var h, k; + const B = this.defaultSplatTarget(), E = (this.lodSplatCount ?? B) * this.lodSplatScale; + let D = 0; + if (I instanceof G.PerspectiveCamera) + D = 2 * Math.tan(0.5 * I.fov * Math.PI / 180) / this.renderSize.y; + else if (I instanceof G.OrthographicCamera) { + const R = (I.top - I.bottom) / I.zoom, F = (I.right - I.left) / I.zoom, S = R / Math.max(1, this.renderSize.y), a = F / Math.max(1, this.renderSize.x); + D = Math.min(a, S); + } + D *= this.lodRenderScale; + const i = new G.Vector3(), w = new G.Quaternion(); + if (this.current.viewToWorld.decompose(i, w, new G.Vector3()), this.lodPosOverride && i.copy(this.lodPosOverride), this.lodQuatOverride && w.copy(this.lodQuatOverride).normalize(), this.lastLod) { + (this.lastLod.pixelScaleLimit !== D || this.lastLod.maxSplats !== E) && (this.lodDirty = !0); + const R = i.distanceTo(this.lastLod.pos), F = Math.max(0, 1 - R / 1), S = w.dot(this.lastLod.quat), a = Math.max(0, 1 - (1 - S) / 0.01); + F * a < 0.999 && (this.lodDirty = !0); + } + const s = this.enableLod ? A.filter((R) => { + var F, S; + return R instanceof vA && (((F = R.packedSplats) == null ? void 0 : F.lodSplats) || ((S = R.extSplats) == null ? void 0 : S.lodSplats) || R.paged) && R.enableLod !== !1; + }) : [], o = s.some((R) => R.paged); + this.lodMeshes.length !== s.length ? this.lodDirty = !0 : s.some( + (R, F) => R !== this.lodMeshes[F].mesh || R.version > this.lodMeshes[F].version + ) && (this.lodDirty = !0), this.lodMeshes = s.map((R) => ({ + mesh: R, + version: R.version + 1 + })), this.lodInitQueue = []; + const y = performance.now(); + for (const R of s) { + const F = ((h = R.packedSplats) == null ? void 0 : h.lodSplats) ?? ((k = R.extSplats) == null ? void 0 : k.lodSplats) ?? R.paged; + if (F) { + const S = this.lodIds.get(F); + S ? S.lastTouched = y : this.lodInitQueue.push(F); + } + } + this.ensureLodWorker().tryExclusive(async (R) => { + if (o && !this.pager) { + this.pager = new tI({ + renderer: this.renderer, + extSplats: this.pagedExtSplats, + maxSplats: this.maxPagedSplats, + numFetchers: this.numLodFetchers + }); + const { lodId: F } = await R.call("newLodTree", { + capacity: this.pager.maxSplats + }); + this.pagerId = F; + } + if (this.pager) + for (const { mesh: F } of this.lodMeshes) + F.paged && !F.paged.pager && (F.paged.pager = this.pager); + if (this.lodInitQueue.length > 0) { + const F = this.lodInitQueue; + for (this.lodInitQueue = []; F.length > 0; ) { + const S = F.shift(); + S && (await this.initLodTree(R, S), this.lodDirty = !0); + } + } + if (this.pager) { + const F = this.pager.consumeLodTreeUpdates(); + for (const { splats: S, page: a, chunk: M, numSplats: c, lodTree: N } of F) { + const U = this.lodIds.get(S); + U && (N && M === 0 && (U.rootPage = a), this.lodUpdates.push({ + lodId: U.lodId, + pageBase: a * this.pager.pageSplats, + chunkBase: M * this.pager.pageSplats, + count: c, + lodTreeData: N + })); + } + } + if (this.lodUpdates.length > 0) { + const F = this.lodUpdates; + this.lodUpdates = [], await R.call("updateLodTrees", { ranges: F }), this.lodDirty = !0; + } + if (this.lodDirty) { + const F = performance.now(), S = new G.Vector3(); + if (this.lastLod) { + const a = Math.max(1, F - this.lastLod.timestamp); + S.copy(i).sub(this.lastLod.pos).multiplyScalar(this.lastTraverseTime / a); + } + this.lastLod = { + pos: i, + quat: w, + pixelScaleLimit: D, + maxSplats: E, + timestamp: F + }, this.lodDirty = !1, await this.updateLodInstances( + R, + S, + s, + E, + i, + w, + D + ), this.currentLod = this.lastLod, this.setDirty(); + } + await this.cleanupLodTrees(R); + }); + } + async initLodTree(A, I) { + if (I instanceof $A || I instanceof GI) { + const { lodId: g } = await A.call("initLodTree", { + numSplats: I.numSplats ?? 0, + lodTree: I.extra.lodTree.slice() + }); + this.lodIds.set(I, { lodId: g, lastTouched: performance.now() }), this.lodIdToSplats.set(g, I); + } else { + const { lodId: g } = await A.call("newSharedLodTree", { + lodId: this.pagerId + }); + this.lodIds.set(I, { lodId: g, lastTouched: performance.now() }), this.lodIdToSplats.set(g, I); + } + } + async updateLodInstances(A, I, g, B, C, E, D) { + const i = /* @__PURE__ */ new Map(), w = new G.Matrix4().compose( + C, + E, + new G.Vector3().setScalar(1) + ), s = g.reduce( + (S, a) => { + var U, J; + i.set(a.uuid, a); + const M = a.matrixWorld.clone().invert().multiply(w), c = ((U = a.packedSplats) == null ? void 0 : U.lodSplats) ?? ((J = a.extSplats) == null ? void 0 : J.lodSplats) ?? a.paged; + if (!c) + return S; + const N = this.lodIds.get(c); + return !N || this.pager && a.paged && N.rootPage === void 0 || (S[a.uuid] = { + instanceId: a.uuid, + lodId: N.lodId, + rootPage: N.rootPage, + viewToObjectCols: M.elements, + lodScale: a.lodScale, + behindFoveate: a.behindFoveate ?? this.behindFoveate, + coneFov0: a.coneFov0 ?? this.coneFov0, + coneFov: a.coneFov ?? this.coneFov, + coneFoveate: a.coneFoveate ?? this.coneFoveate + }), S; + }, + {} + ), o = performance.now(), y = await A.call("traverseLodTrees", { + maxSplats: B, + pixelScaleLimit: D, + lastPixelLimit: this.lastPixelLimit, + instances: s + }); + this.lastTraverseTime = performance.now() - o; + const { keyIndices: h, chunks: k, pixelLimit: R } = y; + this.lastPixelLimit = R; + const F = Object.values(h).reduce( + (S, { numSplats: a }) => S + a, + 0 + ); + if (this.updateLodIndices(i, h), this.pager) { + this.pager.processUploads(); + const S = g.map((a) => { + if (!a.paged || !this.pager) + return null; + const M = a.getWorldPosition(new G.Vector3()); + return { + splats: a.paged, + distance: M.distanceTo(C) + }; + }).filter((a) => a !== null); + !this.pageSizeWarning && S.length > this.pager.maxPages && (this.pageSizeWarning = !0, console.warn( + `# paged SplatMeshes exceeds maxPages: ${S.length} > ${this.pager.maxPages}` + )), S.sort((a, M) => a.distance - M.distance), this.pager.fetchPriority = S.map(({ splats: a }) => ({ + splats: a, + chunk: 0 + })); + for (const [a, M] of k) { + const c = this.lodIdToSplats.get(a); + c instanceof Pg && M !== 0 && this.pager.fetchPriority.push({ splats: c, chunk: M }); + } + this.pager.autoDrive = this.enableLodFetching, this.enableLodFetching && this.pager.driveFetchers(); + } + if (this.lodRaycast && performance.now() - this.lastLodRaycastTime >= this.lodRaycastIntervalMs) { + this.lastLodRaycastTime = performance.now(); + const S = performance.now(), a = await A.call("traverseLodTrees", { + maxSplats: Math.min(this.lodRaycast, Math.round(F * 0.1)), + pixelScaleLimit: D, + instances: s + }); + performance.now() - S; + const { keyIndices: M } = a; + Object.values(M).reduce( + (c, { numSplats: N }) => c + N, + 0 + ); + for (const [c, N] of Object.entries(M)) { + const U = i.get(c); + U.raycastIndices = N; + } + } + } + async cleanupLodTrees(A) { + const g = performance.now(); + let B = null; + for (const [C, E] of this.lodIds.entries()) + (B == null || E.lastTouched < B.lastTouched) && (B = { + splats: C, + lastTouched: E.lastTouched, + lodId: E.lodId + }); + if (!(!B || B.lastTouched > g - 3e3)) { + this.lodIds.delete(B.splats), this.lodIdToSplats.delete(B.lodId); + for (const [C, E] of this.lodInstances.entries()) + E.lodId === B.lodId && (E.texture.dispose(), this.lodInstances.delete(C)); + await A.call("disposeLodTree", { lodId: B.lodId }); + } + } + updateLodIndices(A, I) { + for (const [g, B] of Object.entries(I)) { + const { lodId: C, numSplats: E, indices: D } = B, i = A.get(g); + if (i.paged) + i.paged.update(E, D); + else { + let w = this.lodInstances.get(i); + w && D.length > w.indices.length && (w.texture.dispose(), w = void 0); + const s = Math.ceil(D.length / 16384); + if (w) { + w.numSplats = E; + const o = this.renderer, y = o.getContext(); + if (o.properties.has(w.texture)) { + const k = o.properties.get(w.texture).__webglTexture; + if (!k) + throw new Error("lodIndices texture not found"); + o.state.activeTexture(y.TEXTURE0), o.state.bindTexture(y.TEXTURE_2D, k), y.bindBuffer(y.PIXEL_UNPACK_BUFFER, null), y.pixelStorei(y.UNPACK_FLIP_Y_WEBGL, !1), y.texSubImage2D( + y.TEXTURE_2D, + 0, + 0, + 0, + 4096, + s, + y.RGBA_INTEGER, + y.UNSIGNED_INT, + D + ), o.state.bindTexture(y.TEXTURE_2D, null); + } + } else { + const o = s * 16384; + if (D.length !== o) + throw new Error("Indices length != capacity"); + const y = new G.DataTexture( + D, + 4096, + s, + G.RGBAIntegerFormat, + G.UnsignedIntType + ); + y.internalFormat = "RGBA32UI", y.needsUpdate = !0, w = { lodId: C, numSplats: E, indices: D, texture: y }, this.lodInstances.set(i, w); + } + } + i.updateMappingVersion(); + } + } + async readbackDepth({ + current: A, + renderer: I, + numSplats: g, + readback: B + }) { + if (!I) + throw new Error("No renderer"); + if (!A.target) + throw new Error("No target"); + const C = Math.ceil(g / P) * P; + if (B.byteLength < C * 4) + throw new Error( + `Readback buffer too small: ${B.byteLength} < ${C * 4}` + ); + const E = new Uint8Array(B.buffer), D = this.saveRenderState(I), i = P * XA; + let w = 0; + const s = []; + for (; w < g; ) { + const o = Math.floor(w / i), y = o * i, h = Math.min( + XA, + Math.ceil((g - y) / P) + ), k = P * h * 4, R = E.subarray( + y * 4, + y * 4 + k + ); + I.setRenderTarget(A.target, o); + const F = I.readRenderTargetPixelsAsync( + A.target, + 0, + 0, + P, + h, + R, + void 0, + A.extSplats ? 2 : 1 + ); + s.push(F), this.flushAfterRead && I.getContext().flush(), w += P * h; + } + return this.resetRenderState(I, D), Promise.all(s).then(() => B); + } + saveRenderState(A) { + return { + target: A.getRenderTarget(), + xrEnabled: A.xr.enabled, + autoClear: A.autoClear + }; + } + resetRenderState(A, I) { + A.setRenderTarget(I.target), A.xr.enabled = I.xrEnabled, A.autoClear = I.autoClear; + } + render(A, I) { + try { + iA.sparkOverride = this, this.renderer.render(A, I); + } finally { + iA.sparkOverride = void 0; + } + } + renderTarget({ + scene: A, + camera: I + }) { + const g = this.backTarget ?? this.target; + if (!g) + throw new Error("No target"); + const B = this.renderer.getRenderTarget(); + try { + this.renderer.setRenderTarget(g), iA.sparkOverride = this, this.renderer.render(A, I); + } finally { + iA.sparkOverride = void 0, this.renderer.setRenderTarget(B); + } + return g !== this.target && ([this.target, this.backTarget] = [this.backTarget, this.target]), g; + } + // Read back the previously rendered target image as a Uint8Array of packed + // RGBA values (in that order). Subsequent calls to this.readTarget() + // will reuse the same buffers to minimize memory allocations. + async readTarget() { + if (!this.target) + throw new Error("Must initialize with target"); + const { width: A, height: I } = this.target, g = A * I * 4; + (!this.superPixels || this.superPixels.length < g) && (this.superPixels = new Uint8Array(g)); + const B = this.superPixels; + await this.renderer.readRenderTargetPixelsAsync( + this.target, + 0, + 0, + A, + I, + B + ); + const { superXY: C } = this; + if (C === 1) + return B; + const E = A / C, D = I / C, i = E * D * 4; + (!this.targetPixels || this.targetPixels.length < i) && (this.targetPixels = new Uint8Array(i)); + const w = this.targetPixels, s = C * C; + for (let o = 0; o < D; o++) { + const y = o * E; + for (let h = 0; h < E; h++) { + const k = h * C; + let R = 0, F = 0, S = 0, a = 0; + for (let c = 0; c < C; c++) { + const N = (o * C + c) * A; + for (let U = 0; U < C; U++) { + const J = (N + k + U) * 4; + R += B[J], F += B[J + 1], S += B[J + 2], a += B[J + 3]; + } + } + const M = (y + h) * 4; + w[M] = R / s, w[M + 1] = F / s, w[M + 2] = S / s, w[M + 3] = a / s; + } + } + return w; + } + async renderReadTarget({ + scene: A, + camera: I + }) { + return this.renderTarget({ scene: A, camera: I }), this.readTarget(); + } + // Renders out the scene to a cube map that can be used for + // Image-based lighting or similar applications. First optionally updates Gsplats, + // sorts them with respect to the provided worldCenter, renders 6 cube faces. + async renderCubeMap({ + scene: A, + worldCenter: I, + size: g = 256, + near: B = 0.1, + far: C = 1e3, + hideObjects: E = [], + update: D = !0, + filter: i = !1 + }) { + if (!iA.cubeRender || iA.cubeRender.target.width !== g || iA.cubeRender.near !== B || iA.cubeRender.far !== C) { + iA.cubeRender && iA.cubeRender.target.dispose(); + const y = new G.WebGLCubeRenderTarget(g, { + format: G.RGBAFormat, + type: G.UnsignedByteType, + generateMipmaps: i, + minFilter: i ? G.LinearMipMapLinearFilter : G.LinearFilter, + magFilter: G.LinearFilter, + colorSpace: i ? G.LinearSRGBColorSpace : G.SRGBColorSpace + }), h = new G.CubeCamera(B, C, y); + iA.cubeRender = { target: y, cubeCamera: h, near: B, far: C }; + } + const { target: w, cubeCamera: s } = iA.cubeRender; + s.position.copy(I); + const o = /* @__PURE__ */ new Map(); + for (const y of E) + o.set(y, y.visible), y.visible = !1; + if (D) { + const y = new G.Camera(); + y.position.copy(I), await this.update({ scene: A, camera: y }); + } + try { + iA.sparkOverride = this, s.update(this.renderer, A); + } finally { + iA.sparkOverride = void 0; + } + for (const [y, h] of o.entries()) + y.visible = h; + return w.texture; + } + async readCubeTargets() { + if (!iA.cubeRender) + throw new Error("No cube render"); + const A = iA.cubeRender.target.texture, I = [], g = []; + for (let B = 0; B < A.images.length; ++B) { + const { width: C, height: E } = A.images[B], D = C * E * 4, i = new Uint8Array(D); + g.push(i); + const w = this.renderer.readRenderTargetPixelsAsync( + iA.cubeRender.target, + 0, + 0, + C, + E, + i, + B + ); + I.push(w); + } + return await Promise.all(I), g; + } + // Renders out the scene to an environment map that can be used for + // Image-based lighting or similar applications. First optionally updates Gsplats, + // sorts them with respect to the provided worldCenter, renders 6 cube faces, + // then pre-filters them using THREE.PMREMGenerator and returns a THREE.Texture + // that can assigned directly to a THREE.MeshStandardMaterial.envMap property. + async renderEnvMap({ + scene: A, + worldCenter: I, + size: g = 256, + near: B = 0.1, + far: C = 1e3, + hideObjects: E = [], + update: D = !0 + }) { + var w; + const i = await this.renderCubeMap({ + scene: A, + worldCenter: I, + size: g, + near: B, + far: C, + hideObjects: E, + update: D, + filter: !0 + }); + return iA.pmrem || (iA.pmrem = new G.PMREMGenerator(this.renderer)), (w = iA.pmrem) == null ? void 0 : w.fromCubemap(i).texture; + } + // Utility function to recursively set the envMap property for any + // THREE.MeshStandardMaterial within the subtree of root. + recurseSetEnvMap(A, I) { + A.traverse((g) => { + if (g instanceof G.Mesh) + if (Array.isArray(g.material)) + for (const B of g.material) + B instanceof G.MeshStandardMaterial && (B.envMap = I); + else + g.material instanceof G.MeshStandardMaterial && (g.material.envMap = I); + }); + } + async getLodTreeLevel(A, I, g = !1) { + var E, D; + const B = this.lodInstances.get(A); + if (!B) + return null; + const C = await this.ensureLodWorker().exclusive(async (i) => await i.call("getLodTreeLevel", { + lodId: B.lodId, + level: I + })); + if ((E = A.packedSplats) != null && E.lodSplats) { + const i = A.packedSplats.lodSplats.extractSplats( + C.indices, + g + ); + return new vA({ packedSplats: i }); + } + if ((D = A.extSplats) != null && D.lodSplats) { + const i = A.extSplats.lodSplats.extractSplats( + C.indices, + g + ); + return new vA({ extSplats: i }); + } + throw new Error( + "Only LoD-enabled PackedSplats and ExtSplats are supported" + ); + } +}; +iA.emptyOrdering = (() => { + const I = new Uint32Array(16384), g = new G.DataTexture(I, 4096, 1); + return g.format = G.RGBAIntegerFormat, g.type = G.UnsignedIntType, g.internalFormat = "RGBA32UI", g.needsUpdate = !0, g; +})(), iA.cubeRender = null, iA.pmrem = null; +let Xg = iA; +class Pg { + constructor(A) { + var I; + if (this.pager = A.pager, this.rootUrl = A.rootUrl ?? "", this.requestHeader = A.requestHeader, this.withCredentials = A.withCredentials, this.numSh = 0, this.maxSh = ((I = A.pager) == null ? void 0 : I.maxSh) ?? 3, this.numSplats = 0, this.dynoNumSplats = new EI({ value: 0 }), this.dynoIndices = new BQ({ + value: tI.emptyIndicesTexture + }), this.rgbMinMaxLnScaleMinMax = new mI({ + value: new G.Vector4(0, 1, pA, fA) + }), this.lodOpacity = new bI({ + value: !1 + }), this.dynoNumSh = new EI({ value: 0 }), this.shMax = new DI({ value: new G.Vector3() }), this.fileBytes = A.fileBytes, this.fileType = A.fileType, !this.fileType && this.fileBytes && (this.fileType = NB(this.fileBytes)), !this.fileType && this.rootUrl && (this.fileType = cB(this.rootUrl)), !this.fileType) + throw new Error("Unable to determine file type"); + this.fileType === hA.RAD && (this.radMetaPromise = this.getRadMeta()); + } + dispose() { + this.dynoIndices.value !== tI.emptyIndicesTexture && (this.dynoIndices.value.dispose(), this.dynoIndices.value = tI.emptyIndicesTexture); + } + setMaxSh(A) { + this.maxSh = A; + } + getRadMeta() { + return this.radMetaPromise ? this.radMetaPromise : (this.radMetaPromise = (async () => { + if (await zh, this.fileBytes) { + const A = nB(this.fileBytes.slice(0, 1048576)); + if (A) + return A; + throw new Error("Failed to decode RAD header"); + } + if (!this.rootUrl) + throw new Error("No url or fileBytes provided"); + for (const A of [65536, 256 * 1024, 1024 * 1024]) { + const I = await cQ({ + url: this.rootUrl, + requestHeader: this.requestHeader, + withCredentials: this.withCredentials, + offset: 0, + bytes: A + }), g = nB(I); + if (g) + return g; + } + throw new Error("Failed to decode RAD header"); + })().then((A) => A), this.radMetaPromise.catch((A) => { + console.error(A); + }), this.radMetaPromise); + } + chunkUrl(A) { + return this.rootUrl.replace(/-lod-0\./, `-lod-${A}.`); + } + async fetchDecodeChunk(A) { + let I; + if (this.fileType === hA.RAD) { + const { meta: g, chunksStart: B } = await this.getRadMeta(); + if (A < 0 || A >= g.chunks.length) + throw new Error( + `Chunk index out of range: ${A} (max: ${g.chunks.length - 1})` + ); + let { offset: C, bytes: E, filename: D } = g.chunks[A]; + if (D) { + if (this.fileBytes) + throw new Error("Chunked RAD file not supported with fileBytes"); + const i = new URL( + this.rootUrl, + window.location.href + ).toString(), w = new URL(D, i).toString(); + I = await cQ({ + url: w, + requestHeader: this.requestHeader, + withCredentials: this.withCredentials + }); + } else if (C += B, this.fileBytes) { + if (C < 0 || C + E > this.fileBytes.length) + throw new Error( + `Invalid chunk offset or bytes: ${C} + ${E} > ${this.fileBytes.length}` + ); + I = this.fileBytes.slice(C, C + E); + } else if (this.rootUrl) + I = await cQ({ + url: this.rootUrl, + requestHeader: this.requestHeader, + withCredentials: this.withCredentials, + offset: C, + bytes: E + }); + else + throw new Error("No url or fileBytes provided"); + } else if (!this.fileBytes) if (this.rootUrl) { + const g = this.chunkUrl(A), B = new Request(g, { + headers: this.requestHeader ? new Headers(this.requestHeader) : void 0, + credentials: this.withCredentials ? "include" : "same-origin" + }), C = await fetch(B); + if (!C.ok || !C.body) + throw new Error( + `Failed to fetch "${g}": ${C.status} ${C.statusText}` + ); + I = new Uint8Array(await C.arrayBuffer()); + } else + throw new Error("No url or fileBytes provided"); + return await gQ.withWorker(async (g) => { + var D, i, w, s, o; + if (!this.pager) + throw new Error("PagedSplats.pager not set"); + if (!this.pager.extSplats) { + const h = (await g.call("loadPackedSplats", { + fileBytes: I, + pathName: this.chunkUrl(A), + sh1Codes: (D = this.sh1Codes) == null ? void 0 : D.slice(), + sh2Codes: (i = this.sh2Codes) == null ? void 0 : i.slice(), + sh3Codes: (w = this.sh3Codes) == null ? void 0 : w.slice() + })).lodSplats; + return this.splatEncoding || (this.splatEncoding = h.splatEncoding, this.numSh = h.extra.sh3 ? 3 : h.extra.sh2 ? 2 : h.extra.sh1 ? 1 : 0, this.rgbMinMaxLnScaleMinMax.value.set( + this.splatEncoding.rgbMin ?? 0, + this.splatEncoding.rgbMax ?? 1, + this.splatEncoding.lnScaleMin ?? pA, + this.splatEncoding.lnScaleMax ?? fA + ), this.lodOpacity.value = this.splatEncoding.lodOpacity ?? !1, this.shMax.value.set( + this.splatEncoding.sh1Max ?? 1, + this.splatEncoding.sh2Max ?? 1, + this.splatEncoding.sh3Max ?? 1 + )), this.sh1Codes = h.extra.sh1Codes ?? this.sh1Codes, this.sh2Codes = h.extra.sh2Codes ?? this.sh2Codes, this.sh3Codes = h.extra.sh3Codes ?? this.sh3Codes, h; + } + const B = this.sh3Codes, E = (await g.call("loadExtSplats", { + fileBytes: I, + pathName: this.chunkUrl(A), + sh1Codes: (s = this.sh1Codes) == null ? void 0 : s.slice(), + sh2Codes: (o = this.sh2Codes) == null ? void 0 : o.slice(), + sh3Codes: B ? [B[0].slice(), B[1].slice()] : void 0 + })).lodSplats; + return this.splatEncoding || (this.splatEncoding = cg, this.numSh = E.extra.sh3a && E.extra.sh3b ? 3 : E.extra.sh2 ? 2 : E.extra.sh1 ? 1 : 0), this.sh1Codes = E.extra.sh1Codes ?? this.sh1Codes, this.sh2Codes = E.extra.sh2Codes ?? this.sh2Codes, this.sh3Codes = E.extra.sh3Codes ?? this.sh3Codes, E; + }); + } + update(A, I) { + if (!this.pager) + throw new Error("PagedSplats.pager not set"); + const g = this.pager.renderer; + this.numSplats = A, this.dynoNumSplats.value = this.numSplats; + const B = Math.ceil(A / 16384); + let C = this.dynoIndices.value === tI.emptyIndicesTexture ? void 0 : this.dynoIndices.value; + if (C && B > C.image.height && (C.dispose(), C = void 0), !C) + C = new G.DataTexture( + I, + 4096, + B, + G.RGBAIntegerFormat, + G.UnsignedIntType + ), C.internalFormat = "RGBA32UI", C.needsUpdate = !0, g.initTexture(C), this.dynoIndices.value = C; + else { + C.image.data.set(I.subarray(0, A)); + const D = g.getContext(); + g.state.activeTexture(D.TEXTURE0), g.state.bindTexture( + D.TEXTURE_2D, + fw(g, C) + ), D.bindBuffer(D.PIXEL_UNPACK_BUFFER, null), D.pixelStorei(D.UNPACK_FLIP_Y_WEBGL, !1), D.texSubImage2D( + D.TEXTURE_2D, + 0, + 0, + 0, + 4096, + B, + D.RGBA_INTEGER, + D.UNSIGNED_INT, + I + ), g.state.bindTexture(D.TEXTURE_2D, null); + } + } + prepareFetchSplat() { + } + getNumSplats() { + return this.numSplats; + } + hasRgbDir() { + return this.pager ? Math.min(this.numSh, this.pager.maxSh) > 0 : !1; + } + getNumSh() { + return this.numSh; + } + fetchSplat({ + index: A, + viewOrigin: I + }) { + if (!this.pager) + throw new Error("PagedSplats.pager not set"); + const g = this.pager.readIndex.apply({ + index: A, + numSplats: this.dynoNumSplats, + indices: this.dynoIndices + }).index; + return this.pager.extSplats ? this.hasRgbDir() && I ? (this.dynoNumSh.value = Math.min(this.numSh, this.maxSh, this.pager.maxSh), this.pager.readSplatExtDir.apply({ + index: g, + viewOrigin: I, + numSh: this.dynoNumSh + }).gsplat) : this.pager.readSplatExt.apply({ index: g }).gsplat : this.hasRgbDir() && I ? (this.dynoNumSh.value = Math.min( + this.numSh, + this.maxSh, + this.pager.maxSh + ), this.pager.readSplatDir.apply({ + index: g, + rgbMinMaxLnScaleMinMax: this.rgbMinMaxLnScaleMinMax, + lodOpacity: this.lodOpacity, + viewOrigin: I, + numSh: this.dynoNumSh, + shMax: this.shMax + }).gsplat) : this.pager.readSplat.apply({ + index: g, + rgbMinMaxLnScaleMinMax: this.rgbMinMaxLnScaleMinMax, + lodOpacity: this.lodOpacity + }).gsplat; + } +} +const l = class l { + constructor(A) { + this.fetchPause = 0, this.splatsChunkToPage = /* @__PURE__ */ new Map(), this.pageToSplatsChunk = [], this.renderer = A.renderer, this.extSplats = A.extSplats ?? !1, this.pageSplats = 65536, this.maxSplats = A.maxSplats ?? 16777216, this.maxPages = Math.ceil(this.maxSplats / this.pageSplats), this.maxSplats = this.maxPages * this.pageSplats, this.maxSh = A.maxSh ?? 3, this.curSh = 0, this.autoDrive = A.autoDrive ?? !0, this.numFetchers = A.numFetchers ?? 3, this.splatsChunkToPage = /* @__PURE__ */ new Map(), this.pageToSplatsChunk = new Array(this.maxPages), this.pageFreelist = Array.from({ length: this.maxPages }, (I, g) => g), this.pageLru = /* @__PURE__ */ new Set(), this.freeablePages = [], this.newUploads = [], this.readyUploads = [], this.lodTreeUpdates = [], this.fetchers = [], this.fetched = [], this.fetchPriority = [], this.packedTexture = new dA({ + value: this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ) + }), this.extTexture = new dA({ + value: this.extSplats ? this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ) : l.emptyExtTexture + }), this.sh1Texture = new dA({ + value: this.extSplats ? l.emptyExtSh1Texture : l.emptySh1Texture + }), this.sh2Texture = new dA({ + value: this.extSplats ? l.emptyExtSh2Texture : l.emptySh2Texture + }), this.sh3Texture = new dA({ + value: this.extSplats ? l.emptyExtSh3Texture : l.emptySh3Texture + }), this.sh3TextureB = new dA({ + value: l.emptyExtSh3BTexture + }), this.readIndex = cA( + { index: "int", numSplats: "int", indices: "usampler2D" }, + { index: "int" }, + ({ index: I, numSplats: g, indices: B }) => new d({ + inTypes: { + index: "int", + numSplats: "int", + indices: "usampler2D" + }, + outTypes: { index: "int" }, + inputs: { + index: I, + numSplats: g, + indices: B + }, + statements: ({ inputs: C, outputs: E }) => z(` + if (${C.index} >= ${C.numSplats}) { + return; + } + + ivec2 indexCoord = ivec2((${C.index} >> 2) & 4095, ${C.index} >> 14); + uint index = texelFetch(${C.indices}, indexCoord, 0)[${C.index} & 3]; + ${E.index} = int(index); + `) + }).outputs + ), this.readSplat = cA( + { index: "int", rgbMinMaxLnScaleMinMax: "vec4", lodOpacity: "bool" }, + { gsplat: Z }, + ({ index: I, rgbMinMaxLnScaleMinMax: g, lodOpacity: B }) => new d({ + inTypes: { + index: "int", + packedTexture: "usampler2DArray", + rgbMinMaxLnScaleMinMax: "vec4", + lodOpacity: "bool" + }, + outTypes: { gsplat: Z }, + inputs: { + index: I, + packedTexture: this.packedTexture, + rgbMinMaxLnScaleMinMax: g, + lodOpacity: B + }, + globals: () => [HA], + statements: ({ inputs: C, outputs: E }) => z(` + int index = ${C.index}; + ivec3 splatCoord = pagedSplatTexCoord(index); + uvec4 packed = texelFetch(${C.packedTexture}, splatCoord, 0); + + unpackSplatEncoding(packed, ${E.gsplat}.center, ${E.gsplat}.scales, ${E.gsplat}.quaternion, ${E.gsplat}.rgba, ${C.rgbMinMaxLnScaleMinMax}); + if ((${E.gsplat}.rgba.a == 0.0) || all(equal(${E.gsplat}.scales, vec3(0.0, 0.0, 0.0)))) { + return; + } + + ${E.gsplat}.index = index; + ${E.gsplat}.flags = GSPLAT_FLAG_ACTIVE; + if (${C.lodOpacity}) { + ${E.gsplat}.rgba.a *= 2.0; + } + `) + }).outputs + ), this.readSplatDir = cA( + { + index: "int", + rgbMinMaxLnScaleMinMax: "vec4", + lodOpacity: "bool", + viewOrigin: "vec3", + numSh: "int", + shMax: "vec3" + }, + { gsplat: Z }, + ({ + index: I, + rgbMinMaxLnScaleMinMax: g, + lodOpacity: B, + viewOrigin: C, + numSh: E, + shMax: D + }) => { + if (!I || !g || !B || !C || !E || !D) + throw new Error("index and viewOrigin are required"); + let i = this.readSplat.apply({ + index: I, + rgbMinMaxLnScaleMinMax: g, + lodOpacity: B + }).gsplat; + const w = uA(i).outputs.center, s = Sg(iI(w, C)); + let o = uw({ + coord: xQ(I), + viewDir: s, + numSh: E, + sh1Texture: this.sh1Texture, + sh2Texture: this.sh2Texture, + sh3Texture: this.sh3Texture, + shMax: D + }).rgb; + return o = qA(o, uA(i).outputs.rgb), i = CI({ gsplat: i, rgb: o }), { gsplat: i }; + } + ), this.readSplatExt = cA( + { index: "int" }, + { gsplat: Z }, + ({ index: I }) => new d({ + inTypes: { + index: "int", + extTexture1: "usampler2DArray", + extTexture2: "usampler2DArray" + }, + outTypes: { gsplat: Z }, + inputs: { + index: I, + extTexture1: this.packedTexture, + extTexture2: this.extTexture + }, + globals: () => [HA], + statements: ({ inputs: g, outputs: B }) => z(` + int index = ${g.index}; + ivec3 splatCoord = ivec3(index & 255, (index >> 8) & 255, index >> 16); + uvec4 ext1 = texelFetch(${g.extTexture1}, splatCoord, 0); + float alpha = unpackSplatExtAlpha(ext1); + if (alpha == 0.0) { + return; + } + + uvec4 ext2 = texelFetch(${g.extTexture2}, splatCoord, 0); + unpackSplatExt(ext1, ext2, ${B.gsplat}.center, ${B.gsplat}.scales, ${B.gsplat}.quaternion, ${B.gsplat}.rgba); + if (all(equal(${B.gsplat}.scales, vec3(0.0, 0.0, 0.0)))) { + return; + } + + ${B.gsplat}.index = index; + ${B.gsplat}.flags = GSPLAT_FLAG_ACTIVE; + `) + }).outputs + ), this.readSplatExtDir = cA( + { + index: "int", + viewOrigin: "vec3", + numSh: "int" + }, + { gsplat: Z }, + ({ index: I, viewOrigin: g, numSh: B }) => { + if (!I || !g || !B) + throw new Error("index and viewOrigin are required"); + let C = this.readSplatExt.apply({ index: I }).gsplat; + const E = uA(C).outputs.center, D = Sg(iI(E, g)); + let i = xw({ + coord: xQ(I), + viewDir: D, + numSh: B, + sh1Texture: this.sh1Texture, + sh2Texture: this.sh2Texture, + sh3TextureA: this.sh3Texture, + sh3TextureB: this.sh3TextureB + }).rgb; + return i = qA(i, uA(C).outputs.rgb), C = CI({ gsplat: C, rgb: i }), { gsplat: C }; + } + ); + } + dispose() { + this.autoDrive = !1, this.numFetchers = 0, this.packedTexture.value.dispose(), this.extTexture.value !== l.emptyExtTexture && this.extTexture.value.dispose(), this.extSplats ? (this.sh1Texture.value !== l.emptyExtSh1Texture && this.sh1Texture.value.dispose(), this.sh2Texture.value !== l.emptyExtSh2Texture && this.sh2Texture.value.dispose(), this.sh3Texture.value !== l.emptyExtSh3Texture && this.sh3Texture.value.dispose(), this.sh3TextureB.value !== l.emptyExtSh3BTexture && this.sh3TextureB.value.dispose()) : (this.sh1Texture.value !== l.emptySh1Texture && this.sh1Texture.value.dispose(), this.sh2Texture.value !== l.emptySh2Texture && this.sh2Texture.value.dispose(), this.sh3Texture.value !== l.emptySh3Texture && this.sh3Texture.value.dispose()); + } + ensureShTextures(A) { + this.curSh = Math.max(this.curSh, A), this.extSplats ? this.curSh >= 1 && this.sh1Texture.value === l.emptyExtSh1Texture && (this.sh1Texture.value = this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + )) : this.curSh >= 1 && this.sh1Texture.value === l.emptySh1Texture && (this.sh1Texture.value = this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 2), + 256, + 256, + this.maxPages, + G.RGIntegerFormat, + G.UnsignedIntType, + "RG32UI" + )), this.curSh >= 2 && this.sh2Texture.value === (this.extSplats ? l.emptyExtSh2Texture : l.emptySh2Texture) && (this.sh2Texture.value = this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + )), this.extSplats ? this.curSh >= 3 && (this.sh3Texture.value === l.emptyExtSh3Texture && (this.sh3Texture.value = this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + )), this.sh3TextureB.value === l.emptyExtSh3BTexture && (this.sh3TextureB.value = this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + ))) : this.curSh >= 3 && this.sh3Texture.value === l.emptySh3Texture && (this.sh3Texture.value = this.newUint32ArrayTexture( + new Uint32Array(this.maxPages * 256 * 256 * 4), + 256, + 256, + this.maxPages, + G.RGBAIntegerFormat, + G.UnsignedIntType, + "RGBA32UI" + )); + } + allocatePage() { + return this.pageFreelist.shift(); + } + freePage(A) { + this.pageFreelist.push(A); + } + getSplatsChunk(A, I) { + const g = this.splatsChunkToPage.get(A); + if (g) + return g[I]; + } + insertSplatsChunkPage(A, I, g, B) { + this.splatsChunkToPage.has(A) || this.splatsChunkToPage.set(A, []); + const C = this.splatsChunkToPage.get(A); + if (!C) + throw new Error("impossible"); + I >= C.length && (C.length = I + 1); + const E = { page: g, lru: B }; + return C[I] = E, this.pageLru.add(E), this.pageToSplatsChunk[g] = { splats: A, chunk: I, time: performance.now() }, this.pageToSplatsChunk[g]; + } + removeSplatsChunkPage(A, I, g) { + const B = this.splatsChunkToPage.get(A); + if (!B) + throw new Error("impossible"); + const C = B[I]; + if (!C) + throw new Error( + `pageLru not found for splats: ${A}, chunk: ${I}, page: ${g}` + ); + for (this.pageLru.delete(C), B[I] = void 0; B.length > 0 && B[B.length - 1] === void 0; ) + B.pop(); + for (B.length === 0 && this.splatsChunkToPage.delete(A), this.pageToSplatsChunk[g] = void 0; this.pageToSplatsChunk.length > 0 && this.pageToSplatsChunk[this.pageToSplatsChunk.length - 1] === void 0; ) + this.pageToSplatsChunk.pop(); + } + uploadPage(A, I, g, B) { + const C = A * this.pageSplats; + this.packedTexture.value.image.data.subarray(C * 4, C * 4 + I.length).set(I), this.packedTexture.value.addLayerUpdate(A), this.packedTexture.value.needsUpdate = !0, B && (this.extTexture.value.image.data.subarray(C * 4, C * 4 + B.length).set(B), this.extTexture.value.addLayerUpdate(A), this.extTexture.value.needsUpdate = !0); + const D = this.extSplats ? g.sh3a && g.sh3b ? 3 : g.sh2 ? 2 : g.sh1 ? 1 : 0 : g.sh3 ? 3 : g.sh2 ? 2 : g.sh1 ? 1 : 0; + if (this.ensureShTextures(D), this.extSplats) { + if (this.sh1Texture.value !== l.emptyExtSh1Texture && g.sh1) { + const i = g.sh1; + this.sh1Texture.value.image.data.subarray(C * 4, C * 4 + i.length).set(i), this.sh1Texture.value.addLayerUpdate(A), this.sh1Texture.value.needsUpdate = !0; + } + } else if (this.sh1Texture.value !== l.emptySh1Texture && g.sh1) { + const i = g.sh1; + this.sh1Texture.value.image.data.subarray(C * 2, C * 2 + i.length).set(i), this.sh1Texture.value.addLayerUpdate(A), this.sh1Texture.value.needsUpdate = !0; + } + if (this.sh2Texture.value !== l.emptySh2Texture && g.sh2) { + const i = g.sh2; + this.sh2Texture.value.image.data.subarray(C * 4, C * 4 + i.length).set(i), this.sh2Texture.value.addLayerUpdate(A), this.sh2Texture.value.needsUpdate = !0; + } + if (this.extSplats) { + if (this.sh3Texture.value !== l.emptyExtSh3Texture && g.sh3a) { + const i = g.sh3a; + this.sh3Texture.value.image.data.subarray(C * 4, C * 4 + i.length).set(i), this.sh3Texture.value.addLayerUpdate(A), this.sh3Texture.value.needsUpdate = !0; + } + if (this.sh3TextureB.value !== l.emptyExtSh3BTexture && g.sh3b) { + const i = g.sh3b; + this.sh3TextureB.value.image.data.subarray(C * 4, C * 4 + i.length).set(i), this.sh3TextureB.value.addLayerUpdate(A), this.sh3TextureB.value.needsUpdate = !0; + } + } else if (this.sh3Texture.value !== l.emptySh3Texture && g.sh3) { + const i = g.sh3; + this.sh3Texture.value.image.data.subarray(C * 4, C * 4 + i.length).set(i), this.sh3Texture.value.addLayerUpdate(A), this.sh3Texture.value.needsUpdate = !0; + } + } + getGlTexture(A) { + return fw(this.renderer, A); + } + newUint32ArrayTexture(A, I, g, B, C, E, D) { + const i = new G.DataArrayTexture(A, I, g, B); + return i.format = C, i.type = E, i.internalFormat = D, i.needsUpdate = !0, this.renderer.initTexture(i), i; + } + driveFetchers() { + const A = [], I = []; + let g = 0; + for (const { splats: E, chunk: D } of this.fetchPriority) { + const i = this.getSplatsChunk(E, D); + if (i) { + g >= this.maxPages ? I.push(i) : A.push(i), g += 1; + continue; + } + if (this.fetched.some( + ({ splats: w, chunk: s }) => E === w && D === s + ) || this.fetchers.some( + ({ splats: w, chunk: s }) => E === w && D === s + )) { + g += 1; + continue; + } + if (g < this.maxPages && this.fetchers.length < this.numFetchers) { + g += 1; + const w = E.fetchDecodeChunk(D).then( + async (s) => { + this.fetched.push({ splats: E, chunk: D, data: s }), this.fetchPause > 0 && await new Promise( + (o) => setTimeout(o, this.fetchPause) + ); + }, + async (s) => { + console.warn(s); + const o = 250 + 500 * Math.random(); + await new Promise((y) => setTimeout(y, o)); + } + ).finally(() => { + this.fetchers = this.fetchers.filter( + ({ splats: s, chunk: o }) => E !== s || D !== o + ), this.processFetched(); + }); + this.fetchers.push({ splats: E, chunk: D, promise: w }), w.then((s) => { + this.autoDrive && this.driveFetchers(); + }); + } + } + const B = performance.now(); + for (const E of I.reverse()) + E.lru = B, this.pageLru.delete(E), this.pageLru.add(E); + const C = new Set(this.pageLru); + for (const E of A.reverse()) + C.delete(E), E.lru = B, this.pageLru.delete(E), this.pageLru.add(E); + this.freeablePages = Array.from(C).map(({ page: E }) => E); + } + allocateFreeable() { + const A = this.freeablePages.shift(); + if (A === void 0) + return; + const I = this.pageToSplatsChunk[A]; + if (!I) + throw new Error(`splatsChunk not found for page: ${A}`); + const { splats: g, chunk: B } = I; + return this.removeSplatsChunkPage(g, B, A), this.lodTreeUpdates.push({ + splats: g, + page: A, + chunk: B, + numSplats: this.pageSplats + }), A; + } + processFetched() { + const A = performance.now(); + for (; ; ) { + const I = this.fetched.shift(); + if (!I) + break; + const { splats: g, chunk: B, data: C } = I; + let E = this.allocatePage(); + if (E === void 0 && (E = this.allocateFreeable(), E === void 0)) + return; + this.insertSplatsChunkPage(g, B, E, A); + const { numSplats: D, extra: i } = C; + if (this.lodTreeUpdates.push({ + splats: g, + page: E, + chunk: B, + numSplats: D, + lodTree: i.lodTree + }), this.extSplats) { + const w = C.extArrays, s = w[0], o = w[1]; + this.newUploads.push({ page: E, numSplats: D, packedArray: s, extArray: o, extra: i }); + } else { + const w = C.packedArray; + this.newUploads.push({ page: E, numSplats: D, packedArray: w, extra: i }); + } + } + } + processUploads() { + for (; ; ) { + const A = this.readyUploads.shift(); + if (!A) + break; + const { page: I, numSplats: g, packedArray: B, extArray: C, extra: E } = A; + this.uploadPage(I, B, E, C); + } + } + consumeLodTreeUpdates() { + const A = this.lodTreeUpdates; + return this.lodTreeUpdates = [], this.readyUploads.push(...this.newUploads), this.newUploads = [], A; + } +}; +l.emptyUint32x4 = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 4), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGBAIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RGBA32UI", E.needsUpdate = !0, E; +})(), l.emptyUint32x2 = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 2), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RG32UI", E.needsUpdate = !0, E; +})(), l.emptyIndicesTexture = (() => { + const A = new Uint32Array(16384), I = new G.DataTexture(A, 4096, 1); + return I.format = G.RGBAIntegerFormat, I.type = G.UnsignedIntType, I.internalFormat = "RGBA32UI", I.needsUpdate = !0, I; +})(), l.emptyPackedTexture = l.emptyUint32x4, l.emptyExtTexture = l.emptyUint32x4, l.emptySh1Texture = l.emptyUint32x2, l.emptySh2Texture = l.emptyUint32x4, l.emptySh3Texture = l.emptyUint32x4, l.emptyExtSh1Texture = l.emptyUint32x4, l.emptyExtSh2Texture = l.emptyUint32x4, l.emptyExtSh3Texture = l.emptyUint32x4, l.emptyExtSh3BTexture = l.emptyUint32x4; +let tI = l; +function fw(Q, A) { + if (!Q.properties.has(A)) + throw new Error("texture not found"); + const g = Q.properties.get(A).__webglTexture; + if (!g) + throw new Error("texture not found"); + return g; +} +const zh = lw(); +async function cQ({ + url: Q, + requestHeader: A, + withCredentials: I, + offset: g, + bytes: B +}) { + const C = new Request(Q, { + headers: A ? new Headers(A) : void 0, + credentials: I ? "include" : "same-origin" + }); + g !== void 0 && B !== void 0 && C.headers.set("Range", `bytes=${g}-${g + B - 1}`); + const E = await fetch(C); + if (!E.ok || !E.body) + throw new Error( + `Failed to fetch "${Q}": ${E.status} ${E.statusText}` + ); + return new Uint8Array(await E.arrayBuffer()); +} +class _h { + constructor() { + this.fetchDyno = new d({ + inTypes: {}, + outTypes: { gsplat: Z }, + globals: () => [HA], + statements: ({ outputs: A }) => z(` + ${A.gsplat}.flags = 0u; + return; + `) + }).outputs.gsplat; + } + prepareFetchSplat() { + } + dispose() { + } + getNumSplats() { + return 0; + } + hasRgbDir() { + return !1; + } + getNumSh() { + return 0; + } + setMaxSh(A) { + } + fetchSplat({ index: A }) { + return this.fetchDyno; + } +} +const bA = class bA extends PI { + constructor(A = {}) { + if (super({ + update: (I) => this.update(I) + }), this.isInitialized = !1, this.recolor = new G.Color(1, 1, 1), this.opacity = 1, this.generatorDirty = !0, this.enableViewToObject = !1, this.enableViewToWorld = !1, this.enableWorldToView = !1, this.skinning = null, this.edits = null, this.rgbaDisplaceEdits = null, this.splatRgba = null, this.maxSh = 3, this.showLodPageDyno = new EI({ value: 0 }), A.splats) + this.splats = A.splats, this.numSplats = A.splats.getNumSplats(); + else if (A.paged) { + A.extSplats && console.warn( + "To set extSplats with the paged option, set SparkRenderer.pagedExtSplats" + ); + const I = A.url ?? ""; + if (A.paged === !0) + this.paged = new Pg({ rootUrl: I }); + else if (A.paged instanceof Pg) + this.paged = A.paged; + else if (A.paged instanceof tI) + this.paged = new Pg({ rootUrl: I, pager: A.paged }); + else + throw new Error("Invalid paged option"); + this.splats = this.paged; + } else A.extSplats ? (this.extSplats = A.extSplats instanceof GI ? A.extSplats : new GI(), A.extSplats = this.extSplats, this.numSplats = this.extSplats.numSplats, this.splats = this.extSplats) : A.packedSplats ? (this.packedSplats = A.packedSplats, this.packedSplats.splatEncoding = A.splatEncoding ?? { + ...cg + }, this.splats = this.packedSplats) : this.packedSplats = new $A(); + if (this.editable = A.editable ?? !0, this.raycastable = A.raycastable ?? !0, this.minRaycastOpacity = A.minRaycastOpacity ?? 0.2, this.onFrame = A.onFrame, this.context = { + transform: new XI(), + viewToWorld: new XI(), + worldToView: new XI(), + viewToObject: new XI(), + covTransform: new Kg(), + covViewToWorld: new Kg(), + covWorldToView: new Kg(), + covViewToObject: new Kg(), + recolor: new mI({ + value: new G.Vector4().setScalar(Number.NEGATIVE_INFINITY) + }), + time: new pI({ value: 0 }), + deltaTime: new pI({ value: 0 }), + numSplats: new EI({ value: 0 }), + splats: new _h(), + enableLod: new bI({ value: !1 }), + lodIndices: new BQ({ + value: bB, + key: "lodIndices" + }) + }, this.covSplats = A.covSplats ?? !1, this.covSplats && !this.extSplats) + throw new Error("CovSplats requires ExtSplats"); + if (this.objectModifiers = A.objectModifier ? [A.objectModifier] : void 0, this.worldModifiers = A.worldModifier ? [A.worldModifier] : void 0, A.objectModifiers && (this.objectModifiers = A.objectModifiers), A.worldModifiers && (this.worldModifiers = A.worldModifiers), this.enableLod = A.enableLod, this.lodScale = A.lodScale ?? 1, this.behindFoveate = A.behindFoveate, this.coneFov0 = A.coneFov0, this.coneFov = A.coneFov, this.coneFoveate = A.coneFoveate, this.updateGenerator(), A.url || A.fileBytes || A.stream || A.constructSplats || A.packedSplats && !A.packedSplats.isInitialized || this.extSplats && !this.extSplats.isInitialized) + this.initialized = this.asyncInitialize(A).then(async () => { + if (this.updateGenerator(), this.isInitialized = !0, A.onLoad) { + const I = A.onLoad(this); + I instanceof Promise && await I; + } + return this; + }); + else if (this.isInitialized = !0, this.initialized = Promise.resolve(this), A.onLoad) { + const I = A.onLoad(this); + I instanceof Promise && (this.initialized = I.then(() => this)); + } + } + async asyncInitialize(A) { + const { + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + maxSplats: i, + constructSplats: w, + onProgress: s, + splatEncoding: o, + lod: y, + nonLod: h, + lodAbove: k + } = A; + if (this.packedSplats) { + if (I || g || E || w) { + const R = { + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + maxSplats: i, + construct: w, + onProgress: s, + splatEncoding: o, + lod: y, + nonLod: h, + lodAbove: k + }; + this.packedSplats.reinitialize(R); + } + await this.packedSplats.initialized, this.splats = this.packedSplats; + } else if (this.extSplats && (I || g || E || w)) { + const R = w; + this.extSplats.reinitialize({ + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + maxSplats: i, + construct: R, + onProgress: s, + lod: y, + nonLod: h, + lodAbove: k + }), await this.extSplats.initialized, this.splats = this.extSplats; + } + this.splats && (this.numSplats = this.splats.getNumSplats(), this.updateGenerator()); + } + static async staticInitialize() { + await lw(), bA.isStaticInitialized = !0; + } + // Creates a new Gsplat with the provided parameters (all values in "float" space, + // i.e. 0-1 for opacity and color) and adds it to the end of the packedSplats, + // increasing numSplats by 1. If necessary, reallocates the buffer with an exponential + // doubling strategy to fit the new data, so it's fairly efficient to just + // pushSplat(...) each Gsplat you want to create in a loop. + pushSplat(A, I, g, B, C) { + this.packedSplats ? this.packedSplats.pushSplat(A, I, g, B, C) : this.extSplats && this.extSplats.pushSplat(A, I, g, B, C); + } + // This method iterates over all Gsplats in this instance's packedSplats, + // invoking the provided callback with index: number in 0..=(this.numSplats-1) and + // center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, + // opacity: number (0..1), and color: THREE.Color (rgb values in 0..1). + // Note that the objects passed in as center etc. are the same for every callback + // invocation: these objects are reused for efficiency. Changing these values has + // no effect as they are decoded/unpacked copies of the underlying data. To update + // the packedSplats, call .packedSplats.setSplat(index, center, scales, + // quaternion, opacity, color). + forEachSplat(A) { + this.packedSplats ? this.packedSplats.forEachSplat(A) : this.extSplats && this.extSplats.forEachSplat(A); + } + // Call this when you are finished with the SplatMesh and want to free + // any buffers it holds (via packedSplats). + dispose() { + this.splats && this.splats !== this.packedSplats && this.splats !== this.extSplats && (this.splats.dispose(), this.splats = void 0), this.packedSplats && (this.packedSplats.dispose(), this.packedSplats = void 0), this.extSplats && (this.extSplats.dispose(), this.extSplats = void 0); + } + // Returns axis-aligned bounding box of the SplatMesh. If centers_only is true, + // only the centers of the splats are used to compute the bounding box. + // IMPORTANT: This should only be called after the SplatMesh is initialized. + getBoundingBox(A = !0) { + if (!this.initialized) + throw new Error( + "Cannot get bounding box before SplatMesh is initialized" + ); + if (!this.packedSplats && !this.extSplats) + throw new Error("Bounding box requires PackedSplats or ExtSplats"); + const I = new G.Vector3( + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY, + Number.POSITIVE_INFINITY + ), g = new G.Vector3( + Number.NEGATIVE_INFINITY, + Number.NEGATIVE_INFINITY, + Number.NEGATIVE_INFINITY + ), B = new G.Vector3(), C = [-1, 1]; + function E(i, w, s, o, y, h) { + if (A) + I.min(w), g.max(w); + else + for (const k of C) + for (const R of C) + for (const F of C) + B.set(k * s.x, R * s.y, F * s.z), B.applyQuaternion(o), B.add(w), I.min(B), g.max(B); + } + return this.packedSplats ? this.packedSplats.forEachSplat(E) : this.extSplats && this.extSplats.forEachSplat(E), new G.Box3(I, g); + } + set objectModifier(A) { + A ? this.objectModifiers = [A] : this.objectModifiers = void 0; + } + set worldModifier(A) { + A ? this.worldModifiers = [A] : this.worldModifiers = void 0; + } + constructGenerator(A) { + if (this.covSplats) + return this.constructCovGenerator(A); + const { transform: I, viewToObject: g, recolor: B } = A, C = cA( + { index: "int" }, + { gsplat: Z }, + ({ index: E }) => { + if (!E) + throw new Error("index is undefined"); + E = pB( + A.lodIndices, + E, + A.numSplats, + A.enableLod, + this.showLodPageDyno + ), A.splats.setMaxSh(this.maxSh), A.splats.prepareFetchSplat(); + let D = A.splats.fetchSplat({ + index: E, + viewOrigin: g.translate + }); + if (this.splatRgba && (D = fB( + D, + this.splatRgba.dyno, + E, + A.enableLod + )), this.skinning && (D = this.skinning.modify(D)), this.objectModifiers) + for (const w of this.objectModifiers) + D = w.apply({ gsplat: D }).gsplat; + D = I.applyGsplat(D); + const i = kA(B, uA(D).outputs.rgba); + if (D = CI({ gsplat: D, rgba: i }), this.rgbaDisplaceEdits && (D = this.rgbaDisplaceEdits.modify(D)), this.worldModifiers) + for (const w of this.worldModifiers) + D = w.apply({ gsplat: D }).gsplat; + return { gsplat: D }; + } + ); + this.generator = C, this.covGenerator = void 0; + } + constructCovGenerator(A) { + const { covTransform: I, covViewToObject: g, recolor: B } = A, C = cA( + { index: "int" }, + { covsplat: eA }, + ({ index: E }) => { + if (!E) + throw new Error("index is undefined"); + E = pB( + A.lodIndices, + E, + A.numSplats, + A.enableLod, + this.showLodPageDyno + ), A.splats.prepareFetchSplat(); + let D = A.splats.fetchSplat({ + index: E, + viewOrigin: g.offset + }); + if (this.splatRgba && (D = fB( + D, + this.splatRgba.dyno, + E, + A.enableLod + )), this.objectModifiers) + for (const s of this.objectModifiers) + D = s.apply({ gsplat: D }).gsplat; + let i = Zg(D); + if (this.skinning && (i = this.skinning.modifyCov(i)), this.covObjectModifiers) + for (const s of this.covObjectModifiers) + i = s.apply({ covsplat: i }).covsplat; + i = I.applyCovSplat(i); + const w = kA(B, Vg(i).outputs.rgba); + if (i = iB({ covsplat: i, rgba: w }), this.rgbaDisplaceEdits && (i = this.rgbaDisplaceEdits.modifyCov(i)), this.covWorldModifiers) + for (const s of this.covWorldModifiers) + i = s.apply({ covsplat: i }).covsplat; + return { covsplat: i }; + } + ); + this.generator = void 0, this.covGenerator = C; + } + // Call this whenever something changes in the Gsplat processing pipeline, + // for example changing maxSh or updating objectModifier or worldModifier. + // Compiled generators are cached for efficiency and re-use when the same + // pipeline structure emerges after successive changes. + updateGenerator() { + this.generatorDirty = !0; + } + // This is called automatically by SparkRenderer and you should not have to + // call it. It updates parameters for the generated pipeline and calls + // updateGenerator() if the pipeline needs to change. + update({ + renderer: A, + time: I, + deltaTime: g, + viewToWorld: B, + camera: C, + renderSize: E, + globalEdits: D, + lodIndices: i + }) { + var R, F, S; + this.context.time.value = I, this.context.deltaTime.value = g, bA.dynoTime.value = I, this.showLodPageDyno.value = this.showLodPage ?? -1; + const w = this.splats ?? this.packedSplats ?? this.extSplats; + w && (this.context.splats = w), this.numSplats = this.context.splats.getNumSplats(); + let s = !1; + const o = ((R = this.packedSplats) == null ? void 0 : R.lodSplats) ?? ((F = this.extSplats) == null ? void 0 : F.lodSplats); + if (this.context.enableLod.value = o != null && i != null, this.enableLod === !1 && (this.context.enableLod.value = !1), this.context.lodIndices.value = (i == null ? void 0 : i.texture) ?? bB, this.context.enableLod.value && o && (this.context.splats = o, this.numSplats = (i == null ? void 0 : i.numSplats) ?? 0), this.context.numSplats.value = this.numSplats, this.context.splats !== this.lastSplats && (this.lastSplats = this.context.splats, this.generatorDirty = !0), this.covSplats) { + this.context.covTransform.update(this) && (s = !0), this.context.covViewToWorld.updateFromMatrix(B) && this.enableViewToWorld && (s = !0); + const a = B.clone().invert(); + this.context.covWorldToView.updateFromMatrix(a) && this.enableWorldToView && (s = !0); + const c = this.matrixWorld.clone().invert().multiply(B); + this.context.covViewToObject.updateFromMatrix(c) && (this.enableViewToObject || this.context.splats.hasRgbDir()) && (s = !0); + } else { + this.context.transform.update(this) && (s = !0), this.context.viewToWorld.updateFromMatrix(B) && this.enableViewToWorld && (s = !0); + const a = B.clone().invert(); + this.context.worldToView.updateFromMatrix(a) && this.enableWorldToView && (s = !0); + const N = new G.Matrix4().compose( + this.context.transform.translate.value, + this.context.transform.rotate.value, + new G.Vector3().setScalar(this.context.transform.scale.value) + ).invert().multiply(B); + this.context.viewToObject.updateFromMatrix(N) && (this.enableViewToObject || this.context.splats.hasRgbDir()) && (s = !0); + } + const y = new G.Vector4( + this.recolor.r, + this.recolor.g, + this.recolor.b, + this.opacity + ); + y.equals(this.context.recolor.value) || (this.context.recolor.value.copy(y), s = !0); + const h = this.editable ? (this.edits ?? []).concat(D) : []; + this.editable && !this.edits && this.traverseVisible((a) => { + a instanceof ag && h.push(a); + }), h.sort((a, M) => a.ordering - M.ordering); + const k = h.map((a) => { + if (a.sdfs != null) + return { edit: a, sdfs: a.sdfs }; + const M = []; + return a.traverseVisible((c) => { + c instanceof Oh && M.push(c); + }), { edit: a, sdfs: M }; + }); + if (k.length > 0 && !this.rgbaDisplaceEdits) { + const a = k.length, M = k.reduce( + (c, N) => c + N.sdfs.length, + 0 + ); + this.rgbaDisplaceEdits = new mh({ + maxEdits: a, + maxSdfs: M + }), this.generatorDirty = !0; + } + if (this.rgbaDisplaceEdits) { + const a = this.rgbaDisplaceEdits.update(k); + s || (s = a.updated), a.dynoUpdated && (this.generatorDirty = !0); + } + this.generatorDirty && (this.constructGenerator(this.context), this.generatorDirty = !1, s = !0), s && this.updateVersion(), (S = this.onFrame) == null || S.call(this, { mesh: this, time: I, deltaTime: g }); + } + // This method conforms to the standard THREE.Raycaster API, performing object-ray + // intersections using this method to populate the provided intersects[] array + // with each intersection point. + raycast(A, I) { + var S, a, M, c, N, U, J, t, H, K, Y, L, q, n, r, p, m, IA, X, EA, j, gA, W; + if (!bA.isStaticInitialized || !this.raycastable || !this.packedSplats && !this.extSplats && !this.paged) + return; + const g = this.paged != null, B = g ? ((a = (S = this.paged) == null ? void 0 : S.pager) == null ? void 0 : a.extSplats) ?? !1 : this.extSplats != null, { near: C, far: E, ray: D } = A, i = this.matrixWorld.clone().invert(), w = new G.Matrix3().setFromMatrix4(i), s = D.origin.clone().applyMatrix4(i), o = D.direction.clone().applyMatrix3(w), y = Rh(), h = y.length / 4; + let k = 0; + const R = ((M = this.raycastIndices) == null ? void 0 : M.numSplats) ?? (g ? (c = this.paged) == null ? void 0 : c.numSplats : this.context.numSplats.value) ?? 0, F = ((N = this.raycastIndices) == null ? void 0 : N.indices) ?? (g ? (U = this.paged) == null ? void 0 : U.dynoIndices.value.image.data : this.context.enableLod.value ? this.context.lodIndices.value.image.data : null) ?? null; + if (B) { + const u = kh(), b = g ? (r = (n = this.paged) == null ? void 0 : n.pager) == null ? void 0 : r.packedTexture.value.image.data : F ? (m = (p = this.extSplats) == null ? void 0 : p.lodSplats) == null ? void 0 : m.extArrays[0] : (IA = this.extSplats) == null ? void 0 : IA.extArrays[0], T = g ? (EA = (X = this.paged) == null ? void 0 : X.pager) == null ? void 0 : EA.extTexture.value.image.data : F ? (gA = (j = this.extSplats) == null ? void 0 : j.lodSplats) == null ? void 0 : gA.extArrays[1] : (W = this.extSplats) == null ? void 0 : W.extArrays[1]; + if (!b || !T) + return; + for (let f = 0; f < R; f += h) { + const FA = Math.min(h, R - f); + if (!F) + y.set(b.subarray(f * 4, (f + FA) * 4)), u.set(T.subarray(f * 4, (f + FA) * 4)); + else + for (let SA = 0; SA < FA; ++SA) { + const aA = F[f + SA], wA = SA * 4, GA = aA * 4; + y[wA] = b[GA], y[wA + 1] = b[GA + 1], y[wA + 2] = b[GA + 2], y[wA + 3] = b[GA + 3], u[wA] = T[GA], u[wA + 1] = T[GA + 1], u[wA + 2] = T[GA + 2], u[wA + 3] = T[GA + 3]; + } + const sA = Fh( + s.x, + s.y, + s.z, + o.x, + o.y, + o.z, + this.minRaycastOpacity, + C, + E, + FA + ); + k = this.appendRaycastBuffer( + k, + sA + ); + } + } else { + const u = g ? (t = (J = this.paged) == null ? void 0 : J.pager) == null ? void 0 : t.packedTexture.value.image.data : F ? (K = (H = this.packedSplats) == null ? void 0 : H.lodSplats) == null ? void 0 : K.packedArray : (Y = this.packedSplats) == null ? void 0 : Y.packedArray; + if (!u) + return; + const b = g ? (L = this.paged) == null ? void 0 : L.splatEncoding : (q = this.packedSplats) == null ? void 0 : q.splatEncoding; + for (let T = 0; T < R; T += h) { + const f = Math.min(h, R - T); + if (!F) + y.set(u.subarray(T * 4, (T + f) * 4)); + else + for (let sA = 0; sA < f; ++sA) { + const SA = F[T + sA], aA = sA * 4, wA = SA * 4; + y[aA] = u[wA], y[aA + 1] = u[wA + 1], y[aA + 2] = u[wA + 2], y[aA + 3] = u[wA + 3]; + } + const FA = Sh( + s.x, + s.y, + s.z, + o.x, + o.y, + o.z, + this.minRaycastOpacity, + C, + E, + f, + (b == null ? void 0 : b.lnScaleMin) ?? pA, + (b == null ? void 0 : b.lnScaleMax) ?? fA, + (b == null ? void 0 : b.lodOpacity) ?? !1 + ); + k = this.appendRaycastBuffer( + k, + FA + ); + } + } + for (const u of bA.raycastBuffer.subarray(0, k)) { + const b = D.direction.clone().multiplyScalar(u).add(D.origin); + I.push({ + distance: u, + point: b, + object: this + }); + } + } + appendRaycastBuffer(A, I) { + const g = A + I.length; + let B = bA.raycastBuffer.length; + if (g > B) { + for (; B < g; ) + B *= 2; + const C = new Float32Array(B); + C.set(bA.raycastBuffer.subarray(0, A)), bA.raycastBuffer = C; + } + return bA.raycastBuffer.set(I, A), A + I.length; + } + async createLodSplats({ + rgbaArray: A, + quality: I + } = {}) { + this.packedSplats ? await this.packedSplats.createLodSplats({ quality: I, rgbaArray: A }) : this.extSplats && await this.extSplats.createLodSplats({ quality: I, rgbaArray: A }); + } +}; +bA.staticInitialized = bA.staticInitialize(), bA.isStaticInitialized = !1, bA.dynoTime = new pI({ value: 0 }), bA.raycastBuffer = new Float32Array(1024); +let vA = bA; +function pB(Q, A, I, g, B) { + return AQ({ + inTypes: { + lodIndices: "usampler2D", + index: "int", + numSplats: "int", + enableLod: "bool", + showLodPage: "int" + }, + outTypes: { + index: "int" + }, + inputs: { + lodIndices: Q, + index: A, + numSplats: I, + enableLod: g, + showLodPage: B + }, + statements: ({ inputs: C, outputs: E }) => z(` + int index = ${C.index}; + if (${C.showLodPage} < 0) { + if (index >= ${C.numSplats}) { + return; + } + if (${C.enableLod}) { + ivec2 lodIndexCoord = ivec2((index >> 2) & 4095, index >> 14); + uint splatIndex = texelFetch(${C.lodIndices}, lodIndexCoord, 0)[index & 3]; + ${E.index} = int(splatIndex); + } else { + ${E.index} = index; + } + } else { + int start = ${C.showLodPage} << 16; + if (index >= 65536) { + return; + } + ${E.index} = start + index; + } + `) + }).outputs.index; +} +function fB(Q, A, I, g) { + return AQ({ + inTypes: { + gsplat: Z, + rgba: RB, + index: "int", + enableLod: "bool" + }, + outTypes: { gsplat: Z }, + inputs: { gsplat: Q, rgba: A, index: I, enableLod: g }, + statements: ({ inputs: B, outputs: C }) => z(` + ${C.gsplat} = ${B.gsplat}; + if (!${B.enableLod} && (${B.index} >= 0) && (${B.index} < ${B.rgba}.count)) { + ${C.gsplat}.rgba = texelFetch(${B.rgba}.texture, splatTexCoord(${B.index}), 0); + } + `) + }).outputs.gsplat; +} +const bB = (() => { + const Q = new G.DataTexture( + new Uint32Array(16384), + 4096, + 1, + G.RGBAIntegerFormat, + G.UnsignedIntType + ); + return Q.internalFormat = "RGBA32UI", Q.needsUpdate = !0, Q; +})(); +new G.BufferGeometry(); +new G.ShaderMaterial(); +const PB = [ + "char", + "uchar", + "short", + "ushort", + "int", + "uint", + "float", + "double" +], jI = class jI { + // Create a PlyReader from a Uint8Array/ArrayBuffer, no parsing done yet + constructor({ fileBytes: A }) { + this.header = "", this.littleEndian = !0, this.elements = {}, this.comments = [], this.data = null, this.numSplats = 0, this.fileBytes = A instanceof ArrayBuffer ? new Uint8Array(A) : A; + } + // Identify and parse the PLY text header (assumed to be <64KB in size). + // this.elements will contain all the elements in the file, typically + // "vertex" contains the Gsplat data. + async parseHeader() { + const I = new ReadableStream({ + start: (E) => { + E.enqueue(this.fileBytes.slice(0, 65536)), E.close(); + } + }).pipeThrough(new TextDecoderStream()).getReader(); + this.header = ""; + const g = `end_header +`; + for (; ; ) { + const { value: E, done: D } = await I.read(); + if (D) + throw new Error("Failed to read header"); + this.header += E; + const i = this.header.indexOf(g); + if (i >= 0) { + this.header = this.header.slice(0, i + g.length); + break; + } + } + const B = new TextEncoder().encode(this.header).length; + this.data = new DataView(this.fileBytes.buffer, B), this.elements = {}; + let C = null; + this.comments = [], this.header.trim().split(` +`).forEach((E, D) => { + const i = E.trim(); + if (D === 0) { + if (i !== "ply") + throw new Error("Invalid PLY header"); + return; + } + if (i.length === 0) + return; + const w = i.split(" "); + switch (w[0]) { + case "format": + if (w[1] === "binary_little_endian") + this.littleEndian = !0; + else if (w[1] === "binary_big_endian") + this.littleEndian = !1; + else + throw new Error(`Unsupported PLY format: ${w[1]}`); + if (w[2] !== "1.0") + throw new Error(`Unsupported PLY version: ${w[2]}`); + break; + case "end_header": + break; + case "comment": + this.comments.push(i.slice(8)); + break; + case "element": { + const s = w[1]; + C = { + name: s, + count: Number.parseInt(w[2]), + properties: {} + }, this.elements[s] = C; + break; + } + case "property": + if (C == null) + throw new Error("Property must be inside an element"); + w[1] === "list" ? C.properties[w[4]] = { + isList: !0, + type: w[3], + countType: w[2] + } : C.properties[w[2]] = { + isList: !1, + type: w[1] + }; + break; + } + }), this.elements.vertex && (this.numSplats = this.elements.vertex.count); + } + parseData(A) { + let I = 0; + const g = this.data; + if (g == null) + throw new Error("No data to parse"); + for (const B in this.elements) { + const C = this.elements[B], { count: E, properties: D } = C, i = IR(D), w = gR(D, this.littleEndian), s = A(C) ?? (() => { + }); + for (let o = 0; o < E; o++) + I = w(g, I, i), s(o, i); + } + } + // Parse all the Gsplat data in the PLY file in go, invoking the given + // callbacks for each Gsplat. + parseSplats(A, I) { + if (this.elements.vertex == null) + throw new Error("No vertex element found"); + let g = !1; + const B = []; + let C = 0, E = [], D = [], i = [], w, s, o; + function y() { + const S = AR[C]; + E = new Array(3).fill(null).flatMap((a, M) => [0, 1, 2].map((c, N) => M + N * S / 3)), D = new Array(5).fill(null).flatMap( + (a, M) => [0, 1, 2].map((c, N) => 3 + M + N * S / 3) + ), i = new Array(7).fill(null).flatMap( + (a, M) => [0, 1, 2].map((c, N) => 8 + M + N * S / 3) + ), w = C >= 1 ? new Float32Array(3 * 3) : void 0, s = C >= 2 ? new Float32Array(5 * 3) : void 0, o = C >= 3 ? new Float32Array(7 * 3) : void 0; + } + function h(S, a) { + if (!w) + throw new Error("Missing sh1"); + const M = a.f_rest; + for (let c = 0; c < E.length; c++) + w[c] = M[E[c]] * 8 / 255 - 4; + if (s) + for (let c = 0; c < D.length; c++) + s[c] = M[D[c]] * 8 / 255 - 4; + if (o) + for (let c = 0; c < i.length; c++) + o[c] = M[i[c]] * 8 / 255 - 4; + I == null || I(S, w, s, o); + } + function k(S) { + const { + min_x: a, + min_y: M, + min_z: c, + max_x: N, + max_y: U, + max_z: J, + min_scale_x: t, + min_scale_y: H, + min_scale_z: K, + max_scale_x: Y, + max_scale_y: L, + max_scale_z: q + } = S.properties; + if (!a || !M || !c || !N || !U || !J || !t || !H || !K || !Y || !L || !q) + throw new Error("Missing PLY chunk properties"); + return g = !0, (n, r) => { + const { + min_x: p, + min_y: m, + min_z: IA, + max_x: X, + max_y: EA, + max_z: j, + min_scale_x: gA, + min_scale_y: W, + min_scale_z: u, + max_scale_x: b, + max_scale_y: T, + max_scale_z: f, + min_r: FA, + min_g: sA, + min_b: SA, + max_r: aA, + max_g: wA, + max_b: GA + } = r; + B.push({ + min_x: p, + min_y: m, + min_z: IA, + max_x: X, + max_y: EA, + max_z: j, + min_scale_x: gA, + min_scale_y: W, + min_scale_z: u, + max_scale_x: b, + max_scale_y: T, + max_scale_z: f, + min_r: FA, + min_g: sA, + min_b: SA, + max_r: aA, + max_g: wA, + max_b: GA + }); + }; + } + function R(S) { + if (I && S.name === "sh") + return C = OQ(S.properties), y(), h; + if (S.name !== "vertex") + return null; + const { packed_position: a, packed_rotation: M, packed_scale: c, packed_color: N } = S.properties; + if (!a || !M || !c || !N) + throw new Error( + "Missing PLY properties: packed_position, packed_rotation, packed_scale, packed_color" + ); + const U = Math.sqrt(2); + return (J, t) => { + const H = B[J >>> 8]; + if (H == null) + throw new Error("Missing PLY chunk"); + const { + min_x: K, + min_y: Y, + min_z: L, + max_x: q, + max_y: n, + max_z: r, + min_scale_x: p, + min_scale_y: m, + min_scale_z: IA, + max_scale_x: X, + max_scale_y: EA, + max_scale_z: j, + min_r: gA, + min_g: W, + min_b: u, + max_r: b, + max_g: T, + max_b: f + } = H, { packed_position: FA, packed_rotation: sA, packed_scale: SA, packed_color: aA } = t, wA = (FA >>> 21 & 2047) / 2047 * (q - K) + K, GA = (FA >>> 11 & 1023) / 1023 * (n - Y) + Y, AI = (FA & 2047) / 2047 * (r - L) + L, TA = ((sA >>> 20 & 1023) / 1023 - 0.5) * U, FI = ((sA >>> 10 & 1023) / 1023 - 0.5) * U, SI = ((sA & 1023) / 1023 - 0.5) * U, _ = Math.sqrt(Math.max(0, 1 - TA * TA - FI * FI - SI * SI)), OA = sA >>> 30, LA = OA === 0 ? TA : OA === 1 ? _ : FI, Cg = OA <= 1 ? FI : OA === 2 ? _ : SI, Hg = OA <= 2 ? SI : _, mA = OA === 0 ? _ : TA, $ = Math.exp( + (SA >>> 21 & 2047) / 2047 * (X - p) + p + ), RI = Math.exp( + (SA >>> 11 & 1023) / 1023 * (EA - m) + m + ), wQ = Math.exp( + (SA & 2047) / 2047 * (j - IA) + IA + ), oQ = (aA >>> 24 & 255) / 255 * ((b ?? 1) - (gA ?? 0)) + (gA ?? 0), sQ = (aA >>> 16 & 255) / 255 * ((T ?? 1) - (W ?? 0)) + (W ?? 0), GQ = (aA >>> 8 & 255) / 255 * ((f ?? 1) - (u ?? 0)) + (u ?? 0), yQ = (aA & 255) / 255; + A( + J, + wA, + GA, + AI, + $, + RI, + wQ, + LA, + Cg, + Hg, + mA, + yQ, + oQ, + sQ, + GQ + ); + }; + } + const F = (S) => { + if (S.name === "chunk") + return k(S); + if (g) + return R(S); + if (S.name !== "vertex") + return null; + const { + x: a, + y: M, + z: c, + scale_0: N, + scale_1: U, + scale_2: J, + rot_0: t, + rot_1: H, + rot_2: K, + rot_3: Y, + opacity: L, + f_dc_0: q, + f_dc_1: n, + f_dc_2: r, + red: p, + green: m, + blue: IA, + alpha: X + } = S.properties; + if (!a || !M || !c) + throw new Error("Missing PLY properties: x, y, z"); + const EA = N && U && J, j = t && H && K && Y, gA = X != null ? rg[X.type] : 1, W = p != null ? rg[p.type] : 1, u = m != null ? rg[m.type] : 1, b = IA != null ? rg[IA.type] : 1; + return C = OQ(S.properties), y(), (T, f) => { + const FA = EA ? Math.exp(f.scale_0) : jI.defaultPointScale, sA = EA ? Math.exp(f.scale_1) : jI.defaultPointScale, SA = EA ? Math.exp(f.scale_2) : jI.defaultPointScale, aA = j ? f.rot_1 : 0, wA = j ? f.rot_2 : 0, GA = j ? f.rot_3 : 0, AI = j ? f.rot_0 : 1, TA = L != null ? 1 / (1 + Math.exp(-f.opacity)) : X != null ? f.alpha / gA : 1, FI = q != null ? f.f_dc_0 * eg + 0.5 : p != null ? f.red / W : 1, SI = n != null ? f.f_dc_1 * eg + 0.5 : m != null ? f.green / u : 1, _ = r != null ? f.f_dc_2 * eg + 0.5 : IA != null ? f.blue / b : 1; + if (A( + T, + f.x, + f.y, + f.z, + FA, + sA, + SA, + aA, + wA, + GA, + AI, + TA, + FI, + SI, + _ + ), I && w) { + const OA = f.f_rest; + if (w) + for (let LA = 0; LA < E.length; LA++) + w[LA] = OA[E[LA]]; + if (s) + for (let LA = 0; LA < D.length; LA++) + s[LA] = OA[D[LA]]; + if (o) + for (let LA = 0; LA < i.length; LA++) + o[LA] = OA[i[LA]]; + I(T, w, s, o); + } + }; + }; + this.parseData(F); + } + // Inject RGBA values into original PLY file, which can be used to modify + // the color/opacity of the Gsplats and write out the modified PLY file. + injectRgba(A) { + let I = 0; + const g = this.data; + if (g == null) + throw new Error("No parsed data"); + if (A.length !== this.numSplats * 4) + throw new Error("Invalid RGBA array length"); + for (const B in this.elements) { + const C = this.elements[B], { count: E, properties: D } = C, i = []; + let w = 0; + const s = B === "vertex"; + if (s) { + for (const o of ["opacity", "f_dc_0", "f_dc_1", "f_dc_2"]) + if (!D[o] || D[o].type !== "float") + throw new Error(`Can't injectRgba due to property: ${o}`); + } + for (const [o, y] of Object.entries(D)) + if (y.isList) + i.push(() => { + const h = WI[y.countType]( + g, + I, + this.littleEndian + ); + I += BI[y.countType], I += h * BI[y.type]; + }); + else { + if (s) + if (o === "f_dc_0" || o === "f_dc_1" || o === "f_dc_2") { + const h = Number.parseInt( + o.slice(5) + ); + i.push(() => { + const k = (A[w + h] / 255 - 0.5) / eg; + uB[y.type]( + g, + I, + this.littleEndian, + k + ); + }); + } else o === "opacity" && i.push(() => { + const h = Math.max( + -100, + Math.min( + 100, + -Math.log(1 / (A[w + 3] / 255) - 1) + ) + ); + uB[y.type]( + g, + I, + this.littleEndian, + h + ); + }); + i.push(() => { + I += BI[y.type]; + }); + } + for (let o = 0; o < E; o++) { + for (const y of i) + y(); + s && (w += 4); + } + } + } +}; +jI.defaultPointScale = 1e-3; +let Wg = jI; +const eg = 0.28209479177387814, WI = { + char: (Q, A, I) => Q.getInt8(A), + uchar: (Q, A, I) => Q.getUint8(A), + short: (Q, A, I) => Q.getInt16(A, I), + ushort: (Q, A, I) => Q.getUint16(A, I), + int: (Q, A, I) => Q.getInt32(A, I), + uint: (Q, A, I) => Q.getUint32(A, I), + float: (Q, A, I) => Q.getFloat32(A, I), + double: (Q, A, I) => Q.getFloat64(A, I) +}, uB = { + char: (Q, A, I, g) => { + Q.setInt8(A, g); + }, + uchar: (Q, A, I, g) => { + Q.setUint8(A, g); + }, + short: (Q, A, I, g) => { + Q.setInt16(A, g, I); + }, + ushort: (Q, A, I, g) => { + Q.setUint16(A, g, I); + }, + int: (Q, A, I, g) => { + Q.setInt32(A, g, I); + }, + uint: (Q, A, I, g) => { + Q.setUint32(A, g, I); + }, + float: (Q, A, I, g) => { + Q.setFloat32(A, g, I); + }, + double: (Q, A, I, g) => { + Q.setFloat64(A, g, I); + } +}, BI = { + char: 1, + uchar: 1, + short: 2, + ushort: 2, + int: 4, + uint: 4, + float: 4, + double: 8 +}, rg = { + char: 127, + uchar: 255, + short: 32767, + ushort: 65535, + int: 2147483647, + uint: 4294967295, + float: 1, + double: 1 +}, $h = { + 0: 0, + 9: 1, + 24: 2, + 45: 3 +}, AR = { + 0: 0, + 1: 9, + 2: 24, + 3: 45 +}, aB = /^f_rest_([0-9]{1,2})$/; +function IR(Q) { + const A = {}; + for (const [I, g] of Object.entries(Q)) + aB.test(I) ? A.f_rest = new Array(OQ(Q)) : A[I] = g.isList ? [] : 0; + return A; +} +function gR(Q, A) { + return CR(Q) ? ER(Q, A) : DR(Q, A); +} +const QR = (() => { + try { + new Function("return 42;"); + } catch { + return !1; + } + return !0; +})(), BR = /^[a-zA-Z0-9_]+$/; +function CR(Q) { + if (!QR) + return !1; + for (const [A, I] of Object.entries(Q)) + if (!BR.test(A) || I.isList && !PB.includes(I.countType) || !PB.includes(I.type)) + return !1; + return !0; +} +function ER(Q, A) { + const I = ["let list;"]; + for (const [B, C] of Object.entries(Q)) { + const E = B.match(aB); + if (E) { + const D = +E[1]; + I.push( + /*js*/ + ` + item.f_rest[${D}] = PARSE_FIELD['${C.type}'](data, offset, ${A}); + offset += ${BI[C.type]}; + ` + ); + } else C.isList ? I.push( + /*js*/ + ` + list = item['${B}']; + list.length = PARSE_FIELD['${C.countType}'](data, offset, ${A}); + offset += ${BI[C.countType]}; + for (let i = 0; i < list.length; i++) { + list[i] = PARSE_FIELD['${C.type}'](data, offset, ${A}); + offset += ${BI[C.type]}; + } + ` + ) : I.push( + /*js*/ + ` + item['${B}'] = PARSE_FIELD['${C.type}'](data, offset, ${A}); + offset += ${BI[C.type]}; + ` + ); + } + I.push("return offset;"); + const g = new Function( + "data", + "offset", + "item", + "PARSE_FIELD", + I.join(` +`) + ); + return (B, C, E) => g(B, C, E, WI); +} +function DR(Q, A) { + const I = []; + for (const [g, B] of Object.entries(Q)) { + const C = g.match(aB); + if (C) { + const E = +C[1]; + I.push( + (D, i, w) => (w.f_rest[E] = WI[B.type]( + D, + i, + A + ), i + BI[B.type]) + ); + } else B.isList ? I.push( + (E, D, i) => { + const w = i[g]; + w.length = WI[B.countType]( + E, + D, + A + ); + let s = D + BI[B.countType]; + for (let o = 0; o < w.length; o++) + w[o] = WI[B.type]( + E, + s, + A + ), s += BI[B.type]; + return s; + } + ) : I.push( + (E, D, i) => (i[g] = WI[B.type]( + E, + D, + A + ), D + BI[B.type]) + ); + } + return (g, B, C) => { + let E = B; + for (let D = 0; D < I.length; D++) + E = I[D](g, E, C); + return E; + }; +} +function OQ(Q) { + let A = 0; + for (; Q[`f_rest_${A}`]; ) + A += 1; + const I = $h[A]; + if (I == null) + throw new Error(`Unsupported number of SH coefficients: ${A}`); + return I; +} +class bw extends Eo { + constructor(A) { + super(A), this.fileLoader = new Do(A); + } + load(A, I, g, B) { + return this.loadInternal({ + url: A, + onLoad: I, + onProgress: g, + onError: B + }); + } + async loadAsync(A, I) { + return new Promise((g, B) => { + this.load( + A, + (C) => { + g(C); + }, + I, + B + ); + }); + } + parse(A) { + return new vA({ packedSplats: A }); + } + loadInternal({ + packedSplats: A, + extSplats: I, + url: g, + fileBytes: B, + fileType: C, + fileName: E, + stream: D, + streamLength: i, + onLoad: w, + onProgress: s, + onError: o, + lod: y, + nonLod: h, + lodAbove: k, + lodBase: R + }) { + B instanceof ArrayBuffer && (B = new Uint8Array(B)); + const F = B ? void 0 : this.manager.resolveURL((this.path ?? "") + (g ?? "")); + let S = D == null ? void 0 : D.getReader(); + this.manager.itemStart(F ?? ""), gQ.withWorker(async (a) => { + const M = (A == null ? void 0 : A.lod) ?? (I == null ? void 0 : I.lod); + M && (y = M); + const c = (A == null ? void 0 : A.nonLod) ?? (I == null ? void 0 : I.nonLod); + c !== void 0 && (h = c); + const N = async (t) => { + const { loaded: H, total: K } = t; + if (H !== void 0 && s && s( + new ProgressEvent("progress", { + lengthComputable: K !== 0, + loaded: H, + total: K + }) + ), t.nextChunk) { + let Y; + if (!S) + Y = new Uint8Array(0); + else { + const { done: L, value: q } = await S.read(); + L ? (S.releaseLock(), S = void 0, Y = new Uint8Array(0)) : Y = q; + } + a.call("nextChunk", { chunk: Y }); + } + }, U = F ? new URL(F, window.location.href).toString() : void 0, J = await a.call( + I ? "loadExtSplats" : "loadPackedSplats", + { + url: U, + requestHeader: this.requestHeader, + withCredentials: this.withCredentials, + fileBytes: B == null ? void 0 : B.slice(), + fileType: C, + pathName: F || E, + chunked: D !== void 0, + chunkedLength: i, + encoding: A == null ? void 0 : A.splatEncoding, + lod: y, + lodBase: R, + nonLod: h, + lodAbove: k + }, + { onStatus: N } + ); + if (J.lodSplats && (I ? J.lodSplats = new GI({ + ...J.lodSplats + }) : J.lodSplats = new $A({ + ...J.lodSplats, + maxSplats: A == null ? void 0 : A.maxSplats + })), I) { + const t = { + // ...(initExt ?? {}), + ...J + }; + I.initialize(t), w == null || w(I); + } else { + const t = { + // ...(init ?? {}), + ...J + }; + A ? (A.initialize(t), w == null || w(A)) : w == null || w(new $A(t)); + } + }).catch((a) => { + this.manager.itemError(F ?? ""), o == null || o(a); + }).finally(() => { + this.manager.itemEnd(F ?? ""); + }); + } + async loadInternalAsync({ + packedSplats: A, + extSplats: I, + url: g, + fileBytes: B, + fileType: C, + fileName: E, + stream: D, + streamLength: i, + onProgress: w, + lod: s, + nonLod: o, + lodAbove: y, + lodBase: h + }) { + return new Promise((k, R) => { + this.loadInternal({ + packedSplats: A, + extSplats: I, + url: g, + fileBytes: B, + fileType: C, + fileName: E, + stream: D, + streamLength: i, + onLoad: k, + onProgress: w, + onError: R, + lod: s, + nonLod: o, + lodAbove: y, + lodBase: h + }); + }); + } +} +function NB(Q) { + const I = new DataView(Q.buffer).getUint32(0, !0); + if ((I & 16777215) === 7957616) + return hA.PLY; + if ((I & 16777215) === 559903) { + const g = eC(Q, 4); + return new DataView(g.buffer).getUint32(0, !0) === 1347635022 ? hA.SPZ : void 0; + } + if (I === 67324752) + return wR(Q) ? hA.PCSOGSZIP : void 0; + if (I === 809779538) + return hA.RAD; +} +function iR(Q) { + const A = Q.split(/[?#]/, 1)[0], I = Math.max( + A.lastIndexOf("/"), + A.lastIndexOf("\\") + ), g = A.slice(I + 1), B = g.lastIndexOf("."); + return B <= 0 || B === g.length - 1 ? "" : g.slice(B + 1).toLowerCase(); +} +function cB(Q) { + const A = iR(Q); + if (A === "ply") + return hA.PLY; + if (A === "spz") + return hA.SPZ; + if (A === "splat") + return hA.SPLAT; + if (A === "ksplat") + return hA.KSPLAT; + if (A === "sog") + return hA.PCSOGSZIP; + if (A === "rad") + return hA.RAD; +} +function bk(Q) { + return Pw(Q) !== void 0; +} +function Pw(Q) { + try { + let A; + if (typeof Q == "string") + A = Q; + else { + const B = Q instanceof ArrayBuffer ? new Uint8Array(Q) : Q; + if (B.length > 65536) + return; + A = new TextDecoder().decode(B); + } + const I = JSON.parse(A); + if (!I || typeof I != "object" || Array.isArray(I)) + return; + const g = I.version === 2; + for (const B of ["means", "scales", "quats", "sh0"]) { + if (!I[B] || typeof I[B] != "object" || Array.isArray(I[B])) + return; + if (g) { + if (!I[B].files || (B === "scales" || B === "sh0") && !I[B].codebook || B === "means" && (!I[B].mins || !I[B].maxs)) + return; + } else if (!I[B].shape || !I[B].files || B !== "quats" && (!I[B].mins || !I[B].maxs)) + return; + } + return I; + } catch { + return; + } +} +function wR(Q) { + try { + const A = Q instanceof ArrayBuffer ? new Uint8Array(Q) : Q; + let I = null; + const g = Ko(A, { + filter: ({ name: C }) => C.split(/[\\/]/).pop() === "meta.json" ? (I = C, !0) : !1 + }); + if (!I) + return; + const B = Pw(g[I]); + return B ? { name: I, json: B } : void 0; + } catch { + return; + } +} +async function Pk({ + input: Q, + extraFiles: A, + fileType: I, + pathOrUrl: g, + splatEncoding: B +}) { + const C = Q instanceof ArrayBuffer ? new Uint8Array(Q) : Q; + let E = I; + switch (I || (E = NB(C), !E && g && (E = cB(g))), E) { + case hA.PLY: { + const D = new Wg({ fileBytes: C }); + await D.parseHeader(); + const i = D.numSplats, w = BA(i).maxSplats, s = { + fileBytes: C, + packedArray: new Uint32Array(w * 4), + splatEncoding: B + }; + return await nI(async (o) => { + const { packedArray: y, numSplats: h, extra: k } = await o.call( + "unpackPly", + s + ); + return { packedArray: y, numSplats: h, extra: k }; + }); + } + case hA.SPZ: + return await nI(async (D) => { + const { packedArray: i, numSplats: w, extra: s } = await D.call( + "decodeSpz", + { + fileBytes: C, + splatEncoding: B + } + ); + return { packedArray: i, numSplats: w, extra: s }; + }); + case hA.SPLAT: + return await nI(async (D) => { + const { packedArray: i, numSplats: w } = await D.call( + "decodeAntiSplat", + { + fileBytes: C, + splatEncoding: B + } + ); + return { packedArray: i, numSplats: w }; + }); + case hA.KSPLAT: + return await nI(async (D) => { + const { packedArray: i, numSplats: w, extra: s } = await D.call( + "decodeKsplat", + { fileBytes: C, splatEncoding: B } + ); + return { packedArray: i, numSplats: w, extra: s }; + }); + case hA.PCSOGS: + return await nI(async (D) => { + const { packedArray: i, numSplats: w, extra: s } = await D.call( + "decodePcSogs", + { fileBytes: C, extraFiles: A, splatEncoding: B } + ); + return { packedArray: i, numSplats: w, extra: s }; + }); + case hA.PCSOGSZIP: + return await nI(async (D) => { + const { packedArray: i, numSplats: w, extra: s } = await D.call( + "decodePcSogsZip", + { fileBytes: C, splatEncoding: B } + ); + return { packedArray: i, numSplats: w, extra: s }; + }); + default: + throw new Error(`Unknown splat file type: ${E}`); + } +} +class oR { + constructor({ maxSplats: A = 1 } = {}) { + this.numSplats = 0, this.maxSplats = BA(A).maxSplats, this.centers = new Float32Array(this.maxSplats * 3), this.scales = new Float32Array(this.maxSplats * 3), this.quaternions = new Float32Array(this.maxSplats * 4), this.opacities = new Float32Array(this.maxSplats), this.colors = new Float32Array(this.maxSplats * 3); + } + pushSplat() { + const A = this.numSplats; + return this.ensureIndex(A), this.numSplats += 1, A; + } + unpushSplat(A) { + if (A === this.numSplats - 1) + this.numSplats -= 1; + else + throw new Error("Cannot unpush splat from non-last position"); + } + ensureCapacity(A) { + if (A > this.maxSplats) { + const I = Math.max(A, this.maxSplats * 2), g = new Float32Array(I * 3), B = new Float32Array(I * 3), C = new Float32Array(I * 4), E = new Float32Array(I), D = new Float32Array(I * 3); + if (g.set(this.centers), B.set(this.scales), C.set(this.quaternions), E.set(this.opacities), D.set(this.colors), this.centers = g, this.scales = B, this.quaternions = C, this.opacities = E, this.colors = D, this.sh1) { + const i = new Float32Array(I * 9); + i.set(this.sh1), this.sh1 = i; + } + if (this.sh2) { + const i = new Float32Array(I * 15); + i.set(this.sh2), this.sh2 = i; + } + if (this.sh3) { + const i = new Float32Array(I * 21); + i.set(this.sh3), this.sh3 = i; + } + this.maxSplats = I; + } + } + ensureIndex(A) { + this.ensureCapacity(A + 1); + } + setCenter(A, I, g, B) { + this.centers[A * 3] = I, this.centers[A * 3 + 1] = g, this.centers[A * 3 + 2] = B; + } + setScale(A, I, g, B) { + this.scales[A * 3] = I, this.scales[A * 3 + 1] = g, this.scales[A * 3 + 2] = B; + } + setQuaternion(A, I, g, B, C) { + this.quaternions[A * 4] = I, this.quaternions[A * 4 + 1] = g, this.quaternions[A * 4 + 2] = B, this.quaternions[A * 4 + 3] = C; + } + setOpacity(A, I) { + this.opacities[A] = I; + } + setColor(A, I, g, B) { + this.colors[A * 3] = I, this.colors[A * 3 + 1] = g, this.colors[A * 3 + 2] = B; + } + setSh1(A, I) { + this.sh1 || (this.sh1 = new Float32Array(this.maxSplats * 9)); + for (let g = 0; g < 9; ++g) + this.sh1[A * 9 + g] = I[g]; + } + setSh2(A, I) { + this.sh2 || (this.sh2 = new Float32Array(this.maxSplats * 15)); + for (let g = 0; g < 15; ++g) + this.sh2[A * 15 + g] = I[g]; + } + setSh3(A, I) { + this.sh3 || (this.sh3 = new Float32Array(this.maxSplats * 21)); + for (let g = 0; g < 21; ++g) + this.sh3[A * 21 + g] = I[g]; + } +} +const YA = class YA { + constructor(A = {}) { + this.maxSplats = 0, this.numSplats = 0, this.packedArray = null, this.maxSh = 3, this.isInitialized = !1, this.target = null, this.source = null, this.needsUpdate = !0, this.extra = {}, this.dyno = new MB({ packedSplats: this }), this.dynoRgbMinMaxLnScaleMinMax = new mI({ + key: "rgbMinMaxLnScaleMinMax", + value: new G.Vector4(0, 1, pA, fA), + update: (I) => { + var g, B, C, E; + return I.set( + ((g = this.splatEncoding) == null ? void 0 : g.rgbMin) ?? 0, + ((B = this.splatEncoding) == null ? void 0 : B.rgbMax) ?? 1, + ((C = this.splatEncoding) == null ? void 0 : C.lnScaleMin) ?? pA, + ((E = this.splatEncoding) == null ? void 0 : E.lnScaleMax) ?? fA + ), I; + } + }), this.dynoNumSh = new EI({ + key: "numSh", + value: 0, + update: () => Math.min(this.getNumSh(), this.maxSh) + }), this.dynoShMax = new DI({ + key: "shMax", + value: new G.Vector3(), + update: (I) => { + var g, B, C; + return I.set( + ((g = this.splatEncoding) == null ? void 0 : g.sh1Max) ?? 1, + ((B = this.splatEncoding) == null ? void 0 : B.sh2Max) ?? 1, + ((C = this.splatEncoding) == null ? void 0 : C.sh3Max) ?? 1 + ), I; + } + }), this.initialized = Promise.resolve(this), this.reinitialize(A); + } + reinitialize(A) { + this.isInitialized = !1, this.extra = {}, this.maxSplats = A.maxSplats ?? 0, this.splatEncoding = A.splatEncoding, this.lod = A.lod, this.nonLod = A.nonLod, A.url || A.fileBytes || A.stream || A.construct ? this.initialized = this.asyncInitialize(A).then(() => (this.isInitialized = !0, this)) : (this.initialize(A), this.isInitialized = !0, this.initialized = Promise.resolve(this)); + } + initialize(A) { + this.extra = A.extra ?? {}, this.splatEncoding = A.splatEncoding ?? this.splatEncoding, this.lodSplats = A.lodSplats, A.packedArray ? (this.packedArray = A.packedArray, this.numSplats = A.numSplats ?? this.packedArray.length / 4, this.maxSplats = Math.floor(this.packedArray.length / 4), this.maxSplats = Math.floor(this.maxSplats / P) * P, this.numSplats = Math.min( + this.maxSplats, + A.numSplats ?? Number.POSITIVE_INFINITY + )) : (this.maxSplats = A.maxSplats ?? 0, this.numSplats = 0); + } + async asyncInitialize(A) { + const { + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + construct: i, + lod: w, + nonLod: s, + lodAbove: o + } = A; + this.lod = w, this.nonLod = s; + const y = new bw(); + if ((g || I || E) && await y.loadInternalAsync({ + packedSplats: this, + url: I, + fileBytes: g, + fileType: B, + fileName: C, + stream: E, + streamLength: D, + onProgress: A.onProgress, + lodAbove: o + }), i) { + const h = i(this); + h instanceof Promise && await h; + } + } + // Call this when you are finished with the PackedSplats and want to free + // any buffers it holds. + dispose() { + this.target && (this.target.dispose(), this.target.texture.source.data = null, this.target = null), this.source && (this.source.dispose(), this.source.source.data = null, this.source = null), this.packedArray = null; + for (const A in this.extra) { + const I = this.extra[A]; + if (I instanceof x) { + const g = I.value; + g != null && g.isTexture && (g.dispose(), g.source.data = null); + } + } + this.extra = {}, this.disposeLodSplats(); + } + prepareFetchSplat() { + } + getNumSplats() { + return this.numSplats; + } + hasRgbDir() { + return Math.min(this.getNumSh(), this.maxSh) > 0; + } + getNumSh() { + return this.extra.sh1 ? this.extra.sh2 ? this.extra.sh3 ? 3 : 2 : 1 : 0; + } + setMaxSh(A) { + this.maxSh = A; + } + fetchSplat({ + index: A, + viewOrigin: I + }) { + let g = _I(this.dyno, A); + if (this.hasRgbDir() && I) { + const B = uA(g).outputs.center, C = Sg(iI(B, I)), { sh1Texture: E, sh2Texture: D, sh3Texture: i } = this.ensureShTextures(); + let { rgb: w } = uw({ + coord: EB(A), + viewDir: C, + numSh: this.dynoNumSh, + sh1Texture: E, + sh2Texture: D, + sh3Texture: i, + shMax: this.dynoShMax + }); + w = qA(w, uA(g).outputs.rgb), g = CI({ gsplat: g, rgb: w }); + } + return g; + } + ensureShTextures() { + if (!this.extra.sh1) + return {}; + let A = this.extra.sh1Texture; + if (!A) { + let B = this.extra.sh1; + const { width: C, height: E, depth: D, maxSplats: i } = BA( + B.length / 2 + ); + if (B.length < i * 2) { + const s = new Uint32Array(i * 2); + s.set(B), this.extra.sh1 = s, B = s; + } + const w = new G.DataArrayTexture(B, C, E, D); + w.format = G.RGIntegerFormat, w.type = G.UnsignedIntType, w.internalFormat = "RG32UI", w.needsUpdate = !0, A = new dA({ + value: w, + key: "sh1" + }), this.extra.sh1Texture = A; + } + if (!this.extra.sh2) + return { sh1Texture: A }; + let I = this.extra.sh2Texture; + if (!I) { + let B = this.extra.sh2; + const { width: C, height: E, depth: D, maxSplats: i } = BA( + B.length / 4 + ); + if (B.length < i * 4) { + const s = new Uint32Array(i * 4); + s.set(B), this.extra.sh2 = s, B = s; + } + const w = new G.DataArrayTexture(B, C, E, D); + w.format = G.RGBAIntegerFormat, w.type = G.UnsignedIntType, w.internalFormat = "RGBA32UI", w.needsUpdate = !0, I = new dA({ + value: w, + key: "sh2" + }), this.extra.sh2Texture = I; + } + if (!this.extra.sh3) + return { sh1Texture: A, sh2Texture: I }; + let g = this.extra.sh3Texture; + if (!g) { + let B = this.extra.sh3; + const { width: C, height: E, depth: D, maxSplats: i } = BA( + B.length / 4 + ); + if (B.length < i * 4) { + const s = new Uint32Array(i * 4); + s.set(B), this.extra.sh3 = s, B = s; + } + const w = new G.DataArrayTexture(B, C, E, D); + w.format = G.RGBAIntegerFormat, w.type = G.UnsignedIntType, w.internalFormat = "RGBA32UI", w.needsUpdate = !0, g = new dA({ + value: w, + key: "sh3" + }), this.extra.sh3Texture = g; + } + return { sh1Texture: A, sh2Texture: I, sh3Texture: g }; + } + // Ensures that this.packedArray can fit numSplats Gsplats. If it's too small, + // resize exponentially and copy over the original data. + // + // Typically you don't need to call this, because calling this.setSplat(index, ...) + // and this.pushSplat(...) will automatically call ensureSplats() so we have + // enough splats. + ensureSplats(A) { + const I = A <= this.maxSplats ? this.maxSplats : ( + // Grow exponentially to avoid frequent reallocations + Math.max(A, 2 * this.maxSplats) + ), g = this.packedArray ? this.packedArray.length / 4 : 0; + if (!this.packedArray || I > g) { + this.maxSplats = BA(I).maxSplats; + const B = new Uint32Array(this.maxSplats * 4); + this.packedArray && B.set(this.packedArray), this.packedArray = B; + } + return this.packedArray; + } + // Ensure the extra array for the given level is large enough to hold numSplats + ensureSplatsSh(A, I) { + let g, B; + if (A === 0) + return this.ensureSplats(I); + if (A === 1) + g = 2, B = "sh1"; + else if (A === 2) + g = 4, B = "sh2"; + else if (A === 3) + g = 4, B = "sh3"; + else + throw new Error(`Invalid level: ${A}`); + let C = this.extra[B] ? this.extra[B].length / g : 0; + const E = I <= C ? C : Math.max(I, 2 * C); + if (!this.extra[B] || E > C) { + C = BA(E).maxSplats; + const D = new Uint32Array(C * g); + this.extra[B] && D.set(this.extra[B]), this.extra[B] = D; + } + return this.extra[B]; + } + // Unpack the 16-byte Gsplat data at index into the Three.js components + // center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, + // opacity: number 0..1, color: THREE.Color 0..1. + getSplat(A) { + if (!this.packedArray || A >= this.numSplats) + throw new Error("Invalid index"); + return nQ(this.packedArray, A, this.splatEncoding); + } + // Set all PackedSplat components at index with the provided Gsplat attributes + // (can be the same objects returned by getSplat). Ensures there is capacity + // for at least index+1 Gsplats. + setSplat(A, I, g, B, C, E) { + const D = this.ensureSplats(A + 1); + rQ( + D, + A, + I.x, + I.y, + I.z, + g.x, + g.y, + g.z, + B.x, + B.y, + B.z, + B.w, + C, + E.r, + E.g, + E.b + ), this.numSplats = Math.max(this.numSplats, A + 1); + } + // Effectively calls this.setSplat(this.numSplats++, center, ...), useful on + // construction where you just want to iterate and create a collection of Gsplats. + pushSplat(A, I, g, B, C) { + const E = this.ensureSplats(this.numSplats + 1); + rQ( + E, + this.numSplats, + A.x, + A.y, + A.z, + I.x, + I.y, + I.z, + g.x, + g.y, + g.z, + g.w, + B, + C.r, + C.g, + C.b + ), ++this.numSplats; + } + // Iterate over Gsplats index 0..=(this.numSplats-1), unpack each Gsplat + // and invoke the callback function with the Gsplat attributes. + forEachSplat(A) { + if (!(!this.packedArray || !this.numSplats)) + for (let I = 0; I < this.numSplats; ++I) { + const g = nQ(this.packedArray, I, this.splatEncoding); + A( + I, + g.center, + g.scales, + g.quaternion, + g.opacity, + g.color + ); + } + } + // Ensures our PackedSplats.target render target has enough space to generate + // maxSplats total Gsplats, and reallocate if not large enough. + ensureGenerate(A) { + if (this.target && (A ?? 1) <= this.maxSplats) + return !1; + this.target && this.target.dispose(); + const I = BA(A ?? 1), { width: g, height: B, depth: C } = I; + return this.maxSplats = I.maxSplats, this.target = new G.WebGLArrayRenderTarget(g, B, C, { + depthBuffer: !1, + stencilBuffer: !1, + generateMipmaps: !1, + magFilter: G.NearestFilter, + minFilter: G.NearestFilter + }), this.target.texture.format = G.RGBAIntegerFormat, this.target.texture.type = G.UnsignedIntType, this.target.texture.internalFormat = "RGBA32UI", this.target.scissorTest = !0, !0; + } + // Given an array of splatCounts (.numSplats for each + // SplatGenerator/SplatMesh in the scene), compute a + // "mapping layout" in the composite array of generated outputs. + generateMapping(A) { + let I = 0; + const g = A.map((B) => { + const C = I, E = Math.ceil(B / P) * P; + return I += E, { base: C, count: B }; + }); + return { maxSplats: I, mapping: g }; + } + // Returns a THREE.DataArrayTexture representing the PackedSplats content as + // a Uint32x4 data array texture (2048 x 2048 x depth in size) + getTexture() { + return this.target ? this.target.texture : this.source || this.packedArray ? this.maybeUpdateSource() : YA.getEmptyArray; + } + // Check if source texture needs to be created/updated + maybeUpdateSource() { + if (!this.packedArray) + throw new Error("No packed splats"); + if (this.needsUpdate || !this.source) { + if (this.needsUpdate = !1, this.source) { + const { width: A, height: I, depth: g } = this.source.image; + this.maxSplats !== A * I * g && (this.source.dispose(), this.source = null); + } + if (this.source) + this.packedArray.buffer !== this.source.image.data.buffer && (this.source.image.data = new Uint8Array(this.packedArray.buffer)); + else { + const { width: A, height: I, depth: g } = BA(this.maxSplats); + this.source = new G.DataArrayTexture( + this.packedArray, + A, + I, + g + ), this.source.format = G.RGBAIntegerFormat, this.source.type = G.UnsignedIntType, this.source.internalFormat = "RGBA32UI", this.source.needsUpdate = !0; + } + this.source.needsUpdate = !0; + } + return this.source; + } + // Get a program and THREE.RawShaderMaterial for a given GsplatGenerator, + // generating it if necessary and caching the result. + prepareProgramMaterial(A) { + let I = YA.generatorProgram.get(A); + if (!I) { + const B = cA( + { index: "int" }, + {}, + ({ index: C }, E, { roots: D }) => { + A.inputs.index = C; + const i = A.outputs.gsplat, w = wB( + i, + this.dynoRgbMinMaxLnScaleMinMax + ); + D.push(w); + } + ); + YA.programTemplate || (YA.programTemplate = new Fg( + Ag().computeUvec4Template + )), I = new CQ({ + graph: B, + inputs: { index: "_index" }, + outputs: { output: "target" }, + template: YA.programTemplate + }), Object.assign(I.uniforms, { + targetLayer: { value: 0 }, + targetBase: { value: 0 }, + targetCount: { value: 0 } + }), YA.generatorProgram.set(A, I); + } + const g = I.prepareMaterial(); + return YA.fullScreenQuad.material = g, { program: I, material: g }; + } + saveRenderState(A) { + return { + target: A.getRenderTarget(), + xrEnabled: A.xr.enabled, + autoClear: A.autoClear + }; + } + resetRenderState(A, I) { + A.setRenderTarget(I.target), A.xr.enabled = I.xrEnabled, A.autoClear = I.autoClear; + } + // Executes a dyno program specified by generator which is any DynoBlock that + // maps { index: "int" } to { gsplat: Gsplat }. This is called in + // SparkRenderer.updateInternal() to re-generate Gsplats in the scene for + // SplatGenerator instances whose version is newer than what was generated + // for it last time. + generate({ + generator: A, + base: I, + count: g, + renderer: B + }) { + if (!this.target) + throw new Error("Target must be initialized with ensureSplats"); + if (I + g > this.maxSplats) + throw new Error("Base + count exceeds maxSplats"); + const { program: C, material: E } = this.prepareProgramMaterial(A); + C.update(); + const D = this.saveRenderState(B), i = Math.ceil((I + g) / P) * P, w = P * XA; + for (E.uniforms.targetBase.value = I, E.uniforms.targetCount.value = g; I < i; ) { + const s = Math.floor(I / w); + E.uniforms.targetLayer.value = s; + const o = s * w, y = Math.floor((I - o) / P), h = Math.min( + XA, + Math.ceil((i - o) / P) + ); + this.target.scissor.set( + 0, + y, + P, + h - y + ), B.setRenderTarget(this.target, s), B.xr.enabled = !1, B.autoClear = !1, YA.fullScreenQuad.render(B), I += P * (h - y); + } + return this.resetRenderState(B, D), { nextBase: i }; + } + disposeLodSplats() { + this.lodSplats && (this.lodSplats.dispose(), this.lodSplats = void 0); + } + async createLodSplats({ + rgbaArray: A, + quality: I + } = {}) { + const g = typeof this.lod == "number" ? Math.max(1.1, Math.min(2, this.lod)) : I ? 1.75 : 1.5, B = this.packedArray.slice(), C = A ? (await A.getArray()).slice() : void 0, E = { + sh1: this.extra.sh1 ? this.extra.sh1.slice() : void 0, + sh2: this.extra.sh2 ? this.extra.sh2.slice() : void 0, + sh3: this.extra.sh3 ? this.extra.sh3.slice() : void 0 + }, D = await gQ.withWorker(async (w) => await w.call( + I ? "qualityLodPackedSplats" : "tinyLodPackedSplats", + { + numSplats: this.numSplats, + packedArray: B, + extra: E, + lodBase: g, + rgba: C, + encoding: this.splatEncoding ?? cg + } + )), i = new YA(D); + this.lodSplats && this.lodSplats.dispose(), this.lodSplats = i, this.nonLod = !0, this.lod = I ? "quality" : !0; + } + extractSplats(A, I) { + const g = BA(A.length).maxSplats, B = new YA({ maxSplats: g }); + for (let C = 0; C < A.length; C++) { + const E = this.getSplat(A[C]); + if (I) { + let D = (A[C] >>> 16) * 0.61803398875; + D = D - Math.floor(D); + const i = Math.max(0, Math.min(1, Math.abs(D * 6 - 3) - 1)), w = Math.max(0, Math.min(1, Math.abs(D * 6 + 1) - 1)), s = Math.max(0, Math.min(1, Math.abs(D * 6 - 1) - 1)); + E.color.r *= i, E.color.g *= w, E.color.b *= s; + } + B.pushSplat( + E.center, + E.scales, + E.quaternion, + E.opacity, + E.color + ); + } + return B; + } +}; +YA.getEmptyArray = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 4), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGBAIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RGBA32UI", E.needsUpdate = !0, E; +})(), YA.programTemplate = null, YA.generatorProgram = /* @__PURE__ */ new WeakMap(), YA.fullScreenQuad = new QB( + new G.RawShaderMaterial({ visible: !1 }) +), YA.emptyUint32x4 = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 4), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGBAIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RGBA32UI", E.needsUpdate = !0, E; +})(), YA.emptyUint32x2 = (() => { + const { width: A, height: I, depth: g, maxSplats: B } = BA(1), C = new Uint32Array(B * 2), E = new G.DataArrayTexture( + C, + A, + I, + g + ); + return E.format = G.RGIntegerFormat, E.type = G.UnsignedIntType, E.internalFormat = "RG32UI", E.needsUpdate = !0, E; +})(); +let $A = YA; +class MB extends x { + constructor({ packedSplats: A } = {}) { + super({ + key: "packedSplats", + type: tg, + globals: () => [QQ], + value: { + textureArray: $A.getEmptyArray, + numSplats: 0, + rgbMinMaxLnScaleMinMax: new G.Vector4( + 0, + 1, + pA, + fA + ), + lodOpacity: !1 + }, + update: (I) => { + var g, B, C, E, D, i, w, s, o, y, h, k; + return I.textureArray = ((g = this.packedSplats) == null ? void 0 : g.getTexture()) ?? $A.getEmptyArray, I.numSplats = ((B = this.packedSplats) == null ? void 0 : B.numSplats) ?? 0, I.rgbMinMaxLnScaleMinMax.set( + ((E = (C = this.packedSplats) == null ? void 0 : C.splatEncoding) == null ? void 0 : E.rgbMin) ?? 0, + ((i = (D = this.packedSplats) == null ? void 0 : D.splatEncoding) == null ? void 0 : i.rgbMax) ?? 1, + ((s = (w = this.packedSplats) == null ? void 0 : w.splatEncoding) == null ? void 0 : s.lnScaleMin) ?? pA, + ((y = (o = this.packedSplats) == null ? void 0 : o.splatEncoding) == null ? void 0 : y.lnScaleMax) ?? fA + ), I.lodOpacity = ((k = (h = this.packedSplats) == null ? void 0 : h.splatEncoding) == null ? void 0 : k.lodOpacity) ?? !1, I; + } + }), this.packedSplats = A; + } +} +const sR = oA(` + vec3 evaluatePackedSH1(uvec2 packed, vec3 viewDir, float sh1Max) { + // Extract sint7 values packed into 2 x uint32 + vec3 sh1_0 = vec3(ivec3( + int(packed.x << 25u) >> 25, + int(packed.x << 18u) >> 25, + int(packed.x << 11u) >> 25 + )); + vec3 sh1_1 = vec3(ivec3( + int(packed.x << 4u) >> 25, + int((packed.x >> 3u) | (packed.y << 29u)) >> 25, + int(packed.y << 22u) >> 25 + )); + vec3 sh1_2 = vec3(ivec3( + int(packed.y << 15u) >> 25, + int(packed.y << 8u) >> 25, + int(packed.y << 1u) >> 25 + )); + + vec3 rgb = sh1_0 * (-0.4886025 * viewDir.y) + + sh1_1 * (0.4886025 * viewDir.z) + + sh1_2 * (-0.4886025 * viewDir.x); + return rgb * (sh1Max / 63.0); + } +`), GR = oA(` + vec3 evaluatePackedSH2(uvec4 packed, vec3 viewDir, float sh2Max) { + // Extract sint8 values packed into 4 x uint32 + vec3 sh2_0 = vec3(ivec3( + int(packed.x << 24u) >> 24, + int(packed.x << 16u) >> 24, + int(packed.x << 8u) >> 24 + )); + vec3 sh2_1 = vec3(ivec3( + int(packed.x) >> 24, + int(packed.y << 24u) >> 24, + int(packed.y << 16u) >> 24 + )); + vec3 sh2_2 = vec3(ivec3( + int(packed.y << 8u) >> 24, + int(packed.y) >> 24, + int(packed.z << 24u) >> 24 + )); + vec3 sh2_3 = vec3(ivec3( + int(packed.z << 16u) >> 24, + int(packed.z << 8u) >> 24, + int(packed.z) >> 24 + )); + vec3 sh2_4 = vec3(ivec3( + int(packed.w << 24u) >> 24, + int(packed.w << 16u) >> 24, + int(packed.w << 8u) >> 24 + )); + + vec3 rgb = sh2_0 * (1.0925484 * viewDir.x * viewDir.y) + + sh2_1 * (-1.0925484 * viewDir.y * viewDir.z) + + sh2_2 * (0.3153915 * (2.0 * viewDir.z * viewDir.z - viewDir.x * viewDir.x - viewDir.y * viewDir.y)) + + sh2_3 * (-1.0925484 * viewDir.x * viewDir.z) + + sh2_4 * (0.5462742 * (viewDir.x * viewDir.x - viewDir.y * viewDir.y)); + return rgb * (sh2Max / 127.0); + } +`), yR = oA(` + vec3 evaluatePackedSH3(uvec4 packed, vec3 viewDir, float sh3Max) { + // Extract sint6 values packed into 4 x uint32 + vec3 sh3_0 = vec3(ivec3( + int(packed.x << 26u) >> 26, + int(packed.x << 20u) >> 26, + int(packed.x << 14u) >> 26 + )); + vec3 sh3_1 = vec3(ivec3( + int(packed.x << 8u) >> 26, + int(packed.x << 2u) >> 26, + int((packed.x >> 4u) | (packed.y << 28u)) >> 26 + )); + vec3 sh3_2 = vec3(ivec3( + int(packed.y << 22u) >> 26, + int(packed.y << 16u) >> 26, + int(packed.y << 10u) >> 26 + )); + vec3 sh3_3 = vec3(ivec3( + int(packed.y << 4u) >> 26, + int((packed.y >> 2u) | (packed.z << 30u)) >> 26, + int(packed.z << 24u) >> 26 + )); + vec3 sh3_4 = vec3(ivec3( + int(packed.z << 18u) >> 26, + int(packed.z << 12u) >> 26, + int(packed.z << 6u) >> 26 + )); + vec3 sh3_5 = vec3(ivec3( + int(packed.z) >> 26, + int(packed.w << 26u) >> 26, + int(packed.w << 20u) >> 26 + )); + vec3 sh3_6 = vec3(ivec3( + int(packed.w << 14u) >> 26, + int(packed.w << 8u) >> 26, + int(packed.w << 2u) >> 26 + )); + + float xx = viewDir.x * viewDir.x; + float yy = viewDir.y * viewDir.y; + float zz = viewDir.z * viewDir.z; + float xy = viewDir.x * viewDir.y; + float yz = viewDir.y * viewDir.z; + float zx = viewDir.z * viewDir.x; + + vec3 rgb = sh3_0 * (-0.5900436 * viewDir.y * (3.0 * xx - yy)) + + sh3_1 * (2.8906114 * xy * viewDir.z) + + + sh3_2 * (-0.4570458 * viewDir.y * (4.0 * zz - xx - yy)) + + sh3_3 * (0.3731763 * viewDir.z * (2.0 * zz - 3.0 * xx - 3.0 * yy)) + + sh3_4 * (-0.4570458 * viewDir.x * (4.0 * zz - xx - yy)) + + sh3_5 * (1.4453057 * viewDir.z * (xx - yy)) + + sh3_6 * (-0.5900436 * viewDir.x * (xx - 3.0 * yy)); + return rgb * (sh3Max / 31.0); + } +`); +function uw({ + coord: Q, + viewDir: A, + numSh: I, + sh1Texture: g, + sh2Texture: B, + sh3Texture: C, + shMax: E +}) { + return new d({ + inTypes: { + coord: "ivec3", + viewDir: "vec3", + numSh: "int", + sh1Texture: "usampler2DArray", + sh2Texture: "usampler2DArray", + sh3Texture: "usampler2DArray", + shMax: "vec3" + }, + outTypes: { rgb: "vec3" }, + inputs: { + coord: Q, + viewDir: A, + numSh: I, + sh1Texture: g, + sh2Texture: B, + sh3Texture: C, + shMax: E + }, + globals: () => [ + sR, + GR, + yR + ], + statements: ({ inputs: D, outputs: i }) => { + const w = ["vec3 rgb = vec3(0.0);"]; + return D.sh1Texture && (w.push( + ...z(` + if (${D.numSh} >= 1) { + vec3 sh1Rgb = evaluatePackedSH1(texelFetch(${D.sh1Texture}, ${D.coord}, 0).rg, ${D.viewDir}, ${D.shMax}.x); + rgb += sh1Rgb; + `) + ), D.sh2Texture && (w.push( + ...z(` + if (${D.numSh} >= 2) { + vec3 sh2Rgb = evaluatePackedSH2(texelFetch(${D.sh2Texture}, ${D.coord}, 0), ${D.viewDir}, ${D.shMax}.y); + rgb += sh2Rgb; + `) + ), D.sh3Texture && w.push( + ...z(` + if (${D.numSh} >= 3) { + vec3 sh3Rgb = evaluatePackedSH3(texelFetch(${D.sh3Texture}, ${D.coord}, 0), ${D.viewDir}, ${D.shMax}.z); + rgb += sh3Rgb; + } + `) + ), w.push("}")), w.push("}")), w.push(`${i.rgb} = rgb;`), w; + } + }).outputs; +} +const JI = class JI { + constructor(A) { + if (this.lastTime = null, this.encodeLinear = !1, this.superXY = 1, this.display = null, this.sorting = null, this.pending = null, this.sortingCheck = !1, this.readback16 = new Uint16Array(0), this.readback32 = new Uint32Array(0), this.spark = A.spark, this.camera = A.camera, this.viewToWorld = A.viewToWorld ?? new G.Matrix4(), A.target) { + const { width: I, height: g, doubleBuffer: B } = A.target, C = Math.max(1, Math.min(4, A.target.superXY ?? 1)); + if (this.superXY = C, I * C > 8192 || g * C > 8192) + throw new Error("Target size too large"); + this.target = new G.WebGLRenderTarget( + I * C, + g * C, + { + format: G.RGBAFormat, + type: G.UnsignedByteType, + colorSpace: G.SRGBColorSpace + } + ), B && (this.back = new G.WebGLRenderTarget( + I * C, + g * C, + { + format: G.RGBAFormat, + type: G.UnsignedByteType, + colorSpace: G.SRGBColorSpace + } + )), this.encodeLinear = !0; + } + this.onTextureUpdated = A.onTextureUpdated, this.sortRadial = A.sortRadial ?? !0, this.sortDistance = A.sortDistance, this.sortCoorient = A.sortCoorient, this.depthBias = A.depthBias, this.sort360 = A.sort360, this.sort32 = A.sort32, this.stochastic = A.stochastic ?? !1, this.orderingFreelist = new aC({ + allocate: (I) => new Uint32Array(I), + valid: (I, g) => I.length === g + }), this.autoUpdate = !1, this.setAutoUpdate(A.autoUpdate ?? !1); + } + // Call this when you are done with the SparkViewpoint and want to + // free up its resources (GPU targets, pixel buffers, etc.) + dispose() { + var A; + this.setAutoUpdate(!1), this.target && (this.target.dispose(), this.target = void 0), this.back && (this.back.dispose(), this.back = void 0), this.display && (this.spark.releaseAccumulator(this.display.accumulator), this.display.geometry.dispose(), this.display = null), (A = this.pending) != null && A.accumulator && (this.spark.releaseAccumulator(this.pending.accumulator), this.pending = null); + } + // Use this function to change whether this viewpoint will auto-update + // its sort order whenever the attached SparkRenderer updates the Gsplats. + // Turn this on or off depending on whether you expect to do renders from + // this viewpoint most frames. + setAutoUpdate(A) { + !this.autoUpdate && A ? this.spark.autoViewpoints.push(this) : this.autoUpdate && !A && (this.spark.autoViewpoints = this.spark.autoViewpoints.filter( + (I) => I !== this + )), this.autoUpdate = A; + } + // See below async prepareRenderPixels() for explanation of parameters. + // Awaiting this method updates the Gsplats in the scene and performs a sort of the + // Gsplats from this viewpoint, preparing it for a subsequent this.renderTarget() + // call in the same tick. + async prepare({ + scene: A, + camera: I, + viewToWorld: g, + update: B, + forceOrigin: C + }) { + for (g ? this.viewToWorld = g : (this.camera = I ?? this.camera, this.camera && (this.camera.updateMatrixWorld(), this.viewToWorld = this.camera.matrixWorld.clone())); B ?? !0; ) { + const D = C ? this.viewToWorld : this.spark.matrixWorld; + if (this.spark.updateInternal({ scene: A, originToWorld: D })) + break; + await new Promise((w) => setTimeout(w, 10)); + } + const E = this.spark.active; + E.refCount += 1, await this.sortUpdate({ accumulator: E, viewToWorld: this.viewToWorld }), this.spark.releaseAccumulator(E); + } + // Render out the viewpoint to the view target RGBA buffer. + // Swaps buffers if doubleBuffer: true was set. + // Calls onTextureUpdated(texture) with the resulting texture. + renderTarget({ + scene: A, + camera: I + }) { + var C; + const g = this.back ?? this.target; + if (!g) + throw new Error("Must initialize SparkViewpoint with target"); + if (I = I ?? this.camera, !I) + throw new Error("Must provide camera"); + if (I instanceof G.PerspectiveCamera) { + const E = new G.PerspectiveCamera().copy(I, !1); + E.aspect = g.width / g.height, E.updateProjectionMatrix(), I = E; + } + this.viewToWorld = I.matrixWorld.clone(); + const B = this.spark.renderer.getRenderTarget(); + try { + this.spark.renderer.setRenderTarget(g), this.spark.prepareViewpoint(this), this.spark.renderer.render(A, I); + } finally { + this.spark.prepareViewpoint(this.spark.defaultView), this.spark.renderer.setRenderTarget(B); + } + g !== this.target && ([this.target, this.back] = [this.back, this.target]), (C = this.onTextureUpdated) == null || C.call(this, g.texture); + } + // Read back the previously rendered target image as a Uint8Array of packed + // RGBA values (in that order). If superXY was set greater than 1 then + // downsampling is performed in the target pixel array with simple averaging + // to derive the returned pixel values. Subsequent calls to this.readTarget() + // will reuse the same buffers to minimize memory allocations. + async readTarget() { + if (!this.target) + throw new Error("Must initialize SparkViewpoint with target"); + const { width: A, height: I } = this.target, g = A * I * 4; + (!this.superPixels || this.superPixels.length < g) && (this.superPixels = new Uint8Array(g)), await this.spark.renderer.readRenderTargetPixelsAsync( + this.target, + 0, + 0, + A, + I, + this.superPixels + ); + const { superXY: B } = this; + if (B === 1) + return this.superPixels; + const C = A / B, E = I / B, D = C * E * 4; + (!this.pixels || this.pixels.length < D) && (this.pixels = new Uint8Array(D)); + const { superPixels: i, pixels: w } = this, s = B * B; + for (let o = 0; o < E; o++) { + const y = o * C; + for (let h = 0; h < C; h++) { + const k = h * B; + let R = 0, F = 0, S = 0, a = 0; + for (let c = 0; c < B; c++) { + const N = (o * B + c) * this.target.width; + for (let U = 0; U < B; U++) { + const J = (N + k + U) * 4; + R += i[J], F += i[J + 1], S += i[J + 2], a += i[J + 3]; + } + } + const M = (y + h) * 4; + w[M] = R / s, w[M + 1] = F / s, w[M + 2] = S / s, w[M + 3] = a / s; + } + } + return w; + } + // Render out a viewpoint as a Uint8Array of RGBA values for the provided scene + // and any camera/viewToWorld viewpoint overrides. By default update is true, + // which triggers its SparkRenderer to check and potentially update the Gsplats. + // Setting update to false disables this and sorts the Gsplats as they are. + // Setting forceOrigin (default: false) to true forces the view update to + // recalculate the splats with this view origin, potentially altering any + // view-dependent effects. If you expect view-dependent effects to play a role + // in the rendering quality, enable this. + // + // Underneath, prepareRenderPixels() simply calls await this.prepare(...), + // this.renderTarget(...), and finally returns the result this.readTarget(), + // a Promise to a Uint8Array with RGBA values for all the pixels (potentially + // downsampled if the superXY parameter was used). These steps can also be called + // manually, for example if you need to alter the scene before and after + // this.renderTarget(...) to hide UI elements from being rendered. + async prepareRenderPixels({ + scene: A, + camera: I, + viewToWorld: g, + update: B, + forceOrigin: C + }) { + return await this.prepare({ scene: A, camera: I, viewToWorld: g, update: B, forceOrigin: C }), this.renderTarget({ scene: A, camera: I }), this.readTarget(); + } + // This is called automatically by SparkRenderer, there is no need to call it! + // The method cannot be private because then SparkRenderer would + // not be able to call it. + autoPoll({ accumulator: A }) { + var C, E, D; + this.camera && (this.camera.updateMatrixWorld(), this.viewToWorld = this.camera.matrixWorld.clone()); + let I = !1, g = !1; + if (!this.display) + I = !0; + else if (A) { + I = !0; + const { mappingVersion: i } = this.display.accumulator; + A.mappingVersion === i && (A.refCount += 1, this.spark.releaseAccumulator(this.display.accumulator), this.display.accumulator = A, this.display.viewToWorld.copy(this.viewToWorld), g = !0, this.spark.viewpoint === this && this.spark.prepareViewpoint(this)); + } + const B = ((C = this.sorting) == null ? void 0 : C.viewToWorld) ?? ((E = this.display) == null ? void 0 : E.viewToWorld); + B && !Og({ + matrix1: this.viewToWorld, + matrix2: B, + // By default update sort each 1 cm + maxDistance: this.sortDistance ?? 0.01, + // By default for radial sort, update for intermittent movement so that + // we bring back splats culled by being behind the camera. + // For depth sort, small rotations can change sort order a lot, so + // update sort for even small rotations. + minCoorient: this.sortCoorient ?? this.sortRadial ? 0.99 : 0.999 + }) && (I = !0), I && (A && (A.refCount += 1), (D = this.pending) != null && D.accumulator && this.spark.releaseAccumulator(this.pending.accumulator), this.pending = { accumulator: A, viewToWorld: this.viewToWorld, displayed: g }, this.driveSort()); + } + async driveSort() { + var A; + for (; ; ) { + if (this.sorting || !this.pending) + return; + const { viewToWorld: I, displayed: g } = this.pending; + let B = this.pending.accumulator; + if (B || (B = ((A = this.display) == null ? void 0 : A.accumulator) ?? this.spark.active, B.refCount += 1), this.pending = null, !B) + throw new Error("No accumulator to sort"); + this.sorting = { viewToWorld: I }, await this.sortUpdate({ accumulator: B, viewToWorld: I, displayed: g }), this.sorting = null, this.spark.releaseAccumulator(B); + } + } + async sortUpdate({ + accumulator: A, + viewToWorld: I, + displayed: g = !1 + }) { + if (this.sortingCheck) + throw new Error("Only one sort at a time"); + this.sortingCheck = !0, A = A ?? this.spark.active; + const { numSplats: B, maxSplats: C } = A.splats; + let E = 0, D = this.orderingFreelist.alloc(C); + if (this.stochastic) { + E = B; + for (let i = 0; i < B; ++i) + D[i] = i; + } else if (B > 0) { + const { + reader: i, + doubleSortReader: w, + sort32Reader: s, + dynoSortRadial: o, + dynoOrigin: y, + dynoDirection: h, + dynoDepthBias: k, + dynoSort360: R, + dynoSplats: F + } = JI.makeSorter(), S = this.sort32 ?? !1; + let a; + if (S) + this.readback32 = i.ensureBuffer(C, this.readback32), a = this.readback32; + else { + const t = Math.ceil(C / 2); + this.readback16 = i.ensureBuffer(t, this.readback16), a = this.readback16; + } + const M = A.toWorld.clone().invert(), c = I.clone().premultiply(M); + o.value = this.sort360 ? !0 : this.sortRadial, y.value.set(0, 0, 0).applyMatrix4(c), h.value.set(0, 0, -1).applyMatrix4(c).sub(y.value).normalize(), k.value = this.depthBias ?? 1, R.value = this.sort360 ?? !1, F.packedSplats = A.splats; + const N = S ? s : w, U = S ? B : Math.ceil(B / 2); + await i.renderReadback({ + renderer: this.spark.renderer, + reader: N, + count: U, + readback: a + }); + const J = await nI(async (t) => { + const H = S ? "sort32Splats" : "sortDoubleSplats"; + return t.call(H, { + maxSplats: C, + numSplats: B, + readback: a, + ordering: D + }); + }); + S ? this.readback32 = J.readback : this.readback16 = J.readback, D = J.ordering, E = J.activeSplats; + } + this.updateDisplay({ + accumulator: A, + viewToWorld: I, + ordering: D, + activeSplats: E, + displayed: g + }), this.sortingCheck = !1; + } + updateDisplay({ + accumulator: A, + viewToWorld: I, + ordering: g, + activeSplats: B, + displayed: C = !1 + }) { + if (!this.display) + A.refCount += 1, this.display = { + accumulator: A, + viewToWorld: I, + geometry: new tQ(g, B) + }; + else { + !C && A !== this.display.accumulator && (A.refCount += 1, this.spark.releaseAccumulator(this.display.accumulator), this.display.accumulator = A), this.display.viewToWorld = I; + const E = this.display.geometry.ordering; + E.length === g.length ? this.display.geometry.update(g, B) : (this.display.geometry.dispose(), this.display.geometry = new tQ(g, B)), this.orderingFreelist.free(E); + } + this.spark.viewpoint === this && this.spark.prepareViewpoint(this); + } + static makeSorter() { + if (!JI.dynos) { + const A = new bI({ value: !0 }), I = new DI({ value: new G.Vector3() }), g = new DI({ value: new G.Vector3() }), B = new pI({ value: 1 }), C = new bI({ value: !1 }), E = new MB(), D = new Ig(), i = cA( + { index: "int" }, + { rgba8: "vec4" }, + ({ index: s }) => { + if (!s) + throw new Error("No index"); + const o = { + sortRadial: A, + sortOrigin: I, + sortDirection: g, + sortDepthBias: B, + sort360: C + }, y = kA(s, v("int", 2)), h = _I(E, y), k = MQ({ gsplat: h, ...o }), R = _I( + E, + qA(y, v("int", 1)) + ), F = MQ({ gsplat: R, ...o }), S = yI({ + vectorType: "vec2", + x: k, + y: F + }); + return { rgba8: fQ(zD(S)) }; + } + ), w = cA( + { index: "int" }, + { rgba8: "vec4" }, + ({ index: s }) => { + if (!s) + throw new Error("No index"); + const o = { + sortRadial: A, + sortOrigin: I, + sortDirection: g, + sortDepthBias: B, + sort360: C + }, y = _I(E, s), h = MQ({ gsplat: y, ...o }); + return { rgba8: fQ(vD(h)) }; + } + ); + JI.dynos = { + dynoSortRadial: A, + dynoOrigin: I, + dynoDirection: g, + dynoDepthBias: B, + dynoSort360: C, + dynoSplats: E, + reader: D, + doubleSortReader: i, + sort32Reader: w + }; + } + return JI.dynos; + } +}; +JI.EMPTY_TEXTURE = new G.Texture(), JI.dynos = null; +let jg = JI; +const hR = oA(` + float computeSort(Gsplat gsplat, bool sortRadial, vec3 sortOrigin, vec3 sortDirection, float sortDepthBias, bool sort360) { + if (!isGsplatActive(gsplat.flags)) { + return INFINITY; + } + + vec3 center = gsplat.center - sortOrigin; + float biasedDepth = dot(center, sortDirection) + sortDepthBias; + if (!sort360 && (biasedDepth <= 0.0)) { + return INFINITY; + } + + return sortRadial ? length(center) : biasedDepth; + } +`); +function MQ({ + gsplat: Q, + sortRadial: A, + sortOrigin: I, + sortDirection: g, + sortDepthBias: B, + sort360: C +}) { + return AQ({ + inTypes: { + gsplat: Z, + sortRadial: "bool", + sortOrigin: "vec3", + sortDirection: "vec3", + sortDepthBias: "float", + sort360: "bool" + }, + outTypes: { metric: "float" }, + globals: () => [HA, hR], + inputs: { + gsplat: Q, + sortRadial: A, + sortOrigin: I, + sortDirection: g, + sortDepthBias: B, + sort360: C + }, + statements: ({ inputs: E, outputs: D }) => { + const { + gsplat: i, + sortRadial: w, + sortOrigin: s, + sortDirection: o, + sortDepthBias: y, + sort360: h + } = E; + return z(` + ${D.metric} = computeSort(${i}, ${w}, ${s}, ${o}, ${y}, ${h}); + `); + } + }).outputs.metric; +} +class JQ { + constructor() { + this.splats = new $A(), this.toWorld = new G.Matrix4(), this.mapping = [], this.refCount = 0, this.splatsVersion = -1, this.mappingVersion = -1; + } + ensureGenerate(A) { + this.splats.ensureGenerate(A) && (this.mapping = []); + } + // Generate all Gsplats from an array of generators + generateSplats({ + renderer: A, + modifier: I, + generators: g, + forceUpdate: B, + originToWorld: C + }) { + const E = this.mapping.reduce((w, s) => (w.set(s.node, s), w), /* @__PURE__ */ new Map()); + let D = 0, i = 0; + for (const { node: w, generator: s, version: o, base: y, count: h } of g) { + const k = E.get(w); + if ((B || s !== (k == null ? void 0 : k.generator) || o !== (k == null ? void 0 : k.version) || y !== (k == null ? void 0 : k.base) || h !== (k == null ? void 0 : k.count)) && s && h > 0) { + const R = I.apply(s); + try { + this.splats.generate({ + generator: R, + base: y, + count: h, + renderer: A + }); + } catch (F) { + w.generator = void 0, w.generatorError = F; + } + D += 1; + } + i = Math.max(i, y + h); + } + return this.splats.numSplats = i, this.toWorld.copy(C), this.mapping = g, D !== 0; + } + // Check if this accumulator has exactly the same generator mapping as + // the previous one. If so, we can reuse the Gsplat sort order. + hasCorrespondence(A) { + return this.mapping.length !== A.mapping.length ? !1 : this.mapping.every(({ node: I, base: g, count: B }, C) => { + const { + node: E, + base: D, + count: i + } = A.mapping[C]; + return I === E && g === D && B === i; + }); + } +} +const TB = 5, UA = class UA extends G.Mesh { + constructor(A) { + const I = UA.makeUniforms(), g = Ag(), B = A.premultipliedAlpha ?? !0, C = new G.ShaderMaterial({ + glslVersion: G.GLSL3, + vertexShader: g.oldSplatVertex, + fragmentShader: g.oldSplatFragment, + uniforms: I, + premultipliedAlpha: B, + transparent: !0, + depthTest: !0, + depthWrite: !1, + side: G.DoubleSide + }); + super(mB, C), this.splatTexture = null, this.autoViewpoints = [], this.rotateToAccumulator = new mI({ value: new G.Quaternion() }), this.translateToAccumulator = new DI({ value: new G.Vector3() }), this.lastFrame = -1, this.lastUpdateTime = null, this.defaultCameras = [], this.lastStochastic = null, this.pendingUpdate = { + scene: null, + originToWorld: new G.Matrix4(), + timeoutId: -1 + }, this.envViewpoint = null, this.frustumCulled = !1, this.renderer = A.renderer, this.material = C, this.uniforms = I; + const E = cA( + { gsplat: Z }, + { gsplat: Z }, + ({ gsplat: D }) => { + if (!D) + throw new Error("gsplat not defined"); + return D = CB(D, { + rotate: this.rotateToAccumulator, + translate: this.translateToAccumulator + }), { gsplat: D }; + } + ); + this.modifier = new Xh(E), this.premultipliedAlpha = B, this.autoUpdate = A.autoUpdate ?? !0, this.preUpdate = A.preUpdate ?? !1, this.needsUpdate = !1, this.originDistance = A.originDistance ?? 1, this.maxStdDev = A.maxStdDev ?? Math.sqrt(8), this.minPixelRadius = A.minPixelRadius ?? 0, this.maxPixelRadius = A.maxPixelRadius ?? 512, this.minAlpha = A.minAlpha ?? 0.5 * (1 / 255), this.enable2DGS = A.enable2DGS ?? !1, this.preBlurAmount = A.preBlurAmount ?? 0, this.blurAmount = A.blurAmount ?? 0.3, this.focalDistance = A.focalDistance ?? 0, this.apertureAngle = A.apertureAngle ?? 0, this.falloff = A.falloff ?? 1, this.clipXY = A.clipXY ?? 1.4, this.focalAdjustment = A.focalAdjustment ?? 1, this.splatEncoding = A.splatEncoding ?? { ...cg }, this.active = new JQ(), this.active.refCount = 1, this.accumulatorCount = 1, this.freeAccumulators = []; + for (let D = 0; D < 1; ++D) + this.freeAccumulators.push(new JQ()), this.accumulatorCount += 1; + this.defaultView = new jg({ + ...A.view, + autoUpdate: !0, + spark: this + }), this.viewpoint = this.defaultView, this.prepareViewpoint(this.viewpoint), this.clock = A.clock ? IB(A.clock) : new G.Clock(); + } + static makeUniforms() { + return { + // Size of render viewport in pixels + renderSize: { value: new G.Vector2() }, + // Near and far plane distances + near: { value: 0.1 }, + far: { value: 1e3 }, + // Total number of Gsplats in packedSplats to render + numSplats: { value: 0 }, + // SplatAccumulator to view transformation quaternion + renderToViewQuat: { value: new G.Quaternion() }, + // SplatAccumulator to view transformation translation + renderToViewPos: { value: new G.Vector3() }, + // Maximum distance (in stddevs) from Gsplat center to render + maxStdDev: { value: 1 }, + // Minimum pixel radius for splat rendering + minPixelRadius: { value: 0 }, + // Maximum pixel radius for splat rendering + maxPixelRadius: { value: 512 }, + // Minimum alpha value for splat rendering + minAlpha: { value: 0.00196078431372549 }, + // Enable stochastic splat rendering + stochastic: { value: !1 }, + // Enable interpreting 0-thickness Gsplats as 2DGS + enable2DGS: { value: !1 }, + // Add to projected 2D splat covariance diagonal (thickens and brightens) + preBlurAmount: { value: 0 }, + // Add to 2D splat covariance diagonal and adjust opacity (anti-aliasing) + blurAmount: { value: 0.3 }, + // Depth-of-field distance to focal plane + focalDistance: { value: 0 }, + // Full-width angle of aperture opening (in radians) + apertureAngle: { value: 0 }, + // Modulate Gaussian kernal falloff. 0 means "no falloff, flat shading", + // 1 is normal e^-x^2 falloff. + falloff: { value: 1 }, + // Clip Gsplats that are clipXY times beyond the +-1 frustum bounds + clipXY: { value: 1.4 }, + // Debug renderSize scale factor + focalAdjustment: { value: 1 }, + // Enable splat texture rendering + splatTexEnable: { value: !1 }, + // Splat texture to render + splatTexture: { type: "t", value: UA.EMPTY_SPLAT_TEXTURE }, + // Splat texture UV transform (multiply) + splatTexMul: { value: new G.Matrix2() }, + // Splat texture UV transform (add) + splatTexAdd: { value: new G.Vector2() }, + // Splat texture near plane distance + splatTexNear: { value: 0.1 }, + // Splat texture far plane distance + splatTexFar: { value: 1e3 }, + // Splat texture mid plane distance, or 0.0 to disable + splatTexMid: { value: 0 }, + // Gsplat collection to render + packedSplats: { type: "t", value: $A.getEmptyArray }, + // Splat encoding ranges + rgbMinMaxLnScaleMinMax: { value: new G.Vector4() }, + // Time in seconds for time-based effects + time: { value: 0 }, + // Delta time in seconds since last frame + deltaTime: { value: 0 }, + // Whether to encode Gsplat with linear RGB (for environment mapping) + encodeLinear: { value: !1 }, + // Debug flag that alternates each frame + debugFlag: { value: !1 } + }; + } + canAllocAccumulator() { + return this.freeAccumulators.length > 0 || this.accumulatorCount < TB; + } + maybeAllocAccumulator() { + let A = this.freeAccumulators.pop(); + if (A === void 0) { + if (this.accumulatorCount >= TB) + return null; + A = new JQ(), this.accumulatorCount += 1; + } + return A.refCount = 1, A; + } + releaseAccumulator(A) { + A.refCount -= 1, A.refCount === 0 && this.freeAccumulators.push(A); + } + newViewpoint(A) { + return new jg({ ...A, spark: this }); + } + onBeforeRender(A, I, g) { + var h, k; + const B = this.time ?? this.clock.getElapsedTime(), C = B - (this.viewpoint.lastTime ?? B); + this.viewpoint.lastTime = B; + const E = A.info.render.frame, D = E !== this.lastFrame; + this.lastFrame = E; + const i = this.viewpoint; + if (i === this.defaultView) { + if (D) + if (!A.xr.isPresenting) + this.defaultView.viewToWorld = g.matrixWorld.clone(), this.defaultCameras = [this.defaultView.viewToWorld]; + else { + const R = A.xr.getCamera().cameras; + this.defaultCameras = R.map((F) => F.matrixWorld), this.defaultView.viewToWorld = RR(this.defaultCameras) ?? new G.Matrix4(); + } + this.autoUpdate && this.update({ scene: I, viewToWorld: this.defaultView.viewToWorld }); + } + if (D && (this.material.premultipliedAlpha !== this.premultipliedAlpha && (this.material.premultipliedAlpha = this.premultipliedAlpha, this.material.needsUpdate = !0), this.uniforms.time.value = B, this.uniforms.deltaTime.value = C, this.uniforms.debugFlag.value = performance.now() / 1e3 % 2 < 1, i.display && i.stochastic && (this.geometry.instanceCount = this.uniforms.numSplats.value)), i.target) + this.uniforms.renderSize.value.set( + i.target.width, + i.target.height + ); + else { + const R = A.getDrawingBufferSize( + this.uniforms.renderSize.value + ); + if (R.x === 1 && R.y === 1) { + const F = (h = A.xr.getSession()) == null ? void 0 : h.renderState.baseLayer; + F && (R.x = F.framebufferWidth, R.y = F.framebufferHeight); + } + } + const w = g; + if (this.uniforms.near.value = w.near, this.uniforms.far.value = w.far, this.uniforms.encodeLinear.value = i.encodeLinear, this.uniforms.maxStdDev.value = this.maxStdDev, this.uniforms.minPixelRadius.value = this.minPixelRadius, this.uniforms.maxPixelRadius.value = this.maxPixelRadius, this.uniforms.minAlpha.value = this.minAlpha, this.uniforms.stochastic.value = i.stochastic, this.uniforms.enable2DGS.value = this.enable2DGS, this.uniforms.preBlurAmount.value = this.preBlurAmount, this.uniforms.blurAmount.value = this.blurAmount, this.uniforms.focalDistance.value = this.focalDistance, this.uniforms.apertureAngle.value = this.apertureAngle, this.uniforms.falloff.value = this.falloff, this.uniforms.clipXY.value = this.clipXY, this.uniforms.focalAdjustment.value = this.focalAdjustment, this.lastStochastic !== !i.stochastic && (this.lastStochastic = !i.stochastic, this.material.transparent = !i.stochastic, this.material.depthWrite = i.stochastic, this.material.needsUpdate = !0), this.splatTexture) { + const { enable: R, texture: F, multiply: S, add: a, near: M, far: c, mid: N } = this.splatTexture; + R && F ? (this.uniforms.splatTexEnable.value = !0, this.uniforms.splatTexture.value = F, S ? this.uniforms.splatTexMul.value.fromArray(S.elements) : this.uniforms.splatTexMul.value.set( + 0.5 / this.maxStdDev, + 0, + 0, + 0.5 / this.maxStdDev + ), this.uniforms.splatTexAdd.value.set((a == null ? void 0 : a.x) ?? 0.5, (a == null ? void 0 : a.y) ?? 0.5), this.uniforms.splatTexNear.value = M ?? this.uniforms.near.value, this.uniforms.splatTexFar.value = c ?? this.uniforms.far.value, this.uniforms.splatTexMid.value = N ?? 0) : (this.uniforms.splatTexEnable.value = !1, this.uniforms.splatTexture.value = UA.EMPTY_SPLAT_TEXTURE); + } else + this.uniforms.splatTexEnable.value = !1, this.uniforms.splatTexture.value = UA.EMPTY_SPLAT_TEXTURE; + const s = ((k = i.display) == null ? void 0 : k.accumulator.toWorld) ?? new G.Matrix4(), o = g.matrixWorld.clone().invert(); + s.clone().premultiply(o).decompose( + this.uniforms.renderToViewPos.value, + this.uniforms.renderToViewQuat.value, + new G.Vector3() + ); + } + // Update the uniforms for the given viewpoint. + // Note that the client expects to be able to call render() at any point + // to update the canvas, so we must switch the viewpoint back to + // defaultView when we're finished. + prepareViewpoint(A) { + var I, g, B, C; + if (this.viewpoint = A ?? this.viewpoint, this.viewpoint.display) { + const { accumulator: E, geometry: D } = this.viewpoint.display; + this.uniforms.numSplats.value = E.splats.numSplats, this.uniforms.packedSplats.value = E.splats.getTexture(), this.uniforms.rgbMinMaxLnScaleMinMax.value.set( + ((I = E.splats.splatEncoding) == null ? void 0 : I.rgbMin) ?? 0, + ((g = E.splats.splatEncoding) == null ? void 0 : g.rgbMax) ?? 1, + ((B = E.splats.splatEncoding) == null ? void 0 : B.lnScaleMin) ?? pA, + ((C = E.splats.splatEncoding) == null ? void 0 : C.lnScaleMax) ?? fA + ), this.geometry = D, this.material.transparent = !this.viewpoint.stochastic, this.material.depthWrite = this.viewpoint.stochastic, this.material.needsUpdate = !0; + } else + this.uniforms.numSplats.value = 0, this.uniforms.packedSplats.value = $A.getEmptyArray, this.geometry = mB; + } + // If spark.autoUpdate is false then you must manually call + // spark.update({ scene }) to have the scene Gsplats be re-generated. + update({ + scene: A, + viewToWorld: I + }) { + const g = this.matrixWorld; + this.preUpdate ? this.updateInternal({ + scene: A, + originToWorld: g.clone(), + viewToWorld: I + }) : (this.pendingUpdate.scene = A, this.pendingUpdate.originToWorld.copy(g), this.pendingUpdate.timeoutId === -1 && (this.pendingUpdate.timeoutId = setTimeout(() => { + const { scene: B, originToWorld: C } = this.pendingUpdate; + this.pendingUpdate.scene = null, this.pendingUpdate.timeoutId = -1, this.updateInternal({ + scene: B, + originToWorld: C, + viewToWorld: I + }) && this.renderer.getContext().flush(); + }, 1))); + } + updateInternal({ + scene: A, + originToWorld: I, + viewToWorld: g + }) { + var k; + if (!this.canAllocAccumulator()) + return !1; + I || (I = this.active.toWorld), g = g ?? I.clone(); + const B = this.time ?? this.clock.getElapsedTime(), C = B - (this.lastUpdateTime ?? B); + this.lastUpdateTime = B; + const E = this.active.mapping.reduce((R, F) => (R.set(F.node, F), R), /* @__PURE__ */ new Map()), { generators: D, visibleGenerators: i, globalEdits: w } = this.compileScene(A); + for (const R of D) + (k = R.frameUpdate) == null || k.call(R, { + renderer: this.renderer, + object: R, + time: B, + deltaTime: C, + viewToWorld: g, + globalEdits: w + }); + const s = new Set(i.map((R) => R.uuid)); + for (const R of D) { + const F = E.get(R), a = R.generator && s.has(R.uuid) ? R.numSplats : 0; + (this.needsUpdate || R.generator !== (F == null ? void 0 : F.generator) || a !== (F == null ? void 0 : F.count)) && R.updateVersion(); + } + const o = !Og({ + matrix1: I, + matrix2: this.active.toWorld, + maxDistance: this.originDistance + }), y = this.needsUpdate || o || D.length !== E.size || D.some((R) => { + var F; + return R.version !== ((F = E.get(R)) == null ? void 0 : F.version); + }); + this.needsUpdate = !1; + let h = null; + if (y) { + if (h = this.maybeAllocAccumulator(), !h) + throw new Error("Unreachable"); + const R = !Og({ + matrix1: I, + matrix2: h.toWorld, + maxDistance: 1e-5, + minCoorient: 0.99999 + }), S = i.map((J, t) => { + const H = E.get(J); + return H ? ( + // Sort by version deltas then by previous ordering in the mapping, + // attempting to keep unchanging generators near the front + // to improve our chances of avoiding a re-generation. + [J.version - H.version, H.base, J] + ) : [Number.POSITIVE_INFINITY, J.version, J]; + }).sort((J, t) => J[0] !== t[0] ? J[0] - t[0] : J[1] - t[1]).map(([J, t, H]) => H), a = S.map((J) => J.numSplats), { maxSplats: M, mapping: c } = h.splats.generateMapping(a), N = S.map((J, t) => { + const { base: H, count: K } = c[t]; + return { + node: J, + generator: J.generator, + version: J.version, + base: H, + count: K + }; + }); + I.clone().invert().decompose( + this.translateToAccumulator.value, + this.rotateToAccumulator.value, + new G.Vector3() + ), h.ensureGenerate(M), h.splats.splatEncoding = { ...this.splatEncoding }, h.generateSplats({ + renderer: this.renderer, + modifier: this.modifier, + generators: N, + forceUpdate: R, + originToWorld: I + }), h.splatsVersion = this.active.splatsVersion + 1; + const U = h.hasCorrespondence(this.active); + h.mappingVersion = this.active.mappingVersion + (U ? 0 : 1), this.releaseAccumulator(this.active), this.active = h, this.prepareViewpoint(); + } + return setTimeout(() => { + for (const R of this.autoViewpoints) + R.autoPoll({ accumulator: h ?? void 0 }); + }, 1), !0; + } + compileScene(A) { + const I = []; + A.traverse((C) => { + C instanceof PI && I.push(C); + }); + const g = []; + A.traverseVisible((C) => { + C instanceof PI && g.push(C); + }); + const B = /* @__PURE__ */ new Set(); + return A.traverseVisible((C) => { + if (C instanceof ag) { + let E = C.parent; + for (; E != null && !(E instanceof vA); ) + E = E.parent; + E == null && B.add(C); + } + }), { + generators: I, + visibleGenerators: g, + globalEdits: Array.from(B) + }; + } + // Renders out the scene to an environment map that can be used for + // Image-based lighting or similar applications. First optionally updates Gsplats, + // sorts them with respect to the provided worldCenter, renders 6 cube faces, + // then pre-filters them using THREE.PMREMGenerator and returns a THREE.Texture + // that can assigned directly to a THREE.MeshStandardMaterial.envMap property. + async renderEnvMap({ + renderer: A, + scene: I, + worldCenter: g, + size: B = 256, + near: C = 0.1, + far: E = 1e3, + hideObjects: D = [], + update: i = !1 + }) { + var h, k; + if (this.envViewpoint || (this.envViewpoint = this.newViewpoint({ sort360: !0 })), !UA.cubeRender || UA.cubeRender.target.width !== B || UA.cubeRender.near !== C || UA.cubeRender.far !== E) { + UA.cubeRender && UA.cubeRender.target.dispose(); + const R = new G.WebGLCubeRenderTarget(B, { + format: G.RGBAFormat, + generateMipmaps: !0, + minFilter: G.LinearMipMapLinearFilter + }), F = new G.CubeCamera(C, E, R); + UA.cubeRender = { target: R, camera: F, near: C, far: E }; + } + UA.pmrem || (UA.pmrem = new G.PMREMGenerator( + A ?? this.renderer + )); + const w = new G.Matrix4().setPosition(g); + await ((h = this.envViewpoint) == null ? void 0 : h.prepare({ scene: I, viewToWorld: w, update: i })); + const { target: s, camera: o } = UA.cubeRender; + o.position.copy(g); + const y = /* @__PURE__ */ new Map(); + for (const R of D) + y.set(R, R.visible), R.visible = !1; + this.prepareViewpoint(this.envViewpoint), o.update(A ?? this.renderer, I), this.prepareViewpoint(this.defaultView); + for (const [R, F] of y.entries()) + R.visible = F; + return (k = UA.pmrem) == null ? void 0 : k.fromCubemap(s.texture).texture; + } + // Utility function to recursively set the envMap property for any + // THREE.MeshStandardMaterial within the subtree of root. + recurseSetEnvMap(A, I) { + A.traverse((g) => { + if (g instanceof G.Mesh) + if (Array.isArray(g.material)) + for (const B of g.material) + B instanceof G.MeshStandardMaterial && (B.envMap = I); + else + g.material instanceof G.MeshStandardMaterial && (g.material.envMap = I); + }); + } + // Utility function that helps extract the Gsplat RGBA values from a + // SplatGenerator, including the result of any real-time RGBA SDF edits applied + // to a SplatMesh. This effectively "bakes" any computed RGBA values, which can + // now be used as a pipeline input via SplatMesh.splatRgba to inject these + // baked values into the Gsplat data. + getRgba({ + generator: A, + rgba: I + }) { + const g = this.active.mapping.find(({ node: B }) => B === A); + if (!g) + throw new Error("Generator not found"); + return I = I ?? new TQ(), I.fromPackedSplats({ + packedSplats: this.active.splats, + base: g.base, + count: g.count, + renderer: this.renderer + }), I; + } + // Utility function that builds on getRgba({ generator }) and additionally + // reads back the RGBA values to the CPU in a Uint8Array with packed RGBA + // in that byte order. + async readRgba({ + generator: A, + rgba: I + }) { + return I = this.getRgba({ generator: A, rgba: I }), I.read(); + } +}; +UA.cubeRender = null, UA.pmrem = null, UA.EMPTY_SPLAT_TEXTURE = new G.Data3DTexture(); +let OB = UA; +const mB = new tQ(new Uint32Array(1), 0); +cA( + { packedSplats: tg, index: "int" }, + { gsplat: Z }, + ({ packedSplats: Q, index: A }) => { + if (!Q || !A) + throw new Error("Invalid input"); + return { gsplat: _I(Q, A) }; + } +); +function RR(Q) { + if (Q.length === 0) + return null; + const A = new G.Vector3(), I = new G.Quaternion(), g = new G.Vector3(), B = [], C = []; + for (const E of Q) + E.decompose(A, I, g), B.push(A), C.push(I); + return new G.Matrix4().compose( + JC(B), + UC(C), + new G.Vector3(1, 1, 1) + ); +} +function kR(Q, A, I) { + const g = Math.floor(Q.length / 32); + if (g * 32 !== Q.length) + throw new Error("Invalid .splat file size"); + const B = new Float32Array(Q.buffer); + for (let C = 0; C < g; ++C) { + const E = C * 32, D = C * 8, i = B[D + 0], w = B[D + 1], s = B[D + 2], o = B[D + 3], y = B[D + 4], h = B[D + 5], k = Q[E + 24] / 255, R = Q[E + 25] / 255, F = Q[E + 26] / 255, S = Q[E + 27] / 255, a = (Q[E + 28] - 128) / 128, M = (Q[E + 29] - 128) / 128, c = (Q[E + 30] - 128) / 128, N = (Q[E + 31] - 128) / 128; + I( + C, + i, + w, + s, + o, + y, + h, + M, + c, + N, + a, + S, + k, + R, + F + ); + } +} +const ZB = { + 0: { + bytesPerCenter: 12, + bytesPerScale: 12, + bytesPerRotation: 16, + bytesPerColor: 4, + bytesPerSphericalHarmonicsComponent: 4, + scaleOffsetBytes: 12, + rotationOffsetBytes: 24, + colorOffsetBytes: 40, + sphericalHarmonicsOffsetBytes: 44, + scaleRange: 1 + }, + 1: { + bytesPerCenter: 6, + bytesPerScale: 6, + bytesPerRotation: 8, + bytesPerColor: 4, + bytesPerSphericalHarmonicsComponent: 2, + scaleOffsetBytes: 6, + rotationOffsetBytes: 12, + colorOffsetBytes: 20, + sphericalHarmonicsOffsetBytes: 24, + scaleRange: 32767 + }, + 2: { + bytesPerCenter: 6, + bytesPerScale: 6, + bytesPerRotation: 8, + bytesPerColor: 4, + bytesPerSphericalHarmonicsComponent: 1, + scaleOffsetBytes: 6, + rotationOffsetBytes: 12, + colorOffsetBytes: 20, + sphericalHarmonicsOffsetBytes: 24, + scaleRange: 32767 + } +}, FR = { + 0: 0, + 1: 9, + 2: 24, + 3: 45 +}; +function SR(Q, A, I, g) { + var R; + let E = 0; + const D = new DataView(Q.buffer, E, 4096); + E += 4096; + const i = D.getUint8(0), w = D.getUint8(1); + if (i !== 0 || w < 1) + throw new Error( + `Unsupported .ksplat version: ${i}.${w}` + ); + const s = D.getUint32(4, !0); + D.getUint32(16, !0); + const o = D.getUint16(20, !0); + if (o < 0 || o > 2) + throw new Error(`Invalid .ksplat compression level: ${o}`); + const y = D.getFloat32(36, !0) || -1.5, h = D.getFloat32(40, !0) || 1.5; + let k = 4096 + s * 1024; + for (let F = 0; F < s; ++F) { + let S = function(mA, $) { + if (o === 0) + return _.getFloat32( + mA + b + $ * 4, + !0 + ); + if (o === 1) + return NA( + _.getUint16( + mA + b + $ * 2, + !0 + ) + ); + const RI = _.getUint8(mA + b + $) / 255; + return y + RI * (h - y); + }; + const a = new DataView(Q.buffer, E, 1024); + E += 1024; + const M = a.getUint32(0, !0), c = a.getUint32(4, !0), N = a.getUint32(8, !0), U = a.getUint32(12, !0), J = a.getFloat32(16, !0), t = a.getUint16(20, !0), H = (a.getUint32(24, !0) || ((R = ZB[o]) == null ? void 0 : R.scaleRange)) ?? 1, K = a.getUint32(32, !0), Y = K * N, L = a.getUint32(36, !0), q = L * 4, n = t * U + q, r = a.getUint16(40, !0), p = FR[r], { + bytesPerCenter: m, + bytesPerScale: IA, + bytesPerRotation: X, + bytesPerColor: EA, + bytesPerSphericalHarmonicsComponent: j, + scaleOffsetBytes: gA, + rotationOffsetBytes: W, + colorOffsetBytes: u, + sphericalHarmonicsOffsetBytes: b + } = ZB[o], T = m + IA + X + EA + p * j, f = T * c, FA = f + n, sA = [0, 3, 6, 1, 4, 7, 2, 5, 8], SA = [ + 9, + 14, + 19, + 10, + 15, + 20, + 11, + 16, + 21, + 12, + 17, + 22, + 13, + 18, + 23 + ], aA = [ + 24, + 31, + 38, + 25, + 32, + 39, + 26, + 33, + 40, + 27, + 34, + 41, + 28, + 35, + 42, + 29, + 36, + 43, + 30, + 37, + 44 + ], wA = r >= 1 ? new Float32Array(3 * 3) : void 0, GA = r >= 2 ? new Float32Array(5 * 3) : void 0, AI = r >= 3 ? new Float32Array(7 * 3) : void 0, TA = J / 2 / H, FI = k + q, SI = k + n, _ = new DataView( + Q.buffer, + SI, + f + ), OA = new Float32Array( + Q.buffer, + FI, + U * 3 + ), LA = new Uint32Array( + Q.buffer, + k, + L + ); + let Cg = K, Hg = Y; + for (let mA = 0; mA < M; ++mA) { + const $ = mA * T; + let RI; + if (mA < Y) + RI = Math.floor(mA / N); + else { + const aI = LA[Cg - K]; + mA >= Hg + aI && (Cg += 1, Hg += aI), RI = Cg; + } + const wQ = o === 0 ? _.getFloat32($ + 0, !0) : (_.getUint16($ + 0, !0) - H) * TA + OA[3 * RI + 0], oQ = o === 0 ? _.getFloat32($ + 4, !0) : (_.getUint16($ + 2, !0) - H) * TA + OA[3 * RI + 1], sQ = o === 0 ? _.getFloat32($ + 8, !0) : (_.getUint16($ + 4, !0) - H) * TA + OA[3 * RI + 2], GQ = o === 0 ? _.getFloat32($ + gA + 0, !0) : NA(_.getUint16($ + gA + 0, !0)), yQ = o === 0 ? _.getFloat32($ + gA + 4, !0) : NA(_.getUint16($ + gA + 2, !0)), Ww = o === 0 ? _.getFloat32($ + gA + 8, !0) : NA(_.getUint16($ + gA + 4, !0)), jw = o === 0 ? _.getFloat32($ + W + 0, !0) : NA( + _.getUint16($ + W + 0, !0) + ), vw = o === 0 ? _.getFloat32($ + W + 4, !0) : NA( + _.getUint16($ + W + 2, !0) + ), zw = o === 0 ? _.getFloat32($ + W + 8, !0) : NA( + _.getUint16($ + W + 4, !0) + ), _w = o === 0 ? _.getFloat32($ + W + 12, !0) : NA( + _.getUint16($ + W + 6, !0) + ), $w = _.getUint8($ + u + 0) / 255, Ao = _.getUint8($ + u + 1) / 255, Io = _.getUint8($ + u + 2) / 255, go = _.getUint8($ + u + 3) / 255; + if (I( + mA, + wQ, + oQ, + sQ, + GQ, + yQ, + Ww, + vw, + zw, + _w, + jw, + go, + $w, + Ao, + Io + ), r >= 1 && wA) { + for (const [aI, Eg] of sA.entries()) + wA[aI] = S($, Eg); + if (GA) + for (const [aI, Eg] of SA.entries()) + GA[aI] = S($, Eg); + if (AI) + for (const [aI, Eg] of aA.entries()) + AI[aI] = S($, Eg); + g == null || g(mA, wA, GA, AI); + } + } + k += FA; + } +} +class aR { + constructor({ fileBytes: A }) { + this.version = -1, this.numSplats = 0, this.shDegree = 0, this.fractionalBits = 0, this.flags = 0, this.flagAntiAlias = !1, this.flagLod = !1, this.reserved = 0, this.headerParsed = !1, this.parsed = !1, this.fileBytes = A instanceof ArrayBuffer ? new Uint8Array(A) : A, this.reader = new rC({ + fileBytes: this.fileBytes + }); + } + async parseHeader() { + if (this.headerParsed) + throw new Error("SPZ file header already parsed"); + const A = new DataView((await this.reader.read(16)).buffer); + if (A.getUint32(0, !0) !== 1347635022) + throw new Error("Invalid SPZ file"); + if (this.version = A.getUint32(4, !0), this.version < 1 || this.version > 3) + throw new Error(`Unsupported SPZ version: ${this.version}`); + this.numSplats = A.getUint32(8, !0), this.shDegree = A.getUint8(12), this.fractionalBits = A.getUint8(13), this.flags = A.getUint8(14), this.flagAntiAlias = (this.flags & 1) !== 0, this.flagLod = (this.flags & 128) !== 0, this.reserved = A.getUint8(15), this.headerParsed = !0, this.parsed = !1; + } + async parseSplats(A, I, g, B, C, E, { + childCounts: D, + childStarts: i + } = {}) { + if (!this.headerParsed) + throw new Error("SPZ file header must be parsed first"); + if (this.parsed) + throw new Error("SPZ file already parsed"); + if (this.parsed = !0, this.version === 1) { + const w = await this.reader.read(this.numSplats * 3 * 2), s = new Uint16Array(w.buffer); + for (let o = 0; o < this.numSplats; o++) { + const y = o * 3, h = NA(s[y]), k = NA(s[y + 1]), R = NA(s[y + 2]); + A == null || A(o, h, k, R); + } + } else if (this.version === 2 || this.version === 3) { + const w = 1 << this.fractionalBits, s = await this.reader.read(this.numSplats * 3 * 3); + for (let o = 0; o < this.numSplats; o++) { + const y = o * 9, h = ((s[y + 2] << 24 | s[y + 1] << 16 | s[y] << 8) >> 8) / w, k = ((s[y + 5] << 24 | s[y + 4] << 16 | s[y + 3] << 8) >> 8) / w, R = ((s[y + 8] << 24 | s[y + 7] << 16 | s[y + 6] << 8) >> 8) / w; + A == null || A(o, h, k, R); + } + } else + throw new Error("Unreachable"); + { + const w = await this.reader.read(this.numSplats); + for (let s = 0; s < this.numSplats; s++) + I == null || I(s, w[s] / 255); + } + { + const w = await this.reader.read(this.numSplats * 3), s = Ow / 0.15; + for (let o = 0; o < this.numSplats; o++) { + const y = o * 3, h = (w[y] / 255 - 0.5) * s + 0.5, k = (w[y + 1] / 255 - 0.5) * s + 0.5, R = (w[y + 2] / 255 - 0.5) * s + 0.5; + g == null || g(o, h, k, R); + } + } + { + const w = await this.reader.read(this.numSplats * 3); + for (let s = 0; s < this.numSplats; s++) { + const o = s * 3, y = Math.exp(w[o] / 16 - 10), h = Math.exp(w[o + 1] / 16 - 10), k = Math.exp(w[o + 2] / 16 - 10); + B == null || B(s, y, h, k); + } + } + if (this.version === 3) { + const w = 1 / Math.sqrt(2), s = await this.reader.read(this.numSplats * 4); + for (let o = 0; o < this.numSplats; o++) { + const y = o * 4, h = [0, 0, 0, 0], k = [ + s[y], + s[y + 1], + s[y + 2], + s[y + 3] + ], R = k[0] + (k[1] << 8) + (k[2] << 16) + (k[3] << 24), F = 511, S = R >>> 30; + let a = R, M = 0; + for (let N = 3; N >= 0; --N) + if (N !== S) { + const U = a & F, J = a >>> 9 & 1; + a = a >>> 10, h[N] = w * (U / F), h[N] = J === 0 ? h[N] : -h[N], M += h[N] * h[N]; + } + const c = 1 - M; + h[S] = Math.sqrt(Math.max(c, 0)), C == null || C( + o, + h[0], + h[1], + h[2], + h[3] + ); + } + } else { + const w = await this.reader.read(this.numSplats * 3); + for (let s = 0; s < this.numSplats; s++) { + const o = s * 3, y = w[o] / 127.5 - 1, h = w[o + 1] / 127.5 - 1, k = w[o + 2] / 127.5 - 1, R = Math.sqrt( + Math.max(0, 1 - y * y - h * h - k * k) + ); + C == null || C(s, y, h, k, R); + } + } + if (E && this.shDegree >= 1) { + const w = new Float32Array(9), s = this.shDegree >= 2 ? new Float32Array(5 * 3) : void 0, o = this.shDegree >= 3 ? new Float32Array(7 * 3) : void 0, y = await this.reader.read( + this.numSplats * Tw[this.shDegree] * 3 + ); + let h = 0; + for (let k = 0; k < this.numSplats; k++) { + for (let R = 0; R < 9; ++R) + w[R] = (y[h + R] - 128) / 128; + if (h += 9, s) { + for (let R = 0; R < 15; ++R) + s[R] = (y[h + R] - 128) / 128; + h += 15; + } + if (o) { + for (let R = 0; R < 21; ++R) + o[R] = (y[h + R] - 128) / 128; + h += 21; + } + E == null || E(k, w, s, o); + } + } + if (this.flagLod) { + let w = await this.reader.read(this.numSplats * 2); + for (let s = 0; s < this.numSplats; s++) { + const o = s * 2, y = w[o] + (w[o + 1] << 8); + D == null || D(s, y); + } + w = await this.reader.read(this.numSplats * 4); + for (let s = 0; s < this.numSplats; s++) { + const o = s * 4, y = w[o] + (w[o + 1] << 8) + (w[o + 2] << 16) + (w[o + 3] << 24); + i == null || i(s, y); + } + } + } +} +const Tw = { 1: 3, 2: 8, 3: 15 }, Ow = 0.28209479177387814, NR = 1347635022, cR = 3, MR = 1; +class MI { + constructor({ + numSplats: A, + shDegree: I, + fractionalBits: g = 12, + flagAntiAlias: B = !0 + }) { + this.clippedCount = 0; + const C = 20 + // Rotation + (I >= 1 ? 9 : 0) + (I >= 2 ? 15 : 0) + (I >= 3 ? 21 : 0), E = 16 + A * C; + this.buffer = new ArrayBuffer(E), this.view = new DataView(this.buffer), this.view.setUint32(0, NR, !0), this.view.setUint32(4, cR, !0), this.view.setUint32(8, A, !0), this.view.setUint8(12, I), this.view.setUint8(13, g), this.view.setUint8(14, B ? MR : 0), this.view.setUint8(15, 0), this.numSplats = A, this.shDegree = I, this.fractionalBits = g, this.fraction = 1 << g, this.flagAntiAlias = B; + } + setCenter(A, I, g, B) { + const C = Math.round(I * this.fraction), E = Math.max(-8388607, Math.min(8388607, C)), D = Math.round(g * this.fraction), i = Math.max(-8388607, Math.min(8388607, D)), w = Math.round(B * this.fraction), s = Math.max(-8388607, Math.min(8388607, w)); + (C !== E || D !== i || w !== s) && (this.clippedCount += 1); + const h = 16 + A * 9; + this.view.setUint8(h, E & 255), this.view.setUint8(h + 1, E >> 8 & 255), this.view.setUint8(h + 2, E >> 16 & 255), this.view.setUint8(h + 3, i & 255), this.view.setUint8(h + 4, i >> 8 & 255), this.view.setUint8(h + 5, i >> 16 & 255), this.view.setUint8(h + 6, s & 255), this.view.setUint8(h + 7, s >> 8 & 255), this.view.setUint8(h + 8, s >> 16 & 255); + } + setAlpha(A, I) { + const g = 16 + this.numSplats * 9 + A; + this.view.setUint8( + g, + Math.max(0, Math.min(255, Math.round(I * 255))) + ); + } + static scaleRgb(A) { + const I = ((A - 0.5) / (Ow / 0.15) + 0.5) * 255; + return Math.max(0, Math.min(255, Math.round(I))); + } + setRgb(A, I, g, B) { + const C = 16 + this.numSplats * 10 + A * 3; + this.view.setUint8(C, MI.scaleRgb(I)), this.view.setUint8(C + 1, MI.scaleRgb(g)), this.view.setUint8(C + 2, MI.scaleRgb(B)); + } + setScale(A, I, g, B) { + const C = 16 + this.numSplats * 13 + A * 3; + this.view.setUint8( + C, + Math.max(0, Math.min(255, Math.round((Math.log(I) + 10) * 16))) + ), this.view.setUint8( + C + 1, + Math.max(0, Math.min(255, Math.round((Math.log(g) + 10) * 16))) + ), this.view.setUint8( + C + 2, + Math.max(0, Math.min(255, Math.round((Math.log(B) + 10) * 16))) + ); + } + setQuat(A, ...I) { + const g = 16 + this.numSplats * 16 + A * 4, B = SC(I); + let C = 0; + for (let i = 1; i < 4; ++i) + Math.abs(B[i]) > Math.abs(B[C]) && (C = i); + const E = B[C] < 0 ? 1 : 0; + let D = C; + for (let i = 0; i < 4; ++i) + if (i !== C) { + const w = (B[i] < 0 ? 1 : 0) ^ E, s = Math.floor( + 511 * (Math.abs(B[i]) / Math.SQRT1_2) + 0.5 + ); + D = D << 10 | w << 9 | s; + } + this.view.setUint8(g, D & 255), this.view.setUint8(g + 1, D >> 8 & 255), this.view.setUint8(g + 2, D >> 16 & 255), this.view.setUint8(g + 3, D >>> 24 & 255); + } + static quantizeSh(A, I) { + const g = Math.round(A * 128) + 128, B = 1 << 8 - I, C = Math.floor((g + B / 2) / B) * B; + return Math.max(0, Math.min(255, C)); + } + setSh(A, I, g, B) { + const C = Tw[this.shDegree] || 0, E = 16 + this.numSplats * 20 + A * C * 3; + for (let D = 0; D < 9; ++D) + this.view.setUint8(E + D, MI.quantizeSh(I[D], 5)); + if (g) { + const D = E + 9; + for (let i = 0; i < 15; ++i) + this.view.setUint8(D + i, MI.quantizeSh(g[i], 4)); + if (B) { + const i = D + 15; + for (let w = 0; w < 21; ++w) + this.view.setUint8(i + w, MI.quantizeSh(B[w], 4)); + } + } + } + async finalize() { + const A = new Uint8Array(this.buffer), g = new ReadableStream({ + async start(E) { + E.enqueue(A), E.close(); + } + }).pipeThrough(new CompressionStream("gzip")), C = await new Response(g).arrayBuffer(); + return console.log( + "Compressed", + A.length, + "bytes to", + C.byteLength, + "bytes" + ), new Uint8Array(C); + } +} +async function uk(Q) { + var s, o, y; + const A = new oR(), { + inputs: I, + clipXyz: g, + maxSh: B, + fractionalBits: C = 12, + opacityThreshold: E + } = Q; + for (const h of I) { + let k = function(t) { + return t.multiplyScalar(M), t.applyQuaternion(c), t.add(N), t; + }, R = function(t) { + return t.multiplyScalar(M), t; + }, F = function(t) { + return t.premultiply(c), t; + }, S = function(t) { + return !U || U.containsPoint(t); + }, a = function(t) { + return E !== void 0 ? t >= E : !0; + }; + const M = ((s = h.transform) == null ? void 0 : s.scale) ?? 1, c = new G.Quaternion().fromArray( + ((o = h.transform) == null ? void 0 : o.quaternion) ?? [0, 0, 0, 1] + ), N = new G.Vector3().fromArray( + ((y = h.transform) == null ? void 0 : y.translate) ?? [0, 0, 0] + ), U = g ? new G.Box3( + new G.Vector3().fromArray(g.min), + new G.Vector3().fromArray(g.max) + ) : void 0; + let J = h.fileType; + switch (J || (J = NB(h.fileBytes), !J && h.pathOrUrl && (J = cB(h.pathOrUrl))), J) { + case hA.PLY: { + const t = new Wg({ fileBytes: h.fileBytes }); + await t.parseHeader(); + let H = null; + t.parseSplats( + (K, Y, L, q, n, r, p, m, IA, X, EA, j, gA, W, u) => { + const b = k(new G.Vector3(Y, L, q)); + if (S(b) && a(j)) { + H = A.pushSplat(), A.setCenter(H, b.x, b.y, b.z); + const T = R( + new G.Vector3(n, r, p) + ); + A.setScale(H, T.x, T.y, T.z); + const f = F( + new G.Quaternion(m, IA, X, EA) + ); + A.setQuaternion( + H, + f.x, + f.y, + f.z, + f.w + ), A.setOpacity(H, j), A.setColor(H, gA, W, u); + } else + H = null; + }, + (K, Y, L, q) => { + Y && H !== null && A.setSh1(H, Y), L && H !== null && A.setSh2(H, L), q && H !== null && A.setSh3(H, q); + } + ); + break; + } + case hA.SPZ: { + const t = new aR({ fileBytes: h.fileBytes }); + await t.parseHeader(); + const H = new Int32Array(t.numSplats); + H.fill(-1); + const K = new Float32Array(t.numSplats * 3), Y = new G.Vector3(); + t.parseSplats( + (L, q, n, r) => { + const p = k(new G.Vector3(q, n, r)); + K[L * 3] = p.x, K[L * 3 + 1] = p.y, K[L * 3 + 2] = p.z; + }, + (L, q) => { + Y.fromArray(K, L * 3), S(Y) && a(q) && (H[L] = A.pushSplat(), A.setCenter(H[L], Y.x, Y.y, Y.z), A.setOpacity(H[L], q)); + }, + (L, q, n, r) => { + H[L] >= 0 && A.setColor(H[L], q, n, r); + }, + (L, q, n, r) => { + if (H[L] >= 0) { + const p = R( + new G.Vector3(q, n, r) + ); + A.setScale(H[L], p.x, p.y, p.z); + } + }, + (L, q, n, r, p) => { + if (H[L] >= 0) { + const m = F( + new G.Quaternion(q, n, r, p) + ); + A.setQuaternion( + H[L], + m.x, + m.y, + m.z, + m.w + ); + } + }, + (L, q, n, r) => { + H[L] >= 0 && (A.setSh1(H[L], q), n && A.setSh2(H[L], n), r && A.setSh3(H[L], r)); + } + ); + break; + } + case hA.SPLAT: + kR( + h.fileBytes, + (t) => { + }, + (t, H, K, Y, L, q, n, r, p, m, IA, X, EA, j, gA) => { + const W = k(new G.Vector3(H, K, Y)); + if (S(W) && a(X)) { + const u = A.pushSplat(); + A.setCenter(u, W.x, W.y, W.z); + const b = R( + new G.Vector3(L, q, n) + ); + A.setScale(u, b.x, b.y, b.z); + const T = F( + new G.Quaternion(r, p, m, IA) + ); + A.setQuaternion( + u, + T.x, + T.y, + T.z, + T.w + ), A.setOpacity(u, X), A.setColor(u, EA, j, gA); + } + } + ); + break; + case hA.KSPLAT: { + let t = null; + SR( + h.fileBytes, + (H) => { + }, + (H, K, Y, L, q, n, r, p, m, IA, X, EA, j, gA, W) => { + const u = k(new G.Vector3(K, Y, L)); + if (S(u) && a(EA)) { + t = A.pushSplat(), A.setCenter(t, u.x, u.y, u.z); + const b = R( + new G.Vector3(q, n, r) + ); + A.setScale(t, b.x, b.y, b.z); + const T = F( + new G.Quaternion(p, m, IA, X) + ); + A.setQuaternion( + t, + T.x, + T.y, + T.z, + T.w + ), A.setOpacity(t, EA), A.setColor(t, j, gA, W); + } else + t = null; + }, + (H, K, Y, L) => { + t !== null && (A.setSh1(t, K), Y && A.setSh2(t, Y), L && A.setSh3(t, L)); + } + ); + break; + } + default: + throw new Error(`transcodeSpz not implemented for ${J}`); + } + } + const D = Math.min( + B ?? 3, + A.sh3 ? 3 : A.sh2 ? 2 : A.sh1 ? 1 : 0 + ), i = new MI({ + numSplats: A.numSplats, + shDegree: D, + fractionalBits: C, + flagAntiAlias: !0 + }); + for (let h = 0; h < A.numSplats; ++h) { + const k = h * 3, R = h * 4; + i.setCenter( + h, + A.centers[k], + A.centers[k + 1], + A.centers[k + 2] + ), i.setScale( + h, + A.scales[k], + A.scales[k + 1], + A.scales[k + 2] + ), i.setQuat( + h, + A.quaternions[R], + A.quaternions[R + 1], + A.quaternions[R + 2], + A.quaternions[R + 3] + ), i.setAlpha(h, A.opacities[h]), i.setRgb( + h, + A.colors[k], + A.colors[k + 1], + A.colors[k + 2] + ), A.sh1 && D >= 1 && i.setSh( + h, + A.sh1.slice(h * 9, (h + 1) * 9), + D >= 2 && A.sh2 ? A.sh2.slice(h * 15, (h + 1) * 15) : void 0, + D >= 3 && A.sh3 ? A.sh3.slice(h * 21, (h + 1) * 21) : void 0 + ); + } + return { fileBytes: await i.finalize(), clippedCount: i.clippedCount }; +} +var JR = /* @__PURE__ */ ((Q) => (Q.DUAL_QUATERNION = "dual_quaternion", Q.LINEAR_BLEND = "linear_blend", Q))(JR || {}); +const O = class O { + constructor(A) { + this.mesh = A.mesh, this.numSplats = A.numSplats ?? this.mesh.numSplats, this.mode = A.mode ?? "dual_quaternion"; + const { width: I, height: g, depth: B, maxSplats: C } = BA(this.numSplats); + this.skinData = new Uint16Array(C * 4), this.skinTexture = new G.DataArrayTexture( + this.skinData, + I, + g, + B + ), this.skinTexture.format = G.RGBAIntegerFormat, this.skinTexture.type = G.UnsignedShortType, this.skinTexture.internalFormat = "RGBA16UI", this.skinTexture.needsUpdate = !0, this.numBones = A.numBones ?? 256, this.boneData = new Float32Array(this.numBones * 16), this.boneTexture = new G.DataTexture( + this.boneData, + 4, + this.numBones, + G.RGBAFormat, + G.FloatType + ), this.boneTexture.internalFormat = "RGBA32F", this.boneTexture.needsUpdate = !0, this.boneRestQuatPosScale = YQ(this.numBones, () => ({ + quat: new G.Quaternion(), + pos: new G.Vector3(), + scale: new G.Vector3() + })), this.mode === "linear_blend" ? this.boneRestInvMats = YQ(this.numBones, () => new G.Matrix4()) : this.boneRestInvMats = [], this.uniform = new x({ + key: "skinning", + type: DQ, + globals: () => [iQ], + value: { + numSplats: this.numSplats, + numBones: this.numBones, + skinTexture: this.skinTexture, + boneTexture: this.boneTexture + } + }); + } + // Apply the skeletal animation to a Gsplat in a dyno program. + modify(A) { + if (this.mode === "linear_blend") + throw new Error("Linear blend skinning requires covSplats=true"); + return tR(A, this.uniform); + } + modifyCov(A) { + return this.mode === "dual_quaternion" ? YR(A, this.uniform) : KR(A, this.uniform); + } + // Set the "rest" pose for a bone with position and quaternion orientation. + setRestQuatPos(A, I, g) { + this.boneRestQuatPosScale[A].quat.copy(I), this.boneRestQuatPosScale[A].pos.copy(g), this.boneRestQuatPosScale[A].scale.copy(O.UNIT_SCALE), this.mode === "linear_blend" && this.boneRestInvMats[A].compose(g, I, O.UNIT_SCALE).invert(), this.setBoneQuatPos(A, I, g); + } + getRestQuatPos(A, I, g) { + I.copy(this.boneRestQuatPosScale[A].quat), g.copy(this.boneRestQuatPosScale[A].pos); + } + setRestQuatPosScale(A, I, g, B) { + this.boneRestQuatPosScale[A].quat.copy(I), this.boneRestQuatPosScale[A].pos.copy(g), this.boneRestQuatPosScale[A].scale.copy(B), this.mode === "linear_blend" && this.boneRestInvMats[A].compose(g, I, B).invert(), this.setBoneQuatPosScale(A, I, g, B); + } + getRestQuatPosScale(A, I, g, B) { + I.copy(this.boneRestQuatPosScale[A].quat), g.copy(this.boneRestQuatPosScale[A].pos), B.copy(this.boneRestQuatPosScale[A].scale); + } + setRestMatrix(A, I) { + if (this.mode !== "linear_blend") + throw new Error("setRestMat only supported for linear blend skinning"); + this.boneRestInvMats[A].copy(I).invert(), this.setBoneMatrix(A, I); + } + getRestMatrix(A, I) { + if (this.mode !== "linear_blend") + throw new Error("getRestMat only supported for linear blend skinning"); + I.copy(this.boneRestInvMats[A]).invert(); + } + // Set the "current" position and orientation of a bone. + setBoneQuatPos(A, I, g) { + if (this.mode === "dual_quaternion") { + O.relQuat.copy(this.boneRestQuatPosScale[A].quat).invert(), O.relPos.copy(g).sub(this.boneRestQuatPosScale[A].pos), O.relQuat.multiply(I), O.dual.set( + O.relPos.x, + O.relPos.y, + O.relPos.z, + 0 + ).multiply(O.relQuat); + const B = A * 16; + this.boneData[B + 0] = O.relQuat.x, this.boneData[B + 1] = O.relQuat.y, this.boneData[B + 2] = O.relQuat.z, this.boneData[B + 3] = O.relQuat.w, this.boneData[B + 4] = 0.5 * O.dual.x, this.boneData[B + 5] = 0.5 * O.dual.y, this.boneData[B + 6] = 0.5 * O.dual.z, this.boneData[B + 7] = 0.5 * O.dual.w; + } else + this.setBoneQuatPosScale(A, I, g, O.UNIT_SCALE); + } + setBoneQuatPosScale(A, I, g, B) { + if (this.mode === "dual_quaternion") + throw new Error( + "setBoneQuatPosScale only supported for linear blend skinning" + ); + O.skinMat.compose(g, I, B), this.setBoneMatrix(A, O.skinMat); + } + setBoneMatrix(A, I) { + if (this.mode !== "linear_blend") + throw new Error("setBoneMatrix only supported for linear blend skinning"); + O.skinMat.multiplyMatrices( + this.boneRestInvMats[A], + I + ); + const g = A * 16; + this.boneData[g + 0] = O.skinMat.elements[0], this.boneData[g + 1] = O.skinMat.elements[1], this.boneData[g + 2] = O.skinMat.elements[2], this.boneData[g + 3] = O.skinMat.elements[4], this.boneData[g + 4] = O.skinMat.elements[5], this.boneData[g + 5] = O.skinMat.elements[6], this.boneData[g + 6] = O.skinMat.elements[8], this.boneData[g + 7] = O.skinMat.elements[9], this.boneData[g + 8] = O.skinMat.elements[10], this.boneData[g + 9] = O.skinMat.elements[12], this.boneData[g + 10] = O.skinMat.elements[13], this.boneData[g + 11] = O.skinMat.elements[14]; + } + // Set up to 4 bone indices and weights for a Gsplat. For fewer than 4 bones, + // you can set the remaining weights to 0 (and index=0). + setSplatBones(A, I, g) { + const B = A * 4; + this.skinData[B + 0] = Math.min(255, Math.max(0, Math.round(g.x * 255))) + (I.x << 8), this.skinData[B + 1] = Math.min(255, Math.max(0, Math.round(g.y * 255))) + (I.y << 8), this.skinData[B + 2] = Math.min(255, Math.max(0, Math.round(g.z * 255))) + (I.z << 8), this.skinData[B + 3] = Math.min(255, Math.max(0, Math.round(g.w * 255))) + (I.w << 8); + } + // Call this to indicate that the bones have changed and the Gsplats need to be + // re-generated with updated skinning. + updateBones() { + this.boneTexture.needsUpdate = !0, this.mesh.needsUpdate = !0; + } +}; +O.UNIT_SCALE = new G.Vector3(1, 1, 1), O.relQuat = new G.Quaternion(), O.relPos = new G.Vector3(), O.dual = new G.Quaternion(), O.skinMat = new G.Matrix4(); +let VB = O; +const DQ = { type: "GsplatSkinning" }, iQ = oA(` + struct GsplatSkinning { + int numSplats; + int numBones; + usampler2DArray skinTexture; + sampler2D boneTexture; + }; +`), UR = oA(` + void applyGsplatSkinning( + int numSplats, int numBones, + usampler2DArray skinTexture, sampler2D boneTexture, + int splatIndex, inout vec3 center, inout vec4 quaternion + ) { + if ((splatIndex < 0) || (splatIndex >= numSplats)) { + return; + } + + uvec4 skinData = texelFetch(skinTexture, splatTexCoord(splatIndex), 0); + + float weights[4]; + weights[0] = float(skinData.x & 0xffu) / 255.0; + weights[1] = float(skinData.y & 0xffu) / 255.0; + weights[2] = float(skinData.z & 0xffu) / 255.0; + weights[3] = float(skinData.w & 0xffu) / 255.0; + + uint boneIndices[4]; + boneIndices[0] = (skinData.x >> 8u) & 0xffu; + boneIndices[1] = (skinData.y >> 8u) & 0xffu; + boneIndices[2] = (skinData.z >> 8u) & 0xffu; + boneIndices[3] = (skinData.w >> 8u) & 0xffu; + + vec4 quat = vec4(0.0); + vec4 dual = vec4(0.0); + for (int i = 0; i < 4; i++) { + if (weights[i] > 0.0) { + int boneIndex = int(boneIndices[i]); + vec4 boneQuat = vec4(0.0, 0.0, 0.0, 1.0); + vec4 boneDual = vec4(0.0); + if (boneIndex < numBones) { + boneQuat = texelFetch(boneTexture, ivec2(0, boneIndex), 0); + boneDual = texelFetch(boneTexture, ivec2(1, boneIndex), 0); + } + + if ((i > 0) && (dot(quat, boneQuat) < 0.0)) { + // Flip sign if next blend is pointing in the opposite direction + boneQuat = -boneQuat; + boneDual = -boneDual; + } + quat += weights[i] * boneQuat; + dual += weights[i] * boneDual; + } + } + + // Normalize dual quaternion + float norm = length(quat); + quat /= norm; + dual /= norm; + vec3 translate = vec3( + 2.0 * (-dual.w * quat.x + dual.x * quat.w - dual.y * quat.z + dual.z * quat.y), + 2.0 * (-dual.w * quat.y + dual.x * quat.z + dual.y * quat.w - dual.z * quat.x), + 2.0 * (-dual.w * quat.z - dual.x * quat.y + dual.y * quat.x + dual.z * quat.w) + ); + + center = quatVec(quat, center) + translate; + quaternion = quatQuat(quat, quaternion); + } +`); +function tR(Q, A) { + return new d({ + inTypes: { gsplat: Z, skinning: DQ }, + outTypes: { gsplat: Z }, + globals: () => [iQ, UR], + inputs: { gsplat: Q, skinning: A }, + statements: ({ inputs: g, outputs: B }) => { + const { skinning: C } = g, { gsplat: E } = B; + return z(` + ${E} = ${g.gsplat}; + if (isGsplatActive(${E}.flags)) { + applyGsplatSkinning( + ${C}.numSplats, ${C}.numBones, + ${C}.skinTexture, ${C}.boneTexture, + ${E}.index, ${E}.center, ${E}.quaternion + ); + } + `); + } + }).outputs.gsplat; +} +const HR = oA(` + void applyCovSplatDQSkinning( + int numSplats, int numBones, + usampler2DArray skinTexture, sampler2D boneTexture, + int splatIndex, inout vec3 center, inout vec3 xxyyzz, inout vec3 xyxzyz + ) { + if ((splatIndex < 0) || (splatIndex >= numSplats)) { + return; + } + + uvec4 skinData = texelFetch(skinTexture, splatTexCoord(splatIndex), 0); + + float weights[4]; + weights[0] = float(skinData.x & 0xffu) / 255.0; + weights[1] = float(skinData.y & 0xffu) / 255.0; + weights[2] = float(skinData.z & 0xffu) / 255.0; + weights[3] = float(skinData.w & 0xffu) / 255.0; + + uint boneIndices[4]; + boneIndices[0] = (skinData.x >> 8u) & 0xffu; + boneIndices[1] = (skinData.y >> 8u) & 0xffu; + boneIndices[2] = (skinData.z >> 8u) & 0xffu; + boneIndices[3] = (skinData.w >> 8u) & 0xffu; + + vec4 quat = vec4(0.0); + vec4 dual = vec4(0.0); + for (int i = 0; i < 4; i++) { + if (weights[i] > 0.0) { + int boneIndex = int(boneIndices[i]); + vec4 boneQuat = vec4(0.0, 0.0, 0.0, 1.0); + vec4 boneDual = vec4(0.0); + if (boneIndex < numBones) { + boneQuat = texelFetch(boneTexture, ivec2(0, boneIndex), 0); + boneDual = texelFetch(boneTexture, ivec2(1, boneIndex), 0); + } + + if ((i > 0) && (dot(quat, boneQuat) < 0.0)) { + // Flip sign if next blend is pointing in the opposite direction + boneQuat = -boneQuat; + boneDual = -boneDual; + } + quat += weights[i] * boneQuat; + dual += weights[i] * boneDual; + } + } + + // Normalize dual quaternion + float norm = length(quat); + quat /= norm; + dual /= norm; + vec3 translate = vec3( + 2.0 * (-dual.w * quat.x + dual.x * quat.w - dual.y * quat.z + dual.z * quat.y), + 2.0 * (-dual.w * quat.y + dual.x * quat.z + dual.y * quat.w - dual.z * quat.x), + 2.0 * (-dual.w * quat.z - dual.x * quat.y + dual.y * quat.x + dual.z * quat.w) + ); + mat3 basis = quaternionToMatrix(quat); + + center = quatVec(quat, center) + translate; + + mat3 cov = mat3(xxyyzz.x, xyxzyz.x, xyxzyz.y, xyxzyz.x, xxyyzz.y, xyxzyz.z, xyxzyz.y, xyxzyz.z, xxyyzz.z); + cov = basis * cov * transpose(basis); + xxyyzz = vec3(cov[0][0], cov[1][1], cov[2][2]); + xyxzyz = vec3(cov[0][1], cov[0][2], cov[1][2]); + } +`), LR = oA(` + void applyCovSplatLBSkinning( + int numSplats, int numBones, + usampler2DArray skinTexture, sampler2D boneTexture, + int splatIndex, inout vec3 center, inout vec3 xxyyzz, inout vec3 xyxzyz + ) { + if ((splatIndex < 0) || (splatIndex >= numSplats)) { + return; + } + + uvec4 skinData = texelFetch(skinTexture, splatTexCoord(splatIndex), 0); + + float weights[4]; + weights[0] = float(skinData.x & 0xffu) / 255.0; + weights[1] = float(skinData.y & 0xffu) / 255.0; + weights[2] = float(skinData.z & 0xffu) / 255.0; + weights[3] = float(skinData.w & 0xffu) / 255.0; + + uint boneIndices[4]; + boneIndices[0] = (skinData.x >> 8u) & 0xffu; + boneIndices[1] = (skinData.y >> 8u) & 0xffu; + boneIndices[2] = (skinData.z >> 8u) & 0xffu; + boneIndices[3] = (skinData.w >> 8u) & 0xffu; + + mat3 basis = mat3(0.0); + vec3 offset = vec3(0.0); + + for (int i = 0; i < 4; i++) { + if (weights[i] > 0.0) { + int boneIndex = int(boneIndices[i]); + if (boneIndex < numBones) { + vec4 v0 = texelFetch(boneTexture, ivec2(0, boneIndex), 0); + vec4 v1 = texelFetch(boneTexture, ivec2(1, boneIndex), 0); + vec4 v2 = texelFetch(boneTexture, ivec2(2, boneIndex), 0); + basis += weights[i] * mat3(v0.x, v0.y, v0.z, v0.w, v1.x, v1.y, v1.z, v1.w, v2.x); + offset += weights[i] * vec3(v2.y, v2.z, v2.w); + } + } + } + + center = basis * center + offset; + + mat3 cov = mat3(xxyyzz.x, xyxzyz.x, xyxzyz.y, xyxzyz.x, xxyyzz.y, xyxzyz.z, xyxzyz.y, xyxzyz.z, xxyyzz.z); + cov = basis * cov * transpose(basis); + xxyyzz = vec3(cov[0][0], cov[1][1], cov[2][2]); + xyxzyz = vec3(cov[0][1], cov[0][2], cov[1][2]); + } +`); +function YR(Q, A) { + return new d({ + inTypes: { covsplat: eA, skinning: DQ }, + outTypes: { covsplat: eA }, + globals: () => [iQ, HR], + inputs: { covsplat: Q, skinning: A }, + statements: ({ inputs: g, outputs: B }) => { + const { skinning: C } = g, { covsplat: E } = B; + return z(` + ${E} = ${g.covsplat}; + if (isCovSplatActive(${E}.flags)) { + applyCovSplatDQSkinning( + ${C}.numSplats, ${C}.numBones, + ${C}.skinTexture, ${C}.boneTexture, + ${E}.index, ${E}.center, ${E}.xxyyzz, ${E}.xyxzyz + ); + } + `); + } + }).outputs.covsplat; +} +function KR(Q, A) { + return new d({ + inTypes: { covsplat: eA, skinning: DQ }, + outTypes: { covsplat: eA }, + globals: () => [iQ, LR], + inputs: { covsplat: Q, skinning: A }, + statements: ({ inputs: g, outputs: B }) => { + const { skinning: C } = g, { covsplat: E } = B; + return z(` + ${E} = ${g.covsplat}; + if (isCovSplatActive(${E}.flags)) { + applyCovSplatLBSkinning( + ${C}.numSplats, ${C}.numBones, + ${C}.skinTexture, ${C}.boneTexture, + ${E}.index, ${E}.center, ${E}.xxyyzz, ${E}.xyxzyz + ); + } + `); + } + }).outputs.covsplat; +} +function Tk({ + // PackedSplats object to add splats to + splats: Q, + // min and max box extents of the grid + extents: A, + // step size along each grid axis + stepSize: I = 1, + // spherical radius of each Gsplat + pointRadius: g = 0.01, + // relative size of the "shadow copy" of each Gsplat placed behind it + pointShadowScale: B = 2, + // Gsplat opacity + opacity: C = 1, + // Gsplat color (THREE.Color) or function to set color for position: + // ((THREE.Color, THREE.Vector3) => void) (default: RGB-modulated grid) + color: E +}) { + const i = new G.Vector3(), w = new G.Vector3(), s = new G.Quaternion(0, 0, 0, 1); + E == null && (E = (y, h) => y.set( + 0.55 + 0.45 * Math.cos(h.x * 1), + 0.55 + 0.45 * Math.cos(h.y * 1), + 0.55 + 0.45 * Math.cos(h.z * 1) + )); + const o = new G.Color(); + for (let y = A.min.z; y < A.max.z + 1e-6; y += I) + for (let h = A.min.y; h < A.max.y + 1e-6; h += I) + for (let k = A.min.x; k < A.max.x + 1e-6; k += I) { + i.set(k, h, y); + for (let R = 0; R < 2; ++R) + w.setScalar(g * (R ? 1 : B)), R ? typeof E == "function" ? E(o, i) : o.copy(E) : o.setScalar(0), Q.pushSplat(i, w, s, C, o); + } +} +function Ok({ + // PackedSplats object to add splats to + splats: Q, + // scale (Gsplat scale along axis) + scale: A = 0.25, + // radius of the axes (Gsplat scale orthogonal to axis) + axisRadius: I = 75e-4, + // relative size of the "shadow copy" of each Gsplat placed behind it + axisShadowScale: g = 2, + // origins of the axes (default single axis at origin) + origins: B = [new G.Vector3()] +}) { + const C = new G.Vector3(), E = new G.Vector3(), D = new G.Quaternion(0, 0, 0, 1), i = new G.Color(), w = 1; + for (const s of B) + for (let o = 0; o < 3; ++o) { + C.set( + s.x + (o === 0 ? A : 0), + s.y + (o === 1 ? A : 0), + s.z + (o === 2 ? A : 0) + ); + for (let y = 0; y < 2; ++y) + E.set( + (o === 0 ? A : I) * (y ? 1 : g), + (o === 1 ? A : I) * (y ? 1 : g), + (o === 2 ? A : I) * (y ? 1 : g) + ), i.setRGB( + y === 0 ? 0 : o === 0 ? 1 : 0, + y === 0 ? 0 : o === 1 ? 1 : 0, + y === 0 ? 0 : o === 2 ? 1 : 0 + ), Q.pushSplat(C, E, D, w, i); + } +} +function mk({ + // PackedSplats object to add splats to + splats: Q, + // center of the sphere (default: origin) + origin: A = new G.Vector3(), + // radius of the sphere + radius: I = 1, + // maximum depth of recursion for subdividing the sphere + // Warning: Gsplat count grows exponentially with depth + maxDepth: g = 3, + // filter function to apply to each point, for example to select + // points in a certain direction or other function ((THREE.Vector3) => boolean) + // (default: null) + filter: B = null, + // radius of each oriented Gsplat + pointRadius: C = 0.02, + // flatness of each oriented Gsplat + pointThickness: E = 1e-3, + // color of each Gsplat (THREE.Color) or function to set color for point: + // ((THREE.Color, THREE.Vector3) => void) (default: white) + color: D = new G.Color(1, 1, 1) +}) { + const i = {}; + function w(R) { + if (B && !B(R)) + return; + const F = `${R.x},${R.y},${R.z}`; + i[F] || (i[F] = R); + } + function s(R, F, S, a) { + if (w(F), w(S), w(a), R >= g) + return; + const M = new G.Vector3().addVectors(F, S).normalize(), c = new G.Vector3().addVectors(S, a).normalize(), N = new G.Vector3().addVectors(a, F).normalize(); + s(R + 1, F, M, N), s(R + 1, M, S, c), s(R + 1, N, c, a), s(R + 1, M, c, N); + } + for (const R of [-1, 1]) + for (const F of [-1, 1]) + for (const S of [-1, 1]) { + const a = new G.Vector3(R, 0, 0), M = new G.Vector3(0, F, 0), c = new G.Vector3(0, 0, S); + s(0, a, M, c); + } + const o = Object.values(i), y = new G.Vector3(C, C, E), h = new G.Quaternion(), k = typeof D == "function" ? new G.Color() : D; + for (const R of o) + h.setFromUnitVectors(new G.Vector3(0, 0, -1), R), typeof D == "function" && D(k, R), R.multiplyScalar(I), R.add(A), Q.pushSplat(R, y, h, 1, k); +} +function Zk({ + // text string to display + text: Q, + // browser font to render text with (default: "Arial") + font: A, + // font size in pixels/Gsplats (default: 32) + fontSize: I, + // SplatMesh.recolor tint assuming white Gsplats (default: white) + color: g, + // Individual Gsplat color (default: white) + rgb: B, + // Gsplat radius (default: 0.8 covers 1-unit spacing well) + dotRadius: C, + // text alignment: "left", "center", "right", "start", "end" (default: "start") + textAlign: E, + // line spacing multiplier, lines delimited by "\n" (default: 1.0) + lineHeight: D, + // Coordinate scale in object-space (default: 1.0) + objectScale: i +}) { + A = A ?? "Arial", I = I ?? 32, g = g ?? new G.Color(1, 1, 1), C = C ?? 0.8, E = E ?? "start", D = D ?? 1, i = i ?? 1; + const w = Q.split(` +`), s = document.createElement("canvas"), o = s.getContext("2d"); + if (!o) + throw new Error("Failed to create canvas context"); + o.font = `${I}px ${A}`, o.textAlign = E; + const y = o.measureText(""), h = y.fontBoundingBoxAscent + y.fontBoundingBoxDescent; + let k = Number.POSITIVE_INFINITY, R = Number.NEGATIVE_INFINITY, F = Number.POSITIVE_INFINITY, S = Number.NEGATIVE_INFINITY; + for (let n = 0; n < w.length; ++n) { + const r = o.measureText(w[n]), p = h * D * n; + k = Math.min(k, -r.actualBoundingBoxLeft), R = Math.max(R, r.actualBoundingBoxRight), F = Math.min(F, p - r.actualBoundingBoxAscent), S = Math.max(S, p + r.actualBoundingBoxDescent); + } + const a = Math.floor(k), M = Math.floor(F), c = Math.ceil(R) - a, N = Math.ceil(S) - M; + s.width = c, s.height = N, o.font = `${I}px ${A}`, o.textAlign = E, o.textBaseline = "alphabetic", o.fillStyle = "#FFFFFF"; + for (let n = 0; n < w.length; ++n) { + const r = h * D * n - M; + o.fillText(w[n], -a, r); + } + const U = o.getImageData(0, 0, c, N), J = new Uint8Array(U.data.buffer), t = new $A(), H = new G.Vector3(), K = new G.Vector3().setScalar(C * i), Y = new G.Quaternion(0, 0, 0, 1); + B = B ?? new G.Color(1, 1, 1); + let L = 0; + for (let n = 0; n < N; ++n) + for (let r = 0; r < c; ++r) { + const p = J[L + 3]; + if (p > 0) { + const m = p / 255; + H.set(r - 0.5 * (c - 1), 0.5 * (N - 1) - n, 0), H.multiplyScalar(i), t.pushSplat(H, K, Y, m, B); + } + L += 4; + } + const q = new vA({ packedSplats: t }); + return q.recolor = g, q; +} +function Vk({ + // URL of the image to convert to splats (example: `url: "./image.png"`) + url: Q, + // Radius of each Gsplat, default covers 1-unit spacing well (default: 0.8) + dotRadius: A, + // Subsampling factor for the image. Higher values reduce resolution, + // for example 2 will halve the width and height by averaging (default: 1) + subXY: I, + // Optional callback function to modify each Gsplat before it's added. + // Return null to skip adding the Gsplat, or a number to set the opacity + // and add the Gsplat with parameter values in the objects center, rgba etc. were + // passed into the forEachSplat callback. Ending the callback in `return opacity;` + // will retain the original opacity. + // ((width: number, height: number, index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => number | null) + forEachSplat: g +}) { + return A = A ?? 0.8, I = Math.max(1, Math.floor(I ?? 1)), new vA({ + constructSplats: async (B) => new Promise((C, E) => { + const D = new Image(); + D.crossOrigin = "anonymous", D.onerror = E, D.onload = () => { + const { width: i, height: w } = D, s = document.createElement("canvas"); + s.width = i, s.height = w; + const o = s.getContext("2d"); + if (!o) { + E(new Error("Failed to create canvas context")); + return; + } + o.imageSmoothingEnabled = !0, o.imageSmoothingQuality = "high"; + const y = Math.round(i / I), h = Math.round(w / I); + o.drawImage(D, 0, 0, y, h); + try { + const k = o.getImageData(0, 0, y, h), R = new Uint8Array(k.data.buffer), F = new G.Vector3(), S = new G.Vector3().setScalar(A), a = new G.Quaternion(0, 0, 0, 1), M = new G.Color(); + let c = 0; + for (let N = 0; N < h; ++N) + for (let U = 0; U < y; ++U) { + const J = c * 4, t = R[J + 3]; + if (t > 0) { + let H = t / 255; + M.set( + R[J + 0] / 255, + R[J + 1] / 255, + R[J + 2] / 255 + ), F.set( + U - 0.5 * (y - 1), + 0.5 * (h - 1) - N, + 0 + ), S.setScalar(A), a.set(0, 0, 0, 1); + let K = !0; + if (g) { + const Y = g( + y, + h, + c, + F, + S, + a, + H, + M + ); + H = Y ?? H, K = Y !== null; + } + K && B.pushSplat(F, S, a, H, M); + } + c += 1; + } + C(); + } catch (k) { + E(k); + } + }, D.src = Q; + }) + }); +} +function eR({ + box: Q, + cells: A, + dotScale: I, + color: g, + opacity: B +}) { + A.x = Math.max(1, Math.round(A.x)), A.y = Math.max(1, Math.round(A.y)), A.z = Math.max(1, Math.round(A.z)), B = B ?? 1; + const C = A.x * A.y * A.z, E = v("int", A.x), D = v("int", A.y); + v("int", A.z); + const i = wI(0), w = new PI({ + numSplats: C, + generator: cA( + { index: "int" }, + { gsplat: Z }, + ({ index: o }) => { + if (!o) + throw new Error("index is undefined"); + const y = pQ(o, E), h = pg(o, E), k = pQ(h, D), R = pg(h, D), F = yI({ + vectorType: "ivec3", + x: y, + y: k, + z: R + }), S = jD(i), a = yI({ vectorType: "ivec2", x: o, y: S }), M = zi(a), c = v("vec3", Q.min), N = v("vec3", Q.max), U = iI(N, c), J = pg(qA(fI(F), M), v("vec3", A)); + let t, H, K; + g ? (t = v("float", g.r), H = v("float", g.g), K = v("float", g.b)) : { r: t, g: H, b: K } = $I(J).outputs; + const Y = yI({ + vectorType: "vec4", + r: t, + g: H, + b: K, + a: v("float", B) + }), L = qA(c, kA(U, J)), q = fI(v("float", I)), n = v("vec4", new G.Quaternion(0, 0, 0, 1)); + let r = CI({ + flags: ug("uint", "GSPLAT_FLAG_ACTIVE"), + index: o, + center: L, + scales: q, + quaternion: n, + rgba: Y + }); + return r = s.applyGsplat(r), { gsplat: r }; + }, + { + globals: () => [HA] + } + ), + update: ({ time: o }) => { + i.value = o, s.update(w), w.updateVersion(); + } + }), s = new XI(); + return w; +} +const rR = { + box: new G.Box3( + new G.Vector3(-1, -1, -1), + new G.Vector3(1, 1, 1) + ), + density: 100, + fallDirection: new G.Vector3(-1, -3, 1).normalize(), + fallVelocity: 0.02, + wanderScale: 0.04, + wanderVariance: 2, + color1: new G.Color(1, 1, 1), + color2: new G.Color(0.5, 0.5, 1), + minScale: 1e-3, + maxScale: 5e-3, + anisoScale: new G.Vector3(1, 1, 1) +}, nR = { + box: new G.Box3( + new G.Vector3(-2, -1, -2), + new G.Vector3(2, 5, 2) + ), + density: 10, + fallDirection: new G.Vector3(0, -1, 0), + fallVelocity: 2, + wanderScale: 0.1, + wanderVariance: 1, + color1: new G.Color(1, 1, 1), + color2: new G.Color(0.25, 0.25, 0.5), + minScale: 5e-3, + maxScale: 0.01, + anisoScale: new G.Vector3(0.1, 1, 0.1) +}; +function dR({ + // min and max box extents of the snowBox + box: Q, + // minimum y-coordinate to clamp particle position, which can be used to + // fake hitting a ground plane and lingering there for a bit + minY: A, + // number of Gsplats to generate (default: calculated from box and density) + numSplats: I, + // density of Gsplats per unit volume (default: 100) + density: g, + // The xyz anisotropic scale of the Gsplat, which can be used for example + // to elongate rain particles (default: (1, 1, 1)) + anisoScale: B, + // Minimum Gsplat particle scale (default: 0.001) + minScale: C, + // Maximum Gsplat particle scale (default: 0.005) + maxScale: E, + // The average direction of fall (default: (0, -1, 0)) + fallDirection: D, + // The average speed of the fall (multiplied with fallDirection) (default: 0.02) + fallVelocity: i, + // The world scale of wandering overlay motion (default: 0.01) + wanderScale: w, + // Controls how uniformly the particles wander in sync, more variance mean + // more randomness in the motion (default: 2) + wanderVariance: s, + // Color 1 of the two colors interpolated between (default: (1, 1, 1)) + color1: o, + // Color 2 of the two colors interpolated between (default: (0.5, 0.5, 1)) + color2: y, + // The base opacity of the Gsplats (default: 1) + opacity: h, + // Optional callback function to call each frame. + onFrame: k +}) { + Q = Q ?? new G.Box3(new G.Vector3(-1, -1, -1), new G.Vector3(1, 1, 1)); + const R = (Q.max.x - Q.min.x) * (Q.max.y - Q.min.y) * (Q.max.z - Q.min.z); + g = g ?? 100, I = I ?? Math.max(1, Math.min(1e6, Math.round(R * g))); + const F = wI(C ?? 1e-3), S = wI(E ?? 5e-3), a = cI( + ((B == null ? void 0 : B.clone()) ?? new G.Vector3(1, 1, 1)).normalize() + ), M = cI( + (D ?? new G.Vector3(0, -1, 0)).normalize() + ), c = wI(i ?? 0.02), N = wI(w ?? 0.01), U = wI(s ?? 2), J = cI(o ?? new G.Color(1, 1, 1)), t = cI(y ?? new G.Color(0.5, 0.5, 1)), H = wI(h ?? 1), K = wI(0), Y = cI(new G.Vector3(0, 0, 0)), L = cI(Q.min), q = cI(Q.max), n = wI(A ?? Number.NEGATIVE_INFINITY), r = iI(q, L), p = new PI({ + numSplats: I, + generator: cA( + { index: "int" }, + { gsplat: Z }, + ({ index: IA }) => { + if (!IA) + throw new Error("index not defined"); + const X = bQ(IA), EA = $I(X).outputs.w; + let j = fI(X), gA = fg(kA(EA, v("float", 100))); + gA = PQ(kA(ug("float", "PI"), gA)), gA = qA(F, kA(gA, iI(S, F))); + const W = kA(gA, a), u = fg(kA(EA, v("float", 10))), b = fg(EA), T = vE(J, t, b), f = kA(T, u), FA = bQ( + yI({ + vectorType: "ivec2", + x: IA, + y: v("int", 6837) + }) + ); + let sA = fI(FA), SA = kA($I(FA).outputs.w, U); + SA = qA(K, SA), j = qA(j, Y); + const aA = WE( + j, + v("vec3", new G.Vector3(1, 1, 1)) + ); + j = qA(L, kA(r, aA)); + const wA = v("vec4", new G.Quaternion(0, 0, 0, 1)); + sA = PQ(qA(fI(SA), sA)), sA = kA(sA, N); + let GA = qA(j, sA), AI = $I(GA).outputs.y; + AI = jE(n, AI), GA = yI({ vector: GA, y: AI }); + let TA = CI({ + flags: ug("uint", "GSPLAT_FLAG_ACTIVE"), + index: IA, + center: GA, + scales: W, + quaternion: wA, + rgb: f, + opacity: H + }); + return TA = m.applyGsplat(TA), { gsplat: TA }; + }, + { + globals: () => [HA] + } + ), + update: ({ object: IA, time: X, deltaTime: EA }) => { + K.value = X, m.update(p); + const j = M.value.clone().multiplyScalar(c.value * EA); + Y.value.add(j), IA.visible = H.value > 0, k == null || k({ object: IA, time: X, deltaTime: EA }), p.updateVersion(); + } + }), m = new XI(); + return { + snow: p, + min: L, + max: q, + minY: n, + color1: J, + color2: t, + opacity: H, + fallVelocity: c, + wanderVariance: U, + wanderScale: N, + fallDirection: M, + minScale: F, + maxScale: S, + anisoScale: a + }; +} +const Xk = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + DEFAULT_RAIN: nR, + DEFAULT_SNOW: rR, + snowBox: dR, + staticBox: eR +}, Symbol.toStringTag, { value: "Module" })); +function mw(Q) { + return cA({ gsplat: Z }, { gsplat: Z }, ({ gsplat: A }) => { + if (!A) + throw new Error("No gsplat input"); + let I = qQ(A); + const g = Q.applyGsplat(A), B = uA(g).outputs.center, C = qQ(g), E = Yi(B, C), D = YD(E, v("float", 0)); + I = hB(D, yB(I), I); + const i = qA( + kA(I, v("float", 0.5)), + v("float", 0.5) + ); + return A = CI({ gsplat: A, rgb: i }), { gsplat: A }; + }); +} +function qR(Q) { + Q.enableWorldToView = !0, Q.worldModifier = mw(Q.context.worldToView), Q.updateGenerator(); +} +function Zw(Q, A, I, g) { + return cA({ gsplat: Z }, { gsplat: Z }, ({ gsplat: B }) => { + if (!B) + throw new Error("No gsplat input"); + let { center: C } = uA(B).outputs; + C = Q.apply(C); + const { z: E } = $I(C).outputs; + let D = _i(yB(E), A, I); + return D = hB(g, iI(v("float", 1), D), D), B = CI({ gsplat: B, r: D, g: D, b: D }), { gsplat: B }; + }); +} +function xR(Q, A, I, g) { + Q.enableWorldToView = !0; + const B = v("float", A), C = v("float", I), E = v("bool", g ?? !1); + return Q.worldModifier = Zw( + Q.context.worldToView, + B, + C, + E + ), Q.updateGenerator(), { + minDepth: B, + maxDepth: C, + reverse: E + }; +} +const Wk = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + makeDepthColorModifier: Zw, + makeNormalColorModifier: mw, + setDepthColor: xR, + setWorldNormalColor: qR +}, Symbol.toStringTag, { value: "Module" })), lR = 1, XB = 4, pR = 2, fR = 5, bR = 1 / 5, jk = !1, PR = (Q, A) => { + var I, g, B, C; + return Q.leftIsHand ? new G.Vector3() : new G.Vector3( + ((I = Q.left) == null ? void 0 : I.axes[2]) ?? 0, + (((g = Q.left) == null ? void 0 : g.buttons[0].value) ?? 0) - (((B = Q.left) == null ? void 0 : B.buttons[1].value) ?? 0), + ((C = Q.left) == null ? void 0 : C.axes[3]) ?? 0 + ); +}, uR = (Q, A) => { + var I; + return Q.rightIsHand ? new G.Vector3() : new G.Vector3(((I = Q.right) == null ? void 0 : I.axes[2]) ?? 0, 0, 0); +}, TR = (Q, A) => { + var I, g; + return Q.rightIsHand ? !1 : ((g = (I = Q.right) == null ? void 0 : I.buttons[0]) == null ? void 0 : g.pressed) ?? !1; +}, OR = (Q, A) => { + var I, g; + return Q.rightIsHand ? !1 : ((g = (I = Q.right) == null ? void 0 : I.buttons[1]) == null ? void 0 : g.pressed) ?? !1; +}; +var vg = /* @__PURE__ */ ((Q) => (Q.w = "wrist", Q.t0 = "thumb-metacarpal", Q.t1 = "thumb-phalanx-proximal", Q.t2 = "thumb-phalanx-distal", Q.t3 = "thumb-tip", Q.i0 = "index-finger-metacarpal", Q.i1 = "index-finger-phalanx-proximal", Q.i2 = "index-finger-phalanx-intermediate", Q.i3 = "index-finger-phalanx-distal", Q.i4 = "index-finger-tip", Q.m0 = "middle-finger-metacarpal", Q.m1 = "middle-finger-phalanx-proximal", Q.m2 = "middle-finger-phalanx-intermediate", Q.m3 = "middle-finger-phalanx-distal", Q.m4 = "middle-finger-tip", Q.r0 = "ring-finger-metacarpal", Q.r1 = "ring-finger-phalanx-proximal", Q.r2 = "ring-finger-phalanx-intermediate", Q.r3 = "ring-finger-phalanx-distal", Q.r4 = "ring-finger-tip", Q.p0 = "pinky-finger-metacarpal", Q.p1 = "pinky-finger-phalanx-proximal", Q.p2 = "pinky-finger-phalanx-intermediate", Q.p3 = "pinky-finger-phalanx-distal", Q.p4 = "pinky-finger-tip", Q))(vg || {}); +const kI = Object.keys(vg), mR = kI.length, ZR = { + w: 0, + t0: 1, + t1: 2, + t2: 3, + t3: 4, + i0: 5, + i1: 6, + i2: 7, + i3: 8, + i4: 9, + m0: 10, + m1: 11, + m2: 12, + m3: 13, + m4: 14, + r0: 15, + r1: 16, + r2: 17, + r3: 18, + r4: 19, + p0: 20, + p1: 21, + p2: 22, + p3: 23, + p4: 24 +}, WB = { + w: 0.02, + t0: 0.015, + t1: 0.012, + t2: 0.0105, + t3: 85e-4, + i0: 0.022, + i1: 0.012, + i2: 85e-4, + i3: 75e-4, + i4: 65e-4, + m0: 0.021, + m1: 0.012, + m2: 8e-3, + m3: 75e-4, + m4: 65e-4, + r0: 0.019, + r1: 0.011, + r2: 75e-4, + r3: 7e-3, + r4: 6e-3, + p0: 0.012, + p1: 0.01, + p2: 7e-3, + p3: 65e-4, + p4: 55e-4 +}, VR = [ + ["w", "t0", "t1", "t2", "t3"], + ["w", "i0", "i1", "i2", "i3", "i4"], + ["w", "m0", "m1", "m2", "m3", "m4"], + ["w", "r0", "r1", "r2", "r3", "r4"], + ["w", "p0", "p1", "p2", "p3", "p4"] +], XR = [ + [8, 10, 8, 6], + [8, 19, 14, 8, 6], + [8, 19, 14, 8, 6], + [8, 19, 14, 8, 6], + [8, 19, 14, 8, 6] +], WR = ["t3", "i4", "m4", "r4", "p4"], jR = ["i4", "m4", "r4", "p4"]; +var JB = /* @__PURE__ */ ((Q) => (Q.left = "left", Q.right = "right", Q))(JB || {}); +const vR = Object.keys(JB), zR = /Quest|OculusBrowser|VisionOS|XRBrowser|Pico|Lynx|MagicLeap/i; +function _R() { + const Q = navigator.userAgent ?? ""; + if (zR.test(Q)) + return !1; + if (/Android/i.test(Q) || /Mobile/i.test(Q)) + return !0; + const I = navigator.userAgentData; + return I && typeof I.mobile == "boolean" ? I.mobile : !1; +} +const ZA = class ZA { + constructor(A) { + this.lastControllersUpdate = 0, this.hands = [], this.renderer = A.renderer, this.xr = navigator.xr, this.mode = "initializing", this.onEnterXr = A.onEnterXr, this.onExitXr = A.onExitXr, this.enableHands = A.enableHands ?? !1, this.controllers = A.controllers, Promise.resolve().then(() => { + var C; + if (!this.xr) { + this.mode = "not_supported"; + return; + } + if (!A.allowMobileXr && _R()) { + this.mode = "not_supported"; + return; + } + this.enableHands && (this.hands = [new zg( + "left" + /* left */ + ), new zg( + "right" + /* right */ + )]); + let I, g; + if (A.element ? I = A.element : A.elementId ? I = document.getElementById(A.elementId) ?? void 0 : (I = ZA.createButton(), g = A.button == null || typeof A.button == "boolean" ? {} : A.button), !I) + throw new Error("No element or button provided"); + I.style.display = "none", I.classList.add("hidden"), this.button = g, this.element = I; + const B = (C = A.onMouseLeaveOpacity) == null ? void 0 : C.toString(); + return B !== void 0 && (I.addEventListener("mouseleave", () => { + I.style.opacity = B; + }), I.addEventListener("mouseenter", () => { + I.style.opacity = ""; + })), this.initializeXr(A); + }).then(() => { + var I; + return (I = A.onReady) == null ? void 0 : I.call(A, this.mode !== "not_supported"); + }).catch((I) => { + alert(`Error initializing SparkXr: ${I}`); + }); + } + async initializeXr(A) { + var w, s; + if (!this.xr || !this.element) + return; + const I = this.element, g = { + vr: ["immersive-vr"], + ar: ["immersive-ar"], + arvr: ["immersive-ar", "immersive-vr"], + vrar: ["immersive-vr", "immersive-ar"] + }[A.mode ?? "vrar"]; + if (!g) + throw new Error(`Invalid mode: ${A.mode}`); + let B = null; + for (const o of g) + if (await this.xr.isSessionSupported(o)) { + B = o; + break; + } + if (!B) { + this.mode = "not_supported"; + return; + } + this.mode = B; + const C = A.referenceSpaceType ?? "local"; + this.renderer.xr.enabled = !0, this.renderer.xr.setReferenceSpaceType(C), A.fixedFoveation !== void 0 && this.renderer.xr.setFoveation(A.fixedFoveation); + const E = A.frameBufferScaleFactor ?? 0.5; + this.renderer.xr.setFramebufferScaleFactor(E); + const D = ((w = A.sessionInit) == null ? void 0 : w.optionalFeatures) ?? []; + A.enableHands && D.push("hand-tracking"); + const i = ((s = A.sessionInit) == null ? void 0 : s.requiredFeatures) ?? []; + i.push(C), this.sessionInit = { + ...A.sessionInit, + optionalFeatures: D, + requiredFeatures: i + }, I.addEventListener("click", () => { + this.toggleXr(); + }), this.updateElement(); + } + async toggleXr() { + var A, I, g; + if (!(!this.xr || !this.sessionInit)) + if (this.session) + this.session.end(); + else + try { + const B = this.mode, C = await this.xr.requestSession(B, this.sessionInit); + this.session = C; + const E = () => { + var w; + C == null || C.removeEventListener("end", E), C == null || C.removeEventListener("visibilitychange", i), this.session = void 0, this.updateElement(), (w = this.onExitXr) == null || w.call(this); + }; + let D = C.visibilityState; + const i = () => { + (C == null ? void 0 : C.visibilityState) === "visible-blurred" && D === "visible" && (C == null || C.end()), D = C == null ? void 0 : C.visibilityState; + }; + return (A = this.session) == null || A.addEventListener("end", E), (I = this.session) == null || I.addEventListener("visibilitychange", i), await this.renderer.xr.setSession(this.session), (g = this.onEnterXr) == null ? void 0 : g.call(this); + } catch (B) { + console.error("Error requesting XR session", B); + return; + } + } + updateElement() { + const A = this.mode, I = this.element; + if (I) { + I.style.display = "", I.classList.remove("hidden"); + const g = typeof this.button == "boolean" ? {} : this.button; + if (g) { + if (this.session) { + const B = (A === "immersive-vr" ? g.exitVrHtml : g.exitArHtml) ?? g.exitXrHtml, C = (A === "immersive-vr" ? g.exitVrText : g.exitArText) ?? g.exitXrText; + B ? I.innerHTML = B : C ? I.textContent = C : I.textContent = A === "immersive-vr" ? "EXIT VR" : "EXIT AR"; + } else { + const B = (A === "immersive-vr" ? g.enterVrHtml : g.enterArHtml) ?? g.enterXrHtml, C = (A === "immersive-vr" ? g.enterVrText : g.enterArText) ?? g.enterXrText; + B ? I.innerHTML = B : C ? I.textContent = C : I.textContent = A === "immersive-vr" ? "ENTER VR" : "ENTER AR"; + } + I.style.display = ""; + } + } + } + static createButton() { + const A = document.createElement("button"); + return Object.assign(A.style, { + position: "absolute", + bottom: "20px", + left: "50%", + transform: "translateX(-50%)", + padding: "40px 40px", + border: "2px solid #fff", + borderRadius: "16px", + background: "rgba(0,0,0,0.1)", + color: "#fff", + font: "bold 28px sans-serif", + textAlign: "center", + userSelect: "none", + zIndex: "999" + }), document.body.appendChild(A), A; + } + xrSupported() { + return !!this.xr; + } + left() { + return this.hands[0]; + } + right() { + return this.hands[1]; + } + updateControllers(A) { + var w, s, o, y, h, k, R, F, S, a, M, c; + const I = A.parent, g = performance.now(), B = (g - (this.lastControllersUpdate || g)) / 1e3; + this.lastControllersUpdate = g; + const C = {}; + for (const N of ((w = this.renderer.xr.getSession()) == null ? void 0 : w.inputSources) ?? []) { + const U = N.gamepad; + U && (N.handedness === "left" || N.handedness === "right") && (C[N.handedness] = U, N.handedness === "left" ? C.leftIsHand = !!N.hand : N.handedness === "right" && (C.rightIsHand = !!N.hand)); + } + const E = (((s = this.controllers) == null ? void 0 : s.getRotate) ?? uR)(C, this); + if (E.multiply( + new G.Vector3( + ((o = this.controllers) == null ? void 0 : o.rotateSpeed) ?? XB, + ((y = this.controllers) == null ? void 0 : y.rotateSpeed) ?? XB, + ((h = this.controllers) == null ? void 0 : h.rollSpeed) ?? pR + ) + ), E.manhattanLength() > 0) { + E.multiplyScalar(B); + const N = new G.Euler(-E.y, -E.x, E.z, "YXZ"), U = new G.Quaternion().setFromEuler(N), J = A.getWorldPosition(new G.Vector3()); + (k = I.parent) == null || k.worldToLocal(J), I.position.sub(J), I.position.applyQuaternion(U), I.position.add(J), I.quaternion.premultiply(U); + } + const D = (((R = this.controllers) == null ? void 0 : R.getMove) ?? PR)( + C, + this + ); + let i = ((F = this.controllers) == null ? void 0 : F.moveSpeed) ?? lR; + (((S = this.controllers) == null ? void 0 : S.getFast) ?? TR)( + C, + this + ) && (i *= fR), (((a = this.controllers) == null ? void 0 : a.getSlow) ?? OR)( + C, + this + ) && (i *= bR), (M = this.controllers) != null && M.moveHeading ? D.applyQuaternion(A.quaternion) : (c = this.controllers) != null && c.moveDirection && (ng.setFromQuaternion(A.quaternion, "YXZ"), ng.x = 0, ng.z = 0, mQ.setFromEuler(ng), D.applyQuaternion(mQ)), D.applyQuaternion(I.quaternion), D.multiplyScalar(B * i), I.position.add(D); + } + updateHands({ xrFrame: A }) { + const I = this.renderer.xr.getSession(); + if (!I) + return; + const g = this.renderer.xr.getReferenceSpace(); + if (g && A.getJointPose) { + for (const B of this.hands) + B && (B.lastJoints = B.joints, B.joints = void 0); + for (const B of I.inputSources) { + if (!B.hand) + continue; + const C = B.handedness, E = this.hands[C === "left" ? 0 : 1]; + if (E) + for (const D of kI) { + const i = B.hand.get(vg[D]); + if (i) { + const w = A.getJointPose(i, g); + if (w) { + const { position: s, orientation: o } = w.transform; + E.joints || (E.joints = {}), E.joints[D] = { + position: new G.Vector3(s.x, s.y, s.z), + quaternion: new G.Quaternion( + o.x, + o.y, + o.z, + o.w + ), + radius: WB[D] + }; + } + } + } + } + } + } + makeJointSplats(A) { + const I = new Dk(A); + return I.onFrame = () => { + const g = this.hands[A === "left" ? 0 : 1], B = g == null ? void 0 : g.joints; + I.updateJoints(B); + }, I; + } + snapshotHands(A) { + var g, B; + const I = [ + (g = this.hands[0]) == null ? void 0 : g.snapshotJoints(), + (B = this.hands[1]) == null ? void 0 : B.snapshotJoints() + ]; + return { time: A, hands: I }; + } +}; +ZA.JointEnum = vg, ZA.JOINT_IDS = kI, ZA.NUM_JOINTS = mR, ZA.JOINT_INDEX = ZR, ZA.JOINT_RADIUS = WB, ZA.JOINT_SEGMENTS = VR, ZA.JOINT_SEGMENT_STEPS = XR, ZA.JOINT_TIPS = WR, ZA.FINGER_TIPS = jR, ZA.Hand = JB, ZA.HANDS = vR; +let jB = ZA; +const UQ = (Q) => Math.round(Q * 1e4) / 1e4, ng = new G.Euler(0, 0, 0, "YXZ"), mQ = new G.Quaternion(), $R = new G.Quaternion(); +function vk(Q, A) { + if (!Q.length) + return null; + const I = Q[0], g = Q[Q.length - 1]; + if (A < I.time || A > g.time) + return null; + const B = gk(Q, A); + if (B === -1) + return null; + const C = Q[B], E = Q[B + 1]; + if (!E) + return Ik(C, A); + const D = E.time - C.time, i = D > 0 ? (A - C.time) / D : 0; + return Ak(C, E, i, A); +} +function Ak(Q, A, I, g) { + const B = Math.max(Q.hands.length, A.hands.length), C = Array.from( + { length: B }, + (E, D) => Qk(Q.hands[D], A.hands[D], I) + ); + return { time: g, hands: C }; +} +function Ik(Q, A) { + return { + time: A, + hands: Q.hands.map((I) => Ck(I)) + }; +} +class zg { + constructor(A) { + this.hand = A; + } + static newFromSnapshot(A, I) { + const g = new zg(A); + g.joints = {}; + for (const B of kI) { + const C = I[B]; + C && (g.joints[B] = { + position: new G.Vector3(C.pos[0], C.pos[1], C.pos[2]), + quaternion: new G.Quaternion( + C.quat[0], + C.quat[1], + C.quat[2], + C.quat[3] + ), + radius: C.radius + }); + } + return g; + } + valid() { + return !!this.joints; + } + snapshotJoints() { + if (!this.joints) + return; + const A = {}; + for (const I of kI) { + const g = this.joints[I]; + g && (A[I] = { + pos: g.position.toArray().map(UQ), + quat: g.quaternion.toArray().map(UQ), + radius: UQ(g.radius) + }); + } + return A; + } + toFlatArray() { + if (!this.joints) + return; + const A = new Float32Array(1 + 25 * 7); + A[0] = this.hand === "left" ? 0 : 1; + let I = 1; + for (const g of kI) { + const B = this.joints[g]; + B && (A[I] = B.position.x, A[I + 1] = B.position.y, A[I + 2] = B.position.z, A[I + 3] = B.quaternion.x, A[I + 4] = B.quaternion.y, A[I + 5] = B.quaternion.z, A[I + 6] = B.quaternion.w), I += 7; + } + return A; + } +} +function gk(Q, A) { + let I = 0, g = Q.length - 1; + for (; I <= g; ) { + const B = I + g >> 1; + Q[B].time <= A ? I = B + 1 : g = B - 1; + } + return g; +} +function Qk(Q, A, I = 0) { + if (!Q || !A) + return; + const g = {}; + for (const B of kI) { + const C = Bk(Q[B], A[B], I); + C && (g[B] = C); + } + return g; +} +function Bk(Q, A, I = 0) { + if (!Q || !A) + return; + const g = Q.pos.map( + (E, D) => E + (A.pos[D] - E) * I + ), B = mQ.fromArray(Q.quat).slerp($R.fromArray(A.quat), I).toArray(), C = Q.radius + (A.radius - Q.radius) * I; + return { pos: g, quat: B, radius: C }; +} +function Ck(Q) { + if (!Q) + return; + const A = {}; + for (const I of kI) { + const g = Q[I]; + g && (A[I] = Ek(g)); + } + return A; +} +function Ek(Q) { + return { + pos: [...Q.pos], + quat: [...Q.quat], + radius: Q.radius + }; +} +class Dk extends vA { + constructor(A) { + super({}), this.scratchCenter = new G.Vector3(), this.scratchQuat = new G.Quaternion(0, 0, 0, 1), this.scratchScales = new G.Vector3().setScalar(0.01), this.scratchColor = new G.Color(1, 1, 1), this.hand = A; + } + updateJoints(A) { + if (this.visible = !1, !A || !this.packedSplats) + return; + this.visible = !0; + let I = 0; + for (const g of kI) { + const B = A[g]; + if (!B) + continue; + this.scratchCenter.copy(B.position), this.scratchQuat.copy(B.quaternion), this.scratchScales.set( + B.radius, + 0.75 * B.radius, + 1.5 * B.radius + ), this.packedSplats.setSplat( + I, + this.scratchCenter, + this.scratchScales, + this.scratchQuat, + 0.75, + this.scratchColor + ), I += 1; + } + this.packedSplats.numSplats = I, this.packedSplats.needsUpdate = !0, this.numSplats = I, this.updateVersion(); + } +} +const ik = 0.5, wk = 0.5, ok = 0; +var UB = /* @__PURE__ */ ((Q) => (Q.w = "wrist", Q.t0 = "thumb-metacarpal", Q.t1 = "thumb-phalanx-proximal", Q.t2 = "thumb-phalanx-distal", Q.t3 = "thumb-tip", Q.i0 = "index-finger-metacarpal", Q.i1 = "index-finger-phalanx-proximal", Q.i2 = "index-finger-phalanx-intermediate", Q.i3 = "index-finger-phalanx-distal", Q.i4 = "index-finger-tip", Q.m0 = "middle-finger-metacarpal", Q.m1 = "middle-finger-phalanx-proximal", Q.m2 = "middle-finger-phalanx-intermediate", Q.m3 = "middle-finger-phalanx-distal", Q.m4 = "middle-finger-tip", Q.r0 = "ring-finger-metacarpal", Q.r1 = "ring-finger-phalanx-proximal", Q.r2 = "ring-finger-phalanx-intermediate", Q.r3 = "ring-finger-phalanx-distal", Q.r4 = "ring-finger-tip", Q.p0 = "pinky-finger-metacarpal", Q.p1 = "pinky-finger-phalanx-proximal", Q.p2 = "pinky-finger-phalanx-intermediate", Q.p3 = "pinky-finger-phalanx-distal", Q.p4 = "pinky-finger-tip", Q))(UB || {}); +const Vw = Object.keys(UB), zk = Vw.length, _k = { + w: 0, + t0: 1, + t1: 2, + t2: 3, + t3: 4, + i0: 5, + i1: 6, + i2: 7, + i3: 8, + i4: 9, + m0: 10, + m1: 11, + m2: 12, + m3: 13, + m4: 14, + r0: 15, + r1: 16, + r2: 17, + r3: 18, + r4: 19, + p0: 20, + p1: 21, + p2: 22, + p3: 23, + p4: 24 +}, dg = { + w: 0.02, + t0: 0.02, + t1: 0.014, + t2: 0.0115, + t3: 85e-4, + i0: 0.022, + i1: 0.012, + i2: 85e-4, + i3: 75e-4, + i4: 65e-4, + m0: 0.021, + m1: 0.012, + m2: 8e-3, + m3: 75e-4, + m4: 65e-4, + r0: 0.019, + r1: 0.011, + r2: 75e-4, + r3: 7e-3, + r4: 6e-3, + p0: 0.012, + p1: 0.01, + p2: 7e-3, + p3: 65e-4, + p4: 55e-4 +}, sk = [ + ["w", "t0", "t1", "t2", "t3"], + ["w", "i0", "i1", "i2", "i3", "i4"], + ["w", "m0", "m1", "m2", "m3", "m4"], + ["w", "r0", "r1", "r2", "r3", "r4"], + ["w", "p0", "p1", "p2", "p3", "p4"] +], Gk = [ + [8, 10, 8, 6], + [8, 19, 14, 8, 6], + [8, 19, 14, 8, 6], + [8, 19, 14, 8, 6], + [8, 19, 14, 8, 6] +], $k = ["t3", "i4", "m4", "r4", "p4"], AF = ["i4", "m4", "r4", "p4"]; +var Xw = /* @__PURE__ */ ((Q) => (Q.left = "left", Q.right = "right", Q))(Xw || {}); +const ZQ = Object.keys(Xw); +class IF { + constructor() { + this.hands = {}, this.last = {}, this.values = {}, this.tests = {}, this.lastTests = {}, this.updated = !1; + } + update({ xr: A, xrFrame: I }) { + const g = A.getSession(); + if (!g) + return; + const B = A.getReferenceSpace(); + if (B && I.getJointPose) { + this.last = this.hands, this.lastTests = this.tests, this.hands = {}, this.values = {}, this.tests = {}; + for (const C of g.inputSources) { + if (!C.hand) + continue; + const E = C.handedness; + this.hands[E] = {}; + for (const D of Vw) { + const i = C.hand.get(UB[D]); + if (i) { + const w = I.getJointPose(i, B); + if (w) { + const { position: s, orientation: o } = w.transform; + this.hands[E][D] = { + position: new gI(s.x, s.y, s.z), + quaternion: new HB( + o.x, + o.y, + o.z, + o.w + ), + radius: w.radius || 1e-3 + }; + } + } + } + } + for (const C of ZQ) + for (const { key: E, value: D } of [ + { key: `${C}AllTips`, value: this.allTipsTouching(C) }, + { + key: `${C}IndexThumb`, + value: this.touching(C, "i4", C, "t3") + }, + { + key: `${C}MiddleThumb`, + value: this.touching(C, "m4", C, "t3") + }, + { + key: `${C}RingThumb`, + value: this.touching(C, "r4", C, "t3") + }, + { + key: `${C}PinkyThumb`, + value: this.touching(C, "p4", C, "t3") + }, + { key: `${C}TriTips`, value: this.triTipsTouching(C) } + ]) + this.values[E] = D, this.tests[E] = D === 1 ? !0 : D === 0 ? !1 : this.lastTests[E] ?? !1; + } + } + makeGhostMesh() { + const A = new gI(), I = new gI(0.01, 0.01, 0.01), g = new HB(0, 0, 0, 1), B = new LB(1, 1, 1), C = Math.PI * 3; + new LB(1, 1, 1); + let E = 1; + const D = new vA({ + onFrame: () => { + if (!D.packedSplats) + return; + let i = 0; + for (const w of ZQ) { + const s = this.hands[w]; + for (const [o, y] of sk.entries()) + for (let h = 1; h < y.length; ++h) { + const k = Gk[o][h - 1] * 2, R = h + 1 === y.length, F = s == null ? void 0 : s[y[h - 1]], S = s == null ? void 0 : s[y[h]]; + for (let a = 0; a < k; ++a) { + const M = (a + 0.5) / k; + if (E = 0, F && S) { + A.copy(F.position).lerp(S.position, M), g.copy(F.quaternion).slerp(S.quaternion, M); + const c = dg[y[h - 1]], N = dg[y[h]]; + let U = (1 - M) * c + M * N; + R && M > 0.8 && (U *= Math.sqrt(1 - ((M - 0.8) / 0.2) ** 2)), I.set(0.65 * U, 0.5 * U, 3e-3), B.set( + 0.55 + 0.45 * Math.sin(A.x * C), + 0.55 + 0.45 * Math.sin(A.y * C), + 0.55 + 0.45 * Math.sin(A.z * C) + ), w === "right" && B.set(1 - B.r, 1 - B.g, 1 - B.b), E = 0.75; + } + D.packedSplats.setSplat( + i, + A, + I, + g, + E, + B + ), i += 1; + } + } + } + D.packedSplats.numSplats = i, D.packedSplats.needsUpdate = !0, D.numSplats = i, D.updateVersion(); + } + }); + return D; + } + distance(A, I, g, B, C = !1) { + const E = C ? this.last[A] : this.hands[A], D = C ? this.last[g] : this.hands[g], i = E == null ? void 0 : E[I], w = D == null ? void 0 : D[B]; + return !i || !w ? Number.POSITIVE_INFINITY : i.position.distanceTo(w.position); + } + separation(A, I, g, B, C = !1) { + const E = this.distance(A, I, g, B, C); + return E === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : E - dg[I] - dg[B]; + } + touching(A, I, g, B, C = !1) { + const E = this.separation(A, I, g, B, C); + return E === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : 1 - Math.max(0, Math.min(1, E / 0.01 - ok)); + } + allTipsTouching(A, I = !1) { + return Math.min( + this.touching(A, "t3", A, "i4", I), + this.touching(A, "i4", A, "m4", I), + this.touching(A, "m4", A, "r4", I), + this.touching(A, "r4", A, "p4", I) + // this.touching(hand, "p4", hand, "t3", last), + ); + } + triTipsTouching(A, I = !1) { + return Math.min( + this.touching(A, "t3", A, "i4", I), + this.touching(A, "i4", A, "m4", I), + this.touching(A, "m4", A, "t3", I) + ); + } +} +class gF { + constructor({ + xrHands: A, + control: I, + moveInertia: g, + rotateInertia: B + }) { + this.lastGrip = {}, this.lastPivot = new gI(), this.rotateVelocity = 0, this.velocity = new gI(), this.xrHands = A, this.control = I, this.moveInertia = g ?? ik, this.rotateInertia = B ?? wk; + } + update(A) { + var C, E, D, i, w; + const I = {}; + for (const s of ZQ) { + const o = this.xrHands.hands[s]; + o && this.xrHands.tests[`${s}MiddleThumb`] && (I[s] = new gI().add(((C = o.t3) == null ? void 0 : C.position) ?? new gI()).add(((E = o.i4) == null ? void 0 : E.position) ?? new gI()).add(((D = o.m4) == null ? void 0 : D.position) ?? new gI()).add(((i = o.r4) == null ? void 0 : i.position) ?? new gI()).add(((w = o.p4) == null ? void 0 : w.position) ?? new gI()).multiplyScalar(1 / 5)); + } + if (I.left && I.right && this.lastGrip.left && this.lastGrip.right) { + const s = I.left.clone().add(I.right).multiplyScalar(0.5), o = this.lastGrip.left.clone().add(this.lastGrip.right).multiplyScalar(0.5); + this.lastPivot = s; + const y = s.clone().applyMatrix4(this.control.matrix); + y.sub(o.clone().applyMatrix4(this.control.matrix)), y.multiplyScalar(1 / A), this.velocity.lerp(y, 1 - Math.exp(-20 * A)); + const h = Math.atan2(I.left.z - s.z, I.left.x - s.x), k = Math.atan2( + this.lastGrip.left.z - o.z, + this.lastGrip.left.x - o.x + ); + let R = h - k; + R > Math.PI ? R -= Math.PI * 2 : R < -Math.PI && (R += Math.PI * 2); + const F = R / A, S = Math.exp(-20 * A); + this.rotateVelocity = this.rotateVelocity * S + F * (1 - S); + } else if (this.rotateVelocity *= Math.exp(-A / this.rotateInertia), I.left && this.lastGrip.left) { + const s = I.left.clone().applyMatrix4(this.control.matrix); + s.sub(this.lastGrip.left.clone().applyMatrix4(this.control.matrix)), s.multiplyScalar(1 / A), this.velocity.lerp(s, 1 - Math.exp(-20 * A)); + } else if (I.right && this.lastGrip.right) { + const s = I.right.clone().applyMatrix4(this.control.matrix); + s.sub( + this.lastGrip.right.clone().applyMatrix4(this.control.matrix) + ), s.multiplyScalar(1 / A), this.velocity.lerp(s, 1 - Math.exp(-20 * A)); + } else + this.velocity.multiplyScalar(Math.exp(-A / this.moveInertia)); + const g = this.lastPivot.clone().negate(), B = new hQ().makeTranslation(g).premultiply(new hQ().makeRotationY(this.rotateVelocity * A)).premultiply(new hQ().makeTranslation(this.lastPivot)); + this.control.matrix.multiply(B), this.control.matrix.decompose( + this.control.position, + this.control.quaternion, + this.control.scale + ), this.control.updateMatrixWorld(!0), this.control.position.sub(this.velocity.clone().multiplyScalar(A)), this.lastGrip = I; + } +} +const yk = 1, hk = 2, Rk = 2e-3, kk = 6e-3, Fk = 15e-4, Sk = 0.15, ak = 0.15, Nk = 0.1, ck = 2, Mk = 0, Jk = 500, Uk = 500, tk = 200, Hk = 400, Lk = 25, oI = 1e-4, Yk = { + KeyW: new G.Vector3(0, 0, -1), + KeyS: new G.Vector3(0, 0, 1), + KeyA: new G.Vector3(-1, 0, 0), + KeyD: new G.Vector3(1, 0, 0), + KeyE: new G.Vector3(0, 1, 0), + KeyQ: new G.Vector3(0, -1, 0) +}, Kk = { + ArrowUp: new G.Vector3(0, 0, -1), + ArrowDown: new G.Vector3(0, 0, 1), + ArrowLeft: new G.Vector3(-1, 0, 0), + ArrowRight: new G.Vector3(1, 0, 0), + PageUp: new G.Vector3(0, 1, 0), + PageDown: new G.Vector3(0, -1, 0) +}; +new G.Vector3(0, 0, 1), new G.Vector3(0, 0, -1); +const ek = { + Home: new G.Vector3(0, -1, 0), + End: new G.Vector3(0, 1, 0), + Insert: new G.Vector3(-1, 0, 0), + Delete: new G.Vector3(1, 0, 0) +}; +class QF { + constructor({ canvas: A }) { + this.lastTime = 0, this.fpsMovement = new rk({}), this.pointerControls = new nk({ canvas: A }); + } + update(A, I) { + const g = performance.now(), B = (g - (this.lastTime || g)) / 1e3; + this.lastTime = g; + let C = this.fpsMovement.update(B, A); + return this.pointerControls.update(B, A, I) && (C = !0), C; + } +} +class rk { + constructor({ + moveSpeed: A, + rollSpeed: I, + stickThreshold: g, + rotateSpeed: B, + keycodeMoveMapping: C, + keycodeRotateMapping: E, + gamepadMapping: D, + capsMultiplier: i, + shiftMultiplier: w, + ctrlMultiplier: s, + xr: o + } = {}) { + this.enable = !0, this.extraMove = new G.Vector3(), this.moveSpeed = A ?? yk, this.rollSpeed = I ?? hk, this.stickThreshold = g ?? Nk, this.rotateSpeed = B ?? ck, this.keycodeMoveMapping = C ?? { + ...Yk, + ...Kk + }, this.keycodeRotateMapping = E ?? { + // ...QE_KEYCODE_ROTATE, + ...ek + }, this.gamepadMapping = D ?? { + 4: "rollLeft", + 5: "rollRight", + 6: "ctrl", + 7: "shift" + }, this.capsMultiplier = i ?? 10, this.shiftMultiplier = w ?? 5, this.ctrlMultiplier = s ?? 1 / 5, this.xr = o, this.keydown = {}, this.keycode = {}, document.addEventListener("keydown", (y) => { + this.keydown[y.key] = !0, this.keycode[y.code] = !0; + }), document.addEventListener("keyup", (y) => { + this.keydown[y.key] = !1, this.keycode[y.code] = !1; + }), window.addEventListener("blur", () => { + this.keydown = {}, this.keycode = {}; + }); + } + // Call this method in your render loop with `control` set to the object to control + // (`THREE.Camera` or a `THREE.Object3D` that contains it), with `deltaTime` + // in seconds since the last update. + update(A, I) { + var o, y; + if (!this.enable) + return !1; + const g = [new G.Vector2(), new G.Vector2()], B = navigator.getGamepads()[0]; + B && (g[0].set(B.axes[0], B.axes[1]), g[1].set(B.axes[2], B.axes[3])); + const C = (B == null ? void 0 : B.buttons.map((h) => h.pressed)) || [], E = Array.from(((y = (o = this.xr) == null ? void 0 : o.getSession()) == null ? void 0 : y.inputSources) ?? []); + for (const h of E) { + const k = h.gamepad; + if (k) + switch (h.handedness) { + case "none": { + g[0].x += k.axes[0], g[0].y += k.axes[1], g[1].x += k.axes[2], g[1].y += k.axes[3]; + break; + } + case "left": { + g[0].x += k.axes[2], g[0].y += k.axes[3]; + break; + } + case "right": { + g[1].x += k.axes[2], g[1].y += k.axes[3]; + break; + } + } + } + for (const h of g) + h.x = Math.abs(h.x) >= this.stickThreshold ? h.x : 0, h.y = Math.abs(h.y) >= this.stickThreshold ? h.y : 0; + const D = new G.Vector3( + g[1].x, + g[1].y, + 0 + ).multiplyScalar(this.rotateSpeed); + for (const [h, k] of Object.entries(this.keycodeRotateMapping)) + this.keycode[h] && D.add(k); + for (const h in this.gamepadMapping) + if (C[Number.parseInt(h)]) + switch (this.gamepadMapping[h]) { + case "rollLeft": + D.z += 1; + break; + case "rollRight": + D.z -= 1; + break; + } + D.multiply( + new G.Vector3(this.rotateSpeed, this.rotateSpeed, this.rollSpeed) + ); + let i = D.length() > oI; + if (D.manhattanLength() > 0) { + D.multiplyScalar(A); + const h = new G.Euler().setFromQuaternion( + I.quaternion, + "YXZ" + ); + h.y -= D.x, h.x = Math.max( + -Math.PI / 2, + Math.min(Math.PI / 2, h.x - D.y) + ), h.z = Math.max(-Math.PI, Math.min(Math.PI, h.z + D.z)), I.quaternion.setFromEuler(h); + } + const w = new G.Vector3(g[0].x, 0, g[0].y); + w.add(this.extraMove); + for (const [h, k] of Object.entries(this.keycodeMoveMapping)) + this.keycode[h] && w.add(k); + let s = 1; + this.keydown.CapsLock && (s *= this.capsMultiplier), (this.keycode.ShiftLeft || this.keycode.ShiftRight) && (s *= this.shiftMultiplier), (this.keycode.ControlLeft || this.keycode.ControlRight) && (s *= this.ctrlMultiplier); + for (const h in this.gamepadMapping) + if (C[Number.parseInt(h)]) + switch (this.gamepadMapping[h]) { + case "shift": + s *= this.shiftMultiplier; + break; + case "ctrl": + s *= this.ctrlMultiplier; + break; + } + return w.length() > oI && (i = !0), w.applyQuaternion(I.quaternion), I.position.add( + w.multiplyScalar(this.moveSpeed * s * A) + ), i; + } +} +class nk { + constructor({ + // The HTML canvas element to attach pointer events to + canvas: A, + // Speed of rotation (default DEFAULT_ROTATE_SPEED) + rotateSpeed: I, + // Speed of sliding when dragging with right/middle mouse button or two fingers + // (default DEFAULT_SLIDE_SPEED) + slideSpeed: g, + // Speed of movement when using mouse scroll wheel (default DEFAULT_SCROLL_SPEED) + scrollSpeed: B, + // Swap the direction of rotation and sliding (default: false) + swapRotateSlide: C, + // Reverse the direction of rotation (default: false) + reverseRotate: E, + // Reverse the direction of sliding (default: false) + reverseSlide: D, + // Reverse the direction of swipe gestures (default: false) + reverseSwipe: i, + // Reverse the direction of scroll wheel movement (default: false) + reverseScroll: w, + // Inertia factor for movement (default: DEFAULT_MOVE_INERTIA) + moveInertia: s, + // Inertia factor for rotation (default: DEFAULT_ROTATE_INERTIA) + rotateInertia: o, + // Pointer rolling scale factor (default: DEFAULT_POINTER_ROLL_SCALE) + pointerRollScale: y, + // Callback for double press events (default: () => {}) + doublePress: h, + // Time delay in ms for press move to start (default: DEFAULT_PRESS_MOVE_DELAY_MS) + pressMoveDelayMs: k, + // Time in ms for press move to accelerate (default: DEFAULT_PRESS_MOVE_ACCEL_MS) + pressMoveAccelMs: R, + // Speed of movement on press (default: 0) + pressMoveSpeed: F, + // Speed of movement on double press (default: pressMoveSpeed * 5.0) + doublePressMoveSpeed: S, + // Speed of movement on triple press (default: doublePressMoveSpeed * 5.0) + triplePressMoveSpeed: a, + // Whether to move toward the screen center or finger when pressing to move (default: true) + pressMoveCenter: M + }) { + this.enable = !0, this.canvas = A, this.rotateSpeed = I ?? Rk, this.slideSpeed = g ?? kk, this.scrollSpeed = B ?? Fk, this.swapRotateSlide = C ?? !1, this.reverseRotate = E ?? ($Q() || Rg()), this.reverseSlide = D ?? !1, this.reverseSwipe = i ?? !1, this.reverseScroll = w ?? !1, this.moveInertia = s ?? ak, this.rotateInertia = o ?? Sk, this.pointerRollScale = y ?? Mk, this.doublePress = h ?? (() => { + }), this.doublePressLimitMs = Hk, this.doublePressDistance = Lk, this.pressMoveDelayMs = k ?? Jk, this.pressMoveAccelMs = R ?? Uk, this.pressMoveSpeed = F ?? 0, this.doublePressMoveSpeed = S ?? this.pressMoveSpeed * 5, this.triplePressMoveSpeed = a ?? this.doublePressMoveSpeed * 5, this.pressMoveCenter = M ?? !0, this.doublePressed = void 0, this.triplePressed = !1, this.lastUp = null, this.lastLastUp = null, this.rotating = null, this.sliding = null, this.lastDown = null, this.dualPress = !1, this.scroll = new G.Vector3(), this.rotateVelocity = new G.Vector3(), this.moveVelocity = new G.Vector3(), A.addEventListener("pointerdown", (N) => { + const U = this.getPointerPosition(N), J = U.clone(), t = U.clone(), H = !this.swapRotateSlide && !this.rotating && (N.pointerType !== "mouse" || N.button === 0) || this.swapRotateSlide && this.sliding && !this.rotating && (N.pointerType !== "mouse" || N.button === 1), { pointerId: K } = N, Y = performance.now(); + if (H) + this.rotating = { initial: J, last: t, position: U, pointerId: K, timeStamp: Y }, this.lastDown = this.rotating, A.setPointerCapture(N.pointerId), this.dualPress = !1; + else if (!this.sliding) { + const L = N.pointerType === "mouse" ? N.button : void 0; + this.sliding = { + initial: J, + last: t, + position: U, + pointerId: K, + button: L, + timeStamp: Y + }, this.lastDown = this.sliding, A.setPointerCapture(N.pointerId), this.dualPress = this.rotating != null && Y - this.rotating.timeStamp < tk; + } + if (this.lastUp) { + const L = this.lastUp.position.distanceTo(U), q = Y - this.lastUp.timeStamp; + if (L < this.doublePressDistance && q < this.doublePressLimitMs && (this.doublePressed = performance.now(), this.triplePressed = !1, this.lastLastUp)) { + const n = this.lastLastUp.position.distanceTo( + this.lastUp.position + ), r = this.lastUp.timeStamp - this.lastLastUp.timeStamp; + n < this.doublePressDistance && r < this.doublePressLimitMs && (this.triplePressed = !0); + } + } + }); + const c = (N) => { + var H, K; + ((H = this.rotating) == null ? void 0 : H.pointerId) === N.pointerId ? (this.rotating = null, A.releasePointerCapture(N.pointerId), this.dualPress && this.sliding && (A.releasePointerCapture(this.sliding.pointerId), this.sliding = null)) : ((K = this.sliding) == null ? void 0 : K.pointerId) === N.pointerId && (this.sliding = null, A.releasePointerCapture(N.pointerId), this.dualPress && this.rotating && (A.releasePointerCapture(this.rotating.pointerId), this.rotating = null)), this.doublePressed = void 0, this.triplePressed = !1; + const U = this.getPointerPosition(N), J = this.lastUp; + this.lastLastUp = this.lastUp; + const t = performance.now(); + if (this.lastUp = { position: U, timeStamp: t }, J && J.position.distanceTo(U) < this.doublePressDistance) { + const L = t - J.timeStamp; + L < this.doublePressLimitMs && this.doublePress({ position: U, intervalMs: L }); + } + }; + document.addEventListener("pointerup", c), document.addEventListener("pointercancel", c), document.addEventListener("pointermove", (N) => { + var U, J; + ((U = this.rotating) == null ? void 0 : U.pointerId) === N.pointerId ? this.rotating.position = this.getPointerPosition(N) : ((J = this.sliding) == null ? void 0 : J.pointerId) === N.pointerId && (this.sliding.position = this.getPointerPosition(N)); + }), A.addEventListener("contextmenu", (N) => { + N.preventDefault(); + }), A.addEventListener("wheel", (N) => { + this.scroll.add( + new G.Vector3(N.deltaX, N.deltaY, N.deltaZ) + ), N.preventDefault(); + }); + } + getPointerPosition(A) { + const I = this.canvas.getBoundingClientRect(); + return new G.Vector2( + A.clientX - I.left, + A.clientY - I.top + ); + } + update(A, I, g) { + var D, i; + if (!this.enable) + return !1; + const B = performance.now(); + let C = !1; + if (this.dualPress && this.rotating && this.sliding) { + const w = [ + this.rotating.position.clone().sub(this.rotating.last), + this.sliding.position.clone().sub(this.sliding.last) + ], s = w[0].dot(w[1]); + if (s >= 0.2) { + const o = w[0].clone().add(w[1]), y = new G.Vector3(o.x, -o.y, 0); + y.multiplyScalar(this.slideSpeed * (this.reverseSwipe ? 1 : -1)), y.applyQuaternion(I.quaternion), I.position.add(y), this.moveVelocity = y.clone().multiplyScalar(1 / A), y.length() > oI && (C = !0); + } else if (s <= -0.2) { + const o = this.sliding.last.clone().sub(this.rotating.last), y = o.length(); + o.multiplyScalar(1 / y).normalize(); + const h = new G.Vector2(-o.y, o.x), k = [w[0].dot(o), w[1].dot(o)], R = [w[0].dot(h), w[1].dot(h)], F = this.rotating.last.clone().add(this.sliding.last).multiplyScalar(0.5); + let S = new G.Vector3(); + const a = g ?? (I instanceof G.Camera ? I : void 0); + if (a) { + const t = new G.Vector2( + F.x / this.canvas.clientWidth * 2 - 1, + -(F.y / this.canvas.clientHeight) * 2 + 1 + ), H = new G.Raycaster(); + H.setFromCamera(t, a), S = H.ray.direction; + } + const M = k[1] - k[0], c = S.multiplyScalar(M * this.slideSpeed); + I.position.add(c), this.moveVelocity = c.clone().multiplyScalar(1 / A), c.length() > oI && (C = !0); + const N = [ + Math.atan(R[0] / (-0.5 * y)), + Math.atan(R[1] / (0.5 * y)) + ], U = 0.5 * (N[0] + N[1]) * this.pointerRollScale, J = new G.Euler().setFromQuaternion( + I.quaternion, + "YXZ" + ); + J.z = Math.max( + -Math.PI, + Math.min(Math.PI, J.z + 0.5 * U) + ), I.quaternion.setFromEuler(J), Math.abs(U) > oI && (C = !0); + } + this.rotating.last.copy(this.rotating.position), this.sliding.last.copy(this.sliding.position); + } else { + const w = new G.Vector3(); + if (this.rotating && !this.dualPress) { + const o = this.rotating.position.clone().sub(this.rotating.last); + this.rotating.last.copy(this.rotating.position), w.set(o.x, o.y, 0), w.multiplyScalar(this.rotateSpeed * (this.reverseRotate ? -1 : 1)), this.rotateVelocity = w.clone().multiplyScalar(1 / A), w.length() > oI && (C = !0); + } else + this.rotateVelocity.multiplyScalar( + Math.exp(-A / this.rotateInertia) + ), w.addScaledVector(this.rotateVelocity, A), this.rotateVelocity.length() * 0.1 > oI && (C = !0); + const s = new G.Euler().setFromQuaternion( + I.quaternion, + "YXZ" + ); + if (s.y -= w.x, s.x = Math.max( + -Math.PI / 2, + Math.min(Math.PI / 2, s.x - w.y) + ), s.z *= Math.exp(-0 * A), I.quaternion.setFromEuler(s), this.sliding && !this.dualPress) { + const o = this.sliding.position.clone().sub(this.sliding.last); + this.sliding.last.copy(this.sliding.position); + const y = this.sliding.button !== 2 ? new G.Vector3(o.x, 0, o.y) : new G.Vector3(o.x, -o.y, 0); + y.multiplyScalar(this.slideSpeed * (this.reverseSlide ? -1 : 1)), y.applyQuaternion(I.quaternion), I.position.add(y), this.moveVelocity = y.clone().multiplyScalar(1 / A), y.length() > oI && (C = !0); + } else { + const o = new G.Vector3(); + if (this.sliding || this.rotating) { + const h = ((D = this.lastDown) == null ? void 0 : D.last) ?? new G.Vector2(), k = g ?? (I instanceof G.Camera ? I : void 0); + if (k) { + const R = this.pressMoveCenter ? new G.Vector2(0, 0) : new G.Vector2( + h.x / this.canvas.clientWidth * 2 - 1, + -(h.y / this.canvas.clientHeight) * 2 + 1 + ), F = new G.Raycaster(); + F.setFromCamera(R, k), o.copy(F.ray.direction).normalize(); + } + if (this.doublePressed) { + this.pressHeld = !1; + let R = (performance.now() - this.doublePressed) / this.pressMoveAccelMs; + R = Math.max(0, Math.min(1, R)), o.multiplyScalar( + (this.triplePressed ? this.triplePressMoveSpeed : this.doublePressMoveSpeed) * R + ); + } else { + let R = 0; + this.lastDown && (R = (B - (((i = this.lastDown) == null ? void 0 : i.timeStamp) ?? B) - this.pressMoveDelayMs) / this.pressMoveAccelMs, this.lastDown.position.distanceTo(this.lastDown.initial) < this.doublePressDistance ? this.pressHeld === void 0 && R > 0 && (this.pressHeld = !0) : this.pressHeld === void 0 && (this.pressHeld = !1)), this.pressHeld ? o.multiplyScalar( + this.pressMoveSpeed * Math.max(0, Math.min(1, R)) + ) : o.set(0, 0, 0); + } + } else + this.pressHeld = void 0; + const y = Math.exp(-A / this.moveInertia); + this.moveVelocity.lerpVectors(o, this.moveVelocity, y), I.position.addScaledVector(this.moveVelocity, A), this.moveVelocity.length() * 0.1 > oI && (C = !0); + } + } + const E = this.scroll.multiplyScalar(this.scrollSpeed); + return E.set(E.x, E.z, E.y), this.reverseScroll && E.multiplyScalar(-1), E.applyQuaternion(I.quaternion), I.position.add(E), E.length() > oI && (C = !0), this.scroll.set(0, 0, 0), C; + } +} +const dk = ` +precision highp float; +precision highp int; + +#include + +uniform float near; +uniform float far; +uniform mat4 projectionMatrix; +uniform bool encodeLinear; +uniform float time; +uniform bool debugFlag; +uniform float maxStdDev; +uniform float minAlpha; +uniform bool disableFalloff; +uniform float falloff; + +uniform vec3 diskCenter; +uniform vec3 diskNormal; +uniform float diskRadius; +uniform bool diskTwoSided; + +out vec4 fragColor; + +in vec4 vRgba; +in vec2 vSplatUv; +in vec3 vNdc; +flat in uint vSplatIndex; +flat in float adjustedStdDev; + +void main() { + if (diskRadius != 0.0) { + // Portal rendering: + // - diskRadius > 0: render "behind portal" only through the disk (discard outside or in-front-of plane). + // - diskRadius < 0: render "in front of portal" everywhere, but discard fragments behind the plane when looking through the disk. + + // View ray direction from NDC (view space is -Z forward). + vec3 viewDir = normalize(vec3( + vNdc.x / projectionMatrix[0][0], + vNdc.y / projectionMatrix[1][1], + -1.0 + )); + + // Reconstruct view-space *axial* depth (-viewPos.z) from NDC Z. + float ndcZ = vNdc.z; + float depth = (2.0 * near * far) / (far + near - ndcZ * (far - near)); + // Convert axial depth to ray-parameter t (viewPos = t * viewDir). + float rayT = depth / max(1e-6, -viewDir.z); + + float radius = abs(diskRadius); + float radius2 = radius * radius; + bool renderBehind = (diskRadius > 0.0); + + vec3 diskN = normalize(diskNormal); + + // Ray-plane intersection for plane (diskCenter, diskN), with ray origin at (0,0,0). + float denom = dot(viewDir, diskN); + bool allowPortal = diskTwoSided ? (abs(denom) > 1e-6) : (denom < -1e-6); + + bool hitsDisk = false; + float t = 0.0; + if (allowPortal) { + t = dot(diskCenter, diskN) / denom; + if (t > 0.0) { + vec3 q = t * viewDir - diskCenter; + hitsDisk = (dot(q, q) <= radius2); + } + } + + // Small bias to avoid flicker at the plane. + float eps = 1e-4 * max(1.0, abs(t)); + + if (renderBehind) { + // Behind-pass: only render through the portal disk, and only behind the plane along the ray. + if (!hitsDisk) discard; + if (rayT <= t + eps) discard; + } else { + // Front-pass: render everything, except when the ray goes through the disk, discard what's behind the plane. + if (hitsDisk && (rayT >= t - eps)) discard; + } + } + + vec4 rgba = vRgba; + + float z2 = dot(vSplatUv, vSplatUv); + if (z2 > (adjustedStdDev * adjustedStdDev)) { + discard; + } + + float a = rgba.a; + float shifted = sqrt(z2) - max(0.0, a - 1.0); + float exponent = -0.5 * max(1.0, a) * sqr(max(0.0, shifted)); + rgba.a = min(1.0, a) * exp(exponent); + + if (rgba.a < minAlpha) { + discard; + } + if (encodeLinear) { + rgba.rgb = srgbToLinear(rgba.rgb); + } + + #ifdef PREMULTIPLIED_ALPHA + fragColor = vec4(rgba.rgb * rgba.a, rgba.a); + #else + fragColor = rgba; + #endif +} +`; +class BF { + constructor(A) { + this.portalPairs = [], this.lastCameraWorld = new G.Vector3().setScalar(Number.NaN), this.prefetchActive = !1, this.scratch = { + quat: new G.Quaternion(), + scale: new G.Vector3(), + center0: new G.Vector3(), + center1: new G.Vector3(), + normal0: new G.Vector3(), + normal1: new G.Vector3(), + centerT: new G.Vector3(), + normalT: new G.Vector3(), + prevCameraWorld: new G.Vector3(), + currCameraWorld: new G.Vector3(), + hit: new G.Vector3(), + offset: new G.Vector3(), + camWorld: new G.Matrix4(), + newCamWorld: new G.Matrix4(), + invCamLocal: new G.Matrix4(), + newLocalFrame: new G.Matrix4(), + cameraWorldPos: new G.Vector3(), + viewDir: new G.Vector3(), + portalCenter: new G.Vector3(), + toPortal: new G.Vector3() + }, this.renderer = A.renderer, this.scene = A.scene, this.camera = A.camera, this.localFrame = A.localFrame, this.defaultPortalRadius = A.defaultPortalRadius ?? 1, this.portalCrossEps = A.portalCrossEps ?? 1e-6; + const I = A.sparkOptions ?? {}; + this.portalRenderer = new Xg({ + renderer: this.renderer, + extraUniforms: { + diskCenter: { value: new G.Vector3() }, + diskNormal: { value: new G.Vector3() }, + diskRadius: { value: 0 }, + diskTwoSided: { value: !1 } + }, + fragmentShader: dk, + ...I + }), this.scene.add(this.portalRenderer), this.behindRenderer = new Xg({ + renderer: this.renderer, + enableDriveLod: !1, + ...I + }), this.camera2 = this.camera.clone(), this.scene.add(this.camera2); + } + /** + * Add a new portal pair to the system. + * @param options Optional configuration for this pair + * @returns The created PortalPair - position the entryPortal and exitPortal as needed + */ + addPortalPair(A) { + const I = { + entryPortal: new G.Object3D(), + exitPortal: new G.Object3D(), + radius: (A == null ? void 0 : A.radius) ?? this.defaultPortalRadius, + onCross: A == null ? void 0 : A.onCross, + _entryBefore: new G.Matrix4(), + _exitBefore: new G.Matrix4() + }; + return this.scene.add(I.entryPortal), this.scene.add(I.exitPortal), this.portalPairs.push(I), I; + } + /** + * Remove a portal pair from the system. + */ + removePortalPair(A) { + const I = this.portalPairs.indexOf(A); + I !== -1 && (this.scene.remove(A.entryPortal), this.scene.remove(A.exitPortal), this.portalPairs.splice(I, 1)); + } + /** + * Get transform from entry portal to exit portal. + */ + getEntryToExitTransform(A) { + return A.entryPortal.matrixWorld.clone().invert().premultiply(A.exitPortal.matrixWorld); + } + /** + * Get transform from exit portal to entry portal. + */ + getExitToEntryTransform(A) { + return A.exitPortal.matrixWorld.clone().invert().premultiply(A.entryPortal.matrixWorld); + } + /** Set portal disk uniforms for shader clipping */ + setPortalDiskUniforms(A, I, g, B) { + A.updateMatrixWorld(!0), I.updateMatrixWorld(!0); + const C = A.matrixWorld.clone().invert(), E = I.matrixWorld.clone().premultiply(C), D = new G.Quaternion(), i = this.portalRenderer.uniforms; + E.decompose( + i.diskCenter.value, + D, + new G.Vector3() + ), i.diskNormal.value.set(0, 0, 1).applyQuaternion(D), i.diskRadius.value = g, i.diskTwoSided.value = B; + } + /** Extract portal plane from matrix */ + getPortalPlane(A, I, g) { + A.decompose(I, this.scratch.quat, this.scratch.scale), g.set(0, 0, 1).applyQuaternion(this.scratch.quat).normalize(); + } + /** + * Detect if the user path crosses over a portal. If so, return the parametric position (0,1) + * along the segment where the crossing occurs. If not, return null. + */ + getSegmentDiskCrossing(A, I, g, B, C) { + this.getPortalPlane( + g, + this.scratch.center0, + this.scratch.normal0 + ), this.getPortalPlane( + B, + this.scratch.center1, + this.scratch.normal1 + ); + const E = this.scratch.offset.copy(A).sub(this.scratch.center0).dot(this.scratch.normal0), D = this.scratch.offset.copy(I).sub(this.scratch.center1).dot(this.scratch.normal1); + if (E > this.portalCrossEps && D > this.portalCrossEps || E < -this.portalCrossEps && D < -this.portalCrossEps) + return null; + const i = E - D; + if (Math.abs(i) < this.portalCrossEps) return null; + const w = E / i; + return w < 0 || w > 1 || (this.scratch.hit.lerpVectors(A, I, w), this.scratch.centerT.copy(this.scratch.center0).lerp(this.scratch.center1, w), this.scratch.normalT.copy(this.scratch.normal0).lerp(this.scratch.normal1, w).normalize(), this.scratch.offset.copy(this.scratch.hit).sub(this.scratch.centerT), this.scratch.offset.addScaledVector( + this.scratch.normalT, + -this.scratch.offset.dot(this.scratch.normalT) + ), this.scratch.offset.lengthSq() > C * C) ? null : w; + } + /** Teleport camera through portal */ + teleport(A) { + this.scratch.camWorld.copy(this.camera.matrixWorld), this.scratch.newCamWorld.copy(this.scratch.camWorld).premultiply(A), this.scratch.invCamLocal.copy(this.camera.matrix).invert(), this.scratch.newLocalFrame.copy(this.scratch.newCamWorld).multiply(this.scratch.invCamLocal), this.scratch.newLocalFrame.decompose( + this.localFrame.position, + this.localFrame.quaternion, + this.localFrame.scale + ), this.localFrame.updateMatrixWorld(!0), this.camera.updateMatrixWorld(!0); + } + /** + * Check for portal crossing and teleport if needed. + * Checks all portal pairs and takes the earliest crossing. + * Call this after updating controls but before render(). + */ + updateTeleportation() { + if (this.portalPairs.length === 0) return; + if (this.camera.getWorldPosition(this.scratch.currCameraWorld), !Number.isFinite(this.lastCameraWorld.x)) { + this.lastCameraWorld.copy(this.scratch.currCameraWorld); + return; + } + this.scratch.prevCameraWorld.copy(this.lastCameraWorld); + let A = null, I = null, g = !0; + for (const B of this.portalPairs) { + B.entryPortal.updateMatrixWorld(!0), B.exitPortal.updateMatrixWorld(!0), B._entryBefore.copy(B.entryPortal.matrixWorld), B._exitBefore.copy(B.exitPortal.matrixWorld); + const C = this.getSegmentDiskCrossing( + this.scratch.prevCameraWorld, + this.scratch.currCameraWorld, + B._entryBefore, + B.entryPortal.matrixWorld, + B.radius + ); + C !== null && (A === null || C < A) && (A = C, I = B, g = !0); + const E = this.getSegmentDiskCrossing( + this.scratch.prevCameraWorld, + this.scratch.currCameraWorld, + B._exitBefore, + B.exitPortal.matrixWorld, + B.radius + ); + E !== null && (A === null || E < A) && (A = E, I = B, g = !1); + } + if (I === null) { + this.lastCameraWorld.copy(this.scratch.currCameraWorld); + return; + } + g ? this.teleport(this.getEntryToExitTransform(I)) : this.teleport(this.getExitToEntryTransform(I)), this.camera.getWorldPosition(this.lastCameraWorld), I.onCross && Promise.resolve(I.onCross(I, g)).catch( + (B) => { + console.error("Error in portal onCross callback:", B); + } + ); + } + /** + * Find the most relevant portal for rendering (closest to camera view direction). + * Returns the portal pair and which portal (entry or exit) is primary. + */ + findPrimaryPortal() { + if (this.portalPairs.length === 0) return null; + this.camera.getWorldPosition(this.scratch.cameraWorldPos), this.camera.getWorldDirection(this.scratch.viewDir); + let A = Number.NEGATIVE_INFINITY, I = null, g = !0; + for (const B of this.portalPairs) { + B.entryPortal.getWorldPosition(this.scratch.portalCenter), this.scratch.toPortal.copy(this.scratch.portalCenter).sub(this.scratch.cameraWorldPos); + const C = this.scratch.toPortal.length(), E = this.scratch.toPortal.normalize().dot(this.scratch.viewDir) / C; + E > A && (A = E, I = B, g = !0), B.exitPortal.getWorldPosition(this.scratch.portalCenter), this.scratch.toPortal.copy(this.scratch.portalCenter).sub(this.scratch.cameraWorldPos); + const D = this.scratch.toPortal.length(), i = this.scratch.toPortal.normalize().dot(this.scratch.viewDir) / D; + i > A && (A = i, I = B, g = !1); + } + return I ? { + pair: I, + primaryIsEntry: g, + primaryPortal: g ? I.entryPortal : I.exitPortal, + otherPortal: g ? I.exitPortal : I.entryPortal + } : null; + } + /** + * Render the scene with portals using two-pass rendering. + * Renders the most relevant portal pair (closest to camera view). + * Call this instead of renderer.render() in your animation loop. + */ + render() { + const A = this.findPrimaryPortal(); + if (!A) { + this.prefetchActive && (this.prefetchActive = !1), this.renderer.autoClear = !0, this.renderer.render(this.scene, this.camera); + return; + } + this.prefetchActive || (this.prefetchActive = !0); + const { pair: I, primaryIsEntry: g, primaryPortal: B, otherPortal: C } = A; + (g ? this.camera.matrixWorld.clone().premultiply(this.getEntryToExitTransform(I)) : this.camera.matrixWorld.clone().premultiply(this.getExitToEntryTransform(I))).decompose( + this.camera2.position, + this.camera2.quaternion, + this.camera2.scale + ), this.camera2.updateMatrixWorld(!0), this.shareLodInstances(), this.setPortalDiskUniforms(this.camera2, C, I.radius, !0), this.renderer.autoClear = !0, this.behindRenderer.render(this.scene, this.camera2), this.setPortalDiskUniforms(this.camera, B, -I.radius, !0), this.renderer.autoClear = !1, this.portalRenderer.render(this.scene, this.camera); + } + /** + * Share lodInstances from portalRenderer to behindRenderer. + * Uses previous frame's values to ensure both passes render consistent splats. + */ + shareLodInstances() { + this.behindRenderer.lodInstances.clear(); + for (const [A, I] of this.portalRenderer.lodInstances) + this.behindRenderer.lodInstances.set(A, I); + } + /** + * Convenience hook for animation loop. + * Calls updateTeleportation() then render(). + */ + animateLoopHook() { + this.updateTeleportation(), this.render(); + } + /** Update camera2 aspect ratio on window resize */ + updateAspect(A) { + this.camera2.aspect = A, this.camera2.updateProjectionMatrix(); + } + /** Dispose of resources */ + dispose() { + this.scene.remove(this.portalRenderer), this.scene.remove(this.camera2); + for (const A of this.portalPairs) + this.scene.remove(A.entryPortal), this.scene.remove(A.exitPortal); + this.portalPairs = [], this.portalRenderer.dispose(), this.behindRenderer.dispose(); + } +} +export { + fR as DEFAULT_CONTROLLER_FAST_MULTIPLIER, + TR as DEFAULT_CONTROLLER_GETFAST, + PR as DEFAULT_CONTROLLER_GETMOVE, + uR as DEFAULT_CONTROLLER_GETROTATE, + OR as DEFAULT_CONTROLLER_GETSLOW, + jk as DEFAULT_CONTROLLER_MOVE_HEADING, + lR as DEFAULT_CONTROLLER_MOVE_SPEED, + pR as DEFAULT_CONTROLLER_ROLL_SPEED, + XB as DEFAULT_CONTROLLER_ROTATE_SPEED, + bR as DEFAULT_CONTROLLER_SLOW_MULTIPLIER, + dk as DISK_PORTAL_FRAGMENT_SHADER, + GI as ExtSplats, + AF as FINGER_TIPS, + rk as FpsMovement, + ZQ as HANDS, + Xw as Hand, + gF as HandMovement, + Vw as JOINT_IDS, + _k as JOINT_INDEX, + dg as JOINT_RADIUS, + sk as JOINT_SEGMENTS, + Gk as JOINT_SEGMENT_STEPS, + $k as JOINT_TIPS, + UB as JointEnum, + Dk as JointSplats, + fA as LN_SCALE_MAX, + pA as LN_SCALE_MIN, + zk as NUM_JOINTS, + OB as OldSparkRenderer, + jg as OldSparkViewpoint, + JQ as OldSplatAccumulator, + $A as PackedSplats, + Pg as PagedSplats, + Wg as PlyReader, + nk as PointerControls, + Ig as Readback, + TQ as RgbaArray, + jo as Sint8ToFloat, + QF as SparkControls, + BF as SparkPortals, + Xg as SparkRenderer, + jB as SparkXr, + qI as SplatAccumulator, + ag as SplatEdit, + uh as SplatEditRgbaBlendMode, + Oh as SplatEditSdf, + bh as SplatEditSdfType, + mh as SplatEdits, + hA as SplatFileType, + PI as SplatGenerator, + bw as SplatLoader, + vA as SplatMesh, + Xh as SplatModifier, + tI as SplatPager, + VB as SplatSkinning, + JR as SplatSkinningMode, + XI as SplatTransformer, + aR as SpzReader, + MI as SpzWriter, + Wo as Uint8ToFloat, + zg as XrHand, + IF as XrHands, + Ok as constructAxes, + Tk as constructGrid, + mk as constructSpherePoints, + xk as defines, + pk as dyno, + ss as flipPixels, + lg as floatToSint8, + jA as floatToUint8, + NA as fromHalf, + Xk as generators, + NB as getSplatFileType, + Vk as imageSplats, + $Q as isAndroid, + Rg as isIos, + Tg as isMobile, + AB as isOculus, + bk as isPcSogs, + os as isQuest2, + cC as isVisionPro, + vk as lerpHandsSnapshots, + Wk as modifiers, + Gs as pixelsToPngUrl, + fk as readRgbaArray, + rQ as setPackedSplat, + Zk as textSplats, + VA as toHalf, + uk as transcodeSpz, + nQ as unpackSplat, + Pk as unpackSplats, + lk as utils +}; +//# sourceMappingURL=spark.module.min.js.map diff --git a/web/js/three.core.min.js b/web/js/three.core.min.js new file mode 100644 index 0000000..05d3505 --- /dev/null +++ b/web/js/three.core.min.js @@ -0,0 +1,6 @@ +/** + * @license + * Copyright 2010-2026 Three.js Authors + * SPDX-License-Identifier: MIT + */ +const t="184",e={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2},i={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3},s=0,r=1,n=2,a=3,o=0,h=1,l=2,c=3,u=0,d=1,p=2,m=0,y=1,g=2,f=3,x=4,b=5,v=6,w=100,M=101,S=102,_=103,A=104,T=200,z=201,C=202,I=203,B=204,k=205,O=206,P=207,R=208,N=209,V=210,E=211,L=212,F=213,j=214,D=0,U=1,W=2,q=3,J=4,X=5,Y=6,H=7,Z=0,G=1,$=2,Q=0,K=1,tt=2,et=3,it=4,st=5,rt=6,nt=7,at="attached",ot="detached",ht=300,lt=301,ct=302,ut=303,dt=304,pt=306,mt=1e3,yt=1001,gt=1002,ft=1003,xt=1004,bt=1004,vt=1005,wt=1005,Mt=1006,St=1007,_t=1007,At=1008,Tt=1008,zt=1009,Ct=1010,It=1011,Bt=1012,kt=1013,Ot=1014,Pt=1015,Rt=1016,Nt=1017,Vt=1018,Et=1020,Lt=35902,Ft=35899,jt=1021,Dt=1022,Ut=1023,Wt=1026,qt=1027,Jt=1028,Xt=1029,Yt=1030,Ht=1031,Zt=1032,Gt=1033,$t=33776,Qt=33777,Kt=33778,te=33779,ee=35840,ie=35841,se=35842,re=35843,ne=36196,ae=37492,oe=37496,he=37488,le=37489,ce=37490,ue=37491,de=37808,pe=37809,me=37810,ye=37811,ge=37812,fe=37813,xe=37814,be=37815,ve=37816,we=37817,Me=37818,Se=37819,_e=37820,Ae=37821,Te=36492,ze=36494,Ce=36495,Ie=36283,Be=36284,ke=36285,Oe=36286,Pe=2200,Re=2201,Ne=2202,Ve=2300,Ee=2301,Le=2302,Fe=2303,je=2400,De=2401,Ue=2402,We=2500,qe=2501,Je=0,Xe=1,Ye=2,He=3200,Ze=3201,Ge=3202,$e=3203,Qe=0,Ke=1,ti="",ei="srgb",ii="srgb-linear",si="linear",ri="srgb",ni="",ai="rg",oi="ga",hi=0,li=7680,ci=7681,ui=7682,di=7683,pi=34055,mi=34056,yi=5386,gi=512,fi=513,xi=514,bi=515,vi=516,wi=517,Mi=518,Si=519,_i=512,Ai=513,Ti=514,zi=515,Ci=516,Ii=517,Bi=518,ki=519,Oi=35044,Pi=35048,Ri=35040,Ni=35045,Vi=35049,Ei=35041,Li=35046,Fi=35050,ji=35042,Di="100",Ui="300 es",Wi=2e3,qi=2001,Ji={COMPUTE:"compute",RENDER:"render"},Xi={PERSPECTIVE:"perspective",LINEAR:"linear",FLAT:"flat"},Yi={NORMAL:"normal",CENTROID:"centroid",SAMPLE:"sample",FIRST:"first",EITHER:"either"},Hi={TEXTURE_COMPARE:"depthTextureCompare"};const Zi={Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:Uint8ClampedArray,Int16Array:Int16Array,Uint16Array:Uint16Array,Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,Float64Array:Float64Array};function Gi(t,e){return new Zi[t](e)}function $i(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)}function Qi(t){return document.createElementNS("http://www.w3.org/1999/xhtml",t)}function Ki(){const t=Qi("canvas");return t.style.display="block",t}const ts={};let es=null;function is(t){es=t}function ss(){return es}function rs(...t){const e="THREE."+t.shift();es?es("log",e,...t):console.log(e,...t)}function ns(t){const e=t[0];if("string"==typeof e&&e.startsWith("TSL:")){const e=t[1];e&&e.isStackTrace?t[0]+=" "+e.getLocation():t[1]='Stack trace not available. Enable "THREE.Node.captureStackTrace" to capture stack traces.'}return t}function as(...t){const e="THREE."+(t=ns(t)).shift();if(es)es("warn",e,...t);else{const i=t[0];i&&i.isStackTrace?console.warn(i.getError(e)):console.warn(e,...t)}}function os(...t){const e="THREE."+(t=ns(t)).shift();if(es)es("error",e,...t);else{const i=t[0];i&&i.isStackTrace?console.error(i.getError(e)):console.error(e,...t)}}function hs(...t){const e=t.join(" ");e in ts||(ts[e]=!0,as(...t))}function ls(){return"undefined"!=typeof self&&void 0!==self.scheduler&&void 0!==self.scheduler.yield?self.scheduler.yield():new Promise(t=>{requestAnimationFrame(t)})}function cs(t,e,i){return new Promise(function(s,r){setTimeout(function n(){switch(t.clientWaitSync(e,t.SYNC_FLUSH_COMMANDS_BIT,0)){case t.WAIT_FAILED:r();break;case t.TIMEOUT_EXPIRED:setTimeout(n,i);break;default:s()}},i)})}const us={[D]:1,[W]:6,[J]:7,[q]:5,[U]:0,[Y]:2,[H]:4,[X]:3};class ds{addEventListener(t,e){void 0===this._listeners&&(this._listeners={});const i=this._listeners;void 0===i[t]&&(i[t]=[]),-1===i[t].indexOf(e)&&i[t].push(e)}hasEventListener(t,e){const i=this._listeners;return void 0!==i&&(void 0!==i[t]&&-1!==i[t].indexOf(e))}removeEventListener(t,e){const i=this._listeners;if(void 0===i)return;const s=i[t];if(void 0!==s){const t=s.indexOf(e);-1!==t&&s.splice(t,1)}}dispatchEvent(t){const e=this._listeners;if(void 0===e)return;const i=e[t.type];if(void 0!==i){t.target=this;const e=i.slice(0);for(let i=0,s=e.length;i>8&255]+ps[t>>16&255]+ps[t>>24&255]+"-"+ps[255&e]+ps[e>>8&255]+"-"+ps[e>>16&15|64]+ps[e>>24&255]+"-"+ps[63&i|128]+ps[i>>8&255]+"-"+ps[i>>16&255]+ps[i>>24&255]+ps[255&s]+ps[s>>8&255]+ps[s>>16&255]+ps[s>>24&255]).toLowerCase()}function xs(t,e,i){return Math.max(e,Math.min(i,t))}function bs(t,e){return(t%e+e)%e}function vs(t,e,i){return(1-i)*t+i*e}function ws(t,e){switch(e.constructor){case Float32Array:return t;case Uint32Array:return t/4294967295;case Uint16Array:return t/65535;case Uint8Array:return t/255;case Int32Array:return Math.max(t/2147483647,-1);case Int16Array:return Math.max(t/32767,-1);case Int8Array:return Math.max(t/127,-1);default:throw new Error("Invalid component type.")}}function Ms(t,e){switch(e.constructor){case Float32Array:return t;case Uint32Array:return Math.round(4294967295*t);case Uint16Array:return Math.round(65535*t);case Uint8Array:return Math.round(255*t);case Int32Array:return Math.round(2147483647*t);case Int16Array:return Math.round(32767*t);case Int8Array:return Math.round(127*t);default:throw new Error("Invalid component type.")}}const Ss={DEG2RAD:ys,RAD2DEG:gs,generateUUID:fs,clamp:xs,euclideanModulo:bs,mapLinear:function(t,e,i,s,r){return s+(t-e)*(r-s)/(i-e)},inverseLerp:function(t,e,i){return t!==e?(i-t)/(e-t):0},lerp:vs,damp:function(t,e,i,s){return vs(t,e,1-Math.exp(-i*s))},pingpong:function(t,e=1){return e-Math.abs(bs(t,2*e)-e)},smoothstep:function(t,e,i){return t<=e?0:t>=i?1:(t=(t-e)/(i-e))*t*(3-2*t)},smootherstep:function(t,e,i){return t<=e?0:t>=i?1:(t=(t-e)/(i-e))*t*t*(t*(6*t-15)+10)},randInt:function(t,e){return t+Math.floor(Math.random()*(e-t+1))},randFloat:function(t,e){return t+Math.random()*(e-t)},randFloatSpread:function(t){return t*(.5-Math.random())},seededRandom:function(t){void 0!==t&&(ms=t);let e=ms+=1831565813;return e=Math.imul(e^e>>>15,1|e),e^=e+Math.imul(e^e>>>7,61|e),((e^e>>>14)>>>0)/4294967296},degToRad:function(t){return t*ys},radToDeg:function(t){return t*gs},isPowerOfTwo:function(t){return!(t&t-1)&&0!==t},ceilPowerOfTwo:function(t){return Math.pow(2,Math.ceil(Math.log(t)/Math.LN2))},floorPowerOfTwo:function(t){return Math.pow(2,Math.floor(Math.log(t)/Math.LN2))},setQuaternionFromProperEuler:function(t,e,i,s,r){const n=Math.cos,a=Math.sin,o=n(i/2),h=a(i/2),l=n((e+s)/2),c=a((e+s)/2),u=n((e-s)/2),d=a((e-s)/2),p=n((s-e)/2),m=a((s-e)/2);switch(r){case"XYX":t.set(o*c,h*u,h*d,o*l);break;case"YZY":t.set(h*d,o*c,h*u,o*l);break;case"ZXZ":t.set(h*u,h*d,o*c,o*l);break;case"XZX":t.set(o*c,h*m,h*p,o*l);break;case"YXY":t.set(h*p,o*c,h*m,o*l);break;case"ZYZ":t.set(h*m,h*p,o*c,o*l);break;default:as("MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+r)}},normalize:Ms,denormalize:ws};class _s{static{_s.prototype.isVector2=!0}constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t){return this.x+=t.x,this.y+=t.y,this}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t){return this.x-=t.x,this.y-=t.y,this}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){const e=this.x,i=this.y,s=t.elements;return this.x=s[0]*e+s[3]*i+s[6],this.y=s[1]*e+s[4]*i+s[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=xs(this.x,t.x,e.x),this.y=xs(this.y,t.y,e.y),this}clampScalar(t,e){return this.x=xs(this.x,t,e),this.y=xs(this.y,t,e),this}clampLength(t,e){const i=this.length();return this.divideScalar(i||1).multiplyScalar(xs(i,t,e))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}angleTo(t){const e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;const i=this.dot(t)/e;return Math.acos(xs(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e){return this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){const i=Math.cos(e),s=Math.sin(e),r=this.x-t.x,n=this.y-t.y;return this.x=r*i-n*s+t.x,this.y=r*s+n*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}}class As{constructor(t=0,e=0,i=0,s=1){this.isQuaternion=!0,this._x=t,this._y=e,this._z=i,this._w=s}static slerpFlat(t,e,i,s,r,n,a){let o=i[s+0],h=i[s+1],l=i[s+2],c=i[s+3],u=r[n+0],d=r[n+1],p=r[n+2],m=r[n+3];if(c!==m||o!==u||h!==d||l!==p){let t=o*u+h*d+l*p+c*m;t<0&&(u=-u,d=-d,p=-p,m=-m,t=-t);let e=1-a;if(t<.9995){const i=Math.acos(t),s=Math.sin(i);e=Math.sin(e*i)/s,o=o*e+u*(a=Math.sin(a*i)/s),h=h*e+d*a,l=l*e+p*a,c=c*e+m*a}else{o=o*e+u*a,h=h*e+d*a,l=l*e+p*a,c=c*e+m*a;const t=1/Math.sqrt(o*o+h*h+l*l+c*c);o*=t,h*=t,l*=t,c*=t}}t[e]=o,t[e+1]=h,t[e+2]=l,t[e+3]=c}static multiplyQuaternionsFlat(t,e,i,s,r,n){const a=i[s],o=i[s+1],h=i[s+2],l=i[s+3],c=r[n],u=r[n+1],d=r[n+2],p=r[n+3];return t[e]=a*p+l*c+o*d-h*u,t[e+1]=o*p+l*u+h*c-a*d,t[e+2]=h*p+l*d+a*u-o*c,t[e+3]=l*p-a*c-o*u-h*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,s){return this._x=t,this._y=e,this._z=i,this._w=s,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e=!0){const i=t._x,s=t._y,r=t._z,n=t._order,a=Math.cos,o=Math.sin,h=a(i/2),l=a(s/2),c=a(r/2),u=o(i/2),d=o(s/2),p=o(r/2);switch(n){case"XYZ":this._x=u*l*c+h*d*p,this._y=h*d*c-u*l*p,this._z=h*l*p+u*d*c,this._w=h*l*c-u*d*p;break;case"YXZ":this._x=u*l*c+h*d*p,this._y=h*d*c-u*l*p,this._z=h*l*p-u*d*c,this._w=h*l*c+u*d*p;break;case"ZXY":this._x=u*l*c-h*d*p,this._y=h*d*c+u*l*p,this._z=h*l*p+u*d*c,this._w=h*l*c-u*d*p;break;case"ZYX":this._x=u*l*c-h*d*p,this._y=h*d*c+u*l*p,this._z=h*l*p-u*d*c,this._w=h*l*c+u*d*p;break;case"YZX":this._x=u*l*c+h*d*p,this._y=h*d*c+u*l*p,this._z=h*l*p-u*d*c,this._w=h*l*c-u*d*p;break;case"XZY":this._x=u*l*c-h*d*p,this._y=h*d*c-u*l*p,this._z=h*l*p+u*d*c,this._w=h*l*c+u*d*p;break;default:as("Quaternion: .setFromEuler() encountered an unknown order: "+n)}return!0===e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){const i=e/2,s=Math.sin(i);return this._x=t.x*s,this._y=t.y*s,this._z=t.z*s,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){const e=t.elements,i=e[0],s=e[4],r=e[8],n=e[1],a=e[5],o=e[9],h=e[2],l=e[6],c=e[10],u=i+a+c;if(u>0){const t=.5/Math.sqrt(u+1);this._w=.25/t,this._x=(l-o)*t,this._y=(r-h)*t,this._z=(n-s)*t}else if(i>a&&i>c){const t=2*Math.sqrt(1+i-a-c);this._w=(l-o)/t,this._x=.25*t,this._y=(s+n)/t,this._z=(r+h)/t}else if(a>c){const t=2*Math.sqrt(1+a-i-c);this._w=(r-h)/t,this._x=(s+n)/t,this._y=.25*t,this._z=(o+l)/t}else{const t=2*Math.sqrt(1+c-i-a);this._w=(n-s)/t,this._x=(r+h)/t,this._y=(o+l)/t,this._z=.25*t}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<1e-8?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(xs(this.dot(t),-1,1)))}rotateTowards(t,e){const i=this.angleTo(t);if(0===i)return this;const s=Math.min(1,e/i);return this.slerp(t,s),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t){return this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){const i=t._x,s=t._y,r=t._z,n=t._w,a=e._x,o=e._y,h=e._z,l=e._w;return this._x=i*l+n*a+s*h-r*o,this._y=s*l+n*o+r*a-i*h,this._z=r*l+n*h+i*o-s*a,this._w=n*l-i*a-s*o-r*h,this._onChangeCallback(),this}slerp(t,e){let i=t._x,s=t._y,r=t._z,n=t._w,a=this.dot(t);a<0&&(i=-i,s=-s,r=-r,n=-n,a=-a);let o=1-e;if(a<.9995){const t=Math.acos(a),h=Math.sin(t);o=Math.sin(o*t)/h,e=Math.sin(e*t)/h,this._x=this._x*o+i*e,this._y=this._y*o+s*e,this._z=this._z*o+r*e,this._w=this._w*o+n*e,this._onChangeCallback()}else this._x=this._x*o+i*e,this._y=this._y*o+s*e,this._z=this._z*o+r*e,this._w=this._w*o+n*e,this.normalize();return this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){const t=2*Math.PI*Math.random(),e=2*Math.PI*Math.random(),i=Math.random(),s=Math.sqrt(1-i),r=Math.sqrt(i);return this.set(s*Math.sin(t),s*Math.cos(t),r*Math.sin(e),r*Math.cos(e))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this._onChangeCallback(),this}toJSON(){return this.toArray()}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}*[Symbol.iterator](){yield this._x,yield this._y,yield this._z,yield this._w}}class Ts{static{Ts.prototype.isVector3=!0}constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return void 0===i&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t){return this.x+=t.x,this.y+=t.y,this.z+=t.z,this}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t){return this.x-=t.x,this.y-=t.y,this.z-=t.z,this}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return this.applyQuaternion(Cs.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(Cs.setFromAxisAngle(t,e))}applyMatrix3(t){const e=this.x,i=this.y,s=this.z,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6]*s,this.y=r[1]*e+r[4]*i+r[7]*s,this.z=r[2]*e+r[5]*i+r[8]*s,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){const e=this.x,i=this.y,s=this.z,r=t.elements,n=1/(r[3]*e+r[7]*i+r[11]*s+r[15]);return this.x=(r[0]*e+r[4]*i+r[8]*s+r[12])*n,this.y=(r[1]*e+r[5]*i+r[9]*s+r[13])*n,this.z=(r[2]*e+r[6]*i+r[10]*s+r[14])*n,this}applyQuaternion(t){const e=this.x,i=this.y,s=this.z,r=t.x,n=t.y,a=t.z,o=t.w,h=2*(n*s-a*i),l=2*(a*e-r*s),c=2*(r*i-n*e);return this.x=e+o*h+n*c-a*l,this.y=i+o*l+a*h-r*c,this.z=s+o*c+r*l-n*h,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){const e=this.x,i=this.y,s=this.z,r=t.elements;return this.x=r[0]*e+r[4]*i+r[8]*s,this.y=r[1]*e+r[5]*i+r[9]*s,this.z=r[2]*e+r[6]*i+r[10]*s,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=xs(this.x,t.x,e.x),this.y=xs(this.y,t.y,e.y),this.z=xs(this.z,t.z,e.z),this}clampScalar(t,e){return this.x=xs(this.x,t,e),this.y=xs(this.y,t,e),this.z=xs(this.z,t,e),this}clampLength(t,e){const i=this.length();return this.divideScalar(i||1).multiplyScalar(xs(i,t,e))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this.z=Math.trunc(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t){return this.crossVectors(this,t)}crossVectors(t,e){const i=t.x,s=t.y,r=t.z,n=e.x,a=e.y,o=e.z;return this.x=s*o-r*a,this.y=r*n-i*o,this.z=i*a-s*n,this}projectOnVector(t){const e=t.lengthSq();if(0===e)return this.set(0,0,0);const i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return zs.copy(this).projectOnVector(t),this.sub(zs)}reflect(t){return this.sub(zs.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){const e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;const i=this.dot(t)/e;return Math.acos(xs(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,i=this.y-t.y,s=this.z-t.z;return e*e+i*i+s*s}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){const s=Math.sin(e)*t;return this.x=s*Math.sin(i),this.y=Math.cos(e)*t,this.z=s*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){const e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){const e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),s=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=s,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}setFromEuler(t){return this.x=t._x,this.y=t._y,this.z=t._z,this}setFromColor(t){return this.x=t.r,this.y=t.g,this.z=t.b,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e){return this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){const t=Math.random()*Math.PI*2,e=2*Math.random()-1,i=Math.sqrt(1-e*e);return this.x=i*Math.cos(t),this.y=e,this.z=i*Math.sin(t),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}}const zs=new Ts,Cs=new As;class Is{static{Is.prototype.isMatrix3=!0}constructor(t,e,i,s,r,n,a,o,h){this.elements=[1,0,0,0,1,0,0,0,1],void 0!==t&&this.set(t,e,i,s,r,n,a,o,h)}set(t,e,i,s,r,n,a,o,h){const l=this.elements;return l[0]=t,l[1]=s,l[2]=a,l[3]=e,l[4]=r,l[5]=o,l[6]=i,l[7]=n,l[8]=h,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){const e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){const e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const i=t.elements,s=e.elements,r=this.elements,n=i[0],a=i[3],o=i[6],h=i[1],l=i[4],c=i[7],u=i[2],d=i[5],p=i[8],m=s[0],y=s[3],g=s[6],f=s[1],x=s[4],b=s[7],v=s[2],w=s[5],M=s[8];return r[0]=n*m+a*f+o*v,r[3]=n*y+a*x+o*w,r[6]=n*g+a*b+o*M,r[1]=h*m+l*f+c*v,r[4]=h*y+l*x+c*w,r[7]=h*g+l*b+c*M,r[2]=u*m+d*f+p*v,r[5]=u*y+d*x+p*w,r[8]=u*g+d*b+p*M,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){const t=this.elements,e=t[0],i=t[1],s=t[2],r=t[3],n=t[4],a=t[5],o=t[6],h=t[7],l=t[8];return e*n*l-e*a*h-i*r*l+i*a*o+s*r*h-s*n*o}invert(){const t=this.elements,e=t[0],i=t[1],s=t[2],r=t[3],n=t[4],a=t[5],o=t[6],h=t[7],l=t[8],c=l*n-a*h,u=a*o-l*r,d=h*r-n*o,p=e*c+i*u+s*d;if(0===p)return this.set(0,0,0,0,0,0,0,0,0);const m=1/p;return t[0]=c*m,t[1]=(s*h-l*i)*m,t[2]=(a*i-s*n)*m,t[3]=u*m,t[4]=(l*e-s*o)*m,t[5]=(s*r-a*e)*m,t[6]=d*m,t[7]=(i*o-h*e)*m,t[8]=(n*e-i*r)*m,this}transpose(){let t;const e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){const e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,s,r,n,a){const o=Math.cos(r),h=Math.sin(r);return this.set(i*o,i*h,-i*(o*n+h*a)+n+t,-s*h,s*o,-s*(-h*n+o*a)+a+e,0,0,1),this}scale(t,e){return this.premultiply(Bs.makeScale(t,e)),this}rotate(t){return this.premultiply(Bs.makeRotation(-t)),this}translate(t,e){return this.premultiply(Bs.makeTranslation(t,e)),this}makeTranslation(t,e){return t.isVector2?this.set(1,0,t.x,0,1,t.y,0,0,1):this.set(1,0,t,0,1,e,0,0,1),this}makeRotation(t){const e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,i,e,0,0,0,1),this}makeScale(t,e){return this.set(t,0,0,0,e,0,0,0,1),this}equals(t){const e=this.elements,i=t.elements;for(let t=0;t<9;t++)if(e[t]!==i[t])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){const i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return(new this.constructor).fromArray(this.elements)}}const Bs=new Is,ks=(new Is).set(.4123908,.3575843,.1804808,.212639,.7151687,.0721923,.0193308,.1191948,.9505322),Os=(new Is).set(3.2409699,-1.5373832,-.4986108,-.9692436,1.8759675,.0415551,.0556301,-.203977,1.0569715);function Ps(){const t={enabled:!0,workingColorSpace:ii,spaces:{},convert:function(t,e,i){return!1!==this.enabled&&e!==i&&e&&i?(this.spaces[e].transfer===ri&&(t.r=Ns(t.r),t.g=Ns(t.g),t.b=Ns(t.b)),this.spaces[e].primaries!==this.spaces[i].primaries&&(t.applyMatrix3(this.spaces[e].toXYZ),t.applyMatrix3(this.spaces[i].fromXYZ)),this.spaces[i].transfer===ri&&(t.r=Vs(t.r),t.g=Vs(t.g),t.b=Vs(t.b)),t):t},workingToColorSpace:function(t,e){return this.convert(t,this.workingColorSpace,e)},colorSpaceToWorking:function(t,e){return this.convert(t,e,this.workingColorSpace)},getPrimaries:function(t){return this.spaces[t].primaries},getTransfer:function(t){return""===t?si:this.spaces[t].transfer},getToneMappingMode:function(t){return this.spaces[t].outputColorSpaceConfig.toneMappingMode||"standard"},getLuminanceCoefficients:function(t,e=this.workingColorSpace){return t.fromArray(this.spaces[e].luminanceCoefficients)},define:function(t){Object.assign(this.spaces,t)},_getMatrix:function(t,e,i){return t.copy(this.spaces[e].toXYZ).multiply(this.spaces[i].fromXYZ)},_getDrawingBufferColorSpace:function(t){return this.spaces[t].outputColorSpaceConfig.drawingBufferColorSpace},_getUnpackColorSpace:function(t=this.workingColorSpace){return this.spaces[t].workingColorSpaceConfig.unpackColorSpace},fromWorkingColorSpace:function(e,i){return hs("ColorManagement: .fromWorkingColorSpace() has been renamed to .workingToColorSpace()."),t.workingToColorSpace(e,i)},toWorkingColorSpace:function(e,i){return hs("ColorManagement: .toWorkingColorSpace() has been renamed to .colorSpaceToWorking()."),t.colorSpaceToWorking(e,i)}},e=[.64,.33,.3,.6,.15,.06],i=[.2126,.7152,.0722],s=[.3127,.329];return t.define({[ii]:{primaries:e,whitePoint:s,transfer:si,toXYZ:ks,fromXYZ:Os,luminanceCoefficients:i,workingColorSpaceConfig:{unpackColorSpace:ei},outputColorSpaceConfig:{drawingBufferColorSpace:ei}},[ei]:{primaries:e,whitePoint:s,transfer:ri,toXYZ:ks,fromXYZ:Os,luminanceCoefficients:i,outputColorSpaceConfig:{drawingBufferColorSpace:ei}}}),t}const Rs=Ps();function Ns(t){return t<.04045?.0773993808*t:Math.pow(.9478672986*t+.0521327014,2.4)}function Vs(t){return t<.0031308?12.92*t:1.055*Math.pow(t,.41666)-.055}let Es;class Ls{static getDataURL(t,e="image/png"){if(/^data:/i.test(t.src))return t.src;if("undefined"==typeof HTMLCanvasElement)return t.src;let i;if(t instanceof HTMLCanvasElement)i=t;else{void 0===Es&&(Es=Qi("canvas")),Es.width=t.width,Es.height=t.height;const e=Es.getContext("2d");t instanceof ImageData?e.putImageData(t,0,0):e.drawImage(t,0,0,t.width,t.height),i=Es}return i.toDataURL(e)}static sRGBToLinear(t){if("undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap){const e=Qi("canvas");e.width=t.width,e.height=t.height;const i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);const s=i.getImageData(0,0,t.width,t.height),r=s.data;for(let t=0;t1),this.pmremVersion=0,this.normalized=!1}get width(){return this.source.getSize(Ws).x}get height(){return this.source.getSize(Ws).y}get depth(){return this.source.getSize(Ws).z}get image(){return this.source.data}set image(t){this.source.data=t}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}addUpdateRange(t,e){this.updateRanges.push({start:t,count:e})}clearUpdateRanges(){this.updateRanges.length=0}clone(){return(new this.constructor).copy(this)}copy(t){return this.name=t.name,this.source=t.source,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.channel=t.channel,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.normalized=t.normalized,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.colorSpace=t.colorSpace,this.renderTarget=t.renderTarget,this.isRenderTargetTexture=t.isRenderTargetTexture,this.isArrayTexture=t.isArrayTexture,this.userData=JSON.parse(JSON.stringify(t.userData)),this.needsUpdate=!0,this}setValues(t){for(const e in t){const i=t[e];if(void 0===i){as(`Texture.setValues(): parameter '${e}' has value of undefined.`);continue}const s=this[e];void 0!==s?s&&i&&s.isVector2&&i.isVector2||s&&i&&s.isVector3&&i.isVector3||s&&i&&s.isMatrix3&&i.isMatrix3?s.copy(i):this[e]=i:as(`Texture.setValues(): property '${e}' does not exist.`)}}toJSON(t){const e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];const i={metadata:{version:4.7,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,image:this.source.toJSON(t).uuid,mapping:this.mapping,channel:this.channel,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,internalFormat:this.internalFormat,type:this.type,normalized:this.normalized,colorSpace:this.colorSpace,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,generateMipmaps:this.generateMipmaps,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};return Object.keys(this.userData).length>0&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==ht)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case mt:t.x=t.x-Math.floor(t.x);break;case yt:t.x=t.x<0?0:1;break;case gt:1===Math.abs(Math.floor(t.x)%2)?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case mt:t.y=t.y-Math.floor(t.y);break;case yt:t.y=t.y<0?0:1;break;case gt:1===Math.abs(Math.floor(t.y)%2)?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&(this.version++,this.source.needsUpdate=!0)}set needsPMREMUpdate(t){!0===t&&this.pmremVersion++}}qs.DEFAULT_IMAGE=null,qs.DEFAULT_MAPPING=ht,qs.DEFAULT_ANISOTROPY=1;class Js{static{Js.prototype.isVector4=!0}constructor(t=0,e=0,i=0,s=1){this.x=t,this.y=e,this.z=i,this.w=s}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,s){return this.x=t,this.y=e,this.z=i,this.w=s,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t){return this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t){return this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){const e=this.x,i=this.y,s=this.z,r=this.w,n=t.elements;return this.x=n[0]*e+n[4]*i+n[8]*s+n[12]*r,this.y=n[1]*e+n[5]*i+n[9]*s+n[13]*r,this.z=n[2]*e+n[6]*i+n[10]*s+n[14]*r,this.w=n[3]*e+n[7]*i+n[11]*s+n[15]*r,this}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this.w/=t.w,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);const e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,s,r;const n=.01,a=.1,o=t.elements,h=o[0],l=o[4],c=o[8],u=o[1],d=o[5],p=o[9],m=o[2],y=o[6],g=o[10];if(Math.abs(l-u)o&&t>f?tf?o1);this.dispose()}this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return(new this.constructor).copy(this)}copy(t){this.width=t.width,this.height=t.height,this.depth=t.depth,this.scissor.copy(t.scissor),this.scissorTest=t.scissorTest,this.viewport.copy(t.viewport),this.textures.length=0;for(let e=0,i=t.textures.length;e>>0}enable(t){this.mask|=1<1){for(let t=0;t1){for(let t=0;t0&&(s.userData=this.userData),s.layers=this.layers.mask,s.matrix=this.matrix.toArray(),s.up=this.up.toArray(),null!==this.pivot&&(s.pivot=this.pivot.toArray()),!1===this.matrixAutoUpdate&&(s.matrixAutoUpdate=!1),void 0!==this.morphTargetDictionary&&(s.morphTargetDictionary=Object.assign({},this.morphTargetDictionary)),void 0!==this.morphTargetInfluences&&(s.morphTargetInfluences=this.morphTargetInfluences.slice()),this.isInstancedMesh&&(s.type="InstancedMesh",s.count=this.count,s.instanceMatrix=this.instanceMatrix.toJSON(),null!==this.instanceColor&&(s.instanceColor=this.instanceColor.toJSON())),this.isBatchedMesh&&(s.type="BatchedMesh",s.perObjectFrustumCulled=this.perObjectFrustumCulled,s.sortObjects=this.sortObjects,s.drawRanges=this._drawRanges,s.reservedRanges=this._reservedRanges,s.geometryInfo=this._geometryInfo.map(t=>({...t,boundingBox:t.boundingBox?t.boundingBox.toJSON():void 0,boundingSphere:t.boundingSphere?t.boundingSphere.toJSON():void 0})),s.instanceInfo=this._instanceInfo.map(t=>({...t})),s.availableInstanceIds=this._availableInstanceIds.slice(),s.availableGeometryIds=this._availableGeometryIds.slice(),s.nextIndexStart=this._nextIndexStart,s.nextVertexStart=this._nextVertexStart,s.geometryCount=this._geometryCount,s.maxInstanceCount=this._maxInstanceCount,s.maxVertexCount=this._maxVertexCount,s.maxIndexCount=this._maxIndexCount,s.geometryInitialized=this._geometryInitialized,s.matricesTexture=this._matricesTexture.toJSON(t),s.indirectTexture=this._indirectTexture.toJSON(t),null!==this._colorsTexture&&(s.colorsTexture=this._colorsTexture.toJSON(t)),null!==this.boundingSphere&&(s.boundingSphere=this.boundingSphere.toJSON()),null!==this.boundingBox&&(s.boundingBox=this.boundingBox.toJSON())),this.isScene)this.background&&(this.background.isColor?s.background=this.background.toJSON():this.background.isTexture&&(s.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&!0!==this.environment.isRenderTargetTexture&&(s.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){s.geometry=r(t.geometries,this.geometry);const e=this.geometry.parameters;if(void 0!==e&&void 0!==e.shapes){const i=e.shapes;if(Array.isArray(i))for(let e=0,s=i.length;e0){s.children=[];for(let e=0;e0){s.animations=[];for(let e=0;e0&&(i.geometries=e),s.length>0&&(i.materials=s),r.length>0&&(i.textures=r),a.length>0&&(i.images=a),o.length>0&&(i.shapes=o),h.length>0&&(i.skeletons=h),l.length>0&&(i.animations=l),c.length>0&&(i.nodes=c)}return i.object=s,i;function n(t){const e=[];for(const i in t){const s=t[i];delete s.metadata,e.push(s)}return e}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.pivot=null!==t.pivot?t.pivot.clone():null,this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldAutoUpdate=t.matrixWorldAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.static=t.static,this.animations=t.animations.slice(),this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let e=0;eo+l?(h.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!h.inputState.pinching&&a<=o-l&&(h.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==o&&t.gripSpace&&(r=e.getPose(t.gripSpace,i),null!==r&&(o.matrix.fromArray(r.transform.matrix),o.matrix.decompose(o.position,o.rotation,o.scale),o.matrixWorldNeedsUpdate=!0,r.linearVelocity?(o.hasLinearVelocity=!0,o.linearVelocity.copy(r.linearVelocity)):o.hasLinearVelocity=!1,r.angularVelocity?(o.hasAngularVelocity=!0,o.angularVelocity.copy(r.angularVelocity)):o.hasAngularVelocity=!1,o.eventsEnabled&&o.dispatchEvent({type:"gripUpdated",data:t,target:this})));null!==a&&(s=e.getPose(t.targetRaySpace,i),null===s&&null!==r&&(s=r),null!==s&&(a.matrix.fromArray(s.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),a.matrixWorldNeedsUpdate=!0,s.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(s.linearVelocity)):a.hasLinearVelocity=!1,s.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(s.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(zr)))}return null!==a&&(a.visible=null!==s),null!==o&&(o.visible=null!==r),null!==h&&(h.visible=null!==n),this}_getHandJoint(t,e){if(void 0===t.joints[e.jointName]){const i=new Tr;i.matrixAutoUpdate=!1,i.visible=!1,t.joints[e.jointName]=i,t.add(i)}return t.joints[e.jointName]}}const Ir={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},Br={h:0,s:0,l:0},kr={h:0,s:0,l:0};function Or(t,e,i){return i<0&&(i+=1),i>1&&(i-=1),i<1/6?t+6*(e-t)*i:i<.5?e:i<2/3?t+6*(e-t)*(2/3-i):t}class Pr{constructor(t,e,i){return this.isColor=!0,this.r=1,this.g=1,this.b=1,this.set(t,e,i)}set(t,e,i){if(void 0===e&&void 0===i){const e=t;e&&e.isColor?this.copy(e):"number"==typeof e?this.setHex(e):"string"==typeof e&&this.setStyle(e)}else this.setRGB(t,e,i);return this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t,e=ei){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(255&t)/255,Rs.colorSpaceToWorking(this,e),this}setRGB(t,e,i,s=Rs.workingColorSpace){return this.r=t,this.g=e,this.b=i,Rs.colorSpaceToWorking(this,s),this}setHSL(t,e,i,s=Rs.workingColorSpace){if(t=bs(t,1),e=xs(e,0,1),i=xs(i,0,1),0===e)this.r=this.g=this.b=i;else{const s=i<=.5?i*(1+e):i+e-i*e,r=2*i-s;this.r=Or(r,s,t+1/3),this.g=Or(r,s,t),this.b=Or(r,s,t-1/3)}return Rs.colorSpaceToWorking(this,s),this}setStyle(t,e=ei){function i(e){void 0!==e&&parseFloat(e)<1&&as("Color: Alpha component of "+t+" will be ignored.")}let s;if(s=/^(\w+)\(([^\)]*)\)/.exec(t)){let r;const n=s[1],a=s[2];switch(n){case"rgb":case"rgba":if(r=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return i(r[4]),this.setRGB(Math.min(255,parseInt(r[1],10))/255,Math.min(255,parseInt(r[2],10))/255,Math.min(255,parseInt(r[3],10))/255,e);if(r=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return i(r[4]),this.setRGB(Math.min(100,parseInt(r[1],10))/100,Math.min(100,parseInt(r[2],10))/100,Math.min(100,parseInt(r[3],10))/100,e);break;case"hsl":case"hsla":if(r=/^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return i(r[4]),this.setHSL(parseFloat(r[1])/360,parseFloat(r[2])/100,parseFloat(r[3])/100,e);break;default:as("Color: Unknown color model "+t)}}else if(s=/^\#([A-Fa-f\d]+)$/.exec(t)){const i=s[1],r=i.length;if(3===r)return this.setRGB(parseInt(i.charAt(0),16)/15,parseInt(i.charAt(1),16)/15,parseInt(i.charAt(2),16)/15,e);if(6===r)return this.setHex(parseInt(i,16),e);as("Color: Invalid hex color "+t)}else if(t&&t.length>0)return this.setColorName(t,e);return this}setColorName(t,e=ei){const i=Ir[t.toLowerCase()];return void 0!==i?this.setHex(i,e):as("Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=Ns(t.r),this.g=Ns(t.g),this.b=Ns(t.b),this}copyLinearToSRGB(t){return this.r=Vs(t.r),this.g=Vs(t.g),this.b=Vs(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(t=ei){return Rs.workingToColorSpace(Rr.copy(this),t),65536*Math.round(xs(255*Rr.r,0,255))+256*Math.round(xs(255*Rr.g,0,255))+Math.round(xs(255*Rr.b,0,255))}getHexString(t=ei){return("000000"+this.getHex(t).toString(16)).slice(-6)}getHSL(t,e=Rs.workingColorSpace){Rs.workingToColorSpace(Rr.copy(this),e);const i=Rr.r,s=Rr.g,r=Rr.b,n=Math.max(i,s,r),a=Math.min(i,s,r);let o,h;const l=(a+n)/2;if(a===n)o=0,h=0;else{const t=n-a;switch(h=l<=.5?t/(n+a):t/(2-n-a),n){case i:o=(s-r)/t+(s0&&(e.object.backgroundBlurriness=this.backgroundBlurriness),1!==this.backgroundIntensity&&(e.object.backgroundIntensity=this.backgroundIntensity),e.object.backgroundRotation=this.backgroundRotation.toArray(),1!==this.environmentIntensity&&(e.object.environmentIntensity=this.environmentIntensity),e.object.environmentRotation=this.environmentRotation.toArray(),e}}const Lr=new Ts,Fr=new Ts,jr=new Ts,Dr=new Ts,Ur=new Ts,Wr=new Ts,qr=new Ts,Jr=new Ts,Xr=new Ts,Yr=new Ts,Hr=new Js,Zr=new Js,Gr=new Js;class $r{constructor(t=new Ts,e=new Ts,i=new Ts){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,s){s.subVectors(i,e),Lr.subVectors(t,e),s.cross(Lr);const r=s.lengthSq();return r>0?s.multiplyScalar(1/Math.sqrt(r)):s.set(0,0,0)}static getBarycoord(t,e,i,s,r){Lr.subVectors(s,e),Fr.subVectors(i,e),jr.subVectors(t,e);const n=Lr.dot(Lr),a=Lr.dot(Fr),o=Lr.dot(jr),h=Fr.dot(Fr),l=Fr.dot(jr),c=n*h-a*a;if(0===c)return r.set(0,0,0),null;const u=1/c,d=(h*o-a*l)*u,p=(n*l-a*o)*u;return r.set(1-d-p,p,d)}static containsPoint(t,e,i,s){return null!==this.getBarycoord(t,e,i,s,Dr)&&(Dr.x>=0&&Dr.y>=0&&Dr.x+Dr.y<=1)}static getInterpolation(t,e,i,s,r,n,a,o){return null===this.getBarycoord(t,e,i,s,Dr)?(o.x=0,o.y=0,"z"in o&&(o.z=0),"w"in o&&(o.w=0),null):(o.setScalar(0),o.addScaledVector(r,Dr.x),o.addScaledVector(n,Dr.y),o.addScaledVector(a,Dr.z),o)}static getInterpolatedAttribute(t,e,i,s,r,n){return Hr.setScalar(0),Zr.setScalar(0),Gr.setScalar(0),Hr.fromBufferAttribute(t,e),Zr.fromBufferAttribute(t,i),Gr.fromBufferAttribute(t,s),n.setScalar(0),n.addScaledVector(Hr,r.x),n.addScaledVector(Zr,r.y),n.addScaledVector(Gr,r.z),n}static isFrontFacing(t,e,i,s){return Lr.subVectors(i,e),Fr.subVectors(t,e),Lr.cross(Fr).dot(s)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,s){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[s]),this}setFromAttributeAndIndices(t,e,i,s){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,s),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Lr.subVectors(this.c,this.b),Fr.subVectors(this.a,this.b),.5*Lr.cross(Fr).length()}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return $r.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return $r.getBarycoord(t,this.a,this.b,this.c,e)}getInterpolation(t,e,i,s,r){return $r.getInterpolation(t,this.a,this.b,this.c,e,i,s,r)}containsPoint(t){return $r.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return $r.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){const i=this.a,s=this.b,r=this.c;let n,a;Ur.subVectors(s,i),Wr.subVectors(r,i),Jr.subVectors(t,i);const o=Ur.dot(Jr),h=Wr.dot(Jr);if(o<=0&&h<=0)return e.copy(i);Xr.subVectors(t,s);const l=Ur.dot(Xr),c=Wr.dot(Xr);if(l>=0&&c<=l)return e.copy(s);const u=o*c-l*h;if(u<=0&&o>=0&&l<=0)return n=o/(o-l),e.copy(i).addScaledVector(Ur,n);Yr.subVectors(t,r);const d=Ur.dot(Yr),p=Wr.dot(Yr);if(p>=0&&d<=p)return e.copy(r);const m=d*h-o*p;if(m<=0&&h>=0&&p<=0)return a=h/(h-p),e.copy(i).addScaledVector(Wr,a);const y=l*p-d*c;if(y<=0&&c-l>=0&&d-p>=0)return qr.subVectors(r,s),a=(c-l)/(c-l+(d-p)),e.copy(s).addScaledVector(qr,a);const g=1/(y+m+u);return n=m*g,a=u*g,e.copy(i).addScaledVector(Ur,n).addScaledVector(Wr,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}}class Qr{constructor(t=new Ts(1/0,1/0,1/0),e=new Ts(-1/0,-1/0,-1/0)){this.isBox3=!0,this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){this.makeEmpty();for(let e=0,i=t.length;e=this.min.x&&t.x<=this.max.x&&t.y>=this.min.y&&t.y<=this.max.y&&t.z>=this.min.z&&t.z<=this.max.z}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return t.max.x>=this.min.x&&t.min.x<=this.max.x&&t.max.y>=this.min.y&&t.min.y<=this.max.y&&t.max.z>=this.min.z&&t.min.z<=this.max.z}intersectsSphere(t){return this.clampPoint(t.center,tn),tn.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ln),cn.subVectors(this.max,ln),sn.subVectors(t.a,ln),rn.subVectors(t.b,ln),nn.subVectors(t.c,ln),an.subVectors(rn,sn),on.subVectors(nn,rn),hn.subVectors(sn,nn);let e=[0,-an.z,an.y,0,-on.z,on.y,0,-hn.z,hn.y,an.z,0,-an.x,on.z,0,-on.x,hn.z,0,-hn.x,-an.y,an.x,0,-on.y,on.x,0,-hn.y,hn.x,0];return!!pn(e,sn,rn,nn,cn)&&(e=[1,0,0,0,1,0,0,0,1],!!pn(e,sn,rn,nn,cn)&&(un.crossVectors(an,on),e=[un.x,un.y,un.z],pn(e,sn,rn,nn,cn)))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return this.clampPoint(t,tn).distanceTo(t)}getBoundingSphere(t){return this.isEmpty()?t.makeEmpty():(this.getCenter(t.center),t.radius=.5*this.getSize(tn).length()),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(Kr[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Kr[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Kr[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Kr[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Kr[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Kr[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Kr[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Kr[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Kr)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}toJSON(){return{min:this.min.toArray(),max:this.max.toArray()}}fromJSON(t){return this.min.fromArray(t.min),this.max.fromArray(t.max),this}}const Kr=[new Ts,new Ts,new Ts,new Ts,new Ts,new Ts,new Ts,new Ts],tn=new Ts,en=new Qr,sn=new Ts,rn=new Ts,nn=new Ts,an=new Ts,on=new Ts,hn=new Ts,ln=new Ts,cn=new Ts,un=new Ts,dn=new Ts;function pn(t,e,i,s,r){for(let n=0,a=t.length-3;n<=a;n+=3){dn.fromArray(t,n);const a=r.x*Math.abs(dn.x)+r.y*Math.abs(dn.y)+r.z*Math.abs(dn.z),o=e.dot(dn),h=i.dot(dn),l=s.dot(dn);if(Math.max(-Math.max(o,h,l),Math.min(o,h,l))>a)return!1}return!0}const mn=yn();function yn(){const t=new ArrayBuffer(4),e=new Float32Array(t),i=new Uint32Array(t),s=new Uint32Array(512),r=new Uint32Array(512);for(let t=0;t<256;++t){const e=t-127;e<-27?(s[t]=0,s[256|t]=32768,r[t]=24,r[256|t]=24):e<-14?(s[t]=1024>>-e-14,s[256|t]=1024>>-e-14|32768,r[t]=-e-1,r[256|t]=-e-1):e<=15?(s[t]=e+15<<10,s[256|t]=e+15<<10|32768,r[t]=13,r[256|t]=13):e<128?(s[t]=31744,s[256|t]=64512,r[t]=24,r[256|t]=24):(s[t]=31744,s[256|t]=64512,r[t]=13,r[256|t]=13)}const n=new Uint32Array(2048),a=new Uint32Array(64),o=new Uint32Array(64);for(let t=1;t<1024;++t){let e=t<<13,i=0;for(;!(8388608&e);)e<<=1,i-=8388608;e&=-8388609,i+=947912704,n[t]=e|i}for(let t=1024;t<2048;++t)n[t]=939524096+(t-1024<<13);for(let t=1;t<31;++t)a[t]=t<<23;a[31]=1199570944,a[32]=2147483648;for(let t=33;t<63;++t)a[t]=2147483648+(t-32<<23);a[63]=3347054592;for(let t=1;t<64;++t)32!==t&&(o[t]=1024);return{floatView:e,uint32View:i,baseTable:s,shiftTable:r,mantissaTable:n,exponentTable:a,offsetTable:o}}function gn(t){Math.abs(t)>65504&&as("DataUtils.toHalfFloat(): Value out of range."),t=xs(t,-65504,65504),mn.floatView[0]=t;const e=mn.uint32View[0],i=e>>23&511;return mn.baseTable[i]+((8388607&e)>>mn.shiftTable[i])}function fn(t){const e=t>>10;return mn.uint32View[0]=mn.mantissaTable[mn.offsetTable[e]+(1023&t)]+mn.exponentTable[e],mn.floatView[0]}class xn{static toHalfFloat(t){return gn(t)}static fromHalfFloat(t){return fn(t)}}const bn=new Ts,vn=new _s;let wn=0;class Mn extends ds{constructor(t,e,i=!1){if(super(),Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.isBufferAttribute=!0,Object.defineProperty(this,"id",{value:wn++}),this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=i,this.usage=Oi,this.updateRanges=[],this.gpuType=Pt,this.version=0}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}addUpdateRange(t,e){this.updateRanges.push({start:t,count:e})}clearUpdateRanges(){this.updateRanges.length=0}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this.gpuType=t.gpuType,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let s=0,r=this.itemSize;sthis.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){if(this.isEmpty())return this.center.copy(t),this.radius=0,this;Pn.subVectors(t,this.center);const e=Pn.lengthSq();if(e>this.radius*this.radius){const t=Math.sqrt(e),i=.5*(t-this.radius);this.center.addScaledVector(Pn,i/t),this.radius+=i}return this}union(t){return t.isEmpty()?this:this.isEmpty()?(this.copy(t),this):(!0===this.center.equals(t.center)?this.radius=Math.max(this.radius,t.radius):(Rn.subVectors(t.center,this.center).setLength(t.radius),this.expandByPoint(Pn.copy(t.center).add(Rn)),this.expandByPoint(Pn.copy(t.center).sub(Rn))),this)}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}toJSON(){return{radius:this.radius,center:this.center.toArray()}}fromJSON(t){return this.radius=t.radius,this.center.fromArray(t.center),this}}let Vn=0;const En=new Qs,Ln=new Ar,Fn=new Ts,jn=new Qr,Dn=new Qr,Un=new Ts;class Wn extends ds{constructor(){super(),this.isBufferGeometry=!0,Object.defineProperty(this,"id",{value:Vn++}),this.uuid=fs(),this.name="",this.type="BufferGeometry",this.index=null,this.indirect=null,this.indirectOffset=0,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(function(t){for(let e=t.length-1;e>=0;--e)if(t[e]>=65535)return!0;return!1}(t)?In:zn)(t,1):this.index=t,this}setIndirect(t,e=0){return this.indirect=t,this.indirectOffset=e,this}getIndirect(){return this.indirect}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return void 0!==this.attributes[t]}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){const e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);const i=this.attributes.normal;if(void 0!==i){const e=(new Is).getNormalMatrix(t);i.applyNormalMatrix(e),i.needsUpdate=!0}const s=this.attributes.tangent;return void 0!==s&&(s.transformDirection(t),s.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}applyQuaternion(t){return En.makeRotationFromQuaternion(t),this.applyMatrix4(En),this}rotateX(t){return En.makeRotationX(t),this.applyMatrix4(En),this}rotateY(t){return En.makeRotationY(t),this.applyMatrix4(En),this}rotateZ(t){return En.makeRotationZ(t),this.applyMatrix4(En),this}translate(t,e,i){return En.makeTranslation(t,e,i),this.applyMatrix4(En),this}scale(t,e,i){return En.makeScale(t,e,i),this.applyMatrix4(En),this}lookAt(t){return Ln.lookAt(t),Ln.updateMatrix(),this.applyMatrix4(Ln.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(Fn).negate(),this.translate(Fn.x,Fn.y,Fn.z),this}setFromPoints(t){const e=this.getAttribute("position");if(void 0===e){const e=[];for(let i=0,s=t.length;ie.count&&as("BufferGeometry: Buffer size too small for points data. Use .dispose() and create a new geometry."),e.needsUpdate=!0}return this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new Qr);const t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return os("BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box.",this),void this.boundingBox.set(new Ts(-1/0,-1/0,-1/0),new Ts(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),e)for(let t=0,i=e.length;t0&&(t.userData=this.userData),void 0!==this.parameters){const e=this.parameters;for(const i in e)void 0!==e[i]&&(t[i]=e[i]);return t}t.data={attributes:{}};const e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});const i=this.attributes;for(const e in i){const s=i[e];t.data.attributes[e]=s.toJSON(t.data)}const s={};let r=!1;for(const e in this.morphAttributes){const i=this.morphAttributes[e],n=[];for(let e=0,s=i.length;e0&&(s[e]=n,r=!0)}r&&(t.data.morphAttributes=s,t.data.morphTargetsRelative=this.morphTargetsRelative);const n=this.groups;n.length>0&&(t.data.groups=JSON.parse(JSON.stringify(n)));const a=this.boundingSphere;return null!==a&&(t.data.boundingSphere=a.toJSON()),t}clone(){return(new this.constructor).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;const e={};this.name=t.name;const i=t.index;null!==i&&this.setIndex(i.clone());const s=t.attributes;for(const t in s){const i=s[t];this.setAttribute(t,i.clone(e))}const r=t.morphAttributes;for(const t in r){const i=[],s=r[t];for(let t=0,r=s.length;t0!=t>0&&this.version++,this._alphaTest=t}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(void 0!==t)for(const e in t){const i=t[e];if(void 0===i){as(`Material: parameter '${e}' has value of undefined.`);continue}const s=this[e];void 0!==s?s&&s.isColor?s.set(i):s&&s.isVector3&&i&&i.isVector3?s.copy(i):this[e]=i:as(`Material: '${e}' is not a property of THREE.${this.type}.`)}}toJSON(t){const e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});const i={metadata:{version:4.7,type:"Material",generator:"Material.toJSON"}};function s(t){const e=[];for(const i in t){const s=t[i];delete s.metadata,e.push(s)}return e}if(i.uuid=this.uuid,i.type=this.type,""!==this.name&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),void 0!==this.roughness&&(i.roughness=this.roughness),void 0!==this.metalness&&(i.metalness=this.metalness),void 0!==this.sheen&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),void 0!==this.sheenRoughness&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),void 0!==this.emissiveIntensity&&1!==this.emissiveIntensity&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),void 0!==this.specularIntensity&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),void 0!==this.shininess&&(i.shininess=this.shininess),void 0!==this.clearcoat&&(i.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.sheenColorMap&&this.sheenColorMap.isTexture&&(i.sheenColorMap=this.sheenColorMap.toJSON(t).uuid),this.sheenRoughnessMap&&this.sheenRoughnessMap.isTexture&&(i.sheenRoughnessMap=this.sheenRoughnessMap.toJSON(t).uuid),void 0!==this.dispersion&&(i.dispersion=this.dispersion),void 0!==this.iridescence&&(i.iridescence=this.iridescence),void 0!==this.iridescenceIOR&&(i.iridescenceIOR=this.iridescenceIOR),void 0!==this.iridescenceThicknessRange&&(i.iridescenceThicknessRange=this.iridescenceThicknessRange),this.iridescenceMap&&this.iridescenceMap.isTexture&&(i.iridescenceMap=this.iridescenceMap.toJSON(t).uuid),this.iridescenceThicknessMap&&this.iridescenceThicknessMap.isTexture&&(i.iridescenceThicknessMap=this.iridescenceThicknessMap.toJSON(t).uuid),void 0!==this.anisotropy&&(i.anisotropy=this.anisotropy),void 0!==this.anisotropyRotation&&(i.anisotropyRotation=this.anisotropyRotation),this.anisotropyMap&&this.anisotropyMap.isTexture&&(i.anisotropyMap=this.anisotropyMap.toJSON(t).uuid),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(i.combine=this.combine)),void 0!==this.envMapRotation&&(i.envMapRotation=this.envMapRotation.toArray()),void 0!==this.envMapIntensity&&(i.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(i.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.transmission&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),void 0!==this.thickness&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),void 0!==this.attenuationDistance&&this.attenuationDistance!==1/0&&(i.attenuationDistance=this.attenuationDistance),void 0!==this.attenuationColor&&(i.attenuationColor=this.attenuationColor.getHex()),void 0!==this.size&&(i.size=this.size),null!==this.shadowSide&&(i.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(i.sizeAttenuation=this.sizeAttenuation),1!==this.blending&&(i.blending=this.blending),0!==this.side&&(i.side=this.side),!0===this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),!0===this.transparent&&(i.transparent=!0),204!==this.blendSrc&&(i.blendSrc=this.blendSrc),205!==this.blendDst&&(i.blendDst=this.blendDst),100!==this.blendEquation&&(i.blendEquation=this.blendEquation),null!==this.blendSrcAlpha&&(i.blendSrcAlpha=this.blendSrcAlpha),null!==this.blendDstAlpha&&(i.blendDstAlpha=this.blendDstAlpha),null!==this.blendEquationAlpha&&(i.blendEquationAlpha=this.blendEquationAlpha),this.blendColor&&this.blendColor.isColor&&(i.blendColor=this.blendColor.getHex()),0!==this.blendAlpha&&(i.blendAlpha=this.blendAlpha),3!==this.depthFunc&&(i.depthFunc=this.depthFunc),!1===this.depthTest&&(i.depthTest=this.depthTest),!1===this.depthWrite&&(i.depthWrite=this.depthWrite),!1===this.colorWrite&&(i.colorWrite=this.colorWrite),255!==this.stencilWriteMask&&(i.stencilWriteMask=this.stencilWriteMask),519!==this.stencilFunc&&(i.stencilFunc=this.stencilFunc),0!==this.stencilRef&&(i.stencilRef=this.stencilRef),255!==this.stencilFuncMask&&(i.stencilFuncMask=this.stencilFuncMask),this.stencilFail!==li&&(i.stencilFail=this.stencilFail),this.stencilZFail!==li&&(i.stencilZFail=this.stencilZFail),this.stencilZPass!==li&&(i.stencilZPass=this.stencilZPass),!0===this.stencilWrite&&(i.stencilWrite=this.stencilWrite),void 0!==this.rotation&&0!==this.rotation&&(i.rotation=this.rotation),!0===this.polygonOffset&&(i.polygonOffset=!0),0!==this.polygonOffsetFactor&&(i.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(i.polygonOffsetUnits=this.polygonOffsetUnits),void 0!==this.linewidth&&1!==this.linewidth&&(i.linewidth=this.linewidth),void 0!==this.dashSize&&(i.dashSize=this.dashSize),void 0!==this.gapSize&&(i.gapSize=this.gapSize),void 0!==this.scale&&(i.scale=this.scale),!0===this.dithering&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),!0===this.alphaHash&&(i.alphaHash=!0),!0===this.alphaToCoverage&&(i.alphaToCoverage=!0),!0===this.premultipliedAlpha&&(i.premultipliedAlpha=!0),!0===this.forceSinglePass&&(i.forceSinglePass=!0),!1===this.allowOverride&&(i.allowOverride=!1),!0===this.wireframe&&(i.wireframe=!0),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(i.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(i.wireframeLinejoin=this.wireframeLinejoin),!0===this.flatShading&&(i.flatShading=!0),!1===this.visible&&(i.visible=!1),!1===this.toneMapped&&(i.toneMapped=!1),!1===this.fog&&(i.fog=!1),Object.keys(this.userData).length>0&&(i.userData=this.userData),e){const e=s(t.textures),r=s(t.images);e.length>0&&(i.textures=e),r.length>0&&(i.images=r)}return i}clone(){return(new this.constructor).copy(this)}copy(t){this.name=t.name,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.blendColor.copy(t.blendColor),this.blendAlpha=t.blendAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;const e=t.clippingPlanes;let i=null;if(null!==e){const t=e.length;i=new Array(t);for(let s=0;s!==t;++s)i[s]=e[s].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaHash=t.alphaHash,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.forceSinglePass=t.forceSinglePass,this.allowOverride=t.allowOverride,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){!0===t&&this.version++}}class Gn extends Zn{constructor(t){super(),this.isSpriteMaterial=!0,this.type="SpriteMaterial",this.color=new Pr(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this.fog=t.fog,this}}const $n=new Ts,Qn=new Ts,Kn=new Ts,ta=new _s,ea=new _s,ia=new Qs,sa=new Ts,ra=new Ts,na=new Ts,aa=new _s,oa=new _s,ha=new _s;class la extends Ar{constructor(t=new Gn){if(super(),this.isSprite=!0,this.type="Sprite",void 0===Yn){Yn=new Wn;const t=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),e=new qn(t,5);Yn.setIndex([0,1,2,0,2,3]),Yn.setAttribute("position",new Xn(e,3,0,!1)),Yn.setAttribute("uv",new Xn(e,2,3,!1))}this.geometry=Yn,this.material=t,this.center=new _s(.5,.5),this.count=1}raycast(t,e){null===t.camera&&os('Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),Qn.setFromMatrixScale(this.matrixWorld),ia.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Kn.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&Qn.multiplyScalar(-Kn.z);const i=this.material.rotation;let s,r;0!==i&&(r=Math.cos(i),s=Math.sin(i));const n=this.center;ca(sa.set(-.5,-.5,0),Kn,n,Qn,s,r),ca(ra.set(.5,-.5,0),Kn,n,Qn,s,r),ca(na.set(.5,.5,0),Kn,n,Qn,s,r),aa.set(0,0),oa.set(1,0),ha.set(1,1);let a=t.ray.intersectTriangle(sa,ra,na,!1,$n);if(null===a&&(ca(ra.set(-.5,.5,0),Kn,n,Qn,s,r),oa.set(0,1),a=t.ray.intersectTriangle(sa,na,ra,!1,$n),null===a))return;const o=t.ray.origin.distanceTo($n);ot.far||e.push({distance:o,point:$n.clone(),uv:$r.getInterpolation($n,sa,ra,na,aa,oa,ha,new _s),face:null,object:this})}copy(t,e){return super.copy(t,e),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}}function ca(t,e,i,s,r,n){ta.subVectors(t,i).addScalar(.5).multiply(s),void 0!==r?(ea.x=n*ta.x-r*ta.y,ea.y=r*ta.x+n*ta.y):ea.copy(ta),t.copy(e),t.x+=ea.x,t.y+=ea.y,t.applyMatrix4(ia)}const ua=new Ts,da=new Ts;class pa extends Ar{constructor(){super(),this.isLOD=!0,this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]}}),this.autoUpdate=!0}copy(t){super.copy(t,!1);const e=t.levels;for(let t=0,i=e.length;t0){let i,s;for(i=1,s=e.length;i0){ua.setFromMatrixPosition(this.matrixWorld);const i=t.ray.origin.distanceTo(ua);this.getObjectForDistance(i).raycast(t,e)}}update(t){const e=this.levels;if(e.length>1){ua.setFromMatrixPosition(t.matrixWorld),da.setFromMatrixPosition(this.matrixWorld);const i=ua.distanceTo(da)/t.zoom;let s,r;for(e[0].object.visible=!0,s=1,r=e.length;s=t))break;e[s-1].object.visible=!1,e[s].object.visible=!0}for(this._currentLevel=s-1;s0)if(c=n*o-a,u=n*a-o,p=r*l,c>=0)if(u>=-p)if(u<=p){const t=1/l;c*=t,u*=t,d=c*(c+n*u+2*a)+u*(n*c+u+2*o)+h}else u=r,c=Math.max(0,-(n*u+a)),d=-c*c+u*(u+2*o)+h;else u=-r,c=Math.max(0,-(n*u+a)),d=-c*c+u*(u+2*o)+h;else u<=-p?(c=Math.max(0,-(-n*r+a)),u=c>0?-r:Math.min(Math.max(-r,-o),r),d=-c*c+u*(u+2*o)+h):u<=p?(c=0,u=Math.min(Math.max(-r,-o),r),d=u*(u+2*o)+h):(c=Math.max(0,-(n*r+a)),u=c>0?r:Math.min(Math.max(-r,-o),r),d=-c*c+u*(u+2*o)+h);else u=n>0?-r:r,c=Math.max(0,-(n*u+a)),d=-c*c+u*(u+2*o)+h;return i&&i.copy(this.origin).addScaledVector(this.direction,c),s&&s.copy(ya).addScaledVector(ga,u),d}intersectSphere(t,e){ma.subVectors(t.center,this.origin);const i=ma.dot(this.direction),s=ma.dot(ma)-i*i,r=t.radius*t.radius;if(s>r)return null;const n=Math.sqrt(r-s),a=i-n,o=i+n;return o<0?null:a<0?this.at(o,e):this.at(a,e)}intersectsSphere(t){return!(t.radius<0)&&this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){const e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;const i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){const i=this.distanceToPlane(t);return null===i?null:this.at(i,e)}intersectsPlane(t){const e=t.distanceToPoint(this.origin);if(0===e)return!0;return t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,s,r,n,a,o;const h=1/this.direction.x,l=1/this.direction.y,c=1/this.direction.z,u=this.origin;return h>=0?(i=(t.min.x-u.x)*h,s=(t.max.x-u.x)*h):(i=(t.max.x-u.x)*h,s=(t.min.x-u.x)*h),l>=0?(r=(t.min.y-u.y)*l,n=(t.max.y-u.y)*l):(r=(t.max.y-u.y)*l,n=(t.min.y-u.y)*l),i>n||r>s?null:((r>i||isNaN(i))&&(i=r),(n=0?(a=(t.min.z-u.z)*c,o=(t.max.z-u.z)*c):(a=(t.max.z-u.z)*c,o=(t.min.z-u.z)*c),i>o||a>s?null:((a>i||i!=i)&&(i=a),(o=0?i:s,e)))}intersectsBox(t){return null!==this.intersectBox(t,ma)}intersectTriangle(t,e,i,s,r){xa.subVectors(e,t),ba.subVectors(i,t),va.crossVectors(xa,ba);let n,a=this.direction.dot(va);if(a>0){if(s)return null;n=1}else{if(!(a<0))return null;n=-1,a=-a}fa.subVectors(this.origin,t);const o=n*this.direction.dot(ba.crossVectors(fa,ba));if(o<0)return null;const h=n*this.direction.dot(xa.cross(fa));if(h<0)return null;if(o+h>a)return null;const l=-n*fa.dot(va);return l<0?null:this.at(l/a,r)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}}class Ma extends Zn{constructor(t){super(),this.isMeshBasicMaterial=!0,this.type="MeshBasicMaterial",this.color=new Pr(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.envMapRotation=new hr,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapRotation.copy(t.envMapRotation),this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.fog=t.fog,this}}const Sa=new Qs,_a=new wa,Aa=new Nn,Ta=new Ts,za=new Ts,Ca=new Ts,Ia=new Ts,Ba=new Ts,ka=new Ts,Oa=new Ts,Pa=new Ts;class Ra extends Ar{constructor(t=new Wn,e=new Ma){super(),this.isMesh=!0,this.type="Mesh",this.geometry=t,this.material=e,this.morphTargetDictionary=void 0,this.morphTargetInfluences=void 0,this.count=1,this.updateMorphTargets()}copy(t,e){return super.copy(t,e),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=Array.isArray(t.material)?t.material.slice():t.material,this.geometry=t.geometry,this}updateMorphTargets(){const t=this.geometry.morphAttributes,e=Object.keys(t);if(e.length>0){const i=t[e[0]];if(void 0!==i){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let t=0,e=i.length;t(t.far-t.near)**2)return}Sa.copy(r).invert(),_a.copy(t.ray).applyMatrix4(Sa),null!==i.boundingBox&&!1===_a.intersectsBox(i.boundingBox)||this._computeIntersections(t,e,_a)}}_computeIntersections(t,e,i){let s;const r=this.geometry,n=this.material,a=r.index,o=r.attributes.position,h=r.attributes.uv,l=r.attributes.uv1,c=r.attributes.normal,u=r.groups,d=r.drawRange;if(null!==a)if(Array.isArray(n))for(let r=0,o=u.length;ri.far?null:{distance:l,point:Pa.clone(),object:t}}(t,e,i,s,za,Ca,Ia,Oa);if(c){const t=new Ts;$r.getBarycoord(Oa,za,Ca,Ia,t),r&&(c.uv=$r.getInterpolatedAttribute(r,o,h,l,t,new _s)),n&&(c.uv1=$r.getInterpolatedAttribute(n,o,h,l,t,new _s)),a&&(c.normal=$r.getInterpolatedAttribute(a,o,h,l,t,new Ts),c.normal.dot(s.direction)>0&&c.normal.multiplyScalar(-1));const e={a:o,b:h,c:l,normal:new Ts,materialIndex:0};$r.getNormal(za,Ca,Ia,e.normal),c.face=e,c.barycoord=t}return c}const Va=new Js,Ea=new Js,La=new Js,Fa=new Js,ja=new Qs,Da=new Ts,Ua=new Nn,Wa=new Qs,qa=new wa;class Ja extends Ra{constructor(t,e){super(t,e),this.isSkinnedMesh=!0,this.type="SkinnedMesh",this.bindMode=at,this.bindMatrix=new Qs,this.bindMatrixInverse=new Qs,this.boundingBox=null,this.boundingSphere=null}computeBoundingBox(){const t=this.geometry;null===this.boundingBox&&(this.boundingBox=new Qr),this.boundingBox.makeEmpty();const e=t.getAttribute("position");for(let t=0;t1)?null:e.copy(t.start).addScaledVector(s,n)}intersectsLine(t){const e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){const i=e||ho.getNormalMatrix(t),s=this.coplanarPoint(ao).applyMatrix4(t),r=this.normal.applyMatrix3(i).normalize();return this.constant=-s.dot(r),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}}const co=new Nn,uo=new _s(.5,.5),po=new Ts;class mo{constructor(t=new lo,e=new lo,i=new lo,s=new lo,r=new lo,n=new lo){this.planes=[t,e,i,s,r,n]}set(t,e,i,s,r,n){const a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(s),a[4].copy(r),a[5].copy(n),this}copy(t){const e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t,e=2e3,i=!1){const s=this.planes,r=t.elements,n=r[0],a=r[1],o=r[2],h=r[3],l=r[4],c=r[5],u=r[6],d=r[7],p=r[8],m=r[9],y=r[10],g=r[11],f=r[12],x=r[13],b=r[14],v=r[15];if(s[0].setComponents(h-n,d-l,g-p,v-f).normalize(),s[1].setComponents(h+n,d+l,g+p,v+f).normalize(),s[2].setComponents(h+a,d+c,g+m,v+x).normalize(),s[3].setComponents(h-a,d-c,g-m,v-x).normalize(),i)s[4].setComponents(o,u,y,b).normalize(),s[5].setComponents(h-o,d-u,g-y,v-b).normalize();else if(s[4].setComponents(h-o,d-u,g-y,v-b).normalize(),e===Wi)s[5].setComponents(h+o,d+u,g+y,v+b).normalize();else{if(e!==qi)throw new Error("THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: "+e);s[5].setComponents(o,u,y,b).normalize()}return this}intersectsObject(t){if(void 0!==t.boundingSphere)null===t.boundingSphere&&t.computeBoundingSphere(),co.copy(t.boundingSphere).applyMatrix4(t.matrixWorld);else{const e=t.geometry;null===e.boundingSphere&&e.computeBoundingSphere(),co.copy(e.boundingSphere).applyMatrix4(t.matrixWorld)}return this.intersectsSphere(co)}intersectsSprite(t){co.center.set(0,0,0);const e=uo.distanceTo(t.center);return co.radius=.7071067811865476+e,co.applyMatrix4(t.matrixWorld),this.intersectsSphere(co)}intersectsSphere(t){const e=this.planes,i=t.center,s=-t.radius;for(let t=0;t<6;t++){if(e[t].distanceToPoint(i)0?t.max.x:t.min.x,po.y=s.normal.y>0?t.max.y:t.min.y,po.z=s.normal.z>0?t.max.z:t.min.z,s.distanceToPoint(po)<0)return!1}return!0}containsPoint(t){const e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return(new this.constructor).copy(this)}}const yo=new Qs,go=new mo;class fo{constructor(){this.coordinateSystem=Wi}intersectsObject(t,e){if(!e.isArrayCamera||0===e.cameras.length)return!1;for(let i=0;i=r.length&&r.push({start:-1,count:-1,z:-1,index:-1});const a=r[this.index];n.push(a),this.index++,a.start=t,a.count=e,a.z=i,a.index=s}reset(){this.list.length=0,this.index=0}}const Mo=new Qs,So=new Pr(1,1,1),_o=new mo,Ao=new fo,To=new Qr,zo=new Nn,Co=new Ts,Io=new Ts,Bo=new Ts,ko=new wo,Oo=new Ra,Po=[];function Ro(t,e,i=0){const s=e.itemSize;if(t.isInterleavedBufferAttribute||t.array.constructor!==e.array.constructor){const r=t.count;for(let n=0;n65535?new Uint32Array(s):new Uint16Array(s);e.setIndex(new Mn(t,1))}this._geometryInitialized=!0}}_validateGeometry(t){const e=this.geometry;if(Boolean(t.getIndex())!==Boolean(e.getIndex()))throw new Error('THREE.BatchedMesh: All geometries must consistently have "index".');for(const i in e.attributes){if(!t.hasAttribute(i))throw new Error(`THREE.BatchedMesh: Added geometry missing "${i}". All geometries must have consistent attributes.`);const s=t.getAttribute(i),r=e.getAttribute(i);if(s.itemSize!==r.itemSize||s.normalized!==r.normalized)throw new Error("THREE.BatchedMesh: All attributes must have a consistent itemSize and normalized value.")}}validateInstanceId(t){const e=this._instanceInfo;if(t<0||t>=e.length||!1===e[t].active)throw new Error(`THREE.BatchedMesh: Invalid instanceId ${t}. Instance is either out of range or has been deleted.`)}validateGeometryId(t){const e=this._geometryInfo;if(t<0||t>=e.length||!1===e[t].active)throw new Error(`THREE.BatchedMesh: Invalid geometryId ${t}. Geometry is either out of range or has been deleted.`)}setCustomSort(t){return this.customSort=t,this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new Qr);const t=this.boundingBox,e=this._instanceInfo;t.makeEmpty();for(let i=0,s=e.length;i=this.maxInstanceCount&&0===this._availableInstanceIds.length)throw new Error("THREE.BatchedMesh: Maximum item count reached.");const e={visible:!0,active:!0,geometryIndex:t};let i=null;this._availableInstanceIds.length>0?(this._availableInstanceIds.sort(xo),i=this._availableInstanceIds.shift(),this._instanceInfo[i]=e):(i=this._instanceInfo.length,this._instanceInfo.push(e));const s=this._matricesTexture;Mo.identity().toArray(s.image.data,16*i),s.needsUpdate=!0;const r=this._colorsTexture;return r&&(So.toArray(r.image.data,4*i),r.needsUpdate=!0),this._visibilityChanged=!0,i}addGeometry(t,e=-1,i=-1){this._initializeGeometry(t),this._validateGeometry(t);const s={vertexStart:-1,vertexCount:-1,reservedVertexCount:-1,indexStart:-1,indexCount:-1,reservedIndexCount:-1,start:-1,count:-1,boundingBox:null,boundingSphere:null,active:!0},r=this._geometryInfo;s.vertexStart=this._nextVertexStart,s.reservedVertexCount=-1===e?t.getAttribute("position").count:e;const n=t.getIndex();if(null!==n&&(s.indexStart=this._nextIndexStart,s.reservedIndexCount=-1===i?n.count:i),-1!==s.indexStart&&s.indexStart+s.reservedIndexCount>this._maxIndexCount||s.vertexStart+s.reservedVertexCount>this._maxVertexCount)throw new Error("THREE.BatchedMesh: Reserved space request exceeds the maximum buffer size.");let a;return this._availableGeometryIds.length>0?(this._availableGeometryIds.sort(xo),a=this._availableGeometryIds.shift(),r[a]=s):(a=this._geometryCount,this._geometryCount++,r.push(s)),this.setGeometryAt(a,t),this._nextIndexStart=s.indexStart+s.reservedIndexCount,this._nextVertexStart=s.vertexStart+s.reservedVertexCount,a}setGeometryAt(t,e){if(t>=this._geometryCount)throw new Error("THREE.BatchedMesh: Maximum geometry count reached.");this._validateGeometry(e);const i=this.geometry,s=null!==i.getIndex(),r=i.getIndex(),n=e.getIndex(),a=this._geometryInfo[t];if(s&&n.count>a.reservedIndexCount||e.attributes.position.count>a.reservedVertexCount)throw new Error("THREE.BatchedMesh: Reserved space not large enough for provided geometry.");const o=a.vertexStart,h=a.reservedVertexCount;a.vertexCount=e.getAttribute("position").count;for(const t in i.attributes){const s=e.getAttribute(t),r=i.getAttribute(t);Ro(s,r,o);const n=s.itemSize;for(let t=s.count,e=h;t=e.length||!1===e[t].active)return this;const i=this._instanceInfo;for(let e=0,s=i.length;ee).sort((t,e)=>i[t].vertexStart-i[e].vertexStart),r=this.geometry;for(let n=0,a=i.length;n=this._geometryCount)return null;const i=this.geometry,s=this._geometryInfo[t];if(null===s.boundingBox){const t=new Qr,e=i.index,r=i.attributes.position;for(let i=s.start,n=s.start+s.count;i=this._geometryCount)return null;const i=this.geometry,s=this._geometryInfo[t];if(null===s.boundingSphere){const e=new Nn;this.getBoundingBoxAt(t,To),To.getCenter(e.center);const r=i.index,n=i.attributes.position;let a=0;for(let t=s.start,i=s.start+s.count;tt.active);if(Math.max(...i.map(t=>t.vertexStart+t.reservedVertexCount))>t)throw new Error(`BatchedMesh: Geometry vertex values are being used outside the range ${e}. Cannot shrink further.`);if(this.geometry.index){if(Math.max(...i.map(t=>t.indexStart+t.reservedIndexCount))>e)throw new Error(`BatchedMesh: Geometry index values are being used outside the range ${e}. Cannot shrink further.`)}const s=this.geometry;s.dispose(),this._maxVertexCount=t,this._maxIndexCount=e,this._geometryInitialized&&(this._geometryInitialized=!1,this.geometry=new Wn,this._initializeGeometry(s));const r=this.geometry;s.index&&No(s.index.array,r.index.array);for(const t in s.attributes)No(s.attributes[t].array,r.attributes[t].array)}raycast(t,e){const i=this._instanceInfo,s=this._geometryInfo,r=this.matrixWorld,n=this.geometry;Oo.material=this.material,Oo.geometry.index=n.index,Oo.geometry.attributes=n.attributes,null===Oo.geometry.boundingBox&&(Oo.geometry.boundingBox=new Qr),null===Oo.geometry.boundingSphere&&(Oo.geometry.boundingSphere=new Nn);for(let n=0,a=i.length;n({...t,boundingBox:null!==t.boundingBox?t.boundingBox.clone():null,boundingSphere:null!==t.boundingSphere?t.boundingSphere.clone():null})),this._instanceInfo=t._instanceInfo.map(t=>({...t})),this._availableInstanceIds=t._availableInstanceIds.slice(),this._availableGeometryIds=t._availableGeometryIds.slice(),this._nextIndexStart=t._nextIndexStart,this._nextVertexStart=t._nextVertexStart,this._geometryCount=t._geometryCount,this._maxInstanceCount=t._maxInstanceCount,this._maxVertexCount=t._maxVertexCount,this._maxIndexCount=t._maxIndexCount,this._geometryInitialized=t._geometryInitialized,this._multiDrawCounts=t._multiDrawCounts.slice(),this._multiDrawStarts=t._multiDrawStarts.slice(),this._indirectTexture=t._indirectTexture.clone(),this._indirectTexture.image.data=this._indirectTexture.image.data.slice(),this._matricesTexture=t._matricesTexture.clone(),this._matricesTexture.image.data=this._matricesTexture.image.data.slice(),null!==this._colorsTexture&&(this._colorsTexture=t._colorsTexture.clone(),this._colorsTexture.image.data=this._colorsTexture.image.data.slice()),this}dispose(){this.geometry.dispose(),this._matricesTexture.dispose(),this._matricesTexture=null,this._indirectTexture.dispose(),this._indirectTexture=null,null!==this._colorsTexture&&(this._colorsTexture.dispose(),this._colorsTexture=null)}onBeforeRender(t,e,i,s,r){if(!this._visibilityChanged&&!this.perObjectFrustumCulled&&!this.sortObjects)return;const n=s.getIndex();let a=null===n?1:n.array.BYTES_PER_ELEMENT,o=1;r.wireframe&&(o=2,a=s.attributes.position.count>65535?4:2);const h=this._instanceInfo,l=this._multiDrawStarts,c=this._multiDrawCounts,u=this._geometryInfo,d=this.perObjectFrustumCulled,p=this._indirectTexture,m=p.image.data,y=i.isArrayCamera?Ao:_o;d&&!i.isArrayCamera&&(Mo.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse).multiply(this.matrixWorld),_o.setFromProjectionMatrix(Mo,i.coordinateSystem,i.reversedDepth));let g=0;if(this.sortObjects){Mo.copy(this.matrixWorld).invert(),Co.setFromMatrixPosition(i.matrixWorld).applyMatrix4(Mo),Io.set(0,0,-1).transformDirection(i.matrixWorld).transformDirection(Mo);for(let t=0,e=h.length;t0){const i=t[e[0]];if(void 0!==i){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let t=0,e=i.length;ts)return;Wo.applyMatrix4(t.matrixWorld);const h=e.ray.origin.distanceTo(Wo);return he.far?void 0:{distance:h,point:qo.clone().applyMatrix4(t.matrixWorld),index:a,face:null,faceIndex:null,barycoord:null,object:t}}const Yo=new Ts,Ho=new Ts;class Zo extends Jo{constructor(t,e){super(t,e),this.isLineSegments=!0,this.type="LineSegments"}computeLineDistances(){const t=this.geometry;if(null===t.index){const e=t.attributes.position,i=[];for(let t=0,s=e.count;t0){const i=t[e[0]];if(void 0!==i){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let t=0,e=i.length;tr.far)return;n.push({distance:h,distanceToRay:Math.sqrt(o),point:i,index:e,face:null,faceIndex:null,barycoord:null,object:a})}}class rh extends qs{constructor(t,e,i,s,r=1006,n=1006,a,o,h){super(t,e,i,s,r,n,a,o,h),this.isVideoTexture=!0,this.generateMipmaps=!1,this._requestVideoFrameCallbackId=0;const l=this;"requestVideoFrameCallback"in t&&(this._requestVideoFrameCallbackId=t.requestVideoFrameCallback(function e(){l.needsUpdate=!0,l._requestVideoFrameCallbackId=t.requestVideoFrameCallback(e)}))}clone(){return new this.constructor(this.image).copy(this)}update(){const t=this.image;!1==="requestVideoFrameCallback"in t&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}dispose(){0!==this._requestVideoFrameCallbackId&&(this.source.data.cancelVideoFrameCallback(this._requestVideoFrameCallbackId),this._requestVideoFrameCallbackId=0),super.dispose()}}class nh extends rh{constructor(t,e,i,s,r,n,a,o){super({},t,e,i,s,r,n,a,o),this.isVideoFrameTexture=!0}update(){}clone(){return(new this.constructor).copy(this)}setFrame(t){this.image=t,this.needsUpdate=!0}}class ah extends qs{constructor(t,e){super({width:t,height:e}),this.isFramebufferTexture=!0,this.magFilter=ft,this.minFilter=ft,this.generateMipmaps=!1,this.needsUpdate=!0}}class oh extends qs{constructor(t,e,i,s,r,n,a,o,h,l,c,u){super(null,n,a,o,h,l,s,r,c,u),this.isCompressedTexture=!0,this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}}class hh extends oh{constructor(t,e,i,s,r,n){super(t,e,i,r,n),this.isCompressedArrayTexture=!0,this.image.depth=s,this.wrapR=yt,this.layerUpdates=new Set}addLayerUpdate(t){this.layerUpdates.add(t)}clearLayerUpdates(){this.layerUpdates.clear()}}class lh extends oh{constructor(t,e,i){super(void 0,t[0].width,t[0].height,e,i,lt),this.isCompressedCubeTexture=!0,this.isCubeTexture=!0,this.image=t}}class ch extends qs{constructor(t=[],e=301,i,s,r,n,a,o,h,l){super(t,e,i,s,r,n,a,o,h,l),this.isCubeTexture=!0,this.flipY=!1}get images(){return this.image}set images(t){this.image=t}}class uh extends qs{constructor(t,e,i,s,r,n,a,o,h){super(t,e,i,s,r,n,a,o,h),this.isCanvasTexture=!0,this.needsUpdate=!0}}class dh extends qs{constructor(t,e,i,s,r,n,a,o,h){super(t,e,i,s,r,n,a,o,h),this.isHTMLTexture=!0,this.generateMipmaps=!1,this.needsUpdate=!0;const l=t?t.parentNode:null;null!==l&&"requestPaint"in l&&(l.onpaint=()=>{this.needsUpdate=!0},l.requestPaint())}dispose(){const t=this.image?this.image.parentNode:null;null!==t&&"onpaint"in t&&(t.onpaint=null),super.dispose()}}class ph extends qs{constructor(t,e,i=1014,s,r,n,a=1003,o=1003,h,l=1026,c=1){if(l!==Wt&&1027!==l)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");super({width:t,height:e,depth:c},s,r,n,a,o,l,i,h),this.isDepthTexture=!0,this.flipY=!1,this.generateMipmaps=!1,this.compareFunction=null}copy(t){return super.copy(t),this.source=new js(Object.assign({},t.image)),this.compareFunction=t.compareFunction,this}toJSON(t){const e=super.toJSON(t);return null!==this.compareFunction&&(e.compareFunction=this.compareFunction),e}}class mh extends ph{constructor(t,e=1014,i=301,s,r,n=1003,a=1003,o,h=1026){const l={width:t,height:t,depth:1},c=[l,l,l,l,l,l];super(t,t,e,i,s,r,n,a,o,h),this.image=c,this.isCubeDepthTexture=!0,this.isCubeTexture=!0}get images(){return this.image}set images(t){this.image=t}}class yh extends qs{constructor(t=null){super(),this.sourceTexture=t,this.isExternalTexture=!0}copy(t){return super.copy(t),this.sourceTexture=t.sourceTexture,this}}class gh extends Wn{constructor(t=1,e=1,i=1,s=1,r=1,n=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:s,heightSegments:r,depthSegments:n};const a=this;s=Math.floor(s),r=Math.floor(r),n=Math.floor(n);const o=[],h=[],l=[],c=[];let u=0,d=0;function p(t,e,i,s,r,n,p,m,y,g,f){const x=n/y,b=p/g,v=n/2,w=p/2,M=m/2,S=y+1,_=g+1;let A=0,T=0;const z=new Ts;for(let n=0;n<_;n++){const a=n*b-w;for(let o=0;o0?1:-1,l.push(z.x,z.y,z.z),c.push(o/y),c.push(1-n/g),A+=1}}for(let t=0;t0){const t=(f-1)*m;for(let e=0;e0||0!==s)&&(l.push(n,a,h),x+=3),(e>0||s!==r-1)&&(l.push(a,o,h),x+=3)}h.addGroup(g,x,0),g+=x}(),!1===n&&(t>0&&f(!0),e>0&&f(!1)),this.setIndex(l),this.setAttribute("position",new kn(c,3)),this.setAttribute("normal",new kn(u,3)),this.setAttribute("uv",new kn(d,2))}copy(t){return super.copy(t),this.parameters=Object.assign({},t.parameters),this}static fromJSON(t){return new bh(t.radiusTop,t.radiusBottom,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}}class vh extends bh{constructor(t=1,e=1,i=32,s=1,r=!1,n=0,a=2*Math.PI){super(0,t,e,i,s,r,n,a),this.type="ConeGeometry",this.parameters={radius:t,height:e,radialSegments:i,heightSegments:s,openEnded:r,thetaStart:n,thetaLength:a}}static fromJSON(t){return new vh(t.radius,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}}class wh extends Wn{constructor(t=[],e=[],i=1,s=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:e,radius:i,detail:s};const r=[],n=[];function a(t,e,i,s){const r=s+1,n=[];for(let s=0;s<=r;s++){n[s]=[];const a=t.clone().lerp(i,s/r),o=e.clone().lerp(i,s/r),h=r-s;for(let t=0;t<=h;t++)n[s][t]=0===t&&s===r?a:a.clone().lerp(o,t/h)}for(let t=0;t.9&&a<.1&&(e<.2&&(n[t+0]+=1),i<.2&&(n[t+2]+=1),s<.2&&(n[t+4]+=1))}}()}(),this.setAttribute("position",new kn(r,3)),this.setAttribute("normal",new kn(r.slice(),3)),this.setAttribute("uv",new kn(n,2)),0===s?this.computeVertexNormals():this.normalizeNormals()}copy(t){return super.copy(t),this.parameters=Object.assign({},t.parameters),this}static fromJSON(t){return new wh(t.vertices,t.indices,t.radius,t.detail)}}class Mh extends wh{constructor(t=1,e=0){const i=(1+Math.sqrt(5))/2,s=1/i;super([-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-s,-i,0,-s,i,0,s,-i,0,s,i,-s,-i,0,-s,i,0,s,-i,0,s,i,0,-i,0,-s,i,0,-s,-i,0,s,i,0,s],[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9],t,e),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:e}}static fromJSON(t){return new Mh(t.radius,t.detail)}}const Sh=new Ts,_h=new Ts,Ah=new Ts,Th=new $r;class zh extends Wn{constructor(t=null,e=1){if(super(),this.type="EdgesGeometry",this.parameters={geometry:t,thresholdAngle:e},null!==t){const i=4,s=Math.pow(10,i),r=Math.cos(ys*e),n=t.getIndex(),a=t.getAttribute("position"),o=n?n.count:a.count,h=[0,0,0],l=["a","b","c"],c=new Array(3),u={},d=[];for(let t=0;t0)){h=s;break}h=s-1}if(s=h,i[s]===n)return s/(r-1);const l=i[s];return(s+(n-l)/(i[s+1]-l))/(r-1)}getTangent(t,e){const i=1e-4;let s=t-i,r=t+i;s<0&&(s=0),r>1&&(r=1);const n=this.getPoint(s),a=this.getPoint(r),o=e||(n.isVector2?new _s:new Ts);return o.copy(a).sub(n).normalize(),o}getTangentAt(t,e){const i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e=!1){const i=new Ts,s=[],r=[],n=[],a=new Ts,o=new Qs;for(let e=0;e<=t;e++){const i=e/t;s[e]=this.getTangentAt(i,new Ts)}r[0]=new Ts,n[0]=new Ts;let h=Number.MAX_VALUE;const l=Math.abs(s[0].x),c=Math.abs(s[0].y),u=Math.abs(s[0].z);l<=h&&(h=l,i.set(1,0,0)),c<=h&&(h=c,i.set(0,1,0)),u<=h&&i.set(0,0,1),a.crossVectors(s[0],i).normalize(),r[0].crossVectors(s[0],a),n[0].crossVectors(s[0],r[0]);for(let e=1;e<=t;e++){if(r[e]=r[e-1].clone(),n[e]=n[e-1].clone(),a.crossVectors(s[e-1],s[e]),a.length()>Number.EPSILON){a.normalize();const t=Math.acos(xs(s[e-1].dot(s[e]),-1,1));r[e].applyMatrix4(o.makeRotationAxis(a,t))}n[e].crossVectors(s[e],r[e])}if(!0===e){let e=Math.acos(xs(r[0].dot(r[t]),-1,1));e/=t,s[0].dot(a.crossVectors(r[0],r[t]))>0&&(e=-e);for(let i=1;i<=t;i++)r[i].applyMatrix4(o.makeRotationAxis(s[i],e*i)),n[i].crossVectors(s[i],r[i])}return{tangents:s,normals:r,binormals:n}}clone(){return(new this.constructor).copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){const t={metadata:{version:4.7,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}class Ih extends Ch{constructor(t=0,e=0,i=1,s=1,r=0,n=2*Math.PI,a=!1,o=0){super(),this.isEllipseCurve=!0,this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=s,this.aStartAngle=r,this.aEndAngle=n,this.aClockwise=a,this.aRotation=o}getPoint(t,e=new _s){const i=e,s=2*Math.PI;let r=this.aEndAngle-this.aStartAngle;const n=Math.abs(r)s;)r-=s;r0?0:(Math.floor(Math.abs(h)/r)+1)*r:0===l&&h===r-1&&(h=r-2,l=1),this.closed||h>0?a=s[(h-1)%r]:(Ph.subVectors(s[0],s[1]).add(s[0]),a=Ph);const c=s[h%r],u=s[(h+1)%r];if(this.closed||h+2s.length-2?s.length-1:n+1],c=s[n>s.length-3?s.length-1:n+2];return i.set(Lh(a,o.x,h.x,l.x,c.x),Lh(a,o.y,h.y,l.y,c.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e=i){const t=s[r]-i,n=this.curves[r],a=n.getLength(),o=0===a?0:1-t/a;return n.getPointAt(o,e)}r++}return null}getLength(){const t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;const t=[];let e=0;for(let i=0,s=this.curves.length;i1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e0){const t=h.getPoint(0);t.equals(this.currentPoint)||this.lineTo(t.x,t.y)}this.curves.push(h);const l=h.getPoint(1);return this.currentPoint.copy(l),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){const t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}}class $h extends Gh{constructor(t){super(t),this.uuid=fs(),this.type="Shape",this.holes=[]}getPointsHoles(t){const e=[];for(let i=0,s=this.holes.length;i80*i){o=t[0],h=t[1];let e=o,s=h;for(let n=i;ne&&(e=i),r>s&&(s=r)}l=Math.max(e-o,s-h),l=0!==l?32767/l:0}return el(n,a,i,o,h,l,0),a}function Kh(t,e,i,s,r){let n;if(r===function(t,e,i,s){let r=0;for(let n=e,a=i-s;n0)for(let r=e;r=e;r-=s)n=wl(r/s|0,t[r],t[r+1],n);return n&&yl(n,n.next)&&(Ml(n),n=n.next),n}function tl(t,e){if(!t)return t;e||(e=t);let i,s=t;do{if(i=!1,s.steiner||!yl(s,s.next)&&0!==ml(s.prev,s,s.next))s=s.next;else{if(Ml(s),s=e=s.prev,s===s.next)break;i=!0}}while(i||s!==e);return e}function el(t,e,i,s,r,n,a){if(!t)return;!a&&n&&function(t,e,i,s){let r=t;do{0===r.z&&(r.z=ll(r.x,r.y,e,i,s)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==t);r.prevZ.nextZ=null,r.prevZ=null,function(t){let e,i=1;do{let s,r=t;t=null;let n=null;for(e=0;r;){e++;let a=r,o=0;for(let t=0;t0||h>0&&a;)0!==o&&(0===h||!a||r.z<=a.z)?(s=r,r=r.nextZ,o--):(s=a,a=a.nextZ,h--),n?n.nextZ=s:t=s,s.prevZ=n,n=s;r=a}n.nextZ=null,i*=2}while(e>1)}(r)}(t,s,r,n);let o=t;for(;t.prev!==t.next;){const h=t.prev,l=t.next;if(n?sl(t,s,r,n):il(t))e.push(h.i,t.i,l.i),Ml(t),t=l.next,o=l.next;else if((t=l)===o){a?1===a?el(t=rl(tl(t),e),e,i,s,r,n,2):2===a&&nl(t,e,i,s,r,n):el(tl(t),e,i,s,r,n,1);break}}}function il(t){const e=t.prev,i=t,s=t.next;if(ml(e,i,s)>=0)return!1;const r=e.x,n=i.x,a=s.x,o=e.y,h=i.y,l=s.y,c=Math.min(r,n,a),u=Math.min(o,h,l),d=Math.max(r,n,a),p=Math.max(o,h,l);let m=s.next;for(;m!==e;){if(m.x>=c&&m.x<=d&&m.y>=u&&m.y<=p&&dl(r,o,n,h,a,l,m.x,m.y)&&ml(m.prev,m,m.next)>=0)return!1;m=m.next}return!0}function sl(t,e,i,s){const r=t.prev,n=t,a=t.next;if(ml(r,n,a)>=0)return!1;const o=r.x,h=n.x,l=a.x,c=r.y,u=n.y,d=a.y,p=Math.min(o,h,l),m=Math.min(c,u,d),y=Math.max(o,h,l),g=Math.max(c,u,d),f=ll(p,m,e,i,s),x=ll(y,g,e,i,s);let b=t.prevZ,v=t.nextZ;for(;b&&b.z>=f&&v&&v.z<=x;){if(b.x>=p&&b.x<=y&&b.y>=m&&b.y<=g&&b!==r&&b!==a&&dl(o,c,h,u,l,d,b.x,b.y)&&ml(b.prev,b,b.next)>=0)return!1;if(b=b.prevZ,v.x>=p&&v.x<=y&&v.y>=m&&v.y<=g&&v!==r&&v!==a&&dl(o,c,h,u,l,d,v.x,v.y)&&ml(v.prev,v,v.next)>=0)return!1;v=v.nextZ}for(;b&&b.z>=f;){if(b.x>=p&&b.x<=y&&b.y>=m&&b.y<=g&&b!==r&&b!==a&&dl(o,c,h,u,l,d,b.x,b.y)&&ml(b.prev,b,b.next)>=0)return!1;b=b.prevZ}for(;v&&v.z<=x;){if(v.x>=p&&v.x<=y&&v.y>=m&&v.y<=g&&v!==r&&v!==a&&dl(o,c,h,u,l,d,v.x,v.y)&&ml(v.prev,v,v.next)>=0)return!1;v=v.nextZ}return!0}function rl(t,e){let i=t;do{const s=i.prev,r=i.next.next;!yl(s,r)&&gl(s,i,i.next,r)&&bl(s,r)&&bl(r,s)&&(e.push(s.i,i.i,r.i),Ml(i),Ml(i.next),i=t=r),i=i.next}while(i!==t);return tl(i)}function nl(t,e,i,s,r,n){let a=t;do{let t=a.next.next;for(;t!==a.prev;){if(a.i!==t.i&&pl(a,t)){let o=vl(a,t);return a=tl(a,a.next),o=tl(o,o.next),el(a,e,i,s,r,n,0),void el(o,e,i,s,r,n,0)}t=t.next}a=a.next}while(a!==t)}function al(t,e){let i=t.x-e.x;if(0===i&&(i=t.y-e.y,0===i)){i=(t.next.y-t.y)/(t.next.x-t.x)-(e.next.y-e.y)/(e.next.x-e.x)}return i}function ol(t,e){const i=function(t,e){let i=e;const s=t.x,r=t.y;let n,a=-1/0;if(yl(t,i))return i;do{if(yl(t,i.next))return i.next;if(r<=i.y&&r>=i.next.y&&i.next.y!==i.y){const t=i.x+(r-i.y)*(i.next.x-i.x)/(i.next.y-i.y);if(t<=s&&t>a&&(a=t,n=i.x=i.x&&i.x>=h&&s!==i.x&&ul(rn.x||i.x===n.x&&hl(n,i)))&&(n=i,c=e)}i=i.next}while(i!==o);return n}(t,e);if(!i)return e;const s=vl(i,t);return tl(s,s.next),tl(i,i.next)}function hl(t,e){return ml(t.prev,t,e.prev)<0&&ml(e.next,t,t.next)<0}function ll(t,e,i,s,r){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=(t-i)*r|0)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=(e-s)*r|0)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function cl(t){let e=t,i=t;do{(e.x=(t-a)*(n-o)&&(t-a)*(s-o)>=(i-a)*(e-o)&&(i-a)*(n-o)>=(r-a)*(s-o)}function dl(t,e,i,s,r,n,a,o){return!(t===a&&e===o)&&ul(t,e,i,s,r,n,a,o)}function pl(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){let i=t;do{if(i.i!==t.i&&i.next.i!==t.i&&i.i!==e.i&&i.next.i!==e.i&&gl(i,i.next,t,e))return!0;i=i.next}while(i!==t);return!1}(t,e)&&(bl(t,e)&&bl(e,t)&&function(t,e){let i=t,s=!1;const r=(t.x+e.x)/2,n=(t.y+e.y)/2;do{i.y>n!=i.next.y>n&&i.next.y!==i.y&&r<(i.next.x-i.x)*(n-i.y)/(i.next.y-i.y)+i.x&&(s=!s),i=i.next}while(i!==t);return s}(t,e)&&(ml(t.prev,t,e.prev)||ml(t,e.prev,e))||yl(t,e)&&ml(t.prev,t,t.next)>0&&ml(e.prev,e,e.next)>0)}function ml(t,e,i){return(e.y-t.y)*(i.x-e.x)-(e.x-t.x)*(i.y-e.y)}function yl(t,e){return t.x===e.x&&t.y===e.y}function gl(t,e,i,s){const r=xl(ml(t,e,i)),n=xl(ml(t,e,s)),a=xl(ml(i,s,t)),o=xl(ml(i,s,e));return r!==n&&a!==o||(!(0!==r||!fl(t,i,e))||(!(0!==n||!fl(t,s,e))||(!(0!==a||!fl(i,t,s))||!(0!==o||!fl(i,e,s)))))}function fl(t,e,i){return e.x<=Math.max(t.x,i.x)&&e.x>=Math.min(t.x,i.x)&&e.y<=Math.max(t.y,i.y)&&e.y>=Math.min(t.y,i.y)}function xl(t){return t>0?1:t<0?-1:0}function bl(t,e){return ml(t.prev,t,t.next)<0?ml(t,e,t.next)>=0&&ml(t,t.prev,e)>=0:ml(t,e,t.prev)<0||ml(t,t.next,e)<0}function vl(t,e){const i=Sl(t.i,t.x,t.y),s=Sl(e.i,e.x,e.y),r=t.next,n=e.prev;return t.next=e,e.prev=t,i.next=r,r.prev=i,s.next=i,i.prev=s,n.next=s,s.prev=n,s}function wl(t,e,i,s){const r=Sl(t,e,i);return s?(r.next=s.next,r.prev=s,s.next.prev=r,s.next=r):(r.prev=r,r.next=r),r}function Ml(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function Sl(t,e,i){return{i:t,x:e,y:i,prev:null,next:null,z:0,prevZ:null,nextZ:null,steiner:!1}}class _l{static triangulate(t,e,i=2){return Qh(t,e,i)}}class Al{static area(t){const e=t.length;let i=0;for(let s=e-1,r=0;r2&&t[e-1].equals(t[0])&&t.pop()}function zl(t,e){for(let i=0;iNumber.EPSILON){const u=Math.sqrt(c),d=Math.sqrt(h*h+l*l),p=e.x-o/u,m=e.y+a/u,y=((i.x-l/d-p)*l-(i.y+h/d-m)*h)/(a*l-o*h);s=p+a*y-t.x,r=m+o*y-t.y;const g=s*s+r*r;if(g<=2)return new _s(s,r);n=Math.sqrt(g/2)}else{let t=!1;a>Number.EPSILON?h>Number.EPSILON&&(t=!0):a<-Number.EPSILON?h<-Number.EPSILON&&(t=!0):Math.sign(o)===Math.sign(l)&&(t=!0),t?(s=-o,r=a,n=Math.sqrt(c)):(s=a,r=o,n=Math.sqrt(c/2))}return new _s(s/n,r/n)}const k=[];for(let t=0,e=z.length,i=e-1,s=t+1;t=0;t--){const e=t/p,i=c*Math.cos(e*Math.PI/2),s=u*Math.sin(e*Math.PI/2)+d;for(let t=0,e=z.length;t=0;){const s=i;let r=i-1;r<0&&(r=t.length-1);for(let t=0,i=o+2*p;t0)&&d.push(e,r,h),(t!==i-1||o0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader,e.lights=this.lights,e.clipping=this.clipping;const i={};for(const t in this.extensions)!0===this.extensions[t]&&(i[t]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}}class $l extends Gl{constructor(t){super(t),this.isRawShaderMaterial=!0,this.type="RawShaderMaterial"}}class Ql extends Zn{constructor(t){super(),this.isMeshStandardMaterial=!0,this.type="MeshStandardMaterial",this.defines={STANDARD:""},this.color=new Pr(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Pr(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new _s(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapRotation=new hr,this.envMapIntensity=1,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapRotation.copy(t.envMapRotation),this.envMapIntensity=t.envMapIntensity,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this.fog=t.fog,this}}class Kl extends Ql{constructor(t){super(),this.isMeshPhysicalMaterial=!0,this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.anisotropyRotation=0,this.anisotropyMap=null,this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new _s(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return xs(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(t){this.ior=(1+.4*t)/(1-.4*t)}}),this.iridescenceMap=null,this.iridescenceIOR=1.3,this.iridescenceThicknessRange=[100,400],this.iridescenceThicknessMap=null,this.sheenColor=new Pr(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=1/0,this.attenuationColor=new Pr(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new Pr(1,1,1),this.specularColorMap=null,this._anisotropy=0,this._clearcoat=0,this._dispersion=0,this._iridescence=0,this._sheen=0,this._transmission=0,this.setValues(t)}get anisotropy(){return this._anisotropy}set anisotropy(t){this._anisotropy>0!=t>0&&this.version++,this._anisotropy=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get iridescence(){return this._iridescence}set iridescence(t){this._iridescence>0!=t>0&&this.version++,this._iridescence=t}get dispersion(){return this._dispersion}set dispersion(t){this._dispersion>0!=t>0&&this.version++,this._dispersion=t}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.anisotropy=t.anisotropy,this.anisotropyRotation=t.anisotropyRotation,this.anisotropyMap=t.anisotropyMap,this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.dispersion=t.dispersion,this.ior=t.ior,this.iridescence=t.iridescence,this.iridescenceMap=t.iridescenceMap,this.iridescenceIOR=t.iridescenceIOR,this.iridescenceThicknessRange=[...t.iridescenceThicknessRange],this.iridescenceThicknessMap=t.iridescenceThicknessMap,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}}class tc extends Zn{constructor(t){super(),this.isMeshPhongMaterial=!0,this.type="MeshPhongMaterial",this.color=new Pr(16777215),this.specular=new Pr(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Pr(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new _s(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.envMapRotation=new hr,this.combine=0,this.reflectivity=1,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapRotation.copy(t.envMapRotation),this.combine=t.combine,this.reflectivity=t.reflectivity,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this.fog=t.fog,this}}class ec extends Zn{constructor(t){super(),this.isMeshToonMaterial=!0,this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new Pr(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Pr(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new _s(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.fog=t.fog,this}}class ic extends Zn{constructor(t){super(),this.isMeshNormalMaterial=!0,this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new _s(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}}class sc extends Zn{constructor(t){super(),this.isMeshLambertMaterial=!0,this.type="MeshLambertMaterial",this.color=new Pr(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Pr(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new _s(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.envMapRotation=new hr,this.combine=0,this.reflectivity=1,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapRotation.copy(t.envMapRotation),this.combine=t.combine,this.reflectivity=t.reflectivity,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this.fog=t.fog,this}}class rc extends Zn{constructor(t){super(),this.isMeshDepthMaterial=!0,this.type="MeshDepthMaterial",this.depthPacking=3200,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}}class nc extends Zn{constructor(t){super(),this.isMeshDistanceMaterial=!0,this.type="MeshDistanceMaterial",this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.setValues(t)}copy(t){return super.copy(t),this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}}class ac extends Zn{constructor(t){super(),this.isMeshMatcapMaterial=!0,this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new Pr(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new _s(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this.fog=t.fog,this}}class oc extends Eo{constructor(t){super(),this.isLineDashedMaterial=!0,this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}}function hc(t,e){return t&&t.constructor!==e?"number"==typeof e.BYTES_PER_ELEMENT?new e(t):Array.prototype.slice.call(t):t}function lc(t){const e=t.length,i=new Array(e);for(let t=0;t!==e;++t)i[t]=t;return i.sort(function(e,i){return t[e]-t[i]}),i}function cc(t,e,i){const s=t.length,r=new t.constructor(s);for(let n=0,a=0;a!==s;++n){const s=i[n]*e;for(let i=0;i!==e;++i)r[a++]=t[s+i]}return r}function uc(t,e,i,s){let r=1,n=t[0];for(;void 0!==n&&void 0===n[s];)n=t[r++];if(void 0===n)return;let a=n[s];if(void 0!==a)if(Array.isArray(a))do{a=n[s],void 0!==a&&(e.push(n.time),i.push(...a)),n=t[r++]}while(void 0!==n);else if(void 0!==a.toArray)do{a=n[s],void 0!==a&&(e.push(n.time),a.toArray(i,i.length)),n=t[r++]}while(void 0!==n);else do{a=n[s],void 0!==a&&(e.push(n.time),i.push(a)),n=t[r++]}while(void 0!==n)}class dc{static convertArray(t,e){return hc(t,e)}static isTypedArray(t){return $i(t)}static getKeyframeOrder(t){return lc(t)}static sortedArray(t,e,i){return cc(t,e,i)}static flattenJSON(t,e,i,s){uc(t,e,i,s)}static subclip(t,e,i,s,r=30){return function(t,e,i,s,r=30){const n=t.clone();n.name=e;const a=[];for(let t=0;t=s)){h.push(e.times[t]);for(let i=0;in.tracks[t].times[0]&&(o=n.tracks[t].times[0]);for(let t=0;t=s.times[u]){const t=u*h+o,e=t+h-o;d=s.values.slice(t,e)}else{const t=s.createInterpolant(),e=o,i=h-o;t.evaluate(n),d=t.resultBuffer.slice(e,i)}"quaternion"===r&&(new As).fromArray(d).normalize().conjugate().toArray(d);const p=a.times.length;for(let t=0;t=r)){const a=e[1];t=r)break e}n=i,i=0;break i}break t}for(;i>>1;te;)--n;if(++n,0!==r||n!==s){r>=n&&(n=Math.max(n,1),r=n-1);const t=this.getValueSize();this.times=i.slice(r,n),this.values=this.values.slice(r*t,n*t)}return this}validate(){let t=!0;const e=this.getValueSize();e-Math.floor(e)!==0&&(os("KeyframeTrack: Invalid value size in track.",this),t=!1);const i=this.times,s=this.values,r=i.length;0===r&&(os("KeyframeTrack: Track is empty.",this),t=!1);let n=null;for(let e=0;e!==r;e++){const s=i[e];if("number"==typeof s&&isNaN(s)){os("KeyframeTrack: Time is not a valid number.",this,e,s),t=!1;break}if(null!==n&&n>s){os("KeyframeTrack: Out of order keys.",this,e,s,n),t=!1;break}n=s}if(void 0!==s&&$i(s))for(let e=0,i=s.length;e!==i;++e){const i=s[e];if(isNaN(i)){os("KeyframeTrack: Value is not a valid number.",this,e,i),t=!1;break}}return t}optimize(){const t=this.times.slice(),e=this.values.slice(),i=this.getValueSize(),s=this.getInterpolation()===Le,r=t.length-1;let n=1;for(let a=1;a0){t[n]=t[r];for(let t=r*i,s=n*i,a=0;a!==i;++a)e[s+a]=e[t+a];++n}return n!==t.length?(this.times=t.slice(0,n),this.values=e.slice(0,n*i)):(this.times=t,this.values=e),this}clone(){const t=this.times.slice(),e=this.values.slice(),i=new(0,this.constructor)(this.name,t,e);return i.createInterpolant=this.createInterpolant,i}}xc.prototype.ValueTypeName="",xc.prototype.TimeBufferType=Float32Array,xc.prototype.ValueBufferType=Float32Array,xc.prototype.DefaultInterpolation=Ee;class bc extends xc{constructor(t,e,i){super(t,e,i)}}bc.prototype.ValueTypeName="bool",bc.prototype.ValueBufferType=Array,bc.prototype.DefaultInterpolation=Ve,bc.prototype.InterpolantFactoryMethodLinear=void 0,bc.prototype.InterpolantFactoryMethodSmooth=void 0;class vc extends xc{constructor(t,e,i,s){super(t,e,i,s)}}vc.prototype.ValueTypeName="color";class wc extends xc{constructor(t,e,i,s){super(t,e,i,s)}}wc.prototype.ValueTypeName="number";class Mc extends pc{constructor(t,e,i,s){super(t,e,i,s)}interpolate_(t,e,i,s){const r=this.resultBuffer,n=this.sampleValues,a=this.valueSize,o=(i-e)/(s-e);let h=t*a;for(let t=h+a;h!==t;h+=4)As.slerpFlat(r,0,n,h-a,n,h,o);return r}}class Sc extends xc{constructor(t,e,i,s){super(t,e,i,s)}InterpolantFactoryMethodLinear(t){return new Mc(this.times,this.values,this.getValueSize(),t)}}Sc.prototype.ValueTypeName="quaternion",Sc.prototype.InterpolantFactoryMethodSmooth=void 0;class _c extends xc{constructor(t,e,i){super(t,e,i)}}_c.prototype.ValueTypeName="string",_c.prototype.ValueBufferType=Array,_c.prototype.DefaultInterpolation=Ve,_c.prototype.InterpolantFactoryMethodLinear=void 0,_c.prototype.InterpolantFactoryMethodSmooth=void 0;class Ac extends xc{constructor(t,e,i,s){super(t,e,i,s)}}Ac.prototype.ValueTypeName="vector";class Tc{constructor(t="",e=-1,i=[],s=2500){this.name=t,this.tracks=i,this.duration=e,this.blendMode=s,this.uuid=fs(),this.userData={},this.duration<0&&this.resetDuration()}static parse(t){const e=[],i=t.tracks,s=1/(t.fps||1);for(let t=0,r=i.length;t!==r;++t)e.push(zc(i[t]).scale(s));const r=new this(t.name,t.duration,e,t.blendMode);return r.uuid=t.uuid,r.userData=JSON.parse(t.userData||"{}"),r}static toJSON(t){const e=[],i=t.tracks,s={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode,userData:JSON.stringify(t.userData)};for(let t=0,s=i.length;t!==s;++t)e.push(xc.toJSON(i[t]));return s}static CreateFromMorphTargetSequence(t,e,i,s){const r=e.length,n=[];for(let t=0;t1){const t=n[1];let e=s[t];e||(s[t]=e=[]),e.push(i)}}const n=[];for(const t in s)n.push(this.CreateFromMorphTargetSequence(t,s[t],e,i));return n}static parseAnimation(t,e){if(as("AnimationClip: parseAnimation() is deprecated and will be removed with r185"),!t)return os("AnimationClip: No animation in JSONLoader data."),null;const i=function(t,e,i,s,r){if(0!==i.length){const n=[],a=[];uc(i,n,a,s),0!==n.length&&r.push(new t(e,n,a))}},s=[],r=t.name||"default",n=t.fps||30,a=t.blendMode;let o=t.length||-1;const h=t.hierarchy||[];for(let t=0;t{e&&e(r),this.manager.itemEnd(t)},0);if(void 0!==Pc[t])return void Pc[t].push({onLoad:e,onProgress:i,onError:s});Pc[t]=[],Pc[t].push({onLoad:e,onProgress:i,onError:s});const n=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin",signal:"function"==typeof AbortSignal.any?AbortSignal.any([this._abortController.signal,this.manager.abortController.signal]):this._abortController.signal}),a=this.mimeType,o=this.responseType;fetch(n).then(e=>{if(200===e.status||0===e.status){if(0===e.status&&as("FileLoader: HTTP Status 0 received."),"undefined"==typeof ReadableStream||void 0===e.body||void 0===e.body.getReader)return e;const i=Pc[t],s=e.body.getReader(),r=e.headers.get("X-File-Size")||e.headers.get("Content-Length"),n=r?parseInt(r):0,a=0!==n;let o=0;const h=new ReadableStream({start(t){!function e(){s.read().then(({done:s,value:r})=>{if(s)t.close();else{o+=r.byteLength;const s=new ProgressEvent("progress",{lengthComputable:a,loaded:o,total:n});for(let t=0,e=i.length;t{t.error(e)})}()}});return new Response(h)}throw new Rc(`fetch for "${e.url}" responded with ${e.status}: ${e.statusText}`,e)}).then(t=>{switch(o){case"arraybuffer":return t.arrayBuffer();case"blob":return t.blob();case"document":return t.text().then(t=>(new DOMParser).parseFromString(t,a));case"json":return t.json();default:if(""===a)return t.text();{const e=/charset="?([^;"\s]*)"?/i.exec(a),i=e&&e[1]?e[1].toLowerCase():void 0,s=new TextDecoder(i);return t.arrayBuffer().then(t=>s.decode(t))}}}).then(e=>{Cc.add(`file:${t}`,e);const i=Pc[t];delete Pc[t];for(let t=0,s=i.length;t{const i=Pc[t];if(void 0===i)throw this.manager.itemError(t),e;delete Pc[t];for(let t=0,s=i.length;t{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}abort(){return this._abortController.abort(),this._abortController=new AbortController,this}}class Vc extends Oc{constructor(t){super(t)}load(t,e,i,s){const r=this,n=new Nc(this.manager);n.setPath(this.path),n.setRequestHeader(this.requestHeader),n.setWithCredentials(this.withCredentials),n.load(t,function(i){try{e(r.parse(JSON.parse(i)))}catch(e){s?s(e):os(e),r.manager.itemError(t)}},i,s)}parse(t){const e=[];for(let i=0;i0:s.vertexColors=t.vertexColors),void 0!==t.uniforms)for(const e in t.uniforms){const r=t.uniforms[e];switch(s.uniforms[e]={},r.type){case"t":s.uniforms[e].value=i(r.value);break;case"c":s.uniforms[e].value=(new Pr).setHex(r.value);break;case"v2":s.uniforms[e].value=(new _s).fromArray(r.value);break;case"v3":s.uniforms[e].value=(new Ts).fromArray(r.value);break;case"v4":s.uniforms[e].value=(new Js).fromArray(r.value);break;case"m3":s.uniforms[e].value=(new Is).fromArray(r.value);break;case"m4":s.uniforms[e].value=(new Qs).fromArray(r.value);break;default:s.uniforms[e].value=r.value}}if(void 0!==t.defines&&(s.defines=t.defines),void 0!==t.vertexShader&&(s.vertexShader=t.vertexShader),void 0!==t.fragmentShader&&(s.fragmentShader=t.fragmentShader),void 0!==t.glslVersion&&(s.glslVersion=t.glslVersion),void 0!==t.extensions)for(const e in t.extensions)s.extensions[e]=t.extensions[e];if(void 0!==t.lights&&(s.lights=t.lights),void 0!==t.clipping&&(s.clipping=t.clipping),void 0!==t.size&&(s.size=t.size),void 0!==t.sizeAttenuation&&(s.sizeAttenuation=t.sizeAttenuation),void 0!==t.map&&(s.map=i(t.map)),void 0!==t.matcap&&(s.matcap=i(t.matcap)),void 0!==t.alphaMap&&(s.alphaMap=i(t.alphaMap)),void 0!==t.bumpMap&&(s.bumpMap=i(t.bumpMap)),void 0!==t.bumpScale&&(s.bumpScale=t.bumpScale),void 0!==t.normalMap&&(s.normalMap=i(t.normalMap)),void 0!==t.normalMapType&&(s.normalMapType=t.normalMapType),void 0!==t.normalScale){let e=t.normalScale;!1===Array.isArray(e)&&(e=[e,e]),s.normalScale=(new _s).fromArray(e)}return void 0!==t.displacementMap&&(s.displacementMap=i(t.displacementMap)),void 0!==t.displacementScale&&(s.displacementScale=t.displacementScale),void 0!==t.displacementBias&&(s.displacementBias=t.displacementBias),void 0!==t.roughnessMap&&(s.roughnessMap=i(t.roughnessMap)),void 0!==t.metalnessMap&&(s.metalnessMap=i(t.metalnessMap)),void 0!==t.emissiveMap&&(s.emissiveMap=i(t.emissiveMap)),void 0!==t.emissiveIntensity&&(s.emissiveIntensity=t.emissiveIntensity),void 0!==t.specularMap&&(s.specularMap=i(t.specularMap)),void 0!==t.specularIntensityMap&&(s.specularIntensityMap=i(t.specularIntensityMap)),void 0!==t.specularColorMap&&(s.specularColorMap=i(t.specularColorMap)),void 0!==t.envMap&&(s.envMap=i(t.envMap)),void 0!==t.envMapRotation&&s.envMapRotation.fromArray(t.envMapRotation),void 0!==t.envMapIntensity&&(s.envMapIntensity=t.envMapIntensity),void 0!==t.reflectivity&&(s.reflectivity=t.reflectivity),void 0!==t.refractionRatio&&(s.refractionRatio=t.refractionRatio),void 0!==t.lightMap&&(s.lightMap=i(t.lightMap)),void 0!==t.lightMapIntensity&&(s.lightMapIntensity=t.lightMapIntensity),void 0!==t.aoMap&&(s.aoMap=i(t.aoMap)),void 0!==t.aoMapIntensity&&(s.aoMapIntensity=t.aoMapIntensity),void 0!==t.gradientMap&&(s.gradientMap=i(t.gradientMap)),void 0!==t.clearcoatMap&&(s.clearcoatMap=i(t.clearcoatMap)),void 0!==t.clearcoatRoughnessMap&&(s.clearcoatRoughnessMap=i(t.clearcoatRoughnessMap)),void 0!==t.clearcoatNormalMap&&(s.clearcoatNormalMap=i(t.clearcoatNormalMap)),void 0!==t.clearcoatNormalScale&&(s.clearcoatNormalScale=(new _s).fromArray(t.clearcoatNormalScale)),void 0!==t.iridescenceMap&&(s.iridescenceMap=i(t.iridescenceMap)),void 0!==t.iridescenceThicknessMap&&(s.iridescenceThicknessMap=i(t.iridescenceThicknessMap)),void 0!==t.transmissionMap&&(s.transmissionMap=i(t.transmissionMap)),void 0!==t.thicknessMap&&(s.thicknessMap=i(t.thicknessMap)),void 0!==t.anisotropyMap&&(s.anisotropyMap=i(t.anisotropyMap)),void 0!==t.sheenColorMap&&(s.sheenColorMap=i(t.sheenColorMap)),void 0!==t.sheenRoughnessMap&&(s.sheenRoughnessMap=i(t.sheenRoughnessMap)),s}setTextures(t){return this.textures=t,this}createMaterialFromType(t){return mu.createMaterialFromType(t)}static createMaterialFromType(t){return new{ShadowMaterial:ql,SpriteMaterial:Gn,RawShaderMaterial:$l,ShaderMaterial:Gl,PointsMaterial:$o,MeshPhysicalMaterial:Kl,MeshStandardMaterial:Ql,MeshPhongMaterial:tc,MeshToonMaterial:ec,MeshNormalMaterial:ic,MeshLambertMaterial:sc,MeshDepthMaterial:rc,MeshDistanceMaterial:nc,MeshBasicMaterial:Ma,MeshMatcapMaterial:ac,LineDashedMaterial:oc,LineBasicMaterial:Eo,Material:Zn}[t]}}class yu{static extractUrlBase(t){const e=t.lastIndexOf("/");return-1===e?"./":t.slice(0,e+1)}static resolveURL(t,e){return"string"!=typeof t||""===t?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}}class gu extends Wn{constructor(){super(),this.isInstancedBufferGeometry=!0,this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}toJSON(){const t=super.toJSON();return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}class fu extends Oc{constructor(t){super(t)}load(t,e,i,s){const r=this,n=new Nc(r.manager);n.setPath(r.path),n.setRequestHeader(r.requestHeader),n.setWithCredentials(r.withCredentials),n.load(t,function(i){try{e(r.parse(JSON.parse(i)))}catch(e){s?s(e):os(e),r.manager.itemError(t)}},i,s)}parse(t){const e={},i={};function s(t,s){if(void 0!==e[s])return e[s];const r=t.interleavedBuffers[s],n=function(t,e){if(void 0!==i[e])return i[e];const s=t.arrayBuffers,r=s[e],n=new Uint32Array(r).buffer;return i[e]=n,n}(t,r.buffer),a=Gi(r.type,n),o=new qn(a,r.stride);return o.uuid=r.uuid,e[s]=o,o}const r=t.isInstancedBufferGeometry?new gu:new Wn,n=t.data.index;if(void 0!==n){const t=Gi(n.type,n.array);r.setIndex(new Mn(t,1))}const a=t.data.attributes;for(const e in a){const i=a[e];let n;if(i.isInterleavedBufferAttribute){const e=s(t.data,i.data);n=new Xn(e,i.itemSize,i.offset,i.normalized)}else{const t=Gi(i.type,i.array);n=new(i.isInstancedBufferAttribute?$a:Mn)(t,i.itemSize,i.normalized)}void 0!==i.name&&(n.name=i.name),void 0!==i.usage&&n.setUsage(i.usage),r.setAttribute(e,n)}const o=t.data.morphAttributes;if(o)for(const e in o){const i=o[e],n=[];for(let e=0,r=i.length;e0){const i=new Bc(e);r=new Fc(i),r.setCrossOrigin(this.crossOrigin);for(let e=0,i=t.length;e0){s=new Fc(this.manager),s.setCrossOrigin(this.crossOrigin);for(let e=0,s=t.length;e{let e=null,i=null;return void 0!==t.boundingBox&&(e=(new Qr).fromJSON(t.boundingBox)),void 0!==t.boundingSphere&&(i=(new Nn).fromJSON(t.boundingSphere)),{...t,boundingBox:e,boundingSphere:i}}),n._instanceInfo=t.instanceInfo,n._availableInstanceIds=t._availableInstanceIds,n._availableGeometryIds=t._availableGeometryIds,n._nextIndexStart=t.nextIndexStart,n._nextVertexStart=t.nextVertexStart,n._geometryCount=t.geometryCount,n._maxInstanceCount=t.maxInstanceCount,n._maxVertexCount=t.maxVertexCount,n._maxIndexCount=t.maxIndexCount,n._geometryInitialized=t.geometryInitialized,n._matricesTexture=c(t.matricesTexture.uuid),n._indirectTexture=c(t.indirectTexture.uuid),void 0!==t.colorsTexture&&(n._colorsTexture=c(t.colorsTexture.uuid)),void 0!==t.boundingSphere&&(n.boundingSphere=(new Nn).fromJSON(t.boundingSphere)),void 0!==t.boundingBox&&(n.boundingBox=(new Qr).fromJSON(t.boundingBox));break;case"LOD":n=new pa;break;case"Line":n=new Jo(h(t.geometry),l(t.material));break;case"LineLoop":n=new Go(h(t.geometry),l(t.material));break;case"LineSegments":n=new Zo(h(t.geometry),l(t.material));break;case"PointCloud":case"Points":n=new ih(h(t.geometry),l(t.material));break;case"Sprite":n=new la(l(t.material));break;case"Group":n=new Tr;break;case"Bone":n=new Xa;break;default:n=new Ar}if(n.uuid=t.uuid,void 0!==t.name&&(n.name=t.name),void 0!==t.matrix?(n.matrix.fromArray(t.matrix),void 0!==t.matrixAutoUpdate&&(n.matrixAutoUpdate=t.matrixAutoUpdate),n.matrixAutoUpdate&&n.matrix.decompose(n.position,n.quaternion,n.scale)):(void 0!==t.position&&n.position.fromArray(t.position),void 0!==t.rotation&&n.rotation.fromArray(t.rotation),void 0!==t.quaternion&&n.quaternion.fromArray(t.quaternion),void 0!==t.scale&&n.scale.fromArray(t.scale)),void 0!==t.up&&n.up.fromArray(t.up),void 0!==t.pivot&&(n.pivot=(new Ts).fromArray(t.pivot)),void 0!==t.morphTargetDictionary&&(n.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),void 0!==t.morphTargetInfluences&&(n.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.castShadow&&(n.castShadow=t.castShadow),void 0!==t.receiveShadow&&(n.receiveShadow=t.receiveShadow),t.shadow&&(void 0!==t.shadow.intensity&&(n.shadow.intensity=t.shadow.intensity),void 0!==t.shadow.bias&&(n.shadow.bias=t.shadow.bias),void 0!==t.shadow.normalBias&&(n.shadow.normalBias=t.shadow.normalBias),void 0!==t.shadow.radius&&(n.shadow.radius=t.shadow.radius),void 0!==t.shadow.mapSize&&n.shadow.mapSize.fromArray(t.shadow.mapSize),void 0!==t.shadow.camera&&(n.shadow.camera=this.parseObject(t.shadow.camera))),void 0!==t.visible&&(n.visible=t.visible),void 0!==t.frustumCulled&&(n.frustumCulled=t.frustumCulled),void 0!==t.renderOrder&&(n.renderOrder=t.renderOrder),void 0!==t.static&&(n.static=t.static),void 0!==t.userData&&(n.userData=t.userData),void 0!==t.layers&&(n.layers.mask=t.layers),void 0!==t.children){const a=t.children;for(let t=0;t{!0===Su.has(n)?(s&&s(Su.get(n)),r.manager.itemError(t),r.manager.itemEnd(t)):(e&&e(i),r.manager.itemEnd(t))}):void setTimeout(function(){e&&e(n),r.manager.itemEnd(t)},0);const a={};a.credentials="anonymous"===this.crossOrigin?"same-origin":"include",a.headers=this.requestHeader,a.signal="function"==typeof AbortSignal.any?AbortSignal.any([this._abortController.signal,this.manager.abortController.signal]):this._abortController.signal;const o=fetch(t,a).then(function(t){return t.blob()}).then(function(t){return createImageBitmap(t,Object.assign(r.options,{colorSpaceConversion:"none"}))}).then(function(i){Cc.add(`image-bitmap:${t}`,i),e&&e(i),r.manager.itemEnd(t)}).catch(function(e){s&&s(e),Su.set(o,e),Cc.remove(`image-bitmap:${t}`),r.manager.itemError(t),r.manager.itemEnd(t)});Cc.add(`image-bitmap:${t}`,o),r.manager.itemStart(t)}abort(){return this._abortController.abort(),this._abortController=new AbortController,this}}let Au;class Tu{static getContext(){return void 0===Au&&(Au=new(window.AudioContext||window.webkitAudioContext)),Au}static setContext(t){Au=t}}class zu extends Oc{constructor(t){super(t)}load(t,e,i,s){const r=this,n=new Nc(this.manager);function a(e){s?s(e):os(e),r.manager.itemError(t)}n.setResponseType("arraybuffer"),n.setPath(this.path),n.setRequestHeader(this.requestHeader),n.setWithCredentials(this.withCredentials),n.load(t,function(i){try{const s=i.slice(0),n=Tu.getContext(),o=t+"#decode";r.manager.itemStart(o),n.decodeAudioData(s,function(t){e(t),r.manager.itemEnd(o)}).catch(function(t){a(t),r.manager.itemEnd(o)})}catch(t){a(t)}},i,s)}}const Cu=new Qs,Iu=new Qs,Bu=new Qs;class ku{constructor(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new iu,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new iu,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}update(t){const e=this._cache;if(e.focus!==t.focus||e.fov!==t.fov||e.aspect!==t.aspect*this.aspect||e.near!==t.near||e.far!==t.far||e.zoom!==t.zoom||e.eyeSep!==this.eyeSep){e.focus=t.focus,e.fov=t.fov,e.aspect=t.aspect*this.aspect,e.near=t.near,e.far=t.far,e.zoom=t.zoom,e.eyeSep=this.eyeSep,Bu.copy(t.projectionMatrix);const i=e.eyeSep/2,s=i*e.near/e.focus,r=e.near*Math.tan(ys*e.fov*.5)/e.zoom;let n,a;Iu.elements[12]=-i,Cu.elements[12]=i,n=-r*e.aspect+s,a=r*e.aspect+s,Bu.elements[0]=2*e.near/(a-n),Bu.elements[8]=(a+n)/(a-n),this.cameraL.projectionMatrix.copy(Bu),n=-r*e.aspect-s,a=r*e.aspect-s,Bu.elements[0]=2*e.near/(a-n),Bu.elements[8]=(a+n)/(a-n),this.cameraR.projectionMatrix.copy(Bu)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply(Iu),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(Cu)}}const Ou=-90;class Pu extends Ar{constructor(t,e,i){super(),this.type="CubeCamera",this.renderTarget=i,this.coordinateSystem=null,this.activeMipmapLevel=0;const s=new iu(Ou,1,t,e);s.layers=this.layers,this.add(s);const r=new iu(Ou,1,t,e);r.layers=this.layers,this.add(r);const n=new iu(Ou,1,t,e);n.layers=this.layers,this.add(n);const a=new iu(Ou,1,t,e);a.layers=this.layers,this.add(a);const o=new iu(Ou,1,t,e);o.layers=this.layers,this.add(o);const h=new iu(Ou,1,t,e);h.layers=this.layers,this.add(h)}updateCoordinateSystem(){const t=this.coordinateSystem,e=this.children.concat(),[i,s,r,n,a,o]=e;for(const t of e)this.remove(t);if(t===Wi)i.up.set(0,1,0),i.lookAt(1,0,0),s.up.set(0,1,0),s.lookAt(-1,0,0),r.up.set(0,0,-1),r.lookAt(0,1,0),n.up.set(0,0,1),n.lookAt(0,-1,0),a.up.set(0,1,0),a.lookAt(0,0,1),o.up.set(0,1,0),o.lookAt(0,0,-1);else{if(t!==qi)throw new Error("THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: "+t);i.up.set(0,-1,0),i.lookAt(-1,0,0),s.up.set(0,-1,0),s.lookAt(1,0,0),r.up.set(0,0,1),r.lookAt(0,1,0),n.up.set(0,0,-1),n.lookAt(0,-1,0),a.up.set(0,-1,0),a.lookAt(0,0,1),o.up.set(0,-1,0),o.lookAt(0,0,-1)}for(const t of e)this.add(t),t.updateMatrixWorld()}update(t,e){null===this.parent&&this.updateMatrixWorld();const{renderTarget:i,activeMipmapLevel:s}=this;this.coordinateSystem!==t.coordinateSystem&&(this.coordinateSystem=t.coordinateSystem,this.updateCoordinateSystem());const[r,n,a,o,h,l]=this.children,c=t.getRenderTarget(),u=t.getActiveCubeFace(),d=t.getActiveMipmapLevel(),p=t.xr.enabled;t.xr.enabled=!1;const m=i.texture.generateMipmaps;i.texture.generateMipmaps=!1;let y=!1;y=!0===t.isWebGLRenderer?t.state.buffers.depth.getReversed():t.reversedDepthBuffer,t.setRenderTarget(i,0,s),y&&!1===t.autoClear&&t.clearDepth(),t.render(e,r),t.setRenderTarget(i,1,s),y&&!1===t.autoClear&&t.clearDepth(),t.render(e,n),t.setRenderTarget(i,2,s),y&&!1===t.autoClear&&t.clearDepth(),t.render(e,a),t.setRenderTarget(i,3,s),y&&!1===t.autoClear&&t.clearDepth(),t.render(e,o),t.setRenderTarget(i,4,s),y&&!1===t.autoClear&&t.clearDepth(),t.render(e,h),i.texture.generateMipmaps=m,t.setRenderTarget(i,5,s),y&&!1===t.autoClear&&t.clearDepth(),t.render(e,l),t.setRenderTarget(c,u,d),t.xr.enabled=p,i.texture.needsPMREMUpdate=!0}}class Ru extends iu{constructor(t=[]){super(),this.isArrayCamera=!0,this.isMultiViewCamera=!1,this.cameras=t}}class Nu{constructor(){this._previousTime=0,this._currentTime=0,this._startTime=performance.now(),this._delta=0,this._elapsed=0,this._timescale=1,this._document=null,this._pageVisibilityHandler=null}connect(t){this._document=t,void 0!==t.hidden&&(this._pageVisibilityHandler=Vu.bind(this),t.addEventListener("visibilitychange",this._pageVisibilityHandler,!1))}disconnect(){null!==this._pageVisibilityHandler&&(this._document.removeEventListener("visibilitychange",this._pageVisibilityHandler),this._pageVisibilityHandler=null),this._document=null}getDelta(){return this._delta/1e3}getElapsed(){return this._elapsed/1e3}getTimescale(){return this._timescale}setTimescale(t){return this._timescale=t,this}reset(){return this._currentTime=performance.now()-this._startTime,this}dispose(){this.disconnect()}update(t){return null!==this._pageVisibilityHandler&&!0===this._document.hidden?this._delta=0:(this._previousTime=this._currentTime,this._currentTime=(void 0!==t?t:performance.now())-this._startTime,this._delta=(this._currentTime-this._previousTime)*this._timescale,this._elapsed+=this._delta),this}}function Vu(){!1===this._document.hidden&&this.reset()}const Eu=new Ts,Lu=new As,Fu=new Ts,ju=new Ts,Du=new Ts;class Uu extends Ar{constructor(){super(),this.type="AudioListener",this.context=Tu.getContext(),this.gain=this.context.createGain(),this.gain.connect(this.context.destination),this.filter=null,this.timeDelta=0,this._timer=new Nu}getInput(){return this.gain}removeFilter(){return null!==this.filter&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null),this}getFilter(){return this.filter}setFilter(t){return null!==this.filter?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination),this.filter=t,this.gain.connect(this.filter),this.filter.connect(this.context.destination),this}getMasterVolume(){return this.gain.gain.value}setMasterVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}updateMatrixWorld(t){super.updateMatrixWorld(t),this._timer.update();const e=this.context.listener;if(this.timeDelta=this._timer.getDelta(),this.matrixWorld.decompose(Eu,Lu,Fu),ju.set(0,0,-1).applyQuaternion(Lu),Du.set(0,1,0).applyQuaternion(Lu),e.positionX){const t=this.context.currentTime+this.timeDelta;e.positionX.linearRampToValueAtTime(Eu.x,t),e.positionY.linearRampToValueAtTime(Eu.y,t),e.positionZ.linearRampToValueAtTime(Eu.z,t),e.forwardX.linearRampToValueAtTime(ju.x,t),e.forwardY.linearRampToValueAtTime(ju.y,t),e.forwardZ.linearRampToValueAtTime(ju.z,t),e.upX.linearRampToValueAtTime(Du.x,t),e.upY.linearRampToValueAtTime(Du.y,t),e.upZ.linearRampToValueAtTime(Du.z,t)}else e.setPosition(Eu.x,Eu.y,Eu.z),e.setOrientation(ju.x,ju.y,ju.z,Du.x,Du.y,Du.z)}}class Wu extends Ar{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void as("Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void as("Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;const e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;as("Audio: this Audio has no playback control.")}stop(t=0){if(!1!==this.hasPlaybackControl)return this._progress=0,null!==this.source&&(this.source.stop(this.context.currentTime+t),this.source.onended=null),this.isPlaying=!1,this;as("Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t0&&this._mixBufferRegionAdditive(i,s,this._addIndex*e,1,e);for(let t=e,r=e+e;t!==r;++t)if(i[t]!==i[t+e]){a.setValue(i,s);break}}saveOriginalState(){const t=this.binding,e=this.buffer,i=this.valueSize,s=i*this._origIndex;t.getValue(e,s);for(let t=i,r=s;t!==r;++t)e[t]=e[s+t%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){const t=3*this.valueSize;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){const t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i=.5)for(let s=0;s!==r;++s)t[e+s]=t[i+s]}_slerp(t,e,i,s){As.slerpFlat(t,e,t,e,t,i,s)}_slerpAdditive(t,e,i,s,r){const n=this._workIndex*r;As.multiplyQuaternionsFlat(t,n,t,e,t,i),As.slerpFlat(t,e,t,e,t,n,s)}_lerp(t,e,i,s,r){const n=1-s;for(let a=0;a!==r;++a){const r=e+a;t[r]=t[r]*n+t[i+a]*s}}_lerpAdditive(t,e,i,s,r){for(let n=0;n!==r;++n){const r=e+n;t[r]=t[r]+t[i+n]*s}}}const $u="\\[\\]\\.:\\/",Qu=new RegExp("["+$u+"]","g"),Ku="[^"+$u+"]",td="[^"+$u.replace("\\.","")+"]",ed=new RegExp("^"+/((?:WC+[\/:])*)/.source.replace("WC",Ku)+/(WCOD+)?/.source.replace("WCOD",td)+/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",Ku)+/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",Ku)+"$"),id=["material","materials","bones","map"];class sd{constructor(t,e,i){this.path=e,this.parsedPath=i||sd.parseTrackName(e),this.node=sd.findNode(t,this.parsedPath.nodeName),this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,e,i){return t&&t.isAnimationObjectGroup?new sd.Composite(t,e,i):new sd(t,e,i)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(Qu,"")}static parseTrackName(t){const e=ed.exec(t);if(null===e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);const i={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},s=i.nodeName&&i.nodeName.lastIndexOf(".");if(void 0!==s&&-1!==s){const t=i.nodeName.substring(s+1);-1!==id.indexOf(t)&&(i.nodeName=i.nodeName.substring(0,s),i.objectName=t)}if(null===i.propertyName||0===i.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return i}static findNode(t,e){if(void 0===e||""===e||"."===e||-1===e||e===t.name||e===t.uuid)return t;if(t.skeleton){const i=t.skeleton.getBoneByName(e);if(void 0!==i)return i}if(t.children){const i=function(t){for(let s=0;s=r){const n=r++,l=t[n];e[l.uuid]=h,t[h]=l,e[o]=n,t[n]=a;for(let t=0,e=s;t!==e;++t){const e=i[t],s=e[n],r=e[h];e[h]=s,e[n]=r}}}this.nCachedObjects_=r}uncache(){const t=this._objects,e=this._indicesByUUID,i=this._bindings,s=i.length;let r=this.nCachedObjects_,n=t.length;for(let a=0,o=arguments.length;a!==o;++a){const o=arguments[a].uuid,h=e[o];if(void 0!==h)if(delete e[o],h0&&(e[a.uuid]=h),t[h]=a,t.pop();for(let t=0,e=s;t!==e;++t){const e=i[t];e[h]=e[r],e.pop()}}}this.nCachedObjects_=r}subscribe_(t,e){const i=this._bindingsIndicesByPath;let s=i[t];const r=this._bindings;if(void 0!==s)return r[s];const n=this._paths,a=this._parsedPaths,o=this._objects,h=o.length,l=this.nCachedObjects_,c=new Array(h);s=r.length,i[t]=s,n.push(t),a.push(e),r.push(c);for(let i=l,s=o.length;i!==s;++i){const s=o[i];c[i]=new sd(s,t,e)}return c}unsubscribe_(t){const e=this._bindingsIndicesByPath,i=e[t];if(void 0!==i){const s=this._paths,r=this._parsedPaths,n=this._bindings,a=n.length-1,o=n[a];e[t[a]]=i,n[i]=o,n.pop(),r[i]=r[a],r.pop(),s[i]=s[a],s.pop()}}}class nd{constructor(t,e,i=null,s=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=s;const r=e.tracks,n=r.length,a=new Array(n),o={endingStart:je,endingEnd:je};for(let t=0;t!==n;++t){const e=r[t].createInterpolant(null);a[t]=e,e.settings&&Object.assign(o,e.settings),e.settings=o}this._interpolantSettings=o,this._interpolants=a,this._propertyBindings=new Array(n),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i=!1){if(t.fadeOut(e),this.fadeIn(e),!0===i){const i=this._clip.duration,s=t._clip.duration,r=s/i,n=i/s;t.warp(1,r,e),this.warp(n,1,e)}return this}crossFadeTo(t,e,i=!1){return t.crossFadeFrom(this,e,i)}stopFading(){const t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){const s=this._mixer,r=s.time,n=this.timeScale;let a=this._timeScaleInterpolant;null===a&&(a=s._lendControlInterpolant(),this._timeScaleInterpolant=a);const o=a.parameterPositions,h=a.sampleValues;return o[0]=r,o[1]=r+i,h[0]=t/n,h[1]=e/n,this}stopWarping(){const t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,s){if(!this.enabled)return void this._updateWeight(t);const r=this._startTime;if(null!==r){const s=(t-r)*i;s<0||0===i?e=0:(this._startTime=null,e=i*s)}e*=this._updateTimeScale(t);const n=this._updateTime(e),a=this._updateWeight(t);if(a>0){const t=this._interpolants,e=this._propertyBindings;if(this.blendMode===qe)for(let i=0,s=t.length;i!==s;++i)t[i].evaluate(n),e[i].accumulateAdditive(a);else for(let i=0,r=t.length;i!==r;++i)t[i].evaluate(n),e[i].accumulate(s,a)}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;const i=this._weightInterpolant;if(null!==i){const s=i.evaluate(t)[0];e*=s,t>i.parameterPositions[1]&&(this.stopFading(),0===s&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;const i=this._timeScaleInterpolant;if(null!==i){e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e)}}return this._effectiveTimeScale=e,e}_updateTime(t){const e=this._clip.duration,i=this.loop;let s=this.time+t,r=this._loopCount;const n=2202===i;if(0===t)return-1===r||!n||1&~r?s:e-s;if(2200===i){-1===r&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(s>=e)s=e;else{if(!(s<0)){this.time=s;break t}s=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=s,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===r&&(t>=0?(r=0,this._setEndings(!0,0===this.repetitions,n)):this._setEndings(0===this.repetitions,!0,n)),s>=e||s<0){const i=Math.floor(s/e);s-=e*i,r+=Math.abs(i);const a=this.repetitions-r;if(a<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,s=t>0?e:0,this.time=s,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===a){const e=t<0;this._setEndings(e,!e,n)}else this._setEndings(!1,!1,n);this._loopCount=r,this.time=s,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:i})}}else this._loopCount=r,this.time=s;if(n&&!(1&~r))return e-s}return s}_setEndings(t,e,i){const s=this._interpolantSettings;i?(s.endingStart=De,s.endingEnd=De):(s.endingStart=t?this.zeroSlopeAtStart?De:je:Ue,s.endingEnd=e?this.zeroSlopeAtEnd?De:je:Ue)}_scheduleFading(t,e,i){const s=this._mixer,r=s.time;let n=this._weightInterpolant;null===n&&(n=s._lendControlInterpolant(),this._weightInterpolant=n);const a=n.parameterPositions,o=n.sampleValues;return a[0]=r,o[0]=e,a[1]=r+t,o[1]=i,this}}const ad=new Float32Array(1);class od extends ds{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1,"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}_bindAction(t,e){const i=t._localRoot||this._root,s=t._clip.tracks,r=s.length,n=t._propertyBindings,a=t._interpolants,o=i.uuid,h=this._bindingsByRootAndName;let l=h[o];void 0===l&&(l={},h[o]=l);for(let t=0;t!==r;++t){const r=s[t],h=r.name;let c=l[h];if(void 0!==c)++c.referenceCount,n[t]=c;else{if(c=n[t],void 0!==c){null===c._cacheIndex&&(++c.referenceCount,this._addInactiveBinding(c,o,h));continue}const s=e&&e._propertyBindings[t].binding.parsedPath;c=new Gu(sd.create(i,h,s),r.ValueTypeName,r.getValueSize()),++c.referenceCount,this._addInactiveBinding(c,o,h),n[t]=c}a[t].resultBuffer=c.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){const e=(t._localRoot||this._root).uuid,i=t._clip.uuid,s=this._actionsByClip[i];this._bindAction(t,s&&s.knownActions[0]),this._addInactiveAction(t,i,e)}const e=t._propertyBindings;for(let t=0,i=e.length;t!==i;++t){const i=e[t];0===i.useCount++&&(this._lendBinding(i),i.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){const e=t._propertyBindings;for(let t=0,i=e.length;t!==i;++t){const i=e[t];0===--i.useCount&&(i.restoreOriginalState(),this._takeBackBinding(i))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;const t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){const e=t._cacheIndex;return null!==e&&e=0;--e)t[e].stop();return this}update(t){t*=this.timeScale;const e=this._actions,i=this._nActiveActions,s=this.time+=t,r=Math.sign(t),n=this._accuIndex^=1;for(let a=0;a!==i;++a){e[a]._update(s,t,r,n)}const a=this._bindings,o=this._nActiveBindings;for(let t=0;t!==o;++t)a[t].apply(n);return this}setTime(t){this.time=0;for(let t=0;t=this.min.x&&t.x<=this.max.x&&t.y>=this.min.y&&t.y<=this.max.y}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return t.max.x>=this.min.x&&t.min.x<=this.max.x&&t.max.y>=this.min.y&&t.min.y<=this.max.y}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return this.clampPoint(t,Md).distanceTo(t)}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}const _d=new Ts,Ad=new Ts,Td=new Ts,zd=new Ts,Cd=new Ts,Id=new Ts,Bd=new Ts;class kd{constructor(t=new Ts,e=new Ts){this.start=t,this.end=e}set(t,e){return this.start.copy(t),this.end.copy(e),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,e){return this.delta(e).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,e){_d.subVectors(t,this.start),Ad.subVectors(this.end,this.start);const i=Ad.dot(Ad);if(0===i)return 0;let s=Ad.dot(_d)/i;return e&&(s=xs(s,0,1)),s}closestPointToPoint(t,e,i){const s=this.closestPointToPointParameter(t,e);return this.delta(i).multiplyScalar(s).add(this.start)}distanceSqToLine3(t,e=Id,i=Bd){const s=1e-8*1e-8;let r,n;const a=this.start,o=t.start,h=this.end,l=t.end;Td.subVectors(h,a),zd.subVectors(l,o),Cd.subVectors(a,o);const c=Td.dot(Td),u=zd.dot(zd),d=zd.dot(Cd);if(c<=s&&u<=s)return e.copy(a),i.copy(o),e.sub(i),e.dot(e);if(c<=s)r=0,n=d/u,n=xs(n,0,1);else{const t=Td.dot(Cd);if(u<=s)n=0,r=xs(-t/c,0,1);else{const e=Td.dot(zd),i=c*u-e*e;r=0!==i?xs((e*d-t*u)/i,0,1):0,n=(e*r+d)/u,n<0?(n=0,r=xs(-t/c,0,1)):n>1&&(n=1,r=xs((e-t)/c,0,1))}}return e.copy(a).addScaledVector(Td,r),i.copy(o).addScaledVector(zd,n),e.distanceToSquared(i)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return(new this.constructor).copy(this)}}const Od=new Ts;class Pd extends Ar{constructor(t,e){super(),this.light=t,this.matrixAutoUpdate=!1,this.color=e,this.type="SpotLightHelper";const i=new Wn,s=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(let t=0,e=1,i=32;t1)for(let i=0;i.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{rp.set(t.z,0,-t.x).normalize();const e=Math.acos(t.y);this.quaternion.setFromAxisAngle(rp,e)}}setLength(t,e=.2*t,i=.2*e){this.line.scale.set(1,Math.max(1e-4,t-e),1),this.line.updateMatrix(),this.cone.scale.set(i,e,i),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}dispose(){this.line.geometry.dispose(),this.line.material.dispose(),this.cone.geometry.dispose(),this.cone.material.dispose()}}class hp extends Zo{constructor(t=1){const e=[0,0,0,t,0,0,0,0,0,0,t,0,0,0,0,0,0,t],i=new Wn;i.setAttribute("position",new kn(e,3)),i.setAttribute("color",new kn([1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],3));super(i,new Eo({vertexColors:!0,toneMapped:!1})),this.type="AxesHelper"}setColors(t,e,i){const s=new Pr,r=this.geometry.attributes.color.array;return s.set(t),s.toArray(r,0),s.toArray(r,3),s.set(e),s.toArray(r,6),s.toArray(r,9),s.set(i),s.toArray(r,12),s.toArray(r,15),this.geometry.attributes.color.needsUpdate=!0,this}dispose(){this.geometry.dispose(),this.material.dispose()}}class lp{constructor(){this.type="ShapePath",this.color=new Pr,this.subPaths=[],this.currentPath=null}moveTo(t,e){return this.currentPath=new Gh,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,e),this}lineTo(t,e){return this.currentPath.lineTo(t,e),this}quadraticCurveTo(t,e,i,s){return this.currentPath.quadraticCurveTo(t,e,i,s),this}bezierCurveTo(t,e,i,s,r,n){return this.currentPath.bezierCurveTo(t,e,i,s,r,n),this}splineThru(t){return this.currentPath.splineThru(t),this}toShapes(t){function e(t,e){const i=e.length;let s=!1;for(let r=i-1,n=0;nNumber.EPSILON){if(h<0&&(i=e[n],o=-o,a=e[r],h=-h),t.ya.y)continue;if(t.y===i.y){if(t.x===i.x)return!0}else{const e=h*(t.x-i.x)-o*(t.y-i.y);if(0===e)return!0;if(e<0)continue;s=!s}}else{if(t.y!==i.y)continue;if(a.x<=t.x&&t.x<=i.x||i.x<=t.x&&t.x<=a.x)return!0}}return s}const i=Al.isClockWise,s=this.subPaths;if(0===s.length)return[];let r,n,a;const o=[];if(1===s.length)return n=s[0],a=new $h,a.curves=n.curves,o.push(a),o;let h=!i(s[0].getPoints());h=t?!h:h;const l=[],c=[];let u,d,p=[],m=0;c[m]=void 0,p[m]=[];for(let e=0,a=s.length;e1){let t=!1,i=0;for(let t=0,e=c.length;t0&&!1===t&&(p=l)}for(let t=0,e=c.length;te?(t.repeat.x=1,t.repeat.y=i/e,t.offset.x=0,t.offset.y=(1-t.repeat.y)/2):(t.repeat.x=e/i,t.repeat.y=1,t.offset.x=(1-t.repeat.x)/2,t.offset.y=0),t}(t,e)}static cover(t,e){return function(t,e){const i=t.image&&t.image.width?t.image.width/t.image.height:1;return i>e?(t.repeat.x=e/i,t.repeat.y=1,t.offset.x=(1-t.repeat.x)/2,t.offset.y=0):(t.repeat.x=1,t.repeat.y=i/e,t.offset.x=0,t.offset.y=(1-t.repeat.y)/2),t}(t,e)}static fill(t){return function(t){return t.repeat.x=1,t.repeat.y=1,t.offset.x=0,t.offset.y=0,t}(t)}static getByteLength(t,e,i,s){return up(t,e,i,s)}}"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:t}})),"undefined"!=typeof window&&(window.__THREE__?as("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=t);export{it as ACESFilmicToneMapping,w as AddEquation,$ as AddOperation,qe as AdditiveAnimationBlendMode,g as AdditiveBlending,rt as AgXToneMapping,jt as AlphaFormat,ki as AlwaysCompare,U as AlwaysDepth,Si as AlwaysStencilFunc,cu as AmbientLight,nd as AnimationAction,Tc as AnimationClip,Vc as AnimationLoader,od as AnimationMixer,rd as AnimationObjectGroup,dc as AnimationUtils,Bh as ArcCurve,Ru as ArrayCamera,op as ArrowHelper,at as AttachedBindMode,Wu as Audio,Zu as AudioAnalyser,Tu as AudioContext,Uu as AudioListener,zu as AudioLoader,hp as AxesHelper,d as BackSide,He as BasicDepthPacking,o as BasicShadowMap,Vo as BatchedMesh,fc as BezierInterpolant,Xa as Bone,bc as BooleanKeyframeTrack,Sd as Box2,Qr as Box3,ip as Box3Helper,gh as BoxGeometry,ep as BoxHelper,Mn as BufferAttribute,Wn as BufferGeometry,fu as BufferGeometryLoader,Ct as ByteType,Cc as Cache,Qc as Camera,Qd as CameraHelper,uh as CanvasTexture,fh as CapsuleGeometry,Eh as CatmullRomCurve3,et as CineonToneMapping,xh as CircleGeometry,yt as ClampToEdgeWrapping,xd as Clock,Pr as Color,vc as ColorKeyframeTrack,Rs as ColorManagement,Hi as Compatibility,hh as CompressedArrayTexture,lh as CompressedCubeTexture,oh as CompressedTexture,Ec as CompressedTextureLoader,vh as ConeGeometry,F as ConstantAlphaFactor,E as ConstantColorFactor,cp as Controls,Pu as CubeCamera,mh as CubeDepthTexture,lt as CubeReflectionMapping,ct as CubeRefractionMapping,ch as CubeTexture,jc as CubeTextureLoader,pt as CubeUVReflectionMapping,Dh as CubicBezierCurve,Uh as CubicBezierCurve3,mc as CubicInterpolant,r as CullFaceBack,n as CullFaceFront,a as CullFaceFrontBack,s as CullFaceNone,Ch as Curve,Zh as CurvePath,b as CustomBlending,st as CustomToneMapping,bh as CylinderGeometry,vd as Cylindrical,Gs as Data3DTexture,Hs as DataArrayTexture,Ya as DataTexture,Dc as DataTextureLoader,xn as DataUtils,di as DecrementStencilOp,mi as DecrementWrapStencilOp,kc as DefaultLoadingManager,Wt as DepthFormat,qt as DepthStencilFormat,ph as DepthTexture,ot as DetachedBindMode,lu as DirectionalLight,Zd as DirectionalLightHelper,gc as DiscreteInterpolant,Mh as DodecahedronGeometry,p as DoubleSide,O as DstAlphaFactor,R as DstColorFactor,Fi as DynamicCopyUsage,Pi as DynamicDrawUsage,Vi as DynamicReadUsage,zh as EdgesGeometry,Ih as EllipseCurve,Ti as EqualCompare,J as EqualDepth,xi as EqualStencilFunc,ut as EquirectangularReflectionMapping,dt as EquirectangularRefractionMapping,hr as Euler,ds as EventDispatcher,yh as ExternalTexture,Cl as ExtrudeGeometry,Nc as FileLoader,Bn as Float16BufferAttribute,kn as Float32BufferAttribute,Pt as FloatType,Vr as Fog,Nr as FogExp2,ah as FramebufferTexture,u as FrontSide,mo as Frustum,fo as FrustumArray,pd as GLBufferAttribute,Di as GLSL1,Ui as GLSL3,Ci as GreaterCompare,Y as GreaterDepth,Bi as GreaterEqualCompare,X as GreaterEqualDepth,Mi as GreaterEqualStencilFunc,vi as GreaterStencilFunc,qd as GridHelper,Tr as Group,dh as HTMLTexture,Rt as HalfFloatType,qc as HemisphereLight,Wd as HemisphereLightHelper,Bl as IcosahedronGeometry,_u as ImageBitmapLoader,Fc as ImageLoader,Ls as ImageUtils,ui as IncrementStencilOp,pi as IncrementWrapStencilOp,$a as InstancedBufferAttribute,gu as InstancedBufferGeometry,dd as InstancedInterleavedBuffer,no as InstancedMesh,Tn as Int16BufferAttribute,Cn as Int32BufferAttribute,Sn as Int8BufferAttribute,kt as IntType,qn as InterleavedBuffer,Xn as InterleavedBufferAttribute,pc as Interpolant,Fe as InterpolateBezier,Ve as InterpolateDiscrete,Ee as InterpolateLinear,Le as InterpolateSmooth,Yi as InterpolationSamplingMode,Xi as InterpolationSamplingType,yi as InvertStencilOp,li as KeepStencilOp,xc as KeyframeTrack,pa as LOD,kl as LatheGeometry,lr as Layers,Ai as LessCompare,W as LessDepth,zi as LessEqualCompare,q as LessEqualDepth,bi as LessEqualStencilFunc,fi as LessStencilFunc,Wc as Light,pu as LightProbe,Jo as Line,kd as Line3,Eo as LineBasicMaterial,Wh as LineCurve,qh as LineCurve3,oc as LineDashedMaterial,Go as LineLoop,Zo as LineSegments,Mt as LinearFilter,yc as LinearInterpolant,Tt as LinearMipMapLinearFilter,_t as LinearMipMapNearestFilter,At as LinearMipmapLinearFilter,St as LinearMipmapNearestFilter,ii as LinearSRGBColorSpace,K as LinearToneMapping,si as LinearTransfer,Oc as Loader,yu as LoaderUtils,Bc as LoadingManager,Pe as LoopOnce,Ne as LoopPingPong,Re as LoopRepeat,e as MOUSE,Zn as Material,v as MaterialBlending,mu as MaterialLoader,Ss as MathUtils,wd as Matrix2,Is as Matrix3,Qs as Matrix4,A as MaxEquation,Ra as Mesh,Ma as MeshBasicMaterial,rc as MeshDepthMaterial,nc as MeshDistanceMaterial,sc as MeshLambertMaterial,ac as MeshMatcapMaterial,ic as MeshNormalMaterial,tc as MeshPhongMaterial,Kl as MeshPhysicalMaterial,Ql as MeshStandardMaterial,ec as MeshToonMaterial,_ as MinEquation,gt as MirroredRepeatWrapping,G as MixOperation,x as MultiplyBlending,Z as MultiplyOperation,ft as NearestFilter,wt as NearestMipMapLinearFilter,bt as NearestMipMapNearestFilter,vt as NearestMipmapLinearFilter,xt as NearestMipmapNearestFilter,nt as NeutralToneMapping,_i as NeverCompare,D as NeverDepth,gi as NeverStencilFunc,m as NoBlending,ti as NoColorSpace,ni as NoNormalPacking,Q as NoToneMapping,We as NormalAnimationBlendMode,y as NormalBlending,oi as NormalGAPacking,ai as NormalRGPacking,Ii as NotEqualCompare,H as NotEqualDepth,wi as NotEqualStencilFunc,wc as NumberKeyframeTrack,Ar as Object3D,bu as ObjectLoader,Ke as ObjectSpaceNormalMap,Ol as OctahedronGeometry,z as OneFactor,j as OneMinusConstantAlphaFactor,L as OneMinusConstantColorFactor,P as OneMinusDstAlphaFactor,N as OneMinusDstColorFactor,k as OneMinusSrcAlphaFactor,I as OneMinusSrcColorFactor,ou as OrthographicCamera,h as PCFShadowMap,l as PCFSoftShadowMap,Gh as Path,iu as PerspectiveCamera,lo as Plane,Pl as PlaneGeometry,sp as PlaneHelper,au as PointLight,Fd as PointLightHelper,ih as Points,$o as PointsMaterial,Jd as PolarGridHelper,wh as PolyhedronGeometry,Hu as PositionalAudio,sd as PropertyBinding,Gu as PropertyMixer,Jh as QuadraticBezierCurve,Xh as QuadraticBezierCurve3,As as Quaternion,Sc as QuaternionKeyframeTrack,Mc as QuaternionLinearInterpolant,he as R11_EAC_Format,gs as RAD2DEG,ke as RED_GREEN_RGTC2_Format,Ie as RED_RGTC1_Format,t as REVISION,ce as RG11_EAC_Format,Ze as RGBADepthPacking,Ut as RGBAFormat,Gt as RGBAIntegerFormat,Se as RGBA_ASTC_10x10_Format,ve as RGBA_ASTC_10x5_Format,we as RGBA_ASTC_10x6_Format,Me as RGBA_ASTC_10x8_Format,_e as RGBA_ASTC_12x10_Format,Ae as RGBA_ASTC_12x12_Format,de as RGBA_ASTC_4x4_Format,pe as RGBA_ASTC_5x4_Format,me as RGBA_ASTC_5x5_Format,ye as RGBA_ASTC_6x5_Format,ge as RGBA_ASTC_6x6_Format,fe as RGBA_ASTC_8x5_Format,xe as RGBA_ASTC_8x6_Format,be as RGBA_ASTC_8x8_Format,Te as RGBA_BPTC_Format,oe as RGBA_ETC2_EAC_Format,re as RGBA_PVRTC_2BPPV1_Format,se as RGBA_PVRTC_4BPPV1_Format,Qt as RGBA_S3TC_DXT1_Format,Kt as RGBA_S3TC_DXT3_Format,te as RGBA_S3TC_DXT5_Format,Ge as RGBDepthPacking,Dt as RGBFormat,Zt as RGBIntegerFormat,ze as RGB_BPTC_SIGNED_Format,Ce as RGB_BPTC_UNSIGNED_Format,ne as RGB_ETC1_Format,ae as RGB_ETC2_Format,ie as RGB_PVRTC_2BPPV1_Format,ee as RGB_PVRTC_4BPPV1_Format,$t as RGB_S3TC_DXT1_Format,$e as RGDepthPacking,Yt as RGFormat,Ht as RGIntegerFormat,$l as RawShaderMaterial,wa as Ray,yd as Raycaster,uu as RectAreaLight,Jt as RedFormat,Xt as RedIntegerFormat,tt as ReinhardToneMapping,Xs as RenderTarget,hd as RenderTarget3D,mt as RepeatWrapping,ci as ReplaceStencilOp,S as ReverseSubtractEquation,us as ReversedDepthFuncs,Rl as RingGeometry,le as SIGNED_R11_EAC_Format,Oe as SIGNED_RED_GREEN_RGTC2_Format,Be as SIGNED_RED_RGTC1_Format,ue as SIGNED_RG11_EAC_Format,ei as SRGBColorSpace,ri as SRGBTransfer,Er as Scene,Gl as ShaderMaterial,ql as ShadowMaterial,$h as Shape,Nl as ShapeGeometry,lp as ShapePath,Al as ShapeUtils,It as ShortType,Ga as Skeleton,Ed as SkeletonHelper,Ja as SkinnedMesh,js as Source,Nn as Sphere,Vl as SphereGeometry,bd as Spherical,du as SphericalHarmonics3,Yh as SplineCurve,ru as SpotLight,Pd as SpotLightHelper,la as Sprite,Gn as SpriteMaterial,B as SrcAlphaFactor,V as SrcAlphaSaturateFactor,C as SrcColorFactor,Li as StaticCopyUsage,Oi as StaticDrawUsage,Ni as StaticReadUsage,ku as StereoCamera,ji as StreamCopyUsage,Ri as StreamDrawUsage,Ei as StreamReadUsage,_c as StringKeyframeTrack,M as SubtractEquation,f as SubtractiveBlending,i as TOUCH,Qe as TangentSpaceNormalMap,El as TetrahedronGeometry,qs as Texture,Uc as TextureLoader,dp as TextureUtils,Nu as Timer,Ji as TimestampQuery,Ll as TorusGeometry,Fl as TorusKnotGeometry,$r as Triangle,Ye as TriangleFanDrawMode,Xe as TriangleStripDrawMode,Je as TrianglesDrawMode,jl as TubeGeometry,ht as UVMapping,zn as Uint16BufferAttribute,In as Uint32BufferAttribute,_n as Uint8BufferAttribute,An as Uint8ClampedBufferAttribute,ld as Uniform,ud as UniformsGroup,Zl as UniformsUtils,zt as UnsignedByteType,Ft as UnsignedInt101111Type,Et as UnsignedInt248Type,Lt as UnsignedInt5999Type,Ot as UnsignedIntType,Nt as UnsignedShort4444Type,Vt as UnsignedShort5551Type,Bt as UnsignedShortType,c as VSMShadowMap,_s as Vector2,Ts as Vector3,Js as Vector4,Ac as VectorKeyframeTrack,nh as VideoFrameTexture,rh as VideoTexture,$s as WebGL3DRenderTarget,Zs as WebGLArrayRenderTarget,Wi as WebGLCoordinateSystem,Ys as WebGLRenderTarget,qi as WebGPUCoordinateSystem,Cr as WebXRController,Dl as WireframeGeometry,Ue as WrapAroundEnding,je as ZeroCurvatureEnding,T as ZeroFactor,De as ZeroSlopeEnding,hi as ZeroStencilOp,Jl as cloneUniforms,Ki as createCanvasElement,Qi as createElementNS,os as error,up as getByteLength,ss as getConsoleFunction,Hl as getUnlitUniformColorSpace,$i as isTypedArray,rs as log,Xl as mergeUniforms,cs as probeAsync,is as setConsoleFunction,as as warn,hs as warnOnce,ls as yieldToMain}; diff --git a/web/js/three.min.js b/web/js/three.min.js deleted file mode 100644 index 16cbee7..0000000 --- a/web/js/three.min.js +++ /dev/null @@ -1,7 +0,0 @@ -console.warn('Scripts "build/three.js" and "build/three.min.js" are deprecated with r150+, and will be removed with r160. Please use ES Modules or alternatives: https://threejs.org/docs/index.html#manual/en/introduction/Installation'), -/** - * @license - * Copyright 2010-2023 Three.js Authors - * SPDX-License-Identifier: MIT - */ -function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).THREE={})}(this,(function(t){"use strict";const e="158",n=1,i=2,r=3,s=0,a=1,o=100,l=204,c=205,h=0,u=1,d=2,p=0,m=1,f=2,g=3,_=4,v=5,y="attached",x="detached",M=300,S=301,b=302,T=303,E=304,w=306,A=1e3,R=1001,C=1002,L=1003,P=1004,I=1005,U=1006,D=1007,N=1008,O=1009,F=1012,B=1013,z=1014,H=1015,G=1016,V=1017,k=1018,W=1020,X=1023,j=1026,q=1027,Y=1029,Z=1031,J=1033,K=33776,$=33777,Q=33778,tt=33779,et=35840,nt=35841,it=35842,rt=35843,st=37492,at=37496,ot=37808,lt=37809,ct=37810,ht=37811,ut=37812,dt=37813,pt=37814,mt=37815,ft=37816,gt=37817,_t=37818,vt=37819,yt=37820,xt=37821,Mt=36492,St=36494,bt=36495,Tt=36284,Et=36285,wt=36286,At=2300,Rt=2301,Ct=2302,Lt=2400,Pt=2401,It=2402,Ut=2500,Dt=2501,Nt=3e3,Ot=3001,Ft="",Bt="srgb",zt="srgb-linear",Ht="display-p3",Gt="display-p3-linear",Vt="linear",kt="srgb",Wt="rec709",Xt="p3",jt=7680,qt=35044,Yt="300 es",Zt=1035,Jt=2e3,Kt=2001;class $t{addEventListener(t,e){void 0===this._listeners&&(this._listeners={});const n=this._listeners;void 0===n[t]&&(n[t]=[]),-1===n[t].indexOf(e)&&n[t].push(e)}hasEventListener(t,e){if(void 0===this._listeners)return!1;const n=this._listeners;return void 0!==n[t]&&-1!==n[t].indexOf(e)}removeEventListener(t,e){if(void 0===this._listeners)return;const n=this._listeners[t];if(void 0!==n){const t=n.indexOf(e);-1!==t&&n.splice(t,1)}}dispatchEvent(t){if(void 0===this._listeners)return;const e=this._listeners[t.type];if(void 0!==e){t.target=this;const n=e.slice(0);for(let e=0,i=n.length;e>8&255]+Qt[t>>16&255]+Qt[t>>24&255]+"-"+Qt[255&e]+Qt[e>>8&255]+"-"+Qt[e>>16&15|64]+Qt[e>>24&255]+"-"+Qt[63&n|128]+Qt[n>>8&255]+"-"+Qt[n>>16&255]+Qt[n>>24&255]+Qt[255&i]+Qt[i>>8&255]+Qt[i>>16&255]+Qt[i>>24&255]).toLowerCase()}function re(t,e,n){return Math.max(e,Math.min(n,t))}function se(t,e){return(t%e+e)%e}function ae(t,e,n){return(1-n)*t+n*e}function oe(t){return 0==(t&t-1)&&0!==t}function le(t){return Math.pow(2,Math.ceil(Math.log(t)/Math.LN2))}function ce(t){return Math.pow(2,Math.floor(Math.log(t)/Math.LN2))}function he(t,e){switch(e.constructor){case Float32Array:return t;case Uint32Array:return t/4294967295;case Uint16Array:return t/65535;case Uint8Array:return t/255;case Int32Array:return Math.max(t/2147483647,-1);case Int16Array:return Math.max(t/32767,-1);case Int8Array:return Math.max(t/127,-1);default:throw new Error("Invalid component type.")}}function ue(t,e){switch(e.constructor){case Float32Array:return t;case Uint32Array:return Math.round(4294967295*t);case Uint16Array:return Math.round(65535*t);case Uint8Array:return Math.round(255*t);case Int32Array:return Math.round(2147483647*t);case Int16Array:return Math.round(32767*t);case Int8Array:return Math.round(127*t);default:throw new Error("Invalid component type.")}}const de={DEG2RAD:ee,RAD2DEG:ne,generateUUID:ie,clamp:re,euclideanModulo:se,mapLinear:function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},inverseLerp:function(t,e,n){return t!==e?(n-t)/(e-t):0},lerp:ae,damp:function(t,e,n,i){return ae(t,e,1-Math.exp(-n*i))},pingpong:function(t,e=1){return e-Math.abs(se(t,2*e)-e)},smoothstep:function(t,e,n){return t<=e?0:t>=n?1:(t=(t-e)/(n-e))*t*(3-2*t)},smootherstep:function(t,e,n){return t<=e?0:t>=n?1:(t=(t-e)/(n-e))*t*t*(t*(6*t-15)+10)},randInt:function(t,e){return t+Math.floor(Math.random()*(e-t+1))},randFloat:function(t,e){return t+Math.random()*(e-t)},randFloatSpread:function(t){return t*(.5-Math.random())},seededRandom:function(t){void 0!==t&&(te=t);let e=te+=1831565813;return e=Math.imul(e^e>>>15,1|e),e^=e+Math.imul(e^e>>>7,61|e),((e^e>>>14)>>>0)/4294967296},degToRad:function(t){return t*ee},radToDeg:function(t){return t*ne},isPowerOfTwo:oe,ceilPowerOfTwo:le,floorPowerOfTwo:ce,setQuaternionFromProperEuler:function(t,e,n,i,r){const s=Math.cos,a=Math.sin,o=s(n/2),l=a(n/2),c=s((e+i)/2),h=a((e+i)/2),u=s((e-i)/2),d=a((e-i)/2),p=s((i-e)/2),m=a((i-e)/2);switch(r){case"XYX":t.set(o*h,l*u,l*d,o*c);break;case"YZY":t.set(l*d,o*h,l*u,o*c);break;case"ZXZ":t.set(l*u,l*d,o*h,o*c);break;case"XZX":t.set(o*h,l*m,l*p,o*c);break;case"YXY":t.set(l*p,o*h,l*m,o*c);break;case"ZYZ":t.set(l*m,l*p,o*h,o*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+r)}},normalize:ue,denormalize:he};class pe{constructor(t=0,e=0){pe.prototype.isVector2=!0,this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t){return this.x+=t.x,this.y+=t.y,this}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t){return this.x-=t.x,this.y-=t.y,this}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){const e=this.x,n=this.y,i=t.elements;return this.x=i[0]*e+i[3]*n+i[6],this.y=i[1]*e+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}angleTo(t){const e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;const n=this.dot(t)/e;return Math.acos(re(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,n=this.y-t.y;return e*e+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e){return this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){const n=Math.cos(e),i=Math.sin(e),r=this.x-t.x,s=this.y-t.y;return this.x=r*n-s*i+t.x,this.y=r*i+s*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}}class me{constructor(t,e,n,i,r,s,a,o,l){me.prototype.isMatrix3=!0,this.elements=[1,0,0,0,1,0,0,0,1],void 0!==t&&this.set(t,e,n,i,r,s,a,o,l)}set(t,e,n,i,r,s,a,o,l){const c=this.elements;return c[0]=t,c[1]=i,c[2]=a,c[3]=e,c[4]=r,c[5]=o,c[6]=n,c[7]=s,c[8]=l,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){const e=this.elements,n=t.elements;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],e[6]=n[6],e[7]=n[7],e[8]=n[8],this}extractBasis(t,e,n){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){const e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const n=t.elements,i=e.elements,r=this.elements,s=n[0],a=n[3],o=n[6],l=n[1],c=n[4],h=n[7],u=n[2],d=n[5],p=n[8],m=i[0],f=i[3],g=i[6],_=i[1],v=i[4],y=i[7],x=i[2],M=i[5],S=i[8];return r[0]=s*m+a*_+o*x,r[3]=s*f+a*v+o*M,r[6]=s*g+a*y+o*S,r[1]=l*m+c*_+h*x,r[4]=l*f+c*v+h*M,r[7]=l*g+c*y+h*S,r[2]=u*m+d*_+p*x,r[5]=u*f+d*v+p*M,r[8]=u*g+d*y+p*S,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],s=t[4],a=t[5],o=t[6],l=t[7],c=t[8];return e*s*c-e*a*l-n*r*c+n*a*o+i*r*l-i*s*o}invert(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],s=t[4],a=t[5],o=t[6],l=t[7],c=t[8],h=c*s-a*l,u=a*o-c*r,d=l*r-s*o,p=e*h+n*u+i*d;if(0===p)return this.set(0,0,0,0,0,0,0,0,0);const m=1/p;return t[0]=h*m,t[1]=(i*l-c*n)*m,t[2]=(a*n-i*s)*m,t[3]=u*m,t[4]=(c*e-i*o)*m,t[5]=(i*r-a*e)*m,t[6]=d*m,t[7]=(n*o-l*e)*m,t[8]=(s*e-n*r)*m,this}transpose(){let t;const e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){const e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,n,i,r,s,a){const o=Math.cos(r),l=Math.sin(r);return this.set(n*o,n*l,-n*(o*s+l*a)+s+t,-i*l,i*o,-i*(-l*s+o*a)+a+e,0,0,1),this}scale(t,e){return this.premultiply(fe.makeScale(t,e)),this}rotate(t){return this.premultiply(fe.makeRotation(-t)),this}translate(t,e){return this.premultiply(fe.makeTranslation(t,e)),this}makeTranslation(t,e){return t.isVector2?this.set(1,0,t.x,0,1,t.y,0,0,1):this.set(1,0,t,0,1,e,0,0,1),this}makeRotation(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,-n,0,n,e,0,0,0,1),this}makeScale(t,e){return this.set(t,0,0,0,e,0,0,0,1),this}equals(t){const e=this.elements,n=t.elements;for(let t=0;t<9;t++)if(e[t]!==n[t])return!1;return!0}fromArray(t,e=0){for(let n=0;n<9;n++)this.elements[n]=t[n+e];return this}toArray(t=[],e=0){const n=this.elements;return t[e]=n[0],t[e+1]=n[1],t[e+2]=n[2],t[e+3]=n[3],t[e+4]=n[4],t[e+5]=n[5],t[e+6]=n[6],t[e+7]=n[7],t[e+8]=n[8],t}clone(){return(new this.constructor).fromArray(this.elements)}}const fe=new me;function ge(t){for(let e=t.length-1;e>=0;--e)if(t[e]>=65535)return!0;return!1}const _e={Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:Uint8ClampedArray,Int16Array:Int16Array,Uint16Array:Uint16Array,Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,Float64Array:Float64Array};function ve(t,e){return new _e[t](e)}function ye(t){return document.createElementNS("http://www.w3.org/1999/xhtml",t)}function xe(){const t=ye("canvas");return t.style.display="block",t}const Me={};function Se(t){t in Me||(Me[t]=!0,console.warn(t))}const be=(new me).set(.8224621,.177538,0,.0331941,.9668058,0,.0170827,.0723974,.9105199),Te=(new me).set(1.2249401,-.2249404,0,-.0420569,1.0420571,0,-.0196376,-.0786361,1.0982735),Ee={[zt]:{transfer:Vt,primaries:Wt,toReference:t=>t,fromReference:t=>t},[Bt]:{transfer:kt,primaries:Wt,toReference:t=>t.convertSRGBToLinear(),fromReference:t=>t.convertLinearToSRGB()},[Gt]:{transfer:Vt,primaries:Xt,toReference:t=>t.applyMatrix3(Te),fromReference:t=>t.applyMatrix3(be)},[Ht]:{transfer:kt,primaries:Xt,toReference:t=>t.convertSRGBToLinear().applyMatrix3(Te),fromReference:t=>t.applyMatrix3(be).convertLinearToSRGB()}},we=new Set([zt,Gt]),Ae={enabled:!0,_workingColorSpace:zt,get legacyMode(){return console.warn("THREE.ColorManagement: .legacyMode=false renamed to .enabled=true in r150."),!this.enabled},set legacyMode(t){console.warn("THREE.ColorManagement: .legacyMode=false renamed to .enabled=true in r150."),this.enabled=!t},get workingColorSpace(){return this._workingColorSpace},set workingColorSpace(t){if(!we.has(t))throw new Error(`Unsupported working color space, "${t}".`);this._workingColorSpace=t},convert:function(t,e,n){if(!1===this.enabled||e===n||!e||!n)return t;const i=Ee[e].toReference;return(0,Ee[n].fromReference)(i(t))},fromWorkingColorSpace:function(t,e){return this.convert(t,this._workingColorSpace,e)},toWorkingColorSpace:function(t,e){return this.convert(t,e,this._workingColorSpace)},getPrimaries:function(t){return Ee[t].primaries},getTransfer:function(t){return t===Ft?Vt:Ee[t].transfer}};function Re(t){return t<.04045?.0773993808*t:Math.pow(.9478672986*t+.0521327014,2.4)}function Ce(t){return t<.0031308?12.92*t:1.055*Math.pow(t,.41666)-.055}let Le;class Pe{static getDataURL(t){if(/^data:/i.test(t.src))return t.src;if("undefined"==typeof HTMLCanvasElement)return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===Le&&(Le=ye("canvas")),Le.width=t.width,Le.height=t.height;const n=Le.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),e=Le}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if("undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap){const e=ye("canvas");e.width=t.width,e.height=t.height;const n=e.getContext("2d");n.drawImage(t,0,0,t.width,t.height);const i=n.getImageData(0,0,t.width,t.height),r=i.data;for(let t=0;t0&&(n.userData=this.userData),e||(t.textures[this.uuid]=n),n}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==M)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case A:t.x=t.x-Math.floor(t.x);break;case R:t.x=t.x<0?0:1;break;case C:1===Math.abs(Math.floor(t.x)%2)?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case A:t.y=t.y-Math.floor(t.y);break;case R:t.y=t.y<0?0:1;break;case C:1===Math.abs(Math.floor(t.y)%2)?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&(this.version++,this.source.needsUpdate=!0)}get encoding(){return Se("THREE.Texture: Property .encoding has been replaced by .colorSpace."),this.colorSpace===Bt?Ot:Nt}set encoding(t){Se("THREE.Texture: Property .encoding has been replaced by .colorSpace."),this.colorSpace=t===Ot?Bt:Ft}}Oe.DEFAULT_IMAGE=null,Oe.DEFAULT_MAPPING=M,Oe.DEFAULT_ANISOTROPY=1;class Fe{constructor(t=0,e=0,n=0,i=1){Fe.prototype.isVector4=!0,this.x=t,this.y=e,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,n,i){return this.x=t,this.y=e,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t){return this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t){return this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){const e=this.x,n=this.y,i=this.z,r=this.w,s=t.elements;return this.x=s[0]*e+s[4]*n+s[8]*i+s[12]*r,this.y=s[1]*e+s[5]*n+s[9]*i+s[13]*r,this.z=s[2]*e+s[6]*n+s[10]*i+s[14]*r,this.w=s[3]*e+s[7]*n+s[11]*i+s[15]*r,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);const e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,n,i,r;const s=.01,a=.1,o=t.elements,l=o[0],c=o[4],h=o[8],u=o[1],d=o[5],p=o[9],m=o[2],f=o[6],g=o[10];if(Math.abs(c-u)o&&t>_?t_?o=0?1:-1,i=1-e*e;if(i>Number.EPSILON){const r=Math.sqrt(i),s=Math.atan2(r,e*n);t=Math.sin(t*s)/r,a=Math.sin(a*s)/r}const r=a*n;if(o=o*t+u*r,l=l*t+d*r,c=c*t+p*r,h=h*t+m*r,t===1-a){const t=1/Math.sqrt(o*o+l*l+c*c+h*h);o*=t,l*=t,c*=t,h*=t}}t[e]=o,t[e+1]=l,t[e+2]=c,t[e+3]=h}static multiplyQuaternionsFlat(t,e,n,i,r,s){const a=n[i],o=n[i+1],l=n[i+2],c=n[i+3],h=r[s],u=r[s+1],d=r[s+2],p=r[s+3];return t[e]=a*p+c*h+o*d-l*u,t[e+1]=o*p+c*u+l*h-a*d,t[e+2]=l*p+c*d+a*u-o*h,t[e+3]=c*p-a*h-o*u-l*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,n,i){return this._x=t,this._y=e,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){const n=t._x,i=t._y,r=t._z,s=t._order,a=Math.cos,o=Math.sin,l=a(n/2),c=a(i/2),h=a(r/2),u=o(n/2),d=o(i/2),p=o(r/2);switch(s){case"XYZ":this._x=u*c*h+l*d*p,this._y=l*d*h-u*c*p,this._z=l*c*p+u*d*h,this._w=l*c*h-u*d*p;break;case"YXZ":this._x=u*c*h+l*d*p,this._y=l*d*h-u*c*p,this._z=l*c*p-u*d*h,this._w=l*c*h+u*d*p;break;case"ZXY":this._x=u*c*h-l*d*p,this._y=l*d*h+u*c*p,this._z=l*c*p+u*d*h,this._w=l*c*h-u*d*p;break;case"ZYX":this._x=u*c*h-l*d*p,this._y=l*d*h+u*c*p,this._z=l*c*p-u*d*h,this._w=l*c*h+u*d*p;break;case"YZX":this._x=u*c*h+l*d*p,this._y=l*d*h+u*c*p,this._z=l*c*p-u*d*h,this._w=l*c*h-u*d*p;break;case"XZY":this._x=u*c*h-l*d*p,this._y=l*d*h-u*c*p,this._z=l*c*p+u*d*h,this._w=l*c*h+u*d*p;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+s)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){const n=e/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){const e=t.elements,n=e[0],i=e[4],r=e[8],s=e[1],a=e[5],o=e[9],l=e[2],c=e[6],h=e[10],u=n+a+h;if(u>0){const t=.5/Math.sqrt(u+1);this._w=.25/t,this._x=(c-o)*t,this._y=(r-l)*t,this._z=(s-i)*t}else if(n>a&&n>h){const t=2*Math.sqrt(1+n-a-h);this._w=(c-o)/t,this._x=.25*t,this._y=(i+s)/t,this._z=(r+l)/t}else if(a>h){const t=2*Math.sqrt(1+a-n-h);this._w=(r-l)/t,this._x=(i+s)/t,this._y=.25*t,this._z=(o+c)/t}else{const t=2*Math.sqrt(1+h-n-a);this._w=(s-i)/t,this._x=(r+l)/t,this._y=(o+c)/t,this._z=.25*t}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let n=t.dot(e)+1;return nMath.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(re(this.dot(t),-1,1)))}rotateTowards(t,e){const n=this.angleTo(t);if(0===n)return this;const i=Math.min(1,e/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t){return this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){const n=t._x,i=t._y,r=t._z,s=t._w,a=e._x,o=e._y,l=e._z,c=e._w;return this._x=n*c+s*a+i*l-r*o,this._y=i*c+s*o+r*a-n*l,this._z=r*c+s*l+n*o-i*a,this._w=s*c-n*a-i*o-r*l,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);const n=this._x,i=this._y,r=this._z,s=this._w;let a=s*t._w+n*t._x+i*t._y+r*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=s,this._x=n,this._y=i,this._z=r,this;const o=1-a*a;if(o<=Number.EPSILON){const t=1-e;return this._w=t*s+e*this._w,this._x=t*n+e*this._x,this._y=t*i+e*this._y,this._z=t*r+e*this._z,this.normalize(),this._onChangeCallback(),this}const l=Math.sqrt(o),c=Math.atan2(l,a),h=Math.sin((1-e)*c)/l,u=Math.sin(e*c)/l;return this._w=s*h+this._w*u,this._x=n*h+this._x*u,this._y=i*h+this._y*u,this._z=r*h+this._z*u,this._onChangeCallback(),this}slerpQuaternions(t,e,n){return this.copy(t).slerp(e,n)}random(){const t=Math.random(),e=Math.sqrt(1-t),n=Math.sqrt(t),i=2*Math.PI*Math.random(),r=2*Math.PI*Math.random();return this.set(e*Math.cos(i),n*Math.sin(r),n*Math.cos(r),e*Math.sin(i))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}toJSON(){return this.toArray()}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}*[Symbol.iterator](){yield this._x,yield this._y,yield this._z,yield this._w}}class ke{constructor(t=0,e=0,n=0){ke.prototype.isVector3=!0,this.x=t,this.y=e,this.z=n}set(t,e,n){return void 0===n&&(n=this.z),this.x=t,this.y=e,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t){return this.x+=t.x,this.y+=t.y,this.z+=t.z,this}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t){return this.x-=t.x,this.y-=t.y,this.z-=t.z,this}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return this.applyQuaternion(Xe.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(Xe.setFromAxisAngle(t,e))}applyMatrix3(t){const e=this.x,n=this.y,i=this.z,r=t.elements;return this.x=r[0]*e+r[3]*n+r[6]*i,this.y=r[1]*e+r[4]*n+r[7]*i,this.z=r[2]*e+r[5]*n+r[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){const e=this.x,n=this.y,i=this.z,r=t.elements,s=1/(r[3]*e+r[7]*n+r[11]*i+r[15]);return this.x=(r[0]*e+r[4]*n+r[8]*i+r[12])*s,this.y=(r[1]*e+r[5]*n+r[9]*i+r[13])*s,this.z=(r[2]*e+r[6]*n+r[10]*i+r[14])*s,this}applyQuaternion(t){const e=this.x,n=this.y,i=this.z,r=t.x,s=t.y,a=t.z,o=t.w,l=2*(s*i-a*n),c=2*(a*e-r*i),h=2*(r*n-s*e);return this.x=e+o*l+s*h-a*c,this.y=n+o*c+a*l-r*h,this.z=i+o*h+r*c-s*l,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){const e=this.x,n=this.y,i=this.z,r=t.elements;return this.x=r[0]*e+r[4]*n+r[8]*i,this.y=r[1]*e+r[5]*n+r[9]*i,this.z=r[2]*e+r[6]*n+r[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this.z=Math.trunc(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this.z=t.z+(e.z-t.z)*n,this}cross(t){return this.crossVectors(this,t)}crossVectors(t,e){const n=t.x,i=t.y,r=t.z,s=e.x,a=e.y,o=e.z;return this.x=i*o-r*a,this.y=r*s-n*o,this.z=n*a-i*s,this}projectOnVector(t){const e=t.lengthSq();if(0===e)return this.set(0,0,0);const n=t.dot(this)/e;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return We.copy(this).projectOnVector(t),this.sub(We)}reflect(t){return this.sub(We.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){const e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;const n=this.dot(t)/e;return Math.acos(re(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return e*e+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,n){const i=Math.sin(e)*t;return this.x=i*Math.sin(n),this.y=Math.cos(e)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,n){return this.x=t*Math.sin(e),this.y=n,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){const e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){const e=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=n,this.z=i,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}setFromEuler(t){return this.x=t._x,this.y=t._y,this.z=t._z,this}setFromColor(t){return this.x=t.r,this.y=t.g,this.z=t.b,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e){return this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){const t=2*(Math.random()-.5),e=Math.random()*Math.PI*2,n=Math.sqrt(1-t**2);return this.x=n*Math.cos(e),this.y=n*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}}const We=new ke,Xe=new Ve;class je{constructor(t=new ke(1/0,1/0,1/0),e=new ke(-1/0,-1/0,-1/0)){this.isBox3=!0,this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){this.makeEmpty();for(let e=0,n=t.length;ethis.max.x||t.ythis.max.y||t.zthis.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.xthis.max.x||t.max.ythis.max.y||t.max.zthis.max.z)}intersectsSphere(t){return this.clampPoint(t.center,Ye),Ye.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,n;return t.normal.x>0?(e=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),e<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(nn),rn.subVectors(this.max,nn),Je.subVectors(t.a,nn),Ke.subVectors(t.b,nn),$e.subVectors(t.c,nn),Qe.subVectors(Ke,Je),tn.subVectors($e,Ke),en.subVectors(Je,$e);let e=[0,-Qe.z,Qe.y,0,-tn.z,tn.y,0,-en.z,en.y,Qe.z,0,-Qe.x,tn.z,0,-tn.x,en.z,0,-en.x,-Qe.y,Qe.x,0,-tn.y,tn.x,0,-en.y,en.x,0];return!!on(e,Je,Ke,$e,rn)&&(e=[1,0,0,0,1,0,0,0,1],!!on(e,Je,Ke,$e,rn)&&(sn.crossVectors(Qe,tn),e=[sn.x,sn.y,sn.z],on(e,Je,Ke,$e,rn)))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return this.clampPoint(t,Ye).distanceTo(t)}getBoundingSphere(t){return this.isEmpty()?t.makeEmpty():(this.getCenter(t.center),t.radius=.5*this.getSize(Ye).length()),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(qe[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),qe[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),qe[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),qe[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),qe[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),qe[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),qe[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),qe[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(qe)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}const qe=[new ke,new ke,new ke,new ke,new ke,new ke,new ke,new ke],Ye=new ke,Ze=new je,Je=new ke,Ke=new ke,$e=new ke,Qe=new ke,tn=new ke,en=new ke,nn=new ke,rn=new ke,sn=new ke,an=new ke;function on(t,e,n,i,r){for(let s=0,a=t.length-3;s<=a;s+=3){an.fromArray(t,s);const a=r.x*Math.abs(an.x)+r.y*Math.abs(an.y)+r.z*Math.abs(an.z),o=e.dot(an),l=n.dot(an),c=i.dot(an);if(Math.max(-Math.max(o,l,c),Math.min(o,l,c))>a)return!1}return!0}const ln=new je,cn=new ke,hn=new ke;class un{constructor(t=new ke,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){const n=this.center;void 0!==e?n.copy(e):ln.setFromPoints(t).getCenter(n);let i=0;for(let e=0,r=t.length;ethis.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){if(this.isEmpty())return this.center.copy(t),this.radius=0,this;cn.subVectors(t,this.center);const e=cn.lengthSq();if(e>this.radius*this.radius){const t=Math.sqrt(e),n=.5*(t-this.radius);this.center.addScaledVector(cn,n/t),this.radius+=n}return this}union(t){return t.isEmpty()?this:this.isEmpty()?(this.copy(t),this):(!0===this.center.equals(t.center)?this.radius=Math.max(this.radius,t.radius):(hn.subVectors(t.center,this.center).setLength(t.radius),this.expandByPoint(cn.copy(t.center).add(hn)),this.expandByPoint(cn.copy(t.center).sub(hn))),this)}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}}const dn=new ke,pn=new ke,mn=new ke,fn=new ke,gn=new ke,_n=new ke,vn=new ke;class yn{constructor(t=new ke,e=new ke(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.origin).addScaledVector(this.direction,t)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,dn)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);const n=e.dot(this.direction);return n<0?e.copy(this.origin):e.copy(this.origin).addScaledVector(this.direction,n)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){const e=dn.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(dn.copy(this.origin).addScaledVector(this.direction,e),dn.distanceToSquared(t))}distanceSqToSegment(t,e,n,i){pn.copy(t).add(e).multiplyScalar(.5),mn.copy(e).sub(t).normalize(),fn.copy(this.origin).sub(pn);const r=.5*t.distanceTo(e),s=-this.direction.dot(mn),a=fn.dot(this.direction),o=-fn.dot(mn),l=fn.lengthSq(),c=Math.abs(1-s*s);let h,u,d,p;if(c>0)if(h=s*o-a,u=s*a-o,p=r*c,h>=0)if(u>=-p)if(u<=p){const t=1/c;h*=t,u*=t,d=h*(h+s*u+2*a)+u*(s*h+u+2*o)+l}else u=r,h=Math.max(0,-(s*u+a)),d=-h*h+u*(u+2*o)+l;else u=-r,h=Math.max(0,-(s*u+a)),d=-h*h+u*(u+2*o)+l;else u<=-p?(h=Math.max(0,-(-s*r+a)),u=h>0?-r:Math.min(Math.max(-r,-o),r),d=-h*h+u*(u+2*o)+l):u<=p?(h=0,u=Math.min(Math.max(-r,-o),r),d=u*(u+2*o)+l):(h=Math.max(0,-(s*r+a)),u=h>0?r:Math.min(Math.max(-r,-o),r),d=-h*h+u*(u+2*o)+l);else u=s>0?-r:r,h=Math.max(0,-(s*u+a)),d=-h*h+u*(u+2*o)+l;return n&&n.copy(this.origin).addScaledVector(this.direction,h),i&&i.copy(pn).addScaledVector(mn,u),d}intersectSphere(t,e){dn.subVectors(t.center,this.origin);const n=dn.dot(this.direction),i=dn.dot(dn)-n*n,r=t.radius*t.radius;if(i>r)return null;const s=Math.sqrt(r-i),a=n-s,o=n+s;return o<0?null:a<0?this.at(o,e):this.at(a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){const e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;const n=-(this.origin.dot(t.normal)+t.constant)/e;return n>=0?n:null}intersectPlane(t,e){const n=this.distanceToPlane(t);return null===n?null:this.at(n,e)}intersectsPlane(t){const e=t.distanceToPoint(this.origin);if(0===e)return!0;return t.normal.dot(this.direction)*e<0}intersectBox(t,e){let n,i,r,s,a,o;const l=1/this.direction.x,c=1/this.direction.y,h=1/this.direction.z,u=this.origin;return l>=0?(n=(t.min.x-u.x)*l,i=(t.max.x-u.x)*l):(n=(t.max.x-u.x)*l,i=(t.min.x-u.x)*l),c>=0?(r=(t.min.y-u.y)*c,s=(t.max.y-u.y)*c):(r=(t.max.y-u.y)*c,s=(t.min.y-u.y)*c),n>s||r>i?null:((r>n||isNaN(n))&&(n=r),(s=0?(a=(t.min.z-u.z)*h,o=(t.max.z-u.z)*h):(a=(t.max.z-u.z)*h,o=(t.min.z-u.z)*h),n>o||a>i?null:((a>n||n!=n)&&(n=a),(o=0?n:i,e)))}intersectsBox(t){return null!==this.intersectBox(t,dn)}intersectTriangle(t,e,n,i,r){gn.subVectors(e,t),_n.subVectors(n,t),vn.crossVectors(gn,_n);let s,a=this.direction.dot(vn);if(a>0){if(i)return null;s=1}else{if(!(a<0))return null;s=-1,a=-a}fn.subVectors(this.origin,t);const o=s*this.direction.dot(_n.crossVectors(fn,_n));if(o<0)return null;const l=s*this.direction.dot(gn.cross(fn));if(l<0)return null;if(o+l>a)return null;const c=-s*fn.dot(vn);return c<0?null:this.at(c/a,r)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}}class xn{constructor(t,e,n,i,r,s,a,o,l,c,h,u,d,p,m,f){xn.prototype.isMatrix4=!0,this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],void 0!==t&&this.set(t,e,n,i,r,s,a,o,l,c,h,u,d,p,m,f)}set(t,e,n,i,r,s,a,o,l,c,h,u,d,p,m,f){const g=this.elements;return g[0]=t,g[4]=e,g[8]=n,g[12]=i,g[1]=r,g[5]=s,g[9]=a,g[13]=o,g[2]=l,g[6]=c,g[10]=h,g[14]=u,g[3]=d,g[7]=p,g[11]=m,g[15]=f,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new xn).fromArray(this.elements)}copy(t){const e=this.elements,n=t.elements;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],e[6]=n[6],e[7]=n[7],e[8]=n[8],e[9]=n[9],e[10]=n[10],e[11]=n[11],e[12]=n[12],e[13]=n[13],e[14]=n[14],e[15]=n[15],this}copyPosition(t){const e=this.elements,n=t.elements;return e[12]=n[12],e[13]=n[13],e[14]=n[14],this}setFromMatrix3(t){const e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,n){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,e,n){return this.set(t.x,e.x,n.x,0,t.y,e.y,n.y,0,t.z,e.z,n.z,0,0,0,0,1),this}extractRotation(t){const e=this.elements,n=t.elements,i=1/Mn.setFromMatrixColumn(t,0).length(),r=1/Mn.setFromMatrixColumn(t,1).length(),s=1/Mn.setFromMatrixColumn(t,2).length();return e[0]=n[0]*i,e[1]=n[1]*i,e[2]=n[2]*i,e[3]=0,e[4]=n[4]*r,e[5]=n[5]*r,e[6]=n[6]*r,e[7]=0,e[8]=n[8]*s,e[9]=n[9]*s,e[10]=n[10]*s,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){const e=this.elements,n=t.x,i=t.y,r=t.z,s=Math.cos(n),a=Math.sin(n),o=Math.cos(i),l=Math.sin(i),c=Math.cos(r),h=Math.sin(r);if("XYZ"===t.order){const t=s*c,n=s*h,i=a*c,r=a*h;e[0]=o*c,e[4]=-o*h,e[8]=l,e[1]=n+i*l,e[5]=t-r*l,e[9]=-a*o,e[2]=r-t*l,e[6]=i+n*l,e[10]=s*o}else if("YXZ"===t.order){const t=o*c,n=o*h,i=l*c,r=l*h;e[0]=t+r*a,e[4]=i*a-n,e[8]=s*l,e[1]=s*h,e[5]=s*c,e[9]=-a,e[2]=n*a-i,e[6]=r+t*a,e[10]=s*o}else if("ZXY"===t.order){const t=o*c,n=o*h,i=l*c,r=l*h;e[0]=t-r*a,e[4]=-s*h,e[8]=i+n*a,e[1]=n+i*a,e[5]=s*c,e[9]=r-t*a,e[2]=-s*l,e[6]=a,e[10]=s*o}else if("ZYX"===t.order){const t=s*c,n=s*h,i=a*c,r=a*h;e[0]=o*c,e[4]=i*l-n,e[8]=t*l+r,e[1]=o*h,e[5]=r*l+t,e[9]=n*l-i,e[2]=-l,e[6]=a*o,e[10]=s*o}else if("YZX"===t.order){const t=s*o,n=s*l,i=a*o,r=a*l;e[0]=o*c,e[4]=r-t*h,e[8]=i*h+n,e[1]=h,e[5]=s*c,e[9]=-a*c,e[2]=-l*c,e[6]=n*h+i,e[10]=t-r*h}else if("XZY"===t.order){const t=s*o,n=s*l,i=a*o,r=a*l;e[0]=o*c,e[4]=-h,e[8]=l*c,e[1]=t*h+r,e[5]=s*c,e[9]=n*h-i,e[2]=i*h-n,e[6]=a*c,e[10]=r*h+t}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(bn,t,Tn)}lookAt(t,e,n){const i=this.elements;return An.subVectors(t,e),0===An.lengthSq()&&(An.z=1),An.normalize(),En.crossVectors(n,An),0===En.lengthSq()&&(1===Math.abs(n.z)?An.x+=1e-4:An.z+=1e-4,An.normalize(),En.crossVectors(n,An)),En.normalize(),wn.crossVectors(An,En),i[0]=En.x,i[4]=wn.x,i[8]=An.x,i[1]=En.y,i[5]=wn.y,i[9]=An.y,i[2]=En.z,i[6]=wn.z,i[10]=An.z,this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const n=t.elements,i=e.elements,r=this.elements,s=n[0],a=n[4],o=n[8],l=n[12],c=n[1],h=n[5],u=n[9],d=n[13],p=n[2],m=n[6],f=n[10],g=n[14],_=n[3],v=n[7],y=n[11],x=n[15],M=i[0],S=i[4],b=i[8],T=i[12],E=i[1],w=i[5],A=i[9],R=i[13],C=i[2],L=i[6],P=i[10],I=i[14],U=i[3],D=i[7],N=i[11],O=i[15];return r[0]=s*M+a*E+o*C+l*U,r[4]=s*S+a*w+o*L+l*D,r[8]=s*b+a*A+o*P+l*N,r[12]=s*T+a*R+o*I+l*O,r[1]=c*M+h*E+u*C+d*U,r[5]=c*S+h*w+u*L+d*D,r[9]=c*b+h*A+u*P+d*N,r[13]=c*T+h*R+u*I+d*O,r[2]=p*M+m*E+f*C+g*U,r[6]=p*S+m*w+f*L+g*D,r[10]=p*b+m*A+f*P+g*N,r[14]=p*T+m*R+f*I+g*O,r[3]=_*M+v*E+y*C+x*U,r[7]=_*S+v*w+y*L+x*D,r[11]=_*b+v*A+y*P+x*N,r[15]=_*T+v*R+y*I+x*O,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){const t=this.elements,e=t[0],n=t[4],i=t[8],r=t[12],s=t[1],a=t[5],o=t[9],l=t[13],c=t[2],h=t[6],u=t[10],d=t[14];return t[3]*(+r*o*h-i*l*h-r*a*u+n*l*u+i*a*d-n*o*d)+t[7]*(+e*o*d-e*l*u+r*s*u-i*s*d+i*l*c-r*o*c)+t[11]*(+e*l*h-e*a*d-r*s*h+n*s*d+r*a*c-n*l*c)+t[15]*(-i*a*c-e*o*h+e*a*u+i*s*h-n*s*u+n*o*c)}transpose(){const t=this.elements;let e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,n){const i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=e,i[14]=n),this}invert(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],s=t[4],a=t[5],o=t[6],l=t[7],c=t[8],h=t[9],u=t[10],d=t[11],p=t[12],m=t[13],f=t[14],g=t[15],_=h*f*l-m*u*l+m*o*d-a*f*d-h*o*g+a*u*g,v=p*u*l-c*f*l-p*o*d+s*f*d+c*o*g-s*u*g,y=c*m*l-p*h*l+p*a*d-s*m*d-c*a*g+s*h*g,x=p*h*o-c*m*o-p*a*u+s*m*u+c*a*f-s*h*f,M=e*_+n*v+i*y+r*x;if(0===M)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);const S=1/M;return t[0]=_*S,t[1]=(m*u*r-h*f*r-m*i*d+n*f*d+h*i*g-n*u*g)*S,t[2]=(a*f*r-m*o*r+m*i*l-n*f*l-a*i*g+n*o*g)*S,t[3]=(h*o*r-a*u*r-h*i*l+n*u*l+a*i*d-n*o*d)*S,t[4]=v*S,t[5]=(c*f*r-p*u*r+p*i*d-e*f*d-c*i*g+e*u*g)*S,t[6]=(p*o*r-s*f*r-p*i*l+e*f*l+s*i*g-e*o*g)*S,t[7]=(s*u*r-c*o*r+c*i*l-e*u*l-s*i*d+e*o*d)*S,t[8]=y*S,t[9]=(p*h*r-c*m*r-p*n*d+e*m*d+c*n*g-e*h*g)*S,t[10]=(s*m*r-p*a*r+p*n*l-e*m*l-s*n*g+e*a*g)*S,t[11]=(c*a*r-s*h*r-c*n*l+e*h*l+s*n*d-e*a*d)*S,t[12]=x*S,t[13]=(c*m*i-p*h*i+p*n*u-e*m*u-c*n*f+e*h*f)*S,t[14]=(p*a*i-s*m*i-p*n*o+e*m*o+s*n*f-e*a*f)*S,t[15]=(s*h*i-c*a*i+c*n*o-e*h*o-s*n*u+e*a*u)*S,this}scale(t){const e=this.elements,n=t.x,i=t.y,r=t.z;return e[0]*=n,e[4]*=i,e[8]*=r,e[1]*=n,e[5]*=i,e[9]*=r,e[2]*=n,e[6]*=i,e[10]*=r,e[3]*=n,e[7]*=i,e[11]*=r,this}getMaxScaleOnAxis(){const t=this.elements,e=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],n=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],i=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(e,n,i))}makeTranslation(t,e,n){return t.isVector3?this.set(1,0,0,t.x,0,1,0,t.y,0,0,1,t.z,0,0,0,1):this.set(1,0,0,t,0,1,0,e,0,0,1,n,0,0,0,1),this}makeRotationX(t){const e=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,e,-n,0,0,n,e,0,0,0,0,1),this}makeRotationY(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,0,n,0,0,1,0,0,-n,0,e,0,0,0,0,1),this}makeRotationZ(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,-n,0,0,n,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){const n=Math.cos(e),i=Math.sin(e),r=1-n,s=t.x,a=t.y,o=t.z,l=r*s,c=r*a;return this.set(l*s+n,l*a-i*o,l*o+i*a,0,l*a+i*o,c*a+n,c*o-i*s,0,l*o-i*a,c*o+i*s,r*o*o+n,0,0,0,0,1),this}makeScale(t,e,n){return this.set(t,0,0,0,0,e,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,e,n,i,r,s){return this.set(1,n,r,0,t,1,s,0,e,i,1,0,0,0,0,1),this}compose(t,e,n){const i=this.elements,r=e._x,s=e._y,a=e._z,o=e._w,l=r+r,c=s+s,h=a+a,u=r*l,d=r*c,p=r*h,m=s*c,f=s*h,g=a*h,_=o*l,v=o*c,y=o*h,x=n.x,M=n.y,S=n.z;return i[0]=(1-(m+g))*x,i[1]=(d+y)*x,i[2]=(p-v)*x,i[3]=0,i[4]=(d-y)*M,i[5]=(1-(u+g))*M,i[6]=(f+_)*M,i[7]=0,i[8]=(p+v)*S,i[9]=(f-_)*S,i[10]=(1-(u+m))*S,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,e,n){const i=this.elements;let r=Mn.set(i[0],i[1],i[2]).length();const s=Mn.set(i[4],i[5],i[6]).length(),a=Mn.set(i[8],i[9],i[10]).length();this.determinant()<0&&(r=-r),t.x=i[12],t.y=i[13],t.z=i[14],Sn.copy(this);const o=1/r,l=1/s,c=1/a;return Sn.elements[0]*=o,Sn.elements[1]*=o,Sn.elements[2]*=o,Sn.elements[4]*=l,Sn.elements[5]*=l,Sn.elements[6]*=l,Sn.elements[8]*=c,Sn.elements[9]*=c,Sn.elements[10]*=c,e.setFromRotationMatrix(Sn),n.x=r,n.y=s,n.z=a,this}makePerspective(t,e,n,i,r,s,a=2e3){const o=this.elements,l=2*r/(e-t),c=2*r/(n-i),h=(e+t)/(e-t),u=(n+i)/(n-i);let d,p;if(a===Jt)d=-(s+r)/(s-r),p=-2*s*r/(s-r);else{if(a!==Kt)throw new Error("THREE.Matrix4.makePerspective(): Invalid coordinate system: "+a);d=-s/(s-r),p=-s*r/(s-r)}return o[0]=l,o[4]=0,o[8]=h,o[12]=0,o[1]=0,o[5]=c,o[9]=u,o[13]=0,o[2]=0,o[6]=0,o[10]=d,o[14]=p,o[3]=0,o[7]=0,o[11]=-1,o[15]=0,this}makeOrthographic(t,e,n,i,r,s,a=2e3){const o=this.elements,l=1/(e-t),c=1/(n-i),h=1/(s-r),u=(e+t)*l,d=(n+i)*c;let p,m;if(a===Jt)p=(s+r)*h,m=-2*h;else{if(a!==Kt)throw new Error("THREE.Matrix4.makeOrthographic(): Invalid coordinate system: "+a);p=r*h,m=-1*h}return o[0]=2*l,o[4]=0,o[8]=0,o[12]=-u,o[1]=0,o[5]=2*c,o[9]=0,o[13]=-d,o[2]=0,o[6]=0,o[10]=m,o[14]=-p,o[3]=0,o[7]=0,o[11]=0,o[15]=1,this}equals(t){const e=this.elements,n=t.elements;for(let t=0;t<16;t++)if(e[t]!==n[t])return!1;return!0}fromArray(t,e=0){for(let n=0;n<16;n++)this.elements[n]=t[n+e];return this}toArray(t=[],e=0){const n=this.elements;return t[e]=n[0],t[e+1]=n[1],t[e+2]=n[2],t[e+3]=n[3],t[e+4]=n[4],t[e+5]=n[5],t[e+6]=n[6],t[e+7]=n[7],t[e+8]=n[8],t[e+9]=n[9],t[e+10]=n[10],t[e+11]=n[11],t[e+12]=n[12],t[e+13]=n[13],t[e+14]=n[14],t[e+15]=n[15],t}}const Mn=new ke,Sn=new xn,bn=new ke(0,0,0),Tn=new ke(1,1,1),En=new ke,wn=new ke,An=new ke,Rn=new xn,Cn=new Ve;class Ln{constructor(t=0,e=0,n=0,i=Ln.DEFAULT_ORDER){this.isEuler=!0,this._x=t,this._y=e,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,n,i=this._order){return this._x=t,this._y=e,this._z=n,this._order=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,n=!0){const i=t.elements,r=i[0],s=i[4],a=i[8],o=i[1],l=i[5],c=i[9],h=i[2],u=i[6],d=i[10];switch(e){case"XYZ":this._y=Math.asin(re(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-c,d),this._z=Math.atan2(-s,r)):(this._x=Math.atan2(u,l),this._z=0);break;case"YXZ":this._x=Math.asin(-re(c,-1,1)),Math.abs(c)<.9999999?(this._y=Math.atan2(a,d),this._z=Math.atan2(o,l)):(this._y=Math.atan2(-h,r),this._z=0);break;case"ZXY":this._x=Math.asin(re(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(-h,d),this._z=Math.atan2(-s,l)):(this._y=0,this._z=Math.atan2(o,r));break;case"ZYX":this._y=Math.asin(-re(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(u,d),this._z=Math.atan2(o,r)):(this._x=0,this._z=Math.atan2(-s,l));break;case"YZX":this._z=Math.asin(re(o,-1,1)),Math.abs(o)<.9999999?(this._x=Math.atan2(-c,l),this._y=Math.atan2(-h,r)):(this._x=0,this._y=Math.atan2(a,d));break;case"XZY":this._z=Math.asin(-re(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(u,l),this._y=Math.atan2(a,r)):(this._x=Math.atan2(-c,d),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!0===n&&this._onChangeCallback(),this}setFromQuaternion(t,e,n){return Rn.makeRotationFromQuaternion(t),this.setFromRotationMatrix(Rn,e,n)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return Cn.setFromEuler(this),this.setFromQuaternion(Cn,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}*[Symbol.iterator](){yield this._x,yield this._y,yield this._z,yield this._order}}Ln.DEFAULT_ORDER="XYZ";class Pn{constructor(){this.mask=1}set(t){this.mask=(1<>>0}enable(t){this.mask|=1<1){for(let t=0;t1){for(let t=0;t0&&(n=n.concat(r))}return n}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Fn,t,Bn),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Fn,zn,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);const e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);const e=this.children;for(let n=0,i=e.length;n0&&(i.userData=this.userData),i.layers=this.layers.mask,i.matrix=this.matrix.toArray(),i.up=this.up.toArray(),!1===this.matrixAutoUpdate&&(i.matrixAutoUpdate=!1),this.isInstancedMesh&&(i.type="InstancedMesh",i.count=this.count,i.instanceMatrix=this.instanceMatrix.toJSON(),null!==this.instanceColor&&(i.instanceColor=this.instanceColor.toJSON())),this.isScene)this.background&&(this.background.isColor?i.background=this.background.toJSON():this.background.isTexture&&(i.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&!0!==this.environment.isRenderTargetTexture&&(i.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){i.geometry=r(t.geometries,this.geometry);const e=this.geometry.parameters;if(void 0!==e&&void 0!==e.shapes){const n=e.shapes;if(Array.isArray(n))for(let e=0,i=n.length;e0){i.children=[];for(let e=0;e0){i.animations=[];for(let e=0;e0&&(n.geometries=e),i.length>0&&(n.materials=i),r.length>0&&(n.textures=r),a.length>0&&(n.images=a),o.length>0&&(n.shapes=o),l.length>0&&(n.skeletons=l),c.length>0&&(n.animations=c),h.length>0&&(n.nodes=h)}return n.object=i,n;function s(t){const e=[];for(const n in t){const i=t[n];delete i.metadata,e.push(i)}return e}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.matrixWorldAutoUpdate=t.matrixWorldAutoUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.animations=t.animations.slice(),this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let e=0;e0?i.multiplyScalar(1/Math.sqrt(r)):i.set(0,0,0)}static getBarycoord(t,e,n,i,r){jn.subVectors(i,e),qn.subVectors(n,e),Yn.subVectors(t,e);const s=jn.dot(jn),a=jn.dot(qn),o=jn.dot(Yn),l=qn.dot(qn),c=qn.dot(Yn),h=s*l-a*a;if(0===h)return r.set(-2,-1,-1);const u=1/h,d=(l*o-a*c)*u,p=(s*c-a*o)*u;return r.set(1-d-p,p,d)}static containsPoint(t,e,n,i){return this.getBarycoord(t,e,n,i,Zn),Zn.x>=0&&Zn.y>=0&&Zn.x+Zn.y<=1}static getUV(t,e,n,i,r,s,a,o){return!1===ni&&(console.warn("THREE.Triangle.getUV() has been renamed to THREE.Triangle.getInterpolation()."),ni=!0),this.getInterpolation(t,e,n,i,r,s,a,o)}static getInterpolation(t,e,n,i,r,s,a,o){return this.getBarycoord(t,e,n,i,Zn),o.setScalar(0),o.addScaledVector(r,Zn.x),o.addScaledVector(s,Zn.y),o.addScaledVector(a,Zn.z),o}static isFrontFacing(t,e,n,i){return jn.subVectors(n,e),qn.subVectors(t,e),jn.cross(qn).dot(i)<0}set(t,e,n){return this.a.copy(t),this.b.copy(e),this.c.copy(n),this}setFromPointsAndIndices(t,e,n,i){return this.a.copy(t[e]),this.b.copy(t[n]),this.c.copy(t[i]),this}setFromAttributeAndIndices(t,e,n,i){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,n),this.c.fromBufferAttribute(t,i),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return jn.subVectors(this.c,this.b),qn.subVectors(this.a,this.b),.5*jn.cross(qn).length()}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return ii.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return ii.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,n,i,r){return!1===ni&&(console.warn("THREE.Triangle.getUV() has been renamed to THREE.Triangle.getInterpolation()."),ni=!0),ii.getInterpolation(t,this.a,this.b,this.c,e,n,i,r)}getInterpolation(t,e,n,i,r){return ii.getInterpolation(t,this.a,this.b,this.c,e,n,i,r)}containsPoint(t){return ii.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return ii.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){const n=this.a,i=this.b,r=this.c;let s,a;Jn.subVectors(i,n),Kn.subVectors(r,n),Qn.subVectors(t,n);const o=Jn.dot(Qn),l=Kn.dot(Qn);if(o<=0&&l<=0)return e.copy(n);ti.subVectors(t,i);const c=Jn.dot(ti),h=Kn.dot(ti);if(c>=0&&h<=c)return e.copy(i);const u=o*h-c*l;if(u<=0&&o>=0&&c<=0)return s=o/(o-c),e.copy(n).addScaledVector(Jn,s);ei.subVectors(t,r);const d=Jn.dot(ei),p=Kn.dot(ei);if(p>=0&&d<=p)return e.copy(r);const m=d*l-o*p;if(m<=0&&l>=0&&p<=0)return a=l/(l-p),e.copy(n).addScaledVector(Kn,a);const f=c*p-d*h;if(f<=0&&h-c>=0&&d-p>=0)return $n.subVectors(r,i),a=(h-c)/(h-c+(d-p)),e.copy(i).addScaledVector($n,a);const g=1/(f+m+u);return s=m*g,a=u*g,e.copy(n).addScaledVector(Jn,s).addScaledVector(Kn,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}}const ri={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},si={h:0,s:0,l:0},ai={h:0,s:0,l:0};function oi(t,e,n){return n<0&&(n+=1),n>1&&(n-=1),n<1/6?t+6*(e-t)*n:n<.5?e:n<2/3?t+6*(e-t)*(2/3-n):t}class li{constructor(t,e,n){return this.isColor=!0,this.r=1,this.g=1,this.b=1,this.set(t,e,n)}set(t,e,n){if(void 0===e&&void 0===n){const e=t;e&&e.isColor?this.copy(e):"number"==typeof e?this.setHex(e):"string"==typeof e&&this.setStyle(e)}else this.setRGB(t,e,n);return this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t,e=Bt){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(255&t)/255,Ae.toWorkingColorSpace(this,e),this}setRGB(t,e,n,i=Ae.workingColorSpace){return this.r=t,this.g=e,this.b=n,Ae.toWorkingColorSpace(this,i),this}setHSL(t,e,n,i=Ae.workingColorSpace){if(t=se(t,1),e=re(e,0,1),n=re(n,0,1),0===e)this.r=this.g=this.b=n;else{const i=n<=.5?n*(1+e):n+e-n*e,r=2*n-i;this.r=oi(r,i,t+1/3),this.g=oi(r,i,t),this.b=oi(r,i,t-1/3)}return Ae.toWorkingColorSpace(this,i),this}setStyle(t,e=Bt){function n(e){void 0!==e&&parseFloat(e)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let i;if(i=/^(\w+)\(([^\)]*)\)/.exec(t)){let r;const s=i[1],a=i[2];switch(s){case"rgb":case"rgba":if(r=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return n(r[4]),this.setRGB(Math.min(255,parseInt(r[1],10))/255,Math.min(255,parseInt(r[2],10))/255,Math.min(255,parseInt(r[3],10))/255,e);if(r=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return n(r[4]),this.setRGB(Math.min(100,parseInt(r[1],10))/100,Math.min(100,parseInt(r[2],10))/100,Math.min(100,parseInt(r[3],10))/100,e);break;case"hsl":case"hsla":if(r=/^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return n(r[4]),this.setHSL(parseFloat(r[1])/360,parseFloat(r[2])/100,parseFloat(r[3])/100,e);break;default:console.warn("THREE.Color: Unknown color model "+t)}}else if(i=/^\#([A-Fa-f\d]+)$/.exec(t)){const n=i[1],r=n.length;if(3===r)return this.setRGB(parseInt(n.charAt(0),16)/15,parseInt(n.charAt(1),16)/15,parseInt(n.charAt(2),16)/15,e);if(6===r)return this.setHex(parseInt(n,16),e);console.warn("THREE.Color: Invalid hex color "+t)}else if(t&&t.length>0)return this.setColorName(t,e);return this}setColorName(t,e=Bt){const n=ri[t.toLowerCase()];return void 0!==n?this.setHex(n,e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=Re(t.r),this.g=Re(t.g),this.b=Re(t.b),this}copyLinearToSRGB(t){return this.r=Ce(t.r),this.g=Ce(t.g),this.b=Ce(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(t=Bt){return Ae.fromWorkingColorSpace(ci.copy(this),t),65536*Math.round(re(255*ci.r,0,255))+256*Math.round(re(255*ci.g,0,255))+Math.round(re(255*ci.b,0,255))}getHexString(t=Bt){return("000000"+this.getHex(t).toString(16)).slice(-6)}getHSL(t,e=Ae.workingColorSpace){Ae.fromWorkingColorSpace(ci.copy(this),e);const n=ci.r,i=ci.g,r=ci.b,s=Math.max(n,i,r),a=Math.min(n,i,r);let o,l;const c=(a+s)/2;if(a===s)o=0,l=0;else{const t=s-a;switch(l=c<=.5?t/(s+a):t/(2-s-a),s){case n:o=(i-r)/t+(i0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(void 0!==t)for(const e in t){const n=t[e];if(void 0===n){console.warn(`THREE.Material: parameter '${e}' has value of undefined.`);continue}const i=this[e];void 0!==i?i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[e]=n:console.warn(`THREE.Material: '${e}' is not a property of THREE.${this.type}.`)}}toJSON(t){const e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});const n={metadata:{version:4.6,type:"Material",generator:"Material.toJSON"}};function i(t){const e=[];for(const n in t){const i=t[n];delete i.metadata,e.push(i)}return e}if(n.uuid=this.uuid,n.type=this.type,""!==this.name&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),void 0!==this.roughness&&(n.roughness=this.roughness),void 0!==this.metalness&&(n.metalness=this.metalness),void 0!==this.sheen&&(n.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(n.sheenColor=this.sheenColor.getHex()),void 0!==this.sheenRoughness&&(n.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),void 0!==this.specularIntensity&&(n.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(n.specularColor=this.specularColor.getHex()),void 0!==this.shininess&&(n.shininess=this.shininess),void 0!==this.clearcoat&&(n.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),void 0!==this.iridescence&&(n.iridescence=this.iridescence),void 0!==this.iridescenceIOR&&(n.iridescenceIOR=this.iridescenceIOR),void 0!==this.iridescenceThicknessRange&&(n.iridescenceThicknessRange=this.iridescenceThicknessRange),this.iridescenceMap&&this.iridescenceMap.isTexture&&(n.iridescenceMap=this.iridescenceMap.toJSON(t).uuid),this.iridescenceThicknessMap&&this.iridescenceThicknessMap.isTexture&&(n.iridescenceThicknessMap=this.iridescenceThicknessMap.toJSON(t).uuid),void 0!==this.anisotropy&&(n.anisotropy=this.anisotropy),void 0!==this.anisotropyRotation&&(n.anisotropyRotation=this.anisotropyRotation),this.anisotropyMap&&this.anisotropyMap.isTexture&&(n.anisotropyMap=this.anisotropyMap.toJSON(t).uuid),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid,n.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(n.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(n.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(n.combine=this.combine)),void 0!==this.envMapIntensity&&(n.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(n.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(n.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.transmission&&(n.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(n.transmissionMap=this.transmissionMap.toJSON(t).uuid),void 0!==this.thickness&&(n.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(n.thicknessMap=this.thicknessMap.toJSON(t).uuid),void 0!==this.attenuationDistance&&this.attenuationDistance!==1/0&&(n.attenuationDistance=this.attenuationDistance),void 0!==this.attenuationColor&&(n.attenuationColor=this.attenuationColor.getHex()),void 0!==this.size&&(n.size=this.size),null!==this.shadowSide&&(n.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(n.sizeAttenuation=this.sizeAttenuation),1!==this.blending&&(n.blending=this.blending),this.side!==s&&(n.side=this.side),!0===this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),!0===this.transparent&&(n.transparent=!0),this.blendSrc!==l&&(n.blendSrc=this.blendSrc),this.blendDst!==c&&(n.blendDst=this.blendDst),this.blendEquation!==o&&(n.blendEquation=this.blendEquation),null!==this.blendSrcAlpha&&(n.blendSrcAlpha=this.blendSrcAlpha),null!==this.blendDstAlpha&&(n.blendDstAlpha=this.blendDstAlpha),null!==this.blendEquationAlpha&&(n.blendEquationAlpha=this.blendEquationAlpha),this.blendColor&&this.blendColor.isColor&&(n.blendColor=this.blendColor.getHex()),0!==this.blendAlpha&&(n.blendAlpha=this.blendAlpha),3!==this.depthFunc&&(n.depthFunc=this.depthFunc),!1===this.depthTest&&(n.depthTest=this.depthTest),!1===this.depthWrite&&(n.depthWrite=this.depthWrite),!1===this.colorWrite&&(n.colorWrite=this.colorWrite),255!==this.stencilWriteMask&&(n.stencilWriteMask=this.stencilWriteMask),519!==this.stencilFunc&&(n.stencilFunc=this.stencilFunc),0!==this.stencilRef&&(n.stencilRef=this.stencilRef),255!==this.stencilFuncMask&&(n.stencilFuncMask=this.stencilFuncMask),this.stencilFail!==jt&&(n.stencilFail=this.stencilFail),this.stencilZFail!==jt&&(n.stencilZFail=this.stencilZFail),this.stencilZPass!==jt&&(n.stencilZPass=this.stencilZPass),!0===this.stencilWrite&&(n.stencilWrite=this.stencilWrite),void 0!==this.rotation&&0!==this.rotation&&(n.rotation=this.rotation),!0===this.polygonOffset&&(n.polygonOffset=!0),0!==this.polygonOffsetFactor&&(n.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(n.polygonOffsetUnits=this.polygonOffsetUnits),void 0!==this.linewidth&&1!==this.linewidth&&(n.linewidth=this.linewidth),void 0!==this.dashSize&&(n.dashSize=this.dashSize),void 0!==this.gapSize&&(n.gapSize=this.gapSize),void 0!==this.scale&&(n.scale=this.scale),!0===this.dithering&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),!0===this.alphaHash&&(n.alphaHash=!0),!0===this.alphaToCoverage&&(n.alphaToCoverage=!0),!0===this.premultipliedAlpha&&(n.premultipliedAlpha=!0),!0===this.forceSinglePass&&(n.forceSinglePass=!0),!0===this.wireframe&&(n.wireframe=!0),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(n.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(n.wireframeLinejoin=this.wireframeLinejoin),!0===this.flatShading&&(n.flatShading=!0),!1===this.visible&&(n.visible=!1),!1===this.toneMapped&&(n.toneMapped=!1),!1===this.fog&&(n.fog=!1),Object.keys(this.userData).length>0&&(n.userData=this.userData),e){const e=i(t.textures),r=i(t.images);e.length>0&&(n.textures=e),r.length>0&&(n.images=r)}return n}clone(){return(new this.constructor).copy(this)}copy(t){this.name=t.name,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.blendColor.copy(t.blendColor),this.blendAlpha=t.blendAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;const e=t.clippingPlanes;let n=null;if(null!==e){const t=e.length;n=new Array(t);for(let i=0;i!==t;++i)n[i]=e[i].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaHash=t.alphaHash,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.forceSinglePass=t.forceSinglePass,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){!0===t&&this.version++}}class di extends ui{constructor(t){super(),this.isMeshBasicMaterial=!0,this.type="MeshBasicMaterial",this.color=new li(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=h,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.fog=t.fog,this}}const pi=mi();function mi(){const t=new ArrayBuffer(4),e=new Float32Array(t),n=new Uint32Array(t),i=new Uint32Array(512),r=new Uint32Array(512);for(let t=0;t<256;++t){const e=t-127;e<-27?(i[t]=0,i[256|t]=32768,r[t]=24,r[256|t]=24):e<-14?(i[t]=1024>>-e-14,i[256|t]=1024>>-e-14|32768,r[t]=-e-1,r[256|t]=-e-1):e<=15?(i[t]=e+15<<10,i[256|t]=e+15<<10|32768,r[t]=13,r[256|t]=13):e<128?(i[t]=31744,i[256|t]=64512,r[t]=24,r[256|t]=24):(i[t]=31744,i[256|t]=64512,r[t]=13,r[256|t]=13)}const s=new Uint32Array(2048),a=new Uint32Array(64),o=new Uint32Array(64);for(let t=1;t<1024;++t){let e=t<<13,n=0;for(;0==(8388608&e);)e<<=1,n-=8388608;e&=-8388609,n+=947912704,s[t]=e|n}for(let t=1024;t<2048;++t)s[t]=939524096+(t-1024<<13);for(let t=1;t<31;++t)a[t]=t<<23;a[31]=1199570944,a[32]=2147483648;for(let t=33;t<63;++t)a[t]=2147483648+(t-32<<23);a[63]=3347054592;for(let t=1;t<64;++t)32!==t&&(o[t]=1024);return{floatView:e,uint32View:n,baseTable:i,shiftTable:r,mantissaTable:s,exponentTable:a,offsetTable:o}}function fi(t){Math.abs(t)>65504&&console.warn("THREE.DataUtils.toHalfFloat(): Value out of range."),t=re(t,-65504,65504),pi.floatView[0]=t;const e=pi.uint32View[0],n=e>>23&511;return pi.baseTable[n]+((8388607&e)>>pi.shiftTable[n])}function gi(t){const e=t>>10;return pi.uint32View[0]=pi.mantissaTable[pi.offsetTable[e]+(1023&t)]+pi.exponentTable[e],pi.floatView[0]}const _i={toHalfFloat:fi,fromHalfFloat:gi},vi=new ke,yi=new pe;class xi{constructor(t,e,n=!1){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.isBufferAttribute=!0,this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=n,this.usage=qt,this.updateRange={offset:0,count:-1},this.gpuType=H,this.version=0}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this.gpuType=t.gpuType,this}copyAt(t,e,n){t*=this.itemSize,n*=e.itemSize;for(let i=0,r=this.itemSize;i0&&(t.userData=this.userData),void 0!==this.parameters){const e=this.parameters;for(const n in e)void 0!==e[n]&&(t[n]=e[n]);return t}t.data={attributes:{}};const e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});const n=this.attributes;for(const e in n){const i=n[e];t.data.attributes[e]=i.toJSON(t.data)}const i={};let r=!1;for(const e in this.morphAttributes){const n=this.morphAttributes[e],s=[];for(let e=0,i=n.length;e0&&(i[e]=s,r=!0)}r&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);const s=this.groups;s.length>0&&(t.data.groups=JSON.parse(JSON.stringify(s)));const a=this.boundingSphere;return null!==a&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return(new this.constructor).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;const e={};this.name=t.name;const n=t.index;null!==n&&this.setIndex(n.clone(e));const i=t.attributes;for(const t in i){const n=i[t];this.setAttribute(t,n.clone(e))}const r=t.morphAttributes;for(const t in r){const n=[],i=r[t];for(let t=0,r=i.length;t0){const n=t[e[0]];if(void 0!==n){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let t=0,e=n.length;t(t.far-t.near)**2)return}Ii.copy(r).invert(),Ui.copy(t.ray).applyMatrix4(Ii),null!==n.boundingBox&&!1===Ui.intersectsBox(n.boundingBox)||this._computeIntersections(t,e,Ui)}}_computeIntersections(t,e,n){let i;const r=this.geometry,s=this.material,a=r.index,o=r.attributes.position,l=r.attributes.uv,c=r.attributes.uv1,h=r.attributes.normal,u=r.groups,d=r.drawRange;if(null!==a)if(Array.isArray(s))for(let r=0,o=u.length;rn.far?null:{distance:u,point:Yi.clone(),object:t}}(t,e,n,i,Oi,Fi,Bi,qi);if(d){r&&(Gi.fromBufferAttribute(r,c),Vi.fromBufferAttribute(r,h),ki.fromBufferAttribute(r,u),d.uv=ii.getInterpolation(qi,Oi,Fi,Bi,Gi,Vi,ki,new pe)),o&&(Gi.fromBufferAttribute(o,c),Vi.fromBufferAttribute(o,h),ki.fromBufferAttribute(o,u),d.uv1=ii.getInterpolation(qi,Oi,Fi,Bi,Gi,Vi,ki,new pe),d.uv2=d.uv1),l&&(Wi.fromBufferAttribute(l,c),Xi.fromBufferAttribute(l,h),ji.fromBufferAttribute(l,u),d.normal=ii.getInterpolation(qi,Oi,Fi,Bi,Wi,Xi,ji,new ke),d.normal.dot(i.direction)>0&&d.normal.multiplyScalar(-1));const t={a:c,b:h,c:u,normal:new ke,materialIndex:0};ii.getNormal(Oi,Fi,Bi,t.normal),d.face=t}return d}class Ki extends Pi{constructor(t=1,e=1,n=1,i=1,r=1,s=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:n,widthSegments:i,heightSegments:r,depthSegments:s};const a=this;i=Math.floor(i),r=Math.floor(r),s=Math.floor(s);const o=[],l=[],c=[],h=[];let u=0,d=0;function p(t,e,n,i,r,s,p,m,f,g,_){const v=s/f,y=p/g,x=s/2,M=p/2,S=m/2,b=f+1,T=g+1;let E=0,w=0;const A=new ke;for(let s=0;s0?1:-1,c.push(A.x,A.y,A.z),h.push(o/f),h.push(1-s/g),E+=1}}for(let t=0;t0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader,e.lights=this.lights,e.clipping=this.clipping;const n={};for(const t in this.extensions)!0===this.extensions[t]&&(n[t]=!0);return Object.keys(n).length>0&&(e.extensions=n),e}}class ir extends Xn{constructor(){super(),this.isCamera=!0,this.type="Camera",this.matrixWorldInverse=new xn,this.projectionMatrix=new xn,this.projectionMatrixInverse=new xn,this.coordinateSystem=Jt}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this.coordinateSystem=t.coordinateSystem,this}getWorldDirection(t){return super.getWorldDirection(t).negate()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return(new this.constructor).copy(this)}}class rr extends ir{constructor(t=50,e=1,n=.1,i=2e3){super(),this.isPerspectiveCamera=!0,this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){const e=.5*this.getFilmHeight()/t;this.fov=2*ne*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){const t=Math.tan(.5*ee*this.fov);return.5*this.getFilmHeight()/t}getEffectiveFOV(){return 2*ne*Math.atan(Math.tan(.5*ee*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,n,i,r,s){this.aspect=t/e,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=n,this.view.offsetY=i,this.view.width=r,this.view.height=s,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){const t=this.near;let e=t*Math.tan(.5*ee*this.fov)/this.zoom,n=2*e,i=this.aspect*n,r=-.5*i;const s=this.view;if(null!==this.view&&this.view.enabled){const t=s.fullWidth,a=s.fullHeight;r+=s.offsetX*i/t,e-=s.offsetY*n/a,i*=s.width/t,n*=s.height/a}const a=this.filmOffset;0!==a&&(r+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(r,r+i,e,e-n,t,this.far,this.coordinateSystem),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){const e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,null!==this.view&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}}const sr=-90;class ar extends Xn{constructor(t,e,n){super(),this.type="CubeCamera",this.renderTarget=n,this.coordinateSystem=null,this.activeMipmapLevel=0;const i=new rr(sr,1,t,e);i.layers=this.layers,this.add(i);const r=new rr(sr,1,t,e);r.layers=this.layers,this.add(r);const s=new rr(sr,1,t,e);s.layers=this.layers,this.add(s);const a=new rr(sr,1,t,e);a.layers=this.layers,this.add(a);const o=new rr(sr,1,t,e);o.layers=this.layers,this.add(o);const l=new rr(sr,1,t,e);l.layers=this.layers,this.add(l)}updateCoordinateSystem(){const t=this.coordinateSystem,e=this.children.concat(),[n,i,r,s,a,o]=e;for(const t of e)this.remove(t);if(t===Jt)n.up.set(0,1,0),n.lookAt(1,0,0),i.up.set(0,1,0),i.lookAt(-1,0,0),r.up.set(0,0,-1),r.lookAt(0,1,0),s.up.set(0,0,1),s.lookAt(0,-1,0),a.up.set(0,1,0),a.lookAt(0,0,1),o.up.set(0,1,0),o.lookAt(0,0,-1);else{if(t!==Kt)throw new Error("THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: "+t);n.up.set(0,-1,0),n.lookAt(-1,0,0),i.up.set(0,-1,0),i.lookAt(1,0,0),r.up.set(0,0,1),r.lookAt(0,1,0),s.up.set(0,0,-1),s.lookAt(0,-1,0),a.up.set(0,-1,0),a.lookAt(0,0,1),o.up.set(0,-1,0),o.lookAt(0,0,-1)}for(const t of e)this.add(t),t.updateMatrixWorld()}update(t,e){null===this.parent&&this.updateMatrixWorld();const{renderTarget:n,activeMipmapLevel:i}=this;this.coordinateSystem!==t.coordinateSystem&&(this.coordinateSystem=t.coordinateSystem,this.updateCoordinateSystem());const[r,s,a,o,l,c]=this.children,h=t.getRenderTarget(),u=t.getActiveCubeFace(),d=t.getActiveMipmapLevel(),p=t.xr.enabled;t.xr.enabled=!1;const m=n.texture.generateMipmaps;n.texture.generateMipmaps=!1,t.setRenderTarget(n,0,i),t.render(e,r),t.setRenderTarget(n,1,i),t.render(e,s),t.setRenderTarget(n,2,i),t.render(e,a),t.setRenderTarget(n,3,i),t.render(e,o),t.setRenderTarget(n,4,i),t.render(e,l),n.texture.generateMipmaps=m,t.setRenderTarget(n,5,i),t.render(e,c),t.setRenderTarget(h,u,d),t.xr.enabled=p,n.texture.needsPMREMUpdate=!0}}class or extends Oe{constructor(t,e,n,i,r,s,a,o,l,c){super(t=void 0!==t?t:[],e=void 0!==e?e:S,n,i,r,s,a,o,l,c),this.isCubeTexture=!0,this.flipY=!1}get images(){return this.image}set images(t){this.image=t}}class lr extends ze{constructor(t=1,e={}){super(t,t,e),this.isWebGLCubeRenderTarget=!0;const n={width:t,height:t,depth:1},i=[n,n,n,n,n,n];void 0!==e.encoding&&(Se("THREE.WebGLCubeRenderTarget: option.encoding has been replaced by option.colorSpace."),e.colorSpace=e.encoding===Ot?Bt:Ft),this.texture=new or(i,e.mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.colorSpace),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=void 0!==e.generateMipmaps&&e.generateMipmaps,this.texture.minFilter=void 0!==e.minFilter?e.minFilter:U}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.colorSpace=e.colorSpace,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;const n={uniforms:{tEquirect:{value:null}},vertexShader:"\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include \n\t\t\t\t\t#include \n\n\t\t\t\t}\n\t\t\t",fragmentShader:"\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include \n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t"},i=new Ki(5,5,5),r=new nr({name:"CubemapFromEquirect",uniforms:$i(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:a,blending:0});r.uniforms.tEquirect.value=e;const s=new Zi(i,r),o=e.minFilter;e.minFilter===N&&(e.minFilter=U);return new ar(1,10,this).update(t,s),e.minFilter=o,s.geometry.dispose(),s.material.dispose(),this}clear(t,e,n,i){const r=t.getRenderTarget();for(let r=0;r<6;r++)t.setRenderTarget(this,r),t.clear(e,n,i);t.setRenderTarget(r)}}const cr=new ke,hr=new ke,ur=new me;class dr{constructor(t=new ke(1,0,0),e=0){this.isPlane=!0,this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,n,i){return this.normal.set(t,e,n),this.constant=i,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,n){const i=cr.subVectors(n,e).cross(hr.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(i,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){const t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(t).addScaledVector(this.normal,-this.distanceToPoint(t))}intersectLine(t,e){const n=t.delta(cr),i=this.normal.dot(n);if(0===i)return 0===this.distanceToPoint(t.start)?e.copy(t.start):null;const r=-(t.start.dot(this.normal)+this.constant)/i;return r<0||r>1?null:e.copy(t.start).addScaledVector(n,r)}intersectsLine(t){const e=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return e<0&&n>0||n<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){const n=e||ur.getNormalMatrix(t),i=this.coplanarPoint(cr).applyMatrix4(t),r=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(r),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}}const pr=new un,mr=new ke;class fr{constructor(t=new dr,e=new dr,n=new dr,i=new dr,r=new dr,s=new dr){this.planes=[t,e,n,i,r,s]}set(t,e,n,i,r,s){const a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(n),a[3].copy(i),a[4].copy(r),a[5].copy(s),this}copy(t){const e=this.planes;for(let n=0;n<6;n++)e[n].copy(t.planes[n]);return this}setFromProjectionMatrix(t,e=2e3){const n=this.planes,i=t.elements,r=i[0],s=i[1],a=i[2],o=i[3],l=i[4],c=i[5],h=i[6],u=i[7],d=i[8],p=i[9],m=i[10],f=i[11],g=i[12],_=i[13],v=i[14],y=i[15];if(n[0].setComponents(o-r,u-l,f-d,y-g).normalize(),n[1].setComponents(o+r,u+l,f+d,y+g).normalize(),n[2].setComponents(o+s,u+c,f+p,y+_).normalize(),n[3].setComponents(o-s,u-c,f-p,y-_).normalize(),n[4].setComponents(o-a,u-h,f-m,y-v).normalize(),e===Jt)n[5].setComponents(o+a,u+h,f+m,y+v).normalize();else{if(e!==Kt)throw new Error("THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: "+e);n[5].setComponents(a,h,m,v).normalize()}return this}intersectsObject(t){if(void 0!==t.boundingSphere)null===t.boundingSphere&&t.computeBoundingSphere(),pr.copy(t.boundingSphere).applyMatrix4(t.matrixWorld);else{const e=t.geometry;null===e.boundingSphere&&e.computeBoundingSphere(),pr.copy(e.boundingSphere).applyMatrix4(t.matrixWorld)}return this.intersectsSphere(pr)}intersectsSprite(t){return pr.center.set(0,0,0),pr.radius=.7071067811865476,pr.applyMatrix4(t.matrixWorld),this.intersectsSphere(pr)}intersectsSphere(t){const e=this.planes,n=t.center,i=-t.radius;for(let t=0;t<6;t++){if(e[t].distanceToPoint(n)0?t.max.x:t.min.x,mr.y=i.normal.y>0?t.max.y:t.min.y,mr.z=i.normal.z>0?t.max.z:t.min.z,i.distanceToPoint(mr)<0)return!1}return!0}containsPoint(t){const e=this.planes;for(let n=0;n<6;n++)if(e[n].distanceToPoint(t)<0)return!1;return!0}clone(){return(new this.constructor).copy(this)}}function gr(){let t=null,e=!1,n=null,i=null;function r(e,s){n(e,s),i=t.requestAnimationFrame(r)}return{start:function(){!0!==e&&null!==n&&(i=t.requestAnimationFrame(r),e=!0)},stop:function(){t.cancelAnimationFrame(i),e=!1},setAnimationLoop:function(t){n=t},setContext:function(e){t=e}}}function _r(t,e){const n=e.isWebGL2,i=new WeakMap;return{get:function(t){return t.isInterleavedBufferAttribute&&(t=t.data),i.get(t)},remove:function(e){e.isInterleavedBufferAttribute&&(e=e.data);const n=i.get(e);n&&(t.deleteBuffer(n.buffer),i.delete(e))},update:function(e,r){if(e.isGLBufferAttribute){const t=i.get(e);return void((!t||t.version 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nvec3 pow2( const in vec3 x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\n#ifdef USE_ALPHAHASH\n\tvarying vec3 vPosition;\n#endif\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat luminance( const in vec3 rgb ) {\n\tconst vec3 weights = vec3( 0.2126729, 0.7151522, 0.0721750 );\n\treturn dot( weights, rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n} // validated",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\thighp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tuv.x += filterInt * 3.0 * cubeUV_minTileSize;\n\t\tuv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\n\t\tuv.x *= CUBEUV_TEXEL_WIDTH;\n\t\tuv.y *= CUBEUV_TEXEL_HEIGHT;\n\t\t#ifdef texture2DGradEXT\n\t\t\treturn texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\n\t\t#else\n\t\t\treturn texture2D( envMap, uv ).rgb;\n\t\t#endif\n\t}\n\t#define cubeUV_r0 1.0\n\t#define cubeUV_v0 0.339\n\t#define cubeUV_m0 - 2.0\n\t#define cubeUV_r1 0.8\n\t#define cubeUV_v1 0.276\n\t#define cubeUV_m1 - 1.0\n\t#define cubeUV_r4 0.4\n\t#define cubeUV_v4 0.046\n\t#define cubeUV_m4 2.0\n\t#define cubeUV_r5 0.305\n\t#define cubeUV_v5 0.016\n\t#define cubeUV_m5 3.0\n\t#define cubeUV_r6 0.21\n\t#define cubeUV_v6 0.0038\n\t#define cubeUV_m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= cubeUV_r1 ) {\n\t\t\tmip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\n\t\t} else if ( roughness >= cubeUV_r4 ) {\n\t\t\tmip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\n\t\t} else if ( roughness >= cubeUV_r5 ) {\n\t\t\tmip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\n\t\t} else if ( roughness >= cubeUV_r6 ) {\n\t\t\tmip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",colorspace_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",colorspace_pars_fragment:"\nconst mat3 LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = mat3(\n\tvec3( 0.8224621, 0.177538, 0.0 ),\n\tvec3( 0.0331941, 0.9668058, 0.0 ),\n\tvec3( 0.0170827, 0.0723974, 0.9105199 )\n);\nconst mat3 LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = mat3(\n\tvec3( 1.2249401, - 0.2249404, 0.0 ),\n\tvec3( - 0.0420569, 1.0420571, 0.0 ),\n\tvec3( - 0.0196376, - 0.0786361, 1.0982735 )\n);\nvec4 LinearSRGBToLinearDisplayP3( in vec4 value ) {\n\treturn vec4( value.rgb * LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, value.a );\n}\nvec4 LinearDisplayP3ToLinearSRGB( in vec4 value ) {\n\treturn vec4( value.rgb * LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, value.a );\n}\nvec4 LinearTransferOETF( in vec4 value ) {\n\treturn value;\n}\nvec4 sRGBTransferOETF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn sRGBTransferOETF( value );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#ifdef USE_ENVMAP\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\t#ifdef USE_ANISOTROPY\n\t\tvec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\n\t\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\t\tvec3 bentNormal = cross( bitangent, viewDir );\n\t\t\t\tbentNormal = normalize( cross( bentNormal, bitangent ) );\n\t\t\t\tbentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\n\t\t\t\treturn getIBLRadiance( viewDir, bentNormal, roughness );\n\t\t\t#else\n\t\t\t\treturn vec3( 0.0 );\n\t\t\t#endif\n\t\t}\n\t#endif\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\tvec2 fw = fwidth( coord ) * 0.5;\n\t\treturn mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\treflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_fragment:"LambertMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularStrength = specularStrength;",lights_lambert_pars_fragment:"varying vec3 vViewPosition;\nstruct LambertMaterial {\n\tvec3 diffuseColor;\n\tfloat specularStrength;\n};\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Lambert\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Lambert",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\n#if defined( USE_LIGHT_PROBES )\n\tuniform vec3 lightProbe[ 9 ];\n#endif\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\t#if defined ( LEGACY_LIGHTS )\n\t\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\t\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t\t}\n\t\treturn 1.0;\n\t#else\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tif ( cutoffDistance > 0.0 ) {\n\t\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\t}\n\t\treturn distanceFalloff;\n\t#endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\tmaterial.ior = ior;\n\t#ifdef USE_SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULAR_COLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\n\t\t#endif\n\t\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_IRIDESCENCE\n\tmaterial.iridescence = iridescence;\n\tmaterial.iridescenceIOR = iridescenceIOR;\n\t#ifdef USE_IRIDESCENCEMAP\n\t\tmaterial.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\n\t#endif\n\t#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\t\tmaterial.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\n\t#else\n\t\tmaterial.iridescenceThickness = iridescenceThicknessMaximum;\n\t#endif\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\t#ifdef USE_ANISOTROPYMAP\n\t\tmat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\n\t\tvec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\n\t\tvec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\n\t#else\n\t\tvec2 anisotropyV = anisotropyVector;\n\t#endif\n\tmaterial.anisotropy = length( anisotropyV );\n\tanisotropyV /= material.anisotropy;\n\tmaterial.anisotropy = saturate( material.anisotropy );\n\tmaterial.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\n\tmaterial.anisotropyT = tbn[ 0 ] * anisotropyV.x - tbn[ 1 ] * anisotropyV.y;\n\tmaterial.anisotropyB = tbn[ 1 ] * anisotropyV.x + tbn[ 0 ] * anisotropyV.y;\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_IRIDESCENCE\n\t\tfloat iridescence;\n\t\tfloat iridescenceIOR;\n\t\tfloat iridescenceThickness;\n\t\tvec3 iridescenceFresnel;\n\t\tvec3 iridescenceF0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n\t#ifdef IOR\n\t\tfloat ior;\n\t#endif\n\t#ifdef USE_TRANSMISSION\n\t\tfloat transmission;\n\t\tfloat transmissionAlpha;\n\t\tfloat thickness;\n\t\tfloat attenuationDistance;\n\t\tvec3 attenuationColor;\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat anisotropy;\n\t\tfloat alphaT;\n\t\tvec3 anisotropyT;\n\t\tvec3 anisotropyB;\n\t#endif\n};\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\nvec3 sheenSpecularDirect = vec3( 0.0 );\nvec3 sheenSpecularIndirect = vec3(0.0 );\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\n float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\n float x2 = x * x;\n float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\n return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\n#ifdef USE_ANISOTROPY\n\tfloat V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\n\t\tfloat gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\n\t\tfloat gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\n\t\tfloat v = 0.5 / ( gv + gl );\n\t\treturn saturate(v);\n\t}\n\tfloat D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\n\t\tfloat a2 = alphaT * alphaB;\n\t\thighp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\n\t\thighp float v2 = dot( v, v );\n\t\tfloat w2 = a2 / v2;\n\t\treturn RECIPROCAL_PI * a2 * pow2 ( w2 );\n\t}\n#endif\n#ifdef USE_CLEARCOAT\n\tvec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\n\t\tvec3 f0 = material.clearcoatF0;\n\t\tfloat f90 = material.clearcoatF90;\n\t\tfloat roughness = material.clearcoatRoughness;\n\t\tfloat alpha = pow2( roughness );\n\t\tvec3 halfDir = normalize( lightDir + viewDir );\n\t\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\t\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\t\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\t\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\t\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t\treturn F * ( V * D );\n\t}\n#endif\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n\tvec3 f0 = material.specularColor;\n\tfloat f90 = material.specularF90;\n\tfloat roughness = material.roughness;\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t#ifdef USE_IRIDESCENCE\n\t\tF = mix( F, material.iridescenceFresnel, material.iridescence );\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat dotTL = dot( material.anisotropyT, lightDir );\n\t\tfloat dotTV = dot( material.anisotropyT, viewDir );\n\t\tfloat dotTH = dot( material.anisotropyT, halfDir );\n\t\tfloat dotBL = dot( material.anisotropyB, lightDir );\n\t\tfloat dotBV = dot( material.anisotropyB, viewDir );\n\t\tfloat dotBH = dot( material.anisotropyB, halfDir );\n\t\tfloat V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\n\t\tfloat D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\n\t#else\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t#endif\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\n#ifdef USE_IRIDESCENCE\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#else\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#endif\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\t#ifdef USE_IRIDESCENCE\n\t\tvec3 Fr = mix( specularColor, iridescenceF0, iridescence );\n\t#else\n\t\tvec3 Fr = specularColor;\n\t#endif\n\tvec3 FssEss = Fr * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometryNormal;\n\t\tvec3 viewDir = geometryViewDir;\n\t\tvec3 position = geometryPosition;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3( 0, 1, 0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\t#ifdef USE_IRIDESCENCE\n\t\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );\n\t#else\n\t\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\t#endif\n\tvec3 totalScattering = singleScattering + multiScattering;\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nvec3 geometryPosition = - vViewPosition;\nvec3 geometryNormal = normal;\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\nvec3 geometryClearcoatNormal = vec3( 0.0 );\n#ifdef USE_CLEARCOAT\n\tgeometryClearcoatNormal = clearcoatNormal;\n#endif\n#ifdef USE_IRIDESCENCE\n\tfloat dotNVi = saturate( dot( normal, geometryViewDir ) );\n\tif ( material.iridescenceThickness == 0.0 ) {\n\t\tmaterial.iridescence = 0.0;\n\t} else {\n\t\tmaterial.iridescence = saturate( material.iridescence );\n\t}\n\tif ( material.iridescence > 0.0 ) {\n\t\tmaterial.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\n\t\tmaterial.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\n\t}\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometryPosition, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\tvec4 spotColor;\n\tvec3 spotLightCoord;\n\tbool inSpotLightMap;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometryPosition, directLight );\n\t\t#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\n\t\t#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\n\t\t#else\n\t\t#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#endif\n\t\t#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\n\t\t\tspotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\n\t\t\tinSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\n\t\t\tspotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\n\t\t\tdirectLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\n\t\t#endif\n\t\t#undef SPOT_LIGHT_MAP_INDEX\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#if defined( USE_LIGHT_PROBES )\n\t\tirradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometryNormal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\t#ifdef USE_ANISOTROPY\n\t\tradiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\n\t#else\n\t\tradiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n\t\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t#if defined( USE_POINTS_UV )\n\t\tvec2 uv = vUv;\n\t#else\n\t\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_POINTS_UV )\n\tvarying vec2 vUv;\n#else\n\t#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t\tuniform mat3 uvTransform;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphcolor_vertex:"#if defined( USE_MORPHCOLORS ) && defined( MORPHTARGETS_TEXTURE )\n\tvColor *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t#if defined( USE_COLOR_ALPHA )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\n\t\t#elif defined( USE_COLOR )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\n\t\t#endif\n\t}\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\t\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\t\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\t\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n\t#endif\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t\tuniform sampler2DArray morphTargetsTexture;\n\t\tuniform ivec2 morphTargetsTextureSize;\n\t\tvec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\n\t\t\tint texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\n\t\t\tint y = texelIndex / morphTargetsTextureSize.x;\n\t\t\tint x = texelIndex - y * morphTargetsTextureSize.x;\n\t\t\tivec3 morphUV = ivec3( x, y, morphTargetIndex );\n\t\t\treturn texelFetch( morphTargetsTexture, morphUV, 0 );\n\t\t}\n\t#else\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\tuniform float morphTargetInfluences[ 8 ];\n\t\t#else\n\t\t\tuniform float morphTargetInfluences[ 4 ];\n\t\t#endif\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\t\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\t\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\t\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t\t#endif\n\t#endif\n#endif",normal_fragment_begin:"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = dFdx( vViewPosition );\n\tvec3 fdy = dFdy( vViewPosition );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal *= faceDirection;\n\t#endif\n#endif\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn = getTangentFrame( - vViewPosition, normal,\n\t\t#if defined( USE_NORMALMAP )\n\t\t\tvNormalMapUv\n\t\t#elif defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tvClearcoatNormalMapUv\n\t\t#else\n\t\t\tvUv\n\t\t#endif\n\t\t);\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn[0] *= faceDirection;\n\t\ttbn[1] *= faceDirection;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn2[0] *= faceDirection;\n\t\ttbn2[1] *= faceDirection;\n\t#endif\n#endif\nvec3 nonPerturbedNormal = normal;",normal_fragment_maps:"#ifdef USE_NORMALMAP_OBJECTSPACE\n\tnormal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\n\tvec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\tnormal = normalize( tbn * mapN );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif",normal_pars_fragment:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_pars_vertex:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_vertex:"#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef USE_NORMALMAP_OBJECTSPACE\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\n\tmat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\n\t\tvec3 q0 = dFdx( eye_pos.xyz );\n\t\tvec3 q1 = dFdy( eye_pos.xyz );\n\t\tvec2 st0 = dFdx( uv.st );\n\t\tvec2 st1 = dFdy( uv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\n\t\treturn mat3( T * scale, B * scale, N );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = nonPerturbedNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\tclearcoatNormal = normalize( tbn2 * clearcoatMapN );\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif",iridescence_pars_fragment:"#ifdef USE_IRIDESCENCEMAP\n\tuniform sampler2D iridescenceMap;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform sampler2D iridescenceThicknessMap;\n#endif",opaque_fragment:"#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= material.transmissionAlpha;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec2 packDepthToRG( in highp float v ) {\n\treturn packDepthToRGBA( v ).yx;\n}\nfloat unpackRGToDepth( const in highp vec2 v ) {\n\treturn unpackRGBAToDepth( vec4( v.xy, 0.0, 0.0 ) );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn depth * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * depth - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#if NUM_SPOT_LIGHT_COORDS > 0\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#if NUM_SPOT_LIGHT_MAPS > 0\n\tuniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#if NUM_SPOT_LIGHT_COORDS > 0\n\tuniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\n\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\tvec4 shadowWorldPosition;\n#endif\n#if defined( USE_SHADOWMAP )\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if NUM_SPOT_LIGHT_COORDS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition;\n\t\t#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t\tshadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\n\t\t#endif\n\t\tvSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\tuniform highp sampler2D boneTexture;\n\tuniform int boneTextureSize;\n\tmat4 getBoneMatrix( const in float i ) {\n\t\tfloat j = i * 4.0;\n\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\ty = dy * ( y + 0.5 );\n\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\treturn bone;\n\t}\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn saturate( toneMappingExposure * color );\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3( 1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108, 1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605, 1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmission_fragment:"#ifdef USE_TRANSMISSION\n\tmaterial.transmission = transmission;\n\tmaterial.transmissionAlpha = 1.0;\n\tmaterial.thickness = thickness;\n\tmaterial.attenuationDistance = attenuationDistance;\n\tmaterial.attenuationColor = attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tmaterial.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tmaterial.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmitted = getIBLVolumeRefraction(\n\t\tn, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness,\n\t\tmaterial.attenuationColor, material.attenuationDistance );\n\tmaterial.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\n\ttotalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\n#endif",transmission_pars_fragment:"#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tfloat w0( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\n\t}\n\tfloat w1( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * ( 3.0 * a - 6.0 ) + 4.0 );\n\t}\n\tfloat w2( float a ){\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\n\t}\n\tfloat w3( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * a );\n\t}\n\tfloat g0( float a ) {\n\t\treturn w0( a ) + w1( a );\n\t}\n\tfloat g1( float a ) {\n\t\treturn w2( a ) + w3( a );\n\t}\n\tfloat h0( float a ) {\n\t\treturn - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\n\t}\n\tfloat h1( float a ) {\n\t\treturn 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\n\t}\n\tvec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\n\t\tuv = uv * texelSize.zw + 0.5;\n\t\tvec2 iuv = floor( uv );\n\t\tvec2 fuv = fract( uv );\n\t\tfloat g0x = g0( fuv.x );\n\t\tfloat g1x = g1( fuv.x );\n\t\tfloat h0x = h0( fuv.x );\n\t\tfloat h1x = h1( fuv.x );\n\t\tfloat h0y = h0( fuv.y );\n\t\tfloat h1y = h1( fuv.y );\n\t\tvec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\treturn g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\n\t\t\tg1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\n\t}\n\tvec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\n\t\tvec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\n\t\tvec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\n\t\tvec2 fLodSizeInv = 1.0 / fLodSize;\n\t\tvec2 cLodSizeInv = 1.0 / cLodSize;\n\t\tvec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\n\t\tvec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\n\t\treturn mix( fSample, cSample, fract( lod ) );\n\t}\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\treturn textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\n\t}\n\tvec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( isinf( attenuationDistance ) ) {\n\t\t\treturn vec3( 1.0 );\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\trefractionCoords += 1.0;\n\t\trefractionCoords /= 2.0;\n\t\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\tvec3 transmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\tvec3 attenuatedColor = transmittance * transmittedLight.rgb;\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\tfloat transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\n\t}\n#endif",uv_pars_fragment:"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif",uv_pars_vertex:"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tuniform mat3 mapTransform;\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform mat3 alphaMapTransform;\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tuniform mat3 lightMapTransform;\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tuniform mat3 aoMapTransform;\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tuniform mat3 bumpMapTransform;\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tuniform mat3 normalMapTransform;\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tuniform mat3 displacementMapTransform;\n\tvarying vec2 vDisplacementMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tuniform mat3 emissiveMapTransform;\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tuniform mat3 metalnessMapTransform;\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tuniform mat3 roughnessMapTransform;\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tuniform mat3 anisotropyMapTransform;\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tuniform mat3 clearcoatMapTransform;\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform mat3 clearcoatNormalMapTransform;\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform mat3 clearcoatRoughnessMapTransform;\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tuniform mat3 sheenColorMapTransform;\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tuniform mat3 sheenRoughnessMapTransform;\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tuniform mat3 iridescenceMapTransform;\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform mat3 iridescenceThicknessMapTransform;\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tuniform mat3 specularMapTransform;\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tuniform mat3 specularColorMapTransform;\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tuniform mat3 specularIntensityMapTransform;\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif",uv_vertex:"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvUv = vec3( uv, 1 ).xy;\n#endif\n#ifdef USE_MAP\n\tvMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ALPHAMAP\n\tvAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_LIGHTMAP\n\tvLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_AOMAP\n\tvAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_BUMPMAP\n\tvBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_NORMALMAP\n\tvNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tvDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_METALNESSMAP\n\tvMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULARMAP\n\tvSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tvTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_THICKNESSMAP\n\tvThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",background_frag:"uniform sampler2D t2D;\nuniform float backgroundIntensity;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\ttexColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include \n\t#include \n}",backgroundCube_vert:"varying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n\tgl_Position.z = gl_Position.w;\n}",backgroundCube_frag:"#ifdef ENVMAP_TYPE_CUBE\n\tuniform samplerCube envMap;\n#elif defined( ENVMAP_TYPE_CUBE_UV )\n\tuniform sampler2D envMap;\n#endif\nuniform float flipEnvMap;\nuniform float backgroundBlurriness;\nuniform float backgroundIntensity;\nvarying vec3 vWorldDirection;\n#include \nvoid main() {\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 texColor = textureCube( envMap, vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 texColor = textureCubeUV( envMap, vWorldDirection, backgroundBlurriness );\n\t#else\n\t\tvec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include \n\t#include \n}",cube_vert:"varying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n\tgl_Position.z = gl_Position.w;\n}",cube_frag:"uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor = texColor;\n\tgl_FragColor.a *= opacity;\n\t#include \n\t#include \n}",depth_vert:"#include \n#include \n#include \n#include \n#include \n#include \n#include \nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include \n\t#include \n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \n\t\t#include \n\t\t#include \n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvHighPrecisionZW = gl_Position.zw;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \n\t\t#include \n\t\t#include \n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvWorldPosition = worldPosition.xyz;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main () {\n\t#include \n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include \n\t#include \n\t#include \n\t#include \n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include \n\t#include \n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\toutgoingLight = diffuseColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshbasic_vert:"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include \n\t\t#include \n\t\t#include \n\t\t#include \n\t\t#include \n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include \n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n\t#include \n}",meshlambert_frag:"#define LAMBERT\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshnormal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",meshnormal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n\t#ifdef OPAQUE\n\t\tgl_FragColor.a = 1.0;\n\t#endif\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n\t#include \n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\tuniform vec2 anisotropyVector;\n\t#ifdef USE_ANISOTROPYMAP\n\t\tuniform sampler2D anisotropyMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include \n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",points_vert:"uniform float size;\nuniform float scale;\n#include \n#include \n#include \n#include \n#include \n#include \n#ifdef USE_POINTS_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif\nvoid main() {\n\t#ifdef USE_POINTS_UV\n\t\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\toutgoingLight = diffuseColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",shadow_vert:"#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include \n\t#include \n\t#include \n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include \n\t#include \n\t#include \n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\toutgoingLight = diffuseColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n}"},xr={common:{diffuse:{value:new li(16777215)},opacity:{value:1},map:{value:null},mapTransform:{value:new me},alphaMap:{value:null},alphaMapTransform:{value:new me},alphaTest:{value:0}},specularmap:{specularMap:{value:null},specularMapTransform:{value:new me}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1},aoMapTransform:{value:new me}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1},lightMapTransform:{value:new me}},bumpmap:{bumpMap:{value:null},bumpMapTransform:{value:new me},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalMapTransform:{value:new me},normalScale:{value:new pe(1,1)}},displacementmap:{displacementMap:{value:null},displacementMapTransform:{value:new me},displacementScale:{value:1},displacementBias:{value:0}},emissivemap:{emissiveMap:{value:null},emissiveMapTransform:{value:new me}},metalnessmap:{metalnessMap:{value:null},metalnessMapTransform:{value:new me}},roughnessmap:{roughnessMap:{value:null},roughnessMapTransform:{value:new me}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new li(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotLightMap:{value:[]},spotShadowMap:{value:[]},spotLightMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new li(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaMapTransform:{value:new me},alphaTest:{value:0},uvTransform:{value:new me}},sprite:{diffuse:{value:new li(16777215)},opacity:{value:1},center:{value:new pe(.5,.5)},rotation:{value:0},map:{value:null},mapTransform:{value:new me},alphaMap:{value:null},alphaMapTransform:{value:new me},alphaTest:{value:0}}},Mr={basic:{uniforms:Qi([xr.common,xr.specularmap,xr.envmap,xr.aomap,xr.lightmap,xr.fog]),vertexShader:yr.meshbasic_vert,fragmentShader:yr.meshbasic_frag},lambert:{uniforms:Qi([xr.common,xr.specularmap,xr.envmap,xr.aomap,xr.lightmap,xr.emissivemap,xr.bumpmap,xr.normalmap,xr.displacementmap,xr.fog,xr.lights,{emissive:{value:new li(0)}}]),vertexShader:yr.meshlambert_vert,fragmentShader:yr.meshlambert_frag},phong:{uniforms:Qi([xr.common,xr.specularmap,xr.envmap,xr.aomap,xr.lightmap,xr.emissivemap,xr.bumpmap,xr.normalmap,xr.displacementmap,xr.fog,xr.lights,{emissive:{value:new li(0)},specular:{value:new li(1118481)},shininess:{value:30}}]),vertexShader:yr.meshphong_vert,fragmentShader:yr.meshphong_frag},standard:{uniforms:Qi([xr.common,xr.envmap,xr.aomap,xr.lightmap,xr.emissivemap,xr.bumpmap,xr.normalmap,xr.displacementmap,xr.roughnessmap,xr.metalnessmap,xr.fog,xr.lights,{emissive:{value:new li(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:yr.meshphysical_vert,fragmentShader:yr.meshphysical_frag},toon:{uniforms:Qi([xr.common,xr.aomap,xr.lightmap,xr.emissivemap,xr.bumpmap,xr.normalmap,xr.displacementmap,xr.gradientmap,xr.fog,xr.lights,{emissive:{value:new li(0)}}]),vertexShader:yr.meshtoon_vert,fragmentShader:yr.meshtoon_frag},matcap:{uniforms:Qi([xr.common,xr.bumpmap,xr.normalmap,xr.displacementmap,xr.fog,{matcap:{value:null}}]),vertexShader:yr.meshmatcap_vert,fragmentShader:yr.meshmatcap_frag},points:{uniforms:Qi([xr.points,xr.fog]),vertexShader:yr.points_vert,fragmentShader:yr.points_frag},dashed:{uniforms:Qi([xr.common,xr.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:yr.linedashed_vert,fragmentShader:yr.linedashed_frag},depth:{uniforms:Qi([xr.common,xr.displacementmap]),vertexShader:yr.depth_vert,fragmentShader:yr.depth_frag},normal:{uniforms:Qi([xr.common,xr.bumpmap,xr.normalmap,xr.displacementmap,{opacity:{value:1}}]),vertexShader:yr.meshnormal_vert,fragmentShader:yr.meshnormal_frag},sprite:{uniforms:Qi([xr.sprite,xr.fog]),vertexShader:yr.sprite_vert,fragmentShader:yr.sprite_frag},background:{uniforms:{uvTransform:{value:new me},t2D:{value:null},backgroundIntensity:{value:1}},vertexShader:yr.background_vert,fragmentShader:yr.background_frag},backgroundCube:{uniforms:{envMap:{value:null},flipEnvMap:{value:-1},backgroundBlurriness:{value:0},backgroundIntensity:{value:1}},vertexShader:yr.backgroundCube_vert,fragmentShader:yr.backgroundCube_frag},cube:{uniforms:{tCube:{value:null},tFlip:{value:-1},opacity:{value:1}},vertexShader:yr.cube_vert,fragmentShader:yr.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:yr.equirect_vert,fragmentShader:yr.equirect_frag},distanceRGBA:{uniforms:Qi([xr.common,xr.displacementmap,{referencePosition:{value:new ke},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:yr.distanceRGBA_vert,fragmentShader:yr.distanceRGBA_frag},shadow:{uniforms:Qi([xr.lights,xr.fog,{color:{value:new li(0)},opacity:{value:1}}]),vertexShader:yr.shadow_vert,fragmentShader:yr.shadow_frag}};Mr.physical={uniforms:Qi([Mr.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatMapTransform:{value:new me},clearcoatNormalMap:{value:null},clearcoatNormalMapTransform:{value:new me},clearcoatNormalScale:{value:new pe(1,1)},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatRoughnessMapTransform:{value:new me},iridescence:{value:0},iridescenceMap:{value:null},iridescenceMapTransform:{value:new me},iridescenceIOR:{value:1.3},iridescenceThicknessMinimum:{value:100},iridescenceThicknessMaximum:{value:400},iridescenceThicknessMap:{value:null},iridescenceThicknessMapTransform:{value:new me},sheen:{value:0},sheenColor:{value:new li(0)},sheenColorMap:{value:null},sheenColorMapTransform:{value:new me},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},sheenRoughnessMapTransform:{value:new me},transmission:{value:0},transmissionMap:{value:null},transmissionMapTransform:{value:new me},transmissionSamplerSize:{value:new pe},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},thicknessMapTransform:{value:new me},attenuationDistance:{value:0},attenuationColor:{value:new li(0)},specularColor:{value:new li(1,1,1)},specularColorMap:{value:null},specularColorMapTransform:{value:new me},specularIntensity:{value:1},specularIntensityMap:{value:null},specularIntensityMapTransform:{value:new me},anisotropyVector:{value:new pe},anisotropyMap:{value:null},anisotropyMapTransform:{value:new me}}]),vertexShader:yr.meshphysical_vert,fragmentShader:yr.meshphysical_frag};const Sr={r:0,b:0,g:0};function br(t,e,n,i,r,o,l){const c=new li(0);let h,u,d=!0===o?0:1,p=null,m=0,f=null;function g(e,n){e.getRGB(Sr,tr(t)),i.buffers.color.setClear(Sr.r,Sr.g,Sr.b,n,l)}return{getClearColor:function(){return c},setClearColor:function(t,e=1){c.set(t),d=e,g(c,d)},getClearAlpha:function(){return d},setClearAlpha:function(t){d=t,g(c,d)},render:function(o,_){let v=!1,y=!0===_.isScene?_.background:null;if(y&&y.isTexture){y=(_.backgroundBlurriness>0?n:e).get(y)}null===y?g(c,d):y&&y.isColor&&(g(y,1),v=!0);const x=t.xr.getEnvironmentBlendMode();"additive"===x?i.buffers.color.setClear(0,0,0,1,l):"alpha-blend"===x&&i.buffers.color.setClear(0,0,0,0,l),(t.autoClear||v)&&t.clear(t.autoClearColor,t.autoClearDepth,t.autoClearStencil),y&&(y.isCubeTexture||y.mapping===w)?(void 0===u&&(u=new Zi(new Ki(1,1,1),new nr({name:"BackgroundCubeMaterial",uniforms:$i(Mr.backgroundCube.uniforms),vertexShader:Mr.backgroundCube.vertexShader,fragmentShader:Mr.backgroundCube.fragmentShader,side:a,depthTest:!1,depthWrite:!1,fog:!1})),u.geometry.deleteAttribute("normal"),u.geometry.deleteAttribute("uv"),u.onBeforeRender=function(t,e,n){this.matrixWorld.copyPosition(n.matrixWorld)},Object.defineProperty(u.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),r.update(u)),u.material.uniforms.envMap.value=y,u.material.uniforms.flipEnvMap.value=y.isCubeTexture&&!1===y.isRenderTargetTexture?-1:1,u.material.uniforms.backgroundBlurriness.value=_.backgroundBlurriness,u.material.uniforms.backgroundIntensity.value=_.backgroundIntensity,u.material.toneMapped=Ae.getTransfer(y.colorSpace)!==kt,p===y&&m===y.version&&f===t.toneMapping||(u.material.needsUpdate=!0,p=y,m=y.version,f=t.toneMapping),u.layers.enableAll(),o.unshift(u,u.geometry,u.material,0,0,null)):y&&y.isTexture&&(void 0===h&&(h=new Zi(new vr(2,2),new nr({name:"BackgroundMaterial",uniforms:$i(Mr.background.uniforms),vertexShader:Mr.background.vertexShader,fragmentShader:Mr.background.fragmentShader,side:s,depthTest:!1,depthWrite:!1,fog:!1})),h.geometry.deleteAttribute("normal"),Object.defineProperty(h.material,"map",{get:function(){return this.uniforms.t2D.value}}),r.update(h)),h.material.uniforms.t2D.value=y,h.material.uniforms.backgroundIntensity.value=_.backgroundIntensity,h.material.toneMapped=Ae.getTransfer(y.colorSpace)!==kt,!0===y.matrixAutoUpdate&&y.updateMatrix(),h.material.uniforms.uvTransform.value.copy(y.matrix),p===y&&m===y.version&&f===t.toneMapping||(h.material.needsUpdate=!0,p=y,m=y.version,f=t.toneMapping),h.layers.enableAll(),o.unshift(h,h.geometry,h.material,0,0,null))}}}function Tr(t,e,n,i){const r=t.getParameter(t.MAX_VERTEX_ATTRIBS),s=i.isWebGL2?null:e.get("OES_vertex_array_object"),a=i.isWebGL2||null!==s,o={},l=p(null);let c=l,h=!1;function u(e){return i.isWebGL2?t.bindVertexArray(e):s.bindVertexArrayOES(e)}function d(e){return i.isWebGL2?t.deleteVertexArray(e):s.deleteVertexArrayOES(e)}function p(t){const e=[],n=[],i=[];for(let t=0;t=0){const n=r[e];let i=s[e];if(void 0===i&&("instanceMatrix"===e&&t.instanceMatrix&&(i=t.instanceMatrix),"instanceColor"===e&&t.instanceColor&&(i=t.instanceColor)),void 0===n)return!0;if(n.attribute!==i)return!0;if(i&&n.data!==i.data)return!0;a++}}return c.attributesNum!==a||c.index!==i}(r,y,d,x),M&&function(t,e,n,i){const r={},s=e.attributes;let a=0;const o=n.getAttributes();for(const e in o){if(o[e].location>=0){let n=s[e];void 0===n&&("instanceMatrix"===e&&t.instanceMatrix&&(n=t.instanceMatrix),"instanceColor"===e&&t.instanceColor&&(n=t.instanceColor));const i={};i.attribute=n,n&&n.data&&(i.data=n.data),r[e]=i,a++}}c.attributes=r,c.attributesNum=a,c.index=i}(r,y,d,x)}else{const t=!0===l.wireframe;c.geometry===y.id&&c.program===d.id&&c.wireframe===t||(c.geometry=y.id,c.program=d.id,c.wireframe=t,M=!0)}null!==x&&n.update(x,t.ELEMENT_ARRAY_BUFFER),(M||h)&&(h=!1,function(r,s,a,o){if(!1===i.isWebGL2&&(r.isInstancedMesh||o.isInstancedBufferGeometry)&&null===e.get("ANGLE_instanced_arrays"))return;m();const l=o.attributes,c=a.getAttributes(),h=s.defaultAttributeValues;for(const e in c){const s=c[e];if(s.location>=0){let a=l[e];if(void 0===a&&("instanceMatrix"===e&&r.instanceMatrix&&(a=r.instanceMatrix),"instanceColor"===e&&r.instanceColor&&(a=r.instanceColor)),void 0!==a){const e=a.normalized,l=a.itemSize,c=n.get(a);if(void 0===c)continue;const h=c.buffer,u=c.type,d=c.bytesPerElement,p=!0===i.isWebGL2&&(u===t.INT||u===t.UNSIGNED_INT||a.gpuType===B);if(a.isInterleavedBufferAttribute){const n=a.data,i=n.stride,c=a.offset;if(n.isInstancedInterleavedBuffer){for(let t=0;t0&&t.getShaderPrecisionFormat(t.FRAGMENT_SHADER,t.HIGH_FLOAT).precision>0)return"highp";e="mediump"}return"mediump"===e&&t.getShaderPrecisionFormat(t.VERTEX_SHADER,t.MEDIUM_FLOAT).precision>0&&t.getShaderPrecisionFormat(t.FRAGMENT_SHADER,t.MEDIUM_FLOAT).precision>0?"mediump":"lowp"}const s="undefined"!=typeof WebGL2RenderingContext&&"WebGL2RenderingContext"===t.constructor.name;let a=void 0!==n.precision?n.precision:"highp";const o=r(a);o!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",o,"instead."),a=o);const l=s||e.has("WEBGL_draw_buffers"),c=!0===n.logarithmicDepthBuffer,h=t.getParameter(t.MAX_TEXTURE_IMAGE_UNITS),u=t.getParameter(t.MAX_VERTEX_TEXTURE_IMAGE_UNITS),d=t.getParameter(t.MAX_TEXTURE_SIZE),p=t.getParameter(t.MAX_CUBE_MAP_TEXTURE_SIZE),m=t.getParameter(t.MAX_VERTEX_ATTRIBS),f=t.getParameter(t.MAX_VERTEX_UNIFORM_VECTORS),g=t.getParameter(t.MAX_VARYING_VECTORS),_=t.getParameter(t.MAX_FRAGMENT_UNIFORM_VECTORS),v=u>0,y=s||e.has("OES_texture_float");return{isWebGL2:s,drawBuffers:l,getMaxAnisotropy:function(){if(void 0!==i)return i;if(!0===e.has("EXT_texture_filter_anisotropic")){const n=e.get("EXT_texture_filter_anisotropic");i=t.getParameter(n.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i},getMaxPrecision:r,precision:a,logarithmicDepthBuffer:c,maxTextures:h,maxVertexTextures:u,maxTextureSize:d,maxCubemapSize:p,maxAttributes:m,maxVertexUniforms:f,maxVaryings:g,maxFragmentUniforms:_,vertexTextures:v,floatFragmentTextures:y,floatVertexTextures:v&&y,maxSamples:s?t.getParameter(t.MAX_SAMPLES):0}}function Ar(t){const e=this;let n=null,i=0,r=!1,s=!1;const a=new dr,o=new me,l={value:null,needsUpdate:!1};function c(t,n,i,r){const s=null!==t?t.length:0;let c=null;if(0!==s){if(c=l.value,!0!==r||null===c){const e=i+4*s,r=n.matrixWorldInverse;o.getNormalMatrix(r),(null===c||c.length0);e.numPlanes=i,e.numIntersection=0}();else{const t=s?0:i,e=4*t;let r=m.clippingState||null;l.value=r,r=c(u,o,e,h);for(let t=0;t!==e;++t)r[t]=n[t];m.clippingState=r,this.numIntersection=d?this.numPlanes:0,this.numPlanes+=t}}}function Rr(t){let e=new WeakMap;function n(t,e){return e===T?t.mapping=S:e===E&&(t.mapping=b),t}function i(t){const n=t.target;n.removeEventListener("dispose",i);const r=e.get(n);void 0!==r&&(e.delete(n),r.dispose())}return{get:function(r){if(r&&r.isTexture&&!1===r.isRenderTargetTexture){const s=r.mapping;if(s===T||s===E){if(e.has(r)){return n(e.get(r).texture,r.mapping)}{const s=r.image;if(s&&s.height>0){const a=new lr(s.height/2);return a.fromEquirectangularTexture(t,r),e.set(r,a),r.addEventListener("dispose",i),n(a.texture,r.mapping)}return null}}}return r},dispose:function(){e=new WeakMap}}}class Cr extends ir{constructor(t=-1,e=1,n=1,i=-1,r=.1,s=2e3){super(),this.isOrthographicCamera=!0,this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=n,this.bottom=i,this.near=r,this.far=s,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this}setViewOffset(t,e,n,i,r,s){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=n,this.view.offsetY=i,this.view.width=r,this.view.height=s,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){const t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),n=(this.right+this.left)/2,i=(this.top+this.bottom)/2;let r=n-t,s=n+t,a=i+e,o=i-e;if(null!==this.view&&this.view.enabled){const t=(this.right-this.left)/this.view.fullWidth/this.zoom,e=(this.top-this.bottom)/this.view.fullHeight/this.zoom;r+=t*this.view.offsetX,s=r+t*this.view.width,a-=e*this.view.offsetY,o=a-e*this.view.height}this.projectionMatrix.makeOrthographic(r,s,a,o,this.near,this.far,this.coordinateSystem),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){const e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,null!==this.view&&(e.object.view=Object.assign({},this.view)),e}}const Lr=[.125,.215,.35,.446,.526,.582],Pr=20,Ir=new Cr,Ur=new li;let Dr=null,Nr=0,Or=0;const Fr=(1+Math.sqrt(5))/2,Br=1/Fr,zr=[new ke(1,1,1),new ke(-1,1,1),new ke(1,1,-1),new ke(-1,1,-1),new ke(0,Fr,Br),new ke(0,Fr,-Br),new ke(Br,0,Fr),new ke(-Br,0,Fr),new ke(Fr,Br,0),new ke(-Fr,Br,0)];class Hr{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._lodMax=0,this._cubeSize=0,this._lodPlanes=[],this._sizeLods=[],this._sigmas=[],this._blurMaterial=null,this._cubemapMaterial=null,this._equirectMaterial=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,n=.1,i=100){Dr=this._renderer.getRenderTarget(),Nr=this._renderer.getActiveCubeFace(),Or=this._renderer.getActiveMipmapLevel(),this._setSize(256);const r=this._allocateTargets();return r.depthBuffer=!0,this._sceneToCubeUV(t,n,i,r),e>0&&this._blur(r,0,0,e),this._applyPMREM(r),this._cleanup(r),r}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){null===this._cubemapMaterial&&(this._cubemapMaterial=Wr(),this._compileMaterial(this._cubemapMaterial))}compileEquirectangularShader(){null===this._equirectMaterial&&(this._equirectMaterial=kr(),this._compileMaterial(this._equirectMaterial))}dispose(){this._dispose(),null!==this._cubemapMaterial&&this._cubemapMaterial.dispose(),null!==this._equirectMaterial&&this._equirectMaterial.dispose()}_setSize(t){this._lodMax=Math.floor(Math.log2(t)),this._cubeSize=Math.pow(2,this._lodMax)}_dispose(){null!==this._blurMaterial&&this._blurMaterial.dispose(),null!==this._pingPongRenderTarget&&this._pingPongRenderTarget.dispose();for(let t=0;tt-4?o=Lr[a-t+4-1]:0===a&&(o=0),i.push(o);const l=1/(s-2),c=-l,h=1+l,u=[c,c,h,c,h,h,c,c,h,h,c,h],d=6,p=6,m=3,f=2,g=1,_=new Float32Array(m*p*d),v=new Float32Array(f*p*d),y=new Float32Array(g*p*d);for(let t=0;t2?0:-1,i=[e,n,0,e+2/3,n,0,e+2/3,n+1,0,e,n,0,e+2/3,n+1,0,e,n+1,0];_.set(i,m*p*t),v.set(u,f*p*t);const r=[t,t,t,t,t,t];y.set(r,g*p*t)}const x=new Pi;x.setAttribute("position",new xi(_,m)),x.setAttribute("uv",new xi(v,f)),x.setAttribute("faceIndex",new xi(y,g)),e.push(x),r>4&&r--}return{lodPlanes:e,sizeLods:n,sigmas:i}}(i)),this._blurMaterial=function(t,e,n){const i=new Float32Array(Pr),r=new ke(0,1,0),s=new nr({name:"SphericalGaussianBlur",defines:{n:Pr,CUBEUV_TEXEL_WIDTH:1/e,CUBEUV_TEXEL_HEIGHT:1/n,CUBEUV_MAX_MIP:`${t}.0`},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:i},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:r}},vertexShader:Xr(),fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include \n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1});return s}(i,t,e)}return i}_compileMaterial(t){const e=new Zi(this._lodPlanes[0],t);this._renderer.compile(e,Ir)}_sceneToCubeUV(t,e,n,i){const r=new rr(90,1,e,n),s=[1,-1,1,1,1,1],o=[1,1,1,-1,-1,-1],l=this._renderer,c=l.autoClear,h=l.toneMapping;l.getClearColor(Ur),l.toneMapping=p,l.autoClear=!1;const u=new di({name:"PMREM.Background",side:a,depthWrite:!1,depthTest:!1}),d=new Zi(new Ki,u);let m=!1;const f=t.background;f?f.isColor&&(u.color.copy(f),t.background=null,m=!0):(u.color.copy(Ur),m=!0);for(let e=0;e<6;e++){const n=e%3;0===n?(r.up.set(0,s[e],0),r.lookAt(o[e],0,0)):1===n?(r.up.set(0,0,s[e]),r.lookAt(0,o[e],0)):(r.up.set(0,s[e],0),r.lookAt(0,0,o[e]));const a=this._cubeSize;Vr(i,n*a,e>2?a:0,a,a),l.setRenderTarget(i),m&&l.render(d,r),l.render(t,r)}d.geometry.dispose(),d.material.dispose(),l.toneMapping=h,l.autoClear=c,t.background=f}_textureToCubeUV(t,e){const n=this._renderer,i=t.mapping===S||t.mapping===b;i?(null===this._cubemapMaterial&&(this._cubemapMaterial=Wr()),this._cubemapMaterial.uniforms.flipEnvMap.value=!1===t.isRenderTargetTexture?-1:1):null===this._equirectMaterial&&(this._equirectMaterial=kr());const r=i?this._cubemapMaterial:this._equirectMaterial,s=new Zi(this._lodPlanes[0],r);r.uniforms.envMap.value=t;const a=this._cubeSize;Vr(e,0,0,3*a,2*a),n.setRenderTarget(e),n.render(s,Ir)}_applyPMREM(t){const e=this._renderer,n=e.autoClear;e.autoClear=!1;for(let e=1;ePr&&console.warn(`sigmaRadians, ${r}, is too large and will clip, as it requested ${m} samples when the maximum is set to 20`);const f=[];let g=0;for(let t=0;t_-4?i-_+4:0),4*(this._cubeSize-v),3*v,2*v),o.setRenderTarget(e),o.render(c,Ir)}}function Gr(t,e,n){const i=new ze(t,e,n);return i.texture.mapping=w,i.texture.name="PMREM.cubeUv",i.scissorTest=!0,i}function Vr(t,e,n,i,r){t.viewport.set(e,n,i,r),t.scissor.set(e,n,i,r)}function kr(){return new nr({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null}},vertexShader:Xr(),fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\n\t\t\t#include \n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tgl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}function Wr(){return new nr({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:Xr(),fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}function Xr(){return"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t"}function jr(t){let e=new WeakMap,n=null;function i(t){const n=t.target;n.removeEventListener("dispose",i);const r=e.get(n);void 0!==r&&(e.delete(n),r.dispose())}return{get:function(r){if(r&&r.isTexture){const s=r.mapping,a=s===T||s===E,o=s===S||s===b;if(a||o){if(r.isRenderTargetTexture&&!0===r.needsPMREMUpdate){r.needsPMREMUpdate=!1;let i=e.get(r);return null===n&&(n=new Hr(t)),i=a?n.fromEquirectangular(r,i):n.fromCubemap(r,i),e.set(r,i),i.texture}if(e.has(r))return e.get(r).texture;{const s=r.image;if(a&&s&&s.height>0||o&&s&&function(t){let e=0;const n=6;for(let i=0;ie.maxTextureSize&&(E=Math.ceil(T/e.maxTextureSize),T=e.maxTextureSize);const w=new Float32Array(T*E*4*p),A=new He(w,T,E,p);A.type=H,A.needsUpdate=!0;const R=4*b;for(let L=0;L0)return t;const r=e*n;let s=ss[r];if(void 0===s&&(s=new Float32Array(r),ss[r]=s),0!==e){i.toArray(s,0);for(let i=1,r=0;i!==e;++i)r+=n,t[i].toArray(s,r)}return s}function us(t,e){if(t.length!==e.length)return!1;for(let n=0,i=t.length;n":" "} ${r}: ${n[t]}`)}return i.join("\n")}(t.getShaderSource(e),i)}return r}function ca(t,e){const n=function(t){const e=Ae.getPrimaries(Ae.workingColorSpace),n=Ae.getPrimaries(t);let i;switch(e===n?i="":e===Xt&&n===Wt?i="LinearDisplayP3ToLinearSRGB":e===Wt&&n===Xt&&(i="LinearSRGBToLinearDisplayP3"),t){case zt:case Gt:return[i,"LinearTransferOETF"];case Bt:case Ht:return[i,"sRGBTransferOETF"];default:return console.warn("THREE.WebGLProgram: Unsupported color space:",t),[i,"LinearTransferOETF"]}}(e);return`vec4 ${t}( vec4 value ) { return ${n[0]}( ${n[1]}( value ) ); }`}function ha(t,e){let n;switch(e){case m:n="Linear";break;case f:n="Reinhard";break;case g:n="OptimizedCineon";break;case _:n="ACESFilmic";break;case v:n="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",e),n="Linear"}return"vec3 "+t+"( vec3 color ) { return "+n+"ToneMapping( color ); }"}function ua(t){return""!==t}function da(t,e){const n=e.numSpotLightShadows+e.numSpotLightMaps-e.numSpotLightShadowsWithMaps;return t.replace(/NUM_DIR_LIGHTS/g,e.numDirLights).replace(/NUM_SPOT_LIGHTS/g,e.numSpotLights).replace(/NUM_SPOT_LIGHT_MAPS/g,e.numSpotLightMaps).replace(/NUM_SPOT_LIGHT_COORDS/g,n).replace(/NUM_RECT_AREA_LIGHTS/g,e.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,e.numPointLights).replace(/NUM_HEMI_LIGHTS/g,e.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,e.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g,e.numSpotLightShadowsWithMaps).replace(/NUM_SPOT_LIGHT_SHADOWS/g,e.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,e.numPointLightShadows)}function pa(t,e){return t.replace(/NUM_CLIPPING_PLANES/g,e.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,e.numClippingPlanes-e.numClipIntersection)}const ma=/^[ \t]*#include +<([\w\d./]+)>/gm;function fa(t){return t.replace(ma,_a)}const ga=new Map([["encodings_fragment","colorspace_fragment"],["encodings_pars_fragment","colorspace_pars_fragment"],["output_fragment","opaque_fragment"]]);function _a(t,e){let n=yr[e];if(void 0===n){const t=ga.get(e);if(void 0===t)throw new Error("Can not resolve #include <"+e+">");n=yr[t],console.warn('THREE.WebGLRenderer: Shader chunk "%s" has been deprecated. Use "%s" instead.',e,t)}return fa(n)}const va=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function ya(t){return t.replace(va,xa)}function xa(t,e,n,i){let r="";for(let t=parseInt(e);t0&&(E+="\n"),A=[x,"#define SHADER_TYPE "+s.shaderType,"#define SHADER_NAME "+s.shaderName,M].filter(ua).join("\n"),A.length>0&&(A+="\n")):(E=[Ma(s),"#define SHADER_TYPE "+s.shaderType,"#define SHADER_NAME "+s.shaderName,M,s.instancing?"#define USE_INSTANCING":"",s.instancingColor?"#define USE_INSTANCING_COLOR":"",s.useFog&&s.fog?"#define USE_FOG":"",s.useFog&&s.fogExp2?"#define FOG_EXP2":"",s.map?"#define USE_MAP":"",s.envMap?"#define USE_ENVMAP":"",s.envMap?"#define "+_:"",s.lightMap?"#define USE_LIGHTMAP":"",s.aoMap?"#define USE_AOMAP":"",s.bumpMap?"#define USE_BUMPMAP":"",s.normalMap?"#define USE_NORMALMAP":"",s.normalMapObjectSpace?"#define USE_NORMALMAP_OBJECTSPACE":"",s.normalMapTangentSpace?"#define USE_NORMALMAP_TANGENTSPACE":"",s.displacementMap?"#define USE_DISPLACEMENTMAP":"",s.emissiveMap?"#define USE_EMISSIVEMAP":"",s.anisotropy?"#define USE_ANISOTROPY":"",s.anisotropyMap?"#define USE_ANISOTROPYMAP":"",s.clearcoatMap?"#define USE_CLEARCOATMAP":"",s.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",s.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",s.iridescenceMap?"#define USE_IRIDESCENCEMAP":"",s.iridescenceThicknessMap?"#define USE_IRIDESCENCE_THICKNESSMAP":"",s.specularMap?"#define USE_SPECULARMAP":"",s.specularColorMap?"#define USE_SPECULAR_COLORMAP":"",s.specularIntensityMap?"#define USE_SPECULAR_INTENSITYMAP":"",s.roughnessMap?"#define USE_ROUGHNESSMAP":"",s.metalnessMap?"#define USE_METALNESSMAP":"",s.alphaMap?"#define USE_ALPHAMAP":"",s.alphaHash?"#define USE_ALPHAHASH":"",s.transmission?"#define USE_TRANSMISSION":"",s.transmissionMap?"#define USE_TRANSMISSIONMAP":"",s.thicknessMap?"#define USE_THICKNESSMAP":"",s.sheenColorMap?"#define USE_SHEEN_COLORMAP":"",s.sheenRoughnessMap?"#define USE_SHEEN_ROUGHNESSMAP":"",s.mapUv?"#define MAP_UV "+s.mapUv:"",s.alphaMapUv?"#define ALPHAMAP_UV "+s.alphaMapUv:"",s.lightMapUv?"#define LIGHTMAP_UV "+s.lightMapUv:"",s.aoMapUv?"#define AOMAP_UV "+s.aoMapUv:"",s.emissiveMapUv?"#define EMISSIVEMAP_UV "+s.emissiveMapUv:"",s.bumpMapUv?"#define BUMPMAP_UV "+s.bumpMapUv:"",s.normalMapUv?"#define NORMALMAP_UV "+s.normalMapUv:"",s.displacementMapUv?"#define DISPLACEMENTMAP_UV "+s.displacementMapUv:"",s.metalnessMapUv?"#define METALNESSMAP_UV "+s.metalnessMapUv:"",s.roughnessMapUv?"#define ROUGHNESSMAP_UV "+s.roughnessMapUv:"",s.anisotropyMapUv?"#define ANISOTROPYMAP_UV "+s.anisotropyMapUv:"",s.clearcoatMapUv?"#define CLEARCOATMAP_UV "+s.clearcoatMapUv:"",s.clearcoatNormalMapUv?"#define CLEARCOAT_NORMALMAP_UV "+s.clearcoatNormalMapUv:"",s.clearcoatRoughnessMapUv?"#define CLEARCOAT_ROUGHNESSMAP_UV "+s.clearcoatRoughnessMapUv:"",s.iridescenceMapUv?"#define IRIDESCENCEMAP_UV "+s.iridescenceMapUv:"",s.iridescenceThicknessMapUv?"#define IRIDESCENCE_THICKNESSMAP_UV "+s.iridescenceThicknessMapUv:"",s.sheenColorMapUv?"#define SHEEN_COLORMAP_UV "+s.sheenColorMapUv:"",s.sheenRoughnessMapUv?"#define SHEEN_ROUGHNESSMAP_UV "+s.sheenRoughnessMapUv:"",s.specularMapUv?"#define SPECULARMAP_UV "+s.specularMapUv:"",s.specularColorMapUv?"#define SPECULAR_COLORMAP_UV "+s.specularColorMapUv:"",s.specularIntensityMapUv?"#define SPECULAR_INTENSITYMAP_UV "+s.specularIntensityMapUv:"",s.transmissionMapUv?"#define TRANSMISSIONMAP_UV "+s.transmissionMapUv:"",s.thicknessMapUv?"#define THICKNESSMAP_UV "+s.thicknessMapUv:"",s.vertexTangents&&!1===s.flatShading?"#define USE_TANGENT":"",s.vertexColors?"#define USE_COLOR":"",s.vertexAlphas?"#define USE_COLOR_ALPHA":"",s.vertexUv1s?"#define USE_UV1":"",s.vertexUv2s?"#define USE_UV2":"",s.vertexUv3s?"#define USE_UV3":"",s.pointsUvs?"#define USE_POINTS_UV":"",s.flatShading?"#define FLAT_SHADED":"",s.skinning?"#define USE_SKINNING":"",s.morphTargets?"#define USE_MORPHTARGETS":"",s.morphNormals&&!1===s.flatShading?"#define USE_MORPHNORMALS":"",s.morphColors&&s.isWebGL2?"#define USE_MORPHCOLORS":"",s.morphTargetsCount>0&&s.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",s.morphTargetsCount>0&&s.isWebGL2?"#define MORPHTARGETS_TEXTURE_STRIDE "+s.morphTextureStride:"",s.morphTargetsCount>0&&s.isWebGL2?"#define MORPHTARGETS_COUNT "+s.morphTargetsCount:"",s.doubleSided?"#define DOUBLE_SIDED":"",s.flipSided?"#define FLIP_SIDED":"",s.shadowMapEnabled?"#define USE_SHADOWMAP":"",s.shadowMapEnabled?"#define "+f:"",s.sizeAttenuation?"#define USE_SIZEATTENUATION":"",s.numLightProbes>0?"#define USE_LIGHT_PROBES":"",s.useLegacyLights?"#define LEGACY_LIGHTS":"",s.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",s.logarithmicDepthBuffer&&s.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_UV1","\tattribute vec2 uv1;","#endif","#ifdef USE_UV2","\tattribute vec2 uv2;","#endif","#ifdef USE_UV3","\tattribute vec2 uv3;","#endif","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","\tattribute vec4 color;","#elif defined( USE_COLOR )","\tattribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(ua).join("\n"),A=[x,Ma(s),"#define SHADER_TYPE "+s.shaderType,"#define SHADER_NAME "+s.shaderName,M,s.useFog&&s.fog?"#define USE_FOG":"",s.useFog&&s.fogExp2?"#define FOG_EXP2":"",s.map?"#define USE_MAP":"",s.matcap?"#define USE_MATCAP":"",s.envMap?"#define USE_ENVMAP":"",s.envMap?"#define "+g:"",s.envMap?"#define "+_:"",s.envMap?"#define "+v:"",y?"#define CUBEUV_TEXEL_WIDTH "+y.texelWidth:"",y?"#define CUBEUV_TEXEL_HEIGHT "+y.texelHeight:"",y?"#define CUBEUV_MAX_MIP "+y.maxMip+".0":"",s.lightMap?"#define USE_LIGHTMAP":"",s.aoMap?"#define USE_AOMAP":"",s.bumpMap?"#define USE_BUMPMAP":"",s.normalMap?"#define USE_NORMALMAP":"",s.normalMapObjectSpace?"#define USE_NORMALMAP_OBJECTSPACE":"",s.normalMapTangentSpace?"#define USE_NORMALMAP_TANGENTSPACE":"",s.emissiveMap?"#define USE_EMISSIVEMAP":"",s.anisotropy?"#define USE_ANISOTROPY":"",s.anisotropyMap?"#define USE_ANISOTROPYMAP":"",s.clearcoat?"#define USE_CLEARCOAT":"",s.clearcoatMap?"#define USE_CLEARCOATMAP":"",s.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",s.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",s.iridescence?"#define USE_IRIDESCENCE":"",s.iridescenceMap?"#define USE_IRIDESCENCEMAP":"",s.iridescenceThicknessMap?"#define USE_IRIDESCENCE_THICKNESSMAP":"",s.specularMap?"#define USE_SPECULARMAP":"",s.specularColorMap?"#define USE_SPECULAR_COLORMAP":"",s.specularIntensityMap?"#define USE_SPECULAR_INTENSITYMAP":"",s.roughnessMap?"#define USE_ROUGHNESSMAP":"",s.metalnessMap?"#define USE_METALNESSMAP":"",s.alphaMap?"#define USE_ALPHAMAP":"",s.alphaTest?"#define USE_ALPHATEST":"",s.alphaHash?"#define USE_ALPHAHASH":"",s.sheen?"#define USE_SHEEN":"",s.sheenColorMap?"#define USE_SHEEN_COLORMAP":"",s.sheenRoughnessMap?"#define USE_SHEEN_ROUGHNESSMAP":"",s.transmission?"#define USE_TRANSMISSION":"",s.transmissionMap?"#define USE_TRANSMISSIONMAP":"",s.thicknessMap?"#define USE_THICKNESSMAP":"",s.vertexTangents&&!1===s.flatShading?"#define USE_TANGENT":"",s.vertexColors||s.instancingColor?"#define USE_COLOR":"",s.vertexAlphas?"#define USE_COLOR_ALPHA":"",s.vertexUv1s?"#define USE_UV1":"",s.vertexUv2s?"#define USE_UV2":"",s.vertexUv3s?"#define USE_UV3":"",s.pointsUvs?"#define USE_POINTS_UV":"",s.gradientMap?"#define USE_GRADIENTMAP":"",s.flatShading?"#define FLAT_SHADED":"",s.doubleSided?"#define DOUBLE_SIDED":"",s.flipSided?"#define FLIP_SIDED":"",s.shadowMapEnabled?"#define USE_SHADOWMAP":"",s.shadowMapEnabled?"#define "+f:"",s.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",s.numLightProbes>0?"#define USE_LIGHT_PROBES":"",s.useLegacyLights?"#define LEGACY_LIGHTS":"",s.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",s.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",s.logarithmicDepthBuffer&&s.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",s.toneMapping!==p?"#define TONE_MAPPING":"",s.toneMapping!==p?yr.tonemapping_pars_fragment:"",s.toneMapping!==p?ha("toneMapping",s.toneMapping):"",s.dithering?"#define DITHERING":"",s.opaque?"#define OPAQUE":"",yr.colorspace_pars_fragment,ca("linearToOutputTexel",s.outputColorSpace),s.useDepthPacking?"#define DEPTH_PACKING "+s.depthPacking:"","\n"].filter(ua).join("\n")),c=fa(c),c=da(c,s),c=pa(c,s),m=fa(m),m=da(m,s),m=pa(m,s),c=ya(c),m=ya(m),s.isWebGL2&&!0!==s.isRawShaderMaterial&&(R="#version 300 es\n",E=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+E,A=["precision mediump sampler2DArray;","#define varying in",s.glslVersion===Yt?"":"layout(location = 0) out highp vec4 pc_fragColor;",s.glslVersion===Yt?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+A);const C=R+E+c,L=R+A+m,P=sa(o,o.VERTEX_SHADER,C),I=sa(o,o.FRAGMENT_SHADER,L);function U(e){if(t.debug.checkShaderErrors){const n=o.getProgramInfoLog(T).trim(),i=o.getShaderInfoLog(P).trim(),r=o.getShaderInfoLog(I).trim();let s=!0,a=!0;if(!1===o.getProgramParameter(T,o.LINK_STATUS))if(s=!1,"function"==typeof t.debug.onShaderError)t.debug.onShaderError(o,T,P,I);else{const t=la(o,P,"vertex"),e=la(o,I,"fragment");console.error("THREE.WebGLProgram: Shader Error "+o.getError()+" - VALIDATE_STATUS "+o.getProgramParameter(T,o.VALIDATE_STATUS)+"\n\nProgram Info Log: "+n+"\n"+t+"\n"+e)}else""!==n?console.warn("THREE.WebGLProgram: Program Info Log:",n):""!==i&&""!==r||(a=!1);a&&(e.diagnostics={runnable:s,programLog:n,vertexShader:{log:i,prefix:E},fragmentShader:{log:r,prefix:A}})}o.deleteShader(P),o.deleteShader(I),D=new ra(o,T),N=function(t,e){const n={},i=t.getProgramParameter(e,t.ACTIVE_ATTRIBUTES);for(let r=0;r0,Y=s.clearcoat>0,Z=s.iridescence>0,J=s.sheen>0,K=s.transmission>0,$=q&&!!s.anisotropyMap,Q=Y&&!!s.clearcoatMap,tt=Y&&!!s.clearcoatNormalMap,et=Y&&!!s.clearcoatRoughnessMap,nt=Z&&!!s.iridescenceMap,it=Z&&!!s.iridescenceThicknessMap,rt=J&&!!s.sheenColorMap,st=J&&!!s.sheenRoughnessMap,at=!!s.specularMap,ot=!!s.specularColorMap,lt=!!s.specularIntensityMap,ct=K&&!!s.transmissionMap,ht=K&&!!s.thicknessMap,ut=!!s.gradientMap,dt=!!s.alphaMap,pt=s.alphaTest>0,mt=!!s.alphaHash,ft=!!s.extensions,gt=!!M.attributes.uv1,_t=!!M.attributes.uv2,vt=!!M.attributes.uv3;let yt=p;return s.toneMapped&&(null!==D&&!0!==D.isXRRenderTarget||(yt=t.toneMapping)),{isWebGL2:u,shaderID:E,shaderType:s.type,shaderName:s.name,vertexShader:C,fragmentShader:L,defines:s.defines,customVertexShaderID:P,customFragmentShaderID:I,isRawShaderMaterial:!0===s.isRawShaderMaterial,glslVersion:s.glslVersion,precision:f,instancing:N,instancingColor:N&&null!==y.instanceColor,supportsVertexTextures:m,outputColorSpace:null===D?t.outputColorSpace:!0===D.isXRRenderTarget?D.texture.colorSpace:zt,map:O,matcap:F,envMap:B,envMapMode:B&&b.mapping,envMapCubeUVHeight:T,aoMap:z,lightMap:H,bumpMap:G,normalMap:V,displacementMap:m&&k,emissiveMap:W,normalMapObjectSpace:V&&1===s.normalMapType,normalMapTangentSpace:V&&0===s.normalMapType,metalnessMap:X,roughnessMap:j,anisotropy:q,anisotropyMap:$,clearcoat:Y,clearcoatMap:Q,clearcoatNormalMap:tt,clearcoatRoughnessMap:et,iridescence:Z,iridescenceMap:nt,iridescenceThicknessMap:it,sheen:J,sheenColorMap:rt,sheenRoughnessMap:st,specularMap:at,specularColorMap:ot,specularIntensityMap:lt,transmission:K,transmissionMap:ct,thicknessMap:ht,gradientMap:ut,opaque:!1===s.transparent&&1===s.blending,alphaMap:dt,alphaTest:pt,alphaHash:mt,combine:s.combine,mapUv:O&&_(s.map.channel),aoMapUv:z&&_(s.aoMap.channel),lightMapUv:H&&_(s.lightMap.channel),bumpMapUv:G&&_(s.bumpMap.channel),normalMapUv:V&&_(s.normalMap.channel),displacementMapUv:k&&_(s.displacementMap.channel),emissiveMapUv:W&&_(s.emissiveMap.channel),metalnessMapUv:X&&_(s.metalnessMap.channel),roughnessMapUv:j&&_(s.roughnessMap.channel),anisotropyMapUv:$&&_(s.anisotropyMap.channel),clearcoatMapUv:Q&&_(s.clearcoatMap.channel),clearcoatNormalMapUv:tt&&_(s.clearcoatNormalMap.channel),clearcoatRoughnessMapUv:et&&_(s.clearcoatRoughnessMap.channel),iridescenceMapUv:nt&&_(s.iridescenceMap.channel),iridescenceThicknessMapUv:it&&_(s.iridescenceThicknessMap.channel),sheenColorMapUv:rt&&_(s.sheenColorMap.channel),sheenRoughnessMapUv:st&&_(s.sheenRoughnessMap.channel),specularMapUv:at&&_(s.specularMap.channel),specularColorMapUv:ot&&_(s.specularColorMap.channel),specularIntensityMapUv:lt&&_(s.specularIntensityMap.channel),transmissionMapUv:ct&&_(s.transmissionMap.channel),thicknessMapUv:ht&&_(s.thicknessMap.channel),alphaMapUv:dt&&_(s.alphaMap.channel),vertexTangents:!!M.attributes.tangent&&(V||q),vertexColors:s.vertexColors,vertexAlphas:!0===s.vertexColors&&!!M.attributes.color&&4===M.attributes.color.itemSize,vertexUv1s:gt,vertexUv2s:_t,vertexUv3s:vt,pointsUvs:!0===y.isPoints&&!!M.attributes.uv&&(O||dt),fog:!!x,useFog:!0===s.fog,fogExp2:x&&x.isFogExp2,flatShading:!0===s.flatShading,sizeAttenuation:!0===s.sizeAttenuation,logarithmicDepthBuffer:d,skinning:!0===y.isSkinnedMesh,morphTargets:void 0!==M.morphAttributes.position,morphNormals:void 0!==M.morphAttributes.normal,morphColors:void 0!==M.morphAttributes.color,morphTargetsCount:R,morphTextureStride:U,numDirLights:l.directional.length,numPointLights:l.point.length,numSpotLights:l.spot.length,numSpotLightMaps:l.spotLightMap.length,numRectAreaLights:l.rectArea.length,numHemiLights:l.hemi.length,numDirLightShadows:l.directionalShadowMap.length,numPointLightShadows:l.pointShadowMap.length,numSpotLightShadows:l.spotShadowMap.length,numSpotLightShadowsWithMaps:l.numSpotLightShadowsWithMaps,numLightProbes:l.numLightProbes,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:s.dithering,shadowMapEnabled:t.shadowMap.enabled&&h.length>0,shadowMapType:t.shadowMap.type,toneMapping:yt,useLegacyLights:t._useLegacyLights,decodeVideoTexture:O&&!0===s.map.isVideoTexture&&Ae.getTransfer(s.map.colorSpace)===kt,premultipliedAlpha:s.premultipliedAlpha,doubleSided:2===s.side,flipSided:s.side===a,useDepthPacking:s.depthPacking>=0,depthPacking:s.depthPacking||0,index0AttributeName:s.index0AttributeName,extensionDerivatives:ft&&!0===s.extensions.derivatives,extensionFragDepth:ft&&!0===s.extensions.fragDepth,extensionDrawBuffers:ft&&!0===s.extensions.drawBuffers,extensionShaderTextureLOD:ft&&!0===s.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||i.has("EXT_shader_texture_lod"),rendererExtensionParallelShaderCompile:i.has("KHR_parallel_shader_compile"),customProgramCacheKey:s.customProgramCacheKey()}},getProgramCacheKey:function(e){const n=[];if(e.shaderID?n.push(e.shaderID):(n.push(e.customVertexShaderID),n.push(e.customFragmentShaderID)),void 0!==e.defines)for(const t in e.defines)n.push(t),n.push(e.defines[t]);return!1===e.isRawShaderMaterial&&(!function(t,e){t.push(e.precision),t.push(e.outputColorSpace),t.push(e.envMapMode),t.push(e.envMapCubeUVHeight),t.push(e.mapUv),t.push(e.alphaMapUv),t.push(e.lightMapUv),t.push(e.aoMapUv),t.push(e.bumpMapUv),t.push(e.normalMapUv),t.push(e.displacementMapUv),t.push(e.emissiveMapUv),t.push(e.metalnessMapUv),t.push(e.roughnessMapUv),t.push(e.anisotropyMapUv),t.push(e.clearcoatMapUv),t.push(e.clearcoatNormalMapUv),t.push(e.clearcoatRoughnessMapUv),t.push(e.iridescenceMapUv),t.push(e.iridescenceThicknessMapUv),t.push(e.sheenColorMapUv),t.push(e.sheenRoughnessMapUv),t.push(e.specularMapUv),t.push(e.specularColorMapUv),t.push(e.specularIntensityMapUv),t.push(e.transmissionMapUv),t.push(e.thicknessMapUv),t.push(e.combine),t.push(e.fogExp2),t.push(e.sizeAttenuation),t.push(e.morphTargetsCount),t.push(e.morphAttributeCount),t.push(e.numDirLights),t.push(e.numPointLights),t.push(e.numSpotLights),t.push(e.numSpotLightMaps),t.push(e.numHemiLights),t.push(e.numRectAreaLights),t.push(e.numDirLightShadows),t.push(e.numPointLightShadows),t.push(e.numSpotLightShadows),t.push(e.numSpotLightShadowsWithMaps),t.push(e.numLightProbes),t.push(e.shadowMapType),t.push(e.toneMapping),t.push(e.numClippingPlanes),t.push(e.numClipIntersection),t.push(e.depthPacking)}(n,e),function(t,e){l.disableAll(),e.isWebGL2&&l.enable(0);e.supportsVertexTextures&&l.enable(1);e.instancing&&l.enable(2);e.instancingColor&&l.enable(3);e.matcap&&l.enable(4);e.envMap&&l.enable(5);e.normalMapObjectSpace&&l.enable(6);e.normalMapTangentSpace&&l.enable(7);e.clearcoat&&l.enable(8);e.iridescence&&l.enable(9);e.alphaTest&&l.enable(10);e.vertexColors&&l.enable(11);e.vertexAlphas&&l.enable(12);e.vertexUv1s&&l.enable(13);e.vertexUv2s&&l.enable(14);e.vertexUv3s&&l.enable(15);e.vertexTangents&&l.enable(16);e.anisotropy&&l.enable(17);e.alphaHash&&l.enable(18);t.push(l.mask),l.disableAll(),e.fog&&l.enable(0);e.useFog&&l.enable(1);e.flatShading&&l.enable(2);e.logarithmicDepthBuffer&&l.enable(3);e.skinning&&l.enable(4);e.morphTargets&&l.enable(5);e.morphNormals&&l.enable(6);e.morphColors&&l.enable(7);e.premultipliedAlpha&&l.enable(8);e.shadowMapEnabled&&l.enable(9);e.useLegacyLights&&l.enable(10);e.doubleSided&&l.enable(11);e.flipSided&&l.enable(12);e.useDepthPacking&&l.enable(13);e.dithering&&l.enable(14);e.transmission&&l.enable(15);e.sheen&&l.enable(16);e.opaque&&l.enable(17);e.pointsUvs&&l.enable(18);e.decodeVideoTexture&&l.enable(19);t.push(l.mask)}(n,e),n.push(t.outputColorSpace)),n.push(e.customProgramCacheKey),n.join()},getUniforms:function(t){const e=g[t.type];let n;if(e){const t=Mr[e];n=er.clone(t.uniforms)}else n=t.uniforms;return n},acquireProgram:function(e,n){let i;for(let t=0,e=h.length;t0?i.push(h):!0===a.transparent?r.push(h):n.push(h)},unshift:function(t,e,a,o,l,c){const h=s(t,e,a,o,l,c);a.transmission>0?i.unshift(h):!0===a.transparent?r.unshift(h):n.unshift(h)},finish:function(){for(let n=e,i=t.length;n1&&n.sort(t||Ra),i.length>1&&i.sort(e||Ca),r.length>1&&r.sort(e||Ca)}}}function Pa(){let t=new WeakMap;return{get:function(e,n){const i=t.get(e);let r;return void 0===i?(r=new La,t.set(e,[r])):n>=i.length?(r=new La,i.push(r)):r=i[n],r},dispose:function(){t=new WeakMap}}}function Ia(){const t={};return{get:function(e){if(void 0!==t[e.id])return t[e.id];let n;switch(e.type){case"DirectionalLight":n={direction:new ke,color:new li};break;case"SpotLight":n={position:new ke,direction:new ke,color:new li,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":n={position:new ke,color:new li,distance:0,decay:0};break;case"HemisphereLight":n={direction:new ke,skyColor:new li,groundColor:new li};break;case"RectAreaLight":n={color:new li,position:new ke,halfWidth:new ke,halfHeight:new ke}}return t[e.id]=n,n}}}let Ua=0;function Da(t,e){return(e.castShadow?2:0)-(t.castShadow?2:0)+(e.map?1:0)-(t.map?1:0)}function Na(t,e){const n=new Ia,i=function(){const t={};return{get:function(e){if(void 0!==t[e.id])return t[e.id];let n;switch(e.type){case"DirectionalLight":case"SpotLight":n={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new pe};break;case"PointLight":n={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new pe,shadowCameraNear:1,shadowCameraFar:1e3}}return t[e.id]=n,n}}}(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1,numSpotMaps:-1,numLightProbes:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotLightMap:[],spotShadow:[],spotShadowMap:[],spotLightMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[],numSpotLightShadowsWithMaps:0,numLightProbes:0};for(let t=0;t<9;t++)r.probe.push(new ke);const s=new ke,a=new xn,o=new xn;return{setup:function(s,a){let o=0,l=0,c=0;for(let t=0;t<9;t++)r.probe[t].set(0,0,0);let h=0,u=0,d=0,p=0,m=0,f=0,g=0,_=0,v=0,y=0,x=0;s.sort(Da);const M=!0===a?Math.PI:1;for(let t=0,e=s.length;t0&&(e.isWebGL2||!0===t.has("OES_texture_float_linear")?(r.rectAreaLTC1=xr.LTC_FLOAT_1,r.rectAreaLTC2=xr.LTC_FLOAT_2):!0===t.has("OES_texture_half_float_linear")?(r.rectAreaLTC1=xr.LTC_HALF_1,r.rectAreaLTC2=xr.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=o,r.ambient[1]=l,r.ambient[2]=c;const S=r.hash;S.directionalLength===h&&S.pointLength===u&&S.spotLength===d&&S.rectAreaLength===p&&S.hemiLength===m&&S.numDirectionalShadows===f&&S.numPointShadows===g&&S.numSpotShadows===_&&S.numSpotMaps===v&&S.numLightProbes===x||(r.directional.length=h,r.spot.length=d,r.rectArea.length=p,r.point.length=u,r.hemi.length=m,r.directionalShadow.length=f,r.directionalShadowMap.length=f,r.pointShadow.length=g,r.pointShadowMap.length=g,r.spotShadow.length=_,r.spotShadowMap.length=_,r.directionalShadowMatrix.length=f,r.pointShadowMatrix.length=g,r.spotLightMatrix.length=_+v-y,r.spotLightMap.length=v,r.numSpotLightShadowsWithMaps=y,r.numLightProbes=x,S.directionalLength=h,S.pointLength=u,S.spotLength=d,S.rectAreaLength=p,S.hemiLength=m,S.numDirectionalShadows=f,S.numPointShadows=g,S.numSpotShadows=_,S.numSpotMaps=v,S.numLightProbes=x,r.version=Ua++)},setupView:function(t,e){let n=0,i=0,l=0,c=0,h=0;const u=e.matrixWorldInverse;for(let e=0,d=t.length;e=s.length?(a=new Oa(t,e),s.push(a)):a=s[r],a},dispose:function(){n=new WeakMap}}}class Ba extends ui{constructor(t){super(),this.isMeshDepthMaterial=!0,this.type="MeshDepthMaterial",this.depthPacking=3200,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}}class za extends ui{constructor(t){super(),this.isMeshDistanceMaterial=!0,this.type="MeshDistanceMaterial",this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.setValues(t)}copy(t){return super.copy(t),this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}}function Ha(t,e,i){let o=new fr;const l=new pe,c=new pe,h=new Fe,u=new Ba({depthPacking:3201}),d=new za,p={},m=i.maxTextureSize,f={[s]:a,[a]:s,2:2},g=new nr({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new pe},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include \nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}"}),_=g.clone();_.defines.HORIZONTAL_PASS=1;const v=new Pi;v.setAttribute("position",new xi(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));const y=new Zi(v,g),x=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=n;let M=this.type;function S(n,i){const r=e.update(y);g.defines.VSM_SAMPLES!==n.blurSamples&&(g.defines.VSM_SAMPLES=n.blurSamples,_.defines.VSM_SAMPLES=n.blurSamples,g.needsUpdate=!0,_.needsUpdate=!0),null===n.mapPass&&(n.mapPass=new ze(l.x,l.y)),g.uniforms.shadow_pass.value=n.map.texture,g.uniforms.resolution.value=n.mapSize,g.uniforms.radius.value=n.radius,t.setRenderTarget(n.mapPass),t.clear(),t.renderBufferDirect(i,null,r,g,y,null),_.uniforms.shadow_pass.value=n.mapPass.texture,_.uniforms.resolution.value=n.mapSize,_.uniforms.radius.value=n.radius,t.setRenderTarget(n.map),t.clear(),t.renderBufferDirect(i,null,r,_,y,null)}function b(e,n,i,s){let a=null;const o=!0===i.isPointLight?e.customDistanceMaterial:e.customDepthMaterial;if(void 0!==o)a=o;else if(a=!0===i.isPointLight?d:u,t.localClippingEnabled&&!0===n.clipShadows&&Array.isArray(n.clippingPlanes)&&0!==n.clippingPlanes.length||n.displacementMap&&0!==n.displacementScale||n.alphaMap&&n.alphaTest>0||n.map&&n.alphaTest>0){const t=a.uuid,e=n.uuid;let i=p[t];void 0===i&&(i={},p[t]=i);let r=i[e];void 0===r&&(r=a.clone(),i[e]=r),a=r}if(a.visible=n.visible,a.wireframe=n.wireframe,a.side=s===r?null!==n.shadowSide?n.shadowSide:n.side:null!==n.shadowSide?n.shadowSide:f[n.side],a.alphaMap=n.alphaMap,a.alphaTest=n.alphaTest,a.map=n.map,a.clipShadows=n.clipShadows,a.clippingPlanes=n.clippingPlanes,a.clipIntersection=n.clipIntersection,a.displacementMap=n.displacementMap,a.displacementScale=n.displacementScale,a.displacementBias=n.displacementBias,a.wireframeLinewidth=n.wireframeLinewidth,a.linewidth=n.linewidth,!0===i.isPointLight&&!0===a.isMeshDistanceMaterial){t.properties.get(a).light=i}return a}function T(n,i,s,a,l){if(!1===n.visible)return;if(n.layers.test(i.layers)&&(n.isMesh||n.isLine||n.isPoints)&&(n.castShadow||n.receiveShadow&&l===r)&&(!n.frustumCulled||o.intersectsObject(n))){n.modelViewMatrix.multiplyMatrices(s.matrixWorldInverse,n.matrixWorld);const i=e.update(n),r=n.material;if(Array.isArray(r)){const e=i.groups;for(let o=0,c=e.length;om||l.y>m)&&(l.x>m&&(c.x=Math.floor(m/g.x),l.x=c.x*g.x,u.mapSize.x=c.x),l.y>m&&(c.y=Math.floor(m/g.y),l.y=c.y*g.y,u.mapSize.y=c.y)),null===u.map||!0===p||!0===f){const t=this.type!==r?{minFilter:L,magFilter:L}:{};null!==u.map&&u.map.dispose(),u.map=new ze(l.x,l.y,t),u.map.texture.name=a.name+".shadowMap",u.camera.updateProjectionMatrix()}t.setRenderTarget(u.map),t.clear();const _=u.getViewportCount();for(let t=0;t<_;t++){const e=u.getViewport(t);h.set(c.x*e.x,c.y*e.y,c.x*e.z,c.y*e.w),d.viewport(h),u.updateMatrices(a,t),o=u.getFrustum(),T(n,i,u.camera,a,this.type)}!0!==u.isPointLightShadow&&this.type===r&&S(u,i),u.needsUpdate=!1}M=this.type,x.needsUpdate=!1,t.setRenderTarget(s,a,u)}}function Ga(t,e,n){const i=n.isWebGL2;const r=new function(){let e=!1;const n=new Fe;let i=null;const r=new Fe(0,0,0,0);return{setMask:function(n){i===n||e||(t.colorMask(n,n,n,n),i=n)},setLocked:function(t){e=t},setClear:function(e,i,s,a,o){!0===o&&(e*=a,i*=a,s*=a),n.set(e,i,s,a),!1===r.equals(n)&&(t.clearColor(e,i,s,a),r.copy(n))},reset:function(){e=!1,i=null,r.set(-1,0,0,0)}}},s=new function(){let e=!1,n=null,i=null,r=null;return{setTest:function(e){e?j(t.DEPTH_TEST):q(t.DEPTH_TEST)},setMask:function(i){n===i||e||(t.depthMask(i),n=i)},setFunc:function(e){if(i!==e){switch(e){case 0:t.depthFunc(t.NEVER);break;case 1:t.depthFunc(t.ALWAYS);break;case 2:t.depthFunc(t.LESS);break;case 3:default:t.depthFunc(t.LEQUAL);break;case 4:t.depthFunc(t.EQUAL);break;case 5:t.depthFunc(t.GEQUAL);break;case 6:t.depthFunc(t.GREATER);break;case 7:t.depthFunc(t.NOTEQUAL)}i=e}},setLocked:function(t){e=t},setClear:function(e){r!==e&&(t.clearDepth(e),r=e)},reset:function(){e=!1,n=null,i=null,r=null}}},h=new function(){let e=!1,n=null,i=null,r=null,s=null,a=null,o=null,l=null,c=null;return{setTest:function(n){e||(n?j(t.STENCIL_TEST):q(t.STENCIL_TEST))},setMask:function(i){n===i||e||(t.stencilMask(i),n=i)},setFunc:function(e,n,a){i===e&&r===n&&s===a||(t.stencilFunc(e,n,a),i=e,r=n,s=a)},setOp:function(e,n,i){a===e&&o===n&&l===i||(t.stencilOp(e,n,i),a=e,o=n,l=i)},setLocked:function(t){e=t},setClear:function(e){c!==e&&(t.clearStencil(e),c=e)},reset:function(){e=!1,n=null,i=null,r=null,s=null,a=null,o=null,l=null,c=null}}},u=new WeakMap,d=new WeakMap;let p={},m={},f=new WeakMap,g=[],_=null,v=!1,y=null,x=null,M=null,S=null,b=null,T=null,E=null,w=new li(0,0,0),A=0,R=!1,C=null,L=null,P=null,I=null,U=null;const D=t.getParameter(t.MAX_COMBINED_TEXTURE_IMAGE_UNITS);let N=!1,O=0;const F=t.getParameter(t.VERSION);-1!==F.indexOf("WebGL")?(O=parseFloat(/^WebGL (\d)/.exec(F)[1]),N=O>=1):-1!==F.indexOf("OpenGL ES")&&(O=parseFloat(/^OpenGL ES (\d)/.exec(F)[1]),N=O>=2);let B=null,z={};const H=t.getParameter(t.SCISSOR_BOX),G=t.getParameter(t.VIEWPORT),V=(new Fe).fromArray(H),k=(new Fe).fromArray(G);function W(e,n,r,s){const a=new Uint8Array(4),o=t.createTexture();t.bindTexture(e,o),t.texParameteri(e,t.TEXTURE_MIN_FILTER,t.NEAREST),t.texParameteri(e,t.TEXTURE_MAG_FILTER,t.NEAREST);for(let o=0;oi||t.height>i)&&(r=i/Math.max(t.width,t.height)),r<1||!0===e){if("undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap){const i=e?ce:Math.floor,s=i(r*t.width),a=i(r*t.height);void 0===f&&(f=v(s,a));const o=n?v(s,a):f;o.width=s,o.height=a;return o.getContext("2d").drawImage(t,0,0,s,a),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+t.width+"x"+t.height+") to ("+s+"x"+a+")."),o}return"data"in t&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+t.width+"x"+t.height+")."),t}return t}function x(t){return oe(t.width)&&oe(t.height)}function M(t,e){return t.generateMipmaps&&e&&t.minFilter!==L&&t.minFilter!==U}function S(e){t.generateMipmap(e)}function b(n,i,r,s,a=!1){if(!1===o)return i;if(null!==n){if(void 0!==t[n])return t[n];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+n+"'")}let l=i;if(i===t.RED&&(r===t.FLOAT&&(l=t.R32F),r===t.HALF_FLOAT&&(l=t.R16F),r===t.UNSIGNED_BYTE&&(l=t.R8)),i===t.RED_INTEGER&&(r===t.UNSIGNED_BYTE&&(l=t.R8UI),r===t.UNSIGNED_SHORT&&(l=t.R16UI),r===t.UNSIGNED_INT&&(l=t.R32UI),r===t.BYTE&&(l=t.R8I),r===t.SHORT&&(l=t.R16I),r===t.INT&&(l=t.R32I)),i===t.RG&&(r===t.FLOAT&&(l=t.RG32F),r===t.HALF_FLOAT&&(l=t.RG16F),r===t.UNSIGNED_BYTE&&(l=t.RG8)),i===t.RGBA){const e=a?Vt:Ae.getTransfer(s);r===t.FLOAT&&(l=t.RGBA32F),r===t.HALF_FLOAT&&(l=t.RGBA16F),r===t.UNSIGNED_BYTE&&(l=e===kt?t.SRGB8_ALPHA8:t.RGBA8),r===t.UNSIGNED_SHORT_4_4_4_4&&(l=t.RGBA4),r===t.UNSIGNED_SHORT_5_5_5_1&&(l=t.RGB5_A1)}return l!==t.R16F&&l!==t.R32F&&l!==t.RG16F&&l!==t.RG32F&&l!==t.RGBA16F&&l!==t.RGBA32F||e.get("EXT_color_buffer_float"),l}function T(t,e,n){return!0===M(t,n)||t.isFramebufferTexture&&t.minFilter!==L&&t.minFilter!==U?Math.log2(Math.max(e.width,e.height))+1:void 0!==t.mipmaps&&t.mipmaps.length>0?t.mipmaps.length:t.isCompressedTexture&&Array.isArray(t.image)?e.mipmaps.length:1}function E(e){return e===L||e===P||e===I?t.NEAREST:t.LINEAR}function w(t){const e=t.target;e.removeEventListener("dispose",w),function(t){const e=i.get(t);if(void 0===e.__webglInit)return;const n=t.source,r=g.get(n);if(r){const i=r[e.__cacheKey];i.usedTimes--,0===i.usedTimes&&V(t),0===Object.keys(r).length&&g.delete(n)}i.remove(t)}(e),e.isVideoTexture&&m.delete(e)}function B(e){const n=e.target;n.removeEventListener("dispose",B),function(e){const n=e.texture,r=i.get(e),s=i.get(n);void 0!==s.__webglTexture&&(t.deleteTexture(s.__webglTexture),a.memory.textures--);e.depthTexture&&e.depthTexture.dispose();if(e.isWebGLCubeRenderTarget)for(let e=0;e<6;e++){if(Array.isArray(r.__webglFramebuffer[e]))for(let n=0;n0&&s.__version!==e.version){const t=e.image;if(null===t)console.warn("THREE.WebGLRenderer: Texture marked for update but no image data found.");else{if(!1!==t.complete)return void tt(s,e,r);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}n.bindTexture(t.TEXTURE_2D,s.__webglTexture,t.TEXTURE0+r)}const Z={[A]:t.REPEAT,[R]:t.CLAMP_TO_EDGE,[C]:t.MIRRORED_REPEAT},J={[L]:t.NEAREST,[P]:t.NEAREST_MIPMAP_NEAREST,[I]:t.NEAREST_MIPMAP_LINEAR,[U]:t.LINEAR,[D]:t.LINEAR_MIPMAP_NEAREST,[N]:t.LINEAR_MIPMAP_LINEAR},K={512:t.NEVER,519:t.ALWAYS,513:t.LESS,515:t.LEQUAL,514:t.EQUAL,518:t.GEQUAL,516:t.GREATER,517:t.NOTEQUAL};function $(n,s,a){if(a?(t.texParameteri(n,t.TEXTURE_WRAP_S,Z[s.wrapS]),t.texParameteri(n,t.TEXTURE_WRAP_T,Z[s.wrapT]),n!==t.TEXTURE_3D&&n!==t.TEXTURE_2D_ARRAY||t.texParameteri(n,t.TEXTURE_WRAP_R,Z[s.wrapR]),t.texParameteri(n,t.TEXTURE_MAG_FILTER,J[s.magFilter]),t.texParameteri(n,t.TEXTURE_MIN_FILTER,J[s.minFilter])):(t.texParameteri(n,t.TEXTURE_WRAP_S,t.CLAMP_TO_EDGE),t.texParameteri(n,t.TEXTURE_WRAP_T,t.CLAMP_TO_EDGE),n!==t.TEXTURE_3D&&n!==t.TEXTURE_2D_ARRAY||t.texParameteri(n,t.TEXTURE_WRAP_R,t.CLAMP_TO_EDGE),s.wrapS===R&&s.wrapT===R||console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),t.texParameteri(n,t.TEXTURE_MAG_FILTER,E(s.magFilter)),t.texParameteri(n,t.TEXTURE_MIN_FILTER,E(s.minFilter)),s.minFilter!==L&&s.minFilter!==U&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),s.compareFunction&&(t.texParameteri(n,t.TEXTURE_COMPARE_MODE,t.COMPARE_REF_TO_TEXTURE),t.texParameteri(n,t.TEXTURE_COMPARE_FUNC,K[s.compareFunction])),!0===e.has("EXT_texture_filter_anisotropic")){const a=e.get("EXT_texture_filter_anisotropic");if(s.magFilter===L)return;if(s.minFilter!==I&&s.minFilter!==N)return;if(s.type===H&&!1===e.has("OES_texture_float_linear"))return;if(!1===o&&s.type===G&&!1===e.has("OES_texture_half_float_linear"))return;(s.anisotropy>1||i.get(s).__currentAnisotropy)&&(t.texParameterf(n,a.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(s.anisotropy,r.getMaxAnisotropy())),i.get(s).__currentAnisotropy=s.anisotropy)}}function Q(e,n){let i=!1;void 0===e.__webglInit&&(e.__webglInit=!0,n.addEventListener("dispose",w));const r=n.source;let s=g.get(r);void 0===s&&(s={},g.set(r,s));const o=function(t){const e=[];return e.push(t.wrapS),e.push(t.wrapT),e.push(t.wrapR||0),e.push(t.magFilter),e.push(t.minFilter),e.push(t.anisotropy),e.push(t.internalFormat),e.push(t.format),e.push(t.type),e.push(t.generateMipmaps),e.push(t.premultiplyAlpha),e.push(t.flipY),e.push(t.unpackAlignment),e.push(t.colorSpace),e.join()}(n);if(o!==e.__cacheKey){void 0===s[o]&&(s[o]={texture:t.createTexture(),usedTimes:0},a.memory.textures++,i=!0),s[o].usedTimes++;const r=s[e.__cacheKey];void 0!==r&&(s[e.__cacheKey].usedTimes--,0===r.usedTimes&&V(n)),e.__cacheKey=o,e.__webglTexture=s[o].texture}return i}function tt(e,r,a){let l=t.TEXTURE_2D;(r.isDataArrayTexture||r.isCompressedArrayTexture)&&(l=t.TEXTURE_2D_ARRAY),r.isData3DTexture&&(l=t.TEXTURE_3D);const c=Q(e,r),u=r.source;n.bindTexture(l,e.__webglTexture,t.TEXTURE0+a);const d=i.get(u);if(u.version!==d.__version||!0===c){n.activeTexture(t.TEXTURE0+a);const e=Ae.getPrimaries(Ae.workingColorSpace),i=r.colorSpace===Ft?null:Ae.getPrimaries(r.colorSpace),p=r.colorSpace===Ft||e===i?t.NONE:t.BROWSER_DEFAULT_WEBGL;t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL,r.flipY),t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL,r.premultiplyAlpha),t.pixelStorei(t.UNPACK_ALIGNMENT,r.unpackAlignment),t.pixelStorei(t.UNPACK_COLORSPACE_CONVERSION_WEBGL,p);const m=function(t){return!o&&(t.wrapS!==R||t.wrapT!==R||t.minFilter!==L&&t.minFilter!==U)}(r)&&!1===x(r.image);let f=y(r.image,m,!1,h);f=at(r,f);const g=x(f)||o,_=s.convert(r.format,r.colorSpace);let v,E=s.convert(r.type),w=b(r.internalFormat,_,E,r.colorSpace,r.isVideoTexture);$(l,r,g);const A=r.mipmaps,C=o&&!0!==r.isVideoTexture,P=void 0===d.__version||!0===c,I=T(r,f,g);if(r.isDepthTexture)w=t.DEPTH_COMPONENT,o?w=r.type===H?t.DEPTH_COMPONENT32F:r.type===z?t.DEPTH_COMPONENT24:r.type===W?t.DEPTH24_STENCIL8:t.DEPTH_COMPONENT16:r.type===H&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),r.format===j&&w===t.DEPTH_COMPONENT&&r.type!==F&&r.type!==z&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),r.type=z,E=s.convert(r.type)),r.format===q&&w===t.DEPTH_COMPONENT&&(w=t.DEPTH_STENCIL,r.type!==W&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),r.type=W,E=s.convert(r.type))),P&&(C?n.texStorage2D(t.TEXTURE_2D,1,w,f.width,f.height):n.texImage2D(t.TEXTURE_2D,0,w,f.width,f.height,0,_,E,null));else if(r.isDataTexture)if(A.length>0&&g){C&&P&&n.texStorage2D(t.TEXTURE_2D,I,w,A[0].width,A[0].height);for(let e=0,i=A.length;e>=1,i>>=1}}else if(A.length>0&&g){C&&P&&n.texStorage2D(t.TEXTURE_2D,I,w,A[0].width,A[0].height);for(let e=0,i=A.length;e>c),i=Math.max(1,r.height>>c);l===t.TEXTURE_3D||l===t.TEXTURE_2D_ARRAY?n.texImage3D(l,c,p,e,i,r.depth,0,h,u,null):n.texImage2D(l,c,p,e,i,0,h,u,null)}n.bindFramebuffer(t.FRAMEBUFFER,e),st(r)?d.framebufferTexture2DMultisampleEXT(t.FRAMEBUFFER,o,l,i.get(a).__webglTexture,0,rt(r)):(l===t.TEXTURE_2D||l>=t.TEXTURE_CUBE_MAP_POSITIVE_X&&l<=t.TEXTURE_CUBE_MAP_NEGATIVE_Z)&&t.framebufferTexture2D(t.FRAMEBUFFER,o,l,i.get(a).__webglTexture,c),n.bindFramebuffer(t.FRAMEBUFFER,null)}function nt(e,n,i){if(t.bindRenderbuffer(t.RENDERBUFFER,e),n.depthBuffer&&!n.stencilBuffer){let r=!0===o?t.DEPTH_COMPONENT24:t.DEPTH_COMPONENT16;if(i||st(n)){const e=n.depthTexture;e&&e.isDepthTexture&&(e.type===H?r=t.DEPTH_COMPONENT32F:e.type===z&&(r=t.DEPTH_COMPONENT24));const i=rt(n);st(n)?d.renderbufferStorageMultisampleEXT(t.RENDERBUFFER,i,r,n.width,n.height):t.renderbufferStorageMultisample(t.RENDERBUFFER,i,r,n.width,n.height)}else t.renderbufferStorage(t.RENDERBUFFER,r,n.width,n.height);t.framebufferRenderbuffer(t.FRAMEBUFFER,t.DEPTH_ATTACHMENT,t.RENDERBUFFER,e)}else if(n.depthBuffer&&n.stencilBuffer){const r=rt(n);i&&!1===st(n)?t.renderbufferStorageMultisample(t.RENDERBUFFER,r,t.DEPTH24_STENCIL8,n.width,n.height):st(n)?d.renderbufferStorageMultisampleEXT(t.RENDERBUFFER,r,t.DEPTH24_STENCIL8,n.width,n.height):t.renderbufferStorage(t.RENDERBUFFER,t.DEPTH_STENCIL,n.width,n.height),t.framebufferRenderbuffer(t.FRAMEBUFFER,t.DEPTH_STENCIL_ATTACHMENT,t.RENDERBUFFER,e)}else{const e=!0===n.isWebGLMultipleRenderTargets?n.texture:[n.texture];for(let r=0;r0&&!0===e.has("WEBGL_multisampled_render_to_texture")&&!1!==n.__useRenderToTexture}function at(t,n){const i=t.colorSpace,r=t.format,s=t.type;return!0===t.isCompressedTexture||!0===t.isVideoTexture||t.format===Zt||i!==zt&&i!==Ft&&(Ae.getTransfer(i)===kt?!1===o?!0===e.has("EXT_sRGB")&&r===X?(t.format=Zt,t.minFilter=U,t.generateMipmaps=!1):n=Pe.sRGBToLinear(n):r===X&&s===O||console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture color space:",i)),n}this.allocateTextureUnit=function(){const t=k;return t>=l&&console.warn("THREE.WebGLTextures: Trying to use "+t+" texture units while this GPU supports only "+l),k+=1,t},this.resetTextureUnits=function(){k=0},this.setTexture2D=Y,this.setTexture2DArray=function(e,r){const s=i.get(e);e.version>0&&s.__version!==e.version?tt(s,e,r):n.bindTexture(t.TEXTURE_2D_ARRAY,s.__webglTexture,t.TEXTURE0+r)},this.setTexture3D=function(e,r){const s=i.get(e);e.version>0&&s.__version!==e.version?tt(s,e,r):n.bindTexture(t.TEXTURE_3D,s.__webglTexture,t.TEXTURE0+r)},this.setTextureCube=function(e,r){const a=i.get(e);e.version>0&&a.__version!==e.version?function(e,r,a){if(6!==r.image.length)return;const l=Q(e,r),h=r.source;n.bindTexture(t.TEXTURE_CUBE_MAP,e.__webglTexture,t.TEXTURE0+a);const u=i.get(h);if(h.version!==u.__version||!0===l){n.activeTexture(t.TEXTURE0+a);const e=Ae.getPrimaries(Ae.workingColorSpace),i=r.colorSpace===Ft?null:Ae.getPrimaries(r.colorSpace),d=r.colorSpace===Ft||e===i?t.NONE:t.BROWSER_DEFAULT_WEBGL;t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL,r.flipY),t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL,r.premultiplyAlpha),t.pixelStorei(t.UNPACK_ALIGNMENT,r.unpackAlignment),t.pixelStorei(t.UNPACK_COLORSPACE_CONVERSION_WEBGL,d);const p=r.isCompressedTexture||r.image[0].isCompressedTexture,m=r.image[0]&&r.image[0].isDataTexture,f=[];for(let t=0;t<6;t++)f[t]=p||m?m?r.image[t].image:r.image[t]:y(r.image[t],!1,!0,c),f[t]=at(r,f[t]);const g=f[0],_=x(g)||o,v=s.convert(r.format,r.colorSpace),E=s.convert(r.type),w=b(r.internalFormat,v,E,r.colorSpace),A=o&&!0!==r.isVideoTexture,R=void 0===u.__version||!0===l;let C,L=T(r,g,_);if($(t.TEXTURE_CUBE_MAP,r,_),p){A&&R&&n.texStorage2D(t.TEXTURE_CUBE_MAP,L,w,g.width,g.height);for(let e=0;e<6;e++){C=f[e].mipmaps;for(let i=0;i0&&L++,n.texStorage2D(t.TEXTURE_CUBE_MAP,L,w,f[0].width,f[0].height));for(let e=0;e<6;e++)if(m){A?n.texSubImage2D(t.TEXTURE_CUBE_MAP_POSITIVE_X+e,0,0,0,f[e].width,f[e].height,v,E,f[e].data):n.texImage2D(t.TEXTURE_CUBE_MAP_POSITIVE_X+e,0,w,f[e].width,f[e].height,0,v,E,f[e].data);for(let i=0;i0){c.__webglFramebuffer[e]=[];for(let n=0;n0){c.__webglFramebuffer=[];for(let e=0;e0&&!1===st(e)){const i=d?l:[l];c.__webglMultisampledFramebuffer=t.createFramebuffer(),c.__webglColorRenderbuffer=[],n.bindFramebuffer(t.FRAMEBUFFER,c.__webglMultisampledFramebuffer);for(let n=0;n0)for(let i=0;i0)for(let n=0;n0&&!1===st(e)){const r=e.isWebGLMultipleRenderTargets?e.texture:[e.texture],s=e.width,a=e.height;let o=t.COLOR_BUFFER_BIT;const l=[],c=e.stencilBuffer?t.DEPTH_STENCIL_ATTACHMENT:t.DEPTH_ATTACHMENT,h=i.get(e),u=!0===e.isWebGLMultipleRenderTargets;if(u)for(let e=0;eo+c?(l.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!l.inputState.pinching&&a<=o-c&&(l.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==o&&t.gripSpace&&(r=e.getPose(t.gripSpace,n),null!==r&&(o.matrix.fromArray(r.transform.matrix),o.matrix.decompose(o.position,o.rotation,o.scale),o.matrixWorldNeedsUpdate=!0,r.linearVelocity?(o.hasLinearVelocity=!0,o.linearVelocity.copy(r.linearVelocity)):o.hasLinearVelocity=!1,r.angularVelocity?(o.hasAngularVelocity=!0,o.angularVelocity.copy(r.angularVelocity)):o.hasAngularVelocity=!1));null!==a&&(i=e.getPose(t.targetRaySpace,n),null===i&&null!==r&&(i=r),null!==i&&(a.matrix.fromArray(i.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),a.matrixWorldNeedsUpdate=!0,i.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(i.linearVelocity)):a.hasLinearVelocity=!1,i.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(i.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(ja)))}return null!==a&&(a.visible=null!==i),null!==o&&(o.visible=null!==r),null!==l&&(l.visible=null!==s),this}_getHandJoint(t,e){if(void 0===t.joints[e.jointName]){const n=new Xa;n.matrixAutoUpdate=!1,n.visible=!1,t.joints[e.jointName]=n,t.add(n)}return t.joints[e.jointName]}}class Ya extends Oe{constructor(t,e,n,i,r,s,a,o,l,c){if((c=void 0!==c?c:j)!==j&&c!==q)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===n&&c===j&&(n=z),void 0===n&&c===q&&(n=W),super(null,i,r,s,a,o,c,n,l),this.isDepthTexture=!0,this.image={width:t,height:e},this.magFilter=void 0!==a?a:L,this.minFilter=void 0!==o?o:L,this.flipY=!1,this.generateMipmaps=!1,this.compareFunction=null}copy(t){return super.copy(t),this.compareFunction=t.compareFunction,this}toJSON(t){const e=super.toJSON(t);return null!==this.compareFunction&&(e.compareFunction=this.compareFunction),e}}class Za extends $t{constructor(t,e){super();const n=this;let i=null,r=1,s=null,a="local-floor",o=1,l=null,c=null,h=null,u=null,d=null,p=null;const m=e.getContextAttributes();let f=null,g=null;const _=[],v=[],y=new rr;y.layers.enable(1),y.viewport=new Fe;const x=new rr;x.layers.enable(2),x.viewport=new Fe;const M=[y,x],S=new Wa;S.layers.enable(1),S.layers.enable(2);let b=null,T=null;function E(t){const e=v.indexOf(t.inputSource);if(-1===e)return;const n=_[e];void 0!==n&&(n.update(t.inputSource,t.frame,l||s),n.dispatchEvent({type:t.type,data:t.inputSource}))}function w(){i.removeEventListener("select",E),i.removeEventListener("selectstart",E),i.removeEventListener("selectend",E),i.removeEventListener("squeeze",E),i.removeEventListener("squeezestart",E),i.removeEventListener("squeezeend",E),i.removeEventListener("end",w),i.removeEventListener("inputsourceschange",A);for(let t=0;t<_.length;t++){const e=v[t];null!==e&&(v[t]=null,_[t].disconnect(e))}b=null,T=null,t.setRenderTarget(f),d=null,u=null,h=null,i=null,g=null,I.stop(),n.isPresenting=!1,n.dispatchEvent({type:"sessionend"})}function A(t){for(let e=0;e=0&&(v[i]=null,_[i].disconnect(n))}for(let e=0;e=v.length){v.push(n),i=t;break}if(null===v[t]){v[t]=n,i=t;break}}if(-1===i)break}const r=_[i];r&&r.connect(n)}}this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(t){let e=_[t];return void 0===e&&(e=new qa,_[t]=e),e.getTargetRaySpace()},this.getControllerGrip=function(t){let e=_[t];return void 0===e&&(e=new qa,_[t]=e),e.getGripSpace()},this.getHand=function(t){let e=_[t];return void 0===e&&(e=new qa,_[t]=e),e.getHandSpace()},this.setFramebufferScaleFactor=function(t){r=t,!0===n.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(t){a=t,!0===n.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return l||s},this.setReferenceSpace=function(t){l=t},this.getBaseLayer=function(){return null!==u?u:d},this.getBinding=function(){return h},this.getFrame=function(){return p},this.getSession=function(){return i},this.setSession=async function(c){if(i=c,null!==i){if(f=t.getRenderTarget(),i.addEventListener("select",E),i.addEventListener("selectstart",E),i.addEventListener("selectend",E),i.addEventListener("squeeze",E),i.addEventListener("squeezestart",E),i.addEventListener("squeezeend",E),i.addEventListener("end",w),i.addEventListener("inputsourceschange",A),!0!==m.xrCompatible&&await e.makeXRCompatible(),void 0===i.renderState.layers||!1===t.capabilities.isWebGL2){const n={antialias:void 0!==i.renderState.layers||m.antialias,alpha:!0,depth:m.depth,stencil:m.stencil,framebufferScaleFactor:r};d=new XRWebGLLayer(i,e,n),i.updateRenderState({baseLayer:d}),g=new ze(d.framebufferWidth,d.framebufferHeight,{format:X,type:O,colorSpace:t.outputColorSpace,stencilBuffer:m.stencil})}else{let n=null,s=null,a=null;m.depth&&(a=m.stencil?e.DEPTH24_STENCIL8:e.DEPTH_COMPONENT24,n=m.stencil?q:j,s=m.stencil?W:z);const o={colorFormat:e.RGBA8,depthFormat:a,scaleFactor:r};h=new XRWebGLBinding(i,e),u=h.createProjectionLayer(o),i.updateRenderState({layers:[u]}),g=new ze(u.textureWidth,u.textureHeight,{format:X,type:O,depthTexture:new Ya(u.textureWidth,u.textureHeight,s,void 0,void 0,void 0,void 0,void 0,void 0,n),stencilBuffer:m.stencil,colorSpace:t.outputColorSpace,samples:m.antialias?4:0});t.properties.get(g).__ignoreDepthValues=u.ignoreDepthValues}g.isXRRenderTarget=!0,this.setFoveation(o),l=null,s=await i.requestReferenceSpace(a),I.setContext(i),I.start(),n.isPresenting=!0,n.dispatchEvent({type:"sessionstart"})}},this.getEnvironmentBlendMode=function(){if(null!==i)return i.environmentBlendMode};const R=new ke,C=new ke;function L(t,e){null===e?t.matrixWorld.copy(t.matrix):t.matrixWorld.multiplyMatrices(e.matrixWorld,t.matrix),t.matrixWorldInverse.copy(t.matrixWorld).invert()}this.updateCamera=function(t){if(null===i)return;S.near=x.near=y.near=t.near,S.far=x.far=y.far=t.far,b===S.near&&T===S.far||(i.updateRenderState({depthNear:S.near,depthFar:S.far}),b=S.near,T=S.far);const e=t.parent,n=S.cameras;L(S,e);for(let t=0;t0&&(i.alphaTest.value=r.alphaTest);const s=e.get(r).envMap;if(s&&(i.envMap.value=s,i.flipEnvMap.value=s.isCubeTexture&&!1===s.isRenderTargetTexture?-1:1,i.reflectivity.value=r.reflectivity,i.ior.value=r.ior,i.refractionRatio.value=r.refractionRatio),r.lightMap){i.lightMap.value=r.lightMap;const e=!0===t._useLegacyLights?Math.PI:1;i.lightMapIntensity.value=r.lightMapIntensity*e,n(r.lightMap,i.lightMapTransform)}r.aoMap&&(i.aoMap.value=r.aoMap,i.aoMapIntensity.value=r.aoMapIntensity,n(r.aoMap,i.aoMapTransform))}return{refreshFogUniforms:function(e,n){n.color.getRGB(e.fogColor.value,tr(t)),n.isFog?(e.fogNear.value=n.near,e.fogFar.value=n.far):n.isFogExp2&&(e.fogDensity.value=n.density)},refreshMaterialUniforms:function(t,r,s,o,l){r.isMeshBasicMaterial||r.isMeshLambertMaterial?i(t,r):r.isMeshToonMaterial?(i(t,r),function(t,e){e.gradientMap&&(t.gradientMap.value=e.gradientMap)}(t,r)):r.isMeshPhongMaterial?(i(t,r),function(t,e){t.specular.value.copy(e.specular),t.shininess.value=Math.max(e.shininess,1e-4)}(t,r)):r.isMeshStandardMaterial?(i(t,r),function(t,i){t.metalness.value=i.metalness,i.metalnessMap&&(t.metalnessMap.value=i.metalnessMap,n(i.metalnessMap,t.metalnessMapTransform));t.roughness.value=i.roughness,i.roughnessMap&&(t.roughnessMap.value=i.roughnessMap,n(i.roughnessMap,t.roughnessMapTransform));const r=e.get(i).envMap;r&&(t.envMapIntensity.value=i.envMapIntensity)}(t,r),r.isMeshPhysicalMaterial&&function(t,e,i){t.ior.value=e.ior,e.sheen>0&&(t.sheenColor.value.copy(e.sheenColor).multiplyScalar(e.sheen),t.sheenRoughness.value=e.sheenRoughness,e.sheenColorMap&&(t.sheenColorMap.value=e.sheenColorMap,n(e.sheenColorMap,t.sheenColorMapTransform)),e.sheenRoughnessMap&&(t.sheenRoughnessMap.value=e.sheenRoughnessMap,n(e.sheenRoughnessMap,t.sheenRoughnessMapTransform)));e.clearcoat>0&&(t.clearcoat.value=e.clearcoat,t.clearcoatRoughness.value=e.clearcoatRoughness,e.clearcoatMap&&(t.clearcoatMap.value=e.clearcoatMap,n(e.clearcoatMap,t.clearcoatMapTransform)),e.clearcoatRoughnessMap&&(t.clearcoatRoughnessMap.value=e.clearcoatRoughnessMap,n(e.clearcoatRoughnessMap,t.clearcoatRoughnessMapTransform)),e.clearcoatNormalMap&&(t.clearcoatNormalMap.value=e.clearcoatNormalMap,n(e.clearcoatNormalMap,t.clearcoatNormalMapTransform),t.clearcoatNormalScale.value.copy(e.clearcoatNormalScale),e.side===a&&t.clearcoatNormalScale.value.negate()));e.iridescence>0&&(t.iridescence.value=e.iridescence,t.iridescenceIOR.value=e.iridescenceIOR,t.iridescenceThicknessMinimum.value=e.iridescenceThicknessRange[0],t.iridescenceThicknessMaximum.value=e.iridescenceThicknessRange[1],e.iridescenceMap&&(t.iridescenceMap.value=e.iridescenceMap,n(e.iridescenceMap,t.iridescenceMapTransform)),e.iridescenceThicknessMap&&(t.iridescenceThicknessMap.value=e.iridescenceThicknessMap,n(e.iridescenceThicknessMap,t.iridescenceThicknessMapTransform)));e.transmission>0&&(t.transmission.value=e.transmission,t.transmissionSamplerMap.value=i.texture,t.transmissionSamplerSize.value.set(i.width,i.height),e.transmissionMap&&(t.transmissionMap.value=e.transmissionMap,n(e.transmissionMap,t.transmissionMapTransform)),t.thickness.value=e.thickness,e.thicknessMap&&(t.thicknessMap.value=e.thicknessMap,n(e.thicknessMap,t.thicknessMapTransform)),t.attenuationDistance.value=e.attenuationDistance,t.attenuationColor.value.copy(e.attenuationColor));e.anisotropy>0&&(t.anisotropyVector.value.set(e.anisotropy*Math.cos(e.anisotropyRotation),e.anisotropy*Math.sin(e.anisotropyRotation)),e.anisotropyMap&&(t.anisotropyMap.value=e.anisotropyMap,n(e.anisotropyMap,t.anisotropyMapTransform)));t.specularIntensity.value=e.specularIntensity,t.specularColor.value.copy(e.specularColor),e.specularColorMap&&(t.specularColorMap.value=e.specularColorMap,n(e.specularColorMap,t.specularColorMapTransform));e.specularIntensityMap&&(t.specularIntensityMap.value=e.specularIntensityMap,n(e.specularIntensityMap,t.specularIntensityMapTransform))}(t,r,l)):r.isMeshMatcapMaterial?(i(t,r),function(t,e){e.matcap&&(t.matcap.value=e.matcap)}(t,r)):r.isMeshDepthMaterial?i(t,r):r.isMeshDistanceMaterial?(i(t,r),function(t,n){const i=e.get(n).light;t.referencePosition.value.setFromMatrixPosition(i.matrixWorld),t.nearDistance.value=i.shadow.camera.near,t.farDistance.value=i.shadow.camera.far}(t,r)):r.isMeshNormalMaterial?i(t,r):r.isLineBasicMaterial?(function(t,e){t.diffuse.value.copy(e.color),t.opacity.value=e.opacity,e.map&&(t.map.value=e.map,n(e.map,t.mapTransform))}(t,r),r.isLineDashedMaterial&&function(t,e){t.dashSize.value=e.dashSize,t.totalSize.value=e.dashSize+e.gapSize,t.scale.value=e.scale}(t,r)):r.isPointsMaterial?function(t,e,i,r){t.diffuse.value.copy(e.color),t.opacity.value=e.opacity,t.size.value=e.size*i,t.scale.value=.5*r,e.map&&(t.map.value=e.map,n(e.map,t.uvTransform));e.alphaMap&&(t.alphaMap.value=e.alphaMap,n(e.alphaMap,t.alphaMapTransform));e.alphaTest>0&&(t.alphaTest.value=e.alphaTest)}(t,r,s,o):r.isSpriteMaterial?function(t,e){t.diffuse.value.copy(e.color),t.opacity.value=e.opacity,t.rotation.value=e.rotation,e.map&&(t.map.value=e.map,n(e.map,t.mapTransform));e.alphaMap&&(t.alphaMap.value=e.alphaMap,n(e.alphaMap,t.alphaMapTransform));e.alphaTest>0&&(t.alphaTest.value=e.alphaTest)}(t,r):r.isShadowMaterial?(t.color.value.copy(r.color),t.opacity.value=r.opacity):r.isShaderMaterial&&(r.uniformsNeedUpdate=!1)}}}function Ka(t,e,n,i){let r={},s={},a=[];const o=n.isWebGL2?t.getParameter(t.MAX_UNIFORM_BUFFER_BINDINGS):0;function l(t,e,n){const i=t.value;if(void 0===n[e]){if("number"==typeof i)n[e]=i;else{const t=Array.isArray(i)?i:[i],r=[];for(let e=0;e0){r=n%i;0!==r&&i-r-a.boundary<0&&(n+=i-r,s.__offset=n)}n+=a.storage}r=n%i,r>0&&(n+=i-r);t.__size=n,t.__cache={}}(n),d=function(e){const n=function(){for(let t=0;t0),u=!!n.morphAttributes.position,d=!!n.morphAttributes.normal,m=!!n.morphAttributes.color;let f=p;i.toneMapped&&(null!==w&&!0!==w.isXRRenderTarget||(f=S.toneMapping));const g=n.morphAttributes.position||n.morphAttributes.normal||n.morphAttributes.color,_=void 0!==g?g.length:0,v=mt.get(i),x=y.state.lights;if(!0===nt&&(!0===it||t!==R)){const e=t===R&&i.id===A;Et.setState(i,t,e)}let M=!1;i.version===v.__version?v.needsLights&&v.lightsStateVersion!==x.state.version||v.outputColorSpace!==o||r.isInstancedMesh&&!1===v.instancing?M=!0:r.isInstancedMesh||!0!==v.instancing?r.isSkinnedMesh&&!1===v.skinning?M=!0:r.isSkinnedMesh||!0!==v.skinning?r.isInstancedMesh&&!0===v.instancingColor&&null===r.instanceColor||r.isInstancedMesh&&!1===v.instancingColor&&null!==r.instanceColor||v.envMap!==l||!0===i.fog&&v.fog!==s?M=!0:void 0===v.numClippingPlanes||v.numClippingPlanes===Et.numPlanes&&v.numIntersection===Et.numIntersection?(v.vertexAlphas!==c||v.vertexTangents!==h||v.morphTargets!==u||v.morphNormals!==d||v.morphColors!==m||v.toneMapping!==f||!0===ut.isWebGL2&&v.morphTargetsCount!==_)&&(M=!0):M=!0:M=!0:M=!0:(M=!0,v.__version=i.version);let b=v.currentProgram;!0===M&&(b=Qt(i,e,r));let T=!1,E=!1,C=!1;const L=b.getUniforms(),P=v.uniforms;dt.useProgram(b.program)&&(T=!0,E=!0,C=!0);i.id!==A&&(A=i.id,E=!0);if(T||R!==t){L.setValue(Dt,"projectionMatrix",t.projectionMatrix),L.setValue(Dt,"viewMatrix",t.matrixWorldInverse);const e=L.map.cameraPosition;void 0!==e&&e.setValue(Dt,ot.setFromMatrixPosition(t.matrixWorld)),ut.logarithmicDepthBuffer&&L.setValue(Dt,"logDepthBufFC",2/(Math.log(t.far+1)/Math.LN2)),(i.isMeshPhongMaterial||i.isMeshToonMaterial||i.isMeshLambertMaterial||i.isMeshBasicMaterial||i.isMeshStandardMaterial||i.isShaderMaterial)&&L.setValue(Dt,"isOrthographic",!0===t.isOrthographicCamera),R!==t&&(R=t,E=!0,C=!0)}if(r.isSkinnedMesh){L.setOptional(Dt,r,"bindMatrix"),L.setOptional(Dt,r,"bindMatrixInverse");const t=r.skeleton;t&&(ut.floatVertexTextures?(null===t.boneTexture&&t.computeBoneTexture(),L.setValue(Dt,"boneTexture",t.boneTexture,ft),L.setValue(Dt,"boneTextureSize",t.boneTextureSize)):console.warn("THREE.WebGLRenderer: SkinnedMesh can only be used with WebGL 2. With WebGL 1 OES_texture_float and vertex textures support is required."))}const I=n.morphAttributes;(void 0!==I.position||void 0!==I.normal||void 0!==I.color&&!0===ut.isWebGL2)&&Rt.update(r,n,b);(E||v.receiveShadow!==r.receiveShadow)&&(v.receiveShadow=r.receiveShadow,L.setValue(Dt,"receiveShadow",r.receiveShadow));i.isMeshGouraudMaterial&&null!==i.envMap&&(P.envMap.value=l,P.flipEnvMap.value=l.isCubeTexture&&!1===l.isRenderTargetTexture?-1:1);E&&(L.setValue(Dt,"toneMappingExposure",S.toneMappingExposure),v.needsLights&&(D=C,(U=P).ambientLightColor.needsUpdate=D,U.lightProbe.needsUpdate=D,U.directionalLights.needsUpdate=D,U.directionalLightShadows.needsUpdate=D,U.pointLights.needsUpdate=D,U.pointLightShadows.needsUpdate=D,U.spotLights.needsUpdate=D,U.spotLightShadows.needsUpdate=D,U.rectAreaLights.needsUpdate=D,U.hemisphereLights.needsUpdate=D),s&&!0===i.fog&&St.refreshFogUniforms(P,s),St.refreshMaterialUniforms(P,i,j,B,rt),ra.upload(Dt,te(v),P,ft));var U,D;i.isShaderMaterial&&!0===i.uniformsNeedUpdate&&(ra.upload(Dt,te(v),P,ft),i.uniformsNeedUpdate=!1);i.isSpriteMaterial&&L.setValue(Dt,"center",r.center);if(L.setValue(Dt,"modelViewMatrix",r.modelViewMatrix),L.setValue(Dt,"normalMatrix",r.normalMatrix),L.setValue(Dt,"modelMatrix",r.matrixWorld),i.isShaderMaterial||i.isRawShaderMaterial){const t=i.uniformsGroups;for(let e=0,n=t.length;e{function n(){i.forEach((function(t){mt.get(t).currentProgram.isReady()&&i.delete(t)})),0!==i.size?setTimeout(n,10):e(t)}null!==ht.get("KHR_parallel_shader_compile")?n():setTimeout(n,10)}))};let Xt=null;function jt(){Yt.stop()}function qt(){Yt.start()}const Yt=new gr;function Zt(t,e,n,i){if(!1===t.visible)return;if(t.layers.test(e.layers))if(t.isGroup)n=t.renderOrder;else if(t.isLOD)!0===t.autoUpdate&&t.update(e);else if(t.isLight)y.pushLight(t),t.castShadow&&y.pushShadow(t);else if(t.isSprite){if(!t.frustumCulled||et.intersectsSprite(t)){i&&ot.setFromMatrixPosition(t.matrixWorld).applyMatrix4(st);const e=xt.update(t),r=t.material;r.visible&&v.push(t,e,r,n,ot.z,null)}}else if((t.isMesh||t.isLine||t.isPoints)&&(!t.frustumCulled||et.intersectsObject(t))){const e=xt.update(t),r=t.material;if(i&&(void 0!==t.boundingSphere?(null===t.boundingSphere&&t.computeBoundingSphere(),ot.copy(t.boundingSphere.center)):(null===e.boundingSphere&&e.computeBoundingSphere(),ot.copy(e.boundingSphere.center)),ot.applyMatrix4(t.matrixWorld).applyMatrix4(st)),Array.isArray(r)){const i=e.groups;for(let s=0,a=i.length;s0&&function(t,e,n,i){const r=!0===n.isScene?n.overrideMaterial:null;if(null!==r)return;const s=ut.isWebGL2;null===rt&&(rt=new ze(1,1,{generateMipmaps:!0,type:ht.has("EXT_color_buffer_half_float")?G:O,minFilter:N,samples:s?4:0}));S.getDrawingBufferSize(at),s?rt.setSize(at.x,at.y):rt.setSize(ce(at.x),ce(at.y));const o=S.getRenderTarget();S.setRenderTarget(rt),S.getClearColor(I),U=S.getClearAlpha(),U<1&&S.setClearColor(16777215,.5);S.clear();const l=S.toneMapping;S.toneMapping=p,Kt(t,n,i),ft.updateMultisampleRenderTarget(rt),ft.updateRenderTargetMipmap(rt);let c=!1;for(let t=0,r=e.length;t0&&Kt(r,e,n),s.length>0&&Kt(s,e,n),o.length>0&&Kt(o,e,n),dt.buffers.depth.setTest(!0),dt.buffers.depth.setMask(!0),dt.buffers.color.setMask(!0),dt.setPolygonOffset(!1)}function Kt(t,e,n){const i=!0===e.isScene?e.overrideMaterial:null;for(let r=0,s=t.length;r0?M[M.length-1]:null,x.pop(),v=x.length>0?x[x.length-1]:null},this.getActiveCubeFace=function(){return T},this.getActiveMipmapLevel=function(){return E},this.getRenderTarget=function(){return w},this.setRenderTargetTextures=function(t,e,n){mt.get(t.texture).__webglTexture=e,mt.get(t.depthTexture).__webglTexture=n;const i=mt.get(t);i.__hasExternalTextures=!0,i.__hasExternalTextures&&(i.__autoAllocateDepthBuffer=void 0===n,i.__autoAllocateDepthBuffer||!0===ht.has("WEBGL_multisampled_render_to_texture")&&(console.warn("THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided"),i.__useRenderToTexture=!1))},this.setRenderTargetFramebuffer=function(t,e){const n=mt.get(t);n.__webglFramebuffer=e,n.__useDefaultFramebuffer=void 0===e},this.setRenderTarget=function(t,e=0,n=0){w=t,T=e,E=n;let i=!0,r=null,s=!1,a=!1;if(t){const o=mt.get(t);void 0!==o.__useDefaultFramebuffer?(dt.bindFramebuffer(Dt.FRAMEBUFFER,null),i=!1):void 0===o.__webglFramebuffer?ft.setupRenderTarget(t):o.__hasExternalTextures&&ft.rebindTextures(t,mt.get(t.texture).__webglTexture,mt.get(t.depthTexture).__webglTexture);const l=t.texture;(l.isData3DTexture||l.isDataArrayTexture||l.isCompressedArrayTexture)&&(a=!0);const c=mt.get(t).__webglFramebuffer;t.isWebGLCubeRenderTarget?(r=Array.isArray(c[e])?c[e][n]:c[e],s=!0):r=ut.isWebGL2&&t.samples>0&&!1===ft.useMultisampledRTT(t)?mt.get(t).__webglMultisampledFramebuffer:Array.isArray(c)?c[n]:c,C.copy(t.viewport),L.copy(t.scissor),P=t.scissorTest}else C.copy($).multiplyScalar(j).floor(),L.copy(Q).multiplyScalar(j).floor(),P=tt;if(dt.bindFramebuffer(Dt.FRAMEBUFFER,r)&&ut.drawBuffers&&i&&dt.drawBuffers(t,r),dt.viewport(C),dt.scissor(L),dt.setScissorTest(P),s){const i=mt.get(t.texture);Dt.framebufferTexture2D(Dt.FRAMEBUFFER,Dt.COLOR_ATTACHMENT0,Dt.TEXTURE_CUBE_MAP_POSITIVE_X+e,i.__webglTexture,n)}else if(a){const i=mt.get(t.texture),r=e||0;Dt.framebufferTextureLayer(Dt.FRAMEBUFFER,Dt.COLOR_ATTACHMENT0,i.__webglTexture,n||0,r)}A=-1},this.readRenderTargetPixels=function(t,e,n,i,r,s,a){if(!t||!t.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let o=mt.get(t).__webglFramebuffer;if(t.isWebGLCubeRenderTarget&&void 0!==a&&(o=o[a]),o){dt.bindFramebuffer(Dt.FRAMEBUFFER,o);try{const a=t.texture,o=a.format,l=a.type;if(o!==X&&Pt.convert(o)!==Dt.getParameter(Dt.IMPLEMENTATION_COLOR_READ_FORMAT))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");const c=l===G&&(ht.has("EXT_color_buffer_half_float")||ut.isWebGL2&&ht.has("EXT_color_buffer_float"));if(!(l===O||Pt.convert(l)===Dt.getParameter(Dt.IMPLEMENTATION_COLOR_READ_TYPE)||l===H&&(ut.isWebGL2||ht.has("OES_texture_float")||ht.has("WEBGL_color_buffer_float"))||c))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");e>=0&&e<=t.width-i&&n>=0&&n<=t.height-r&&Dt.readPixels(e,n,i,r,Pt.convert(o),Pt.convert(l),s)}finally{const t=null!==w?mt.get(w).__webglFramebuffer:null;dt.bindFramebuffer(Dt.FRAMEBUFFER,t)}}},this.copyFramebufferToTexture=function(t,e,n=0){const i=Math.pow(2,-n),r=Math.floor(e.image.width*i),s=Math.floor(e.image.height*i);ft.setTexture2D(e,0),Dt.copyTexSubImage2D(Dt.TEXTURE_2D,n,0,0,t.x,t.y,r,s),dt.unbindTexture()},this.copyTextureToTexture=function(t,e,n,i=0){const r=e.image.width,s=e.image.height,a=Pt.convert(n.format),o=Pt.convert(n.type);ft.setTexture2D(n,0),Dt.pixelStorei(Dt.UNPACK_FLIP_Y_WEBGL,n.flipY),Dt.pixelStorei(Dt.UNPACK_PREMULTIPLY_ALPHA_WEBGL,n.premultiplyAlpha),Dt.pixelStorei(Dt.UNPACK_ALIGNMENT,n.unpackAlignment),e.isDataTexture?Dt.texSubImage2D(Dt.TEXTURE_2D,i,t.x,t.y,r,s,a,o,e.image.data):e.isCompressedTexture?Dt.compressedTexSubImage2D(Dt.TEXTURE_2D,i,t.x,t.y,e.mipmaps[0].width,e.mipmaps[0].height,a,e.mipmaps[0].data):Dt.texSubImage2D(Dt.TEXTURE_2D,i,t.x,t.y,a,o,e.image),0===i&&n.generateMipmaps&&Dt.generateMipmap(Dt.TEXTURE_2D),dt.unbindTexture()},this.copyTextureToTexture3D=function(t,e,n,i,r=0){if(S.isWebGL1Renderer)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");const s=t.max.x-t.min.x+1,a=t.max.y-t.min.y+1,o=t.max.z-t.min.z+1,l=Pt.convert(i.format),c=Pt.convert(i.type);let h;if(i.isData3DTexture)ft.setTexture3D(i,0),h=Dt.TEXTURE_3D;else{if(!i.isDataArrayTexture)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");ft.setTexture2DArray(i,0),h=Dt.TEXTURE_2D_ARRAY}Dt.pixelStorei(Dt.UNPACK_FLIP_Y_WEBGL,i.flipY),Dt.pixelStorei(Dt.UNPACK_PREMULTIPLY_ALPHA_WEBGL,i.premultiplyAlpha),Dt.pixelStorei(Dt.UNPACK_ALIGNMENT,i.unpackAlignment);const u=Dt.getParameter(Dt.UNPACK_ROW_LENGTH),d=Dt.getParameter(Dt.UNPACK_IMAGE_HEIGHT),p=Dt.getParameter(Dt.UNPACK_SKIP_PIXELS),m=Dt.getParameter(Dt.UNPACK_SKIP_ROWS),f=Dt.getParameter(Dt.UNPACK_SKIP_IMAGES),g=n.isCompressedTexture?n.mipmaps[0]:n.image;Dt.pixelStorei(Dt.UNPACK_ROW_LENGTH,g.width),Dt.pixelStorei(Dt.UNPACK_IMAGE_HEIGHT,g.height),Dt.pixelStorei(Dt.UNPACK_SKIP_PIXELS,t.min.x),Dt.pixelStorei(Dt.UNPACK_SKIP_ROWS,t.min.y),Dt.pixelStorei(Dt.UNPACK_SKIP_IMAGES,t.min.z),n.isDataTexture||n.isData3DTexture?Dt.texSubImage3D(h,r,e.x,e.y,e.z,s,a,o,l,c,g.data):n.isCompressedArrayTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),Dt.compressedTexSubImage3D(h,r,e.x,e.y,e.z,s,a,o,l,g.data)):Dt.texSubImage3D(h,r,e.x,e.y,e.z,s,a,o,l,c,g),Dt.pixelStorei(Dt.UNPACK_ROW_LENGTH,u),Dt.pixelStorei(Dt.UNPACK_IMAGE_HEIGHT,d),Dt.pixelStorei(Dt.UNPACK_SKIP_PIXELS,p),Dt.pixelStorei(Dt.UNPACK_SKIP_ROWS,m),Dt.pixelStorei(Dt.UNPACK_SKIP_IMAGES,f),0===r&&i.generateMipmaps&&Dt.generateMipmap(h),dt.unbindTexture()},this.initTexture=function(t){t.isCubeTexture?ft.setTextureCube(t,0):t.isData3DTexture?ft.setTexture3D(t,0):t.isDataArrayTexture||t.isCompressedArrayTexture?ft.setTexture2DArray(t,0):ft.setTexture2D(t,0),dt.unbindTexture()},this.resetState=function(){T=0,E=0,w=null,dt.reset(),It.reset()},"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}get coordinateSystem(){return Jt}get outputColorSpace(){return this._outputColorSpace}set outputColorSpace(t){this._outputColorSpace=t;const e=this.getContext();e.drawingBufferColorSpace=t===Ht?"display-p3":"srgb",e.unpackColorSpace=Ae.workingColorSpace===Gt?"display-p3":"srgb"}get physicallyCorrectLights(){return console.warn("THREE.WebGLRenderer: The property .physicallyCorrectLights has been removed. Set renderer.useLegacyLights instead."),!this.useLegacyLights}set physicallyCorrectLights(t){console.warn("THREE.WebGLRenderer: The property .physicallyCorrectLights has been removed. Set renderer.useLegacyLights instead."),this.useLegacyLights=!t}get outputEncoding(){return console.warn("THREE.WebGLRenderer: Property .outputEncoding has been removed. Use .outputColorSpace instead."),this.outputColorSpace===Bt?Ot:Nt}set outputEncoding(t){console.warn("THREE.WebGLRenderer: Property .outputEncoding has been removed. Use .outputColorSpace instead."),this.outputColorSpace=t===Ot?Bt:zt}get useLegacyLights(){return console.warn("THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733."),this._useLegacyLights}set useLegacyLights(t){console.warn("THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733."),this._useLegacyLights=t}}class Qa extends $a{}Qa.prototype.isWebGL1Renderer=!0;class to{constructor(t,e=25e-5){this.isFogExp2=!0,this.name="",this.color=new li(t),this.density=e}clone(){return new to(this.color,this.density)}toJSON(){return{type:"FogExp2",name:this.name,color:this.color.getHex(),density:this.density}}}class eo{constructor(t,e=1,n=1e3){this.isFog=!0,this.name="",this.color=new li(t),this.near=e,this.far=n}clone(){return new eo(this.color,this.near,this.far)}toJSON(){return{type:"Fog",name:this.name,color:this.color.getHex(),near:this.near,far:this.far}}}class no extends Xn{constructor(){super(),this.isScene=!0,this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.backgroundBlurriness=0,this.backgroundIntensity=1,this.overrideMaterial=null,"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),this.backgroundBlurriness=t.backgroundBlurriness,this.backgroundIntensity=t.backgroundIntensity,null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){const e=super.toJSON(t);return null!==this.fog&&(e.object.fog=this.fog.toJSON()),this.backgroundBlurriness>0&&(e.object.backgroundBlurriness=this.backgroundBlurriness),1!==this.backgroundIntensity&&(e.object.backgroundIntensity=this.backgroundIntensity),e}}class io{constructor(t,e){this.isInterleavedBuffer=!0,this.array=t,this.stride=e,this.count=void 0!==t?t.length/e:0,this.usage=qt,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=ie()}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,n){t*=this.stride,n*=e.stride;for(let i=0,r=this.stride;it.far||e.push({distance:o,point:lo.clone(),uv:ii.getInterpolation(lo,fo,go,_o,vo,yo,xo,new pe),face:null,object:this})}copy(t,e){return super.copy(t,e),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}}function So(t,e,n,i,r,s){uo.subVectors(t,n).addScalar(.5).multiply(i),void 0!==r?(po.x=s*uo.x-r*uo.y,po.y=r*uo.x+s*uo.y):po.copy(uo),t.copy(e),t.x+=po.x,t.y+=po.y,t.applyMatrix4(mo)}const bo=new ke,To=new ke;class Eo extends Xn{constructor(){super(),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]},isLOD:{value:!0}}),this.autoUpdate=!0}copy(t){super.copy(t,!1);const e=t.levels;for(let t=0,n=e.length;t0){let n,i;for(n=1,i=e.length;n0){bo.setFromMatrixPosition(this.matrixWorld);const n=t.ray.origin.distanceTo(bo);this.getObjectForDistance(n).raycast(t,e)}}update(t){const e=this.levels;if(e.length>1){bo.setFromMatrixPosition(t.matrixWorld),To.setFromMatrixPosition(this.matrixWorld);const n=bo.distanceTo(To)/t.zoom;let i,r;for(e[0].object.visible=!0,i=1,r=e.length;i=t))break;e[i-1].object.visible=!1,e[i].object.visible=!0}for(this._currentLevel=i-1;io)continue;u.applyMatrix4(this.matrixWorld);const s=t.ray.origin.distanceTo(u);st.far||e.push({distance:s,point:h.clone().applyMatrix4(this.matrixWorld),index:n,face:null,faceIndex:null,object:this})}}else{for(let n=Math.max(0,s.start),i=Math.min(m.count,s.start+s.count)-1;no)continue;u.applyMatrix4(this.matrixWorld);const i=t.ray.origin.distanceTo(u);it.far||e.push({distance:i,point:h.clone().applyMatrix4(this.matrixWorld),index:n,face:null,faceIndex:null,object:this})}}}updateMorphTargets(){const t=this.geometry.morphAttributes,e=Object.keys(t);if(e.length>0){const n=t[e[0]];if(void 0!==n){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let t=0,e=n.length;t0){const n=t[e[0]];if(void 0!==n){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let t=0,e=n.length;tr.far)return;s.push({distance:l,distanceToRay:Math.sqrt(o),point:n,index:e,face:null,object:a})}}class ml extends Oe{constructor(t,e,n,i,r,s,a,o,l,c,h,u){super(null,s,a,o,l,c,i,r,h,u),this.isCompressedTexture=!0,this.image={width:e,height:n},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}}class fl{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){const n=this.getUtoTmapping(t);return this.getPoint(n,e)}getPoints(t=5){const e=[];for(let n=0;n<=t;n++)e.push(this.getPoint(n/t));return e}getSpacedPoints(t=5){const e=[];for(let n=0;n<=t;n++)e.push(this.getPointAt(n/t));return e}getLength(){const t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;const e=[];let n,i=this.getPoint(0),r=0;e.push(0);for(let s=1;s<=t;s++)n=this.getPoint(s/t),r+=n.distanceTo(i),e.push(r),i=n;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){const n=this.getLengths();let i=0;const r=n.length;let s;s=e||t*n[r-1];let a,o=0,l=r-1;for(;o<=l;)if(i=Math.floor(o+(l-o)/2),a=n[i]-s,a<0)o=i+1;else{if(!(a>0)){l=i;break}l=i-1}if(i=l,n[i]===s)return i/(r-1);const c=n[i];return(i+(s-c)/(n[i+1]-c))/(r-1)}getTangent(t,e){const n=1e-4;let i=t-n,r=t+n;i<0&&(i=0),r>1&&(r=1);const s=this.getPoint(i),a=this.getPoint(r),o=e||(s.isVector2?new pe:new ke);return o.copy(a).sub(s).normalize(),o}getTangentAt(t,e){const n=this.getUtoTmapping(t);return this.getTangent(n,e)}computeFrenetFrames(t,e){const n=new ke,i=[],r=[],s=[],a=new ke,o=new xn;for(let e=0;e<=t;e++){const n=e/t;i[e]=this.getTangentAt(n,new ke)}r[0]=new ke,s[0]=new ke;let l=Number.MAX_VALUE;const c=Math.abs(i[0].x),h=Math.abs(i[0].y),u=Math.abs(i[0].z);c<=l&&(l=c,n.set(1,0,0)),h<=l&&(l=h,n.set(0,1,0)),u<=l&&n.set(0,0,1),a.crossVectors(i[0],n).normalize(),r[0].crossVectors(i[0],a),s[0].crossVectors(i[0],r[0]);for(let e=1;e<=t;e++){if(r[e]=r[e-1].clone(),s[e]=s[e-1].clone(),a.crossVectors(i[e-1],i[e]),a.length()>Number.EPSILON){a.normalize();const t=Math.acos(re(i[e-1].dot(i[e]),-1,1));r[e].applyMatrix4(o.makeRotationAxis(a,t))}s[e].crossVectors(i[e],r[e])}if(!0===e){let e=Math.acos(re(r[0].dot(r[t]),-1,1));e/=t,i[0].dot(a.crossVectors(r[0],r[t]))>0&&(e=-e);for(let n=1;n<=t;n++)r[n].applyMatrix4(o.makeRotationAxis(i[n],e*n)),s[n].crossVectors(i[n],r[n])}return{tangents:i,normals:r,binormals:s}}clone(){return(new this.constructor).copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){const t={metadata:{version:4.6,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}class gl extends fl{constructor(t=0,e=0,n=1,i=1,r=0,s=2*Math.PI,a=!1,o=0){super(),this.isEllipseCurve=!0,this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=n,this.yRadius=i,this.aStartAngle=r,this.aEndAngle=s,this.aClockwise=a,this.aRotation=o}getPoint(t,e){const n=e||new pe,i=2*Math.PI;let r=this.aEndAngle-this.aStartAngle;const s=Math.abs(r)i;)r-=i;r0?0:(Math.floor(Math.abs(l)/r)+1)*r:0===c&&l===r-1&&(l=r-2,c=1),this.closed||l>0?a=i[(l-1)%r]:(yl.subVectors(i[0],i[1]).add(i[0]),a=yl);const h=i[l%r],u=i[(l+1)%r];if(this.closed||l+2i.length-2?i.length-1:s+1],h=i[s>i.length-3?i.length-1:s+2];return n.set(Tl(a,o.x,l.x,c.x,h.x),Tl(a,o.y,l.y,c.y,h.y)),n}copy(t){super.copy(t),this.points=[];for(let e=0,n=t.points.length;e=n){const t=i[r]-n,s=this.curves[r],a=s.getLength(),o=0===a?0:1-t/a;return s.getPointAt(o,e)}r++}return null}getLength(){const t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;const t=[];let e=0;for(let n=0,i=this.curves.length;n1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,n=t.curves.length;e0){const t=l.getPoint(0);t.equals(this.currentPoint)||this.lineTo(t.x,t.y)}this.curves.push(l);const c=l.getPoint(1);return this.currentPoint.copy(c),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){const t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}}class Fl extends Pi{constructor(t=[new pe(0,-.5),new pe(.5,0),new pe(0,.5)],e=12,n=0,i=2*Math.PI){super(),this.type="LatheGeometry",this.parameters={points:t,segments:e,phiStart:n,phiLength:i},e=Math.floor(e),i=re(i,0,2*Math.PI);const r=[],s=[],a=[],o=[],l=[],c=1/e,h=new ke,u=new pe,d=new ke,p=new ke,m=new ke;let f=0,g=0;for(let e=0;e<=t.length-1;e++)switch(e){case 0:f=t[e+1].x-t[e].x,g=t[e+1].y-t[e].y,d.x=1*g,d.y=-f,d.z=0*g,m.copy(d),d.normalize(),o.push(d.x,d.y,d.z);break;case t.length-1:o.push(m.x,m.y,m.z);break;default:f=t[e+1].x-t[e].x,g=t[e+1].y-t[e].y,d.x=1*g,d.y=-f,d.z=0*g,p.copy(d),d.x+=m.x,d.y+=m.y,d.z+=m.z,d.normalize(),o.push(d.x,d.y,d.z),m.copy(p)}for(let r=0;r<=e;r++){const d=n+r*c*i,p=Math.sin(d),m=Math.cos(d);for(let n=0;n<=t.length-1;n++){h.x=t[n].x*p,h.y=t[n].y,h.z=t[n].x*m,s.push(h.x,h.y,h.z),u.x=r/e,u.y=n/(t.length-1),a.push(u.x,u.y);const i=o[3*n+0]*p,c=o[3*n+1],d=o[3*n+0]*m;l.push(i,c,d)}}for(let n=0;n0&&_(!0),e>0&&_(!1)),this.setIndex(c),this.setAttribute("position",new bi(h,3)),this.setAttribute("normal",new bi(u,3)),this.setAttribute("uv",new bi(d,2))}copy(t){return super.copy(t),this.parameters=Object.assign({},t.parameters),this}static fromJSON(t){return new Hl(t.radiusTop,t.radiusBottom,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}}class Gl extends Hl{constructor(t=1,e=1,n=32,i=1,r=!1,s=0,a=2*Math.PI){super(0,t,e,n,i,r,s,a),this.type="ConeGeometry",this.parameters={radius:t,height:e,radialSegments:n,heightSegments:i,openEnded:r,thetaStart:s,thetaLength:a}}static fromJSON(t){return new Gl(t.radius,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}}class Vl extends Pi{constructor(t=[],e=[],n=1,i=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:e,radius:n,detail:i};const r=[],s=[];function a(t,e,n,i){const r=i+1,s=[];for(let i=0;i<=r;i++){s[i]=[];const a=t.clone().lerp(n,i/r),o=e.clone().lerp(n,i/r),l=r-i;for(let t=0;t<=l;t++)s[i][t]=0===t&&i===r?a:a.clone().lerp(o,t/l)}for(let t=0;t.9&&a<.1&&(e<.2&&(s[t+0]+=1),n<.2&&(s[t+2]+=1),i<.2&&(s[t+4]+=1))}}()}(),this.setAttribute("position",new bi(r,3)),this.setAttribute("normal",new bi(r.slice(),3)),this.setAttribute("uv",new bi(s,2)),0===i?this.computeVertexNormals():this.normalizeNormals()}copy(t){return super.copy(t),this.parameters=Object.assign({},t.parameters),this}static fromJSON(t){return new Vl(t.vertices,t.indices,t.radius,t.details)}}class kl extends Vl{constructor(t=1,e=0){const n=(1+Math.sqrt(5))/2,i=1/n;super([-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-i,-n,0,-i,n,0,i,-n,0,i,n,-i,-n,0,-i,n,0,i,-n,0,i,n,0,-n,0,-i,n,0,-i,-n,0,i,n,0,i],[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9],t,e),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:e}}static fromJSON(t){return new kl(t.radius,t.detail)}}const Wl=new ke,Xl=new ke,jl=new ke,ql=new ii;class Yl extends Pi{constructor(t=null,e=1){if(super(),this.type="EdgesGeometry",this.parameters={geometry:t,thresholdAngle:e},null!==t){const n=4,i=Math.pow(10,n),r=Math.cos(ee*e),s=t.getIndex(),a=t.getAttribute("position"),o=s?s.count:a.count,l=[0,0,0],c=["a","b","c"],h=new Array(3),u={},d=[];for(let t=0;t80*n){o=c=t[0],l=h=t[1];for(let e=n;ec&&(c=u),d>h&&(h=d);p=Math.max(c-o,h-l),p=0!==p?32767/p:0}return Ql(s,a,n,o,l,p,0),a};function Kl(t,e,n,i,r){let s,a;if(r===function(t,e,n,i){let r=0;for(let s=e,a=n-i;s0)for(s=e;s=e;s-=i)a=vc(s,t[s],t[s+1],a);return a&&dc(a,a.next)&&(yc(a),a=a.next),a}function $l(t,e){if(!t)return t;e||(e=t);let n,i=t;do{if(n=!1,i.steiner||!dc(i,i.next)&&0!==uc(i.prev,i,i.next))i=i.next;else{if(yc(i),i=e=i.prev,i===i.next)break;n=!0}}while(n||i!==e);return e}function Ql(t,e,n,i,r,s,a){if(!t)return;!a&&s&&function(t,e,n,i){let r=t;do{0===r.z&&(r.z=oc(r.x,r.y,e,n,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==t);r.prevZ.nextZ=null,r.prevZ=null,function(t){let e,n,i,r,s,a,o,l,c=1;do{for(n=t,t=null,s=null,a=0;n;){for(a++,i=n,o=0,e=0;e0||l>0&&i;)0!==o&&(0===l||!i||n.z<=i.z)?(r=n,n=n.nextZ,o--):(r=i,i=i.nextZ,l--),s?s.nextZ=r:t=r,r.prevZ=s,s=r;n=i}s.nextZ=null,c*=2}while(a>1)}(r)}(t,i,r,s);let o,l,c=t;for(;t.prev!==t.next;)if(o=t.prev,l=t.next,s?ec(t,i,r,s):tc(t))e.push(o.i/n|0),e.push(t.i/n|0),e.push(l.i/n|0),yc(t),t=l.next,c=l.next;else if((t=l)===c){a?1===a?Ql(t=nc($l(t),e,n),e,n,i,r,s,2):2===a&&ic(t,e,n,i,r,s):Ql($l(t),e,n,i,r,s,1);break}}function tc(t){const e=t.prev,n=t,i=t.next;if(uc(e,n,i)>=0)return!1;const r=e.x,s=n.x,a=i.x,o=e.y,l=n.y,c=i.y,h=rs?r>a?r:a:s>a?s:a,p=o>l?o>c?o:c:l>c?l:c;let m=i.next;for(;m!==e;){if(m.x>=h&&m.x<=d&&m.y>=u&&m.y<=p&&cc(r,o,s,l,a,c,m.x,m.y)&&uc(m.prev,m,m.next)>=0)return!1;m=m.next}return!0}function ec(t,e,n,i){const r=t.prev,s=t,a=t.next;if(uc(r,s,a)>=0)return!1;const o=r.x,l=s.x,c=a.x,h=r.y,u=s.y,d=a.y,p=ol?o>c?o:c:l>c?l:c,g=h>u?h>d?h:d:u>d?u:d,_=oc(p,m,e,n,i),v=oc(f,g,e,n,i);let y=t.prevZ,x=t.nextZ;for(;y&&y.z>=_&&x&&x.z<=v;){if(y.x>=p&&y.x<=f&&y.y>=m&&y.y<=g&&y!==r&&y!==a&&cc(o,h,l,u,c,d,y.x,y.y)&&uc(y.prev,y,y.next)>=0)return!1;if(y=y.prevZ,x.x>=p&&x.x<=f&&x.y>=m&&x.y<=g&&x!==r&&x!==a&&cc(o,h,l,u,c,d,x.x,x.y)&&uc(x.prev,x,x.next)>=0)return!1;x=x.nextZ}for(;y&&y.z>=_;){if(y.x>=p&&y.x<=f&&y.y>=m&&y.y<=g&&y!==r&&y!==a&&cc(o,h,l,u,c,d,y.x,y.y)&&uc(y.prev,y,y.next)>=0)return!1;y=y.prevZ}for(;x&&x.z<=v;){if(x.x>=p&&x.x<=f&&x.y>=m&&x.y<=g&&x!==r&&x!==a&&cc(o,h,l,u,c,d,x.x,x.y)&&uc(x.prev,x,x.next)>=0)return!1;x=x.nextZ}return!0}function nc(t,e,n){let i=t;do{const r=i.prev,s=i.next.next;!dc(r,s)&&pc(r,i,i.next,s)&&gc(r,s)&&gc(s,r)&&(e.push(r.i/n|0),e.push(i.i/n|0),e.push(s.i/n|0),yc(i),yc(i.next),i=t=s),i=i.next}while(i!==t);return $l(i)}function ic(t,e,n,i,r,s){let a=t;do{let t=a.next.next;for(;t!==a.prev;){if(a.i!==t.i&&hc(a,t)){let o=_c(a,t);return a=$l(a,a.next),o=$l(o,o.next),Ql(a,e,n,i,r,s,0),void Ql(o,e,n,i,r,s,0)}t=t.next}a=a.next}while(a!==t)}function rc(t,e){return t.x-e.x}function sc(t,e){const n=function(t,e){let n,i=e,r=-1/0;const s=t.x,a=t.y;do{if(a<=i.y&&a>=i.next.y&&i.next.y!==i.y){const t=i.x+(a-i.y)*(i.next.x-i.x)/(i.next.y-i.y);if(t<=s&&t>r&&(r=t,n=i.x=i.x&&i.x>=l&&s!==i.x&&cc(an.x||i.x===n.x&&ac(n,i)))&&(n=i,u=h)),i=i.next}while(i!==o);return n}(t,e);if(!n)return e;const i=_c(n,t);return $l(i,i.next),$l(n,n.next)}function ac(t,e){return uc(t.prev,t,e.prev)<0&&uc(e.next,t,t.next)<0}function oc(t,e,n,i,r){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=(t-n)*r|0)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=(e-i)*r|0)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function lc(t){let e=t,n=t;do{(e.x=(t-a)*(s-o)&&(t-a)*(i-o)>=(n-a)*(e-o)&&(n-a)*(s-o)>=(r-a)*(i-o)}function hc(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){let n=t;do{if(n.i!==t.i&&n.next.i!==t.i&&n.i!==e.i&&n.next.i!==e.i&&pc(n,n.next,t,e))return!0;n=n.next}while(n!==t);return!1}(t,e)&&(gc(t,e)&&gc(e,t)&&function(t,e){let n=t,i=!1;const r=(t.x+e.x)/2,s=(t.y+e.y)/2;do{n.y>s!=n.next.y>s&&n.next.y!==n.y&&r<(n.next.x-n.x)*(s-n.y)/(n.next.y-n.y)+n.x&&(i=!i),n=n.next}while(n!==t);return i}(t,e)&&(uc(t.prev,t,e.prev)||uc(t,e.prev,e))||dc(t,e)&&uc(t.prev,t,t.next)>0&&uc(e.prev,e,e.next)>0)}function uc(t,e,n){return(e.y-t.y)*(n.x-e.x)-(e.x-t.x)*(n.y-e.y)}function dc(t,e){return t.x===e.x&&t.y===e.y}function pc(t,e,n,i){const r=fc(uc(t,e,n)),s=fc(uc(t,e,i)),a=fc(uc(n,i,t)),o=fc(uc(n,i,e));return r!==s&&a!==o||(!(0!==r||!mc(t,n,e))||(!(0!==s||!mc(t,i,e))||(!(0!==a||!mc(n,t,i))||!(0!==o||!mc(n,e,i)))))}function mc(t,e,n){return e.x<=Math.max(t.x,n.x)&&e.x>=Math.min(t.x,n.x)&&e.y<=Math.max(t.y,n.y)&&e.y>=Math.min(t.y,n.y)}function fc(t){return t>0?1:t<0?-1:0}function gc(t,e){return uc(t.prev,t,t.next)<0?uc(t,e,t.next)>=0&&uc(t,t.prev,e)>=0:uc(t,e,t.prev)<0||uc(t,t.next,e)<0}function _c(t,e){const n=new xc(t.i,t.x,t.y),i=new xc(e.i,e.x,e.y),r=t.next,s=e.prev;return t.next=e,e.prev=t,n.next=r,r.prev=n,i.next=n,n.prev=i,s.next=i,i.prev=s,i}function vc(t,e,n,i){const r=new xc(t,e,n);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function yc(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function xc(t,e,n){this.i=t,this.x=e,this.y=n,this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1}class Mc{static area(t){const e=t.length;let n=0;for(let i=e-1,r=0;r2&&t[e-1].equals(t[0])&&t.pop()}function bc(t,e){for(let n=0;nNumber.EPSILON){const u=Math.sqrt(h),d=Math.sqrt(l*l+c*c),p=e.x-o/u,m=e.y+a/u,f=((n.x-c/d-p)*c-(n.y+l/d-m)*l)/(a*c-o*l);i=p+a*f-t.x,r=m+o*f-t.y;const g=i*i+r*r;if(g<=2)return new pe(i,r);s=Math.sqrt(g/2)}else{let t=!1;a>Number.EPSILON?l>Number.EPSILON&&(t=!0):a<-Number.EPSILON?l<-Number.EPSILON&&(t=!0):Math.sign(o)===Math.sign(c)&&(t=!0),t?(i=-o,r=a,s=Math.sqrt(h)):(i=a,r=o,s=Math.sqrt(h/2))}return new pe(i/s,r/s)}const P=[];for(let t=0,e=w.length,n=e-1,i=t+1;t=0;t--){const e=t/p,n=h*Math.cos(e*Math.PI/2),i=u*Math.sin(e*Math.PI/2)+d;for(let t=0,e=w.length;t=0;){const i=n;let r=n-1;r<0&&(r=t.length-1);for(let t=0,n=o+2*p;t0)&&d.push(e,r,l),(t!==n-1||o0!=t>0&&this.version++,this._anisotropy=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get iridescence(){return this._iridescence}set iridescence(t){this._iridescence>0!=t>0&&this.version++,this._iridescence=t}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.anisotropy=t.anisotropy,this.anisotropyRotation=t.anisotropyRotation,this.anisotropyMap=t.anisotropyMap,this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.iridescence=t.iridescence,this.iridescenceMap=t.iridescenceMap,this.iridescenceIOR=t.iridescenceIOR,this.iridescenceThicknessRange=[...t.iridescenceThicknessRange],this.iridescenceThicknessMap=t.iridescenceThicknessMap,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}}class Vc extends ui{constructor(t){super(),this.isMeshPhongMaterial=!0,this.type="MeshPhongMaterial",this.color=new li(16777215),this.specular=new li(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new li(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new pe(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=h,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this.fog=t.fog,this}}class kc extends ui{constructor(t){super(),this.isMeshToonMaterial=!0,this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new li(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new li(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new pe(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.fog=t.fog,this}}class Wc extends ui{constructor(t){super(),this.isMeshNormalMaterial=!0,this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new pe(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}}class Xc extends ui{constructor(t){super(),this.isMeshLambertMaterial=!0,this.type="MeshLambertMaterial",this.color=new li(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new li(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new pe(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=h,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this.fog=t.fog,this}}class jc extends ui{constructor(t){super(),this.isMeshMatcapMaterial=!0,this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new li(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new pe(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.fog=!0,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this.fog=t.fog,this}}class qc extends Jo{constructor(t){super(),this.isLineDashedMaterial=!0,this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}}function Yc(t,e,n){return!t||!n&&t.constructor===e?t:"number"==typeof e.BYTES_PER_ELEMENT?new e(t):Array.prototype.slice.call(t)}function Zc(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)}function Jc(t){const e=t.length,n=new Array(e);for(let t=0;t!==e;++t)n[t]=t;return n.sort((function(e,n){return t[e]-t[n]})),n}function Kc(t,e,n){const i=t.length,r=new t.constructor(i);for(let s=0,a=0;a!==i;++s){const i=n[s]*e;for(let n=0;n!==e;++n)r[a++]=t[i+n]}return r}function $c(t,e,n,i){let r=1,s=t[0];for(;void 0!==s&&void 0===s[i];)s=t[r++];if(void 0===s)return;let a=s[i];if(void 0!==a)if(Array.isArray(a))do{a=s[i],void 0!==a&&(e.push(s.time),n.push.apply(n,a)),s=t[r++]}while(void 0!==s);else if(void 0!==a.toArray)do{a=s[i],void 0!==a&&(e.push(s.time),a.toArray(n,n.length)),s=t[r++]}while(void 0!==s);else do{a=s[i],void 0!==a&&(e.push(s.time),n.push(a)),s=t[r++]}while(void 0!==s)}const Qc={convertArray:Yc,isTypedArray:Zc,getKeyframeOrder:Jc,sortedArray:Kc,flattenJSON:$c,subclip:function(t,e,n,i,r=30){const s=t.clone();s.name=e;const a=[];for(let t=0;t=i)){l.push(e.times[t]);for(let n=0;ns.tracks[t].times[0]&&(o=s.tracks[t].times[0]);for(let t=0;t=i.times[u]){const t=u*l+o,e=t+l-o;d=i.values.slice(t,e)}else{const t=i.createInterpolant(),e=o,n=l-o;t.evaluate(s),d=t.resultBuffer.slice(e,n)}if("quaternion"===r){(new Ve).fromArray(d).normalize().conjugate().toArray(d)}const p=a.times.length;for(let t=0;t=r)break t;{const a=e[1];t=r)break e}s=n,n=0}}for(;n>>1;te;)--s;if(++s,0!==r||s!==i){r>=s&&(s=Math.max(s,1),r=s-1);const t=this.getValueSize();this.times=n.slice(r,s),this.values=this.values.slice(r*t,s*t)}return this}validate(){let t=!0;const e=this.getValueSize();e-Math.floor(e)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);const n=this.times,i=this.values,r=n.length;0===r&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let s=null;for(let e=0;e!==r;e++){const i=n[e];if("number"==typeof i&&isNaN(i)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,e,i),t=!1;break}if(null!==s&&s>i){console.error("THREE.KeyframeTrack: Out of order keys.",this,e,i,s),t=!1;break}s=i}if(void 0!==i&&Zc(i))for(let e=0,n=i.length;e!==n;++e){const n=i[e];if(isNaN(n)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,e,n),t=!1;break}}return t}optimize(){const t=this.times.slice(),e=this.values.slice(),n=this.getValueSize(),i=this.getInterpolation()===Ct,r=t.length-1;let s=1;for(let a=1;a0){t[s]=t[r];for(let t=r*n,i=s*n,a=0;a!==n;++a)e[i+a]=e[t+a];++s}return s!==t.length?(this.times=t.slice(0,s),this.values=e.slice(0,s*n)):(this.times=t,this.values=e),this}clone(){const t=this.times.slice(),e=this.values.slice(),n=new(0,this.constructor)(this.name,t,e);return n.createInterpolant=this.createInterpolant,n}}rh.prototype.TimeBufferType=Float32Array,rh.prototype.ValueBufferType=Float32Array,rh.prototype.DefaultInterpolation=Rt;class sh extends rh{}sh.prototype.ValueTypeName="bool",sh.prototype.ValueBufferType=Array,sh.prototype.DefaultInterpolation=At,sh.prototype.InterpolantFactoryMethodLinear=void 0,sh.prototype.InterpolantFactoryMethodSmooth=void 0;class ah extends rh{}ah.prototype.ValueTypeName="color";class oh extends rh{}oh.prototype.ValueTypeName="number";class lh extends th{constructor(t,e,n,i){super(t,e,n,i)}interpolate_(t,e,n,i){const r=this.resultBuffer,s=this.sampleValues,a=this.valueSize,o=(n-e)/(i-e);let l=t*a;for(let t=l+a;l!==t;l+=4)Ve.slerpFlat(r,0,s,l-a,s,l,o);return r}}class ch extends rh{InterpolantFactoryMethodLinear(t){return new lh(this.times,this.values,this.getValueSize(),t)}}ch.prototype.ValueTypeName="quaternion",ch.prototype.DefaultInterpolation=Rt,ch.prototype.InterpolantFactoryMethodSmooth=void 0;class hh extends rh{}hh.prototype.ValueTypeName="string",hh.prototype.ValueBufferType=Array,hh.prototype.DefaultInterpolation=At,hh.prototype.InterpolantFactoryMethodLinear=void 0,hh.prototype.InterpolantFactoryMethodSmooth=void 0;class uh extends rh{}uh.prototype.ValueTypeName="vector";class dh{constructor(t,e=-1,n,i=2500){this.name=t,this.tracks=n,this.duration=e,this.blendMode=i,this.uuid=ie(),this.duration<0&&this.resetDuration()}static parse(t){const e=[],n=t.tracks,i=1/(t.fps||1);for(let t=0,r=n.length;t!==r;++t)e.push(ph(n[t]).scale(i));const r=new this(t.name,t.duration,e,t.blendMode);return r.uuid=t.uuid,r}static toJSON(t){const e=[],n=t.tracks,i={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let t=0,i=n.length;t!==i;++t)e.push(rh.toJSON(n[t]));return i}static CreateFromMorphTargetSequence(t,e,n,i){const r=e.length,s=[];for(let t=0;t1){const t=s[1];let e=i[t];e||(i[t]=e=[]),e.push(n)}}const s=[];for(const t in i)s.push(this.CreateFromMorphTargetSequence(t,i[t],e,n));return s}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;const n=function(t,e,n,i,r){if(0!==n.length){const s=[],a=[];$c(n,s,a,i),0!==s.length&&r.push(new t(e,s,a))}},i=[],r=t.name||"default",s=t.fps||30,a=t.blendMode;let o=t.length||-1;const l=t.hierarchy||[];for(let t=0;t{e&&e(r),this.manager.itemEnd(t)}),0),r;if(void 0!==vh[t])return void vh[t].push({onLoad:e,onProgress:n,onError:i});vh[t]=[],vh[t].push({onLoad:e,onProgress:n,onError:i});const s=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,o=this.responseType;fetch(s).then((e=>{if(200===e.status||0===e.status){if(0===e.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),"undefined"==typeof ReadableStream||void 0===e.body||void 0===e.body.getReader)return e;const n=vh[t],i=e.body.getReader(),r=e.headers.get("Content-Length")||e.headers.get("X-File-Size"),s=r?parseInt(r):0,a=0!==s;let o=0;const l=new ReadableStream({start(t){!function e(){i.read().then((({done:i,value:r})=>{if(i)t.close();else{o+=r.byteLength;const i=new ProgressEvent("progress",{lengthComputable:a,loaded:o,total:s});for(let t=0,e=n.length;t{switch(o){case"arraybuffer":return t.arrayBuffer();case"blob":return t.blob();case"document":return t.text().then((t=>(new DOMParser).parseFromString(t,a)));case"json":return t.json();default:if(void 0===a)return t.text();{const e=/charset="?([^;"\s]*)"?/i.exec(a),n=e&&e[1]?e[1].toLowerCase():void 0,i=new TextDecoder(n);return t.arrayBuffer().then((t=>i.decode(t)))}}})).then((e=>{mh.add(t,e);const n=vh[t];delete vh[t];for(let t=0,i=n.length;t{const n=vh[t];if(void 0===n)throw this.manager.itemError(t),e;delete vh[t];for(let t=0,i=n.length;t{this.manager.itemEnd(t)})),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}}class Mh extends _h{constructor(t){super(t)}load(t,e,n,i){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const r=this,s=mh.get(t);if(void 0!==s)return r.manager.itemStart(t),setTimeout((function(){e&&e(s),r.manager.itemEnd(t)}),0),s;const a=ye("img");function o(){c(),mh.add(t,this),e&&e(this),r.manager.itemEnd(t)}function l(e){c(),i&&i(e),r.manager.itemError(t),r.manager.itemEnd(t)}function c(){a.removeEventListener("load",o,!1),a.removeEventListener("error",l,!1)}return a.addEventListener("load",o,!1),a.addEventListener("error",l,!1),"data:"!==t.slice(0,5)&&void 0!==this.crossOrigin&&(a.crossOrigin=this.crossOrigin),r.manager.itemStart(t),a.src=t,a}}class Sh extends Xn{constructor(t,e=1){super(),this.isLight=!0,this.type="Light",this.color=new li(t),this.intensity=e}dispose(){}copy(t,e){return super.copy(t,e),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){const e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,void 0!==this.groundColor&&(e.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(e.object.distance=this.distance),void 0!==this.angle&&(e.object.angle=this.angle),void 0!==this.decay&&(e.object.decay=this.decay),void 0!==this.penumbra&&(e.object.penumbra=this.penumbra),void 0!==this.shadow&&(e.object.shadow=this.shadow.toJSON()),e}}class bh extends Sh{constructor(t,e,n){super(t,n),this.isHemisphereLight=!0,this.type="HemisphereLight",this.position.copy(Xn.DEFAULT_UP),this.updateMatrix(),this.groundColor=new li(e)}copy(t,e){return super.copy(t,e),this.groundColor.copy(t.groundColor),this}}const Th=new xn,Eh=new ke,wh=new ke;class Ah{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new pe(512,512),this.map=null,this.mapPass=null,this.matrix=new xn,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new fr,this._frameExtents=new pe(1,1),this._viewportCount=1,this._viewports=[new Fe(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){const e=this.camera,n=this.matrix;Eh.setFromMatrixPosition(t.matrixWorld),e.position.copy(Eh),wh.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(wh),e.updateMatrixWorld(),Th.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(Th),n.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),n.multiply(Th)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return(new this.constructor).copy(this)}toJSON(){const t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),512===this.mapSize.x&&512===this.mapSize.y||(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}}class Rh extends Ah{constructor(){super(new rr(50,1,.5,500)),this.isSpotLightShadow=!0,this.focus=1}updateMatrices(t){const e=this.camera,n=2*ne*t.angle*this.focus,i=this.mapSize.width/this.mapSize.height,r=t.distance||e.far;n===e.fov&&i===e.aspect&&r===e.far||(e.fov=n,e.aspect=i,e.far=r,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}}class Ch extends Sh{constructor(t,e,n=0,i=Math.PI/3,r=0,s=2){super(t,e),this.isSpotLight=!0,this.type="SpotLight",this.position.copy(Xn.DEFAULT_UP),this.updateMatrix(),this.target=new Xn,this.distance=n,this.angle=i,this.penumbra=r,this.decay=s,this.map=null,this.shadow=new Rh}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t,e){return super.copy(t,e),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}const Lh=new xn,Ph=new ke,Ih=new ke;class Uh extends Ah{constructor(){super(new rr(90,1,.5,500)),this.isPointLightShadow=!0,this._frameExtents=new pe(4,2),this._viewportCount=6,this._viewports=[new Fe(2,1,1,1),new Fe(0,1,1,1),new Fe(3,1,1,1),new Fe(1,1,1,1),new Fe(3,0,1,1),new Fe(1,0,1,1)],this._cubeDirections=[new ke(1,0,0),new ke(-1,0,0),new ke(0,0,1),new ke(0,0,-1),new ke(0,1,0),new ke(0,-1,0)],this._cubeUps=[new ke(0,1,0),new ke(0,1,0),new ke(0,1,0),new ke(0,1,0),new ke(0,0,1),new ke(0,0,-1)]}updateMatrices(t,e=0){const n=this.camera,i=this.matrix,r=t.distance||n.far;r!==n.far&&(n.far=r,n.updateProjectionMatrix()),Ph.setFromMatrixPosition(t.matrixWorld),n.position.copy(Ph),Ih.copy(n.position),Ih.add(this._cubeDirections[e]),n.up.copy(this._cubeUps[e]),n.lookAt(Ih),n.updateMatrixWorld(),i.makeTranslation(-Ph.x,-Ph.y,-Ph.z),Lh.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(Lh)}}class Dh extends Sh{constructor(t,e,n=0,i=2){super(t,e),this.isPointLight=!0,this.type="PointLight",this.distance=n,this.decay=i,this.shadow=new Uh}get power(){return 4*this.intensity*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t,e){return super.copy(t,e),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}class Nh extends Ah{constructor(){super(new Cr(-5,5,5,-5,.5,500)),this.isDirectionalLightShadow=!0}}class Oh extends Sh{constructor(t,e){super(t,e),this.isDirectionalLight=!0,this.type="DirectionalLight",this.position.copy(Xn.DEFAULT_UP),this.updateMatrix(),this.target=new Xn,this.shadow=new Nh}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}class Fh extends Sh{constructor(t,e){super(t,e),this.isAmbientLight=!0,this.type="AmbientLight"}}class Bh extends Sh{constructor(t,e,n=10,i=10){super(t,e),this.isRectAreaLight=!0,this.type="RectAreaLight",this.width=n,this.height=i}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){const e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}}class zh{constructor(){this.isSphericalHarmonics3=!0,this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new ke)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){const n=t.x,i=t.y,r=t.z,s=this.coefficients;return e.copy(s[0]).multiplyScalar(.282095),e.addScaledVector(s[1],.488603*i),e.addScaledVector(s[2],.488603*r),e.addScaledVector(s[3],.488603*n),e.addScaledVector(s[4],n*i*1.092548),e.addScaledVector(s[5],i*r*1.092548),e.addScaledVector(s[6],.315392*(3*r*r-1)),e.addScaledVector(s[7],n*r*1.092548),e.addScaledVector(s[8],.546274*(n*n-i*i)),e}getIrradianceAt(t,e){const n=t.x,i=t.y,r=t.z,s=this.coefficients;return e.copy(s[0]).multiplyScalar(.886227),e.addScaledVector(s[1],1.023328*i),e.addScaledVector(s[2],1.023328*r),e.addScaledVector(s[3],1.023328*n),e.addScaledVector(s[4],.858086*n*i),e.addScaledVector(s[5],.858086*i*r),e.addScaledVector(s[6],.743125*r*r-.247708),e.addScaledVector(s[7],.858086*n*r),e.addScaledVector(s[8],.429043*(n*n-i*i)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let n=0;n<9;n++)this.coefficients[n].addScaledVector(t.coefficients[n],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let n=0;n<9;n++)this.coefficients[n].lerp(t.coefficients[n],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,e=0){const n=this.coefficients;for(let i=0;i<9;i++)n[i].fromArray(t,e+3*i);return this}toArray(t=[],e=0){const n=this.coefficients;for(let i=0;i<9;i++)n[i].toArray(t,e+3*i);return t}static getBasisAt(t,e){const n=t.x,i=t.y,r=t.z;e[0]=.282095,e[1]=.488603*i,e[2]=.488603*r,e[3]=.488603*n,e[4]=1.092548*n*i,e[5]=1.092548*i*r,e[6]=.315392*(3*r*r-1),e[7]=1.092548*n*r,e[8]=.546274*(n*n-i*i)}}class Hh extends Sh{constructor(t=new zh,e=1){super(void 0,e),this.isLightProbe=!0,this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){const e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}}class Gh extends _h{constructor(t){super(t),this.textures={}}load(t,e,n,i){const r=this,s=new xh(r.manager);s.setPath(r.path),s.setRequestHeader(r.requestHeader),s.setWithCredentials(r.withCredentials),s.load(t,(function(n){try{e(r.parse(JSON.parse(n)))}catch(e){i?i(e):console.error(e),r.manager.itemError(t)}}),n,i)}parse(t){const e=this.textures;function n(t){return void 0===e[t]&&console.warn("THREE.MaterialLoader: Undefined texture",t),e[t]}const i=Gh.createMaterialFromType(t.type);if(void 0!==t.uuid&&(i.uuid=t.uuid),void 0!==t.name&&(i.name=t.name),void 0!==t.color&&void 0!==i.color&&i.color.setHex(t.color),void 0!==t.roughness&&(i.roughness=t.roughness),void 0!==t.metalness&&(i.metalness=t.metalness),void 0!==t.sheen&&(i.sheen=t.sheen),void 0!==t.sheenColor&&(i.sheenColor=(new li).setHex(t.sheenColor)),void 0!==t.sheenRoughness&&(i.sheenRoughness=t.sheenRoughness),void 0!==t.emissive&&void 0!==i.emissive&&i.emissive.setHex(t.emissive),void 0!==t.specular&&void 0!==i.specular&&i.specular.setHex(t.specular),void 0!==t.specularIntensity&&(i.specularIntensity=t.specularIntensity),void 0!==t.specularColor&&void 0!==i.specularColor&&i.specularColor.setHex(t.specularColor),void 0!==t.shininess&&(i.shininess=t.shininess),void 0!==t.clearcoat&&(i.clearcoat=t.clearcoat),void 0!==t.clearcoatRoughness&&(i.clearcoatRoughness=t.clearcoatRoughness),void 0!==t.iridescence&&(i.iridescence=t.iridescence),void 0!==t.iridescenceIOR&&(i.iridescenceIOR=t.iridescenceIOR),void 0!==t.iridescenceThicknessRange&&(i.iridescenceThicknessRange=t.iridescenceThicknessRange),void 0!==t.transmission&&(i.transmission=t.transmission),void 0!==t.thickness&&(i.thickness=t.thickness),void 0!==t.attenuationDistance&&(i.attenuationDistance=t.attenuationDistance),void 0!==t.attenuationColor&&void 0!==i.attenuationColor&&i.attenuationColor.setHex(t.attenuationColor),void 0!==t.anisotropy&&(i.anisotropy=t.anisotropy),void 0!==t.anisotropyRotation&&(i.anisotropyRotation=t.anisotropyRotation),void 0!==t.fog&&(i.fog=t.fog),void 0!==t.flatShading&&(i.flatShading=t.flatShading),void 0!==t.blending&&(i.blending=t.blending),void 0!==t.combine&&(i.combine=t.combine),void 0!==t.side&&(i.side=t.side),void 0!==t.shadowSide&&(i.shadowSide=t.shadowSide),void 0!==t.opacity&&(i.opacity=t.opacity),void 0!==t.transparent&&(i.transparent=t.transparent),void 0!==t.alphaTest&&(i.alphaTest=t.alphaTest),void 0!==t.alphaHash&&(i.alphaHash=t.alphaHash),void 0!==t.depthFunc&&(i.depthFunc=t.depthFunc),void 0!==t.depthTest&&(i.depthTest=t.depthTest),void 0!==t.depthWrite&&(i.depthWrite=t.depthWrite),void 0!==t.colorWrite&&(i.colorWrite=t.colorWrite),void 0!==t.blendSrc&&(i.blendSrc=t.blendSrc),void 0!==t.blendDst&&(i.blendDst=t.blendDst),void 0!==t.blendEquation&&(i.blendEquation=t.blendEquation),void 0!==t.blendSrcAlpha&&(i.blendSrcAlpha=t.blendSrcAlpha),void 0!==t.blendDstAlpha&&(i.blendDstAlpha=t.blendDstAlpha),void 0!==t.blendEquationAlpha&&(i.blendEquationAlpha=t.blendEquationAlpha),void 0!==t.blendColor&&void 0!==i.blendColor&&i.blendColor.setHex(t.blendColor),void 0!==t.blendAlpha&&(i.blendAlpha=t.blendAlpha),void 0!==t.stencilWriteMask&&(i.stencilWriteMask=t.stencilWriteMask),void 0!==t.stencilFunc&&(i.stencilFunc=t.stencilFunc),void 0!==t.stencilRef&&(i.stencilRef=t.stencilRef),void 0!==t.stencilFuncMask&&(i.stencilFuncMask=t.stencilFuncMask),void 0!==t.stencilFail&&(i.stencilFail=t.stencilFail),void 0!==t.stencilZFail&&(i.stencilZFail=t.stencilZFail),void 0!==t.stencilZPass&&(i.stencilZPass=t.stencilZPass),void 0!==t.stencilWrite&&(i.stencilWrite=t.stencilWrite),void 0!==t.wireframe&&(i.wireframe=t.wireframe),void 0!==t.wireframeLinewidth&&(i.wireframeLinewidth=t.wireframeLinewidth),void 0!==t.wireframeLinecap&&(i.wireframeLinecap=t.wireframeLinecap),void 0!==t.wireframeLinejoin&&(i.wireframeLinejoin=t.wireframeLinejoin),void 0!==t.rotation&&(i.rotation=t.rotation),void 0!==t.linewidth&&(i.linewidth=t.linewidth),void 0!==t.dashSize&&(i.dashSize=t.dashSize),void 0!==t.gapSize&&(i.gapSize=t.gapSize),void 0!==t.scale&&(i.scale=t.scale),void 0!==t.polygonOffset&&(i.polygonOffset=t.polygonOffset),void 0!==t.polygonOffsetFactor&&(i.polygonOffsetFactor=t.polygonOffsetFactor),void 0!==t.polygonOffsetUnits&&(i.polygonOffsetUnits=t.polygonOffsetUnits),void 0!==t.dithering&&(i.dithering=t.dithering),void 0!==t.alphaToCoverage&&(i.alphaToCoverage=t.alphaToCoverage),void 0!==t.premultipliedAlpha&&(i.premultipliedAlpha=t.premultipliedAlpha),void 0!==t.forceSinglePass&&(i.forceSinglePass=t.forceSinglePass),void 0!==t.visible&&(i.visible=t.visible),void 0!==t.toneMapped&&(i.toneMapped=t.toneMapped),void 0!==t.userData&&(i.userData=t.userData),void 0!==t.vertexColors&&("number"==typeof t.vertexColors?i.vertexColors=t.vertexColors>0:i.vertexColors=t.vertexColors),void 0!==t.uniforms)for(const e in t.uniforms){const r=t.uniforms[e];switch(i.uniforms[e]={},r.type){case"t":i.uniforms[e].value=n(r.value);break;case"c":i.uniforms[e].value=(new li).setHex(r.value);break;case"v2":i.uniforms[e].value=(new pe).fromArray(r.value);break;case"v3":i.uniforms[e].value=(new ke).fromArray(r.value);break;case"v4":i.uniforms[e].value=(new Fe).fromArray(r.value);break;case"m3":i.uniforms[e].value=(new me).fromArray(r.value);break;case"m4":i.uniforms[e].value=(new xn).fromArray(r.value);break;default:i.uniforms[e].value=r.value}}if(void 0!==t.defines&&(i.defines=t.defines),void 0!==t.vertexShader&&(i.vertexShader=t.vertexShader),void 0!==t.fragmentShader&&(i.fragmentShader=t.fragmentShader),void 0!==t.glslVersion&&(i.glslVersion=t.glslVersion),void 0!==t.extensions)for(const e in t.extensions)i.extensions[e]=t.extensions[e];if(void 0!==t.lights&&(i.lights=t.lights),void 0!==t.clipping&&(i.clipping=t.clipping),void 0!==t.size&&(i.size=t.size),void 0!==t.sizeAttenuation&&(i.sizeAttenuation=t.sizeAttenuation),void 0!==t.map&&(i.map=n(t.map)),void 0!==t.matcap&&(i.matcap=n(t.matcap)),void 0!==t.alphaMap&&(i.alphaMap=n(t.alphaMap)),void 0!==t.bumpMap&&(i.bumpMap=n(t.bumpMap)),void 0!==t.bumpScale&&(i.bumpScale=t.bumpScale),void 0!==t.normalMap&&(i.normalMap=n(t.normalMap)),void 0!==t.normalMapType&&(i.normalMapType=t.normalMapType),void 0!==t.normalScale){let e=t.normalScale;!1===Array.isArray(e)&&(e=[e,e]),i.normalScale=(new pe).fromArray(e)}return void 0!==t.displacementMap&&(i.displacementMap=n(t.displacementMap)),void 0!==t.displacementScale&&(i.displacementScale=t.displacementScale),void 0!==t.displacementBias&&(i.displacementBias=t.displacementBias),void 0!==t.roughnessMap&&(i.roughnessMap=n(t.roughnessMap)),void 0!==t.metalnessMap&&(i.metalnessMap=n(t.metalnessMap)),void 0!==t.emissiveMap&&(i.emissiveMap=n(t.emissiveMap)),void 0!==t.emissiveIntensity&&(i.emissiveIntensity=t.emissiveIntensity),void 0!==t.specularMap&&(i.specularMap=n(t.specularMap)),void 0!==t.specularIntensityMap&&(i.specularIntensityMap=n(t.specularIntensityMap)),void 0!==t.specularColorMap&&(i.specularColorMap=n(t.specularColorMap)),void 0!==t.envMap&&(i.envMap=n(t.envMap)),void 0!==t.envMapIntensity&&(i.envMapIntensity=t.envMapIntensity),void 0!==t.reflectivity&&(i.reflectivity=t.reflectivity),void 0!==t.refractionRatio&&(i.refractionRatio=t.refractionRatio),void 0!==t.lightMap&&(i.lightMap=n(t.lightMap)),void 0!==t.lightMapIntensity&&(i.lightMapIntensity=t.lightMapIntensity),void 0!==t.aoMap&&(i.aoMap=n(t.aoMap)),void 0!==t.aoMapIntensity&&(i.aoMapIntensity=t.aoMapIntensity),void 0!==t.gradientMap&&(i.gradientMap=n(t.gradientMap)),void 0!==t.clearcoatMap&&(i.clearcoatMap=n(t.clearcoatMap)),void 0!==t.clearcoatRoughnessMap&&(i.clearcoatRoughnessMap=n(t.clearcoatRoughnessMap)),void 0!==t.clearcoatNormalMap&&(i.clearcoatNormalMap=n(t.clearcoatNormalMap)),void 0!==t.clearcoatNormalScale&&(i.clearcoatNormalScale=(new pe).fromArray(t.clearcoatNormalScale)),void 0!==t.iridescenceMap&&(i.iridescenceMap=n(t.iridescenceMap)),void 0!==t.iridescenceThicknessMap&&(i.iridescenceThicknessMap=n(t.iridescenceThicknessMap)),void 0!==t.transmissionMap&&(i.transmissionMap=n(t.transmissionMap)),void 0!==t.thicknessMap&&(i.thicknessMap=n(t.thicknessMap)),void 0!==t.anisotropyMap&&(i.anisotropyMap=n(t.anisotropyMap)),void 0!==t.sheenColorMap&&(i.sheenColorMap=n(t.sheenColorMap)),void 0!==t.sheenRoughnessMap&&(i.sheenRoughnessMap=n(t.sheenRoughnessMap)),i}setTextures(t){return this.textures=t,this}static createMaterialFromType(t){return new{ShadowMaterial:Bc,SpriteMaterial:ao,RawShaderMaterial:zc,ShaderMaterial:nr,PointsMaterial:ol,MeshPhysicalMaterial:Gc,MeshStandardMaterial:Hc,MeshPhongMaterial:Vc,MeshToonMaterial:kc,MeshNormalMaterial:Wc,MeshLambertMaterial:Xc,MeshDepthMaterial:Ba,MeshDistanceMaterial:za,MeshBasicMaterial:di,MeshMatcapMaterial:jc,LineDashedMaterial:qc,LineBasicMaterial:Jo,Material:ui}[t]}}class Vh{static decodeText(t){if("undefined"!=typeof TextDecoder)return(new TextDecoder).decode(t);let e="";for(let n=0,i=t.length;n0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t0&&this._mixBufferRegionAdditive(n,i,this._addIndex*e,1,e);for(let t=e,r=e+e;t!==r;++t)if(n[t]!==n[t+e]){a.setValue(n,i);break}}saveOriginalState(){const t=this.binding,e=this.buffer,n=this.valueSize,i=n*this._origIndex;t.getValue(e,i);for(let t=n,r=i;t!==r;++t)e[t]=e[i+t%n];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){const t=3*this.valueSize;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){const t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let n=t;n=.5)for(let i=0;i!==r;++i)t[e+i]=t[n+i]}_slerp(t,e,n,i){Ve.slerpFlat(t,e,t,e,t,n,i)}_slerpAdditive(t,e,n,i,r){const s=this._workIndex*r;Ve.multiplyQuaternionsFlat(t,s,t,e,t,n),Ve.slerpFlat(t,e,t,e,t,s,i)}_lerp(t,e,n,i,r){const s=1-i;for(let a=0;a!==r;++a){const r=e+a;t[r]=t[r]*s+t[n+a]*i}}_lerpAdditive(t,e,n,i,r){for(let s=0;s!==r;++s){const r=e+s;t[r]=t[r]+t[n+s]*i}}}const uu="\\[\\]\\.:\\/",du=new RegExp("["+uu+"]","g"),pu="[^"+uu+"]",mu="[^"+uu.replace("\\.","")+"]",fu=new RegExp("^"+/((?:WC+[\/:])*)/.source.replace("WC",pu)+/(WCOD+)?/.source.replace("WCOD",mu)+/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",pu)+/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",pu)+"$"),gu=["material","materials","bones","map"];class _u{constructor(t,e,n){this.path=e,this.parsedPath=n||_u.parseTrackName(e),this.node=_u.findNode(t,this.parsedPath.nodeName),this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,e,n){return t&&t.isAnimationObjectGroup?new _u.Composite(t,e,n):new _u(t,e,n)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(du,"")}static parseTrackName(t){const e=fu.exec(t);if(null===e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);const n={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},i=n.nodeName&&n.nodeName.lastIndexOf(".");if(void 0!==i&&-1!==i){const t=n.nodeName.substring(i+1);-1!==gu.indexOf(t)&&(n.nodeName=n.nodeName.substring(0,i),n.objectName=t)}if(null===n.propertyName||0===n.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return n}static findNode(t,e){if(void 0===e||""===e||"."===e||-1===e||e===t.name||e===t.uuid)return t;if(t.skeleton){const n=t.skeleton.getBoneByName(e);if(void 0!==n)return n}if(t.children){const n=function(t){for(let i=0;i0){const t=this._interpolants,e=this._propertyBindings;if(this.blendMode===Dt)for(let n=0,i=t.length;n!==i;++n)t[n].evaluate(s),e[n].accumulateAdditive(a);else for(let n=0,r=t.length;n!==r;++n)t[n].evaluate(s),e[n].accumulate(i,a)}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;const n=this._weightInterpolant;if(null!==n){const i=n.evaluate(t)[0];e*=i,t>n.parameterPositions[1]&&(this.stopFading(),0===i&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;const n=this._timeScaleInterpolant;if(null!==n){e*=n.evaluate(t)[0],t>n.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e)}}return this._effectiveTimeScale=e,e}_updateTime(t){const e=this._clip.duration,n=this.loop;let i=this.time+t,r=this._loopCount;const s=2202===n;if(0===t)return-1===r?i:s&&1==(1&r)?e-i:i;if(2200===n){-1===r&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(i>=e)i=e;else{if(!(i<0)){this.time=i;break t}i=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===r&&(t>=0?(r=0,this._setEndings(!0,0===this.repetitions,s)):this._setEndings(0===this.repetitions,!0,s)),i>=e||i<0){const n=Math.floor(i/e);i-=e*n,r+=Math.abs(n);const a=this.repetitions-r;if(a<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,i=t>0?e:0,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===a){const e=t<0;this._setEndings(e,!e,s)}else this._setEndings(!1,!1,s);this._loopCount=r,this.time=i,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:n})}}else this.time=i;if(s&&1==(1&r))return e-i}return i}_setEndings(t,e,n){const i=this._interpolantSettings;n?(i.endingStart=Pt,i.endingEnd=Pt):(i.endingStart=t?this.zeroSlopeAtStart?Pt:Lt:It,i.endingEnd=e?this.zeroSlopeAtEnd?Pt:Lt:It)}_scheduleFading(t,e,n){const i=this._mixer,r=i.time;let s=this._weightInterpolant;null===s&&(s=i._lendControlInterpolant(),this._weightInterpolant=s);const a=s.parameterPositions,o=s.sampleValues;return a[0]=r,o[0]=e,a[1]=r+t,o[1]=n,this}}const yu=new Float32Array(1);class xu{constructor(t){this.value=t}clone(){return new xu(void 0===this.value.clone?this.value:this.value.clone())}}let Mu=0;function Su(t,e){return t.distance-e.distance}function bu(t,e,n,i){if(t.layers.test(e.layers)&&t.raycast(e,n),!0===i){const i=t.children;for(let t=0,r=i.length;t=0;--e)t[e].stop();return this}update(t){t*=this.timeScale;const e=this._actions,n=this._nActiveActions,i=this.time+=t,r=Math.sign(t),s=this._accuIndex^=1;for(let a=0;a!==n;++a){e[a]._update(i,t,r,s)}const a=this._bindings,o=this._nActiveBindings;for(let t=0;t!==o;++t)a[t].apply(s);return this}setTime(t){this.time=0;for(let t=0;t=r){const s=r++,c=t[s];e[c.uuid]=l,t[l]=c,e[o]=s,t[s]=a;for(let t=0,e=i;t!==e;++t){const e=n[t],i=e[s],r=e[l];e[l]=i,e[s]=r}}}this.nCachedObjects_=r}uncache(){const t=this._objects,e=this._indicesByUUID,n=this._bindings,i=n.length;let r=this.nCachedObjects_,s=t.length;for(let a=0,o=arguments.length;a!==o;++a){const o=arguments[a].uuid,l=e[o];if(void 0!==l)if(delete e[o],l0&&(e[a.uuid]=l),t[l]=a,t.pop();for(let t=0,e=i;t!==e;++t){const e=n[t];e[l]=e[r],e.pop()}}}this.nCachedObjects_=r}subscribe_(t,e){const n=this._bindingsIndicesByPath;let i=n[t];const r=this._bindings;if(void 0!==i)return r[i];const s=this._paths,a=this._parsedPaths,o=this._objects,l=o.length,c=this.nCachedObjects_,h=new Array(l);i=r.length,n[t]=i,s.push(t),a.push(e),r.push(h);for(let n=c,i=o.length;n!==i;++n){const i=o[n];h[n]=new _u(i,t,e)}return h}unsubscribe_(t){const e=this._bindingsIndicesByPath,n=e[t];if(void 0!==n){const i=this._paths,r=this._parsedPaths,s=this._bindings,a=s.length-1,o=s[a];e[t[a]]=n,s[n]=o,s.pop(),r[n]=r[a],r.pop(),i[n]=i[a],i.pop()}}},t.AnimationUtils=Qc,t.ArcCurve=_l,t.ArrayCamera=Wa,t.ArrowHelper=class extends Xn{constructor(t=new ke(0,0,1),e=new ke(0,0,0),n=1,i=16776960,r=.2*n,s=.2*r){super(),this.type="ArrowHelper",void 0===ku&&(ku=new Pi,ku.setAttribute("position",new bi([0,0,0,0,1,0],3)),Wu=new Hl(0,.5,1,5,1),Wu.translate(0,-.5,0)),this.position.copy(e),this.line=new nl(ku,new Jo({color:i,toneMapped:!1})),this.line.matrixAutoUpdate=!1,this.add(this.line),this.cone=new Zi(Wu,new di({color:i,toneMapped:!1})),this.cone.matrixAutoUpdate=!1,this.add(this.cone),this.setDirection(t),this.setLength(n,r,s)}setDirection(t){if(t.y>.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{Vu.set(t.z,0,-t.x).normalize();const e=Math.acos(t.y);this.quaternion.setFromAxisAngle(Vu,e)}}setLength(t,e=.2*t,n=.2*e){this.line.scale.set(1,Math.max(1e-4,t-e),1),this.line.updateMatrix(),this.cone.scale.set(n,e,n),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}dispose(){this.line.geometry.dispose(),this.line.material.dispose(),this.cone.geometry.dispose(),this.cone.material.dispose()}},t.AttachedBindMode=y,t.Audio=su,t.AudioAnalyser=class{constructor(t,e=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=e,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0;const e=this.getFrequencyData();for(let n=0;nthis.max.x||t.ythis.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.xthis.max.x||t.max.ythis.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return this.clampPoint(t,Tu).distanceTo(t)}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}},t.Box3=je,t.Box3Helper=class extends sl{constructor(t,e=16776960){const n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Pi;i.setIndex(new xi(n,1)),i.setAttribute("position",new bi([1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],3)),super(i,new Jo({color:e,toneMapped:!1})),this.box=t,this.type="Box3Helper",this.geometry.computeBoundingSphere()}updateMatrixWorld(t){const e=this.box;e.isEmpty()||(e.getCenter(this.position),e.getSize(this.scale),this.scale.multiplyScalar(.5),super.updateMatrixWorld(t))}dispose(){this.geometry.dispose(),this.material.dispose()}},t.BoxGeometry=Ki,t.BoxHelper=class extends sl{constructor(t,e=16776960){const n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Float32Array(24),r=new Pi;r.setIndex(new xi(n,1)),r.setAttribute("position",new xi(i,3)),super(r,new Jo({color:e,toneMapped:!1})),this.object=t,this.type="BoxHelper",this.matrixAutoUpdate=!1,this.update()}update(t){if(void 0!==t&&console.warn("THREE.BoxHelper: .update() has no longer arguments."),void 0!==this.object&&Gu.setFromObject(this.object),Gu.isEmpty())return;const e=Gu.min,n=Gu.max,i=this.geometry.attributes.position,r=i.array;r[0]=n.x,r[1]=n.y,r[2]=n.z,r[3]=e.x,r[4]=n.y,r[5]=n.z,r[6]=e.x,r[7]=e.y,r[8]=n.z,r[9]=n.x,r[10]=e.y,r[11]=n.z,r[12]=n.x,r[13]=n.y,r[14]=e.z,r[15]=e.x,r[16]=n.y,r[17]=e.z,r[18]=e.x,r[19]=e.y,r[20]=e.z,r[21]=n.x,r[22]=e.y,r[23]=e.z,i.needsUpdate=!0,this.geometry.computeBoundingSphere()}setFromObject(t){return this.object=t,this.update(),this}copy(t,e){return super.copy(t,e),this.object=t.object,this}dispose(){this.geometry.dispose(),this.material.dispose()}},t.BufferAttribute=xi,t.BufferGeometry=Pi,t.BufferGeometryLoader=Wh,t.ByteType=1010,t.Cache=mh,t.Camera=ir,t.CameraHelper=class extends sl{constructor(t){const e=new Pi,n=new Jo({color:16777215,vertexColors:!0,toneMapped:!1}),i=[],r=[],s={};function a(t,e){o(t),o(e)}function o(t){i.push(0,0,0),r.push(0,0,0),void 0===s[t]&&(s[t]=[]),s[t].push(i.length/3-1)}a("n1","n2"),a("n2","n4"),a("n4","n3"),a("n3","n1"),a("f1","f2"),a("f2","f4"),a("f4","f3"),a("f3","f1"),a("n1","f1"),a("n2","f2"),a("n3","f3"),a("n4","f4"),a("p","n1"),a("p","n2"),a("p","n3"),a("p","n4"),a("u1","u2"),a("u2","u3"),a("u3","u1"),a("c","t"),a("p","c"),a("cn1","cn2"),a("cn3","cn4"),a("cf1","cf2"),a("cf3","cf4"),e.setAttribute("position",new bi(i,3)),e.setAttribute("color",new bi(r,3)),super(e,n),this.type="CameraHelper",this.camera=t,this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.pointMap=s,this.update();const l=new li(16755200),c=new li(16711680),h=new li(43775),u=new li(16777215),d=new li(3355443);this.setColors(l,c,h,u,d)}setColors(t,e,n,i,r){const s=this.geometry.getAttribute("color");s.setXYZ(0,t.r,t.g,t.b),s.setXYZ(1,t.r,t.g,t.b),s.setXYZ(2,t.r,t.g,t.b),s.setXYZ(3,t.r,t.g,t.b),s.setXYZ(4,t.r,t.g,t.b),s.setXYZ(5,t.r,t.g,t.b),s.setXYZ(6,t.r,t.g,t.b),s.setXYZ(7,t.r,t.g,t.b),s.setXYZ(8,t.r,t.g,t.b),s.setXYZ(9,t.r,t.g,t.b),s.setXYZ(10,t.r,t.g,t.b),s.setXYZ(11,t.r,t.g,t.b),s.setXYZ(12,t.r,t.g,t.b),s.setXYZ(13,t.r,t.g,t.b),s.setXYZ(14,t.r,t.g,t.b),s.setXYZ(15,t.r,t.g,t.b),s.setXYZ(16,t.r,t.g,t.b),s.setXYZ(17,t.r,t.g,t.b),s.setXYZ(18,t.r,t.g,t.b),s.setXYZ(19,t.r,t.g,t.b),s.setXYZ(20,t.r,t.g,t.b),s.setXYZ(21,t.r,t.g,t.b),s.setXYZ(22,t.r,t.g,t.b),s.setXYZ(23,t.r,t.g,t.b),s.setXYZ(24,e.r,e.g,e.b),s.setXYZ(25,e.r,e.g,e.b),s.setXYZ(26,e.r,e.g,e.b),s.setXYZ(27,e.r,e.g,e.b),s.setXYZ(28,e.r,e.g,e.b),s.setXYZ(29,e.r,e.g,e.b),s.setXYZ(30,e.r,e.g,e.b),s.setXYZ(31,e.r,e.g,e.b),s.setXYZ(32,n.r,n.g,n.b),s.setXYZ(33,n.r,n.g,n.b),s.setXYZ(34,n.r,n.g,n.b),s.setXYZ(35,n.r,n.g,n.b),s.setXYZ(36,n.r,n.g,n.b),s.setXYZ(37,n.r,n.g,n.b),s.setXYZ(38,i.r,i.g,i.b),s.setXYZ(39,i.r,i.g,i.b),s.setXYZ(40,r.r,r.g,r.b),s.setXYZ(41,r.r,r.g,r.b),s.setXYZ(42,r.r,r.g,r.b),s.setXYZ(43,r.r,r.g,r.b),s.setXYZ(44,r.r,r.g,r.b),s.setXYZ(45,r.r,r.g,r.b),s.setXYZ(46,r.r,r.g,r.b),s.setXYZ(47,r.r,r.g,r.b),s.setXYZ(48,r.r,r.g,r.b),s.setXYZ(49,r.r,r.g,r.b),s.needsUpdate=!0}update(){const t=this.geometry,e=this.pointMap;zu.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse),Hu("c",e,t,zu,0,0,-1),Hu("t",e,t,zu,0,0,1),Hu("n1",e,t,zu,-1,-1,-1),Hu("n2",e,t,zu,1,-1,-1),Hu("n3",e,t,zu,-1,1,-1),Hu("n4",e,t,zu,1,1,-1),Hu("f1",e,t,zu,-1,-1,1),Hu("f2",e,t,zu,1,-1,1),Hu("f3",e,t,zu,-1,1,1),Hu("f4",e,t,zu,1,1,1),Hu("u1",e,t,zu,.7,1.1,-1),Hu("u2",e,t,zu,-.7,1.1,-1),Hu("u3",e,t,zu,0,2,-1),Hu("cf1",e,t,zu,-1,0,1),Hu("cf2",e,t,zu,1,0,1),Hu("cf3",e,t,zu,0,-1,1),Hu("cf4",e,t,zu,0,1,1),Hu("cn1",e,t,zu,-1,0,-1),Hu("cn2",e,t,zu,1,0,-1),Hu("cn3",e,t,zu,0,-1,-1),Hu("cn4",e,t,zu,0,1,-1),t.getAttribute("position").needsUpdate=!0}dispose(){this.geometry.dispose(),this.material.dispose()}},t.CanvasTexture=class extends Oe{constructor(t,e,n,i,r,s,a,o,l){super(t,e,n,i,r,s,a,o,l),this.isCanvasTexture=!0,this.needsUpdate=!0}},t.CapsuleGeometry=Bl,t.CatmullRomCurve3=bl,t.CineonToneMapping=g,t.CircleGeometry=zl,t.ClampToEdgeWrapping=R,t.Clock=Qh,t.Color=li,t.ColorKeyframeTrack=ah,t.ColorManagement=Ae,t.CompressedArrayTexture=class extends ml{constructor(t,e,n,i,r,s){super(t,e,n,r,s),this.isCompressedArrayTexture=!0,this.image.depth=i,this.wrapR=R}},t.CompressedCubeTexture=class extends ml{constructor(t,e,n){super(void 0,t[0].width,t[0].height,e,n,S),this.isCompressedCubeTexture=!0,this.isCubeTexture=!0,this.image=t}},t.CompressedTexture=ml,t.CompressedTextureLoader=class extends _h{constructor(t){super(t)}load(t,e,n,i){const r=this,s=[],a=new ml,o=new xh(this.manager);o.setPath(this.path),o.setResponseType("arraybuffer"),o.setRequestHeader(this.requestHeader),o.setWithCredentials(r.withCredentials);let l=0;function c(c){o.load(t[c],(function(t){const n=r.parse(t,!0);s[c]={width:n.width,height:n.height,format:n.format,mipmaps:n.mipmaps},l+=1,6===l&&(1===n.mipmapCount&&(a.minFilter=U),a.image=s,a.format=n.format,a.needsUpdate=!0,e&&e(a))}),n,i)}if(Array.isArray(t))for(let e=0,n=t.length;e0){const n=new fh(e);r=new Mh(n),r.setCrossOrigin(this.crossOrigin);for(let e=0,n=t.length;e0){i=new Mh(this.manager),i.setCrossOrigin(this.crossOrigin);for(let e=0,i=t.length;e1)for(let n=0;nNumber.EPSILON){if(l<0&&(n=e[s],o=-o,a=e[r],l=-l),t.ya.y)continue;if(t.y===n.y){if(t.x===n.x)return!0}else{const e=l*(t.x-n.x)-o*(t.y-n.y);if(0===e)return!0;if(e<0)continue;i=!i}}else{if(t.y!==n.y)continue;if(a.x<=t.x&&t.x<=n.x||n.x<=t.x&&t.x<=a.x)return!0}}return i}const n=Mc.isClockWise,i=this.subPaths;if(0===i.length)return[];let r,s,a;const o=[];if(1===i.length)return s=i[0],a=new Zl,a.curves=s.curves,o.push(a),o;let l=!n(i[0].getPoints());l=t?!l:l;const c=[],h=[];let u,d,p=[],m=0;h[m]=void 0,p[m]=[];for(let e=0,a=i.length;e1){let t=!1,n=0;for(let t=0,e=h.length;t0&&!1===t&&(p=c)}for(let t=0,e=h.length;t=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}},t.WebGL1Renderer=Qa,t.WebGL3DRenderTarget=class extends ze{constructor(t=1,e=1,n=1){super(t,e),this.isWebGL3DRenderTarget=!0,this.depth=n,this.texture=new Ge(null,t,e,n),this.texture.isRenderTargetTexture=!0}},t.WebGLArrayRenderTarget=class extends ze{constructor(t=1,e=1,n=1){super(t,e),this.isWebGLArrayRenderTarget=!0,this.depth=n,this.texture=new He(null,t,e,n),this.texture.isRenderTargetTexture=!0}},t.WebGLCoordinateSystem=Jt,t.WebGLCubeRenderTarget=lr,t.WebGLMultipleRenderTargets=class extends ze{constructor(t=1,e=1,n=1,i={}){super(t,e,i),this.isWebGLMultipleRenderTargets=!0;const r=this.texture;this.texture=[];for(let t=0;te.start-t.start);let t=0;for(let e=1;e 0\n\tvec4 plane;\n\t#ifdef ALPHA_TO_COVERAGE\n\t\tfloat distanceToPlane, distanceGradient;\n\t\tfloat clipOpacity = 1.0;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n\t\t\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\n\t\t\tclipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n\t\t\tif ( clipOpacity == 0.0 ) discard;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\t\tfloat unionClipOpacity = 1.0;\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\t\tplane = clippingPlanes[ i ];\n\t\t\t\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n\t\t\t\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\n\t\t\t\tunionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\t\t\tclipOpacity *= 1.0 - unionClipOpacity;\n\t\t#endif\n\t\tdiffuseColor.a *= clipOpacity;\n\t\tif ( diffuseColor.a == 0.0 ) discard;\n\t#else\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\t\tbool clipped = true;\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\t\tplane = clippingPlanes[ i ];\n\t\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\t\t\tif ( clipped ) discard;\n\t\t#endif\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#if defined( USE_COLOR ) || defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#endif",color_pars_fragment:"#if defined( USE_COLOR ) || defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR ) || defined( USE_COLOR_ALPHA ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )\n\tvarying vec4 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR ) || defined( USE_COLOR_ALPHA ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )\n\tvColor = vec4( 1.0 );\n#endif\n#ifdef USE_COLOR_ALPHA\n\tvColor *= color;\n#elif defined( USE_COLOR )\n\tvColor.rgb *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.rgb *= instanceColor.rgb;\n#endif\n#ifdef USE_BATCHING_COLOR\n\tvColor *= getBatchingColor( getIndirectIndex( gl_DrawID ) );\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nvec3 pow2( const in vec3 x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\n#ifdef USE_ALPHAHASH\n\tvarying vec3 vPosition;\n#endif\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n} // validated",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\thighp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tuv.x += filterInt * 3.0 * cubeUV_minTileSize;\n\t\tuv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\n\t\tuv.x *= CUBEUV_TEXEL_WIDTH;\n\t\tuv.y *= CUBEUV_TEXEL_HEIGHT;\n\t\t#ifdef texture2DGradEXT\n\t\t\treturn texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\n\t\t#else\n\t\t\treturn texture2D( envMap, uv ).rgb;\n\t\t#endif\n\t}\n\t#define cubeUV_r0 1.0\n\t#define cubeUV_m0 - 2.0\n\t#define cubeUV_r1 0.8\n\t#define cubeUV_m1 - 1.0\n\t#define cubeUV_r4 0.4\n\t#define cubeUV_m4 2.0\n\t#define cubeUV_r5 0.305\n\t#define cubeUV_m5 3.0\n\t#define cubeUV_r6 0.21\n\t#define cubeUV_m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= cubeUV_r1 ) {\n\t\t\tmip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\n\t\t} else if ( roughness >= cubeUV_r4 ) {\n\t\t\tmip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\n\t\t} else if ( roughness >= cubeUV_r5 ) {\n\t\t\tmip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\n\t\t} else if ( roughness >= cubeUV_r6 ) {\n\t\t\tmip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = objectTangent;\n#endif\n#ifdef USE_BATCHING\n\tmat3 bm = mat3( batchingMatrix );\n\ttransformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );\n\ttransformedNormal = bm * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = bm * transformedTangent;\n\t#endif\n#endif\n#ifdef USE_INSTANCING\n\tmat3 im = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );\n\ttransformedNormal = im * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = im * transformedTangent;\n\t#endif\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\ttransformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE_EMISSIVE\n\t\temissiveColor = sRGBTransferEOTF( emissiveColor );\n\t#endif\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",colorspace_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",colorspace_pars_fragment:"vec4 LinearTransferOETF( in vec4 value ) {\n\treturn value;\n}\nvec4 sRGBTransferEOTF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 sRGBTransferOETF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, envMapRotation * reflectVec );\n\t\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t\t#endif\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform mat3 envMapRotation;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#ifdef USE_ENVMAP\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, pow4( roughness ) ) );\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\t#ifdef USE_ANISOTROPY\n\t\tvec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\n\t\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\t\tvec3 bentNormal = cross( bitangent, viewDir );\n\t\t\t\tbentNormal = normalize( cross( bentNormal, bitangent ) );\n\t\t\t\tbentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\n\t\t\t\treturn getIBLRadiance( viewDir, bentNormal, roughness );\n\t\t\t#else\n\t\t\t\treturn vec3( 0.0 );\n\t\t\t#endif\n\t\t}\n\t#endif\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\tvec2 fw = fwidth( coord ) * 0.5;\n\t\treturn mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\n\t#endif\n}",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_fragment:"LambertMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularStrength = specularStrength;",lights_lambert_pars_fragment:"varying vec3 vViewPosition;\nstruct LambertMaterial {\n\tvec3 diffuseColor;\n\tfloat specularStrength;\n};\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Lambert\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Lambert",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\n#if defined( USE_LIGHT_PROBES )\n\tuniform vec3 lightProbe[ 9 ];\n#endif\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif ( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif\n#include ",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.diffuseContribution = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.metalness = metalnessFactor;\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\tmaterial.ior = ior;\n\t#ifdef USE_SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULAR_COLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\n\t\t#endif\n\t\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor;\n\tmaterial.specularColorBlended = mix( material.specularColor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = vec3( 0.04 );\n\tmaterial.specularColorBlended = mix( material.specularColor, diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_DISPERSION\n\tmaterial.dispersion = dispersion;\n#endif\n#ifdef USE_IRIDESCENCE\n\tmaterial.iridescence = iridescence;\n\tmaterial.iridescenceIOR = iridescenceIOR;\n\t#ifdef USE_IRIDESCENCEMAP\n\t\tmaterial.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\n\t#endif\n\t#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\t\tmaterial.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\n\t#else\n\t\tmaterial.iridescenceThickness = iridescenceThicknessMaximum;\n\t#endif\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.0001, 1.0 );\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\t#ifdef USE_ANISOTROPYMAP\n\t\tmat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\n\t\tvec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\n\t\tvec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\n\t#else\n\t\tvec2 anisotropyV = anisotropyVector;\n\t#endif\n\tmaterial.anisotropy = length( anisotropyV );\n\tif( material.anisotropy == 0.0 ) {\n\t\tanisotropyV = vec2( 1.0, 0.0 );\n\t} else {\n\t\tanisotropyV /= material.anisotropy;\n\t\tmaterial.anisotropy = saturate( material.anisotropy );\n\t}\n\tmaterial.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\n\tmaterial.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;\n\tmaterial.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;\n#endif",lights_physical_pars_fragment:"uniform sampler2D dfgLUT;\nstruct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tvec3 diffuseContribution;\n\tvec3 specularColor;\n\tvec3 specularColorBlended;\n\tfloat roughness;\n\tfloat metalness;\n\tfloat specularF90;\n\tfloat dispersion;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_IRIDESCENCE\n\t\tfloat iridescence;\n\t\tfloat iridescenceIOR;\n\t\tfloat iridescenceThickness;\n\t\tvec3 iridescenceFresnel;\n\t\tvec3 iridescenceF0;\n\t\tvec3 iridescenceFresnelDielectric;\n\t\tvec3 iridescenceFresnelMetallic;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n\t#ifdef IOR\n\t\tfloat ior;\n\t#endif\n\t#ifdef USE_TRANSMISSION\n\t\tfloat transmission;\n\t\tfloat transmissionAlpha;\n\t\tfloat thickness;\n\t\tfloat attenuationDistance;\n\t\tvec3 attenuationColor;\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat anisotropy;\n\t\tfloat alphaT;\n\t\tvec3 anisotropyT;\n\t\tvec3 anisotropyB;\n\t#endif\n};\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\nvec3 sheenSpecularDirect = vec3( 0.0 );\nvec3 sheenSpecularIndirect = vec3(0.0 );\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\n float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\n float x2 = x * x;\n float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\n return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\n#ifdef USE_ANISOTROPY\n\tfloat V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\n\t\tfloat gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\n\t\tfloat gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\n\t\treturn 0.5 / max( gv + gl, EPSILON );\n\t}\n\tfloat D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\n\t\tfloat a2 = alphaT * alphaB;\n\t\thighp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\n\t\thighp float v2 = dot( v, v );\n\t\tfloat w2 = a2 / v2;\n\t\treturn RECIPROCAL_PI * a2 * pow2 ( w2 );\n\t}\n#endif\n#ifdef USE_CLEARCOAT\n\tvec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\n\t\tvec3 f0 = material.clearcoatF0;\n\t\tfloat f90 = material.clearcoatF90;\n\t\tfloat roughness = material.clearcoatRoughness;\n\t\tfloat alpha = pow2( roughness );\n\t\tvec3 halfDir = normalize( lightDir + viewDir );\n\t\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\t\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\t\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\t\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\t\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t\treturn F * ( V * D );\n\t}\n#endif\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n\tvec3 f0 = material.specularColorBlended;\n\tfloat f90 = material.specularF90;\n\tfloat roughness = material.roughness;\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t#ifdef USE_IRIDESCENCE\n\t\tF = mix( F, material.iridescenceFresnel, material.iridescence );\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat dotTL = dot( material.anisotropyT, lightDir );\n\t\tfloat dotTV = dot( material.anisotropyT, viewDir );\n\t\tfloat dotTH = dot( material.anisotropyT, halfDir );\n\t\tfloat dotBL = dot( material.anisotropyB, lightDir );\n\t\tfloat dotBV = dot( material.anisotropyB, viewDir );\n\t\tfloat dotBH = dot( material.anisotropyB, halfDir );\n\t\tfloat V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\n\t\tfloat D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\n\t#else\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t#endif\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transpose( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat rInv = 1.0 / ( roughness + 0.1 );\n\tfloat a = -1.9362 + 1.0678 * roughness + 0.4573 * r2 - 0.8469 * rInv;\n\tfloat b = -0.6014 + 0.5538 * roughness - 0.4670 * r2 - 0.1255 * rInv;\n\tfloat DG = exp( a * dotNV + b );\n\treturn saturate( DG );\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 fab = texture2D( dfgLUT, vec2( roughness, dotNV ) ).rg;\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\n#ifdef USE_IRIDESCENCE\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#else\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#endif\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 fab = texture2D( dfgLUT, vec2( roughness, dotNV ) ).rg;\n\t#ifdef USE_IRIDESCENCE\n\t\tvec3 Fr = mix( specularColor, iridescenceF0, iridescence );\n\t#else\n\t\tvec3 Fr = specularColor;\n\t#endif\n\tvec3 FssEss = Fr * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\nvec3 BRDF_GGX_Multiscatter( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n\tvec3 singleScatter = BRDF_GGX( lightDir, viewDir, normal, material );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 dfgV = texture2D( dfgLUT, vec2( material.roughness, dotNV ) ).rg;\n\tvec2 dfgL = texture2D( dfgLUT, vec2( material.roughness, dotNL ) ).rg;\n\tvec3 FssEss_V = material.specularColorBlended * dfgV.x + material.specularF90 * dfgV.y;\n\tvec3 FssEss_L = material.specularColorBlended * dfgL.x + material.specularF90 * dfgL.y;\n\tfloat Ess_V = dfgV.x + dfgV.y;\n\tfloat Ess_L = dfgL.x + dfgL.y;\n\tfloat Ems_V = 1.0 - Ess_V;\n\tfloat Ems_L = 1.0 - Ess_L;\n\tvec3 Favg = material.specularColorBlended + ( 1.0 - material.specularColorBlended ) * 0.047619;\n\tvec3 Fms = FssEss_V * FssEss_L * Favg / ( 1.0 - Ems_V * Ems_L * Favg + EPSILON );\n\tfloat compensationFactor = Ems_V * Ems_L;\n\tvec3 multiScatter = Fms * compensationFactor;\n\treturn singleScatter + multiScatter;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometryNormal;\n\t\tvec3 viewDir = geometryViewDir;\n\t\tvec3 position = geometryPosition;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3( 0, 1, 0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColorBlended * t2.x + ( material.specularF90 - material.specularColorBlended ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseContribution * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t\t#ifdef USE_CLEARCOAT\n\t\t\tvec3 Ncc = geometryClearcoatNormal;\n\t\t\tvec2 uvClearcoat = LTC_Uv( Ncc, viewDir, material.clearcoatRoughness );\n\t\t\tvec4 t1Clearcoat = texture2D( ltc_1, uvClearcoat );\n\t\t\tvec4 t2Clearcoat = texture2D( ltc_2, uvClearcoat );\n\t\t\tmat3 mInvClearcoat = mat3(\n\t\t\t\tvec3( t1Clearcoat.x, 0, t1Clearcoat.y ),\n\t\t\t\tvec3( 0, 1, 0 ),\n\t\t\t\tvec3( t1Clearcoat.z, 0, t1Clearcoat.w )\n\t\t\t);\n\t\t\tvec3 fresnelClearcoat = material.clearcoatF0 * t2Clearcoat.x + ( material.clearcoatF90 - material.clearcoatF0 ) * t2Clearcoat.y;\n\t\t\tclearcoatSpecularDirect += lightColor * fresnelClearcoat * LTC_Evaluate( Ncc, viewDir, position, mInvClearcoat, rectCoords );\n\t\t#endif\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\n\t#endif\n\t#ifdef USE_SHEEN\n \n \t\tsheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\n \n \t\tfloat sheenAlbedoV = IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n \t\tfloat sheenAlbedoL = IBLSheenBRDF( geometryNormal, directLight.direction, material.sheenRoughness );\n \n \t\tfloat sheenEnergyComp = 1.0 - max3( material.sheenColor ) * max( sheenAlbedoV, sheenAlbedoL );\n \n \t\tirradiance *= sheenEnergyComp;\n \n \t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX_Multiscatter( directLight.direction, geometryViewDir, geometryNormal, material );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseContribution );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 diffuse = irradiance * BRDF_Lambert( material.diffuseContribution );\n\t#ifdef USE_SHEEN\n\t\tfloat sheenAlbedo = IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n\t\tfloat sheenEnergyComp = 1.0 - max3( material.sheenColor ) * sheenAlbedo;\n\t\tdiffuse *= sheenEnergyComp;\n\t#endif\n\treflectedLight.indirectDiffuse += diffuse;\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness ) * RECIPROCAL_PI;\n \t#endif\n\tvec3 singleScatteringDielectric = vec3( 0.0 );\n\tvec3 multiScatteringDielectric = vec3( 0.0 );\n\tvec3 singleScatteringMetallic = vec3( 0.0 );\n\tvec3 multiScatteringMetallic = vec3( 0.0 );\n\t#ifdef USE_IRIDESCENCE\n\t\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnelDielectric, material.roughness, singleScatteringDielectric, multiScatteringDielectric );\n\t\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.diffuseColor, material.specularF90, material.iridescence, material.iridescenceFresnelMetallic, material.roughness, singleScatteringMetallic, multiScatteringMetallic );\n\t#else\n\t\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScatteringDielectric, multiScatteringDielectric );\n\t\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.diffuseColor, material.specularF90, material.roughness, singleScatteringMetallic, multiScatteringMetallic );\n\t#endif\n\tvec3 singleScattering = mix( singleScatteringDielectric, singleScatteringMetallic, material.metalness );\n\tvec3 multiScattering = mix( multiScatteringDielectric, multiScatteringMetallic, material.metalness );\n\tvec3 totalScatteringDielectric = singleScatteringDielectric + multiScatteringDielectric;\n\tvec3 diffuse = material.diffuseContribution * ( 1.0 - totalScatteringDielectric );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tvec3 indirectSpecular = radiance * singleScattering;\n\tindirectSpecular += multiScattering * cosineWeightedIrradiance;\n\tvec3 indirectDiffuse = diffuse * cosineWeightedIrradiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenAlbedo = IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n\t\tfloat sheenEnergyComp = 1.0 - max3( material.sheenColor ) * sheenAlbedo;\n\t\tindirectSpecular *= sheenEnergyComp;\n\t\tindirectDiffuse *= sheenEnergyComp;\n\t#endif\n\treflectedLight.indirectSpecular += indirectSpecular;\n\treflectedLight.indirectDiffuse += indirectDiffuse;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nvec3 geometryPosition = - vViewPosition;\nvec3 geometryNormal = normal;\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\nvec3 geometryClearcoatNormal = vec3( 0.0 );\n#ifdef USE_CLEARCOAT\n\tgeometryClearcoatNormal = clearcoatNormal;\n#endif\n#ifdef USE_IRIDESCENCE\n\tfloat dotNVi = saturate( dot( normal, geometryViewDir ) );\n\tif ( material.iridescenceThickness == 0.0 ) {\n\t\tmaterial.iridescence = 0.0;\n\t} else {\n\t\tmaterial.iridescence = saturate( material.iridescence );\n\t}\n\tif ( material.iridescence > 0.0 ) {\n\t\tmaterial.iridescenceFresnelDielectric = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\n\t\tmaterial.iridescenceFresnelMetallic = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.diffuseColor );\n\t\tmaterial.iridescenceFresnel = mix( material.iridescenceFresnelDielectric, material.iridescenceFresnelMetallic, material.metalness );\n\t\tmaterial.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\n\t}\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometryPosition, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS ) && ( defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_BASIC ) )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\tvec4 spotColor;\n\tvec3 spotLightCoord;\n\tbool inSpotLightMap;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometryPosition, directLight );\n\t\t#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\n\t\t#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\n\t\t#else\n\t\t#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#endif\n\t\t#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\n\t\t\tspotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\n\t\t\tinSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\n\t\t\tspotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\n\t\t\tdirectLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\n\t\t#endif\n\t\t#undef SPOT_LIGHT_MAP_INDEX\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#if defined( USE_LIGHT_PROBES )\n\t\tirradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n\t#ifdef USE_LIGHT_PROBES_GRID\n\t\tvec3 probeWorldPos = ( ( vec4( geometryPosition, 1.0 ) - viewMatrix[ 3 ] ) * viewMatrix ).xyz;\n\t\tvec3 probeWorldNormal = inverseTransformDirection( geometryNormal, viewMatrix );\n\t\tirradiance += getLightProbeGridIrradiance( probeWorldPos, probeWorldNormal );\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\t#if defined( STANDARD ) || defined( LAMBERT ) || defined( PHONG )\n\t\t\tiblIrradiance += getIBLIrradiance( geometryNormal );\n\t\t#endif\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\t#ifdef USE_ANISOTROPY\n\t\tradiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\n\t#else\n\t\tradiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\t#if defined( LAMBERT ) || defined( PHONG )\n\t\tirradiance += iblIrradiance;\n\t#endif\n\tRE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif",lightprobes_pars_fragment:"#ifdef USE_LIGHT_PROBES_GRID\nuniform highp sampler3D probesSH;\nuniform vec3 probesMin;\nuniform vec3 probesMax;\nuniform vec3 probesResolution;\nvec3 getLightProbeGridIrradiance( vec3 worldPos, vec3 worldNormal ) {\n\tvec3 res = probesResolution;\n\tvec3 gridRange = probesMax - probesMin;\n\tvec3 resMinusOne = res - 1.0;\n\tvec3 probeSpacing = gridRange / resMinusOne;\n\tvec3 samplePos = worldPos + worldNormal * probeSpacing * 0.5;\n\tvec3 uvw = clamp( ( samplePos - probesMin ) / gridRange, 0.0, 1.0 );\n\tuvw = uvw * resMinusOne / res + 0.5 / res;\n\tfloat nz = res.z;\n\tfloat paddedSlices = nz + 2.0;\n\tfloat atlasDepth = 7.0 * paddedSlices;\n\tfloat uvZBase = uvw.z * nz + 1.0;\n\tvec4 s0 = texture( probesSH, vec3( uvw.xy, ( uvZBase ) / atlasDepth ) );\n\tvec4 s1 = texture( probesSH, vec3( uvw.xy, ( uvZBase + paddedSlices ) / atlasDepth ) );\n\tvec4 s2 = texture( probesSH, vec3( uvw.xy, ( uvZBase + 2.0 * paddedSlices ) / atlasDepth ) );\n\tvec4 s3 = texture( probesSH, vec3( uvw.xy, ( uvZBase + 3.0 * paddedSlices ) / atlasDepth ) );\n\tvec4 s4 = texture( probesSH, vec3( uvw.xy, ( uvZBase + 4.0 * paddedSlices ) / atlasDepth ) );\n\tvec4 s5 = texture( probesSH, vec3( uvw.xy, ( uvZBase + 5.0 * paddedSlices ) / atlasDepth ) );\n\tvec4 s6 = texture( probesSH, vec3( uvw.xy, ( uvZBase + 6.0 * paddedSlices ) / atlasDepth ) );\n\tvec3 c0 = s0.xyz;\n\tvec3 c1 = vec3( s0.w, s1.xy );\n\tvec3 c2 = vec3( s1.zw, s2.x );\n\tvec3 c3 = s2.yzw;\n\tvec3 c4 = s3.xyz;\n\tvec3 c5 = vec3( s3.w, s4.xy );\n\tvec3 c6 = vec3( s4.zw, s5.x );\n\tvec3 c7 = s5.yzw;\n\tvec3 c8 = s6.xyz;\n\tfloat x = worldNormal.x, y = worldNormal.y, z = worldNormal.z;\n\tvec3 result = c0 * 0.886227;\n\tresult += c1 * 2.0 * 0.511664 * y;\n\tresult += c2 * 2.0 * 0.511664 * z;\n\tresult += c3 * 2.0 * 0.511664 * x;\n\tresult += c4 * 2.0 * 0.429043 * x * y;\n\tresult += c5 * 2.0 * 0.429043 * y * z;\n\tresult += c6 * ( 0.743125 * z * z - 0.247708 );\n\tresult += c7 * 2.0 * 0.429043 * x * z;\n\tresult += c8 * 0.429043 * ( x * x - y * y );\n\treturn max( result, vec3( 0.0 ) );\n}\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGARITHMIC_DEPTH_BUFFER )\n\tgl_FragDepth = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGARITHMIC_DEPTH_BUFFER )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGARITHMIC_DEPTH_BUFFER\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGARITHMIC_DEPTH_BUFFER\n\tvFragDepth = 1.0 + gl_Position.w;\n\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = sRGBTransferEOTF( sampledDiffuseColor );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t#if defined( USE_POINTS_UV )\n\t\tvec2 uv = vUv;\n\t#else\n\t\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_POINTS_UV )\n\tvarying vec2 vUv;\n#else\n\t#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t\tuniform mat3 uvTransform;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphinstance_vertex:"#ifdef USE_INSTANCING_MORPH\n\tfloat morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\tfloat morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tmorphTargetInfluences[i] = texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;\n\t}\n#endif",morphcolor_vertex:"#if defined( USE_MORPHCOLORS )\n\tvColor *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t#if defined( USE_COLOR_ALPHA )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\n\t\t#elif defined( USE_COLOR )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\n\t\t#endif\n\t}\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\n\t}\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\t#ifndef USE_INSTANCING_MORPH\n\t\tuniform float morphTargetBaseInfluence;\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t#endif\n\tuniform sampler2DArray morphTargetsTexture;\n\tuniform ivec2 morphTargetsTextureSize;\n\tvec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\n\t\tint texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\n\t\tint y = texelIndex / morphTargetsTextureSize.x;\n\t\tint x = texelIndex - y * morphTargetsTextureSize.x;\n\t\tivec3 morphUV = ivec3( x, y, morphTargetIndex );\n\t\treturn texelFetch( morphTargetsTexture, morphUV, 0 );\n\t}\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\n\t}\n#endif",normal_fragment_begin:"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = dFdx( vViewPosition );\n\tvec3 fdy = dFdy( vViewPosition );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal *= faceDirection;\n\t#endif\n#endif\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn = getTangentFrame( - vViewPosition, normal,\n\t\t#if defined( USE_NORMALMAP )\n\t\t\tvNormalMapUv\n\t\t#elif defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tvClearcoatNormalMapUv\n\t\t#else\n\t\t\tvUv\n\t\t#endif\n\t\t);\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn[0] *= faceDirection;\n\t\ttbn[1] *= faceDirection;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn2[0] *= faceDirection;\n\t\ttbn2[1] *= faceDirection;\n\t#endif\n#endif\nvec3 nonPerturbedNormal = normal;",normal_fragment_maps:"#ifdef USE_NORMALMAP_OBJECTSPACE\n\tnormal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\n\tvec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\t#if defined( USE_PACKED_NORMALMAP )\n\t\tmapN = vec3( mapN.xy, sqrt( saturate( 1.0 - dot( mapN.xy, mapN.xy ) ) ) );\n\t#endif\n\tmapN.xy *= normalScale;\n\tnormal = normalize( tbn * mapN );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif",normal_pars_fragment:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_pars_vertex:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_vertex:"#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef USE_NORMALMAP_OBJECTSPACE\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\n\tmat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\n\t\tvec3 q0 = dFdx( eye_pos.xyz );\n\t\tvec3 q1 = dFdy( eye_pos.xyz );\n\t\tvec2 st0 = dFdx( uv.st );\n\t\tvec2 st1 = dFdy( uv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\n\t\treturn mat3( T * scale, B * scale, N );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = nonPerturbedNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\tclearcoatNormal = normalize( tbn2 * clearcoatMapN );\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif",iridescence_pars_fragment:"#ifdef USE_IRIDESCENCEMAP\n\tuniform sampler2D iridescenceMap;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform sampler2D iridescenceThicknessMap;\n#endif",opaque_fragment:"#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= material.transmissionAlpha;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;const float ShiftRight8 = 1. / 256.;\nconst float Inv255 = 1. / 255.;\nconst vec4 PackFactors = vec4( 1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0 );\nconst vec2 UnpackFactors2 = vec2( UnpackDownscale, 1.0 / PackFactors.g );\nconst vec3 UnpackFactors3 = vec3( UnpackDownscale / PackFactors.rg, 1.0 / PackFactors.b );\nconst vec4 UnpackFactors4 = vec4( UnpackDownscale / PackFactors.rgb, 1.0 / PackFactors.a );\nvec4 packDepthToRGBA( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec4( 0., 0., 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec4( 1., 1., 1., 1. );\n\tfloat vuf;\n\tfloat af = modf( v * PackFactors.a, vuf );\n\tfloat bf = modf( vuf * ShiftRight8, vuf );\n\tfloat gf = modf( vuf * ShiftRight8, vuf );\n\treturn vec4( vuf * Inv255, gf * PackUpscale, bf * PackUpscale, af );\n}\nvec3 packDepthToRGB( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec3( 0., 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec3( 1., 1., 1. );\n\tfloat vuf;\n\tfloat bf = modf( v * PackFactors.b, vuf );\n\tfloat gf = modf( vuf * ShiftRight8, vuf );\n\treturn vec3( vuf * Inv255, gf * PackUpscale, bf );\n}\nvec2 packDepthToRG( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec2( 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec2( 1., 1. );\n\tfloat vuf;\n\tfloat gf = modf( v * 256., vuf );\n\treturn vec2( vuf * Inv255, gf );\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors4 );\n}\nfloat unpackRGBToDepth( const in vec3 v ) {\n\treturn dot( v, UnpackFactors3 );\n}\nfloat unpackRGToDepth( const in vec2 v ) {\n\treturn v.r * UnpackFactors2.r + v.g * UnpackFactors2.g;\n}\nvec4 pack2HalfToRGBA( const in vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( const in vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\n\t\treturn depth * ( far - near ) - far;\n\t#else\n\t\treturn depth * ( near - far ) - near;\n\t#endif\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\t\n\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\treturn ( near * far ) / ( ( near - far ) * depth - near );\n\t#else\n\t\treturn ( near * far ) / ( ( far - near ) * depth - far );\n\t#endif\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_BATCHING\n\tmvPosition = batchingMatrix * mvPosition;\n#endif\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#if NUM_SPOT_LIGHT_COORDS > 0\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#if NUM_SPOT_LIGHT_MAPS > 0\n\tuniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tuniform sampler2DShadow directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\t#else\n\t\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\t#endif\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tuniform sampler2DShadow spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\t#else\n\t\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\t#endif\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tuniform samplerCubeShadow pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\t#elif defined( SHADOWMAP_TYPE_BASIC )\n\t\t\tuniform samplerCube pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\t#endif\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\tfloat interleavedGradientNoise( vec2 position ) {\n\t\t\treturn fract( 52.9829189 * fract( dot( position, vec2( 0.06711056, 0.00583715 ) ) ) );\n\t\t}\n\t\tvec2 vogelDiskSample( int sampleIndex, int samplesCount, float phi ) {\n\t\t\tconst float goldenAngle = 2.399963229728653;\n\t\t\tfloat r = sqrt( ( float( sampleIndex ) + 0.5 ) / float( samplesCount ) );\n\t\t\tfloat theta = float( sampleIndex ) * goldenAngle + phi;\n\t\t\treturn vec2( cos( theta ), sin( theta ) ) * r;\n\t\t}\n\t#endif\n\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\tfloat getShadow( sampler2DShadow shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\t\tfloat shadow = 1.0;\n\t\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\t\tshadowCoord.z += shadowBias;\n\t\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\t\tif ( frustumTest ) {\n\t\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\t\tfloat radius = shadowRadius * texelSize.x;\n\t\t\t\tfloat phi = interleavedGradientNoise( gl_FragCoord.xy ) * PI2;\n\t\t\t\tshadow = (\n\t\t\t\t\ttexture( shadowMap, vec3( shadowCoord.xy + vogelDiskSample( 0, 5, phi ) * radius, shadowCoord.z ) ) +\n\t\t\t\t\ttexture( shadowMap, vec3( shadowCoord.xy + vogelDiskSample( 1, 5, phi ) * radius, shadowCoord.z ) ) +\n\t\t\t\t\ttexture( shadowMap, vec3( shadowCoord.xy + vogelDiskSample( 2, 5, phi ) * radius, shadowCoord.z ) ) +\n\t\t\t\t\ttexture( shadowMap, vec3( shadowCoord.xy + vogelDiskSample( 3, 5, phi ) * radius, shadowCoord.z ) ) +\n\t\t\t\t\ttexture( shadowMap, vec3( shadowCoord.xy + vogelDiskSample( 4, 5, phi ) * radius, shadowCoord.z ) )\n\t\t\t\t) * 0.2;\n\t\t\t}\n\t\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t\t}\n\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\t\tfloat shadow = 1.0;\n\t\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\t\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\t\t\tshadowCoord.z -= shadowBias;\n\t\t\t#else\n\t\t\t\tshadowCoord.z += shadowBias;\n\t\t\t#endif\n\t\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\t\tif ( frustumTest ) {\n\t\t\t\tvec2 distribution = texture2D( shadowMap, shadowCoord.xy ).rg;\n\t\t\t\tfloat mean = distribution.x;\n\t\t\t\tfloat variance = distribution.y * distribution.y;\n\t\t\t\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\t\t\t\tfloat hard_shadow = step( mean, shadowCoord.z );\n\t\t\t\t#else\n\t\t\t\t\tfloat hard_shadow = step( shadowCoord.z, mean );\n\t\t\t\t#endif\n\t\t\t\t\n\t\t\t\tif ( hard_shadow == 1.0 ) {\n\t\t\t\t\tshadow = 1.0;\n\t\t\t\t} else {\n\t\t\t\t\tvariance = max( variance, 0.0000001 );\n\t\t\t\t\tfloat d = shadowCoord.z - mean;\n\t\t\t\t\tfloat p_max = variance / ( variance + d * d );\n\t\t\t\t\tp_max = clamp( ( p_max - 0.3 ) / 0.65, 0.0, 1.0 );\n\t\t\t\t\tshadow = max( hard_shadow, p_max );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t\t}\n\t#else\n\t\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\t\tfloat shadow = 1.0;\n\t\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\t\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\t\t\tshadowCoord.z -= shadowBias;\n\t\t\t#else\n\t\t\t\tshadowCoord.z += shadowBias;\n\t\t\t#endif\n\t\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\t\tif ( frustumTest ) {\n\t\t\t\tfloat depth = texture2D( shadowMap, shadowCoord.xy ).r;\n\t\t\t\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\t\t\t\tshadow = step( depth, shadowCoord.z );\n\t\t\t\t#else\n\t\t\t\t\tshadow = step( shadowCoord.z, depth );\n\t\t\t\t#endif\n\t\t\t}\n\t\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#if defined( SHADOWMAP_TYPE_PCF )\n\tfloat getPointShadow( samplerCubeShadow shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tfloat shadow = 1.0;\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\tvec3 absVec = abs( lightToPosition );\n\t\tfloat viewSpaceZ = max( max( absVec.x, absVec.y ), absVec.z );\n\t\tif ( viewSpaceZ - shadowCameraFar <= 0.0 && viewSpaceZ - shadowCameraNear >= 0.0 ) {\n\t\t\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\t\t\tfloat dp = ( shadowCameraNear * ( shadowCameraFar - viewSpaceZ ) ) / ( viewSpaceZ * ( shadowCameraFar - shadowCameraNear ) );\n\t\t\t\tdp -= shadowBias;\n\t\t\t#else\n\t\t\t\tfloat dp = ( shadowCameraFar * ( viewSpaceZ - shadowCameraNear ) ) / ( viewSpaceZ * ( shadowCameraFar - shadowCameraNear ) );\n\t\t\t\tdp += shadowBias;\n\t\t\t#endif\n\t\t\tfloat texelSize = shadowRadius / shadowMapSize.x;\n\t\t\tvec3 absDir = abs( bd3D );\n\t\t\tvec3 tangent = absDir.x > absDir.z ? vec3( 0.0, 1.0, 0.0 ) : vec3( 1.0, 0.0, 0.0 );\n\t\t\ttangent = normalize( cross( bd3D, tangent ) );\n\t\t\tvec3 bitangent = cross( bd3D, tangent );\n\t\t\tfloat phi = interleavedGradientNoise( gl_FragCoord.xy ) * PI2;\n\t\t\tvec2 sample0 = vogelDiskSample( 0, 5, phi );\n\t\t\tvec2 sample1 = vogelDiskSample( 1, 5, phi );\n\t\t\tvec2 sample2 = vogelDiskSample( 2, 5, phi );\n\t\t\tvec2 sample3 = vogelDiskSample( 3, 5, phi );\n\t\t\tvec2 sample4 = vogelDiskSample( 4, 5, phi );\n\t\t\tshadow = (\n\t\t\t\ttexture( shadowMap, vec4( bd3D + ( tangent * sample0.x + bitangent * sample0.y ) * texelSize, dp ) ) +\n\t\t\t\ttexture( shadowMap, vec4( bd3D + ( tangent * sample1.x + bitangent * sample1.y ) * texelSize, dp ) ) +\n\t\t\t\ttexture( shadowMap, vec4( bd3D + ( tangent * sample2.x + bitangent * sample2.y ) * texelSize, dp ) ) +\n\t\t\t\ttexture( shadowMap, vec4( bd3D + ( tangent * sample3.x + bitangent * sample3.y ) * texelSize, dp ) ) +\n\t\t\t\ttexture( shadowMap, vec4( bd3D + ( tangent * sample4.x + bitangent * sample4.y ) * texelSize, dp ) )\n\t\t\t) * 0.2;\n\t\t}\n\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t}\n\t#elif defined( SHADOWMAP_TYPE_BASIC )\n\tfloat getPointShadow( samplerCube shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tfloat shadow = 1.0;\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tvec3 absVec = abs( lightToPosition );\n\t\tfloat viewSpaceZ = max( max( absVec.x, absVec.y ), absVec.z );\n\t\tif ( viewSpaceZ - shadowCameraFar <= 0.0 && viewSpaceZ - shadowCameraNear >= 0.0 ) {\n\t\t\tfloat dp = ( shadowCameraFar * ( viewSpaceZ - shadowCameraNear ) ) / ( viewSpaceZ * ( shadowCameraFar - shadowCameraNear ) );\n\t\t\tdp += shadowBias;\n\t\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t\tfloat depth = textureCube( shadowMap, bd3D ).r;\n\t\t\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\t\t\tdepth = 1.0 - depth;\n\t\t\t#endif\n\t\t\tshadow = step( dp, depth );\n\t\t}\n\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t}\n\t#endif\n\t#endif\n#endif",shadowmap_pars_vertex:"#if NUM_SPOT_LIGHT_COORDS > 0\n\tuniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\n\t#ifdef HAS_NORMAL\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t#else\n\t\tvec3 shadowWorldNormal = vec3( 0.0 );\n\t#endif\n\tvec4 shadowWorldPosition;\n#endif\n#if defined( USE_SHADOWMAP )\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if NUM_SPOT_LIGHT_COORDS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition;\n\t\t#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t\tshadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\n\t\t#endif\n\t\tvSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowIntensity, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowIntensity, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0 && ( defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_BASIC ) )\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowIntensity, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\tuniform highp sampler2D boneTexture;\n\tmat4 getBoneMatrix( const in float i ) {\n\t\tint size = textureSize( boneTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn saturate( toneMappingExposure * color );\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 CineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3( 1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108, 1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605, 1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\n\tvec3( 1.6605, - 0.1246, - 0.0182 ),\n\tvec3( - 0.5876, 1.1329, - 0.1006 ),\n\tvec3( - 0.0728, - 0.0083, 1.1187 )\n);\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\n\tvec3( 0.6274, 0.0691, 0.0164 ),\n\tvec3( 0.3293, 0.9195, 0.0880 ),\n\tvec3( 0.0433, 0.0113, 0.8956 )\n);\nvec3 agxDefaultContrastApprox( vec3 x ) {\n\tvec3 x2 = x * x;\n\tvec3 x4 = x2 * x2;\n\treturn + 15.5 * x4 * x2\n\t\t- 40.14 * x4 * x\n\t\t+ 31.96 * x4\n\t\t- 6.868 * x2 * x\n\t\t+ 0.4298 * x2\n\t\t+ 0.1191 * x\n\t\t- 0.00232;\n}\nvec3 AgXToneMapping( vec3 color ) {\n\tconst mat3 AgXInsetMatrix = mat3(\n\t\tvec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),\n\t\tvec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),\n\t\tvec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )\n\t);\n\tconst mat3 AgXOutsetMatrix = mat3(\n\t\tvec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),\n\t\tvec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),\n\t\tvec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )\n\t);\n\tconst float AgxMinEv = - 12.47393;\tconst float AgxMaxEv = 4.026069;\n\tcolor *= toneMappingExposure;\n\tcolor = LINEAR_SRGB_TO_LINEAR_REC2020 * color;\n\tcolor = AgXInsetMatrix * color;\n\tcolor = max( color, 1e-10 );\tcolor = log2( color );\n\tcolor = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );\n\tcolor = clamp( color, 0.0, 1.0 );\n\tcolor = agxDefaultContrastApprox( color );\n\tcolor = AgXOutsetMatrix * color;\n\tcolor = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );\n\tcolor = LINEAR_REC2020_TO_LINEAR_SRGB * color;\n\tcolor = clamp( color, 0.0, 1.0 );\n\treturn color;\n}\nvec3 NeutralToneMapping( vec3 color ) {\n\tconst float StartCompression = 0.8 - 0.04;\n\tconst float Desaturation = 0.15;\n\tcolor *= toneMappingExposure;\n\tfloat x = min( color.r, min( color.g, color.b ) );\n\tfloat offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n\tcolor -= offset;\n\tfloat peak = max( color.r, max( color.g, color.b ) );\n\tif ( peak < StartCompression ) return color;\n\tfloat d = 1. - StartCompression;\n\tfloat newPeak = 1. - d * d / ( peak + d - StartCompression );\n\tcolor *= newPeak / peak;\n\tfloat g = 1. - 1. / ( Desaturation * ( peak - newPeak ) + 1. );\n\treturn mix( color, vec3( newPeak ), g );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmission_fragment:"#ifdef USE_TRANSMISSION\n\tmaterial.transmission = transmission;\n\tmaterial.transmissionAlpha = 1.0;\n\tmaterial.thickness = thickness;\n\tmaterial.attenuationDistance = attenuationDistance;\n\tmaterial.attenuationColor = attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tmaterial.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tmaterial.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmitted = getIBLVolumeRefraction(\n\t\tn, v, material.roughness, material.diffuseContribution, material.specularColorBlended, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, material.dispersion, material.ior, material.thickness,\n\t\tmaterial.attenuationColor, material.attenuationDistance );\n\tmaterial.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\n\ttotalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\n#endif",transmission_pars_fragment:"#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tfloat w0( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\n\t}\n\tfloat w1( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * ( 3.0 * a - 6.0 ) + 4.0 );\n\t}\n\tfloat w2( float a ){\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\n\t}\n\tfloat w3( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * a );\n\t}\n\tfloat g0( float a ) {\n\t\treturn w0( a ) + w1( a );\n\t}\n\tfloat g1( float a ) {\n\t\treturn w2( a ) + w3( a );\n\t}\n\tfloat h0( float a ) {\n\t\treturn - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\n\t}\n\tfloat h1( float a ) {\n\t\treturn 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\n\t}\n\tvec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\n\t\tuv = uv * texelSize.zw + 0.5;\n\t\tvec2 iuv = floor( uv );\n\t\tvec2 fuv = fract( uv );\n\t\tfloat g0x = g0( fuv.x );\n\t\tfloat g1x = g1( fuv.x );\n\t\tfloat h0x = h0( fuv.x );\n\t\tfloat h1x = h1( fuv.x );\n\t\tfloat h0y = h0( fuv.y );\n\t\tfloat h1y = h1( fuv.y );\n\t\tvec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\treturn g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\n\t\t\tg1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\n\t}\n\tvec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\n\t\tvec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\n\t\tvec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\n\t\tvec2 fLodSizeInv = 1.0 / fLodSize;\n\t\tvec2 cLodSizeInv = 1.0 / cLodSize;\n\t\tvec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\n\t\tvec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\n\t\treturn mix( fSample, cSample, fract( lod ) );\n\t}\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\treturn textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\n\t}\n\tvec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( isinf( attenuationDistance ) ) {\n\t\t\treturn vec3( 1.0 );\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float dispersion, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec4 transmittedLight;\n\t\tvec3 transmittance;\n\t\t#ifdef USE_DISPERSION\n\t\t\tfloat halfSpread = ( ior - 1.0 ) * 0.025 * dispersion;\n\t\t\tvec3 iors = vec3( ior - halfSpread, ior, ior + halfSpread );\n\t\t\tfor ( int i = 0; i < 3; i ++ ) {\n\t\t\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, iors[ i ], modelMatrix );\n\t\t\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\t\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\t\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\t\t\trefractionCoords += 1.0;\n\t\t\t\trefractionCoords /= 2.0;\n\t\t\t\tvec4 transmissionSample = getTransmissionSample( refractionCoords, roughness, iors[ i ] );\n\t\t\t\ttransmittedLight[ i ] = transmissionSample[ i ];\n\t\t\t\ttransmittedLight.a += transmissionSample.a;\n\t\t\t\ttransmittance[ i ] = diffuseColor[ i ] * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance )[ i ];\n\t\t\t}\n\t\t\ttransmittedLight.a /= 3.0;\n\t\t#else\n\t\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\t\trefractionCoords += 1.0;\n\t\t\trefractionCoords /= 2.0;\n\t\t\ttransmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\t\ttransmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\t#endif\n\t\tvec3 attenuatedColor = transmittance * transmittedLight.rgb;\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\tfloat transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\n\t}\n#endif",uv_pars_fragment:"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif",uv_pars_vertex:"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tuniform mat3 mapTransform;\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform mat3 alphaMapTransform;\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tuniform mat3 lightMapTransform;\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tuniform mat3 aoMapTransform;\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tuniform mat3 bumpMapTransform;\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tuniform mat3 normalMapTransform;\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tuniform mat3 displacementMapTransform;\n\tvarying vec2 vDisplacementMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tuniform mat3 emissiveMapTransform;\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tuniform mat3 metalnessMapTransform;\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tuniform mat3 roughnessMapTransform;\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tuniform mat3 anisotropyMapTransform;\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tuniform mat3 clearcoatMapTransform;\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform mat3 clearcoatNormalMapTransform;\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform mat3 clearcoatRoughnessMapTransform;\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tuniform mat3 sheenColorMapTransform;\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tuniform mat3 sheenRoughnessMapTransform;\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tuniform mat3 iridescenceMapTransform;\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform mat3 iridescenceThicknessMapTransform;\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tuniform mat3 specularMapTransform;\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tuniform mat3 specularColorMapTransform;\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tuniform mat3 specularIntensityMapTransform;\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif",uv_vertex:"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvUv = vec3( uv, 1 ).xy;\n#endif\n#ifdef USE_MAP\n\tvMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ALPHAMAP\n\tvAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_LIGHTMAP\n\tvLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_AOMAP\n\tvAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_BUMPMAP\n\tvBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_NORMALMAP\n\tvNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tvDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_METALNESSMAP\n\tvMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULARMAP\n\tvSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tvTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_THICKNESSMAP\n\tvThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_BATCHING\n\t\tworldPosition = batchingMatrix * worldPosition;\n\t#endif\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",background_frag:"uniform sampler2D t2D;\nuniform float backgroundIntensity;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\ttexColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include \n\t#include \n}",backgroundCube_vert:"varying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n\tgl_Position.z = gl_Position.w;\n}",backgroundCube_frag:"#ifdef ENVMAP_TYPE_CUBE\n\tuniform samplerCube envMap;\n#elif defined( ENVMAP_TYPE_CUBE_UV )\n\tuniform sampler2D envMap;\n#endif\nuniform float backgroundBlurriness;\nuniform float backgroundIntensity;\nuniform mat3 backgroundRotation;\nvarying vec3 vWorldDirection;\n#include \nvoid main() {\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 texColor = textureCube( envMap, backgroundRotation * vWorldDirection );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );\n\t#else\n\t\tvec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include \n\t#include \n}",cube_vert:"varying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n\tgl_Position.z = gl_Position.w;\n}",cube_frag:"uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor = texColor;\n\tgl_FragColor.a *= opacity;\n\t#include \n\t#include \n}",depth_vert:"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \n\t\t#include \n\t\t#include \n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvHighPrecisionZW = gl_Position.zw;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include \n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#ifdef USE_REVERSED_DEPTH_BUFFER\n\t\tfloat fragCoordZ = vHighPrecisionZW[ 0 ] / vHighPrecisionZW[ 1 ];\n\t#else\n\t\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[ 0 ] / vHighPrecisionZW[ 1 ] + 0.5;\n\t#endif\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#elif DEPTH_PACKING == 3202\n\t\tgl_FragColor = vec4( packDepthToRGB( fragCoordZ ), 1.0 );\n\t#elif DEPTH_PACKING == 3203\n\t\tgl_FragColor = vec4( packDepthToRG( fragCoordZ ), 0.0, 1.0 );\n\t#endif\n}",distance_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \n\t\t#include \n\t\t#include \n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvWorldPosition = worldPosition.xyz;\n}",distance_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main () {\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = vec4( dist, 0.0, 0.0, 1.0 );\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include \n\t#include \n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include \nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include \n\t#include \n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include \n\t#include \n\t#include \n\toutgoingLight = diffuseColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshbasic_vert:"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include \n\t\t#include \n\t\t#include \n\t\t#include \n\t\t#include \n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include \n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n\t#include \n}",meshlambert_frag:"#define LAMBERT\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshnormal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",meshnormal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( 0.0, 0.0, 0.0, opacity );\n\t#include \n\t#include \n\t#include \n\t#include \n\tgl_FragColor = vec4( normalize( normal ) * 0.5 + 0.5, diffuseColor.a );\n\t#ifdef OPAQUE\n\t\tgl_FragColor.a = 1.0;\n\t#endif\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n\t#include \n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_DISPERSION\n\tuniform float dispersion;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\tuniform vec2 anisotropyVector;\n\t#ifdef USE_ANISOTROPYMAP\n\t\tuniform sampler2D anisotropyMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include \n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n \n\t\toutgoingLight = outgoingLight + sheenSpecularDirect + sheenSpecularIndirect;\n \n \t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvViewPosition = - mvPosition.xyz;\n\t#include \n\t#include \n\t#include \n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",points_vert:"uniform float size;\nuniform float scale;\n#include \n#include \n#include \n#include \n#include \n#include \n#ifdef USE_POINTS_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif\nvoid main() {\n\t#ifdef USE_POINTS_UV\n\t\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include \n\t#include \n\t#include \n\t#include \n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\toutgoingLight = diffuseColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",shadow_vert:"#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include \n\t#include \n\t#include \n\t#include \n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\t#include \n\tvec4 mvPosition = modelViewMatrix[ 3 ];\n\tvec2 scale = vec2( length( modelMatrix[ 0 ].xyz ), length( modelMatrix[ 1 ].xyz ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include \n\t#include \n\t#include \n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include \n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include \n\t#include \n\t#include \n\t#include \n\t#include \n\toutgoingLight = diffuseColor.rgb;\n\t#include \n\t#include \n\t#include \n\t#include \n}"},Gn={common:{diffuse:{value:new n(16777215)},opacity:{value:1},map:{value:null},mapTransform:{value:new e},alphaMap:{value:null},alphaMapTransform:{value:new e},alphaTest:{value:0}},specularmap:{specularMap:{value:null},specularMapTransform:{value:new e}},envmap:{envMap:{value:null},envMapRotation:{value:new e},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98},dfgLUT:{value:null}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1},aoMapTransform:{value:new e}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1},lightMapTransform:{value:new e}},bumpmap:{bumpMap:{value:null},bumpMapTransform:{value:new e},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalMapTransform:{value:new e},normalScale:{value:new t(1,1)}},displacementmap:{displacementMap:{value:null},displacementMapTransform:{value:new e},displacementScale:{value:1},displacementBias:{value:0}},emissivemap:{emissiveMap:{value:null},emissiveMapTransform:{value:new e}},metalnessmap:{metalnessMap:{value:null},metalnessMapTransform:{value:new e}},roughnessmap:{roughnessMap:{value:null},roughnessMapTransform:{value:new e}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new n(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowIntensity:1,shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowIntensity:1,shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotLightMap:{value:[]},spotLightMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowIntensity:1,shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null},probesSH:{value:null},probesMin:{value:new i},probesMax:{value:new i},probesResolution:{value:new i}},points:{diffuse:{value:new n(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaMapTransform:{value:new e},alphaTest:{value:0},uvTransform:{value:new e}},sprite:{diffuse:{value:new n(16777215)},opacity:{value:1},center:{value:new t(.5,.5)},rotation:{value:0},map:{value:null},mapTransform:{value:new e},alphaMap:{value:null},alphaMapTransform:{value:new e},alphaTest:{value:0}}},Hn={basic:{uniforms:r([Gn.common,Gn.specularmap,Gn.envmap,Gn.aomap,Gn.lightmap,Gn.fog]),vertexShader:Bn.meshbasic_vert,fragmentShader:Bn.meshbasic_frag},lambert:{uniforms:r([Gn.common,Gn.specularmap,Gn.envmap,Gn.aomap,Gn.lightmap,Gn.emissivemap,Gn.bumpmap,Gn.normalmap,Gn.displacementmap,Gn.fog,Gn.lights,{emissive:{value:new n(0)},envMapIntensity:{value:1}}]),vertexShader:Bn.meshlambert_vert,fragmentShader:Bn.meshlambert_frag},phong:{uniforms:r([Gn.common,Gn.specularmap,Gn.envmap,Gn.aomap,Gn.lightmap,Gn.emissivemap,Gn.bumpmap,Gn.normalmap,Gn.displacementmap,Gn.fog,Gn.lights,{emissive:{value:new n(0)},specular:{value:new n(1118481)},shininess:{value:30},envMapIntensity:{value:1}}]),vertexShader:Bn.meshphong_vert,fragmentShader:Bn.meshphong_frag},standard:{uniforms:r([Gn.common,Gn.envmap,Gn.aomap,Gn.lightmap,Gn.emissivemap,Gn.bumpmap,Gn.normalmap,Gn.displacementmap,Gn.roughnessmap,Gn.metalnessmap,Gn.fog,Gn.lights,{emissive:{value:new n(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Bn.meshphysical_vert,fragmentShader:Bn.meshphysical_frag},toon:{uniforms:r([Gn.common,Gn.aomap,Gn.lightmap,Gn.emissivemap,Gn.bumpmap,Gn.normalmap,Gn.displacementmap,Gn.gradientmap,Gn.fog,Gn.lights,{emissive:{value:new n(0)}}]),vertexShader:Bn.meshtoon_vert,fragmentShader:Bn.meshtoon_frag},matcap:{uniforms:r([Gn.common,Gn.bumpmap,Gn.normalmap,Gn.displacementmap,Gn.fog,{matcap:{value:null}}]),vertexShader:Bn.meshmatcap_vert,fragmentShader:Bn.meshmatcap_frag},points:{uniforms:r([Gn.points,Gn.fog]),vertexShader:Bn.points_vert,fragmentShader:Bn.points_frag},dashed:{uniforms:r([Gn.common,Gn.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Bn.linedashed_vert,fragmentShader:Bn.linedashed_frag},depth:{uniforms:r([Gn.common,Gn.displacementmap]),vertexShader:Bn.depth_vert,fragmentShader:Bn.depth_frag},normal:{uniforms:r([Gn.common,Gn.bumpmap,Gn.normalmap,Gn.displacementmap,{opacity:{value:1}}]),vertexShader:Bn.meshnormal_vert,fragmentShader:Bn.meshnormal_frag},sprite:{uniforms:r([Gn.sprite,Gn.fog]),vertexShader:Bn.sprite_vert,fragmentShader:Bn.sprite_frag},background:{uniforms:{uvTransform:{value:new e},t2D:{value:null},backgroundIntensity:{value:1}},vertexShader:Bn.background_vert,fragmentShader:Bn.background_frag},backgroundCube:{uniforms:{envMap:{value:null},backgroundBlurriness:{value:0},backgroundIntensity:{value:1},backgroundRotation:{value:new e}},vertexShader:Bn.backgroundCube_vert,fragmentShader:Bn.backgroundCube_frag},cube:{uniforms:{tCube:{value:null},tFlip:{value:-1},opacity:{value:1}},vertexShader:Bn.cube_vert,fragmentShader:Bn.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Bn.equirect_vert,fragmentShader:Bn.equirect_frag},distance:{uniforms:r([Gn.common,Gn.displacementmap,{referencePosition:{value:new i},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Bn.distance_vert,fragmentShader:Bn.distance_frag},shadow:{uniforms:r([Gn.lights,Gn.fog,{color:{value:new n(0)},opacity:{value:1}}]),vertexShader:Bn.shadow_vert,fragmentShader:Bn.shadow_frag}};Hn.physical={uniforms:r([Hn.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatMapTransform:{value:new e},clearcoatNormalMap:{value:null},clearcoatNormalMapTransform:{value:new e},clearcoatNormalScale:{value:new t(1,1)},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatRoughnessMapTransform:{value:new e},dispersion:{value:0},iridescence:{value:0},iridescenceMap:{value:null},iridescenceMapTransform:{value:new e},iridescenceIOR:{value:1.3},iridescenceThicknessMinimum:{value:100},iridescenceThicknessMaximum:{value:400},iridescenceThicknessMap:{value:null},iridescenceThicknessMapTransform:{value:new e},sheen:{value:0},sheenColor:{value:new n(0)},sheenColorMap:{value:null},sheenColorMapTransform:{value:new e},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},sheenRoughnessMapTransform:{value:new e},transmission:{value:0},transmissionMap:{value:null},transmissionMapTransform:{value:new e},transmissionSamplerSize:{value:new t},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},thicknessMapTransform:{value:new e},attenuationDistance:{value:0},attenuationColor:{value:new n(0)},specularColor:{value:new n(1,1,1)},specularColorMap:{value:null},specularColorMapTransform:{value:new e},specularIntensity:{value:1},specularIntensityMap:{value:null},specularIntensityMapTransform:{value:new e},anisotropyVector:{value:new t},anisotropyMap:{value:null},anisotropyMapTransform:{value:new e}}]),vertexShader:Bn.meshphysical_vert,fragmentShader:Bn.meshphysical_frag};const Vn={r:0,b:0,g:0},Wn=new u,zn=new e;function kn(e,t,i,r,u,g){const v=new n(0);let E,S,T=!0===u?0:1,M=null,x=0,A=null;function R(e){let n=!0===e.isScene?e.background:null;if(n&&n.isTexture){const i=e.backgroundBlurriness>0;n=t.get(n,i)}return n}function b(t,n){t.getRGB(Vn,_(e)),i.buffers.color.setClear(Vn.r,Vn.g,Vn.b,n,g)}return{getClearColor:function(){return v},setClearColor:function(e,t=1){v.set(e),T=t,b(v,T)},getClearAlpha:function(){return T},setClearAlpha:function(e){T=e,b(v,T)},render:function(t){let n=!1;const r=R(t);null===r?b(v,T):r&&r.isColor&&(b(r,1),n=!0);const a=e.xr.getEnvironmentBlendMode();"additive"===a?i.buffers.color.setClear(0,0,0,1,g):"alpha-blend"===a&&i.buffers.color.setClear(0,0,0,0,g),(e.autoClear||n)&&(i.buffers.depth.setTest(!0),i.buffers.depth.setMask(!0),i.buffers.color.setMask(!0),e.clear(e.autoClearColor,e.autoClearDepth,e.autoClearStencil))},addToRenderList:function(t,n){const i=R(n);i&&(i.isCubeTexture||i.mapping===a)?(void 0===S&&(S=new o(new s(1,1,1),new l({name:"BackgroundCubeMaterial",uniforms:d(Hn.backgroundCube.uniforms),vertexShader:Hn.backgroundCube.vertexShader,fragmentShader:Hn.backgroundCube.fragmentShader,side:c,depthTest:!1,depthWrite:!1,fog:!1,allowOverride:!1})),S.geometry.deleteAttribute("normal"),S.geometry.deleteAttribute("uv"),S.onBeforeRender=function(e,t,n){this.matrixWorld.copyPosition(n.matrixWorld)},Object.defineProperty(S.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),r.update(S)),S.material.uniforms.envMap.value=i,S.material.uniforms.backgroundBlurriness.value=n.backgroundBlurriness,S.material.uniforms.backgroundIntensity.value=n.backgroundIntensity,S.material.uniforms.backgroundRotation.value.setFromMatrix4(Wn.makeRotationFromEuler(n.backgroundRotation)).transpose(),i.isCubeTexture&&!1===i.isRenderTargetTexture&&S.material.uniforms.backgroundRotation.value.premultiply(zn),S.material.toneMapped=f.getTransfer(i.colorSpace)!==p,M===i&&x===i.version&&A===e.toneMapping||(S.material.needsUpdate=!0,M=i,x=i.version,A=e.toneMapping),S.layers.enableAll(),t.unshift(S,S.geometry,S.material,0,0,null)):i&&i.isTexture&&(void 0===E&&(E=new o(new m(2,2),new l({name:"BackgroundMaterial",uniforms:d(Hn.background.uniforms),vertexShader:Hn.background.vertexShader,fragmentShader:Hn.background.fragmentShader,side:h,depthTest:!1,depthWrite:!1,fog:!1,allowOverride:!1})),E.geometry.deleteAttribute("normal"),Object.defineProperty(E.material,"map",{get:function(){return this.uniforms.t2D.value}}),r.update(E)),E.material.uniforms.t2D.value=i,E.material.uniforms.backgroundIntensity.value=n.backgroundIntensity,E.material.toneMapped=f.getTransfer(i.colorSpace)!==p,!0===i.matrixAutoUpdate&&i.updateMatrix(),E.material.uniforms.uvTransform.value.copy(i.matrix),M===i&&x===i.version&&A===e.toneMapping||(E.material.needsUpdate=!0,M=i,x=i.version,A=e.toneMapping),E.layers.enableAll(),t.unshift(E,E.geometry,E.material,0,0,null))},dispose:function(){void 0!==S&&(S.geometry.dispose(),S.material.dispose(),S=void 0),void 0!==E&&(E.geometry.dispose(),E.material.dispose(),E=void 0)}}}function Xn(e,t){const n=e.getParameter(e.MAX_VERTEX_ATTRIBS),i={},r=c(null);let a=r,o=!1;function s(t){return e.bindVertexArray(t)}function l(t){return e.deleteVertexArray(t)}function c(e){const t=[],i=[],r=[];for(let e=0;e=0){const n=r[t];let i=o[t];if(void 0===i&&("instanceMatrix"===t&&e.instanceMatrix&&(i=e.instanceMatrix),"instanceColor"===t&&e.instanceColor&&(i=e.instanceColor)),void 0===n)return!0;if(n.attribute!==i)return!0;if(i&&n.data!==i.data)return!0;s++}}return a.attributesNum!==s||a.index!==i}(n,h,l,_),v&&function(e,t,n,i){const r={},o=t.attributes;let s=0;const l=n.getAttributes();for(const t in l){if(l[t].location>=0){let n=o[t];void 0===n&&("instanceMatrix"===t&&e.instanceMatrix&&(n=e.instanceMatrix),"instanceColor"===t&&e.instanceColor&&(n=e.instanceColor));const i={};i.attribute=n,n&&n.data&&(i.data=n.data),r[t]=i,s++}}a.attributes=r,a.attributesNum=s,a.index=i}(n,h,l,_),null!==_&&t.update(_,e.ELEMENT_ARRAY_BUFFER),(v||o)&&(o=!1,function(n,i,r,a){d();const o=a.attributes,s=r.getAttributes(),l=i.defaultAttributeValues;for(const i in s){const r=s[i];if(r.location>=0){let s=o[i];if(void 0===s&&("instanceMatrix"===i&&n.instanceMatrix&&(s=n.instanceMatrix),"instanceColor"===i&&n.instanceColor&&(s=n.instanceColor)),void 0!==s){const i=s.normalized,o=s.itemSize,l=t.get(s);if(void 0===l)continue;const c=l.buffer,d=l.type,p=l.bytesPerElement,h=d===e.INT||d===e.UNSIGNED_INT||s.gpuType===g;if(s.isInterleavedBufferAttribute){const t=s.data,l=t.stride,_=s.offset;if(t.isInstancedInterleavedBuffer){for(let e=0;e0&&e.getShaderPrecisionFormat(e.FRAGMENT_SHADER,e.HIGH_FLOAT).precision>0)return"highp";t="mediump"}return"mediump"===t&&e.getShaderPrecisionFormat(e.VERTEX_SHADER,e.MEDIUM_FLOAT).precision>0&&e.getShaderPrecisionFormat(e.FRAGMENT_SHADER,e.MEDIUM_FLOAT).precision>0?"mediump":"lowp"}let o=void 0!==n.precision?n.precision:"highp";const s=a(o);s!==o&&(v("WebGLRenderer:",o,"not supported, using",s,"instead."),o=s);const l=!0===n.logarithmicDepthBuffer,c=!0===n.reversedDepthBuffer&&t.has("EXT_clip_control");!0===n.reversedDepthBuffer&&!1===c&&v("WebGLRenderer: Unable to use reversed depth buffer due to missing EXT_clip_control extension. Fallback to default depth buffer.");return{isWebGL2:!0,getMaxAnisotropy:function(){if(void 0!==r)return r;if(!0===t.has("EXT_texture_filter_anisotropic")){const n=t.get("EXT_texture_filter_anisotropic");r=e.getParameter(n.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else r=0;return r},getMaxPrecision:a,textureFormatReadable:function(t){return t===M||i.convert(t)===e.getParameter(e.IMPLEMENTATION_COLOR_READ_FORMAT)},textureTypeReadable:function(n){const r=n===E&&(t.has("EXT_color_buffer_half_float")||t.has("EXT_color_buffer_float"));return!(n!==S&&i.convert(n)!==e.getParameter(e.IMPLEMENTATION_COLOR_READ_TYPE)&&n!==T&&!r)},precision:o,logarithmicDepthBuffer:l,reversedDepthBuffer:c,maxTextures:e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS),maxVertexTextures:e.getParameter(e.MAX_VERTEX_TEXTURE_IMAGE_UNITS),maxTextureSize:e.getParameter(e.MAX_TEXTURE_SIZE),maxCubemapSize:e.getParameter(e.MAX_CUBE_MAP_TEXTURE_SIZE),maxAttributes:e.getParameter(e.MAX_VERTEX_ATTRIBS),maxVertexUniforms:e.getParameter(e.MAX_VERTEX_UNIFORM_VECTORS),maxVaryings:e.getParameter(e.MAX_VARYING_VECTORS),maxFragmentUniforms:e.getParameter(e.MAX_FRAGMENT_UNIFORM_VECTORS),maxSamples:e.getParameter(e.MAX_SAMPLES),samples:e.getParameter(e.SAMPLES)}}function qn(t){const n=this;let i=null,r=0,a=!1,o=!1;const s=new x,l=new e,c={value:null,needsUpdate:!1};function d(e,t,i,r){const a=null!==e?e.length:0;let o=null;if(0!==a){if(o=c.value,!0!==r||null===o){const n=i+4*a,r=t.matrixWorldInverse;l.getNormalMatrix(r),(null===o||o.length0);n.numPlanes=r,n.numIntersection=0}();else{const e=o?0:r,t=4*e;let n=m.clippingState||null;c.value=n,n=d(u,s,t,l);for(let e=0;e!==t;++e)n[e]=i[e];m.clippingState=n,this.numIntersection=f?this.numPlanes:0,this.numPlanes+=e}}}zn.set(-1,0,0,0,1,0,0,0,1);const jn=[.125,.215,.35,.446,.526,.582],Zn=20,$n=new C,Qn=new n;let Jn=null,ei=0,ti=0,ni=!1;const ii=new i;class ri{constructor(e){this._renderer=e,this._pingPongRenderTarget=null,this._lodMax=0,this._cubeSize=0,this._sizeLods=[],this._sigmas=[],this._lodMeshes=[],this._backgroundBox=null,this._cubemapMaterial=null,this._equirectMaterial=null,this._blurMaterial=null,this._ggxMaterial=null}fromScene(e,t=0,n=.1,i=100,r={}){const{size:a=256,position:o=ii}=r;Jn=this._renderer.getRenderTarget(),ei=this._renderer.getActiveCubeFace(),ti=this._renderer.getActiveMipmapLevel(),ni=this._renderer.xr.enabled,this._renderer.xr.enabled=!1,this._setSize(a);const s=this._allocateTargets();return s.depthBuffer=!0,this._sceneToCubeUV(e,n,i,s,o),t>0&&this._blur(s,0,0,t),this._applyPMREM(s),this._cleanup(s),s}fromEquirectangular(e,t=null){return this._fromTexture(e,t)}fromCubemap(e,t=null){return this._fromTexture(e,t)}compileCubemapShader(){null===this._cubemapMaterial&&(this._cubemapMaterial=li(),this._compileMaterial(this._cubemapMaterial))}compileEquirectangularShader(){null===this._equirectMaterial&&(this._equirectMaterial=si(),this._compileMaterial(this._equirectMaterial))}dispose(){this._dispose(),null!==this._cubemapMaterial&&this._cubemapMaterial.dispose(),null!==this._equirectMaterial&&this._equirectMaterial.dispose(),null!==this._backgroundBox&&(this._backgroundBox.geometry.dispose(),this._backgroundBox.material.dispose())}_setSize(e){this._lodMax=Math.floor(Math.log2(e)),this._cubeSize=Math.pow(2,this._lodMax)}_dispose(){null!==this._blurMaterial&&this._blurMaterial.dispose(),null!==this._ggxMaterial&&this._ggxMaterial.dispose(),null!==this._pingPongRenderTarget&&this._pingPongRenderTarget.dispose();for(let e=0;ee-4?l=jn[s-e+4-1]:0===s&&(l=0),n.push(l);const c=1/(a-2),d=-c,u=1+c,f=[d,d,u,d,u,u,d,d,u,u,d,u],p=6,m=6,h=3,_=2,g=1,v=new Float32Array(h*m*p),E=new Float32Array(_*m*p),S=new Float32Array(g*m*p);for(let e=0;e2?0:-1,i=[t,n,0,t+2/3,n,0,t+2/3,n+1,0,t,n,0,t+2/3,n+1,0,t,n+1,0];v.set(i,h*m*e),E.set(f,_*m*e);const r=[e,e,e,e,e,e];S.set(r,g*m*e)}const T=new b;T.setAttribute("position",new N(v,h)),T.setAttribute("uv",new N(E,_)),T.setAttribute("faceIndex",new N(S,g)),i.push(new o(T,null)),r>4&&r--}return{lodMeshes:i,sizeLods:t,sigmas:n}}(r)),this._blurMaterial=function(e,t,n){const r=new Float32Array(Zn),a=new i(0,1,0),o=new l({name:"SphericalGaussianBlur",defines:{n:Zn,CUBEUV_TEXEL_WIDTH:1/t,CUBEUV_TEXEL_HEIGHT:1/n,CUBEUV_MAX_MIP:`${e}.0`},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:r},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:a}},vertexShader:ci(),fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include \n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t",blending:w,depthTest:!1,depthWrite:!1});return o}(r,e,t),this._ggxMaterial=function(e,t,n){const i=new l({name:"PMREMGGXConvolution",defines:{GGX_SAMPLES:256,CUBEUV_TEXEL_WIDTH:1/t,CUBEUV_TEXEL_HEIGHT:1/n,CUBEUV_MAX_MIP:`${e}.0`},uniforms:{envMap:{value:null},roughness:{value:0},mipInt:{value:0}},vertexShader:ci(),fragmentShader:'\n\n\t\t\tprecision highp float;\n\t\t\tprecision highp int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform float roughness;\n\t\t\tuniform float mipInt;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include \n\n\t\t\t#define PI 3.14159265359\n\n\t\t\t// Van der Corput radical inverse\n\t\t\tfloat radicalInverse_VdC(uint bits) {\n\t\t\t\tbits = (bits << 16u) | (bits >> 16u);\n\t\t\t\tbits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);\n\t\t\t\tbits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);\n\t\t\t\tbits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);\n\t\t\t\tbits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);\n\t\t\t\treturn float(bits) * 2.3283064365386963e-10; // / 0x100000000\n\t\t\t}\n\n\t\t\t// Hammersley sequence\n\t\t\tvec2 hammersley(uint i, uint N) {\n\t\t\t\treturn vec2(float(i) / float(N), radicalInverse_VdC(i));\n\t\t\t}\n\n\t\t\t// GGX VNDF importance sampling (Eric Heitz 2018)\n\t\t\t// "Sampling the GGX Distribution of Visible Normals"\n\t\t\t// https://jcgt.org/published/0007/04/01/\n\t\t\tvec3 importanceSampleGGX_VNDF(vec2 Xi, vec3 V, float roughness) {\n\t\t\t\tfloat alpha = roughness * roughness;\n\n\t\t\t\t// Section 4.1: Orthonormal basis\n\t\t\t\tvec3 T1 = vec3(1.0, 0.0, 0.0);\n\t\t\t\tvec3 T2 = cross(V, T1);\n\n\t\t\t\t// Section 4.2: Parameterization of projected area\n\t\t\t\tfloat r = sqrt(Xi.x);\n\t\t\t\tfloat phi = 2.0 * PI * Xi.y;\n\t\t\t\tfloat t1 = r * cos(phi);\n\t\t\t\tfloat t2 = r * sin(phi);\n\t\t\t\tfloat s = 0.5 * (1.0 + V.z);\n\t\t\t\tt2 = (1.0 - s) * sqrt(1.0 - t1 * t1) + s * t2;\n\n\t\t\t\t// Section 4.3: Reprojection onto hemisphere\n\t\t\t\tvec3 Nh = t1 * T1 + t2 * T2 + sqrt(max(0.0, 1.0 - t1 * t1 - t2 * t2)) * V;\n\n\t\t\t\t// Section 3.4: Transform back to ellipsoid configuration\n\t\t\t\treturn normalize(vec3(alpha * Nh.x, alpha * Nh.y, max(0.0, Nh.z)));\n\t\t\t}\n\n\t\t\tvoid main() {\n\t\t\t\tvec3 N = normalize(vOutputDirection);\n\t\t\t\tvec3 V = N; // Assume view direction equals normal for pre-filtering\n\n\t\t\t\tvec3 prefilteredColor = vec3(0.0);\n\t\t\t\tfloat totalWeight = 0.0;\n\n\t\t\t\t// For very low roughness, just sample the environment directly\n\t\t\t\tif (roughness < 0.001) {\n\t\t\t\t\tgl_FragColor = vec4(bilinearCubeUV(envMap, N, mipInt), 1.0);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Tangent space basis for VNDF sampling\n\t\t\t\tvec3 up = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);\n\t\t\t\tvec3 tangent = normalize(cross(up, N));\n\t\t\t\tvec3 bitangent = cross(N, tangent);\n\n\t\t\t\tfor(uint i = 0u; i < uint(GGX_SAMPLES); i++) {\n\t\t\t\t\tvec2 Xi = hammersley(i, uint(GGX_SAMPLES));\n\n\t\t\t\t\t// For PMREM, V = N, so in tangent space V is always (0, 0, 1)\n\t\t\t\t\tvec3 H_tangent = importanceSampleGGX_VNDF(Xi, vec3(0.0, 0.0, 1.0), roughness);\n\n\t\t\t\t\t// Transform H back to world space\n\t\t\t\t\tvec3 H = normalize(tangent * H_tangent.x + bitangent * H_tangent.y + N * H_tangent.z);\n\t\t\t\t\tvec3 L = normalize(2.0 * dot(V, H) * H - V);\n\n\t\t\t\t\tfloat NdotL = max(dot(N, L), 0.0);\n\n\t\t\t\t\tif(NdotL > 0.0) {\n\t\t\t\t\t\t// Sample environment at fixed mip level\n\t\t\t\t\t\t// VNDF importance sampling handles the distribution filtering\n\t\t\t\t\t\tvec3 sampleColor = bilinearCubeUV(envMap, L, mipInt);\n\n\t\t\t\t\t\t// Weight by NdotL for the split-sum approximation\n\t\t\t\t\t\t// VNDF PDF naturally accounts for the visible microfacet distribution\n\t\t\t\t\t\tprefilteredColor += sampleColor * NdotL;\n\t\t\t\t\t\ttotalWeight += NdotL;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (totalWeight > 0.0) {\n\t\t\t\t\tprefilteredColor = prefilteredColor / totalWeight;\n\t\t\t\t}\n\n\t\t\t\tgl_FragColor = vec4(prefilteredColor, 1.0);\n\t\t\t}\n\t\t',blending:w,depthTest:!1,depthWrite:!1});return i}(r,e,t)}return r}_compileMaterial(e){const t=new o(new b,e);this._renderer.compile(t,$n)}_sceneToCubeUV(e,t,n,i,r){const a=new P(90,1,t,n),l=[1,-1,1,1,1,1],d=[1,1,1,-1,-1,-1],u=this._renderer,f=u.autoClear,p=u.toneMapping;u.getClearColor(Qn),u.toneMapping=L,u.autoClear=!1;u.state.buffers.depth.getReversed()&&(u.setRenderTarget(i),u.clearDepth(),u.setRenderTarget(null)),null===this._backgroundBox&&(this._backgroundBox=new o(new s,new U({name:"PMREM.Background",side:c,depthWrite:!1,depthTest:!1})));const m=this._backgroundBox,h=m.material;let _=!1;const g=e.background;g?g.isColor&&(h.color.copy(g),e.background=null,_=!0):(h.color.copy(Qn),_=!0);for(let t=0;t<6;t++){const n=t%3;0===n?(a.up.set(0,l[t],0),a.position.set(r.x,r.y,r.z),a.lookAt(r.x+d[t],r.y,r.z)):1===n?(a.up.set(0,0,l[t]),a.position.set(r.x,r.y,r.z),a.lookAt(r.x,r.y+d[t],r.z)):(a.up.set(0,l[t],0),a.position.set(r.x,r.y,r.z),a.lookAt(r.x,r.y,r.z+d[t]));const o=this._cubeSize;oi(i,n*o,t>2?o:0,o,o),u.setRenderTarget(i),_&&u.render(m,a),u.render(e,a)}u.toneMapping=p,u.autoClear=f,e.background=g}_textureToCubeUV(e,t){const n=this._renderer,i=e.mapping===A||e.mapping===R;i?(null===this._cubemapMaterial&&(this._cubemapMaterial=li()),this._cubemapMaterial.uniforms.flipEnvMap.value=!1===e.isRenderTargetTexture?-1:1):null===this._equirectMaterial&&(this._equirectMaterial=si());const r=i?this._cubemapMaterial:this._equirectMaterial,a=this._lodMeshes[0];a.material=r;r.uniforms.envMap.value=e;const o=this._cubeSize;oi(t,0,0,3*o,2*o),n.setRenderTarget(t),n.render(a,$n)}_applyPMREM(e){const t=this._renderer,n=t.autoClear;t.autoClear=!1;const i=this._lodMeshes.length;for(let t=1;tu-4?n-u+4:0),m=4*(this._cubeSize-f);s.envMap.value=e.texture,s.roughness.value=d,s.mipInt.value=u-t,oi(r,p,m,3*f,2*f),i.setRenderTarget(r),i.render(o,$n),s.envMap.value=r.texture,s.roughness.value=0,s.mipInt.value=u-n,oi(e,p,m,3*f,2*f),i.setRenderTarget(e),i.render(o,$n)}_blur(e,t,n,i,r){const a=this._pingPongRenderTarget;this._halfBlur(e,a,t,n,i,"latitudinal",r),this._halfBlur(a,e,n,n,i,"longitudinal",r)}_halfBlur(e,t,n,i,r,a,o){const s=this._renderer,l=this._blurMaterial;"latitudinal"!==a&&"longitudinal"!==a&&D("blur direction must be either latitudinal or longitudinal!");const c=this._lodMeshes[i];c.material=l;const d=l.uniforms,u=this._sizeLods[n]-1,f=isFinite(r)?Math.PI/(2*u):2*Math.PI/39,p=r/f,m=isFinite(r)?1+Math.floor(3*p):Zn;m>Zn&&v(`sigmaRadians, ${r}, is too large and will clip, as it requested ${m} samples when the maximum is set to 20`);const h=[];let _=0;for(let e=0;eg-4?i-g+4:0),4*(this._cubeSize-E),3*E,2*E),s.setRenderTarget(t),s.render(c,$n)}}function ai(e,t,n){const i=new I(e,t,n);return i.texture.mapping=a,i.texture.name="PMREM.cubeUv",i.scissorTest=!0,i}function oi(e,t,n,i,r){e.viewport.set(t,n,i,r),e.scissor.set(t,n,i,r)}function si(){return new l({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null}},vertexShader:ci(),fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\n\t\t\t#include \n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tgl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );\n\n\t\t\t}\n\t\t",blending:w,depthTest:!1,depthWrite:!1})}function li(){return new l({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:ci(),fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t",blending:w,depthTest:!1,depthWrite:!1})}function ci(){return"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t"}class di extends I{constructor(e=1,t={}){super(e,e,t),this.isWebGLCubeRenderTarget=!0;const n={width:e,height:e,depth:1},i=[n,n,n,n,n,n];this.texture=new F(i),this._setTextureOptions(t),this.texture.isRenderTargetTexture=!0}fromEquirectangularTexture(e,t){this.texture.type=t.type,this.texture.colorSpace=t.colorSpace,this.texture.generateMipmaps=t.generateMipmaps,this.texture.minFilter=t.minFilter,this.texture.magFilter=t.magFilter;const n={uniforms:{tEquirect:{value:null}},vertexShader:"\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include \n\t\t\t\t\t#include \n\n\t\t\t\t}\n\t\t\t",fragmentShader:"\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include \n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t"},i=new s(5,5,5),r=new l({name:"CubemapFromEquirect",uniforms:d(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:c,blending:w});r.uniforms.tEquirect.value=t;const a=new o(i,r),u=t.minFilter;t.minFilter===B&&(t.minFilter=O);return new G(1,10,this).update(e,a),t.minFilter=u,a.geometry.dispose(),a.material.dispose(),this}clear(e,t=!0,n=!0,i=!0){const r=e.getRenderTarget();for(let r=0;r<6;r++)e.setRenderTarget(this,r),e.clear(t,n,i);e.setRenderTarget(r)}}function ui(e){let t=new WeakMap,n=new WeakMap,i=null;function r(e,t){return t===H?e.mapping=A:t===V&&(e.mapping=R),e}function a(e){const n=e.target;n.removeEventListener("dispose",a);const i=t.get(n);void 0!==i&&(t.delete(n),i.dispose())}function o(e){const t=e.target;t.removeEventListener("dispose",o);const i=n.get(t);void 0!==i&&(n.delete(t),i.dispose())}return{get:function(s,l=!1){return null==s?null:l?function(t){if(t&&t.isTexture){const r=t.mapping,a=r===H||r===V,s=r===A||r===R;if(a||s){let r=n.get(t);const l=void 0!==r?r.texture.pmremVersion:0;if(t.isRenderTargetTexture&&t.pmremVersion!==l)return null===i&&(i=new ri(e)),r=a?i.fromEquirectangular(t,r):i.fromCubemap(t,r),r.texture.pmremVersion=t.pmremVersion,n.set(t,r),r.texture;if(void 0!==r)return r.texture;{const l=t.image;return a&&l&&l.height>0||s&&l&&function(e){let t=0;const n=6;for(let i=0;i0){const o=new di(i.height);return o.fromEquirectangularTexture(e,n),t.set(n,o),n.addEventListener("dispose",a),r(o.texture,n.mapping)}return null}}}return n}(s)},dispose:function(){t=new WeakMap,n=new WeakMap,null!==i&&(i.dispose(),i=null)}}}function fi(e){const t={};function n(n){if(void 0!==t[n])return t[n];const i=e.getExtension(n);return t[n]=i,i}return{has:function(e){return null!==n(e)},init:function(){n("EXT_color_buffer_float"),n("WEBGL_clip_cull_distance"),n("OES_texture_float_linear"),n("EXT_color_buffer_half_float"),n("WEBGL_multisampled_render_to_texture"),n("WEBGL_render_shared_exponent")},get:function(e){const t=n(e);return null===t&&W("WebGLRenderer: "+e+" extension not supported."),t}}}function pi(e,t,n,i){const r={},a=new WeakMap;function o(e){const s=e.target;null!==s.index&&t.remove(s.index);for(const e in s.attributes)t.remove(s.attributes[e]);s.removeEventListener("dispose",o),delete r[s.id];const l=a.get(s);l&&(t.remove(l),a.delete(s)),i.releaseStatesOfGeometry(s),!0===s.isInstancedBufferGeometry&&delete s._maxInstanceCount,n.memory.geometries--}function s(e){const n=[],i=e.index,r=e.attributes.position;let o=0;if(void 0===r)return;if(null!==i){const e=i.array;o=i.version;for(let t=0,i=e.length;t=65535?z:k)(n,1);s.version=o;const l=a.get(e);l&&t.remove(l),a.set(e,s)}return{get:function(e,t){return!0===r[t.id]||(t.addEventListener("dispose",o),r[t.id]=!0,n.memory.geometries++),t},update:function(n){const i=n.attributes;for(const n in i)t.update(i[n],e.ARRAY_BUFFER)},getWireframeAttribute:function(e){const t=a.get(e);if(t){const n=e.index;null!==n&&t.versionn.maxTextureSize&&(M=Math.ceil(S/n.maxTextureSize),S=n.maxTextureSize);const x=new Float32Array(S*M*4*u),A=new X(x,S,M,u);A.type=T,A.needsUpdate=!0;const R=4*E;for(let C=0;C\n\t\t\t#include \n\n\t\t\tvoid main() {\n\t\t\t\tgl_FragColor = texture2D( tDiffuse, vUv );\n\n\t\t\t\t#ifdef LINEAR_TONE_MAPPING\n\t\t\t\t\tgl_FragColor.rgb = LinearToneMapping( gl_FragColor.rgb );\n\t\t\t\t#elif defined( REINHARD_TONE_MAPPING )\n\t\t\t\t\tgl_FragColor.rgb = ReinhardToneMapping( gl_FragColor.rgb );\n\t\t\t\t#elif defined( CINEON_TONE_MAPPING )\n\t\t\t\t\tgl_FragColor.rgb = CineonToneMapping( gl_FragColor.rgb );\n\t\t\t\t#elif defined( ACES_FILMIC_TONE_MAPPING )\n\t\t\t\t\tgl_FragColor.rgb = ACESFilmicToneMapping( gl_FragColor.rgb );\n\t\t\t\t#elif defined( AGX_TONE_MAPPING )\n\t\t\t\t\tgl_FragColor.rgb = AgXToneMapping( gl_FragColor.rgb );\n\t\t\t\t#elif defined( NEUTRAL_TONE_MAPPING )\n\t\t\t\t\tgl_FragColor.rgb = NeutralToneMapping( gl_FragColor.rgb );\n\t\t\t\t#elif defined( CUSTOM_TONE_MAPPING )\n\t\t\t\t\tgl_FragColor.rgb = CustomToneMapping( gl_FragColor.rgb );\n\t\t\t\t#endif\n\n\t\t\t\t#ifdef SRGB_TRANSFER\n\t\t\t\t\tgl_FragColor = sRGBTransferOETF( gl_FragColor );\n\t\t\t\t#endif\n\t\t\t}",depthTest:!1,depthWrite:!1}),d=new o(l,c),u=new C(-1,1,1,-1,0,1);let m,h=null,_=null,g=!1,v=null,S=[],T=!1;this.setSize=function(e,t){a.setSize(e,t),s.setSize(e,t);for(let n=0;n0&&!0===S[0].isRenderPass;const t=a.width,n=a.height;for(let e=0;e0)return e;const r=t*n;let a=Ri[r];if(void 0===a&&(a=new Float32Array(r),Ri[r]=a),0!==t){i.toArray(a,0);for(let i=1,r=0;i!==t;++i)r+=n,e[i].toArray(a,r)}return a}function Di(e,t){if(e.length!==t.length)return!1;for(let n=0,i=e.length;n0&&(this.seq=i.concat(r))}setValue(e,t,n,i){const r=this.map[t];void 0!==r&&r.setValue(e,n,i)}setOptional(e,t,n){const i=t[n];void 0!==i&&this.setValue(e,n,i)}static upload(e,t,n,i){for(let r=0,a=t.length;r!==a;++r){const a=t[r],o=n[a.id];!1!==o.needsUpdate&&a.setValue(e,o.value,i)}}static seqWithValue(e,t){const n=[];for(let i=0,r=e.length;i!==r;++i){const r=e[i];r.id in t&&n.push(r)}return n}}function Rr(e,t,n){const i=e.createShader(t);return e.shaderSource(i,n),e.compileShader(i),i}let br=0;const Cr=new e;function Pr(e,t,n){const i=e.getShaderParameter(t,e.COMPILE_STATUS),r=(e.getShaderInfoLog(t)||"").trim();if(i&&""===r)return"";const a=/ERROR: 0:(\d+)/.exec(r);if(a){const i=parseInt(a[1]);return n.toUpperCase()+"\n\n"+r+"\n\n"+function(e,t){const n=e.split("\n"),i=[],r=Math.max(t-6,0),a=Math.min(t+6,n.length);for(let e=r;e":" "} ${r}: ${n[e]}`)}return i.join("\n")}(e.getShaderSource(t),i)}return r}function Lr(e,t){const n=function(e){f._getMatrix(Cr,f.workingColorSpace,e);const t=`mat3( ${Cr.elements.map(e=>e.toFixed(4))} )`;switch(f.getTransfer(e)){case pe:return[t,"LinearTransferOETF"];case p:return[t,"sRGBTransferOETF"];default:return v("WebGLProgram: Unsupported color space: ",e),[t,"LinearTransferOETF"]}}(t);return[`vec4 ${e}( vec4 value ) {`,`\treturn ${n[1]}( vec4( value.rgb * ${n[0]}, value.a ) );`,"}"].join("\n")}const Ur={[ne]:"Linear",[te]:"Reinhard",[ee]:"Cineon",[J]:"ACESFilmic",[Q]:"AgX",[$]:"Neutral",[Z]:"Custom"};function Dr(e,t){const n=Ur[t];return void 0===n?(v("WebGLProgram: Unsupported toneMapping:",t),"vec3 "+e+"( vec3 color ) { return LinearToneMapping( color ); }"):"vec3 "+e+"( vec3 color ) { return "+n+"ToneMapping( color ); }"}const wr=new i;function Ir(){f.getLuminanceCoefficients(wr);return["float luminance( const in vec3 rgb ) {",`\tconst vec3 weights = vec3( ${wr.x.toFixed(4)}, ${wr.y.toFixed(4)}, ${wr.z.toFixed(4)} );`,"\treturn dot( weights, rgb );","}"].join("\n")}function Nr(e){return""!==e}function yr(e,t){const n=t.numSpotLightShadows+t.numSpotLightMaps-t.numSpotLightShadowsWithMaps;return e.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_SPOT_LIGHT_MAPS/g,t.numSpotLightMaps).replace(/NUM_SPOT_LIGHT_COORDS/g,n).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g,t.numSpotLightShadowsWithMaps).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Or(e,t){return e.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}const Fr=/^[ \t]*#include +<([\w\d./]+)>/gm;function Br(e){return e.replace(Fr,Hr)}const Gr=new Map;function Hr(e,t){let n=Bn[t];if(void 0===n){const e=Gr.get(t);if(void 0===e)throw new Error("Can not resolve #include <"+t+">");n=Bn[e],v('WebGLRenderer: Shader chunk "%s" has been deprecated. Use "%s" instead.',t,e)}return Br(n)}const Vr=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Wr(e){return e.replace(Vr,zr)}function zr(e,t,n,i){let r="";for(let e=parseInt(t);e0&&(_+="\n"),g=["#define SHADER_TYPE "+n.shaderType,"#define SHADER_NAME "+n.shaderName,m].filter(Nr).join("\n"),g.length>0&&(g+="\n")):(_=[kr(n),"#define SHADER_TYPE "+n.shaderType,"#define SHADER_NAME "+n.shaderName,m,n.extensionClipCullDistance?"#define USE_CLIP_DISTANCE":"",n.batching?"#define USE_BATCHING":"",n.batchingColor?"#define USE_BATCHING_COLOR":"",n.instancing?"#define USE_INSTANCING":"",n.instancingColor?"#define USE_INSTANCING_COLOR":"",n.instancingMorph?"#define USE_INSTANCING_MORPH":"",n.useFog&&n.fog?"#define USE_FOG":"",n.useFog&&n.fogExp2?"#define FOG_EXP2":"",n.map?"#define USE_MAP":"",n.envMap?"#define USE_ENVMAP":"",n.envMap?"#define "+d:"",n.lightMap?"#define USE_LIGHTMAP":"",n.aoMap?"#define USE_AOMAP":"",n.bumpMap?"#define USE_BUMPMAP":"",n.normalMap?"#define USE_NORMALMAP":"",n.normalMapObjectSpace?"#define USE_NORMALMAP_OBJECTSPACE":"",n.normalMapTangentSpace?"#define USE_NORMALMAP_TANGENTSPACE":"",n.displacementMap?"#define USE_DISPLACEMENTMAP":"",n.emissiveMap?"#define USE_EMISSIVEMAP":"",n.anisotropy?"#define USE_ANISOTROPY":"",n.anisotropyMap?"#define USE_ANISOTROPYMAP":"",n.clearcoatMap?"#define USE_CLEARCOATMAP":"",n.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",n.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",n.iridescenceMap?"#define USE_IRIDESCENCEMAP":"",n.iridescenceThicknessMap?"#define USE_IRIDESCENCE_THICKNESSMAP":"",n.specularMap?"#define USE_SPECULARMAP":"",n.specularColorMap?"#define USE_SPECULAR_COLORMAP":"",n.specularIntensityMap?"#define USE_SPECULAR_INTENSITYMAP":"",n.roughnessMap?"#define USE_ROUGHNESSMAP":"",n.metalnessMap?"#define USE_METALNESSMAP":"",n.alphaMap?"#define USE_ALPHAMAP":"",n.alphaHash?"#define USE_ALPHAHASH":"",n.transmission?"#define USE_TRANSMISSION":"",n.transmissionMap?"#define USE_TRANSMISSIONMAP":"",n.thicknessMap?"#define USE_THICKNESSMAP":"",n.sheenColorMap?"#define USE_SHEEN_COLORMAP":"",n.sheenRoughnessMap?"#define USE_SHEEN_ROUGHNESSMAP":"",n.mapUv?"#define MAP_UV "+n.mapUv:"",n.alphaMapUv?"#define ALPHAMAP_UV "+n.alphaMapUv:"",n.lightMapUv?"#define LIGHTMAP_UV "+n.lightMapUv:"",n.aoMapUv?"#define AOMAP_UV "+n.aoMapUv:"",n.emissiveMapUv?"#define EMISSIVEMAP_UV "+n.emissiveMapUv:"",n.bumpMapUv?"#define BUMPMAP_UV "+n.bumpMapUv:"",n.normalMapUv?"#define NORMALMAP_UV "+n.normalMapUv:"",n.displacementMapUv?"#define DISPLACEMENTMAP_UV "+n.displacementMapUv:"",n.metalnessMapUv?"#define METALNESSMAP_UV "+n.metalnessMapUv:"",n.roughnessMapUv?"#define ROUGHNESSMAP_UV "+n.roughnessMapUv:"",n.anisotropyMapUv?"#define ANISOTROPYMAP_UV "+n.anisotropyMapUv:"",n.clearcoatMapUv?"#define CLEARCOATMAP_UV "+n.clearcoatMapUv:"",n.clearcoatNormalMapUv?"#define CLEARCOAT_NORMALMAP_UV "+n.clearcoatNormalMapUv:"",n.clearcoatRoughnessMapUv?"#define CLEARCOAT_ROUGHNESSMAP_UV "+n.clearcoatRoughnessMapUv:"",n.iridescenceMapUv?"#define IRIDESCENCEMAP_UV "+n.iridescenceMapUv:"",n.iridescenceThicknessMapUv?"#define IRIDESCENCE_THICKNESSMAP_UV "+n.iridescenceThicknessMapUv:"",n.sheenColorMapUv?"#define SHEEN_COLORMAP_UV "+n.sheenColorMapUv:"",n.sheenRoughnessMapUv?"#define SHEEN_ROUGHNESSMAP_UV "+n.sheenRoughnessMapUv:"",n.specularMapUv?"#define SPECULARMAP_UV "+n.specularMapUv:"",n.specularColorMapUv?"#define SPECULAR_COLORMAP_UV "+n.specularColorMapUv:"",n.specularIntensityMapUv?"#define SPECULAR_INTENSITYMAP_UV "+n.specularIntensityMapUv:"",n.transmissionMapUv?"#define TRANSMISSIONMAP_UV "+n.transmissionMapUv:"",n.thicknessMapUv?"#define THICKNESSMAP_UV "+n.thicknessMapUv:"",n.vertexTangents&&!1===n.flatShading?"#define USE_TANGENT":"",n.vertexNormals?"#define HAS_NORMAL":"",n.vertexColors?"#define USE_COLOR":"",n.vertexAlphas?"#define USE_COLOR_ALPHA":"",n.vertexUv1s?"#define USE_UV1":"",n.vertexUv2s?"#define USE_UV2":"",n.vertexUv3s?"#define USE_UV3":"",n.pointsUvs?"#define USE_POINTS_UV":"",n.flatShading?"#define FLAT_SHADED":"",n.skinning?"#define USE_SKINNING":"",n.morphTargets?"#define USE_MORPHTARGETS":"",n.morphNormals&&!1===n.flatShading?"#define USE_MORPHNORMALS":"",n.morphColors?"#define USE_MORPHCOLORS":"",n.morphTargetsCount>0?"#define MORPHTARGETS_TEXTURE_STRIDE "+n.morphTextureStride:"",n.morphTargetsCount>0?"#define MORPHTARGETS_COUNT "+n.morphTargetsCount:"",n.doubleSided?"#define DOUBLE_SIDED":"",n.flipSided?"#define FLIP_SIDED":"",n.shadowMapEnabled?"#define USE_SHADOWMAP":"",n.shadowMapEnabled?"#define "+l:"",n.sizeAttenuation?"#define USE_SIZEATTENUATION":"",n.numLightProbes>0?"#define USE_LIGHT_PROBES":"",n.logarithmicDepthBuffer?"#define USE_LOGARITHMIC_DEPTH_BUFFER":"",n.reversedDepthBuffer?"#define USE_REVERSED_DEPTH_BUFFER":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","#ifdef USE_INSTANCING_MORPH","\tuniform sampler2D morphTexture;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_UV1","\tattribute vec2 uv1;","#endif","#ifdef USE_UV2","\tattribute vec2 uv2;","#endif","#ifdef USE_UV3","\tattribute vec2 uv3;","#endif","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","\tattribute vec4 color;","#elif defined( USE_COLOR )","\tattribute vec3 color;","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(Nr).join("\n"),g=[kr(n),"#define SHADER_TYPE "+n.shaderType,"#define SHADER_NAME "+n.shaderName,m,n.useFog&&n.fog?"#define USE_FOG":"",n.useFog&&n.fogExp2?"#define FOG_EXP2":"",n.alphaToCoverage?"#define ALPHA_TO_COVERAGE":"",n.map?"#define USE_MAP":"",n.matcap?"#define USE_MATCAP":"",n.envMap?"#define USE_ENVMAP":"",n.envMap?"#define "+c:"",n.envMap?"#define "+d:"",n.envMap?"#define "+u:"",f?"#define CUBEUV_TEXEL_WIDTH "+f.texelWidth:"",f?"#define CUBEUV_TEXEL_HEIGHT "+f.texelHeight:"",f?"#define CUBEUV_MAX_MIP "+f.maxMip+".0":"",n.lightMap?"#define USE_LIGHTMAP":"",n.aoMap?"#define USE_AOMAP":"",n.bumpMap?"#define USE_BUMPMAP":"",n.normalMap?"#define USE_NORMALMAP":"",n.normalMapObjectSpace?"#define USE_NORMALMAP_OBJECTSPACE":"",n.normalMapTangentSpace?"#define USE_NORMALMAP_TANGENTSPACE":"",n.packedNormalMap?"#define USE_PACKED_NORMALMAP":"",n.emissiveMap?"#define USE_EMISSIVEMAP":"",n.anisotropy?"#define USE_ANISOTROPY":"",n.anisotropyMap?"#define USE_ANISOTROPYMAP":"",n.clearcoat?"#define USE_CLEARCOAT":"",n.clearcoatMap?"#define USE_CLEARCOATMAP":"",n.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",n.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",n.dispersion?"#define USE_DISPERSION":"",n.iridescence?"#define USE_IRIDESCENCE":"",n.iridescenceMap?"#define USE_IRIDESCENCEMAP":"",n.iridescenceThicknessMap?"#define USE_IRIDESCENCE_THICKNESSMAP":"",n.specularMap?"#define USE_SPECULARMAP":"",n.specularColorMap?"#define USE_SPECULAR_COLORMAP":"",n.specularIntensityMap?"#define USE_SPECULAR_INTENSITYMAP":"",n.roughnessMap?"#define USE_ROUGHNESSMAP":"",n.metalnessMap?"#define USE_METALNESSMAP":"",n.alphaMap?"#define USE_ALPHAMAP":"",n.alphaTest?"#define USE_ALPHATEST":"",n.alphaHash?"#define USE_ALPHAHASH":"",n.sheen?"#define USE_SHEEN":"",n.sheenColorMap?"#define USE_SHEEN_COLORMAP":"",n.sheenRoughnessMap?"#define USE_SHEEN_ROUGHNESSMAP":"",n.transmission?"#define USE_TRANSMISSION":"",n.transmissionMap?"#define USE_TRANSMISSIONMAP":"",n.thicknessMap?"#define USE_THICKNESSMAP":"",n.vertexTangents&&!1===n.flatShading?"#define USE_TANGENT":"",n.vertexColors||n.instancingColor?"#define USE_COLOR":"",n.vertexAlphas||n.batchingColor?"#define USE_COLOR_ALPHA":"",n.vertexUv1s?"#define USE_UV1":"",n.vertexUv2s?"#define USE_UV2":"",n.vertexUv3s?"#define USE_UV3":"",n.pointsUvs?"#define USE_POINTS_UV":"",n.gradientMap?"#define USE_GRADIENTMAP":"",n.flatShading?"#define FLAT_SHADED":"",n.doubleSided?"#define DOUBLE_SIDED":"",n.flipSided?"#define FLIP_SIDED":"",n.shadowMapEnabled?"#define USE_SHADOWMAP":"",n.shadowMapEnabled?"#define "+l:"",n.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",n.numLightProbes>0?"#define USE_LIGHT_PROBES":"",n.numLightProbeGrids>0?"#define USE_LIGHT_PROBES_GRID":"",n.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",n.decodeVideoTextureEmissive?"#define DECODE_VIDEO_TEXTURE_EMISSIVE":"",n.logarithmicDepthBuffer?"#define USE_LOGARITHMIC_DEPTH_BUFFER":"",n.reversedDepthBuffer?"#define USE_REVERSED_DEPTH_BUFFER":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",n.toneMapping!==L?"#define TONE_MAPPING":"",n.toneMapping!==L?Bn.tonemapping_pars_fragment:"",n.toneMapping!==L?Dr("toneMapping",n.toneMapping):"",n.dithering?"#define DITHERING":"",n.opaque?"#define OPAQUE":"",Bn.colorspace_pars_fragment,Lr("linearToOutputTexel",n.outputColorSpace),Ir(),n.useDepthPacking?"#define DEPTH_PACKING "+n.depthPacking:"","\n"].filter(Nr).join("\n")),o=Br(o),o=yr(o,n),o=Or(o,n),s=Br(s),s=yr(s,n),s=Or(s,n),o=Wr(o),s=Wr(s),!0!==n.isRawShaderMaterial&&(E="#version 300 es\n",_=[p,"#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+_,g=["#define varying in",n.glslVersion===se?"":"layout(location = 0) out highp vec4 pc_fragColor;",n.glslVersion===se?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+g);const S=E+_+o,T=E+g+s,M=Rr(r,r.VERTEX_SHADER,S),x=Rr(r,r.FRAGMENT_SHADER,T);function A(t){if(e.debug.checkShaderErrors){const n=r.getProgramInfoLog(h)||"",i=r.getShaderInfoLog(M)||"",a=r.getShaderInfoLog(x)||"",o=n.trim(),s=i.trim(),l=a.trim();let c=!0,d=!0;if(!1===r.getProgramParameter(h,r.LINK_STATUS))if(c=!1,"function"==typeof e.debug.onShaderError)e.debug.onShaderError(r,h,M,x);else{const e=Pr(r,M,"vertex"),n=Pr(r,x,"fragment");D("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(h,r.VALIDATE_STATUS)+"\n\nMaterial Name: "+t.name+"\nMaterial Type: "+t.type+"\n\nProgram Info Log: "+o+"\n"+e+"\n"+n)}else""!==o?v("WebGLProgram: Program Info Log:",o):""!==s&&""!==l||(d=!1);d&&(t.diagnostics={runnable:c,programLog:o,vertexShader:{log:s,prefix:_},fragmentShader:{log:l,prefix:g}})}r.deleteShader(M),r.deleteShader(x),R=new Ar(r,h),b=function(e,t){const n={},i=e.getProgramParameter(t,e.ACTIVE_ATTRIBUTES);for(let r=0;r0,J=r.clearcoat>0,ee=r.dispersion>0,te=r.iridescence>0,ne=r.sheen>0,ie=r.transmission>0,re=Q&&!!r.anisotropyMap,ae=J&&!!r.clearcoatMap,oe=J&&!!r.clearcoatNormalMap,se=J&&!!r.clearcoatRoughnessMap,le=te&&!!r.iridescenceMap,ce=te&&!!r.iridescenceThicknessMap,de=ne&&!!r.sheenColorMap,ue=ne&&!!r.sheenRoughnessMap,fe=!!r.specularMap,pe=!!r.specularColorMap,me=!!r.specularIntensityMap,Ee=ie&&!!r.transmissionMap,xe=ie&&!!r.thicknessMap,Ae=!!r.gradientMap,Re=!!r.alphaMap,be=r.alphaTest>0,Ce=!!r.alphaHash,Pe=!!r.extensions;let Le=L;r.toneMapped&&(null!==F&&!0!==F.isXRRenderTarget||(Le=e.toneMapping));const Ue={shaderID:P,shaderType:r.type,shaderName:r.name,vertexShader:w,fragmentShader:I,defines:r.defines,customVertexShaderID:N,customFragmentShaderID:y,isRawShaderMaterial:!0===r.isRawShaderMaterial,glslVersion:r.glslVersion,precision:_,batching:H,batchingColor:H&&null!==S._colorsTexture,instancing:G,instancingColor:G&&null!==S.instanceColor,instancingMorph:G&&null!==S.morphTexture,outputColorSpace:null===F?e.outputColorSpace:!0===F.isXRRenderTarget?F.texture.colorSpace:f.workingColorSpace,alphaToCoverage:!!r.alphaToCoverage,map:V,matcap:W,envMap:z,envMapMode:z&&b.mapping,envMapCubeUVHeight:C,aoMap:k,lightMap:X,bumpMap:K,normalMap:Y,displacementMap:q,emissiveMap:j,normalMapObjectSpace:Y&&r.normalMapType===ve,normalMapTangentSpace:Y&&r.normalMapType===ge,packedNormalMap:Y&&r.normalMapType===ge&&(De=r.normalMap.format,De===Se||De===Te||De===Me),metalnessMap:Z,roughnessMap:$,anisotropy:Q,anisotropyMap:re,clearcoat:J,clearcoatMap:ae,clearcoatNormalMap:oe,clearcoatRoughnessMap:se,dispersion:ee,iridescence:te,iridescenceMap:le,iridescenceThicknessMap:ce,sheen:ne,sheenColorMap:de,sheenRoughnessMap:ue,specularMap:fe,specularColorMap:pe,specularIntensityMap:me,transmission:ie,transmissionMap:Ee,thicknessMap:xe,gradientMap:Ae,opaque:!1===r.transparent&&r.blending===_e&&!1===r.alphaToCoverage,alphaMap:Re,alphaTest:be,alphaHash:Ce,combine:r.combine,mapUv:V&&E(r.map.channel),aoMapUv:k&&E(r.aoMap.channel),lightMapUv:X&&E(r.lightMap.channel),bumpMapUv:K&&E(r.bumpMap.channel),normalMapUv:Y&&E(r.normalMap.channel),displacementMapUv:q&&E(r.displacementMap.channel),emissiveMapUv:j&&E(r.emissiveMap.channel),metalnessMapUv:Z&&E(r.metalnessMap.channel),roughnessMapUv:$&&E(r.roughnessMap.channel),anisotropyMapUv:re&&E(r.anisotropyMap.channel),clearcoatMapUv:ae&&E(r.clearcoatMap.channel),clearcoatNormalMapUv:oe&&E(r.clearcoatNormalMap.channel),clearcoatRoughnessMapUv:se&&E(r.clearcoatRoughnessMap.channel),iridescenceMapUv:le&&E(r.iridescenceMap.channel),iridescenceThicknessMapUv:ce&&E(r.iridescenceThicknessMap.channel),sheenColorMapUv:de&&E(r.sheenColorMap.channel),sheenRoughnessMapUv:ue&&E(r.sheenRoughnessMap.channel),specularMapUv:fe&&E(r.specularMap.channel),specularColorMapUv:pe&&E(r.specularColorMap.channel),specularIntensityMapUv:me&&E(r.specularIntensityMap.channel),transmissionMapUv:Ee&&E(r.transmissionMap.channel),thicknessMapUv:xe&&E(r.thicknessMap.channel),alphaMapUv:Re&&E(r.alphaMap.channel),vertexTangents:!!x.attributes.tangent&&(Y||Q),vertexNormals:!!x.attributes.normal,vertexColors:r.vertexColors,vertexAlphas:!0===r.vertexColors&&!!x.attributes.color&&4===x.attributes.color.itemSize,pointsUvs:!0===S.isPoints&&!!x.attributes.uv&&(V||Re),fog:!!M,useFog:!0===r.fog,fogExp2:!!M&&M.isFogExp2,flatShading:!1===r.wireframe&&(!0===r.flatShading||void 0===x.attributes.normal&&!1===Y&&(r.isMeshLambertMaterial||r.isMeshPhongMaterial||r.isMeshStandardMaterial||r.isMeshPhysicalMaterial)),sizeAttenuation:!0===r.sizeAttenuation,logarithmicDepthBuffer:h,reversedDepthBuffer:B,skinning:!0===S.isSkinnedMesh,morphTargets:void 0!==x.morphAttributes.position,morphNormals:void 0!==x.morphAttributes.normal,morphColors:void 0!==x.morphAttributes.color,morphTargetsCount:D,morphTextureStride:O,numDirLights:s.directional.length,numPointLights:s.point.length,numSpotLights:s.spot.length,numSpotLightMaps:s.spotLightMap.length,numRectAreaLights:s.rectArea.length,numHemiLights:s.hemi.length,numDirLightShadows:s.directionalShadowMap.length,numPointLightShadows:s.pointShadowMap.length,numSpotLightShadows:s.spotShadowMap.length,numSpotLightShadowsWithMaps:s.numSpotLightShadowsWithMaps,numLightProbes:s.numLightProbes,numLightProbeGrids:T.length,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:r.dithering,shadowMapEnabled:e.shadowMap.enabled&&u.length>0,shadowMapType:e.shadowMap.type,toneMapping:Le,decodeVideoTexture:V&&!0===r.map.isVideoTexture&&f.getTransfer(r.map.colorSpace)===p,decodeVideoTextureEmissive:j&&!0===r.emissiveMap.isVideoTexture&&f.getTransfer(r.emissiveMap.colorSpace)===p,premultipliedAlpha:r.premultipliedAlpha,doubleSided:r.side===he,flipSided:r.side===c,useDepthPacking:r.depthPacking>=0,depthPacking:r.depthPacking||0,index0AttributeName:r.index0AttributeName,extensionClipCullDistance:Pe&&!0===r.extensions.clipCullDistance&&n.has("WEBGL_clip_cull_distance"),extensionMultiDraw:(Pe&&!0===r.extensions.multiDraw||H)&&n.has("WEBGL_multi_draw"),rendererExtensionParallelShaderCompile:n.has("KHR_parallel_shader_compile"),customProgramCacheKey:r.customProgramCacheKey()};var De;return Ue.vertexUv1s=d.has(1),Ue.vertexUv2s=d.has(2),Ue.vertexUv3s=d.has(3),d.clear(),Ue},getProgramCacheKey:function(t){const n=[];if(t.shaderID?n.push(t.shaderID):(n.push(t.customVertexShaderID),n.push(t.customFragmentShaderID)),void 0!==t.defines)for(const e in t.defines)n.push(e),n.push(t.defines[e]);return!1===t.isRawShaderMaterial&&(!function(e,t){e.push(t.precision),e.push(t.outputColorSpace),e.push(t.envMapMode),e.push(t.envMapCubeUVHeight),e.push(t.mapUv),e.push(t.alphaMapUv),e.push(t.lightMapUv),e.push(t.aoMapUv),e.push(t.bumpMapUv),e.push(t.normalMapUv),e.push(t.displacementMapUv),e.push(t.emissiveMapUv),e.push(t.metalnessMapUv),e.push(t.roughnessMapUv),e.push(t.anisotropyMapUv),e.push(t.clearcoatMapUv),e.push(t.clearcoatNormalMapUv),e.push(t.clearcoatRoughnessMapUv),e.push(t.iridescenceMapUv),e.push(t.iridescenceThicknessMapUv),e.push(t.sheenColorMapUv),e.push(t.sheenRoughnessMapUv),e.push(t.specularMapUv),e.push(t.specularColorMapUv),e.push(t.specularIntensityMapUv),e.push(t.transmissionMapUv),e.push(t.thicknessMapUv),e.push(t.combine),e.push(t.fogExp2),e.push(t.sizeAttenuation),e.push(t.morphTargetsCount),e.push(t.morphAttributeCount),e.push(t.numDirLights),e.push(t.numPointLights),e.push(t.numSpotLights),e.push(t.numSpotLightMaps),e.push(t.numHemiLights),e.push(t.numRectAreaLights),e.push(t.numDirLightShadows),e.push(t.numPointLightShadows),e.push(t.numSpotLightShadows),e.push(t.numSpotLightShadowsWithMaps),e.push(t.numLightProbes),e.push(t.shadowMapType),e.push(t.toneMapping),e.push(t.numClippingPlanes),e.push(t.numClipIntersection),e.push(t.depthPacking)}(n,t),function(e,t){s.disableAll(),t.instancing&&s.enable(0);t.instancingColor&&s.enable(1);t.instancingMorph&&s.enable(2);t.matcap&&s.enable(3);t.envMap&&s.enable(4);t.normalMapObjectSpace&&s.enable(5);t.normalMapTangentSpace&&s.enable(6);t.clearcoat&&s.enable(7);t.iridescence&&s.enable(8);t.alphaTest&&s.enable(9);t.vertexColors&&s.enable(10);t.vertexAlphas&&s.enable(11);t.vertexUv1s&&s.enable(12);t.vertexUv2s&&s.enable(13);t.vertexUv3s&&s.enable(14);t.vertexTangents&&s.enable(15);t.anisotropy&&s.enable(16);t.alphaHash&&s.enable(17);t.batching&&s.enable(18);t.dispersion&&s.enable(19);t.batchingColor&&s.enable(20);t.gradientMap&&s.enable(21);t.packedNormalMap&&s.enable(22);t.vertexNormals&&s.enable(23);e.push(s.mask),s.disableAll(),t.fog&&s.enable(0);t.useFog&&s.enable(1);t.flatShading&&s.enable(2);t.logarithmicDepthBuffer&&s.enable(3);t.reversedDepthBuffer&&s.enable(4);t.skinning&&s.enable(5);t.morphTargets&&s.enable(6);t.morphNormals&&s.enable(7);t.morphColors&&s.enable(8);t.premultipliedAlpha&&s.enable(9);t.shadowMapEnabled&&s.enable(10);t.doubleSided&&s.enable(11);t.flipSided&&s.enable(12);t.useDepthPacking&&s.enable(13);t.dithering&&s.enable(14);t.transmission&&s.enable(15);t.sheen&&s.enable(16);t.opaque&&s.enable(17);t.pointsUvs&&s.enable(18);t.decodeVideoTexture&&s.enable(19);t.decodeVideoTextureEmissive&&s.enable(20);t.alphaToCoverage&&s.enable(21);t.numLightProbeGrids>0&&s.enable(22);e.push(s.mask)}(n,t),n.push(e.outputColorSpace)),n.push(t.customProgramCacheKey),n.join()},getUniforms:function(e){const t=g[e.type];let n;if(t){const e=Hn[t];n=me.clone(e.uniforms)}else n=e.uniforms;return n},acquireProgram:function(t,n){let i=m.get(n);return void 0!==i?++i.usedTimes:(i=new jr(e,n,t,r),u.push(i),m.set(n,i)),i},releaseProgram:function(e){if(0===--e.usedTimes){const t=u.indexOf(e);u[t]=u[u.length-1],u.pop(),m.delete(e.cacheKey),e.destroy()}},releaseShaderCache:function(e){l.remove(e)},programs:u,dispose:function(){l.dispose()}}}function ea(){let e=new WeakMap;return{has:function(t){return e.has(t)},get:function(t){let n=e.get(t);return void 0===n&&(n={},e.set(t,n)),n},remove:function(t){e.delete(t)},update:function(t,n,i){e.get(t)[n]=i},dispose:function(){e=new WeakMap}}}function ta(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.material.id!==t.material.id?e.material.id-t.material.id:e.materialVariant!==t.materialVariant?e.materialVariant-t.materialVariant:e.z!==t.z?e.z-t.z:e.id-t.id}function na(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.z!==t.z?t.z-e.z:e.id-t.id}function ia(){const e=[];let t=0;const n=[],i=[],r=[];function a(e){let t=0;return e.isInstancedMesh&&(t+=2),e.isSkinnedMesh&&(t+=1),t}function o(n,i,r,o,s,l){let c=e[t];return void 0===c?(c={id:n.id,object:n,geometry:i,material:r,materialVariant:a(n),groupOrder:o,renderOrder:n.renderOrder,z:s,group:l},e[t]=c):(c.id=n.id,c.object=n,c.geometry=i,c.material=r,c.materialVariant=a(n),c.groupOrder=o,c.renderOrder=n.renderOrder,c.z=s,c.group=l),t++,c}return{opaque:n,transmissive:i,transparent:r,init:function(){t=0,n.length=0,i.length=0,r.length=0},push:function(e,t,a,s,l,c){const d=o(e,t,a,s,l,c);a.transmission>0?i.push(d):!0===a.transparent?r.push(d):n.push(d)},unshift:function(e,t,a,s,l,c){const d=o(e,t,a,s,l,c);a.transmission>0?i.unshift(d):!0===a.transparent?r.unshift(d):n.unshift(d)},finish:function(){for(let n=t,i=e.length;n1&&n.sort(e||ta),i.length>1&&i.sort(t||na),r.length>1&&r.sort(t||na)}}}function ra(){let e=new WeakMap;return{get:function(t,n){const i=e.get(t);let r;return void 0===i?(r=new ia,e.set(t,[r])):n>=i.length?(r=new ia,i.push(r)):r=i[n],r},dispose:function(){e=new WeakMap}}}function aa(){const e={};return{get:function(t){if(void 0!==e[t.id])return e[t.id];let r;switch(t.type){case"DirectionalLight":r={direction:new i,color:new n};break;case"SpotLight":r={position:new i,direction:new i,color:new n,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":r={position:new i,color:new n,distance:0,decay:0};break;case"HemisphereLight":r={direction:new i,skyColor:new n,groundColor:new n};break;case"RectAreaLight":r={color:new n,position:new i,halfWidth:new i,halfHeight:new i}}return e[t.id]=r,r}}}let oa=0;function sa(e,t){return(t.castShadow?2:0)-(e.castShadow?2:0)+(t.map?1:0)-(e.map?1:0)}function la(e){const n=new aa,r=function(){const e={};return{get:function(n){if(void 0!==e[n.id])return e[n.id];let i;switch(n.type){case"DirectionalLight":case"SpotLight":i={shadowIntensity:1,shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new t};break;case"PointLight":i={shadowIntensity:1,shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new t,shadowCameraNear:1,shadowCameraFar:1e3}}return e[n.id]=i,i}}}(),a={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1,numSpotMaps:-1,numLightProbes:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotLightMap:[],spotShadow:[],spotShadowMap:[],spotLightMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[],numSpotLightShadowsWithMaps:0,numLightProbes:0};for(let e=0;e<9;e++)a.probe.push(new i);const o=new i,s=new u,l=new u;return{setup:function(t){let i=0,o=0,s=0;for(let e=0;e<9;e++)a.probe[e].set(0,0,0);let l=0,c=0,d=0,u=0,f=0,p=0,m=0,h=0,_=0,g=0,v=0;t.sort(sa);for(let e=0,E=t.length;e0&&(!0===e.has("OES_texture_float_linear")?(a.rectAreaLTC1=Gn.LTC_FLOAT_1,a.rectAreaLTC2=Gn.LTC_FLOAT_2):(a.rectAreaLTC1=Gn.LTC_HALF_1,a.rectAreaLTC2=Gn.LTC_HALF_2)),a.ambient[0]=i,a.ambient[1]=o,a.ambient[2]=s;const E=a.hash;E.directionalLength===l&&E.pointLength===c&&E.spotLength===d&&E.rectAreaLength===u&&E.hemiLength===f&&E.numDirectionalShadows===p&&E.numPointShadows===m&&E.numSpotShadows===h&&E.numSpotMaps===_&&E.numLightProbes===v||(a.directional.length=l,a.spot.length=d,a.rectArea.length=u,a.point.length=c,a.hemi.length=f,a.directionalShadow.length=p,a.directionalShadowMap.length=p,a.pointShadow.length=m,a.pointShadowMap.length=m,a.spotShadow.length=h,a.spotShadowMap.length=h,a.directionalShadowMatrix.length=p,a.pointShadowMatrix.length=m,a.spotLightMatrix.length=h+_-g,a.spotLightMap.length=_,a.numSpotLightShadowsWithMaps=g,a.numLightProbes=v,E.directionalLength=l,E.pointLength=c,E.spotLength=d,E.rectAreaLength=u,E.hemiLength=f,E.numDirectionalShadows=p,E.numPointShadows=m,E.numSpotShadows=h,E.numSpotMaps=_,E.numLightProbes=v,a.version=oa++)},setupView:function(e,t){let n=0,i=0,r=0,c=0,d=0;const u=t.matrixWorldInverse;for(let t=0,f=e.length;t=r.length?(a=new ca(e),r.push(a)):a=r[i],a},dispose:function(){t=new WeakMap}}}const ua=[new i(1,0,0),new i(-1,0,0),new i(0,1,0),new i(0,-1,0),new i(0,0,1),new i(0,0,-1)],fa=[new i(0,-1,0),new i(0,-1,0),new i(0,0,1),new i(0,0,-1),new i(0,-1,0),new i(0,-1,0)],pa=new u,ma=new i,ha=new i;function _a(e,n,i){let r=new Ue;const a=new t,s=new t,d=new K,u=new xe,f=new Ae,p={},m=i.maxTextureSize,_={[h]:c,[c]:h,[he]:he},g=new l({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new t},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ).rg;\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ).r;\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( max( 0.0, squared_mean - mean * mean ) );\n\tgl_FragColor = vec4( mean, std_dev, 0.0, 1.0 );\n}"}),S=g.clone();S.defines.HORIZONTAL_PASS=1;const M=new b;M.setAttribute("position",new N(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));const x=new o(M,g),A=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=ce;let R=this.type;function C(t,i){const r=n.update(x);g.defines.VSM_SAMPLES!==t.blurSamples&&(g.defines.VSM_SAMPLES=t.blurSamples,S.defines.VSM_SAMPLES=t.blurSamples,g.needsUpdate=!0,S.needsUpdate=!0),null===t.mapPass&&(t.mapPass=new I(a.x,a.y,{format:Se,type:E})),g.uniforms.shadow_pass.value=t.map.depthTexture,g.uniforms.resolution.value=t.mapSize,g.uniforms.radius.value=t.radius,e.setRenderTarget(t.mapPass),e.clear(),e.renderBufferDirect(i,null,r,g,x,null),S.uniforms.shadow_pass.value=t.mapPass.texture,S.uniforms.resolution.value=t.mapSize,S.uniforms.radius.value=t.radius,e.setRenderTarget(t.map),e.clear(),e.renderBufferDirect(i,null,r,S,x,null)}function P(t,n,i,r){let a=null;const o=!0===i.isPointLight?t.customDistanceMaterial:t.customDepthMaterial;if(void 0!==o)a=o;else if(a=!0===i.isPointLight?f:u,e.localClippingEnabled&&!0===n.clipShadows&&Array.isArray(n.clippingPlanes)&&0!==n.clippingPlanes.length||n.displacementMap&&0!==n.displacementScale||n.alphaMap&&n.alphaTest>0||n.map&&n.alphaTest>0||!0===n.alphaToCoverage){const e=a.uuid,t=n.uuid;let i=p[e];void 0===i&&(i={},p[e]=i);let r=i[t];void 0===r&&(r=a.clone(),i[t]=r,n.addEventListener("dispose",U)),a=r}if(a.visible=n.visible,a.wireframe=n.wireframe,a.side=r===le?null!==n.shadowSide?n.shadowSide:n.side:null!==n.shadowSide?n.shadowSide:_[n.side],a.alphaMap=n.alphaMap,a.alphaTest=!0===n.alphaToCoverage?.5:n.alphaTest,a.map=n.map,a.clipShadows=n.clipShadows,a.clippingPlanes=n.clippingPlanes,a.clipIntersection=n.clipIntersection,a.displacementMap=n.displacementMap,a.displacementScale=n.displacementScale,a.displacementBias=n.displacementBias,a.wireframeLinewidth=n.wireframeLinewidth,a.linewidth=n.linewidth,!0===i.isPointLight&&!0===a.isMeshDistanceMaterial){e.properties.get(a).light=i}return a}function L(t,i,a,o,s){if(!1===t.visible)return;if(t.layers.test(i.layers)&&(t.isMesh||t.isLine||t.isPoints)&&(t.castShadow||t.receiveShadow&&s===le)&&(!t.frustumCulled||r.intersectsObject(t))){t.modelViewMatrix.multiplyMatrices(a.matrixWorldInverse,t.matrixWorld);const r=n.update(t),l=t.material;if(Array.isArray(l)){const n=r.groups;for(let c=0,d=n.length;ce.needsUpdate=!0):e.material.needsUpdate=!0)});for(let o=0,l=t.length;om||a.y>m)&&(a.x>m&&(s.x=Math.floor(m/p.x),a.x=s.x*p.x,c.mapSize.x=s.x),a.y>m&&(s.y=Math.floor(m/p.y),a.y=s.y*p.y,c.mapSize.y=s.y));const h=e.state.buffers.depth.getReversed();if(c.camera._reversedDepth=h,null===c.map||!0===f){if(null!==c.map&&(null!==c.map.depthTexture&&(c.map.depthTexture.dispose(),c.map.depthTexture=null),c.map.dispose()),this.type===le){if(l.isPointLight){v("WebGLShadowMap: VSM shadow maps are not supported for PointLights. Use PCF or BasicShadowMap instead.");continue}c.map=new I(a.x,a.y,{format:Se,type:E,minFilter:O,magFilter:O,generateMipmaps:!1}),c.map.texture.name=l.name+".shadowMap",c.map.depthTexture=new Y(a.x,a.y,T),c.map.depthTexture.name=l.name+".shadowMapDepth",c.map.depthTexture.format=be,c.map.depthTexture.compareFunction=null,c.map.depthTexture.minFilter=Ce,c.map.depthTexture.magFilter=Ce}else l.isPointLight?(c.map=new di(a.x),c.map.depthTexture=new Pe(a.x,Le)):(c.map=new I(a.x,a.y),c.map.depthTexture=new Y(a.x,a.y,Le)),c.map.depthTexture.name=l.name+".shadowMap",c.map.depthTexture.format=be,this.type===ce?(c.map.depthTexture.compareFunction=h?re:ae,c.map.depthTexture.minFilter=O,c.map.depthTexture.magFilter=O):(c.map.depthTexture.compareFunction=null,c.map.depthTexture.minFilter=Ce,c.map.depthTexture.magFilter=Ce);c.camera.updateProjectionMatrix()}const _=c.map.isWebGLCubeRenderTarget?6:1;for(let t=0;t<_;t++){if(c.map.isWebGLCubeRenderTarget)e.setRenderTarget(c.map,t),e.clear();else{0===t&&(e.setRenderTarget(c.map),e.clear());const n=c.getViewport(t);d.set(s.x*n.x,s.y*n.y,s.x*n.z,s.y*n.w),u.viewport(d)}if(l.isPointLight){const e=c.camera,n=c.matrix,i=l.distance||e.far;i!==e.far&&(e.far=i,e.updateProjectionMatrix()),ma.setFromMatrixPosition(l.matrixWorld),e.position.copy(ma),ha.copy(e.position),ha.add(ua[t]),e.up.copy(fa[t]),e.lookAt(ha),e.updateMatrixWorld(),n.makeTranslation(-ma.x,-ma.y,-ma.z),pa.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),c._frustum.setFromProjectionMatrix(pa,e.coordinateSystem,e.reversedDepth)}else c.updateMatrices(l);r=c.getFrustum(),L(n,i,c.camera,l,this.type)}!0!==c.isPointLightShadow&&this.type===le&&C(c,i),c.needsUpdate=!1}R=this.type,A.needsUpdate=!1,e.setRenderTarget(o,l,c)}}function ga(e,t){const i=new function(){let t=!1;const n=new K;let i=null;const r=new K(0,0,0,0);return{setMask:function(n){i===n||t||(e.colorMask(n,n,n,n),i=n)},setLocked:function(e){t=e},setClear:function(t,i,a,o,s){!0===s&&(t*=o,i*=o,a*=o),n.set(t,i,a,o),!1===r.equals(n)&&(e.clearColor(t,i,a,o),r.copy(n))},reset:function(){t=!1,i=null,r.set(-1,0,0,0)}}},r=new function(){let n=!1,i=!1,r=null,a=null,o=null;return{setReversed:function(e){if(i!==e){const n=t.get("EXT_clip_control");e?n.clipControlEXT(n.LOWER_LEFT_EXT,n.ZERO_TO_ONE_EXT):n.clipControlEXT(n.LOWER_LEFT_EXT,n.NEGATIVE_ONE_TO_ONE_EXT),i=e;const r=o;o=null,this.setClear(r)}},getReversed:function(){return i},setTest:function(t){t?X(e.DEPTH_TEST):Y(e.DEPTH_TEST)},setMask:function(t){r===t||n||(e.depthMask(t),r=t)},setFunc:function(t){if(i&&(t=dt[t]),a!==t){switch(t){case nt:e.depthFunc(e.NEVER);break;case tt:e.depthFunc(e.ALWAYS);break;case et:e.depthFunc(e.LESS);break;case De:e.depthFunc(e.LEQUAL);break;case Je:e.depthFunc(e.EQUAL);break;case Qe:e.depthFunc(e.GEQUAL);break;case $e:e.depthFunc(e.GREATER);break;case Ze:e.depthFunc(e.NOTEQUAL);break;default:e.depthFunc(e.LEQUAL)}a=t}},setLocked:function(e){n=e},setClear:function(t){o!==t&&(o=t,i&&(t=1-t),e.clearDepth(t))},reset:function(){n=!1,r=null,a=null,o=null,i=!1}}},a=new function(){let t=!1,n=null,i=null,r=null,a=null,o=null,s=null,l=null,c=null;return{setTest:function(n){t||(n?X(e.STENCIL_TEST):Y(e.STENCIL_TEST))},setMask:function(i){n===i||t||(e.stencilMask(i),n=i)},setFunc:function(t,n,o){i===t&&r===n&&a===o||(e.stencilFunc(t,n,o),i=t,r=n,a=o)},setOp:function(t,n,i){o===t&&s===n&&l===i||(e.stencilOp(t,n,i),o=t,s=n,l=i)},setLocked:function(e){t=e},setClear:function(t){c!==t&&(e.clearStencil(t),c=t)},reset:function(){t=!1,n=null,i=null,r=null,a=null,o=null,s=null,l=null,c=null}}},o=new WeakMap,s=new WeakMap;let l={},d={},u={},f=new WeakMap,p=[],m=null,h=!1,_=null,g=null,v=null,E=null,S=null,T=null,M=null,x=new n(0,0,0),A=0,R=!1,b=null,C=null,P=null,L=null,U=null;const I=e.getParameter(e.MAX_COMBINED_TEXTURE_IMAGE_UNITS);let N=!1,y=0;const O=e.getParameter(e.VERSION);-1!==O.indexOf("WebGL")?(y=parseFloat(/^WebGL (\d)/.exec(O)[1]),N=y>=1):-1!==O.indexOf("OpenGL ES")&&(y=parseFloat(/^OpenGL ES (\d)/.exec(O)[1]),N=y>=2);let F=null,B={};const G=e.getParameter(e.SCISSOR_BOX),H=e.getParameter(e.VIEWPORT),V=(new K).fromArray(G),W=(new K).fromArray(H);function z(t,n,i,r){const a=new Uint8Array(4),o=e.createTexture();e.bindTexture(t,o),e.texParameteri(t,e.TEXTURE_MIN_FILTER,e.NEAREST),e.texParameteri(t,e.TEXTURE_MAG_FILTER,e.NEAREST);for(let o=0;on||r.height>n)&&(i=n/Math.max(r.width,r.height)),i<1){if("undefined"!=typeof HTMLImageElement&&e instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&e instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&e instanceof ImageBitmap||"undefined"!=typeof VideoFrame&&e instanceof VideoFrame){const n=Math.floor(i*r.width),a=Math.floor(i*r.height);void 0===h&&(h=E(n,a));const o=t?E(n,a):h;o.width=n,o.height=a;return o.getContext("2d").drawImage(e,0,0,n,a),v("WebGLRenderer: Texture has been resized from ("+r.width+"x"+r.height+") to ("+n+"x"+a+")."),o}return"data"in e&&v("WebGLRenderer: Image in DataTexture is too big ("+r.width+"x"+r.height+")."),e}return e}function A(e){return e.generateMipmaps}function R(t){e.generateMipmap(t)}function b(t){return t.isWebGLCubeRenderTarget?e.TEXTURE_CUBE_MAP:t.isWebGL3DRenderTarget?e.TEXTURE_3D:t.isWebGLArrayRenderTarget||t.isCompressedArrayTexture?e.TEXTURE_2D_ARRAY:e.TEXTURE_2D}function C(t,i,r,a,o,s=!1){if(null!==t){if(void 0!==e[t])return e[t];v("WebGLRenderer: Attempt to use non-existing WebGL internal format '"+t+"'")}let l;a&&(l=n.get("EXT_texture_norm16"),l||v("WebGLRenderer: Unable to use normalized textures without EXT_texture_norm16 extension"));let c=i;if(i===e.RED&&(r===e.FLOAT&&(c=e.R32F),r===e.HALF_FLOAT&&(c=e.R16F),r===e.UNSIGNED_BYTE&&(c=e.R8),r===e.UNSIGNED_SHORT&&l&&(c=l.R16_EXT),r===e.SHORT&&l&&(c=l.R16_SNORM_EXT)),i===e.RED_INTEGER&&(r===e.UNSIGNED_BYTE&&(c=e.R8UI),r===e.UNSIGNED_SHORT&&(c=e.R16UI),r===e.UNSIGNED_INT&&(c=e.R32UI),r===e.BYTE&&(c=e.R8I),r===e.SHORT&&(c=e.R16I),r===e.INT&&(c=e.R32I)),i===e.RG&&(r===e.FLOAT&&(c=e.RG32F),r===e.HALF_FLOAT&&(c=e.RG16F),r===e.UNSIGNED_BYTE&&(c=e.RG8),r===e.UNSIGNED_SHORT&&l&&(c=l.RG16_EXT),r===e.SHORT&&l&&(c=l.RG16_SNORM_EXT)),i===e.RG_INTEGER&&(r===e.UNSIGNED_BYTE&&(c=e.RG8UI),r===e.UNSIGNED_SHORT&&(c=e.RG16UI),r===e.UNSIGNED_INT&&(c=e.RG32UI),r===e.BYTE&&(c=e.RG8I),r===e.SHORT&&(c=e.RG16I),r===e.INT&&(c=e.RG32I)),i===e.RGB_INTEGER&&(r===e.UNSIGNED_BYTE&&(c=e.RGB8UI),r===e.UNSIGNED_SHORT&&(c=e.RGB16UI),r===e.UNSIGNED_INT&&(c=e.RGB32UI),r===e.BYTE&&(c=e.RGB8I),r===e.SHORT&&(c=e.RGB16I),r===e.INT&&(c=e.RGB32I)),i===e.RGBA_INTEGER&&(r===e.UNSIGNED_BYTE&&(c=e.RGBA8UI),r===e.UNSIGNED_SHORT&&(c=e.RGBA16UI),r===e.UNSIGNED_INT&&(c=e.RGBA32UI),r===e.BYTE&&(c=e.RGBA8I),r===e.SHORT&&(c=e.RGBA16I),r===e.INT&&(c=e.RGBA32I)),i===e.RGB&&(r===e.UNSIGNED_SHORT&&l&&(c=l.RGB16_EXT),r===e.SHORT&&l&&(c=l.RGB16_SNORM_EXT),r===e.UNSIGNED_INT_5_9_9_9_REV&&(c=e.RGB9_E5),r===e.UNSIGNED_INT_10F_11F_11F_REV&&(c=e.R11F_G11F_B10F)),i===e.RGBA){const t=s?pe:f.getTransfer(o);r===e.FLOAT&&(c=e.RGBA32F),r===e.HALF_FLOAT&&(c=e.RGBA16F),r===e.UNSIGNED_BYTE&&(c=t===p?e.SRGB8_ALPHA8:e.RGBA8),r===e.UNSIGNED_SHORT&&l&&(c=l.RGBA16_EXT),r===e.SHORT&&l&&(c=l.RGBA16_SNORM_EXT),r===e.UNSIGNED_SHORT_4_4_4_4&&(c=e.RGBA4),r===e.UNSIGNED_SHORT_5_5_5_1&&(c=e.RGB5_A1)}return c!==e.R16F&&c!==e.R32F&&c!==e.RG16F&&c!==e.RG32F&&c!==e.RGBA16F&&c!==e.RGBA32F||n.get("EXT_color_buffer_float"),c}function P(t,n){let i;return t?null===n||n===Le||n===Pt?i=e.DEPTH24_STENCIL8:n===T?i=e.DEPTH32F_STENCIL8:n===Lt&&(i=e.DEPTH24_STENCIL8,v("DepthTexture: 16 bit depth attachment is not supported with stencil. Using 24-bit attachment.")):null===n||n===Le||n===Pt?i=e.DEPTH_COMPONENT24:n===T?i=e.DEPTH_COMPONENT32F:n===Lt&&(i=e.DEPTH_COMPONENT16),i}function L(e,t){return!0===A(e)||e.isFramebufferTexture&&e.minFilter!==Ce&&e.minFilter!==O?Math.log2(Math.max(t.width,t.height))+1:void 0!==e.mipmaps&&e.mipmaps.length>0?e.mipmaps.length:e.isCompressedTexture&&Array.isArray(e.image)?t.mipmaps.length:1}function U(e){const t=e.target;t.removeEventListener("dispose",U),function(e){const t=r.get(e);if(void 0===t.__webglInit)return;const n=e.source,i=_.get(n);if(i){const r=i[t.__cacheKey];r.usedTimes--,0===r.usedTimes&&I(e),0===Object.keys(i).length&&_.delete(n)}r.remove(e)}(t),t.isVideoTexture&&u.delete(t),t.isHTMLTexture&&m.delete(t)}function w(t){const n=t.target;n.removeEventListener("dispose",w),function(t){const n=r.get(t);t.depthTexture&&(t.depthTexture.dispose(),r.remove(t.depthTexture));if(t.isWebGLCubeRenderTarget)for(let t=0;t<6;t++){if(Array.isArray(n.__webglFramebuffer[t]))for(let i=0;i0&&a.__version!==t.version){const e=t.image;if(null===e)v("WebGLRenderer: Texture marked for update but no image data found.");else{if(!1!==e.complete)return void X(a,t,n);v("WebGLRenderer: Texture marked for update but image is incomplete")}}else t.isExternalTexture&&(a.__webglTexture=t.sourceTexture?t.sourceTexture:null);i.bindTexture(e.TEXTURE_2D,a.__webglTexture,e.TEXTURE0+n)}const G={[ht]:e.REPEAT,[mt]:e.CLAMP_TO_EDGE,[pt]:e.MIRRORED_REPEAT},H={[Ce]:e.NEAREST,[vt]:e.NEAREST_MIPMAP_NEAREST,[gt]:e.NEAREST_MIPMAP_LINEAR,[O]:e.LINEAR,[_t]:e.LINEAR_MIPMAP_NEAREST,[B]:e.LINEAR_MIPMAP_LINEAR},V={[At]:e.NEVER,[xt]:e.ALWAYS,[Mt]:e.LESS,[ae]:e.LEQUAL,[Tt]:e.EQUAL,[re]:e.GEQUAL,[St]:e.GREATER,[Et]:e.NOTEQUAL};function W(t,i){if(i.type!==T||!1!==n.has("OES_texture_float_linear")||i.magFilter!==O&&i.magFilter!==_t&&i.magFilter!==gt&&i.magFilter!==B&&i.minFilter!==O&&i.minFilter!==_t&&i.minFilter!==gt&&i.minFilter!==B||v("WebGLRenderer: Unable to use linear filtering with floating point textures. OES_texture_float_linear not supported on this device."),e.texParameteri(t,e.TEXTURE_WRAP_S,G[i.wrapS]),e.texParameteri(t,e.TEXTURE_WRAP_T,G[i.wrapT]),t!==e.TEXTURE_3D&&t!==e.TEXTURE_2D_ARRAY||e.texParameteri(t,e.TEXTURE_WRAP_R,G[i.wrapR]),e.texParameteri(t,e.TEXTURE_MAG_FILTER,H[i.magFilter]),e.texParameteri(t,e.TEXTURE_MIN_FILTER,H[i.minFilter]),i.compareFunction&&(e.texParameteri(t,e.TEXTURE_COMPARE_MODE,e.COMPARE_REF_TO_TEXTURE),e.texParameteri(t,e.TEXTURE_COMPARE_FUNC,V[i.compareFunction])),!0===n.has("EXT_texture_filter_anisotropic")){if(i.magFilter===Ce)return;if(i.minFilter!==gt&&i.minFilter!==B)return;if(i.type===T&&!1===n.has("OES_texture_float_linear"))return;if(i.anisotropy>1||r.get(i).__currentAnisotropy){const o=n.get("EXT_texture_filter_anisotropic");e.texParameterf(t,o.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(i.anisotropy,a.getMaxAnisotropy())),r.get(i).__currentAnisotropy=i.anisotropy}}}function z(t,n){let i=!1;void 0===t.__webglInit&&(t.__webglInit=!0,n.addEventListener("dispose",U));const r=n.source;let a=_.get(r);void 0===a&&(a={},_.set(r,a));const o=function(e){const t=[];return t.push(e.wrapS),t.push(e.wrapT),t.push(e.wrapR||0),t.push(e.magFilter),t.push(e.minFilter),t.push(e.anisotropy),t.push(e.internalFormat),t.push(e.format),t.push(e.type),t.push(e.generateMipmaps),t.push(e.premultiplyAlpha),t.push(e.flipY),t.push(e.unpackAlignment),t.push(e.colorSpace),t.join()}(n);if(o!==t.__cacheKey){void 0===a[o]&&(a[o]={texture:e.createTexture(),usedTimes:0},s.memory.textures++,i=!0),a[o].usedTimes++;const r=a[t.__cacheKey];void 0!==r&&(a[t.__cacheKey].usedTimes--,0===r.usedTimes&&I(n)),t.__cacheKey=o,t.__webglTexture=a[o].texture}return i}function k(e,t,n){return Math.floor(Math.floor(e/n)/t)}function X(t,n,s){let l=e.TEXTURE_2D;(n.isDataArrayTexture||n.isCompressedArrayTexture)&&(l=e.TEXTURE_2D_ARRAY),n.isData3DTexture&&(l=e.TEXTURE_3D);const c=z(t,n),d=n.source;i.bindTexture(l,t.__webglTexture,e.TEXTURE0+s);const u=r.get(d);if(d.version!==u.__version||!0===c){i.activeTexture(e.TEXTURE0+s);if(!1===("undefined"!=typeof ImageBitmap&&n.image instanceof ImageBitmap)){const t=f.getPrimaries(f.workingColorSpace),r=n.colorSpace===Rt?null:f.getPrimaries(n.colorSpace),a=n.colorSpace===Rt||t===r?e.NONE:e.BROWSER_DEFAULT_WEBGL;i.pixelStorei(e.UNPACK_FLIP_Y_WEBGL,n.flipY),i.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,n.premultiplyAlpha),i.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL,a)}i.pixelStorei(e.UNPACK_ALIGNMENT,n.unpackAlignment);let t=x(n.image,!1,a.maxTextureSize);t=ee(n,t);const r=o.convert(n.format,n.colorSpace),p=o.convert(n.type);let h,_=C(n.internalFormat,r,p,n.normalized,n.colorSpace,n.isVideoTexture);W(l,n);const g=n.mipmaps,E=!0!==n.isVideoTexture,S=void 0===u.__version||!0===c,T=d.dataReady,b=L(n,t);if(n.isDepthTexture)_=P(n.format===bt,n.type),S&&(E?i.texStorage2D(e.TEXTURE_2D,1,_,t.width,t.height):i.texImage2D(e.TEXTURE_2D,0,_,t.width,t.height,0,r,p,null));else if(n.isDataTexture)if(g.length>0){E&&S&&i.texStorage2D(e.TEXTURE_2D,b,_,g[0].width,g[0].height);for(let t=0,n=g.length;te.start-t.start);let s=0;for(let e=1;e0){const t=Ct(h.width,h.height,n.format,n.type);for(const o of n.layerUpdates){const n=h.data.subarray(o*t/h.data.BYTES_PER_ELEMENT,(o+1)*t/h.data.BYTES_PER_ELEMENT);i.compressedTexSubImage3D(e.TEXTURE_2D_ARRAY,a,0,0,o,h.width,h.height,1,r,n)}n.clearLayerUpdates()}else i.compressedTexSubImage3D(e.TEXTURE_2D_ARRAY,a,0,0,0,h.width,h.height,t.depth,r,h.data)}else i.compressedTexImage3D(e.TEXTURE_2D_ARRAY,a,_,h.width,h.height,t.depth,0,h.data,0,0);else v("WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()");else E?T&&i.texSubImage3D(e.TEXTURE_2D_ARRAY,a,0,0,0,h.width,h.height,t.depth,r,p,h.data):i.texImage3D(e.TEXTURE_2D_ARRAY,a,_,h.width,h.height,t.depth,0,r,p,h.data)}else{E&&S&&i.texStorage2D(e.TEXTURE_2D,b,_,g[0].width,g[0].height);for(let t=0,a=g.length;t0){const a=Ct(t.width,t.height,n.format,n.type);for(const o of n.layerUpdates){const n=t.data.subarray(o*a/t.data.BYTES_PER_ELEMENT,(o+1)*a/t.data.BYTES_PER_ELEMENT);i.texSubImage3D(e.TEXTURE_2D_ARRAY,0,0,0,o,t.width,t.height,1,r,p,n)}n.clearLayerUpdates()}else i.texSubImage3D(e.TEXTURE_2D_ARRAY,0,0,0,0,t.width,t.height,t.depth,r,p,t.data)}else i.texImage3D(e.TEXTURE_2D_ARRAY,0,_,t.width,t.height,t.depth,0,r,p,t.data);else if(n.isData3DTexture)E?(S&&i.texStorage3D(e.TEXTURE_3D,b,_,t.width,t.height,t.depth),T&&i.texSubImage3D(e.TEXTURE_3D,0,0,0,0,t.width,t.height,t.depth,r,p,t.data)):i.texImage3D(e.TEXTURE_3D,0,_,t.width,t.height,t.depth,0,r,p,t.data);else if(n.isFramebufferTexture){if(S)if(E)i.texStorage2D(e.TEXTURE_2D,b,_,t.width,t.height);else{let n=t.width,a=t.height;for(let t=0;t>=1,a>>=1}}else if(n.isHTMLTexture){if("texElementImage2D"in e){const i=e.canvas;if(i.hasAttribute("layoutsubtree")||i.setAttribute("layoutsubtree","true"),t.parentNode!==i)return i.appendChild(t),m.add(n),i.onpaint=e=>{const t=e.changedElements;for(const e of m)t.includes(e.image)&&(e.needsUpdate=!0)},void i.requestPaint();const r=0,a=e.RGBA,o=e.RGBA,s=e.UNSIGNED_BYTE;e.texElementImage2D(e.TEXTURE_2D,r,a,o,s,t),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MIN_FILTER,e.LINEAR),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_WRAP_S,e.CLAMP_TO_EDGE),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_WRAP_T,e.CLAMP_TO_EDGE)}}else if(g.length>0){if(E&&S){const t=te(g[0]);i.texStorage2D(e.TEXTURE_2D,b,_,t.width,t.height)}for(let t=0,n=g.length;t>d),r=Math.max(1,n.height>>d);c===e.TEXTURE_3D||c===e.TEXTURE_2D_ARRAY?i.texImage3D(c,d,p,t,r,n.depth,0,u,f,null):i.texImage2D(c,d,p,t,r,0,u,f,null)}i.bindFramebuffer(e.FRAMEBUFFER,t),J(n)?l.framebufferTexture2DMultisampleEXT(e.FRAMEBUFFER,s,c,h.__webglTexture,0,Q(n)):(c===e.TEXTURE_2D||c>=e.TEXTURE_CUBE_MAP_POSITIVE_X&&c<=e.TEXTURE_CUBE_MAP_NEGATIVE_Z)&&e.framebufferTexture2D(e.FRAMEBUFFER,s,c,h.__webglTexture,d),i.bindFramebuffer(e.FRAMEBUFFER,null)}function Y(t,n,i){if(e.bindRenderbuffer(e.RENDERBUFFER,t),n.depthBuffer){const r=n.depthTexture,a=r&&r.isDepthTexture?r.type:null,o=P(n.stencilBuffer,a),s=n.stencilBuffer?e.DEPTH_STENCIL_ATTACHMENT:e.DEPTH_ATTACHMENT;J(n)?l.renderbufferStorageMultisampleEXT(e.RENDERBUFFER,Q(n),o,n.width,n.height):i?e.renderbufferStorageMultisample(e.RENDERBUFFER,Q(n),o,n.width,n.height):e.renderbufferStorage(e.RENDERBUFFER,o,n.width,n.height),e.framebufferRenderbuffer(e.FRAMEBUFFER,s,e.RENDERBUFFER,t)}else{const t=n.textures;for(let r=0;r{delete n.__boundDepthTexture,delete n.__depthDisposeCallback,e.removeEventListener("dispose",t)};e.addEventListener("dispose",t),n.__depthDisposeCallback=t}n.__boundDepthTexture=e}if(t.depthTexture&&!n.__autoAllocateDepthBuffer)if(a)for(let e=0;e<6;e++)q(n.__webglFramebuffer[e],t,e);else{const e=t.texture.mipmaps;e&&e.length>0?q(n.__webglFramebuffer[0],t,0):q(n.__webglFramebuffer,t,0)}else if(a){n.__webglDepthbuffer=[];for(let r=0;r<6;r++)if(i.bindFramebuffer(e.FRAMEBUFFER,n.__webglFramebuffer[r]),void 0===n.__webglDepthbuffer[r])n.__webglDepthbuffer[r]=e.createRenderbuffer(),Y(n.__webglDepthbuffer[r],t,!1);else{const i=t.stencilBuffer?e.DEPTH_STENCIL_ATTACHMENT:e.DEPTH_ATTACHMENT,a=n.__webglDepthbuffer[r];e.bindRenderbuffer(e.RENDERBUFFER,a),e.framebufferRenderbuffer(e.FRAMEBUFFER,i,e.RENDERBUFFER,a)}}else{const r=t.texture.mipmaps;if(r&&r.length>0?i.bindFramebuffer(e.FRAMEBUFFER,n.__webglFramebuffer[0]):i.bindFramebuffer(e.FRAMEBUFFER,n.__webglFramebuffer),void 0===n.__webglDepthbuffer)n.__webglDepthbuffer=e.createRenderbuffer(),Y(n.__webglDepthbuffer,t,!1);else{const i=t.stencilBuffer?e.DEPTH_STENCIL_ATTACHMENT:e.DEPTH_ATTACHMENT,r=n.__webglDepthbuffer;e.bindRenderbuffer(e.RENDERBUFFER,r),e.framebufferRenderbuffer(e.FRAMEBUFFER,i,e.RENDERBUFFER,r)}}i.bindFramebuffer(e.FRAMEBUFFER,null)}const Z=[],$=[];function Q(e){return Math.min(a.maxSamples,e.samples)}function J(e){const t=r.get(e);return e.samples>0&&!0===n.has("WEBGL_multisampled_render_to_texture")&&!1!==t.__useRenderToTexture}function ee(e,t){const n=e.colorSpace,i=e.format,r=e.type;return!0===e.isCompressedTexture||!0===e.isVideoTexture||n!==y&&n!==Rt&&(f.getTransfer(n)===p?i===M&&r===S||v("WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):D("WebGLTextures: Unsupported texture color space:",n)),t}function te(e){return"undefined"!=typeof HTMLImageElement&&e instanceof HTMLImageElement?(d.width=e.naturalWidth||e.width,d.height=e.naturalHeight||e.height):"undefined"!=typeof VideoFrame&&e instanceof VideoFrame?(d.width=e.displayWidth,d.height=e.displayHeight):(d.width=e.width,d.height=e.height),d}this.allocateTextureUnit=function(){const e=N;return e>=a.maxTextures&&v("WebGLTextures: Trying to use "+e+" texture units while this GPU supports only "+a.maxTextures),N+=1,e},this.resetTextureUnits=function(){N=0},this.getTextureUnits=function(){return N},this.setTextureUnits=function(e){N=e},this.setTexture2D=F,this.setTexture2DArray=function(t,n){const a=r.get(t);!1===t.isRenderTargetTexture&&t.version>0&&a.__version!==t.version?X(a,t,n):(t.isExternalTexture&&(a.__webglTexture=t.sourceTexture?t.sourceTexture:null),i.bindTexture(e.TEXTURE_2D_ARRAY,a.__webglTexture,e.TEXTURE0+n))},this.setTexture3D=function(t,n){const a=r.get(t);!1===t.isRenderTargetTexture&&t.version>0&&a.__version!==t.version?X(a,t,n):i.bindTexture(e.TEXTURE_3D,a.__webglTexture,e.TEXTURE0+n)},this.setTextureCube=function(t,n){const s=r.get(t);!0!==t.isCubeDepthTexture&&t.version>0&&s.__version!==t.version?function(t,n,s){if(6!==n.image.length)return;const l=z(t,n),c=n.source;i.bindTexture(e.TEXTURE_CUBE_MAP,t.__webglTexture,e.TEXTURE0+s);const d=r.get(c);if(c.version!==d.__version||!0===l){i.activeTexture(e.TEXTURE0+s);const t=f.getPrimaries(f.workingColorSpace),r=n.colorSpace===Rt?null:f.getPrimaries(n.colorSpace),u=n.colorSpace===Rt||t===r?e.NONE:e.BROWSER_DEFAULT_WEBGL;i.pixelStorei(e.UNPACK_FLIP_Y_WEBGL,n.flipY),i.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,n.premultiplyAlpha),i.pixelStorei(e.UNPACK_ALIGNMENT,n.unpackAlignment),i.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL,u);const p=n.isCompressedTexture||n.image[0].isCompressedTexture,m=n.image[0]&&n.image[0].isDataTexture,h=[];for(let e=0;e<6;e++)h[e]=p||m?m?n.image[e].image:n.image[e]:x(n.image[e],!0,a.maxCubemapSize),h[e]=ee(n,h[e]);const _=h[0],g=o.convert(n.format,n.colorSpace),E=o.convert(n.type),S=C(n.internalFormat,g,E,n.normalized,n.colorSpace),T=!0!==n.isVideoTexture,b=void 0===d.__version||!0===l,P=c.dataReady;let U,D=L(n,_);if(W(e.TEXTURE_CUBE_MAP,n),p){T&&b&&i.texStorage2D(e.TEXTURE_CUBE_MAP,D,S,_.width,_.height);for(let t=0;t<6;t++){U=h[t].mipmaps;for(let r=0;r0&&D++;const t=te(h[0]);i.texStorage2D(e.TEXTURE_CUBE_MAP,D,S,t.width,t.height)}for(let t=0;t<6;t++)if(m){T?P&&i.texSubImage2D(e.TEXTURE_CUBE_MAP_POSITIVE_X+t,0,0,0,h[t].width,h[t].height,g,E,h[t].data):i.texImage2D(e.TEXTURE_CUBE_MAP_POSITIVE_X+t,0,S,h[t].width,h[t].height,0,g,E,h[t].data);for(let n=0;n1;if(u||(void 0===l.__webglTexture&&(l.__webglTexture=e.createTexture()),l.__version=n.version,s.memory.textures++),d){a.__webglFramebuffer=[];for(let t=0;t<6;t++)if(n.mipmaps&&n.mipmaps.length>0){a.__webglFramebuffer[t]=[];for(let i=0;i0){a.__webglFramebuffer=[];for(let t=0;t0&&!1===J(t)){a.__webglMultisampledFramebuffer=e.createFramebuffer(),a.__webglColorRenderbuffer=[],i.bindFramebuffer(e.FRAMEBUFFER,a.__webglMultisampledFramebuffer);for(let n=0;n0)for(let r=0;r0)for(let i=0;i0)if(!1===J(t)){const n=t.textures,a=t.width,o=t.height;let s=e.COLOR_BUFFER_BIT;const l=t.stencilBuffer?e.DEPTH_STENCIL_ATTACHMENT:e.DEPTH_ATTACHMENT,d=r.get(t),u=n.length>1;if(u)for(let t=0;t0?i.bindFramebuffer(e.DRAW_FRAMEBUFFER,d.__webglFramebuffer[0]):i.bindFramebuffer(e.DRAW_FRAMEBUFFER,d.__webglFramebuffer);for(let i=0;i= 1.0 ) {\n\n\t\tgl_FragDepth = texture( depthColor, vec3( coord.x - 1.0, coord.y, 1 ) ).r;\n\n\t} else {\n\n\t\tgl_FragDepth = texture( depthColor, vec3( coord.x, coord.y, 0 ) ).r;\n\n\t}\n\n}",uniforms:{depthColor:{value:this.texture},depthWidth:{value:t.z},depthHeight:{value:t.w}}});this.mesh=new o(new m(20,20),n)}return this.mesh}reset(){this.texture=null,this.mesh=null}getDepthTexture(){return this.texture}}class Ta extends Rn{constructor(e,n){super();const r=this;let a=null,o=1,s=null,l="local-floor",c=1,d=null,u=null,f=null,p=null,m=null,h=null;const _="undefined"!=typeof XRWebGLBinding,g=new Sa,E={},T=n.getContextAttributes();let x=null,A=null;const R=[],b=[],C=new t;let L=null;const U=new P;U.viewport=new K;const D=new P;D.viewport=new K;const w=[U,D],N=new bn;let y=null,O=null;function F(e){const t=b.indexOf(e.inputSource);if(-1===t)return;const n=R[t];void 0!==n&&(n.update(e.inputSource,e.frame,d||s),n.dispatchEvent({type:e.type,data:e.inputSource}))}function B(){a.removeEventListener("select",F),a.removeEventListener("selectstart",F),a.removeEventListener("selectend",F),a.removeEventListener("squeeze",F),a.removeEventListener("squeezestart",F),a.removeEventListener("squeezeend",F),a.removeEventListener("end",B),a.removeEventListener("inputsourceschange",G);for(let e=0;e=0&&(b[i]=null,R[i].disconnect(n))}for(let t=0;t=b.length){b.push(n),i=e;break}if(null===b[e]){b[e]=n,i=e;break}}if(-1===i)break}const r=R[i];r&&r.connect(n)}}this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(e){let t=R[e];return void 0===t&&(t=new Cn,R[e]=t),t.getTargetRaySpace()},this.getControllerGrip=function(e){let t=R[e];return void 0===t&&(t=new Cn,R[e]=t),t.getGripSpace()},this.getHand=function(e){let t=R[e];return void 0===t&&(t=new Cn,R[e]=t),t.getHandSpace()},this.setFramebufferScaleFactor=function(e){o=e,!0===r.isPresenting&&v("WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(e){l=e,!0===r.isPresenting&&v("WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return d||s},this.setReferenceSpace=function(e){d=e},this.getBaseLayer=function(){return null!==p?p:m},this.getBinding=function(){return null===f&&_&&(f=new XRWebGLBinding(a,n)),f},this.getFrame=function(){return h},this.getSession=function(){return a},this.setSession=async function(t){if(a=t,null!==a){x=e.getRenderTarget(),a.addEventListener("select",F),a.addEventListener("selectstart",F),a.addEventListener("selectend",F),a.addEventListener("squeeze",F),a.addEventListener("squeezestart",F),a.addEventListener("squeezeend",F),a.addEventListener("end",B),a.addEventListener("inputsourceschange",G),!0!==T.xrCompatible&&await n.makeXRCompatible(),L=e.getPixelRatio(),e.getSize(C);if(_&&"createProjectionLayer"in XRWebGLBinding.prototype){let t=null,i=null,r=null;T.depth&&(r=T.stencil?n.DEPTH24_STENCIL8:n.DEPTH_COMPONENT24,t=T.stencil?bt:be,i=T.stencil?Pt:Le);const s={colorFormat:n.RGBA8,depthFormat:r,scaleFactor:o};f=this.getBinding(),p=f.createProjectionLayer(s),a.updateRenderState({layers:[p]}),e.setPixelRatio(1),e.setSize(p.textureWidth,p.textureHeight,!1),A=new I(p.textureWidth,p.textureHeight,{format:M,type:S,depthTexture:new Y(p.textureWidth,p.textureHeight,i,void 0,void 0,void 0,void 0,void 0,void 0,t),stencilBuffer:T.stencil,colorSpace:e.outputColorSpace,samples:T.antialias?4:0,resolveDepthBuffer:!1===p.ignoreDepthValues,resolveStencilBuffer:!1===p.ignoreDepthValues})}else{const t={antialias:T.antialias,alpha:!0,depth:T.depth,stencil:T.stencil,framebufferScaleFactor:o};m=new XRWebGLLayer(a,n,t),a.updateRenderState({baseLayer:m}),e.setPixelRatio(1),e.setSize(m.framebufferWidth,m.framebufferHeight,!1),A=new I(m.framebufferWidth,m.framebufferHeight,{format:M,type:S,colorSpace:e.outputColorSpace,stencilBuffer:T.stencil,resolveDepthBuffer:!1===m.ignoreDepthValues,resolveStencilBuffer:!1===m.ignoreDepthValues})}A.isXRRenderTarget=!0,this.setFoveation(c),d=null,s=await a.requestReferenceSpace(l),k.setContext(a),k.start(),r.isPresenting=!0,r.dispatchEvent({type:"sessionstart"})}},this.getEnvironmentBlendMode=function(){if(null!==a)return a.environmentBlendMode},this.getDepthTexture=function(){return g.getDepthTexture()};const H=new i,V=new i;function W(e,t){null===t?e.matrixWorld.copy(e.matrix):e.matrixWorld.multiplyMatrices(t.matrixWorld,e.matrix),e.matrixWorldInverse.copy(e.matrixWorld).invert()}this.updateCamera=function(e){if(null===a)return;let t=e.near,n=e.far;null!==g.texture&&(g.depthNear>0&&(t=g.depthNear),g.depthFar>0&&(n=g.depthFar)),N.near=D.near=U.near=t,N.far=D.far=U.far=n,y===N.near&&O===N.far||(a.updateRenderState({depthNear:N.near,depthFar:N.far}),y=N.near,O=N.far),N.layers.mask=6|e.layers.mask,U.layers.mask=-5&N.layers.mask,D.layers.mask=-3&N.layers.mask;const i=e.parent,r=N.cameras;W(N,i);for(let e=0;e0&&(e.alphaTest.value=i.alphaTest);const r=t.get(i),a=r.envMap,o=r.envMapRotation;a&&(e.envMap.value=a,e.envMapRotation.value.setFromMatrix4(Ma.makeRotationFromEuler(o)).transpose(),a.isCubeTexture&&!1===a.isRenderTargetTexture&&e.envMapRotation.value.premultiply(xa),e.reflectivity.value=i.reflectivity,e.ior.value=i.ior,e.refractionRatio.value=i.refractionRatio),i.lightMap&&(e.lightMap.value=i.lightMap,e.lightMapIntensity.value=i.lightMapIntensity,n(i.lightMap,e.lightMapTransform)),i.aoMap&&(e.aoMap.value=i.aoMap,e.aoMapIntensity.value=i.aoMapIntensity,n(i.aoMap,e.aoMapTransform))}return{refreshFogUniforms:function(t,n){n.color.getRGB(t.fogColor.value,_(e)),n.isFog?(t.fogNear.value=n.near,t.fogFar.value=n.far):n.isFogExp2&&(t.fogDensity.value=n.density)},refreshMaterialUniforms:function(e,r,a,o,s){r.isNodeMaterial?r.uniformsNeedUpdate=!1:r.isMeshBasicMaterial?i(e,r):r.isMeshLambertMaterial?(i(e,r),r.envMap&&(e.envMapIntensity.value=r.envMapIntensity)):r.isMeshToonMaterial?(i(e,r),function(e,t){t.gradientMap&&(e.gradientMap.value=t.gradientMap)}(e,r)):r.isMeshPhongMaterial?(i(e,r),function(e,t){e.specular.value.copy(t.specular),e.shininess.value=Math.max(t.shininess,1e-4)}(e,r),r.envMap&&(e.envMapIntensity.value=r.envMapIntensity)):r.isMeshStandardMaterial?(i(e,r),function(e,t){e.metalness.value=t.metalness,t.metalnessMap&&(e.metalnessMap.value=t.metalnessMap,n(t.metalnessMap,e.metalnessMapTransform));e.roughness.value=t.roughness,t.roughnessMap&&(e.roughnessMap.value=t.roughnessMap,n(t.roughnessMap,e.roughnessMapTransform));t.envMap&&(e.envMapIntensity.value=t.envMapIntensity)}(e,r),r.isMeshPhysicalMaterial&&function(e,t,i){e.ior.value=t.ior,t.sheen>0&&(e.sheenColor.value.copy(t.sheenColor).multiplyScalar(t.sheen),e.sheenRoughness.value=t.sheenRoughness,t.sheenColorMap&&(e.sheenColorMap.value=t.sheenColorMap,n(t.sheenColorMap,e.sheenColorMapTransform)),t.sheenRoughnessMap&&(e.sheenRoughnessMap.value=t.sheenRoughnessMap,n(t.sheenRoughnessMap,e.sheenRoughnessMapTransform)));t.clearcoat>0&&(e.clearcoat.value=t.clearcoat,e.clearcoatRoughness.value=t.clearcoatRoughness,t.clearcoatMap&&(e.clearcoatMap.value=t.clearcoatMap,n(t.clearcoatMap,e.clearcoatMapTransform)),t.clearcoatRoughnessMap&&(e.clearcoatRoughnessMap.value=t.clearcoatRoughnessMap,n(t.clearcoatRoughnessMap,e.clearcoatRoughnessMapTransform)),t.clearcoatNormalMap&&(e.clearcoatNormalMap.value=t.clearcoatNormalMap,n(t.clearcoatNormalMap,e.clearcoatNormalMapTransform),e.clearcoatNormalScale.value.copy(t.clearcoatNormalScale),t.side===c&&e.clearcoatNormalScale.value.negate()));t.dispersion>0&&(e.dispersion.value=t.dispersion);t.iridescence>0&&(e.iridescence.value=t.iridescence,e.iridescenceIOR.value=t.iridescenceIOR,e.iridescenceThicknessMinimum.value=t.iridescenceThicknessRange[0],e.iridescenceThicknessMaximum.value=t.iridescenceThicknessRange[1],t.iridescenceMap&&(e.iridescenceMap.value=t.iridescenceMap,n(t.iridescenceMap,e.iridescenceMapTransform)),t.iridescenceThicknessMap&&(e.iridescenceThicknessMap.value=t.iridescenceThicknessMap,n(t.iridescenceThicknessMap,e.iridescenceThicknessMapTransform)));t.transmission>0&&(e.transmission.value=t.transmission,e.transmissionSamplerMap.value=i.texture,e.transmissionSamplerSize.value.set(i.width,i.height),t.transmissionMap&&(e.transmissionMap.value=t.transmissionMap,n(t.transmissionMap,e.transmissionMapTransform)),e.thickness.value=t.thickness,t.thicknessMap&&(e.thicknessMap.value=t.thicknessMap,n(t.thicknessMap,e.thicknessMapTransform)),e.attenuationDistance.value=t.attenuationDistance,e.attenuationColor.value.copy(t.attenuationColor));t.anisotropy>0&&(e.anisotropyVector.value.set(t.anisotropy*Math.cos(t.anisotropyRotation),t.anisotropy*Math.sin(t.anisotropyRotation)),t.anisotropyMap&&(e.anisotropyMap.value=t.anisotropyMap,n(t.anisotropyMap,e.anisotropyMapTransform)));e.specularIntensity.value=t.specularIntensity,e.specularColor.value.copy(t.specularColor),t.specularColorMap&&(e.specularColorMap.value=t.specularColorMap,n(t.specularColorMap,e.specularColorMapTransform));t.specularIntensityMap&&(e.specularIntensityMap.value=t.specularIntensityMap,n(t.specularIntensityMap,e.specularIntensityMapTransform))}(e,r,s)):r.isMeshMatcapMaterial?(i(e,r),function(e,t){t.matcap&&(e.matcap.value=t.matcap)}(e,r)):r.isMeshDepthMaterial?i(e,r):r.isMeshDistanceMaterial?(i(e,r),function(e,n){const i=t.get(n).light;e.referencePosition.value.setFromMatrixPosition(i.matrixWorld),e.nearDistance.value=i.shadow.camera.near,e.farDistance.value=i.shadow.camera.far}(e,r)):r.isMeshNormalMaterial?i(e,r):r.isLineBasicMaterial?(function(e,t){e.diffuse.value.copy(t.color),e.opacity.value=t.opacity,t.map&&(e.map.value=t.map,n(t.map,e.mapTransform))}(e,r),r.isLineDashedMaterial&&function(e,t){e.dashSize.value=t.dashSize,e.totalSize.value=t.dashSize+t.gapSize,e.scale.value=t.scale}(e,r)):r.isPointsMaterial?function(e,t,i,r){e.diffuse.value.copy(t.color),e.opacity.value=t.opacity,e.size.value=t.size*i,e.scale.value=.5*r,t.map&&(e.map.value=t.map,n(t.map,e.uvTransform));t.alphaMap&&(e.alphaMap.value=t.alphaMap,n(t.alphaMap,e.alphaMapTransform));t.alphaTest>0&&(e.alphaTest.value=t.alphaTest)}(e,r,a,o):r.isSpriteMaterial?function(e,t){e.diffuse.value.copy(t.color),e.opacity.value=t.opacity,e.rotation.value=t.rotation,t.map&&(e.map.value=t.map,n(t.map,e.mapTransform));t.alphaMap&&(e.alphaMap.value=t.alphaMap,n(t.alphaMap,e.alphaMapTransform));t.alphaTest>0&&(e.alphaTest.value=t.alphaTest)}(e,r):r.isShadowMaterial?(e.color.value.copy(r.color),e.opacity.value=r.opacity):r.isShaderMaterial&&(r.uniformsNeedUpdate=!1)}}}function Ra(e,t,n,i){let r={},a={},o=[];const s=e.getParameter(e.MAX_UNIFORM_BUFFER_BINDINGS);function l(e,t,n,i){const r=e.value,a=t+"_"+n;if(void 0===i[a])return"number"==typeof r||"boolean"==typeof r?i[a]=r:ArrayBuffer.isView(r)?i[a]=r.slice():i[a]=r.clone(),!0;{const e=i[a];if("number"==typeof r||"boolean"==typeof r){if(e!==r)return i[a]=r,!0}else{if(ArrayBuffer.isView(r))return!0;if(!1===e.equals(r))return e.copy(r),!0}}return!1}function c(e){const t={boundary:0,storage:0};return"number"==typeof e||"boolean"==typeof e?(t.boundary=4,t.storage=4):e.isVector2?(t.boundary=8,t.storage=8):e.isVector3||e.isColor?(t.boundary=16,t.storage=12):e.isVector4?(t.boundary=16,t.storage=16):e.isMatrix3?(t.boundary=48,t.storage=48):e.isMatrix4?(t.boundary=64,t.storage=64):e.isTexture?v("WebGLRenderer: Texture samplers can not be part of an uniforms group."):ArrayBuffer.isView(e)?(t.boundary=16,t.storage=e.byteLength):v("WebGLRenderer: Unsupported uniform value type.",e),t}function d(t){const n=t.target;n.removeEventListener("dispose",d);const i=o.indexOf(n.__bindingPointIndex);o.splice(i,1),e.deleteBuffer(r[n.id]),delete r[n.id],delete a[n.id]}return{bind:function(e,t){const n=t.program;i.uniformBlockBinding(e,n)},update:function(n,u){let f=r[n.id];void 0===f&&(!function(e){const t=e.uniforms;let n=0;const i=16;for(let e=0,r=t.length;e0&&(n+=i-r);e.__size=n,e.__cache={}}(n),f=function(t){const n=function(){for(let e=0;e0),p=!!n.morphAttributes.position,m=!!n.morphAttributes.normal,h=!!n.morphAttributes.color;let _=L;i.toneMapped&&(null!==k&&!0!==k.isXRRenderTarget||(_=G.toneMapping));const g=n.morphAttributes.position||n.morphAttributes.normal||n.morphAttributes.color,v=void 0!==g?g.length:0,S=Me.get(i),T=w.state.lights;if(!0===le&&(!0===ce||e!==Y)){const t=e===Y&&i.id===X;Ne.setState(i,e,t)}let M=!1;i.version===S.__version?S.needsLights&&S.lightsStateVersion!==T.state.version||S.outputColorSpace!==s||r.isBatchedMesh&&!1===S.batching?M=!0:r.isBatchedMesh||!0!==S.batching?r.isBatchedMesh&&!0===S.batchingColor&&null===r.colorTexture||r.isBatchedMesh&&!1===S.batchingColor&&null!==r.colorTexture||r.isInstancedMesh&&!1===S.instancing?M=!0:r.isInstancedMesh||!0!==S.instancing?r.isSkinnedMesh&&!1===S.skinning?M=!0:r.isSkinnedMesh||!0!==S.skinning?r.isInstancedMesh&&!0===S.instancingColor&&null===r.instanceColor||r.isInstancedMesh&&!1===S.instancingColor&&null!==r.instanceColor||r.isInstancedMesh&&!0===S.instancingMorph&&null===r.morphTexture||r.isInstancedMesh&&!1===S.instancingMorph&&null!==r.morphTexture||S.envMap!==c||!0===i.fog&&S.fog!==a?M=!0:void 0===S.numClippingPlanes||S.numClippingPlanes===Ne.numPlanes&&S.numIntersection===Ne.numIntersection?(S.vertexAlphas!==d||S.vertexTangents!==u||S.morphTargets!==p||S.morphNormals!==m||S.morphColors!==h||S.toneMapping!==_||S.morphTargetsCount!==v||!!S.lightProbeGrid!=w.state.lightProbeGridArray.length>0)&&(M=!0):M=!0:M=!0:M=!0:M=!0:(M=!0,S.__version=i.version);let x=S.currentProgram;!0===M&&(x=st(i,t,r),V&&i.isNodeMaterial&&V.onUpdateProgram(i,x,S));let A=!1,R=!1,b=!1;const C=x.getUniforms(),U=S.uniforms;Ee.useProgram(x.program)&&(A=!0,R=!0,b=!0);i.id!==X&&(X=i.id,R=!0);if(S.needsLights){const e=function(e,t){if(0===e.length)return null;if(1===e.length)return null!==e[0].texture?e[0]:null;P.setFromMatrixPosition(t.matrixWorld);for(let t=0,n=e.length;t0&&C.setValue(ze,"directionalShadowMap",T.state.directionalShadowMap,xe),T.state.spotShadowMap.length>0&&C.setValue(ze,"spotShadowMap",T.state.spotShadowMap,xe),T.state.pointShadowMap.length>0&&C.setValue(ze,"pointShadowMap",T.state.pointShadowMap,xe));if(r.isSkinnedMesh){C.setOptional(ze,r,"bindMatrix"),C.setOptional(ze,r,"bindMatrixInverse");const e=r.skeleton;e&&(null===e.boneTexture&&e.computeBoneTexture(),C.setValue(ze,"boneTexture",e.boneTexture,xe))}r.isBatchedMesh&&(C.setOptional(ze,r,"batchingTexture"),C.setValue(ze,"batchingTexture",r._matricesTexture,xe),C.setOptional(ze,r,"batchingIdTexture"),C.setValue(ze,"batchingIdTexture",r._indirectTexture,xe),C.setOptional(ze,r,"batchingColorTexture"),null!==r._colorsTexture&&C.setValue(ze,"batchingColorTexture",r._colorsTexture,xe));const D=n.morphAttributes;void 0===D.position&&void 0===D.normal&&void 0===D.color||Fe.update(r,n,x);(R||S.receiveShadow!==r.receiveShadow)&&(S.receiveShadow=r.receiveShadow,C.setValue(ze,"receiveShadow",r.receiveShadow));(i.isMeshStandardMaterial||i.isMeshLambertMaterial||i.isMeshPhongMaterial)&&null===i.envMap&&null!==t.environment&&(U.envMapIntensity.value=t.environmentIntensity);void 0!==U.dfgLUT&&(U.dfgLUT.value=(null===Ca&&(Ca=new Ln(ba,16,16,Se,E),Ca.name="DFG_LUT",Ca.minFilter=O,Ca.magFilter=O,Ca.wrapS=mt,Ca.wrapT=mt,Ca.generateMipmaps=!1,Ca.needsUpdate=!0),Ca));if(R){if(C.setValue(ze,"toneMappingExposure",G.toneMappingExposure),S.needsLights&&(N=b,(I=U).ambientLightColor.needsUpdate=N,I.lightProbe.needsUpdate=N,I.directionalLights.needsUpdate=N,I.directionalLightShadows.needsUpdate=N,I.pointLights.needsUpdate=N,I.pointLightShadows.needsUpdate=N,I.spotLights.needsUpdate=N,I.spotLightShadows.needsUpdate=N,I.rectAreaLights.needsUpdate=N,I.hemisphereLights.needsUpdate=N),a&&!0===i.fog&&De.refreshFogUniforms(U,a),De.refreshMaterialUniforms(U,i,te,ee,w.state.transmissionRenderTarget[e.id]),S.needsLights&&S.lightProbeGrid){const e=S.lightProbeGrid;U.probesSH.value=e.texture,U.probesMin.value.copy(e.boundingBox.min),U.probesMax.value.copy(e.boundingBox.max),U.probesResolution.value.copy(e.resolution)}Ar.upload(ze,lt(S),U,xe)}var I,N;i.isShaderMaterial&&!0===i.uniformsNeedUpdate&&(Ar.upload(ze,lt(S),U,xe),i.uniformsNeedUpdate=!1);i.isSpriteMaterial&&C.setValue(ze,"center",r.center);if(C.setValue(ze,"modelViewMatrix",r.modelViewMatrix),C.setValue(ze,"normalMatrix",r.normalMatrix),C.setValue(ze,"modelMatrix",r.matrixWorld),void 0!==i.uniformsGroups){const e=i.uniformsGroups;for(let t=0,n=e.length;t{function n(){i.forEach(function(e){Me.get(e).currentProgram.isReady()&&i.delete(e)}),0!==i.size?setTimeout(n,10):t(e)}null!==ge.get("KHR_parallel_shader_compile")?n():setTimeout(n,10)})};let Qe=null;function Je(){tt.stop()}function et(){tt.start()}const tt=new On;function nt(e,t,n,i){if(!1===e.visible)return;if(e.layers.test(t.layers))if(e.isGroup)n=e.renderOrder;else if(e.isLOD)!0===e.autoUpdate&&e.update(t);else if(e.isLightProbeGrid)w.pushLightProbeGrid(e);else if(e.isLight)w.pushLight(e),e.castShadow&&w.pushShadow(e);else if(e.isSprite){if(!e.frustumCulled||se.intersectsSprite(e)){i&&fe.setFromMatrixPosition(e.matrixWorld).applyMatrix4(de);const t=Ce.update(e),r=e.material;r.visible&&U.push(e,t,r,n,fe.z,null)}}else if((e.isMesh||e.isLine||e.isPoints)&&(!e.frustumCulled||se.intersectsObject(e))){const t=Ce.update(e),r=e.material;if(i&&(void 0!==e.boundingSphere?(null===e.boundingSphere&&e.computeBoundingSphere(),fe.copy(e.boundingSphere.center)):(null===t.boundingSphere&&t.computeBoundingSphere(),fe.copy(t.boundingSphere.center)),fe.applyMatrix4(e.matrixWorld).applyMatrix4(de)),Array.isArray(r)){const i=t.groups;for(let a=0,o=i.length;a0&&at(r,t,n),a.length>0&&at(a,t,n),o.length>0&&at(o,t,n),Ee.buffers.depth.setTest(!0),Ee.buffers.depth.setMask(!0),Ee.buffers.color.setMask(!0),Ee.setPolygonOffset(!1)}function rt(e,t,n,i){if(null!==(!0===n.isScene?n.overrideMaterial:null))return;if(void 0===w.state.transmissionRenderTarget[i.id]){const e=ge.has("EXT_color_buffer_half_float")||ge.has("EXT_color_buffer_float");w.state.transmissionRenderTarget[i.id]=new I(1,1,{generateMipmaps:!0,type:e?E:S,minFilter:B,samples:Math.max(4,ve.samples),stencilBuffer:o,resolveDepthBuffer:!1,resolveStencilBuffer:!1,colorSpace:f.workingColorSpace})}const r=w.state.transmissionRenderTarget[i.id],a=i.viewport||q;r.setSize(a.z*G.transmissionResolutionScale,a.w*G.transmissionResolutionScale);const s=G.getRenderTarget(),l=G.getActiveCubeFace(),d=G.getActiveMipmapLevel();G.setRenderTarget(r),G.getClearColor($),Q=G.getClearAlpha(),Q<1&&G.setClearColor(16777215,.5),G.clear(),me&&Oe.render(n);const u=G.toneMapping;G.toneMapping=L;const p=i.viewport;if(void 0!==i.viewport&&(i.viewport=void 0),w.setupLightsView(i),!0===le&&Ne.setGlobalState(G.clippingPlanes,i),at(e,n,i),xe.updateMultisampleRenderTarget(r),xe.updateRenderTargetMipmap(r),!1===ge.has("WEBGL_multisampled_render_to_texture")){let e=!1;for(let r=0,a=t.length;r0,i.currentProgram=u,i.uniformsList=null,u}function lt(e){if(null===e.uniformsList){const t=e.currentProgram.getUniforms();e.uniformsList=Ar.seqWithValue(t.seq,e.uniforms)}return e.uniformsList}function ct(e,t){const n=Me.get(e);n.outputColorSpace=t.outputColorSpace,n.batching=t.batching,n.batchingColor=t.batchingColor,n.instancing=t.instancing,n.instancingColor=t.instancingColor,n.instancingMorph=t.instancingMorph,n.skinning=t.skinning,n.morphTargets=t.morphTargets,n.morphNormals=t.morphNormals,n.morphColors=t.morphColors,n.morphTargetsCount=t.morphTargetsCount,n.numClippingPlanes=t.numClippingPlanes,n.numIntersection=t.numClipIntersection,n.vertexAlphas=t.vertexAlphas,n.vertexTangents=t.vertexTangents,n.toneMapping=t.toneMapping}tt.setAnimationLoop(function(e){Qe&&Qe(e)}),"undefined"!=typeof self&&tt.setContext(self),this.setAnimationLoop=function(e){Qe=e,Ke.setAnimationLoop(e),null===e?tt.stop():tt.start()},Ke.addEventListener("sessionstart",Je),Ke.addEventListener("sessionend",et),this.render=function(e,t){if(void 0!==t&&!0!==t.isCamera)return void D("WebGLRenderer.render: camera is not an instance of THREE.Camera.");if(!0===H)return;null!==V&&V.renderStart(e,t);const n=!0===Ke.enabled&&!0===Ke.isPresenting,i=null!==F&&(null===k||n)&&F.begin(G,k);if(!0===e.matrixWorldAutoUpdate&&e.updateMatrixWorld(),null===t.parent&&!0===t.matrixWorldAutoUpdate&&t.updateMatrixWorld(),!0!==Ke.enabled||!0!==Ke.isPresenting||null!==F&&!1!==F.isCompositing()||(!0===Ke.cameraAutoUpdate&&Ke.updateCamera(t),t=Ke.getCamera()),!0===e.isScene&&e.onBeforeRender(G,e,t,k),w=Ie.get(e,y.length),w.init(t),w.state.textureUnits=xe.getTextureUnits(),y.push(w),de.multiplyMatrices(t.projectionMatrix,t.matrixWorldInverse),se.setFromProjectionMatrix(de,Nn,t.reversedDepth),ce=this.localClippingEnabled,le=Ne.init(this.clippingPlanes,ce),U=we.get(e,N.length),U.init(),N.push(U),!0===Ke.enabled&&!0===Ke.isPresenting){const e=G.xr.getDepthSensingMesh();null!==e&&nt(e,t,-1/0,G.sortObjects)}nt(e,t,0,G.sortObjects),U.finish(),!0===G.sortObjects&&U.sort(ne,ie),me=!1===Ke.enabled||!1===Ke.isPresenting||!1===Ke.hasDepthSensing(),me&&Oe.addToRenderList(U,e),this.info.render.frame++,!0===le&&Ne.beginShadows();const r=w.state.shadowsArray;ye.render(r,e,t),!0===le&&Ne.endShadows(),!0===this.info.autoReset&&this.info.reset();if(!1===(i&&F.hasRenderPass())){const n=U.opaque,i=U.transmissive;if(w.setupLights(),t.isArrayCamera){const r=t.cameras;if(i.length>0)for(let t=0,a=r.length;t0&&rt(n,i,e,t),me&&Oe.render(e),it(U,e,t)}null!==k&&0===z&&(xe.updateMultisampleRenderTarget(k),xe.updateRenderTargetMipmap(k)),i&&F.end(G),!0===e.isScene&&e.onAfterRender(G,e,t),Ve.resetDefaultState(),X=-1,Y=null,y.pop(),y.length>0?(w=y[y.length-1],xe.setTextureUnits(w.state.textureUnits),!0===le&&Ne.setGlobalState(G.clippingPlanes,w.state.camera)):w=null,N.pop(),U=N.length>0?N[N.length-1]:null,null!==V&&V.renderEnd()},this.getActiveCubeFace=function(){return W},this.getActiveMipmapLevel=function(){return z},this.getRenderTarget=function(){return k},this.setRenderTargetTextures=function(e,t,n){const i=Me.get(e);i.__autoAllocateDepthBuffer=!1===e.resolveDepthBuffer,!1===i.__autoAllocateDepthBuffer&&(i.__useRenderToTexture=!1),Me.get(e.texture).__webglTexture=t,Me.get(e.depthTexture).__webglTexture=i.__autoAllocateDepthBuffer?void 0:n,i.__hasExternalTextures=!0},this.setRenderTargetFramebuffer=function(e,t){const n=Me.get(e);n.__webglFramebuffer=t,n.__useDefaultFramebuffer=void 0===t};const dt=ze.createFramebuffer();this.setRenderTarget=function(e,t=0,n=0){k=e,W=t,z=n;let i=null,r=!1,a=!1;if(e){const o=Me.get(e);if(void 0!==o.__useDefaultFramebuffer)return Ee.bindFramebuffer(ze.FRAMEBUFFER,o.__webglFramebuffer),q.copy(e.viewport),j.copy(e.scissor),Z=e.scissorTest,Ee.viewport(q),Ee.scissor(j),Ee.setScissorTest(Z),void(X=-1);if(void 0===o.__webglFramebuffer)xe.setupRenderTarget(e);else if(o.__hasExternalTextures)xe.rebindTextures(e,Me.get(e.texture).__webglTexture,Me.get(e.depthTexture).__webglTexture);else if(e.depthBuffer){const t=e.depthTexture;if(o.__boundDepthTexture!==t){if(null!==t&&Me.has(t)&&(e.width!==t.image.width||e.height!==t.image.height))throw new Error("WebGLRenderTarget: Attached DepthTexture is initialized to the incorrect size.");xe.setupDepthRenderbuffer(e)}}const s=e.texture;(s.isData3DTexture||s.isDataArrayTexture||s.isCompressedArrayTexture)&&(a=!0);const l=Me.get(e).__webglFramebuffer;e.isWebGLCubeRenderTarget?(i=Array.isArray(l[t])?l[t][n]:l[t],r=!0):i=e.samples>0&&!1===xe.useMultisampledRTT(e)?Me.get(e).__webglMultisampledFramebuffer:Array.isArray(l)?l[n]:l,q.copy(e.viewport),j.copy(e.scissor),Z=e.scissorTest}else q.copy(re).multiplyScalar(te).floor(),j.copy(ae).multiplyScalar(te).floor(),Z=oe;0!==n&&(i=dt);if(Ee.bindFramebuffer(ze.FRAMEBUFFER,i)&&Ee.drawBuffers(e,i),Ee.viewport(q),Ee.scissor(j),Ee.setScissorTest(Z),r){const i=Me.get(e.texture);ze.framebufferTexture2D(ze.FRAMEBUFFER,ze.COLOR_ATTACHMENT0,ze.TEXTURE_CUBE_MAP_POSITIVE_X+t,i.__webglTexture,n)}else if(a){const i=t;for(let t=0;t1&&ze.readBuffer(ze.COLOR_ATTACHMENT0+s),!ve.textureFormatReadable(l))return void D("WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");if(!ve.textureTypeReadable(c))return void D("WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");t>=0&&t<=e.width-i&&n>=0&&n<=e.height-r&&ze.readPixels(t,n,i,r,He.convert(l),He.convert(c),a)}finally{const e=null!==k?Me.get(k).__webglFramebuffer:null;Ee.bindFramebuffer(ze.FRAMEBUFFER,e)}}},this.readRenderTargetPixelsAsync=async function(e,t,n,i,r,a,o,s=0){if(!e||!e.isWebGLRenderTarget)throw new Error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let l=Me.get(e).__webglFramebuffer;if(e.isWebGLCubeRenderTarget&&void 0!==o&&(l=l[o]),l){if(t>=0&&t<=e.width-i&&n>=0&&n<=e.height-r){Ee.bindFramebuffer(ze.FRAMEBUFFER,l);const o=e.textures[s],c=o.format,d=o.type;if(e.textures.length>1&&ze.readBuffer(ze.COLOR_ATTACHMENT0+s),!ve.textureFormatReadable(c))throw new Error("THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in RGBA or implementation defined format.");if(!ve.textureTypeReadable(d))throw new Error("THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in UnsignedByteType or implementation defined type.");const u=ze.createBuffer();ze.bindBuffer(ze.PIXEL_PACK_BUFFER,u),ze.bufferData(ze.PIXEL_PACK_BUFFER,a.byteLength,ze.STREAM_READ),ze.readPixels(t,n,i,r,He.convert(c),He.convert(d),0);const f=null!==k?Me.get(k).__webglFramebuffer:null;Ee.bindFramebuffer(ze.FRAMEBUFFER,f);const p=ze.fenceSync(ze.SYNC_GPU_COMMANDS_COMPLETE,0);return ze.flush(),await yn(ze,p,4),ze.bindBuffer(ze.PIXEL_PACK_BUFFER,u),ze.getBufferSubData(ze.PIXEL_PACK_BUFFER,0,a),ze.deleteBuffer(u),ze.deleteSync(p),a}throw new Error("THREE.WebGLRenderer.readRenderTargetPixelsAsync: requested read bounds are out of range.")}},this.copyFramebufferToTexture=function(e,t=null,n=0){const i=Math.pow(2,-n),r=Math.floor(e.image.width*i),a=Math.floor(e.image.height*i),o=null!==t?t.x:0,s=null!==t?t.y:0;xe.setTexture2D(e,0),ze.copyTexSubImage2D(ze.TEXTURE_2D,n,0,0,o,s,r,a),Ee.unbindTexture()};const ut=ze.createFramebuffer(),ft=ze.createFramebuffer();this.copyTextureToTexture=function(e,t,n=null,i=null,r=0,a=0){let o,s,l,c,d,u,f,p,m;const h=e.isCompressedTexture?e.mipmaps[a]:e.image;if(null!==n)o=n.max.x-n.min.x,s=n.max.y-n.min.y,l=n.isBox3?n.max.z-n.min.z:1,c=n.min.x,d=n.min.y,u=n.isBox3?n.min.z:0;else{const t=Math.pow(2,-r);o=Math.floor(h.width*t),s=Math.floor(h.height*t),l=e.isDataArrayTexture?h.depth:e.isData3DTexture?Math.floor(h.depth*t):1,c=0,d=0,u=0}null!==i?(f=i.x,p=i.y,m=i.z):(f=0,p=0,m=0);const _=He.convert(t.format),g=He.convert(t.type);let v;t.isData3DTexture?(xe.setTexture3D(t,0),v=ze.TEXTURE_3D):t.isDataArrayTexture||t.isCompressedArrayTexture?(xe.setTexture2DArray(t,0),v=ze.TEXTURE_2D_ARRAY):(xe.setTexture2D(t,0),v=ze.TEXTURE_2D),Ee.activeTexture(ze.TEXTURE0),Ee.pixelStorei(ze.UNPACK_FLIP_Y_WEBGL,t.flipY),Ee.pixelStorei(ze.UNPACK_PREMULTIPLY_ALPHA_WEBGL,t.premultiplyAlpha),Ee.pixelStorei(ze.UNPACK_ALIGNMENT,t.unpackAlignment);const E=Ee.getParameter(ze.UNPACK_ROW_LENGTH),S=Ee.getParameter(ze.UNPACK_IMAGE_HEIGHT),T=Ee.getParameter(ze.UNPACK_SKIP_PIXELS),M=Ee.getParameter(ze.UNPACK_SKIP_ROWS),x=Ee.getParameter(ze.UNPACK_SKIP_IMAGES);Ee.pixelStorei(ze.UNPACK_ROW_LENGTH,h.width),Ee.pixelStorei(ze.UNPACK_IMAGE_HEIGHT,h.height),Ee.pixelStorei(ze.UNPACK_SKIP_PIXELS,c),Ee.pixelStorei(ze.UNPACK_SKIP_ROWS,d),Ee.pixelStorei(ze.UNPACK_SKIP_IMAGES,u);const A=e.isDataArrayTexture||e.isData3DTexture,R=t.isDataArrayTexture||t.isData3DTexture;if(e.isDepthTexture){const n=Me.get(e),i=Me.get(t),h=Me.get(n.__renderTarget),_=Me.get(i.__renderTarget);Ee.bindFramebuffer(ze.READ_FRAMEBUFFER,h.__webglFramebuffer),Ee.bindFramebuffer(ze.DRAW_FRAMEBUFFER,_.__webglFramebuffer);for(let n=0;n + + +
@@ -183,13 +193,6 @@
-
- - -
@@ -207,34 +210,49 @@ -