diff --git a/.github/workflows/check-notebooks.yml b/.github/workflows/check-notebooks.yml index 1b7a009..d0ef8b9 100644 --- a/.github/workflows/check-notebooks.yml +++ b/.github/workflows/check-notebooks.yml @@ -1,4 +1,4 @@ -name: Check C++ Notebooks +name: CI on: push: @@ -6,13 +6,12 @@ on: workflow_dispatch: jobs: - execute-notebooks: - name: Execute C++ Notebooks + execute-notebooks-cpp: + name: C++ runs-on: ubuntu-latest defaults: run: shell: bash -el {0} - steps: - name: Checkout repository uses: actions/checkout@v4 @@ -29,7 +28,7 @@ jobs: - name: Run C++ Tests via Pytest run: | mkdir -p executed - $CONDA_PREFIX/bin/pytest tests/test_notebooks.py -sv + $CONDA_PREFIX/bin/pytest tests/test_notebooks.py::CppNotebookTests -sv - name: Upload executed notebooks as artifact if: always() @@ -38,3 +37,88 @@ jobs: name: executed-cpp-notebooks path: executed/ if-no-files-found: ignore + + execute-notebooks-openmp: + name: OpenMP + runs-on: ubuntu-latest + defaults: + run: + shell: bash -el {0} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Set up micromamba environment + uses: mamba-org/setup-micromamba@v2 + with: + environment-file: environment.yml + cache-environment: true + + - name: List available kernels + run: jupyter kernelspec list + + - name: Run OpenMP notebook tests + run: | + mkdir -p executed + + # Force OpenMP to spawn 8 threads to match your reference .ipynb files + export OMP_NUM_THREADS=8 + + LD_PRELOAD="$CONDA_PREFIX/lib/libomp.so" \ + $CONDA_PREFIX/bin/pytest tests/test_notebooks.py::OpenMPNotebookTests -sv + + - name: Upload executed OpenMP notebooks as artifact + if: always() + uses: actions/upload-artifact@v4 + with: + name: executed-openmp-notebooks + path: executed/ + if-no-files-found: ignore + + prepare-dell: + runs-on: [self-hosted, spotter] + steps: + - uses: compiler-research/ci-workflows/actions/wake-on-lan@main + with: + mac: a4:bb:6d:51:d5:d2 + target-host: 192.168.100.30 + + execute-notebooks-cuda: + name: CUDA + needs: prepare-dell + runs-on: [self-hosted, cuda] + defaults: + run: + shell: bash -el {0} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Set up micromamba environment + run: | + /root/micromamba-bin/micromamba create -n livecpp-ci -f environment.yml --yes + echo "CONDA_PREFIX=/root/.local/share/mamba/envs/livecpp-ci" >> $GITHUB_ENV + + - name: Install CUDA kernel + run: | + cp -r $CONDA_PREFIX/share/jupyter/kernels/xcpp23 $CONDA_PREFIX/share/jupyter/kernels/xcpp23-cuda + python3 -c " + import json + with open('$CONDA_PREFIX/share/jupyter/kernels/xcpp23-cuda/kernel.json') as f: + k = json.load(f) + k['argv'] += ['--cuda', '--cuda-path=$CONDA_PREFIX/targets/x86_64-linux'] + with open('$CONDA_PREFIX/share/jupyter/kernels/xcpp23-cuda/kernel.json', 'w') as f: + json.dump(k, f, indent=2) + " + + - name: Run CUDA Tests via Pytest + run: | + mkdir -p executed + $CONDA_PREFIX/bin/pytest tests/test_notebooks.py::CudaNotebookTests -sv + + - name: Upload executed notebooks as artifact + if: always() + uses: actions/upload-artifact@v4 + with: + name: executed-cuda-notebooks + path: executed/ + if-no-files-found: ignore diff --git a/cuda/01_Intoduction-to-cuda.ipynb b/cuda/01_Intoduction-to-cuda.ipynb new file mode 100644 index 0000000..912f8ad --- /dev/null +++ b/cuda/01_Intoduction-to-cuda.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "a", + "metadata": {}, + "source": [ + "# Introduction to CUDA\n", + "\n", + "CUDA lets you run code directly on the GPU by writing special functions called **kernels**.\n", + "This notebook walks through the simplest possible examples to get you comfortable with the\n", + "three things every CUDA program has to do:\n", + "\n", + "1. Move data onto the GPU\n", + "2. Launch a kernel to process it\n", + "3. Move the result back to the CPU\n", + "\n", + "**Some examples in this series are inspired by concepts from CUDA by Example by Jason Sanders and Edward Kandrot. [Link to the book](https://books.google.bg/books?id=Om8JRAAACAAJ&redir_esc=y)**\n", + "\n", + "---\n", + "\n", + "## Part 1 — Adding two numbers on the GPU\n", + "\n", + "The `__global__` keyword tells the compiler that this function runs on the GPU but is called from the CPU.\n", + "The result can't be returned normally, so we write it through a pointer that lives in GPU memory." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bf2ceb5e", + "metadata": {}, + "outputs": [], + "source": [ + "__global__ void gpu_add(int a, int b, int *result) {\n", + " *result = a + b;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "df01c907", + "metadata": {}, + "source": [ + "To call it we use the `<<>>` launch syntax — `<<<1,1>>>` means one block,\n", + "one thread. Before the call we need a place in GPU memory to hold the answer, which we get\n", + "with `cudaMalloc`. After the kernel finishes we pull the value back with `cudaMemcpy`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dce266d8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 + 9 = 14\n" + ] + } + ], + "source": [ + "#include \n", + "\n", + "int host_result;\n", + "int *dev_result;\n", + "\n", + "cudaMalloc((void**)&dev_result, sizeof(int));\n", + "\n", + "gpu_add<<<1, 1>>>(5, 9, dev_result);\n", + "\n", + "cudaMemcpy(&host_result, dev_result, sizeof(int), cudaMemcpyDeviceToHost);\n", + "\n", + "printf(\"5 + 9 = %d\\n\", host_result);\n", + "cudaFree(dev_result);" + ] + }, + { + "cell_type": "markdown", + "id": "e67df804", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Part 2 — Adding two arrays in parallel\n", + "\n", + "A single GPU thread is no faster than the CPU. The power comes from launching **many threads at once**,\n", + "each one handling one element independently.\n", + "\n", + "Below, the kernel adds a single pair of elements. The index it operates on comes from\n", + "`blockIdx.x` — the block number — so launching N blocks gives us N simultaneous additions.\n", + "\n", + "![Vector_Add_Model](images/vectoradd.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "92148462", + "metadata": {}, + "outputs": [], + "source": [ + "#define N 10\n", + "\n", + "__global__ void add_vectors(int *a, int *b, int *c) {\n", + " int i = blockIdx.x; // each block handles one element\n", + " if (i < N)\n", + " c[i] = a[i] + b[i];\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "458bea36", + "metadata": {}, + "source": [ + "We allocate three arrays on the GPU, copy the inputs across, launch `N` blocks, then bring\n", + "the result back." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "93d16f4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 + 0 = 0\n", + "1 + 1 = 2\n", + "2 + 4 = 6\n", + "3 + 9 = 12\n", + "4 + 16 = 20\n", + "5 + 25 = 30\n", + "6 + 36 = 42\n", + "7 + 49 = 56\n", + "8 + 64 = 72\n", + "9 + 81 = 90\n" + ] + } + ], + "source": [ + "int h_in1[N], h_in2[N], h_out[N];\n", + "int *d_in1, *d_in2, *d_out;\n", + "\n", + "cudaMalloc((void**)&d_in1, N * sizeof(int));\n", + "cudaMalloc((void**)&d_in2, N * sizeof(int));\n", + "cudaMalloc((void**)&d_out, N * sizeof(int));\n", + "\n", + "for (int i = 0; i < N; i++) {\n", + " h_in1[i] = i;\n", + " h_in2[i] = i * i;\n", + "}\n", + "\n", + "cudaMemcpy(d_in1, h_in1, N * sizeof(int), cudaMemcpyHostToDevice);\n", + "cudaMemcpy(d_in2, h_in2, N * sizeof(int), cudaMemcpyHostToDevice);\n", + "\n", + "add_vectors<<>>(d_in1, d_in2, d_out);\n", + "\n", + "cudaMemcpy(h_out, d_out, N * sizeof(int), cudaMemcpyDeviceToHost);\n", + "\n", + "for (int i = 0; i < N; i++)\n", + " printf(\"%d + %d = %d\\n\", h_in1[i], h_in2[i], h_out[i]);\n", + "\n", + "cudaFree(d_in1);\n", + "cudaFree(d_in2);\n", + "cudaFree(d_out);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/02_CUDA_Fundamentals.ipynb b/cuda/02_CUDA_Fundamentals.ipynb new file mode 100644 index 0000000..4aad7cf --- /dev/null +++ b/cuda/02_CUDA_Fundamentals.ipynb @@ -0,0 +1,678 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "b2c3d4e5-f6a7-8901-bcde-f12345678901", + "metadata": {}, + "source": [ + "# CUDA Fundamentals\n", + "\n", + "This notebook covers the core concepts that sit underneath everything else in CUDA. You have already written kernels, allocated memory, and launched threads — now we are going to understand *why* those things work the way they do.\n", + "\n", + "We will cover:\n", + "- The GPU memory hierarchy and what each type of memory actually is\n", + "- Why memory access patterns matter enormously for performance (coalescing)\n", + "- What a warp is and how the GPU actually schedules work\n", + "- Thread divergence and why it costs you performance\n", + "- Occupancy — how full your GPU actually is when a kernel runs\n", + "- Error checking, which you should be doing on every CUDA call\n", + "\n", + "## 1. The Memory Hierarchy\n", + "\n", + "The GPU has several distinct types of memory, each with different speed and scope. Getting this wrong is the single most common reason CUDA code is slow.\n", + "\n", + "| Memory Type | Location | Speed | Scope | Lifetime |\n", + "|---|---|---|---|---|\n", + "| **Registers** | On-chip | Fastest | Single thread | Thread |\n", + "| **Shared** | On-chip | Very fast | All threads in a block | Block |\n", + "| **Local** | Off-chip (DRAM) | Slow | Single thread | Thread |\n", + "| **Global** | Off-chip (DRAM) | Slow | All threads, all blocks | Application |\n", + "| **Constant** | Off-chip, cached | Fast for reads | All threads, read-only | Application |\n", + "\n", + "Everything you have been calling `cudaMalloc` for lives in **global memory** — the large, slow VRAM on the card. Shared memory is the small, fast scratchpad that threads in the same block can use to cooperate, which is what you saw in the dot product notebook.\n", + "\n", + "**Local memory** sounds like it would be fast, but it is not. It is just the name given to register spill — when a thread runs out of registers, the compiler moves variables to DRAM and calls it local memory. You generally want to avoid it.\n", + "\n", + "### Constant Memory\n", + "\n", + "The new syntax here is `__constant__`. It declares a variable in constant memory — a small (64KB) read-only cache that is very fast when all threads in a warp read the same address simultaneously.\n", + "\n", + "Here we write a value into constant memory from the host and then read it from a kernel. Notice that threads never pass it as a parameter — they just reference the global symbol directly." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a676dbca-5175-4077-929f-a24fcd46844b", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "\n", + "\n", + "__constant__ float d_scale;\n", + "\n", + "__global__ void set_constant(float val) {\n", + " d_scale = val;\n", + "}\n", + "\n", + "__global__ void scale_kernel(float* output, int n) {\n", + " int tid = threadIdx.x;\n", + " if (tid < n) {\n", + " output[tid] = (float)tid * d_scale;\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5eb42afa-dace-4e53-88b0-c7e525cba80e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 0: 0.00\n", + "Index 1: 2.50\n", + "Index 2: 5.00\n", + "Index 3: 7.50\n", + "Index 4: 10.00\n", + "Index 5: 12.50\n", + "Index 6: 15.00\n", + "Index 7: 17.50\n" + ] + } + ], + "source": [ + "void run_example() {\n", + " const int N = 8;\n", + " float h_out[N];\n", + " float* d_out;\n", + " float val_to_set = 2.5f;\n", + "\n", + " cudaMalloc(&d_out, N * sizeof(float));\n", + "\n", + " // INSTEAD of cudaMemcpyToSymbol (which is failing),\n", + " // we launch a 1-thread kernel to set the value.\n", + " set_constant<<<1, 1>>>(val_to_set);\n", + " cudaDeviceSynchronize(); \n", + "\n", + " // Now d_scale is set! Launch the work kernel.\n", + " scale_kernel<<<1, N>>>(d_out, N);\n", + " cudaDeviceSynchronize();\n", + "\n", + " cudaMemcpy(h_out, d_out, N * sizeof(float), cudaMemcpyDeviceToHost);\n", + "\n", + " for (int i = 0; i < N; i++) {\n", + " printf(\"Index %d: %.2f\\n\", i, h_out[i]);\n", + " }\n", + "\n", + " cudaFree(d_out);\n", + "}\n", + "\n", + "run_example();" + ] + }, + { + "cell_type": "markdown", + "id": "b8c9d0e1-f2a3-4567-bcde-678901234567", + "metadata": {}, + "source": [ + "## 2. Memory Coalescing\n", + "\n", + "Global memory is slow, but *how* you access it matters just as much as *how often* you access it. The GPU does not load individual bytes — it loads memory in 128-byte transactions. If threads in a warp access consecutive addresses, they all get served by a single transaction. If they access scattered addresses, each one may require its own transaction.\n", + "\n", + "This is called **coalescing**.\n", + "\n", + "**Coalesced (fast):** Thread 0 reads index 0, Thread 1 reads index 1, Thread 2 reads index 2 ... all 32 threads get their data in one transaction.\n", + "\n", + "**Uncoalesced (slow):** Thread 0 reads index 0, Thread 1 reads index 32, Thread 2 reads index 64 ... each thread triggers its own transaction. 32x more memory bandwidth used.\n", + "\n", + "The rule is simple: **threads with adjacent IDs should access adjacent memory addresses.**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c9d0e1f2-a3b4-5678-cdef-789012345678", + "metadata": {}, + "outputs": [], + "source": [ + "#define SIZE (1 << 22)\n", + "\n", + "// COALESCED: thread i reads element i — adjacent threads, adjacent addresses.\n", + "__global__ void coalesced_read(float* in, float* out, int n) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (tid < n)\n", + " out[tid] = in[tid] * 2.0f;\n", + "}\n", + "\n", + "// UNCOALESCED: thread i reads element i * 32 — adjacent threads, scattered addresses.\n", + "__global__ void uncoalesced_read(float* in, float* out, int n) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " int scattered = (tid * 32) % n;\n", + " if (tid < n)\n", + " out[tid] = in[scattered] * 2.0f;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0e1f2a3-b4c5-6789-defa-890123456789", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coalesced: 0.560 ms\n", + "Uncoalesced: 2.806 ms\n", + "Slowdown: 5.01x\n" + ] + } + ], + "source": [ + "float *d_in, *d_out;\n", + "cudaMalloc(&d_in, SIZE * sizeof(float));\n", + "cudaMalloc(&d_out, SIZE * sizeof(float));\n", + "cudaMemset(d_in, 0x3f, SIZE * sizeof(float));\n", + "\n", + "int threads = 256;\n", + "int blocks = (SIZE + threads - 1) / threads;\n", + "\n", + "cudaEvent_t start, stop;\n", + "cudaEventCreate(&start);\n", + "cudaEventCreate(&stop);\n", + "float t_coalesced, t_uncoalesced;\n", + "\n", + "// Warm up\n", + "coalesced_read<<>>(d_in, d_out, SIZE);\n", + "cudaDeviceSynchronize();\n", + "\n", + "cudaEventRecord(start);\n", + "coalesced_read<<>>(d_in, d_out, SIZE);\n", + "cudaEventRecord(stop);\n", + "cudaEventSynchronize(stop);\n", + "cudaEventElapsedTime(&t_coalesced, start, stop);\n", + "\n", + "cudaEventRecord(start);\n", + "uncoalesced_read<<>>(d_in, d_out, SIZE);\n", + "cudaEventRecord(stop);\n", + "cudaEventSynchronize(stop);\n", + "cudaEventElapsedTime(&t_uncoalesced, start, stop);\n", + "\n", + "printf(\"Coalesced: %.3f ms\\n\", t_coalesced);\n", + "printf(\"Uncoalesced: %.3f ms\\n\", t_uncoalesced);\n", + "printf(\"Slowdown: %.2fx\\n\", t_uncoalesced / t_coalesced);\n", + "\n", + "cudaEventDestroy(start);\n", + "cudaEventDestroy(stop);\n", + "cudaFree(d_in);\n", + "cudaFree(d_out);" + ] + }, + { + "cell_type": "markdown", + "id": "e1f2a3b4-c5d6-7890-efab-901234567890", + "metadata": {}, + "source": [ + "## 3. Warps\n", + "\n", + "You launch threads in blocks, but the GPU does not actually execute threads one at a time, or even one block at a time. The hardware groups 32 threads together into a unit called a **warp**, and all 32 threads in a warp execute the same instruction in lockstep.\n", + "\n", + "This is SIMT — Single Instruction, Multiple Threads.\n", + "\n", + "Key facts:\n", + "- A warp is always **32 threads**\n", + "- Threads 0–31 form warp 0, threads 32–63 form warp 1, and so on\n", + "- The SM (Streaming Multiprocessor) is the physical unit that runs warps\n", + "- When one warp is waiting on memory, the SM switches to another warp — this is how the GPU hides memory latency\n", + "\n", + "The warp is why your block sizes should always be **multiples of 32**. If you launch 33 threads in a block, you get 2 warps, but the second warp has 31 idle threads — wasted hardware." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "08e487eb-648b-43ce-9f14-643e98adb0b1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Block size 33: 2 warps (31 idle threads in last warp)\n", + "Block size 32: 1 warp (0 idle threads in last warp)\n", + "Block size 256: 8 warps (0 idle threads in last warp)\n" + ] + } + ], + "source": [ + "// This kernel identifies which warp each thread belongs to.\n", + "// threadIdx.x / 32 gives the warp index within a block.\n", + "__global__ void warp_info() {\n", + " int tid = threadIdx.x;\n", + " int warp_id = tid / 32;\n", + " int lane = tid % 32; // position within the warp (0-31)\n", + " \n", + " // Only the first lane of each warp prints\n", + " if (lane == 0)\n", + " printf(\" Warp %d starts at thread %d\\n\", warp_id, tid);\n", + "}\n", + "\n", + "for (int bs : {33, 32, 256}) {\n", + " int warps = (bs + 31) / 32;\n", + " int wasted = warps * 32 - bs;\n", + " printf(\"Block size %d: %d warp%s (%d idle threads in last warp)\\n\",\n", + " bs, warps, warps == 1 ? \" \" : \"s\", wasted);\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "a3b4c5d6-e7f8-9012-abcd-123456789012", + "metadata": {}, + "source": [ + "## 4. Thread Divergence\n", + "\n", + "Because all 32 threads in a warp execute the same instruction, **branching within a warp is expensive**.\n", + "\n", + "If an `if` statement causes some threads in a warp to take one path and others to take a different path, the GPU serializes them. It runs the first path with some threads active and the rest masked off, then runs the second path in reverse. Both paths take time even though each thread only needs one.\n", + "\n", + "This is called **warp divergence**.\n", + "\n", + "```\n", + "// BAD: threads 0-15 go one way, threads 16-31 go another.\n", + "// The entire warp runs BOTH branches, serialized.\n", + "if (threadIdx.x < 16) {\n", + " do_path_A(); // runs with threads 16-31 masked off\n", + "} else {\n", + " do_path_B(); // runs with threads 0-15 masked off\n", + "}\n", + "\n", + "// FINE: entire warps of 32 agree on which path to take\n", + "if (blockIdx.x % 2 == 0) {\n", + " do_path_A();\n", + "} else {\n", + " do_path_B();\n", + "}\n", + "```\n", + "\n", + "The key question to ask is: **do threads within the same warp ever disagree on which branch to take?**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1b172623-f9c3-4f09-a8af-7d06a6859db3", + "metadata": {}, + "outputs": [], + "source": [ + "#define DIV_SIZE (1 << 22)\n", + "\n", + "// NO DIVERGENCE: branch is on blockIdx, so entire blocks (and warps) agree\n", + "__global__ void no_divergence(float* data, int n) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (tid >= n) return;\n", + " if (blockIdx.x % 2 == 0) {\n", + " for(int i=0; i<200; i++) data[tid] = data[tid] * 1.0001f + 0.1f;\n", + " } else {\n", + " for(int i=0; i<200; i++) data[tid] = data[tid] * 0.9999f - 0.1f;\n", + " }\n", + "}\n", + "\n", + "// WITH DIVERGENCE: branch is on threadIdx, so within each warp,\n", + "// odd and even threads go different ways\n", + "__global__ void with_divergence(float* data, int n) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (tid >= n) return;\n", + " if (threadIdx.x % 2 == 0) {\n", + " for(int i=0; i<200; i++) data[tid] = data[tid] * 1.0001f + 0.1f;\n", + " } else {\n", + " for(int i=0; i<200; i++) data[tid] = data[tid] * 0.9999f - 0.1f;\n", + "}\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b4c5d6e7-f8a9-0123-bcde-234567890123", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Check value (prevents optimization): 62.626938\n", + "No divergence: 24.006 ms\n", + "With divergence: 57.509 ms\n", + "Overhead: 2.40x\n" + ] + } + ], + "source": [ + "float* d_data;\n", + "cudaMalloc(&d_data, DIV_SIZE * sizeof(float));\n", + "cudaMemset(d_data, 0x3f, DIV_SIZE * sizeof(float));\n", + "\n", + "int t2 = 256;\n", + "int b2 = (DIV_SIZE + t2 - 1) / t2;\n", + "\n", + "cudaEvent_t s2, e2;\n", + "cudaEventCreate(&s2);\n", + "cudaEventCreate(&e2);\n", + "float t_nodiv, t_div;\n", + "\n", + "// 1. Warm-up (important!)\n", + "no_divergence<<>>(d_data, DIV_SIZE);\n", + "cudaDeviceSynchronize();\n", + "\n", + "// 2. Time No Divergence\n", + "cudaEventRecord(s2);\n", + "no_divergence<<>>(d_data, DIV_SIZE);\n", + "cudaEventRecord(e2);\n", + "cudaEventSynchronize(e2); // Force the CPU to wait here!\n", + "cudaEventElapsedTime(&t_nodiv, s2, e2);\n", + "\n", + "// 3. Time With Divergence\n", + "cudaEventRecord(s2);\n", + "with_divergence<<>>(d_data, DIV_SIZE);\n", + "cudaEventRecord(e2);\n", + "cudaEventSynchronize(e2); // Force the CPU to wait here!\n", + "cudaEventElapsedTime(&t_div, s2, e2);\n", + "\n", + "// 4. Force the compiler to keep the math\n", + "float check;\n", + "cudaMemcpy(&check, d_data, sizeof(float), cudaMemcpyDeviceToHost);\n", + "printf(\"Check value (prevents optimization): %f\\n\", check);\n", + "\n", + "printf(\"No divergence: %.3f ms\\n\", t_nodiv);\n", + "printf(\"With divergence: %.3f ms\\n\", t_div);\n", + "printf(\"Overhead: %.2fx\\n\", t_div / t_nodiv);" + ] + }, + { + "cell_type": "markdown", + "id": "c5d6e7f8-a9b0-1234-cdef-345678901234", + "metadata": {}, + "source": [ + "## 5. Occupancy\n", + "\n", + "**Occupancy** is the ratio of active warps on an SM to the maximum number of warps that SM can hold. Higher occupancy means more warps available to hide memory latency.\n", + "\n", + "Three things limit how many warps an SM can run simultaneously:\n", + "1. **Registers** — each thread uses some number of registers. More registers per thread means fewer warps fit.\n", + "2. **Shared memory** — if your kernel allocates a lot of shared memory per block, fewer blocks fit per SM.\n", + "3. **Block size** — there is a maximum number of threads per SM.\n", + "\n", + "You can query all of your GPU's limits at runtime with `cudaGetDeviceProperties`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d6e7f8a9-b0c1-2345-defa-456789012345", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPU: NVIDIA GeForce GTX 1650\n", + "Streaming Multiprocessors: 16\n", + "Max threads per SM: 1024\n", + "Max warps per SM: 32\n", + "Max threads per block: 1024\n", + "Max shared memory per block: 49152 bytes (48 KB)\n", + "Warp size: 32\n", + "Registers per SM: 65536\n" + ] + } + ], + "source": [ + "cudaDeviceProp props;\n", + "cudaGetDeviceProperties(&props, 0);\n", + "\n", + "printf(\"GPU: %s\\n\", props.name);\n", + "printf(\"Streaming Multiprocessors: %d\\n\", props.multiProcessorCount);\n", + "printf(\"Max threads per SM: %d\\n\", props.maxThreadsPerMultiProcessor);\n", + "printf(\"Max warps per SM: %d\\n\", props.maxThreadsPerMultiProcessor / props.warpSize);\n", + "printf(\"Max threads per block: %d\\n\", props.maxThreadsPerBlock);\n", + "printf(\"Max shared memory per block: %zu bytes (%zu KB)\\n\",\n", + " props.sharedMemPerBlock, props.sharedMemPerBlock / 1024);\n", + "printf(\"Warp size: %d\\n\", props.warpSize);\n", + "printf(\"Registers per SM: %d\\n\", props.regsPerMultiprocessor);" + ] + }, + { + "cell_type": "markdown", + "id": "4f5b6b72-38f4-4779-9025-a24709f89cb1", + "metadata": {}, + "source": [ + "## 6. Error Checking\n", + "\n", + "Every CUDA function returns a `cudaError_t`. Almost nobody checks these in tutorial code, but in real code you absolutely should — a silently failing `cudaMalloc` or `cudaMemcpy` gives you garbage results with no indication of why." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f2594ae8-308a-4b7d-8a01-452ee584960a", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "\n", + "#define CUDA_CHECK(call) \\\n", + " do { \\\n", + " cudaError_t err = (call); \\\n", + " if (err != cudaSuccess) { \\\n", + " fprintf(stderr, \"CUDA error at %s:%d — %s\\n\", \\\n", + " __FILE__, __LINE__, cudaGetErrorString(err)); \\\n", + " } \\\n", + " } while (0)\n", + "\n", + "__global__ void double_array(int* data, int n) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (tid < n)\n", + " data[tid] *= 2;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "98814be7-8d40-43d3-abb7-9a7dae800af4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All CUDA calls succeeded.\n", + "result[0] = 0, result[1] = 2, result[2] = 4\n" + ] + } + ], + "source": [ + "const int M = 8;\n", + "int h_data[M] = {0, 1, 2, 3, 4, 5, 6, 7};\n", + "int* d_data2;\n", + "\n", + "CUDA_CHECK(cudaMalloc(&d_data2, M * sizeof(int)));\n", + "CUDA_CHECK(cudaMemcpy(d_data2, h_data, M * sizeof(int), cudaMemcpyHostToDevice));\n", + "\n", + "double_array<<<1, M>>>(d_data2, M);\n", + "\n", + "// Check for errors in the launch configuration\n", + "CUDA_CHECK(cudaGetLastError());\n", + "// Wait for kernel to finish and catch any runtime errors\n", + "CUDA_CHECK(cudaDeviceSynchronize());\n", + "\n", + "CUDA_CHECK(cudaMemcpy(h_data, d_data2, M * sizeof(int), cudaMemcpyDeviceToHost));\n", + "\n", + "printf(\"All CUDA calls succeeded.\\n\");\n", + "printf(\"result[0] = %d, result[1] = %d, result[2] = %d\\n\", h_data[0], h_data[1], h_data[2]);\n", + "\n", + "CUDA_CHECK(cudaFree(d_data2));" + ] + }, + { + "cell_type": "markdown", + "id": "7798bac8-a354-420f-badd-5ad2ab67fa0d", + "metadata": {}, + "source": [ + "Kernel launches do not return an error directly. To catch kernel errors you call `cudaGetLastError()` after the launch, and `cudaDeviceSynchronize()` to wait for the kernel to finish before checking." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d2e3f4a5-b6c7-8901-defa-012345678901", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Caught expected error: invalid resource handle\n" + ] + } + ], + "source": [ + "__global__ void bad_kernel() {}\n", + "\n", + "// Launch with 2 billion threads in a block — impossible.\n", + "bad_kernel<<<1, 2000000000>>>();\n", + "\n", + "cudaError_t err = cudaGetLastError();\n", + "if (err != cudaSuccess) {\n", + " printf(\"Caught expected error: %s\\n\", cudaGetErrorString(err));\n", + " cudaDeviceSynchronize(); // flush the error state\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "e3f4a5b6-c7d8-9012-efab-123456789012", + "metadata": {}, + "source": [ + "## 7. Unified Memory\n", + "\n", + "Normal CUDA requires you to manually allocate on the GPU with `cudaMalloc`, copy data to it, and copy results back. **Unified Memory** creates a single allocation that both the CPU and GPU can access — the driver automatically migrates pages between host and device as needed.\n", + "\n", + "The trade-off: easier to write, but the automatic migration has overhead. For small datasets or quick prototypes it is very convenient." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "42bb91d3-747f-45cb-b14b-c5ded527f423", + "metadata": {}, + "outputs": [], + "source": [ + "__global__ void double_unified(int* data, int n) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (tid < n)\n", + " data[tid] *= 2;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f4a5b6c7-d8e9-0123-fabc-234567890123", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No cudaMemcpy needed.\n", + "data[0] = 0\n", + "data[1] = 2\n", + "data[2] = 4\n", + "data[3] = 6\n", + "data[4] = 8\n" + ] + } + ], + "source": [ + "const int K = 5;\n", + "int* managed;\n", + "\n", + "// cudaMallocManaged creates memory accessible from both host and device\n", + "CUDA_CHECK(cudaMallocManaged(&managed, K * sizeof(int)));\n", + "\n", + "// Write directly on the CPU — no memcpy needed\n", + "for (int i = 0; i < K; i++)\n", + " managed[i] = i;\n", + "\n", + "double_unified<<<1, K>>>(managed, K);\n", + "\n", + "// Wait for GPU to finish before reading on CPU\n", + "CUDA_CHECK(cudaDeviceSynchronize());\n", + "\n", + "// Read directly on the CPU — no memcpy needed\n", + "printf(\"No cudaMemcpy needed.\\n\");\n", + "for (int i = 0; i < K; i++)\n", + " printf(\"data[%d] = %d\\n\", i, managed[i]);\n", + "\n", + "CUDA_CHECK(cudaFree(managed));" + ] + }, + { + "cell_type": "markdown", + "id": "a5b6c7d8-e9f0-1234-abcd-345678901234", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "| Concept | The one thing to remember |\n", + "|---|---|\n", + "| Memory hierarchy | Shared memory is fast, global memory is slow. Get data into shared memory early. |\n", + "| Constant memory | Fast read-only broadcast. Use for parameters that never change mid-kernel. |\n", + "| Coalescing | Adjacent thread IDs must read adjacent addresses. Scattered access kills bandwidth. |\n", + "| Warps | 32 threads execute in lockstep. Block sizes should be multiples of 32. |\n", + "| Divergence | Branches within a warp serialize. Branch on block index, not thread index when possible. |\n", + "| Occupancy | More active warps per SM = better latency hiding. Query your GPU limits with `cudaGetDeviceProperties`. |\n", + "| Error checking | Wrap every CUDA call in a check. Kernel errors need `cudaGetLastError()` + `cudaDeviceSynchronize()`. |\n", + "| Unified memory | `cudaMallocManaged` removes the memcpy burden. Convenient but has migration overhead. |" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/03_Speed-comparison.ipynb b/cuda/03_Speed-comparison.ipynb new file mode 100644 index 0000000..8956472 --- /dev/null +++ b/cuda/03_Speed-comparison.ipynb @@ -0,0 +1,256 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "882ddcc9-970e-47f7-b76f-a03de05bd5f8", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "40ab9e15-9852-4514-8a23-45fb426de963", + "metadata": {}, + "source": [ + "# Speed comparison with multiple threads\n", + "\n", + "In the previous notebooks we only ran kernels with multiple blocks and one thread. This is slow because we are not maximizing the use of a block. Here we can see the speed boost from running a vector add kernel but with multiple threads per block.\n", + "\n", + "In the first cell we can see two global kernels. The first one is the same as before, but the second one has a different index: `blockIdx.x * blockDim.x + threadIdx.x`. This is the standard cuda thread indexing formula that gives every GPU thread a unique global id across the entire grid." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cc22b2be-3513-406c-9b79-37bb0cca2e94", + "metadata": {}, + "outputs": [], + "source": [ + "#define N 10000000\n", + "\n", + "__global__ void vector_add_block( int *a, int *b, int *c ) {\n", + " int tid = blockIdx.x;\n", + " if (tid < N)\n", + " c[tid] = a[tid] + b[tid];\n", + "}\n", + "\n", + "__global__ void vector_add( int *a, int *b, int *c) {\n", + " int tid = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (tid < N)\n", + " c[tid] = a[tid] + b[tid];\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "cd91ab34-b671-4697-9d06-f6fd28fa8073", + "metadata": {}, + "source": [ + "Here we have the standard setup that we have used before." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc291b80-7c51-4089-9c1d-fe6f898df012", + "metadata": {}, + "outputs": [], + "source": [ + "int h_in1[N], h_in2[N], h_out[N];\n", + "int *d_in1, *d_in2, *d_out;\n", + "\n", + "cudaMalloc((void**)&d_in1, N * sizeof(int));\n", + "cudaMalloc((void**)&d_in2, N * sizeof(int));\n", + "cudaMalloc((void**)&d_out, N * sizeof(int));\n", + "\n", + "for (int i = 0; i < N; i++) {\n", + " h_in1[i] = i;\n", + " h_in2[i] = i * i;\n", + "}\n", + "\n", + "cudaMemcpy(d_in1, h_in1, N * sizeof(int), cudaMemcpyHostToDevice);\n", + "cudaMemcpy(d_in2, h_in2, N * sizeof(int), cudaMemcpyHostToDevice);" + ] + }, + { + "cell_type": "markdown", + "id": "d9182a38-b828-4097-afe9-d8577f831b34", + "metadata": {}, + "source": [ + "This cell calls the first kernel with an N number of blocks and one thread for each block. We have already done this. The new code here is that we track the time it takes the kernel to add the numbers using the **cudaEventRecord()** function." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5d2c6648-9712-4c59-9d8d-a6ff91926d76", + "metadata": {}, + "outputs": [], + "source": [ + "float time_block_method = 0;\n", + "float time_thread_method = 0;\n", + "\n", + "cudaEvent_t start, stop;\n", + "\n", + "cudaEventCreate(&start);\n", + "cudaEventCreate(&stop);\n", + "\n", + "// warm up\n", + "vector_add_block<<>>(d_in1, d_in2, d_out); \n", + "\n", + "cudaEventRecord(start);\n", + "\n", + "vector_add_block<<>>(d_in1, d_in2, d_out); \n", + "\n", + "cudaEventRecord(stop);\n", + "\n", + "cudaEventSynchronize(stop);\n", + "\n", + "cudaEventElapsedTime(&time_block_method, start, stop);" + ] + }, + { + "cell_type": "markdown", + "id": "8aaf1eac-895c-4400-85f8-3d430f3b371e", + "metadata": {}, + "source": [ + "Next we call the second kernel but with 256 threads for each block. The number of blocks needed is calculated by this formula: `(N + threadsPerBlock - 1) / threadsPerBlock`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e8fce433-4a04-4c74-8761-0e71c12e7a99", + "metadata": {}, + "outputs": [], + "source": [ + "int threadsPerBlock = 256;\n", + "int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;\n", + "\n", + "cudaEventRecord(start);\n", + "\n", + "vector_add<<>>(d_in1, d_in2, d_out); \n", + "\n", + "cudaEventRecord(stop);\n", + "cudaEventSynchronize(stop);\n", + "cudaEventElapsedTime(&time_thread_method, start, stop);" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b66ef60e-d6a6-4b8d-94a8-d21419ca43c2", + "metadata": {}, + "outputs": [], + "source": [ + "// Destroy time events and free allocated memory\n", + "cudaEventDestroy(start);\n", + "cudaEventDestroy(stop);\n", + "\n", + "cudaFree(d_in1);\n", + "cudaFree(d_in2);\n", + "cudaFree(d_out);" + ] + }, + { + "cell_type": "markdown", + "id": "cb7249b9-ad73-487e-b6fa-f6661fe1f5f6", + "metadata": {}, + "source": [ + "This cell here is a CPU only version of the vector addition. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "17499984-2201-418c-b0e8-e898005cc09d", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "\n", + "\n", + "void add_CPU(const int* a, const int* b, int* c, int n) {\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + "}\n", + "\n", + " // Using std::vector for easy memory management on the CPU heap\n", + " std::vector h_a(N), h_b(N), h_c(N);\n", + "\n", + " // Initialize arrays\n", + " for (int i = 0; i < N; i++) {\n", + " h_a[i] = i;\n", + " h_b[i] = i * 2;\n", + " }\n", + "\n", + " // Start Timer\n", + " auto cpu_start = std::chrono::high_resolution_clock::now();\n", + "\n", + " add_CPU(h_a.data(), h_b.data(), h_c.data(), N);\n", + "\n", + " // Stop Timer\n", + " auto cpu_end = std::chrono::high_resolution_clock::now();\n", + "\n", + " // Calculate duration in milliseconds\n", + " std::chrono::duration duration = cpu_end - cpu_start;" + ] + }, + { + "cell_type": "markdown", + "id": "0a8c9793-c16e-43d3-a4bb-a7e1ed72c14f", + "metadata": {}, + "source": [ + "And finally we print the numbers. We can see that the CPU is faster than the one thread GPU kernel but the 256 thread one is much faster than both." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "714fc2ff-5a80-4c63-9fba-fc721e6ed1db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time (CPU sort): 21.129480 ms\n", + "Time (1 thread/block): 30.603071 ms\n", + "Time (256 threads/block): 1.990752 ms\n" + ] + } + ], + "source": [ + "printf(\"Time (CPU sort): %f ms\\n\", duration.count());\n", + "\n", + "printf(\"Time (1 thread/block): %f ms\\n\", time_block_method);\n", + "\n", + "printf(\"Time (256 threads/block): %f ms\\n\", time_thread_method);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/04_Thread-cooperation.ipynb b/cuda/04_Thread-cooperation.ipynb new file mode 100644 index 0000000..aafd167 --- /dev/null +++ b/cuda/04_Thread-cooperation.ipynb @@ -0,0 +1,139 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "a", + "metadata": {}, + "source": [ + "# Thread Cooperation - The Grid-Stride Loop\n", + "\n", + "In the previous notebooks each GPU thread handled exactly one array element.\n", + "That only works when you launch exactly as many threads as you have data points.\n", + "\n", + "A more flexible pattern is the **grid-stride loop**: launch a fixed number of threads\n", + "(typically chosen to saturate the GPU) and have each thread walk through the array\n", + "in steps equal to the total number of threads in the grid.\n", + "\n", + "This means:\n", + "- You never need to know N at launch time\n", + "- You can reuse the same launch config for any array size\n", + "- Each thread does a balanced share of the work" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ec24e43e", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "\n", + "static const int N = 1 << 17; // 131 072 elements\n", + "static const float ALPHA = 2.5f; // scalar for SAXPY\n", + "\n", + "__global__ void saxpy(float alpha, const float *x, float *y, int n) {\n", + " int start = threadIdx.x + blockIdx.x * blockDim.x;\n", + " int step = blockDim.x * gridDim.x; // total threads in the grid\n", + "\n", + " for (int i = start; i < n; i += step)\n", + " y[i] = alpha * x[i] + y[i];\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "9d46b9e7", + "metadata": {}, + "source": [ + "We launch with 64 blocks × 256 threads = 16 384 threads, but the array has 131 072 elements.\n", + "Each thread therefore handles roughly 8 elements via the loop. The result is verified\n", + "element-by-element on the CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d080db69", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Verified - 131072 elements correct, max error = 0.00e+00\n" + ] + } + ], + "source": [ + "// Allocate, fill, launch, verifi\n", + "float *h_x = (float*)malloc(N * sizeof(float));\n", + "float *h_y = (float*)malloc(N * sizeof(float));\n", + "float *h_ref = (float*)malloc(N * sizeof(float));\n", + "\n", + "for (int i = 0; i < N; i++) {\n", + " h_x[i] = sinf((float)i);\n", + " h_y[i] = cosf((float)i);\n", + " h_ref[i] = ALPHA * h_x[i] + h_y[i]; // CPU reference\n", + "}\n", + "\n", + "float *d_x, *d_y;\n", + "cudaMalloc(&d_x, N * sizeof(float));\n", + "cudaMalloc(&d_y, N * sizeof(float));\n", + "cudaMemcpy(d_x, h_x, N * sizeof(float), cudaMemcpyHostToDevice);\n", + "cudaMemcpy(d_y, h_y, N * sizeof(float), cudaMemcpyHostToDevice);\n", + "\n", + "// 256 threads/block, 64 blocks — 16 384 total threads for 131 072 elements\n", + "saxpy<<<64, 256>>>(ALPHA, d_x, d_y, N);\n", + "\n", + "cudaMemcpy(h_y, d_y, N * sizeof(float), cudaMemcpyDeviceToHost);\n", + "\n", + "// Verify (allow small floating-point tolerance)\n", + "int errors = 0;\n", + "float max_err = 0.f;\n", + "for (int i = 0; i < N; i++) {\n", + " float err = fabsf(h_y[i] - h_ref[i]);\n", + " if (err > 1e-4f) errors++;\n", + " if (err > max_err) max_err = err;\n", + "}\n", + "\n", + "if (errors == 0)\n", + " printf(\"Verified - %d elements correct, max error = %.2e\\n\", N, max_err);\n", + "else\n", + " printf(\"FAIL - %d mismatches\\n\", errors);\n", + "\n", + "cudaFree(d_x); cudaFree(d_y);\n", + "free(h_x); free(h_y); free(h_ref);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/05_The_Julia_Set.ipynb b/cuda/05_The_Julia_Set.ipynb new file mode 100644 index 0000000..621ca9b --- /dev/null +++ b/cuda/05_The_Julia_Set.ipynb @@ -0,0 +1,192 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3abb4a11-4c9a-4759-938c-652cd8bc96a3", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "a6d0653e-f7e5-41e1-9085-ade376faad41", + "metadata": {}, + "source": [ + "# Julia Set Fractal\n", + "\n", + "This program renders the Julia Set by calculating millions of pixels simultaneously. It maps each pixel to the complex plane and repeatedly applies the formula:$$Z_{n+1} = Z_n^2 + C$$\n", + "\n", + "- `vec2()`: A custom structure that treats a 2D coordinate as a complex number ($x + iy$), handling the unique rules of complex addition, multiplication, and squared magnitude - norm2().\n", + " \n", + "- `escape_count()`: The core math loop. It runs up to $256$ times to check if a point \"escapes\" a boundary radius of $2$ ($\\|z\\|^2 > 4.0\\text{f}$). Points that never escape belong to the fractal set.\n", + "\n", + "- `julia_fractal()`: The GPU kernel. Each thread maps its coordinate to a $[-1.6, 1.6]$ complex grid, tests it against a constant $C = (-0.4 + 0.6i)$, and assigns an RGBA color. Trapped points are colored black, while escaping points form a vibrant blue-to-white gradient." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e1855365-fa8c-444b-9ff6-f0b6441bce3d", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "\n", + "// Image resolution (power-of-two friendly)\n", + "static const int W = 1024;\n", + "static const int H = 1024;\n", + "static const int MAX_ITER = 256;\n", + "\n", + "struct vec2 {\n", + " float x, y;\n", + "\n", + " __host__ __device__ vec2(float a = 0.f, float b = 0.f) : x(a), y(b) {}\n", + "\n", + " // complex multiply: (x+iy)(u+iv) = xu-yv + i(xv+yu)\n", + " __device__ vec2 operator*(vec2 o) const {\n", + " return { x * o.x - y * o.y, x * o.y + y * o.x };\n", + " }\n", + "\n", + " __device__ vec2 operator+(vec2 o) const { return { x + o.x, y + o.y }; }\n", + "\n", + " __device__ float norm2() const { return x * x + y * y; }\n", + "};" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aa3c6b4a-c297-4784-8258-96186f4287f9", + "metadata": {}, + "outputs": [], + "source": [ + "__device__ int escape_count(vec2 z, vec2 c) {\n", + " for (int n = 0; n < MAX_ITER; n++) {\n", + " z = z * z + c;\n", + " if (z.norm2() > 4.0f) // escape radius = 2 (squared = 4)\n", + " return n;\n", + " }\n", + " return MAX_ITER;\n", + "}\n", + "\n", + "// Kernel: one thread per pixel, launched on a 2-D grid\n", + "__global__ void julia_fractal(unsigned char *img) {\n", + " int col = threadIdx.x + blockIdx.x * blockDim.x;\n", + " int row = threadIdx.y + blockIdx.y * blockDim.y;\n", + " if (col >= W || row >= H) return;\n", + "\n", + " // Map pixel to the complex plane [-1.6, 1.6] × [-1.6, 1.6]\n", + " float cr = 1.6f * (2.f * col - W) / W;\n", + " float ci = 1.6f * (2.f * row - H) / H;\n", + "\n", + " // Julia constant - gives a dendrite-like fractal\n", + " vec2 c{ -0.4f, 0.6f };\n", + " int n = escape_count(vec2{cr, ci}, c);\n", + "\n", + " // Colour: points inside the set - black; outside - blue-to-white gradient\n", + " unsigned char v = (n == MAX_ITER) ? 0 : (unsigned char)(255 * n / MAX_ITER);\n", + " int px = (row * W + col) * 4;\n", + " img[px + 0] = v / 3; // R (keep low for blue tint)\n", + " img[px + 1] = v / 2; // G\n", + " img[px + 2] = v; // B (dominant)\n", + " img[px + 3] = 255; // A\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "c2187f1d-709b-440b-8405-cbdfded0e131", + "metadata": {}, + "source": [ + "Here we call the kernel and write the data to a .png file" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "140ffa7b-4253-41a8-b0eb-f1fa1b8bdd99", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved julia.png (1024x1024)\n" + ] + } + ], + "source": [ + "#define STB_IMAGE_WRITE_IMPLEMENTATION\n", + "#include \"headers/stb_image_write.h\"\n", + "\n", + "unsigned char *d_img, *h_img;\n", + "h_img = (unsigned char*)malloc(W * H * 4);\n", + "cudaMalloc(&d_img, W * H * 4);\n", + "\n", + "// 16×16 thread blocks — each covers a 16×16 tile of the image\n", + "dim3 block(16, 16);\n", + "dim3 grid((W + 15) / 16, (H + 15) / 16);\n", + "julia_fractal<<>>(d_img);\n", + "cudaDeviceSynchronize();\n", + "\n", + "cudaMemcpy(h_img, d_img, W * H * 4, cudaMemcpyDeviceToHost);\n", + "stbi_write_png(\"images/julia.png\", W, H, 4, h_img, W * 4);\n", + "printf(\"Saved julia.png (%dx%d)\\n\", W, H);\n", + "\n", + "cudaFree(d_img);\n", + "free(h_img);" + ] + }, + { + "cell_type": "markdown", + "id": "3c932314-bd63-4da9-920f-c24b07142f8c", + "metadata": {}, + "source": [ + "And now we display the result:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "77302d5a-1bc7-4f7e-bd44-46480a1ece14", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAYAAAB/HSuDAAeDMklEQVR4XmNkYGD4zzAKRkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNASGdQgwjcbvaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsDwD4HRAYDRVD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjA4AjKaB0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHhEAKjKwBG0/FoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbA6ADAaBoYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgOITC6AmA0HY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITA6ADCaBkZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQEhkMIjK4AGE3HoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjA4AjKaB0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHhEAKjKwBG0/FoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjAwCjaWA0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDiEwOgKgNF0PBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwOgAwGgaGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDiEwugJgNB2PhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwOgAwmgZGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BIZDCIyuABhNx6MhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIwOAIymgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B4RACoysARtPxaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCowMAo2lgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A4hMDoCoDRdDwaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsDoAMBoGhgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA4hMLoCYDQdj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMDoAMJoGRkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNASGQwiMrgAYTcejITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMDgCMpoHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgeEQAqMrAEbT8WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMDAKNpYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgOITA6AqA0XQ8GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbA6ADAaBoYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgOITC6AmA0HY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITA6ADCaBkZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQEhkMIjK4AGE3HoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjA4AjKaB0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHhEAKjKwBG0/FoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjAwCjaWA0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDiEwOgKgNF0PBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwOgAwGgaGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDiEwugJgNB2PhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICAGW0VgeDYHREBgNgdEQGA2B0RAYDYGREwKMNPDq/9EENBoCoyEwGgKjITAaAkMiBEC14GitNZpYR0NgNARGQ2A0BEZDYDQEhlAIMA6j2Bptho1mvdEQGA2B0RAYDQH6hcDoAMBoahsNgdEQGA2B0RAYDYHREBhkIcA4GiMoITA6SDCaIEZDYDQERkNgNASoEwKjAwCjKWk0BEZDYDQERkNgNARGQ2AAQmC0k0+9QB8dIBjNwqMhMBoCoyEwGgLEhcDoAMBoShkNgdEQGA2B0RAYDYHREKBhCIx29AcueY0ODIxm7dEQGA2B0RAYDQHUEBgdABhNEaMhMBoCoyEwGgKjITAaAlQKgdHO/tBISqMDA6NZfjQERkNgNARGagiMDgCMpv3REBgNgdEQGA2B0RAYDQEyQmC0sz+8ks3ooMBoMTAaAqMhMBoCIyEERgcARtP5aAiMhsBoCIyGwGgIjIYAESEw2uEfeclkdFBgtGgYDYHREBgNgeEWAqMDAKNpejQERkNgNARGQ2A0BEZDAEsIjHb4R5MFegiMDgiMponREBgNgdEQGOohMDoAMJqGR0NgNARGQ2A0BEZDYDQEgCEw2uEfTQakhsDogMBomhkNgdEQGA2BoRYCowMAo2l2NARGQ2A0BEZDYDQERmwIjHb6RxM/tUNgdFBgNE2NhsBoCIyGwGAOgdEBgNH0ORoCoyEwGgKjITAaAiMqBEY7/aMJnl4hMDoYMJrWRkNgNARGQ2CwhcDoAMBomhwNgdEQGA2B0RAYDYFhHwKjnf7RRD4YQmB0QGA0HY6GwGgIjIbAQIfA6ADAaBocDYHREBgNgdEQGA2BYRkCo53+0YQ92ENgdEBgNI2OhsBoCIyGAL1DYHQAYDTNjYbAaAiMhsBoCIyGwLAJgdFO/2hiHqohMDoYMJp2R0NgNARGQ4AeITA6ADCazkZDYDQERkNgNARGQ2BIh8Bop380AQ/HEBgdEBhN16MhMBoCoyFAixAYHQAYTVejITAaAqMhMBoCoyEw5EJgtNM/mmhHUgiMDgaMpvfREBgNgdEQoFYIjA4AjKal0RAYDYHREBgNgdEQGDIhMNrxH02soyHAwDA6IDCaCkZDYDQERkOA3BAYHQAYTTujITAaAqMhMBoCoyEwqENgtNM/mkBHQwB3CIwOBoymjtEQGA2B0RAgJQRGBwBG08toCIyGwGgIjIbAaAgMyhAY7fiPJszRECAtBEYHA0ZTzGgIjIbAaAgQCoHRAYDRNDIaAqMhMBoCoyEwGgKDJgRGO/2jiXE0BKgTAqODAaMpaTQERkNgNASwhcDoAMBouhgNgdEQGA2B0RAYDYEBD4ER0vFnpNCf/0c7daOZlZwQGE03o+lmNARGQ2A0BGAhMDoAMJoWRkNgNARGQ2A0BEZDYMBCYJh2/BkHwF+jgwOj+ZioEBgdDBhNKKMhMBoCIzsERgcARnPAaAiMhsBoCIyGwGgI0D0EhlHHn3EQ+2V0UGA0b+MNgdHBgNEEMhoCoyEw8kJgdABgNNWPhsBoCIyGwGgIjIYA3UJgmHT8GYeoP0YHBEbzOs4QGB0MGE0coyEwGgIjIwRGBwBGU/poCIyGwGgIjIbAaAjQNARGO/2DMoGNDgaM5nucITA6GDCaOEZDYDQEhm8IjA4AjKbu0RAYDYHREBgNgdEQoEkIDIOOPyPjyEgbo4MBo2UAzhAYHQwYTRyjITAaAsMrBEYHAEZT9GgIjIbAaAiMhsBoCFA1BIZ4p5nGnX5GBuLC5z/DAHW8RgcDRsuD0cGA0TQwGgKjITCMQ2B0AGA0eY+GwGgIjIbAaAiMhgBVQmC0448rGInt9OOLhgEZEBgdDBgtG0YHA0bTwGgIjIbAMAuB0QGA0SQ9GgKjITAaAqMhMBoCFIfAEO7802jGn+ROP7o78HS+6T4YMDoQMFpG4A2B0W0CowlkNARGQ2DohMDoAMBoah0NgdEQGA2B0RAYDQGyQ2C0448edCR1/HEOPsDCFdixGkwDASDPjg4GjJYXeENgdDBgNIGMhsBoCAzuEGAajaDREBgNgdEQGA2B0RAYDQFSQwDUQR3t/FO38w8JU0ZGZgZG4MCAsIw5AxMTKwMDaJAAx0ABNbYWkJz28bhnNB+NhgADwxAvG0ajcDQERkNg2IfA6AqA0UQ+GgKjITAaAqMhMBoCRIcA49AOq8Gw3B/FDYjwZAR3rJkY2LlEGFjYeBn+/PrC8Ov7W4Z/f38Dwxw6qzrYVgOAUsPoioDR8oNgCIyuChhNJKMhMBoCgycERlcAjKbG0RAYDYHREBgNgdEQIBgCw2DGf1B1/oFz94xM4Jl+UMefEchmAGI+EU0GNg5BBil1P4Z/f34w/P/3FzVm8PhhQFYDgFw3uiJgtPwguvxgHA2r0RAYDYHREBjwEBgdABhNhKMhMBoCoyEwGgKjIYAzBIbBcl5G2nU6iO50wzvJkI6/RfAyYH+fhYEB2vGX0QoGL/f/+uE+g7iKO8PT6+sYmFg4gNLM0Jghzg8DNggwOhAwWoYQHQKwMmV0MGA00YyGwGgIDEwIjG4BGE15oyEwGgKjITAaAqMhgDUERpf740oY5B30BwlPRiZmBlE5W+DS/l8M71+cZ+DklQayfzLIaocx/P75ieHl3d0MP7+9AYuBVgD8//8P6gykZdRELLsfkGsDkQNsdGvAaLlCUgiMbhMYTTCjITAaAvQJgdEVAKMpbTQERkNgNARGQ2A0BFBCYHTWH1+CIH3WH9U00HL/Dy8uMLx+eJCBm1+eQcOmgoFbUInh75+fDJ9eX2Pg5JNmkNbwh2tixLaCgYhVDQO6GgDk+tGtAaPlCkkhMHp44GiCGQ2B0RCgTwiMrgAYTWmjITAaAqMhMBoCoyEADoFhsiR3oJf8Y7UfOvvPCOnkgFYBsLLzMfAIq4FDXkTWikFeP47h0u4yhm8fHzH8+Pyc4c/vr9AzAIBz+eDZdLQZUiJn2Ad8JQAsd42uCBgtZ0gOgdFVAaOJZjQERkOA+iEwugJgNFWNhsBoCIyGwGgIjIYAwzDo/NN4xpngjDpO+5E7/wzga/1AV/39+/uLgRV42j8Ig5b8g5b6g07/B60Q4JfQZ2BiZgeeA8AO0sDAyIhldpRxCJwLgJyzRlcEjJYzJIfA6HkBo4lmNARGQ4D6ITA6ADCaqkZDYDQERkNgNARGcAhg6VgOxdBgpO0ABt7OP96OLVrnnwFyCKCqRQHwqj8ehs9vbzGomOeCZ/x3TdMBz/7/+f2N4QtQHLQVQM+lA+kgQPIjhnEwDfAwMo6WOKMhQEYIjA4GjCab0RAYDQHqhADoeN2G0cAcDYHREBgNgdEQGA2BkRUCw6TjD4q0ger8E5zRxuz8A6fyGUAz/J/f3mBQtchnePPoKPi+fy7gWQB//3xnYGXnBfK/MvwFLv9nYmJlAJ0VoOPUwvD81hagT7EshybB74NuEGB0IGC00CU7BIZR+TWaCkZDYDQE6B4CjNhr1NGYGA2B0RAYDYHREBgNgeEaAsNoBnYgO/84kwdSx58RutAQtP+dEdQFZ4RvAWBiZmXgE9UGnvz/Edjh/8bAxinM8Ov7WwYj7+kMx1eFMIC2BOi6tDNc3FXCADwMAMiHDQCQdxYAzLmD5kwA5PAbPR9gtLilOARGzwsYTUSjITAaAsSFwOgAwGhKGQ2B0RAYDYHREBghITDa8Sc1orHOmmMddEANW9iefVAnX1LNF3yl34s7O8DWMzKxMICHAoDXAXLyyYBn/P/9+QEcGGAC7/UXV3JleHJtDcO/f7+BHf//DJBrAP8jDQCAjBmGgwBgb4124kaLY2qEwGg6Gk1HoyEwGgK4Q2D0DIDR1DEaAqMhMBoCoyEwAkJgtPNPaiRjdP5RlvzDliBjLkWGXdsnpugIPuXfyGsKw+8fH4GH+rExgJb1K5tkMPCKaIA7/D+/vobc98/wnwE0CPDn11cGPdcuYGf/L6Tzz4DoyDBScbUD42A99HF0W8BoaUyVEEDOn6NBOhoCoyEwGgKoITC6AmA0RYyGwGgIjIbAaAgM4xBgHF5+o1MHEWvnHxySjAywjvj///g654zgw/tE5e0Zvn9+xiCp5s1w78xM8PJ/aXV/hpf39gBX9f9hAC3HB68GAG4HAC3z//3zE/jqP/Cs//9/YHkGpCsA/6MsladsFQDIO4NyOwAsxY5uCxgtmakeAqMrA0YT1WgIjIYAA8PoCoDRVDAaAqMhMBoCoyEwTENgtPNPTsTinh1nBB/gx8ohyAC6xg90mB8YA5fyM4D3+iPNOkIHKvjFdRnUrYoZHl1aysDFL8tg7DOT4eX9vcAbALgZlE2zGNQsi8ArA6Q1Ahj4xfUZwNsDgGaxsHIxKBqnEnA+5fHLOJivfyR4yOJowTUaAqSGAOaKndEwHA2B0RAYeSEwOgAwmupHQ2A0BEZDYDQEhlkIDMNG7kDN/INSBpLdvMJqDKAl/NxCyuAZfkZg519WK5SBmYUDPLsPO+WfCbTPH9iRf3BhIcP3T08ZuAUVGQQkjRiuHWxkUDXLBac30D7/l3d3gTv9oPMBPr+9CR5gYAKaBTobQNO2GjzQwIBkP95tAMN1+fzoQMBoCU31EBjdIjCaqEZDYCSHwOg1gKPpfzQERkNgNARGQ2AYhQDj8IvNQdH5hyz9//XjPbBD/wS4TP83+B5/0IF9bx4dBu7j/wU+qR/UQecSkGfQdmgE3+X///8fhk+vroL3+/MABw2+f3rC8OXdbQbQjP+3jw/B9IcXF4E3AAiCbwIAbQMQkNBn4OCRZPjw/CzD5zfXwVsFcEcqWnyTEVaDehUAssdHzwcYLalpEgKjgwGjCWs0BEZaCIwOAIym+dEQGA2B0RAYDYFhEALDdGnrIJn5Z2CA7v0Huuf//7/ADroEcEm/HMP3L88gM//A/foq5rkM756cYGAHXucH6tyzsPEwKBqlMHDySTF8fX+f4de3N8DtACUM75+fZ/gJZP//9wd8PsDfP9/AB/6xAtX/+f2NAXQw4M9vr8GDCj++vIAMAMD7+YwMmEEyzLcCIOfO0dUAo6U1TUNgdDBgNIGNhsBICIHRAYDRdD4aAqMhMBoCoyEwxEOAcXjG4EB2/kEhimI/ZAAAtOffLmYneBZfx7EJuLRfieHt46MMoK0BH15cAJ72/4FBXNkVKHac4fevTwwgMdCqAdCMPwcvcCDgwz3wMn8Ghn/gAQTQ4YAfXpxn0HFqZnh6Yz0DN788Ays7H8O3T4+A+DFwEAB4FSDsJgC4e2BuQekZIzhkhtuQWQkAi5vRFQGjJTdNQ2B0MGA0gY2GwHANgdEBgNG0PRoCoyEwGgKjITCEQ2C0809J5OHs9GJ0LiEHADIyMTE8v7WVQRC4n//lvd3AZfrnwNbL6UQyPAN24EGn/oOm6BUMEhi+fXjIwMrBDz4fADSrz8YpyAA65V9c2Q28719GO5Thwfl54Bn+l/f2gu/7//vrC4OIvA3Dp9dXGUTkrIFmPGCArT4AbS8ADUBwArcHaDvUM7y8u5sBZx94JAwCgEJ+dEXAaOlNlxAYPTxwNKGNhsBwCgFQjh69E2Q0TY+GwGgIjIbAaAgMsRBgHN4xRofZXbwz3lhm/9mAS/s5+aSBS/RfMYD2/n8EdtJhV/eBIuMPsPMOuh0AdNo/aIk/EzM7+JwAOd0oBtCWANCSf3ZucQZeEXUGPhFNhtsnJjAwA0/7//LuDnjW/+uH+wygAYRHl5cxKJtlM1zaVQIU5wcPDHALKIC3BHz/8pyBR1AJfLDg71+fGWBXBCKuB6T8akCQXwb19YC4Uv7otYGjpThdQ2C0+zCa4EZDYKiGwOgtAKNpdzQERkNgNARGQ2CIhcBo55/SCCO+84+wCbSUHzQDLyxrzQDqrHMCl/SD9uiLK7mAl/ULSZszgM4HAJ36D5q1VzCIB3b0NRhe3N7GoGiYBJz1Z2UQU3RiAKn//OYGA2hLwN8/PxiEpE0ZQHv/eYGDAk9vbGBgZGZluHt6GngwAHTLAOhqQHYe0MCBBgM7lyjwsMDvDGpWJQwcwMEEyBIA6PkEVEzFQ2o7AMzfo6sBRktyuobA6BaB0QQ3GgJDNQRGVwCMpt3REBgNgdEQGA2BIRICjMM/pgZ65h8UwliX/0Ma+4yMkHkD0EoAdm4xBjndaIar++sYQCf/g074F1N0Zvj1/R2DkJQJcBn/NYaf39+CO+2gawI5eCUZbh3rYbAIXQWewQeZ9e7pKfCgAaiTD1oJ8O/vL+CNAEIMMppBwCsDm8Cz/8qmWQxPrq4CbicQBMe/mIIDw4eXoJsDhBmeXl/LAHLH98/PwLcQQFYCUGcVAMiyIbkSAJZLRlcEjJbsAxICoysDRhPeaAgM9hAYXQEwmkZHQ2A0BEZDYDQEhkAIjHb+qRFJBGe2cQxAwDrW/4Gn/YM6xaCZf9AKgCv7qhn+/fsNPuWfi08WfCDg399fgWJ/GKQ0/BmYmFgY/v75Dr7mD7RFAOSHbx8fAa//8wcfJAgaBPj94yMDSAy0rYAZuG3gH3BVwP3z88FXB4oCO/v///5mAG0tAJnLxikEHiAArSQADRiAVgSA1IjI2YDVQ8IILa1QMKgyJFcCwBLK6IqA0ZJ9QEJgdGXAaMIbDYHBHgKjAwCjaXQ0BEZDYDQERkNgkIfAaOefGhFEnc7sf/C++3/AK/xAhwH+A3bOQecAgDr6wDX+DEzMbAygwYFnNzcy3Dk5mUHJOI0B1KEHrQz4++srg4JBIgOo437v7CwGA89JDKCVBKDZf9AKgS9vbzGYBS0G6n/JALoGENTpB10r+ODiIvAgAuhaQdAgwOuHh4C3DqgDzw/gZPj14wODBPBQwbePjkLPA8ARUhR0hof0IAAoOEZvCxgt4QcsBEYHA0YT32gIDMYQGN0CMJouR0NgNARGQ2A0BAZpCDCOjJgZDMv+QSGN+0h9Bog0LD6gNCMj9Eo/RuBJ/+zAa/3kGUCz8U+vrwMf+icibwfs/P8EitmDT///8fk5cICAFTxIABpA+Au8859PVJvh5tFOBlntcIYv7++C9/eDDgtkZuNm+PPzE9he0PkAslqh4O0EoBUAIHHQNoM3j4+BBxf+//sL3ioAHAFg+I+y7B3HUmQyl8YP6e0AsJw0ui1gtLQfFCEwuk1gNCGOhsBAhsDoNYCj6W80BEZDYDQERkNgEIbAaOefWpFC9Aw2WQMAsBk+BgbQEv9Pr68wGPvMAG4JuMugYV3O8OrBPvCtAaAOu4JBHLhTDzokELSVQBB4TsC7pycZQFsHQDP+AhL6QLUvwd4WkjZjUDHNZvj05jpY7PObm2D646srDJIqngygVQAghSA7kTvmjMQMppA54DLkVwKAAmx0W8BoaT8oQmB0ZcBoQhwNgYEMgdEtAKPpbzQERkNgNARGQ2CQhQDjaIxQKQSo1fkHOQdldh3aiQbt4Qef1M8AW1DIyHD/3Bzgkv2fDJf3VjGA7Gdl5wOuDpAD++gzcJk/qPMPugng59dX4DMCQLP94sBl/CA5JhYOBtAKANCNAqCtBKBtAOAZfob/DKB9/g4JBxhun5wEXHHAyWDoMRESSuBZbciMIuoKADzpaCQPAoBCbXQgYLSMGTQhMDoYMJoYR0OA3iEwugJgNM2NhsBoCIyGwGgIDKIQGEGdf0ba+pWkGWsCs/+wBAKZYQe6G7r8X1jGAry8X04nAri/P4Hh9YMDwJUAX8FX+4GuCgRdC8gtoMgAuvYPdGWfuLIrw/tnZxg+vroM3CbwGNzZB50f8P75OQYWVi7gVoAwhjcPD4O3CoDMAqkDHzwIPHMAJA+6cQB06CCvsBrDoyvLgSsKPjOAlv6TlYBH+iAAKNBGBwJGS/9BFQKIFUWjETMaAqMhQLsQYCS/5hyNltEQGA2B0RAYDYHREKBWCIywWX8adv5JXqpOZOcfFNOwAQAm4F39oEP/2DgEGFjZ+cE3ASgYJDDcOTWVAbQiALgZH0xz8Egy/Pv7E3xWwN8/P8FioAP/pDUCGJ4Azwr4+/s7eBAANFAA6uiDrgEErQAAz/oDO/1gcTx7/EF6GHCuAIClTSL2G5OxN35YnAmAnn1HzwgYLdIHXQiMnhcwmihHQ4DaITC6BWA0TY2GwGgIjIbAaAgMcAiMdv6pFQH02qcuIGEA7vgrGCYxCEgaAk/zl2F4cGEBpPPPwMAAmbX/ywBa6s/CxssAUg/q2Os6tTKwc4kwgPb0g673A/lbTMkZOOPPzgDq9IPcD7o5gINXkoEROMgAGkBgBq4MYACbCeoI/Aff9w+6eQC9809RGJIxIDMszgRAD7TRFQGjtcGgC4HRLQKjiXI0BKgdAqNbAEbT1GgIjIbAaAiMhsAAhsAI3O9Po9l/sjukWN2DGS+IA/YYwVf9iSk6gq/sA50D8OMr8PA+4Ew9G4cgeDDgJ4j//x/4Oj8mRmZIhx84o//i7i7geQCyDKDD/JRM0oDbAU4zKJtkMPz69pbh+6cn4HT48eUlsJq/f74zgOz8/eszAzu3GPxWAJAi1Nl3QmmIyDRGRueXkQECh10RMjoQMForDMoQGB0MGE2YoyFAjRAY3QIwmo5GQ2A0BEZDYDQEBigERjv/1Ap46nb+Qa7CPwAAOfyPhUFeP5YB1GH/+fU1eBuAtkMjw9UD9eBzAEDbBECH+DGxsEOuCwQuL4ct9QfpZ2bhBJ8FICxrzQBa+s8tqAg+HwBkOxMzGwMrcHsBj6Ayw6fXV4G3CtwHmw9a7o/S+YcvWUcsE/6Pcxk7CUuJR7cEoCbN0a0Bo7XEoA6B0W0Cowl0NARICYHRFQCj6WU0BEZDYDQERkOAziEwQg96GhIz/4Q7/wxQJYaek8Ez+O+fn2XgE9EEz/Y/u7UFfDc/KIaFZSwZfv14B1MOXtIPPtX/72/QHgEGQSljBn5xXQZl43SG75+fgQcS/v75wSCjHcrw+8cHBj3XTgYpdV/g4YDcwMMF90Pv+Edq6NOyUzq6JQC1TBhdETBaSwzqEBhdGTCaQEdDgJQQGF0BMJpeRkNgNARGQ2A0BOgYAowjM7Rp0PmneA86kUv/QRGGvPyfASIAmdUHLYFnZGLQtKtmuHW8H3zgHwNQTM+lg+He2VkMbJxC4PMAXt3fyyAoaczAK6LB8ObREbAY6LBAdk5hBg5eKWDn/yJQL3BgAOgmdctihvvn54G3EvwBLv8HXReoZlnEcHFXKXj/P3wFAMoAADErAEAOJ2OmcHQ1AGaeHV0RMFprDIkQGF0ZMJpQR0MAWwiMDgCMpovREBgNgdEQGA0BOoUA48gNaSoPAAxM5x8UfdA4ZITufWeEzLyBBwgYIecKg5b3g/bsS6h4AJfu32MAdeBBB/Zx8cuDT/wHXfkHOsQPlhhAHXrQAYCg6/xAKwR4hJQZQIMIX9/fY+ARVmX48Pw8A2zrAO4tACDTII39/wQ7p6ODAFTNiKODAaM1yJAIgdHBgNGEOhoCsBAYvQVgNC2MhsBoCIyGwGgI0CEERjv/1Apk2pw+j33PPyPKwAWWOAR3/v5DlucDD/0DX8kHFPvz8xMD6IpA0Iy/sKwVw9/f3xieXl8LXPZvwgDq6IM7/UD1sGv+GKB6QXf8f357G7jv/xoDaDsAA0w1UieTkP8ZCQ62kJEWyVgCP2wPCERPyKPbA0ZrkCERArBtAqPRNRoCoyEwugJgNA2MhsBoCIyGwGgI0DgERjv/1ApgqnT+MTrIqPHDSGhrAFQe7hbkVQDA5f8MoNUBwJP/OXjEwUv+QTP5/4D7/kGDAJCr+/4xgJfxow0eQMT+Ifb6///PgCEGCkjoYAC+rQD/iZqVJnNGcHRLAOHkPLoqYLRWGRIhMLoqYDShjswQGF0BMJryR0NgNARGQ2A0BGgUAqMzLtQMWNp0/hEuZAR33LEN1jAiK0L1EiNyHEPUQdz5H3go4BuG909Pg/fys7BxQ88MQG9wM4Kv+lM0SkE1F975x9JAxzoAAdMOdQMjMYNOZA5Mja4GIJysR1cFjNYqQyIEYOUX42h8jYbAiAqB0QGA0QQ/GgKjITAaAqMhQIMQGG1QMTBSLwxo1/nH12FG6tzj7NBBOvCQawGZoZ18aHICLusHXe/3/98fBl5hNQbQdYAM0JlhRujhgdwCCgyqFoXggwF5hFSAW/+ZGLCtQGBEGWgAmg92D0gtM/gmfmxhzUjLQQAGqBtIzDm02b4xiAswWLphHC0PRquZwR4Co4MBo2l05ITA6ADAaGofDYHREBgNgdEQoHIIjDb2h0rnHzzrzwTquINuBUZqAIMO9AOtCGBC69QzMDDA97YD1SgYxDMwMrEwqFkVg2f6QSf7AwXgAwGgZfofXlxgeHV/H/Bqv48M/6EQnOCA5oOu/7t/bjb4cEDQAYBMzGwMQtLmkIEABlg6grgLskIB4h7QgANIra5LOwPITkbo1gMGtIEC3KsakJM80kAHqTlhdDUA8SE2OhgwWtMMmRAYHQwYTazDOwRANX7DaCSPhsBoCIyGwGgIjIYAdUJgtPMPDkcqzHhS9RA5DPcgZv5BHWhOflngnfx6wPv4nzLAZueZmFkZOLjFGf78/soA7YIzIHe0waf9c4kwsLLzMfz48pJBWMYcfG8/6OT+jy8vMcAGQaA2IcZEGBnh5sBm6eX1Yxk+v7nJwMUrzQA6JBBkxs+vLxnAtwOALWdkAN0OIKboxPDt42OwOCMzC/h2gK8fHkCCnIEBai5mSqbLQACJGYiq8TvUiq/RwYDRCmfIhAAFA4SjsTwaAoM0BEZXAIwmzdEQGA2B0RAYDQEqhcBo5x8ckFTq/FMlUrDOUCM6/6AuMzuwEy8MnHX/DuxYg2bh9Vy7GEA0aNm+oJQxg7RmIANkZp8R0akHzv4LSpmAr/jTdW5jkNUJZwBd+/fg/HyGV/f2Apf7cyCtFMCeLkADCHxiOmC194H6QDP6zMCzAhQNkxn+Aw8NhHT+GeEDEswsnMBrBe8zcAsqgfVwcIuBBw04gYMGwjIW4JUIzKycDM4pJ6ErEDDthQ0E4N8eQObsH5nxPqIHAkCJfHQwYLQGGhIhQGa5MBq7oyEwCENgdAXAaLIcDYHREBgNgdEQoEIIjHb+wYE42Dr/GDGLiCfYvnrQdXusnILgzjyos3///FwGAQl94JL99wySaj4MDy4sgMzEQzwI71z/+fmZgYWVCzj7/4Lh9YODwGX++xk4eCUZvn96wvDv708GWHgoGacxgLYBMMC2FUCX6zOzsDMIAVcNcPPLMfwAzvZzcIsyPLu5kQF0UwC/uD4DaGb/35+f4E0DoMGC38CrBVUtChhe3t3FIK7kxPAXaIeucyt4BQLo6sD//34zsAMHBe6fmwO8QvA7A3wHAQOuAQjY+QUImgFreJHQ8CdjSwDMyhE/EAAKiNHBAIZRMBRCYHQwYDSdDu0QGF0BMJqCR0NgNARGQ2A0BCgMgdHOP7WSENUOicM6EIHe+Ue4GjTbzsYlDOyon2f48fkZAxtwVcBfYOdbQtmNAXRHP2jWnRF+HgAjeCUAaJk+6JC/L+/vMvz59ZlB2TST4cu72wwgMVCHHdTBBy3Zh6wIYGfQsKkAryyA7dNn4xQCLud/xPDpzQ0GNg4BMFtONxo8gPD81hZwxx7SJ4Q1thkYrh1sZABtEfj48jIDaEUAaOb/2sEm4PkD0sDOvyhY7++fH7FEB3FpFHmFACPOMES4B2e8UzAQNDoQAA1V5MEAxtEyZrSaGqwhQER5MBp5oyEwyEJgdAXAaJIcDYHREBgNgdEQIDMERhs+KAFHYSeFtp1/kEsxZ/9BnXET31nAmfcNDKCZeFFFRwY2TmGG39/fgQ/me3x5OQOfqBZwRYABw6+vr4HnAXwBd/5BbgUNDnx9f5/h358fDEzM7Awv7mwHL90HmalomAjZ0y8gD57l//XtNfggQNBgAqSTzcQAGmAAdebZ2PkZtOzrGJ7d2ABe2i8qbwccSLjDwCuizvD13V2wfaDzCDRsyhl+/XjPwAocLADx1SwLGR5cXAQ8e8ASfMAgn4gmw6fX14ADEL8ZQOaC4wYlTohJrzA1jPCDCCH9UGwdUCS12HIQFdLD6GAAUsCODgiM1lSDOgQIlAejsTcaAoMoBEZXAIwmx9EQGA2B0RAYDQEyQmB0Rg4l0AZD5x/v8nPs8QXqYF7YkQ+eTefgkWS4dqCB4en1teDOLzNweT9oOT6okw86J+DPry/gGXxG6FL+R8DBgZ/Ajr19/D6UJf9MTKwMT66vYwDpB8n//vEBvKwftL1A372PAb4VAGgOaN8/aKn/mU0p4G0GX97eZnh4aSkDF3DgAHKQIPSqP5CZ19YygK4N/Pn1FXC7wmvwAAOvkCrDu6enGDTtaoCDGJvAVw0Svv4PuaGO2uEHDSxArjRkYVA2ToecfQDdQoD/IEEcgwtUmrkeHQjAUkSNDgiM1lyDNgSIGWwcjb7REBi4EACl0P+jETAaAqMhMBoCoyEwGgLEh8Bo5x8jrCjo6FE880/Qbka0sQpI4xR0fZ+0hj9w5n4HAxe/PHj/PgePBAOoow862f/983MMoCX8oMMB3zw+Cl4RAFreDzGMEbISANqJl1T1Bs6+X2UAXesH2nwPOhsAdK4A6N7/f8C9+SJyNsC9+7vBqwVAfJgZTMArBGHXA4AGG0ArBP79+wM5c+D/P/DAAUitskkGw5f394Cz//wML+/sBNsN2gIA0gvaBvD28XEG0ECDrG4kcABjHXg7Adg8mM//E2jqMDKCBzekNQIYQG69f34eAxefDMOLuzuRzj9ANeM/XjOx2Pefus0t0JWKo6UWgRD4P9rEHU0jgyUERtPiaFocPCEwugJgNDWOhsBoCIyGwGgIkBACo51/jMAaqM4/3hl/mCtxxxdothu0nB60Fx80E//jywsGY58Z4EP9Pr2+zqDj2Axegs/CxgPu/IM61KBBA1DHm19cl4GTVwp88j5I/PntbeDr+RigHS7QYXycwBUFoI476CA/UKcdNHgA6rSCVxCAzvYHuh/S6Yc0jEErB7iABwKCBgUgahjggwzvnp1mePPoMMPzm5vBh/+BthzwimiAzxvgF9MFuxnkNjXgIYEgfzBA7yCAxxWusIKKwwZhRBUcGEB+A5nz7dNjqB+ZocZgDqTgXm2AJdwZqZt3GBkQcLQIwxEC6KsEiMozo6E5GgK0CIHRVQGj6WrwhMDoCoDR1DgaAqMhMBoCoyFAZAiMdv6xBhSZHTuyZ/6Jto8Rh3MhDVEm4Cn8xj4zGc5vz2XgA3amv39+zgC6Rg80e//393dwR/s/eDb+DwNoVt7AvZ8BdDgfSM29s7PAM+U8QiqQvf0gmxihy/WB7gN10OXAs/HrwXrBd/sLKjN8Bh4S+OnVFQZ16zLgnv+NCPeB9AIPGVQxzQYv/79/bi74YEHQQARIL2TbAXDOAjzAABxG+A8bNGABrwoADWKAViyABiD+//8LXzkAG5DANVuOHAegQRDQtYeMwO0GoMEKfjFt8HYE0I0G8NUE8Bll3LN5qCsDaL8SAFskj64OoKBQH101MFoj0iUERlcEjCa0gQuB0UMAR1PfaAiMhsBoCIyGABEhMNr5xxpIFMzqkjwAQNLsJb7OP8gnjOBO8vNbm4H967/gPfUw/4EGAEDL9EGn+IOX5APv5AfNdMtoBoOv4APt7QepYeMQhFzvB9QIWk3AJ6rNANLz5/dXBlDHG3Q7AEg/2DZGZvDVfCA98vqx4MMCQdf4ga72Ay3jF5Q0Ap7kL8Pw5uEhho/AAQIBSQMGIWlThnfApf0Qd0H9AwuDf6BO/l+gGjOGv0D7xJXdGUDbFBhwdNCRZ8vBbNDWBdD2A+Alg+AtCIyQBZE/v79l4ARug/j64T4DaKACFA7glQ+MkNhiZGJiAK1QQHSwGSGHBQLNYgT6EWQ/xImgLQU48gwj7fPS6OoACgp1XKsGsImP1h2jIUB2CEAGYhkYRuvW0URE/xAYHQAYTXWjITAaAqMhMBoCBEJgtIGCNYDo1fknqeMPcimhzj9UDSNsCIIRfOUej5AyA6ij//3LcwZReVvgifsfwNfrgU7wB4mDlvmzcQqCtwOAlvh/fnsTvET/y7s74JP4WTkFwLP23MAD/H6BbxH4Cwk20IoA4Ow+j6ASA2h2HnRPP2hbAQsbL9COd+CF7KBBAy5+WQZJNR9wxxt08CDoOr8fX1+C9YA66eDD+YAddTYOfgZhWUvwTQHfPjxgAOkFDRzAT/5Hjiz0sGOEdNhB2w1Y2LjAZkMGBBggHXmgPGiFA+gcBNAZAKBbB3gEFRlAKwxA7pECug+0reHl3V2QBfigMAS6CXRIIvigxJ+fGBiQ7MSZRBjpl6fQBz9GizsqhgC2QYFRMUQewBUWo4kQLQRggwGjATMaAvQJgdEzAEZT2mgIjIbAaAiMhgCeEBjt/FM7eRA184/ccCbJAcTEF0INZCb7P/i0eyl1P4af396A99X/+v6eQU4nkgHUkReVt2cALWuH3QgA2nsPOq0fvM8eOOstIAGcrZexYAAdFgjaw/8VeFgfaD8+6HA+FnY+8KACIzMruIOtap7HADLvz6+vQPMjILcKAAcHOLjFwasJ7p2ZwQAaZOAEHsAH6lCDtiAwQmfrBYCrBJhZOBhAS/RBWwxABxWC3AS6hhB7ECGFBazjz8zGAHIjaKm/MnC7ASevNPgcA9DsvYpZDvgwxB/ArRCgTjxoGwDIDtBgwA/goAgLOy94uwFo+wNsSwInnzSDvF4McOsEN/j6RF5RTQZm4JWIHNxiDA4J+xkQs3tY4gVpoICeRRDGaojRGcjRGoDeIUDsIMmIi5nRgYDRzEifEBhdATCa0kZDYDQERkNgNAQYCHagRsMINQTInMEl2PmnqFOIe+Yf9bA6qDqoH0A80D73N4+OMIBP6Aeevv8deAAeaEn9H+CMNmg5PFgHVP3nt7fAM3yQpfEMDKDZfNDSeFDH/fOb6+DZeVAHGTQw8OvHOwZQZx+0FQA0iw5aRfAfuHwfxH/98CADZH8/I8PvX5+h4fufAXTN348vz8Az/CC1ILczQTvVIDttIjcyvH5wgAE0Iw+aoYfN/EOu6WNmgK9rgAcHpFENCwNhGXPgtoFvDKDVBX+BVxuC3A3q5H96fQ2sl0dYDei83wzcwBULYEcBw8M8ZDn4loP/wO0QP76+YBCWs2YArT4ADT58+/gYeGOANHD1gjfwloPv4NsIHJOOMFzYnsfw7dMTwt1rxoEfZBsdFBgt4AZlCOAbKBjWUQYbCBgdgB/NmbQJgdEBgNGUNRoCoyEwGgKjIYAlBEYbHjiTBS07/2SlRVhjEVMz9lPq0QcAkOIauIcetkceYhp07ztwFp5HWJXhz8+PkOW9wE4xpMPNBFwd8Afc+X375Dh4ST2oA//y3m7gtgJ+cEcbtOwfZBZoMAGsBzjjD1pG/x3YORZTcmH4AhxQANvCCDKaCXgdoRS4cw+e/WdgAK9OAN04AOqwC0joM3x4eZEBNEsPMvfnl5dg97hlXGTgA86+g7YCgLYngLYFKBomA1cVnIeuyIf4UcuhHiwG2tYA6vSDBjxA1weqWuQDzyX4BV7xANILOssANNgAOsiQnVsUeDbBQfBKhi/v7oKvB/z0+ir4ekBBCUMG0OAJaNvA39/fwGcp/AEOZtw40gFeEcGAcqAcnjzFOPjy2+igwGjFMKhDANvgwLCMMtzl+2gKHQ0BckNgdABgNO2MhsBoCIyGwGgIoIXAaOcfb5Kg9gAA2bP++Dv+RHf+kfyD3EEH7ccHH8IHlActjwfNeHPwSjBAOvJMDBrW5Qzvn58Fz3B/eHGBAdJhB3Ybgcv9QR1n8Az5v98MoBl6JvAWAEiogmbWQecNgK7Z+/fnO4OcbhTDu6enGECrBrgFFIGd/w8MvEKq4EEA0O0DoGX0//7+AJv/7eMj8JL7Zzc3MoAGECCHDDIyPLiwgOE98KpAMUVnBkFJQ+BBfcwML+7sQNwGAHIlcBDj94/3wBUKVgwfnp9jAG0xAB1CyAjagsAlyvDx9RXwQYTMwG0CoK0LrMCzBr59eAjeEgFS++PrK/CK/p/fXoPPBAB19EFbJEBbBXScWsDXFIIGE0BuZPgHu4ngP/F5i3Hw5ztsgwKMo1sIRmuQwRIC6IMCwypmRgcCRjMa9UJgdABgNDWNhsBoCIyGwGgIIIXAaOcfb3KgReefpPQHawRixhNkRp6RgRGvGxkhM/gMDPCl8uApcgaIPtBeeHEVN3CnF7RcHzS7DdrPDzqgT8EgAXhA32XwLDm/qBaDjFYwuOMOMgk0Gw86WA/UmQa5DHwIIHCVAEiMnUuYQUzRkeH752fgWXPQTLmsVij4RgHQbQK/f3xkAA0GgK4lZAd2xEGdetB+e1CnG7SFAH6TAKijCTTz5d3dDBzAk/pB1/aBOvAgO0B80H59UAcc5H9Q5x20dQG0Fx800w/ro4I67x9enAe74w9wxh7kXtBMP6ijDxqA+PfnJwNosIKZlYNBHDiYALu+ELTNQVDKCHy7AWhrA+hMAJC5ID2gKxNf3d/HANo2AWILAs9EAA8CMJBxzRfj0Mx/owMDo5XIoAyBYTkgMDoQMJrbKA+B0UMAR1PRaAiMhsBoCIyGADQERjv/tEgKOGdIMTp7yJ17XGyEC5E7/IwEO45Q8xihXTXQtXfgxjETA+R0fYQ8aN89aLk96BR8UOdf2SSTAXQ+AGiG/QvwgD9hGUuGH19eMFw90MAAGyAArQYQkbNhAHWOGcFX/v0EOxTUwZZU82YA3dEPWiYPPgwQKHP1YCN4Rv8r8BT/t09Pgg8DZGbhBA4SPAWfGcDCyg2+UQByBgDEjcC9AMB9+crgWX3QzQM/gAMKILtAnX3QQALoEEM5nQjw2QGgwQPQAAHEEYjuKeRQPsggCGjFAtj9wLDgA975D+r4gw4fBLkTdNXfhR35DFwCCuCbCUCH/b1/dgbsPnFlVwbQQAJomwAfcCDkP3CVg1X4OrC7QWKgVRGwwxWxpycC+YwRMUgz1IsmbAMDo8XtaAgMWAggDwgwDP3cxTC6+mY0M5EZAqMrAEaTzmgIjIbAaAiMhgDDaEOCiERAxuws4c4/ckefsBtQZ/kZwR1nBri7sM0MIYlBO/+gK/R+fXsLns2W1Q4FbbIHn/4PMocRukwedLidXfwehntnZ4L3zINm/EH73kHL3UEz+Ry8kgxM0Lv9QWmHW0iJAdRBBu3/B3WkZTSDwR1xkI9As+KgpfdPb6wH3ywAumYQ3DEE3p0POpEfdLI/6C5/0CoCkGtBnf7vn58ywPSCBhHUzPMZIHvsXwFn/8XAqxBA++uZgMv3haRMwXa9f36GAdQBB7n9I/CcAE3bKoYn19eB/Qk9CAB8TgBIXt2ymAHkJtCKAfBWBmDnHjTbDxoUAK04AB1YqGFTwfD1/V0G0Ew/yA8qwFsDnt/cDN5aAFLLwSsF3EpwFn61IWglAWh7BMSM/5SXKozDc0BudLXAaIUzKEJg2AwGMI7W36NZiuQQGB0AGE00oyEwGgKjITDiQ4BxNA0QCgEyO2NYBwCgZsHutYe0Q3HHAebSfkiDD6Rf3boUvGT968eHSD7AMqiAZCeok84rog5WD1qq/hM4m8+IPIgAZINmtUFbAED73EEd7Z/A+/j//vkB7kyD/ATuFIP40KYnSB62H5+NQwA8oAC6Dg80YAAyA3RLgKiCPQNoVv4P9MR/QSkT8In5oGX64DMBgKfpg/wEchvIjaDbA0A+MfaZwXD75GSGv8BzAEArA1TMcxnunJrMwAbcWgDq2IOv7QNuDYBdU/jr+1vgVYN2wCX5Txk+v77OALtpQMu+luHjqysMssBVAs9ubWIAnTcAWkXAwga8wo9LCDyD/xd4JoGySTr4jADQMn/QdYHg0AQONDy/s50BHA7ArQOgrQegVRDcwBUCID8pGaUwvHl8hOE/w3/q5iXGkZM3R1cLjBbDAxYCw2IwYHQgYDQHER8CowMAo6llNARGQ2A0BEZ0CIx2/omKfjI6Yvg6/+Ad+MBOJWipOsh+yH33jAyQzj4DA+79/IzgU/HB1+wB78UHLc0H7aEH70cHH3SH5Bu0Ri0j9CA80Ow26FA/kErwfnydcAbQrDgrsOMOmhWHnVwP3k/PADmZn4mZBbxVAGSEiKwVsBMdCTm4D+gHcEcfuHf+P/RmAF7gbQG/vr0BX6MH6kCDOsogu0DL6sHX9v3/Cz5/QNEwieH1/f3gpf6grQWgmX5xJWfwIIMI8Jo90EqAX9/fMID2/IMGEkD780ErFj6/vckgrREAXnGAPHAB8i5oFQEoLL++v8MAWrYP2ioAm/1/B9xqANoqABpsAJ018PbxUXBgfQMOnoAGQkADHKAtBaBZf5B9IPaXt7fBe/s17WoYQJ3+r8AtEKCwBg2QgG4mAOkFHWoooeLB8BS02gAcmaiDAP//YxsUICHfweJxBJZTo4MCo9Uz3UNgyA8GjA4EjOYawiEwegbAaCoZDYHREBgNgREbAqOdf6KinlqzsEiz7KCOq4xmEANoPzmoIwk+PA+4/F4W2BnnFdEAL8uH71dnQJrRB5ohJG0G1OcGXAovzqBimsUgIm8LPr2eS0Ae2klnZGBAczNsyb0F8D570L33oM4upBN9GjxTDtqLD+rMggYHJFS9wCfkg/bzg/bdf3l3G37oHis7PwO/uC4Dj5AKA+jwPdBSegHQqfvAk/NB4qCD+D4DO82gzjtoqwGoswzaEgDq/IM61aDBAtBJ/aCzAG4e62EAX5/39yfY3aCtAKCOOaiTDbr3H7yHH3RWAXBgAbY8//65OQyg+/pBWxMgfmQEhxVoQEQKOCgA6oiD1P4D3tf/4s5OcDiA/Q7crgBaaQCaoQd19t8+PgYOe8ghgP/B5wqA/C6vF80AWu4POduAGTw4YeQ9nQF0JsId4CoEkB9+A1cw/P75GeyOXz8+MIBWK5xaH0f7UoRxNL+CAnl0UGC0yqZbCAzpwbfRgYDRnII7BEZXAIymjtEQGA2B0RAYkSEw2pmgZeef4Ow/sGH5+c1N8J540KFxYopODF8/3ANfLweaPYctk4e7EdoQBZkLuo4O1Inn4BEHd35f3dsL3h8P2rMOuvoO0uxD7SbB9veDOseg0+pBM+OfXl5m0LCphF5f9w5sFjdwEAF0Nz6oww46mR900j/oYDyQe0CdZ9BNAKAZeZA9oM47eAsB8Fo8AXF9BtAMPajjDTpB/9GlJQygAwRBqwhAJ+iD5H98e8UA2vP/++dHBtAqAZA7QZ1+EVlr8F570AqCL8DZfcg5A08ZQKf4g/wP2j4A6uCDBjhAnW1Q+IBm+kFyus5tQC/9BR9KCFrKD+rY8wCvEARvSQAvx4cMhoAGSsA3BgAHKkDbAECrHUAdfVXzPPAgASg85HQiGT6/vcUAGgR4/fAggzRwgOYX0G/3z89leHJtNQNocOIbcJsCaMAGdDsBaMADdHsA6EBABrKW/pORB0cHAbBm29FBgdFqnKYhMKRXBYwOBIzmDswQGB0AGE0VoyEwGgKjITDiQmC08090lFN96T+4S8sAu28f1BnlE9UE7y2XUHZnePvkBHj/PHg5PQN0KwATE0Q9WCsT8Ho6JwbQrDzowDlQJxm0V17BIJ7h2oFGiLfQoxfqB5CdX4AdXNDMPaizDup8g5b2v3t6GnIgoE4Yw4dnZxlAe/lBHX3QoX6g5fASym7gvfugzveHFxcZQHvpr+yrBu+hVzbNBG9JAF2txwCdrZcEriAAHRIIuuoPNKgBOikfNKsPchzosD/QrPvX9/cZQKsQ/gNn6kH3+cNO4wcNGoDkQdcIgrYigPga1mXAvftXGYRlLBhAnXxQpxtkFmiQAnS7AGipPmjgAbQ1AdSp5xPVYPj05jo4LCDtdkbgnv7zDKBbDUDhBtoiANrrz8LGC+zYr2EADTqAwuYD8OBA0J7+R1dWgG8oYGblYtB2aGQ4vz0XPDDDL6bLAAo/TdtKBtCBhqDBANhABOyqQroUJUN6VpJ+hS36oMBoRTcaAlQJgSGb/0YHAkZzACIERgcARlPDaAiMhsBoCIyoEBjt/BMd3WTOthKa/QfZD9njz8zAI6gIvE8/hIGNQxC8jB/Uyf38+hp4phw0swy6kx80Ww466f7Tm2vggYBvn54w6Ll2gQcNhKXNGUAdV9By/bdPTyAuhQK39RgZ4Mvkoff8g2btQXvWQR1u0DkAz25tYXBMPAg87X8W+MA88Cy/fjzQ7NcMoL32oI4taMk9O7cIw88vL8H2v3qwnwG0jx40kMAjqAw+FV/Nsgg8eAHqsH8DXu0H6pSf357DIAbc0w9aqQA6GBB0TR9owEMReGAeSD/oVgEmFjbwknvQgAdozz5oUEISuJ+elYOPAbS6ALRN4e2Tk8DBgm8MIDnQtXwg/4K8pwKcvQfZ8///HwZe4JYEUJjyi+sADwcUAV87CD6NHxzZkLMVbKK2MNw7MxMo8g/cwUdeSSCh6skAOvQPFLag1QagGf0vwBsAngPDBzSAAVryDzkb4CfDM+BNACB5FnZehv9/fzEIAs9iAB1ECD6PALzf/z99SpTR1QAkhfPogMBoVU/VEBjSAwGjaWGkhwCoDv0/mgxGQ2A0BEZDYDQERkIIjHb+SYplGs7+g/b3gzrLoBlxHacW4Iz1DQbY3nfQcnTQ4XygDiwP8EA90JL2z8AZbdA+fdCVdTeP9zKAVgu8AR5iB7nL/je4QwtigzrwoH32oNl1JhZ28OF+oEPoIIflMYJn60Ez26CZd9OA+eCl8/eA++pBHWnQTDxowAA0sw6eiQfN6AMxmA/cQw+amZfRCgW7E9Q51nPpZAB1mD++uszAySsNHAA4DpxllwVf0Qda6g/qUDOxcDCA3QPc5w8a5BCQ0Acf6vcHeJI+ZBUEC3h1AXiFANAuI6+pDBd2FDA8uDCfQVzJFXoWwn/w8nvQoAVIH6izDTlwkAl+1gHI/aDzB0DuBh1o+BN4EwBo+8F/8PkB4NBGGgwBpQJE0wekB+RGdm4x8JV+8noxDI8uL2MAbbUALfcH3TwAWmkBOpcAdKjhy3t7wMkI7MfPzxj03HoYbh7tAouBBkQeA7cLMCANBGA/BBA5JVKhGfZ/tClHaQlO9RscRivVkRUCQzIPjpYbIzWbjq4AGC2gR0NgNARGQ4BhtPM/mgjQQoAms/8gOyCz0aAD50Az+yAR0E0AoA4/6Eo60MF3oJlpUEcctBwd1MEGrQSQBM5Qg2biQUvgQR1r0BJ6UAcapB7UqQZ13kF8Ga0QBlEFR/CsNGjQAHyaPQNi6SdoFhQ2M/7s5iaG1w8OMPwBHmgH2h8PmdACnQ2MWDmgblUCXgkgBFx+D9pXD5r1Bp9XAD0N/82jw+BD8ED7+sEDEP/+gPf+CwIPBuTgkWQAzfp/fnuD4creSnCHHjzIARyYAK18AHWw2blFwQMGIHeC7vR/cm0tsPO9lEFCxROy7QEaD6DOPGiQ4duH++Cr9uCrLEDyoE4+sPENWm0A8vOvnx8YQCsOQFskICEOjVtGWDhAG73QBjsjdJBDwTCBAdTZB51vALpKEDi9z/D7+3vwAYCgww8NvSYz3D83lwG0FQAU3qDtBizsfODDAEFDDPL6sQy3TvQzoJ8HwEiPmfrRbQEUF2GjKwSGXy2A7WwIXGKUJyBGjMNXB3+Ijm4LGKltn9EBgNFW72gIjIbAaAgM+xAYnfknKYqp2fkHWYxmHqhD+Bc4Iw7qNINm6kFLy0H760Hi7MC77UH730EdfdD+fNAec1AHFTab/f3TU/CJ/KCl/KBOM2jGWd26HHwlHuigPtDBff9+f2cALdkHzdyDlqeD9q0zQLcEMEKvAgSZCVsVAD4gkIEB3HEHdbL5xXQYwNfu/fsN7kiDZvE/v7nBoADcGgDq9PIKqzGADtsDDVjAZuJBqwP4RbUZQHvxQWcE7JymzSCl4c8AXh3AIwEcCPBlgB1ECBrYAB22B7qST92qFLiffiMDCzsPA2gGX0LFHbxqAWTn81ubgTcO6DOABwmA1wqCDuQD77kHdtwhWyhAgynM4PMLQAcXgq7s4wXu/wedQfDy3m4GSEf8P6RRDo8D1AYvaNYX5AdQB//D83MMoLMBQIMqoPAGRR1oQOUj8GwA0G0Grx8dAt+48OLOdvDKBE6gv0A3HIC2CIDUvQZujYBtm2CAHUBIVMKjYv5kHM3r1CrOkTuKo5Xk4A4BanTqqTYAxDg6EDCaXwZ/CIwOAIym0tEQGA2B0RAY1iEw2iEgOXppNvuPcAl4/x3wPnzQUnHQ/nPQEnNlkwzgQXeWDC/vQ5aYgzrMahYF4BlmZZN0BtB2ANAhdiA9tjE7GB5eWMjw5883hufAmXzQPnjQ1XugzjVoxQDo7n3Qaf+fXl2BzpjDlsEzMYA6raCOPmhJPchOUAcXJAvSCzqDgBt4LsGHFxeAB98JM4DMAm0XAM2Gf3x5ieH75ycMoPv0QT4RkjEHX0UorRnIADqY7/evTwyg7QVvHx8Hd/hBbFCn/vjqUAY14EqC4yuDgCfrB4MDATRYAdrzD9oCARpcAIUH6FwD0OAC6D59RmYWBtCVhR+enwcPJIAGHED+A29RYGZl0LStZgBdJQg6QFFeP4YBdOUfaHAAtGT/2Y0NDP+hVwcyonX8YQMHIL+CTvKHLdUHuQO0CgM08w+Z/f/PABok+QP0k7ZDAwNotQRoNcBH4M0JoMMOQbcw/Pn9BXxd4r8/3xlAAy+g2w44uMUZvn58wADbejAgRctIWg0A8ysyTYNAH10dMLgqSXrEB8UDQENyMG60vTBSGsTgNsho6380BEZDYDQERkNgOIbAaGU+oJ1/kOVYG4GQbQAM0CP7QLPnkBl5ZnAHmg24CgB0wJ6OcyvDlX014MPvQMvOQSfbg5a2g5bOgzrWP4CH8oH4/OJ6DM+As+XgBisTM9jL3MDD+UAd/C/v7jKAZq9h4QBaFaBpV83wCrj0H3TWAEj876+v4EECLj5ZBlDH9hdw2TtoZQK48wxcHm8WuIjh7ulpDKBBAdBee3ElFwbQ+QNSar7gw/ZAs93MrNzg2wNAS+JBp+1z8ssy/P7xkeHk2kgG78LH4DMKQIMcoG0CoOsPQSsgmFk4wecJSKr5gAcVQAcEggYbYCfrgzr8vCLqDCB/gs4cAPFBYQWacQct7/8JXBUAcj9otQKo4//u2RmwG/5DtwQg7+kGHxYI3J4AUi+rE8EA2mbx4u5OyNkJ8K0AkBUFoIEF8HWFwHAAX2X48xPk9gHgFYAgv4LEVM3zwWECGoCAdPYZGUCDLXLA8wMeXFgAXklA2jkAIJfRaD/uUD4fgJqdKBqGw+j5AbSvPxkZBr4+IzueR88HYBgFgysEmEYjZDQERkNgNARGQ2A4hsBo55/kWKX7jA2kwwfqQIIwL/A6QND1eaAOLeie+uuHWoG3BCiBD9gD7TkHLecXkbdjgB12B5rJ/wfs1H77+BB8XR34Gj4GUB/4LwPohH3Qknj49XpAvzED996z84iDT8kH3RoAOodA3bIYfDAgr7A6+Kq7n19fM/CJaYPFGKBmnVoXC+ygn2IAdcBBB+V9fnebAXQg3ptHR8A3GICW/f8HbhcAHTooJG3G8OvHe4YjS73AKw1c0s4ybO2XZdg2URF82N+hxW4MMtqh4K0FoG0PUuq+wNn1jeAr/kANfG3HRvDVfCB/gpb1gzr54PMNwLcYMIFIBtCKAXbgTDuoU8/JJwNeNQG6npAB3shmhG43YAaehWDMoGScBj4TQVDKBDyrD1ph8P7FefDsPSTM/oMHDkBs0GAKaDABNGgCOu9AWjMIPCgCGoQAdf5B8QSKn1vHesDbJETkbBhA2xnePz8L7vS/BR7MCApz9LTHOJCzgTSeHada6Unr2Xx086lY7I+uEKBNHTrYtmHA3ENW3TLkVgSMtiGGc9t4dABgtOczGgKjITAaAsMuBEYrbnpGKTkzU5gnwzOCl/qD9viDZslBe9BB+/xBHU5Qp5uDVwo8kw/apy4iZwv2HqgTDupYfv3wkOHGkXYGkHrQrDoPcI8+SAFsvzxk7z0zg4ZNBbgT/+/PT4ZXwJPsQZ3cm8COLOwGANAsO+Rmgu8MoNl9yEz6P/BgALjzDFxdYOwzA9yJBu2TB3WE75+fB3aLln09A2jVwvtnpxn4RDQZDIGn+YO2AID21AdVf4NGByODbfR2hidXV4MHIbiAqwT+At0Ccs/DS0vA9tw40sGgBNwKAVpKDxpwAF0FCPYHI2JfLchdoHAADYA8ANoPCi/QoAjsykPQagqQ3XwiGuAZftDqCZCcrE449JwDKQZQOElpBIDDAzwAA1oD8fc3+HwF0BkCoFURoPAF+REU/qBrC8EDDKBBBiAG6QENoLy6v58B5laQGGiLAGwFAulpkA75djANBtCwQ05U2COlKWqXF4Ot4zqUqrihEHYUDQQwDK3YYGAYbU8wDEMwegYAwygYDYHREBgNgeEUAqOVNVmxScHsDN4BAAxzEfEDO4QPtKydjVMY2HFWB8/4gw7aA83Wg2bUX9zeyiCm6MgA6oSCZqZBHdLvnx6BZ+v//P7KALpaj19Cj+H7x0cMrGy84C0EHDxiDKCD/MAH0jGAJsMZGeT0ohlAKwJAB+m9e3ICfNo9pBMPvEIQdBYBKNCAHVvQfnZQR/7tk+MM4OXuwC0AoNl20B55UEccdEgh+Mo+hn8MoM47t6ACcCn8VAbQlgHQKgDQAAK3gDxk1QLQTaAl/aBZetCgBWiA4u/fHwyy2uHAqwB3MYBuFQCtVABZDdrKAJtdf3B+Lvj8AdAhiSA3gFY+gDr7oAELUJiBBgZAbhGWNmcAhdFP4FYI0KoD4JQ8A+ywQ9DBgSBzQQcqgm4OALkLdDYAyDxQGIJuPgDN2oPcDD6wD7x64D/D53e3gKsdTgNXDaSCwwsUW6BzF0BhBztXAJa+QO75+e0tAyhMYWYMqaXg9BwMoPXsPt5MD4pFdIykgYYDASBbRlcHMBCIHdQQGpDaGFv6xCWGnHTI6RzTOL3RJvxg+YdhFAyTEBgdABhNyqMhMBoCoyEwbEJgtPNPVlTSqvMPcgyhAQBgB1vRIIGBW1CJ4Stwvz7oMDlQmxJ0hR6oswu6co9fXJcBNCv9B7hXX9U8hwG0TP/j66vgzv/3z0/B++ghHeM/DNwCigy6rp3gO/lBAwDgZhvQDaCbANi4RMADB6ADAkEz6KBDBUGn7n9+fZ0B0oH9Bw4+0P56RtiSe6D79Ny6wTPn3z48YADpA3XMQbP24A498AA8Desy8FWAoE789UPNDDxCKuABBtBZAiBzQQcEMjIxMYDsBXX6Xz88yMAFHCT4DrxDHzSzDtrTD7IP5HbQOQcGHhMYXt3fCzm8EGj/31+gw/ZEGUCH7IGuPAQd1vcbuM0ANMgBcjD4LAPgvv//wEEJiH+ZGAQlDBhAfgbdpAByJ+SKRVbgCoRtDI+vrgJvTwCZBzILci0isOsOul0AaCBoIAUU1p9eXWb4CvQzaDAGdJ4BZAsA8j59kJ6/kHMHGJDEcez3JW4bwADlYSI6OwTzFr5OFF3LWDydfbg7kNVABenUMRsdEIAcSEr2LDqpaYmYzj1GusBjCVo6GTmrAcAVGsMoGB4hMDoAMJqSR0NgNARGQ2BYhMBo55/saBzIAQCgoz++usQAOhUfNIsN6owKShkzgDrHbOz84BPwvwEPn+PklWTg5pcH3zMPWhYvpxMJ7niCZqc5gfftgw7VAy2DB3W2QR110In9f4CH8EHChBF8Yj7oAEDQAXygwQZhGUvwWQLvgQfngfSBZsRBs9egTiozCweDPHDFAOgwPNBgw/vnZ8ArDEBL3uV0I8Ez5Jp2VQwgd4GW+H95f48BtO8dNCsvCjyjAGQnaEUAaDUBaF89yG+g5figO/o5uMUYQPv6QTTo7ALQUnyQHpCbDi12YQANBrx7doqBAelgPlCY8Evog+/kB7mHV1gFvO9ezaKQ4fGVFZBDDv//g3mVAdS9AN1WAOqw8wK3I4C2GoDcClzvzwBaBcABPAcBtEKAiYWNARRuIPf9h64AAOkBrWz4+e0VeI8/aIUAyH2gwRSEGqSU9p8WB/cNorxMTOeJTh1n/Pkbs0MPu/GBEI1hLp39gz4gwDhMl1xTZWk/KemRqHhEpBvQVihIWoGlCPSBJLQ0hlZvMI6uBmAYBUMnBECp+f9ohI2GwGgIjIbAaAgM5RAY7fyTHXu07PyDHEVoBQD4Xn5GBtgtACrmuQygQ+pAy/1BJ+qDxEEdb0PPyQy3jveBZ6RBM/Sg5eegE+fvnZkBnikHXd8HOp3/3NZs6KF1LyD726Ez0yBz4LcOAN0EMht0FSB4OT/IjeAONCN4Hz5ouwFosAB0Nz5o1h7UOQcNSGjYlDPcPNoNdiuoQw7qvINm1z+9vsYAUgsapACZCzKTHbjaADQIANp/DxqkAHWeQZ170MAEaAk+BP9kAB1iCGKDtgqA2KBOOmhmHrTq4d3TU+CtBaAtEaArA0HBqW5VCt6nf2ChI2TmHTTzDz31H3mGHrwiAj6IwATeKqDv1gsMw16wfiEpU4YHFxeCBxLA1wuCwgmpM/8fhQ9ZHcDAgNZcgqr/j3f2H7OJ9Z/oQYOR2DxjpCArQ/UyQo+3gg/qIHfoGBgckw4zHJhvDxYEbb8BH2IJvTYSq+X/B0c8DLWbBqgykMFIq7oN1VxQ+Qg6eFVU3hZ4o8oWcNmCnhZAK5u4BBTA56eA5OADgmjpY/SmgNHW5FAIgdEVAKPpdDQERkNgNASGdAiMdv7Jjj4KG5dENXCJGQBggN7RD6T1XbsZ3j89DV5SD+pgi8haM4AO53txezuDqKID+PT8T8Al+6AZdNDyddBsOmg5PWi2//65OcCJ8z/Qa/8gnRZGJLMRE1TAxfLAw/d+fX/DALuBABSGoE6ztLo/g4SyG3i5PmjgAbSHHnS/P6hjDjr1H+RSUKf/F3DvO2jmHLQkH7TUHrJywYQBtK+emZkdfOK/uJIr8GDDKwygk/RBhwOC3Pzj6wsG0OAG6JBDVk5BSCceeJMB6OrD/39/gd0DOv0fNMABMlMUeP7Bp1dXoQMB3xhe3N3FcO/sTAbYVYEQdzOBl/TD0gFiqT0kDKQ1A8FXEr68t5tBTMGBATTTB7qSEHQVIGhp/3/o9YAw/dg7/2ipjIJOIfE3Agy3vI1vRhUmR15uhocpIxM47Rl6TmQAXfPIAEkgDKBDLH98ec4AumUDdK4G6PYGp+RjDKABNNBAFWRwB0d4Mw6OeMC2UmCwrBag6ioG5Fl+mtTNmJ1/0HWemraVwLNJdjOAtheBV0MBDz0FbTP6+e01A2Sg6Bf4oFXQ1aSgW1NEZK0YPry8yMBAjZUA0HTKMOTAaPuDYYiC0QEAhlEwGgKjITAaAkM1BEYrX4pibhANAIA656C95qDZfdCVdjJawQyg/fCiCvYMoGX6wrKWDK+BJ86D7poHzZiDrtADXT8H6px/B24R+PbpCQN4DzywAwRabg+6Wx802w7u2MAa1P9R96+Dhx3A/S7YCgQmBlYOfvB99oxMrOCGMGhWDHLA3x/w+AHo0EHQwMC/f78YQMv0QZ1/0JV9N492gg8qBImBtgVw8EgwvHtykgG0tQB0cOC3jw8g++lZuRhA+/FBnW5u4GwayCzQzQegBja4IQ10Izu3CANoBYIgcJYedPjfhxcXGHiBJ/qDlvGDBh9AnXaIsxnB4hIqbgyglQYC4noMn6DnGYDONoCsPPjHANoWYR60GHiuwD4GBeB5C/fPzWYAXS3IL6rN8AV46B9kBQAkJaHO3uGY+UVfKQBLhCQMCoyMQQD0Dj/1y1nY8n6IyYwM4PMqgHkAlGdAq1dA4qA0xMrGAx4EAuUdXuAtGaD0dv1QE/g8DVAeQRQFg3sQAFsI4hoYgIlTI9TpYQcDrJyCOxiSfiCro2CXlpGbppD1QVMLI6jcg4iDzjV5Bxx4BZVdoLJJQNIQXHaB+NoODQxvHhxkAN0iAjrnhAt49ejTG+sYPgCvEsUVtmQPzGCEwVBom8DCdrQlOZRCYHQAYDS9jobAaAiMhsCQDIHRzj9F0UaPzj/IgcRuAYBOz7MAT/L/ATzYD9Z5VTXPA9/BD5oFZ2HjBs5AcYNXB0hp+IEHCECNY9BJ/L++vwUHB6izA+oUgU7ef35rM3jFAHI4wTq4jEhbD0CzXOBZUOBtAKBOE2iwAXQ6P7eQMgNolYEA8EC9b+/vg42RBl6dB5qhB50TAFvKr+fSyaBolAJeOQCaoQd1xBWNUxnePDwMvhsfdCsA6HwD0DkBoJl/iF3/wJ32l3d3M8jpRoH9xMUnC77jH6T/89vbwPMANBgeXFgInu0HDxoAr+kDDSjABjVAnTjQHn3QKgVh4GzcS+DBgaCVA4JSRsB7/w3B1/N9fHUFuHjhF8Mj4FkBIL88ubaWAbSdALTy4e3jYwyQWwBoWQDgzqfDcxAAs6MFyQaQzha4Mwc8EBJMM0BuqEDtxBMXF5h6GMEzsa/u7wOnWVCHDpQ+QFtRQCtPQMv82biEwGdV/PrxgeH3zw/gVSWwsyuIsnVIds5QD9wj1JHHJc9A0yzCiDGLjrxdCXSDB2jg8d+fHwyYxTb6gAAuPsID6INGMENBHX9QugStUILcsMLPAFrNBConQGXOF+AhraAbR0CrSSCrof4jG0rdEGIcivX7aJuEYQiB0QEAhlEwGgKjITAaAkMtBEYrWopijAqNK6JneHAMACA6f5DZd9BheSCxH19fMoCWzoM6LqDr5UB7Tl8Cl72DOq/KppkMH19cZAAtZQbdDvD20RHw4X6gTiyocQy7f17TthqsBjSLBbq+DtSAZmHnBXfGYYfrQVYccAAbuGzgZfegGXfQsnqQv0B78EEDAb++vmYA7b8HrTQAz5ICNYHkQDcVsABn8kF7YkEH+T25vpbh1YP9DC/v7QF3qEH364MazUzAJbSgBjPolH5Q4xp0cwD4ykMOQQbQgABoth4kDto2wAp03/tnZ8H39n/5cA/ciQOtYIAs9Qc1tBGNbXATnxHS0AcNRnABD0f88vYm2M+gqw1BbgetTJDXi2F4fnMTOKmABlT4gSsE3j09CTYb5DbY1YbwtMTISPfj14bHIAD2Tj8sXNHTOigNgbddoK2YgHXM8IUJ9sECaHkIndEFzdqC0isojYK2loAOudSyr2MAD/gA9/oLS5uB8xGok4dIX8glCoHylXG0/KVKjYlzQAUSvqC4Bl1BCsq3oFUboLIGtFoHoo24OEBOU5hpBzLwADn8jxl8ewnoClSQfaCtTaCl/qCBTdBNIKDBV5B+UQVHhifAW0QgZcc/vMFAcWkyOggw2jSlYQiMDgCMJq/REBgNgdEQGFIhMNr4pDi6Bs0AAKTzr2ZVDN63D+rsy2qHMTwDdlpBAwGgGXZQ5xt0KwBo9kkQuCwVNFv/5uEhhtdADLoVADS7DjrZHnTAHmh2HTTb+QrYEQd10kGn7oNnu6F73EGDCMgH2YE6waAl/5CVBZwMPILKDKD9ruB77YGdM3CnHbgvH5TiQDP+oIP+QDcQcHCLM4Bo0LJ+UFzounQA9/6fg86mMwKvIDzGALp7X0LVE7ydAHS4H8hu0PJ9UXl7BlDjGXR2Aajh/ejyUgbQSf0gPngAA2TZ/7/wA/5A5oNWNbx+cIAB1CgHuek/7MR/BsjAAMjNzMABCZAdrMDBBZiehxcXMkAGRf4xgE79B/kVfOAgMDx+//wEP0cAkRyA8cHMArYbMhJAn8Pfhu4gAKzjjztHonf+QfEAWtUCmpEHXWEJGZDCLNOwddyQzYLMECPZzwjJS6AOHKjjD9q6AqJB12mqmGaBD8SEDWSB8oWySQbD20dHyS9KRgcBKAs7nOGH6PyD4hg0uCkGPAcEFGegMztA25wgFjMywAYCcKUVSHphBK4k0mYArfpApDVougGnGWYGJeDqpR9fnjGoWRYxgG77gMz+CzCABo2eXV/PADrkFDTY+RF4LSh4W9Ovz5AygogQGLmDAKPtlMHerBwdABjt+oyGwGgIjIbAkAmB0UqV4qiiZ+cf5FgM+0ANV2g8Avcqg5acgma6QXv+3z4+ygA6AwC0nB+kAtRxBi1pVzHJZAAdYPcauA/1DXTWHzSrD+pAgTALeH/ze8hJ967d4EPuQNfl8YP3xF9jkFDxYADNnv3++RkefKB7+UGdetByedDqANAKAtB+fNi+aZBC0CnXIOeDTv8Hd9iBM/qgDjSo8wzupwM74KDVCZz8ssAl98YMoD39oO0DoP3XoFkyPuAee23HBvDBWqBZWRZWbgbQgXzfgY1t0AABaNWBuLI7+ApEUMeeiZGZgRs4CAFyF8gOUIMd3LgH2gsa4ODil2PQtKlkeHFnJ3SmHnp3PzAcQSsIBCSNGEA0aKk3aGb3O/DQN1AH4j94MOMvA2hFA+TQQ1jH/j986TFoMAQ0iMAK3IIB6nBo2lYxPL25kQE1CmmX/0gbBBjIcgDW6SbsBpQOOyNkcTl4AAuYhkGdqyfX1jCgBjA2M5Hsg+YXcOTDZo+hNMh0duD1jkLSpuAzJkB7tZmA11m+Bm4JAOUD0JkZkqreDKCzAED5C3SwJnJaxyxXiAjj0UEA0otjvGHGCE0OqOUj6DyRz29ugAcYQWXAn58fGVTMshhAK4bwOgCUXqAH+YEGHUFlELhDDk5SkPQIugoUNNgqoxnMcOf0VPCAIaicAg1Wfnh+nkFcxR28sgm0LQs0uARKV6AtRwh7CW8DoMogwJBMa6PtlcHctBwdAGAYBaMhMBoCoyEwFEJgtDKlOJao1IgiqUGHawAAdFo5Ewv4SjrQUtO/f38wgO7zZwbu87cIWc7w+OpKBlCnHHQt1cNLSxhktEIYPjw/xyCh6sUAWhEA2qcKOiQQ3MH99xfccAV1Wq8eqAN3aoWkTBhAy91BjVvQAAOsQw1b4w5uAwMP+gPNrEsCzfwJPNUfNJhgHrQUfA2hiJw1eNAAtGLg7ZPjDKCVCd8+PAAv0Qd10F/c2Qbu8HMLKjKAZltBNwKAZsfeA6/uA3WyBYEdsdvAawtB1wKC9u+DZnxBbnh5dyfDV+B5AqCl+qCl2aCZWFDDGrxNADigADrAELTCAHT+AOSKQlCs/2cw8ZnJAGp4gw7e+v7pMQNkxv87eBYf5B7Qqe6gawNBAyqgMwRAKyZAB/39h13vBhoEYEDq+DPA5pAhAzKgjgWoMwCyX82qiOHE2kjESgBgHEK2SPwjMwkSl3cZSUqfsI4xPcou4jv9MNegztYDwxqY1pnZuMCHO/75/YVBD7hqBBTWz29tZVA2SUc7UA2LfYyQDptZ4CIG0NkWsK0sEFFGkAUMoJUsoEEkyCqP3wygczAMPSeBl/6DDpoUV3ZluAE8rBI00AXpPKJuLSErJGEDEaOVKP4QIBhOaJ1/YEEFOsjzGzivc4LLN9CgJ+iEflDaAq3sAOX7n8AtUxCLkdMMJD2AVkOBzi+R1ghkAF0rCtoGBNqGBLrRhBF6BgqofAOJfXh5gQE0CCinF80A0gcqP0DblEBbi0DlIujsEdDAJej2EwaG/wMT26ODAKO5jIohMDoAMJqcRkNgNARGQ2DQh8Bo558qUUSFBhRZszko9kKWKoPu2gddJWXgMYHhNXD/vCDwoL1/wEEAUEcYNOMlruQM3AqwmQF0XZ2Bx0SGx5eXMYCWpn4EnogP6tCD9sSC9veDZu9BS+NBJ92/Ah6CB5rlBB3UBzrsDtSBBnWIIY3e/+AeLzglMUI6vaBOLegAPlCnGtQBBi2xff3wIAOvqCbwML6b8OsEeQSVGEAzt+CbBoCDDWzA6/tADWXQrBwoXkD7/EEDAOAtA+DtBv/AgxdyOpEMoO0EoA4f6PBBkH2ggQBQA5yJhZ0BdG0h6HR/0JYF0GFsoAO3QDO1oH2+oOW2oGW3sAb+89tbwQMSoG0Df359ZRCWsWAALQsGNcZB6kGdPlCDHcT/CLw2ELTiQcu+Fjx7h552QB0IUGcRtEoANPgAchtopYW+Wzd4+wVohQGowQ8aPAC5mQl4rSFo6TpoiwH47m8aZkfYcmbi0zutBgJI7/TD3Axbeg0614KBEZLeQStOQAe58QBP4AeFPej6vafX14G1gDpzoAEtUJyBBWCdRSgNSsOgVSyQqyF/A/PBNwbv/PsMN492M8BXAwAZoGskfwEP9wOlLzXLYgbQlhgWdh4G0Moa0OwvqAPIDVxFAlr6D5rhBaW939/fgQe1sIc3CRHNOFpG40yzRIUNpEyCmMEIHsQEbdkB5VF2LlEG0FYnUJkBiltQfgWtNrKJ3spw81g3ZJsPsh3QwSJQmQLatgQqU0GDl+CrS39/hSQx6EGUkAT0n0FK3Y/hx9dX4C1LoCsBQYegggYZQXpBZRvoLBR42Q8bVGQgJZdSKX0M2UGA0fwx2JqZowMADKNgNARGQ2A0BAZzCIxWnFSJHSo1nKgzAMAA7iD//fONAdQwBZ2KD+oU3T8/lwE02wS69u7Zzc0MkNn9P+CD+kD353///IyBAboMGrSfGdQxAu3bFwQufQfdsw/qCIOuCQTp5YN24kEdY7jXoZ0xUKMX3EkDzoqDZuNBM2ugPf3aDvXgg7CUjdMZ7gKXwzJA99qDZt1AnW1QYxq03x404AAaFHj39AQDyA38YtrAA/heMoA63yA+uJEO3McPWoL/B7zX/j8DaGYWdMYBaJABdHAfaNsC6HwCkLmghrqmXTXDpV0lDMbe08EHG4LMAC3bBTXKQR1E0NYCUBiBwgo0U//28XEGyAn+/4GrE8LB2wikNYPAs8CgmV/QNgTQtgmE30F9CkYG8AF0QH+BaNDgCmhLAmhlAiicQHxQJwF0tSID0P2ggxZB4QIa/ACpA9sJOp8AKUESnx5Iy8eMJKdXtBlQkjINul7yyxyYu0EDNXwimgygVR6gDhSfmA4DKF3xiWkx3Dk1mQE0Myum6AxcDXKHAZSWXj86xID1YEDoTO33j48YQINUoMEx0IqVo8v9wCs0EPu/mSADXMD8YR68hOHaoRZwXgJ19EGdONDgDSid/fn9jQGUBkGrD+T0ohjePTsDHliDpF0Ky9rRQQDUVAcbyCGYFiHhDi47QCujmFkZQJEJWh0EWrkBGuwEpaXf398zgFYWgQZHQVuSzmxMAp/tAEm9kAEE0EAT2DSg3Qr6ccD4PQUeIACt+gCtAgDt8QeVd6AtKJB08Z0BpAc0UAVaRQQSA5etwBUroC0ioPIGNDgFujVCQMKQgVdYlQG0fYThP+mrgRgZRvIgAAMDA8NoW2YwtTRHBwBGez6jITAaAqMhMKhDYLTSpDh6qNgwp84AAChO/zP8/fsTfJgeaE/rr+9vGEANUNBsPWjvP4+wCsPPLy/AnRzQVXagTgsoHBQNk8D32qtZFjKATs8HDSKAZqnBy+WBjVLYkvevwCurwEtVocmHEdr5B11hBbIL5g/QsmzQ1YOg2VXQlXygFQagTi9kdp2BAbRUH9RuA83cg+7nB7kDNJP67skJcLRAGu2MDKb+8yB784GNd1ntcPB2BdCJ/6DtAXwi6gwgf4E60aDtAKA92CD7GKBbF0AG/fj8HLyl4CvwBgAZYEf+E3DPL2gLA8j5IL2glQCgGWTQQABILciN/6GHG359f5dB26kZaOdZBtChgqDOHSjMYI10WCcRdCicll0teKkvaHuFrE4EMMxtgR1LWQbQUl/Q4AZogAXU4FcwSACfXQByG2iAALTcGHSzAPwAQmxpimA6Iy0vk74aADmnYOvU4xKjTgHIiDTaAmKDOvmgpf7Pb20BL/3/8v4OeHm1MvBMC9B2jvfAPdag9PPh5UXwlXywQyARnXpGBsgVbYwM5sHLGEB3r/MIKDK8AQ4WgDpyzCyc4PSpBNxCABpkAM34g86AAN3nzsknBc8/kI7fLfABl98+PmaAHW4JOiMAtJoGNFgGulkDeyiQWP6ODgIwQAsGIhMVI1Q5I/iKU9D+e9BqD1B8gAblQCs3QNuMQHfvg652BMUXaHUO6IpReYN48CogUHkJSiegFQKgQUDwdaPAcwIgZcB/Bsh5E6vBZRCo/AOlAVB5CSqb5PVjGN4/Pc0A2noFWgkFKmssw9cwgA5aBa8gAZ6v8hWYbkHpihu4Egq0cgs0MAC/jnSg2g5DNp2NtmcYBgkYHQBgGAWjITAaAqMhMFhDYLSypDhmBrrzD/IAihsQDV6w30Cd9n+/wVf0gTqakPvyf4E7KeB9+0j7TUVkrRlAy+WZgcvn+YCz7qAVAexcwuAT+EEdetDVgeAZdwbUK/Mgk6hAFcBZLTXLAuAy16sMkmreDOBr+ID2g/Zgg2a3wbPuf76DT8KGOJuJATTbCuoUgwYpQCsBQOKgJbiwPdg8QsoMoMY56JwA0NJ8HiFVBtAAA7iD/h9y1z9sVQDojnbQ4YSQOP0PXX37D7yPH7T0/9+/X+BD/ECzbk9vrGeA7LVlZAB1yEGzfqAOAGiGDoRBbPDyf9BsPvAGgEfALRKglROgmfuPLy8jneQP9gl45YQk8FaCx9dWQ+6JB57kDRoQeHF7O/iUb1BHA3RtIGgwAdTxAG2tADX0QQ1/0Gw2aAACFDcoOZKstEV6nqZsIIA+ZRty5x8c4sDD10ArOECrQH79eMcAXnUCmtkFncXw/w/DLeD5EKDwBq1YAW1xAcU5aNAK7FegXn3XLobX9/czwNLhs5sbGEBbW8C3W7y9xQAakAHJyQK3mYDSMTjf/PnJANoGAFr2D9oS8x9oD2h1DHiAAbhtBJQ/QAc8gtLJXxCfWxTcgcTd+Scz7EbyIAAjbNCG2LBDlIeg5f6gs0fYOYXA231AA3KggU7Q9Y2gAR7QmR6q5vkMoLwOGly0DFsDXj0COhMCdPgjbFWRdcQGcPrStKkA3zgCOmwSlIdZOfjAK4VAZoHKDti5JaDy8Q90awCobHt4cTF4lYiyaTYDqJwBrdICqQUNOMG2BwHXcJGVOBipOQs+OgjAMArIDwFQzvs/GoCjITAaAqMhMBoCgy0ERjv/VImRQTcAAPIV8iAApMEsruTCICRtDp6lBO2NZ0C7Ix00wwVqgIJmpkEz8KDr7kAzmbB9+LqunQzntmYxgPbjI89SgxqcoMYyA/TQQdCd+eAr8ICDDuDT8YFL2hmh2wr+I9kJ6oiB9r5DrgnkYQDtwwUtfYU1YEGNdZB60OoDSXVfBik1X4Yr+6rB6r5+fAhZzs0AGnRgZgCdsA2a8Qct/QetcrhxuI0B1CEE3dEOmkkDzbTBVi78h61igC+xZWQAddxAWwFAWwa+A2dwwYe8Ia12YIAd8AcWgx7shnLoHwN4qwJ4NQMo+IFyIvK2DKCwAy0rBw0YgGaDQYMpoOvC9N16GR5cWMAA6vT/g64y+P3jI7jzADqXAHTzASSsgHZBw+w/8sFg/4lpVlHW9Pr/f3A03Rgx8hcsbTMxgNKdGDBdg2ZTQekHtA0ANKgC6ryD0g8oHUoAb4F4fGUFA2ipPmi5NygcQbPAoHQC2pLxBbqSBTQIBDqoEjT4BerMgeIBJA+KH1C8glfOAK+shCzlZwYP+MC2ooDCCnRwJiitgg6KBJ8l8B+STiDXRMLCEkJjD1syw/v/CGpik1zWog6Ggpbmg2boQYOOoAEiUDoAzeqDtpHwi+kygOIaFP+iCg7ADn4/+LYH0MAdaOsTKK0Jy1gygFYOwcS4gLeTgMo2LYcGhgvb88GrRUCz/qA0+x244gh0/R/oij9ls2yG4yuDwWkGNOAHvpIUuDoJNKAAsh+ULsGDkeDBK9jSf8gNJAzYDgQkEOf/qX2I4JBNY6Pdz4FsdY6uABjt9YyGwGgIjIYAw2jnf1gmAirPkJA9e4OjkwQeCoCO84D2KL+6t5sBtHcdvYGI3OkGLdEHdaCEgYMFoNn398/PgPffgw4EBM1egxrDKI1SoPmgU/VBe2AhS59/ghvC8sD9saCDtD6/uQnujCM6csBGGbhBychg4jsLvM0A1HECzf6DGuL/gLOqoKuwQIdigWbbQfdyg5bPPwfOpINWJ4A69WA3gBrLDP/AAwEfX19hgLjvPvDu9SNg+zh5JcDLvgUljcEHHYLN+g+zGxQy0AY2cIDiN/TebcjAxR+G/2in+aOmXUSjEjz4wQAhQQMo8MEFoAZQBxI0wAE6eA7UsQDNFoPCB9SRAF21CDpfANRpBd0ocO/sTPAhZKBtA6DDCUHmgPcNg9yLbZyOqHRH2QAfyjL5Acq8jHjSNWyiE7w1Bei+/39/A9MdK3hGFdTRA20ZAc208gBvkQDNyIM75cB4ZQQPVDEzgLac8AJXk3z79IgBlKZgg1T8oqA73d8xQE76/wM5HR7oDtBAFShNg/IE6HYM0AATaBWHoedkBtBqEtDNEaBVBuDBJuigDgM9Ok4jZTUABathkNMRaDXGm0eHwed7gLYCgFZ2gPbef357gwEUh6D9+aDDTkHi4I4/8OpQFWAHHtSRB62IAqUTkDp1q2JwWgOtLALlZ9C2INDgHqgcBK1MAQ0Ogcokef1Yhos7i8BlCmgwCnQGC8gM2LWBoBVV8M4/1nKH9HzMSO298KMrAUbbsGSEwOgAwGiyGQ2B0RAYDYFBFQKjM/9UiQ4aNIpoMQAA8ivIqaDl8/+xnS4N9QfYbmDSAB1M9/XDQwbQUmjI6eY/wMtcQR1Z2Kw8xExEOgJ1ZrkE5BhAe2NB+/NBS1pBqwhAnTNQp9cydBXDk+trGUAzbqCZVFAHG6Qb1KEHnYwPUge++x/Y2AYtwwY1okF7sEGdf5A68BJ/oKXcwP3Z4E4VyM0gDJ/Nh3TKZTQDGUAzuqDZXtB+flDDH7TqAXTiNsht4HhnBM3WM4L3jMMHM+CztX8ZkDttEGuYYNrAWwrgvkbPRmjpAXSoHDuPGNjPoE4CyA+SKp4MoIENJuBSddDsH2h1wLUDDQwatlUM4HMLfn4GD57ourSD+eCl41C3YaQNogcBKM/v9B4MgNmHmU+R/MIIDREgDUozoI437LBF0LJ80Awv6NYL8HYNYMdKViccvHwftEoElCZBK1VA51CADpwEnTsBSpNiCo7w7Skgu0GHQ4Lu9Qd17EHbUEBxBtpiAlkqngvc2nGFQc2yiOHB+XngAQPwlhpYHgMPUGGfgWTEGncUxBPjMC7TYXmd5EIbESYY4Q0dgASVFaCyC7SdAzxwA0wnoEEd0GApqFMOGpD0yr8LXHlUwwBKPx9fXGRQNEoBrwwAbRMCHd4JyregvA278QN0ZgpoFYB54GLgVaurGEBlD2h1D2gVCehGEFDaBN1yAtLPAFtRBEsr0LxOjfppdBAAForgGoRhFNA/BEYHAEZT3WgIjIbAaAgMmhBgHI0LaoTAYOr8w9s5GD1SFJ8y4uy5QpUxQrbMiyrYM7wFHsAH6hSBZqe0gctbQUvjPzw/x4C+dBnesAY2XEGzX6AT1EEz3aDT/kF39oP2t4LEQGzQDCxoqT14nz90+T1ILahDBTqMELSUG3zPOvD8AdBe/r+/vjAwQGds2TiFwXvuYQcCgmjQUl1BKVPwXl5Qpx20356TVxp4Nds78En8IHtBp/WDbxh4fQ3qyf/gpfqg2VxQIxzUoQPRkC0CqDP74HMNgHvFxZVcGZSM0xheAa9SBOn7B14GjggzBuQOyn/EUm/Q4AXIX+CD/xgg2wxAAxOgJeqggRg54AGBoP3koOX+Bh79wKsaDzKwAq8/BG0LAB1OqGpRAD48jI1TgAFyVgOWhEt0OoQ1gqk7GMBIxXxAeJABtfMPCg1QJwe8hBt4kBpoMAWUDkC3LPwHnvXAwSsF3tMPWvECun9dQFyfAdS5Ax3SCLryEXzeAnA1AGjlgKCUEfgWCdCgFWhGH7TnH7QaA2QHKD+AVr6AOoUcPOIMoNle0OqMz+9uM4A6dKCD4EAzwvABJvRZ3P+kDAJQUDiR3VEexFUC2emLEa3sY0TKsAyQgTxg3IMO/wOtUgLla9CSfdAMPWilEDgNAeMNNFj0/NZWBkPPSQxXDzQygPIiaGAUtGIJfE0qcHUTB68kA2jbFCgdgAYMYKt3Hl9dDT7RHzRwBLpSFDQQACojQWkMdNgnqPMPOlzy/bOzULehppP/g3HZ/ZAeaBpt+9A7pzMxjILREBgNgdEQGA2BQRACoxXgSE6G/5E6p5Al/GgdE+gs1H3gbCaoUwSaJQU1Zi/tKWe4d3Y2A2L1AEgfRC/MTND+dtABeKAOPugQrbtnZoBnRHWcWhhA+6rFlJzB++zBM7TQswFAbgCZCTrtX8EwEdwBfnVvL8PTa2sZQIMC/6En+INmZkENdNCsmgLwhgLQ8m672F0M4P28wOsJwfvzgQMKoGX8IDHQcnvQ0noQH7QfG3TXNiP42i9E7IMGI0DXtYFWO4D29YKW5cM7s9BGLmiQAXSPu4isFcPdM9MZQCsKQCsT9N16GEB39oPPPWDAM7v0H7LFALSdATT7B3IPaDsEaAABtHcYdJsAyP+gzgPILaAwBA2YmAUuYgCxn93YALw3/CUD6ERxmMuxzurBOn5kDQYgDwwQYmPPPcgdd2JXCmDTQ27eBHW8QZ0o0GoJ0Mn/oPAFXScJOvvh5Z2dDCC7QOkU1OkHzb6e35bNALraUlojEHwqPCi9gDr8oFl+Od0ohst7K8ErXjSBqzIg2wKYGUAzvVLAcyhA6RJ04j/ojADQAAFogAy0ZcPYZwYDSExI2gxMy+tFg28XIH0Wlgpl9HBYDUDRYAauzj96CvvPABocBA/IgcoaYLkEWpEkpxfDwAO8iu8/+DrO/wyg1UlnNqUwgMor0LYRUPoCrQIA7ePnBh5QKqnqzQA6BBA0+Ag5J8CcQdk0iwE0uAAaLACdLfIUmJdBN1OAzgABb20CDhKBBvieAAcJQANX4HMn8C7bJy9dMNLiWrzRQYDR1iyRITC6AmA0qYyGwGgIjIbAgIfAaOefalFAowYQxY01DHdhj3Pcs7bIM6yw0PoPOe0e+VApRswGNmiGCzQzChoAAHWyQIeygZbCgjrgvCJqDKA9t6DZ+E/AvfrgGTKgGaA9s6B7t0EdfNAeeNCVbuCT+oEz7KDZc1DHHhQmoJl9DesyBsjJ6l8YQJ0u0HYCDm4xBlCHD3R/N/hebaCTQUuzQeaDzhYA3eMO6pCBZmlBh36BbhGA+Qo0Uwea/QedXQC6dgs04wcyC55GGCGdYZD73j45Bg4D0IwfqDMPuqoLdLgfeO8u/M5+WOf5P/z8AJDbQVsAQB1L0L5x8O0JwIEK0KwiKIy+vr/PALr7G9SpBJ27AJpFBrkBtBwZNGsNWyKMnm7xphPkwQBkNlUSP8yPMBq/obgGBshbNYCcNhFsRsj1E2CHgFZagE7eB3XUQJ060Ay/lEYA5AYL0Ew/cF8+eGYfSIMGDUA3SYAGZkCDOaCrBN89O80AmukHbQ0AxRl4RpeDnwG0nQU0cAVaLv739xfwrC6oYwcZbPrNAFreDbo+ELSCBXTjACefLPiKyr/AGwPAA20o2YXYzimFEUZRB5ph4ADF7sYs81DTG1SeEZKLINf5fWKArcoB8UGDRuAtO8BQYGZmBw7GsTGABnt4gFf0ga5z/PX1NQNoABHU8f8IvF4SdC4AaMAHtNcftFIKlG5AK3geX1kOHjgCrRoBmQfaigIus769AQ9eSqv7MYBujzANmA8eXAWZ9f//P6QiiJFh0ILRQQCGUUA4BEYHAEZTyWgIjIbAaAgMaAgwjoY/tUJgsHb+Qf7D6jbscU/cIACWxjT6jBLUzu/Ag9RAM6mQ5eunGMSV3aDXWz1kUDHPZQAdxgY64Z8BOpAAmnX/A+xMgW4d+Pv3B3hG/ff3d/DOMwPSXljQrNnbpycZQDOvoAayunUpA+jed9BsG6hD/vLubgawucDGM/gwQeD93KDZXtCKAWZWDvAhg6BrviBBxAQ/rR+09Be0HPfX9/cMrOCO3kMGRBBC/A7jg2bzQJ1z0DLwD8B9wKBDEkGdd5CfQbPEdtHbGUBL+UEdA2S3gzqSwjLmYPfpODaDDx4DHTYGOl0epA804w+yWxG4suHVgwMMoI7Cj68vwdcIMkBXEGBLuiQPFuEaGEAXx5VPsOkHq6VX2UJ4AACmAhQ2sDMjQINGILa4ohN4Vh901RpoOwBoth60BBumDrzs+/tbBtAKD9BqDFCnDXY+BAsbLzjNiMrbMYAOdQQNaoEGdEADWqAVLk+BZ1uAtm7wCqmA4w90fSZowAk0mPAHuo0FX/GDmRepGKZDZSCAKu4kpqxDqAGHO3RVFDztAM8gAW3vYGZmA0cZaFBO27EJPPjIL64HvtUDtE0JNIgHOsdDz6WTAVQ+gQ6FBJUxoHM/wIUIsCyCpZHPr68zgG6nAJVRoEE92AAoaJsTKA09AV4b+vXDPfCZH0RXUyTUQzRZBYCzvhkqTY3RNhE9Ymp0C8Bo03s0BEZDYDQEBiwERis6qgU94/AJS9z7SxHL+xmw7EFFvz0A1tkFmwee3f4DXip/59RUBlCDGNSRAi3xBzWeGaAH9oE67u+fnwXfsw6aRQVdTwjalAtecvsfdko/ZPk8qLEMOjUbNMsKO2H/GnAvLmgpLmim/DWw0wzp/ENm3iGn+P8FH9IFOtwLfAgh0qwa6FwAIx/I9gTQIYOgTj2IBrkV0hmExTEkHED+Aq1MAHXQQZ08kPmg5b8gtSA3gDqSoFnkn8DOI2i7ACR8oLcLAIczzAIXMogCD5YDrTa4sKOAAbQNAKQPtEUBpA90MCPopHDQ7DJIDUgOdB4B8iACbNCEAS39kdOwB3eOgYM4IHcHVX0Bd2xRzMHS0Qf5FeRWRuhVjqBBFlF5ewbIFghwT4CBgYGWeQPJbKQwwOV/kLtAcaFilgM+6BF0qj9oGwhoph/kD9Dgk5CUCYOEqicDaFUI6DpA0EABaAYf5BvQmRegKy1BA0igsydAaUYIOIgDSiPfPj4CH9IIurYNdCr8zWPd4CX/oJUHoIEo0B5yULp8BJz9BQ3kgM+wQFqlACmLMMOKpoMA4CgapGUX1QYoSPQf0F7kmz7A5RdQTAI4cAnessPCAY5n0Aoi0KAcaBUR6EwUbn55Bth1kKCl/beO94LLucvAbVKg1QGgWwVAB32CtjQxs3IzgLalgLYfwc6QAOUh0CCTXexu8BYp0IoB0JWmBh4TGBgI7vkfhHE4pOvE0bYRrZuloysARrs+oyEwGgKjITA6ADD00wANGztUmaXB6T7cDR38y7Gh+rCYi9FphHYAQeJ/fn0C3wYA6rBDlv1fYwB1lsD9IGAqMPKexgCaMfvz+ysD6FR/0L37kFO3GSD7poEdTdgsGjjRADvwoJl00Gz9D+Dd2qCrDEF7skF7cWF36CMSF6LzDes4gxrd/KJa4BUJoGX8T6+vAx7alcgAWqoLct/PLy8ZQJ1A0AF9wrKWDHqunQyPLy+D99VA8lwC8gygE8BB+3dfPzzIAD7YD9hgB50hALn68BcDaKCDAezWnwwQu/8zgOwCXfcF2qMOOqwOdOo8KFxAAwag2WHQLKKBx0TgKePV4DADXyUI3gKBNBCDJ+fAOvSEMhd8VhzUiWdiAneMQaskQJ0bkF5QTKOnQbjZwPjnAh6uCFIH2uIBGjwAL7f//Q2t3w8xhboZnUDnH542ga4FskEDSsY+0xlAS61BS6pBnXDQfn9Q2gPdYgEKb9Cea9ABfqDtItqOjQyg7SqgMxdA20BAnTPQqe6gFR6gmV5Q/rh1HHjmA/AQSnbgAYCgDiFo+T9IHSj9gWaIQWkItGoAFPcg9vsX5xhAg1qg9MKAc+sMMZ0PKndQqNbZpkIMU7Xjjz+cGJHSCNzljJDUDeYzQtIt+OpTGQsGSFz+B18vCrtaEpRPQKtHQNs6lEzSGEAz+aDtAaDtHqA8q2AQzyCl4c8AGiR4DzwsFTRQeP1QMwNoUAA0YGbsM5Ph4aXF4EFP0DYS0O0q3z49YQCXB8DrKx+ByxvkM1kYoU6jThpgpOUA3eggAMMowB4CowMAoyljNARGQ2A0BAYkBBhHw51aIUDjRs5ADQCAgoec7QCYAwBgk8D9dtAsNiTY/zNADmZ7D5+8BtkFunMddPiWVfg64J39Rxm+vL/HAOoogU5bB82sghrMoGW1oAY3bE8sJCWDGuV/GUCdLFDnCzR4ANrHDYtihJv+I2bTgPGmBjxNHzTDC5phA3W8QZ1E0L5u0OF+ikbJ4MY8aH8uaAAA1Il/eHERA9Q3DAzgWW9GcOcftKIA5BFQR8HUfy7D05sbGUCdSNDgxN8/3xn4JfSBS4XPMzDAVhxA0wxo0IKB4R+kgw9siIOWlIMGPISkTRhA+80fX13BAFoJALqvHuQ2UKf05Z0dDP/h5wsgJWIc6RDWWcdFg9wNMhs0AALaciCq4AC8vq4YfHgZaGACNIgBVsMI7UiDB2EYwAMyoPMKQP4ErYLQc+1mAK3IAM1cgs5dgOxxRy9nqDUQgNn5hw9KQBIuA2QEAtZZYgKtbWAAraAApbG3j46C4wJ0xoK+Wy94KwhIDny1IlCnPPCwN9DhbZq2kEP/pNR8GEAHB4K2e4CuqwStJAANGIAOafz68QGwU+8MHtABD/IABz9Ay/xBA1ugrQKgAQfQSpFnwDQBGiT6+PISAyjO4YNQsA4YSscXNdyw50MalOEwNwxEx41qHX8GBmJWnaCGKTQsof5mRFqZAV79A56B/wee+QeVP6AzJEBxCx4kA+YHeeABkaC0/+H5eXCGFAPmIdDqIdAp/6CzRECHAoLSF+jMk7ePjzPwiqiDV9iAyrHHV1aCV4qABpVAq45ANw6Ayjnwyifg4YOQfAT1ETzKscU9Zp5gGAxgdBCAYRRghsDoAMBoqhgNgdEQGA0BuofAaOefakE+FDr/IM/idSfu9MBIrD4kdbgGAFCcwQhVhdTuBjW0QZ1JHeC+Wl5hdYajK/wYIKdgc4IPwgIdtiUHPEFdWiuY4QXw+i34slhGBgZGaGcc1FgGNcxBs23wRjxQjpWDDxzloAY4qNEOW44Pur5QRM6aAbSUGzRjC5q9BXXYQB3+x8D9t6CT+UGde37gNXEi8rYM74GHwYENAtppFbaG4dX9vQwg+yA3BTAxSKi4M9wD3nIA6jTLaAZBOpbAcwRAgwjg2xOgs74gb4P1AK8SBM2agxr/IP9w8UkzgA5NfHF7O8Pnd7fAHVYm4N5j0MACaLYadKgYaG/5o8vLGVBmkMlN0IyIDjLIH6CVFKCDx24d7WYAHWgIGgyBD1oAO0WgQQlQJxh0bR7orAJQhwW0HB4U3qDDHEHbKkAdH9hp5gw40x44BMhwNZo+JPczwDuvkLMcQJ130GwqZPsGaLyGiQG0NBvkRvABjL+/M4CumgQdGgneWgFMJ4JSxuDVIKCbGECDA6AZW5C5MP+ABjxA2wFAgzSguGBiYQMPJICuiwStHACvEgAeBAc6/R+4lAK8JBw0UAQ6uBFybsA/BuTD3OB9fwbE8AxYDEu+o9sgACxW4OFJw/qC6nYQn64wZv+RyzDQIBckIhgYoW4EdfpBg3mgvA0aDALZJCRrAR4YAqUFYWlz4KGQ9xlEQeXEi/MMD4A3pvCKaDKAZvVBAwAgfaB8AlohA8pDoO09oFVKYsCrVUGDB6B0CkqHoDMGQFcA8gDPjTANXAAsT6ZD3MDACE0ajMDySgy8GoFaMYNSZtOiPULjepK2TShGhlFA/RAYHQAYTVWjITAaAqMhQNcQGK3MqBbcdGjUUK1hRuYAACisiFoFAFEIDlr8AwDQBjojpMMDmf5nZIDZAepsgzpSoGXSoNPXQbOwoM4WqPMkqx0GPon97ulp4APzQHtzQd4C7cEGdepB97iDGtmw/fqwhjuID1LLK6oB3lsL6gTCzycAzrCBOqzfPtxnULcsZgDNDoPu9QfNsINm6v4ADw0ELdkFLccFdeJgnW4N63IG0AFvoGXvoOXhEsqu4FsHQEvJQZ1E8Mnery4zgDqGoFllcOcf6bwB8AQjEwsDaAUCaEYYZCfIHaArv0ArEgSAKwZAnW82dn7wAYeg1Q+gWWPQMuOn19dDDgUDz0qi5WdS0iRcLTQugKsKQAeSgbZRgPwMGoxhYeUEHzooqebNADqoEbS9ArQ9AeRGkFqQ30Fi3788Ax94BrrSETTYAdr+8AV4DzrhvEZshw2LOqj7QfHLCbzXH7SCAXTQJIgvoxUCXj3yA7iFA9TJR6xgYGIA3SIBOtwRtooCdFMEaG83KJ0JSpsy/PzyggE0uAFyu4icLfTayT8MoBsnOID2gDqB4BPdgae8gzpsoEEQ0HkAoO0BoNUroFUfoPMEQAMjf4EH/YHkQYM8oLQCWhb+69trBlA6gucrcAeTAbyiBLSdBHQGAQsLJ2QrCTRHwcKR7oMACIsZGCjtrCPrh7GpVxgzkHLWBMbsPywtgTrZwM4/aJUHJ58UuHPPABUDORV0wB9o2w5o7z4onQkB0wtosBB0U8DXd3cZQIeHgjr7oLQEOuATVG6BBstAaQOUbi7syGdQtyoB3z7xD7gySAB4eCDosE9QGQHSZxECXPEDPAD10aWlDErGqQxHlnmDQwg0sKTn0s4AugoVZDdoBQF4xcC3twyMQ6VKZxzKbY/RdhO1m6mjAwAMo2A0BEZDYDQE6BUCo5UY9dqb9AlL+gwAgEIFt38oHwCAmI0y4wYfAICcBQyRY2QAdTRBHWLQoWq3T0xgAHVEQR0p0CF4glJGDC+Ad7eDrhAELfOHxaWCfhx4BQBkOS4jA+gO9++fn4Bn5kEHr0E66W/A13OBzhSAzMDCzgOAdBtAjXjQsnVQo/rNw8MMoD3woE4g6MA40DJ92IoBkDtBDX/QkneQG8GrCYAde1ADHrRsF7aCAHwwIXC/PqjzBzoc7Ce004c8aw86cA7UqQbtFwadAwDSC1pyD9obDDo0DuRO8Ezzp8fApccs4MEJ0BVioOXo4BPscSVmYhraSJ1/cOwD9/6D7iIHdU5BHRHwnmbgUnZQZ59PTAu8EuHPj4/g2XHQdWigjg5o1QSoww3q3IAGXkCdYVAnGXSII+gqRHAnF3l5O97MB+vg46LRNCN32IADKaBZeT5RbQbQffzgE9e/PAdf3wZyKyhewIcSwg9S+w9OL+Bl1kBzQIeygQZuQLP8oIP8QP4C+Ru04gO8XB/oJFntcHCHHHQbBUgNSBzUcZNS82UADQyB/AtKq6D4kgGuUAGlHVCHD7SVBHTImzxwHzgoLYBWm4BWnYDTE9Bu0OCDiLwNA2jlBSivg8IPNPMLuk0AOFqF1KclVN7QuWyHdeBJoWlSzRE7gIRqOUZZBFtBBD3MEjSoBRrIAZ1FArmm8zN0/IOJQckoFbyfH3zOw+enDCrAe/1Bp/aDIktUwY4BdNAj6DBA0M0k4CsngYeACkoag28JAF1vCrreD5Q2QGUEqHwBrSIC2QUqV4TlrMC3mIBWBDy7uYkB+TaKt09OgMs00MDA64eHGCBlz18GlMEkBqR0QGKHm+arAMAFzeggAMMoAIfA6ADAaEIYDYHREBgNAbqEAONoOFMrBOg4kzEYBgAg7TZc6QezwcmI0elDzPCDezSgzj/0Si3QDBrkRHQG8Awj5Cqsv+C9tqCGLaiRDbojn51bhAHUSQZ1vsCdf1hnDmg9aG8+6GrBL29vMYCuDgTNwoIGEj6/vsYAamiDOmWg+/xBV7wJAZfpgu7ofvP4GAOiM/4fvKceNLMH6tiB7AB1gEGN+B+fn0HVQQ7hAp34DdovD7pqEHTtG2jmGdQQ5wYeBAiagQZ1FEHLgUEdDMitA78ZQMt9QTP4oNUN/5E6oaAtB5DBhX8MoFk90K0IigYJDI+vrmQAdRi+vrvD8B965SHoTARQhwBkF3hZOkpaxhI3yB0zmFoMMdSBGZC5oCXKwsBlzSD3gjrNoI4IaBkzyE+gWXJQfIHCF+Rv0BJm0EqNrx8eMIAGaEADB6BrzSD72xkwJ2SplW+g5iDnDdCyfvC1jcB71EFxDZpZBV/HCLw+kkdYBbyVBBR2oHgBbSsBHdoHjn9g+IL0gjrqoIPYOKEz/KA4Bp3e/+/fLwZBCQMGUIcLtGLg0q4SBjng+QCgAQPQLDFogAF0YCSI5hFSBa/MAK0wYWXnZQCt4ACtZgG5E5SuQHEK6dRB0puKaSb4CjnQ1hZQGlcFXokJOmgSdEsASAySPv8zIKZ40QfS0Au0kVLGM0ITF3n+RZ/9B3W8QXkUNFD368c7BlAeBw0Agc4dAcUh6KpS0HkOoDgBlTOgMgU08AW5eeQveBsQKI5Bg3cgOdBAj0XIcob75+YygFYMgPI9qLMPyjtgfcCD/UDmgwaaQINHoLQGyj+g2ISsMmJgAJWJIN+BBiYlgedPgFbjgNSBbqsApVdWTgFwmgaXT9AyhZFxiMQ/4+ggwGhjjIFhdABgNBWMhsBoCIyGAM1DYLTzT9UgplMDhqozMkS5GXc6IWUVANjdcPsYGRiR9tNClmIzMXACT44H7fMHzYCDGsiQReiM4M4ON78cgwjwXnVIZ/8nA2ifLKjzBppxBS2pRb5uEOxiIAFadg7aaw2Z1WUAL1sH7dkF3wbw5ycDaBZPQsUTvEcX1NGDdf5gM/ugzh1kVcF/yPYC4NYAWOcb0X9mZBAHLvUH7xcHLiQHHc738+sLcIfh79+fDKAZ6PfPzzCAtiT8Bu77By2DZwXeE//s5mbozQfIp/eDXP4ffF0eaLYRNGsImu0DbTuQ0QxmeHBhPgPC/v/AU8KXMID3EcNPjv+PlqQZGXAugYZ1/OE6IGohqxmg+hhhgzSMDKBwh8wqMjGomucxgDqnoMEJ0IAIqEMC7hwDVweoWuQzgPa6gzo84M4QcMUD6PwC0KAB8j53eNyC7Kck76D5A5bOQOlLH3gAIWglAmgLAqjjDxrMeXZjAwMHryQDaBYXFLagThfI7aCtJKCtHeCtJaANAcAOGeiudZBakBOVjFIYQIMaoA4fB48kMNxfgffyg5b1gzqA4JUhwDMqzm/LAh/mBko3oJl70AoC0BYS0AoA0P3toPQICjfQig1OoDue3doC7hCCOoWgUH8P3CcOPtTx7k4G0A0CoFlk0JkTIDNAq1ZAnUZWNh7oOQLwVMgACUZceRVPOhjSNS3MX4wU+QJj6T8o10DTFWgQD1R+gA7CBG3d+fbxMQNIPWhFCyivgywGrQoBrRDiBKYLcLkFLNtANGjLCWhlEmgADVRGgQaMQAMJoC0gKqbZDG8eHwEfAgraMiOm5MTwAXgQJGi1EfgwU2BZAxpIA83wg+IdfCsKMF3CBhtBeQ6UdkErhFjZ+RjkgAcOglaiqJrlMoDKFtghncirixBZnbTwomqdgy+mhvQgAMMooEIIjA4AjCaj0RAYDYHREKBpCDCOhi81Q4CODZehPAAAORSPETwzzCsMmRkF73sHNphBM7Sg5eagjhSocwk6bR/UGYJEEyMDaOYVJAeacRaRtWb48vYmA6ijDjlEDdaJhnSAQZ0tUIcTdGAdqLEOvqebmY3hL/iAN+BKAuBKg39/f4CXsIM67qCZYdBMN/KBfAxIs/IgN8A73kirDEDioFPfQZ1j0D39oGX7oOsBQe4E3WzwBnj9H6gTCDqHAHQGAGiW+SWwY/f0xnoG0F5f9MEEWJIEmSmjHcrw+sFB8BkCoA4ASA9smwID0v3f4MEKtPvAMQdmsHWUEGKgzjKoI4tYKcwIn2EGrZAQBN6BD+pAgzpBoNPLQYf+geIG1MkA3Z0P7ijzSIBXaHx6dZUBdFge6KpC0EAIqAML6kSD4gDUEQL7Ean4YSR6OwBahsUYwGBgQAwyQQYuROXtwZ120CAMSA40g6rr0sEAiidQ5wnUmQOZqufaxQC6yUFON5oBNJsKWsUAGhyAnB3BDB7MAYmzcQkxQFaCfGGAnCHxhwHU+QIt6QYt43/z+ChwwEcLvAwbNPsPOjAQ1CkDnYUAOgwRdnAiaNAEZDZogAk02AURZ2QAHeioDFw6futYL9gdoC0koNPl9d37Gd4BT4kHdQxBndFfPz6AO6GgAQLYDQWw0ME/4zscyn3qdPpxhxck7YPSC2gQB7SVCLSyQ14vFhjX/OCBL9BgDWgQBzQgACo/pDUDgTP++8HpH5Su/vwBXncJzJOsnILgwztBdoFv/wCWP6B0ARoEAl0NCkoDYgqOkFtFgGeDgOwDDRyABs9A7E+vrzKAyiTQViFw3v//H7LwA7i9CJyXgE4FDQaB0iDIPaAVA6C0CEpToNUmoLIRcsMKqFxEi3vG0UEA6jaCRttU1AjP0QEAhlEwGgKjITAaArQKgdGKiqohS+dZC/oPAIBCC3eawd7hwGxsgjpM0hoB4D3YoBlh0NJseeDp/R9eXGQAdd207GrA+6lBnTJQZxN0wv67JycZ4HtZGRnA92yDOvFfgCfho3Z8UWe+QTOmqsCr/ED7aEFXAIIa6MCWNPTwLgYGZeAya1DHFNRZB3XQnlxbC56FxZwtg5iL0fmHJSBg3IOucgMt+wZ11ECzcW+fHAefKwBaPgzaywuaMX50aQnwoML7DC9ub2MAHeqHuK4Q6m60DjyoYwDasw7qIIIa8cj7ejE6/yQnZlgHCqIREn+MDKCbBmCdBSOvyQyg8wZAKmAdf/ABecBZcdAgDvhOc+CBdOAl7cC7yUEdflAHGTTYARq8AJ23APLzS+BtCGoWhUCzdsH3JsOyCyMTE9zlKIMAWDr2DEjhzYBHHjIAADntHzSrD7p+DXRgIajT9fvXZ/BSfNDtCS/v7WYAhSN4FQADZGUIaLXFz2+vwNc0gvbbg86LANkFWSXiwfDi7i6wHKgDbuo3lwE0kAPbDw4aJAF11kDXu4HMBKkBdQRBs7mgmwVAnUTQdgLYjC2oQwfSC1q2DRoMAOUN0BkPoO0hn15fZwBtlwCFKUg/EwsHw/ePjxh4hNXAh1Uys3IxgAZT/kFXVoAGDUADTpDDC/8TkRpQ459hSADqdvoRyQm9XIPyQStfICOT4AM7Qff8g8oQ0Cz764cHGEDp49Ob6wygmXtQmQGa/QfR4O09oDwC1A/KN6BOP2jVCGgAAdSBB83agwbQQFuCQGUbaHsAqNMOWtnDAxwQBZ0PAMpb4IEd4DkCoHQLShugMsPIexpwQPAAZODp3x8G0M0UoI4/aDAIZBfolhHQICoozYDUgwYdQddOgsqnDy/OMwwpMGRXAoy2rShNZ6MDAAyjYDQERkNgNARoFQKjlRTVQnYod/5BgUC0+ykYAIDaAepogk7EBs1wQpa5fmEAnZoO6jiBOlqgpa4cPGIMoKWuoP3kb8H78f9BogrWIGdgQL0uDSyL3EmHKAc1tt8+OgLu1MvqhIM7n2xcIgygzjhofyz4cC5gpxt0ij+okQ6fWceSMP7/x+xU/Udacg/aBw+asQOdRwBabg6agYMdfgdaTg6S03XtZACdPfADeCo+6JR80Aw0SC3E+eB1DKg2g+z8D1vVwMCAa6UAvnRMzN5fWOcf1FkG3TQAvl4ReML/p1dXGEBbJcCdbaA7QCsywFfbQf0NWi4P2tcM238MOvwPdNAeaLAFtBrgxZ0d4NlQI6+pDFf21TCYBS1meHR5Kdi5oAECUKcGtMUBfEAjuKOFZaMCrKOPTOPxMGz2H7REGrR6BNSJAp3/ANq/D+oMQU5h/8oAussfdPc+bBAGvDLg83NQymIAHWgImsmHHN4GWVEgre7PAJqtBXXeQB0yUMf7J/AAN1DYgGZhQeaBZnpBdoHiHrQSBIRBg0ugrRCgZf6glROgmwN+//oEGsVi+AYaNAGeDwFOe6AwBfoR5B7wcm4OAfAs8++fn4FnPhiCt62AVmCAZnhB5oO2MYBWITAysQIHbWQZ3gGvoASt3gAtK4cFDyNR+Zo2nWrKy1Zkd9FmsAIUPthXyUBdDytvgDToDA9QJx0UP6Ar/EADMKBBGlDeRj5bD3aDCChdgNIgKE2YBsxjeHJ1FTSb/wNfKyoKvEECtN0IdAsFbFUTaNsTaFDnG/BgT1BZBCqjQKtmQAMKoNUhIDborBNQHgQNDIHSAQiD7ATlQ5AbQXkQfGUphyD4AErQwCZoVdP7F+cYsG4DALmKxPqLblsByHAbw6ABo+0rSqJidACAYRSMhsBoCIyGAC1CYLRyolqoDsAsBdUbYCT5AXvaIbgCAKkxLargAF7S/gM4uwXqkIEataAGM+hgLdAsJ2hGDLRPHtRBBF2BB1o2D747HdQZBvcFIB0ChLMZoY1rWCcdubP+nwE08wbqyIJWFYCucYPtUwetIgDt7X39YD8DaNYMfkAdRuJgZEAPInjn/z+qXaCD+0BLvkEz9iBX8YlqgTvBoA4jaOYfNosPariDr+oCHiwGasAjn10A9QzUFZgDG8jOw9CHJWFj7+gwMMDE2bnFGRSNkhiEpc2A1wrqMYBWZIA6IaAZTvANBWA//gOHEagTre/WwwA6jwB84BnwYD1+cR3wGQegAQ82YMcD1BEFHVgG2vsMmnW8d3YWuAP7HHhyOSjsQSsM+IFXnIFOx7cIXgY+KA0UPqB0AQoT8IF8DKSXUSgrCBhAW0y4GUCzsqBOGqjTDpohBfkLFN7gvdu/vzKAOvSgwQHI2Q0MkO0kwCsPQbOnIBdAtkRAtquAOuoymkEMIL2gjjeIDxoUAXXWQB1w0In+oJURoEEN0LkTILtAqw+0HeoZxBSdGW6fnMQA6tSBOu6ggQJQeIGvImT4xwBJ1oyQFQk/IasUQFHJLajAAFoVAFo1AFrmD7piEjT7/PX9fQZNuyrwcvTH11YBF7b8Ap8+j54eGEnO25C8Rd96F2YnMk0bF8DSPMHyCmQ9qMwCbksCDdpADsF8C976ATk4VJQBNIsP3mIEHMQBDcjYx+8D3+8PSg8gn4DOMtG0rWC4vLeKQULVg+HHp6fgwUfQYCCsPANdAanr3MoAGiwDLfsHnRECWkECGgAFnQ8BGiyE2PMMfOYG5BBRJgbQ4ZKgQQEW4L5/0CoS0PYg0GDXy3u7GEA3o7x6sA96XslfBtiVlogQxZK3GAdxm2Awuw1vMh3EYcowuMHoAADDKBgNgdEQGA0BaofAaKVEtRAdoIbJYBwAgLSXkdMWWjpDGgAAdZxAnaM/wI4O+OA04In2oGXkXHyyDJLqPgzgpdmgndxMzOCl8iCzQR1pZeN08F3XqHbB7EHrpCN1zGF3roNWFMgDrwUEHQAHGngA7eUGzeqBltCCziIAndDOgD7TD4pjKAaFO6Lj8J+BAWl2HuQm8GF34Pv8/8MHDECzd6CGOfggL+D+bfChXEA1oEY5aDk91rT4/z9Nij3kzg/CH6Dw+8fAxs4PvhUBdFL/D+ASeB5BJfCMt4nfHOCs/XIGUNj//vkBfF7Cy3t7GECz62+A142B9j+D77gHHmwImpkErRoAdaNBKwDePz0Nv24PNJgAil/Q0mZ+MV0GUGcWdIYDaJk8aJYc1NEGrf4A78eHRikp6ZwR7QwBkP9A6Qy8n/r/HwZR4B5r0Cw8aLUHaK8/aAAG1BEHzcpDViDAtmFAVpuAOmagVQqgQRGQPHhFBzDePoBmUoG0IXB7BPiUddC5FVzC4M43KJ6FZa0YQINAP4AHQIJDFrhE/8XdHeAZYFCcgwaH4KsOgHqlNQPAh0CCDrGERPp/8EoPULjABiZAnUFlk3Tw2QZXD9SDB25A/gKtUABtrwAfZgk8aBLbORCY+ZLYpAVyPTqmNFliM5NwfYSebinh4/cBZpkFWnEhoeIO3vYB6riD0jhoqw9o6T9o6wZk2wbkKkzQYA/sukeQPaD4k9ONZHgDXIUESiuQ1SBXwPEHWpIP3lai7A4edHsMXCEAGhgDDYqB4htULoGuHgVtgXr94AADaOvSt48PGLgFFBlAWz1AM/sQvzACB4g0GEC3jjy9uYGBEXrwIGjACHRV5H+cB4NSFpd0XQXAMJTBaHuLnNgbHQBgGAWjITAaAqMhQM0QGK2MqBaaAzgrMbADAKAQxJ6OUGfVkNRAw4oRup8WtpQd1BkGz7QCO/qg2VlQBxw0e8rMys0AO/gMdE6AvH4sA+jwtMdXVoIbwog4hNoBnakDnfIOapTDOvEojV9opxq05xY00waaPQPN+oNMAHUCQZ130MoD0IwuxIfg7j640wVayi2p4gGeWQMt95YFNuo/gs8sQHTUMZfn/wc39EWhNxY8vwU87R94bRx4jvk/0koFvJ19/LP/GGkZniaJzeeMDLDl/T+/vwHP0ssBz2MA7UcHDcKAliaDrh0EmQbZty4MvqEB1JkBzXCDOu2gZek/v7wEzzKCOiE3jrQzqFmVgPcpg04+B62EkFBxg64Y+AY+FwHUAQZ1VED7l0Gz6WKKjgxvHx0FH4KGvkwZEQs40hwDRAU8LFDy5X/IVhGgGGgPNuhQNJC9T6+vB9+wYBuzjeEp8DYA0AFrkOXdX8DqQUaAZl1BK09A+kDLtUE0KH1DDmH7xwC7PhI0oAG60QF0GKIecIsHaMsJ6Gq4J9fWgK9iA61qAB2ICHKfjFYoA6hDCXYH0N2gMwNA2wBAy7Zhqx5AAwjfPtwHe0fBMJFBGHjQJezgwOd3tjOADq0Ed/iBp8ODwv8HdNsCA4FBI0aqlFe4OvDEihNf+mLO1EPtYGSiUZMALX1BwwsUz6B8AIor0OGRIPaf318YQAM0sK0goHMz1K3LGW4d6wGmiy8M8PKDiQU4eLaMAZS+QYOdr4DnBkAOK2VgAA38gDr7oKsF756ZDj7kD7L+5B84DYLOkAAfAAg8TBNyXeAf8KopUJkJuQIUNFD1H3weippVMcP983PB20pA6VjdqhSyqgZ4RgD6ICXewCMxjdB1EGAA61uGUUD3EADlxv+j4T4aAqMhMBoCoyFAjRBgHA1GaoXAcOr8g8KEZP+QPgCAPEML6oSBZlhBe8VBjWhQx+gZdHk4aP85qJMNOnALrA44OABqNIOWhms7NjOc2ZjEAOvYg8yAnagO2l//HXg11+1Tkxngp/gjd4oYoR1FRkhHAtLBYAbPvkGu1oImDuTBCmjYgGbvP7y4wAA6tRt0xReo4wWa0b5/fh4DRocepAdbZww6M/cfbcsA5mAFAwPDf9StDBh6YOkYqg5l2Te6+VjTPOrgDGRghokBNOMtIGHIAFrWDJrJB91NDxocAc2Ug9wACzPQMn4NmwrwSo3vwGXNtjHbwQehgcIe1CEGdVxAs/ygTi1oqTJo5hMUv5DDDP+AOzigDhSoc8srog681nAB+HYH0AF9iNsckMOBhIwLT8uMDIywuAamIdBBjHwimuCrCUGz+QLi+uDl/6AT/y/sLGQAdcJBbofYxMgA2ocPOs8AdJAkSD1oBQrovn4J4EAQaNAANHDy4fk5BlmdCPCMP9hv//9B/cbKoGKWzfDoygrwjROgwROQPGhpN2gwCXRA5D9o5ww0CAU6kwJ86v+JfvDBfpD0yAiOD9D2DND2BJB+0EoV0JkAoPCFbGv4xQAbkMC1JQU95P7/H9zNasyBCkhaBZUFzGzc4CX0/+AdW3BmY6AM4KgXGZEGlhiZ4GnJyHsqOF5BAy+gsgpyRgmk6w7PR8COPwMj5BBK0FkBoDQOSkfgwS1o+IOvnASeSwI6ZBNUtoG2goDkQYNooPiFpRnYqf/g1UWg60f/QZb0w688/Y84IwR0WgXoKlJQWQVa4QQyB3kAADPucaQFEtIIMVuQGKgJ/g/VbuFod5aUZDC6AoBhFIyGwGgIjIYANUJgtPNPtXQ0wDMRNJl1oeUAACOiAc8A7ZCBlsaClvyDluSDTjcH7ZuWUAYts33MADrETN+jn0Fc0Qm43H8PuNPNL6YNnh0GHdoGikdQRxU0qwbqeII6U6DGM2g5OqgDB7qLG3Rl16t7exkQs8kwNzAyMCANAIDYyMu/4Z0PlMY/8O77Dw8YQJ0O0KF9oEPyGJlZGZ7f2go1H7WzjrND//8fWhJEbRBij1ds+Ra1846RrlHiEqQWG4bqQhrsAMUBaFADtLQYtHcZ1IEFrcQAdVxAcQU+7IyBATxzruvSznD39DTgbQ1vwTOQoPvGn9/eygBavs/NLweeqQQtvwff+Q/srIGuagR14Lh4pcEn2FsEL2d4CLwRAeQK0DJ20IoD0JkAoFUfsBlSsvIrht8h0a0CvFIPNFgEMt/AcxLDY2DHHHQuBOjk/DunpoBnTsHXqQE7F5BOHAP44EjwbQbAzhyokw6a/QXf9a/kzAC6xx2kjhO4ZQU0swtKRyDzQeEFutYRdKjlu2dnGEADR6DDLaU0/BhAAyp/Qcv0gecLgFYWgPZtgzr2gpKG4JUlIHnQTO69s7PB6Qo0QAI6T4ERusUAlMZBgw2gzh0oPkB5AGQGysGV/4duJwM2448a79D8CsqPwCs7QWkL7GfgCfuIIyJg6ZucFIOnXkQpAyBmg5IXaFk+aJ8+KN5Bg5eQ6xchs/GQdMDEIKXhD14hABm4+Qe+dQJctvz/Dxm8hG4BAg0ogfIV+JA/hv/g5fugWx5AaQJUNoIGAUD67GJ2AsvC3Qx6bt0Mz4E3iHDyywK34nxkYIBuN0J07P+By0nY8n+SZv+Rg4+E+oAm9RG+qGQcqm2Z0TYYKTmUVut8GEbBaAiMhsBoCIycEBiteEZTO54QIKtBRWRHA9bBBHZiQCdcg2a9QB0a0OwqaKkq6H520L5wUAcQNOsJukseNON87UAjw7VDLQygjjboQDrw/e2gpb9A80AHy3HzyzMwA6+fA3UyQTO7oM4QqDMH2usPahSDTpxHXUqO1tlmxNVpQPMXI6LzDHI3yM2gQ/FAM2uQDgtolo8ZEbh4Z+RxhBlS+DOi7WOHGYxrVhQsD+2ooDTEGRnh9/fjjHks8Q46RRykHtRpvXW8n0HbsZEBtFz/3dNTDLCZedAgAegUdFhnFrSdAnSdImhpMqhDBNrbDOrUgFYSQPbRs4H3LUup+zEoGqcygDq5oE4UaL8z+ET+Pz8YQKs9FA2TwIMsKO4lJW2iqEUt8+4ABytAh6yB0tjFnUUMBsABJlDHGXSWAWTmHjSrihw/EP2gPd1fPzwErxoAHRYIOnn9+qFW8Ky7EnBPPig9gDp74MET4PVtsFUAX97fYwANQoH2jIPORwBdhQgKC9AMPmiLCxunMGS7A7AD9xG4xBuUVlUt8sEDEwzQVQSgZd+gMNawrWKAXVN498wMBtBWGZBbQGcagMwhtWxjHGQdKOwdf5CvGBlgK4VAgyHgQRPgAApouwUDI/JqHnguYWAg+uBIAoMGWMMIcjYDaJDxPnCQBjS4BToYEBLnkLSjCYwrUFpgBZ6nAVohIKnmAx4wY0BkZMge/f+QrSmw9ALyp5CUCQNotQDIXNDBlaC8AYurw0u9GEArUK4eaACvWgFtU2KE5nHE1qP/kJVDMLMZiCmj8Q+AEJu2RgcBiA8phlFAVAiMrgAYTSijITAaAqMhQFEIjHb+qZqABkHjmeqNLbL9hD1tIToYkAY8qPEO7jyz84Jnf8UU7MH3/INnx4Cnn4OWh4MORgN1ggQlDcCnbIM6Q5w8EgygA+lAZwRoOzYxgG4KADWKv7y/wwAaMADNcoEOzgJ16kDmg2e9gI1e0OnqoNP9kZe7QjoZzOB7u0GzbWJKLuAl36A731FWBDAgOs4gM7mBB+HxCqkAZ/DegJMReEktMLxAe8JBS7lBjXVhWUsGyMny/zCT2n/SBkpABmAOAkA6K5D2PiLMGaHLkmHL3MFOZ2CA7oiHqoMNBGCjkVzLCN1XDdlT/owBstz4D8M90N5k4Iw1aFCGEdrpAm0LAF3lB9qrDjo48evHhwyg1RegAQJQXINOwweZp2lTyQA6PwDUaRaQ0AfvhQZ1iF/f3w9cQr0MPKDwF7iX+j90OffTmxvBHRiM5EhM+sTUBPcdIj3+Bw8wgGbSQSsWIFog8Q0OLaCAgIQeA8hf4K0AQD6ow84CvA4RlLZAAz+grRCQmyL+M4A6f8ysHODVDmDLgHENO+QN1IkHrRIAL+UHduhBZ1OAwha01B/U6QOfOwAUBw1cgc6IAG2TeHp9HfAATF8G0I0UsMEr8NJw4B7/T29ugA9oBJkLGhgAHR4H2uYCmokGnaHAwEDazD/uTjd9q1vcgxGQeAFdoycoZQS+RUMAWDa8urebARR+HjnXGe6fmwMuBzD7/JD8AhkMwMXG40+ktIRrQA4U3qDtKiAaknYg5oGuxXwPvI4RdEMDKG5Bh1yCrgoEzcSDBoBAgwMc3GIMkEMbfzGA9INW28jpRQHPyDjKAFrZASqPQGULG/BgSdDAJ/hME6AloHM3IIOnwgyg/Pjn11fw2QJf3t5mgKU/BrCJ/1H4FMUoCXXD6CAAwyigYgiMrgAYTU6jITAaAqMhMBoCgyMEhmPnn9YhC+xYgpZ2g+5UBzVqQQeggTosoLuuQdfJgZbzgmaXlYAzw0+vrwXPioKutQIdKgfqEILuXbcMXc1wdlMqA+jALHBH9f9/8PJs0EFroI6qpl01A6ijBlpVALmL/z0DYln0f0iTGNQRB8YfaKYZNHsKWu4NmqUDNcjBZxHwSjKAlm+D9vQyQvfuMkJXLYBm8TiAgxGgDpyBxwQGkHrQtgMQHzQDDB5EQFreT+xebIzZSkbo4AMj6sAJA0ycATYQAJKHsEFnKICuSQSdbs8IXSHBAE2n4DlSmF9wzIwyohyg958BNPMPihNQJxMyEw2dVQSpA+9rZmQAHdwHOrMB1CkGzV6DOvCgpfCgO8pVLQrBVwWClkefXBcN7uiATkt/dGkpeKvAu6cnGUCH6cGSHXiQBr4sGhJXiCSJNMCEFDYoSRYeNsiiCH3IHUxwvIDiCWXZNKSzZBO9FTxTC+qMgZfYc/AzQAaVPjOAZpwhZxdA916DZ+j/M4AOpuTgkWQArXgAhQnonIAn19YyMMAHfSChC0qLoNUHkPvb2YHbBw5DVlMAzQEPYl1bzQAaOADpB618+Q+bwQUOjIDEQFsJIPvBIecLgM4xAJ2dAMpH4A4jJIWTlZMHajUA/gEIRPyBwh1y2CYDZNWFcRoDaFBg51RtBtBSeZSVAFjTAgnBQqr+/5C8AUlXkHQEOksCtDLJMfEQ+KpI8On9QCeArnHkA25jAm0hUgcekAnKYwxQ/aBBRNA5AKAVMSxsvAygATZQfIPOM1E1zwMPeIBWTrFyCjKABiRBAwiglVMCwGs0QekK2Yc02Y9PQr03OghATHpjZBgFhENgdAXAaCoZDYHREBgNAbJDYLSioVriYRwcYUmTBhZFfsMMF+QVAKAZrl/fXjOA9vkb+8wA3nW9nUFYxhLcOJZU9WIA7bEGNfJBqwFAHVl2HnHw6eqgZeUgMVCHDHS1FWifPmh5LAOsow2kQSejgxrGoJlQUDyLAk+SB3UWILNjn5E6Ygzg5fCgzj6ow8wOXH4NWloN6uiBOnmgLQigK+1ADW7Ifl7I6f2ggQge4JVb756cYAA12EFXf318fRV83RbooC1eUU3ggMVd8JVcID8QOwtLuNPFyAA6IwF0yN7rBwfBHVHQgXrgQ9/AtwiAfMsI7rCCDq4DuQ3UAf394yMD/Co50CACExODkLQpuOMNPlCRAbE6gBHPyfmw5ADupDGzgO0BXZv35d1d8An+74BX+4GuT/wGvIcesuqCgUETeCAgaL/6gwvzwYcBguLJNGABA2hWGzRAAL4XHTgYARpI4RZUBJ/zIA68Wg10NgAD3lUSWPIdrsEABthsLyLXo6ZFcACAfY686gOULq/ur4ee6i/CADmH4A80/TAyQK41RHIHeMDiHwPoAECQlaCBrB+fn4L3doMGst4Cr3oEhTQTMOxAnVTI2QKQzjuoQ8+APAAB7QR+eHGe4T/6dW3QgRHQqgFI2oIMkIDMePv4KHjbBNiu//8oKuboPQiAd9YfNlDFyAiPJ0lVb/CqIEHg4ZRvn5wEp0HQTQigMxxgeQ6lXEROHzjTCjTICMhjXwEAG4CD5EMwCTSHk1+GAXQ+iAjw1o8v726DByVBeRJcvv38xAAq00BnSYCubQRttQFtX4IN9oDOPQGtGADle9ggJGiA5+GlxeBEy8zMxgDaOgIaPIMMSIozgFYNPLiwgIEBeSAClhL+k7IihIi6jXEQtyUYh2I7Z7RtRqjQGh0AGO36jIbAaAiMhgBZITBawVAt4QyiBsaQGwAAhR2wMQqaJQXNVoE6L6Dr40Bx8/PLCwbQFVigPc2gmXQOXgmG0+vjwEuwQUut//7+Cu7Qgg+fA5qjZJTCAJpxBi1/Bs30g+6fBzWYQUthQVeugewAdepFgPewg7YBwG8KAHUqGBnAHWlT/3nglQTfPz1mAHXEZHUiGUBqQYdq3T09leHn15cMoJlskPtAHdpfoKvx/nxnALFBd+CDrgCTAu7rBW1LuLSrhEFSxZMB7E5g55uBhGXYqB1TWMeVkQG2rB80ow4KA9CJ4OzcouBVB6DwAXVOwV0jcMeFiQFyAB0DAyhMQYfUgeRAgxygZeqgzoUacEb+w8uLwDv7Uxhgp5Vj5At4+oaUGYxQs0Fm8YlogGcdwdssgBpBAwmgzjxoKT+krwbZy/zy3i4G0Ew1OK7+QwZQQLP9AsAD7kCDN5AzE4C3DACXzIPOFNAB3uYAWrEB2uIBW0qNO78iwgdzjzeyHMIE1BlmaFkI9Sdypw4U3i+AV+uBVoWAwhmUlkCrKUADFaDwA3U0GdDCBzHj+x8c/qAl2qBtBSB/wcKYEZreQGkMdC4FeGAG1lGHysnpRgHT4nVwRxG0ZQUW92D7QCe9M8BWXyA6c4j93sR2+omrB+gxCIB71h9t4AbW+QdFJ3DQCHTnPSjdcwnIg1cIgQZEvAsfMtw82gWJcFj0MjBiQtg2GbBZDAzw1TSQCMJbRWAMKjDADAEZAwtXuOXgszJAs/igjjxokAsUn6AtSzZRmxlAt4WAbo8AlRGgdA/eMgMfzPwPnuXXBx7wBzqQErS1BDToBB40A1opC7w6EnRtJHgQlIWdQUrNm+HDy0sMoAE40NYa0IAcA4lbQBjIAYxEpiUGRga6A8YBsJNiTw5FN9MvZkcHABhGwWgIjIbAaAiQGgKjFQvV0swga1hQfQCAYv9hpjVss66gWeAfwOviQB2dv8AOtZJRKgNo6T87pxADqEMP6kSDOrOg2TNQRx7Uqfr79wd41gx00BnoDm5Q5xN0CjiowwiaPQPNSoOW4b8FztCDZshBjWZQxxTUOUeZVWaEdBtBHbfntzaBT+SGdfZAHVtJVU8G8CncwAY56O532HV34KvsgMtsQft5QR1h0D5/UIf66Y31DKAZOTm9GPDef9CSXNAsPKgDiHs2G3s4wTpFYBp4VR2sg/Ln50cG0IF6oNP2uYEdH9D1Z6Alv6AD5cCdb2AjG3K2AiN4fzQofEBmgMIDtBcfFIagTidophjUuYXcWMAA7QAxoHaEwJkF4T6IW4Az/8AZbFAYgPY1gwYYQIM0tlFbGe5fmAdZUQHqboGvaIRc6weZ2WYEy4FWa4C2S9w7Nxt+gB1oJhR8hgJQH2iGFLIy4C8DaG8zJNwQHV38HVJIhxHWYYbQkE4ZZicTKdzRBgCYgJ0pHuAZD6CZZdDMPWiFAw/wIL9vwBsfQOlBWiMQOLBykQE5jkSB51eA5GEDLIgZaGiJwwgdxAGGC2jACpSOhWUsGEADCiDzIeqBaoDbKUAdW9AqE0lVD3CaBA2egLYUgLZXoO/rx3oNJEmzvIRLRNwddMpKU+zmwjr9aPkC1vmHbmdhhPJBqyx0nVoYnt3YyOCccpxh+yRl8GF4ioaJ4HM9wGctgI1kAg5YKYBXc4DSPWj7Biivg5bZQ1MNUZ7B1/lnYIANAKCmLUia/Q++zvLnt7cM3EJKDKCzHR6cmwvesvT7xzsG0OGQ3z8+gp7n8B++6gOUZ0HXZILyEGgQAZ6ugP4HrXQADWqCr+IEbgt5cXcXeDDv7aOjDJDO/z8qVHdEthmIGDgBh8/oIADDKKAsBEYHAEZT0GgIjIbAaAiQFAKjnX+qJZjh3vmHtGQpDC58AwCQpiCIBHXuQR3/f6Al7MCOy4cX5xjAy/eB91qDTjgHzZiBVgeATrf+8u4WA+hQQFCHGjTjDr5qCzgzD9pbC+rsg5f+Ag+me3VvD8ObR0cYQPe5g2abQfuoQecEYHTC4Z0KRvByeNB1fqDtBZCOCTPD1/d3GUB2g7YIgJb5g2bwYNsKfnx5Bl4pAJ6NZ+EAz7SD/fH3FwPIHaDOOKhzDFrC7Zx6kuHhxUVkhCeo08wEvtWAgwsy2w/qAIAa/aAzEEBhAeqQgjqUd8/OBM8WggYKQIfHgTr5oCvu3gOvnOMRUgWfEM/OJcIA2uIAOuMAZA5o0EBGMwi4lP0qdHwBfQkzIg4hnRhIJ5YVuB9ZSNqM4eaxbgbQsmNQPNw63gfeEiAsYw4OM9CZDpDBk7/gjj9o/zJoOTNodQboej924EFmoI4+aIAH1MkBdcZAe7hBAxWgDh1oxhx8s8LXVwzo+5exdRyRO+MMDJCONOj8B8jAAnrQo3bQYLLgzh00b4PcARkM+gLedgEyB3TwGuhEdtDya1CakAXe1Q5aFQKKb/AgD9Ag8B5u6Kwr2E3ADj2owwkyD3RPPGhPN2hlC3j2GniIH2jpNmSWH9Z5hAx2gGaDvwK3VoC2yEAOCPzPAMob4BUTYAejL+XGPOCN2vu+qTUQgNsctHiBdSqROv8KBgkMsOvxQGkQVH6AOsig8zdAg1mg8AHNqINukwCln89vrkMGaoADLyA50AoaXlEN8Ooe0MAL8lWJhAZRiev8I8o2Bpi7gUKgPAkakAJd//jo8jJwfgTlBVB5Ayor/kFvvGBgQHT+kQe/4Cs8/iPiGeQfULoDDSrwiaiD8x9owA+yvQDR+cftL2LbBCS0HYioGxlHBwGIqAtG22u4Aml0AIBhFIyGwGgIjIYAsSEwWplQLa0wDr6wpEmDimJ/Yg8nRri5MPn/DNCV+GAadKWVqkUB8EyAnQyy2qEMoMOyQPvZuQTkgCf/X2PgF9cBdzBBnfpPr6+AD/6CzID9BnfIQQ16UCeXATgQ8A18R/9vBsjMP6RBDJnFR6QGyGF/TODl1qBZNtC+f9ChhNLA+7pB+iAH/qmBOxGgawVB5xaAr72Ddk5As9cgNWqWheBT2kGd2t/f3zOA9nf//fMNbO4DcOcf395bUFighxd0xhg446lgEM+gYJAInnWGdGj/M4DuAgcNOIBOg38CPCwOdPsBZHbwP/gmBdCeY1BHAHTlHuiQMSbgXek6zq0MLMArEkHbGUBXJoJOkAettgCFBqhTD1qWD+mUf4MPCIDkkOMM5ErQ7KmonA2DnG40g4SyK8MT4CGNoG4LqJMLGpgBrUAAhTOkIwJZrg5yL+gAQT4xHQZQJ/rzm5vgMxJgHVrw4YLAhMAtqMDwEniiO2grBuhcBdQzFFDDCdKRZGKADU5A1nNAwo0X2CECDYyAlu2DzGFA6kyisJEKBuQBgP///zAom2QwgAag+EW1GUDnSoAP3gOuKgFpAZ1RAeq4gf3y9hYDaIBIQskVuAT7AgNsiTYoLYMGW/TdexlAgwmgNAUamPoMHMgCXwf35TkDqPOvalnAANqzD5/NB3rTxG82+JwEUF4Ab58Adgz13XoYnt3cAD6UEjToQvnybvLKMtTBFuJKVvx6IPGK2OqAaiYsXkDpCzSYArpuErStBXxgJ4cAeIAGcrsH5DBG0PWMoHz6CXiNIihdgswFreYA5WvL0FUMoIGwj68uMUDu4v+DYhkj0mYBmARMDK6QEZYOIeGHGNAA8rEcuAlKb6D0DBqUg9yEwcwA2uYB6ryDyhTIQARwoAy+tQPV/8irPOCDOuD9/f8YYGcJfAeuovr14z0DaFABshIIR7wwEiqXccUnCWlldBCASs2NwdfWYBgEYHQAgGEUjIbAaAiMhgAxITBaiVAtnTAOzrAc2gMADJBl5wyQ7hvoSjVQp/LlnZ3gAwJBS3RBB8u9Ax7yBbpaDTSzJ60RwPDuyXHw8nzQvnZQhxvUSAZ1sEAdWGWTTIZXDw6ABwRgs2j/0ZZFwzqNAuK6YHtAKxBAHTYROVtwRxu0lQB00CBoFhnU8QMtv2Xl4GMAuQe0EsAscCHDq3t7wcvYQZ1XkPtAhwyClq1zAw8IFAMePAg+wA1sL1rnH2c6QupYANUYek5mAJ3+DZotBi3ZB3X6QAd+gc4mMPaZCd5nDurAgxr9oH3AoAEMDdtKBtA94+DZReBABOzQRNB2CdCsPGjwAiT3DHi1Hui0elDaAblZEHjXOC9wpQCo8wo5kA7iZvQBG0bgAYKgARdQJwsU3qCZalBcyQO3PYBWG4AOMwNtMwDNaIL2ZoOWNYM6qqAwAi1j//X1NXgVx0fg4A1kqf9/BtBS+F8/PjCABjqe39wEvj5PxSyH4eWdHQzwwx1RwgwRTqDOHegMBNBgCMgvoI42yC7QwAHoRoYPLy6Csz9ssAC0RQPsJ9B5BAyMKJCBEdahA1409R9088E1BlCnCjQABTqpH7T9QkYrGLxiArRaBHRgG+gWC9Dqk5/fXoHPOgDPKP+HDGqBBkJAp7w/urwcvCT7ydVVDKCwAHVgQekIFBecwPMtQHEIOSPhL3QwjJEBdB0gyJ0ge8FhB7wiDnS4ICicQLPIoA4l5BBABgb4QAC+pf80KruQO/b42NjLYGg8gtwGxJzAmxNAh33CVuGAZrOhkQctHRjAg1ugff+m/vMZ3gMPnYRcS/kXPDAIWn0BGiQAX6EIzH8gvRLAAyVB2wBAeQe0rQJ0mwVonz1ogAxUNoBWC4C3CWDZK4+14w/t/IO2/oDcCfEXUCVwgA1kF2hFB3Q4gwFeLiOFPUiMjVMAvPUDdBAn6DpMUBoGDypiDSRGBtSoQ5z/8B+5bPkPOS8A1PlHKetgaRrnrDuN6rTBOgjAMAqGegiMDgCMpuHREBgNgdEQICoERgcAqJJQRjv/JAYj9nTHiBKOSGrgDVUG8AwwyDLQLDVoZhTUkQR1zkEzfqBl4m8eH2EAXQcI6nCD1LFzi4A7jZB91ZYMoJn3jy8hHT/Mvff/4Z0JkFtAnQZQZx1kHmhJPWjJsJS6H/BALV9gp+0Eg7ZDI3j2V1zJGXziOGgrAqgDDTq4EDRAAOnI/QFvWwCdNwDqnINmGS/vrWSAzdaTnP6gYQG6ZQA0QAFaMg9aDQHq0IKWEoM6gqBD8j4AZzFBWwPA1w0CLQF1xkF7i/8Bz1L4++cnA2jmHzQzDV5+//sbeJsDqIPw6dVlsNtAHU/Q9gDQlXGg1Q6gjj0Ig84+AK+aADucER5eoJ4I6ECybx8fM4A6vKABEJDbQJ0p0NJ20CnloC0AoDvOn9/eygCbgWWAnkYOujf/26dHDLCly7BT70EHN4JmZUEzpKC7y0EdZFC8gE/Zh3bUIU5hZECevQd1nAQkjYBxVA9eTQBaFQIyC3ReA2jgBmQOqOMH6ijL68eB74YHqQHZAZlJRRqYgadLRgbQ0nHz4KUMXHwyDKA4AB2sBur8g1aLgO5gB60u+PruDtgfX4C0DPBMAPAybFEtBtCyfdhKDNDydBAftJVF26EBPLAESseg9AzaQgJaiQHaww66DhO2Vx2UJkH2KxgmgFdKfAduNQGd8cDFLw+8EtAKvCLm3bNT4JUD1KkAB6p+QM37oLgEHbgJ2pYiquDAAJqtB6/mAR74CQoT0GAL6GYJ0OAHSC3odoUfwEEX0BYUUeCg3bdPT8CH7YFWfIA65jyCyuBbG0ADQKDVHAbufQygWXLQYaCgdAZKG6A0Dhr8+vP7CwMDdNAGnr5ggcuIlOag+QE0sKMHXI0Byo/ggSfgrD/I7aABuxd3toG32YDTAEwvAyM8+YLMB836g7YngW7CAB0ECUonoIE6bFuUQOoZoasKwLeUALcKwNIXPP7/Q7cN/P+PsAc5cSANAjDCl1thph5GgnUciWkF7n/cKRVjkIWBxoBxqLWHRttv6ClidACAYRSMhsBoCIyGAKEQGK08qJJGBnGjYXDO/oNCndwBAEb4igDQ/n2QSaBZ8PdPT4EPRAMteQXN8oGWSN8/Pxe81B7U+ZLXi2YALWkHNehBs2mgWXBt4Inyr+/vY8BoMCMlCtDsKmibAejAwZ/f3wLv2jYEX+/GBL3bHtTIB826gzq2L+/uBC/vBi23B11BdvNoB3g5MfgQO2DDHHSAHahTCzrZG9TJhc/EwRrmDJgDHhjpEymtgcwAdT5B7lcySgYf6vfw4mJw+IDCQEBMlwHUCYIsEWcAd0hBnUdQZxG0BBq8CgB4zRjosELQlgjQSgmQPHj2GHhWAchfoA485EyFL+CVEKDOEWgQBKUDA23Ig9LaS+CqB9Dhg6CDD0Ez+KAtEyDzQGzQAAqoQwRyo5pVEQPIbOR9zOAzARggh6Ehn5gP2ksPWmIPGsgAhSXo5PyPwEEK8Gw6NMjQ0zmkI8MIvgINtKz+O7gD+IUBNCgEOj/APGgJ+DBJ0Ow96NrE2ycmguVAYQWLL7AbQOajDUqB5EF3sl89UA++LhHkFtBWANDgCOgsCdDAhKp5PgNo5h90+CQXcNsCaOUC+JwJBtC1foiOGGjQADQg8frhAQbQPnVB4IDFj68vGECDEKCwBq22gIQ3ZAUMKN1p2dcBz4xYyACyF5Q+Hl1eyqBhWwUciDoKXrYOGvQADTSRXLYNmnIMNR9A4pKJATRQAxqg4QEekgdaUQObYYfNmoO7ucCzQUBbUEADKaAtPqDzQkAdedDZHKDzGEDnK4AGCkCDWqABFsfEgwx3z8wEpsW94IM5QfkTlFYtgpcx3D4xAXJbBvy6RLT8iRFejJDtJkDxV8BtKmzAMzVAA3KgMyBAg36ggy1BB0iC0jHGyhmYWUAa5C5Q3IMGh0DljgJwcAp0rScsPhmR1qWABjz5xbTBBxuC0g+IDS7jgG6GGEloaxHUVFhnnBGak1DSPcLfxA0CkDEQQCCx0qQew2Xn6CAAw1AGowMADKNgNARGQ2A0BPCFwGjnn+L0QcQMxkCnQZo0nKjSQCJmAAAUelg6A0Bh8N58YCccNAMOmgUFdUhBs4CgDhOoAwo69fsXcIm7EPAkdVBjGjQzr2yayQBain4feOc8aFk4aJ+5mJITA2wZOOYMGwN45g80Sw7q/INcA5oxBnUeQMv4QbPjoA4uqGMHWvIN6uiCBgFAHQ3QTCXIPaDBB8QAA/JM3H/CSQM9faGFOyM0eEA06IAz8BVgwA4m+KwCflnwfl/QrCZo6TxogAS81B44EAFyGyj8QLOSEspuDKDbCEAz1aDZUtD+etDBe9zAU+5BAyygTgVoUEBC2Z0BNNgBm5VHjz14OgNKgA9GBM5Kgs4fAM1gmgHv9Qd12kGHNP4AHdoHPJEcvfMPX66MNlsJcjN4kAPUCQNiyMAA6LwGzNl55I4RZF00IwNk9cN/BtAZDKDl16BVGTrAU+E/Aq9DA215AK0EUTHPBR/C+PvnZwZprSBgZ3A/A+JsAXBPiAFxfgDE5w+ANxqABps+AQ+RA3UYwWkDuKoCPHgA9B/opHUQGzTgAbILtCcdxEdZlg1aVg6MU9A2AVCnDTQQAFoxAgpnUHiBOquglQ7weIbO9ILSrZ5LBwNoFQVoqwto9QJoiweoQwxa5QJaAfKfAS2MiC2IsOZtRjoVY7CwRrIO1CEFX8nHxABawQJaaQMaCIBdAQnOY8A0BVveD0oD3z4/YQANagkCr5IEzY6D9IEOwQOFMWj7CWh1hYi8LQNoth+0xB50PgAonXEDV1GABl9A20RAcuCBA/DSf+S8ii0sIO4Gd46BbgXdMgJaaQMyR1YrBGwPaEDi2c3N4MFDsF3A/AUqk8Az+AxIaQzaAQddAwgKBVD+BQ1AoowNwjjQuAIddgiKdw4eMeC5KOHggSHQqhLQAB6obAKlI/QIhG3HgIjD3M/EANqSAtruAzrgFD7IxwAtaKCGMBJV/pOYZogwc3QQgGEUEBECowMAo8lkNARGQ2A0BHCGAONo2FAaAoxDIwyp3miimr+xhx9m4xJJHdRukJ/4gXvzYTN/oE4maIksqHMH6siCZtBAe7NBDVhQA5oRetI6qAMA6rS/f3YafFCgLrAT9fTaGgZQo58B1/5oqPUgu0Cdh//AmXHQAW2gjgVo2b0Q8FT7X8Cru0BLwTl4pcCdbtAMI0gMfNjWf8jd9prgGdrDDMgz3kQnQRwDTchxi+hYQjoroA4EG/AANFBDHrTUH3TeAMg+0B5nNcti4MGHtxlAy9ZB4pCO5nfwMnnQnmdQZwI0mw3q+IM6sKBZZ/A99SB3gPwDDE/YQXawTjfYL7D4AdLMzOwMoOXYoNnYz+9ug88qAB8oCO/E/8dTOjFC+tugE8/B8QJR+x/rneWwCGKEL/8HDW6ADoMTkjJmAHW8ufikwdefcQEHRUCHvf0CXqsG6kQqAQ/xA511cO/sLAbQzDJIPWiWFjzIAY43VCdim7UFdUC1HeoZQJ1u2BkK4JsLgIdMglaagNIAaF8+eC/6f2inHCWt/QefOA9a5g0ayAINKIG3IAD1I+/hB830gjp6oDMwQINQoAEfi5AV4Bl/UFr7D7wlAzTY9ObhQQYeYTXw4ZKgAQoGqt3zTuvyDov5jJDUBbrpALTVBrQSgltIGTwrD4ovUFiAtkaIgA+cjGIADYKAZthBA0+gtAuiQXLCshYMoLMnQHkBtDKCE5geQANQbByCkFs8gPa4ZlxgAMW9NnB1xaMrKxhAgyzIZQJqsQdyKwKD0gXoXAFQmgelGNCAD8itcjqRDKBtOKABItCKANBqANCgggxwkAm0pQVUXoBvJoElM6TyDbGx/z+CieQIcN5nhLgBtFIAtKUF1OF/dGkp+OwT0AAlKHzgRoMYjMg8RvC2JFA5BsovYGkmVgbQGScg94IHAGDba8DWoMYP6gACrqwMCyMiS7rRQQAKWiW0zp8MQwaMDgAwjILREBgNgdEQwBYCoxUFxemCcWiE4eCd/UdpjaJEB/bZJWh4wzuYTOCl/aA95fzi+gygGVQuXmkGVYt8hkeXlsD32IJ0ge5RBzVyXVJPgWcFz25JYwAdJAZqoL+4vR28D5gBNuuMljAYkWbaQIfb/f7+DtxRBJ098P75OeCBf8/BV/qBOragGUnYfn/wDB/woD9QJxxkBqhxDj4B//d3Bm3HJsjhdQyQgQEG3EFBMJkyok4LQoxCSpvgpcAMoOvhzoPlQIemyWiHAWfF7zNAbgUAbQv4zQBaIQHrrIIP6gNewQc6SE1SzZsBxAfJiwNP8wftqwYNsoBOvQftpQdtcwCdWI++Lxoch8AwFZQ2YQCF/UNgnIBWR4AOSUQcjIajbIJFNfK+aGgnFiyFdaAGlh8Zgdsg2BlAZwyYAlcdgGwAdcak1P0Zvn58wAAemAFu4wB1mEFxc2pdDAPIP8a+MxnunJrMALuuD2waI+SgP1BwYs6WMjDA9l6D1H4HXtcHuiUBtPJBwTAJfMUk7PA5BuiKjP9YO/+glAIc3ECSAw28MKBtE4CMhvxnAJ0tIKXmC55FBm1lAHViQVsbQDcNvAUeggkKY9hgDmhLAmjwC98AAM7yAWf5RotyD08nEToAAMrXoNUooFl+UP65fXIiOF2CBl++A8+bAJ39Yewzg+E2MA5BcQXu/LNyM4C2U4AGS0Az2qBtILDDFUHbU0ArW0Cz5LBOPmhbDiiNg8IftLUCkaJAqeg/Rt6CpV5GaCcctIpG2TQLfM4A6NpR0MAX6DBS0AGdoHQHsk9MwZ4BtPoAfMYA8AwCkD2gswxgAzWYg2mMSPailYHgvfqQsAO5AeTPP7++MoBo0GCHlLovA+icA9A2H1AaAa3oAZVfkMUGjOB8CTpfAjRIAFqdANrmY+g5kQG0JQZUhoKuUwQNtoAGWMCDBDjKKVjewL8qABbHRKQfIgcBaFK3YS2SaJHmGUYBDUNgdABgNHmNhsBoCIyGAEYIjFZmFCcKxqEThsNnAAAUa4gGMGhGGtTABnWCQLNVoP3Arx8dBl8DCJq5QpyYDdpP/gW8d/gxcFYP1Ejll9AHN9JFgUuAQasFGGAz0jgSBmSmjQE8owpqHIOWlINOCQd1oEGH6YFmt3mF1RlA+/tf3d/LALoqD7TiANQQB3VYQG4B7xm3LmW4ur8OvEcY1HkGWwft4ECs/k9y0kQdAEB0pBghvVYGmNthfJAFILdATkJnA3cQQJ0hUAcTpEbPtZMBtIUBvFwduIz9w3PQwME/8NkCoE4MSB+PoCKDHPA8BdDs9AvgmQeQDhRynmCE74MGdYpAhxFqAWfIQZ0tUDyBl9Zj6cQjdyRAHQ7QSg272J0MkBl55OX+iGBC7XRA7AX5GbQ6BLT0+dmtzeCDDcFLuf/9ZRCUMmIADYqAZzyBM+ygsxBAe6ZBbgPdovAHeBAi6Po+0CGPrGw8DKBl+KBOEOTaNET4wuIONKAC2kahCryRALStAjS7DEobED9CZvsRJ67/Z0CeUUa5rg3uJdBJ7TC/IvwMik5Qp5aZhQ3sftBqAFCnDjRIA7pqEbSKBeRG0MoD8NkSf38zgOQpmv3HOwhAjTIQLTzRUz9ssA+YikGDG6B8Bwpj0E0JoBs32Dj4wX4E7e0H5bEHwG09Wva1wIMUL4P7uKAOL2gFAGiQCrQV6P3zMwygQRrI4ZWMDKAOMmhbDOwAPVB+Bs3KgwYKQFsCQNsBQOlCCnijCPjsBrB7IIN2mJ1eRgZQXgdtJwEt6welHdCAIXhFAjMbA2jVEGg1zjPgDRagjjZoRQjowEtQPIJW5IAHiZD9Dw97aF5igJZ/SHECdjcohzMxgw+lBIUm6PwKTuAqJFC6BMmDVhz8gg54gc5DAKUH6JABMMszAbdDxTIws3GDO/2ggzvfPj0JHkwFHc7JK6oJHqgEDXaCDv2EmQ0pu7DHP2oeRnY7iucYGBiIiHsiBwIY6AGGTJ0/2r4DJYfRAQCGUTAaAqMhMBoCyCEwWjlQnB4Yh1YYUn0AgKr+x92IxB5PUPUgN/yHXGn1AXiSP2i5Ovgqvq8vGUAdetjVceDGLlgLrCPFyAC68x7UCAcdRgc6+A3UkQB3CLDNKiP5FbyXGNTYBs4Kg2b5QY14CVUv8LJy0GnwN450MIBmeEEDBKDtB4ZekxlAHRXQsm6QX0AdTtAMpjTwijhQAxrUKAc1gkFnFViGrmQALdvF2VlDdhuW8GdE2w/MAHUnbG8x6MR0UOcdFC7gmULgPnXQ1YigGXDQPun/0APO5HQjwXv8IR0FBgbQOQYWIcsZQAfMgTqxoJsT+ID33YP8D+pMgfbTQw4X/AeNLmjXghERTz+Ad49/B95l//z2FgZFw2QG0BJ80IoC1PhlhHcIQDP1oI4xKBxBHVjQ7KOycRr4OkWQ20HnNwgCl/WD9mfDzEDtjDGC+xbC0mbAGw60GEBXCoKubwR35IAz56Bl+iA+6NBIkNvBB619eAA+DBBkHmjmFrRfXBQ4UwsaDAF1ziDu/c/AgBz2jIwMsHAHdfg+vrzMAAo3kNtBg0Ggpd+gLRMonX+ChQ/yABDmYBAorYCuuATfcf/lBfi6O1DHF3LKPORmAsi99f9wbzPBl36wuQ9vfofFG6mlKpH6oHbDBrHAtgDFQJ1qSH5/xQA7sBF0ngdoOf2r+5CzG0BhBNp7DxqcA3XoQR3sL29uMnx5f4cBFF6gQRJYOgQNJoLSOujUfdCAFshMTbsaBtChjKDONGgwAJTGQKsIQJ1kxIAXIt1C8hoD+NwI0HWa3MBDH0GrEiAz/YoMksC09wS41Qh2Kwno9ghQmpFQ9QBfDQnP+2AjEeYyIg0EwPwPLk9AeR5YFikCV5uABvBA12eCBx2BByCCBjFUzHLB16CCVjOA8j542wj0fApwBgGlX6B+0CAJKJweAg+RBK1eAN1cIabgCB7AA92MAFq1ANpK9QJ4Y8ffvz8ZIAMh8JzHwMBAuD7EPyiAFIYkpz+IBkhOZGSgOWCkgx1U8cRQcSftYmx0AIBhFIyGwGgIjIYAcmU9GhoUhQDj0KpYqd75BwUeVcMAe3gyEux0MIDbnX9+fGQAL6AGzuyCTskGLfUGzUpjvc8faCaokQxq1INnDIFLrMGn9B/vYcC59x+edRjB2wRAjXnQTCJo0AAUtqAGPGiJ8fXDbQygswFAjWdQ5wLUgQStBAA1vkGHBZr6zwPOqu9iAOkDdTy+frgHXn4rqeLJANqL/OT6Ovg2BEh7GqnzR2BgAhwlaAMAoJk/JuD+e9B+cdCSdNASd9DMPWgGGdQZAOkBdcTBh+MBZ8EhYfiHAdSxBt0tDzptHzRAAOqM3zjSyQBaIQGaOQd1cEEzqKDBC9BVd6BVAiA/gO77B52/AGvoI+cx0Ew4KJZBgwygaxFBAweoeRApDQDjCDSAA+r867l1M7x/fhZ8oBnoAEDwLCmwwwJaAv/k6mqwmyDLkmH6YR0JBnDYguLhxd1d4FPdQWyQnaABENByaJD7Qf4TkbVkAB3gB+o4qZrnMYCukwR1ekBqv7y/Cx74AM3ogw/4A6YxBlj6R+mYMkKvUuRkAA2IgDr/oA4Y6GA5mFnEzcJDzzj4jz3uQQf6gQ+Fgw7WgAa9YFsKQJ1+duCWDdCqhTePjzIwIB1a95+I9MNACID8SzBPIsIf0zjkTh6RZSiSfZABAIg+ECmvHw88VO8cON+CZtlBaRkUBqC8Bh68kbdjAM1ag/IlaE88aLAAFC6gwy5BbgOFI6hTDzoUElRmgA5+BGZOhg/ga0GB2yyA5yeA0gWoXACpEZW3ZwDt7X9xexsDqOzA1ueF7aNnZuUC37QBOpMEtCID1IEGDdqAts6ADhtlBq4GAHf+X10BDl58YYAPLjEgxpcg+ZeNAbJK5T94ph6ySgESsojwYGQADTaCDrQUBx7kCTpw8BNwIAq0igV0DSpkFdIv8OoADesy8PYW0FYV0GAIpIxlZAAdygk69BPkVxAbNMihZlEIHHDbw6BlVwu+GQG0kknNooDh8ZXliLISJT3gi3twpmGAzfiDwgOycgFp+xM8weAYDCCyzqFJfYeemIdYG4BhhAJQSvrPMApGQ2A0BEZDYDQEGIgZqR8NJjwhMAQr/sE9+8+AM00SNwAA6xBAOxSg/drg6MNW7UPVkhyHSJ0VtE4fJKUwghvp4orO4FO+QVd+gfZgg/bYg2b0IcvYVcAzjqA9tqCOMqizAho4AM0YgjoroNlH0F7bqwcaGEDLgRUMExluHuuBGP8fTxMGvYMEDk6YP5kYQKsTQHujv358yABqdIM6R6BbCiD7/pE6FeCVFIil6qCwBw0WgK5HvHdmBgMjMyv4hgBQZxN0pz8LOx940AI06/3l/T0G0L3joBl+xCDKf9R4ZUTMlENm0LHFBSwOIWpBB76BBh3ElJwZ7p6eBh5cgdzv7soA6uSAzl4Arz4A7ncGnQEBWiWAfDggI3R2FDwgATysEDQY4pR8lOHgIhdwGMNWPIDOhgDN0oIOCwTNEisapTKAlu+D3AkZLPkKngkFbUUArd5AbCtBKidA/gOnPUbwwANoQAd068T7Z2cZwFcfwq+PY8CIU8wtAGjL/6Hxj2urAMwVoP3eoOsTQYMPoAMdIe7EMqCAfhggWvr6T8xhgf/p0KzGk7YZwKtbIB1FUP4SlrNmAO2fB8UjOAsA0yvoxg5QGgbNboNm80EDQJC79D+BB+FAaQh0NoIwcAAIdOsCaIsJaJAHlD/Ahz+CbxxgBudtQ89JDKBBMJAZ4Js+gAeA/kePUwbIoJOQlCkD6P7+l/f2gAeoQHkFNBgE2qYB2Qb0jwF28wBIHHLzyH8GmHmgfAoqD0DxADqoEnQ+wF/grD1ocPMRsPMNGjxErqE0basZnt5YzwA6NBI0ww9KA6AVC6AzBV4DD4IEHX4IOtAPtPUJZBZoYACyOgqyYgdkHygsQG4BrbYBDRSCtjGADrIErZQCDTKBZv9BB1KCbkCB3ZQA9z+RaQE8OAKMF9CWCtAZC0+urQUfvIg8MPYfp1kEBkNxVNn/GWicTv8Phe7lyO0Cj64AYBgFoyEwGgKjIcDAMNr5pzAVDNFR/8E9AMCIM1IYCYY3osMIMwQigtTgwWrGfzLsxDYIwACfroOFMWhm+tuH++B9wJDT9v8zgGYDQSdxgxrM4BO6xfXAs4OgDidothbUieUHioEOIwR1FkFsUGMd7EhiGpiM6IMgsI4RI3g2GtTpAR0OBzrpH9TYBnUOQKsgQI16sE5GyAAGeGkz8I58BvC94cwMoI73k+trGTh5JMGH6YFmTEErGsBX2AHPBQAdMscC3h//nAGyogA5XLGFF3J8Qd2MEj+oAwCQ6/cYGcD2AAccQIMLoFPtQdcQgjo04FUCwOvaQGEO6rCAtlSAO/vgko4RETfAjhyoQwVaUSCtEcgAXjkA7BjAlmeDtnGABmZAnSJZ4MGIoNPzQR090L5p8EoO4A0KoO0OoJlccOcLPckid1ShcqDwAHUUQWZj6ygiJ0BGBizpGC3d4h8kgJgGOvgNtAIDtNoDv51oHmBkRNnWABl+YcRfWKLpYaA2QPM/ZhgxMsBmr0HBB4pbUNyA4hSUDnSd24C3W9xgAMUh5ApLRvBhl+pWJQyQrQAMkG0hwOXsoDM7QAM1iI4ocmfzLwNoBQxoZQFowA6Uj0ADBqBVPaBzFhihaQ0WZqCbB0BL5ME3TgBvmgDdpAE67wK0Fx+UvvhENMFnN4A61aBBCfA1mdCwY4RecQiiQStUVEyzGUADge+enQHO3nOBzxYB5QFQHEO0QGx/++QYA2gg7tX9PeDtOqBBBtB2H9AWp//gGyR+MoDSL2gVC6gsAJVBv3+8B6c6kF0gPqgcAq+I+PMdPFAJvloVGAcgf4JWPOm5dDI8v7MdfGaKMvDGDHCYwgtd4tIKKA9KArdLgQYTQfaCt++glW/YVg8h/AoPKKJTG1FpmZK0y8jIMAoGbwiMDgCMps7REBgNgdEQYBitqBhGYEXPSIt4p2qjB3e6JHoAABSvuDoM6HGO4Xbs9mO3G0ktvNPNAO48gRq3oI41aCky/AYA6AwhaEYR0iGQA99OALoXHLQcGDRQAFpmD9rCAOpogjoZoIPpQKeFo86kwzyBI6yQO6DwWW8m8Iw/6AR40HYIUIcC1CkEzQaCDkcEzYqCZvtADX0+EQ0GUAcA1JkHHV4GUgfqOIDOBQDpBe2VB7n/7ZMT4JlT8FYBYMcCdJI46NpESEcdOryI7kT0wQl4XCEUIsIa0RFmRJq9B13VB+nQgjpx38Gn9b8AdkYUDBLBs7OgqxxBgwCge+FBbgPNtCKiHTS4wcTAL6bLICxjCTnHAHgwnrx+LMPHFxfB16SBln2D/Ae6vk0QOHsLihOQfaCtDlwC8uBZ3B/A0/1B1+vBzWWEdprhYQ9xO0a6QR/AYUT4kQHJDEjnjxF8yCI47oFyoPv9wbPIsFlMuFnoA1hQPvJKAXJmJmHugXpyQAYC0NzAgOQWBpR8jhgAAIXdN+DAFTunEAMob4HS8v3zc8EHfoIG1UBxD1reL63hzwCaQQfNdoM6zKCtGWZBixlAg1yg+AatvAEd0Ac6XwI0eAe6IhO0EgS07QQ0c65mWcQAunXgA3BLyl/gqhNwmmRELRNAYqCl8qCBB9DZDyBzQO7hFVZlAA1MCEmbM4AOHQUdZoi8RQM0QGDgMYEBdDsGaNsJaDYeNKABOisAtIIH1AmX1gxkAOv7/x+adGBhAMx7TEzga/tAg2WgPAkarAAPVgHLIFP/+Qy3T0wEb1sArar5/f09A2QVAWS1CihYQWehgPI56OwLkPtBK4RA+QF0dgloFQLoVgXQgAUbOz+DZdgahgfn5jLAthHB44URS/mElP8ZweemPGMArSwArcYBbYcAbYcChwNGPmJigAwGMDBglA8o6YCBKEDTgQDGwd62Grltv9EBAIZRMBoCoyEwskNgtPNPdvzjaJAOlfRE9QEAqjd2aDMAAIsfnP5H8Qd2N+AdBEDSD9INmqH9+e0VuLMIuUrvDwOigf8fPAwjKGkMvEGAH7zfHLTkGHRLAGgZ+z/ggV2gpbug2TEQH9L5x7VKAUd4ITW0+cV1GEAz2qCZSFAHFrT6ADQzqaAXywA6DR90sB2oEQ663xw0aKFgEM9wH3j/PWgJPeS++X8M/8FbAv4yqACvMwMNVoAOTgMNFoBnH0FyoE4puJOJ6k5Ix52BgQEp36DEAUZDH9k/kE41rPMPHrQArjQALVEGmSevG8UAWtb9/sV5cNj++v6GAXa4GWgPN2hGEXSfO7iT8+MDOAlAOhFM4BlUkLmguLGN3s5w/9xsBtiVZ6DzHECrHkBLm98+Oc4AWzoP6syBBmRAs7So+R1bHKAPADBizKrDzcDIQ8CD+4B7xkGDNaDrFkGnsYPsBfkNNPiB3FHELHewdP6xFE6MWOzEuSIMFnfInTcGRga8nSg0PSSXj4yo4YWunxFllQQsrJnA2y1AaQPUuQSvaAFu9eDkkQDPiIPCDTT4BhrYAnU0QZ1x0CAbeNXK52cMsAM5wQcIAtMZKL5BeiFL8hkYQIddggfjgGmdR1AJfK0eOI8A1TIgL/9HcTsklECHDIKXszOCDmXkZgDfzPDnB8PvX58YXj84wABbxg/yCWjQ0DRgPsPVA/UM4NsCgHfwg9wGGpAADa6BZuth54mAtvCIKUG2sIA67eA4ZIR05EFmgM60AG3R+Q91I6hcAu3Zhy35B69IgfqVEWI5A2ilARPwVgnQqgRufjkG0LYIJZM0BtAAn5xOBAPo6k6QPtCKB9BNGKAVFKAVAKA4AhuBPMiMnA4YkdIMkA0qS0ADKSC3MDGzgA8CBV23CTaHEbTShxMYZX/hZQconkDbbsBXqIL9iJYqCKQZbGmQZgMBjIwMo2DwhcDoAMBoqhwNgdEQGMEhMFoxkR35w6BSH9wDAPjTJiNR4Y9kBg715A4CEL8KAOQGSEcMfJAYA+ZSeND+bGZWDgZ14CFc1w82gU+KB+8lBi65hV0VB9syQDi9Ygk3qN9BfgUfEgc0BDSLB57hF9NmAM2OH1zkDJ59BHWWQZgBqgZ0yB5oHzwzCzsDaLAANJvKAO3gvwPO+oM6VqAOD2RvNJ79pEhugDf9QfviYQ11ePzAOnDo/oB0ZEAdc1BHHdTpAQ2GCMuYgw9H5AHOogoAt0q8f3qagUdImQE0gAHq+IE67qAOFWjvM6jzArlZAdb/ZmTQtK1kAN2TDxr0AK16uHd2BgP4SjTgtWig7Rf/oXfvgztJBPbHo85GQro/sI40anohdgAAEgagw/1AHR7QHnaQm8B71wUUwGcVgM43+Ak87Z+8xTyMBJITsh+wsMFxh2oEIwMmRFGBHN+48jAxapAMRR8AAMU7aAsNaL86aE+7Q+JByA0aQHNBq1vEgZ1k0AF+oAEtUPoFXb8HMw50YB7otH+QGdoODQxf390Fb9MBH2rJKcwAmvkWlbcBpxnwwZHA9AG6PQJ0OCDiWkeYabDwhYQdJA1A0zcDA3iQAXQTAahjDprJB60kAQ3MwVf4MEL0gQYFQP4A5TvwVgHg1XugfAwaOACfbfD9HThBSwFXMYBm6UHXW4LyJnihDGQxPwPowEnQAAXmdhxQnv3PADt/gAF04CfYWkg8gtx359QU8OAa5ByPfwwaNuUMF3cWgc8VAK2EAYU1aDUAKP98fH0Ffl4BA7Y8zwDJx6CtBZADMCF80DYLUF5TtypieH5rC4OScSr4fAyQe0VkrRhA1zmCtvKAViCA8jloSxLIraC8DVqZAxoUY8By7gIDIyPJVTwsBVO1YUiGOxjoBhgZRiIYHQBgGAWjITAaAiMzBBhHI57cEGAc+mHHyEBlP1A9TPC7j+QBAFBcY3Ej3nBAUY/pHuwzp9BEhaQXbAc2u6FGgvZng67pugtsaIM6FfzAa/RA98yD79nH1qiFW4EtjLCIITXEQdEOWuIMajiD9hyD9vCDGs+gjjV4HztwBhB0lRyoswFqfIMO8AMNUMjrRjOAlk6DG9mwWX6QO1BmOzEzFCyMYHuYYbOSgtImDKDODOSKQHCPgwF7Z5mBAXkmE3TwGPgkd+Dee9A1faCOBKjTBpqhfPfsNHjWF3QGAEgNqFP2DziIApqhBC3lZ4B25uGuBIbL20egE/H/gTtjMsBl1KDbBEBugg1sQNTiGNhgxNzaAPIvNowIGWj8oKcPBsx0wwDuLEGW/oM6WaBl3qAT3EH31oNWiYBuKAB1ur5/eQbJzXiyDKEDzwjlJ7CfgHfJg7azgAaOQB000D3w4BUR0A4jrs4WI74VAqBwQMcMxAPkzj9oYAS2XQIUdqDOOqhD/BR4gwbM/xzcYgwvbm9nAKULUEcbdK4D+NrKj48YQEv8QYNLoFl1AQl9cJp4BZyRB23HAfkZtFwfNFAEGkAA5VdQmgOZAeqUQjr//xmQFyOgpwNkSZi7QQNZMprB4NP3OfmkGEDL30H2Q0IAEqGg7SUg9SA7QHvkQVtUQFsIQGxQeQHKo6DBDtAKF1AeBh0uCho0YoSFKwPENlB+ZkRKZ6CtBYrAjjaPoCL0pgtmcOcdkhsZwYMKoEEDVk5BaDaADBaAtkqAbvoAXZ8IOtASdB4I6OpMeBggD5Shl3vQswxA8QA6iwFk/u9fnxlY2HmBAwrSDC/v7WUArQAArXYCDayAbmp4C7y1ArQ9CeQL0CoIUPkFGgwAXdEqAjzg8eHFxQyg1Uew7UYYqYeRkYEcQPWBAHh8MIyCQRACowMAo8lwNARGQ2AEhgDjaKyTGwKMwyPsRgcAEAkAZ1hgxDVq3JM0AACyDm4ewhwUMxghXQTQPl1QQ/c/lmX0EFfj0A/3EloaRRkAQMiBOv6g7QWgU8RBnUpQIxs04w9aXs8K3M8LOjwN1PEBHRAGXtoLnPEH7T9GPXQO2S5GaF8d0nSGzwAC9yCDZiVBgxqgDhYzcEkxaGk9qPP+5/cXyBwlsGMAEofMfkK6IAwMMJqBAbKUmxE8Ewk61Rx0ABpoxhS0IgG54Q/eNwycxQR1/vmAM6VCwBUCn9/eZFA2zWQAsUGHuoE6+PDGPSNoeTE7gxxwCwFoTz1opQBksACt08/ICHUn5C598P3n0PAGxSFoSTZKBxjoH9DKCdDgDsIfSGGFHCfIZRFaGgGZDQpv0BJr0HVwIHtAe8ZBnSDQFY06zq3gswsgyYuRAXQiPaiDy8BAeDUGIi1B3IVr8AKSRoH+By6hB50eD5qBBd1iAepYg66LY0B3P6yjg7LCAxqHDAwM1Cp7UMwBxQ/QPm3HRgbQthnQfnfQ1Xegff4CkkYMoFlk0BJz0GARbNsEaLAANJP+7+8PBtAKFlB8gfaeg8+4AB7WCUrzoPQKHAlgAA3KgVZfgELq0ZUVDLxCqgzgmzoYkG9lgCcIBgakeOTkk2WA3awBO0APIg+5ou/F3R3g9AdaiQLKc98+PmZAxB8jAyPUb6DZeNDAFugcCtCVoqC0DFIPulUAdHUpyD2ga/pQD3lkROyTRysHQOaCzjD48fUVeDBOSMoYvAcfNKgDWXGAphfup/+QWX7ggBpo2wRoKwTyygJGtOKHASk9CMtYgMNaTNGJARS2oEEb0AAdaBAFNFgD8hPozA5QOoesjHjEALqqFLT6BbTdCDSIBzqsEESD8sDT6+vB1xxCzguAJUR0BzAw4BqcYiACMOIbwGIgAzAyMgw+MBjdRNtQGh0AYBgFoyEwGgIjLwQYRyN92FTcpHuEcYjP/oN8zEhUI4r4hiDOMEGxB9U88gcAwD6ARxysgwURAHX3gJ035M4/Vr8youlHTgdo/kbvbDIyQvsfTAygQ8s4eSUZQB1pUCcTNIMIYn8HzoiCZjhBnRFQAxy09xl0hSEDjgPkEJ1HJgZQ4x7UsQJfVwbsjIM6WoqGSQy8ohoMoEMGQQ14kJ2gRj9o5QHoYD6npKMMoM4l6NRylBQN7TyAG+HADiioswA66R/UWQN1PEB3rsvpxTCAOvmgPfKgThBoebCghAED6AwD0D3/oE49qEMIWq4M6jSDOwvgsQXoAAPQT6COFKgTAxqkAM/+Y2zVYATPCEuqejKAzk6Q0QoG79UGDUKAt0cAZ1HBnUUGUF+DiUFQ0hB8NSH4rniUqGFE6Yygd2IhShEdcphWkDpQxx8URqBBG5CdoNPcQcvDQXaA5EF2gsISdAgdeNUDkh8I53loWGCUDVBxRkbw8ndQ3IHCHhTOoJsjQDOxyJ1V5MEO0KoFPddOYGdZBdzZAy8V//WFAaQe1qlioAAwIk+3Q9lvHkHSEWi7iqSaD/B0/LsMoBshkK8BBLkRcpjlP/ChkaBzJECz7qArOBGDSdB8yABZHg8Kc9BBfaAtJ6Awh2yTQdvOw8gAH8zyLngAHJhZwiCjGQROmxYhKxieAq+203KoZ/gEvN8ftP0APrAC1AVasg8SA1/JCY90RDoA3VAgquAIvrlD1TwXOGN/gwF0IOFT4E0coO1CiCX8kFUI4PAF33DBzABPU4yMiMEXRtgZCUxgN4NWIvACbyG4f24OgzBwyT1oEBKphIEMwAFVcvCIMYBWCMFukwANnPyFxinyoBOibESkK5AYeBvBv7/g9PDr22vgtiN7BtDZGqLy9gygW0RUzPPANw2AzvMArWgA2QXSAxpAAR1ECN6KA1ylBBrEM/DoZ1Axy2G4BzyjBP36Q6zJigodb2qkW7DbGEfbYAwDDEYHABhGwWgIjIbAyAqB0YqH5PiGzWAMk4QyOgCAGZHEDQCA9CE1izGnuhAGMyI3n6FsFPXYzEHKm4xoM6VYG4y43IKWxzEGABjAnVnQ8mfQTCJoGe67pycYQEuL2biEGb69vw/urINmS8GzocB90P/Rl8+DgwJmD8ixTAygpdGgWwO+fnwAZjMCO+yggQDQjN4b4DLer+/uMICuGAQdLAjSrmSSDrx2bxUDaFDh5b1d4E4BaLAA1pFGnrUDiYNWJshohTKAbiMA30kOvEoN5F7Q/njQYMPrBwfBh7GBZgp1XdqBM/5mDKC9yaCbACAzsAwMoFPOUa9KYwDPkIJmikH2Qs5IQHTskAc2QEvKQZ0j0OnvoPQCGoAAdURULQoZQEuyQe4AXwv38wMDaBABfJUZw3/I/CG4DEFKHgxInTGYMCMiPFE6UNCOG8gPEsABCNDqCVCnFnTeASjuQMuwNazLGUBuB51ODzpA8tnNjfhLK1xlGlQcFHcMsDiG2q8MjC/QjC1ollbfvQ/ckQUNqkCUMYKXbkP0Af0MXPUBmu0GHVYoruTKADoY7jv4GknEMnmwPmzhwEDA6eh6wOHGCE4uoNl+0MASj7AKw+kN8eDBGmZmdvAggKx2OMMX4GoQ0J34oIEuUJoGzSyDVtuA0pRT8lEGyBWbjAzmwUsZQOdHgFa/gDq2oFUFIBoUp/BBAni2ZoROcoNoSMcadHCmNLDzDzp3gk9MhwEcH8CBpjcPDzNABmcYGGAz4xhlDyzvw/ItkH739BQDKO5BeejpjQ1gf4nK2QDv+EfEMwsLJ4O4shsDaOAOlE5B6RXkVlCnWQo0GPL2NgMsTkEDYi7p58D77WV1I8HlAWjwCNShfv3wIHAQz5EBtMQfph68tQK4BQQ0CMgGvvryGXwVAMTQ/9DBD0YG0O0E4DNGGJHDhRFqFPBGAuAZCqB0Azp89M3jYwygNCMkYwa+OQAUFyC7QAMnoFVJXMCrPEGDbaBwBw1QgvwDWgkBWo3x4MIChjsnJzPAbjRATTU42jmM1Gn/UGUggEpuYaAaYGQYSWB0AIBhFIyGwGgIjJwQYByNbFJDgHH4hRnOzi45qYPq4UM4vBmJtpP4RiDlAwBIdqG5jxFlphIWyAj1qLNlUHlY458Bt7kMDATMABmF5BZkd4APSmNmYwCdSA6aHQXNLDMDT5sHLXsGNchBh8vxAzsu4GW3aMvJGdHdBLQD1FECdXhAh6aBOlfiyq4MoCXrIBeCOjwgM0ErA0BuBl25BppxB3W2ILN6vxlgM8mghj1khpiBgREJgjpLoI4daOYZpBZy0N8N8EFhoAP/QJ0d0BWLoKXBoP3PILMfXFzI8O7xcfAAg3XEeoabR7ugJ6yjX5XGCA5KSCcPFGioAwCQGGEEd9hAHW7QzCToFHjQSeigQYyHFxcxgK6Z4xFWY+AFYpCfQbPKoP3LoMEHkL9BKylAs5qgzhjWVAmPJ0YG+IoQ0AwuMyvY/SD/gzqsoNl90Ew6qOPKzMrNwCOgyABif3pzjQE0IAE65R3kHnDUoyU1rGmcEeIvSAcPcr0aKxsPeLYf5lawPqC6D8/PM4C2bSgAV3Oc25YN3rdu7DOD4cPLCwygrQ6gQ/NAakBxCjIPtE8cNGgDWokBWmoOutLyP44zLYjtUGH4AS3cfn55Ce5QmgcvYwCfKg9apv7zIwPourtbx3sZWMGd16eIJfmMED+zAwe+Hl9eDgl7oNjzW5sZQHvrQXv9Iede/GNgwLHcH+RX0CoZUKcbdE4AqLMO2vICGqQB0WIKDuBOOWhPO2iwBjTgpePYzPDqwX6wmdDlOEjxDgkNZHHQIAZo5QFokAfkVpDfnt3YCNEPzCegFTagwwtBS/J/fnvLAFohArqaEDToIgs8rR+0sgVykCgofTGBDzYEiX1+e4MB1LkG5x2gOaA8CxrU+vT6OgMkDYHUMzOAbikBnZUAGkABDYzou/UAb8uYxQC6lQKcX4FhBjoXAnSGBijeQfkdlM8/Q82Bro0A+xE0KAJascAvrs8A2oYEyq+gsALdpgAKa9CgJCivgwabLu4sZACt8AGtuADlJ9D1o6AVLyD3gMsK4AojyJYkPFteGNAAFessigcCGEfbZAwDBEYHABhGwWgIjIbAyAiB0YqG5Hge7fwTDjKqhhFxaZQWAwCwxi4DwcYimZ1usAXI/iNgDraOO6lmIKnH6LQDZyNBJ5uD9tGCOzhA54Bm30D3oIMGAkAny396c4MBvB8eHCb/sKYFWAMYdDgaaOYRNJgAmpEDDQj8+/2dATRjJyJvC742DNxpBc5SgjolkCXVz8EzrqBtAKDGPegAMAbYFYKw4IF2UMHDAVA2aPsAaOk/yK0gc0CnuEPOTPjHANuiAFqaDD4YDGoeaLYQvOwb6954SCcYkgYYGGAdL0jwwR0C9T9oe8Y/BpDdoK0FoNPJQcvHQXyQu0DLskEdcdAS6TunJjOw84iDh0uUTTIZQDOrkOvfGOCzvwyMCLshfmRiAN35DjqPAHRIG+hsAsgSf5AeJvAKBpCfQeEOmkEFhTXoBgTQSgdQJ/QHsAPMBVwZAepMgbZySABn3yHX1UGcz8iABQI7b/zAQ++YgQNCYorO4GsRIWHwnwG03Pwt8OwHWCf34+urDKCDE0EDLhy8UgzPgLPRoPgDzSiD9rCD/A+6Wx+0ogIUJqDOImh2HZTOLEJWMoCunQPHMY5yA6v7kAeCkFMhI2p+ArlRSt0HPNv/5NpqBquw1eArHUEDUqDr6gSBZwGABrbAVzhCb04AbWcALX8HDSqB4grkXtBKFtAAFcivonK2oIBnAIU5A5rdjAzQQSrgSheQHaDVKKCOLMivoNUgoHMiQDPhv39Crp0ErT4Bxx1wJh00kAVKt4iD8xjggw+QdMfMAE/zDAwMkC0LfxlAh96B8hgovMGH+jEygvWBOsiga/NgKzBAg3fgrRqvLjOArusDXSMIMgMSZCCX/2cAdfpB/lYwSAAvwwfpEQfGP4h+dHkpA2igAeQGkJ0gN4EO5wPbDbyxBHSIH2grDexWESl1X/CAn7JJBjiUQDQov4MGKhhg8cQIHdiAeJABvCIE6BTQuSKi8nYMoMES0HYGISlTBtBAAkiZmlUxeJUCaOAJdPYHyL2gOAKt8AANToIGD3BtS2JgwFOfoOQ7BooBRQMBjIOpbTaY3MJAUzA6AMAwCkZDYDQEhn8IMI5GMqkhwDg8w4yRgYr+onoYEec2igcAQGkBi9uxhg2GOogbsc7ao5mLYR4jemcS2uiHp00k/yPZi9F5x6Iewz1IDVzs7gDaBZuNhVoL6riBTpoHzcqBOhegmVvQLDDodHJQBwc5C2Fr8ML254I6uXLAWwNAS+pBgwzg2UVgJxO8zx44GwsyG3TgF2iGD7TyANSoB53gD2qwg0+ZBx0eh+JHRJiDlpWDri0EzXaCOj2QO8z/MqB2Av6jhRDioDawSSACOS6gbHg4gfmY8cwIPtSOCTyo8evHB3DHC3RQGWg2EuRHUAcadBo7KNxAs62g5dSgk/I1basZQIMBIsBODmjFBWaHBewgeAcQdv85qJP1GbRsG7hnWtEwGexH0IFtoHCEdBz/MYA6qKBOJxuXEANo5h8UNqAwAZ9QDwwFISkT8D53kBoGFH9DgwjqVxZWTuBha+bgGVmb6G0ML+/uZgBds/by3m6wQtBgA+RQw88MFqErGUADPKC75kF72l/e3ckAWo5u4N7PcPt4P3jmXVY7lAF0MjzolHrQIXUg+x9dWcbAgDwAQ0n5gSVfgma9hWUswcvZQdsUngBP/welW1CaAqUX0Ow2+NC7L8/BfgLFN6+wOnhwCnzTBfAsCdAhmKCVIKDOK6jTqePSBo478DWXcLdDMwzQDaD0KAQ82A40IAKakQbZD9ka8hW8EgEUT6AT7iF37P8F7lnPZQDN0oPSPidwoAa0RQKcl0BmMTKDt86Azt/QtK0Crqr4BL77H9yRZYSkTtBKEti9+/+h53EgVowwgu0EqQStdAANwoC2izwDXqsH8idoYAh0jgGoQw5arQAa+AC5FXT+AMidoHQHWrEiJG0OPAfAkgF07gfIbCFpU/AKBlCHHzQYAIp7UEcddAYFaBUMaFAAlN7A1yICwwiU50HbCUCDUrC8DpJjhJaPoAFG0OoDXhE18JYd0EoBkDrYio3752aBtziAOvqg6xFBg3ug/AVaFQCKF5D/QWd+oN7qwchAFqAkDWKxkOyBACq7g2EUEAyB0QGA0UQyGgKjITDMQ4BxNIZJCQGkjtNwCziqdv6hjTnqhRHx6XTwDACgddgZGVGXrSMHDsHOPzhAETqQGoTYBwAQdqN0/tHSL0acI7kDORxBS4zFlV0Yvry5yaABvBsf1GEDHcAFWuILWgYNuTbtH+7ohpsL6XyDloLD7twHdSBAB/e9f36GAXR1H6ghD5qdBh04xgM8TR3UoBeWtQTPcoI6z6CO5Ivb28AnkzPC+1oI/4I6o6DOJejWAlCnFHSwH/o1d4zgDhXQ99BOO6jzCzIBtEQf1CkC94WZIPu1wWwGRKcO4kkIH9a5AnX+QfaCZnZBGNQ5Bu03B82SgjpQoCsVQZ060HLq1w8PAc8z+MwAGqBgYuEAz5JLAPdmg2bLGeCHO0Jshc1SwuwB2QGaOQcttwbtWQd1nEDnCXx+fY0BcjAbI4NpwHxwBxzUwWKA+oGFnQ98kjxothd8XRxwlhl0OBtoBvXGkQ4GyL51JD8ipRPwuQvAq9hAWxtktUIYbh3rYQB17kFLwdWBZwu8Ae4JB3UaQfEI6oiBZm5B8Qfaow3qQIK2OIA6b6BbFkD7s0GDH6Cl36Dl7qCVHU+urWFALKOHJSH08CahJMHaWWIE2wEKO9BBkqDOKihdwbYggE/WB11f+fc3PHrVLAsZXtzZCd43/w14bgWoEwtaUQGeZf7zg+HVvT3grSmgvAAJP7RD/xgg6Qu06gK07B002ACaPQeFAWhbigrwsD7QwMgz4HYC0F72758eM4Bmu0FX3IHMhHT+IYOAoIEEPjFtBlDaBO2xB6UpWGcdtBIE7GikPAZK7/COP1CSEZgOQNtQQHvpQYNEoDgFxRMXvwx4EEFQygh4TsVxaJ5iZADddgAahAOtXgEPJIDS5X/I6f7vnpxkAN2iARuY+PL+HvyWAlC8ggY0bIGDRHdOTgIfcAhym7ZjEwOko/4EfEggSI9N1GaGm8e6GRDXD0LCC3QTAOjqQFB4gwaoXtzZAVwN8IgBtKKGi0+GATTwBToDAHRYIjivAldYgLa6gMwHxQ3oTBHQNgLw1gNwwOBb/s9IOGExMjJQG5A1EEADdzCMApwhMDoAMJo4RkNgNASGcQgwjsYuKSEwzCtgxkE7+09aOqXbAACOjgbYfugp2sgdTdAMMHhJKnqaQ+v8w/SgKkMKAzR7iRsAYATPfMI6s1gboFjcAXEDI7iDCFqqDeqUgA4qA59UDuwsgTosoCXNkJPxwbug4c7GdBcjdBYbQjNCO0igZdCgjiJoTzWoUyOh4s4AmsUGmQbq8IM6TqAGPWjvOKgTDVoqD+oMgGayIfuLYWHDCOotgTunoOX9oNl30Ezzc+BgAcJREDWgGVDbqK0MoGvCpDX8wHv/QTOvZgELgWJrwDcVgDoa8OsWwQEHCT3kpcOQuGIGzkgqMID2LcNm30EdQtA1g6DOEqgjDOoYg1c8fHsDnOXNZgDNNIPsA81ygvz+EXjyOyxtMDKirvyApSdQZxU0U80GvIJRFXgaOjMbFwPorAOQWaC95aDBBUHgVW2PLi0BD6SA9pSDBgHUgcukP76+wgC6zx20jB10jgOo8w4anACFEyg+EUkKPa8xgm9L4BZUAu/pBy33By3tB6Vl0CzxndNTwbPKoKv/tB0aGZ4CDxf89fU1A2jGHLScHtQhA3U+2TiFwYfU3T7RD9opzwCadQe5DxQ+kAMchRjQbyZgYCBjEABX558BnDTAM9Xgpe7gBPEffK0dqEMO7sT/+w2OQ9gqBPDAB3Alh6JhIgP4MENgngbN/oOujAQdKAkavADFK2g2mwG6Wga57IGzgR1n8FYaoM9BZ0SAOv+gDj3ICaBVCKBBhW+fHjGADrMDrawApzngqg6IV0D5lolBy76WAZQP5IAH8oHsA+kBXYUHOrwPlCfB5zEwQvMXAySNg0MPGh6M4BU28gwgGqQXNDgG6sSDrzn885MB5CaQ3+A5Caj+1493DOABKUaIG3RdOhhAZ0yAzrcApR9wEDJCbgkADVqA9ILCFhSPoJP3Qe4FrYwAhQPk7IE3DKCbKkBhIAIc0Luyt4oBdAUi+OBNYPiB1Bl6TWEAnV0AGaD5At6GgHyDAWg7CeiqQ9DtHWoWBQygwTRQ2QMazACtigAdpgjaXsMCzBsgt4AGAH//+sRAMYBkSgZqA6zlMD5LsKZvBjoDRoaRAEYHABhGwWgIjIbA8AwBxtGIJSUEGId/eDFSawCAqmFFWrgzkmQ3AbPRzMIIHwy7IOaBO4XAWSnQrBpophTEB+2BFQQulf0E3HMLTnawBiXYDJA+RnDjHLv7kdyJxX+MeGanGRkRZoNm7kFXaoE6Lv+hS3EZUNwByxAIf0BEEB0KbuB1dqDTtkGzdqD9yqBr+8Cdf9gtALjCDO4O4L36wOXkIHNBHR5QZxXUSAd1ukCdEVCjHdTJB5kJ6giBZolBnQeQOOykftDKAWmNQGAn+grDf2zLrqHeAC1Zfn57K2ouh7oP1PGF3QrwC3goGmiZMqhzBNID6mTA9i+DOvSgDgVocOI/eHb4PwNiUAcWtqAT7tkYpDT8wZ1YkFtBHazXwEPcwAfz/f7KoG5dxgA7IR9kL8hPoI6YgcdEBtCBcrDBDOTl/4iBIEZwJ9smchPD46srwfu8QTPWoJsTIIMhHxlAnSqQn35C72wHz9wCr0MDddRBYQnqsIFmdEGz9aAwBe3pfwQ81A7kFsSye9hMKcRfsD3m4P3v3GIMJn5zwVfX/YZubwDdbAA6zJCDWxw8QATaFw6KS3CHn0OQAXTbAGigBjRIBAoP0O0IoHMIwIMWr66C9fz9+5MBtF8dtLUEtAQf5H/UJARN+4Q6YHjl0dMzAwNsxQfIfaCT80FhgH5VHKhzD5rNBomDZt/1XbvAq1BAKxZAnVaQPtBNGIil5kj5H8UTjHD7QHvwQemAFTiIA9pKA8p/oK0EoDwFGsABbwUAXY3JAElToAMCjXymM1zZVwu+KQA0qAUaOAGlV5AfQAcrgs7iAK8GgBQs4JEOcJnAyARPqyB7xIDXBIIOZAStGgFfUwjMs/+hdkHSAKQ7ClqhARrkYYQOJDBAB+rePDoMPswRdHggaAANdgMCYgsCKG9zMIBWioAGuyBpmgE88Aga1AOt+gG58/+/XwygFSmggQvQYAK/qDYDZBsQIwNouwhosAWUJkDpGWQPaPsEyM+gVTUg/ZAbGv4wgM6U4BXVZACpA5VHoAEL0EAA6IwG0FWfIH+CryP8+4sBMaiDrcwnoY4hlA4ZyAMk1b2MjAyjgPYhMDoAMJrKRkNgNASGaQiMViJERSyNKvzBlqio1vkHeYyqDRTS0inxAwBEmIurMwuLPAx/ImbgQO4ALWUHXSkGWq798cVFBlBjFNxwhzXUGRAdSFDnE7QkGLTEG3yyOLIaWBrEEa6oAwCMiEY/zAygPtBsoYSKBwNo7zPIHSA+6DRwBoxBHyydJXhHAHJN3p/f3xggDer/SDRSeGILN0aYX5kYwMuggdewgVYUgDqGoP3ykE4UI3gJMvgQwK8vGUBX5oEOIAOtNgB1FkBqQLPpwsA9yKD7zeEzuWCjGREdH6Q0iEgPUPcxQjo5oA4RqNMAmuUHnmQI7oyCOrKQGd4shrOb0xhAM9qgA+1A+5pBVyKCDm0DuwMtbkCdYNCybNBZCCLAO9JBgwggN4M6eiC9oKXMoBPaQfv7QfHMwSXKYOg5Cdyhg2wZ4GYAdexAHfy7p6dDUxckvGDxA+K9BnbAQIMQoC0N3788A19DB5rhhxwW94cB1nn+D12qDdrzzgi8JQA0AACaKQYNFkBWB/AAr907zeCQsA98yCJoUAe0dxoUp8iDG7CwA4UYqNP1FLhnHjQwIqHqwQA+YA04wADSA+qsgWa0IcvjvzOA3Axawg06VA+0ZQR0tSPIflC8grYCfHh+lgG0OgC0qgN8ZRtwCTnoZHzwgZLwaGJkQCQjtLSFnB9gbJwFKkIvZlpgAIcZaOUFaJYZ2QiQWlD8gW5UAHXQQewHF+YzgFZAQFYvfGMApU3wtX8MeLa+oBjKwADqsIMGlUAdWZA5oMEYPuA5A6C0+Bu4zQI+GAP0F2hPPmggB7RFAJT2QWdJ/Pr+hgE0eADqRIPi7TZwmT14IOE/dGAKuNQfNMsOMuvjiwvg8x0YoGkeNFAAuhsftBrh68eHkFQMHCTQsqsBnzsAGpgB3VQBWhkCijPIqh5G8MAk6OR9YE+eAbQKBXz+AQc/+FpJ0D58cLoBlxFM4DwIKltAAx1/gSsLoLkeeO7DVWhIQLYRgPbugwYIQINLYPeDUg3IncCBU23HRuCBf3oM754cB595ALqxAzQQAxk8YQfbARqkAA00gAYwQOlKBHgYI2j7AWhARxR4qCgo7ECHBkLKktdI5RQDdQDBdEe6NZCSiZE4jYyMDAMLBtp+2vt+dACAYRSMhsBoCAy/EGAcjVRiQoBx5IQT4zCY/QdFKd0GALB0/uH2Q5f/W0duBC/bBe3/1gAe2nXvzAwGUGcD0l+FdtSBe7FBDXTQUnfQFVagDhOoQQ3qHIAa3KAZXIb/uDsY6J1/0P324OvDkDpJoA4qn4g6+Io20Ow/qLMFOQQO0mmAZAVYh5OBATUMER1nsP9gU6cMEB5qmCPlF6Twgc0kgjoGoNk8EGZkYgVfJQdaUgxqxOs6tTCAlqYLy5gDr6u7xwDa6/vhxTkG0NJi0CwrbBUA6LT8h8Dr+/BdF4foOTIy4BsAAMmBZhYhM7+MwD3duxlAKzVAKxtA+9lBKwFAKyZAS65BNHjpNsLb8AEH0Ow1qHPPySPBIKMdAhxkuQvej88vqsUA8g9o5hsUp6AZc9CAh6SqNwPoUMNPwGX5v39+ZoBc3SYCHvwAqQFtdWBA6+SCwhA0OwwaoADv/QcOwvwD7kOX04sCX9MGXm4PXGmgZJQKvlMfZB9oiT4o7YAOeAPto9YArkIAdbpBYQlZpj2bAdTBBd0NDzpE8AXyVgl4+cgIGYMAdjBhd92DDi8ELZmHrdgADXSB3AJys4nfHOCy7AMMoAERkL9BHWfQ4ABooOPL+7sMoA6tiKw1+MYD0MABKB2CzpEArVAADVyA97MD8w9o4AR8CjwDA/aBAKJrMESaxEgL0LiEqPjPgCgCQSKQwS2Qu0ADVKBT6EGDF6DVIuCzFYDxowPsqIJWA4AGdUB+AccbA+JASfS8Adl3/5gBFI48QkrgTjdoVQZo9hs0KAAZXIKtMGECH4AHXrkBXDED6miDDnIEdXBBHXDQlgvQTDlsawHILlDaBQ0wguIddM0maEAIpJ8RfmgmcIYduJ/+64eHSF5lAu/9B53nAcpnoLIKZAco7GGrA0C3F4C2dIA67ALiugygmXXQag0j76kMT66ugpQEwI67ll018OyJ2+ADAkHpCXQAIOT6QGjJwQihQWdCCABvlQBtXYEMeCBWnoDcCrIHdG3ho0tLGUCHZIJWC8BiEXS4IGi7CxuXCLhsBa00AOVfUB4FYZCbQWkTdusEaAUWqMwDrbz6/x/fQA2ZdT2NBgKISt4jqH3CMABgdACAYRSMhsBoCAyvEGAcjVBiQmC0809eOqFauJGeTqna+Qf5Hs0vKIMkcDmQOyFuhc+YAjv1oKXQoM4rqCPPDbyL/fLeSgbQbB/o+ivQTC44cIENc9B936DOIKjDCzqgDDRrCmrYg+7Mt4vdwXD7xETEoAEDIwZkgLsT0tkFzdqBGr+gA94gUpBlwKBG95vHR8D34oNmIUFL9yHLhhmhfU2gOtCBcQww/yD8xYAUFugDDrBEgq2jDZeDriAQB145B+pcgzqJoL3Mr+/vYwCteIAsXX8NDh9QBxjUAQB1FEGdWlAD/gdwNcB/6BYD0CABYpn4f2gnnAEeLgwo8cKAfQAA3CFiZADNSkPuhWdmAF1PB7pxANQJA3XwQEvpQaekgw4FBNkNOtSOAT7T+x+x2gBoH2gpNMjNoI4i6CA/0AFnoEPfQHqf39oKPrwM1BHnEpAHH2AGOon/JvAgPZAeUAcOvFQaaA6oMwkakEBP+YzQ2VVQWgKdzA5a7g/qxIOujwMN5mjYVDCATmf/D13SDb7/HOhWkF9AbgClL1An6RXwxH5QGgQtjwb5D3TwIOgqO5B/H19exgBajg+JM+Q0wIDiV1A8v7iznQF0kBxkxQATA+gANvBWjZ+fGEDuAXX+QOcugDr9Eqqe4E4caJAAHNbAk+xBgwV6rh3AK/jmgrdwgGffQfEG3PcOO0MB5F7Q7QigbRSgDigLKzcDaLk4wn2Eiie09MuAJS3gTNdgCUgnGTTwAZzJBu3R//PrKwMofti5RcBX4IFm5kHbUkBxAtoeAQp30EF+6C6DlwvAdAfqPINWe8DEQHpAaf0r8JBBBgbUQwRhaR4UXvziOgygDi7k7ID/4LMMIGcmMIDPU7AKW8Nw63gfA+jKR9ASeFAnHnSVIOj6TXB5ABwwAmcNRlgOhg6OMYLygTcD+EpPoF+ZWNjAA1EgPaB8Bh7cAS6hZwFezwnaygHKn6C0/R14UwJoVQto5QI49wEHAEArX/iBBxWC0gBosAS0CoEd3FF/D82WIDuZgANer8C3SYDyN2iQAHxgIVL8gFYogWb9IbcYwDrtkDwnIK7PAMpLoO1MoLwGCg/QqhtQXgWlGVCYga64BK3UAB1Y+er+XgbQagHIIY3Q1IOzjqKgbQQyE4YZKAeMxA7IM4625xhoBEYHABhGwWgIjIbA8AmB0cqCYFxSsRIfKumG6MYGIQ8NYOcf5DS6DQCgdTJR7YZ00kGdKUEJA/CJ7Oe35TBIAjtCrMB90dcPNTOAOkYgVaAOHWhmGdTpAS0xB9+v//UFA6gjCVrmff/8PPCSW0gjG8tJ1ihplRG81xayTPgteJYO1PgGH5rFxssAOmEfFD6gTgSoowlfdgvs9IMGK0CzcaD7tf8AD8z6j34VG1K8wtMKWhgQMwAAOuwO1IAHuQXUuYAtI5fRDGYADUiArhcDNeRh/oVc6fWFAd4x+o8aBnA7oeEAmiEFdVhgyRT7jC8jgyXwmjrQ6e7SGgEMoA4w6DyBp9fWMkD2Gf9jAIUPaGk6qJMN6qCBZrxBqxFAYQnqxEKWPDPAp6ZB9oDiFLTdgxW4NBrkbtBJ5OAT5x8fA+8bB/kX1DF7+/g4+GR5yHkG/xlAnSlQBxc0s8ktqACeFQZ1iBmRhnpAvSfQzCjoWjXQABLoKjrQNWmwJeNfgFcBiirYg2dE3z09zQDaKw3rlIE7jcCOp55LOwPoPATQgApoewJohv0xcPYWNnsKnt3/jzwLDg1FRohLQG4AdQrBAzag5ebAQS6wDDD9aABvAgANdoG2IoDMe//sFPi8A1A4ga4pBHV4r+yrZgANRvz4/JwBNEAC2k4A8idoOTt4TzfwAD4xJRfwQYOgrSqgFTGg+IB1gkEn6aOuhEEfqMIxcAX3BnLdh8SGpmNs6Rq54w460NEhYT/DzaNdDKrAw+dAnVRQ5xq8jx3YuX51fw8DqMON3olHT4sgP4NXmADvsgfNsoMGFRSAhwyCbq1AzFAj3Adyl5xuFHiwCjSABOrYg7a/gMIUVu6omOUCT9PvBQ+mgVbXgLYbgdItaP88KL2C3A4+FR8pLmGrAkA0KE+CVg6IKtiBD9UDneUAOvQR5Lb/0MP5QGn70+vr4LQMHpADbv+ArT4AuRGU1kF80IqSn19eMIC3L3x/x/DnzzcG8IGBQLs1gVsNwNf1AfWCVysAr/wEbY+CnSkCW/WC7Htw+IG2tICGioD6wPv8Pz9lAIUByF5wmmRmYwBtSwKZA3IvKG40bSsYYCud/mOZ+cddV1ChjQQrl1HKZwaSAawMYKBbvUuqE4d3e3J0AIBhFIyGwGgIDI8QGO38D96KdOBSGCMDldIFIzXMwZy1IzZkqN75h7SuUaxH7SRA/AuylxE6o8wAnekGqQPtGwZ1eB9fWQk+GA506NanN9cZQDOZYKOBHSd+cT0GkF5WTkEGdasSBpBaUOMVtOwf1Kh/eXcXA/iqPOQD9pAbl3DXMUJmuoFy3z7cBzfSQR0E0MwyaJ8s5Lo9YOcO2JCWVPMGLq+XBi9TB50sDmokg2ZvQctqReXtwY1mhv//GdDDE6MxyoiIK1S1jMhrthmQwww8AAGczQcdegfbLw6afQYNgoA6IaBZY2ZWDnAnmAHa6Id5kRFqHyNyh5SVC3ylGGgZMBNwZhl0IBhoZhsSdSB3MCHiDxpuIPc8vbGeAbSEGrQqA7RcGhRP//7+YADFH2g1AqjzA+qMgJYpg+LjzYODDOCBFGDnHnSQ2vtnZ1GWi4PiELRvGaQW1FEC3UEOOscBFOewDizIIaDOMGgmEt7ZBs8u/wBvAQDZC+kI/4G4GS2ewcvogf4FzfqCZplBS+sh2yL+MoDOBQAtJYetAoDFH2gZOGjPNmhABbRkGtTJBK1iAN27DzrbABTnH19dAs+owjpJ4PgCRy0jfOYfFEagjiTIDsid+RIMoFUMoKXWoO0loMEu8MGAwEGB/+AD1xgYQAMVX97dZYBtNwDNTIP2aYO2AXBwi4IHq0CDJKAl/6BBAVAYgs5jAHUiIcvWmcH5BjRQAur8//kNGQhiJLOcwUijiIQFZqHmbXAKYoCnIyADNGAGmmEHdfBBByeCBlZAHXLQah1QpxzkTwbYABWKGxmRzGEEpxvHhIMM14ADgaBOuZiiIwNo0Ah0LgZ4lQTwEEcGOIDka9CqHlmdCOBhkVvA1zuC0hgDvExgYgANCEEGvv4zgDv7wNl50JYB0CARKO/DtlIwgVcmSYJNN/WfC76xARTuoAEZTl5JBlA+BN9kAbzxAeVaT9CNAMDbK2DhAZr5B8U/5KC/v+B0At4CAuykw24wAIWPiLwdg6CEIcP7F+cZQHaD3AEaQALlfdBqAfB1mcASAjQAChoABKdbBuTyA1rGgCiof8EDEkCHgFY0gdIkaKsJaPsCKC7k9aLB23hA7nz14AADeCUMLE7+Yw6g0nQQgAEJoA8IkDhAQFQdTZX6l2EUIIXA6ADAaHIYDYHREBgGIcA4GouEQmCEVqCDZwCAsjRKXMeABDvQ0gNyBwHU+QLNtIGSFOggLthSXEbw3n9mcIMY1KEDdRYgS3dfgpfpgjs8wEPZQI1l0Cw76CRxkBrQfnPQnffgE9OBnSNQ5/HVvb3gPcAM/wkdMMYI76yDGsGgxjWo0wc6yEtA0gB8HRuo8wLqDEBm85jAV96B9vuClvOCDtfi5pdjAB3yBbqCDOQX0GAEqFMJmq2DNMHRwg0eNhBxRjQ+dL0vA3qnCqTO2GcmA+gOb9CMNy/wjn+QX0H23T8/hwFyuvkHBgb0FQjgvAs6FZ0FfCUdyM2wvc2gDimo8yQkYwG+qg3U6QV1TEEnlb9/eooBqhVKQToXoFlK0OnqoJUHoI4IaFk26ABAyO0DHyCDMsBT2tmBp9uDVmKA9naDBipAndPbJycygNTCDIYNTIA676AZYFBHDHQbAGhGnAGp0wFZzgwZhIHohewVBy9NBi3dB/kZvIQf1FFBT6eM4JUCP4EHwGlYl4I71aC90bDr0UB2gsIRNOADiWOIDaB4B82QggY0wNstgDOloI4hO5cQ+Po70KnsoP3RoIPswGEOjUdGlNUHwCXbwEEbbiFlcNgzsXCAV5eAVh2AbAENHoEGAUAHJIJ6t7C8AApTUPoBufH5rS0MkKv27jKAwhDUcQMtewfFE3hmGjrLDDsYD3SLAMidoJPoQcvrwbcDIKUJcgYBsA4AIOVxbAMAKOmaEWnMBxxXfxlAgxmg1RaQ5eX/EWkMxMKaRyDx+gC4sgcUPqAwF1d2YQDtdQddhwhe5QCtp5DdCxrAAS1pBw02gNIWaJUM2E5G5OTNyAA66wG0mgV00Ocf4Ow65HDN/wygpfCgdM4DzG9KxqngffqgwUaEnxnAAwfgw0eB7gYNxoFWD4HyMWTrxQ/EahfgIALIHlDeAJVb4LMCQIdBMkJNA9Ja9nUMoPQGOjPjPfAcD5AMKN2AVrqABpFAM/WgNAvyg1ngYoarB+rBZQLoKkzEeDSibAENxIEH9mCDHkAaFCawMhh0eCHo3BPQlgB4PgMFDdogInJoMWAJZwYUQMc2EyOkXGJAphnQXUOEe0ZoG4aBRmB0AIBhFIyGwGgIDO0QYByNQHwhAKt0R2AojazOPyiCScgLeAYAQLNxkNleGQbIIXI/wamHlVOAAXRYGKhRDGqUsgFnjMEdJaBZSsZpDKDGMGhpM0gNqBEPuvMa1JEFLdkFLeeGnBegAL4tADRzLwI8zRrS0YLNXoHcj4pBnVlYxx5klqxuBAPoLnhQB56TR5IBdjc2+L7tnx+Ad8ErM4BWIoAGCnScmsAHyIEOYQN1EECNflAnEtS5ZOXgYwAfSobRF4UJQGhsnX9YBxIcKMidLCD7JXAf+st7exhAy+Rhh6aBBidAAwIM8A4wJDPCO6LAToeCfhx43zAozN4+Pgqc6dsDXBbtC+6VgcJUWNoMvNQY1JkF3RLAL6YLPgwPdGo9JMSgjWxgDwN0ICJo+TboPAHQsnSQP0FnMIA6D7AZTNAhbSA27I53UAf287vb4AEVUMcNbCYjIixAy7pB7gcdlvbq/n4GxMDNfxwlC5o4dLAAEVyIeAaFMcgfoAEFUNyABipULfIYQAf7wQZLIKfYw8z8D+5HgbaDgE5CB4Ut+GwD4B52kKkswC0hoE476BA3YRkzBtBWE7gjkTohoFUHoEEt0EAJKM2DOvlge4BuBZ0jABocAS29/vX9PbhjD1oyDnIPaMAB1JkExR+okwfa6w065BF0FgFogAC05QR8kB4wvkEdQlDcgQZQQOkXlCZAgxag8AR1FL8CVxGAVrP8+go7yR2aNkjo7BCa/YeUDIxIK1ewpG2ofYgyE6gGFGfIA3ToahhhccjAwIjOhiYd0KoNyIoQ0EAfbAsGsv2QXAA5Mf87g4n/HIbnNzczwK7FY4AWawr6scBtRl7gKyW5+eXB2yxAcQFaGQMaOALlMdDBm6B8DhqAFANuGQENUoJm8UFGgFaVgG0FuhO0Lx+kBjSgCBogAq2QAR3WCfIDqByT1QlnAK0CAGU+0E0doEGMNw8PM8C2qoD8AyofQTPzoEMTYeEPMvPXt9cMoJP/Qas9QHF/98x08IAkaBUDIyIRMjBCrzAEHYQKSiumAQvAW3MgA2b/GUADACAM2moAGiwFpZGfyKsn/v8nukbHPaCEiD/ymgcw/ag08qGMDLhW4DEip0dEeUjQHSTkCwaqAEaG4QpGBwAYRsFoCIyGwNANAcbRyMMXAowjN3yo1vkHhS9F4UhZHBA/G0iiPWh+QsyWMYHvnwctIZdU82EAzaSDTIYsgWUAd4RA+7rB98oDG3cuaafBd6eDOvnMzOzg2VMJFU8G0AnpoGvZQA1k0NJ10KCBvF4sA+gkdlDnHbSfHXS41ZNrqxggHTYG+Ew/yM8QzMQA0gO+5/3PdwZQxwrSEWRkAO0rBnWyQad0g8RAqw9AjW4WNi4GUEcWFG2gmdV/wNk7aeD99aDZYtAeX9CSYVDnC9S5g8/EI3UK4U1RoBj61gfw6f6MoGbTfwYGjAYsI9j9sI4qSC+oUwnqgEBmoIFXAP6HXGXHgJymoPaABiw4eaWBp46vZABdBcgnogFeIg7qLIIGAEBuBe1NBu2TVzRKZji3JQPc0YDHOlIHDNTZBA84gDs778HmgFZygDpR4PAHHqAHCg/QlWuwWXbwfeKgzh7Kigxow54RkZt+gpdKgzpzMJsZod5hAndqQIM8oA48fAk3bGYbR/JEn4UGLTUHhQVoGwMDyonzSB2e/5Cr1kCdftA5C+DVAcD73sHBCrx9AdSRZwKmRZD/QGcCgDuh4KX7yG5mBN/EADpbAHRdI+wGApD94iruDKCDAGHLscF9GPBs6z8G0Owx5LR4PQZ+4EnvoHQE6ti/B55NABp0+PPjIwN4tQCwgwdadfIDuJ8bNBsO6hSC7GBl52UALeUGu/vjIwbQagBQmIFuTwDHGVJ5TkzeR1WDFMhI+ZsRvuwcGp8MiLwG76BB1SPKAXBoMqDGDzSuYZ06aJpD7vyDO8lw+6D2/Id0/JHNhuctRsgAAOQGBgYG8Eoh0DkdoPv7kfwAWn0C6hyD0ilouwRoUAbmW9B1fKAwBJkEKpdAWzBAZ0WAVmGAfAG+eQHsZ0gaVTXPA28RAq1IAm2NAR1M+vHVVbBfbx7tZADd5gEqJ0DnN4DyyeNrq8FyoMFIIeBAHGhwU8UsG3wbAGigAHzIHyMj5CwMsKP+M4DyPSgfgrY/gLYefX59DZpPGMHbBfjEtBhA5SRowAu0PQG8QgJ8GChwywEs3QPDDWQGKD+AB+7AnX5iOv6YmQ1WpjJgBbB0gUgfmMrQ1eCyg4lB17mdAXKY6V+oMch60UxmRDWHqHqbkZFhFFAeAqMDAKOpaDQERkNgCIfAaEWAM/JGeCVJtQEAssMRX2OK+CxH3AAAifkAV6ML1gkAdl6UTTPBs2Cgxieooy0PnIEDNb5BDXUdp1YGdk4hBtDVcKCD1v4j7V8VBl6BBrpPHOZDkBx4jy5QDaiTBJ4d4xEHd0pBS4xRZ3ZROyagw8HeAGfDQQcMgg+0A+7nBu2xBS1RB83mgxrqIDcpGqUAByGWMYAayaAl19YR6xkeXlrCAN5nDxwAAC1XB/kBdJAXD/B+/m8fH4NnsBHBgNq4BYU5eEkv0I+gpbygtAQ6CA5yov8fBtAMIejkbYgfEfEM7whBO0agfcagK/FAS5tBAxagAQnI1glo6CDFA6ihD5qNB62eAK1wgN3HDppd5hFUZAANXoBm/UHhf+NwG3hWEXRyOfiEfaTkBEsvoH3woCvPQO4HmQ3aLwzu1DLAlunDrnNDzKpDjPnPAOkworoRtRMJGf9A8T/QLyB3ywH3KYNWh4A6VR9eXmQAdeItQlYygA7Fgw24gLyN2iGBpl9GSK6FzP7i6OggL3sGsiFLrf+Bu6SgTiVoxhREg/aA3zjSwQA7yR41riHpDNRxB+/VBnbKQbO1oM4aKP2A4ha0ukRQ2hS87YIB7It/4DQDGoQBDUqBlrODBrjAB/kBT/f/Dey0gmaWQfEF2vsNGih4cXcH+LBA0AAXaMk6qOMKSv+g2WDweQjATi4of4AGpCCdf8ztEbg6bpjiiDBkQEpXsHgDdUK/f34C2fzAiKVDxgjpiIPjFK6fEcpFKstQ1DExwFZRQCMAoh5pwAF1cICBATY7zAi9HhQxKMCEGABEGUCA3L0PUgdKw3+BZyWAb5YADfhABxZktIIZQAdsQvIP8JyPJyfAMQZarQIacAENxNw/N5sBlCdAM+6gWyZA7gINaoK2ZYD4DOBtGkwMoHMjQPaADzMEzriDBh9BeRZkP2gvP2hQAZTOwYdaAm8/Ac3Mg8+ZYEDkF9BgJCitgwYYQG4FrUiCrKphBIeXinkuA6j8Aq8yAKYd0EGCoPINtB2BX1SbAZ4WQOn7H2zQkPgZfwY8AJZu8NcrhDv76FaAzQXelAAaBAPVC6DwA9UdYJNQ6hvsaQ8jzTIQAGTXywyjABoCowMAo0lhNARGQ2CIhgDjaMxhCwFQxTjCK0dGBiqlDbLDkTr2MxJlPxl2oZnLiDKjB2mkg2ZwQB1YUKcXtMwatKydEdjAA+2/B3WCQPtZQfedg2bIQMvNQY09HkFlBlAn4x2wAQ5qfMMadRB/QGZtQR0eUMMYtOQWNFjw+e0NBvhMPANS4xDoRtDsGOgOd9ABdTePdTGAlvkys7AzgA9m+/WFgUdEDbgvWBV8eBhoGS3oFO5nNzcBO/+LIR0NoHGicrbgE/glVD3A14yB3AW66xvUoQZlH+QwhneqgAMgoFPkQR0z0O0FoAY8qBMPWk0AOugNdIo48l50RGcMtSMLmgUEnYMAOjTv7dMTDKC9/LDbCRgglkNzMCMkqIB+Bt0bD1oxwAieQdYHn/4N6bAwAVc23GIAnXAPGgQAHZTGBryuTRK42gK8t5jhPzS4GcG9c1B4gGYrQbPkoPvxQdeFMaAsG4bYCe6QoSzPZ2SAd1agnT1GtBlf1HBD+Bk00wpa+QHqTIP2aYNmY0FmgQ5mfP3wEMO/398hnTx4+oPFNywYkDuhDPCwwVrQQ2dD//9HHsCApDFd4I0Ax1YGMoAOoQSv9PgPWbEAKRoZGWCdUjANdAIo7Uqr+4FnLUErJUCdc9AsPWi1A2jpOCjdgTru4IEuoH2g9A0aODDyngZekg4zD7SyBaQHdBvC46urGUDbGvTcusHbOUAdzf/QFRb/wKsR/jGA3A4eEIINaqCEC6qvYWkMkdaQ5ZHTHSQMYSQoUYDiGLScHHZrBsiPsP3wDND6Ar0MgK0MYER3EzRNQMxlZgB1ZkFpFnSYIcRtwI48MwsD7KBGiCsZockd1JmHzMJbhCxHrLJgYoLHCXKZAXI36OYQ8GoSkL3APPEfvI3mH8J8oDiowwwacAKlNdC1iiC7QatQQANRDIwQ+6TUfBlAeRqUl55eXwMcDNAE5ph/DKCtSOBT/BkYwIMj4JUFQOeC9EuouIGveATFE2ilhr57H3iZPmiAAHSjCGj1EqhM+PHpKQOkA8zMAHIzqFwErRYApZH/yKtqgG4FnQ8Cyougw/1AA6PSwMEL0OAkWC2wsw86gBH5zAXMtM/IQBwgrA45TTGQCZDLPlD5Blqx5JJ2BhhOq8EHwoLKepDREHWQgTdYOgGdjfIOPFhDtuUM9AGMDMMRQEp6hlEwGgKjITAaAkMpBBhHowtbCDCOhgsoWAZ2AIA6ccBIVFySYReauShhBZWDLc+FzO4xM4BO/AftiQbNtoJOWwfNuoOXeTNABgtAjX/QgVx6rl0MoOvQQHLg1QJ/f8Mb9sLAQ+xAAwigk///oxwIB+m0gZMzcgcV1vkEzhSClnODDtgCmQs6dRvUmQItkwfNtILsBfkBvFQWeNUaqNMFuiebhZ0PfD82aNbu/fPz4NlbkL2g1QPgg73gM+GIjATyN0gN6ARu0Gwc6K5vkJshp9H/YwBtcYCc7v+DAX7SPY58yAidxYTNeDIgzWqipFFwmEM6paABEdDsMGimH3T3PsjPkEPtRBhAHQrQrDOokf326UkG0AwbaN8++GA/4LJ80HV/4A4+PA6hnRE5a/Cd9qC95ihOBXaMFA2TwKs8QHfZ3zreD+68gOIJNLMNUiunF8Pw8OJiBgbkQwuhgwEoHUNoXIE6W+pWxQyg2w5AYQxyOyjdgNIRaBUGaFYd1AFzTDrCsHe2GcN/BsxZTVwdUYTbISsYEKtO/kPch7YyAKL+Pzic/qPENXSWnZERfHAlaEAItIoCctDfX3CnHBSmoqDzKd7dAS7l/swAmkUG3XCA3BEFqQelDXAeAQ6MgbafgDo7sDMWYB1V8MGFwI4dnA+euYZ0/uHhitXtDGjhjjWhISde8ADZP+iM8X+krRygk/NBB9uB0iwoDYOuS4QNZoANAIcFKwNYLwOykcjlCyMDbDAB3FUGxTnQ33K6wJPpgXfR/4Seog8arAMdfgk6eR80WIUcx6AwAy13B4Uv6JA9UBoHnczvlnkZmM4WMYAOuoMNUoFW2YDy9tf398FnYwjLWjKArpiEuQ6yggDSuYe4h4kBdt4FxE9MDIKShsAByefgcAQNiIEHccAH+kH0gfImyC2gfHb7xAQG0IAO6PpMkD9BM/GgcgZ8eCjwXA+QXkieZgKXJaCw0nfvZTi/NRscbqAtU6C0Djq3AlRegG4+AbnjM/RqQRAbZB/oME/QlaSg7Uyg/AFKM6CDIEH48ZXlDMa+s4FlaA30gNT/iDwCjU+UAS9oeQkP4/+4VglQtnrgP5K52OslWNpgZgANfoHyPqic5BPTZgANyILiFORf8DkYf39CkxwzA8jPoMHBB+fnM8DyM/IgJbbygQEb+E+d1REMeAE97GCgK2BiGAWjITAaAqMhMKRCYLSTixFdjIzIa3JHdHoeuM4/KF3Sq/NPpl1EDhChn+gOOq0ctFwfdAga6IRv0CFc7JzC4IEBBf14BtByeVADD9T5VzbJBN/XDkqEoNl6UGca1Mj++vEhw39o45sBZdYWMvMGTrSMiE4GuOMMv37wP4OEsjsDqMEM3kv9+ysDyC3fgXeuSyi7gQ/MAjUmQQMFoI4BaNYb1FAFLccGdUyMfWYwwGbiQI16eAaBhQeQBi3rBXWEQW4FnR4PWvoL2uogLGMJPhgPZBaoYwwa5ADpB3diuEAdcy4G0CoF2EwqA6wzDLUEW4MdewZlZABtEQDN2oNWHiiZpDPA7ikHuRnUodJ2bGIAyUGuVPsFPrUedPXdw0uQFQ/w5dXgTjpkYAW0kgN00CKkK4HaiAWdYv/z+1uwOaDZUg3bSgbQgWigZc1cAgoMoFPHGRkRnSx4xw+ejqDxBR/sYGS4BexIQa4/Y2CQ1gwCH1wI4oP8BUpHoIPXDixwYADPzKKt1CGUd0FxChr0AMU1pPPNwgDrkKB2giB+/4/lADsGpIEZXZcOBvu4PQyg++RBZytYhK4Cp1FQWIAGW9StShlAbged5v8fqRMPVg+83g60LQaUDkBnNIDiWduhkQGWjkHuA62M0XZoAA/egGay1YE3HGD4EW/nBZbPcdEMDAxIeQY0mAE6xA5kFyzeQDTIHyC3gLbMgK7FBA0wQcKBiYFPTIcBdHq+pLoveHk6eC89EzMDakcPUq6B3C6jFcoAytOgqxNB+Q20rQRkLygcQAfqgfbNgwYaQKsCYHEMXo3ACJnlB4UnaNAANKgI6iRr2FQywFYQweMGaP+bx8cYQLPJoPwM2poB6iiDBx0ZIasIOIAHgOo4NoP364NO0QeFA3hL0f+/8OwFy3ug1Q+g9AFazQTKx2BzGSHbF0DnPYDKI1C+Prc1CxwGIDeCOrAg+0BbAkB+Ag1eQAZAGBl0nFqAaTuQ4fy2XEh0A90Lui0CPLMP3DYEusUDNNgF2jYEYkPKMkgYgleTAFfCgLYhQQaL/jBAth8wMoDOXLl1vBdSTiKlU/jAA2iNAiOW1RJoK7gwyxdc9QWWdAUvcxmQiknIACXOzj8DLNkzga9aZATeBAMqP0HlMGhVGCgcQekLVMaCwhE0qAKKM33g6hjQ2Q6g/AaqP3AOkjIQAETWawyjACUERrcAjCaI0RAYDYEhFAKMo7GFHgKjlR9KiFBlAIDkMKVeuiQ880+mXVj8hBJWKPKQBp+BxwQG0P5WUGMd1EgFzQ6DTl4HzeKBOomgRjJodh3UePvx5RmDmkUheJ8t5AA3BnDnArQMHNQh0HPtBHYcnBmuH2pigMyOQWduobEH7iQwQEhQxwHcqQDvKWViAB2QBlpSrmFTDu6UgmYZQZ0u8EnswEP5wMvqmUDzGf/BV4WBOswgt7FziQIPXIthuLSrhAHSgYPayYjkc2iHHXRQIWgpriawQwLqvEiqejGAOhmg5fugvcKgE+VBS+1Bh7dBDvcSYBCSMgEv6wed/A9e8syANpgB9hsjA/psOQOGOkZg2DiAD/8DzSQDp/8YQIeYPQPe569gkAC97/sfw6v7+8AHIYKu/wMtEwadtcABvN8cdkggNnMhdkPTDGxwghHS8AfNrqoBZ+xvn5wEXlINWpYM6riClr+D9jGD4g7USQF1ZkAn3/9Eu8MdbB+oswiMJ9AKBVDjHhRX75+dBQ8KgWYCH19dwQBKMxJKrgygKyPBV+QBb2sADeaA9UPjAl9ahKkD0aC0xg7c+gDqVIDcCr5yEnoGBQPGtgAGBowwgYYBqJPy7cN94BkBWxhA2ylA5t040g5OJ6CZZ9AJ/eCzE4Az0KB09PvHO/DqAJA7QSsnhGTMGUCHWILS4HfgYX6gTubzW5sY/iN1QEFh8unNDfDgEyjE34FXbvxhAHWeQUu+GaAAZaaTlLKHEdExh+3Flweu2nj76AjYH9KaAQygwYvnd7aD95yD7AcNoIG28IA6s6ABAVBektOLYgANDIAOKTT2nQk+XwJyOwdSxxEabp/f3WIAnWcASiugMyZABxyCVgCBOtagASWQ2aBrN0ErKECDU5AIYIR05oEdQ3AZAjxbAbQiBJQnQVuGHl9ZwQAemIPuw2cDDi6C9sSDrvoE6Ve3Lmd4fHUlA+S8EAYGdesSBtAgAij9Q1Zq3GYAbVeCLC0HzixzCYNn0EH5GTRgBDrQD7Q9BdSxB10jCLJT074WvOIANFsPijvQgA8oLED2gQY2QOc1gMqQN48OM4BO6AfNzoPSCKhDC5rll9MOZwB1+P8DD9QE2QvaagQ5dPQ3OPxAKwRAt3mIKTkzgDq54HwIDMOvHx6Cx2xgh28KShiAVxCA0hto8BR8XglwUA5WyoPyFD9wJh08CAK8jQIUz6AONOi8CXB4oFcHeNMPUoefkQk+eAQbRNJyqGcAlXegvA9awQXLPQw4AVq5AolsBtBqC/AVhqCVLcD8wCuqwQBa+QPKq155d4B1QAs4n4DKbdBqLdAgJfjWDHwrghgIAEZatw2HX9tzdACAYRSMhsBoCAyNEBjt/KPEE6jCYxwNE+QwoX/nH6mBTIVMxEhU440Mi7CYixFWcDWQNAWatQLN9H2Ddm5Ay6BB+5VBMzegA8VADVLQwACocQ066Rx0XRboujVQox106jqoEw86EV0ZOJMN6syClraDOm+gw9E+vLjIwIC23B/WCAWtJmAC7iEGnbLNBL3XHbTnFjR7BNobD2qYgjqioBPeQSEB6kiB3APea67qDT5sDrIsm4kBtIwX1DkHHcL2C7xEGemQNUbYrBakIfwdeDCgGHBWF3zdFwNkuT/4ZHjgfm2Qn28d74NcMfjqCvjcAdAs8N3TUxlA9/GDDrvj5JFgAN9LDk4SyPmSuAEAUEdS37WbAdRpBrkV1JEUkDBkUAGuqLiwI58BdOUYKPzB2xf+Q5aqg672Qw1HBkSjHmWpPlpDnRGSbkH7msHLqkEdL2DnDLTCAHT4IKhDJ60ZCL6ODXTAGqhzBlrN8ePrC2jiY0SZeebil2EADVyAwh3i9j8MoFUiIPNBM8ygQxxBaUBOJ5IBtOcXZB6o8y4O7ByBZqefAe/RZ2BEdjsDwh6wMCOcDzpUDXS2Aij9ggaEQLO5oE4LOBzgwY59awEjfICJkUFUzgZ8sOJf4FkSoCsqP72+At/WAQpn0L5w0K0MoOXaoDSOvA3iw/OzDIoGiQxX9teBB4BAq0xAHTjQmQOgbTKgDiXIwSA2aFb3G3AQATQrL67sygA6ZBBEgzrjMDPJKreQ8jREPyO4UwXZevENeEtGAvQaRUbwSp1v4I4nMwNsth40EAA63wCUJ0FpH+RfUH4GLVl/9eAAJPUgxQkjdEZaTN6eAXS7BeTwwz/gFRKMwPwKGuQD5zHgoXagmXjwqf3AVROM0HwGKg9A5oNWb4DLlJ+fGEDhDOqUg5aJgwYUQdYxsbCBV9SAbhUBzZLLANPh3bMzGEBnhoDyBGhgADQACdr3D0pDoGX/4BPngQEOOgxUALjsH3RmB6gDClIPvqYPPHPOzADq4L97dgp8ewboaj1wHP0DbVNiAocL6AYR0IAGpGMNSUygVTigzj/I+6DBBAboqhLQuSigsgc0gADyI/gcDmCZ9he4xB20zYKZlQM8CAPa4sAAX4kCK1tBNGSVCujgQtggKagc+QrcdgJTDzIXZA9oOxIofkDplFdIBXzYKeh6SgaGf5B8wciAupYG1jbAQYPKdmXjdPAWKUgUQ1b5gAbnQKueQGkTZaUUJHMyMKDToLiFDtKCrogFnYFhFjCfAVSGggZ5QSsnQHEOCg/Q4B9I/4u7O8EHa4LSHyjfgNIC5KyQfwwUA7z1J8MoQAuB0QGA0SQxGgKjITAEQoBxNJaQQ2C0osNID1Tp/INMJTpsqZcm4Y1knKmcTLtgDUAs5hIeAGAEz3CBrlEDnUIPakxrOdQxgDr3pzckMICWM394eQl8pz+oIwrqZIP2/L59chJsG8T8f+CD1UCHPYFmhUFLPUGzZKC9to8vL2dAP/wP1DAF7VUGif+D7hUFLeP+++cbA6gDA76qDjhLBJrxBg0sfAHeoa5qUQC+OgwkB+rMgtwJGoQAzQw+v7UVPPsKmullgB6Sx4jU8Qd1WB3i9zOADg4DNahBAw2gQQ/YQX2gZazgO92BnUTQtXygjgbIfFBDHHQaOKhzB7vqEHLlGHrHE63zD01f8LBHGnQBLb0GhQ1oBhW81eH3N3CnHzSDDNmfDjmFHjJbDLPnP7zlj/AXyE4m6HgKuHkPiX2oXSC7IQMkzOBr8EBXJII6U6DbCkAHkEmoeICvcgRdx/YHvNXiCwOoc4vSyYaZBZxFBM0ig7ZOgA4+Ax2UCOpkgTo1kI4UpHMF2r4AsvMJ8Do1UEcY1EkF8UF7r0Fh+uMzaJ82ehpH7iyBAw4y6ABkgrafMIIPmvsHXnIMcifI/6DBAPRbJTALCoi5oM4vKCxBnbrXwJUVoM77b/AVftD76oHpBbQdguE/ascENKgB6nQ+ubaGAbSk/O6pKeCVACA/gQ6JA3WmQatEQPaCBrBAbFBeAa0qAXWEuATkGB4Bt2wgVgpg2VuMJ98yQNMQJETAsckAm80HhSlo5QqoU6UF3HoA6pyCDrEExRGoswiKG9DAGWjJPWh1g6pFPvDE+ZvAk+99GUDpDDTzDZrhBw0AgfMLdMAEZAvosDoG4MATaDAE1BlVNctlAC1vBx0oeP1gE3i1jKZdNQPoOj3QlpiP4BsgYEmPmUFYzooBtEIAkp9/gA/fEwGKgdKAFPC6UdBACyj/g8wEzdaDOqCgtAm6zQN8Bgd4MIGJAXRt4yPgDR+gmXXQeSLgVRXAuHp6fS14KwEoLYAGn8AdWGA4gtIbaKWAgKQReFAKdK0paFsPv4QeA8h80IAUKH+xcfAzgLaowM74EFNwZACtClAwTABvzQENYIBXHQEHREFhCercvn9+hgF5mwk4X4MGAYB5F2TOyzs7GEA3j4AGpyBRCsmboEwL2qoBuRXkDwPo2kLQKhTQ9YRPrq1FytNM4O1UfMCbAUBpUcepmQFU3oDSlYZNBQNo0BBURkmr+wNXetwCD6oSqgdBYQzadw86rwC06gMyqGsAvpUFlGdBbv4G9iMDfsAISXtCMmYMoDwEGlgSAq7suH1iIgNo8AW01YEbeEsC6EwAUBiABu5+fXvNAM4HrJwMoMEi0KAOqPwGnf2AfbsOA1JdwkAcGG0bMRALRgcAGEbBaAiMhsDgDoHRzj9K/IxWcFiTK1UGAOjc+Seu409i+od1HvD4BWtYwdUzQpesQ2jL0JXgk6/ldMIZ7l+YD55lBDUgQUuEwTOHwPv5QUs7QQMDoE6NjGYweE85aKkrqOMBmhEDDSL8/PaKAXR/trp1GcPxVcHwhjNyxxXU8gUtbWUE3uUOYoM63aBOPsjMT2+uQZYAAztkoNkkUIMYdLUXiIbt7/8PnRn/A7ySDXKAH/AAQ2DDHtTZYYA2JWGzWKCOPqizCJrZhhyQ958BfB84sOOiZlkMHugAdcRBKxZAHQ1QBwXU8VSzLAR3OiEHH75jEFNwAM/qgq+uY2BAWe4P9htwhgxiNaxjzswAn+2GNW8ZIXKgmWHQsmlQIx10nR3ITlCn+v9/zNkxUCMbtucf1HkBNbIhe+8hqxzAAwVoaYEROosLGmwA7QMHzSyCz3cAzjqCBj8gs5HvGT4Al/CD900DO12gjjKoowRawQFyLmRIAeJe8JV3wCv0QLOkoE4oqCMP6zyAD70DzgaLAA/TAy1zBqkFdQq5BRUYQO79+v4uONxAZxogrjKEDVjAOv+Q/d4M0PCBuJ8JvFUCZD7oEDnQFWrgDhboID7gvnDQXmzQChGk5MzAgJEnGGEhD97/Dhr0AHfG/kPuYAdLQleoYBxEBhT/9/8PA2jAB9TJAW0dAXW6756ZzgAacAIPlAANYAauXpHTiWAAhQco7EArRJRNsxhA8QsKJ9AMKOqqBSzFGrK7kdiMSCsZYGEDuuIOlJYVDZMZQDPJb4F76EF75B9dWQZefg1yI2wLCagTBjID1CEHLZ0Hr6oBrpABbf0A5VnQ0nbQCh/kcINdtwgKd9BAy9ePD8CHYoLiFZK/IGdYgDrooLQDCgdwbAK35oBWDECuxPsMXmUB6qBDDgm8Cr7yDpTOYXkEfLUncKsJyH2gaxy17OsYQOd8gM4EALnn48sLDKAl8J/f3GQADTiAziAA5QN+CX1wBx+UL0ADWqA0Dkp7isAtNOA9/X9+gAcrQR35K3srwTdEgG4AAG0tAm0HAfkLFKcg/aAwAa3+AMURSAzkftBAAXg1AdBToLwPGvABbYOArQCA5EdGBkWjZPB2in9/fzBAzob4C44t0BYa0ACMZdgqhgcXFjKABiJAgx2g8g408MQjrMoAWmUEK+1BgyCgA0tBaeTbp0fgTjUojYJWUIAORATFAWgFAmgwBnQzCyTf/Yena/QyHjnNgPSBDksF5ROQOaBzOUB+AZU5oO0+oE7959fXQKUZxkoQeJoAyoIOewSFG0gPyP+gwTwOXgkGJuC2LNAgBWj2HzQoBVodBioLQXkddEMIyH5I2L0Hb2tCDATjPmiPKvU7wyhADoHRAYDR9DAaAqMhMIhDYLTzD48cWANwNL1ihMBQ6/yT1fHH0RlgQBcnkD5whhUjtGsHpUENOJBRoOW5oMYaaBYYNAMF6uSA2KDOsZJpBnBJ90kG0JJsUGMX1MgHNb5BV2mBGpOgGSrwXlfgMnpWNl7gjNUT8H5Y0Czif+jVbKjOBZ7MDpzZBe2t/w48UwBkFmjPMKiRDuo8gTowoNk30MADqPEKmuUHNcBBZoBmZsEzTb8+QwYXQB01oL2gBjy4FEEqSkAdBlADHtTovnagngHUOAd1QkEDFaBBBFDnCTxTCZwBB7kBZC6ooQ1aJQBa5QDqKIFWG4A6AqBOM2KAAeIbRmiHFdTZ0HfrYQDNMINkQLPMoE4jqFEPvv6NAXnAgAHcGQI1mkF7cPWA2wEegVZJIO0ph3T2GBlADW/QkmvQzDto1g60FxsU9qDOF6gTCOoMgtwEOqwMbPd/2N3+sDhmYgCFK6jxD+qE3DzaBV7K/v/fL/Ahg+AOlZgu+EpH04CF4Fk7UJzBrvVjgKYRUEcPPEgC7HyB9i5zCymB9z+D9INP/f72FrxyAxR/oMGVN4+PMoAGjsCDGsDBBVCnEnybAgOsjw5MnYwwDDmk7dOrywyg5eGgmURQRwiUfkEDTuBOA3AFgqxWCAOoMwmKS9Dy8Be3t8H3ijNirT4YUYpUUCcYtA8ZMmsP7YDg6fyD7AX5GZQ+9IBx++DCAnAnBrQlBOImBgZQ5w1kCSgeQecsgNigTiioow3quILObQANqIEHzUAHY4L8D+vU48m/sE4cqMPKCD0MDrxtCMgGbVcBrUx49+w0A6hTDsqPID9Btoz8ZwCxQcvrwfvYgZ1N0CDEf+iNAb+A5xuA4gKUrkBxBEq34MEJBkR6AV/dCRzsUwOuuAFtxQHNor96sI/h8p5yBtDNHKCwB6UBUEcUdObDhxfnGWCDbaBBJJB+0OGVoPAGpU1QJxF0kwfotH/wtZfQMPgPHFwB2wo8WwJ0fgHoFg/QGQaQ5e6QMzxAS9VBekFXS4LyEWi/PUgP6NR5UB4GX+sHDBPQiiPQ7DJ4ywjQPPAqj+/vwGeKgAeQgIMIYH9C4xvkB1AHGzRAAj6xHuhf0N50UBkAGuQCrSwC2cUNXMUBCldY2QPaHgVa9QCyG+RecNjDzn4Ap2fQahtpBtA5IifXRDBABlP+MoDUgwasQOdLgA9NhO6BB3f+ecQZdJ3bwTPzoMECUBkFynegwTMJFXfwCgrQwCUoD4IHUGDnYCAlekakFRzgZAXNtyA2aJUTM3C7BeiQQ3FFJ/BqIFBZDToM8cG5uWA3gs41AB0GCsqvyFkJZi5oyxP4qlPgdo7fP0Hl7h/woZ+gFRWgQz+5+KTBaRG0DQuU/kCrm0DlG2jpP8gMkF4Ghv8MVAeMtGo3Dq/26OgAAMMoGA2B0RAYvCEwOgCAqLhH0ym2EKDazADBRgMjA3xtJplRQVLHH+QeZEyF6Mff+Qd1wpiAJ6ILApc0W4JP3ActFQY1pkE0aO8yqLH4/NZmcDiAOp7gQ+K+vACfwg9aCgxeMg2UBc0Yi0Dv3wc1ckH6QIMBoBkg0F7xH+DD5GANP1i4gjp+TAyywMO1QA1q0PJbUKcGtAoAtET4yt4q8OoDRvip9P8ZIA1IiLtBHRvwqf9fXzJAOi9oS7fBs98QtaBZKTndKAbwQXJA80CNUvDqAWhnTETehoEDeIAgeMkycBZbC3hgGGggBLTnGLT0F3TVHei8A/AgAbCTAFkuzQCf2Qftmwd19EDbGSAdIQZwpxR0tgEoDYDPCvgPu7efAaKRERI7oA4GqBPy8OJCBtDybVDnCBL1iM7Y0+vrwFee/QMPcHxgAK2yYOMSYlC3LGI4utyPgUdYDdyAfwfcjgE+JI8BeasAE/iqLtChXKAODOigOlAHGNTB+PbpCQNoaTIoHkGdVNg+cdCgB6+IJngFB8ItQO8CZ3dBp9yDVneAVhN8enmZAXSOAujGhmc3NjKAOm0gc0Gz0qB91KC0BIo/0FWSoFlm86DFDKA9wchmwtnA8ADN3oLurgcNAIBWgYBm0kFbTcCz54yQa/xAHc43Dw8xgDocoIEnkNmgZdGgWVHQ2Q2gOETuzMKyESNSfv/87jYD3prmP3InBcF+emMDw3/4qgFI5xQUi1IaAQygwQpQpwd8mjyw8wkaQAEtg5bXj2MADdKArm0EpREGaPTD3YU2EIDZiWMCz7zziqgxgAYCQPkQFEagZeSgjidsJhd05z2oowU5IJKBAbQ8G7xiAjioJQ+8ug90uB2oQwmeqeUQYAC5DRS+oAP+GFDSJjTPQAccIAc8soNP3wcNwoFmj0GzyaC99SAaNDj44cU5BsSydybwTD1obzt4nzzQo6DVEOD7/YFxAFoV9A+chxggo0D/EbPYoA47qPwAnf8B3iYC6uQygs46gOR90PkNsM4/eFAPeI4H5AC75+D4BIULKE2AZ6mBh2XCBptAgwyg8FYwiAff0AAql0AdcVBaAl+3CdySAtlKJMIAjjfgFiBQmaFsmgkeDANdGQgaZAPdMgBaaQBakQAaCAQPaAG3LqkAV3qA4h10FgEojEEHRoJWK4D8ADpAELS6AqQHVJ5AttZAtp3ABg61gUv9QbP9sIFV8A0swA42KC2AVi6BViOAwh40sAI6Y+PL25sM/9EGChnQASOs/GAEZVwGFdNs8AGRoJssQPkdNEAHSh/3zs5kAA2mgTr9oK1OoGX6kDMwGODDCZA0iyiP+ICH/IEGMMADCC6dDKABCfDAE7A8BZUzoIEG0AAKyBzQwA1oMBh05gYkXxI/AEBSXc842nZkIABGBwAYRsFoCIyGwOAMgdECHHm53WgqxQwB+nb+SY8B5OXtjHgbJEiDC9BOP7ixB15e/oSovZ34XMdIaHYRqXEIWtIO6lTIaIeCZ6Rhh5qBGvpPb6wD9WTBHWfQknfQYVygDhZoFgq8FB/YIQV1wkEHX4FmYkEzV6BGMmjpN3iWHNiAB3f+YUva0QY5QO4EdSDAHfnvb8D7X0Gzb6Al+LDTtkFL11nZeBhAs/GM0CurQKdtgzqun4B3bht6TmSA7P1HXAfGAA17cHoBskEz+CB3vHt8HNx5Bi2PBh9aBpx9BHXmQZ0IUGcI1IgHdRqeAQc9QJ0I0Kw5CF/cVQy+Og68TB7cYWEEd/5hDXjQSeGgBjoHjxh4H78B0E2gWbvnNzeDZ/RADWVw6YbsfwZIAxsUj6CGP8hsROcfMVgCsgM8Gwjs1INnwoFm6AKvJQPt4b95rBu8Hx00Cwnq8IE6CgywmUEGSEcOZAuocQ8aMAB1pEFL/0HqQfEIGtABH+AI9BOo4wRaqgvaIgBaKg05Qf47A3iwgxEyWAMejAEuvQcNeIDsAt0EAYoDUOcSNrsMm60EdUZBnU3QMmrQvfSg2w0eXVoKH8SBpF9I5wTUMQKdKwHqkIH2doOulwN1bD8Cz5yAnA3xnwG0vB5kP6jjBtqSArmKUpxBxSyHAWQ/aLABchvET8g8NlL+Q+RFaB2DnD6gGQn7HeSQeEC52hGk/j/SAAuwsw8JX2FwJ1lU3g64hWYVA2hQADQYBBo0AK0egZyyj9T5QSsfsOZZRshp+qrm+Qyg2W1Q3IHygrCsBfh2CFngIYugwTrQbDuo83tmYyL44DvQ3mtQ5w6URkCzs6AT9UFLtkEDNaA4BqVt0P5/0FkbYO/DgwUUz4wMoEELUHqE3F3/Dbx6BHzVJtCvoMExUF4HpTPIFpx/kAE4WPUNdDNogAY0KAMyGzTYJixnzQA62R5UPoA6npDZbwYG5PMWQPkddKgcqLMO6kwyQDu4kAFAZgbYKhRwOAHdAb6FAkiDZrZBfgQNsoDLn7+QcyhAaeo/+EBPAwbQoZqgMgN0eOiXd7fA9oLKE/AqoC8vGUCrCkCDd6CO/AngjD2ks87MALoeFORH0GGDkA7/L7A7QHkdNJgGujUENJAC2vt+59RkSFAC/a8B3PYEumIQtJ0JlJ5BK5xAV2TK68cwgM7dAK0o+QcefASFNzP4cErQABZoxQgovYP8DDIXdHsEaHUSyGBJ4FkdoD384HIVaAd41QMDZBAKajED6tYXRvAZCZDbOoDbNZ6fYwCdvwAaJPwNvF3g64d7DKAZekhZ/pBBUNqEAVT+gPItAyx9o5RXiPYZyJ2eubfBZyWAbv0A37gCXV0CMg+0xQa0WgPkRtCgzee3N8AHU4K2Sfz/T4XD/3BVfoyjbUh87YLRAQCGUTAaAqMhMPhCYLTgZhitvAgmS6oMABAMZ/xpEb2Tj8xnIMIHDMhzj0gdEdCME0gOdKo1aD89ZJYZ0i0gNr8yErGsGJHOII190JJlUCMdNPMD6rzB7kEHdSwgp6N/ZQDt4wQ15kCdCFBnGdThgbkJtDwX1LH8D+1Mg9wN7kz9B516jWigYos7UEMXNMMFmuEGNVRBHRlY4xM8RAJa6gxcbmoVsQ68UgA0Mw1qeIPsB+0VBs08gRq1oAMD4XphDoM1XoFh8unVVfDSdFAYg5bxg84LAHU+IJ0JFgZQGMDcB4pPyH72P+DZP9DhY6DZa9i1VZD4RqwsADfWgTOGoG0DoM7N5T0V4KsJQZ0ukFNAM4Z8YloMoKvlQGxQAxky/MMI79SAOzv/YTPKUA8wQlXBadBd7UzgGAbN4IP2D4NUgvwN6jCBOsugPcSg/bygZdaQk9IhaRm0EgF0/R8oHEAdC3DnHxiukE7cP/DqD8jy5n8MoBPsQZ0k0Azef/TTzIEdLtCVaqDZXUHgAWDgAQugGvBsJNT9oLAFhQVorzZophV0mBxoMAG0vBt8qOO/v5AcAIlgSIoFriwADZKAOp6ggQDQQAyowwUaQACZAdrqAOp0gQZxQDPEMtphDF+Ay7mvHWxkAM3OgsIdtPUDvFQfuqoDFDawvInIP0h5GynvgdXiWBOA0vn/jzl7CconoAETAXE9cMcSNDgBGhwBdZhhp+BDtoz8Y/iPrh9fWQSNd9AeeVDHCbTcHtYxBC39fwu8YpAFeLgaaIb1J3DrBeiAwmc3N4KX54M6ZKABIdC+dlDaBQ1qgbZ/gE6qB+0nB+VrUJxB4hzqJ2h+AR10CYovKXVfhi/ATiIov4BPv//5kQE0KAhaGQPK66AVNffOzGAA+fsvdFUMYuANloYZwFtEQAOHoHgDlWsge0Huhyy5/8EAD3tGSHnEAKOBEqBtPqAyB1Q2gFYFgc8yAMpr2ALzGPB0fPBJ+cB0DDp0EbLP/Rd4pcyVfTXggTHYigdQxx90yB9oRhq0YgS0jQFU7oBmqjn5ZBlAS/JBAwLga/yAy+PBh0xCvQBabQO6LhJyIwBiaw0ovYoCVw6BDlN8DtyGAjo4FRQPoDIcNIAJKsdAK2VAg5sgP4O2aoAOwgMNDjy8uAjib3AeYGIAbekBdZJh1xOCBgRBfHBZCswvIHGQ20H5AnwWAacQA5+wOgNsuwdKncKAKDdA6u3j9oBP6QcPpIFXVDCA0ylocAe0SgsUd6BBWNBgBeg6UpBbEbkEFCdMDKCVNZBzNiA3qIDKyhd3d4Cv+wQNSoHcCVoNAh50AW4rAg1UCEkZg90HLu+AZwSA8gmoXEBdDYZUs+HIC1Sp8xlGASgERgcARtPBaAiMhsAgC4ER3vmHd1RGEya+EBiozj/xs/r4Xc+A3sFA7oAAO7qgZeBqlgXgq7xAjXDw8llo1oB17LF2ohkQskSlIHhDC9LgBg88AO0HdeRBs+KgTh2o4wdahgvacwrq3IMa2KBZPdAyfdjsHWhGFnRyPGjGGNKZZgB3aDWsShlgs1aInA3pZCD7A+wXoFtAS4JB7gZ1ZBlR2oOgA7ZSwAeaPb2+nuE5eFb+LwPohgHQTB+ogwtalgvqbIFm7MDLb2Gz8ygBATIV0rkGNVJB0QDpezIxgMLcwGMC+PYD2Ew3qNMJvgMfeII1KBxA/oZ3hKGdVlDHjkdYhQF0iB9oKwRoGwPokDtQ41nbvh58KJiySQb4qjzQygLQsnlQBw4UTqAZYvAyYLhnoR0fsMMgIQR2PtIAAGiGE3TGAmSZ/ncGUEce1KkDXxEGdKc28D5vkDtB/gFtoXgIPHUetmwe1ikDLeUGNfoVjVMYQLNzDCh7caGdwP+Qq8r+Iw9GQP0M7pgxMDDAlkGDr7UDdf5B5sA7thD9oK0B4DADioO2d4A6Z+Cl6UA//f75AeI92GAVUocPFPag8x7A98V/esrwE3qVI6ijA+qAgDo0oLAAdfZBS8qVzbIZQCsCQJ03yGn133FkAUinCC7JiNLFQQjD8iiOzghMIfJqAdC2FfDWCmZ2hvfApfCgziDI76CBNB3nVgbQTPzXjw8ZGHDtfUYu/2FspDwKSjOgFSUg/4MOxwOZJQK60vDNdQbQIAko/YEGxECDYKBOP/jwPeCAFCj+X93bwwA54R9yZSCo0w1yGyidgPa3gwZbQIf7QUIHkvZAK3vAq0mAZwu8BF7hBpq5ZmHnYwAtZwefmQG9Rg+kF6ROBLjiAXTQIXgLAI4BSNAAG2jLBuhAP1DnFnSCPChcYGECKmNBs92gFRyQbTqIskkBuIUCFO7yejHg7SPg6yk/P2MALZMH+Qd0XSZopQUozYAGKkH6xZRcGEDbkEBbDUCdcFCaubSnDHydIUgMNEMNCgdQGjq/LQd80wDIDtAVfLDbL0ADHKD0B7IDlKfAqyaAq19AAy0gtaD4BeVt0P59UL4HDW6BQxCctCDp6z80P4G2NoDPIBFUZgCdIQHKO6Br82B5E1SeMcBm86GDbiB/gfIMaAUSqFwGLf8HXRMKLi+B5oLKbdA1ncgpGbmOgZzLIQ4uN0FbakAH9337/ITB1H8uA+iQPtANHaDBJVCnHZRWQANEoDMRQNtU/oNvYGBkkFTzYgDlXdBtFqB0BPIz+CwTRkbwqjDQCgLQ6h5QGIHyIAsLJ3hLEGhQBLTiBTS4ABpMAYUZaBuEjGYQA2ggBHbjCwMtAIG8yzCCwegAAMMoGA2B0RAYPCHAOLIjY7SyIir+GRmolE7whjdSUwraKWGkOH7QOh4w30LNZUTqcIDuVgd1ZkGNL1ADEe4asBGMDMjL2hlJ7fSj2QtrKML8B1paDprxBc0SQw7e+88AGoQAdRpB7gHNGoNmckDq9N37GUCzzaCl+pB7zp9ATAc6EXSDwKv7+8Gnb4Ma/OCTqv//Z8AZfSjhC/ExPMxBncUf78F76UGNYVDnFXJg31EG0D3zoEYmZHbyEQPoqjOQGxlRA40BtUGMGr+gpeOgJb6g5eOgmVJQoxS0F9bEdyYD6GA08Gw19JYBsAcZIbEF6kyADtIDLVEHdbpAB96BliGDOkfgjs37Owyg5c9vHh0FL5EF6QLNhoM6wqAOzifwaduwZbDIfobEMSNKJxTUEQINVAgy6Ll2MLx/epoB0gBnYgDN6oMa56DD6EBLp0FxAmrogwZwQMutYQd5QQZamMD6QDOdoHAE78dlgEUbxA5QhwGycuMfNKn9Z4B1+hmROuugMAXNGGIumYfNjiMGE0BnAoDSAChsIcumP8LTCtgSRojdoAEcUAcSskLgD/gQQNBAAWhpNSheQYNMoE4/6FR1UIcD1HkEpUXQihDQknTQoWOgLQygtAOaXQZ1yiHXAzIw4Bp4Y0DyPwMSgHTiICstYP5Hlof7G3k2H8gGdcYZ/iOuFAQN9Nw+OYkBtLQbcsf6fxRbGNABRlkDSxsMDE+BV8WBzi0ApUvQUn+QVlBnDBSmoE4baBAA1IkDdQpBs+KgwzLBKwaAHVbQdg/wUmzgqfgg/4A6lOBD7oB7zN8Br7VDX+4NCkNQZw0UjqDZb9BqEtAViCA7Ne2qGEAdZFB8gM4cAIU7KN39BV/h+R9eRv1HG1wCmQlO98DwAc9iI107Bx5gBa4AAV2LBxrUklLzZgDPRgMtlNWNZPj3+zsD+JDLHx+AS9Qvgrc+gFYrgc4WAV9bCfQHyK3g8zmA5x2Arl0EbW0B5UlQeaFknMoAWnkgqeLJABpAA6VF0KoFyEDUf+BBfdMZQNebKgEHxkBhCDrHAbRSAhQuoDQmKGkA3jsPyvegsNcCDra9fXQE7A7QoAj4zA3goAgofEB5CJJmPzJIqLgxgMoGUDoEbZUBpVvQQAl4GwfwDAZIzQDJWQwQzaDRNQbYtZ8qwGsXQfaBrlkErYLRtKlkAO3XB4UfqCwGXWsI2VYCCnZQPkKUJZAylBF8vSfouk5QugENIIAGId4CyyXQShHQoBXI7eBDV9/eAh/eB7pyENY5B5kBKt+0gAOaoIEn0AArZCUL6CwTRnB5AkrjkC0N38BnEoAGNcADYsBVGdIafgygQQ3wygxg2jP2ncVwdnM6A2hbBgOJBwGSXP9TtV3FyDBcwOgAAMMoGA2B0RAYHCHAOHIjghHRoRtNjfhDYCA6/wwMsI47Mk1sTBHQg9b5B83AgDpzoJkr0BJm0JV3oD3QoGWUoA4UyjJmcLphYCB5uwhGekPkPVD4/od2XF4/OMAAXnYK7NCAD5QDLucE+ZqNU5gB1CkAzfiAOrOg2UPQslVQ45+FjQu8hBwUZqCZetDyclAHBHIGwH8GyEF9r7EPAuDs9EDcB5rNBC1FBjV6ufnlgMu9+8HLUUFhAlpOC5oBgw1QENOohDWMQdELmjUEdf5By8tBZwKAZgVf3tsFXr0goxXEAFrKDmpoQ8yFhhdwpQRo9hW0NBnUmAYdgAc6LBHU+Qd1rEGdClBHFXKLwhfgFWGpDKCGM8gc0KoB0F3coM4XAzQKEXGLKA8gHXZY/EAb9kAuaLAD1JkENdxBKy9A92mDVgKADuMD+QVyQ8EL8OFusMMZIckYkh5BQQ2K54+vr0CGGGBpAugn0LYO0CAL6L51buAsJcj9oDCHdA4ZGRDmgF3OwIgcb3BzGBlQOszIW0BAbOgMJ0IvzF1M4BlJ2JYT0On/oI4IO7c4JMMB06a0ZiAD+Fo24InusA4QaPYW1LkCLUkHL2UHLpUGLRWHHQ4I3hLCAO2UIrsRLRujlC9QdaC0AFqqLAfsgIKu2AN304DbH+B71v+jDnbAVkzAZ3GB9oJXhICuVfz8lIHh/38G0gAk/pEHw0AioDQEOln/w/Oz4EE20HYh8N34T06AD3N8cnU1A2i2GtQhVzBIZADfrvHpMXhAChQeoPMDQP4CH37HwgE+jwGS95HTGxN49hy0wga07QUUF5AD/hjBK1tAHUbQYBZooBC0JQA2yAcKM5CfwX79j7StgAGa9WFZCFqGwfIiaBk+qKMLmn0HdeRBA3ugATSQPOjWi+e3tjCAOs3gZfDAFSGgcwtA8aFhUw65Ug5oF6iDDOrMggZAQMvVQcv1QWaBOv7gWz2A5ReonAWlHdDAJkg9L+hmBOCBpqDBGVCn9eOLiwygVU+g+AbFM+gcBVCZ9/ntbQaw2YygTu8fBtCBh6DrQUGn54Pyy3/oWQWg8hs0UAE+QPXLc3B0g1Y1gAbbQGH858dH8MDWD1B6YGBAlIfoZfN/yGolUPiDBgxAgzygeIcM6DAz/PkJufUEtA0HfWAVJW+B8+h/BthhfYzgWxH0wecAgMtk4DWtoPoGJA+avQetQgANwPyHHrwIWuEEKm9Ag23gwV7gqgrQAAnk/JBnYA+Ays23wINHGaArgUBl33fggYqyOmHgsw5gNyyAzATdcILYKsQwCgYgBEYHAEaT3WgIjIbAIAgBxpEbC4yMoymQyBAYqM4/aMkiaF/xd2hDDuJcSIcF++AAshwezzFC51IZoYdaMTKCTwgHdajNAhcyvAJ2wEH30D8BnvoOnukFNqxADTdQ5xK03Bu0JBTUeEWftcNpI0bHH6YSkQYhyZEROqjwnwHRSQa6FTiDCJrVAu3DBTX0QQ05UIcb1LmHnTAOO4wKpA+0vBQkD+qYgjpioIYzeL89wz+kIITahTMfIDo/4CvMhJQZQPvIQbP0oM4NMxs3A6gxDLIXNBMJXsL6+xs8CFCNhXW8UP0L8hNoKbG0ZjADaLACNGsOWkIPugYL1OAGncgNmjGDdHwQYQbyI6jj/wx4Gjxo7zBouSx4xowRdOq6OfiwNPD1eMC7778BTyi/DFx2DLkLX4nhJ/CQQ0jn/z9S4x909R0LAztwTy/s8C/Q4AIssGBxAerMgDpwoM4+6Ao88BLwV1cYIJ3hTwyQ086hy/ehs2uIcGBkQO8YMKKtMvjz6xMD6CBD0NLpn8BOEaiTBz7XATizCeqYQZYog1yFiBsGFDNAyYeJAbTX29hnBviqyD+w6xkZGBgQM8KQ+IC5B0SDVk2Alv2DlieDllyDl3NDO1Wgjj9ophu0bBpsOyNkVhPkftBBZqCZb9C+ZdCZCIZekxkeXV4Gnq0F7eUGdT4IlbQYnX8GiB9BcQxacg6aYQXN7IPSiyjwgE7IFX/YOv8MDCgDUKBOHHzQgwEpbSK7CJfrkMMYGubQcgM82AUMV3CIAgcXwJ1Y4HJ4UL4EzbCD0i9oVh7UqQMNDIDyKGivO2igDpR+NKzLGTRtKxnunpnGALqZAqQPKWfA8z5odczjKysY/v+HrVT5zwAaJAKVQ6BtNKAbCEByoA4/aGYcdOAhaAsRaOASfH8/AwOypxkgg1pMEPPht3pA0gwobYDu7weVgaB8BxqkAJUvID3gA0dBs8nApeOgzjD4zn7gagPQwM/Le3vBYQ6acQddtQk6RBB0Qj5ku8hr8PYIUPiArzcFehI0OHR8ZRADaEsDKE5Bs9ugjjD4RHwJAwZQOn98ZSW4PAbd/AHKc6BtWKBVBmDPgDPUPwbQYZagVReggwUhZyiA/MHMABrEAB14BzpJH7x6AHgA4b2zMxggA1t/GUDnOIBWJYBjFBroqHmdiUHZJBO8RP4/fCUJAwPILtC2D9D5HmaBixjun5vFgDnYiSVdQdMMLCK07GrBekHbm0DuBp3MD74OErSlgwGWfhnB2Rqcv4BnPoDKWNBAG/gGAmA6+/bhPnhfP8RMyIAQI9RDsK0QoE7+xxcXwG60jdnBcPNYD3RlA/SwSAYCK2EYsANGUlcBjrazMAJydACAYRSMhsBoCAxsCDCOzAgAVUijlRJJcU9ypY/LdAKdTUgbBt4qYwB1ukGdC9BsDagBBO5gweIPmSbWN1A9kIYwI/heapBW0B5J0Gwa6CA7yPVJHAygRjRoD72mbRUD6N5tUMMSdO82qPENPqketJQXfQklNreR4mekzhwoFEANcgP3PvAp2P+AqwBADVtwGDEwMsAGAUANbshKBOAgBjMbA/i0biZWBlAjEaQfdP0VqIEJ2lqAfNo3cUHGCF7irgo84f3RleUMsKWzoCW3oL2qoNUHoLADzUaB7P0NnBkGLQkGn2oOnUHDviIA0hkGDRqAOg2gziVo3/CVfdXgq7BAhwqCGrvga7CQGuGgjipyJ5qLXx7RHAWGM3jpP/BqOdDAByhMQIdrgTprvKKa4I417IR8sJtAbWygHn5RbQbQjBnoEDfQ3l5QpwR0QJuiUTL4VHtI2gcrBt+OAFpuC0ojoFUEoD324Bl6aGCC4owRfEMCRAA0QAByA3jwBjiIA5mBZmRA3kYCizuw34C+Ae2VBt9kwC3GANriAFr6LSRjAV6Ojby/GT5ABItIRkYGWLoGueklcN85aHYWNNMKWi3y/ukpBtjVdMhxDzMHvP3k9xcG0Mw2+KT7d3fBaQy09Bt0QwHsKjmQX0A3P4A6nKDZZl3g/vobh9sZQANioA7v/QvzwTO1oIEUUFqAbAGAHtqGJdGhDILA8wojOB2D4g203QIUP3LAaypBK1/A+5yBnSIGePpCNhR52wNEHOtWAQx3gGOOAXVQkQExCMcAiTNG6IAhKMzAV88BO22gMAWf6P8P1Ln8zQDq2IHP7wCegg/SBtoWAppJB4UP+NBOYHoGlSegZeTgDiZ0kAJkNyMjA8og0bNbmxgYkPMRUB6UJ0CdYlDeuXm0kwF0rgVomwsoTYMGBEADX6ADByEHSyJdeckIub4RnD4ZQQfKGYA72ZDVNYwMoFly0B5zdugsPXyPO1AfSA2onAHJgbYeQNL8fwbQwBBoGwCos3n9UDN4xQIovkHnC0AGau4CPcTEAMrjoO1CIBo0AAA6lwO0QgC8PQAYbqA0Bz7TBBg2oE7xz+9vIeUYMwsD6MpAUBkGcjdoQAx0/smjy6BbLD6BB5lAh1rCBlAg8fKLATRwLCCmC75KELTdAJSvwTcaMMAOgIQM/oHMBOVjkL//ANM+eOUMMGxUgGdagGb7QeUdbBAAlO5+gVc+/GC4f3YWA8ifiIEZBkieRkq/DIzQNAMv05nAqQ602gm0MgJ0ECmozIOtEgK5Xde5HXwjgIxWKIOxz3QGyMqGfwwiMpYMIDeBBpNAg4SgMwNAh6+C4hhUvjDA8z4T+EwA0JkQoLQGOiQSFHe3jvcyMDCQuvqFgXoAZx3IMCLB6AAAwygYDYHREBi4EGAcmYE/WhGRHO+07/yDnIRIj7AOCahxJiJrBV66DmpwgjqxoAYPpKkO6ewwQmexQPdbwxpwsIYXVpqBgQHmH9BME/jUfeDeVvCycEkjBtDMLugaJtDME8hs0IwdaH8zaImmbfQ2BtCp0aCl8KDZPXBnEtyoIicvoephREmXsM4GEwNoWftr4F5+0K0A4NOngbONoNl3XuD9z6DGJ3iGDhgGoI4WyL/mQUsYQJ090P5ZUEMatLcetIwc+TovBmxuxrY0GuomkD3gMxGAs8GgZa+gTj5o7znodH3w7CXITUD3aDs2gWelQHekg5Y8Q/agfiSQ3v6DrwMEN6x/QTqfoCvTQFfagTqu4L274A4SriurGMF9Nml1PwbYoIRF8HKGpzfWgzs34FPWgR0x8PVYsHvjwcHLxCCvGwU+xA80WAGagRRXcmUANZhh932Dtn6AOr/g9jtS5xq0/x3cEQd26L9/AS3BRaxuAMULaEWDInC/M/g+ceCACOjWAdAsOHiFBnglCRMDI1I6BMUb+G52oCgTCxuDHPCueNBsIyjtCcuYA0/4NmQAbQkBndwNmmUFbXcAH2SIHLJI7mOAdlZBKz9AB4yBDm0ELYnWAcYP6NBBRpTsBnEJA1LHBZTPQDPuiM4NqNMEu9rxPwM3cNAF1CEHDZiB9sODbkEAdQ5B/gYNBIEweJUKsGMHW5YN7wMxMGJAsDfQ0z8DpCMMuroQFHcgXaDl56BOEOjwSVAHCDQbC+m84k5i+Dr/qINJmGbAyiHw2Q7Ajj4TeOm2LniwCNSBA52JoAy8d56Vgw98NSVoZh50WCdo8AbkZtAsOUgvaI8+aAUAaFUFeIsCOAJAaQaGGRgY4MUBND7gAQaRQC+DQekFlL9BJ+mD0xlwXz4oXEDL5IWlzRggqzf+wQ2G+JWJQc2ikAF0FSdoNh7UAQXlX1C6BNkCGvgClSega/FA+RHUUQdvh4IPdP5nQKy8gAzogFargGbmQdteLEJWgGffQYf7wbaCnN2cBrw2MpIBNIgLGtTbM8uY4e7paQz6Hv0Ma5vZGECHZBp6TmbYOkEOPOAKOvsDlLavH2wCz7iDzAZ1/kHpCDTgCBrgAw0Kq1kWMUC2X4CuDvyDCD4w6z/4wEXQgAuoXAfNsIO2FID8A7/2EJjeQNf5gbYdgFb9iCjYMYC2BoDiFHQtI2jgDZSGQXEJKvtBZSZkKwsD+BpI0KoFBgbYOROIOgWctRghKyxA+R40+AMSA+VZ0CARZPAFuHoGuFIKdD4IKMzBh4SCy19GcD4H+RnkV9jqM1C6AsUneFAHnC+YwVsYQOaCBhDEFZ3BK7FAeRhkJvimB+CVihy8EgygVUQM8C1ADMSD0XYSAy3B6AAAwygYDYHREBiYEGAceQEPHY0fTXGkhcDAdP5BbmRkEAAe+gTa0w26ug00ywO+/g3U0WGENJJBB0SBZt/ASyOBJ7Az/Cc8w4E82wjZLy4OnkXiE9NmMPScBN4vCbqHGtTBBV0jBzqkCjTjBGoAPriwkAE0Cw+ahQEd6AS6bgp0hzMkREnJU5hqsQ0AMANn80F+BM0QgfaDgzoVkFOi2cENbSFg5/AtcM8xyG2gw9tAnbIXwNPCQftBQW4CNRxBDXHQdXHgmf//0FkvUBcM2Qn4wg2pIQjTAtoCYOQ1BXylFahhDmpAg5Ye3zjcBr6/WtEwkQEUVj+xxQlaRw/R72SEHNIG3OoBatiDBhBAqwJAHQtQRwrWeUa+vg0+Aw40BLQEmktAATxYBBo0ATWsQZ1e0J3goE4FfPaLEdKxBF3bpmqRDz4XADS4BBpUAa3wAHV6IbN+fxhAM5s8wmoMHFyi4JlEWCcZNAMKuSbsBQN4Cfh/yHYNkHtA4Q2KJ1ADnotPmgF0GBfojADQ4V2g6+JAHRKQPaAZUvjAArDDICQN3LYgawk+LAx0cNrrB/sZQDPMoDQIXAYD3mcOCk/QNg4BCT0G0AoUcLqDlmugjgXotHXQtgTQYAgov4C2C4DSO6jTBFqlAZp9BXVcQHEGmoEFdRxhboDkOEZwRxR8QwPabCFyuP8GblMADYCAtuZ8fn2dQdeljQG0/x80Ow7qgIDsA6VN8MGVyGkLvQyG8cErJiB5GtYTRgwCMoK3M4D8BxoYAh2i9vbJcQbQfvgfKNuCyC/ZYQMB6DRkRp6JAXLrgxQDKF5B6RFyVggrg6JhEvAwuFngzhgozYAGq0D5DDyTDtzXD+pIgwaWQKuI4KsgGCGz8KC8CRoQAHcI/+O5jx1LRwwUUrBT8UHL2Y28p4EHvEBnAYA6uJBbLv4jFUuMDLABANC++qv7axlAeQq8kgK8jQEyUAC6xQGUPkGDhaArFEHL/kH5DrQqCtb5hZgDWWYPGlwDXbcHSlegQ0gfXlrCAOrkg9SCzmwApTXQ2QGgNAg6+R4UfrAtJNcPtTD4l71lAM10g/ITaCXBqfWxDKDBNZAdoPxyaXcpA2gb1n/YdZLAcAKlaZB90hr+DM+AZxKA0jLIfEFJQ1DGBudZ0KoXUPoA1Q3SGoEMoPITNGALu+UEPATFBOmkq5jnMYDObwBdfwo68wU0yAQKclA4gla8QMod0JYe6GANcFALsh0NJgbJM+AZeFDcMrOCw9278CFwoGMqA2jQAVSmgNIQKL2CBqTAdRBQG2hrE8h82AoDcHYADjKBVm2BBoxAq0ZA+sDblf7DtuyAtioxMYDOYQGVeaBBH1C6A8UrE3B1CmhAAHzOCacgA+i6RvCAH8hdLOwMDEjbSLDnFuLrMLLaBYzUaHcOj7br6ADAaEt8NARGQ2CAQoBxZIU8I+NoSiMjBOjd+Qd3QhA9QgbQ7IuR91QG0DJRUAMb1CgFzcaAT3sGzr6AZhpBnRAQBp0eDWkMos7GIHsbxT+MkA4HaNYY1AjXcWpmuLizCNwwBjUyQQ1b0EwnqBEG6uSBrt8Cz8ID7/kGyYMaiKDOFgPJ+ygx0yIjRvoE91IZPPNuM4A6lDxCqgygBi/oui3QUlnQKd2gGaEXwDuvYbO0oFl+UAMPtHJBFHg1mZiSEwPoIDLQSdyghqeWQwO4Ewsa9AAvo/38DBo0RCwLZYR1ziBh+xe4VBZkP6yDD2rEQmbwv4LteAm98gw2+4oZ7rBYgXRMwPEO7ImCOvygQQyQPlCnGbRUFhTO+m69wA7mZgbEafKIWAU3mkGH5wE76qDOA6jzCVp+DZopBx0eBtqv+x868w8LZ9CsLCgMQZ0C0CoF8EnrIurg2U3QNgBQeIE6euD7xoHxyw08+wC07P/98/MMkE4hNA7/I2b+4WkXGpcgM0DL6EFhA5oVBq0AAHUo2LmEGCDpBnH7AKgzBupAgFafgNIT6HA40KAEaLBJzbIYOEB1iwFyvd4b8Mwm5FDK/5C+O3Q+HTRIAPKnGHB/PGhPPujwOZAfQPueQUuxQekExAavXgAeDvb2yTEG5PzCiDbjjJwXMe7fBx00BuwIga5EA8XXs5ubwVt1IOcjfAQeEDmBATQAAungIuIaHmuQSGNggPoA5CZlk3QG0GFr4A4mE2SpNKRTxcwA2gIBGoQDuR+0tQPUQQWtAADN1iKfwUFK94WBIIDkQVDZYAgsg0Dlj4nfHPCJ86AbHkB57AFwqwMoTYI6ypCtJdA4BYYPqDMJmh0HDVaAz6aADRIB/QY6OwO07QSkFzy49OMdA0bYwMMIl0P/w2e9QQd+guIX4n9Exx8RpwwMsPMv+IDpXBXY6QWVK6Al+cLAgSfI1g5grgOulJFU92UAHcIH6mSDtq9ABhP+ggemQOaD0qqiUQp4th60KgXUgQcNZkkBO+SggVFQeIHCB5Q2YAfNga7eA81+H1nqheKZm0e7GLTsasBioNUtoEFM0OAKKA+D8g9o2wtolh00sAVK/6DVCy/u7AQP8oHOaAHdOAJKQ6DBQtBKBtCBnKC0BOp0gwamfgMP6QOd+P8ZeNuHuLI7A+xaVcRyeeCM+/19DKDl8SA7QNsoQCfmg/wE2vIC2kYgqx0G3vYDO0gVXKbBO+OwFAcpH0FuVwGuCAGtUACZCfIPaCAEVK6BVpuBrt0DuQ3WEYeVR8iDXaDwY+MQZIAc6vgQfP0maBAEdBAgaGUFqFwAxSsTK+jgyE8Mz25sZIAclghMD0xM4DIStILAEHil6s2j3Qygw1BBAwMgM0HlwBfgzSgMSFuqMFPXaFuJgQ5gdACAYRSMhsBoCNA/BEZQAU+wETWa/nCFAH06/yDbEekRtSMM6RyCrkkCN/aB10qBDrf6+/cHeDZLVN6eAdRJB60KAHWIQMtzUfdiM+JeagztpIEaW6DlnqB7pkGzUKArr0ArAUAn2oMGGjTtqhleAhucoPu1QXaDZpXA92//hx6ihNEQhPkHWx6DNBLRwxuz8w81A+jGO8Cry0AzvqBOpJSaL7gRD5pNBJ0eD1lmDFmWDfIp6BA+UMOPG3joHWhP66NLS8GNR22HRuBM2WYGUGcW1EiGLGn9Al5BABpQAXUM/qPN9mLEPSOioQtigjob4D26YM9AZsJADXbQzBOoswZrkIKlkQY3MDuZiAEAkFrwrDiIAQxX0L3p4KvFgDOUkA7OH7SgY4QaD6FBDXSQftgMPGjWD+RX2KF8MM2gOAd11kBmg5feAiVA2zpAS7lBs+qg+7NBgwKgGU3Q6grwQVovL4Nn3MExCBsMYYSkLwbkwRHQ0l/gDB5oBQnoCjXQABJ4lh0YvqfWxYD3R4NniRkYGWAzl4xQc0Az9OpWxeABH1CDHXwoGHDpNWhbC+RWiq8MoJUuoD33oPMH4EvJQfqBWxE4eMTAV7SBDuEDzcKC9IAGHUB7wkF8QQkDeKcc1AmBHSTJgJxUGZE7NAwo4Ysc+IhO0D+oGuDScqDbQUuRX9zdBV5JA/I3bMsOQi8sD4DiHTIDC+osgTo2oGXyoBUSoFUboMEDkL/BqpmYwLdNgDrgIH+D8gJoiTNoMAzSkWEEdiKrwWdkQGaKkZbVM+ADjHgkGRmQ91SD7AYdRHh4iTsDKExB4QkaDILYh1gGDhko+QeehQalR1CeAK2WAa1AAW1XAFkIye//GUDlCOj+fmO/2Qygpd2gVSGg7Q5YHYVthQ6sDANr+M+AGL+BhjEsfUIsBZ/9ALo6ENTRBt9eADxpH7RdAJRPQKudYOcFfHp1GWzit09PwFddgs8dAW6RYoSawyOgCE5HoBUfIP9/enMNPFALindIecrGAEr7oE4vaIb74q5iBtCMNgePJAOoMw0aiAQNIKiYZjPou/eCO+WgrU2gwSLQABhoUBG04gA0MAvKg6B4BuUZfuB+flDnFTQbDlrRBBpwhDiJCXz2hLp1GfhUftDgHii+QHUBeIXC11cMoG0qoPQIHiRhhJZCQBo0QAYacAN1/kFxChqQAQ04fnh5gUFOLwZcz4CuUgXfroBcRjKi1lngPMwISTOgbTugQQBQnIPKb9AAC6hcAZ1jAVplBBoUAG0LAK2igbmfAZqHYasIQB1+2FkXoLIAVK6CBiNA2yhAA5SgQTdQeQFyhYicLfhmCVBaApXvIP/I68cxXNlbBe78g3wLGrAWBp4hwAy8JQY0UAw+7PPLM3hSw14HMTAwMOLLI7gH2hnwAQJmMowQMDoAwDAKRkNgNAToGwKMIyfARysasuOaap1/BkKNCNT0yIjWAQHN/oMaNaBGmU3kJgbIve0MDKBOO2i/MWgmENTQBl2RBJo1hcyGM0InFiENMgZGNBoeKozgWUsdx2bw8lnQkkthGTMG0DJR0BJs0DJ60CwO+I7zN9cZQEuaQfZBOj/Ie6IhfoA3ApHMh81wMjBg5jtM9TCNULVIDXjQDDVoLzfo0CfQYIep/zyG9y/OgRve//9DTpyHLIf+xwCa6QGH2YcH4Ku0QAf/gWYhQWEoLGsB3u4gCzxMDdRRvH9uLsN/HMuPUdIAWrygceG++w+eFb7IgFgVgfALOClgzDIjDwAwQjtdDODgArkLNHP6Hz5bhZjxRO10M0I0ACnQnl5QQx/UOAZ1llnYeYB3gHuClyVDQpcRQf37C3anrE4EeNUHaDktqNMAOoAPpBe0SgK03BxkFmz5NrxBjBQ3MLeA0y5wAAC0GoVbQA4czqAZbdAABKjTCuoEgTo6oBlU0AF6oHiEHd4ICmvQuRLPgSs6QGc2gDrOoO0HoNlPeb1YBtDSbNDsIeikcgngTCZsCwKi48EEPiQM1JEB3ysOPK0d1GkAdexAdoJn47++Bq/OgOwbF2YAnfYP6khD9tD/R2vsI9I0JAsjx9N/+KF0sCv3QFdngtx5dX8deH88aKYV1FmDpS1IFmRkgLkXvJxfzQd8LRqoQwPq9ENOsWcCd+LAnSPwqg2IHtBp8aABOdBMu5C0CXgGGNQRVAYe1AY65Rw0gw1aUg/qnMMH6BiIAdC0w4Cc9yDpELyiBbhPG2Qm6BwGUCcUNBAIKg9AZ0bA0qe8QTwDqNMHGnABnzfxH1I2gAYmQfkQcsr9A0jKZwQt/2cG31ABGmQCn6EBXFH0GHi4Jmj2GJRvIC5CKi+I2J4DzquMUJ2MsPzAyIAuDlqaD96K8vg4A2h7EehwPFA4wpfYg3ISI2hwChHH8PgHDmyBzLt/fi4DaIALlElBKzJAg2igLSOgMAKJge6WB50/AiorQenOyHs6A+yGDlA+Au2tB+Vr0FkAoE42aJAAlAZB4QGZZf/LADo3QEzJmQFURoFWfoDKY07gfnbQyiLYqpUn19ZAtguAc/F/8N550MGdoJULIH1gfwHT0K/v7xkYkMoQBoiHoBHOCNYN2jIE3toB5IIG2CDnqjAygM62AHXGQYMS/7HOmsPCnJkBvC0EGEagwTXQ6ihQvgNtiwINHoBWxnz79Ag8Ow8acAHfygFcbQHKD6CVAbBrRSEDkozgLQtgN0DdqgRccSGm4MgA8jP4UFR4XDOBzyMApUnQQAPIz4zQKzIl1X0YQGUhyF2gARXQiihQGgbdiAIePGPAsnoJJR8wjAIahsDoAMBo8hoNgdEQoGMIMI6M0Ia0NkdTFpkhMFCdf0hbB5ZGIY1wUIMPtKcY1EAENfJB+0hBDTxQoxx8dRLwpGjQzDaoQwTxLmJZNXh+AnoYE6gB9eHFRWiIIDWUgWkFsj/3D/j6Nsgp0QzgvdegzhNoRhk0YwZig5f8A0+XB80Uf3l7kwE2e4QezIhODvb8hrvjz4DkPgZoZxgySAFaSg5a5nr9UCt4KwDoPm7QrNL//3/h1oPMVTJKZQCdGg7qTIHucH/39DR8bzaoUQxyM2jvNmjp7runJyGdf/QOBiPC3YxYOuyIeIKqg6oH85C8zIgxSoDcIQGbwoBTDcQScEcT3Q3InRoUtwDtA3U0QIf4gTpSkGXjz6FXifExIPaLQxwJslsGePUgaJ866Do20F5Z0A0PoAY7eNDk6QlQQmCANfwZGSF7t0FBAjphG3IIIDMDIj4haRa0LQU0WwlqjLMBl/uDtpCAOligq79AAwxXD9QzgGZHIR3IX5AwAJoNGtwB7eEGdRzBs5fgVSb/GN4C3QE6EwHUiQGlA9DhhqDl/pCDySDhCFrmDFrtAFqhAurkgbYBgLY/gNIHqEMG2ocOWS4NObUddIgjaIYXtN8b1KFAjnHkwSrk+AF1JEAdGeSVH7CBHtCMJug6RtCSfFAH6tvHBwzg5fkMaGmaAeJeUQV78Aw4aOUNKD9LqHqAz3/4++cn0Mi/4CsVQQcxgmZSQds0QNdCgjr/oMEWUNoH7bEHLSkHHxAJHMgBdXpYgLOboEET8LYUiDVQ21DTKQNWACkTGKDpDpTG2IAn4csCT2IHXRkJGlQADeSAOm6gfeUgN4NmqEGzsqBwBg0SgQblQAMBoHiAWgxJGwyQdA86HwHkTliYgmbQ5fXjwYdmgq7d+w8eOPiHmMnHGDRE3qqDktHQOvpM4LIDtHwf1LGFGQgapAGdSQFKY6Ar+UDpE3R+CWg2GDzTDizTEEHzHxoUkDTNL6oFtgO0GgC0p14TuGwfVP6ABiZBgz6gPfSg1QugfAE68wI0EAIqM0H5CdQZBnVsQVd8gjq/oIGSA/PtGOxidzOAyimQXvBhhMCBENDgAEifTfRWBtAKIFBcgsIYFKbgw/tA5R0wr4BmsUHuANULoEExkPmgmX/wNp1nZxlAA2iQ7UmIqxNh4Y5R5vyHrBgBxSn4BpH3dxlA++i5BeQZQDeMgG58Ad/9/+wMON/CQ54RNDjFxADKe6D4l9EMBK9IA+Vd0IAWiAZtXQP5CTTIBV7xwS/DADpjALyMn5ERvCoDtM0BFC+gGX/Q1gPQtY/Pb29hYISuJgKlHlDdB3IDKLyEpEzBAx8gP4IGVEB1ISieQXUgKA2BDskE+V1AXJdB1TyfATTIBPIz6PBGUBnz7OYGyIDIf+iqEaRyGqnoRyQFrIJI0lgGtxkIAQJmMowAMDoAwDAKRkNgNAToEwKMIyOgRysWiuKZkYGK6YRgXGDaBWmcwTpokH3AoEY3qCEGun4KdJezsS/w+iXgvc6gTgFoZhC0JxQ0wyEHnMkFzUiBDj9jBLdbmRhAyx5BAQJZ8vwY3KgCz7LBeqsgheAZ9L8MoCvGBIGNq89vbzCABhpAnQtQo1JIypjh46urDCB9IHeAOlKgzh9y5xvSyMbuH+QBAUa8YQLSDzUDTR2oswE7wOrj66sMoD3l4M4XWucdvDf8P6QDxcLGywDqJIFnm4AnmIM6haBOFHh2Gbi0HLFcGpZkUDsVIFHUzjcsXmDqUN2K6JhDdSI1LGEz5xA1TJDGLcrBbwzwAQ+waxgRYcGIHFcMDBizmhDXM0L1Q/0CDBfQLQKgWdyv4Puyn0KNRbgd1OkHrYwAbZG4e3oqJH6BhwiCrxQDHjoG7viDjWUCrxAAGQAaDAJ1pkGmgGZPQbOSoMY8eOaOEdLRA3VWIIMIn8FXn8FOsQcdzgiaGQXtUQbNaIL3hTPAwooJuAplAwN4KTYDZEsFLFbgJ3gDO4igTgLDf8h+bHg4Ae0FDViAZvxAAzygU79BcS6t7s8AGtwCDRaA+KCbGUBnA4Du5Yechn4fcrAhtAOEnDZRBjUYIGELyl+g9AO6FQHUyfsDvQMf7D4GxIwxeAUNcO81A8aVY9A4BboXNOsLWokA6tRB9on/A18bCBq8gAwcMII7xqDT30H+BK34AS3rBu0t9y54yAC6chA0uwrKo6COIGglAyguwZ3v/0hbANDzG6EyCSoPiknQYAdo6ThoUAHU0YWsyGBkAM2ggjqFoANAQZ06iPtYwYMW4BUfoKv/gH4H3aEP6tiCBjlA+7VBNOhAN9BKI9D5DKCBItCyd1ntUPDsMfjwOQYG6IASMzh6QWeOgNIjZlhC0g0sDcDyHqjTCDovBNTJBq0YAq0cAYc6I6QshW2JAYU/qLMMMxu0pB6UjsWVXSDnU/yDbi0C6gPdKgK6/lPPtYsBNCALGtACXysKHHwFpQfQ4Xsgf4LyC2hADTSICjaXEXStoCX4Zg5QBxk0UAKyA7T1BrzqBjhTDerAg66qA11jB7rqD+QfUGd2/zwbBtANFqABWPhSf/C5EJCBCdBgDCjcwOqBZ5mArkYFDaKAtkuB7AedFwA+vA+oALQ1DDTIABqUAF0FCAobUNoDpXFeETUG2DkmoAESkJmgPA7aXgaabQfFE2gbEChuQJ14cDwwQkpFWJiDDhIFDc6B4hJi53/wmQHqwLM7IO55DA5TUB0FMgPkPpDdoNttQDcQgMppUJoHDRCBVvk8B56n4ZxyggGUV0GDYKA4BR06CAtTUL5+8/gIA+xcCfA5G8CwAQ2qgcp00OAuKKxfPzjI8OjqCgbQbQngwwz/fAcPBv9DKdugfgHqBw1swdzPSCifMIwCSkNgdABgNA2NhsBoCNAhBBhHRiiPVlpkxzMjdJaKagmFYFxgT5PwAQBGyP38oFlbUAMINPsBWpatYVMBXLr8iAG8bBmoBnTdHaiDAzpoCdT4Bs2IwO9EBu6LBjVKFQ2TwXskQY0sUKMSdDc+uEMK7bAxQBt04Cu6gAMLoDAAzdT9As9I8YCvBfzy7hYD6J5o0PJt0NJw0KwWbLkuA6SFzQAzk4ER0cmErEJgBm81QAyuwDq36DRS6COFH6z/C5H9D54hBbNhHR2odQh1kKXyoNknUGMbfEgasPMIGjgA72UFskFXzSE6oMixDjMMQuPu1INDiQGlYw8WQvY7AwNyfEKkgZ1pJlbwPmrIrPVLBlj4we1CCj9G5LCExRckgsCDCPCBF0ZM94Iaw+Al9v9hs6pQNYyQcAd1hEHhAxokAS0TBnU+Icu+v0JWHjAygO0ANYxBqz5AS81B+3dB7gbNuoEGFkDpE9JpRwxMgNLp/XOzGSCzom8YIDO70A4yIwMDypYGRlgYQcOTATUuQLObILtAHUHw9pf/iMEBiC8YoeHAwAA5OO0FA2jZOcgv756dYoB1WEADZaC9xD+A+35BM/mgASzw1gbgYALy+Q/YOv4M0HAHdexBqw5Ae43NgxaDDx4Dz8rDnQzpnP1H7oDD0gQjIzx/MEIHfkA0aCUE6JBKUBoFpUfQ/eawk/Mh11b+A+cdBYME8In7oE7Q3TMzwB1mUCcHtO0AFB+gcgA2EAPqhIL2c8OdxYg2rAlzC0wBktvgQsBECVrpAD5sFHqAJIitbl0OXmoOWs4N6riCBlJAA0KQ8zXeM8DuzWeAxivo8DtYmgLlPdBBpXI6keCtTKB4AK3KAQ0Mga+HA5ZXoEEH0NJv0HJ6BeBNGqCVGqCBLJi7QGGL2jmDxD/ILFheA3VgQWUUqFMOOlkfdGgi2D1AQsEgkQG0OuXrh4fgg/5ktELAK2RAS/hBnepbx3rA1/X9/49YiQAadAENWIEO5GRggGw3YgSnLMhACygeQQfWgcIH1IGFpIn/DKAD/rjBt3LIMoA6uqBtWqBBo/Nbsxggh6m+YQAt8wfnIWDnFNSJf/3wMPiwQdCNGCC3yAAHR0B2g+wAnaUAsoNXVBN8KCzID+BbUoC3LYAGDUCDBU+vr2UAqQNt0YDkKEYG0JkukEEERvCWApBbQPKggQBwmgFu8wDnUeAgKehcB9BMOcivoDMLQNtkWIHbiED5CZJvkcpHWDny6AgDqK4An7zPzssAuh0GNMgD2j6kbJwOHIQ7Do4+kBsgK8z+g/Ms6CBI0Co2fbdu8F3/YDuAAy+gFQ+g1TSgOAVdswka2AIZALq1BESDBhVAAw6gVQqiig7ga2JBbFAYgQbp3jw+xgA6fwC0ggI0IA6qq0Db2UCDVqDBK9BZG6C0Cx4AAR6cChqUAJWDoBUQoIFEhv9Iqz+Q8wgDbsBIzYkDhpEBRgcAGEbBaAiMhgBtQ4Bx+AcweoNuNEmRFAJUr7wZiUlz2NVAOiDMDKDTs0ENUtAJ7qBZTdAsIWjpI2jWH9SQfHV/D3iGCHRXOWg5KOgQLfDhTy/Og/0OMgfEB83CgWaDQDM4oFlaY98ZDPfPzwN3TEENZCboNXsg88FL+oFuBy2JBjXWQA0+UOPz67s74E4b6LotEB90ujVkRg7aUGJghEOQeaDGO6hBCvYLcGYFdHATaM89+F5ujFlRLFGF0vlHanBCfAb1H4hCCkOoHrAII6R5zgBdQg6xAdFwB4UrZPsCwm6UjjbYaIifGKCNXEboVgokHQQ7/xBjoN1URiZ4h13XpQM80w2e2fr8lAES58BrrYCHF0JmwhgZEB1RmI2QDiS488gIGkRgAd9lDp6RBi4bhw9gwd2LCDd4+oYEDtKgBLDTDLze7/vHR+CrHU2BJ7w/uryMgQGp8wOyD3TlHqjjAb4SDbhyAnz2BHDWEdS4Bl0Ddw7YoQEdaAY55I0RvM8XNNMIOvALPGPPAAkqY5+Z4KvrQPpADW7QwZagxjbET1D/QWfbGaBxDRqIegS8Wg10ejdkJcdfBvjKE0YGeByAlIP88Rs28w4aKGCAzoQD/QNamg1Kt5AZ53AGGc0gcEcLNIgBGySA2ckAjSsZrSAG0LJi5O0OfCKa4IMlQfeTgzpsoPwAaftD7ELv/DMyoEGg2aDD7kDnVID28oO2C4CuWQQdtAY6CFBA0gjcOQblQdBAAMj/vMAbMEDLxx8A8y1o0EIPmH7ePz/DADrrALTHHNTZB88WA/d6g8IJtOoBfF0o0EOgWW7YAW4Y5RyOegM1vUAGdkADi6D4BG0/AM0og85hAA2ogQZEQAMOkJsQNjIgBlMg+Q1UFoBmkUErHUDlEKjDCuqAgswDlU2gAQTQQAbIn6ABHNCMPWhwBjRbDJqNhd+mgbbSB563QHkBWIaBBqZAWxZAq3vAV6IC74AH3UIA6kDCzk1hAJdt7xlA5RmoAwzq/ILCG5S2xZRcgGnzAAPo/ApQRxRWBIHKSDYuEQZQOILPKAAOhiiZQDu10D3xIHFQRx+ykuM/OE2CyhjbmO0MoBls0JYDkF8u7ChgAJ1zIQo8tA7UwQdtZwFtgwANcoD8C+o4fwCea8LGwc8AuqYQNNjLAB1MAh38CsqXikZJwJtNVkHzKCMDKE+AOrOgMAatjAENREA66tByA+znd+DVJaA78UFxCz7HBWguKOxBy+TBM+ugQVFgOIJWeLFy8IFXc4CW24NWU4AG4EBmggan4HkElj+B5oNW9IDUgNIAKOxA5yN8Ap4ZA5rRB60eAMUtqI4CbW8Br7pihAzagPIOyP2gwQZQnaZpX8sAukWBAV6WM0IGioBX+4EO+FQxy2UA5YN3wGtfQWaCDv8DD0T/h6Q1UBiDBmBAYQYalAQNSoHqPJA7QNvfQKtlQCtQLENWgM9EAYWbiJwVeJUYaCAClL5hZ66AwxDbQB4DFQHjCGib4gmu0QEAhlEwGgKjIUC7EBghnf/RJER2CNBk5J5gxY678w9pVzEygBozoFksEB/U8QJ1lkB3Oz++shK8bxTUcALvDwU22vTd+8AzKODlv4yM0AllUEfsDwPswDRQwwxk5sOLi8EdNFDDFrRkEtRABh2cBprdBdkFupoLdN0euCHFAOtfMYIbnODD9higp//DQhzWCQN3JpjAWwdAB1ExQRvloKW2oP2goE4I6JBCeOcSVxihiSM6I7AwQ4QdI7RDCwszEM2I0oHEMrvMyACdq/kPZTBCtaOZzwjpuCmZZIBvHhBTdGSAnWIO6iCCGqnwqwQZGRlgAwUMDMjuAwcOeLYWcvUV5JoqcAcNuHwccqDiP/DKCtAyYgXgydWgQ6vA+8yBB9ZBzIKYATIfFKb6bj3gE9PBcfbyEgPoxH7QzB94hpBPhgHUKUUfzGCEu48BPggBa2SDGsqgxq6uUysDaBaZW1CZAXJKPyTywR0G4CAF6No+kB2glSigTvSNw60MZoGLGW4caQd3jkBXCsK2nkDc/Z8BFN+I6GRkAM30GnpNBtvDzikEHuQCnxHwHXIFHCQ6EfEAczeocwvuEANXp1gELwcfBMYIXdINSYaMDAg/Q1Z/wDui4M7BX/BhYCAzxJXdwIMQoLMhpDUCGEBXqcFjDNoxAZktKG0KPmgPNCMIyjfgLQTAuIVdPQbigzrZoBUK4E42cEYZnLYZkAB6Ggebz8ygYp7LALmt4z+ww7MbfNK8IHCbDejwRdC+dDmdcPCNC+D0zMgEPksAtELjL3TbCij9gMoD0MAEqOME2s8Oui8e1NkEnUgPGlwBDR6Ab0UAznBCVjsAzxZg+M9AqLxDkWeEpl8gDQorUPyC7GMHDhqB0iJ4+wJwOTVo5RFsdQbc94yQOAFt+QCdxSEsaw2daf8FToNawM4eqMMPGriElAmQWyH+/PjIIAg85BAUV6A4As0q/8c4fA45jwFvSBDXA1sLWkXAwS0GXu0EikNQmQO+3g8+o8sEvp1ADXhbw9tHRxlAs/7gQUmgH0CDKaBBrJd3dzNABjcZwVkElI5Ag3KgvArq5H96c4MBNGMMOvMBlA9g5Rkoz4JWQoDCBTx4Cg0X0MDEq3t7GUAdX0OvKeADHkHlNmgwFTSYBBpgAq9IAQ6ogWa6Qattzm/PBe9dB9knIGnAAHIj6IBHUIcZFBaww/0eXV4KXK2gBF4NBss7IBq0QgC8LJ6BASVfgNIcZBXCF/CNKKCZdlBn+j90STxoAAO0lQQ0kGDg3s/wEGg+KO2ABmUggyj/GZDLFkZo+gCtUnj9YD/4ekiQ38EH8QHlLENXMYDqLtB2A9AKHJCfQQOCiNiDmGcAvK4PtFXt0u4y+JksoA4+6NA+kF5QfIDSH+jsD1AahFxNysAAOzQTFE6gw11B17+CVgmAtmiAylvQYCB48AFY1oC2V4CuNQTl5XtnZ4IP3wTnL+BqLFCZANpGAzrfARSHoIFz0GoBUJ0JcjMDvjyNnN3pugqAkWGog9EBAIZRMBoCoyFAmxBgHN4Bi9SoH01B5IUAIy0qbEZi0h12NYwoeiH7KEENQtCMFWhJI2hJO6jDBJqlAs2+gZYsgjpmjy4vBwcA6PAk0IGB4kquDOC9o8COFeiQK/CeR2DnSV4/hgF04BvI21YR6xmeXl8H7riCr4eC7nkF2QG5tg3cemQANYbYOAUYQKd/o9+fDHMvaIYFNKAAajGDDp4D7eGENaRAs3GgZaSga5gge7n/MEC7FdD+LSOk84wlPWN2RkDeRG78Q0wCex4adozoM8jwMIXqY2RkwDWoAGvQwswDdSJAM0KgOAB1JBDX1oFm4JkhnThg5wTU6QDtrwV1BmAz9/C4BHbgxIAHvoHMBHXwwQenMbOCOwS20dvBnSHQKdigxixoFg80YwqaMYTMSjPAwwbsauCeYdDp8qDzGUDLdEENelDnE7SMHHTgGWgmFXQ4GejQOHiOAHfEQPufGcF2MQIbvLDwRw6rl8AVJaDZcNAhgqCT9xH6IYMGIDtB4QC7YhB01gL4ajfg+QKgNAKakUaxExwPDNCgBMUx5Mo78D3pwKXe8rrRYL+xsPOBb3KQ0QpGuamAETyzyw5ezgy+Dg+oBzRoABpU0HFqAh88BtrjCwonjHhjYETr6EK2H4A6c+DVLMAODyitvgDeOAA/54AB4k8m4HJqUOMf1IEAHe4GmoUFXRMJOoAS1JmBrFxgAW83YISuFAB1qr6BBgCg0cWADGDpGqQW6Acdp2bwAAZoJhLUOQa5AxSPkIPRfoOX+4OuqANf6QjsDEOM+gdeYg3bsgI67A80AADq8IBmbEHxAlpVAupMgsoEyFLq3+CD3EDmgzrG4FscYFkAGj7I+YsRI8wgnmGEuhvkDlmdMPBAIGimF3Jl3B8G+Kw3/NyG/7CxJQbHxMMML25tBd8GAVq2DUqnoJUPoCX6oKXuoNseIKucxMBpE9SxA91aARqUApVD4CsxodsPGDAAxDMgd4M61KBOIKiDDDqrAHITwX8GUAcXdB0oaKAONCMNSYwMDG+BS9YRp/5DyllQ3gWfF8EA6TSDBnbAK0GA4QIaeBGQ0AdvfQBdhQjq/IP2mYMO24SkAUbwPnrQygbQlZOgQU+QOGhA5umNDeDONqjjC9qKAPITaNAVpBZURsIGciHeAw2avWQApTWQ+0B6QOUOaIUCqCMOUgvOn6BtK8ByB5T/QHKwFSxSwFslQAMmoBl5UEf3N/iMCtCWG9jqlH/gvfmgLSwgfaCVNaDBWdDZDrB4BG13AK2UgZyW/4gBVBaAym/UJM2IMhAAOqATpB/U8WaArvDSc+0ErmKoB291AG1JA10HClrNAZaHr85hADmO4fmd7QzPb21mAA0ugvfgM0LEYYdZgvI3aODlP/jsjx/gOgmUD0H1IGhgDJSGQHEC2toGqm/Ag6DAvAbaZgEKL9DtAW+Btz6Arxb88pwBtKoONMDkmHQYnBdB8QLyL2hVGKh8A6UV0CG3oNU2DNhWrBFVxzMQB6hpFsPQAqMDAAyjYDQERkOA+iHAOLwDdQRXGtSK2IHr/IN8gD19MqJ1VkGNIVCnDDTzDprRATWkQDNR74CnMYMOBAQ19ECzaKCZLtCy3E+vrjBArgV8Cz5ACTTrAVILtg3YkAddfQQ6FRlk5qNLi8EHu8FOaAc1eGFhAutQgRqxoEYuqKEKmp0ELQcF0YjlkZArvUDLKEHL/EHLSUGdT1AjH9TYB81Qgjo3oAY5qCEOPrEc2IgDHWgGMgPcWcYRoRjxgxY2jAQ79tAOAjkDANBBAtDsEeg+aVDHHNQhA5+QD7wbHNT5AnUqQPuvQY1NUGMd5H/QQVUQ78AGJiCDG+BD03glgXfYc4AHDUD7VUFm/Pv/h+ExcMk9aPYLdkc3aPYMcu3eH0Q3DTTbDcQSwIEdUGcTNEsnqerJANpnC9pzDVpxAeo8gZbbPr+9lQHWaIV1UEErRF7f3weeeZdU9QbfjQ12JyN0KAAWRkgzrRAhiPtBnUptYKcbMuP7lwG0lBjUgYXdow+ZpYN2nBghgyOwcICnJWCDHJR+wHvGgaeLQ64q/MEA6gyC3AmaQYSkCVgHjIVB066a4dT6WAbQYWGgk8RB8cEM3e8MmrGFnYsBPucBnK0QnUIQFzQoBQoPUD4Bd/j+/4NuZfkFXimBMrPMCIuz/wygw+pA6RbUqT6y1JMBtI8cNAsLGuiyjd4GPKxwI3jwCtSpAd3bDplpZGH4A+1wwWaQoSNcDBCaARyfoJsWQMvmQat1RGQtwddUggZPQKftg/aCQ046vw8eFAF1JsFmQmewQbPAoNlobeAgAmggSMk4lQG0Uge0/Bq8wgbYuQHNwILiA7TN4vvn52BzIFuIoKfBo9UdWDv+sDzJCOnogTqyoEEFUDyAzhsA3bQAXqkC3A4BSv+gTuJ/tCX6oHgHDWqBZn5BZRT4YEOgeaBOG2hPOmhWGXZS/IeXF8GHMYIGW0BpGHSbwBPgXnbQoXag/eygQTOUYgIpT4PsAZV9XMC99qDzSUAdQVAeAcU3H/TkflAeAc0gg24owCz3odtEGGCz20AVwG1LoMFU0AqP3z8/gOMP1LEGhSPo5hCQOf+hA6agMwRAWxtA/gOlJ/BNG8B0xiemAz5B/xdwJQ/ooL0vb26C0zpoywxIDWhAFNS5B6UDUMcWNFgBGsgBdUxhqy3Ay9Gh9oDKYYid/8DuUbcqYQDlBdBAIGwQDDQYDL5NADjwyyukwgBefQU8LwB0KCZo8At0owSo7AcNaIDyL+hWjhe3tzNAZrkhg2SggRdQ2IH0wjrrDKiBj8RjRBR3DMhXlDKAbzDQtKkEr5YAbVOD3RgC2uYAvrEGll7AnX1I2oTd6gEqG0FxCboZALQCB7S6AuRXUHiA/A1aUQFaNQEqJ8Grg769BrvjP3TLFyg8QQOLoDwLyk+g8gU0AAUKa5A5oIEzEBu0ggJ2fgn4EEfgwCBomwNo+xooHTGgpGm0OhtHG4wm7QqG4QlGBwAYRsFoCIyGAHVDYBh3/hkhDfLRFEN+COBt8FISsIzEpjvc6jA7tdCuA9BsUEcJNAsFakCCZlFB+yy/vr8Dvi+ZATwjBDlYyT5uD1gMNIsDuqYK1HiCLREHNb5e3t0JPgQLNKsD6XAxMYAO2wI1+kAHCYJmwkAdWVCjCXRIE2hmDdRgBc2s6Dq1MIA6F5A9o5Al9KBOEWg2FzRbA7kWS4AB1Mnj4JUCd25As4WgA6JAbgB1ckAdFdBeXVBHADTTCj4rgIEBaU4SffYWGilIjX6QCEpYMUL1wPMHIowZ4R07BgbY1CS8kYZhJux0fmYGyEICJvDyW9DtAaBZYFBHHjRQYuQznQG0XBfUWAc13EEdDNCVchizRSB3gWeJmRlAqwQ4+WWBB4N1MoCWRIMGRUDmgWavQNsvQI17UDiBVlBABgOgWxQYIVdlgQZhQJ1Seb1oBtAsNfgKRGCDFSQGio93T44zgGY/QQ1e2AnfDFD7wTOjoMO55G0ZQEuSP7+9DaZBgzSQzjukXGGEr55gZICHGyMjuNMM6kSAOmygcAB1XmD78EHqHgIHkwQljRlAnU7QKeIgt4IO3UJeSQLqpIH8Bl618vYWeP89aAn2ReC+aNDMHOj2CdDVeQyQyAUvFxcALu0GzXJq2FYxgE5dB+2XBx0iB2q8C8mYg7cqgGY9QTPJDPC+CLSMBPkduGIC5C4Tv1kMoD3WoCXAYPORZiAhSQbiX1C6Be3PB90WAEqboOXgoE43uPMC1AgKL1C8g/IKZCBGmgG05xqyyuUROExB4Qm54gy1MEEeVAMdQgfKZ6D93uAVOUD3gE7bB9kJ6riBwgiUtkBxBeo8gdIVqEP07MZ6BlBYgTrgoBlcUAcSNKgCOsEeNPAH2hYCWo4PzvPA8wAgZzZ8Z8DYmkBMOQfNG5CO/H0G0JVwoP3roIGm++cg9+CD+KCBAchNAP8xTAUNWILSOMi9oJUKoAP/Lu8pB59dAopD0GAXaCYcNDgFWkUCGmQDpRnQyggQDRrMAHVIQQb/R9++AE3boHIQ1EkEpUfQzDZoYBSUP0AdPVC5BZpFB4UjaMAIlrYgDgX3PDHcDB4IBebZm0c7wVtAGKD2gjvjSGdKgOMEOKgFLr+ANCjNg8o6UHkInr3/8gK43P8jg5SGP/gaOlAcgAYJQKuzQCuyQAMCIMtBaQW06gdyld0TBtBgFijOb5+cwABKuyB7QIevcgsqMYDTP/AqV5AbQZ1byEDqXwbQAATEI//BZxiA/A26oQO0Wga0rx1yRex/BtDMNshtoIEV0IAGaNk7qNwGDSTCyq7/KDPe/3GkFNhgGVSaEbVOA8sCwxA0aAc6sBI0MAza5w8aNP396xMD8qAF5FpIJvA2KdjZGyZ+sxlAeRo8kMUrAR7oAKUzUB4GdeRBA8yg+AWlRfDVfsArGUEDYqAyRsuhngG0ggq8CuQfZLXZd+DBn7AVH6DwBQ2Ywm6UAQ1cgeIWFMagsADlO9AgA2igjuE/uv8Z0TM1wyggPwRGBwBGU89oCIyGABVDgHH4hiYj42hKoTAEaDY6T1LckDIAAFELIkGzHaAVAaDDo0AdE1CDHzTzCGpUgZcfQ90A6gyAGkCgDjxory6oUwaaWQLN3INmfkCzPaCGMqizCGrsQIYY/oNn4CAzP0/A+1RBnUfQDAxoTyuocQ1qdIEGHkAdXlA4wmZ9QfpBs2KgWTqQnaCGrJ5LJ/gMA5A4aMksyD0g9aCrm0BXRoHcLqsdxvDw4kIG5KXJOKMXo6MOC0NGcKce1FEAzeqA9kJDGuGQDh1yJxZ35x9kK7TDC2y0Sqn5MoCutlMEnkAOWlbPwScFvjoK1GgENcA/AhvgoBlNkHmgGXHQLCuocw+etQddfwZp/UKW2wMPrwINdIBmtkBLYv/8/MggpxfDcHFnAXhLhZpFAQNoNosTeDc2uNP34z0DbDsGzMugMAXpB53XAOrQgfargvZNgzrHoIY9+BRx0DVgwJO8QR19WOcf5HfQqgSQetCBkqDG8vlt2QygQ89AKwhAHVcxRWfgaeJPGX5Dl5pDBgAgS/Vh5xzABgVAjWMhYCcf1DkDd3AZIDP1oE6zuJIzePmuuIo7+C570EwkKO3ABgDAwzPAsADNyIKWToO2QoBmekFpS8koBXyiOSg9ggdYwOYyMYAHG15cAO9vBnWYQSsEQB3tK3srwXeAg/YkgwaVQFfjMUDdAo5v6LJ8UMcCJC4JXBb9EHiI4CvgHmXQzCJkqfM/pKQGTUtAfSC/gFaqgFbO3DszkwE0GwjqeIPPf3h/jwF2Dz4obEADLYpAt4MG5UCHD4I6mqCBGFAH5OW9XQywWVlGRkaU5dKgDiKoA/YDeEgdyM/g2zxAnS7gIB6oQw3quICWJIMGWUADNbDtGKDODeg2D1AHBnR4HsjvoEMKQepBy5xBAxKgMALFDSifg9IKaD807DBAlLwFGfVgICW//QS6F3S6Oij+fkCvnQMNIIIOV8M6UwwK1v+gJefvwdbwCqswgAYlrcLWAvetKzDcPzeHARQGIH9Clu3/AQ9cgsog0JYF8LJu8Ow3dIYeqYyFleOgvAHKXz+/v2Hg5pdj0HJoAG83AB2mCNo2AtrTD4p38P35DLB1GAwoLJROHtAO0AALSC9oGwYoPYBO1QettAClTUR4QTuGwDQDykegQSNQpxs06AU+pO4p6PaJf+C0Cxqog6VLUNy8erAPvHIHlD5hS95B+QXkZ1DZBZqJBqUPVfM8BtB1q6Dl+aAOP2hGGnYuCwP0wD5QWgClH9DAFOhQQ1B8gOx4dGUZA2j/PJ+YFsNz0DYX0JYXoONB6QYUZqBBF1C6AB0GC7ryFbISBkdqgGUPpC09GCqx1H8gMz+/vg7eIgLqpIPKeVB5BbvqkQGaL4SlzcGDyqBDQ0H+BeUPyBkHf8ADVyD/gFbkgAaMQKvVYAO/4HoJWN6CVsmA0iDocElQmILsAIUJqEwG+REUN6DVc6D6CxTeoDIMtN0ANKAOWiUA4oMGQEB6FfTjGUAdf1AZClmZ8Y+BIMDid5q1MxiGFxgdAGAYBaMhMBoC1AmBYdpBJtRYG00+hOtoBhyzytQIOyp1/kFOwVwBABsAALemwSfHg/ZRwlM6kAE+4RvccNUF7+8ENSQhZjExgJbggxo34IOXgI1V0EwHuGMEnNkANaAkgMvIQXt5QcvJQTMooIYheAYZ2FEFNRRBs06gzjqoMQzalwrqdIBOgAfNzoCulwP3dYGzrKAl7aCZWlDDS0YzkOH2yYnAjqAAA2iZKWjQAHLt1HcG0IwVeO8ssEEKmgkCNazBpz4zQE7OZsAWlihijIiZaehsNcidoGWgoA47aJYJvHQTHK+gwQFQR1KdAXKvOgO4Uw62A6WogIYxNJ+B/AA+yAo4S/0RuqUC1DkHdYBAgyvgzjhwJh10ejek0/8L3KkGLXcGr6hggKxmgDRwmRnAp1AD9/yD9p6Dwv7s5jTgvdTFDKAZLXBcAmcPQctZQYMAoE4beKYK1ugGugk0Mw7qkIBmBUEDBiA3gQZ8QJ1NUGcBNJMIWv6MPuMOCheQX0BLyEGzpKDr70DhBJrNBjVwQe4FDWo8A965DQlKRvAsHKjDC+ooKxmnMSBm1iH5BzR4JCxrxQBuoENnRsEHQ0LvfQcNUIFmRMHXSQLjWBR4cCJoxQA4RIB+AXVsQLPC4IPHgJ0YUFh+/fgAfEI5ZJ/xf0jogdIq8MA70EFxz25tYYDMxv0Fz4jK6kaC7X9wYQEDaMUKbIYYYgcTA+gASzngKgnQMm1QRwl8bgXQrWB/AQ+mBF9rBzzIEhzEsHQAGjQABQIwX4D8ADobAESD4gs8gwo8+A00cPX64QFwmgZ1zkBXnIHyCigdgJZLg9Sb+M9lOL0hngGxEgQ5ocHyMgMD6PR3UEcIcsAdYgk6yM2wgY3/0M4vJI8xwUsqUNiCOor8Enrg1SmgTpambSUDaMk87HwGUIcaFEeoWxLApQJqiYdet2DUNbC8AXEzaPsQaBUCeFsPcMACdqUbAz7ACBkoAu0tB3WSQXurQQeRCkoZgc8j4QQOsIHT6u+v0JUK/xkgs7Ww2VekMMQYBGAEDxqA0itoSwFou4i4sjsDiA0KA9DKnWc3NjLAttyAZrxB4QIOCeAyf0EJA/Ad/bBZb5BNoMEE0P3136G3c4DKPnCnlRGSB0Dl3z9oegfFM6iDCepsggbYQLPSoLMxwNsAgJaABhBB+kHhBVrdARrw0HFoBB+WJ6JgB96GAi6/QVtT/kHOU7h3dhYDKF+CVkOABy5A+YZTmAF0+OTd01MZQDcu/Pj6AryKAuTO148OMUAOqvwKjgWzgAUMIDMfXlwEPjEftOQfZD9ooAO0/UdSzRu8moYJfOK/HAP4bBZY/DFCu65I5Q94WwVoJpwROoACTpDgSGVgQE4v/7GsFmCEDS9DOtKMUL2M0MEE0NYSkNtAcQUqA0F+Bg1agcpV0PYB0AAyKKzfPz8HXhkBOisFtOVEA5jeQYNyoLAHbctgBZ5RA4oD0F5/UFoAraSCnMcgzgCKO5A7QfUM6BwT0OAdeMUKMMxBgw2gOhJkD2gw5Q3wYEjwNg7gABfyoAgjI2Y+Rkny2OotBhIApfoZhiYYHQBgGAWjITAaApSHAOPwDMQRWjFQMzJpPhpPUhzhTqc4GxnQhiescwxrRAlLmzGA96R/fMgA2ssJauiAGr6gziv4xHmgQtCybZA+EB/UeAI1eMENImCHCHTaNmg5Jche8AnPQPWg66dg+21B4qCOBnhG7vMTcGcQNJDAATwBHNQIBt8rDdQDmmUzD1rEAGpwgtSCBhRAHSNQxxB0ijdoZhK8/BW49BO0Zx7UyAId9AVq1IEaaeCbC5AjnBFL4xIszwjuwMtohYKvZmOEbRoALfOWMATfyQ5SBmqEgzpjTMwsDKBGLmj1A2zfp7iyKwNi/ym4NQoxmRHKBtHAhiHIfaAGJWj1BHhJMejQPmCYGXlPBR+uCOpsgewHddJAM7Cwa7TAjUZYAxnkPkYGcGdG3bIIfEgYKOxBKzaUgTcLgBqdLGy84H3joPMYQDOPmrbVwAOxtjFAjGBksAxbBZ4lBTWSQYM3oBl1UByAllKDBgFAs4MgxaDZedCMOqiRD4o3kPnXDjYygK4bAy0vBnVUQPexAzf7MoD0cwOvGwSFPeRec0gHDbS/GxRXoFUDoAEDUIMZNPABvt/921voSou3DIjD1KAxAOxIgWZBQUvXQR0f2Kwb6NAu2Cnx4CXowLCFnaQOOSwM2n8ADoAgOlQM0GQOuUoQ1PmAnBsB6kD8B18JBpodB/kRtDwatGwctjwf1ImE7FX/zAC6kQB8VgCwE6dsmgnWB+osQPaJszGA7gEHbaUB3RMO6YtA8iXIrxLAWwJAgxSQKwf/gFc2gBz1BHpgJmgQBdTpB80yg1bjgK6aA6VpkJ/un53NAL6nHpyqkDuw0HwPLStg98SjlnP/EQfqQa8fA6cDYPoGHRoHisM/0CsOQasYQGaAViuABvxe3NkJ3qYB6hyBtpeAtgI8v7kJsqz6P+TWDrzFFCzPoTgIUVaBwvvXjw8Mr4An5INWYYD8DlL6n+E/zqIatdxlBA+cgDrBb4D33IM6W59fX2MA7ZM38OhnAM3ggsIc5EfkswRwDYiCLIV1IkFq/kNPsVcBzpqDZrRBYQM6EO7MphQG0BYJkHrY6fcgf8D4oMPgwDd7IO1HBw36gM4dAOUfh4T9DKCDJkFuBK0wAJ1VADtkENapBq2iAm3/AZV5oAE9SPn5D3zQnIx2CANosAs00ANadQUadANd3wo++R/oCNDqIfAgEDAcQXkaNLgDOQDyPTifgsoT0BYsUHkGOocCtMrp0+sr4LNbQGkYNJMNSrOQ1TIXgeXFaoYzG5PB54yAVgz9BOZb8H52sP/+gVdggFYPQQ7T+84AKXtRT/YHnVcAcgMoX4HCCZTGYQMaoHL//z/I2SQMxAJGxMABIzSdQeKOiQE0oGoWuJABlCbAZw9ADzcElRegwTbwwapAe0ADyeADZIEH2YJutXl8dSU4bYMGpEFnUoAGl0B1HPjwwrc3GUBbjUADA+CDA/8BD8MEDnaABvBAZSTIzyB3gFaYaNnXM4C2AoDqQcg2GUg5Q9hrWOpxtAxG83YHw9AHowMADKNgNARGQ4CyEBiGnX+sDbLRdEJKCMA6iDQNNUZS0x5u9YwYZiE6DYzQ2W7YTKpZ0GIG0L3F3EJKDKAZJ8gsz08GUIcf1FhSty5jgCy//g+d1WWD3hf9EHwyNujMAFDDEbzHWkgZPEsC6iyDZk9AesGnYcM7DpCQBDUaQbProNlO0IwT6Mok8OABcJb8ybU1DCC3gbYHgBrGoM4TaJk86AAtUKePT1SDAbTHGbZ/Grx9AGg+pJGJZaYPJdLA3SDwzD9olgi05xu0DB/kHvC93MBwAzX43jw8BF5yC+pcgNwFasSDGoZqloUM8vqxwBsP1jCAlmtDZqRhk1eMiOXZ0FlgVeAVbaAZIl2XdnCnBdSxA22lADXCH19ZAb4+ioNHkgHUIQcdhgfzC+wAO4jTQYcjsoDDHuRG8NJd4IwueOk8sMMMuvMdtAUCdIAYaG+yrnM7+A7y50in0oM6naATxEENbtCsNahjAqJBAwiQMwN+M4D2EoMauuDOCPQQLpDfwWkDeCgaqGMASgeggQxQhx68OgQYXuA4+vmJgQE6iw8y+9bxPgbQNZOg2Uf4AX3A+89hy97hKZeREdJJZ4TmMGC4gQZlQAMDoBsJQCsUYPvgQTP88LMCGCAmgAaVwGEE1K8GHBgBdYBAHR9QXMHvGYeaDR5YYWBAxBED5L5vUDoErayApx9oeQmKA9Ay58/vboGvCAP5D+QeJvCVlPoMoLADLf0FDUyBOhEMDMgHlzEygE4UB4lB7IXMzIOXHn9/C3a9MvD+d9CKBNBACniwC3jXOWiFAChtfHt/H7itw5ZB2SSNAX4LA3KeRmKDQwJb2fEfttwdmooYIekI1HEG7aEHDc6A/Azq9PyAHvgH2nsOGrD6AZ21BKVv0Goe0H5p8Mw30O/gk9XBRkJWWBAuE1HLKUTZ9J8BfB89CYUqrKMO6siC8uh/6EFtoHAGzYiD3Pjs5gYGyIwrpvtQBgFQwpARnIlhA16gVTKgsgk0QAEKC9CAkFPSUfCBl6Al9uA89uAAeGsSaCsPZIUHCwNi5QnEU7La4Qyg8zRA506Alv+DyrQnV1eC8z3IreBDV8E3PvyHjlYxQvIRcIsLeIAGNJsPGmAF5i9QPgKdJQBaPQW7XQPkT1DaBaUx0OAByEuw1SmgZeyQPABJB6A0BjpEEBR2ILeAO+zANAIayAIN3oH0g5bXQ24v+Ae+1hB0beDbx0fBqyBA2w8gq1GA5v3/Dw3jf+BBKgaoO2FRCQpH8CGbrFwMoEFTyL3+HxlAYqCZddDKGlBHHbTyC6QHe/2KPCCEVH8xQm4hAa0+EAduO/rw8gI4T4PyJSTd/mGAlXGwwRyQu0E3z4DklYD5DnRlIihdg1YRgQog0AAmKLxAq6BA4QvSD4ofUHiAVtKAwhdUzqmY5TK8vr+fAXZrBUgNKG+AVhmAyl5w5x8YCcqmWQyQA1h/MDAwYPoDZ/2MnBcYSW0PMIxoMDoAwDAKRkNgNAQoC4FhVuiOViIUJQe6dPzBLSDqdf4hxqGbx8gAn/VHGQAAHUx3gQHUqAV1hEEd8X+/vzOATiQHLSsHNRZhZwDwAk/pBnXAwB1PYCMMtLcZtMwS1OkCzR6CGktCUqYMIHNAHTBhOSvw6c2wjiXEWsgBTaAVB7DrxCDmMTLoOrcxgA5jA3VyQctOQTOwoMYXqGEHOtkeNDPNxiHAADmsTIUBtN8StF8VtBwd+xJLSGcfMmcEY8M6gIzgFQDwA6RAM6NsPOC94i+BM6CgpZ2gve2gTixo3y/IfNAS8SfXVjOAToIHNc5BNyIwwPcVw8IbFM5MDKAZOFDDXM+tiwE0W7xvrhUDaKk3+A5w4EwyKGxBh6uBGt3sPGLg1QWgjjaoUQs+yI0B0nkB90WBbgOdDg/q5IP2dYP2qYNO/Ac1LNmAnWpQJxvUAX0OXN4Oih/QNVqgMAUPasDbzUzgAQt9917wWQmgvc6gMIadzg1qmIO2UIA6reDVGLBcA4xn0BJYcAcZeAo8aOYMtH0B1CECzYqD9vuDOxn/ITN/oI4RZKZfleHc1kwGflFt8D3qoPgDxdut473ApfeGDODBJyboIYnQqwRB6RNkLmgWDXTOAKiDxwCbxQO75z/4AC/I7BokPiENaUhcgg7lAzX4QTOxoLQHCh+4XxhR1YMGkW4DBylAB1kirueCdOBBeR406w/asgJKc+AzGqCNeFBHD9RJB62YAA2EgOLwKXDACrLqgAGa1BBpDWVJNAO0Q84A6eyBVspw8kiAB9FAh1yCVnSAV7QA0yFooAu0rB00Ywy+Hx56ejsDIyIfM0BCEVG+wcp6rMunGcHXx0mr+4NXrYDSB6gDCFpxAJrpB7FBnXFu4AAeKH2BwhXUaQOtCoHcHPAPPIAF2jYCyhMPLi5gQHRsGBlwA0w5lE44ukai6qv/kKXYGP78DxmohC4xRzUa4g5sAwCIAVFI2QAaFAF1FEEDXqBrUCHXdl5meAQcsANtnbEIWc4AGuCCpBsGBtDqA9DACWgVDvJ2A5BXQGkedFYF6DBFUFkFWsUCud+fFXjgoxzwdpV34Nl5kFtB225AKy5Agy6gMEe4C9LZBuVB8LJ1YPkMK+NB+RgyK/8XXHaBVhGBVmyAys2fwIEm8CoeYPkBGhyEdFr/MnwHD+78ZWCADoCB4h6UHkCDnJAtXxD7QKtjQINboHIEvKLiP/Ie9v9I8Y/UwWVElIPu2dcYQCfjg8oLUDkBGpgAlamgfAUa4APlPfDWGmh+gOR/RujQ3n8sSQqSz0GDbqCBStDgNGgwVMu+DnxQH+jA2sdXVzGABs+4BOQYINc3/mWA1C/MDKC8Bip3QQMZoFUi4DQOrE9AA7KgMhq0LQJ0ij+oTgMderhrui542wPI7aAwAK26AO/pB97kwC+uD97uABq4VTHLBucpUFmuaJTMACr/3j89DY4PWHgywPwI9hWsLMJI/AzQ9Q0ICaT8AAsZhlGANQRGBwBGE8ZoCIyGAAUhwDi8Qm+0809RfNKtwiUrnnCnVUas5kE6DrBGJWj/vABw3y/oZGdQpxTUyIXswQW1QZgYIIe/QWjIbDQTePkyqOEFuv4JtDwS1LACz4YCT1d/+/gI+DR58H3HwAYqSA40awLqQIBWBoAOvQKdDWAWuAh4Vd1yBgPPiQyg5aGg2WtY4wi0nx90AjzoMELQIVSgawhBDVi3zMsMoAPJRIB75UH2gtwL6nSClt+COsSgjhRkVvI/wfiGdRhBCsGzesnHGUDXpoH2bv6CzsyCDroDNdRBjeZHl5eDZ/lA+29BM8GgrQ6wfbug/bOgGR/YLBYDAyKMQXvbQY3JF3d3gU+XBw1msAH3loIarKBZa9BsNnhmG7ikFGQmqLMFmol99+QkqFnOAPI/rLMHCmPQ8nRQhxt8Vz0jI3grAKixDzqoENTYBHWKQY1W0HJbyD5gRAMd5mdQwxY0gAGKG8hZD0wMoMYvqNMBGrAA7UMH7YV9//w8AyxOQOkFfGXYf8hyVtAMJviu7z/fwYfngVZlgAaMwF4HdjRAcQ5yA6gTA2qQg5a3/wcutQXJgzoCoBPUQf4CdXZAfr5+uIVB0SCRAdzJZYB0wMDuBdoHPo0cHKTM4IPe1K2KwQf8CUoZg2daGRkhe9kZwSeE8zGAr7UDHkAICntQxx00ywja0w5ZOQBJG2A9wPADhb197G7g/uVtDKDtDPCr4Rgh6R8Ud1rAawNBq1FAs+OwU9VBboPskf4GviITlPZAnT5tx0YGUDhBDohD5E3k9AZKc/Al6dBl1KCBG5Be0G0aDNAOLWhpN2jQDGQuaDYesncbNoyFZDYDWhmAlu/RT2AHLbWHHFz4nwGUbkAdWNBqH9AAB+y8iK/v7oLjHtRZ5Qdeewe6thK0FB20pQTUcQXNDj+7tYkB1BkC72uH5zhIpwZ1sA17GYV3AICUEpsRt2K4FEqYMDIg280IO6sBqdMKid8v4M7jtw8PgOOArOAbOkBqQemYT1yHAbT6BbTaBDRwArpaErRc//GVldCzBhgQA62MkDABdbhBM8pPgJ1TcJkBvKYQVO6C9IFmoWErR0CdUFD4gsodUD4Cz6IzMoFvg4CdjwAaqAPtNQe7HZjfIGXILwbQKpZfwOvrmFjYGC5sz2XQAd6wAtrqARrgZAKuJgB18h9cmA/ulILtY4SsBgGfDfEfcp3lL+j1dwzQgar/MBq6eguW3EDuAq0iAYUHOD1B1aGEOdD8e6eng1dRgc82AV5RCur8gzrToPAAbRF6BDxME7YsH2QmaDYelOaFZa0ZQGGPkl+gwQrq9INXhv35yQDqhIPyCmyFDGiwwcC9D7g6ax0DaOUGZEXAc3Ccg8INNDAI2roBWoUEig/QgCzoRgnQgDNoK9PFnYXAKznXA2+xSWIA1UWgFQOggT2Q+38Dr+QElZGgOgA0GABSDz4M9+sr4GqrwwywsAMN+IDKHlB9AR5k+/YGcm4LA3jIE+IWULpghHiIEanMg8Q3chqFpu/RdhxRpcLoAADDKBgNgdEQIC8EGIdPwDEywhsho6mB9BCg26w/yGlkV+640ysjVjMhaQLWeAR1aEBL00GNTdAeUlDnELScEeQk0LJ48NJgEQ0G0KwQ6Pol2DVJ4NPJgQfagQ4eA81uiCo4MoCv1wI2hEAdWNhVSqBGJKiBC+qsg09jB7qJETjTe3JtFLjjCFpVADqpGdQBAQ82QMMCvCQTPrP3H7y89M6pyeAZP9D1XrAl36BOG6ghBrITtAIBfYYK1phigLehYA0rWDgwgVcbgA5/A826g5ZrgmbOQDPgoMY1+Gq8Z6cZIKeqM4Bn9EGzVaDGIEgNKDxAp/DDltEywBt0EPMVgJ1a0FVziBns/wygThVIPahxCOrUgfb/gq9me3cbvJwWtPwU1BEGdTghXQdISgR5ATTTDJp1ZmHjAl8BCGpkgjr9oH2/4GXxwI4CZCn7NwbIgMsjpIQPSSvgBj1oJhmadHiAWz5As1WgjjYT+GDBu+CzD0CNXpj9cEMYIZ1zUKMXtOcfdHo+aOUBbNk8IzT+QCsjQDONoJlm0GAOqBEOMh92UBZoeS1oFQdo7zvogC7QNWagwQjQ2QLIh8DB7tOGmQsa4AGd8wA+4AsY2KAOBPisCbC9TODbAkBmQOLtDHhLBahxD1p5AD+oDZgGQXt7QecLgNIHaPAJFP6g1RWgMAdt6QCHPbTjBlqB8PfvT/BeevBKAtBp6cA0DLp3/vqhZgbQTKaSYTID+EYM4K0Jz25sgI7ZMDKgpj/0vIpYQg06XR086AM0G9QRAc2wg8IDlE5Aee0bbHk4Smwi0gUifnCXB7CBBVC8gvZJgzpHoqBD44ADdaD0Bjs4DuRm0AwziA9K96ByAbQaBjTgA8rX74Gn0UNuJ7jNALqpAGYuI4llGCNap5wqdRQWNzAieqywUgA+AAAuB5lYGCCH0kHuwockYUg4gvSCBvpAZSKIDeo4gsoe2Ow5aMk86PrRu6engQfRQANeyIf/wa6gA89qM0DyjoJhEgPsvAXY4XCwVRTMrBzgcz1A56qArqYElRusnILgNAYqd0CdSZDap8CzI4TlrBlAnXvQ7D8ovq7sq2aArc4C5T/Q8vZ3z06BtxmAz3uAJg3QFYKIMy4YwbeRgPb+w7fWMEKGb0A3gYBWuYDKKB3gqiz4FhRoHgdtHQG5R1TBgQHUMQbZAUrHoMMEYeUGIuxBfmdi0HXtBHeqQeUYyO+g5f/SWsEM4Fs3QHUDqPwClk0geVC5AFoN8/8/8ioDSJ4CbckC2QsKC9AKNNBefNAsPCiPg+wEDTiCV/58fwdeXQEKf1C5CxroAK0uA60aA68sAtoJKm9A5QHs3Bjz4KXgAx5BeR1UH4LqA1E5G/C+ftDKAdAKGVB9BhowA5VnoOs9QaujQAN/oG0UkOtxIYOzoMFO0AohaY0ABsigLTgRgLdAgG6GAQ1AgM7YgQ18wgfOQAM+koYMkFVWmHmakYGRuOwyAgcNRgcAGEbBaAiMhgDpIcA4fAJtdLSY7LiENKvpmBYoiivs7sTZ+WeANMRAJ5qDlumDZvJBDRA5nXDwKc6gBi4IwxpRoAYdqIMJWnYKokG2gRqb4E79ry/g2S6QflDjFDRzBZo9/w28Kxx8UBtw2TZoxhDU+AJdywa5h/4vA6jhCOp8gGZ5QHo+vboMPjgKfEXXf0gjHOF+mP8gnSVQ4+s/dCYKdFYBqCEOmukFDSBArrqDnHoNiXxE2CA6YozgWwMYoI1N8P373tOAB0YdZAA1gEGzO6DOn5iSC8Ol3aXgO+hBs3ygRj+ogQjunDIiZt5BgwbgWwIYIDPjsIYv2H5gIw60YgFkF4+wGgNohh/UaAQNtoBmekFLa2HLgEEHSYEap6DGLGhfLqizDF5GzAhpMELcywy8s9sd3BAFLesFdf5BYQEaBAEpA+kDzbqDDs8DzdqC7ITdB8+AZA4sY4BDB0iAGvEG7v2Q68WAgx2guAbbjdTwRu7UgDqooMERcMNY3h7cwAafFI+25BqUhljYuBmu7K1i0ACeHwHq9IAa1CBxUJoBuR0UZ6BGNeiaM1C4fwV2dCGzgaBGP6SxD+k8MYI7aTePdTOAbpkArTYApZcvwH35oL3XoO0CoDgGrVwAbRsAreYAuQlkL2yQCXTYGsjPoIMcQdeEgTpOoM4t6IA+0P7dE6tDGWSAnRHI4V0Q+0F2/4ddwwgdkAKFBXhPMbCjIqcTyQDqBIDsAw1EQJYyYyt6kNMiqIkKSs//wKs8GGD714FKQLOaYHcBbwgA2QHqaDP8RztEDFd5gS6OzEcaTIO5DpQeQekO1CEErQoAbQOBrfIBDXiArkkDHTb3D3zd2z/wlZ6glT2gpdegASDQ7Ox/lOXgDAzEDgJgqmOkbt2LFhaogwCgdAVcNQJaMQLcm64KPM/j3ePjDLAZcYjbIO4BsUErjkCdONB1iaAZYVDnGrTaBzQYBe7sATMXaKYecg4IIq7AZQ7w0FDQ9ilQR/r7F8gsNGgwBzxgBg87yAAneBAAGE+g9Ay6Xg60UgoUKKCyFLQCAxTeoEEmkDrQFZbsnELgaz8/vbkGPrMF1GkGX+/4H3qmBbD8BfkCdtMK6OBR0MAhKJ4hV7i+AceXonEqA2grFqh8A63kgZRdjOCVLaB9+qB8BBrkA610AA0KMULrEFC+BeVB0KoZ0GGGoFVFoMFL5CtYkcsNkBzkEM1nDKBVI6D8DhpIhXT+GRhAh4yC6oWfwNsIQANPoIE1UHqDDY4gJxBQ+QNKn6CZf1Cdc/fMDOCApy4DIv8xMsDCE9SphhzYyscAGqwCrW4BbdMAmQdawQBZSfaFATRQqe/Ww8DJLws+OwB0OwnowEPQ2Q2g1S+gAVvQoIqAuC4DSD/ojBjQVgDY4aPgFVrAA1hB5ae0hh8DaKASVP6BBkJB28cYGCD5AxQOoPAHqbeKBA4WAtMPeHAAuj0AvKoDuFoDZA94UA7sceiqNqRsQvQgAMPIAqMDAAyjYDQERkOAtBBgHB4BBmr4jHb+SY5LWKef7pUqDTr/sIYGZiAgGrWgJYqg5fOgw/5AnVDQoVKgmSxQo0nRIIHh/YvzDKBD6UBmgBosoE4I6LR70EoAyGFu3xlAqwdg1/+BBwl+fWUAz7BImzKAOs0v7+wAn24P6viBGsGQmepn4FkNBvBy07/gZdegBi6oYwha1gm7bx/idmieBC3xhnVGkTqloNljUEMZ1JkGdd5BjWrQLAwDln2W8IXTQLNAM3qgGRmQGKihCeoggmaTQB3pS7uKGVSB9+iDVjYYeE5iAHXuQSd+gw7bAjU0Qf4HdZZAB7+BGuSgrQjI+30RHW0m8CwPqPMA2kcMWi0A8h/In6CZNFC4gU7UBh1gCDIXNBADCifIqfv/wAMriKQBbnIzgO5sB+0JBm0DAM8Y/QftVWcEX9MI6pSDOtHGfrMZYIcKgrYZIDrySKnhP2TvOTidAAnQYVig+Ae5DTSTBVoNALpJADQrqOPYxPAYeN4BA5IeUPiCZq5A4f3h2VkG0IneoNUhoEEH8JJlqFWgDhBosAcUtqD4hxwqxgBqBYP3zYI6T6A0B2pogzpPoJlO8A0TYLuAS57FgFdQAk8chyzXh1y9KKcTATxTIIsB1BgHhTWo8Q46lRvmPlCcfHhxjgGyX/cfA6jhDuqkQDoGkMGl++dmg89B+AJc5s4MHKAAddyVgHt2weH69TX4ujTYrRaQMGIEuxk8GMAA7bgD0y/I/QrAgyBBblezKmGArPSA7o+GRx4k7hig5TJsVYmGTQXkGkIGxOwmKD2DOtefXl6GrBIBLsUGHwbJ8B8p8mB5AuEmBqxlPpK9cP0Qc8AzqtBOIqjDCEqDiNl/SLoFdU4gBz1KgNMXqKMPPjgSuI0DPNgDHBQAd3zQBgDA4UWgTMM9SECoDv7PQBgg95AQbPQBANA5HqBBTAkVdwbI2Q2/GEBbZ0DpFLyqBhZfwEQG6kCDVpWA9vuDZrpB6Qk+KAP0P6jjjDpLDUsuTAygAT1QRxmUVkAdaNhgFiScYDkQ5itIxx20LQbUwQSVMaBVIaCBA1A5BDpHArzKhwF0zgYT+EA+0DJ/UEcZtIUHdAUqLB+Awvg/+NyMv+DOtr5bLwNo1QzIJlC8/oQu8wdfkwfMY6BtVuBrNhkgA63gwRCg30F1BGjGHHRAKPiqVXDeZGBggNKgA/NAgxGgVWCgWz7AK6VAq1gYoekPZh44Kv4zgMoH2C0ToNUXoFU3sNsBQPkQVK6A6hU5vRhwhxxSfv1DjXag2aAy5QOwjgKV1SC7QW4HlXegjjX4FhWg3xnAaRxyxgGoow+5CeEdpCr4D9nuALptBjQg+/zONgbICqH/DM9vbWUArSS7cbiNATTIACrnQDc23DjayQAKB1BcgAbIQDRoVQF4JdeH+wyw/AEq10Gr50DnEIAHi0ADaKB8Ag4SyOATKD+B6t0H5+cygAYHQKsXYANQoJVFID4onYHMBp9LAFyZBbne8y/DKMAfAqMDAKMpZDQERkOAhBBgHB6hNdrxJzke6T7bj+xCiuMLe7rF28CG2glSA5r5BR1WBGpAgRqQ4Bl4YGMFdDgSSB7U8AN1sEAzyiBng/eZAvdcCgDv2gbNVILEQB1H0F55UGMOdP0WqAMHmhEFXbMG7qQC7QMt4/4HNvcMxPfATjjofn9Qw/kb8L5268iNDPeB+1J/Qa+FgyqCd7ogJ+9LgQ9xguwjBXUE/jF8AW5BAM38gxp6oJPiPwNnwkANc0aMJb/QQGeE7HeFLNP8BF51ANIHHnQAKpEHNjpBs2iggQDQoMCDc3MZQA04UGMM1NgEzQ4zQDt+4IafvB0D/PAqeLxCGr6gjh7o/nbQlYrgU7OBDVJQoxEU5qAGHahhCZqRBncewDOsUANAjVYGRIOXESm+QCpA5x2AwhUS8//BgwyiwFl4UOcRbDbwbm/QbDisk8YAW1HBgDAfJZMADQIdmgdqeIMOvPv26REDqBMK6hyBOiGgPc2o6hFDZKCVHqBOBmhGDXQAGahDzQBzL2QkBNzRBw8qsPOCtyyADmqEmQdq6IJmJUGDISB/gQZCQHKgmTXQAMxx8Ix8CAOkccwA7oiC7hwHuQ9kL3ilAsh//2H3gUPzw3/IQYSQayr1GMAHHCKpAc1mgpbtguIWfOUh0NIP4P3YL8G3WoA6KeCZcAZQXwHa0QY7mpEBdHI7KJ2DT+wHxhMo3EA3UZzfmgU+XI+BgQGW+hggM3mMwGvptMDbY8AhB9pvDjz0EDQrCLpJAnSSOKzzCFpdAsKgdAjqpIGv9UMa8GJEH1RA2MQAG+BC0AzgtAFKa6DBMQao/9E7qgxQP0KWwjMzgA6OBC31VwcOaIDiBTQYAVv9A5vtB63QgKz4QO6YMaIlE0bw7DJ4FpwRlc2AE+Crh4np/MMMRjIHJT0ygMsUULyAOnugWX3QQAdoSwRoIAB0XSkoLYPKm9/ApeOQ+GIEH+wGmqFVAd7k8Ra4UgC8+gNlRQW62yD+BeUF0O0RoM42+EA54EGP4MP6gIfvIVzICL7VA7aqCTRjDlqNAFr5ASpzQJ1P0Kz4X/BqK2jnD1RGAMsM0Aw6aEsGeG868DrF/9CONyguQauBQB1y8NYj8E0hP8FXqoIHLEGdY2hZCLrDHnwlIGiLy78/4C0FkGshGcDxBysLQStzQAfDwlZuwfMH8PwBDZtK4ODXdvAKIlDY2MZsZwCdmeGSfobh7qkpkEhhhHR8QWEKzo9APmjwALQSCMQHDYCC0ihokBTUKQed6A/eTgG6ihFpAAwSJwwMoDoLNLACqp/Aqwa+vGAAuQk0aA0a3AFtfwJ1sEH+BYU1yHxG8NWgvxhAA9Mge0EOAw24vrq3lwGUn0Hufgu8sx9UX4kBtzWAylRw+fb+HgNoJQBopQNoqwgovMH56s8PBkjYvwenK1C4gVYggQaLH1xcBF5FADs/AXTWDsjtkK13jOArBUFpArQaBGQPKN2B5ED5FzR4CRrYBqVP0Oo20IokyI08v6BhichAiNKYYRRAQ2B0AGA0KYyGwGgIEBkCo53/kZhUwJUxwwDGPVUGa0gZAGCEN8QYwO1gJgbb6G0Ml/dUgmfyQbNHsGu9QEu7QY0dUCcQ1OgDNT5BHSZQAwXUqQJ1NEEnHoNm7kFL4EEHgYEaQqDl86BOC+gkc1ADW8k4DTwrAmqggTrKoDCXUPEEdwpFgDcDgBo2ILMeXFjIAGqogt0FchuwgwRalg1q9IAa66BOFgs7H4O0ZhADaEYMvswVOnsKmvEBdf7/Y5mNhM+OMkJiHGQHaFkr5MC8/wxqFoUM4PMHgNdrgZaiggY0QCseQI3HX9/fMMD3RgM1fnl/FziLJgi+FktMwR58Dzyo48uA1LlkhDZ0QYcSgrZPgDqvoJCHLOUENgdBjXFgwxHU4QXZAxv0ADVYQecewGauGZBmhlE7fgwMqJ3s/+AD8UAzXFf31zGAlv3DTgM3Bm5tAK02AHXsQVsaQJ1OxHJalC4IOG2AT6oHdi5AnTvQ4WT/4Tcb/IdaycgAn8EEdWThRkA6QIj+KaSxD+6MQjuwoHQBuace0rEAN3SBnSzYagJwBwDoClCnADTQAuo0SQLTCqgxDmqsw/Yngxr0DNAVAqDGOKjzAtp7DFr2D3IzrNMGXjUAMo+Fg4FXVJMBsnUDZCvE0eBl/QyQgSTQwBf4hHugevAhj8CBJYgqqH+BHQdGcLBDzosAzQiDT/UGxjsoXkGrTniFVBngYQvWxgRcfbCLAXS+BWhFBWj2FZa/9Fw6GUA3R4DyC2iwAXK6PqirAFk+fvf0VAbQ9WEfgIcw/od3fqAuQutMM4JXtLAxMMA7f4yQjjewYwaa8YTdLvAbGtYMMAAOQ7CvwFsrwPu5gekS1KEEpUvQAYug/cegpdOgFTOQpecMED/+J6UzzkACYMSilly70Mo7pEFBRmjn1yZqK3jpPGi2F3SqP2hQ7sXdnfCD3CCJHhKeIIeBOoeg8yFA520wIK/KQA8PRsjgC6i8/P7lGQNowAQ00ADa/gO7LQVkHmQrDSPkUFXgyor/0FlryOw7A7hDDZ4JBnbOGdDs+A8b+PoPvW8fmA5AB/GB0oOQjAV4hYyeWzcDaBYalDZAh9ahnEMCHJADle8g9Zz8MuBBCND5A6DDAkFlMniFEvCwVfDVn4JKkG1TQD+D8hlsdQx49RfQI6DDEEFsUNoBrXR6cn0teDDs6v56hv/QWytA9oDKN1A5BTr7AzTgArlS7ycDKO+DBlR5RUFnzUgy3Ds7C3wbDcYgE3wwBxx64AFFUD4E5SPI6oGf4CgD1UWgMg90LgMDdLUEKPwEJI3AKxBAgwygsAZ11kEDvrBtXaBzA8DnngDzO2iFHEgPaFASNMgAGmyGHdgKKqvBh7WKaQM78hEM4NVhwBUVoLIKFAegchZ8M8R/yEoNE9/ZwFtwdjOAroAEDY6Dzm4AXRUI3g4FrOtgK6dAB8TyAW9LAQ3s8ImoM4AGWEGHl4L4v6HXqzKMAoIhMDoAMJpIRkNgNASICAHGoR9KjIzwDsFolOMPAVinf8BHzene+Yc0mMChg9SIegg8fRnUOOQH3gIAakCBlpiDGqqQw+3YwbMe4AYlcEk/+D5k4H5ZkBrQHlVmZnYGUEcB1HEANWRAjThQgw50fRiosQRqYIGuAZTWDGQAdepA5luFr2M4vMQNfGozqCsGmkUBNb7+I3WgQQ0obkFlcAMS1AEBNYBBDUbQLCTohH7QoVGQWIYtVQXxYHtoGdA6x4j0wIjUAQDt+wY17kANUtAS18/ADh+3gDwDaHDDLGAheKUB6OA4UMMPpA20xBU0IwdqzIJmpkEzPeDZb2DjVljWggHUSIPYBOlQgcIMNLMDOoALNKgAWioNamyDVlmAl9kCT/wHNSzhy3Che5FBDW9QIxjUeP0BvCLwP3T2HtkXKCmcEdzFBt9DD2q4CgKvXgQ10EHXkYHCFtQhBh1kBWqcg8IS5Vo/BuQ0wQANHUZoR/8/QpYRog4yCMEInlUGHWwGFgVtzYANrDAiOvagcAR1zMH7iUEDBTDTIb1oBphZIMtA2ylAS5h/IXVQQY1r0AANKIxA6Qk0mATqpEO7wBD9QA7oVHPQXmzQXmjILOlXBrA6oJtAHQpQGIBO8AZ1fpWMUxhAcQqLJ0ZGJP//h2y5AC3zBnXoYeEEcieoUwS6Ak5C1Qt87SR4EOrpCQbQDQDgTiC4IwY+FYABtoQXNggEWuoM2hetD+yIgZY0g/IH5DpBUQbQqe+gARvQagYG6CAJrJMHGvAAXU+GGFBgZGCAxwgj+ER6WPiDbjwAdTBBq0tQ1ADDHTTIBDqQEBSeoCgArSwAbY+A2QNyNchkkBtAByKCBihY2fkZQO4GdWZA6RC0Uufx1RUM8AEpjM4uIwP1ALpZlAw0IJkFT6Ow/MkIPozu2sEm8MoM0AAMqGMKOp3/P3Q1DvrKG3AOAWoH3xKB7ExsgyHgAQZW8HWJoD3gsMNTQedWgMIVlK9BS9+f397CADq8FFQugDqJjy8vgwcl7JR/BuS6ghGUx5gYZIADoaA4A69+AuoAxRMofkB5DlQOgFYV3T4xgQG0TP7tk2NI0fMfPFAEHmoCDvaAlpSDVnLJArfVgPIsqMwCDeqCV64AB5BAg7CgPAMq70FpA3Q1pbHPDIaHF0BXPzKCbyVg5xZhAK8gAB5+CQo/0KoeUF7Wd+0GX/0Hyp+g4AIN1qlbl4IHcEFlOWjgE3SwHqhcBQ2EgG5F4OAWA3f+weXrr08MDP+xrDBBKm9AeRA0QA3yB2i1GqhcB51ZAdqq9uD8fAaQHCj8QOUAqOyGHKTJAAkDoNmguge07QNkD+Ra1bMMoLMWQAOVoMEHULkBubaQjUHLoQGyxQeoHRRGoLwMOqQRtP0MtHUIfB4GsD4AddZh29BAdQ6ovgQdNggaDAYNSICuxQXfagM0BzSwBo5H4AoDUJoAr+wCDgiAygjweQzAGwcYwPErDb2yEe0sEGjMDnh7hmFwgdEBAIZRMBoCoyGAPwQYh34AMTKORjIDoVhGdPsHRWBRLc6wxz325f+ojWFQOEBmSiEhAr7mCsjUA57QDDq4CNTZBzWEQfdWgxq+kI7qf/CBeKDT0kENLVADCXQY4O4Z+gygA+S+fXoCXkkAapSBOlCgbQGgmc+n19YygGdtgeY/uQaaGVIGzyaBZkRBB2OBBhtAZoHcDWoMcfHLg1cNwGZowUv+gYewgRrEsKsCQQdZQWaMIfun/+OYkcQY8GGEdQCYwJ1IUOcJ1PgEdSBBnSJQA/Ht46MMH19fZQANOoAawqCGL2gQAtSABd/d/+kpONBA9+iDGpCQJfL/IT1oRnALnQE2Cw26bgp0zRpoRl5WOxQ8KweeLQN2zkAHMILCFbTPF7TMFzSwAGo4gzquoE4GpEMMS7EQd2NNv0Cp7x8fg5fEgu8tBx40Bu70A10BWpkB6kSDOgrg0/eRl9JCwwI+ow9JFCidc5g/QJ4Dd2qBJ9+DDnUEX5MI7CCA4hfU4Iecng1UDZqFZGZjAA0OgQ4xBJ8RAXY0bIUAZH85yO/ghj90YADS4YaEITgdcIkwgJYvgwaRQJ1/UNiD3ALqqIBn5X68A7sTdEYBqEMOijNQuJ3bmskA2n8LUgvig5Z0g2Z2QekFtIQZ1NAHxSG8888IWYoL6vSCwgiEIaf8Q90C9CM3MD2CZjaPLvdjAN04APE7C4Okmg/YZ6DzHVDjBdJB5+KTBnc0zIOWMIDuOged2g7bigAaIAPNIoLcCIpZEXkbBtDMK6yTDV+mz4jUtIelLaCbQEv0QWlSVNERnCfBg0rAGWTQ7DRooAcUrKDBOdC1jqB8AzrUE7SqB3T9GygM4KsK/kP8CVr2DwoDkDkg/4NWVIBmxUF7nEFL3yHlATF7j8mtj/CkbwZKAMQ9sA4tZGAGYhdoiw+oEw46fwLUCQfP+AKtAg0Egm6QAHXcQfEBGRCA+gvW+QTnFaAYtNz5z4A+UAEZnAQPSgE7xqA0Cl6BwQS6blMEvM0EFC+gpd+gMhaUVq4ebGCA7e8HGQ/ayw4+tR5Y9nHySoAPKIUcosfOAOqQPwIOFkC2Ivxj+PP7CziQQG4GxTWIA5rlBl3nCRtcAoUBaKYctN8dNLgGOx9A2TSD4TLwkM63j44wwA6ck9ONYAANxL66twd8FgXIjaCzNEBm3Dk5iQE2qw66/QRkHqyDa+Q9FXzSPWhLFWxwGRxUTJBrOkHbwsDL3YEdXtCAA2hVF4gG3Xhx+8RE8O0AoAEMSJgjDeoywMZ1IWUMYmUGuGRiAC2TB8UtqFPOyiHIAF5ZBhxkhUQTE/icGdBAHqgs/vHlJXiVFKjMAg0WgldLAdVCDmH9wwDaegNaFQAqn0D1EWgQ08BjAvhaQFA9CRoMBm0hAs3ygwYdQOU0+CYMYNoA+QUSrtCOOjS9gOwBlcWgwQbQwAfoykjQ6pB/0IFgyPY5LfC5JeDtNsCBBNCVoM9vbQFfwwvZCvSPYRQQFwKjAwCjKWU0BEZDAE8IMA7t0IE2BkejGHsIYHT8BktAMVIz3WGaRWznH9wwYmBkQF7iCjoNH9TYhzV45Q3iGEAnyIMOpAI13EANStDMDJgG7kcFn6rMxsOgZV8HvjIONIMGmtX8BeycgRqMoAYlaGYGdPgVaOYe1DgCddhADSfQslJQowZ0/Rx8VhbYeQR1JkFnEoCWrYNmhN48PsYA6hiDljKDGmyg2W3Q9U/gq/eAbmDA6PgjGuoMsDwC7zixgK+IA820gBp4oFl5UAcc1NkBNQJBs6Wgq7dAqyFAHTTwUt2fHxle3d/DAFoqCvI7SA8jeM9rBcOZTSngTiCs4ciImENngMw6CTOA7AHtZQUt3wTtHX55bxckJUIPIgQNPoAa+eDZJuAeXlCnDhRmoE4Y6MwERkhEIaXe/7gSPHwzi7xuFHBZ82lwJwO0lBa8zBesC1kvrGMESQOM0Jl8SEefCepGRvhABkge1JkB0eBOCrBBDzqxG6QCdgYCZICABbjPeCHwNO9MBlBcg5bnggZBQGELUgvqoILSCUgtqLMiqx3GALn/nJEBoh/UdAOePv75OXhJMngLCMgVwCW5oMY4aDYNdOvD5T3lDKDlsmc2JTOAzhAAdRpAYQa+Fgy0FB6oB3TLBWg2ENSgBrkFtHUE1JGHNdZBM5+gwQLQ/l/Q8nZQ5wp+pgAjpKMB2h4C2ocNavCDlm+D3AjqKIPCFDSABbrFAbQCBnKlGswPTAyghjvoHANQvIM6FOBDIIHxC+p8g/b1glY8gGb5QWkKlO9A5iB3/qARgBQPkI4OOJ6AfgMNSoGvSQMeYKhomAi+FQK8xxl4UBh4WTHQ/SB7QGkVtKoENNAGWtL/7ulpBsjS5H8oaQo0UAOa6QR1SEB5C5Q6QIN8oJlxUOcflJ8h1zwy4Eh/yGURqWUc6WUirgE/cHZhxHQLKBxAJ+qDBoFA239A51yAQhS0tQm0xx28Ygk48w/q9ILKKdCMsbJpJrgzC1mF858BZaAMYhEDA3p5jlIe/QfnQdBebtCqKlAZBopjUFoA7QcHxSEo74PSEWgFB6icAw1WgVdlAM1VMctlAOVlUPkISvugcgFU9oLKDPCqLeABmZBl6qDD7EBbmQrAW5JAHXRB4PVxoIErUJqAXaMJWrXDD1xeDipbTfzmMDy5voYB5DfwVXgMkMMHQeUpaMYeYu5f8JkboPQCvqsfOOAA3q4EPPcClA9AaQo02As63wSUtkD2gNIkaDAOdLAmZMAREkSgQWPI+TE/GEDbqECDnqDyHDRQCFohBlp6D1pRBQoTQWkTBtAAKChPMyBtf4HUbYwM5sFLwNcWgvnQ1UWQc2CAt1SA8hj8EENQJP1nAG1VAw1qgzrZoLAHDfCA8ggob4IHClk5GUCDQIzgAU1uBlD9AhokBMUZaJsXqHx6emMdA6gOBJVdoDIatHIMtOoLlPdBA2uggRZGaJkBWroPyk+QQVjwEBK4bAbVNaC8CFot8fzmZvCAMfimAwFFBsg2j18MoHoSfLYJcNAINOACig8F0IG8wHyLkfEYh3gbloF2YHQAgGEUjIbAaAjgaK0M7YAZLfgx60IGRhQ4KCOYxp1/kJ+JHQCAdVbBjVrgdUOgjjd4fzKwASsFvL4IdJAfaLYDNDPz6DLwTmRgRwO0VBt8ajOQrWySCb7iCDSbA2qgghp3oNkjUAMH1IkCzSqBOkGQJfSMDD+Be+lBTSFQowi0LB10yBZoRuQZcIaDAbqHFeR2UCMJ1EAFzX6BluWDGkbgzjGwIw47CRnUMAMt1QZtL4D0ev8TiG5IZw7UcAYtvwR1+EGdQzbgUmeQH8FXN3Hwg5fRgxrDoEY4qKMFuh8dNKMEcqeh52SG++fmQFYmADsKoNlD0EDJ60eHwWKw3jc4XKHxDGr4gzoaoBky0F5uBtg1geCGIjMDaIUEeIAE2GgFdQZBGORX0CADKBwZoLOzmIMADHiKtf8M4AMHwSr+M4Aau5BG/X/4AAFs0AekBNQhl9MOB9/4ALIHNNMOui9fx6kJ2IndjDRABDyRX1yP4c7pKQzyerEMoCvzQCf6g2ebgQaBDwQDNqBBS5kNvaaAG9Gg07JBAz2QztZ/8HYRUEcGtGoEss/4J7jzD1qaC7qWDzSrCTqDAHSPOfjQNOBAEiRNMzCIytmC90ODZu9AS3VBDXFQegKdawBL96COBPgUb/BeeCbwLCAD1G2gJbegWXNQuoadvQBajgxKQ6DZVdBMHmj5MawjwQgeF2ECH4gG6rCAOsEg94FuxgD5ARTPoDQMiivQdgtwJxEUgOC4Z2RQNc8DHwD2FXjAJSjNcfJKMkD2M/8Fnx8B3ksMXN4LGggALQ8HrSoAz/xB4w0RwdBGPiNk5QTIHFAHATRYYeo/lwF0ej/Iz8ys3OAT3uEdHOBhmqBweg/u8P9gAA20PLy4EHIOwn/kZcTIs6yQNAK7sQG0ugUUVv/Bh829IFykYnS88XVQwIHFwMDASDDvoivA1/mHqUWUg4gBLlCH09BzIsPT6+vBW3xAeRx0VgnoGjlwfgOGMeg6RNAACGi2HkSDl+nf2sQAHrRCdgiyX8FsyIw/A9pKAPCJ9MB9/aCyQF4/BnzrA6gM5OSTYgDfWAIMW9ByddDKJshBoYiyDJS/QAOyoOX9oJsHQANmoDQE2iMO6jg/A24f+A86N4ABsgrqDXAGH9Sx1QXe1w86aPAhsNyGbVMBD+CxcTGADrwEdVpB5e4v9DMhGKDbWMDbYf6C0yto8I6ZhRN48OVqyF5+6JJ8UHn44u4u4BYHGQbQ6iPQ1XigVV6gQY7HV1cywM4SgYQHI4OycToDaEUQKO+AVpaAwkBSzZeBhZ2HAXTgIWg1DWjpPCgMQOEC6oSjhyUjtNwE3fgByiugjjbYD+AoBt2E8h6SmqBx8x86EADKA6BVOKB8Aiq3QCvOQPaCr9cEximoDgOZJ6HsDo4TUNyDBmZAgyig8h1UB4Fm/UGrd0DuBw0WgQYFHJMOg28LANVz/GJa4JsWFPTjwIOvSsBrFUE3JoDcjDhHhQE84AIqM0CD5q/u7wWvKAKdp2DoPYUBVAeDBolB6Q7kHnCaBPoBFB6Qw1Hx13OMBPMSw4gBowMADKNgNARGQwAzBBiHdqCMdv7B8cc4FDr8uBqMVEmB2NMx5gAAkjpo2kFpKIBmolk5GEBLskHLVEFLgUGNTNAMDqgRBpoFBKkHdfpAjR7Q7AVothw0Gww6tRjU6AN1YqWAjTnQifGgRh5o1gl0yjKo0Qk6zA180BNwvymoEXzv7EwGUIcI1EAEnf4PmslC6plCQ+Y/A6zTD5IXkDQA6wHt5wRdcwfaSwlaRg9aWQBbAYCaLZA7F5Al3qDGH6jjqWZVDD5YCbS0GTQDBJq1AjU+QQ1PUMMONEgAsg80cAHqzILvRQcu03x0BbgH+j/kOilwZw+4RBPSwITNpDIitgBAUyjk5oPfDKAZZAZoIx3cyQYuoxcGHoAICi8x4On9oNUFkLus3zGAZ6CBjXrQ0nrQieOg2WPwUmTgYADqyeMMDIzoHS54/DJA+1WQuIcrAzuRkQF51QdoSSxo2TxozzcorJ/f2swAahCDBn0YkM9lAB6kBzqYzrvwEXiWERR/oPgEhSdkVQPwpHsRTXC8gWblQR0QUAMWNLsJPk0dOIMP2+oAngn8+wO8tBgUh7DZUdAsIWjFAEgP5JYDYMpjgtzVDlq6DFoRAWrwf3p9BRLCTMzQ9AK52QE0AAVyO+yKRLDvgZ4HncIOGtQAzUyCV3AAExzsNgdQ4xoUx6AOOWiJMKhTAN5aAhkBYIAd3AgakADfjAH0B2hrCmiZNWhZP2hAAXI11z9ooDOC4wU0aPT26UkGUBiCZjZB5xiA4hHUyQENNkBOAmcCr5KApLMn4H3UkOvk/kEXr8Dij4kBtO8apB+0EgEU7qBOAqgTBRpIAe3TBrkFJAbahgPZjvEfcqUZ9GyB148OgTs3DLBD5sBGo3b+YcUSKC2CzAOfBP8f/xYbjKIMo35CzYvQTEJ2CUhM5x9mOCx/gPI0aFZfTNGZAbT6iBF8NsJ7BvASe/Ds7y/wtY+gtADyO2jrD6wTCpr9hsy4Q1YAgMsq0GoZCIMBZBZo1ha8DQRp9v//f8ihmeBbJoCzuaBOL/jqPeBJ9aDOJ+TUe8gJ8qB0CdqqATmgE5akGYEz1zngG0bYgNth7p2ZzgA6eFLDuowBVJaAVrOA95ozIAYeQOUSaHAIJAe6mx4c8kC3gg42/PL+DgN4IBCYp0F2gdI1bFsXeBAYmJfAA6Q8kuBrWxmg5oLyJyj/Qq6N/McA61Q/v72VATQg/A249QhULoFXMQDNfnh5CXigD9J5hfgFFA8g+0BlAij+QatdQDPkoAEO0LkwoA4y6JwMUP0Cvkbvz08GBuhgBGotBzwskUOAAbSCA9Qphw8sAgewYau9YAOwoDIFtj0CFC6PrixnAA1wg7dwAW9g+AG9MQCkD3yuC/DMGdBANihPgdSD/A0+dwRYb4HMAqUJ0MGPsDNpQOEMumoVtKIIFPeg/AJaJQM68wU0YAIaxAYNFoDcClpNAcoWoIHR++dmMUBWc3xlgK0A4QIewAiy9yxwRRnoRhrQ+QGgK1hBqyo+vb7OAIpneJoGM/4zjAL8ITA6ADCaQkZDYDQE0EKAceiGCCMj5nLDERK/6J39ITfSTZNBG8y0jNEhRJ8RYISEJDjZMCI6gqDrjkAdI9DsA6jD8hd6tRFINajRBpp9As2igA5RAy0hBh8uB9xnDmrcwg5cAzXmQPpA+8NBS/vBSyB/vGe4sq8afFAU+GR64KF2oMOrEHudGRhAnRbI0mcGRPqGdjpA/gHNkoNmlUCzKcLS5gyghhGoEwhqnIEanaBl3OB7pxkgHWJ4o58R0hEDNdBBy79BnSbQ7DFoCasg8ApDMSVnBlDDG9SQBF2ZxwCdFQXdMQ/uDAIPOAQt8wQNCsBnooBBpqAfj+jQ49p+wIDc8UZrrIGkwIdPPQY3lEENSNA5BLA9+k+urQJvG5AH3i3/EHiNFGhWGjRLDDko8Q9GjmdE7t0zMCCWKTPCOl6wgQJE+QHSAz4tHNjoBzWEQXEM3jsOvP9eBrgkH3RgI+iwKsj5DyD9zOB4At32ANvDDpopBTWeQbPK4BlpYCMctK8VdHAdqIMLWm4MWl4Pupcb5CzQMlbQjBcDNJ7ElVwZIFdNMoO3eIAGBUBXCILSFmjACDTDfWV/DYO6VSkDaAb03dNTDOAlu0B/gVYpgDr6oLADd5iBKytAHe4zG5PA2wIgAzvfwGElAlw5AOrEgRr+oPQC2rMMcjdolQf43nPQyhSgmaD9+KCZRVDnH7QcmwG6jQCRhf6DO/Og5f/g/eIvL4FnhUEDBiC3gAYuIFkKEvewgQNwRwZoFmilCXibADDMQR0qkNtB4QnKd6BDLWHXZoLtBg8WwdIQJB5f3NnOABrYAG+x+faGAZSOPwGvvASdKwHa1w/qzIEG10BLxCErapihhzUyMoD2L4OWQIOuigT5EbTyARTGsFsPGJBnrf9DO5T/IXekMzBg6WwglWdYy2Kq11Xk19vw/AH0D+gARNDecHAnD7ivHpT3QXuyQZ1VcLxDB7xgJ8+DBqFA6eY/9FBA0MohUHhATr6HnO4OWq0C6tSCZowhy+NB/WzIoAkksyLYoKXoL+7sYAB1EEGdevDKD2BcgjqcoM4/yuAGMB5AaR6UH0ADP6C99aAD554BVyOAtr6ArviDDdAhCgVI3MEOdgR16B3i9zKAVjWBrrADDd6Czjp5cXs7A3j2G5zGGRhgnWZQ+gLxQB1e8EGF8MEFkA3I6QAycPQfdrc9UB1oUBjUEQbvfweGLdhN0HIc5E7QDDbI3yD/g1ZCgTrUoAFdULoHbb+BDM5cY4CtVkIu6OBpDJiuQKt8QFuqwINuwIFZbeD2M9BtGaD8AerIQw5OZGIAHa4HGvQBb39ghAw7gVY//IdfKQgd2ALyQZ190OAkKA2Aty0A7QHVF6ByBLSNBtRxB51nAN5iA3SYLPB8BNDBruAB8tfXwIOe4K1R/34xgFY88QFvMgANFoDqQnA8MUDSCoj/H3oDDCiNga6iBR2CCLpt5svbmwxSGgHgsu4/9CBBUB4FrTwB5VPQ4a6g1R6wuo5hFOANgdEBgNEEMhoCoyGAFAJDvPM/QuJyyHf20eOJTp1/kLWYAwBQx0Ab5IzwmRKwagZw0w8oB+qsgBpkcnpRDKAG5+e3N8AHi4E6ieAD/95cZwB16HiA15x9fXeHAdQhBy2LBt0fDdo3DBoIAHXKQMukIbP93xlAh0CBGk/8EvrgK+pA+65///zMANnTzcAAamSCOoWgjifIDlDHEeR+kP2Qjsl/8NVkIHWgPd+gBitoJgTUkQI1wJ7f3gY+FRnRiUEEPEo4AGfAQHvUQWaAZtVBV7y9erAffNgU6DwB8JVvb26ANYMaXpAVDZ/BB2D9+PaKAXY9G8hM8DJu4LJt0B3VoM4XbMsEahQjyhnc8QEJf1BHErTX9ef3twzgE5+BAybgrQD8sgzf3t8HL7MH3QgA2j7AI6wCWb6Nkr5QO4ngmTz4XgRGePyCm79QR8Ia+6CBFFAjF7SsHTSzDvILaOYJFJ/gZfjAa/PAnR1Q9wB0BR4TMwOsww1SCxoQAp2EDescgdLHidVh4GWsoHAFNb5BnSdQOgA5GRQHoI4JaPYLlG5Anf//0LvIQepAJ/UfWxnIALq+DLSnHdShAp09ATIHtG8bfCAkI2RQRxrYUAZ13vbONmUAHZQFui0B5AfQSg5QZx+U7sAz/cC4hy2XB7kd1Dk4vy2bAbSKhAGSYcCdetBeY1C6AnVQfnwF3SUOPewOaRAFpBzUUfsLPGwNtOQZ7L8fHxlgB4D9h3eUEQMv4FlJ+CARpBMA2m8OciMoLb99cpIBNMMHmkkFdU5fA9MlbNsHJJoRZjGxsDGA8h/oSj9QxxS2+gU0iAGboQYdngmKXwlVD/B2FRFZa/A2BNAyZlA6Bq0OAMUX6JwLULyA8gRG55+BgeE/AxEzjEidfFiZzYAOYGoYaV334nIvNH9A/QTKY6AyALS1CBSXoAEq0EAQqOwCxRVoJQ7obAfQYApo6T8kDX8E+wo0ICWtFcygaJjEAEoroHQMinshGTPwoBtoQBK0hx+0vQl90ARWDoA64qCwBS0tB3UuQZ1F8FJ5BtTONQMksYHTJijeQAOXoIHTh5cWMSgaJDKAbnUAD4RCt8iA8z04rYNM/8cAWRX1D3zQKujawg+vLjGAlsuD8gLIjaB8C7Ib1PEElXGQrMAEPMi1D3xCP6hMBpXj//8jzolghOYFE99ZwP33m8EhCu+sgweL/jDgWp0BO9ASdMDqfwaImZBzOWzBq4lA9oAG8EB1y3+UQQcGBga0cgs8UALstIPqINCAGogGXdsKdivQHaAVTaABBvCtJ+DBFUheBt/BDyzDYOdsgPwDimvQYC9ogAI2GAiqb0Cr4ECDzaDrG0EddZAdT29sAPtZSt0fvLIGPPAIWgUGHSgDDYSDV3wBr2sE+Q2Uvz8Cwx2cFqBhByqnQOeIgNUBVzmABnZA5wqAzx75/Z0BNBAMKqdAYqC8C1o5AHIDaOAGtm0CdjgiwyjAGwKjAwCjCWQ0BEZDABoCo53/wZQUsHXycTYih3IaplnDFzM9Y+1swjr+oE4csIEIagTxiqgxgA4nAy1HhTXqQDR4BcCjowzgJf9AtfK60eCliqDZSdAMGWiG9P3zM+Al6qAOGKjx/ALYCWfjEgKfXAyaXQTpBS2z/w6+vu4/A2jWB3b3OKiBB+q0IXfkQMsmQWpuHGkHL38GzXaAGjjwO9GBjSvIbOtlBtDMKGgbwqsH+8ANYNBsG3hvJcosPKzDhESDwgA6E/UPes82aAvCE+A+VVADDGQGaGYP1PCDzfyBOrggd2kAZ59f3tsLbYMyAv3+E7wXHXTtE+i2BNBeWtDKB3BHmZFQnDAgyiKgWjmdcAbQrNnnd7fBnX3wsnfgslRQgxTkNw7gHmHQsl9QI/sXcJYafE81sl/h9kE6xQzQOAZbwsgIXpoMaljCl/cyIGb6wAMCwM43aOkpaJkpKGxB++NBy3lBAw4gf0HuuAd2WoFL8EGNUlBnAdQI/QtsuKpa5INXQYAOv4JdZwVKQ+BtBEB7NG2rwDPUoEGi/+BGMmTrBCicQGELWlECWoYMkodt4QClC9CAECgOQIMFoM446IRwUGcFFE8gN4EGLECzbqAGMmgfL8j+H8AbGUCrSEBxCypDQANZoM4ZqAEOGvAC+Q2k58SacIbHwGXAoL234E4GI6TEAaVl0KwwaPADpB689/g/5F510KweyF+gQ/oEJQwZGJlZwB1+UPoBxdOdU5PAV7j9/4/lai6U9ABbav+fAXSdIGjmH3zIJLSDAtqnDcoLoM7pb9DVZwyw5eaMkA4Q1CxQ5wY0KAeafYSduQA6hwB0MCJoC8/XD/fA8f7140MGCVVPBlAYga6ZAx38BpptBqVxUEcFpB/EhxzqB+3kQdMWvPP/H3+nGl4sI3XyoUNODFgHccGSSP5hJIKNUvYz4qgJ/hNVQ4B0gzr24AMggfEF2lICnl0Fny0iygCKe5A8KExgV+qBZoVBKyZA/gGlbVC6/PTqMgPo9H0u4JWh4GsXgWaBVpUIAVcngcqC//B7/BngnVcGMJMRMg4HZIMGXEEDbaCbKUBxhD5ggDwLDl7WD+zwgjr9oLIRtEoLtKoFcrUfxO+gdAq+lhW4TQc0gw3rJIKvAwTeTQ/K29oOjQygayxB+9VBHUtuQQUG0IoCRojjwNe0ggZGQLcJgAZywdtIYDP44LKFmUHPtYsBtMoE5HZYRxridkJxgFiZAM7vwDAD5VdQ2MJWXsG2KEAiE2YeNM6h5RlooAvkhhd3doIHOZRN0hnuX5gPPixUBXhgI2i1EWiGHLRVAnRGDOj8AlC+AsUfaFADNMADMh+0JQc0WAbaxgNa5QTaygZaCQLKW6CVa6D8DUoHsFUhoO1mIH+Cyh/QChvQoa+wLQ7iik4MoFVB4DoPuCIBVH6A4gAUhpCyjRE8qA7yJyi9gcIYNEAAGqAA7/UHbg8BDTCABgVB+kCrKEBlLehQRMig7F8GUBkIrpvAtxrAVpQwMowC3CEwOgAwmjpGQ2A0BBgYGIZwQck4dN0+Yjr5uPIYTeMOM10wInUIGWCNawZop48BMuMOOhQM1IEDzYCDGongDg54jzXEPPB1eMD9piBx0EFO+u59DKCry0BeBDVQBIAnS4Mar6CD00CHj4EaOaDOHKijCdrXyS+uA27sQO6RZmQAzQSDGtUgt4EajKBT40Gn+oNsg3U0QCf9QzpwP8GHo2nZ1YBPUAd3qkGNZeDVgiD/gBpeoCXkoBlQcJsVOJsDv4cdLIAjr0Abj+pWJQywK95AM7igPeD84vrgU5dB2xpgHV5QcQFbRgo66A/cAQSbwcwA6iyDOougjhqoA3v//FzwYAp4rzcDrNMI6ZAz4o3//+BrBsF7cEFLQoENfMj93b8YQFdOgeIG1BAFdaRBDU3wFVD/0K5gQ4pvkHtA9oG2CoAa5+ADv4AHd4E681y80gyguATJwYpCQUljBtCggqxOJANoWSnIDvA2CGA4Xj/UDD6YCrI/GBywDCD1H4H77kGddNCsGegMBlAj9tuH+wyQ0/0hmQC87xnIfHl3NwPkEC8G8KqBH1+eMUCiCBJHoEEByNYKUB8JMlgBSkfgvcbQzi+oIQ9Zsv+JATyLz8IOXnIPuS4QkoJA6QZ0R/2xFQEM0sCZOdBBgqCZUVADGrQEF7zfHZQHgCsYQANWoDiDLLFnBHfcQTNxIPWgTiF44Al8ldp/cAcWtPoA1GkAzbSDD78EpjdQAx2UD0DuBMUPqKMImyUFuQgc5xAGohMMOqcAPkDwH9yYB91MAPIfaEYZ1JkAhSUTdJUFeEYSKa7hA6PA+AYdKAiasWaAzpKC0unTa2vAV0uCOoWgU9nBp50D/QwyH5QO1CyLGEDnTYC3KADdwieszmAMnMW9Boxn9M4bUTP/kJhkQK1XIXEIOigNtJybAaVzzwTuCIPSKLjMIaU+hnX8wOaBLEbvaBLX+YcMjjHC0yCoI6cCPKTx48uL4OX4oFlxUNkHCmvQgXyg8g18lSnwcE7wlZFAN4PyA+hAVFAHDjSLCx78Ai7/Bi0rB6U3XuAKHdCSfQbY2SCwEIL6AT5AB8+3/8FnkcA6/7ByBpqTYBmKAR5HIH3QQRnQCi2QAvgALrAMBw36gPInKN/BBiFAs+2gTi3ogD5QGXJlXw34thZQmgXNRjNA8wYoLUMOb/0O3pcOHgD88IABvhqFEZIKQStUQPkFlIcgy+u/MWAOADBCBjqAekBbY8CrTOADCTBvweINQqPO+mOPU1BaBm2HAg1egUwxC1zEcP1QCwNoAA9kByjdgwZ1dJyagQM0yxlAA7egwRqQ+0BllqxWCANojz/o8ERQHhaSMgZvawKtvHlyfS0DaOANtBoMNJACXgUC3A4FyvuM0GsbwdezsnKBz9EA3YgAKy/BB4IC8y4oXCAHH/5jgA+OAIMCNDinZVfLABpcBQ2gglPx/z8MdjE7wOWyELAsBg02gFaOgAbIQYOdoIEk0CA45AaO7wzggc+fnxgQqxcYEACtnmEcyu1dBuqB0QEAhlEwGgIjPQSGaAca1oAa5NE34jv5uOKHkZbpDn/nH9J5hXRCwTPA4A4V5Fo30OwCZIbnJ3gJvoSKGwNoFgXS0WViAM2agPaIgjoPoIbNsxsbwY13UMMINFsN64iCGsmghhVoKTLogDXQbCKokwg6eAo0IwyaLfsP3lsJarT8A19xBGokgxqNoCsCQQfNga+zAm5JAB98BQwv0B5OkBrQnklYQwdyOvN3Bk2bSgZQ5x98ZR/wjmdQxw3UiQI1jFD2waKHO7ThCjo4DbQHFjRTA2rogq43fHRpKXgp513g4VqQ69g+MYAHHYCrH0CzvRo25eBtAiA3gZf6gw/++g/sHFuCtwWATu0GhSeIZsCzZBp9WSxiYADa0IW0lxlAfgMdAAVaEg4O26+vGN4AV2SAlhuDVzogRTu8kQf2LyM4jiBXzn1kgBy4xwxeSg9qyII6XqCVHwzQpbfgvarADqm6ZTEDaFAAdM83aAsCqPEJuvIOtJ0DchAd5ER4kHtBNziADycEzm6CtmtA0tFXyKFyUL8jLxcGZQtQxwjUGYEdYAUyB9zJBZ1mzwg52A8sBry2DnSOAygNgTowoJk40Gw2aMUDaNaLAXrgGsitoAPaTm+IZzD0mgze/gFqzIMOnQR1AkCdCFBHDuR+0MAHKP2BVnGABhHObckA35sOnpUDOk7LtpoBdsgbyE5QxwHcOAftiWaEHDQGPiQMOOMGmj0HDXpdP9zKoA48gO3Lm5sMIL/CVovAkhyoowAKW9BsK/xkctC2CUEl8KoBUDr9D++4szCADj0DuY0NePsEaGABdvUYaIaeAZomUBrzoPiHdqTgdgLDRtksmwF2RR/43nWg/0CdGJAbQJ0b0JYa0EFroFUuIDZoIADUkQMtK/8PvScdfzWD6DhjqoN0/EHpFnSiO/hQuA8PocogcqBVB6BtGiBTwCs+GBjggyP47EUMfDCBtyOBV+8AO9dYi1ZsqxUYsZeToDTHxi0C3hcPWpUEKi9BHWDInvQ/4CXpoLIMlO8gq5dg5vxnAJ2yD+qUgQYLQOdmgJb9g1ZagA7EA83MQ/bEI3VggVpBdoA6h6AyBhS3kIFXUAQzgcOBAZqHYZ15UBoGdUb/ww8chQwsgsIKvBIF2GEEX58HvIkFMuD3gUHVogC8cosJuAIANEgJGuiEDwIAy2HQihnQ4AR4wBQ0uPQfcmAlKD2AyhbQNZqg2WlQxxi0VQB09SsovYDSM/hATLDlDAygwVrQsnZQuQzueAMHZyFhBIlJWNkGCh/QwZSgAWAeQUWw20D1DOw8EPigwf//aNtNcA/ogAYyQLepgA7zBJUjkFtY/oJvcwC5BXQTB+hsi9PAc0BA+R6UtiHbAoDDIMC9+aC6CrSFBjTQChpkBa1WA8UH6JpU2PYB0KAkKE5BgzygPA8rs0BXG4KX4ANvTYCdvQHyMXhVFHCgBGQfqJwD5UNQOQ5aTQRL26D8Cb5FB3jYJDhNAwcUwKuggNu9QHaByhHYiiXQgAN4mwoHH/hcAVCaBw00gcpAUN5hhLUL//9nwJoPcGWo/8QOlDEMGzA6AMAwCkZDYCSHAOPQ9Dzj4HM3ro7+aP7CEgI0jz/sDVuISxgZQHsXYXeig5ZQgxpbuk4t4M4krIPknHqSATR7DTrkDrTUENYRAM2Kg/Zigw5jA+kDNQhBLQ3QtVOswEYJqOEFmvEFLdcE7WUGzfSDBhRAnS7QDBT4HADgMntQAxTUUAbPmAL3NoJmst89O8MA6gR9Bp5qDL7C7T+oQX0YfEAgqBOkCeyUgcwGXVf25vER8OwTaMABvL8Z6DnQzDao0wKaYRQHHuAHX778HzJjC48JWCOJEdZxYQLfKQ1q4IMaxaCOEaghD/IzKJxAjX/waecM/6ETl0zg07dvHu1iAMmBOqfgbQugzhuw8QzaGws60BDU4AMPKPz5zoC4vg01boi/qxy0RPwP5NR2uBGQRhtGcoIOaoD9ywjpZIFXcjAwgq+hYoCKgeIPNHsJapyC9+5/eckASyOgjjDo3mpQ4/M7eHYeYhfo5Op/4EOy/qHM/oHCCeKs/+ATqUF7VcGNbND1ZsAVI6DGPfgucbAiRmifBjIIBWu0gpbbgjqDoAMGOYAnjf+FLn0F7ckHdVRBbgKpBd1IAFoiD4ofUHoDdXJAciD7QP60DF0FTsvgTgT4EDPgEltucQZ+US1w5w3kR1Dj/hdw6TMo7YAa0KAlwaDtI++hd2kfXOTEAJrdBzX8wQdzAc0BNfjBHQFg+KkC718H3dAAOswQtGIFtEXF2GcmeE81+L542Iw+yL+MsI4uK3i1Ayj9gvwGSqvmwcsYHl9bDR5oAadXqD7QIW6gzhdkL/hHBtDJ4pAOH2LPNUoLH54I0NIXKD0CDw8DbeeBnSAPCiPQ1hHQ8nXQTDZothg0CASaBT63NYMBFNagFRyg+GdAm5lFKc1QEh4sLyHilJERwgZ150EdKR7gXeagczz+ALcwgNzglHyU4QHwEEvQYWyQGz8egQ9xRJ6gxFWvMDJCVg2AOj6grUeggZJ/0OXVDAyos8cMhDo3SGEHWvYO26fNDkwzoEPoQDcBgAYwQMu+QYMjoA46aHYXlA9AK0xAg4egFSzgLSZAd4FWkoA6x6CT/OWBV76Brgb9Bz5Q8BcDqtsYwQNzoLQAuqIRdGgmaAUKaE8+aNABNDMM9icDZBUMA3RgDKQePGD59SV4yxGsswwapAKfwQJcdQM+YBN4uCXoLJLnwMMhQekdlHZBM+SgvPkeWtaC9ML230O2FSDyNSgfwg41BOUvVk5BBtCSedCVdKCyGzSQBaoHwFtNoOkcFFbgayvZeMDXGYIGFsCDk+A4QZS3IH+BVrKAZuZBy+tBfFDYQpa0w84oYIQuIsHsnGItN4FlDegAzHdPjjOAzycAllNKwC0AoLoAtAII1El/dnMjeAsMaBAEdMYCyB8w/4PKHtDsOsh/P6AH2ILOlYG7HzQYAcyfoDoIpA80yw8aLAANZGg71DM8vbEeMpAH9CtosBV0ngHogFrQYDZoFRL4MFxgXILqF0SYMDCAyhzQwABoYB00iA5awQRKDyCx58ADHUGDNqCyDVQHgepAUFkNueHmM7heAZ3/AiorbKO3g69BBZkPKtdBZ6T8/4ec5kZbY8ghMDoAMJoeRkNgxIYA49D0+SDo/GNrlI1mJCJCgBHS4KN9WGGmbUakRi5odhZ0CjFoPzWoIQNqdIE6M6D7rkENPdDp8tcONjGAZ3aBe5DhM2vA2UpQBx60TxrUyAXfWw9tXIMaTKBGCnhmE9hIAnWmQQ0gFuCsBmgGFtRABzUMQcuQQR038P5J8H77PwygK85AM2CgxiTonABl0wzg0sdV4GXLoKsEQQ1uUGcM0tjXZ7h2qIkBNnMDasCC3AuaLQVdtwabRQXt6wSzQe5jhHVrUcMFMYMI6aCBGlEm/vMYQLN1kCXizxgYkJZmg2ddGSG6QNsbYDPlIFNBDWtQgw3UWQYNfICWaIIanKCD7EBbKqD9XgaYS4hNA7BZP7h6WJsYrcOHog4qx4g0ky6l5sMAusIONHsEcisoTkGzdKCBGtCsH2SwBLbigJEBNKsNOtAQtGccFP7SmsHgQwhBnSNQhws08AGaMYPtYUXxDzDMvry/x3D7xARwhxd0dgTornL4rDUwHYE7V8CzAkD7+EF6QaEKarBeO1DPIKMVygDq9IsDr2QDrVAAdaIg1+j9Aa9AAXWOYXuYQSs8wPEA7PydXBfNAFodAlqBANqvfXxlEHAWfQ2DnF40w5GlnsClwIHgBrOgtAm4IwP2MzCsQJ0UVuCqEdDBXqAwAXUAQDdAgNIYqNMNaniD0jeogwXSAwpr0GwpSA7S0fjLANo+AroaEnQwHMjv4JPFGSAdN9BZEqDOt7CsFfhaOZAZoNlC0IoKUD4Bzb6D/AC5XgwUB/8ZQHmBi0+aAWQPaLb509sb2JMMRpkCS+PInSboDDFQraJBAviaO8j2BQMG0PkSoE7nhR354FUToI4/6LRx0JYVx4QDDO+fnQYPjsE6rox4lw+D7MbE4PgBdoDlDeIZQNdBgjqgoAE+0PYI0FJy0MADI3CVB2Tp9n/8WQTqX1D8KholM4BWE4FWM4DCCZR+wCtCwCaQOKPJCHE3qDwEpS9QegMdgghyO2gFE2jmFXRAIqh8BK1iAHXoIQfEfQWfDQBeDQIsz0CDMqBOMmgmHqTnL/h6v0cM/4CDnKCrAEEDougRCSpLQYNQr4BniYBOwAeVxaDVN6AOI/ggR1A6Al4LCkp/IPeB8iUo/4Lc+PfPNwbYAAeIDxqgBc1OM4AHK5mA4b0HvP8dNEsPSm/SGoEMoNlm8MAttoER+IAPcMAROHjkCBykAe3pB63MAg0S3T83m0HPpRNYRm5nAB/YB+x0g0IOfIAeIyN41Q3oFpAv724xgNI2uLMLOvEfXvTCC2PIlXu/v4JXOYAGTEGreiRVPOGDd6AoAeVl9EMQMTv/SHENcv9/xCAZaLUUqFwG5UtQuIMOVAV16kGrLkB10lfYNgagJDj8gDecgDrsoAFIUBiDV9v8R81L4JVS/yEHKILSH2Rv/ktw+QhKI6CwB507AprlBw38ggbaQANFOo5NDHfPzmCAlV3I6QAUZrzArTfgaw6BK7FA9oJWEoAGxkGDKiC9oNU7oAFY0DYe8GGRwLCHHIj7FXxjw+OrKxhA5Qqo3gGlR1BZJqMdihgMZaAmGPorBkYHABhGwWgIjMQQGIKdf7p1HjHTA3qHfzTPkBECdBu4wUzbjOidReASQ333XgZQwwW0xxXUOATNvoKWGYKueQItsQbNxoBmuECnpUMaFJA92qAGFKhjBL6bGdhQAe1dVAcuhX90eTkDA3QGHHQNE+yEdtAMCWigADKTqgteVgtuJAEbUKAOKaiRBWrkgmYiVcxyGG4d72V4eHkp2CzQDBG/hB4DaEYVfBgecD8taBYW5AYGpIYqaH8+ZDnnXwbEbB9oxhzSmUKOLeS0DBdnhAwAgBr3d09NZQB1WCH+ROypZ4T0/sEdWlCjCxR2oA4AKLzApzYDr0UEzWbJ60aB93DDZjQhsQFyB+QeetByYNBJ1qgpCLkxhRp/6HEHnr2HdcKQ4hVzoAAy+wo6U+EzcEk6aHAGNIMJmwEENc5BgxOghjuoQQpZkgpb0s8MuSoPuL8ZpAfk1jePDjOAOrWgGXPQUnfQtgAB4KF3sG0DDGhbHEC+AA2EQPwJXanAAHETuFPFzssASnMa1uXgmUKQ+0HLdEHXTYLCFkSD/ApKm2c2JQE72MUMoAEHUMP2zKZk8LYUUIP95NoIBjndSAbQVCHoHANb4L7Zo8t9GUCDWyC/Pzg/jwF0LSNoEAHWoQctST6wwI5BWjOIAdJRYgabDdreAvIXbC82qLMM6liCOmeg9AVZoQKJS5B7Yfeeg2ZuDy/xALopk2HPLCMGUEMese2EkQG0XcTUfz4DaDAFlKdAgzCgjhsoHEAdCNBKG1DnDnZg3H/ooBOoAwDqaIJmb5HDlxFrWQLreDMwwNXCOi6M0HAH7kMGLTMHDQCC8hxo8AI0gCKqYAfuJIK3k3x6BL4SEDRoAeq8gvI5qBMD6jzC0izKIACsXkKiQbPXkqreDKDtGLCZelCHHbTqB9ShA3W6QANsoEER0AGeoHgELSkHDQKC3MUEuokEbBl0tAvZDlBMAwe2YDc2gNI1KNxAnSRBaVPwzC847KHL4wnO/qMWDuD94qCVIaA4gnUIQWd6yAHPwgBtXwLl7xd3d4K3+IC2DOm7dTOAygHQFaSgcAcNbIDKS9CqIPDJ7B8fMIA65KBl35D78FHP6QB5DVSmcQLveQfNhIPOpAANioAGDWGzuKDwB3X6DTwnAs8+2QreLgXengK8bQS+bQQU66AOIacwA2hAC+Rv8AAgcLANNNAC6ryD9pCDrjUFDfghb8eBpydGyNYLkD9gS95BV32CzgABLa8HdZpB6RiU/2AHd4JTHdAOZeABe6D0BOrsglZlgW4QAA12wK6ARS6v4ekIGI+gjjno4ExQ/gLFPWgLgLpVMcPr+/vBN7yABgFB28lAA64QfeidcQbsgBGyTQc0iKNimsUAKrNso7eBzQRtFQOFNbjzzwArmyDGQA5p/Ac+tBbR+YeW38BBKlD6hdx6c4MBlE5AM/Ugs0DL72Fbs0DhB6rXQCsKQHnBEBhv34ErCu6cmgI+eBO0CgaWLkEbHMAlPjCvfgYOmoBcAa6jgGEDqo9A53+ADpYE+V/FPIcBtBoPdJYB+EpJ4HYDyMF/fxhAg3igLQ+gVRlgnwDTAijdglddQQyFhxPx53gwDGsACvf/DKNgNARGQ2AEhcAQ7fzTMYYYGRhHcwQ1Q4CRka6xh24Z1k4ksJENaqCAGqmgBguoIaMAnKEDzeyCGhla9vUMoBlV0MwFaKkkbGYfsiYT0rkGNTBBDRHw1VbA5eOwjguo0wJamg1uKL29xQBrTILcBT5/AHSYGSPk3njQzB9seTOsQwUzB3mmB+Q20FJacCfuH+zEeFB/H9rJ/w/dK4q0ZPk/+vJlXEuBGSGdJ3BnBVdMMUKGDkD3MoNmY57d2swAGtgQlrNmgA0WQDpKv8AH0YE6NCCjQJ0D0B3rJ9dGMYD8CtuTDhpYgW2jwLQSkV6wxR04HKEDEtA1sgy4VgCAG+4CCgymAfMZXgJPxgatxgB15kGz2mxcwuBDFe+engq+XxrU4AQf0gf0K2jlBWgWDNQJgu1pBnVuQHuBOYFXEEL2M/9mgOy7vw+ezYP7Azk8oYMrjNB9+qAVJKAZOW5BZQZQwxbUUQLFP+iwO9CMIqhRfnlPOdgoXZcOBkiaYQHPJoIPvwMKgA9jA6YhUBqDNLJZwId1gcIXckq3IAPoBG9Qxws0yLBzqhbYnOCanwwv7u5iAJ+kDzwwC+SvU+vjGPzL3oIPPgPNvoHCE9S5BDWswVfxfX7OAOpg/ofui0Y+AR+kDrzSBGg65P7uP2BzQHaD/MYAXfYMOstCVjuc4fbJSQygpdtfgdc3gjo7ogoODKCDMUGdYFBaAHU6IQNr/xlgHSbYShfUk/cRzVbcW0j+MyB3MkBhBbqPHpafH15cyKBolAq+fhOUh0GdHdABfaBBIdDADqgTCQ4PUL4CdibgeQlPHpJQdgfPOIP8A1rVA+pwgvz74Px8Bkh6kmAAbSkCpSmQ30GDD6DlzaDOM+hMEJB9oM4ZyB2gwQfQSfSIjiqkEwZOD8A0Bd4qwsrNADq0FDRwAeo0gu7NB606AXXEQANwiFVCiByGq/PDiDSohigHGBlAA0dPrq4CX7cJCifwlhE1XwZQhw/kD/DVlaAtMaCD/YADN6AtIaAl3aCBQVCYcvPLg0/Sh+83R8nskIEZyNJ+ZvC99KDwAK2KAcUT+NYP0C0QwBl0UD4BdeRBZ3GAymxQmQMyH3Tg43/4KiWgeUzM4EMLQYNvoOXs4HgAdj5B12SCBvBAg5Wg9AcZ9EPMlIPypbJpNgOobAB3gmEHFQLjG+QWkN9B8Qliww7vBIUZaFAHFF8geZAbQeUdqIwBpT3Q4IwKcKvMfeAgHOhmC9DqBlj5AspnoLrmw4vzDN6FjxmOrvAHl5ug5fQ3gFurQAMboEEj0OoI0KoFkD2gzjBo6TvWcp0RfeCUmQF0m8f1w23QGXcG8KGeoJU+4MEE+CoBiD7EQBXs7BEmBogYlGaADOCC0hgoL4HiH9TJZwDnD8gNHwh3QdRq2FQw3DzWzQCqM3iB1+OCVpaB/A0OeyxnwsDKSNAKGVAyEVdyZYBsFXoOzldgvcC8CFphAip7PgAPqASV46AVMKBwBMUfaGD39MZEBtA5CKAbHFDSHTTvYs0D/0ntCg/9rvPoCgCGUTAaAiMpBEY7/7hiG+vM6GjmoDwEBrjzD2swQzwCTf+MkOYuqOEI2o8LOh0dNCMHmnEE79V+dAR4HdoKBlBDB9RJBJ2ID2oggu/CBjacQA0V2DJGkD5QZxbUUAEtVQbNLoL3wgIbouDT2MEdQGYG0HJpUCcK1BCCLP/+zgDacgA6gR50LSBklhPkyv/gPi1s0AB8JzTQTti1ZgwYHXwGBqJn+bDFBVwMMh+APboY4cH3B3ivO6jzLwm8Qg3UiQOFA+jOdFDjj42dHzzbDDoYEXZAF2hf+KPLS8DLZUGzvKCOAUj9O+D97ojZc2zJDNYwhZVZjAywPd+M+Dr/kAhngKsBz7JxgTsXoIY6qIMN6rSD99sCVy2A4lRCxZ0BvPwc2JGB+B/SMQHNZMJmyUCdOtDedZDVv8Enn38EzuALM/wBnzz9B9xJBlsNdRusMQvangHyM/hwSKDhoOus5PXjwas6QMukQTOeoLQD6qyDOgygzg1o3y5oryvsLnbYjBrIfJB7QekH1LAFmQ0+/Ro4E3pkmQ8DSB+owwNKfzumqDHoOrWCZ/JAS5idko8zgG4AAC/rBg4eCEJvqwD5CWQWaLAKtAoFtO8a1LED2QUaqAB1NEFLhkGxADrzQdU8n+HiziIGUMfk8t5K8A0RoLgGdYCUzbIYnl5bywBZsoyIU9DtBaADKUH+AB1cCBrIAKUX0EoSkH9BjfWv7+8wgGb2EIfEwVawMILzA8h+RgZEvIBWqYDCGNTpAoUhIyNEDkKDDvREHhADz+kygM45AC0pfgs8P0MdeH0l6LpMkDtA+6JBaRPUyQLt/wd1yEEHpsEPiUPuHODIQ4zgAUVWBtAAFyi+dZ3bQBkTsgQdmAb//v3BoGlbyQBZ0v0a3LEBrfgAncIOO7ATdCAcKHzAVyl+ewu+JQJRYyPnBwgbdpAaKP2IyNsy3DrWwwC6Ng50iOh/pGXgkFKFuA4Lwj6IetAKKVD58g96GCKo0woa3AMdAAg6awI0uAGKB9AsNWjZO2g2H2SfDvBMFdCecNCWCtDybkh5wIBaVjFCtoiABhVAd/jDtjuBzlIBzfiD0iVo+wp4awQwDmDbWySAy+RB5sFmqyEz9pDzSUCDMKCweHVvNwNomweo/Abl4V/AE+tBfgB10EH5Dpbm4AUbKP0A8wVoXztocA+05B9yuN9/8CAh6BwXSDgA95TDz7dgZADNOIPiEdTZBK+G4hIFD9Y9vbGOAXS+jIJhIsMr4I0foLQNW5kCG6wEuQc0OPb4ykrwQX2g+ge2tQaU70BlBSidg/IWyK/gbUQM0AFfBgYC5f5/BpB62MomkHLQeTOQuIAMfCAProLKFZA9IDdC6rn/4AEA+CAAsD4Dr0769ZVB16WdAbRaBTTQ8x/qHpRBCeig2etHhxhAdR5o0AQ8UAQcyIHlKYwSH1ongwbTQW4EhTWozATlSdDKCtAKF8i1i8ADc0GrzT49hg66/gdfjwtafQbKS6BzRUBbBMBlLvAARvAgBQOBtP9/6HfmGcgAowMADKNgNARGSggwDj2P0rjzONrpp2GSYER02OiX8DDTOOpyYag8NF2BOjuywP3Wz25tAV8tB5qdBzXAQJ1BFWBn5jnwDn/QlUnPbm6GXKX08TGDsd9s8B5iUKcI1FgC3W8NamSAGuGQA5Qeghtm3PxyDJC70L8xgM4BgHR6/jCAZnZAs9Ggg9NAyxZBd1fDZlFBbgUtIQXNbnwD782EHQYF6wxBQxLVGwwkLViBxQtG/CB1NbDmO5ilEDeAGnUPgPdLg5aNgw6PA92X/+rBAcgp4MB9raCOFGg5K2hGE+x30I0HwI4zqBMEahi/frCPAdwgRm98we1G7vCA7GREGQAAz4JDO32gJeqgvdzQEwoZELOZTAyg5dSg0/NBDULQrODrhwfA+8ulNPwYQNsqQEuTQY1LUGcD3PFFChfY9Vwgl4Aan6A4Ac1OgQZrQHviQY1/kH5QIx0+CANUDBo4Ap0ZAOrUgman3jw8yABbQg5aSQJagv/r5wfwKdbwQ79AXgSGBWgQAHRwFuicCVAnDuQX0Cwq6OBK0P5W0LJ90AAEqPMAPpANOCMGWrmg7dDAAApnUCcfNhOsYp7LsHOqJkNI3R/wVYSQwYp/4Flo0PJYUOcbtPwddPUXZMb+HziMQY10WZ0IBtAADajTAPI7qCMAOuEcZDeoAwbqLIC2GYAPBgTOloLyAeQ6TMhsICM0ymBbNhAdBUjng4mFjQF0sBzILlB4gvz85uFhBshgx29wIkNZ/QEyEDSYA9w6oWFbAb59AnzwHfCAScSMHjC0QHvFhZQZnt/cxADbvsEA7aSAOhKgwy1BM4igGzXAM5HAfeug++pBs8ugFR4gcVAnFxQvsA4gA3oHAkseArkVFDawGVLQeQePr6xgAA0QgmZLQR09UNkCOlgQcnf6XwZQ5/o3OB28Bx9eBup4geISlLZAq45gaYoR1lEG5w1IPgAvbwfyQX4ELRMHpUNQRxmUFnF2spALYjyDGpC4Y4SrBnWGQf4ApZePLy8DV04kMYDSNGh7CWzgA3YiPuyAtxd3tjGA0i/k4EjE1qT/8CXnjPDCDDRwAEpPoI4faHUKaMk6+CBR4CoZUBkMKg9BK1lAYQqSB2FQ2gcNNIHPZ4EPiv4Hb7sAHfAH2kIAupLw6oEGBjlgWgadJg/K74KSBgwgP3yBLTcHBy4T8LwVawZQ+IEGUMDbRIAHf4JXWyGFE9jtUD64wwscCABdGQma2Wdm4wJf7wraYgTqvP+DlnegKyhBeR2WBmEDVJCONQM4jGDlFmj2GryC4NcXBtBKHtiqM1C5BMrvIDtBeRhruYm1kkXu2CINHKCpZYSmZ/C1nQLyDOAtb8CVP6CDAkH5FJQXQO4FrRgCDeaBtgmBth2BzgoAzdKD4ooBWn6BKaRDKEGxDK4fgZ12QgPVIHcY+Uxn+A7tuIMGxsHxDQxbUPz9g97xDxlM/wP1xX8GUFoArRwB5R1QPgCFPUg9KP4g5e7I7OAzEACjAwAMo2A0BEZCCDAOLU9idE6o5/zRTj8dkgLjQKQ37HZiHQAABQHIjcDG3Kc318CdctC+U/B+WuBhVaBZUtAeTGkNf4b75+YygGZLQZ0UUCP14YUFDJCO1z/4LDPoBHwj76kM94AHREE6bZCGHWhmCNRJAu1BB60MAM2GgGZOH11awgBaRn8N2Djl4JMCH84GOoAN1JMHDSyAGnmgcwhAe05BnQH0Zc6wmVBQwxzWSWRggN6xjzEaQGxcYKpjxIhHRnAHkQl8b/t/yJJV4GwcqGMM6rCCGq+gThBo1h90iJ0G8Eo40D5n8I0GwDAHddjunZvDADrsC7ZHHLNDwADv6DNAZ3xhp39D/A1Zogrq6IJn84CdQlDDGTQgALmPHJq+gW4HDbCAZsTBy9mBh5GBDvwDdb5vn5zAAFoNwCusCj4VHzTTBO5wMUBuS0AMICDnlf/gGSfQUlOQv0CNflDnBjxo8B925RQj1O2MDKABBVDcgw5nBDWgIf5lZACdDwHSA+rMg2aDwVsigKsIEEtpGRhAdkCSKGQprYi8DQNodhDkP5BbQR1Y0B56WMMa1OEA39sN3AO+tU8GfPhgYNVXBtCp2qDDLEEYNOO9a5oOgzJwPzBIPcgs2K0CIDeAzhcA3S4AWm4MGrx5AEz3R5f7MYBmIWFugdzkAGpM/wNvOQDdRABaMg1qkIM7KLDOHTTdgDs7sOgApUtoRw204ga0ugC0PxdkJyguQKtJQI128PJpeAeCEdw3Aq10+AY82R3kFtANF6COCGg2H3R4HuiwwptHOhhAM81g+4Dne4DyKfiguD8/GUCDGLD8A0rh4MPsgAN5sFUDIDNBcQEKn4eXFoO3kkgBl7iD8hN4Nvs/cscJV15ihM+WguIB1FF+CZz1Be97B175B0pPoLAGdUhBM7mg/ABKA8zAQRDQ9hPQloN/wBUCoC0gfGI6DJDOy18G8OofRkRHGZQPQFuBQGURaLASFLSgMgI0yAbaSgGe+Qctx///jwE5DaMsecY32wmLN1gZAh1wcEk7Cz5bADQgBtp7D9pyADIffGYKOx942Tx40BIYrrAZV/QZYZBb/2Nd9g3JE6DBIMh5E77Qg9zU4Td2gAZqQDclgJaug8IIVDaC8h+oc4dhD3j2+R/YB6COKqhMB13pCKJBcQrurMLChxG6AgFYhoBWDoBuaQF1OEHpGrT9B3xrBFJ4QQZGoOXT/3/gzjuoswpK/6BBOtAKmlf394BvwgCtiAAfLvr1BagygJfKTOD78HkYQINOCsAbEmDX/oE62KD0DDqgE1RXgNIRaDAJPKACtAuUv0B77bFtefnPQLiDy4heLyClK9CKCE4eCQZZnTBwPIO244AOggSdgwE6SA+UrsDxB7piEmgOKA+BVs2AVt+ABstBW37As/MM0FU3YMUwN/0Hl4WQYoCwO0GDiKAwBQ1CgOoLUNkNijPQKhnIzQGQlIRiHjD+tOxrGUA3U4DLcuDZAKABN9BKL9eM8ww3jnTAC3JiwophhABQeh4dGmEYBaMhMJxDgHFoeY5GnUdGBsbRZE7rEGAcyDDGbjfWTiwoHBgZoR14JgbQQVbXD7eDD7MCzeJbRWxgAC2pBs8CgpYtAhvVoMYOaEkpaLkmZPk/AwO/hD74NHVQox4yI83E8B/aMAQ1QED7ekHLJCEzOKAZi/8M/5Ea57BGPGwPLIgPmukFdcZAM6KgxhBo9hCz4cPIoGSUAr4lANQQBq0gAC3LNfScBN5veWSpFwNsXyyiwUioqscdd+iDKKAOpJJxKsODCwsZQG4G3Y0PGvwANeJBHR8BSSNwpwB0mj1ophk0IABq4B5dEcAAOo3/AXAQBWtnADmPguIHuKwapA90QjZodvAvuEPHwGAVvhbcqAP59wTwbAFQIxkyqwqZfYYkc0aw20Cz+6DlqqAGNWhvMWi7BmjfKKjDD9sHDKf/Ix2iyIivsweSg3T2weUKtKMECidd53bgXveJwCXyjgyg5ayg9ALq8IEPBAPONoMGAED78EFL78GrCj4+Au9ZBp2c/x88w8UI7lxfBd4GoANcRg6aYQUtTwfNzsG2I4DEQOnt1PpYBvu4vQwHFzkzuKSdAfqXlQHU+d0+SRkjp4P2+YMGl0DLrEFuObjQCazGI/cWA2jJM6hzBF7RALoKEdigBh3OB9u2glhODkq/oCW38uAly1zg/d0XGUADQJAtK/8hA0TMbOCzESAN9+/gTjUoL8CWbIPcDxq8AV+nCMxboA4zZAvEOwbY7DVy+gB1ysSUXMCHS4JmvEGHYoLuOwetogF14O+dnc0ACzvQCg1Q/gHFC6gTdvfMTAYGpAEFUAeMGXg/PGSm9Ss4rCGHEn5nAOVD0FJ00E0cj6Cz96BzN0D6UTteyHmJEew/0PkCsAEpUDyBOsKg0+xlgKeqw7YFgWYpRYFX04H2LoPyNGipOmhgB7TXHzRAADprwTJ0NQNoDzNsFhQW9qB8ANoWAuqAg9IC+NYP0P548JYkZnBaA8UraI87aF88SA3sCjfY8n1CM7AM0HIRTKENAoDCjQEckpBBMtBsPGiZ/9X9deBl8KBtQeAzNMBnAfxlgKcZ2Iw5cicVfRACmtdAq4pAg1ugmV/QGRmgeIbsq+dnAJ3+Dt73/eIiNI2AOuCYy+GRZ+mR4x3iNdT97eDtI1B/gswGDbaCOryg2fenNzYwgMPtP8weBnB5IqbgCBYHDS78h/sV6g6QvxiZ4GkYfmApIyN8Pz3IbNDZHqDBDNAgM2if/JPraxlA5xKAVlmAr98DLrMHxR/4/AhgWfkPvnQeMujAgL4qgYF4wIhWxsLChRG4ckYQWG6DVpDABjXBq5ceHwXe3CEN3g4HWmXFDt3iADqvAnToJGhg89f39wwg/8DLABTnoNY7GIPZGOUsJKxA5RRo1RZoZQmofAetRAKXDdi8Cj5fhYEBHi5AM0E3NYAOHYQN1jNgS4cMSHoYSAVDv+s8ugKAYRSMhsBwDoHRzj+kmzfa+ad5Kh+EnX+QnwkNAID224L2SoLUgWbcQAMAoOuGQA1eyGwWcM8hsJMCmoGANNyhSw+BSQrUmAM12NSBM93gg5WADREOblHwvnDQnfyghjjo0C/QXdqQQ9T+gxsp4I7Vf8jyfvChgCB9POLgThWoEw1qXIH2nIL3gIP2pcMjD9I4AnXyQLOgoMMKQZ0dyIFtPxhAM12gQQPkfY+IaIF2WrEmBOLyBywsQY1s0Cw1yB5QJw50Ojhodhg0KwTawgA6SA3kX9AMGmg1Bch9oP3ioGvdQDOVoGWkuNIjI1LHA3bHPajzA7ILdF4CaPYJNGMNukkB0uD8ywA6eAzUcZDTiwKfqA9fOQC0BDSIA+rwvwBu5wAtaQXdxQ4aDIDMNDOAO4CgjpgS8Eo10CFbIP/A28jYZkuhQcUIpxnhs/6g8AHtHwd1UsHX+AEPsQLFE2imEpaWwFeUAc0FdfpAZ0uA3A7qKMIGlRjBp5bLMIBOkQf5D5TGQGF7Yk04A+iQq9/AxjboPnLQqhQN2yoG0JJj0MAUqFO9d7YJA+hWgVvH+zCCF7R/H7T/HXLdISODomEyg5plEXgZOmjmEdTIBh2sBgprUJyBVhiAlveC0jfoXAxQnIJm6kEdU9DMJmgQCLSkGnYrBmT2nYVBVM6GATSIBepEg1YggGarQfuqQbOXoA45yN+gxjgor4GWvIP8CJppB+UT0JkAkJlaBuQUzwDaaw5aiQPaygEaVABtgwCfMwHMGyDzRIErJEDioLvIQW4CHdR498x0BtjWHETHgAG8akXbsRG8Pxq0VxiUFyHX1X0Hd9xAhxCCBoxAy5s/vDjHgL3TDMtLkM4/KL2pArdbgAYAQH4BrSYCDYqA4gt0GjxoywRosALUwQMNZoD8+f3zEwaQvt8/3oG3boAGDEGDUk+urgYO6uxmAG1FAMUDrAwDxYuCQSIDKH+DOjWgDut34DJt0E0NoCXroHwF6sCB0jqoAwcqx8CHLAJvDgF3hP+T0GGBDY7CYoERFAxInW0gHxRPoP3WoH3hoLwFSr+g1SNcAnIM8FsbsNmJIoaYJQZZBVodBUrvH19dBd/QAt4GIKTCANqCBT6Ij5WLAWQvbHATf50GGayCqIFdA8kAHigBhQ/oSkZQOgFtXQG5HXzQJzDjg+wEYUQZCl1ZBc3woHiDXJV5H2z0f/iydOh2rf+IA1rBCoBhBYoXUFkG26IDKuNBYQfKSx9eXWIA30LDwc8ASoegwVPQ6fqgcgiU50ADmLCtAOidZ4xBVHxxjFQ/MzKgFmKwcp0NeIMC+AwK8C0U/xhAaRmU7uR0Ixhghz2aBy9juH28H1zmgfbnw7Z3ga9ERVmJgL/jjx53KPU00K2gwQfQFhlQOEHOJEGOTzTd//9D8yliIAZ0BgRIH/KgBPVm/4d+5x8UgqMDAAyjYDQEhmsIjOzO/2jHn07pmpERacn2QOUl7GmdEeugBKLxA2rcgPaIg2YgQcvpQcsOQR0AUIcINAMKajiDZolAs2qgBiLkRGFIIwPUuZEDXnkHkgM1FsGzb1wi4FUFoCWTILNB5oGXiIJOUAe6BbRc+TvwmjFYZw+0jBk0kwvqNIMaeaCrtkAze6DlyaDDq0DLXRngy6oZGOAdcND+0p8fwQcsiQBnFEENMU5eafBJ46DOhUPCfoZ7wJlPWVDD7dUVBtTQQXReGBhgbOLjDeKG/wyIRjgkPED+BXVIQftoYY1CBmjDDLRCATQgAGokgsKRAbP1BxdhRJt5BO95B/oVtNQZtJUCJC2nGw1eYQCKK1BHFtQ5BHWyQR0RkJ2QaGcEz9iBrvkDda5As9UgNaCOmZRGAPjOalBnSQR4iwHoujZQo19WJ5zh3ZPjKK6DNRrR3QUOB+DADbicAXbaIeHCCJyB52IAHfQoqebDAHIzqBENOywRyZMM4OvLgJ2FL+BbIv6D8xDIDFBHQcEwiQHUgQN1ZiHx/48B1ImEdAgZGU5viAMPEIDSFqgTCFrCC/If6F747ZNVcUamknE6OA2BOqKg9AqaVQPNeosp2IOvAQTNhLMDB6JA5oIMAe/9B84Mgpakg8IdNHgAGjwBLd9XBK5AeXJtDQPyrBxIDLQCBLRqBbKc/ysDyM2gZcJMrBwMF7bngk8iB5ktCjy0DtTRBg3AgQYRQIMYkKvkGMDJEpwyGSEztuCONfDQL9jp7aB7+kHuBg2ygQZ4wNe+AbWB9teD3KwJXA4MOg0fNIuKfE0c2EzgEmyQm0Cz8qBwAN0EALrNArRcH7xNAzgw9/H1VQb4IB00NMEDHGjlCaJ8YQSvggAN3IHimp1bhAG0nBzkTtCAD3iFEDAAQXKgwQHQ4BkkP7wCd/pAnVst4BkOoM49qGwAXbMHWknyGHj6PsR6RvDKDkEpIwbIzPMf8Iws+CBEoH9Aq2xAy8lBZQZo2xIoLYMOfwN12kBlE+YKIuQkgqXshPoTPc2DdMGCAGQmKF5Bt4CA0ipoBQsovF/e2wM+NA/ZBuwdL0QnCtSxBZkLKv/AN0EAy6wfwD34oBlw0MnxoAE/0IoP0N590PkhoMFY2BYiBrTOLGbi/88AGRAEDvaxcjKA9uyDri+E7WsHDU6CloqDBrVAh4GCV9q8vwfeB88vqsUAWs0B30ICdCRo9QgovUHOdDgJPugPXOaALUbtpEKqRibwtaqgJf/gAziBV+mBVtxwA/faw7eSAdM5qEwDdVhBeQ90OCx4iw5wcAFUnoOui4VtUWKA2YO+7J/YAR7kuGVkZIAPlgLZoNUooDQN2iYEChdQ/IPcCV5t8/AQOM2BBp1B5ShoC9vTmxsZQFuqwOfh/P+HNFiGGrcMJABY/QJabQCrJ/9j9RuhTjisjmIYBThCYHQAYDRpjIbAsAwBxqHlK0bquXe040+nqIe0bgZBOsOddggNAIAO5wMtadQA3uMPOk0dtIcQ1MmBLLVmAN/TDupYgRo5oBlXUMcGMiMI3A8OPNQI1OEEXcMF6oCDZkRBAwKg05/BDW7gXmTQbBaoUQmS//jiAnjZPmjmGrYfVVzJGbzfFbzUFdjRAu1fBHWkQQ0u2DVzoAGC/9ATuCENZeRO+3/w0lFm4JJr0J5NkAyIfgC84gzUYATdtw/ef85AyhgNtoYVZhhjZFmgAOgcA9Dp2ogbDUDJA212hgG2Xx4kh2QujoYpqIMOamyD7ngGrSAA7ZF+dHkpcLsGP3hPPmj/M2iJLKhxDV92DE2boLAEnVgNamiDOtKgcAJd4QXqqIEGKfhENcBnAEAO7HoPXT3AAD5ADjQoA7t2D5bIwR0iRkbIcl7QUA+w8wXapyqm6MwA6gCBlvyC3ACKX9DsNmgPL2gAAGSvIrBTDzoJHGzGf+hMFQNkUAfUgQfNfkJm34AHkslYMoBWj5xaHwPeMgHqjILSMmg2GTRAYBGyHHzg2J6ZRgygjh/oDn7Q4AVo2bSScRoD6AT6G4fbMPImaEksaGYc1NkGSXILKjAcXODAAJp1BM1qgjqSoE4dKNxAnTbIIXm/GUDuA3VcQasTQFcWglYFvLi9nYHhP+LAP5D7Pry8AB4YAnXYQXu2QQMMoME08AnqQAtBKyMgndF/DKDVD6BOOCi9gvIGaCaUAblTA09gjAzgjjXw9gmQPOjAR9A2EtBgELgjCNRj7DMD3EEGDTqAZltB1w1y8kiC3QK5RQOWpv+BZ9tBcQLKm+CzPoAHV4LOhmBAueoPutSaARHzcBYjZNYfpWyB3lkOuQbzJ/hwSdgAD6RzyAi+/pCFhROc3mCDRpp2NQyQDjPwesY7Oxgg99P/Ac9yP766kgE2mAWKD1ntUAbQsnvQSfhSwLNJQPu0QQMKoNlj0GwnaM86yA+vgPfHg1ZKgAYdIAdMwu7dx9dhQsvfyHmRAVZ4QNTABrpA/W5QR/DhxUXgwY6/wGXroPgALd3+Az3TAiXfMGAC9G0VoJVEoEEeSDoAlm3Acx8YQMvsgeUfqAwF+fH/v18MoFlx0JV8DCjxwwi+4x60hQN8rgsDIo9BymzIIAr4/IXfkIEp0GCDbcx2hofA8gS0igLUAQbv+wfpBaZtUEf4OfCAWMhtJYzg8yjEFB3BgwOg9GcTuRl8WwxoAAeU18GDm///MSCnFVBeA5UJoLgCDc6AB0OBakD+Aa3aEQBuIwOVFVLq/gzvnp0BD/yBbqYBnSkDshu09Qm0FF4eONgMWhEAGrQCrQJCCU0SV3egpmVmBpA7QOXGJ+ABj9zAAzRBhyuCznsA5Xe72F0M57flMIAGukFhBJlV/88AWu0F2bLwkgFxm8t/NGcR6qQz4AZYV4owkAaQzMA6CPWfAvcxDH0wOgDAMApGQ2C4hcAQ6vxTsRM52vGnYzpmHCxpDL87GHG6k5EB0ln7ywBqtII69qAON6ihDdrPCGqAwma/1KyKwR0+0MzHf4zGnTcDqIEGmgEBLXMGNdpBjUhQgwh8qjivJLgxD9obC96bDLyKCjTbCemU/wd3bECNRtB1bd8+PmAAdZZEFR3Ad6mDGvigAQLQwAKo0/Pu6WkGlIYb6LAz4JJYUIMUdiI8aHkxyA+gA9FAs1SgRhy4AwTVyEgw3ohpEDGiuAPO+Q/uMoIPkcKIFbgADr1Is3gonWxgxwp0tgFoFhXkL1BnG3xFFLCBDh4UYQQdkge8YvEv6NR4pM4oA6Q0EJa1AG+LAC33Bw0igDrSoJUWoNUeapYFDKDTwu+dncVgFbaGATTAAIoj0E0BoKXhoPj7BlytwYDcSAQ6H3QAoihwHzDIHaAZS1AjGbSSA3bNF3glBPD+a9CWEFAnHsQHdRBAK0pAM+egZdng5bT/IQMhoE4xqHN9ck0E+NwA8B7ud7cZQAM4oCX6oFlQ0MznxV3FDKCBKtCsOeiwNFCaBZ3UDzJf2SSDATSIATrxXwl4tz0oTm6f6IdHjX/5OwbQEnXQygLQMnLQ4YOgWU9QRx28bBzYuYZ0fBgYQOEEauiDOhkXdxYygDroIPeBVkuABsu+frgH7VgjpRVQtMLS1v//DLAtFizAe+oZwdtbQJ3xPwx3Tk5kAC+7B8ffH/ASfdAyX3DjHKUxDjaQATa7i5xsQZ0jUP75DpwhltUKAS9NBg1ePLq8jAF06CJoFQEj1D0C4voMoPzG8B/SCYbNNIO2KCgaJTGAVjDoALcDgGaZUZaV/yduEAwSwIiyBLLiBTh4wIA4iwKU50Az5KCBRRAbdHo66KR50P75O6cmg29nAA20gMoIULkDWbKMfJYFA7isAq12AYUVKP2CDpsDzf6rA7dwgLZWgAYpQR1EMWUXBtA2FlC6Bg8mMCBuESFcOyDlWkZI/gHrQRqIQV7xAO4NA+MRlCdhg6KgNPsbPFCDsA1WjjLinamHhjco3FEKD4g4KH2A0hSoww4qn2EHzkGMZIQ6kxF8hsvP728ZYLcsMEBnpUH6QapA5SIofEFlLug6U9CACujsEml1P3BaBA0MgW41AQ38gfLUBeB1l6BBDrAN4GhmAq4IeAhetfH752dw5x+0EgV0GCKoIw9eKcPwHzETDvQPaHAJdAsB6DwU0GAJKM5AaVQIeGAnKM5B/gGVC7BVCJAtY38YPr++Dr7SEeQ5UKdbxTQbuLXiNgNoYAu0Ygm53GUgFTAiwgxUpoC20YCuZgWtOAKlK1AaA6kArQYC3WQBul4UVM6BBndAg3qgwQzQNjTQKiJQnpLRCmYAbUFhQB50wesmGnW8cXToqbf0n2FYgdEBAIZRMBoCwykEGIeOZxip51ZGBiLMYmSETIMSQ49mCuwhAAu7QRE+hOMc7wAAzA/ARgOowaNqlsvwDDzbA2uc/GcAdYRAp9tDToNGXuII0fzt/X3gPsnH4Ibny7u7GEAdzf/Ag95AsnJ6MQyghh1oVhe0dxo02wlaeg5q/MGuMwI1mECzKKCryUCdGlbwidpHwPdIfwceDgfakwmSe//0FAMiiTOCl3GDOm6g2RrQbCxoaT3ksDtu8GnooCuzXtzbxQBeQvkf1plANPoYKc57iLDHMAvJbJR8idSRgAU9I7oYIyMD5FoxNvCgC6hhDt4bDexUgA+NA175BjqhG3TCO2R/KjMD6E580PJa8PVnwK0RkF0NkLwO3tMOXJ4Pug0A1MGHrbwAhRWowQq6pUFIxoIBsm9fmgE0qwcaWACFJ2hVBgPSgA9kXTpwFhHYqQWfog+8qusz8CoxUCMe1CGHqwV2eMF6gQ4BHzwIXJ0hoeoFXmJ/bksGA2hgAdSZZmCEzP6DVkyAlvnqu/WC4xXUsf8H9CdoYAo0yACalQd1oiVUPcHpDDTLDDpnApRmT62LZgDN3IHcDPITqFP588sLcDkHOl3eM+8Og6ZNJQNILUgfZK/zJ/BsOei8CPDVWqBr8PhlGY6vCmEADTSBzmcAzdKDZpFBaQw0sAC6ZQF0QCD46jzwoXNMDCB3g8ITdK0jKI1CZqshh2CC0jWoIwOKZ9AKlgs78hhA52SAr9X7j9kphXWwwOrRsjUsjfyHrpoAdd5Ay+tB+eUD8EA4UAcMvMQePNAgAfYrSAx0eBgrOz8DaMAAsocYnuHBq25AK0dAA0LPb21lYGAgtkOCXuYg8WGdKuS6CCoNOqMA5AbQShHQMn1QuIPKA1AH9P3zMwzIHRQhKWMG0GABKHxBaiAHhEIMAi3LBvkCtq8ZVHZIawWBB7lAM+KgQ+VUzLIZQFsHwAMK/1EHEvAfwAZ1LLI/UMoJRgbMAQAGBsy4w2IONOhB5QHsMEGI0H9I2KN33MD2wuxjBKdnRqROKzjvQDIQA8gF8FUJwAEPEBt0FgRoAA68AgLeIf8P3vYDGjgCpwdGyA0bkNU1TAygpe6gshpUFoDKlpd3dzKA8gwjNFGCZvJB+RFkPmhQALS9C3SgKOTmmK/gKz1BfMj1sAxwACrPmKFnF4DKBdC1hqAVQaAtJ+CBCfA2F0YG0Got0IGWsG1DoJUCsFtKQPEMyjugQWLwyjAG6CoDlHDDl4bR0y0DPExB5pkHLWEAD+69v8sAuuoTJKbt2AQuF0HlAGjABTTICe70A6+nBfFB240gN1qIMYAGm0HX44IG1OC5DKMzTq3VAAwkAZyd//8je/YfFIijAwAMo2A0BIZLCDAOHY9QqfNPcNafkRHR6ScldJD1wdgjOaMMyjDAn97xd3JRG6mgzgto/zBqFP9nAM3OgBrbkNOe/zFgJltIAxZyVdN/pOuOGICzy6cZQEs3Qcs2QQdHgRqK4CvT/kFuA4DNLIP0gmajQJ1K0KFjoGXJoI7o71+fwLPp4M4JI6yhzYhYfg48qAnUyAft8dVz7WJ4dHEx+C5x0Ew0aNYJtAwXNJv1FXgNGWpHFuJLzPAhtUEECUOs4YwUUJiDAIh4Y0TrYDAwQvznmnGBAbTiAtRQ//XjA3grBih8QI1uUIf4G/gat//Aw//MGEADLqBGM6jzClrqD9krC7KDERxfoD3DoE41aNYftmQcfJ81cJny1QN1DOpWJeBr10CzfqAVE6DOGmjbAajjCg47BgYGeAeDkRF87gIo3FXNcxhAjXSQTaAOPKyzAfIvv7gOuDMNOk8AdLI7qNMD2pMNmqmFnIEACWtQxx7kbtCAAKjjDkoriM4oJG2B1PAKqzOA1ICWL4M6KeAZOmDHAXSTAGh5PqyjAtuLCzrTAtThBukBpTtOPlkG0MzdnpmGDKBVALA9/sdXBTGAtpuAD0XTjwVvK/gFXKUCGrgCbSsAbUsADRqAzAUNmIDyArjMBa4+AR/GCOzYgMIbfJYAMJxABzGCOqkgdaBZUfD+ZRZ2BpA5oH3vjNBBEZgfIeH6nwEW75C0zggdw0F0ODE6rgyQdAKalRRXdAIv/QathDkBXEUBuhUBtM1DSMqU4SFwKwzsADF4uEIb/v//458dR0m3KAUDJG0xMKCVPzjTPAP4MDXQICBoWwlo4AF0cCPoQFHQTD185QFQP2igBXI9IAcDaK85aEXD+2enwINicPcD4x10bgloEBG0qgTUYQWla9DWDFDHFBQf/4BXmcIHxBhAE9L48zYiH0I72/DONczjiHKHAUkOHkaMsPwGCxsGBlhhiaKGEdLptghdyfDk+hqo4RC3wTpqyOoZweUBM1KZBzWfEeYeBogc6CwO4EAfaCk9P/gaxZvglR+gAThE1CHCALIqRZwBdFYDeCARuJUHlKdBA1lWYWsZHl5aBM7nsEE6kF8kVTzAq8VAZoK24IAOigWtZgENvIDz79dXDPCVCUidS9AAA+jcEdAgMmT5/D8G0JYVkH9BAwKg21RAq7tYwIME78FnDoCuugTd8gLZyiIBLp9AZRj4jnvwADPSKgMGUsptpDTLCMlfoK06oM49KJ+/erAPPBAAS5ugQUdQ3QEaiACtGgKVCZCDOt/Bb2UADRKCDjK9tKsEvvLhP9EDEwzYAZU656Mz/wx4wegAAMMoGA2BoR4CSJXuUPAKIyNVXIm7gcaApdOP3GgjM7wYGckbTBjKyQvm50HnB8JpiKgBAAYGeEMV1MDGMBUugCqD2WBmgPcHGKFhBqLBh3EBZ2t4BJUhgwlInX944wQ+s/mJAdRYRD60C2YPIwOksQY6xR689xVoB6jDCepwgVYAPANeWQVq1II6WqDZGFCHALSEG7wFAHp+AAOWfMdIcV6EhAuqOdCwgpqNkk8ZUfMehj5ooxR09Rps5hnUuQctiwftVwc1oEGH+mnYVjCAZjvB2y2AHTlQJxvUmIZ02P8xMDIywjvtkBP4fzAgOoIMDJCOLAMD6OAt0DWKoEMbIVcJ/gDfJQ2a2QI12hlQ28sMoAMhQfu4NYC3PoAa/aBGO+w6O9AVg6Bl16BwBsXJuycnGRige4lBZzvAOwcM0AEFaFiAZhVBV+TtnWPGIKcXDV61AZq9BnViQfr5RDXBZx2c3ZIGnnWH7bsHLb0GLX0HLdsFDS6Arn4E7f0H2QXyM2j1A2glCPjQMuBBg6Aw1HPpYNg+SYUBdB89qKOuYpYDvsINdA8+6KpBkJ9B4XRidRiDT/Ezhg/PzsL9gOiAMkASO3BZPehQS9Chj6C0x8TMwnDtQAMDqKMAUvsfuC0Dduc+aLk0aCACHD6gMGFkgHf6QfEJGgwTljFjAPkJ1HmFHf4FyVSM0KSL6OiAZiJBM5CgQ/bk9WLB2wBA/gR1RhiBh6yB0j5orzx4UAaW/kHO/o/a2SSqWCMmj+BQwwjtLEsD93eD3Aq+ghE4g/rgwjwG0PYE8N3m/yF31oPUgjr1IL+D74oHnhcASkegbRS/vr8BOxXUwQXNKINWwIA6g6BwB/kZNGAIyh+gPAAaVACtIPj3D3btKHIHEcbGLD8h5RYTuEMNuoIUdAsFyCxwXgJ2rkHXV4LMB/MZwCUSJPiQ8jQjcv5Gzv8wNrCjDkrroMMgQYNZoNU9oLNXQMv2keMCvOIF2OEGDehBDjiVhHQuQYMfoBU1yu7gMzcYGSGHRII6sCD9oM45KB+Dr7IDDvCB5P9jhMN/YDrjYwANjoJWeIE6/aAbFUADpyB3gJbpgwdnGSGpD5SvQWb/gK6sgRw2up0BtDoLNJgHMgM0oAOSh12bCfELasccVt6DBqzunJ4GPrsFZA8oD4KuUASladByfNBA5BvggXugawhBZQDoFHzQljJQWgbXDQzkdv5RQhjMAQ0ggswEbfO5fqgFvL0AdAji+2enGUD+BG2dAZ3VAdoCBApH0C0PID+C5EFXnILyPmhgFrSFAHR2COTcC5i/SRmYgLqNirPyeDv/FNlDhr8YBicYHQBgGAWjITCUQ4BxaDmekXL3MiI3PrD5HsUOSIcD1DAB7cOF2I7cCCLTPSA7YHi4ZaBB7zfi4oxw5xZqDlqaxDqwBLcSYTe8sQtv6DKAD0sDNdBBe00hM72M4IYrqPMDalhBZqCREgy0849+Vz8jvIPECJ/hAp3yD2rggpZqgjqfIPshs90g8/6D97CC9gmDOmCgxiSoUwe7/xvhfEakAQ8c4YitcYQz30LMIGoAAG4Gfj0gWVDjDXRVFqgzCmpogjqWoJlq0MwY6Oou0BJn0Aw96ABG0AnuoIYn6NRw0Gnh8DvP4b13pAYzmj9AnWVwJxHYWQWdvwC70g4UovB0wIhwL2i5Pegud9CsGWiv86n1cQygmw8ge64/M8AObYPEMMQnEDakzIF1CEFLhUFLekHhBpq9Bw0CgLYpgGbXhKXNwCtHQGdAgEwAdZRA6iWBWwDAMQ3s0IIa4Wc2JjKADp08vNiNAbSVAcQGbV0A+R80aALqCIE6iX+BWxUgy3vvgQ8WBDX6QYNIJ1aHMoAOkwMd/HVmYxID6BR60FYGUEMf1CEANe5B9oEa+KADDEGrL1C3RQAPaXt3lwG83J5DgOHKvmoGZZNMBtCVl+DBNOCsKmgLB7gzATy4DeRG8BWAjPBuPQPIbH33HvBKF9BqG9DJ/aBzD8B7nP9DBnK4+GUY+IEHpYEGJ2ADN6ABD9C+elAnBXSFJyh/gcp30IoO0DkOIDaoQwa6EhF0oj4D0Q1+1DyBngZwFvV46jWQiZ/f3mCAXAt6EzwQxQE8GwS0Z5wfeEYBKI2DBkrAaQ5oDuhcA1C4gOIOlAdAHdP/4DMuGBjA+8aBM8CGXlMYHl1aAlyi/pMBvA8bmCYEJAwZYLdtMED3YqOXK5juR/gXMgDAyABKa6CBJdDWJ9DKJ9AqC/A5I39/MoDymVvWJYbbwLMcwKMykIIKacANknOQBxsZ4SsGGMHqQANhoCXtoK0OoLQNugKTAaVTywCu4UFlGGjVBGjQDdaJB824g26aAB+0CjrXgRG0JYeLARSeIJtB5oLCCrQKAHRrBmgABeVwUOhsOagcBcUHqKMNOiMFFIbggwvRZtNBYQJazQO+JhK4LQdU3oLSFqjTD9puAxpgAHWgQYN9IsCrKMG3ZPz+xgAeAPsPvXoQFuiMkLIcpAe0AgAUrqC4BfkftH0HtOefX1wXfK7AN+AVkSA7QdcBwq7KhMcdtM5goAIAreoBlRnPb25iAA02gFZDgK++BJqtYBDPADp7BJQ+QW4D3YwBOvjzy5ubDILA8wvePDwMHkgFrSaC3aBBOL3hcDS9Ov4MowA5BEYHAEbTw2gIDNkQYBxaLmek3L1YO2dIFSzqLCei4Q7qkBn7zgQuO1wLbsRg7bCQG5qM0E4VI+PQzkswfwxqXxAfxkQPAID8S9QgAMxuRLpigDZuYY1c0Mwd6ER10CnKoD3T4Jk7qNmg8wEYYXYxMjIg3Ic5Y8IIbSyCOmKgTiro4DlQZxd0ZzWoYwdb0s8IMwc4EwbqHIBmzEBXB0LuGGdATGDDOl1AdaDTpUFXtYE7aUA+ZGDiGyTWCTXEMNI4cljAMyIiBTGizxSCA4CB4IABUN+Pz0/BB/OJAO+Vt43ZAT5sEbRMF9RYBw2ygJZLgzr/4LMTOAXAe7/Bs1bgGWZoXEHdi7XcgDek/4MbspBD2pASPyOkIwIrU0BuBi3RB6kD7RcGNeBBnW5Q5xLUwQPHCSNm+vwP7wgwggeIQJ1kUCfg8p5y8Iw+aGYVfI878L52UGMb1CCHLJdnAA/+gJfUAzvQoBP+uYWUGEAHIoLcBNo6AOrIgNIFyKWg+9j3zDJiAB3IxSWgwAC6xx80ELBnljEDqAMPauAfXe7LIA08sAt0vRno7APQ4ADIx6CbKj69uswAShMC4noMoI4XaAACElsM4D2+oI4bqMMGco888HwL0OGMIPeAwha08gR0mCJo8An53In3wHv0YbPa4M4/rIMFShfAWWVl00zwKfigLQTq1qUMoAMSQfvjIdsIQAf3MTKA0ufNIx0MoBUKDLA4A+q/d3YmA6gTDToTAnZHOejqRdDBi6AzAkB5AWSWNvB6PdAhf4SKNUSaZIQMksGSEANSWmKEyaHRMMOxDp4xgMMVYsp/8GGNoDACnfEBch/4Kj94OcLAAF61Az6XQQ4cNn///oDWWUzgAwNBaRx03gjkPID/DJDtSf8ZQCsMELOeoDRN7Ewsah4GrTICpSvQgA/oNhTQihfQDQSgjirIzpvHeiCz8eBwYYTfUgHqsPIIqzLAzikA53zw0nwW8HWcoE4uKA2CBvRAZoPkQR108DYr8ADHf5RyAzTzDhoQA+V5UNkJGgwBlYWgVTeQ6zEZwe4Azf6DVj2BBk1AeRN0eB/IXJAdj6+tZgANFkELNwbkgSDQFisEHzO8QFENGnzg5JEAD1SBBhUgNxGIg+MBNHAG2tIB7hQDV9iA0jfk1oV/GEkNNrgCyo+gcuPd4+MMmnbVDA8uzGeAlDtMDLCzYEA3qIDMAWFG4M0wcDdS0En+jz4YgeFCkP//MsAGjkApAjSYDDqLBDQoARpcBQ2ygQY9QFuzwAMdwAERBpQylIyZ///UnU3/T8x2iP/DZwafgUIwOgDAMApGQ2AohgDj0HI0I+XuJdj5RwkR5EYNI/iAH5B+0N62//8hFR1mJ4QKYcqIo2E4WGML2b2DPkURHz+MRKU3NPPQ9GCkNxR5WAeeEdy4Bc2CgjphoI4caKk1aCkzqCMC6WSD7IGkC0ak2TBQgxW0TxnUqGX4j3rAIKiTCGqAga5PA6VX0KwTaHYGdOAd6EpC0InQkL2uN8AHiIH2iIM6DiAx2JV3YFuZIPtnwVcZAu/SB82aCwJnCkGdQ7PAxcAOxi7w/npQp5Oo6McIV9TOA8QMaLgid77h+hDhBpsHButBUwu6og20NBx0oj14BurtbQZQox60XBi8zxl4LgATCxv4AEBQ4xTWGQKHN8wjSG5FjkvkRiIjNrWM2OMLlKZAs86WoasYQLc9gJbmgmYEQZ1QUAcUFOfiwOsAf4FPIf8BTheQK+9ADc7/DJDBIUPgPe57GUANa9CMP8gvoAY/5Oqzf+BVHKCOFMgFoCXuIDtBs2sXdhSAD5SEpSmQXpA9sJlh0CGAoM4K6KAy0IwkaEXB4aWeDKAl+ubByxhAZ0+A9uTL60aDZ6APLXIBHx4I6pCBwhrU8QbtMQaFE+jMBdCgAqijAkpz4DMwoOmTV0gFvMQftLcefJo68CR0UAcLlPZe3tsNPk8AdIYAKIxBbgL7//9/+CF3iChhBA9ugAY6IKsu/jCArpAEbZkBXeMG8ieoAwQ6iwC0VBt06wJ4NvwZ9CYMoJmgzqaKeS4DaCAA5GdQpxW0Fxk0OAFaxg1aWQFK1y9ub0UkbeR0BhJFSpfg4R4gX0TOigGU30Azx5ABPgbIDDcl5SMjuDsMMQHUGWNggIQJqDMCkgMnOUiYgOIUFFewgS7Q8nKbqC0MoD3noHIClAZBAyagUAVtDwANooC2rDAwYOuAEdPZQc7DjAzgGV3gcnfwQJegIvg2CtBZA6DwBG8xAnZ2IUEHmn3nZADlQ5C7QCtaQGUf5KBNBsggCrC8+/r+DoO4sisD6Ao80D560NV2IPeDBmlAdsEG7ZD3jYNcBIpPUOcTNJgKMh9UroFWr8AGL/9DD/wE5UPI4ZZfGEArc0CDATLaIQygJfSggdD/aGeuMCCHPQOU9x975xW0SgGUtsWVXMF5CJQ3QfmcjYMfeIPEavA5A6A8CrralQHtwEUG9NUEQKtAAxmg7T2GXlMZTgNXD8HOaQBt8wGtIgCtcALlY9C5JKAtHOBVLwz/GVBXsOCO0/8kdm5xToSAIgDkH2DaBB9YCoxH0O0o985MZ4DlNQakA1JJnvmnYiecqE4/wyjAFgKjAwCj6WI0BIZcCDAOLRczUu5e0jr/4OYJdJaRkQHUmALNuIEam//Ao9b/8IQflcMW5HdkPNAxN9jcQ3R4kBYv1BgAgKYiVBcidRjAs+/AGRrQcllQRwPEVwaewA26lgvUcAPNWIJOUAYdyAaiwXc3QzuXYL3A2THIie5i4KsCkRsyoKWhIH2m/vPBDVnILN9fyK0CX54ziAGvoXt6fR0DqHELWiIKmv0FdQxAM2agpZqg0AKpAc2ugTqFoOvw3gOvEQTlA9AsNsg80CnwID54Rvk/5g0HOKMGJT8jdx4gIQbXB+30gAYdIP6FDJaAOizg5eXQTg/6cmFQAxh0+BSoAwI6sRs0gwxa+guaCQad6P4JeD3WP+CsKKjTD96XC+1QgcwBHY4GWtIL6cIzMjAibRfC1VBkRJ7hZUAMUIDCRlY3Engd1zV4WQIKt2e3NjGAlseCOjCgjsyZTckMgsAD50DxANp2ATnEjZMBdE4B6OYBBmgnD9RIBjX4Qec2gPb9ggZ4QANAoE42emcBdNUf5KrAfwygu/9F5GzBPoEtgQfNDILSByuHIHgAB3RI37EVAeCDB0Ed979/foK3B4A6G6BzEkDpE7RHF5QeTm+IY3BOPc3w49NT8D5fUPyAVlOA9IE7b8B4Ay0NBu39ZeMSYgClW5D9oHIU5BbQmQmQTgED+NBAUIcAFBegDgL4nAOUxv1/6DKU/0jJAmkQCBp3oBULoCXfoNndl/f2gq8RBEULaBsNZDDhD8OTq6sYYAfmgQZTQDOmr+7tAQ+0gFYBgG5GAN0K8OzGegbQgY/od7IzoM3kw9MkUBzkT9iWDNChkaAwAZ8vAU3DoOs4wQNrYPcideZJKc8ZoS5gZGCAlU+QmWEGsB9AW1DAy9CB8hAaMiAAuiYS1AkGrRYA5W+Q+0CrgMBXfgLLn4cXFjCA4hniFMhgE1Zn/UedYUcr2CBuApZJIHNBZwyA4hsUz7wimgw/gWcQgM4aAIU3ZJANkpdB+QAUd6BBGNDgC2gg6z+0YwjKP6B0BdIHiitQmQa6RQJ0BgBoUAt0GwKoHDANmM8AmkWHzT7D3QUcqAeVTZAzPH6CB9A+v7kOHjgClbkgs0HpAJTfQOEI6jDLaoczgG5VePfkBANoYNUp+TjDXeB+ewZiZoZhaqDhBCpHQAMUoFUvL4A3vMC2aYAGpkA3eYBvXuGTYQDdmgGKF1Dah91UgT1ZQOIGNLgEGoAFhS8oj4PcBklbwC0vwG0z4O07wAFOkB9AeQu5o43NH/+p0JnGGAhghJSKoK1DKsDDTkHxBfIfKAzAEyjQOP6PntcJ5YeB7vhTbP/wWj0wOgDAMApGQ2AohQDj0HEsrLNJoYvJ6/xDDgcCNULA+wiBB0OBZlxBlS+4wQCsaEENS0gfBD1MId0HmgQ0egeckYbxSU+7aJoqSQ8jRqLCFYu5aPow0h5cHtKJAe05B82egq48A+83/f4evFwalO5AM3egDjqoAQvig2d2gTPyQpLG4OXqoNkq0Owr6I7lV3d3o8zyaNpWMYD2YoJmVUGzXp9eX2EA3QcPOi0a1PEDHYAH6vCCrqoCHdD0GXhvPKgjCdqzyQA+VIwRvKcTxP4FvRcb1CAGzcCBGqxqFoUMoIYmqGMBWzEAi8L/GDNXaOGEEkYQOUh4I6mDdpxAbgTN/oFPnQeK8Ytpg0+zF5G3ZQAtoUVONoywZdDAMALtzwWdxA+aBQU1ekHLgCH37AP99eszA2imEdxJAnXIgJ0W0FJ0kBouATnwFYqwxjqxyZIRaWUGyC+qFgXgThmoQwmZoWQAz2iC1QHD9zNwRQKocwS6gUBA0pBBy64WvFQd1BEGNdpBy5xBy87h15AxQFYAgFZigPapSwEPhQPNbr64vY0B2LMBOxN0mj9sxQBo9hw0ww2Ka1DnHnSYH3gQCLr/HxSvoNUe4C0Jn5+BO8agmW/QtXKg8AJ12EBp7/iqYAbQwV2gg8VOb4hnAC2RB3WWQdsrQLP/cjqRDKD4P7TYlUEQ6A+QuaCOqKiCHXhpMmg2FeQ40MwkN788eCUVqDMAmhUFqQWFAag8BQ3YgAZmwO5nhHR0QXvJwffvM0IOlkPMYiKXr5AGNXiP9e+vDKAwAaVTUAfr3pkZDNZRmxnun50NPiMA0vGAqAcd9Aea/QetFOARUmUAzZ6CwgJ02B4ozYDOMwAtVcbc+w9Lo4zgNAQaHANtnQGFGegsB8jVb9/B98iDZ3o5BRlAgwGQWyM+QpITNP0zMiAgajpD7yQwwvWBD61jgHSeQeZCkh0TOG9Dwo4RPKhnBNzjD4pP0GATaGACtEUDlP5Bs+LgdAee/WYEr+YAbZEBxYdnzg0G0JWGoEEeFPfg6/SglWegQTbQgBtoMAa09B2Ur0B5FbQHHLRlBJTmQJ1W0J31oAP8QIfngbYGgLY7gdI+6HBM0HkBoMFFUCqArbYTBq6qAOVpkBoJ4OF+oJlwCeBBfqCzKEAz+N8+3GdA6egywlZdMIJXSoCuyOMT1WYAXeto4DmR4dHlpWC/g1arSKi4gZfkgwaqQINYoFURoKXqoG0S1w+3Mvz/j2PAH6kcg9cX8M4/bNYdeHXgt9cQt/2HDGaB2hOg9AJKZ6ByDeQnSOcf6cpFbGEOtu8/eNANdC4GpPxDTiuMDKBDOkGDhqC6AXLmxV+kqPyPFq3U74wi15ugsAQN0nwEXrWp79YDvgEBPMgJvJ4W5BCSOv9U6vhTNNv/f3h13hmoAEYHABhGwWgIDJUQGGKdfwqDFda8wmsMlo4eI7jBycwgCpw1A+9LFFJmAJ1oDKx5gXdxvwU3sOSAM3ughhVk6TPaYT1wC+kU3oyM0D2nVKaHRcYmPQ6I6/yDAgeH2fgGAdAazKA9z6AGOfgEaGCjnA/YwQXNGIE6gaAZRFADGHzIF3BGB2QjqHEKPun8zw9w7ID2Y9882gVt/EIaqqCG1ZtHhxhAaRe03B90MJucTgT4KjFQx9DYZzoD6LR70PJz0H5XUMcfNGMHng3/B9k3DTIcfAc9KyfYbPBedaAcaKkwSPzjiwsMkBOwj4IPnAPvuSYwS4YyGMKI6MRBZlKZIb0+aFpG7lArGSUzgE7XBi+rBp7MDeqQgvaLgxrREFMgOR2xEuA/A6iDAFoObh68hAF0tzSoMwtSCwoT0En5n4H75UGdWpAZIH2gjrYocFABdEAgaDsGZI8wA8JNsLyA3ghE6swxgMsNiItAS55lgWEOWmoP6vCCZ4PBSQYyKyup6sEAmlEHdZZAAw8g95zdks4AOsAOpAwUZ5BbB5A6H0CjQTcGvH54kEFU3p4BlE5Ah92BZs45eCXAS2vBM95AN3IJyDPwiaiDOzmgtAQaKAItv4etFgANSoDCB9TBRZ6R4wEu2f4AjFtQOgG5DdTBhSzzZwGuSKhkOLrcjwF0OBpID6jDCZqBBc0e6wEb+KAVUpAO+DPwafygu8BBdoNWl4AGDzh4pRhAd6t/B1/B+BfcMQN18EEdLJD/QWbCsgeo8wBaAfH983MGkFtAM+ig+Acv54ZnO9C+4//waAeZA/IfaPYeZK9FyAoG0JYPUIcItEQa1Nn6D10ODdp2ADqEDJT/QIcmQq7P/MjwDninPujqTdABdqBVN5A0gphxhyQDRvBsN2j1DTe/HHgwDhQvoD3qoK0SIHvfPjrCALr6DDTTDNpLDuq0vgKuTEBUDahlB7jOAUvi6mRAO/3gU+xZGUD1D6hTCx6sA87ig1epgQalQQM8wHLkw8tLDKC4BA34gfwIOo8BdIAo+LwHoNWgegvUSQeFE2jgUUE/nuH8jnxwZ/cvfG82Kat6GMBxrm5VCjz47SL4IEB5/TjwAYOgMgN0wwNo1QF4xQVw1AK0NQN0HgkonYPLGuDgDehgONBgI+gGDwboAY6gQSxQOgR1Ijn5pIBL5p8xgNwNOcxUBLy9AHw1KmxGGVoGgUIXNFimZV/L8PbRUfD+eNDgHmg1BGi1AGgwH3w4IPCsBNCVoKDBBNAAEPj8k0+PGR5dWc4AGQgh0OnDNggA8hC8nICkUQZo3IK21IC2/Dy+upoBdo0kKC3Cr3JE0cuAFcBuZ8CU/M8AGrQAlWUgv0FO1Ye5H+GP/zTuyCIPhoDiGHzmxP09DK+BNxOA8z7wVhuiO/9UcOvoEn8GmoHRAQCGUTAaAkMhBEZe559grDBiCxNI4w7UQAA1zEEdByPvaQygE3qf3tgIPqBIx7mVAdTABjUaQKeJw+yBdGTQzYR0CEbzCL1DgPxwp+cAwA/oXllQZw/UOAct2wRddQY6SA186B/QG6D9y6CZVlBDl5mVg0FGM5gBdGAUaFYX3KkBHoAFOggO1HEDd2ihS5VhnWjIVVZ/GUDLy0FLXkGdMAllNwbQHmWQ/aAltqAOA3g7APDOdVAHCNS5R16ODbIPPIsroMgAWn7+99dX8Iw1qEGP0vmHNdgYsZc3jNiWywM7NapmueAl2qAZRLBORlA+ZAZeMacG3oJz+3gfA2imEjQIB7prGnW2j5GBAW1gBZTaQPH49NpacMIDhRWoMwdqjIKW/kIOWVQHL/MF2Qe+Vxx44BcoTEAz2pDG+V9wR48Rej84wz/YIVdoaZkR0qlXNs1iAMUBKLxBS5ZB5oLCDbSl4z/SVXKgzhBo9g/kH9Cp6yC/gFZVgOIVFMdqloXgmVjQ1V0Qf4BJ8HwxaFYXNGsKOsTwzeOjDJCDzZ4x8ADjBeR28H36QItBcXJuSwb4MD7QdgdQeQY6KwDUeQCdjQDaRgDqXIHiGJY+QOUdbFAAZP454IAEqON6bmsWA+g+eVBDGmQfyL2g6+iYgdepgToboG0JoA4aKMxAs++gRj8oHkGz/yAxkJmgw87+AdMp5IYF5E4JOpsRHJWgmxLeAv0Hii9QBxY0+wuaMQatVAGlcdBgAIiGzRCD4hQ0WAFaQg4KnxtH2hlAq2AeAO/xBw36gA6EA68iQZrNZecRAw9ugfSAlsfDOmHg9Ax0K+od8NAZZUZG+FJ30Ood0IoIUGcfFAagVSWgARXQ1hqQfRw8kgwgN4PSAGilBmiZN8gO0MAxA2zFCNA82NV8oKXSb4FLz0Gxjd5JA6VlEVkrcKcRtmUClF9B5oH2e0MOs/zKAAsT0IAPaIuIoIQBcLDvHvhMAtAhtqDBQh5hNXAuBB3QB1ldxMgAGkgC1WmgtA7yg6CUEQP4Gku0pI7cmYLnZagakLtAM/fggRHgIZKgVSLaTk3gU+lBYQraYgTZFgE5qBA08AkadBMDnnvxDng2AyiffHpzAzHjDgwb8An8wHwHuhkCFH+ggQpQRxJ0bSlodQtoSx74Gst/sAGl//CyAHZ7BfjAOeBNFqCwAg3qgA/5A656AbuJnQ949/4LBvDZPqBVEeDyC9Rp/4tZYSF39mGrN0Crh4B+BQ28gba3/MNyXgDEIEg6Bw3agFabwNItRlxj6fDi7MDiGIwExR9osAVlUAGUMug4g41ch4LC+/WDAwyQMvAfA1GdfwrdSvVO/+jsP9YG3OgAAMMoGA2BwR4CjEMnihip41b0xglGAODo/IPUgSovUOUJ2mcH4oPu+QXtHwUfmgbcPwxqfF472Ag+yIsBPuuJcPfoQMBAJzfK0hDFAwCQRIQSCKgdX7AC+D5edesS8CwiaL8q6GR20EFZoI4AyB2gtAa6luz++XkMoA4haNYVtPwTJM7Myg1eOg5qdEOWzKLOVoGWgYKwedBSBlBHCDRDCerYQ/Y3f2EADTKAZi5BDWRQhxi0DQE0Awe62grUUQPZD1qqC+rkg2ZxQYMQoM4iaLYRdI0X+OAwYIfqP9reV1SPY8YFbGAC1CkFmQe6oQA06ADqIEIO3IIM3oCWtIPOIQB1XEGH+YHyGuiEcdChb5zAq91As4ig5e3IemD5lwG6Fxk0YALqTIIH80BuBXYUvry7Bb5SDdRZZQR3wNiA5ySsh8ygA1cYQPZMv2ZghC49B+0NB23HgMzig8IYc1YQ1PkErbYA7Z0HdfBAs60gGnSYHrjTC9/XDAkPEAkakPkP63QA5cFbLYD856Bl/cAwZYQkE7g7QD1j0CwlKB5BbgF1vs9tzQSvGgDNcoNmMiGrIhjBtwWABhhA9/WDOqOgrQiIw0uZGCBXg/0Fz5CDOqOgwyJBHQfQWQ9SGgEMoBPmQXurQdcTggYBwHvav79jgFxNycAgImvNANpLDjuAEtThvLK3Cny2BMgeUOcS7BZg+MI7Ikidb1DYgtIWKC2BOoaQ6yhh4coI6QQC4wqULkCdQNBqB9DgCmjgSduxmQHUuQUf3Ag1E3bXOqjTDhIHrRIBhRFoxhV04BpoIOg/yr7j/+CtJKC0BPIDeEXDf8zZUkhahqRH6HIQBhANcr95yDKGe6eng2eKQdsVQGEFvlufiYkBNOsPOiUetMUDFBZa9nXgferSmkEM4BsaGCEDCrCzCGDhABoswNwHDhkUAZ/2Dpzl5wQOLIDiHrT1B9RxBnUoQXzQ1gzQ1gdQfgEPBAAHMeQN4hjA+96B+p7f2QZOS7BtMaBBlY8vL4K3vIAOqQObaZTK8PT6WgbwDQ5InR58HSpE2QbL+f8YQMvydV3aGS7vqWCAdOJ/M4AGlUAddmT/geIe1HH+DLwaDqSbB3hLBSh9g9IneAUMMA8yQN0Bij/QgYGgcACFF2i1B+haSUjcYa5WEFdxB59/Att3Dirr2DmFGECDn6DVBq/u7wXeQOALHrSDpVHQeQWgm1NAK3gYsHX64EtUwBHIAFplACqjQOUQyD7QQYXgDj5sIAAcJNB09f8/A+5wxL7SAEM9UR1RWBmFMJPwrP9/MiptwvUsKLhA+QI2APofZx6DWk9BR5tmM/1U6/z/ZxhuYHQAgGEUjIbAYA6B0c4/1tghMAAAaeQxM/iVvgDvHwU1UEANKdCMz0vgwVGgBj5sWTEDPIhRwxr/QADjaLahegjAGurkG8xI0gAUnjhEM4cRbeYb5EJYBxMyY6bIAL6H+/VVBtDMFuRO9lfgWXbIXcqfGUAz9aBGMQjzCCozgJeDA5f6gxrEv39C7pBH9jl4Rha4nBV0wjSogw/pKDMwgA7pAu0xl1TzZQB1NkENf9CJ8U+vr2cAzZKDzAWpBV39BlqRAJq9VTROAa46uMoAGmgA3fkMOmmc6GWr2MICKAZaLg4ygx+4NxfUmAfNRoI6d6AZflB4uWZcYLhxuI0BNGMN6kSBOlegO85BS3hBHQBQYxt0xgGsowkJU0gaAM34g85WkNeLBd5tfo0B5F7w7CZQGsQGDTqAwgDUsQXtOQZt9/kEDHtQxwA0myokbQI+oA7UmQR1XECnwoPiBdKJRoQyJL0AZ1CB99nre/SDT0DXBa4QegWc8QJ1qkEdPNBsOKhzBroCDFJmQNPNf/QVBWiDC0Bl4IEeFg5wxw3WAQUN6oA77cBVGKDDA0GDG5BrGyENTJB9Ssbp4DMgQMvwQfaCogC5I35pdxl4Vv/H1xfArU424A41A3gQ4j04pYI6YKCtBqC0CfIzqLMIKvMu7SphAB3Edhd4mjfoAEJI5wuyUgK0CkVGKwSyCgIYRKDwFgSeVwFKTyBzYKe1gwYyQOEOWWH1lwG0hQE0uAXqKEIGh4CaQY1uaFyBOv+gTi1sqwKo03sHeI88aIk5bNADNPsMChfQqizQlgTQrD5o+wVoKTeoAwI+0+E/bPYRrUOG0sBHa6RjKw+AYiB/gmbTQQNqoEEEkP9AGNRpBM20gwZkQGdMQOS+MYDOEwANnoDcgigKmMGz1aABJ9C9/A+Ah/GBVtlg63iC0hlo6w9oSwEoPEH+BR1WB8vToDwA6rSCBhFB4Q5aTQJa2g/igwbaQKsRQBgWX6D9+aCtHeCBbuC981+AJ+2Dwv8NcLn8H/Bs+R9wIie2U4U+CCCu6MQAOoATtNoIdG4HaIULaBsGqJwB1Z+MkMwKPrwUNLD+CXo4H2gGHbTKBVRewQ+MAw3EAVfhiCk5gW/AAK2UAg1ogYyA1MPY97mDz5/4DxkYAIUJaMDzB3Dm//2L8+ABMNA1lKDBTlB6BIUFIzTNfvv4ALx1Rs2qiAH1dgRovoenCdA5KV/AWx9AN1eAylXwKivgKirQShz4/ftQN2AbKMXXMSe/848on/B3/GnRIcWsE///Rz5DAYedZHSyR5f2Mww4GB0AYBgFoyEwWENgtPOPNWYIdv7BrRNwO+0WcOnxR+D91qrA66LePD7GADrACNQYBjVUQKELOtAHvFQaZRAA3JRgYIAtxWZkZGDEaScjXN1oPiI3BKgXhlQbAAAnIUT+Y8RY+s7EIKXhD+6MgzpOoL3QoNld0NJx2Kw/aIkxaIYL1JAGdVhBHQzQrDhophm0BBvUUQUddAdaKs2APBMPDUZwpwG4xBW0fxq0Vxu0xBe0LxSyJ/gOcD/2MQZQQxVycvoeBlgHkZmNG7zVBeQe0CwyaL8wyG5Qwxt0Sj5ouSyoowyaJf7/n8h9woxoYQHkg/IN6IBC0Kn+oEEI0BJpUIMctPcWpPreudkMkL3ADODZedBJ/iLyduA9/aBT5e+emgr26X+U2XVGcKcKtJqAV1iFATQzB/KzCnB5PqhDAL42C6getJoBtEwWdAgYZAXEK/AyafCWCuDsHWzZMKjzCZqFBsUJeucfEsXQtAekngD39YI6eaBBCQ2bcvB97KBTzsH2AmfPWdl5IPuKEUEBLhcwl3tDyh9wRxnY+dEA7qsGnZAO6vCBZEBbRMC3kUD3s4POR4Cfh8DEBPY/6HA70GnpIPeAwgKWrv+DO8H/wPflgwY+QHxQRx9yeOA/BsjqhW8MoAEXyGni78Gnp0up+TCATvYHbQUwD1nOcP1QCwOoMwcaBAB1zkGDWaA0CboeELRaBJaTQW7l4pNmALkfNqsKyQugjgAjeFsHSD949cPfn+BZYkikwjoN/8FnWYAPFAPO3oKXvQO3U4BmW0HX/oHCjhEc5czgQ8ZAh82BrzoEhhsoPYEGrEAdW9BZAJAzFdA6/8QUOYwoEQbWAbIHFHbgsp/hPzh9giRAq3LAtxwAD5oEbeEBdeZB4QLqsIPOTgCtXADFhVvmJYbz27LBVyKCBrYeX1nBALlyDtSZxcxToEEo0IoL0Ow1aCDg9ol+BtAKCtB2HPAMKzRewdc7/njPAFpqDuoggQbKQAMAV/eDViBsA9/yAIqTj8BDQUF5TkzBHrxnHxzvwL3/oO0bIPWglQsoHSzkDhrWugw8ZA5Oe6BwAA06gcoJ0EoIUP0JKrNAqwpAnX9w6gZ26EHnmYDKJtAgJGwwVErdhwG0WgN8tz9024y6ZRF4iT5oMANUDoEGREGr80CrPeCDWkjxiC0/gQZXn93cCB70AsUP6OBB0BYB0NknoAFS0FYN0IAhaDUIqEwFr6QArkoApR34IZ6wMEAaAAClDFCZ8enNNQbQwYGPLy8DH34pqerJANP7H3rdIAMD8R1u0jr/2M2lf+efxPqbzJl1unb8R5f+443U0QEAhlEwGgKDMQQYh060MFLHrQSX/cNCBMM+pM4JI6xBzwhfegvqfIGXZAMbLaCOAGh5KejQKtBeStCBPqA9ruCZPXBLlAGsD3QiNmh2DWIlxEz83oTay4BOj+Yu3CEACyvqhRGtBgBALoTMbjIygA6HAzU0QfuWQfuVHwEbjV+Bs06gmb0nwH3oui6dDKAO+9unJ8GNSdDMJmjPNmhGEbSkGbbUGJTmIEu7kWZYkBssQDao0wpqiIM6IiAzQLNxoC0toA4JqLPw+tFhBtC+WFAnDLyEHTgbCDopG7aHFNT4Bp3i/eDCfPDS5afAK9JAM3agA85AHRfwMmysDVu0PI2U+GHhAJohA82Qgvayg/YbgxrSoFO9QXvkQUuqQTPEoPgAnZIP6oyCZrNBy5NBfgIvlQbtyQd1/uFWQRigzgTo1HNQRxDkD9DsHshs0IoD0Cw/qNMA6pSAOp2glQIg/4OW+MO2RoBm0EFLmEEdN/AqCOD+ZNCyZPAhiVj8Cl7pA1xiLQ6coQRtSwB1pkEz/6CsDOpsgA/lAsqjXteHbVAQ0ZCHbU0ADQKAOrKgPc/gvfvAw/5gy/BRUj10xhx00jnoADDQ7Pi7x8fBhyFKafiBl3TziWowgGaFYR0RUBj+Ap1QDjUI3GEArkoApTNQGIMHYoAdafA+duChcqD4AA2ggNIf6F550Pknn9/eYAClB0hHjJEBtH0FfFMKMB2B7AENBnwEr2qRB68yuHWiDzwYAHM7aPDpO/BaSpDZ4IPtgKe5g5b5g8wDhQFoqwFoKT8o/kGHv4G2w4DjFLhVAzKr/58BtIccVN6CtrCA9pX/+vEO3LEGxSlovzgorWMLM/T6Am/eh4wywIMcMYgBLeGB8rrO7eDONPiAOeDBfKB4B+1dZ2XjYQDt079zahIDKB+C0idokAg00w264x6UZkBuhAyicDNABioY4MvFYXaBzAPFHyivQPa//wR3uMGDVaDwBqYB0KoWBeDhe68fHGQQljZngB2KCBLTtKsB30gA65D//vkBOAh4kgFyCN1/Bsi5GsDuFfBgvP/4tvXAQgGtQoPla7g0MANAtuj8ZgAND2gDt0GABjVBs+Sy2qEMoK0xoAER0C0MoEN2v316xAA6iwGU5sUUHRhAg5+grSWgkAB19kFnLbBBB4Eg5SnEJtA2AshWGrQVHkgZBLQqA7Ty5+GlJQzg1SjAQ1RBg/egLRCgcAUNMIG2oYjK2QBXRW0H18Kgshk86PYf7RYA5AEAaLoA5VGQetD2DvAhrsDBFFB6Aq9igJ4dwogj3BgIAaydUNyDCYO64z8UOv2w+Bjt/BNMmqMDAAyjYDQEBlsIMA6dKBlEnX9QoMFmsgTEdBlAHRx2bnHwycOgpZ6ghgjoZGXQDASogQxa5ghqzID0gWYSQa0GWGfAOnIjwwPgvm3wHeZMkCsFweYzMDCQ3snENTgwUgcLqN/xZyA5XmCxiSer4Wggg2ZSQbOzoEYnqIEOmkUEH6oGXOoNmhEHdepBDX1QRwekDnTi/o8vz8AzoaBlq+D0A+yYQZZEwxqCyA1CLI1DYJCBOutGXlMZ7p+fzwDqSIE6XqBVBKBl1OqWxQyGXpMZQLPqkNOj/4FXBDy/vQW8fBm09BjUmQI1tEGdafBKGOCsNv6CBqkcwjIAAG7Y//7OAGk8KzOA9suDOs6gWUvQ1YSgTtNL8PWG/xhg18lB7EN0VuCzarAOGiMj+Hgu0AwkbMYX1HEEzWiDOv/ga+UYIIN0IDtAYQya1QY13kF+BO0zB3Va/vz4CFyarsMAmjUEdSTBVwhi7QiAZrGtGECdOFC5ABpMAG3VOLYqiAG0HB008wwawAAv/YafUI6/8w/yI2jbBShcQLORoAEbUDnCzi0CXjECuq4MXNZADyKDLBkHxTnkyjHQrDxoK8eJNWEMoJlI0CALB68keAYftmRc26GB4R30wDlwiAEHN0ErHWBhxg28+eQ88PA/aeB5ACA9oA4a+HYA0EwzsIMIWjUAshd0iBsjsLMLUnN6YwL4thTwoOjbWwygzh54STvQ36DZatDhioaekxhAJ9ODUgaoowwaZAAfpgecMQXtnQbFA/jwQAbICgFu4G0GoGXeoL3WoHR/ekMCeKsMKI4gZyv8Bx9yB1ryD3I/6Ho/UHoGXXkJi8t/SAcwQtIPIwN8QQ4Dgg2ew4YlWagwtkFlDDFGSJkOii/QzDxoWwa/uA4DaBk7qHMJyneg09lhs9WgOkbBMInhGfBQWVh88AKvIgSdWwHavgA+1A6W1qD5BuYs0EGDoAEA2CALZLn6V3DnXVLFk+E1cEsQaBUNaIsCaNAaZD7I/+CrP4HbUkAdXtDAF6hjChp04eSVBt9GwQBdTQIKH6I6/7CMjzVfQ8pGRmieBNGwwTVQnIPKOx2HRgbIINw7Bml1PwbQlZegQyXZOIWBNxxEMIC2IoAGCEGddVBZCFqRALpTHrwKCmguaGUNaLUUKHxBA5ugrUGgs1H+o+dR6MAYaJAVdPUmbKUMyIWg80RA2/pAA3aQASJGhvcvzjGAzvwAlW+gsEI3jxHLSi5QuoMMxp5jALUX7GK2M4DCHrSiAKQelKdgN45Aai6k9McID0gG4sEQ6/xT0JEesGX+VO/802K7BcOAg9EBAIZRMBoCgyUEINXLkIkPenf+we0SRqTgYUQJKljHigvYKGLh4GNQty5lAM3ggWYjxYDXboEqedByW1BjCjwjCWxAg5ZBgxpU4IYFsFMWUP6O4c6pyeC9g6BBA1ADAjRbCmoAgRvuUBsZqeR31LiGxT+x9FDKuch+oo27SY8TRsIOQW8gg9MgA3ivOKjDAOrwgg+DA3aqQB0q2IwX+Oo44FJeUNoCHWIHmhUFdTJ/fnkJvl8e1EmS1QplAHV0NWzKwLOGoP2t+JaZguziAF6lBT5JH3gAFujUbdAMJShdg2biQLPMIP2glQiIQ9lAne3/4FPCEY3h/wwYDW2c6RopjKCdcwZoPoR1EEAdJFDnH9wrA+Yh0AwaaGAE3PkHqgUt94XNLoKW5oK2JYBW3YBmpkEdGZgNjLAOMazTBDQLdKgi6PovCWVXBtAKAsQBZP/B5x2AOhCgVQCgPcigE/hBHVJwgx04gwfqVILkv31+woAcrigdQEZIXILUgmYuQe47uzmVAbSnG+yvz0/Bty+AlliLA29eAA3wgJYeQ66zYwSvFgLtgQevLkBqdIJWiIDSAGggADRIARqEYISvImBgEALO7oLubgcdcgi+3x+2DQIYBuDVDsDrJEF6QYNEoOXjIDeBOiSgmWZQ8IPSESgsQNtPvry/Cz4MEHRQF3gAALoKQMepFXzOBCicQQMh/2FnFgDDF5ROwVcJvr/HAOrYg8o60AAKaBk76LwU0Oz2ybWRDGZBi8EDqYeXeDCAOm2gNAZcMA9dJWUE3nIAWpkBWlkAuoINtO0E7GYGBvB2ANAAAqijChoIAx1eB7ohAbSq4MXdnQzIAx9cwJPYQZ028BYOYFiA2KCD7SDbBBAzuIxIaQN8UB9woAfUIQeFCZ+YFnhrBGh1FwM0n0IoWMqC0AxYAMgM0Iy1Regqhgvbc8EDQqCl5aB0A1qRATq4D3QlJeicDdB5B6Dr70C3M4Bvjnh+DriPnA884/0Z+RR8mD2wfAOkQat0QOkMlEdBAy3gA/3+w67//AcOV9D2FtB5AqBBAlD6hQ3agQZRQKfsgwZVQKtjQFvZQGaB8zo07ZHU+UdyHyycGBgh5TQonEHpATQIBuroK5tkMoAOagR1qkErDUA3JYDSN0g9KO+Bz+QQVgVvPQIN3IC2+4DKNof4fQygsAL5E3TAJqyeBfkDdLo8aOAANEAEOm8DfMsDAzSucc2agwsLUPn1nwEe1lAxUL4E37Dw/T20fEO6lx+WbpAGAEArT0BlLiuwrQAa6ANtCwTV848uLwWfMQAqp0DlE2iFDGQAkAEy8AQ0C3QGA7hMAR9y+I+BEVGIoaYuDH8Mkc7/UOz0w0J+dOafgVgwOgDAMApGQ2AwhADj0IqGgej8g1spyOGEYDNCGy6gmhjUCAA1uEGNCxnNQAZQRS0D7GyBlh+CZhJBDQ7QEmEW4B3p/6EnVUur+zOAZhjvnJoCPqwNNFsHuvoJdPozqPEMWmqLMZvAiG0mkJ7RCGmsMTDgowcqWaG7ibbuoEnnHyO9gecYGSCtvf/g5djgU9SB6kAnT38Gnk4PahSDlqqCOn2gGTEQDT71HriPGtThfwnsuIM6G6CZYdCMM2hwCrSPFTSrBun8YG8ggpI3SN+rB/vBgwbgMwP+Iw7PMvGdBd7HDDITtAwfeUYQzsZZxKBKYIYlVJ4R2oGCdRKAs84GHhMYQIeggZas3zrey2AVtgZ8cjdosELfvQfsJvAqG3BeYQYv3wWtUADlRfA1esDl5Sj2IbekgWxQB0hOJ5zh3rk5DKjbFUD7tn+D8zboOjzQ8nPY0mzQvmrQeR/wDi/ysn8sHQF4ygRvR2BikNeNhuwJBzYkuYGHNcKuUwPFD2hgA7QlAbQPG2Qf6FR40OAAqPOLPNsF8hOo4wiaBQV1IEDnMIDUg5a484npMIA6j+BrzFi5GP79/wO5Yus/ZBUAyN2iwAFLUMccFM8ge4WBV8hBrp/7D+4kgjrVfMBBAtAAJqi8A3XghYEn+4M64KCONWhpPmhbCmjGHXQvu7x+LDj8QDEIihvQkntwBxd0/RowHYEGcEAHUcI676CZWtCAB2grC8j9kL3pH8BbWkBmQMrFzcBDLgUYQNsrQNcLggZFQJ0+BmiHFtTBBZnHxiUMPk8BNFABGig4tS6GARRnoHQJG9ABHcLGAN0HDxH/Bz4EkQFlRhiSDmEDvaCBF9A5CKCwBcUJqIMK6piBVhCAtqGYBy0BnjexFr5aALkEwrZHG1S+g87IAA2OQLaKBYC3zYD0geoDUF4HdbZBgyygQyYNvacy7J9nDb7XHnR2AOg0fMiKMrQ8zAgZKIKsUGACD3OBB6Y+PmIA+QXsFmAcgDrboDgHHVwHGigBdfxB1yaCTr4HDRZJAQ/9BO3BB3W2QW4BDeAg5wmyOv+wQIHmbdCqJvCACrBjC9q+AdpiBLIHlK5AW59A4cwrogG5dpBfDlzzgAZvQGUAaBWUOHCgDtTZB4UTaOUCaOYelAdA9ScojYDKO8h5Eb8YQAN2oEFUkJ2gjjeonIRsY4GEH3ocMaLM3kMczojWHGAElwjoA0Zo5Re0XAflZdBKD9BAG2xFBSgv8YloggcQQFuvQAMeoLwNUgMatAXna2ZW4EGvigwy2iEMoIE40FkBID+CVsLgvuOfgYGBYZB3/insOA/YbD9Kxh6eM/UMNAKjAwAMo2A0BAY6BEZm5x9cDzOQ4HdGzM4/IyNyJ5wR0jkDVmS/gftIQZUyG5cIuNEKmsUAd9ygDUpQAxG0CgDUeAS5A3SPMqjBBTppGHLf9H/wHd0v7+0CX/H2H+VaIFQ3k975pGd6A7mVGEyqmwiZSd88RdcBAHDCZYQ36EAs0AwyKI2AGsCgRqOOUzPwLvjNDKAl0aAD30Az2VcPNDCAxEFLYkGnq4P2+4I6w6DD+e6dmcEAuzceV8iBBqsgKQ+zkQPSDzqkC2TWJ+Chlwxg1yHUoc56Y8tz+NI0RA7WMQBdKwcaSAN1lEAHEioZJjOc3ZwGvp4L1IgHdXJB9oM6mqBBNUjnjIMBtKwZ1JEBLXEHzYCCwgDUIQQtB2eALvVF+B3iYlB+vA/r/KM3UKFOBnWGQWccQO5g/wfeN499NQVUAyPSTDBsMANIg7YugDoAIBq0F//dk+Pg8x5Ah5dBrjRjBO8FB88Wv7sDPsTt/LYccByDlyAjuQ+khl9UiwG0ZBq0jB80ow0+8RzY0QN1gEBpBdTxkVSHXGMGW+YODWkG0N5l8OFlwI4YeBb4P3Q2E2QHkA1a+QFeHQHshIE6KqCO44dnZ8Gz6qCOLGjPNShcQANNoIEWUDhDki0T+OA+8MoURmaGX8B95KCwR15ZAep0g8pFkBrQag7QjQige+Vf3dvLAJn9ZwaXiaDVCyB5UHoG7YkHbW+BbWsB+x840HF5Tzl4iwgomCFXAV5kAC+X/w+ZxUVO63g7EIzQsp0R0pkGz0wDr8ADhQ1oDzk7cOk5bJDk3tmZ4GsO75+bi1jpAtOPp1gClSGglSmgNAA6hwC0H5wBah/oXA3QjDMoHYBSD4gG3WYA24/+/eNjBljn/z9KOoC4GzTgAuo4Iw51ZGKA5SceQSXwYZ6fQAf7gfeeMzGA7l0HhSvozBBQJx80YA0KY1C6AZ0pAjqgELxyBDyA848Bd+efUIcIKU8wMoHTK2jwCBRMkBl5kH5GsPmgPfygfA+qK0GrWUCD7KA0BkqnMLeABjxBHWhQ+IAGrBQNE8DbA0DmgcLn5Z0dDCD3g27jAR9oKmkAXqUCGkCAbMO5yIAvHYBLBXg7ALPuRwwSgFM7A3xiAJL4GRD6GcFXbYK2ZIDyhqCEIXjQDzRh8PzWFgZQ/gENyoLKMtCgLmhwF7JiBVJ2MLFygAeHQHpBA46gtgZoWxbk5gJsYT5IO/9UmC0fFB1/cIVHq87/8B1UGB0AYBgFoyEwkCHAOLSCn5F67mVkINEstAEARqSGAGj/JayxBjrMCXQwGWjvMKhDBKqYQQ0vUIMLNEoPCnDQAW6gfbGgpX06jk3gJdigBg/4LACgAtB9xeAZnY8PwaeLQ5Yt38YZV6gDEbSLUpg91LcPFBek4MGTbMkbgCEy7aGld0aMWSiYOZBGAmgZMShkQJ1I0Knp4NPYgZ000DJs0Gn/oJkk8LV/wO0BoFP9QecFPL6ykgF1nzNxDQ6Ev/8zgGbfQJ0z0MFw+GKGEcssGkI9rkEAiDiokQtaig+ayTX1mwPcX78ZfGUc6NRvUAMetGT43bMzwI5+MPjAONAMM+hAOlDDGTRLDDp5HTQDCFoeDNrPC5op5OASBV/TibAZkgZhfgNvrwB2eHHH1n/wad0IP/xnwNb5x9cRAOkFySsZp4G3/sCWfIMGL0AdMdAMH0gN6NAx0J30oAPaQMvPQR1CVYtCBhF5G6zXjYE6ECD8BbjMHrQ8GdRZBa0cAKUB0IoRUOfxxa2t4M4GbHYQVO6AyilQPIFO//8LPowP7EKwF/9D93qDaNBJ6KAyD9RRB5VroE4LfJbxP3Sbx///4E4QCwsng4ZtJcNX8JL/x+AtA+D93MAtKZBl2ZBzFUCWgG8UAA5UgE/JBx4yCN5i8uoKvDMNOnQOdAI8aP81aOYW1GkG7XsHz9bDVjEAO6ZfgCtiwIcqAlc4qJhmM4AOoARtU4B1GHBVJRinwKPVEyB3Q1ZTfGIApTnwIBPwUEHQNXOgWV15vWhwZxy0Agy0pQOSNhAdXXhaQe78MCI6k6CbOhihHX/QtgvQeQSgegI0YAPaPgaKE9DKA1A6AN2QAOr0wg/gg5sJ6ThD0hYT+CYG0EoyUIeTG1gegFZVgA6ZNfGZCZ4JB5UJID+BBgNAdRmo4wk6FBG0GgB0LgUoz4EG1ECDAaCbP0Cz6aAZedBye3AH/P9ftGxPeqcFtNUEdAikgDjk/BxZ4MobUNyC9siDOvqgFQyguIe5EXQIIXhbEo8EeMk8KK5BZxKABvxA7gRtDQGVRyD9oCsEP728zMAMXnX3mwF0pSFoxQioTAHV04+vrkTc54/eKWVELh2Q4xHChudtRkjnnAES6AyQFReQ8gTWNoCs3oLqA6YrUN4GbVECz+4D+aDrH0HpHjSYBFrNAgpn0EoP0JYMkOmgiQNQuwHkL0bwTRWi4BsOQGkAfMbGP/SrQRnwArof+Pefep3ZQdPxB4Xw/9GZfwYywOgAAMMoGA2BgQoBxqEV9IOu8w8MP2AlDJqNAN+tDewoGHlPY7h3Zia4wQW+1/fDQwbQsjzQjANoxhXUUYEcovSJAXLo0H+GV6D91B/uMUD29DHCTxkWlrMGH7TFwSvFAFriDGqsI5bxYY87anbMYWYh0+gJhhg1wz1/kz4AQEK+wzUAAApULDNRoP3NoC0AYkou4OWh3z8/ZwAt1wVf9ccA6pw+ZwAdXgVq4INm8UAz4qAGPuiEd9RT5qGxBmrYYM136J11BgasS0yx6MU9CIBrAADsWbD5oA4MqPNy9/RUBouQFQygw9FYOQUZNG0qwIcNgrbVgJbMgxrRsIP5wNd/Ae+8B80Og/YtgzoKoNlO0ODAV+AAm4SSKwNo3znIqVjzD1Hlzn/M4US4dxhRZgJBHTmUjgAjpJMA2qsMcjeo8wLqvII6RKDOL6jTA5rVVAFeJQo6DA988jlw1hY02AEa5AEdeIYc9rD0CApn0D7nV/f2MEBOiYdsgQAtKQZ1xEHL9iH340Nm90H6QOaDyq2/4Cv1mBggyQziPpB7ILOQ/6Cd8f/gsyhA6QhyrSCkEw/qpIA6kRC3/wefOQGyC3QIJGgW+tT6GPDJ/6C0B+64go1nZADNpIMOZgN17MBLmaGdeYTf/jPAlueDZm/BAwTAAQTwIAVowIABJg+hwSsLGCBX4r0BHm73H6NzxMgAiXOoP6HJDJI+URv0kK4drIMHGfQBufEL8Ko3kD/BneOfnxlAaQo0gPMDeHYDv4Q+dNsIZGEYeMYaeFYHKP8hZrchloI6c6Cl7KBBFFCnHuQn0DYVHiEl8Gy8iKwlg6pZLji9g85BAG1rAKUj2M0SoGsSwSsA4GGGKHVBrmbnEWMAbVkAzYr/+fMNPOCsaVvFAFoVBFo18/fvDwZQuQE60BI02AByB6hc+AEuP54xgA7RE5A0Am//gR1gC+qggvwBP5sGZfCB1FKfERy3Pz49BR/YCUovoEFFSJj8YICsjBFjAG3V+A28IhGcxoH2aQDzPWh1C2hQBrSqR8k4hQG0egTUsQf5A+RGUHoHnxMAXDoPGowHlXOggQX7+L0MoAFQ0CAb5OYKPFeSMiI67dBMwQDb2wFZSYEkj1wuA7cpgeRBbgOVR6AZe0hyB5Kg/fvAUsM96woDaNUIaDAAvM3vP+jQ0lvgbTmgfAo6DBiSD5kZQIOAoMkEUPoAnYkB2qoDWqkBWhUF2vYAMQM6CEBRfFC5Q0vlDvJo559hWIDRAQCGUTAaAgMRAoxDK9gZqeteSmf/QQ0O0H5P0B5C0AwIiA9qpD+8uBg8owZa+go6fA3UYAU11kD8o8t9GUB7lkGj9aC7y1/c2Q6euQCpA+kF7VkF7VUEX/0DbMyCxEDLPEF3K4NmbyAND+KiDV+nHZcJ6J15wjYxMmDu/2dgoOYgxGBPpIxkpUsS0jKa+SjpFqmhCQonkFtAnX3Q7DCoc8UN7DyAZqNBs7//oUu4f357Cz6pGnSCO+h6NFAHAtSgBO/3RjrJmwF3IkGSwdVhR/MfUX5gYMC2WZoR2Y9AY0GdlsfAqw5hS8RB1x6CZmFBDXhQBxI0mwfq1YFmekF3/YNmxSD7lCFugs0mg9UAG6Wgpdagji3ktHl0T0P9gS+OYQ1bJDWMWFZpQPzBCF52bQk8pwDUCQHdzAATZ4B6H7S/GjTAAVqdAdp7DRo4BA0UgmZdQXuWv7y9yQC69gzkV1D5AJKDH2bHCDEEbCYjZK83aJAAJAoaGAJ1rEGzo6CZfVAZA77vHqVTzAhcHq/CAOqEX9pdyqDt2MgAGkwB52dgRwbUqQKvRHoPGayEiYPCD8IGLStnhnT4QafDg255AO2rB9oBGngB3YAC2nsPOuAPtAID1CGGXcXHCB1IBR0wd2lXCXhmHWX/Pai/BNwyAPMrfCXCf+i998ipEhwO0A7Mf7RBAZg6RrCB4PgArZYB3bwAOocAdEUr6NYF2DYWjFEdlHiGDHiAynLQoAwon4E6YaA6AZQPQfEI6miChw2A4QcaMADNSoNWZUA6ahA3MkJ6hAyg+GYE384BHGABhpmogh3kPn7g9i854LkQd06DzocxZADdfQ9K86DOMKguAdU9sCsqEasgkNMycMACeDAdaCYcNPgsKmcLDF9TBtC2gOfAFSCguAPfif/3N/j0fPCACtBRoGsAQcvPwdsGgDchgM+iAIU3ME5BW28eX1kBHsgBdbAZcHQ28c0wYys7QYMLrBz8DNYR6xlAK1dAtxqABiZAM+SwlTWgjjQIgwYJnt/cBL4WEjRYASoDQPEAysvgcwB+fGCAncfDK6QCvsoStILiK3D7DKg8vHd6OgN4awzwSj/EjSjoHV+ksoyREWUJP6zMBQ1UgMIdfKYPuJwFRyi4HgSt3gCt6gNv9/v6mgG89YaBEXqOC6SuBLkDZDL8jB9GSDkBcjsor8ImBkADR6By7z94dQzoEMLrDKC0CxooElOwZwCtHgCf9QFMawxErAT4T+tZaxqYP6g6/qAEQOswZBjeKwtGBwAYRsFoCNA7BBiHVpAPdOcfUtNDwwwymwda8gqaTQDNlIFO5gbV6ZJq3uATh7kFFBlAB0GBlvaBTggHnUB9cm0UuPMP2icMOj2dF3jQD+hcAFBjENRwBO1DBo3kg67NAqkBVf6wq8MgB/tgizLi4hG9Y4+LT1yigDRuYFseYEsbPXKugQ9Kg3U0YY0jRkbGYZu9yfMbieGBFn4YA1dweUi6BHWwJIDXeYGWt4JWo4CWaaPuC4V0iGBLakH7/v9DG/VERxSKm1D9w4jkHhTzsHWQUfIVmIOmBdlsSKMZdDDmb/DJ64zg68dAy9kFpU0ZQJ0G0Aw5aKYScpjXXwZQZxq2BBi0Hx62XBt8lgGwkQzqDIBmMMEn6sNthqZv9J4fsp/xNfqg6tAHAUDhAjp5X9Uin+H64TbwlYX/wVsLGKFjaJDOBagDCLr1AzSoKAW8Qu/JtVUMoBlW0PYKUMcMtBcbtDccdLUfaO895GwQBgZk+0AHyIE7ZIzQjghQFtRRAF2DxsLGywDx73/wfnrkwQPQtaSgffSgQRFQJxN2WJqQlAmDklEqA+ggNtBABHi2FHrNnoFHPwPILaKKjgygpdmguAHZAdqff3lvJaQjzwBZBQDqwIH89frhYQaQXyBL1/9DBwyZGG4caWcAXYGnCLziDlR+wjqVoLADdX5AfpTXjwG7A36wJKyBzAgJAZBa0Eqr++dmg0/Sh4giNaJh6kAhBhxQkAMt1//wgAFkHmhwBHTdGqhDC8ofoDCDnL3AwABdKoCRRUDxBdq6AdoGABrQAPkRNBOv49TCcBfYwQR1DEGztqBBFdCAG2gGGBz+/1Hvhgcd/gfansLOIw5OeaDyH3TAIuxaRVBaAXWGQTENWqEBWsr+4eUlBvBgwq9PDKCZc9AZD+CDDJE6DbB0AQoXcUVn4BV5UQygmxtAt4KA8gZodQwoD8AOeAQtvweFO6iDD8on4AMOgdsbEDdFQMoP0Ow6KO2BBg4RnTLUzgqxHUyUMgOUZoGd1+e3tzGA0h+oTgRtdQENcoA7xMDOOijdgMIGdF2hqf98BlDdCTp/wsBzIgNoKT9o8AW0wgl8lsK3N/ADIEGrVL5AO/+Q1SFA9/4HbVUhtGweWg4xQvModFYfUo8yM+i6dDKAVtIIy5iDt7gwMkI69qA6EhRXLqmnGEBXXIIGZkGD/KDVGqAtWeAbGMCxDdkuwwjLr8DbOkDbNEB++M+AWJ0DCnOQeaB0BhqYAU0cgOJOAXjA5tMbG8ArH0AHA4LSLqEbXWi69H8kdPxBJcH/4d05p0fDbXQAgGEUjIYAPUNgtPNPcmijdXhAFTWoQQS6wxrcWAIujQQ1pkBLcUENNXBDDGiJjFYw+LRiUCMKctLvJwbQYU6gZcwgNaD9laAKXtEgEXy4F6iRePNYL+REbvBsLGipLWI5K6KPgtYxojj5IHd6CLBBjSDgLBXIzaDlx6Aroz69vQG+t/g3eMblJ5ZGMuOwzOKDYgAAFLLQ9AmeRQXNIAJnDEGzxQ8uLmDAdhc1qLMD7iSCj7uCpi8sMcTIgCfe4HkC1wAA2GEM2NIsirmMuNMyxmACtAEO6oyJyNuCD4KT0Q4FXpuWBz4sb89MIwbQdWGgziLoBgRQR5MBmo+EZMwYQGkVlG9h+5bB+8ahy8bBbsLlXWQ3EtPog7kTHjeM4Jlm0Aw8qHz49/s7eJsP6GR78M0LwPhihM4KgvwMum4N1PEDbVUADXjAlgWD6P/QA/jAHT3kg0EZIbPRoNl4yPJwFpQYBXWkQB0j8NJ5WAcRzS+gGVXQLD9o7zV4Zh5owv9/vxhAtzqA+KCOI6jTAup0wpblgzryoPINJA86MA40gADq5IAsNw9eBlyyvoMB1NkA770HduxAK05g9++DO1DAzhSo4wTq1IkpOIJvJwCt4gCtjkBKPOBO3n/w0ug7DKDZVJA/wec7QAciwEENNEtONwrcCQPtnQcNbIEO/kNc9QhtsEN6aOA4AZ00/+7ZKQZQhx1yKrwwg5plEbjzCTozAuu2FviqD4gLQVs3QDdpfHp1leE/dC88ON6A/gXlSVCHDLxXnVeSAdSBA7kfdsUfZKAGkldAW71AqwdAYSEsbQa+3QI06y4EHOACne0B2lIAkj+zKRmyjefXFwbQ3nzwsn4gG73zDws/UNqSVPVi0LSrAQ9knN2cDt66ARqQANVDkAHrh6DYZpBQcWcAnRsCui4QFJ+gmXXQahXQYDYDWrr5z4BcN5HX+Ye7EZbHgDRoOTto1QHkQNNLDKCbIEADR+BBCmDYg9I3aEAAcrvDU/D1h6B0CFoNBApnUDoHp8uvrxhAt+vAVjmBZspBccEBjAfwoZT/EWUftg4xI3rZBORzcIszgLZCwFYMgbb/gcIKFDegOv71wwMQLzEygg+bBN2UAVplAEpToJtBwAcqArdVgM4jAMc6OC1CVuvABtNBS/tBg23g2y+AtxqABvpARRNoBQdID+gqYdAhobLAsg901hDoelJQOvv46hJ4MA7k/wGZKadRh3jQzfqDImG0889ADTA6AMAwCkZDgF4hMLI7/+AKl4GMMEBrCMBG6kH7CkGNCdAsP3gvLbDBx8YpwABqcIIqflBjGLRKANZgBjXoYTMnoPvCQTNtoAYLqLJ/cn0tw4vbW8EH/oEGBUCNRFDjFbQlgPDeanLiFamjD20Qg/wBmjUBBxEjmplQNZCOChOw4QlsiPPLMqia54OXUYLvWQZ2bP7DZ7YwO4bkdZgHZ+lAl84/pIWIEgBYO+VIcQVq+IIa8KCOCIgN2feMLQyhjV9GwmmHkJ0MDJhxjbARKodkD/YBAEx34B4AgNydD5rRBC35BS1LBzXMIQdnPQAfagaa6QPdEgBqVIMOuwO5BzRzDrr/HZTGkVeqwJwPHwSApnVcs74EUyTUr4zQPb6M0EY+aGBCSNKYAXTuAGgFEfhK0D+gATNQXEDyI0gtqHMIOlMEJA+acUdeCg85IA/RcWFEC1fQbD1o5lrRKBlyMCBolQE87wJdDmq4gvjwBiyk4wbqAIFOkgeFFWhmVwLYYQSdQwC6Dg50zgKoQwbqvIL2S8PyOHg+FDhbCRoIBYmBZoNBZQhoewmo0wgZvEB0Ev9DB2NgS5pBB7GB0inopgUmZnbw1ik24Gn657akM4DMBHWuQAMQkGzAxADq8IEOTwVtTwB1DlGvZWQEryQAzRaDVmSBBnlAnegre6sYQOkCZBeozEWkVUh6A93zD+qEg663A3W4wKsSgO4E6QcNJrx7epoBJYuAZoxBKxrgaR54Zsvvr8D99frgazlBgxugwQnQYAaviBp4MAIUf8Iylgwgf/IIqzGAls7DOuvIeQF0VeLzW5vB++1BaRp01z1wGQv4gE5QxxU06wvyM3jFAfCmDdA2H5uoLeD94xh1BEoH5T/4oEvQXffXD7UCBzfegAd1QKfpgwbBINc9QuIJ1NkEnWEA8geo0w0aeAClR3i5DvU/PA9g6QhRsrQcFCugrSkgv4IGyEHpH3S9Ijy/QosJUF0KXo0CXA0E2r4AKutAgxmgQXRQOgOlZdDSe9DyfNA2GcjViuzgWwZAdSrk0FNE2seVp1HKeWBCAA3eiyu7gM92+ANaicTExAAaJAGt6gANBIHOLABdzQfK+6BBPNAKQdD+f1D6AkYs+DwH0AGWoPgCD2IA0zvkZgUOBlCaAOUDbkFF8K0MoIEfkP2gbQCggTvwGCEDZBUCaOAQtFIQtBIEdFjwF+AZQuAbIYBndzAQ6JxSffZ/JHX8GaBlKAM9wH+G4Q5GBwAYRsFoCNA6BCCNyyEVzkR0TEj1DyM5nX+QJShugbRAQBUzqOIFXYUFGo0H7ecHNR5BswGgRgdozz/42ibgwVCgxoasdjgDaFkjqOIHLVn89vEBeBksaM8oqOECasCAGg2gmVnQElrQqcWg5dmQw6LAtQ7YuxidJ7jbYHGMr0OHRQ0jpEEBGogA2fsXfA0USN1/BtiMBMiv4NllaFiATloGn4HAJ8Og7dAAnon9+OIiA2gJLcR23BXXcBgEoFvnHyPtMWCmAVgmQO2lQFI62jJj1PyCJZ3gyHPUHADAMIsRe9mE0fmHhgVsAApEg66iAx1sBtpnCxoIUAReB/jy7g5wOnxwfi4DaCZay66WAXStloZNOcPrhwcZQB0DBgbogX3QtK/n0sHw6sE+SNgyEltKYEvj0DCFhiN4lQVciAk86w/qIICWi4PyFmi5PAP89HTIUnhYHIE6D6Al0JAtGuh2wfiIsgi8CQDcQREFH/AG2g8MSgTg/ckMyPoZMZaz/0eaCQXdL/8ROJMNPktCSJUBdPo4qCMIKqc+Ak9Rh61GYIDO/oLOIgANrIBOKwcNEoA6KqAOKujAPwbw4AMDLNEygPTAO3L//4M7+aDBCtBAJ6icA+kDnewPuq4RVMaABlXBcQWKE9CJ58DOEmjQFCQPClvQVg9YFkHOk59fX2MADR6ABnoU9OPBHWjIKesMyI5BxDcTM2Qv+6cn4DJZWsOfAdQpBnfGGSDloJHXVPBp65BVB0j5EOw2RvBefVB6BJWToO0ToAEE0NWcID5o5QSo0w86K+DC9nwGxHJ6BgZYpw6UHkADJ9z88gygszue3dwMXk0A2gsPSgegwWZw+AH34oMGW0Gz96AZ4av76xhgg0KwcxEY4AA13YBmosFXOwLjhRM8C/6BAbJXHGwyJDyAJKiDCgpf0IoGUDkPinvwIBQRnX8GkgB6uoaVSdBBI2ga+4+cjoBioPoUsp3kF/iKR9AZOaCtG6COL2hLA2TbwkdwXEKW/P8F31ICSlugw3RB2yzA2x6ABzISM1gBT1vAuAZt1wMNboHyJ6ijDjon49mNjQwgu0FpE3IoIwNwO4wyeJUGyJ2gLSAgu0GHZYIGKkGhDdoCCBrUAS3fB+Ub0HafD8/Pg/MIaJALlHZF5O0YHl5cxADa0gIaDAQNIIFWEcloh4FXReg4tzGAtnw9ubaGAXRIJOh2k09vrjHQDdBwFnx01p9hRIDRAQCGUTAaArQMAcahF7yMtHEzIxVm/2GBCXIiaOQeNKP/DHhvL+heaFAnBNRYAS/ZBO41BC0zBDWQQY0uUIMLdNI4+MAy4CnGoH39oE4+aGku5D7jn+AZAJA4aBkuaNYK1DgGycP2gcLtRvcHRnjBOlXoNFpSgDasQTNroP3BoCsLv316xCAFPMsA5BdwwwfY8AYdSAY6cf3xleXgWTbwPezv74IPMDwLnK0DLdmFzCL9gy6BRe2gMGBYy8gwVAcCyHc3GWmaJh1ybMUBmtuw2MuIN80h9DNiTYsMiEOvkM1hxOz8MzKipw0kt0HTK2jQ6S3wjnxQxwfU4QTN6IFmKUH3hP8Hr8IRZOAErk4BNaxBh5yB8unz21sYIB1GSNoEXbUGmvEFDXq9vLuTAdSpBDW6QStvQAN0EJdBBscwQ+w/njKVET5wBpqlBOVd0FLdT6+vgzuioCXcoBsMQMv8QfkcsgScEXxwHmTmDqofHE64Ov7I1kPCC3xaOnAmGtQxBJ/4D+zUgvIl6IpRYVkL8KoIuF3QWUTQigT4XmHoIABo/zqovAKd1v/y3i5wxxjUGQQNbiKvmoDN5oNmpEGrDkDhDNqzDFrdAOqIgGaw34Hi6D9kYAPUqdGwLmMAL5EGHQwI3NsMnl0G3sIA6iizcQgygOILNAMN6qiCOm4gX4JiALStA7SVBXLNIAMDqJMFcjfIDaCyExTGsI4cqMOt59oFPucAvOUBeN0l6HA/yDkX/5Fm85HCFpiuQJ00kF9Abnh1fz94bz0o3YAOYQQNbjy7uYFBBDiL//7FeQbYigxQWgWtAAMdbgjeZgDezmDBAFo1AHI7aEsFyG2gwQDQ1q97Z2czgG50YEAacAGpA8UDKB2Dbk+ALBF/Bk5DoLT86PIy8I0yoHoAtAIDJAYa1AGdbg8aVNayr2MAxRcozBCpAjN9IgZ5IJ1r8OoJYF75j7Ed5D/kfAZguIHcCj6QFnxGCEglrnSPECfcof5PYnsEtWxCLl9Ae+rB1xcC0zPIdaAbDEArVLgE5BhAKzBAJ/zDZsNlNAIZQKsAQKseQOeigA4WRFkFhOEqLGUauNL/D16pAjqDALSlAJQ3vn24Dz44UwF4dgVo1QIo64L2+IMGsEBpFnT1JihdGnpNYXh2Yz0DiA0a8AcNroDyG8hdkBU0j8D1Iqj8AU0KgFYQgg9oBZ5RARrQAvkdZB9o5QFo9Qdo0gE00AZK26ABLlAZgzL7Dy+Lia17iIwbGnb8QdEw2vlnGDFgdACAYRSMhgCtQoBx6AXtYOr8g0IPxT2YjQLYPkjYflGQCtDVPKCDsVRMMxlAB/39BS7zBZ8GDTQL1CgAVeKgjoa6VQkDaPQe1GAGLXkELX/9/eMduDMCmmkCzUD9BN+TDT0wCtwrgXUQGKDNeGgnBUmOqEhnhOgDXSUFmv0XlDBkAHX0QQ0jUAMJtN8S1GAHdbRA+6lBDXDQXmDQflHQoAfoujBQZ0PVooABNJMJWkoKWpYLm7Ujxg1DbRCArp1/jLQHCVG8g1gEGnz43Y9WVqDlQ2oMADBi6fxDzi1gYMDe8UdyEzS9KhqlMID2vYI6lKAVJ+C95cDTy0HpFtQgh51azskjyQDbxw461R00aAXaagObcRWSsWCAzAL+ZAANzglI6DGA9IMa8PBtMAyIMIfmFgaMpdYgEWiDGHmmUMepmQE0QwtaoQDKxyCTQPeqgzogoIEBkL9BAwCg/PTo8lIG0P3nkIE+SL5mQIl/RlR7kRvgjJCwAw1kgMwH0aBeLitwKxJo2TnIbFDnAtTJBtkH8iu4QwJcugxaPgzeC43cEYR2CMGHuwE76qBOCmhP8hvgwX3/cdz1/hV41SloJQPY/UC3gTrAoHIDHnrgk+3/MoBmJ8EHm0E7lKDVDaBl76DO7wfg/mVQJ/njiwvgQURIccYEHhgBnaUCWl4NOjwNFEeg1VXg++HZecFxBuowIcfU6wf7wXEP6hiD7QOmD0h4Apdrs/EwIM5PYIDOwDOAZ/zB5fDXl+ADJUHlHyjcfn55AdwTf48BdJ3izWPdDKBBgf///0N3hzABB5pkGGCdZB7g4a+gwV/QYBRo8AUUXqCyFXQbBSjtgdIY7Po/xIAFA/A0fmMGkHqQOXpu3QygAQgufhnwOQSg1Skv7uxgeHlvN1gN6OBKUPmrZlHIcPvkRPDADmh1AHhlwn9cHX8GKIDKQ9X9x3oWBGSAANGRx9EpJLkTSGrHnwELYIRmC0YG0CGToHqHjUsIfCYEaIAKdCggqDwAbQ2AnH0C8QuoUwzaHw8adPv4+go0Dv9hzcuYliLsBJdVwEEe0IoV0BW9oINHQR1x8DkAwAET0EAAZFsKA/hAPnBaAYYxaCWSkkk6w+XdZQz/kM7tePf0BANoGxNoRQcov4Hu9wetLoCkLyYGUL0LmvX//uU5uK4HrTAB+QWUByBXPoL88I8BeYsQAyMDbcFIm/UHhSaNBzywR9h/hpEARgcAGEbBaAjQIgQYh16wMtLOzZTP/oOCE9V9iP4WtJHAAFED6vSDD+UBLpkFL9cDNmpBs/mg7QKgE73By/kkDBiuHWwEz0qAOhWg5YSQGYt/DAr6cQygWSPQKb+gGQ5EwxvcLGYAtVpBjXkuQQVw5xvcqQF1kEBXacEcBaLxYQZERwM08w+6cQC09xK0vBLUgAI1/CVUPRlAgwEg90E6XF8YwItFgR0D0AwGqEEC0geS+/zuFgNo+SWkMYJceeGP06EyCED3zj84KWGGHXEDAJhpFVYYUG0QAMvAGKbZUPdD0yZ8Tz1sbzywMQ06rA3U6GVggLkZlsbRii/oAABophM0wAbbCw1a1q9hWwle3g9aYs3FJws+9RvUoYLt5wadrg45G+E+A6RjyQjZrw3sGILyKSunIHhWGXT6+39oAx18/RY0/4Aa8KCBBdAWA9Byd9ggAL6Dw0AzkaDVP6BtQCC7QVeEgfYyg3zFL6bN8PP7GwbQoWGgvAY6gA6cn4BLksEHiMLyLTwIkMIEa2OUkQHW8AeddA5aMgzqKIBW84D2H4O2HIDSDSifgg74g60QAC1NBw08gMIQPnMIjitYecYI7tyCOtTgZdiwNAmOe+SOIoTNCHU3ZFCHCbxCCGTvnVOTGUCdG9DeePDVlMAODbgTDvQLKDxBYQAq40CDFAwMiMFOAXHIPfrvnpwEz4KD93kD77AHla+g/fx3z0wDH8gGu4cecko+bCvFf3DZev/8HAbQifbggxEZIQMAoIFL8OwvKNgYIYMMILdDBhIYwdfjgQYjQHEOUgcamAWVkaDBWsjecWhqBep9Cjy7BXJ44S8G0PJs0Mop0G0wHMB790FlNGhbA2gWH3R1IyiSQDPH6DPPX97fAZfGoAEIUB3ACez8gwaKQAM1oJUVkPMggLPMAgoM4PT06ysDaE85KK2A9p6DByAYCHUYiO38g1azw8xC1cNANiDgNkIdLEbUchAUV6DBZlCaBQ30gc5VAJ9BAzoIkQHp4Fw094IOlsQ/64/Lg4zgWXs5vSjw1hJQuINWfoC2HoHOyAAN0FiHr2e4fWICw3/otitEWfifAVS+gbbkgOIXtJIDZgvI3SCzQIMCoDgG3RoAKmtA6kH1Lzj9//zIABnc+QceDAPlAVB8//37gwE02AcaHANtzWFgIK7DiHuFBhH6R1rn///I6IQzDCAYHQBgGAWjIUDtEGAcekHKSDs3M5I7LI7hJsyGCDygoR0U0PJD0CwEeB8fcL8m6KR80FJKbYdGBlBl/+r+XvCIPWhPIKizAeqcgPZYgg4KBO1lBDUgQA0KUGccfEL4/z9gKxjhfSlG8Gwp6HBB0EoC0JkDoJk30GyELvDqKfDeXyIqLkbIqAHYbNCyUlBj1z37KsONo10MoOWwoIYGqPMPmm0ALVsWA17zBWq0gw75Ag1kgG49ALFBjWnI/dDQ5f8wu0mIT8zZ38GVfAdL5x8UKgTTMkq4Y89TuP2DRT2SeZgz+BAXgUms8c0IWQ4PTGug9Alq3IIawCD7QQ1e0KnkkJUzjAygWeZ3z05jj3ho3gJJgtI8KO+AGsjPbm0Cd/JAnSZQZ/rhpcXAWeYbDKA71kEzc6+As6aga96+vLsLPikcso8ZmE4ZIGcAgBrkoEE0UCcKslT3C/gE+JfAGVdQgxqcLkEzftxiDKAZYRAftMQdMgiG3ElCLxcg3gDPDgI7iWC9wMPyQB1jUKcBtHwbvH0BemsGqDMDPjjv02MGlCW8kOEKrGGCvEwWZDtothvkB1CHH3Rn/B/g1XCQpcZfGZCvEQV1skFlB2j5PWh5MWhvOuwqQUg8MoEPSgPtlf4EnC2Fxy0sDhghnSHYwM1/+Gw+AwNolQVoTzlogAFUhoDtB65+ktOJAM/UgwZBQMvWQYcKIp8FANlOgDqgALq3HWQOqBMNcifIPaCwAV2pKixrzQAyg1dYHRzXsHwBmi0FHa4I0gfezvTxEfgaQkZmFnAnCnR6OyhO4Pv4gX4BpSdQOQYKQ9CKCVAcg2ZjxRSdGEDLqkFbE0ArF0DhBF4ZAosNaJSDtkqABouMgMu7nwKXd6uY5TKAtpuAtoSB9vN/fnubAbRvHFQfPAce8grZr490BSAjZOwGvIcdyBZTcACf4QDq5IEGhp7d3MgAkgMNEIPcwgs8lwEySwy7uu4/WpphIBNA0jPBmX+STaew849sH7yM+Q8+cwFUD8FWgoDSNaiOAm2zQ+kM/0fKp/8haYwoLzBi1vWgMxFAgzOgMwZAccHBJcoAGtwBxdWD8/PAZRFodQp4OxwDA3wwAOwe4MDAj68vGOB5DFiugM+CAA9CMoLPKAANyIHPCQKtMAHmfdDZD6AVgeBDAlm5wCtTwHkXuL0QRINcCEq/oIMJQatOGJHSJoINYzEyUARGO/8M9AMjZ+BhdACAYRSMhgA1Q4Bx6AUnI23dTNYAAK4ODVLoIjpSjPB9v6DlgSpmOcDTn+8wwJaAghqOoP16oKWbILeAlgzKAhvFoNkv0CwleFQfeKIwuFEMrGhB+hAzFf8ZYBtXQfaBVgWAKn3QbBpo/yszKzeDS+ppBlAn5+GlRQywRiooRHH5G7nzD2p+gjpMIG+B9iaDGu2gZbOg5cG2wBOmQTNaoJkGfnFd8EnSIPeCGqOg66ccEw+Dl6EiZv1xVVzExS8j4+BLu4Op8w9uPBIazMIIQ8wwxe8nNPXYBgBQ7IAMSKEWOpDUh0i3TOCDrECz9qDGKmhmk1tQGXxCOujUbtAMNXilCaiRCdYKyU/wFQMMiNUqkA7nXwbYFXDgGXx2PgbQIZSgGTXwXnLgXnhQh5hHSIUBdBI87M5t0P36sEO6QMEI2lMN2SbwnwG2FB6URyGHWTIymAbMZ4At3wfla2XgMl4N63KG+8ADBrHPuEHCDhK+IPZ/8MF/oFk6kHtB52yAOqCgATXQagXQdgNNm0rgSqAm4GF788EHeoHLB0ZG+JYIRmQ2sNMAnjlnQOv0MUI6kaDl5oqGiQwHFtgxWEWsZwB1TEH5FBTGkHvRf4PNBQ0UgPa1g/Iy5MYIpHwLtA90NglogA802w26nx58VgGk58IAKndAM5WgckYeeOUeaOACNpsOWgIN2t4AClPI/flMDDePdIBn4EEDjCC9oKv2UE/vR6Qc+D51YDoAn2UAvPP9N3gvOnD7wOur4IEM0ADS4ysrgYMNbgzgc0pg7gJuaQD56QdwyxRowPXX19cMoJUdoA66lJov+DrCr8CBIPDBi9DZUlBYiys5ga++A/kXcpbAXwbQVgqQ/0BuBy25B28jAK4MgZfJwPBmAsUFaCUL0K2g8hg0QKBklMrwGLhnXxG4Fxw0GAAaLAIN7IJm7UGro8D+xnIwJ+i8BFA6hlyn+IEBtI0AFK6PrqwADxaDtquA4gq0hF1Yzgp81Rt8oGiozlKS626ksgdy8v93cMf7M/AqWnjnn4DZ/8EDgETWNShl3X8G0FY3Ga0g8JYd2LV+oHgFrTiyCF3BAKrnQVt/xJXdGED1O3jQEHheDmjFAKg8A6U5VYt8Bg5eCQbQiiPQ4BRopR14Dz/w8E1QXgNtdQFdMwjauiSl5sMAOgsApFfVPJcBdOAgaLsTaNIAdLUj6ApA0OpC8CA80K2g8wS4wOeffAEPDEHqekJNQjwdThqnr9H9/iO79zM6ADDa+x0NAaqEALTRPdRCczB2/qGNSsygRG00oHekQA1w0GybOGj26P09BlCFDWoMgO4xBjXCQctKQQ09UKMSdGUPZOb8LwPqskTILAUkWP4junugyp2ZlQF0vRfIDNBJ06BGA5+IJgOoMQBqDIMaqqDOFcTdkEod3KFgQCXBDRHQjCRQISO4IcsIvCM9HDx4AFq2DDpkCuRWUEMeNMgA2t8L4v/4/JQBsrXhEvj05euHWhhM/OaAG+KIQ8KQQo2MuIV1eAZDMh6Qzj/OtAcJEUYqDABArMDVAEYTRx8AwOj8MzEwwGeqkcogqDpIA5QJnEZBp6t/B96BDUpPkNsvvoHvHAd1bMDX3TEyYPUd3M+MEPOR4wU0IABK9yA/CUoaMoBWFIA6ZKDVNqDZdtBSaVCH+yP02jSY30GDcKAOH+S6s1/gE+lBnTSQGMg+UIMeNMMIWsovpxMJ3gN+bmsmw52TkxnwH3SGGAQAHTQIOqgMdBidCrDxDhr8gAywfWIA7amX041kAB3cBbpuDzQ4AXEbM4OonC140A98+jpYkAl8PgeoYwq5yg6zwQ6ySx544j1Iz7MbGxhA5n37+Jjh6v5aBnBnH9iRBg1agK4ZAx14CMr3oBlp8OoAUKcUOvgC6vCDrgAEdeZltEKhA5vM4IPhQGUBaIYT0vH6Bt5/jtjT/B9cjoGX8wM7y6B976DBGFA5BfICaGXCV+BVZZDOP/IMOHSwAxjzoM4PbN80qIMLGsQBxS/omjVQygCdoA6a/QbNpIJvUoB25EEzvyBzwWUg8IBVkDmgchcUjqABhKfA8AC7GbhsGlbWMkK3S4HCCLSH3sRvNniwB5RWQKtVQNsoQFs1QANVnMDOGmiJOXx7AtBDoAP+QOkM5DeQO0EruV7d28MAukIPtKIEpB4UFiDzQYNO4GvcoNsb0Ds9oG0BoHQIGiQC3fEOGhiCH77H8B98VgXoZH524LYC0FkAkPT+Dz7zj9mJwpa3ceR3EspogmUPqCRAMQ9Hx5IanUqgd0CrfkCdY9CKGgb0QTFIcclAbAcTr9+Qy0CgvaCyBLR3/ynw9H3Qtg9QvQ+arQdd2wga5Hv/9BQDZKsQA7i+BK00AuUFWNkDGqC6fbyPAVQ2gM4AAaU50AGloDQFXokEngz4Cx6UBG15Aq0UAA1kPb2+Hjig+I3BJnIzw5OrqxlAtwaAbu0Ar/oDGg4alAKlXVBbg4WdB3gOwVsGULkAPq8Hmv8ZSAGjs/4Mo4C2ITA6ADCawkZDgOIQYByaYchIe3cT02jBCDxG4jpHjGidIUhj8BcD6OA+UIUOmtGBLPv8w8AnpgPuNIP2zYMa8qB9e6D9ush7b0HLV2V1wsBLT0EzjuCZSPB+aQb4jCBoFgvUmAbNEIFuFADtBQTNMoFmxkAzR6AGJOwAK4zeFMi9jIzgRold7C7wYWrga6CAHQDQCgLQrD+oocwJvN4PtMRWxTQb7BbQOQbgU7eBDQJBSSMGUGMXdl4BaI8qG/DAMXBnCriHmQHn7AppcT2QAwGU2U1hmiaQJ0gfAAClSuxuwj7AgUUt1E2QzjxIHpKGGMF7qrkZQMuy4XtboWkMYitQLbijxcQA6uyCOkKg5dag5fvyejEMoDQFajCDrm2Dz6gzwoYTGOHDVvD8idIQh7iBmY0bvMwb1FkHzbqCZtMg19UB996+v88Ayh+g7TSwdAlysxrw4ErQIVqgrTrgwTBwnmBmAO3dBjW4YQdjgjqbDy8uBM+kg9SCZttQzrhAbyDDwgnoZ9AtHqC956C8Cl7CDdy/De7UQc8dADX0QR1W8DJf4FWhID+CTioHzfyBDg4EdbZBy8Ehs4hM4LBgAa50AM2kY56zwQDuDILUgpYpKwEPSgT5AxQ2oC1HnMBzEUBXjoEH9YAdAdBMKSguwEuVkQ4ABMUsqMME6oSDOqQgMyCrCpIYQH4HzSyC3AWaBQWtrrh2oB48uAC63gwef8CyBNQxBg0Igso50Ow12J/f3jBAVn98RhrwhKQl0KAEqBOkblXKAOnMQAZBwQMtwDAGlZOgbQCg1Qqgjj54GT00UYDSMKisBe3xB620AB22B/I36AA1UGcftD8fdGgk6NBVxJWqDAwgN0LOdngDnmUH7eUHbXfiAB4eCV5WzSUCPksC1OEGzeAjb6MARTNoiwCofBaRtwWnY1AnC3RlGyjeQYMToAFeUNyC1IDLcuDABHxwg4EB3nmHeOM/Ayh+QGEIOWQQOigMS19AGjQgBep4Qg6KxLGUHUt9hJHHkfMyA7XAwLQ/QNtYGLCsqKBkVhln+coISauwcg1ywv838JWjoA4+yB2gMhB8jsX//wzI5YqJ/xwGUEcfVGeDDuHUtK1iAA0KgtIxaJDyPXDrEyj9gNK4KDA9gQ79Aw0ugK4XBl3zBxo8+g0sI7j55RhAbNCAFihvwQbjQXaB0jIov7ADr8oEDcqDziMAlaSg6zQVDRLA6R00YYAZ4zQcpMGRvEZn/fHlu/8MIwmMDgAwjILREKAkBEY7/7hCj6zOP7iGxxWmqOIYAwCMkI66jHYo+FAy8IwV8G5pUMMONLsDXgYI7CCDOiR/fn9hADdkYR0eYKcBtI/04aWlYO+AOgH8oloMoOW2oMY0bFkxaPaAlY2XAbQMH3KOwG8G0CoAUCMVtB/SNe0Mw53TUxnAnRuwXxjAjREGeOOQEbzHF9TYEJI2Z/j68QG4QS4kZQw+uRjkdlCHDDTjcAO4fBd0DRZoNgw0MAA+rfvlRfCSWVCjGtzQB95aAOpM/P37E9KohQYR6qwtLIZIT6v0HAig3C4K8yKlnX8S0i5EKTb3YhFD6tiClpiCrs8DzW6CGqDgZddfX4FPMgfNejIirTYBpTkj72kMoP2xoIPUnlxbzQDqqIO2k4BmsEBpCjSjDFpqD7pvnhE62MUAS7fwZMPIgJx+YXkB1FEHNYRBA2CgmW/Q6hfQLD5InpWDD9Kp+g9bUcMMtNsHvOwW1PkHrQAAdapAjXfQrDpoFhe0jBg0eAayC9QRA20LAHXwQJ1e8OnhoAEuRlB/8Q9aB44BAaBhBTIHNAsPuqYLtKrm8p5yBtAMIWggBNyJZ4DMDoIOngMfsAfUB+48AGnQoXYgv8EG9kBLfUGDEaCZaPCtIP8hJ5gjr0RghOc7BgaQm2WBqxY+PD/LACpzQAMuIPNAHVJQRxbUif4NPn/gF4o/wOkfuCIIFJagTivIraDZZtCyeVDnBhRO4AFIDn4GflFt8MAPpFPxH2rOf/AM+P1zs8HL/kEdfth966Cr+PhE1MFX1kFWKcFWAUAKQNBhaqDzUkCDBaBOO2hAEhKo/xlQtz1gdn5Bs5ygVQ2gDjhoMAI0aAFeYQU8AwC0ygq0PQRyngpidRVIDchc0AAN6Bo+ULqBxQNocAZ0uClIL2gQFzLggNowB4UlN/AQVlAa5hFUYvgKvhaVjQFynR8bA+xMCVA6AKUj8DkLsM4qysARxFyUvff//2HMXENm/SHuR1+BglLPoZQhoETBCB08htRNDEh1ArbyDuugIJKZ2Mt19AzLgBvgmVUeLB1DrO0GpPoTxATlkX/QAW9Q/Qeq32HpB5TXRGStGMDXiTIygw/ShVzT+I/hN3Ag6Dnw2mDQABuovPsOXlXHDE4vsFVJui4dDPJ6sQyglQSgbTOgtAS6SvTl3d0MoINEwYNE/34xaNpWM4DOCwJtuwGlU1CgW0duZDi6wh94s4kUeAviP+CqF9Bg3SNwu4LIzuVImvn/P7I63AyDDIwOADCMgtEQIDcEGIdu0DHS3u1kDQDgdRfCzZgNJVgn5T8DaEQfNLP//fMTeAP73+/vDN+BS3JBjXrQHlHQ7BuoAQHe0wy188WdncA26S/wnkb7+D3gJbYgP4DMA3VWQDP6oCW1oIO0nt/ZDm5Mi8jbMYgruTCAZrBAjcRbx3shnf//SA1spCXaoEYHaBaWi08avEwR1IAFuQHUoAEtMwXNIIIax6BGA+igL5A6UOMF1GkBHb4FbpD8/gY82OorA2jpJWjJIWTv7D+U7QoMkHY9JH1SIa5pORBAnY4/hemZiDAiKj3jNAfTfVgb+wzYBwBgs/+g09xB+8pBjU7QknvQrCSogwi5/pEBOn0PywuMDKAZaNBgFehAM9DKEVCHFHRfP3jpPXCpOGipvpCUKQPoOjjQDBdoEAs0a8oAXZLOgOEfSIfGwHMSA2hGDXTKOmi/OKiRLKMZxABazg1Kv6BOL6jjBmukg5aFg1bYgDqG4DQPPKATlDhhB6yBBulAjXbQcnNQYx6Ul0CrXUD7a28CD8ZUAO6tB6kXkjRmgCw/Z8DopCE6RwzgBj1oUA40EGfsO5MBtLrGJnoreP82+NwP4EnuoM4AaFYdNPsN2ev+j4GdU4gB1MAHlROgwTjQCfigw+lA+R8UdqAOMijs/qPkb1g2A8Xdf/DVo6C9yKCOCWiGEeRn0EwiaDk6A3jG/x8D+DT7/5idaX7gdYigQR7wHeXA8gpyN/1HcFkDWnIN6iiDOtugwRxY5xYUV7DOG8hcPuAtB6D4AO1ffnRlOQMoHEHxAhrEAJcVwHiHpSdQeQIqa0CdG9DSftCMJegwSHC5CF3WjXlIIAO8XAXOnYP9AromEBSXoAEm0KqS64eaGUA0SB68agDNr6CVIqDwAZ20DtILWp0B2jYAciMofkAdedAAKWg7FGilCgNapx10hgMoDNjY+YFxehR8qwQovYEGxECxIQc8H+Hto6MMDAzQw1HBqQW9s4Gt84+mBm4vulo8VT8jI3QGmgl8ngBoaTn4vnzQti/Qli8GiFmgugCUJ0FpDn4wIgPSQAGyFYyM8EE4RuggH6RaQS4vIGxGEst7qnb80Tt0ZNY9GGUt0gAAAwMDWrH0H7wtCBwuwEFM0Mod0GAoKA2D0jcoPysYJIJvGgGlRdCKKQ7owaKgq3bB5+wAD/kD1cucvFIMoC0tt4E3Z4AGqMSVXRhAK3ZAZQVkcImVQUrNmwG0TQR8YCDQLeCyA3qY4JNra8HpHnS+CWirFegwyrtnpkPLKtgNGQPTbBxUM/+DsuM/8gYjRgcAGEbBaAiQEwKMQzfYGAdp5x+zZkcLY1wDAFBxqL/APGQhRkiTCdKQ/ccAauBC7jAHnfAP3ecPUgNsnIHPCQDSDy7MZwAt+QV1yEFLASGHaDGBl6WC7jQGLUGFLK19zQBqsIIarqDGPmhG7j/8KiJU58NmTkGHg4FmXiEn+QsxgJbYQmYV/oBXBzglH2W4c2oKA2SJNy8DqLECsgvUSAbNfIEauY+vrgDPLIEaLJA7md8zgBryf4D7F0GrC0CzxCC1mDFNWdzDOuuMjIPDHAYGCtMyUsOaUIam9gAAJLkz4kzjDEj5AdZh+wI82wK08oOFjYsBck3aXwbQlhEOblFww/XTmxvQzhmko24ZvpYBdH0aqLMOGmQCbVsBLScHdUpBs+7gPeu3NjOA7vAGzZiBOvOIZc7Y3QZKl6Cl2aAZdmmNAPBKGlCHGTRrC5r5l9EMZgCJQxrIsL3S/8DLYGGDVWqWxQygGzRAs/OghjZoFvcNsMMGcheosweefQfeCQ/q/IkAT51/8+gIA2hGGJQP8DVkYeEECVRIg+7J9XXgTj1o4ATUiAfZwcknBT7BHpQXQfuIQaeJg1YjgFbSgPIvqAMO3hIAdANodhk06wtaCfAUeCr8f4z7+BkZkOMSlk5AM4qgA/1AnTvQlaOgMuM38HYAsGK0DjHIfFBSBMUB7BA/KVVvhhNrwhmkNPzBcQoaCAS5HRSXkCXu7xiQO/8McDP/g2ft3z45Do4byFLt/0idECZw2QFa3QSa+QevTPjznQEUF1f31zGABnIge+aRGsSwshWeJKDm/YfNikNWRYAGkEB+AJVLoA45SucfqTMNGsgQkbdhAHX+QatIQNsIICtKRIADmw8hAzhvb4EPfUPxIyjwgOaA0gqozAR1tMDXy/2DnMr/69tr8N5tUJyBVkzAZ+v//2fAn3+xNP7ROin/8XRu0c2GpUNQ5xCUpkDnIei6dgBnlU9Dro4F+gO09QKUtsHlOnAlF6IgYETq4IICHIFBqy3AZR4wPrgF5BlA5T18IIBQmYzuHwYKOjyUduCIqD9QwhRjAAAaJoxQVYyQMAOFM+hME/CZOKA0AV3NATrkFJQWQfUWqLyEXH35hwF06ChokAk0kAlJT9wMoHIMvBoKqPfDy0sMoKFGUDkE2lIEGmh9/+IcA2hgAbSSClwGAwfUQIPzoKtFQVv7QGkaNIjACtya9xu85ec6A/K2GUQ8E05zDFQCo51/hlGAJQSYRkNlNARGQ4DUEGAcukHGOIjdjtdt5Lsb0hhDKupAjQJo4wA5IkEzgaDlqKBZQS7gnmHQ8mlQowA0mwaawQTP2IBmDoCj/c+gHQHQzA6oo8MJPPn3I3B5PmrHmJEBtcMM88N/YMP3NHjgQBJ41/9f4FVdoE6HpLov+K7h/fPtGEAnU4M6Z6CZjBd3dzGA7rEGdX5AsxGgAQxQ50LPtYsBMrP3mAHUmBRXcmUAzaCC3A7arwvrHKN2ikA+pk4aQPYbqWzKMxCsUUyBSSTkBUZiBhrwmke92QU24P5obcdmBn7gPe2gPaegxilomTNoEMrAvR88cARKq4xMrMC7sScygGavQXxQGnp4cTEDt5Ay+I548PVr0GvyYIcCgk7PBq0qYURpcCPCGjl9g27EAJkN2j8NauCCOmOg2X1Qmnx1by94hct/aAMctPQdNHgBGpwC7cO9e3oaA2h2H7Tvm1dUE9jJDWCQAJ7cDcpPoAEvBeC+WdDKBlADGzRQBloqDjbrP3RAAdQBgWH0JADvlP4Hb68BuQ20Rxe0xB20/QB02wboDA2QOMhcUF4CrawAmQ/aHwxyk5JxOngrD8iNoM4qaIDkzOY0BtAJ4AxY7IaHC1IaAO/lBy5TBi2nt4nexgAa1AA7FUfHEuw/0Gn3QAxaBQDqxIBWbpzbkgGevQR1qkHxDTIDvKQduQOHZCaoo/ofVsYxQGZHGeBngzCC0wfoTBTQQNId4EwneEsUcEUEKBw0gPujQVfnIQcpPO2DO1nMDErGqQwMSNtFkJfPg1clfHvLAFu2j3yzANjdDLA4+QM+UR20NeDDiwvg5dIgPaBBTMhNE/8YsC39Rx7kAPkRNOAFHnAFp4t/4MMuQatHILcrQAYlMEoIkutAPHkXySxG6Mw8JO+xgDuJsMEkRuABss9ubmKAywEHmaWBK2ZAZTl4EJeFk8HEdzY4X4K2fTFAD0lEzm8gNii/6Tq3gQ9/BdVXDIyM8PwOOtQOFIfEDIqS1SHEl+dILYYpMIsRLcwZkMoq0BkUoPwKWoUEWgkDDo//kAEx0OG/oPoRtCJKxSwbfLYIaHAfpAZ01gjoqkjw9gE5GwYu4LkdoAMoQWpBZZcUcKATtAoA5E3Q9gBQfgKVt1r29eDDe0HlA2hwFbS9BjSgA1phCCpvQFdl/kfLmziD6j/1Z6D/Y135MkDNV1zl9aBoTY+82X9QsI+uAGAYBaMhQGwIUKHTMZCBzUifzj8jObOyBN2GcDt6JxsepIyMDKiNVSZwQ1VWG3iwH/A+aFAD6Q9sBo4B0XCCNCAYGUDX7YGWVoNuDQDtuQV1UkCzN+DTwP//A5sN2uMKOgcA3pWHNrTB+xB/fWGA70MEqWaCHB4GatCBZsbA9jBCXAiadQO5GzQDAZp5hFxR9Z8BtAIBPKvzH9RQ/gO+xgx0ujCo4w/a9/v53W0GUOMGtPwfcmfxPwbQWQfsXEIMoH3DoMGL1w/2M4BmK0ENQdDsJsgeRjgBCy3GIZrtqdTxJzEvUD4AgBEB4PBnxHAHWrygpGkmBlY2HgbQMm0+UQ0G0MnWoAYv6NRp0PV2ogr2DDePdjOAGqeQjgHkvAnQbBfoBoDXDw8ygJb8g9Ie6KA20Ew9aDsAaMYXlDdAB8CBGq2wWXiQ09AHdiCOZgJ31kH7XkGz0aBGM6jBC9r7Dpo5B3XyQY1e0MAZA6xRCzQMdA89F/QgLdBhb6DtAaAONui6LdA1bh+AA2igu+RfPzwMHCA7AZ7FhnVkEXuwcaRfrJ0CRvAp3KCrCEHbAUANc9BAmQvwnA5QvgPt/wVdWwe5mo6BgVdEDXy/PWjJPCi/gQ6UA608gJ0Ij3KIHNQZkHwFCWdIymSEdo4ZwYN/4BPS//+HXCWGsnIAfUn5f/iyepDRoM4v6FBB0IFkhsA77l/f3w+OV9BBe6AOC2iGHvVefEi6Qe9wM0CTHSiOQMuRQR1u0GGlF3cVMYD8BzrPBBRPoE49qFx5+wQY7v9gN6MwIJadAzukoAEj0PYp0OnnCgbx4C1SqKsOYKsMsBctqJ1OxMAEOL0COyqgwSPwVXKgMpVAZwh50AGWxmArvGDmYXMFcv0AT0mU1ouQjMIAK99B5a6R91QG0BkyIP+ABpW17GoYHgAPtAQNKn96fQV83gsoH4IOTwSlbVC5DUproDQGiiNw3oGlMUZIWoINuoDiAbTKQkLFgwF08wFIGWj1GSjfKejHAldAfAAOLr9B9f7/AZztZyASoMUDSpkLl4OGBaz+Bg6sgOo68C0RYDWQAx1BK41AK1pA+QiUrkCrjDTtqoHXlV5gAJ3dAyrrQIOC4K2AwO1IoEEYkB7QtpPdMwwYQFtITq2LAW/vA21jAZWToBUloAN3QXkadBAnyNwXt7eCB69A5dnLOzvAh2iCBsFAZ3WA4hd0i4lj4iGGe8BzORhQVlz8p1784Aje/wyDpFP7f2R2rhmGABgdAGAYBaMhQEwIMA7tYGKkn/vpNwCA5Ceo/5AbeKCGLuSKIOBSWWBlCOo4ga87Y2AAz7SDlvCBZlFBI/mgjs7fP9/AQxegGVDQ7BuIA2psgTtEoEYYcNYGbiOonQ9qFHMJgzv9oKXEoEYGI1Qc1ODmEVAEz3KCOlX/wftuGSADFNAGHUgN+CRs4CFu4FksoPgv8OzZHwbw3lrgPdygRsnLuzvBh7yBVgBoO9QzwA5sAzVwQLOvoMYiqDMAWsoIWm4MOswQdD0T6Dos0L5a0N5h0PJnBowGARU603TLFRS6FRIxDAxk5AOi0zNBszHzIM7BLFC4YknToP2toM4+aJkpaC88aNb9+a1NDKBZa/CJ9eD4YGSAHOjHCF5uDLr3GjRQAOrog2ZbQbNUoCX3oLwAuhoONMMOOqgNsrcdqfOHdSAPYjboUCzQbK2AuC4D6FRsRgZIwxyU7kCDYZCO7z8GWIcU7HNgfjHxncUAWj0DGugC+QOUP0ErBn5+eQFeqQDqDIGu0ALn258fGGAdTORZNEakzgA8+WEJK3AQAt0FyhuggQnIcvS/DI8uLWYA2QEfVPj/F9yIBw1OgMqEd09Pg28MAe0vB2+9AW6rgRyMdxs8KIFsJzhtAO0WVbADz9KDluuDtuhAriEDFwbQPA/RBXEmLC0zIpIjtJEMabT/B29ZgPkd5E7Q7QSg8AaZC8rj0lrB4OXLMD+C3AFepcTAAA9zWAcAZBvsWj3QLCWo8wO6FhF02CFoLz5o9QOojHn1YB900OUvasxDw/Y/cDUDaEk0KPxBbgKtpgC5CVxW4liNAPU1ZNU6POAwOz8wfzOgdBYQ6gjlwf84O1eMyAHPgB5eMCehJymIffg6LrjqU0bwAK2SSTrD46srwYNAoBlp0GDtX+AA8aNLS8DpHLT9AdRBBA3aglbEgAYJQOnm/tlZ4ENeIR1auOvAg0qgPCGvH8cAuv8edJbEs5sbwGdD6Ln1MDy+vAyczkDnTIC3fODp/BHdMaSo4wYLOxLbHWhlKHJ9Dq49GaHXnjIygs/qAa2GAK2sAC3hB5WJoHKPnUecAXamDuTwyb/g+v4NcACUAbwCBVLGgcpO0CAK6PYL0Bk+oEM3QdeWathUMIDCH3QQMCjfgOpk0Io8kPmgsg1Ur4IzLnCgCrSNCrRCAJQfwNdSAsVA+QGUr0DbVEB1LyhvffvwkIGBjh3y0c4/Awlg5A5QjA4AMIyC0RAgFAKMQzuIGOnrfqI7TPD2DTHuQ6iBdACQ9DCCux/wzjVsRh98kBdwmSUTCxvkQCrgyb2gWUtQIwF0QJaeSyfDvbMzGUCdcFDFDnIOqPIGNYwZwG134Aw+8OAm0FJNBeAd38omGeCTxEGVK8gMZZNM8F3AnPwy4IO2YKew8wJP22Zl52UAdbxAywhBakF6QMt3fwFP/4Y1ZCCHi3EzwJYKgw8l/PcHHCpSwO0AP4ADA6CGBWjv4XfobQagbQagFQ2gjhzozmuQz0GHb4E6YqB9tKAGOejQQpBd4BnL/3/A+2lBM52wmWHMxDyY0zeZHX/kDj8F6Z96nX9QqGOGM77VLBAdUD2MkHAAdayFZS0YQHeXQ66pZGYADfyABp9Ay01BA0bCclYMoBkr0NVroBkw0HJXUNoEze6CZhpBHW/QtgHwNhHQShNQw/Q/dLk0RqMfFv5QGhqWoHMEQPtqXz86zAA6kA00GwY6+R404wW+AQNlFhfawAJ2tEEz/SC1+sBOCygN3zszgwF0+CXITaBDDUF5F3T95Zsnxxggp/X/Z/iPpSOCMQgAdResQw5J44zgogB8IvzPTwyQGeK/DKD8CcpboA6zqnkesEN1BLzc/AfwRHDQdV+gfeSgvfqgTj9oBhc0SwhaOQG5Qx+1YwPakw1aVQAaPADd3/8COFgHussfdOo+ZPUEEwOsPALHJyNSegayQasmQHHJAIsHkCKYfxnB/WZwOIB0gcooyH7xD9DO/39ox5oRbAdoLz1oBRNoxRBsRRGs0wGa6QcdfvYMOFgESiOgcAKtAgENvIDSAWTm/T/49HJQeIEHPoGHjTL8hx5mCipjoeUsaOUAeBUJMxvD7ZMTwduTUDo3SL1pRrDTGMEDUhYhyxlA16uhlD/IcYs17THAB+0gcQvTTUajHeIY6Ew9E4OMVhAw7WYxIF/vB4oz0AoQUN2B6EQx4qj/0cUZwR1+UDiDtpmABmpAW3NA5TpoUBl0gjxo8O3Pz48MoIFZUJkMWpYOyqeg1WegQ2pBZTpo+TlocBdEgw+yRSq/QGfSaDs2gAedQTPSoMFl0BYOdasScKcVcgYN5DwEihotJHX+SY0LRvxOQ/IvIj9D0hBo2xtooAoUT6DtO6Ar/kD0rWM9DLD6DXaGCXiVHWjlHvAmANCNGJD68B94Gw/oQE9QHgFdWQpavg8a5AelA04eCQbQaijQoCSojQC62QI02w+qt/+ABwIdwNeegs4JAJWroE4+aPAftG0FFHeg1Uag+hqkDyQGPmAUWPbA2hcQj9N29n9QdP5HZ/0ZhgIYHQBgGAWjIYAvBBiHdvAw0tf9dO38Qxt0oA42qDEL2TMKaWCDGgig05cFgPfmg/b7gjrQkKt6/oOXx4MO1AItiQZ1AMAnakNn6BmgM5mgRrueaydkj/2HB+AllaDr1MDX7QFTBOgmAFCDAzQLBursg5ZfmgUsYHh0ZRkDiA1KNKAZWtDVYqB9m6Blh5CZMgZwIxE0owA6yA201xfU0bEIWcHw5Ppa8EwkZIsBI3imCNQZAd/xDzwnwCZqCwNo+S/ojmFQhwM0iws+FA3o9p/f34L1gjojoL2MoI4CaN8pbNYC3pDHmZoh4TZ4EjsJ7kFp2DMyMFAxzROdnomyEzMvYh0AQG8AgyKFEZauGRhAHVLQCevgFSDA8yhAHQzwrCxwhhHUGAYt5wYNBIE61aDBIdCMO+hQKtDAEPJd7JAGMwOk4QyfnfrPgNrRQksRULcxwmkm8AAWaG8tqDMLSuegBjF41QzDP4Tm/7Al7pDGL+hKPpD7QUvzQQMAoLwLypOgzgzo5PtXwG0sDOBBBCQz0FYkoAwCMDIywOMKpQMKDXNoR9TEby7YvaAD1EAzeaCVE6AVEAzgM0H+M4AO7QMNloDyHEj+w8sL4FlxyDYAiNuR7QXZCVoOD8rPoOvFQB2x+8ADREGre0CrCYSkTBjAB34CDxODD1zCyy1m8MGIoBU7oIMawfGB1nBmhKuF+APWIYJ4EZLWYas9QB0c0DJ/0GGD4Pv8/yNWYIC2AoEOBQRtdxCWMQffnQ86a0FQ2pQBVF6Alqu/fXoSfAsCaEAJlG5ge55hdoKWmYNmRN8DV0iAVlRwAQc+VS0KGMBl0F/UKw3hEQ+csdWwrQQf9vf59XUG0CDJR+Cef3iSxtFRQIlbsGIm8KoN8Cor4NYq0IAJIpsQ6oDCyhIIDYorUAf806vL4MEV0CowUEcdNNgKKl85eSTBZQj4ZH6kLMuINY8jmw0p28GdPWDYg250AOc34MAXyL6XwLNcQEvFQWkddDgcKAxBy8X/As9fAC3pB63IAXU6H19ZyQCa6QetrAENpkFzPgN4CwDQDaBZalC+Aa1YAw0ggNIwaFsBKJ5AA1WgOgB8nSY4T6OWOUR1DonuvFE6c8qIu7phRE3voG1uoLINNOgoD9x+8hF8bsQfBtDs+ovb28ED8HJ60eCbSSBpC6L/P3QAC5QHQWECGggAtQNAs/+mAQvBNwaBB/yBYQW6KhUUN6DzS0Bl07MbGxnAg2XAAQTQSjvQGSWgbRygTr+SUQrDM+B1gqB4A9etoAE8YFkMGhwDrcb4Dx1UhbQ7XjFAVh78Z8BYBUDljvKAd/6HXMd/5M7+g/LJ6AAAwygYDQFcIcA4tIOGkf7up8cAgAxwTz/oNF5QgwyEQaPsBh794MYAZBk+pMkEasSCZjr/AWf+wXuPgZ1kUGMZtByPBXhPOagR8Ax4AjrkTmBGBnEVdwbQrIAQdIYVNNsCagyDZnRA2wRAjWdQQwLUAQPNkIH2bIL0gvY2/wQu3b9/fg44vQgBG9ighgZoRh40ywRqjIsru4IP/fvz+wu4cQmehQWeMA5aqgjeHgBs1IIaDqDGOKjR8ht4KjRktQIzA2j2DjRLBNrf/QY44wpSDxoYAB2qBmqYgBoVFsFLGV7c3gZu0IIGHUCzeqABiP//EQdhYXaQsCVvWIN2IJI+amMapwugnSLEnlvauJW6nX+QGzHzI2ZHB6EG1vGCDWjAOnogk0BnWYDvwgZuE4GYzMgAaiCDDq0C3U3NBTwhHNR5gJ018RHcAWViAHecoINcoAYzKH+AZsJBHXaIW5AaRMjlByzMGRiQOtoMDOKKTgygfAbKk9cPtTKA7OcX02WA3LvNwMCArUEI9SIoXYNWyIDvaf8PuZEDlJZBs3IM/3Ec4IY0CAAPO0YmjNU/DFB18E43yN1AdaBOMOhgPdC1d+pWxQw3gTOH4Bk8BsjhgqB8DuuIgwZWINd0YjYSEXYDyw3g4ZugwTtQZwEU9nrAe8RBeQ+0aujD87PAfcH7IasPgGEIPgQOfsAbE/gAMVAcgGZ7IQd3ItvFCF66DNID6iwyIA0cwDqDoDQCWtYPOdn8FQPojBBQfID2IDMgDeqA2KBgN/WfzwA68AzUeRcEXv8IKldAA0SvHxwED1zePzcHfJYIaJYaph82CAEaEAGVtaCDEkH+BLkBZA+oQw07LR2ljGGELNMGDRCAOnCgqxhBHVfwcmngLRagZfKgDh2u3Asr38EDvMBVXKDBFNDAFqhMBs3Qg8RB5T6ozEYd2IKYiN5hZ2SELM8HpU+QXtCgDsgPP7+8BJ+rAToTgptfngHkT9i1kIxo2ZYRT52KKvefAWQebOAVFJ6gwzshN0gwMigYJjGABp+f3ljPYB60lOH+ubnAwSB2sDtA+Rq0UgbSiWdggMU7aEsbKE7MAuYzgAabQDe9gM4AcIjfB952oAZcBaAIvC4TFIf/oSvJGEhddk5UB46anSYiBgGAYQ5atQMa9BSQNACXQKBtFaBtE6ADNkFxCRpsA9Xn4G1Q0PwFWn7/9eND8GoJUPoA1ZWgDjvkoMT/4C0aoPoRVFeD6lM+EU0G0KAQSAxUDoDOIwGxwTdLfH8HvmoSlNZAVwHfvzCPATbQAxtkACUV0FYqSJgjhxH2VUzUrrUGtPM/OuPPMBTB6AAAwygYDQH0EBjIThAVY4ORvgMAtOn8I1pgsMY8eO++mA4DaLkj6OAzUIcctPQY1JDnEVYD73uGNdxAJ+yLKTqDD/4B7dED8UEmQvbF32EAdZJgS3hBByiBZv9ADQlQ4w3UkAbNnIIO9wHNEoAGEr59uA+OIPDd1KDGFXDmELQUE9wRB1WCQItBBwqBGiigDgTowCzQklrQdU+gawVB+zPBDVvg1gKQG0CH94EaJ6BOEOhqoX//IB0hUEMX1DEDNexBs3ffQFsAgJ0i0FJSkD9BjUPQnlzYCdiggQyQw0DuBHVAQFsCQCscYLMTIDmUBgLBtAHLA7RMQ8h2ELAHudNPhwKL+p1/RDpGdj6i08AIbugzMkAhcNYJsXScEbyEGnSqPxP4HnEGBlDjHzSDC1qaClqGDko7oDvPQWkPdJ87KJ2BlrlDZkqh4QxNn7CBha/v7jCA9pKD8g/ocEvQ8lXQoXPgziIjNATAWhFxgxIuQDWgq/lAK1hAy2hB11mCBuYQHXgGBvRGKUL/f3CHE9TRwhwkwNLBQEmvEPfAygNQg15QyogBtOIHtKQdFr7InX8GqH9A+QbkVtCeelAnFjTjDzrwE/nEedi5BeDDw7B2oJDsB5oLGlQArQICdUqlNQIZQPd+gzoPoBlfUFkFPkgUuPVHVN6WgQN4zzjITtByb9BgCajsAZ+HAMzfoI4G+lkHoHMbQJ0YUOcPPKAI3NIE2sYBLo9Ad48D04OMdggDaEASds4BaGm5gmECcDb0JAMD2pWFoMGCL+/vMIC2X4DKNtBKDBBbRisELMYjrMoAXg0BDURwp5mZhQGWTkFL1Z/d2MAgCbwLHbQMGuQmWMcKNjYDT8Nggf/gQQ7QwKecTiR4hha0WkQZuEf+7eOjDIiOO+rABzyPADtzoOXaoGXVoNUhoPQEihfQ6gQJ4IAtqKMMPmCVAXl2FSm9guIdikGDQtKaAQygW1VAbFBnDmwuMB/8/PqCAbTnG1QOgw5bBaUp0EoUUHoBDRi9vr+PATldYRsIYMSSRsFbyRggeR8ULqDZetAgAGipOWibAOhWCdDhl6C4B8UraD876HpNUQVH4HV0Zxgg2Y8RfCsMKL5gg0yWYWsYzm5OBYvzS+gzQM6q+ADulIJWaYA6sKC4BKVtogcB6N75RykJsZfq0HwLStOgLSQPzs9n0HZsZADFO2jQUU4nHLy6BJSOQANooLqWA3gGAGgFDmjlHSgcQAOjoIF6cDkD9CPoID8BCUMGULpl5xZhAE0IgPIoqM4H7f8HbZUC1a2glXygchSyXeM52H2gQXnwwDr42sl/iAFOeNihll2o25fQyjUqdppHO/8MZABqDmQxDEkwOgDAMApGQwA5BBiHR3Aw0t8fJA0AEO0+1MYcqOEGqpRBnWDQ0mHQkkdQRwjcWAOe5guajQI3SoGz/rAGGaijA6rsQQf2gDvfwEYlqNMD2qsLm+0DdZxADVLQDBdoLyCoQwBSC2p0guwEdcZBDQHz4OUMT66uZmCAd5CYGEB7l79/ecYA0cMEvZ8d1Dj4B1nSD2wsgJZfgzpHkMTFyGDsPR249/goA6jxCnIX5N5i2CwoA4OQjBl4bzeoMQPaZgA6sR20/x/ceAR2Iv79/cEA2vMN7rwABwZADVXQnnBQI+ft42PgxiPo0CmSZ4Cwpn5wM5QBMqtKbrpCN4MIc9A6/eCOBXi2lwHWTaZ6XoV1XogymOQ8hupn9M4/MzM7OIhBM1qgwSFQ5w3U2QGpA13hJwvspIEatJAl/0wMoP3E4GXZgkoMoAPEQA3Tn+BVLozgQ+yYgXu0QStWQKtNwANBjLCOKxMDZDUBA3iWEtTBAi17Bu1bBy1BBi3VBl2P9ev7Gwb4igFoiKOEC5L/QYffgQa5QNeagfQQ0yD9j3OWH2ELRpkCtxMyKALKhxzcogxaDg3gcw/Aq2ZAbmVCu+GYERKzoG0zoMPZQB0x8OAacGYP1AkEna2As7GO3FBHsh90KBto4AXUiQfNJoNuZQDFAagjDppNBA2OgPL37+/vwHkHZDdoBhK2pQe0xBy08gJ0Fejzm5sZ0MMDFO+ggT9eIVUG0IAgZGvCJ/DgDygdgJeHA/MDqPMopuQMXgEE6ljeONLOoAA8LA40MAEZgoE1dP8zgJY3g88DAYb9pzfXGEDpCzSACTm0ENqJhpdtjAy6zq0M57fngjuYoMEM8IoloF7QCg9QGIIGPUADTpCUhWfgBmgm6HYVLgE5BtAMPOh8BVA4gMIHFFbggRtG9HqYEVzOggZiQcuzQWc0gDrpoDv+RRUcGECzraBbCXiFVBhghxMi0h228oWRAVIGAweffn8Fl9fywGXjoLIXdqsCqE5h5RRkEAPeqMHOLc4Ayjvga92A28AY0JbUQ+oSRgYYjVlmMMIH9fjEtBhAS/1BaQ00eANavQVSD5qphwwmM4AHSmS1QhlA5bwQcHUGeLUXyE5g2IHqNFF5ewbIORQMwLNrZoHPtQHVV6A4BJkBuhIRfPYEcFAItPJHHDjwDTqrg6g6YEA7/7CQwxJn0HwL8sOLuzvA5dzFnUUMoHN9IOnnLqSMAvoZVDeCz9P5851BVNERvPIGdq4OaJYfNBAACitQfgMNzoE6+KDBS1g7AjQ4BhpYAKUH0HYmUeB1gO+enQHX56B8DRoUAq1iAU0kCMlYgM9c+M+ANAiANFiIeW7JMOz8j876D/m+wugAwGjvdzQEGPBUQEMxdBgZB8TVtBwAQOksAX0HqshBjWLQ8nxYQwo0mwI67R50Dz6oQQfqtIMal6DKH1TZg8wAzQqA9uyCGrCQBjfQ1cDOAqghCbrSDLSsDzS7BWr0gTpVoI4BqLMEWsIPWnYNOk0d1PECn/oPDGfQgVGgwQTQVUSgRgPoFHRGeEeLmQHUiATfk/4fcjATuBsMbLQ/v7ONAdIxADYMoB0hRKPhHwNoBcEv4DYAbWDHBrSkE75vFtzQ+Qc+eAs06wO+CgyoH7LnENKAB+0NBQ2MQFYH4BnlZqRmZx5bBx9ZjIQkCev4Q7XAO+XAcINc1/SVAftsI2XJnjbpF9lNqOGNPgAAWtIKGsQBXQ0G6siClkqD0jCo8w6aMX12ewu4wwaaMQbNdIE6oJo2lcClrKsYwA1U4KoBiJmM4MPcQDOtoCv2QGkeNIDw7f19cMcf1NAF7RMHNapBHTjQABTIHlAnHsSGHXYH2vICbuAyYm+YQ3zGCF6oADo0C3S1HsGOP6FGIxa7UOIFnreYgJ0ADrATQPn+zeMjDOCD/YAra0DLhUGdU/DqApAKeCeCAXxFGmi5PUgYNEsP8v/H11cZEMt4kfILLrdC3SAiZ8sAOsEddOCXlLofg5iiAwPkDvv/4I4aqEwAxQeogw1anQE6JAy8Bxm45BzEBq0AALkdNKsOGnSEzVDCayNGkB/ZGUCdRlDnGTSLKQicuQQPskBXH4HUgtLMG+ASftA5KKCVAKDyDVROgQcHwXuRkcsAxLkAsDvLGaArQ2AdRdDAKCjtgAY0QekQdFI6aAsVaAk26JR6FbMcBpBa8Mw7UC9sMImVQxB84ChyGgCXAMDy1SJ0JQNoSxWoIw8qo0HL+EHbB2CzrAywsEbO+7C4BtoG2Wv9H9whB2V+0KAHyCxQ2gaFAWjpvqCkMWTrCTy5wsofcCJALRyge8NB27hAZvGKaICvXAWVL6ABHNBWLFD6AK0WAZ8RAe6Iw2OGyIIG4hBwGgCuAAF11kFmMwJXVIA6qqA8p2KayQDaUw7aDgBaRfIAeH4EaJADlKZ4RTUZQNsTQOELSiOgARjQvnTQafagzix4EBqY50HxCDnv4xsDbIAJlEZAA9r/qdZJo9dsKbayBjLgC+rwgwZHQNs2WFg4GUDpEtRZB60CBN+O8OgIeMAFcrjfJQZEvcvAAOr0g+pK0KAcaCUeaMAclF9AakHpHBQvoO0pXHzSDKb+8xiu7q8DDyCAtvfB7ABNNIDKDlDbA+QWUH6HpA0GBljewR7etAm7AZv1HxYd/9HZf1CqHR0AYBgFoyGApYEwVANlGHb+wbED9xdixgV0hzhoBhQ0KwU+MRzYYAYtmQXt7wUtmQU1kkANRCkNPwbQ1V6gBjc38Go+0JJXUGMAMvvzFnyV0rsnJyExDjQDtDxX370PfL0ZbI89qGEPssfYZwZ4mSVoGS3oAD/QsmnQoMEv8B7BF+D9+uBl2aCZauAdxaCZJHXrUnDjFzZ7g7SNGdzxAHkN/V5rUMcL1Ml7BLzeCdZAh5wWzcMA6iBCZh5ZwadYQ67v+k+gEYIjQQ9QesHqGuTGP1QBvPMHDE9QA9rYdyYDaFUGeP8lWluRkYGR5JUBJOvB4kbiigrMhi36AADIT6CZeFDHEjJb/IpBQS+WAbTUGrRXGjQ7D5kx1WAADVhxA2f+75ycxABqEIM6vPK6UQyg67Be3tnJAGrcgtwFvpMauG0F1LgFdXJBs6+gPAHpQAkxGADTOWj7DEgMlDdAA2rgqwKBJ8DD0yskAzLAz1xAyosM8HiicoGJli7RBwFAYScO3HsPoo2Aq2lAfgDNzIFWPNw5NZkBNMMMyv+ggUBEfxDSIYQZDeoMgJZ3gw4Rw5glJWKgArTlAHRbB8jn985MZ+ADdiJB4Q1afgwaGADNqoPCEHZfP2hQETRTC8rboLwMmv0HDSC+urebQVYnArxqB6VR/x+yfB408w9ezQN0OPjKT+CBoKD4Bw1wgMokUAcRMhD4FzzAA0oroI47fA85PGqQ9yL/Z0BdqfGfAdZZB3U0QeaBBhxAZwWAaNAsPK+IGgMozYEGFv79/s4AWjYNWv0AWqUE2roE2nYEPkPhP9LNAQyQcwBAs9egLUmgcvo+8E50SBp8Cz7oFDQIA05iyEkIKf7Bcc/IAPYbaNAX5GfQiiiQH8WAs+KgFWGgQyNBq6xQBhIYcKRORkiuB9+iAixXQEvmQZ190KnuoD35oKv5QIOroM7dd+jtK4g99bhTPKwMZ0RJu5ABZvCssbQ58PR/PgbIvfT/GUB1FGim/zlwYA80EAHaCgCyB5THQQfBgq+bg8QKZGAJaDVoFQRooAWUl038ZjOA9IHCHJQuQKuGQIMgoBUukAM0iezkEOzQ0buzhF6wQ+ILMuDBCD6FH9QBBw1yKxolM4DKAdC2I9CACuhWBFBatInaxABaDQEJy7/ggSHQSjpQuICuSjQLWswAOtQXFJtqVkUMd09NAV+lCrry7+GlReDDdg08JzKA6l/QShvQoBUoLYDyMOhgYVCafwxaCYi0ionozj8VOtAD0vkfnfFnGG5gdACAYRSMhgDj8AiCAezMoTTQ8YUm0W5ExAm2BhWo4QnqBINmKUEz6aDlvKA9gLD7t+V0oxlADU7QSfigWRxQYwtUgUM6BW8ZjH2AS/CBB+qBZqKeAw8CBB2aBlnKycSgYJQEvmYNNIvyH7qHFtQABs3igRpXoNl5kBdBM7CgFQKghry4shsDaJkm5HBCJvAeWdCsgrCcNQNofz7oajNQoxI0UADthkA6VNDRAGQ/Is/mgzomjODOrygDaJ82aEACNFMEPrAQeJ0U6PAoBgZsnf8hNMKNo1MNafgzMsBmukA0aMb09cMDDPAOG46si9yxx8cmOuOT3fHH3mFAT9MQPzKBZ+5BK1BAM02g8yNAy7hBs5KgU+tBNzqAZiZBjVTQjDsovVuGrQbfqw8amLp1vJcBdN84yEZQRwI0MwzqcII6N+AD5sAdyB8MoJPiQcvKQTNa1w42gQ8Ugyz5fwucYX0OHkQBn+wObNxCghdbWkINePQVOsSFK7q5mA1/ROghyTFCBgFBDXlQpw00IARaLQO6rhPkf8hAnwL8nnzoRmqoURC9YA7QnBd3tkNyIJ5yCXtj+z94//qvr68ZQHv7QduDQMuuQQfbgTpukLKEmQE0swwqN0CDlaDrxUCrhdSAJ+eDZm1BWxcg2wauM4BmdWGrBxiQkgwjNN2ByhLQ+R+gVQXgGd9PjxhAV/6B7AQvxf/2GnjtaCED6DYBRcNkcMcQNQ6Qwxp72QDKJypmuQygmXVl0wwG0AFzoFUVoCXrsFslQIMAoA4saIAJdFYKyH6Qv0BuB29RAm7DgtjLCF/+DgpgBYMEhmfX14M78bzAw9ZA4QXqtEK2XiCurYPXI8grAhgYwMvsQcuvQWUuyHzQ+S+gFVfg0/uBy/lBM+CgczHAS+AZsBUK/+HxzwA1D5TnQKfog1bevAQOwoAOURUCdtLBB2YCzQANkoEGQkDhDD7QD7ocH1vaxtb5g+UJRui2JfD98sCtBKCBY5B5ILMfX13BALueDr4S4/9/uA8g0Q/xD6h+gSx9+g8eOAYd3giq/0DngoA6xKA8Cz5zAjh4h7h2jtJ6YKDqEdT8DoszUJiCtrCwcwoxgOp2UN4HHdwHWgUA2lLz+uFh8AALKCxAZSRoFRVy/QhqJ4DMAN20ABs4A7UPQNugYHzQABDoTJF7Z2YygM79AeUvUPkLGkAAH7AJHFD98vYmcNAujAF0wxDIbcN+5n9Ydf6HUNuIgbZgdACAYRSM3BCAdMWGhf+HQucfUosTEdy4OhcM4NlO0Ewb6Iol8Mn8Pz+Ar+phZecB76GU0w4HH2YFWs7PL6YNboCDGk6gyhs0MwdqRII60aD7ukGn+YJmy0ANPFBDHXJI4HfwbAFoP6UEcIYRdNf/a9CVZMDGH2jAAdRwVbMsBO83hnkEtDcQNGsKubccMlMFWtoK6jiADr4CzUJ8fHUJ3GEwB57WD56hYUCkPXhDEbi8H7anEzw7B610QbM9oKWJIHXajpAOG2hGF3QC8l+ku7rJXu45UGkHT6ca0vkH7eMGddiYwSeTs3HwM7DziIH3QIMad/BUAg5KRupnY5j7KA4fTLdhdJiBdoD27IOSBegQMNCp7OCDqIDxC95uAvQdSB6URrmFlMH7iUHpDnQlGKhD8Qy4hxx0zzhouThoCTEozYHSu4nvbIY7wNktUAcN0illYgClHWYWdgbQXlrQ0m5Q+gctgwUNLIEGt0ADZSKyVuCTxWFXV0ICF5ZmifAPztj4T1r+h4Y9vGPICHEDyC+gQTBQPgedMA9aKg3aEw5anv7q/l4G8IAHaAADNZEwoIQ7VrMZGBiQGrsYnX+0hjDIXtAKDVDHGDTgAuoQgw6nA8WNLPC2EtA+btA94qBVO6DBSdAAFqiDKasdygCaWQcNMoI6MfBDypBDhxGylUPXqYUB1EkBrRwADQaB4go0cACKJ9DJ8iAa1AEErYIAxTN4NdN/kMuRwxoSEBD/I4n/Rx0YAM2igzrFoNlo0LV0oFlWYWCnGNRhBfkLVN5c3lvBAPIXaNAUtMIBVC6C1IK2HsBO9YdkHSYG2KwtaGZdWNYaeObJLfCKK9DsvbZ9HXDwaSsDpFqA5HMGlMP8oIHByAgeOACdtQLayvIXeJMKKK2DBlpAHX7QoApoFQF4hhdsGAN0UAcWmJgDTaCDMzm4RBlAA0igwyBBAyuglQWgQQzQgYigwTbQVhlQXMFO84emPAYGlDSFPzmDwxsUxsC0CLqyDhRvoCvmQCtTIDfU/Ib6nwE86wzadgYaUAEdUgnKv6BDI2GrPBjgaR9yvgVoAAG0IgMULqBBaFCnH7RyCHTOAwMD9nyGMVCPt2M30B0lpHIG6HfQ9hZQ+gd11EGrT1TNcxlA592A4h+0px+UFk2BV/GCZvNBbQPQgABynQgqP9WtyxhA221AaRaUfkFnT1iGr2X48ekp9BYVJXD7AXxbBTCdgcIWdEYAKE+B8h0of4G2SYHCHpRHQOFMUr1LYUea7jP/o7P+DMMZjA4AMIyCkRkCjMPH24wD6xdazv7DGofwyAL6FbSnFrR89y/wIDzQaD2oowRqWIGW5IL4oAoe1KAGNQpBnWTwNXvQMAI10sEdIQbIPfugBjyoEgddnwQ5MImBAbQHFuQn0Anp987OhBy2B7yyD9QYAy1dBS0zBM1egfcOMrEygDpgIDNhS31BDRTQDCuoEQJaXQDaxw9abghqkDy8tBTcwYBFGSMjolMFHoQAHtym79YDntVFzAj+Bx9EBFp+CN63++M9A+gQKZD9oKWIoFkgYhIz3niidxrCYx+k888IPuQK1FEVAx74BVrWCWrcghrFoPAHzeyADn4DNdRhNyEwQHod0JUVJGRvZH3kmoHTOux5E9sAAMgIUEMe1JEVlDYB388O6hyCT7EGXvcHWp4PuhECpAbUuQSlD1CHDDQoBUrDyqZZDKCGMGgLCyhMBCUMGF4BV0uA9heDlkjDXAKSA828gk4dB9kJ6jCDttKAOs2Qu7JFgQdQcjA8urSEAdbhxJc8GDEkcZVHpHQoUBv/2AYAQB0+0Ow7aK8z7BBMUEcY5H/wyhmg5yBLxj8wgA9YBC/XheU3Bng6QckXsPjHFp/YGsOMkNlpUFmjZVsNnpWE3OjBBJyNXw1ergw5F4QJvHUItLQbFH+gARpQRw3kB1CZAh7Iw+i0/QcP9IAGakCDOqBtA6COI2hgEzTTe2xlEIO0RgB47zqoDADNZCPuJf+HxQfQLiwj7IBEUHzAMFQ5MIxAHU5QugOdOv8JeHc/aEsFqGMPWkUFSiegmXfQIAGoAwsqg0EDnyD3g9SAY40RMghqHbkRvI0KMmv/nwFUHoJXM3EKg5dbP7qynAG0PQo06Ana5gBa4QAKC1AcIjqw0IELoPNAKwcEgCfegwYfQJ090EoY0ICLoedkYHm5gQE0uMIIjQ/QnnDQsnDw+QT/YeceMDAgp1XQQDDskD9QnQEaUACV4ffOzGAADSrpODUzPL62igG+/J8RkmZAS+1BHXTQQBHk/ANYukZdZYCouxjBgwaadtUMjy8vB+/TB20RAZ2pAIpPBtjhgkDHgzrx4CsDgTPcisC75kGDOxYhK4BXNy4GWQ4eCAF1XkGDdqDwB7kDtOUMdPUrKF+Dr2PEmk4ZGYYeQC0DQB1vUBoBpUHQqqY7p6eBZ/tBAzRawMEk0PkJoEP8QOkHUnfCrhL9Dxm0AaYD0DkUoPNPQOfkgAfegNtpQFd4gswEDSaCz7UAHuwHHj4D3sgDGlwADeD9B69s+c8A3zbzHy3fYAQu9QdP6Nr5H7Yd//8MowARAqMDAKOpYQSGAOPw8jPjwPqHqAEAot2I6hfUzgVMDlKIg3igu8xBewAfXlrMAGoEQTqEf+BLRkErAkDLAUFLnEHLqkEzmqD7pEEzdKB9/KD906BGHOggMFCiYAc2TtWtSxhAgwEfX19hAHUsIFcpMYAbgqCTnH//+sQgrx/LADqYDzx7CtwmAFp+ClrmCt52APQraIYL3LADyoFmv0CNM9CMEsiNsMYtyG+cfLIMoFk2kBtAAxugZbXgk79F1MEnVqNsBwBWyqDZYdAqBlCDGdTgBd9ljaXjQFYCp0c6wtfBYmBggHX+QSzQjA1oWfdb4PkMoJO+QcubQfEICn9QeIE6rKBZSdABaRj+xdWpxyZOs9IAe77EmqYZYbnoP/hqSlBDFbTvFLTXG6Qe1GkENWpBaQg06COjFQxeog3igzp9oFlDUOcftEUAlCZA+5tBDWGQXtDqFNDsLOh6K5BXwfbDZoiBtAXwZgvw/lngYXigmVDQYAFoRtc+fi8D/AwKBtTOEyzIGLGmGXR/k9vogpoDDhtGBsQMKLgnBl4GLQC9Ag10/R4kDHaD8z6okwjKk6DD+cD5GnjdF2yFDgNSGsTo/CM8hpoq/qN38sAhyQAJTyYG0BLkBxcXQe/1f8rw++dn8A0LoNVH8noxDC+A5zKAXA1e7g3sTIA6rqBBShAfNJiIbyYRNMsLKyNANEg9qExTsypmAJ13AhoMhSxTfwYe6ABtawLfCAIrF6D+BeUZUQU74A0B8eCZU1ngFWrgwwcZUM8GAKUfUHoDHSwJ6vSDtoqAtgaAOpegpfegWyJAZxeAZrLBBw3+/cUA77AzQtIJaMsCaPk0aKAO1KkGrVwBLaWGnb0C6sx9//gIvE2DmY2LATKI+Z8BvF0FeC0fYj89KOExgcsFUH4HhRf4mrsPD4FnoQgxgM5GeHJtNWSPPHBgA3QTxffPzxlAB16qAGeIwSfp/0cMhsDTKzTdggZrQNcyMrNyM8DKbNAgMnh5/pUV8M4/aBAD5AdYxxIUlqDBSNCgy1egWxgYMFcZQNIGJK2C2JBVHP8ZNG2rgCs6DoMHRP4jX9MIdBP4cD+gYtBZHqDtP6ABgXtnZ4EqHwbQqgU9t27wCjXwIaDAM2ZAgzUgzABfOYHdHQwkA/I7SvhmxLGXF/gchygDQGkDlE5A4Q5atQEadOLkl2UADdw8v7WVAXTgqZ5rF/gsjldI1zYiTGcEbtexAW+dAZ2dABo8A63eAXXuQbdmgM4TeAO8mhI0UA+qe0BlKPj2IOjVvAwoh+1CTCVp6T8FnWq6df6H9Yz/aOcfPaeB6ySGUTAaAiMmBBiHl08ZB9Y/1Jv9x/QHzplFpA4BI/jkc9hSUybwMkqQGGjJLahDAGo0gmaQQfsGQZ1/UMMOtEwadIIwaBYU1CEHiYE6VaDBA0Hg9Uughi+oEQiasQJdNwWZaXnDAJoJAA0cgBoMoJl4UEcCNLMI6tyDGvmgDgDIDvByawZohwVYoYKWK4ISHWi59ec3N8GNORAftIQZtKcQ1LC5d24OWBw8G/j3JwPk8LDfDMirAP4jdULgp5YjzUT8x9pJYWDAu6QZV26gdkOAQDrF7Igxgme7wCenc4kwgO5tBjkVdPAZaI8yqAMBmq0RlrFkeAicqWZA68Tgz+SoaQ2WznCGH1klBvZ8iS9Ng6yBDIBArukDXycHOgkcuM8cNOgD6kCBDgADpRHQygjQzD9ogEoYuFwf1Dl5fHUVAyP4CrD34EEEUOf3ybW1DKB97qDrMf+jdISYGEBbC2BioAEA0Gw5KK2AOoV/gTNjkDCFXXNFSuMJ3e+UDwCAZmTB1+eBO5sM4MEAUFiB8iMIg5bqgg8D/foKHFugsAN1hHkElRmUzbIZbhzpAG8dAYk/uLAAJU+ANeBKn0gDJQw4llXDBhHBM8LATpmBxwQG0F35oEPkYLPHkCvEuBhAA4yg7UUMaDd3MICzKXI4YYYZqFwDdX5hHU6Q/8DXngHDRM+lk2H3TEMG0IAZ6IwH0BYZcFnDwAAdOIEMroGWt4OWPoMG0+4CZ1CVTbPBV/zB/YaU75lYOMArQECdUlDnH7TqAFQGgq/MA3eKUDMGrFMMsgm0Z1rVPJ/h9smJkNP1+WTAZRpoth/UqQXFFagcBg1KgdI1aHAWUh7fY0CkU0bwYI488CDMR8DOOHi2HVT2g8p8YDoHbQMADXiBzkYBldGg2WHQDRmQA0KZGEB80CwvSiebAVKuQLYmQPIZOA0xwrYbMTGAymnQrDpo9h3kFtDgDqieAN0uAToXQVYnkgE06Ag6DA50QwvcfFDYoaQjRgbECi/IqgjEIBb0Kk5GyAABWB3QDVp2tQygwSHQqhFZ3UiGq/tqwVdAgraKgPwPOqMAJA8qB0D+BJ+KD/QTKB2IKbmAr4JEhB9sYAcpLUHjF96hxFnOE59n/1OhriA8MACNN6T0jFKeAcMAlB/Ag2mwPItWbjPC6mQgDVpNBkpvDND0ACo3IemAGVyGygK3EoLqHtBA+zfgAM/nd7fBqw0gq81AYQMJH0y/4wi30c4/w8CD0QEA9DgYXQHAMApGRgggRuKHjX8ZB34wg6gBAILuJL2zhKjMwU1n8AyRpJoPAze/HANoVgo0IwabfQJ15EF7dEHLdEFLcEEN2afAA6lAHUhQowFyMB8jeLYHtCUAfFUTdGk/qLELmiUCbS8ALTkFNcBBjVXIydjfwEkJtBQfNJMAuqcdRIMaasyskCvKQEs9QfpBDTTwieRgrzKCGxmgxgeo0wW6sgs0qAAeOACGFeiqMNB93uxcwuBGLEjff6SOPrxD/5+GFRq10hYjI7wDgi3fgTtxDEjxD7eXETzjBWrgg+ID1PkDnasAokHLMkFnKzy9uRF8Fzj22TdGjOYfAwNqGQBqdIJm9kCdX9C9zqD9xBBNMHXklBn49TCidRDgjoSKw9I1MwsbA8i9oJlY2NJoUDiAGqWgwSZQBwq0lBU0a7VzqhZwpn4puPMHOgAPtKwcNGAC6hyAZsxAHRqQPaDVJaAzLUDX9YGvTwPa+Q/a0QevTgEebgUaKAAtnQYveUVJX8SWNejqcKdRfAenISIPkn5Ah3eB8gRoYAx0qwdowAO0SgE0Kwo6BA3EBnUEQfpAYQy6thM0+w4aKAItTRcQ1wdvqwEd2gVuxCM7EyNOIJ0N0KALNIMzIKcxdHeDjYIOroDMBuV1cDoFHvgGij/QDDO4g8EAuoYQODgDGsQAhS1S+KKaCQ0zjPwNul7wPfTQuL/gMxpkgPfGg1Z4gPb/cwMHO0BlEeSw0bcMiLTMwADr8ELuwQe649tb8PWCoJly+OwxescJ6CfQgYVPr6+DrGz48oLBNnoLA2ipNVgPvEz6D85aoNUqoHvsQVcygmZnQTPYoOXyoC0ZoI4ZaFYV1MkCDZiA3AkSBw3owQ5EBB8i+B/pXnVGSKcZVG5DZsb/gwduwOUz6GBU4KoOUPiC3AJa0g0ayAXx2YHioPgG79v+/wcx2MMIiVfQ0nuQWpA54EEbaLkASjeggQtQHILOBgBtjWGAugFUJoNv0vj3F3yOAWiggV9cB7xSDOQXjLKNEVIOwAcAGBlRVjdBOvwM8AECRmg5CYpL0PaKN4+PMYBuhwDVM6DBDbD5QD+D0jlocAI06w1aDQYamADdia8C3P4DYqtaFjCAzreBrXIB20pyWU64Xvn/n7adKdwDApA0wIAlb/yD5SucA3UM4HzMCM2HkLICuOUPuO0OtIoQNLgFOlQV1OEHpWFQmfj0+loG0EAPaDAVlBdAWwwYcALqhsnorD8DFcFo5x9bYI4OADCMguEfAozDz4uMg8NPlA8AYPcHZgMASR2WxhSo063n0gFu/IAa36BTwXWAB+aBOtegxid4H99/yDVZ4KuqgCkCtHcf1FAF6QU1/ECNR9CSYtBSUFDwgvZcg1YQgFYSgGbuQB1EkNmgpcRSar4MoI6SuLI7A6jx+fP7WwbwDQRAjaDOCegKIdCST1BDDHQCOGjwANaJAHVaQFsXwCdZAw/GAjWCQXs5QR090KwWyD2gZdl3gVeLgQ8zYyC18kILU6S0QlR8wXILtFHKQE5ag+nFkvNgnX4Mt8DtgbgfFA6gmRrQrCXocDJQZw4UtqCGN2jQBrQX+f3T0wyw8QNMZ8Ia4UzghjZ4hpKRAc4GdURA5oMOZrx1rAc884jdqxBz0AcQIF7DJ4fqeUJpGqQaFCagq+xAHR4eYRUG0CAWSAx8ABuwsw7qSII6vKAOCGhQCjQYAlpBAurwg24PAKUzUMcKNGgECh/YNVh8wJPXQTOu3z8/Ad8tDjrYSg64NB10iBbolHpQngBdnQeaGQa58z/yDC9avOAuTBmxxja6IDGdB0YkO0HxBjr7ANTAB+UlkJ9BZ378+v6GQQu4rxp8Hsbf3+AOFih8QPEEuiUEMrj3ngF0eBhoNl7dspgB1KljRE/fDMhxCEkf/MABA5Ao6JpE0CodyN5gUF8SOS+C2Ag/w5wMyrOggSvwTDSwQwtig5bMf//ynAF01SIobn8CO+AM/2F7lHGHKGon4D90dhxkL5AN7PB8eHkBrPk/dJky6KBASNj9x5h9BocNuBMJWiXxnwE0oAYq40ADJ6ByEKQXYhhiAOLV/f0MkMFJkNg/SOcftnqBAZYDwJkKvJIAPEgHPJUftnIJNIMKGmADDSyBBqJAcQEqB8EDOMAyE3RjwWvgcm3I8v6/0M46ZEAB5A/QIKimfS34SjdQuQzq9IKWeoM6wKDyGmQ2aFAI1GkGdY5BfNBZKqDyH5ReIFukkHIqcPUAaOsCSB14VQnQrUrGqQx8wANjQQMn1pGbGEArREADJSAzQDpBfgINQjCCBx1EGUD5D1QmXT/cChmMQSufYYN4oMEOsFuBNzSA/AIasAPdXAFL25AVDUwMoAFpUL4F6QOFG2Q//1/woA1o1QFosM7IexoDaCsZyD2gpeugA+hAYcvOLQ4+rwA0qAEK21vH+xlA6QqUKkEDHKBBGdhhdSB7wXb+/8+Aux7AX9fQuuOPLSfgHgyA5T1cbmbEnrEYoVUGVBp0zolVxDpwvIPKFVA9DMoPn15eZgCdPQMKx6fX1oAHWXGuAsJXR5MxWEKXzj+NB3EYRsGgD4HRAYDRRDrMQ4Bx+PmPcXD4aaA6/6AIZYQeZMUIX7rJyPAceKUXaIYfvEwf2CF4eW8XA6jzD1LDysbDAOrwgZbKgvZMg2Z5QAdrgWaLQB0nUOMYNGP4B3jyL+hwNFDjErwvFThoAGKDll2ClkWDZlH1gfswbxxuZxBTcmYANTBBZoE6CqDZApBdoAYb7BRi0L3roAPbQI1f0LJRWOcX1JH5+v4uw2fgIVughhuoAQfeyy2kAj78DuSOPz8+MoA6OwzIs/9YUzMkPTDSMl0gDwag24Muh8UdODv9MP+gdPiAqhkh2zpAHX1Q5x+0bxa05/ke8A7xr++A4fbmOgNoWSyoQQb2PTRLQJzCCO3kM8I7QaBGnHfRY4bbJyaAV1+A7tsHzX6DltGDrmnk5JVmAB/sxQDrOOErNkCWwTBxxQv2uEHKx1D/g8IJdKgVB48kA6jTAWqIgjoBkFUsGgywGUnQFpejy3wYjIF34INWnYD88RrYWfv59QUDuOMLPCgSNKsF2usKMvP3r8/gfdagjgY/cN88aBUBaH80qFMCWhEACkfQknFQB+Qf/Co3JL+hDAIglz+khwWxBTIkzBgZQP4HrZQBdaJBeQHkRlB4gGbW3z49CZ6dBi3N1rSrYQB1Av8BDwcFdbLBZ3cA8y/Iz6Al+aD8C75Pn4EBOkEKGRhSs8gHpyWwT8DpjolB3aoEfNI9aJAFtF0IdFAYovGPrcMBS2sM4E4s6Po8SL4F3oMPnGEEdVJBgxJ/wZ3jfwyQAcF/xNdN2BrrjMgdGaj9jIyQ8TBGJsQAACMjeLUAaEYTVDaCykTQmRqgPAFZAcIAXp4P9h/cHogfsa08QpxLAnU+0B1yOhFge0GDTKDtVvruvQygQRfQIA1oywHonALQQMLlPRUMWvb14EFTUHoDhcs34KAUA/SgPkZYZmaE+AeUL0EdXdBp7aB4Bw3AgjpsoE45qCwGldug8hc0AAs+n+XHB+DZKbcZQCtkIGe3IOIKlJ5At1uA9u2DynbTgPkMoMFXUBoC5TOQWx5eXAxeeQRig9wEKrMlgYO9oEEDkP2gAUNQ2Q06dwDUWQTtFweHAijckPIwAzjMWRlAdQnomlrQSiPQ1gxYPQNO28A4UgIe9Ae6aUBc2YUBcj4MKP38hcQd0AzQgDBowAG05x00UMPNLw++TQZ0fgNocBs0KApK06ABIJBfQNsWwGUicKBDFhgnoDoNLAYMXw2bcgbQQBZ4+xrJg8rog18D06wir45jRHUsI3J9ycgAqmtBWzlAikCDMaAVAJDVRJCBEtCKKtCZK+DtFkh1MVFbxkY7/wwDD/4zjALsITA6ADCaMoZxCDAOT78xDg5/MTIQ4Q6sbgU3tbHGDWYFj1l5Q2ZymcAdOVAnALTEHrysFNjYBzVowbNhQHtBnW5Q5x60hNLQeyp49g/UoIPtEwTtPQU1jkCdCVDDFNTQAy1TBTX0QB1O0MwqaLnllX3VDKBDmUAzeqAG9InVYcAZIx3IrBRwzzGogQvafw0+jAloL0g/aCsBaD8uyC2g+5pBAxDgvb9grzMxwPaXgg7yAzVeQQ1c0LYF0EnfoBlD0OAAqCMIW/6Ouo+VAbqcFDkIkRs1IHHsjR6IDBXSDyheYRhPLoN1/HEqgZsBVMnEArmBAdwJY4DO6EIOAAPtaX54cSE4xYFObIY0eD8wQGbEWcCnoYM6CmB7/sNmZqHpDGgHaCYMdLXeZ+DAAWj2kZVTkAE0Cw7qUIAa+5B7s1E7C9QoPBgZkTqGGAZC4wEpjzBCZ6MhJ6t/BV9/CO4sAv0kJGUMPlgOlNZBfgB1eEGdANA2E9B+ftA5FqB9raBzKUADJ5DZfWhYADsAoIGs/9BZZ9AgFWgvOShtMjD8Z0DeNwx3JiNaDkeJb9x5mAGXPxlI70SArAR11kAzvqBZ3n/gA/TegTtIoDACHQoJ6oSBZnBBy7QhS9oZGEBi4LAHpilQeIG27YA6jeBOOSNoAICJATSbLKnmBb7LGzzYB0x3oHAA+Rq0pB40aw06BOz2iX4GUEcUNKP8D3YGAY7EARu0YGBkhM6y/gdfUyoqbw++mx80kAg5+R3VALwdG7ROOUQn2BPQcgCUxpjAA5wgOdi5KHxiOuCBBlB5CTrMD9QJBV/bB9w/r+vcBj5MDrRE//KecgZQ2KIPcGCb7cXo/EO9YeQzjQF0JeW3T48YQOdygG4OAHWkQPergwZJQQNOoFl10GFroFsuQGkTFH+g9AeOV6RwBcU5aIYeZDQoHkGDMKCON+h0ftAVmKB4BJ0lACobQYMA4Fl/YTXwjQmgvAIaBEbu5EKyFyQfgspR0JksoFUdjy4vYQDlF2kNf/BhhKArFUEHHoIPLOQSAg/uyoEPcNzOADlA9i0DSA7kFtDNEyAzMAbLYPEOLcNAeVNc2Y0BdCjj57e3GUD11Ze3txhAcQI6ZwZ0cwdIDag+AJX/oHIflDdBWxjAWx84BMCDM7A6C2QfKA2CV6IBzwYBhREoHECDKOCDJYHnx4DiH1SPgVcxgFaaAPM36DwB0AF3oC1soDQAGojCTMLYO0r/B/FMMWkDAkj1HrRchq2S+PTqMgOkPfCYAZQ+QGUp6AYf0IAWqMwAbSMCxQvkYMCfDAwMtOlU0nzmf8TN+o92/vG1Y0YHABhGwfAMAcZh6q3B4S/KOv/Yowa1MsfSwUBqXIEbT8Zp4EavjGYwA6ijD5oBBc3WgWbjQTN+yqaZDKCle6DGFuhKK1CHD7TME1ShSwAbZaDDzkAVPKgBBqJBe35Bs6egRtmL21uBDfajDKDGJ2j5NGh2BdTJktEMZADvY/0H2U4AalCBZms/PDvLwIA0ewzqSIDv/v/8FLwKAXzLwH+k06jhQfAPvIwUZCaoccjOI84A6nyApEHuAe0J/Q+2C6aBEbHknQHBhshC0gYiHHGnFaLij8wcBOv0MzJAOymgThjILHCUMsKmXyE0A0QC5GbQ9gtQZwDUWAaFtTQwrEGduv/QWVzwkACw8wLqAICW4IK2XIDiFrSCAjQDDEoHoEY2SuOMEdI5As2ygWa/QOaBBgNADWBQYw50gB6oEwA6PfrF7e0MEL3o4UheQOBvnKI2RqGhAA0TaOwA3Q5eAQDs3IA6HaAOHWhWFZSOQXf2g2bvX97bzQDqUHDxSTOAbqCArFz5AE4joD3hIDVfQAdPgnwGDEfQne4/v0KWgIPMBnXC/sM6XyiNQ6j7oA1lcNQxMCIGnhiR4pGBUkBoCS9ogOIv+LYM0GAdqDME64iDOleQ2duP4Gv2QFt5HgJP4wfN5IFdCzyUDzTzDVpJA1rOC0mSTAws7LzgfAmaxb1+uIUBlA7AAwRAr3DwSjCAZopBHVVQfgSFKWhlAagTBVqNwoDeiIYP4DAyYA4AMIDjFDTwBF69AOo4IM0iguOdEZHeQPpBHdr/GNsDEDPyyOkKMsjBzAC+KeDXF3BEgDo1oDMyYCuRQGka1GGWUPVkAG0dAe1lBx2OB+rwgmbTQWkLtOwdNJCJMyaxdhwQbrp/fh4DZK/6f3D5CDpIFVRumQUuYngMvO4P1BkFhSFooAUUjqADV0FpD9TRQhlUAQYFKG2DBm9B4QC6ZhDUqQet+gGVtSC/8YloMKiY5zGAZrdBAz+g2wRAZTn41gtg+QDqmCOXAeDwYoQcugdKKyBzQf4G+RUU56DwYICuKAPnF+CBb6CBWNANGKBB3c+vrzGABoJBqxyeAM9DAIUdyC7wjQ7//zMwohWzoC1eoM4kaOsYyD7QigPQeQSvH+xngJzYz8AA2YbABt42BirjQWaADv4D1T86zi3gq2dBq3dAfgFvhQJuB+ICzv6DVjWA+LDVDaAVBixsvODBLFAYcQkoMIDOygANcIJWB4BWzoDcAYoP0GAJaOAFdEMFsR3Y/0Osw0h4QAC1XAOlA9BWPFB4gAZXQOUBqI4ApTHQ4ZOw7R+gcgC0zQp0q9AL4MpC9MEyrPmGxLAb7fwzjAI6h8DoAMBokhtmIQBpqg7LaEVvaQygJ8kbAGDE6WLUTita5wja2YDZCWpggRo2oFkS0MwJ6MCeF8BrgBiBjX1WDj6GJ1dXgwcEQA0rUEcS1GEAXZcFquhBnWxQwwh0KjhorzVoVgzUEAU1lsGzZEAzQI2Arx8fgmdpQHt2QfKghhuo4QiacQZ1GEFL9iGnsXMAO14HQFOb4JkvUMMU1IG3jtgA3FO4ENwYBp0XALmq7j906TEijcKW2IIadaAOKeyOa9BeZdAyZtDVgAzQgQNGaGcMdAI8+HCtz88YGOFbISCdD/OgJeC7tyFhBZsJhwY7WvohKg5JSGOMsA4iA8I+0IwZaMYe1FCFLE8FycH8D+1Wgv3FzAAa8ADNGIJWRYDvaX5/j0HHqRU4Cy7GoGFTyfD85iZwZwrUOQBda/f81hZw+IIacaCBGtAydxZWTvDMHdgtQHNBAz2gVSGgTgYobYA6SqAwA82Aglzy4flZ8JaLBxfmMcBmfxlQkh8jybkMFk/4NSIaopAQQeZDBi1AbgfN6oGuuANdawVaRq0KXK7+7893BlDaBS2hBl0XCGrggzpUoD3/oFlX0B5o0H5p0H3ioI4CqNMESr/gpdLfXjGAOhWgFSqglTPgpc5gh/6HD8hA3M/AAOtcyutGIU6KB6Y3UD4AX4kGOycAeTAAnQ0PBFzhSGiGhhHawYLMpIPiEdTxEpG3A8+MQlbOaDJoOzQygGZPQSsfQJ1/0KCRqLwtA4gGHQ4K6niCO08MoEO/WBlAy6O/fXwAPmEdtDQaNCAEviUEuMJACniYKOSgtVcMoCXYoDAHnasAWvbNgK1RD89XjPD8CF8BwIhI4wywATEoDQka2KABNF8AwxeUhl/e3ckA6vBCogbR0YYFJyM0zwjJmDOA3C0sbQa+3gx0dSToMFJQnH95exO8fx8UZqAzB0BpBDQAqmyczgDq7IMGxUDhAjpTA3R1Ht5OISNamcyA7iYQHxJHoHiArSgBDVCBZqRBK2xA7oCcXH+JAbxaB+0sAWgIgA8nBMWbunUZAxsHPwMonTMyszCAlmGDtwwAVxm8f3qKAVQ+gspq0NksoEFa0GoYbYcGhpd3diCyHiMkTkDbh0CrCcC3tADTLWiwAnxdJnBwEjT4C9kOxAcejAWdvQIaSAb5ATQgCbseDjQLDCqLYcvDkfM3cv0FKnt4hdUZuIWUGPSB19KBBkdA2x9AA1GgsyxAaQg0wAReUQZ0H+jkf1CdBRoEBsUbaMAJdBYHaIUKuGMK3M4GvpXm02PwzR2gs0FA7gL5AXxujaQB+DpE0PWxoG0QoE4rGzs/A2xgBTTYAPIPaEABFH7oq8lwlVP/h8FsMfYBAUZwWQc6MBg0UMMvoQesXyoY3j05wQCKH9CWPdCAEuhaX9CAnyLwjIg7JycDV5n5MVw72AiuJ/7/J7B9h4SwG+34M9AIjM7+EwrY0QEAhlEwfEKAcfhGJuPg8hvBziOGezHdD+soMUIbybAZXvASVlhrEBqjcPuAakH7H0ENctAe/PcvzgE73ubADsp14KydJXiGBdRBAM14gGY6QUt4QebyimqA7/QHNcxBHW3QHeEgNqgjD2pYgg4JBDUCT62LYVAySQc3PEENKNDhVKDZQZAbQTPHDy8tZgA3yv78ZLh3dgb48Cjw4ACwIQmaQQDN9IDuagbNtICWiYLshx3UBemUwq5/YoCsJAAGC3gmCdjIgxw+yAyeHQLZB5o9Ag1gIBrmQBOAtxOA3WKUzADq+IFXCDD8AxnGwMkvwwA6FA90Ejxoto0Bfsc0euMdkU0wOu0k5iCYfoz0AItTYEMIdJ0YaK/6/QvzGUBLU/lFtcH77REdZUZw3wh0CB2owwWaLQStygDNWj4BXm0HWj0BOigM1nAF7XkFDcKA4gykEbyM/+dHBtCgCOyue8hKeibw8mvQjDlo4AY8wAA8NAtEg5bTPwQuAQZ1hECrN0AdKZB9oA4CekcINZ1iDyBi1KDqRHT4kdM2I2zvNpAGdVBAgx2grQugQwBBnSZQugbNZoM6D6AGK3h5tJAqA6jzA+rcgWZ5QR30T6+ugM8CAHUUQCskQJ0yUOcFNADyA7gqBXSqPqjj9A/aiYd2U8H7n0HuAQ0wgDoUoLwImlUHsUFxA5qdBV2t9+fXJ3AHg1CpBBnYYmP4j/XAO+IbaMgNeZCZoMPUQP6EbJH5DByEOwTeDgLyIwevFANonzbokE5Q2gANkoA6f6ADFUF5nkdQkQHUmQPNUIMPDP32huH9i/MMoJUQILNB6Q/UuTINmAdeVQFaGQLaJwxeLYFl6S84DKADI5A8zshgG7WV4fHVlQyINA4t0BgZ4cv2GaAjTYxoAwigOAOVT6DOHegKU9BWhPfPz0OTz38EDbQTtE0JNKAJyi+g+AcNdoIGikADbiD/gwaPwPf1AwcLQRrBV/Md72MA7WcGDXKAyhjQUmcGLB0aZHdBBi+gg0IoCRkpDv+DujKQgw1BYQIaXOUFHj4JWskDOmcCFAegMAelR9DAFuZZApDOOqgcBJ33ANr3Djq48cXdHQygQUHQYCzI3aByGXwFItA+0AAe6BBIUNyA4gyklgG2wgIcMaBBV2bwAC2oLAcNAIPOZwDFAqg8AZ0DA9IPGnRRMkplAA2ugg7ZA3XGQXkINBAsDBxkAa0yAA/GwldwMDAgBgrRB3EYwGdRwOIeNPAEOswQNAANO1wTfCgtMO+BOpn3z8+HdCqhZ2+wA7cfgOIGVO+A0gFIHyjtgjqroPoElGbBg6mMkPMlQPEOv8EElJaA5T5oCwRoFhsU3qDBctAqD9DqGX23HmC6XM2AOdiDmhcHpvNPbHnAyEAOQB8MAA2UGPvOZLh/djZ44OfVgwMM4sCrFEGDViA5UHvgMXAy4RHwmllQ+gOVw6jlGA73DpbO///RDjDDKMAbAqMDAKMJZJiEAOPwjcmh1vkHxQSKmxFxg72jBJEHd36AM/CgPcygk8kZIE1lBuQOEkgMtGQT1HAFHQIHauSA9m1Clts/Y4A1MkENWlDDR14/FrzHF9TpBM2ogE8MBza8QJ1AUKcKZCeo0w46DBDUGAOdA7B7hgGDtmMzeGYN1LgG788EnhJ9/+wscEMStJ0A1AEBmQ85Zfo/eEYBvMcaaPa5rVkMFiErGO6fm8sA67SC7AHNmmrYVoDvkAY1zCD3VvOCD2cDNSw07aqAcucZHBMPM9wGnuYMmcH5D+nLMjJC9z2/As9aghpzoEYqiAZvEWBiAnfIQMs8QbNNoJk9jK0DDIhOJ3pmYUSfvceTm3B2+mF6oJ1/UFyD7qsGdRpBS/RBcQZaZQGaQYMcggZOKAyM0OW5oCX6X4Gzskyge75B+7GBWx9AM7WgJe4glaBZMFBDHTTQAmqog8ITtF0ANKADavSD0gADNO3BOmKwFSCgdAO6FQI0kw6KU9Dp5qBGMGhGDNQh+Q7sIIFnUmXMGEDpADSwAgpLyHJiRGAgp1/SO/3wAGJAdid4ihvoX9Cefsi1X8/BYQLu6LCwg9MQKOZAcQoe3AF2WEGDP6D0+/rhIQbY7RTggS/gXlZQhwC0DxqU9kHyoCvCQAcdgvIEeCYWmEZBBx6C0ya4kQgZgAHPWgMHskCdJPB+ZOBhi6CwAa1gAXWwQNtsQCsn7gHzAWwpMygMkdMDCpsRsi8d1JkDpUnUw8dQO44oyQ3H4CEkWTEygMIJtGcXtFQXdEAa6CR70GAXaNk2SOz39/cMoPgEzQr/AB6KCBr0gNyJDzngEZw3gB1eUD4WkjJlAM2Mg/SDVpKA4hw8G8zOB86/oBUVIL+DziAAN/6RG9VQd4L9DJyhllLzZgAtxwaVCaC0AcqbiOXtjAywqwAZ4AOesGQAil1GcBnCCB74+cQA6oApGMQxgDrzz4ArXeCdWpj94I7ef/Ahc6DZZtAADeiwOfBgIjDfgMoskFmgVS+QZc53GJRNMhhAh9yBOpCg0+NB6QY0UIg5m4mtvGZiAHUiQfEOGtjk5JdlgHQiofEI7vyjdjhAaRTUYQcNNoFmUmGdJ/A+fSxbIaClAQPoCkeQHapmuQyPgNsHwHkTeJI+5FrH3+D99KCOMChOQIMjoPgDnZeC9XwCaFiD4hB0cKYUcL8/aAk/aPUAqLwGDZCA3Aa6Su8T8EDW/+DO8xcGUGcQlEdg14+COvGg8gv79g/0AQBG8GA0bIANcsvLG/CAHOhQWNAAHGTW9z8DyG7YdgJw/gPGP2i1BhMwPYHSD2jQAnIo7U9w+Q/Kw1LqvsAVQLYMoDLKKmwNwwPg2SigG21AhwyCykjQVgDwljIRdcj5Ab+/gVdcgPL+o0tLGUD+xrfagz6df2p3Tolv/8EHAoBp9tHl5eA2A2QbBsQM0CAaaBAKdLjqb/Bhqi4MsPIDlEZRDsZkQAOjnX+GwQFGBz+IiYfRAQCGUTD0Q2C080/POGRkIBDeWDr/qDNhMNdCG74MDOAOj4x2GANoaaewnDV4RgR08BKoIob2gKGaIF0MFbMcBtCsCqgDB9rvKChhCG4QgRRBOn9MDDLaoQygDh9oZg90wj5kxvg/g6icLbhzD57NBJ66D1opANp//ubRUXCDGrTcHHRdGvhQpT8/wEvT3z4+zgDqyEDuX1ZnAHUsILPFkA4JaOk+qPEIWj4I2ooAmjl9+/gI2M2ghjjITth1hKCZ+l+gq6Gge+Mhtw38Azc6QY3AW8e6UWdMwcEE6iAwgZe9qgGvM9NxamZ4fnsbcC8zD/igL2XgqgXQkl5QBwAUfiA2JMDQT7WHxh2OQSWcnTkGhAzetIbU+Qftq/UBnrz/6t5eyB5lYFiCOpTgVQvADhjIRNDsIKgjC9rPD9ovDJplAc3KgZZigg+3At6lDurAgU5QBy19B+2Dh3QEfjHA9vyCOoOgQ9ZADVzQig7Q/mfQjC2oIwgKT9AsOajBC7qXXFzRmQF0Oj6oEQ7qJIH0gDqOn4EHc4E6SqAtCKDZSlDDGzS4QP18hZR3GCEzeOycQuAZTtCMPqjDyMLOwwA6CBKUXkDL2fVcOxkeXl4KPo8Cklb+gg8vA8UxyI2g2UFQWhYH3koBPuMCaAUoHYAGtkAzWaCtEiD/wzodDLBD//4j718GdWKYwSfug8wD7b0Gha+J72wG0FVmoMGVK3srGeSA2wFAW1xAAyMi8jYMoE4KPH8yQjqxoHgHndwPGuwBdaBBM6qgFTEgN2EkO3wNZrRyBDZQBDIL1JkGrUQAxQ+oMwqyDxTXoPABbR8B5UVmVm5wGgEvN2eEHBqK6Pj8B28ZAF2RBprdA5sHXEkB2tYDXiYNnI0F5WFQ+MEHSrC5FcmNoP31oAP+QP4EdRxAqzdge7ZBs+GgztrTmxsgK3+Aq3YgZSITAyhtg9wOGtQCuQ907zho1QpkP/odBtCAFXigEd1+YHCDBiFBq0JA5oPOLgB3/IHlippFIXgbFOgOf8itJ38ZPoIPOhMGX2MHGliAzPrjuooQVjZD0gVoIAF0NSLolglRBUcG0C0ausBrV5/e2ICaRZDcCL5VA5jPweXSf8T9/rgOEoSVV6AOOuggNvC+fuDKHtBqL1CYgvIGyFWwmwFAQQ9a8QM6DwRc3mFbZQJUBFrtAxp0BOVzULyA0ixoUAFUnoNWgoDKGlDHGXTtH6gTDdpC8+TaKgbQSgFQ3QGaeQetOEIfKAHXg9D4ZwRvxYKkf5A4KN5Bg3mQAYQvDCA2aMUK7CBZ2MAQZGCYHex1ed1oBlCaBcU1qAwElWGgeg2kB1SGKejHM4DiAbQCCLQqBVT/3T09FV5XgOojUJoFX5MJLFNA21ogW3z+MwjJWIDPvADt/wcNdoC2CiAijl6dJXrZw0hUsY1aFoFS5X9wXQpKa0zQs2ZAeQ+0IogBY8sLFiuI7PzTdMn//9GOLwPDaBgQ224ZHQBgGAVDNwQQHchhG4uMjIPOa6QOAIBnvhgh17rBZjkY4J0FRvjM1xfgjCNoGTjo8J2Xd3chDpVCamRBRu8ZwTMnoFF5UOMQNMsEG8EHNaJAe5tBDSxQYxx8qj9wRuw/uEEPamyzMYBmckCzvCA7INeG/WKQUvdjAC23BDXcQI1o0CoEUCMRsvT3LcPV/bXg5f43DreBG+zghhXQXaCVBKAlxqBOKkgf6LAv0LLcx1dXMIBm4EGRB2rkgWbfQKdks7Bwgk9y5xFWBd/xDmp4ghoZIHtAs0vg2RnkwwIZIctuQfaAGuwgs0AdINCyetgJ7oaekxhuAa+3A3WCQA3Gl3d2gg81A4UNeJ8rMzsDYrYaKTlRO20xQvIjqCOjYVsJPmUc1PkH7cWGdRxBs8igChp8fRXwSjTQjOuHl5fASzAhd/3/Ah/2BrrWDtSpNfCYwABaogxq9IMa0/9+f2cA6Qdt2wDteQd11sHnCwCXtYPCBnTa+MdXVxlAgweghjP4/AE+WQZQfGoBr4kD7eU09JrMcP1QC1gNKB5hB0GB0jUPsBMI6njDlswjQota+RBqDiNkQEVIygS8cgN0IBuoMyep6s0AWuECXpoPTAcg94E6oeDru35+BnfeQGkE1FEFhREoXYDUaAD3S4NWNYAGrUCzgfBOEbQxBAob0KAZaFAA0kCCNZIYoVmREZwHQHaBB1K4xcCdZ9DgASg/gQa2QLPboM4U6DAzUPiCBikQ5zrAQoqRARSeoK0VX9/dYYB12kEDeZBD0/4i9TuIaKjB0yhosIQFPBhn4jcHvIQf1OEBHeYH8i9oufSRpZ4MoOW7drG7wekJfIjan28MoAEJUFoCHdYJmsEGbfcAdYBBnSXQfnHQIAvoNgHQnnvQQBD4ajngKglQOMM6aoh908huhsQlI3RwQQ/YIQYNlBh6TgQPPEJWrkCu4AN1NkEdcVC5AzrfA9YJAF2XB4pbJeCWHlA5BupkggbE3j05DjYDNJuLvC0FtfMAHMQAlpmg+AeZDVqVBFq5AUrzoDIA5C7QDSagwTFQ2QLeBw5cMQIqE0D70UEDFLA98ZBIwREfQG/yi2qBr/UDxTsozYLw5d3lDMgDKojZcYg5iJlkIB/aMUF3PywxoKiFrg6AH1L5D5JmQAMsoK1coMEH0PkGoBUloHiBDzBg6aSBYgjUkQdf7wq86hMU56AyGrayCzSQBTr0FWQGaOUHKG5AgxqwcAGZD8oPGFsk4HUSIziNazs2MYBWLTBACnwwBUpPoNtkwDfAAMsk0JkeoMEH0Kqmd89OgdWAzzHgEganV1DeAw9EAFf4gLZ0gPigNAjamgRaoQJyI2jrA8jNoLT2CDgoCBq8gmxtEgPvYwddcwoqO8BhB70lAFT3gMo7UP0KObvjN/gcEPiqEgbkLEmLztNAdsjwl9uMSOULqCDk4BZlAA0sggZ9QOdLgPIVLO5R0ygDKhjt/DOMgqEXAqMDAKOpdoiGAOPwjznGYdD5B3V0gKPpSsDlpx9fXAA3lkB76SEzNpB7dmGzJzzAQ5NAyx9ZgTOgoM79v3+/wHEMahSBggLcoYYOHIC7mmCzWSBLa6HLxkGNXCl1f8iJ6MDOIrjT+Pcn2BzQAXmg2UtQ4w904jJo5g28vBKoDjSAAGpsgWZQQQ1k0OwxaGYINBMHmvUHXQMIatCDDowCdb7uA++jBx1CCOrUgPZGgw4aA53CDlqaCppxhM0awgYsQEtKQQ0JQWlTBtCsKMgNHMD96KBZIVCnA2VvITja/4MHRkDyIPtsY7aDZ33BDRKgb0AdX1C4gZaEPwMejgdSA2oYgvb7gjoZz4GHIjKzcjBAwvY/+B5w68iNwCW1K1DXb1ArjSE1pEBdW9Bd8yC3gGaaQCe1i8rZMIAarKAZN8ie1k9g/4GWA4P2PIPUgeID5B9QRxgUb6ABmac3NoJXPYBm/0EdNdCsI+jubNBhTKAtICD/gbaAgK7yAs3mggZjQHuBwY12YDiB4vH1g30MoFk90PkNoAPeQFtBQIcygmb1QAkDNMMD3ioAHJAApVHwzBmws/2fAf2gJ8gAB/kFD1J+hg4AfP/yDDzDCwoDUGcUlNZBacc8eBl4+TMozXyBdqRBK0fAy+j//wUPYoG2rYCXPgM7qy+Ah8aBBrxAh8eB0ijIDJAcLJ9IqHowgAZjQB0O8MoG0CAT3DkQf4HsAeU/kJ3gmWygGtCNGqBBANDgFehQQZBeUD4AH8b28RFoLQFSemIEDzSBZltBeRy0aoYVeEK5sKw1g5CkMfjqS/DWgf//SAtCRoj7QHENSgOg6zRB+ZJPXIcBMugTDd5zDRrYYQEu3X8BHAADiYNW9hh4TGQAuR8UlwbgjvlesFpQ5wqUN0FLwEGzzSA+aPUA6AR1KY0A8LV/oDIBvO2EjRu8TJgBh7tBdoFml0FLvkGHU94+ORF8ijvoQD5Q+QJaOg+y4+q+GnC8qVkWMrwBdsRB+QQ0aANawg/qWIMGdEADkKBT50FLuEGDoSD/gmbCGf7D9tcDgw5lGwKEDxngY2aADMwIMoBWRUE6m+HgGw9AIfju6WlwngN12kEDN6AzVEB7nmEHRiK2hCAGh8ARBQx/UFiCyl/wahTgLQug/fGgtAhaeQBaqQA51A/R0SNlGTlGxwrsP6B/wWeYwMz8zwBaKQMaXAKFCWhrCyg+4Kta/qMPOoBcDhL7zwDZd/+fAbQFADQoBOYD1eu79YIHY0HhfA9YnoMGB0D+BF3fChmMAQ48QN2CmmChGQcYLqAyDjT4+/YRZLWXuIo7A3gJPlAONJD9HHibDGjADHZ9H6hcAq1EApkHSjegFVCgQwBBZTio3PkBPtiVEXK4KZ8MA2hAG5QmQB3Sq/trwAckgg7wPLk2EnxIJCgOQaunfnx5yQA6KBFcbwLrO1B5BopP0LkJoHwIumoWtK0OVK6CBjixzUJTd+n//0HWPsPdlkI+GwA0eAIZHJMFr5gBnSUCPq/iPyIdYnhsoDv/o7P+SFEy2NIdw6AGowMADKNg6IUA4/CPNMbB6UeSZ/+h/vgM3F/pkn6WQVLVC3wtFPggJqCculUpeBkxeGYXyHdOOcFwYWcheME5aPYNtDRfBNiBAM1swfZjQhqlTAygGSzQDDJoeSTooDLQ8s6v7++DZwfBV2mBBhCAjXZQIxU0SwK6Qg20PBy0ZxS0PxW0nxx0+jWowwnqRIJmfUGdaNCMIqhDDZoFgvFBnUXwvlHgYAFoYEJUwYEBNMsKMgvU8OIFbiUANbQYoMtQwY0KRkRDETbbAjp5HLRnHdTIAPkDdLWQvkcf+CAi5KVrjOAGZAz49HVQIwTUQQQNHIA6FKCTz0GdY9BMJaTBGgje82wZuorh1PoYBpDZkKveGBjULIvA94+D9kODOtigBidoQAOE4ZkI5E5K0htcLyLNggYoQLOsoEEV0F5K0NVs4PAEXlUGvrMeeNUaKP4gHbpr4HQBXtoP3CYAWjIO6lBABknEwAM8MppBDKC4enxlBQPoei5Qwxu8pBe43xsUR7BzBXRd2sG3BoA68iD/gRq6oG0B4PAAxg1ooAV0yOO9c3PAB0aC0g4oDSFmQv8xIK7JwtWYIDVvQjqwKOHNwMAAW0IMokEDFKCl1aB0COo4gpZug+IadKAdKFxAK1lA6Q3UGIWcO8EA3gsNHgTil2MAdeJAK09Ag1+gtA4a1ABfhwnaPw60C7QaBJROQTO3oBlF8Mw9qOEIdhojtGPIAO/M8wCvHgRtwXl8bTUDaPAFlNZA12qCVieAOsWgbQLw8y8YGOArTECz7SD/gLbTgNwDypOgQRhQp/3L+zsMDLBOHVqj9T/Ww/WQwhmYxkBhBFqJAEo/oAEP0CAECIOWgYNm60B7zUEDfKAwAuVvUJyCOkCvgFclgvIuKA+ClvaCVwuB3AzcZw2S//HpKfgOcNAqEzm9KAZQegUfAAe8hQK0HQN0VgAoPYPTE5q7YZ0H0NkjoDIDZDao7AENvoC3ZwDTO2jVC6hjBjqvBDRA+ObhYQZQOQGKO9BBd6CwBsUHCIPKBtA2GTm9aAbQCgpQHgCFP2J1EKRTC0lLkPABuQFUZokqOoC3NYC3r/z8BN5GAipfQOaB4gt88v2PD+DBDNByftBSe1CHGJSPQCsoEMvoGZAAI3SFFmSm+9LuMvCVc5D0IcMAOhgPNHgHWWrOgAXga5BjyUewjjzyYXtQU0GDR6BZbFA5C+rcwtMM1g4Q1F4k82DXFILLWaDVoDMGQINDoO1eoEFY0AAXKAeA6hDw2R9YO/8wL0LCBTSY4Jp+jgG0sga08gLUGQelBVBGAqUZUFkNG6QArzaDHroJqodAeQmUR0Cde9CAA+gWE9BgCui8AvDVs9/fAQcHfzCAyidBaRPgobMzgeeTJDKAtriA4kzBIJEBdH0jKC2BylHQAJ8Q8AwTyBaUdwygDj2o3ANtbYAMIMHSDpDG6zcGCsBg74BhL7th+Rg0yAUaoAbFDWjQBDIQisdPRHS+/9NySfr/0Q4vIrGOhgWpGXd0AIBhFAytEGAc/hE2VDv/oJhB6wzCOsKgw5dAMyOgZZKgxjCoowNq0IE6ouC93EB9oJl00AwuqCEMuncX1MgDLT8GNTJBs3Ogw8nAV0IB1apblzKA9nODl8//+AieyQEt4QM1fmyiNgMPu1rAADvhHNR5BHXyQZ1C0D5rkDpQoxVyqNNfcIcZtI/8D/gebdBVVp8ZQMvLQbPEIDFw5/vjY/B1cXK6kQxvHh9jAHWCQLNtoEYzaPk1qLMBPkwM2PIDdWBBDS8dpxYG0OF3kG4VZEYLNLMHun7o05vr4EOhQHoeX17GAOvUQfrijODZHdCMIKihBzILtLwfNAjyCniXNGg2ETQAAFq6CppNAnf+JPQZPr+9wQAamADt2QZtX5BU8WA4vy2bAXTXNmgZPmhm+PKeCgbQgWEM2BolpA4EYKiHdUgYoB1KyHJw8OwqsEMCGoAAdb5BjeW/f36C76sGzTqDlqWCDjADbYsADfqAzmoADWKA4l/RMBl4v/sz+L3tsEP5QKeLg+IMtNQctKQbNAMHOlQRfEc8cLuHIrBxDGoQQwasEJ0BUFjeOTmJAZSuQNsCQJ1l0CAT5JCvrwzwA54INqzQOvVYSyUsapDyNmQAALI3HbREHdTRB3U+QHebf/3wkAF0oB1sJhJ2Yv036FVgoGvfQGdmgGbjQTOWoG0hoDgHDZyA8hyoAwrqGEPyFhP4YDXQnnzQyfCQA9ReMaAcaAYeDEB0KEEd6gfAWxtAHQvQQWugDjEoT4AGBUADMKCBE1BeeAc8GwNkH2jJMmiQANT5ZYCVA/8heQm0dBu0ZBs8Y4syqwsJNEINZFgcgtI5qIMPWmYPyueggTHQYIawtDl4kAtUvoA6c6Al1qABFFBcgzr/kL3YnxlAJ8aDBkbAq22A8QAqg0ArCb5/eQ6eJQZ1tEENftDAFWgfPsguUKcNNCCA2P8Na2Qi6iFYlIIPYAMOGoDs1QRugYEdXgcaeAQNnoDiA7wiBzoQBSqH5PXjgCt77jFIA1ctXQHO8ILyNWjAElQegPIFaLk6aNUPaHYYsqUIs5EL2g4DKstAaRm88uH7W/BsOaiTDkofoI4vKJ9xCykzgO81//YWvBJBxTSTARSvoBskQB1X2JYlSPTB/McIHoADbeEBDRiAtsiAzAENmoDiGzS4ABqYAq1+YsDX0YEGEnwAGaWeQPUTZnqAyMPyJmKlAoGmANbBBJhd/8EDiaDONuhgWAbQNjHQehZg3EDKmH8M2GbE0ZeMg/j3zs5kAG1Vunm0GzwoBxpw/A8+0R9qF8ivSB1u0DYt0IADaDAM1NEEDWaBBg1AgzigOhGkH7SPHxSfoLQLuvJyz0wjBtuYnQzg1TfAcxFA+Roy4Axa2SDEABrMBtWNoC1moLoFvmXl/38GlPDEUa5RPvs/1DpfmO1IWNwygm/0+QUerKR02f9o559ezfXRzj85IT06AMAwCoZGCBDT4B4mcck4OAc5SJ39hzckgf4BzV5DTtd9C24kgTpgoBPFQfvwwftKgfdYQzr67yENL2BDDLQnE9SgBXXywbPHwPvPYXvvQR1nUOMY1BGAn/wPjv7/4FkR+PVmwP25oFUHoM4gaBk/qPMO4v/9/QV8mj6oswmeSQTOJIM6k2qWBQygJcSgpaagjgD4fulnpxlAs/6gPcSga+lA7gK5BzTbB2rEvbq/B3KSONCfoBPsv364x8AMXDYMatyBGvKgjjtoeSnIz6CGJmimB9TINwtYCHTrQuDZAloMoAY6JPVC0jmowQ/yF+gEd9CBT6CDvkAdDNAACWwJL6zRbRuzg+Htk2PgWWDQQXCg1RTgWeA3N8EdG1BH583jo+BDA0H7i0GrMRA5BUtag3XsCdEY2Q3RgQRJgU6rBg06gGZjQdesgZazgpYNg7dYAGciQeEBaXQxMoA6WKADt0AdINA2jo8vLzCAOo6gzhTIDJBakDx4ITRwiStoKe1/6HVX4M47MG2A0gJoGTao8wsaMPoGvC8cFqagdCQKvDsedpgXaFAHNNsGOcSOiQGSlkB7jRENCczOCrbyBVYuYaOxqEfK2yDzQSsWwOkD2OgEzfSpmueC0+9v4DV7oNl6UIcd1NEC3Rv++c01iIHARjxolhfUMQWlqzcPDjLAOtf/oddJMoA7Mt/AWz9AM5OggS/IrNYbBtiJ9ojODFLjiZERPJsPmjEHpSvQ9Yt8YsD93y8uMoCWq78CbqcAuQfUqUTseWZiAN06ADpjAZSXQYMT4H3WwEEeUKcGfBr631/QATlEBwzkGWIbyIiBnP8MsNU04L3vwCXToPwIsgOUJ0FyoI6RLnDwDbSSAjQLbxO1heH++bkMkDMI/jFATvP/Bx7QA9+YAAwzkD5QZws0EAPKO6CT1UFhyQDuFILcjK2BiZzeGRlAaRV8bScwXYLKm5/fgSe/A8/8AJ3oDgp/UBoEDTiA8uC3D/fB7vgB3AICshs00AMbbAGlXVBev7SrGHjoYjQDKM9DyjPkjjAibYHCGtRxBHVcQOc8PAMezAdK27+A9oPKDdCgEvhaROAhgCB1sKvkGIFXioKvQwStWoKuXIIsAYGkAbANjJCDR0EdffCycuAMNmj1DSjdsfOIMYBWnDwDHmwIWXH0H3VQCWIAUlEDDS/YgaLAm0vAN6kAywIGnANu6H7G39BnRKs7UdMXslnQOAUPxvxFc/d/BuwdP9T4ZoTecgFKI0+vrQUPsn0HryYRAA+agK+gBeUnoH9Bd/eDBhtAgQEqD8GrMn59huZnyBkHoMMswaspgB188KDk11cMoBUhoDIKdDYBaPsSyHxQvQBK86CrOEErO0CDVpC68x0D+HpB2FYVvJ1/anaYhnLnC7P+g5UTiISL5j8iZ91p1vkfnfVnGAXUCYHRAYDRlDQEQoBx5MQS4+D1K7kDAKBGDGhWA3aVkqZtNXiPPqjxCVo2C5rFAzV6QR1GUEOSkQnS6ATN6EJmMCF7W0F7H0EJAdTIM/KexgBaSgueKWPlZBCUMmYAdwrBSyz/M4D3HgPvbwZtNQAd0PTg/DwG8IwJw3/wlUigRhvo0CzQPnnwPl3g4W+gGULQrB9kKe95BtDBYKBOBaihde/MDPBMOqhTBprZ+wc9VwB00BMoXECzYjD3gRqzoNUKoJUMoHMCQAczgRrN4L2nwPgFza6C9rNeBx4oCOp0gPfPgg66AvchIUttQY15RcNE8GF1oIYEqPEHmuEH7fEGXeHFAD5FHHSoISt49QBotQLIXlDHFnR2wZuHBxlA7gHtEwctvwYvJQZ2wkCzQ5iZiRppDrlxDI4lBtCMIWh/7NMb68H73MEzjS8vgq+mAjWejbymMIAGgEArKCCz+XIMoNlYkD5QfIFWeIAGbXZN1wEfcAVeLQLcmw86sPEXeHnsL4YnwCXqoLMUQJ1S0KANaBUBSD/o/m6QK8BXCgLPoADFEagRDboyDtQQB509AFq9AVpZAdqPjXHFGy1KHLS8DXHTPgZFgwTwDRagGytAB7aB4gu05B80YwxKp+ZBS4HnASxjAA0CgGYDQfkCfM4EMK2DOhmwQRQQDevcgpbKg1ZVgGbtQbONXMAD0ED74Nk5hcHXgIGuxQQNPIBmfUHqkL0LchdoewYoDrgEFMAdf+TzEEBpCXHAJSP4YD4N6Iw3aDDi4+srDPLAJeygWzhAYQxaAg+6/gw0mAFa5fMfet85RgMZvWGLJbwYIEmLAbyqBqoefFMIA2TRCXh7ArBj9fTmRvCtHaCZcdCKD5QT3MEdpH/gATPQwAVosMPUfz4D6HpDUAcKsiLlPXj5Nd4rv6COAYc/6CBA8GGALOBzCUCrEEADiKDbOkDlHGhFCqgjDzq0EFTegPwO2qoAMYIRPDgBKjNA5R1oYAOUjkEnwSsArzF9cm0NA+z8AewdU0hnFhQOz29vYQClGdDABmjFDehMBNAAAKgsEpG1ZAAPwIE63MByEHy6+X/o6fyMiC0pYBYjdECLkRF88CRoqwSoXAGFI8iNLGxcDKDBEtDAHKjsBqVDUFn2H7rEHTX7IJUvoA4xE6Q8B6kBmQdaNQLavgG+Z5+RgQF3aQTtiOHsAKGVQVjMQpnpxjCH+MEGUB0FKmtBZ5aAtriArmwErfIAxRXIDvDqMqBfIduZ7oJXjIFW+IDyEexaWVB9BconoLNMQHEGWkkBGoQGlfOgwXKQGGgLF+i8AzHg7SWggQBQ2IPyJihNg+oc0EACqE4CX7MIrkNAg6l/MQdiUPyK2qElf/Z/KHf8ySjgB7rjD8kwDKMAPQT+jwYJmSEwOgAwmnQGeQgwjpwYGjadf1CUIRpjkOXLnxlANKjB/QJ4wj+ogwtqvIA6w6Drq0CzbuBZJKA22CwcqMEkreEH7uCCZppAV+eBGqGgziNo+Ta4kQucOYU0sk+B97yCr1kCNiFBS3DBp+Uzs4HvSQbPMAMbu6DGvaZdNXjJMKgTDWpYg2brQR1IUMcetPQcdDc4aLsAaJYV1DkCXQ0H2ksLmpkGNcYeXVoMvDFAG5wuISc3SzKAOpqgPYOw5amgTiobOz/4jnbQUlzwLQHAQ9NA9pn4g04xP80AWuYJWvIOGRiANHyRB1lAjToG6F5Y0PVPIPeBOisg9SB1TinHgR3gteBloQqGSeArFEGdM1A4gsIO5EDQwAjoUDE54BVT70GHgNEkNyHyKOoSWQYGkN2g2UuQe0Gzhkzgqw8ZwVc0vgBeYwg+NBE4GwpapQCKO9AMMmhwBDRrrWySCe74aNnXM4A6laDGL0gdqKMMuvYQtBwdtOUB0tlhYwB1JEDL4V/f388ACjfQbCuoAwtaSg9aUQFqOIOvgoTN+gEHUUArU/7/x3UVGlJgUZo3segHxzUw6EAHNoJmhEEDOF/e3WJQMctmAK00gXVan9/axAC63QC0TBvkV9CybVA6A62WEFOC3FENSr9qFgXgdA3SB5r5Ba8QAfoNtJICfJI4MF+AZqVBYcHKIQiOG/AhgtAZQ+SBBNAgCaizAtvbDe4OAgfmQB1s0NaUP+DZy//gXjcoz4BmnWEDaqDZSVCcQwZW/jLIaoeDr7gEHYYHSp/gq/aAs5wMDIQ6dNDwR1s1wQAvXiAz1aCTu418ZjCA9u6CltuDBoRA5Qp4gBC4sgeU90D+AKUtQQkDBrifoZ1f0DkVkuo+wLNJVoJX+kBm8n8yoCy5x9b4Z4SVcUzgmVpQegSlXdD2lv/QFUygPfaQWdzHwLvbrcGDj6COLijvgw6jBO/55xBgAM3Wgw/jA25DAp9U//oaA2gAAXQ4HKjsg8Q5rKGLZUbyP2QQADSwAHYVyG9ABmhlEajMZYAOfMKuhUPuZcODF9RhBnXQwQeqMoMLJFh5BIpv0BV5oLM2QNsiQHEI2rsOO4Ty87vbDP+hg6/g6MFI7+AUBD7cDnRwHWjbBmiFjjzwWknQAC3ogFBwpxmoGXRWBQNSnsTVQYWXlYyMDAxIGFSXgA5lhdzCwABb1ABNTKhpjrxZWnBpBj5vAbQVBlSGg9IeKB/LAwdswOkbmD9A4qBOu4p5DsOTKyvBK2AYodcFSqh6MoBWhYDLeKBfQWcwgG6w+AQ8KweULkD1FKgOuQsceAalT9BZGqDwBQ0agbYBgQbRQVfPgtIqqEwA16fAdAQqA0EDpaCVN/+JzV9k1QkjqNNFwoz76Kw/A53BaOefkgAfHQBgGAWDNwRGO/+DJW4YGQjEBdYGH8T1MClQhwLUcQF38oDXjIEafqCDsUCzuaADuECz1SA5Y99ZDI8vLwfPGoNmc0EdClAHCbQ3GnYiOuRAsX8MsAPBQB1L0BJnWHhJawZDlnX/h8yGgJbGggYEQHvhQUuXQSsSYAe/gWawwB0e4MwkaIk4qBMB6lCB9kCDDh4DNZp5gSsEQA000An7oJlm0DV8oMEB8H5B4GoAUPiAGsSQw/X+gzuun4BLtkF7ZkGrDEAnQUM6dP/AHQ3QkmWMjidyQxYl4v+DT1AHLfeE7+0ENiRBnURZnXDIoWWvrzKADpQCNRBBe0FBB1qBloaCThAH+fM96NopvA0ZSvIarCOEbAakUQ7r5IIavqAT1kFXyYEasqCtCp/f3gbfjw3e7vDrKwP4SjzgIYDgQwJ5JBhAh2iB3A6Kc5C/QMuYQQ1uUAcEdLo2aIYc1PgFDRiBwoWbX55BQsWT4cn1teDQAw0SgM5IAA0WgfSBZs5BcQ+ahQUvOUZfIgvWhRoOjFh7SiTmSkbMsEXpvDAg8gmocwg6GA6UNiC6/jPoOLcyXNiRzwBaRQLyK6ijCNo+A/I/qAMAUgvq4INm+kEzkqAOAkgMtGUFdosEaHk5aHUBaNYX1PkEzf6DZuQhh/IxQDp7QHeCOi9gu2FpEdYRY4TMBGvYVoE7epKgDszTk2CHgwamIFsOvkIOJgQt8QbO8oI7icArzkBnToAGJEDxCFraDLuODqyZ2MY1rLMNiw8oH5TvIQM7TxhA10n+A9/88ZkBtNoIpFQIeD4AaIk8eAuIgj14kAB0TSVoMOk/dHAN5HbQShJwRxPkHmCZAe/8E3IfuMPMxACaDQafgQBcVg86pA2UbkFhD1ruDfIzKH7AK32AkQraIgFiQ7YCMTOAZvshs/H/GZ4Db/QAlSMwP4EGyECDX/DBEgbsy5GxdTxA5QVs5QAkhUEGCUDhAk5b4DCEDKJAZv2ZwKs5wAOioNUM0PzACE0XoBU8oFVFoNlvPjEdcP6EXSsHuvMfNmDFAE/PiHTPyAi1B0iDyj7QYB/oXIGzm1PBqkFlLPhmBmC6Aa1UAJWr4C1T2M4VQMpPjAxIEDhwATrkEbSVBjQAABqMAXXMQWED2iMPWg0BPlCRgYGBgWBxhxTO6GkAqBcU36CzMUDlCqgMAvkFZAfoVoWX93ZBDhgFrroBqQOdTwJa2QSyEjRAAIp7yOAuAwNsYBpy/egPBlB8g1dVAM9MAZVdoMEA0EA0KE2AtosYeU1lAF1TCMq7oIGtH19fMIAGrEHbXdi5hBicU06Cy1HQGRjY8xdq+iF99n+EdLj+k+ZPmnX8QZH4f7STyzAKaBICowMAowlrEIYAIzE19PCJOUbGQe0XRgYi3IfhB9TGH7SHAV5OCroKTxB4LRjoZHhQQxDUuBGRs2YA3e8M6oiDDpgCzd6AGsbgK9mAh/yBGsCQ/e8M0APmYJUiZE8v7GwA0NJpUGMT1FlnBC/JZWIAXR13eU8l2BegWSfQbMuHZ2cZQEuRGZlZGUCNL9CSaVCnCLSUnh3YaQF1GkGnf8OWmoM6TaBD9UArAEDLyEFbBUCdSFmdMPABTKDlux+B+6R/AZfXglYMgPwFnu0E7gEGd0xAe9T/w64/+w9ZogkOov8MjFjjHxZ+MH9CaFBcyAAHN0CdQNAy0Y/QO/RB1+yBGoygk/JB97OD/AQaTAHNHIEPN0S2G2dqIycdQvSg+gFqDiOkcQ6anQN1unSd28FXcYEGakCz2aD9rqAOippVCQNoZQdoxhPU+QftmYY0qBihBwXeBg+ogA55A527AL6WCbjcFbTkGNI54QanHVAHBbxcGtxpYGQAxSVosAE0swhaWgtqoEsAb6EADdLADl1EDgoUP6B1MuDqSMmrILU41GMOAMDCEclF0GAEbV0ADV6AOrfgZdLABiFolQNomTkoLECdMJDbFY1SGB6cnw9d/vufAXbuwQdguvzx+SnDy/t7wZ13UF4Bz47C0gQjA+QUf2DnC5QXQZ1V0AwiaAYTNBsN2isOMh98BgVwZhp0WwZokAy8xxloBmzlAKgzA+oUgU9BB4qDDvIUk7dnAA08gA8p/PQEPGsKumoQdk0jA0YHD0caxBYfUDFQHgXtbQdtGQENeP2DHsAGG5wDrTwA5QHQeRqg8ALd8w3eCoOUJ/5jWyINFcPVuEcuF0EDfErGqeBtBRrW5Qyge/hBh4+Cr/wEugcUR6A73EFlhihwIAI0OAfajgE6owA0kAg+bRx4FgGo4w8alAEP7IAOpoMOwGDtqGFzHzZ/IBIvhAXPl0wMsH3sMBo0yw/KK6DBA1A5CC47gOpBg7AwY0Dh+w142wpoQA40KPsaeAbFf5TDHVHLfmzlGyhtgTrpsC1QkGsZmcFXfoLiCHTGBGxAAXvxiJZOgGU9aHUQKP2BwhJ8TgXwcEfQFi2QeaCDQkG3KiAPrIH8Q7Buw9H5At84A1y5BCrLQCvZQPEL2l5xaXcpA2i5PmhQDHzVIvBmhmegmzjA+YQJvJIH5B7QoDMozDXtahhA+RvUyQeV17BBG9DqJVDaAF0rCVpJA6oXdRybGc5tzQTf4gAaJADladAgEmjAF7R97t2zMwyg7WaguAINemEW85R2JIdxR5SCTvZo559hgMDowAilAT86AMAwCgZXCDCOvAhhHNx+ps4AAAO44w6alQR1UEGzQOAGGLDToWqexwDqEIJOxAbNFIJOugd1GEGdBDXzfHADCbT0FDWUQDzkjjQDeBk+qKEH2Y/6C3zIH6ihClpGC+pogFYFgFYSgGZLwIkM2CgDzfQJA88KAF0HBZpxBnVAQY1T0N5wyP7/LwygpfygzjZoAELHsQm4L78V3JECrSYALcMENVZBy6xhB2qBZv5A5sE6U5ATn9GXmf8Hz10xMKJ3/EB8tPQAa5wAhUF7Sl8CDx1UB3aaQe4FNTxBd+CDOjUgP4LsBLkT1EkDuQvkblADHHTwGPiEeGB4I+/fxsxsWOzHmiNR1cE6gQxIM7TgdMMIUQdqlIP2IoNXcADdAApjkLGgOAftNQfdhQ7aKw46DA20GgTUoQN13GDL+0EDHrdPTmAADb6AO6fATpW+Ww/DsxsbGUCdVND1ipBOCjRcGSDNe5BfQZ0BcWU38O0Hbx4dAp8VAV4BwIi+PJgBaTCGEWWWkBF9JQC+PIun4w8LSmwrAGAWQoyGpgFGmEpEYwfWoQLtmwaFF2g5MagDCjpPATajCLIHxAZtKQCladC1Y6AtAeClxEjLqxmhbgXRoBUYoDMrwKtknpwAdw41bMoZYDckgNISaDkyeIn/35/gATTQ9hbwQAFwawdIHtThBYU36JYGJaNkBtABlqAtG6DOEChOQR1F+FkZ+E6NxzboCMsraKsAQOke1FkCDUqA2KCQA6UR0EAGKG+AVvWAwgO0NBy0KgHkH1BahAw+/Md+4BuBzj9ylgCFHaizD9pyAOqIgWZfYQdTggYBQdstQAOcoHIENFMOGpgChQVo1h9UxoDyBsQ8SHkG7vj+hx5WSEptiKXzjzxwAE9X0AEA2JVxoMM1QWkP1AFl4+AHnxMA2oIDKl9AfgOls7/gG1IYwUv4X9zZDr6CFbT3HTQTDev8M0KyHAEXQ/MV0K3gLSLQMwNA20Q4+aQYQGaC4gi00gW8zQTsJ1jaRysXYfkMSIPcDtp2AtIDWu0CGhgFDcYqm2SA0zGozAcdOAhKq2qWhQwgu8EOZYSsbIGVwygDUkjhia2TB3MN6NYAUEceFC6gcAPf/gA8owTkFtCgMag+Ax8sB0zvbKAzOH5/A9/CABpgeQY8qwIkB9o+Aqq3QCtawKtT/v8Bb2kD5WnQti/Qiq5ntzYzgFbHgfIxqFwD5TfQigOQHGirCXg7GfScF/jqFjyxQdrs/zDobP2nrh9GO/4MAwhGO//UCPzRAQCGUTB4QoBx5EUG4+D2M3mdf1A0IvyFPAMEmtEHLWMEHaoH3svPwgE+QR/UQQMdwgW7pgt0aNgH4IFxoJl8UAMTNLMDWtoJXvYIPPkbYiaoCgZVBP+BS3DlGUB3kIMaQ6DT3kGzyaCl4pAG3T9wIxDUsATN7INvFwDuZwY3yoANUNAyUW2HRgaIXf8Y/v79wQDqyIAaYqDOPGhlAGipPaiR9fwW5JAt0Mw16Poo8L50XikGUMcS0nAHXX32BTwjDXI3eM85A3TmHxQkwPgGnZYOcitoEAS8Pxm43BM04wNekcCI3AllYGBA6YhADjAEHeAGm/UEuQ3kJtDKBNB2BdCee1DDUFDSCNzhBTUoWTkFGUCzjCC1oJUMxDVcwI5lYMDoiDGiiIHiAdKJZIKszAB1LoCzcaBlqZDtEBD/gJYVgzpBoAEe2Gwi5OAv4JVkwM4kqNEM6nBYha9jeHRpCXiABRTn4GXj4vrgqwBBe95Bs/mghjXoZgBwxxI4sw3igw+WA9oNGoQBDZKAZtlADWfI4Yc/GEAzvqBOGWg2G5QGYQ19UGcVNIAAOXX7JdgPoP3J4Pu7QWGPlD0x8gJSB4QBmU2wC4SlI8OAyDOI/AJODNCBIiYGRGcdwgbN4oPONwANMIHCBfWauP9IaecfA/igMaQZb7ALgG4GDbSBbQbGGWQW8zMDbCALNFAH2sMMWjkBWjHBCF0WDtrSAk5fwDMtQGkelC9B2ypAHXvQYYAfgdtRuAXkGUCHPxp5T2V4Duy4gGYpwSfZo3To8AUUlnIRfQAAqZhBUQ3lgDqRoFl50PWHkC08exhAA3awAQGIMtQVNmAXEdNRQFPzHXhNKCjfgcIOlM5A5xCAbhoBzfqD8iDonALQuRygFRyggRZQeQeaOTdw7wPezrEdfFsDaEUA6MwO8E0VDFjcRXTt+B/qDcxGMiSZQvIqaCWIbexOcGcUlD9AB9KBzhoA5RnQICJoBRSoc2sMPF8BNKgBGlxlAy4zh9ye8ZABth0JvN8cegAdIu2iugEjTTNC0jBsll9OJwK8nevWsW4G0FkWoAFVUJiCzmsBr7ZiwDEIAM83/8FnNoBWd4HUKwFXw4DKdVAHGjR4CCr7Hl5YAB7MApUpkNUtjOA8BdrOBRpMhFzZysAAMgN8Owg0vPGVl6A0BLoCE3QrDWiFAWigC3RWDchfoHIJNEDyG7qCDVTmQLap/QeH+dvHRxgg25H+gc+QAA1WgQapQO4G5RvQaibICrgPDKCVaqDyDzTDD4o30EAvqMwDX+8IPKgTtILgP2xgD2v6JbfDNAAdrf+Dv3M32vlnGEAw2vmnVuCPDgAwjILBEQKMIy8iGAe/n6k7AADx7+OrKxksgpeBTxcHdQpAh0KB9m2DluyCrugDNTBBDWlQBx40uwm6Qxx02BRoRg/UUQQ1mkB7K0En/MP2uIIaW6CZHdBKAVDjCNTRBXXKQAMJoAY5qHEEmt0ELTkFXekH2o8O0g9yEbegMgNoJga0txW0bxQ0OwdKjKAZGrOABQygpeWgMwnADSxgnMkBDzUDdYA+vDgHbnSCGnyw2UT4rCJ0f/F/eKeLAdyRAy1TfgqctQYtGwV14kGdLC3goYQgu2GHVoFVAu3hFlQAn5iPMpsDNO8fcHYI1OkC+QPSYP8N3ksKOnMANKgBnjECztiBZstBs/6g2SnQQIW2QwN4fzzsOj3wbClRaRAUSjCMyKbwRj2wMQ9agWAbs50BNJsP6lSD9giD94aDwgE0KAD0Pfi+baB2UIcIdBo8aNYW5FfQ9gXw3evAjj5o4AV8pRXwtH/w3fFA9aAOLsh20EwqaHk5aKADnD6+vADPSMpoBjKAz20A2gM69A/kQlAHDHRwIqghDwoT0KAAqOGMaCgDV4wwszC4Z11hAA06gcIJfJc6CzsDOJ0AzyIAbUsA+xbsdUYok7I8y4hnZhs22ILcWYJsY2FmgA2ygPaUgzov/GLaDKBlwaB4BXXYwPL/Me8uR6Qd1A4leOAGuBKDX0IPeGMGD3TPshQDaPk5KG2BOn6gvKJolASeLQWlKdAADmg/v55LBwPoDAZQ/IHPc1B0AncGQZ0R0LWBoFlc0GwraCb29Po48IoL0F58UBwzMJDSeEMLa6wDAIh0CZGG6OEVUmEArXYAdc5Ay+lBnSfQoWugTjpIDDRwArpZA7TyiJRZXwacnROQv/7Dkwt4Fhd6KB5oZheUF0Czw6AOHejed9CgHWhLx8t7exjAnVFgWgTFLeQKyw+QTEZkRwhbmsK6pYEB0uEFDYiAb14BHsT4FHjDACi/wg6TA63wAB06CFreD5ollwbmLdD99qDOPmhFFmSv/hfwTRIgMT3gth7QPnhtx0bwwZWgshRy0CADA3LZB/IQJF0zggfZuPikwWUnJ58s+KwXUMcZMujgzACKH1C+BdkHmlX//x999RRyukCwQfEPXuUEtOwd8MBTULiDzhwB1RcSwBVAoBtFQIMYoFVF4NlyaNkEKo/eAc9IAaVl0IAYpJxcxwBKF/8JHaQHtJ4LePYIqKyCDChDymLQAATojA7QDTIQvzNABkiB5oFWU7ABt5mBVi3AVnuAyjUl4GqFO6emMIAGVB5fWQE+GwLkNlA9oQg85BW2kgB0yCTo0EhQPQXaRvX1w0MGhv/4DjLFzHPEzf7TuKP1f+h15Gja8QcllP+jnVuGUUC3EBgdABhNbAMcApgdixERJUOg8w9uuJC1/x+iExaPmDOaDOB770Gz3qBOFqjjAOoEKhomM9wAXo33HHg6PKgBCJrBA3VGQA1BSMX7nwHUcQR1eED7IUGHY/348hK+ehM00wNaNg5q3IJOJAfN3oNmdkENPlBjDrTUFtQpAHX0QIfQgfZGQ1vaDKAzAECNUFAjHHxHN/i+ax4G0EwzrBMJXqoLjDdQIxN0jRyo0QU7uRpkDqjxCBoYAC29B3fm4I0yRkjfDjz9xsQAOogK3JkCzqCCzg4QV3YBz0yBrv0CnSMACi9Q5wl0qB+oMY2YQQLZ8h980Bro0ClQgxN0zRuoEwNqxIMaiaDlobbRWxluHO0E3w4Aaky+e3IcPOMEOlzOMnQ1+FYFcJhAGxuMJKZF+Kw/AzSFADuSoCv9Tq6LZuARUAQftPYffJDabwYNq1IG0PVWsJP5QR0L0PYK0K0FoFkz8CzW+7vgBiyoQwuKX/DgDVA/aIUA6LA50I0MIrLWwNPbn4CXJ4M6JeAl5cCTtkEdZNCg0dsnx8BxBVpxAWo0s3DwMXDxyYDvUAe5BbQ3HLYihBE6IAFahQE6hwI0mATqGII6ZKAVGaDZ6l8/3oE7tShdUMj0KQOkxCJ9IADnYBo8/CFmwuIDtDIBdOI+aOUKqMMCiktQeIA6NpDBFFBjkZEB1okAxwZRcckInOW0AN9bDzo0DXJGxF/wIACoIwI6WwB0JSbI3ndPTjJAzgFgZgB1REArYUAnk4P0gE7UB8XFvTMzGcB3zXMKMYD2JINWIoBmlEEdblDYgwYSvoNuwGDAHKBALusx0yFSGCP5ixFjCwBquIEyGyifg8LM2Gcmw+U9ZeDbEUBXQ4I6nqCOFyj9QDp9fxFOINT4xpDH0VgHOoebXw58TR4HcHUQKA+D0va7x8fB5RdoBQBoRhrU2QddDwjaFgDyAahD9+MrcBUK0H+gmxVAbgR3QnG5i2BcY3cfaHYdVG6BztoAncUCPhDy1VVwqILi6xPwGkdQmScsYwm+vQE0MAs6mwAU56ABS/B1duBzFhjB17mCbqg4ty0LnP9AA0iQveyf4CsEGKDlBCR9MjCAV3Ox8zFAboERAA/UgPzOwSMOLptAh1iCVpyAylvQgARskBc1fWC2GxADDAwMoLIYdIXeu6cnwPkD1OkGlX+g7RegFWKwAUPQgYygjjfo/BTQwbCc/DIMoPT8H+lGAwYC6QK00gkyOAytTYDlPqjzD0+9jJBVUKD6CJbYQOcFQMKDiQFUHoLqOFCZDBpMAJVFoPJHy76WAbTyAlRGgg4vBaUF0GAGKA5A4QMa7OQWUmIA1TegegB0vg0D0oAzA0WAyh3RId6xpXnHH1y1j3b+CSfZ0TBioCIYHQBgGAUDFwKMIzPwh33nH9y0gcctxgAAcMYY1BkDdShAnXXQ7D3oCr0nwJUB0uDZ3KsMkmpe4K0BoBlbUGMJdAK6qIIj+JAo0NLQe+dmM4CWacP7AkAGaLYfdNc/eN84Cxu4QQpafgxqnIE6haAOAehgMtCsCWh7AaTj9B+8nxXU4AM1ekENUVAnCCQH6niDzg8ALVsHNeBBHUaQOaCGK2jZKOg+b3CjiwFy4JqCfjwDbHYJ1FEC7UNlQFq6CuqsgswEdZBAS0FBZv3+9Ql8/gFolQFIDLwPFHh1IajTAJo1BN9O8B91PzAo17x5fBQ8iAKZwWRkEAfOwoIahaDruEAdNFBDHNRxAw0KvIU2gkGzuNcONjGAOsPYZucIDQSgdvwRcQzqkIFmhEEzqqAZTtASWpD7ITczXGcAHQAHXqIPbASCOv6gziLI/QzQVRKgBjao0wDqiIAGg8BtIWADHBQPoEEhUMMdtDoCFHagVRmg5dTvn59jgIQVKwPs1gaQXsgKCF4GUCcQNCAEWmnyALj0F9yIBzfEmRhA8QQaRALZD6JBK0FM/OYwgAaeYHt4QYdJgrYqKAIPdgN1GsBbBRCJjQHie0YGYlbIQFThKOtQygLIDC0DzHSgHGjmErSHHzTbDgp/0MAVaCsKyEzQqgbQYAX4ADckPSA+aBZVDJhfIKtKUDveICtBJ/GDBlrYuESA4REHXuUC6Wz+BR6eeB685FhYxgLcIQOlIZD/QXEKOsAOlK5BV5SBBptAy5VB6Q40UAeaVYfcSgC5eQORxiCz48TuOcbs6DEwwEb5UMIbx8AJeLSNETLmdv/8XAbQ4X/Pb29nAOUJ0GGKgpKG4LwDil+4G9E6KBgNfmI7/9BSD1SmiSu5AjvQ+8Dbb0BpFVSOwQZcnt3czADapgK+pQK4DQo00AgaBAWVNaAVTKAwAF+LirFiAtbxhdCglUPgVSLAMpUBpdhFaiijuP0/A+y6QdDAF2gAErSVBnxgJPDAOtBqGNCKIdBhm6CtHqBtIaCrCmW1QhhAq43AA3KvLjOAbkOBnZECthdoB2j7FWiAD5QHv395xoAKIOkf5C/QIJ2cXjQDKPy/fLjHwAkeJHkPTmugeAYNeoHKaFBnF5TuIYc6QkzDLKMgg2AwuxiheRwUhpCtHpCyGTSoAKprRGStGECdbNCAITgPAesbkB9B5Sjo8EPQdZb8wJVI8G1FDNgArk7If2xeBq/eAeUfUHiDVkqBwh9y6CIjA2hL2n9w2H1iAA0kwOo60HYa0EGSoPCAnPb/kgF0fg5o5RqoLAUdpAnKr6CBHNAqOlC5C7oBBXYOBgMeQDgfUqmT9X94dNZGZ/0ZBgkY7fxTOyJGBwAYRsHAhADjyA34ETEAAIpeRKMP2nxjgBwQpgGeHQLNiIAaxv+Bp1+D9sWDljiClnbDOh7gO9qBM03gDhDwmjh+cR3wPdqg2UXYfmdw54qJGdxBAHXgbaK2MDwCLp/8A9x3Ce4QAjvPIFeomOWCO+fgU5ahSz8hsyX/GECDEaBGJmhW/Q3wRGtIpx1U7f+HLK0ENmTMAhcxvAcu+QfNvoAapaCOOWhwAnl2CHIi/28GTn5ZBlAHCbQ0FtRRBTfV0eIcNIAAuhIKNOsMuuoQcsDad3Awga8ZBA4CSKp6g2fHQB0F5JkdSEeciQG0fBuyzFmKAdTxB83SgWbMQB1p0CoFUEMcMsv5GzwbCT4ZGzTDiNIwQ82HsE4+Nhozw4Jb2+AZYlDnD9Tp1HfvZQA1ckH7+UHxC2qs/vn9hQHkFvBy1m9vGECzW6DGOKhh+xN4jRWoEwaaKQUdkAXqY4P2TYM6EyD3gpZLgwYyQB1/0AAAaPAFtI8bNFADuusdJAdeFg9csg/e4w/sCIHMBS0nBnVKbx7rgfYdGRlAy8JBYQTaAgFafQI7zE5UwYHh7ump4MEl0ECEuLIr+BwCAQlD8OAFA3DmWkTOFrg1QBfcaYGnIQZ4qmZgxAPxFnRYBwBg4crEAHIDyB/gw+yAKyVAe/lB4QgaYAKlQVC6hu1dhs2AgjoXIH+A0j+ogwe+Eg/sCFgD6j940AnU+QeZC7pWDBR3IHtAaQ20xP/D8/MMoKvLmIBXq4HSJqjTAhrwgs2cgm62AIU7aNAKtCUDdJ4FSB14Wwfo9Hq0PeyITge2RhxmXcCI3LmHslFm/nF2/qHlDkwemNZB+Ql8jz7QTaBD4UD5FjQjDDrrA3wYJYUdFfQOFdhqoJlgO0F744H2/oeuBgKthgHN7IPuugd1oMEz5sBtJ6DBS9CAzEfgTDxo2TtoC426dSnDi7u7oMkHtaML9iXQItDsPGi7i6ZdLQOowwsapDEHllVPb0CWsMPKJ1gnBhKG/8HXFoJm9EHxDboiFXReAyhuQYOEoIEH0CAeaHBJQNKAARLvlxlAq5ueAwcuQGkPNEsOXqUFPDQQlAdBakAde9BAJniFADj+/0OGzBhhgxYMDIzQvf+g8glUZoBWW4E6xqAVLSC/gGbhQfEDWtUD6gBDDgv9D89pMH9jz1OQATTLsDXgwwT5RLXBnWrQABZoOwMovEFx8ubxMQYG8KAtMwNoABe8AgbIB/lbwSCRAZTfEQe3otuEmX5B8Y85MAFN04yQEAetOgANSoBuQgGtfIKsdvjEADpfATLw/AF8uj94MPzrK7D7QHUEKO2CykrQijNQHgOpBXX+QQPioMEfULqSUHFjAJWNoC1joDpITj+GATSAA3E5qZ0mKnSyRjv+DESD/6OdWuLCajScGGgARgcAGEYB/UNgtPM/2FMdMTObYD/gHcxghCqBNgAZIQ000H5cUOcQRIP2W4JOcpfTiwI3DoWAs46PrywHL2sENapAjURQowjUQQfNxIKX40OvnAJZLaMdygBqIIEOTwI1fh9dXgY2B9LghuyLBM1SgmZ2QQ1AUMcctMwW1CEFza7CDmUC2fH+6Sm4e0FL2iGndX9kgMwU/2L4/Po6eFk5qGEJG3gArTAA7WMFuQXUYQXtfQZ1zEArEUAH8kEal9CmGLSyhwTZfwbQTBdkJcIfBtBMN3jZ64/3DJBOvCYDZF/6V/CMHfJAA2SGVwrc8QZdfSWp5ssAu0oMtP8a1PkFH9AFsg9qJ2jbAcjd4IEBrLOKpKZIaCcV1PFlYgIfwghaMg5qsL5/foYBdMUXqKMOatSDVieAG9RAj4MGUh5dXg7uTICXiENPAQcNhEA6HTfAM4Kg6wwZwVd7iTOAt3IADzWEnJr+lgGUFsCnYINP0/4KbsSDllWDz0AApg1QpwGy7PotA2wFBigt6Ti1MIAGhkANcNA+WlBnFdSZAaUBUNyBOj9aDnUMoAEp0CAKB68EA/hefeABb6BVB6BGNviQyn/QZeOMVCjHkDqyjJBEBB4kA7FBHTtwgx6YN0CrGEBXmoHSOch/oOXsIPdfO9jIAFrVAgorPbdu8KoZ0IwgD3BpMMg/oE46aFYZvtoCGs0g9aDrykCrK8DXrgHPUwAtQwYNkIA6gk+urWIADaSA8shv4HkMN4FbSjRtq8FxAYpnUPoHXTUGWk4OupIMfC3l76/g5dYgt/9H2pOMv/OPnO4Q4QnvUEFntsHlESMjfCUAQhekTEHmI5dLIHMg/oesCAAdlvn53S3wdgbI6ffklMSIxiju2dT/DLCBRORkApppBm1bAm8hguZD8AGFd3aADx8FnX8BykOgMgR0gB1s5QqG/xggy8pB4QJa0fDz+xsGUFoBzcCDDo+DrXBhALsCs/EMKidAeUTNspjhwo4CBsiVmkzg8y9AA6+gQQpQvgMNvIE66KD76EGzzaDBV9CgI2gADqQfVN6B7AWtRgGdowK6yePTmxtw58LjjQEWTxAadFYL6KwXUIccMpD6D3wWAMjfoIE9UHoCbZEAGcQIIzDyG/ZOwZNrqxnAh8B+ewUesHv1YB8DbI886ABVyLkwL8BnEIAGAUEDF+BZeeBAMuh+flA5/x94zgpmyiAm3iHxAtGLKCNB4QkqS0DlIejaP1D5DBpwBg1QgspkUD0BugkFNPMPW5UCKttBA3hPrq6CGAfMU6D4Bd0mAao7QfkfNKgAyn+gAQVQWgcP6nx7y4B99QgwGPB2OCnsZI12/BlIAqOdfyKDa7Tzz0AjMDoAwDAK6BcC0I7gSA1yxqEz8EHNAQBQdIMaJ6BZSVADBjTzDWq0gjpiDy8tBu9Pf3xlJXjWAtQpBDUmwfvrgafDwxpuoJlk8L7M/9CGNSOkoQXqWMIOSgI1ZkFLaiENb9DeaIhaUCMWdAAUSBx0QjRkbzUfuLMEamyBOkNcvNLg+5shZw/wA2fedkD2MwOvVQKpAS2lZmbjAnaA2Bn4xLSAJ5tvBR/QB1qWCU7VwGvQQH4EnUEA2pMJGlAALe8H+R10FRTI38gnS4PEwXvdwTNRjAwi8nYMoA4VSB/ILaAZHFADGLz1ALQFAK3TDurMg2YPQXvmQSdngw6uE1NyYfjy/g4DqIELalTCOr8g94M6zF/Be+1xVaakpE1Iw9Y17SyDvEE8A/hwKmDHG3RiN2jW+cOzswygeAEdVAfqfIEa1LA08BjUmAX6B+QWyCnijAygK7BADVc5nXAG0HJkyBkKkLgD3SEPGhABhR+4ow7MQ/ZxexkeXJjPAE4TwIY6qBEPXhUCHvD4xwCaoYd1QGGdB1Acv7y3C7z0G9QxBm89Aa5MALkP1LGBicFmQUFXEYIOUQQtGQd1VB5eWsQA2pLBJ6LBANmnDS3EKMnTKHoZwQNXoLMfZLSCGUAdd9BsMGif/fsX58FXgoEONAOvjgC6G9SdBW2RAA2QgdhiwLvlpTWDwMv3QSssQGGmbl0GHkwCDUaBOpLIS1lB4QMboAJf7ffvF7hzD1q9AVoxAIoT0AoU0HYD0MoA0Mw1aIaRg0cCfLsE6GyNK/uqGUCHmUHu/f8PHogD5VHQ3mTwmQqgqwLhjVxiGnHoAwDAK9qAK2FA/pPTjWSAbPEADb5A6hHYbDIDA6xegepHCldI/CPqHdTo+s/AgJTskcs8Yso/zM4/IT9C0jR8cARs93/wIYkgs8BnfYAGTpDCjJHAeQfgbUXAW0RAaRNUvoL244M6haD8hzwIA06tKB0OiFtAeQKUNmCDT6ycAmD3aFiXg1e/gDrMoDQHWqkFypuggQbwGSjAgUrQQBloVho02ACSA8U95P55RDgwQgdtQANFsI4tI3hQhxFtKxIk/YNWe4HOhQGXAf//M0C0A28tAIYDaNYbtFwfdFbKD9AWA+T97vCIZYSs+PkPuY0FdLsLKGzAB74C7f0DPTcEfIjsl5fgYAFtcQClV9CgBmgg8j90gBm1mYLwEzFbWRADWIzggVrQ1g/wQYevrzGABvZULQrBW5dAA7eg8AMNtoAGs0FXScIGjkDuAW1dAIcXdEANtAUHVFaCrjUEbZEADXyC8izoINqv7+6CV9bBbtIhrZn1n/xW2TDqyNJlrz8opEc7/6Mdr0EQAqMDAKPJkE4hwDiyQ3o4dv5BMYrXX8gNekj0iwKXUoM6+aCGGKghCWr8gJZ9gjotDNDGL2gpK2i2BNS5BS3HBDUsQTNNoEYhfCkr0F7QjC7skCcF/TgGUIcaZCaoIwS6/9w14wLDHeDSblADF9T4AnXAQZ090F3d2sD7/O+fm8MAa5QqADuyoBO5wctnb25gMPaeznB+Ww4DqCP4H7oHH7Q/E9TxAR0c9xd8D/ofyP5OYMNSFrgSAWQ+6CovSXUf8HJOUKcS1GAF7XOF7Nt8A+mqMDExwA5WYwQ3bHkY3gNPrQb5HzRYATrwDjTLC2q4wq92Q24wANkg/4AGB0ArGkDnJoAa/KCZXNBs2oeXFxhgWwb+wwZMiGp0EJNHEZ2sB+fnM4Bm0L+8uckAWsILOugNvOUBuGwc1DEALSEGD7AAB0cYUA6nQu4gMIEPpAMtGwbNzjJA0xQkzP+Ct22AZrNgp4+DGsNPrq9hAHVEQSs6/sPN/c8Ab3QzQJceQwdN0DtzoLgGzTyCthmA0gaosw05Tf8HA6ihDlqJAZqJA3V+QVsZQPuCQfuGQR1jSOcf5H7kniOZZRvGAAAjON2ADoADnT0BuuMbtJcalAZ1ndvA+/RBM4igAQ5Fw0TgYWpWDKDOPUhM3aqE4cr+WvB2FtDef9A5GSD3v7q/hwGlI4icjkDOhqYPcGcaGPag2X2Q/0GdPlA+BIUzaCAENGACutIMlMZB4QVKZ6DD00BnOYAOvIPMODKA84uSUSoD+LpMeNojpXPBCE0C0E4+MK+AZkFhZ2uA0hGsUwjb/gEuO6AdTQakMEXtPKOXRdjjD30QALMDjqsaQ/MjyO9o8QvTCRFmZIC5FewSRLZiYEDq9OMfAGAEKwWVj4LA7SrgrRrA5eOgA01B4Y/SkYXHO2ZcQAZn2cFbYED5DLQF69HlpQwg826f6GcAraoCdeBBs+qgFSKgTimojALfqAHd4gDrtKL7EXZGAWhLA2jlgKxWKHhVDaizilAL8gcT+Po9FnYeBlBZAJJjAt9Soc8AWlUAGpjjF9ViAB1MCBogAB3yyoC+kokRmmZgaQHoZ9DVrpDOP2TlgYn/XAZQngYFHKi8lAEOmoHKLdAAMSjPgGbTGZDKFPTYJuXufFC4gldrAQ8WBOUrUD4EH1DKzgse7AOdEQEa1ARtOQJtPQOdqcEA3i4Ci6N/DKhbIP6DB8F+/fjAANIDqu/AqzOAN16AtpGBDuD8BFylxgAfREKNa/yrVRhIB6MdfwaywGjnn4Rgo2BgimEUEAqB0QGA0TRChxBgHA3l4TgAQJSfIHEP65yBZqhBnQXQMlNQp/4LcNYC1DBE7qSAZrBAS51VzfOAp0wfBjcIQQckIR8GBUpQoJlHUGMIdP8yqKMNumse0ll8D15GDTpFGnSaOUgt6KRt0Awb6GT51w/2M0A6/6DZxP8MkMMDjzGAZnpBcqDG4GvgslGQ2fDToP+Dhh7+McAOVQM3PoH+BzVIQR1x0IAF5O74v+CT50EzMiD3gJaSggYywPrAnQIGBtip2iAzlE2zwEtRwffQA5dhC8uYg6+lA+kBnQIN2t8NuTcfMmOHnpFAnTRQIxLUMQMtnQWtGoDdTIDS+Sc6B0Ia0ZjKkcSh8Q6ayboPHASAxZ2+Rz8DaPktaDkt+E7xN9cYQH4ELWkGDVSADh8Eddpggxqgfb6guOcRVmWA7Mf/AT6QEeL+/+Cl+CB3gBrRIDHw/fzfXjOA9iyDVwQAl3KDwwbcl2IGDtpMYwD5n0dIlQE2gwiLJ3BnC9ohBQ22gJa1Q8xmBh94Z+w9jQHU0YdttQDtiQe5GzQIA1oizAbc6wzr/DNiS/ek5G9GROcPEs6MiMGL/5BbHkAdMYuQ5eBO2VVgx54PeO0f6IpK0J590OAKaMYVtFwZlD5B7gF1dMCnu//5ziAobcIACivw9hZgZwA0S/gNfFXYf6zRCgpfHYdGcMcI1PkHxeffP98YQAchgpYfg+IMNNgCOtNCCGg2aDsC6IwA0NVnoKXIILdw8EqCry8DDa6BthWAbixA6UzhavRihBtyecEIzscymsEMEqoeDKCyAjyDC+wgg7ZDgO7MB7kLfH0jKyc4vTAincUA9ywjappmRONjHTRACim4meB4w5aRkMIVmz/hfkT1GwMkAYJdjOIGsDJIGsE2AAB3PyPUZdBzL1iAYQCKy0fAVVWQK+n+MKB2krE3pkFlJ3jbjroveAsAqDwDrQ4BpSdQHgCV06A0ARqQAq3gUTHNZgAdEAg6OwU0g40SIlC3w9wISgegwTPQmRugLScvgQNSkLLwHwNoIBi0Sgi0ZQU0aATig8rn75+fgAcwZYCDBaABRdhZMKAZcdAAMmiAAHxTC9IAADicGGEDAEzgwRVG6HkDoLAFdbxBnX5Q2gQN9oHOuQDN9oPOWwB1zl/d28sAymOgOgCUtkGDA+B99kAz/qMMXiL7Flt4MiIlO0gcggbRQINkoHIfVN6BBwHYeBlAK30gW3DeM0AGU/7gH6xjAF1dygY5CPfTU/AhqKDDGEGHvv4AnqUCikfEjTmo6ZSqnf/Rjj8D2WC0809C0I12/hloDEYHABhGAW1DYLTzz8A4dMIAfbYUb9ogyl/IjV6EaaDGEKiTAd4jj7KUk4EBdAc5ZMn6PeCs/gPwfnHQkkf0GR9QowfU6QVd9wTq5IBm8MWB9z2DZohAs1igE8DBHVDgndOgPfCgeIDd8Q/r6IFoUKMJtAwaNMME6rQ/AJ4cDjoz4C30sCi4q6EdSFjHGrS0n1dEk+Hb+/sMoH2voD3soFk3PhF1BtD1WqDOP2gWFjT4AJ4JhyYDeeBqBdAsLahxC2psghqFoE4zqIMH2lIA6nCCBkpAnWkl43SGN4+PMKDODEEmD0EdINCyX9DhdrDZWTF5e+g1fGgDBng7JthiGdZpQu08IadlUMcL5C9QZxXEfgy8xQE0+wjq6MP294M64+BbF4CHyoHCFrzEFrrvH7SkG3QoFvhQNmCHE3y/vbgeA+hGCNCSY9ByYJDLNGwqwCeQg2YkQfENPnkeOAsG3uYA9hckYEF7pkErSkBL15XNssF31f+H2gXzIWIFCRP4BG5QIx9kLqjzDwp70N5/UOcH5AbI1YGvGECDDbCrJAnmB0J5Am+HF2I6qPMB6ryAZnFBnTGLkJUMoLQBWm7/8NJS8JWRkHv6/zBA7hL/Cx5EAm3BAF0XBhr4un64FXwOA+iKMfBd6vCZWmQfQDoooMEa8N7/l5fBHW7QFZWgVR3CctYMoJPFQdskQPkUlC5B51aAttmAllaDZiwlVNwZwJ0q4DJ0UNoAra54en0tpEODspwdT8ihhAlaJxnYAQMN5oAOlwMPKAA7faDl0iB/g/Y9gwaPQPKgQUNQvsewBWvnG6QKqUxGsh+j/GOEhBGPsBoD6JR4xM0jWBqn+Br3jIh8hFgezsQAcQkjdDUAut8Z0QYHIANFIL+CDy0FbpkBrbIBdWzB8fP5OXhFDmw5PiIsEG7F1hEEbe0QlDYFHzgK2n51/8I88PYa0EqTf8CtIbCOJejkfFB+B5WLoG0+4JUXSAGO2gkH+QmydB90nSkXcBYctK1JWiOQAXS2ChMrBwPotgFQPQAKU9AsPWiAFlQWgg+SBJoLXkEEyr9Ao0CDjaBbWEADXaCyEZyPkcMbHITAVQTAAVSQWaDD9UAz/aByHbSFRcu+jgFUhoJm+UF5CzR4BlrJABlAYwafgQAahAWdPwMqwyDnG6gygMpYSBgDdcPtI6ZjAolL0JYhyB7/rwygwQ7QdijQeQqgvPISesDja+DBs6CVCKDtE4htbljyCzgN/WcAraaAHMz5CnzWAajMArkXXEb9g9zAgax7tPOPGZZ0W+oPr3hGO7MMJIHR8GKgAxgdAGAYBbQJAUSDZ0SH8HDt/IMilYQBAIhyRKMb1DmGnb6MnD7AqQZoLujqrkfAwwBBM7ygpY7oszAgq0FL7EGdRtCsIKgx+fDiQgbYQYHvgfvQYZ18UOMK1MmE2A6pWMCNVWCDDjZ7DbsrHtSQAnUwQHvKQR1XiDxoJpIJ3DmC8P+BWoMMoGWXoP2WoH3boO0I987NYgA1zq8fagEvhQbNdCFO8AfZCzEHdEgfaEADtK8Z1EgFNehAHV7QYYIawJO/QY1wkN9BS85fPzoMng1DbcRBOveg2WkhKWNwRxeyx/sf2E0MDDSsPKFxjpiZZADPXoNm0WBnD4DiBDzgAoxY0JYG0MAIqBMJmk0ELS0HH4DGCNEH6myClvOCDpsDNcpAfgJd1QU60wDU6QP5C9Tx4OSRZAAdlgZKK6AG/Vfg9WEge0CdKdhZAqCD/EDp4P75eQygU79BM5ffPj0Bd6JAs27wgxEZIHaDZslBcQ26WQBkJ2jQAjRbCdpSAep8g2YvQQMzoA416EAuxIGOsPBlxF60QTuNDNhoDB3InT5wLmEAdVBAbufik2FQNk4DD+iAOnWgtA3qdIFm2UEDPiA/MbNyM4DcBpqNBR0upu0InMkHXpEIuv4QFOagjhrID7A0gZyOYNkXNABw5/Q0BlF5WwZZ7XAG0KGcoE4UKP2CZloh4czEAPI/aN8xqKMCujIRlGafXlvDwAA95R40CARaJg7Zf47ZEcFbD2B01BGzuJAD7RjAB3CCVhqADrADdSpBq19A+VpOJ5IB1DEE53dIAcIAD3vIphsGyHJsWHwhxRtaGYYyAIDkJvC1cMC94aABB9B2CNDADCMpFRuSWbDZccgMNROBzj+kEw3q5CPP/IPyFGgADXQ4JfiQVOBZJSDzRMBbrE4ygNzJysHHIK8bDZxpP8kA3kqFMUABScegMgrUCQd1xkGHP4KXnUP3nIPSEOgUffB1mcAVSggvQw5YhfMZEYMVoAGD/+BtOIzgMhOk/9X9/eCzXsDL75kgg2+gDv+3jw8YQB170DV2IPvBd9wDb3BRMc8Fr+gArQYADfqBtp1Atpq8BJvzH2VAC1yYgOPYOmIjA+h8ANDKFfA1j0B1oLQCOngRckiiGLhTD0o7oBUuoLwDWkYPWrEFSrsgv4PCFTQoomiUwgDyP+xqUohfSStbQXkPcmDpF/C5KKCBNtAAJqgM1HVpBw9sfnx5EXyAI2glBPpZHchJDJbeQGXkH+D1saDyDOQv0DkNoPNmQIMHiDqVkDtJrCNGZ/0ZyAajs/4kBh0N2y8MowA5BEYHAEbTAw1CgHE0VEEhwDi0woGk2X+S/IfeyQFpRivkkcIKPMv06CgDpNPynwGzQwsxD9zRBDZ8QTP4T6+vAx9eJaboyACagQd14EG2SAGv0gN1okGdRtBeasghUIzgRifo4DTQnfQM/xGNWdASaPBM1M+PDPAOBbATAepsgRr+oNPVwWcRQPWAZmJAnSTQQXjge7GBM6Ggw5xAHRJQIw82wADqh4AanPJ6seBGH+gEctAhiKCl5qBtC6AOH6jRCZn1fQX2C8i9oEYpIjMhhRl0NQJoEAJ1Noxw5Ym9k0NElkWKI0bkfcpAcdBWBlDYQVYF/GUAd0qAVziCOs9fgY180MAI6FA7UJjAjAGZ8fbpSfBS1nfPzoA7uqDr2UCdW5A4LF5AS2hBAzOgmXjQygzQqgrQAWSgK91A4Q5ODUACdLc9KE2ATloHNYRBA0egDj5oYMAp+SjDvbOzGEAdIXDSBbpf1SKfAWQXqEENihfQTDkjEysD6Pox0OAS6NA9kJ9Ay5JBnV1QGgLZC2rQUydrI8oHRuQOItBt4JPWgascQH4Fd/KAJ/GDruUDDRqB9v1zA0/5B237AG2tAM2sgrbDgLaugPIByO+gdARKG6A91bD9+dhnAv8zgJY/g8KFD7iaBXS4IvymDaDzQLOKoIMQQZ0wUByAZk1B6Rx02CW4w/TvD0o+BS9B/o/a+cc124Z1th00XAMMC9BtICCzQIfaff/0iAG0/QCUpsDX5X16zABb+g8a6AENLIEPS4MnYfAoAHggBTSIghi4gcQ8Qhlq+Yyr8w9Kd6C0pmFTDh5sAW0PglwFCe27gwbcoI18dL8i5xOw7dAD8EADFOD7/oGCoLwPWkoP6+CDOp6gVSigFTOgATRQnoIlDxZ2YKdeL4bh8u4yBtAqJ9ChcKBOKugqS0XDBIY7p6YwgA5ZBZ05Alo6DzIT1NmFDJLBfI6tjPgPzrOgPIfww3/wIY+g2fQbR9oZcA8sIsp30NYt0HWeoO09oFVRIPtBVwSCVjuBVgGAV3dBD9kDXR8JGnwAnbsCmgUHreoApTXQTQig7SvgmXegx0EDouAbCbhFwHkTvL0BumoMlm9Agx+gFRqQFVdvGUDbFwQkDMAryEBxJQRc4QAKB9CqIlB4Sqp4MoAGS0BpHVRmgK6EBJX3DomHGG6fnAge7ILddgDackPU3n9sHT2UJPYffHCssKw1eLXF/XNzkQ5C/M+Ar/OPWgf8B28VgBj9nwF0oC74Zg7gWSvoB83iyvMMpIBh0oGl+6w/KIxHO/8MpIHRzj8DHcHoAADDKKBuCDCOBigoBIZ7558kP2Lr6MCSCZb0gtLRREpOWMIUpBs0UwuaxQXdjwzqjMNmIEFyoEYfqCEI6ryDZpFBjUcl41QGUIMUdCAV6Kq6//DGJBP4EDgG6N5R8OnLQDtB5oPEQDNboD3m4LMIkFYPgE+/f3sTvGwWtE8ctHcffNo9wz+UvAByI2g5qJiiAwNo1hvUeAXfBQ5UBWqggswGuR10wBNopgx0YwFi5g5aMaI1KDCWwjIgL1UlMisSk1YZcXSWgOIgf4C2MkioejKAVk2AOv2SwP3EH19chCwl/vWFAXR6ONgEqDHgw8GAnT1QZxrUQAddiQXq3IKuVYTMQIJ8BvEzaNsG+I55oDmge9FB+79BHVPQoYGM0HQoImvJAGr8g64CBB0eBlqeDup4gDrtoM782ycnGEBLyEEdEAboQVugJbi/gNenge7DB92bDkoHkJP+1cGdK1DDHzJ7zsAAWsoLGmAAzYqDZishIQtyH7nlHVp4MkI6raCOIXguFZgGQWkWlF5BfgefQ8AlDD6ZHZSmQe4AXRsGWi4NvkoSONMJORPgNwPo3AgFwySGt4+OMIDiAiMNoSQLRvBkOch/sP3RyOpBS/5BykFpnhV4eBmocwaaDYYcUPmHgQG9gfsfEW/EVgSoHW8GBjEFBwbQqgTQVgPQwAOo8wfq7IJuInh+eysDeNk2cBYZdBYE+PBJ4CqP/0gdQiZmFrDV4BllYJj9gW5PwFiRgVy0IA1oMSAPxoAGI6TNGECnsz+5upoBdKYIqIP+5tEhBtCgFzu3OHhmF5ymcKy8AfsPnE+YwIdagga0QAOKoD31Ok6tDKCVS+AOOqisYWFnAJ3qDlrW/RO4rxt+MwA4nTOB/Q46tA50MCN4sAs4eww6owE0mAW6Ug60VQR8HgnwrAzQQaGgwSHUbTDog4iIQIB3kNDiFHReCgPK4XQIPYxoYQU6FBQ04ALKn6BBCJA8yJ2gjj54gBB0swvDf/C2LtDABegMFdCZEqCZeFAcggZ9WIEHAYLKQkjZ8Als2bNbmxiMPCczgFaqMKCVqzA3gFYTCQKvCwXZL6XmzfD46gqwXlDYggYUQP4D3bACWm10dnMqg5SGP3igQErDjwGUl8SUnBmOrQgAl2GgPA6a+Yd0qGFhhqNzQkwnDym7g7aEqVkVM4DiB3yuCI7BI6jjcWcjqJmg/A86jwNxzsd/qFbsAz0MpIBh0IEdkI4/KIxHO/8MpIHRzj8DncHoAADDKKBeCDCOBiYsBBiHVljQbvYfFCCIsGDEGi44wgqqFveMNSN42SeogQc6sA9kCogNnqEFW8vIoOfayQDaAgBqSIP2g4IODASdlAxaHgua8UUcsMfAALpyDTTTCFpmDVpWDJrhBDVK1ayKwIfKgeRUgHvLQQMKoJlHSFT/ZwB1NkEdLfDeVWBHBHQPN/rMC6hTAupMgfacg9S9BN77DeqYgjqpIHHQTN4j4P5uUGP9+c1N4KlF0MFZsAECBiwNCsyGDXoFihSuuDrwyOkVPW5AfBhGytlY4wPob9DSVtCSbFCDn5mZnQExG/UfupeZAbIgG9hBA80gI1ZjMIIPTvwJvYsePhP2H7nhDZw9A86Cg+IXNNsLSVWQTrMwsIMGulccdKYEaP8/yA3gw8X+/mYwC1zIADpRX0BMlwE0CAA/4ZsRsg0AZA54hhjY4QYdvMgPvOIRpA7sl48PGcAHdgGX2YM6QCA7FICn7/OL6wDPZTjGgJSqGRgYiM3vjFjVwmZ/wTPDHAIMoPQDCkfQAAao8wS69vHT6ysMoL3M4EP3uMUYQJ0a8Gnq4HD6xwAKG1CYsnIIgrfCwLarED4M8j/4XAHIDC8ozBHpCBL9zAygNA86jR/UOYVc6/gP3vnH2sBGb/wSKA+RZ8pB6QZ8tSR0dQHoKkjQAARo7zloVQZoQAS0XQGU58Adu//QWx9AcQo8OR7kRvC2DjkbBlBHDnR7B2gQAdThBg3AoccU+iw9NJUyQIoQRgbY7SHswBloUFqBLLn/zQC6bQOUl0Gz9/+RzzHB8DsDeDUCaFsT6PwPkH5QvgbNWIPKINiViaA0ABpkBHXiQQNkoAGP64eaGTRtq8EzxeCUwwSJCyXjFIaPr6+C8xUo3b8FrpgyAh5k+fbpCQbQSg7QQBdosEYEGAaQ8yuQMjCWjgn2zj+2juR/lJIAFkaQQVMmBtB2KNBAK2j7ko5jMwPoFgqQO8B5+t8fcDjABj9AHWDQrD+oTASlPdBKHVD5BzunBbzN4z3wHBjgChBQ2r57ejoDyioERkReAoUdqAMMOlsFdGYKaPXBq3u7GUCrK0D5CHTry8cXF8BRC0oDoFUSoAGJizuLGEDbf0DL8F/c3g684vIRA2iVAGw5PmLgA0vnhJwOHtDJoPoJNLgLGuzAOutPhrnwlWYM2OIMFmUkdrCGeAd2wDr+WOpqhlEwGgKDMARGBwBGkyUVQgB7o3bEBu1w7/xDWn0kRC9qk5t6gwCQAQC4Qxih3TBGhDhoXzRopgnUiAfN9oIGAkD7mLUdGhhAnfB/f38wwBrvoBlX0B3moIYZJ58UA2jWFdQABF1BBTtM6sKOAgbIjNY7Bgb0pb//IZ0nbB0u8LVNwKXLoIOmRIGNclDjF7SsHNS5A81QvgMuhQft5wQtswa5EdQRAA0aQGZwMRtu+Bo3jESmP6yDPjg6/bAwxr1sG3h4I2h2DzgTDVomD+78MyLpAhcRjOAOgJHXVPC+ZNCyVfDyZtBKAGAHChTumG76zwAPT2j4MkA776D97qBwA3U+YEuXQfGkZp4P3icMOsgPNLsIWgIP2hbwH3YoHSOkQwZargza/8vGJcQAOkjy3bPTDKAZf8vQlcDtAjPBXXp9t27wlXagcwFAM4KgKyDB96y/ucHAwIBtwIURS76AlY+MWPMMYhkzM3ifO2hWGewu4EAAqKMIGqQCzRSCZnpBM6HcAvLgpcSg9AMyEHRKPuhgMUhnGNQx/8eAt/FLbMMe6lwhGTPwAAFolQpk9v8peJaUqI4/Nh/jSJ+MkIgF6wB1BEEz5aBVB6Al/qAtGqBwAOVl0IGN4IPpPj9j+PP7C2RQCXj1JLegErjDz8TCAT6DQ8u+ngEUp+CtP7+/gZe4gwbrQOZCYoSRAW4ncAAItNQctLKCEVp+MEKX64NoUMcW1GEELYcHlQegwUCQG0Fbjf4j3xuPI2xB9oEOlQRt+QHNyoOWqINWmCibZkLOLwD6GrRsHnKjARf4FgfQKiKQPaA0CV7FwABJtyAx0GAh+GpMoL9A6RrUkQZtTQCtlAClT1CnGrSEHrbC6f//f1jSKyRy8HX+UaPvP9a0DQovPdcuBlB+Ag3SgE/5B4YhiA0KG9BKDBXzHPDqFZD7QIMyoEEJRvCgG/D6QWA6B20xAA14gPwKilvQmRaglS6gVTeQq+1QV5YgD9rAB8+AqR60rQp0rz+o3AQNQoDCAlQ2vHtyHHiYpxgDaLWRjHYIww/gKfqgE/RBg0ugMy0+v7sNvkITJA/ZYvAXZ3hBEigFs5X/IYN1KPmH7M42lroBq1mjnX8GeoEhPnDCMCDgP8MooH8IjA4AjKY6CkOAcTQEkUNgJHT+Qf4lyZ+YaYToQQAke7DN1CHMAffqGJAb7QzQhjxo3zloHy943zBwGblj0hGGo8v9GMAzTbCZO6B2UOMTdLgcaOYd1AAFHaQFaniDGrGgzhZopg40KwXqtIOXkkMr+v9IAwEYmQGqBtTABC2P//vnJ/DQvi0MoI4qqKHJyikAXoYK6gyDZgZBs3mgxjrooDPIGQL/qZA/oeGPJc4gXSDCeRinOuRZOJhLYdbB+Yzgw8BAWylA8QNaRg2aYQP5F3a4GWIGHCwC7piBZkEZYJ1+5EYV0E73rCsMZzalgGf4H11eDuz4fWGAdCg4wJ3Av8DBCNBABKhTCF7J8Q+2XB0SniD7QB0u0JYRUFyCZgdBs8SgGXfQveegtAGKB9Bhd6B4Al09Bupkgzpx4PMl/iPMwYwg5A4/EWHLiIgffuAtCKCVKKC90KA0AToUDTSzCUon3Pzy4EEpUPqDXfkHGoQArQKAX0X59SUDYlk+4VnL//iWrYM99h9sJ6jTBtrmAdo6Az4cE10fqY1eHGkRbCU0OECde9B2D9DAGOh6TtCBm6D8COrQI24Q+Q9ZLQPcngDeMgHsjIPCDhQ+n4HXUII67aAzO3hF1BhAHXfwafLg8ouBAb4lAHruAOjGhK/AVR+gFMjFJ8sAOlgNsg2IiUEF2FEHDSSBbrqQUvMBDzDJ68eDt1uAygXEYCC2QSEG8MgkeCk68J52NasS8HkXoBlv0GAAeNXR93cMsKXyoHQHOpsEdDAdKA2DtwEw/IcPVoA6tiAvgGaSQWaysHExgA7XhNwE8BS8TQA0m80OHNgCdcxB2xfgt5+gJVbs8Y/wA2IlE/5yCORWUJkG6niDVouAZ/WBcQzKOyD/ga/YBNoNSrum/vMZQGdVgMIbdO0eqBwAbccBDbKBBl1B54CA4hA04AQ6uA90uwNkkAXV8aAyCXTGBXhVDyNkcAQUp6BtAKABSHYuUWCo/WMAXScIWtEDiieQHlB+Ag3EgraTgPI/aIUF6NBV0BYm0AACaBsD6MBNcBj/J5yHYK7CO+jGgAPgzDekl/v/qWXWEO7AkhUHDFQEo51/MgJztPPPMECAiWEUjIYA2SEw2vlHCTrG0fDAnpSILeCJb2yh2gMJd8ip2swMisBl2qBZJ9iAAahBLQc8DZsBOvOyY4o6A6xjD5KDdeBBnUVQBxA0g6QOPI0f1OkBzWqBGrSgxi2okwXqIECW5aO5FVvcQxsD/+HLMv8xgJafgpaYQmaZ/jGAlseCZrlAh9uBBhfgs9RgPeRXjJgDLEiDAHgGAmAdfXQaa7xiTe//sS4NN/ScxOCSdpoBMtDxBdxJAS3nBq2MUAXO2INmtxkYUd0IvocceBI+5A5v8GJc8GoNUBjtnmHAoGlTyXDtYDP4VG9QmGra1zIY+wJn7oGHYSkAO2eQmVF2Bil1f0hnjwGymgAc58ABAdBsK2yLBWhVCORarv/gPejgTvR/6Gw6cFUD6AC+Z7c2Q/yG1shjpCDfowxgAQMZNGsKCguQG0GdkXdPT4OvKAN1PkGdKtAMPKijCF5BAl4iz8ggbxAPvg4QEoagU+WZwHusoethEFGH5G7IfCru9IUiD8o3wDAAd3T/o60u+P+fgYGcRi8RekD+Aa2GAM0Eg2bgQXkWdE4BqOMMuk4O7DFGyKoSUH76Bt2yAVrdA+pograCgPIX6LA50G0JoFly5P39kMEn4LkfzKzg8AOtQAHtvQfNGoPyOyxNgsoV0M0SjEB1oIFA0Mw8aCAIdNAnSA58RghsoAojoyCHMSN4lhy0hYNfXJ+BFbrVA7wtAXzd4XMG0MAYaJsHeAAKmF4FJA0ZhIBbXED+BZVLsAFOmDWgjjGoowva/w6KH9Cg4cu7uxlAg1mvHx5mAG0xAKVdBoQGBooBLM7hcf8feKbKefC2E9BgBSitgs5XMQ9cDB7oBHXiQekWtMUGdCjjybVRDKCzD0BpGLRdCjTY4ZR8nOED8MwQ0KoG0DkooBtAQIMXoLMOQIMgDBh2QnwBGgQBDX6AtmyB4wsoDD4kFLriASQPut0DNCgAitc/0JUgoEEHdeBADCiNgO7RB8UraHUPyD7QQZg4wwhLuiWUlzCTxH+s5QjURwwMDKOdf1LTKMlxwEADMNr5JyNQRzv/DAMIRlcAMIwC8kJgtLOLEm5DsPMP6yCTFf8k+xczvZC9CgA66wzWz4i4LgzcMdAMYgA1HkEzp4jD2oD7eD/cZwB1Nj+9usIAP+kapcL+D11W/RN80jeosQjqhIGWXkMO7nNkADVsQQ3H//BVA9CBBwakjisDA6KPwQBplqDPyMKWtIO8AYoD0CwgCIM6IOADBnE1AHGFOVycES1Jooc5iA/FjAyIGVCwQxgx+bgSBkw9XB4aDujuYGSEz1qCOkugjpysTgQD6Io/0BJg0D3uoNncd8/PgE91B8Un6KYEBgbobB6QBp2TAOq4gZdAwztZ/8EDAaDlzaDDw949OckAGkABnWYP6gSBOhyg/dmgmT7QQXKgk/4xrg0Dmg1a7QG+JQDoStAgAWifPWjmELRMHPXatH/gwwzBgzYM1G2woA8AgDp4oCXqL25vYzAPXsYAcj/4KjHgeQbgGyuA7gYffvf2FgPoVHpQugGladDyeNAgBvh6OuA+cZAZP4CHyIGjCK2T/p+sDsY/+FYZBmo1dNHSMyNKPgKlqf8MoDgC5WNQpxDUOQbNzCsABzxAq3Mgh2SCUwsDdHiIAbSM/M7pqeABJtg1kaAD5UCz5qA0Agpf0OAAJAmD0jwTeNsFqDOuaVvFADqHArRaCHTlJGiWGHzeAVAxiA2aFf73/w/wukQ7BtDgDKg8AF0zCcmzDAQBj6AiAyh9yulFg88UAXU2Qec6gPIBaPYefLgh0BTQIAdoABJ8iOP3twygTj6PkCoD+DpUYDqAlXugAxL//f7OALqyEbTKAXRrAGilCmj7EngwAKgXfB0qcnwzUlhvo8X9f+hAJTi2wFshIMEAut4PdPYGKM+DDtgDlW3iis7g/fWgcvjR5SXgK1NBKwZAN6KA8h3o0EDQChjQ1gjQQMat433gQywhqxcw8x0z8MBEi5AV4NUYr+/vA6cB0I0doBUEoMEdUBkDKsdBq6lAA4+glUCgMzzAe/AfHgSeDbKZAbRqBLSqBZRvQPpA6Q10CCXocElERxxqN1a/MxAP8OYb8sqV/9Q0c4h2YAd81h+UAkY7/wykg9HOP8MAg9EBAIZRQFoIwDoRo+GGEgKUNqzoHJz07fyDPIe94UnUIABS2DJC9wmDZntAGHSiM2gWB9TrBnUUQctKwcvnf7wDN5zBjQOgftBSYFDHEN5YgFfYkEoI1JACLzMFdu5BJ9I/v7WVAXxmAPAEcVCnH9SABc3Ufwaf9v8HI7YgM4EsDKCDwkCzh7BT/dEbkf/RBh1gs9HgbQbAKw2RO1cItZhhhzv+GNGSJWSGFHbqPogGnYT9G3igHmSGGFk9VC1wUAV07Rn4Hn5sAwWoNsB5qHEJGVCArMpgAnd4QB030CqLBxcXAAdj3MAnooNOL390eSl4RgwUf6oWecA7zNXA92+Drr/TsK0AH7IIij8GBkRcgcIJ1GECnUYPEgd18ECdHlAj/j/wlHDQIYSguAIvV8ex/9kReOUX6AwB0NVyoEGej68uATucD4FG/2FAOccBGmfgtIOjoQfyO6krATDCCxqSX97dZQB1UkD7vEGdf+QYAq2GeP/8PHjGGjQLzSOgCL6yTFzFHbjH+gj49gLIvev7GEArBkC3I0DuMYeGHa7OP1kNWGIbcHg6neh5G1xUQOoYkBR44AaYHkHL+S2ClzOwAQ/iYwOe7H/39DTwlg9QJx+WLkSBd+CDlpt///iYATRwBOpcsnIKMoDutgedkwBaXQGaLQefvM4AKZNA6ROUbljZeBhAnT5QRxzUiYYsLQcOQLy/ywCKpx+fnzLAZvtB50kwQmfsGZA6vbCMgK1TBvILaDUCaGsK6Mo70BYjNg5+8DWUoIP6QMvcQWkcdNYBaCDz2fX1DKBrHUGz4qCZ/y/gcucvuEwDqQfllb/Q2WxQPgAtY/8J3P4BSjugDjfI77CtA/+JjVscA4nYqibsna7/4K0+oPIPNFgBWsEDypcgDCqvvry/wwByE6hcAQ2egGb7QfkUPIDx5TmDZdhqhtMb4sGDgbAl/5CVWv8xyjSQAKjsBB3GClodAZrlB20bAF0DCzr7AHTOCmi7B8ge0AoQUJoAnRUCOiwRNOinZVfL8PjKCgar8DUMt471MIBWfoDSBWjAALTiArQaC7YNgHj/M2AHNOj4Q/yPL/+R2Lkagh3YQdHxh0QEwyggNQRGO/+DIc2AatrRmBjNvUSGAONoSGELAcahFy5DewCAiQF0mBZotu/GkQ5wZxI0iwNavg+axYXd9wxbZg/pIDAyQDpcjIgpenCj5z9qZw84wABqIII6HqCZQFCHANSZAJ0uD7qbXkjKBHwCPGj5KnJSAHUIwHu2OYUYQEvbQWxQ5xTUCWWA2gNSj61jCRYHdczgjTCkji7cErRi+j+ODh22hhwwfYLcIypvBz7oShJ4RdbV/fUMDAwwvzMwwGYVQTOfoOvNLu4qgcx6I7kdM+kj0j1m5xcSzqAD3JiANwKABkRAHSvQlXugg91AZyGAwhfU+QY1wEENfm5gZxa0dQO0XBi07xs0qAPanw+aAYacyv0PLa5ALmIEL3cG3ekNiqdnNzcyyGqHM4BmxkEz4pCDyKDXMaKHDTBcQJ0psBrgEndhWSvwjDtoOwEDSnxA5pcZIBGIFAzYq05iOly4Ov/gcyvQVpTAlvKD0hhoEOXFnZ3gzj1oeTworYI6gqABHfBtBsDBDtBd8aBDBEFxDtq28B96/gFGg5mmnX4GHACtrMQyuAfRiMivIH+DBo5AM/mgvATe3gNc5QBKV+BD5mCDgsCtH6AbAEADduzAWxJAnWHYtp//0G0M/6HbOmCOA3X2QIMsoDRnCDycEnQqPGhGH5TuQGKy2mEMoFl00OCAmkUBeOYfdBUlaOABNGMNNvc/7EYERH5iwMi3EH9DBoqYIWdiMLMBaVbw3n9Qhx40uAO6vhE0mw/amgLu+L+7Cxl4AM52g073B28RAW1ZYGJlAHVsQWUd+L78/5AVGjD/QQar/kGTLCydQmm0eMedLtDKof//kHyF3SywAvDIDVSeEbIKCOQXUIdcySSdAXTF6XPgifvCMubg8yVAA66gwQ/Q1grQjPy7Z2cYYLd1/Mcz4Aa5eYCZAXJ2BzcDKC+DVldc2l3OAIo7UFoBDS6A6grQ3fuggTBIefyPATR4DApzXZcO4DaiJvDWLNCqEtCqCtBZBLeO90NWXMDKP0Jhhiu5/6diJx1qB3EDOvjsRXMsWeUAw4CBQdPxx6gPGEYBUSHwfzScBkkIjK4AGE2KRIbAaOcfa0CNtM4/KBDI8jPu9IN95hRJPUYnAbhA+88PBlBnCNTgBS2BBp3gDXIa6LAncOMOdJ+2kAqDsnEasFN3kgFydzTUTEZkGlQZITdm/zPAlov/BZ+w/Re8xBQ02wrqWICWk4Maq3DXoYUFqOHJL6oN7lCDTiwHd77ACec/ls4rA0yGiDyIpePECOkkgTsVDAzg5faQjjwDynJ+cBMceEo6B68kAwgDW8cMoGuvQGEHUi8sa8EAGqwANX5By2q/AWdQwQ1ooPmg5bkQxyHbz8gA65RCkgN63MI6O0wMxn6zGZ5eWwucaVsLXPIrzCAOvGsb1GkBzQqClvm+f3aKAXY41+9fnxlAAwWghjro0DfQoVwSSq7gw9tAM4X/oHeII6+SAPX9ZLRDgQ34uwzgpcPAw9RA92L//vEevLwXfJMDrsESYCcfvKz6H+TEb2Q2AwWAESlekI3BJY4clrD9I4xYBgFASQ2U/kCrOAQlDBlAgyuSar4MoNUpf358BK8KAKVNUEfS0HMiw/0L8xlAq2H+I3XcIAmO1AYYtRtsmGmZEWP5PwN8wA4UbqAZctAwDGRFCVT/f8jBeODVLdCtQKA8C5rFhd3gATIWNCMOmglmgC5XB1vFyAg5NwHYmQZdx6dqnscAuuEDNLgAulYSlEZB53+AlqaDrhQEmQta9g+5uu0vA2gQDVTWgML6P3yFCXI4YQsz2KAGqAvznwEyQPmHAXTqPWiPOijuvgBXHIAGckBXkYLKIS5+GQaQu0HnDEAOCf0OWfkALP9A/vjy5iYDqv3/SE65kC46NM8yQN2IKOCAV2EyMzAgrRzBXEUFsxLmZzS/M0LKJjbggaeggyRh526AVmSBtmO8ur8fPCjAxS8H7viDw5gBeTAFPSwhbgR1/EFXHwpJm4PLO9AAI+hgT9CqDFCdANpqACoLQCf7gwZ1QOcPgOITNDj27fMTBlB4gwYAbh3vZYBsmXgHvHKxkuHKvhpwWQ3ZQoYZj0R3QIdC559haIHRzj/DEAejnf/BFIGjAwAMo4BwCDCOBhK2EGAceuFC0cw/LAwGfAAA6AvgbJ+p/zzIIVefn4MP1wLdDw+a9QQ1rEGHQoGWzYLuygadGA47KRo2wwoKB9ChVKC7wcFLpP9DGuVwL0IZyDH8H3kpObRRC+mwwRr2DOABB9ASWFDnADSzCO60AN0KMg6lI4azU4pIaJgDI7CONyO4E2Afvxd88BaoIw3SBeoIgZZ/g5YNQ1RCmvagmTLQvmDQzCKoIwQOE+DgBuRQMUZ4pxu09Bi0SgB0j/d74OFz4EPfGGBjCQg/IpIBphhEDjYAwAg+7Rs0S/v02hoGRaMkSGcV2NEHzdCCTtMHhdUb4H5cLuAJ9yB1oH26oJUcoA4WyBRQmMloBoKvcwPd546yRQLaoQMNzoA6uqBr/2Azh6AVA7DtAeCwR1/6/h+zs4Iys4bUeKek0Ym708+ABNDKEWj+Qh8EgAzuMIKXt4M0gzoy//58ZwB1gN48Psqgbl3CADo7ALTMGtQJBm1jAQ3ugM5CwN1pY8ADiG+soc9KMhIsIxiREzp48AqWl8BpGTyIwswAmdyHnFUM6mxbhq9lAK0EAA3sgZZ/iwBXtXADO46g2XHwAA4w3kB380PMgBzwB9oKAZrRB90oAMsrkEGX/wyiCg4MPMDrA68faQevqgANrIDOpAB1IkHlCGhFEWhgCbR1AHQLA2igEdSpBC2xB6Ux0CABaKsKKK9AtiNAUhu+UIWFDWzgAnSrgISKJ3glAGipOuhsB9BAHWg/O2gwAjTocf1QC/C+emsGUHkCGtD4Chwo+Il04wN4JQOQD0oz2E7MR3EPtrhhhJQpjEyQGXXQGSqgATeQ3TLAVRCgszYgZ1AgD5bCTEWkE8x0wAAuQERkrRlAS+xBg1YSwO0qoIP7QAOkDLAyFTiAAzp/ATTQAhl4/c/AQOCsClB8fHx9BbiEv5sBdOYFKJ7Pb8tmAK0k+g3euvWVAbJS6z94IOwr9JBI4IgGA2RV0W+G2ycmMIAOAPwPXfHz/BbkhhbQ2Qrw8pqcGXIqd/6J3sbBQGIHa4jM/g+qjj84i492ZBlIBqNhxjDIwOgAAMMowB8Co51/nOEzxAYA4B0KSpM8lQcAQM7B3tmFOhRrh+g/A+iQKNCsD6gzCZpRBh0gB1oGDutIgveE//nGwABdHisgrssAWt4J7iCDZgCBy2hBp2f//PKS4dfPDwzwziUjouMM6XQxQTsoiFlJ+FJtaEcFtBwZ1KkALT0HNeJBDVxQp0NKIwB84wDsvmmsM2kY8YHIc9g6UhAxRuDeZuCsOvAkcZA/maAHv4GW8INm1mATqgzQhj1oLzxoBgzUMAYtHQbNkIMGS0CdSNA926wcfAzy+rEMz25sBJ9ODpqJZIA2iiGdJeiQAhMTeMaS4T+umUao2xkRgwCQjvxfBtCy/ndPTzCAZuFADXBQmIH27AtKGjOA9kODZgPl9WIYQKeWg/SA2KC4vHtmJgPomjFY2KE0BmEDKdC72FEbyv8ZGLA1cPF2/gk0UlDSPjXKRixmINmBPAgAindQ+lazKgYPeIH2UoOvULu3mwG05xnUcQLPIAM7P28eH2MArXohr/NPXEON2E4J7sEARFoBdTTFgas9VEyzwFfreebeZgAtBZcCrnCA7LlnZIDkqa/g5dov7+1hAKVLUAcZdO8/KCxgq20YGSE3IYDstYvZyfDgwgIG0E0eUup+4NVA4MP2wFYzMoC2CYC2D4HSySugmaCOPvgEfuCqEFDYg2biIZ3qfwwi8rbgAUdQdoVcYfkfvMoEtBUJdCAhfIAQW5qDxyl00AzoRnngYYCgDvHL+3uB5zccZQDFFagDDhpcAOVhVeCWA9CyeNAp+KDDM79+eAgepAAN4IHsAukFr0YCdZ6/vQEPZoDORAEtsYeUqUwMOPMpyD3IGKgBtIReUhUyEAG6rx8UNqBDOj8Br1OEDJL+hZZU2NMHzuX6QF2gAQ01y0KGp8AtOiC/vX1yggG5gw250vAfeCYeZZsUyEas4cnAALoZAjQgAzq/A1SmmAbMB1+vCHIraFAGdL4HrMwAHaIIsgM0MCah7ApOS6DrM8F1A7yc+88AWSn2n+E/jnNDiOqIUrHz/5+kDvrw6/wPuo4/rvTIMArwh8Bo538wppDRAYDRfIsjBCAN/tHgwRU8Q29ghCoDAGQPeuAPL+ydBEQHAdyghe71BTX8QUvVQXs4QQdAyelGgmdFwct8gVr4xXTAnUjQDDdIHXhvNNDdoA75o0tLGDxybjI8uLgIeH2cEQOosQ+yG75kGBrdoIY4bF+/NPBmAfDd76BhACbI/l3YbCzILQrAjjPojnjQveWgGVlQwxxkp5iSC3iGHtTRhpxYTnhWC1tqQ55FhnX+wbOlwMYhaHUDqFMIOvwQdL0YqKMD6kiDZsFAM+LgXAxcgQA5Ff4VeFwANGAA2msLkgOdV8AjrALuKHwBniwPWlYLmkk19JrMAFpGCzqoC5RuuAXkwbcj/AefQs7EgDj5HFZOIJUXyAM2QDZoVQFoJk4U2IECNdZBYQPqzIE6GKB9t6CD6kBLnEH7c0GdIJA86LA00AoN0FaFr+/ugE8PZ0BepYHRMEZeMgwKRRwNDiwNatIa2dQsEXHkCRwDACCbQXvhX97dCV4yDZqdBi1LZweeOwHqxIIOB/z9/R0DckeUtJl/6nb80UMKVx4H5TNQZ+7Xjw8MoPvrQZ0w0K0MoNnYT68uw7eIgO5nB90GADsxH3SH/Ptnp8Ezy6BZXG3HJgbQKgEuflnwzC9ogAl8ECRwlQRoNh10pSIzKwcDbGsPZBCPgQE2WAYaIIOdowCSA13BBzoRHrSSB5SHQUv1QfvJQXaB8hOoowmatQbdRgEahPzz6xP2ASdYQDBC8gjIHNBNDo8uLwMfigcqo0CDEqA8Bcq3oLzCClwuD/LH6fVxDKB8DR4MAx4SCpqFB+UZ0KAlI3hlESP4qj2QGaDVNKDONch/oG1QGjbAAzQfHYa6iVDcMoLDDLS6ARQXH19dBZ8BomiUwgDafgNyCyg/gvIlyP+IgUyIuf+x5EdE/P8Hm/3s5mYG0G0VoooODJ9fX4NI/0ctE4nq/EMNBpUVoNtFwOkBOAD48s4O8EGOv4Dbf2DnRcDcCYp/UDyCtlqA4gq0yghUDv6Ar6LA5Q8S8/t/6nV0Bq5cYhgUYLTzzzBMwGjnf7BG5OgAAMMowAwBxtFAwRcCjCO08w8KExoNAECMRg9XxAAAI7TzD2qEghp1oAYu6FAp0En9oEYrqOMKasmDlgKD9pKDGsEsLJwMoIPdIB1bdvBeVvPgpQxnNiaD2XwiGuDZRtDSUOTl+SAvggYWQLPOQjIWDEwsbOCZJdAKA9Bp26Dlt5BGNiMDaN8qaBABQn9k4BPTZuABnj0AGoQANepB7gLxQR1z0Ewm8RkLuWMNDh0GBvAABAt4NQJkLzQTeLkrSBZ0oB7oACxQhx00uw/qRMAOSAPtk1UALr8HdahAS+tBcozA1Q+gU7NBnXPQCdigpbCCUsbg5bqgsADN0IEa2KCwBq0SAM0qgvZJw+4dB20nwOoXtM4rI3SPNSjeQJ1+0OACaNYfFGaghvjnNzcYQB0z8AALsPEsImfFAFka/B+8RxvUuXJKOspw7+xMBninA29ng4GBgYGeDQ5KygIserHkL8QqAAYGyIF1v8Cd/G/Aqy1By7RBYckPTHcsrJwMoHTw89srBvjMJjg4CIUH8eFFaacEcxCAEdwBB+0LB6VFLYc6BtAhh4+vLGcADTaBl/MDZ2NBnV1QngOtdAF1xkGdPtCsr4SqBwMknTIwgGZ8QbO8oIEEUGcYlA5AK19AHT1QBxY0+PQduF0IdMgjJHchyhfY4BLIfaBBBFBeAG0hAR1SCRoIA60MEATeyQ/qSIJWqIDcC8pH4GX/wM4n5FYNInI30EqQ+0HL90F5GHRoIch9oHLq85vrDKAyA3TwIMjvZzYmMYCuuQPdlQ/a5iEgaQBePQO63g402Ag6If/Pz48MoLM7QAMWILeA3AdaCg/ig/bSo5x9AHMeKP8wYpa1IL+DVmGArukUVbAHr0r48vY2A+h6QRmtYIaX9/cwwLcd4Ez2aGkJnlchHX2Q/0BXKyLKW4R6jLSFbbAO21YeRkieB/kfdvgfehkAyjegQRJQGQTKT6CDHUHnaTAgDUBgrB4iKu8gxfn/gcxnJJZ5/wdvp2xQdvxJTQsMowASAqOd/8GcEkYHAEbzKVoIjHb+8SaJkdz5BwXMQA0AAJe5gjr9vCJqDKAT30GdcNBMGqgxrWlXzQBe3gm8VuvmsW4G0EFQoEYwqAGPfEgWqPMKWuYLWhkAWgYPmg0C3SEPmpVigB0QBj0EC9TY5xFWAx8sB5plVTXPZQBd4wWapQM1rEGH1YEGDkBL2UEdl1fAZbwg94D2/oNm10EdBNBKgGsHmxhAy2gFJPQY3jw6wvD//z8yShxER4VPVBO8/FtGIxC8n17JOJUBtAcetGIB1PkHX4cH2t8PPGEc5D9QJwW0XBo04wXqYDy9vpYB1OkAhQ+o4wDSB1oFALpCDew2YMMQ1JAG7QFWtyoCu5mdRxx84BzI3/L68QyggQQN6zIGyAn7f2GHBEBoJN/BOq46wJlZ0N5+UBiBZv9AS29BqypADXDIXe0M4HABxSFosAbkDvCgw4tz4P25oC0AKB1alBCkUQMDXzrH0nkiLVIh3U+sevAOAMD0/Ydsl4d2hox9ZzBwA++YBw2ygGaOwR0bWEcJb0Offh1/ZL9iDAJA/Qya2QYNRIFm6UGDe6DOHGhWHnwWBTDfgDr9oHMgwLP0DJB8BFodAkoboM40KJ+BBkNAAwVgMWBe/g/dGgLq/IPyNPjKULBeRkS6BS8B+A+ZKQeGF2i1C2j1AGg1BWjQjp0LdHilKzi/gcwGdSZBHWPQ4YDge+xhnUiksMbdifkPPqEeVD6omGYDT6BvAJ/hADqbAHz4JvBwP1A++Pf3BwPoSkDQVXSg/fOgGwde3NkOXgkDOksD5E/QABBo4JEPuOLJ0HMy+NR60HYei5DlDKDzHww8JgCv0DzAACoXGODL3JEzKCNqbgXGA+jwQ9BAymvguRygO/NBKygkVTwYQFcXgrY2gVZRga7ZBOvEaCrg6vzDugJQeZRBAagcER1SbFt/kNMVKIxA/sS2GoGJmYUBdMPC0+vrGECDjqBB2a8fH8C1D6bZdtLdMtr5Z6A1+D/akSU9iEfDjGGQg9EBAIZRgAiB0c4/3tQw0jv/oMCh6wAA2EJwQx00+w5qcINm4EGd4FcPDoBnwkFioOXjIJUgcdBhcqCOOWiQAHTYFGhZNGhfLOisAFDjnV9UC3zYloCEPngvMehALciMM/L+VkYG0GF6oIbzx1dXwLNyoNOrQTPm4BlsYCMd1FCGBAdoFl6BAbw0Gbj3GtR5ZWHlBh9UdvtEP/Au73QG0JJU0EnXKmbZ4Fk1nDPUuMKWEXpAF3AQBHRfuZ5rN3CmVwQ8sADqHIGWf4M626D9wCA7QEuTQf58/fAQA+gAQNCSXiEpUwbQ4ICwnDUDO6cwA2jfNGhGTEzengEUFqAZVtD+WNB2ApD7QR1x0HkGoM4WaKsF+I5y4FYH0JV94NPKgcvyQZ0fXCUGI9J2DZA7QOED6oyBGt+gQZRP0CXG4LvVgYMVwrKW0Gu3/oFnr0Ezl/Dr+FBa+eQ1KijZ/oJVL9mDAHjKWBzxj2I/Us8Lth3k+e2tDKCO7TvgcnjwjDBwS8DP728YsJ5/QMbqCFp0jtAHAUB+BG0JAa2UAaVZHiElBjFFZwbQCoAfn56CUwDIHZCT8/+C8z5oEA4kAaJBg36ggxBB5ggBV7JwArcB/IJuhwBf6wlswIP3sQM7/yA1oME50GoJUEcaVrZAZvH/M4D294PcB1rmD16a/+cn+FyMH19fMIBWqoDSPWj2HTyYgGWvOOEZzP/gQzxBeUJOJ4IBtGXn/XPg1XfAuAFdMwq6bvDxlZXAsiOF4fntbQyg1QugFTjgGw6AZ36AVgSABkhAZRBokAK04gc0wAZaUQMa6Lh9ajIDSP4B8BYI0CoJ5MEz1LQES4sQGhYnIDWgQQ9QfgUNjiqbZAKvPj3CACpfIYNLoGKFCewHXZd2BtAyfIx6k6jBEOLbXrg7/4jy4D+WgQWYDaBBFdBgL+Q8mL/g6wdht73g375ApBsJdhAJl1vk5bPh0ckatLP+oOgf7fyT0Uka7fwzDAEAKvlHY4phFMA3Qo4GBfYQGO38Q8KFrHAgfmAJ+xJhRnCDH3TiNujUbtAhfqCZd9AeaNDBXKA9qiDH8QM79aBZ7zunpjCAGnuadjUMl/aUM4D2zz44Px987RNotptfXI8BtHIAdHAYqMGMvLcc1nEFrTYAza6BOsCgTvEf4Kw6aBYdtKQdNHsE6gSwsvMzgA7kAh86Bp1FFFd2YwDdyw3qfOi5dgJn+JoZQA11yKwkcO4MdCc70mwcMQ0fcIOcW5RBRisUvOUANAMPWuYMGvwAzcqD7AIt4wc19kGdZtBMGOREcuCJ8cBVEaCD1J7e2AA+QAzU8YeslhAAd2pAnQbwzOj7++BBC9AJ8qAlzqDOD8gfoM4+OHyAM6mQmXlFBtASZNgd6Az4GkeMsI4F6BR3RgbYgYSgAQWQ+aCDEUGrE0AzrqB7uu+fn8sAW42Bshf4PyiU0GcPYdmUiA4AemcExc3oZweAzEWqEqFqccYTTv8jV6tEpn+iBgAwO22gtAoKW1D8gNLKf4zZXvKreFrOjCLyOiO4MwnK3+LK7uAZcl7g6hvQ4BtoVhw8iw/saIM76EAatDIHlP9AA1agwQJQBx+UpkD5AzRAB1tZAspzoCsiQbPXoAGmh8BzP0D5ArScHrRiAjRwBlqNAjqrA5SX7p2ZCU5UoMEw8L38zKzgGXfwNYDAQQDYuSCgNAoqD0ArfsDbAP79hg+2EJqlhlgAKc9gcYZc4YC39gD39oPKHFBeBq2EgR0UCNIFKrdA/mYDrkoAbZ0B6YWsfpACb5kB2Q8aPINsgcBRlTEgpUdwmkMaAGCEHHgKCh/Qagvwsnqg/0BbEkD7/0E3hIDKGdC2ANDqBNDWBdD5KSiH5qHnN2Rn4Oik/0fLk2AtuMzBYga+zj8DtjwMFvsPtQY9f2Dmf0RpgyMvUTgAQH4+IzFv/x98zf3Rzj/DMAP/GUbB0AiB0RUAoymVYbTzT0QiGGIDAJTMeOIMDRrO/sPsZMQ1s8oIWSYOO6zvL7RDDlrWDprZBjVAQft9H11ezgCaDQPtxQd1BkCdVdBMGGhmEXQKPehgL1BDHnRdGniPMPiuf6Rl+eB+KqhDwgiefQRdfwU6UwA0+wXuDAMd+vzmJgYJ4LJY8GFZLy+D8w/I3aDZQtAWAMip/CyQlQMvLkCu2QPupWVgwFz+T0w8gdSA9q6ysvMC94C/ZhCQNAKeZn6MAdTxA83Wg2ckgVfrgToCoO0HoFlNUHiC/AlZkcAF1PcWvKca1JkCLf0HdYxAgxugbQ2gA8VAHQbQoAJob7GCQTwDaE856PAx0PJf0Iw9aNAEtBwYFB6g8IavYsC5BAC9o8oAHQBgZADtrwb5B7TXGbSNANTRkNUJA19h95+CO+uRO5QoaZiREb7cG+wqNDcz4pvNhw1iMODwKM48wQgtVynr/DNAUhfCOyj2wcz+D141AVEEanwNnQYYI7QDCspLOk7NDKBT7y3DVoOXrYPSJ+h6O9BgE+RsC+BNHcBbKEDbU0CdflAnHBzKwA4zOK0DD8n78fUVON+BOrCg/ADa6w1K09cONoLP5gCFEWjQDLRtB7TUnYNHEny4JehQUNh2AVD6BHX6QWkRPLgGPCvkO/DeeNC5HqAyQMkknQG09UDBMAF4hsheBlheIKrzD49JWJxhxhdoRQ4ofwhJm4CX3oMGI2B34wtIGAIH8rjAh4v+hw0mAgd8QNsAYFs/JIC3KYDKRQYGNLOxpWVo+IPjAbrNCjQwAVrhADvoExSObMBVQ6DyBry9ALjiBOQ+0BWqysBbG57f2syAbVUTsR07nJ1fSutcggMIDFgALfIOrfLj0O5oDeqOPyhl/B/tyDKQDEbDjGEIAUYGBobRGGMYqYCRYRQQEQKMQy+cht8AACQOYLPtoAYr6ER00Iy1if9c4F3QveCOJWhVAOgkbNCSWdBeXVAjGdQhh1wz9ZcBdHc3eBko8JovxEwprAiE2KFpWwW+Em/fXGvg/dLi4FlA0CwcSC+oowE5AJAJfPo2aDZQFngLwccXFxlAB3A9Ae6xB53kzcknzfD6/n7wAVpcfLIMoOX0KAdf4ZslQ0qS8HgEN84ZwUv6QbPnoP3ekJOu/4Fn/kArD0CdJNBVYaAlwf+h/gPpt4vbzXBkmQ94wAB0DeKbR0cZQOH3DDiQoWgIPBCRhR18MjpoFcHbx8cZQPvz752dxQC71xzU2Neyr2U4vSGR4T90JQBkVQBsQOM/Yrk5js40rIMBcjdoBQWoAwZafQE6hRsUT6AwBa9eAO3Zhl7byIAtjLA2yjCrMPROBch+ac1g4MDJccjd4P9BsQ9zN0T/f3xmE4ovShqLBMoXRowZWwaUFALjMFK5nKJ89h89XjDLUVi6gG0/Ac2og1bpgK7Ae3hpMQNobzxoZQCIBq3IAR3KCdqfDioHQNt0XtzdxQBKS6D9/6AzA0AdftBgH2h2H5QfYFte7p2bwwBb/g3Jh8DVMcABNU5g3gRt1QGtPIAMbDEyiCsBtx78+gI+oR+05B/UAQflDZAbQbcUgPSDBiAwyhJYROBNC6hhAgtj5LgDrUAArY4Bza5fP9SC1ERjZAC5A7R1AGQVZMACkRQYkbbdgEQZ0QeLcAwAQK4w/Q8uH0ADiIpGyQw3j/WC7QV1+kHuAQ2KgLZagcIVdDMCyA2gFVSgMgKyLeM/wp1Q/2N08DDCBREWWFcAQDwJ9iDm4AoBvUR1/rHle7Q0iyUuCfsLvU3xH28jYyTO/o92/hmGIfjPMAqGVgiMrgAYsSl2tPNPVNSPdv6RWpjkphni9eGcjYU3XsGtQgbQqhVZ7XBwh+7lnZ0MHLwS4KvRQJ1/0J5+0FYBUCOVT0yLAbT/H9RxBzVuwR1NlGX4mJ0U0CwfaPXA90+PGUDLjkEHSIGWGoP2CoM6F7+/v2cAzRyCOhigcwZAHX9QRwGEQQMSoNkz0GoE0Iw6aIAAZcYcy3grrsEa1I4fJBpAYqDZe9DhhrC7yEEdZVCnGrQPGjSjDvIrt5AyA+xaRNDVh+ClxcBBBNDMppxuNPgsAtCsIagT8efnZwZQhwYUNqDOPujKQhAfdFaApl0VA6jRD9oqADqRn4mRmQGyTJkJ3GGAr2oAT8WixzOCD+noMTKA9IOubQTN7n7/8owBPFgBnLkFrSwAHTAGpn99RTksEaWxiDU/YutYMoEHOUD2QiY5mcCDHKBVFKDOJCg0IXJM8PQNUgcRg6wAAS/5hsmCJRFxgBFnEM2k1SZE6sE/AAD2CZIfqFOu06dTAnUrsJMFuloOlJ/AK3mAB+CBlpeDVt2A8vBf6CodUHoHnacB4oMGCEB74UHxBVpJAjpgEnSzBehwS9A2IPDNHsCl66ABBVBHFTTPAepQg1bLgK6jBG1vAXXsQWdqgA+EA26BgWwF+gfesgMqM34A0ydknzgD+LwN0BkCsAP1IJ1/pE4vLAZwdv6xd/xxJRjQAXVvgAfxoXeMQTeTgAYyGLDdU88IXcuHlAQQ5Skj/JBOxKAiONOCNYHuzQcdjAoKJ1jY//z6mgGU/0HbMNiAW4k+A1cxgfb8gwYO2YDXFIJWDcEPGGSgJkDxAGTlEDWMR4kbIjsrNK7/6db5Zxgc4P9QmG/8P9qRJT21jIYZwxAEowMADCMRjHb+iYr10c4/ajAxDuAAALifA7GfEbrfHtawB90HDup8g671ewG8Cxo0qwc64A7UoAV1WkEzVKBOK2gGETSLBepIsLDzgGfwMWeKGRhAnQTQHfpqloXgmXvQMvvXD/YDbx+wAc+Kg64FBHUmQNsLQPv7QZ0I0MFdoNl/0BV3//7/YQANAoAa0+DZRmwNCrSwZGSAQLA3kdjwCEBSD1ptAFrWjFjiC9yu8OMjeDAENHgBWv0A25MLMhXUwYHsKf7JIAy81hC0JQLUEFM0SAQvtf757TV4pQPIL6BwAg0CgLYRcABP/394cSE4PN48BN4nDnSXuk0ZA/jaReCqAdBWAtBAB+Q+clgDANqpQFsyD++IADsuoMPqQB1/CVVPBtA+avA5DMDBCevw9Qwgv4H2GP8n+bYEJHsZIQeUadnXMIAPhgPva2YA7y0H7WUGDQKAZpVBAzr84voM4EPm4Ekb1iliAp+3AOrkgK7XUwEudQbdBoGcIWBxhtFBh3Xs0Tv4uMTxFEZYBxqwqkfNm4x0L7soaQCC3A672QDkuf/gWz1AW3n+Q1eDQPzDCDwj4juDtEYAA6gTCuqwg1YBvXtygoGNS4gBtDUAdHYAaJDg3JZ0BtCqGNCKoOuHWxkEgOd+gM4OEJGzYXh0eSl4mwDolPxnwLMxYIcDwlcEAe2Eze6D8xgw/YDP1wAe/glZFYPk1//QlSR4KxRSOv/QQQVsHXwGSNjArELp3EPLR/TOPfoAAEbnn4GBAbaaQl4vmgF06wEoP395f4cBNGAKurIPtIIKFJagW1VAcQJa+g+6beDZjfUMcjqRDJDwIyf+GRkw/QIXYYAMZ8DyIwN6iYJHL8OQAHTt/A+CTu1o559hmILRzv9QjdjRAQCGkQYYGUYBESEw2vlHDSQ6dP5hFhJeBQBNw4wM4FleUMcVtCwedKAXaPkw5PC+r+A7/nmBd/KDZptZgMt9IdeIfWEQkjFj0LKrZQB12JHvgYbYD2ymABtLoA78y7u7wUvemYGn+oMGGXSd28D3sINmzEG3AoDUa9pUMoAOHQTdWw65ngzWUIU25Emc8WAkcq85JARgFe9/BvB956CZUuCsJxuXCMQUoCLQoWEymkHgA/5AfgCdfQBqeIIGRUCznPfPzQZfCwia7QOJgQ4JBK18AF2VCGrwQw7lY2AA3bfOA1xV8OzGRgbQbQi8wqrgDjLoyjbQsn7QwAOukgW1E8LAALm+kZcBtNLg89sbDKDDFHlF1MGd9R+fn4HDGOu+akQCwczA0M41aOWCgcdEhs/vbjGABj1AM6XgwRigPOg8A1CHHnTdnKCEAQPoUDNWDj4GyNVw/xHnBAA7fKDZYdCSb9AKD9Cya1CnEnxbBMhmcJ8E1bdYBwOQ3Utm/iF+AADmMETQkDsIQHrHhPoNQNh+fHgQAlO0tIY/A+gsCtBsP2hmHnR4JPgwTuDsNOhwOhZ2Pobjq4IYdJxawNdWgm8BAG6FAV0lqO3YCO74g66vBG0HAJ0rALoSDrRKBzaQBstTEP9D/ATu3oNWDIFWKQBXqqDsmKRapwot/IgYMISVMrCBEXA4MUIHEeFpjZEBLg8UYwKelQBTh9DPxCALvIkA1Mn/+e0tA2wVE8ifoMEO0KocEBt0AKqMdgg4j5xaF8MgqebLACpzeQSVwNeQMhBTzmHNA6iDACD3omAmZgYeAUUG2GGEjCjJnDptGdR8woi9bEESxVlGM2ADo50jUKiMdv4ZhikYTd9DOWJHBwAYRhIY7fwTFdujnX+CjSDicw3paQ7nAAC48QcxD9wIAzV4gQ1E0P580F5V0MwUaIb72c2N4CvvQB1aUAcB1HiF3KX9hwHUIQRdcQdSA9ozzIB8YjojamMUdBgWaJZYzaqYAdT5A3UWZYD7yEH3+YOu7gKtJACtOAB1liGnbv9nADWyLUJXgWcowfd4Aw8BhAwygBrjFJQ1KGkSGgZgMWQ2xHxGaDiBaFBHCtS5BnWGQDN1oNl90N5p0F5/0GoF0IwpaKk7aOn9rx/vwPuewcuwQYMJf38zQIxiAu+b5wUfhvaMARSeoNPJQdsCQIeDga8j+/mRARSWGA14pM4IA1L8QQ5x+woeYLEIXs7wAriNA9RR//n1JQN4ZhZ4sBjeRiO0w88AoxkYwOsmQIfGvQTuCwd13u+dmcEA2uYAGmCALDF/D74JAbSyATQYAprlBC0FB3XwQQchguIJkq6YGPhFtcGrI8D3rItoMoBuUQDtNYftv4b7Bd0djJBOFyPUPQyURDkD4c4IqvHY8xq5AwHEOZ3MBiCsk8uIzc3I+ZABngZBnX/QIBto8Al0GN7X93cZQHkeFI+gDiJo1Q/oxo+PLy8ygDr9oDiF3MDxleHZ7S0MoJsALu+tAqcTZbMsBtAVmJCVLVA7gAcMgm75YACdQ8EAndn/DxvIQwsNbJ10rAMCqOHzn9AydEKDCmjlAHIHnwGW5pDyHChvg7ZFgPI06IpQ0Oz+j89P4dtjQLkGdGAgaBUO6LpB8Gn/f74zgPSBzPsPHPQAnWcCOoTw87vb4PITFMaggTrQairQeQygwxENvSYzPL6ygszUDsktKDP+DBAx0EAcaLUWaOUGqNwG+Rc04Ig4ABGa0+BJhtj6hpGBanmTkXSzRsrS//9D5Yix/6MdWdLzw2iYMQxxMDoAwDBSACPDKCAyBBiHVliRNiNBZiogO0xIC0tGAh0CBqg8fAAA2FDk5JVkUDJKYXgK7PiDluODGrSwBiKXgBwDaHYLNEMoKGkMnu0FLXmH7StmwDPbBuoEgq4b/PTqCniW7PmtreAZMlAnEDSzDuqMgGbBxBQcGb68vckAsZOBAXRNH+gUcpAc6EwCUIiD/cUIiykyK05cjX8GyEoISNgwMkD26AOLdujBgeAlusAlxdz88gyKwHC6e3oq+IYDSTVvBtCBX++B98eDOgawbQuWoasZQPuoQbcAgPb4g9wO6kCAOgliig7gg9l0nFsZQGcLgGbwwYcRYlw9h5zOkNIAyA/AMP8D3dcNknkE7DiA7h0HDbKAZhxB99qjH3BGTKoFhe73z8/Bfvv3+zv43nJQx/APcHsE5PBIBgbQ/m/Q4A0oDkFnJAhI6DGAzk4ADRpAlntDwg80428bsxN4uGQP+KpH0H3r4CsfYWENdhCi4wI+SA0cv4wMrunnGEDxDjo5HqKCxDyAbQsILADw5kPc9hA7CEBax4TEdExi5xbhZYi/QPlayTiV4c3DQ+BtKJBzNt6Du+qgbS2gwaw/v7+CB25A23NA+9NBnV/Qlh3YGQPgfA+8jQOUZkGdWNCVl+D8Cez8q5jlMOi79zKArgsEDRCBVhTBV6Igux2JTdUODgFz4eU8cgefEZrCkE7wh3WkwYNxwAFSBYME8M0ooFs8jL2nMTy8tAQatIzgGX0moBrQlibQ4ODbJ8eBK3vkwWUI+AwRoErQlhlQGQcKD1C+kNEKAZdxIPNAK39AW4xuHetmgJ2XgDev4ku/jBD32ERtAd4GsRJSjgHFQGWPkJQJeIsH+BYTTiEG0IAmJAtC9IDP62ACNWdxDNgQKEAY0cpWDOWMpOVhhsEEBqhz+3/0fHGG4QtGO//DIW6ZGEbBCAgBxtFYJjYEhlhFT5fOP9mphwbpDtqYgTUuQB0C0OnxoBl4UIcANFsF2r8L2zv85f098Kw2aN86aA83eKYLePI3uKPz/z8DMoR78/9/Bkin9y8DaJYbdAgWqDMM6jSATvMHdSC/fXgIboR+enUVvPce1KEF2ws0kQvY0QYtqQedG8AIvaIMdLK+qf88BtBhggw4lvljdQuesId31qANZ/AcOLAjAJrxBzXmwbN4jIyQpfBAO9+/OM9waXcZA+SqtL8MoBPTH15czCCnG8UA2tYAWtoPsu7kumiG++fnMYAGCMCngDNCGtagxjfokEMReVvgjQAJ4EMGQWEOuvUAtPICchYAolOMmNHD4gnoHmfIdoS/4A4z+OYC4HJr8D5rUDxjwzjCA5EPIA0TVg4B4HkHlsCBoVQG0J3poMGZt4+PMoBOVwefMfAPck4D6Oo0IRlzsKkgv4K2JwgCOxugAYOt/bLgcyLA96r//ckAmvEExx8wjEH7pcGdDkbEgIuWfR0D6Jq0Q4vdGGADP8gDVowMCIjNG4z4Ov4gDRSUTf+p3gkgoQEIi0dC5QiKOiwdOaD8lX01wEG4GwygcznAV1d+fwvO39aRmxhAW1ZAg12wzj5o9QZs3zoHrxSDPPB6S9DZFtYRGxhAakCDBPBl8UC33Ts7k+HIUm/wdYHgmz5gS+bpUXsixQ+ujhMucdAKJFCeB10fCPIPbBUOt6AyAx9w9cqlXSXAlRKu4HLg2Mog8BkKoJl1Ruid/6C0ASovQLPsoKv/Pr66DN7XD8qPoMNUQVeFcgkogLfmSKn7M1zeUw6+jhRUFoDy6st7e+A3hiAHFc66CT0dQ8svkHrQ7D6ojAIN5oDY4IMdWbkYQPEGunpVCnj+A+g6V7AcLD8ByydQ3gQNTIC2gIHyMQNReQW1fiJ1EID+de/Q6XQNqc7//9HOLGlF3Gh4MQwTMLoCgGG4g9HOP9ExPIQ6/wQ7C9RM1mSHC+lpj+AKAJi/GCHNL9BBgKAGKmgpL2ip/o3D7QwY+1GBakENVdAd/eC9pMDOHGhvO65GCqxhB7qeDnTqP6hTAVoeCzoNH3SCPWgAgJVDELzNALQS4AvwdGxQ5xjUqAapAy1jB3UOQbNloIEIWa1QBtBS2ZfAAwpBHQ+E+xAV6X9ibgdAiQdI2DICZy5BjWFQh/ffv1/gKwFBS31BHXPIqep/GSB2goLlLwN8fzOw0QOSBzX8QdsY/gCX8IMGMUDBC75THdhBBoUXaCk9qEMM8iNo+wRoYAO0FUBK3Q888AHyI6jxrevSAV0CjKdxAHU/5kwmJFIxkxmO9IMlPSKbCerEg06QB3VmQLO5IH+C0hWoQwg6FBAUHqAZREPPyQxPrq4E+uMEeDAD1HGAnG0gywCaHWbnEmUAifGJaYNvKwDd/ACaYQZdiQg6rBC2bQB0oCA7cFYStNIElL5Ap6iD1OHLgsiDAUTnZYL5kHB+Y6R3GUdu4xrJnZCZbBYG0AATaBULaLsKaEk6bNk/+ODLp6fA+R4k9uv7G/DVnSAatF0FNFAAik9QOgfJP7m6mkHDpoIBdFMAaIAAbBWQ0HFsBh/6CR4IA/JBNwjA8iVRwcZIefgT6jgh0jkTfH8/qNMLOqsCNOjEDe2ogzrAoFs8QIN4/GK6wIFMEYYvwC0ToPQMOiPk+6en4O03DOAJdCbwzQeKwJUCT66tZUA+FwUcJi8vMIBWVr17epIBdIAnl4A8g7plEbhMA597Aj6okcROASNk5h7kTnD6B3bixYDXL4LyEGgbD8hPoIE70HktoPIWlGdBA5egOAEdTggZfPjJAB70BM78g877AOV7cWVX4MDmKWiBAqMYcRUwDOiDsbDBE4QBjKhqYO5mIMZs7CXAf3p2OAegczva+WcYxmC08z+cInd0AGDYZlVGBlwzjQyjADME6N0wpiAO6D7zQHbYMJLsS1IGABhgKZyRAdyxBR0qh964AjsddKo3eD87ZFYRcrDdf7xpgBFqOPiEeiAbdPo1SAjUAAYtKQd1+EHXybFzi4Bnw0CNUlCjFdRJBnXGQZ0V0LJwkDpIR4WTAXTqPWiZO6jDLqnmwwA7VA5fgwkjruFxwQjpAAD56pbFDKAry0DbFUCzeqABC/DVg8gn6YP3NUO9DF35AGrog64Vg21dAHX8VYHLoEHL44WBs+KgMw5AneZvnx5BrhQEDlKA/AXy3/M72xhAgx2gPdagTgBo3zVophwWbhgzcEhpCPsAAHRAAyOtMeKNJ5gkspngAw6/PGcAxx3Qr5B90LwMoA7/y3u7GeSB1yCCOjPPbm4GHgT4gwE0YAOObuBgip5bN8PDCwvB2wfEFB3BM6Gg2WDQKgkB4I0BoDh79+QkA6jTCRpwkdYMZAAthQYNlIDiW926lAHUiQKdM4CyTJmBQkBcD5QoS+g2CEBp5wPJz6ADKEFpzzJsFQNoNQ4ojkEDO6A4+gScsQZ1bMFXcP76DDyZPoIBtPUHNGAHGsQDHf4IWiUEUg86X+IxcNAHtJ0HNIgASqegeAOFCWgp+/sX54BX39UAt7cshcxqg/IQqK8K7GSi30xBXEeHkfyIRw4/aFgwQnrsDKB996D0BRoABHWYPwK3KYFuPADN3oPKHJB/QGejgDrOoCtNQXkWtIIJdC4J6PpEeJ5nhLYTgDToUET44iRQGQEsM55cXwO+BQRkLmiwE3SmCmgwBWQf6PpF0IAatgFNjHyJIxRg+RZ0tSlohQ7IvcKy1uCyEeQP0IorUMceZAcoH4K24oCuZgW5EzTIBrr5BXSWCWhwDlRGv316ggEUT4wIBzBABhmgAiD/Yi1jYO0lCA0ZCIBurQJrRchDthMx0rl5NTQ6XqOdf4ZhDEY7/8MtckcHAIZldmVkGAUkhADj0Akvunf+QcFIVviQF6akDwDA7MFWOSG74T+OVaFY3AlvbMMajQzwJqCScToDqDEKalSDZsxhnV7w7KSgAgOooQ26ax90mNY/4H3mInLWDKB97aABAtDJ46BZLNCMHGifOwPsoDECSRUlzmENdgYG+AAAqMOv49gEXtoPaiSDGtEK+vEMoBlwQ+CJ+E+B13VBGvaQRqx58BLIDQgg+6GDBKDVC6Cl/S+Bh/GB/AKaQQd1jEAn5oPOQIB0Zv8zgJbmfv1wjwG0R/rV/f0MkFPC/4HtxjhPAdbYRks/pA0AgBMgagjhMg+eVhkZ4J0SRkg4gVZygDruoI4PaJbw5f29DJDD3hgZBCQNGTRtqxlA8qDDIUENfNBgyrdPTxi4eKUZQAcWgsL4C/RmAdC+ckiCYGIADaCABnhA5oI6Kk+urgKvDAGtjIC4AZouKSljiNZLXJ7DNwBAtcEBas08QtM7ZBUHE3gVAChsQTdY/P3zE7zVAhRf/OK6DLK6EQyg5eigWeK3j4+Bl/KD8idoZhxEC8taMDy/uQl6y8Q/BpAeUOfRxH8uWB9oEAtkFviAUOCVf6Al8KDwAC2D5+SRAA/0gfIw6XUrarwQFca4wg+cnpkYTPzmgM9CAOVxUNoDXUMKmj3//OYGA2QAgIlBSMqUAbSKBzRY9QN4uCYoTb8FXpkISpcgN4Bu/AANeoA61bCBBdg2IvDgJXBFEXhlE3ArBGgrgYxWMPDmjoMMsPQOu2IV48pOfPkTKfCQyzXQ7QOgQ1lBYQ4auPsLLDuFpc0ZQFt0QOKgeAENSIJm+kFxCRp0BOkHDw4Aw4RHSBV8FSRotRXIj2IKDgygbVqgQyK/vr8P7qyjxAJy2QRkg8wHHfIKKrdBYQM5OPE/eDUEI7QMYYSq0waWtaAVZ+DBZsbRaRZYlI52/hmGKRjt+A/XmB0dABh2McvIMApICAHG0c4/3tAiO3xID1fcDWMcZkHdhjEogtXNCDMw7cFiPrrZ0IY36CAyQSkj+J510Iw/rOMLWhEA2qcKunMcNDjw9d0d8JJi0Gz8//9/GEB7V8H7lN/eAna9/0GCHcssH3p8YBsAAPsBet89qNH87tkp8B3pysD76kF7m0HueAXcm/vz2ysGUAMY3HgFzmKCGrpCwIY1yM2QwwEhqyJAnQLQafigU/FBM32ggYzrh1vA+95BDX5QJwGkBuRH0AGHoEY66DBFUOcDvq2AiLSC6ReYb8mLH5Bu3AMkELNBAxqQqyG/gJfyg1YBwDotzCxsDKCOBWiG0zJsNfCquOUMoO0MoJlj0GwnqHkPjk/gzDLorANw5wrYIQJtswCd/wAKV1AYgJalg64TBG+7AK42wegUgR1KRllDUv6jfAAA4kzal4lEbXlBCjPQUn7QXndlk3QG0LYVUBxCtrb8A8/4ishaga/jBMUPqHMIOo8DtHQctPoDNIAF6jiCOnXwA0KB+c4SeFsH6PaJF7e3gge2QOaBrge9frgVeI2gNHiFi6p5Hvh8DFCeAg/qIK+qwVZw4owvUJgiMEIZlrAmMHgCysPfPtwHb3MA5WPQ4B0o/4MG60BhA9nWALy54+NjBlBYiKu4gw9ChR3yCVutpGKayQBaBQHKH6A99rDOP+icC8iSenYGSFj+Bg+agGbYQZ1v8C0hf76BBxghZR/hDgJ6GY1ZZkMDExgwRt5TwduWnl5fywDyK2g1DchO0DkOoBVHIDYoLYAGcEADQSA26LYC8FaPLy8YQLcGgFbkgM76AMU/O7coAygtgNzKiOWcDcjgBxMDKH9DViBYMYBW94D8/p/hH8xhDKBwUbMsBK8QAm03A50NA1oFAdqGBh7sG2xtif/06bj9H2qH/f0f7dAS30IeDavh3J8aHQAYVrHLyDAKSAiB0c4/4cAiK4zIS4fkDgCA+wkMaHZidTcJnUz0AQBwSAGbOsB79iGzbJCOBywAQR0P0L3koCXioNly0A0AH15eYgCtAgDN0oEaoKBDAB9eWgTRgnOGD3vYwRvMjJBOBOjKM9AsPGhZL6izDrrlQBu4hxl0GjqoswSZKXvJAJrVBC19AN3Xzcknw/D7+3vwjDaoo/oduLQf3FGFLvcFLWW3jdoK7AQvA88cqlrkM4BOxwe5Hba1AqQeNJAB6hzDlhGjJyKMxj1UAe7OPyQGYeaQMkCDEfeMsE4WA3yPNKhxziuqCR6MsY/fwwCaNQRt5QDpBTVeQYengTqM98/NAV9xCBrcAPkP1OFgAx4mCL5Kko0H2LHgZQB1JkArAi7uLGQQlDJmAG3nAK+6AKYLbn45BlCHETQLjboaAuEm8DIUYvIUSA0NOv/g8CJmoIaRgroETwOblM4CcpoHnUNhEbKC4dBid+De80OQ3Ai6nx8cif/BM8UQF/8Hr6sB5QF2HnFwqeCUcoIBlC9AKwNAeREyAw656hE0uwwarAPlIVCeAXXywYdQAs0FdQZBA0PfPz1mgB14B+vw4vUHLO7QaFBHHbwcHSgOWsIPGmRiRCR6BgasHSksDXBg+II6+aBOOyg9cnCLMxj5TGe4e3oaZFsOaMYbEkJgM7+8u8ugYV3GoGScxgBa/g/yH0jfB+ChoMrAQQBQGIBWCnAAz7zQdmgA3/IBuRL0A8N/6GAWaOUD6PyP/9DDO8HhAI1nYpMKI75DMOHlLQP4ClVQGQvLQ6CD//78+sQA6tADC1TwoAAofiWU3SGDEEBfgrYjgQYyQIMC4FU+wPMEQH4C5V1QvIJWXiFXEShuAdoNXmEAvJmEB3hwoqiCPfg6V9DgKWjlx2/wLSKMYDFO4Iqgn8CDJ4WlzcCDwLDbQ1DjkYHKYPB2wkY7/wzDGIx2/hmGORgdABg2EczIMApIDAHGoRFmuDpUNI9vssOHvHCl6gAAKHCwuh/XIACam+ENUiRxqBi8EYwUAaA4Ai2HB3X+QTPBoBlnUCcbPIsE6qgAG8uPLi8jLsqwuBt9AMAqfB0D6JYBUOcTdGUf6Bo9UCMddAr4X+Ahh59fXwcfCAia9WNm5QZfUQiaIQM1cFk5BcD7qMGdIViDHuyy/wyg/f/iwMbza+BVa59fX4Ms90VWAxosgM+KYfEOUrghN7Lxd/7BkQU3jKwVGijxzciAMIMRvEYXch7AP+AVaIsZQPv/wfuEoVELuiYNvP/72RnwygxQBwB0YNp/6LkRoGsmQVs5QJ0E0P3yoGvlQFshQB0n0MnpP76+YABdkwY6DBB0WCJouwEo7GBLrRGhhJaWYB1EmALkDiNJmZv4/MbISBu1hJxLSUcB5GJQJxx0Sj+4kww+dO4vFishDVYp4Pkav358AF8NCoqTm0c6wVfbgTuB8E4rE+QWD2Aa5+KXYZAFXm0H6mCCZvrBs8nAziBoEA9028CL29sYQNfkMQEPqgOdtg86QI/UsheUdkx8ZwEPnARuTQB2MkGDASA+6ApMUJ4FzcqD8ifqyhH8DXDQjSeg9MfJJwUuC0DL/EGdfdC5CKDZeoRZ/4H5fS+4888APUMANLAFGkAArRIC3a8P8o+ySQbw9o854BP3QTPoovJ24IEV0FYZSPyhuwedj1lWEh1OSOkSYcp/0CgeA+j6VtB2A7OgxQygcwr+Q7cugbZhgQc0QTetAFdDgco2TdsqBlD+fHZjI4OcXgzDa+A2JdAgKcRMiHkoe8EYGSEDCmy84NVOoIFV0Mom0AGg34ErKMArHkBnnzCzgL0CGnQFrfZ5emMDePsTaPUQA6FVIUiB8H8YzT7/H73mj2H4gtHOP8MIAKMDAMMikkc7/wykt8gGfcwzEroWjNY+IGsAgLy0iL9jgsdMlIYjmjqSBgBAgYnZgMXecYWoQxgP4v9HWRL7/eMj4MnZvAygmTQGvA0lLH4jYgAAstf8BQNozyvoNHPQIVig677k9eMYQB0A0MADaEYfnESAh3nB9i6DViqAziAAdWRBS/5By6MRjdL/DKCO1ntQRxioBzITiqMh8J9A4x9X2sEQB/kfEQZkz/6jmAtp1MM6O4zQTg8kLKBLehlhZygwMYD2i79/ehrc2XBMOMBw78xMBj3grQagO9FBHb4/v7+AB1CkNQIZDi50AF+byMzMxgAafAHNEINmGEFmgAZ+wLcPgAZggHuxIdmTkQHVy6j+BauBdfzJys+k5TdGRtLVMzJSVr9Qr6PwnwGnS+BuZASvXgFtgQF1cEEdb1DHHzSgA5o9hrkFvJLl8zMGIWlTBtAtIqDBHNDsP2jQjh9468OnN9cYQDdjgDrKsjrh4MMg1YAn34NWEsA71uh5AEc4wdLf89uggzPlGEAdd9Aqkgfn54OXuoMGAEArEP7CltVDEiqExNJhZISmF1An/feP9wygdA5yN2jw8d/v7wygJfOgbTqgLT6g8AINgoDSKGhmHLQKCHQIKuzA0Jd3dzKABhFAHVnQtaCgcBBTdGb4Blz1ABrkAg2IgJbDg8OdEVIagu0HuQspMihNI2iZBMqFWAA6CBDkdtDtDaCyCuQKJuihjHquXcCbCc6ABztBqwJA53aAVgaAb10BHvgJzrt/f2HmLHieA5oGNMsscBEDaMYfNAgEKvdAKyxA4QS6FQS0Ago0yAo6VBG09QS0tQu0nQS8IgF8uCqkLEQdpB3evYch2fn/P9qpJS5VjoYTwwgBowMAQz6iGRlGAYkhwDj4w4yRYRC4kaxwIs/duBuQBMxDcyMjRVsBUFq0kL4ZA6YYA1SMEa3TCdUAlgUv+wfOQjLgaHRg1YucjHH5C0X8PwNodvrhxYUMkNmvavCyVNDsPej6LNAyWlDDH3RC+h/YjCZwKTvoKkPQct77F+YxIM8SwtwK2xaAMXBB0C9ocQVrZCPTsEAChxJm3JI1AIAWD5BD+v6DOwXw2TlGxLVpkPEAyCAB6No0Q68pDC9ub2cAnQfAyikIvC+dH7xk/NGVZQzywFlEUEf/6v46BtCBYoqGSQyg6+VAy4BBs4+gq8pAs62g09hF5e0ZQPuWPwFXXyAOIYR0MBjBd8r/A69MQFmdQFHhTVpeo6STRlS8ULMigqU1PGUQ1jKSETKwA4qrR5eXMoAGaEAdYPAhlsjpF9qZZQcun/8KvB7vC/BgS9CBjqCBM9CBdKBVAKDBMtAMMGhFAWhGGXTzBei8DbzexJNvQR190KAbaJn9vXOzwQNI4sBl7OIqbgzgMwaA23OQ99Tjmy0GxTzIraCrKEGn4YNmuUGHAIKW9D8A3mIB7vwDb7UADTRAbgx4zwDq/IM6zqDtLqCOLWiARFLVi0FC2Q28PQZkJuh2kmfA2W3QCgXQfnvwVZcgDwP99eXtTbAZoNVGoJURkANAEbPqxNRZoI4j9nhDTsuMiO07jIyIPAOPM1EGi5Dl4MGTh5cWM4DyOOg2DvDWHWAYgpblgwZqQNueGJlYGUDXdn4CDsiBDnxExB3IPkZ4Gf8KeCjoV+BWCdDgCfiayc/PwYN+oLCV1ggAL/8H7fkHnSEBSlug7SQiwNsKQNsMIGbi6jSh5lHS8yCZnTEadnZHO/8MwxiMdv4ZRhAYHQAY0pHNyDAKSAwBxsEfZqOdf+Q4HbwDACBXYnTkGWGNSgYGzDEcfI1BNH8SHABgBM+SgRq9AhKG4IGA98/PMygBD0kDdWZBM3mgU9Ll9KIYQCf7gw6yA113BxqYAM3wg67cAt9VD24oAit9aIOR4N5mjOwG9S9yQx3arGaAdvJBs7Cgw7gIpWuiO5mMiIY7ZKoQ0phnhB6KCJph5RfVBh9wBp4xBHaEIKeFI+sD7gEX0wLPloJuSQBdEyep6snw4s52BtBybNAMqCDwdgDwrCpwBlEC2FESAu75hxz4xQA+S0FeLxqsHuQG0MoLUMcLNCsL6miA7AV1tkBhADpFHrQX+R98JhLWwfnPwIBjIAR/qcaILXERLAgpnaVlZIS5G2YV4bKU6M4CKR0WLGU4etp6C7yqERzewBla8AF32JZpA50PutIOtPQeNMgDwqBzPECdX9DJ+eBbIoDuAg2oQQZ08Kx6gQcJWh6HFQLgsGMGrxK6f24uAzunEHh7DWh2GTzDLGUC3EZizwBKX/+RZpURkYpu938G2FYkUEccNGAB8i9oJQro4DoNm0oG0CAfaLDhDXA7D8jMv9BBQFAaBc34g/SDygDQDDuoE61mVQK2H3R6PmRFwVtoTmYE3pigA7zhhJ8B1PFXB6oDbTMCdZhhZSBor7yMdgjDxxcXsaZDbOkA92AtNJ2B8zMzOK2DViyBzyMArqYC3bICOsNDWMaSgY2DnwE0gPPn11cGxAGldxk4+WXBh3uCxN8/O80AuvkDNPABvrWFkQE+qADJE4yQrU5As0GrMEDlCMh/IBp0zgeovASdQQEaAAHdNgA6OBE0cAi6ZhJUnoLOVoAdBMiIFN8MwxCMdv4ZhjEY7fwzjDAwOgAwZCOckWEUkBgCg7zzD2o8DIrOP6RVR2rgkpUcCXdKCKRzXB1lZNdgxDvCTKyzsUjqGfGsAIAEE7L7wC1LuM1wGUY0NVAVeFcBMOLuSEC0Q2fGgMtXQTN/oEY9n4g6w72zs8B3hIMau6AVAK8fHGQA3UDwHTijpWyaAbzq7gT4fnxQwx/UwAXJMRDofKGEESN0XAPkPEaof0GdG/A+XGYG0HVhoM4uI7yRzQS8V70WMoMGPHQQti8e2e/YO5Y44h0tbsADC8AwAC3Jh+zrZ2KAXL34jQF2Dz9oMIBHSIkBdGc4aJk+KEpBWyZAM52gO8fBHfZ/f8HhAtoqAdr7C+rAKwC3U4BWBIAGWUBhBeoYgvb4g+6k5+KXB56XcAO8VFpKzRsc7qBZftC+aVDnCoRBB62BVl+AOgmg/dWgzhEovLkE5BlA7gZfb4aSWsCBysCAdfUPPjnCWY+RimUf3nRLailAyUwl3oGA/9BgRAxuYRYJCDlIaoOsGgHdqw86wwF+uwV4C89/BuxhiCWdIg9QMcAzO5gBmrUH5TdQZxyUnkBbDECDAaC08ur+PgbQNgTI4ZrIjXG0hjl8dQTEbPCAwf//0JtFQNskGBkUDRPBVxu+uLODAbJP/T8DaPUKqDMLOigPlEdBHWnQuQaPryxnAK1MePf0FAPkJpAbDKB8ahuzneHRxcXgcAQf+gkcmADdMgC61QS0qgK08gU0cABKy6DyB1TegMsVeEBD3I2v04hZvkLCE5TfQGdpgPIIaOuGIHCrBigvgQZmQEv8QeHHws4LPhMAZD/4IE7gABsoz4PKARYWTgZQ55+VnQe8xcMUeNUj6FBH0FkCqPkLUoaB617gQCHIrSCzwDcGAOMRtMoHZD5oQAS0wge0QgIUbqBzIHRdO8CDq6DVFyB5sLlg5w/PjtRo559hGIPRzj/DCASjAwBDMtIZGUYBiSHAOLjDbNB0/EHBSlZYkR6+xHVK8JiLw50YYYmhDmEmxgAAWgcTnsqwdOKxdoSw6ceiF2YuITPg6jBmlhjBh1cZ+8wEX9UF2o8KWo4Kutrs9okJkOu7gHdpg/WDDk0DHkT4+uFhBlADHdLp/8tAcDkzA2o4yWgGMXz/8hw8WwbqZIOWwUK6pYzgmwVA+6kh15A9BVsLXnr87Q3w5HwRBtDeXNDMPGj2DOInRvDkPWr4wzq5OPI2etgyQsJAx7mVAXQdmLp1KfgMA1CnCrSkWhC4MgJ0MBozGzf45H+Qf0EzvqDOBahjoW5ZzADZ6/sD3GEC7YEGbxkAOgN08BvIFaBODqjBD+qggc5LYGRmBV8L9+bxEQbQDCios/Dh5UXgtgFe8JkPoAMGQQcvcgIPlgN1pqTUfRlAS6ZBZwnou/UAOyzrgUuS6xhAVwjCl1dj9S4sLAiECQNhwEjVsg8a44wMDBh5h4FEQI1lyoTKAKLzHqQBDIo70P5/fOd2MOIpTxiQyk/U2WBGeHiBVoYYeExgAN0lD9pnrmKWxfD05kYG0AF04H3l0AEHjNDEFl7gLMoIXQjDyABe6fP9DQMofYOvtJMxZ/jy/h6Dll01Ayjtgjvpv74wgG4OAG1JAHXqJIDXBIJmyEFyoLQM7vwCl86DbjQB5R8G8L0KoPBhBKdlUL4HDaSBBst4RTTAW2ZAZxEo6MczgJbPg2bHQasaQHmDUKcR2wAAJHyBfpHQB69iAJU7oIEL2EoO0EGloG04H4CrDUCdfTmdSHBZCDpklY1TmAG07x80IAHK20xAf4Dccvf0VIY3j44gBSksHTOBV/yAygZx4FYILj5ZBpD/QGd5gAZEQAOFoAE+0FYfUHiA4gfkR9Cgy/Nbm8HmgcIRNAAAGpAA+ec/ysGqDKNgoELg/2inlnDQj4bRSM6gowMAQy72Rzv/JEfZIO78gxoMg6rzDwpcksOLvDRJuGNCwFxCjX9YQiGqEwDu0cCTFkrjHUeDn+gBAJQwRfgJZ0cCzT5GHKsQQPo/vDgHvDZrIwPkQLAP4NP9QadYgzoWoHurQQ1g0LJdUAcWNJsFvtcafIo6gYqfERoeSDTo1G3Q8njQjCXILNAMGwPUb6ClsqBZQtAhgqDGNGjWDNQBBw0IgLYmgJbWgpbVI++Nh44AMMC3B+CLbhwDK6DGN2hWHjQz+PHFBbBZoP35oNl4kJ2g2VQQBi2HBs3UwVYgKJmkMYDORfjw/Bx4XzMrcCkx6Eo/kPtB7tF2bAKvIJBQ9QCumjgJ7vSDBg5AHXleEU0G0F5gsF+Ay5RBqw9AV4WxAM9X+P39HbijBdp7DZqN/Aw9DBCk9+HFRWC77pyazAAaiICFBSONyyfKzEcaiIBusQCfoQBcdQFJl7B0RGIZQHTj/D9apw1L6U+oHCCY/5Hczoi2/oKUvI9W3jAyIJcpsAEARnD6AF0n9/vHO+DBc2/BnVfQgBVo3z7y8n+I1VD/4wsvRuiSduAqHFD+BM34g0/IB15f9/ndbfCyfVCZADoYD5R3WTn4GEA3HIBWAoDSLShvfABuHwJ1sEFbZUDpBVR+gJbYg1a/wPb6g28Y+fMDnMdAhwyCOtagdA2yExRqoC1GoO0uoGD4DDxEETyTTkRljVLWMkCu2wOdqQEaLASdW6BolAxezQAatBCWtWQAnU0AMRayDQK0NQB0E4ewnDUDeCYeWL6B9LKC8uPPT+AOPnjwgAF6iCQ4STOCwx1UBnHwSjKATvcHbaEAdfJBA6SgMkwTOGgCOg8CtHrnybXVDILSJuDzBEDlKshO0LkrPMKqDKBtBaABEFBZJwwccAENIIBXcTAOUOOSBh3f/6Mn/jMMPzDa+WcY4WB0AGBIJQBGhlFAYggM8s7/oItPssKL9HRJXKeEXgMAjJAD4xigDWlgRwfSOcUWOxA3MeLqVGDrqDKADYYahvAToQEEsDasnX+oDNAoLbsa8AFeoBk/0MwTqCMsqx0GnHUXYwDPMj46zADa1wze6wzcA4x1uT8ON4MHp4BhATpoEHQiOGh5Mitw2S3ohHVWdn4GUKMXNMsICivQgVugvbigmTOQ60Cz3uDG8bfXDAbuvQygrQgmvjPBM/Tga7mAdgoB9z2DDtICmQvaxgCeOWOEdprQaXjoQcMPyc2gVQ2gTgioU8PGJcIA6qSDTu0G+RnkXtCVjKCwhqx++A+KZAbQMmZQJx60PB90aCBoEAHSqQdaBGxAf35zE3jI2HfI4WjAzi4f8GR4Ng5B4DVuJ4D7pM8wyOlEgBQygO5yB61sAO2bBnWIYCkGNDsK6gTwS+gxgNwCWp0BmTX9wwA6TIwBbZaQVoMAjGTnZ3AvCZEBgObwCquDV3OA4gk0Uwq+4eL/fwaEFdSqn4hpmKLZhcWfjHjyDsxjiPBBMg+UBAnoxZn/oXkds/PPxMAAHRAA6QUdzglKb6A0ApuV/we9LhQkD1ruDspjoPMJ4GkKSycMZg+oQw6ecf/3m0HVPI8BNGMOulkANBgAWhHz88sL8OoA0PYTkFrQifbcAorglTvgg+yA+RykDjSIBer8gg6/fAk6GA+4egCUVkErBEAdX4jZp8FX4IHUyQCvTwR10kHnZ4A6/zePdoA763+Be/LBnUasqxYw0wkjPGyYGDRsyhlA+Q+0koCTR5Lh3JYMoNv1wecmgPwFGnQAhYk49K7/H19eglc8gTr/oME48BkHwI4/qEMPCmcJZVfglYCg8zp2gvMsuFwD2gcaJATlY9DBf+zcYgygFT5cwLMDQHkaNJsPGjQFrSwCnQXCJaDAADp3AKQGdEUgKK+D8jioXAMNGoLCRh94IwEoj4BWGoDz/39sV1Uir5xhIAAGRwdtdOk/wzAEo51/hlHAMDoAMGQSAeNociU1BBgHZ5jBGiCDMkJJDjPSwhjSuCVGD3mdf1CYMjLg6hygikMa8YzgDqGInC340DhQbwbUyAXNJkOWyIP0IDDC/cji0JjE1fkHOwpmN8IN+AYAMNIIRrxAZhRf3tvDAG9oA40GzdKBZvTA130BtwCADvgC7Ut/8/goA2JZM6zyx94IgHX8QQ1k0H53s8DFwFUGmxhso7YwgO4tBzWw1a3LoTNx/xlAe+hBnWwloxQG0LJckBtAS5FBnQDQ1VyglQKgWbW3j48zgGbcQYMQoM4/aJb83tkZDOCDyh4dhQYi7oYJZocOMosHGpwAda4gHX9DBtBMHLhT/vEheBYf1DECzbiClliDOgmgcAcfnAbqhAM7KKBr4OAzhMC73sUU7BkgS7EZwGEGmg0FzeqBrpMDuZkduMwYtF8btD0AtGQctB8YZCZotQW4cwJeYQE88R84IwvaYw26ThBkH2jGF7QsGbzc+u0tDP9SexCANPOwpGcGRLoGhT1ooAa0XFxQwgB8qJqMdig4XUCSN1L6JpB18Z85QUrDFFc+R5SsjBhbZ8CuZUB4DTNfwkY08OllJDAACOnQMoFnmUH75cFnY3x/C3UNIwNiNQwjA6iTKqMVzAAahJIAHkQJumYOlGdBW1pA982DwgtfJwyUrtXM88HbSrTs6xieXFkJ3m4Ashc0SKdhXQY83+I+OE3/+fkZPEsOmTV/xfDx9RXwgZaglSugWXPQuRig/APqCL+4s5MB1JEFzbqDtgaArhgErVQAdZjBYQRM5yC5++fnMjAzszPcBeZlkF7QjDihc0UY0MozRqTVEu+enGBQsyxkAOUr0Gn+hp6TwdEF6pSDVwXwSoNP6OcRUgHfngAakBKVtwX7S0DSCJznZXXCGEBL+Ln55RhAAyGg/AvqvMP36UNvBQF13kHXe358eRk8kw/ZovQfvIUCvHoHeDYI6EBJUDiABk1uHutmAHXyQWELWvX06v5+oNofDKByAHRmxPPbW8ADfOBtVvABG0IZgmHQgtHOP8MwBKOdf4ZRAA6B0QGAIZEQGEeTK6khMIg7/4M2MunQ+Sfe7wTSPB63EjMAgGjAQzqRoCXgYgoO4Mb4a+BhXKAT9CHLxWGrAhihS0aZGECNP/BSXZgbQDS+zj/I04yoHQ1sHQjwKfagmSkGQh0biDyKGYwMEF1AGjQLrmSUyvDy7m6GP8BlwKBTsEEdA1CnHDTDB5qpx4gHLH4BuQd0aBnoKjXQjBfoNgHwTBnwmrvHV1cygPawgxrMoKXzoDu0QYMNoI63HPDqPJC+64eaGUAnhp/dnMoAOrhLADgbDlpSDJr1FJKxAB+6BzpY6/XDAwygxjVoNh52MB4jAyaEu5kR0lkF+x/YkAfdaQ7q/IP8Bjo4DLSMGTQLB9qSAFoNAVpaDZrdBM0qwpfdM0ADDDxDCWoQgTAjA+xAMWFZCwbQSgWQWaDVCSC7QasMQAMaoH3RoE4HSA7Umf8C7MyDwooLuO8ftOKAmZUbcpgb8FAyUDiABkTAqwOAdpkGzAPPNIL2Mf/HcjI9NQYBiB9kAydMBgYGPHkNmi7AsQE8JA1Eg8LlC/DKtPvn5zGATsqHzchC3E5u45JcffjzCiPWmXxGpKSEmi8ZkPIqcQMAmPbDOv+u6ecYHgC3fYDS+BfgVYOgMgO0egZ8eB7EIgbQUnfQEnTwSfxAMdDgnQiwMwta5v4ZeO0eqOPKgJ5O0GbVQea+fnAAfIAfaAk76F5/UKcclF5BS/9f3tsLLLM4wNfmgdI/aGb8zqkpDKC99aCOOsge0AAVKO/J6UYxgPKLpl0Vg7C0GcPzW1vAAwegPAsaqABvgQEuewdtAQJtcQENCIA60SD3g8oaSDr/Bw3f/7jTFs4BAFB4/mcAde5Bq4hA52iABiJBgw6QwwYFGUD5EeRHULkEkvvz8yMDaHUNaCUPKHyfAc9TePP4GIMk8HBO0EqKN48OMXDwSjHAV/jAhmFA1yQCB+lAK3tAKwtAjtZz62IAlf9gDwBn8EGH/v36+poBfBYC0M1iCo4MoLz79/cXcNiAV14BV26ABlZAYQ/aUvHv3y8GhmGw/3y0888wDMFo559hFMBDYHQAYNAnhtHOP8lRNAg7/4zYOnaDKe0Nk84/uP1OSqOfEXJwFqhBCVraCZrt/frhIXgZOeQALIiJDNBtAaCTuzm4RcFLTsHdUEY8HVVY/KKELSMDRuefETK4IA2cBfz6/j4DYik8AwMDml7kzhryIAbYlUC1oNku0CFVoE4aCysng5iyC3gmDNRQBzVMQTPXDNiuRGNAtwvqeKAnlYB7cF8BVxpATtX/zwCaiQN1ukFL6kGHboE6GqCwEJA0gFy9B2wQg1YOPLm2hgGEHZOOgA/gev/0NPjwMdAs/PePj8AW/PrxgQHUaAZ11EEzf+BVF4SKPKA/QTP6oOXRoAPVQHEC6jCAlx0DG+0/v70FL/FnBG9fkGIAqQNd2fUfuiSXEc2vsIYuaCaVCzxjKAj2I2g7BcgfoGXAoE4T6FBD0OoHUCfp9YP94G0joIMAQYcfgjpsoAEM0AwoaMkwaAUJyBrQagHQAWKm/vMZHgBnSp/f2srw58838PWD4JlSbMu6KSi/iB9AAKdeBrwAqfMPS4fgw93+/gRv/+AWkAOHLajD+h14wwMoXXALKoG3RcCyICP64AJNOkZICQZbxxIjH5I7AICuDy2hooXXI+Ad9aAtLqAVKqD8CFmd8wo8Yyyl5gvcd+4IynQMoO0joPQLuooSNMAEuqMflE9BaRyx3x3qCTzhB+qUgwblQIMGoP3yIHNBukBL/jVtqxhA14OC+KC0DN7SAzyv4hNwMA8Up6CVLaB88vHlJXCcvgTeHvD42ioGWJ4BqQflU9Cy/BuH28AddJA+8Hkjf39DyiyQ23CVLWDnE4gnWPgBaZA7QFpAy/FBW3vA5Q8wX4MP4gRuyQGVcaBBQ+QrGkHbHUDnHIDCEdQBB+XXV/f3MIBW94Bn86HbVRih5S0o3/KKasIPUbWP282wa5oO+HwE0PkhIDMg13f+ZgDVC1zAlQcfX18Fb38AHX4IOuATFJbvn59hAJWpIHtBKwUIrdiAFD+ECjmGAQWjnX+GYQhGO/8MowAlBEYHAAZ1gmAcTa6khgDj4AszRoYhEI8khxvxfmKkptlEmIVr1g8xMwrt/DBCOu+gji2okwaaJX737Ax4eSmoUwkSB6sAqhOWNgevAAB1CE385zE8vrwMfLgUaGYd1LFGLBlHS7Ao7oV1/qH2Iy17Bc1UgZbSM7NxAffM94E7UT8+P4UaBlOPMBu98w+WASoDzUiBGuWgfeagg7FAs96ghru4ohMDaGAD1GhlYmFnwOleuBWMMCMZQNsHYLPVCgbx4EEJ8HV6oIvHgLPc4IPHfn8FL70FLR0GLakHzd4JA2f5ReTtGCSBd+iDZhJBcqDZRfDsGDBcQAMIoEOzQHvk752bzQC5/gzmZRzpixESFv/+fGfQAHZqIHtx/4DtBg0egJY8gw43A3UgQLNyH19dYfjxCRKOjMws4FPKX97dyQDq6MP2ZMP244PsB82EKhmnMIA6DKCOlLHPDAbQMmTQ8l7QzC3I/a+By35BHX0hKVMGUIfo+e2t4DBhZeNlAHWUnt3cDF5CDDJXFnhWAMiNoCsFb5+YyKDj1Aw+2fwtcJnzfzxLhEmbxUesUiFcXGKmJax60DqzoLACuQk0W62gHwsOv6/ALRb8oloMoPQGmnkFzZaCOo7gq9tIOjSM0oYpgY4lA3qagqZttLwJSfCMSDkAymZEDTNGND54cAQtvECDT6DBMSk1H+D+dV3wjRGgU/hB4QTr3IIG+0B780H78kGrSUCDjKDVRaBO5bePDxggK3X+M8DTCbzzjyO8gG4AzY6D7sOHXEv3HzwTDWKD8h9okBO0EkFaK4gBtCoIlL6ZWTkYwINwwMEA0NJ2UJkHutMfVD6AOv/gfA/s1IPiGJQ3QPkVZAfI7aABL1A+AnW8QVsKQKsL/qMNUDBiC2NQCKOV44woZSEjgzTwxhHQQYag6/9AN3KAymfQ6giQnSD/gFYtfHhxHmjSPwZ4hxt+rgbE36DtDZCzUf4zwG73YICVaoygwwZZGUD+Aa2U+g+ctQetaFEHbpcALecHnSsAGhSBXLH4D3xWwjfgIBconv78+gTeegC6NQS0cgC8nQh0fgPDfzwz/4wMdAH/R2gn7/9o5xZ3+hoNG4ZRgDUERgcABm3CYBxNsqSGAOPgCrNBP+sPC1+Sw424cCa1EwNxDh6ziXAnI9bl85CTpUENdUbo3k9wexPa6AQtLQU1xEF7vEF7YWGNaJh7hIAnO4P2PwuI6zKAToMGNYZBV8OBlpmDGqSgmVxQIxpsNciNyBiehiGdf9AMMqhRCeoMgK/bYoDM/stohYJnBEGNW9CVYKAZLtA+YWyhga9RDe3aMID2sfOL6wEPrTsG7liD9p6DZiFBDVZ45x+90YSlsQ62C6YOSINOCwfNLAoAr9gD730Huh/UAQCFK+jUcNCqCdBS4Sv7asCNeNAyYlBnFzRjBuqAgJYqg5bXKxgkMoAO7Hp+exsDuEOEbeYQPSyROl7ge8iBHVDQLD2o4w8avAGtSgAdXgbyI6jjAmr8gzo1oIEQ0OwrqNMuIK4P3uYB6mQpGSYzgDq0oM4+7M530CAAaFsDaGYUNPN498wMBvgAAQP01HHgSgLQ4AYorn7/+gycwb3PAJphBelTMkkHDw7BTnMHHRwGGoC4fXIiA8iOl3d3QTp2GA1W7OkelocYsaR9fHKYRSdqJxZv0YrUmYXM7j8FbuUoBq8kAXX05PSiGR5dXs6gZlEIvroOlKZBYQ46jwKUTyDbLP4zYOylx2optRqn2AcBMAcDiev8g5yK6JQi9IDjAViGgAYIwTdqIIUV3C6gPOgAOTWLfOBy8dvgQyNB6RVUxrx/fhYcCqCtIS/v7mAArZgApVNB4IGYoMM6QVtlJFTcwLP1oAEyUNoD206g8w9KW//hhwgiBzTE7aD0D0qzoC06T66uAu+XFweuDgKXYcBBPNBhnqByD9TBBc2Yg8o30MAhA1LeBw1ECACv5nvz8BADbLYb5E+zwIUMoBsu/uPohGEtr5DSMyLcEHEIOpgQFEagGX9QXgalMdC2IdA2LdDefvDtHng7fcidcaQ0Bi1TQHaC8i5opQT4cE7gKgZQWIMGgEFlGDi3AFcagFaFgQYCxIFXJYIGHEBhACrzeYVUGUADFKDrUB0TDzPcOtEPXy1B7Ow5I8n1LgNdwP/RE/8Zhg8Y7fwzjAKcITA6ADAoEwfjaJIlNQQGUWU6ZDr+4FYuqWmNsHryOv6QJjfOaCcyfhmxLP8HX1UFPOUZ1OE09JzE8AK4vBVkD2jfv3v2VQbQflhQZ4WLT4bh188PDKBGJmg2DrSkFiQOOm0a1EkENfYMPCYygDpxoIa0ilkuA+iwrsdXV0A7idhcD+l4wToOoMPAQB1L0NJSUIMZtAcYJAfqyIIalOA948C75kFL9mGz7pA2K2QAAdFohJgLtxGpIwIKAtBs9Wfg8t7/0IPuwPvYgQdagRq5oI4LzliEhzOi0wObKQeFLeQawf8MsNUJoLAF7dMFdSDAy8OB14SBOjugAQJQhxg0ywhyB2iPMGQZPvAU/A8PwAduwU7LRszO/WfA3yhGuAnUwYbcC/6XAbTsVlTREXiI2k0G0Iw/6Doy0MF/oPiEDXaAOgyicjYM74GzhqDlvKA7+UGnnINmEkErBf4jndgNmkEFqQfdAQ4a7IFkE2bI0mDgTQqg09pBs7Mgs0HhDIpH0JJt0LaGx1dWMMCvcvsP64T8Y/iP3IHD2XHBn7eQO/zEdx7Q0gmhchUlHTEygLY/8AirgM9yeHlvNwPI76ABG9DWi5/A++aFgCtjQIfWgTqYoOXq/4GdSQYGtA4XA3j9AMRmIvMxcmeSOL8ihR2yH2D+RUrXEPOg4QK/8QM17JE786Cl4uCVJsC8BFqpA7rxAjRwJK7kwgDa942ik5ERvFIIdCAkaOUMKM2BOpR3gXvuQUvxRYEHTIJmz0FpHjR7zga8fhJ02j9IDXj7iJQxeHWOtmMDcMvIPAbTgPkMT6+tZWDA0SnD7HT/R1EL8jZoawaorAN15kHnVYDSP2hwASQOnukHDhyABkFB9+mzckK2v4AHxYA3CqB2Bv8zgAYAIYMCEHtAg58PLy7E4j608EQrVzAGh1DSBSMDA3SwDRR9oEEJfjFdcBn77OYmyIw/qCxDChPIYA0DJOyB5Sc8vBgRNQK0JGZADOwwgAfjkPM+fMCDAXKOgTJwQA+0auLtk2MMwFEPBtA2I9ANGKCVP5/f3mAArfIA2QVapfAf7/YHhiEBRpf+MwwjMNr5ZxgFeENgdABg0CUQxtEkS2oIMA6eMGNkGGLxR1LYEfYb+bMaeMwm0o2MOGb/QW4CLVPXsKlgeAw8IRt0WBRo9hbUAAftvX335CQD+KA24L3coIYp6FA7UKf2N3AwAHSCPaiRC2oggxruoNOmQZ2+t8BT60EdItByb3iHD5xuoR0LBhjNgOjUAv0BHmQAngauaJjEIKniCe5ggWbVQIeqichaMYCWUYP2yoP3oIIaufBgATJAnRW4HUiZBFuHB2j/f3CHBTkz/cc47w17mIH0QCyGxye4IQ1xA6wjCgor0FV/oAYxeCYe2IkGzRCD9t6CrtkDNZZBS4pBh+OxAA/GA20BEAIeLAaaLQatSADNIoLCGjQIgujgwBotyOkBEZZgl8HTw38G2BLdz9BT9UEdLmmNAIbXDw8zgJbkgwZtQDN3oMPCQJ0sUDwbek1huLS7FLz3F5QuULZDgPwJwsADwsD3nENXifAIKYFnTcFXgP14D7UXEp6gzh4DdKAFPGMLnDkEpS3QdgTUjhuiQQZvaGOkbWqUH8hpkMjCFOQOJLfAO0nANAfaxw6a3QcNToE6QaDVE6DwBHX2QR1F0JkLoMErUOdJBri8HHQTBMTfUL9gTZ+Y7vpPxDJe3OULUrhhs48REiag2VyQf0ADU0zALSGgVSmgQ+wgsowMMMgADQ/QABeoswdKSxLKbgyfgPfbg667A60AAG0lgZzXwcDAAA8/RnB+B80Sg9ICaCUJrKwBbYsBzaqD7qcHXaEIskvZNIsBdu886EBF0KDY20dHwNdNgvIOqGMJmqmGhBZqgx41vHA39kHxBNrfr2ZRwABatg5aCQRyG/g6SgbINY4gf4C2B4HKHtBgAWj1ESieGTDiBLkMgQwCwEMeT1pGHbiEhBcjlsFa2FYT5NQBuq4QNKgIPqsAeGgf5IrN3wzInXzwAC7wCj/QdYR/gIN0oG1HIH+CygfQagbQMn3Ikn5k9zOilM0IO/+DB+xA8QIqRyCDtf/AB4TyAGf+QR1/0K0IoK1GoPgBHYwIG7xlwDt7jpm3ya8vGagORjv/DMMIjHb+GUYBwRAYHQAYVImEcTTJkhoCjIMjzOANx6EUgySHHe6whncKyfI/njgkwY34GpSgK8tAjW/QLDSoYQ1a1g/qyOs4tTDcPzeXwcR3FvhUelBjHbQkFyQHnqkH7o0FNUBBAwKgmSBQQ/Tt05Pg2SgNm0rgDOAVBtASeAYG7LPXyLONoE4TqBHrmn4e2AEtZwAtBwYNRoAbqsBZOFCjGzQYAeoc/IfOcIE6IKAO9S/gbCtoJgzUWUYcEsgIX2YNCna4/+FhBglXbI1v5GjCFW5gM6EdJ1CHFnTCPqjjJAacbVcxzWYAzXqD/A5qXLNzi4APBgM1hGGH2zGxcDCAZuJBp3GDVl0ws3EzgA7F+/DyAgPoei5Qhwq01BfUWAftuYWdtg/OS4heBUqKQvELIyN01wUzeFn/f/ABgK8Z3gKvPAQ13kGz96DZanFgxw10ijhoQIKdR4wBFMbg6/uAZyx8//iY4T9s7zDQTtBNCX+AJ3yDOoaPgOc8gDp7oK0FoBsGQA4BnfoPigfwoAEjZMYRJAc6fBF0dRkonSgbpzFc3V8LmR1EnxX8T0zDDNIdZSBpMJEMPbBOK1oeQ6QjJuAglQcDqLMDGsxQAXZWQXEESgOSqt4MoJUdoKXZ3788g9zDDrx7/ePLiwywgSf0uILM+iL7H2lA5D/xDVbsnSakMoQRUhozQBIwNI9AOnugGXyQfkFJYwZQegZ17izDVoPPeWDACA9G8IwyyM+grSOgmy5AA3ig9Ata7QE7swLZn8gDZqCrOPVcOhjePz3FABogA4UZaBsR5Hq9P+DOJ2jLyr2zsxlAg4Cg7SKKwKs0QWUC6AYNUCcdVragF6vEdv5h+pSMUxmuH25lAJUj8PQOCSCokv/gawhBK2LAqwSAs/+Qzj96vKCGM8x8fGUIohyBlFKgcGZEXnnBiJp20dMNKO1x8kqC0yFoAA+08ge2sgkex0AGaCUPaBUK6JwF0CotULyB0ido4AVyeGc0cBvLSaiTGRmwlotgt0AGNmDhBHIrKM+DBv9AqzjAq7OA5TVoEBN0xgNoUBk8OMbwj2EU0DEE/o92crGH9mi4jOZD4kJgdABg0KQUxtE0S2oIMA58mA3Jjj8onEkOO9xhzUh2PMAaflgiHtYYJzJNMGKd/Qd7FNzQAy1BZ+cUAl8FBW5EAvdug5Z4v30EuR8fNJsH2i8uqe7D8OHZWfDeXFAHB7QVAHQ6PaiTC5qhAw0egDq4IDNAs4CgQYBn19czQDrsiMPYQGECPoUeuK0A1DgEzyQKKjKATpB/dGkJA+jgL5AaUCMTtAoBdPo36OArUKcC1Nn4/O4WA4gGDUiA9gaDOh4gOfC+YNBgA1K4YKRBnAMAkPBgQIt/RrwzceBeLgPo+j/QzBuokQ0KE1AnG3RVImxvPWjGH3zqOLBRBjpkUAK4ugE0swpqhINm/EGrL0B7j0EdRFDHFjS7CDo8EbSyQljWmgF0fR7owLwPz88xgLZXgA4ShCQBWMcNucEO9Qeoowe8t58XuEQdtKwZNPMPmp0D+Qc8wAM8IwDUiQJ1rkBioAMWQWcFgDpdr4Cn+IPCHNQxQ561A3XkQR1D0MABKD2A4xG4pBg0CACaRYUd+oecG0DxomlbyfDr22vwXugX93YxgDoLoIPFQGc9/EdbroyRpPHmH+TOET421FRYviGGxpbt0NICqEMFvmZRWI3hMXDvOGjgA7SN5QNwLztoOwhozz9oYACURxQMEsAz1/D0BOzk8YloMJgFLQYuY1/DABnwucOAPqv8n8yGPGq5A40RRkbEEm9GRHgxQtMK6BBP0LYFPuDp76CD8UB5GXQAJcRNjKi5CnReCGg1B/D0d9Bed9DqB2E5K/D2FdBAD2ggBHTjwy/wipB/SCEHGTgAnYUB2q8OGogC5Z2PwIEvEB98TRzQJlC+B9kP6uSD0r2MVgjD378/GEADARA9f9HCClsZjNbYxxqW/8HnEEDSOe7Owe+fnxngnf7/kE4wpKhAtxcR1gyoIcaAXrZgzOgDwxS0Ggg0EAMqP9HLbWydcpBtoM42yP2gFVngbUjgMhDdHSD+f/ANIKABPNAWJNBqBtD2AWEZMwbQNaag8hRybSXIf7D0wQAeJAK5BVSegc64AKmD3XoC8hO4/AN28EFns4C2fcC2UoEGhcFsotMwI5bsjy1eGUgHFHSIR/f9MwwDMNrxZxgFJIXA6ADAoEgwjKPJltQQGCSd/yEZcVTq/EMa1eSkXaSGF3oAktHxZ8TT+QcZD2tUgg57At3JDZrhBV3lB5opAp3qbuI3hwFyndNZ4AzRaXAHFDTjBGooglYNgBp9DNAl9aCGIahDB1ouC1r+CerUgva/I5yA3OlgYpACLke3jd4GPmcApA82mywPPEgNZDfIbSAxdatShtvAg6RYgLcAfHx1lQG0bBdkF+iOaqvwteAZbtBsOahRCmqkQmZZGTHniFHiFhI3uDpKsKDHHn6M4CWvoJlD0JJuLj5pBtBsKaijDvIvaFYftNz/J3A7A6jzDW56gxugwP3uwNkxUEcZFGagjhOoMwPaO6zn1s0AOvQPbB9wth7U8QHNnn///AQ8wADqdIMGEkCHMTIQPIiKkQE0Kwda3gs6oAsUf6BOAijc+MR1wAd0gWb5QasCPgHDE9TRAu1nB/FBM7KgWU74GQLwhvN/BtDqC1DHThi4HQO0PQA0QMDKwQceRAKtFrlzajIDeOYXGM7wawWBbJDapzfWA687PMwAWrEhpe7HADolXwx4+wIo3lD2GVO70EDq7MM6MaAOFqgzx0jCKgJGjIEgqAgwfDh4JRjAnTCgXaDr10CdMNCAFWg1BegqNlCaeAdaGQOMN9DeeLBa4OoH0MAZaDYWlNdAqz9AK3Co5X1GrGmdiQE0AAXCDNAtMIzQgQBQngPF70Pg9Xyg/fagASyQu0Fx9PX9HaizGMGz/qDl4rLa4QygJd8gCVD+BK0AUAReiQkavHt4YSGDiLwN+Eo4VeBZIKCD8eB7wKGDEP/A52FwgVcLQVa3/AefocAAHcCTA94QAVo98fntbQbQoMDbJ8eBq1eOM5gHLWEAD1AAD8hEWeaOL+CoMRuKUpSjluuYg7zonW8GBka8A4ngkhjc0QYdRghaSQPeDgQc8AOnU1CYMSLKTvgWDJiZGH19aNnGgJAAldegeAet4AJt1wJtqfoN3a4jpuTMAEqnjOD0K80AOuwV7lxofDFA3QBaFQTamgG6ehAUp+DbRX5+ZJBS82aAnPHxjwGx3x+yXYAB/TwCEhM5+YPolOem0aX/w6H5Pdr5H+1EkR4CowMAA55qGEfTLQPJteWAhhkjAyMDKQ3rQRXBjKSmN+zqyWuwwBp4aCGC1IEhNqxwxgHODjAjgyLw1PdX9/cyKAGXaIOW24OW54L2h4Ma3qBODaTT8pcBNMsO6gSKKjiC9/yC3AQ+5R7YKQQtcQd15j6+ugzuCII6CuC9shBFiL3AQHeAZrhAnQDQwXSgve6gFQigGSkh4EFfx1YGMcjqhDOAzhQAzSA+vrKcwSxwMcP9C/PBy+ZBHTjQHlNQ5/r5ne0MoMEC0Ow0qEELmn0EDWCAZrjAjVic4UfGAAA8/BgZQPdeq5rnA2c8X4Dv0ga5FbzUFdixAtkNcgv4zm0GBuhy2v8MkAbzHwbQTDyoww1bLQFaggvaRw4KD3YecfCSaND5AeD9yaArBL+9AZ9/8OreXgbMMxXQUwUjJJyBjW7QIICqeR54CTrIfaB4Ae2xBoXtqwcHwDOaoM4qqPMJvq0BOGABWhEAWcYLnGFFGWiA5ev/DKABIFCYgwYwQGcXgPwFuu4PlDZA97ODwgHU0QCnaOCsJugMApBuUMeNhZ2PAXSQIOhwN9DgDni7AKEOGiMZ9QAs3qHBAy6TwDOswE4nA6JjQqi8wpBHSgOwfA6Kb0ZoPIO2U4AGb0ADKaC4Ah0ICNouA9ruAconoIPRQOL/fn8HX7PGI6jMAJ7tBboNcnvDIwZYh+k/hR1XRiS3wpaWg1aCgLZ7QJbPM8DzJGjwDDT7DD55/89PBtA+fdAqEC4BBQbQIA0sCzNAy/cvwEEB0NYX0EAXaCUEyJ8Pzs+H3qf/DzwgYuDey3BxVwmDS+pphrtnpjMghyWoYwVyA3jGH9mf0IEy0IDJ1/f3GECrA8CDFsCVJqCVL6AtAeCrJaGz8IxInVys5SOOMCTUscNZhyGHKZKFJA0koqQhJlAkMMDiB3RjCij/gM6PAG1pApUJoJVAoPAFxcUfYGcbHBcY/mZkgA3mMEAjCxE2TAygpf6gchyU1kDpC7aKArTS6/mtrQwge0CDfqCBTNggDGQQm5kBdCCiW+ZlhnvAWz9AW5fAg63AMglcnoHKCGCZ9/455NpB5M4/AyGANV8Tm9dH24akpHeGEQtGO/8Mo4CsEBgdABjQhDNawJMc/IwDF2aMQ7njD20wkRbemGGNfdYf1rEnRKPZjtSBYWQgDWL1B0baYETs8wR10l5fA9/nDOrMgO6VBjXyQFfXyWgGMrwGLgkHzeiBZotBy7dBDXfQjDSoI/7x1SUG8EF3wG0D8DufoY34f9BTz9Eb0zC+qIIdA/j0dOBsIKjjBAo/0Kw+SAw0ywy65uo7+J76/wygFQWQpcWPwaeug2eg/kEOuwINEvz4/AzckQLdNQ/aT/wKeCo77viExB3WRjtSWsDoBCA13EGd3ac3NjCABh7kdCPAd96DZrrBB/wB/QM6bAvUcAffZACMPwFJIwbQwAl4dQKQD+o4g8IHFJ7SGv7A++LfgAdNwOcpAGc9QR0ydati8FkCID2ggRjQzDlodv4/7F5tsAfR0hUjwm+gThzoFHrQjC7Ibi27GoZHV5aBT1IHXbsGa6yDDnQEL9UFmgs6tOvTmxsM4E4ocucJaCxoi4Iw8GR70GAQaL8vyH+gu8FBW0R+AjsEoDMcwFe6fX0F0Q90C+gqMSZmdqA/9jCA9paDrnIDDTKBbiMAdfBAZz+A7g6HewVXpBFbtiHlG5hRoHgEDVbIAO9PB500D3I/aDACnLag2RhXDkNxDoobkDpcjIzQQU9G8EoQ0AwuKB7BnTigHKgDCz74ENh5Ay3TBg1cQTphb8Az4KCO1xdgZxcUJ+BtJAzENlrx7EGHOhycxoH5W1ojkAG0yge0qgR0xR0oLxu494Fv7QAptQpfB9zGsBIcb6BBo89vrjOADnAEX++GnN5AfoXuUQd3FoFs0BYc0EoB0AATbG856A590PV36talDCdWhzEgzwKDZ7BBIQYKe1AaY2RAGhyADs6AD478B94uAhrIUrcuZ3h+azMD7GBLRNKH5FJwDEDjnpEBNyB1RhejDEAqHxjgjmBgIGcAADQgBLoCFDQYBop3UD4BDxoBD2AEnx/y6yt4pRFou4S6VQkokBhAAwSg21XAy+sJpkcGBlhYgwbmnt3cCL7FBRRHILtBh6mCVlKBrh4FrQoQU3RmAA00gFcZgeIEuMUDtC3IyGc6w9nNaeCVYKDBVZC3QfkJPMgKOyMEJEjkgBXWMEWJMswYHIhVAENu9v//aGcXNeePhgfDKCA7BEYHAAYs8TCOJltSQ4CRcQBja4jHF8lhh6+Bgt7RJyFaYJ0XqHsgjVomcMcW0pAjs0LD6j+0Dgx0Ty9oRhLUiQbtwT25NhJ8vRuoA/PmwUEG0MngoNlDUKcPdGc9aDYZNOsP2lMOauCDOnZvHx8DN9Lhs5eMsGYyoosFm+36AuzoghqzsPvqmVnYwcuAQafTgzqvoAbxX+Chc6DDpMCn4396DJ61Bi2tBjWUQVjbsQm8txrUAQGdB/D0+lrwoAKiw4EeVwg+ygwpLJqQwh4j5hghcQvTB1rmDeoEgWZOQQ1l0J3+Ok6twMGKreAwAA0IgGb0NazLGEAdru9g94MOw/rPAPLT7RMTGPSBs6Tg+8+Be+FBM+Wg2XeQ2yHXkD1kAK0EAO2rBcULeH82cN846D5uBmydRKR4BjXkQXpBM30/v75mAB2eBlpBAaJBs/ewvcLoB6aBOq2wfej/UZbuMoDTAmhpMmgFw3fogMsnYEcR1HkAdRZhgwCwPeOgGAddEwka7AANDIAGA0BbGkCz/szAQQHQIBOoEwE+gRypk4mzg4CWP1DiByaHJAhLcaD0Bup08wD36kPOiWBgAKUnBtjBZOBoZYTPhjMw4mCjWgifcYUc2sYE4QP1gg6LA3f+wZ1cJgbQNhlQHICuV3x1HzIQAloyD5qNBQ3MgAYiQKshwB0vaCMe9+w/MWUAWhoHukkauO0CtI8eZB/4ej5gfgfNpIPyEGj1zQPg6hrQIXwgd4JWo4AGoMDX+0EH2SBBBCozmBkU9OPBq1TMgatyQIe8gfIv6NBL0OAQyN9sXCIMoCv8vn54yAAqJxiQ8xYjyAwm7LPVQDlBCUPwYBjspgBQRxi0Mgh06CQD+LwImGGIfeqg8gK03QYUD6AyCXQeBbb8gbNDhzLQxYiZ7RnQxNA63gjvwdTBCj0IzYhVP6T8BQ14grbRwFaKgAY7QGeCgA4/BQ0MgMIWNPAGKoNBA0Qgu8ArrMAdb0RdA5/9Z4SkengaZoDYo2KWzQDCoLwPChvQXn7QrQqQg1R1GUCHN4LsBpkPXtHCCC3rgDd+gAeB/kIGW0FXmIIGz5RNMsCHM74ED7RC0yQjA8SnYG9jSadI4caIsYIBPdixxAMjphgDjcBo559hCIPRjj/DKKA4BEYHAAYsETGOJl9SQoBxYMKLcajP+oPCmOSww9cwgTRuQR1lcAMCS6cEs3XJiOh4QCWROy6gPdOqwCuqQDPA4CXl4HYZkfGN035GlM4LaN88aDafhY2XQcuhngHUUQMdCAY68A20fPnc1kzwrDuo8/Dj2yuG1/f3gV0KmokG7fkFnewOWp7LxiUE2Y8P7NijtpFhfmRicMu8yHDv3BwG0F5X0B5fUKcRNPsM6iSBGu6gThFoIAB0LR1orzzoTnlQhxJ8PRfQVtgSVtB94+DOyt2dDCC3gzoKIDNAKxNgHVjUDj6kQQuJckakDghSWEIdjbXBDvcQQi+oowcKO9ASflBjHTSgAdrrru3QwABarg9b3gwaGPgBOg0euJz/P3TJLMidoE49qHEPokEdZFDHDDG7/5/BwGMCA0gdyB7QloG7Z6aB9+8zQPdJM8DSAlo8Q9zPyAC60g104NfrhwcYFAwSwfeyg1ZpgDpUoAPaQLc5QJIcUoMJ1gHFOgv9H7zdAtQ5A7kTtLLg/bPT4CX9oFUEsMMeQe4CdWgYwDPP/gxPrq0Gn9sAWs4NOgwPtN0AtMQbNCsJimc9l3bwNgXQDDUDUh7AWwQyMqJ22BkQs8go5RJSRwZ0EOPv7+/BKzFg17jBohXUEYJgRgZQ2IBWKOC2H5IGYKfmKwCvrQQNPIFm/WFbXkArP8SVXME3O4BWOoDSCagjBVoJABoIAt+iAdyDDT5s8ccH8H55vP5lIKdRC0nboPB4+/g4A8h+0OoEUKcSNDAEciu/qBaDhKonePUPbBk3KBw4eKXAN3gg9u6DApiJAZTWQfEOOkMCdAf/P+DBfKDOP2jwDbRyBDTQwi2owAC6DYQRKS5B+R0U1+AtEsCr6JAHWcDpFdRxBaYX0OAiaKk66LDR/9BVAOCDBKHXfoLNZITGNTgJMDGAVnWA8gfoYFAxJRcG0KGmoENJkQcBMDp0hGZLGVHLWEYiBgHgnXB4IoakRJR4RStHQOeo8ItqM2jaVYPzuiBwpRBo6w9oUBBUpoLOPQGlGUEJA/BNLKAyBXJwKmTVASM03CxCVjCAViSBZuhBA26gzj5oXz+kvGNiAA3Mgjr8oKX+oIGmd8D0ALoNBJQGwLdTAMMXtHrp+5fnDOBwA5oLGpjTBN7mAopfJeMUBtB1rKCBTtAWMZDZDy8sAK9gAcUlaEAPdv4KD/BAV/CBhP//YiZppHBlRB4EYMRWpxFZzzEQAKMz4wwjB4x2/hlGAVVCYHQAYEASEuNo8iUlBBjpH16Mw6HjD2kZkZjWMMMapZMJjAtQhws0Swrayw5eJs/AyIDRUWNkxOj0wxwCawzDZslBy4NBs8L84nrQzh/Y4QgzsfkAZj5W30E7BcDGNmiZPeRO/08MoEafW+YlhnNbMsCzQaDOLGiWEnSqOei6N9BMD+yQPUl1X2hH8BcDaOYdNDgB6oCDZo5AnR1Q5wDcSUVp7DKDl5eCZrZBDV5Qh+Hzu9vglATqDIH8CbpP/g90K4ER8D76u6enMYBOqQbPkAPNguxJlgfvuQddtwc6gA80gwm63xo08wg6LRzRgYb5E9ZZQ9CgjqlTynGG++fnMaB3RBihy5sZsMYRwkzQQATo5HbQfnZQhwU06wk6oVzNIh98mN/XD/cYQCf3g8IENLuqblPOAHIj+FBEaLyA7z4Hni7+CXhmgqCUCQPonnFIp+U/A2iJ/YPzc8F7qcGz1sBGLGjZ7X+kq/MwOiUMkI4RAzSJgGbY3z09DeZ+Ad6cABpIAnUMQDN9oMPnQI10eCcJqZGMv7P0nwGmB3ZTAGi2+j90KTA4yoEEqMMHOkkesoWDEXyQGyhfPL66kgHUAQENJoEGmEDuA3VGQTcnwNwNS7aEyhmYPCN0ph20JQFiBix/MYEPQwRdXwhKu7A7z0GdJNBhl6DBJdB2F3BwAW9MAJ1tAJolBw3YwJbpQzMaAzIN6+jxiWkxgNILaPsJn5g2A2jFh6x2GAPoFgBQmgDlr7dPjjGA8g/onAVp4HYa0F3zoME10Aob0DJuUF4BpwlQ+P9HhC1q1qWkUcvIAMuGoAEY0BYS0Mw+aFk5aDAIdCYBZE/3WwbQyh+QnL5bL3gVDciNGjZlDKDtNpAwYmQA7fm3iljHcOf0VMiBj8B4B6kD5SnQwX2gDj7oFglGiAYG0LYT0AoRUEdT2TQDvDIGtOwclPZBy94h5R0TA2gVDQiDyhnQqiJwXAG30oDsAw3oIYoSRgbQ7QmMwGXysLz+Gbh9CXS2BIgPu1oTdPMCA65BE2I7hIyI8p7QAADGaiJGtM4/SpnMCB+ABA1egNItKNxAQQbq7INWyIAGacAHbQIHh0Cu+PzmJgMk/ZxhQByaycgAuTGABXxmA2hgALb16OWdHQywOAPTwDwCOjcFFD4g/A+84gaWyv4zQE7rh6xOYmSAlSOM4IEhUPzByniQDlB6Bw3iicrZMoDLcKDfQNuYQOdHgAYVQecEgA8RZUAqj5AHUJDKVkZkNXjKXJhL6bEVYHT2n2GIgtHOP8MooFoIjA4A0D0xjXb+SQpyRvqGF+Nw6fiDApnksMPX+WeANGOAnUdQIxTUGQLNCIOXcwO1gWdDGaAdUDwRDGsMw2YiQZ0RPbcehqfAq/S+fbgPPIFflgFyVRO8OYR9cAFvIkI0PvmBJ8KDlrF/+/gAPAN77+xM8HYDUKMbNLMPaoSCruYCHdQHWokA6qyAGo+gGUAWVk4GUOfuB/C+eNCBb6BGua5LJ8PNY90MKEvHQQ1hRsg2BlAHC9QRAnXyQTPAoI4tqFMoqeYDvn8e1AH4Dd4n/YXhyfV18CYjyE7Y3l/QKghQ5wC0dQC8vBg4y/Tx9VUGkBsgS38ZGBBtTeQ4Y2SAdeJADWHQLOzTa2sYQJ1qsAx0CwSo4wZajs2AdgAekqEMsEYoyN3fPj1iAHWkQbNkqsDO/40jHQygjiUoDYDiCtTxAZ3yDjrDALR9AhQ1/6EdPfBhecBOzr//fxhAgxcM8MPpGMB7yUFpCXRYHANUPbZl4SidYOQZNWgaYIR4joGLXx64AuAK8Cq+heAzHVD2mpPU+YcYDHILpJGP2ehiBM/8BzCA4gMUp6AOIviwP0ZIhwW0mgPkd/DSYmD8Qc5GQDIHLW+i+xGjHAKZy8TCAJo9/fHlJQMs/4DiiQN4RzooHkCDFaDTzkGz0OC4/Q86zFCKAbKqhpEB1CkHzT6D3AZaWaJpWwFexYFeTMA7IEA/gmZDQfunQVs8QOkZtAXm5tFucACBZmE/vb4O7liB8omEqgd4hhbUqQOt9gANvIHO1wD5HTSYBOp4M2DtmFLaqIXkAZA//oNvHvgGvlYS1IkDpWnQLC8oHkHLzkHpExRPoG0ioLgD5TlQ5+8bdOsNA7QMewCc+YWUc3/BK3nAY5zA8JdU8wIOqs0FH3YJEgOt5AENioHOHQCtcoGdQQC5leIpAzg9Ax2mBLzfn1dUgwF08wConAFtVwCxQQMKoMEEWHHGK6LGwM0vxwAaVANfCwpMO6C4BZe+QPtB4QrqyIIGt2Dnj2AUhf9JDE9GHIMAjKhlC3z2H1regdIg6DYQ0Kw5ankEiw8gDUxDoPITFP+6zu0MoDNRnt3cBB7oBQ0EfH13l0HZJB18dgOo7IWcx/CXAZKlgbkAuDwflLdAKx9un5zIABqYBZWDRt7TwNsoIAeR/oSUV0B3gTrtoBUbiLIN0sEH2QVaFQTbcgAOM6j/QKtmQPZBVi79ZQDfHABcLSClCjz1H7iyB5wXgf6AnWHBwSPGYBe3G7ziAFTOgwYbQW6CxAOiDIasnmECC2sAB0fBAzb/0coAkBtgGGudxsgw4sH/0U4vtEYaTQujIUDVEBgdAKBrghotzEkKbkZGOsfOMIkfvA0KXEGK3e/osz4g/t+/PxlA+zrZgQ0h0JJI0BJ3TuB996DD1X6Al1fCuqGY3RrwUkoWDvB9+KCGI6jDDJoVBt39Duo4g2aQJVW9wDPgoHvUQTN24CX0DMTGDVLjE6gHNGsJ6kSDOiGgWXTQEnQJoPmg2SZQ4w0848/MxgDaVwuSAzW2QTPVYsAbAJ4CO+igRjYraNuAfT3wmr6JwKW35xhgh/ahNPigaRV8V/+vLwx/gRi27x8UJuDGH1ANaB85SA1oNh3U0OQX12cQkDQAL+kFDUooGCaCG8f8wNnWjy8vgxvG4L3swI4N6owWA+rMPnhWHyIGmm0DdT5B9oJmQRnAwsBr84ADGgbu/eBOMie/LNjPkLuuUcMW0dBnAF+LCFpSDrrjHuQO0NVaoBltUGcTZAeoUyeu5MTwAnhTAaRT9Z3hP/Is7///kMESjA4+aEbuP9JACnIjj4i4hpcN0PgG+hF8FsCXFwygffCgARxwhxPkeXwNSBQ5iBsQgxBQN6HrB1rJDRxsAG0NAM18g254AJ0TABpUAd/rDtwGAbouESQOPoke+RAx5OxHbPkGGrgBzt6DOtxa9nXgqwZBM92g0ANdrQhakaILPJfhDfBsCtCgEfjgMnCcMzGA0jpoufr3j48YhOWswXf5g9KvqnkOcBXMRQbQXmsGeFJiZEDO76COs7iyG/j09NMb4hlAq1pe3t3NADqTAnSbBuQaxX/gMy1AnUFQ5xd0XzroBgbQigTQie6gThuogwW6Wg08m01MYx6fGpxhhux2BvCAFajsAJVAoL3lIHe9fXQUfJAlKH5Bg1G/wdsSvoIPjIRs7fgPzlMgPf+hZycwgtPVGwYDz4ngrQ6gk/5BKyf+Q/enw1aFgFbxQFb2fGMADcCABp9AN2i8eXwEPKQMO1MCNIgIOpsBNKgG2mrAK6wOzDs74B1e0AAFZFvAf/AgACgd//7xDppq/jOAB9qAeQ2yeoMBXgRRNKNL9AAAEwOobAYNmIDKcSk1XwbQwAlopROs3Iclb3A6AqZbDeDBhqA0BooD0JJ6UDkMGugFzeIj7/cHDSxx8sswgK4LhTgH0vkHpSvQCgLQoAlo5RkozYHCDJSuQAMGoLTGzi3CANn3zwheCQJfQQQuGiDlA2gABrTKCjRABjILlF9BgwSM0LoS1skHuR+8/Qd4uCs4HoGrtUBuUARugQEd5glaDQYaQAMN/IDSFKi+ApehwDQLMQqSDsHulrdjAB3+CToYFDTIAxrkZYBubYLXjMAwAq2MAKU/0HYFlPBjoA0YUrP/o51/BgaG0QEQhlFAkxAYHQCgW8JiHE3CxIYAWR1Y8oOXcUTP+oPCjVDnH6qGkRE88whq3IM6f6AGNOg0bVDDGlRJgTpcoE4qeCYbvaEOj1OIXaAGG6gxBeoU6ANP6gYtSQZdtQVqBIEaQ9wCcsAVt6wMkOvV4M0iBgacAwGMcDnkTgyocwTa6wxqeILYoA42+FAyYIcIdDAVqFEmKmfDoApe1r4VPLMHmpUCDRqABjpAs20gvz4Dns4NYn/79ISBAcv+dFAaAnUGZbSCGd49OwU+QAx03gDIuaDD8EAH5IEakKDBBVBHEXSKP+igO9B91LeO94LPJAB13EF74UXl7RlAAxSgRjX4Lvt/mPtM4Q1IoAWgmUdZnTAG0KAF6PBAFdNssP2gWSnQgANoCTioYwFqQIM7pMC4uH9uNgNo1hIU3oyMsEYrI0oHENSahqUM0AweuIMP3NsMarCC9k+Dr0QEug20egIUNqCTt9E7/9hzJVqDBtzIw5IGGXGUmSjiEDWIWWsGBlDHAt75J7FYwFiBgKMBCtqnDEo7oI4e6JYE8GAS8JYAkHWgFRZKwFlN0LYP0FJ55C0NGM5hxFMvwDonwJlf0CwoaJAN1PEApWNWTkHwihbwMnfgYBNoRhhkH2iQC9RpBHcogHFzF7iMHbRCAdSpAXXEQXuvQcvxhaRMGW6fnMyAPFMKG7aDzIID950DOzCgWX+QPzVtqxlAhz2CVvyAOnSg7QWQWxV+g7cggNI26DwLReAAFmgLAOgcjSNLPRk0gPurQYMWD4BbUUArEGBXsCHCAVtaICLSMMINKe0C5UCH/YFm+kGDkqCtNKBVMKCyCTQQAiq3TP3ngW+fAHXeIIfx/Yd0wmHlC9x8YHcJGI6g0+VBWwBAgzqgJf/P4Xf0M4LPBBEHni4vBNziAhoY4QN26kFx9PbREWhZAerMsjCADvgD2QUbdAQNoD68tJgBlN/B1xCCV+iwgAdcZHUjwVtjQGUVKD5BV5iCtluBtt1YhCwH32wA6oCCyibQigsQDQ41LANaiNAkkNYYkJazo+Ux2KDgL+BgBCjtgAY3Ien/IwOovATZAUmujPCl/6BO8KfXVxhAs/WgAzVBZ0aAVpSAynRhaTMGUFiCVhCABkRAZyuA9u/D8gpoRRloBQmocw9aqQHKR6DzAkD1BWgJPmhQALQqClQOgq77BJf+jNA6gBFSOjJA+aCBLF5hVQY5vRiGjy8uMIDCE7Q6BJSnIKtlGBggK2qYgANEiuDzPkB1GKjsBflbyTiV4QXwHBbQ6hXQWQICkobg1VygKwNBZShoYAx01gsknCFuAK0KAA0UgPKsmmUhA+jGCVCeBG9JgjgWfPsByF7Q4BGojvqP7TwBBuqC0c4/wxADo51/hlFAsxAYHQCgS+JiHE3CxIYAI/3CinG4dfzJCjvs4c2ItYENXM4IbKSCGp6gGVBZ7VCG9y/OgxuqwjLmDKAZ6//wfZeMqEv3Yc1rSCuRgQk4owlq/IFmK0FLt8Gzt8AOFKhzAuq8gZbOg2fTf0L27qMmH2hDjwGZRqhAHgCALOv8D270gTo7oMOzQPGuYJQEnm2SUPFkAJ0UDjoPgI2dn0HXuY3hGfDqu//wWdv/4CXOENNRK2PkTjioc8DJJwW+VgzUMfr++TkDaDAA1EgGDSaAO5ZAM0GDDqBGIbhDAVquDFweD1r9AGpcgg4vA81aPrm+hgG0QgA0uwSbDUTyHdqWCCYGkB2gfc7Pbm0CH4oHalCDOqGgg+lAnSDQXnvwMnVBJeDs8SEG0PJvkPmIZavomROaJpAa0qCGqqHXZPDJ8qBZbtCKCciyduCeWnCn4z8D4TvdGRmwJlHsghBHQdMLmIPMhgjAHY6aXv/Dx4kYGahTnqA3nEErQ8CnywNPgweFN2TAARIWoAEe0Ewm6HyJX9C7xPEWfzB/odNQP4L8AOpwqVsWAw8bXAPeIgPqnAhI6DOAOuTKJpkMoJU0oP3KIHtB8QqSA+1XBg0KgDqHkNPP/zGA0sWPry8YwMvOgekPHDroQQSN928fH4P3wIPSDmjGHLRCBzTjy8TCxgA6BPIFaA820AzQICBoUPDV/f0MoEE8UFjI60aBV/G8fngQfPAbaDuKFPBcDVD+g8x2gvISUn4iZ6YPJd0wQpMIE7gzB/L3vz/fGUAdTtCsMWQfOSu4cwqKO9AydNDNAKDVRaC0DQoXUAcRNHgBTjLoHWmgP0F5CbT9AnJH/z9w7QFSC1q5A4of0Gw/ZOn/EwZIuH9mgMwyA8tNaB4BDT5AOoKfwWpAg2egMwtgg3DgLRJAtaDOPnjGGBpHoAEC0AoQUAYCrTwBDUSCVgmB8uS9s7MZUMsJQp0GLHkCGpaMGAMgjIhBQUbIAYng5fTAVVHSGgEMvEKqDODzSxA5kQGW+UB+Am0/AZ2TAVrtALr9ADSgBCrjQQOcoDL/zcPD4Kv3wNsc/kPLEqDzQOUgKExBA5igDjxoEBO0/QK0GgmUfvlE1OHpChxmoDQLdB+oTgENvsA6/6C4fffkOIOx7yyGy3srGPRcOoBnO0xhAK0cALkL5GzQYINT8jFwfILSOSjuQId3gg/JBJprHrSE4c7JSeCzYEBnmYBuCABf1wq8JQQ0oKZolArecgRNgJBBcuAgAWhwFZTvQOe4gAZPQStkQHUaLK65BRQZYGEEuuUBdMggKIzAh8JibM/CU4KMzpIzDE8w2vlnGAU0DQFGhtH1JTROYqOdf6IDmJE+YUWtTsGgKJsoCjPs4Y2t8w9qUDFBZyJBMzegTiuviCb4FG3Q7D2oUwiaiQJ1Op7f2goPGtBsC2zpI0SQkUHDtpIBtMcW1DgD6QHdHw+aBQMdiAe50u0VA6iRDF9NAO6MMxDRwWRgYETvFDAiZoMYoUupGZlZwecAgPaDghrsIHEhaVNwhwXUqYV07v4zgJaKygNnjS7uKmaAdFr+MuCa4QbN3gsCZ1XBd9gDG2+gw8eQByIg9+WzMIA6IrCrqGCBBOpI/oNeQQVqyIPcAwpjUAMY1LhFzCBjbxCAOzfA6wVBHTXQzDAXnyxwqbA7A6ghDooX0OwVaFXAlf21DKD4gQzU/Ib4CXxiPxZzkTsEjJDzDUAHdIFmzR5eXAx2OqgxC+7QQGeucC2dh3eekRqqsAEWuN/gcugDCbgaQahpFzms4YkPKS2g53mUDj1aZw/FH///M+BWywCvPpEHP0Cz9KA76R9dWQHuDMD2av/HOzuLrTSBdWoZGUAHwIE6XqCZS1BnCnSyOmhZNWhlBmiAyTZ6OwNojzJoIA5kH+hEfNCsK6jDLixjCR7UAqkFDT6BOmzgsySg7gHvdWfAHNwCDWqpWRYxgDo7Vw/UgweaQAdm6gAHyW4e7WR4Dey8MULTBiifg5oSoME8kE9AgwAgO0DbZz68vMQA6vyDViuAloGD0x/6tghyOzFo+R00EAGaYQZ1GkHndYDcBPIzaNsDaJUGqMMNWrUBG3AEd8iA5Rqkw/eKAbIl5j88b4DTDdgORvgsMQMjE5wNOZQRKAc0wzHxEMOhxa7giJQCdo5BnVzQqgjQYB/s9giQetBZBFf21TKABlJBgwqQsz+Qwx/ChuVr0LJ70MADyK2gbRyg+Li4swjc6TcLXMQA6jjunmXMwPD/PwnNObSyHyW/MzIgd+LBHgL6GXTjA2hVkoxWKMObh4cYQIddgtiwM1NAh+ghr3YBl7zAe/ZB6Q6EQUv3QSfwg8IEdL4BqFMNUg8q+8BpEClNgFYrgbaZvbi7CzxTDioPQeUm6GwT0JktIH2ggRcQDTIblA5Bq25eA69yBc28gw4uhZelbNzgVSqgK1dBaUAMuFoDtCULlDdA8QKKE5CbQGcygLbWgA62BB3weW5rFmRghQES9wzQ80vUrUoY7pyazAC+FeX9PQbwdhzY4AUosBgZGSArpngYIKtv/oCvyQSVnU+AV7hCCk/gihNgmgEdGAuyG3SwJqi+u3W8D7wCAVIH/UMqFPB0BonMO6Oz/wxDCIx2/hlGAc1DYHQFAM2DeHQAgKggHu38k5YSQeFFUZjhTpfYBgBgSxVBDRPQEkgQDb7jHDjTDZrRATVKQbP5oJkpUIMQvA8deNgdaJYItDT896/PkHYksCEJaoCDll6CzAQJgvaV3wdemwdqfKuY5YBnHcH7TNGWRDIS8C9G5x/aGIM14pmgDS7QTCa4ww1tcIIan6CZQD7gVVWgxjSocwByG+hqrvfPzzGAlniDOvTwfcKwmILFAdRdoGvwQOHyD3qvOKRBzgiejAId3gYy+++fb9BwAIY/I+QEd9B91SB7YLN/kOX0PxHpAdweZwTvTwZ1wkFLYLUdGhlAs5WguADNVIFmMEGNY5D9Eiru4IP/QP4CN4a/v2MAdQhBHQrIPfVPwZ1akB/1XLuBB8HthgycINkD9yJoRhCcVP6D9/uCtm6A4g+0BBfUoQMffMeAY/Yf1qlghNyJDhuAAe0ZBpkBum8bfB83A2TgBtRpY4DrQR7MgXVIkGmk4EEf9EGOHwbkYESkeciwEJQExyPYEdC4QdYE0gNtjCENUsBU/MfS6QKFO7iTC9xH/h/X/n8GQoARkU6ALFCaAh94BlxhAxlQY2QAdWxBaRm0zB0kBlpdAprtZmblZji5LooBdF0caCk8aKYedMo9aCAAdJUhaBYVdIYD6Po10EoQ0D7/L29vgjuQsHABxQMovkArfUDnO4AOUAN1QkFL/3lFNIDXXM5mAHWIQDPV/MCVCCA/g/elg5M1MwNo9YCCfhz4zAHQahHQICFopQT8gEJk7/+nsLELj39GBtASdVBeAw2WgDqo4C0TwMNFQQMmIL+A9tCDBihBZRJoIEUceKUeaBUFqBMOWrkBuvVC2TQLvCoIEgEM8M4+6LBFUFkHKmdAAzzfPj8BD+hBBgH+Mzy8tAgaZ0zAAxdVGSDbj16BB05A6QB01gfIDlD8gE71B5UvoFgGzXKDtkOBttRYha1meHRlOThspdT9GEADeCBx0DJ0UJyAtheAtlOAzAGVv6By8y7wYFPSOv+wwEeqA5DyKrijDzz4FDnngOwGneMAKsNg+/1VzHIZQOkGVJaCzggBb0P4/58BkYaYGEBL70ErkHiAS/A/A69OBaUT0O0IXMAzY0CrQUAdZVBnH3RIK2IuihF8jSXsPn/Q1aegjjJoCwGojABvIwHXDYwMoNl9EeBWFdCVqaAOPmj1C2iFE2g1FWRbBTCf8Egw6Di1AA+oXAeuW0Arq2DnV4DcCgpn0BYt0IAayO+grQigOH4COkCVSxg6qAxUCaw/QO5/8+gQOO+BVgoIShmDrx6FFxyMsMECBnAcgtIYaLUOKK5BZ8yomOcygK6l1LStYgClQ1P/uQygbV/g8xGAYQ6+JhVa79GpScQw6MD/kdz5He34M4wCuoXA6AAATYOacTQpExMCdKjp4I2SoR4jFHf8QQFASucfqh6oBXSXNmi/vxBwuT+oEQVaggpuPAM7vKDZRlAHHrTXHNR4AjV8QHtvQY1GUIcaNEsC64iDGnCgmX/QXlJN4GqAa4eawUuTQbOIyiYZDKAZTVDnBnGHO8LNsOWTjIyIDhJMDBG1qA1byEwUC3BW3A283xa0Dxi0XB/UcQIdRgXalwnqOIOWaILcxgid4QMdYAU6vAu0tx60xBrUiHxybRWWFITaWYMrYIR0HkADD6COO2gmFLRfHzK785cBNPABauCDloeCr7cC7uVmYMC9lB7kD1CjGDSTBLoiDNQBB3XwwQMuwC0VoFk10AoEbiEl8AFvsDACrWoAHQ4HahyD9INmZkGzaYaekxhA1/eBGs7g67iA98czMqB2ksF+ATdqGRlA+6ZBs/+gpciggR3QUmjwgMb/f2hhAjMDHAAMoCvXQDOwoI4kaNkr6O5+0Ewm6MTvv2A/MzKA3AwKG9CtA4glxYwMyPGNrZhgxNX5BycZ1HTOiG07ACNodp0XfPI6yF2gsxRePzoM7sSAZuXAt1wwYM7OgozHuuUBNqvOgD5owIAljBhxlEbo6QkSjqBOHqizCYorkL9B6QAUt6BDxkADMaDO6W/glYug/AbaVwzq/IKXtANtAc3cq5hlMYBmIEEzsaAVPKAOD2ibCuhaOthJ8wzw8gUS9qB0AsoXoAEw0JJ6UNoBnTfwH7o03TRgAQPIPlCnG3Q2AKijA5plBa2cAXX4ITO2JyEzqbABN5JmqhmIA+A0yswAWv0COmsA1Cn9+v4OA2ggEdTZA3XOQeUW6F5/0IAZqFMGGrR8DjyRHrRNAJSmQR06UDn2BjiLDCrLYEkLtNwc5H/Q0m/QzDI4aQFntkGrDUADCbDDL0FhBersgm8SAQ70gewFn5UASSzgM00gJ8b/BocHSB2obAANhEFWHv0E38oAGqwAhS9oRQdoqxQof4KWpsvpRgMPuFRhAHVQQZ1pUJkBOSCUlJl/Bux5lZGRAVY+gwaHQGc6gAYZwGUhtEsPGvQDlV2gtASKa1D5DEp3oHCDnAMATfPQNAQyA3T2AqiDD0oLoIMxQauaQGnkw8uL4O1S4OX0wKsmQSszIMvj0VZxAc2SA24nAaVTUF4EbSUBX5vIAFEHKk/AZxEAB5hBZSlo5QLopgRV4ODEU+BWLlA+AW0nA5U9IDYovEEDF6Dwhu3xhw00gMwB+QuUj0CDZWBxRkboABCQBq4cs4ncxPDg4kLwDQQgv4MGDhgYEAOYwrKWDKDBB5g4KM+AwlBE3gY8GPLsxnrwSh1Q3QfKd6BtCCBz/kC3ukEGNyBXFTJQEQyZ2f/Rzj/DKBgNAXqFwOgAAM1CmnE0FRMTAoy0DafRjj96JOAPb2yz/wyQFg7wAKWL4Jlj0Awg6M510CwnKzsPpDELPPmcD3jNFahzAerIgzoF4A4q8NA82PJOUIMb1CgEdURBs4WgWU3YSfugWRvQLDxoVgg0KwzqLENmhP4zMDAidSiRO6hY0w6a/6ANW/Cye2DH/tHlJQygJZ6gjjPoCkLQkmXQvlSQF0FLO0Ezh6BGLmhQADS7CXIraMYL1Bh8eGEhA/IsFXyjOVY3QTptoM4BqEMCOoANNKgB6liAwgM0kwVa1gpq6HMCZ6hAs7WQwxTROtOMiE4w6E550LYEUKcD5D7QTDp4QAA4uwbqrD66tAR4u0Ikw8s7OxlkNIPA95yDGpSgmWFQR1AeOCMLmgkGdd5BB2qBOtqgxjnITSBzYLPVKHkGKYyfAhuvIP+DDi4EHXYGmfH7h2NrBqITC7o+EDTgApoFBHVgQbNsoEOzQPaCGucgM0FmcQEPfgTNgIHcBrlWkoEBtN8ctMwYdIgWuAPMyIAyKICaujHjHlkeYwAA7DdG8Mw3qIEMmi2Hd4aBaUVKzZsBnDawHMKI76aA/zg6/4w40yvI3cgYffUDZCAJlA9AHUJQxx+URkHpEnSbA6jTCopT0EFqcsDD40DhDTr5H9QpB3W0wMvi391mAJ3gDwoPUAcdtJoAdLL5s1tbwNeeyepEMoAGZCDhhYg7UKcKtKIE3GlGGaCCdDpBaQ2ULkH5GJQNQIcAgs4XAC3TBsUraPYftBSegcxOP6GOC2qc/mcAdZ5B53nADqhUMEwAH/YH6iiCOpCgDiconEADF7dO9DFAzsH4D04DoBVAoMENcOcfUugxOCYeYHh5fy8DO5co5OyFX1/By7tBA3CgcATpB5/BwSHAAMqDoFl/EB+yBYiJwcBjIviGDJBxMLUswDITfCAjeECEkQF0VgSoLAQN7IgBb9QALU8HdVRB5Se4Awvs3IIOnQQtWX98eTkDSN2HF+fAs9kMODpM+M7jwFrGwzu6wEEU4DWEkBVb/xlAA7KgNASKS5D9oHwK2p8PGjABldGglROg8hpyawJsoAySlkEdX1AYgTrtoA4uaEAEVPaBVlSBOumg8guUdj88O8uAfh4JzP0gk0DnWoAGEkDhAto2AUrroHoCXBYD3Q0auAPdyw/ig1aYgAaznt5YB6434GUZtBwFreIAD0yJ6TCABsDAAzqwMgU4ww86mBFUZoKudgS5AVQOgVaNgM+kAW7TenxlJYOQtDl4YAlcXoL0ggZIgNcVggafQLfOgOqan8BzNkCDUKDBG1A4gLYUgAZuQKtiQGUcKEz/gW/TEQAv+QelGfBAOcZgKqwEYxxtTw7rEBid+R9N4PQPgdEBAJqE+WhhTTBYobMEtEzyWGf8hlIpAwsjRmqlJ/zm4O6gMMAbU6BGPugKJdCsFaixyyuqCZIEX3cEOvUefMc9cOk/qKEHPsQJeMUe6Aot0DJk0H5gUGcYpA60RxjUAAR1/EGNWPCeTuDyZlCDEHLy/R8GUIMO2pSE9LUxwgMiC5VkYMAxwwtKB+BTnYENadByUZCdoE40qPML6hB/By7lBbkBNMsP2kMKSiKgpbY/v79hAM3ggBptoMPMYNfwoUYHZpgihyNkfz/w2kTgUlLQ0n5QYxDUmAU1hkGdMND+T9CyZdCSadDgA2RJPWYiBR+GxcoBDhPQPn/Q8lYl4OFToE4dqMMMaiSD/A8aRAE10kGNclDjFmQPyA7Q6eEgP4BMBsUbqMMBuqMdZB9IDrRiAzSTB75ykRES3wwoHmVE4kL3xf+HdJwwgx0RJozQjgWo0wobZAB1zkAn9YM6OEqGyeDlvqDOE2h7AmibBWhVAGgQCdTRAXU2QINNoLQDPhOBARdAiwe0PIO9888ATjOM4H3K7AyQ8yAYGUCdHy4+aQZQJ9Yx8TAD6Oo3iOmEG2nYO6zo4UE4H4K2a8Bm48FLzBmZIOkbGp6Qg+2YGED7nkEHkb1+eACcR8F387+5Dg5TkPtBM/agThFoVlMReJo5aCYZ5GvQihxwxw643Bh8EB4wDECzopAsxghf9gyKW9CqEtgp86hpG3JoG2SVBCMDaFk36FR00MAZyE2gQ9BAM/Aguxmg1+phdExxdWAZSGsQw+MXHLSgdAkZSAPfwgAatgSWLZAO6Rfwsvo3j4+Cz/gArUwBhSVooOPDywuIbRBMkPAGDaqBVs+AwhG0bQWURkCn/YM6teAbUJ6cAIc7aBAPdAbIW+BVjJy8EuDDOEEz5OC8DrxuEDLbzMQAugYQNMsMKh9B8Qsum4ADTCpm2QygPA3qJMKW0ms51DGAlraD4hYU7q/v7wPfFgJyp4nvTAbwgBzawMp/EmZQEXEJdAWw8yurE8EAGhgBnVkAWpoPKhNBg4Tg1VvA9OeSepLh/rm5DKAtI09vbgRne0WjFAbQrSCgFU6gMIUUHbD0w8AAOlsBFH4gd/0AbhcDmQnK66BwAA0WgVaXgNKntIY/eMsE6HYRyDkMDCjlOWSFwG/w1grQIB147z40j0O2VXAygFYWgMo1kBtAg82gW1lAJ/CDBgtAA6agPAWaeQeFrxDwFgKQ3yDXKTIygFasgOo1ULoF+R20MgyUXsC3ujw9ycAIXmEVAPYraGUGOM9AiyJ+CT0GY+9p4AFXUBqBXXMIGvwF1TGgNAPKE6B8DCpvjXxmgK+JBW+XAx5UCRqcAqUTcPgwkAj+k1smMQw+MGJn/0c7/wyjYEBCYHQAgOrBzjialAmFACNtwwhlBnOoxAZy5xbGpqrbCYc5cQMAjOBGMqgTB2rAgjpyoI4ZeM8/8Io4kC2g/Zqge51BDSxQpwDUQYAsrWdkAJ3grAs8ifk58Fo98HJHUIcG2PkAzcyAGk+gDjPkOiRopQhuUTIxqFkUgPe8M0D3mDIxszDwAWdxQLNnOIMJms7AnQMg2xx4YBZoFh/kXtAsDWi27+vHhwyggQbQjBuoISqvH8sAOkka1PkENchBDc3XD/ZD7joHW4Stskae+YK4BhyWoAPSgH4DdYpAHVnYQYOgxiOo0fzz+1uwYlBHATQbBLrWCiSAyB5gzzOABzaAgqCGK+jgKdD+YcvQ1QygDr2sVghwhnIPA2imiYNHDHw1HKhzAb5qDNioB82WgQZfRBUcwTNX4D2moM4YdJ8paBUHqHEMcg8LKycD6JA51PCEuYEB0SmEOhKlU42SpyFpDTk9fQfvKf7PABrkAC0/BzV+QfH/8dUlBtC2kc/vbjGAZrRB20qk1P2BV/m9BB+uBVIDCi/4rCw8GSOFDfoIBJbyBZdbQY18RYNEYKf/E8Q+YJyAOl2adjUMoJsVPgI7hZ9eXQEvLYec9I8lH2FruBJozEIGRhgZsNGg+AYttwbtqwalTdAVlVy80uAOIsgfoM4JaHsNaObz0eVlDKCw5eAWZQBd1XfzWA8DKJ39/AIMv/9/wDO4b8CH9TEzwAZdQIM9oLQO6rSCZmNBcQ7aqsOA0elmRBr4Q00HoBUsoLCDHI75jwE0s/7l/V3wLDloJhNyjsV3BvDZGThnNbHnXEqWKyOSByKeQCxQOQTarw2a/QUd9gbK76BOl1X4WvAAD+zwOpCfQCuZQLO+oHKLEZp/QVf4gdwFGjgEhRd45Q7w1o/P4LMT/jGAZohBM76gQT1QugENqoGX8QNXXvwBDYgC0wNoLzsonEB5FRRGoKsDf3x9xQDaJgAaOAAPRgAHKWGDoaB8C9mPzgSOU1D+AOlziN/HcH5bDvzAQlAo/iez84ScR0GrbEA3h1gEL2MArZJQMEgAn24PCgtQugPtiQeFz9unJxggRQATA+z8hF9fX4MH0CDnUzCglFmgMAMNIkHS13/wSjLQaijQ1gtQZ/4XcKAVFM6gfA7aHw8+/wVqBCgvQNwIKWMhYf8Xnm9A8qCyE3YjAXgwClRWArfCgMoZ0OoV0DJ78KGXQDP///sFviIVVO6BBhxBq5lA9Rh4QAaY/sGz+MAzLkCDlSB7Qau0QPkLNAgCGpwADVCDzokAxQtkRRLw3Ang1ilQXQGyA7aSA1RWgOox0AG3oBUpQtImwKtmCxhA285AeRZkPsht4C1ZwNVzOo5N4Bs+GBhGaGdwRHb+Rzv+DKNgQENgdACA6sHPOJqk8YUADTv/Q6Ljj62jz0jrNEPYfLydf0hrjwHWkYY1ykTlbRlAjR5QQw7UOIIccMfIADqYDnzNGLAxA1kO+43BxG82eMYKdOgWSAzUkIKcF8AEnvkBNZpBVz39ATeA/0IbmIzgswFA5oJO9gZ3QZhYwI0/0HJyUMMaNGgA7v/hGEBBnhkENbbBV0QB3QXaz//y/h5wpw/U6ALvaQZtEQAuo390eSl45go0Iwo7LAw0W/Xu6WkGkPtBZiCiDL0SZ4S7HdRY1nFsZgA17kF7skEnQl8FnsSvalEIvrP/5b094OXXoBmi32jXHSLHB3IDGNTBADX2QY1IUGf+5b1d0O7vfwbQUmxQhw7UiAW53Tx4CcPtExMZhGTMwPuGQSsdQAMfoAEO0KwYqAOp79HP8PDCAgaQHKTzjzyYgdSJgnsYKgblI8IXOY0hwgBSFCDkYCtHIAfGMTKArjEDnSYPun4R1CEFza6BOo8CwFk10IweRP9/8F3roLQB7jAzQDrOGCsPYGkArfzBN1ABMg80OwcaYIAdDAYKQ5BbQKtVQDPqoDMpYIcdwvxDepYlNo8zMsAG1kDLhm1jdgDjcAJ45vEvcMmwGjDtgO6XBy2hBg3CgdLYv9/fGUDX/oEOjwPNYILCEJRuQW6H3fjw9+8P8JJx8H51YIcD1PEB+Rk0wAI/tBKcwWDxy4To/EPzP6IzBgp/JvBSdNAqDtCSa1DnFJSOwStI/kO3hYBoEjs01NirjBrfkBgDpR3kQyt5hVTAd7mDbh6BzCYzgE+b5+CRBN9sAi4ngO4H5RfIIaGvGEBnVDwFnuIO6ryC0g1oxhhUdvCL6zGA98WD9rUD94mD1INWsICuZQQdnAg6ZA5yWN4vBm1gR+/2iQlgR4H3zwMHbkCzy+DBJdDgJjBhgcqYz8CBAwZwOIJWWfwFnzgPGiAAhQ/4wNQf7xkYoAMrmJ1/5DKJ+LIfvK7n7y8GUFkL8j/4Xn7gygnQ1Y6grUegLQDgbQqKTsB97HcYQINAkBVVrxhAaQ00qAJZxv4XJe2AtmWAwgk5z4DKJ9AZIqDtSaCBLtDtJKBrZR9chB6kyADJB7CVMJC6B3L7AnjlBNAw0Cw/qDwEpUvQ/fyg8pARmlbVrcsYvr2/Dx7cAdUz4LAC6gHVVyCzdJ1bGUDnuUCW+bMwgAbVQGcLgPwE2s4AWkEFcjP4XIH/oHNZ/jKAVlKBVtC8fXKSAbKK6yMDzC2wlVegLQCgsg20FQ4UXrCDCEHndDwDDnqD+KDtJLLa4QyQawj/g2+fAZXnVmFrwTcrMIy0zvBo53+0zzAaAgMSAqMDAFQNdsbRZIwvBBhpFz6MDFQ2G1uHkhpidE0h4BY9UTZiDgCghScjpNEP6nCAr7QDHZQHnB0DLXH88u4uA0gcNIts4jeH4R7wVGrQXmVQQxnUmAGd+gy+CgvYYAU12ECzZqCDpkAdLtBBZYJSJgygxhaogQXq9IAOUALZDtr/DTotGXSCOKjxDmok8oqogffggsQfXVoK1ocr5tE7fqBl9uDOPrBT8vLuTiATdK0f5MAlkP81bMoZQNdUiQAHNkANVFCnSgE4OwzaUw1qXIKWjYJoSIcJtBDiL46whbnoP/hAw3/AmVjQoMfXDw8ZQCsBIIf+fQWfoA1qNIM6TgxYZknBnV0seQbSyGUAdwBAfgRtDwA1RB8CD6cCdV7B+5+BdoJWCIA69aAZNSngElvQYAnoIC7QtgFQJwXkF9AyYtBgCvhOf2hnjREj6mECSBJEDwBA9IDSB8iNoE4P5ODA/+AcC77mC5iWQDNh4AMRWbnAnSmQP8AHdf34yADaMgJaci0grg/eZw2aTQTN5oLkwREAy5c4YwPqbhSPwdwFpYF6xRQcGEDpmYtfBjwbB1ku/58BdOAlaCsIpBPBAG70gxv+MPuoUvRA8yo0n4G2Y4AGxUD7nlWBJ4eDlvP/AK6iAKVF4OlpDJBrMn+Dl4SDOo+gGX3YlWag2UqQW0GDBKCzIEDbXEBOVQRutwAPGAAHEsDxDepggs83+M8A6W8xQmdWmRhUgCfhg2+mADsLuv0A7HUmBlj+By3lBp0bADr0DHxGAzj9/GdggNPIEYIjkJDihKjOP67OAlqiRR8EAHX0wFscwE76zwDft/4f4ndYOgKtguEHpjPYCgBQWIJmmEH5BZSXQLPKILWgsAXN6IPCGdSZfAy88hE0EAraVw7qoIPKir+/vzD8h17vCRpsAXX8QHKgZfOgchGUL0HL6d8AD50EpSfQVY+gtA7KB6C74GH72kF2gFfQoPgd22GhhGYUsccBymAjcAADFE6gw+xAK19AcQJKM6CBDFBnHHSoI2hfPCjuQeU1aHATtMUDdK8+aFuAhLI7+FR7uE2M0HSNkjeBpgJn4kFhAB7kA/oLtAoKfK0kVB3YTcByAXStJWjL1vtnpxlAZ1qABrZA7gHfwgC83QG02gxUZ4BWcoHEjX2mM7y4vR28fQfkLtCgGWj1B8jdkKsB/4Lrj3fPToEHc8Ez/VA7QVtWQFs1QJ118OoP6EAjH/CQQtCANWhVDWgr09d3d4DbDT5A8goDA6Q8gKUrYB4F2QMq58BXUQKvzARt+fgDXdkBcitodRFo8AO02gx04ChIK6jufAccWADl4T/gG3OImB3+PwyW/492/hlGwWgIDFQIjA4AUC3kGUdTMa4QINBApyTgGBkgkCwz8HXoh3xsEp8eiZ39B50yD1q6DZoVk9EMZnj37AwDqLPJwsLJAF66D+xMgJZ0Grj3M7x6cADcwQad8g8SA93pDGpggTq7oCXxkBkWBuCMWCMDaKkrqKHNxikIbJQ5g0/Chs3qgxpun19fB88Ag2ahQKfWgxpRoA4HaCk/bMkppJkJSw1oaQLeOYB0cMAdlP/g+S6UYSPQ3dagpbyghh7ILlDDHDS7CRqs4BFSZQDtswcNCoBmT0GnraPM1DCihzfMLtBAAXCJMHCGHxTOoM4EyD+fXl8Bn4INuoZNFbi9AbRMG2IevkYd1A5GBnDjEzR4IKMdCll6CzycDNQ4hSVbUIcHckf/PwbQ2QagWT3QCeWgJa2gDi1sdhE0OwaaWWRgQJ01ZITawYgUdvAsgeRXeEcLZ+caOnAEHCxiZESKJSAbNBgCul6OFxi2oDAGHcoI3pIAnKEGxQFoby+oQQxa0g6Kb1BaAh02J6bowHD9UAsDqJMMMxFn0QOLYRR/QMIR5h6QXtAVY6CGP+g8BnElZ3CaBM12gtI4aJYc3KlmgPhFDrhXGjTjB0l7sA4vmgsYseU/iGsx3QpRC5pJBqUtUEeGS0CBQcOmEnx/Oeg0c9C+YlAHDDRYBhrIAnVIQWkJvLUGGLagvAMaTAN1MkEHbYLyBij+QWkalO9AeQ4ys3uXAXy6+X/ESeOMSOkJZC+o4wI7RA90YCPsijZG6O0Yem49DKAOG6ijCJoJBcUj6JBJUJoDqwGPJoAGDaBhg5L/YL5nJK2EJbajgC1tgiOYASn5ItnNyABJIUAa1FGUVPUG5qcfDKABFXAZBVUKmWX/Dx7oBIUPaDAKFK6g9PkCeOgmaBAOtIoIfKUfcLsNqEMHKhNBK39AKzJA4QIaBABtE/j44gJ4EAV0qv+9M9Ph7gLJgfbSg5azw2bfGaDlFKKswVY+/CextsIMe1hegB0ECp65BpYJoMFb0Ew7qDwEdfxBgxagNAeqA57d3MwAOePkFwNosAh0WwrkoFAGBlj5DXEYzD5Ud0Ki6j9itQA0HYI0g7Z4gdIW6HpTUKcftHQetKoCfFgonyxwMMAQXCeAyoYXt7eBw1NBPx48cAcayAOldciZHkzgO/hBYQ8atAGZBRrUBZ8BADx8EHyuCDAvgMpS8On9wPMzQFusQG4ArVoDHQb4BzgICRo8BZVHoEEg0IAuI0oyBvFgfvsP9jwbBz942xio8w9aOQK6elNKzQd8lSr40EguEfAKANAWGZDbQAcLggbyQCtF/pO4ZYZhFAyhEPg/GlujITBoQmB0AIAqUcE4mqRxhQAj7cIGZZaHmBhA7/AP21gjLcyJmv0Htui07GsYDD0nM4CuMnr//Dy4sw7qZIA6JSAzmNm4GMyA14Jd2l3KAL6e6Q9oD/BX8DVhkKWSTAyw061BnS3QAVDgg+lAjVzgVYKgThWoI/PxxUVwo5AfeC8/qOENu2YL1Ek18p4O3gsNO71fSt0XvE0AFJWgO84xohQl/SE65dApT7ByRsj0J5TNAL73H3aQE6iTAzr0CzQQ8fbJMQZQRxS0Zx7bjD0Dml0gA8FCQAK0eoFHUJEBcq7AH/DMLeh09vvnZgPva3cGb4MAzzQizZ7CT8JGNxfIBzXGQY1y0AGAoAYk6Fo90B5v8FYGYIcQNIMO6tyD+KBZrX/QWV+w/X8h15CBV0P8x9GBhbTgGRhgNHLegQYy9s4/2NcMsBk82IoR0HkNILe+eXiQAXSLBEgVaCAHtPwX1NkCzZqBZlBB+8hBs6agfeqgtABqsINWgIA6GqDZb9AABmi2D7SXGnJ13X94HDIyYEIGRCSAO28MMLdDIoYBJg9yL2g2ErIV4CMD6Foz0HJmUOfn+6dHYGXgmySA8QOajRUGHiIGWbr9jgHcYIfGEXFlEiMiXKFpDxROoHMzYDdogGbZQf4DDdaA4xFoL6gTAT57A+oHWKcU1DkEHQgJul8etNwcdL4G+ByN/5AVLiD3gTod4KXYQDHYyfdgVwDdDRowAM14gzr1oEEi0BVqoIMmQTOR4NUPwGXhsHACxRk4PoBLw8HnMgDTGmhFj7p1Kfi0fdDSepBa0CwpaHsHaPUBJH8xwGdKGUkpnsiZIUSyACU+kOIcPvjDCB0sBA5ugK+Lu70VeCWlMgNowAd0GBxotQ/otgTIrQaMDObA/fGgATNQOgXpBHcygWHADDygE1QmSap5MYDCDlQ+gDqvoIEaUP4Dbf+BrHhiA28lAG07efv4CAMjcMYdsiQ8jAEUruCZcODgKWzZPAMKQHQeEMv+ye1QoEYCangwMEAGe5gZwJ1u4BkGsKX2oMEe0PJ2UIcf5DcFg3gGUIcZcs/9NUgyAeVDeBxg7/yj5kOgfdBDF5HdAdpixsohCD5XAnQuB3i2HhjWoEEq0JkVoCX2oFUKoAMmQeUraPAMdFUt6KwCYeBJ/b+gZ6zcOzODAVR+gzrboDIPFPagAzAhA3vA8wSA28pAg6eg8hM0YAPa8gC6EebG4Xbw2Sqgcgi0pQA0aw/KVyAfga97BN+KAUnWYHeDVtQA8ykoL4HyKsiPoO0AoBUdoMEHHadmhufAQRNQWILSEGglFGi7B8jNoIFt0FkB8O04DJQDamynYaAlGFGz/6Mdf4ZRMOhCYHQAgCpRMjoAgDUYGWkTLrBmPlFRB3IDDA/7AgjWsSDeo8R0/kGmgcIctDcedA0SbKYa1AADdYJAHW/QslbQrAtoeTmoQfsPuOcYtDwTNGMD2j8PaoyBOnWgTj5oaSZIDeTUcdC+TmYG0AnloFkvUOMMZB8z8PYAZeDJ2KDZHZBeyEF66gyg67BAHUHQnk9QJwm0pxN0x/M/8FJbBgb4zBNGnEPSIiNywxS90wblg9wHOvEfpAPUiAJ1cECNQBANXq6Ptq8Zs5PBAHUIAwPMPlBnDrSMFHLYFAN4GaqBxwQGUMMTFK6gpbOg1QCgxud/HNsBILHKCO3IMkL23bKwge+XBnUMQQMTvMCrGCWUXMHLcMEz1NBOIOgQM9jVi1gbhoyMDPAOITjsGCAzc8DGMWg2E3xeAwM0DKEdbbB7MPI4LJyZGECnin8Ddp5BM9Mgf4PiHDSTB+ocQeyC7DMHHWAHOhARlFZANwAIShoygNIBaLACdrc3aI8xaCkwaIk2aNYVcjAXaAvGfwYGXOUMPA0wgvcrg7dKMPwHu94idBUD+J5wcEwxgnog4PMsQIeQgQ6KAzX0QZ0KcAcD2FAF3XYBSs+/f31iAKkBpVfQagTY6fhkl3+MiPACxSEonYAGhkCHPYIOeASvjgHGIeh8DJAcaNk5aGk4qIMKWhINyoOg/Ai6rhA0QwnaMgDqyILDF3ReBhCDwh6cpoDp6h+sMw9NoqDOPyj8QQMr4PQCdA9o+TIorUDi4yv4KkRQZxakBTQrrgS8TQCUB0FmiQFXS4A6XqA9zKDwBZkDyiugTvOt473QwRFgegd23EDpHbR9AzQQhB5lWNMkJR0EJAswB6oYGeCrURiZoOkHmEaAJ72DVn2AwhZ07SEozEH+Aa+iAA5QgswBnfgOKqfAy8uBh56CTokHzTiDBiJB556A1IM6+pAD6DzAh16CzuYAHSQKKq9+AW8EAHVeQatyGECDDsCVQaDtTaA4BaV5UBxCVhfBrgPF7Dj8p1rHCVE/ow+IKJtkMoAGQUHXSoLSAWgAA3RAJ4gGDYKCDggEbf8Alfm2MdsZ7p+dDc4CoEET0Moc0OAkqJMLyYJQe5DdzQipq2CrSkBXsxp6TmR4em0tOG7AA5rAAxJB9QhotQVoGT5oSw74sFngEnnQag1QWIPOgQHlf1C5ce/sLAZQfQRanQa6NQCUZkHnY4BW1oDsAV2DCt5aBFymDypjQJ1y8BkyDJB9+KArD0FbOUArO0D5CdzZB6YJEM0rrMIAuyEGtAoMVBZo2lQAD2I9xACKD0kVTwbYmRCgAUwJVS/gNpNnDODVCG9uAs8MEAH6bQ146wAoH4NvmAHmRdDVr6DtaOB6EViHgVaXQMqS/9iLV4ZhAkY7/wyjYDQEBjoERgcAKI4BxtFUjB4C8IY39YMGpbOFz3gaumFwRjh56RDvAAAjosMH8jPo9GpQox/USAXJgJaqgg93AjbuQY19UAML1NEA3XMNakiDGjPqVqWQg5j+/GCA3VcOPhAJeI0UqOEGanSBZnZAnUQQDV5GC2x0gU5PfnFrKwPopGRQwwrU4AYd4gfqnFmELGcA8UFsyF5pQQbIUk58o+ywjhYsnBgRS09BnoM2SOFMMIMB2uWF7AOHdN7R7EALI0RnlJEBdbABaCCoYw+1HuTuBxfmMYBO/gfNEH56c40BNGv6/z/yuQKocQprpINmG0HhC+qggGaiQPEBaqSDBkFANCicQYeSgfbNg2eUwI0txH39jFC/ofgVOhPNJSAPPnEctDoDtFpDUMoIvAwdMpv2HzGzD56xw8j4DBAzIY170OyxWcBCBtD+YdCS2x+fnoJP0wd1YkGdedDp5yC/gzr/oIEB0D38ILWg/begjhXooEIN20rw9VoislYMID6oAwU+CPEf5JpIuAtg+R2ZhrgG7GbQNYKgjvUf8GGL/xhAy4VBByhCZsMRcQVe9g2OJ0bwVV2g8xFA15iB98MDxXkEFMGrNUCzjIiOGmTZLzSxMGAMCDEyMmAAtPIJFLeQe+V/M4Bml0EdB9AgB2i5P2ggDBQXoE4NyGxJdR/wVWygE9shWxNApv8HX8UJOsyMAZZ2gR1M8EFp39+BTx8HdWphWz1A9oEwt6AyeHYUdHggqOMKihtQvIA6UqCBBNCMP+jcCNAsJejMCFCnFdQ5gg0CgrZsgPIlyErQYIAQeGUEE3A1wF4GY+B1Z6BD88BbGoB3y4PUgs4WAIW7GPAgOQ3gqoHnwDzOwIAl31Kjg4Avb4K2pIDOMAGf9/EUmq4ZwGd0gDr4oAEYUJoHrUwB7SNnYIAMvIHKAPBqCuCsOCgM7pyazADyH2hpPOhwTdBWCFY2HrA52yerMGja1QI7x7MYbh7tYuARVmMA6QeFMWiQBZQGQQdMagFvnLgFvL3hP/zQP0jnH7QtRkojgAGyJB1b2UbprCIjUvaB5FlQ+QXyD3ggFrzlgxHsZlAaAKUF0HJ20EAV6HpFUUVHhk+vLgPPfJnNAOssg/SB1IHOBwANmILSK+iKQ9CNMAzQGXJo8gTfww9ZVcPAABo0enpjIwPosEqQPCitgm5pAZ2RABpoAJX3oG1B4LwFNIedR5wBdPMAqByFHRYKGmgRkjJmAA3EgM6hAQ1CgAZYQasWIFs6njN8/whczQPKx8BtRyA3/4ZeWcsMHEgFbVUDXyMI3epiHbmJ4R5whRaobAIN9oHKClDYgPSAViSAygDwljbguSWglRCQQ/0YwHXRF/DtD5/BtySAbmcBDaiBb8thhNzoABns+QY+BBaUnkBu0XVuB68CAW1HAg2Wwg7uZMAGCOSPQT37P9r5ZxgFoyEwGEJgdACAolhgHE3F6CHASJswYUSedcQX6hgdf2jDhgEfPZSjEeYv0v1ATOcf0lhjhM+SQTr8TOBT8kH3s4MaZqDOO6jhD57Z5xQG78+8sD0PeJ2eD7hBA5qlBzXEQJ0r0OFW3788Y4A1hkCdGtBydlADE34PPiNkGT5oiSaoYwxqOIL2ioNWAYBmuUEdXHDjC3iQFOjuZPBS8P//EX1vBvQ0COHDZ7ngPTVIqsLdaYfqgwQCOIBROvVgcZgaRgZkcyBSMHcg5BihZoFmQUGNTdBMIWgpNXhwAdYwQslDCL8g3P8fvO8fNDMP2qMN6jCCOragE7VBYQEaqGHjFAAOuDxngC33xsimoPwE7ACBOpagfc+gBivE/P8M4Ou4gFcsguIT5C5Q3IHuOAd1zI2A911/eX8HMuAC77gh0iA8fBgh2z1A+q/ur2EA3ckNGpwAn6T94jwDotP3nwGyTeEjA6izDb4WC7h6BDwLD+zkg2aaQdsAPr28zAC+cg50aB0onFAakYw4Ej+sY88IHskBbeUArSQApccnwJlG0JJg0Kw16LR/cBpihKzYYISWIfbA69YeAG9IADX6te3rGUC3NoDjCTRrDLxKEbxs+NtrSLz/xzMIAEsnGIMTEGcjBgwYGWAdetDKA8j9+gwMoGX0oE4Q6EA/VmC8glYggM5AgFxtBhmUAQ22gZZrQzpikNPS5fSiGEAHahoBD0YDbQsAD5LBQ4qRATYDDVp2Dhv4AA8gAMMYNEMJuqsdNOv5GzjjCllqzQAf3IAMIDAzgFb1gLeSAGcvQTPboD3PsFPjb5+aBDoAgwE0mPMeFOdAc0FbFEB5GHTYHajzJA288hF2SCHcadTqIOAZAACle1CaBHUqQR13UBoDpQHQ4BJoHz7sDATYkm/Qif6g1R+gVUuggRJQmgXtUQedDQLKY6C4AB9uCuz8MzOzg6/2UwYepPjq/l7w1ZygwSdQPgPNVIPSOChMwYf/ATuj4I4jkAYN5oEGVUFlKWiJurxuFHgJPuiK1M/AWWRQ+FC+9B+zJECUVYwMoHNeQIN/oJUhoE4uaEAOtHwe1LmGXBvJxwAavACV1aDBXdDSdXC5B3Q/KLhB2yBAA2Yv7mxjAJXb+u69DKCbFmDneSAnP9Dyd1C55ZCwn+H++XkM4BUo/yA3CIDKCdBVmKCOMuhWE/ChjcBVGKBBF1DnFnxGCHCLGWipPSh/ggZLQPaBbqMADTCD8jkoX/EKq4K3XUkAZ+hBA5J6wCtoQYNqoIEL2DkpoEFOUFoErUIALcNXtyxiANGgNAI6mwV0eCu4888AKR/AK5A+PQUP/IAGYkFpB7QyDrz9CqgGFI+gtATKIyAxyFksfxlgK7JAfuIRUmIAHZ4LEtOwrQIPWoDOGwDdQgEyE3JY6g8GrINjDEMYjHb+GUbBaAgMlhAYHQCgKCYYR1MyLAQwOt7UCxqiZv2x2g+JH1BFDGogg5YnAo9lZsDe8R2KcUmZmxlxdDSRetKQBj+sIQ1cTgxadgzqvAoDr5YDLVsFxQ1oKSboxH7Q8krQYX+gWcVHwOv09Ny6GWDX7oGvvALO2oA6vaCZG8hMN9D9oCXqwI4e+HomYMcK1NADuQvUKQb30/9DDisDN8CA9oP2TYIacOYhy8AHPoE6TMizHagddPSOKbQjzgiZzQOlB9gSVEiHBqnDzsCAZ4UAwlwG5E4GI7p9YEMgGQGbOmBjCLxXFNQoglrNiDQ4gchBiHTMAB/c+M8A2nYBOo8B1JEFde5Ap4iDlsyDOtqgcxlgs26oORESBqBZJtByWtDsGGS2/SJ4CTwXnzQD6Ko+0OALaMkv6K5sdm4xBtCWC1BDF7RKATTwAAo30CwuaDkwLOyQwx7WIQUNIoAOOwMvbQZeXQaaKX18dSUD6BpG0IwyqLEO2iYAShcgs2FnK6ia5zGAGt+ge7v5gGdBqFuXgJfgMoO3PKgzwA6RRA8jaGAzwGZsGaADHaA9vaBOHajTBu6MQAcvBCUMGUAziLCZc5C/wOkCmNYeXloM7sSAOnyg/dmgpe+gTgRodQXIHtCqBJB60CwmuCMCXBXBiBQ/xJRbKGoYIR0MWFkF8jf4XnnQPmjgygVQ5xrkhzePjjKAVjRATgtnYFADdlhge/y17OuAZ0o4MYDUcPJKM3z9+IDh3JZ0BtDJ9uA8xYC0ZQKcJv+DO+mguAOtFgB16CVUPRhAq0tAs9OgDgwovkHxCNrfD+7EQPMGyN4vwI4p6OwCUMcMdEAoqOMI6gR+gA7ygAYHQWcTgPSBrqMEDdyB3A1aug3aUw3aMkRcJ4fw6h4GbABLvgP5FdTJAq04AQ12gVaWgGhoLmOAXPkINQw62KRsmgkeMAEP2H17A16BBDo0DlQugbdtSBoxQK6M+8cAWh4OOjwPFF+g/eCgFROgTixoMAC0KgcUL6CBAMh+b0YG0NkgoFUwIHNAqygeXV4OTneggQLQgAPk/AGQ//GEAbEdK0ZsdQZ0oAxY/oIGcQw9JzCAzl0BlR/g5f76ceDVN6CBgPfAq1BBB9yByhjQ6geQH0B720FxChr4AQ3Uiis6M4DO6ADlb9BKH9BgASSc3jPA8ico34CWyoNWM715fAx8FR43cJUIaGAEVAaAD2P9+hocDurA21lAaVFMyQW8zB7kA9CqAtBgBegMGVmdMPAhgKA8DMrnoMES0CAT6KYQ0AAyyC4hKVPwCitQvgCVlaDBUmEZS7AYeDUS8BDVz29vgHMvKLxBWxBA8QEehAOGGSgd28XuZnh4cTF0tQMjA6iuAw00gG5E4BfXAV73ehTsPdAtMpAswswA3o4DDFdQ3Qi7YQCUh8EHcQJtA618AK3kAZW7oMFF0PYCUL5n5xFjgAwA0mh1DMMooF0I/B8N3NEQGBIhMDoAQHY0MY4mcVgIMNIuLIju/KPEBlpHDFgBg2YIwKc2Q/dXM+JoCCE6WIM5epE6oGQ6E+sgCCOkcwgyEjw3DprpZIRcAQZqRIH2RIOWiIOWxYL2V4JmDkEtJlXzfPBMI6hRDZq5ObE6lMEl/RwD6DA/0Kw9qOMB0guaOQZ1LkEz1iD92g6NDKAGIKgBDlrqD1qCyYCRpiAzxKCGJqjRDNIHmjl6CTx52y52F/CO9H4G9A4EcocUwoacMwBqbP2HzSAD/SWp4gE+5MkscCED6A51iNWwnjgjA2ZnHEtHHNbBAM94s4KNYIQPBCDlC0Z082BmQUIbqpEBFvbIfFiahJvLCGmwgzoqoI4wqBEKOngM1IEGdapAHTDQLBP6WQKwcAF1MEHLj0GdPZB+UGMUFK6gZbewA+NAjX1+CX3wHmZQQx7USQYNtoAatKA0ADIfNLuMEmZQ14MGRUBLqMEniItpg2e1QdeKgWZIwY1c4L3poL3roIGjW8d7GEAz8OCVJcCtHyA3gtz3CXjzA2gmFnxYF/AwL5BesD+Bp2uD4hByNgADA2o2huQLWJyDOuwg94KW34Jm+nlFNBkkgXtzwfepA2cTQfuDOXilIKfiQ2ceQekQ1NEAhwVwjy5ooALUYAcdSAY6awK0NFfZLIsBdKYCqPMBOiEcvCwcOBspB5yxldUOAQ9OgO/Dh543gKsMwxBnhHXEGBlAB62BzsEAmQ3qQEHc/Ae88gPUGYdfFQb0MmjfP2i2EnQiOqjDCJq5Ba2sAaUH0MymhLIbA3jgDdhxhadIpICD5XXQYBAoHYBWXYD26sNWExh49INX8oDyMGhZNShuQTPDoL3/IH+COrigQTnQSh6QW0Ez6+Ar5IBhCpo5hl2jB1ILmtUFHewGHjD48IABdcsLAwMDRkeWlMY0lnoIKX9CBoUgaQTkJhAGXdsHGuABlVvOqSfBN5BAtruA4oIZ4j5gnfHq3l4G0NJ20CwxaMYedCYEaE86qJMIWgkC6thDVmQwMIAGPEDmgbaNgAbOQOUlaCAUtNIAFFegDqegtAkDeAAMOAAFmy0GdVpBN40wMkFWVjAysTKAbqUAr+KBhwtaeJA7o4qScSDpDtT5BN1IAkpDoI4yqGzQB974AFoFA1npxclwZV81+CDEO6enAq/MtAYPDID8BM6TX14ygO7BB60gAO27f/v0JAMoHYIGjcGHvUIH3SDVDBODXfweyAAb8JR90EoK0FYvxJYWUGECKftBWwFA9oMG38CxBywnQNd1Pri4CLw9AbRdBlQWgfIKaAsGfB89MGxA9Q9ogA402AAKV1B6YwEeVguKH9AgJ6huAp2BASoLQfGkYpbDAFpFALp2EHL+xz/wTD8oTsHbWYBxA8p7oNVKoK0h397fB185CLp6EFKGAbcO/f7OANqKABr0AeU/UDkNPocD6H+r8HXALXEzGMBXsgLLMtDNJ28fHwWfDQDKt6DwFwNurbi8u5wB9UBA4vPBoF3+PyJm/0c7/wyjYMiEwOgAAFlRxTiaxGEhwEibsIB0l4gwG2dHHjKbBtp3CdlL6c8AqvTBp4z/g+yzZsTpdkgjcfBFMvXcxYjWAITt/WSEd0KYwKdVw2a8QI3nP8AD0EAdLxlgJ+f1/f3gWRdp4P3yoP2Rz25uYgAtGQYd2gTaQwtqAII6X6DloKCZIdD1SaBZUlBDGGQHaLYGdpAUaG8waLYM5DtQYw3UoAY1zMAn3QM7oTIagQygO5JBDSxQRxJ8MOCPdwyPr64CL6tEHGyGLb0wgnuJkCvzwqB7MiUZQCsJNICHOH0EXscHOlAKNKAA8ztoSShkvzQDA/qyfgYGBgbkjjiYDxoFAQ4AaABnqkANTpB7wDNZkJYu2Az8gwkQU1BWEzDA7Eb4CTGwwABulIKWCoM6eZBr4X6D7bEMXckAupaMgQF5xhA5XBjBekEdPNCScQX9WAbQrPjr+/sYQG4HYchhbuzgFQGgGWhYBwm0/x3Ehgwu/IF01uBGQ9MmNF3BziMA3eMNmlF/dmMDA2SP+08G0OoE0AwhqFEMXrYOzY+awKWwILNBq0dADXzwnl9ggxt0Ijqo4wUahAB16kEDTyC9kP38kCXwsLiDpWvQTDTklHoWcCcONBMLyv+gzhvodH+QXpAa0HJtkD2gRjOo8wvSo2ZZyABK06B98PJ60QygferswK0toE4OaBAJNBgAWnUBGkwAhT2oMwCekQdeXwgazAJ3RkADjUjBDivPkGmU8gXWUQX6FzQTCjpUDjQ4AbqNANQRU7cqhl6tCTvLAbrlBagPlE9gM9GgDhhouT8DeNaRn0HLrprhwcWFDKDODcQ+aEpEboyD3Ankg7bWgDqhoME+YTkr8E0IINXPgfeqgw5iA4X7HeCyftDyfVD6+g2+2pKJAeRecFgD7QTla9DZBeAtFcA0CFrtA5rdBnV8QAMooA7YA+Byb04+GfDtIOAtFbCAQOkgkNuQRisDkAYAQAfvgbd9MEMG6sDnZvz5Cc7PoLQByk+gztpn4P5t0CqPd0+OM4APNAUtPQf6DdQhBB3mBxpIBsU9OB0BT4IHr6wArmSyjljPAFoV8xaoD7R1AuQ3UJoFlS/gMAGfPwHcIw7s8ILSCDe/PPiAxR9fX4C3CYBWUYEOAgUNnNnH7WEADaiCBudAN2iA0i/kcErE9Y0M1OhQIdUD4H3393YzgMqxO6emgDvXoG0KoI4zqAMOGkgCHVh4F3h1IchvoBlqTn4ZyJWQX56DO6yggRDQihHQYBgonkEdelCegHWO4YMwQHsfnJ/PAFqJBIoTUL0MKjdBg0egwwcZoGkSnDT+Q1atgFdrgVbZAPOIGHCVAWj1CehQWFCZAdrzDyozQHyQOaAyBtSRB622AK0oAF/TCEyPoLIINNgAGkwADWCB6jdQHgb5HVR2gMzSdWoFDgivAG9NApUBoHAG5S8t+1oGkHrQyiRQngQNFIHSEPiGBOj5BrAl/6AtVSBzQfkXZC7k6twghst7qxhAZ0SABsNAZRDoEECQ+SA1oDi+vKecAXRrgYJhEgNogAm2IophqIPRzj/DKBgNgcEWAqMDACTHCONoKmaAdk5o2PknKpCx2g+JH1hnCXZgD/h6L+AJzKCKHH5QFgMDAyNeP0A7NQMa4zA3UC/dYfoZ0ikELfsFXx8HnMEAdSo0bCsYXtzdBd57DZpVAe8/BTZ0NKzLGSD3RDMygDqSoFk055QTkM41tzgDaAnj399fwLOVoKvzQIMGoIYTqNEDWpYJaqCB4gM04w/a2w1Z/s/IoGKazQAaLAAtzQTtjwTNjoAa2g+BHZif394ygK57gs1MqgE7RE+vrWGAn8oPj0ek8GKEnPANaTgyg5f2gq+XAy6pBnVAQHtrQTM3oI4JKIpBjTTQ6gIQ+zuwQQveMoJ2QBk87Bgh+6zBfEbIfneQ2aCOP2h2FNRgBrsEJAftcDCgdJbR0x4jA74BAEYU/4Gb0Qyg5fSgBiKokwY6TBHUOAfvWQcuXwd1YFCXyaOmZVBDFTQDBpqlBDWOQZ1f0MwfyO/g+/hfXWUAzZyDZvxAZoNWc4Bm/kENXpD/GGB5B7Z9gRHN/SAuUA0ovsC3RQDZMtph4EYtqLENmgkG3bEPGoSBDFgwMLx9dIQB1MgGzRiCZtZBHQfw7Cgo5oHXGOo4NjGADpsEuechcPYP0ThGzxsQPujmAtCgFei0b1C6AnVYQHkfNFMO6syDOgj3z89lAHUIQB0U0MAPaIAK1PAGdXBAM3AvgNfCgUIbpAe01P3gQieGG0c6GFSBgwSgcwRAZoAOaQMdnKdmUcgACv//sJsXIIFEXOnBCIkfEAlaLg+aDQUNWoE6pKABTFB+gRwk9pmBASlNguIeNCgG8hco/YIO2QPNwKpZFIC3NoA6E6C8CxoIBXVUQLP8oI4uaEUFxGGMSNR/BtitHY9By9DB2wUgg02gWUnQjDVocA60VQC0T/r1w0PwKzhBaReUF0FbNEAz3MBTKhhAS+TBNwoA4+7J9bXg8yhAHTzQ1iHQgATIvSD3gDrHqIFEjVk0mL+gQy5MoMPXzBlAnURQugcNVILurQcNeoA6rKBD4kBXGV7aVcIAOo0eNKsNGnQCLRUHHRwH3gMP3FIhoewKTsOglSmgzi3Iz6B0AcobV/bVMIAGEkF7xkHbZn4CO/a6zsDO5OVl4HIKdtYCaDn5b+hgAGhVC2hwFHSoHWgGHrTqBdQ5BZWT75+eYgCZBVoVABp0Ag0s/IcOljFQs0OFVAeCQg20BQG8eghoB6Rz+58BlDdA+9xBcQ/qZIPKFj3XLoZntzaD4xV03gF4JQDwLAhQ+gOtqAJvtYEdasoIHXhihNQ1oPQCGlwBbVsCmQUqj8EDhMC658+fbwzaDvXgayVBdQ6o7AOVxaDBFfDqjP+QM1Agh+f9Y4CsKtIH06D8DDqBH3wGjao3uH4HrVgBDTiC8hFotRFoOwAoPkHuBQ0+gNwJ2k4FKh9A7QXQTD8oj4FuPACtDgDlH9C2t/fPz4CX/YNWdYDLHtAg33+k2xr+wwZn/gMHT38ygOpAWF4FDe6AtkKBBkg+AstW5NWIoLQPCm9QPMMOgvzw7CwDaFDy//9/KPmdULwPytn/0c4/wygYDYHBGAKjAwAkxwrjaEpmpF0YMDIQaTbBzj8wmsCdNEbwgWWgxgLotGrU+5UhdjES9A+s80TPuIfZSd3khq3zz8AIaSSDGmOgRjlo1hZ0+vQz0En9QOtBM1igBhhoDzh4CeztbeD9rqDGL2gGB9R5BF2fBJphA51wDVpCDepggDr+oGWNoEY2qHMK6iyBaNAyYsjJzt8ZQGaCfAjqpIM7JUC3gK/LAzYcQXs5QTNuIH3ghhRslgXYCIbtTwbrhQURrBMK8g9wlkhQwoAB1NgHzWCB3GXoOZkB1LkErTYANQpBS0tBhy6BBixAjVDQAAjskDhQZ4sPeKUeaCAAHBPghiss/hnBqx/k9WIZQI110KzwP+gVTqAloWA/Ad0KOWBOBXzaNSj9gUMZag5qPKB2VhggAcLACE2/iJl/NHVQrmnAfIZHl5YygDpeoFkt0AAKyI//wVe+YelMwRrjoCYmcHYT1PEHdcJAgzSgWWdQAxfU+QV1QEGHl4Gu8wN1/ECdbtCsJ2gpNGj/K2ifMGimDbyqgwEyKMGIdIYBKCxBtzmAOuygwQpQ4/0H8AouUKMWtEoENAMGWzoLjl+gf0GDQlrAk9Nvn5wIWX4NdCPIDFAj/SHwXAlQwxvkN5CbQZ1MBkZEnDAwIPIMKOxgjW/QjDVszzFoiTqo8wU6BAwUZ9xCyuBlyCB5yAAI5Eqwv8CZYdCAE2hADDTDD7IT1GGQAh5aJwdcFQDp3PxjAN1sAOrsgQYYYKeCYzTaCZUvSH4AxTVs6wZoRhA0QwjqsIP2ZoM6VgwMmPEJOnQMlFdAeRfUSTq1LpoBlJdBe/RBHe6nN9YzgPwB6iiBVj28Be65hh0mB7GaEbJKBZo2IXvOoQNUjJAOG+QGAEg5IapgB14hAd76ALwKD9QRBqV5UMcW1LkH5QfQQAJoRQd4JhS41B+0QgJ0tSZotQ8ovUDOTGBm+ArbBkCTTgLMX0zgayBBZQAzcPk3aMARlB9B6RM0Qw9yN2jADJTn2TgEwEu0QeUGeA84sLMGSnOglSqg8yqeXl8PPdRPH3zTAWj1DGhfPOg6PNCgH+i6OtB98qCyEVTWPb6yHKwelF5AWyhA+UfXpZ0BtO8bdMgfKB4+A7e7gDq/oM4h6Iwa0GAPKC2C4tQybDUD6MDHNw8PMvyD3XxBi7BCSaOQ1UMgIVC5D+pUggYvQHUC6MBG0IAF6HrAq/vrGUBpDzSIowm8rQOUxmDlMmQp/39YUQZOX6DyBHRGwD/olYqgNAOqP0ADZiAzQatXQBrAKyeAA76wsxhAeULNshh45d4BBtBBmOAtScDDN0HL5V8BV6KB8gRoAAY0WAya8Qed68ErosEAqntAM/igQRyQvdzAGzxAeQvkRtBEAKh+AtVnoDwBGoQEpQFIWQYpU0B+AMU7aPALNBgDKq9AAz8gN4KuuQRtkQKXgcDzH0ArEsADIP+RV15B/A9yC8iPoLQOqnNktcPBW+YYMFa8wPRC6P/wwYXRJufgDYH/o5EzGgJDNgRGBwBIijrGkZ3UGRkZGBhpEwbQeRriwhenGxgZkGdKQctoQft3QZU/yN2ghimoswrqJEH6WEgdOkYGBkai/AbrZNAiHGhpNgMDqp/BPJggeL87aDYEFgaQQ/dYwR1dUEMKfGgRsMECmkkBNaTAy7CBJ6GD9uGDZj2VjFLA18WBlud/eHkBvOQYFN4gfaCG9Q/gyf+ghjeokfvh5SUGUOPnP/JVboyQ66ZAnT1QBw006wLSD+6wAVdugPakw+48x9YJgqUfSCebCbx8FjSzB2rgs3MKAZduyjKAOnSgjj54eTpwhQLIftASb9CJ1aBBDlBjEXZoF6iDAjrUDGEXUtxAO0qgTi3o+ifQUk/QLQagDi5oXztoiSco/ECDC6DBDlBDH7SnFHTAF2hJKGYih3ZUGKD5C9rpktOLAa+qADVMQaeyMyDlP0YGRF4EDdSABreeA7dhgOwEdSIgs/T/0KxiRIlvBqg9oEY4+JaGz8/Bgw7yQHtBnUDQagjQgWagwYV3T08wQPbRsjCAZtZBZw6A/AY+/Au4DxZl3I4RElagLSCgQSFQxxS0pxjUiQU1asF7W0GDOf//MCDfaQ6eFQOmicfXVoFn82ANZJAdoIPFwCeCAw8KA5kJSY//4P5B8SjcXywMoMY9qPENGrAAzxiCDpwEdlpBbFAnWU4nEnzgHeSwSpAp/xlg+9IFpU3B+/lBZQYofEHbI0CDRKD0DBqsgq0sAM2+gzp/oFUByHudGZADBVfZiVLmQOIHlAdBy8DBVzoCTxsH+RXUIcWW7kFikI7SfwZQBws02ALq2IKWq4NW8Vw92ACOLxE5W/B+clBH9T/8qkmofUyQ1SzgIRzoyhZQ2gBd4wdaIaJomAie9QalOSZmFuA1hfcYQPaC4gGUZxQME8CDXKD8CbIblMZB+en+hfkMkMMfP0AGYYHL5UEdZNAACmiJPPhAwX9/0dIo9RvUoO0boFVKoC1HoAEJUEcMlB5AnVuQHCheQWXfR2C5BT4F3qoEuI1mB9jNkBnZv+Dy7P2Lc+CwBDkYNJAMGiwD5XPQUn1QHQOaPQZ1EkG3cIA6l6ABOUk1HwbI/vS/DKC6CJQnnlxdDU7foA4j7KA3UNiCVmmA3AQ7KwM0WHDjcDtwJc53aD75z0CNGWBGXIPsjIj6EBYpsPoAtFUGlMZB7oMdignuqH9/D7y9QwV8XR5ouwAorYJP5IcbAKlXQQNsXvn3GUDbe0ArLV4/PAwua0ADLqAwBm09AdXL8gZx4HMYwPnxP2wAgZlB372H4cTqMKS08p8BnNeAbgYNtILSLiefFHhVFGiFkRRwaxqovGEEpldQPQLqhG/pk2JQMEhkAG1lAJ1zARpoAZcNXMLgFW2wMgB0uCcbcMvPl/f3GEAH/L24s4MBVLZDtgNAyhxQWSQkaQwewAYNZoJWL4HzFaxTD+/cQ25VAZ1fA0oPjMDVYOAbTZBXDqDnAIyBAaiCoTiTPqxn/0c7/wyjYEiHwOgAANHRxziykzoj7fzPyECC2TjdAev8QzofoAYHqGEMqshBnVPIoWGMDKAljKAGFqjjBmoAmActBu8lZ4A3NhiJHAgAJQeIXYiZR1LCiBK95CVFrLP/YG9Aus+gRr950BIGUOMGdMIyqMMOOdn6P+SEa+DsI3iP7NtbDOCl58DDmEB7/8H7PJ+fA3cMQI1CUGP4L3RvLGgQBrS8E7yXFTijDu6YAsMaNLMCajjLA/eggzrHoNAANQTBM8TAThpoVgnU2AStRgB1LGD7SLH6HDlNQDufnDySDLBD5ECNfRAbNFsHWnYKWn4OWW75F3x3Omi2DbwUFHiQG6gBDxokAHVuv0NnqxnQzAeFFmi2CtS5hMzsKTOAOkagcAANXEgouzOADm0DzSzqOrcx3DjayQDaQw1qdP7HuOefkQHWEQfNNIM6FqB4Aq1QAA1GgAYrwPeAI80GIXf+IdEHSXegwRJQxwx2LzYsrBjRO5mM0OES4CoJ0MF4IH/8A/odtLwYtJQXsv/3L/hMAPB93m+uM4Bmwb59eAiehQRtdQCdXA662g10Dzdo/y54SSwjbFAC4h5FgwTw0udnwPu92bmEwPupIfulkWfJYK6EdG7AS1hRlr3+B5+4ruPYzADaCgJaDQJKSyiDR9A0DBsgAeV9UD4HpS/QHd5GXlMYQEvaQWEPOnwLfHYA0K18IuoMoJUooBlYUBiBZ4SBd+aDXA/q9IM6JaDwB3XEQLO3oHACLQcHXxkHvD8clFZBnX9Q5wDUKQLN0sJm7XAXU9AwgocVPJYYEPHFwAAyF2Qv6LBBfMt6IWkBeG0mOy/4wMZ7Z2czgNI2aLsN5IDNi+Al2qBBKfCeYgakTiQ4mhgZQJ07UHiBtkuA9ptDOjuM4BPMQQMRoMEbUHhLafgxCEgagjtLoHQOWg0B6gCDZlTBK4SAeR5UZoDEQGeAgFbHgG8QAG4BAHV8QWkElNfAHTdoefsf2T0MpDWo/+PoXKCXc6C8Deq8gtwJGqzjFVZhALkLttQeFJ+6Ti0MoIMnQWnnKWjlE9BsULkBSlOgdAAaPITVEaCy8fO7W5BBTGBaBZ+RIajIAJr5B7FBZR9o0AtkLui+fFB+AZkLChvQQBYon4O2eEDMg/n5PwPoxg1QOQfSZxW2lgG0cgM0Mw7xJ+7OP7nLvrHWu1gHpEBFFDMDl4ACpNyHnssBCxPQOS+gVSqgwV/QYXmQMu4/A2SMkgl8owAobYPv0geurAEN/oAHs4B2QdLLL/CgG2iA8Q1wWwls9QAoHmGroEBhCCpL3z4+zgAaeAMP5gHTC2jVEqhcAKU3UIcdFF/aDg0MoPMbQGKg+gqUVkHmgFYM7J5hwAAawAYNrkmqeYEPqgWfrQBcLQUyF6QWfOUiMG+AzgYBnT0DO98CtIoFVH/wCqkygNORiBp4y5qySSZ4oBY0wAs5OBASp4h4gZZtoLIfPPCJtG0Amumxp2US8wOJ+YeB1mC0888wCkZDYDCHwOgAANGxwzgyUzJGQ5W6wUCtzj/IVaCl3qAKXBN48BWooWARsgI8tKBolAru1IJmY57eWMcAus9YySSDAbTE8ynwPnDIrMZHFI9BGh+kDAbAm+8MqAMCjDj49E1OODv/4ICDDQAwMICWuIIaS6AZE1DHExRG4D2aPBLgpawM0AaMsLQ5A2hWHryEF9hhB+1ZBTWgQLMc4CWZwJlaUGcfNOsFmjEGNaJADUhQBw48qwZcBgpqqN09M4MBxAfd0Q7a7wqKQ1BnC6QOZB7ouifwbCszGwOoQYY5CwoNXzCF2JcPaoiDBg9Ay+BhM9Hnt+cygGbT3zw+At7fDurEgpfKQzvX4D3Xn56Al7WKAk9iBqUhBljsMULSgoF7PwNopgs0iwRa/ikOPGEdZAeo4w5aogtqIHILyAOvq7oBtgM0qw3aUw9a+gnqYML22cNn85E646CZKvBSalYu8AwhaLb2988PDJAOCGImDTFeBvE7PG7Bjff/DIwwRzMgGIj4Z4QOODAzgA6WA6kAzdiB9ueDlvaDrvYCxT/4ruuPj4AN3Qfgfd6cfLLgQzRB4SUiZw1eDQDZSsELXgaPSM2QchJk34cXF8FLvEFpBtSZAXWqISdbo6d97A1dRMfnH8PDy0sZYB0myD7o/xB/gOMHOqDBgBjIAg3gqFkVgRv4oK0LApIGDKB9/CA3g+INdEo3aCAI5BJQ+gZ1ZiH3skPuIQedwg9a5gxa6QK6DhE0Ew4a7AGpB81agpa3g+ISNEAGWhEAMht8JgPUPaB0yshIbJ2Bqg6mD9mf+EoLcCoADsZBDpP7ygDa3w7SC8qTIP+Cwh9+td3//wyIXRqM4FlY0BYG0AAQqBwErbb4D92+Alni/xU8AAOaQQfNlIMGESRUPcHbTUB8UEcIVK6C/A9yN2jmFdTpBXWEQCtJQJ1u0LYb8KANuEOA6MiS03H9T2KnAjkOwHuqgWUVaGAPFB6gwQ7QrDNomwSoLAOfxg68cQIUp6ByD1SXgNIRfNUOMKBBeRt0zgcoDYHSAWjWH5RfQPfLgzrvkD3q/xiM/WYzgK7LAx3mBlohBTIPvAWBlQPcWQSdcQHqQCP7B3QOASjeQPEJGiAADdqA0iZ4sAvN3/+p2NnDqIOxDAKAB28+P2MwcO9jeHhhIQO8HAY6FpQ3QAMs4LIddGAiUmIFhQ1oYBKUHkDhBQpTUN0CCjfIPvr/CLMYEPvdQW4C3VTy9eNDcFkIqitOr49nAN2Z/wO4UgkUf6C45RFUBm/rAg22ggYFQLP3oEFpUD0EGkADpT2QWlB9AFrJBrreDzRoCaq3QB1/2MAM6OwA0GAhaNAQtAUNXI8B/Qa6sQK0zQGSv+8xgAa3QWeXgFZZgQbZQG0JkBhoEBR0kCoDtC5BiR94uv/HgDzogz8to5WJQ60zPdr5ZxgFoyEw2ENgdACAqBhiHHkpmQ4df+p0/kFRA+2oA92s59IJvnoINPsF2q8ImvUFNaBAnbt3z06DZzBADWXQSdmgDiWowwVeWg5vUGHGNfJgAPGN+sGTZLC7GcmfjLCOE2SvLGj2HTS7C5p1AfkC1NABL39m5wfPvoAar6A9l6AOEOhKJVBjDtT4A82ugjq8oM4T+FRy4PJQUOcV1KAG7REFNbBe3tsDnhUGHcYE2ncJWX77DXySNPhAP2DD4dX9PQygRhpo9QDowDWQuaC74sHXbCE1LGD+gsUPqPEG6oSDDkIDNUpB+2xBs7aga8pAM1SglQigPeugq6lAtwCAGpKg2SrQvlFQIw808wTqyIPcC9onDWnkQjqakA47EwNotQLIzd+BWxpAM4QgfaAZRtDMOWh2+OuHe+A788GNdmC4glZTgPaPgpapgvaJg89NYGBggHdZwQcVAm9cEFJhULcuYwAtWwU1EkF+ATVozQIXMYDOV2AEn3ztBF4ODL+LnYGBAaVjD84K0LiEsmG9PfQBANBsNSieQHezg9wEmg0F7b+XBu5xB+2lBQ3YgLdLgAZ3gHtcQfkHFJ6gMAItowYf5Ajchwtb1s+A5BYMNwHjDDSoAw7P/3+xZAw85StGQ5LArBgwzEFxAep4gjpkoHQKimfQknTQXf6gtAQahAC5/+LOQvChcKCVDaB9xZBr3CAd1F9Av4HCDjQIA1ka/J8BtJ8bNGgAOqASNJsJasCD9hCD4he0tQXUgQZ1REBxB74FAuzT/wwMeFc4YS9vIIFERL0D7ayB/ARKy3AdwI4IrPOPGDT7j1jMwggpfUErcUCDYtxCSuABK34xXYbvn5+A98yDwgjU2QeFC+gwOEiniJEBlO9BK0Jg51+A0gzodgVQRwsU7qABL1CHEJTPQGLgA0PR9jPDO0hEdhT+U9ChQC3//oPznoHHROA+/FUMoHIB1PEH3dEP2t70FnonPWyVB2zrEywMwQOL0mYMoOs2QQOUoJlkUKcdNPAHKmdgM9qPgQf/gdIJyO+gMIUc/PaXATSLDMrLkIFQ5M4vcrb4D55hBoUzZLsMIs3/p9EsL+FBAMjAIijdM8DTNXhIBdypBcUz8uomSJhD6mXQgXugMAD5GzRAxABdSQbqLMPUgcQQ51IwMoAOzQMNHoPKb5DcI+ihlKAyCnyoKHDACzRoBxogBYUTKB5A50+AViNABiZ5wPUMaKAGNBANGlwF7dkHpU/wlY3AGztAtzCAzAe5HVRngFaAgMp+UL2jaJQE3ooAqsdAKz7uA1fWmPrPZQCdYfEZuCJKy7EBfEsOaGsWyA7QYDHIDWB/oKxqQY1XGI+kzj/DEAPDtvP/n2EUjIbAcAqB0QEAomJzhA0AMNLWvyR1/EHxg9c9ELdCOoFMDO+AJ/WCOmKgihzUUQM1zkAnh8OunQLN1oHsB810gSp20GwwfMkiPC3g9/9QGhDAPWCBOQAAGiwBnZINauSCZg9f3t0Jvq8Y3BgGLo2GHKL4ngEy8/eIATTzDV7SDQw30EwZeFYHGFfgGRfgVVegBh9ozzRo9gukDnSKNOi0dNCsOahDLK7kzADqLID2WIJPmwY2nKTU/RhAnRJQowq0PxckDl4WC9y3DZ49gTsbxIA0MEH77kEzOaA9vqDZ7PfPz4KX3IPuaZbWCGAANcpAnTNQvIMPFGQEnTfwmwEU/6COH6iRB+rsQAY8gCehg07oxmjEQOwCLVMFzWSDwgeUhkD7TUFL7kH7eUEzi6CwAs32g66rA4UT6JA4UGcQ1FCFHXgI7g8C3QCSB7kVNEMG6jiClqaDBklAjUMZzWAG0CwgqMELWkEBmqUFzdCDzAKpB133B5pZRKw2gSZe+GAOLKAQ+QOighE8cw4auADpBx2qBZrlBh2yBXI3qDENvjKOEdLRAw1kgOIRvH0BuF/7P3QFCGjmFH5IFUpSQrWXAe4eBgbMDgJsVQMjAyP8wEPQzQ1MDNLAqx9h+6PxFtGMEP/AV1QwgG6muMkAOYX9FXjFB+i8AtA97qDwBR0cCLvWDNSB4BKQYwCd9wDukAFnIMGpCrgnHmQnaEYW0jH5C17xABoYAw0ggE7dh1x19xE8OwlbrQI6bBA0uwk7IwPibthyX0h6xVwdhOk7jAEUUlocjMiKYatBEHECNhs06MTAAA5zUCcMlJ5A+Re2vQK+0gKYB8CrgIADeSB3g1awgMIDNOgBinvQygjQ2RegvAMKK1B+AJkHyrugGwJA6Qg06wsJd+jM/39opxHDT7gb1/+p0KFAHQBjgF+VCZoJBt+u8OszA+jAUZBbQYdegk7kB+VN9D33IHNAKz1AB7mBbsYApWlQHgGFHfhGA+AKItCZGqAD8SAz1Q/AM/6gdAeyB5RuwDP9yNtcsPoPFF6QtPOfTku7UepljDoXSzkCi0NGyIAmmIuU/kCz/ZBtSQwMoLQDuiYWVJaB/A++dg90OwrI7+CswciAPDsuDawHwIMtslYMoHIPdgjlf2i4gZb+g7ZZgAahIHn0HwNo0AWUB0GDlKABB9AAH+hQTBmtYAbQdoDbJ/qhq7L+M1w72AjuwIMGA0BuBA3sgtwLGugEDSCAVrWAtjSAbrJ4fnMz+AwA0AAg6IwIUJy/vLsbvBIM5PRnt7YwgLZ94O78o6Ztkjv/RKT//4Nl+f9o559hFIyGwFAJgdEBAIIxxThyUjOsMU1DH5Pc+Qe5hcgBAJBSUCML1KED3UMMPrEXWCGBGmagRipouR5oBhg0UwOqMME0+CA6kM7/DCh7vRlgDXbCgTEYBwRgbsLuerQ0De2kgTqooGXOoAbT3dPTwOEBanyBTr8G78EHzt6COmqCwH3AoFlO0BJLcHMe2CgDdbTBKwJYuRkgB+8JA08i5wEv7wc15EB7WUFxA2rAge6uB822gWYNQQeVgToLsOWgoE6xqJwN+AooUEMMdD0WeBks8MA4uF9g6YER0nEEXecHmskBzfKA9jODDxFkYWcAzXDfAZ4mzwHdvvD37w8G0GoGUGMNNCMNmqEUBs7m6QOXtYJWhIBOvAfZATtUDdysZYR0UkGDI6D94KDGPcgf4AOkgCf/gxt9wP2joFl5yNV7zxnAe/m/QwZKQAMPoGXBsM4vwulM4LABhRt4plXFjQHUsQIddAW6ngyUNkGDJ6AGKqhTqQPcowxayi4ia80AEgN1XD6+voIavbDONkqeYcS+SgDYCQQ1jkHxAtoiAVoOC+rEgA79Aw+iAFfLwA61Ag2mgRutsFlcUCcOa0MPuZPLAM9PjAyMSHmLESkakdnMDOAluMDDtyCd95cMkCXpXxgY0Bq3jATKA1AH4Bfw4EhT//ngQ7pA1zxq2dcxgAZTQJ0MUIcNtFIENMgC2jMPXrbNAOlsgcwGHaQIOlgRtLwY7FhgWIEGfUDqQAcHguL55tEuBtANAqBOL+SQwJfg5cGgTgkb8LwD0CAWaIYY1AlmJKEKYcTR8cJfCsE6GEgWIZnDCE8PsIEW2KF/DAygK+xAq2FAN0eABvhAHWCQ28Ezz+AD+hgZQLcJgFbUgPImqIMEyo+gE+5BeQl0wOW2iYoMsjrhDP+AV7iBwhWUx0EDd6BZcdDqCtDd9qBOFqjTh9KhJtBZ+E/lzgQjUrkBGvAAdfhAg4egcgs0IAkqt0ADfNaRGxlOb0hggG/BQA580AAYMFwge/ghS9ZBA0qgchO8vQc4eGQTtRm8zezVg/1gM8C3VYD98g+c5xmQ8hG+eCWqU4ccRoyUt1UoHgSAu4ERnG9B+QOUX0TkbcE3poDSBWhLF+jmFdCWCPCsOTA8QGUf6AYVSH5jYBCRt2MArUQCqQUdsAcqA8Grd4DnSYDKA9ABlaDVZKAVPqBrPEGrdByTDoNn7UGrMEDmgswElWmgrUigAUDQYBQojkFpXMUshwG0MgE0oAqqO0BpGVTugPIDaEAa1PkH1SOgOgg8sA10GDMbN3hwGpQuQCtcQOkcXAeCVzX9Z/j//x+W6CS28z86u8wwaMFo3DCMgmEZAqMDAHijdYR1/mmcxGnd+QfPrkGjDLRMDzTqD5ptAHUKQUsKeUU1GUANvo+vLjG4ZpxnAJ3GDKvcccc0SAZfOsCURx4QGIhSg5FgQxDNP/COI/D+YuBMO+hUY0in6z+DmIIDwyPgctb/0IESUGMJ1EEFdapBDSTwHkrgckrQYWqgmX3QMmtQA9fIezrDy/t7wQdAgVcJAO0Adej+//sFnjUFHbQEmn0FNbYY4Acj/QcfngfqgMIOegMNNIBn7dEbV1A/gtIUqPGtYV0OmcEDugXUwAN1WkGHtLFzi4OjADQrC2oY2sZsY7h/bg4DaN8v6DCnR1dWgK/z+vX9DXi/+mfoAYewWXrQoBBo9grUOQXNKkEarP/BV0yB/AXrpII6DuDZLqA7fwKvsALNsIP2kL8EniANWbKP6KSB4wc04w20BHQiOuTOd1YG0LYC0Owj6OBK8CFlr69BB1A+gu/bhsw2/mUA3aIAuqoP0rFjYIDNfsM72oyQNMnIiDjdnQGx8RscHiA58AwdcG8/KKzBS5mBAxqgBjKoIwPu/KB0wGADZDB/gGhGRJZjRLgDMRsPSf2EBwAYwbdNgNIUaM/trx/vGECDTuCVI9/egGeqQR02ULiizsgi5z0EG5b+QX4CLVUHHSwG8iPokDZ4pxLoN3BaBQ8u/IeGCcQPGsCtGKBD+EDxCdrCAurggzq+oDQFutsbNPMLOhwR1CFW0I9jAN1xDzpEDzy4BDxMEbRyAdQhQT65n5HIzhnxAwD4GqXQ/I2UR0BxAir7QDRoiTMoPEB2gQ4MBB2Q+eD8PAaQm/kl9Bi4gGkCFGegzg2o7ASlRdChlqABQiEZC+D9/i4MoKvvQDP9oIADdZpAK11AHWHQwBSoTAXtqQcdoAayA5QXQIMDoAEV+FkEBApG0jr/yGGBv86Ghe9vYBqzCF4GXsr/E7jvH9S5ZIDOLt863gdfrYLNHch9XJBtyqaZ4AMYQbPSoMHBR8DzKkB39oPCBbRSBtJJRDv4DcfgBt5OP6kDImQMCBAzAMDAwIB76xFS4MCYoAF5Ped24E0BsxhA9+lDBpGegw89BB10CkqLoPQC2bICiUtQugRtmQKvzAGWS6CbA57d2swAO0MEdKYIqJ7g4pdnAK1cApWjt09MgMQbsEMOKj9AB7OCBrVAqznA53UAyxLQZAAoPkD+BA0ggAazwId5Ag+wBLUVQGaBz77485MBVAeCDsHUcWwCDh7uYoCs/pIGnoPQCzw4eCUDyhkOsLhBLzOR0jnuNI0nL4/O/jMMLBjt/DOMgmEbAqMDAHijdgQMAIBqaUba+5NWnX+MxgjQL9YR6xkge7O/gU+sBl2nBtr7B3IDaGUA6ERw0F4+SIMDuieZEdpFgnVkMNIFrIOBTsMUYhen52AAzC4GUtM0ckcBrQEDmvlDzGz8Z9B362EAnQrOA9wzDFoWDjoPADSTDOrsfHpzA9xZA3VUQfvFYUv/we5iYmEAdTxAnQzQ0nxQYxtyVR1iSTDEnn/gq5zADWFggxx2aCAilBkZkCGoA65hUw6+tgvUsIPMYHIygGaMQB1c2In4oAYkaBnpsxsbwI1Q0KwQ+PRnYGMRtC0BtI8ffHI3cAABnKYYIMtaQR1l0GyPgIQhA2h/P6hjCGoYgjr/oI46SC0LOw8DaMYZ3GD9+hLcmQUNNoA6nqBOIUg9JFmBOrpM4OvaQHtVQY1h0GnVLMBVEyD1IP+D3P/tw33w6dKgMALtOQd3yIGNYFBDGtSpAHU0QAMuDDA3gkIE1NkHnhPgmHiQAbRSABTmoA6ftkM9A3iFBSSjMMD0gMYDQAe/gTp2oFUWoHAErcoArS4AL/PHMesOaryDOpFM4OW7/xjAV6u9v8MAmnUH2Qla0YESfmgDDwxI++EZGZE67UBNoDAF7+UFphVQYxzUwQR1ukF2gjrjoJlE8I0DDLAxD1i5hSi/GJE6IKC09vz2NvBeYPDtEv+RBy+gKQos9h/uLNBMMGhPuKSKJwPoMDCQeaBzIUBhAznIDjiLCwwbUGcAFFevHhwAD2ixc4swgAYpQIfkgQ4bAy1FBl/dyIAA+PIn/ryLXj4T0yiF6mGE5BZwnDGxMsjrx4CvTwMdjgaKe5C94OXVQGeC8oCUmi8D6KDU71+ewx0O6tCDrqgD5UXQWQqgA92uH2oG5zkTvzngtApaig3KI6A8BZrlBe1/B5UDoI41aMk8bICNgYilyoQ7/6Q0yjHrNlASAQ1k3DrWwwC5lQI0M49sJpZ0gnaOAyM8eBkZQKujQPXKU2DZAsoXoHQLGigFHYYIKgPBW39g6QwUqmidOoIz/f+p0AkhoY4nZhAAOZ+BEwpSOoMkHEbwIAFo4BS0WgS0oga8MgS4lQycx4GHusIO7QWtkgGf/g8s75HDFRR2oA44qAwHbUeDnQEDuoMflN5A5oDKZJC5oLwKGtAFrV4BmQeKA1D+B5Xp4BUezOzg81MgZxX8YYAc/veNAbSyC3KQIzMDaJUCTA/otgtQ/gCVuaA6EDQICNq+ARpA+ACcQPgCGijGm5ZR44yszj/DEAL/h2NHebTzzzAKhnUIjA4A4IzeYd75p2PHn6zOPyhecDZaUOMGpTEC1PPk6ioG8Am/wEYbaBUAqDEAmn16eW8XA2gfOuigOsgM819Y2wUyowtcNgxuiIPtZoDPrMJnWMGdLOC1RsAOG+SQN4QaUGOGETqry4jD3ciDAYxUGnRBNpNwSYUjTUPdwojRWYNUgMi6QDMkoCvwQIMokNnYfwygq59A98iD9rGDltaDO6zAxhxoFgbUSdJxbgVfkQUalAGtHoB0SBGVK8R8EB+pwsXWoEBOs3A2IwPoKjtQ50RUwZEBdJc3eDkp8Mo60PJQyMns/xlAnRwWVk4G2PJ+ePCDl/T+Ac+0g6+WgtkLNR909zMP8NowUIcGtH8VNBsK6sSAOkuQ5fKc4M7/P+jKBvAsPbCzDj5jAriPFTRTz4CUnkBpBBRGoJUNsL2roBOmQWEGkgOdKA1akg+SB5kBGlgBzUh/Ai73B3VWXj3YB77mDZ5wkcIB1FEGdXh5gddTgQYeQB1S0H3+ILeCrpODDZwwIKU90EDJ/bOzwPtsQTcbgK5PhOy9Z0BZtg9SBxq0AB3MBdq6YRm6GrxyArREF3xQF6jxDuy4gzq/oIY7uKMHcxsj/o46yD2QtMfIwCOgCL5+DpRuQEvuQWkK1KgHdTylgOc5wJbxg/IbIlghnQ3UPMUI6dRD4xdrxxM9jQG1gK6lBKVl0OCghk0FA2gPPMgdoAY/+JA9oF9AKxVAAxLfgaeRg2eNgYNIoJlE0HWCIDVg/wPt/QMdTGJgwCyviC8LyOn8w0oCRnAcMoL3/AMPVgMOEIHyLKhDBsoP4E4JI+g8jL/gmVNQRwq09QR2UCWoUwbaRgOapQXtjwf5A9RZAqVDXeCMLuj8jgfn54PvtwelU9DKFJBe0JYCkDpQfuLklQRvu/kH3S6DfQCA2IY2NRrkkPCEDHT9xbJsm5AdjNCsB6IZGeT1ohlAaRXkX/DKCaAwKH2AzhMBlUmggUHI6imouUhpji4df+RKgcg6h+QBAFj9AU1n4KFTRkj4gNIKqCwCb4MCriIDDbCBBlRB6URGM5ABNKAH6oSD9tZD0gaoPFdjAJ8nAXQ7bPUUaMANfH4H0A7QKhPQFaOgLVyg8hm07QQ00AS+jvPHR+hgJBP4qkfQNh3IYZVCDKAVa6CbH0BnnoA68qC8ABokBR0ECbq6FTQpAB5wBA1uAu3mF9MCD26Brzp9d4cBNuDw5e1NaJEOy5vkpksC+oZKp3rYdf5HO/4Mo2BEhMDoAADOaGYcvgmAkT5+I7vjD27Z43IjpjgjtLHBANUHVgFeiv2GATSbCursQxrn/8BLNc0CFzKADnF7ATzkDtQ4VjJKYQB1ZED3BIMGC0CdPUjzhRFlthm0D1vNqpgBZB5s9gw0MwhqeIAaNqCGBKixB77GDjgTzABtJuBKSOidAPyzgFDTGBGdHdIHEXCEKVJ6YMQxYwtRwgjuy3x9fxfsGFgDFrYNADRDo2CYyAAKVwZw+L9mAB3kB2pUiSk6M9wHLjOGnZQNnhWH+gUUdqD9oOpWJQygGVUGBrTBAPRwROpQisrbMLy+vx/cOAN1TkENcVBnGrSMHDSbAwojUMcY1BkDd8zAEcsEXiEAvpYPNNP5H3b91H+0pa2QGXvQrPuHZ2fBd7ODZrQ+v73NAB4E+PUVbC8rpwD4qjTQbD07pxDDN+BBYCD/g2aKGJBulwCFE2ibBGgQAnSiOqiz/Ovra/CgBOhqPdAd4aBVFaBGKUgc1LAFH2QJ3J/+7ulpBtDAFWw1BqRvzQjeYgHqmIO2aoAay6DzEEANVXElF/BtBNzAa7JA4QIPQnhegaQjUAMdtD8etBwetJID1DFEWaYN7cSDwg7UgAa5R0jGHOxmUKcPNFABmv0E+Q3USQeZBxoYAbkBsQUBnDFRsgE47YJvQGAEz8ZBBtAYGWCdZ+AyCgZ1y2IGyLWSDAyg1Rag0/ZB+/NBM4KiwD3FoIY8ZBAKPV0zwjILIuUwoqnB2hH7zwBaWQGa4QYN9IBO9gYtHwbN8IK2qoAGlEAGSqp6M4BujgCVGaBDKxFLl0H7gP+DOyCgwSIGqgDCZTX67CIjUv4Ahat1xAaGF7e3M4DSE+hQM9AqBTmdCAbQ9gXQ6ffgLA8KD6C+/9C8ACoLQQMvrMDVLaCVPeBVIcAr3kCDB6C8BOrAvXt2igHUkQJ13tSBW3BAHS3w2SDANA2SBw1EgVcFvDjHwIA0A47PR/SbKcVWxpAWYaBwBg3egdIoKC2CZvpB6RN0WBzowDuQOOiGBPCqpz8/4IbTveOP7i1G/GkKo95GUQ/RC09j8EFvJvC2Kn5RbQZI/YDIgyC1kmre4CX/oI49qBwBlWWgW3lAA0Og9AgZMGQAlwWCEgYMkGX6DAwoA0agtAnEoAFR8I0ewAE20Mw86DYfRaNkBtCZP2C3A937C3yd42vwjRWMwA49aPsPqO4G5eO/wOX9oAE7UD0BKqtBg7SgtAtavQFaxcUNvMIWFJdvHx1lAMUfqE6CDUiA0jFssBLUHgDV/6ByCRLE2DuOmGmaeh3MAT/8b7TzzzAKRkNgqIbA6AAA1phjHJ4pGtqYp4fn6Nv5B/mIkQE+kwjrWAKXGYKbEMDZJ1BFCWqIgBrmoEPBQDOt4BOEgQ0KUIcONKPHBFwmCLoGCrTPFyOMgGaCZq5BM2GgxoOBxwQG0EnA4P4ksIEhpxPJALorG9Rw+YyxPJC09IRrYID0Dj+yL/C4AamBhzkAAAlbiN3QMGaEdNpANyuAOp2gGWbQtX6gjiN4DyW0E2EXuxPcORdFOkcAvNf8P+JkdNAMDmj/NOjANFDjDDSAomlfA16mjJlOkf0A6cBClmn+YvgHPCQQNEsNatRBrkT7Bx68AS1ttw5fzwC6Gxp00jPIzZBDu76D79cH8SGH9MEGARC2guMBOKsNShMy2qHAO+UvQFYQABs9oLg2C1oC3Ju/Cdz5Bx0OCEoXoAMUQekIfHUcuHHECF1AAgo7JgZQeIF8ATq3QBC4rUBCzYvhzeOj4IYvqOMJmj0FhdE/6GFXILaOYzMDaF8xeNAEmtRhq1JAAw2wveaglQ+gTjxoaf/57bng08dZgVc3gtwEWr4KmmkDNWRh6QvmU5C9oA4eaMYXdGgbSqMbmjbAbgbubweFLb+oFgPoyixQeINWGZxcG8Vg6DUZfGgfaAAGNIgGOkPg+a1NDKDZdOTBHoTdjAygQw5BM+agfebgA/WADXpYGucRVASe6XCQAXRtGMh/oIMnOXilwKeJg24uuA+cef6PcqUgOCcyMGAMYEG2coD9Ckvn2Dr/yA1ZIBs0kAG6Dg80IAGKV9BeY5AZwsDBjzcPD4OvrQSlLcjs4G3wNoD/sE4u1kYxqXUKIwP6ygEGLABXhxmWX0Fhe3V/HTgcQQNL4E4ScCUAKB1c2JHPADobAxE2IDuBnRNg/gR1sEADcqBBDtDgHCifgZZTw7ahgA5JA+UB0AwuKB5B6Ro0mPDt4wPwICuoEwgKO9DtGJKqngygJdWg1TiIOMPsBA3IMmlSOjBoHWdQOQKqQ2AHx4EGR9h5xMCDIqCOJS/wak/QPnPQChlQfgd1Hqm6x5+BAoBnEAD3AAAiDcPSF2hQDH4+DHAwALTyAZQGGBkg5TOsQw4qDyEDjccZQIdDggf2/oNuXAHO2P9HXE8JGjQEdehBA40mfnPBZ5+AxEBlDmzL2OuHB8EDBCB7QQdLgga2QAOXoMEA0HYs0IAyaFWGgLg+cOHTD+A2pUTwif2vHxxkAG33YgJeIahsks4AOqcBFCegQSqQflAZ+R+8muc5A2jQGiQHWtXyH7x6hYEBdOYASB/o5guQH0DtCFCdBxqQhA0KoA9ek935/z86C81AdzAa5gyjYESFwOgAAEZ0D8POPx07/gwMSA1ucrMS1sYJ9ngBN0Sgh52Bl7rCl7uyMIgArxACHdYFWooJkxNVsGMANdRAlbq+ey8DaK86qAMKurIJ1OAHnQ4M3o8IOgEbGm6gzh1sib9j0hEG0IwXqLELauyATp5XsywEHnA0hwF0/SCokQxq5MGvfBs0xQmedI1tAAAckTA90MYcsOEkrxsN7liCOn+gfcSgmVrQbDvkJHXQRB90Zg3YgAFdMwfqJIHCChQeoBsYQEuCQfc4w5Z7gvprkCsAGRhAs2mgk5hBWzhQls2ihCGiYwRphEIqbVCHExR/cF+C+9vMYJ0gu0F7yjVtq8AnUYNWaICWu4PShYJBPAPorv6/sGsGQekXOoAE1gzt1IEOfoM5A5wegA5/D5wBBTU6QbOeoH38oAYiSA0oLMDLw5Fm/8GdOaC5IHsgtyH8ZQAdhAgaXDD0nAg+SA60NBaUTkXl7cFLT0H76kHh8Bh4UCED9JR6UHipmueCD2wD3WMNauiCViDcPzebAXRHNyiMQVstQJ0yWe0wBlCjFtTYFpa1YADNbEEOOfzPAOlcQkILkodALkdfAQEODLC3EZ2C/wzgQxkZQUvKWRlAh/aBtnWAzjMAHbjFLSAP3hMN2nJgFb6WAXTWAmgQgwFqCtxeUJoDdjRBq2ZAnXzQ6gfwtWrAfMfMxsUA6liABpZAM8mqZrnggRdQXgY12p/f2c4Av3KNgQGzn4zeUUNego+3LISmpf//wR16UAcAdFgc2Aro9h/Q/uNPr66CT/wHnZwPWjEAWiUAvuueAQtAcQuxdQs+dQg5QnvlwVYD/QJaXQJaiQPqlINWZ4C2WYDSBGjQBdThefPoMHg1AOS2jX9Qv/8DD8Lpu3Yx3Ds/BywGWuECSuOg1QSwuAEFPqjsBOUh0KoJUKcflA9BgwPgeAc6ApTeQWEppeHHANpKAUv/DEQBKjXKqd2hgqZf0Aw2aFAYVOaD0jCoXAMNqIGWpIPSPiicYGXLoOn8wwsy3OmMET3PMKBmNNgAAOiQTNDp+qDtD6CwUDXPA5en4Jl54Cw8ZLsRxJ5nwAFBUD0Kvi2BAZHXkJ0DWq0CGjQB5SlQPgOV2aBVY6A6AlKO/AcPlv4HbzlihudTUH0OOowRdH4H6AyA/9BtOVp2tQygMvbLh3uQQTrgNgQ2DkFg+fqQATIY/RfcTgCt4gH5GZSGQStcQPUJKK2LAa+qBdXpkJtQ/jKA3AUqg0ATCKAyDzQgBhpwEJazAp/tAjvzhYESMFQ6/8NqkGK0888wCkZcCIwOAGBE+TAaAKBzxx/SRKAw/Bhx6ccUhzVCQJ040AwDEwsHA6ydIiRlAt57ChqhBzVQxIHXrIE6U6DbASCN1KcM4H3swIY9qBMF6miA5EEzZJARfQYGyGwlcC8hcOYRdGUQqGEB6oyBrrwCLTkE3R8OamhAZhL+MYA6QKDOH6Tz/5+BgazGPy3KIDxxgiW8GbFsAwCFBajxA7q+CdzABZ2a/OUF+BAtUKPuP9KsPnimC7oKABTW/8AH2P0C7/cEL0cHy0EGFUAdBVCHHBQHoE4KaFBFzaKQATTDCB4kADX0cKQJRmzhC/UqSE5IyhTcyAOdxA0yF7S3HdRpA7kfdPI+qGMEusMZdPo+A/jKM1jHGN4kRUQGI6yf+R+8Xx603QHUeQUNhIAau59eXWYANfZhh52BOu+QZa1IYc8IDdn/iCvnQMtOQXtZQWaAwgk08wU6sM7Efx54cAo0w4/YagFJk6Alq6DtC7Al9yC2qKIj2F2gGTDQ+RegWVtQpwy0wgJkhjrwZHvQQVkicrYM4CWrIGdBywfYLB2iIQ5zMyMD8qoaFWBHHLRcFzyT9/gY+LR4UHqHHJj1GOx/0LYG0BYaUCP6+e2t4P3RDOiHZTEyghvLoNlzcSVX8B3boHwKOiQSlJdAA3egGWrQqhDQUnvQqhIQHzTbLAGcTQY16EH5VVY7hAEyC/gKmu8Z0fIc2mAkI2pcoOY05A4JamMQlJZAWyxAq3tAnRHQlgdQeQM6VwQ0CPbwwkKG/9CrwBiwNYox0im2/AiOEAZiZv1xlxDojVgIH3TKPSh8QWUiKK/B9lWDBoxAB6dpOzSAl2eDtreAOkKgTg3Iz6D8cff0dLCbQANToLITlIZA9ht5TwOmzzUMpqB0en0t2P+gmwBAcqAl3qArV0FhAd4KAjp8UC8GfIUaaMb8B3h7FMyt+BreFDbK6dFBYYRXOeBtZKAVMe9fnGcAdVjhqx1AA0q4Dowb6E4UrrIVzwAAvNyFDryDtuNIqHqBBwZBh6yCV2ABO9qglUiw1T+wdA0bDAGZgRjA+s8AzjfAsADdygIqF5SN0xlAW0xA9QNoVRKonIUNXoK2GYC2UoHKc/DAPlAfaBUAaCALUu5CBqJBZQTo3J+vwPNg5LTDgatQjMC3V4DiBjSICRqYBt0SAuKDDpIFnZ8COnQQtIoJdCUsaKAalJZBeQc0MQAqd0DtA/A2P+BZJaADT0FuBa3uALnlx9cXDAz//zEQnz8ZKAIDuvx/2HT+Rzv+DKNgxIbA6AAAStQzDp+EwEh/v2AsHSQnNBlxNY5RDUN0/hgZPgJn5EBXWYGWoYMbXsAOJ6iRCTmZnJnByGc68Oq3ucDO4CcG0HJMUMMD1BDV9+hnAC1RBTVSQIeaPQA25P/8/Ai2CN4pAroH1CHRdmwEzrCuBy8DBC1FBo36gzoCHMAln6BOEaiRDTlF/QkDuNGD1e8Dkb4I2ElwAACiH7w0E3iNEmh2Grx3/vMzBlCjDtQJBW2HAC2xZ4Au+wTNQoM6Csj71cEdSdh+USbQ9XTM4M6aoeckBlCnGbTMG9RwBO07BnWIQY0vcGMO2tCADMYg/MKI4W7Uzh2I9xN6hRxoGTpo1h7UYQN11EH3/gPvdALv9wYdKAXyG/xQR2jsY3TEoPaB0sWPL88YQB130Iw0aFAEdN83aHYU1DgELbMHLWFFSQOMqB1TWNoC+QG0+gS8vxrYgQSd3i8gaQTe1w9avvryzk4G9GXujMDOFKjBDdqrCpIDDRqAT7EGhj0o/EB+hhxaeAc8iw7qiIGWI4NWtfz59YkBdIAfeicVMQAAi2tYZ5QBPgAAmjkGDSiAZt5BN2qA3Awa6ALdigAKO1BH/g1waS54Sez39wyIhvg/SFeCEWIWLB2Alk2DDtPiBF45B1oJAeosvLi7C9yABq1aAA22gTqPoBl4UEMetJUBNEMNGrwBrbi4c2oScBZegAF0aB+oUwE+RJEB0uEH+QeGUbIhepoBpkfQ6gvQVY0Y2RXWwAW6G5SvQWkEtLcbdLXjC2C8gAZ7QIOAoKvHQIMAoHNBGPCdCo41vcLCmdRyAZt63A1ZUFiAtrqAOifywI44aIsKaJYelC+MfWYyPL25ETwzD1oVANoyAFpqDUrfoEEu0M0LIH3gGf2fnxhAeR0UF7dO9IO30IC2poD2d4vIWoOXZYPiATSQA+pcgQb/QOergPIF+Oo34KGJoIET+CGRSIH+n5odChLNIrYjhbN+g0YHaJBYxSwLfN4C+ABIqDuwmj9YOlBEDwAglw0M4JwGysugK/JAdSh49Qgw/YMGg0EHd4L44HIGVvYxQnIk8ooA5DIcPsgJNBlUh4M61KDVBKBO/dunJ8Ert0CHAIIGGEFX+oIGBUB2geojyBkVfxlAh1UauPczgG5jAN3K8Rt8qC8TA2hVmZxeFMPNIx3grWKgfAoqs0C3qYDKKdBBwdcPtzGAlvaD0jaobAOtPlAxzwGv6gOlfVCZBNoGA7r1BDSIDSqbQCtohKHnoYBWwfyHDyJDEjZqmiayozkUOtajnX+GUTAaAsMhBEYHAFBbiEM/TtE6G/TyEM7GESkOIKPzD2pQyOmEgwcBQPsBQR0qDl4JcOcH1BkCLTkHzXSBOoC2MTsY3j8/wwC61gs0WPDu8XEG0GFEoIPTXtzaygC6AxvUgBUG3nUN6tCBZolBjQVQYwM08w8a8WflFATvD5TW8AffPwzqDIAaEB9fXABfX8fwH3MvOcOApTHSO/8gpzKirABgBK+EAC31B80IgldIAO+5By2LBDWgQA0h0D3ooMYcaBk06N59UAcAdKIyeB87sLEACh9QY0wCuAoDdPo26ORsUKcBtM8YdNIyaPAAfPI4cL89aHkweP8wsLOBbVYefSAAa9hCG5ughhw7lxADaMk85Eq51+ABnCfX14H34sNOdse93QDUaEMKQ6i58nqxDKCBD3Ba+AY8aOrjY/BgAqgBCFo9AmkIglyG1OgDNZqQ0jekP8zEAApH0OyWiJwNuEMLGlQApSHQTDdoKwS8sw7N1yD/g8L8L3AFBngJK3CmDWQTJ78sA6izdnV/LfiAQ9CsFKjhC+rEQZbsMzDAbmcARS84HBlA/XsmBgbothlw3DMidf4hAgzgPbhiOgygMwYggw6/gOMnv8BBDwo7UNx+enMNPCgCcgNo8Ac0EAJKL+BrHIGHx4H8Ae+UA+378PICA+gAPVDnAbSNBjRgBxpUA90wAepAgFYWgAbreIVVGUCrNsAz08AzCEArHECzrKAzO+6dmQ6+xgvUuQSvLGHEk95R5CB+BHUgQPkWtFIEfKAgAzTOUDpu/xlAg1Og/fOgDt7752cZQGEKCr9Hl5YAO71vwafgw9MQShyjuYfYshmmDgcN2c6EXOJC0xl6wxzqFlD4gAZNwLdBAL0IWikFGgAFnVD/6PJyBlB4g8pNUPkJvl4SaA7o3A5WDgEG0KoA2A0VoEFO0ADS++fnwVeqgeJL16WD4ebRLvDhneDD3cCDr68YlAyTGUCDTqDy4t/v7+CDMUHmgNSA4g/UocJfNZAxM0dCx4TS2VOM+g4Y1aBOL8jPoJVgsJlgDHsGY+cJS75hRFsBwAie7UcasIKWhW8eHQLnB9BMOKiDDBqMBNWvsEFF68hN4OsiQeU7YiQQspIJNFwHuqsf3CEH1ZvgsIFcswlaXg/aagJKo6CyDnY45U9g3SMNvA0EtKoPciUoI7hcA5UvoLIGlH5BZRSoTIXc9PMbvLXs4aXFwGv+7MADXaBtacqm2cBzAY6AbwYApVHQgDDorJRX9/YygAdwge4BbeMC1WGgczC+A8t4UB558+gIA6heAl3zCZ5MAHb6wTcdfH3FAF/1hZGwqd/5H7DZ/9HOP8MoGA2B4RICowMA8JhkHNpxSmzjksq+hDfqqWEuRkMENU5QO39QOaAe0IFkApIGDKDOJagjAeqAgDoWoJlq8D3x1qXAA8dEGG4c6QTPqII6JqDbAUB7AUFLB8EH2QFPaQZ1/CE3ADAygGaGYQc3gWalwQepfXrMAJplBVX8oFlQ0KFWIDnQbCxoeTBoHyJoRhLUkAbtAYU0grAFDD3SGhF2MGJXgzwAAFpCrm5VygAKC9BSb9C+SNCMCGivJGivOaihBtoHCgoH0CwgaIYYtB8UdJo9bAUAqAOlaVfDADqETxa4FBN0iBNoZgfUaANdUwebkQHtgefklwHvbwcN0IAPiiI5qCAaQGlFVNEBvA0E1HkDNRhBDfQfwJULoMYoqLEIuhJKyQjUUTnMALlWDrmhht5og6U3BvCVgqDlqKBD/EBL9989OQleXgpaug/qJIM6Ovxiugzwpc5YOmagMAYdPgVyE0iPKHBpPsi/oI4RKA0+Bl5lCQ4/RshaBOR8BjtfAtQIBF9TCDzpH9T4Btsrrgtedg/qnIJmYY28pjKA9tSC912DZugYYI1vMAN8YBtoqT2ocwjJX8xQCxkZEMv/mRhAp8YfXeHPAFoKD1qOr25TzvAVeDUWeMAD2FgGDWSIA/fLgjrIoLQvpuQEkQfe+w050BBiH2wGEHQQF+hwuLfAsAPdeADqQIPOLQDpBYUpKP+BGuWgxjVooAY0yw7qtIL24oJmkUEHjYFmsL8BG+agszfgs23oaRqlXIR1YCBhAF7+C1zxA+rQg2YdQdsPQPEAshPcwP6P6FhDThV/BS4/+ITVGbSAy+ZfPzzAABuEwXkYHwOWBEygg4+rKAWnAWBHTNk0CzzACbmuEUfnH9kQoBNAp9ODBtZAqxlAnXjQlhjQqg5Q3IDCD7StBD5ABNT79d1dBlCaYmXjBd96Air3QOkOdhuAjGYweMAHtNwdNPvJDDxwFVQGgs7CkAQuB392azMD7Oo30LJq0GGDoPgD2QfbT03VqoiOnX90dyM6y//B6QFUrlGn40/GIAgDmXULWr5BrQMgs+iwQyDBA4gM0PIBqA+0LQw8+MslygC7+hI0Uw6+BhGY/0H1LL+4DjgdQZI+I2TQEcgBmQnKx9r29eAD/0BhCynrQKz/4HoHHN7gQcr/4BVC74E3ooA65aDBRtANHZBtUv8YQGWcIbC8e3JtDQNodRF49RSwbAKV1aByBVRP84tpM4DKf1Dd/Qu8QoyBAXw14d9fwPrpLAMofcLS+M9vrxggKwn/MIDqKFD9BDoTADQxwAQerP7BABusBuUnyLYPyBaA/8Omo4yU2kc7/wyjYDQEhlMIjA4AwGOTcWjGK0oDl75eYGSgYphhdEYRZmPO+sI6Y9CmApALmsED7+MHVvigmWnQXmpQBxXUQAdV4t/e3wefOg662xs8s8oAmf0EdVhBlTlodg98RR3wMDjQgACoIQPq1ILMBO31Bi1/hlxv9pkB1CgGdYj//v3BoGySAZ65BTVK7OP3MNw7M4PBLGAhw/0L8xnwLglmoGV6I8JsRtxqUBt/jOAGE/gkdiljBvA+YgEFBlADB3TiPGh/Nqhj75xyggEWrlx80gzgQ/k+PgKHAagxDJqRATWMQZ0P0AwgaNYY1EkGmQsKf1DHEtSwAomDGmuQ69+QG8Co7kVvYKFuCWAEr1oAn859ext4bypoHygrGw/Dd+C1f7CT/0EzVaA4AnV8QB0kUJyDVi+Ab4fAmpUgbvgPvaYQdEI0aF80qHMKCgcObnEGcCcJOCsEWnkC6ljCDq6CGIfkByATNFD0H9jwBDWCQSsUngNXoYDcpAQ8oRoUphA9WDoB0LgTAA4ygNIhaPACNEAFaoyC/AZa+QLq6IFmrECdf3A6ZGSATsAxgmf0QQ100MnXoHveQTdYgG4iADWO1YBX74EGb0AuhaUDkPmgQwRBeQoURqBZedCMIGi2HjTQBoprUByCDtcEHUwIMhe0nBa0lQN0vzZogA7hf0jcgNID7CA58IFawMY4aN8t+MwCUH7++BDYyVUAHtBlyQDqYILCB3JOgB94tQX4kDHg6gvwIMl/xK0SYHuQO9gQAQao7xkQZQkj+IBEkDtAe9dBbgelR8jAA/o+XmCMQ1f2gMIFFMbvnhwHnmlxjwF1xQ80ftHKZEgphYMEdmxAYYeyQgIt7cF0MkD3XIM6/qCDSOHnDqBtPcDW+QR1ZsBLm19fYwDtoQYN1IBcC1ppAkrD/6CrNMBW/4f4FzSj+eX9PQZQOQc7oBJ8GjtwDz+o4wXqUIE6UqDVMKBBNtBgFkjd++fngKsmXjNA8iikU/wdejUmyJ+gGzsgK1v+Q60jp6OLFEhEdkzoM2uK5BeSOkwUhgEDLkBEXQDSim8AAHhrhAZwEBhUNoLKOdCVnOBzX8CrjxjBK+JAZcBf8AodXnB9ASoDYIeigrZMgcrBn9/fgAcVQYPykHNfPjMIAAcsQeXf3bMzGGCrJkArg0CDcx9fXQJ3zkGDhiA9oPIMNEAKWY3ADC7LGWF5DbiFCpQfQCv1/kKvXASt+pNU82GAlD//GEArfUD1C6jOBs3kQ84j+Ae+vUdExhI88AwKCtBgMTMrBwOofgPnM5A/gfn/L/BmFtCWK1DdBMpLoDwFKmdBfgXVX6CyBLR1ADUmiIzXwd65Hu38M4yC0RAYbiEwOgAAjlHGoRmvjAPnbnp0/rF3/BnBjQjYAXuM0OXLoMpeWiOQAdQIBXUOGKCHx/EIqzGA9g2CxEFLXUEH+YBm+kGzE1zAjiyoMgfNYoLkQTPZoNPWQftgQQ3UP+BryZgYQHvHQbOOsM4caB8wCzsfeF8iZD/wVwbQckFQwwO0nPnJ1dUMoD2I4H2QoMY5zniCdLOom/iISBME0g0jyhYABgZI2HwBn+iu7VAP7piBZtJB+x8v7ipmkNEKYbh1vBe8P/jh5aXgvcCg5f0wf4HM+whc8g06MR7UUQXN3oAGVkz95jA8vraKwdhnBlgPaBAFNrsN8wWYZkSYRCiskAcCwHecA9PBH/B9/Z/Ad8yDZihBAw2CksbgziBoySrkUCcF8BJ6UCcclAaQBxjQBxcgM+MMDCD/qwBnY++emgpuvII6hqCVEaAOLahjDBtgQHUzopMI85a0ZhDDvbMzwTP3oGvEQGkTnAYZGRggg1p/GZDDElJkMTKA7nQHuR20VBs0QKXr0s4A2iMPiq//0EYrqPMPaSMDD94DXnP5/OYmBlCjFdSZBi3vBh2gCZrxBvkZ1EkDXXf4DLgnHGYHpNPJAD48S1jWkgG0uuY7eGCHEbw/FrTqBrQ3F5T2QbPGoMYwyE7ISoufDKD9uZC8yIDofAPzLKizD9pSA+pAwmaEQXkM5IavwM4/yAzQQBCo4S8H3Lf+8t5uBi3bavAAG2i2DTQ4B7rHHjRwAfEjcoqB5SvIYAdo+TukA4uUjhghakB+B50DADonQc+tiwF0cCGsYwBR/Z8BfS8vyG8g/J8B23YfpPyHPBABZjOhrK4AhS3oekFQhwOUDuHZjgF1sIABqhd05giobAOdu6BpV8UAutscFJfgKycZ4K5FJDdYox3spP9Q4/+D4xAcJ8COHWiZtKS6L8Onl5chUc4ASics4AG8/9AyFNTpFwJuiwLFDWgLBqgcBB/wBjIfdNo6cEAANJgFnokF7YMGd8b+objjP8M/THcxUAEMqs4/0D9Ed5Ro1eHHF6YE6gZovYBa/kPSImjAB7RqCzQQB1rtYeo/F3xzCUgWtKUElJfBgzvAAU3wliHgVaGgsgu8Gg5Yj8Jmx5mgaU7RKIUBNDMPyn9fgSf0wwbvwfn+x0fwYD3oLApQ+QTqVIMGKkE+Ay3FByVk0CAEbJAVNIAGuiYUVKaBtq6AyhMuATnI1qGXl8AHjoIOmQXdLAJaTQSq1z8At/KABgxAq/lAeerbp0cMsMMxQW4BTR6ABsZA9cXvn58ZIKsJ/oK3A4EGP0BnYYBufwCVdyA58GCqiAYDhE9i3JLYuR6w5f8MQxn8ZxgFoyEwGgKoITA6AAAOD8ahlS5gDcsBcjUjtWevMTqkjPB95wyw+IHOfoGW2IMaq+BmCUgMuBQPNKMMOtzq0ZXlDKA9haDlyqCGBejANNByZVBHDDTTAKrguYHLpcEn0//5yQDaWwjaq2zsO4sBdKcv6JA0UKcI1OkQBM52wxrWsP2qsBk30PkAn19fZwA1bkCrDUCNI1CHSwh4IBBk3+J78DkD4AEEWBzh7XRTI/0ROZhAxKARegMQtpIB1Ol6eHEheG8vqBMN2rsP6lyBOgagmZHHV1YygMIbPtsHHvwA3p8MnHkHXecEChvI9ouHDKCBkuc3N4M7V6AzBEAHKYJnkoGdVFAjCnQYHuhARlADDXQ9IKjDxQDtyBC+/gy5Ewbpc4HOeQDNVIIGH0B7OEFxKSRtDt7LDuowMzKzMoD8CVopgC1bIQYBGBlgg08gf4IGgGDhA1ryDJpBBs3AQ/ZbIzo9KPpBFjBCGtYgJmi2H7xHFhhe4EGsT0/Bs1Ggk6dfPzzEwADvyDFCcwNQL/AgRVBHGXT4JSgdg8L/6fX14CX9oL3/oI45vGgD2gXaowtqMEOW8H9lAF1nB+p8ggZcQPvgQcu9QZ3JO6cmY5SI4IE4YMMddKAb6FR+0J5Z8NL7z08ZEEvloR1l2OwxrBMIdjuo8YXolIPCD9RY1wPuH3//7Cz4JgnYHl/EzPB/Bjm9aAZQ7L19cgwcHqBBAJAe0MoCef048N77D8D96Igshoh3+OAhsIwAdR7AB0ICExAo/YH8Cg59ZhYG0FWJ98/PBV8rCOpoKAL3rsMHQFASAupSe4S/saYWFEHwjCUw/OR1oxhAdoDcBipjQDTIb6CtKKAbRbAEPANioJOZAZQHQGZpAQfhQDOdoDh/A7yNARxmjAwM8I4Btg4FUnqDJj8G0IwmOP6BnSR4MQseAGBjAA02gDtJwA49KK+ABlFBg3egFTyQZd6g69iYGUCDMaAl/qA90aDy8z843rGEFSxE4G6jQoN8MHT+B8UsPwOJAE99gzwIAK1zQSfug673BK2WA630AJVzoGX2oAEfUDoWV3JhAA0CgDrZoNP0dZ1bGW6fmAjuNIPyGWiLAKjDDpoxh3S4pRlAS/6fA7eJ8AE7zaA6FFQ+fQMPLDKAl/2D9veDDpMF32QCLOtAcrCDT22itjCA8g1kD/5vBtCWE5C7wIfHAgcPQSsPQGepgM6hAeUfUDkKWrkAWgUISrug7QqgvAKaEADlJdCKFVAZKgS8KhU0KAFahQQa5AIdCAhaIQM+9A94Jg2s3gHVU6CyCDx4DF0ZBAoLyJYchuEH/g/1zvNo559hFIyGAJYQGB0AoOlSbCqnuQHu+IN8Q7fOPzBeQIfH8QgqMkDu8WdkkNWNBC8thezLA82KMjKAZkqVjFPB9/ArA5dOg2brQUuYQY0KUKUOWtqrblUCvkdcDqz/DQNkhvQv+LR10PLiZzfWgxswIPWgQ6pAM8agve2wGQEGWOsY1MQGNnBBywdBZmjZ1zKADsECLfv/++cbeI87aK/7U6B5kNUCaPFPcBCAkYwEQ2THHxx5hM1HiV+4exnB/RDYLA2o0w9aNg6aAQHtHQYtnZZQ9QDeJR4LPhgR3AmAL0v+zwDev/32JgNozzuoQws64Z5HSBUc/qDGFigOYIeQgTp8IHX/oTP3oNPI/wBnhEBmgrZpgAcCwKGEXKlj+gvS4WaERx1oqTxodh6iH7gsGTirAxokUgJeNwXyHOhMB1gDFDUSoJ1upLBgQGkkw1T/B3fUQTOdoGX9DCgrP5DNgLkJMQAA8jPMeFBn3MBzIgNoFQn4nAQGWOeZgYEBbYYOdObEtQMNDKAOLmjVASgMX9/fzwDp/P9ngOVX0AwZaPsKyL+gjhrIfZ/f3QYPsoHOwgB1BEH5CLT1gZNPigHUCQaFE/h2AUaYKYwMkFUwXxlAs+mw67wQYQVS+J8BUZyC7P8PD3+4OrgfGBhAh3OC3Ay5GhIWn4gZd9DAGqixDprpBjWwQbdxPL62mgHUKAeFDWi1BmRmDhFGkI4/E3ggBJQHQec0gPL957c3wKs0IOnqMwMkzJmAnQdv4D3hx8H7k0EDTg/OzwMPSkG9zcDAgNl4RJ2BQ08fMJ8ywu0AzfSD/AlaegwqJ0D5ATRQBLmb/x4DaCBK360HHB6oh61Bwh6WPkD5DzQbCVrBBDrsTFjOmgF0bgEizxJo6DKCTQLHESO0LoH4k5EBxge5DbzCBdj5A5VvoDgChT34IFXgIBkoDYA6V6BbGkB6QOUr6KA20AAo6CwLvLchDPWOBNnuH6wdECz1ASx/MjKD77wHDdSC0iT4wNffXxgge90/MoDOaAEddghbvQKa4QfVv6BO/YMLCxhA5TrkirzvDKDVeaABddCgOQN0+9TjqysZQFuKQEvtQYOloPv7YYOAoPTFzMbNwM4pBF6GLypvB972AxpEAG0ZA60yA1/L+wM40A48YwA0UPDg4gIG2IoV08CFDKA6CnzF6suL4MF9RD7+B1EHzFogM0BnVZj6zWUAlTOg1T+gwTQ+EXUG0E0/IL+DzgcA1ffwAUpQlgQNcgIPu8QcBMRcLcRACAz22f/Rzj/DKBgNgeEaAqMDAENhAGAQdPwhTVFG6uYDjA4xojENakCAZiRBB5SBlh0rGCaCr+EDLe8DL+cFzvyDog7UOAF1FMAnegNnskANa1DFLwXc+wcyA3S6+usHBxk4gAcUgTpBoJlL0AoBUMfVAHgFHfjwqq+vGUDiIH3gw32AyxhBM9mQBgUzeAsAaGAAdLsAaPUASFzFLBu8bBvUcQKtHoB0RP4xgGYGUGcz0YKMkVAYQjoOkJ4UjA0zA58cgahhJC7ucA8AgDoJwO0QQioMoHv1X93bwwC6Dx58jSJoFgTYUADNhktp+DGAZm3+Q8VArgJdOQbaZw2agQbdE60IHLABhSO4QwnsiIOWE4P2hIJmNGHXMIL8DwpTkB7Qie+gJZe3gVePoTTEULyM6j+MGXegWtBAA0LLf/AJ0KC4g9wv/Rc1AJE7/AwMDNhWADBCEiADrNeLrAUejkiC8EEJ5I48IyRO4eYD+U+Bh1ghdzwhyqH+Y4QOHDBC4gO0xxW0EgA0O/fl3S0G0PJw+L50kEaoXaAOOyg8YdtYQIM2Umq+4LvZQStqeICn7YPCB7QdATSTC1r1Ap6VhpoBshWUB0CdcfBqBei+e7BrgGqUTTPBy2NBAxHc4EG7F+AtFaCD4RgZoEGE7G8GiOB36KwfAwb4Dx1Q+c8AWxUA2vIA6jSDZr9B2y1AhyXCZr8ZGOCWMECuB7MDD/SBOhigVQugsgA02w3atgEaBAEPKgLjD3TuByi8QHkb1HkFHXAJOnyQAzgQAprdhAwCQldy4GwMI8otZG8gxzdoVvL9i3Ngv4DiiI2DnwGU5oXBS+ufMkBWEf1msAhZzgAaQAS5AWYWpHMOvTqT4T94EBTkd9DMpbpVMfgAStDVkG8fHWVArKBAcQk0eCBpBpReQeUc7DYB0FVq4OsrgSeZg+IYNGACmk0FqQFtmfoLXC0Fmg0F3YYCujUFdBsAaPYVdNAaaHYXdK0giA8qm4WAK6fAp7NDwwrvqgQGCgCRHZP/DBR0vinu/AzWjj+WtIGacMHlHXjA9csL8PW5oNVfoBVAoG1VoEEAyF53YOgCO8KgPfygASDQahxQnQDqMIPKbNBKGtDhj6AVV6B6GVZvg7YRgA/PBA6mg+pc0HkU8DILGOaggUpQ/QAaZAcNDr4F3tYDKuNAnX/QViVQGgfVHaC8yczGxQDvoIM65kAzQQeogmb8QW4E2QU5E4CRAXQ9Kqj8+AE+sf8vuM4HDR6ArvcEn+4P1Asqz0ADF5+Bt5qABiZAK8ZAgx3gVYB40zQZcT3YO9ejnX+GUTAaAsM5BEb4AADj4I9bxsHhRkZaDJRg+A2pIQ2UA93Nf/NoJwMHtxj4IDBQwwPUuAd1GkCznqAZe1DDHtRQBzUKeEU1GUDLUUFioNlM0N5okPi1g40MoFUCR5Z5M+g6t4M76aDlf6CrgUB7AkFLpkEdG1BjBDQroWFbyQC6GxzUqAU1jEGNddB+ZNAJwZCTsP+CZ95Agwv3zs5igOy3hsx4wg6+Qm1iocUhyXEK6SSSlViROoGE9GPEMdydkBlC0CFHoJPbQY050MnND4BLp0Fm6ji1AG9H+AUeZAE1vv7B958j2Qj0AqhRBwpP0MFKsH3U4LvkgVfagTozoNlnE+C5AKDGGOh8AFBHAqQWNJgDmpUEzdYw4G3QI8IZYwCAETr7CXISoi/NAF44DerMwsSQ0zma/2EdffAMKQOyIcgdQJBFUD7GAAEjeGYMPsuLzXx4J5kBah10dpYBm7kMDJD9+wzg5fKg66tAYQWa3Qc1tiGdY0SYgE7eBx8YCDxzAHSjA2i5P6hTB2ogX9lbxQA6GPA58NBE0OwZuFHOANk3Dk8XjKD+JahD/g8RFNBwAOU3UP4DHd4FutkB1HiW1QkDroo5A+5MgDqJoEY+3DWMiDSNyA4QMQQfdVUAyE2fgYfYgQYyQHv2wYNusPQAS+eMkPACrYIAdUxAfgEtsQcNboBWE70BdpJBgwKwcAOvGAAuMQYdAmkC3NcMGcz7Az7hHnSgIXLDnwGSWnBkI0QagK1CgE61M4DC7w9w9hTU6QHdVgLq2IBuKAFdZwYaaATJgwZVQEuowYeTAfMDKA/BBldAKwhAnXTQjCRocAXUuQJ1jECz9aAtFKAtM6DO0Jf3dxhw5w9G8MAIaEYTVK6BtlKBDgP8/OYmA2gbCSj/gXwAKstAA3igQ9Hun5vDANpLDb4VAbbUGegb0NkLoPgGuen3zw8MIL448NYH0BJo0MoE2HYWeEBhdCTo0zEmq/NPlU7P/yHYZkSUE5DyjYEBVP6C0iQblwh4yxaojADVeaA8BdoGABkg+wqu/0BpHjSYBVqhIwq80hR0KC8ofYIG8EF1LWylAGjgDjRoDhosAq0qAJ1ZAs/H/yFXAEIC7z+DuJIrA2iAGXRGDwPSHfugFQUg+yAHD/5ggJfH4PLpHwNcLbAsgFzZyQRehQBaBQY6xwRkNyjfgQYTQAMJoLMGkAeWwQdafn7OANrqB1phA7rdBSNfoaSToRjfBJLoaOefYRSMhsBwD4HRAYDBGsMkdNxo7QV6dv5BfoF13u4Dl+NqWJeBD28DVdyghqWp/3zwVUuwQ6v0gEtnP72+Au5kSKn7M4A6H3xiWsClg87g/bagQ9VkdSLApwlrOzaBZ9pAp7WDGrCghjCoMQ2afdOyr2EALTsENaZBjRLQkkZQRw3UIAapAbFBAwWgWQjYUnjQ4AFkPzmhu/+xxBCt45cM8xmxdn4Rbgc1+t49OwMeZAGtoIB1nkFnIYBmjkGDJ6C9mZCrlCCNIuSZbdCpyqDw1XFsZnh4cRF43zVoMAF0cBPoxGfIPdoHGUDLRV/c3QmOK5CdoE7bC2DHFDb7gxKaKIMpiEYs5gAAuDsF0cqITR0DuCEJTn8onXuoCHAPN2QvNxMD9k4sTJQR1RxGWKcWJM7EIA1Mo6DtJZBD6SCdVUake/ixDS4wws1gAncmGaB85LwC6jiCBmfun53NADlI8T8DI5I/GKHnZYCW14JmeUH3lYMa5qAOHGigQEY7DLzMFnQaPOh6PwboDD/cs8j+QDYXOjABasSDZtXBNyoAB+xAAw3nt2YxgM7mAMU7aHvFP+jp3Njcjzy4AupYgAbsQDOKIL2g2w3ADXDQDB8DdEXAf+iKDUaITkjsQuOYERJOoNl80J5/UP6WUPFkAG0NAu0HBi9rB5oD6oCAOvn/oXd5n1oXzcAPPZUclAZfAbdTwGcmoYkOfx6BxDWoww4yG3QtGSxuQTdSgMIbdHOElKo3g7RWMLisAg2KgVZNgFahgAY4QR0SeAcamodB5ZGEshsDyFzQwWSggR5QXgPtyweFE2gVA2QGE/cVZCCjQMv1pYHX94HCEtTJB2HQIAkofEHbQkADOCC7QTO/oJl/UEcLdE4EaHUULD0YuPcxgLaZgNIYqCMF6tiB9AgDT1EHLaEGH3wKTTsUzb4z0BmM2I4/cjgjDwJAcyRoRh641B6UBkAz46Cl8qCOPWhVHXjwCpjXjLymMIAO4wRtSQFvHfr1mQF0JSzoYFzQMn7QljrQNYCgsh40oAC6VQc0WAQ6lwN0iOo74LV+kHM6XjPAyx1g/gTXrwz/UVa1gA4RBG3lAg1Ag8/5AZWd4EE/JgbQKhvQYD2ofAPlO9CZL6CyzSXjHNh9oNUAIHHYobYMsPIENogI4gPLgp/Q20XAqxxAgxJIaQMzTSM6/yRd/UdGeqNbfhrSnf9hOBjDMApGQ4A2ITCCBwAYB2eaYkR0IAbagbBGNdXdwYgt7CFiyB03WGUPOq0ftu9UUs0LeJ9/OwOoEQGanQM1fEEH94H2pMKuDQLd0w07sRh8YjXwuj7QjBr4pGqgZ0CNVwkVD/CefdhhaaAZMNASdFADHDY7CO6oABsAID6oUwI6bBA0OwC6gxwcJvAGBAOUS0blA4tvRiqkRwrMwhjkwXAPI6TfBmoQAvddMkD3coJcDQqbh5eWMICWh4KuDsPWEAKpg1xd9g983/N/8PJPNgbQafCgzj14FQXQTNCqDRXzXPCp86D4BXVMIFeUIc8OIc3mg0KeEanzDU2sjEidZAaoGkZsHXt0vYzoAwUgfzMxgGZeQbNEkLuwfzPA9kmDDrGCpBdY5w8Rj2D7wB1vZqh6ZgZQAxQ0QALqDAtI6DOABqHA100B712HmADVD3U/vPMPHIAA3ZP//z9kDyvESwg7Qaz34APxoGkQ6i9GaAcdZA7IrdcPtYBntkB8biFlBtB97qC8Ar6SENxxQ4QzLGhgM24ogyoo5jOBZ8xBbgJflQVcMg46WRt0O8TFnUXgqzLfQ0/dhs0uItwPK10Q5R5oNv7ijgIGSTVv8F5eUJ78D+vwQxunKGkMKd2DDnM08ZnJ8BvYCQF1eEGde1Dn++axbvABlaCzHkAN/2e3NoHT3n/wzOI/BtAefV4R4AoiTmEGTn5ZBtABYuBZQrB9sDBlwATIeY4RklbAA4fAsATdUw6yixF42OB74MAZaEACNIsPmnUHrV4CL2MGXp0Gmr2X1QkH7lXewQBaKQHa9gLqKIH1AtMPKCyVTTPAAzrgThTwqlJQZwbUOQd1yt48PAi+ig3cofmPWDWBcCwkTcFOZQfpAan99+8XAyg9wWZJQaucQKeuvwaaBxIDDU6Azjh5fHkZA2xl08t7uxhAZzGAylXQTSigq91AW4JAA0qggQnw4NP/fwyUAzzlIREdFJI6SxR3eKjT6aDk7nhE3qQ05BlRkg2k/GBgAHW4wYPmwFQImpEHDYSDV6PwyULPrmAEryD6BbzqDzTLD1qhAjpwFJTmQWkZ1OG3j9/LAFoxB9s+AFpxBxokAFkoqmAHvmUGNuCGegsLSAWsfGBkAK1C+AJcuQLaEgRKh6C0Chr8/w48yR80qACqS0DpGrT1B1TWgup20GACaOAVtBIIXF4jp1FovgV7/D90MB++GoHcuMWjbzB3sEc7/wyjYDQERkoIjA4ADKaYZmQcNK7B6BBSy2VY/YjUaUL0OsA2ghqboMYleE8ycCYCtCwVNLMGPjiMATRh8JcBdt2egn48+G5vUKceNJsFanhIawYwwE7nVbcsAs8CgmYjIfeX/wF2TjLBh4CB9gCDupWg8wZADRvQzCXoFGzQwAGoUwtyDKjBgjiV/T9sioSokCEqPNE6EwyMiE4RiiXEqiPCZZDuLlq6wxFHWBuZQK2gjgLEhP+Q2RocyZgRpW3JCD4EEHQ+wB/4CcugffmfwQfggWaaQB0odvD2j2cM2Br0KGEKNhxiAbbZf0gTEuoAYtSCZ+UZGCDL9ZkZlEwywHvcQdsgQMtbQbdNgK6IAp2ODVqlANqLDdqrCgtPWMcbtMcUdP80eLaUUxB87gBokAN2xSTkQLeL4E45+CwCkBOh7gPPYgGvqgTNoIH2tCoDDywE3b0P6kCCOuWw9IEY2IBEODycGRmRVgwwgG+mkNUOB6+gATWcQXu84SsrwFr/M0D2hkPSHWg7AaiTqmZRwPDu2WmE4VALYH4E7fMF6VM0SgWf/wA6FRyUP1lYOBlAd4eDOq2sbLwMoPACXcUFvnUBJY0g0jnITFDYKBolg7c3gGb1QOENT8oYHVzksoOZATRAAzrrA6QetD8dFG6gFUHvn55iAA3egdwA2oPPL6bNAOpAg7YD/AafQ/GDAbSfGDRzDzrfA3TLhZ5rJwP4tHNo2MCWAWPLy7B4Bw16gDrGoIPLbh3rYQDdVgDewgTcSw1aAQCatQcdggnaYw+axQeFBWjGEXQIGqSMYQNveYIsu4ccdMrCygkOf9CKCPDWCu1QBtDeZNAVpqC9+a/u7WUAXQEJ2r7AAHcrAxpgBC+DBg2KyAC3gCgBD0wFxS9oYAbUgWIB7qUGn+gPzG+gMASl91fAqxdBK3XAW3rgs6T/GD6+ugq+thO0pBq00gMUliAzQAMmIH+D0zHMdiI6FNTrvDKQBqjS2aGs8/+fBh0uysOTEaUgAfFgS/5BHevf4AFgBvC1paDxRVDcgwbHmVjYwPkPVOaB0gIorYK25IHOkADl45tHu8HXmoLOEwCZA15JB9wuBj5sD3jAJCgfgPRgHUAGFRHgVVjM4ENOQeWvOnB1IChtgg4yBdXpoHIKNKgF2roAcjNoZSBomwoo/1mErmK4c2oKA+gQzv+w7QSg8hGIQfkSpAa0BQqUH0B64QOODAwMiPIUFCzI8U2/2Wa6zP6Pdv4ZRsFoCIykEBihAwCMgyuOGRmRapmBdxrNOv8MDDj8iRofjOCKmYlB1SIf2ABfzQCamQd1vkGNENAVQI8uL2cANdxBS/xAMxGGwMP8QBX3J+DVfCC9oA47qOMBamT//PYWPPMHOoEbNDsIuroOdsI/aOYNPNsFnFEDNcRBB9WBanvQoXSgGQPQzDboCkHQjAJohhB5mS1oPzUDuJOIaAQwEkhWZIcreoefCkkEa8cfZi6OAQBI9ME8ieZZWJuRAUkciznIjVPQKfOgTgRif+V/hv/QWWiQGPjOeeBVcyj7L5HMZMSwi5EBY5YaXT2YD3EjxkABNH2CwwbU2GRiZoD5GbRcGjTwBLsaEpQeQMvLQWkAlA5BhyKCD+BjhKZxqD2gjj+oUQua1QatYoGdog1qYIIObgMPTgH9DNkL+wcaAxB/gM6yAK2QAHkTtOIFtLwWtIQc1IkD3aMN0QPdjw/rlMO2EzAyYmwXEFdyZgDlE0ngcnjQYY2gvPAfvtSfEbxNBjT7DDn86yX4ZgxQwx40qwYapHlwYT545Q0oPzDCVxYwMYAG20TlbBlePzoEviEAtFwYZC5IL6jxLyJvA77z+9unxwyQgxj/w/3JADUH1DEH6QHNloPMBuU7UAcBpAe0LF/Dtgp8AvlH8JV1/xlQkxYjfKAG1CEF7TsG5X3QiglQZxRkDogNigfwzQYMoHGqv+ABBlBHBXxiOCsHeAkxKC73zjZjAK2KgG33AXWUwfuGgeUEA1I6h+UheDoEhv3Xjw8YQLdWgOwBrewAhR3o+jJQGga5A1TGfP/ynAEyG/8KfJo6qBwCzZSCt2R8f88AOp8BNMgD0gNOo8A4Al2zBu4cATtMH19dBq+MAA2ygMIDNFgAGcjBUjD8R1q9AGSDBn5AVweCDlJUAw6Ifn1/nwG85QOoVVzFHXzA4PXDrQwgd4MGXkHnIsBOR0eYDtqf7cIAWpkDunUFNMgC2voBSt+gPdP///9jGPTL/wd41v8/HTpb5A8EYJbhEJH/SDt1mOCrmUCd518/3jGA8gkoLYBWkoDKR9C1uKDy7QYwPYHOfgGVeaBVPaA0yws8TBZUvoPyKugaP1C6BB8eCzo/hgG9Yw0pD0EDeN759xhAZ/eAykDQoCPoClVQhx6U9kB1OWi2nwFah4AGGkB1OGjwAXQ2zY8vzxhAA2Z6Lu0MoLNOYGekwAYjQHU+aDUhCEOuCv7BACqDhYHXxX4H6gVtV3gPHgjF7PgTHZ9DupPNMEjBf4ZRMBoCoyFAegiMDgAMZKoBtWIZGQdVukXpVFHbZTj9ijkAAGoUgE42h802gfYq28XsYDi5NooBNOMA2gcIauSDnAja4wuq2CFLq7+DTx9/++Qk+I53Tn4ZBtBM2YXtuQygBgeocwNaTQCaWQaddg5aTgjq1LGy8zKATpoH7acF7SEEnWoOWpYLmgEEdXhAHRHY/kTQ1gQu4NJHXtDJ6cCZPdByXNC5AiB9kM4q7jilNHyROx2UsHFGLYE4Qm1Uog8CQDvWOAcB0DveMFf8R+gAK4FV6MgdPcxGKUg3ovMF6QQyQPeEgpZN//31lQEeRtCl+JDBJUboQAHITCyNXaBaUGcMfDPBv9/gqyZBjUlQ3IJWAICuuoI0ZC8ygDq5X4HL9wUlDRnAV80xQFwFaimDr99j4wFf8yau6MQAmq0Cz34Bb5kALZUGdZRBS9VB9oDSKLhjzQhxG6jDD1KrYpoNPmQLtqwVNLgFmql6cWcHA8h/iJkqiF9AHWDY9gRG6AAG2EVAc0Ez8SB3ge54B11dCTnLAjLLDBIHhQ1IDLQtAcQGDbqBltmC3AZK26BrOUFbF8CdO0aIP0EzfKBDNkHnOIC24YAGNUD5BHSwlixwpho0aPbm4WEGUNiBlp6DxMF5BOxcWMediQF0KwHkMM+/wM6tKHjQDuSPR5eXMoA6pi9ubwU3xkGngcNn4hkZGGDxiZyeQWUBaGAJXD4AOwOgsxFAbgKd5QE6QBS0QuHTmxvgDgw4nQDPJgCFI2g/O8gcOb1o8FWIoCXPoJtIwFs/gAMEoE4uxO2MmNkHNrAE6vwCtyuAZtlBqyaeAK87k9LwZwANXsK2uYBWYYDOGAEtlwaVSaB4BC39B2/HeHyUAdL5/wcdwAHHDHjAAORX0BYo0DkaoCXP4PMaPjxggF07iXIAKdaOxn9wPIAHfYBuBJ0XAfIPaDYVdMc/KE2B0hconkErNUCDA6CrFhF7pRHeBg1qgJaFgwaUYGcWQA5TA6YnqnVyGMmqgQgOPgxg5///AHQAyRsIwFIuwke/GBlAK3pAHWXQoBRo1h1UZoDqQVB+AV0LCVpFAhr0/PD8HANooOnGkQ4GULp6++gIA2iwC5TGQQPtkLr1EYO2QyPwXJgFDAxI+/HhkY/klIeXlzCIKdgzgAbYQOUFqIwEdf5BHXPwIB+wzP8H3PIHO9QPNDgGORT1J1gPaOvfreP9DLByE1wMAQ8BBZUZoHMKQOpBgwsgs0BlBagMBJXPIH+CBgRBNwhAnDM6+88wKMBo559hFIyGAJkhMAIHABgHR2IZZB1/UKAMhs4/2B3AsAEt4wN1ukGVMGiEH9TYBC11BYmBliDC9g6COijgxgSwU2UVtprh0ZXlDKAZCFDnHNRxAe/jBZoH0g+atQc1BkAVPGhZMWj5NaiRDxrtBzV+QQ1q0CwAaOk1aHb1+c3NDKDTuyF7cRmh14vZM8BmEiEHuUFmQtQsCxle3t/DgJK6cMQxrFNKbEJkRHRjEVqgg0eghheoMwpaMk+VhE3SAAAk1SAaahDfMxI9AMCIsiIEuTPPgGQGrpl6lDTLCOlMcvBKgmepQY01yGF4DAywDjGowQhaBQKKT9DBa6B79MHWIA3EMUJnpCF7pH+DO6OgWXvQihPQ8vsfX18ygAafQHaDVpKAOv+gRuyPry8YIIdPQTqloM4/KG2CGr2gThVoBgykF3TNISi9wU6cB6Wh75+eMsA6h2C3AjvuoBl30BJxUEMVNMsKOvUetG8c1LAFrQIAiQtKmzKAOmmMsI4wUB9oOT5oiTlo1Qxodg00KAYJV0ZoODAygJabg/II8jJXyAAAJCZBS/DBB18CuaCzAZhZuRlAp9aDl9YC7wdHHqgA7fkHDVaAOtyg8AUfZAccEAHN6IHOfADxxRQcGUBXxonI2zKADu/8z/APGuzAvANc+ssKHCQBDRYIAf0D0gM2i4WDAbRcHnRwn5S6HwOos3F+Ww746knQlgrwIZTgzhS4Cc/AgLQigY1TgAEUz6BwBnX8wcvcgbP34Pz/9hbDJ+AVX2BdwIEeEeDKBSEZMwbYygJQhwI0KACKY1A4gVYigGa1QUuM/8Ptg6QpBli6gecZyOANaFBEy66WAbR0H7RqBHSfPqgjDWKDOqeg8wVAtwF8A1+B+B/cuQeVU6ADNBGDG0wMoIELUKdaWM6KAVQOgu5BB4UPaOXJoysrGMAHKwLLPViHF1vWRe8MMyJlWfB2lo8PGUBbTEDbVyA3nfxmAHXiQKus/kNv8/iPrVMGDAvQgAgoncE6W1jLHyLrOUYC5Q4DtcAAdf7/D4KZX9IHAqC1GVLcQMpHYGQAB7pAeVvPtYMBtJIIVF6AZvtBB4GCyjTQ9hrQ2RTgLVzAshGUP0F5CVRGgG6iAA0Ugsox0OARqD4H3e0PLo9whhNkdRhosAy0OgV0zgBouwno3AnQwCuoDgSt0gHdQgIadICUbdAtacD0C77WF5ieYbcOQPIBtGYFlmmgtgAo/YPqDVD5Byp/QeU5aAsPyEzQwCPo+mDQIcOQc27IOOfi/yDtrP4fqp3o0c4/wygYDQEKQmB0AIDeyYcRtdMzGFIvqR1Skt2MtxHIiGEcrKECvv7nP2TWCtTZAu17Bh/yA76vlwGybxo4kwfb5//o0lIG0B3fGjZl4EYJaOBA0TAZ3LkCNUxAnTHQEmTw8j7gLAFoZB80SwdqxIL2HIOuxQI1+kEzGqBGAKghAdqfCHKggmEiuAPFzMzGALqqDrTkG9QQAHUWQGcGgAYcQEshQR0JFO/i8Ttyxx7W+UUXY2RACx9w+oEMOoAaQCC3gRoqoNlXeGeW3ERFZCMctSGJ5D70hiLIHaiBwQARgulBbWCiDgCAVaKpR4iBO8oMyPoZwXucQae8gzpGoMPJBCQMGUCdFNBMOKhDB1rVATs0ChRXoA49qGPFiD7AAuwYcgFXjnBwizKAVoyAGrGgzjioI/rxxQXwYVegU7BBYqCGJbjBCDx0DtHZYgTPTIPc8Ru4NBa09xR0iwVoFhi8BB3Y4ASdRK8ITFOgTjr4PnvQlXuMjOBZaVADGeQ10B5XUAcQNOP77/d38JJrkFvEFB3AS/nBnX9oGINmcEGzyXyiGuBbAECDBaCl5aDBLNASWFBaZYR2kiF7YCGJhBEeRxC7QR198LWY314xgPRc3lsJPhn/+8fH4AMLQVsSQFsREJ1OJgZQmINmhEHbaL6CO/+fGUAdWVBHHpTfPry8CD7cDjTrDZpBgy29ZYCGuxBwiS0oLF8/OswAcjNkyw8bAzs4/PUZQI1zSTUfhuuHmhlA5yCAzgEB+wG96GCEpCBQfgDZBZ9NBIYtKM+Dzw2BNnaf39oCPvhPQT+W4c7paeDtRqDDyUBxBlqmD1q5ALoJAHLmB+RgMERSxiyzIMHIxOCUfJxBEJjuQIctgmYlQTOKoM7Jk6urwWECSncgV4I6FKATy0EDDqABSXBZx8AAjn/QKeuQ0/j1wStMXt7bA9YLSsegjhaoIwXqqIDKnn/Q1QsQn0MbxFA/4poJB7keVJaCOjmgbQrgFQ7AARdQ/IFWQn15dwc8yAU+DR2j84/a6Ma49pSCzgR5M9UMdATkdTj+D7IOFvHhjFm2w8oQUKCD0jao8++Rc5Ph9slJ4C0AoEEA0GoW0CASaEseKB+qAbfygbYPgTrYoPIPVA6COv8M/2EHmoI66sA89v8//rNeGCGDqyC7QbcGqJrnge0F5Z+3T04wgM4CQKxIYYAPLsP8C18txAjJZ6DZfcjAJyMD6MBCUJ4H5SeQG8Hn2gAHVL8Bt8iAygCQXtAhoaDyDdQGoVeio/lWmiHZ+R/t+DOMgtEQoEIIjA4A0DMZ4e0ID0x6ZmRgpJ3F4M4qPvNxNaTBTVSIu2BK/v8HL+ED7xNmgFTuoAYwaM8u6C5s0PJiUMUMuaLoALjzAprRB20PAM0MgPcTA2e7QB1HBYM48BWBoI4VaJYLPPMPPFUYvH+VAdQQ+QceNIB1/kGVP2jmAGQ+qOFx+8QEsPmgw8ZA+4dBnaJXDw4wgBohoGWEiH3O0IqKYDjAvIojrGD6GSHhAjrfANThBx1uBmpUCctaMYA6pvAOD6npjMR4GlQDAHC/AvewAzvWoPQMOUzqGwPojntQyJr4zmYA33MOlAelD9DBg6AZddhBkigZALpVQAp4Aj2oUwoaRBCSNGYA3SX/4OJC4LV2sQz3zkxnMAtYyAC5veA3eAk2LF3CGpngZfSgGXl+eXBHE3Q3NugkeFAHC7RkFbx/+/VV8N74////QMduGBlAh9CBrlSD3WoBPlkdOHsNmj3/DDzjAjSrDOokg1YNwJbSgzr5oMEAbcdGBtBWFJB/xJRcwLPaoM48KB2DZqVBg2iwBi98xhw6KADig7a2aNnXMYCuhWPnEmUAbYMANXpBM/Sg5bywK95AM/6gfeOM0HQDuvsdFK6gVTWQ5eWQhjxk2wJoSfg/BtA1kZAT+GGdacggCWhGEORn0MwaqMMN6tiCBh5AgwCgji5oKTGoowHqWICu8QR3JIB36oP3x4PLAUhZgDIgxICtgQgZSIQUHUzgGwZAt02AbgcA7fMFXW0HshfUcQGvCgIeTAkaEACtFPkL7WSjFpRIZRQk9sCDPveB5yT8Bu7jB4UhqHwCDXg8u7GeAeJeRgZN+1oGUHkF6rSAxEBL7UEdIZC/GaAdE9j1ZqAVTKABoocXFoBvoQCpBw02gdSKAc9zAKUByDaOfwyggQHwWQJMLOCyCe5WbA18oD3KplkMkC0hDAygwZXnNzeBVyKA7OYBbm0CX0cIu7bxPyLskMMAo2NLdGeC1DqHSnUURZ2d4dH5h8UfyYMA0HKWEb7SBjJgCCp7nt5YBz5YFHSrCahzD1IDKudAdS9oUBJ0nS9otRVowB2UvjxzbwEP5JvMAL7ZB3hrANhNODr/yOkNnOOA5TNou8D9C/MYQINsoBUBoEM3QSuuwAOTwFl+ULpEVAsId4LKZNhqMA5eKQZQ+Q4qLyG3FFwBWwUaZAPt9ZfTiWR4CbyKFrwSDLTKBmjuK+AKP9CgAXhlEQOJYDB2tEc7/wyjYDQERnIIjLABAMaBi+uR2PknGNr4BgBAmqHy8MYHAwN80hfIBDWAQTOroL2+oBl+0B5e0EwluAMBbLyCKnzQkmjQSe2gJdqgDglozz9oRhK8Jxd07Rxw7z/IJtDyXAboLCxoBu/n97cMDP8RnRWQGlDnBnIi+T8Gh/j9wFUGG4HnBvQzfHl/D3wNF6jhD5rREwXO0IKW+WJ4H7kjj5PNBJ7JhnTQGOCzGBCzIJ0m0CwEqPECOuUcNGMBOugM1ilDGQQgJs0RVMOIxRvIYkhsJLMYGVDjDhZxjEgddrjByI1LBmQ/Q8zAOuDAiNSwg7MZGUDL7EEdOtAtD6DD40DbNV4AG3KM0Gv0QCsCwHeXA/f2g1YDQGajoXYCG5eghiTo5GjwgW3A8x1Ayz7B++2BnXBeIVWGR5cWg2dpX9zdxcDJI8HwCHhFGiiNgTtDkBYqA6jTZgncjgJeEgtc/greI/0f0kkDiYE6/yAxUIftP9KhVyB3gwaUQG4EDS6BGqb3z89hAHWuQafSg9I1bHYKvFcfGMag1ScPzs9lAC2LBy2zB3XSQY1s0OoVkHmgFQqgg/1A+kFxAglqcE+TgRGp8w8euACGEeSKL8jBmZf3lIPNBR1uCGrIgzrlIHnYoXHgJfDgeP4P70yiJhZIxxE0Ww8aJAAty0VeJQE6r0HTroYBtJwXtL0AFBYSwIPoQGEEijcG6LWQkMMigQM6wAP2ICff84G340DCADykwYAykAn2JCxdYnbcQLPwoEEHNnZ+BlBHl09EnQE0Iw+KR9BAEejAPUi8MIIP2wNdnwhZro+WHcGeRU2joA6ROPDO/ndPT4AHYyA3lEBCBZQuQDeLsAOvGgQNyoDSJGjLESjNwgc0oAEImpEErdwAnfwPWqoPPmUduPpIGrgdAtRhB52NoG5VAr7VBLTdADTgACrbIFsjoIfw4WnggwZcQGmDB5imwSf9//0Ntfk/+CYV0NYRcFzhMAPR+SeiY0xMOQS1HXfHFHs5w0AsGO38Yw0pRlLKf1g5CxxkAuV90MGfoLIGVI6BDAfd5w8qU0Fn7IDKLtCqIFAaU7cqZQAdDgjqoIPOzrl7ejp4NRFowA9yCOp/kg6NfAm89QJUFoI646B0CDp7ADRT/x/t+kmQ10ADjKCtRQLiugygWwJAK/dA7QKQGKh+Bx0SDNqSBDqnA7TyBbTtCFQ2gA4aBG2NAZ0HAlrV9/vXJwZQnoB0/pEG9hloB2g6+z/a+WcYBaMhMNJDYHQAgNYpANbRG2QpjeYz/wT9y0hEgwS1E4neYQEZAOr8Qw6hYmQAzUCA9n2DOxrQw7h4BBSBh2pdZwDvvwVe/wOaFYZ0qCCHgIFm9J9eX8sAujMY3AgHdoJAS5dB12qBaMihYwzwe7BBDXxQp+v+ubkMoA4WaHku+L76/5BTxb++vwPdTwzbI8hIZMyDe4/gjg3oGiXQicUQjVBxRsiyf/BMLXDfNKijCpx6ZgCdKA5acQCeff2HOEUebinOgQZGbL0ZNLeSEEcgnegDAHA+aieJgQGzMY9rwABiLLI7YGYxge9rB8UFKN60gB1JUOcNdG0kqKEJihPQSdQ6Ts3gThJohhTU2VKzKoJ22hUYQLP7X97dYoCFM2xGG9RhBg3giCu5Mjy9tha8RxrUAQadswDabgJq9IK2GIDSGWj1BXj2FjrrzAhdQQCaxQedSg0aYACdhA/SA2ocgxqusIMoGcB32/+Hz/6DDscCNWJBDU9YoxqUFkCNbdCyWvCMOjCOwR1faGOcG7jCAOQPUGcStEUBdNAgO48YuBOnYVMBbHjvhlyTCWrwMUKWvoL2tIK3C4hoMIC3NQCX6MPiBLRahoWdhwG0WgA0qACZ0YfdjY04rBHWcYB3IBihMQhNb6CtMtoODQygTgBo0AASa9CZZKgakA7QqhvQig3Q1Z2gzjKIBg2+gQYNQGcHgDrooC0A34B3fIO2Q4AG2JiB142BGvGgQzwxMhcjZloBq4E2eEGNalC+Bvnr0q4S8J3ioBl/kH2gjjjoADFQWIL3KwPLAtChYaDVEKAOwqsH+xlgg4Qwe2ErPpDdARrsAMU77HpS8KAc0FmgARSQetCye9ABp+DzDoADlaBVDqAVJuBDBhkhMQG6sQEUF6AzGBjBh5TxgQ8SBB2KCirDQOkD1IkHrV56Azw4EDRYABookVB2ZwAN/jBgBeid9f/gVTLwPfxInQLUzj+qPmKWtGPULxgdTexlC2Z+R/YIbj0MNAPDa+YfWzARPQgALXOk1f0ZQHkRtFIENmAHukYXfNUplwgDZI++FPiaQFCHWVDCgAFUFkJWPykyiCm7gCpUsBioPGSApTuiO6WQcgRWpoAG3sF7/hlR0wrMX6COO2j7H+hwQtBKPtDKA1Begx3iaxW2hgF05SV4FQHwhg5QPQEqg0GmgQbW5IHbhEB5DbQqADzAxoBUgzHC6iM8CXCwdbZHO/8Mo2A0BEZDgIFhBA0ADEDjgZFx0KUx8CwgrZf9E+Vr7GHDiK0BD6tkkWaVIZ01SKeYEdowAe3zBjWIQdcFgZbKgkb4QR1k2OnioIY4qPMEmjEHHf4FXnoLnOmHLJsGHTIEOhH9P4MxcMn4tf310PvSP4NndHmElBkgM3WMDErGaQygTuZP4OwueEXB8/MMr4GdA/A8BmgJIgO0gYLSAcaXFhgh968DOxyg65FA7gQ15D++vsIAmbVlBC89/w8eZHjPADpwENTJADWuQDOloH3boKXikM4JLPAZoc0UctIgIwMDA7ENdKg6tLQOG6yB3KMPm61nRk0ZyPEKYqOEFwMDts4VA3TWGmQ+qPMKWrIO2v5x5/RU8H590MwT6ERn0NJ30MGPoMOlQGohs/1/GcAnnQPDEdQ5A3UmQYMnEKuhfgZyQGKQWfNr4IEf0GFXsG0FoM4h6Bo24HQQA/gaSuCd2OCDJhmg4ynAAQAF/XgG0KoDUEePjUuIAXywJDBuQYNQIP2geAR1rsHXw0E75qBOPqgjBj7RHSwGTBPAGV+Q30DuB81Sg67FfHlvFwOkwQwNU+BsHHhPKtBPoLvhQZ1tyAqDnwzgGW3g/fcM0MEJUAMXNBAC2rICunYPlDfew+/3Z4CnNXXLYgZQ+gJ1hhkYIIMGakAx0E0HoEEWUH4B5SMRWUsG0E0GyHECXxUADEfQCh3QadqgsAblN9iWC0hIMzJAlu0zMICWBoPyE8idoP37sEMG5fViGECz6eDZONBd/X9/gjvBoHQPWpoPX4rLCA18bGUHUjqGd2qB4Qtq4IPSB2hgBrQSART2oNsdQI192NYgaeDp/U+urQaXA4+Bp/kzIG0twJ42GSD5BinroHSEgeKgLQagpfegNAo+uZxTkAF0aCFkhcR/eBx8eHkBMnADKttAg5JAv3Pzy4FXn4APIQO6BbSSATQQ8Bd8jelzBtCZErdO9DNgztzj68BDB2XQO/+0qLkw6kP8ZQzejikjdr3UnTUd/p1/eG3BiL9+Qq5VQJ1i0KAUqBwA3SYCykeg/AsaLAOdoQOqV419Z4HLWlAeffP4CAMo74CuCQSduQMql0Db5UD5HLwKCpSvyOmUojkZhcsIKbc4+aQYpDUCwMv9QfkbNND3F7yFiJEBVA6DVtCByiXQFirQzQaggVvQ9jDQAZwgf4LaDqCzSUCrCCHbCB+B8yDolg/Q4cNM8JtW/lM1x9Bs9n+0888wCkZDYDQEICEwOgBAq5SAt0IdmOTHSOuOP9F+xt/wQw0dqFpGRviSZdB1WaBRfFBDWtOuGry/GLQ/T0LVEzz7BVpmCNoSALqaDDQ7ADosCDRrBhrxh13nB9pDC6r4JYDLdUGdGtAyZNBMLmhWH3RAGMgNoM49aOkv5F70F+B7w0ENmXdPjoP3y4L2BisYxINn/EHLhkH7emGziwxY9yFDO5kMqDSooQta0g9qQIGW+j65tgpsF/ItA6DliZDD0VgZPr++xgBqZIE6k6Al46COJMiM/0gDD5gDKeh2o6dBZHnc6RPrAA1IOVLcwzv/wM4paHACFE4gGjTD/Rd2lzo0PsGxClzRAOrcgDrvsMEcRqydBdS0AFr98Qh4LRRo0Ad0cB5oSSiowfYPuqwetD1Ez7WTAXTnOaiTCjrtHdQJBl+5BxoE+PwMeSoH3LADmWMZtgq8SgB0XR7oICvQ4AFoP7ywjDkD6EAo2Ew8+FT/X5AD7yBRCkmjoBlsNYtChuuHWxhAnXLQIAhodQpobylomSx4Rh94HgFoxgyRThB5AuZ10AwbaKYYFH6gdAvak/ofegAmLHz+gK86ZGAAnSoP2ucPCl/QEnNQwxvWuQcvSweeCQBqxILSKPgKw1eXGMADFBwC4IPmQOkLVjyA7/MHdjgh0QpJF6DzC2AnbXMDB8NAeQt0Qj9onztoAATueuhKFVDaBO3PBYWdpIonA+jcBZA/QMt+QQ1siF2M4EEe8JkZMAP+wzqk/xhA99CDZg5B14WB/AA6FBB8leDn5wyo+3CRyxNYOoakYVh6Am/ngZnNAMo+kME+BmjnA7QkH7TUHpTXQatpQOEIWgUCG3QDpTFErmDEkUEQ6RObApAsKM2AyhnQTCRohQRogAFxMCKk0wKKSy37eoaX93YzGHpOYgCFPWjJP6+oJgNouTNIDuRGEXk7BlCaB5kHOjMCdA4JA54GPvaZ+/8MDCR0Ckg50A5rfQNK3IzY4gt7mMIGWhDlASPplScdOz3/h2QHCyllM+JP27B6BlSOgFbF2MXuYngMHCQDDdyBZtXBV+ECV9+B0itsuTysXoJs7QFt5XnIABo8B19jirPz/x9/HoPJorkXPc2Byh9QHgGVPaCBUlA5AsrLkIGAb+AyH7QdEFQOgAYBwWcYAOst0EAAeKAXVFYAy1xR4NWDkLL/N3j7Aqjs1nfrBZ/NATorBLIKEeZmJLcPpvQw2vlnGAWjITAaAogQGB0AoHZqwGjgDI7kRrPOP1n+xd2IY8Q1S8QIGwBgYgBfBfjzIwNothx0bz9oVhcUyqBD0iBLeV+A+xegGV5xJScG0EnEoA4OaPYNtOwWNIMGatyDGt6g1QCgDgxoqS2oN/gR2DEC7fkFHSwEOnAN1Gj4+OIiA2jJN6ihDNpXDmpEMLNxgWcVHl1awgA+kRt4ajzocD7QrCfyPkFGRvwNVpg8qNMKWv4MWpoN2oMIOd37H3gGFLTcko1DEHw9F2iAADQbDVo2DN6rDDygCDRoAeq4gGYzER0V0KoCyIw7ciMa4RxYRwm1w0QotWIdAEDyI6zzD55PBnYGQR1E0PJm8HJooDpQxwpiIyN4Bhg0+8rMzM4AWiYPaoSBZqZldcIZQB0kiFuQ3AdNa/ABBqD5LmlnwJ11kD2gWxFAjUpIp+4veMUG6NA4kAmgWx5A10iC9nKCTq1/+/gYA3jFBHhFAaTjBeq0athWgVd3gMwDXQMJCk/QknnQbBf4RHhggxU0UySq6Aie2WeADbpAe88gt4HS0/Pb2+DDbaDbB0AzvKDOGyjuQIMhoMEL5P3/EL+CGo6Q9AK6+g/UGAXdsa+gHweeDQaFC3yPN7QxBwkSJgZQWr+8pwI42xXI8OfPNwZYOIDiCzS4BBoQu7S7DJie3BnePDrEAL7aEBjuoJOvQUtjQdddgkMaHsYM8MERkBmggRNQXgMNvMFWzggDT+8HNYQRM/GM4C0sIHeC0iIoL+o4twC3YOxlAA3agQZ4PgDzEnjZL8h4eLqB5hGkdAReDQHcsgO+xhAYz+rAmz3Ag3dAfaDtHQzwLRew/IVIJ6jpnRmcb0B33f+GDtb8Rw47YGMftDQZtGoIdO4Cv6gWA2j1EHiQAjSXDt5K9IeBAWNADz3/IOVzvHkeuo0C6AbQtaEMsGBmhAyGgNIIyA2gJce/f35gAG2RAA1KgQZOQHKgAZBPwJVBoEFO0NJ/ULyCZlQ/g7ay/Md2NRmkM4Kz84+W4Wl+6jjMPkZY/kcuH7GFKSO4wwUJJ0YGlKDFEs7Uq+dIn9Ed6p1/RNQwYqkGYHmUAbxaDRQRoFl/0BakZzc3ggeswatp/oPXwTEwwDv20HAExxUk7YPyIuhcEbAlKJ1SUsMce56DpwFwEmNkAA1WgOr3n8CbTRjB15j+Bpd/oPwEOg8GVHaCtlGBbuUAbSEEXbMJObD0PwNo5R9ocA3UwQeVO6AVVKD6CmQmqNwArWQAH6YJ9AfebM9APKBJHhxynX/qrqhgGAWjITAaAhghMEIGABjpE/WMjIMuiTEyQCDVHQZrwJFsMO4wwt5ZhjU8GBkgy8mZGUB7gEH7+EHLnUEVM2hpNKhBAT4ADtTtAld2/xhAnS1Qx/jzm+sMoIYyiA26Jgiy1Po3eAkg+G71f3/AoQRqXIMqeJA86Ooi8MwvKyd4th98KCDQr6AOD+hQI1AlDdIL6rCDTnEHd4KA9oLsAW8/QAoXXIMAKLNajIzgw9BAdyKDOmwgf4Ea9sLSZgyglQqgpdSgQQFQYwXU+AINAICWEYMGC0BuAjW+QLPfoI4fuAME3DcM2hMsIGkEvrYO5D4h4Aw2aCAE3MwmI61iHZyBmgNPZzA+sNMG6mSCZilBgxagA+pAHWxpzUAG8BVQQHWgZeGgmVfQvfWgK/dAgwEmfrMZJKAzxvBZabS0BhkAgGz/AJ3MD9rrD1pGfmF7LvBKulwGDl5J8PV/oAOdQLNSoEMZQZ1y0OwUyC2gQ52QZ99B6QpkN2iGH7SsExSnoMYtaMk+qAMKGjT6BjyADqwOGq+sHHwMoBUZkOWkEEHE4Aci8kFOB536DtqDCjq8DdSBB83e6rv1MIAOEgRdUwk6GA69gwne3gHcHw4KC1A4gGb1QXvVJVW9oIMjiMECkG2gdAFasg7KE6B0izwQBEqfoJlsZZMMBtAgE6hjDsoboHT2DXwP/GfILDAjNI+BB0UgnTFQnOu79zOA0jr4aq9XVxlAcQjqmIJWR/AKq4AP0IOkKSYG0NWKsIEYUJp8A7zaD5RWQeEnLGcNzoegmWzQYZ0M8JUwDAywnh0jbEkt8hVhwM4EqKENij9wmkDrjDPC3A1M8+ArFP9DwwZ6qKOScToDSB9oNQXs7n3wrDdQHWh2ELTS5xPwOlEWFk6Gv8CVD++B2yZA+Q9+xd1/yNJ8oos65LyFreHNyMCA6KRAwxzsb0YGWe1wyBajry/BBxTC7tkXB67gAKUF0MGTJ9dFM8hohzFc2VsFvoLx2c3NDJBbGB4yMDAQ23AmpYGNKLOxlgF4AoaY+ge2TQi2ioYBlt9B8QoMF9B2HtAp8qB0BSpbYQdE0q6yHbmdf+QwxVXeg8oN0GoZ0FYZUPyCBhFBh6WCt7HgnNGHmfyf4S/sdgmwEKUdPcxBAOS8BbICNEAPqgvBq4CAaQp0LgxoNRaoEw9qD4BMEAeeSwA6ZwWU1kAdfdiNAaCBA3FlVwbQta8gs2ArCliBK6dA57OAzygBboUCDegyDFYw2vlnGAWjITAaApghMDoAQK1Uwcg46NIXvCKkpsvQOmOkG03eAACokQiqcGW0QxlAHQHQ4W9KxqkMoJky0L5CUIcNNGsKquhBS+JBs3mgCh904j+oswea0QXt5YOdFAzZJ/uPAdbIB12bBtIP6kCAtg3cONLBYBe7m+HW8V6Gz+9ug5fcw2Y1QDMYoIaDgmESw8s7Oxhgs5XfgQeVgfeawwMFteGMOjMJ6WAh758GL58ENqD+QW8wAHU+QX4BHVAI6uyDOtQgf5n6zwVfQQeaqQCdCn4buO8X1MmCNYxZ2HgZQIMZoD3CIBrUSAGZDep8gg9LgrqPkYQ0i6sxiGi8MzIgpucgnRqQXRA/MTCwAvc6//r6GryfGhQfIPNAjSuQv0Az7KDZZBWzbAbQKg7QsmjQrBIDlo4XuEMB7BSA/AYyH7RiABQmoIPiQCeng1ZsgFZ8gAYBYEvgQZ3erx8eMoCuswN5HbSkHDxDDWoYMSI6upBD4H5BV3TIMoDMBrkRlCYMPCYwgE+QBnYqQYMIoHgGbT8BbRdBvgEAW34AxwHwfnzQtVigzjdoZh92+jVoAAd8Y8R/5JkyiCkgl4FmzUHp4P652QygZaigZfEMcHeD1DGCl9GDtp6A/ARaLQDa7gLaPgAajGKAxzUzcDZLCdz4vrq/hgEU3uBD56CzxqB4BDWAQX6DDCaxQ9M8I8PR5T4MoMO+QAMjYBuBYQBqKIMGMkBx9uLOTgaYOGgQCnQIHcgdoBls0Ew6KL+A/AzKM6C4h2zfuY8IKkZYN5ERfN0i6LYF0HkeIPf9hx7mCRmM+cUAHtiApQvIqAMDaGsJyDDwqhjgdhJwPmWElH6gAT1B4DWOoAMcQYML4AGA/9BT8hlAXvwDHhyAHN7IAuyAhzGAtoiAtixg7UwTyjOEOv/wCGGAb2kSkjZhAG+NAboLNFj5H3pYKWjQClQWCMuYgQfNQLd/cAAPeDTxnwcu90DbMEDXF4IGi0D+gx/mBw9Zas6iEVG/4QkbRAwjscDbRUDlBhMDKK2AbkmA5kbIsDVQHrQtyi5mB/hMCvD2EeCAFWhGFu7FQVjvMgwjgFHug8P7PwMoTu6cnMzwAbhiDpTuQGUbYisJvWdvGTHKEgakcp0Bms5AeVzFNJPhwcVFDI+vrmKA3ZTCCVy9BxqcBZXvoMEN0NkuoPoftGoMNBgAKrdAFoDq31/AawtBZR6oHAHVD+9fnAcfMAy5vvQPasyT0fGm+uz/aOefYRSMhsBoCGAPgdEBAGqkjEHWCGGkxaw/xR1/UECT2vlH6AE1RMCdiGdnGEAHq4Eq4Zf394KX6EEOWWMF96VBM3qQu96fwZdgg675gRwChziZH3RKOajBAupEghowoBlC0N56yDLj/+B90dePtDGA9k1///iIAbG88z94FhXkFvD+ZNAdweBKFtTowdbwweZnSKMXfDghw394RwC8Vxs42wDqxIoB9xyCTmMHNWRAM5OgDi/osCXQnn/Q/fOc/LLgDtp94BVwoMEL8NJEFg7wdgfw+QDA+ALtYwRtWQAtOddzaWcAHWQGO10eluxhgxL4sgGuWT+Qe0GdUlCnTskoBdqggnT+Qe4GzaKATicHuRu0fB60OgG0nQEUIsysHAwgP4EbZcCOP6gB+RLYkXwAvPMctJoD0siHhCdy5wFiLjMDaLsF6OBDRmYW8GF83ILK4APiQPEP2tYBOqQJtN8eFF4CkoYMoFl8UIcONLgD6ggiTqaH+BzkR1DHFBRWoIEAUOcTcrAiAwPonAjQOQKgg/tAK0FAnXLQQBNoT/r7p6cZMDqKyI0uoGfBp/8D7/oH7aEHzeSDtjeAZtBAs/Cg6wpB6RMeH+AkD+0GQcsVkP9BqxxAAxsM0CzBiEUdyB2g/eKgWVLIoXoMDLC4A4UzaIsAKJ5Ad/v/h94YAQoLyDWG/8BhCgpHkDmwFRIg/aCBJtCMF2gJLWiQCTSgBOqMgjrjoMMO4f4HNrTBJ/Z/eMAAOjEfMsDwnwGk/+zmVAbQWRyglRNvHh2FTvZCBi9Ay3Jhs76/frwDr7gBDXqBrgaEzdTDDtiE+R8SDJC0pmSUCh4cAV2LCVodBJphBF/rCQwk0Mndrx/sY2AEDgyA4gw0oAPuKMPj6B84H/GL6zOA9uSf3ZwGXj2Ckh+Q4oEBFu6MqJ0OBmzlI0q9gFw2MIIHy/jFdBlA/oUcesjEAOnAMzKA0i/42sU/38EHJIK20IAGBkDlBWhw4i0w/EB6QDOwoDwtoxUMvm0BlHZ1nVoZnt/eiuJ8spemY9RrjFDvo5dpaGHBQAAAzQWlO0j5x8AAWnoNGsQAdb7g8csIiVvQIAhoEBS8+uPtTQbQwBlioANqL1Xr39HZf2yxh6gDgDkROEB159RUBtRyj7RwIzZNEj9IjUgLjNAVTKABQVC5AVplBcpTIH+BOvSgs2FAs/+QA4PZGUADwqA8BEpjoJUMh5d6MjgkHARuXdrPAKqHQB1/bgE5hvfPYZ39twygFUPvn58BHxAMGjAFbS8CDdwxMJA/+DHa+af3wBHDKBgNgREdAiNgAICRthHMyDhoEhDVO/6wRi3V/Ig9rPBX8rCKnQHcUAd18ECzj6DKHbTkENTJBXXSQaP5CPGL4MYJqNMD6miCl24DZ9dgDQPwbCcLO4Nb5iUG0CwGZGb/H7xBA+70f3oCXvYMmsFEmVkDdhwgy6uB1fXf3ygDAwwoHT9kv4LYSBjauAXNckoBTyg2C1rMcP/sbAbQTAXsZG+QvaDOOsifoH2KoO0LoGXu8npR4EMHQUu3QTO8SibpDE+urGQA73EEzrCDOv+gziVslhg0ew3qsN47OwusBuR35FUAsMQLGwjARqMmcNSGFihsQLN0oP2QoAYSqDMHWqr74/NT8N5d0AwmqD0GWkIO6oyDBm7ePj4OaeczMoEbUKBZZ9Bd5KCGPnh/JacAA2hWH9RZB8cNSjqEdAxAWwfAp8pD0yZoNhq0EgIkrgm8/u7FnW0MoDAEHb4H6mSDZshB4Qi69xnU0fjz4yPUDbBOMnD2GXgtHui8B5A62EoOUJoB+REUbrBBFzbgPe6g1QzvnpxkgC0rhYQKsAGDY8k3yDJQxx90Hz8obkAzSJDBGKR924yM0MEgJmjHnRHcUYSlW5AZYO9C1YEGWMCnUDMyIA0iATlIM+SQvAVxHWipO2ivOygswGkYag44nQFvHDi1Pg58hgCo483JK8EAGbj4D3YLbM8uZEYeMtgFTkf/EQNfILtg9+XD8gxIDWh2GrT9BGQPyF7QNhdI4AP9CRzAAW1rgG23APsEmC6+frjHALomURm4fB+0ygclb0Eb+ODBIOCeXlBHGLRvHpR+VC0KGEArSkCDFODzO15eYgCdcQC5GvIZA6iRDo8rYGMd1hEBzfiDVp78x7qPHpEDUMpYWLokWANgb9iCblEAdehBB0yCOsOgsgC0zQNsHHQLBCjOQAdJgtSB3A3eyvLjA4OcbgT4kEDQ2RSgJc0v7mwHX2kIGmgDD7wgdUQIdqLwle8YcozQfMOI5mskPnq9gcyHJGDwoBAo/YLyq4i8LQOfiCaDuKIzA8h/oA4V2M3AdABKF0zAOAYd8Aralw3Kz6A91/iczEBHMFz2/RMbZIxkBjw1womodgIDpDw38pkBXtkDqndAKwe/vLkJyu3gFUSg7Wjg1VHAgQyQu0BtCvAANfCAWlD5IKsTAS77wLeqAG8JAg18gso10ECAtmMDw/3z88DBBdomBN5y9fMzA+RKV4bBA0Zn/hlGwWgIjIYA/hAYHQCgJIUMllYIA7QDQK3UTnTDlhQLGXEqxl2xIzqbDGA/MoBnyUANRFCFDFnWfokB3MEDLpsHdZJB1xBBRuIZGOzj94OXc4NmnUF7aEEdRnBHjleaAbSs+t7ZmQygvaX/oQ0BsAP/Q84OAO9T/I82q49cqf7HNeOP5E1s6YMR0oEFNX4lVTzA7rt3ZiYDeOb0I+h05FcMIDeCZrhBs66gw754RdSBjZm74BUOoJUKoD3dsCsJX97dBQ4T0PJt0ODBL+DBYaCZdvBd8cCl8qCOEGjpLGgZI2gvI2Tp9kNIx5Xk9IIaH6BOCwiDrlkCdWxBS89BM3ugRjxoNgO0EgPEhnWoQdsAQHEAOSn6PwPIXzqOzQwXgfexg2ZDQbOaoAYVqKEPmgEGHdgH6fjB0g608wHsAEI6OcAr5AQUwLM0oHvTQWEKWm7/9Po6BtC1TqAwBM3ggJdVA09yBs0Ag+wALTdGzLYwQlIWMF5AnUTwapHfX6EhA+m4gTpXoFUEoKv4QB1E0Iw2aF8/aMkyeGk8cIUIaAUG2Hzw3f4Q7YwMyOEFYsNWezAwIDqhsJ0TjPDOPmhJu6ZNJQPo+izI7Dgk9cM68+ABLdAyfC5hcBiClp/yCqtDVn8wIHXQQEtfQXvLoR19UGMX7Pd/iEPtQGaCrgUEhZuwrBVwi8A3BtCgEihdIZ8jAIoHkH5w0QDalw2875sFeBAmv4Q+A/hQPlhah0UV0vobcH4E5jHQLBkkDv4yMELzAWiAC2Q3aBAJdOgm6BBN2PkWoLQKWpaLGLD6z4AYoGJiULcuAW51kQQf2gga2ACt2ACtOHl6fT14phjcWQe6FRReoEMI/wIPR/wDPDwUPAj15ATG4B32GThY+mBggM/yM0JXLjAwMDDigeBUwAiJdxAbuRMEEgbNSorJ24NXJ4DyERdwKTJ4cObPT/Aqp9/AQSpQfgflF1B+llT3ZQCtlAENHIBm/kGDUKAwfXR5GYOJ3xwG0IGXnDySDKAOMiTMGInP4YyIvIWhCVYfINPw4GBkQJTf0LBCNoAR3Q0Q9aD8C5p5BV3nCJqRBR0SCsqroFUybx4eZlC3KgGvBAGttAINRIG2cL0BHtwJKs8gxsMGVVDLJAaKwOgMJDnBh15/03pQhHB7gQFcv4EHlIFn+IDKhH/AFVjg21ugW4pAA2vKwMHzV8BVhKAzQr59uA/u9IMGBkD6wIOK4roMoPNKwOePAAfdQCuYLu4sAte34BVU/xGTBv/xtRWICFSqzv6Pdv4ZRsFoCIyGAOEQGB0AIDeVMDIOivSFMiNFiV/QGnfU9RzusCJqVB+pcQq6fxg0YwiacQZ16kHL8MEdBuChPKDlz7BleKBG/6NLS8GdE5A8aO8e+CA04B5AUGNTVM4W3MAEzUCBRvgZYBX4f+gpxkRWoijux5Ym0BrPIHfJ68UygE4dBs9KcwoxgJZbg04bBjX2QfvVuQTkGUCdaVDjV043kgF0ojz4BHBuMXDjHtRJAi3FBi8JBzZCQLOAP748g15TCOmngG4V+Ac9bAl08jqoEwHqGIAa0KABBET8EpOO0Rr2cH+CVkH8YgDNhINmW0G3MoBnWIHyoE4/qNEOmt0DHawHuzoPclL0P3C3CbQiAHTHO+hOfdDAAEgO1AkUV3EHnyYPaowhXIfUsWVghHcEQf4SlDJiAO2jB80wgzqYoBPrQZ1H0En/4Lv2GaCDNaBVIGBjoHz0Dg0D9s4E6KRr0GDM9cOtDODZauC2D9DABqjzAuuggGYwIdsMUHMOYvaeEcesPsJfsI49eNXC0xMMoDh+en0NuDMEOkQPtqoDNCgASi+gQw5B2xBAaQO0qgHUgQINYIDMAZ3ED0pPoJlxUDoB6UFPnuC0C7QetOoCNOgA2qoButIKdOAVfK89I2TACtz5ZYAOXjGClqv/ZQDlK9AACGh2H37lIGx2HqyWmQEUDyAfggbUYAMB4GAGmgs6uFDeIA48gAeabQOlAUjnn48BFLZKRskMoHQFugEDvCUBnCchaRHkR9Ag4JV9VcCtC/4MoEEe0Mw/aHsDaCYf1DUHXe0JOiAUdKgfaCsMKH2ABphAh0CCrk9kgKcL7B0/xGADxN+ggbSfX16AIxhkP2jrBPhwMWxZiBFyC4eIrDX4EM//WAYMQWaA4k1a3R84iPUafBMGKM5AA3WQsuwPeJuMiIwleAAQlI9A8QlSA1qlYRu9HRwHoA7zoysrGISkTMAHS0JmI1H9xIilI45RxiOXswyonoLVM6AtFSB3gMpMZjZuuBHIYQURhJUZ6DQDNO8yMxj5TAPnW9DMKuxMCdChpaDrJUWBqwJAS6xhZ1LI68WAb5MApTfwli+w+wa2wz74Zv9JDQ9GhqEMcKZpYDoG3eEPOkATNCgOqocgg+I/GUDbvEDba0CDpqBtSuABYWDnHtQmgEwE/GUAnUsDqmNB5QT4Clbg4ACoLn0BHWxnQMvLlKaD0c4/wygYDYHREBiAEBjmAwA0quAYB77ipLjjj9b5oV3awx1WxC7pY0BqmIIa9qDZI1BnAdTBA828SgP3wIJmbyFX9UGWVIPuHgd1+JlY2MD7aEGNTJBa0IFloFlAUAeOX1SbAdSQBV9RxwDaC4yvAcXIwIDhFex+Y8RUCJ8nBC3zB501AOpwgc4bAHXaQDPdoKW/oGXvoAYuqGMH8h9ohhx0wjKoww7qLID8DRr0AHdygVe4gWa8wXfnA2c5QZ08cWV34An4Egzy+rEMr+/vYwAfksfOxwBakg+60xh8VzFohhpjmTOuxjpMHCl1IMcFUj4AuQ8UvqBrlLTsahhAKw5AnRvQIYwg+2V1wsAdPVCnH3TgEugqM9DSbFAa+I/UQQfvMQfuIYfECaSjjtq5YASvlgAtxwf5HbSs3iZ6KwNoxgYUPqDBEBHgTDb45GfgDCrIB4rA8wnAJ+MDT3gHhd/nt7cZsMUcRrwxQvxvEbKc4SHwukfQIZGgjjdoCwOoAwbqVINWA4C2WYBmkhiQZoTAIcYIyaWIzjPEPHBHH6SAEcYHpS0m8MGOMlohDJCrIGUYQAe+CUmbgjtMkMEQRvAVXKDVDooGiQygsAYNcIBWuCgaJjKAr64C+oxfQg+0VAa8zBokD+pcgWbZwYMvDKAOGHSLAWiFAFA96NpA0OANuBP/HzTLzgQ+W+PS7lIG0Ioa0Kws6BwKcPoBuhm0pxY0yAI5ePAtcODpPQNouwZolg3W+WOEzryzA1cpgLZMgPz1/tkpSLBA3QDOA8C4Bp1ZANq/zs4lCh4MA7kXpBC0/BuUriFXJv5mgIUpAzRcQasyQAd1gcoB0MoM0GAQaIb8L3gFx3/wKh+QOGh2/TfwbAHwdphfX8ArBv6jxxUsicPTNCyFQOMIeF0g6GDDt8BtH6rmwNsmgBg0mADqjCJ5CrpKgImBi1+eQcexiQFU3oAHCdBXDzFCihPQSh7QgZUgd4MGNP4AlxODBrMgefUfA2hVE6hMAK3IAIUT6PTy89tyGIx9ZzI8u7kJ3KEBDRCCOi/gGxJgA5hYCnSiBwHQBgLgg1jA9ALa2gMalNR2aGQArbRBWANJw6C4gZyv8g9nlQJK/8KyFuB0DVoFAepowW7bAHXKQOeVPL2xgQF0TStIHDRICxoUAJUdoHwOskNMAXgN5/t70LEkUBz9Z2AYBPUyA03BQA14MDIMVoA1TTNCBt9Ag4mgK19vHutiAA1SglYJgQ7CBaUp0KAbqI4FrQAElaPg62mB3gSxQQekggbhPr25xgAql0CHAIMGR0GDvbCzU0DhgdrxR4qbgZqB/z/UVrCMrrhhGAWjITCAITA6AEBq4A9wI4Oijj/I7TBMl0SHu+FAdOcf5E6kBimoxQea3WaAdmJB95d/AB7OA7pbHHaKPkgLaN8x6MYA0CwgqAMD6gCDOtygpfKgziAoHEEVO6jRDZqlhswUIwUKUjxDOqBM4M7XfwboPd7gfgHEf9hWATAyoEIGJH/AZidBs5ogt+g6tzGAGrjgu4aBZw+A3ASZYVRgsAheCl7aC5oJ+/bxMQNooAC09BxEgw6RA81QgAY0QLMSoH3wkMEBNgbQFXugq9pAy/NBs6uQE9WhM98wb5KalpHjAewfJgbQKfagjhqosw+6Ag7UuAI1tEBiILeB9u+COvog/4EOoANtFQC5G3ToFyM0TECzfaAZFsRBjf8ZGFAaM5BOGHjBNbATAkoDoEES0AyPlkMDw8WdhQyQE+r/gU+51wUeeAjqHP39+4MBdhME6GTnx1eWM+i6dIAHRyDnPvxHiSXsWeI/w5Nra8BX/v3/9wt8Sj3I7aDl5qBBJFDHDbQPH9w4/P8fdTk0I6TDrgi8LeIj8LRscMcV1DEGHkgHGtwB7YVnhA4CgOQsQ1cxgFZOgBqZoH2roFlg0LV0EL+B4g4yEw3qvP4B32nPAOzMPmcAXcUHOqQQlDZB4Q0apADt5xdTcgZf2XdokQuDjlML+CR5kFtBM2Kgg+UgB/1BOqKgsxFgS+1BaQ/UIAalS9C1dDxCqgxfoDdhgAY9QINtf4HL1EEdUtBJ9KAVIKDzLEDxCkr1oBUJN4G3aIBmi0FmQu7N5gUfxIjYYw8dbgFGLezKyw8vzoE7caAZOEbwOQAPgNfbGTLAru6EdsUZYB1S0MDCmwcHGWCH+oFm5EH76EEdftAhhSzAwS/QjD1opQHo0K8LOwoYQFsBQJ1uUMMfvgIAGvHwASCkchLkDnD+B14xCEq7kIGUN+CD+kBLi0EdWFB+RHQMIHEEWr3w8fVVBlBYgwb84P6GpmvwoBd0JhGUf8HXVSo4MIBmKmEDBuDzE4CdXFDnH7TyCRTGjy4vZwANcoG2pYDSB6jzDx94wtoBQC2DsQ8CIPIXJDUA/QD0L5gNL+cYwYdtgg/Q/P6OAXRLx1/oVhnw1YtAdeKKTuDBR/CAzL+/DJBgZGRAHsCDpXeQX0BbT14Ab1EBHXgKSr+g1Syg8AYNiIKuiQSthALlB1D6AM/k8kkzgA7RBJUTn9/eAA9wglY9gAZQIDdeQDoUjFiH9whVeKR1Rugz+z+UOkiMDAMJEOkakv9A5+VwAdMLqN4Brf4BbacBDTr7FD5iuHGkkwE0EAA7EBcUl6DtXUzAQ3RBZRho9h9Uxr9/fg58+4S2Qz0DqP0A8iE4byKdHUKpn6k2+z/a+WcYBaMhMBoCpIXA6AAAKeE1QJ1/5K4kyQmc7p1+eO8Sp1PJ6fyDDEM00GFG/wcfvgPqCIIGAhiRrIYsEX7MAJq5BDX+QTNr5sDD9kD7ZUH7oCGDBYwMoEYsYl8pmpOhYQfrBIA6baDGKGg1AUgfyD7QFWegTgd8JhDsUEYGBqQBAgaUQRfI7ATolHpQpxEUFqC9yaCZXtBsOUg7aHsDqEMN6qCB9vWC3Q88oAh0UjFolg8kDmo4yAJni0Gzo6AGjp5rF/iUf9BAAagxDOoYgNwKuqYI1KDBtgSZAeZWBiIARucf0tACDbCAOlIg94I6QeD7/IHGCUmbM4A7hOB96CwMoIEIUNiDBgWEwNey3WEAdSZBB6CB3Ac6iAk0+88tpAw+FwHuIpSBGCYGIWkzBtByfNCycFAH9O2jI+Dr+pRM0hhAHY9/wE46qJME7iCDl/wzMYBOngft5QS59cL2XAbQQXGglQPYfI3eIENPc6DOHOhANgbwkVKQgQrEtWTIA0KM4M4saMAJNFsuBjzgDLS8HtSxB1+DB7wW8B/0JH7wrCnwDnpQZxI0mAFavg8KJ1ADFTLw8xDsVPBhaMDtEaCOIR/wwELQ3lTwif/AZemQDigjgzJwi8u7pycZ9N16wIdFghq6oL39oAMzQQNhoIGZi7uKwPEBulmAR0iJ4Rv4lou/kG4TIyRe5fXjGEADSKAVMsdXBTOAVlGAB22A8qC4Bp8lADwEE5T+QIM+SiYZ4BUI4LIKGOegcwRAgzqgNHhhRz6DgkECA6jTB145wcAAHyiBbdkB374BbMSCGu4gv4NWgIDyGEgPqIMJWl0CvpoPKS+BVj4gd+JB6f7No8MMoOW/oAworuzGwAg+aJKL4cL2PAbriI3gFQag1QqgMAEvOwcOqiH3F+FlLfDgOWFgWgOlJ1DeBKVR0BkWoFUKyqZZ4Gs22YCrGz68vADs5EsygMIGnp2AdoJuoACJgWYRQeEDGXBCXD8IS3uQTsUnMBeUt0HlFDjNAf0J6uyCOhx6wEErUHiA8j3kilBmBpD7QX5D3JYB6SzC0y9KXYXaOUPvkIP4TODrE2ELGJgZQGEHGhSF6QSXU+BD0v4wOCZB8hxoNQQoD4uruDGAtsmADmvUsq1mAG3rwXbQKMTPkHwBGpgB3QYBChfQgY+gcGWAHlwIWr0D8hv47n9FR/DBgKB0ABrIAa0ogYU1SB60VQRUPoLODPmGFpfYyhCGQQ9Gyqwo9QcM4O0KYNoHdfhBB+OCylBQuWAduZHh3pkZwM5/OwMsnYGuEgbV6aD6CLTyBFT/cPJIMHwFnsUDOtfk67s7DLAzZUCrT0Di/1EO/oUlJvLibGR2/kdK+mYYBaMhMOhDYBgPAFC5ghmAzj+sMUpyKhqwTj9ysxa7q0nq/IOMQO4AwlrqcDFYhwtqFzTKIdR/8B5qUOUPmbH8znD/wnwG0KyrIvDaMNByZNByPwbka3ug5iIPuIA6b6A9+6COKmg/MqjTDb5CDrgkGNRBAc02ghqgoD34/6FX+kmpeTPou/czgDqimJNRENeBZjXBS6i/vWUADR6A9ulDvMsEXs4OmqEF7fcFuR004wVaag463Aw82w9UCNriANoeAB5EAM4qg2Y1QUtpeQQUGUD34b+6t5cBdYYTT8VLKG0jhQtiMAMyswdqaIH8z8rGC9x+IAXcj+3HAD7U6/Nz8BJsUOcHtNUCNIupZV/LAOqogq6OAzXwQZ14YeAeafBd+8BbGUCNLPBKDuCeTHBYwJMTpFMKshs0kPHn1ycG0OFnoNlV0BJxMeDMI2im59f392AdoFluUAcYNGsN2Xv+B9xBA5kN6vRKqfsxQMKHgQE5fvA1yBiRHITet0IdJGBkgM1ygvwI0ga5pu0BAyiNgDqzoFUToKXdHMAD20CHT4HUgfzCDDxUD7RkFRSmoHgGde4g9+E/AvsLtOUDNDsKWp4KWn4Nmo0FLd3/gbQv/fSGBPBecH4xbXBDFjRg8vndLXBHGHTzAahjJqMVygDq2ILS7jvgtZogwzXB2zbOMTBAB01Ay2NB8QHqjIEGL2An90MGrH5AYoYR4nNQJx+0/QAURiC/gM4w+AIc4ACtQPj0+joDaLBLRN6GAXTSNqijBhoYYkDL25AVH//Ae9rBnVrgVhXQyhzQUnBQxxd2uwADHCAPtjAwwAa4YG4ArfgAXRkHyqugRjxoy8S7Z6fBM/Kg6zVfAvMHxMz/cL/A0jYoXAWBV0eCygfQkvuX9/aATw8HdXJBYqDBCpBekHmg8ICsrvkLjSNmBlB8g8RBdoM7qGw8DKArJGFL9BFeYISvZgDN8CM65kzgDj5oJQXoTJAXt7eD8xIo3ECDRqCVB7CtP+DVGsCzPnB3uGG24aoPgTP7wIM0QXEEWjINyougNAM6L8TAo58BVM48B96oAQob0BYYUJkFurEENPABOrgUtLJBSs2HAXxTA9AKyOolZvBACyJvMTLAVhbA4h0yyMEATpeQVASJB9CWDtAAG2ggCBQmoLAFDdQIAK9pBA1KgNI3L3BFCuSWDkYG0HYf8GGwry4zSGn4M+Aa2GOgIqDN7P9oxwh3FDGSFHtg1cDBxP/QA/9A5TroulbIIa/QFXzAuho8GA0cqAbN9P/69hpcd0HO3vgNnhgA1fmgATmQOd+/PGdArBpCdg5avBE5Ez/a+WcYBaMhMBoCAxwCowMAxEQAHTv/yJ1P0mo9RgZE52ygUhWsoYdpP6xxi0WGAaVxiKwALdwZcQ4AINnLiNoxAHWaQA16PlFN8HI+0HJkGe0QhrunpzKAOqAMuO7tBQ+iAGePgcuIQXuVQZ0IUKcKNGsFWnYKmpkDdQZAh7+Blt6DZqdAHSrQneS3T05kAM0Ygjp8EO8gGsCwziF4Bhl4mBxYnhHSaYTdiw2a7QR1xKSBDdo3j4+CG8ngWXJgRx802wZadg5qgIMayuD9/S8uMoBWD4A616AZVtAhbiAbQW4C+Rs0OAAJFQKDAOjpHDaQBI4hRgbwoV/Ajhl4fzeo6wKcJQXtBwZ1vEFnLYA6sQzAsxROrAlneH5rC/hudtDyaNCdyaC4A53iDTml/B54OwVITFoziAHkF9AAAajzC1oWDOoogWZjwJ1RBmgnCRRQjIzgQR3I/uj/4E4GaLvB/XOzGNyzrzLcPTMdHJygZd4PLy4EXzEI62iAOkggfaBGH2j5NAN4uT4DA3J8wJPef6ROIQMsBqH5C8ZnhMYpLL0xIORBZoI696CwAJ3rABrMgVxl9w+8bBnUSQJ1TmEz1aBOHGi5M2hm8wdw4ASUj0FxBnIvuJMK3VoASsugRihoVh/UOQTNEIM6SqADI8H+YYCcjwDSDzqdH+SOD8Br8EADHyA2yLwr+6rB9/2D7fr6CrwSAHR3/q7pugw2UVsYQHu8QR0qKTXgifPArTWgdMorrAY+IRvUEYPtlQXlWVA6AA1kgAacQCsBYGkZNFAG8juo8w+6hpNHWJXh5Z2d4EMqwUu1QeHLiAhXRuhZBOB9/MDBH9CZF8ommeAD8ECDXLDbCBDJE9EhAPkLfXULaAsEeOUFcFZbAXgeBujGBjElJ4aXd3cygFb7gM8U+P8H5lwGbHkU5AdQPgTlK/BSYaDloE4naKYctGoBNLAFCkNQegLZBzpbAmQuI3RgEHSfOGjFB2hbDGgZO+gsANABjRC7EPkQtIIINMgI2moBWgECuhIU1AkHxRuoUwIyHxRvoA4/KHxAKzZAs5agqz5BBxyC5EBXoDIQdf84ohyCl7mMkFVQoIEK0EGKoGsX5Q3iwedLPL2+lgGUDkGDVCB3g1Z+gK8lBV6DCRqYAg0Qgc9XAN6swMLKDT6vAHQgISjPgwaOQAOnoHQOHwhAK09A6Qe00gR0qCB4SwzQHNjgKsjv4K0h/HLgAU3QKidQ/EH2Yr8Dn2sCGgh78/AQAzuPOAPo+k54GmRgYGDEHHllGJxgtONPfrww4tSKXpUhbxEB5xVGBgbYtp3PwL3+oA75Z+BgJaReYGZQsywCDlgeBg+IgrfYQLfroFo4OvNPfNyNpnOGUTAaAoMsBEYHAAhFCJ06/4zIHR1iEwmsQYXhRiwNPQZkMVqkQnyVMbocEW5B8xNKgw4uBzEX0YljgAyCMEAndsHSkMPAQHvmQZ1hUAMSfAgfEyuDAPD0eNjSY3iIIDVSQaaAOk+gO7dBNwpAlkAzgQcSQDPQoMOpQKeJg/augq4UAnUKQDNQoAOHQLOD/7Hsg4XYwwh2JzjOgXttQVsKQA1pkD2gRgioYQvqBIM6zKDGB6iDwAvsRIE6CY+Bd/6D9qKDGjGgWbunNzcywDrEoI6fnmsnA2xWUAB4jRFo/7+sdhgDqLH+BbifGOZPnA1kLGmKEdq5hcxUSzOAZkZAjXdQYwm0TJiTT4oB1HEHzU6DlgTL6kQygA7pAoUXaMk5qKElpuQCDjfQAAWsswLq0ICWq4PMg1wD+Bu8beA7cEk6ZHUGA2JQC9rhBs0K8gEPbzQLWgReog6yH7Q/+O7paWCvgaIcNPMPPvUeOGACGiAArU4ALTHWdW5leHptLQMDdFk4yF2gjgVoAAM8e/j6GgMD+gwOlg4+uHuBNADAiNT5h8mBOm6gWWjQMlPQLCUozYFWRggDT3QHH/wIWuUA7diDlnNfO1APPKjKggF0NRpsNpcbeBsEpOP3F5Fhoe4DrSIAdcwh++P/gmfAER1MBvDJ86CBK9CgDHiFAFgfI4NZwELwipN/0MEn0Ew/KI6e397KcP1QC8PTG+vBy79BnTJQPEE62H8ZQINfoNl70EGCoEEIUDyAtnWAOsigLTjntmaA79+Hpy9ouIEGckCz2ArAQwtBHeI/wGXkkOBiZACtXoAcBMkMTp+s7DwMoNUPsHTxFriVARQfqPvrIYM2yAOKkPz/nwF2OjfITtC5EuA8BOwggmbOQdslDD2BA3PAmTw9t26Gx8C99Lg6zaD8BrpdBDTjD/IvqMwA7ScGDcKBZ8eB+Qg06w3q2IMGbEB5ATRQAbIfFOaguAdtRwENFkgDV5uABnF+fn0BHrxigO4fZoSVYUAadD4DqCMLmm0EpZVnwMEzULoFYVD545h4CDq49R/YMSlmAJVFoO0PH56dBc+8gwYgYKtAGJABI+4yGZJZYINrjAw/Pj1lAJVB4OtFgWkFFH6gs1VA6UBBPx58/SDsVhGQXg3bSgbQAA+oDNQAXln5C3jIIii8QR0pUOcflIZB5d9H4BYJ0MABpMRHDG+D8iAobYLCDhS+oPwKOocCNEDLI6gIvr0FVGax84gxgDpvoIFWUFyAVjnxA1cDgNwJKjtAW1tAZfv//7gPHYT5lWFQgdEOEXWjA3taZ8SaB6BqgRTsHBTQwZUcvFLgG0VAA7OgwSQZzUAGu9gdDDeP9TDAzhxCrP7AEn9EzP6PzvwzjILREBgNgUESAqMDAIQiglAjisyIRJ7pZyR1tgKlk4rS4mOAdUBAFR+oIYu9kYvcAYexyfEI/o486qw/EZ1+mBPwdf5BauDyjAyMSGwGKBu5QwayFdwRB+oDNbBBM9agGUVQxwe09w/UqATtZwZbDZ6ZRG5IMIKNBDXmQVEEOr0etLcc1NgFzYSBGvig/cCgGTLQHmdQoxl0WBBolhHUcYM4lZkBdMc5ePkvA1JYM0IOiAM1fEGzueAT0YF7WEFXjYFm8CHx9h+80xzcWQOqB3WkQJ1lWKcJNAsIaviCGzGMDOCOP2gG7h/0mjrQKgVQJxK0f/vmsW4GBtgd9fD2DyPeSEcZlAJ2mkGzlaCzBkCdDdD+aNDVdKDGEmhPPqghDz4UDNgQBw0EgDphIHeAZvhAy/NBe6FBHTnQ8nt+cT0GyGwLaEb8HwPoHmbQfnNQxwmyD/oTA/YlzRAXiQNncx+cn8cAuQrxI4pa0BJiUIcLtAUAtLydX1yHARRGoG0KD4CrAkBsUMcK1PkADd6AluQbek1muH6wCbPzj5QeEWkKEmaQtM0MmWkEHUwIjVvYYBRIvQJwJhW0bBm0YgPkd1BnCjQ4ATrEDdTRB+/nBsYrqDMnoeLJALpnGnSbAKhjCVpGD+r4gA6mAh0MBzYeaRYKNLgCGggCrTAArfT4Dd3+AEqwkDT/G3yFHvjaOlDniBGSV0ADVKDT/UHuAqcxoDjoXAI1i0IG0PYI0InzoAEpUMcO5j5Q2gala9CSflAaAnWEIYfBvQevogGdYQGaAQcNBEC2EEDSuYSyKwN4FQvwXvd30GsNIXmCCdzhBw2InN+WzQC6kxs0Yw9KR6DZb/DSXeDgGSj9gFcvgDUxwAeDYFsrwMN8oHQJ3D4CchfsMECQPtBp8aBDIEHxAQpP0FkGoMMcQbP4397fZwCtSoBd2wgrpyA05IYEUDiA4gy0GgKU3kF+5hVRYwAN5IA6r6CBF5B+UHnw8/tbcBoDxz08jv6B0+frhwfAV/j9Bh/a+J8Bffk4bMAAdqgjeJadmQ08oAbq5IIGxkBnKMD89ur+HqD1wMFLSQPwDQ2g1QmgAQ6cWwAYceRx9LISyAflbdD2AtDADGi70aMry8Cnp79+sB8c9qC0Czq/ArQyArTlA0SDyhfQIAho/z1o0A40+w+KH9DZFAbufQyggRTYIBJ8hRo4LTKB91drAw/xBG0JAs34g8IbFHeg/deglRSggVDQ6gbQgZsgc0CrKUDlLmiwCuRvCeAZD+CBF/jqB9p3qilf/j/a8WegOcBM84wY+QBeCcLbEKCtO6DtNqCzUkDl0FdgOXFlfx0D+Nrc/5TH22jnn2EUjIbAaAgMohAYpgMAjNQJYkZGqkYVcqefLIMZGRkYsLoJ0bGEdUBADWrQ/lXQ0mOINkJ+gZlBCo3bF6gVLiNkryfYIQzY/QDzG5r/sA6OMKL7F+QOqB1YZmMh6wH+gzuKoAYjaMk+aKkpCMOWWKP4BO4G2AADJOxAjX/Q7BbYNiZQ1gEuQwfu4Qd1ekCNY9AyblBnD9QZA82SgpZMS6n7gk/MBlf+MHMZISkB1PkEdYJAM7mgJfMgGrSkH7QkHtyRAy4nBjWKQY1OUEcE1NAHzVaDOypA+0En/YM6hyD/QNwP6WCAZuRBHR3QwIJZ4EKGW8d6GUAduu+g5eVojWVGLCtPMMSA7gWd9g7qMINPQwZ2ukAdSVCnBDSzDl7CzifDAJpNBy1HN/Gbw/Dy3m4G0AAEaCAE1BkAmQnqzIE6tSD3gjrkoKvrQPEBCjPQvmxQwx80Ww/qiIIP9AK7FZEeYWkb1DEAbRkAmQ8/SA8cAP8Zvry/A75DHiQPig/w/e+/vjKAb3kAdoRB1zqBloODOojgGVrgFoQreyoZIFfYYWvkMSKt1mBmQHQSmcEHEoJmKMHLvoF2IKKXGTybD5qtBJ3RIA2cSTqy1IsBdBUeqDMJOlQO5B7QgAconkHuAK0eAYUZqHMpDjwwEDTIA9p2AlqSD05vwDCHHfQHSe0MDKA0ATIflI4haqBuZYS4Ez4gBo0/0H5qkBjozASG/5Dr/kChCxq4Ae1xBaVjUAcOFG6g+ALtt5ZU9WbYP8+GAbSCA7SPFhYvoIErUMMY5AZQpxDUIQN1AMFXbwKX3oNOZgctaQcdhnf9UDM4PMBZE0jwiWowgFZCgOTVLAoYQKtwQKsLQGbIAs8nAJVZ/5Gv6WOEDG4ZAQdqQINJoFsJwEvFGSDiEkqu8PhFrLphYgB1ZkGdRtBKDFBYg8IKlC9AfgHdCIHI88hlHgM4jkHqILdS/GWArMJhZQANiIDiBLTc3dhnBgPo5HpQeArLmIP1QO78f8AAytegJfWglR7gJfzAgykZUGaoEekMlCdAg5GgcgU0YAHqTIP8fuNIO/jgRNDAGOSgP8Q1paAZb9ANC6BVDeCBj3+IFSI4y0vkchXKBm+9YAItdy5kAB1+BlpJAOrYgzr8oLwOWlkDLsuAbgflI8iBn5B0B1otADqgErTCCDQACToPALQaBJTGQPmSi0+WAbQqBzKI8wca1IxwGjSoBPIHaAYflK5Bt0qArpf8BNzLD1qRoglcYQA6hwC2TQa09QF0YwCo3BFVsGcAbcUCYciqF+ydM4ywwFp3MtARjHb+GegKGDFsQ2+XgPKvVdgaBglVT/CVf6AbTUBlm3nQEgZROVvgDTCrGSA3UfxEGmgmb/afKl7/P5TS0Gh6ZxgFoyEwiENgdAAAV+RQqbFAcacf0rLH0fEHS8J9AJ+VBDbqQJ1AyHVMf1DkaZ0WIW5ANPQgKxKYwDNuKPdhI3f4kcIaObxwd/4h/oZ1CBmgJ82rWuSBT4iHnOoPcQNcDQMDZLaW4T90yfw/+MndsDBBsY8R0imA6Qfvewd13EF2ATFoWSxo8ODv7y/gvfGgpcugDhLoXAGQWlDH6C/wznHwXmDg3kLQAWwM0LhkhA9SMAKv0ZMFX3UG2lMLutoONLsFOmMA1OgHHQoH2ksOGXT4zwDqKIJm0EF34IMa3aBryUCHrXHySgCvglNngHTwGMAHnYEOwgN1REB7Y8WBJ8eDDj0ENbQ1bCoY3j8/wwA5mRyRGvCmU6C/Qddy/QNeqwfqNIAGImTANxBcBh/aBjqZG3RnNyvwsDNQx+7m0S4GNvD970IMoK0QKsCT6UGdA9AKDFAHEzTDDFrJAJplhC3vBnXqQR1m0IABbFsGJIkwMqCnKXAHEXjWAOwEechMNsQvkLvjPzJoAk8jB3VyQR0Q0GwOaKWHPnBG8s6pyQygO6DBAyTsvOBDIUEdUQbwgVH/seQVRrBfQHaAZjxB8QreCgG8Ygq0teI38N520GoG+PJ7aPoADTSA4hB0uB5ID8itoE4rqEMIWjoNohHN0//w/ajgziZwBhiUf0HpCRT/oJP9XwEPovsP7rQjpX1GSGcVPFgESt/Ajj8ofEGzyqA4AM2ugs+nAN4wAFpZAvIz6LorUHjI6cUwgNInSAw0cw8bXDi3JYMBdBYDaDAG1CgG2SYJHMQCxQFo9hU06wq6lhAWb5BrAZ+DB3tAYqCwAaUB0FJ/0CAkaDm3MvCGAFA8gLfQALe8gMRBeQTUkQZ1AEFpCbTnHnS/PfhgR+BecAbolgVGaOcftPoElMdAA2RnN6eCD6cDDSyBBrlAcQvqFIK2GIDOHmCADhzxCKuADyAEzaq/Ag5IgdIGKHxBgxIMsIY0tnIeFDHgTjUoPUDTBKgTLKEPzlugDsHtE/2gkgScNkF5EWQHaDAPtI+eCTxw9xdczoD29D+5upoBtqIHviILoyHPCN53/Ba4UgLkTlB8gVbZPL66igHsp/+Q1UAg/aCVEqC0gZ5mYYkXa7kJLXvgg0IMoMP/5ME3aIBvlHh8jAHUwQalWdCBe6ArVEEHooHiCRR34MEM6C0AIDNA8Qra3w/q+H98eZkBNHgDui4NdD0gaMAFtIIFNLDHwABxN7xGYISssAB15EEHUYLO6wD7Beg+UBoA2QMqm948OsQAGdiEnFEAyjuggSZO4MACaJACNBAD2joA2n4FOtyNYVCD0Y7QwEYPnoEAYP4HlxvA/H3reB8DaDUVKP2CtqM8vLQIvBUFds4PIg+j+YaITjlVZv9HO/8Mo2A0BEZDgHohMDoAgCsssTUMiQx3qnT60Rps2K1GVGywjqqInBUDqJEO6uiBlk2CZqIgV6JBGiGMFPgLn/dRO2lgx0OUM0KWuoP2sINmB7UdGhlAp2pDu9cM8LAC7csGLuX9D12ujNUuRsTAAqiRDTk0DzKTCeoYgGYnQTNmiKCDzewxwGdxoY5iQAkHqLnYBwCYGEANT7PAxQygGSnQnm7QLB1o2S+o8fv57W2wH0CNVh3gHnNQYx/U4Xv75BgDaHk26PAz2BYDmJ/B7gMO0ogqOIJnLkH7ikGDCaAD1UB7D0GDCOBZamDDGtzZAi/d/88A6tCBDtF7dmMDuFPKwsrJIKnqBW6kgGY3QSfigw7eAs2+gTqlcnpR4P2zoIY8+Bqxb28Y3gNPQoddowVZtc7IwIA/YhkggzgM4CXyoIY3aE/y6U3J4EO/QJ1JcCP/H+SkfdCgBCieQecZPLu5GXyYGGj/N+hUddDeZtBsOSjeQB1V0MwnbLn3R/BhdaDBqv8MiP282NwG6hGCHPyfAaOjA4tHIA26WQG0WgFkB8jvoI7uE2BnCjSLC9rvD0onoFPNQX4DdeBAM54M8BUHsKQLiTFQB8jYdxbDm4cHGUAzrx/A+5p5wYMooPMKQIexvX18nAE0Gwsb3PkBvZoPtGx++0QlcJ4EDYCBtomAT6MGxSlShx4RBaDDDV8ygM5KgHSa3zOAbogA52FocIBXLmgFgffyMwLPsgCnZWD+EQSeaSGvG8UAGmABbQ8BbacAdch5hdUZQNsuQJ000MoHUKfuyDJvBtBtALCBHFB+AomDBpiOLvdjAB3OCNqqcHJdNHjlAqjTB1oaDrqjHxTnILeBBplA8Sip4gFOZ6AVALCtAZBrHb+Br8gDDehAZnLBKR8Sbp+fAQ+YewEe+AB1FkENb9C2DtDsPPgcAOAADwN0wI2dWwS8ugSU/0CrFUD7zyWA6R505R+4rw5Me7DBOHCnmAGShkDxCl6RAzxvAbR9592TEwxYr8NkZIQMsMJoBgbUtMUIGWgBpVvQygxQhwE0QAPLR6DwZwMejAfKW6BZclD+B82og9wK2nYA2goBOzDwPzTekTsEID+AtiaB8gAovkDxBl4SD/QHONxgnX+UDsA/Boz9yEhlOyOWlT0MUH/B0igoTYHKHNCZGqBwB9kPWs0AuhINtIIJJA/KL6ByDHwQItA9oPQGvoUAOLgJWr0AOngTtHIANPgIOrMEFOYgPmgrC+hAQdDgDEg9aFAJFF8MSFtldF3aGR5dXAy+kQI0IAYKs2+fgDdegFfqyDFAtlmxM4DiH2Q+7IaBH8DzFECrD8BbEe7vRwyeYSnHcJURDGQA8pb/D5POP606nzRqj2BGL2ZdAmkD/AdvlQINYoHqcPCAIrC8ANUfoDwAmkwAXf8HGjAkJ/5Hl/0zjILREBgNgUEaAqBScRgOTzNSFtxkVEo4Z13IcQlR9iP8CO/Mgvdps4E7rKBOAKjRe/fUVAZwZwTUufmPNKPFwMDwnwqVOvYBBSS3ATu6oNkx0HJ10B520EF0/8DXVsEObWJkAN17DlID2n8HWiKO/0AnyIww6GR1UNCClpKDGvmi8vYMkKv1vkOX6gEPGQMenAfadw2qhOHxgzSIgLw6ADKLipRuwJ0PZuDp8tcYDi50YgC5D3R2AGjGCrSXHDzLBww/Tl5JBtAyeNBAC2hmGtQxAmHw8m6gA0EdS1BDGbXjAfIDEwNo7/nxVSHg5dWgmW9QJw3kF1DDFtSJB3UEQHEH6jhCZn+ZwAd1gQYhQFsGdF06GUBm3z8/n4EBvs+bGXz6PuhqI1DHDzSLxgK8yQBkPmgwATRripg5RMv6yOkBJQ0yMiCnMUboLDfIbYJSpqCUxACaRQad5A2Zgf8AjtP3wFPkwQeDATs9kK0M/8DdEtDJ9eCBAtA9+P9hHX4ojbWzg5aJsOQP5PwH6oRCrgbcDx/44QXeAgEyBXz2AJAButMdvG+eEccgAwN0dh3kYtCKGuABUSD97NziDKDBLNAsLGjGFOQvUPyDOieI0+qZwHEKSgeghiRomwJoNQZo8AO0ZxrUCQKp/Qq8Kg+R1pHjgpEB1vmFDL4wwf0B8htoBh28Vxw4AATqOMMO+QNtOQEN/oH2m4Nm5sH7tIEHCYK2iYDUgeIe5F7QzCloyT3sDn/QTDwP8KT/vbNNGUz85jKAV7sAZ7FB1639Bp/M/gG8nx3UIQPpBw0KGAGXwIOud2QAlzmsDKBzDECz37B0CvIXeOksMI7BK1iA6mDnYiDHJmhrCWgZOWhFzZ1TUxhAWxHAN0DAyitg/IAOyQNtYwGFGcjfDNB8BbrJQ8UsFzwYBvL3rRMTGEB+Rd4+IAM8ABN04B9MDJ4PoWkdVwMda3nOyAhe3g8vT0D5AJg2IIMnLAygeAFt7wANBkC2dOwB33wAyhOg1QGg9AI+FBPLif0g+5RM0oGH/c2A5GVwIDGCO7f/4WU3LOQgaQXrgWTElumg8g0Ux8B4B52JARq0AA0ggsstoBmgQS3QgCpoy4WgpBF4Lz8orkErmkCDaaCBwGc3N4FyCQOoDAYt6b95vBd83SFo4Bm8FQNovkXICoazm9MYQKtskM8pgAxMAW+XAK4qgJxn8YcBOW64hZTBqxNA6Q+U7kD5ixt4xamooiPDzSOdDCC3gAaOQKs5MMpXtDDAGscY4US4GUR6fTlEm1b/B9jdNB0UwDUQAKmTQYN8oLIdVM6A0h7oph3wAPd/1LYTvAzDE1Yjb9YfFCrDsDvBMApGQ2B4hsAwXAFA384/rpkWspIL0gwUfv0QP6LMuoMaowyQjhpodgR0QBWoQwqafUbZTwudgQGZjzlrT5yrYfoIdf4hnRhG8J3W4sC72l/e3wteFgvqnIBOuwYNCIBnCoGzSVr2dcAlqNvA140xMGCrREB+hnVEGRlAe+FBd95DDvy6xgDq1IAaiqDZQ9AyYjngTCiokwnaTw7q+KLOdiPCDzIjxcCAfQCAkeH++bnAJfrGDEomwEbsmxsMoCvY/iPtuYU1EkAzXyB/gWdUX14E7z8GLY0HLU0Gn3wPO4CPAWY3A3jJLWipPMgPoAYxqJELWrkBWj4O6pyBTmQHddxg4QEKb1BHDXQ4EWjmDjRYAmqg/wOf6A6ZEQcdYAQ6HRuULkGzaaBOIegAM0jj/htS5wKcAlAjHJb+MBpgyAMAsK4RI4O2YyMD6CRy8HJv6L5zULyAGvqgO8QfXV7KAF7qzgja6iDDANlP/Ad80j8DfE/0f2gUQOOcEcrFl40JNRCBjTLwnn+kQS9QJwU0KAbbww7vZDJAGi1w6+BmQ/0MHewAdTIMvaYwgOICtIIF1NkFpRk1q2LwlYegPAbLF6Ar7EBpBHJv/A/wdYWgtKBolMQA2rcNGgCDHNz2HzKwAh4EgfgfPijFCA1n8EAUIn2CZvZBy/tBM/QgN4FXLgDDEtQJBQ1OgTrZoNksiP8ZwB1iYVkL6B3XZ8G+BaVZ0N542JkAoGXUBxc4MJgHL2cAnXYPvu4PmCdBBwWC0uHxVcEMoI4fqAMEutZP1bKQAdSpB3XcwGcQfH/HAFomCxrcY4Rub7m8u4wBtEIGtK0FtL0DlCYZIIUOOK+BOnCgMwRA7gS5HbT3FrQEHJRfQXkJsRKIEbzfG9ShBjXMQfvsQdsTQAMRRt7TwYOboLgEDSIYeU8DnrexAVzGwDqTn4CraLA2xKHxjN7RZ0SaOUfXxwiO/X+QHMwISR+g5fKQgZG/wD3EMuDBQNCJ/7DcBSqXQOUQaL87bIAInulQOg//watzEGX1fwbYagbUTEqggc1IRP3HCClLQUv/QZ15E9/ZDKBDGuV1oxlePzrMAEq7oFVOoDgDhTuovIH5BzRwBurMww5HBImDDnoE0aCVRqBDK0Fmwq7dBG1pAnWiFA2TGMBbCmDhC3QDKB2CDjmErJb5Cw5dBugAIGgrAKh8A5VboFUXoHAEdc5Ag1q/wFdF/mWApIO/DBgALQzQ45iBLmAIdYT+D3K3MjJSOcZQzUMMbjOCB9hBV4eCrvCFbCX8j3uiZLTzjxYvo51/hlEwGgJDKARGBwDQI4uIygbWSKRaw4Lojj+sGcaAmJEFN7iZwKdxgzqRBp6TgNdELQbP4oGWdoJOUAY1thlAnVZwuw9W+UEagWAToY1Z9I49IxZxRrzhg1SxMkJCCWQ3aP845DBCZgZQBwa0RBTkLlADENSos47azHBxRwEDaKYUtFwUPIMJjxeEOyFuhcyGMoP3ScsAT07PBc/KgU7MBu0rBzU+QbNwoD3noGukQPdpw0+/Z0APP6h7YW6F2QltIMM6Y6A97KDD6kB7okGNYtCSVFADFzTQAupQMkJnAUHLu1/e28sgKGEI3i4AOtAO5B/wUm7gTCok+BGDGKDOPeh6NT7gEm3QoWmgsHoCvHsb1PAAHSoI6rCi7P8FNjhAy3FBfgV1aEGdq4+vrzJABgj+gztWoOXloM6mPHCPN2jJM2hvvhhw1gxkPmi1AvjOeJIKKEgYoXZMGcF2gZdU//sNNg209Bk0EAC5q/4XwwPgqgQwH5g+wVcEgk6pB2r79/s7ku3/IbPNwE42eFYVPIgF8g5sMIARu0uJahD+hw61QMwCLUVGHGCHZix6ZxAa/6AOJWgJNvhKP+BMOuiGBdgJ9KDON2iQCXRX+pNrq8FnXMD2rYNOLgedNQBaLQCKR+QtEqAT70Gdd1BniE9MiwF0nRxo6TjyoBck30HSOXi7BDM7fIUHqIMPMl/XpQPc+QUdQggaWAHd9AByC2j/PziuQGca/IPMqoIGlkAzWqAtI6C0AwpV2AABiA3yn45jE3i2+uhyX/CSf9Ag1JY+aQYdx2YG0PJ00IobUIcMNBgAEgMfngkcYAHZBzrbAXK9IwMD6PR80IoI0AAfaHAC1EkD31MPDFPQqhbYlg+QOtCgAWgfOejAO9BNEOJKziiDKbCyiQE6+wbaYgAKT/B1dGDzZIDbHQQYQAMYoLxyDXiNIeT6SByzdQzI5SYDdCCCEbYonQFnef4fkrcQZSUTAxd0ZQXoNgcWNl4GSIf3JwNoCTHoME9Q2gCVedeAt0uADtOD3JDwnwE+qADvPCAazSirhJA7F9TuoDEiylTQQM5D4O0YoBUcMtoh4PAHhTdk4BgajvB6gAnc6QblZ/Cd+8A0BhrUAK28AvkVklbZwAO+sMP9QKsHQHEGSeOIMGeAhjYofSAGAxlQygbYYAiozgDd3ABKw6CBbWzbKCAacZQXDAyYcUtUGYJwDmmz/0OgI/R/CHfWSIw7BpwAkV4g9RskTMCDusDta6DBJ6yrbEDmjXb+0UJ1tPPPMApGQ2CIhcDoAAByhBFRsVB1NoER0pEiPs1AKixwJ4SRCakBywhe9g2akXsNvPcadEc4aIYMNMsIWpourRkAvscZ1rGAXw+Iu73EwEhWJcsIdxPITyB3gvaOgmbuQO4ANfiVTTMYnl5fB5mxBy5hBh+QBpwdVzJOYwAddAbrWIA6RLABCIhZoI4z5PowSeCJvaBOB2hZLcgvoKvmQDPRoJkmkL+/f37CANq/Cjr5HnS/NUQ/pPGP6FxBl1UDwxG0HPoP8DA/Bnh8QAIGZDZosAJ26B7olHZQxwhkB2iVAWg1AKhzDzv8DHSVG6jzDjpkjxHaqQU1/sFx8eUlNJqhjW+QXcAGNOgKNlBnErT0H3ydHzAsQGECbhSDOnHIqyGAjQ7QjCsobECNE/DhdUjy3vn3wHeEgzonoH3X4M4ncOAHtAIAdDAbaN87eAsAygoLPImAAZbeEB0G0GAHaGvJV+Bp+6AVD+CmNXAABLTUFxQ+oOXx3z49YQD5HzRIIasTBj4IEHR4l5CUMQOowwfu7AL9D5ohB+2RBx2ACBq4AA3qQNpW/8DpD2w72GqkdIWcLvE1YtE79SA/ww1EH0CD+hPqXwZoB+nF3R0M2sCVKaAZUFE5G/Bhj1eB10JJaQSAO8ugAxhBe+BB10eBzhoARzDYqUwMoOsIfwNnxsHL3qHuBJ31cHJtFHi7BEgfaFb0xuF2xB5mqL2g8xNAHWpQGIJPS393mwE0Ww5Ku6B70kGDB7wimgyg6xbBJ8QD7QSdEwBKM6AVMBLK7gygjhfoDASQGEgfyA+QVSpM4O0ZhxY5gwcfQLP9J9dEMIjI2zGAwh/UcQWle9DgGeiQQ1AZAjIDsjf2PQNoYOnrh3vgAYlT6+MY1K1LGY6tDGQArTwBreYB2QG6FhAU3yA9kDMiGMFnIIDOEAB3lIFbgECrD0AdR5C/QNtIQAN3oNldWGcflucZYIHKAO2M/ocMGoG2VAgAr8I7vMQDfJYBqHwBhakE+MDL0wwoAyrgQVIGeP4DnUeBfJsH8gwgA3q5h5zGgHKggy5B6kGdXZBfQDc8gMIelMdBW24ge965GfbNMWcArXwADUyABmJhs4kMkAQOdQt65x9HTUBqWYyvXoGbxcgA29cPcdJfhue3t8HDDSmrgDvPwtLmDKCyELQyAJRXGRkRZQLsJgLQmRGgeAT5FXLg61/wGSf/YXHHgIgDEAu5joHYB8nnoDITtKoDtBIBNAgAWlEBSqeQLSZ/cayMQDWbAUuYYdTdpIYrAzFgkHeE/g+zjhrFcciISJWMkEkL0Mq7X9/fMJCzxWZ02T/DKBgNgdEQGCIhMDoAgBxReCoT5KWhFMctvgYaTsOhnRRQJQXcW8kH3NMMmUl/AW7sgzqQ0lrB4EPKQKfIgwYBQDPvoNlg0JJlUCMe1OEAzQKC2Poe/QygDiJorzTk9GxGCrwFbQwyIq2NAA1QAJuOoIY5aC8wuEOhE84Amp0HzVqDOgCGHhPAM06gU9EfX10JvPtalwGloQx1EXJjE3Jt1iMGUOMf1PkGLa19eXc3eEky6Co30N5UyGFd78GdNJB6BrjXQA1MJgZQ2IAOuwLNhoOWZYPCCNJx+cHAgNLpBS6h/v0VfGo++FT/P98ZII1fZvBMH+RwIMhd9mIKDgwPLy1mAM2wwjpdoFkw8DJX4L33sBlSBqS4B3WIQB0G0DkFoOuvxIHXmUFOtMbSSPuPrbMAFEMSvw3cAw2yD7Q39sWd7QwM0MMDFY1SGUAz2eAOIUZjnAHqZ+T4Z0QNB+gyeEbgCe6g5c6gjhZoqT9oZQFsufb7p6cYQAMw8APugPaAZnzBV9QB3QiacYZ3SBkgM3KgQRpQfINmR0FXjwnLWjGIAa/A+wNcLSEGPCDx89sbDJSkSlgngBGlYw/xL6LzAel0QEUhKY6RkQE2ZwjazwzaIw2a1QWd0QBadcHJLwPuhCgD92yDBq1A4QAa2ACdag4zF3Q4IHggB95x/ccA2vIC6iiD8gJomf4r4GoR8P5l6IAMrBMEypegw/ZAgy2ggQWQOGyQ6d65WQygmwXAh/ABr9sDHd729d0daE75D16+DTphHTzr/h9y5gJodQDoGkLQChaQ3aA4BHX4QQdnglYGgQ7+A53qfhA4KGDqPw+8lx20LJtLQIGBnVMI3FH8Dz7H4Tf44Me9wM6trE4EAwiDDlIErWqA3SoBcufpjYkM4kouDKCT+0EDCKCBDFDH8DNwIAM0SHBhex4DaDsFKDxgA4CgvfsM0EEacHzBy2JECoDNkIM6mqCVMKBBMNCWG9AAHkgMdMjju2dnEAMq4EiF6Ae5ATzwCTQX5BZQGIDOPhAArtaBpNn/8DTPAC5jmSF88FaV/4jwBfJBZyOA77sHioLKzv/ALTigA0BBg6+gARqQv0GDPaCVGaA0/vHVVWinFXTuCcIsBpip6J0yanXSYGUNMg2zFK2cgwj/R0r/kEEyUNoHxQsobYO2aIAG/0CDtOAtL8CBP9ABqSBxUPoADUCD8gfo3AvUQ9Mg5kKcwcgAH4RlQMt70HwHHkwR0WD4CeqEAQcwQXbByhFwGmBkwCgXUAesoeUXmEItQXAP4FNU0jCghB/DIAPDrdOPK3gZKYlDiN7/0JVTWOOT1rP+IEuHXFwNswElhlEwGgIjJwSG2QAABRUAnsqDarP+SJ0/4pMYtDHDAJu1hMyEK+jHgQ9JAh08BepEgWbZQctRQddTga5Ag+3vBc1KgdigRhWoYwjaj6puWQxu1IOWDINOfka4BWEXae4DOw486wtqmIMOnQN1UHiB13CBlheDDrsDdZZBM06QQ5v+gA8VA83Qg2YBJYCniIPuAwcd4gVpszExYHUTI6KSBjU6QbNE4PMOgB0L0N3zT66tBXdYQDNvb5+ehHcEwGYCO6/2sbsZQCfogwY9QB0PyN57RvABVaCOOGTVASKcwR1IYIMANJMN2qsKvnIKeLo7qJMNW7oKWabKwADq3MCupQM1UkHhDRr4ADWMQQfhgRrEyOkIxAY1akEztqBl/vZxexjuAg9Bgx+URbAhgOj8oy4r/s8AGhRB3ksMWp4LPnCOAaGHEWt6R41/2MALqLMD8j/o5HVQHIJmnZlY2MCnJ4P8CQonkPh/6GF/kHBkBl6z+A48IAXq/INmwsGnegMHr/7+/QmOXkhHgBk8uw26mg/UcQINAoC2LYBOEWf4DzkoEuvgG7ENJUZGBmIGALCrAaXD/8BtJvkMoFlt0H3zh5a4Ae9njwcvvwfNIoNWYYCWN0POYQB5Czm/Iuci4EWBwO0SoAET8JkU4GsMYVd0/oeHByhPgGaNQStNQIdBsnIIMjAyszCA0gloAAa0fQCSZv6DT8YHX7XGCDosDrgVAxQmjAzgfAhSywjtyB5d5sPglHycAbTtBmQmKK1DVso8ZTgClANdCQjqwINW4WyfpMIAOpAPtOz6x+enDKBtKaAVJaCbKUAdPNDtF6CBRNBhdszANABKV+Al+QwQe0GDkoKSxuBl+aB9+bCVPKByADTYAUonmrZVDKCVKKC4Bu09h+UhWMcQtC0G1LEEDUKAQhN0IB3YvcCVJaDrFkH5HtQxBa1sAYUlaMDz9omJ4PNDwOkRUhxBAx+yOgq0SgN0vRcoL4I68CD/gG7JOAO8zQJURkLSOuRMBlA+B5WroHQPuuYTefk36PR/ac1gBpCfQdsNQAdyggZaXz84CD7NHhR3kD3yH8H5A+Ynh8RDkAP+GMhsMGPJryiDWAykAkRdyYij7gOt8AFtawKVU6AVT6A0DlrRAYpHY9+ZDJBzHf6DB4wgBzz+Z4CkbQYGyKILRni6Bg2MgPI/SAA0SAu6IQGmBjbgwwg9VBHkHnDZDFQAWiEES0cMyPEKNvo/PI4hcpDBBURIMMIcwgAfeGWEDkDAFFHUaUQO80HYEfo/gjtnVItXYBwTCEeqzPozELaHYVCB0Y4/wygYDYEhHgKjAwAEGgIUdf5hHX4KO/6wxg3EqYwMoOXWt471gGebQY1kLftaBtDsKqgxCjpEDtTIBnWsQXt2QYdggZbpvr6/jwE0UwnqvIGWzoMauY+vrGBgIGpGGFsqR+osMsIaekwMoEO8QB160IwRaKYIdDr3K+BVTaDZYHElJ/CJ3eCGPXD2CLSnGtQwA80YgQ6LAnUEQDOUoBlJkPu+Qxv8yLPmoM4BaG89eOYUuMcZ1EhnBd7nfvfMDPDhX6Al8qBVB7C91yCXg2YdQS3SZzc3MIAO7QLdsQ3qXP4B32v9lwG0XP4/dLYcFsYMkEAHdx5B9/GD7jIHDR6AbzD4B7uuDloJYszOgw4OAnZekRsOjDCTsXVIGRhA+8jB01r//zGQAtA7/yC9KHuJIQIM/7Es+2dkRG8wQ92IIs4ITiOgTruWXQ14cAG0ggIUDjpOzeCzJ8CzoNDZZoh1/xgggwF/Gd4+PgK+lQLU8QIdOgZaio5o8DMygFYngBr+oBUSoNlx0FVvoNlrUKcOfPgYop/CgDsvIjdGGFGDD5Y2kWYbwbP7jLDOAeSaSrAmmBh0fpGDR4wBNJML6uCDVouAzoEAnTr//PZ2cOcOcrgjYlYX2WZYpwq584iQh55PAM83ELeAOz7AQQJZ7XCG0xviwcvywQNTwLQJ3tvOCFm2DVka/ZcBNAgIWjYPGpwBD/gB4xh8GKBWKAOIBh2WBloqDzpdHrRiA7Rf+8+Pjwyn1sUA7/rPZgANgoHsAjkDlCdAAxqqFoUMoLM0QGUIaC8/KB639skwgK5yBHWuQfkblE9B8Q868O3oCtCVgYHg5eGglTcgP4AGOUBmgWeJGRgYYOkMZBZoawIIg8om0HJy2PWAoLgFnVFx63gPcOm8O3CFjyH4HniQm0FLv0GDD+BtOtD8AQoPUL4GzbCDDlbkBu/J/8KAGIhB2AsaKADFFXiQChi+oAENUBiC1KoB/QtyC2jQErxsHRgYIHHQ2QygFSiQ2zwQeRIUZqCyFVTugFYSgK8L+/8HfOAhaJXI28dHwaswQO4FDYCCOrugGznunZ3F8B9lNQEj7mzOiJBDSfOMePSQtFYG0xzMGXTILDtoOw8onFVMMsHnXIDiEDTIC6o7QAOc4BVXwEE9UFzC0zojxNWgFSygLRmgwQFQRx50PgjoYEjQ+QKg8AaV9eCrFKH5DjRAoG5dBoz3+wygMyRA6VBIxgx8hSUoD4JMBR+KCgxH0KGAoDQN9gncO5B8BLqeEuRmULkCqhPh154yQOQ1rMsZwNfFEtlB/j/UOtL/RztnWDMX3vyDpoOIMKRaxx9aRzMMGTCavhhGwWgIDIMQGB0AYGBgYMBRMeDscIDUE4NJTiCQBgoDWmMOvXEG2kMPOe39FNjp4P3HQPeAZsVADSRQIxXU0AItywYd0gW6Mg6kELQ8FjR7xsrOw3AdeGCWqnkeA6hTA9uTjelcZPegs6GqoWEHCivQzDuoYa1omMgAaiCC3ANaAgzaPw25guw3eCYTdHf9T+BMOmggANRQA10fB+qE6zg0gs8qAN1lD3ITaOYaNnMO7jYDZ4hAHSLQyfqgxjcIg08j//kJfPf5H+jd1F/e3YKEINBtoGW++m49DKCZK9AACGiGChQmoL3qoJkl0EwjaLk26DA1UAMeNAMLubaMgQHWUQV1QkDLe8GH8oEOvvr7gwG9UQhJK9BT3bEOqiClM1jagcYzLPn9hy8Fx9LQh6dRRgYkJgMDoRlF5IYMjkYNrIOGOSDACM4boIY0qLEPCjtNu2rgKgthBtAVfx9fXGAAnTAPakzDwgrU4AbPMIM6O0AM8hOkc8oAvuINYRfoDAYmBtBeS9DMM+T8ADUG0NYF0Aw3yK7/0AMGIe12SJjA8yQ8ELA1RpDCDyl9IgccqHNi5D0VaN9OBj3XTvCKGPCqDgZExxHUEQSdTwAalADvcwb6BzR4BlpFo2FTzvDm4UEG0B59UCdJCHgdIriDDUyD8PjEEt7IcQfJ14wMjIyIa/5Aq3JAnWzQ8nrwjDlwvzy4Y8rwH7VUALoFNOsM6pSD8g4D1N2ga/VAA2+gDipoCfrlvZUMoKX+oE4vaBYWVDZIafgzgM7QAO3RB+VFUP4D5UNQuINWdrBx8DOAVhRt6hZjuHNyEjijgwYWQZ2/bRPkwYcEggYY/vz6xADaAw9KgyBzQR06kJknVocxgG4QAJ0nAL4+8y/kcDyQHaDZ8aPLfRjA7vzwkAF2NSBsdQPIraCVCqBVI//A10QCtzEwgc5USAGHN7gTDQwv0IAcyL0iMpYMH15eAA88fgGflYC4XhQyDc3EALo5ABTW3ILK4MEN0EFy6sDbGw4vcQf7E3TI4SvoffKgFQwgDBpQhZVNoBl+eNkISlrAARnQIAdo1QS4HADGM+g8CNhKLJgcaGsTKK0wwFbG4Ml/DCgWMKDUSeCyDxb7jKhlA7aOOwNBwIhTBcqqAqgyLl5pBlC+/vntFXirFahMB8UrqOx8+/gYeAAVcXYDpJ5QNssCD/xA8s9DBtCKFtBgAGRv/28GZeN0BlBah22XApcxnIIMkIGeb+CtYKC6DJQOPgCvEwXlAdCKBNBADyhdgfIqqLzmEVIFDxQxMDDAZ/lB6kBxChr4eg68qvA/dMAWZAdoq8sboJtBboes+mKgAhgkHaLRjj8DvcBo559hFIyGwGgIDPEQGB0AgDUc0CISpfOP3tknOtLxdaCxyWE3mBG1xwduWEEOU2MAn6oPanCCTqIGNcpBGDTjBZqJso7cxAC6WxtUWYEaPqAZGFBnDLSX+d3j4+DrtVBWADAykpackdRDOoAMDKD9yKBZIfD99cDrmkCz8aB7vEGz56AZd1CjC3QgHehObA4eSeAhUQ8ZYNsVQIMRUmreDA8uLGAAndgOOnjqy3vo/mZYRw64cgDU0QcdsAZaZWAVvo7h5d1dDCAzQY3ML7D90ECvgMLC2Gc6w81j3QyglQGgcAEtAwbNBIKWTlsC76i+cbSTATQgAJop5eSRYADPFP75CR9AACcPIAHq/ICWgIM6Bv9RZukZwQ1PfnFd8LkAXPzyDKCOG2xPNKijieikMyKN7SDCGtYRZEBKi7D0B2v8gxqv4CXhoDv9gZ1MUGcWNHABCl/kQYD/WDr82BsrhOIa4i9Yxx7UYQMt+wbNhINuWHgCPLMB5FfQDDToMD/QgNTn19cYDIDnOoDCHbTHHeYuxNJe0JJ6RgaQm2H+A834XTvYCN6uARpUAB0ABupswM6CgGQ96Cw9I6SzDIor1BUb2JIt1H+wdMMI21bCCJmRBqYj0FYJUGcX5Afwqfj//0PHCGB58z8DaGaTAboPGXR4HGgwDbQPGrT15AXw0DRQPgQNjkiqeYGvkALNGkNcAzID1DFAXZ0AjmvolZ3yBvHg/II4lJOJAbRNB3wTxo93DKB97aCtLhxcosCV+KwMkNlocGKEW8EIDRNIOmNkAK1WAQ1UgVfPANOpOPBQPFBYgVb+QGZbGRhktEPBVzEeXxnEAOpMgeIKlF/3z7NhuHt6GsOt430MN4H5AjlUQas9QAMi2sBBOtDe+/3zbcErEI6tCGAw9pkBdvfbR0cZQPaABtogK3tuM5xYE86gYprFADrfArStA9QZA8U5aHAS3vlnhOQy0EoSkDtAgyqgAzYhS9DtwNdHgu/Q//sbPIsO8g/ojATQShHwQYLA+Pn24T4DbMUBfMCIEZJ7QNs37gFXCIFWKIDCEzQ4AuoEgk6zB5VVoDgF51domQFaVcDBLcogrx8PLotA2w5gYYEa3gzgwRvweQTAcytAcQc6vwI02CmvF80AOuATdL0hxgwySnnOCM32yPkRmv7AFCO8YysJ3Cr17cMDBvCtLuB8jkcv2iAyIi4ZGQgB5IEpyI0n/8C3dYC2SoDyA2jFCWjwDzSYAw436MoGRniWYwRe+XcWPNgLWsUDyh+ggZ0n19Yw/AKma1AaeXlvFwMo7KXUfRnAN7UwMoLPZgENSIHOMgGtAAOV/6DzLL5/ec4AGmAAbRFStyplAKUj0GoRUJl79/RUBtBAMyTEIOUD6PwJUNoA2Q1aKQKqd8ApDJjnQbeVgFaYgW/feH4OUlbDBhoZCIcNZtiNdv4ZRhAYuR1/UCSPzvwzjILREBhGITA6AICl08uIPNtCdKcY1mlA0PDZTmDDA9KWI72BgXVpJrhXxMQAWuoIWuZr4N7PAJpBBe1bBc3OgBo9msBtAReAV+uBOsugu+ZBHTjQ7CpoVg10ijho5gXWMCWn2cOAFi6gMAPvTQY2TEErDUD75kGHc4E63i/v7GQAneIMXp4PXH0Amtl5A+wsQPaL/mcAHfgGO1gKdCYBqKML6siDOmgonWcGaIMe2AEGzw4C3QDaCgG6Ex/UiATNhP6D3okPnr9nBC2Z/gruGIBm9UF7jrkE5MCNU1DjE7QsFzL7yQa+qx00WwXeDgCeMYKFCqTDCMrzn95cYwDvS4cHGKIBDtonC5oVA+1tBTUwQY1jUEcF1BiFXbkGuuYMdNc2ZNUFYqYZUp7AW8/w4gUlHTIwgjvJID+AZsNkNIMYFIB3a4NmxyB7sMmpnHHFPEQc1GECNd5BHXKQv5VNM4Gd0J8MoFk4UKMafAjl11cMoP3B4FPoGUADUuoM987OZviHtM/fKmwtA2jQADTwAppVNfadxQDa/gE6AR50yB7Iw6AOLGi5PejgRMiM639w5wrUOQY1ukBLgkHpC7QsGNTBRSzrZUBZjYGRXxghnQLQ4Bc8DwI74KDtCFoO9ZAZza8vGSBLkz8ygAY5YB1IcGoDzj6D9jo7JBxguH9+LnhrA6hzCuo0gjqoIHNBaRQ0EwoblAMNRIHu5Act/QZHJqizxggpF0CDIaCT9GHXN4IO0QPfnACcDQcpAR1kBzqgDxRW3788A868KoHPywAtfwfrBZ79Aer0gtwILl+AZQto0AXUsQXl/f/ATjKoAwtaTg27nvI/OE9A4gbUQQWtVABtzeEX1wd3rkHmgPIQaEuBqkUBeNAQvY67cbgNvBoA1LFl4xQGn/oPOrwRNNMKmrHfOVWLAbz1BxTv/yErYUAdclCHjk9UAzzTDrk28g/4ikz4cnh4NmMEd/JAHb33z86C8yxo9Q7oUDlQWgPlTdAMNCx/g8oH8GwyA2QLBupWC0aUPAQaOAHv8weKqlkWgQ8HBYU1qAMJsguyrz+IAXyrB7AzCD4dH9ipfXpjA/h8Cgakpfug9Agb5AMNhoD3wQNn+EHLyh9cmAfeViEIvJ0AlOdB6RR8GCMD2nYgcIJHznuwtAEdnAKlWWC6g+d/BkbIPvtfnxlA5zWAzAQPSiANJICrBIy6CmIuZNQRxmYgCkCSKyMDaLXI+6enGawjNjBcP9wK3voCOjQRVMeAy7b39xlA6R82KIo8WA3K3yBxfnEdBtAgGyi9SANv0ACt1ABtAwEfvArchgXaggHSBzrDhpmVG5zeQYNuoPIfFO+wmy64BRTB5QhInxDwVgLQeRSgAQTQNgzw4Bg0r4MGDEADCKBVX7C4BB1UCbrqELRiALSdADQwAxokQ9QXDGSAQdAhGp31Z6AHoGrHH+TgIRdvo51/hlEwGgLDLARGBwAYMTtBiI4XE/iOeUScY2tQYTasYB1/BmjDTVLVG3xIHKihhJDDn5Iw1UHdCW7kMIOXvIJmnkCzzaDl6aBGqmXYavBJ9KClvqCOG+h0fMihbW8YQB1FUGMMtGwSfN0c2jJ1kgY90MIMoRfmp//ghjBoqwGoMwLaKwyaNQTdJQ7azwtqvIMa7KAOCmhGENTBlAXeQf0KeE4BqGMP8jtoyTKoAwQyEda4ZYR2ouCdH6Ak6K510IwbqCEIOkkfPAvICOlcg/SCDh8ENSBBHSJQgw80g/YffBjba/CMLWiwAXTgGeSuciYGSNiAa2gG2HQ9wl7IAAQDzFEQBgOs0QtqwILMAw2w/AWuIgA1dsH3vYtqgTvEoJldUCcNvA8eJdkhcaBhy8iAKgbq/IE6U6DDy0BLmEEn7oNmocErAT49ZgAPiDAwMGBJzgyMeGe2cHQSoGENmtkHhRtoyS34pHvgkvQXd3cyiMhZgwcCQB1/UJoCxSPIf6BOwdPraxgQs//A2cDnZxlAKzUeXlrCAF4G/uY6MH18ZgDN4nHwSjGA9gSDTmMH5w9ghxY0mAI6qBLkV1AnFdTAB51ID9IrruIG3BtvC+5QgGMJ77JqRvDMJWRJcBQDeDk2OFYhh+aBOhigQTPQ8nXQkvJ3T46DD5KDdsfAgQm6IQKUXkGdUdCgkaJBIthuUGcXNAgBOiUf1GkFHQwH6tiAlhaDBipA22tA22AQ2zogyQkUVqAtO+BD8YCddZDfIVsM/oHt03ZsZACt7OAT02IAqQNtnwEtpwfZA1pe/wy4pBkWtuBVK8DwA6Vd0OoWkDtAq3tAA2sKwNUFoLQnLGsNXk4N6rRDwusfA+RAvr/AwY/XDLzA20RA6Rx2CCZoGT9oBQADFuBT9JRh+2RVBsj2hL/gWX9Q/IHCRhR4awMo/YOW2Z9aFw0cIPAFD5aAOoGgtAoKa9BgJXjJNygogPEMOlQSPKMN394AWTEBHngCLgcHlQ+gQTXQeQig2fSf4Ks0/zGgnHGBK/4ZsOVVBnAnH7QiARTnoC1GoPICFB6gAULQzDZowBS0ugWU9kArjJAP9gSFO+gAQ9CNBaBbSEDhC7q1AjR4CcqfoLwAGvwBxScozYGvwwOugkJdMYQUsJCCDT7DDxpI4wLeMAFym7RGIAPkHBMGiE+AakErbUBbMti4RCAlD3glCQP4toX/0PKcEVsBwIAL4N8+A8oHoNUhoMGGu6enM4Bn04GDEKDBJtAAL+RKUgYG0KoqyHkqv+GDcbABBFC5ywnO48DtIup+8PoJZC5oBQg43ULLUVD6Ba3kABVizKwcDKAzKMArgf7/g6604GGAXPX6mwFUFoLyF+gGFdChoeDYBmdcyMGdoHoPFCegugc0iAAaNAXlIdiBpJBtSsArBYGrRxjwgEG7/3+0489AD0D1jj/I0aOdf4ZRMBoCoyEw8CEwjAYAGMkLTZydWcjMIahDB7p2C7TsENLIAHUqmMANEnB7A9whZ2RgRKGZGUCNDpBeRiZWBvD9xf/+oLgP10AA9o4/emeQEXyPPhefNAPIDsiyfl3gvvuV4I43J3BpPWgGGjRrCLqeDtSIAu2xBc1IgQ7QA82EIM9qwRyG3ulkQGugwvlIPsHWUWWAXhsH6vyDlhiDtwMA9+n/+vYavBIA1EEBdf4U9GIZQDPAoM4+aFYNNGAB6jCAGobgWSGQPTCvg0+IZmGAhDlkKTm4sQvaZw7s0INmfEAzRF8/PmBAmY1ihCwfBy35BIfV52cMoJUJ4FsEgJ3Zb0D1H6AzjvBDpRj+Q+MTNpAAdQQjngEAaIcZdEAeqGEMGvQBdSbYgbOloE4ZCxsXA6jjDzmh/y9STx2z8w/xNsJOMB9oPqgjCl6FAAwLUEcbNKMK6pCA9hpDtlEwQNIlUB52XRZaoiMuj0DzBGi2E9QJAS2xBcUl6HwEcGecX5YBNIMGnokGhj/In6Bl8SB50IwaaEAK+cAzkN5ntzYzmActAZ8NAdp/Dpo5B81+g2ZfQZ0A0NJgUEcCPIsONBO0RQM0qAG6GQGUNkAdNFBnHJR2QLO2oLSE0hFkQE4siHhTNExmALkLtLUE1JkE5QtIHmNmAG+JAaYH0KoC0B3ov8Gdtf8M0ETGAGKAZsXBZ1l8fwsOW9BNE6BbG768v8cAuq//N7BDBNrbDNriwiemDd7DDKJBK1P+wZcWQzpxoPwDsgPUMeEHDgpBluQzMYA6STC1oPQBmpmGzJb/BW9JAeUF0AoDcGcI2mEB+YETGA+gQy3Bq3yA1/X9/vkZfNYFqCP1DnwLxm8G0J39oFQLGmQDrRgC7+UGrtoAdaRAKy52TtVkeHB+Hvh+f9DyaJBZOo5NwC0AXRhpRdk0mwEUnqDkAdouAOqE7Z6hzwCajQV1/kHhBopbVfN8cFiBr4cDlnsXdxYxgM5IAA0SgdwNGnSBDES+BA8igFZffHpzA9ypA8U/SA1osAV83oe8LXj7AKgMBaV18O0QDCgFECTm4eUEAwNGuQVS8R8yuAAKZ9B+f8iWgb/w8gTUYQef4QAMQ9CqIFDnEzQQAT5XBGkFAChtgzqRkPL1K4MW8EwM0Oor0FWLj6+sZAANXoGcAtqiANoOhZwPICmUEWseBMUR6EpD0CCCXcwOBiEZc/BBdaAbS0B+F5GzBR/ACRrYAQ0igg4vBOU/UBpWNEoGn52CXO4RHgggNKPHiBKuIB5oEA90OCdo9QuPsCr4QFVl4OGAoPQGOogRdbUWpCwCDVqABrBAaRi0Ugm0wgocptCVG4zg1XGQuhYysAst2xkgg3diwINjQZ15UNoGd+oZGMDlO2hFAWhQCDQ4ARoYgqQrNvCWFvCZGKA4A9cZTOBBQJuoLQyQQ2+BuReYL7Ud6sDnfzCQeysDwwDOiI52/hloDf7TKn5HO/8Mo2A0BEZDYHCEwMgeAGDEbIwxQloh4NgJqHjPANp7Cmp8wxrroLvbQcs9QY1IBozCHNw9Bc/IgJa5gzq2oAO9QDOjoAYQuGGKpocRbQABkiwg5jCgzQIzwDqgwIYNaIYf1BAFH5YFXOILbmxD98hC9t+/ZwA1sh9eXMAgpe4PXnYL0gMaEADNuoFmzeHuRwoHSBeXkajUiTFgwABpyIE6QKAZNNASePDSZGCHA7TvGzTjB2r8gWb2QTPtrx7sZwDNvL4Bnpz94vZW8Ane/5FnZIDOAM1yy2gFMYBm3T4Dl+CDZ4XFdMF3RIMdCXUqaLYUfio7WAzWgGUCHloWysAtpMQA6lSBwhC0/PnDc9Ay4z/wqwIZYCsiGKGdaKhfQDOi4CX2jNBOHMhSeHhBBn5AAx6wGTtQ519I2pQBtDwVtAwe1PkEDTiAOquglQagzrqqWQ4DaB8yaOaQAWYeWhwwYLMHKAZKV6ATsO+emQbeQ/sEONsOPokc6H5Qhx3UeQTttzUPXga5dowRlqJgDAJxi5Yn/kM7+KC4BJ27AKJhWw5AcQPyAyhOQR1O0LL626cmQ7ZJwN3/H7y0+y9w28YP4FJ7ULyzcQqA97eD/ADaRgDq6IPCCXS+gjpwiTYov4HSwZ9fXxlAnTFQZxA0oAYaFAANdIBnAf+j76+HJVmE/0B5C7SsGzQrC+rgPb2xHtw51HfrBW+Z4QPOfoOXCQPtAQ1cgDoTSLrBg0CQa/YYwOcWgDrg4PQJtBvUEQUt5QeFOSiNg9IAaGsH6AwD0MywFHCpM8huBiRngTr+oFUxoPv4QYNNt09OYJBU8WQQVXRkAJUrkOvOGBlAS6wZoP4DdZohV6/9AYcjpHiCpDtQhwg0Gw/aJw07JA25wwmy7+r+OnDHWhqYh0Az3sdW+DOABqdA2w5A5RKIDVrGDxq4ApVxu2cYMCgBD2iDHf4XUveHQR14ajpsCwBouwFoIEtWJxK8WgJ0LSHo4EDQCg1QOgBtoQBfYwjcagNOl8ABAFB6BA3sIccQeEYWeLYB6PwNUFiC3QO8zQOUPxjAae4zeGCET0QTOEh4gAF00OLL+3vQsgUjdMCLkUHftZsBJA85HwK0LQApnWNrdEMH7EArh0DLzm8caWcAdW45eCXht4mAbi4BlaGQWej/sIwEHnQFxRdoQA7UqQTlgUeXlzOAyxCgXeA4A95hj7zNigFb/maAzu6DI5WJ4ePrKwx8IuoMz29tZXj37BQDaNUUaKAPdLYC6JrTt0+OgQ8xBA1YgQY7QQM4oHM3QPaDVpKgd1owB5MZSASMKOH9+PIyhud3toH9CapjQPkVtK0MfFgrrMMEDVcGqN9AK2JAK29Aq2Ig52z8AwcFKI2Bb7YAhhfoVhuQWSD/gMIUlKdAW1JAA++g9AS+Oha0jQVaNpsAtxCBwgh0PgxkVQgwHIFbJkCDLqAwAKU/kFmg0AVd/wg6t+TZjY0M4Cs1gWaAViQ8Aq5GAg+CY63DGQYn+D+6DJvWEfOflgM7o51/hlEwGgKjITB4QmB0AAApLuAdWmhj7ebRLvCMDmiJKKgzD5IH7fEGnXr+D3QSPKiygDXsGJngM0+gmSNQ5wI04whigxqQoIEAPdcuhqfAu+ohVoIaVzgw0EzIdUd/GRCzkagdUNAMKGhWCNTIBu2pBnU6QJ0zUKMect3VH7BeUEPq7aMjDKBrvkD+ADWmQB0xxAoAaEOZkZGBActAAGxAABuNkowZIY1xTj5ZBlAnCNThB3WAIXeWMzKAZkpBS/FBHWTI/ftM4CXCoLAEH+gHbODBl8pCzWJiZAYfGgW+61vaDDzTyAI8QwDU+ATtdQY12MEDKwxIQxFgb8DCFRJmX97eBB9IBeqggDqijMysDJDON6JRD+o4SCi7gpdLgxr9oCXcoEYp6L5r0OFVoNlTUIcK4WdIJwwUx6Dl8KDZbFCnHrTKADSTCIp30IFZoM46qGMHOufgMfDgPND2A1AnFnTtH6ihCnEpSrcTmjwQaYMR1qgG0qDOLPLsJPg+bWA6BO1tBs2Mg2Z4QY1o0DJu0J5bsGGMaJ1+tLiGq8HWSYEnDybwjDnoYDoZnTDw7B9opg3UWQV1eEB+BneW0RpQsAMAQSsgQOkBNAgCOp0exAedSwEJ0//g0+BBAwGgrSqgpe6gDiLo9HZQGgDdPAAaiIMs1//IgG31CmqRygj1EiTVgtIgaFk1KP5BB7WB8gqIDxqMAA0MgGbghYEzriBN4I40AwMDIswZGCCzjcYMoE477PBBUIcXdJAdKAxAy5lVzXPB6kADUSB/gs6yYGBAyVIMLKycDKAlyaDZYtAAHOhqPVB4gAYmYOcHwPIgyOXwZd0MDAj/AMsZUDr7D53hBNEgv4BmgkFpFBR24ME9YDyAlrSDDu8DlRMPLy4Chxto1h6kFhy+cjbgTjyIDRpYA83eqwAHp0CDHEZeUxiuHWwCnzOxGXgbgFfBA8iNB8CzCkCHZYLyMWhFBijeQeUKaCYXNJMPyjOggSDQgX6g2XAGaFgqAG8GAZ3vAPMXeOk9cOAFNMsPzgdAf716cIABEr7AARfgYABo9dDtE/3g6xAhK2cQJ/yDVjSB0iJkL/lL8AAnaLsKaKUIaAURIikzgstB5Bs2QKtOQOUzyG5QmgDlX1CeYuMSAq5wSAIfkPgduK0GVLaCTveHDZTC4gM0UAJKRyA/gs+MADXsQSf9w9I+xuAUUhkLi0vIwn5wAgGFHeigVHndKODJ+OshVxkCwwPkNtAKKVWzXOD++xYGUFkD0g6KI9Dg2zPggBboRhjQFXuwQzOhKYUBGVA2EMDIgL6aAOIbyMDef9jKNkZo/QQtq2D5BzR4BQovUIccVC9AbtpgZAClBdCgLuikftChr6AbOW4f72f4C6xXwYM4wFl60HWb4BUVwLAAbR8BlRWg+H54eSkDaPsbqCwHxQlIHBQf+u59wPp1DfjWB9DBsIaeE8EHWoLyAGjbFGQgkAl8fS4ozUoDB8ZBK6ogeQmtjGTABwagIz7a+WegFfhP69UcQzLuRgebGEbBaAgM8xAYHQBAimD0AQDYskJQA5qVjYcBtN8cdKI0qNEDOowNNKMBUgPacw87yRvEB81qgpY1gwYJYA1SkFrQYUrgvba42hrQji+oQwI6NO8P+EoxiKsYYSsTkBpYoGXIoMYpaEYD1AEBzXCDZkxBdoEa8aCGF6jBBWpUgzrRoA7Pf/CS+T/ghjakH8iIaJIyQpZfQpbQMkAHNJgYGAi1jRgRHS5Qow42OwXqqIMa6aABB3AnEbgvHjR7DN6bycwGXpr5D7xqATjQAZ2BZ4SGATe/HIOR7wzwtXCgGU4+UW3w3mWQn0AdFTm9KIb3L84zwJaFgj0BPV2dAa0RCmo4gxqioEPsQJU9aIYZ0omEdPRA+7lB8QpxC2SmFXzQnlYweKAAdLYA6MA9yJ7UuxCroHaAwhPUKOUWVGIAHS71AHhQHGgmCjRAA1qa++bRYfCd7KDZYdDAB2hGDDTLB541ZkDcL86I1CEAuR/UCAalMVD8GXpOAp58DZn9BHVuQMu+Qfeng8LKKfk4A2Qv7A0G0P5h0Ows+BoyYFijLG9lZMSMRkgCQO2lIlIDA9SjDAzQ1RCgcASlNVBHC3QgHvhUdeDqDsRMGjB0kRo7kCBiBO/lZecRBx++BnI7KC5AM86gA95As8+gJc6gjqs88IA70EDVk+trGUADWaCOLOjgRNCqhpf39jCA7rAHzdCCDwVjgHRAUMpnRkRaZmCAxC3I06C0BxqQktePBZ8gDuq0vQKaB+p8g8JQySiFAXR1JOgwTVD+hN8kATEEPOMLGrQAXeeGsA+4TQQ4kPQXfCDlb/Bp/pDBKMSgEizjwDpD/6G3CYAO5ZMAzvyDBqFA8QsaEELupIF88R/Zf4wQv4DyjYn/HAbQ8nPQ7DCIf3lPOQPodoKr+2vBy/PPbEoG36EOcico74G2IIHSINjdoLwPxPL6MQwgv4BmbkEdeVHgMnvwIZz/foGvewOF71bgdX+u6ecZQKuGbh3vZZADzviDBmBA+WTPTCMGUFiC4g8UX5DzM4CdOuCqGlAeAq3EAa+YAloKSsegVQKg9AraSgFyN7jDBXQHaHUNKF5AtxxIAk+D//H5KQN4cA8oB9o2AwoT0IAQaOUPSA84dhkh5RJoDzp46wTw0EFQBxo0QAs6IwK0ZB5kB2iZPCh8YIOEsL38oHAADVqAVpyA4ge0PeXz6+vgcyVAN6mAtiaBZqZBAxmgQUtYOfEfLb2BBvUQW1D+MRANkPMcvNxkYgCtDHl5fy+Q5mWAHHJnyqBpUwlcDbCZAeQW2B35oEHFz29vg89vAG3lAg1kgFYcgbbkgAcq4GU1ZqHNyIilIEfvnGCoQR4AYIQMWMBKErj7Ib5nhPqNEakegZU6oIEx2HWgIGWglReg+AcNfIEGEUG3MoD8CMp/oMEdcF4BDgKAylHQABeoLAPVwaBD/EBlMyjtgQbvwPkAaD0ovYEGQ0CreMCHxwLTELh+BMYbaNAbNOij59LOABr8Aw3SgsrgR1eWM4DswVW9DYr9/6MdfwZaAJp3+mGOHu38M4yC0RAYDYHBGQIjdwAAS2MI2wAAqBEA6oyAlqmCGmSgjiho+Thovyzk3md+8P5W0KwfqOEIavCCGiOgZa+gWRpQJwO05B10rza4YwFubfyHdq4Z4TS4Uww8LwDUiAItC4bNVoPsBM2SIyosRvjsJCN01QFothE0+/sX2BgGNWbhB1cxwJZJ/4csdQfOUiFf24TcQQHP4MlagRugoA4ArJOuBbxNAHRiO7gzid5hhPHBaRviLnHgLDroxGXQLDqocwM+aAu6F1rNshC+ogJ0ReHlPRUMoA4xeCkoA6wRyQRcouwJPm0atH8UNFMECvPfwDvHQZ0W2OFOoNlmUMcDNHPJAHUH6DAy0GAHqOMDci84HIByoNUC4I4gsFEImqWErJaALRNmZADtB4YsXRZggJxEzcUAOjAKpB92mjeowwheov0fcVUcKIxAe2FBnUPQHnZQpx40aw3qVIDsBLkRNFsLatCD4hN0JgOok/Px1RUG2EwyNOgQ6YEBxITMtoNnWIErI0ADFqDBAyEZCwbQwBKoMwVZNczMADppHjTgJArcIwxqTDPBB1Z+AffDRjOA0gZ655IRz4gOfCCCAR4hDCB/ggakQKd5qwPvv4esgjkBXjINGnCAnPb9lwHRYAalO0ZYqgDHMShuvn16BN62ICpvzwBalgtaFQMKe1DHDbRcHtRwB91tD9nz+xF8Ajloqw0ovkADHyC7BCUMIYej4WpYQUYdGCB+ZmaAzQ6ClpKD4hB0tRio0wu6Ag40MABasXJ5bwVwq4EmA+jqTFAHBLzVgQFyCwF84A1L+Q27XxyU1mAHosH7RiD1jJC4ZGBAdJxA+QIUR39/f2EAzSCDZiVBs81s0LMiQPGrBjyJHyQG6/iAjALN5oPC/cenp+DtI6AOLijdg67MA6U7YeChjKBBPlD6gw3YgMohUN6CDSjCB51AHWzggNre2aYM0hr+4A4nMzDdgGZFQeGybaIC2LeqFvkM3z8/Z9Bz6WQA3fkPOzdDVjuMAbQ9A7SVCHwLBXAWGJzmgQMcoPBmBc7eI5+ufmxlIANoyTUo/YL8D9rfDvI7aJUTKF5Bg0GvgduBQOkXVnaBOoygmyNADkE/4R+cRplYGCDnRzwGpztQHvgGPJH+7dMT4MMTwR1G4JWZoAEJyIooyAF14KICuO/8/tlZDKBZadBKlD/g7SkvwDcugMIMtFUJtM8dNOAEHjDFmCH8j5rW/4NKZ+jAD84GP65uJug8FyUG0CqSf7+/M8C2coFuGLiwIx986wbIDaBtVeBBMNCAE/DsElDnH7QtBrQFAFTGaFiXgQdEQW5mQBkEAI+YMEDKeljdQcCtKHUjjgEApHzGAMvpTJCzcUArXED+gdVPjPCBAmg+APLBtzgA6yuQe8GHMAK3TIA7/7CBUHA5CDnsFr7MH1jfgfIHKI1Arrt9graFC7TI5Te4bAUNLIHyJ2gQ0cR3NvCq2J3gsgA00AjePvDuNgN41QvwDA/0cxoY8AI6zoyOdv4ZqAno1umHOXq0888wCkZDYDQEBm8IjA4AIMUN6gAApOEDamiAGtACkkbAfZmnGUANR9C+WVBnAnxFGWjpJ7DhC1t2q+/Ww/DzywtwxwvUYQR1YEENG/isJahjwQBuooNthne4gI0b0MwcqGENaiBrOzQwgE7FB3WIQKdRMzDADqZjYgANPsD22v6DXrsFWsYKanDBZvlBhoP4oFkSEBvRyEGaoUSasQGpVTJOZdB16QBedzaHwRZ4EBVoaTJo9gnlvABYeKE1EiH2MTKAOsyg2W7QSgSQGPjefGD4gJZhPry0GNx5Ac2qgdiQVQ6fGGBLbGEzpZD7m78xgGaFIA15fvBMP6gTBGoAgmaNQYdOgWYnYf4ELX+2DFvDAOq8gTsqv79CZ6sYIDQjZG81eDAF3FGBewQ6DsIIOQEeuO0ANLsEmq0EHaAGmmEC2QmalRJXdAbe5nAL3lkHxR2okwY7HRvU2TD0mgyeZQaJg2YZQQMBoGsYQXt0QcvZQcudQYfGgVY1IGboEY100CwryGWgxj2oMwY6ZZyDR4wBNAsOSk+gTiAorkB3qYMOBAOdrA/yM2gpupZtNQNo1gu0HQB0Hz1otuzjywvgK9hA+sF7hoGHrTFA0x8s7SHTGEUVIyQfgBrToHQMygugJfGgASPQEnjQ7CMoPsErW3AspQRd3waa2QUt8QeZA/KHoIQBA6gxDkorIL2gjiaoEwea3YOk4T8MoAEeUEeXVwTUOT8GbthDZucxG+GMyIMajKAl5HzAgzKVGEDX1oEGFww9JzOADnADxRGoAw5anQEawIOYr84AWpkCmnWGXOuGNqMLT+vInTiYGyA0yuwqOMwgq2nAK4Og2hihS5lBneWrB+rBB3mCl26D1TODrz8DbRMADYxADsT8CykjgPpBYXT/3BwGXed2hsNLPRj03LrBh8KBO02MoCwEvWoOaJaIrCX44DxQ3gMtKweFMXjAALjiBHT+BWiwEGQvaBYWNIhwcm0kA+jaQtDMOGgQQR54OCfousp9c63AS+JBqwMOzLcDXkEXzXBkqSeDrHY4A+iU9uOrQhhAs/uglScn1kQwgA6CBJkH2gJwcm0U+HwDUJyD0jvoOjnQwBwojkGn7IM8pm5VAt7rDrr2EXRyPuqJ+7DhSdiAGwO0DwvpRILUggddgGEKun7v2c2NDKCr/sCdfWCZDCojIUu+GRkgWxOuMsBm80EDiaBBRUiafs8AmkUHbZ0BDUqBwgl08CQoXGE3KTBgW20CjhlEOmQkuEyKgYEBQw0kb4FXSwDdDDoLAnxuApANukkDfM3hf9Ad/EwMoMNEQecBwK6WBA2agQZgQAMtoAMUQfUMKOxBA5GMDKhhBb4CkxGSy9EHZxhwAaQ0DyuXYYkRNsPPiKKGiQFUR4LEQCfzg8JMDHi2BShfge/hB6oFDaRr2dUygK9BBfJBdRcoL4I79MABKNAWAdChf6A0CIobUPiD4gZ0TgSonAENdoCCEORn0JkIoDMaQFskIGEPyWSwlSKglUagchlUDr8AnlsAWqkCGtQBn5cBPOwTtC0IFBYqZsCDLYErgECrBxgGU4dttPPPQCmge4cf2cGjnX+GUTAaAqMhMLhDYHQAABo/GA04YANFAzjbCZrR/wycLQAv6wcuUQV14EBLMEGNKlADEzSTC+rkgRoSoMOOQLPl5kGLwZ0V0NJy8GnRwFkGcAce2HoBDR6ADi+CzNIxIjqTwIYsaAbM1H8ew4vb2xhAB+OBGkGgDih4Xz9w1gfUwAM1ZkH3zIMqN9DMCOjaLVAHEHRaO6iTBW7kQluAoE4a6NR/0AwbaNm8mmUxA3j5OwOsLc0EvIPfHnxYIGh5JmgGFtRBBjXgWYHXcIFm6cD3hqMsJ0fuBDEyIDdqkTtBIHNAB6OBDzRjAO2jPsgAun4LNOsHapiBtkaA9nvCG+WQ1iUDnAJWoKCZLchBba/A80KgTgKoAwxqBINnX4FxBOpUg+ICNEt5YIE9+HpE2B30runnGO6dmcmA7C5wPMM7ZBD3g8IJFK+gE61BnUXwbD1wpg0U96C9piA++Koz4FJp0I0BIDczQmd1QfogJ6yzgJe4g5bigg4sA7kP5E/QAXagzu494IwjqFMC6tiDTkQHDShArgtjYIDN0INo0CGNoLgC3WoAuhoPlFZAqxJAjWhQWmIAhwsXeAYWdPI8aEk+aJk3aDktyDyQ+aDZU5D7INec/WUAHXIGSqugA7tQlwkTKJwYkeIatHwcuBoBtq0EtMLl3bPT4KXToIEqyAATAwNmIxrSSQJf+wiUBnV+QVsbQOEJ6nCCzHnz8BB4YAjUYQWlUdD+3f/Q5fIg80CdIga8M/6wZAOPWPDMICheQDOpj6+uYgANVoDOw1A2zWAAdU5B19aBDl2TUHYH77kGbVMBrQ54/+IcAwNs5QwjNH8ip00G3DOA8I4SUJ808MozUDyAZrzBt0swQtMaMN2Azg8ArQ4CHeAHOskdtGUEVL6AOlagzs/ZLWngAUTwNY8MkPQB2n5i6DGRAXTgnriSKwP4EFJG5FIL4i5QWgMNWIHyM+q5DP8ZQMvjQR0gUJr8gzTzqePUysDBK8EA0gPqFB1a7Mogox0K3loCuiEA1OGXBfKPLvcFh4S0ZiADaIAMdGo9aJsTKL/JaAaBO9KgVT+gTpeiYRL4MFTQwOeVfdXggwdB2xNAy69B24RAeQg0IAMKG9CgEvgsC/C5BgyQOWDQ6fBA/4EGCvkl9JG6zqhlDkgCdFYA6JYPUOcdlMdA5SNoOxRoqwlo2wqoDAKfe8IAy2vQ81qAcSksY8kAOlwPVM6C8w+3KHjLByhtgFaeoKQFjOyCSG8MuOSwiiP8gFw2QQ7z/Af1K8RsEeCqLFC5DlopBbptANyxBd6dDzoIEzz4CFw1AOoQg/wKWYUCHZBigA7rAQc0QZ1fUB1iG7uT4fX9/QyIa2AhjkPuKMFTFCy9gvMAE3QQlQm8nQlULoMGi2GDEaB6CZR2VYBnFYDyHKgjD3IfKNxBA4/fPj5msAJeUQuKG1BeBMUPKF2ABpbBS/CBdvADb9AQkbcDDyCDBg1AqwJAA0OQGz/egq+xBZXToJUqoDADnRsASj+gAW7QAZeg+g/kT8hWlr/g2zAgK8v+g7eageoRUJ0EWW3wFlw+gMpM0JaPR8AzBSD1FGzFHAMD9uX//xnoAkY7/2QF84B2+GEuHrJxR6e0zTAKRkNgNAQGSwgMkwEARtLDkxFVD+YAAAO4swyZTf4GbjCADnKDHLh3mgF8rRFw/zpoxha03BDUcQMdKgTqzDwFzkaBOjOghgWocQqaWQJ1CEGdOggWZ4Dth4Q4nBF8Jz3oILknN9YxgBqdoM4aqIEN6vRJqHowgBruoIYP6BAx0J5wUAca1HAGzRgi9lZCZpQY4I03JrDxoEEK0EDBL+AyS1BjEdShhQxAMDGAZkRBAwSgRheoYQeasQTNhoAOwQMdYAdaxg4+i4CJGWwWItTQwg9pNghi/3/IlWQQF4DHCUCz9iB3/wBfvcYJ3hsObvwDDwODN7RhzV9Q5wY4KALq+ICWNYPcCFryCznpHzQzCrneD7TyAdQpBYcTsDMH8itoQATUWATNNP5DP1yQAdapg4YVqKEMbCSD9jSDZn9BDUTQ7BqocQ1azQHqFIBWJIDc9wc8KMAC3sYAC2MmZhbwSfWQE89/gw8tBM0wwvYHgxrloLQAupoRNGsPiv9Hl5ZCroZE6UyC3MXEAGosQw50YwXvswZ1jEBhBhqIAKUjkL2wWWLQABDsnAjQ/mXQjDooHYJuHQANQoD0QvbpAw9Je38XvHIEtjebgZGIPIMUp5AkBQxzFnYGyLL1p+Dl4eD93zhnSJGyJdQ6UDyC9sCDZu7ePj7OABpku3G4HXwwF2hFCOiE82+fnzCABkEYcHa2kdyOLR9DxUD7pUEDL4oGCQyggaeLOwsYQJ18UMcaFCcgU8Azvmemg/e+g9I6zGTk2U0GBixhBWvooYQRSB0oXTGBO+qQU83vMoAGOcBXcUI7U6DwA3XAQYe5PQEOToBOlAfNfIJXPABvSgDdzQ9a8s0AXS0Esh+UP0HhAzrM7NT6GAbQVhvQjDBoFhhkDmy1DKi8Ag0wgewAdRxB/gBttQEduAhKP6Br/EBnWoCuZgMvuQfONoPuUQelJdBWDlBHSVozmAF0tgHoBHUZ4HJ/0ECYlJovA2g7E2jLAGiwB1Tmgc88AHbaQewTq8PAg2+gjiBoWT1oVYGsTjgDaKk6aAABlIZBbgD5CXL6+z8G0AAF5DDALwywaytBIahlX8MAGggB5UPQICrojA3woZ2g2XB4eEMbrMB4APkZZA9kZpoBskUEWHaAz+UAnksA6hzDBpBA5TzowDhQOQEaxPjx9QX46kZIPoIsYX/z+AgDJA9DVlUwYol/RvT8wwhVhZZUGAnkM1R5Rlh1AFyezs8A2e/+gQF2zgLIf6BrTkGrHEBhDtILWmEBKldePdjHAB9MZWREGlhmBA9MgvwPynOgtAQeKGZA2raAVnvC/MsIXtLPzAAa3AFvfwKGKWh1CmhQAlQ/gQ9zZQBZxcQAvhkHuI1DAHhDC+RWAAYG0M0uDFB58CGeLGzgc1xA6fbFHdCSfGYGUFoBpQnQigvQdiBQXIIPVmQEXdf3h0FUwQ680gVkDreAPOQGBhEN8PWYIDHQACxoNh+06glUdoA6+aBwAQ0wQs7DecBgH7eH4fy2XAbQSqyv7+4Cy5wKhhd3d4LLcfCgKDB+QQMQqHXyADTRRjv+RAf6oOjso7t2tPPPMApGQ2A0BIZOCIwOADDA2lwYLTewxH/gwVggBqjBDtpPfRfYWQAtNRVVgOxjBh1GBTkR/DR41h7UEQMtLwU12EFsbuB1WJ9eXwU2PkSg933/YQA1hkEdTtChgIyMkI4oqJENmh0DN1aBjTNQwwbUeQQ1iCDLxSENLVAHFeSOl/d2gfe6ghrGoFlg0HLzP9Bl7+DOPRNk/ySocQWakQEdhvUffL3WFwbY6dygGXrQ7B34oECgnUZeU8EnmWvZ1zGATr4HLdUEddhAKwJAnQLQbCZoVQCocQxzN4xGJHlo45MB2m0CBytkNgpkP2hJMqiRBlqKDApH0KADaNn6f5TGPSRMQIMWoP3GoM4TSA+o4wY7LR1kLyjsQQ13UOcB1HEBmQNq+IFPOf/xETzzA27Yg9wCDmdmBthsFSPSQVWgjgZoNgjU6QA1okFLoEErJT4C4w20Xx+0NxfU+QHN1iJmcxkYYA1wUPiB4g62DB5+OBho1hw0q/kfcsghaEYRFL+ghjMobUD2eDMwwDuY0EEPUJyBllaDlnyD7roGXZcIPtgRaA7ITtCsGWh2GXSjAKiDD5o5A7kBNJgCWrEBPp0f2JEEHZoF0scC3Av9G7zs9QMDSqeaERFXDOgA3nGB5AtYRwXcaQPu+YYcQAlZKo+vMYbSeQIaBVrBAjoAD7xqAHg2xD3gsnbY6gFBSQPgGQGSDKAVNWD/YWlQMaK5C+xspE4WI8oADwN4phrUkQHFLSgtgQbBQB0/UCcE1EEAdfpB++hBM4ggvSA1IvI2DKB0D+qQMKCkS2ggobuLEdLxBw2egQaeQGkMtD0FNOv88OJCyOnt4NltSD4AzX6Cli+DDlIE+R20/QGkFrb8G7aMmQGabmFpFpTGT62PYwCtkgANKoBOqAetDAGtxIBdzQjSAxpsAi+jBtoJSregVUWvHx0Cxz3Iv2c3p4E766COJI+wGgNoEA3U+QH5+cPLS+DtEKBVJSDXgs+eAF5rubFTiAE0IAAaFASZDbvNAyQP7hQCbxQApTHQCgXQbDrIfaABAnCZ8/Mj5IpP4GAcyE7EYN9/pK41qEMPSY+g2XvI7RaMDKCVSGA/8csygO93B4Y1aDYb3EmEBBADaBUQKA+Dyi3QIB6oTAGFv5xeNANoRQRoNh9kHixfgmanQTPpoE40aNAMkpf+AK8KVWYADbyAyrj/yNeRwvIGSn5hZEAt+xgZQCsjQAOG4MMikaoTzDKSgQEet5gZD1xGgQZmQUaABkBBZTRoMAlUF4AGxkD5HlTOgcJX27GJ4THwCkLIYAxkmxhooPTjiwsMXHwyoKlsBtBZDqABUlCdAhoI4wCucgDNroOtRk7LaPkINLv+7eMDcDkKKt9A25hAZQzoQEhQJx+8JQu4Kg5UfoEHT4ErE24e62YA1Yeg8AbpAcU1qCwFnVEBCnPQeSnPbm0Bb0sCrUQBlbugVQKwzjcoX4JvUQGehwPa+gbq1IMGtED5E1S/gQaq2IG3NcCuUAXfQgGs90D6QekDhEFpTtuhngFUJoLqjrtnZoAH5ED5DpT+Xt7bCxksAW+vYAFvL4OU/QM4Czra+WfABgZlRx+rQ4fqDProzD/DKBgNgREaAiNzAICREUuzC/sAAEghWDm0ggbv+wd2gEAziKDOF6hBBepM8kvogc0EdT4h9zTLM4AayfrAvbqgZaygBiVouSxoST7o1PGbRzsZkA/2AzWUQHulQY1pUMMJfMATcL82yGzI/txfDKBGH2T2/j8DaBYN1EAH7VcHnZQOmtEDuQU80whsVpsHLWEANfJAS4tBe0RBjUhQJwM0kwfu1IJOz2YArTxgBx/SBrqG6c7JyQy/fn5gAA1YgAYMQAMPoPu1b5+YwADqnIC2CIAGQnDvlYSGISOkowObJYeEIaRxD1lWy8AAmlECNdpBKyYgM1eoHU2QXlCHAuQW0IoB0OznO+ABX/Al7EA7QB1FkL9AHRjIoVOMDLDD0UANPXjnH3hgGKhjBhoIAXX2wJ39T0/A2zRgHVRQgxIUb6CTv8HnBAAbh7BODiie4A1EsDMhDW0GWGcTpPbHe+yT6v9hB4YBz6cGbqUAN+KBy69BnX/o2Ah8UAKUnlSB17CBBoNgB/+BBl9Ap+SD0oSySRr4oDpIeP1nAB1gB+r4gc6cAA2ogGa3QANEIH+AOjkgdSD/vr6/jwG+HJYRS0kH69gg03BlCA0gaciMLfB8BTwziNjKUlg4g8IRvMT/P+zmB5jq/+D0DZo1/Aq8ag4xUIElr6IPAqB1XGARAR4sAdpjGboafJ4AqKMH2YJgCZ5hBg1ygcIPvMUA6AxQvuTglQKf4XD9UAu4QwjpCEI7e8AZUUjah25rgK5QALkQtE8Z1PECd06BAxugtAfqMEMGmhBLiyGdeeC1mD8/wWdsQSeXg9MtqIwBYaiXQedagOIdnOeAfgR1fkDLp0HnJIAwqEMF6swhBggh+Q40wwsqR75/fMQActfT6+vBHW1Q5w2UJkBmgDviwHQLSoegfAEaFIRd6Xh6YyIDaAUQaEAL1NEGDTRIawSABw1AA1gQvf/BHT2QGlCZA1uxAd63/g9yywg4DsGDYKA88A/uX1C8CEoag/Mf5Do3SHqClxPQtAVaxQCSBw2Cga4y/Q9eccUKPnQVvBKIAZIPQX4F3VQAihuQH0HL5UFL0UFuA4mDVlaB8y80qb26vwd8jSUoXD+9vMwAWyUEGgwAHQQJKuP/QQ8uhacl2JJ6UJkJnMkG3QwjpxPBAAo/UF4DDTKBzm+BHX6KnLdhaRn3oClajgHGtRrwAEaQ+0EdWdB5EKCzL0AdetAhouBVTsABPdCqMtBMOmwlBjj2gWkUVL7pAAcGQGkZVI+A7sAHlZMg/4K2j4CW4f/HtWoHmpdg+RXkH9CAGSRd/2EA3cLx7NZmSKcZWIbC4gxUf4BumwCFO2hgBTSACbkWlAFcv4Dyg6SqJ3D//yFwvIPcDrotBpRWQVsSQPUSaBAbsm3pH8NfcP3EwAAa4AKfdfD/D/gsB5Ba0CoYkL3GfrMZbhxuA99UAYoHkDh4axgwzYHKGNiqLFAeAKUB0MoPiNgfcIAjDmL9zwArU0ESdF/+P8I7/0Omk4+tYhvScTfa+WcYBaMhMIJDYHQAACnyUWYrIS0bBtjsLHwWB9hAAnWmQKf6g2ZYQbPQoGvRwDcAAA8yAu2hBTXaXwOvfwM1Ru+dm80AapiC9IOWMIIaru+enQHv4QY1EsHmgpbXM0JmlEGdTtBhWaDG0NePD8GzL6CZDNCBSqDl4ZCG3BewuyCzof/BV2eBOuegJb6wk41BHVlQYwnUwAKtOADdcQ3aAw1qYIEaVCDvgWasxJWcwNsP7gL3yoMGCJRN0hlAS/VBgwSgfbzXD7WCT6bWAF5J9ezmJgase/bBYQjttcA6/+DwY0KaJWOEdHTBnWZIqIL2KjMwoK0UYEQyB8gGz2wCG3Sgg/BAM5+gwxfhy3lBdgGX74PiANRQB3VkwNcEApfqwwYVQMuHQf4HLSUGbd8ArToANWBBy8MZoG6BrZgADZZATpm/w4DcaJfWCAQv2QeHN7iDBvELcueAAe5s2MwgEwP4UDvgSgQGBkjnB9bQgTcwGSEpjhE6kADqeICW738HnpYPakRDDsd7Cr4KEdTJAS3zhnQwnoFDXFzRCbyag5VDEHy9Fcg9oI4YqDEMSkdc/PLg06/Bd2/DO5akVPqonW/E7Dtqh5aU8hPUsYKYiukOyOoXXKYhD0TA2Ii0AklHaHxG0MFkhgx3T09j+P7lOQMTeFbxN3gw4OaxLgbIYJssOAxBOkEdFtAAHWg2UVDKlAF0Qj0DeBk+I/hmCtCtFKD8+58By7VvwDQK0gvaogNZBs8DPuUfNKsOuuscVBZAtpJA8jkDUkcfMaD2H5IkwemaCbgKZzUDqKMM6nTBTssHzQiD/ALig1bDgK4vBPsd6FdQ+v8HXbEkLG0Gth9y+B/kRgPQVYGg/APaPgByI/icBaB6UFkGvjEAuJ8ctA0AtOQbvCUA5Hfg4BnITNDAD+RAVHZwhxnUaQZtZwF1DEGzuiDzQDdigPZogwYRIdmfGbz3HzbDDltNAVILWiUAGgAEDWIom2YBl2TvYoCVv7DzIkCDmqCrNUFbB0CHoYIGyEBxAFq2D8ob/6F5EbSSA3S+Aai8A50vATIbdO3kyzs7GECdc8jd8wwMsMEbUCcVFIa/vr5mgPkNJAfyByRMfuNO0tA8Cwp/0CCuMPDARditKaCZf9CZA+B0A1ouL6zOABqcBa0kwmUgemcTVqaDyml5g3gGUAcetFoGtHIGtBII0mmFmKbr1MIAOhcAXiYD3QbK86A6CFQXvH9+BrySC3SeAyjtgwZqwFdC/idwbSEjYgAXttICVO8om2QwgG5rAKUDkL9BA3WgfAMa/ADlHXBaAA5sgZbVg8IBttrjPwNkpQdIDWhwAjb4CVpRAFplAPIzaHUCKD2D6lLQgBNosAOUxtStSxlAh6GCr6z89gY8mACKf9BgN8gc0MABqL4Cr36DrdqArbwC59P/DKADP0EDzm+fnGSA5Q94pxPegRugztAI6fwP6U4+7szLMHTBaOefYRSMhsAID4HRAQCkBIB9AACkANKpA82sgg7LgnTsPjCAOp6gJcOg5YmgRjWokQ9eWskImuH7CD4wCXTNEahBBlqKC2q0/vz2Fn53PaSjwAs+hI8B3GiBnPoN6rSDD4gDzTYBOy2gpZaghj/ogDpQQxV0nzHoJHZQh48feJ3X89tbwUsqQbMl4Jk4YKsMdu4AaFUBqPEOahyDlrbCTlgH+RXUmQF1dsD3svNIgrcmgA52AjXwQMvg75yeCj7YC9SBfnZzMwN4qTaswYIyC8sIn8UGHaoGWnYOchto1hC2FBkaigywVQGQhi7yoAC4KcmAKg6JHFCjF3RQ2fnteQwoM8Ng7cwMoBOiQeGsbl3CAFpeClYDdB9oPyoozEHxBr5fHrjfGjS7D1oOC5oRghxC9YcBNksL6iyAGsngxgojxG2gJc+ghiooPEBbL0BXSoH2s4LTyv//DIzwJeeIdAIeUAB2AECNcdCsImjrAqyxDO5Qgvup0AoYag9ID2iJN6iRDEoroMOpvry5CV6KDjqdXgnY+AZ1mF7d280AWyIOSkugpcKgTh5opQBozzP4DnZgIxw0EwvqEIL3tQMHmEAdCFB6Bd+PDk/zjHiKP0w5Rka0jje5hScea1GkGNEVQvgo7oCqYUSMwEBdBcmzoFlkUDoEn+4PVAu+RQHYqQV1JEGDLKBtFqADzSC3CzCCz/YAdQJBWynAB5QBw44DmDcgVzL+ZgBdZQieZUT2O6xTCLzaDzRzDro9ArSEHjTzCFquDb6KEWgn4vA1qL9AbkfvADCCzrYAbVVhYgAthwZ1riA3iDAwgPY6gzo/sI4sA7SDAxmcBJ4Uzy0GPtMDlMdAt0CA8xq4s/ef4frhVgbQ1Zugw0rBp68Dz3KADHAwgG9jAKcLJsi1iaCOG2jJ+dFlPgxadjUMoIFD0CoD0OoV8JVs4P31CgygVQiglTmgzjfoyj7QIX8atpUM4JsNoOEDKl9Aq5TAg1OggTkGePSA93P//A454A00YHUPuFQbdJI8A3RmH3Kf+38GULkHysOgwTGQPeCr8kCdPXAWZWIAzYpDBgSA26u+v2cADX6C8gpYP9As0MorUJghOn3/wOXIf2jYwAZgMDspSPEEzaegcAGpB53ZANqjDzrPgo1bBFymgw5zBG09EABuZQFvSwCuFAAvN2f4j/A0AyPBXANL36CyCtRhB12rB6JBOv+Az0thBB+wCNqGw8ElCi4zIVtAGMDugFxDa8sA6lyD0jgovkGHHYIGYkArhEDhC/c7hmsY4WU5aDUbaJm+odcUBtAJ/B9fXWIA5QnQICTIHaCBFog5jOBtLqB6BMQHnfQPKotgZ21AtkQwgvWCViGAylsu4NY40OoVyK0mzOBBZlD9CaqvwHEFjF9Q3gUNcIDUg/IOeOsQ8JwBUPiIKbkwvAIu5QdvDQCmK1AeB91qAUqfkEGvfwywwRXQ4AE4zYBu7IENfqDkO0Rn6D89O+TDrPM/LDv5uHLrkI670c4/wygYDYHREGAYHQBASgSEBgBAHSpQhxDUsAR1IEENK9DScVDnHHZNGqhBwyemw8AjqAjegwhqZINmUUCdatCyyLfgA6YgM3KgRgto6S1o7zNotgPUaIV0LiAnFzMwQg7xA12jBTrxHXzaO3D/poJhIgPotHnwdgBgwxQ0ewIaQACdPQBqmIKWzYO8BT6kCdQ5ATbswctagTcJgGb4QHIgv4IORQLflQxsQIEa4KCONmipPGimHHRPOajRCbIDZD7oOjrQtgfYjCg42GCdV0bYjBETeLYGdE89bJYPFDagjgKogysCPEUf1CFA78DBOtGgBiv4GjxG2KoAUJOXEdyPAXXsYU1n5EECkDtgZxqA7skGNYShuhh+Ag89/Avd6gBe/gxUDDocTxS4X1nHuYUBdJI0A3QmlhG+GgCaIKB+At1/rmKexwDqKIKWrILuwgd3loArD8BLsyEBwQB1MXwAA+RGFnYe8KwzaEAHdKiaJvBwM/CWB5QOATQ2GBnBjWDQ7CTITeDO1rfX4C0NIP+9BB5aBVviD3IraFku7MozkH8h+13vM8BujAANIHx8cRG8ggQ0UwuaMQPN7L55eJABNiPHgOJ2RqgfGOF+YUADVBsAQDaXkZEBG0DJi3A1ELXI7gClM8zOPyxMwV0d8CFqoLQMGpwCzRqCrth8DrwaDBR/4Fn9t7fB0QeaHQcNvoDMBJ3RARo8YWZmB6+QAXVUQexv8O0JyJ06yKw+aJYVNJAAOpMDtNwZtNz6L3DbByjNg8/Z+A894R0cxMj+Rm2Qgc50AHXiwINP398xgGa1QQM6oNsgYANoDEhLuEH2gmbxmdm4GEAdPdjee1i4gDplosC8Bz7cErx0/C8DKC2D96uDg4oJ3IEDdeDl9WKAKyI+gK8yBe0vB5Uh4MPj/kNWfYAPCgReywjqCB5d4c/AK6TKABo0BC27B5URIL+yc4szgGbTQUaDTucHddphWwRA+/LBS8MZQdfzmUOvMnzLAOo8W0duZHgJPBwOlD5Bs/2gmX/QIAioUwcevPr6CrzkHlTuQgbBGBmeXl/LADosFdTRBa0oAg3OgpZ5g84yAJ8P8vc3eMAMdcb3PwN6Rw99STxqWoeVQ0wMoMEY0HYvUF4Eb6nS8GMAbU8An9APvCqWi0+aAeRnULiBymjYNa2o/X5saf4/Sr4DJ3lgmINuTADN/EuqeILPmAFHF7h8ZGQAHcYHWnkGGmgEb4N6dQWalf6Dt3GBOvuqFgUMoE48aEUXqEyBXC3qyAA6XR+W78ArLtDyIWR/vjB4cBRUJgtIGjKA6j9Q/IIOpQXVFaDON8Q9jMAtRt8YIIOz/xlA8QuazQet3oCtxAKtVgKFBb+4PgNoUOzB+bngLTaQcwIYwOdQQMpVJgbQ6jeQuSC/Q87CeQce2BAEugHkbmY2bgZQWgYt+f8DHVT6+v4OA8hOVk4B8IA6+IwSWDkLS7sM0KsyGUgFNOgwDfHO/4jq7KMnl9HOP8MoGA2B0RAY+iEwOgCAFIe4BwAgDfw/4MOGHoNn2UBs0Kw/qJH198838OzczaNd4HuxQXu2Qct9QUvtQQfZgQ4mAjWGFI1SwVf8gXoboBOyQTMqoIY9aDYFZAZohgs0AwJa/ggyGzTzDloyDdqnCmr4gzom/KJaDA8vLoKfkg47CwDUcQe5BbQMGdSBhN3dD+4gAQcAIJ1ATvBd95BOLyMDqEEGauiCBwVAKxCADSRQw/XptTUMr8AzLUzgRh/oOjrQKgPYPnJwow/aooV0/SGzRqCOCMjNoJkx0OwkqJMA6pSAGmmg7QaQ/cxfGCADAgzQ1QAM4L3fIDNBM928wqoM4Hv3gYMfoFk/yOwcxHxIJx2yrQA0OMIInX0HdYxAWx9AB/SBzIE1TkB+4wN2VkB7sd88Ogq+/grWCL20u5QBPDPFgD7YAO0AgwYAQMt4gSdOgzrTslqh4OvCzm5JB3fIQLNdoJlj0AFskP4cI7jzLwNUB1puysjMCl5CDrIP1DkBXyf59hYD/BR+hPcZkDsbIHlQOIFmjWGdlP/Q1SGguIGtbgAttwbNSoMPchNShvrtF3jFBijdQQ6kYwHOhn4CHwbGzikE3ioCuyYL6+F2BMozRpROAiN1Sz8sAwGYgwDIAwCM4M4JKJzhA0JwFyHUgfLBW2Dcg9SAru8EhSFoTzU4nYBnBP+CZ0pBAyRyupHglTSgvd2gO8NBNyqA8iWosywsYw5e7QFarv789hYG1E4TI7hDAuqggJIkaKABNBAD2jIDyjPgJeefHjOAOlGg5eqIWzuYGECDUagHHv4Hpv/HDKBVQ6A8DepYg8oSkDsQS+gh/oNvRQCmD9Dhe6DOHehAQVB+AM3AggYOQduOwIfaATtDoFUN4BP1PzxgAF9FCm3Igq9u45UED5TAlsGDlkqD3AVxK2TAkltQAZy+QFtRQOcFiMrbM/wD7s2GXdUJnoEFLtMGrbABlSmglROglQigayhBfJDfQeUIKE+DBjdAHTbQwNy1g00MoLwPuj8edCMByHc6oOXtd3cxgA7eBB1iCcrDx1cFM4BuSAB1IP9DO3WgA+RAB2reAK5wAJkJKgMeX13BAIpLUD74D53xJSq1oqVBRgw+EwNkEOU9A8geZdNMhocXFjCABlFBZSRowA+UZkHbPkBlHGg1DmjlEfiKOZA7GKGZnpERXvbBOs0MWNIuchkHWgUBK+9A7gINkIAGmkBbQECDI6+gB9uB0gxoYBl00wOo8/zuyXHwlg1pzQAG0MGAoEEJUNr4CB8sQM3GsLwEOUPlM/jkfJDfQOKQgR5F8OGzoDwF26oBH9xA6hiBwoQRWoaC6q5Hl5YA07oteHUIKM+CBuFAg2Uge0ArDX79eMcA2lIHqiMh58OwgQfehKTNwe4GDT6AVlMoALdFgK5iBQ2KgupOULkPKutAg3lKxmngehG8VQJ4DgUDsnsYsHXiUcXoNvs/xDqQI7qzj5w9hvyKjdGZf4ZRMBoCoyEAD4HRAQAG5KYXI3prCIUPkwV1cEENe1DDHHaiO6ijoevSzgBqYD+8sJABdPo/aCZcQT+OAbSHE9RIQ1yLxAi+qgo0KwY6uRp05z/ooL+XwMOpQB0N0HJWUOPNPHgZw4Pz88G3B/CKajCArrcDHfwGWg7JxiXCADoXANS5BjWiQCcvSwDvB//w4jwDaMkt+JRkYAMM0kDmYQDNEoFOBwddIfj4ygqIv0ANUXDDFOoz2EwJ6IA2IBt0PRloOf8f4NLmH5+eMjAwoC5bBzcWgZ1k0EFdoIY2qOEJmnECzUCKAGfZQfuoQasGQHKgpbGgRjNoFhq0nxfSzYZ24oBm6Lt2gWe4QPuyQUuIQZ0pUINMz6UDvAce0flnYgANqoAGOiAz8JCON2jZLwNsSS/Id4wQcdDMKEgdaBUGaDAFdKI/aOAFFrGgJc6gzgdsVpKBETHYAJppgtzD/ZLh8dWV4MY/aDk0aJ8zaCYZNJsP62CAhxGA/gDFB3hJObCzDwovUOcINCjCDeykgw70AnUG/gAHjECDAqD4R+1jQOIBcSc11JXwhsd/sDWghjyo8wXueAFXCYDSAniZ9utrDKAZavA+e+DWkR+fIXEGciNo/y7oSjzQYBPyPmJGRqK6RgyY6ojTB/EBroYHofyGJM8ITTFQGhRPoLMyQHuAQfeLg/IaNFEzQKIfoh7GBq0u4RNRZ1AB7jd/+/QkOC5Bh+GBDo8ELWkG5WNQWgF1JkGz9aCOHqhDcRe4DQbUUfn67g4DaCkx6PwISD5AuA2cjRj+Q7YP/Ids4wGldVAnBXy9GfAedJB7QemQjYOfAZSuQAM9QsCD8EADZJDtB7AwggwmgNKLCPCOetDqEdA2EpB60BV+4HvMgQdOwq4WhOVJUByD/AFaWg3eTgTsAIEOPbsPvWWBR0CRAdRBBm2FAF0dB4pPyKz3X7C7QYNuoJlryLJ5BsisOagTBUzTssDD7iDh+x88Uw/pWIN0/wMv62bjFAabATlE7xj4Fgfw4B0wTEAdVUEpIwbQ4APomsP/UDNBnT3QICFoIEvDpgI8ewsZCPkHXjUDWrHx9+8PBlAnF9TBO7zEnUHboRF8fSqs8w/yu7HPDAZQZxZkN2hgABSPoOs7QYMQkOvu0Mp3RkTRB08vYDHsaZQRWo7AOsagvAMqS0A0+KBO4GGBoE436GpOLuA1dSA50NJ90Ooj0LYb0HYh+KoraIdYEbiCCzR7DirjQSuMwO6A5XGwWxjBK3dAZR54gAvawwalSeuI9eB9/SA9vCJqDKA6CHSeCcgOcRV38AAvqAMNTl9SJgxiSs7gcwJAbgWJg9wN6fyj+xc1PYPLQaCbQHvyQdd1glZhgMIWtAUGNCgEGnCC3D4jAB7QBYfPf8TZAqAwAaVR8FkmwM49aDAKtnIDZA74NhmgJ/Tde8HX7YLKc1D+A+U90GAlqC4B1WGg/A2qg2BXsYLqE9AqL2XjdPC5J6A8JSRrAU4DoLQNygeQ810QbkFd/QFLDwPUGRoCncjRDj8DJhjt/DOMgtEQGA2B4RUCowMAaPGJOesIU8AI7wSB9v1D9laDluj/ZwBdOwWatQedtgya9QPNtoNO3gc18EAziaCGN3i/ObRzAG7PQTvboEYqG3DZ4uuHkGu6QHw1y0Lw0u/rB5sZQHaBZ4CBDWfQ9gLQzDPIjeDl3I+PgWexIdcmsUCWfQKvYgLtZQftDQf1FkENcFYOPnBDEbQcHtSBAS3zBV9BiLxvGtjQB21bAM+iQ1cDgM8LADZwQY20J9fWYkn5jOAl58JyVgywU8VBDTJJdV+Gd8A73kGDEaAln6AOLeRAwucMoKXUoFPrGaCz96Al16C9oKClvpCOFxt4Nhu03xl08B/oBgWwxYyQ2TfQgADo/ANQ5xkU5qBZIJA88uwYzGxQoxR0tSHIDPA+/Pf3GRgYINsrQEtcQQeQgWYYr+ytYgDN2ioBV2iAGruQNjgTg6xWCPjQKFCnCLwE+ctL8KFcoAPEDNz7GUAHCoKuSgTbD3SfpKoXeMUE6E5yUCMX3OAF7mVlYmYB6wN1BkHhA4of8MndDIi0xYB0lgDEfmiDHKnhAWmY/QdflQdKB6C0AZpFBYUvaFAA5DfQYAzoKjPQnt1/0NPYQQfJ3T09nUEMeHUluLP5H/UQMEKDALjl8Q0CkNLARjIHaUACMy8yMoAGhkBpA9TBBPkP1Bn49OY6A+RwQUbo+A3IPKQODRNoWbEQ+GR70KANaPAGtL8YtMoCFh+gE/zBp+YDV26AOv6gdPH0xgZwPoSs0vnMAB9ggrsRYgcsfEDuhdz28RPcEQN1wEEO+g/Ou9/AkQ1a1gzKK6Bl1ezAveMXdxZCzwCBhdd/BtCgHWipOWgmGZQfwYNXwK0sn9/dBnfoQJ1x0L57UEcTkoIgy/NBaQIkB5pFB3UOQQN9sEMXQduSQIMYUhr+4Bs9QCuD5HSjwQciwtIvuPMPymfA8wou7ylnAA0yXdlXDR444BVWAW9RAa2iAM2sgs4mAJVroGXboLQMSu+QE9ZBAyD/GEBnZoA6cKCVDLB752En8YNWNYDO1QCZD+pYHlnmzQAaCIBtfwK5BzSgBdpCATrNHbwdQlAZvKXnP/h0/v8M4H3iwLwM2hr1Hbi6AnJbw39wHIEGeMBnFSDP+kIH9piYIFeBgtIByB2guAMdfAqa3Yb2vRlwA9joAWLVEAsLJwOonAfldVCcgQb7QIMwoDABlXmQ8hRyWwFkNRYTAygeQGXPjy/PGGA3KoDyNiy9g86O0ASepQA63A40qAzqvIPyNqi8A60EeHp9HXyQF1S2gFZegDrQoLILNMAJWkIPCnPwiorPzxlAWz1A4Qa+oeE/rgMAkQcAoOmaiQl8LgxoNQPkWssX4C1eoM49aHBLTjcKPGgLWq0B2g4BiV+IX0ED3yD3g0wC5VHQdg7QdjhQmIPKedDBliA58PWkwJtnQKsAQAcLguorYeCsP0gNqLwEDRaDBvpAgw6gAYJfwAFPCWA5C9q+BRqcAA3KgdItZGDmBwP48Mr/WDr/DOQCKg4UDNJO5GiHn0DaGO38M4yC0RAYDYHhFwKjAwBoccqIfkgTUmMfNuP94fl5BlCDTM+5HXwQEajxC2pkcfLLgDuvoGX8oMYKqLEjrx/D8PzWVgbQYVmgu79BDSVGsG5Iox3caAQehAXb/w+SA91bDRpEADUiBaB7JkH3MYO2BWgCD+V6cXcHeC8sqPMCWvYLmvEA7zVlYADv5QWtTgDNCEEOW5JnAHX6+MW0wVfBgfbkgzo2YG+D+0mQzhJIrRBwmTNouTN4b+d/2CFK/xhADU4GlCWUMD2Qg53AS/aBDWvQcl414J5T0DVToJkfUOMOtAwWdBI2qMEI4oM7A///QzpqQD2gxiEorEAzRKCZqS9vbzKAlnmCrgsEdaTBnQ1G0Ky/AvgEaNCBiLADDkEdEFCnFjyjxcgAXhIOWjaraVfNAGk0A/cI31jPADozATRzBF9+DzQPFF4gPqhjD1pJAercvbq/FxIz/yGNWFC4gfYXgzoL4EPGgB05cOMXuC8b1PEHdbp///wMGRgCphNQGgDFB7gzAJylhTVKQUuhwQdAAvcwgzp3oMEjyOzfF7B90F4rPCUyYhxoBwp9SKcHrAgYNyB3gMIINLAEPnkdaB+oWwLqOIE6GKA91eBDuoADEKBD6UD+Q3T+MRu1yDOd6GzcxR4jDilyGs1IZkHzHLYBANBZFaBbD0DbH0CdRlBnB9QBBKU90IwkKExAKyIg6RucKMDxA+oIg1bBgE5GB+Ub0KGJkNUpf8GhDRoQAHVYYYcqgmdKX15kAImDOnX/kWc3QYajlwsMkAFCUUUHBtDeZNCSfVCnDJLuPoJXHIBW4IC2AUgDO+GgNAVyB+iqNnjnFeRcoDmgMgLkN5B/QLO2oLgDDXjdPtEPPhgQlG5BJ61D9sEDYx10PSEjI3ipN6jzJCRjxgAaeETuUIPMAHfYgWkQJA5Kf6D91JBtPQwM14HL8EEHTYK2DygBZ1dB2x9AM/KiwEEjUMcT5J73T0+Bl66D7AWdgQJaaQQKf/C2Enj4/AevHgCZDcrzID+ABgIhs9SQMxDA13MCz9AA5QPQKhVQnv4PHqyClImQu/ivgPMw6JA92Kn9kBlkbGkLoo8BraGOGEuCpS1G8Mw6yN2gDipoIAl0QCDoXJC/vyBXEYJVwpMipJyDdPfR0jo4aTGCDzIEpRFQOQY6fwDUcQXxQXkNfM0deBUOA4MecIUT6PwQUNoAlemgWW1IWQgsZ5HKVvAgEjAsQWboAlc/XQYOToLSJKh8Bp2sDxoMgl0TC94C9Oc7A2h1FmibGTe/HAPsrn/QShPwwCuwwwwegAKqY8DV+cc6oAVyCSO4TAWtGgKdHwDqnIPOPoDcVCPKACqfQWkXFI8gf0NO/WcAny8BSmuwgQKQ/aAVGSB9oEECUF0HKgfBt9I8OcEA2pIAuu0AVEaKyFozbJ0gz6BuU84AXi0F3OMPKqNBKyVg21FA5SxoSwB42wMwHkDbd7SAZT7o/AhIPYUljaCkDUx5mi//H2SdyNFOPwNhMOQ7/gwMDAxUHMBiGAWjITAaAsMpBEYHANBiE+8AALDDCrofH9SwARWsr+/vB++BBTW8QDM9oI4waGYStGcVNPsDavSAOoqgzjzooChQww3UUATv5QZVLoyM8FUFsD2ToOXooBly2D540OwGaH8kqBGqYprNcHV/HXiWC7QaANRxZATOLoPPEwB2VkCnRYNml0ENTfCd3sAGH2jbAEgvyDxQxwF0uB+o0whqzoL2KYOuiHp2cyN4gALUyAfNioL36IMrv3/wmTZIMCFmWGGDIeBZLaA/VM3zwbNDd4EneYMa+KBGNngmHDhjB2r8g2ZVQct6IUuAIZ116/D1DKAVE6Dlu5f3VIBnyUEdC9BMImigAjQAAnKnffxe8CF8oFUCoOXeoA4FaPYb1AkCLeEGxQVoqT5oRlNOJ5Lh3tnZ4MEOiBsZGEB7RmGdf8hKAQYGNYtCBtDsJmjLAaiBC5rhAjVgwYcW/voE7uiAZq1AnQ7QAMN/6LYIUIcfNLgC6jBAtiDAZvcYwaesP7qynAG0L/fJtdUMoE4mKK5hqyNAS5pBgyug2S5QIxh8ovd/SKcI2txmYETv/DOid7IhFTrE3K/gmWZQRwbkV9CKBFDHAuQXkPlqlkUMkDv3YR0k1M4GAwMjhWUZdreRbyjUPBwDAIzQQzFBp4yDOlHgsxWAp9mD0hRoEAR8ZzkrFwPowEXwggoGSKiC8omiQSLDY2DcgMINlA5BAwL/4fuEgcv3gTOloDgGzRCDltmDOrugFTOQgZ+/CC/B3cbAAN6jzQjrJDKA8zLotgfQ3nzQbQ2gpfGgsy9AeQrkNtBSd1B62jvHHHqn/isG2DkUYAsYEe4FlR+gtA05DM+RAXSQHmglDqg8AB1wBroTH6QHHO/AcyrA+/+BM+GgThJoVQjEwf8ZYMvlwXukjZLBK4FA+9LBgxTAM03AA4fAvA5avQIapAQttwcd+ge+DQOc5v8xgAYkIGdSQMoD0MoG0DYAUP7kEVZjAM00g90CLB9BW5VAs7SQVUt/GWCHH8IbosD0Dgp7UByBBhZAgwSQq+YQnXhQxxgUT+Ar+f6D7H/B8P/fXxzJCrmBC+rW/GdAHghAHswC5UdQ3gD5GbS6Arz/nIERfFUhKG2BOq0gN0FucsFmHcwuSDoFhRXo4FVQfgbNrsO2Z4CuawX5H3z9ICh/Awc7YPECypegchG0rQq2lQDdvTLaIeB4evPwMHgwBdRZhgzy/mIAnaMArg+gnXlJFQ/ggGkC9EyHfwygOgd0ECEoTiAH5EFuPIDZ8R9tsAGW7hDlO2p6hqwk+8+gYVMGPNzvIgOk3PoCVg4azAK5CzTgCDuMD5TvQPUHKN2CMIgNGoxySTvDABoYBpXboCtZX9zeDt4GB1IDHnwDHq4JPu0fOBiubl3GAFrNAkrToEEP0NWDoBtuQJaCD3l8fxc8+ABaeQcKe1DZDinn/oG3xcGuuWUgYt8/Az3AIOlIjnb6SYjs0c4/wygYDYHREBjeITA6AIAlflEGAaANfEhnEjLLBtqjCJrdA81MgWZGQMvLQct5wbPdyq4M4JlF0IwW8I5t0Kw96GAtNasS8KycvlsvuNMLapyAGjygjguoQf0LeGI9aPYG1AEFNYBA5oEaqSAMamiDlgyDGkKgwQeQGKhzAR4EADYEYY1zUOcAdigcSA34KkHw1V7MDKAT+CGN/m8MsFl10CwLSA1oFg/UGAU1UkGnSYNokBios8uAvO8fHFaQBiJoTzXo0EJQ5x20lxrUKQHNukOW5DOCG6KgmXVQRwbUSAPPeP7+CjEBtMwY2HEDdVbBDWfg/eOgcAKpBQ1UgLcLfH3BAAkjZgbIoXagpAoMf+BNBqCZVFDjGrZnGDSQAZlBes8AWn0BahCC9laDwgrcwYENtMA7WEwMalZF4K0boAGFbx/ugw/1AjXgQUuTweEDbMmCzIftiWaEzvCCOpP/YddJ/UfqEAD9BFopAQodSByoMIA6/CAPgzpWoAPCQP4CLYOFrYb4D+1gYSRBlE4/IwPkILHnDLC4QN4DDUqXoCXDOk7N4NUooEYxKD2B9kGfWBPOALaDAbVTxMDISIVSjZEGJSOSmbC4AtmClAdBAzaQ68b+MoDyHegUePA5GMAZXNj+X/DMOCPyYAIj8Cq5CwygGVDQPm3Q7DZoVhG0VB61k/AfHF6geIJdsYc6a4owE5Qe5A3iwANTnPyy4AEj2OASaMmynmsneOk1aC8zqHMCMhO0Rxm0XQE0EAgaIAKdZQGzH9JRZWJggPkVmt5A2zfePDoEnt0Hz6QDZ/DBA4gM/6FKGRlAV9OBVj7AtyLAByVA7oWdfP6fAbR1BrQ8HbTKBjQTC9uTDfIjKK2CrpQDddhYWLnBh0cyQLcpgdwIClPQLQig8AOFP8gPoG0GoE4a5EC4f+ABENCgCvgOeODM7X+kVQGQaGQExwHIXFAaBnVk//1Dv3Mfllahees/+qAV2CRIeAPzHKyshkc3OFWidtQhhQ7oWkVX8BJxUP7TsCpleAJcSg/yK6gMA62AkFTzYQAN2ILyDCPUGnx5BdShApWVoGXnoOthQXkPFM+gKwBBaRO8ygd4JScofEHhCkqnoDNeQIOuoDQISmOQwZP/KHkJJAaKJ9BgM4gNOkAUtpoHNBgDGrgDbVkBnTEA2hJwemMiZEAJONsPGmyW1Q5nAA3qgtIDaA89KM0xgEuP/xh5FnnAETLAxsgAW5EES88gcVA6BJW5kG1hfxlAdQ8njwR4Hz5scAachoHbR0DuA6kDnQMDcr8CcPANdEgjzHKQHCisQQOzoEEX0NYbkFqQ+aBD/UCDT6CtJaB0/fjKSnDaB5Wb4EN4Pz4Cr+Lg4pUGDwKABn5hA16gOguU/kBhbRezneEh8OBBBiJmQHHP/v+nvIwb4I7kaKefxCgcFh1/SG5nGAWjITAaAqMhgCcERgcAsAQO9gEAJnCHEbRcETSrB2r4gZaigzqbsFP/QQ0hUIcStCSTT0wLfLURqKEPGiQA7WUENTSeAZekg9uWwBYrqBMCmhnkAe6vBR1yBJrRBM0Igk4phyyr/csAokHLHUHXvoH2zIJm9kGNS9DeWlADEbTUFNTQBC0XBc2qgBpvoFlmUCMK1CB7+/goeE8xZMn7RwbIsmBGBjm9KLB/IDP1L8DXOIFmx0B7M0GNMPCBUdDGObxbxghpHII61qBOJygcQDP7oFOXQfeEg5YTgxrToA4Q6NAvyPLn9+ArwSADA//Bc84gd7lnXWG4eaSTwSp8HQNojz54FhvYeNR372MAXXkHWSkAORDtF/DqMshe0U/g8AB1qMHX6YFn15gYYJ1/UMMdtBQc1FAENSBhd2ND9t6yMoBmOUGDNCD7Qdsg7p2dCT7UDDxbCZ2JB+/FBQ8YQG8bYGCEd+5A/gYNvIBm/kBhBV7KDI5MBvjM/X/wwM9f6MwupAEJii/QrCZ4pQHwNH7QTOTXjw8Y4J1LUAAzIhrekCQJFgR3qkCrS9StSxhAHS1IgxbRoQcdSAnu5gH3iIP2eYNWgIDOAQDdFAHek/sfOgOIsxAgtSMPcRdtSlUkt0DjgIERYR8oHkGdN1DaAg2+gdIu6ADN1/f3gVewwLZpMGAZtIJ1jsGrYICHy4EHj7DMKkM6M5j7pGH6wTEN6ngCB9ZA23c0rMvB156BO0+MkMQAGgACbWkBrSJ4fnsbePYa3DEBpmN2HnHwkm3QShfQSgFGWPoB+hO0ogW0HB7USQR1hkByIPrRpcUMoLgF++s/okMPcgsoLYLKIlDnE3SuBXjAiwGyGgE06ARaQg/2E7QzD9ouATpgEJSmYCsgwB11oLmgGwRA+RCyWga6sgV4JgJoZQ1ojzxo4AEUxqA8dnZzKgPkysD34AFPSOePGXwGBjvwgFJQWQYZSIG4RUjKlAE0eAD2F3DLAsJNDAywTjYjNM7htxswoMcDIwNEDSPwYFQ2Bn5RbciBij8/MoBWhIAGJjDTJTT9AM0GnYvxC3wN4h8GULyAzAIto5fWCASnH1DZDdo6Az5AFVweQNMjIyJdot7+ALINsuUBfG3n15cMkPhkBJsH2voEGmAFrwCCbjsCDTqBDmsFlSU3j3YzoGwtgQ/+MIDPXwAdlAfyE6g8BXWGQR150AAtqDMMSm+gMAZdLQsqX8DbpoBbNEBuBy21B5U3oEEa2Mqv///RrsCD+gk+gAJMz9KawQywwzQZYeUReCCKAXxuBMg+0FW0kFtc/jNAthT9ZwAXkaBoBJbfjokHGWCHzIIH5L48B6+IAoUUaBABNPgECivQGTSgQ0xBaReUrlg5BcFL/kHnc4DOnxAEHmAIGtgGl+3AmyXABzz++Qm+lQC0JQc04AIaQIatPgENkIMG5UEr4iRUPYGru2oYYANliDTxn4GuYAA7k6MdfzJierTzzzAKRkNgNARGTgiMDgDgiGvUQQAGBthSRVDjFtTxAzW0QLMyoH3+4FkRUAML2MgDNZBBHXbQaeKgPYrgpcawGeN/oCvHQB1L0EwfE4N54CLgjPVbBtAVdeBZNmDnEXTnN/j6P2AnBXyHPXTZM6iRrG1fxwA6LBDUUAVdYwe6bxsym8/IcGZjEgNo7yzocDpQwxhkJqhzAFrWD/ILaKABtIwS1MAC8UENJ1CjHnSeAaixBxIH7aUEzepIaQSAl2eCDuiD3BX+H7qYmhFCAxuLoPAAdagfXFwAvnoJsmT3N7hRDt5LDTodG9iIBPkH1NliQO6IAv1078xMBtBSetAsDagxDAozEA3SCwlPyN5sUPTA9sCCVhSAGobgbRHf3zOAO0RAs0Az9wzQDjz45HXQ/nvQfn2gCtDqA9CSWtCME2jW7QXw/neQmSA/gxrOkOiHnrwOPCkd1JoF3y2uHcbwC7yPH9IJAYUlEwsHeAAFNAsNug4O1JkB3Wv+DriPFdFRBTUyIR0G8MwSeA/+A3AYgQZXQIM+oIYv7NA+mP0MkKERBtiWClhHhwF8+CE7A6gzoG5dCh6wAM14wRp4oMY+5Kq4ewxgdwDTGmhvLWggABT2kC0SWBI5UqcGYjcxhR4jWSUjvv21jIzoZkL4oLQA2kMNXh7+H5JvGKAdRFD6//z6OgPooD5QXgR1fCFL6SENfISJkM4fwg5GcJoBD0bBG3vEdAqgbmJEmAfeh80rBd6nDloKDVrGDNrPDuk4MTGAlm+DtmCADkIDX1sHHZSAdIr/Q9Mu1FxQOgUuE7eJ3sYAuvITtKUHfLgkI6QUAnX+4X74D13mDtbDBD4UENRpB634AR0eChqMA52BAJo1BqWlm8e6gdcPGoGTJygvgMIVtKLoP7gsAqV7FgbIjDwkv4EH94D5G9TZA6m5drARfN885B7+1+AVEqAOqKJhEsPrR4cZQAN/ILeBZnL/grcU/GIAlTOQZdiImXhQRxY0Wwu6XhA0cAMaiICttAElKtCACeQ2C0OGb8DDOkEDPJDtSwwoYQXyiGXoKvDheZAzG36B8wxoQBJkHuimBMhZBQzwgQUGRrQUAc5TbAzM0O0jisCtEaCrT0F72UGrpODbDYD6QIN1IL+DwhhrZ52RCTFAyMAIvrEF5GLQ4CzowFVQ+gQNmIAP5gOu3gCFHWhw8s6pKdDOPyKMGJHS16fXV8EHI8JWOYFWj4DKY9DhjyAxY99Z4GvzQAO9ZzYlM4DyPMheUNkI0gtanQVyO2hlCHzLGQMagA0CMELqJNDgEegMCPANI8AzY0D7/SFKICvffn57ywDausCAkXf+M4CW5oPOqQDdegAu8z89YoDEHyS9ggaAQCuZvn58CE5DoMEnTftaBlD5BdoyAVILOY8CuKJFxgI8OAo51PIeeNsD6CwJUBkIXkkBPOgWfB4A0HHKwKv/QOUA5JyBGwygAdEnwBtbQO4BDXKBYx5Px45me/8HqDM52vFnIA+Mdv4ZRsFoCIyGwMgKgdEBABzxjb4KANT4A3X4QQ0P0Aw76DRy0En/4M4qA7RBDzRLE3illY5zKwOoQQmagQbvjfwP6USCTs4GNTpBHRZQpxU0Ww6a7QfNcoAP7gN3Fu+DO5mgzh6oIadqkc8AaviBOo23T05igO0dB91VDpr1UjbLYgAdLvjgwnzwLBjoIDvQigTIoVYM4MY9aBACdiUZuOEP8jMjVA44cwxqlIJm80AzTKABDlAjDjQrBr7jGjywwQBfFgrphDEySKh4MoBO4AY1yED7YEGzXe+fnWYA71UFdf7BjWFO8L33oEYrqDHJADOLAbXLCdp3DdqXDWp4gvawIs5IgLgR1DcGLREFnWAOWkEBMu/DywsMsIYoyCugDhloKwJoJhS2BxTUAAZ1aEAdMFDDHjLDqsOAfAI/IzQsQPEN6pyAOpegqwzh+1r/Q5Y2g8xSMcsBnpp+FtwgBc3KgfwD2nIAUgtrSMIa8SAfguIb7Of//8CNfdC1iqDBHVDHCTb7D5loY4R3/EEzwKBBJMjyW8iACyhONICngr8EHlIICm+w/5Aa4aCGMigOQV5RMklnuH92FgNoduwT+K5vPB1cjEEARgbYQAR2mlDhyIihgJgGNiO6O4B8UJoAdWpAeQRy3gXkxg2Qu8AdUGCnDbRKBbZ/HDRAA+pgymiFgq/rg81gonb9GKCdNQbsYx7YGoFwtzEywDtowBls0KALaKk7KN2BZiohg1zQwR9GSOkBStMM0LhHBAxafDDC4p4JPJMOGuyCzOL/Z4Cf88EA9QVyOIHcCjQbFM+gwQfQGRoi8nYMoJs8QJ1A0AnpoLwOKlsgaY2RQV4/FjzDC9ouAhlIlAaf1g+6JQQ0MwsaUANtWQDNHoOWxoP4oK0557Zmgc+zAK9uAW8n+ccAOaATlDeYGUCDnaCtTKD8CR4YBc7Ig/IRZFDkGTisQR0y0Kql0xviGUB7wGEnxsPKE9AKqF9fX4MyPAPo7nfQYB0o/ULKAuhKAEZIfnhyfS34PnnYoYCgA+9AV86pmucxgAYsQPkYHu+MqGkSbAJwsAV00CF469PfX8CrVueBVyGBynTQdargg1qROsViSi7gVR4MaCsSmFk5wGkCZC/4FgHgeSygwUHQCiXQYAKorAbddw8qV0H1BmgFBChsQVuOYKsu4OkC6ExG6MAq5HaP6wyQQ+8YGP5AtxFw8kqCB1hBW0pAnX6Qu0ADA+LKbuCBGFB9AVpBBbpzHzQA+Ak4SAYe3AGddYGxFB6RpkBxB4obUAcdNEsPOlkfVHeBtq5BRo4g4Q6b6YdkHkg6huXvP9DD+kB1G4gNPmcG6B/I+QXPGECrZUBxCkqvoM48qAx+dW8P5NR+YH0BO6ASvLIKeLAq6MwKyDYTdQZQPgIPRDNCVmWB0jWorgGVwaD6AnzIIXDwyQw4oA4Kd9A5DqA0BB5ofXmJgYGsg9CIGRjEUR7SuTM52ulnIB8Mm44/A5npnGEUjIbAaAiM0BAYHQDAE/GogwAwhZAln6CD/sAdSZQKBHQX+AtgB2w2A2gGCzwzAb76D9KY0ALOeIBmqsCzgMDGO2gWHtQ5BZ2CD5oBAdkH0gdq9IKWSYJo+AFcwIaqumUxeK8n6JA80B58UGMKdLr/fWDnH7znlEuYAWQ+rIML6rCycQmBZ49BnQDIoVcwf0AbgOCOxH/wVV+gjgFoCSyocwBqXINPIMfScATNLIIOmgKtAgC5E9SgfQfs/IMamwpGSeA9+6AGHTfwXmzQ2QayupHgw+hADTFIFxOpUQ5kgjq9oEYbqNEIWv4M6iSD9rL+Ap9sD2lugjoWYgqODKDZedA5CeC9+6Br/aBGgfeHAk/cvgWc8QQdlAXqrIGW+0L2jL9iAJ0iDQpfyIoG4IoOYCcA1kkE2fD0+hoGUGMdtJQUdFI8aPUFeOm1iCa4cw4aoAF1vkGDKaBZt4+vrjJABi6OgOUhM6qgsGWEdDJBB0ZKm4LDFaQeFP7fPj8BD4j8h62GAAcGpAMI6pz9Bt6XDer0ghrfoLAFDRKBBhFAHYpXwGXuoC0En15dhm7jgAw6IXewQR0I0DYBlE4TPLohAYWSpsHOhbiXFuUfKbNrjCgdbWBDH7icGNSwB6U1UCcUlHZA6QJ07RnobnRQ3gINyoBmU0F6QUuTYelbWjOAAdTBhHScECsyYDPBjLg61LgCgRGaamGzvUA+aMmyjFYweK/1f9g+dkbIIAEjLFzB5iHZj6MjAhp8A80yg+g3j48w3DzaxQC6Yg3UaQKf4cAIiyPgtZts3AyIQ/MYgNciGoHP2wDlddBsKmjFAWgwBBQuoJUiMLUgN0GW4D9jAJ8ZAhxsBK2wAAUFaLUB5BC3/wzgwQNVbwawn4ADHaBOIGj5+T+UTiQs7UE65kLAdA46/BCU7kCDXKBVOqBBMdAqBFA8gMoq0AojkJtA+9ZBA5fgfemwshNEg4OYCbzE+zxwwAFkJ2I7Amw4ihElhkAz6yA7QGdegMpCUMcYdB4IaAAN0VllYGBALqOhRoD0gtwAGnT4B+2AgsIAtJ8f5F4+YL6HXTUJEsco64FxAiqzQGUX+NwAoBmgawtBZTsoHkBX84HCDjSIAxocAg3sgO36+5tBy6GBAXLjCHjdFwO01ACXI6BOK6gjD76+EbyfnoEBdD0eyH/gpfPAcha0jQS0GgrU2RWQMGQADT6A4gDEB3WMQYcYgrdRgAef/kBSITQMMFfcQIIUFGcge0AHQIJWk0CuhGQAuwk0wAM5qwExCIYYQfvPAFlB8o8BtMJJXj+OAVR+gnwG2poDmpEHr2gDph/QGTGg/AwbLBNTcmYADfCBtimABg7Agw/A1VQgc0CD7aCbDUCDbKCrY8GrKNj5wQPgoMEN0CAJ6HBW0GoeULkMWk0GKjMhZ818Aa/MAa1+QmwnwezQ02T2n44dytGOP4W11mjnn2EUjIbAaAiM3BAYmQMAKA10/JGP2VmANCQgd9mjNyr+g+/KBjVIQJ101IYn6CCyywygpZmgDir86izgAAHo4DnQ8nJQBw40OwLqfIL3lwP334JP9wbeFw1yJahBD2o8gWauQA020D7cO8BVAaCGFKhTDGoggjoO756cZAB1UMCHzv34CJ7xBu+HB1Z44KvTOAQYQI1rU/+5DE+BZxKAOq+gxjDovAJQIx40qwTqMIMaZ5D9nuAAYwDPakM7Q6CZMtABVKCZI8j1T//BjUWQv0HX7oFmn0D2g8wAHY6HfCAYcsMF1B7/ATzwD+RfkBtB+0qZgYeQgRqFDNB4AscB0F5QoxmkF6QGNOjAAJ1phXTsQDOm3xlAAyIwu0D67gFvJQCtHgC5ERSu4souwDv/3YB7RKsYQCsJIB0kBvAyadCMG2hvPkgtyC28oprgxi2o0QyaHQOfcwBcfgpygyRwn+mbx8fAM6PgGXlwBwZ0YJ8J+CpIUEMXFJfXDzUzgK6fY4DOnDLAVotA3Q7xG/CAMqC7QEvGQQ1v0HVsoE4a7FpJUJyABmRAKz1A504gZrRg6Q86Gwc+1f4fA/JSZZTUzYhjEACWHxipMRjASHZpCls+D+okgmauQdtRQHEAOvcC1NgHnXMBmq0EDfaABgdAq01gM8iCkkbg5cTg8xyAnVuQGtC2F9AAFLjzyohwF0aeRmsIwtInqjpGBlEFO/AWDNghjuDtMwyM4O1BoA74jcNt4Dv9IR0LaFhD8wssUNA7HaD0CN6aAjwVHbSlBHSvPKiDDNqHD9vPD96+A5wFBqUp0E0A4Cv+/kM64aAONigsQGUCaFuJrlMrcFBiMwOosw26KQA22ATSCzITNFsN6qCCBsZgNx2A8ikovUP8zcgAKmdAZRRIvZJxKgPo3AxQBx7cqQYOgoC264A6tqByA2Q3KP2DVh6AyiNhGUvweSJvnxwH7+kG2Qvq1P4FH9L4n0HTtprh7pnpDLLAlRogd4AGaUD2gkILtO0ANCgBWi0A6yhCzixhgPc34XEDdIeCQQL4hgJQRxx0Dsrnt7cZIOUGJD8wsbCBh3r+/0c9BwMUr6C8Dgpn0GoBkNtAZ6yABhJA5yCA7P4DPbAUcj7LPQbIagPETQSgVTmglQegWxDAh1ACy4VvwGXvsBUfoDQL2lIFMvMndGUD+PYP4MAgaGAPvNUA+XBOcNZjBq+OAK0wA832gwY3QJ1xEA3aFgEq46XV/cGHOYK2hYDKClDnHxRXoIFB0Az4lX01DChlLY5ODsqAGzB4QddWgvIQ7Eo/UICDynhl00zwuQ6gs1runp4KiQhQ2QUcnACV9aAZ+//QMg2UXsSA12CCtmE8vrycwSPnBnjlBCheROSswKsAQOHICD4P4Rd4MBRUD4HSEuhsHZB5oMFw0Kw+6JpGUP4CqQflC9BgGGgQBnxDBPAsANj1mKD0ARpsBsmBzpwBpTXwLQzwGz4Y6Afo1KEc7fhTGKXDquMPCov/DKNgNARGQ2A0BEgNgdEBAAIhhjJjyojcucFe6CJUQBroiMlG4D5K4CwRaFkjqOEGmr0ELZsHnewNOpRLDbjUHzR7B2oMgWZ1QA0a8LVcwEEA0GwcaHYDtOQUdA0gaP8nqFEJmhmVBs5CghphoBkSEH5+ewvYRyA9sPMIQI1iUKMB1FkHNb7YoAMAoMaeRfAyBtBSf13nNvCeahZWTuD+/7sMoFlE8D3VDAzQVaCw2R+Q8YwMoJObQQ1NWOcf0ikFHi4InO0HzVaBGtegZZygBjXIXaCBAFAD3yn5GMPdU1MhoQ7vkIK4/6F7Q/9CrnGD2gu2jQl6bgIDZLYc1ukD0aCZOvDJ/YxQ98G2W0CXi4KWoIL2/4MGOCAN/6dgt4O2aYBm5rmgqxRAcqDGOnx7APLSbaDZkNO3ga4BiQPjEdRBBx2OBmqgggYkQA1qAXFdBtBMFmgWEhR3oAYtaLkzqAMPkgM1TFGSG9Bc0IoN0MFeoDusQdtBQJ0ikNk6jk0Md09PAy5VgCx7lVLzZgCtqIBcMfmSAXR4GWTZPzQd/gfFMK6GAFK6hXbyweMVoPDEghkY4ZEOi3zcNAOpAL8bwQNCwIPDLENWgg93BF9J9+4uA6hjBdpXD5pJBV0hB0rHoDvqQR0tUNyBOoCgDguoQwzqoIM6NKDOKGgfMGg2Edm/cBej5GeIKLbGNUgvKJ5AnT7QFZug2W1B4KF24JU8QDNAW2BAcQaatQZ17kCzkZAghIU7I5ZAgoQDKA2CD738/4cBtO0H5A/IAW6yDKAD48D3ujOzgVeSgPIY+ApAYPoDHYTIAMmK4GXo4GX7bDwMJ9aEMYBmR0GzrsgDRaC8CpnJfgHerw3eGw40B5SPwZ1/aCcZ1qkH+RE0+AeaVYcfCghKK8AOLKjTC976BF4V8A8cNyC3gvL8d+AqF1AHDuRj0LYkIeB+bkHgLDX4rArgPfX751mDB95YgW4FbTcALQOH5XHQgAXomlJQnvoJu+0A3NlkAg+ygDrr4EFV6OAZaEUMaCAOtCUAlNdgt6KABvxA+dgqfC0DaJASFDaggRf4Fg5GSDny7dMT8DWaoHIElE9B2xD+Qjv+oMMTFY1TGEDh8fHFRQbYOSOwiATtlZfWCmIAzTKD0hpoxdIf4GAraLsWaPAAlP9BZTxooOXMpiQGHacWBlBn+g4wT/8Dnu8CXt0EHcRBnk3/+PoKA+gWAdDgAajMFJO3Bw/SgsJEA3g3PuiAvd+/PoOX/IPsAA1Eg1YMgOIbdAUpZMsZbIUG7o4B8gAAKL+DzP8L7FjzCqsygM4dAZWpoNtuwAORfDIMl3YVgwcWQGkLlOdE5W0ZQNfOgrYfwFYzgOIcdNgtaJAaNHt//9wcBlhaAA0ggZbsg+IGtrIDdFsBaPBIADh4BzIDtOICtAoBNKgBWi0A2kIBWpEGvtWFmZ0BfN4O8EBA0AGa4PQNLONBgyKgtA0qc0ErLr6Dr/P8A1mVgGfpP9Vn/0c7/wxDAox2/hlGwWgIjIbAaAiAQmB0AICIdIB7EACmGbWBj+hXQMUZESaAOiOga6BAs+Ifnp8DX2kEWuYL6kT+h3YuwR0W4BJ1FfNchpf3doOXPYIamKBlzqCGJKhhBDno7RUDqCEEOlgJtEQd1FkAzZaAlhKDDmICdZ5AnSLwbDnIqaBGPiPkKj0uQQUGdk5hhmvAGWrQYAHIHlDjDtR4BTXa/kJnuiE+RO/AMELbrP8ZUGX+gxumoNk98Gz6hwcMoEEIXuAtB6CBD9CgxY2jHQwMyA0zcNgwMiDfqQ6ZCWZggM0Ii8hagmc0QfvbQVenQa7mg5y0DWqIg2bWQLNA4D2rDJAD/UCzWbBTyCHXYEFONQddIQg6JR808ALq+EBm5xjAHVxQRwFkJ2jwA9TBBjVgwQeXAbdfIFYbMIFXcYAa8KBOFPhef7B2Jgbw/uFPTxkggy9vwNtAQHElpujMAIpr0LkJoJlsSB8c0gkBzXaDBkpAHSXQPmzQIA3oDIKzm9MZQAej6bl0MoAGBkAdRfA948B7skENf1DHAGQ/A3QWkfCsEKQLDItP0NYC0D5oUGMbucMPWoUC2k8NWqHCSEwZCR1QYIDRYD24dBKaqUDoA3Ue3z07xQCKI9AyYBAGhRNsWwBopg84LQs+6Rt2dgNohQaog84E3j7wG7x3GN4RZkRyE4pbIXEPzh7I6RLWUITpA+Yd0CF7sJPZQR09UH4B5VtYZxXUMVMA7rMHxwt6uAD5kAEmyPWW8NVBoKQP7MiA0jVoGwD4bAngXnPY1WbgzjnoTA1gxxu0Lx/UsQJheMkD3asOm1UFlQug2VKQ9f9hHUzo4BCofAG5FdShApkByjNyOpEMoNl6RFT/hy/pBoc1A2RgDZSOQXkUtL0ClOZB18t9eH4W3PkHpz3wQaf/GRiQZttBy+BB8QbKf6CbRSTVfcA3cZzbmgnu0MM7/4yQPAVKk6DBMlB+BuVfUEcT5B/QgA9oqT38fndoBx7kj/fPz4NXHoEGGWEHjoK2/oDsBZVpILshV2FCfAjyB2ggVQF4iCGoc2vkPY0BtJ3p2c1NDKA9/qAwApn16+cHBlD5Cd4uAcz/sIMBIckBEiYfgAMDoDNHQEv7IdscPoJXoYDyMGilFyi9glaygLZ+3TzWCz64ELSfHdL5x3LDAXCgEzTzDUpTxj4zwatJQLd5gPI4eDAGeAYIqHwG+QG0SujJtTXggQnQYAUo/hWB269AHWfIKgRYXsOW5yB5ATEgAjpfg5EBtBILNHgLCldQBx92RSE43Xx5yQDaHgUpI5nB5xOAwvfF3Z0MIPeBwhtSrgMHh4FbseC5DZwG/4G3LSmbZjM8ubqKAXb9Iyi9gzCorAGvBgGeIwBeVQNM66D8Ad96AbQBtDoKFB/gMgCYxkArNkADLsqmGQw8wMNbZYCHtoLqVIwii6wOH4kzqnToVI7O+jNQDv6PzpQzjILREBgNgdEQgIbA6AAAEUmBEa2by8CIrYODKoY6w8IInmeFzbSArkACWQs67RvUkAM1pMDLzqF7iUEdeNAsCmQWhJ0BdIIy6IA7UMcX1BCFdIa+gE+cBukDn5D8+hr4fADQ6drvn50FX9sEamiCZvhg7gV1CGAn6oPM0LKvYXh4cSED5Equfwzvnp8B62NAXpoKDx9YBxIxqIEcdLAwAi27Bc0CfX4LOZEZvHcV2HgEX1EGvMMftE0BpA8WPqCGK6jTyQhu1DNDO/0Qu0By/OJ6YDFQIxQ0y6cJdPOTq6vBB5qBDhkDzfyAVkK8Ay45BqnhFVZnAC1bBnXCQMtnIbOXDOBOAsg80EAJaGk5KGyYwDOrysB91AaQJdPgGU1GBtD+WtCMFaiTowg+bO4WA+wgOpBbQUuywasjwPf4/wcPHoBm60ANb1BDXV4vlgG0DeIF8Ao4bcdGhr2zTRkgDfbVSMtzwT0/cOMVNBP5EXxYFQN4BQFo1hW0NQE023t2SxoD7HwHULyAVoeABhNeP9jPwADbToA1DSM38hEKYOEN6iypAA+QBM1ggjqF4DhgAC1zdwSnB8hqBcTtD/iyCSR1MzKAOnngZetgq9EbW8Q2vhjh2QsUV6D0DerQ6rl1MYA6C6BrykCrIEDxChs4AeUVULoCpSHwvezA69hAHUnUWVtG6CoGmE+wpWeoG7E0FEF+fAk8tAw0mMbCwQfehw9auQGa5QUtPQbN2ApLmzM8vrYabAFoJhW0jBvSGWdkALFF5WwZQOkKJMYAjj3IAJqeSwd42fy7p6fB6RCUZ0F+B5UDIDHQIBFoIAo00MfBLcoAmqkGxz0wz4AOrgMNEjBCO03ggSpGRNyDZshBy80ZkAYDQKsHQHkFlAfAHUZIhgSvDPgNu/kCqB609By0JBs02geafQWlSfChg8A72D+8vAhewo2yzQmaHv9Dt7uA/AyefQfvsVcFH3II0i8FvG8f1OmDWMsEHgQFnyIP7ACC/ArKz6DVLSD9oA4haCBOxSyXATLgBcnLoPwG6qiD0x5wwAc0uAKaCQcNvoHCA7QlApRvtOxqGEDlBThSgMFi6DkJfIDgxV1F4ENTQQOBIH2g6xxB5SYo/EDlhqxWCHgAADQIgr6FAHT2ByycYWcn/P71CbhFxIEBlN9BKxIgW5p+gv0MOnwUtIIIvILl3y8GWJihzkJDyhFQOIPC7PmtzQwgt4HKUfAed+C2FtAKFFC5Db6JBrjaAJQX/kOXuoP26IMGj0ADVPCBHwYCuRY48AIqX0F5B1SWgvKamnk+A+gQWZBOHiEl8AAu+HpaoAAoTYLyFWjQwy52F3jwAXRgICi1geIPtBoLfCYHqKIDZTdQrQe+8vEPeAAAVC9ADvX8Dg4D0EAHKD2AOvKgQR+Q/aBtNiD2L/DVf3/AZRHI3tcPDjCABmtBA2/MwNUAMppBDKAyEFSGg/If6FYFBryH/TEy0ATQuFM52vGnQqwN247/6IAGwygYDYHRECA7BEYHAIgMOlIHAbAPAECWsjMyQZZ1g5YwP7iwANwYAu1TBi1XB83mgJZ+c/LLggcNuIHLZkF7cEF7v0FLjPlFtRhAJ+qDZvpBe6BBy8L5JfQYQGcCgGZNQYfjgTpBsI4vqIMMagSDZp5ATSBQAw500CC4UXV/P+SQug/3kEIBWqkwQif5cbWbGLFL/IceFgZqNIOW4cKXFAOvfwJ3fJC0gcIIchUf8KgmYCdBB7gNATRjBjo/AGQ8qFMFmgm8dbyPAbQH38RvNsPx1WEMkI7eU/A1faA9xSC/gTqBoNnCm8AVBqDBBlBHF2Q/yDrQMlzQrD8oXEEdJlDYwOIHNJMMmn0HzSKBZnRBs0ygU9FBjUnQAVbga7XeXAPHBaiTIa7oBJ69BA0igBqfoJkrUODBBlHAZygAD+oC7dMG2Q26ChLUqQFh8NVu4FUYDAyQFQWgVQzADh1wpQR45hTYUAHdhADqlIPcDwpLx8RD4HMlQFengRr/l3aXgJdQg1ZWgA/7A8ccroYAJLAhgyuQWUsGcKOcGdwgBx0sCGqEg05vB62eAPkPNOsH6mB8B+1nRkoVsE4+Nhoy+88EPhQRFIeg5ePgg9jg+tHchz67jpIHYW6GCoLDiwk8swqaFQfNfoLSNGjLCqhDBbqWDLQHGjSIAZKDdbrBAxHQFS+M0I4IKEyZwAerIdzDyAhbiWEOOXUd3liEqYEmWEbIihTQVX2vgfkG1MEEDZKAVoqADpZUBa7WAc1ogzproMMkQR0j8EGW39/BZ8VBAzrgk91BK31gg2xAc0H6QHuaYYMasE4lqHMOPusAeEYGaLABJA+6oQN+4wQwiECDf+D8IWnMIK0ZyADqhIEPCQUNCAD9BhoMA+UPUFqBLIOHDoaBOmbg2XpIuoDtewelU9AAA7jTCxzgAg1SgrYFfQduywAttwaledAKANChpcgdY5B+0J30oO0PoI4aeNYYuIwftKwcdEf90+vrwfvzwafgA8sCWGcNdLsF6OA60LJwkNg/8PaGTwxswNVJoLwIUs8rpMoAPmSUAbKKB3T1G2ggEzRIwMopAB0I/c4AOkAUtGoGlOdAg0OgtH77xEQGyGAJpDx7eX8PA2gLAyhvg0+P//OdAdThBOXzO6cmAw9fjASf4QGa2QalFcgZIUh36DNCVhiBBilAcQkeeAHaoGSUAr7/HhTWoBULkNU678BnrYDY/35/ZwCtPIC4C7TdCZa+kPIGMO2B0jho+T3oSj1QZxk0cABZffCfAbbdChQn756dAbvzPywdgfVeZcDo/KN3fpDKbVDaB20rAPkBvKUDuA0FMuvPCN6OBTrrAbQkHxS3oDQB6nSDBiVAK82uH2oFrhw5BknbQDNBaZNXRI0BVHaArocFddJ/fn8DvsoQsq3qP/gsFPANJ8CBB1mdMIb3L84zgPwCPu8GmEdBYQPKB6CVH6C4Aa90kzICHyoLu04XJMcGjHPQQBsoXD6/uwVOV7BqBeI9pDDFUk/9HyIdwtHOPwPlYLTzzzAKRkNgNARGQwBbCIzcAQBQaODoxGILKIwBAJz6ET1c2BJLyJJ9Q/DsnrpVCQOo0wVqkIMaS+CZaGCnBDTDDNorC7pDG7THEXS6MXg2CNiIBi2fBy1rBTWqQbO/f8DXJH0BzxqCOougu79BMySgpdCgxhaoEwRqWIGWd4MaUqAT00F7KSH72P+BZ5lBDV5QAw/cKQV7GLVTBF5GDVyKDPYNiGBkhM6gQmmQHmyVKyN04IDhP3y2Gx7MMDmwACN45g/UcAR1bEGNcJBfvn18AJ5ZAoc3sKEI6tyBOr+gpbCgswxAjWCQ20CzwaAwev3oEAOkwfgXvLQUNAgAkofdVw06URp0ujSo4QkabACFIegUeVCnFTTDCWpYvnt8HDxTB7pmD2QvaJYW1LkAxRN4BQW448HMAGq0ghqroFsSQMthQXEI2mPOAO2YwBrqoBk+0LaFW8d7wasyQLOqb54cYwCtTgBfMcbAwABLT5CVBKCwh4QX5ARwyIwZaMk1aOkzqNMH8jdo5s00YCH4RgXQEmURWWvgdX/3wANIKOkTJV2DAp0JfDvEf1iHmBFyHgUobYA7qcD7vQ08JzCA9syD0hE78OYI2G0JDLC4R88UjBBzhWTMGGBbLUArI0B7eUGnkDOgpSkGXOkFaz6CDVYwMIC3bAD3i7Oy8YJXcYDOrwDlD9BsPGiZMuiQTFAHGjRrC+pggZa1g2YVIQf/QTq7oBlb0AGKoDM3QB1c0J5uiLWM4LwAig1Q2IJXp/xHPTAO7m2gf/XdehjOb8thAA0mgU5dB3VsQXkYlCdf3N3FABt0e/v4KIMI8MBA0Cw5KIxBM9Wgw/tAA3ag/AkeuIF2vsHmI+cLoDiowwja5iGq4MAA2hMOGazbxwC6dhR5lhNUvoDCHuQWUHq8tLuUQVTRkQGUpkCDfqBVJW+BaRu8VxxYjkBmnhnBp8qDDr4DrVgA5ROQG0GHGIK2UIAG2sCrUaCrW0B76EFXCoLyBCjsQCsCQPELu0MffPsFA6RMAG0rEAddmQe7ovM/qAvzDzxzD55JB85iM4C2CjBAVj5wA7chgc5PAHV0QX4BlQNX99cyKJtkMIDUgTqaoE7hb/BtIJDyCbTUHuQ+UBiC/AraGiMBvAYP5D5J4NWkoKtSQfkCFMeg8whggx7g+GZiggQ3Iyg/sIHjC7SlChRPt09MYLAMWwseTAANpDwHbgkADZSC9pQz/EecrwHKDqDzIEArDUBmswFPpgcNnIHKElA6AF1DCRrgBZUdoJVEonI2DCB5kD9A5TloexUiDlE7/yBxyKn1kLIA9RwHcAZiAB14CBpcBB36B0qz8JUdDAwMGB1bfJ0faBkByu8qplkMX4CDwKBVSyA+qK4ADYKCzqQArU4DuVsZeL3o3bMzGUCrRyBbXn4ywMo7UNkDCitQmQxyM2hgBDQgC16pADy8ElxGAt0CimfQIa2gMhQ0UAZKp6D0BVIHqotA5TjIDFBY8YtqM4BWHoDrSuDKMdjWJBAfdN4EKB5EgOcQQFaSQMIRtJIGtBoAPFDyH32LBQOR4D8D0YBGncvRjj8D5WDYdvwh5QDDKBgNgdEQGA0BCkNgdACAhAAkbhAAcwCAATwTlwa+Qx60Bxy0lxfUyAc1XkCzRaAGEegwP1BjCzTjBBoMAHUaQI1cUAcVsg8YeEgYcPAA1NkBdeRAs2Av7uwELy0GzcaBGqCgBiRosAHUkUHcIf2ZAbRfUsO2AnxvP6jR9gN4qwDIbNAqAngDkhGy9B3U4fwKbAxKKLszgK72As0OY9xoQCjMGBEdXEjfANyLhM96Q5bPMjGADuczcO9lADXAQY3A38CBDdB+XdieVlDHA7QEGrQyAjT7CBoMALsZaOhf4EFaoA4CaMXDL/iy5X8MoGXToMYlaJAE1JgGheflPWUMoIEBUPiABkdAqwBAp5aDT4sGdkhA8SoFvDpOTicCuG/8EANkxpAJ3BEBNUp/g09gZwRfnwZaHgtaLgveSw2c3YWcDg5qbDIiBkiAHRzQjBnIvaCgenpjHQPInaA9tuDwhnWqkUdGGBAzgiBp0A0FoAYyaOYTlF5ADWDQeQegWVHQlgHYwWywFQggexgZGOEDC4zQQxDB1+YBz5OAzFg+ZgB1SEBpAxSnoG0AoGW+oIER0OF5x1cFgcMPNIMLSiOgk7nBp7+DGlPIboYO4IBWT4AO9QIfvAVc+WEetIQBNFMNWrEC6uxCvAf1FzENMqTwYIQOMIDiDxRXXPwyDKA99qCD1EAdVdD1lqBOL2SW/DfDnz/fGMCrZ4AnzIPOYgCtqACFgaSqBwOoAwJaqg/igzoIkIPS/oJXkoDiD9RBBt08gXzVG3JnCrZaBLTNBLTaBjwLCbxyE7QnHdTpA6c/oP9Bg02gvAoaiAMNoIDyIihdC8taMIAG2kCdNsgNBr+RchAjIl+AUh5wFlbJOI0BtPUEtKwZPPMJu4IP3hGFdKBBp62D4lICeCMFKL2D4hOUtr8AD00E7b8HzSaDzp0AHTL4D7q9COQX8NVswLR7eU85Ayj+QI4BrboBDSSwAf0FWmoPWQEAiTvwNYDAmXKQOshy9lcMoBPhQZ05BkjCA6/+AIUvaAAGlFTAS/8ZYDPn/7HOTIPiBeR+0EDeB+AWGNAAA+iWEtDSdtCAHWgrDGQlCWSADLTaCbS/HlIe/mUArTSBnQ0BOoAQdEMEqHwFXz0IusIQdH8+NKRB+QAUrqCBAVAcgA/QBKoB7eMH5SvQOR0XdxYwCMtZg/epg9wFvmHhP9LsP9SvoDIUPGALPLwONCACSjegcvIZcNk+aBsBiA9aTQQ6CR80OAvCoLIedMYHeDABPS9A+fCO339EWYC+TQCc34FuAq2Owt75Jy2/geIWNIgC8us74BV8oDMIfnx7BR5sA4U96DwQ0BkRoBtiwAdcAtMRKJ3IaAYzvAEOdMHSCajMBa1O07CpYAANUIDCF3zFH3DlCChfgspi0BWRQlIm4AEqyEDTRfAgMSg/gVa8gQYPQGkKlHdA5Q+oDgTdrAAun9V9GUDbNB5cXADWAxpkAdVz4JtCgFc2gsIcNBAEGigHHQ4JimNGBhqC0c4/w6AFo51/hlEwGgKjITAaAoRCYHQAgIQ0gnUAANwoRG9qQPiwFQAgfW+BV/OBZrJBnVbwTA9oNowBMksBalAiliYDm4HARhZoNQCowwPqoID3VgMb4KA73kErBEB9I9BMK6jjBlky+gm81BS0DBU0iACaoQR1GEGdUHZuEfA1gM9ubGT4j3RNHKjh9h86SwJeBg1sDEPu574G3hYA6iSpmucwgJYYI5/yjD0MYA1WaDgwIjqiiD3JjOBGJQM0vEB2gjqJoA4LpMP5Ery0Xl43CrzcF9SZYAbeeQ465Rq0AgIUFuDZU3BHBtIhAHUcQIe+SQGvxoLcMc0APpUb1HAFz/yBusNAt4D2Xktp+IHPNwB13kGNcfAhd8BOMmwwAhT+oOv6QI1P0OwoaBkr6E5pUIcA3NgEzaCCO+mMwIMXX4OvgwN1dsGH+sGXmDOCb08A7VGHdDL/MYDcDmoUg65WhHRKQQGAPMuElHagDRfQGQKgThhophvUwYAc4gi5YhI0cAPa6wtaKQFZag01ixFhDiyOQKdrg5aqg9KPWcACBlAaBKUR0IoCUIMblH6EZMwZQGkStG0C1NgHdZBBHSzQqeiwziFsvzZkbQdkMAcUf7BTt0Ez3qAONih9gwZGQMvfwXezvwdtLfnPwEBsgwxpAAC8ygM46w9acg7q7IO2wIA606DOAmiQCuRm0EAV6Cq4j6+vgk/QB525ABo4AZ9pAAxm8KFywNnDP+Ar6P6CtxGABtxAM8WfgNs6QB1o0GFtoCXtsGXHWDtoDJA4A4U9aJYbNEMKO5sAJPYDemI9aIsKaEsPqCMHCltQJ9nQazL4KjRQXIJWjoCWrkNmgGEz2tB8wYgIV9CgwrNbWxieXl8DPgiOAZpPUTqIQOWgThuo0ws69wPUeQblGdBgGmg1DSgsbhzpYFC1LATvlQbNqDNAl4uDtneADh0EdYhBAyyg8gc0eAHqeIPC+RfStgVQGQHqAIIGjEArimCHsIHKCljeAZU1oMEgyLaV3wxyejEMoG0SsEEHjCL2PyT/gvIoqEMLWyIO2i4AWjUDiltV4K0ooHTKAB30AKU38FJx4GCWMnDGGrT1ArZXHdTxA60KAN1qAhogAN2mAl5qj9SRBqUjUByD/AmKO9ANHqBrEEEdd9C+eVA8gjqnIP2g+IQsif+HmXaB8SQkZQxevQRKo2LAFQ+ggaB7Z2cxgFadgLYhgLYzgGbnQWXI2yeQZfL/kQZD8FY5SG5GVYfIR/Bl/yTUXdhmlUEpDnxY6/v74NsQQIOKoDMXQGfOgDrjoIFjUCcctFoMNFgDGugCH1oKvCkBtMoGvNIHGpcgp4DCATT4BBpQAcUhKF+B0xd0VQ1o4BJ0RS3onACQPaD0A9rOA4oPUNwq6MczPLu1iQGcR4B6QPEA2sICGqAA1XugMAatvADlB1DaAbkFtDoBlG5BdQFoAAOUJ0D+AB/8yAhdjUb0SMB/4kKUBh3M0Vl/BsrBsO74o7cbGEbBaAiMhsBoCFAUAqMDACQGHymDALBZTFBDETSDzc0vzwCaFQE1TkANI1AjyTpiPQNo7z5o6SN4mS3wIDHQbD5oJg3UuQTN5IEa36AGKhuXCANoZgWkDzRbDmpwgZZdgxpUHDySwJmXreDZEdBsDHj5KLBCBG8dAHb8/0NnukEN57/gJZUsDKBT1GFLvEH+gjSkvoFP6gY13kDLTe+fn8cAWk4MOokerpYRFgqQhjxqEDKizPSDmmCgA8xADWrQrA94yTsDpKMM6tiB7k4HdY7A+12/vGAAnfwOm4EHHwQF2koAdD+oQwnigzqpoHulYXaCOuygZc7g7hOwcwCb8YathgAtGQY1GEF7S8GHAAJvNwC5CbSMFzTbCFqmC7uqCjSIAO64A/0H2sMKmrEH3ZQA6tCC7AOfH/DzIwPIbJBbYCe1g+IL1KEAd6CBh6OBBm9AjVZQxwq0DxbU0WBAWlqOvCcfmQ2bTQN14kCdGtDybFjnBOQuFvCAyEsG0DJ4UGMaYSZi4AWyHx8SB+BVCsDDwkCdRNBWCZCfYW4GnbUA6syCBol+AA9phHTEXoCDFSz+7g4DaDbTyGcGwwNgGkAaX2CADWyB0gOosQ/qRIPSN2hGDjT4BOksQk6IZ2DA3qiGNXgx8hO0IwzZNmMAHrQCDXSAZnrBhz4CtwOADsQEzzADwxS0ZBmUJ0A07JYESNoA2csI7tiATnkHLU0H+QfUUQDlK1CcgVcqAA8MFJI2Ad8mALoj/xXwsDHkmVVE2mZkgIUBaBABtLoDtBwZNPMOPpEceDXbg4uLwO4FzaqCOqda9nUMR5Z6greBgDo8sCsCIatAIB1+0PYEdh5xSJiCGrCMkMEzUFoA5e3/DP8ZUMIIqYMI6uSC7AfdTgA6TwSUL0CdaVA5Ato2APIz+MwAcP6HDTgwgPddg9I0aHAPvEIBeFUfaJAP1HEClSWwvf3w/eSgTvh/yHV/oPAAxT+o4wWaBQetOrh2sBE8UAG5450ZfGvFL6Rl++D1QIzQ7Riga03BNwZAt1r8R8xYg/SABpFA9kOuRkTtgOu5doKv9QOlY1DcgcoTUL4GhS3kytGn4C0ToHINuUMFCz/Q0n7Q4AgoL4FWfYAGaUADjvcvzANvOwKVyaC4A23DAV/3CDqbAyP9/gdv5YINsIL2xIPS+3/olgnwDQ1AP4HSL3g/OzB9kdNhRy1TEXkIW0eR0J52/J1LyGoSyNktDODzEEDL98HbVIB+B69CA662Ag0Cgq5tfHx1JfgaVRAfXKfAOtegNAIc1P4OXF0mBKzDQINzoC1MoJVacL8A0xAsnEADJBzgdM/EYOw7k+H+udkMoPJXDjgADBrMAW/TAobpm8fHGECDNuJKruDVbqD4AR88CBy8hawGYwCfBQOKR9CWAdAZGLAzDUQVHMH5H5QXGKjVORzt/A/OJvdo53+0KzQaAqMhMBoCJIXAyB4AgLRmSQownAMAGGYxghv1oBlc0EF2oMY2aJ8yaIktaHk9aGYWNAN+82gXeDYJ1EgBdRhBnXBQIwi0xxnUYQAdygTab/v3708G0AngoKXknHxSDKBZatB1SqCGGGiWBjSAwAB1A+iU7Y+vroJno0GnJoOXjQIbZ4zgPbD/GQw9JzNIq/uBZ1tADSNkP4GW24NmwkGzkKAZPNCp1mc3p0GNZmQANdBBbgXdAQ06vAskAWuAwpZKg3pKoE4/eBk40E5jYCfy46tLYDPAp7VDZ+ZB936D7pEGLXEHzc6BTk4HdV7A14/Be5z/wUu/QY060IDH53e3weMQIDtA+1Sf3VjPwCemDWq5ArcUeDGAZntBnTPQIIisdigD7Hou0AFfoOWtoAERkDtBjUWQP0CzfqCOD+iAQpD9YkpODJ9fXweffg26hvHR5WXgQRVQGIMGXkAznaBOE+hEdvCMPvD8BpB9oHh9cXs7A6jjDrs+C7RqATZbxQA9JwB0BgSoAQsKR5BbQIEC3qIBXDr75sFBBthVZKCOOmyLBqgzAZoBg5xt8BU4iMTLAN4zCzwcDtGwRZ/mYgSnK9AMG2j5PKixDVoyDRrUgCyB/gxekSGnF80gqeLB8Bx4YwFIHLS6ADSLDupsgxrfoM4/LIPABisYkFZOgMRABxeC9II6n6CVC5AT2a8xYOuY4OuMwNMhMO5B6RmUFkEdKtBgFyjtguKLhYWT4fSGePA+dtDMN6gzB5o5hs2sg+IV1DmFnLQPGaACDRCAtoCAwhSUZkBnQoBmPkHpjAd4RSUon4EGgq4famGAdVAYEJ5mQAagZAm7dhKUV0GdRvByY2A6AIUxKC2B0gY4jQBXQKiYZYMPcQR1BsH74KEdSkZoXgUdGAg+3JCFnQEUjiAzGZBWA8BGHVDLnf8oYfv64WEG0JVwus6tDA8vL2WAbAdiYAANPv2Hd/5hHe1/4PMuQB070OADKPxAg24gdfrufeB0wIC0Mgjid9jsM8QM0AoK0BJtkBxoNv7msW7gVgJb8P558AGkoEEyoBkQPzIwwFYKgLb0gAY1FIFX8IFWKkH2vCMGABjgAwMMkJl3pMEOkFrQoAATCwcDaCsGeOsAcGUHKF+C4hY06w8KS5C5GHEIDHNQvgV3MIHbfECDB6CtVKCzUUDL9EFmgmbtQeUkaIYaNCMNOrARvvICrXMBCivwSghg2IKWrMP3oUPVgVYGgfI4aGUS7OYC1DQEy6tET00zkAsw8hu2jhJs/BCcJhnAB0mCVo6B6gBQnQUamAGtBgKVb+DyGTTYgTQwgjwgCDICNHgMKq/+AQcOGKDpHJQPQGUVKM+CwhW0yukH8LpA0EAMqA4EDfqABnZA58CABgdAg5yg/AAajPkJHEQBrTICrfAADaaC7LOJ3Aw+WwKUF0GDkKA4ANU3oK1ujy4tAZfZoDwIKtPBg7FobiYrPEc7/wyDDgz7jj8oxP8zjILREBgNgdEQoHYIDJMBAFCwkNmYYiRdH/GDAKBJ9p8M4BP7gbPb4FPpgZ2nZzc3MoAa/aAZKFBnETR7B2rQgMRBB16B9+ACG5egTg2oIfQPfA/1H/BsBmhJPEgPSB2oYwharglqJIHsAHXKQY1h2H5NBujsOWjWEza7rAc8yAx04BVofy24g8oAqWAgM42g2ZQPDOCOFXCZJ2iPPKhjARqYAM3+gA9XA64eAO2xBjWqfgL3iiJOnYaEI6hxBhqkALkb1LgDNapBs6qgGVxQwxl8nR6ogwEMB9AMJWz/KcgV4NP7gaeX/4Hu3YUPLAAlwff1w1YegDqIwJlgUCcYdC0eeMAAqA/U4Qc1IEGzw6AOJGgGHDRIAlpWbOAxATxTpGySCT4sEHKwGAMDqKMLWiIP8jNome7R5X4MoNkmkNliwBkk0DJTyKF/rAyg66pA/gF1sMDuAR2SCPQHqFEMCh/QUn3QtgXQrChkhvAuuCHKCO0JcfBKMIA6Kho2lQygpawiwGvhQIdgga+yAt4pDrveDpyagZpA+4hBA0gg80GNY1AcgwYOQAMBoKX6kFUdyEUCZFYZMuPKBD5ECzQgAerggtIUaP86qHMDjgNg2gANXIAPsAOeJQFyAyjcQXEOHtgB+gs0cAXaGw5ZkcEI78jJaoUygK5IBF+bBrQetBwcNBMKmo3mBPoRftsB2uwpMctcIXkLeOL5n58MoFUFoBUQsAPhQLc1gNKgonEqA2Qv/2eGR8AOL8gfmsAwBc1igzq1oAE0kD8g5yP8B3dMQdsEQCfEg/IPOK8YpzCADhoDpRXQEmeQn0EdeawzhYyIDhtskAs0GAXKF6DBONB+bMgqH+B2G1CeAA62ga5FA51VABqMAJ1KjzILzIjIK6DOMegwQdCp96D8D1r5A07HwPTAAO+YIcIeJPT/P/JBhf8Z/kNn50H3oIMGfEBbJEC3YYAGxlDUgmZpGaCrdoBsUP4AzfiD0hc7pxADyH5QPnl+ewsDbLuHgLgueADjP+yef6B+0GDm1f11DOZBSxlA51sIAw+jBK2y+Am+uu03AyhfgwbLwOeQgBro0FUNoFlh0KqIi7uKwasawCuagCsnIGGONKgBa9QzQsomMPkfOpgDXNECVg/1i5i8PcPTa2sZQHEBXjUAvRYPfeUJ7OA6UOcUVPZClpL/B98uAip3wIMSwIMcwQNwf39DBoIY/qMNYiENVjBAhi/gfoSn9f8MoDQKCvf3wGtVCVfYkLgFxTUjSjWGlEYY8HUAECtTCNpFqLMEdgojcCDVF3wFISg+QasbQIevgrcCAAdfwavG0IocyMAgMzhOIYPMsBoSMggO25oCWiECKiNAWyVAeQOU9yCd8z/g0HRIOMAAui0CNIgHqkNAg8agcATP4DNAViqA0jRocBe03B80eCWp6g3e4gbasgQalPkJPNAUNMADSiPglQDfXjOABphhZ6bgXi1B/07W6LJ/BsrAaOefYRSMhsBoCIyGALkhMDoAAAo5EgcB8A4AoJgHbZwBG+jga6uAy89BjRlQoxvUQQbPPAOvSgI1gkAdGlBHBHRYG+iQJdCydFDHFrR3HLQPHaRHzaIQPJgAaviABgVAnVNQQwjU+AU10EH3LINmx0D7NUFeAu1BBdkHWrIMHkQANuJBV7+B2CZ+c8AHk4FWIsBmS0ENNVCzFtRAAzU/1SyLGED7f0GNKVCHBrTqAOQP0PJ38J7p/+gnpkMareAT+IENNpA7eIEHNIHUg/dMf3/LAFlqCpmdBvsDeLYB6OowUAcIsp/zPnibBOygPQZooxQ0kw86AA+0bB9kC+j+alAnHbRKAeRH0HLgV3d3M4BOtQfZBRJn5xFjAHVU1K3LGSDLVSFX1YEanqBlpaCVGKDOGaijeGFHAbjjIqcbyQCacQb5F3So16HFruCD7WBnJoAGU0ANS/B96aCGOXRQAtTpBbkDdEo2aB8saBsAqLMPy5igrQmgDhZo9hm0xBY0ywU62R7UGWEB7nUHxTvI/6DlzLDOIp+YDsPbR0cYQIfIgcIQNOgAGnQBLdn/D+/oMDDAZ+YZkNmMDKCVIPzi+gygfd3glSKsnAygGXWwXqC7QeEH3usMPFcB1KEHdZK5gHe8g9zGCB3Y+AVsQMMGGkBiEqpeDKCBpy/A67dAKzhAGLQqA9Rh1LStAjbgISepg9IYIp+AfISlgQ3v6DEyoPYpGMH9z2/g6+JAMv8ZQHEFul8d5BbQoZdKRqmQE/yBaRDUgQUdTgfavw3qTIM6ZeBzK0CrXoD+AJ00D0oPoPwG2ioD2gYDWr7/CnidH+QMjY/gK9ZgZ2JgugXkPkhnhgGav2GdNdCMtikwL4G2yIC2o/yHnrMBWZ78nwGy5QLa6UYxGGIeKD5AeRx0Vz9oEAF0UwQoPXx6c50BtmoEvOICmBFAeQJ0rsM32NJ0lI4yAziNg9InaOAGNPsJOssBo2L4D3MLhP4PPpkfuMoGOOgGCiPQAW4MDIiOG+h++4cXF4KvGQUvC/8P6eCCBi9B6RvUqQOxQZ02UDoEpTPQoYTgrRmgzj1sxQNwJRDITU+ur2MADbhxA++YB8UvKP2gdtYhcY/sbpStCAyITjh4Owfw8EDIjD/2U9//o/kXdG4F7KR9UBxCzhK4wfDi9laG/8grEDADDiICDfP/DMiDAYi0jbCPAbyKAVcnD3nrDyjsmIDbl0DlLihvgTuvjIzwcwbgW30YkWoelDqLkQHBReQlFLtJ6CyBVkaAwwlevv9nAG05AoczUrgwQgpncPkjrx/LAKl3gFeMAg+yBK3sAg2ygOoMbiFlBvCSf25RBtBKNtBAI2RQGzHQAnI16NDZX8D6ELTyB1ROgq46BNVNsEEs0C0lIDfIaIVA66V/4ANuQdsCQPEoIGkAv3ECVF+CzgMADaiBtlQxUNpZpHJnc7Tzz0A+GBEdf0i9xzAKRkNgNARGQ4BGITA6AAAKWBIHAMBaGBjxRwmSmbBZQ1AHCnxq9c9PDJDO/1sGWOMX3NkBNkBBDWjQjIuScTq4kQOabQM1mEANH9CyVNB1S6AZDlBHHNRpADVmQWaCTrAHnRgP6ej/YQA1ykEz9SBXGnpOYrh3ZiYDIzMLA2iJN2h2DtRhBXXiuPnlwJ1CkGdAB8KBZppBHXNQZwRkn5p5PgNoBhy8NBnaCQGdxi2vHwc9XAza+IX6lxG6PBzkPtA1X6DBB1WgGaD9/qA98pDZtz/g2WRQhxd22BZoySloOSeowwnaUw6aIfoPXkbMCL4THDSzBFqGCmrogWZ6QI1lUFhIKLsygA4nAy0TBYURZIUBZLYI5A/Qctxbx3oYQMtxQcu8BYGnUINmq0HuBHUUQTO4IL+DliczQjs+sI4AaGUG5NBGBnAHSEYrmAG0lx7UyYc1hsFxC/Tzf+iKDR3HJgbQPlllYPw9BW5PgDfmgXufQctgQXEG8guoEw/yI8he2AFrqKevg5ZqX2EALX0FuRW06gA0UAGb7UU0IBHpkBGtUwCK/wfn5zNAOqP/GGD7u0HhCL4vHbjfnZEBMpMJGngADRiBVlSA7nwHHer3+sF+cCcE3PEDmg2a6QYNOoEONoOcZv8XvBQfNIMKchtoNQGo8whKj6DOJ3g5PjB9geyFZxZ8jTfkPIOWL2FnF4D8D+oIgGYnH19dwQDargDa2mAfv48BdAUcaHULaKAElP7A+Y2VC5zXQGxWDkHwNhrQYAxoUATkB/DWG1jHD91t4A4XI3h7CXyZM6zTA6VBq3qe39nOABqgAS2XBq0eAQ3mITockPyBvk0G5B5Qegdh0NkSoEEp8P7031+AW1CuMcAGI0BXtIG2bYAGtUCzoqCbGUCrMpAP2IN0Jpkg7gS6C3Rd4F/oqf0M0JEKsH2gdApd3o/sHrB+2BV5QBqilpkBlL9g+/zBZRBwsAA2OAXZaiEPPrgTlIdBAxmgMgy0rQU0CAm+PQLW+QeFI7CDC8r/oIEz0OocNctiBtCtCKCZd9Dd+ZDohqVlRnBZBU73wK0R/2G3IMAS0X/EgApyhxu9U4Uy24vccYfH83/w7PFf0A0S/7Ec+McAGVBjQAOonX8GpKT9n4FwOkevNyB8NuDd9qArLcVAVz++ugI2BrQCBjzg8/ERorZhhK3NgA7SgOILKAsqt8FbkhBByMCAc+UAvtluoNx/bFdh/sc0jxESPqDVQ6DyELQdBrTsHzRYKwjsjIOvbQWmQ9CAD6h8AC3pBw0wgs7gAOUP9IMRQekHlM5BZ8+8uLuTAXR1J3x7BdB20MAAn6gWcNXJBvCAnYJBIvjcAJA4qO4CnbcBWhEHWvEESq+g1Qbga1wJdhjxhQcDAwMVO5yjHX8GysBo559hFIyGwGgIjIYANUJgdAAAFIo0HgBARNR/BlCjBNygADfUIB1VUIcQNPMD2psPmkn8Dz786CiDVdgaBtAeZdB+StBhgCA5UKeVETyrqckAmuEANb5ADUfQstOfwMPcQJ040DJXUMMJNCAA6jiBTk828p4OXgoJ6pyAZkVgS3TBHStgpQoyE3RFHqgjA+o0Q/bFfgAvBQV18ECdSFAHBbQkGHRfPvi0cNCSX1gjHxqOoI44aDYbNIMDchtoZv7lvb0MoBUNoBlSyBVev0FdbQbkK75AHQPQsm3QrB54dQFoySe478XMAJqNB7lXWiOQAXRdGKhDCjrYDtSJBi8pBW5LAM0swRtqwPgErRQAH7gI7DyAOoeg/b/g68aenwcPjoCWkoLcCuqMHFvhzwDa7w/qEArLWjKAVmSAZvlBAwLfwftURcH77kEzz6CTr0H2g/bGg06oBnWKQXeJgzrzoNl5kD2g8ALdmQ1vgDNCZu5AKwNAYqDlqqBOMaixDLtqC+QWUIcLfLgd+IYISMMTdHAZaDYYdrMB9kyPvVMBGiiCJDPE7ChoYAfUYQPNtoFuKACvSgCeag5aVgvaSgJyPyiNgWbNwFdQArefQAZGGMAHvYHuaAdtMQGtHAENsIDiDHQ2BWhQCMQHpRHQrB8o/ED3zINm8SAdOAbiGtKwgSRYlwfMh8xw8gqpgm+lAB0SBts6ARrMAd2Xf3iJB3hFAGgfPmTf+z8G0KFxoHQByhugQQkQBoUxKD2BZjhFFR3Ah2qCZvG/oRz4Bg1P6AAAaJAI1LEHDdQwwgcFIGpAfMiKkz8MHFyiDODOLFIHCtuSY8igEfA8DaB/QHkdlH9Bp9FDZsR/gW+OAHWYQNtJQANvoE4NKD+DD7r7+JgBNFgG2YIC6biA8gbEHF3wTQewQSnEDC0T+CwM0AAFaDAQtJIClo5A6Z8DuFIGdHuBulUpA2hPP2ilDSgeQeaCBp5A13WCBiRgB9yB0jBogAGU/0ADIJzAKxpB8QHZavQXvBwfXBwwQDvywPMRQG4CrTgBmaFqnssAuqEAtAUDVDZB8gkiPEFlBmgAE5SGQOUeKL4hs+CQ4SqY2//j7QwgqcXR+WcAJ0ksHVus5jLirW//Iw0qYFWINjgH7saDruoEbl0CD1QBtzSB0iaovIEtVwev+JDQYwCtVgGZCRoMgp27Ap7yB6VFYNiCBg1AGLRHHjRICZptB9UF8PKQkNugDsaZVrF7iAEWx6ByFlSmgW6tAA1awM4sAaVXUF0DStegQQHQlghQ5x9UdoOHHaEDO7BBHPCgKjDvgAYKQGkQfE4HkttB9RrIj6D8BjpnBLQCBbQSDBRmH56fBZ+hAT4X58NDcBkP2YrxF+Y7BrLAaOefYdCA0c4/wygYDYHREBgNAWqFwOgAACwkaToIgGg8MmLtqzGCl8WC9jyC9vCDOvagBu/jK8sZQIf4gWYxngOXqILEQHvNQZ0D0FJmUEcV1Oj+8v4OeJYX1MiS1QkHz9yBOl7wpaPARhWoowdqPIH3cr69xQA6OAncsARWqqB9w6COLGjmBDQbxi2gyADqDIM60aAZeVDnA9TpBTVMQYcLgu51/gm/Fo+BAXFQGQO4owzqxII6DqCOImh5JmhQAdQZBHXWwLPJoDBnhBGw2RfELAysgwTrbIFmnVnYecBnIIAagSD7wDPu/36B7yMH3SIANg3YGBYHHuIHsh/kT9BMN6jDcWiRMwNoUAK8LB24CgJ0UCBowAHUeNw3x5zBKeUEA2RlxmfIbDkwvEBLWEGdOcjM/k8G0N5x0JkJoAEZ0MyWiLwt+LA10EwnqLF640g7A2j5Nug+ekTYwPwEma0DNXRBHSnQCfGgcAbtaQc1nkGdLdC+b1CcgQY/IB2i/+AOM3gG7D+WTgoDItwhSRgUoDAMTdQYnWmIOCgdgPZpPzg/lwG0hxYU35DGNqixjDQb9v8/AzyagGaBBiGe3wIulQbukQZ1WEGNblAnFdQgZwIfgicJ3h4AmqkGzVK/fngA3MFG3FkOsh8RJjgLMSzuBpkPMhd0YCIo7kDhB1qFAtoCAzqIDTQzCDoEDJRWFAwTgdfQ7WMAnYAPWh0AthU4qAJajQLyA2jQ6/2Lc+DOOmi5PPiGC4zZUkYG2OF1oKXrn9/eYACdaQHqQEP2moPCChKvsJT88ztiRQ+m35BnGYHhCuz8gfIdaKYSdCUjaPUEbOvFn1+fGMAz/MB0CEqz4OvrgMunQYNUoLwEGthDzO5Cyg7QKhvQffOg9AW63hA02w7qcIE6l6DwB6U9yJ31LxhAW40gM5H/wZ110NkhoDQI6kiBzQYPYEBuUAANNoCWcoMOyYNd14dYkg+ZKYYcVvmPAb60Hug30CoL0NYF0Aqirx8fgG9ZAA0YgOIRFC+g/Pjk6ioGxGAoLBQZGX6AbmaQMmUADX6A3AqZ2WZiAA0GwFaCYEs7jMiDRqDOMWg1EijvYPTdIXHxHzlfIXcu4IU0RCNsuT4D1Ilw44ioMxiRV4oxQtIUvPMOXBWhYprNAEqzoAFE0OAjaCUOaFsFaIUEKD18AJ4FATorhBU4QPDy3i4G0Cw7LL+DB4KBB6CCVh2BBlJAafPWiQngOIUNIjAQAf4T2bFCX2EECw/QNhLQ4CFo8E1MyZkBvEINOCgLGggADQyAymwWNi4G8EqXz88ZQGedgLazgbaj/cdYbfAfvKILXgbC3c8I8zb43BbYGRyg8hO8mufXF/CgMuggSNBgFijsQAeugsor/EGAZ/Z/tPPPMCjAiOn4g0L7P8MoGA2B0RAYDQF6hMDoAAAslGk6AACyBHkQAMaGNAhBJ9GDGk+gJdugDgHoBGlwpwnoJlCDUELNCzwTD1ni/g08cw5ayg+6zxs2kwLaZwmaQXrz+CjDG+Cp4JAr/hjBs7agQ9pAgwSgxhZs2TNohgjc+AI6gRN4haCApCH4YDrQzChoFgXkJtAVfaDOAWjpPOjUbEinBK2TCF0KDfEhIwO8DQ7sEMpoBjGA9rGDOv6gFQCgDgErsCMPmvGEdHShgQ9upIPCBLaslRl82wB4tQSwEQ/bTw2afde0r2UA7S+GdWBAHT+QuaDGsISqB3RJ8gtwhwM0+wTqAII6TqAODGi7A6hhCOp4gWY+QasZZIGngoM6P6CGJGgGG3QWAWjZ88GFTuDl5aDZV2FpMwbQ4YKwVQogl4LCDmQmEwsb+Jo30Ow0uAMIXWKNPFOM0gkAdpNADWNQfIM6RKCZVGkNf/BecdDgz2voTQCElp2idHawlRRY0jPI3aBTsUEDO6AzIEBpAHTXNqiD9h92SjZQH2g2EXT9Iej2CVA6hHQ6QA0ToAlQdeBtFKCZXfDsLjP4wEHQVV6qFgXgjjdokAo2sMSAawCDATVfMKDlRXQ/gma9QR0bFbMsBtDBkuDrFRkhaQY04AAKc8iVmBLgu/cZoHEBmnlmBS6xBg2mgM4IeH5rMwPkwL+/DJAr3DAbXeC+GnB2FjSoo2KewwCaudQGXusHmlV88+goAwN0hQoDNP1DZtsZkLzAyIC1YwVvzAL33f+AXCkJch9o1QgoDYFnyYFLvkHbY8Cdd+ASeNBgFmiVAyhvg2bDQSsskDtOoAEY0JkWoIEp0CGIoA40aMACpA40cMYnrM4A2h8N2iYE2ibBgLTcHdRpB22hAcU/KL+ABrJAe/hBnTrQeRiglR6gTuin18Bl6UB96H6CbQmAd9gYIVd8ggZNQG4ErZ4AhRlokA50NghoRcvlPeXQQUNG8BYTyMFysEEuSJkIGiQDpzugeSCzWDkFwauIQIM4DNiWtkM715DOOuSsD9CAB2jwAlbOMTCQ0LhmRC6jmRhAg02wwQjwGQkMUBKqDF/1gZr/IUkEFLfgbVTAcyhgqydAq65At5CAVmmpmOUw3Ds7mwG0HB68Tej9XfANJ6DVK6DVQlBTwPvun97cAB1gec4AOmQRdMAr+ByW/8jnImD6HXfHH10tI0oJw4gUNiB/gMMVnDYgqz9AaRU0CAs6UPIh8GpM0NkcoHwEqtdEFezAZTvoVhbsWzsYsANwsgAebMrOxwDa3gMKF1C5D8o3X97eBF/jCKq7QLdg8AAHsEEDg5DOP47BU7At9OlsjS77ZyAfjHb+GUbBaAiMhsBoCNAiBEYHAJBDlaaDALgaUQzgfaigfdeQu/8vg5frghrk3PzyDKb+cxlA92yDZtRBjVnQKccgGrwVANj5AjWOYfd3g/amg5b5gmazwXuKgZ1nUMMLtF8afP8+0iFX8BlAYMPt988PDOCzB4DL3RWNksGzcqCGJqgDB+r4g9wGOlAONDv4H6lRiTIjxAheKA5u2IP0gg8Ce3iIATSzpWKWywC6fg204gC0IgDU+APt8wfdGf/v93cGmFtAs4OgAQfQNgFxFXdwpwvUuAQ1gEHmgG4kADW7wTPWn58xQDq06gygjhOow6lsnAbsGO5jAM1+gq5dA205AHW2wR0BoLtBnW3QrD/oVGjQkvVN3aIMd89MB56PMIMB5CbQlX+gWUaQ+aDOOHhW9NMTBlDY/Ybea64PvEUBtKoA1Mj98PICg6ZdNbjxCRqUgA26gE5UB63GUASeNA/yE6hjBrpu7/PrawzgAxaB8SILPMgKtMQXdA8/aFb7LbBT+ezmJuAhVqcYQIMD2DI7PLwZIQMt8BSFNrPIgCcdg2bAQenlDTBuQCsawIMxwBsqQGkKZB4oFkEDLqAOMugWBNC2ENDACGgwBmIsyG4m8GGOoFleReBsO2hvPejedNCSe1A4gsLk6fW1DKidQ3zFF2reQKwoQe9d/QfPjIPOpAC7FRiOoH3CIPeBBnRANx6A9qCDBsLAnVoG0L7ufwygg+wghx3+ZQCtCgGtsIGs0gC5CXtnBxzWwMYnaAb86v5a8CwtaOUE6JA8yNkUoKTOxAAf6AEZxQgJQQgTMjAB8TXUDvTGLFA5KH2COvCgJe+Qcz7uMkBuX7jGAD5hHmgmyI+ggzJBnWLQlguG/38RgQkNIvChoUBxUCcSdJI9KJ+BBnZAHTRQZxC0ageU1sAnsQMP5wMf/sfwHz4/DdoGAUobxj7TGUADQ6Dl96Al3KBOFOycDgY8e8phnUklw2TwVgxQ5x1UNoHOtQDd6Q7abgIuIYD+AXXaQJ0/UJyB1IC2aYBWHyGnb9AycVB5CMKg1R6gAUrQ4AjIb4itQ7BggIU7cPCBmZ3BNGA+A6jcAt0OoWZVzADqEINUgNMK+IYRLB0/aJ6BlGKIdAcKPxAGdf5BZQYobUHO0vgPHvvhE1FnAG2fQQzIMGJN6DBz4eYD7QOVaaABX1CZBFomDzoYFrQqCFSWgMoY0EolVYt8BtDKlrdPToIHaEEDjqABHnAaYwJtj1IBXz3KJSDPAIov8FWqwIEl0DYuy7DVwHMxJmJ1D/bOP6EOMcJv4LgCbWGAYlA9A9p+BroCEzToCorzD8/OggcGQeUt5PySvwwKBgkMoOs2IWfVYOYLbJ1l5AEUkLvl9aLAhwqC0iVkpdt/BtB2FUFpE/CAHmh1k6p5HgPoVgzkNPuflM4klTqeo51/BvLA/5E2Ez46888wCkZDYDQE6BoCowMAyMFN0wEAcJMNbhvyLAqsFQ5aKgmaZYed8K4KnHm8f34eWJoZfJjZR/AyWwW9WAbQTCuooQg6YOkH9Oox8J5s4F5m0F500CFuoE4caN86aI8ueI8zvPMO7ZzAll8CafDyeEaQOBMDaGkm6CRoUAfEJe0sw8VdJQwgPnwvNwPCL/CGIHwlACMDaGYc1FkCdQJAs5ev7u9hAM3Qgpbng2h9t14G0FV5oJkb0B3TDPAVAAzgK7RAKyFA7v8JvOcetMQedO0cqMMKOQRQBGmJKCODjlMT+DYDUMcGFB6gzi3kHn5Ghtsn+hhAgwewBvqFHfkMoCWqILWg2SM9lw4G0B3UsEgBXUMFWg0BPoAQGNKghqu4sgv4oClQ5wy8V5eVG7wnF9TBBHXcQPeGg2aE/0P37YPUgG4iAM2ygjrSoIGEz6+vM4Aaq6BG8W/wNWZ/GUCzqqADAUEDC6BrCiEH531HdP5hfRBwuDIwwJYNgwYUzAIXMjy7sYEBPAfJiNw8Ris7cDWigOK/gIM+oLACndMAXw0CntVmBK+iAHVKQOcAgLaYgGeXQQeRATsczMAOFmjJMmj7CWip+SPgNhXQKhVQeIAGUJiA8qDbGMCdNLwz/+jlHFLHCakzBklqSB0PmDaoECjcQGEMOgQNFHegbTQgt4GvkoTaj+ic/QcfaAk5lBCt84GS9xmh1jIySAMPfgQtwQalY9AqAFA6MPGbDV4RIglcmQNb2cKAnieg7mREK1OQOwQgW5SAg1aggyVBaQHUuQTN/oIG4yCd3H8MkA6iLgNocEhExpIBNLCFYgbQfGWTdHD+AnVwQas2QEusL+0uYQCtXoGsNpFgAOUj0AGCoLwGuV0B0eAEDURB7nf/wwCaoecRVgOvoAC5D7QSAXRfO2w7Ecw/kI4xM8SX/xGHxoHSAUgO5EZQeQZacQMa4AJ19EFXBYIGw0ADc2xcwsDZ6lrwNY6gcosBObyAfgKt0gAd3Ak6qBR06CNIDwiDzIQNQqIX17DZf9BMM2gvOmj7FGjPPHiwFHgIJ6iDDRogIuZQN8hgBRN4uTpoVh3UAQfla9AVk6CBPPBBqcAl/MY+M8BXe4IGUVG6/oTqErj8f8hADzDvgfIhaNsMbIsT6NpO0Gou0OGtoCX2oIFR0AAv+GA7YLkAqgNA5QFoYAi0NQLEBp3WD7q1AZSG7pyYyPAfebAIGsbkdf5RMx4orEEdbW5BZfAAKcge0CopcNkKdBtoEBN0MwdoyxroFg7Q9hFj3xngwWzQ6i/QdgBQWkAuBQh1lmHh+w06KAsy5x/4ysY/4EEYULkPiiNQmgVtiQANioAHvhmwATwdrtHOP8OAgv+jnWGGUTAaAqMhMBoCNA6BYTQAAAopRsqDi9qDABjmIToXEMcyQvYagzn/GWCdbJAqUOcYtIwX1KgBzciBloyDGq+g2T3QcmBQYxB8OBh0VgvUKAPpBy2Lh5xwLwM+NA10zRjcXEZQB48FfF0eaGsASD/sNGbwqgMBBcgeTuDhb6BBhxuHWxnA2wygS7/hIcwImQEFdUJBh3ZBlr//Z4B0EED7kgXAhzKBTmcGd5yA+/VBgwygg9de3tnBADohH9RxgxxwBZmJBJ3oDprFBXWWQXuiQddKgTrW4HvlGSAHKMIadKAVESC72HnEwQ1Q0EzhL+g1g6BOKOiUcml1f4ZLu0vBKwJEgXv2RYD3lZ9aH8tg4N7HsGOKOrjzH1TzAzwjBQp+UOMePNDy/T3DmY1JDKB7+EF2gxqUYorODKCtEA8vLmYA7XsHzdiCGpywO/VB8cIIDhPI3mnw3n6gACh8wYcoAhutoP3bkI4UIzj8QbOHoOX4us5t4GWx4CsX4bOsjOAZRlC8g05KB21NUASdeg1cKQByEyMTK3AvrAx4wAC0wgMULyizl7hyAiN0pQZ09hekFzZLBulAMTJA9u3eYQD5DdQR/f7pMdg00L5t0JJw0JJeEXk74KqJKQygjhxoSTKosQ3qmIDiDrTKAXZ3N65ZN0Yc+QJsEVQOPrQBV4s8q84AnmkGbTNRA247AHV8QQMQoAELyCDLP2i6hTUmkRqV+BqYjNCQhNKggSzQTDUobUHimoEBdGYA6Bo7kEpQpxKUFsEdQEZk98HMYQbPVoI7KgzQJdn/EW6C7bkH5Q2QX0Cz9KAOOmgmH7QSAMQGDZqB0g0ovSFWVSAiGKQOFC+g8gBEgw6nBO0nB98mAhwcAA0CgNIMKB+CbhQAn8OB5AaQ28FXswH3bYPc8xq4LB1UfoBuAQGtiAHtxQcNAkHSCgMDbNAPdKMGqLMPWikCvrbw/3/wqg/QAMuvr8D719l5wauJxFXcGEBniYAGm0BuAA16gc/pAF5L+f7FeXA8gcsVRsgAJMhM0MnuoIE7UDoC7+sG3mYBuhIOdBgjaBAE5ntYmoWnJ6AbQGkANBvOB7yC9O3j4wzywAFT0BkeID3gwUBYPKCvaIBkYPhgG2jVAugmENCgBj/w9Hk91y7gwNt64CDMbXA5DVq6D9qSAbshAaMGwkjjUFdjiIPKP0jaAa0cAm2XAKU3UKcZFJagQQ8Tn5kMoMMbQf4CDTyCTALFB6icA12lCFIHDjfgmQDgrTLAOgG0aoS4bQ+kdrggtQBoa8ePL88YQGcQfHlzk8EqfA3DgwsLwfkSdJWqpm01eIsCyA2gffqggWVQeQ9akQUqN0BlJPiwQkhOZSAGgLa+gVZAgOMR2PkH+w860AcqK0Fbl0AYJP7+6WkGmP9Ry6HRzj/DYAQjtuM/OuDBMApGQ2A0BOgeAqMDAOhBjqvRhidq8MzBQnShmIlrAAA6EMAIvc4LSIM6jKCl1aCZFcgSfshBW6BGOujEcRFZK+D91dsZILPTzAz6bt3g68hAM2CgJd1W4WvB9zeDGkug2SLw3egMkA4gaAk+ZAaYBbx0FDarBpo9hXX4wQ1NaOMKeVk5I3S2HzTjBDrcCbycE3iXPKijC95bDfQvuLMPvNIK1GkGLcWE7Jn/wADqGIA60KDOIuj+eETDnxF8Xz0owEADEiC3gTo2oM4J5K7wf/CwBHVoQKdAgzqn1w7UM4CW7IP2GkOuUvzPoOvSDl6xAL4GENjxB+2BBi99By59NvSaAr5eETTzCloqDFraq2yWzaBhXc4AGpAAdfhAjWnQ7BaogwMKD1CHEtTJPbzEnQE0+AJqpINWVYD0gtiQTpADw1fwSfIQH4CWNIPCADQLySukwgAaWGDjEmGAHOr3jwHUiQZ1l0AHCL64vZ3h3dMTDLCZauRZVtBKBdByYJAZT65B7thXsywEDl50AlczuIBvdoBclYVIoKjpEblxgZT2YJ1VRohq0E0UILeCZkhBfoac9/CfAbRNAyQOGnwCncEACgdQB+MlcFUHKN2B0ihokAayTBy4NB20mgTYkYSkIcING0akzj3YB1A+ih+Q1CCrB6VP0MqUl/f2MIDyBPgGDOBeaVCHHLxUG9gJhXQAMDv/eJcaA+0DDSjADgEEbRkApUfw0n9gvrSP3wM+kBI0EwlKo6CODSz0QZ1ciD8gA2SgFSegVTrfPz8Bd4YZYPkJuTxhBI/1MIBWgoD0G3hOZAAt4QYdogkauIOcjg7pXKPOXoP8BTw0DbjU+vO7WwyggS9hOSvwbCho0A/U0X55bzcDqKMKWo0D6hD+A3eaIJbDwwA+g/+fATToCFoNAEr7oFVDoCv9QPkIPHgFyayQbQ/AcIDcpPEK3OEDDQCgDE4A1YIOYYMcHLkZfP3oqwf7wCtheASVGECrlCCn+yM6v6B8DVrijohjoP+AbgOtMgGFC8htoEEQSCoG+Z2RARMgUg6o4wzqFILyJejAQfBhh0B3gw5A/Qc+gf4fA27AiDh0FLi6BzTDDkpjoG1BoPgAnZMB2yYEGngBuRk0Qw+64QB+nSfIcLRBBezbcxghC3zAB2mKgZ0EOhQUZJ6QtDl4tQloSw34ervfXxnAhyICy2BQPIEGaiArwH4zgG6LAQ0K6Lv3MoAGf0CdbuRSAbtfye18QAYsQJ14UNyAtovdOtEPXmkCuk0CtAcfNHgEWgUAKi++fXoEPnwSVE6AVtOAVu6AwgnkJkQ6JOwW0AAIRp5mgJgCWp0ESlegQZG3T09CVz+Q4L/RmX+GAQOjnX+GUTAaAqMhMBoC9AyB0QEAbKFN4iAANQcAfIufgZfFgju9wPYtaPktpEEMbciAZtmAjWLQ7AvonnaQ80GdedCVcqCOP7ghDr6T/hcDaBkkqJEFanTBOikgs0Az2v+AM/KgWUZQA1/XuR18sB58tgQ0M4Y0Q4gSRIyQAQRYQ9Yx6SjDO+AsG6hzJCpnywBuoDNCZj9BDXzQsmzQMtz/4EOigPuxgUvPIUs/If4Bz+CB7yAHmgukQQ1G0A0H4FsHfgIPSQM2vkGdZ1DjloEB0lkALXXWsqtlAM2UgRrFILPBe6OBDgU1RkGNRPCMJtCPoA4UaOsAqJMOu50AtC0C5CdQx2bPLGMG0DVnoNk20OwUaEADpBfUsQfNfIPcApID+Rp2fR+o4Q1a1g9yO2h2GNT4FZAyAp53cJWBHXilGuQEbgbw2QQgvaDZU5Bd4HMCQHOk//+BO2ngU9XB4QLp6CDCmRE+ywrqRIH2b4NvfXh3hwG07x50cB/kNoh34MPsQA1e8OwstLMB6syb+M5mAN38ADITNvsFiRbIlXCg8ABt7wDNcoIGITh5pRhAWy1AYQQaxAHHMlCDpIon+FpEUDiDOtaQ/elXwbPaoOXdkEGivwzod3r/x5V+wJ5EdNxQBgDQO/+wzhOSHlT1IAlG4KCMKfisCdCWBdCqFtBqj9f39zH8Q74/HqmBiW+pMSN0cAt0OCBoYAnkR9vobeDbIUAdF9BKk9vH+8H2gbZ4wDp7IHfJaAYzgM6uAKUjUJzB0hxoFhuUTkBLuUGrCEBhw4hcxkDZoI4kqIMPumXg06urDAYe/eDtLaC0g+nm/wzIYQwKUdDs6LMbGxlAN3WAlmCDOq2gAStQHgQNQMD2/aMMIiANSIDl/0NW46APKkEGQyD5GtTpAw1mgbYtgFbCgFYKgPZgw64mBLsLaM6bhwfBA16gDjMoT4FmhUFs2PkLkPEESL4H5TdQ3gcNqoG2n4DSGSgtyuvFAAfL+IHhfZkB2d0gs7mAZ6Sgpm+I+0DpH3QOCWhAElQmgQYvQINDkAP0XjOA8vV/2OwxPG0hDybABsoYwHaCD9RjgAy2gNI7aDUBKO5BeQdUFoFu0gCdCQLSBTqEDmE2tgEKBiyAETqowswAWrUAWr0BKitAA29Sat7ge+/Bg7wMMHcxQQ5PBLkJVB4DBzVAWyxAKyRAB7g+vrICMpgKVv6fAXnQgaiZcFydMUbUMAKFM2irFmi1Aujkf3C8Astr0DYG0MALaIAYlAZ1nVoYQDfagMpNSLn+iQFylgW2QS0GsgF4IBoYJqBrSUGrBGCr3oie/WcYBXQPgRHb8QeF9P/RBDcaAqMhMBoCAxYCowMAuIKekZGkSME7CIBhFiN8qTykYc3MAJttBO0NB3VcQHtxQR1oUEfhPwPsOjYmBtAME+j+Y1CnF7THF7ScUhx49RJ4ZgTYmQR1WMB7Xb+/gzSYGaFL9YFuAHVUQZ76+/cHvPMM6lg+v7WJAbKEnZEBthIA4nn0CooR4k5wJwnUkWRieH57CwPszAJQBww2iADr4MBmeeCBCZpthAYtKFhA2wdAM12wvaqg069Bh36BZuFBnQvQDDj4ijpwZw5kPTODZegq8F5S+LWC0O0JoE4IaD8zqAMGWgYMCkfIqe9bGb4Dl6qCOrkgc4WkTRlAM3mgQ8IEJIC3HwA7A6DGKmj2CNTpAK2sAC915xBgAO3xBzdagVezgTr2IH16LqABk4PgsALJga4GBM1Eg/wIOjn97eOjYO+COuagmwYgZwWcYADtj/0H9Qc4nP/DOnFI4cyI3DlmYgAN6oDC4fnNzWD7QLcqgPa+srLzM4Di8z1w9hfeoQJqhVzHJ84A6qxCTneHdFwYoJ0HkDyoYwvq0L+4uxN4vsER8AnioJl+0KoR0K0IoM4SKB5BJ22DtpqAVkeAOiTgmT42bvChlaDOLWgVBnjJP3jGH9Ggwd/5h6UEZH+C2IzwPADqPKBmPljHB6YHkYBALPA2FmDHAxSmoBUnT66uBm/7gGwvYUDpOOLr/MNdBuxQgWZ3QbO8oM7i48vLwTPjYB8C0woblxADKM2COl3g/evANA06rA102BxotQAonEBxDgpLUL4EDUqAZstB+7mROyPwQQBG5EE1iN9A+kArZyD74/E1FGFy/8FbYUArN0AdVlCnDHSIHOiqR9AgAOwgNrAfsZRt/9FWJkDGXpjA+QSUdkDlCqhDDRrAAM3sXt1XAw5j0OAWKC3CzghBMec/4mpA2EARA9Kye5D/pTT8wCkTdFAj6FwQ0Mnxn99cYwDZCRqkBHUsQfkOdAglKI2CbvoAbZMAdbhBB89BBioQqwFAZoLcCT4XATiIAj5RH3jVHmgABrQa4u7pqQwcwMEuWHmDGhTQdIiU+GDyoBgCxTkoPkD+BaV90CDs7ZMTGUCdYFDcgvI7yD5IWYqZzhFl4H9syRt4m4gmA2iFDSisQCtYQHkOcpAdpAwHdWxBeR482AB0GGhlF8gg0JYv0OoP2EGvDOBy5R80qkF+gtmHzGbABKR0xsBG/QOnOZC94NsZkM6CgJxLcY0BFFfPbm1hAB+cCCr7oGX1f4ztMAw4ALGdJER5AsqDsMGu0aX/DIMXjHb+GUbBaAiMhsBoCAxUCIwOAOAKeToMAECWjzMz2ERtZgB1WkCDAKDGK6iDCjp9m09UgwE0Sw/qDMBmVECdXPDVZcDGFKhjDGpYgRpgysbp4KXwoBlA8HJd0KABcEYd1BEEdSBBDXcJ4GwuqPMIahyBOgighjWoEw1ajgk6oA60vxbcaUJqyIEaUIxoYQFqhIOWB4MP+wJ2iDSsy8DXsoFm7kC3BYDMAe9nR+7YoFf2IDngoXIgs0GHjkHczMAAOvQL5H/Q7CKo8w859OsvfNkxKLpAAyOg2XPQHlPQ6gLInth/DKCZX9C5AaBDBEHLn0EDE6C740GdQlBHGTRrDjpMC3w+Ao8E+B54UHiC7AZ1zEF7/kFmgxqt4HAAuhEkB9qvClo1AT7ID9g5BIU/yE5QRwAUN5CbAxQYQEu9QR0EyMANE3gZ98t7exlA8Qw+vA1pRhrSXP2PmJwDC0Abu5DeFwNsUAkUBqCwAHViQPaBBjVAp19/A96vrgLcvgA+FR+oR9O2igG09BV8rzjwxgHIeQnIDWhGcCcbNBACPnEceL3hpzc3wPaAZvdBaQXUiQUduAjqtIJm70CzpqBOFsiPoIGRp8BtCLyimgygA+VAe8NhZzLA/ENc5x8Ui4gGOzh9AcMVdPUkaMk46BwIkNkgcQhmQgyYQQcyYAEHCSOIH0EmggahQLPvoI4jAzENTCxqQOaABmtA6Qd84jrQbaDBENDZEaDT5UFhBTIbNBgDOuAOlAdBaQOU5kCHz4E6cTxCqgxvHh8Br/QApTfQVhbM+IB07MADHqD8wIjwJyzuYeEKLqag6QLid6R4RV5tAe2YgTqrIDeCDmkD7bOGlQnI5oCuBQRdFwg/JBFmDtAMUJ4BDSaABslAZQXoPA1QngOZCypD+MX1wQN/oNlu0E0Qr4DpHHbuA9iO/+juQ16xAE6G4MEF0Ew6KA+C0jXILNBAAjPwoE3QdgXQKgZQOgUNwoBWR4BWuYBmuUEDL6CwBJ8FAB5QhKUlyMAqaFAOlA9BA3WgATTQgYKQmx9eMoDKA9BNJ+ArJKGDEYx4ynqIHCMDaIsRyFzQqgPQChlhGXMGUL4ED2ACz0sBdYBBA24gN4MPGmSAnYeCmtZxVvRAL4BWUIDMBqUd0HYD0ACUtmMjA+z2E9A2DtB1jqCDJ0Flig5wZh2UX0HuAp0TAwoT0ACBMvCaTNDAJWgQBaQfdLUo6HpI+EAyuiMo6oj9h44tguIbFuf/wNusQIOwzKwc4MFI8OoQ6IGEhJf8E9vpZ8ALRjv/DIMTjOiOPyhK/jOMgtEQGA2B0RAY6BAYZgMAoOBkpF6YUmsQAMMcSEMVNKOlBbxG7u7paeDlyqBZKVAnAry3nAnSgQTtxwZdkwWakQYvvwZ22EAtLtheSNDyeFCjGHJF2WbwvnBw5xnYAAUNHoA6taDr6kCdBtAsGqgTCcJG3tMYQKeYg7YGgFYSgBrYoAYtZAn9F4b/2DpG4A4IE3jfOcg8kHslVL0YHl5aBO7kigD3H4MawaCZK9BeY3BMwPwOpJFnX799uA++CQB0wjpolQBkye9zBpDfYOcQ/P7xDj57C/IneN/8f8g+c1BnA3RYGbjj8B80QMAE3IP/EHzdIGgAAXQyPWiJKqjz/vz2NgbQ9WHHV4cyiCu7gff2/vr+BnytFqijd3ZLOgNoqTBoZQXsKi7Q7B543zTwbAPQ9grQlXmgOACdBwDyB6ihDRlM+cOgoB8PXqYL6lw8urSE4T/4usW/4JPZQUufISd3gw7Sg3T4QZ0KkL9BHSvQjCho6Tiosw3u7IJDgJEBfUUJaLBF3iCeAUSDOjegMAN1FkCdf5AZoBlrUCMbtOwfdMYCqJMPPpPgP9I+Z1DHTt6eATSDDVo5AtvbDupTgwZAYNergQ70Ax3WBpmJB91X/wG8DQC8n/r9PQZQpxh88BtwkAE08ARKT9rA2xjAg1gMyB0BaFYEpSWseQmSVxmhHVvQlg4th3qGBxcXgq9WBKUxkJ2CwFUaoNUZYNNgnWBoOMHFYMuj0XI/3pU5GGkc0TADhQdk1vIvA+g8ANAhjKDZXdBBiKB0AYp/8HkRX1+CbQQfBAeMd1D6AA8QQDuXoOv1QPkZnFZAcYFsJ9D7oGXk4BUZv78xgDqV4O0xoHEa+CobRgYGpEEPkH9AqzhAHT7I6gPoMmqov5HzHCw9/YfFCSM0XTFCzJTWDGAAdapBg4OgNI7In5A4By0/B+0jBw2EgA6iBHXy+cV0GUDpBpTmQOUSaDvAyzs7GSB30+PbUw+LGEQYgwaVQHaDOvzawHh/fnsrMC/FMUhr+IO3EoHO4fj64R54ubuMVijYANDMODjdAlc4gVYyMcBCBzqAAg4roPdA6fv++blgd4EGMkCz5XouneAbTkADXODBIaxVBdqAGch8YFkMGpT6D9xSBD5bAnhtJmjwAXQWB2gLFWjwB5R3QGWSlLofA+gAU5hvEYMLRNRLjJDUChpwA5VLoEGXCzuLILEPShPAAVPQYAboijvQGQ+grSJg/wLTlaJxKngbF2gfPKis/PLuLgOo/AOlPdDAHkgMsgoDFkdQf5LYGUNfQYORv6DelNOJBG+1AA1Qgg7NhB8KyoDPXso7Rv+x+of2HS5iVhYxjAIGhtHO/2gqGA2B0RAYDYFBEQKjAwCEooGRkeiIwtnZwDADOlMF7FyCO4HABhyoMQ9qpIFm40H32IPufv4GvnqNheE/9OAu0EFsoEYxaCYOfPgasDEFXj4PNAfUkQB1MsDXkjFAOpqgjihorzrs8DKwR4BuAd2bD7oq6inwKjmQ70CzcCC3mwYsAJ/sjnLPOHzJLiQcmIBXX4HumgYt4QS5CyQK6uSA3A+aOQfRoAYwaJaOETqjCWoEgzqosD3vIHeAZv1A19mBZuTBDehvb6A3IIAaayBTEcvjQYf4gTpWoLABdUrAh4cBDfkPvgLqL7iDAFoqC7ID1MiFyXMCZ/nBdoLUAsNIwTCJAbTqATQ4cXlvJYOURgD40ETQigVQRxPUyQOfuv7qMgPo7ndQYx6kH2QvaDk36A540EwwKH5AM3+gAQgG6DJn0IoH8JJ74Cw/bEb1P3S56zfoKfrgljww/EEDCSBzQMuqQbN3LMDT0MEz7fBDBCFJDr1RCRo0eXBhAYOMdigDKNxA7gLFBSgtgDCoY8QvoQ++Fxx06jtoSTXocDhYAgaFKuiebvB+YqA7QEuHQf4GhwkwfFjYeBmUjFIZQB1MUHiDOvb3zs5kUDHPZQCFGegedtAyZ9A5E6COHyicQQc5gsIItJLkJzwOGXA39FDyAiM0STKCBzZAg0+gcy3+QA86M/CYyAAa3OISkAPnAVBHBjTTCunGIuVLaIcWZBgjEht1lQADKkBpiOLuIICWVoPsBQ0MgTqUoIP5QEvqQQNfoE4YKA4g99UrM4DSDuhWB9A2FMhBZ9zAO/2NGUCDUZBtMqAl8RC7GKEdfFBHD7y6B3hNHShNga50A+UbUHr7DB7sgzqbEdF5l9ePZYCt4IHst0cd5EHkO8jWIlAnkRF8uCjMDMhKg7ePjzGADt4DryJ5cIABdpUlyEY1yyLwlYOgcggUH2+Bt0+AtzYAtw+B0jxoqwtolhnkDtCM938s180x4AL/IYNEoNUHoMEVUKcVNPMPGqAElV+ggRXQ1pxjKwPB51JAzjs5AL7+EzQIA952AnIHPGgYwWWApl0NA8idoHgHXy+KJA8KZ9B2JchqIVgcMDCAzvxA+BtbOoCkTZA+UL4DrShQNc9nuALcAgGKb1A+Bh0sCrqb/iHwBHzQiiSUwQXo6hFQuQja1gWKX5ydaGiShtUjoPhhhCRqcP4AiYNWN4FuhQDlUVBdAEpnoLwKvroUmIdBeRZUpoBX0qh6ggc8Qf4D3xQAPxSTgSRAbOcW5m7Q4BBoABGUnkGdf9B1rpByElfnn/wO+n+CHUoCZlOhQzra+SciOY34jj8ojGg/EMUwCkZDYDQERkOAyBAYHQAgFFAkDACA22oMOAYM0Do+sJkhUEMN1GEEzZCADvECNaRBYkpGyQygWWFQAxl8bRfQXJAa0B50y9DVDKC9p8h7PfEtLwY1FEFL40GzlqAZcdCd6SA7QeaCDiYDn5APPJzv8dVV4H3lhPYdgwYMwHvNucXBnXbQ9Xmg2WZQJ0dQ0pgB1FgGzXqDZstAnQ/QsmjQrDHoSkPYHmFQwxXUSQVd8QWa+QWtPgAdAgaaoQcdZKXv1sPwAnhdIChMQW4HLecFdXpBnY0/wP34kOr0P7ijCeqEqQD3+UJm1Bkg5xgA94TfOTUZuL1iC3j2GjbTCbIftLwY1IkH7XkHLbc9tzWDAbSUVgF4zR7kvn4WBtCKBNCMOshPoPAAzbSD2KCOBagTAlrlAJ/pf3OdATYYAT6hG54EYBU+rMMB6YCBGuSgzjqoIwmKU/A5BMAGEmgA5++fnwywgQLwfmlQwwk6Mwjatw8a6AE19kEm6bq0MYBudgDNdoK2X4BWTrACO/GgDroI8PYDUGcVnrzhHUjIsnPQjCj4wDUxHfC2C5BfQGaABiMg+/1ZGVjBZyCcYAAtmQalEdjd6n+AhzOC0+m3t+COlzRw1hM0iw2+yQC8z5dAQweeFxjhS/tB+QF0SBioMwy6chG01B50wBpophW+xB563SV83wTIHIzOPyQXgv2NlOcY4SsEYL0szHwK60zAZ22B+kF5BnzlJHD21S5uN/haTdCMMuggONAADkgOlIZAg0OgzjQoPkEzt6A0c+NIB7hTDeo4gw/AA+17hjWEGRnAfgcfIgc86A3kJ8jBb+oMoMPfQNs4QAMJ4LgGugNy7SWk4w5KP6CbK0AdZtBWCQakVRfgq9C4xcBXcIIGTkA3N4DMAeVXyKFooOXs0gygQTvw1Z1AvaCBHNjqD5BZoHB48+gwON+AVtiA8jeoYwmSA/lZ26ERvKwbtKcePFSHLc7BcQM5JwQUnqAwgJ0VgrLSABinoC0K3z8/ZwBfWwccUNN1bgUf7AhyM2grDmggFJRXwIObSNuTGKDL7Dl4JcDRDdrqBFpVBR9wY4CkL1B5B8rvoK07IIWgsJTVDmcA5RMQW1jOmgEU3rBbCVDTDiTlgJazg1ZBgFYTgfwMynegw1dB5QXo+knQ6gjQlaQ/oStCQGrAKzCAA6bswPgAlcGgwYHfwCtGsVU5jMgrPkADp0h8UNixcvCBt92ADjAFD/AA0yNo4A40+AQq+8HhCxqMBA7EgNPbD+CqHeAqK9CgLGjVCqhs4QNu3YGfiwEuQPHnU3I7tpAQ+w8+ABJ0nSPIDf+xzvwT1yH6T3bnkfad/9GWJhEhMNr5Z2BgGO38j+aV0RAYDYHBFQKjAwDExAcJgwCMJA0AQDohoOW3oAYoO7cI+KA4UKcA1JkFddJBM66Q/ea8DKC99g8uzGcAdWwhM+ovGDD278L8wwg5hR60quArcDmoiLwNA2imCNRglNEKAXcyQfv1QR0t0EnboMPeQMtx4Z1/9EobJQz+gw9BAzWcQR0E8EAC0F7QEmZIx/gf+A550J5xUIcB1DEF7UtFvi4N1IEEdYpAhx6COvygQQVu4KneWsBZPNDs590zMxhAe6dBFae0RiDwDn4HBsiS61fgThhI7Q9wp+EfeMn9beAVVKDT/hUMExlAd3+D9IFmoEAzUZCDwhgZBIEn9YOWb4O2EoDsFhDXY+AH3psNmvkGnbwNGiQAdSBA+2VBtw5AZtjVGCD34P8HDwqAri8EDRwwgPceQ/rqsBsOQEEPin9QAxwUn6DOAWgPLMM/6Cn5YAWMDLAOG2h2G9SZA52nALrt4SdwWwJICeiaNNCsO3iFAbThAFrOCz4zAnhVGKiTBzrUDdQJAXUyQPvxQXvfQXEHXh0CXB4NCitY2mCE93lBvU4mcBoDde5BYQHeAw7swIHOD3h2azMDaPuIuLI7A0iOW0CeAdR54OSVBMcFyMz3z8+AB6Y+v73NALpTHtTpBcUTaLAGPHiBlm5gDX+MfAHtuIM6MxLAmUpQWpTTjQZ3GkCDQaCBDlDnH5S2QKtcQANDoNUskOQN7j0zQEdKGCAdLagnkfMf1OPodqPyIQ0z7FtemBiEpIwZQINOoA4yaMAEFC4g9q3jfQyg9AEayAGfOwAMQxAfNDggrujMALpZAdThAuUBEJsBpePKCC91tOxrGU6sDmMAHcYJSleQrQT/GAQkjRhAs6egLUGgeAfFDwfwhglQZwo0uAaafQalsVcP9jOgHtzJAJ71BaVT0IoNkL/4xLTA215A9+GDZtpBJ82DOqrgu/Z/fAQPUoDyCmgwAdksUNyAVuqABt5AZdCdk5MYbKO2MlzZXwt2G+R2CgnwgB9oOTpkwI8BJV5AnWZQ/gHtnQcN5DDAtqRAVwHAGsYgu0DuBaXthxcXg2+wgF2lCcoboHwKGhAFd/qhVoBXNUAHRu3j9gAHRScxwM5+MPKaCl7uD8o3oME8kD7wiipg5xqUJ0GrqUDhDRooY+cUYgB14mGz1IxIWy4YGGCDVAwMoEEe0Iob0PYb8I0NDP/BYQ8eGAR27MGdf6C/QAMXem5d4JsyQO4BlQegMwRAW4RAAzoMWMpWUByDBjBAgzKgMhp0swAo3EGDQRo2FQxcfNIMoBUnoPARlbMBrwABDfaBzhwApRHQABKoTDUErpp5dGkxA2iLCGhVEGgAC3QlH0gd6NyQf9ArOhnwAGrNaIPSEvxqVBQ/Exh4oEqHkT6d/9HZf3wJabTTCwmd0XBgGAWjITAaAoMuBEYHAIiNEkoHAVD0M6LMfII7/MD97pzQ06lBS8RBnVLQXeCgDhbosDnQ9XqgU9tBjUnQUnVQ5xF0Wv5/pH3FKJ0toH2gQQIOLlHwFWagxq1Z0BJwx+Q/+M5+cfAJ86BGJqjDDF4mCmuU42qAwTpU4OXETAzg/e280gywK7ZAnQDQ3mnIlVRvwHfIgwYbXgHvjAc1nmGdC1iHDTRrDOrIgE8sB84EgmYZlUzSGS4C972COpuwzgGo4wWaWQUdxAeaBQT5C9QYBnUQIF0pRgbIcv2X4M4pqCMMavCCVkuAli+DGuSgJcCgjg9o5hOkF9SxBHVMQLP5oFUQoEY86H5w8FkIwLvkQXaDOnSgQxnBHQdopwDUafoGXqrPyACaLWcHroIAdSBgHTfwvnVgOIFWD4A6Cw/OzwPPtqJ2fCA9GPAhbMDVA6BBFNAZAyA7QecxgJbpg/Yp/4Werg8KdkXDZPBABCjsQGcOgNz+7OYmBtCSf7Ae4CAPaKYetKoCtvUAOWmDOkKgdCanEw68Ju4SA8ivsI4IbAUKiA/qwIIGbMBuAs4igmb9QeEPGsyAHQIHigPwGRTA2UYQDV76D5rdBg50gOzE1yhG6XwDIw+0wgV0OCPo0DPQ1hEBSUNw3gDFISjtS6i4M4C3Gry9Aepugbpj8A4/SN7Efw4DKBxggwFgPzPCBgggIYDSoWOEDIKAtpKAti8wgDtxyA00JDYwH4DCGeQWUGcXdA4BaBk36OBE0EARaNACfIgi0EzYShHwtZTAwQDQeRKgVSWQk9lBS/TRG4EQN4Jm0UHLyMFL0xkhVzSCOur3z80Gb38A+QB0ywRoaTuo0wraYgAapGHnFGYADQYiBhagq0wYQQM8PxhAJ8WD8h7o+jXQDDRogA18jz3QraAVNQ+BnUTQzD6oPAHZDxrA+Y/eOQc6ETRAARqIAp10DxokAOUFUHoADQ79+fONAbzyBJgfwNftgW4egSc6SBkHupLQKnwduNwBpZW/8A4oYuAFFCWgAS3IOR98wJPln4EHGNWtyxkeXVnGAEqXsM4/JH4hqyfYuYTBN1iA8jl4oOLVFTAftLoIpB6U50HqQZ3qb+/vM8BOngfnD6Clr+7tZgB1tkEDLf+ht0jAzWdADDJBtk9A0xJQHzg9/Adts2JiAJVJ4HNIoAd8gg/nc4Zcewc6IBI2iAlaaQAqH+FXMSKFE4gJGnQEXa0IMgu03QQ82AQ8XBC0KgZUPn58eRm82goUXyD/gfIp6OwE0IGgoCsjIcUTI3D7jyt4exAorYBW+YBXPv35zgA6EwCU5+EDXTjKeKp1aLGaPwg6/gzUA6Odfzxh+X+008swCkZDYDQERkNgEIfAMBwAAIU2I22CnMhBAKyrAFD0og4AgGb5QTMzoI49qDMpqmDPADqx/+2TY+BluF/e3mQANfRBHVLQsl8BCT0G0PJTUGcT1GmGLOVF9zJwCSaw0Qu6oxtkNnhJ+JWV4FPJQY1j0FJQ8GFYQG2gQ/PAd2ODD9iDNsyRlqwxos2qgmeh5O3Ae57B14MBO8GgBiuoMw9aHg6a6QM19EGzkCA7QJ1HyDkEDKCWOwNoOSzocDGQWtAyZVCDFjTLahO9Fdz5B29JgHYmQJ08kD9B7gXNpoJms8DX/AEbtSAfg2aKQR0AyAn9DAygmXvQgX+KRilgv4I6D6DOC6jjAloyC95jDVw+Cxk4+QccOPBnAOm9fqgFuELAhAF2SwJoEAY0ewnqJH6H7uEHzYSDwh8U3qAUBupI6AKvBATt/QctswbphcWCulUxAwtw2S5oGT5oiTiosQja6wy62gycQoHpAdSxBe/HB7oHdM4ByN8gt4A6eaCtFJ9eX2GAddJBAxOgAQxQh+LDy0vgVQ+ggxxB8Q86KA20RPkVcB83+JBHDn6GXyidMQYGUFyAZhVBnUlQZwLU6QNdFwc7HAy0mgJ8lztwHz/oEDbQwAhoxhJ04NijK8vB132B2E9vrGcAdSh/fXuNtPrkHwPKHl8ich8jtIMF6hCBzk8A7e0HDezIAe99B82w/gYv92cAX7EGGqQCDSwxMkA6fqDbDww8J4IPIwSfGfDrCwMrpyB41QL6AhyUzj8DpGwADQiBruUDDazBOmgQJ2NvtMKyLq+IJng/P2gWHjSABOr8g87EAJ/dwcoFnmUHrfaAzKT/BYcTOFz+Yx6OBzITvIWAmQ08oAEa7APPyANnkkEn74PSLGgWF5RPQGEBGmCADFL9YBCUNmEAzayCBnVA8Q2+Dg7e4IYc4CcIHEi5dqCBAXZLASjtgQa/YEv9QWzQ7DIoL8HS3X9o/od1bEB5BDSIAcrLoPwDvnHk8zMGyGz6QwZQJxO0rB68JQKYHiChC8njsHMHQANWoPgEhRnkCkE/BvDZBuDl6v8ZGKDbF0CdddAKJdDWiv/QmXXQ6iQG8IGasMENRLkOGgABlyOgvAn0O2ilj5pFAdhsUBkAOrMCtGcftEIDNFAH2rcPGvgDb3348pIBNHsOmlkHlSegdAc5eBQp4QKtAp3LARos/Q89ZBTkJ5AfIMmIEbz9BTSwKaMVzAAqh0DbLUD+BV0DCjpXBLRtCHRFK2iwFrQSAPfsO2SwAZSmIYd7fmOArQIDDYyAOvEispYMoK1Cn8EDhl8YIKs7gAeNAgcGQGUDCzsfA8itoMEw0HYHkDkmvjOBt8usYvgPHZyAbb/ClT2J6tCS1bGjR8efgYGB2GXWVOicjnb+caSi0Y4/WsCMDoQwjILREBgNgUEZAqMDAKRECyPxAwsYgwBwvRAzQJ1obccmBtCMLWgmH7yUE7i3GqQP1OAGLSdlB8/eP4Mc+PXzM3hGELQkG9RgBy+7B872gTpzYC/gnHGBVECg5dOgpaKgGUmQ2aCGJajDDpqZAnV0QbNc4Cv38DSiYH4CNXJB18R9fHWJAbScHrQUGdTRBc22gw4PAzV8QWKgK/1AHWZI5x/ib/PAReC79UGdF9A95aAZL9CSf1CD9f65ucBZ7kcM4CWtDKDOHhMD6HA50H3foI4AZFUAAwNshpuREbKcHbQC4Tu0I8Arogbu0L97fBx8yB/IXFDjHDQQApptBi1TBjWUQZ0N8HJtZVcGkDmgzjF4qTFwWwBoD/Ed4P3eIPdBriH8xwA6iR4cL8COzv2zsxhAV+GB9IH8CuoAvADeNABawv7h+VlwQxR0HR+ocwXa0gCaBeUVUgEvJYd1AmSBp5qDOhigjhr4gK7vb8HRCDpjALTq4MXt7ZAONiOk0wuaGX8DPIhNxTyHAWQnqGMmoeIBXoYuoeTKAFraDZopBA2YgGZlP7++hpKyQUv+QecwgDptoFlE0AnsoA4saIYdEsZq4HQGOhgQzBfRAO7DNmcAdfjVgdc8PgIuywalWVB6BR9AiW2wCFfjD0u+Qe6YgwdTgJ0UUIcUtAoA1OEBnzoPXN4OGoiAbDEBrvJQ82EAdZJAK1ZAYk+AZ1aAruIDmQXqEP2C3hrByICADNAZf8R2ASYG0GDNo8tLwZ02kF2QlAltqKH7AZrlQcaAr4sEHj4HshvUAQB1QkGDdbCDJkEDKuCOwX9Ex/Y/UsccESEQQ0HxBBrsAc3Ig/IlaOUMqCMMnvEFzmZDVppAB+SA4QNa6QHq7IvIWoM7n+BD+H68R9kCwAjNN6B0BJqdBq2cAQ1miSk5MwhLm4Nn1iHL6a+C752HDQaCVxL8RxxSyIDi7v9gO0D+Bq8MAQ7OwGfywR35f5BjGRgh4Q5ZBcPMAF5eD5ylBx3iB57dBw5MgQf+fn1mQJkJ/w8bdPzHgGIvyiABJPRg++pBeRc0aAg6PwR8owdQLfj2EeDqJtAZDKDyFBSWoPwGzqfAtAQ6FBO04gI0gw/aBqBuVQreTgUanEDtPDKCywRQGQnqPIPyN2jwENT5h2zDYQbLg67YA8mDBsxAeRIUNuCYBQ1IAAfvQAO6oLIPtAwfVGZz8skyQAbOEJ0CmH9Ag5+gbUyglUygwQh5vWgG0CGAsEEZUPkFOfyPlUFaMwjc2QfFByj9gFainFwbBVyJ5cmgbJrJcAd4qwwbMKzvnJrCAFshQmgfPd4OLdmdOnp1/BkY6Nn5ZxgF2EPg/2hnFzVgRsNjNKuMhsBoCAzeEBgdACA1bigeBGCELmFmYgB1EEEHVIE7ssClsULAu6VBDWPQgU+gvaKgWS3IqfW/wIfMGXpOYLhxuJ0BdKc4aBk2aHbrP/LBYnj8AtoHCxpwAHWwQJ0N2In8oEYyqKPw+MoKhv8kzKCA9o6DGuugzgpo5hmyVYGP4fHVlQzg5ffAzjm40/kFck0aqGsAUgNyN8h+0MAA5LC1/+Brs0Bs5EYq7OAwUJiAZjnBYQRs3MM7jtCtD6DOPWiWDTQQws4lxAA5nO4NqBsEPjUcNCMMOaDwL3ivMngmFdhQATXmQY1z0AoF0Czm9y/PGEAdY9AqC9ChZKDrzsAdPfChWqzg2WZR4BV6oP32kE4FI4OScRp4RQNocALU2QF1JMAHiwFndTmA++aVgMv2QTctgDoAIH2gmWzYQWyg0/VBHT7YrQ2gFR2Q2do34HQBPhANGp8gcdDMH2j/OaijATrIEdR5BM04ggZxQHvQQYekgdIKaCAA1Pn/j76CA5huhYAHNII6qaBODCgOQJ0o0BYFkJ9B6Q7kf9CAB6iz8v3zEwbQwWYg80GNa9BZDaBtChB9f8AdNZT0QkzjDynvIAYAIAMcoDMPQIMooP3qoO0u4AEc4OGCsBsdQPEPGmACzR6DOsGgVR+gLQ+glQt6rp0M94CDMv+h5zJAOv2M4E4y6C51yN5vSL4DyYGW2/MIAwc8QKeiA90NOv8B7E9sfgC7GTHw9w964B0ofYJmoEFna4DSEChcQfkBuWOLvfMPy6SMDDrAw/RA53OA0icob3DzyzHouXaB93qLKTowgAZowFcQAg9jBJ+2D7767idkVdC7OwyQ0/ehqwtgbgc6FTQ4B3InaNYYtMLBwKMfPOgGShtqwJUpN4/1gFdLgOP050cGjGXpSJ1/hB9g2xggjVpG+MAIeIQKXqaBBolAYQM678PEdzbDc+BAFshvbOz8DCB3gfIMaFAJ3tGHd/6RG8vQAYH/sIEU1IINVF6B8rWySQZwxVAhg6iiI3ggEpRuBYC3YIAGsAQlDMADpqCzQkC6ITeNvGUA5RNQWQEKO9CNGuhbKEBqQe4HrcJgZedhAJ0rAhr0gp2NomqRD95mAJqNB92kAlppALoZAJT3QEECWsUB3qYB3JIDyjegslBIyoQBtFIF5D5I/scsqB8DV2eBVg2AygFQOQG6ux+0igi8PQu0AgGoRcU0iwE0mAg6uwRkJ2jFDmhFA2hwS8UsB3zGC2hQDDToA8oj3MDbM0ArH0CDHgzkHEJGUYcOd+fnP9U7ivTtaI3O/mNpaIx2/tECZbTzP9rxGw2B0RAY3CEwOgBATvyQuxUA2pkAdWaYmFnA+9ZB16mBGpegzqZD3F6GW8d7gUvrHzOAD6oCHnIH6myCGpegZa1Pr68HL+f89/s7ZD/rf7Q7nTH8gpi+BM0qP7m+lkFePw58XzSiQfgfPHvMQHIHjoEBttwa5BduIWXwvfegJdCgDiqoYQ3am4q89B+031bdqgS8RxW03xU0ewe5vQDaOQO7H1Fxgq4agwxUAIc5gDOvoI40qIMPumMadkYAaO+9JPAQOdBhaODl8KC9vsD9vNaRG4EHle1ggNgP3FsNPDwP1IEGhSP4NgXQAAVw2SyoUwkaGAGtFJBS82V48/gIeHYN5BTwYWnAAQzQIAlouTZoRg50CB4o7EB+BHWcQUt7QXeUgwZjQJ1p8Aws8N5wHcdm8Oy5oKQB+NBC0Iw+rBMB6hCBZv/By9qB7gKlAdAsI/gKQuASX5AZoM45yB5QZ0QReLAhaLb5+5fnDKD9waDl3OBtEsDbEMDL9r++YgDdoAAeTAAfOPifATU+/4NnB0HXx4EGekBpAbSXHXTnPGglBChMQWECuWWCGTxTDJoZBu17B3VyH11aCr4uTt26lAHU2QXvrUZOL8Q2/tDyDSN8nzUDA2zwATT7CT5kEagWvK0DuD0CMtvMCB7AAa1eYWRiBccRaPAMtMICdGYCKC2Br2BjgKwcAaU18P52flkG2HYCBugJ6aADBUErVxiBV++BloeDtlQwwMINmocY0Q6CY2CAjPWApaHZCjSAB9r+AZrdBm2pAC3D/gVdCo+18/8ftZMLOnQRdJgiLH2B4hLkLk4eSeABdvsZQOcAgK59A83mg9KuADAtgQarQJ07yGnykK0XDGj5BrR1ALSKBjRYBNrGASpvQMvEQQMroPAFzcIDR0cYQJ3ZNw8PMxDuHKKlJ0bIoA3IDNASelCHHDSoJChtCtl2AyydQOEPylu3gYclglbwgG9TAIY3KJ2Ctjd8RbvykoEQgIfdf8jAB/TKO9CqCNBhkaC0DOoMg/KQqf88hrunp4PPIAGdhQDadgNaAQXaLw9aOQPq3CPOBPgP3T7PiIh5YNoDbUkBrWYCxS9oew0ob4DOQADdjgBKj6BwBG3TAa2qAQ2usgEHH0ErREADHKDzFED+Bw1WgdwFSl+QbRy/UX0JzQ+MUBp0lSmo3ABtyQKd9wIaUATFJWhAEjRwBerkg/wIOvuBW1AZfKUpKJ5BdQdoQPbbx8cMoHMRQIN4oOsNQXlFRM4WXDagpxFkh2Dt0JLdocPf8aFu55/EThYVOqmjnX+0jDra8cdSco12/hlGwWgIjIbAoA+BYToAAAp3RtoGPjmDANABANCsEGjJMugkeiXgXnXQLCfoULGLO4sZQAfHgWapQLOhoKW7oNUAoAEALuCJ7OCD5sCHVf1lQF2iS7D1zAC7zxu0TBZTNXqFhSfsYI1WeAeJATyDCNq7ywCdsYPtKWZAm4UGNXRBy4FBnViQX8D7mIGOAc3mgvSKAc8+gF0ZBXIBqJGt49TC8BU42wnqTIC2RIBmGEFnBoA6XyA1oAYZK6cAgxzwWq+nwAEO2Awb6MAtUMceNFMG6jz/BnaWwcvGr61mAC2vBXWoQB0WUIcKts8ZtI0ANqsKcitIPWjmHjRIAZo1/g/ejwy5dQB0CBqoMwyahbxxuA3YyN7JAOmwM4Gv64JsifgGnoUGnQIPOwcBFPbC0mYMhp6TGEB+Bc20g9ICaDABpg7c+Yc3rBgZQAMpsLvlQbOLoBsbQCsMQGaCwgF0eCRo5hDUEQHNHmJLGyB1z25sZPj79ycDqCPz/NZWBlCnBnJI3X8G0AnkIP8KAZeJg846gMzUbgAP6kC2XDCAV3aAlqWD0iO8IUxqAxAj/YCHTMBbP0Bhowrcxw06QA80+AC62hHcAYMeHAeKE9Cd66AZXtCgCSjuQOkBNHgDmuUED2AwQMz7+/sL+JwMZeN08AFooI4RaLm/VcR68IoTUDhZhq4CdxLBh7MxIHVykd0IH7SDmMuA1mkD710HLokHDdQxsbCBt69g7eQghROiE/EffmQB5BC6PwygwyO/fnwAvo6TV0gVHFegM0BAZxaAwwW4AgEUTwzIy/WR8hnIbvAKG+Aye1A6AJ2zAYp70DkLoM4iaLYc1DEFnedwC3hzBmgLA+iAOJQBIxxlG8jdsEEb0GALaNAFlE5A+VhIxgx8sKSmbTXDy3t7wJswQINioM4/KL+BTqAH5duPLy4yQPbbk9BIhoYdcriJKTiC7QHlgd/QVQygmxIu761kAC2XB5UXoHwB2vIDut4UdHAiaMAFNHsO6qiDBtPAfobHNbggYmCExrexzwzwYCx48AR4OCtID6izDxroYGXjYQDlCVHgVZugsAOVdyA5UHiAbhMAhenz21vAKwVAgwXgcwP+/0dZYYU8+AUbAAANioK2IT25vg7cuQfdIgFK2+BBTOBAGGhQAXT9K+jsCpCfQYeIgvIH+EDY39+Agx5TwWc+gPwOcjdooAc04IIxwIM1LSLVCqOd/9GmKzEhMNr5ZyDclhpNSqMhMBoCoyEwOEMA0ocalrHDSHtfMRJnByPyyWTwDgUTA+jKOlBHDLw0FLSnGuhi0OwuaCYQ3DFjhJxuD+oAgmYzQbN5oMb1f/j+a8xGNPoyesoCAYf/cHTiQHbBGrOg2UEwHzrLy8TMzgDqzJ/dnMogqxMJPqQO5G/QrD1odh3kXz5RbQbQjOJ/6MoGUCMWtNceZA5oxhO0pQC07x3UKAbNqoEOczP0nsoAGjgBscF2QjtGoM4GaEktaKUAqCPw8fVV8KAJaM/7ua1ZDKCOJqjhDFnm/48BdiggaDACpBc0IANa4gDqDL9/fp6BAeomyPV0tyDqoYeVgTtj0BPwQW4FLSkHLd3lAHYcQB0Q0IAHaIkvAySAGECdF9BKjF3TdYH3j1sygJajg2brQG6B3If+Fx5toLQD2ucOuhoQdCDhJ+jeftD2AdB9+aC97LBtDQxw94DSBSJtoHdIwbciAGdQ4Z0+RkbwnmbQOQigAQLQuRCgWVXQnmOYQxjBNz8wMoD0gg9aRJvNxp/OkNIRRucamkpA4tBT8BkZoffHg688ZGFA8JnBB+uB0swP4KoHyMF4fxkg/v8LjUOgv4H6QQNpoAE20Iw6qOP0GjjTDQpfRrBfmcEdONjhkf/g99iDwgzqVpA6Bsg2AgaU1QDg4+2gywEY4R1GWPgwoJ9CCOucY3RiGVDi2Dn1FMP+eTYMoDMYQJ1T0GAOaFAAlNZB+QOU90FnXdw81ssA7/z/R8QzrrMGQKs+Hl1aArYLtIUFPIgATMtqloUMoFUpoBny+8CbKhj+ox5UCFrRAxqYAp078f8/ZNALbAjITmDY8APzKqjDCgpT8GAcE2TlCGjbEmiAEzRrDhpwAbkdlM9AaRx0ngNo1hx0SB78QDps4YLiL8i5AP+RB2jQExsjKF2yMoDyLaicBKVhRugWJFDaAG3nAXWKQdsSQPnpP5pfGaBxDQpjcCcfXGYxMYDO5wANboCW+4MGLEEDC6DVO6D8ASqjQW4CD2YCD6EEnRcCKmfevzgP7vhDypaf4MFRDLfD8gAoTzHAtqYwgQdNQKtT/kNvkYDk5//g1TegVTugsNZxamW4tLsMvBIItAIG5heQHEgNaKACVNaC0g141QFo0BJcNv1ngPsb3wAAWZ06woM51Jv5J2HgCJZOqNRRHZ39hwboaMcfR3VHRtpkGAWjITAaAqMhMDAhMLoCgNJwJ2sQAGLpxxcXGEAzyKAGMWSW5j8D7Dox2KwNaLk/aGbRMfEQA2imGbSUF7wkFNqxILdhxchIygAJFrUYgwAgP0HUIQYBGBkQM13/GUDLjcUUnRggM2L/GED3v4M6tKDZZ9BgAGh5K7ijzvAfMtEKtAM0awnaVwtqxIP2MINmfyGHrgHv5QcuOX4OvAoP1DECd0KA6o19ZoLvEAc1iEErB8SA+4NBs4+w08RBs8agJcC/wdcO8gNnxH8wgDqCT66tYgDNVspohzCAlnSDOhCgBjOowwtqzIM6SKDZZtCsHMgPILf8h55DAI4DRgZoA/sf+IR2kBxoRho0ewvqFCFmzIHywGsGIafpizOADkPUc+lguH9+LgOow8rwH+0gNGBYgAZHPr+7xQCZrYfIgzo6gsC9xfABE9gMI1rjDKNjCFIH6hQwIDdW/jOADkgDr8oAug0UlpCbD2Cz4v8hAyBAt6GuTiClwYPoWENSCiOOTjRkCT+3oAJ4P/wL6B5yef0YBlA4gmbaYdc/gtKZsR9wn/mtzYjODSOs0/4ffOCdoJQpA2jWF7TKBnR7Bki/jGYwA6gj/Ae2//0/6oAJrBMPvu0CuCoFlN5MAxcygJZ/g1YmQHIvclpnBGthRGQBBsyBAKSCBqMB/Z/hHvDaP1Dcg+IYdOYDaLvFnVOTGUCDWqDVJqBVLM9ubmSArBz6hLbFA60Qg5v/nwE04w4e6AGKgbZKMEAHD0HpBnRoIigdM8D8z4gY3NAAbvcAbasBDbiBzp9AH3QE5Vfw+QrAwzdZWDgZINdBvmZgZuNmAM2Sw67iBA0GgJbBg8IQVLZ9A9+ogZRukMoRUFkBWtL/8/sbsP/A5QLokEOkwTWITyH6QWkbVoyB8hFoKw5ouwQoHkC0lKo3OM2ABozAK5/+Q84xgA0+IBeBMlpB4JskQOUuaFAElAdAA5KgFUs/Pj1lALsJqEHfrYfh/dPTDKAVWaBrFkFlCeg8E8jg3RPw2Qqg2XnQSghWDkHwdiesVQwjpOMvpe7PADoHAhRmoEIPtMIGtCoIlLZh7gSFPegGA9DWCVB8gvwGGtgCdfZB5SLIjaCBSlB5BxoYA+VdYeB5MqByjRF6UOr//7AzHBCuwejQDsfOP8MooGoI/B/t5GIPz9FwGc1poyEwGgJDKwSG8QAAKCIY6RMbjITtwVwFAHLaf/BJz5iOhHaAgZ00UEcVdNAU6N7ub5+eMICu4gLPAFKxIiZuMADNjxgDADB5xKwobGaNAd7Y9WMAzZ6BbggALWMHHXQI6jCAZj1BV3E9uLgQ0tEEdUSAM4qM0OXcoGXWoM40aEaRAdaQBaoRV3RmAHVQPrw4B545BXVCQDOWoM4JSCvonmzQvmcGBsid3bzCKuAl1qAODyP0TADINW4cDKAr3kD2gGYp756eCrxP2w18JSAo/MGnewMb0qDGOqgzBNoWAOoAwGbjQZ0PZuDBf6B4hM0mgxf8/v3NAOuAg0MH2tECi0H9AepQg85mgC2zR2+Uw2dKwXvUEQexgQaGQNsb/qMMGKCmJGydf0iq+4/RgQQdlAc6MA500B9olha8R/s/6rJlsOlInUtk29AHorCnKVinmQncsQV1dMEDK4zMDKA9y+AcC0wroK0eoNnlF8BtCqBwkdYIBB+IB5p1BV95xwDJ26AO+qv7exlAp+KDTk8HdZIgnXBGBlCeAZkNWoEBOrsBfAf9b9C99boMoH33oHMG/v76ygAJ938MyO5nhPbkwX4Ahrtt9HaGCzsKwAfNQc4TgDT2YMvFGZDzAiMiHzAwwMogRhzjAaiDMDDloO0poJsxQNtIQGkXdMo7aDsQqGMKWvIOu3WAAQ/4j7zygBHasQeLMcIH1yAdfygfulKHETorDeowg1aZgE+9B4qBtibAZqQhg5P/GECDKqAwBHWOQbPvkuq+DOBT+YGddlAHFHzt5ttbDKA0DjvH4iv4cDyQw9EGAUDhBsSg+AXtvQf5UUrDnwHUyQXne/iA1X8GzLTGAF5NBdoGAj4UVNkNfFYF6HBM0AoE0DkdkOv8MBvpsDgEpQlQJxq0cgF88CTQLaDzBEBlECiN2MXuZABd+Qfa9gPKc8ommeCBRtC1rVzAwSrwIYOgQxqB15OC9uqDrqoEncEAKp8gN7Ug283IACkTmRhAh32CBvNAYQ0aNEGsJIEMhDFAV1+Art4UlrFkAA3YgAYbwGqBZSRoQBNUDoJWA4G2OMBu+ACdQwA6pwS0CknRKIkBtPqBgYHanRTC5v2nWj1FptupZP+In/0f7fjjLW0ZRsFoCIyGwGgIDLEQGB0AoFaEkToIALIXqx5GFBfBOo7qlsUM4NOc//9jIK5Rha3BxEjQt7gHA9D04h0AYAI3cEGdAohbIYMCoEPqQB1NUCMbNBAAuk8fdPAeaLkqrLMH7qwDOyOg2TVQpw0y4/sdfEUdAzy8IMtZP726zAC6FhG09BV0/zXoYD3Q0nXwIXJAn4JmfkGNYJA5oHu1QftnQZ13UCDI6YSD91mDOnSgRjN4n/KTE+CZZNABW6BZNJAceLUCsAMEMhu0nQB0ZR9oFQLoBHVQiMCWlIPkQdeGgU4hB+9xhnb2IeH5nwE+GMKAmG3+D1/WDBX7/x+6YgI5mtDiEd4Qg25bQG/UI6UplLiE6sNsyELMhw80ANWBOi8M6J1/lAYgwk2E0iJmemJkAF2bBjmr4R8DaMAEtKoFdKI/KO5AnRvQ9gtm4H56UEcYtDLhPXCAB3wYJvCOfC5+eQbQjPNf4KGQoL3QoFUkoIGbd6BZWeA1a4gl3AzgwSRQXIAGj+R0o8ADOqDVHaBl3KAOm5CMBQPsWjtIiIP8BUnnoBPgNW0qGUCHsN07Nweo7hMD8lYdUEcN5E7IYY0MSCtdYHEHMQecPoAdNdDMPWgZOgNSRxakEnPgASzK8PTaGgaYm0DpDrQdAzSQ8R18Dz9EDQN0gAxsO7asjRxnjAg3wjqZoM4taPCKAdb5B9KGXpPBZ0N8//wUvPUC1An+AbQTPBT0H/nQUUgaAPkfNIhmGbaGAbTPHjSABjo8E3TdJEgvqPMM2jMPyvegmWrQYB/o/IZf4Gsv/0MGolAGTUC3ggCX0f/7BR7sBMU/6GpNjGX7aCtYQB1jUKcYNIP++tFhBtiqB/DZHcAl9fD0zYAJIHmYETw4CHIvaFYflEZBK06YgHEHSpOPrixnAO35B13tB9pS8vzmZgbQ4AKojINcX3meATQYAkojoP3/oAEM0AoJ0MAtLM5BbkDOD6D9/moWhQygVRGg9Ag6KFEReCYMKL7BVz4CBxRA7gHZr2lXCxyA2AxeXQE+AwLof3vgobGgq1NB2w7ePjoC9hioTAWVp6zAawBB4QxarfTyzg4GyIoeBvjAH+Wz/9QeTGDAASiwZ7TTykAVMBqODKNgNARGQ2A0BIZbCIwOAFAzRqk2CABzFKRVD+osgWY6cXe2yG0k4R4QYCQ0OIF1AADS0QftWQfN/oGW8ELuWQd3leGzXqC73EF74kGnc4OWtIJmFyEzsYil/6AGK6ijAprRAx2QB5sdA3XeILPskH3JoE7Gi7u7GED35L97cpwBdkCapm0leL84uPMCnIlXMcsG770HNY7BS62Be8glVDyBnYxXDKDGN+TObcQMO8w9oBPORWStwAf2gZYzg69MA3aEQA3/v+DbGCCrC0Cz5qB+FGgmmoNHjAF8sjw0GkFuBu0PtovfAzzZfQ74oC6IOyEdf9ggCWz7OLxj9h91XzYDvCH2n4hBIOS4BbGxpRHkzj/IsVA1VOr8w1MxI6pbQLOWoJlJUDxw8EqADzwD7a8GX+8HHGwBdaxAHUXIcuZHYGPYucUZIJ1+PgZQxxw8owkMH9CMMqgDBRp8Aa3OgHRmQVoYGSBXZP5jAJ2EDopf0Cn9oDgUkbcDp5NnNzaAO/aYM6OM4K04us6t4JUhoMMZQfuqQdtRQOaDBq9AaRt0ngTI3h/wTjki38I6lSD1oGv4QEv7Qfogp/ejhztEH3xFAQMoqzAyoA54/WVgQFrGzYjSaQYqBd6MwCuiBhkoA0cl2pJvRkYG2B32oNU2oA44+IwNYXUGbugMNgN41vsRA6jTC4oL0DkEoOXtoEE2UBkEWwWASIeMDKDOvRawcwo6ZwA0Ow4ajAPFHWjWHWQHaOsC6Lo80NYZ0BWHjy4tZgCdRQDOHygDFJAyArLq5x8DaFsPqAMOGjQA3VQBDndmVgbIwBFSWkYy4z98vzsiLeNaBQMOcUaInaLyNuCVSaCtAnyiGgygMy5A5Qpo0Al0UwLoOkxQPINWoLx7dgo8MALym7HvLIbX9/eDMWhFEGhwCXxtH3DAARR+oCtBwStRsNQxIKtBA1ig2wNAK29AaVUYeAAnaOUFaLDjz4+PDKCtT6DVBM9vbwVv/QANiIFW6IBuQQHZA1qpxAY8ABVUPoK2WYAOj4UcWPodPIgDCquvwC09oHNFQOXSx1eXqFTbEVffUD77T69BBvzBMqJn/0c7/wyEUgfDKBgNgdEQGA2BIRgCw3wAABQjjPSNFnIGAcDOZBzAiga73dhmb+GORB4AQOqMgA9sAy6vl9YIAO9tBc1CgRqooJk4yGFujODr8UCdBNDNAYiZOURjTx44Wwu6ysoh4SADaAYNNBMPMgd0JRroekTQrC24IwB09i/grDCoYwSaQQZ11GAz16B7tEENXtB9+X///GR4ApxRfffsNANsLyyoYwM6DR1kFuhEfVDHBTQQAOoEgTr84NlL4PJv0EAGaD8wyH7QtYSgbQugRjZo2S3ovAKQn0AdJtDBY6C95Q8vLmKAHDbGAJ2ghXZp/v5iANkJapCzcgpCrkuDNq5QOnOgjhpw1hHUGQH5CTxgAQ50yGAB1kSCbTAGKAYaeEDPAYwMuNIZovOPOyEi4ojUxj2qHxnAd7SDlkeDlvuD99UzQoILtCQatIIDNGMMimNI+LKAZ1dB/gHxQfH86t5u8HJzUHzxCqkwgFYPgNwNWioNOiwSdJUeSC0o7XwHXo8GmqkGdcZAHfDXjw4xgE7Fhw3moPgXFpZAGpRWbh7tBF6tJgQ+/BCU1kC3CYDSM/iud+Dy9s/gJe5/4KEKdi9oOwg4bhnBnUVQpw40q6xskg68F38beAAIlCZRBx4g8QIOJ0ZGpBUFkEE1Bmxi8BEjRgbQEnvQrRKgw+jAgydfXkBSDSyNMYBuk7jMALpiDraSAbQFA5Q/IGH9C6wefNXmP8jBiqAZbdAsNigeQFt2/kMPjoR1iMDDSsDOLqij+ujKCgbQlZGgFQAgt4IOtQTl768f7oE7r6DBD9BMNGgL0wfYoZrQpMgIW4HACNkaAgoDWa1Q8PYo0H3+oHhXA96/L60ZBJ4FZ2BATav/GdDT7n8UvzMw4EnbQDeABuck1X3A+Ra0Ggg0aw6anQcdxghaSs/A8A+yxQh4swRoEAR0wwToHArQIAdoYBKUvkDnAoDyKjtw8A8yUPQfsg0F67J7aJwCXQkqW8BnWgD9Di4ngTdegAZV+CX0wde1glY2gQY8IYNb/xlAgxCgwWCQB0HXQoK2F4C2SUA6+/cY4FfEAu0FXwkIHAAA5S/QrRf///9loBcY8M4/lTquI7bzP9rxJyKrDI4BKoZRMBoCoyEwGgJkhMDoAAAtkg25gwDobmGk5+AFiYMA8A4JsNHOAOnogBruusAD7cCz9MDr5kCdZ1ADGXTt3Dfovd/gDg6wcQHubMP9i9xA/w8+OAvUwX4KnKEFNchBS7z/g+9wZwUfsgWafQM1MJUMkxk4+WXA14qBZh9hHQnIvtl/4Fle0BJw0IFZoAEA0Gw+2ErQNgpgox7kNvAeZuDd7eA750H+AHa+QbP7kE7SHwaQvaZ+cxhA9+eDOi7fPtxnAHXeQPv/QX7hBi5JB/FBbgQdKgcaIGBAXir9H7RCgBF8HSCo8w9qtGvZ1zGAOlSgAQFYEIDMAmFQZwo0WweafQVd4wXqZID2f9vH7QYfFIgzuSINAsAGWiBLgB3BS4wRZyfAhgDQO0k4TKZiQxA+CAB0K3h/OQMDOFxAHR9Q5/wfcFk/aGYdtMwd5AchKWNwxwt0XgNofzbIhRLK7uBDFkEdV1AHHrQkW1LVkwE0uAOb4QYNJbBzi4CvTwTFH2igATRoA4pj0IoUEA06QPH7x0cMyA18RqQONcitoFlqSTUfhrePjjKABoh+/3jHANoCArrBATzbDbzlAdSxB8UraOAJtJwefHCgvD0DJI3+Ac/ig1Y7gDrZf8BX8/1j+P7lGQMD+uoOUFiAbj8A3XwADhcW8KADJFYYweYwIp8aD5aA5Tsm8H58ETkbBlBaAaUf0Kw1+rJ30Ew9I3AWHTS4BDrYkpGZhYGTR4IBdLYIKCxB5oPSMmj2moWNF3w45vXDLQyg7TPgJeTgfIOaV0HhBwofkH7QXfugmXDQrDjITPC2B+AJ+f+gg1+gqzhBgyooxRrSwAbosEPQSgtQBxw08AfOh+BDAP8wXN1fywBbvQPu0EPTJa4tLRipGS0dI/T9ZwBtdwAdUAqKQ3m9GAbYViXQYaugwxhBAzj8YtoM7DziDKAzRcDXTQLjApQWYPv7QfH99883BtABfSD34dtywMAAW+HBBL65AFQefAbe7gEaCAClMyPgzSag81BAAy6g6z9BAymgQQBQeQE7DwF0OCkorkBuYWZhB1/BCFnxgogf0EAEKLz/o10dS9nyf3p0ekY7VgwDCUY7/0SE/mgaZRgFoyEwGgJDOgRGBwBoFX3UGgTA5z6qDxAQMwjACF+aDOowgBrrCgbxDKADr0Anlr9+sB/c+QF13EEdLdAyWsi93wwMkA4MA6QzA24FwwkG5D3n4CWwwM4S6FouUKMYdGggaDktaBYRdDgaaAYY5NJvn4GHIn55yQDagwtq7IJmPkGDDqAOzl9gxwPcnwM2ZkB3+4MOg2OADlSATtMGzVCC9+QCO1yg/bIvgMtsQQcBglcuAAcrQPt9wYf8ATs9oBP7IR38z+AVBCC7QYecgWbeQHphV4OBlueCZppBS4EVDBIYQIfSgee1gRpANz2ADuoCzcAyQjt64MPGwDOEIBMhGNTABw0igJbzPr+9Dbw8W1TOluHS3gpw5xPbcnV4EgGlB6DZoIEO8Bwy0G/c/HLgrRCgGWLQqgjf4qfA0+yPMECWrUMGJ+hZgoEHOoDuAm2TAHX2QHEHEgMt8Qet+gBt+QB1qCGHzzEzgDrpID+DBmtABy2COlqgwRjQbDBoVQkofYH2/0OWhgOX7gM7myzsPAyyWiHgMzNAnZ9Pb26AtxmA0gOoUwU+sR24KgBxBgM0BBjBKYQBcno6M3hZOGjmVQp4uN27Jyeh4owMCvpxDC/u7GQADVSA0ja4UwtO1swMoJPjBcR1GSAzxd/AaR20fBxkA2hlC2ggADSIhNyJhYU/KM+AbsIAdfRAy/lB4qB0B4pL0Gw9KN2Ath2A7+0HpyFmBjm9aAbQQA9ogAPkH9AKANBhcCB9KDPfQL+BttuArq0Dha8G8HwD0CAG+No4YAcSdF88aDADZCcozED2fHh5gUHXuY3h2a0tDGbAWxAeX1vNwIDSOQA1gv8zIK/iAXVIYddEggfRQKsGkGbBISUMbAYcMoAB2erAyAC6AhV0bSFothq0mgbUMQcNRMhqhzGABoxAGCQG8xdKRxa9gw/nozbUsXZ+/0P8AXIbKF+AtjPADpwEdf5B6fPrh4cMoHAD5XVQugO5BcQGlTegsgR0VgToTAlQGsY4cR+9Q8UIGRAEDayAOvKg/fugcg60kgV0vgDIDaDBRpBfwVuYQLcgAB0HskdeL5ZBUMqIAbRtwDn1BPiWh09vrkEGlKD+AMchRjxRI5cT1+khf/afSp0qKnVgR+Ts/2jnn4iMMtr5ZxgFoyEwGgJDPgRGwAAAKI4YByaiiOygMzJQyX1UGRAgNAjACJ+NBHVIpIHXWN05NZWBX0yLATI7BZQHztaDOkKgvdkgNeZBS8EdOdDy4j/AZbTgBjzcrYyIgYH/iD34kAO97jOAOgAfX15kAHVoQJ0q8DJ/aIcCtHQX2EtjgJzw/ZcB1IAGNc7BnSGgG0DhClID6hzyi2qBD3EDzbCD9hTDtg6AZp/ZgNd1gU6SB81egmYZQXvNQbOXoJlA+Gze//+Q2WLozC2oEwmbSQXNEoNmX0F720EzpSbAq+lAd3VDZjsh/gN37ICDGqADBEH7mkEztAxoB5kxQJdCgxIr6IpIUEcUtKQdNFsMWioPHrSA3unNiDqNygAb3AC5Q8+lEzggcwC8XxrkTlDYvQdufwDNGD64sIABdBgd6Mo/cjMF9gY+oUYRtOsHmv3nFAavzgBtswB17kADLKCZVFDn9MPzcwxMLBzgmVHwTCswTKzC1zGAZmNBcQXqTIM7h8AbMSTVvMFnM4DSFOg6TVBnHTR7DVr6DNojDYpj0KwobKk/eJUB9M5/jM4/LDCAzgTZwQec8QWlA5D7QKsLQKsIQFs9QJ3zl8CbB0Cz/aBVGrABCtCAhZiiA8M34MACKJ5Ah7m9AR7MBoon0OwtaKAC1OEGbTuBXx+J0jFmBHekQedK8IHyEvCMClCnENThBnU0DT0nMYD2eUOutIScO8HJK80A2uoAMhO0BQV0YCUo34DjFpaXYOmWAdLJBXUoQekAdEgdaLUFzNugQ+dAaYUDeNaCuIobeMULaIYbNCgB2ov/BHwoIXIcQ9j/UTra/xlA+Y8BahekWIMNMjGirmIArrQBpW3QDDdo8A48OAh0M2SbBzMDaCARFN+gMFcxz2UAXXcHuioRNBgGWhVDfNrFUbZi6eiA4gV0NSJobz5ktQYkzEArmAzc+8EDAKA0CdoW8Qa4jQQUH6DwBuVP2IGQKOdB4O1M/Qdva3HPvgJecQAaDIRcO3iPAVJGPGDQsKlgAKU12KALaDAGNCABOoBUCXhY4N0z0xlA52SAyj/wAZPQsuk/ts7/oO/YDa7O/4hr2452/ImM8tHOP8MoGA2B0RAYFiEwOgBA62ik9yAAvCNDyaACvkEARgZQIx00ww3qaINOXRcFLj0G7zEFdq5AS6BBy5Bh9/KDGvagxi3opPen19eC97DCOr6QWV5GBuvITeBGMGhG9T+0EQtyAaiTBpqhhO0VB3WcEctr/4E79KCONaizBVrqDZo1A83OggYJYPtdTQPmM7y6twe8VQB0KwDIDNDsHqijAsbAZeegThd4XzdwL/kP4PJs0KDB64fAk8ShHRlIZ5sRuqAANEjxjwHU2QINJIBWAIBWHoCWBoNmWEEd8GsHm8EzpbABCHBHEXiqOmimE3QrAShsWIGHd4Fnd4Edof/I95wD0wsoPEF+Bx1YB+rQgtwD6VgxgP2MiGLUeAK5EzRrCLquDNwxASo0D1rCADrFHtQBBcUbaGk85Fq9a5ADE0GGgRt/ULOg6ZX4QSnSG0Sgzgr4dHZgXIPiBnRoJGhW+/fPD5AzGoDioA4VqAMK6iQ+ubYWeJCfNQOo0wpaTg86cBGU7j69ugr2A2jmGjRLrevcDj5fAnwlG3DpOLjzDFxtAFq+rWlXwwA6TA3eOYXne2T3QwZrDICdbVBYgWb3QZ1fUAcLtM8bNJCk7dgEPD/gGANoVQoo/YM60aBZfVDYg5beg/eBc4kwvLy7k0HZNJMBpA90xoQo8OBB8LkD/yGH+WGbXQTt/dZ2bABffQfq0IP8DtpWAhqEAKUR0OwyaKUKqNMMsg90QByo8w8KC9AAlo5TC9g+EB+0VQK0JB8+0MEIi1FGBtDBcaCOLKjzCBo4AXV2QatGQAN0d05NYQAPnAAPzgSpAQ1qgcOMQGeWAZqO/qPP9kPTE6gjr2FdzgAamAG5HVQegPwH6jCDBjJA6RwURu+BA0DKphkMoIM9IVt5/jK8uL0dfCsCaEUBaBb+P5btE4hiHDHQhFK04yyHEfEP7jgjzaLDtIDiGXTlJqjTDQoj0GAaaLATdlAoyD2glQCg+HgJLGuQwwvXLDLIlaCy8uaxXuC2gmvgqxJhVySCBnBAfn0FXE2FvJ0IdLsBqMyxilgP3iYFGlhSsyhguHtmBvxsE9QBGWpWbsTlc/Jm/wdfp2pEzf6Pdv6JzCijnX+GUTAaAqMhMGxCYHQAgB5ROVCDACC/kb0qAHMQADbrDGocgTr1oGX1oOvVQLOQoA7ER2CHDLSEG7R8HTQTDmrkgzp6oKXwID2gBj94TyqwAQ+aOVUCHooG6mCAOuQg/aCT2mENXrBdjJAOGaiTA7qaDtYRhzewgQ0X0F5j0PJ60GwcaP8taJk7A+g0cOjSehAfdH86yB2gzj+IBi01Bh2YBpuJBbkZ1NGCzzz//soAauyD9wWDZ+WZGECzfmpWJeC7wEEdS5he0Ewl+GpD4P3foBUPoIEAkPsYoUu0QZ1T0PkHIDvAh939/88A6fizgJdug2abQZ0HSFRBZknBKxbEdBhAHWJQgx+08gG0H15E3pbh1YN9KCmWERxGoHBCxBfodgVw5wRoF2jpOGQARgq8hB2ydJmNAbIa4xv81gQG5K0IoDTDyACZwGWkZQaBzLCCwo8Bur8cbB10fzXoIDRQZx7UyQYd6AhyO2ifuIicNcNn8LL+98Al8DHgAxVBKwie3dwAdizokEXQdhHQoAd4XzvwPApQfIFWdIBuGICFDehwN0zf/Qd2OLeBZ7JBYe+UfBQ4qLARvLcetEwedKigrHYo+MA40HJ7UDoG30oBDLP3z88wgDrqf359AhsLyg9MwOX14BPhX10BbylgAw4OgOMb2ww0cLk86MaA57e2gq8fBA10gPwFutECNtsL2hYDSn+M0LMqQLPFDOABpH/gwwV/AQdRQJ1q8IGXwHMuUJbsAwMXtLUFdIo8aKsKKGxB6fPCjnwGXZd2BtDWAdASdFD6BK1uAWHwTDgDEQ1fLP5hhK5oAcUB6FT/l/d2gc/wALmdF3j7gJZ9LTicQB1qEANyVd1/BvCNJ8DBRNC5D6ABQNBAGCg1gga3cB5kh1LOoQ8CgLvbDAwY/kDr/INdg+lX0CAjaHXEG+D1gmJKLuADRUGHVTLABwsg6ZjYzj8szYG3rfyHXefJwCAsa8kAGgSBrQ5CH+gADygCzzx5fHkZA2h1CKisAR06ChqoQT1TAs0Pg7qDR8VO1WhHlvTCejTMiAyz0c4/wygYDYHREBhWITBCBgBAccY4sBFHQkecalsCkH1M8kAA7gEAWGiCOtOgvaig2XPQrCNoSTfoOr4Pz84ygGatQZ0VUAMexAZ1AkCNaPDJ7sBZWdDeb9Bd4SA+aIk/qCEL6ZxBtgGAliRDZr0ZwSeX/wSfag4ZEJAF3uEPu0YM5ErIcnx+8JJ3kHnwWU/gQADokD9QpwbUaQSdzg9aboxYafAfPFP/8/sb8InboA4jaEABtIT7DXQFACN0EALkP9DyW0kVDwbQ6f8M0CXWoL3roA4Y6P5tmBio3wM6ZM7Iawr44D6Qm1jYuMCHqT24MI+BE3hfvan/XAbQGQOQQwP/Qlf/MzFADmL7zgDqaILPUADuaQfpB3Xo4DOCeJMytPPDAOnBg+4UB8UXqFMsA9wXr+3QwAA6qR3UgQANWMCWOoP7/NDBBNChYrDOG7iTg9M+PI0iXA1LLB01yIAJJLGCltaDZqVBgyagMAcNVIA64lIa/gygQSLQKfLgwZz39xhAZzuAwvz901Pga88gS7e/gLcPgMRhy9FBHUjQPfqgTptV+HrwYXIgcyAzzNj9ALYHeCI7aMuEinkOA6gzDEpHoI4raJaai08GfH0kaKYecpc+A3QvPKQjDjpgD7QSBpT2BcT1GbgE5BhAKz/M/OczPLy8lAGeVtBKJdBsLmjVAMjvoCXgj6+uAnfMQfEF2i8uCby6EpT+QZ1R0CGRoNUJoHM4QIMooLwIOkQOtBUCfAYGvIMKs+Q/eIUAaNAAlAZ4hVXBYSGm4AgeUAGtyAENrIBo0AF8oAEo0FYYUFrEnBFF7mRDwhCe72DWAZWAZv7ldKPBKyJAgzKgtAzK56AVKqDZfNCgHz8wfECDhZCDQf8zgLYdgAbLQCfgg1YavQRe8wlamg++hQApvDDKSeS0xcgE31oEysMc3KKQgxxBt4aghTmhWXPQoA3o6kTQQCboDA/QVg4GpLAladYdJV8gp73/DKA4BK00QHT8UdMmyB+g7UaggTDQyhnQSg3QeSagFQrgQU+adeZGVudnRMz+j3b8R7syoyEwGgKjITCiQ2B0AICe0T/QgwAgv5I0EIBrEADSuQR1DkB7nkFLk0GzqyDV6sBZclDnBNQxAnUuNe2qgSfeHwPeaa0DPNBOCXziOHhf9F/QtWP/GEAzpKBOEqhzANrj+gJ48B3ImaDOALeAIgOo0Q9awg26y1pAQg98RzdoHzZoOThIHaijAppRBC0rh5xkDnPzf3CHDDRjCOoQfQCeIwCayVM2yWSAXaMFnslngAwCgDvy8BlCiBmgjgho2b6sdjgDqJENmsUHrUSALP+F3tEPnblmQOtsQW5A+Aq+oYCJhQ3cgQTdpw5a2i6tGchwdnMaA+juewbo1Vwg/4M6bzJaQeABBtCgBmgwANTx+PruDuQAQKTtEcizmbAOCOJcAGDXiIkJfI84SD+oYwjqVIM6s6CDBUGDKSA3gGYsQQM2oIEAaPcb3PliBN4pL67sBg570KoKcGgwEplRiG1YwtMhwmCYEGg1B2iLBagjCkofoPgFn8wOvIEBdCr7o0tLwTOgoJURoI4kaCAAdKo96CwAi5AV4P3jX4DXz4E6UqAVKiCzQB1M0GDUk2urwOdKgHzz++dnBtRZYVinFuJXDetS8En8sNUi8sDDLkErRUBpAXTIIOjgS9BWAdDAxD/gChDQbDpo9h10XSRothq0BQC0fxyU7p5eX88ASougO/HBM7YM/xmwxRsslEEz9KAZcVAnD+R20FJv0FVzoHQPukECtPUE1JkGzRpD0jNkcAy0zQCUxiCrSv4xoC/JBrkBPDACjCdIHlNgAB3GCBocM/CYCLx2cxEDyD4hKROGL29vM1gELwOvgIAcKsgA3sfPABktYgCdVg+7Mx+yXgTWUUSlv7y/wwAaDATFJchf4FPpgasWYCsMQPffg7amgAZIQGEJijdQ2gdd5wja5gFy8z+0wwRh4YQ+CABZecMEvCJSEbxNA3xQH3BVBGiVESg8wSflE1rRgJaGQekGciDof/DtHf+hg38k77XH2fmH+Ab5MEWwCJa8BLotAHQgKngACeiOH5+fM6D6iYzOOsmDw9jLAtKX/1NxYGG0Q8tANBgNKwbSwMgaAGMYBaMhMBoCIyIERtAAACg+GQc+UklsbNFkNQA4KIgJCzwDAEAzwPfxAzuwoM6qoKQheNk0aHYR1HmAdaxAM9ByOhHgk+dBYrAOJaixCNpHDTrVHbRlANSZuQfey/of3L8AzcKA9sK6Z19juH64lYFPRB181zto9gt0Ajzsrn3Q/ns74BV54PuygTO2IM1KxqkMoFlaBqS99aB9/t+BtwZAltcyQA4kY2IC3yX/C7gCALY3nIWFkwF0uBxoFhY0uwYabAB1pkDLuEFbHkBbFiBLbqGNAnAQQWdA4YMA/8GdZ9AScPAydOBs/L8/P8FuAs3kgva0I2aAIZ11UOdfAtjpBi3/Bq0eAM14qlsVM4AGJkCzpKAZcNBBaKCZbNDsM+Twsf8YHTzI1gkm8DkNoM7/3dNTGUDuBs8sAjtR4NsZvr1hAJ+OD7x6TBo4s/7uyQnQ/QgMIL2gziBIDagjBVotATt7ANSRAt1iALnRAeRfLI0iUhuWaIMAsAEMUIcd1OkDDVqAOtSg/dCg8ALNBoPc8ezmRgbQTDzovAZQRxu0FB/U+QYtxwfxQR1z0MCRln09wyPgcmlQWgPtrwedoA7a9/7++VkG3EvbYYM/rAygwSzQifCgFQSg2XIeIWUG0I0CoI4zaJCLjUuI4TdwRhmUJkHXX94+3g8OQ/ChfL+/g28eAMk9AZ59AVpRAAo7yNkMmPEGyZKwFS5h4NUC4EEgYBoF5Q3QShEu4PJv0LJ4UFoBhQtoNho0CAIa4AHph1xF950BNBiCuU8eGl//EZ1zkBqQXtDecxD7/bNT4PMHQOENXjHx7xcDaGUOKA3DB0qgcQYql0DhDprNBw1KgAc/wKt0EHkBFp+gOAMdogdOZ4zM4MFA0CAPyE7QgB9oYAAUb6AOP8gPUmq+4G0yMH+hLrXHLMIZGRAQHI7A7RGg6w5BnX5QnIG2HoHORwAdJAnaRgPqRENujUA2Cz18IHIYs8H/YQeVkliV4On8kzKQ8O8/8GpJ6KAlrMxiYMCensAuHLSdvdHO/4A0RkY7/6RmXIZRMBoCoyEwGgLDMQRGBwAGIlbJmHGhyUAAI+mDAIh9+AzQZeuM4LvcQR0RUEMfvLwXuIcedGUbB48kuIMKmj0DLVkFdVxAHSJQR1ZI2oQBtKcadPI7aLk9aBYa1OFhgDZQ2IEnxYNm90GdX9Cp7qCOG2ilAGi7AMgsUOcBNFsIatBfP9QMniEHLY8FdbRBs4agvbSgTgyocQw6GBB0DgDohHkG6NJg8KnjQDZodhZyT/tDBpBaQQlD8CFooNlkkHtAnS7QFgdQpw+0CgHUMQd1RhFBBzwUEdjhYADf0f4fvLQb1GmAnTwPOtEddHXh81ubGQQk9BlA18nBDg8DrdIHbU2AXXEmJG0O3hYAMhs0Y/oCeJAcRP0fcIcQtAT9K/CKQtC1byA2pIMEa0jDZq8ZwYMboGX8Jn5zICsQgFsuQFcTggYyQJ1oUAf1y9ub4BUZoJlpcBYAaQP5A8gBhStolhs00AHqPIHu5wftR+cRVGSAHfaIkW3IbVgiDQLABi9AcSMiawXeiw9b/g/aCw86ywAUlqCzHEBhAzr8EbSKATQgogYcLHkCXC4PujkBtHweNGP85uFB8KGToHQHWhlwZW81eGsKaHk8ePsAyBPI7kZyC+gaPNA2hPcvzgM7+e8YQB130LL5W8d6GECdStCyeFDaAc1ug1aEgLaHgDrO/KLaDGJKzgygbQmgwa4PL86BbyoApWWQu1A7a8idIMhAkKSqN/j6SB3HZoaXd3YwgK7FA3X2lYzTgR1nPQbQgBpomwro0D/QoALIHtAZBKBBE9DgEngLDK5OKtSv8E4tSB1IDDqIBRo4YICHCWoHDZ7vGSGdbdBAG2grDSidgLYggPLxZ2CawtxW8R+88uHZjQ3gAyxB4Qa53o8HeA4FJwPoQErQdXig8AUNNIBuuwBtdYF1/kEDPaCrOUEHfCLKQDydR2gccvFJM0DO5vjBAJr5Bx3OCCor3j46ygAaCMRa7KOlYZTOP9LACSSIkN1AfmeWmM4/dnfAfPCfYeiBwevm/wxDMTyJSAGjHX8ysskwTQsMo2A0BEZDYDQEGBhGBwAGKhUwkrcageoDAQTdgepO5GXmoE4AqLMmpeYD3g8NWsYLkgctewYNBICWkYM6naCONKTjeY0BtAweNPsKauSDZpjBHU3gSfywzv9/6Mn7oM4naPYZ1NERlbcH37kuLG3GADpnQFjWArwaANQ5BHUaQMvZQcuHQbPz3IIKDKAl7CD9kNPZGcCHdoHcIixjyQCbsQRdLQaZqf0K7dQC9+ED7QbNTP789orB2GcGA2jWHLTaADTDCZ6hZOdjgKx6gCz/B/kVhEEdTNBsI2iLAqiDjpiZYwBvHQDNFoM6/eDZ8/+wZdmQq9xAy4tBgwcg80F7i0HL3kEDHaBOPqhDB/IHaGYUFFag8AYNDIAGVEB+g98egN6JBqZpHiFV8L5u0FJ40CF6oAEVUBh9fncb7CaYmaCOFyhNgVYLgAZNwOYDD3MEX0HIKcRgF7OD4Slwxh3kL1D8wgZVULINpY1LRsTgBehGiBd3toFvWQAdYAgauAANAsloBjGA7sa/vKcC3JEEhRHoMDTQbQqgjvrjKysYQNtOQLP1oDQCGiACLZsHnZwOWr4O6oCCBqRAHWaQ30HnPDDgcjfQOaD96aAr8UCdWtAefvCp+cAZbil1X3CHHnSyP+iGAFA4gM6ZAMcPMG6/f3kO3lcPsl9a3Q+88gWUjkEH+b0AdugRy7yxFDxA94DsBZ0mf//cbPC1mqAZeB5hNXAnWlTBHjwAAFoZAxoIA4UBaAsOj5ASeIACfPgjgQ4MovMPatzCGrhQGjx2BFmFwAA9QwLW8QcPmIGczAiRhwygMQJX0CiBr/gEhTlolQxiSwXUzP8Qe8DL/qEDDoqGSeABLdCtDLwimgygWw1A8Qy6nvDn1xfgQTRBaVPwXfeggQ3QIAuofICsTmEFr65hQBvMgJeL0LQEKXd+gsMFNBgGGiQBDSCB0wb0KkjIihdWBpRbOKDRghpOtKkksHb+0awipvP/nxqdO0bGodkeGu3YEo630TAiI22Pdv4ZRsFoCIyGwLAOgRE2AABuwQ6eCKWg0UXfgQBE4xA+AACaSYee8g1ekgxsuIOu81I0TAbPYoOWWx9d5sMAmr0DzQ7+/PYWPEgAvlILeCc9qOPJBFwOLCRjzgC5S52BgQE2IwmKIWijhQd4UNm9s7PAel/e280A6uyDOnuwjgZoRlrFLJcBtLQf1Fng4pcHdx5BnXcG6J550Aw7qNMMXr4PXJoNOXjwEvgkfBmtUPDS/H/gk+Ih2w8UjZIZQLO1oG0AQjIWDKCOG2iFA2jmF3RlnTBwdhp2uB7k0L4f4D3+oD3TjNAVBpCZWGgn6z9yZwiW/P5DVgsAt1Bo2lQygGYmQXuvQXuqQTcDgGaCQecagNwAOkAQNIsJ2koB2soAWqIPmiGFdQ7AsQNOS4wMsA4baKUC6IwB0IoG0L5wyN3p/xlAWxpAgxGgmVjYNgKQHvDVfMB97KD4sQTto4fOnoOW29tEbQYvBQevoGD4h5p/8M2aYslpONMtNC+AZvFB6Ql0Uj3Iz6CDIkFuA82kg049B3XqQVsoQOGr69QKvK9+OQNoAAV0zR9oiTdo68d/aDoCDRyA4xV43gRoBQfoJgHw4YrAjjyumT5k94HCDxS2kIMhX4FXE4BvEmDhgFzvxyMO7mCCwhM0yAJaKQJffg/cfgJKm+AbAoDuwej8Y2uUAy0DDXqABsf4xfUYQGc/gPwFuyUBtKIANIgEOsMB5A/QgMDHFxfAg1qgARvY2QK4BzZAvsHVsIV27IGrQBwSDgDjezF4YT0zGzcD6CA/UHhB0jYzA+i+elA6BJkGO18BNLiE2NYCStto9oAGFxgYwXvz3wK3nIA69KDzJ0Az/qC0Dho0fA88PBS0sgUUz9+A5z2A7GPh4GOQ14thAHXeQSsFQCt5QPkfdJ0mcvJCHQBgZIBkB0YG0KGJoDMRQINEoPQO2l4DylMgBaDBIh5BJXBeh5UV4KKHkllgpDKd0jIa/2w0+R0UqtcdJNWog7djNSxn/0c7/6Odf4ZRMBoCoyEwGgKYITA6ADDQqYLCmReqNuZwugVzAAB0MBuo0wHqPIJmr2F33YM62qAGN2hpO6ixDZr9BHXoQHv2QR0U0Iw36Eow8HV5QPtAHTRQZwB0DgDoVHPUq9n+M4Dvegfu7QfZ9w/YeQd1EkCdf9hABAtwVh40Yww6KBA0a/nx5QUG+Cn/0MYPyD5QRxK0FQA0mw/qZIA6TyC36ji3Mtw7Mx18Dze44wTUA+oYgGZeQZ0s0JkGoAEEUIcE1PEBDTSATuSHdbRN/eeAO4GgZekgNyibZYO3NjDg3SsM6SD9B+/dBd5zDlzqDwqnP+BD6YC+YGYBz3KDln7zi+tAbigAdmLfPDoCHlwBhTc82TIygjtqkNUYzODOMIQNSRmgjqSWfR3D0+vrGEDhA+rMXzvQAO7Mwjo9oLAFHbgImhWXUvdnAG2pAA3mgMRBAwDgeAPudQetDgC5CW43iZ1/5KyGkW6hAxggt4MGjEDLykF79UEDMeD92sDwBC3rBy21B83YglZ/gLZVgNKZse9Mhiv7qoEn7csziIOX359mQDTm/4NneP8CV5mAB43Q4wVLmkd0JiEuBqV+0HYKUEcUlEZBqxE+vLrEAIpz8DkTwEEfNg5B8DVuoLv3QekZHLf/IKtKQKagzPxjaZTDVr7AVsKADh4E6QOFAcjfoO0FIDtA++hBe+9Bs+h3Tk5kAHWEeYVUwMvcZTSDGUBnBSDv/4etUoHQTOAbEiD73/+jnB8BkgetOuEV1QQOqqwED6KBth0Yek5iAN0e8ejycvDWEtAgB2ggDBTuoMEKyHkEzxlAs+yg5fyglSKg9ILemQKZD7rCEbRyApTnQYcbgtyhalnAAFoJAIob0DJ90KocUBiAtp6A8jFoOwpoIAC03YEbOLgHOnMBlC/hgxzoHW74QBgT2L2gARPQbQyggRnQKiCQeY+AtzCAbuIAbbkBuQc0UIM8AIArfTMQOzBAxUEA7G6hUSeagrqIuFUIVHb3aOeWAS8YDR8G0sHgHaBiGAWjITAaAqMhQMUQGIEDAKDQG2TLHamw/JJqAwE43QIJM1jHF9QR8Mi5AZ7hf3JtDQOkQf+XAXT4Fmj/P2SW7ycDaIkyaLkyqDPJL67L8PzmJgbQLP1X4CntoEPewJ0oYAcK3HGCHnCFvjQW5CTIQWQMiHMHQILg2XbIrCZoCT5oaTRolu8/2iFZoGXvoGsHbx7rYpBQ9QIvowZd6QXaB3739DSGf9AlwaCUAdILHpwANp7+//0N7oiDl9sDzQTN8IPUgrvc0Jl+UAcbJA45ePA88LBCTQbQbDBo9hm5w8AIX1LNBMm+/2GzpKAGx38GUOdO1SIfuO99O/B09WkMt0/0M4CW5YNO7XfNuAjmo3ZSIKsVwKkZNAgA3OevADylHrQsHdQZg5ykzgheag3q/MPiDRRXkAPtVBhAHW3QoWugTjf4qjfQrPWry2A/gPigGVfTgAUMoDMXQJ06UDz+xzKwQcnMGUq6BfoDtKwdlH5ggwCggSNwpxg6WAKzHxL9zOCOKij8wSfGv7nOAD4AEHSzArzxC1lpQbDzhq3TxohI86DOKSitglYSgA4WBIUPaDUKaKAClO5AS85BnUzQFhPwXvr/kHgFpyk8DXGMsIPrgzREQXaAOsqglQew6xtBYfQSOGj0D5g+QXvkQTcBgFeiAM/eAKlDHwAAJzhgegV13EEddhE5G/C2F0iYIBq8oDM8QDPiIPNBW2FAq0FAg26geIddYwi6pQJ0LgVowA+0ZQXUmQcNpoEGsEDpBDQ4gZJOkfwO2iIAWtkBut7w3rlZ4Hzy7MZ6BpA46BwQUFoEnfEgJGkMvHlgAwPo2kbQwAfIT3zArQKgFUCgLRKIuISW47B4AucxyPV/oK1GoMEaULiAt9kAD1MErRABrdYADRqycQqAV4/ArtCDZkqiq1ZGlHISS32Cnp5QlNCy/mEcbSCN9BAY7fiTmQJGO/+jhcdoCIyGwMgJAUjvacTF+CBsJDFSx01UGQjA6hbUAQDw9WeCypCD7YD3sIM6HaCOEAsbL1gM1CEHdaRBS4jBHSKgmaDZS9ABgKDZPNAAggDwwD0uAXnwsnTQYW6g2TnQwAFmZ40RvrQdNtMNmqWHLGeH7scHnfzNyAy5pgzS62JgYEDMcoKuLATZBTqM7cPLSwywAQPwbC10yTi8MwbdOoCYtQXZzwQ+7BC0Rx80mAGaKQd1RkBLn0GrF0BbAkCdUJDVoA4pqKOBut+bkQF0sB3oCi95/TiGm0e7GOD7ouEzi4zgbQHg/ffcYgzwU9AxOhOguECECeiqO9DSd9h1iaD74kF+BHUcYXu1Ycu3wUugPz9jAM2Kwjp5/6FXEUKC7R8DeKXE11cMoC0Tqub54FsYQHehg24puLq/HrFaAlpuUGPpLGLWHZYPkPMDtoYZxP+g8x7MAhcxgG47+PLuLnjfPGyGG3+xhpbf0NI8I3R7C8QMSPwbek1muLCjACwECk9b4PkIoIMFQekBlJ5B5yNArqP8wwDZhoB8DR/UD2iNc0Saw974hGyveckAnvFmhKZDYDqHxRkkfpkYQNtGYDc2MDAiwhA28AOOf2ZW8CGI4kquDPfOzgRfpYg8kw6adQfftAAcTLp/fh545h80gw66+QA0MPARfDYEM3zFCWjfPuhsCdA2nos7ixhAeQI0SPEfeSsPWiSAyg3QwAU4jwMHJUArTUCdfNCtDSBxUBkAWkEEPl8BFFYgP6PFBchImL+gkQGPE9AKApD/QGHADVzeD4qXv+BtP7/B126CtiaBBjRAW5JA+Qs0uAcvA6ADh7jjBDOOCO/jh+VTBkh+RxmcZGDAdwggSr5CSTeo7sCcfUdzJ44OIc58i6GecMeI8AqAwT37T40ybFA0o0Y7/xREw+gAAMMoGA2B0RAYMSEwQlcAgJuQgy+SGak7MEHRYACOQQBQwxu0B52ZlZtB26EePEsNnr37+poB1JAGzdRxCSgwvLy7i0FUwRF8ojmoQwCaIQU1xkHLjEH73EH7mUHqQWcEgK5aAy3NB+21Rpk9RO+UgfiMjOC72UGdXtBsP2gmFhxqjIiGNgNUHXyGE9goAqmFnFr+HHyImKSKBwNofz9oiT9swAERXrCBA0SDANSpBq0eAF29BjqMDLw//etLBlCnH3SwmLJpFgPoZPpf315DOmvInXoGiNtA+kAHnoGWd2tYlzOAlvKD/A3qhEFWLUCuGAPNfIIGUxAJFOoOpM4QuOMH7RiBOm6aNhUMP7+/BV9rCL4XHtgJA91uoALckgA7MwC0Vx60nxvUUQT5nVtAjgHU0YItDwfdUgDqFIE6cZDr996D4xEUbqDZVNDye1DYogwYMFC30YTIASBzYRgpq6KlCVCHko2Dn+EZ8JYFkL9gKwTwdUhwzt4imY05AMAAXp2BXHKAOpug2XTQrDfsgEcl4zQG0H5z0IoVRDhhDyPsnQ5UteBzGuBh/B88QASb4YeHFWi1CvDKPgao42D5gQGa7mA3XzAxsYJX7Dy7tYUBvPIDdCAlvEPKAL7GE3RIImi1AyieQekadMMB6HBI0LYZ0IAQeGUJ0FzwuQfAFT2/gdtWQKsiQNcAgtIh4ppIkGNQ/fIf7E7EtghQumdiYQPfqgBaKQTKh7+Bd/aDtqKA7WFENYMRHvjIeZ0J6m1GBsi+fgkG0NkQoPLlF7BMgt1MwMLKBR7wAPkJxAathgAdlAm+gvDTYwZ4WYG3VsAsnzHTEmRwDrxUiQEyYAMa9AStpvn+5RkDI3ICYmBgwJoWKa4HiKtHKKofGEbBoAuB0c4/BVEy2vkfzdGjITAaAiMrBEYHAAZjfA+WgQAMd0Aa3qAZT9CsN+jAti/AU+VB+8dBwQjqzIKX4AP3q4OWEYOu+QPdW65smgncx34QeK96EXBp70YG2L3ioCX4IDWgxj5oKTEDtgYM3A1Au4HLeBmhjWpQBxV0Ij/ourZXD/YxOMTvY3gMvAaOAdpJBnXCQJ0x0PVxsI4WqFkM6xiCZuI/AO+DB8nBO0zgGUlJBtjheLCOOUgetFcZ3KECrjQALe8HbQ9gZmYH76kG2QnqBIGWE4M626BtAqAZWbCfkDrIoKXOP8EDJT/By5tBM9Wg6w/Rl/YjOq+IRgksGBhBYQCcoQUNpsBm+EGDK6COMOh8BFAHHnQiPWjLAyePBHBW1o/h8bXV4L3ioPACH4oH3PIAugsddoo9Kzs/eNYfNBML6sCBzLUGHvx398wM8NaEv3++MYBmZyGrGv4ywOKJ5FkzvPGLmREJdlAYIbOqIH//B9+u8I+BgchGMCNSuoLbDBWD24uc9pDzAiOke8cOPAQQdI4EMysHfLUG6IA+UPiBOqDIS/GJK2YQ8Y1rAIMRizsgq2KgHU9o+odcS8nAADnfQYEB3MEFhhFoNh+0Fx+UXtWBVyeCBu8YGJDTGWSlC2gLBmiVDCgNgbfpAA9/BKVdZZN0cFoC7ZsH5W3YmQegdAMaJAOpgcQBZucfEgao4qBDBH98esqAPFiHHFbwmX6Yv0CSjNABAOhBpIjBGkYGYeBVmm8fH2WAxMEHcHoADQyB8gTIfezcogygbT8atpXgawJBgzigcxxAhxGCzpVgIGNAixHqHkwash0BdIYDyH7QwINrxgUG0KAjaPATvF0CXJ5BBgIY0cpbYjvojIzYOvxIYoyMpNVypKpnoDOgckd3WMz+j3b+KUiEo51/hlEwGgKjITDiQmAEDwCA4ppx8EY4DRphZM34YHMHsCMBmhEGNWBBS/5Bp8N/g86igTr3oPMAQMvjQct6QftvQZ1O0JJzyAFuvxlAB5hBTun/D2mgww5oQ4sN5I4YaMYbtD+YmY2LAbSFALR8HtS5AR3IBprZBHW2QMvgBSUMGH7/+gzu+IKWF799epIB1sEGdZIhHWhmsE3ghjNShwlkh6ZtFYOqeR54fzBiKTPo9PxPDKDZQtA+Z5B/QHfAg/Z7gzraoAED8OoFoKmgRj7IDn33XgbQAXqwpdugLiMrGw8Dt5AycAAEOAAA3L8N6gSAZtfBKREUzv8xVx5AggTR4QF1YkCHskE6OO/AM4igPeBvHx9nAHVeQPv/QasiQIMNoHAAnZ4O6oyCVhSAblQAd4SAS8FBKxdAHTiQHCicQR06di5hBtAhbqAOywPgEnDwbQE/PkI7//9IzyvkNEoJpHvMNPwf0hvH6zrMfI5v5hX/AAAjLEoYQDPVoHAGHYYH6viDzmwAnXMBGpwCdTpB4UhOhxLbABDcUgYGtO0woBlwRrgYKE+ABqFgaYpbUJEBdNgdKF2Crlh8dmsTAygdgvLmc+BKANChmyD7QMEOWjIPWuoPWXXAAF7dAuoYg1etfHgI3tYAuvIQtOz/w8uLDJDl8z/BTgOVBaBBBWydKQz/IKULdPWoYc/IgDEAAHQoKLxBloIGHkFbFsBlCXS1A2gQDpQ3QAMLapZF4KswQW6W1Q5jAB1iCVoRYOQ1BbxiBLzKBmgeKA55gNuZQKuTQH5gIDEtIZSDRoaYwOUbaBUNI3RLkpxuJANoKwcIgwYOQasqQIeV/kdfJQQc2AMNnELCHzxciWQ0OXUV4UEAnHUCSj6ktJ4c7WAx0BKMdv4pCN3RtMkwCkZDYDQERmQIjA4ADOZop9FMDHUGAiCH0IE645A9vaCAhFSmoM4FJFhBfEbwcmM+US0GJuDp9qAG+tsnx8CdcngDGL0Bg+ZvUPMTdCe7XdxuhlvHesAHDbICT/8XA96L/vTGBgZQhxw0Kw9aTgwaGAB19H98fg48EO4AeCYQ1sEBzZqDZgD/A1cogPaOW4evZ3gCnB0HL41nZgN3NkADG6DzCGCDDLAOHKhjADrTAHRXuaJhInhrA6gTDToADTzrDjwlH6QHdCgcaHvCua1Z4A4TZJU+yAeMDKDZU9BsO+hec9C1Z6A91KAOCWjgQULFk+Hzu1uIGWxYmEDDAtTxB2GQW0Gdnue3t4DDEKRXDnhN2ptHh4DXpUWDDzgEdYBgs8/GPjPAAxGg8AJ18EFhA7rLHnSwGqhzB+nwMDKADvkDxRFoRhfUGQJ1UsArIFAO/SOysUStBikR6R8jLePVg9qRwVgFABsMAiVeuDkQPdjVQlK5unUJA+iAOtD1ch9fXwUPUIEPlsQ2m4zkPkYGCCStCEJ0ikFbNrj45RhAS93BqwCAq1NAV2KClrmD0inI5aAl+qAVIqB0eXlPOfjsC9ByftC5HD+AV3f+h8fvfwaQOtBVlKBbM0DL+UGDd6Dl/7BDA4WkjBlAq20+vLjIwAA7lBF4cCRojz0D2nYCmJ8wVjJg6/wjpxdGBvgZA+BoAJ/tAZlJZ2CE5CNQmueX0ANvWQDdjAHZDgMpa0CDb6DOvoCkEXDLxjbwTQ2g/AAaqAQd/AnawvP05kYG0EGToBUwILeD8i9o4OsH8NwLlAEbnGkJvUMMcRfIfaA8CrnFQBTsPlD+B62OAA0Ggc43AA3WvbizkwG2UgKsE2gPqGwEDd6BtlLADuf8D1x1gb3rjSnKSIxbQWqwqCMvHQ5QxTna2UUE/GhYUJgIRzv/DKNgNARGQ2DEhsAIHwAANzEHd+TTaBAA4nMSZ3ZQ3IKsF1SR/kfbzwqpXEGqQJ0M0AF1oFlCPhENBtC2AfjyaHyNGKh9oAYq+J76X18YQA1+0LV8Zv7zGR5eXgK+yx/cMQZ1SIBL20GDAaCOrbCsBfgQu7/AKwRhy8JBe+IhnQUG8NkFT6+tZQCdRwBaQQC74u0fcC816IR1Nk5hBlADHHkZN8g5oKX9oIP/wNcSAu2T140Gb2kAHV4ImrkDdSpg2xog/RVG8D3qIHtBS9VBbgUNgoAO4AMdHKgAHEwAzbSD7ukHmQkaPIEcYoeULIEGgTpkIDeCTvB/BrxJATSrCJqx/fz2BgPonn/ICoiz0IPd/kG6lsAl0k+Bp6yD7AYNjoBmRdWtShhAS/tBZwGA3CCl5gs+hR0iPo0B1EEChRnInq8fH5KWN2jVICUiDxA3EICa3lE69YygjjXk6jjI8nlopw4aAvCZaHDGgZgDthPIBA0YQUT+gw96g2j5z4CRu2D+ANFQDIpz7HkR2jhF6RxD3AQayALN3INm4kErbkAn8oM6/aBBHtAMMmjwBpQ2fn5/A04HoKvuXt/fDz77wixgIfhGCfB+fvA1hdCVHf8hq3FA51KA0jLosEzQVgHQagbQbL+ySSZ4oA200gU0cw46zwJ8dSTozAsG3KtDcHVMcQ7+QYtkRmh8gFZVsLDzgG97AHXOQQNYoEP+QFuQIKssfjGIytsyQK4QBa0GYQKXCaA8CB7cgl7FCPIPKKxBBwD++/OTAbQ6CLRSBrzl5T/o0EZIGUZ8uQhLH4wMDFC3isrbM4BW2AiI6zGAwgbU6QeVDyB3glbbgAYMQbdagOIHtNLi1493kAM1QfqBAx2gsgW0SgE0kAjajgMejGBEStk4y19IioOEGSOWPIualhmQ0h8DkpkYAwGMjAzDHQzZ5f+jnX8Kk+Zo559hFIyGwGgIjOgQGB0AYBgCjRwaN8RIWhFAoBEKbkCjuRfUIReSMmH4CJw5fPf8DHhWnti92rAGKqhxC1rqCzohH3LK/UUG0KoAUAcB1FgGNbJBHSDwXls2bgZQpwV8NSH0RH+QftAeeNDsP+jqNNCd6aAOMWj2T0zBgQG0ZQE0yAAyAzTjCZpJVDJKYQDNrCNKCEgnQRp4Vz7ourk/vz6B7+V/cmMdZFk/8DR9yMFviMEQUGcApF9Y1gq8Txw0qwrqkIPCBNTA//DsLANo7zHIDbAzATAbpf/BHSDQgAGoUwHqKIBmOW+fnMQAWf/+H77NAdZxArkdfIL8lxcMoCXcoGXQoHADDVCA3AgyAyQPumceNHDx8t4ucE4AzUyCtjaAD0f7CDscjYgykh4NUiLyAeGBAER+Rx4AAHUOQbdSgDqFoJUSoPQE61DBD1yEJG5wYMDtYUR0rnAOEsCCjxF9AIKJAXQfvZiSMwPsCkuEFf8ZsOURULoEdfhBaRd8Hz5wmAo8eAQc7AGlsTsnJzKAOpugK+9A8QvZ//4BPDgHGtwCrR65dbwfmgcRnX9EmoMMXIDyAegwwO9fnjOA/A9yH2gFDOgmD9AWA9C2H5C7QWdtgFbTYAxaMZCaZv4zwPdyAMMJdPYAaCAKtCwfdCsAqNMOWj4PshMUzqCVFqA0Dbql4sGF+QyQfAdZHQHbVgMqO8D+AuZLUKcbNNgH8gu44w+8hpSdU4hBQNIQPCDJgGvvP6E0B5UHDaCBDj4FuQO0Qgh8TeO/3wygwRRQ+cTGJQQ+cBO0FQo0qAIKL/AqAGCuk9ePBW5VuA7cJiAJHMi4z8AnqgleuQCPf0biBwFg5S8i7ULCBHVwAK3Ogw8IQAbAICkaqgbuf3LrydGOFtVbmKOdfwqDdDRNMoyC0RAYDYERHwKjAwDQ5vygTwl0mI0heiAAwy3YG4ewDhZomS2oMwFqhP//BzsFHFcljKVxygA9Uxt4AJ6R11QGUKcEtJTe0HMiA6ihbewzkwHUkQV1hEAdHtAMGrizj2QXaD+usLQZg65LOwNo+fu7Z6fBV8aBOtSgvcygjjloKT1ofz2PsArDizs7GEB38IPTxX9QNwI6Qwg08/2L8+AON2h5M6izARpUgGyDgHaoGGGNbibwzQgispbgTpSooiN4RhbU4Qd1FMAzg3wy4NsAPgPvsAe5gwHbFWrQDgCo4wVani2jHcoA6lSATmxn5xGD3uf/DmwHaFAE4q6nDKBBDlC4gGZNQQMwoO0KIL+LyFqDBwVAAwo6Ts0MoE4lKI5Ah9nBDhQEuQeydYKRQVY7HDjQcYUBuZOEMkhBVoMUW/wT0ckgIh8QOwgAHwAAHSYHNBd0RRzodHzwXnbQ1YjgeGRiAKUH0D5xWBmBYj4j+gAAAyS1Qt2JqRbJFKAa8Gw0MA2AOqYge/nFdRhAVy6CzhdgAIc4WjgBw/rnt1cMoOXioI4+KG4hWzX+MoA6lvpuPQzvnp0BH/4HWt0B6gT/At8OocQA2jt/82g3pLMMNAfE5wLaDZ5tRonD/wzgszuAHVjQQANkRYEiA2jlCSh9SmsFM4D214O23ZgCVxSA0hFoOwFqJxoRlyidT4woxkwHoK0xoC0LoLwF2pIA8hcXnzQDaMYc5F6QfaCwkVD1ZLhzajIDaFCCG7iHX8k4lQE0MIEcr4LADj5opQsDMD5BV4GCtgJwA7dNgAYuQOcjvH10lAE2aIezDsCV5pDEQW4AbbsArcQBDTyCVtCAViqBV1oABxdAZzCABidBZZMh8AyCJ9fWgMsGXlEN6FkKv8GDfILSpuAVPcIyFgwg/4PSBTgfMjFDnfefgQHFPbD0h0YD07SJ3xyGZ+BzHkBJkokBtCoElI6RYgZWsoLLDtDWA9CtIeCrWBkZBt/Q+GjHl4FhNAwYRsFoCIyGwGgIjIYA5SEwOgAADkPGoZGWGGnvTvIHAWBBiM2NiOW1xAc0kjngDjAj+BAvUIcffJgWsHPy6fUVcIMI1JEGLeeX1YkEzrJdYtBz6WAAdZZhnViInf/A+27fAE8IBy2dZmXjBXfiQXumQepAV+iB7u8HLacHXSknqeoNPq2bAd75Z4A2vhB+gdzjj3StGQO0bc4I2e//CXhvOg/wEDZQpxvU6QetgFC1yAd2xNgYfgCvEAQ17kEzgqAZeFDnAGwejplI0Aw1aGUCqKMBMhd0ejtIj4JBIgNomT+oUyABvNoQNKABGpAAzZ6C1IJm88EzuMDtE6COEGhPN2gLA6izJq8bxfDg4kJwh+MP8Do3yNLy/wzgDhMo0IBRAAqn18BbFphYOLA3PolukJI660IgrePJC1jTMFqnCd5JBHVzGCHbNEBbM0DhAup0gmZnQdskQEu5QVfGgVaK8AqpMoA6d+CeEcg8uJmQAR8G5LIEKod9AADiN1C8qFkWMnwCD/48ZADNuoPODgAfoAkagIBlFlgYw+wD8kHxaBm6Cnx2Ayh9gfSBro8Ed95A6RDYYYTMhP8HqwHlEUHgKhzQmROgFQ6grTgKhgngfPLh1SWoTchx9B8e3wr6cWAvg5bPgzq4oO0nz29vZwClQ9DA3m/gShgR4AoX0AoB1PyN6JSCthCAZrpBV1SCOrSgPfjIHW/kswJA22A+v70NHtiCHNzJwgA6uwM0QAJKmyB/WoWvBXb+p4D32YPiSBS4ige0xB6ywuUfeACElYOPAbTSBTygAywvQJ1f0P58UPkBuooTtJ0BkoeJSJvo6Q2NzwjNL6D4NguYz3Dv3GzwQAyo/ABdN8grogY+CwW0+uAJcOsRaDUDKB4MvSYzPLm6EnzbBiivggZrbKO3AbdpTGAADUZ+enUFHEeQQwp5GUCDFuCrQ1HSH1qpCpQDDf6ABpOe39rKANr+A9qKANv+AErjjIyoAzSwWyNA9sOuIAWdL/EHeAgoYiSA9vUPAx3BkFv+P9r5p0Lq+M8wCkZDYDQERkNgNAQYGEYHAOCpYIg0bhjp406iBgIIugW3WxmJ9gfEDCFpEwZQBxV0EwBoKTvoQC/Qkm1Qh0JA0oABtLf2zcNDDKBO8utHhxm4+eUZQLcCMCAdYgfqvIBWDoCW2Ioru4Fn2F7c3gretw2a+QZ1ksCd8Z+fIHoZYDP/yEUFpAEB6bBAGxPwDhrkhHbYknFuQQXgzPl18N5r0F5t0DkIoCvAQJ1p0PJj0HkFoKXaoEY3aGsD+NR4lEP3kOwFioMOKgN11EEHiYG2Q4BmNEGDFaCZRlE5WwbQtgSQH8AzsUD1oOXeID2g2WLQjOo/4F5nMQVH8J5p0NVuoJnir+/uMIBWR4Bm/p7d2MgA6qCA79YHLlnmAF6ZBprVZGXnBW9xQLiGlEYUpQ0uPOkdTxrCPwgA67Azgmc+QWpBcQY+zA7oSSl1P/DgD2jWFtRZhAzUCDGA7qr/D7tvH63cQFn+D5LDOQAA6/xDOsegdAw6kA+UpkErNECdbdDVgr+/v2P4/x/7tYagAQnQTDf4ujvgQAHoxHnQgA/IH8qm2eBOL+SGDm6wK0GdXNBMM+gWDog/vzH8AV7tCOocg26BAKUB2G0AMG8h50/QjDvoNgmYHCivgQYfQKtkQLdHgNIv+L595GyCPH8MDAuQftBSfjXLYvB2G5B7QPvvGcCHCYLSCCydQOMbSIFWzoAGuEDnG4BW94Bm78HXWALD5dHlZZBzAYBmgwb7QCsSQKsBGKCHE4LOCAB19kFhCBo8A+Vv2KobUJ7ATMuMaK7Hku5gnW4s6Q45vT26tJQBsmIE5CdGBh4hJYZ7Z2cymAUtBq4q2gq2B9TZB+VbUFiCBjdAA5ugVQOgfPrgwgLgdgBxBtCACshvoHIPdIYBaNAQvOUC2aXIboKyQW4BDSL9Ax92ysIAGvgBbwUBlmuwGx4gSRSSD0B2gMoF0EoQkJtAW0xAnX/QNZCgsEc+B4VhoMBI7/yOdv6pkPJGO/8Mo2A0BEZDYDQEoCEwOgCAq9E6mJPIYBoEAIUTUe4hPHCBe1CAEbzsH3SyP+gQQFAnGrT8FzSL+O7ZKQZQoxl0I8BzYGceNBMK6hiBriUE7xuGzqiDbAedfv7j81MGUCMX1CHngN7jDurAgBq7oM4vSBx+MjpyowuJ/R+HOCQomBlAHbQ/v78wCIjrAzvO3xlAjX3Q1YdvHh8DpyrQTC/oHAHQzC2oAwZaBQCaVf3y9iYD5G5w0OQramMFEjYQMdDd5SA3wpalg8wCda7A97UDtyiAOnmgZdSgFQ2gTg8bhyADyO+gww4FpYzA2xtAakAdTdCgw5+fH8EDKM4pJxjun58DHhARlrEEL00G7cEGXR8HWnEAmlGU1ghggFw5yMCAfzkqtRtbONIPjrRHeACAiUFIxhzcUQN1vkGdLFAaAK2iAO3l5gIOIIGvVPzxAXilpD8DqOMEih/U5A7pQMEGfOBFBiMjAwwii4HPt2dEDD4wMEIGINStyxhAHWmQHtCg1fePj8CHUzIwoM3IQw0DpVdQ/H8H3nTx+fU18FJy0GAQaBYXtMIEtCf+1f09DKCT8EF5BLTFA7JXn4kBNDMMmglWNEpmAG0leXF7G3gLCmJrDtrMMLQjzwjraDJAlobfOzuLATRIgZ4GUFZWQAML5C/QgYKgwS7w6ho1b/DAy6eXlxkgfsRMK1LAFTigmxV+A2/XAOXl38AD80AHVIIOEAUNlikYxIGv+ANdx/kbmn5B8QVyJsgvoDAC5X/IwYjSDIiOLMwuBM1IhfIUnt4Q4xdgv4HEQfELWl0CWj0ComEDE6CDCCG3jfwBXw8KPuvg708G0OoO0CAhaCWEskkGeJXD+6enwSs5IOH9n4ERxwJ9RuiKFlCaBA0SwgYXQAOnZoELGUCDC6BB0L/AFUGwlSygrSBmgYvAXNAWBFAZBD7v4ekpxPYIeBgxMowCOofAaOefCgE+2vkfzbejITAaAqMhgBwCowMAKOlhCDVuGOnnVkZidoOS5B4yBwPA2iCHlIGWxoL2t0Ou4XsKXDI7EXywGfhedmZ28OnaKDNXQL2wWVXQDCCoQwCa0QUt7QbNgAkDO4OgBjpozzMDtmX4ePyHfKI56OYA0EwaP/Ak8P/QfcegZdmgwYbPb66Bl/OCl/p+ewPevwxig5Yjg/bzg2fnQNep4WjwwWeZGWH7cyEdSNCBf4+uLGdwTDoMPuEf5G/QWQCgQw1BS71Bs5+g/dOgZdKg6/5A5xWABlFA7gQNeICyAGiWH3RIGmiGFXQWAWj2G3TQIAsLJwNodhc06CAF7PzfBF7DiP/AN1o2tHCkG2IHAZA6MaCwBHUkQR1/0GypCHAFBRe/DHiWH7TPXNe5leHhxUXgDhC4IwW8FQK09Bpx2BwDZPUA8K53ETlrcCca3OlnYmLA6FCC7WUEL0sH2QlSB967zwAxA7RPHNRRA8UTKC4/vLwE3oOPSIeQMEUeeAIbCUon0EEEGc1A8MDW3dNTgVf9CTA4AQdzQJ1+0EwuF58seLYcfPvE5yfglS+gGWFQXIJPwQfeZsGApRxEpDdIuKMuGwc7ngG148vIgGsAADS4JqcXDRx0MWMADSqB3AYasIKkJWiaQUr3oDQHGeR4xgAaBACxQfEE2p4BGjgBnZEAmtkHhSNo8AyUlkF80FV7P8E3EzAwgFavgGa2bxxuBZ+rAHIbaCAOtBoBdA0neCk91E64u8ksVlHKSNggADS9vQSeJwI6kwSUn0Arlhig8Q7eTgJkg/IeL/B2FFBYgA5yBHXWQf74CBwgef3wMAMojkDxCDoLAZwm4IMMjAzoEBQ2oIFHA48J4BtTQAMgoDMHXtzdAd4yAUpjoPCEbQMAbXMBhS0oPkDXs4LKw1/A8Pvx5SUDl4A8w0/gIaKYTaahPwgwZJb/j3b+GSgHo51/hlEwGgKjITAaAmghMDoAgJEkRgcBsOUS6g8CgGyhZCAA4krQbDtoTzvk4Lb/4GXT/zGW0cNbzOChDNDeeX4xHXDHFjRzCpqhA20fAJ/GDzyoDzRzDgsD1IY9oiMEadsjNSzQGmqgBjWoAwI6ZAzU2AZ1xkHLlEFLfRX0YhmeAe/xB83Sg2ZswaeHA/coQ2ZhQTajN1gQ4QTpSzKCO5+g2VxQp+HJ9XUMoFPTbxzpYAB1EkFL90EdDjngHn/QHm0ReTsGkHtA2yFAy/6/fXwAPkQO1NEHdcxAe35BnabXDw6Cl2eDwgbUEQDNvIJmbkEzhCB9z29tBg+yQE5Wx9aookdDC0uaIWsAgAG83QF0kjyo8wUaKGHnFmcALYV/dGkJ+FwE0IGToNUOoEElUHiAOv/g9AB0AisHP3ilBCunALjjzckjCb42UhR8o8Q9BkhHjRF2KAQDZMABuDoEeFgdSC9ku8d/sDxopheU9kCDA6DD4cAd2P/QmyT+Y3b+4WkT3PlnZlA1z2N4CHQzKI7t4nYzPLm2GnxIJOiqPtCNF68e7GcAbTMA7cF//fAg+MYByP733wwM/9Gu8EMbJGGAzSgzoPoFfkQceDAKXQ6atxkh3VMG6CGLoJU3oKssb53oZwBtKwANRsG36MD8iTT4BoppSF6GxDkoPYPPAPj7G3wlIegGEFC+B3WQpTUCGUBbIUC3boAOuQTlN9Bqnw/Am0dgN26A4gA0WAMaAAQtywetGACfxA8dRIGs5GDADWB5HEt6wywnYIMhjPCgegPcmgQOGWB48AqpMIBWnIAGYkBbM0ADhMLAwzk/vboMHvAAuRHkXtAgCWhgEHJd4T+0ARc0p0IKBwZxFTeGZzc2gFcegdKVnE44eAAEtFoEFC6grVOgcAQNMoA6+aD0DUqToAEiULkB2hoCshe0YgMUP0SV/Qw0BCO1Ezza+adCohrt/DOMgtEQGA2B0RDAEgKjAwAYgcI4tBIKI/3cOzgGAWCdeXD3gAG0fxl0SjkDrsPzoI1icKRCOySgWXfwHeH/IQekgRrYoBkv0Cn4//58B3eWkDtGyLNs2g714Hv/QdsRQB1HhN1IHbX/kIEI0EADyF5hOSsG0P5ecSUXhvvAw8FAPQLQCgTQLCb4pgH4rD++xgoj1AuQzj9ottM6YgNwxn86eFUBaIYf5E5Qx9Ip6QgDaI80aEABfEsBcO8/SD2oEwG6uhDEBs3oy2gGMYAORPz26RF4iTuogwaaSQUvUwbelQ4aXOAT02YADYh8eXcLvNQc+7J/ejeysKR5Qp0yUOhhdG4ZGEBbSUCHJoK2SIgruzJc2lXMIAo8JwGUnkCztSpmOQygDtp/2KF8jLCZfyYG0Mw6aPsJaPAANGsPWtoN6mijriKBdARB5yyAVhsom2WDl3T/Am4tAHXcQQc1guRAM7egU9pBHTApNR9wfNhGb4dsycB6LgTk4EJ2bhFweoXc4PCRAdQBBg/efHgAPEQuiOHwEncG0BYT0EAHaL85aCaZT0QdPKuMcsAlAwNS55IRwgMeJAhesQDKN0ws4BUM4MPkXl1hQM5PDNA8hjL7DxTTcWphAA2Agc7cAKUr0MATaIADtCUFki7/MghKGDKAtjIwYD1vgwE+cALqIINWrYA66aBwBi2TB60IAIUpaM86aFYfkq5vggf2QG4BDaSAZ9aB6R882AB0E+jsBFBnF+YGUIcY5BdZ3QjgQEou5NR8UMcLnMRwD/AxoKQnBgbsAwCwa/VAiYYJPGgHCivQrDtoK5OScTq4/AId7Adyryzwdg9QZxx0kCEoD4IG3kADAaBBONBqBR5BJbDfwId1wtzICB18YYSVD0zgwxlBA4ugMz0EJPQZQKuDQOeDSADPPXkPvHb0+6fH4LgE3RLw+MpK8CAQ+HpSoC9A6QM0kAI6aBE8+IKc1VDyGCPDKKBRCIx2/KkUsKOd/9E8OhoCoyEwGgK4QmB0AABryAyxxs2QHwQAt6bx5lJGXI1PRgbUDQpo6hihnROw4YywGUlYYxnS7QDNhoGWEoMa3fAr4JBcA2/cA/W/A+7FBW0ZAHUiQDcFgA5fAy8lhh9mBtIIa3j8Bze0QbN8eq5dDCfXx4JnZkHLm0H7zvXd+xme39zE8B9bBw/rbCMj2DzQbDOoIwRe+QBcrgtyD6gTBOpQPgeuLHhwYSH4RHlQxwG0Zxo04AHqFLJxCTOADgsEdULAp6UDZ1JBe85BjX7QgADoFPVf39+AOwSgWVOQOOhgvHdPTzBw8EqCl6Vjzv4PRCMLR/5EywcYA1ZweUYGWLoAdSJBMQZaRg5aci0oacwAOpcBdNYBL7CjfPf0NPBsMySFMjJIA5fag/SCOvmg5ej8YroMoPgH7TkH3Un/7NYm4CKCv7DkBrcHNLgAWvEBmvn99PYGA+haOtCMMGhbBWgfO0g/aHk2aFYYFFdyOhHg09ufA69xA3V44cnxPyJtgeICtIUDdOAdKN2C7si/fqgVfK4ByBzQtX0cwJUJoKXmoPQBGhwCdQxBAwGgASxsy6BhYQY6NwB84CYzG/j2DBF5WwbQQAVowAK2fByUBtm5xcADYqBtE5AD5iAdUpA5oIEjPddOBtAgAiifgGajIdsRvjEwgFc4MDGA9rqrW5cwvLi7iwFjcAkYX9Ia/uD9+6BD8BigM+egmX/Q9h+QGGg/O+igRlBcgAa8QAMgoIMyQXaCBufA5xQwgAZLWMHuBLkLNOj15cM9Bg4uUfDJ/AqGwJs0QKtoeKXAhz+CbscAdbxBbgaHO74OGVKaY4SvkoAMEoE66g4J+8FbSUBnS4DPbgButwANVIDKjo/A2xdAfgDlMU7gdYygcAVdrahpWw28cnEjgyRwIAiUd0Grk0DlBcgtMsArGEErdxBpApYXQDQjfAvGa+CqD5B60KAjKA2ABkpBg1R8wGsHWYFngoC2+IAGCUFuAcUdaPAPdIAqyA2g8lDFPBd4veJxBlwDqwyjgDYhMNr5p1K4jnb+R7PoaAiMhsBoCOALgdEBAJyhMzoIgC/hYHSusCkmeWACf5hj7C+G2QnVhtxRh0jBOvqITgkDRicQpPI/ygFbcK9A1TIiLX8Gzd6BOjqgO8dBy2Q/vrjAADl5H2IOuMGM3IgDdu5Be+tBs24fnp9ngJ3sDtIDOvjtx9dXDPBGNqHGHyNkplFSzQvcGQc13kF7fEEzrKAOy1NgJwZkrrRmAANoRQMb8CR/UGcSNKsMPskeuGz95b29DJ9fX2cAHQioCryC7uGlReBZRVCHAnk1A6iDC9oCABpkAHX+QdsEfv/6jBbLA9nIwpJWSBwAAA14SKn7M3wFbokAdb5B9+t/eX+PAcQGHS4J2j4BOhMB3OEF+hw0SAQ+YwJ4JeI/6L558MoKYGcSNMMMPtGdS4QBdEsD7EYJcIAB3fXtw0MGUDyArrdTMc1iAHXAQTPfX9/dZQCdPwEaFAK5RxHYGf3+5TkDaKvIg/PzGGD2g83BSB//waNfoI42KB2BltWD0hfIblBnE+Qm0MnxoLgG+QXEBl2DCeoM/kdf+g+yACm9g9ILaL88aHsKqPMJWmIPOgtBUMKAAbR9ADRAAAoP0OoHUCeWkZmVAby6BDwXzsggDDwXATSDDZ7RBu5lBy3HVzbNZAANshh5T2UALcUHba/4Cgw70G0CiBU3qGkKlP5Ad/kLSZmCBxLePzsN3nIBuqkBNOsPOruBEzg4BRrsAh1cBzqoERR/oPAGDdIxMrEyyAFn90EHCoLyPvggUOD+dgklVwYlk3QG0AALyP2ggZTvwANCufhlGUDuVjCIBx6WuZ2BgWCeRKRDRrRtEnK60eBD90DuAfkPdPUfeBsJMJxBq2sMPScxPL6yAnzOBMj9oMFF0GqU98/PMIC2b7wBbtcAXbUICnvQyiTIAOVr8A0BoPyNSO5IboAOeELKQuCAFfDcjtcPD4BvRwEdOgrKxxy8EuCBD9DKA5DZ71+cA68iAqUj0CAh+GwQ4ODg94+PGUADly/v7UEMsqLkMTrUkTToEA/a/f+jnX+GUTAaAqMhMBoCoyFAnxAYHQDAGc6jAwCEkiD1BwGIHQAA91YQzmNEa4TDOzOQGTFQox+21BeyXgAxAwwbEEBeKQAxjpGBAcsAAKhDAFr2/Rl4dzuoAf3uyUkG0HJZyP5hUOcFuhUA7QR3yN37/6D9OMgWAXiHG63h9x9+cwG28PgPPjEedMI5eEk58JRw0LJs0J5f0Gwo6KCwDy8vMkCWXD9kAHVUQR1B8IFqn54wgAYFQB1E0PJo0AyxqLw9A+gQMvgBd/8hVx8iViX8B+9JhhxQiJh9xpU2/hPZiGVkpDR/4dCPLS3A0wMi3YDsBw16gAZIQIMdOk6t4NsRQKsr5IH33oM6p6BT059cXwvpBDJC0gyoE/vy7m5w0gCtkvgOPFQPdI4E6F56UKcOdPXi0+vrwQfd/fr6mgHSJ2RiUNCPZwAt+/8LvH6PEzjTDL5TH3juA2hWHjQgA5pJB+1JB+1fB628AB1S9+rBAQbQgY3QRMOArePyH7x9BLTiAJb2/jOADpsDzTCD93EDB5ggM/P/wf6As1HSJyNKXgKlZdDABug2AlDe4QR2il8BO4H//v4A3wwBDkVgx5pPRJNBVNGBATQzDzrIELQSBTwwAgwrUDoEzcKDzACFC8idoNUmILPFFZ0ZQANWoMEDUAcdcuYGUt75/x8+kw3epgAOpz8MoFsDQGkZNAMO0gM6TwA0Ow4aAACtCgBt1QAt+QetVADZCToTAXy2xf194JUzoI49qLMP2vcOGnABpX/QSgnw6hc2HgbQGR2gjvajy0sZXtyGdf6RByTwpznIAAD0EEjgagVQngcN4IAGdkB5TsO2kgFSXvwFH1IKGrADuRMU76A4B4Uv6PBOULyB8i/ojA9Qpx80qAHyL8hfIP+ABw2hAziwfMQITZ/g+/wZQSseWMBhCLoSFWQWaHAEVsaBBiJAcQgaPAGFGWgACjQgJabkxACSA21dEpG3YQCtGACVdaC4BA2OMY62ymgXAqOdfyqG7ejs/2hWHQ2B0RAYDQFCIQCq00dLS5yhNDoIQDgBERFGJHX28JuHexUARB/qKgBG8L5b0KweqBEOmi1/D5yFB+0nBjWsUWb3YDNncLcyIgYAgI15BgZIoxoUHqDOEWjJLugAPdCyZtDd7aBZTNBJ7qCD9EBqUJfKQwcFUBp50GyHJIZvZgplsAXoHlBnC9Tx5BZSZgAt2QV14MFLlqEdA2nNYPDJ9NzA6+xAs5+gZcCI7Q2MDKBl5++As6ncAooMoJPHQdeDgWcp0c9SwOZmtETxn8LGK/mDAVjSCgkDAOD1FKC4BWLQIAgzKzcD6EA+DmAHHdQRAi1PB6UTkBjCy4wMoFlSVjZe8KoR0JYB0C0PoFPXz2/PY4DcNf8dbA5ilp2RATQbDRqwAc0GgzpVoCXXoP3wIHNBgwagZfqgjhoojYLiEbT6AjT7C7YfdP4AdGAG7g6c8QJJtyBzQJ19xPV+EJ2oNwmghx9EL2jGH9ShBi2tB+3jP7slE3xwIGjUAzTzDJr5Bw1+gAYyQKtbQOkG5HbQGQagNAU+OA54ZgCoUws6ZA90fR/oEElQGuYRVmUA6QXd2Q+aIQetKgDlI9htANjSEvr2H9B2DdDZGaDOO2jQi4ERks9BAzogPuh8DWWTTIbbpyYzgA60BO1/h12NaRu1leHaoRZwuQDa6gHaDgA6JBE04w5aFg8ZpPkOnfnHVTWihRvSQKF9/F6GHVM0GHiBgyMg/4OW8IPKGdAAJGglBogGnccAjg2gPtjBn6ArAEHysMMhYbd1gNIeyF+ggRXwtaag/A0a9GH4j3XLBGhlBKgsAg3sgc4ZAPkJcv4BE3hlA5+oFnjFD8jfIHNB7gP5HXaoJSjNgspH0GAN6FwAUPyCBi8gA1EIOxFp+z9SksQWXhQ2L2jQMR50KwBGO/8M1AOjzVmGUTAaAqMhMBoCRITA6AoAgoHEOLQSEiP93UvPlQC4zwJA+Bu2FBc0YwZq+EP28v4HH6wGuhcdsmf6JQP8Ojt8nX/wFC4TAxuHAAMzGzcDaLYRfF0e8JA80EAAaK84qKENmkkG7bcHJZb/WBrn/yno/MMSIGJwg4EB1KkC7acG7ckGLfcGddYg14pBGkD84roMoGXF4G0BwIMNHRIOAA8gnMsAOvjrEXDZMWh5L6iz+vPbW/CJ7Ay4OhWI5j1GPvhP5YYr6QMBuAcAUAdMYOqQ0gg0ziEz9IwMoE44qOMIGtABzRJDVnncZGAAn+3wl+E/0owr6AA60Ow36MA/0OAJqNP77OZm4KzuL+hBicgn6zOCZ2JBaQ2U7r59uA++aQFy0NpfBtBqA9AqA9BsNegWAtCssYSKO/iOe1DHC9E5Rgp+goMywMsogekTtqyeUDxhC3dQx50NuJ0BtGwcfI3k93cMkNUDoHExZvDWBFAH0sCjnwE0kAE5df8ZYrUEA+gavh8MIDeABjNAaQ10OCVILSivgM4ieHpzIwN4ZQ7IP/9BYYzceEdnw/j/wYfcgc8c+PkJvF0DlA/g7gRerwkaHAN1YEEz2aBwhQ2CgA/bAx9syMwAOhxPHHgo3sOLC8FXJII6yZABkz8MDNi2R6CkftwDAKDVA6CDM0H5EzTgA4pz0KoCkP9BWypAZYWwjCX4KkaQHGgFCUgO3Ln/+wu8gQK0Fx/cUX9zgwFUhoHyMaysguz9x9LJgQ2C/P7OwAO8aQI0IAiyD5SuX9zZDi4vQNs3mFjYwf4DDYiC0j5oEAW0+kRCxZMBtDoFNGAACjfQ4A5sG4uiYTIDaFsC6HYA0BWObMCDJ0HpEhIkQ6t+HO38D+d28Wjnf7TXMxoCoyEwGgLEhsDoAADBkGIceqlpsA4CgEKSaLdhD3fiBwCYGFTMshhAM2Ggg9oUDRIYwHtsgXu3QR0SSWCDF7QHH+IkJvCVWaAZYRPfWQyQPcn/wbOEkNlFZuDJ8HbAU9+lGfhEgafiv7vN4JB4AHiA32YG0GniApIG4CvlQJ2m//9hy7FhyQa9UQLlI3XiSG2UgkIGtF/5y/u74A4nyE7wPmMGpE7S66sMoBO/QR0Hv7LXDLum6TCAZm5BqwDePz0F9i+4YwQ9gBDboAWuA8D+03jGipGSNII0Gwtep8+I2vmHL5UGRw8jeJUHSAVo2wS4Awj0G6hzAz474edH4KF/QeDr5Rig6kHGgZav//75GRz2b58AD0r7Dzv0jxFp2whUB9JAA2iAASIKiicIBi1nB3W2QJ1W0L51UCcMdJYAaIAANMCAck8+RkmESFuYcYJICwhtuMsylJU1YGWQIRQpdV/wwZFvHx9lAB1iCO6oMvwDb3EAdWBBVw5C0h4DeLsDA/TKPwjnPyQ8/kO2vNy/MI8B1MEEDaR9fX8ffA4F6Ko54HAFAwMDeoefAcv++/9gY9WtS4HbYK6Bl+w/v72VAbQ8nYWdD3wbAmimGnxIJzsvwx9oHIE79EA3gLbcgLcQAM9jeP/iPAMonEGHB4L8Bbr7HjLY8w8jlLGnR6SwRE5zQN2wlReg1TfXDjaCz0MQljYHnwcA2SrEAPYvKNxAbgWpB9kBOsMBlO5AB02CyiBQ2H8C3rgASgOgFRmg/fhPrq5kAIUXNIoYYKsfQDdHgM4ZAa0AAA1qgAcZgFt+XtzeBl6pAtra8gk4oABS9+bxMei5JcCVKcCtD6BVAKDzKW4e7WRQNEoBhyP4itBfnxhAA6agNA4aiACtEgBdKwnapvANGH8MtK4ah/vM+OjMPwP1wGjnn2EUjIbAaAiMhgAJITA6AEBUYI0OAhATTIzEtgiJ6uBROgDAyACaBdR1aQfvawXtmwUdGsYPvNYOsk/+EthLTIzMDKBZfNBp2aAZO1CHBtRhgBzyBllaLCRjAT6JHNRhBu0dBs0GP7y0mAG0VBq0ZBe0HQC03xk06waaWQMdtIW984zZSCHY+cfWSAQHDawTiRkzyCsFQB2Lu6enMoD8BprtA59aD9wXDprFBvkFpBuz84+9MfWfjg1WsgcBUAYAgNewgeZUgXEM6fgjhxWs888I76RCZCH7z/9BZ9BBHXGQOGJVCRN4lhbUaQPfof7jPQPkRHtGBlDHFNRx4hFUZOAX1wN3vMDLvRnBmw2ggwOgyGME64Ec2PcVfF4DaNABNNP7CXhAIyieQEvvn9/aDHESclb4j9qxxx4nxDaGEQajDgBAUtCf31/A6eb+uTkM4D3qf34wwM7SAHVKQatIDIEH+j0DzuSDBpdA7gaddSCrHc7w8v4esNtBHV5eETUGyMFyvxhA2yxAW2YeXlzE8PP7WwZY5xwRM1C340lroPMZQMvlQQN54DMcgHEFOmwQlOdAnW5xZRdw+IKuRoRsewF16iHmgvIm6FpE0L5/UAdcGXiGBugcAdCADvY8ywj1B3p5hMRHG3QChSXoZH/QCiFQPIJWlIAGG0D2graWgAYhQAOHoG04X97fAd9OAAoH0GGbQlIm4EMhQbd0gAZdQPEL2loEmo1/cXcn+PA+2PkcjNADF0GDAOBBBCBfRN4OfAMIaMsPqMMPOaD0P7hTDzqrBHz7B/BMBdA2FlD5Bdr6IiChBz6TQBl4OCXIfeAbKYCDX6BVFvziOgygMwhAA6agsDP0nMwAKvtAqwT+E1wpwTAKcIXAaOefimljtPM/mtFGQ2A0BEZDgNQQGB0AIDrEGIde6mKkr5sZSZkSInMQAOsKACSzYB01cJcLOBsJOmUdNMMFOj0ctM8W1GkA74kFztqC7lkHHW729+9PBlDHHTSDD5o1BM3Iwu7wB5kD2vesC7zTHHRoGOhANFCjGTSbCNrHDRKzClvLcONwKwPolHX4TDw86MmIA3Ibh1jCAXSYHMhNIDeDliWDti+AZl1B96H/x1j2j7sh9X8AGqyM5KQRWGcM2OlXtypmAB1Op2KexwA+Rf3rSwbYqgBQfIP39iOtEIAMEgAP7AOexA/q+IMPw4Oe/wDqzIGWjYP2RTNA9YCumAOFC4TLCF5hAurICUgagg9WBG09kVT3gWyxQEoPIHvkdCIZwAcBAuMA1EEEDdCA0t3nd7cYQIcPnlgbxYDeIYWkbXzFEJb4Q443rOGJ3sFFGhgB5mdQ+IEGuUBpBnRYIsh2UMcRdOo/yD2gzj8onEAz6aB99yA+aOUJKP+A9vqDOprMzOzArQ4xDKC9+KCO+os7OxlAg2nwgyahYQNxHqofsA2QgZSDBiJAq2AYoCtYIEXPf/AViKBzE0A3MYBWdYC2dCCHI+hQPlA+BdsNDBvQIXiI5ezYwhaRf7GWPSAtWAYAQAMmv39+AA9EgLaIgAZANG2rGJ7eWA9eBSGnGwU+UPHz62vwa0BB23hAbgfN+n///Aw8OALqeIPCHbTaB3yWwK8vEPUgZzEywgeVwB19IBeUPkFhDLrCEXyloF0NA+iMA/BhiqD8Djzdn5NXmsEsYCHD2S1pDKDBS9Bg4CegO0BGnt+ey6BpV80Aui0CVFaCrskErR4AXbsIGuQExSEb8DYRSHn5ioHk7RKjbTQsK1tGA4X8EBjt/I+mntEQGA2B0RAgJwRGBwBICrXRQQBCwUXdQQDM8MY3AICY+Qa3jhkkVb3Ay+BBDWLQDNlPYAfwL6gBDbqLG9hjAJ2ozcjMwgDqgIFO3gbNaoKW04Pu3wYdrPcbuAQW1NkDLVsGdyaA1+CBZhRBAwWgDiFouS2oYX///Fzwnmhd4EnyoMPJwPvKwR0DBmgDnchGCjU72YyQRdigzoNHznWGe2dnga+WAw0IgGZNQfuhwcuv4bN4Az/rj7X7RXAQAC2NMELmRUHxBlrtAIo70FVz4Jl8oF9B6Qe0j1lY2owB1EEHYUhfipFBy6EBPGAA6iCCromD7V0HxTWokwSaAQWFG2gg4Ct0CTRk0AAU2EzA0/dDwcvOQUv5QbOooPQFOvWdAbhkHja4ALo+D9RhBh9CycAAXiUAuoIOZD5oiwDoNPZHl5bCgwIxPsEI364A69BiPVcCppNQWkIJV0YGSL5C6vyDwhE2+AGkeQSVGED70kHpX14/BtzxA4WHedAS8Gw/iA26ahDU4f794x3YFUJSxuCZZdCqGlCnE3S+AfIWGUjMQQ7XBK0gAC0vB+UtkGbC22IQK2DQyxxQXgcNcEFW4oD6W5C0jZmU/kNvVviPOnSJoRDqUkRkMKBHEHLZAxssAp0/ADqfALRtCLTaBrQcH7SHH+Q+UDiB0heo/IANhIDE/v/7xQBZjfCPAbIqQAJ89ghoIIaDWxS8kgIxoAEp58BXfHIKMoBWCoD8DErToLMGQNsLQOEAshO0bQBkDygOjXymMZxYE8EAWi0hqxXKwCWowPDu8XHw1YyglU+grVKCkkYMoHICvA0FGEr8wK1PoBUFoIACXeUIKkvhgy9DpO01KPb/j878j7bUR0NgNARGQ2A0BAZBCIwOAJAUCYxDM9Ey0tfd1BsEIGIAAHn2DRQ7SI30r8A73RlAh4sBO/ygPa6gvb6gJbagZdqghiyowwVugEPvdAetDOAFnlIOuhscsqSYAXqA218GyKoByFJi8Mw5UA/o8CzQCgMJVU8G0GnmoI7hm0eHIWkE3JdiAp8bAGrwE0w4BBuGxAwioHeGgV1P4PLoW8f7GETkbcGdMVBn8/PbGwyQGca/0Nmowdn5Rw4z3KsB0P2MGAAAzRCDDmQDpQPwYZDAlR6g2WjwbLVpNsNL8NV2PxkgyYYJvK9dy6GeATQY9PHVVeg+aQYG0CFooLQDGhgAbR8BX+kITGcymkEMIAzaUw0yHxSmoFlcUCdZVMGe4Qvwjn8FQ+DZE8DbFkDyInJWDKBVKKC0CNor/we4zPr/f8gBg6Al6aCVJuDOHdhLsDhhBB7cOAs8WwxanQJZtYFY0o41XRHbyUArF0CDE6Z+cxme3doCvoceNIMPmjE38JjIADrnArQPHdTJBG2lAfkRdH0d6CR9UJiAlvWDBslAtyOoW5cxgJbVf//yHDwjD+pMgvIT+NpLoNtAe9VB5rhmnGcAbS8AxS1o+wCfqCYDOGzRl5bj8w+6H8ABAgs72CABahpBaIGKo5chKOUImANNIzBzUPVBVCCJgf34BHwjBCgtgeIaNPAI3h706yv4akdQ2vwN3T4CcTLErZBBnf/gfAnqsIIGmkDpFxTviMECSLkEG3wC7c8HbWECrQIAHVYKCmfQtiYdp2ZwGgSJg85C+fTmGnQAgRF8OwIovkDXA4IOEgUNFIK2rYBm/EGrZUCDWKCZf1C5BxpIePcUct0paNUTaGDrP/TcC+LyKMMoAIXAaOefyulgdPZ/NGONhsBoCIyGALkhMDoAQHLIjQ4CEBNktBoEYMSYuWSCH9YHWZoNih/YjCbQpcDZS1Cn7Pf39wz67r0MT4H3uoOW7INO6wb5A3TlFejUbdASWdAe/m+fnoCX2EJiGWIOI7yDwACf0QctYQbNyoH2gYM6h6AltKDlsaAOHGy2VxC8FJyfQULNiwF5ZhQj/PA2DMlp5CClUUbISgBQhwPUOfgEXnIMPajwP2IWFdlN/wdpQxX7IADuAQBQ5xXUUQXFLagTpGiUzPABeA0kqGPz6v5e8A5q+KnqwHSiCVwufe/MDAZQhwd028O3j48ZQDP+rOw84KvTQFspQNsGZHUjwbOjoPh9cn0dA+g6RtDMKygdwPacg+72B83Evn96Ghy0oGXVoPQB6siBrl4EmQlKl6BZVgakVRigpMYInXkXV3RiAM0iv7y3l8E0YAHDxxcXIafXK7mAB5wQcYaURkiNO6QBM9CBb6AZeNDWBlgY/AGuglExy2G4vLscvDoCfLo+cOACssWGEdyhBJ0sDxpYAqVxSGfxNPiARPDVe8xsDKC95U+uroLkK0bQFZSqDKBOK6hjKwnKG8DT/EGDIr+BK2xAnVyUZeXkDmYwwPIqLJTQBwEg5QQ8DPEOAkBLA0YkPUjlEPLsP8Q8kDrEAA63gAL4wENQ+oFc1Ymc/5BzHrI+mDjoAEXkMgDERvYLI4Oucyt4QA90wwRoZQnkIERWBgXgVhbQlgzQff6gKyXB7gS6G7TaAnQmATCSGECDBOLKrgzPbmxkAK3gAG2dAB2qCBqIAZVv4IGz39/Ah5yC4gW0sgW+95/otEZGnTnaWWYYBfhCYLTzP5o+RkNgNARGQ4CSEMDW4hgNUYIhMDoIQEwioc4gALaGO8h2RnBnHNThAM1KgWYnX97dzYCyPJYRMhsMWpILvhIQfAUYK3zAALLHmxl80BnIHFCHEdSxAQ0K/AHO1IEaxo+vAE/dhq4QgA0w8IqoM4BmzkCdyv/Qe7nBhwZC99TD/A26Ig602gB0uJecTgTDua3ZYPeBO9jQTt9/bPd5wwOX0kYONOwYocusWTgYQIfS/cex7P//IG90ExwAQO7EMUIGhkDxCuqYw06GB+33hpxoLsAAWsYMu98ctDQadAe8mkUhw93T0xiYgGEFHjyAhh3oVHXQzCdogAiknwV6ejooXu+cmgpeXQE7MwAkD4rzx8DrFgWAS6lBAxCgGVnQye6gWVbQIAyo8w9KR6DrA8GdXugp+DxCKgygWwYM3PsZQINUoMPkQDO1IPWgLQ2f3lwHXxEIu9ruP/IgDjnxhzQAAMonoBl80Cn9oOvjQGkcdBAdKG2D/Qa82x/kN9DWF9ASc9Ad+6BVMKDtFaDwBbld1SyXAbTv//ASTwbQSgtxJVeGG0c6GGDbayBnJjCCDxUEDRiA9pbziekwgLYIfACezA+OD4yzKRiQ8jV6yYNUPuDtlEPLDKh2RiR/g4Vw6kWYDx7YY2JlwLrvHc08RuhgAegqPlBnGjTQBFoRAT4jQsIAvPqEARpf8KXpSPEHSo+glRb/4dcjIlYFMCDHMyO0jGNmZQCFPeiMEtBgDcRPTAywmXqQKhP/eQxX99cygMo2UFzDzmEAbZMBXfkIKqtA8QSKX9C2DSbg2Q3fP0FWMsDOTIDExH8GFDcg3eCAuwwhsSyjQVk0oFsARgc0GKgHRjv/DKNgNARGQ2A0BCgMgdEVAGQH4OggAKGgI2kAANw+xxWmyDNwMFthAwCsDNrAvdugu9RBHXhQR8XQcxID6HA/BqiZoMY4r4gG+M5wmA2g0//Bd2IzMIBnJkEnZMNmNUGNXdByftA5ADJaweBzBMBGATtAAmK6DLA7ukHXYsGWZTOCncPMYBGykgF0+BdoOThoRQGowQ+afQdtKwBtO+ADugN0jRZolg13g5T6DRyQXeCT7RkwZ/3/D6HGKd5BAGhnCDZQAzrdHLS0HHTiOmxgSEzBEbycHjSrDVqaDjocEhS3oM41aLk16PAzPvBNEc8ZQNtHwIenAcMMdO8/j7AaA2hmH5SGpDT8GUCz1qAD1ixDV4O3C+g4tzGA0iHoJHzQjCtoBha8kuDDAwbQ4X4ge0DpQlTOFrg0+zZ4Fhy0DPwv8LR9WPoCbVEAnUkBGiQwD1rM8Bg4cw5Z+v2XAXQQHPyqSSLiDPsBeljyGLSzCsqvoIMiNWwrwYfVgQ4lBC1hB+kAdQxBfFB4gMIVlDdAy8NBnXg1y2KGS7uKGUADXqCO4+PLyxkEpYwYQB1Y0EF0oE6ooJQpA2gQA7xt4Ntb8G0CIPu4gWcLSCi7A/UCb9r4cB/cYUW9656YvIAY6EIuk7DPzDNAiwVYOGDqRdXHiFAPHFQCrZIApQ9Q+fDt4wOYYUjWMjIgDy6ADnoUVXQEb4kAbXEA3ULy9slJ+PYScLxDT/PnEpADD4yABiBB5QaofAGtXIINVKJf/8cAS+9Q20HbS+6fnc0AH1T8j9gqAnIT6BYB0M0DWvZ1DKAtCb++v2EAbU8CDUqBVrOAbggA+RY0KAMaePqNtEUF5sFBsY+egXQw2vlnGCZgtPPPMApGQ2A0BEZDgAohMDoAQHYgMg7dBMhIP7dTZxAAqREODnVGBnjjF9goB52a/Re41x3UcRcCdjRA9/uDZnNBM1yghi8XcAmugLg+uEMHmrUHnWYN6sCBOlMsrNwMsIEDsJlMTAwWwcvAS5hB16CBlin/+PoCbB/owKyvwEY/aK+2id8s4KnmBxlA+21BfgTNhArLmDOA7unm4JViAM8eA90K2lcNuk4LdNgg6Iot0MyyhIo7A8hc8NkAGB05WjVwUM0lv9NPqfsoT3uYgwCIThwj0qn9rMBZelD8gjpUoA6sjGYgg5CMGQOoU/rh+Vnw/mjQafKgsPj+6RG04/SPAbREWkTWigF86BnDf/CKEdCsPGgPNWQmnBm+AoQRetMEt5Ay8JDFXQw/Pj8FHy4ISmMgO+X0YhhAh7/BZoRBAxGgGWHQQNDbJycYYGkAMrvMDLkSDmgnaEYdtBIB1NHUsCljAN8Lr+YDPrX9yzvg4AFwMApSAGEZ0GEgLo7QO7qsHHwMoFUJoK0i3Pxy4A48aMk36CA70PkHoFU2oE4m6JA48LV/HIIMbJwC4GvnQINiIDnQIBNoYACU/kF+Aw2CgLYN/PzyAnxtpoisNcO7Z2cYrMLXAmfBdzOATrkHrax4++goAw8wDMF3zIPiAnhaPQMDKWmNUEceFFpYyhFYKY6+AgA2KMII69AzgreGgG6WALkLvJ0DdJgoXB/IbOTOP9Q+oDBsJh80m464mg9RfcDiARReoEEW0OAKaBXFH/DWiK/gQ0pVLfLB6RaevhnAw5UQQ6BuBW0BQK2UIOEHy+ugrQKgLQKg9A/q5INWw4DSKGggQxB4/SDkHIun4NUaoBUroDNSQIM3IJ/9Rz6XgawBQ8aR2WAbnfmnYryPdv4ZRsFoCIyGwGgIUCkERgcAKArIIdqoYaSvuxkpvh4QueEOYzNBBgGAHTDQnuq/f74xKBunMYA6/6C920wsbAygzgioIwbqwIBmFWU0gxlAh1mBZrt+fXvNADoYCzTrBRoMAK0QADV4QclBGHjv/63j/Qyge85Bs/igxi8TcPsA6IR2YTlr8CwwaCYPdIUY7KRxkPnmwIGDB+fngTuMoMY86GR3Ln5Z8GAAKAxAnTxYo/szcCk3aR0c0EoFejaA6GkX6ekRdRCAET4gBJo1BS1vBi29ltEOZXgD6lgCD3Y0C1zE8ODiAvDyeVHggYigw+vAS56BS6wh6RPczQEv7wbJgQ7lA8UPKN5By/lBHWLQbLdl6CoGUCcWfLUauHMIPOgROHMLWhIPvpYO2GkFrQoBHaQGWvIN6riDzFE0SGQAxTm/hD54iT9oJcD/v78Y4GmAEZpLgB0GyBVyn8ByoA4Y2AzQwAawEwYa7AItkwd1tkHXDYIPtAR1lNGXkxNZrsHyJui+dx4hVYZX9/eDO/4qwEMSL+8pBx8WB+rAgrY8gK6YAw2agVYocANPjgdfZffhIQNoqwzo8EzQHnfQmQngQRHgqgfQ6oc3Dw8z6AD3qIM6zL+A53C8fngAvB8edFsGKBxBKwxA2yhAM7Sg7QeswNPsv7y9zQBbFYE+UMWIs+yiYAAAzUxwmADFeASVGUAz4bDBRpDdn9/eAh8ICjvsERTMIHFQOmFAGwyA8ZFTN0pKh6qH2QcyCzSg+OHFOfAqI9AJ/Jx8Ugy8wMMRQdcFgraygK40BbFB6RxsPoqd0CNKGBjh6QqxReQ/A2iLFOhMCQllNwbQrD/ohgCQ20GrMEArlDiAdoH8B3YH8MYUUFyC0gRoKwf4MEOsaQq1nGCkc93CMJjBaOefirEz2vlnGAWjITAaAqMhQMUQGB0AoDgwGYdmgqRjQ42kAQBQaGJ1G3R2DbS3Gzj7CZqBZATux5XVDgMegPWEAbT/GDQIAFomDeqswE7xB9/dDjxtG3RI2dsnx8HLc0EdPNCycNDyXNBM6w/Y9YCgvcfADuEr4KFr4EY9cA8s6L52kFng5bDAGb8vb26CT2W/tKeCATSIABocgA5JMDy4MB+8hBlmN2gQgJ1TmAG07Bl0uBZoywGocwc6fZ4Ba+MQs5FDn+X5g6lxRXx+YkTq/IA6naCOOijuxRWdGUDLnUHxCOpAgfYyg1ZzgOICdrAZeLkz0CpQ5wcUP+DzHP79Bedl0PYQfgk9BlCHFXRrBCjOJFW9wR0/0D510L59OeBBgCwsnODzI0AdVpD9oNsgxICn/4P27INWBIBm078BrwsEpTHQlW8ge0DbDkAHEcL2Zkur+4FXg8AGAsCnvQPTK+iwQZD/dJxaGEDpFrTCBHRyPugOftDBfKCtKeA0/OICw3/k8yTILI1AM/bgqzCBZoFOhAft6/8DvfYStJIGNMBlARz8eHF7O4NV2BoG0N32oPMBQKsrQHkPNGMNuvUAtHUBNADHAjw4EZT3QLP/z25uYoAcEvgBPLv8D3jVHSS8f4MPrwOthHj39AQDaJAAciI96K57/GkSs6OJOgCAUuagpBNY+sIcMAAXPeA7PEFyjOBr9XiAg0egVRCgpfMq5rkMoAENUFiAVgGBBwaBe+9BcqCD/hC3ODAyMCB37uFlGrSkYITYxIAxAAAp40DpGFR2wK6MBK0KAM3Qg1YSgWjQlYKIwUOIWyFWIPsNJv6fAXHWwD9w+INm/98/O8sAKePYwIM8X4A3poBWloDMBaVt0OCDgIQhA8hO2AGOlC+jZxw5jbfRzj8V43q08z/a6xkNgdEQGA0BaofA6AAAVUJ0iDZshtQgAKRxDJrZBe0vBi3dBg0CgDoZoAbusxvrGUAzjqDGOWh2DnTHNWjGHjRrC+p8aNpVgQ93A3WiGMCdnO8MgtKm4NPcQTOpoNlb0LkB8nqx4L3doOX6yqaZDKDT4kGNYdCsK6iTB+pgPrq0BLxtANSRATeuGaENflCjD9wZAy4XBq5AAO2nBnV0jH1ngWc9QTO5rOx84OXjmLP/1FqiTyhBD6XGFOF8Be8IAuMA1GkGrepgZuUAz/SDDpZjBHbQGKBL6r9/fMTw8/tbBlCHjp1LmAFyBSTkikdQJws0ww1SC+q8Qg5f+8sAm/kGnRHxAXgKPwsbN3iVAKiDDLIPdEAeqAMMvuYOuMwd1PkHxQBodl/Ttorh+e2t4EEh0OnvoJlX0BkDIHtBPhOSNmcAnTsA6jyD9noLAu/NB3WewYMZ3OIMoNUroNl20AAVKE2D0hpoCTdIP3gZN7ATBx5I+P+fgWDnDFuHBGPmG+xycAIC32YAGhCBDi6A3PIUmMdA+e/y3koG0JkIoLwCChPQyhnQwBsoXCFL/z+Bt8bADgeE7OlnYODklwGfwwHjg25GAB2yCQo7VnZesBwo/Ikd9MJYBQLvaCMtj0fqfMOWzzOABxGZoTvvGVFo5Fl80FkeoEMzQdf3gVaV3Dk5kQEUR6D4Ah08ClrxAMrPvEKqDJCygZsBMhDwggHS/UZKv4xQEaTBCNQBAMihlaAyA2QHaIuQFvBWCtCd++CtQ8BBT9AZFC/v7mIADdCoWhaC7+5nAG9RgQ6OgmMOMbABPvwUqA+clpFWiYAOclQD6gdd3wi5flGLQRJ4lSloYBI0qAFaIQUalAGlvee3NgNXeLgxwFbEMAzBji3d9/+Pdv5HW+qjITAaAqMhMBoCgzwERgcAqBZBo4MA+IKS8lUAkPD9AJzxBC1TBTfmgY1pcIMcuGxYUs2bAdSgBe9pBZ5cDWJDdh78B8+QgpZsgxrtIDeCGrYgGrRfG9QRBC2jBnUmQNsAwHdhgw4jAzaYQbPEoJm4/9D9yKDZN9D97qCVB6AGOqgBDzpBG7RvGXSytibw8DTQtgDw1XFsoKvjboFn30AzdiB3fXx1iQF05SDsukBEeNG68z/UZ1Bw5y3kTiCoowMKa1D8guIHtJwa1EkHDcKAOtgq5nnA/fhbGX58fQU+tR+0HQN0NSDotPvPwGXn4EEZYJoCxRHo7IDfPz+D77EH7WmHLO9nAB+e9u/fbwZmNi74yf8gPqhzD5pB5+SRAK8UAHVBn1xbwwCaPQdtKQEtJwfNhMOuuQOlX1DHXgx4QBxIHpQ2QCfvgzp4oHQBGqgC3TwAWjkC6nzxAm8HAK0qAK0kkNeLBh9yiVjejSPnkdIRQZ+xBumF9yUZwWcDgNwE2uICWnWjalHA8OjSYgbQfnXQSgHwlYvAbTVSwHMKQCsWQGEGOtwPNAgHyiegw/NAgynfPz1mgAyu/GN4fmsreDAFNLgCyj8M8BPvYf6BpVvs8Y9rAABz9h9yCwZo2w7o0EVQB1jdupQBtAQePIACG8BDWykAWnIPilfQ/nvQPfugzj5oQODZjQ3AgSFe8MoekDhoawdogOcb8OwC0AAN3EyYN7B1/kFySGEOWtqvapEHHjgBLfEHDVKC3AdKW6BVH6B0AxIHDTqAVoOABiZBq1I+vb6OFPlInX9g4ScJjAvQYAFowAVUhkFWnfwHJU0GAXE9BlAnHzSYAToA8/apSeCBBdAAAGiFCmggA7YKBLziAPkMAAJ1Jv5tAMN8FcBo55+BumB09p9hFIyGwGgIjIYADUJgdACAqoE6OgiALzipMQgAajODZl3Bp+8Dl+SrAjt1oJl7XmF1BlCDFdbY5RVRA8/0Qmas/oFn6CBXvb1nAC3rB81agmZzQcttQZ0V0JJq0OFsoA4WqKEPulILtByZDbiEH6QOtBcYMsP5kgE04wc6EA7USQSdNQCaRQN1AEBqQQMU4FUHf3+CDxIENeBBAw2gO7ZBbgOZAZrxBK1KwDabRr0l/8Ot4UTcIAAoTMGddWBDHDyrDOzEg+7pB8XD85ubGUCHQ4JOYwcdmAaagb66vw6SToAJlxF6zR1oVQl4Jhe0NQR4BzooTWvZ1YLvQgftvWfj4GcAbSsAne9w99QUBhXg1XegmX9QBxkUxyAMWoUAThdA/aDOG2hm992zU+DsAdoS8B+63QS0Jxt0zgRo0OHm0S5whxi0GgE0eAEa6AKZD17lAhyQggxs3Acv2YYMFECWd2PMcJLbCUEfBAC5FhrsoI4zaBAC1Nn//vk5w+MryxlAHWTQ+RlvHhwED5SAOtav7u1mAG0LAOUhUHi8Bsn9+ABebQEaLPgPO5ke7EZIGoWFBQNRh/6hpgNGtBl12MAgA6xTzwCZHQetxgB1ZNmAg4Wg1Tyg80FA6eQ/dMUOotxiBJcVoPiV140Cz/iDDowEdZRBgxegKwvBM+sMDODl9KCl86DyA5TuQAM2X8ADSdCAYwQnKrB58NUHsC0GyGENYgPdAdrXD1rBAko/sNseQB130DJ8UBoClXmgAUnQ9ZUgO0HbLSBLDRjh56EwMbNAvAJc5QA63A8UJ6BDR0HxBxo8YICuUgJt4QD5g42dnwE0aAkZuPgH3S7wnwF0MCPkWlRQHI12wohqJox2/qncRB1NdwyjYDQERkNgNARoFAKjAwBUDdghPLvBSB+3UzYIAFvqCus4/AUeqPYQ3Ln4AFwODbmW7AO4480vrgu+ag223Bh0ZzloVg00mwY6gA0W7aCGPWiWGNTg5uCVYJBQ8WAAHez35tEhBvBUGbBhbuwzg+HJtbUMoJk3UCcGvPwbtOgaOGMJ6liC9INOSAfNMoP20YIa8sqmWcDtA/sYRBXsGEAzaqAGPOjsAdBBZ6BOC7gxzoDauKa88z8SGkyEZoOh8kAKNCgDinPQFg4QW8k4lQG0X/spMC5BB0O+BHZWQbPpoM4Q+Po9Vk5w/IOWQoMO2wPvwwamAtAMKWhgB9Tx4hKQB680AaUfEeCBkKDZe9CVjqD4P78tm0FM0Qk86w8aJAJd/ccMPCcAFNegvfAgt7x7eopBCXhYJajzCerQwZaBg2d3gYfkgTpo4HMJmNnAh0eCrtYDdaZB6Qq0qgE0KADeVgBeno8W39TogCCVA4xI++FBnXPQKfYg94Jnwv98Bx9U9+jyMvDWG5B/QFsuQJ1kUP4CDQ6AVguABkFAAyugsAINdvyHdkBRl/rj8AfeMgkSz5ABABibCewm86ClDCB3geIIJC8OvGbwzaPDDKBBANBtDpAO9iukq/j+Q/I6dLAAFGegfAuKK1CHHrTKBzQAKA48PA90yCgojkD5GZQuQP4AsUGdZVD8gGbZIWMPkLIK1PEHhQVo0Ae0woEFuHIEEuf/wXvwIWxGBnWrEvAA05uHBxlAAxSgQwVBaRJUFokpu4C3Kv0FDiqC/CMLPH8CfI4Ewz/4VgNG6NkooANRQYf2gcoi0FYHcHkHXBH1DYhB6e8/0lYA0IoIyG0An8GrpBhQBmWQyibkdEWVeoJ+9eRQvbZwtMU72vkfTQOjITAaAqMhQMsQGB0AoHrojg4C4AtSSgcAYI16mB2/vr4Gd/ilNQPAM1mgcwFAS74hp6X/gs+MgWb61ayKGUCHmEE6hv8ZQEtkQSecgzo04JlAYGcfNEMPugIOsgf6DwOfmBbDnZOTwXvBQdsNYLNuOo5NDKBOBWgmH7QSALSkFnJY1l9wxwLU0QDN4oIa8KCzCcCzjcBOG+hKQVCHEL1hOnDX8g3FApbYQQBIagN1vkCzoKAl+JB9zn8ZQEvrQR182Cn9oI4caAk+aNsHJF1cBF9R9+snZEBJXMmZART3v399Al/LBhrkAS1xBw0GgbeWANOOFPBAP9AsPaijCBpcALkSlH5ABwGC9vCDDiIEze6Dzq+QBl5JCEk/PxlAZw+ABodgM+GgrQHgcyf+/wGfRwFarQK6kULRKIUB1MEDDVSBDjOEd+hAUUjN2Uf0lQCMkFlxaQ1/BvBgCmhVBNC/oMEI0MAHaPAMdGAiqIMPmmkGrYwAbXmBnaAPypMgfTxCSgyg6+VAAy7/4UvKoQ19Qu7H2vGEDggCO7+gswlAcQHafnP//FwG2MAfqBP8DXhTgZiCA8Nr4CAAqGwA5VnQwAQX8CYDUHiCBi1gnXbYoB944AZ4Dz6oAw1accTOLQK+thBkFmzwDtTpB60o0HZoZABtC4D7CRpeoPICFLegGXzQQBFoUBJ87SRwCwlo0BCS8yB+ePv0JPg8CJB7f39/B74SETRI9Rl45SNo8Ae0QgS0TQSUokFuktUOZwDdPAFbAQAaZODgkWRQMIgHroS6ygA6cBQ0IAoaGACtxACt3AClYdB2F8jgyz/wAYyQNISY+YckJaTOF8F0RSgvjpAG3OjsPxUjerTzP9rtGQ2B0RAYDQFah8DoAABNQnh0EABfsFJzEAB8dzivJAPoWjFQpwN0ajro6jdQ5wPU+DXxnc0AOg0eNAMJunbsyfU1DKDOm6CkMQOoIQxqGLNziTJIqfsygA43A3XiQI12PlFtcAMZNCAAmtUDNbBBgw3gPcTApeKgJbOgVQWgGcHfwNPS3z87zQDpwIEa03/BHSUG8LJePgbQGQPgDsl/2GFt/xmQZ9vIS4I0bCSR05hlpHeax7QP+55wBgY+4PYQUCcUtDUDsgz6H/hQM9AyZ4gpkLAEpRlQ5+vdk5PgQ/Vgh6SBOo2gziXonnzQihEROVvwXm2QPKjDDzo1HdTBB20PAHX2QasFQHv/QR0+UCcflM5AnTER4PWDn4F7tkGdS9B2E5D9sIEg0HJscGcMtA8euLUFlOZAAxegrQN8IhoMoIGJ1w/2g5edg84EAF8nyYCv80wofRCIL6RBANAyf1C4iSk5gQ+/BG1hAV0PB0rXIP+D3AMa2AB1/L9+fMAAujkBdK8/+NYCFg4GUGcbtI3mD3DgALRF4D/4tgUcM8x4Cw50NyNm/kFxB9riA+qUgwb4QAfZQfa//wSfuwGaMQe5ATTQIq8XwwDamgC6FvTJ9bUMiMEImHmMwK0i78An4MNWkYDiF3zuB7DHLSxtBl5dBLohABRHoPgEd8YZGMCz+mBTgIMSoHTDxS/PADpMVEYrBDyLLypnAx6oBMU7I1Q9A3SlBcj9oMEk0IAKaFAClEZA5QRou8LnN9fAcQ861BJ04CLIXaCtRQxgM0AHCDIDr6e0ZAANRoK2o4D8DkqrDvH7watSXgNXFoAOjkT4lQFc/qEHN2IgktadMMbh07ob7fxTMS5HO/8Mo2A0BEZDYDQE6BACowMANAvk0UEAXEFLjQEAkNmgPgrkJPff4GX7kDvTdzKA7mAHdbpcMy8ygA5iAy3nfXJ1NcPjqyvBjXpQgxvUqQLNuoEGCUB7rD8B7+UHzSKCDuMCmQPu+AM7KvfOzADvAwZ3wl5eAjemQasDQFsBQLNsoJPlQY108CntwA4ZeEvAf9B1cqDDB/8zgM8DAF57htLwRmswkjb7T+UGEq0ar3QZECA0CABJgaCONqjz9ufHRwYG+D7z/wwMUO2wgYNf398wgA+jA6rh5JNhAHW8QB1K0MAS7JpBUOdXALi9BLR6AHQ9IKjjCbreD3STBCjNgE71Bx12BxpYguwHZwR3QEHpCzRzC1qKDT5LAnhgHsh62FkCILtAS7whp/r/Azv8PzDdgA7cu3d2FgPswD/QeQEgs+HpCSP+SE0fOMoppPgD+QPkR9AqBNAgB0gH6KwMUD4DDYKAtj2AO6TAWxBAAwWQu+T/g2fhQQMYrMADMXVdOhiuHahnYOMSAQ8iMMBWAJCa/jDSFSP4FH+zgPkMoNl5UGf8398fDCA3//nzDbz//senpwygwwlBbgPlXdD1n6B4Ax1WCHbHf2hagM7cMwEHLUBbdUBxDAp/0OAPKM5E5e0YQCuLQB1z0Aw+aHWPjmMzw4Ud+ZCbBID6QZ190FYI0HYR0NYH0HkIoPIBtNIElAZAh5GC9vmDlt+DVnbADgwE+QJUhoDDGniLxd8/P5GKT0hZAhsMAMU9eDsGA3TAgZGZwdBrMniAAHQ2A/gsCqB+UJyc25LBoOfaBSz3pBlAdoPPHmGgsAwhMm8zMjIO/0bcaOd/tPPPMApGQ2A0BEZDYOiFwOgAAE3jbHQQgCqDACgNSdQwBfFgnTbwRBqShaDOO6jRDdrnClrGC+qAgWb/QQ1j0IntzMCr+liBh4KBBhFAnTZR4AwtqCEO6tixAg/HAjVguQQUwDOaoMYzyGhQB0wcuM/73bMzDKAOEWgmDzS7DDo0DmQGaEkwqJPBwIBjhhPeYCS1EU7Fjj+9G6007QgQNwgAThZISuGDUIyIThRkzzQzA/jOf+BsNWimGnQIm6xOOANoZvvf7+8MoA4jqLMPSlOglQWgO/lBgwLgDidQD+Q6PyPwsn6Qvpf39zKAlsmD1MNuEgAtUzfymsrw9Po6BtAJ+CA7pLWCwJ1V0Kw6bIk2yM2QmWXYihFI4v6Pdeaf0vSBpayCrQIA0qDT7jl4pRhAK2xAq2BAB2SCDlME7fcHzUiD7sAHXZuHyH7/GUCz46CBF333PgZQXgT5CzSAALsJgYEqK00YwdvoQQN9oHM3nt/ZzgDa0gPakgBaeg9a9cPJJwU8j2M/eKb/H/Rwzv/glRZ/IbP/jAyIvfRMzAyg2XpG8Az+dwbQCh+QWhPgVZ6grUCgwSDwSg3gMn7QIMLjq6sg40ig4AOGE0g9aDUHqAMP2v4BOncANGAACiPwjSLAgQ/QoAkoDEHL9UGrTWAhD761AnSuyF/g1iVQHDOCEyf4ykXQoA8ovCAn+f9DsRPk1o/A21FAZxaABiBBgwvg1QNAVdLq/gwi8jYMl3aVgAeiPgKvsgTFETxLgi3/z8AAj2siK0Q8ZTID0YC29SPN9/+Pdv4ZqAeoPLDNMApGQ2A0BEZDYDQE8IXA6AAAzdMH49BNgTTsuFFvFQAsfKE0tDEPatBCZqD+gRv5ghIGDKAGOCgyQLN3liErGV7e3c0AalA/Bh5kBtr/DZq9Bd0eAOrgQQ59e80AWpILOicA1PCXA54KDmqwf3hxHtwRBF0ZCLsvHTSoABoIAHX2QDcE/ANfHcjAgNLJwdJgJG72n0qNo8HQYKVJmsLMY5izj8i9fwibEbr0GtSBktePYQDNakup+TKArlgD7dUG3/X+8xMDaNYecljkHwbQWQKgA/3+/vrCcO1QE7hzD0oboCX5oDQA6uS/e3oafD3em4eHGGS1Q4HX5S1hAJ3GLiCuzwCbwQd1CEG3RoDMBp0fwQ1cKg66YhJ0wB8Djv3xKB0alLikZuMZLSwZITkV1DkFdeafXFvNAOposnEIMkCuh4PYDZzvZ4ANesFMAHeWgR1ZUKf4zcPD4MM6QebAZt0JddBwlhFonU9QXIPMenlnB/hqRlDHHGS3gcdEhgcXFwC34DyGbu3/DR5kAd3rD5IXlDSAHugI7QADO/2gmyNAeRq0XQM06w/KzyB/P725Eew/UFoBDSLK6oSBD/dkYICs1gC51SZqC/j8D9BKE9Bhk6BtB6A996AVBKCVBJ9eXQbv7QfFOSdwv/6zW1sg5QMowMB+YoSeCQhZ1QA7IPDv7y/gbRSg9AQakISt/oBoYwLXL5CbCP6ByzNQOQYSBKVf0CqEO8CbKkB6QGnxOchOaASBzmQAHTgJ2s4ECkPQYYf/oFeewpfH4Ku9iMjLw3YVwGjnn4rtmtHO/2g3ZTQERkNgNAToHQJMo0FO6xAYwpUbDRs51JqdwbVn1SZqM/ggLNCeftDMvyFwxpWZlRs8CACaITy9MZEB1MkDxb68fjwDaDYT1BEDzfqCGsmnNyQwgJbLgmbqQA1x0ODBvTMzwVsIQLP9oA4d6OpBUGcA1JkAyYNm9kCdB/gBZNCkhelXYtPEfwYGBiqkn/+oM8gDmudp4hZiwghJDXq6BnZkXgM766BD10BpAxQ+oFl50JJyXuD+e1DnCnSfPejUftCgEWjlB2iQSM2yGHxyO2gWHDR4AJolB50fATr8DZR2QFfGnVofxwA6yZ9HUAm8JB7UOQV1zGC3A4DsAal7dmszw7mtWQyQ/fFIMfQf1sHG5X5qly9oaQ68PJ6RAXQmBmilA2iAAzTY8f3Lc3Dn9T8DBCKnKbjY///gwTfHxEMMoBU4YL/9hwzIEZP/sZmNM+1C7QLFEei2DtD1oOe35YDdCFoJALqVAZRnxZRcwMv1QWeCSAIHe8yDlzHArugDdVZB5xSA4hx0kCOoow45NPIf+OpPTdtqBtAgH2gwCNTBB6UB2P59UBlxdLk/8DDAjeDDIkF77kFbhMDL/IFnOoC2ceg4t4HPFQGVF5/e3AB7BWQn+AR/0Cn+jKDqGHUABjy4AdyKBFrlJKMVCp7FB5VpkNsVQOP34GEABgZouEIGHP+Dwxt0RgFoRQkbhwD4HJLz2/PAM/2g4QVBKRMGUHoFuQXkJ9BWFFB5hhg4xQxprAMyjGgDsFgiCP8gAONoE2Q0BEZDYDQERkNgNARGQ4DOIQCqfUeHX+kS6EO4oUOjlQAkrQLAcAMiPBmRG6GgGUtgQ5pHSIWBiYmVATTbBzpFGzQTBmqsg5Ylgw8OBM7AgU5SB3W+QPt1QUv+QdsBQFdvgZaCg5bzgw75EwIe+HXreC/4EDZQxx40yws6rAu0NFvZJJMBdPUb6PRt8JJh4PJi8LJxYIMfsoz7PwNsNhfX4Vu4VwBQqeM/mItUqqcrzM4TpveR1IDTCjMD6AA70AoQ0HYR0GoP0Intbx4fA58rYR68nOHumengmV3QgACo4wTaIvIeuAUEdDDkP/DVbMzggyV/Ae+7B82iggaDQFfEvXpwADyIBEo3kA7wb/AVb6BBBlAaAm0PAKcX0JkRoA7cP+iSdIb/8D3/4GXfDPTq/GNLLNDwwhZXuAYIaVBeYJQV0BlzkIthd/+DOsWggRdOPlkGbYd6hnvn5oC3YoA6/qBBHFA8gLZ3gDrQt070g29zeA1cmQBbqcAAvgaQiQG0F98scBHD4WXe4AABxSno0MN/0KX5oDgDbWUAn3UA7ngj4ocR6i7Qag7QbDpoFQEHtzgDSC3s7Ib/SPEMSkvfPj5mAO3bBw0eskAHKWGz/2KKjuDOO2jbBGgrxYPz8xlA55SAVqGABo8gV5qC7GdELOMH+gNyFsk/BnZOYfBAKGi1CegQQFi5BAozI5/pDJf3VDLwiqgzCEoagc9LAZ0tAEqrDHB//UddxcQANgEzoRCxIoWkso4Kg8802wIwOvtPxVpltPnJMApGQ2A0BEZDYABCYHQLAF0DfXQQAD24yR8EwDYAADEdNOMPum5My74WfPCfhk0FA6gzBtIBmukHLXkFLcUGndIOms19BlzeCzvRWwx43RvowDBQR+LRleXARvEqBmEZS/Cd7CB94H3PHx+B+aCl0OArBEHXekE7cbAlwQzQgQhwhwA8i0pKQqOwUTTUGqhU7TASGgRAGwAARguoww5ang3q4IFmuUG3QoDu5QcNBIGW5IM6X6Cl66AzIkDLub+8uws+cA3U+QcNKIH0gfacgzqgoDQC6uiABhTePjkGnvUHzbCC1IA7jqxcDODDAj/cZwB1pUAHT8K2lIBSCHxbAji5DPPGMYnxjlJWQDvajNBBHFCHVkzengEUf6CbCUBnfIBmzUGH8IHCHtSR/vL+HgNI/PntLeBrPUHXOoLPBAFda8jICJ8dB60CeHhpCbjjC0ktjAws7DwMoLgCxS+okw665hNyYCNsxQTqIABoIFEUePUgaGARtFUC1CEH3yjAwABecQC6khRUdoDEXtzZxuCWeYkBdE0lKNphVwRKqnpBrjMEdsZB+l/e2ckAms0H2Q1a4QA6WBB+nSAjI/QgQiYGXlFNhjfAU/9Bg5+wW04+vLwATlGg8wlAhzYyMjExQNLqPwbQdhbQyhXQCgfINYfvGYSkzYHbWB6B0ygDNGwYGGGhAbWLATUvIUo47PUc7pUA1K8XRzv/DEMAjHb+GUbBaAiMhsBoCAxQCIxuAaBrwA/hCm8QdyrRZ5ZAHa1Hl5cygJZfg07+hpxY/gO8LBbUmQNdAwaanfv57S0D6Ao/OeC1YKD9/aD9v/eBs4ZX9tUwPLiwAHziP6gRDbo9ALQnGNSoBO3vBjXAQQ178CnxwM4/qKMI2its4DmRAbQ3GjQAIShhyADa1w3qFDKQ1NGhII38x5ytGxIlKw3djTnriBS+8DT9n0FSzZsBtCIEtCf65d1dDKb+88GzsqCuDqiTBZttZQfO5oI6k6COpaCUKbgTBTrMDTQYAFppAupcgdIcaLk16KYI0OACSB14PzYwHSgZpzKArqMDxQsonYCuywMtvQZdSwmaqQbNPoNWnoDYGHFHxCwrvvj+/x+ysgAbTTidIHd0qVSOweIdncbhGKydOuBqHwkVDwZQvKmY5zKAlv+DVgComOcBV3ZIMoDCFTRjDpopBw0MgDBoNQ5oEAd0swHoyj2QdbAuLcRqmF8ZwCsxQJ1vULkBGsgBbQsAzeaDVgBoWJczgAYOwdt0kNISiA864wE0ow/aBgBKAyDMCB+0YGYAbQmA3M//hQHkVlCZA3InaOsBA3Q7ACgdCkHTmFXYGgbQLRECwJl60KDB3bMzwXzEQCMzeFADtOoJtM3EEqgelL5AYQY+qwG+ukESnGZldSIYPgAPBFSzLARaB1wpBTwMlYWdD3xwIyg8QSsMIGEB6pyjdfTBAwLAqweZWcGDGfCwgw0UMEBCFHa0InJ0DukzAf6PdlgZqAZGw5JhFIyGwGgIjIbAAIbA6AqAAQn80ZUAKI1CBiLDA6MjjW0VACO43Qlq5IOu6QJ1zu6ensYA2gIA6niBGs+gO/vBJ30DHQGZLXzAALoaDLRfFjSj++vHOwY5nUgG0MoA0AoB0BJx0MFwoMY8aGksaPDALHAh+DA00MwvaPYR1OkDnQEgAOz4g07gBnUQwasDgLN3IDUMWPby4+2ckpIuh1PDlJEaeQPVDEY86QZ2cwTonn1QHEGWVDMwgPZ+g2ZBQfvdQbOmoBUhoA4dv7gO8JDAfQw/vr4Ed/5AM8qvgUv9QQM92vb1DDePdjGABodAJ/3/Ag4wgWZgQTPNoPvnjYEnyYM6daCzJiCny/9nkNWNAJsFOmsCNGPNySvJADptH3KbxGsGyPJ00gup/1RKE9TvsJEYv1jSA2yVBGj5PGh5Pujqvdf39zGADigEneMAGrCRUHYDn6kA6syKgO/eP8gA8guvsCoD6JwAyKGN37GXPOh2AsMS1KkGpQlQGgHpBa0qAp0bASpLQGUNfHUCkt4/wMP7QAcIggYaQB110CARKCZhq4JAZ4mArpsEhcgP8JkKfxlA2wVA502AZ/aBZoHKI5AcaEAStOIAdLAgaDsDyE7wrRQMkBUFoMEE0NYGULnDJ6bN8Oz6emD6VAPO4j+GrGQAWgIaEAANMIFWs4DKK9AqANB5J6BBTnWrYobbJycxgOwG3XACuy4QEf+wgQBGcKcfNJAlBxxEeHVvDwNosAqUR0BlLeg2AsxAReiF+59hFIzcEBjt/I+m/tEQGA2B0RAY6BAYHQAYsBgYHQSABT0jhQMAqJ0URuhSXojp75+dBfPFlVwZQB0vUKiDOmOgvd6gBjloz6tF8FKG57e3M4Aa7KDlwiDz3jw6ygDqvIFvBHh+DrhM9iuDtEYgA2jvv4JBHMPtExMZHBL2M9w/Oxu4sgB4bRdw1g4ys3gb7JvfwDvnQZ1E2NVe4NjGG+VkNoqG66wURQMBmAGNkUYgPRFwImGEjgLA1DBCZ0stQpYxPLy0mEFeN5rh7ZMTwMP8LMFnSoDuvwct4/8FvMsf1EEDdQh/f38HvlUCNNv/4eVF8BWR3IIK4D3o3AKK4NP/QdsJQJ02dh5x8JkS4OvbgGr//vrKwA+8IeD75yfgswZAs82gfdmfXl1lYCDhyr//dEgL1B0QILIMREsLsPLi98/PDH+Bd/2DBmZAgwCgvAlazg5arg86j+HNo8PgpeygKwtBA3egwT5QpxsUP6CIBx1syMknzfDr62vwUYbgjAuzCzks4c78zwBexg8c1AMNBoA69/AbG8DjjtCyB3qYH2gAEjTzD+pMg0/pB8clI3hBEGgFgRhwi8C7J8fBgzw/v79lAA0A8YtpAQcjL0OLRkYGUPkEj9f/kEMVQSsSQGkQfOAf0L2gwU0JYPkGGnAE7fMHrUThAt4qoWSUzADaNgAbTACvZgFuVQK5xchrCgPkPAEu8M0JL25vYwCdffHhxTkG8OAVMD3DDqREjnPYKgZQ2gStEgANVHHySoMHBWBbL+BlHdY8DJJlxLIoCi0tUJD/abL8f3T2n0otpdHOP8MoGA2B0RAYDYFBEAKjAwADHglDdCCAkbruJmoQAMNOiBtQZqkYIQtSYUtjIctpGRlAs/CgDhbo8DXQEl5Qx03NopAB1DkAdfJADXnQTBioYwc6NRw0SPD391fI4AHw3n/Qne2g2V5Q4xs0yyWjFcxwYm0UpEMAnqljZQAtEwetMgDNxsFmj0H7xj8DT/yGnDQOS2zojSAyGkUjoUFKs0EAaNpFSiugmAEt8Qat9gDPsAI7a6AO0QvgvmtQRxJ0toOQtCn4OjbQrC+oUwfqZII67+BzAP78YAB19N89O8XAzMwG7lB+fX+XQUTWCtyJgywD/8oAGhACnS8ASg9yOuEMoCvbbCI3Mtw/Pw98YCTo0DbQ1gHQqgFIBw/kMvzp4/8ApQXqDQYQUZZgGwQAaQP6HTRDDurAggb0QJ1gUNiCtgDpOLWAB2JAs92g8P/98wMD7PwG0Kw1SD1oyw6vqAbDtw8P4J1urFUCLMnABosYEPECDgdGyMw45LBRBvh5AuCe7n/YVYFQcaBa0GAh+HT+T0/AKxPAq4SA6j69vg4ZDkUuxxig+phZGECrTUCdewYkM0Gz76AVJO+B15OCzh6AHVYKuolAF3jzAOhsAUaoGaDVSyD246urwDc0SKh6gq+yBJ1DASrXQNuaYHkBNCAKCwtGqP9AaR10MCqonGTjFGBQMk4DbnWSYwCVraDBVkha/M+AsiKCETEwwgT0A2ibBmiwg3GoVH2jnX8qtZJGO/8Mo2A0BEZDYDQEBkkIjA4ADIqIGB0EALdPCa0EwNpiZGSAzUpB2rhM0NOwGRlAs3ugPbGgZdSgWTAWVk7wFV3Ak7UYzEOWMzy+vJwBdFo3aF8/qDEObjgDDwQDLQPXc+1iAM2mgToOr4DLi0GHhYEavwJiugygmb+3j48zgGZnQQ1u0AyYpl012B1sXCLAZbxiwBneS+ArB8GzhECVGjbl4GsHIUt9/1GW6kZSg5TsXgJmnkJdzszAAB8kgs74g5aTg1aJgJbggw5Iew68mg80qAPpxP1nAB0ACDr9H9yJAu5/Bi3JBnU2wQNGwOX+P76+YAAtFQeZAztgDZSkeQSVwXfRg28MAFrLwSsBjn/QuRGga+JA2wJAaQvUeeQAbgEArTwBDTCAzhP4BjosEBzfsMYzaiP6/yBJC5QPBpA2CIDoYDLAl7iDDvAEDdyBwhJ0wCfs7A/QuQ2gve4v7gIP0QPudYccyPgbfPr990+PwYM6oK0+oI40CIPiFXkWGWwXOB1CZ66ROucMDJDyB5QOQPaCtiWAt3LwSIAHB+HJFzZAAF0dAPItqBMNukkCdA4BSJ2mXQ34mkE+EU3w2QWf392ClBOg/jMTC/hMES5+WQYD934G0MDm13d3wANNIL3gjjtwUOAPcEUExA2fwbdYgAYuGUAHlEKWNzBAykjwyAl4AODzm5sM4GX7QHnQYAjITaCDFMGDn6C0BY8WyAAHqPOu69IOHDg9yQAbRAGpB20vAK2y+vTqCtDcPxB7GBgREOhvReD5F6AzDkBl8VfwIZgMDIN+EGC0889AHTDa+WcYBaMhMBoCoyEwiEJg9BDAQREZQ7RypHfjCI99oAY4qAMFOiQL3BgHNphBh6spm2aBG9WghjpoxpYBem/5sRUB4L3c987NBnfcQQf7gToxoI4+qINwdlMq+FAtGc1gBlDHzTv/PvhQwB9fX4GXa4Nm8Iy8pzN45t9lAM0wXjvYzAC6Ygx0pSCoVQvqdKhbl4FtA935/uXtbbB5sOsAER03EuN+pDVIQf4ly8+Y4YrSWYZ2yEAdElDnBdShAu2hBs2+fwbOwoI6WhIqnvBBAtCyfdj1baDl26DZflB8g5brg5aUg1aGgJaUy2gGQe96B17pBzwgEhTvoEMD/4BWk0DvagddPQm60g3UOZNQdgfP6oLupQctTwfdsw9Kx6COFijdgG4kYGDELKZhB/kNlroE+WBB8txERD5ASgeoy7whhxuCBlJA+Rg0gAKKR9DJ9qBD+0ArO0DXdYIGVYRkLMA3BTCxcIBXX4AODwQtZQcNvIA64+C78UGz6xjpDjrQCD6gjxk8aADr/IPyO2hvvZCMOQOvsBr4tgDQgXrg1QCguANieb1YBtDqI5C9sGsLQe4EbV+AlAmMDDePdDJ8AG43Ai37Bw0ggW4fAQ9KMDKDV5KABqZY2HgZQKsbQGUO6ABCkDzIHfDwALodtOIIpE5E1prhP7TzD5nBh3TiQerVLIvA0QQq60DpHnaWAjiPQNMpPB6hM/ggPiivnF4fD17JAlrpBDo3BXQzCmgg4dHlZQygazJB5jPA9AD9DnI3aHDk4cVFwMNV54O3UcEHcBhgA7gg0xlHG4fDMgRGO/+jCXs0BEZDYDQEBlsIjA4ADJoYGR0EIH/vJiMDqAEPOoQK1HEDNcZBDWNQ4/Q+sIMPanjbxmyHzEYxQu75BnXmlEzSGUB3+DMD794GzeqCDuQCL7sGdtu1HZvAp2RfP9IO3qO7Z5YJ+Eou0AF/oOv/QI3289tzGUCnd/8FrhoAndx+81g3A8gM0J3aPELKDKAbBfhFtcH6QFeLgZbIgjp1ZCU5sjvCw6TQperAx3/wsmcWNh7wne+g9ALav/z0xkZgx+Y1+MBIUByCZudBK0hAh6qBaMi9/7/A98cLSOgzPL6yggGUjkCdOPCBbrxSDKBZZrPAxeDZ1f/Q69su7ioBp6H/0I4V6Pq2s1vSwfezgw6SAy2jBg0egDqPoA4WqIMIOqhOBTh4BRosgO8zh54H8H+QDwKRPzhBRhn4H7EyAmQvKOz4xfXAq29Ag3WgmXFQ3IA6xODr/YCdUPA1oZqB4NP3QfmfFdipBq3SAG0Jenl3NwMkvEHm/meAbMNgYpDTjQSnCwX9OAZz4Jkh4NUfTKAFdIwMoLTBI6TCADpsEJQeQPELShOwZfOgmXHQIBCoEwyaZQfFKWSrACPEfHAW/Q/eew8asAStOgINVIJmycErQ4BlFi9wVQD4OsG/vxjUrUoZQAMdoCv7GKE3BkAGQJnBB//BziJ5AbzNAtytBqqRUvcHD1qA7AWVjY+Aq59AaR7k18dXVoIPogTRiLTGCBn8gs3hM0JWVoEGJkCDXaABK9BKKZA/QdciguwB3aTyFnimASN8tQQTAyisQSuxQOEP8rsA8KwL0DYbUN6DDJBAOv3U2k5C1f3/o7P/VKg8Rjv/o92e0RAYDYHREBiMITC6BWDQxcrI3g7ASPI2AMiyXFAnHHSCNmj5LahhCupMgZazQpb0/mMANW4ZgftPwbP0wMPbfgIxaBk/6CRsBcNE8CwsqHMvIm/HAOrogTpyoIaurFYocCDgAgNopvfTm2sMkFPZIZ2Df//+gJfPiqu4gzuUoNPfQadog06EBy3rBe33lgDKgRriX4DLecF7y//+ZiB59n+0IYrIpSSvGUbNT7COBuiARtABZrLaYQyg2WLQMmbQknzIzQ1/wbP4/MBOPmg2FjTbqu/WxQDqNP3//wd8sB/k9Pe/YHeBOjegjhtoCwCo4w4adILdEQ/pkEDSC8gloPQGuu4NNPMP6tCBaFC6u3GkgwHUgeIT0WD49PYG+PR20NkDoHQNmskGnUEAsuw/lQdCiC/+yC+XGCmMMww3Qs1DKStgnU7gyh9pjQAG0KGMoNUUoP3qoIEaUOcf1BnlElBgAImDDsoDLXMH3RAC6oyCzlx4++QY+BBG2MGLyB1Z0GGgoO0hoOX1T4D750GdfdBNDrCl/6CVQ6B0BIpb0Moj0Ow+qCPPL6oF7gSDrvATk7dnuLS7hMHAox94T/8hBnCnHbiVBFRugcoG8DkFwMNDQZ3qH19eMoAO+gPfMAD0G2hpPQN0QOnJtbUMoIFOUBkGcquqeT4DKC2D/AW5nvQ7eCsKZIsKZIDC1H8uAxuXMIO0uh+4rAOFKSitgrc7/P8LHsj68eUZAyy9wuMMaLe4sgsDbLCBAbpdBpRuQfpBK55eAw9b/Pv3BwPk6sD/DKA0LK7ozPDpzXWwH0H5B3QTAmhAA7Q6QRq4Sgbkbj4RdQbQ2QWgVQgMDIOsozha5o622EdDYDQERkNgNASGcQiMDgAMysgdHQTAGS0YnQnoHlxgwxQ04w9qkEL2pv5gAHXmuATkwY16SVUvBlCHC3ToGmj2FtTgBzV+QY1Y0MFasBOvQY1v0HkAoFkt0Gz9q/t7wDOC4IYx+OCt/wywMQrQ0uKAig/A68fWMIAO1fr+8REDaJABdPo3aCAAtL8Y1IEEDUhAzEdu5BLR4B1thGJPBiR1KHGfBQAazPn++TkD6M52UOdKSMqEAbR0GzTwA5odBc3agsRBS6TBs/gM/yBpAbysGjpDDHShf+krBtCMPugKP1C6Epa1ZIDtz8bmAdDSbEZgxw+k9jNwUAmkhhfY8QfN6oKungQdSAdKL6D97KBBJAZoOqCs80/tDhZpZRRVBwGQ4h/lsDnocnLQuRugsgAUhqBD/0DlAWjWGTQYqG5VwgC6+g40UAjq1IIO7QQtVwd1QiEdUWj2hnpPD7Tf/dlp8DYfUNkAmuEGzcq/fXwUHLWgTryUmg8DaKsHqBMO6uSCBnRAAwCM0OXv4MNDgYdEvnqwnwG0vx9U3oDsBQ0O3jk5kQF0XgHsukfQoASorAEdJAk6WwS0MgE0WAXbLA+yG9SZ/vYReL0fA+SwPdCZEqABDZCDQAMQoG1LoHIQdJ0peHsCtzjDh5cXwGeagK7tA5V/oMEGYeABlaDyED6oiVLeMDKA3Agq40BloY5TMwNopdRnYKceFEKwDj3ojAwpdV9w2Qo6WwU0GAYahJA3iGd4cQey6srIazKDKHDwA1QOiiu7glfdgA4N1LCtAg+ugvIbaKBr0AwCjJa7VGoVjc7+j/aeRkNgNARGQ2CwhsDoFoBBGTOIzsWQyjpUajiRs4wTvNwauDwWNNMGmsEHdeRADV1Q45+NUxi8JFsWeG81qIH9HHjlFWQJ7n/wHllw5xzYuYctowUdJiajFcIA2usNms2HdP6RGjPQ5figxu/+udbgKAKdBg/qrIEa1KA75UEzeqBVA+zAQwFh2wpAConuxI02QnEnfZLCBncjFJRWQKefg2YoQcuy3z45yaBskskA2ncP2hsO2ucPup7tzqnJDOCZXSFVBlbgIXIMkIgEL98GDSJt6BAAnyIPXl0CnLkFLQH/j7yPHJpeQOkAJA7qCILuawd1OPXdeoHXSR4AHywJ6vj//vWZAbKE/h9keTh00Im8zj+sHKFFQ5y0MormZxb8h7gHtCoHtEwdlP9AHUsG8LaLvwyGwE4oaCvA1QMNDKDBAPBsOrC8AOV9UGcYdjYHeqIDbfEBrSaS1gAtoRcGn+MBKldAZQz4hhHgigPQoADIPtC5DaDl/ia+syCn2wEHAEDnSYBWC4BWDoBWmIDcBOrEg86XAKlVMcsBWwlemg9UD9qKBEonoHILtHf+2sFG8NWTID5oBQMTMzsDKK2CViTAyqtLwC0mv4CHUILOOABj4NkTXz8+ZIBtDwDt0X//9DTk8EDgIAlodQHohgvQ6geU8yUYGSEL/oFbG5igh1yC3A1a7v/w0hLgyoH9DDpOrQyggZR3wLwCGugElY2MTKwMikYpDDLA1TSgwQRR4PWGl/dUMIDOUwD5FRTmIvK2DKDBWNDAy+d3wKtSgecanNmUArzy8CIDbCUDRoYnceXIf4bRDufgaS+MxgXDKBgNgdEQGA2BQRwCoysABn3yHIKrARgpdzPOrQA4VgCAZqVA++5Bs0+gmSvQ7L26dSl4KTBoxh50vRb4BHdg4xi0j/fbp0fglQHgGwJgDUdgZwHUGQDNzII676B7xcH7cf/jPrUfNNMGmikGNYjBd4oDtxaAkhRoRhc0Kwdq7DJg7N3G0zga7fiTliOJSmvYtgHA9jgzMIA6dKB0AJrJBQ36gJbbgwZ+zmxMAi+bBnWkQEuVQfu8QbPAoLvm0TsboA7ksxsbGDAGi7B1SoBx/P75WQZQugDNRoOWqb++v58BfKga8Dq6/wyw9AZJJ/+pNOBB26KO+DxP/GoAHGZiWwEA8hxYnBE82AfXCWSAlr8/uLCAATTYA8rPoK1B4A4/VBFiqT/0kDzwoYuQlUVMLOzg5fZ/gTP4oLMCQB1i0HJ8yIGiDOADRP9Dt/WoWRQwvLy3i+ER8GwI8F566OAN7PpQUOf+D3CJPyiNgFYogAYLQekKlPZANz6ABp9A2wpAgwmg2XZth3rwipTbx/sYQOdQgE7RB60yAW0ZAB1MCjpjhBt41gholcC/f7/Ag5kg94JWHSkaJDDAVimAViKB0tqTa6sZ+IG3mICuQwQNlIAGJEDbFkBsyCAlJE+ABkhAq15AbhSUMgZ20i8xgPbugwYrruyvYQDdKgAekAAepAgyFzSzD1ra/+Ut5NYCEBt0/eC9c3PAaRyk/v75uQzgW1iAKwhE5WzBqwNAKxQgW2X+DZ5aeLT8pUJcjHb+R3s9oyEwGgKjITDYQ2B0AGBIpFHGoZmTKBwIIDwIAAkXcAMe2Gj//fMTuMEJWmINaliDOm5qVsXA/baHwadWg67sA+2XvXd2JoMk8IT3d8/OMIA7W/BG33/wrCuosQ9a4grq7BFelvqfAXSNIEgdqGENspNbUIEBdEL3x5eXGWBbC4ja9z/a+CQvnZM4CADr8DFAZzzl9WMZQHemg5ZagzovoP3NsPMkQHvJQekBNLP69d1dBtDSbsxOPszZ/xhIXcYMSi+gThjo9oCX93ZD9qD/R8yuE9f5H0wNbuLKKkYyBm7giQPvAABIFaxcYADHx9ObG8FL9EGdZNChgJB99VDTGKFbiECH6YFuDhHVZAAN8MAO/wO5E3RGAOhAQdBNDqCzPJjZuME3CaD69D+w87+HAZROQIM63IKKDLD9+6ByDLK//wMD7KBCkPmgsyL4gYfigdIAK/BASlCn/tvHBwyQAYV/DC/v7GQQV3FjgG0P+PTqKnClyF0GUMdcQT+eAXaVHmgWH3YVJchc8L78BwfBHoSndVBIAAckQKuhQKtMQKteQAMF4C0HwLNMGBkhgxngMw3ANyTcYwCtaADlB5D5IBp8LSqwjAXN5H98eZEBtPQfdHsAaAYfpA90FSpo+wtoJQ2oXAUt6wcv7QcNqADTNGgVxW/gAAhooEBWJwy8JYHhPzmDXJjFBFVm/0fLXyq0M0Y7/wyjYDQERkNgNASGQAiMDgAMqWQ6BAcCaDEIADcTEh6gpbGgDhvoQDfQgWmgGTRWDgEGKeCy3cfAq6lgS2FBDeb3L86BG9CgGVjYQW0YnTZgQ/kndCafmA4YshdBZwCATpCHNK6/ATt0XxgIdv5HG56U50KC6QyRd5APOAPNZIKWR4spOIKX4YNmbkErOm6fmADu5IE6SqClzqBD5MCrRWBL+xkgnUt0h+NKLzg7vMC4Bx3eBhqMAtn1/z9iEIFw2husjW1qDQKQswIAFCNIA4OwCAIJgcIWyUhQkgEtdQfNqoMGeUB5FrTKA3TAI+jAPJBSY5+Z4AP7QJ1/0P31IONA23pAtwfAyghI+fEf3OEHDQBwA88dgXX+QeZDtgowg48OAS2f5wUffvcRPBsPdi2wgwxa2g8aXAANGIIGHCDX9wFlgW4G3WoAOsPk/bNTDCCzQOUb+LYCoLQIcDadCXi4KegQS9Dhe6DzByADBsA9/Kxc4G0AIPeBbkL58fkZ+LR/8FYUYKcftoQfdLAlJJjAowDg7S5/f38Hn3sgoerJAHIvaPvU81tbweaBBlHA5n15AT7ED3SuAmgQFFT2Ckmbgjv2oDNQlE0zGUCrrkBnHIC21ICuLwRfcQi8ShU0mICc1hlGwTAIgdHO/2gyHg2B0RAYDYGhEgKjAwBDLq2ODgIwIA0AMDJClu2qmGUzPL+5Cdhp+ww+pR3UuAUdtgU6EAy0DB+07Be0nxt87zaw8Qvfo420RPs/hR1xkLPAh7d9ewOeqfsD3c8NSWJYGkejHX/q5j4iBwFgnXFQ5wy01J+VUwB8Jzzo1HXQEmrQffKg/fmgAyJBnS3QLCdoWwnsejZs8UlK2sE2GAA+gI6omf+h0simxiAAtQYAIB1bULyBTQSnE8jMP6gsAW3dAXXaIYeH/gTuuRdkgHTqIZ1oUeD+ddDsPKjzCtqXD1oe/wG4hQOU10HxBot7RrQr80ADj6CrSUErPETlbBi+fXrMANofD9oKALqp4OOrywwgGjSjDxpgAOkHnTUBSpOgffegQyFBnW1l0wyGF8BzS0Dll75bN9gMRcMkhifX1zKAltGD9IAGJUCrDkDnj4DMAZ1jAnIzqOMNWsUC6rCD7uoHHdQHCgdOHgkGyOGkfyBnmoIChhHiA5A+WOcclBdA+/efXF3JAEmjkOX6oFsIQGUs6DBL0NkKoO0MoC0soO0RIL2gbQSgWy2eXF/H8OPzUwbQrD9oGwFosAt8LgMVy12qFCKjZTGFwTja+WcYBaMhMBoCoyEwhEJgdABgSCbXkTUIgHUrAFIjHtSRAzVwQQ1QEP3h+XkGDdsKhlf39zKAlpyCGqug/figg7tA2wBAs3TIp/Jj77wR26BBj4v/4GXAkMPHYGagmUWHxiY1lsQyMjAOzcIc50AA8swwhA06uR2UZljZecEdNPDBjdwiwJsB7oHTDujQNpA8aNkz6KCzl+C71RHx+Z8acQkyA6nzjxnoQ7VxTaNBAKT4RUmjaCuDGJH5UDZYPbTsAG3zAZ37AOrYgzq3Rj7TwafSmwctZXgKOs8BeOUj6OYQ0K0gbx4eYgANCoBO7gdtNQINGvz+CRpsfA0WhwwkSIG3/ID21oOuAQVtLQF19v/++cYA2Z7EAF5V8h96faiwjDl4y8ev7+8ZQLdOsAEPDAUNOIHsAa1EAB0KCSpHQJ1n0JV6oJVOrx4cYDi1Lga8PB980wFwhQDIbFB5Bjq7BFS2gc5DAc3Ag07vB60qAZkLGvgEpWGIX39CVgIwIMon2OAFOO3Bw+0/A2gwAnQOAOiQQcRhfYzg1QEM4HEVJvDKGRY2LgbQCgnQSgbQNgCQW0CrKECDHFJqoFsCbgHPEdAF3hZwiwFx5gB1iheKy7rRzv9o53+02zIaAqMhMBoCIywERgcAhnSEj5yBAIzOKLSRCjrQD7RXFXQHO2h2CXRwH2gGC9RR4xFUAt/5DWr0ghrVXHyyDOrAMwFAy2RBJ/Zjdt6o1dH6z8DAQNsZ/8Fw4vWgHiAgYhCADTjz7559HXgt3Gbgfup74NPNQZ0pLn55BliaAcWjhnUZw90z0xlAp/szMFBnzzL+Yuf/MKqGKB0EQNNPsPMPCjrMgR7YeQ/ggIUOADABT68HHfgImpkG3d0PWiIP6ri+AO69F1WwYwDvfwdq+Pr+LlgbaFk+aIYdpObDC9jp9QzgewNBg5Cgg0dBgwqgQSTQMnvQ0vm3j46Al+2DOtDge/mBykEHTYI6y6AVJaDOMKjzDjrAFDSjLihpzAA6pR+0DQV0Lz/oPArQFYMgS0CDUaAbBUAde9DggATwalMQDVolABpkgKxQAd/UDy5/QHzQqgBQeQi6oQI0OAC5xg9RPkGCk5GBAboCALy6CqVD/J/h44sL4DNUQGmfCXh6P2iZPye/LAPIj6CVCqCT/kEDKJLA6xBhB1qCtjqwsfMzgG5kAG0DAA3CatpWM9w/Nxc6rPh/tLE5LEJgNB5HE/JoCIyGwGgIDMUQGB0AGPLpdmQPAnx4eQlyMBbw9HTQSdmghjVoLyqosQo6DIsBdo0asOMGmnG7f34+uHP3H+Nkfxo1ZKgwuzTUrrcaNAMDeAYBQLPDoA7ZzSOd4OXJ1pEbGe6cnAQuDUBLlmH7ukGdnOfA+8yRTyunbNZ/JDaYKRkEIGIAACOeocv7YStYGCHz2/CiHjoAAIpj0Aw36EDQL+/vgDv8msC76Z/eWM8AOnAPoh5i1n/4Co3/DLDVQ5DtR+BpcAb7uD0MIsB79T8AD8cD7eEHXXcHmqEHdYRBt0z8Bs7yw5bW/wPurwd1tEFlEKhTDroCEHRYHmhAgoNXEjy7/vnNNQbQ8v23T44xgDrYoC0CoOsIQWUaaFUBaDAAtPSflZ0PuGUB2NH+9BTsXA2bCuAe/OMM4EMBv78F79kHDUi8f34OfAsCKD2D3Q088BC05YFHWI0BfIMA8EpEmH9BwQYrcyDjAkwM4Gsr//xkMPKeAr627yOw3AWtZAANQoD280MOA3wLPsBQ16WdAbT96gtw4ATkN9DKBfDSf6AFoPM2GAbTdX2js/8UtIBGO/+j3Z7REBgNgdEQGKohMDoAMCzS7kgeBABFIKQhAtrvD559wxKnoBD6DLymCrz8H6XzT+VGzAjs8BOThQZ0UADXQAD8wL3/DA/Oz8Ppjf8oB//BlI02fkkrOskdBEDSh232H0fnH7RPH7TSB9TZBS2vB3fgIb1ZBvAcOVAfqLMNOgAQtEcfckr/R/D1dKCOsaiCPfDOf14G8CAiA2qcM0LNYecSZjDymsrw/PZW8Lkjz25tAXfWQTP/kOX5fxnAJ/t/eAimQfaC9tJbhq5mEJW3YwCVVaAl/6Al86Cl+rxCqsADSh8yiAHv0QfdSAHeDvD/LwPonn3QoANIDWiFCvhkfaCTQAOdoA426AaJ1w8PM6gAD917CjwXAJTXINsOPoPv3gfd+f/+2Vn4bQKgswlAe/RB4QJaFQU6QJUJePI/aJCCW0COARQWsJsHQOEHuvpQQFwPPJsPukoRFK6gMwdA6kC0pJo3A+i8AlYOfgY5nUgG0E0GIL+BDiiErR7gFVYFn9ECsgd0/gDo0EKGgS4rRzv/FLR+Rsu/0W7PaAiMhsBoCAzlEBgdABhW6XdkDATg2g5AOCpBjRYS7pymYwNxqM3yUyPb0H1QgJHS/DFIGr2kpEvGwVQmEHYLI5YOPTytoQ8AwPngHjkDrGMPokGdZ1CnGWSegKQRA+i6u3/QWW7Y1XjgTi7wBH7QAaGgq/GsItYxgO7KB6VLkFrQ/fkgM0Ad6G+fHoGXvINmx0Ez2iDML6bDAFraD1qiD5qV5xPVgJwbAZzhB9kPse8/eBZexTSbAXQDCejEfNAyfNCMPmgWH9SJBs2ug0/kBw40gVYkgFYxgc4qAXXUQX6BzebfONLOALoNACQOOlQQNMMOGhB4dX8/eAk/6OwTkL1iSi4M8nox4K0toG0NH4BL+CE3GPyHHvjHxAA65R80SALazvAMeE0iaCABdNsA6JwUkB74LQTAMAYNSIBWFnwEbnsAbY0BhRsovEArFkDmvnt6kkFExhK8veo18KwE0NYrUJi+eXQUfEghaMsCaPAVFI9sHIIMwsCVEqCbUj68vMAwqFYDjLZliQyB0c7/aFIZDYHREBgNgaEeAqMDAMMuDY/sLQFER+cgmP0ZiZ1+fPFDtwEBrJ1ibPlmABu6tE6fAzYwQOogAFQ91L3gxfzgO/uZwbPtoA4kbCk+rGMP6iCDT9IHdjRBHVtxJScGUGeUgQG2Px5oJtg84IGd/34zMECvB3xwYT64kw86gA9kFqhzzcYlBF7yDrrRA6IfaAbw2j0ObjFg5/YDA2j2HDTbDxpgAA0YgGbpQecAcPLJMIA60iD3gtgXduQzCEqZgM0CDQyADvYDzZKzsHIygAYPVC0KgOa9ZwDNzIPkRRUdGEAH+YHOKOAEnl0Cso9LQIEBPFAAPETw8p5yBtCBhKCzTFg5+BjYOYUZZLVDGUCdcZC9oEEBiJshaRg00w/SywA/2PMfA2jgAnR2AegU//9/fzOAVgCA1IHcCVriDw5boKfBs/fAVQ6gWwPANyUAtwKAVkiAbhQA3UIAcjPoilVQGDMxMTOAzkcA7f2/c2oyA+gMgj8/P4LDFWQOyHrQaoS3T45Dwp2C+pei8nN09p/MkB/t/I92e0ZDYDQERkNgOITA6ADAsE3HI3Q1wCCOz9EOP2mRQ/MBgcEyOz7QnRG6hgP5AwCMDLCOOyMDaD88aGYc1KEF7beHnmIHnm0HnQUCOhgUdHsDaMb6LXAmWsk4lYGdS5QBdBsI4mgAJgaQOKizCjkx/yODlkM9w6fXVxnk9ePAZ0OABhNA8rAl8SC9oMPtQIfdPbq0hAF0iwSo8ww2ExiPoJlz0PL2H1+eg90C0i+tGcgAOokfuEEefFL+3z8/GEB+kQSejg8aaADdKPD6/j5wJx50DeWhxS4M2g4N4KX4oP3/oI46KxtkOwJo1l3Dphx8KB9oAAGkH7S9gQk4KKFsksEAumufB7jcHnRwIXgFBLBDLqMVwgCyE3RYIGhLAjgcodugQNtbQKsZlE0yGUAHqEpr+DHcPTWVAVRWQXY6MDGAVhqwAO3/9e01w9+/P8FbCcArAYC3JMDOIxCQMASerfIIfMsB+FYCoPmgg/9A9oFWOYAGI74Ct0KAzgIAbWHAPIMFVDbQqXM52vkf7fyP9l9GQ2A0BEZDYISHANNoChiuIQBqTA2x0XoyGmb/GSBwsMYizH2jnX/SY4jmYQdKbwPRGYDZO1D2o0cFsntonpHIKJMYGcGdaX5xXUinGtipBe2RB52UD+kEA6sxRujgAJD+8u4uA+jaO8jp9D8ZmNm4gfv0t4H3sIPurUdeRfAMeN0faNk87E78x1dWgmerQdfXgVYPfHpzgwHRYf0PlgN1cEFyCsC7+EEdYNAWA8hyfQbINoH/oGX/zAygvfOMULfeOzODAbSMHtQpBy3PB3X0QSsFvn18DD4/QAY4e394qScDbEn8ulYuBtCtAiC7z2/LZgBdAygoZcoA2jZw7WAjOJYUgfbDTuAHdajPbskAH1AIOnUffFAhaKUEED+7tZkBdGAgaBCDR1CZAbQiATRQAdqOADqwELRlAOQekFtvHOlggBx4CfQrONyZwXaBViyAwgm0dUDDppKBW0CeATTwAOrggxS8eXSYARQOIPNAKxBA4Q8KE5B6Vg4BBlB4gQY6QIMy6Mv+GckYgBotT+ld443O/I+2lUdDYDQERkNgOIUAI8PoJrwRkKJH8LaAAYjd0cYp7QOdpqsDqDkjPpRnG2m2MoCUVQCQjj2oM6xgkMAAmnXnA+69hyz9ZwLO1l9nUDbNYrh9ciL0kDtGBtDMM2hVAOiEfFCnl5VTkAF8KB9wmTuocwu7xQF2Gj7oqj3QDP3jKyvACRfUWYXvgWeAbhuADkIAe7IMQsCl/KABA1DnG6QBdBAeC/A0ftB+etisO6ijDdrb//nNTfD1kiB1oOXzoAEI0NkBQtLmwD36W8An/YM61qA9/6DDA0F2cwsogjvMW/tlGcyDl4NP+f8OHCj49ukJeAsAyA2gLQcgl4H20oM6+CKy1gwv7+0Bd94FJAzAYXJqfRx4mT3Iv6AD/0CrFX4BbyP49ukxeAUCaGAE5C7QlgfQPv/rh1ohd/RDsy+oMw+6nhB0tz/8KsR/f8FDrqC7/UHbBH79+AC+IQA0KALbFsEnoskAGkABrTrQcWphuLK3GjxwATovATKYAjQDuEIAcpsCA7gJgrhlAa3swJF/yC5j/492ZBlIBqNhxjAKRkNgNARGQ2CYhcDoFoARlaRHBwJoFd2jnf6BzUh0OT8AW4d4JHQoaDIQgL8sQswKQwYAQLPJoI62kIw5cDabgwE0AAC6Qx/Uyfz8+jp4iTsoBYL0gTqZhp6TGEBX8oE6vKB9+Qywmz/As/PArjPYT1A3AMXePj4CTsCgjihsBhwiC5kJBy2TF5KxAK8iAG0JAC3Rh7hJlAF0jeDT6+vAAxCQZfOMDKDVAaC97pq2lQyvgbPjoIEI8+ClDNIaAeCDBkHbDECn9//5+ZkB5EYOHgngsv63DMdXhTDIaIcx7Jquw2AZtgbccf728SH4vAHQDD3IbSB7ZbSCwcvtQTPsoMEB0B58UBkEygeg2wFA1/CB1IMGHUDhAdqGAFoFABq4gNyU8h98UCBoewTozIEXwKsuQeEJuzYVdE0hiA2SA9kHMhu0rQKkl5WNhwF0EwB4OwDwYEWbqK0MDy8uAl9fKKXhD96eAboaUNEomeH6oWYGkB9Bhx7qOrcBVwkYMoAOJZRQdgNvsYBsxyCtgzna+adnWTva+R/t9YyGwGgIjIbAcAyB0RUAIy5dj5xBAFjU0qJzONrhH9wZh24HCo6k8oOqAwEkDAAwMECW/jOzMoA6zRIqngyvHx4EdyRBV8mBZsZBp9GDOs6gfew/v7wEaWCQ041mAHXMQR1YLuCSdVBUgTrvoJnzn8D97CA+8rkCkKhE7fCAl/YDl9GrmucxgO7S//jyMniWHbQXHzRbz4B0pSioww1ZFcDIANqH//vHRwbQtXzSmsHgvf+gcwXePTkJ3kcP6rgbeU1hAC25B3W8QdfsgfbHg67JA92pD1rx8BN4jz9oFcPJtVEMQdXfGK4fbmcAzbJ/BJ5RAOpUg7YD/AevavjHoGKWwwA6gR90oN9D4NkEoMP3QAcDPgd27EFmgFYVgK7qA9kB1gOaxwfO5oPcD9o+ALnq8h8DrFwDhQuoMw+atQetTAD5+/O72+DtEFz88gx6rl0MNw63gc8HAJ3sD/I36EBC0MABaKDmBzAOQIMVbMDl/6DVGKCBGj4RDfBKDBAbNCgBPgsBuEUCRMPcgZKdRmf/B7h0Ge38j3Z7RkNgNARGQ2C4hsDoCoARm7ZH3kAALKpJ6RyOdvSHfgYZHQygYhzSaRAAdV84IwNsphh0aN+DCwsYQEvOwRi4BB10uB7oajnQzLIhsFMN2o8OWRlwjQGyzJ8ZvKQedFCdmJIzw7vHx+F79cEhA/cTYkUATBykH7SlAHRq/d9fXxkkVD0ZvgLPGIDvnPsPPWuFkQF6AKEOeCYcvNQdeMMAaHk9aPb/OfAUfdBgBWigAuQ20Mn9H19dAc/6g07HBy3LB++nB5p3bmsm8Ko8S/BgB2gvvbx+LMODiwsZQPKgGXzQcv5/wIMEQWcICIjrM4Cu3AOZATrg8MXtbQyCksYMoKsGQXv7QQMioNl30FkD4FsAwAMWsBzxHxIODKCrUaGdPXin+z/D57c3wX4BbSkADaCABh9AKxdAKypANx58fnsbvOoBMsP/BezmT8DVGKCrCkFbH0BhABoAgAy2/GeAbMn4zSAgoc8AHvAAbkUADVSA/AXaBkFMKh2d/adXeTza+R/t9oyGwGgIjIbAcA6B0QGAEZ++R+5AwGjRNjJDYHRAgArxTpWBABJWAQDtkwWeZv/qwX7wDDzo2rznwMPtOHilwIMBoI6xiJwNw/1zc4Ed5R/AZejqwMP/uMAn6XNwiwKXu0czgJa5g7cL/P4KOeiOAbK8HxIaqG6BdDQRnSDQbDpozzxoOT5o5h05BEGz56A0xc4jzgAajADNiEP26DOA9+C/vLuTQcEgkcHIexrDs1tbwGrAd///+gJSwPDj6yvw+AboUMOfX18zgLYagFzz7tkpBrB9oCv6gAMdbMCr/kCDHkLAwwBBh/aJKjgwwM4AAF/hB5yZB+29//bhAQOoQ/3m8VEGhK+APoKuVgANaLCw8zKADgEEHUj47OYmBtDKA/BNB9ABDdBWCJjed09OMHx8cQG4peISeMAAdjMC+BwG4Ay+qLwdA+iwRND2BtDKjN8/3jOABg3+A28JAG0VAIUVyL2glQGgVRLswPgADVg8u7kRvLUBNFBA05JodN8/icE72vkfbRuMhsBoCIyGwHAPgdEBgNE0Dg2B0YGA0aQwMkNgdECAgnineCAAd7nDiDYzD5rVBs0mg2bFv396CjnY7/9fBtjVdqBZafCRfUysDCzAk/9Bs+TgZfLAe/PfvzjPALoG7/+/XwygO+xBp9qDVwcA7UDQTAwuaacZ7p2dBZ0ZhxwACOq0KhomM/AIKQGv/RMCH3oHOiAPdBWhpJoPA6iDDApBGeBSf9C9+iD3gZbJCwPPDAC5WcEwEXxw4P3zcxlA+kBbA0CrCUDL5UFbAUDX9IFWMICu8JNW9wcf9MfKKQC+yeDGkXagvarADv03BtCWAFDHHrR//sm11Qy8QioMt070g7cXgG5FAB1CCFplALotAbzVAXTeAbCDLq0ZxAA6JBC0hQEU2qAr+ZySjjBc3FXKAFqW/+HlBQZOXmnwbD9ohcJ/pFUAID7svAVwTAHDS9U8H3xVooJeLANoFQIoDJ4DVx68fngAPOAhruTK8Of3FwbQIANoAABkB2hgBLSSAXQLAOg8BXZucfDtB6ABD/D1iOiddCyd9tHVWPQon0c7/6PtgNEQGA2B0RAYCSEwOgAwms6RQoBxaIYGI+NoLI6GANVCYHRAgMSgpCj/ET8AALtrH9Qhhezl/w85eA/YyTX2mcHw6v5+BjFFJ/B99KCl707JxxlAKwNAs+igzrYw8OR90J32oKXyIB+C9q3zCKuBVwmAOs6gu/RBnfkfn58Dpf/BAwG0l50TuNLg3bMzDKAl66BZbtAy/C/vbjG8eXiYAbICgAE86AC6Yu/r+/vA8wciGO6fnw/uEIOW33/9cA+8f/4P8FwAkPtBAwGgU/BBZn98eZEBZBaocw/qpINm+Vk5+BlA+/VBp+h/BtojpuAIPDTvNgPoRH7QAX+gAQPQ9oI3j44yvAKe/g86YBB0CwD4vAM+WQZReRtwJx20t15c2RV8ewJo77+UZgDDp1dXGe6dm8MAWnEA6rjDtlL8ga5IQN3eAA0GaDSB8oawrCUDaPsCyH2glQeglRVC0qbA8wDugf378fUV8CGBX9/dYQCZBRq0AW17AN0aAFoF8O7pSWAcPWH4+h4UJl8ZEOco0KDzOTr7T0JmHu38j1ajoyEwGgKjITBSQmB0AGA0rWMJgdGBgNFkMRoCsBAYHRAgMi2QNRBAygAAI/j6OlBnHqQL1hkFdWBBB9xBVgIwgAcFQJ1j0L59QeCVfaCOp6ZtFbBTepdBXMkFfJifhIoHgxLwlHrQrDnoMD9Q5xt8UCDQD6BZ+HdPT0M9De0UAQ8CBHXiQYMGoJUGoNl/0PJ5SKebkQE08w9alQBacQBaAQAagIDcxc/IADrhH7LMHbEMHzRQ8fvnRwbQgX+gAwNBp+2DZsxB+/lB1+iB9t+DVgd8AK5cuA9ckQCSAzkItKceNMgAuuEAtLoA5GfQAX+ggQPQzQDgAQTgEnzQLD9oqwDIf6CONuguftCgBWjAAhRNID1iis7AQQXoNYXA7QEgN31+cwPcaWfA1nEGBrqBRz/D7RMTGUA3CoAOYwSttAB18kFhzQC9IhA8gPAfeq4AI+TGBdAACihOQGchQNx1lUEFeH3jq/v7GOADDrBkNjr7PwCF72jnf7TGGw2B0RAYDYGRFAKjAwCj6R1PCAzhmfXRVQGjKZuGITA6KIAjcKk4CIC+BQDS8Qf1KJnAS9dBd9CDlpCDOvD/gEv7eQQVGUB8s6AlwD33CeCD8358eQ6eeX/39BRwVtyWAXRnPqgzDhoweP3oEANo5ho0Yw/aSw8SAx2UB1pJAJ6Vhqx5Bx8k+Ov7GwZx4NV1bJxCDJ9fX2MAqQXNvINCATTrziemDV66D75yEKQPdM898HA90J3/oLMJvn18xABaKg/aegDq7IMGE0B2gK7V+w683x90KB6o8w2apf/26RF4EAO0XB40Sw/amw8aDAAFLagj//HFRfBVe6CtAK8fHGTQdekAL8V/dGkpeJsDqHMOOh/hO3AlA+gEf1AYgDrfoMGAf3++gw9EFJQ0BF7R1wQ+zZ8LuGLgE/BAQhWzbPCtCeAT+RkwO4Sg+IANmIjIWTNw88uBbwEA7e9n4xRkAN3GwIBjxh105gGPkDIDaDDm89sbDCD1oEET0EAKeOsCnrw6evAfrYvy0c7/aGU5GgKjITAaAiMtBEYHAEbTPBEhMDoQMJpMRkOAUAiMDgpAQ4jkQQDs5QuuAQCzoMXgE+r/ApesgzqQoD3koBPmQZ1KeYN48MF4Z7ekMYDuwIecvP8H3EF+C7yCD7bMHWQ2aOk+6MA80JkAoBPuvwBPtQftpQcfhscAuXhAQtWDAXK2AAN4yTqoAw/xJaLTpAycyQbZDzoMD3RdHlgnKAyA5xOADu7j4BGDuAU4IPAFuiwedJf+P+DhfurWpQxvgJ34bx8fgK8uZGZmZwBfiwe0BLQyANQ5/v3zAwOPoBID6KYA0NYH0L58EP360WHoagdVhvfAFQugrQ2gVQeg2X/QQAEoXEBbIEB+/gI80R808MENNAe0DJ9fXIcBNKgAuroPZDZoJcPDi4sZwPvx0Tv/SJ160BYGkPmgpf9vgUv5QYMfb4GHDYK2AzD8R7pNACWz/Afv9wdtPYCsDvgP9uP3j4/BqzH+/8d2CwGF5c3o0n8iA3C08z9as42GwGgIjIbASAyB0QGA0XRPQggwDu3QGl0VMJra6RwCI3pQgKT8hlq2YF4DCJEHdThBnX7QXn12bjEG0Gw5SAy0vB10WB+oMwmaUQft1QfPfn9+xgCaVZfTjWR4D9zDDzqhH3RCPWgJPKgzLiRtBtzPfgl8awDofADQNYNvHh5kAHVUQeaC1IJmz0EddBAflHwgbmNkgHVcH19ZzqBhU87w6PIy8FYAJuAhhHqunQzPb25mAO1/B12NB9rTD+qkgwYXhGUtgEvouYDd7H8MsAMNQWaD7vAHbSEAdbBBBxZ+fnuLAXzdHysnuAMNWjnAzMwGXn4PunqPAXpiP2i7AeicAQawq/8xQAYw/jOAwgNk5h/gVgPQ6gnQgANoJQPITR+en2OAhNVj8H59UAcedB4BfLYdZwca0mEErZgAXff39NpaSDhA3YKcvf5jmPEfGq4M4IMLQQMQkOX/0E7o6NJ/OpdOo53/0QpxNARGQ2A0BEZqCDCNRv1oCBAfApAG3JANMVADE4ZHo300BOgQAqAOFToeMQFPxVlYyO5/yM7/m8d6wAfkgWa8eUU0wIfvgbYBgGb81SwKGUAdXVDnEzRbD1q2D9o/D7oeELR/H9S5Bt1Rzy+uxwDqUINm90Gn998/Nxt8j/+1g80MIL1gDOyigw68Ax1aBxp0EFdyBneqQXaBBg4gqwv+MoBm1W+fmAA+RR90XaCcTgTD2S0Z4I4xaFUCKL5B1w/COrugffigmXmQe0GDEqAO+59fXxlAp+PfOzODAWQuaJ8/SBw0Qw+61x+0VQB8Ij9wUAV0vz/QIWC3cABP0wepBXXwQUvqQSsZQIMWDNDBF9uY7cD79/kZQCsLQO4Adfr/AW9F4AYuxwetWABtmQCtfAB16OHL91HiDVbmI3UWgfKvHhxguHm0mwExew+Rh4cdnrhHqPkH1c/AwEDNGfv/ox1bwmXMaBiNVoCjITAaAqMhMJJDALxbcTQJjIYAeSHAODwCbnRlwGgGGAQhMGxXCxCVv/CsAAAewAc6LA+0//7Hl5cMjkmHGQ4udGIAnYQPOuAO1CE39JrCAOqEgw7cA+25F5AwZHh5bzfDhe15DFLqfuAl56AT9EEdfi4BBfBedNAAAOwkfgj9D3EiPdDNoIPr/vz+xiCrHcYAmmVX0I9nAB04+Bx4lz/oSj7QdX6QKwSZwfvqQYMRoL3+sGXuoE46aN876Io98D53oJmgTj9oST5odh60UgDUaQepA61SAA0UgbYSgNwpoeLO8PjqKgaYG0HL6/nEdMCHBoIGH+6cngY+m4CZlQs88MAroglcTn+WQQZ45d/TGxsYZLRCgdcZzmQAHSgIMpeZhRN4S8JeBvDBhAyIzjoDA2L2HTz7D+88E99B/E9yhxvNbBz6ydr7P9r5Zxjt/I9WZ6MhMBoCoyEwGgKEQmB0C8BoGqFCCDAOn1AcHQwYzRGDKASG1aAAwbyFKEeQ9/+DlseD7tQHdf6ZgFf+Pb2+DtyRBZ2iD+rQgjrYoFl/0Ay/oJQxw0/gIAFo9h+0FUAWOBv/+d1tBtC9+7++vQGvDgDvowfuzwd1wEEdYMiSecg+dFinE+QSUGf8z++vDKCBANDp+28eH2MAnbwPujHg17e3DODrAflkGDh5JCEHAAL36oPiC9aRBnXuQQfs/f//B7wsH7RlAbT8HmSfiKwV+FwCkFna9nUMoNPwQYMAoPMDQHKgq/4gZwH8ZwAt+wed9g9yN+hKQ9DhhaCBBFDnX8exieHDiwtgzCusCjxo0Bc8aPDw0hIG0H5+ULjwCqkygNwAuZbvHwOkw/4fPuuOuuyfcMcff4efxJllanb+R0suIkJgdOZ/NJmMhsBoCIyGwGgIMDCMDgCMpgIqhgDj8AvN0QGB0RwyCENgyA4M4M1PuAYAGBm+A0/z5xaQBx+Gp2Vfy/Dy7i7wbD2oMw26U//jq0sMoAEB0In+zCzs4FP6QZ108PWAf36CO8OsHHzgGwHEFBzAB/qBOtucfFIMoE64PHB2H9zJ/voS2jH+z/D712dwzLOy84JP3Qff/Q88TA+0HB80Mw9yLaiTDhqg0AZ2xEHL4sFbFYArFsArCoBL7UEH+LEDbw4AXe8HWoYPchNo0EFaM5ABtFoAtBIAtLIBtBQfpAZkLuhsgj9gu/8zMDEygw81BJ2wD14lAB5M+MsAcitodQJoj//TG+vBYQEKhzcPDzHwi+sygK/lA3auVcxzwX4ArSYA7/EHd7gRnUDCe/4hiZ+qnX5YfqJ253909p9ASTXa+R+tzEZDYDQERkNgNAQgITA6ADCaEmgQAozDN1RHBwRGc8wgDoEhMTBAxCAA7KA98MF7wA41J48EAzuXKBi/uLsTvAIAdJAf6Ko70N540OAAaL886MR9UEcXdO0c6Kq798/OMoA64aDO/O/v7xhAeviAJ+CDDhEEXZf3H7wSgIUB1KmX0vBneP1gP0rsKhgkMjy/tZXhB/AwwU+vLjNoOzQw6Di1MNw9Mx08UAC6qo+LVxo8iMDOLQq+hhDUof/z6xNYHrTfHjTrD3L7989PIHvegafev318HHgFoTkD6BYCkBmv7u9lgKxGAHbu//2G3AgAPPwPcn7BbAYuflkGUGcdtBVCTjcKvNwfNCDwBnwTwF9wePz6+poBdNjgyzs7IIMjQHtAKwlA5wzATuiHBD1k9h+z84/ZQaRnx3+0YKFlCIx2/kfT12gIjIbAaAiMhgAiBEbPABhNDTQMAcaREbqjgwKjuWgQh8CgHBQgMAgAHgAAdvxBy+FNAxYyHJhvxwBa3i8oZcLw4vZ28Aw/aJYcdAgd6KA/0D32vMLqDKAl+6DZ+LObUhlAnWfQmQCgGXUO4DJ9UGcbJA86fR7cof73l4ET2LEGXY8H6rSDrsID34GPNJOMPhAB2TPPyABzH4+gMgPo0D0dp2aGYyuDGUD2ge/b/wtcdcDAyAC6Ix80iAFasg+a7QetOgANOkA65Azg6wFBWxdgh/qBthtArgpkZODkk2YQlrFkeAvcegBy77unpxhAgwWgpAY6yBC8BeI/5LR/kJ9AqyHAh/IBO/6wbQjgWX/gSgTIYX0M4EEJiNhfBkIDALg7/xR0JgnM0pO175+BgYFhdPYfTwk02vkfraBGQ2A0BEZDYDQEUENg9BaA0RRBwxAANTxgeBgH9H/IjBoDNno0fY2GwACHAPotBGR3sqjpD0IdQWheAs22759nDZ6h//L+HsMz4NV6P76+YgAdkgfqtIP2uL+4vY0BdMgdaAb+46srDEeX+4Fn5MF75j88BB/cBxogAO2Zl9ePA+/H/woUB83OgzrYoA466Ko+EA3fH88AKbcgJ9b/Y0DtSEM7VEA3gk/nB3a4Dy/1ZgAt4Qefsg/s/MNOx5dQdmMAHUjIJ6oJvmUANAgAORcAshdfw6aCAdT5B90AoGlbxQAaIAAdagha1QA5of8WcLDjPvgQQtAhg6AtDtzAQQfQtgWwWuAgCWhrAWhLAeyaQpB54orODFzALROattUMInK24EMKQVsENO1qGEDhxoBnAAZ2Sj/26CazMwkrG/GkodHOPy0KitHO/2gFNBoCoyEwGgKjIYAZAqMrAEZTBZ1DgHE0xLGFwOgqgtF0McAhMGArBbCmfegsO3AWHdZZBbkP1KkFzdiDlvvDZ32B+g3c+8EH6T0HDgaAruUDzdCD9s2DDsADXbkHGhwA3RgA6vRDZt8ZwcvsQUvqQbPnYHGG/wzIZiKiA9UtoI42aDABfGgfsAMOGoz4+PISeKABpB/WkQWdGQA6sf/7p6cMoFl+Ge1QBtAsPujQPvA9/kB3g1ctAPf7g840kFD1YmBl4wXfyw9zJ2wgAdT5Bw02gK78+/39PcPz21sZQGIgt4CuNATdLAAKly/v7jIwQE/2B90aANLDB7wq8QXwzATQFYEsQPNB4fDrxwfINgG4nxEdRarN/JMwK0/RoNTo7D+OkmO08z9aqYyGwGgIjIbAaAhgD4HRAYDRlDFAITA6EDCa9KgQAqMDJzRLRnQdEMA7CADzIiN4JhvEgyyjh3ZwgHpBM+iQ5e//GSADBozgTjeogw9ahg9aqv/+xXmGf8ADARF310OW4KOYhR6aUHdBZtchgwbqVqXAcwE2A5foy4KX54OX+DOzQnTCO6P/wcv71W3KGUArEcBnEQA73aDBCdBS/ffPz4HVc/HLMQiI6zGAziN48+goeAsDzI2wbQagGwxAHWTQbQMs7HzgmwhAhwyCVgrwCquBV0fwAG8AAA00qFkWMZzdks4AWh0A8jvIXNBgAogNGjQBDXaABgogBwJC7+FHOhiQKp1/Ejvko51/WmTh0c7/aP06GgKjITAaAqMhgDsERg8BHE0dgyAERgcDRpMhHUJgdLCA7ECmy2AAgfgBS/+H3dWP3MH5z4Do/IO8+B+8Rx/UQZbVCQNfiwdicwAP6QNfAQjcEw8LCHDnnwGzswT3L3wAgBHcoQd19sEn8P/6Aj7AD2wOI1LoQBwJdg+oMw26evA3sOOvZJLGAOrsP7u5kQG0IgF2KB9IjldUg+HG4TYGZjZuBm5+efBWAlAHHjSoAbrXH3SmwH/wjQKfGH58fcEAubbwP4Oogj1wcOE5eBBCWMYcvA0CdCvAC+AhgKDrEsEhAT3kkAk2QAFcUcEjpMwAWgFg7DOD4cWd7eADBCFqcXUaiexM0nsmfnTmH0d+Hu38j9anoyEwGgKjITAaAvhDYHQAYDSFDKIQGB0IGE2OAxQCo4MDJAU8zQYEcKwEwOY4RjxxBuqog24CAM16q5hmM0hp+IEP6ANtEQCftg/r9KN3ItHMBJdIwGX+oA60Z95thsdXVoA78GqWxQwfXl5gEJIyZQAtvwdfCwhUB16SL6YDvDXgOdCGfwygk/lBgw6gJf7fPz8Fq2Vg+Af2DmQlwj8GUAefnUsYPGgAWrIPXlHAxMygblXM8ObhYfDZAbAl++AtBv//g88k+PL+LgPoTAHQ+QKgWw0+v7sF7tCD3Cyh4sHAys7PADpXALTtALQFwSn5KMPDS0ugQQm8YhA4KAA6G+E/0oAIZjgT0ZmkoCM+KM6jGFaF7mjnf7QOHQ2B0RAYDYHRECAcAqMDAKOpZBCGwOhAwGiyHCQhMDowQDAiqD4YQMIgAMhxmAMBjOC9/KAT/wUljRhA+985gVf1ge7I//zmBrhjTvDUeCQ3gMwHncgPOnUftNefnUsEeLo/G3j2HTTD/+/vD/B9/RJqXgwc3OIM/MABgHfPTjOguw18awHDf+gNAqBQY2RAbEeA3PkP2q4gruIGHmT48Pw8cEvAF4Zf394y/ANfDcjAwMUnwyAiaw0+JwB0UODvn58Yfn55yQBig1YVgFYNgFc7AK9N5BJUYLh/fh54iwFoAAM0CAFy0+8fH8HbEkBmgQYfYDcSYEY0gc4khTPwo0v/qV3GjXb+R+vN0RAYDYHREBgNAeJCYHQAYDSlDPIQGB0MGE2igywERgcFcEYIVQcDKBoIYATPnIspOgEHAHYygO7G/wKcIce73x/dV7Dl/0Bx0Cz/57c3GUBL8y1CVzI8uLCAQdEwiQF0wN6HFxcZQB1s0CF7n9/eYnj1YD98mT7o8EF+cV2Gn8CbCxihKwRAZxSArgUEyYH39wOX6YNWJei5dgHPAuAALuk/ygC6/vD3r0/gzj/i2sD/DH9/f2X4+e01g1PSUYa7p6dB7/v/ywA7+A90I4CiUTLDy7u7GUBXBYKuQgTt+X9+azPDB+AZCCJyNgzfPj4Cr0T4+PIyA2wLBObefzydSSosvR+d+ad2mTba+R+tJ0dDYDQERkNgNASID4HRawBHU8sgD4H/8MbtaFSNhsCgCAFQBwgZj0YLPAT+M/xnoFrnDmtHE3d5gHp93X/w3va7Z2cywO7HB10ZCNt7z8AAMweZxh2RILNBh/NJqfsxXD/UwgA63f/zu9vAk/jVGUAdeXZuMeB1fQ8YZLSCwbPxsE476IT+b8ArB+X1ohlAB/WBluyb+M1hAO3VB20bgJ9dADzb4OLOIoan19eDBy5YOQQY2LlEGUCdd9A5AOAVANDwYGJmZzi40AksL6cbyQDZFgC5qhB01R9o2wO3oCLYHJB+kJ+lNYMZtBwawKsWQFcIGnhMxBNPODqTsDRPYXqnOH2M7v1Hi4HRzv9oETwaAqMhMBoCoyFAWgiMrgAYTTFDMARGVwWMJttBHAKjKwRQIofiVQEEwxNXefCfgbySAkkXI2SpPiMTE7hDDdpWALpH//65OQy20dsYLu4qZQAd5Pfz60vwsvrXDw/BZ//BNweA9usD99h//XCfAbQNAbTHH7RfHzQYAdpKwACc/f/98zMDbAZfzbIQvGLh55cXDKDZ+68f7jGAbhAABSjoRH8t+zqGt0+OM4AGCP79+QG+ehB0xgBsS8Of318YQFcMgrY6gNz38OJiBh4hFYan19aABxN+A68cBG1TuHd2BgNiMISIvESlTvdo55+a5dZox3+0HhwNgdEQGA2B0RAgLwRGVwCMppwhGAKjqwJGk+0gDoHRFQIokUPxqgCCnU/cs/iwVQGoqwMIpR3MjhXoQD3QHfw/v75mAF23B+mIn2AAzaaDlviDtgZo2ddDDQb6GOpm0B59STUfBpDeR5eXgm8CAB3oB9o6ALoVADQgAO78gwYKgIMBN450gK8qFFNyZnh1fx/Q/J/gcwJAh/jxCKkCl/1PZwDd5Q+61hAk9uXtbQZI5/8/5OaBf38ZQPf8A08HBJ99wMzCzgA6p4CDV4pBQMIQvKUAtAoBOQRQl/9j6VQOls7/aKGHFAKjnf/R5DAaAqMhMBoCoyFAfgiMrgAYTT3DJARGVwWMJuUhEAKjqwMYKFoRQHL4ES4XGAmYCZK3T9jPcOfUZODe+a/A5fvywFn4k8AT93cCO+vfgbcBXAJ27GUZQCfqswLv6Qft0Qcvywee9g/aNgBaCSCnG83wD3qVH2jFwNcPDxhAHf8fX55D9vGDtiT8hwxkgDrk75+fhXfsQR19Nk5Bht/f3zHoOLcwcAsqMYgrQgYIQDcd/Pj8DHqYICT9g9wLGnRA7PW/xKANXP5/+8QEBpA5oMEHkBv//PqKlmEGeed/dOk/NL5GO/+jdd1oCIyGwGgIjIYAZSHAyMDAMFqbjKaiYRYCo4MBo0l6dDBgsIcA2QMBZA+ikDsYANQH3QoADlPQYX7Aa/pABwy+eXQEuIr/N/DwPi4GCRV34EF7Fxi+vL8HUQYc6gAt2xeSsWCA7MX/DzzV/xuDtIY/eCYfdE4A7AyA/2gDAKDl+bDl8qBwkjeIB24hkAIf4Pfp9XWweaCtCK/u70V0/pE7yEA3cgBvAgB19MHX/IHkgH4QlrUCm/H90xPo2Qiw6h+tGUDFzjZVzoQY7fxDs/Noc220bhsNgdEQGA2B0RCgPARGBwBGU9EwDoHRgYDR5D1EQmAErwwgayCAovAiZyAAMggASk3gUwGAAwA6zm0MV/fXgw/9Y4B2+SHj6QjzwecAADvjwsBBgA8vLwJXDyiCZ/xBHXPQOQCwWwngnWT4KoB/kI498HBAkNGgVQGgmX3QUn4ZrRAG0Gy+nG4U8DaChQywa/yQO9rgMGVkxDo4AHITZMABZAeO7VRU6HD/p+bcwugAAMPoXM1obTYaAqMhMBoCoyFArRAYHQAYTUsjJARGBwNGk/oQCYEROhgw+AcCoGUIbDUAI+wIHeRZWUYGxJYCxMoB8L57oHrQgXxMTKwMoCX6z25sAM/GI6dK0MF/gpJGDKCT/D88P8+AvEoAMsbACL7dANQZBO/dBw4QYO1oo3SYMWeNEfv+abPsf7TzT+2yZnTmf7T+Gg2B0RAYDYHREKBeCIwOAIymphEYAqODAaPJfoiEwAgbDBjcgwBI5QY0XuDuRYkn2CAA0tYB0LYBkBogrWSUCpy5n8/AwIA+oMDIABocYOMSZgBdK/jxxUWGv39/MsCW8P+Hrwb4B028/yFXACLPtBPo+IM0jnb+h1rpN9r5H62vRkNgNARGQ2A0BKgbAqMDAKMpaoSHwOhgwGgWGAIhMDoQQDiSyA4jwmUAyqw+zCU4BwGgAwCgTj8DZBAA1NlnhA4AQJbnM0FXCqAPEjCBzxNgYmYFH/YHus7vx5eXDLCtAvCZf/iZAQwMqNsHYI7DN+uPQ81gW/YPcuaIXvo/2vEfrZtGQ2A0BEZDYDQEaBMCo9cAjqasER4CsD2wo42t0awwiEPgP2S2l2GEdIjIWkJOdtiQkveR1ELtw9oBB3b+QUv5GZlYgB19ZgbQSf4MsAEBbMkMODigZJwG3BLwEDwwADpgELRdQFY7jAF0lR/BlRF4Zv6xX4GI5ufRzv8gy/yj9dFofTQaAqMhMBoCoyFAuxAYvQZwNHWNhgBGCIyuChhNFEMgBEbIqgD6bQvAn+/xrQIApRbYwXuM4OX+TAwcvJIMf35+YuAVVmNg5xJi+P3jIwP4IDfoLQKM0G0BsBUBIDk+MR3wCf+gU/r//vnOALpF4Nunx5BbBMCWIIUGVuciOo7/cXbqqd+5/E/ty4RGZ/5Hi+DREBgNgdEQGA2B0RCgWQiMrgAYTVyjIYARAqOrAkYTxRAIgRGyKoB+qwGI7RhjrgJApBZGBj3XLuAeflGGf39/MYA69L+A9/dLawQCdwEwglcDgGb0BSWNGUDX9DECl/ozQAcMWNh4GL59eMDw/tkZBhY2XoZ/f34yvH10lEHdspgBsoUAuD2AhZNB066GAXy7AHx7AWZaJanzT2Fn+//oTcJULCxGZ/5H657REBgNgdEQGA0B2ofA6AqA0VQ2GgJEh8DoyoDRxDLIQ2CYrwqgz2oA7PmcEe2gP3hKQD4LAMh+fX8/g4ZNBRCXMwhKGTO8fXKcgZWDn+HT62sMrOx8DELSZgwK+nEMP76+YODil2X48fkZeNn/r+9vwXv92TgEGX7//AjGvEKqwAMDF4CtAt0kwMLKCV5V8PPrSwYxBQcGNYtChue3txGZKKnbuaRZx3/Ezv6Pdv5H65fREBgNgdEQGA0B+oTA6CGAoyltNATICoHRwYDRhDOIQ2AYDwTQfhCAhAEApHCGbQEAneTPLajIwCeqzfDl/V3g0v8P4NUAoNQiKGXC8PX9ffCZAG8fH2XgF9NlAC31B53wD9kSwAxeKQDig1YAgA7/+/f3N3BFADeDtkMjw9UD9eCbAti5RRn4xfUYHl5cDL4lAHJDAKQDiX32H0fnkszO9mjnn5p5f7TjP1qXjIbAaAiMhsBoCNA3BEZXAIymuNEQoDgERgcDRhPRIA2BYToQMPCDAIgr/EAxz4i0HJ+DVwo4u/+S4c+vz+DOPbeAAnAQ4D04gfwEnugPOhxQ2TST4eOrywzKZtkMH19eZhCQ0Gf4+fU1A+gcANDBgRzc4uD9/3+A5waABgZ4RTQZ3jw8xACyh4WDjwFi5kfg+QIqDF/e3gbrIzkFjnb+B0GmHe38j9YdoyEwGgKjITAaAvQPgdEzAEZT3WgIUBwCo2cGjCaiQRoCsHMChlkE/Wf4z0DyLDRJYUGoY4aQRx2MYAQu6X8OnqUH7dv/DTwE8MfXVwzywCX/wKl6BtBM/YcXFxhe3NnBAJK/f3Y2A2hA4O/vbwwG7n0MoM6/iJw1A+hcAAlldzAfxP789iZ4UOHfP9BqAB6wOL+4LnB7wUnwNgNY9JI0+09Gmhjd70/NjDTa+R+tN0ZDYDQERkNgNAQGJgRGtwCMprzREKBZCIyuDBhNXIMsBIbhigDarQbAzL8oNwEwMiIO44NGM0QeIg7as8/IyAzurIPZwCsBQdcBwpb6gzr7oFP+ZTSDGJ7e2ABcLfADOEbwF3ztH2iggImZneHHl+dgMaBFYFoFuGLgwYUF4AEG0DkBv358YAANLIC2CYBWD9By+T9NO/8jbt//aOd/tG4YDYHREBgNgdEQGLgQGF0BMJr6RkOAZiEwujJgNHENshAYhisCyL4l4D/xs/zYYhE08MDBI8kgImfDAOnsM4EP+AN17BmgAy28IuoMEqqe4NP/1SyLGDiB2wNAHXtOPmnwvv7///4CO/8bwR16VfM8BlEFewZQJ55XWJ0BdHsAaABBTNEJOCjACe7og7YGiCu5MPwEHhjIAzwg8P+/Pwz/gBh3KqN87z9Zqy1ISfYjqvMPqxNGS8bREBgNgdEQGA2B0RAYuBAYPQNgNPWNhgBdQ2B0VcBoghtEITCMVgSQtRIAFBV4wwA1vyKvAGBkYmIw8Z3N8OLuTuCVfT8YnFNPAffzX2T49vERuLMuIGHIIKsTATzpX57h/dNTDF/e3QGvGJBQdgMv52dmZgMeAqjDICpvz/D1w33wLQGSat4MoG0Dv3+8B18DCJrV/wE88Z9HSAlo7mPg1oHtDKAtBKArBr9/egK+NYCWqYnmS/5HXOd/tPQbDYHREBgNgdEQGA2BgQ+B0RUAo6lwNAToGgKjqwJGE9wgCoFhtCKA7M4q3k4o0l5/+EABIwNshv/8jnzwQX+g2fsDCxwY3jw6Aj6oD7QiAHSCP+iu/3dPT4K3Afz78wN4aJ8aw8u7uxj+/voKnrln5xZjeHlvD3hggFdYDZwwQAMIoEEAkH90ndvAWwIUjVIYGMD37TNCTj8ArhyAnPwPEsbmRgaoeixpjchO9+h+f2rm09El/6Pl/mgIjIbAaAiMhsDgCYHRMwBGU+NoCAyKEBhdGTCaEAdBCAyDFQHUXwmAyJvoe/yZWDgYRGStGNg4hRhYgHf8g5bts3MKMzy+tpqBhZULHKEgcVCHH7bnn0dQmeHx1ZUM6tblwFn/q8DT/rmAWwBYwFcFgvbyc/BKMrACzXr94CADEws7+PR/Ln55BmngWQGvHxwArgR4CBx0+MkA2fP/D0jBOpcQGnEOAPnL/+nS+R8xs/+jnf/Rsn00BEZDYDQERkNgcIXA6AqA0RQ5GgKDIgRGVwaMJsRBEALDYEUA9VcCIHfgIAf8mQbMB87qswKv7zNgUDJOB+7Xf8/w6dUVhm8fHjA8v70VvOcftEz/75+f4L38oNl668iNDKDO/y/g8n5JNV8G0GCCdeQmoJgSePCAhY0X3PEHnf7//tkZBjXLQvBKAV4RDQYmZlaG57c2Qw4UBB0sCB6oYWRAvn6QqNRDRKd7tPNPrXw4ut9/tEwfDYHREBgNgdEQGJwhMHoGwGjKHA2BQR0CoysDRhPoAIXAEF8NQPZKAFBwY/gdkg9B+/5Bh/79/PaG4eeXF+DD+Th4xBi4gTP03z8/Y/gFFAcd3CerHQae2f/28SEDaBsAGwc/w9NraxkEpU0Zvry/C57xBx0A+PrBfgYVsxzwmQA3j3YxCANXE4D0/P71mQG0dUDJOA24ukCYAXQmAGh1AWhVAegAQJATmYC3CkioeDB8fX+PgVqd9tHOP7Xy2uis/2i5PRoCoyEwGgKjITB4Q2B0BcBo6hwNgUEdAqMrA0YT6ACFwBBfDUBRZxZjphzaofv/D7zPH7QU/+e31ww8QioMr+7vA8/ygzrozKzc4IP5GIEz9iA1oCv6FA0TGUBbBf7+/Qnc778beCigHAMrcEAAtCoAdJL/0xsbwWKgWGZh4wGvJmBm4QSfEfDsxkbwYAHIXGFZa4Zvnx4zcAsqgm8N0HFqZQANOoAGGMBrARhB1TkjAyOugRsCs/+jnX9q5bPRzv9omT0aAqMhMBoCoyEwuENg9AyA0RQ6GgJDMgRGVwaMJlw6h8AQXRFA7ZUAsHMAQAcBgq7lUzbNYnhwfh64w84vpsPw5/dXhvfPzoI74vxiuuBOO2j/PxMTK3iGHzRQIChpCOy8PwevDhAQ12MQU3IGngdwneHJtTUMoAGDizuLwXJ8YtoM987OBt8y8O/fb+A1g+YMn99cZwBdDfjs5iYGQSkT4OqADwzs3OLAlQB3GT68vAS+gQByDgBaRxTPAMBo558aeWm04z9aJo+GwGgIjIbAaAgMjRAYHQAYTamjITDkQ2B0MGA0EdMxBIbgQAD1DgaEbgWA7sEHDQKwAvfug+71/wJcis/JIwncr88GvNbvAfhk/98/PzLoufUw3D01lUFON4rh9cODDNwCiuCr/kCrB/7+/sagalHA8AnYqf/85ibDT+CVf6DBAtChf48uL2P48+sL8HDAnwzsXCLgawBBNwuAVgmAYht0UCDwUAAGflFt8MoC0I0C3z89Ba4geMuAMQAw2vmncQYZ7fyPlsGjITAaAqMhMBoCQycERs8AGE2toyEwrEJgdDBgNEHTIQRGBwFgNwEy6Dq3MoCW+/8B7tsHXd8HOuQPEgP/GUB79J8AbwQAnQnw4vZ2BtAp/6AVAqCtAf+AWwJAqwee3tgAPPyPHzh7fwF4GCAvw9d3d8G3AzACl/QzM7MxKJlkMIAGEkAdfND5AFp2tQxf3t0BDwpw8IiDDw789OYGA+j6QNCAAtbZfxxJYvSqP0rzymjHf7S8HQ2B0RAYDYHREBh6ITC6AmA01Y6GwLAMgdGBgNGETYcQGGIDAdRZCYB5LSA8pKHhATmdnwk4Qc8MXhEAmqUHzex///yUwdBzEsPVAw0MoM7/m4eHGEAHCoL2/IM686C9/qzsvMCbBLYBVwO8Bl739x24/P8ng4SqJ3B7wFrwmQMc3GLgbQUaNpUM/MAtAtcPtzGomuczHFzoBD5/gNjZf7p1/oftdX+jnf/RMnY0BEZDYDQERkNgaIbA6ADAaModDYFhHwKjgwGjiZzGITCEBgKoPQgACln4uQAQDvh6PmZWTvA1gd8+Pgbf8Q9aMgDaIvDv3x9wR52TV5rhz89P4CsAQUv9VYBnCdw+OQnY6f/BIA48E4CTT5bhGXB1AMjIH8AbB74CrxhUsypmuH9uDvAQQQEG0FYANg5BBtBhhCA5kBmglQXEDACMdv4pzQ+jnf/RMnU0BEZDYDQERkNg6IbA6C0Ao6l3NASGfQiM3iQwmshpHAJD6MYA6nR+UTuAiE43UBxpxptPVAs8CMAnqgnsm/9hAF3hB7rT/9+fn+BOPuRgP1PwPv/rR9oZBICHA4Ji6un19Qw3j3YygDr+MsArBUHqQPv/QVcF/vn1FThw8JmBR1CZ4fPbW5BDADmFsUcwltn30c4/JXkBVpaOliijITAaAqMhMBoCoyEwdENgdABgNPWOhsCICoHRwYDRBE/DEBgiy73J6gTjuhoQIzj/g+/l/wvs5GtC9+u/f34esgoAqBZ0C8C/v7/Ay/z//v7O8PjKCgYZzWDwAAFoFp+FjZtBwSCBAaT/64f7DBd3FjJ8+/CQAXRtIAgDj/lnEJW3Y3h6Yz1wgOA5+IpBWZ0IBl4hVdTD/0Y7/1RO6KOz/qNl52gIjIbAaAiMhsDwCIHRQwBHU/JoCIyGADAERrcJjCYDKofAIN8WQLutALBw/M8AOpTv7eNj4Bl+0In9AhIGwKv8zBg+v77OIKsbycArrM7w8dVlhjePjwIPE2xjeHJ1JcOPz88ZpDX8GTh5pRjePT0J3i7AgNSZB60E+PT6Gvi6P5D47x8fwGaAzhcADQ6AbR/t/FMxMY92/EfLxtEQGA2B0RAYDYHhFQKjZwCMpujREBgNAaQQGB0IGE0OVA6BQTwQQNYgAIZ/0A8FBIUfUIyRkQF+GCAj5EBA2NV9///+Bq8SAKtgYgFuB3BheHpzIwOoQ69kks7w/NZW8AAA6NrA///+MsA79tCo+Y/UwWeEugdl7z/aAMDosn9y0/Ro53+0PBwNgdEQGA2B0RAYfiEwugVgNFWPhsBoCCCFwOgWgdHkQOUQGMTnA9B2KwAkHEEddO+CB8AzAJkZQEv+Qcv/wXcIAsPlL/AqQA4eCQY2LmEG8KDA/78M756cZHCI38fw4+tL8FJ/WOcf1MGHYeQYgoj9Y8A1+z/a+ScnPY/u9R8tB0dDYDQERkNgNASGbwiMrgAYTd2jITAaAkSEwOjKgNFkQoUQGKSrAUheCUBwFQDQROCsP6ijz8TEyiCjFcLw8t5uyB79///A+/ZBe/2/f3rCAJrhB58aALwdABTCEioewKsD2YGrADYDtw78ZgB17P8Tc/7A6LJ/KmXR0Vn/0bJuNARGQ2A0BEZDYHiHwOgKgNEUPhoCoyFARAiMrgwYTSZUCIFBuhqA5FlyQh1y4ACBnls3eNYfFGqgQ/qYmNnAy/pB1wOCOv+s7PzgAAUf7gfq/APNBLFBy/9BB/z9Aw8I/GdAdP7x5MH/A9RpHcSrO0hPraOz/qNl3GgIjIbAaAiMhsDICIHRFQCjKX00BEZDgIIQGF0ZMJp8KEk+gyv9kLQSAOtqBsjMv7HvTIZbx/sYQNf9/f75EXhvvyCw8y/JALoBQEzRGXx3/6v7+xlULfIZbp+YABR/j3TYH6Qzj9rxxxPGODr/NF/6/384zZSPzvqPlmOjITAaAqMhMBoCIycERlcAjKb20RAYDQEKQmB01mw0+VCSfP4zMAyijiRJnWac7v7PcG5rFoOySQYDIzMrA2jmH3RyP+havw8vLjB8fnODQU43ioGZhYPhzslJwCv/EhnA+/f/I/ISUZ1/PLPvo51/YtPkaPk1Wn6NhsBoCIyGwGgIjLwQGF0BMJrqR0NgNASoHAKjqwJGkxQZITCIzgcgeiUAlrMAIKfyMwL3+bODtwAIShkz/Pr2hoFXRJNB064aPOMPuuoPFEJvnxwH7/P/9+835Fo/0FAAfGABx6w0gQGT0c4/MWlvdMZ/tIwaDYHREBgNgdEQGLkhMLoCYDT1j4bAaAhQOQRGzwsYTVJkhMAg2k9OdCcay1kAsOv4QMv//wFP+f/44iIDaG//n1+fgQMCTAzsXCIMv4FsEIatDoCtgsA7809E+NC08/9/cK3WID+PjXb+R8un0RAYDYHREBgNgZEdAqMDAKM5YDQERkOAhiEwOhgwmrxIDIFB0tGkVmdaUs2bgY1TiOHPry8M987OZnj37AyDomEyw+/v7xl+fHnBwMLKzcDIxMyAs/NPZHjQvPM/5BPy6HL/0bJoNARGQ2A0BEZDYDQEQCEwugVgNB2MhsBoCNA5BEa3CIwmORJCYIC3BhC1HQDFjZD0zQi8BhDUsWdiZgfP+osruzKwsvMxPL66CnzN3/fPTxkEJQzBZwS8fnQYfB0gJFSgM9QknI0w2vnHl55GZ/xHy5vREBgNgdEQGA2B0RBADoHRFQCj6WE0BEZDgM4hMLoqYDTJkRACA7wiAHxHPwOBTiSWzjqo88/GKQzu/Etp+DM8uryM4c6pqQzCMhYMXz/cB+79/wVcDXCaQck4Db7/n4GBtM4/UW4jN7ENiyX/o53/0bJmNARGQ2A0BEZDYDQE0ENgdAXAaJoYDYHREBgkITC6MmA0KRIRAgO4IgDvagC0VQCgFQCgGX8FwySGF7e3AZf5szB8enMdeusBomP6H+n0f4bRWX8qZYHRjv9oWTIaAqMhMBoCoyEwGgK4QmB0AGA0bYyGwGgIDMIQGB0MGE2WBEJggAYCiBsEAN4CALwCELQCgIWNhwF0AOBP4E0AwHX+SHv9Qf5D6qgOhs7//6HecR7t+I+WG6MhMBoCoyEwGgKjIUAoBFhGg2g0BEZDYDQEBl8IIDfkRwcDRlMolhCAdVbpPBAA22+PdSAA5CZG6Lg6kM0tIM/w7ukpoOMZwTcBQHyB1kkd7fhTIXmPdvxHy4jREBgNgdEQGA2B0RAgNgRGVwCMppXREBgNgSESAqMDAaNJFU8IDMCKAMKrAWBpFkcHdbTzT2GSHu34j5YJoyEwGgKjITAaAqMhQGoIjA4AjKaZ0RAYDYEhGAKjgwGjyXbwDAYQfzYAAwMDicvsaXbC/5Be7j/a8R/N/6MhMBoCoyEwGgKjIUBuCIwOAIymndEQGA2BIR4Co4MBo0kYRwgMtlUBREbU6LV++AJqtPM/mt9HQ2A0BEZDYDQERkOAkhAYHQAYTT+jITAaAsMoBEYHA0aTM44QGIyHBiI5laadfpA9owf8jWaN0RAYDYHREBgNgdEQGA0BYAiMDgCMJoPREBgNgWEaAqODAaNJG0cIMI6QtPF/OMyWj874j+bj0RAYDYHREBgNgdEQoGYIjA4AjKan0RAYDYEREAKjgwGjyRxHCAy3wYD/w6XDPNrxH82zoyEwGgKjITAaAqMhQIsQGB0AGE1XoyEwGgIjLARGBwNGk/wwGwwY7fSPJunREBgNgdEQGA2B0RAYDQEiQ2B0AGA0qYyGwGgIjOAQGB0MGE3+eEJgMK8O+D+cZshHZ/tH8+FoCIyGwGgIjIbAaAjQKwRGBwBG09poCIyGwGgIgENgdDBgNCEQEQIDMSjwf7h2kEc7/qN5bjQERkNgNARGQ2A0BOgdAqMDAKNpbjQERkNgNAQwQmB0MGA0UZARApQODvwfKR3i0Y7/aP4aDYHREBgNgdEQGA2BgQqB0QGA0bQ3GgKjITAaAnhDYHQwYDSBjIYAdUJgtOM/mpJGQ2A0BEZDYDQERkNgoENgdABgNA2OhsBoCIyGANEhMDoYMJpYRkOAtBAY7fSPppjREBgNgdEQGA2B0RAYTCEwOgAwmh5HQ2A0BEZDgKwQGB0MGE04oyGAOwRGO/6jqWM0BEZDYDQERkNgNAQGYwiMDgCMpsvREBgNgdEQoDgERgcDRhPRaAgwMIx2+kdTwWgIjIbAaAiMhsBoCAz2EBgdABhNo6MhMBoCoyFA9RAYHRAYTVQjKQRGO/6j6X00BEZDYDQERkNgNASGSgiMDgCMptXREBgNgdEQoGkIjA4GjCaw4RgCo53+0XQ9GgKjITAaAqMhMBoCQzEERgcARtPtaAiMhsBoCNA1BEYHBEYT3FANgdFO/2jaHQ2B0RAYDYHREBgNgaEeAqMDAKNpeDQERkNgNAQGLARGBwNGE99gD4HRTv9oGh0NgdEQGA2B0RAYDYHhFAKjAwCj6Xk0BEZDYDQEBk0IjA4IjCbGwRACo53+0XQ4GgKjITAaAqMhMBoCwzUERgcARtP2aAiMhsBoCAzaEBgdEBhNnPQKgdFO/2haGw2B0RAYDYHREBgNgZEQAqMDAKPpfDQERkNgNASGRAiMDgaMJlRqh8Bop380TY2GwGgIjIbAaAiMhsBIC4HRAYDRND8aAqMhMBoCQzYERgcFRhMvqSEw2ukfTTOjITAaAqMhMBoCoyEwkkNgdABgNP2PhsBoCIyGwLAJgdEBgdHEjB4Cox3+0TQxGgKjITAaAqMhMBoCoyGACIHRAYDR1DAaAqMhMBoCwzYERgcERl7iHu3wjxZooyEwGgKjITAaAqMhMBoCuENgdABgNHWMhsBoCIyGwIgKgdFBgeEV3aMd/tECbDQERkNgNARGQ2A0BEZDgPgQGB0AGE0toyEwGgKjITDiQ2B0UGBoJIHRzv5oYTUaAqMhMBoCoyEwGgKjIUBZCIwOAIymoNEQGA2B0RAYDQEcITA6MDBwSWO0sz+aLUdDYDQERkNgNARGQ2A0BKgfAqMDAKOpajQERkNgNARGQ4DEEBgdGKBekhnt6I9mv9EQGA2B0RAYDYHREBgNAfqFwOgAwGhqGw2B0RAYDYHREKByCIwOEKAG6GgnfzSLjYbAaAiMhsBoCIyGwGgIDI4QGB0AGE2JoyEwGgKjITAaAgMQAsNpkGC0gz+ahUZDYDQERkNgNARGQ2A0BIZGCIwOAIym1NEQGA2B0RAYDYEhFgK0GDwY7cSPZoPREBgNgdEQGA2B0RAYDYHhHwKjAwCjqXw0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZACDCNxvJoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwPAPgdEBgNFUPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITA6ADCaBkZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQEhkMIjK4AGE3HoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjA4AjKaB0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHhEAKjKwBG0/FoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjAwCjaWA0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDiEwOgKgNF0PBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwOgAwGgaGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDiEwugJgNB2PhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwOgAwmgZGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BIZDCIyuABhNx6MhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIwOAIymgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B4RACoysARtPxaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCowMAo2lgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A4hMDoCoDRdDwaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsDoAMBoGhgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA4hMLoCYDQdj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMDoAMJoGRkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNASGQwiMrgAYTcejITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMDgCMpoHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgeEQAqMrAEbT8WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMDAKNpYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgOITA6AqA0XQ8GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbA6ADAaBoYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgOITC6AmA0HY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITA6ADCaBkZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQEhkMIjK4AGE3HoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjA4AjKaB0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHhEAKjKwBG0/FoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjAwCjaWA0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDiEwOgKgNF0PBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwAgIgdEBgNFkPhoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCIyAERgcARpP5aAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQmB0AGA0mY+GwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwOgAwGgaGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDiEwugJgNB2PhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwAkJgdABgNJmPhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsAICIHRAYDRZD4aAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAiMgBEYHAEaT+WgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIAQGB0AGE3moyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwOgAwmgZGQ2A0BEZDYDQERkNgNARGQ2A0BEZDYDQERkNgNARGQ2A0BIZDCIyuABhNx6MhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyAEBgdABhN5qMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMAJCYHQAYDSZj4bAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbACAiB0QGA0WQ+GgKjITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgIjIARGBwBGk/loCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIwOAIymgdEQGA2B0RAYDYHREBgNgdEQGA2B0RAYDYHREBgNgdEQGA2B4RACoysARtPxaAiMhsBoCIyGwGgIjIbAaAiMhsBoCIyGwGgIjIbAaAiMgBAYHQAYTeajITAaAqMhMBoCoyEwGgKjITAaAqMhMBoCoyEwGgKjITACQgAASrhdzJhmo6IAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#include \"headers/display.hpp\"\n", + "\n", + "im::image julia_image(\"images/julia.png\");\n", + "xcpp::display(julia_image);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/06_GPU-ripple.ipynb b/cuda/06_GPU-ripple.ipynb new file mode 100644 index 0000000..60865a3 --- /dev/null +++ b/cuda/06_GPU-ripple.ipynb @@ -0,0 +1,158 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "a", + "metadata": {}, + "source": [ + "# GPU Ripple Pattern\n", + "\n", + "This notebook demonstrates GPU parallelism using a 2D ripple pattern rendered on the GPU.\n", + "\n", + "## How It Works\n", + "\n", + "Each pixel is assigned to one GPU thread using a 2D launch grid. The thread computes a\n", + "grayscale value based on the pixel's distance from the image centre, producing\n", + "concentric rings that fade with distance.\n", + "\n", + "### The Kernel\n", + "\n", + "The kernel maps thread and block indices to a 2D pixel position:\n", + "```cpp\n", + "int x = threadIdx.x + blockIdx.x * blockDim.x;\n", + "int y = threadIdx.y + blockIdx.y * blockDim.y;\n", + "```\n", + "\n", + "It then computes the Euclidean distance from the centre and feeds it into a cosine wave:\n", + "```\n", + "color = 42 + 127 * cos(dist / 10) / (dist / 10 + 1)\n", + "```\n", + "\n", + "- `dist` — distance from the image centre \n", + "- The denominator `(dist/10 + 1)` attenuates the wave amplitude with distance, giving a natural fall-off" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "be04b0ab", + "metadata": {}, + "outputs": [], + "source": [ + "#define GRID 512\n", + "\n", + "__global__ void ripple(unsigned char *fb) {\n", + " int x = threadIdx.x + blockIdx.x * blockDim.x;\n", + " int y = threadIdx.y + blockIdx.y * blockDim.y;\n", + " int idx = x + y * blockDim.x * gridDim.x;\n", + "\n", + " // Vector from pixel to image centre\n", + " float dx = x - GRID / 2.0f;\n", + " float dy = y - GRID / 2.0f;\n", + " float d_sq = dx * dx + dy * dy;\n", + "\n", + " // Hardware sqrt and cos via PTX intrinsics\n", + " float dist, cos_val;\n", + " asm(\"sqrt.rn.f32 %0, %1;\" : \"=f\"(dist) : \"f\"(d_sq));\n", + " float ang = dist / 10.0f;\n", + " asm(\"cos.approx.f32 %0, %1;\" : \"=f\"(cos_val) : \"f\"(ang));\n", + "\n", + " unsigned char color = (unsigned char)(42 + 127.0f * cos_val / (ang + 1.0f));\n", + "\n", + " fb[idx * 4 + 0] = color;\n", + " fb[idx * 4 + 1] = color;\n", + " fb[idx * 4 + 2] = color;\n", + " fb[idx * 4 + 3] = 255;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "eb999236", + "metadata": {}, + "source": [ + "### Launch Configuration\n", + "\n", + "The image is `512 × 512` pixels, divided into `16 × 16` thread blocks.\n", + "The kernel launches `32 × 32 = 1024` blocks with `256` threads each — one thread per pixel." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d3f05392", + "metadata": {}, + "outputs": [], + "source": [ + "#define STB_IMAGE_WRITE_IMPLEMENTATION\n", + "#include \"headers/stb_image_write.h\"\n", + "\n", + "unsigned char *d_fb;\n", + "cudaMalloc(&d_fb, GRID * GRID * 4);\n", + "\n", + "dim3 block(16, 16);\n", + "dim3 grid(GRID / 16, GRID / 16);\n", + "\n", + "ripple<<>>(d_fb);\n", + "\n", + "cudaDeviceSynchronize();\n", + "\n", + "unsigned char h_fb[GRID * GRID * 4];\n", + "cudaMemcpy(h_fb, d_fb, GRID * GRID * 4, cudaMemcpyDeviceToHost);\n", + "\n", + "stbi_write_png(\"images/ripple.png\", GRID, GRID, 4, h_fb, GRID * 4);\n", + "\n", + "cudaFree(d_fb);" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7406f526", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#include \"headers/display.hpp\"\n", + "\n", + "im::image ripple_image(\"images/ripple.png\");\n", + "xcpp::display(ripple_image);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/07_Dot-product.ipynb b/cuda/07_Dot-product.ipynb new file mode 100644 index 0000000..2201010 --- /dev/null +++ b/cuda/07_Dot-product.ipynb @@ -0,0 +1,230 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "a", + "metadata": {}, + "source": [ + "# Dot Product — Parallel Reduction\n", + "\n", + "The dot product of two vectors A and B of length N is:\n", + "\n", + "$$\\text{result} = \\sum_{i=0}^{N-1} A_i \\cdot B_i$$\n", + "\n", + "On the CPU this is a simple loop. On the GPU it splits into two stages:\n", + "\n", + "1. **Partial products** — each thread multiplies pairs of elements and accumulates a local sum\n", + "2. **Parallel reduction** — threads inside a block cooperate to collapse all local sums into one\n", + "\n", + "The reduction step requires two CUDA features we haven't seen yet:\n", + "\n", + "| Keyword | What it does |\n", + "|---|---|\n", + "| `__shared__` | Declares memory shared by all threads in the same block (fast, on-chip) |\n", + "| `__syncthreads()` | Barrier — every thread in the block waits here until all have arrived |\n", + "\n", + "The diagram below shows how the reduction collapses 256 values into 1 using a tree of additions.\n", + "\n", + "![Dot Product](images/dot_product_cuda.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a9fa22e3", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "\n", + "const int N = 33 * 1024;\n", + "const int THREADS = 256;\n", + "const int BLOCKS = std::min(32, (N + THREADS - 1) / THREADS);" + ] + }, + { + "cell_type": "markdown", + "id": "379e138a", + "metadata": {}, + "source": [ + "### The kernel\n", + "\n", + "Each thread strides through the whole array accumulating a running `temp` sum, then\n", + "writes that into shared memory. After a `__syncthreads()` barrier the block performs\n", + "a tree reduction: in each step, the active threads halve and the surviving ones add\n", + "their neighbour's value. The block's final sum lands in `partial[blockIdx.x]`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e74d87cd", + "metadata": {}, + "outputs": [], + "source": [ + "__global__ void dot_product(float *a, float *b, float *partial) {\n", + " __shared__ float tile[THREADS]; // one float per thread, on-chip\n", + " float running = 0.0f;\n", + "\n", + " int tid = threadIdx.x + blockIdx.x * blockDim.x;\n", + " int stride = blockDim.x * gridDim.x;\n", + " int lane = threadIdx.x;\n", + "\n", + " // Phase 1: each thread accumulates its share of element-wise products\n", + " for (int i = tid; i < N; i += stride)\n", + " running += a[i] * b[i];\n", + " tile[lane] = running;\n", + "\n", + " __syncthreads(); // ensure all threads have written before we read\n", + "\n", + " // Phase 2: tree reduction inside this block\n", + " for (int half = blockDim.x / 2; half > 0; half >>= 1) {\n", + " if (lane < half)\n", + " tile[lane] += tile[lane + half];\n", + " __syncthreads();\n", + " }\n", + "\n", + " // Thread 0 holds the block's total — write it out\n", + " if (lane == 0)\n", + " partial[blockIdx.x] = tile[0];\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "e76ec409", + "metadata": {}, + "source": [ + "Allocate input and output arrays on both host and device." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53450b72", + "metadata": {}, + "outputs": [], + "source": [ + "float *h_a, *h_b, *h_partial;\n", + "float *d_a, *d_b, *d_partial;\n", + "\n", + "h_a = (float*)malloc(N * sizeof(float));\n", + "h_b = (float*)malloc(N * sizeof(float));\n", + "h_partial = (float*)malloc(BLOCKS * sizeof(float));\n", + "\n", + "cudaMalloc((void**)&d_a, N * sizeof(float));\n", + "cudaMalloc((void**)&d_b, N * sizeof(float));\n", + "cudaMalloc((void**)&d_partial, BLOCKS * sizeof(float));" + ] + }, + { + "cell_type": "markdown", + "id": "559b403b", + "metadata": {}, + "source": [ + "Fill the vectors (`a[i] = i`, `b[i] = 2i`), copy to GPU, launch, and retrieve the partial sums." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ed007081", + "metadata": {}, + "outputs": [], + "source": [ + "for (int i = 0; i < N; i++) {\n", + " h_a[i] = (float)i;\n", + " h_b[i] = (float)i * 2.0f;\n", + "}\n", + "\n", + "cudaMemcpy(d_a, h_a, N * sizeof(float), cudaMemcpyHostToDevice);\n", + "cudaMemcpy(d_b, h_b, N * sizeof(float), cudaMemcpyHostToDevice);\n", + "\n", + "dot_product<<>>(d_a, d_b, d_partial);\n", + "\n", + "cudaMemcpy(h_partial, d_partial, BLOCKS * sizeof(float), cudaMemcpyDeviceToHost);" + ] + }, + { + "cell_type": "markdown", + "id": "f71323d8", + "metadata": {}, + "source": [ + "Sum the `BLOCKS` partial results on the CPU to get the final answer.\n", + "Since `a[i] = i` and `b[i] = 2i`, the expected value is `2 × Σi²`.\n", + "The closed-form for that is `2 × N(N−1)(2N−1)/6` evaluated at N−1." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e8c1f64c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPU result : 2.57236e+13\n", + "Reference : 2.57236e+13\n" + ] + } + ], + "source": [ + "double gpu_result = 0.0;\n", + "for (int i = 0; i < BLOCKS; i++)\n", + " gpu_result += h_partial[i];\n", + "\n", + "// Closed-form reference: 2 * sum of i^2 for i = 0..N-1\n", + "double ref = 2.0 * (double)(N - 1) * N * (2.0 * (N - 1) + 1) / 6.0;\n", + "\n", + "printf(\"GPU result : %.6g\\n\", gpu_result);\n", + "printf(\"Reference : %.6g\\n\", ref);" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "453c394a", + "metadata": {}, + "outputs": [], + "source": [ + "cudaFree(d_a);\n", + "cudaFree(d_b);\n", + "cudaFree(d_partial);\n", + "\n", + "free(h_a);\n", + "free(h_b);\n", + "free(h_partial);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/08_Ray-tracing.ipynb b/cuda/08_Ray-tracing.ipynb new file mode 100644 index 0000000..a13d11f --- /dev/null +++ b/cuda/08_Ray-tracing.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b", + "metadata": {}, + "outputs": [], + "source": [ + "#undef __noinline__" + ] + }, + { + "cell_type": "markdown", + "id": "a", + "metadata": {}, + "source": [ + "# Ray Tracing\"\n", + "\n", + "This notebook demonstrates how ray tracing works in a very simple way.\n", + "\n", + "## The Scene\n", + "\n", + "We create a 1024×1024 pixel image. In front of this image, we randomly place discs. Each disc has:\n", + "\n", + " - A random color (red, green, blue),\n", + " - A random size (radius between 20-80 pixels),\n", + " - A random position (x, y coordinates in the image plane),\n", + " - A random depth (z coordinate, how far in front of the image)\",\n", + " \n", + "The discs are scattered at different distances from the camera, creating a 3D scene.\\n\",\n", + "Below we can see how ray tracing works.\n", + "\n", + "![Ray Tracing](images/ray_tracing.png)\n", + "\n", + "The camera sits at the origin looking in the +Z direction. Every pixel fires\n", + "a ray parallel to Z, described only by its (ox, oy) offset from the image centre.\n", + "All rays point the same direction - much simpler than a full ray tracer." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7f9a4457", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "#define IMG 1024\n", + "#define NDISCS 15" + ] + }, + { + "cell_type": "markdown", + "id": "e06a657c", + "metadata": {}, + "source": [ + "## The Disc struct\n", + "\n", + "Each disc stores colour, radius, and position. The `intersect` method answers:\n", + "*does the ray at screen offset (ox, oy) intersect this sphere, and if so, how deep?*\n", + "\n", + "It works by computing the 2D distance from the ray to the sphere centre.\n", + "If that distance is less than the radius, the ray enters the sphere and we\n", + "calculate the depth `z` using the Pythagorean theorem." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "45e2cbec-a57f-4662-9f66-fcb3260d0797", + "metadata": {}, + "outputs": [], + "source": [ + "struct Disc {\n", + " float r, g, b; // colour\n", + " float cx, cy, z; // centre in 3-D\n", + " float radius;\n", + "\n", + " // Returns the disc's z value if the ray at (ox,oy) hits.\n", + " __device__ float intersect(float ox, float oy, float *normal_val) const {\n", + " float dx = ox - cx;\n", + " float dy = oy - cy;\n", + " float distSq = dx * dx + dy * dy;\n", + " \n", + " if (distSq < radius * radius)\n", + " {\n", + " float dz;\n", + " float depth_sq = radius * radius - distSq;\n", + " asm(\"sqrt.rn.f32 %0, %1;\" : \"=f\"(dz) : \"f\"(depth_sq));\n", + " \n", + " *normal_val = dz / radius;\n", + " return z;\n", + " }\n", + " return -1e9f;\n", + " }\n", + "};" + ] + }, + { + "cell_type": "markdown", + "id": "9c02fca8", + "metadata": {}, + "source": [ + "## The kernel\n", + "\n", + "Each thread owns one pixel. It loops over every disc, calls `intersect`, and keeps track\n", + "of the ones that was hit at the greatest depth (closest to the camera).\n", + "\n", + "The disc colour, scaled by the surface normal, gives simple diffuse shading." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fcd10329", + "metadata": {}, + "outputs": [], + "source": [ + "__global__ void render(const Disc *discs, unsigned char *fb) {\n", + " int col = threadIdx.x + blockIdx.x * blockDim.x;\n", + " int row = threadIdx.y + blockIdx.y * blockDim.y;\n", + " if (col >= IMG || row >= IMG) return;\n", + "\n", + " // Normalised ray origin in [-0.5, 0.5]\n", + " float ox = (float)col / IMG - 0.5f;\n", + " float oy = (float)row / IMG - 0.5f;\n", + "\n", + " float best_z = -1e9f;\n", + " float fr = 0.f, fg = 0.f, fb_val = 0.f;\n", + "\n", + " for (int d = 0; d < NDISCS; d++) {\n", + " float normal = 0.f; \n", + " // FIXED: Added &normal parameter so the function can populate the light interaction value\n", + " float depth = discs[d].intersect(ox, oy, &normal); \n", + " \n", + " if (depth > best_z) {\n", + " best_z = depth;\n", + " \n", + " fr = discs[d].r * normal;\n", + " fg = discs[d].g * normal; \n", + " fb_val = discs[d].b * normal;\n", + " }\n", + " }\n", + "\n", + " // Clamp the colors to a maximum of 1.0f using direct PTX hardware min instructions\n", + " float cr, cg, cb;\n", + " asm(\"min.f32 %0, %1, 1.0;\" : \"=f\"(cr) : \"f\"(fr));\n", + " asm(\"min.f32 %0, %1, 1.0;\" : \"=f\"(cg) : \"f\"(fg));\n", + " asm(\"min.f32 %0, %1, 1.0;\" : \"=f\"(cb) : \"f\"(fb_val));\n", + "\n", + " // Store safely directly to the frame buffer\n", + " int px = (row * IMG + col) * 4;\n", + " fb[px + 0] = (unsigned char)(cr * 255.f);\n", + " fb[px + 1] = (unsigned char)(cg * 255.f);\n", + " fb[px + 2] = (unsigned char)(cb * 255.f);\n", + " fb[px + 3] = 255;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "0710c52d", + "metadata": {}, + "source": [ + "Here we configure all variables and create the random spheres on the CPU, then copy them to the GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0c4c052", + "metadata": {}, + "outputs": [], + "source": [ + "unsigned char *h_fb = (unsigned char*)malloc(IMG * IMG * 4);\n", + "unsigned char *d_fb;\n", + "Disc *d_discs;\n", + "cudaMalloc(&d_fb, IMG * IMG * 4);\n", + "cudaMalloc(&d_discs, NDISCS * sizeof(Disc));\n", + "\n", + "// Build random scene on the CPU\n", + "Disc scene[NDISCS];\n", + "srand(time(NULL));\n", + "\n", + "auto rnd = [](float hi) { return hi * (float)rand() / (float)RAND_MAX; };\n", + "\n", + "for (int i = 0; i < NDISCS; i++) {\n", + " scene[i].r = rnd(1.0f);\n", + " scene[i].g = rnd(1.0f);\n", + " scene[i].b = rnd(1.0f);\n", + " \n", + " scene[i].cx = rnd(1.0f) - 0.5f; // [-0.5, 0.5]\n", + " scene[i].cy = rnd(1.0f) - 0.5f; // [-0.5, 0.5]\n", + " scene[i].z = rnd(1.0f) - 0.5f; // [-0.5, 0.5]\n", + " \n", + " scene[i].radius = rnd(0.1f) + 0.04f; \n", + "}\n", + "\n", + "cudaMemcpy(d_discs, scene, NDISCS * sizeof(Disc), cudaMemcpyHostToDevice);" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b7894631-0540-4657-974f-f3f2e3a5fe82", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved RayTrace.png\n" + ] + } + ], + "source": [ + "#define STB_IMAGE_WRITE_IMPLEMENTATION\n", + "#include \"headers/stb_image_write.h\"\n", + "\n", + "dim3 block(16, 16);\n", + "dim3 grid(IMG / 16, IMG / 16);\n", + "render<<>>(d_discs, d_fb);\n", + "cudaDeviceSynchronize();\n", + "\n", + "cudaMemcpy(h_fb, d_fb, IMG * IMG * 4, cudaMemcpyDeviceToHost);\n", + "stbi_write_png(\"images/RayTrace.png\", IMG, IMG, 4, h_fb, IMG * 4);\n", + "printf(\"Saved RayTrace.png\\n\");\n", + "\n", + "cudaFree(d_fb); cudaFree(d_discs); free(h_fb);" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "46a4c954", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#include \"headers/display.hpp\"\n", + "\n", + "im::image rt_image(\"images/RayTrace.png\");\n", + "xcpp::display(rt_image);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 CUDA", + "language": "cpp", + "name": "xcpp23-cuda" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "CUDA", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cuda/headers/display.hpp b/cuda/headers/display.hpp new file mode 100644 index 0000000..9310179 --- /dev/null +++ b/cuda/headers/display.hpp @@ -0,0 +1,32 @@ +#include +#include +#include + +#include "nlohmann/json.hpp" + +#include "xeus/xbase64.hpp" + +#include "xcpp/xdisplay.hpp" + +namespace nl = nlohmann; + +namespace im +{ + struct image + { + inline image(const std::string& filename) + { + std::ifstream fin(filename, std::ios::binary); + m_buffer << fin.rdbuf(); + } + + std::stringstream m_buffer; + }; + + nl::json mime_bundle_repr(const image& i) + { + auto bundle = nl::json::object(); + bundle["image/png"] = xeus::base64encode(i.m_buffer.str()); + return bundle; + } +} \ No newline at end of file diff --git a/cuda/headers/stb_image_write.h b/cuda/headers/stb_image_write.h new file mode 100644 index 0000000..e4b32ed --- /dev/null +++ b/cuda/headers/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; + static unsigned char lengtheb[]= { 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 }; + static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; + static unsigned char disteb[] = { 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 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, + 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; + static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; + static const unsigned short YAC_HT[256][2] = { + {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const unsigned short UVAC_HT[256][2] = { + {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, + 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; + static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, + 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal release +*/ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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/cuda/images/RayTrace.png b/cuda/images/RayTrace.png new file mode 100644 index 0000000..93ecced Binary files /dev/null and b/cuda/images/RayTrace.png differ diff --git a/cuda/images/dot_product_cuda.png b/cuda/images/dot_product_cuda.png new file mode 100644 index 0000000..e0dc8ec Binary files /dev/null and b/cuda/images/dot_product_cuda.png differ diff --git a/cuda/images/julia.png b/cuda/images/julia.png new file mode 100644 index 0000000..ec4522e Binary files /dev/null and b/cuda/images/julia.png differ diff --git a/cuda/images/ray_tracing.png b/cuda/images/ray_tracing.png new file mode 100644 index 0000000..2a39041 Binary files /dev/null and b/cuda/images/ray_tracing.png differ diff --git a/cuda/images/ripple.png b/cuda/images/ripple.png new file mode 100644 index 0000000..976a2e0 Binary files /dev/null and b/cuda/images/ripple.png differ diff --git a/cuda/images/vectoradd.png b/cuda/images/vectoradd.png new file mode 100644 index 0000000..ab3829f Binary files /dev/null and b/cuda/images/vectoradd.png differ diff --git a/environment.yml b/environment.yml index 5821d38..6bb4cd0 100644 --- a/environment.yml +++ b/environment.yml @@ -1,9 +1,15 @@ name: livecpp-ci channels: - conda-forge + - nvidia dependencies: - python>=3.11 - xeus-cpp - jupyter + - nbconvert + - llvm-openmp + - cuda-toolkit=12 + - clangdev=21 + - cuda-cudart-dev - papermill - pytest diff --git a/openmp/01_openmp-demo.ipynb b/openmp/01_openmp-demo.ipynb new file mode 100644 index 0000000..808fbee --- /dev/null +++ b/openmp/01_openmp-demo.ipynb @@ -0,0 +1,317 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2bf44eba-b903-40f1-9ef6-67fb8e2d9cc8", + "metadata": {}, + "source": [ + "# Introduction to OpenMP\n", + "\n", + "OpenMP (Open Multi-Processing) allows you to use multiple threads of the CPU when programming. It is an industry-standard API for shared-memory parallel programming, designed to help C++ developers take full advantage of multi-core processors without needing to manage low-level thread creation.\n", + "\n", + "## How it works\n", + "\n", + "1. The Fork-Join Model\n", + "OpenMP operates on a simple execution pattern:\n", + "\n", + "- The Master Thread: The program begins as a single serial thread.\n", + "- The Fork: When a parallel directive is reached, the master thread creates a team of worker threads.\n", + "- Parallel Execution: The work is distributed across these threads.\n", + "- The Join: Once the work is finished, the threads synchronize and terminate, leaving only the master thread to continue.\n", + "\n", + "2. Practical Implementation\n", + "- The most common use case is parallelising a for loop. By adding a single \"pragma\" line, you can distribute millions of calculations across your CPU cores.\n", + "\n", + "Here is an image of how the Fork-Join model works\n", + "\n", + "![fork-join](images/fork_join.png)" + ] + }, + { + "cell_type": "markdown", + "id": "0fb794c1-2999-43ae-9c9d-58060e4eb66f", + "metadata": {}, + "source": [ + "In this first example function we can see how to print Hello World normally. There is only standard c++ syntax." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b0c15570-ee24-42ed-b61f-11a3fc858b2d", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5001e441-1fa5-4bdc-9fa5-2ca103ae484f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!\n" + ] + } + ], + "source": [ + "void example1() {\n", + " std::cout << \"Hello World!\" << std::endl;\n", + "}\n", + "example1();" + ] + }, + { + "cell_type": "markdown", + "id": "f37a7cfd-f158-4ef9-a4cf-977296ccf5d4", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Now, let's use OpenMP to run the same code in parallel. By adding a simple compiler directive, we tell the system to create a \"team\" of threads.\n", + "\n", + "```#pragma omp parallel``` This directive tells the compiler to execute the following block of code in parallel using multiple threads.\n", + "\n", + "The result is that instead of printing once, you will see \"Hello World!\" printed multiple times—once for every available logical core on your CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "53fb7656-b72e-42bc-ade7-2ae2077142da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!Hello World!\n", + "\n", + "Hello World!\n", + "Hello World!\n", + "Hello World!\n", + "Hello World!\n", + "Hello World!\n", + "Hello World!\n" + ] + } + ], + "source": [ + "void example2() {\n", + " #pragma omp parallel\n", + " {\n", + " std::cout << \"Hello World!\" << std::endl;\n", + " }\n", + "}\n", + "example2();" + ] + }, + { + "cell_type": "markdown", + "id": "f1568cd4-d407-49c7-98e4-26f971fdb63d", + "metadata": {}, + "source": [ + "---\n", + "\n", + "There is one thing we need to address before we continue\n", + "\n", + "When we use #pragma omp parallel, OpenMP spawns multiple threads that all execute the code inside the curly braces simultaneously. Every thread is trying to talk to our monitor at the exact same time.\n", + "\n", + "Thread A might finish sending \"Hello World!\" but, before it can send the newline, Thread B jumps in and prints its own \"Hello World!\". This results in two greetings on one line, followed by two newlines later.\n", + "\n", + "We fix this by using this by using ```#pragma omp critical```. It makes each thread wait for each other. This significantly slows down the program and loses the whole point of using multiple threads, but we are going to use it here in some examples to show you better how OpenMP works. Below we have a function that uses this fix." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "efcdfdb6-a60b-46af-8194-75ef9cc0e27f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World! (0)\n", + "Hello World! (1)\n", + "Hello World! (2)\n", + "Hello World! (3)\n", + "Hello World! (4)\n", + "Hello World! (5)\n", + "Hello World! (7)\n", + "Hello World! (6)\n" + ] + } + ], + "source": [ + "void example3() {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp critical\n", + " {\n", + " std::cout << \"Hello World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + " }\n", + " }\n", + "}\n", + "example3();" + ] + }, + { + "cell_type": "markdown", + "id": "a6123ee3-92b9-42fe-b1a0-57f9764569aa", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Other things we can do in OMP, includes using a set number of threads that are going to be used: ```#pragma omp parallel num_threads(2)``` " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d86a9efa-ba28-4cb6-bbfc-abc00ee63506", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World! (0)\n", + "Hello World! (4)\n", + "Hello World! (5)\n", + "Hello World! (6)\n", + "Hello World! (1)\n", + "Hello World! (7)\n", + "Hello World! (2)\n", + "Hello World! (3)\n", + "This is another message! (0)\n", + "Goodbye World! (0)\n", + "Goodbye World! (1)\n" + ] + } + ], + "source": [ + "void example4() {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp critical\n", + " {\n", + " std::cout << \"Hello World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + " }\n", + " }\n", + "\n", + " std::cout << \"This is another message! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + "\n", + " #pragma omp parallel num_threads(2)\n", + " {\n", + " std::cout << \"Goodbye World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + " }\n", + "}\n", + "example4();" + ] + }, + { + "cell_type": "markdown", + "id": "25421d19-67e5-4bc9-9420-d96439cffba5", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Now that you know basic syntax we can do a speed benchmark. We are going to time filling two arrays with 1 million elements each, adding them and calculating the average. In the average calculation there is a problem that can occur. In parallel programming, if multiple threads try to add to the same average variable at the same time, they will overwrite each other. When we use ```reduction(+:average)```, OpenMP does the following:\n", + "\n", + "- Each thread gets its own private mini-average variable initialized to 0.\n", + "- Each thread calculates the sum for its assigned chunk of the array (e.g., Thread 1 sums indices 0 to 1000, Thread 2 sums 1001 to 2000).\n", + "- Once all threads finish, OpenMP safely adds all those private mini-sums together into the final global average variable." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5557e01a-7c7d-4b54-8545-962ad11027df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialize a[] time: 0.0720448\n", + "Initialize b[] time: 0.0857489\n", + "Add arrays time: 0.0623472\n", + "Average result time: 0.0487919\n", + "Average: 5e+07\n", + "Total time: 0.274028\n" + ] + } + ], + "source": [ + "void example5() {\n", + " double start_time = omp_get_wtime();\n", + " double start_loop;\n", + " \n", + " const int N = 100000000;\n", + " int* a = new int[N];\n", + " int* b = new int[N];\n", + " \n", + " start_loop = omp_get_wtime();\n", + " #pragma omp parallel for\n", + " for (int i=0; i\n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9078ac79-ca50-4fef-b785-37f35fec3cab", + "metadata": {}, + "outputs": [], + "source": [ + "static long num_steps = 100000000;\n", + "double step;" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3bee0992-3a6d-4da1-9020-3b6c153ecd0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num threads available: 8\n" + ] + } + ], + "source": [ + "int i, j, num_threads_allocated;\n", + "double pi, sum = 0.0;\n", + "double start_time, run_time;\n", + "\n", + "step = 1.0 / (double)num_steps;\n", + "printf(\"Num threads available: %d\\n\", omp_get_max_threads());" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9c3baec7-f369-4e28-bcdb-fd1fc7f985fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num threads allocated for this run: 1\n", + "pi is 3.141593 in 1.106737 seconds using 1 threads\n", + "\n", + "Num threads allocated for this run: 2\n", + "pi is 3.141593 in 0.551873 seconds using 2 threads\n", + "\n", + "Num threads allocated for this run: 3\n", + "pi is 3.141593 in 0.368655 seconds using 3 threads\n", + "\n", + "Num threads allocated for this run: 4\n", + "pi is 3.141593 in 0.289997 seconds using 4 threads\n", + "\n" + ] + } + ], + "source": [ + "for (i = 1; i <= 4; i++) {\n", + " sum = 0.0;\n", + " omp_set_num_threads(i);\n", + " start_time = omp_get_wtime();\n", + " #pragma omp parallel\n", + " {\n", + " double x;\n", + " num_threads_allocated = omp_get_num_threads();\n", + " \n", + " #pragma omp single\n", + " printf(\"Num threads allocated for this run: %d\\n\", num_threads_allocated);\n", + " \n", + " #pragma omp for reduction(+ : sum)\n", + " for (j = 1; j <= num_steps; j++) {\n", + " x = (j - 0.5) * step;\n", + " sum = sum + 4.0 / (1.0 + x * x);\n", + " }\n", + " }\n", + " pi = step * sum;\n", + " run_time = omp_get_wtime() - start_time;\n", + " printf(\"pi is %f in %f seconds using %d threads\\n\\n\", pi, run_time, num_threads_allocated);\n", + "}" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 + OpenMP", + "language": "cpp", + "name": "xcpp23-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/openmp/04_mandel.ipynb b/openmp/04_mandel.ipynb new file mode 100644 index 0000000..eb4aba8 --- /dev/null +++ b/openmp/04_mandel.ipynb @@ -0,0 +1,200 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7c545848-70df-4ec4-bea8-93969fc96aa9", + "metadata": {}, + "source": [ + "# Mandelbrot set\n", + "\n", + "This notebook estimates the area of the Mandelbrot set using parallel processing with OpenMP.\n", + "\n", + "### How the Mandelbrot Set Works\n", + "\n", + "1. **Grid Mapping**\n", + " - The grid indices are mapped to complex numbers within a specific range.\n", + " - For each point `c`, we check if iterating the function $z_{n+1} = z_n² + c$ remains bounded.\n", + "\n", + "2. **Iteration Process**\n", + " - Starting with `z = 0`, compute subsequent values using the formula.\n", + " - If at any iteration, the magnitude of `z` exceeds a threshold (here, 2), the point is marked as escaping and not part of the set.\n", + "\n", + "3. **Counting Escaping Points**\n", + " - `numoutside` keeps track of how many points escape within the given iterations.\n", + " - The area estimate is based on the proportion of these points within the grid.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5059dbdd-821d-498a-8716-eb0fcf8a8f5f", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "#include " + ] + }, + { + "cell_type": "markdown", + "id": "f86e5fd6-f657-4848-8f80-780b5ca67678", + "metadata": {}, + "source": [ + "---\n", + "1. **Constants Definition**:\n", + " - `NPOINTS = 5000`: The grid size, creating a 5000x5000 grid.\n", + " - `MAXITER = 1000`: Maximum iterations per point to determine if it escapes." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8b66f96a-14ef-4f23-8024-bcfc42b31e4e", + "metadata": {}, + "outputs": [], + "source": [ + "#define NPOINTS 5000\n", + "#define MAXITER 1000\n", + "\n", + "int numoutside = 0;" + ] + }, + { + "cell_type": "markdown", + "id": "dfd58cbd-798b-472c-869e-5a9de42a502e", + "metadata": {}, + "source": [ + "---\n", + "2. Function testpoint:\n", + " - Takes complex number parameters `creal` and `cimag`.\n", + " - Initializes `zreal` and `zimag` to 0.\n", + " - Iterates up to `MAXITER`, checking if `(zreal^2 + zimag^2) > 4.0`. If so, the point escapes, incrementing `numoutside`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5c35c479-2f79-46b7-bc66-24be6b1694e0", + "metadata": {}, + "outputs": [], + "source": [ + "void testpoint(double creal, double cimag) {\n", + " double zreal = 0.0; // Start at 0\n", + " double zimag = 0.0; \n", + " double r2, i2;\n", + " int iter;\n", + "\n", + " for (iter = 0; iter < MAXITER; iter++) {\n", + " r2 = zreal * zreal;\n", + " i2 = zimag * zimag;\n", + " \n", + " if ((r2 + i2) > 4.0) {\n", + " #pragma omp atomic // Safety check if not using reduction correctly\n", + " numoutside++;\n", + " return;\n", + " }\n", + " \n", + " zimag = 2.0 * zreal * zimag + cimag;\n", + " zreal = r2 - i2 + creal;\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "53fb8c2a-5b6e-41bd-a6eb-d31ab6c94ad0", + "metadata": {}, + "source": [ + "---\n", + "\n", + "3. **Main Function**\n", + " - Maps grid indices to complex numbers within a specific range using scaling factors:\n", + " ```\n", + " creal = (i * (-1.0 / ((double)(NPOINTS - 1)))) + (-1.0);\n", + " cimag = (j * (-1.0 / ((double)(NPOINTS - 1)))) + (-0.75);\n", + " ```\n", + " - Uses `#pragma omp parallel for` to distribute the computation across threads.\n", + " - `default(shared)` means variables not specified are shared among all threads.\n", + " - `private(i, j, creal, cimag)` ensures each thread has its own copy of these variables.\n", + " - `reduction(+:numoutside)` accumulates the total count of escaping points.\n", + "\n", + "---\n", + "3. **Area Calculation**:\n", + " - Computes area as `(2.0 * 2.5 * 1.125) * ((NPOINTS^2 - numoutside) / NPOINTS^2)`\n", + " - Error estimate is derived by dividing area by `NPOINTS`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ea116fef-7d05-4e29-97a1-55c85c7241d8", + "metadata": {}, + "outputs": [], + "source": [ + "int main() {\n", + " int i, j;\n", + " double area, error, eps = 1.0e-5;\n", + " double cimag, creal;\n", + " // Loop over grid of points in the complex plane which contains the Mandelbrot set,\n", + " // testing each point to see whether it is inside or outside the set.\n", + "\n", + "// i, j, creal, and cimag MUST be private so threads don't overwrite each other\n", + "#pragma omp parallel for default(shared) private(i, j, creal, cimag) reduction(+:numoutside)\n", + "for (i = 0; i < NPOINTS; i++) {\n", + " for (j = 0; j < NPOINTS; j++) {\n", + " creal = -2.0 + 2.5 * (double)(i) / (double)(NPOINTS) + eps;\n", + " cimag = 1.125 * (double)(j) / (double)(NPOINTS) + eps;\n", + " testpoint(creal, cimag);\n", + " }\n", + "}\n", + "\n", + " // Calculate area of set and error estimate and output the results\n", + " area = 2.0 * 2.5 * 1.125 * (double) (NPOINTS * NPOINTS - numoutside) / (double) (NPOINTS * NPOINTS);\n", + " error = area / (double) NPOINTS;\n", + "\n", + " printf(\"Area of Mandlebrot set = %12.8f +/- %12.8f\\n\", area, error);\n", + " printf(\"Correct answer should be around 1.510659\\n\");\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "39cf129c-8106-4e67-a2f1-1a7fff17cd38", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Area of Mandlebrot set = 1.51064145 +/- 0.00030213\n", + "Correct answer should be around 1.510659\n" + ] + } + ], + "source": [ + "main();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 + OpenMP", + "language": "cpp", + "name": "xcpp23-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/openmp/linked_list.ipynb b/openmp/05_linked_list.ipynb similarity index 60% rename from openmp/linked_list.ipynb rename to openmp/05_linked_list.ipynb index 005380b..0e030c2 100644 --- a/openmp/linked_list.ipynb +++ b/openmp/05_linked_list.ipynb @@ -1,5 +1,19 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "4de82d38-88d2-4d56-8ed1-3a33cdd4dac1", + "metadata": {}, + "source": [ + "# Linked List\n", + "\n", + "The program builds a linked list of 6 nodes, each storing a Fibonacci input (38 through 43), then uses parallel programming to compute the Fibonacci value for every node in parallel. A single thread walks the list and spawns one task per node, each task calling the slow recursive `fib()` on its own copy of the pointer `firstprivate(p)`. Once all tasks finish, the results are printed and memory is freed.\n", + "\n", + "### What is a linked list?\n", + "\n", + "A linked list is a chain of nodes where each node holds some data and a pointer to the next node. In this code, each node stores a Fibonacci input (data), its result (fibdata), and a next pointer to the following node. The last node's next is NULL, signaling the end of the chain. Instead of storing elements in contiguous memory like an array, each node lives at a random location in the heap (via malloc) and they are connected only through those next pointers - so to reach node 4 you must walk through nodes 1, 2, and 3 in order." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -29,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "22f97c49-78d1-496e-ac7c-978aed95331a", "metadata": {}, "outputs": [], @@ -41,9 +55,17 @@ "};" ] }, + { + "cell_type": "markdown", + "id": "afc7ee35-8fd1-45de-be44-f987d98b7808", + "metadata": {}, + "source": [ + "Here we can see the 3 main functions used for this program. " + ] + }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "b16b1e8a-8831-4b8d-9d57-09deeaaa88ee", "metadata": {}, "outputs": [], @@ -53,9 +75,19 @@ "int fib(int n);" ] }, + { + "cell_type": "markdown", + "id": "10231105-2ab9-44e9-9878-24d128a473c6", + "metadata": {}, + "source": [ + "### Fibonachi function\n", + "\n", + "`int fib(int n)`: recursively computes the N-th Fibonacci number by breaking it down into fib(n-1) + fib(n-2) until it hits the base cases 0 or 1, then returns the final integer result." + ] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "0ef8af6c-1d6f-4c68-84bc-3dd1d8092b06", "metadata": {}, "outputs": [], @@ -72,9 +104,19 @@ "}" ] }, + { + "cell_type": "markdown", + "id": "a13acd85-15f5-4ac7-9312-5288cd8ad598", + "metadata": {}, + "source": [ + "### Process work\n", + "\n", + "`void processwork(struct node *p)`: takes a single node, computes the Fibonacci number of its data field by calling fib(), and stores the result in its fibdata field. Returns nothing." + ] + }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "1fa0307d-fdc9-4503-95cb-1c6448791354", "metadata": {}, "outputs": [], @@ -88,9 +130,19 @@ "}" ] }, + { + "cell_type": "markdown", + "id": "a35c79a7-a72e-4fa8-81ba-6bdc0f18e0a9", + "metadata": {}, + "source": [ + "### initialize list\n", + "\n", + "`struct node *init_list(struct node *p)`: builds the linked list in memory using malloc, creates N+1 nodes with Fibonacci inputs starting from FS, links them together, and returns a pointer to the head (first node)." + ] + }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "03acb599-9329-49ff-8aff-c0902adb6c3c", "metadata": {}, "outputs": [], @@ -117,9 +169,19 @@ "}" ] }, + { + "cell_type": "markdown", + "id": "111c0742-1c27-40ad-a261-7ed85e379d10", + "metadata": {}, + "source": [ + "## The main code\n", + "\n", + "`main` prints some info messages, sets OpenMP to use the maximum available threads, builds the linked list via `init_list`, then starts a timer. Inside the parallel region, one thread walks the list and creates an independent OpenMP task for each node, while all 8 threads grab and execute those tasks concurrently — each computing its Fibonacci number via `processwork`. Once all tasks finish, the timer stops, the results are printed node by node, memory is freed, and the total compute time is displayed." + ] + }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "f2dfb41b-e55f-43c0-b7f6-546a1697acb1", "metadata": {}, "outputs": [], @@ -177,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "353e5dfd-fcae-43e6-97e3-ec98070811a1", "metadata": {}, "outputs": [ @@ -195,7 +257,7 @@ "41 : 165580141\n", "42 : 267914296\n", "43 : 433494437\n", - "Compute Time: 2.617225 seconds\n" + "Compute Time: 5.455860 seconds\n" ] } ], @@ -206,7 +268,7 @@ ], "metadata": { "kernelspec": { - "display_name": "C++23 (xcpp+OpenMP)", + "display_name": "C++23 + OpenMP", "language": "cpp", "name": "xcpp23-omp" }, @@ -215,7 +277,9 @@ "file_extension": ".cpp", "mimetype": "text/x-c++src", "name": "C++", - "version": "23" + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" } }, "nbformat": 4, diff --git a/openmp/06_race_conditions.ipynb b/openmp/06_race_conditions.ipynb new file mode 100644 index 0000000..98eb13e --- /dev/null +++ b/openmp/06_race_conditions.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fc192d05", + "metadata": {}, + "source": [ + "# Race Conditions\n", + "\n", + "A **race condition** occurs when two or more threads access shared memory simultaneously, and at least one of them is writing. The result depends on the unpredictable order of execution - making bugs hard to reproduce and debug.\n", + "\n", + "---\n", + "## 1. The Classic Race Condition - Parallel Counter\n", + "\n", + "We want to increment a shared counter 1 000 000 times using multiple threads.\n", + "Intuitively `counter++` looks like one action, but it compiles to **three** instructions:\n", + "\n", + "```\n", + "LOAD reg ← counter ; read current value\n", + "ADD reg, 1 ; increment in register\n", + "STORE counter ← reg ; write back\n", + "```\n", + "\n", + "If two threads execute these steps concurrently, one write will silently overwrite the other - an **increment is lost**." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3e2e951e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 1: counter = 458255 (expected 1000000, lost 541745)\n", + "Run 2: counter = 340448 (expected 1000000, lost 659552)\n", + "Run 3: counter = 367539 (expected 1000000, lost 632461)\n", + "Run 4: counter = 367803 (expected 1000000, lost 632197)\n", + "Run 5: counter = 405751 (expected 1000000, lost 594249)\n" + ] + } + ], + "source": [ + "#include \n", + "#include \n", + "#define N 1000000\n", + "\n", + "void example1()\n", + "{\n", + " int counter = 0;\n", + " \n", + " // Run the experiment 5 times to show non-determinism\n", + " for (int run = 0; run < 5; run++) {\n", + " counter = 0;\n", + " #pragma omp parallel for num_threads(4)\n", + " {\n", + " for (int i = 0; i < N; i++) {\n", + " counter++; // RACE CONDITION: no protection\n", + " }\n", + " }\n", + " printf(\"Run %d: counter = %d (expected %d, lost %d)\\n\",\n", + " run+1, counter, N, N - counter);\n", + " }\n", + "}\n", + "\n", + "example1();" + ] + }, + { + "cell_type": "markdown", + "id": "6ab1f67b", + "metadata": {}, + "source": [ + "### What you should observe\n", + "\n", + "- The counter is **almost never** 1 000 000.\n", + "- Each run gives a **different** wrong answer - the race is truly non-deterministic.\n", + "\n", + "> **Key insight**: You cannot rely on \"it worked in my tests\" for racy code. On a lightly loaded machine you might get lucky; under production load the bug emerges." + ] + }, + { + "cell_type": "markdown", + "id": "8d67c01b", + "metadata": {}, + "source": [ + "---\n", + "## 2. Fix #1 - `#pragma omp critical`\n", + "\n", + "`critical` creates a **named mutex**: only one thread at a time may execute the enclosed block. It is the most general but also the most expensive fix." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb9dac12", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "critical: counter = 1000000, time = 0.1604 s\n" + ] + } + ], + "source": [ + "#include\n", + "\n", + "void example2() {\n", + " int counter = 0;\n", + " double t0 = omp_get_wtime();\n", + "\n", + " #pragma omp parallel for num_threads(4)\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp critical\n", + " {\n", + " counter++;\n", + " }\n", + " }\n", + "\n", + " double elapsed = omp_get_wtime() - t0;\n", + " printf(\"critical: counter = %d, time = %.4f s\\n\", counter, elapsed);\n", + "}\n", + "\n", + "example2();" + ] + }, + { + "cell_type": "markdown", + "id": "ec744b0d", + "metadata": {}, + "source": [ + "The counter is now correct. But notice: with `critical`, threads spend most of their time **queuing at the mutex** rather than doing work. This makes parallel code *slower* than sequential for fine-grained operations.\n", + "\n", + "**When to use `critical`**: When the protected block is non-trivial (multiple statements, complex logic) and cannot be expressed as a single atomic operation." + ] + }, + { + "cell_type": "markdown", + "id": "8762443d", + "metadata": {}, + "source": [ + "---\n", + "## 3. Fix #2 - `#pragma omp atomic`\n", + "\n", + "`atomic` maps directly to a hardware atomic instruction (e.g., `LOCK XADD` on x86). It is **much faster** than `critical` for simple read-modify-write operations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8358fa20", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "atomic: counter = 1000000, time = 0.0168 s\n" + ] + } + ], + "source": [ + "void example3() {\n", + " int counter = 0;\n", + " double t0 = omp_get_wtime();\n", + "\n", + " #pragma omp parallel for num_threads(4)\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp atomic\n", + " counter++; // maps to a single atomic hardware instruction\n", + " }\n", + "\n", + " double elapsed = omp_get_wtime() - t0;\n", + " printf(\"atomic: counter = %d, time = %.4f s\\n\", counter, elapsed);\n", + "}\n", + "\n", + "example3();" + ] + }, + { + "cell_type": "markdown", + "id": "6c34b191", + "metadata": {}, + "source": [ + "### `atomic` clauses (OpenMP 3.1+)\n", + "\n", + "| Clause | Effect |\n", + "|--------|--------|\n", + "| `atomic update` (default) | `x++`, `x--`, `x += expr`, etc. |\n", + "| `atomic read` | `v = x` atomically |\n", + "| `atomic write` | `x = expr` atomically |\n", + "| `atomic capture` | `v = x; x op= expr` - read + update together |\n", + "\n", + "**Limitation**: `atomic` only works for a *single* variable with a *single* supported operator. Use `critical` for anything more complex." + ] + }, + { + "cell_type": "markdown", + "id": "ce4969eb", + "metadata": {}, + "source": [ + "---\n", + "## 4. Fix #3 - `reduction` clause (the fastest approach)\n", + "\n", + "The `reduction` clause is the idiomatic OpenMP solution for accumulation. Each thread gets a **private copy** of the variable, works independently (no synchronisation!), and OpenMP merges the results at the end of the parallel region.\n", + "\n", + "This is a **divide-and-conquer** strategy: eliminate the shared state entirely during the parallel phase." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cf2a0336", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reduction: counter = 1000000, time = 0.0005 s\n" + ] + } + ], + "source": [ + "void example4() {\n", + " int counter = 0;\n", + " double t0 = omp_get_wtime();\n", + "\n", + " #pragma omp parallel for num_threads(4) reduction(+:counter)\n", + " for (int i = 0; i < N; i++) {\n", + " counter++; // each thread increments its own private copy\n", + " }\n", + "\n", + " double elapsed = omp_get_wtime() - t0;\n", + " printf(\"reduction: counter = %d, time = %.4f s\\n\", counter, elapsed);\n", + "}\n", + "\n", + "example4();" + ] + }, + { + "cell_type": "markdown", + "id": "e1b99804", + "metadata": {}, + "source": [ + "### Supported reduction operators\n", + "\n", + "| Operator | Initial value | Use case |\n", + "|----------|--------------|----------|\n", + "| `+` | 0 | Sum |\n", + "| `*` | 1 | Product |\n", + "| `-` | 0 | Subtraction accumulation |\n", + "| `min` | type max | Minimum value |\n", + "| `max` | type min | Maximum value |\n", + "| `&` | ~0 | Bitwise AND |\n", + "| `\\|` | 0 | Bitwise OR |\n", + "| `^` | 0 | Bitwise XOR |\n", + "| `&&` | 1 | Logical AND |\n", + "| `\\|\\|` | 0 | Logical OR |" + ] + }, + { + "cell_type": "markdown", + "id": "572cbe98", + "metadata": {}, + "source": [ + "---\n", + "## 5. Benchmark - Compare All Approaches" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f67d05a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sequential: 0.001751 s\n", + "critical: 0.165203 s\n", + "atomic: 0.019443 s\n", + "reduction: 0.000474 s\n" + ] + } + ], + "source": [ + "#define THREADS 4\n", + "#define RUNS 5\n", + "\n", + "double bench_sequential() {\n", + " long long c = 0;\n", + " double t0 = omp_get_wtime();\n", + " for (int i = 0; i < N; i++) c++;\n", + " return omp_get_wtime() - t0;\n", + "}\n", + "\n", + "double bench_critical() {\n", + " long long c = 0;\n", + " double t0 = omp_get_wtime();\n", + " #pragma omp parallel for num_threads(THREADS)\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp critical\n", + " c++;\n", + " }\n", + " return omp_get_wtime() - t0;\n", + "}\n", + "\n", + "double bench_atomic() {\n", + " long long c = 0;\n", + " double t0 = omp_get_wtime();\n", + " #pragma omp parallel for num_threads(THREADS)\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp atomic\n", + " c++;\n", + " }\n", + " return omp_get_wtime() - t0;\n", + "}\n", + "\n", + "double bench_reduction() {\n", + " long long c = 0;\n", + " double t0 = omp_get_wtime();\n", + " #pragma omp parallel for num_threads(THREADS) reduction(+:c)\n", + " for (int i = 0; i < N; i++) c++;\n", + " return omp_get_wtime() - t0;\n", + "}\n", + "\n", + "double avg(double (*fn)()) {\n", + " double s = 0;\n", + " for (int i = 0; i < RUNS; i++) s += fn();\n", + " return s / RUNS;\n", + "}\n", + "\n", + "printf(\"sequential: %.6f s\\n\", avg(bench_sequential));\n", + "printf(\"critical: %.6f s\\n\", avg(bench_critical));\n", + "printf(\"atomic: %.6f s\\n\", avg(bench_atomic));\n", + "printf(\"reduction: %.6f s\\n\", avg(bench_reduction));" + ] + }, + { + "cell_type": "markdown", + "id": "a26c94cb", + "metadata": {}, + "source": [ + "### Reading the results\n", + "\n", + "| Approach | Why it's slow/fast |\n", + "|----------|--------------------|\n", + "| **sequential** | Baseline: single-threaded, no sync overhead |\n", + "| **critical** | Threads serialise at the mutex - effectively sequential *plus* lock overhead |\n", + "| **atomic** | Hardware atomic instruction: much cheaper than a mutex, but still causes cache-line bouncing between cores |\n", + "| **reduction** | No synchronisation during the loop; one merge at the end - fastest of the parallel options |" + ] + }, + { + "cell_type": "markdown", + "id": "71d7fe12", + "metadata": {}, + "source": [ + "---\n", + "## 6. A More Realistic Example - Histogram\n", + "\n", + "Counters are a toy problem. A **histogram** is a real-world accumulation where multiple bins are updated, making `reduction` over a single variable insufficient. This shows `critical` vs `atomic` in a meaningful context." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "abcaac25", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "atomic (per element): 0.1241 s\n", + "private + merge: 0.0066 s (speedup vs atomic: 18.9x)\n", + "\n", + "Histogram (should sum to 10000000):\n", + " bin[ 0] = 623773\n", + " bin[ 1] = 624866\n", + " bin[ 2] = 624957\n", + " bin[ 3] = 624934\n", + " bin[ 4] = 625238\n", + " bin[ 5] = 626471\n", + " bin[ 6] = 625747\n", + " bin[ 7] = 624270\n", + " bin[ 8] = 624621\n", + " bin[ 9] = 624898\n", + " bin[10] = 624977\n", + " bin[11] = 625217\n", + " bin[12] = 624620\n", + " bin[13] = 625424\n", + " bin[14] = 625240\n", + " bin[15] = 624747\n", + "Total: 10000000\n" + ] + } + ], + "source": [ + "#include \n", + "#include \n", + "\n", + "#define N_SAMPLES 10000000\n", + "#define N_BINS 16\n", + "\n", + "// Approach A: atomic update per bin\n", + "double histogram_atomic(int *data, long long *hist) {\n", + " memset(hist, 0, N_BINS * sizeof(long long));\n", + " double t0 = omp_get_wtime();\n", + " #pragma omp parallel for num_threads(THREADS)\n", + " for (int i = 0; i < N_SAMPLES; i++) {\n", + " #pragma omp atomic\n", + " hist[data[i]]++;\n", + " }\n", + " return omp_get_wtime() - t0;\n", + "}\n", + "\n", + "// Approach B: private histogram per thread, merge at end\n", + "double histogram_private(int *data, long long *hist) {\n", + " memset(hist, 0, N_BINS * sizeof(long long));\n", + " double t0 = omp_get_wtime();\n", + " #pragma omp parallel num_threads(THREADS)\n", + " {\n", + " long long local[N_BINS] = {0}; // thread-private copy\n", + " #pragma omp for\n", + " for (int i = 0; i < N_SAMPLES; i++)\n", + " local[data[i]]++;\n", + " // Merge: each bin is independent, so atomic is fine here\n", + " for (int b = 0; b < N_BINS; b++) {\n", + " #pragma omp atomic\n", + " hist[b] += local[b];\n", + " }\n", + " }\n", + " return omp_get_wtime() - t0;\n", + "}\n", + "\n", + "// Generate random data\n", + "int *data = (int*)malloc(N_SAMPLES * sizeof(int));\n", + "srand(42);\n", + "for (int i = 0; i < N_SAMPLES; i++) data[i] = rand() % N_BINS;\n", + "\n", + "long long hist[N_BINS];\n", + "\n", + "double t_atomic = histogram_atomic(data, hist);\n", + "double t_private = histogram_private(data, hist);\n", + "\n", + "printf(\"atomic (per element): %.4f s\\n\", t_atomic);\n", + "printf(\"private + merge: %.4f s (speedup vs atomic: %.1fx)\\n\",\n", + " t_private, t_atomic / t_private);\n", + "\n", + "// Print histogram to verify correctness\n", + "long long total = 0;\n", + "printf(\"\\nHistogram (should sum to %d):\\n\", N_SAMPLES);\n", + "for (int b = 0; b < N_BINS; b++) { printf(\" bin[%2d] = %lld\\n\", b, hist[b]); total += hist[b]; }\n", + "printf(\"Total: %lld\\n\", total);\n", + "\n", + "free(data);" + ] + }, + { + "cell_type": "markdown", + "id": "6371ac17", + "metadata": {}, + "source": [ + "The **private histogram** pattern is the general-purpose technique when you can't express the accumulation as a single built-in `reduction`. It trades memory (one copy of the histogram per thread) for speed (zero disagreement during the loop).\n", + "\n", + "> **Rule of thumb**: If threads all write to the *same* bin at the same time, cache-line contention kills performance even with `atomic`. Private copies eliminate this entirely." + ] + }, + { + "cell_type": "markdown", + "id": "be248cdf", + "metadata": {}, + "source": [ + "---\n", + "## 7. Summary - When to Use What\n", + "\n", + "| Mechanism | Overhead | Flexibility | Best for |\n", + "|-----------|----------|-------------|----------|\n", + "| `reduction` | **Lowest** | Only built-in ops on loop variable | Sums, products, min/max in loops |\n", + "| `atomic` | Low | Single variable, supported operators | Simple shared counters/flags |\n", + "| `critical` | **Highest** | Arbitrary code | Complex shared-state updates |\n", + "| Private + merge | Low (memory) | Anything | Histograms, complex accumulators |" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 + OpenMP", + "language": "cpp", + "name": "xcpp23-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/openmp/07_false_sharing.ipynb b/openmp/07_false_sharing.ipynb new file mode 100644 index 0000000..4419172 --- /dev/null +++ b/openmp/07_false_sharing.ipynb @@ -0,0 +1,321 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# False Sharing\n", + "\n", + "You fixed the race condition\n", + "Your atomic code is correct\n", + "But it's still slow... why? → **False Sharing**\n", + "\n", + "---\n", + "\n", + "## What is a Cache Line?\n", + "\n", + "CPUs don't load individual bytes from RAM - they load chunks called **cache lines** (typically **64 bytes**).\n", + "\n", + "When Thread 0 writes to `hist[0]`, the CPU loads the **entire 64-byte line** into Thread 0's cache. \n", + "When Thread 1 writes to `hist[1]`, it **invalidates** that line on Thread 0's cache - even though they touched different variables!\n", + "\n", + "This is **false sharing** - the sharing is false because the threads aren't actually sharing data, but the CPU thinks they are." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Threads: 4\n", + "Iterations: 100000000\n", + "Cache line: 64 bytes\n", + "sizeof(int) = 4 bytes\n", + "4 ints fit in 16 bytes (one cache line = 64 bytes)\n" + ] + } + ], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "#define THREADS 4\n", + "#define ITERATIONS 100000000 // 100 million\n", + "#define CACHE_LINE 64 // bytes per cache line\n", + "\n", + "printf(\"Threads: %d\\n\", THREADS);\n", + "printf(\"Iterations: %d\\n\", ITERATIONS);\n", + "printf(\"Cache line: %d bytes\\n\", CACHE_LINE);\n", + "printf(\"sizeof(int) = %zu bytes\\n\", sizeof(int));\n", + "printf(\"4 ints fit in %zu bytes (one cache line = %d bytes)\\n\",\n", + " 4 * sizeof(int), CACHE_LINE);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Experiment 1 - False Sharing (Bad)\n", + "\n", + "Each thread writes to its own `counter[thread_id]` - **different variables**, so no race condition. \n", + "But all 4 counters fit in **one cache line** → every write invalidates the line for all other threads." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False sharing: 0.2637 s (total = 100000000)\n" + ] + } + ], + "source": [ + "void false_sharing_demo() {\n", + " // All 4 counters sit next to each other in memory = one cache line\n", + " int counters[THREADS];\n", + " memset(counters, 0, sizeof(counters));\n", + "\n", + " double t0 = omp_get_wtime();\n", + "\n", + " #pragma omp parallel num_threads(THREADS)\n", + " {\n", + " int tid = omp_get_thread_num();\n", + " for (int i = 0; i < ITERATIONS / THREADS; i++) {\n", + " counters[tid]++; // No race condition, but FALSE SHARING!\n", + " }\n", + " }\n", + "\n", + " double elapsed = omp_get_wtime() - t0;\n", + "\n", + " long long total = 0;\n", + " for (int t = 0; t < THREADS; t++) total += counters[t];\n", + " printf(\"False sharing: %.4f s (total = %lld)\\n\", elapsed, total);\n", + "}\n", + "\n", + "false_sharing_demo();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Experiment 2 - No False Sharing (Padded)\n", + "\n", + "We pad each counter so it occupies a **full 64-byte cache line** by itself. \n", + "Now each thread's counter is on its own cache line → writes don't interfere.\n", + "\n", + "```\n", + "Cache line 1 (64 bytes) Cache line 2 (64 bytes)\n", + "┌────────┬──────────────────┐ ┌────────┬──────────────────┐\n", + "│counter0│ padding(60B) │ │counter1│ padding(60B) │\n", + "└────────┴──────────────────┘ └────────┴──────────────────┘\n", + " Thread 0 only Thread 1 only\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Padded (no FS): 0.0347 s (total = 100000000)\n" + ] + } + ], + "source": [ + "void no_false_sharing_demo() {\n", + " // Pad each counter to 64 bytes so each lives on its own cache line\n", + " struct {\n", + " int value;\n", + " char padding[60]; // 4 + 60 = 64 bytes = one full cache line\n", + " } counters[THREADS];\n", + "\n", + " for (int t = 0; t < THREADS; t++) counters[t].value = 0;\n", + "\n", + " double t0 = omp_get_wtime();\n", + "\n", + " #pragma omp parallel num_threads(THREADS)\n", + " {\n", + " int tid = omp_get_thread_num();\n", + " for (int i = 0; i < ITERATIONS / THREADS; i++) {\n", + " counters[tid].value++; // Each thread has its own cache line\n", + " }\n", + " }\n", + "\n", + " double elapsed = omp_get_wtime() - t0;\n", + "\n", + " long long total = 0;\n", + " for (int t = 0; t < THREADS; t++) total += counters[t].value;\n", + " printf(\"Padded (no FS): %.4f s (total = %lld)\\n\", elapsed, total);\n", + "}\n", + "\n", + "no_false_sharing_demo();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Experiment 3 - Private Variables (Best)\n", + "\n", + "Even better than padding: use **thread-private local variables** on the stack. \n", + "Stack variables are guaranteed to be in the thread's own memory - no sharing at all." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Private vars: 0.0433 s (total = 100000000)\n" + ] + } + ], + "source": [ + "void private_vars_demo() {\n", + " long long total = 0;\n", + "\n", + " double t0 = omp_get_wtime();\n", + "\n", + " #pragma omp parallel num_threads(THREADS) reduction(+:total)\n", + " {\n", + " long long local = 0; // lives on THIS thread's stack - completely private\n", + " for (int i = 0; i < ITERATIONS / THREADS; i++) {\n", + " local++; // no sharing of any kind\n", + " }\n", + " total += local; // reduction merges at the end\n", + " }\n", + "\n", + " double elapsed = omp_get_wtime() - t0;\n", + " printf(\"Private vars: %.4f s (total = %lld)\\n\", elapsed, total);\n", + "}\n", + "\n", + "private_vars_demo();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Experiment 4 - All Three Side by Side with Speedup" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Method Time Speedup vs FS\n", + "--------------------------------------------\n", + " False sharing: 0.2729 s 1.0x\n", + " Padded: 0.0315 s 8.7x\n", + " Private vars: 0.0425 s 6.4x\n" + ] + } + ], + "source": [ + "void run_all() {\n", + " double t0, t_fs, t_pad, t_priv;\n", + " long long total;\n", + "\n", + " //False Sharing\n", + " int counters_bad[THREADS];\n", + " memset(counters_bad, 0, sizeof(counters_bad));\n", + " t0 = omp_get_wtime();\n", + " #pragma omp parallel num_threads(THREADS)\n", + " {\n", + " int tid = omp_get_thread_num();\n", + " for (int i = 0; i < ITERATIONS / THREADS; i++)\n", + " counters_bad[tid]++;\n", + " }\n", + " t_fs = omp_get_wtime() - t0;\n", + "\n", + " //Padded\n", + " struct { int value; char pad[60]; } counters_good[THREADS];\n", + " for (int t = 0; t < THREADS; t++) counters_good[t].value = 0;\n", + " t0 = omp_get_wtime();\n", + " #pragma omp parallel num_threads(THREADS)\n", + " {\n", + " int tid = omp_get_thread_num();\n", + " for (int i = 0; i < ITERATIONS / THREADS; i++)\n", + " counters_good[tid].value++;\n", + " }\n", + " t_pad = omp_get_wtime() - t0;\n", + "\n", + " //Private\n", + " total = 0;\n", + " t0 = omp_get_wtime();\n", + " #pragma omp parallel num_threads(THREADS) reduction(+:total)\n", + " {\n", + " long long local = 0;\n", + " for (int i = 0; i < ITERATIONS / THREADS; i++)\n", + " local++;\n", + " total += local;\n", + " }\n", + " t_priv = omp_get_wtime() - t0;\n", + "\n", + " //Results\n", + " printf(\" Method Time Speedup vs FS\\n\");\n", + " printf(\"--------------------------------------------\\n\");\n", + " printf(\" False sharing: %.4f s 1.0x\\n\", t_fs);\n", + " printf(\" Padded: %.4f s %.1fx\\n\", t_pad, t_fs / t_pad);\n", + " printf(\" Private vars: %.4f s %.1fx\\n\", t_priv, t_fs / t_priv);\n", + "}\n", + "\n", + "run_all();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 + OpenMP", + "language": "cpp", + "name": "xcpp23-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/openmp/08_game_of_life.ipynb b/openmp/08_game_of_life.ipynb new file mode 100644 index 0000000..09f39dc --- /dev/null +++ b/openmp/08_game_of_life.ipynb @@ -0,0 +1,623 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conway's Game of Life - Parallel with OpenMP\n", + "\n", + "## The Rules (just 4)\n", + "\n", + "Each cell is either **alive** (1) or **dead** (0). Every generation, each cell looks at its **8 neighbours**:\n", + "\n", + "```\n", + "┌───┬───┬───┐\n", + "│ N │ N │ N │\n", + "├───┼───┼───┤\n", + "│ N │ X │ N │ X = current cell, N = neighbours\n", + "├───┼───┼───┤\n", + "│ N │ N │ N │\n", + "└───┴───┴───┘\n", + "```\n", + "\n", + "| Cell state | Neighbours | Next state | Rule name |\n", + "|---|---|---|---|\n", + "| Alive | < 2 | Dies | Underpopulation |\n", + "| Alive | 2 or 3 | Survives | Survival |\n", + "| Alive | > 3 | Dies | Overpopulation |\n", + "| Dead | exactly 3 | Born | Reproduction |\n", + "\n", + "Simple rules → incredibly complex emergent behaviour.\n", + "\n", + "---\n", + "\n", + "## The Parallelism Problem\n", + "\n", + "Every cell needs to **read** its neighbours and **write** its new state simultaneously.\n", + "If we read and write the same grid, a cell updated early would corrupt the neighbours of cells updated later.\n", + "\n", + "The solution: **double buffering** - two grids, always read from one, write to the other, then swap.\n", + "\n", + "---\n", + "## 1. Setup & Grid Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grid size: 8 x 16 = 128 cells\n", + "Threads: 4\n", + "Each thread handles ~2 rows\n" + ] + } + ], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "#define ROWS 8\n", + "#define COLS 16\n", + "#define THREADS 4\n", + "\n", + "// Two grids - the core of double buffering\n", + "// We ALWAYS read from grid[0], write to grid[1], then swap pointers\n", + "int grid_A[ROWS][COLS];\n", + "int grid_B[ROWS][COLS];\n", + "int (*current)[COLS] = grid_A; // pointer to the grid we READ from\n", + "int (*next)[COLS] = grid_B; // pointer to the grid we WRITE to\n", + "\n", + "// Print the grid nicely\n", + "void print_grid(int g[ROWS][COLS], int gen) {\n", + " printf(\"Generation %d:\\n\", gen);\n", + " for (int r = 0; r < ROWS; r++) {\n", + " printf(\"|\");\n", + " for (int c = 0; c < COLS; c++)\n", + " printf(\"%c\", g[r][c] ? '#' : '.');\n", + " printf(\"|\\n\");\n", + " }\n", + "}\n", + "\n", + "// Count living cells\n", + "int count_alive(int g[ROWS][COLS]) {\n", + " int count = 0;\n", + " for (int r = 0; r < ROWS; r++)\n", + " for (int c = 0; c < COLS; c++)\n", + " count += g[r][c];\n", + " return count;\n", + "}\n", + "\n", + "printf(\"Grid size: %d x %d = %d cells\\n\", ROWS, COLS, ROWS * COLS);\n", + "printf(\"Threads: %d\\n\", THREADS);\n", + "printf(\"Each thread handles ~%d rows\\n\", ROWS / THREADS);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 2. Why Double Buffering?\n", + "\n", + "Before we parallelize, let's understand the core problem.\n", + "\n", + "```\n", + "WRONG - single grid (read and write same grid):\n", + "\n", + " Step 1: update cell (2,3) → writes new value into grid[2][3]\n", + " Step 2: update cell (2,4) → reads grid[2][3] as a neighbour\n", + " BUT grid[2][3] is already the NEW value!\n", + " Cell (2,4) is computing based on corrupted data.\n", + "\n", + "CORRECT - double buffer:\n", + " \n", + " current[][] = old state (READ ONLY)\n", + " next[][] = new state (WRITE ONLY)\n", + "\n", + " All cells read from current[][] simultaneously - no corruption possible\n", + " All cells write to next[][] simultaneously - no conflicts\n", + " After all cells done: swap pointers (next becomes current)\n", + "```\n", + "\n", + "This is exactly what makes it safe to parallelize - threads can compute any cell in any order because they all read from the same frozen snapshot.\n", + "\n", + "---\n", + "## 3. The Step Function (Core Logic)\n", + "\n", + "`collapse(2)` flattens both loops so OpenMP splits all **128 cells** (8×16) across 4 threads — 32 cells per thread." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step() and count_neighbours() defined.\n", + "collapse(2) flattens the 2D loop into 1D so OpenMP can split 8*16=128 cells across 4 threads\n" + ] + } + ], + "source": [ + "// Count live neighbours of cell (r, c)\n", + "// Uses wrap-around edges (toroidal grid — top connects to bottom, left to right)\n", + "int count_neighbours(int g[ROWS][COLS], int r, int c) {\n", + " int count = 0;\n", + " for (int dr = -1; dr <= 1; dr++) {\n", + " for (int dc = -1; dc <= 1; dc++) {\n", + " if (dr == 0 && dc == 0) continue; // skip self\n", + " int nr = (r + dr + ROWS) % ROWS; // wrap around vertically\n", + " int nc = (c + dc + COLS) % COLS; // wrap around horizontally\n", + " count += g[nr][nc];\n", + " }\n", + " }\n", + " return count;\n", + "}\n", + "\n", + "// One generation step - parallel with OpenMP\n", + "// READ from: src (frozen snapshot)\n", + "// WRITE to: dst (fresh empty grid)\n", + "void step(int src[ROWS][COLS], int dst[ROWS][COLS]) {\n", + " #pragma omp parallel for num_threads(THREADS) collapse(2)\n", + " for (int r = 0; r < ROWS; r++) {\n", + " for (int c = 0; c < COLS; c++) {\n", + " int neighbours = count_neighbours(src, r, c);\n", + " int alive = src[r][c];\n", + "\n", + " // Apply the 4 rules\n", + " if (alive && neighbours < 2) dst[r][c] = 0; // underpopulation\n", + " else if (alive && neighbours <= 3) dst[r][c] = 1; // survival\n", + " else if (alive && neighbours > 3) dst[r][c] = 0; // overpopulation\n", + " else if (!alive && neighbours == 3) dst[r][c] = 1; // reproduction\n", + " else dst[r][c] = 0; // stays dead\n", + " }\n", + " }\n", + "}\n", + "\n", + "printf(\"step() and count_neighbours() defined.\\n\");\n", + "printf(\"collapse(2) flattens the 2D loop into 1D so OpenMP can split %d*%d=%d cells across %d threads\\n\",\n", + " ROWS, COLS, ROWS*COLS, THREADS);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 4. `collapse(2)` Explained\n", + "\n", + "Without `collapse(2)`, OpenMP only splits the **outer loop** (rows):\n", + "```\n", + "Thread 0 → rows 0-1 (each doing all 16 columns)\n", + "Thread 1 → rows 2-3\n", + "Thread 2 → rows 4-5\n", + "Thread 3 → rows 6-7\n", + "```\n", + "With `collapse(2)`, OpenMP merges both loops and splits **all 128 cells**:\n", + "```\n", + "Thread 0 → cells 0-31\n", + "Thread 1 → cells 32-63\n", + "Thread 2 → cells 64-95\n", + "Thread 3 → cells 96-127\n", + "```\n", + "On a small 8×16 grid this matters more — without collapse, each thread only gets 2 rows which is very coarse granularity." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 5. Pattern 1: Blinker (Period-2 Oscillator)\n", + "\n", + "The simplest oscillator - 3 cells in a line that flip between horizontal and vertical every generation. Placed in the middle of the 8×16 grid at row 4, col 8." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Blinker (should alternate horizontal/vertical) ===\n", + "\n", + "Generation 0:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|.......###......|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 1:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|........#.......|\n", + "|........#.......|\n", + "|........#.......|\n", + "|................|\n", + "|................|\n", + "Generation 2:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|.......###......|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 3:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|........#.......|\n", + "|........#.......|\n", + "|........#.......|\n", + "|................|\n", + "|................|\n", + "Generation 4:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|.......###......|\n", + "|................|\n", + "|................|\n", + "|................|\n" + ] + } + ], + "source": [ + "void run_blinker() {\n", + " // Reset both grids\n", + " memset(grid_A, 0, sizeof(grid_A));\n", + " memset(grid_B, 0, sizeof(grid_B));\n", + " current = grid_A;\n", + " next = grid_B;\n", + "\n", + " // Place a horizontal blinker in the middle\n", + " int r = ROWS / 2;\n", + " int c = COLS / 2;\n", + " current[r][c-1] = 1;\n", + " current[r][c] = 1;\n", + " current[r][c+1] = 1;\n", + "\n", + " printf(\"=== Blinker (should alternate horizontal/vertical) ===\\n\\n\");\n", + " print_grid(current, 0);\n", + "\n", + " for (int gen = 1; gen <= 4; gen++) {\n", + " step(current, next);\n", + "\n", + " // Swap buffers — next becomes current, current becomes next\n", + " int (*tmp)[COLS] = current;\n", + " current = next;\n", + " next = tmp;\n", + "\n", + " print_grid(current, gen);\n", + " }\n", + "}\n", + "\n", + "run_blinker();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 6. Pattern 2: Glider\n", + "\n", + "The glider moves diagonally across the grid forever - it takes 4 generations to return to its original shape but shifted by 1 cell diagonally." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Glider (watch it move diagonally) ===\n", + "\n", + "Generation 0:\n", + "|................|\n", + "|..#.............|\n", + "|...#............|\n", + "|.###............|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 1:\n", + "|................|\n", + "|................|\n", + "|.#.#............|\n", + "|..##............|\n", + "|..#.............|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 2:\n", + "|................|\n", + "|................|\n", + "|...#............|\n", + "|.#.#............|\n", + "|..##............|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 3:\n", + "|................|\n", + "|................|\n", + "|..#.............|\n", + "|...##...........|\n", + "|..##............|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 4:\n", + "|................|\n", + "|................|\n", + "|...#............|\n", + "|....#...........|\n", + "|..###...........|\n", + "|................|\n", + "|................|\n", + "|................|\n", + "Generation 5:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|..#.#...........|\n", + "|...##...........|\n", + "|...#............|\n", + "|................|\n", + "|................|\n", + "Generation 6:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|....#...........|\n", + "|..#.#...........|\n", + "|...##...........|\n", + "|................|\n", + "|................|\n", + "Generation 7:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|...#............|\n", + "|....##..........|\n", + "|...##...........|\n", + "|................|\n", + "|................|\n", + "Generation 8:\n", + "|................|\n", + "|................|\n", + "|................|\n", + "|....#...........|\n", + "|.....#..........|\n", + "|...###..........|\n", + "|................|\n", + "|................|\n" + ] + } + ], + "source": [ + "void run_glider() {\n", + " memset(grid_A, 0, sizeof(grid_A));\n", + " memset(grid_B, 0, sizeof(grid_B));\n", + " current = grid_A;\n", + " next = grid_B;\n", + "\n", + " // Classic glider pattern:\n", + " // .X.\n", + " // ..X\n", + " // XXX\n", + " current[1][2] = 1;\n", + " current[2][3] = 1;\n", + " current[3][1] = 1;\n", + " current[3][2] = 1;\n", + " current[3][3] = 1;\n", + "\n", + " printf(\"=== Glider (watch it move diagonally) ===\\n\\n\");\n", + " print_grid(current, 0);\n", + "\n", + " for (int gen = 1; gen <= 8; gen++) {\n", + " step(current, next);\n", + " int (*tmp)[COLS] = current;\n", + " current = next;\n", + " next = tmp;\n", + "\n", + " //if (gen % 2 == 0) // print every 2 generations to keep output short\n", + " print_grid(current, gen);\n", + " }\n", + "}\n", + "\n", + "run_glider();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 7. Performance: Sequential vs Parallel" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grid: 512x512 = 262144 cells, 100 generations\n", + "=============================================\n", + " Sequential: 1.3265 s\n", + " Parallel: 0.3410 s (3.9x speedup)\n", + "=============================================\n" + ] + } + ], + "source": [ + "#define BENCH_ROWS 512\n", + "#define BENCH_COLS 512\n", + "#define GENERATIONS 100\n", + "\n", + "// Allocate large grids on the heap for benchmarking\n", + "int *bench_A = (int*)calloc(BENCH_ROWS * BENCH_COLS, sizeof(int));\n", + "int *bench_B = (int*)calloc(BENCH_ROWS * BENCH_COLS, sizeof(int));\n", + "\n", + "#define BENCH_IDX(r, c) ((r) * BENCH_COLS + (c))\n", + "\n", + "// Seed with random pattern\n", + "srand(42);\n", + "for (int i = 0; i < BENCH_ROWS * BENCH_COLS; i++)\n", + " bench_A[i] = rand() % 2;\n", + "\n", + "// Sequential step\n", + "void step_seq(int *src, int *dst) {\n", + " for (int r = 0; r < BENCH_ROWS; r++) {\n", + " for (int c = 0; c < BENCH_COLS; c++) {\n", + " int n = 0;\n", + " for (int dr = -1; dr <= 1; dr++)\n", + " for (int dc = -1; dc <= 1; dc++) {\n", + " if (dr == 0 && dc == 0) continue;\n", + " int nr = (r + dr + BENCH_ROWS) % BENCH_ROWS;\n", + " int nc = (c + dc + BENCH_COLS) % BENCH_COLS;\n", + " n += src[BENCH_IDX(nr, nc)];\n", + " }\n", + " int alive = src[BENCH_IDX(r, c)];\n", + " dst[BENCH_IDX(r, c)] = (alive && n == 2) || n == 3 ? 1 : 0;\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Parallel step\n", + "void step_par(int *src, int *dst) {\n", + " #pragma omp parallel for num_threads(THREADS) collapse(2)\n", + " for (int r = 0; r < BENCH_ROWS; r++) {\n", + " for (int c = 0; c < BENCH_COLS; c++) {\n", + " int n = 0;\n", + " for (int dr = -1; dr <= 1; dr++)\n", + " for (int dc = -1; dc <= 1; dc++) {\n", + " if (dr == 0 && dc == 0) continue;\n", + " int nr = (r + dr + BENCH_ROWS) % BENCH_ROWS;\n", + " int nc = (c + dc + BENCH_COLS) % BENCH_COLS;\n", + " n += src[BENCH_IDX(nr, nc)];\n", + " }\n", + " int alive = src[BENCH_IDX(r, c)];\n", + " dst[BENCH_IDX(r, c)] = (alive && n == 2) || n == 3 ? 1 : 0;\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Benchmark sequential\n", + "int *src = bench_A, *dst = bench_B;\n", + "double t0 = omp_get_wtime();\n", + "for (int g = 0; g < GENERATIONS; g++) {\n", + " step_seq(src, dst);\n", + " int *tmp = src; src = dst; dst = tmp;\n", + "}\n", + "double t_seq = omp_get_wtime() - t0;\n", + "\n", + "// Reset and benchmark parallel\n", + "srand(42);\n", + "for (int i = 0; i < BENCH_ROWS * BENCH_COLS; i++) bench_A[i] = rand() % 2;\n", + "src = bench_A; dst = bench_B;\n", + "t0 = omp_get_wtime();\n", + "for (int g = 0; g < GENERATIONS; g++) {\n", + " step_par(src, dst);\n", + " int *tmp = src; src = dst; dst = tmp;\n", + "}\n", + "double t_par = omp_get_wtime() - t0;\n", + "\n", + "printf(\"Grid: %dx%d = %d cells, %d generations\\n\",\n", + " BENCH_ROWS, BENCH_COLS, BENCH_ROWS * BENCH_COLS, GENERATIONS);\n", + "printf(\"=============================================\\n\");\n", + "printf(\" Sequential: %.4f s\\n\", t_seq);\n", + "printf(\" Parallel: %.4f s (%.1fx speedup)\\n\", t_par, t_seq / t_par);\n", + "printf(\"=============================================\\n\");\n", + "\n", + "free(bench_A);\n", + "free(bench_B);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 8. Why Double Buffering Has Zero Race Conditions\n", + "\n", + "Let's prove to ourselves it's safe by thinking through what each thread touches:\n", + "\n", + "```\n", + "Generation N (frozen - nobody writes here):\n", + "┌─────────────────────────────────────┐\n", + "│ current[][] READ ONLY │\n", + "│ Thread 0 reads rows 0-1 │\n", + "│ Thread 1 reads rows 2-3 │\n", + "│ Thread 2 reads rows 4-5 │\n", + "│ Thread 3 reads rows 6-7 │\n", + "│ (multiple readers = always safe) │\n", + "└─────────────────────────────────────┘\n", + "\n", + "Generation N+1 (being built - nobody reads here yet):\n", + "┌─────────────────────────────────────┐\n", + "│ next[][] WRITE ONLY │\n", + "│ Thread 0 writes rows 0-1 │\n", + "│ Thread 1 writes rows 2-3 │\n", + "│ Thread 2 writes rows 4-5 │\n", + "│ Thread 3 writes rows 6-7 │\n", + "│ (each thread owns different rows) │\n", + "└─────────────────────────────────────┘\n", + "\n", + "After all threads finish:\n", + " swap(current, next) ← just swapping two pointers, O(1)\n", + "```\n", + "\n", + "No atomics needed. No critical sections. No locks. \n", + "The double buffer design **eliminates** the race condition structurally." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++23 + OpenMP", + "language": "cpp", + "name": "xcpp23-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/openmp/images/fork_join.png b/openmp/images/fork_join.png new file mode 100644 index 0000000..defa4d3 Binary files /dev/null and b/openmp/images/fork_join.png differ diff --git a/openmp/mandel.ipynb b/openmp/mandel.ipynb deleted file mode 100644 index 08a6b64..0000000 --- a/openmp/mandel.ipynb +++ /dev/null @@ -1,133 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "5059dbdd-821d-498a-8716-eb0fcf8a8f5f", - "metadata": {}, - "outputs": [], - "source": [ - "#include \n", - "#include \n", - "#include \n", - "#include " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8b66f96a-14ef-4f23-8024-bcfc42b31e4e", - "metadata": {}, - "outputs": [], - "source": [ - "#define NPOINTS 1000\n", - "#define MAXITER 1000" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d89dd57c-fe19-4233-a33a-df9b24fae98a", - "metadata": {}, - "outputs": [], - "source": [ - "int numoutside = 0;" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5c35c479-2f79-46b7-bc66-24be6b1694e0", - "metadata": {}, - "outputs": [], - "source": [ - "void testpoint(double creal, double cimag) {\n", - " // iterate z=z*z+c, until |z| > 2 when point is known to be outside set\n", - " // If loop count reaches MAXITER, point is considered to be inside the set\n", - "\n", - " double zreal, zimag, temp;\n", - " int iter;\n", - " zreal = creal;\n", - " zimag = cimag;\n", - "\n", - " for (iter = 0; iter < MAXITER; iter++) {\n", - " temp = (zreal * zreal) - (zimag * zimag) + creal;\n", - " zimag = zreal * zimag * 2 + cimag;\n", - " zreal = temp;\n", - " if ((zreal * zreal + zimag * zimag) > 4.0) {\n", - " numoutside++;\n", - " break;\n", - " }\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ea116fef-7d05-4e29-97a1-55c85c7241d8", - "metadata": {}, - "outputs": [], - "source": [ - "int main() {\n", - " int i, j;\n", - " double area, error, eps = 1.0e-5;\n", - " double cimag, creal;\n", - " // Loop over grid of points in the complex plane which contains the Mandelbrot set,\n", - " // testing each point to see whether it is inside or outside the set.\n", - "\n", - "#pragma omp parallel for private(eps)\n", - " for (i = 0; i < NPOINTS; i++) {\n", - " for (j = 0; j < NPOINTS; j++) {\n", - " creal = -2.0 + 2.5 * (double) (i) / (double) (NPOINTS) + eps;\n", - " cimag = 1.125 * (double) (j) / (double) (NPOINTS) + eps;\n", - " testpoint(creal, cimag);\n", - " }\n", - " }\n", - "\n", - " // Calculate area of set and error estimate and output the results\n", - " area = 2.0 * 2.5 * 1.125 * (double) (NPOINTS * NPOINTS - numoutside) / (double) (NPOINTS * NPOINTS);\n", - " error = area / (double) NPOINTS;\n", - "\n", - " printf(\"Area of Mandlebrot set = %12.8f +/- %12.8f\\n\", area, error);\n", - " printf(\"Correct answer should be around 1.510659\\n\");\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "39cf129c-8106-4e67-a2f1-1a7fff17cd38", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Area of Mandlebrot set = 3.80247750 +/- 0.00380248\n", - "Correct answer should be around 1.510659\n" - ] - } - ], - "source": [ - "main();" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "C++23 (xcpp+OpenMP)", - "language": "cpp", - "name": "xcpp23-omp" - }, - "language_info": { - "codemirror_mode": "text/x-c++src", - "file_extension": ".cpp", - "mimetype": "text/x-c++src", - "name": "C++", - "version": "23" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/openmp/openmp-demo.ipynb b/openmp/openmp-demo.ipynb deleted file mode 100644 index 101ade0..0000000 --- a/openmp/openmp-demo.ipynb +++ /dev/null @@ -1,220 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "b0c15570-ee24-42ed-b61f-11a3fc858b2d", - "metadata": {}, - "outputs": [], - "source": [ - "#include \n", - "#include " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5001e441-1fa5-4bdc-9fa5-2ca103ae484f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World!\n" - ] - } - ], - "source": [ - "void example1() {\n", - " std::cout << \"Hello World!\" << std::endl;\n", - "}\n", - "example1();" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "53fb7656-b72e-42bc-ade7-2ae2077142da", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World!Hello World!\n", - "Hello World!Hello World!\n", - "Hello World!\n", - "\n", - "Hello World!\n", - "\n", - "Hello World!\n", - "Hello World!\n" - ] - } - ], - "source": [ - "void example2() {\n", - " #pragma omp parallel\n", - " {\n", - " std::cout << \"Hello World!\" << std::endl;\n", - " }\n", - "}\n", - "example2();" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "efcdfdb6-a60b-46af-8194-75ef9cc0e27f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World! (Hello World! (Hello World! (Hello World! (34)\n", - "Hello World! (7)\n", - "0)\n", - "2Hello World! (6))\n", - "\n", - ")\n", - "Hello World! (5)\n", - "Hello World! (1)\n" - ] - } - ], - "source": [ - "void example3() {\n", - " #pragma omp parallel\n", - " {\n", - " std::cout << \"Hello World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", - " }\n", - "}\n", - "example3();" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d86a9efa-ba28-4cb6-bbfc-abc00ee63506", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World! (Hello World! (34))\n", - "Hello World! (0)\n", - "Hello World! (2)\n", - "Hello World! (Hello World! (1)\n", - "\n", - "7)Hello World! (\n", - "6)\n", - "Hello World! (5)\n", - "This is another message! (0)\n", - "Goodbye World! (0)\n", - "Goodbye World! (1)\n" - ] - } - ], - "source": [ - "void example4() {\n", - " #pragma omp parallel\n", - " {\n", - " std::cout << \"Hello World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", - " }\n", - "\n", - " std::cout << \"This is another message! (\" << omp_get_thread_num() << \")\" << std::endl;\n", - "\n", - " #pragma omp parallel num_threads(2)\n", - " {\n", - " std::cout << \"Goodbye World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", - " }\n", - "}\n", - "example4();" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "5557e01a-7c7d-4b54-8545-962ad11027df", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initialize a[] time: 0.588681\n", - "Initialize b[] time: 0.513927\n", - "Add arrays time: 1.58928\n", - "Average result time: 0.637053\n", - "Average: 5e+08\n", - "Total time: 3.33191\n" - ] - } - ], - "source": [ - "void example5() {\n", - " double start_time = omp_get_wtime();\n", - " double start_loop;\n", - " \n", - " const int N = 1000000000;\n", - " int* a = new int[N];\n", - " int* b = new int[N];\n", - " \n", - " start_loop = omp_get_wtime();\n", - " #pragma omp parallel for\n", - " for (int i=0; i\n", - "#include " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "9078ac79-ca50-4fef-b785-37f35fec3cab", - "metadata": {}, - "outputs": [], - "source": [ - "static long num_steps = 100000000;\n", - "double step;" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f3c10995-6f29-4d71-9e61-1993ca9d1cc9", - "metadata": {}, - "outputs": [], - "source": [ - "int main() {\n", - " int i, j, num_threads_allocated;\n", - " double x, pi, sum = 0.0;\n", - " double start_time, run_time;\n", - "\n", - " step = 1.0 / (double)num_steps;\n", - " printf(\"Num threads available: %d\\n\", omp_get_max_threads());\n", - " for (i = 1; i <= 4; i++) {\n", - " sum = 0.0;\n", - " omp_set_num_threads(i);\n", - " start_time = omp_get_wtime();\n", - "#pragma omp parallel\n", - " {\n", - " num_threads_allocated = omp_get_num_threads();\n", - "#pragma omp single\n", - " printf(\"Num threads allocated for this run: %d\\n\", num_threads_allocated);\n", - "\n", - "#pragma omp for reduction(+ : sum)\n", - " for (j = 1; j <= num_steps; j++) {\n", - " x = (j - 0.5) * step;\n", - " sum = sum + 4.0 / (1.0 + x * x);\n", - " }\n", - " }\n", - "\n", - " pi = step * sum;\n", - " run_time = omp_get_wtime() - start_time;\n", - " printf(\"pi is %f in %f seconds using %d threads\\n\\n\", pi, run_time, num_threads_allocated);\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0f84442a-d947-4860-bd3c-aeeea963b419", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num threads available: 8\n", - "Num threads allocated for this run: 1\n", - "pi is 3.141593 in 0.179501 seconds using 1 threads\n", - "\n", - "Num threads allocated for this run: 2\n", - "pi is 3.141592 in 0.184605 seconds using 2 threads\n", - "\n", - "Num threads allocated for this run: 3\n", - "pi is 3.141593 in 0.097145 seconds using 3 threads\n", - "\n", - "Num threads allocated for this run: 4\n", - "pi is 3.141593 in 0.071473 seconds using 4 threads\n", - "\n" - ] - } - ], - "source": [ - "main();" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "C++23 (xcpp+OpenMP)", - "language": "cpp", - "name": "xcpp23-omp" - }, - "language_info": { - "codemirror_mode": "text/x-c++src", - "file_extension": ".cpp", - "mimetype": "text/x-c++src", - "name": "C++", - "version": "23" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 3e539e4..e66bf5a 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -4,79 +4,205 @@ import os import re -class NotebookTests(unittest.TestCase): - kernel_name = 'xcpp23' # Your standard C++ kernel name - notebook_dir = 'xeus-cpp' +def sanitize_and_sort_output(text): + if not text: + return "" + + lines = [] + raw_lines = text.strip().split('\n') + + for line in raw_lines: + cleaned = line.strip() + if not cleaned: + continue + + # drop fragments (safety net for split text streams) + if len(cleaned) <= 2 and re.match(r'^[()\d\s!]+$', cleaned): + continue + + # handle histograms + if "bin[" in cleaned: + # standardize variable array values to 'x', keeping the bin index intact + cleaned = re.sub(r'=\s*\d+', '= x', cleaned) + lines.append(cleaned) + continue + + # handle data race counters + elif "counter =" in cleaned: + cleaned = re.sub(r'counter\s*=\s*\d+', 'counter = x', cleaned) + cleaned = re.sub(r'lost\s*\d+', 'lost x', cleaned) + + # parse milliseconds first, then seconds (order matters) + cleaned = re.sub(r'\d+(\.\d+)?\s*ms\b', 'x.x ms', cleaned) + cleaned = re.sub(r'\d+(\.\d+)?\s*s\b', 'x.x s', cleaned) + lines.append(cleaned) + continue + + # handle parallel core prints + elif "Hello World!" in cleaned: + count = cleaned.count("Hello World!") + for _ in range(count): + lines.append("Hello World! (x)") + continue + + elif "Goodbye World!" in cleaned: + count = cleaned.count("Goodbye World!") + for _ in range(count): + lines.append("Goodbye World! (x)") + continue + + elif "This is another message!" in cleaned: + lines.append("This is another message! (x)") + continue + + # general timings, benchmarks, speedups & tables + else: + # parse dynamic speedups like "18.9x" or "6.4x" into "x.xx" + cleaned = re.sub(r'\d+(\.\d+)?x', 'x.xx', cleaned) + + # parse floats/integers attached to execution seconds (e.g., "0.1241 s", "2 s") + cleaned = re.sub(r'\d+(\.\d+)?\s*ms\b', 'x.x ms', cleaned) + cleaned = re.sub(r'\d+(\.\d+)?\s*s\b', 'x.x s', cleaned) + + # parse metrics like "Total = 10000000" into standard values if they differ + cleaned = re.sub(r'total\s*=\s*\d+', 'total = x', cleaned, flags=re.IGNORECASE) + + # general float / timing cleanup fallback + cleaned = re.sub(r'\d+\.\d+(e\+\d+)?|\d+e\+\d+', 'x.x', cleaned) + + # if the line was a table header separator line (e.g., "------------"), + # compress it to prevent spaces from altering the alphabetical sort order + if re.match(r"^[-'\s]+$", cleaned): + cleaned = "---" + + lines.append(cleaned) + + # sort everything alphabetically to neutralize thread execution randomness + lines.sort() + return '\n'.join(lines) + + +class BaseNotebookTests(unittest.TestCase): + __test__ = False + kernel_name = None + notebook_dir = None + # flag to control sorting behavior dynamically + should_sort_parallel_outputs = False + skip_gpu_hardware_cells = False def test_notebooks(self): - # Scan the target folder for notebooks notebook_files = [ f for f in os.listdir(self.notebook_dir) if f.endswith('.ipynb') ] if not notebook_files: - self.fail(f"No notebooks found in directory: {self.notebook_dir}") + self.fail(f"No notebooks found in {self.notebook_dir}") os.makedirs('executed', exist_ok=True) for name in notebook_files: - + # skip intentional error notebook if encountered in the target directories if name == "03_redefinition.ipynb": print(f"--> Skipping intentional error notebook: {name}") continue - + inp = os.path.join(self.notebook_dir, name) out = os.path.join('executed', name) - # Load the reference notebook (Expected) with open(inp) as f: input_nb = nbformat.read(f, as_version=4) - # Run the notebook via Papermill try: executed_notebook = pm.execute_notebook( inp, out, log_output=True, - kernel_name=self.kernel_name + kernel_name=self.kernel_name, + cwd=os.path.dirname(os.path.abspath(inp)) ) if executed_notebook is None: self.fail(f"Execution of notebook {name} returned None") except Exception as e: - self.fail(f"Notebook {name} failed to execute smoothly: {e}") + self.fail(f"Notebook {name} failed to execute: {e}") - # Load the freshly executed notebook (Got) with open(out) as f: output_nb = nbformat.read(f, as_version=4) - # Compare cell outputs exactly for i, (input_cell, output_cell) in enumerate( zip(input_nb.cells, output_nb.cells) ): if input_cell.cell_type == 'code' and output_cell.cell_type == 'code': - # Extract and clean exact raw text streams - expected_text = ''.join( - o.get('text', '') for o in input_cell.outputs if o.get('output_type') == 'stream' - ).strip() + if bool(input_cell.outputs) != bool(output_cell.outputs): + self.fail( + f"Cell {i} in notebook {name} has mismatched output presence.\n" + f"Expected outputs: {bool(input_cell.outputs)}, " + f"Got: {bool(output_cell.outputs)}" + ) - got_text = ''.join( - o.get('text', '') for o in output_cell.outputs if o.get('output_type') == 'stream' - ).strip() + elif input_cell.outputs: + # extract the raw text from reference cells + expected_raw = ''.join( + o.get('text', '') for o in input_cell.outputs if o.get('output_type') == 'stream' + ) + # extract the raw text from execution cells + got_raw = ''.join( + o.get('text', '') for o in output_cell.outputs if o.get('output_type') == 'stream' + ) + + # apply pointer memory hex sanitization to all types of notebooks + expected_raw = re.sub(r'0x[0-9a-fA-F]+', '0x7fffffff', expected_raw) + got_raw = re.sub(r'0x[0-9a-fA-F]+', '0x7fffffff', got_raw) + + # apply undefined behavior garbage integer sanitization to all types of notebooks + ub_pattern = r'(Undefined Behavior \(Reading freed heap\):\s*)-?\d+' + expected_raw = re.sub(ub_pattern, r'\1[garbage_int]', expected_raw) + got_raw = re.sub(ub_pattern, r'\1[garbage_int]', got_raw) - expected_text = re.sub(r'0x[0-9a-fA-F]+', '0x7fffffff', expected_text) - got_text = re.sub(r'0x[0-9a-fA-F]+', '0x7fffffff', got_text) - - ub_pattern = r'(Undefined Behavior \(Reading freed heap\):\s*)-?\d+' - expected_text = re.sub(ub_pattern, r'\1[GARBAGE_INT]', expected_text) - got_text = re.sub(ub_pattern, r'\1[GARBAGE_INT]', got_text) + # conditional logic split here + if self.should_sort_parallel_outputs: + # run the heavy shuffling filters for parallel runs (openmp / cuda) + expected_clean = sanitize_and_sort_output(expected_raw) + got_clean = sanitize_and_sort_output(got_raw) + else: + # keep standard sequential text formats intact for core c++ notebooks + expected_clean = expected_raw.strip() + got_clean = got_raw.strip() + if self.skip_gpu_hardware_cells: + gpu_hardware_patterns = ["GPU:", "Streaming Multiprocessors", "Max threads per SM", "Max warps per SM"] + if any(p in expected_clean for p in gpu_hardware_patterns): + print(f"Skipping GPU hardware info cell {i} in {name}") + continue + + if expected_clean != got_clean: + self.fail( + f"Cell {i} in notebook {name} has mismatched output.\n\n" + f"--- Expected ---\n{expected_clean}\n\n" + f"--- Got ---\n{got_clean}" + ) + + +class CppNotebookTests(BaseNotebookTests): + __test__ = True + kernel_name = 'xcpp23' # standard core c++ kernel + notebook_dir = 'xeus-cpp' + should_sort_parallel_outputs = False # stays sequential + + +class OpenMPNotebookTests(BaseNotebookTests): + __test__ = True + kernel_name = 'xcpp23-omp' + notebook_dir = 'openmp' + should_sort_parallel_outputs = True # uses parallel filters + + +class CudaNotebookTests(BaseNotebookTests): + __test__ = True + kernel_name = 'xcpp23-cuda' + notebook_dir = 'cuda' + should_sort_parallel_outputs = True # uses parallel filters + skip_gpu_hardware_cells = True - if expected_text != got_text: - self.fail( - f"Cell {i} in notebook '{name}' has mismatched output.\n\n" - f"--- Expected ---\n{expected_text}\n\n" - f"--- Got ---\n{got_text}" - ) if __name__ == '__main__': unittest.main() diff --git a/xeus-cpp/10_modular_notebook_design.ipynb b/xeus-cpp/10_modular_notebook_design.ipynb index 0454d7e..1e33db0 100644 --- a/xeus-cpp/10_modular_notebook_design.ipynb +++ b/xeus-cpp/10_modular_notebook_design.ipynb @@ -62,13 +62,12 @@ "#include \n", "#include \n", "#include \n", - "using namespace std;\n", "\n", "// Notebook-wide constants\n", "const bool VERBOSE = true;\n", - "auto log = [](const string& msg) { if (VERBOSE) cout << \"[LOG] \" << msg << endl; };\n", + "auto log = [](const std::string& msg) { if (VERBOSE) std::cout << \"[LOG] \" << msg << std::endl; };\n", "\n", - "cout << \"Setup complete.\" << endl;" + "std::cout << \"Setup complete.\" << std::endl;" ] }, { @@ -97,7 +96,7 @@ "//Task Priority Enum\n", "enum class Priority { Low, Medium, High, Critical };\n", "\n", - "string priorityName(Priority p) {\n", + "std::string priorityName(Priority p) {\n", " switch (p) {\n", " case Priority::Low: return \"Low\";\n", " case Priority::Medium: return \"Medium\";\n", @@ -110,7 +109,7 @@ "//Task Status\n", "enum class Status { Todo, InProgress, Done };\n", "\n", - "string statusName(Status s) {\n", + "std::string statusName(Status s) {\n", " switch (s) {\n", " case Status::Todo: return \"Todo\";\n", " case Status::InProgress: return \"InProgress\";\n", @@ -119,7 +118,7 @@ " return \"Unknown\";\n", "}\n", "\n", - "cout << \"Types defined.\" << endl;" + "std::cout << \"Types defined.\" << std::endl;" ] }, { @@ -148,43 +147,43 @@ "class Task {\n", " static int nextId;\n", " int id;\n", - " string title;\n", + " std::string title;\n", " Priority priority;\n", " Status status;\n", "\n", "public:\n", - " Task(const string& title, Priority p = Priority::Medium)\n", + " Task(const std::string& title, Priority p = Priority::Medium)\n", " : id(nextId++), title(title), priority(p), status(Status::Todo) {\n", - " log(\"Created task #\" + to_string(id) + \": \" + title);\n", + " log(\"Created task #\" + std::to_string(id) + \": \" + title);\n", " }\n", "\n", " void start() {\n", - " if (status != Status::Todo) throw logic_error(\"Task already started or done\");\n", + " if (status != Status::Todo) throw std::logic_error(\"Task already started or done\");\n", " status = Status::InProgress;\n", - " log(\"Started task #\" + to_string(id));\n", + " log(\"Started task #\" + std::to_string(id));\n", " }\n", "\n", " void complete() {\n", - " if (status == Status::Done) throw logic_error(\"Task already done\");\n", + " if (status == Status::Done) throw std::logic_error(\"Task already done\");\n", " status = Status::Done;\n", - " log(\"Completed task #\" + to_string(id));\n", + " log(\"Completed task #\" + std::to_string(id));\n", " }\n", "\n", " int getId() const { return id; }\n", - " const string& getTitle() const { return title; }\n", + " const std::string& getTitle() const { return title; }\n", " Priority getPriority() const { return priority; }\n", " Status getStatus() const { return status; }\n", "\n", " void print() const {\n", - " printf(\"[#%02d] %-25s Priority:%-9s Status:%s\\n\",\n", - " id, title.c_str(),\n", - " priorityName(priority).c_str(),\n", - " statusName(status).c_str());\n", + " std::printf(\"[#%02d] %-25s Priority:%-9s Status:%s\\n\",\n", + " id, title.c_str(),\n", + " priorityName(priority).c_str(),\n", + " statusName(status).c_str());\n", " }\n", "};\n", "\n", "int Task::nextId = 1;\n", - "cout << \"Task class defined.\" << endl;" + "std::cout << \"Task class defined.\" << std::endl;" ] }, { @@ -203,25 +202,25 @@ ], "source": [ "class TaskManager {\n", - " vector> tasks;\n", + " std::vector> tasks;\n", "\n", "public:\n", - " shared_ptr add(const string& title, Priority p = Priority::Medium) {\n", - " auto t = make_shared(title, p);\n", + " std::shared_ptr add(const std::string& title, Priority p = Priority::Medium) {\n", + " auto t = std::make_shared(title, p);\n", " tasks.push_back(t);\n", " return t;\n", " }\n", "\n", - " vector> byPriority(Priority p) const {\n", - " vector> result;\n", - " copy_if(tasks.begin(), tasks.end(), back_inserter(result),\n", + " std::vector> byPriority(Priority p) const {\n", + " std::vector> result;\n", + " std::copy_if(tasks.begin(), tasks.end(), std::back_inserter(result),\n", " [p](const auto& t) { return t->getPriority() == p; });\n", " return result;\n", " }\n", "\n", - " vector> byStatus(Status s) const {\n", - " vector> result;\n", - " copy_if(tasks.begin(), tasks.end(), back_inserter(result),\n", + " std::vector> byStatus(Status s) const {\n", + " std::vector> result;\n", + " std::copy_if(tasks.begin(), tasks.end(), std::back_inserter(result),\n", " [s](const auto& t) { return t->getStatus() == s; });\n", " return result;\n", " }\n", @@ -233,7 +232,7 @@ " size_t count() const { return tasks.size(); }\n", "};\n", "\n", - "cout << \"TaskManager class defined.\" << endl;" + "std::cout << \"TaskManager class defined.\" << std::endl;" ] }, { @@ -289,7 +288,7 @@ "t2->start();\n", "t3->start();\n", "\n", - "cout << \"\\nAll Tasks:\\n\";\n", + "std::cout << \"\\nAll Tasks:\\n\";\n", "tm.printAll();" ] }, @@ -329,36 +328,38 @@ "source": [ "// Filter tests\n", "auto highPriority = tm.byPriority(Priority::High);\n", - "cout << \"\\nHigh-priority tasks (\" << highPriority.size() << \"):\" << endl;\n", + "std::cout << \"\\nHigh-priority tasks (\" << highPriority.size() << \"):\" << std::endl;\n", "for (const auto& t : highPriority) t->print();\n", "\n", "auto inProgress = tm.byStatus(Status::InProgress);\n", - "cout << \"\\nIn-progress tasks (\" << inProgress.size() << \"):\" << endl;\n", + "std::cout << \"\\nIn-progress tasks (\" << inProgress.size() << \"):\" << std::endl;\n", "for (const auto& t : inProgress) t->print();\n", "\n", "// Error handling test\n", "try {\n", " t1->start(); // Already done — should throw\n", - "} catch (const logic_error& e) {\n", - " cout << \"\\nCaught expected error: \" << e.what() << endl;\n", + "} catch (const std::logic_error& e) {\n", + " std::cout << \"\\nCaught expected error: \" << e.what() << std::endl;\n", "}\n", "\n", - "cout << \"\\nAll tests passed!\" << endl;" + "std::cout << \"\\nAll tests passed!\" << std::endl;" ] } ], "metadata": { "kernelspec": { - "display_name": "C++17", + "display_name": "C++23", "language": "cpp", - "name": "xcpp17" + "name": "xcpp23" }, "language_info": { "codemirror_mode": "text/x-c++src", "file_extension": ".cpp", "mimetype": "text/x-c++src", "name": "C++", - "version": "17" + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "cxx23" } }, "nbformat": 4,