From e7db326fc9d1397a374058c0e682331e16f5ec3f Mon Sep 17 00:00:00 2001 From: Smolder Date: Mon, 15 Dec 2025 20:19:47 -0700 Subject: [PATCH 01/20] Update Extension-Keys.json --- Gallery Files/Extension-Keys.json | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Gallery Files/Extension-Keys.json b/Gallery Files/Extension-Keys.json index 83782263..4c0b650c 100644 --- a/Gallery Files/Extension-Keys.json +++ b/Gallery Files/Extension-Keys.json @@ -1,5 +1,13 @@ { "extensions": { + "Topaz": { + "desc": "Customize and send requests to Google's Gemini API.", + "creator": "cs3203402", + "url": "extension-code/Topaz.js", + "banner": "extension-thumb/Topaz.png", + "tags": ["all", "fetching"], + "status": "new" + } "Sharktilities": { "desc": "Various utility blocks for various operations", "creator": "SharkPool", From 131897218afb0372d70bec9063c876b6a7952205 Mon Sep 17 00:00:00 2001 From: Smolder Date: Wed, 17 Dec 2025 17:59:16 -0700 Subject: [PATCH 02/20] Update Extension-Keys.json --- Gallery Files/Extension-Keys.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Gallery Files/Extension-Keys.json b/Gallery Files/Extension-Keys.json index 4c0b650c..a7e1cc03 100644 --- a/Gallery Files/Extension-Keys.json +++ b/Gallery Files/Extension-Keys.json @@ -1,7 +1,7 @@ { "extensions": { "Topaz": { - "desc": "Customize and send requests to Google's Gemini API.", + "desc": "Send requests to Gemini API.", "creator": "cs3203402", "url": "extension-code/Topaz.js", "banner": "extension-thumb/Topaz.png", From 8cea9126d7a8d2d9d59cbeb38ef1ae03b3e38618 Mon Sep 17 00:00:00 2001 From: Smolder Date: Wed, 17 Dec 2025 18:04:53 -0700 Subject: [PATCH 03/20] Add files via upload --- extension-thumbs/Topaz.svg | 1 + 1 file changed, 1 insertion(+) create mode 100644 extension-thumbs/Topaz.svg diff --git a/extension-thumbs/Topaz.svg b/extension-thumbs/Topaz.svg new file mode 100644 index 00000000..2c3dbeb6 --- /dev/null +++ b/extension-thumbs/Topaz.svg @@ -0,0 +1 @@ + \ No newline at end of file From 383d5f7c6fdb3d164e09340577dea1c5ec2aeea0 Mon Sep 17 00:00:00 2001 From: Smolder Date: Wed, 17 Dec 2025 18:05:47 -0700 Subject: [PATCH 04/20] Create Topaz.js --- extension-code/Topaz.js | 125 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) create mode 100644 extension-code/Topaz.js diff --git a/extension-code/Topaz.js b/extension-code/Topaz.js new file mode 100644 index 00000000..fb2ec042 --- /dev/null +++ b/extension-code/Topaz.js @@ -0,0 +1,125 @@ +(async function (Scratch) { + "use strict"; + const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") + let ai = new GoogleGenAI({apiKey: ""}); + let instruction = ""; + let key = "No API key has been set."; + let modelChoice = "gemini-2.5-flash"; + const menuIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><clipPath id="76958f3aa3"><path d="M 192 0 C 85.960938 0 0 85.960938 0 192 C 0 298.039062 85.960938 384 192 384 C 298.039062 384 384 298.039062 384 192 C 384 85.960938 298.039062 0 192 0 Z M 192 0 " clip-rule="nonzero"/></clipPath><clipPath id="2021399f92"><path d="M 0 0 L 384 0 L 384 384 L 0 384 Z M 0 0 " clip-rule="nonzero"/></clipPath><clipPath id="52dd35305f"><path d="M 192 0 C 85.960938 0 0 85.960938 0 192 C 0 298.039062 85.960938 384 192 384 C 298.039062 384 384 298.039062 384 192 C 384 85.960938 298.039062 0 192 0 Z M 192 0 " clip-rule="nonzero"/></clipPath><clipPath id="3b1e48df2b"><rect x="0" width="384" y="0" height="384"/></clipPath><clipPath id="70e9b3573f"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="690320e48c"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="085dedec43"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="5da0bb3383"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath></defs><g clip-path="url(#76958f3aa3)"><g><g clip-path="url(#3b1e48df2b)"><g clip-path="url(#2021399f92)"><g clip-path="url(#52dd35305f)"><rect x="-84.48" width="552.96" fill="#ff904b" height="552.959979" y="-84.479997" fill-opacity="1"/></g></g></g></g></g><g clip-path="url(#70e9b3573f)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#690320e48c)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#085dedec43)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#5da0bb3383)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/></svg>"; + const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><clipPath id="f6215e00b1"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="2125bdbb39"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="178a5802c7"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="120ff47fb0"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath><clipPath id="fd2aca7393"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="a00259f769"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="83d31fb901"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="d6ddfc073b"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath></defs><g clip-path="url(#f6215e00b1)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#2125bdbb39)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#178a5802c7)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#120ff47fb0)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#fd2aca7393)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#a00259f769)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#83d31fb901)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#d6ddfc073b)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/></svg>"; + class TopazExt { + constructor() { } + getInfo() { + return { + id: "topaz", + name: Scratch.translate("Topaz"), + color1: "#ff904b", + menuIconURI, + blockIconURI, + blocks: [ + { + opcode: "generate", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "generate from [contents] and temperature of [temp]" + ), + arguments: { + contents: { + type: Scratch.ArgumentType.STRING, + defaultValue: "Tell me about Gemini.", + }, + temp: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: 1, + }, + }, + }, + { + opcode: "getKey", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "current API key" + ), + }, + { + opcode: "getModel", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "selected model" + ), + }, + { + opcode: "setKey", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set API key to [key]"), + arguments: { + key: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setInstruction", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate({ + default: "set personality to [personality]", + }), + arguments: { + personality: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setModel", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate({ + default: "use model [model]", + }), + arguments: { + model: { + type: Scratch.ArgumentType.STRING, + menu: "models", + }, + }, + }, + ], + menus: { + models: [ + "gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think" + ] + }, + }; + } + async generate(args) { + const response = await ai.models.generateContent({ + model: modelChoice, + contents: args.contents, + config: { + systemInstruction: instruction, + temperature: args.temp, + }, + }); + return response.text; + } + setKey(args) { + key = args.key; + ai = new GoogleGenAI({ apiKey: args.key }); + } + setInstruction(args) { + instruction = args.personality; + } + setModel(args) { + modelChoice = args.model; + } + getKey(args) { + return key; + } + getModel(args) { + return modelChoice; + } + } + Scratch.extensions.register(new TopazExt()); +})(Scratch); From 9dc3c609897b1a42c9545e103fa0806e1ce17699 Mon Sep 17 00:00:00 2001 From: Smolder Date: Wed, 17 Dec 2025 18:11:25 -0700 Subject: [PATCH 05/20] Update Extension-Keys.json --- Gallery Files/Extension-Keys.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Gallery Files/Extension-Keys.json b/Gallery Files/Extension-Keys.json index a61284aa..cd82dfd8 100644 --- a/Gallery Files/Extension-Keys.json +++ b/Gallery Files/Extension-Keys.json @@ -4,7 +4,7 @@ "desc": "Send requests to Gemini API.", "creator": "cs3203402", "url": "extension-code/Topaz.js", - "banner": "extension-thumb/Topaz.png", + "banner": "extension-thumb/Topaz.svg", "tags": ["all", "fetching"], "status": "new" } From 1441b1d73b0ad0f2c1269b5553e37da79e7b1ae3 Mon Sep 17 00:00:00 2001 From: Smolder Date: Fri, 26 Dec 2025 22:24:13 -0700 Subject: [PATCH 06/20] Update Contributors.json --- Gallery Files/Contributors.json | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Gallery Files/Contributors.json b/Gallery Files/Contributors.json index cf88df41..9e703ad5 100644 --- a/Gallery Files/Contributors.json +++ b/Gallery Files/Contributors.json @@ -74,5 +74,9 @@ { "display": "ObscuraPH", "username": "PH8NT0MH4WK", "url": "https://avatars.githubusercontent.com/u/113964833?v=4" + }, + { + "display": "cs3203402", "username": "cs3203402", + "url": "https://avatars.githubusercontent.com/u/223149891?s=300&v=4" } ] From fa13f5137e2e52e885fde5e1aca5be06a4428730 Mon Sep 17 00:00:00 2001 From: Smolder Date: Fri, 26 Dec 2025 22:26:06 -0700 Subject: [PATCH 07/20] Update Extension-Keys.json --- Gallery Files/Extension-Keys.json | 23 ++++++----------------- 1 file changed, 6 insertions(+), 17 deletions(-) diff --git a/Gallery Files/Extension-Keys.json b/Gallery Files/Extension-Keys.json index cd82dfd8..be1025b4 100644 --- a/Gallery Files/Extension-Keys.json +++ b/Gallery Files/Extension-Keys.json @@ -1,13 +1,5 @@ { "extensions": { - "Topaz": { - "desc": "Send requests to Gemini API.", - "creator": "cs3203402", - "url": "extension-code/Topaz.js", - "banner": "extension-thumb/Topaz.svg", - "tags": ["all", "fetching"], - "status": "new" - } "Sharktilities": { "desc": "Various utility blocks for various operations", "creator": "SharkPool", @@ -597,15 +589,12 @@ "tags": ["all", "utilities"], "date": "Released: 10/24/2025" }, - "Example": { - "desc": "", - "creator": "SharkPool", - "url": "extension-code/Example.js", - "banner": "extension-thumbs/Example.svg", - "tags": ["all", "utilities", "expanded", "fetching", "category", "addon", "searchQ"], - "status": "", - "overrideLabeler": false, - "date": "" + "Topaz": { + "desc": "Send requests to Gemini API.", + "creator": "cs3203402", + "url": "extension-code/Topaz.js", + "banner": "extension-thumb/Topaz.svg", + "tags": ["all", "fetching"], } }, "site": { From d95b56a243f0b2afd63965bdbed277cc7161cb13 Mon Sep 17 00:00:00 2001 From: Smolder Date: Sat, 27 Dec 2025 19:03:08 -0700 Subject: [PATCH 08/20] Update and rename Topaz.js to Gemini.js --- extension-code/Gemini.js | 124 ++++++++++++++++++++++++++++++++++++++ extension-code/Topaz.js | 125 --------------------------------------- 2 files changed, 124 insertions(+), 125 deletions(-) create mode 100644 extension-code/Gemini.js delete mode 100644 extension-code/Topaz.js diff --git a/extension-code/Gemini.js b/extension-code/Gemini.js new file mode 100644 index 00000000..1ecefae2 --- /dev/null +++ b/extension-code/Gemini.js @@ -0,0 +1,124 @@ +(async function (Scratch) { + "use strict"; + const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") + let ai = new GoogleGenAI({apiKey: ""}); + let instruction = ""; + let key = "No API key has been set."; + let modelChoice = "gemini-2.5-flash"; + const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><filter x="0%" y="0%" width="100%" height="100%" id="a12064eef0"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/></filter><filter x="0%" y="0%" width="100%" height="100%" id="09e8c543d4"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0" color-interpolation-filters="sRGB"/></filter><clipPath id="6875787bdb"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="f589309bc4"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="8ce659a234"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="61e06adb7d"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath><mask id="dcf138de6e"><g filter="url(#a12064eef0)"><g filter="url(#09e8c543d4)" transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></mask></defs><g clip-path="url(#6875787bdb)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#f589309bc4)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#8ce659a234)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#61e06adb7d)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/><g mask="url(#dcf138de6e)"><g transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></svg>"; + const menuIconURI = blockIconURI; + class Gemini { + getInfo() { + return { + id: "gemini", + name: Scratch.translate("Gemini"), + color1: "#a3e0ff", + menuIconURI, + blockIconURI, + blocks: [ + { + opcode: "generate", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "generate from [contents] and temperature of [temp]" + ), + arguments: { + contents: { + type: Scratch.ArgumentType.STRING, + defaultValue: "Tell me about Gemini.", + }, + temp: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: 1, + }, + }, + }, + { + opcode: "getKey", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "current API key" + ), + }, + { + opcode: "getModel", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "selected model" + ), + }, + { + opcode: "setKey", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set API key to [key]"), + arguments: { + key: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setInstruction", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate({ + default: "set personality to [personality]", + }), + arguments: { + personality: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setModel", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate({ + default: "use model [model]", + }), + arguments: { + model: { + type: Scratch.ArgumentType.STRING, + menu: "models", + }, + }, + }, + ], + menus: { + models: [ + "gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think" + ] + }, + }; + } + async generate(args) { + const response = await ai.models.generateContent({ + model: modelChoice, + contents: args.contents, + config: { + systemInstruction: instruction, + temperature: args.temp, + }, + }); + return response.text; + } + setKey(args) { + key = args.key; + ai = new GoogleGenAI({ apiKey: args.key }); + } + setInstruction(args) { + instruction = args.personality; + } + setModel(args) { + modelChoice = args.model; + } + getKey(args) { + return key; + } + getModel(args) { + return modelChoice; + } + } + Scratch.extensions.register(new Gemini()); +})(Scratch); diff --git a/extension-code/Topaz.js b/extension-code/Topaz.js deleted file mode 100644 index fb2ec042..00000000 --- a/extension-code/Topaz.js +++ /dev/null @@ -1,125 +0,0 @@ -(async function (Scratch) { - "use strict"; - const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") - let ai = new GoogleGenAI({apiKey: ""}); - let instruction = ""; - let key = "No API key has been set."; - let modelChoice = "gemini-2.5-flash"; - const menuIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><clipPath id="76958f3aa3"><path d="M 192 0 C 85.960938 0 0 85.960938 0 192 C 0 298.039062 85.960938 384 192 384 C 298.039062 384 384 298.039062 384 192 C 384 85.960938 298.039062 0 192 0 Z M 192 0 " clip-rule="nonzero"/></clipPath><clipPath id="2021399f92"><path d="M 0 0 L 384 0 L 384 384 L 0 384 Z M 0 0 " clip-rule="nonzero"/></clipPath><clipPath id="52dd35305f"><path d="M 192 0 C 85.960938 0 0 85.960938 0 192 C 0 298.039062 85.960938 384 192 384 C 298.039062 384 384 298.039062 384 192 C 384 85.960938 298.039062 0 192 0 Z M 192 0 " clip-rule="nonzero"/></clipPath><clipPath id="3b1e48df2b"><rect x="0" width="384" y="0" height="384"/></clipPath><clipPath id="70e9b3573f"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="690320e48c"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="085dedec43"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="5da0bb3383"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath></defs><g clip-path="url(#76958f3aa3)"><g><g clip-path="url(#3b1e48df2b)"><g clip-path="url(#2021399f92)"><g clip-path="url(#52dd35305f)"><rect x="-84.48" width="552.96" fill="#ff904b" height="552.959979" y="-84.479997" fill-opacity="1"/></g></g></g></g></g><g clip-path="url(#70e9b3573f)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#690320e48c)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#085dedec43)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#5da0bb3383)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/></svg>"; - const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><clipPath id="f6215e00b1"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="2125bdbb39"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="178a5802c7"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="120ff47fb0"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath><clipPath id="fd2aca7393"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="a00259f769"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="83d31fb901"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="d6ddfc073b"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath></defs><g clip-path="url(#f6215e00b1)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#2125bdbb39)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#178a5802c7)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#120ff47fb0)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#fd2aca7393)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#a00259f769)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#83d31fb901)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#d6ddfc073b)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/></svg>"; - class TopazExt { - constructor() { } - getInfo() { - return { - id: "topaz", - name: Scratch.translate("Topaz"), - color1: "#ff904b", - menuIconURI, - blockIconURI, - blocks: [ - { - opcode: "generate", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "generate from [contents] and temperature of [temp]" - ), - arguments: { - contents: { - type: Scratch.ArgumentType.STRING, - defaultValue: "Tell me about Gemini.", - }, - temp: { - type: Scratch.ArgumentType.NUMBER, - defaultValue: 1, - }, - }, - }, - { - opcode: "getKey", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "current API key" - ), - }, - { - opcode: "getModel", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "selected model" - ), - }, - { - opcode: "setKey", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate("set API key to [key]"), - arguments: { - key: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setInstruction", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate({ - default: "set personality to [personality]", - }), - arguments: { - personality: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setModel", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate({ - default: "use model [model]", - }), - arguments: { - model: { - type: Scratch.ArgumentType.STRING, - menu: "models", - }, - }, - }, - ], - menus: { - models: [ - "gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think" - ] - }, - }; - } - async generate(args) { - const response = await ai.models.generateContent({ - model: modelChoice, - contents: args.contents, - config: { - systemInstruction: instruction, - temperature: args.temp, - }, - }); - return response.text; - } - setKey(args) { - key = args.key; - ai = new GoogleGenAI({ apiKey: args.key }); - } - setInstruction(args) { - instruction = args.personality; - } - setModel(args) { - modelChoice = args.model; - } - getKey(args) { - return key; - } - getModel(args) { - return modelChoice; - } - } - Scratch.extensions.register(new TopazExt()); -})(Scratch); From 0ce494daff8311ab191448f42466eb01e982727f Mon Sep 17 00:00:00 2001 From: Smolder Date: Sat, 27 Dec 2025 19:04:38 -0700 Subject: [PATCH 09/20] Add files via upload --- extension-thumbs/Gemini Thumbnail.svg | 1 + 1 file changed, 1 insertion(+) create mode 100644 extension-thumbs/Gemini Thumbnail.svg diff --git a/extension-thumbs/Gemini Thumbnail.svg b/extension-thumbs/Gemini Thumbnail.svg new file mode 100644 index 00000000..a0e2702f --- /dev/null +++ b/extension-thumbs/Gemini Thumbnail.svg @@ -0,0 +1 @@ + \ No newline at end of file From 956e1a2d770924796204a47ecafe3cbf5c1ccce2 Mon Sep 17 00:00:00 2001 From: Smolder Date: Sat, 27 Dec 2025 19:05:08 -0700 Subject: [PATCH 10/20] Rename Gemini Thumbnail.svg to Gemini.svg --- extension-thumbs/{Gemini Thumbnail.svg => Gemini.svg} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename extension-thumbs/{Gemini Thumbnail.svg => Gemini.svg} (99%) diff --git a/extension-thumbs/Gemini Thumbnail.svg b/extension-thumbs/Gemini.svg similarity index 99% rename from extension-thumbs/Gemini Thumbnail.svg rename to extension-thumbs/Gemini.svg index a0e2702f..68c871a8 100644 --- a/extension-thumbs/Gemini Thumbnail.svg +++ b/extension-thumbs/Gemini.svg @@ -1 +1 @@ - \ No newline at end of file + From d164f9f42ffe1d52810ce67ba0e6c0cb3d07be7f Mon Sep 17 00:00:00 2001 From: Smolder Date: Sat, 27 Dec 2025 19:08:17 -0700 Subject: [PATCH 11/20] Update Extension-Keys.json --- Gallery Files/Extension-Keys.json | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/Gallery Files/Extension-Keys.json b/Gallery Files/Extension-Keys.json index be1025b4..7ee8ff40 100644 --- a/Gallery Files/Extension-Keys.json +++ b/Gallery Files/Extension-Keys.json @@ -589,12 +589,22 @@ "tags": ["all", "utilities"], "date": "Released: 10/24/2025" }, - "Topaz": { + "Gemini": { "desc": "Send requests to Gemini API.", "creator": "cs3203402", - "url": "extension-code/Topaz.js", - "banner": "extension-thumb/Topaz.svg", - "tags": ["all", "fetching"], + "url": "extension-code/Gemini.js", + "banner": "extension-thumb/Gemini.svg", + "tags": ["all", "fetching"] + }, + "Example": { + "desc": "", + "creator": "SharkPool", + "url": "extension-code/Example.js", + "banner": "extension-thumbs/Example.svg", + "tags": ["all", "utilities", "expanded", "fetching", "category", "addon", "searchQ"], + "status": "", + "overrideLabeler": false, + "date": "" } }, "site": { From 1ecb32bfa0bd5c0b32285853e6f86a7ed9ef3ab0 Mon Sep 17 00:00:00 2001 From: Smolder Date: Sat, 27 Dec 2025 19:12:20 -0700 Subject: [PATCH 12/20] Update Gemini.js --- extension-code/Gemini.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extension-code/Gemini.js b/extension-code/Gemini.js index 1ecefae2..e4efda54 100644 --- a/extension-code/Gemini.js +++ b/extension-code/Gemini.js @@ -5,7 +5,7 @@ let instruction = ""; let key = "No API key has been set."; let modelChoice = "gemini-2.5-flash"; - const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><filter x="0%" y="0%" width="100%" height="100%" id="a12064eef0"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/></filter><filter x="0%" y="0%" width="100%" height="100%" id="09e8c543d4"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0" color-interpolation-filters="sRGB"/></filter><clipPath id="6875787bdb"><path d="M 45.050781 24.058594 L 339 24.058594 L 339 360 L 45.050781 360 Z M 45.050781 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="f589309bc4"><path d="M 186 24.058594 L 198 24.058594 L 198 99 L 186 99 Z M 186 24.058594 " clip-rule="nonzero"/></clipPath><clipPath id="8ce659a234"><path d="M 45.050781 105 L 112 105 L 112 149 L 45.050781 149 Z M 45.050781 105 " clip-rule="nonzero"/></clipPath><clipPath id="61e06adb7d"><path d="M 45.050781 235 L 112 235 L 112 280 L 45.050781 280 Z M 45.050781 235 " clip-rule="nonzero"/></clipPath><mask id="dcf138de6e"><g filter="url(#a12064eef0)"><g filter="url(#09e8c543d4)" transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></mask></defs><g clip-path="url(#6875787bdb)"><path fill="#ffffff" d="M 332.109375 273.027344 L 332.226562 273.027344 Z M 57.875 269.566406 L 192.003906 347.011719 L 326.125 269.566406 L 326.125 114.703125 L 192.003906 37.261719 L 57.875 114.703125 Z M 192.003906 359.902344 C 190.976562 359.902344 189.9375 359.636719 189.011719 359.097656 L 48.898438 278.203125 C 47.050781 277.140625 45.90625 275.164062 45.90625 273.027344 L 45.90625 111.246094 C 45.90625 109.105469 47.050781 107.132812 48.898438 106.070312 L 189.011719 25.175781 C 190.859375 24.101562 193.152344 24.101562 194.996094 25.175781 L 335.101562 106.070312 C 336.945312 107.132812 338.089844 109.105469 338.089844 111.246094 L 338.089844 273.027344 C 338.089844 275.164062 336.945312 277.140625 335.101562 278.203125 L 194.996094 359.097656 C 194.074219 359.636719 193.035156 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 111.847656 238.398438 L 192.003906 284.695312 L 272.160156 238.398438 L 272.160156 145.863281 L 192.003906 99.582031 L 111.847656 145.863281 Z M 192.003906 297.582031 C 190.976562 297.582031 189.9375 297.316406 189.011719 296.777344 L 102.875 247.035156 C 101.027344 245.972656 99.882812 243.996094 99.882812 241.859375 L 99.882812 142.40625 C 99.882812 140.265625 101.027344 138.292969 102.875 137.226562 L 189.011719 87.496094 C 190.859375 86.417969 193.152344 86.417969 194.996094 87.496094 L 281.136719 137.226562 C 282.984375 138.292969 284.128906 140.265625 284.128906 142.40625 L 284.128906 241.859375 C 284.128906 243.996094 282.984375 245.972656 281.136719 247.035156 L 194.996094 296.777344 C 194.074219 297.316406 193.035156 297.582031 192.003906 297.582031 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 278.144531 148.386719 C 276.089844 148.386719 274.066406 147.3125 272.964844 145.398438 C 271.308594 142.535156 272.289062 138.875 275.152344 137.226562 L 329.113281 106.070312 C 331.96875 104.394531 335.636719 105.386719 337.285156 108.253906 C 338.945312 111.117188 337.960938 114.773438 335.101562 116.425781 L 281.136719 147.582031 C 280.191406 148.128906 279.160156 148.386719 278.144531 148.386719 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#f589309bc4)"><path fill="#ffffff" d="M 192.003906 98.65625 C 188.699219 98.65625 186.023438 95.980469 186.023438 92.671875 L 186.023438 30.351562 C 186.023438 27.046875 188.699219 24.367188 192.003906 24.367188 C 195.3125 24.367188 197.992188 27.046875 197.992188 30.351562 L 197.992188 92.671875 C 197.992188 95.980469 195.3125 98.65625 192.003906 98.65625 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#8ce659a234)"><path fill="#ffffff" d="M 105.867188 148.386719 C 104.847656 148.386719 103.820312 148.128906 102.875 147.582031 L 48.898438 116.425781 C 46.035156 114.773438 45.054688 111.117188 46.714844 108.253906 C 48.363281 105.386719 52.03125 104.417969 54.882812 106.070312 L 108.859375 137.226562 C 111.722656 138.875 112.703125 142.535156 111.042969 145.398438 C 109.945312 147.3125 107.921875 148.386719 105.867188 148.386719 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#61e06adb7d)"><path fill="#ffffff" d="M 51.890625 279.011719 C 49.835938 279.011719 47.8125 277.9375 46.714844 276.019531 C 45.054688 273.15625 46.035156 269.496094 48.898438 267.851562 L 102.875 236.679688 C 105.714844 235.007812 109.394531 236 111.042969 238.863281 C 112.703125 241.730469 111.722656 245.382812 108.859375 247.035156 L 54.882812 278.203125 C 53.9375 278.757812 52.910156 279.011719 51.890625 279.011719 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 192.003906 359.902344 C 188.699219 359.902344 186.023438 357.226562 186.023438 353.917969 L 186.023438 291.601562 C 186.023438 288.292969 188.699219 285.617188 192.003906 285.617188 C 195.3125 285.617188 197.992188 288.292969 197.992188 291.601562 L 197.992188 353.917969 C 197.992188 357.226562 195.3125 359.902344 192.003906 359.902344 " fill-opacity="1" fill-rule="nonzero"/><path fill="#ffffff" d="M 332.109375 279.011719 C 331.089844 279.011719 330.0625 278.757812 329.113281 278.203125 L 275.152344 247.035156 C 272.289062 245.382812 271.308594 241.730469 272.964844 238.863281 C 274.601562 236.011719 278.285156 235.019531 281.136719 236.679688 L 335.101562 267.851562 C 337.960938 269.496094 338.945312 273.15625 337.285156 276.019531 C 336.175781 277.9375 334.164062 279.011719 332.109375 279.011719 " fill-opacity="1" fill-rule="nonzero"/><g mask="url(#dcf138de6e)"><g transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></svg>"; + const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><filter x="0%" y="0%" width="100%" height="100%" id="fdc29b5ee1"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/></filter><filter x="0%" y="0%" width="100%" height="100%" id="c4b48f47d3"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0" color-interpolation-filters="sRGB"/></filter><mask id="2eb4ea65bb"><g filter="url(#fdc29b5ee1)"><g filter="url(#c4b48f47d3)" transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></mask></defs><g mask="url(#2eb4ea65bb)"><g transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></svg>"; const menuIconURI = blockIconURI; class Gemini { getInfo() { From 22024f9980afd7d64ffc21527b6cf81028d7db82 Mon Sep 17 00:00:00 2001 From: Smolder Date: Sat, 27 Dec 2025 19:13:23 -0700 Subject: [PATCH 13/20] Delete extension-thumbs/Topaz.svg --- extension-thumbs/Topaz.svg | 1 - 1 file changed, 1 deletion(-) delete mode 100644 extension-thumbs/Topaz.svg diff --git a/extension-thumbs/Topaz.svg b/extension-thumbs/Topaz.svg deleted file mode 100644 index 2c3dbeb6..00000000 --- a/extension-thumbs/Topaz.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file From 62d08eb3bba7139cbd2287fab9b11949c4985fc7 Mon Sep 17 00:00:00 2001 From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com> Date: Sun, 28 Dec 2025 21:00:58 -0800 Subject: [PATCH 14/20] shorten url a bit --- Gallery Files/Contributors.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Gallery Files/Contributors.json b/Gallery Files/Contributors.json index 9e703ad5..16277086 100644 --- a/Gallery Files/Contributors.json +++ b/Gallery Files/Contributors.json @@ -77,6 +77,6 @@ }, { "display": "cs3203402", "username": "cs3203402", - "url": "https://avatars.githubusercontent.com/u/223149891?s=300&v=4" + "url": "https://avatars.githubusercontent.com/u/223149891?v=4" } ] From a6fe7856c21d9e24650be454ece751374b278504 Mon Sep 17 00:00:00 2001 From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com> Date: Sun, 28 Dec 2025 21:17:03 -0800 Subject: [PATCH 15/20] format and optimize code --- extension-code/Gemini.js | 255 ++++++++++++++++++++------------------- 1 file changed, 133 insertions(+), 122 deletions(-) diff --git a/extension-code/Gemini.js b/extension-code/Gemini.js index e4efda54..6049141f 100644 --- a/extension-code/Gemini.js +++ b/extension-code/Gemini.js @@ -1,124 +1,135 @@ -(async function (Scratch) { - "use strict"; - const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") - let ai = new GoogleGenAI({apiKey: ""}); - let instruction = ""; - let key = "No API key has been set."; - let modelChoice = "gemini-2.5-flash"; - const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><filter x="0%" y="0%" width="100%" height="100%" id="fdc29b5ee1"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/></filter><filter x="0%" y="0%" width="100%" height="100%" id="c4b48f47d3"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0" color-interpolation-filters="sRGB"/></filter><mask id="2eb4ea65bb"><g filter="url(#fdc29b5ee1)"><g filter="url(#c4b48f47d3)" transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></mask></defs><g mask="url(#2eb4ea65bb)"><g transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></svg>"; - const menuIconURI = blockIconURI; - class Gemini { - getInfo() { - return { - id: "gemini", - name: Scratch.translate("Gemini"), - color1: "#a3e0ff", - menuIconURI, - blockIconURI, - blocks: [ - { - opcode: "generate", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "generate from [contents] and temperature of [temp]" - ), - arguments: { - contents: { - type: Scratch.ArgumentType.STRING, - defaultValue: "Tell me about Gemini.", - }, - temp: { - type: Scratch.ArgumentType.NUMBER, - defaultValue: 1, - }, - }, - }, - { - opcode: "getKey", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "current API key" - ), - }, - { - opcode: "getModel", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "selected model" - ), - }, - { - opcode: "setKey", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate("set API key to [key]"), - arguments: { - key: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setInstruction", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate({ - default: "set personality to [personality]", - }), - arguments: { - personality: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setModel", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate({ - default: "use model [model]", - }), - arguments: { - model: { - type: Scratch.ArgumentType.STRING, - menu: "models", - }, - }, - }, - ], - menus: { - models: [ - "gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think" - ] - }, - }; - } - async generate(args) { - const response = await ai.models.generateContent({ - model: modelChoice, - contents: args.contents, - config: { - systemInstruction: instruction, - temperature: args.temp, - }, - }); - return response.text; - } - setKey(args) { - key = args.key; - ai = new GoogleGenAI({ apiKey: args.key }); - } - setInstruction(args) { - instruction = args.personality; - } - setModel(args) { - modelChoice = args.model; - } - getKey(args) { - return key; - } - getModel(args) { - return modelChoice; - } +(async function(Scratch) { + "use strict"; + + const menuIconURI = +"data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="65" height="65" viewBox="0 0 65 65" fill="none"><path d="M57.865 29.01q-7.5-3.228-13.126-8.853-5.625-5.626-8.854-13.126a39 39 0 0 1-1.999-5.905A1.485 1.485 0 0 0 32.447.001c-.68 0-1.272.465-1.438 1.125a39 39 0 0 1-2 5.905q-3.228 7.5-8.853 13.126Q14.53 25.782 7.03 29.01a39 39 0 0 1-5.905 2A1.485 1.485 0 0 0 0 32.448c0 .68.465 1.272 1.125 1.438a39 39 0 0 1 5.905 2q7.499 3.228 13.126 8.853 5.626 5.626 8.854 13.126a39 39 0 0 1 1.999 5.905c.166.66.758 1.125 1.438 1.125.681 0 1.273-.465 1.439-1.125a39 39 0 0 1 2-5.905q3.228-7.499 8.853-13.126 5.626-5.625 13.126-8.854a39 39 0 0 1 5.905-1.999 1.485 1.485 0 0 0 1.125-1.438c0-.681-.465-1.273-1.125-1.439a39 39 0 0 1-5.905-2" fill="#fff"/><mask id="b" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="65" height="65"><path d="M32.447 0c.68 0 1.273.465 1.439 1.125a39 39 0 0 0 1.999 5.905q3.23 7.5 8.854 13.125 5.627 5.626 13.125 8.855a39 39 0 0 0 5.906 1.999c.66.166 1.124.758 1.124 1.438s-.464 1.273-1.125 1.439a39 39 0 0 0-5.905 1.999q-7.5 3.23-13.125 8.854-5.625 5.627-8.854 13.125a39 39 0 0 0-2 5.906 1.485 1.485 0 0 1-1.438 1.124c-.68 0-1.272-.464-1.438-1.125a39 39 0 0 0-2-5.905q-3.227-7.5-8.854-13.125-5.625-5.625-13.125-8.854a39 39 0 0 0-5.905-2A1.485 1.485 0 0 1 0 32.448c0-.68.465-1.272 1.125-1.438a39 39 0 0 0 5.905-2q7.5-3.228 13.125-8.854 5.626-5.624 8.855-13.125a39 39 0 0 0 1.999-5.905A1.485 1.485 0 0 1 32.447 0" fill="#000"/><path d="M32.447 0c.68 0 1.273.465 1.439 1.125a39 39 0 0 0 1.999 5.905q3.23 7.5 8.854 13.125 5.627 5.626 13.125 8.855a39 39 0 0 0 5.906 1.999c.66.166 1.124.758 1.124 1.438s-.464 1.273-1.125 1.439a39 39 0 0 0-5.905 1.999q-7.5 3.23-13.125 8.854-5.625 5.627-8.854 13.125a39 39 0 0 0-2 5.906 1.485 1.485 0 0 1-1.438 1.124c-.68 0-1.272-.464-1.438-1.125a39 39 0 0 0-2-5.905q-3.227-7.5-8.854-13.125-5.625-5.625-13.125-8.854a39 39 0 0 0-5.905-2A1.485 1.485 0 0 1 0 32.448c0-.68.465-1.272 1.125-1.438a39 39 0 0 0 5.905-2q7.5-3.228 13.125-8.854 5.626-5.624 8.855-13.125a39 39 0 0 0 1.999-5.905A1.485 1.485 0 0 1 32.447 0" fill="url(#a)"/></mask><g mask="url(#b)"><g filter="url(#c)"><ellipse cx="14.407" cy="16.95" rx="14.407" ry="16.95" transform="rotate(19.552 -44.576 -16.496)" fill="#ffe432"/></g><g filter="url(#d)"><ellipse cx="27.433" cy="2.587" rx="18.652" ry="19.062" fill="#fc413d"/></g><g filter="url(#e)"><ellipse cx="18.951" cy="57.386" rx="19.493" ry="25.253" transform="rotate(-2.799 18.951 57.386)" fill="#00b95c"/></g><g filter="url(#f)"><ellipse cx="18.951" cy="57.386" rx="19.493" ry="25.253" transform="rotate(-2.799 18.951 57.386)" fill="#00b95c"/></g><g filter="url(#g)"><ellipse cx="20.02" cy="56.211" rx="19.107" ry="21.035" transform="rotate(-31.318 20.02 56.211)" fill="#00b95c"/></g><g filter="url(#h)"><ellipse cx="67.391" cy="25.327" rx="18.346" ry="17.667" fill="#3186ff"/></g><g filter="url(#i)"><ellipse cx="21.222" cy="22.384" rx="21.222" ry="22.384" transform="rotate(37.252 9.752 -8.009)" fill="#fbbc04"/></g><g filter="url(#j)"><ellipse cx="24.469" cy="22.604" rx="24.469" ry="22.604" transform="rotate(34.51 19.587 64.852)" fill="#3186ff"/></g><g filter="url(#k)"><path d="M54.984-2.336c2.833 3.852-.808 11.34-8.131 16.727s-15.557 6.631-18.39 2.78c-2.833-3.853.807-11.342 8.13-16.728s15.558-6.631 18.39-2.78" fill="#749bff"/></g><g filter="url(#l)"><ellipse cx="19.902" cy="3.356" rx="27.971" ry="17.388" transform="rotate(-42.848 19.902 3.356)" fill="#fc413d"/></g><g filter="url(#m)"><ellipse cx="13.583" cy="46.75" rx="14.989" ry="8.717" transform="rotate(35.592 13.583 46.75)" fill="#ffee48"/></g></g><defs><filter id="c" x="-19.824" y="13.152" width="39.274" height="43.217" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="2.46" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="d" x="-15.001" y="-40.257" width="84.868" height="85.688" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="11.891" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="e" x="-20.776" y="11.927" width="79.454" height="90.917" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="f" x="-20.776" y="11.927" width="79.454" height="90.917" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="g" x="-19.845" y="15.459" width="79.731" height="81.505" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="h" x="29.832" y="-11.552" width="75.117" height="73.758" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="9.606" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="i" x="-38.583" y="-16.253" width="78.135" height="78.758" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="8.706" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="j" x="8.107" y="-5.966" width="78.877" height="77.539" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="7.775" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="k" x="13.587" y="-18.488" width="56.272" height="51.81" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="6.957" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="l" x="-15.526" y="-31.297" width="70.856" height="69.306" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="5.876" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="m" x="-14.168" y="20.964" width="55.502" height="51.571" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="7.273" result="effect1_foregroundBlur_10859_4895"/></filter><linearGradient id="a" x1="18.447" y1="43.42" x2="52.153" y2="15.004" gradientUnits="userSpaceOnUse"><stop stop-color="#4893fc"/><stop offset=".27" stop-color="#4893fc"/><stop offset=".777" stop-color="#969dff"/><stop offset="1" stop-color="#bd99fe"/></linearGradient></defs></svg>"; + + // typically extensions should work offline, but this is a online AI extension, + // so all offline rules break for this... + const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") + + let ai = new GoogleGenAI({ apiKey: "" }); + let instruction = ""; + let key = "No API key has been set."; + let modelChoice = "gemini-2.5-flash"; + + class smolderdevGeminiAPI { + getInfo() { + return { + id: "smolderdevGeminiAPI", + name: Scratch.translate("Gemini API"), + color1: "#a3e0ff", + menuIconURI, + blockIconURI: menuIconURI, + blocks: [ + { + opcode: "generate", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "generate from [contents] and temperature of [temp]" + ), + arguments: { + contents: { + type: Scratch.ArgumentType.STRING, + defaultValue: "Tell me about Gemini.", + }, + temp: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: 1, + }, + }, + }, + { + opcode: "getKey", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate("current API key"), + }, + { + opcode: "getModel", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate("selected model"), + }, + { + opcode: "setKey", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set API key to [key]"), + arguments: { + key: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setInstruction", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set personality to [personality]"), + arguments: { + personality: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setModel", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("use model [model]"), + arguments: { + model: { + type: Scratch.ArgumentType.STRING, + menu: "models", + }, + }, + }, + ], + menus: { + models: [ + "gemini-2.5-flash-lite", + "gemini-2.5-flash", + "gemini-2.5-pro", + "gemini-3-flash-preview", + "gemini-3-pro-preview", + "gemini-3-deep-think" + ] + }, + }; } - Scratch.extensions.register(new Gemini()); + + async generate(args) { + const response = await ai.models.generateContent({ + model: modelChoice, + contents: args.contents, + config: { + systemInstruction: instruction, + temperature: args.temp, + }, + }); + return response.text; + } + + setKey(args) { + key = args.key; + ai = new GoogleGenAI({ + apiKey: args.key + }); + } + + setInstruction(args) { + instruction = args.personality; + } + + setModel(args) { + modelChoice = args.model; + } + + getKey() { + return key; + } + + getModel() { + return modelChoice; + } + } + Scratch.extensions.register(new smolderdevGeminiAPI()); })(Scratch); From 572fc75c3d25ef873bc9d6e1d8760c0689a232ac Mon Sep 17 00:00:00 2001 From: Smolder Date: Sun, 28 Dec 2025 23:09:32 -0700 Subject: [PATCH 16/20] Update Gemini.js --- extension-code/Gemini.js | 262 +++++++++++++++++++-------------------- 1 file changed, 131 insertions(+), 131 deletions(-) diff --git a/extension-code/Gemini.js b/extension-code/Gemini.js index 6049141f..177dd18f 100644 --- a/extension-code/Gemini.js +++ b/extension-code/Gemini.js @@ -1,135 +1,135 @@ -(async function(Scratch) { - "use strict"; +// Name: Gemini +// ID: gemini +// Description: Gemini API Requests with Customization +// By: cs3203402 +// License: ARR - const menuIconURI = -"data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="65" height="65" viewBox="0 0 65 65" fill="none"><path d="M57.865 29.01q-7.5-3.228-13.126-8.853-5.625-5.626-8.854-13.126a39 39 0 0 1-1.999-5.905A1.485 1.485 0 0 0 32.447.001c-.68 0-1.272.465-1.438 1.125a39 39 0 0 1-2 5.905q-3.228 7.5-8.853 13.126Q14.53 25.782 7.03 29.01a39 39 0 0 1-5.905 2A1.485 1.485 0 0 0 0 32.448c0 .68.465 1.272 1.125 1.438a39 39 0 0 1 5.905 2q7.499 3.228 13.126 8.853 5.626 5.626 8.854 13.126a39 39 0 0 1 1.999 5.905c.166.66.758 1.125 1.438 1.125.681 0 1.273-.465 1.439-1.125a39 39 0 0 1 2-5.905q3.228-7.499 8.853-13.126 5.626-5.625 13.126-8.854a39 39 0 0 1 5.905-1.999 1.485 1.485 0 0 0 1.125-1.438c0-.681-.465-1.273-1.125-1.439a39 39 0 0 1-5.905-2" fill="#fff"/><mask id="b" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="65" height="65"><path d="M32.447 0c.68 0 1.273.465 1.439 1.125a39 39 0 0 0 1.999 5.905q3.23 7.5 8.854 13.125 5.627 5.626 13.125 8.855a39 39 0 0 0 5.906 1.999c.66.166 1.124.758 1.124 1.438s-.464 1.273-1.125 1.439a39 39 0 0 0-5.905 1.999q-7.5 3.23-13.125 8.854-5.625 5.627-8.854 13.125a39 39 0 0 0-2 5.906 1.485 1.485 0 0 1-1.438 1.124c-.68 0-1.272-.464-1.438-1.125a39 39 0 0 0-2-5.905q-3.227-7.5-8.854-13.125-5.625-5.625-13.125-8.854a39 39 0 0 0-5.905-2A1.485 1.485 0 0 1 0 32.448c0-.68.465-1.272 1.125-1.438a39 39 0 0 0 5.905-2q7.5-3.228 13.125-8.854 5.626-5.624 8.855-13.125a39 39 0 0 0 1.999-5.905A1.485 1.485 0 0 1 32.447 0" fill="#000"/><path d="M32.447 0c.68 0 1.273.465 1.439 1.125a39 39 0 0 0 1.999 5.905q3.23 7.5 8.854 13.125 5.627 5.626 13.125 8.855a39 39 0 0 0 5.906 1.999c.66.166 1.124.758 1.124 1.438s-.464 1.273-1.125 1.439a39 39 0 0 0-5.905 1.999q-7.5 3.23-13.125 8.854-5.625 5.627-8.854 13.125a39 39 0 0 0-2 5.906 1.485 1.485 0 0 1-1.438 1.124c-.68 0-1.272-.464-1.438-1.125a39 39 0 0 0-2-5.905q-3.227-7.5-8.854-13.125-5.625-5.625-13.125-8.854a39 39 0 0 0-5.905-2A1.485 1.485 0 0 1 0 32.448c0-.68.465-1.272 1.125-1.438a39 39 0 0 0 5.905-2q7.5-3.228 13.125-8.854 5.626-5.624 8.855-13.125a39 39 0 0 0 1.999-5.905A1.485 1.485 0 0 1 32.447 0" fill="url(#a)"/></mask><g mask="url(#b)"><g filter="url(#c)"><ellipse cx="14.407" cy="16.95" rx="14.407" ry="16.95" transform="rotate(19.552 -44.576 -16.496)" fill="#ffe432"/></g><g filter="url(#d)"><ellipse cx="27.433" cy="2.587" rx="18.652" ry="19.062" fill="#fc413d"/></g><g filter="url(#e)"><ellipse cx="18.951" cy="57.386" rx="19.493" ry="25.253" transform="rotate(-2.799 18.951 57.386)" fill="#00b95c"/></g><g filter="url(#f)"><ellipse cx="18.951" cy="57.386" rx="19.493" ry="25.253" transform="rotate(-2.799 18.951 57.386)" fill="#00b95c"/></g><g filter="url(#g)"><ellipse cx="20.02" cy="56.211" rx="19.107" ry="21.035" transform="rotate(-31.318 20.02 56.211)" fill="#00b95c"/></g><g filter="url(#h)"><ellipse cx="67.391" cy="25.327" rx="18.346" ry="17.667" fill="#3186ff"/></g><g filter="url(#i)"><ellipse cx="21.222" cy="22.384" rx="21.222" ry="22.384" transform="rotate(37.252 9.752 -8.009)" fill="#fbbc04"/></g><g filter="url(#j)"><ellipse cx="24.469" cy="22.604" rx="24.469" ry="22.604" transform="rotate(34.51 19.587 64.852)" fill="#3186ff"/></g><g filter="url(#k)"><path d="M54.984-2.336c2.833 3.852-.808 11.34-8.131 16.727s-15.557 6.631-18.39 2.78c-2.833-3.853.807-11.342 8.13-16.728s15.558-6.631 18.39-2.78" fill="#749bff"/></g><g filter="url(#l)"><ellipse cx="19.902" cy="3.356" rx="27.971" ry="17.388" transform="rotate(-42.848 19.902 3.356)" fill="#fc413d"/></g><g filter="url(#m)"><ellipse cx="13.583" cy="46.75" rx="14.989" ry="8.717" transform="rotate(35.592 13.583 46.75)" fill="#ffee48"/></g></g><defs><filter id="c" x="-19.824" y="13.152" width="39.274" height="43.217" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="2.46" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="d" x="-15.001" y="-40.257" width="84.868" height="85.688" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="11.891" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="e" x="-20.776" y="11.927" width="79.454" height="90.917" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="f" x="-20.776" y="11.927" width="79.454" height="90.917" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="g" x="-19.845" y="15.459" width="79.731" height="81.505" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="h" x="29.832" y="-11.552" width="75.117" height="73.758" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="9.606" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="i" x="-38.583" y="-16.253" width="78.135" height="78.758" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="8.706" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="j" x="8.107" y="-5.966" width="78.877" height="77.539" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="7.775" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="k" x="13.587" y="-18.488" width="56.272" height="51.81" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="6.957" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="l" x="-15.526" y="-31.297" width="70.856" height="69.306" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="5.876" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="m" x="-14.168" y="20.964" width="55.502" height="51.571" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="7.273" result="effect1_foregroundBlur_10859_4895"/></filter><linearGradient id="a" x1="18.447" y1="43.42" x2="52.153" y2="15.004" gradientUnits="userSpaceOnUse"><stop stop-color="#4893fc"/><stop offset=".27" stop-color="#4893fc"/><stop offset=".777" stop-color="#969dff"/><stop offset="1" stop-color="#bd99fe"/></linearGradient></defs></svg>"; +// Version V.1.0.0 - // typically extensions should work offline, but this is a online AI extension, - // so all offline rules break for this... - const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") - - let ai = new GoogleGenAI({ apiKey: "" }); - let instruction = ""; - let key = "No API key has been set."; - let modelChoice = "gemini-2.5-flash"; - - class smolderdevGeminiAPI { - getInfo() { - return { - id: "smolderdevGeminiAPI", - name: Scratch.translate("Gemini API"), - color1: "#a3e0ff", - menuIconURI, - blockIconURI: menuIconURI, - blocks: [ - { - opcode: "generate", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "generate from [contents] and temperature of [temp]" - ), - arguments: { - contents: { - type: Scratch.ArgumentType.STRING, - defaultValue: "Tell me about Gemini.", - }, - temp: { - type: Scratch.ArgumentType.NUMBER, - defaultValue: 1, - }, - }, - }, - { - opcode: "getKey", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate("current API key"), - }, - { - opcode: "getModel", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate("selected model"), - }, - { - opcode: "setKey", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate("set API key to [key]"), - arguments: { - key: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setInstruction", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate("set personality to [personality]"), - arguments: { - personality: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setModel", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate("use model [model]"), - arguments: { - model: { - type: Scratch.ArgumentType.STRING, - menu: "models", - }, - }, - }, - ], - menus: { - models: [ - "gemini-2.5-flash-lite", - "gemini-2.5-flash", - "gemini-2.5-pro", - "gemini-3-flash-preview", - "gemini-3-pro-preview", - "gemini-3-deep-think" - ] - }, - }; - } - - async generate(args) { - const response = await ai.models.generateContent({ - model: modelChoice, - contents: args.contents, - config: { - systemInstruction: instruction, - temperature: args.temp, - }, - }); - return response.text; - } - - setKey(args) { - key = args.key; - ai = new GoogleGenAI({ - apiKey: args.key - }); - } - - setInstruction(args) { - instruction = args.personality; - } - - setModel(args) { - modelChoice = args.model; - } - - getKey() { - return key; - } - - getModel() { - return modelChoice; +(async function (Scratch) { + "use strict"; + const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") + let ai = new GoogleGenAI({apiKey: ""}); + let instruction = ""; + let key = "No API key has been set."; + let modelChoice = "Gemini 2.5 - Flash"; + const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><filter x="0%" y="0%" width="100%" height="100%" id="fdc29b5ee1"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/></filter><filter x="0%" y="0%" width="100%" height="100%" id="c4b48f47d3"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0" color-interpolation-filters="sRGB"/></filter><mask id="2eb4ea65bb"><g filter="url(#fdc29b5ee1)"><g filter="url(#c4b48f47d3)" transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></mask></defs><g mask="url(#2eb4ea65bb)"><g transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAIAAADwf7zUAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeZAk93XY+ffLvrv67rlncAzuiwRBUhIlShYty3KEN7yxsbF0xG5YFkmAAASRkrinrQ2ve3VSpEzQAEFgABAgwMMSZEm+JIW8YYEKSZZMUSRAXCSuGWAGc3d3dXVXVdeVv/0j85f5+2VlHd1d3VXV/f0EDQ9zurMys5LC+71876UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADANlHdPgAAwM557K7HlNZKfE+0iK4NKt9TekTd8/l7un1oAIAdwgIAAHa5L995YqRWyFQLh9bPj9TK35x/v+f7g15NRCraq02qD5z525IeOTd2KD+YWR8c/djj93b7kAEA24gFAADsTg/d98x4OTdXWty3fvG1qRumK4uHCxePF96aqeQSP5kdnDyVueqd0cPZ0Zlbsy8vDe+7PDJfGJq959H/pStHDgDYViwAAGC3WVh49uDimfnC0qWRw/vyZ27Lvnxd4WSbv3t29NB3pm+5NH78ytrpQmaqNjf/jxf+8bYeLQBgh7EAAIBd5UsfOzEyWH39yC23v/bfPrD8N3OV7CZ2kh2a+uu595euuz7zzlsXqpMfe5KiIADYPVgAAMDu8W9/+jfnytmTmavfn/32Tauvb3Fvp8av+Mu5D1xTOJkdnvkfvvLPO3KEAICuYwEAALvE7/+TXztUunR29PBPXfzGiF/uyD7L3tB/OfDjRwtnl4Zm/8Fv/3JH9gkA6C4WAACwG/zn//n/mS0vnR47/A8vPqu07uzOvzH/wQOlS4vD8z/5O7/a2T0DAHae1+0DAABs1e/+k8/OlLPLw3P/3YU/7Xj0LyIfWvzLxeH5mWr2D/7pr3d85wCAHcYCAAD62xMffWS+svTW2BU/fvkvt+9Tfmzpr05njsyXlr/6sS9s36cAAHYACwAA6GMn7v76/vLyqfGr/sHlZ7f7s37qwp+9nblqf3n5qXuf2u7PAgBsHxYAANDHJstLZzNX/f1Lz47UStv9WYN+9Scu/Nn5iSszpeXt/iwAwPZhAQAA/erJu5+cqWSPrL1+oHR5Zz5xvrx0IHdyopQ78dEnduYTAQAdxwIAAPrVVGn5QuboB5e+uZMf+sGlb741cmyusrSTHwoA6CAWAADQlx6/8/FMZfWK1TczteJOfu5IrXR94fVpP08nAAD0KRYAANCXhmvrZ8aOvif7/M5/9HtXnj83dfVQeW3nPxoAsHWD3T4AAMBmZGqFEb80Wc3v/EeP1dYz+fND0vkXDgAAdgBPAACg/ywsLIx6F4+sn+/WARwrnpssL5+4+0S3DgAAsGksAACg/0xnJ/7m+MQNa6936wBuWH39telrBmt+tw4AALBpLAAAoP9MlGpXvnVoppLr1gFk/OJopTq6/S8fAAB0HD0AANB/jqyUfW+xu8ewb33Rk1p3jwEAsAk8AQCAPvPQfc9M+IWjxXPdPYxj62enqmuP3fVYdw8DALBRLAAAoM+MVNdenLvjmvzJ7h7GtfmTL0/fNORXunsYAICNogQIAPrMWKUwWl0bq6139zCGdHW8Whj0q909DADARrEAAIA+c6B4vtYb/9f7YPEybQAA0HcoAQKAfvLYXY9NVteuWn+72wciInLF+umJWp42AADoLywAAKCfjPilF2ZuvbpwutsHIiJyVfHM8zO3jTAMFAD6Sk88RAYAtGm8WhgZKHu6J97ApbSeruQGaAMAgL7CEwAA6CeH1i8czF/o9lHEDhXPj3qVhYVnu30gAIB2sQAAgL7xxEcfGa8Ur+v2AFDbjauv/c3xD87kLnX7QAAA7WIBAAB9Y7yWf27m3fvLXX4HsG2munr8zCsT66vdPhAAQLvoAQCAvjFVXc34+W4fRdJ8YWmwwOvAAKBv8AQAAPrDU/c+NVNbu7LwTrcPJOmq4luT5bUTP/Plbh8IAKAtLAAAoD8MVIqvzb7ruvypbh9I0nX5Uy9m3jUqxW4fCACgLZQAAUB/GKvmK5X1wd6buelpf0aWvRqvBAaA/sATAADoDwcL5w6VznX7KNIdWj8/NnhxYWGh2wcCAGiNBQAA9IEn73ok4xd6agCo7YbV17919fjsSqbbBwIAaI0FAAD0gfFK/rnZd+8v9dAAUNtcJXvN6QMT61QBAUAfoAcAAPrAdCWXqfbcAFDbvsLlwULP9ScAAOrxBAAAet3Ddz4+Wc4dz7/d7QNp5njh1EQl99DHH+32gQAAWmABAAC9LlMrfHf61mt6bwCo7Xjx7e/M3jJZLXT7QAAALVACBAC9brKyNlEreKK7fSDNKK2Pri9qTRsAAPQ6ngAAQE97/M7H5yorxwo9OgDUdqR4dra69vC9T3f7QAAAzbAAAICeNuiXX5u8/sa117p9IK3dtPbGKzO3jFR4JTAA9DRKgACgp2Wq+bJXHvVL3T6Q1kZqpeni8oBQBQQAPY0nAADQuxYWFkYGLh9d74P6n8CR4tlxWV9YeLbbBwIAaIgFAAD0rrns+LevHrth7c1uH0i7bl579W+P//Bc9lK3DwQA0BAlQADQuybXq3On9s+Xl7p9IO2aqeSuO/VyZXS42wcCAGiIBQAA9K6rl9cqar3bR7ExB8oXhouVbh8FAKAhSoAAoEc9eecXJ6u56/NvdPtANuam3KsT1dUnPvpItw8EAJCOBQAA9KhMpfDCzC1H1s93+0A25mDp0nenbpuorXX7QAAA6SgBAoAeNVPJZqqFbh/FZhwqXxisUQUEAD2KJwAA0Isev/OR6Uru+rXXu30gm3H96uvT1dzjd1IFBAC9iAUAAPSiTDX/wvQtVxXf6faBbMaVxbMvTN8yXunLxxcAsOtRAgQAvWi6kpuo5bt9FJu3v7g4pKkCAoBexBMAAOg5D3380elK7pq1t7t9IJt3feHNmerKY3c91u0DAQAksQAAgJ4zWck/N3PztYVT3T6Qzbum8NZL07dkqn38EAMAditKgACg58yWc5OVgtK62weyeUrrg+sXB/1qtw8EAJDEEwAA6C2P3fXYXGXlhvzJbh/IVl27enK2nP3Sx050+0AAAA4WAADQWyaqqy9P93f9T+C6wsmXp27K8EYwAOgxlAABQG+ZKa9MVNf6uv4ncqB8YahGFRAA9BaeAABAD/nSx07MlrPXr/Z9/U/g+tWT05XcYx9hFhAA9BAWAADQQzLV/EtTtxwv9PEAUNvxwtsvTtw6UVvt9oEAAGKUAAFAD5ktZyequ+oFuocr5wZrtW4fBQAgxhMAAOgVT9712Ex15ca173f7QDpGK3X92pszleyTH3mk28cCAAixAACAXpEp516eue3K4tluH0hnaKVE5MrCO69M3swsIADoHSwAAKBXzJaXD+Tf6fZRdIBWSiulRWktouRA5YI3uLKwsNDt4wIAiLAAAIAe8dRHH5opZ29ZfbXbB7JVQeJfaxGtRSkRuWnl1RevGpjNZrp9aAAAERYAANAjpiq5l6dvPlK60O0D2Tw38a8k+LOoQ5XL1751YHK90u0DBACIsAAAgF5w4u4TY37xWKFf63+C0F/cxL8WJeaBwIH1s4dWaw/d90x3jxMAICwAAKAXDFcrb00cfdfqy90+kM3QJtxPJP7DBwJatJZ3r7xycvrG0QovBACA7uM9AADQfZPVfKk2Mt1v8XEU+ovWSgX/VWkRUUqLiCitdfBjE7X8TOEc/8oBgF7AEwAA6LKn7n1qvpzru7f/mpofFdT86OAhQFAOJKK1aK1NaZASUccK5+YqS4998qvdPnAA2OtYAABAlw1X1t6eueHW3Pe6fSDtSkz5jGp+JAj3dVgLpJVSosRsv2X1e6fmrh8p5bt9+ACw1/E8FgC6bLK8Uq7kR/1Stw+kLXGzr6Q0+wbbgz+LeSAgWrTIsC5PrV4almrXDh0AICI8AQCA7nro449OlZaOr53s9oG01mjKp2n2TU/8B9F/8Ofj+bem17Mn7n6626cCAHsaCwAA6Kbp8toL0zfctPZ6tw+kmZZTPqPEf9j7G/yKFq0l7goQdd3qG69N3Zgp57p4LgAAFgAA0DULCwvDA8tX5s972u/2sTTUzpRPu9m3PvEvpkNARA7m3xkcXFpYWOjuSQHAXsYCAAC6Zi47/vKVA+/OvdLtA0ln1/woEbFC+TCs1+GPiYiYBwL1iX/zQECLyI35V793zJ9emejeaQHAXscCAAC6Zma9dP1b+w6VLnb7QFJsdMqnbpz4D39flCh1oLR45enDU+uVLp8eAOxhLAAAoDsevvfpwyuVK3pv/P/mpnyKVQsUrxaid4FZDwSOFd45mKs+fC+twADQHSwAAKA7MpW116evuy37crcPxNGk2TdM/Ldq9nUS/yJilwyJElE35b53evKqkcp6104SAPY23gMAAN0xU85OVNYyfrHbBxKKmn0bzPlRweB/LaJEhXU+InHNj4hE24P8f7wkMLsSJaJH/fJUMTusyzt/jgAA4QkAAHTFlz52Yn598drVN7t9ICLxlE+1xSmf0XYliVWBCtcGwRpCqasLp6YruUfueao7JwwAexsLAADogsnK6vcmb7gx3/3x/9aUT73FKZ+m2dfqIpDoDxJOAlVKK3VN/u03p67NVFa7e+4AsDexAACAnfbkR56cqBaOFM+FczS7ZDumfLqdACJWE7BSceGQJ/pg8dzUQOmZhWe6ceoAsKexAACAnTYg6xdGrrh95YUuHsM2TfmMtqcm/rVSWiutRSu5ceXV0tErKiuFLl4EANibaAIGgJ02VckVhkrzlWxXPt1t9hVTox819SrdutnXaurVOuoKSN0eJ/518FnhzmerucLpy5PDtZ2/AgCwx/EEAAB21EMff3S6unR9l9p/d2DKZ7xCSCT+RbSSqDdAlLoyf3p0ZfnBj/FCAADYUSwAAGBHzZTXXp669rbVV3b4c93Xe9U3+zZ+vZdIfW2POM2+1mu/JBwB6iT+racK8WMBLdevvvnm6NUTNVqBAWBHsQAAgJ2zsPDs8IB/fO28p/0d+9Cdn/LZPPEvEm73lD5cPjczSCswAOwoFgAAsHPmshdeuvJ971p9acc+sStTPnWY+JfUxL9IvP3G/BuVK45VVngrMADsHJqAAWDnzBUW57MXDpQu78Bn2c2+SokJ5a3MfZD5d6d8hqF/oqlXJZt93Smfbs2PpNf8BO0Fie0z1VzhdHZiuLIDFwQAEOAJAADskIfvffxI7vR1azvR/tv1KZ9hq4AoUao+8W+tH+RI/vRoLnvi7q/uwGUBAAgLAADYMdOl3Pdnrrtt9Xvb+ilus69ENT+mtqdxs69Oa+p1X+9Vv715s68kegmiwqFo9qjIdfk338lcNcpbgQFgp7AAAICd8ORHnpwqF65afWfQr27fp/TUlM+g2Tc8KvNAIHrmEHUSD4g/Wzw3IqXPfYpWYADYCSwAAGAnDOn1S0NH35N9cZv234NTPkXi9Yb16MDabg7yprU3zs4cGS0Vt+niAABsNAEDwE6YrmQLQ6Pz5aWO7znuyg0m7zSe8hn+WItm3/opnxK+wddM+YwfF4Shv0QPBxLNvok9i4iqf2ewyGR1dWZ1eUhoBQaAncATAADYdk9+5JHZyuJNue93fM9dmPJpCofamfJZl/iv6yWQcB1y9eqpmfXsF+7hrcAAsO1YAADAtpuuZl/LXHdj/vUO7tOu+VEiYofy0Wu/6qZ8Nn69l9Ps6075dJt9g05id51gv94rsX4IPlolOgGsdoJgXXF18cxbmSsnaQUGgO3HAgAAtteJXzyRkfxVpbfCkLwT+mjKp6Qn/rW2Co2CKqIjxXOjev3zv/D1Tl0lAEAqFgAAsL0yheKpfcfes/xCR/bWd1M+GyT+zcpB4iXHDbnXzk0dHivTCgwA24smYADYRgsLC0Nnlw8uFjO1DsS1dlPv5pp97cBdmQR/o2ZfaaPZN/pEt9k3fHWw9dbh4M/aeW2wu33UL8+tLQ9JeesXCgDQBE8AAGAbzWZHXzmi3rXy8hb309dTPu1lRpz418H2cDhQ8PPH105OreceuedLW7xcAIAmeAIAANtovlCcXZk7Vjy76T3sgimf4ZE0SPzHB6PVweLllw7fPFXObfpyAQBa4gkAAGyXxz7y2NHs+s25Nza9h10z5bNJ4l/MdlFKlFyxdma0Vn7oblqBAWC7sAAAgO0yW1l+ffy623Kbqf/ZZVM+4+bg6MCiAiQdPxDQSl2Tf/vc6BXjVeaBAsB2YQEAANviqXufmvQL1xTf9EwSvH27cspnUHyULEzSwUeINhONlOj9pXOjtcL9d3+lE98DACCJBQAAbIvRcu789PE7VjY2/XMXT/l0E/9K6+D44/VG1DZwQ+718yP7Rmulzn0bAIAYCwAA6LxnFp6Z8oqza2c2NP0zburVyRbbMPFvpu5Ezb6Jmh8n8S+SSPxHZTkpiX9xA3FT8yOJEN88c1Bugl/r9MS/vd06QRUsPpIjRM3SYliXZ8u5obXlhQ8tdOLbAAA4WAAAQOfp5dXVY1e/J9tu+n+PTPkME/8qmfi3/hMsPdR1hVNnLuQnZqc7/MUAABgDCgDbYbKwlFtePVi61PIn99SUT5H0xL/ZSdzwMFvOHr72ZrVyebPfAACgIZ4AAECHPf2Rh6ezF25ee6XlT+7BKZ+NEv/26Qe/eGXxzPyY/sK9T3X+GwKAvY0FAAB02Gx58Y3MtTetvt7kZ/bslE9pkPgXa1hQsK44VjxzLnNosrLW6e8HAPY6FgAA0EmP3Pn4eK1wbf7VJj+zl6d8Nkn8W+uH8DSPFM8PV0u/ddfXtunLAoC9iQUAAHTSfGX5tYlr7lh5KfVvd+GUT52a+G825VMaJP7N9vg5xtWrb70zdHCilt+mLwsA9iYWAADQMSd+5ssT5fwNhZMDulb/t/0y5TNYm9gJ/mZTPpXa6JRPJ/HvrB/CdUi4bhA1IPpw+VJGrz/4iX+znd8bAOwtLAAAoGMma7m3R66+Y/m5xPb+mvLpHPD2TPmMVyzKSfwH/5+9rrgu/2Z2Yv9wZX17vzkA2EtYAABAZzzwya9mZO1o5cx4LY5Wo1L+1MS/SDzls0ni32r2rZ/y6ST+VXuJf52W+JfGzb6NE/9260LDxL9YNT/uIwWxE/8SrCuUin9dqWGpThZWRkqFz/700zv0RQLAbscCAAA6Y7K4+tbsle/Nfifa0oUpn2bPHZzyGRxMx6d8xn0IVs2PVmEnsb2uuGb1jUu1yZHB6k5+mwCwi7EAAIAOWFh4dlRVji6dm69kxa352dEpnyIdn/KpUqb01E/5lI1O+XQaHnR0yvHORSutlVJqwi9Mj64PDWcXFhZ24rsEgN2OBQAAdMC+7LnvH33XHavPi9ML6+bao2bfXTjl053m2d6UTzfx756+tt5cJuqq/JkLh3OZ3MyOfqkAsEsNdvsAAGA32F+4tD97/sj6edOnG2b+g//Pys2HUbiKCmCi7XZgHYbXOuoKiLabxL+p6hHT7Cuqcc2PJEN/CffVIGevRCllb7drfsySQJQyk4TMaTZJ/Nc3+5rEf2J7sMfgxWFRmdB8efnAO+/3hi515tsCgL1NdfsAAKDvffVnHrymcGqqtnrd2pthkjy92TdZ8xNm/e2YWMKAvq7ZV8IQPxH6i7OuiP42ztknjiTYRWLn2gm4Vdp2qQvQGzT7qpahv4r3LGIfibY/Pbn9/MiBwuDYxbEDnzzx05364gBgb6IECAC2al/p0pvjV1+7drJ3pnzaRfaJZl9r53GTQJz4b9Dsu5kpn6mJf3fKp93sayJ+qwApPEERpQ6WL14cOzBZWd257xUAdikWAACwJU/8zBfHaus3515hymdyymfU1xs1PNRN+bSbfcXdHr8jLOyVUEeKZ4f98v33fG1Hv2AA2HVYAADAluwvL74xfvUt+dd2YsqnWSdI56Z8inR5ymci8W8uXbw9Kkk6Vjh3YWT/ZDW/o18wAOw6LAAAYPO+fOeJjF+4Jf9aHMpv65TPIF/urhO2OOUzbUqPk/jXbST+Jar43/iUz6AZzXkgEP45TPxriZ8GHF2/OOyXP3vv7+7M9wsAuxILAADYvNny0tsTV9+We9mKmHfFlE8r8a/aS/zbNT8bmfJpFRqZxH9QgFTXoywicqx4+sLIQToBAGArWAAAwCY9dteTmWrx2rU3vGAQfsNmX5WS+Jdk4l83SfynNftK4pGCG6AHR9gg8W81+yYS/3azryRrfqRp4t9st55jOIn/5COFcPJpWuI/7iSO2gDMIkFEjhTPjfrl++/7gx36mgFg12EBAACbNFtePJk5fvvKi2Hiv2Gzb/xAIE78iyQS/1Y/bl3iv67ZN5rAX9/sq90pn3FLbl3i394ucddyw2bflMS/ttcP4TqkYeK/rtnXerLhNPtG6wRzPa3nG1pdWXh7eezgaJWHAACwSSwAAGAzHrvryYnK2jVrr3m+z5RPiRoeNjvl0272DQ4jWs/Y6wRRylMyWzo74hc+/cnf3qlvGwB2FRYAALAZM+Wl05mr3rv8vDDlM2p42NqUT/eRQnj6UeI/XhqJHF976+LYzES5uKNfOQDsFiwAAGDDHr/z8cnq6vH864NSi5p9mfKptzbl0309sDlNHT2XiNcbnuhDa0sjldKn735m5751ANgtWAAAwIZNl5fPjB177/LzIsKUzw5O+YyPzSpJMv3K5jS1Eq2uzL+9ODg34Rd26CsHgF2EBQAAbMzjdz4+Wc1flT85pGtM+ezslE+72VfrcGnkNDyYPQwofbi6OOKXPv1z/3bnvnsA2BVYAADAxkxXsmfGj7135QWmfFqJ/85M+XR7keOanyjxr00vgRI5Wji9ODY/XqETAAA2hgUAAGzAl+750kQtf1Xh1JCuMuVT7MR/h6Z8Rol/sU8nfnQQbtdKDWp/X2FptFb6zft+f6e+fwDYDVgAAMAGTK4vn5049p6VF5nymUz8S2emfNqJf3v9ECX+4yojUVevv708MjdepRMAADaABQAAtOuLdz2ZqeSPZk8O18rJmh/FlM+OTflMWz+E28NeAnNqnq7tK10erZU+ey8PAQCgXSwAAKBdc+Xlt8avfF/uBSuBzZTPzk/5dNcPKYl/c2oioq4snskOzY7xEAAA2sYCAADa8vCdj09UV6/Pvzmkq27iP+h2ZcpnJ6d8xuuHtMR/XGgkyvNrc6XLg7X1X/747+3UvQAA/Y0FAAC0Zb68fHrs6Huy32XK5w5M+QxbDsRaKriJ/7BVWpSIOrZ+5uLg7KSf35k7AQD6HQsAAGjtkbuenKgWblh7c1DXTGWOk/jXTRL/OqXZlymfLad8xtvTEv9OJ4D4R2sXR/zSr97DQwAAaI0FAAC0tr90+e3MlbfnXmLK545N+XQeKZjGBjvxr+ODVUcL55aG56Z4CAAAbWABAAAtPH73iUxt7ZbV73vaZ8pnvA4JT3Abp3wman6cpwrBwZh1glJyrHpxxC9/+l5eDAwALbAAAIAW9q0vnpk4cuvKy0z5jLbvzJTP+pofCVcIOty5jrspDhUvLA/NZGo8BACAFlgAAEAzX/7oI5lK4ebsq8q88ddqmVVOzY+JX5ny2cEpn4maHx2dprPn4If1wfKlEb/y2ft4CAAAzbAAAIBm9pUuvzN67Obcq9oK6JnyuWNTPpPbo1aH4PqImYCklIg6uH5pZWQmU+YhAAA0wwIAABp66iMPjdUKN61+L2r2TUn8x7XsTPlMafa11xubm/JpN/vWJ/7jBwKiRMmB/MUhzUMAAGiGBQAApFtYWBgavnhm7Oj1+Td1HLjXJf51SrOvKKZ8xtvjxP+mpnza6weRKPEvYeJfSzxSSWR/9XJ2ZKaYL3z4w89s8w0CAP2KBQAApJtfHn31iHpP7kW3H5cpn+1P+bQ6AcT++Q1P+QzWD4l1RV0vQXjNj+XPvFAYPTamd+pOAYA+o7p9AADQixbue+iq6uJoaervX3zWVOAoSST+JZn4t2p+7GFBUh/6x/l+q9lXopy9ij9RW9sbl/sHKXVrzw2mfJo/uzuPM+vhdusEmzT7Kif0r5/zY7aLiv9dE+bsnVMzp5/cru3DiHaeupNwu7ka35+8Pr9e8YenFx79R+1/6QCwR/AEAABSHChX3hqcf0/2BRPRMuWzy1M+o791jsRE/06RlVLHCmf84ekRtb4jNwsA9BkWAACQ9NB9T85WiretFfeVF+OaHxO/ClM+7dqeNqZ8inRgymf82q/UxL+7fcxfnx5YGdKVf/7JP9rWWwUA+hELAABImirlljKH7lh6Pk5sx72wTPnc8JRPaZX4j7c3nfIZrR8aJf7tMz22dm5xZCZTLe7ILQMA/YQFAAA4Hr3vyclq/ljuzJS/5tT8MOUzrdnXXm9s95RPu9nXXCW3cCg8TiUiw7p6cH1pzC//Cg8BAMDFAgAAHNPF5YuZw3dkX3Rr2d0QXzHlM675iRP/2z/lU8x2swc78R/XQQXriqPl84Xh6dEq7wUDAAcLAACIPXLPY5lq/qrlk6O60qjZlymfZrv182L//PZO+bT6JdzTDJde8QOBQb86u35p2C/9vz//77f91gGA/sECAABiB4qLZ8YPvTv3cmriX4WJZ6voxW32lboHAk7RixO8xs2+bma9Yc1PnJuPR4WKvX6QOHBv0exbN6XHbvaNAms3EG/U7Fuf+G9Q8+M8VYgS/07PcavEv93qYD/fCK+/1UkcnrU6VLyQHZmcKPMQAABiqvWPAMDe8MRHv3ikdH6iWrx+7c0Gc37CJYFEuXmlxAr94+12WU48ItOuwImjXrHH8DfYiQzXEzEAACAASURBVFPzUx/6W9vFys23HM/ffMB/+CuNpnxap6DSt2vzVMQsA6Ji/SbNvqlzftK2x9+OfTGt7cE/F4fnSoNDq8OTv/Tg/9jObQAAux5PAABAROSZhWf2DRXPjhy6fu0NpnxatUCtp3w2T/xvx5TPOPFvvqP4uYd2vgWl1HxlaXV4cqq0cuLuE9t7DwFAnxjs9gEAQE/wl3PrR6547/PPajf0lzBiTjYBm6r2hol/SWyPQn9JpucbJ/7dZt9Ed2ywN2e7Gb8T5+y1+fT6xL+EXchB6B/+V+s0dTCFyMrNm5x9vBOrJTo98Z/Y3jzxn6z5SUn8myVKsPBIJP6DZUb83YXrBK0Or10oD3nramyTNwcA7C48AQAAeei+J0eKK9WT7xwsX9RM+eyHKZ/NE/9ibRelJmr5FW/e14r3ggGAsAAAABGZKq2dHZx7X/a5OF3NlE+zPZrSk2z2VV2e8mk9Nokqo6y3m1lvDdNKHV4/d3Fkfry2vq03EgD0BRYAAPa6L9zzVKaSP5Y7P1nNC1M+UzsBxP75Xpny2Tjxby2QzJJpWJf3VVbG/Mqv/fyfbPMNBQC9jgUAgL1uX+ny2bHDt698lymfKc2+PTvl0zwfaJT4t08zaBk4XLxYGp4Z4b1gAPY81fpHAGD3euKuEweLF0b99Ztzr0VdsBLl5pnyqdznHs52HTf7BgcZ5eZ3cMpnfG2tFYV9Dc2/6ZQWuTS6r6YGV4Yy//LB/77RLQEAux5PAADsXc8sPDM/ULwwdvDm3GtiF724iX8rIW3/U0SkSeLfbvbt6ymf0jTx3/Upn3HiXyUT/ypqGDCns6+0tDKUmSlnGQkKYC9jDCiAvctfypUOH3nXd//cSjCboNzktFvn7IN/MuUzOp2dm/IZLAnC/mb3EUF4kDqeKRRcWX24cEkPVAve+MbuFQDYRXgCAGCPevCnnx5ZW62+8c6R0nkn+m+W+GfKp9Qn/rs35dM6QesbtBP/oqxGalFaqYlafnFwnyhv4f/4w+28vwCgd7EAALBHzfjZM5X59618NxGgB38bh/JRpCsiu2rKZ7jnaEpPstlX9dOUT7MwELHXVNHpmycVwVOFw+uXVyZmhsrlbby9AKCHsQAAsBeduPPxSX/t6tpbGb9gV97H3a6mByA18b8rpnxaPy/2z/fllM+wYMkpSTKnL9EBhAczpMvja2tD1cq/+BTvBQOwF7EAALAX7S9dvjB+4PbVV6KAPmCljU2QKuIk/pnyqXZkyqf5rEaJf/s0Gyb+3UcKVieAHCpeWh2eGC8Xt+0WA4DepVr/CADsLk//zEMHyhcztcLVxdNihf5i5ewlbkiVulk62kkzM+VT3Gbf7k35tEN8c2rp20VUdmi6PDCYH8j8yy/8o+QtAgC7Gk8AAOwtn7nvyVF/9eLwgasLp5nyKa0S//015TP+XbfmJ9pz1NchSs1Uc/mBzJCq/bN/9ufbfdcBQE9hAQBgb5lfXzs1efCOleclin1NUGg1+zqBu9PsawfounniP9nsawJfra3A3SqGMUF5XPEf7qW+2ddU/Ldo9jX9ym6zr5j1g72uSATi0eHZ25sk/q31Q5zjT1xA+0yDZZPTCVDf7BsthOxm3/AaSrI3QEREa/epRV3i3+kl0HKoeCGXmR8t8W5gAHsLJUAA9pAv3v3l/evnh2r6fSvPWwGiVTljEs9hClxHDal2Arths6/5pxX619UCheGpk7O3jiTu07U+1B2XKdGYztSdtC4cStb8WKcWHmTiE5uG/oly//AIzdMVu6k3vhqS2K7FvpJibQ8PPtHsG31rdYVDTWp+wkcKYWVU+IkXRg9UvYE1Gf+NL/xUezcRAPQ9ngAA2CsWFhZGBs5dGj307twLDRL/TPk0h+cm/nUy+hfp4SmfTaL/IPFvXX81X7q0JuOZGg8BAOwhLAAA7BWz2fHTB0u3Zl8eDINdpnzuzimf8Z6jFVrU2GAWQtFpeiIHyxeHdGXhE/9p++49AOgplAAB2BNO3P2VcX1GVyZ/fPEv43y/XfQS5ew3VfMT9+NKXF5irx9E27GvtXN7iJApgElM42ky6qedmp/oItRVEzWq+THriiizbnaeupNwu31N7NNPrfmxtke5eecE7dA/eUHM6btZ//gT0xL/dgWUfW2D7WfGj3paLw/P33//jzS+iQBglxjs9gEAwE7IVHL5oWM/svIXpuYnCk+lLrzWTqzZesqnjh4dhKG/ckN/q8ZdotoeqQ/cVSJwN78UPFKQsP03DP1NAN2RKZ+mvMaq+FfRykSZRU6Dmp+NTvmMC66i5YduOOXTrArqm31V2s6dq2Qq/rV1be3TDM5aKSWyv3z59cwN45W1tm4mAOhzPAEAsPuduPvJA8WLov07Vl6I407pQOLfbva14lorPI2z0S0S/3YY3Tjxn0zwt2z2lbQAvUHiv3Gzr8Trh2gnEn7uRhL/brNvi8R/SrNvSuLfDv3jz61r9nV2FQ0Lsj700uB81RssDoz+xoN0AwPY5egBALDLLXxoYXjx3MWxA7evvGxnnU1FuylkN5XoiZbc5ol/idYPYS27MOUz2NLGlE8Jr7PT7BteQ0n2BojIhqd82s2+5lMkTvwr+30OMldZLg6MVgprH/7wM9t6QwJA11ECBGCXm58efWtx/Se9l5TUtFPR3iLxr8JgWLmhfzLxryWu+Ukm/sMQ30pga1OX0nTKZ1riv1HFv7PdSvwHfboidmlNcNZh4t1O/Itd8xOdpr09LmeK2gMSO6mr7G+U+I+afaXdxL9ZsShRcbexSFrNT1jvpO2FR/TUJTx990sJC4qU6P3lxb/KDRzIDG30HgOA/kIJEIDd7Is/+7Wpy6e88YkfXvqmiCQD96hepWnNT+KH6wqHGlb8Ozu3an6c6LbFm33jgqJo/WDX/ER7ThblR9vNzp3cud0JkGx1sA47tdm3QUFRXc2POUjrEzfZ7Gt+uJ0pn82bfaOaH/MN6sTK5PzIwWK5rCYmf+NzPykAsEtRAgRgN5tfv5zbd/Ud2eeioFDHpS9M+ZSocMiqidpVUz4lqPnRyZqf+Itz9zBfuqwmJkcq69t3TwJA1/EEAMCu9eU7v7ivtDxaW782f1KcnD1TPrV9GJ2f8hlPPdpC4t8t948/cQuJ/3AtVJf4D3euRSuVHZyqeQPr3viv0g0MYJfiCQCA3enzv/D1cb94eWT22vzJOPEfJaFN+rlJ4l/CiFMnHx24iX+R8D278a83SPxLMrMeJf7rm32lWfSvxY13rcR/42ZfiQL0KPEf9cJaCX438S/xdnG2mzi7RbNvnPjXycS/jhL89Yn/tGbfhon/4HFH+HCgReI/+Mi6xL/9zarp6uq6N+7pyi/+4rPbfJMCQHewAACwO00VV85OHX730ktW1UrUSxqFg0EIKFq5YW59zY8T14a1PW7Nj7aqSsIKHLECcbsyp3HiP675CQqEotKUBpU54eMJsab0xHlut+ZHR6fp7DnYuY7WD1Kf+K97qhBX9STWG27NTzzpSJsVgoqvYbhysNYV8e82qPmJanvMusU8jVHuwWhtXWdrvaG1+bOV+A/+wu0Ynisv5gbHR6vlbb1FAaBbKAECsAs9ctcT+yqXle/fsfKS0+wrycx648S/3Sq6gWZfK2evncT2xpt9zfE4AzrjnUQ7dzLobu7cbfaNdiKJnW+82bfu9V7ms9yaorqaH3Nt7ZFBdT+8xWbf+AQbN/umbjffoIjIpcE535P1gbHPPEA3MIDdhgUAgN3mgU/+0Vz+7TVv+O9d/DMvrBzZWMW/1G0Xa/Hgvt5LnDA07tNtNuVTzA+n7KS913vZob91asGO2369V8oQofAIg/5oZyfO1Uiv+LfC601N+Wwa+lsHL4lPNCcizs80Wz+EH9ko+g8eI5weOzo2WFFTowsLfzf9VgOA/sR7AADsNpn1xaXMlXdc+FMvjAlVMvRXzoB/cRL/VvTfIPGvm075NDl4VRe4B2sBFYf+4TGkJv7DEDbac5SbV+4npiT+Ew8EzGGIWMFxw8R/ynYTOidC/+i6OWP4dRCf6+iNZlbor4KrkVwSROuE7ZryqeKViWq8fkguCZSar2SLc/O1QqXVHQcAfYYnAAB2lUfu+spcZVlr/33Zv3Wy4/Y0npaJ/7QQv2Hiv3XOXlslMYkAevOJfzv0D09ta4n/IPRPyc2bBwLtJ/61cna+lcS/fVnSAnetU2t+Eo8s7EcH8Qc1jv6DP2t9YWR+cFCKMvaZ+3kIAGD3oAkYwO6x8KGFoeWzS0Oz71r5rtitpa2afZUK/1/DxH88xKZFs28YLqdX/DtdsHFTb6NmXzPVXuLEf3qzr7jTe+KmXrsXViRO8CffHWYCd3s+UvifqNDIdBKHZx2P+nGafSXZ7CvmYUtKs2/UBxyfTqPEv8RDhOzO45RmXxW82ldSo38VdxKHjdQ63B7fGOH1Fy1qvpwtytgb75oxBUYAsBuwAACwe8zOjJ5eLN6Ue2lIV6MAvWnFf/BHFUW6YfxnBeIiTPncVVM+ndNvkPiP2gkGRE+Xs7/30ff82B+/uT33LAB0ASVAAHaJB+766szK2yqT+cDyt8VU8rTf7CtxjYpOa/Zt8Xovu3S+LvG/ucKhuOYnrSh/IzU/EhcORTuR8HOTpfDa2t685qfF671San7Mzzeo+Yk/N6XZ19pVtH5QKTuJantMB4VYp9ay5se6ttbBXBze9861UwdPrn/m8z9ed98BQP+hCRjAbrCwsDBy4Vx2+sqfuPwNO7xunvgXs06wokwdV64nos+oFiiOfU3i32yPmn3DBHkQkob/Ndnsq6IAPa2pt/WUz8T2JhX/KTU/G53yGaTexY68wwcsym72NdfWFPmIvRNtrayc7ak1P4mVgznNYBkTXL3Gzb7O9sahv7M+SYv+g53MlZeqJ4eH/fVWtyEA9AdKgADsBrMrmXMH8zfnvz+sq6YypGHFf1wZYgpCJIq8k6/3ireL2MX61uuETam9NoF4WuLfbNfxqNCgSMbuJbAqc6zuhbqKf/v1XuZg017vFb32Ky56iSLyuqcH4XHGYXFcaOS+3kus7XWJf7Ff7xXWRIVn2vD1XlFtjylYEtFWVU90+qbmx634d17vFR1M6uu9RJKJf+sbNA9b7DIhc+Se6MlqdsCv/Z+f/NNtvIkBYKdQAgSg793/8a/NqtNebeoDl75ZX/MT/SGZ393I673smh83bWwn/utD/5TEf5wptxP/idx83QMBp3LGTfwHh2GdmtnJxl/vlagRij/Lzs03qvlJPqwwp29+eLumfDYrHGpV8yNiDtD9RB39hvkxpS4M7h/0aoWxic9/+ocFAPoZJUAA+t7+8uKl4Sv+3uKft1vxH06DcSK8uOI/ChfTi/Wb1PzUT/nUDXZSv36IK/7ran4kzI7XN/uGjwjqan6SRxLXAtW3F0fxrtg7r6v4j557xNvjKhpdV5JkTl+UVsFjgTBnL1HobxUUhUeiVV2ArsPWhUTNT9TYUB/6xwfQKvo3w4LEPEBIbI9C/+CX5ypL52eOjpaLze5FAOgHPAEA0N+e+uhD0+WVMb98vHCqUejv5HcbTPkUsWLftMR/HCy6AXqLxH+r0D86kUa5eUnZru3DiMfkN0n8b6rZd0uJf7fZN/7ELST+w7C+E4l/+7XBKYl/ZV9YFXUv5AczVW+wLCOf+dcfEgDoW/QAAOhjD9z5tUylsDI83SD6D/5oCsR3cMqnbhL9p6Xhw0r0RPG9iJjDFjvxr5jyae3B+Wbd02+U+Leif6sTwHnDg+klUFGPgYgarxbKMjLgV37hF/6i83czAOwUSoAA9KuFhYWRC2fPypEPLf25juLg1JofEYmH2Oi4JD2uRUlP/OsNT/lMJv4ljJXTa37iPVsVO2Geu/2aH+uBQLQTCY+nRcW/Tkv8B38bTzrSpurJTvwnuxHMtW1c82NP6VHJnL21q4ZTPuNuivgKhAfYXuJfS1RQFF+E4BN1XNwVNyKH10/ZpzlTXr4wvH9El5rfnADQy3gCAKBfzWXHzx3M31j4/ogupSb+xYqAo6S1tgJ3e9KLTib+w73EDwQkGnnZKPHvvHjYzs2HOXu7bcB6INAk8R9vT5Ykmeg/yNabYUFNEv/xmbZK/CtlJu3YbxdOJP5N7rx54l+smh/3kULizb7mNcMmQK9L/MdDgZzEv6pL/OtwXRGdjvkGrZIqa6GotTXQyRy21ioe0GQNCxItntSm/dygrv1vv/CNbbu1AWB7qdY/AgC95/57nprTZwfKk+/Pmtd+pSX+rSVBlHdv8GYuZ0pPSuI/yJTHVeOpO9l4s6/ZsxWetvl6rwbNvlYtu1vZbyX+ne11zb7R9vYS/3H+vuWcH0km/tOL8pvvRJuP3EDiX+ydW7VAVhOwm/ivO03tPPa5NDQ36FdKA8Of59VgAPoQJUAA+s/ChxbGli4szR35iZX/Kk0S//XNviZtnNhu1/zEaWOxA/cgklRx6O8WFEXrB5G45ifac5SYV+4naudDzeLE7oI1hyFiBcfR672SNT8p200gmwj9xVy3xOu9wpIa86zDCv1VcDXqan5MgL5dUz6bFQ61Cv3FPLBIfGL4IMP6sTDxb65hyvpB2zuZrWQvD8+efPes6GhNCAB9gwUAgP4zOz1+/lLhg0OvD+tq2A9aH/oz5dP5RGmZ+N/jUz5bJv61tX7wRE/WCv/+o3/ng39y6i8b36gA0JvIWwDoMw9+/Omp5XfU+OQP5L6jw5S6Fbcx5TOt2Td5+lYTMFM+7fbi+LZJKxxK7GRlZPr08an5N4tfuP9HBQD6BwsAAP3kc596ZnZ1cU1lfvzSXwxKTcSuGEmv+Ym2S7PEf33OvlXo32gnbrjcOPFvBdBtVvynhv5p2+P4u0GxfhTphosfewaRvTgRN4AOdqKjU2tZ89MoZ6+dE0zU/CRD/+T2+PRbJf5Tt9uJf63ja+4m/hsUDtnrB1E1UReH54bGvOqh/Q/+/PUCAH2CEiAA/WSikFuenH/PuecGpeakZpnymZb413binymfKc2+EjZCON+gNt+siq+n9UAgWvx4IjOVlZXjNwws5xrcsADQi3gCAKBvfPGuL89Wl8XXt+deaj/x72yPc/a6LuxrM/FvN/smc/bxTpy0ccPEf7x9y4l/O/RvnvhvXPPjJP7tAnrZWOK/Wc1PfIKbS/xboX99zt69etEKqlni314/BLtvmfi3H6FokdzQpIwM18rq/vt/RACgH7AAANAfPnvv7x9YP58fHP87l//CU3aEV5ea1W5E6wbuQThXn/gPMuVx1XjqTpjyaW+vC/0lmfi3n7qY03e+lB6d8tks9A8/MV5A+qJWhuZUpVysDTz88I8JAPQ8SoAA9IfZ8uWLo4d+eOm/htE/Uz6d6ppE6C8i5nTCE6mr+VFu6K+Cq1FX89OhxH8cgicS/D055bNZ4j9afVkFS5lKbrGWGR7w625bAOhFPAEA0AdO3PXYTDk3pMs3rr2ZGvo3TPxvoNm3fsrn5hP/dugv0oHEv6lRqcvNm1C1/cS/3ezbkcS/NterLkBv0OybeGRhPzqIP6hl4n8Dzb4dSfyb6+xe2PBEdH4g4/tSGRx+4P4PCgD0NhYAAHrdF37u6/P5C7nBiR9d/GZ64p8pn4nTt5qAmfK56SmfTuLfqvlxl0bRtZKloZlBqVWGhh/8zAcEAHoYJUAAetrChxaGLp9b3Hf4B8//tZbk673ESmmLXZixgdd71df8SBjqdWTKpxYnQFdKrFE/yk786+QjCGmwJGiYm48G2lhTPnXDKZ9mVZBM8Gsn9k0k/q2ComBjohjGJP5FpO71XsGBKJXe7KuSp7nFxL+WjU/51E7oH+wtteYnXFYGv66UiPhKTVbXcmPTb946zeuBAfQ4FgAAetrs7Pi5C6sfGFgb99ft3DxTPoUpn9Enbs+Uz/DpQeIqaeuhSrRdha8HHi0X//Cf/tAP/ecz/y31bgaA3kCKAkDvevDup6eyZ9XE5HuXn2+U+He2M+XTPn1thafxT4q49fdOgr9R4j+x87005TO15ic+wfibCr/l3ND0O9dM7D9Vfviz7xMA6EksAAD0qN+6++v7KsurQ5M/evmvBnUtmfgXkUR8pqPYjimfTPl0T3MLUz5bJv5FnJ3XtGRH9w1VSrrmPfggzQAAehElQAB61Gwle3lo9gdWnh/UNW0F7vWJf6Z8Wol/pnymrh/ai/4lpeI/+FsJPzaup5Kw9EuHf20+0ROZKK+s++PKYyoogB7FEwAAvejRjz8+XcoO+ZXrCqekSeKfKZ91iX+72bcjiX9trlddgL6Hpny2TPxb/xQtUhwYF18qA4MPfY6HAAB6DgsAAD3nsx/7+pHqhfzI5AcW/0YkzKA7xTDJ8Jopn0z5ND/pJP6d9UOzxH99zY/EFf+NQn/nsE0nQLT0yg1MeNovecOP/qv3CwD0EhYAAHrL5z71zORqNutPfCj3VyN+JQocZZOJ/5TQP/yVjkz5FHEC9C03+0qT3LzZHkW6YqXh7cS/WXK4AXSwEy1O7NuqWD8tZ98g8b+hZl9zlFtJ/G94ymfjxH/iNE3i3zpC6xOtJVMy8W/v3NdedmhqYmB9aryysPB3BQB6Bj0AAHrLxPrq6uTM7RdeHKlVTLE+Uz6Z8tn9KZ9R4t9ZDtUl/lX8HelMLT816RfWhwQAeglPAAD0kEc+/vh0bVW0ujX7vfpmX2HKp3362gpP458Uk72OlkMiG0v8M+XTfaLiTvlsVPMT/rp2vw6lipIZGqwWZPSR32IqKIBewQIAQK+4/76v7S9eWhuc+OHFvw22pKVmRdIS/1rFIVpd4t9ZJzDls1HoL8nEv/3UxZy+86XsxSmf9vrB/XKjdYtzmlrL2tCU0pXS0MATn/4BAYAewAIAQE944JN/lCmdzw2OfODSt8ZrxTA0TIbXW03826F/tOdkbr7ugUCTxH9wGBLtMNrJxhP/4v5824l/c/paRJLbo3XCdk35TCb+09cPTZYEzXL2ycR/2k7M+qEjiX879G8z8e+G/nWPJrSIUr4v2fHMpJRnR8s0AwDoBfQAAOgJY6XL+ZFDNy59M+MXfWmUs08f8B+EbnVTPtsd9VOf+LdCf5ENVfw3SPyHNSpOhG1/orRM/OvmUz6T0b9Jcjeo+LffHhAeiVZ1AbqOivKVE3lr80F1oX98AC0T/06Cv3mzbzuJf22H/taRxKdvkvbOhQ2XlW0n/rVza6lk4t+K/oNvSomIeJ6Ml8qz0+V8iX/nAugJPAEA0H0n7n5sqlL0dfW2te+LVn4Q6Ptu0YukBOhM+WTKp30wOznl0/pm607T+ndr9PNFb3h4wC/osUc/e4cAQFexAADQZQ988rfnC+fXBjI/uPRtT2mtlfaVVkpFAZ/U5+ybhf4SpbTro383XG6c+HfCR4kT/3GCP5n4Z8pn4vRbJf5Ttzdq9nUT/00LhxKn726PLlp0GZ0Lu5Epn/HX5FyltIoyUaLFV6owOOGpWnV46PFfvV0AoHtYAADopgc++UcT5fNrw+Pvv/hX435JRLTvaRFRnhMUtjXl01kntFnz017iv3HoL/H6IdqJhJ+7kcR/+pTPBon/lGbflMS/HfrHn5uSs7d21XDKpxtANynKN3tsv9nXWZJZtT3Na36suNz54lok/ttu9nVvvE0m/hNLgppShfHJjF+cHS7SDACgi6hHBNBN4+XLa8OHblj+63G/JM6UT2la8W8i4/C/Jpt9lThx24anfCa2N0/8p3YSb2DKpxJxivK1iBYz4F8lHhGEB2kX0IvEY/i31uwbHJ1b8R8k+K23BDjbG4f+9Tl79+qZnbiJf+0m/u31g4RrlhaJ/+C34mvr1vyYMn7T8BB/gzr8a0luj7+atAWnOZFwLWevA60bIzxNT2SkuD47WVwtj9T9TwEAdg5PAAB0zSP3PDJTKfm6dkv+Ve2LUl4QLPpBTCxM+WyZ+G9cUFQX+ksy8W+Hqub07euWvn5okOBvtH23T/lsUvNj31rWCcr64NiIVy54o4//xnsEALqBBQCA7njgZ7++r3w+Nzj+geXvau2b/3OktFZaKS1KfDvxH0dyTtFLMsITsVOzTPnceLOvpCX40wqHWoX+IuYAGwTuVuJfzCKk0fqhl6d8tkz8J+9G7RdGJ7yqrumRL/3WLQIAO44FAIAuWLj760dqK+vD0z+U/evRWtUPYsug6EUH/xFRnhX610/53Hzi3w79RTqQ+Dc1KnW5eROqtp/4t3tSO5L41+Z61QXoDZp9E48s7NA//qCWif8NNPt2JPHfaMqnOfANJP7tnccHn9h5i8R/Suhvryq18ooypaTqe8NPfOYmAYCdRQ8AgC446K+cHZj+O7kXRvyKNnGnXZkjSmllxb6piX8T+ouITgv9g89SUWbXHqcT/E3Kdm0FiFYA3XDUjwncUxP/5nRMUCgSjNtX9v6txY9KJP6Dc6lL/IsVntqfuIXEf3hBOjblU8X1WmJi7uAq2TU/Ekz5lLARQswOw8S/CZejW6JR4t/tJK5L/JtOgPAwlJnRr5ok/lWj0D/4p/n+46VafDUaJP7tpwe+HlJr5YEpJWUBgB3HEwAAO+2Jjz84Vi2OKn08f0pETM2PlnD+j4m/lRLNlM/0BD9TPlO3RxctuozOhd3OKZ/thP6JG680MKi1V/Pkyd/kzQAAdhQLAAA76os/+9i+0uLaQOa9uRe1eCKixdNadBg9eVppJZ6vRZSnfTeA3kjNj6QF6HHkzZTPup3EAXSTonyzx3aafe1PdBL/u3TKp7Nu0dFq0/lhUc7OiwPDSktlYPQrv3GzAMBOYQEAYOc8+Imvz5Yu5QbHfzD73IBfE8/TWsT3fBGtRGvtiaeViPZ8X8K/TWv2FXHitg1P+RR3+5YT/3ao2jzx3zj0dxL/9oQc2Vjiv1nNT3yCm0v8W6F/fc7evXrRCqpZ4t9eP0gigI6/wYa5TV+GIgAAIABJREFU+cRpRjU/8QlaIX7dQwn3Fgp+XbtfR12C39l5y2Zf+zRN6J+8n329NjKlKpVKRf2bf/0uAYAdwQIAwA753KeemV7PFgYm3rP8rYlaISz71kq08pUSCQYBKZHwTcCmtn5jif/UnP2GE//JSE7E6VJwd+Kkh5sl/sXa3l7iX9zotlXOXiTxiVZRvvUzrQqHrOu2mcR/ohZoM4n/xjU/0vNTPqNVZfK7E/eBgLm7fOWtlodHdXVovfboo+8XANh+NAED2CFTpezK6MxNyy9O6oKvlPhBO6zyw/gsqPgPemFVsvPVSvwncvZRfKYSoZXUJf4TDwRM0CZiF2Y0bvZNT/yrutBfJIwmE6/30uGxqbabfTuU+A9+Rpz4Nfl6L9V4/dBkSZCes09cPaV0uAhJSfybfbeX+I9WX254LeHHxs2+ohu/3qthzU/do4kwbd868a+bJv61uYT2/RwtWT3tZ4Yr3opfGx0QANgRPAEAsBOeuPfhTK2gfP/6whsiytdWfKxFifKDwFF5IiJa+SKiPDOzZWOJfzv0F+lA4t/UqNTl5k2o2n7i3+5J3WLi374saYE7Uz7TE//2zuODT+x8a1M+UxL/KaG/vV3KakRVa+Whoa/+5q0CANuMBQCAbffAfU8eKF8uDE7csfJ8EBtp8XwdJv6VVlqLDuM2T4sW8XwR0V79673s0D/af9vNvtJ4ymfKTsLt4sa4UbDYtObHTfxv8PVebugff+KmEv9OWN+xKZ/R9W8QuMfxrhv6O4l/Z/3QLPFfX/MTBdCNQ3/nsLfW7Bs/fNhgxX/9uiK5ZJX4fi54I56q+UMDX/0V1gAAthcLAADb6/77np6rLK8MTX1g5VuDvh/l5n1RopWEL/8SEeVrLcoTkeBdYL4WT3l16fa2Ev92+CjtJP6Z8pk4/S0n/pny2Ubi32k79kWXRkdVzdcy8NVf5w3BALYRCwAA2+hzn3pman1pVY2/f/W5TK1gx2RaPPFFghBfixallQQ9waY/2ISAaTU/soHEP1M+3QDaSuRvpdnX/kQn8c+Uz8Y7iU7TfXQT7ryqVGVgeHC9OrxWpiEYwPahCRjANpoqLedG525ZfjHjF7UyOXsdRnK+EitRqnQQqZnC8UTgHiX4W0/5TGxvnvh3O4ml8boiDO6TiX8lyWZfCU5ElN3sKyaXHfyACaCDvzJ1Mltr9g2OTqn6xL/V7Otsbxz61+fs3atnduIm/rWb+LfXDxKuWVok/oPfiq+tW/Mjyix4VLznhs2+4ZHEv771KZ9aUhL/cejv3M8SrxOiOz8t8R98s8EneloGxR9eK1fG+LczgG3EEwAA2+XL9z405hdUrXZd6ZTEVf5K+yqo/tfaBHlaRHu+hK8AU0p0MBVHKfGdxH9qzn7Dif9khCfhvuOQNBn8tZP4F2t7e4l/saPb5qG/JBP/dqhqTt+JMpnyaX+5DRL/2z/lM7nzuGM4vAJ1rSC67A0OVPzq0PDXPn2TAMA2YAEAYFt88RNP7C9fynsT7177rlLBkB/PFxGJ6/51mLJV2helPF90MPZHPCVa+X6QAE4PoVIS/yKJxH8QjonUFWa0V/FvJ/7F/flEuLnJZl/zwx2Z8ummtDvQ7GsOsEHgbiX+xSxCGq0fOvJ6Lzv0N9+UlpRPjNd4buhf92hCh2u2lon/5PamNT/2beAk/tNqflK3i1JlNay07w94X/911gAAOo8FAIDOe+Dep+b8pdzw9A/kvjWgfS2ifSVa+V5QRRHUzHh+EBZrpUT5IhLGZJ4WEd/zdfgy4ETi3w79RTqQ+Dc1KilxGFM+U7fboX9HEv+7fspn/bqiPvFvXyWtpTI0LFrXBgZ/51evFwDoKBYAADrss/c+Pefn8t7k+9e/M1oraqep19Nai3haifie1iKe0sEYUJHoQYEWEfHCUFW33+wrTPnceuKfKZ+bS/zbpV+bTvzbt66vpTQ8or2B9czkf/i/9gsAdA5tRgA66UMfWlhbuSDTB+8ovzLql8wLv5SYTs0w2LKiHy1Bjbe73Q4W0xKlUbOvOPGZivK15vM20OwrTXLzwRpGmSMxB9NgyqdZFSQT/E2bfc3OTUuo2F2w8WkGZ53S7CtxxVSiFkglT3OLiX8tG5/yaT2CUGZvcceFdZpi6nLEbvY1nygqUTIU7cS9tnWdAO0l/sNraz4uurWCYzP7D7+p1Gbf8LI4280lj77ZRol/e+2nPDVcKa/MHbh4TbAqIWEHoGO8bh8AgF3lvfNDf3Yuf2P15HxtOYx3o9DaCwPHYEJOVDuuVdASoIKu3zgWjwN6Ff6MiIl9zVMFpXT4OgFl7zmYJKODUKxR4r/uqYIW0Vb4qIMQ38Ti0d8qFUSw0agf80+Jotvgz+HpxL+rzF+F2+0oX4WnFoXR1imHB6O1thdO4fJJtNbmz3bqWhqO+gkassMDM38wRyLO9jCyDk5QBd+aDuJa8wVFpxNut/YQnLUOr20yQNfB7sUJo8Vc8+gEw5KYOOCOvnoJb4PwWgWfrU2kHmyPT1OcW8ucdbw9WIVKdNeFt258DaMAPb61ohOMo/y4+aQ++jeJf3PfmrsiOhIJVmvB/SxKiUxkF//6f9p3639Z2vL/NAEgRkYBQMc8ce/DhdVLsxOjNxfeNOGj8kUr5YXBk46DY9HiqyBOUlGu1NdahcU/QYeAZw1cr8vvmrJsMUlaK3W9gdd7WTn++sS/+awWNT+m6MWtv3cS/I0S/4mdN675iU8wkeBPhP512+trfupz9u7VM9ewruK/6ZTPtMR/augvznbrm9Vify9WbU/dQwmn5if8dTfgtq5GmMh3dr6pZt/0xL9spuYneSTRDVD3wxU1dOn4yP5Tpd/5dZoBAHQGCwAAnfHQJx7bV17Ke1O3F56LU7NhhBRO81TKNP5G2XTf80VEhc2+vkgY9ItZM1glN27gzpTP+vWDE+W3rvhnymd49omY2znNjk/5dK+StfZLWSeEK4uKNyRatDfwzK9dIwCwZSwAAHTAA/c+NasXc0OT7199bkBqURAThOxai8nrKz9s6g2G/4h2mn09LVr7noj4Iko8rbUO1wYpif8gWhKxguO0BL802G5CtEToL+av2kn8m/DUifDC7dE6gSmfduCeOM29OeUzal+Ruk90b85w/aBFVQeGtfZryvt91gAAtowFAICt+vwvfX06t7xanXhv6TtjftHk7D0RiSuhwzqHMKMfRPn2dgnLoMUUQ2vRnmjRnif+lhL/pkalURwm7Sf+49IUkY4k/sPPZ8pntNtWiX975/HBJ3be81M+Wyb+49M3e9ZaSgNDWg2uD2b+eGFeAGALaAIGsCUnTnxralCvTM3eXH5lTK9rCTssw+J+FcY0QV+jH6wBzHYJInQVRv9imiBFJPyz1aaplYqbep0hQhJF+XWFGSZwD1Yd5ud1eBjB57sdmVZ3qdPsK8lm3yDMi37FNJuGO4n23CrxL1ELqXWQqc2+VoCemvhX4eea6x9uNwcWteqKaTYNTzP8xfpm37C9VeI9mEhUB4duHXazxL9p9rVPM4hxw/+qrAsYhuPB9THXMKooMwemxDokcU9Tks2+4d3VOPqPby3rxjD3ibs9TvxbgXvUCy5ibpvEfWtO09zPwX0eD27SyvoGzenrcHvwi6JkWNfWBzMH/EsLC8927n/BAPYixoAC2JLR82+sH73x2m//x1l/OQi2RETFhSth8CdK+b6IVlpJMONcqWRMLJ7yta+i/KuJsq3E/zZP+YyOJPwrpnxGzzqixH+DwiHrEcQWp3y6X0SvTfkM95x4IBDeE3G51OYS/2In/u3t5j7XE+Xl48PnLtamBQC2QLX+EQBo4On7Pj8+5vmF/DXFk2F46oeJ/Gi2iQR1/1aOP8j9hrU92tNKtHiig7p/ibL+YfozClXra34kjqskEf3b9SHNKv5Tan5aVPyn1PzEcV5q6B9/bkqxvrUrra0AsW79YA5b4iiz7Yr/tGZf+xPD2Nqq7Wmr5ie+zuHO3QBdJ6+Stq5ttD2t5sc6bGcdkvhE5zStf52lLgmcdYuOonPnh0Wl7dxdVzQI3KUucG8V+idvPF23MnFP32z3lTeu1tfU2O/9ynEBgE1hAQBgkx7/uUdmq5fzAxO3rr/iBxGVrzxRopSvo5ISiRL/WjzROhgJGtbJBOUTnvK11toTk/g3ncGeFq2VFyX4JREVbbzZt40pnyJ2zO38pNgxaH2AzpRPd23gnn59zt4K8eseSjixrzY3hvN11CX47XXgNk75TEv8p+Xs3SNpkfhP30l0nZV7P9cGBrQW3xv4d798pQDAxrEAALAZD//8o3OV5VVv+vbit5Uo7SutxIvG9psQX2ultRblaRFlNQSHZdOiRCs/3KUXhn1afOWJaC2eiPjas1KzVtzWJ1M+zZ4TiX87VBXnZ5qtHxok+BttTw393VogN/RsL/HfKPRXTPlsI/FfP+UzJfFvPlGb009s93VlaFjVfBH1B792lQDABrEAALBhD3/q8alyNjcwdUf+uUGpaV9EPFEi2gvCfRHxfaVFtHhi4ndfPAkCnWDaj/K01sEiwRPlB422IiLKl3CdIEEtkCSjoo0m/sX9+US42QtTPq3DZspnd6Z8tkj8b+eUz5SFpUn8a3EOMroaWsRXA+JpPaD/3cJxAYCNYAEAYGMe/r+fmshn11TmttXvjtVKWokK6/XNtJwgr68lqAVSYYhmh/ieFq3N4wLlq/BxgQnywkcEWgXBop8e4YlYtUCNQijzY20l/u2eVNla4t8KvlMDd6Z8pif+7Z3HB5/Y+W6c8umcplk/1G+3T81Xyh/U2vd8b+g/LhwRAGgbCwAAG/DZ//3pOT9XHpu8/tJLM9WsKeMRiSJ4PyjpMWn7YOxPMBJRS1jQH2Uxg7ZgHU1I1BI8FtCeFgm6BSScktkg8W+Hic0S/9oNHLeQ+HdD//gTU6L/1ol/J6zvROLfLihqGLjH8a4b+ruJf3EPpnHiX9ddpfTEvx36O4e9tWbf8BvcbOI/sT1YrboLIWft1zLxb4f+0Z7tNV5azY8Sq6ld1a8rksvC8DRrWmrDI1W/UvT8b/AcAEDbeA8AgHZ9+MPPlHPrS97UVYuvztSyUfQjEqeTfRUFfKKt8C4KaLSIH1b+iBOgB78YTQpScUiqg4WEmAn38XbzH6Ws6F9pUcGLBiTerkTiifLxwWgVj+EP/hklrZPRv8RTeqztWsKBntHxiAqGIAWLHzPEPfj0YPKpNieo7Bn8ktyDqMSe49NPjf61dtsJzElpHR6ntd4IejN0YmViov/4PQBiH4mYAwhPJ/wIcU5TRMVrA2W+ApUY8C/x7+rwmtsHY/7WPc0o/+1uD79B8yYHc/2Vuf4SvMogvjHCP5tTNgtRc2oSnY71DYYhfhjlO6N+Gkb/5jq7t1Z8P8fbzfokOFD79RH2TRvdGBLd+Up5A+Vy0fOX/QlZiP/nCADNsQAA0K5bMsvPLc/ckD91sHrJyqGqsGgnDKrCH44CGlFmsHr4zyC4V+G7nIL4TOLOYBMhBUGhmZdfn/ivq/iPAkeJYt8g3tZWuBlGtyLBmkNZQaoJ7sMA14prozA3jn3jg4zfwBWvW4KMr3IPRqe+3kuiQNxNXUvDUT/ailCjQFxbsW+8PQw5gxMMw/qwFTuOicO9mRbteA9OgF6X+NdW7BtuCU7WWW/oaC0Uxb7uYiw8NRWtHEx0Lu5pSvL1XuE9Y7Zrsd9fFt118TWMAnR7vRGvH8L7yqrY0dGpJRL/7pvjrCMJ1hfRq9Mk+XovZb/eK9oeLqu0e2tF97O1fhbzgMd5GOJ50+Wh5719N/q5Tf4PG8Deo1r/CACIfPUT/6q4Xp0ekWtLbzpRiPaiHH805CfMtgZZWC9Me2sloqNOAKVMs28YVOkwvPZFm+A+jJZ8LwiPRKxHCmKF/tHBtDHl02T3Vf1PSqLQwiT+3di3bruz8z095VOL/b1YtT1S94la7CORHpry2V7NT/JI3MT/RguHVP39bN3nds2P808VX1tfq8tqZJ+u/odfpRkAQGssAAC09tTPPzRdXVzzMjeVvm+yv0pUUPEfRO1B7leJp3xfiQ7T/KLFV0Hhixn/r5U27/HVJsQ3dSbhPpS1Tgj/qe2QNBn8mcoQd3vjZl83+ldbafY1ew5rQeoDd6Z8MuUz8Yl2iC+tQ39nieveGFqsH9Yy4IvWSv3hr7AGANACCwAALTz2iydmq0t5b+rW4vMSBS4mQA/LWiTO2eugPMLztNaila+U0uJrEfG0SDgYNGzwDV/4JSK+KcZQpgk46BiWsGzD6h5OiYqceC4RbvbClE83pc2Uz/rQv+7RhA7XbFtP/DsXZGuJfzv0N5++LVM+4503Sfwn/hcRvkBDlPL+0y8fEgBojAUAgGYe+sVH5qrZtcHZ2wvfDsZ2+kqUHwQunq/DogqtVPA2AC2ixPNFBy/2EqW0L34YGwXvBPC0hIVDwQvCgujNjwqKggmhIiKeaK3tpUJKHCbtJ/7j0hSRLSb+reA7NXBnymd64t/eeXzwiZ23SPzvlSmfqUsCHa6wzCfWr4fVgBatvYE/WjggANAACwAADT3wycdm9XJucOqOwvPDqhaW60TRmIiY+hw/yNArL8iIhnnNoEAomoIS1IrosGMy/LNIkPgX3zxSUFFwEzYG+GL6Jt2oKBn6W9vj+GyjiX839I8/MSX6bzfxH4b1e2PKp2ws8V93mta/lZycvTSM/ttJ/NulX1tM/Nuhf7Rne42XVvOjZFNTPttK/EfXNtiutR4c0uLLgPrjf3FQACANCwAA6b7wvz41VVnKysQd5efHpBzOr5RoxqIJaKLAPQq+zQu/4veCifaVCnqCzZZo5SBBHZHSSnvBD4SFQ6KtBUCwZ/PP5s2+IiaKsoMwKygUe4d1Cf62Ev/pOfsGif8NNfuao9xK4t9u9nVOs3nhUFriP3GaJlS1jtD6RCvybpj4d76mlAR/o+0tQn/nxmiY+HdOp8GcH/uKafcqNU/8N1w/mG/KvlU2kPiPQ//kns2ROMcmWms9PKBrUhPv/1vYLwBQhwUAgBQnfukr4+vLKzJ9W+H5Cb0axuiitMlPBjU/cSgvJgGslPjiBy2/Tkm3ebNv+Epg0UHo74tWntKixRMVzVQJph+GvQEqeL2AjtcYYueD3Q9qkfhPqflJSfzboX+057ScvbUrre0gLHX9EO8kNcQ3e2yn2df+RCfx337Nj5uGb53419a1jban1fxYh735xH9iSeCsW3QUnScT/Ck7d9cVbQfurUL/9hP/JnC3tkdftbOwlK0k/sU5fdGqMjCgxFMy+CcL0wIALhYAAJI+96nHZ1WhPDp7bfb5mVpOwiGWntZaiefrMCoypT7hdhM/BSG+SNAJEDTyhiU9nkTBfbgHT7RoL/wZUaaUKPwZL8zImgcCbUz5FLFjbucnxY5BN5X4b1bzE+xTnNBzl035DMWJ//aafcNf1+7XUZfgd7Lj2zfls2HiPy1nH33iphL/0XXe+pRPd2xReuI/ud3ztAwPlUtjxdLv3n+FAICFBQAAxzMLz5TWLl+qDd9Sfn1fdTEI6EUkDOtNzY+YVt0wJlJesCQQCYJ1rcXTSrTvKS3ihQsGid755QevUvJU0BwczAkV0SbN74cl7J5o0drTSkR7YgeFjZt920v8x+uHlqF/+MNpxfpM+WTKZ+IT7RBfWof+0QOB6FlH88R/653E27VMrpbWxiaKwzPfWOBf9wBig90+AAA9ZGFhYbV8ZnLi2HWXXthXWwxijiDYCV7aFSVEgxIUq+4//EEd5KzNIwIlboASFA5pEWUixzB8UuKLVirsJVBBLB9X/4sVz4UVR+bQTHgq8ftf7dBfBUFbckkQrRO2a8qniuMw1Xj90GRJ4GZ2TUjqhoMS1nyba5iyfmgv+o8abcV5gbEyuft4e7DnsOJfzLt7W9b81D2a0OGarWXiXye2u4l/bS5hnB2Pv1lrSZaWsxeJG9bjADq8ztF3p82dVj/lU29myme7iX8RrXRqQZEW58az67XskjARrWRlcrTszVy+pRz04AsAiAgLAAC2/YWB0+O525deOVI7FwQxnogO0vZ++CRAB0F2GNoo+f/Ze9dmy67rOmzMdW53o99A40mKEig7lkTxAUK0GFUqH5JUpRJXpSqf6J9Ap1IplR58gpTUIilSBEWRgkyJFEU9LCdx0S5/zBfHikpOrFIkoBvgQw9HtiWLBEgQRKMbjUaj+6yRD/Ox1trnnHvPvbeBvo85qtm8WGfvtdfae5/bY4415lxOAWsjtLa9lxSxnwElbLUC0Ho+Er4IPZji24FBKXRxLXlUvheEf25e5XMJP6PGD20A2q7EsYsrbDqtAFFHQ1XcVXLf8zO70CjNLs8YXsH+R4F/sb33/Kwj/HMaPzTq7/ffbvRwY42ec+h2E+Gffm/7zpvwv1As37ioTNttTUV6Zd2Ff4/9NG6xJ7Xg+bEny+7JTuOKW1Llc+x5FP7ZvxitfUGzl576+5KOTlXaiXEPx/iBffskgIwQS3AE3/3qu8793T+49ldIJBIJQ+oBiUTC8M9+/FHOrsxuHv87N/+DNVFGs76AZgQCINU/NS8QgaJJvSSKWoAodmJF1aKfUuDiKNXVYxnDBUB1ogcPLcIRhC4JuPGzVcm+S6TZxvOyymdW+Zy0L6X+0XMf4y3z/HSxXyf898L8+GLsKtlX+mEvFf4X2gXy3Bs37vzr+b/+ubuQSCQSGQAkEgnF//oTnzozv3xVTv9nN/8yqByN0Hv5TiGou4EVrQQEETXr0836epY4rQniTtK39xKhBQl2vG71ZanDwtB7xbcR0EjAq4tqH8gqn7IwzVXGoUXqv9AeNy1u43Bjs8rn6vjBn1T/qmwu/K+g/tOefSTD2LC6E2tdXCIDxL5lIr//c3cikUgcemQAkEgk8Ds/+ct3zi9dLad/8MZfqIEBptALrDy/pfCqxt/rlGrTrywArM5PbBbm5YBoZXJCHxWw395LKkGA1MjBNgAGWFGgSwqwaCGrfK6b7NsIonU+JdCTu8Tu3kb7Ms9PN+ydC/+TkGCIWxi0dSrwL+l8jCvWJu5bUf/1hX8n7l17POohsMTuhP9++lh4z5cK//GKmhlMiubt/MH5jAESicOODAASicOO3/2pXz09f/5yOfWW61/VYj7SEXelEbp9r+7da1X5USorxLbrUrqvf7TKJ9QaxFhAoH/qAYDYwYAuI6CwBE2xCETHgFJ78jql/oPw3zukgW0J/5t5frRPDNTzgFX55CBgdxR/c8+Pnc7xcSwI/EPnr16Vz21p9i1Y3YnwH/f59lT5bCPhQrjS7nmwfz29okAAkT/42dwcIJE41MgAIJE41PjiTz921/yFq+XON738VEFP6E3Cd+pgTh6xrAASQgGrbe+lFh1x6qMLAqrxBxlVmlLhvn8tJGprC4LJagNAzwEgIX48pux/lfDfBNGs8mmMnNiN8N/HD+jYaht8176G5wd+axe0+WlkYiPpHkpPlzFpnxL3gS5zvEsLwv++qvLZgp9Nhf9++gQghZW18t98JPMBEonDiwwAEonDi9/6qcdO1xcuzc4+dP0rxQhpuH3CkQ9Rmg41+VhswJat6zv4WrKvkEK378O39xIafa/SbEIVXi/IjtcCoNoDzCYkAhIsFdC9Agbqv0QQFSe6t0D4bxHCFsL/8vhhk5BgVHZH4h6HbWIo8vjhlgj/PfVfU/gfqf/C0gRN+R4o8o6E/wiTImLZsfDfU3+/+kJ5osa2F+OHoZPlVT6HF2OHnp8hquyf0dqen7i3i+8zgHklSoHM/s3PnUIikTiUyAAgkTik+OJPPXZnvXylnPnhV76yAZP0K9AoBWH7cIXurn4egDWKAkVuQPP20N078ORgsFBoyQDWf6kVEJBFCJZCciwK5AxJo4sqtUTOAHArhH9jlsu8E8uTfUc+N1D/dqEthf9tJPveEuHfl1+GkTh9n7L/zYX/vvM2+Enn20/23UL4X0L9+/ZXq8qntndT8Ol4/LBDzV47WFLlczF+WNLe7u34PrdpLhP++wmKyJwACoRS8IcfPo1EInH4kAFAInEY8cWf/vyZ+XOXy+m3vvL1I7gZ/IwM7VZYTfUnREL496JAWoidBCiwKp8FAnft6yqBQH1E9KrtnhKgzn50cYJdTgCWSkiRSoouAmgPJQoBrRb+R+qPoFBL2P/Wwv9A6w9HlU+9t8Owd5fsa8R9p8L/pJ2hfO9U+O+pf/Tcx3jLPD+CvV3lM17yBepvHS28XagUmaFCMJP/+4MnkUgkDhkyAEgkDh0+/77P33nz0hW58y3XLxzBTadohUKl5prsq3K7klCz5lcBhGJ5AhBWiFTQFwoiJNBjqsUJuixAWx+Q5jIyZg8AxdKOAT+mggVELX3njYMusp+p8j22d+RvlWafVT7j05XCf98+3qVtC/899R8it7WE/6zyGasKxHrC/yQmJARHROaYAX/w4YwBEonDhQwAEonDhS+979dOzl+4NLvrbS8/eZSvOFk3Jw8B1KDs2qJJvablA1GbHxCgClWhR+Mx4eRxshJZxQjhv/peAazSHaOFhrSdkCgKBKBUUFgWBM4lwn9P/bGZZt915XWHsspnN+ydC/+TkGAgoAzaOhX4l3Q+xhVrE/etqP/6wr8T9649HvUQWO5S+O+nPwRgOxH+OQROKzxsBChyRHCDcrPM/vhDx5BIJA4NMgBIJA4RPveTXziH5186cuaHrj11B24YZ/K8WxFRI36r2S9iHB3wfADXDmnEqKvmCUa6sJEPp1+WHqBhQ2nunSb8iwcPet1S6QFACy08LMESgp5VPsfYYJy+hwRtgh3FX1iUGLivnc7u3g53wznu4HTqBP61PT9NEQcG/tpPJ6t89p3vSPifxBWVmM82BJSZ/NEHMgZIJA4LMgBIJA4Lfv0nvngGz1+Ssw/dfOq4XAuVzX7WAAAgAElEQVSzvnNrmB1fzf1G8d0d1LO95u1RzqRitrt3YGsCcO5O3x2MnjcMq/PThH+VSCuEVSzqMK4jFRDvllZyFOgE0azyaYyc2I3w38cPbWqbCP9beH7gt3ZBm59GJnB6uhg/jJ1nlc9++msI/zHNZW6i1l4pOFpwc17q/P/52cwJTiQOBTIASCQOBX79PV88O3/+Bd71Vl64gy9DNMW2KAmrllwbXERpt0n1CFuOxwlWIMi1RvYav1gkACC28eriB4Bi6wZO/fUqvvVY7CpgDK/SKwtJRCNEsJzdCf8tQthC+F8eP2wSEozi60jc47BNDEUeP2SVzwXivrVmj16bXxGZLIsfhk72a5XPgf1PvxGt87GdIrN6o3IGlj86fwcSicRBRwYAicTBxxfe84XTfOEFueutNy4cx8uVhBf1dwlfBm5Et+9bsm+n5RNEEVGjP3WvAGj90NHb08w/BEsB6X4M3w2A0FqElYUVLCKt8H+prCJmKNJ4Q0OCMAtllc++fTISp+9T9r+58N933gY/6Xz7yb5bCP9LqH/fnlU+pwL/Djw/Xc/LPWz6nsscLCiCf/szGQMkEgccGQAkEgccX3zvF0/V5y/L2R+ef+UEX6pKosW34MVQpcdZOySq7tC394L9EduuS+t+sq8XFBWEogBohVB3A6gwN7UuLJRCErTFgUqRIrEFmNguARZ1mNeIoHgFUowUagn731r4H2h9Vvnc0vPToovWbsQdK9n/5sL/pJ2hfO9U+O+pf/Tcx3gLY4vYDxPhf0qgdy38t+glhr1N4X/9Kp9rCv9+n60HCGaVN4la8ae5DpBIHGhkAJBIHGT82nt+4y5eerHc9YM3LpzANXXylHDsAEQB2Nv0jcSE8N8VBTLhlFKNkffZAqgQYSsSyo6rWVqwnwhNM6jK6b1kkMQASnQOsydZ+aAqsEJAmwv/yzX7rPIZn64U/vv28S5tW/jvqX8XmQBrCf9Z5TNWFYidCv899V8ayrJr16OqgDcqCgTyJz+bOcGJxIFFBgCJxIHFb73/N07Mn/8u7nrb/MnjfInKU1pBnkKhu3os5RegV/kUiLCCvr0XPDaog5OnI3x2TIGm8yrVqLY4gHCDKB+iELrxsMYehUJhqQSk0OINXYIgUQgISxVYtrFTf0yJe0900BFEDiRsWfzQOllK8b3HVWb9Bc2eAwPrvD3LJFhZsOUMMvzWwj+d+27l+emGvXPhfxISDASUQVunAv+Szse4Ym3ivhX1X1/4d+LetcejHgLLCHJ2Jvz3019K0KeB2WbCP4fAaVjHGJ/jesJ/e7VsmsQcBAg8njFAInFAkQFAInEw8Zsf+PyZ+aUXy7kfeOXx47heCUHU8RQjEO66AYD2KSNCQJfUKwBFqDv+Ar75FwiQRQC4Wb8SAGIHX6hxyHtmFYgo0a9w7gUBNJdA4xCp6kqiCKTq6W0z4KzyOU7fQ4I2wY7iLyxKDNzXTm/3E0R/N5zjDk6nTuBf2/PTFHH9OfhrP52s8tl3fiuE/0mIu0r47z1stnJVK8sMMnviQ8kTEokDiPxiJxIHEL/xk79ytrx45cjdb3rl4jFeU3KvDNuUdf9Zif4ompLVduBCkBh4Oq9nAsDpnbJzRKVOMHKICbfsS19mtFRotzYApfgaLfhyAarxKrEiRdoboPHDKM0OhIYLhKaJr1sZh9qJOxL+J16gkXquJ/yv9vyA2I3w38cPbWqbCP9beH7gt3ZBm59GJnB6uhg/jJ1nlc9++msI/zHNZW6ixbhljFrHt6uPK+wUITkjyCIXP5hUIZE4aMhvdSJx0PBb733s1PzSJZ59C75+VK6D8E2+oDU0bW/dKhAxShGOHRqR0u29PAAw6g8v3l+93VlUhASonhOscn7xnoO4m/NHK5CKsAoiAECw/FBnNUvYQhTfNQwD+csqn9G+tvA/Uv9Rs/cAycTpJcR928m+t0T476m/Xz2rfC6++cs9Pxjf8/HJTl9Rmz5RSxGiAI8/kmwhkThQyK90InGg8Nvv/+zpevky7nzT/KmjuGmUy3Jt+2RfY//V2WKU7ontvQBTVt2R7/YbCwkExm6sQn9kAlhqL6FVPklrIYP0aPJBiUiAXkJUhX9CCswmRLTk4CFy0Akv805klc+s8qnt3RR8Oh4/7FCz389VPpdR//EVilW17n0uQCVIXPxwEoZE4uAgv8+JxMHBb733M2d4+crs7A/f/OoGb2olH5jxBs7a9V96JdYwf041lV2LAsElf7PfqHtHhvRf/VQpToWw2jFgqYRY4f/SrqUyvxnyBZYJILB6o4UkfekAaLuPAag1LEBiqxlrCP8Drc8qn1t6flp00dqNuGMl+99c+J+0M5TvnQr/PfWPnvsYb2FsEfthIvxPCfSuhf8WvcSwtyn8v+pVPmOymwj/k1BWD9Nve8ET6QVKJA4K8sucSBwQfOm9nznLFy7L2TfPv7YhN7Q8f8fGpBXZhKrscKLvhYBM4ydFUC1UqGiZAErQxRcQlH5V0hJ/WWL1QLTKJ5oXCJoWTGqZID2YtvWvHVwBy1Quuk0B9ELdRsVLFF8EDc0qn4v8cnlc4XPdhfDfU/8uMgHWEv6zyqfHfrsQ/nvqvzSUZde+NfWHLQgMA/ZhS4FuIXIxc4ITiQOB/CYnEgcBv/v+Xzo1v3xJ7npL/coG5k6XlcMFtTIlHkBVwmEsX5pG694GmG9HRXfAjwlvD9XbU03Rp/F+dRw5WaewiMUGIFBIipUJ0mhB635KJYSlArZDmQgrfHFASEGJnmFGJqAjiBxI2DKhFAiWAyxSfO9xlVl/QbPnwMA6b88yCVYWbDmDDL+18E/nvlt5frphDwR9csXNhf9JSDAQUAZtnQr8Szof44q1iftW1H994d+Je9cej7o9jsNV5XN6l7BU+J/Af4dABBcyHyCR2P/Ir3Eise/xu+999DQuXyl3vunGV2emHRdV7cKaDwgoVYTqTVE7kBcFgu34W1C1fKezNwh8Ky4Jcz8AWpF+NwVJkJtW+N+9/l7rswsz9Oqj8D+sKkT8oFsBoFRQVx68EugglALOwHYm/HfUfwmF6k+fULEVwn8fP2BCoBG8dqU2P8rMzfPTJthR/IVFiYH72umNIILo74Zz3EEebtx3fc9PU8T15+Cv/XSyymff+a0Q/ich7k6F/9a+GXQqBAQXMwZIJPY58jucSOxv/N4HPnlqfvkyzr4JX5/Vqsm+6Lb3UgpECoiqTL5tzgWtC2Ql/OEWIDf8OIkXOKEHQHX8i2/g5fSxooh1CE/57VcPBAhC3+0SQKmA7f7rF60iMOEfoK4huJtIohhRVvmcrCpMCTQ2Ef638PzAb+2CNj+NTOD0dDF+GDvPKp/99NcQ/mOay9xEi3HLGLWOb1cfV/SD3FL4n0LDbeY6QCKx75Ff4ERiH+N/f9/HT+LKC+XOH7rx9SI9fxL49l70f7OrM364t0eZAkVUiW9MhWTP2t1/L8bpJQr5G/nrswI8ZqhKYqqdLtYPoipRJaTrHJBaYasWUkgISpXKqoxf9yOLzYCnyb7AJsJ/E0S3pv4wCpVVPtcR/iNMiohlx8J/T/396lnlc3gllgr/wzS3IfxzMVRbB7qAmOsAicR+R357E4n9in/x3o8cx9XLcvYH+GdBWWLHrkj2BcECEqy6g2/QejSKTyvlicYRlaLZpr8kNXKoMAGeGkuIpQYCBZoxjKnwT0R6se4AYMQltvfCkOxbCA8DAFQlKKIFhai5B7UATnp6fjZleE6J0MvGmwv/20j2vSXCv9HBCT+ziUzZ/+bCf995G/yk8+0n+24h/C+h/n17VvmcCvx7rcondoBYBwAuZE5wIrE/kV/dRGL/4fz58/ffmN89v17mp/6O/Dv1ygMC2z9L4HYdI+vVfP/VG6FkmvCE2kb6db/ePmOYKErENSQggVJIWgl/1YOtbk+pys9c+EdbEwAgFSJq6SmWcCwh/EMNRSIiFZoeANGYAcU3Cbac4Kzy2V2xKeXoyWiMakJeu3Yj7ljJ/jcX/iftDOV7p8J/T/2j5z7GWxhbxH6YCP9TAr1r4b9FLzHsbQr/e7PK585BXCFeJJ6ZA+eTSyQS+wz5pU0k9hk+9z9/bnbyu8+cnD907ZUH+TcAml3Ht/dyKh87+E5YXUG1s4yjm4nby/arcChtNwCl3e7gFwiqVhASEV0W0IM9oogqn3rp6iV9wFJb5zqw0u3vW3S0tc821gETVgxUuhyAldQ/q3yO09y+8N9T/y4yAVYK/8N0JmnHWeVzT1f53AUuvILvP4FzZ/H4P0o6kUjsJ+Q3NpHYT/jCT3/heH3hyvWTbzz9H16Hp5W+s4oY25be5G20G4hvOrsCnYBZ7ZVDxL4BUQmUEDZtXjDU4lRRX6Qo7/f9gwk2Kg+LJdTubyGBVNpI1EGk+wSrYalqTrAAbZwwu5EXCa2t86zymVU+jbh37fGou0WVXQv//fSXEvRpYLaZ8M8hcBrWMcbnuJ7w314tneaOqnzuBuVuyEs4QvzRTyWjSCT2DfLrmkjsG/zmx/7xiZdevHL9rgeP/Pm9/JZ4lU9xww/pfh76trvw2vz6b785c0ybr0oddN3AMwcqnFt4KaGKdokQ/i2KsDr97OIKU/cFo2bfPDzKitzV49WBUKX6McLiqwr0GkReXAie2LC+8N9R/yUUqj99QsVWCP99/IAJgUbw2pXa/CgzN89PXLGn+AuLEgP3tdMbQQTR3w3nuIM83Ljv+p6fpojrz8FfJ9MZR5JVPvdTlc+dQgTHjuHGDZB4/ANJKhKJ/YH8riYS+wO//sivny3Pv3THme+/8ud3yfMgKQVV82iV+hPKqt3/A0rkgxoJaAQ96Je5dBirB9AqnyLoy/wjNgw215A5iIyZ+bpBZAXYAXCWzzYMadGFFLhPySMWjWEKRVgBCgvgOwBUwlIIpPT6rlIiYJGHrWhfSv1HL9BIPdcT/ld7fkDsRvjv44c2tU2E/y08P3Z8VvmcOmq26mR4PeyjHQr/Mc1lbqLFuGWMWieOsi6u6Af5qgr/ExStNFBw4f3JKxKJfYD8oiYS+wCfe//nzsqlK+XcD9Unz8plc883Iu7W/GbWVx1d/+3XFN7O/6OiIN0dxLYtQBhvAKlOYjhW+dREXmUb7jIi4OYcEhQt4xPxgNX+t6UGiyIswde3HK4RNohbiQhBqUKg+JoGadsDd4WA0ATRrak/jEJllc91hP/hhqwS/rPKZz9CfzMwfLRU+N92sm//LLonO31FseAFeg0gAGfATZSKx38mqUUisdeR39JEYq/jix969FS9+t1631vkiTO4ZoI6RYQuu06Ff90J2NR99+qEKUjJGbpMACPWLYUXBFqBIEZ9zwJAWb6gVHhQIVFBSGMD71zr+Xj8UM2tBKDFG37dWFiwTAAWXXAoFJJWh5QAWSiAjWcQRHtWtEL430ay7y0R/o0OTviZUdIp+99c+O87b4OfdL79ZN8thP8lnp++Pat8TgX+21vl0wb/Ggr/PUjMKlggs/QCJRJ7HfkVTST2NH77A586JZculbNv5tfuqK/4v+gFFCWiRuPo+2c1lbh0rh6NB7qiQOG08TjB6D6FhJRCVraiQIh9uABCCqsm/gqsnD+c21kAoL7/SqCrF6RrDiJSSS8hWqpyKVs0oCX7olSxKIICVgIFZhMSFjFStR3hf7k0OyHuje+O1L+xzNZJY5ZL2f+iwL9a+O+p/zDs3SX7IqxfuxD+o52hfO9U+O+pf/Tca/DLPD8miE+E/ymB3rXw36KXGPY2hf+DVuVzZyDKDKwA8URuEZBI7GHk9zOR2Lv4J4985DSvXuI9PyxPHZGbUNO8ESghwKo2ejf3B6OqEiZ752T0uvtuzhHjam7Raao8RP8Jl2pU26p8glHus9uuS5XytjgAzSQmwSooUvv6pLAqn1FcSM39QlR6DwDFoxeiAoB6fjyuEPENwpZJs4vsP6t8bkr9u8gEWCn8D9NZkezb3zGOd2lz4X9l/OBPyu/eNoX/Rv2nPftIhrFhdSfWOiHcuxH+e+q/NJRl17419QdejSqfO4MQ+qW/+MHkGInEHkV+OROJPYp/9qHzJ3nleZz9YfzZTHV6I+uAeWyohfONxIgV2xGAkWLbKL6V09F6PvQ4gebyL3AK2NYNWm6AUCC9y8j2FNNLlwoWL/yvRX7M0sOoCKQWIICi+wrbqoKtPKjwrwWL2kUre5InbgHSMXT7l23m+Vml2XNgYJ23Zy3PTyOI1vmUQE+Efzr33crz0w1758L/JCQYCCiDtk4F/iWdj3HF2sR9K+q/vvDvxL1rj0fdHkdW+bz9wv8C6PsO5jpAIrE3kd/MRGLP4ctf/vLsmW8ee/G5F6/OfhB/rqX03bhstNs4sXv6zZBTRay4vplnzAik5JjScTULA1q2rh8DSG1Cox0mZulRIuKufV83UD4FkapjYxxTCIhmCTeTkkUjLIWkVPP0N+OQCf/SVjzMDlRIus2pYBn1X0KhMLD/gYqtEP77+AETAo3gtSu1+VFmbp6fuGJP8RcWJQbua6c3ggiim44L/KM83An8a3t+miKuPwd/nUxnHElW+TwMVT53CEKAGTGruKPiD87vseElEoce+Z1MJPYWPnX+U687haPf9+CxJ//0+/AfYUVvjA0LQLfUkyQLBHBtHhBhMYZEYQGrb7PlmjcRwr/vABCLCcH40XEyaMKxbuClpX5C+Ic4Eddzq/5tUYpAB6wbhOluvhYY6MHKfWyCE+GfFKFUrUYKgG7+iUyAbQr/Ey/QSD3XE/5Xe35A7Eb47+MHYCR/S4X/LTw/dnxW+Zw6arbqZHg9sCvhP6a5zE20GLeMUevEUdbFFf0g96DwPwVx9gZeEsyJxzMGSCT2EvILmUjsIXzpw5/ckKvfnp1+2yt/fd/s28p6KWqqUTLtzn5COQShVT5Ft/RyTg9WNdPbbr6aqNuouVp0IBVu1xVN5zUWbrytSgsJCJh7p50OL/UDdfZb3c8Q/j04CXJvn1awMPxI0jn7UQhopVGPc+Dxg4UWVQnighciQoJRfB2Jexy2QlXt44dDUuVzC+E/q3z2I/Q3A8NHS4X/bST7Tl7F8clOX9FFL9CeBlFuoM6AGS48sudHm0gcGuS3MZHYK/ji+U+dmV96kWfeyL86J88bF68uddsPfRaskt2iJnvnEwIIq4v96LIC6uCfUaZl5KwVBYLV8rdFgEICRVzFN4uOBRs2HvPlW1F/aJyAdkwQdwjAygJS1AsU7a766+bBEKvzY9ctQlo6spmClMmtFviXtvfU/5YI/0YHJ/zMKOmU/W8u/Pedt8FPOt9+su8Wwv8S6t+3Z5XPqcB/mKt87hjUoIxAxcXcIiCR2BvIr2IisSfwhUcevXN26fLsrh+6+dVT8hKdzhBFSb9TBOn89wgZvlM3g6wXBAWsYtSnK+ljFT+ltI11w+JfATXedHkCyuZF2bwIfAC1AhB64oEUS/aFLx1oZU+4kydYsjJ+jTeIAkG1/Q0s2RdEVeFf4OxfMClPNAqlU2l2Qtwb3x2pf2OZrZPGLJey/0WBf7Xw31N/9ORvd8m+9nR2KvxP2pvyvVPhv6f+0XOvwS/z/JggPhH+pwR618J/i15i2NsU/rPK525AAHNAICXXARKJPYH8HiYStx+/8zMfOcUXn6v3vG3jwh24EYVxnLgojbZy+5b/alV3jGMSqr4L3Iiv0rsRccvHJbTcPqCF/OE02kz8rRio9uoCvK8kQDTZwCIBXROo7lNChCXu3tHO1bFDX8HQXcmgwn+FLkpU38kYEEZIAFTdA7hAQyBY0nPbDHi7wn9W+VxD+M8qnx777UL476n/pOethP/xKbcnS0wGvK9g6wAAgIsZAyQStxv5JUwkbjP+t0ceOVleel7OvQVfm5W5kR4Ba3HNU6yFwmosHIBv3QXjzcbyQRSQlCLVFhCM05vCWSxCMMc/QN8TgIAuCGi0EKsNEPGC/ZaOHFf0IkIQ6vBYRGwLMCsWZMI/BUWtQaUKwTi9FSwSWiRQPXhwuk9WiOcSePBTVmv2HBhY5+1Zy/MzyvBbC/907ruV5wcDr80qn0bcu3b43+1xZJXP/Sv8L0JvrAgu5BYBicRtRX4DE4nbhvPvPv/Aqet3HXlpPjv5po2/BARSXYA38V5JA52yh1kfSk20nqaIMLbUhbqAiohza3H+jToHUEy/h5J7IKT9lgSsnRAtKwC6vZc7f5opCGFEcX8RdDClVHJIXSgaSBSihsAfbn6yCFmt4Gn7gyo0PiewRIJSBaiuIk/p8hbCf+/AwYRAI3jtSm1+lJmb5yeu2FP8hUWJgfva6Y0gguim4wL/KA93Av/anp+miOvPwV/76WxLs48rTth/VvlEd2876j9Mc3vCf2s/ACAhBdiAbEBO4PF/dEDmlUjsO+R3L5G4Pfjl85848dLlZy4de/iByw+WvzbObYRGICIVbs4RVhU6SxhyAFHuSE+fbQypRnFPd9GARGGloFRCE3DRVfmEWPZtBTw2KASFXkrIrUSxGxeayQcm4dsYVKTvvEPiJ+oxVVcSAEszsElJMyPpIoAm+1qgImYH8qwAWNyCgV43TjxSz/WE/9WeHxC7Ef77+AEYyd9S4X8Lz0/IqAva/DQygdPTxfhh7DyrfPbTX0P4j2kucxOtXBBYKvz3cUU/yIMk/E8ggNyN+gL4Ei6eP2izSyT2BfKLl0jcBjx2/tGzuPQcTr+1/vt7y3MweucBgNX0hDPd0shEuO1rsa+v75yl7Fla4U44ty5GXKqKbxYtiFhycAj/dKqoPcAHEx4e3Q1ATxHxsamTp0ULvhlwdIsCmwWpnv6OpWkmAEp4gTyK0CRgDzMAdCFB+KAWiHuwpRWqqhNEPeQWCP899V9T+B+p/6jZu2yMWyH8Dzdkd8J/T/396lnlc3gllgr/PfXvn0X3ZKevKBa8QAcVfAWcgcBTWRookXjNkd+6ROK1xhfPf/wUXngWdz+Mr5yWF43WN8MPYT4fITHo4lZgRQir7g+wRjkgSkVRxhGKvrUHMYKgX0bwkj6ks0MtDWS5BE3q9nyDnnz7fxrF17Rd1ipuBLJ9u/qMhUqfmpPXShG3AIGopYDKPmWyGTAb+x83A84qn6uE/yWen749q3xOBf6s8vmaQjC/CSmQgouZEpBIvLbIr1wi8Zri937uZ07ixefk3rfJhTtwk+GrMeoUVMxpt+UEG/3V2ADNZkNz2FdlDMUDCRCaMVy0KKf7/qlVPru9urQreiqwFv4v0I29BJZ2jBYbVCGq1fvXjGHlMcrpNVuAgG8bXISovTVIVNpHbxkCpHqMocI/RCqLWEhADgeX8A6h59aN747Uv7FMvXkjs1zK/hcF/tXCf0/90ZO/3SX7GnHfnfAf7U353qnw31P/6LnX4Jd5fkwQnwj/UwK9a+G/RS8x7G0K/1nl83bBihMQFz90iGadSNx25PctkXiNcP78+fvwyjm8dIOn3yxfLeqaMddHAYQCq63Z2FVB7ABgP9i2XxWAa/DKy6Gkn4XCKCFKgCzq2AF0s15dBBAndqUSAqkUkVblE112gXRm/YhMWrQgKu0b7daFCIhel5ACah6CRTVVdEsycddTVx6UMOFfVwzYdgIGbAsw7aqq2gpfBEDPjLPK56LwP0xnknacVT6zyuftBYkXiReJZ+bA+UM3/UTitqDc7gEkEocCj57/3H2o38bRDWy8bfbUbEaXBoMEmIhI0gmr/kNIjrQGgkrSDgasE2MPcE5SNR6AQJSiuynf6QVFCFRl7aHQi13SPELmODLjSluO8CspW9JhaztFVHRuLZ2Lg0DYJGIY2rOyJe+5T0sQSEERm06R6j4enY6I7xxMQGDhhNqKOneTdWiLFRFoLRB0Bhnu6DKE/iDo03RLUj9Niavb1CTuobSoQLyeqY8Tk/YWF4HwCcKzNSwQsE+DBOstpHQTnAj5gN+lpcRd75jFn/1IoM9U0MI2v5/6ZDV0nLTrdOD54j4wdPdfXB3nZuyfngseU9Npdj1Ez2i32l8Pe9G6RxOD8YT7eBA2fdqAbWot9uueYyf8dwPznwkO77PHbEvZv33n/aKHDyI4XfDMHA8ewds+xa1PSCQSu8Zh/F2TSLzG+NWPfPwUrz3LBx7Ckw/MnkFfmrMZpt36AtqCABC6ONzbE7GBseHIClBWR1EnjxfPKUqfjVCaU1+gqb0VCCOQV94E4FV6PKqQtm8AgwDRmUr1tN2gQVZ6SKxsf/A/Cru6RgLUuAkAfdMA+lZloFT/CL4WoYTbMomLTQSj8N87cNBz3M2F/wXNvlPWB2m29/Zg4Yq958dOHwn3gn9m7DyrfPbUf5h4N02PebLK5wHD/AhwA1Lx5IfzhiQSry7yO5ZIvLr4wkc+cgaXv4NzD+HPzpYX4BtgwbkyAC3c2XbwraS5aJzjsknXqOYIMrpsNM/cOIxSQsqQ2JfwL6GzmqFfindiNp7QOKtqp0rKaxswg5GjFRJ1iz+IljNgSQW2Y0A7TDOVrRJoxA+Q6kGLaO0ji1is+ieLsGrGsPmgUFx17rkver7LrPLZt0+J+0CXOd6lYMBLqf9ygt5T/CknXkL9vd3/GVoi/O/IODQEPwvEHcgqn3sXVb/5AhFcyN2CE4lXE/kFSyReRfzTj77/BK4+y/veXp66g9cRtXRc/KPV7bHi+kqc2BUFglFDZ9ixbmDuBTRTR4QEYlo7jKNLbMqrHAVjQq0TPqFHCwSEUgXQfrqaQtqJVBf1EVGHgKxh+dCra9lQ3wushuOCbfp2DIW6T3BtVg13whRWQBDZzDZsTVAeVVUniAAWSN5S9r+V8N9T/zWF/5H6j5q9y8a4FcK/hRy3Qvjvqb9fPat8Dq/EUuG/TVPfrnWF/0NR5XM30EdwMWOAROJVQ367EolXBZ85/5m78NzpcvmaHH+zfF2l/khsdQUdCA+3SKPyTrulE/5ZVVbOxfYAACAASURBVHPWNF8TZim6Ua7Akm6dmuguAeqiKVZhU/lH7TxFRneqsO3468nBfunGxZXE1CDx0FRgK9/ZJtXZ9y3qGLYThq8SaCEgTfntSgAJim9fYHcMFZphXFrcUksV+kbFOxT+jQ5O+JlR0in731z47zuPrjjpfPvJvlsI/0uof9+eVT6nAn9W+dwvIFArWDGv+Pr5vFGJxK1HJgEnErcej33sk3eV557H3Ru88bbytZm2SjBLZ55BLi3zUp3udIUSLfHUlEaJhQExFmItltIqfrCAaBmZ5mL3q6AoF3E5s6eA7vtRLmdXt54ZrLTCHf/Kimy0kOhcW0Sa2qo/09iSCvnWT2jP4tmuCB+RViO1dEz7lGDRAXiAJBFvGHPllsK/J/v2GZxK/uw/JVJXY60DnhK6WbKvx2xtmvYnHquMhY9WC/+TpF5Ez5P2pnx3xL3L+Sbs7kV6cTu9TbAl+/rNnyT7ok/29anFe+vDE2nvLRYd//o4BhptkWOf7BuddzfQX4AQ+LtXZUz2jRtu01yS7DsNbzrhv7H/eD20vX9VvGdL9tVLYxD++7sXySrt1VrjF8nhhQBFMK84soF3/AK3PiGRSGwT+TsokbjF+PzP//yZcuU7cu9D9St3zS7Brfy2gy9DQBVfBABdZfdyMTCaa7afIkb14hSjj67Kd1kBkOIpv2z9qM+nuLQpgG0l5tkCYsfYYWE0gi0vVGdglAox4b9CM3F1JMrydGdfL+RvXNmmRoSHhygk6dNswj8LxLYAqz74kGYrC8iq+xnHIOGK/XaE/6k0u6jZNy7OkXfG38viCn8NdiP8956f9YT/YTor6vx0d2Z7wn/fydCO3Qn/zfMz7dlHMowNqzux1onTZjfCf/dkpz1vJfyPT7k9WWIy4MSWEJSKSgjwRKYFJxK3FPmNSiRuJX7v/PtPlKvP8t4fmT15vLxi6mB4ml09FSv4E9m6+rPV8hcniJXm7QHQKK+xf2VvxcuGaid6pG4rVkgKC0WqZx7rXgNmymd4bARAhScM2A8WP1RQ6/2LZhJb4KFeoGYBQrddl23yZYkHBQJUAaR2UYoX8hfdo0BDAoTzx4XqShQUitqiEH3S44olnp9GEPW2LRDo0ZixfrIvBl671PEPjOSP3e/YpSHBQEAZtHU4GLKs8zGuWJu4b0X9u56JLvhZ3N7LiXvXDv+7PQ7ZheN/MX5YStCngVnT7JdR/z5w6q84eY7ReYumus6XJftidPa3wafnZxcgUaiCSaYFJxK3Evl1SiRuDb5w/vxJeemkXH2xnnrz0a9voNI8IQDcqmGqv8veaMTdKaAEoamEF9JRqRusIuaMF+VlLS+WIEuxAqAlNPsg3MbsARX+vSiQhh+wYqOYEWjxA7RKD2w3XzeQKEFkl0ksSvcrK2A+E0YtUZGw+HuOQYUOTymWl/rx5RGNCqpYqANonFPpNYsIiy6UI2aVz0k7ttTs44o7Ev7jPmeVz+5+dvd2eLKtPbFDEBDUipopAYnErUPmACQStwCf/sinj5WXr/IEpDx07CsbqpWbPCpurQmeFGxciYLSEiUfIaMa0+gsyI2raedeK1P7ERGYOQcMdl7FEgNMrm1VdAThz7exiXYTLBaUGGSNgY1O6KbOan6kDGqu8eWBn6FWy1iAhPbf7xKl/2mOb/Tbe+nIRVi6WQ09iOdCmMkeCLM+faKd8N+RPxuAu54muQTRMzrh3/xa8YBiMN02XjqA5rMPVzr6/ct8ey8LlzS6i3SI9hrQVnIaEe/bp8SdPXFnO96t9nDHPyNmk3g9/OkM23v5NP15dNMBu7n7c/GnuUr4H1cPbJpsrxajHdN28dc+7hgkimvpy9y9GJYb07b3gsSoAA+P7aNYgvNvSnef0d3/aGe8dTFNE/6T/d8S+B2dVxw5gh99lFudkEgktkb+YkokdovPf/TnT8mVb9XXPVQu3jf7jpEPKoE2F7sSeFbn1m3/LCUTbv6h7gZgIYIXBVJ2AtAVdFLUBgNhpe/0WyhauNOq7lTCg3y7CquwmGmHAtRSCUGJFAJ4sU7qhlx2ITUIBZ8zOd96rmBXZpRRz0ev6M4l+j2pFClSnQlq7oHRRF9nMO5LbSk2KkFFQYXXCi9V7wl2Lvy39rWFf/R0dlgQcMX3Fgn/RnM2F/6zymc/QiLu7VbCf1b53H8gceQI5nMAeOKDeW8TiV0hv0KJxK7wTz76vpNy9Vne9/DGhePlulgaKwhBBZpVhk6/RD9qAYDb6KVTZ51MlFbR3yzyTu8ItG28IFrf04wxupGWl920s3wnLwGDfBOdEcj3KKD4Vl9FJtTfk3oRXiALCTyBQbyyDUze9j3CCklLMzAJuVBItAlqyi9KIUViCgAjihCwlkoWyxIuVXyai9TfQwJM+JlR0in7X3T8L40fssrn0vZhanbHBk5Mi7D8ipNOpvHDkvZ2b5cQd2Knnp+u56zyuT8gAs0IuvihvMOJxM6R359EYod47LHH7rz+zKn55RdvnHjrxldnpYrT8SG1F8qDrcBhx/udOekSgeX76onmeRCt1q9WHMvZFdP4RblUERGS8DRfjzecaVF6Gi2UKrQdA2yRwRX0rihQhSixFhSCGtJUTfYVS9IVt+lXyyHWVQjX8k3R92Mq0LdDgFJBtJ0K9LoAdNsvo/g6Zd0LjKKCa2wPLCxie4FhZP+LAv9q4b+n/lhX+AfGuILd79Jm/mny8LaF/0l7U753Kvz31D967jX4hbH59L0TWYwrbpHw36KXGPY2hf8F6g9/GyfsfxvCP7se2guwifCf1P+1gRquClDAgqfem3c7kdgJMgcgkdgJPvfRj9517ZuXjj2wcfPaw0ef3FA3CgCAMIM6wjcvpvdGjXwaW4Z4AU3CMgX0Bz2/MmghzGrsIqWTFZJmQfbOjTQaiTEDtPr70aRKeL/i2mXjPZYcoETP/3iGQBDKAgKV8ERfmz+jP6PRpLqaRnqtBum4V+HSVhXWcicAFI+UbNIeQpjjXM8dHP/uROod7QJIiw3E/eIirsQbQWzn0p9Fb/i2v4GRoC+yf+sh3Odw33mz2sd9E2Jw/MOn09ZbvOdluQTwnnv2H2/QcuG/zyWgRW3ejtbu8Ulz/DeK7CNvU7P70/2R2LbCl4xiavbtsHZpPWB4Cj4YAJ3HbJzmcuHfzfrSHP/trWjDi/e8c/zHNInICkC8Tl3Pw/ST/b9msP0qwALM8dAv8nYPKJHYl8hfVYnEtvHbH3vPKXnp2/V1D80unt24Aks69CqfTRxVUgXASmQayVBiUZWvFFCqy6th6XHyB/EkgSj4Y9RQwsADO170GOWjhYQUNdgUHZud5ZYbo1+EGYdiocAWHHRxwKoPmfBfmzvfyphqvoGX/VHK7Oxc8xkaUyRFROuWFk9Hhgn/bRtjodU+KpqNUAmrQNo5kcJ6pMPOKp8dJ55McPT8rC/8W1DXt8P/boQ7q3ym8H+7UAEU9Q7iQtqBEoltIr8zicQ28IkPfOLeY5fObFy5KifefvRrG5g7VzY2rKQsaixqSKACYVfr049hbM4KBOm3sEGcdLQqn1CyDiN8EjSabG4ZJ/S+p5in2KoXSLSSiRV4sXRb3zgMRJWiWcXS7PuWxyxENceRkLAynVVFbs0q9nwDEVRdHBB4t4jsiG6fMr8hjcpbbFAEVaVuAFIpIqWSQIk9wrSYqbA09tZxO4yeHwRv6yj+ZFFiQv3t9EYQXW4fCPrYeVb57Kn/GFe0aQ6RyZL2WN1aCFfaPd+Z438V9R+mudzx393b4cm29sRrD33/KrNCaCKxbaQFKJFYF7/x8Y+/7vjzz16/89is/uixJzfkplMkwOm6EyHztwhgxpv41HMHe6MFGvuH9SXGMghnZILmIBKgnQ7CpHzY6Sju5DH6q3v46qciHV0RAtV6AAWsVYo1NisRbIBKvtjkYf2r52f6sZ5uM2LvY3EfiBRY7IS4exKfdkyuGTPCgTPx/DjJm9LlrPKJrPJpL7l3Jd0XNTw/7T5nlc99BrF3AfOK2Qxv+yi3PieRSADIFYBEYk381iceOSNXvltf94Ny4e4jl5xuR/VMmKPGFgSUKHTLAkqOa3COUFJD+OzycV2Itn7MoqPBwHRXYML9x0HOVOwnfbesUNahBUOtGqnu2isF5lxChYgtKSg9V3MOAMstFimVPmCT/KVjgRJOJy34U5Vm1WZSr8XWCghQNwQotrYA2x7YiL6g1BYXlZgmm2HJVidG2XgQ/lv72sI/0H06LAi44nuLhH9/gzYV/rPKZz9CIu5t99FS4T+rfB4uEKhziKBI2oESibWQ35NEYgs89n88dvqZ75y+eunyi6fevnHhqNxU9iCV4cj3mjwCQOvSuLfHiKA0mdlsMGIEPfxC5ggyFh4LBSxd50KTZgGWqgdUY7VW5weNCDarfYUbkNSlo//pVXp6s77WEo3owkkbMTMeyeJjMwoOSpUi5uw39lbdFGT2JLEjdQ8vVqkCZ72x8bDQ8yJM0PUheYyhJMyPt3qjoNguCkBMfMr+Fx3/3d/oCGLPa4Ge/I2m/IX2JdQfo/neIxMbyTLq37dnlc9xmjvy/HQ9Z5XPAw59MMeP4/hxnLsb//wf5gNKJDZDWoASic3wmU995MzfPH3lgXvkyvydR/7fo3IjGEpPcQK0ejUqxnftgC0JeGONn8TtJRoC+PFGmsX/E+idPBR6hcYQMs2A48crY46ujH02ywTAAjc4QB0jkGJzIt1oJKF5E2gyvF5CWj1T40k+7MYdi/qOzIBRSfOlBK0XL64S8jx7odrunoU3On1Q9VkWiclqez+wzriiQ/OgIowlQOcM6SMNtNPdamKP0g1IFoGsFv6bt2cIpTBtb8p3R9zZmV7cUBTuo3b61JmD9tSat0cQ03fPz9RSFcOTuIce3gzCvz6OgUbrIWE9GjrvbqC/ACHw+yMQK4QFe7HbDQ8HVLxXffsK4b+x/3jztb3dNG8Pz499Dxv7t5GETah7LVv5oMSegj6Ta9dw7m5842m85Re41RmJxKFG/hZLJFbiSx//4MnZlafLfQ/Xr9175Dth7BHzZAdDgm1H5Umrg6gfThVBpUqIxbV2EJZHC4jmyLqDCLZ/sB2s/761LFvOYWxJJflidu9qiwCROmzEUSixXy8AsBCh2euixAyqpus+A11Sr4U8VWxUFBY9bEZo/nF4n3x7LzuxM+vrjgGePUzbZ0CqCCoqRESqW9X9HkolIEUnVXWFpBP+7WArNjlq9o2Lc+Sd8fcg/Pft7fQdCf+952c94b+NpG8HPArysQ6KONYU/vtOhnbsTvhvnp9pzz6SYWxY3Ym1Tpw2uxH+uyc77Xkr4X98yu3JEpMBJ/YqKjAnZoAILj6SzyuRWI78biQSS/DJT37yLj5/Vq68OD/z8NEnj5WXAej+WSajAlCV1K0ybkFxO0qz+HsMgIquh1BAG09qlXykk1TF6/m4Yt2KjSpNsUqgqOIhgUYCgJRaIWKpqE6sC4SsIQAX8R21ugG7w97GIab6E77j7wzdFsWWOmmbedGyDjS7wNXoGpanfjqUCg8D3IlUreJQ3DexAkEatLjabZsBA7pbWU/7lnp+MPDarPJpxL1rh//daHRW+UzPzz4FAVZUYj7P6kCJxBKkBSiRmOLTHz9/D779vNw14/zHjv/xsXKt40OA+lsA22AL9jMAhAMfzv4BOxjmDUIR96vASzXCiYgTTmmKIwTVuQ7cr1N9dYHKcWlypregamZvI7B9aZTYkQBu+xHEheG+C6NKxjg95NGduIozKyOcQb96Jwli7sr+MRgw9B4xNGhNOHa/CuFbgPXeDy1Y1KYp8SwQho22egCMnh+3ysANSIjIjfoQJwQ92GmTh3vhv5HIrnoPe9+R3fagnt3KRjO99D6l5u0BwvPTtbdpes2oqfBPRA/R3pw53m6en6WZAO3Gmt8sQsHOgQNbCessSd3bbgFqmL78RvU9eKTU7n8M0tqXC/8d+/ezpq9W93ZF1aPl23tJu5/o7rNFmNaenp/9CSFKwXyOjRnentWBEokF5C+1RGLA7378J4/Prv6n+evfefTJuzeeN7ld2W6zmrgFyCmXkvEQRF07D25hQmOru+9nGdVjcbtOVw/UVXzlg6q+E0Bz8gjVj2RapyfvKgusoBSPSIrRI93SyxN2xUR9td+otB8iPcTYZwGtcxunmOrfNhmQAkJ7UJdOUYW+Gier9IRjuzOq2fuozLA0Vj3ykQCxMqD3QdOafW8ySB/PbJ7si6bjrhb+t/D82PFLtPnuimOuQu9HWtZ5yxgGQvj3UGr7np9Vwr9fkT79tT0/7V6tFP637iTauWvhP6a5sCixrD06Xyb894aifpAp/B8MEMAcEEjBhbQDJRId8vuQSBg+8YnzD8h3z8jVF+dnHj7+1AZu0s0zEJFg7cGrICTVuC8IL5DKjaYWQ6TW8PC0KuO920ek2wk46rKHfd80dnHVtrTIwYTq0tOdqsdEeGCyd7EIQbMUKqxyDn0DL6jBSXfgKtU4WreHF0pXxtRyGNSlE34kdxkBxtqb419jgypFNwjQgVUIUKoquO74F3X8W3kiHYlUU5oRj4MxcbHcgKbZTwzfm3l+Wns8IHWDDBQ5q3xuRv19MENkAg9+phR/c+of93Yq/Mfp/cEL3h5Z1h49r+34zyqfBwrUXwkVIDjHxbQDJRIA0gKUSCg+99H3f498+xmeOyHX33niiQ2Zwz08apMJZ8SwCABRYqyMkYAX2HES45SJRpC0J7E9hBpXQwXCkqGqua83wD8BICxBtHQkzlpMs/TPfKMpp63hBiJQOgv7SJeL0rvqLEv1eBsX6aTW/zGFiNb914nrMKTFJ52lRHydBJDirh6RGqsodi1B79iJTrwEkF6DTtB74Z9oinjzhFjPDAtNmywwpdE2AACdG4TdVlPNGRJVemBT86hm4vmxHhDJ0Gg+n+bMMUPRqu29euEfYTRCbz2yKcfw0Jte/EHorYx2v7ovWLV26f/oRMwyE5VtpbuHfveCiNs9n3p77OgF9k+48O93z+9558zx4Xmfo7fHO2p1e9o0Gb4gaU+WbXuv4e4x2f9Bgz5JKeAcmOHhj3OrMxKJQ4H8HZc47Pjyu941f/3JY6fnTx97/TtPPnWqXDUCoVKiK58IjR/uVKGRFronuksFlurcMBYE6AJ1CN6m9fZ6f7SjiCe8Orv1UZl7R2V1O1i3JVV53vb5QjEqEwS0yzw2vhseG81djk2+mv2mAFKrEusCRq2eEvcHKFUgLGT4i3QHMXf4SGE1Bu+ava48eEkfgXZu3BpRoUisKxRfKiFY9Hii5SWr5wfrCv/AqPuy+00Yx3fy8LaF/0n77oV/P6YL2NZM9vVOBtOLU/A2910I/9o+lvrZnvC/4PmxjnYj/LProb0Amwj/6fk58CAguFJxteLpCuRSQOJwI1cAEocav/zLH5v/vTOzb169dubMf3Xmj0/NriofUBHdZX2FUXOX7o1yBulhRymqnxQV9+GHGZy6e2rwhPYBICk1sjCbsBr8Joq+w6ViX4oopnGqcN6kUBNHjRiZyKoytgqlOqdGgAT0LcKMwknVc0n95UHo3sTOvWrVLQJiIcLNISidvguR2jFsvWov/GvAU1261pUF61Y82deUeFOom9i8TPjvPrWLohf+4wF5u8vGS4R/v2+bCf9AJ8MPwv+qZN8thP/e8T8K/1iV7OvxyVT4j1FtLvy3NagIHWNq9u0Ykn19MN1TGIV/oj2LifA/bWcn2y8T/n14oqctFf7RJft2wn/reZh+sv/DAAGBM4KnK75/hnfkRgGJw438ZZc4vPjSoz95anbtG/KGt9cnXn/sWdZQ5ZVSABBT04ds1F7y78RR8VoiEBIF4fKHZbXSKaOzuibJu91fmWtR8du2LtKNAgReGRO+EOHjkdB9x7WIEj+bj1+JINTZD18isPFU67aIm/VpU7A8AWVatV29BJ1Va35bHJDWodr64ZZ9EirbV8t8LZUoLUsYusMxRKpJ+2LZEb6TsRYLqlUgpZLqwfLipLsV/ntlHb02HytCSlvXEP4HKrmu8M/Gg5dRf6wv/OvVs8pneHtGZ38K/4cchZgTEFz8UD73xCFFvvqJw4hPfOYT99dvn5HLL9w88/ePPnWsvOIkzwvwG2VolXxMRXYPNNAycZ24NEZunwo8aRWEFq5BKPaEGG0NWw60So+FBMGH6Em3yoDVzlGlFfyB1SkqGrH0CnQ1yqhnWTX9UMRhumyrCOS+ne50ZYrsu5Kg43q6VFYUcwRZ/q5YwrHHIbGNVziaCBEUkpDSZQyXajdHQN2hTBVci0bsdF+tqCwQVN8iLbivkb9GEF1uHwg60ZG/nSX7ugY9iRN24vmZjmTC/rdpHJKBuHvnA3HflPqPcUWb5hCZLGn3kXAhXGn3fIXw30UOfedL44qO+g/TbKFX/2S7ezs82daeOFSoFSKoFZWoNTcKSBxGpAUocejwa5943xvmf/utct/x+vJ/eeJPjpXrALpgeFwXFmuiV2tc+LQGNdGC/XaUO2TMLKF8TN3+LosCQSLbwSZ+Y+Q3AARiZhMNLUyK9mMEbmTo2CR9PjF250DSXTQInDmFEF2iWEs1l4qTKmm3RqCpAc7Pgop1nh93v9g6RPNmmGGDNsRgtDZE+kTcT9KSfe3iHkrZRIL8Rb5B477hwEGrVrTCmeM17NdI9l2akmvvTOfMmRJ39sSd7Xi24+FGo856JMFfxcOtztuDieen2YS6uS96fvwxjsL/uHpg01yV7Du2i79Accfai+HbI/RGI7tLo+fHX07pvT0WuCCOke4+o7v/0d6SfWOaJvwn+z/EKMV+P9WKjQ08/Ivc+pxE4mAhf/clDhE++clPnpPvnJHLz908+87jF08feYnVuThdFAfgFTwbewvfDp1ZojkZ0BJV3XKgxwQjpAikQim68yECVlzfMoARyrczWuvEPUi2hbBJ4E7m9CM1CBEQd+ZoegGlshQJ4qsF+0U8y7ZqhVNftaiWyAurDQrd8TcoWgFQWSCC2DnY9gQQYqZ1USlQbT72PFaOWCkoljdMxGoDbRUCIKVCBKWCop9qD1LQliBCbBZKYXVv9xLPz6jZu2x8S4T/jnD767FT4T80+y4mzCqfLQAeOl/W7jHumsJ/1vlJdCAww03BfIZXjuL/+/F8KxKHBbkCkDgs+Nyjj7yufOO7vGcDr/w3p//t6Y2rSrIl9Mr4G5rYisZnlP1If1gQj4gNKEDzMXcyvwiqsnHTX71zZSMQFkC8EmhI+CG3w/Vol+u79QSxpEkxo1Ftei1czNbsBkSyL8BqiY8+Q7JqwKDxSBFCI4o5YTp0yMYSPFhCwHZ9V8QWDZRqmdCLagkIYsJwH0FJCT3YlXtKT++aXG37FuizCOG/T/b1+zMsCITZqbHPqfDv4ZZsr8onhiUFuwO98G8i9KbC/4J/Jqt8bqPKJyJd2Nup7zbjDnR3L6t8JiYQoGJjjleO4o5reHtmBicODfKXYOLg48vvelf9nmPHzvKbJx98x9EL5468AIruMDXwFbrrhFEYR3qFnlCxHI30Q5RFs+ukJa16524eMvW3Y0hh3w+vP9ASbakauXTOkPDrVz3eZGOxrb5oxF1oJTKtjicspvF1g1I1xRgCTah1Oigo5vuv6r8HWjazLSCYxs9Sfaa2s5htDWZVSm0idE8/RCt4glYmSFcbqv0ML2ZaAMsW0BRhsFSBoJCoomsdvhCh+cpAl00xaPOD+N21tyBtF8J/tLc4aqfCvx9DdD33GvzC2Fyb9066kInxgrW570L4pwWx3bC3Kfxnlc/E3ocAlTh+AieO49w5/PN/mO9J4oAjVwASBxy/8uh78feOlW9cf/nU8f/65B+eO3JJBemJlu8QU/qdRgAIyRsmfDpx8RKfNf6lYGNCPUMDfJ0BCM7vCmVTuGGqqtIUAEWdQU46G9ehxe70FnMtVXEeJo2QtfG4IFptBlO2BFiA00r59x5rCMjq0/Hb41VIm1cbVg5Ib04Uo4SgNJbpf6BcPKxTVlOySd0aDkj1W7lU+G9SNNp0mvAfz6f5rLBK+Lf2rPKJnVT57BYK9EVaZP+aCOKy/TLh34enL8dmwn9bU5Ks8pnYFfS38csv49w5PPM03vFRbn1OIrGfkb8NEwcZv/Poj5+avfCN+X0/cvTr9x99DpPKPL5PFoxKq0pNK19DYyRQA424q8Y9GCpds5KWlhssWcKnXu1MaX22skJeL18/apZ6+4gsSqBcPDZ+6SNRhd5L+ig7tOHFuoHE7Kz6py1lFIklBXH9PtYxfJcuslCDkFoqCEhl0YQEO7gWCoEZvToQqBeirRVAKorYmkY/X51LLAUQUoJSW6kf/VRaFgH8DpBgyyXwRgBbCf+9so5em0dW+Vwu/PfT37Xwz+4+e/yJxRGuK/wzAtEFZ38K/4mdQ1BuohZIwRMfzNcmcWCRL3fiYOKzv/T+++W5k3Ltuzfv/tGTjx8pczfbNMZPN/Wbt0cFx0rEz8rGGHyokftWM6eKKZVDwdA4RosBucYZ8QNDSKZ/as4Z57tG7yCi2+i6H8aoMHpCLMLKJvpqIm9c1+bbaoAaD9P9Aew/exqtPWuCsqfeQpODNcgpqAIR9RqZ7UcvXQv8/lQRtTDBuL7ysNIIPS2u0PhBoN4ejRaap8iuGPcwQiYWdSUpKaxoidROo4mO/L2KVT67diyn/oZhJBP2n1U+0d3bjvoP05xke2/i+RnbE4n1QaD4e1QK/uR9+QolDiDytU4cQPzup/+Xk+XK384feKj85RuOP03V6E19b86QCACCyrAGWwLcjYNw8Ifw3zIBxEVQrZwDQlB9cSBWFYxsiRnvXUEHoEVsgHCxl8bhUGi2/sgTMLpfImaArVTEvlpeTEb992hFgTQGqIICte+7zC9t1aKq2abYCFkIvS3GyMV2Ana1HgIUcl7RogAAIABJREFULxwU7NNs/d5zhCJFYwbNCkAMKW51295Lh9Hm62GP7mjmP7PAdhBDs3yM2vyiZq9ceYk23xHWrpRTtyCwkDzat0+J+0CXtxL+B4q/Svj3K9rz3Zz6x4KAjXYr4X/rTqJ998J/THMhMlnWHp0vE/77uKIfZAr/id1DgNkG5nMAuRSQOIDIdzpxoPDpTz/yOvn2qfLS8/Nz7zh+8Vi5ERw9ZFfl6L3pAp2LxoiLNirfctGdQSVdVo8FBA8J4JwVA8uPn6kme93CVjoaPQj/FBGY092IeGeqAQS2m28zF5GFIFEkFjpgWntk8YIAi3Ll3g2lYYAbgQZ+T91mS81IpbBGKKI1OtU+NCMhKJrIaxVRAVBjA1RKQdEFAavy2cqhFnVJtTin6FZfhbogELsgSwRIuuaAykLQ1iUsOjLle/fCv2n2mwv/WeWzH6GHVhg+Wir8byPZN3peW/jPOj+JWwnx8mul4PEP5EuVODjItzlxQPDld71r/oY7jtxZ//rUgz8y+9r33vG0y59eqMeYK1z476RENccHXwfgHK2p406s0cnSUJ7P0fmjiYkVjdzbMMRNLJCoL4SusKOJ4iJeFQdeKhHBy9U4VAGJyjkm/CtpFkvHtNo4HKYALQpk3h7RdOCisxOCMlPiHgWIzNmvtn4LcsztYwJ8FctAtaJAYkWKahiiZgDJmQv5pWrnBEsJ35QGMPDBVEK3BxYdJzRysJiEFtFZ6oKVA+pKGizQ6yXUfwvhfwn179uXxBW7FP4JRvzQTcGn4/HDDjV7QbvipJNp/LCkvZHpJcTdvlw78Px0PQvInspv5fnp7m08vhT+E68OdLOwF27ixYpnKnA+367EQUBWAUocBHzmlz6IH7xj9rcvXz918h+c+L++9/g3Q291Zw7CQQ6r8WIyPbXgvUn21qHyCLPpa4vxSWfwaP8zGElrn1g1ITSVFL6gYP8h1hvB0PulMTD4dqVOaGS8Vt+58vDGdG2oFkJ4UaDYp3joVvmZxHBBtErtejtskCLVggUTxsRvGm3cFBTSi6CawOyFREGyQgcq4X2ycfoYotKLiD0UQbB/v//q+G8tMa/ohJuxf413/P43gh7TbO1N+e6IO6NmDgivk+MbArTTdYReY8deibYCE8VtfPqeHOKOJn1duuHpsG2ci45/e3btb4s3LIyk3x+23uyPF+kPgd/jYdH1KHtN2ikxTf3aLLSvEP4b+/cBWHu7afG98JI+8Fe/E/77uyfwZOcYABKJW4dSMK84JXim4o0zvD0LBCUOBPIXZWJ/48vvetf8e48dvbP+zYkH33nHxfuPfAdWJMcZIV0obQkAxv2FTv3ZcaYg13D2RkSfrsWWJgP7R+77R+ftgen6YoUgK1CM5QySf+cXsoxYVFppf4jn4+p16fkGqvqLhhqkCqBGwlCDTtkApNmB1FxUAFZfDAFUs9fBmAyvujus8Ofg8EFciN4hxTxCwdQpYrsQ+GHOF93K7/WCYCswtbdC2cQBeLKvz9dTCCTajX+vIfz3np/tC/+rkn2xU+G/72Rox+6E/+b5mfbsIxnGhtWdWOvEabMb4b99utDzVsI/umP6J0tMBpxIvDrgHMdP4sSJ3Csgse+RKwCJfYzPffKD5QeOzf7T9ZdPn/gHp/71A0eeBZzIKC1vhCZUczpDMWbrpMpZPho1hAv/5sqwfbpCjI8jI/PWQ2pX3HuliIIiTtld4PcPtXy+rzM4cV0gNMq64rSm2Zvk71OuoG8JrKOKEu+M42ujeqJXbPS6dUU9ktGbabSgbZtGv4qwhpiuvDbuP4mqhfxN+9dSS86J1bDkjyOIXRP+u8fREqyb1uvrCSG3T7R5WxAQLe7UrCabCP9NnB6E/1XE3RdMVgv/XC78Sy/8R7tNLeqitpUiH57T6FXCv7H/XviHL8LI0MP4ZFcK/317BHKj8K+vtD8XnVp8+/rnGIsq7Ac2Ff67l03iuzJl//ZlSOE/8Vphhpev49w5PPMM3vHxXApI7GPkb8zEvsT58+fvveOFuzauPD+/9+GTT9x/7Du9im+KbCi+ztAp5kdxiXqQaUlnnPSAwfiTq+wWCTTaB9HCQUZx2qeuuzcGZrxfYiSWS2AMyTeyre47ijRcGAM1dh7ZAtG5FPF6PmIieqOJENHApWp1/+Jb+fYLERVarlTr/5iur6S4L88f1hcbm/rvYYWAjCCW6r1ZgSPOjNtVX3/wDYxbSVAprLSMYd03ABDLIdYFBKlGoGEbGkDXXgogVQSQWguCLG4q/DMCFH1Sy4V/BFVdLfwv0+zjijsS/u1nIqt8dvezu7fDk23ticRrCkEhjh3H8dw2OLFvkSsAif2HX/v0e9548pvPvnx2Y6P+t3f+nw8c/Y5/0n4Lc/hbyYTL0SY6sqm/JuAH7QPMlN91KJ3oD/f3c8wcgK0DBH+LcWlqgK0zwC6PoDHGZUKEbn9iBcKTBEDYF1d/kKjiIlJJUkOA5p6nG0mMQrlYq1eMSZniq+N0tV4HzzIuZcAmSF1d8FvohUCtO6N6UtnINOnElZFQocOGxjXB/jy+srsdxL0J/J06LiE8W7ykwj874V88slJN3rM7mvDPifCPvn1K3NkTd7bjPd4bhH/2w1sl/Mc0daCj8D9dUgjVXJazfw7sv01zifDPyZIC7XWQReHf35cthP+2jqHPKLqyXA74k/VHsFr4j9yYFcJ/sv/EbQJxE7j2Ms6dw9NP4+2/wK1PSST2GPK3Z2I/4WO//rH767fO8sp3rt/z9+/403uOvtB8BcY4xZhB840oc7IMALZGmHFcxeAoDUQwKgn6QoE0mtX8/V4VR0iKO9TZ1hAkqFWBlbUJ6u9Jsk6wKilhrIfvCeCFhhDZAkXMLo8oCmT77Br7RFAuK5vT1hl6e32phHvfbaMAlOLbINhZUqzAjq0Y6BSsoj9Y3XyPwm47MC3c6TsG6BWLsFQUkFWK0LcHloIaW33p76K+pmfxIMEWAcbMCisi5JsVFJBWCGgN4d/+ud5c+M8qn/0Iibi3Wwn/g8A/dL7QHj2vLfxnlc/E3gKJKqiCGwV/8f58LRP7BrkCkNg3+NKn/6e/O//33yr338Fr/92Z37/n2AvoSADhdWgkuJEL7faha+rwgiG9pu6dwGhKcMS4SMfJpJ0C5z0cj3G+AxFUtJHGYTD1VNN6pevW2Y8P3f7fTC86AIH3qSMm2erDiOnw4WUyjb+Y4E+yhFgrPhK/F9VP8T2ATfI3pTYqrgiBlkggxSIoFEgES9p5RTUflk6zQOidM5ioJ1DEM2UjiDoN8QUKEZZe+FdF2Ge0hvDvXvY+ZyCWR1p0ZyL0psL/gn9myZJC6OvNQLVa+G/yfAjty4T/aKfWdhJbHonXg/amd3HvRPj3gbEn7lP2b9+Ilk0Rwj+XCP/dqzIK/25I69sJV/3Fw2+9/2zCfwsOTfhP9p/YYxDMgBsFRyse/gS3Pj6R2BvIX6OJfYBf/cwH7ivfOlGufvuVcz926qkTG9ealcQEcgg74hLFeVw+d2nTKU44+JUvi5BE7EobgYElunpxRrOg2Eft06BlTredQZrkbMRRnfHu1wci27d0LE3HX+j+8VhMiANM4zceWdw7UTxgMBketlGAMqpuuwD2ebGodF+NLhqowA/Yfr1tnwEfm21d3Gr7+C4EM5LAzChmLShSzfevHM62ICBnoFQBqzNCzvzZKae39Q2dXaUZZojISSiVBKS6BYrUHcS6xI/Vwv+kvSnfOxX+/RiPWAbh37V5TGw5LUDshf9emPfDdiX8a/tY6md7wv+C3d86aqdvX/hn1wNispsI/1ngP7G3QUKKfZFyy7DEvkC+o4k9jXd/4d1vvDF/QK5ffeUNbz3ylQePf8MFclHrDUwC9yRddHKspe0Wl9kbjTMqL03n76zegiEAUI9zCMYmaaNxcUA79PzdGqp78wh1xF35MSM2cAW6OsOGq6GW8svWjxUAFWEfM1gqMKhydRErb9pp5B6ukMX85bWFQMrOq+cZA0WpucYD7u1RUg7rPJKD1YlEYRGpUlGqHwn3/wCo5gKCpvZ6NFX0AXUZzwJKLQJKZRu8BgCW7MsC2x1MNwOGxD5oVgmUXearc2vIimTf5e0YqL+/UT1BX8b+148foFzWXpXRJtQR91VeoEb9pz37SIaxYXUn1joh3DbNJex/e8m+k57bNLeX7EtMBpxI7EmwYraBY8cyOTixD5AWoMTexT/+zE88fPOl/3hkdseNI//96X/1xhPfAJzhD4p+/Gf/2zbIdLNnd4dI9+47JzMbiHoY0IhauF/UDRLcMboSxH93Wx2huUSg4YC6L1C9mzYwC1GIjpJpnqMHI8JujsqUKKzShmduEFuTsBZ3hmggI+KuejfG6CWkmu/J5m/uFR+h5VBwbi1F2ubKZtWwfGii+nKKWJ50ENWoRio2796cYwe7t6fCnCHiR9JXLXzwqESxPaCyyqdPbWWyL7qQNat8JhKvCqSgzlty8EMf49bnJBK3CfkrNbEX8Yuf/cV75RtnZi9868a5Hzv+xD3HLjV/M0KSZ/NOGBszZd24CCFug1ELQWMqpqO3jGEvcAkjJW7daGYb0G0wYlqolGFn025twUfSS+wS3A5o9iQV0RFuH63p2RmKlHWJqCFHYgXD/TNgbMtF86mzmW3QimbGGFDgTLkjiyKRgFtBlFid8CqfvgxCQEql+n9g4/f9xUAhCjVF2J08Yh4kZfa+qiBSa9GVBIm9vaQQhRXVoqkiQJUCrfIpqHCxX80puiCgfiRBjWqqLT5bJfxjUM1XUv8Fzb49u50I//YzkVU+u/vZ3dtB+G/ticS+Q62oBVVwM5ODE3sSuQKQ2HP47c+++/s3/uJZfs8xXv0f7vz9e49eapFqCOTB/kPthgvjUG6jP5tWjgUaIUG8/L8ZwYUr5XCuUi1pUtmJqenGlsLVo6SqG4mbiZTrhBAbUwhmSSu4WUR8ocD5kmW+Vr9g04NtDOazcFJrOcutbKhmQBj/b5pvrHJonq7ptToRUf8P3FweyckSJzuzbPfZzi2eHmoTodv3gwyzSgzeplJNey4kqg7Jb3ST25tSrtMRiUQO0b2J23oC7OdO+M8qn95uL/GC8O8vYlb5TCRuAUrBjLhZcLTi7b+YSwGJPYf89ZrYQ/jML/30649+6+TspWdv3POfn7pwYuPlltqrvN4zPhvfBZrkj6ahGqtThmumc3pWQIj0cXDxX89Ra5KCIC5m2FAWNaw5OEsjrXNpznWgH5XoTlhRbyc68TRWuJXFuLiK2aGyK10Sek5tv2QRybtGNNtahMnwUlGLoNq5glJ9dlp5U6yeT3EmWszQokqxbeblm4jZUygoeoyytxmIKmrQt2UHqVKL5iTMjOqx+AJF8aG2BYT+VlvmsTlwLPmhLcIwKoGC4ikK1eMfe5ibCv9Z5bMfoYWssZ6wifC/jWTf6Hlt4T/r/CQOGli8XBpw4ZF8sRN7BfkuJvYEfuk3P3buxjOnePkbL937o6ee+t47nlaO3unNUIbtCbgdm2nZq42o9f4Z98ETrnGKp+oGCXMKDvftMHr2q0iI/xEM+N/FJPje7QN4OZ2R30fn8HZxCxDgdqMxb5hE22dAObRqyVqp0+rwAIUiIG3PAW1pcYXabEqI1hCpVScUpwfPLiYzi+8ibN4h1tah2YSqOpQIUMvyaEAyM9NUu5wXC7KFg+LBzCx2A/BQrZgdqIZMXkhBERK1Wh5zJVHUnlQqIG1D4qWen769V9CNcC8Qd7afB3q91PMjttZhT3CJt2fgvl37YHrxtzH+dubdFlCmnUzjhyXtjUwvIe72nu/A89P1LCB7Kr+V56e7t35RkSz1kzjgmCO3C0jsIaQFKHH78aXH3v1983/33SMPHLt57X+851997/FvAs754bza9OOREnkM4GYdRSQOIkJcem9KLdRR4zYV07kBM/3YRenOHCMrUC5PX0IAxOuTBOlS+gJnSHZRxvgKotEGbqECPOVX6D1YpVC7A26lML8OXIcWFJi9p8TUh2G7y4Iw67xx+0HTjfvsZLMizCZ2a9jSqQVFUFA9s8J4oYiFQn4/g3DbKoc7RMyjUmyGdF9MLZHH7OK6MJxX9NGYeySsMhHs2dS69qZ8d8SdnekFtm1wpBe306fOHLNL2fpDZ4aBoPf82InwpxbD02HbOBcd//YOtb8t3vBlKG2JzsOo41OIr0MLHWWa7Nt5ezw8nnp+puFNJ/w39h8vpLa3mxYvqnt+7PEPwn9/96RzoGWyb+LAgrTtAm58Dx74Q/o3PpG4bchftYnbiV/9lR9/w+zpO2avfPPG/f/FySdOblxzi47TT5PzBYBmwdIYYsvFdBJj7iDjmLpcELm2VtImSI8zMLtKMZGY0Q+7S0t86n3KsD5AF2vd9u6cT5yGuqBu5Iy9DK/hiLOlYmOAsIJShBEhiDEnLxhKFKFVzdesCPXeQKRSBLHxcPF1jBkpVUkYCwS2JXAptaKv9Qk1LIlvEhyb8lrnpWi5z6r2G1sQIDTZFwKpIsJS1aVTbQyw51JAqWoZQkEFi1CXJgBwhuqJvyzwBYrY+dgGifAL6eykkiLFFyiWCv+rkn2xU+G/72Rox+6E/+b5mfbsIxnGhtWdWOvEabMb4b99utDzVsI/umO66Xv8ndQ/ceCh/65ceARv/Jc49+d44kP5ziduG/LlS9wefOqzj9xfvn1q9uI3bt73Y8cuPHDiu8YPjGqrNOxFb9iRBufWqhy3IAG2426Qb4TcaNSTHY0OJTgIPRqnZ0j+xsvFknBdErbTEayoiyVcfw2SZ24WmNTKoFNO0Md0AjvGRqBXJJzyOjWPqwi0aGZ4hwDb0awWCyQokFLZHP/OjHUbL3iJHkBr7ZtPqTTjkNH3UknIDJUtFUEd/AQxA2AVjXzjMACVmhsgYKmCUktVW1GdQXzkcTyjNz3dDEu1Cor6lDzNAIXmjGq1jDQ46dinPtU1iftW1D+esr2KvuAzeH7EV2awxAuE9sJo584HVrD/1Y7/xfhhKUHnsnb9Xiyh/n3g1F9xGGHXeYumus7ZH2PtGJ39bfDp+UkcSpAo+huioGzg8ffk+5+4DcjXLvFa491fePeD85v3y/Xnrz/4tiNffdOpvxK3eVBpz0D3vUAkgBDpOzrSe/2VVkRswJbs2wUACJFeEMymCf+wJFSLQBBGHPMnuMucTjTFrCN6SYQrYyEJuLD+/+y9aaxt53Eltqr2vW/gTD7OkihSoizZmgcPEOykO8iP/ErQCBoJEKChTtp2t1tK7I7HlgMISHuGLFu2LFHuGIHd/xrdQH7kTxCknW4gbg8UNZiySJPWRFoU53l671blR9Wqr/a55/ENfOSbvoJAXe6zz7e/vc+5l2utWlUFF2EmwUeXGFbWFqAvohJaPtrlqgo2GgaZK+Dpfa9agijqdaQi7iyiTWRfVGFMEwvonx4buvAL+meRtKjvIe0iDo4eC3qjFKeXSAvAY+cxAgym4r4AiCxErGBRDewKETMVuMsCiCXDUc9FxKAiWfBgorBoGOo5v0ySC/GmiH1PIPxv0+wH2zwd4b/4w+zy2Z5ne7Yr4X8cnzHjIgwz7BzCwR0cOogjR+bUsBmvd8wagBmva3zu0//0g/bMN5edw3s7f+/K//P7rvjr8lEjgUGPAmeJpoml4lCACfreKz1A4TNf5T9pzU+8OF7lOwLu8Mp5ePMt8HIsBMrzdlEXDrQKKpOLhWqb+7W6N0Ig6qwFiQJfwnOIQW4jmUh2YmQKQuESFvB245keIHQTodLK54hxow6jwzw+AqG/CPTbiCsgMANoZcr8Q2YYPB9D3mZDt1mAHWQGaUACbyc2oMFnAJXMUiwji7KxSD5WIk4awQZ5W30WPL4J3L0Ddx/n14Og47+cWmW+z2fUHP9jcclPaHb55PHZ5XPGjOOGKuxlPP8cjhzBd76D982pYTNe35h/f2e8TvGpT/3PN+1899Kd5x88etMPXnLXdQcfXymXSNhb/TQx9PhYYGjV+erIABDztp6hTXCVgeNDLxWafJpO35oCESBKWi4yJxCCqLNPDhLs94QDoXPC1cJ8JdsDhJh5OR6Pf/WG2xwhb1dCgOqyBgiry9EzE6b5YCWBwOjhSWdUwcHwI6kDhqGjQxRp1kcK/xjmfkBhboUpw6Cfhn43aLYWddBllB4hhE1IxPdaWa0LVD2LGXRV+eDqsbiJL5oFEhwQVqYgRzVUVaPHSSJhclqaPQqeMplUySI0jje7fG4uvoLyJxT+Z5fPGTO2hFMZcuBLvzh/O2a8HjG/ZzNe8/iVz37iev/uFfL0Ay/e+IHDX37rZd8GQBxPcLCPABQKR3l1CjqkmwWWGHOF5ge0WtUQr8ENsbtQPV1Ri3QEAc0jZOs3hhTtBO6hQ1sta5xQ1vmD5EQxNM/6kKhZCZAEJqC5awqoqUNDxvzdojHaCIaMGxdxE0f472PDVeYbBCYIQD2rhUxJvAgAsoQgwLcJco6vj3OwchkpdxvjAnJZyOLkbFH+67IEAQD4s3LOAEDTUWxJk2AE3Ef+0wGYuGpUPLeuoF1BT8A9u3xuHp9dPmfMOKfCYIA6Fsdi+NNPzF+TGa9tzG/YjNcwfuyOO9587FvX7zz+qN3wLvvy+674muoeJfaBkNL3n0ecVbZBABKUoSuytGo4wcWoBMAw1iPdKSM50CAL9dqyT4BOfRKPkv/dRzGxO6KfvXAzw1IfPTEFMOJ4gFJ6pSySQgDU2js3EM7GSrO+c2ZW3hcA9+gkKvT9kxsgJPxVG0cnA3EXiSkB1ot6c9sGJZlR0iGtaQMFpt2UHYfgojCa+KPhD9TdnXMGUqoHYEqqo8GvzLPBP3yBRD1x1vKaKywTLHDNd0WegfkQE2Y83AEtepPpBdMNbf6Ewn+H/quvGTX4/aZ8pyC+IfxvAuhXLfwP9lLbPkXhfx/0z4X2of9TFv4dI6UwNu9Y3wgwof+MGScX8efjwFHsXI6Dl8zCgBmvbcwagBmvVfz+7/74D+DOb+7ccslLz/39S//NB6/+S9VjKAlTU0QU4pcIr3+A+EPG8YJBzAHAafAZa9T5TnMNF6lX6//blSsXAZcCVV6b6e9PeqIlYOd+QilOrC6otANiw0iFP69VSV8gFFapbYenOrrlxAV5P1HY7HUssSxLIDSPR6bB88ZpmqfsS+d3VkUzEyOWy2o9sRD6kzJlTiPpW3qiRBzYg9fYhL43GB1Jzo8pYLTGjfjwyufDLH4EEUlGJFxCqmY6ffYFPYe5qJnv09HuHf3zq3Ic4b/XEjgfSx7HOJ4AHcPxPyAyXVJBezYc//m/sI9JgOM8k2+Mp8ekzVgBXIf/bMDdN9E/vy5bhH+a9ZvjP9dc1Qbk1zf3BrLNQv+sCgDP97by6vYn+p8x4+Qi/lq/tIvnXmRhwC/5Cd81Y8bpxfyLPOPMx+/+7sduXh46vLz4wMs3f/iyv7jmwNNIrR3U4+EE791xkfJh+nYgtNwMv9Dw7suoJhQK/BRNHZBe/Vl2eV8hv15m0CxACgAibj6gW+8mxA3wjTrGBhNLpuieXiZirACLie181fknhfwQ2pEN+Et9h0jOkg+PO9w0jVJlRgqfUrqVHKjJu4FTw0qUE38zCZDteoCsNk6tPVMBMnIR1WvfK7EQ48eSH4D5hGEKqnm9yP5CbCWEhfYtFagJ4GpQcTEfQBmoWQES58TGDNkCiKwiLUBwNQBCC9AW4Z/a/PE8Pycv/CfZWpth9snws8vnFP5nzDjtYHlb/nNODJhxxmN+pWacyfjk7/3s9fLdy5fnHnj5pg8d/NKbL/sOkDhgoLFmuUH39qT+TQAxMHdRgkL/cbXAx0Q2Kb7CjIZv7wW1raXMMPSvz5Fs7YIwr4cDZ4WDQXE331jqcuYaUqxNJw8c1ZrTIM01FBpqg87V61MGlHcgJ3ARM9L6QutRentiS1GdHBamaBqj7hCpCgFEvazE3ACoGySb64tnUW9M4MLo+2lVxFzVApEoUM4jK8E7NrbE2C+4uMKNowZMPet3EfPLTBVGA48PvhHmIhct0O9ZP8DHldYgkitRM4Go1XdDdHzZyvRS8HR2+dzm+D8e9F/d5nbHf3u2nbe04zNmzDjtkMgrC5YFf/6z8xdqxhmL+WWacWbiNz/78av80ct3nv3WsTe8S7/y7ivuU60mjE6JHayIHW6P0vuLBiTUZluY8d7GHPhDNuAPb0ykCCjzNwST9bWVVVhfNCF46PcyyoshaXTxnNdLjtEqB5xJgHgKslnU62i9Fy3hkUPcPGXs1b1kRYFBWGsbECqGXgkhcqjmkMDZvKNRjYBgU4tYZFq0khLtNLDHf9g8sidPEBUSJG27CiAej0UigWCApOiuBoW7ySKWT8l6csBrYldUI8Bd3dVFzT06CAFqBpElWhL1pEQ2BdL8gLIpUGRRgvzQgsL9nLTwvy72PY7wDxDib2LiLdC/EgL51/VEwv+JF6njr174r9vcx0y2Ha/Ftwn/nVf0TU7hf8aMMxtmOHAAbhDBzi7+5J/N36wZZyDm12jGq41f+7WfvfLAU1cefP47cstt/rUPXnX3rh4LidQSx3vJrqF2C6X95vwpdd9XDVuafp/CKxH2AFIF1wKfDWkfgMQI3obGqr9QVQYnBwDQEHYZJFLCF5pwhgpOcO8o5w+arUhSk4YiZVsWKEONhg8fjyVKbIU+fVYPx72rwConMNiFokwv4i7BCuK6cPVo3hJviXeZMKXQqnXBQWMqbkEt4jY1hfaoCU61Pg08GA9E6T5Sdm3SGHxm0Lpxy4e8uAj7/2jmIlwc2fETMbwsXvXsbQos7grJB2UQ+GIARIw3ruQMoxNo0+zRtfktxb558uzy2Y/Xyict/M8unzNmvDbhEODgYSyKg4dwzTWzPnjGq435BZpx+vGJf/d3rnzk6quek4cfvv2Wy7/1g1d85ZL1kvVmAAAgAElEQVSdF5tVhoic1bjbvD2l2Y/yzzw5UD479CNXkY1MQhzmkF3QGJMbGO7/lcsoz2lLAagOPM0rkl6gGh3QBgYncoVUHWemC5Dm+zTqqAyL/OAbcbPRtr+MMcDgJJl2GLb7ylesm29mnkSNrCZcTC7gyOFU/ZNaOFw1ygxyca/GQcPkk3OLIzOQz1CL6ljysSWEfBhclnIZBSUwSEwVQOMJApgtrHAAXT3RQSjmG1Tz00gOCPsa1fRfYW1AuJXc0JxOeS96qsI/yzewxdl/WsL/SrPPEm4Zbzwuf9hyfIDpLcA9Bf7Z5XPGjIsh3KGCt96Ory145Ho89MNF+2fMOOWYXYBmnGb8/md+9G0PHXzquif8+av+yxv+r//s2j+7ZPdFkFNy1ifQ5NV6NX4aZ4Dqfj9FiTYoOKa4vPFPniMDNgGlULYrjAMyjncTduJs4X5qzw0C+bg1WS/lQ8vPdST9EIL4X64lpBbJYsZdOz1TcVocQUJ/wq/+117gcKvTJNeRqFwA57zmLn21DTKKVHKRowykoKfwNP4HJu7duIgrktVI9rSRfLe4OZ+L1fMUwF1zG+6WWxJwtLIDDgsHv0eTT8uS7OJ9uaIO7VlStq+dkEF15iPVmolESMbIWwj6ZF82sclnXvzBpX1JsIH+fStwT47pTPX0xfMHcWSrn/p2Fl2ESNDafAT1lrrNcpetjx9H+B/onxvI4+Oh8Xgx2PHlHMJ/f3oCFjvXBjBjxozXJkJNuPc+LPfioR/Gbf8WH5jzg2ecbsw/1jNOOX7vd3/0TbsPHVyOfvOlN334sr+49vBTcZxKeXls4uhap+zJgUoFeOn3oHKPcnW3sssGbuhsNvcEpM35U+16nFp7wjWRmgxQ+YHIGzihOpXdxEMj58A8Q+4NVYBL2TjfQmSW2u/AeQ3GarIRavbs7l8CvHDuFVZluw6ouOV1U/gvJ08+vZDtWVIc6FO6CSd+HuacuK5Rg4cj+/bE6IAwIzkhr9Q0sfhnfIgqoeu7urGSGMKpXsLmP+IukYJwV/qaNAaNuWRhA4t6Cd8h7gpV2xM2/ld3gYo5xJhwEDX3bAR0UsI/Bj7eWjF8usJ/L/bdn2rYtzccfxHwa7KRVTh94X+8um/l0y32dWxseMaMGa9DeOQuU7b5wj+fv4AzTi3mN2bGKcRnPv2xmw88dGh54esv3fThS79482WPAsO6Ezg4Slc7sqd8D1CFNsFAUV44u8A9pdBmBKrzmREofO8yAD2IszGg/CAVQr1ZcnEkUhtlu/UD0E3b5ewfnYgwdpWVACLeFpdEyZLGIVR/z8ZPxnVbTYKIeLS8BOt0s44iffCExVkmW9xAxCHiYqIgATBzII6E2FzzehGNgKDBFiRb9/CiJpINN6OYoSqMZcmBXyCgz50rfIwnGwuqYC+6i1JmjpoEi6Xio1dADZK8YjiXVEQst6E+zgR8yU/c1bUNCY6mQPuhf+Vc8ivkxK8d+wpYIbDFCwR+kcr0crqO//38YStA923H42szu3zOmDEjIv9WCCC46+fnL+OMk435XZlxUvGpz3zsxuXhy5YXv/XCLR+67Iu3Xf5A6KcYBEBosmldegpsDbzezmkia0LPwujxjqr37QTAV7W24g3ipKelRHpILYthuCn3fygn9LgHWyBY9zQVxeJWZCaN9bHySA6MtMaQ1WNX2Z2Te0uA2UcOD/NJ5SsAjtQFp/Y6++gLG/kLoXwWHMvIM2QRQkJ2F9esRrAw4rtAIgnAXkOuAjdRmJhAsAxI7cqq6yzPNcRHuiDyBgIzjeoCeO08mMki/FD4KASu5ppsxAJuaizuWIzjySCLRyogK5WZTpHF4ok5m7QKJxjEc/PTFP7z50w3vbLw/4rQf80rji/8bx7nTnwfXeHiZ0L479B/dZunJvyP4zNmzDj7ocgkr+AvfmH+Ys44ccxvyYwTxG/97v90w/LwpTsv3P/ym9534O53XvX11ASBwuUCjFJdJK4t0C80hFsBnSG6Q1Y1wQHLCFy8YMc4v2pzkWWy7oW2Cd/h7Z+FyJM2OD0zqDxAXprls6GjVy8gIvtC/GxG1KxENmhPPId6tTbDkytjAKd+nyW/5iLrImAHqh1QOKyMZmv4WDPgL+LkXMq5CJMD1MVDRPesZg4uAUkATUXfqnNoPB/lw4lznFeULPN1ZWKnSMViEE22IKbh24m0Q7btl2xhJAYVVxN1wAwB5cXVfIGE2C8uYp7MxH3JNAVMfDERxzKIXBQBbyv2PY7wDxDib2LiLdC/EgKkaicQ/k+8SB1/9cJ/3eY+ZrLteC2+TfjvvKJvcgr/M2acmyGACvYAV5jiyz8zf0NnvFLM78eM48avf/qnbth55PKd57/18pvee/Dud171NxoWDx81uYkYWIU6WIEMblAIgxWEQ9qXpusDoLDtKIONFLAWat5kF6QEKIDFutq2vUK9zB6gLZ4A3Uuhx0ggMMnQhP8gKuIYM7xoHHKmIOj7j71p5y2e+Lj4AHzkHzSWGGuWnJ9sASQVGOb7zCRIVl8wgeCjkX8CdNBaAwmRSB0SE7sckOgE2lX2rBAgZA/HjosIDAvcLa1BolDL219ywzYkeal+qeGGiuQAYqns/pnivUV3UbYBjdoAVM9TjYKHqHYAYg6AmLvIYllEoSVU90QQBtpeVaFsFf4b3gX2AfQTCP/H9/xsEf5P0fPDDfSXtgr/2709su14rXzSwv/s8jljxrkdDlEc24EezdzxnXOE8IzjxPxmzNgSv/7pn7ph5+HLdl64/8U3v+fQV99/1b3LYhjIGAWRE830wtxmyCmSkHhiTQD29/tvLKLWKRwfunieL+2K0f1maPkeenYJ/6wESOiZuKwQXmreKGs+i4ATXYEQnEiu2YRcJNtl8pY9pokN1pEXDfRcNp54S7r8wyOUg8ZCmOcVa3vMRQD02dM1BKJ2IPMDjfNEaW+8UcflSAyMQBxJAGrMcJYXx0e8l+UBQVoWGCzqd10hzlLgAPSLu6djJ41AURqhHsmBLOEFRMcYL6i5i7B5aDqRlE9PgCVcQwYoalKYQpC1BCaAmoBv0S7858cCbHH2v4piXyLv1ffWX4k/bDnei333AfcU+GeXzxkzZpxClK4DAJMGzNge8zsxYxW//umfunHn4Ut3nr//xVvfe/ju919976I2wE25X9JIk39oSnhGg/iDAJA2DBAz9PvEIo7C2ejMoUiFd9tPAXovUJWn5YCtkuGHyR6eNbJU620InITalc3o8J03DoCMInRxCIxTxko/jtXEYVJqer1KlhK2nNKq8+cA32WjRzr7E6CLBTJLz0zCcYjC8ggkZybUOdISFynwp0IfrEwEbaxYy4EkQ5AYo6YWGQDVrEmwlmnRSCZoWJjgasqiAhFL1T+VewcMCtYtRCGvB6VJB/+SeQZXl5iIHDOGxfIWIKJmKqpmUtXMgLgsMGdhAzMt2Or5EbLRlfC/CaBftfAfx9etfk5N+N8H/XOhVyP8e1sBdbOvIPxP6D9jxvkYpAEW0pbirp+bv8IzRsxvw4yM3/jUT95w4JHLdp+/78Vb33f4L9979b07i6G88gCG/z4O+saRRAxVI5sYPf1Co0AWaDZ6BGqnRx+J0YViLSjkD4IBlO85lW8fCYTSvwcnIe5xCMRCPSUc7OZ+IQI2shruNlZWKqbiEDf3sQEJrOydt+SW1AFwzi7pkLBrJ2eBAQOgVzOlhO+8/SoP6C+lS6eIRJvhBSANNoBT/rckQpxwHCifU5OL3iR85xivUdcrWfAAZ+5iqUplvj1rAzLtYMVMcpHmMgqWohauqj1xVeEeDEvelKuJwijquzhYA+AU/uOiruYCrenI2Frsi1cn/Pdi340ag+MU+55A+N8A3K9G+O/Qf2Pl0y32dWxseMaMGedP5C/wAg+L7aQBMxjzezADn/rsR6/Xxy7VF/762Vvfc9lXP3DNPaqW4maT9ocymtZ/9w0jPl8t4b+hfK+lBI02NGeLp9BaMqcUniaKzQzAhnEolnXqvWUEKmQPL8DHVIMT8tae44rolxNKxftcPenpL7QUyvqgDYnU01M0dtLcRHGOF+wOkRvlXEpOIuXbQVjk1wSgwe54YuzyiXqSWpeOR2GIXqI6Dpb1CGrxAZkCMImZACoQK40/n0mo8kD05AFTFlGpjCWzBFnm6yX8U9FHmfsBcVPXqKbQfAJYDHQiuRhEZKHnSqL1JzyhfziCMGoPluCH9cluavMgvVxXCHQYPbt8TuF/xowLJ+KPyM6kATNGzG/ARR2f+uxHr9dHL9t9/m9euuVdO/e+75qvLdH4cVOG75A6YXrihob11xB/jfIDdHmpnsPSQ6264f4S9cc6A983+R8l/CdzKMKAwmFt/VzKE2GvNP7cOWsDKBvXdXMPgtHLiBid9AOt8IDVzEIptprl17az4SmQqnljLHE5BeA2KIqXmB2moER4wrlXQmM9ElWDC3pcDjluzOnOj/3IoENhs5GgN8py3nhcHhi9aFLcZqQIqOW7uC4wmMeTCavS4vBqT8RqXbiJgeW/WKoMw6EmEFtsNbJAxBZXDf9SCv8QuBo82gTxSBCzZb/w3xNB2ED/m8D9FaH/mlccX/jfPM6dxG/Lfnn+zAj/HfqvbvPUhP9xfMaMGRdIFA04lr/jX/rF+Tt+8cb87C/S+OTvffSmne9etvPi/S+9+V2797z/mnuWZa/AuhRq94YkCnYnoIlTBzGAU1lcpwuG/ycLYdEgMiimQuh+caqPiVo8JuMOI777QGxE/82VjhLR82BsvlIN6Bp/SsXNC+Qd9gU9GHI+pX04hjkHtfP2KkmU1oYz8wAAasR53lbIot64X4/yYiTcF6SLJtTusv3k4tkLqBIIEK16gKyOCL9Q4HLvGjwtOkmHwrMUs8PYpZRFwPHooo+QJd/g2K981Is5JAcIRGWCuoubQMutVFUNWeZrrqpqhijtLQoUS+3FrkwgS7zdAGAxliKER0iyxkAEahZVAZsQfxMTb4H+lRDIv40nEv5PvEgdf/XCP7/Aa34yYP32hMBW4b/zir7JKfzPmHGBB1UzIArFcNekARdlzE/9ootPf+6fvGF56NDOS1974S0fPPSV91z9N6qOFLadkLdUw66IF0zH8QgACt8U2GoEAHxpCOGFwqm7UhF3Xy8uDWRT5eXwAaqVQS2y8KCQUP1cfn04FXEJ5hClrj11QKQ15N4S/pMniFTfnhLFHQjUjjqt7DqJpHMpScf/ym5UXh2RbC5E+z6NT50tlMMnETmc+H6YgqCe9pvMAPDVlnBwdZYiIPsU8YQs0o0ThIPGdC8fSNh1YgIA8wao4cGRbVDmSRKdwxcLB1HYftK3A5HFIDBdVzMrS4cXuJpEdfWSt1DpEVNoliikH8k10iNYC/8N7wL7APoJhP/je362CP+n6PnhBvpLW4X/Uy72rQ2fhPA/u3zOmHGxhDtcoDZKhL80pwhfZDE/74soPvOZj7zpwCMHd4/e8+Jbf+DgF99+9bdVvdR6Twi/hvJNKY/XAiJDJKb1pjU/ABCbvjdBnf8kAfD+kg/ZfrQEzT6YzqtAiK3JNwoE9zxDv1wD1paAhhad0OC9OX+GqF/kpGwbKYi22gAWoTbnjzQ4PhZnvyBQ+BcAYpYJB7bjdE/CQ+m9cheNQqS+btHdVDg8Kx5dDtWKnbO5fmj2XvA9ADFc4JEKQDXl9D3E4K3kTqNmAO5LpBSqdCFLeEUtKiOSP4j4EimdlhaIG1yGOi6h8Yv5Qp8Sgi0gML1JzBK2LJ4W99D1xUTcFhPE7DBnniHTF4ZcITefuQuuzy/J6Wn20pnwepFN/rDleC/23QfQU+A/u10+c/NT+J8x4+ILjy4dO5C9/Pv1xZkNuGhi52xvYMbrEZ//zD9848GHDux8657nbvnwga/+0M3/BwBgAIWEAe0tRPYApf9xSp2XP1QDH1+t0VaQIAwoi067UJ04zicS3tiJeFUReH/jvsvx9Dyt73V18ehX6XlTaQeqH4oa1YZq5aIQIvlgeF8OEWFlQh0PfuQOTcHY3Fm0kA8oOqvCgqoUvalHkiAvuwPVQwj24QIRzcECmS6xeoYuDuSruVnWQFtJyGKbT0gACyKR6NYEcFOBGZS+pih9FnNXwGMgsVFsj53FylZfAIkHBxOJFnX5uJSPJR+xQEYXVywuUSkRXBOcAw2h2E8uVw8T4uYiNROgAeiTdvyPbNJxin1PtsunrI4jVhHOlGjHjyP8+3GE/y3HQc9PffOb8C+bwr97Pz5jxoyLJ/K/YHvDEXTbv/EXr8V3/pP6AzLjgo35AV/I8bGPfeym655702WPvfnaJ772zFt/6Iov3nrVQwC6Qk9zTnXY7MI/UKJ+1fvmWdJGARRwWQmrZacJxOQNC483CuCtIHLYdbr8P8qLUdJ+5g1o7Al8XD51wKm117vgBawl3+gEmqGUp1CNqg1wkLfQdVPPqhnoo1Q37jfAFrLHDjx7YkqWIJMbxJ6lsD6yrtcdks1tMNICvQQ5Ma4rRlMggGZ67pOyPUV6fqwxK1cMCkPmEFDCvzuio/+w/ueXIXIOojCESM/u/ktswBxRd5uTfXNYr8DgS3p1WIss+UBscRExiv0SE4XHxLEY/pU3LhojBTLDkD2FaDqKGgBbLMC0iWjUDGgH0zg54X92+ZwxY8ZFG2L4wsfxjj/CVd/AIcMff2L+ZbhgY360F2Z84jM/cUSeufToc3fd94YPvvORH7nyi9df/mQJ8Bj+mfTos20/5XASgFB5xbuVv8A9DdDE/Ty+IgAppWdJ8ZobRE1w4enhnm/Xzd3mu7xzA/pqsrdPh/hZbSyExXXpwRZ87DyhMxrH4FMKjA6aoISuoaY3e92C1tNIdpGTsyQqYkFr/tgJkbqnah8CtnoxkNXl6lPL4cHl40dC+bDLA6zBJc0YzqVU6PcEkiYivqRwN1kyQSGh6ouo+l52N0pCEqTCAChE9hzR61OgJoLo7RPVCEE2PK1KLos5ROuIthkCrC2WxdKRKuQwGjXH0Sgp2goBcCwQsRyCFnXSS9Ew9ygXls1p0/zn7PI5PT8zZsw4bjiuPIrnFMcANdw5acCFGPNDvdDiNz77k9frw5fsPHf3i294+/KdHznypSsPP88Xh+bdmYAMad9XCL4lBzoyTpi+jwC0dyXUECJyFAEYnWqAhCOCkJB7wXHEODIc/+XPCZaSgE88MTqQjSylb5jcIDClewdnCfQbqegNf2LnoWEPUpE0I1VztD5Fg1YNSZ7MwWEiUoNvq9o47iUqYsFChZGCEAmF3uBSSZKqshXJ9pdJPIYLP5GsuMNVYQnr+ZLy4QddUVcQjkeZAYBWzstGQ87FY2Wj7Z75irxfwWKAQM2Y6Bi8RVnJsFhxMFnc3LHkEAP2+nQR31OXqAxOquCyeLwdiOJgIOuJwfxD1ihHEqllh07o+Rlfm1GVu1X43zxORO6VI9pc/EwI/x361yZPXfgfx2fMmDFjSzgcWI7CDwALZMGdPz3/YlxQMT/OCyd++44fu2l55JKdl/7qhe95187dH7r2nkMHXkaiY2DI88AQuQFW1uZhnlMqODqm38gDeMM6zTGPlaSNRjyYW2ByoI4MS1Lwg0C6Y28Fo8ugL6vLiZdqDurifGm/K2njcgUQ62kMkZ65C4rl+RDE1i2AiNW0iixZfSsBKtmtP1bWIlqe3IjNNEcDH+GZANTc4RrPdfAHV6HpxaPJpgsEObQrCguiJ0/UEKNsMwizTcn/I4sCtWAdtACxE78yyRCPJW6TPYjqJQkHjrjnDOBsz8+JwiHnA1E9DPb0VLecEyxQCzoHhS8myKV0jC7e8wXOGQIqHq2B9sBhwws4xpjNmhRAjlao34X2w/GFf+TPJzIOnRHhn7B+zU8GrN+eENgq/Hde0Tc5hf8ZM2acUohAdrH3MswAwZc/Pv90XCAxP8gLIX7/s//gTQcf2t059pcv3P6Bg199z5H7l8UCWAeALfsNRf2G75kTQAKJgdpln+hO/R5pdifYLdm+HESxuNXiRQAwuEHlIjYwuuyrBPACPURqZaDnrtwiHZCqObAC90NrrxQEb20kGSpfQSgPQnkQEOceYj/07lNox4qxDBNOnFxOnkCxg344vS7dOEQd3UM1b6Woma9ojfljGldc1KMGNx44xwWIZp9Td+r3KfwnjAbcFeJGUC7ZWlRq59Htp6iLDU2d2QmNob/RdWexlOqrskKNlwPnA5gh6IEkf1ARmC1OVhO9fSzYVNAeAL5kO9GEv+oitgfI0loeVSlCfckV8Gw9dIqeny3C/yl6fuL3CauXtgr/2709cpzjWAn5JxT+Z5fPGTNmnFZEczaBAk+9A7NK+MKI+fmdx/FLd/zYNfLczbuPXX/gqb98+m0fvuKLt179XZQ8SVeKZ/0uCmqDXgf65gnoCyIAMtIF5UdHwlZPQLQiAI1IoEPw1VXyukUzypwzFNbONxLvein6QoTd7UZxTt5RKeuhzVN3Z66gpP129WBKaVAZbIFuH1RKIVnHahEFAoNm3sPH3eVbMKp1pWH9UQLhVfaarCYgMkTU98a9GESSV0Rbm9pwkYSA0Y5s/C+sQND2wNVdoAITrzpaYVWxtaqAUP3BvqLe5pS5uJJUoL3aqpY9a4Ibt8GCVrqQQ4JDwg/5H5AA98iCYAMEi7m7LJwFhrAJQcSg5pFy0bxNV2PRsJsCmVpJalscrGv2JLRD7D+OwL/1eC/23QfQk07PLp8zZsy4YCKqhN/2R7jsG7M84PyO+cmdl/Hbn/mJ63YeueTAc3e//Ma36cMfvurL11z2bIr7haQT97eJWs2rIysADVpfBlsoEL+fAMSreSnvI3WHQr9JAKRVFFBERyUluPjG5cp+M6BMISf2ryQZ8P3uHRAWg/eemn1JpKjrCvMV65rRTCCQgXToT+NQ7rleFXF3N/amJG5u9Kl65EvWVw/+MHgCzfrOCWWaTCCqEQBDCfwsHhjoVlpagN1+aj91mompoCb7Rr8nJgQGWwgoL+LZKDRsPPHEItdRFcCJv+M5h1WJqQkIllFyHR6qKNVNSrC4u+uCvRwQZsjhZRBxi7ZC0fuILY9k2duL6gtxU1OkxcgXQCymnhV0jiRAfYInXex7sl0+18fjl2sf9K/f0Fcr/MfP4xfqFYT/Cf1nzJhxZkPghuUofIEo1PHnc3rAeRjzMzvP4vc+9w9u2nn0kt2jX3v2bd93+K8+dN09B3ePNvk8Mb0QdqfDBJkBKIs8Ty41keq1+0bjlEoRBCJfv1rsIk+TsU7TLAnNS6G3gjXlwCm0NI7kvN58tTwzpc03MT5gTsOXxUmiX814Ccwq0D6kguaxKbMQgXi6qIo/5KtjbHDD3GAvUUd5bLKYteUEgDC9BHSOj8xFyDc0kxJxFb6Upb1GeMqmpYHprS5XFCLBdxBAuoBUYbFzgnsRh5pxV8w/sAFoGPQXg0sW+Ga+ohUxJ1WAC6B7Jq7xoNRF3DROkKiOEDXnOrlCzBFT0xwDnMUG4mbiuriLmDg03pv5H1ngYi4WrAD1KNRdTBZADbqqfkGVUwvcoZG6WYnlkaAaRrUV9D+u8L8BuF+N8N+h/8bKp1vs69jY8IwZM2aciYi0+45hD6mFfGHSgPMq5qd1fsQn/uVPHfEnb9p99Mbdx778zO0fOPy1d1/3DVWj2N9tPNWLJBFAc/An7hhoo1Rzit+BXNYqeEr7TmTRNHuKiywp3mAUdRVyAycUbi8B6NAqUKl5nTPcSoNLrAiANABE0Z2MJRYfRIIsYjyxdqTyBtg0Dlm/LkVu1hsMu5EXWBQRbx6bfGLDlgPafhI9k9Wkms6cQ/GQ4WVycZVxOXpvPFV5zg3IUcFubNwJi5RFFQlkFyCO3QVieLCIu7opNPIA4gIzFcA1OvoX+YleosrNkPCEIccFLiYKT/O9u2BR24N7aPxanxetROquJAbB0zS5gWcbUFd1FyYBFkQ1AtgyyKMRqkJy2LBUEUiyneixqTCPjqjHE/675+dVC/8+fmuA2eVzxowZF0y4QwUwuEAOAgvkEtz54/PPznkQcxLwuR6/+S9/4jp59JKd+79y9K3XvvzkzZc89qHb7i1LTyGR4nL9147Vh/x32UL4iJLrxI1TiF3SUVQn+8aZ6ZShrWKs6KvrDnWcq7RbqC15vXGkNuIsJc+RTD5I4vWNNZDpikDYgf77timhspGR13V4fu1fmBsAhpHJSx6OJ2O5QMqxeV2MZ+LpNa81UdUFMoqwcy+CygnkOtxAoknzNF/lsmMIMPdAZCiCyIFAc1Prgu/crASsF1ZFKwA2V4WIwvfacxE0TpXv91gzMxhwCFTgnLkWfi3zaMUDjzKHJZZzh6u4BQG1GkBWKwfTcVnSpQY3EXW3RRGP3sU0Pm5td0eaJ0grlzSpflTlOrNY+7T5zgNlfIWYmenyvJ9B4d/ru7RN+Jc6HnvbIvyP4zNmzJjx2oXUf4MAvAS5Fv4kPvgvXDF9Qed6zI/n3I3Pf/4jN+88dPDA0a+8+PZ36tc+dOSeSw+/JB2yF76huX8A5gCOXuK4DOjZMWieGXCjjPvjIIbKXqkAgj9vIGaI5aNPaIKbxPidabSeNt7hb50mhXhk/CtxEst2Q/Af7p31dc0x1N/h/AG9K5CwyI+6CGmYO3MOzsslcGwJBAhVeQO1fMrwkUUJs42GdT4GKpeXqf3PPccAQyzBIuf+xkhgb2ak6OQzAGilIKLLpwBtPu54zkpFuYvlGFo+qMEbMgMgguzxDwzTTs9IxJoKiBlC+Ben/E9rEKIhD8T2HKrmdPhoWLMWc5Hw9qi4I3r5my+AI9v5x+e8uMWsALhmtTEQR3KKsGEBa5fdeEeerUgh3n5ThC1BCbK3Cf9dnj8jwn/+Jm4I/8PPsz0hsFX477yib3IK/zNmzDiLYQYV7DiOCZ74Xrx4HR76YWD+OTonY3MMQkYAACAASURBVH4q51z82md+4sjOEzcdfOz6Q0/e9fT3ff/hL77j+gfD7UMFsub1rghA6ZNIJEexPOHqsPIXE6gS24APA+IT5g40TAqxButULRsBaGW7oaASecdOBx8grvLaZ1X0piRbNZqDS0iJ4iIFxzFAGDFxXE7KFjVeYrLA+/lgxXBJ2oGVMTbAnceCyi11T5G4s2ZA4BB2qSde93FasQXWOdSDVR+8ZZhtLDxFzbBk1dHSo1sOewEF6gV6I3wXFs6Orj5wwEVhEmPCVjSGZcrwmvyVDiIrFpEshYxLNIqAgwaQhyz8IuUR407ElLML1KtSwuJyCsCgElxCwnq0mAMxqzhuc29xDUahJmKjdEHSSgRlSkXFSilPS5KMb8hJafOvAP3jm4zVS1uF/1Mo9q2VT9rxP7t8zpgx45yIcCjIgrt+Hm/9I1zyDewZvvqJ+afp3Ir5eZxD8Tt3/Pc37zx8ePflrzxz+9sPff2Hrv7qNZc/48NRUz5+EoBU66VeRTnO20uesvyKAJQGj7GUoBavmlcHUTgGxI/Lgf6WfXb/lkAIqIo1u8jzZVyl0hFEaR7mnpYrwOauBtzJDfgKapey62OA13gpn2M5bWIFpeAa47Sa7T7rI0TyusTKjUKkQFtlFYTv7uBUgbzBEtQp/A92Eaq5DU16TRUIE7OIFnALMTvvJRmUt3qD1njHCZHdEMI8V1b+4An3Rc0gOVer5yuiwyayWFkk+x05+4FiyYtCDYgiYOOzJddaHBCojYnF2SwoJvjGLLAs9t2TqA+OWzBXhVjSmMWragLiInt7Ep1/3FSWxSwfIBky6WXCZa3GoMcT/nux7z7gnl+hs9vlMy4xhf8ZM2acgyECM7x8FLu7UIUovvBz82/UuRLzkzj78S/+4J9d7Y/fuPPYDbuP3fXMO77/8F+++/pv7O4cAwgCkgCEIns8AoDA+eboPpx4W+HvlfMnPfRDrU/o0vR4KVwObNX4B/LA4AmdABCRY00ARp8ijzzDCvIGXOI2mjUoHoI0tZ4ANxMjPV8xUgeJbvkwh3mp5RB49SJRIzPADENbKhgCgDZFmPyBvh2FiJHeBDcI60v1wie29uHSSewONsNBQ/OJ8JqxJ68LwBo6R5uDK86GoaLusKHls+OQaZhqnPduDqQLKNsEMTOj0Ywo+oqGjm7cCaBW+8wiY90ziKiBNKymiTny+eTPSzEByAKDKdyX4E6VbUh24co9BIXI/Ibtae4WNTNh6dkP5LPKmoH47RDR8d0+ReF/dvmcMWPGjBNGpPNlge8hNCtTfPln5p+ssxzzAzib8Tt3/MMbdh49fODYl45+71vt/u+//K9uuebR1WcyMGuq+1sJgOwX/mnWF2mqIQp/p86dKDyXqixBIPLBDbZq/PzBC5ej0FJgIx9rMqsQZ9BI4yBEXhGAuvEyI7F+QHzkDVaXgwjLQ3Mz+ZL0vIGM1epyBffXHpu1qUn4VHMd42Zo4GleIxTFqpFYVecgKe178/bUwy/rTjUFEvbirE8fva2QNkrARMG4BW3plGrqPyb4hncIYQqCc0AYbC+pC2mVcG6xOP0/efV4kuntCUe+5HUjq+A5LywSBZ7Eb7Eq5FB1r+kBWrsFFoc7FmSjz0rjLNk7KB6OC3MI6uYxNhiyGNxcRTRORnIb9UzlSOJy0fqiIp7YNuF/A3C/GuG/Q/+NlU8k/KOdQ+jPhMBqwzNmzJhxroYZlgXHdqBH8z8td358/u06azEf/VmIX/rsPz6iT1+/+/gNh576wjPveM+hez54/f0Hdo9uPTmdOfGzl8+nXoX4WiDPo4S8lBm9YAQRNoYw30t1nV4gNL8Q5fxGGLYTAAG8amSHetoZi6Bxg2IjYw+DG6SgjsFABtxnwsHTZRQXFu9cBSNLEMahMtXETsbJwyZET1Hp8RhMqfhGuXcItevBCi3yXvi7bD9ExkE8KLrzY00cz1Ld0Mgl2nTSy+QkAO0uJMw2MBlDdgv1IgflWn5DIilR90sbTwjzIm4ebT3R5vWmwC9qZBfkKovB+c9MBUTqwxwyTPnSNwmNsl1xh/niQEz4MlFx92jfaQs0i5WNT158MRHYYmPnUbjMzbtGTmMv6yg0xgIAkQQA8pNad/90SNxsfF5notiXn0tLjqGlBU4k/OfvCLDf2T+F/xkzZpzvEX/uFsCAYwJXHBXcM61Br3vMJ/66xuc//9/dtPPI7u6xO5/9nu/ZeeD9V9x7y5FHT/CeYadJzwxRe4KU5uopAlCDtwJYbCUAtdSqf44TaK/E/qaIN6qQw4MHTtpGG3x1cqzcKmszRZBURFa4Fg5UNXOp9fUo6kzq94G5+dIAyqssRzsYj0Eqb2DJtfItQzzmXTf1vUT32rPUTsLUxPxDbZK7ajO8xNtbRABh4YGwo3+yBayLClwkJ3MBfQxwDf0t41B8LjFxrGboBsSvPEY47z3tWAExF0/XUNADQMRMXZDWo/Q4VdJDyVjUckizZEmuLSYIs5DETmQJ95QFZM9iYoXE7S/ulSoRl3ij0CakLmz4QxOUQNNKFCPAHIY8Pxw+4i2jEpXBIvzqptMpyVLmc/bL82dG+O/QnyufhvA/js+YMWPGeRqREHhOcWgPi0MEd/7z+Wft9Yv5rF+P+OTn//ERefzGA48fOfjkXU+//QOH/+r7rvv2zs7eSb35+ARAUgIvgbwr5SgsG6p+1RLsywBszgJrl1639IlK2E1kvyIAUvB3GwEY5vtVvoJ7HnmDNNuMeb3d+ROL036TpvB4TsP0wh+Mtzns+yM7MbIKyISJY/iFSrZHTxdQp0/G0u03vK9Y2SGZkWByg+b+fEvYUVxjhEqB+1wq9xzmGRVYEADNrEvO6wWrb4vbxNhdMWcFAp8GqwtEaEByGuiDQkDE3KVqdkNEt+jbg/T9ByI3gaq5S9TjQlotspASpKtnpBeSw9AdxKJkCACmBSDuUdoLpIMo7ytmiuXN+sL0y1KuJ/PFJSuMjZPFADAvEZ9jlUbUt1ohiHJnaVUopyH8F3dekdgB67cnBLYK/51XjN/ZKfzPmDHjggyHCsypTAq++AvzT9xrHnMQ2GsYn/yDj19uj1y388g1B+7+i2ffee2xJ954+SPvfcvfnJHFu6Vm49jqpIQXI2HAw/nu47yJr+YCkj8G7JB1CqL9UKbkHr4+4n3TtT1P6xBpibd3iWR6A/F3gs6cqCoISiJJV2pv463jxsmXkleQGxSN4Q0Gp/A4VLjNSzYeOAykXkGi8pzVU4mfDZxi5ojKU6YiOCOs6rYFMLfauSSNiQEAwVhQ6RFFv2EXT2gbOQAXuLPyOD5ACVrFD1eY2QgQG5uvlj7g4IFYS4PA0C2vRfZE8zE6vyExGJJgOj6rGPAsloQulfkYbhBSvWdtMQAxYm3kp+/5AbkCPqoR4DU8GJCswFaBA+YkGCS3Ku4Oh8WXTlCpI94499zrd8e/vrLwj3xW60Vk2/FauRiCrIT//eO9vB+fMWPGjAsnBAaYYHGYQhzv+1WHzFrh1zYmAXhN4nO//5EblkcOH7jr7pfff/nRR2489OhHb/vX1Sbk1UehpOO+CgANjlfZgBCxDoi8Wkqk4daxXkLn1YvE7o7VCzzYdEr3gZDin8RE8caNa77iYxrMIeB7oP9NJhPibGJPKVCOhJ55R3ndgZ+LJ8nYVd4BoIXM0q7hUi3863mI1XISDfhB2BrP0NmHvmUbIGBht2ti5dyCwRGwNf9EBhfKcWCZ7QgIm2g+P5FMUBSCDJk7VgPXqvoRQfuA4q1pvI/7c+HMZXUnMkfuDYnljSUKyZYw+I44BLakAyh9O245CRioQWnKW6sUTSWu0HcYn75AYc4vkfLSQQ9NBEgeFQ9YBW4s9g2pKcxB4QJCJEDyNinwb/P8oJ5YOf7zfAEZy6Ad49MsiB8f0BbPj2NFP3iJKfzPmDHjQg/Nv9UAoI5jC+QYbv23PqeJvUYxH+iZjE/d8Y9uWB678eDjVx989k+fevd7D3z13dd/83jVvScb+9w70gTyYbsHCiuhedxTJSW+BKim8iUf56C1BA0YOJrkQDbfSFRNqd4KxKx9DoGiuKV+uTTf+1r4bCu4OzVpacWvdaYU0ASNN2sbD+inH1b7fGPcpvMtVaS7KoyWAUyJR8MxAvS6Ya5fqnnelNbl4iqWDZ1aIW9bIU0vAnCebjyHlLohw1OUuQD6jmg0Cls8H11uIJw8yXOGtK/wLC92h2MZDwp0FgkANcs7RVp64gmwQtcRdbd8/uo5xEAcCwScOpwXjZutLXm2/M9CXpZPLIj5Xy6i7EDqYhz6m+cowkoU/UBdFofEDXLAs8LVJbqIBjnTLIqAiITjv9hLvNezQiBJ6xYvEHnvhvC/P0VAln78Yt/43mIl/M9i3xkzZswAkFlujWli/wqXfQtu+PL/Mv8SnrGYj/IMxKc++9Grlsev333s6kNP/enT73rPwb9+/9X3X3bp82dm9TUBoPZPwTjPSeDIVwvZh0SeBCBsNs3UDqqqae4nkfAGwdt1eeY+AlBrio/N5A8+7PtgDQDKMc/0QiA2+uy5DpV8EF8WmA58xh0meKW+XgaPqmFIHDZ+SBk3PesoGM1Lj/O9XhLnsCrUWCv0Pp4xr3dFq7IM15xsJ+C+rKt1g9ORz3jOBKghWWQsou7RVdNr8V4Imyb7YBd0xrdSYGlrBlBGtNmR6O/J8oZ8u8L3JJro8zYD3LPzZt2pqDmAVjesYhYgW7J5P/sjAbLn2v5VWSogBnUDVLNsYNQJSJYpRxWEu4lKDAAe9GZxATyqmTlnIEiLButQBL6X3Aa/dcP6j2AFECT65/fh1It9B609KeEf7RxCfyYE6qUZM2bMuAjDHaLYOwZVqEIEqvjzn51/FV9tzCd4+vFrn/voVfLkdTtPXHvw6Tufee9tB+57/xV/fdNVT5zhh9oIANEwthIAaRW9hcKLAHT9HtlbE4VdKJajrTkm+MpKUB/vItIlNioCUD+P00a+grifKD/d85vvDWdGWe2R4nE9jdrD6A7ka9JSvCiRWevbY0ldSkFHob2t0wCqfhd1ud5xaMD0YhRYLc7cAlX/LMmlJKxGNoJRrQtAjIq+eIriBTrZbzR62kTeII60hEBLevCgusMUsMDTIiGZD/SP7PgZj9rUNXYoEDUDfDFBaO0QNxNA3eC6wLNimHen63pf5MQuW1yQWQgIovkP1FzhcBX4gkzjaDwBM82nIWJQ7MF1galpPJPFHSYiHnp/sAUJow4sKJAmTUJ9jWv+cQP04ddJYobuBdrw/GDjy4mTFf7jG8gkwOzyOWPGjBknHYKdBceOBYiA7uDOn55/JE8z5oM75fjkH3z8Env0iD52ze6jdz73rtv0m++9/L5br334DFr8V0HIm6p6Onk2CUAZgVLA7gSAqxT4pvUlX5WVJ6ek8cEWMDIJaz0+d+UrqN3yANnmshEPrz0wm9G67qzsQ40boO9n7GRI5swhoNhFZRXozxkdhOoWvKF2+NiSoCb4pkUHpQ0To5OxDGDdz6d1inzAWV/rCU95I8UcuIHYTLf9BPovBjJgejpqsq3NsMrke9Ul+u6LO9xi6hZaL1HxbPnPNaMPTzGQksmruygb/rjGRx/uncpFRN6AsD4geEjvKuZwLO6RolGomNEIZOJQYHFhF9R8DuoiZksY/d0kOEYYjTgHTXMWgeWwM3GNQQGsElaQ1XjWQWv7osb8ssTj7lGeHTQvshOG4gwnIfx36I/TF/7H8RkzZsyYsT/csRyEvZwNNnyZ5cKnHPN5nWz80h0/eRWeOrLzxHWHnv3iSz943d7X3nvovu+5/sFlsdf60gl5NzB6IwBScH/YbzAaaNb5gadXYn/5HwDU4lXVSm5AOb+gal66EwYUA0m1XijtA1gt4rRJoCHpNQEQ1HE0fC9lYRriehKPJrJWuoCngZAXPZkQb6T1CE33dWYbaASSZFg2pgIzPVJt+8uuU+yrT/CtyV9Ihw8Kajd2MRZRAHQcaVGCzlWYzYhWnmF8D2gerWxgrpKXG8mK2ECkDkSat6eRB3M4+F5akrgrtfGFTEdQJARATxGZw+IOy8tlisANpio2eoA6ajDZ4i4GiGimNWJQQNAPgVnkK8JoFP3+BbxxY99SgVqQqGgVKgqIRDMjshSU20e0iKhki1VxFygbE1ni9dnlc8aMGTPOrfDsdbF3AHIUewtM8fJB3Pc/zr+fJxXzMZ0gPvkHH7/UHjuij121+9ifPf+eW+Vb77z0/rcd+dvdk+zif0ZiA6Oz0QoSo3ftfzCBTBlgEAavN46uOImGsXq797c3wlCApvTOQEUN+tRW1ymIUVRAztISEZ02gFi5Xa5hdBKAxiWkDCdwd/GB0VnhWgQgEVi5g7rDR1BFqM2GRHCPyjAMR1CmFFwyb9AriYNo9axCLWV5pwqBOSSKg/nECIvzh+giU3Z/pITvWaQbJbadFQTxyP734pkBEI8+pKMeV4TOe0ca9+GyBwQZkKjf9dFN34aDqMhMH0sMx5JWIuOUsTIOVU1CrBBvt8hpLAHc0z4UIxFydIAaxM1NFhiiUhlYnBPNotk/XC0rB8RlcQC+WN54FBhUG6JoQqSOVPojDZQsUSBZ+syvX1Yhx8n5RT/JYl9+mU9e+F95gWbMmDFjxkmGA2JwwbOX4/DzkKNwx57hq5+Yf05fKebT2R7/6x/+9FXHnrxOH79+95m7XvqBG/buffehe2+/9ju7u8fOwm62EgC+BCrWPDBQuAz46x1SB8KWfYp+O8ch/aV074y0g3cdPQlDuW4kUfuw6BBUYWxgHJFS7qmSDtZR8Bcjq1BcAsOQk4yl6ehO7Fs79wHoC8/FkYHRc4rtIAnwwvTxRwYYpvlIVoyd2IoAOG0nYL6i0HYeidZJgembgyhrZCVaWbqYI2E0gNbz3kXcakpXKPFCPI1y0cTiVSGQlx6MRXmVnAUWunj5+IfQLuoGGekCrT5ITBSEkA8uQlDu6f73bBW1JGNxsRhDpsFA8sbdFRq0ARZjvAQwNa1ZYAnujfW+ImrpL0pGwTLlTAFJFi3kw3S4OpMVkfnx1tKUbFOyKVAD9xvCP0cfdOU+ietJdPkEpvA/Y8aMGWcmHIBBBC8dxc4CX+CCo4p7fm7+ad0S86Gs4tc//TOX7zx5ZOfxqy978j8ee/9tL33z3Yfufdt1f3uyU3tfozgOAQjE2+37wAqFo1B49sSXgiZS4LutWbBbEjQ3P0NZdFLz7KYgH1g/jyaaGRA/MX280cvK0jZMGT72ySPs1Uhh1WpZWoB4fo64gjTiQZaSj0Y6AahHMaxBna6gsgoadIjCfyYcWi0yyQAtPbzfgaTLCEToDGYVaCWKDYSlvm4h9P5kGlqfbDS0yX47/VHQfy+5gVF9m+Ycr91qUJHIEsQVzQSC4ThKaF5PTNJTVBAcbMpJPiAi5sVPFitiEF8qWUZlRfqUFkemHdyW2pvlp0DjUG0ACxymChvlxRY1EpFDcIWoIUkFIrsSnUxV0k/FL0x8r4JQ5aSFSEB51iHkTIB25ITCP1NkmQQ4sfA/of+MGTNmnOmIv+cieH4HB/awE1qd4s6fn39pR8xnAQC//Zkfv1yfvnb3yasOPv8fn/iBmw9/4z2H7r39rOP+im0EQPJfNwjA0PjR7f7hLygovKHoF5oPABRX3E8A4hdq2O7rcoMA1CIdZiX0cVYqhxt7nJbyObMZY0ueMFryuk2YHzg+ZPjKDARExtihJTdYnV+XTvRs7V2NYIwTxhtJADSe8KgBsDqnsgoFzavdp2RJLnp1MgQU+2tvKcBrdMjhHtLbEy6gFPv5kIveBED3MNtYJUxcHCLVwj+Q8eAJiKG5bgGR1QRs+JMsAim6i0DM4ItG/W6CdZI0s+hctAySYCLRvSfzDLC08ks07gRgIAGAeDTsd4kun4Hvo5wgXjLXMdMgb3CBSaQILDiMKFxg6sKUiFQqANy2gI5/Pny4iAY/Gc4fYfugaCU0BP6TE/7RzinPD2aXzxkzZsx4TcMynw5dYEa7KvDnvzj/6l7cBOAzd3zkyPLEkd2nrtx9/k+eeP8bdh98z+X333LkEdXXvK731IJCPgaMjsPANgIwMPpwvwwCMJw/PNLgMlj1iwbNWREbr6/OD6jqm3xjLeTzuoTR3BvQKxYaFWn1vpRg8+QVjqc1CMOQ0xYvl1Hh45XMn8hMwhNCDX54ipofCdg4JwE9wATCwNC5qyqepsA/vCjW6w0S7rNEtfuF8ng9ZE2KElDbPB1H6M3ySUXy48i5XZGLoFJOCT8EflTZAEBLPUsR6qJpzYfBopVQNtKJXIFC0OoTogaABn36cMrb47xQFh+7iovrYtmsM2sPLOaIWbiMFHCTBZ4tRNMmJArjcIMVK4jiAbirhJUoGp4Gc5YsY0hTE0zKC4Tw/NDGxk8nRH1J9F/fLn7Pj1/sS+Y9hf8ZM2bMOJuROMWx69gTuODJd+DF6/Cdi3jG8EV32796x89d6k9dszzx1sPfvOTAi//hifd9z4Gvv/2yB2484/37z2AMPz0IK1DIeCB1YK3fywptJy2I12XLOStu4A1GrzMD5RpC31VRkYHs3XueQRB1qInphww/nP1p+xkyf09ZFM+hHt8KcAffoL+ILKW083L7sDYgcxFjzX3GoebbAeVhL+W4ac9DvzeAhiVq8ONO6YBPrT3sQCDBaEUUY3GCe0J8ASzHhKG33AnQHCtUWiDvpYYMcBs1wbeRqITviMECXNyQbKG/MWtzE1VXxyEgawCq8X824kwrkahbsAXP5EBkMLKQYKlEhHnVEoyyCgOAJQaBZad/c5HFs2ZaHIsZXAFfwq2EqCpOd5AX7icHAFTN68spA/RLlmSgblzUHTpKRGQl8NdvKH8BTyT8j+MzZsyYMeMshEMX3PlzuP1f4dCD8AUvXXztgy6Wu/3k5/7R1frUkZ2nrzrw4p8890PX+7ffefi+d1zz7cOHXzrbWzuJaASgKfT7CEBmBuiEAdYweh8BwOocABhY2YfGv3FdKesL13FAvBA5ih5wQSk/D/cNDKgNntxO6NzAEwqTXdBtD+IzrFF+5is8phCMpWJvQ+OHx95HOWzPXcRjYcns4CTjunS8DLdSrpCju5C1uQNqN6mYY6r6e4OjQRrHqDOVWRd6ijqv8AFSKbSDJbmVRnCnpx8mLou5gc3yo/q2iIfnJ6t7yIpkV4W5y1KXqxJbRKmDwWQBkFBe0Ww8iwDZm99jdthCoLy4FW9ZHDDq9zDNGm5RN7F0Oi3OFqKtHZACcYKaAKZugkVzQhmfM4F7tQByZL0EB4R5afZKPsAUE3K6mUQBRnjeji/8O/jrM4X/GTNmzDiHwwwL8PQVOPwClmMA4I4vXRwGoQv5Jn/jD3/64NHnr8RTtywPXHbwuX//1PveuvPtt1/ywJuvfnhn99ww959kdAsQCjGTANBFI4SnDUYPiC+tuSehan9VCpe3NbGNG3S7fzEKNgLq0H/t/AH9M+00ZjPYhsXbS4g7zZxAneP0uqBs9N2cMwxL+0qQ6baX4j+U/9HX5BOQIZC3pMQqsVCnNSyOkUnorIDGocFAJL00YXoZVb/i1ZBeCm0HTBfLjywM+jTrV7+gavJT9QYQNxGVUvQzKZHQVswkpHEH5XaoeYJj1AwBiEPM0lETDqKRIypKMIqMo2JYTBY3j+oCg6anyOCiko6gzFcYSYi5mi4ShchRruCC4eSB2+IC+GKRZ/C4QXFb4iHAtWU5EvfzO5wCP20/aKyAeSEg3f+ikWNyA5B8BpkwYd3L7PI5Y8aMGed5ONGwWSALHNuBKV4+cCGnBS7AG/utz/7TK+XJa3aevOrwc3+296Ern3/09t37v/fKbx+58unz9XadpuSGyNPrQuPOwMr8AQBRe7bIJGrHBj4OYLJBAFIjH9xAWrqAANepem4SgHHdBFWdeAwdvS5XMHrYYCRxKlkKSG/GEyiwXup4OYiKZowZWPkWX10XKA4Q98i2nuHYicuhfDhereJtTQ9IIWTjurZ+LKCc3x5UulwggA20XQs2djFeyuSAw0Wljo8xwOM0WY3xggNe/KE7diybCLmrRYUxBKKIet/sv4kh/EduIU1NYinDc8Mu7jHBV/m5iGOpZAtYZWs2yIOJxFQEd42EgEdWwfMpuUclV9r3DYu7mIpYpBcQrqQaNZDlztD8iw51WNy4aHzWUX2hxeswYL2Q+mp+gh6V38JuVEkqMKC/YyQB8ldGpvA/Y8aMGedPRLUABM9cisPPY9nL/3jfdcGlBS6Q+/nlT//4lcvzVy3PvOWShw4dOPb/PvGDtyzf/N5Lv37L1Y/sHjgbnfvPfKw0+4L4To29cP9+AiDObv3bCACota+RfUIZQQevw2hUlht6ZgYB8H7d3DBat808Us09fdydFDJu3h4M6N+P12q09OSW0LMfBaPX7KI3EsV4GkT/VeZbDCRRdd1vk/876Mdoi5nr1AyvKsAtxxFqFlgA8Xyqo/CAF8XIRdCiw72lwByqPMq74llmoMG+jIUHfJhLJj2cE7uqMU625PfYWzrscz/V/RPInZfdP+89RfriFVCHR2vOfFAaEr5Cic5d0KYBwME2o8sgLZn6UM+lNJ9z3ri6i7CvkUE5eow0gI9CovFRjPxKLX/MkXCif04KEzfQCxSsT/lLJ5LoPyuGcTzhf0L/GTNmzDg/gxAIwqIwM7hdOCPGzuN7+I0//OmDR5+9HM+8UR+8dPfFP378vbccePSthx64/YrvXHnFs2d7d2c61pYeQnynft9cPccF9+6FgIGAlbJG9mutnVfe4u2JC3f7jfd6g8pXYIWwEwmFvJx+GAMd5xTyg2MM8wyyuz9vf2D07tshAYhf1wHxabbZlOHHbmvQWMrwlrCP6QICRHp7gGgclMA6mYDwxodpx1EtgAAUlqV438xFCay9u/YJrCtHkXW0GqRFAwAAIABJREFU9PaoU6ag1M00RT5z5YOKqVjGKyqnmGWtQhUklNCe3zcJNT0mZy3mMW0XBkVYYnLbagJxsUw1DLg/qAi0mgIBHukCzwm+MRQshpGp5xF1SIB7g+fiAHxx0Xx7JA24f7iILGbOQcJqLhL1ylgcDld3qI5SYEBdXCITotUvFVrUK1s8wVUzDxYlxXDE4x0mtP2eH8wunzNmzJhxwYQLYHj5KHYWqOLY7nnvETr/9v1bn/sfrpKnj+w8feXhF//02Pdf8cJ337Lz7dsvffCma54459p3nsE4DgEgQIxTVuC+OuvTveND2AYwcF4r6l1xA4qX4xJSFAI8jQvS/FClsYbx3mG/CYQu5V/qNxXit6Ar5ZGv8LLmjy5DVTlQeYC8hTyZyYTyn6RbyUXcpCA+Rv/NRjlanoEdP4PRBKyPB6KVvli5bhyoxkG0gtBSjw1/jpvIEPvJc1K0jptKcz8v17aU+1cb2Q/2/Sw/EsQEaYjPB5J4N+G+Zw2AMZvhAnHl4w0ALZk9yGrmyDO08oAozLUarKv0fZEJaCYE8vYNriztTWeOZHdUD6t9DggbbCrk/6hAcDVAsLBiAUFUYk3EeGA2LHKWEefsO1dhX1F3DSRfCQHz7BMndPyHDyqhvG8MCFOp79gU/mfMmDHjIogQQFUAxTOX4vAL2NnDk4YXHd/ZA86rzMD5sddf/vSPX7M8c+3uU2+77MFl1/7vx77/tuWBt1/ywC3XPLKze2E4fE4U2wiADHsMQPPMQPDD5R8vBWNIrZ2KZiF4/isAQvwyBY3FsyBSCp5uEAAfXUqb5YbmHGfHzwLTdVNNYh+LU0GPe10TgELDJCfcFbxfd/QLoqJPW1G5dNCE/A1PUTl/2NDGyzjEIl3QRjLqBGi2qU+BcB/pI8+TweQM1McdJaznw1cyJR0GofSsD3M8kxI6yEyacLxGdLVeompwgvvo6J+MxSAiKahHpsKGOp5NMwvQB/AdHh4wDZI4nrYfqOWDWjy69aftPk5DzAKTLCoQkzHka88EiOahkbIQE/U9TeldgjmEPJ9zBqIMID1FAng2BUryUxK/Edwjvzyj9iMzULQkEfoDQKRNcoIyAEAikaJACf/xu3N+/GmdMWPGjBmnFynBCgT4wkt46w4uccDPG4/Qub7F3/y9f/Lm3QcP7774xadvu/3g377r0m++6ervHjx49Gzv63WPfQQAA9znD2gZAKxML0kA+kubVb/tBykyIESZCUYD3zdHTSMA7FNURKKp/iQAI0uwOQyYWBnDceSjutc3rlsKvRmiqb+Upu7R8IjLxruSOYw3NqjnqfTHOUBJ7Ont4ZH1lhJP9+s6kxidwyRzYDfJEA9ySK0AMWIssXLaoszbg+rcQHLGVgPovKkQ/lf5Cm4soLDDNdz/LhTy03WD8VhAS33W4+Z11V3NoZA9KBxWJEHEsMDcVWEaiRbzJTYf436hY2NWuQVwmACnBAxXT7AvW3KamAO6tEqJxSCcYhZYPJ6emtCDhDAsiZsiPEtYgmghk0WAjtEHlP0VVdcBzgrIb2YlVaqFaB7hkGlAdAr/M2bMmHFxhqe0ipeP4sAulgWq+POfPaf/W3Dubu5X7/joG/WhKw8899fP3fqfXvJn33fjt5ad86p355mNtXuHKrtjLfwH8k6wTxjdmIDv5wYUmIGm0POlViBLHR0oSkCID4BdETdTClhtoGw/Y+dDRGfeoBz8VTXL9EIrMxAXuBFsDbW+cR4gTR0l1afGn373YEHJXuKgrIB1brgyBvT8OBA1siD+rmfSCwDae6WxmrDNjK6U9ZakLi1NMVw0KG4ghOliEiAb1RXUWNjaGMvwqed1B72pOcGwzEKwELkyGOWxYXkx0nZfenzmEBAzE7IuIgaEiUHhbqpiPDKeoXCK2eJRb+ACWczdXbMGQKSqjaPA16GQxerusjCA3UWxGBSAmUgULeS9qFHgT+Aukj4fZIqGbYLgzm5I4RJLHpuuJwCob13mTyDBJWJG2IT+M2bMmHERR0isOzuwo5A9LIY/PVezAXq2N7A9/vCOv/+uw/c9YDdefuzZn3jLv373G79+UaP/VwqpfwB0KY8jvu3sVfgo+N0AL/veKzxa50l70TfPbwvlyl6sob9946pMbkCx/+6QancVEWQCrq1WJg54eL03bqB+TKtGKsKVVOEbnFese253KN7OTOLj62t5UpXcWzIizXQhD3LnCTXz40juxEXCam+1MnM2+RTyc6kyY9AwlbfQbFHO3WbttWcxsCTHEn6BYm9khtAoOYjSWQEkYH+jdSjOEB6xtPQzkwBWkTA5BKYC3OOOxA0WpixXuIgrm8AmHo9JBck30xoWtETh9cWI09JihszVCLMl+ZxFRKD8FvDTcRGowj27YEm8V+NO3c3dTbjh/IaJW3CNSnPNmDFjxoyLNOK/ikePwYDFcGzB+3/5HP2PwznHSz7x7/7OGx7Xm+ylxx+/+e+98d9fjG6frbHKABSOHii47DTCH0Zl8PDV+MrAk2I237j5krfkwMgbJDZF1+OBRK5N9S8J2VHeaG5mVBdUvmLVdrPlFrKHaUs7pJidR1l/2TZWN0WJ3augk9uT/jAHNOzuHdANkrkI+nyA7HEESvI5MBhDoW9dicIqY2WFyryB1uV4mo5cBxVxB1p5AB0poE1IYNGlhzsRkdHTs8aEOYbTPSqG023vIXVz2nG1EK2MBN1KSSzUAHF1kbyuKG8QbaRX3ZR64HpV92i3v7iJK2BislCDV5eY+bXEwAGWDdB/D4mhwubqoeuLRmLHXF2X7PYTd+EsLfCYHRYfijoWR7p6wrXVkgDCXxNhbUwQA6Gzfzj+PW1CKi5QgbFfKlRogXv1v+szZsyYMeNCCEeBoLt+4Zz7r8O5lQH4xEc+8oa/2n3wGtOnLvlv3vL/TPS/P0pm3MooQw5fG3bWr7bjvv+l7Zfad76sD2/fijQ7tJNIjHyD71tpKOg8Wup+ifLeZXiIK19NzZtC+2rVnnQokFZLirfla/0U2H2dtdDGkzYSBsm8xhNZXREsJW03FmSgpVOK3JGAiRil+nhXJQRKb6aAHdA08hQthwAfE9+iDyyTA67SHnhmFZw5AmrnOp6hIhpfkuzwswgrTtKxIGgUyAVYxqeT9isyungCVg/cLbcko2tt0su4BYX7HgQWVCmF/3BdOiE7jI/ahFmO3BiX0lq9khWKKCS2LPd10XwmIubu5q5x7yScCreoAUFwCh9fnBkzZsyYMWOgf/i5mAc4twjA7bc+8uCfveG/fuCJ//zWO2dGfRVbXDfb/+V4TpwV1F4B1HqN3nXQQOKEzxuxcYlEhCvXEfF961haeLesOMNTJN6X8rFeh9H9Z1mh+r7TceVGhDjlQOg+Ae0r/YZk36Eqjl0/L8/chjPbkfYkGSfQWFKlGglUC3ZnVUJCbXKG5pbJNAMrS2s/Bf0rUdNI3cgSRAlAcShFLD6gKp+kcj/KRIfWo0vO4szbePqqYAHUDUBexRoncohkrgOAB7iPdqWVC8mcB+BWLItkqR6lIOYMFF2pbZGQZZLG4lUVEYlWQGHkcQ3mkTknFw/gTlYAC05l4W6CeywVt5CPyqJraNQKB38wp4eqvmCjlAYzZsyYMWNGEwsdeN+vnFv/dTiHCMAf/28/8sbrH/8v/s5X337Tt8/2Xs7F2DTZrynB1tyS7zt3fThf2/9egspW09jkasKcja/yFurhoTuPnEPpy6s8xFhqNO3cv12ylsKkXckfwHrzdgbQT4jm3q8t47qNQ9DEBKyZA+rtlNjr5yQDOV9rtTe0kuPVtunmp5E/siVaqvlQDxyW6jixeG5siVxLNrEsgR+se66ruApgrAcgpZHEu6AqTsKWmn1WCNTOc1Yv3OEWVCHgu3N70h/4+AgsAXf47Mlt4NmqJxB5KPL5oLKnqsJhAeclhnBJPT0LvxMGiQpw75W6MXgWRmvyBwvNXpH6vbhHh6OyBoH5EMvTsuQa0VnIHeIx0ljaxScHmDFjxowZx4tzLw9wrhCA//1z/+2hQy/j4M4H3njf2d7L+RcFW1f/jrRexA8Nta/zBvswi9dK/UQ6ecps07mBr06j18XHKr5x0cYl2nXbrfQC2dRuV1RnAPQhO/eVht2lXZXGlFL0hQ9E8h8cXpv6fVt87Hm1bdlCv5o2n3ad+hTyOJsMlV3HW8Vq3tsgG6NwNp/RQMBg631PVgAwO5HXLSM9rzIya1L/x8Lf3H+1/AGBO1j1GyeYi8YILSSv4FNCZkLcYO4B7hEzd5NviAOW047rHXARidLcWCrNOYuAA+zy09T8k0XxHlmhEQmHyG9Q+I+PxwTQ6tKjACx9Su7xxVKYZ9fWdDE5LFof1a9LTFO29BchecU+DjB+Dc+hv/IzZsyYMePsBjsG4oO/dK781+GcIAC/8ps/dc3Os1975rYP33L32d7L+Rdbtf/NV2XI5+Of+8+VjbcBVNAbmF+j7/UCeVYB66aCg2+VcfWO4IlpZX1+FRQTaQ8Peinl3J7kHrSMGaXkJ9ZbUQIv1LjaIDnM2BNQvKCarNbOfFx33GxSpXxcDqfnZHCbtKQj3DLsFzT2kqfluClf1RgwqxDZlc5YWvee4jsW6N887yvhvpcMzzst+AxyI+VpljQD4m51C8bHk08/VlM+PU3+wM81KwCigtlruJZECyBUK556Vhka5qn0HbEEHYCYuy85/Tk0+wTx9YmouJvvObMK7pocAAZoPKXoLxQzJRxxMREjp5IwFEHCicTvdX17GwdYfXvPlb/yM2bMmDHjrIeHb/UgPnjHOfFfh3OCANx6+Nt3P/22/+rG/3ACMDvjOHFC3/+WEwi/2JK+YCvQdM/9awVcHCtvvWgXmfsbZeQNyi2xb7PowB0U8tvJw8MDlEW+mvg3JMrregjMlRrYckUU8h1HmByQeGPZXbgrVyfOjk2w8MDLJsTbrTxBURDP96IVA+Sy+b+AwbK5paIiIWl7tyTlItYmxY1mRDLMOeQdsnrC4izG8DC9JICuXE3sWQXp86lhCdxAoP+gGigvjZiwoDoLG9TdUE816Eg9fn6OFj574acLBdzIrcLfH8wB4u5h/Q+Zn7cfbEXo/6FmnzkRTWrGEmE3qzyJ098vgLsBkuaiBu75XWiUEuhlG3Lc38wZM2bMmHGRRWSk5XL482d7KwDOBQLwqd/50SsOPvt3j/x/l172wtneyzkfa4U+MNjxIMY2MjUE/I1XV2XBq2Y1W8575RggaQXp+wnrHRA+9rJR0Bxf+QLh8a13xrxBU8gpYZMbrO9B2nUTB6eu7D3JkEIz/2VfYoNXE7jXSAEKwh4A0NnQso5nh9OuGSNLB/L/E8ISQ0tjIEIWpXDQwT8WJ2dJQI//n713bbbsuq7Dxlzn9u03uvEk+AIJkpD4lkXSZCSZMk2XVfkDysdUUqaLiWXJdCxKpCC5YJUsxpLtSj4kJRXLoklLclLJF9tKlcsVJ0wcW5IpEHyCIiiKAEESBEAAjVcD6O67Zj7MOeaca59zGyAI4PTtXrPA5ul99l577ce9PcaYY84FqCh9XtK8VKCxKZC/RF2F+F7gda4iprD7hDqXiVs7o6Ng8WY4CY1FKnkj6XBAb3o8n5SgNW0swLXpNt4TW4+5KeJuKKRBe/c7z95C8aawjlm8dqLZosXMhNRECiSojTZBi1wMBOgu/Ec3JHgNhS8h4P8l8yQZ9JUKZHKAGTNmzJiRoQ9B9/D239z+Pw3bJwA3HvreXU+++i/cOK3/319Q4yx/Lx+K9r/hJVtD0AOc3YSvCXxkkLTzg5vL6Yj2obTMQOtQwSSUG4mzFWIqsgJWUFunmMNraPbjdF1NLt17Aq5rUAI6T3w6aSlZXjYnGzOVrE9FzJlQMqpupXzXdLhjSr1b/HKCDikX4XL86HNewGzRzjWX1atmg7FkzYNoPSxrA7T7A+yAFbZKrZQI7w18GS/lPrAGOzaymePL/RJ0LsMFP9ZqbYmYOT1LDthTUKAr8XJJ3fSe9I9VuR0Cb7yjok265Q2ElKVJdjL17AEgYmsheAMgUkSJhkLCLIcy6wI3AlmOwmbg3Y28PGHBAeLdUidZYskMdTuVLN/PGTNmzJhxJYcCexpLe24ztkwA/vHv3Hri6IUfPf6nbbV9MnSAYtSgN32b/xcfdLHZt45FixvhShhUBidOOq2zkrZa58ezZwfOYR6G0QeKgDDHgH5sQuoKDYeTaD08Pmu9FZqTMJ5TOYjB8ZZzc3LFWXDM2NmWkY1r3MSz6gmixhcB+13S5nwMiBJcll46XrnbWMbRapKkMJBAqZF+sa/zMXlLVkWWTyi6OnpFaa2afiSodyb1pycSj1zNWhMyv9JBlBdbHrWxAvtWFNZ2U0RFxNfxVe8HSlOQdRwq7XqgTg4J6K0tUJHizcRv39sZ1Pz7Dsdt2QGhw6p7IXKLBbQVYiv7KtC0idUBB+KPOxTMBfGeDByAb9jIc2fMmDFjxozVBTy5B9y25X8atkwATu49eNfe299549e2O42DFVKgVYSWb33LBkg6cANdAybr6F/LODJur5+G+Qz+irJFU9Vdn1jI7NW7X/aM7IDtE5b7gefosHOwgALb4zQg3s1TDNMTh3QVtUPL/lrn49uF3p4y67piF2xF5oT2hK1FpIeDYM6NhqVAlp3LEwO+6C8nIEE5HKDD1XpSKpO60fzCCychX4DSVV+ek90LR/l2rkYMDYhiTyHNLfKOmCErAQuXvWOPev9Q8+vEzfTCBr8u62wEb94vVrtsdcOingfo5ucRa/XjCQovD1A05hzoMrL+Qs23dmEHUgr/3W6Q0QBVtfXXogWQhPfLqhjK0/MibF1yAE5gNgadMWPGjBmLEODPzuHl27bgbPn816wefsX5Ow/vntvuNA5GJLR//gMQstk4WtHzMm8wnmw4edlH3WYjywPKaemkKa9b0a2XLukRqC/YDteHjZkkBHdqEBkJsAxgbVaaUrjj+BS8DcEHyIspDpdoO2uuaVVO4TXBFV57gkD9ckzRp7UmzqKFjFinHcCabDpUtVuRaYo4p+R8ASsOjptZUxO2CC46fI0sBIfxLEHXBl/umE5+v1eN7n44JjZs3QF0LgtAd76B4FwAwtbTsiUFunhTznjQYkYg0SbunhcrzDUJPesffIk0XxsBTZhBdbcSYIXLK2XFs4JckU/ZC3m96Wes42s0qfOeCMX7aJHrb6FviWXrBg7gz15H19bkADNmzJgxYwhVvPMQjmx0XLyEsbPd07929+6dQ3vbncMBCkNSFbVXBVsCcY6IYw13LLz6eSzK/ioJf/NbSWATQ21+h8OgErWl62kLytIIDOpDJu7y6wYF2Bhd3GsdjotsAyQGbDXQrQ/svpHl0gdUvn1nG9bxK5ElGUNwGcJTjgz4urQKQYsLEIeHInmxPKtr8yraTOduruHX+tp8BI4x7cJ79A/y2+P1DV3VPEJqjXEKw6/urO5bTKtvMUO7LAy1tuoZh+b+ensQKqId0ujQCqJmEySY700UXVuz/v8mq/dML6iqojVrZaTSbKUtrwJhXQR3VBVT97042AX+rp4JsdIJEacSYqUD0uP1kNILNd7RJjBOYBfSyHHthy1efaeaKmY9EpuyWIV1vsdsNJQ1ycxH8cdo27/yZ8yYMWPGtmNPcPpKzgD86m//rbbbb7rqgS3O4TIJJwVSt4zfZ2j8sXlfAFHPStgKN3J4hPF60yrC1QETIEiHbVUsT5OMb2/kGmGDEYIoHp4jCn3zYSYhjVAq+iApyu2G5FPPTkE6CA5LY+kwCYW3XKNXl8Id6gFroxZWoYoel+AglSmCvCksBnKlHDDDSr2Z7E0ZNIieHDpzALCPZzUiGS1iJYA7X+IpREm3q/G+DhoniWytCrfpg7fL0L+q19EilG+uXNBEwbSBrQYgzfV4NWc+IA1i0rut6sXEBLy0oEte+GBJEsuNaJidxMsPxNsCeV0BYh1f1e7FACJWw21kCb3HS0hGFOI9zWZk1vGMPJfg7ySwvlshcZHrKC/ujBkzZsy4ckP69v8x2CYBOIqn/+CRHz9xbHb//EHDsd7G12nh7VnbZeAGMm7diO/jXNXMH410Ft6etUKEskXWtmh8Ey3qDbwXKw5Mb5VhqgV3C6G61BHhPTpTmF+UIpSUSBTpLjw/DnOdDzgWz4WDyRw4z6LPB+cKCGvYXd3bI/SxRH5hQOFxHY0OmeRDvCOkB85ehEA/2YLCe13yhpCxsHKAFboInTwcOHEemnxgTntrDIqmwUB95wag0wsEbdL9BkQmRPh+WCUxr9rUdQlaqH1vz+68ROGyP8puhdFqpb2csQLe5NToGQ1NTrpAab41K/d1IN9SvC8cwF/ifP7xDB30k5EluB93i43JJZaWtxkzZsyYcaWFVfr96K9v85+DbRKAIzh/LR6dKfEfMC4uLI7u/BGaJASsPpkE6DKMmjK6lmG0bN9vBtR086/REWg5pOPDckrq6oGfG5F9RdRKjVxo7OaUaLBHKt4B6EoEnFYC6DyLNoGUJbwWmu5IJDgIGxaJX3kK/6EJF2c/woNkA0reD5+SVnRZjf1ZzgsmFkILz3so5bSRVBGoipla7Kq7rc8l7HLayArAXxUq3clZ8xplgcK76wAsWgDbnQqX123o6EHPqJ/Xtk6u+gdM91tBT46zghYExWuOPQPTWL8Aq1H2Ql7T/dnpVTwp1KC9qzSwMVHxZpHMVSg/4Pv4OZIoxvaHMxcHmDFjxowZzyFM99suAN4mATiBsyfx9BYncCBDNvxtPzQxiOCbd1oWA2wCtUOE4L1xVi56L1mB1H2yw6cMk9LF34CE7ymd08PDnbT4fhqxWw4h1mNnKO0NuEfaYNhNBmZTfEGprTvAq1Z4qrpwe3gUMISAnJfp+DtlY++sn08xfCQG5flVEwSCp5VIcvJgeYLQY2Mnctwf9btqQjoAs8d7BgNwNaJnEYKRKOdpqgLtBqA7l3ugng2JKXGlsAKfm9OygNFMoaitMdxtoS7hztYc2Tw25g2SFpNks6CmQLc8QI/GO2CSwXMOXr/R0L3oQGCeH3Ttmo8sX/iC5tcRv1+s3+xA/FL3wVwcYMaMGTNmPLdoW9aCtkkAdnHhkMz+P883SuvG2DJ+n1H2cDXa8cwCLq8fK+MHXWL95V9R8DgIuktH/AFR2+cQpOnCcCTMnRZkYi00Rta6Y+YRDGGOXxmSbpEU6TSa11GBgOkA7flxUQCkDffHLDZE/pHPkPCK2HRGliIU/MXLjCmSd95O0cpYAuY6RTFMacvc+uHCLITyAnwmTb1YGo7LkwIpLVLZoieaeHJdYUO8rM1IFgRLI3RFV/oatYUNSel/IXHybEF31Gy3s5H22FVYEbPD9IZmT4jFDBT+0SDqaRZWDIuVEKtKF8twNJCf9G6mo6Z+faSQfIID4k9Fn+K9nVRGDsCfIzc8BaOQBQew13QuDjBjxowZM6AXtjyBbRchz3i+MaL35XfCDwZe+MUCtJdhNvDQxRZJ7d9lae6Xm5YdgRY1AMtv6zcEiJG2qBZ8776ChTknqUa9oiRFLr3zGBmHzZOV7u4LtR4utPtuILCOSQ7OnLwogtK8SuXgUnBsDFt3cOCIpoHygyaVi7VVszRSF1yEi+kCEHL6VavABPDIDwCm0PdOSsIqZ+2Ar7+rhL+w9IA64o/cUWNBhQqAXF3Ysg1Srk9Kaa/Nykt1JZ+/AuFEMvu+90YSpyJeW0zSYhfuVb9WNKzWhScyA4CquBnIZxhSvcTjqg+QDzbQPIqBR0PRJwcor89cHGDGjBkzZjyn2DYA3+b5z+vOed3d4gQObhi+usi3HgFmiQi1FXBoexSMrmsYHak6az1o/H8soUzA21a3AQRWi4maaF3qfh2i+ikFwsrXxJFgz3iEQp+AO0FcAq/8UCB+5Qn1Yhy9Oaw1MNiGy+ScIzNCkT7zAzErgvcieJsIndWuXKZKrZfoMKWu5Vibkt9FqYW9pRFNcCD72EgiHJeDWFyVjYd8VvTKkzryKkQk+u4rIX5Dl7jHZunxil5V4Rpl5GzCxRASl4O8zF4MA+5du6q4n0cF0rtdkhf7wuhJl6iaaAJT9Js/cRW1tScEUBFOspnpKO4lhlnosrQjplraIM3FAWbMmDFjxgsS0rwUeFuxzZOf7UefvHBkixM4oHEx7b86X3Kb4bDh2/yiiN+bFfrqwx8QUp4ycLau7eNgiZ1YNn9bgbUiLDHligq0950kR86Tcvw2SNoB9zhiIUFBjYZbEaURw0paZjKxn1jxeafFXzkz/lULpTE4q7w+oFc24hft1b72ReNRjVYcEL6j1CwIL0h4K7S07hG6aACYo6YBbu5npbId2+K1qiTHfEFK7d/5jLLUQbPGwR+OM4gG7f5iiOTCxqqqnU2BRFw6t1raRjbmOxNoS/PbDgDarVAh6hPaolWoqqB7m06xlYQdksfKviBw5wnjcpnKyHY9IweQ5AB2eNCJgQNIcgDfTUBylRwgiNrkADNmzJhx5cXeCmfeuM0JbJMAnNNDj+Pk/Ofv+4jw/UtuqRBmADPxseLdGolOExrlfjL6Yap2vhxnWAxsfZ/h0EGtB6p+Px67HEdjtyWLAJEfcbwTBPOVIF3jgHL5LUfAGO5UcJ1w/TisKyv7BugmBOwF+ml0TmpwnIqAhzAfi0O/ANCcpAn/kosEa33KCsgqAKjP1GbZhV1ujEYI1Nrk2Bq7VOhL2ohEIwkYr5kZCVVgxQzMylcPDragzmDUSYWIuX0AWnHirWtOGzr1eJ98Q1dtrbQtirpepwrdnia3MMuhWhYA9rl3Pm/rOCRZSwCFaBNbyRiB5kO8dw5Asohye9muZy4OMGPGjBkzXthQxRd+Hk9fv805bJUA4PBPXfdHj589usU5HLzYr2h84fvf8P04TIX/GzMDSqqRHVyKch8fNpxsKHIYoctLAAAgAElEQVSUMhLWkI5sxD6h/ROm8/BBNQ8YnpM2YJesJbcrryUAcXbkFCihJ4SCbb24kd6whpZAOW4lZXieDq7+aof5ScYlAaL2VCk+R4MdXm+WqUKA3jMTQse/++yFly++gG7BmADMOg+bg5+C4/MBs3EnL0S1ayukgjenw4qnbU+bEjG32Lq84m34jU54fbLGOgP+YjTbF9bVRyXvpZXWKtebA6dgVKlwJ946MWc/oF2bAE21dzjTiOOWHMD/wi2WrZA1DgCsLw5QXoeyJY6qNLVy28WBySVk35/rGTNmzJhx2YUq3vC7uP/HtzmHbRKAX/iZ//nChXbv4zdscQ6XTQzWBm5S4pJlCqCov3Vz/XtFg3XnilMUCZYLoqXKfdG0AQJ6prKOCvcFpbw4nDiZNyhgShDSrLq8TqwpJBkxPbesCA+MLIqr0cFYlEdVGjAsBuxT8mNNIg+gR9yXiNynIUxHNELFTLloveNBAyI/oGAdbXIht5a4TadgTZb5AjTYc594JLZOsCpRryp6420UiBfMGpr3zjks8NWmAtbv9pWqQrX54lzNeA+b8Ldo/A/vSeSD2H3uCIKhXqSrZTkwlW7tP7Wp24FWyNamTfwRmO+nW96jaZPeQF4VpqlFUyW/7SMHQHKAuFUy0OI1fJ8v/1wcYMaMGTNmXDxWDSfuqRBqC7HlIuRvPHnTV87evN05XAax7iOoLXSG92so5i3cgH91LL6APZsimtRjQElxFpFwsY88QBdIugjhMcaoude5wRF3FAvw4uNwZw5arpfjcFtOPGR4ovnAdnTmlDn76YwV9EDkGgheA9mJS9qB5oMVpf8+sDjV5bBSpQuI8rOjShmeRuEP5jJKYFtkcgGgZsXpZGgWLe6cOIMi0/Bb10g5AKtF9uxJwnfjTF17FCdEpbIC6KbBx9RFFd2cNd7/tGm3+2l3o3EagMRFWc6iAWCFQORGmr8LzjHU7Vjh+Gf3UoWqNwxFJWjE+o7+SffWd9uI+EkdgfI85+IAM2bMmDHjoqEdj25b89kyAXjowtX3Pv36Z84d2u40DljIhr8t4PXGfRe2H37rf1T8XbHv+tk1ke0Steiw1/LtXvj+6/51ro7GxQ/RcS9IgWgD9xmk+spz1B35NQVCvM/CWZOmaUEh2YhRmNNQB+8yFJUOw4bN3+akiRzzqi3/YKB/05LLWcVL2Nq8GtitMtaTh4W/XvwKbhoetKp4JyHOQSG+5BfvcAzeUdIFNp5dQU/LPUSBJh20+PtywugtKFZXiHcytfM1lQbrztP9VieF8OV4s8SFtiEnWmpVv+LZCSV/8FdRm6KzR9Eqygz4kD0P0AsoRxHmmX0yDT5dV0Wqr4h/Lg4wY8aMGTN+gFDFHRfw1LZ/32+ZADx24Zo3nrzz9gdu2e40Dmqkfm9S8fr3JXS5eU2/HyC7DJ/K+IF6ZXmGGC9s3vFH8pOQTGlXWqD2taUEkLp3rskVM67/V9T2PDuBr8nWPjPNHjvqSBRwm3reRu5ccD7XAku93AVvP6HbTQp3MCwYJxkJGfxuaH7MNEIWGJjNfRCnXVmPsmN1ICkG3yWAfl6MMIsiSubBKUhSIqXK7js3+yUhsNac6hq/Of4jDcKhWnHVW4Vw89tmJc7KdXzdv9NVu7cq4kOLtk4E9wBM6fcboBjWoLDsAYLGLNG8rwQsKJ1JebsGcA9K9azoLsyzsIJC6MiOqqKPuANzcYAZM2bMmLEeDXh9w3f79qexzfiFn/vNJ8/vfvbJt+ztzfz384wBL8jah3Efze833nDZ+NfqfkDF6LIYeSAHILaq422U/jMzgAXmSsirGwhOIFpjDmMuxP0wbukm+FZZ3KI2XiKhcOrfiRPZzKdYwxV1gTRulzDHcDw64AkknVDxekknWraKdEOQFVQ03z++patKVTsH9zpZg5jNtWpQL7f77AP73TSTj4v0PWZlt4lau5/IS5QN5jrwZT1uVut22p94R0i0Om+Hg3sb30tsgSZihb+R0IBqMyYj2oDeYesAeHNPVdEuCu2dt5qOmnht7HZoPtIF4g/xfmAF9f3UdP7wjZ6LA8yYMWPGjOcfiqfP4ziA27aMe7e9EBlw3/kbbjlx9+fuf/22J3IQgz6TTW9RytJVOcY69l9H6cNXQOroSN//iFSozUex65KKROFtKKsyzFyH8/LCkldAILEMcFACpY+llFDGBfvJrLCTqqyDe82d3GTkoF/9Z0J4qbGKV73Y+Ev0skcWlnqdglabDUib4nobLCPhgrqL98pzO8rFQBsAmM+HLSt5Y3Ni5omXICluniEQt7Jdc+xEC04+soZAxCIawr/nL+CIv/NSeSdtQD41s1r5Sm3uzHF465fZPflTmIYoVJyCKIDuc+uulzNZ4SREtTXyMIG1AArx3lz1pGzxUnG+yRIDpvO9LBwg30VyAM12PXNxgBkzZsyY8fxCBYeO4sK25X9cCgTgv/uZ337s/PH/84kfe/zJY9uey0EK9n7Z51v7v9HEMHyFkGP3SQYMe0sKl/X8oeAmIShjSSrK3DcnspgYlfI6VJmzLA/c0DGF/pagFrppr3rKkKQRinW9XOGYBNsgGSh9e5gWyKkbWmQha5mvCi3ssn4Fea/U7rNY787wnSfWN/BPlZ3ic0WWtKF4EyQRQHslMKLabLVdA+i2pyCqIJRVuYKuvk9Uf7CRUcrkhoAjvdLJN3x5LyM5dghres35I5AmzcCx3x+h4UfouRHkOgMiXaC652XVEs+rPCAFRFW7307emZra8ceVBh5N8d6H4hsfdRya7Xrm4gAzZsyYMeP7DQVW16Lt4s5ty/+4FAgAgD8/9+q3Hvuzf/XAX5r/5D17FAl5w9byF32Wu6mJgdaHibN4jawu+s+kmB8bhu+pXa/trvyLIM8iUqH/hhMphktMY0ZNdCxBOFAWmvXT+AQ0Lk7Ztj3uyZIQBHKrDIT9SymfcykucoZsBGPcwGoD1HXfuAEKNgVqfiBFAW9RvybSiwTJ8bIAheFsM9k7+RDi5ux56fCTvIjeHhPX4w4BjbW54uWz7rAiNI66XucY8UyMStod6GVEvzOKrt3a9dggfuPzCWhXbehhWPInlvYaW9nX1v1SLrkQL0XW0fJC+Z5k8a4TihDjX9DFAUohb7xEyKPivY1cUd0tDkwuIfXna8aMGTNmHOhQoAn642iXhtx9SRCAX/mb/+OZ8ydfds09//E7b972XA5EbMLiKLhybZf1fTVx8YZvc4Aoei1nCcRcEHEFgqNMHsNUBbpIoDJCocDNw+VgMxYqlzMOrqxxDSZThtUAjs23DpL8UNhAxOxiP9IyYhDNT5fZA6WTiNkDwkffojEZYnHr0gM6WlLP1nobacZRceeTZQC02f6ijaPXtpt8OgALEwiIcyYClWaTtfwEwKZAJDaGelUEK59M9yXAmOKwvj3Z+FVhK/vCSQi6cgUDuxh3/MNaANkjWIHlvGGjcpjvK7UZNm+SKy7HhUq5z+hSET8Cgvuib9AXZXGAzEhwS1QjDIsDcG7x31wcYMaMGTMu+2j2C/48bv/g9uV/XCIEAMB//Tf+lwdWhz59087n7n/dtudygMOF9pESKD8Mb9wasFh/H3XtQ9nb+5nooqxWhp01piA5jToq7Ufhw/fBkxvEgM3hcp5l4Dph987/SxF6/ULUWUs2sSHa9jpS1uP67MpfWOeQkBQF9VZoGneZkja/dIyuVqtLx7pPQ3P/MgFDh504taUIbeUCLhmDxbvofsekjEZVnPK/36UWqjYQhn6/TaRuPdxQtiCAe/pVqOij+ToDfqLGh2LA2e5nsCn4Ayem7nwcLFoolEobgN57B1SbwK1GLDMYYLr2TuePxkUV8d4IRuUA8coU+jkXB5gxY8aMGS9gCPD4ayCKz370Uvm1fqkQAAB3n2qveujk/7P3vru+94ptz+VABqHIZsmwwuM1LF7g8tpXdcOSEoynWhtBNroYYkNRymO8zbPQclmGoZLqSEin5lzXHCQwFwK3BSeR3DjmQrKzPskGlWMvRo27l+4poazrdhfh3ES1O0z3myx1VgHE3dACCtU6zBVALIWswtSB9BhEgjnYrqw8NTAtELTmznu4297P19JIpBDvjiqwpkAKQBpgFCG61ohfi1prHyrWCi8R5qoLaCAeV4fDIoLGE+ZdDf5DEGxAmE4h9RSHDeXAvRGUN3KA3mFA2/E6fT6IXIXaGsrIc1VQXoX5GCRsYrx7+S4VxD8XB5gxY8aMGfvHZz+KJ27CZ2+9VNA/LikCcNtf+fQjZ3/4uuN3/u8vu+7f3fsjU/v6voIYeAit38ZGHTfVNva2gwwjyeJT7OaYTdbhCc+Q8v1IPGz1K8fwS/TN/xtnQGmZWxKFo4CyQPWNG6nrxxzYIIe+bBrJk9tE68sA6CzcdKU9hP/E4g4mHUZrlPkqRFQNhRtPiPdaNB6aGMz2lILzm+ZdQbUpRXSuhpvsBz1TElY+wAWxhFXiii6q2qnH593IFkxq/UAVEJUOtXE5TjzFqDxWf4IGqP0ueX8hMhfTzZvEhEXMyaPGgrq4KYgAGV3tdqkEz9GuCtW+XHaN4L5g/c5lx8pvtTbsRttPAnfx97cI8yHeL6R6Uqryo1FYQaD5oEODos+hQvfH2Bh0wQHANMJsDDpjxowZBzkMKjx+E27897jvvduezRiXEAEA8OH/8h/dc83ZV57Bhaue+b27/8oz5+cKwfuEDB8Iop5lX63Yonw7HKnl77L2Ib4MAI6hdclyKBCsI6H/2vxMNc8S3piga8N5LmgZr54rBfvynSKdJAVbS/AQJMjLGXIASezLyuCSLKCAzamJUvLPpERyLTbBzP+YB9AA5ATOOQlnGZrkzvkIbULqy2apYtDR409p0JaKPcClBpp2WpYU2cjfsgMqVpRM+tTI8kSg6OhO0LLJKf00TiGgvWsBr9rAlX1jGIH4cmDOGVZuE2reiSiMRhKnc2KBwjDcO6abpHpuUUUjQWoycIC5OMCMGTNmzHhxonf/BX/yXnz3JyUVoEsjVtuewDI+/cm7//X/evdf+6n3vOzwY//2/p849/TeK48/3Nr8x28RYQ0hYAzUPH6g3EyosvFbbjEYEhJ1HAyUr1I7jZ2zhrGGFwcotXnX56ltIj0ldm5r/iiIH5KcSUy7TsmaB2mZWx4bDWISu/NWxYQbtf8mdOaYOG2itegwYQSuV6lt6QVmbClrCBDle9N9vxCB22mEViEAIi1hY4NwTKlloXb5jTOP9jctpGkVL21Wvygxx4k6g2hcsjeM+OLQssXpBJDerTBaxKfRjJ+4I96W5YKI+fvVtjTlHHJZYAHQ4sHZrOoFqkC7qPiJtAm02Z1Bk06mqK2pQppYTsdbIPkDaQ7d+YhFrJVSuqni5jtBgD9Zvqs+kOQvZb5jTNmQ6OWrHq+3u/ptNHtx4ih7wYveP/wg+moEvptofsu3N1/9OKOUOc+YMWPGjAMQ5wFAGu74pUvxV/clRwAs/uW/uvNdf+2nbjz0XdmR/+PB9xy/cPa6I49PGlAiQXrR10fQUFC6Jixb+xb1QAf34/e5W8kNJDjG8Lk2/ynbxfhA9LKJ3YiZClZSYrWkB1LGQd2fJ42vAxD7bmpQVRL+FoDoIMzhf6A3lTyp12+qoIlX0A67OazXoSdl49wGa7/PnOPU26s2CPEgVFg50GIyvgzv8CeSJ9hNa/zWUKyDe4U0FXfpEN02b1BvM1QmPWBXbWAdqiQenCHvpKg0EAR7UYEarRCgdThDcSFfmwoETaVxyeFgfYnaoZZfkC5t8aCteMDO4lNiBqQA+gHcZ2W07xYPvWDuygE4h2fhAJaRiGF9t8oBuLMu2QUHr5g/iETZrfy4OgVd22HGjBkzZlxqYcngHWuXIcAePvcrl+gv7Ut0WhG/8VsfuPnwd47vnP/ykz908+7dbzx2982nHzy0c2Hb89pmpKSdpnOzE1QLAqI3jNJFo/VYN3vQ90BjRXqZWfFquEbdrUIDjkg4ITQBfY4DNUmY8+HZXXjWwJ3CmRdjRDSrCa8GkwmxiC+9HYb47Q7Ax5HILfjOPqbPQchAXOPXci09zuLauVWh8ho5QgwC2lQUgLaed8OWxfKhNGYet0LF76E2NLEJd5sDl3hQiNW6dqcEtlvLS0Pr/mRtzKatKRRqqrwp+s1m3tGg0gWizW5Rl+aXqaIiXcWLgmWVw2rrAqDtKWD7q3QjD9og0lUU0iEm+QOiHb3ZPAUqHSsFOpoYK+gO7rs2SFN/9M3vRm+9Nau06DYxbWhWENB4B6CwmbSYkood1WwFY+3N3xBtgubPkedKNd1+AOBrkpFRqOVA6A8yzqBes+wf624kPzbocBS5pZ0utsRbXbgmVCuHKc2YpNAYpjNmzJgxY8YlFQatzkFWaIIGfOaXL+nf1Zf05CJ+87d+5vTqzLU7Z645+uRnzr3r+PmHX7Nzzy3Hv/Xqqx5atUtgPeWXNlgjGdbgDQTAX0QVVUKLKkIDqATAACsclCSvSL+zOuyOb917HlpsVMjaBAzMECInwrYS3MDoxh+48pMkyMZAAEQbLzkJQKUfxPG8BNuoQJwuOIYmYUiUn+flZXJ6Eveta3wW96ZXCgRx8lCnLUYqGhTdDPTKXEEC+mA1Dk/VgSA6xBG2mknGcLYUNiLeIzOHcujZ0ZS0B3CYrmbL8S3QJtp9cFVRFWmtd5irB2idKQj7ljeqqbTeG808PkNbQsxufvenYHNocd7eg9X4Kcp9WwHoWMWlAa2r43WjNyQMfOgqkIa8b36Ub1E+I22Q5ukUOOdhzicwPUYOkMmOROTC2ovkAJt224j4N3AAYXX5Rg6AoCU86eQAM2bMmHEJhamZ5lF9/DiOnsXqPABgD5+77QD8ij4AU6zxm5/6+UN7T52Qx165uu/Ekaf+vwt/8YYnvvPK3ftfd/y7N131ULsyyIASE4R+jxDdfZdagClJAMKnYN8oKUEhAInaOaw6amf2oAwFiC5OF0fZUMTTqAxEU6Qnu8iq0hTIgeAJ+a0IvN28xBbxTAJx4ZBA0MgblPNaBeoSwavP3L8Vx9+oSNqFdtiNyhSEKjqJh+NI18VD/o9UgN0xB/eAdO5v0FnQuogtG+yAG9I9FxEzt8ObRgpCodb539CwOGMxbZ6X0GCKvqLb/U8NXsSb5rSuBPdo3Wpm1VkEZNVdgLeURTOeINK0i7aakTBw3xzjMj3StWkT9KZo2nhPYARANMR7z8807YIWuL9BI8HSoLAyZ40zevJErMCAmQGoFTKLaG8qpUXUfhxglOrXOEBI/vvstpkDCAUius42cwAeqIAsOAAy53DQfnXPmDFjxuUR3s6iAc8AK6DhwiH0hnO7+LOfO0i/mQ/SXBfxsX/xoePnHj+BJ14l9x3bPf8fHn/Xje2+1x/+5g9d9Z3Tx85ue3YvbgScXRIAFh8q39FByBcUIK4FwfshsvTtgAkEiWLQ3J9sIY+tOwwmH/frhNSNIADiqieZBmmG/yn514Dv3sfTgTtCyA9hWNDLpflCs0UgVyYlFm6foCthjCmSf1xy6woxRO4kKmoD4uqqtJ/T63bhmRCgm4Wchw/LkLFSwxanFhBRK5AFHfzNiAeA3r2WV1W0Ne3g4GYZIkpWaGvalWeR3gW2ELC07u2BBsrhc5OmgPaVNukq6NBV0y4dImhGM+iAsmtfaXiQ9tQHl9bdqBPEyZInK9Rb524fWDNUDtjs6cMtTE3sEnoMZeDeMzyxm2cb3A3lzqVU7hPNO3CPLAo2CfO5JW0/spkD1ANDvC9oXrizEtBLJBbK3NJTZIMpT3eQf3vPmDFjxsEK++XdFJ2IC3pgxP6NcVDnvYh/+PGfPSGPn2qP3Xzk20d2z//fj73jNfKdW45+6w2nv7t7ORYM7EcAXPxeF/JTKSdqzw7qvtH2HgiAOqRRFy/3IwAgRi+HRwWCjvuTEiAJgF9R8eHEVyHPZyZBMy9h06YkDKDX3AJM0g7XTQr5yk6W6cNB8TIF9FeF428ghm1MmEjMGUXmh1v5q2cmYDESo/tMHGd3FbXuQOQGrEagxg+weac5efwsPY1Aarq4/25yAb4kAeDDWlMgGBYXsVyHusDvaLuzdMG3iKv+vWjz7jvqglXTLgp0aaoNql0anBVYlgNdG1pTbarSW0MXyxt08AI7a6ld0W9+D1VEzIzkhIcpBZsbuYQGBxB0vyJVS3E0e2pxdemoCeA+2vHVecCaeF/Bvf8oFg6Qqr896SgGwMU4QKYd7NXfhwP4yOI/ZpMDzJgxY8aLHL27w+fUM3hyB3sCAALcfimt5/W843K4hkX8o9/5wCk8fs3qsasOn/sPF977srNfveXIvbec+PbLTz562VzuRgIgbsTfTAAg+cEJQKJwyFhADEfk4tKkmr5PD0+hB+nPQRKAQhuAQPZxulD0USfjhpzA6Knxx+nG7AQC92dxcLqMMG5JAw9Eu+OxmjeoJQSA9K4wQ0vieImcBqcd1QIApIuIIhAtVDpdSbYDzHbvVn4v9i31BoU52FWbn95gX4d/Tm+9qkrXhrAAuXwOFSk2nrjMZq14ugZjaRqwWKU3Sv666lA7C8QIA+sEuujKDDaGxVcKUVE1S4/Q+eOPr5UshF1XVBSsAHQz8Ph726BNG7SLtQTlDEsiguOIiHbeit60Ab2FNUgs6WFEghwACssPoENbGznAoOg7B1io/gHcFxyAW5IDSDKBkQOABp6kBM/CAcrcJgeYMWPGjJcg3NYvkO5i/66iKY7s4dMHVuzfGJfVxSzitt+97fj5752WMzev7j5x6Jn/98w7bj5y7xuP3fO6Uw8cWu1te3Y/UAyie4qRVMfXCEB8CNSOQgAI8TksxwkXjRGA1ObLbgiAjk0EQN25UH3/dRBAutq8ApU63JfiL9LKFlyMDS7B2oD0IDkO02QUkUCgsF16ehr8dcLA25vJgeQSsEpc2vcBK2AlcEfATXf7kCS4nu1os4POforZzhxMWa8FA1JyDm6Iyv9MXM/khuH+kPnDZlMKmrsihX+4Ccq2MKdRpXSYiq90LnWFW4/cONSsGqGL+LeyIky3uwrIShVuBxJBj/mvNK7Xbnhv9PqLhK3fOECHdRBi/UajTb9FjYQCMH+/fXBrUMuHiOIpcuxOV30g6RHfa1H0hxZAAdxjHI+xttjfwtoUSEcTPxH/wAHEf1rWd6scQHkgZzhjxowZM553SIc2oOOOC7hlBydt2R69TMT+jXHZXtgifuO3Pnh659Frdx695vBT/+mJd59effOHj9zztqvuOXnk6W1P7fnEQACsM48aSh8AOi5GAEBjP4o2jwUBQNmZXnkQbkICmkfqwGG3sl8QLUYoBCD991GcoMM4lVQYbA0BfkwvJAEouYLU9WFn0XDddK35ikX7HeGNRd1I7bkMnnkMl+E1DTzRb9Q9PJ3Svqh0AcF6ObWAQLaAe6Eu3gGvN3B/C4mHXaZ7gYrRqKnAO37aEyRcTuIhLcuXXfhn21DH02DNQG6XJr2LSgM8veDl0WgqXuxrCwh3KLR1CZeOG4e6NqiY+u53oDNBIaIdQFNprtCbou99irzBaEeDql9Ch5inqGcWRawNqD0gcweJKFMB4s+05UINIdUPHCC20GZmN1cuygE2NgYN8T45QAyFBPexxe1VGJMJZbdE/KWMgT+qM2bMmDHjuYcvfak4pNgTqOIRxdOK73bg8hL7N8blf4WL+Icf/4Uj8uip1ZnXHf3m8Z1nPv3IO245/I03n7znphMPH6CbUQkA8fQmAlA0fle+ww+zDwGIitWisgeMjvrd6ilKJ1KOo+IjDSg/C38rN8jpEYVXBO+8YiwgBolHEbYzvYBA576/EYDQ6UtWoTqI/MI1gXjwGTP389LsEmqdALMEy6QEFetyINL3X55U8cY4U/I29u5+icqBUPRFVEVUejTS8cNb5/zF2IL6gl/dymGdsTS/Y76Or9dFqEq3Bb8MyvMzawDgMj/ZUc8RmlqbfxVVdeuO7dlEO7pPw1YerN08G18bW0U5tP9GBxHUWo5qE+uY1J11OMHwrIJlAARoXv7ruwFqkyn5B21cV2sjBxjEe12C+0HRHzIDz3lxgCWUDy2feSoEB8h9BJkE4MagJWZhmjFjxowZzxZm8lHF7nmc23Ef8+qSb9v/gseVdbWL+Mcf/8A1q0eu2z1z+tCT//6xH7ll95tvPfGNm09+79JvJxoEQNYU/UoAJDC3HRXw3Z87jTcANGB0fBtsYYDRjklc6g6I70QiOIZJ9dWZg0WWINMFkjNfNNfXOqbwqomMTZn1rjWccDjyAfrIVTsoBkcKooB1O1atX1BI+5EEsHRGbfMPwnEEcwCkC3dYDC5rG1lim1cqrtlX3xFU1X3/rasqbf2lyNhNI50chkb8mGpLbmD1xNo6ICxU6NKgKE4eA+JCC5NXCRfi0bwagakAbdK7AK0LkXpSoJV6e6JmiyG4J8fEfgRMF6/cNS7R4V2MrPE/2QjIpjorEOCVAN79M5YCkFwyzA6HKBcI06ZcOyw5gL33CwOPp4oqB9gg3s/FAWbMmDHjYIS65vO5c3jDDk4pRLHq+OMrQOzfGFfoZS/i1z/+wWtWj15/6My1O4//4cM/cuOJ+990+M/fdvW3LtlSgYJ37a/h0pH81t/1RO1Vrbf/DwIQuN8VzLolCECt+l0SAAD8kGdZg++FgeSUaKTxWTvOQxW2EdzAZXsdR3BlPVMQfuGGX/1GVInd2tInAwERc0wv7Do1aQCg9O2BoHuehMSAbITzpHHIvEAC9ZqHMrJ7VFgBTAKgBKWGgF1xT+gvcKzMzADgGjylbjIHKItiu8AdMi3KBqDautpCY0TVbPjD+mD05nYd8SXGoM32iepeX2O4m8mne3aldzcIwf05ccPF8wB+pU0AcKEuv590HKmKRNLAmBJzIAAULWsGfJ2v0jwU4HVxVubqM88AACAASURBVN4tVJMDpOEeF+MAo1S/xgFC8t9nt80cQPiPEpsCbeYAPFBRPEVJPObiADNmzJixMUwbaQ23/yLe8Hu4cDeeVnx374ow+Vw8rvTrX8TH/qe/eWL3iat3Hr320ON//MDbX3H6228/9vW3nr53d+fSYgJqfXsUAehBHA8HFG4BWqJtCVBSCEAV6dNjk3q82klKrS0KIHYlXsWESnIDivRL/d4nnMYhM9IYfiqAfr1ygAeKqtJjY2NGsmKB1yXuCaozJ+V5IxXF5CO8GzT5GEkIuE9lnbq1ap60m58+Jmn4voHuGp95WHQUvUUZa5ATr1Utt6VxvTDPJIiAsJ65BfHUivX07HBSoUItP/wwEOVCY+QVzBuoQAW2GHCUz0JUVr13O9AqFro2WEkAWhegi7YVfHGxlvkNEV/ZV0S0IWbLD7GyL9hcNVv3WHsfE7gt9dFb2sDU+5+C3UKz4xA7CLn5TdlKyHMXWatgPyoLDjAXB5gxY8aMyyNEMzl65k14+jrc95cwM6UR80Zsjtv+yYdOHnns2t0z1x9+9DMPvu2ma771tmN/9qZT3969ZHICAb6XBIAQn7q+fwahuSQloI5eCIDjsCUBMP+PsjNPaOc8Ear5ZyQAhPIxZskbcGL+50gAYktgepv00IIToZUGah+4QeYipFCR5ABx7XYtPbaEy9/mmSQB4cgv/Cq8TAKvSRDYUc3BffdUAP3xNW+Qnwlw+ZnFvjYBa+0PodGoe5IhvDHuIB/aAakvrNu7SGtxIFS7w31X1qNGNibThSW2nekLA9zSuOCAuLWmN222MnHNhLDAwPA9bUVl7bPmN8qvwhco0JgJV/YdlgPrassD9w6RpiwD4E2ztYEB9wWF7UdEWXls/UCrVI/CAQK4z8UBZsyYMeNARbdVflqIlIDgjl+avxU3xLwpzxK3/ZMPnTr62HW7j1x/4ok/efrdN/S7fuT4199y6t6tM4H9CIAXImrB6IuWoImPFzo64lukkI/8VjUbcS7M/fV0zBhU4B7MITEu0bPhIXKMRXIACmEtcjKNIAzFJGNye1jtS94giEd4QqxzTiDpYg2qgxcSVSp0g5mMN8ps9NV6ZOJ9SPs9L0FA2R5cHjihs3+LXFgXRioEDV1TKTe3jycHOFvE0mCAotkqv5YusDpaWB2t+q32NcIUEsI/YbQao0BTwLtwisvnTpB6szUBSDkCuEtnTgNId/6g8ZNpkKxKbYUU+8DXIhBVQfdVAmpnz2AjhV2IQtBbcrCw/XT42mEF3BOmU7xPDjAo+s4BFqp/APcFB+CW5AClXc/IAUADT1KCZ+EAZW6TA8yYMWMGAHToCqsL2OMvcgg+99H5m/BiMe/Oc41f++Stx/Wha1cPX3fokc8+8+5r9+5614m73nr1t1eynYrhjQTA0MN+BIA4PrRz+5swb1CANQooB6jfa+L+8kHtBhA98yslhlYQ2aNAz3UCYG0rB609MgDFy6TKMe3bhOaJnmv2QFUA7YODiAxkIeRnlfCg+nMfvzqFRL1Bd0tPK8zHAfEg8CvdODGrQfhvrpq3FqamPMofdPOnGRWuWW7rJxLT7Hn5XizL6wJb6XslsQLifXuMG3SmRHpr6Oy7L9ZptEHBwt8ob2jdyqO1qZUpd9G2qjcTGjyqeW/TYtdB3Lc+cAOX8BF+fasSjiXDKOFrkIFmdcNRtCBc9QxZCuweJCgHXMB0/7miqz6Q9Ijv40cJAwcowN05QPxqHWuL7VNyAAL3RcfPMjipji45gP9IFw6gPJAznDFjxozLO0RhtlhQrLr9V+Zvv+cU8zZ93/Frn7z1aH/o+p2Hrtt58E8ee8vNx+59x/GvvuGq74XE99LEfgTAQfzFCYCjTw2RO/oFpcYPpwQGbHSNAJBmAKQQgVmdAIhBsdDRS5FuJBwC06vqMAfq9+Pp3OLiU0bK9uplu13jegN8C0RDIzfsKwHuK21wuB8kKvpvupXf6U0YcnxKfhYDowJ4lXBhIMZtfMuyB1GA+LzwWIW3JgFoSeKAsYIvBDFP0+mdS4gqujRFEy40lso6tFuCooeO7r6dbuPEGsNoHYLu98eMQ6pi6F+x0g5bC6xeiwN3RZm8G5BgYF0lJllc+z6OBOfxAgAb0DkArKWpd2dqdByJdqA1qC8moN3eiuZrAlgmRI1ENf4ULThAkeo3bxEmECw/dVEOsLExaIj3yQFiKCS4jy10r43JhLJbIn4p48SlzZgxY8ZlGL0x3QyI4Pbp8/k+Y96v5x+/+ts/c/rQozccevj6w4/98aNve+3uve889dXXnnjopbmnITm7gOionY2ADDfwA4kBtyQEV6XrgNhXKq5lSsGwbLh6iPXVHRM6Vg64v8j79oyeolS4MxfBMStJ4InSiB+uJClmpGyFqdw/ShdSyG/h7TEZPu5GdM8smYe4RU4AwEb4afvp2ij2++AB9xHifeJ7sDuNqGj3laqCjXguwrvXE9B3zyQoIbI19MxFdtldB27v6dKlW897382gvDOW1gXQ1tVMQZ48gbbu523w5YFFVeyiDLJ3b85jd4XLfnWBNAi6inbpraEUGwAkM13q8snRzkgycUHy4/37VbVBmzZf2ZdJAy8eyBRKdPdH6840fPFjSLM1AYw/JGGArVJmu0Ud8GjFAfbhAIN4r0twPyj6Q2ZgIwewQdc5QIXyoeWT9yI4QO4jyCQANwYHsNPNmDFjxuURiq5oK9zxEbzh93DiXqjg8x+Zv+WeZ8wb9wLEr3/8vz29evSG3Yev233sj554+5t273rP1Xddc/jsi3rSDQRAYXgRBNOxWxIAF4lDiVepuB9usQAJgNB0ARKAyDDU8fN0YdLwOW7gBkqUE0QCfl4ELJYA9Gn7KWfMCadxn3OjQo9gC6j7cEpguqCponjoUWaV6/jaZwnZvp6aHiSEWk+XUT08KQqapSm8n2bOioaWSE2Q2EB9MeCYsHfy8XvVusvzi6xCNO1hWsB6aKYJKtpi0hQEtg2VsOJ4usMNWqbQK8gNBPQdccUx0W6rjCkb87NRj3f3tw+VKblXB0TwmakIUxAVfYBLmDkJMVHflySD90Vtwn7/0WEJKvA0DpcL2A+m8y0iey7APbJOyQE2iPdzcYAZM2bMeKGiAytAgWfOYWcHj70ZT1+P785+Pj9wzNv3QsZ//zv/zXWrh+RVj/6b95/6y586+vYjX/nR03cffnHKhSsBQGDWNQIA281BMMDSXtqH1jB6CNsGNiqgNzXahXYIqqIf+DtmAquYLCAe4VQxYFT8Mwgvk9koCDcrwgZhYhmwMV+RWQWJ1EcaeJw20Pdf3EFkAtEgtXUoipWIWQJicbPyK2zZr848A2oyIQavFiOpbfvLbgjrC/+TULhJ1ViKQJcOswru6lH3xrShJrgrRBppRgxu828xcw7ekl04AzE3f/MbHmYbB+JgckAsOwE/kM6f6jhS+o788TWFWfaFS5XZJYg00c66he6ZAfUmoTayUNEXX/9Lwx1kF9gUlhsOAiBqaaAcwfoL7S/VI7YAg/dmjQOMUv0aBwjJf5/dNnMAzzbY6fbnADxQUTxFSTzm4gAzZsw40OEKR0Pv6B1dsbeHO2+bv9NemJj38YWPn9affs3nd17x+BO3fOf8559+58vkK+84dtdbTt3XHCG/MPF9EwCC4CAALiP6zqyLVScAWJPPDfYHWEclAEW/L7RhtAwx7UBkzw+VnyBqc8Hy4mhGJEsCEKwjrUS1kLfAcYKnqtb3oAqZ1ggBPviDTdJl6VwqePDxA1T6FV7P6qiXI3QQs4pymS27md6tQNXWEKjQ2Sp01dzq6mah1jOV0Qq5IiuQcPv4BLwfKEsXfOkuNAhJDqC9dURpr3jJL1gsC+lYKdSXBFaI+EphbLFvIr35dgJz5wd3/4uIt/Znd1FT/bWpZZoyA0ADjzuIGsJB5Lao5mN2f4jQlrkOmqz8ESgikyDqBcFW1LGU6gnQ5+IAM2bMmLHNUKwauv3bLBDB7dPq80LHvKEvYvzaJ289jgetXPiPHnvTG49+8z1X/ekrjz36ggyu/Jc+tXMlkCA4Fqr1AcT3JQBpmk/mMCBjB/R54LB/emx8ckkAlt4e4nsQtWtAfM/oOdxPVkM/jJQtpDTBFpwbSJH2qcHbKlZE9lWqdzphFKIr1XpD59UqM8j2iBWskuEIFXozycTVmZIdI4i4NyYvzTX7aJuT/T05zw54l0yJHpoAWu9Ac+M+3LiPrk1FrMOp9T7q2rj0b80zNIVa/37VbAqkaGIpEecY3iq0C9zAw5V9B3xvqry/GwnTtbiDYPmEqHJmasKYjETpgruDuMawIXWX7WO7prOIniKfmx0Clhc7bm6WMHEGosIlCIoqvy7Vo3CA5W4OytV/AtfE+wru8ycWCE8REPLW2Bh0fw6QaQfgIhzARxZnxpMDzJgx4yCEKppABXd8BLf8Hk5+E03wJ7OV54sW886+FHHbxz943c6jL9996GWHH/uTx9/0o8e//M7Td++2H8gapAQH1TwDh9GpFO5HACRLcuHCdtpgipknvnK0rUL9vriGiLZ5auJ+5VfDPpEKyJKA9AtJTnK0+AsrgOPUfUh9pLnIgWPlBqxeSK9OaPz0rjgKH8xI4tzAjUaFOfisGiTGQTjOK3wvSQmz3ygAX4tKJI+FeLOdyACYzqvSFaaCq5cT0I6v9Aux+lZhi/vC4W/jPh3KPv3uuuHN6dn8J9IImfFQdvvxbIw7dlDWMovTITIDToGiQaoI7Hoh2gncC38wygGK9zYU10IWha9Q5pkBhK3L0w4iQSeyjgLiLiOReHaNCwA7JRvB/SapPrbss5tzgIXqH8B9wQG4JTlAadczcgDQwJOU4Fk4QJnb5AAzZsw4SOH/cOPcORzawWNvxlPT4v+SxLy/L2n8D5/4r2489MCxQ3tffOZtr2l/+p6Td77m+JnnPVpg5XUCAKJ2BFjPelPbGq11HGZchAB0blRXN3OosMqY2j9wA6gmzWAqgJ5+jAQASt2dyQHULEFR6wleNQ4XR8bhaB/O4op++cpJQtiH4qtQx21wgJ15nFQw0WFUxIzpifuDb5jCjcCpUjGrPSBfz8sc+ZSuwVJdCS4UI9CQA3X8ahdizfsBFevpCRpyAtxDRW03ddTbIykB6SxLMI2fVhm78KaxGLDnduoaXtDBtCNwklAwOvsawVp5Rv5B4wJd5re3oQ7OpX+hsIpe80dlbUAo+s7QvGVQEjlw5QGI1RVArTuQ9RdCI58t4B5rMJ0/LFg4akZ8r0XRH+oKArj74PH7dqwttk+DE4nVCAHu/QSVA4j/GK/vVjmA8kDOcMaMGTMuhbDfnDsNe4q9Dp0W/5c25o3eQvyDT/38KfnejTsPXnfo4T98/C1vO3rXT1z91eOr89/vOPsRAKGjpmL0wNNSmABlWjtQTN6nrgwkBgX1bE3TS/ng+9QtNnpwA3OcDwgexNMOg0z5HWB00TvzQKY1aP6mZA4scTO31Fkl0LcRalkC4WkX13R5ruKcYUIAoLde1d3/yVXg7vPiBSqDqBQrv1rBcbbtF+ZSDPSrlfYW3FyJSiyOG21JBc2WAPMzdvIEQCDSu12Cmfjj1kk3f7zlE1ozKxGa9D17H6x/TgB3wvSoCoiKZKVZ3+dJe4/GLRoLA1SMDjlfciOQ5V68v7M38RSU5p6U8JNoWRLAD+lo3vFT4lzZvEgh4kmJ5yDV+xxw0S3+yPz1kotygI2NQUO8Tw4QQwFY2+IVFBiTCWW3RPxSxolLmzFjxoxthgpW16A/CrkwrT7biXnHtxkf+8QHbth56OTu3p39Ha84/+X3nPzSG0/e/9wfyUYCQKXfPi4JADIVYMC6EABCh0DtSGdLMIeBACR01nK6hNpakglYg9oYUg2FAFBZl5IciC2poystE6PD3uRwAGGncTjkS+pCFOhmDAptntida3gB4ksTx6peyjraUl3AdEHMwZlMcg8z9GsnMzFoW1CscwABdPD9a/ptPMnQCebU+EPM2SAyyyd8wp5VcOVbc2Sz9fOeWwrCvExmvndu0DxtEho/JwMH91x4i9Z5lebWmmBKEBp+bHASjGjzb/DVOvZ0BSkEr11ERNVbAPn7Y6mJbgmnluYiTw54FyNhr8/MQpgFyH5eOonHiPg3SPXRFGgzBxjEe12C+0HRHzIDGzmADbrOASqUDy3ff6gLB8h9BJkE4MagJaYQzJgxY8ZLHgYgtAEK2QV20I7i9g/O30jbiXnftx+3/YvbTu49cMPOAy9b3X/7E29+x/Ev/Njprx9pF571wMTQhLCyEPVHAgCQCRBhA8kWEsqHRT42AoSeQ5ehSA6QVBRAXwlAAvoN3p7MM0i0GQ1bRbYA8q41C34SpxuKCnwE7uyTyd3CR1FwcMJuJzPlKwzmIskupYukRIG/EAC9jpzmHA3jPmLtLa9UtmW2YuSmCjRol7qScTpwrGxXRaWJny4MSz4UorRAvaOOoX9nCJFYCNlemgK9L1B4EB7EgmW2UVytZ6mDUxHmWBS1DIA8sPTksaro3tCs6VMrPigu9WWVyj2E/6g2llD0fRUClVgcQNT8UUGiGtAAT2XE5EPs51u+D0wHiKQVCwOP2FOpHGCDeD8XB5gxY8aVGQYFFLjlFnzrW3jqaUDwuSn5bzvmA7iE4mOf+ODLD91/fOeZzz/5Q7cc+cZ7r/riq45erGXQggAYyAVhNBESYUaF3ZUAuNsHAwGILIEDnRDmtZhnsn4g7elMBQTmxmLMKB1OAhDcIAmApyOq6j+4elCZBgqGRu6TViKod8hZZCFQFvlCrthFEhUXZXJ4Il3AF/NCd1uORvkvZ8J0Qa6WZZ154N+W1pxBPAIZU2JHzCGEf1Djt4nlCsQi2uGrCKffhr5/JCj3lX0BeH9S6dLg63kZy/IiB668K/W5BD2je0dUBU1U2dwTYd2Jq2uwkoDGZIgt2iVsChRVAS7VB4/yYgn44gDQbtZ/T54Q9xu+FwWXIYNYDQCZjJ2lGSxWEgMEB0gZfn+pHgW4By7fyAFGqX6NA2TaZPNumzmAZxvsdPtzAB6oKJ6iJB5zcYAZM2a8ZNE7mqCt0DuOH8fuLq69Fv/bfzF//1wSMR/DJRe//E//9jU7j7xy93sv233kPz35lvccu+Pdp+5ZeQ/6ISoBCES+kQBQDq/m+PDfu1ZflHiAUNWkwmACQQBiBKRCT5heDgdiMkkAQtp3WVpYbxCDezaDRvbiCIpMgsS1EHL1DaYgSeAONdlbkicQ1MrALmA1AFzkq6e8DQQrqJNRnzl19GQs3j3TcS3nmYdz0QAFa2fBZv/lEijrujbP0lgjFaHfd5PPoV7y69K+42/31ucNp3AO4wPusWEfJF8xF8w2sCRXI/8AV9/tWS/LdlWtILxpInXC7sg5wFZGI4UQFjdb1S8JANlpo5mHNh5zLtk+3TkYuAJAWTuMN5NLj0lYmLQ5cMcA7ufiADNmzJjxA4ZD/+vc5S9tNvK/5GI+j0s3fuNTH3jloftOrM5/6ak3v+Hwne879eWrDz1VdwjULuHAWSMA/o9+Re2VAIhD40TtozvIEUYODt/H1UgZvyJYB/1IMSCnmiQhLCLpsdFA2CCpoCAdc3NFP31KQmk/vzIYTcXaawC0m8edzCHnE3UCOb2YUmxpYhW6JqIrxf60GNV5mrc+t8AX/4JPoGjqtl6v5wpMic/n1byPZTIHh/Jcw0tgnXwknPrauepW9uRRUZUeXUFFfLkuWwoATdG6Jrj3HvmcQ/ANmov8r1DR1tDdXJSGHDWXl8H0sOgE5xFWPMdtLwsIOKKlnO/1Cep1Aj4OF/dF8w6kZUUC5CU0OoKk+7oBPkJJL4gTTf+JIrgPRL4u1V9sNwfl6jxgTbyv4D6GAhCeIv7EYdkYdH8OkNySr9dGDuAji//ITQ4wY8aMFyFMsmlmat2F7ECOTZf/JRrzqVzq8Q8++aFrVg+eOPrUlw//0Gsf/vp7T3/hlmMP2ldKYS+RvbpuWDMAwCj8U+p2ebESAIJ1Jc4wkBPIz0wHKZYXbhCYPhV9P138J2uTDCm3WIYc2uacSQno24laAqi6nWYgACpxugCRfpNGSmCNiaJieAT9yTdoeSrHah3KV+qFA2VFT/He5im+0cF08TXFJGNAifpdAQ/nSf0/avYitkqA4+/mBccq6lzFhXlLGnRzzyOMN5mFsAmT3ghdJdHb1K7FgHgUQ9vMWxzCRIc5f0ir6A6KZwHkzinVo4zpjUdjMmwhqkKm1JQ1yoAUjuFlAPBLaF6XbC9nF21N0WCLB8dlBgegQD40Bl2X6mPLPrs5B1io/gHcFxyAW5IDlHY9IwcADTxJCZ6FA5S5TQ4wY8aMFz0EZxsO72GlEOCzt85fL5d0zMdzMOIjf/CR0089/PL24Cv0wc+c/eG/ePTOHz/1tZ2VdWjf0AnU/7kPK06i7SQA4G7p+C+WnuqxSUeQ2gAm05YBgwAg0b/62IFugaQBCwMPvBgUiP6GkbVIhT6AeBKVJAkmkiKQNMpXnudYfDUUCUBoiIcAbBkkmStY898HgscwcqQFvDDDGgG19PpDtKtJ8uZHN+P+UDAA4v5MF6SnX+sEtKGhe/Wt33xO0hv+IKV9sTyDcN0AW1I3LUMBoJt4U6B6Or+T5ANGw+jpVw1V3iZjhzSFAg3W+UdpE6JxSO0rg6n2wdw+zti8VNrX8CI34OUgPD9+jWXFAHhZs6j5voJvpGGpFTRvL7qD4wHcYw2mw3+4DJ0nkh7xPc1LCw5QgLsPHr+Ex9pif92rE4nVCAHu/QSVA4i/uOu7VQ6gPJAznDFjxoznHdLx2Vvxut/HsXtxXvDVX5y/VQ5AzId0wOLXP/XXX7Hz4MnVM186+8Y3H/nS+6++88Tq3EYCIKk0O3JwgdztCIHaCwEgnEXx4TA5oOHDEZKEPK/7cMBuoSbSg+v7hmqOyDxUAkDcX3b2fWQgAJEuEKii+/6cIcsMspMmypZQ9JUJkEgpVOF/sP0g7CI9lPsC7l1zjUxCEfW7kyj70GwCxdnPVEY6iISYWK1Ylg+0dVWjPbWQN5ceCzTs8/SKAtiCX76IWys4npq6ufOVliFPZQS9cfjujKvb0gEKN/DwqywVKOq+ApUA+G2sDftrBkCyh2knEbJenzZz0LSTFiDPLVjqQ7ov+MU6B/M4WVrGmENTKLRxZTSvRba7tIkDPAepHggYvf8Wzx35j5ZclANsbAwa4n1ygBgKwNoWvpNjMqHslohfyjhxaTNmzJjxXMM0jpWgK868EU9fh/t+ErPD2AGK+agOZPz9T/zt63ceOLnz1BeevuX1u3/+V6+649VHHi0qu0c6fyoBEIrzDra0ytg8cCAABu4hMdTwFZIA0BSdNnpUkgBN5pAHEm17k5zCJUKDj5kHW+gaiY7MLaQGD4DidzcQFcmEAu7VxX6BL+lFxT24gd9ANV9Kb+FvYWYgrpRL6pKxcK3fKAxA1fhBYdsvqoD7oEO1H6gsmENXQRu7/fCD3wo203TM7cq6aGPJrDQu1wX/4B0/syY4iQpoqmHbGVXJAgMBOufvpnzximR4Sx9376SBR+KqwcwDz+XAPQoGRMlAWMir2lTtEgxqk8P4gl9RDyCejoBaVUCHNSQV73BaBPJq4OFP0WJL7rndxQHGgoGYpP+YDxeSTiRBJgF4YNASY0EzZsyY8RxCFdJwAVhZq2nB7b80f4EcvJjP7ADHhz/x4atXjxx95YP/8f27P/G7R378xOfeeuI++4oGiQ0EINR3/6DqLUTNzlCPKjmEwg1GAoDMKsRZgi2EVwcqMauolAW10TyXq92ZMXD8xDl45ajErOhliG8Lo6DPO1CsJha3k/ayfwsNmymIRtoQBbsh8AvEvT1m1tcuDQp25Rex7cwewLv0xAjONKDNlwBD1CQU572QwzBN0bki7+K/4DDitEENoHckA+nS2ADHHf+q5Dx02mCh0LvlBtCGBnfm0ARFxsK1fuuUjB6wsFickrVILGgc6ykjX1aMg7fYDRCu6kVaooCZ+5tAYasEsE9orLkmqtI89ZEz8cZEvuaAKFrhANUYs7ZlI0z3d89x9mDgEedhhQNsEO/n4gAzZsw4QNGBVcdnL+D1OzixQge+ONv5H9iYT+7Ax0/rT7/6CzuvfuLRN3zn6c888ZZ3H//CT1z1ld1V30gARNNRQ9idBADBBEoyIeCvJIIn7q9qfTlLqSWInVHzDJVUxJ9WYKDCqoCA6a7Tw+T8xOhE//Fhad+vgB6CoQyAmQFEnqTI7SizDQk//PempabYX8z6kayAZEIgeAtYQeulEYHOIxUAmmdC0Ucvl2BXFHUCqjyLsp8mrJSCANoJT+vergeIJqF+CfZSWLKlFQIAWnS8Xz7yFlUCYDfZ+oHywOz1CUUD4kHYnyyHCHsPYb0KtK7sa2p9M6OOaNRR8D6MfUjLPuYp6gDYCygeBJqgdUsj8PDRGEMoX9H8RaR6FOA+eG/WOMAo1a9xgDjXPrtt5gCebXAL074cgAcqiqcoicdcHGDGjBkXDxODRHCm4xnFfR24bf7GONgxn9/lE3/vEz/7ykP3X7U6+6WnXvfGo3e9//QXT+0845YSYnSNDEBuofzncBYIEJxWmcoNUndf7pMHhoMoLEBrwBrC8wYKp/8H2R0IZYv7vPNbLXb/xN8xASnAWtFUlKBWvUjU51PKfz0hUNjC4NSHA2IacmIFMd4QJwBduCXKfIEOZgZ8Jq22E3XeolChQE7/fRcmMaqniPi+o9ErZatroSvlcHXVHICtI6ZMJrg0Tvjo5MQ/uPCfwBpSbrXEYsBMKAXij2W5HIsLPG/gvh3vIMTDK3OwFA1o4q+Ng7K3T5iOBB3WTtRxf4+3onn+oftVgwanoBDNFwdo1oMIAbgT5QcErzJ5keoJ0OfiADNmzLiMw34ttYa9PbcVfP6X52+JyyTmOpVdUgAAIABJREFUg7zc4tbf+bnrdh66anX2zide9/rj9/zVU7e//PATCuJsEOKPBEDCIu8EgJK8A5fFV/zPwIowSzAmEJw2dA29fyH8D5wBDmwCvqs1b4mOQws93mVYUS37lPwGqiQPrgzg2JQX7vL5sgLYQGGR3m3AcPVEvqIcCM1y2EqEHMeD3h43hPQE+mD5hLhHv/Ac5wlOohLud4GtRuz1BsEfkoDZga7smn3Imn4iuAH77hfqUlR8llLkClykYaCVSLK5UOn3z5LcUL69ZRCHYuN/8cWDG9C5KAEn4I2DPIfQVLUQjOZZFFuvwPlDY0KjlX6gZeZITxF8cQBh3bO9xQMHSLt8gPtA5OtS/cV2c1CuzgPWxPsK7mMoAOEpslnZlmQguBgHyJtvj3AfDuAjCxWCyQFmzJjh0TtWgvMNK/NKylzJ63KL+Tgvz/i7v/13rz505rqdM9996tprTjz+/qtuv+nwmYraqxiPBN/C5ICL+vsSAJrsXUZcEADHlwRXQ01wJhlqLiKTCZFACI8N5czgJOqqalKI7jkEB+ioKDztOr6PFOUepSrX78mQUiiOqSixdSGZSxAgwDqolHtyoMyzZYog/EIm/NPvBEQlQOwmQVf6EtwH5o50BPmJQBWdnX+ApXkmJ8n8Ay9KQILE8onmtpy4fFY8s6sPh8o+POKte3qkC5ArD3A3iSJj5Z1hWqAsOlY+xOIAdREDf73q4gD2ujY6l6Lg2F8naNPW0EtuRKqabj89hQNQIC/gfpNUH1v22c05wEL1D+C+4ADckhygzG3kAKCBJynBs3CAMrfJAWbMmLEeCojimfPY2YE0dJlG/8szVtuewIwXJf7wD/7w//qXd7zrP3/v0d1nrl+duSCH/vWZHzuEszfuPub/ukv5n0X8rWAP/zu/0noOcQ99PdAVZRlGH/fxcYR9Pxfn1TBWZEliQGTbaKP7t55qMKzWJHZzWOnIKoVaEdCIn8ibMKk5HiP282O5RQDAl/0CcxEQx+iQmID4BdZTG9pmQqAQGwANMasoLRVAmk/agLVdujS1nSVuXXqZ1NY144ES0r4Qy+ZtgUhLAOo3n9crfAQqaOKY2HcqVhPhIQZSbVUv8VM6tpZAvT5hkeavhAqa3zhwypxji4cYzz3fFuUWSY7KV1biOn0OfHJip3PQbwifwDoMPA6OF5epPCPqu5c3NF4A3uTxx4vPaTxQeJYC3JHXGLtKuV73zOWjh5DULu6fGDfI3UTLzCVOtXYtkwPMmHEFh3Tc8Us4djcOP4q9PXzpV+SBf/f3tz2pGS9KzN/yV0R87J//9Vcfuu9YO/elsze/8+SX/rMT3xBR1+8DQ1NE518dqbOiN1rrKH0jvhElA+BCviEOVgCPdiNhTgA0mVStXSlpg6aUUY9XW1kWjtFV00afOY1q6cnMg/0fzxsNRoszqtb7NjHbSQjwDt9tPYQUoT05AKi3l6meophzuG7C8d+Vl+AdeLyTDxDulMxpqHZE388wyTBRkG3+0dl7x7vdR/1rzJ9OpzTZg8kWRPceILw9XioQxyoBtHv66fYJGd6zIlknAG/O4/TGLyEqg2v9rvJDavx2IES0+6IELvkzUwGBrS/GG2Jrgbm7KesTBOhcCLlHesTOrqQKdNSkom9saUFkl1uQPK9I9Zu3eOIlme5oxy+DC/jSzsUBZsyY8WKHdKjMjv5XUMwHfAXFr/6zv/Hy3QdOrp6586k3vO34nT958is7jrFDR08CIPwwEADuSeaQbCFgNLMEhQAENF9WHsvwrbgiHg6iaF2abEEkzyLSVQnu/Vu35UipFtCYJOiel1K2S6oAEgmvDUAiYN/TuUT27JeYSTSaLO4dHg4rL2ZToB53Uoo5XsTXuGVToA4RZBvQYBpR+2vDcuYtPpNNhVUm7kDprpPQvGnXyFpwwd3CcIID0L4lNlQ4kVgPYIMjjgqwCxbpAhINf8Ale6PAlx1Ou5EHljdoZA+UxicjgV20q4ovaia+rIHmesC2Zln3FQBU+SGGUjFrq/8MBAcIcAxUAw9it2FL7rndxQGWUD60fP6A5LTTiSQ+Dn9mCwcgC5oxY8ZlHdHex359f3bW+F4xMZ/0FRd/75/9rRsOPXjV6uxXnnr9Xzj+hZ+86quHcMEVcYNrAFJNj5JcIPdB7LNOAEA3vGGegPiGnsW73Q+VA4TRJkVrbOGBhOCGoMqUCgmxbIYo632768pRG1CuBcwAsG4Y4fKHzcGQt5UXO6PoCmjrhQ9Ee35eaS4GHP+hbEEtLFZ6frwSAA70I5tRuQGgtmKAcQMRAUsFIKrorYGlw10afNlmLnpVSoppYRKNDwplR50U1IGyIACorFvegA8aTRs0G/CDjqPo5BOPTGxlNFKsSCwYd2pQRS49lmsCKJr2hgbRlsskR/dPkh9ExUIUMGi0HyXtkegxSvbSnaVIVeXNOZMcIK1gG7ZshOn2JXF20d3d8T9ygA3i/VwcYMaMGS92qKI1iGJP/Z/12d7nSov5vK/Q+OgnPnTjoftPr85+7ezr3nLVF9974s7d1gMGpSqfeQAqjITmw7eB75GYu7IFB/H2lbrmmLW5Ae4VgPbcX8r+AZqj+raMXKjC8s+gLpkcKDB9QSpS8/aJ5TwzIZDyvwGmPnyr2inSI508HemH6ZU1lW79AzdQ6WhgxgCtRfKhF2W9CP9QbdZECDZaV5bkIup0RdOnhCbawx9FDG2PPkuBHW2zjVIDoFmSm0mAItJ7WTAA7eJWfmUxbgX6vphXE6Ubyh9QK3ejMefAKmFajyxvQLNZ47noIPKXpuWqxswhiA3VfbXmgQP4K17LYQuUr2j+IlI9CnAPXL6RA4xS/RoHiHPts9tmDuDZhqGMYS4OMGPGDAsFBK1ZOwcI5jq+V2jMp35Fxy//079z/eH7T63OfvXpm998/MvvO/nlw62HQWUA2eolhdUIROE/QCQItWvewMV+ZEnACMcr2VCo+cwJ37GgItUdpADQWd+Y2vngILKzBCVQ2GpiIh2i3TGf6/0Gr90uD1+WOH0141kQxnfD9zG4wBR9if42Mgj/1r0erCVQ6c3gPumH31gi4KyIiHvCBqAIq4yv7Cuh2SeeJpp3aFh8SobgNdTo2v8nXEDg0gds7mkEYKAQYtYarzSgxg8mCiBiVhy69mPlr2ZzBhMCeaXdaxjQwz3FpkBacg7S2AVodAcZN7Clhc0UFHQLsLQAFNqbthb4PjlAqv4IJE0GvJDJi1RPgD4XB5gxY8alGaroO2gdDZDZ2fPKjvnsZ+Cjn/g71x964PTOk18/f9PrD3/9/Se/eEQuhMcGoaPX+l0gNPtIDozOn3TpOD7RkRukeG/4ntRi4A/iyKTK8GQjZXAB7TpZXRAem6AENiX3loj1INoEr6MxKOCzSvtNDt5C8KbAn0kAwP0zGiK6CrkBICpduQoBRvEbYlI3LUzhJkLXIDOi0hTVlSSqok1EzTwTajcNVGngCZMMOE+ow9/iwEkOMCYEtEGUAN0TAqPwLwCX5ULTDrTiRMrK3fD329wEhuz99kqlCoWNiDt/zMrfVaWJs6BGCpEVw8gMBh1ETgZUcqGxVj02F+cAaZcPcB+IfF2qv9huoOFWh6NCvK/gPoYCEJ4i/uAABbj7VPfhAJl2AC7CAXzk9UzIjBkzDnAY9De5Sxu+8Ivzh/pKj/kGzPC49Z//3NWrh0/vPPn1C6+5Zedr7zMaQAE+dHSki4YyvDrqSEyfojtc7SamR2j5IwHoCNqgCdbtAEfDWDTsJzkpyDvrfUNHr/uLQqvHZuQG5QMMTmlabspZkgkkJfAJmy/fcGSPMR33Bz6upQgOuLvXEIdBX6JlPmzYML3QwNMbRfSQ8735fZ0tWwmJFwlkgW+mGqQC8aRDNCypxldScjVJLUplduQBvJUQvErbbPeD8A+bsJ0XZW5Oh+KvDaH6x2XyWJ4lKpV9wlJ6AbEHUXiKhIUBwT0Eg0ifHGAuDjA5wIwZBzuUgp0lPif0n8GY78GMIT76+x+6pj10Sp742tlXvfX4Xe898ZXdtmcQntWojigK2oaDzoL7A4YCA1tY4HI4JtNom4NCAFLRRwBTwFrdV6RbDTZ+InOquOWDXMLYhXRAUCV2qAPrqOg16KnE4plScGlcoNq8mjnOLpkBKAJ8qRxgUoJlygCkh4MlapFBOJtCPjxv4IfbhI05OFAmMSsrjhWkLon741sK6nFeDQ+9Pd+mgBDTR5rCDTkK9a7/DqlL9gAmqwvPaMYn9DhvXbHLbUKZZfIplaGSXThVkDiRoX/Asg0qzUiUtwHVoFI2oDrob9YJFN4/dETzxmCBTeWwmQdwcLxsHLSA6RY8RcknoOJ7LYr+UFcQwN0Hj1/XY22xfRqcSKxGCHDvJ6gcwF70kQP4D3PhAItMyIwZMw5ImLRwXrHiv9OzzHdGjfk2zNgQH/7Ez95w6KFTh87etffaH25ff99VXzzazhOQuVY4An0Ttovwzy25c5p2woCOYtYPHV0dEgXul4LseRbJdpyag2d1QXUZBbVwoR2RmhCJJYF9zmkHMliphOOiQBcRjdacA7JH804+Nk6nKymV8gK7fUrZ7MhhKM0tfo0929rYbax9h7K0tzuziTHH0xnUS5dRcS6Z+yVYCojpyyIAQBppuLxu6Ohp+ynpAi5T0AVhysraYmM1LfV7epM0tmQDU6L8znO59h+UQ2MoT8soqxEgQEO316BZRQE6Yj6gcQjeg2gw8Ki9ms/OAZ6DVA8EjN5/C61HdpvSwLOJA9Rq4+AAId4nB4ihAKxtIUkekwllt0T8a5mQGTNmXNphv6hlB30PqujAl26dP7kzljHfiRn7xs///oeulYdPr57883OvfuuRr7z3+Fd2pCuQa4ElhCWqTlUeLs2K2PJeFce7fp9Eonp1TIENq0nZgZmHrM0VgWo21UmPTbAFSvLBXnImRZiPvEEeaFA1CEBUFNBkH1J9SPscp0fdcFr8A8I6zu4Q1R6FvCK1B6gA6AXl2z10IxCie2ZNKaAifoNqucZWPCkuOlbN/VzEIGpwG3IaRYMXUbfyK/zbNdW/XoI9MIn8Rq5rRkaR/qjcYjkHgXbR5D/JN6LXJ3uVovYXYurGj5UyN1f6u3ijJCsy7mJLAfgbXww8m/MAZbd1xL9Bqo+mQJs5wCDe6xLcD4r+kBnYyAFs0HUOUKF8aPmkgggOkPsIMgnAjcEB7HQzZsy4JMNUf3TLsEIa7piGnxn7xHwzZjxLfPh3P3TDzoOnVk99/dzr3n74cz9+/KsGAkUoG/MDYouWz4Y3RiEfoff7ztVF4wQghHDA3TKFaeS3hK0OuEXWSwVEHU8DQIH45qhB4RJmLqr+GRIAODdgw36glPYGyuq0xGisOJbSPl03nj3g9UJEWydPUMDaMxjW+v/Ze/dnTa/qPPBZ+5zTd3ULhEACIRBI2BicDL7DkHGIPZOZzDgIm0s8Hk8qNVXjMa5JiG8IB2InNalMTf4CalI15bHjiySYmpSrUhPbCYW5GtQSBmJutsEGWgL1RVJL6tvZa35Y61lr7ff7uiWB+nK690J0f+f99t7v3vt9j/SsZz1r7fw8yv2dyI/BPXE5fACAKyrsO0boHAg+NqE6Mw3qBYsoi2JYAEDcK8T3ed84KMA/OOnO83092ziuqHiWsC2qiwpThLtqFBeKM4a9F88Rc6fOXR2YTEjVtUCdRYG4XeoPzoVDHns5DzGfrLyAAp6h2fora2E6N81f9+TdXfE/+gBryPt5OMC0adMubAJskymB4v4p+Jl2QZvvx7SnZe/8N7/4go0HD7bHv3j6Jd+3777v2/cXcKxcNPp2RZ0xpHzfKf0VCdBA/AMZHIgYQtEURZsSGbAalNBg9FEQf7nogBujB0JCHSDd2xEYPUqCqiXdCqS7YImkfsBfgIqjEk9Ai0PBiOBFRYpzIl0VUesGUC8llJU9CVtNDoSs6O/eQpNMX67eTnP2WirUtmVSBeS4PLRAKIA+BPrhEjTPx+jupUh4MpEbEIMrxAMXjToTyRVF/c2g9u1KOgxQbdoAFe2N+9zgvkG4QNT5dDLZUWM0zi+D2InCqBkFPHkgxEgerAgfYNTZe3cDwkM6bIHyFc1fgKpHAe6By9f6ACNVv+IDxL3O02y9D+DRBpcwndcHYEdF0RSl4zEPB5g27co0TyUSKPCpWdd/2tOw+ZZMewb2zt94xwu3vn6wPfFnT976uus/+crdXw/ZvcN9YoUR32swzXCQJ0MDw1eovkH8s3QAykVApUNNyi/LbAGS5WzJi1qdCieYM16xUAepppA9cHxA7aBajINXonZ0FWVWACiA6WTria013BVYNrCjecYrMoc1vKPk3aFKkI3STCISotTYZMSALoFjYkGgdlL1pcyR+uljPFoLUWUI5qjEnyHZt6ffon4RO3qJnvBJuCd2hkBrVtFfIc76Z8yBWb9eE6lp814l26FJCXRwT+ghuIw+i4Tabkinw+BOSKD5AtwXPkCy/ggkjYj+DDR5oeoJ0OfhANOmTbsY5jyDAsADU+s/7WnbfFemPWN796+//cV7vr534/Tnzt32N/Z8/BV7vhHMNwi4y+fBAUi+uSqIEmbZv8jU6+4XmI74HEy8d/RsRsfxjmKhroxHNxgnlgvVVDQJ7+oAFHDPs8BM6uTZt5xGOdXL19ggYGUe2BG5VA1Jr95IOTiMFT+D+Cd1bUU/0ycJFtylVjCCPCrqBKrGgIlhfk4R9nDJoS+ihKaEBbRzDz2ztlYEYtwADdq1EO2qzT2lgN3xZ8qrLL24hBQKRvfB3SWIcIHEOQAs8iN+305BVIc0QQ/fKRKdPcdX1Mv/g26MVRNCd+RtQY+U449o3qDzhX2AlMsHuA9EvkrVX6iZg3J1P2CFvK/gPoYCEJoim5VdSQ8EF/IBMuwAXMAH8JFXIyHTpk27PGa/fs77Cw6/a/4+TntmNt+Yad+i/crvvP3Wza/ukzNfPPXSN1z3kRdvnViQ9EgKnw4AowTO+geu9a9cjmIY3QBSiM6HgEAR0CsUIzcPFW3ofWDNY6hOrA8X9AcqJVJHSvaBcixx4uwg8g2+S0DqbqR++A/B6ANxkq5C8vRigMQ/XH6jjGwkj54ujdPhGnOoWcJQ8EQtadoVZMRzWyKGkMg7vIumgGjw6OnDRCzFaXhzXXg7VxlpQ4N2oYCH2cZ0h9CBCHF0289mmbhQQYdR+1mtH5mIzLOERVWYuZsxBwG8FpBLerK+UIp/JI4CUHcAwKJArCy0kOJUHyAxcSJp+yUoPgAJ8gLu11H1ceU8zdwHWLD+AdwXPgCvpA9Q5jb6AKCAJ12Cp/ABytymDzBt2pVjCjTB4dO4bRPPaTg8BT/TviXbuNwTmLZT7Y/u/cTv3f35V7/xRw/i4Q8eu+Nr/YU37frmvnaWCYIu2rHP7g04dBFeEvtSopUqqVKBkf3WNfGGX0djp+EPAcEY70Kdg9A9IJCKOzmwY3fABzekQwm4lEUIICKRAABtXK/AsmDRZJhVhEdEVCRwpq0ODVSwWA+vZcTlBCnr0YSCz8CJ1aUIukJ8wmiI+UtdpuZafBgLFOTMY9qAtHhIfKStkNoijdg3AGg8bj4J5ZjRTMtLAN+nAjRFIM1/Ui6n3JSzFm4+MbHEJLlvkk+wrKJS6XEXEEnnUJKvDVLA4+B4VNS4Q8p1Le/Il114x3htC56W8juRwyifXXlxS0cOHo6KvexanrjwdY7Nib/tpWQzWexhbsG4lukDTJt2aa13oGHjBjx2GrsVf7WNI++Zv4DTvkWbDsC0b8s++P5P3va3X39o19n9curjx17zEA7cuuubm3bWFjlNrWCI4EED7SXU4F/rfIOQqju8LL6BOiYiIImExfA3EjJWAYXEBDT8jQLKguMHRO10KTFq3yjRir+zY3zrTHbkGTcfkJAy4axKoEtYQjDhuxT4DpK0VoM+QT8oRhLXsq/gzkD5FfI60LW7BFKmyIWbgBhOOSW42xN+SDofGg6eoFkzEdFYb1a5EdjhxNJQpmSHCmtcyac1+Dwt8W80bHQ449FD3JkhJvYB4jF4YShzM7SAfpCqH0n3eEzuA2DFB+CUsxevxK4mepd85otfhOoD0Kt5Ch/A5hbRiTI3+gA5t4V3wcEr5o9NWzdzzmo5zrRp0y6a2W/kmbNouwDFnuvwhZ8XfOCfXe55TdvBNv/FPe3ZsXe89x2Hdj9y/a4nvtxv+67dn3n9gc96yXhFoDrKeKhmMXCi8NqaAheliIbqHSHOieze8gF0ADRVMeEkRHKtII76UoHx435KV2D0kACh1tbMCRedPUKApFFKKMTudt+UzZSVip/mGw0iYwHKmqTlHN/ozlo6YJKx63ByyZTKKDIrt8EzXKOGach+sjqQz1w8NYLymw7W77fDgCN5AEwIVoVYTX1Ybm7OxIoINfd87AwviUpBNTlYQDVR5AN4Ec/4Ck21wQUqUm4h8NPWzK9ocbowl+nyJMk0Za8QCv8Wdgyw5ydY9KmoXxLsFgGPez6ggCcVNXz24bGsketky6vrcABKmKZNm3ZxrHdsi/+3ZHsb/+nX5q/btGfB5ms07dm0f/Sbd9248Y2DG4996fSLfuDAA6/Z82XifqeDa2UeSvNDvk/wbd+qY4ySODtkDJeCP0qQhxWMXlX7oMwm/ISKgxGgOY8dEFGg++2oXAc6HYnQymdoIkbOf1AygJf+Ru+ASLcjeInI0QpGZxYE6hoJ+hPWe9ZEoGQFWncel7fONk0VVuGUuQGxIX4LA9zZ3ShzV+H7TAivm8+8S47JERhdkTFpgUcOO6Zssb32Pkhsl+cfI2v8Iw4SbioN2t27IKz3ZGKISrMDiTVziAXdqhsxGbo3dY07gfvSBxhgukaDGmoozdZfWQvT/bFKVBxK4C7hH5ewSaYfEJH79Tr4umZLNH+eK5B1hUEVZUXzcIBp0y6xiWLbD5mZB/pOezZtvkzTnn37h7/xjhftevDQxhNfOfuiH97/8Vt2HbfDgBN5C2sBOdanA0BvgZiPzD0AHq2lUTC0tDek6wfiUm0STkXB3D46yf7mx3Uh/wzOHooeTkuUtJdUIgXhzW/H4IZKb5Eu7BfzuF8XNalW1j+qZEZwwAIduliUlGF5PSuHNo9FZAEcwvpaEhQVo0f7DH0YL55BA3AHLG+7N5tkhhQMzdvJaKY98eN+3RspcQARR+SI84PR607G3JpCVRvU6/dzn2PkBmHlJatDKo3UPpODAToY4UQJLAXZPENtMKlM8uIYfIDCfKcPYEB4SIctUL6i+QtQ9SjAPXD5Wh9gpOpXfIC413marfcBPNowpDHMwwGmTbsCTIP4AQQ4PKH/tGfb5is17WLZu377Z/c+8fin/+pl3/mdX/2R/R957uaTScAvgXhxAAyBJIxGwfFB/5eAgIp5F0zJDRyMLgFYM4wAgGU3iciHuEHw60Fa60i3uwMQCiLwvh1CwF30RZAOkSI36iHvcZeGwpWQElnAIQj75PspASrMegH3VlGHDo/nC1gNoiTjI+4BlSzzD6GHRmadSFeDqi9nCNB5o3uQsQ4S/Ag9Em+XxxSYQwIvCmQfoiS/NKhGQSQErKc7UfwK8BADxj3iQ4B7NHQPWSDjBlLUQfQiFEsfIKQ44QNI4vv0AZL1Zy8pGpuBJi9UPQH6PBxg2rRpC7N/F99xB44cwcmTs7T/tItlMwl42sWyD73vk8/7njc973mP7m+nPt5fd/zcxi27vrmB7ugfjlDzT2DgL8NKvqwxnt4KBW/ElSYw7G7oBelaWLtQcygimzYGkrgLkODbgRBDE+YbEBzabIR8sd8dgb89e1MQZYjCJ4m8TqlrYeKvIa1hSrFX/KCre5bfEpw2MJsCyqJAgoG1DSIYYFPUrRimJ8b4KjNrJRZuCFiGaZD+5v7Eo44nEs0IQQ25KlwNBauyZADdH5mW9RLxsq9AoaxlVEi0uhbi14Z4UpxrfbWECJooOVNyiX1lnIdUJI3spXWQ7PFUzfyNFwjf3Prqj1dEhu9Xf4/sNc0BzAdAbqZyQlkUCH7neOGB4ixx30TL7SZYmTbtWzSjvs6cxb79OHcOz38+/sPPzl+oaRfL5rs17aLb//Lbv/bc9tCh9sifn7r5e/Z+9vsPfEGca0fiaTLrCFJ/IP69JQbin8EB/oMi4OEH9lWn6pk5MGhsusJl9yiJCi5Zcdo0xzQdPBl9+Iemih7HDIfYxu7SQqXjlPzgk2ipGpQKHEGJG7j0pQQWsEgFdpFMaoGA2MDWgcwEAHX/gzQo5TdAKnNK9q1NzyrwlBPNTHnP5ODhLLBIDrYd6E1ic5h9myGOzEbwiqiRMwC1kqOS53yhafcx1bya3vxoMBcjIZcZcn9t9L6ab53tswUNQHAf3guWUpyqsy+YuJD3pdc8HGDatGlP1xQQbHacVWwrtvvM9J120W2+YdMukf3Mb/zCzZvfuH7jib86c+sPHfjoy3d/Y21JH1jSLbQ7Ei0UvgRUranDYjIQWPJuZgJ4lR6Ia2Dgmh/AUguMJ9aaTLxIGHCHAUvULl0ECtP29ILR0+UIhF0ap/8A6tEBYOW+EFWRYRrcHxfVAITRTBcuTkJCajYz6ZHnMFRxDijgCWEMJAU5iJTcyIEGWpl8U0A7Cw31bKae0xwSIDpvnpIbDoAtoVVFEHMAPMdXoegtZuW+VlekvogKK2vvq7OZA9LEXALxE8T4UtnZwJDUUxFbF3Ac0Ya1aF4REYKiqEk0H5oiXYL76AgwHhF3HBU1I77X8DEGH6AAdx88gx7FB2CgYVAilcJB6fksfABhgGalWfUBlB05w2nTpj0dkw7dhGxDgKb4xLvnr8+0S2HzPZt2Se0XfvMf73nZX33htfIdv73vb13/yYPtVEBtDGJ9kvoF0KOW3xkIfqAEE5zmd1BILVDQ8DXykHAZCvFMYof4jEioEt9FvZ8aAAAgAElEQVSDJYCQaFtCj84QgaiqdDS6K2ToJcF9TkkiGTrV+Uo4VWuPano19Svry5xX17JLhEciIGCIvyvESnBaCaBeMH0RmqtI5Ph6Y1ihTGQtI+to6+pwIVCw76Y7cik/5xnxBz/1zCC4KpqjcPc3kBWHpClEIuM52pgv0US7qYMk0osz1UG9hulYYzRCTKIidvIxshhRAe5M1Q2mXyq4JwS3N+Rp+ABPg6r3CeCCV5h+oMjbnc8H4BKGwqBB3qcPUERNWLnCV30MJpRmifhXIiHTpk17KlPFHXfgwQdx8gncf9f8rZl26WzmAEy7pPbR93/spn/9qhs+vXVg89x933zDie1+y66jrRQYX+CGQoamBMibEYZlVoAsuotnWbpSuXaU+MibCihqUO9CIBi8L4h0DSCxfxEdmVcgAsBTcmPmnEbOOJeQiDCOinWxvpQJC6ldXh/4Vm5BQDSJ2RKrxWlZrTlKy7k1KftgW5/7KQNatQ9+wQBl3E594YCAQ3Ljxc7wcuGN6+/FmfHhQTCPIjXy/vQ9Uq5+yFeu28b3okncZmum3CgPZSjylgVS2+DejMJ3aJXQ5Dm+Zbpl7hw2mi0TKobpDp01Bs/RJdYVD0B9UjG3IuIvb0iog7KZxLb40GMehdRVxRVB7SVlJus7hhcEekHTpk1bZxbN2yXYsxdnzuL5z8cf/sz8fZl2SW2+cNMuj/3cb/3z6zeOHNp49CtnX/jafR99xe4HC49OkQ+J/yrIWXD8cHWGJteuyIKh8YE8eofHEJCovXzwwv9OZ/pMYBr6iBtIRxDPDAiklF8NrfY8gipcF2r3s8w/xUIeHEAoZAqRH4NDMobguh02yzqhCCJc1MUtIqot1ttdKcRjv1QUoaIpRxBkNEAgLMeZQQmEOghdQn8fI8dRXDVeEeU7wTwBJPE/rCU1RT5U0468OywbIVT+EW2AH0qgPgFPM+BFT0voEDSVBj8coGlI4Q3frpL3dKvWEvPJykv4rEOz9VeGvIJSGBQE0AsBj3koocwZ4gDsRY9qHHxds7KEC12BrCsMqigrGguDrkRCpk2btmLNyBNgQ/DHvzJ/TaZdBpuv3bTLaT/32790y9ZfHZAnv3z6RT9y8MPP3XhcKbc2lI+auRsYffANigMAuFifVCwxLmG0I3itUDvhrNeqD4mLf9V5F1itT3cqhvTZHqJ/UctGyNtpRgYSoBf/pHfPRkBk9NpdTLtCr8YR2kK1D4JgmBQHRWOT+QausXFwr91qcdJV4Mgox/2CSh77anGOL/JHJ9HNv2q+TGr9XeUfmRKhwzGGXZsfK8bDfTPb2ORMw/m+XuZftamqfwAgDSp2fnA6GNK025OydOHmmqLiIwGNCcd+u+XJvtUHCE8gfIBRZz+EEebhAPNwgGnTzmceToQA903oP+3y2Xz5pl1++4XfevvBzSe+cOaVr957+HX7PrUl20qdASE7OgSKRZovQLivWoIDUQN01QGgX0Enwb6yhGP/M0hrOgB+XBfBN6xjt44ApOcpvy64qCcPJA0PYtnE8V7axRwGWaQgBwefqbEWXgjY6uuVEZQ7mKaTAEe9LYb1/SQNb7V9mDJh4QgW6SfLrqzJQ6peVZuHCzoglPVHOrJHA8RJ9wT3jey1RA4AsTuivlBmG9uUelD7QsQPlWaZAIAY3LdJAuaxhPNQhgIbN6g20TjfYKSuAULb0QcgOE4fQBLfpw+QrD97GXAfeq1Q9QTo83CAadOuPrPfxdNnsLmBjYb7Z3X/aZfbZg7AtMtvH33fJ170xp98/uaR3bL9sce+r2+cesHmCQzwHSCCchzlQnwUahbUXlN2ENroaK/84CECUZObJ8kKAavIJ0byYR1MCzNrxXF2jG/3C5gEn54goBSC2S00qiMlJ/K9Vy4wMKhD6jKs31idsg0SmotyUGYdNWUq0vLGdZfqNgIizuijgmA24H++8ooP7lfiLjFgDGKo0uT4rXxrD7eoRjRTFPJGfpfGOQuXJp6NQACKxl1yr6aA8rhpYGNQYpVLEA5UFsVtKhL5Atw1X4YcXSqSRvbSOkjZmKdoJgDm4QDTpu0sE0HvEMH2Nj79T+dvxLTLb/MtnHYF2dt/867n7zpy3cbJr5696Q3Xffg5m09Qi5KeALU9pPOda9e4EiGCDlC3k2Q8Ql80FO5cKPWhQA+NDdDtvkbqB08PYTOoNsnaQShDsVxPynUKHa70HyBK4VB2hCtbJMl7lHk2/0DZzHBHq+mZ+QYlZ4ANUKcHKRGA4RZxdm9RTIks8xOsl7HvQND53rGELJRtCqMfgQuFQFlAyeoLqaA1phkgP5DjjzQDQFAYfRf2sPqnokGVa7En6DkAcRyB//tQK2ytV3hxlOJUnX3BxIW8L73WlhMF1lH1WUpofTO7Mg8HmDbtijatv5G4f2p+pl0xNt/FaVec/ePf+blD7dSfP/mql+/7479x4IENV+WUpN7E/QHfVUW6QpAF+5lLIAqmw8ZX0JJL4GmvhtmqP8ChSPZ3Ty/uEJjun64IcpxwRQKRA8u03UDDVE8QW3dqu1PAw8Kgms4DAsejLsGbeWKrwbuqC8opqU2YVfNF1A5fIHCvE/CRTS7vJUFRsopdnEOlvsiI5jmCFhG/EMF791wO4sPoMLhjMCqRmPhra0FXSHgFVQIkroCKtbsqiTkAykqjjJ+sEccPuQEXQvO2jxF22AGHA6wpDFqKh6bns/ABxF5rrDarPoCyI2c4bdo1Yvbvhl1ncG4D2nB4an6mXWE2JUDTrjj72L2fuPW/++nnbH1tbzv3sSe+97rNY9dvPB5YBhVMhO6fUgXj2hMdYWRDhXIgF6cUzBfjIAh+UIejAazhjLh/NpQzFnBM7RC1I0WLkrIlk0mIhFwHxFT0GTjvbOxlIyBadyNE2y69SLWGI8MCyBS5QeyCnDzvGe3j7iqEk2yjChb6DKhK9QiiVxHJ2KS6sjQnSWhDiYY4RSBG1SORpTTWk6nsMrTcWqrEK6lrD+BIXRTrycaPrmZJcZHEgFwXlTlFb1V48YHiy2Zcgu+YN6sPrvaq0yyAO/dhvFIfUn39BgFP+ADRNZcwFAZV811kuLPWTaiD17emqIBWZ85ZLceZNu0asG4khGBzG5+cmp9pV57Nl3LalWs/81vvvO62r3zlh7Zfcs9zf/jARw9snB6PAAu220AZv5KhgeUNG+bpqSBCJ+GtgKhT74wb1OBAjTOkgCfaOyKPaIDV3yRhj6DzU58T1TZRvooogfQesvvQKdXwBRSWdysYwgLMvnXYnbw7Yjn8R6JjlsGhkCY8kEKZx+CSpYSszGitJgRxZZGfBZbaJF2qlWq6sKKpKHpDZFprU+kxOMbc4hT5UHok8IRgv3sKlpqiiaB3idPHLCk5lim95haHu1LIe/dRSN6bG1aY74Gqh19ZxgHotESzVdZ/DVVfC4OGXCdcl/CugpXn3IYDwsLtGARLKweE2aBDL6yJhHDO8YqmNolen4+D0nERCZk27ao2VTxwFi/ZwKGGP5nE/7Qr1WYEYNqVa/e978Mv+tevPPTZvfvbk5/85uu2ceamrWMDRU0iX6RCI6FYpdDDkhoKVdEWNyFbG/R5AP0k5pUlPol+4MEE0rmVma7sZ71CwtVvlJS7/2lRgg609CsWi0oiFmSyc5JCwCYyYizC1LyvQnhcFxEhYKd0xYCaA8jyLnExMLBNqbG2dbDLnkYcUFdQv421SSYelMHFEnnjKQa+5NMX7xu8MwtAlYdbUK/z4WymkNZiB5S76lR9Je8lNsoDQ5BwFZAtBmKeV5Q7l39ELzasVzInW5KqzyfI28cG+hsqUqek0TY2gq7FslmF+PXHcgXjFXuLXHgk0W75yuS+jZs5fYBpV69phyoeV+wSfK3joUn8T7uCbb6d03aA/YPfes/zN48c2njswe2bXrfvwzdsndQSCkDK/aGCrpktEAVDTeqtqfK3K4BIr6p6oGdycCjsVSGZWsBxECEC5/KlDh6Mvg8eWbPMCTbIqxF5MPhHHNxV7HCAFRG/5kVTt7eIEtQi98yZHtX/SHbcUS/P8ArQ2DJc4OtqqlDLxFUMs/I6nmJpykDLBaINQYmc9nAWWOnVrLIqchtbCO7jnIHc6og2dJEG+yrbSGOCBDMHMhtBSgilRZKASltS9ZW6NhtE/Ah/LL3PUWefhUExDwdgQIMRj2nTrjITQe/2nwN86t3zJZ92pdt8R6ftGPuHd/+j6zZPfEVfdJt++bUHPuXJwSrwKj0J60Org0TYvOjqHVWIKHqcDxAF+EMS40nA1gvEylTsIDG3IcAiswHANOVU1BTPYZDr6AK+g6h9WRQoYholpXiU6wDwAwp4F3osxvZqnmZQvQWX9+ThAFA07V5BCFnkx0Q16gKeBjvDy6cUU82TfZmGG9nM6RQ1CKIOT+JypWBJJCYMbRQsicYVO0mTHyBNe/NiUNpURCDamza7ryU6i3s7XU2nhNbQQ+lEkBo+QFLXNa8ASx8gEx0qTNelDxDAPXoJgznZK2D6IMXJOMCyWaB5B+5aeq2Ic8qVsqL1PkDtGDtQ0Hzs0jwcYNo1bvZqnz6DrU1sbODwu+a7PW1n2JQATdsx9vF7Pv6St/631+uJPXL2jx/7vv2bx6/ffBxReDDMMUzVGZhOwoE+L5kQyL9KPGdKBeVpAKFjYHelCoKobxwh7ztwyS6MYWv7mxoerQAytS6MM8TcTOfhiCtzbUMXIlCgCSSkOAnsJHbGOrSW6zVYFlMKjMi7SwzFPdEGy67IQapEZ1WuE4IlaSHF8a0oObuOk1tzXOxTqpBRHGoqU6sVnlCRD5EQndsILR+omjHHQZdPsBDULpqahwNQwBNZwrGN83CAade8bTRsd4jg3Db+5D3zrZ62Y2y+rNN2nv1P/+auhlOHT77yDc/55OsPfnyXnEvunyIfkPgnj25kf+QGaEQJXPkDlt0cxEKhtDHqU7oSkmb+cRQICl0NB+8RQJBAsRr/sLQ/IubAzGOqg4bc4mimqiqFKa+Dl8KdHohI5Q81P5pzcOV9FtOkaMqaNVFtcEUNysxDsAQIafvU6lhusbDjQvvkV8TJeOp2PCjhqboUmUfoo5XcYouBWGZw0+5+S9T6hJYoRKPIx2IagCuOImO4w4cKXyvFOUg3RnGeK4P3ElKclOsMmLiQ96XXPBxg2rQdZ6qQhttfjgcfxBNP4L675ss8bYfZjABM23l2//s/JH/7H7x0z9f3bZx+4Mnv37tx4jkbj5XkwuTgSbGTazd+OyuHJsRnP+KSVgAurEy8wKUQQUtLZUlVyZQjLqIMG7xruUtM0inmRWRAiLSGuMEwTwiikGVMyb9sBQICwe7nzJ00Xjsfy9+1+6kEgxvNbF6ZTJ3IuXztYLK1AKCEgq0gTolpggy1hzkScUaVG9uMlnIXar3QoBobZTNpPiMNdrpAYb+dJQnkugaqPojwRUgJhZUHCnwvvbgb5aYoS5CxMKhtr5ZeZTPjrYqXiPEBKf+PT4uym4W8D+A+bHgOni+SQujMlLmVgSX/zjiAwAvGjptZ9yp/Q6YPMG2nmip6x769OHcON96IP/iZ+RpP23k239ppO9j+x9/+Zwdv+7OHfvDJF9/z3Ndd99Hd7Vwi+5IJoIB2RFZAzzqh/JbtUc8Rqx9UtdlxUVBI95QAAQYXglw7gt2nwh4GZ0sdzPqt87WL4ABS9z/OBJ6x6iGLHp5MaRknW3nKr6qKGh1OHl0hMtxUoOqlSNUlPern+IoCcWxW3AsZu8jqnMTTLWaCUhLUrsiyV9yFyQaCzCsojL74UKI8HdnCDgCJfL8129DN0N5yKIARAEsYaGoxIMmiQEnVF3FRuFJAIe/NXykKeM8ace/FOyo9pDJ4ZfRLXsFTUvU+AVzwCmVRirydpBy/DJ5LGAqDBnkvoTcroiasXPG0lnCBVpol4l+JhEybtkNMAViVz4ZDMjU/03awzQjAtB1sn3rfB17yf77i4Gf37pMn7zvyQ7u2Tj5381EATqUH1ajwup9Sy0RqsN3K7zwroGA+8pqQUN8LAFnEAQJOMZjAlq0guZCbg9hIqL+PG/mUCeCCSiUi92/ZfWBbFzN3TOnMc6V6yRKv3Df2Rura/bMK8WtGM5RQWJA7sOCS8+hbL9xp1LeWu2Tv2KWmHrYISUkTUY8DIHYv0l6VRVcj0GEbYjtU+WrvW6hwKVR3LCuo+qKzD/IehbxnlKFKaIYqr7Gv+aCoqs87lh9k0WOk6mNWJSIRC+Hs4SGrMrchDhC3DHVQNitxj3iLpNwnoTzy5RfUXmM50dIsLywiIRNFTdsJ1rGleCyqfP7qfG+n7WCbr++0q8F++v/+J9fd/pVvvvb0zfc877UHP7a3nSExj85QAJB8vAIKdbK/iXagiPVZPCfjAHCVuYEfJ/I7KU8MDH1EA/x2SdUjTtTKxhBJJrvy9wIy5TEN5jCYtMZq+PiEa6wgGHoAXCybhUzfynRCooBmKQoEE9lLB/X0TplHnSJK56HMB2BwgGPWmSigJtpBzhkAvCpRrcPjdTzr1lk1IdUo6OlBBu8ogt5st/yKxxy4k9qkWfgiMhl8toiMAhYtXWX03TuJrOiBTcca8p7u2VpiPll581nS+6LnsPbKkFdQCoPG3Ox2VVKlGA8IW0PeLysOna9ZWcKFrkDWFQbV4mEuCoOuREKmTbtSTckVNaABn5hVPqftfJsv8bSrxN6ibznw2X3PPXru+Nduv/3Afa/c82VVdAnUjnAJ1CpsilZ836vYJkqCZioqGydYt3FEQkdUU3LrfYcy/ymD8YL6Cb5R9DAxCP0NVsaMewGAKVhQ7gvT0iB6+QRYfxNRkRMjkvZmQJT5F1FFXwh4lKQ+pPgP6qcEAFGQNFG4Nj88uKtIpCk3hGLKXQLLWDB51cJd8SCD+nrFHRt3Tkxyk5tgaN5HdmEPvRSWMQ1REywhuHggWVVq4QO4FdiazYoPEJ5A+ACafdMHMCA8DweYhwNMu+JNBNqg24DigXmy77SrxdpTN5k2bSfYPXLP//XqXz/+tdufu+vrZ7av+/eP/ujJvhsokgoiEWoTDOWY8h0EOaTOC20bcDsEPuEsLIQOYcoinHlnybv4rFQ54BBmADwx1cEVJTwxNEuuyLCaXJPS1VjMTYnpSnjAAgSNqhnheLyrAKod4GlnIP53vYe61qR3jyu4kyXgtrr3BEgjONRYb67AdtIbECHGzpSnoNCIskSzlHj5+PBcCQqOFOpeDx+BKYy6Z+LG7qkXK4ofI4hSN1nrEhzJRxstnbkDuQblWmIH66PnS2hTjbvknisTCcbtLU5ErDfmxofCe0nZN+UVTQeZzfKd4Qs/dozNjO0138g72rXl3DReHs5N48lOm3blmfunCtmY6H/aVWXzbZ52FdrP3vuOg3jka0++5DsOHn7l3r9QMYIfY+FOx3o8VIvSmmTZgyD3zMkiaHGOMyU9eerWKNFhKMCFN3EEmPoxWwG7fDRQ61Jul8my/qMmQV5my1mlgqjEIppHMyKkYLECVaPe/b7N1xtiG48DxMgQP8PLD9wFAwjOyjP3d8zo9SU0VQWaCrTb5jRqikS7TZiiIBUVtSPA0ES7QKx8J/ccAo8GAFrSlJtoh3bR1lQhsJPCOLjvT1NRdDsLTLQ3ZkVbEjCJamCFmEdC10VZTGfaSxyABHnGAYrGJuMAQd5HL48noPZKVn6Vqr9Qs4rQ15H3laqPoQCEpshXB6SAJ6a6Tg3FJawpDFqiDbMw6LQdYILW/fdmHu817eqzmQQ87Sq0T979sdt+7M4bdh/ZEHz61He9YOvIlmwDhFwIqntMr6x5veVq8N6IKzUVddFGOFAAsLyjIXKRdWNWhr3cn8jJIab1lmEteQvJ5Mtslktx6tt+inxQJkZHniw3IcYW8roCFZTT01i/CNl3UHI7ey8ZTgD5/DbMLXNtiYmbjxapqwx7xIZAVaTxovHqUrdrxNk2Nz+LgMsP/IryQEVqujenN14BNTZltfGcyx/eI3UvdaWOwIfdj7lRz5O9JOYm9Z68sr5ZfS8jKJAN80pMu3xYZhsLF1J+iSRcAq7IrkhpJrHeMrdxM+v2TqQ17TKbKlqcWKg4/CvznZx2Fdp8raddzfYz9/6vhzYe+/rZl75q/8dv2/oaSXrtQhnHmBvgAQGFaCHvFw0giBBBXPRjs+CMdVQCBSJhIPUc5LA17sKEAU9IjZQDF6/zdh5nyMgDkMGB8CIY5WgGzGrWbyhaSpnOpgJRqUsYIyENMVsugSd2BTpvw2wjNOFwu0VChXrdfbGZo0dspGm5o8vXe9MG1eZVXLUhQgS+sc33szXt8CPSPDrROIEG5vh6bAEqItqbWnKwelDCIwDhUGmFpCs6+wD4SZOLPQ9/+Zz5JqOvAe6dqjddATHxmA475BWsZCRHRwAZmqBXU9n09Crj9ShXgtF3LU8MntB8yCtQLSL+nNuyMGgZnOkHujwgzJrpuu3lDKdNu1y22bEtQJvE/7Sr2WYEYNrVbPfd/ce3/cSd6E988Juv092bN289KOiGtQpBOxKfEoQkkUoyoDLgpBIuGBBhUqMu6A4SmvLzypRH+zJyze/kxKR+JULw6W2GM5sQzWXBtZbB4ha2XsnMVLAjJBdfCXJbOvHsGIvglALU1rTXAd0xEmKKI/tQGH3Jwjsa7LLPyv7XmMLUBD3pbQ2Q6o2l4F4Yr10iA7aoyIaqtHT5K/j1pPC5lTXoEeS9BQ2SwsdA1ccDZWyB2wVkMxmmUANE+UQL4OYgyytlYQOjH+S933Sx4lzCUBjUyHuV4c5aN6EOXn91MnSzZuac1XKcadMurakHrLChuG8q/qdd1Tbf72lXv33ve997y/4jL9j98Ek87zX7PnTz1jcNmadwvxD8QFLsKFy7iZxD1J5y/6DhfdAxqYD0f4DjGgooRYEc7NZSQjW7QFDP0uJsfZKCDlfeZ9kiUU8zaFBFE9WmXTXq8IB6GEgequVZAaGYhwTZnyEL5jAgwX2psMk4gHH8yHyDWB178VSyWjjIlmCKfyh6TX6QKN8p5agvJg5niU9EPoC7Mc0LHCEzBzzmYA/UzwLzTSv0edDw9lpUqn4QLDEZQIde5mcU5nug6uFX1scBSrNV1n8NVV8Lg9LdGRYSbpanKkiWEhoZ/SEyMDQDytzWHBCW7l3xV1k1C3RYSxs6rigXl9s7bdolMlWgW7wQD0zif9o1YDMCMO3qtyO/93uff/8HvuOtf+c5OP6Xj37PN9veF+46UijUAkE0SGFH/4Rb4tcGIlPqB2dPjcMO9nogYqVCn5I/SuoXddjksAsrGgMCEDEcHyOTJyZNnmujVr/5IOrRgxIdMP8EOQfAx5dEunWv8uCturqk1eEJA9xDRkLY1yslxXIakWrIx724TOwDAIsRFLWI7wAZ/QKOhw/wqEJ8rwzySEt2X1PD7v3WMPqU4lDLPpD3woUzigQZsOw6Yp5XGC6QOueygHgP+bTWUfVcaXgVuYH2pW1vTElzufFcYwljsyEneDzqS/I3AKUNGMmpvZb3Q76Esb018jNt2kU2BUSx8TxgGzg7S/1Mu1ZsOgDTrhX79D0f+M4fe/Pu3Uf3yanPPPHXD209tG/jNICC2wqIMfozYKtxqAv0D2+T6H8BxwnjCuxjQ7LvdDXgShWKZzhO+gfIa4nIRSjZdwzNSALCKxH+B245N4JEqTMnthaiXmgoc9Jb4MhSeyFmbsBf040BpDmAbrleQu4qDQ9QmzKbysJzVrF7Wh2PbIU88lkD1vtNWwi0qLJpXsBHlng97iBaf1x5LuEDaD7fgNwVf5dPxQfIuYXfkN8l84+afqAiC5hefIDqcqRrseIDBPqu/gjqIE+j2fIK8X3sQMlMX+4b/ZPUFIUXVDydadMunllJXtkFdLQDuP/n5ys37Vqx+a5Pu+bsp+/+Jwc3j37j3E0v3vWlv3bgM4gy76HeSaVNEfB0pV5olABBJE7p0nrdP0MGuQ6rykscPauhRwIP54KYXAe1Y/SiIAcdAFSkRxIwchqot+MJx0wyBnKoBg2lk1j+sVheLFqOlusaz/S1lFwTlrCSplJ1o03QOZSnJCOn6ieFCVyY1BAL6UihjqmhugBIrQ5MQRRlTD1/d9QLiQ+o8BPKVPxcM0qtHE/3ljnKSLVPcNKolSuJpwdxTlDXY7PhgLCQ4ngvhhHMySmaIlQ/gSh/7EVcvSrFkbXNQD8W5tdq6eULUXpT9UpZUah61jTzD9wBW2jET0BP0nrF9pa5paZo2F7M/0hNu1imUKDvgpyFdDwwD/eddo3ZPAhs2jVnv/HWf/GNczcd3Dim2PyPJ/7Lx7b34qlQhqhiNU20kbT0vzV/dGW3Du3Bc5d4yQF55XwNXas6U47ATuVoJwBwVTuZYbZx54LcPcu+xPDOzQayagLtfn8vHNnKrOIgJw6lWdmn9OIZVXARvU+jGWTntnBusQTosD9+Mlqc8+U0tXcn7a5chp3dLCwoWl0V3q67R+MxGFUIT7DymI1qp6OnnImtRctUBcgDwpRE9rDhPpoyv4PNyiFi6tmFedKWhspFtRwQFo5S9NLyFnFu40FgKy/bshmfFF0wqpR4JQn/coW7hHzB4j1SvpaaDzS21z2CckBYkfNobG9schwQFtsb1aryptOmPWvmb5VAtqFbE/1PuxZtvvTTrl37+/f+0qGN4w+fveXl++5/2e6vFOYeNQIQiImpwJnaG4Xnma0bXxEY1gPCfDSrtsmvvEYnSXpibBmSX61vxgEcZ0W4QEVFesW/zsqD+J2FRxET9oRaMt/O6PtaSpaw9kxxRhyYJdI9zVdjnpn46xMoMQ1FsvtA5uyS0Rc7KaxrRAb8gOKoHOrT8KABYx2C1qQw+nbFAwjweqN2HBifUQwevkyJDBiBTRJ6kCeRqgfOfwWFql9eWWH0h1zbIdpQ2LSe54oAACAASURBVHTUXmvLia6n6uPKeZqJL3xk/YO8rwQ/8goH51TtSkYhACBzi33mcH8jUpDti9XtnQeETbs0Jmhb6GeBjvun4n/atWozAjDt2rVff/O/evjsLfs2vvK5J3Z95LHXbq9LiYn/OCQoKt8ZmNXkRkkABzHfVvhLstikbJPcZwyhNEHwr4g4QCqqs7C7grCO3HGPGSdVXwcDmWMmCDvyhA6311xCyX0wWj0nDuWZB4XBTeZ72LnazH6kNEk7GX13lIBUtHAJnXPwhTtTHDcQ1d6DXfZs43DKQiiEDnTn6MU8ohLKiCVEVMcY7FxyEuR+RQsHX5YGjD8OBPky2lBCC+HlgeBYofShYm4yUvWcW/LtjA+w2fgImHBdHsoQCdHlEmJwkvf2qYSA/LXMoEQJaIjNS+PJRXwpN3OIF5XtLb8Q06Z9y9YBVdx/F47djrY10f+0a9pmEvC0a9o+fc8HXv7mO/a0ffvak5994gcPbj68b+PJQJNCUAwgkIvn6ZLWdNI0El49DTTSgkESNJJBmRyZmbWE6ckdB1Met6NefJwS0uHwzF2HbFKHysnGsvLWnOmoaA/kFd+W5SAOyaSAqbVA4WR4q2RKyWFLAjvq7yOXtMBniZmLlsMBQG+CBXBEmcGLqDgEp5nHzOwBYkfKaW6KH99WePTyOLC8kmp4m2TNmkW54guLJFpuK7eBVP1IujNFN3OLs5kMUxh8q+Vs2TDL9eSV8mzm4QDTrhFTRdvAyVux6xF89b/Ckf98vk7TrmmbvwDTpgHA37v7n+7fPHrk3I2v2PXnrzrwaZeshHrH03+1SGWglqsq4MVMBUYeHSBMOUWW7S+KINMRGeerTu1K9gI1OSEBClUPkJIYAM6cW0IwgMzxVYiqSs7ExUWod+FNnTTurlMKmJ6yGap97NhdJZTXmoCr4EG8xPp+vUGUpwiLqoiEMoc5uKl9ahI1/hEnBoSMxzRUEmoi2AnKls4LoAta4xIaJfx2uxaqLa6uMTfakoBRXRGtqp6Q4pitzbVFTQjWoZd7cal+SbBbBDwac6gCntJsVZxTrmTLnXE4AGr+8eBE+pXYTKZMTJv2TK136G7INhpw/13zLZo2bUqApk0DAPzOW//5kXM33rBxfFvahx79kVPbu9e1MuSt4uKQkNxj0Oz4j+YBVOmFfVyRVayk6qZ2IuBTCkhGt10T2cHBuGlFghoOuQ7vwS6OrqOgvxIoBkUNFDhZJpbeCth1uQRLD5W6UqHCxDVFIqKqPXePabC+UcJYQex23IWKI/Y1mN45uAokjwgbOwJ8BLm3dr/IWM3ddD+rPoKQ4oBYfci1lXjilMG42N57Ka9wbitbZ/4Br1QBT2k2iHPqlZDiCKU4vrrYXvWbcG4ayhylzCm1YfUuHHxoxjc8JwyszC2uxPaK1iu62PCskYuyvaLc3mnTnoH5C7sBnINuTPQ/bZrb/E2YNm2wv//+X7yunXjw7Iu/e9/Hbtr10DICYMp35/glOX4gkBdZcC0xAc/3BZBkeUQJPGsW8KxiJgd7ujCc6mYcwBtHpVGj5LuR7p4g28GEY2kwFbzkUASVBqlqqrER5DlJlBUxqiBKUh+lbzcsaXPoRHCRdGsBgW7Y1rJ7m2+pkvVXUefsIeTjM8biS2hB2/celVUjRAA/UGw4BhjZBhB+UL8IkaadlUy7aBMpBHnS6kNKLkrGaokDDP5ZjQNEMwyFQYEhDlCYb2EoiR7W+fKPKw1/fqp+XILUXmJ7wTjASNUnK19DHBdoVqIN5Ur4l1RDpQNR4wAr2yt0wYQBDeW+TZv29Gx7A62jAYfn+b7TphWbOQDTpg32qd/9yK0/8cYDux7/M7zu5Cm5aesIEGx64huT0AAB0TCIzg3KNO9lH3gg2BIjUuXt0IqAkNBKJJtojqmS4wib5eBCfB/4Sr1hrIUM9sqUnB0X/kHcqZxVyQGItSOgbMQG4qDi1Is3KLQZCA54LQSC3EZGCLzKf36bG5W8dKBG4SZrHdldNUJXHhBW8yjUyqFGyIE6fOLb3MDyUEoIpC6w/MFm8XhLr3wEiGfDJUQOwKCzL4usH4VPbHgHazEfe54yLGE86kvGe8WoJRuhXtES0Sp7kM1k7KjjZkYaQ2Z/CPgOx7vkGzVmI9DFyg2ZNu28pgBw+x04ewanzuGBSfxPmzbalABNm7a0e9/yq0fby6/rX28bWx9+9L95bHu/XQ+2M36AX6HQIq/w7/QcomxLdDfOHYX41UzQ1cBnGmBqTJeMokBxL5LgCQ3VRRToyHvwj8USNK4H5qpLUBVFV3ofFIFYo8SrzrdXVJq6FCK4LPq+ohWR4IW5fNeKiGFjiTxnfpCYv3j9GcntRWRbQNgsjjuLu6h2EV4JLdBYEqfkgOQTmIcDpISpbriW9zI1RRi21x8ZO8f25gswDweY9q2bAHv34thR3PwC/Mk7J/qfNm1p87di2rTz2v9w77uv2zx+bPuWl+35+It3fdVl0ZEcDCCkNaDIx7NsoX7FgFVKbmwEF/BonM5L2Y+DnZr4mzmyyPxgUavhDubypqwlU3Ih0rv63IruCJHIG1nLPocopW+Og/g5walrgmcbh9qH0hHr3jskVEB5bLAnKDMbGH53wM8MFhcFRTPfhGErjK0YE4K7aZykDMisX+ThDOjNc6Bz9wR2UoGKdkizk4ZDOESpTE2HDb48hShVinP+K1hQ1/UKL45SnHk4AMrc5uEA056pbW5iexvoODwLfU6bdh6bEYBp085rv/nm/+3Y9i375M++9PjWA4/9wCB9KCQ0uXZgyMlFLR/jRkYz001jtOSJjaBVIrvSaKByk5v2v8m5Og0PL3MzMP0aBD+53Rig8SZNJbEdSdmYcEKvwsI6ha1tkQ47Mt+ZAA2e0FWo+oE2TqLXATnzk0mQjxy2aOJDdxA05hn+V7DLknEA7VxRzbX1ZvNwgNVIiC6XEINze+1T7Bt8bvNwgGkX3RRQ3H479u7FxsZE/9OmXchmDsC0aReyz979h3f8xMv3tH172pNfOPn9N2x9faudI/QhIVpzE3kgllWvDzl5tpFoJin7RtClSXYKP/hURAJPwZXyMojvfZz0EvwPY/QB3iVI3EqsFko1CNZmfLBl5EpOyohbqvOp02giCsYfOGHfJNdyD4cDGMD0uTkd3Ln0QOW+WeWKAJ3rFc7JiW11drkZ9hY0G9nKj+YggSydXRbAKpDGJsQ0DYXWwpTl6dcrQlS7RmePcsUs0mFNLq8B/UGqfiTdQ1Vf8wq8mQxTyF5rZjskLSyulEXPwwGm7UQTYO9enDuLG2/E7//P88WYNu1CNn9Dpk17Wvb3fvfdBzeOPXz6xa889OEX7H5QE7ogtSXG2w+0ash+8jMg3XnaqgWywkGu0hEsy/XUoVwNLanMSaGR+QndS61nL2dlDYc1FdEOyn4Aju9ct7O1pcy/hROal+2vFYey/E7MVlp88DiEK6ZaqX1kpwE09xmU+2B36QCssTo0N01RD6lVUzaDuBaoyn4UUFP+QPK+2tBEu7Dqv83NRE1NpdmepMIkq9YEsHZnqUR3ihTHnzo1NlXGg7hCpB+9xMv1hJeYYLcIeDTmIHWobLYqzilXsuXOOByAc8tm1QfD6vZOu9Ztyn6mTXtGNiMA06Y9LfvMvR98yRt//MDeR7/SfvDJM/3GXQ+t/4+Mc68j80rMxCti+N5xTi0xGXEDJ1YHqBRUf1Cz/D4bCwrijBGsfROJuQVsIjaFcEIt7qsO89g5JqOxTI7F9bYSbYjJ5bx89XEZBJP+qUFylRBHq367bli9AdBGrUqEPpTVifxujfx+mZtQ3JRUdCw2h5LF3CpVn8+5svJrGX3q7IVUfSXvfYPNB+CVgmXXEfO8wnBBbGzpFa9PuRLkfaXq87Xh7YO8ty9te2NKutiACHGMM19kKaD+GNtWf3Ukr6oOvZb3Q/hiub3+9iqGMaddS6YAcPsdOH0a29u4b9b6nDbt6dnMAZg27ena+3/qXce3XnpAvwbZ9dHjP3K67yqkLBsVEUkWhCmCZn6rUcBSgcgdQPEgUi1tYQNFZgUEoITGEEnzCgetFXVsGFGK9EexdUsxEbSUdpH4uFDHcJBgm8FAQqjzEZEPLkHKYlPLDkWPJeRNDZNmSZwOQc2USHU+IxBOkntiRhGa12blEfg2xYDc8NTZgzp7Us3jJIvO3jY2l38eOX4ticMl6KJcjy3XW+TcPLoTc8ukBb4nWYMomxURPydcDwiL7YXm9np8gup8Xc4tXi9/st7rPM34IFaucDNje5PSX9k3u99QSkgzr2BCvmvVzBO0aj8veAE+8cvzVZg27ena/G2ZNu0Z29vuuevQxvGHT9/yqoMfvmHraKmxAwd9rt5RxKleiLPAhAhRuiFH01wE4HIZTDkmjAVzYJDHRD52l9QdOXMeqh6qgyjKV62yH2iLjqqQ0M+EpCeKC5mUSN1L8Ao8lPEQrvKmPnNxIVA3vNZUodJC6cRiPhT/dGijYEmbS0EUkKaqCgp4egxeK//YblSJlPg+uISpiY3jR4A1APUYMtMpUVOk6KKtEY7WyjkooheEH4cqRFGgVq1xl4GBF4zU9aIkTs0AIYMuw12sczkgzCF39KLOfpwbcfWKFEfWNkMIeNwFK718IYsyQSi7NEwba5r5BxRNEYrUyv0Y7xXbW+aWmqJhe/lEpl1L1rbRG0Rw+Ffm05827ZnZlABNm/aM7bP3fOgld965X45+6cR36ebGc3d902FNqhTEicpI1TVdAyi9IGQJ/T1S2+OJAQGeAEBFhkTeEnPwRFf4jbKXRLNESBLNEDORIXbgf/KgMZFQE2VNIi1LKJMRr+Pp2FQhfiXAcTSmq5QTc0CPmEkjElXNpYlpRYgPfVOr5sSFQbkDuTO5BSq8wodliFfqzoRcBzlzGZfg+DXURP4jxgcd7kI8Xx0HF95geQUxWNwlkLpgsaicZP7IhZS5RY+nahY7IlnMB7UParvh+3zl0kTrANzeeOKRyqxSt12KZ2XLhzAfIDazvuHTrg3rHRtnoQ1Ncfjd87lPm/aMbUqApk37Vuz9P/meh594/nP2Hj23vfnHJ/7mOd0igFP/Y1D4IDlMgbOqAAr+rGIPMJAQFyn2KVqRVA0VDUvpztFB2IjsWxQmlMoU9UgAe1BxhNCKsKMV3xRJjI2sXKlB4cYkhXOmosankwvPuZHdpexHcnAfrkkRonQqdtQfQYpkEOEW7f4M4nYaAh72BTqUUY2ouYmyBC0CHlFi5SqmsudcBTzjvpHHLoPzn+GJq+Nlu1jvEgolXT5o76V8IUovLXPLnPDyKM/TzKcURL1f4dzyyvD28nUa5zYWBi0CnnAllIMrXWCwWmu88La9MQgdglkY9NoxqwHWgN4g27jvPRP9T5v2rdj8zZk27duyn7znlw5unnj49C3ffeiPrtt8zIFVinMSLmkt3ROiF0PZLFxDRBxVcZwFDwURJc8J4lDP8xKKc0xvA3aPuyAOwzKmlQdjNVMHgXId8AwvSdlPLMFxaNzFKoFShKPiSnNfbwOkK8CaQiYpcaFOiHOoOIILckLP0yDQFCyV48BA0REkNUVQP1zMJEAC7cIJCysL5VRNg2Tf+mwpKyImLQIeAvDVkjgprYnGIcXhdoGIPuInEVWJXiulhMQJbw2C36n6cCwHTVEVLNW5BcHPucVsk6rnioqmCDlPRNJKzHyQ4pTB4z8rkusd6wvVfWOWcGxgDs6Hq8sDwqxZ5o6vqKGmXaWm5CJaw+GZ7ztt2rdhUwI0bdq3ZZ+55yMvfdMbD24c+8tHX7O19ciBjceAQHgUWdjRs3GdeganNAUOQw1iaehVimKHkQIHgvatQzCpwMnbl58HaBRTgqBRaNTIqkkOQm5c0AKkgneX0I/ULlVxpNG9AD9AIE2c0B1LCQnHkuDtQaac+5YnVAkAdHBu5lRAHKtzQBF0LsfLGZV7SQMyGxaA+R6c1WK7iknQ+stm6zoScEusLrcxr/j2UpljER8H/YTXyphDbDoDQ4Ngids7TCF7rZltCpbqvsdbwKbzcIBpl9d6RzfMonhg1vqcNu3bs+kATJv27dqf3vuBl/3dn9i7/9Gvt+994ozeuOtB/yJBDEFtAKYCeYvu3/B68pqOd5MzFrQAssRbrfCgEpCxOfYfXZG4ncRxXdY3YLq1cPzFK+m3wAIHodfhioIdboHI+EcjhhW1aIJlM+TtwCWMAK7M3HZAkrdmNmnuHnIy0UwzV4FlJT2m4RAZAulaS+Nb0oIM+1X2KO8yNOH3urYZ34Sk6lF8AL/CDY/CoOkDcLtTsFRmVh/ratLCOsQ/wHSf6gju63prNgJxeQH34yvtEqx8ndb4ADb0qg8wvo2S7ySnXfyToVleWGzvBIhXkSkA3PEKnDmN0+fwJxP9T5v2bdvMAZg27Vmw9//0Lz+69eJ9/Uhrm4dP/M1zfZddlyhcCMAFzf4RvKzxZeqnAUfcCGTJtsrGvKJE8o1NvJh+5e01PQs4YpcscInEiBIzch0+Qvhu6NLxvEadGMepjsnjLlr+MTCnLYuHVvCJBIChjM+CjzaXmH8uipUrEXBSq4oqWiUJr4jpajQzYBnO14Axh32LddV9c0Ts/xCs5hI4JUmdfdGy2+C+vXChjffS3De6WMnPxw4ksI+ymGOzIbWjXvEd8LllKESwmuzhL2Go872caGRExA4gloBlM2AxNwVW5hZXYntFyxVZbji3F/GLwOKkUpJkpu1wU2jDnr04dhQvvBmfnsqfadOeDZu/SNOmPZv2k/e888DGI0fP3PLK6z94cOMxq9rpUEVZxt8VQVk5NCuBqnYEN58lPrMWpyMi1xSVfAOn6lWJZFk8NICzqtj5Wa7vV6hIVw7OGAVvB6rwmXhgzVjuU/1ejVjMJiyh9QdKxkIHWrPcg55rl9gW0cgQkChRCm1KIbip+RFnDOddmtRsBEQurV8Rab0DnvzQsqOKNoHCMhBEy5TQrAOfqiRVTy17EvxxxfF1qNXhTlQWBs1vpWDecfBoNhYGhfuMEndhX6mFQRFJCzFtZa9Bji9cAqdEOf64BKm9jKof1PnFveKKVsqJnqcZyi7llZXtLaCe46zbXqELJhjzCqbtbFNFa+7sPjCh/7Rpz55NCdC0ac+mfeaeD7/0TXce2n3sobOvETxyYPNRVDUChRaDdtmhs5vy+NvMBICkFMewoyTRihTdiAb4S2jFDynXEEeJcKinQbcGD8/oAKicAZZLcLKX1YGoY5FyO6puFBKJBKa8R84LKtKscI4k0MxJhjynAdBOYbjawkWUCiIp+1yzEST2sHzQHDjmGXqhaMatTinOGp19wbd1cH8KVL+kosbjEOWPxeCovVCmlNONx0S3oGhshrKYGEYJVyVWX0VThu9lWMIgWFIZ7xWj5kyGKxGbGqZdOsrYUcfNDCVWVmcVIPRRdZMjCBRCtRhlQsadbfGo75/of9q0Z9WmAzBt2rNsf3rvf/iOt715a+ORI/KfPXm63bB1JDF0xfSBy6RWhtEQL1Bjk+CSqLXqzAfYLQjCd0C0IZ4oGDfmY1RsgbDNZ+ITKFr2VOpEX+X3Og6e0nDDpLLYBOXCpWWqbqA31HUNTHxB+UFscyaxS2jCbGMO0mK05InRWgW7jHJw+EGOvxamFx9gBYCW9RKk5vwDdCOvyLN0OEA+yHGS+SMXUuYWPZ6qWQByodM6bMdwRWT4fnBL+AjrnGN7I0MgfIB5OMC1Z6q4/iy6oAvun+d8TZv2bNvMAZg27dm33/3xX3ikvWhff7CJPHDi9dsannbR7oP8KInS4HyzCDqIqUz3g0h+zf8c8ixguPYlJDCD8UrosMfS6ZYynLJv3kZd8+G42kuD1mamBwFF3g74wfruPaBfqswjAODQuafw3TBkU66XkYmiMg8pvCyvSG0TWDJnyyVY2VI0Ct+l7LKXqVEuQbMOPRc4DwfQ4kXlI4g0hnwo6UvxJV7ObR4OMG3V7C3eVJxq2Hduov9p0y6Kzd+radMuor3t7l88sPnosdMv/s7r/2j/5klHLhKae3HMFZp+AFTedymifL/uXyHOGRCw7n4t8w8CWDoH5VQBTf09QlptqQLdkX/zWTGjANK0QyWU9zEZk+mL5/+qlLmJY2m/XfO15MzFhfgiMTgUiobMc2i2OYg8Ch+wCVeXE7APlm9gNY66KBMPcgnakLkHcRyBoEuMA6/KKmBl/aHkPObhAMXPy6nazLkDGnEK8XHcJNdLxf88HGBamIZXK7h/VvuZNu2i2ZQATZt2Ee2z93zkpXfeuX/X0b889d17N07s2zwZLH8CIwFKVoAWqUxw8QRSQnwYIh9ARCiXjyvBqRLMuS4iM0KRiLNgI6YpR4tBbC1oRHKmzscoRKlYS0PhnevltCXwIMFkgyoas2AFYsFJ78i0VS5EvKMAcRQAoaymXpzwz3VKgPi3sQQNsC2ccwM9JZLQwkBH7lLsdJoErb9shjUdCbhXdfYoV/hC+N1t3Q76+VYoYw4BwUNVXwVLNWmhrDdvuTLbFCyVgE2+DGw6DweY9uzaxobHoR5493xe06ZdRJsOwLRpF9c+977/eOub7zzQjj/0xHd2OXto65hLGQKLD3XoHSAFpNZGpC8DRFMnepUi9YJ36V3oQOWm0CfaSNW+eysp33rya0XSBtrU+1YS2nBi00B4xKEVshlwD19nGDzYXDoM3EInf62ZhBfkhYY0EGyCRjoeLHjjIxfIKKWZKV3CN2gQLYcDEGIufIB8YLGWsUnMfG0zBI4v805MjHk4QImWxO7HIJx28U+GZnlhsb0TU165JkA7AwXa5pT9TJt20W3mAEybdtHt99561+Nnbty/9efHTz/5xZPfQ+GyfWkHXBUUE+pwE7iEbBpFGO3IUkPzUQaEy6AHHERJdzZTYTN2gYcfFKwSVN2Hqrq2bATSzEjvA6a/EYqzfdL1LgrtJTKgxIODXEPRs1eZg6ReXIA+HOQrMmYjWFxAOZRlBWD4FtSLm+jYB1c6GCHiX4jIdWVu1NkH9e69tCBuzWbCZqGzL1p2G/waOhxAytwUWJlbXIntnYcDXG2mgOLwu3Ds1ZBzuO+uif6nTbvoNiMA06ZdCvvC+/79K9/y0s22f3d78qtP/rUbdn+toReEHpx0/Egc6lLpQqk6RiZHHL2szH/yqUDl+9X8/RiZB/QaP+sTiDlIokh+SA6+flWIXrLsMU//WstEmYlKRjaK84TDQZVR6MNj7WJDLSpX+jfW3wQ8hSd2iX8pE+lLkAIFs5znwIsv+fwLsMsyUPW+iZoDVu6Zc0tHRmP5tVkpiQMsBx/ds9iIMrUS6/CSOGXaiCvLClTrqXoMS0jyPsqtevyk7NLwbo8hjkUzXWm27MhGtTDo4A2XfQNjLllKiM+n/HJNu4JMIYKTt2LXI/jqf40jb5gPaNq0S2HzN23atEtqb73nXQc2jp84ffMrnvNHe9opAFqyZlWiDIrxwMb01zOqxLI6mW6rKIm/npgLgYh2VbUsWDD7VqMB//TMXW2hqLGyL6075vIzuWJ84V04ASgsDddzXhVQNPgZZ5E9TE/DU3WNirXBW/L/2iL5uGQJN1WFeDpvplDzxC5VkRiK56nB59lKOm+e86UCVZ9bzAp20JhzyI3gcl1KrgcbJH2ARa4tRkcFSCWSgmKqkltMPB1OVTQrB4QVaItyBUBovWJuzuEnuB8TeUeNTaqk6sxzJk9xQBh/LKka8IV4OanxSlmRxGJXm/kH7oAwoCKIXVJubyYEl03O3OJhe/lEpl0BFlFJERyesp9p0y6hTQnQtGmX1O5+y788cfrmA7uOfv7E33rk3A3lG01YIoTSwejzOlUPhDk1RTPbjlqR5Fgbkiot6pFGglWDUPVmqt0HxICFHVH5504gVrQiEYDwJQTILzVGQ2OjypyBHnNGQEc7TFnpgLgYBjGmSPybTMdttHDAUsfC/eiFgnaBilKgknqSHNCbsQZlSnE05uYLRFSuLCR0KSfKuWXlSuGlkLJ4s/AHs9lYGLR2jLv49lKLxQ3PXmVuKHMbfixSnPXNMBQGdWRe5TpB+JcrVTNWX8K64Vr2PDVFcKdVOVRJCB4Kg0rZXi27NAuDXmnW0TfdQZvof9q0S2xTAjRt2qW2P33fB17242/cteeRL+t37zr3xIGtEwCS90UwoYKAYEnBcpSA6qjkqfWpAh6H82VgCS45cL2raFq5QhTMz1J0MsR1wdiWv6AwlyL9FEC0wYIMWo4ubqbD4ToXKacC1/yn4CT2h6w201QptE/SXX2pzdXq6SvkDopSgySkiiNRIBRBqPfhM5JIyS1UfbSPVUs8srKE1BpJpHLHjLjl5THL4NTkTYY/Uooz3CWjDX5Fxu111D7OTWJuUu9ZKg6tabZ8APmu5WrilR1e4pxVmVuRbMWjRinfxEd0vgPCytzGzazbOxHn5bTe8eQWWods4FPzlN9p0y65TQdg2rTLYJ+79w9v/u/fcp0cP7p5x+nTG8/ZeshxlRTYFPCUAB/AiJIK/ktgTcQvK0C29iLKDwQe+N4RsA538+o7Cgsj2DjMER2rGKX3wpo/KUQJpM42g148xhRI8wL8McMAqSBMF0l5TMhegtutOJviEI+GSPFnKA7xrVaxkqTpG6D4GrEQr1wZNwpkmftvAHTwAaxZNPRm+TCGDQ9c7k+mIqRh13IJ50XzxXGKpIWhMGiZWwDqvOMCpmf8pyD//LQou7nqBZUV56LGAk06+gA+tzKw5N/pA0gpilWaLXyA2MHy47RLb3fcgbOn8fg2/tM751OYNu0y2JQATZt2eewP/u47Tm3csG/7YWntTx95fTdgHaKeivlDo1JRGSisMBNFNyxM4tYVJgHSrVHUAkrphSo7sm/RisQ9Qw0yyDMAlfi3SJ0wZRuOzRbFXnwClujbeVVtnqEVkVCYRNmZQPuAgwAAIABJREFUmEnsicTcVHsPXGdz1kUznuybbpHdtlEr0oDOlArlLolQikNFjcgg4CGwTQEPN7Oca5vNhiUA7Bj7VudW9DOx7VhbSoiri9129RdjIRw8BUucG9+TqhnLucVsh4pDWq9QysUNH8InKeDxAEIZPAMlY1Egbq8/Am7vSl2mqDiUpbR8kLFZ3fAB+cdvwbRLZPZG792DY8dwy034/ET/06ZdJpu/e9OmXWZ7yz137d88ceLszd9x6INbcs7wuGfBWqqrIyJn0HkgLjwZV4DSJlKBmS4sVASJg18bR+Gn5DrE5uBonu+rgEO5koJsIplyFwP5cb4v4qBftDyRN654onNDAFUOBYhq87WIdDVgyzOJtako0LK9MsTRmzZoZxY1GkTQoZHOaykCXTzxFwAE2vyY4biFNHQDpE3RFGrnDTtN7tB13Qm1kaGbvhuv1Kr/2UsAilNqszhBbMgtzpAFr5CBj14yZCRnWAHUzICBFI+fLHKLkYm8w1TrlWyZ0R4HzzIsxKbL9yTmtnpMsqBcGZpZpKJsb/by2EBuePp6rBBFV6y0kfKY8kmN2zvtEpm9h4J5yu+0aZfZZgRg2rTLbPe85X8/cfbm/ZtHP3PsRx/v+yuqAVBo+GQ0gYJaCOqXvUpjh5xR+VKo0g++Nvhm7dlPSKPbeBLhCSWAJYPLkVk5nuqX6C9klzkVqWvxNsHgZlpy3ShGBhhVsI6i6ANVz8zjwi4j6WRn4FfzXFWZOkHKOdjqC5LQw4Yv2OXMWCUHz3+4BM1mS0afm+nbW8h7R+YlIxnL7S0PPjacV1QxDweIe5W3d9pFNY2CXzLR/7Rpl99mDsC0aZffPnfPB269887rto5+4/FX7938xu6NU4R03sBdAK+oE3L8QqaykVO89rOJ3YUMLlMtVU3g3ozR9QKdHMJpARHmvnLw4J6T1hbH4yHdhii1+3RIDHDHOJKEdPYFwBV5b0eyozvEUjtSEiSs2E3uQUPkA8QmuLh9JRshk6oFQEv/qWxXWS0/VuyycqXq7FF19ggwOz5B5DeZV5DfCmozGzwe6Dj46Dquytzn4QDzcIDLZUpPcWOi/2nTrgybDsC0aVeEffF9f/iyN71pjxx78MRf37X7+N7Nk0BAwKA9+cFzTBP6DOg/QZ7RqeVbYuGojOijavL5JP7FEnH9dgWQ5QQAoFYcShiXV+gJRHWdGEIRYFEgXq5nSCGNKRHue+l8pYfAb+2i1NsFmlWfbaaHSiwzPAclIpZcY+LKShKvg6T+v9xeIssx13Z0ZgYfgL0SJgeern8sBkftFU9HFjNDzK3C9PQBFuvlQ9McafABOPOSF77OBxjulZseMxmurFYcWnUVakcdN7P6APV2+cTT08jc4vABVvZt2rNuG819gPvfPfd52rQrwqYDMG3alWKff9/v3/p33rq19+hfnnrVVjt13dZxJGZCQvMCUqVg+gGvqSRAS8Qs7CFogZRaIkJn9AvGTc8hJ6CJgK14DgXtiSyD4KdPkni9TkZTfM4Ja/DBCjRKeZpQX1PRmxK+N59qleNLAlMAEvWUJMtEBuIvdSXNWyjHJFewW2zwAVyOv0Tzy/iJFCRdAGh5vgSpAe4TdCOvZEmcoVlxFmrHpacx+AB54zLJ/BEJtAeX4Ok0C0AuJa5R+6C2G74f3BJueJ1zjYQsfIDzFQZd+AB1M/N2E5teFDt0BtsANnD/LPY/bdoVY9MBmDbtCrIv/b//7sYff9v1e4+e3P3Ss09uHNr1jYStIGvPtMgkSp3RL/9xDdCVgEkSPzUh7JHQ2STQX5DQGMdJBYqUiwHuCbVLGifxXis5AwG/EHGAwICatxbYecDprgjsoN82sMsEkQXGaYwT6HLk+EUAUT+DrCBCizYwyLDOByhImjdPAc/CBxgeAZvPwwEwbGZOu3yYhwNcHXb/GWw13LCNj07uf9q0K8lmEvC0aVeWfein3r6959Decw/LhnzpkR/wcjiaamWKsEsfBeKUU4M9PTJclUoZRQWkkc5rfwaGH6jXkvXLlgT2cbvMLVaUo2dzdN5XO10F5UFhmrBQrWWPJfiU8jhb+G29aYiYIp+Y2cYtbqpacpGzI5EjPK0hrnArsnJlgGBVjXKiNr1audIgpjIlN7KBWYc0RhZZlsWElD3kTIQ7WOaWubbxoMelDT+uWwKnShStYzqso3nmFte5ycouxTvgMN3vGIna0YyFQWW4ImUzh8Kg+e4pyvbapywM6nNjVnTeNAaPs+/ykOC6mYsSrrG9SJd32rdj9mROdty0gS92fODXJvqfNu3Ksvk7OW3aFWpvvueX9m09evLcC2878EetnTPASFhk9TR5RSryEhhWkub4yFhzdgeivY0j6lcijODfet0Wq9qpURIUQFNIByuT8nYYBreCH9HAeymslqgY+NTWtIsz/R1A6agS5TjRpCt8Fb7whiz6aTVPuQQrWtrVTijQ3tBEVWAVP20CENVmN7V6oFDR1lg/1CYjyoRo0uGMuqxWrrStswToqkSCPZWVKxIhkryI1Wb+QSh6GQuDglS9T1JIk4+FQW1K5kNqdjTsT16cU4pmLpUZ5ibrZpur40zOc0U0yPi4nW2mgqx8Xe9KYdDYXif+62aubi88fBS7tNqsbniOE0ub9q1ahIWAwzPld9q0K9JmBGDatCvU7n3Lvzp57oV7Nx7+4iM/fHZ7j4Ict309/FdVi6xCoSALHlgNCCK2EurjOHHwFrUilYQuY0k0I8VvCKsqhjiUhqAlIgNCLp20sUAr0es8sd9FrJqk/bVKQofOhvGG4Iljo5R5BVomp5IFQwE7ISAYfduALEaZdHgWBnXorENh0DXsMvhIeCWY72WI5jzNkOQ9K1dmHEDrvtXCoBk4skaFqociKrEyzMLBK6O/IOaTzh9fm7EwKLd32De7otxzifjJEAkZqo5yCUNh0NhejYXAZ143PFB9vIQRTBg3PJZgU+Vmjr8g056huW+vE/1Pm3ZF23QApk27cu39b/7Vx848f+/msc89+oYnzx0omDCxbIXCAcj5fyW5uUDwyO4EPSVxlAKSBNYqWnAVjPwPmB4SFfLyMBm9wln9JbJEIFzHeAWZFTTvMN0u9S4pRPHZk7ENvlE5OZuw+oyrCMRY5AoKRZlGbEtQD0aETin3mQ5WAlApwDER//B06r4FTEc4Wrl2R8vei2jemlUfwFdeYSs9nuoDgM6eoIDynInOwwGYrD56QbG9074Va5tAg070P23alW3TAZg27Yq2f/u29zxy7qb9G0e/dPwNj597TtGUm3nao6GXoOAVI3yRgvr8ywCmChAiSvCpdQAhP0v3woCq8viAxNlOnWY7cSm2ZjNUSC1BaXNyQPonPhfpVbweO0CRt8Hp7ndv9o2OPLGB1G7NhT7PKrJU0ZI+Efu29E9GH2CFS0YEARC91lD16VTEOES91lG05BWUOICPGc2QbDqKD1DnNvgAOTeNtI0a4hgWq/nKsVno7JdUve+NhkeY26tY+gDj3HzfGB9gr7HZAs3XDccYQYrtTdXUyr7Z/TJTQtMLSu932jOwboW7OtoGHpgpv9OmXdk2qwBNm3al25fu/YNb3/gT1+0+euLcq7fa0d2bTxREH0gbRDEsXxOQmcgO/Ei0Z39GSU8PFlCw7W04QLR3chnsFCfolllVn4B+xtCmgDBvRUAnyEI0QuAcenFDi+JaEJ6MFr2iNFADeEBYA0z33wzBcnMipcF6xbepzuc8h4Rr35l5OIBwCYgehrfrEurg83CAq9qUMbPWcPiuuW/Tpl3pNiMA06btAPv/furnz+AFG/LQn538vuOnbgaQZKehewkkHDyxtRKncSMBsmAaFZWA81X+4aAvCv5kD7tOZb/dASvscmGRyw21NBAA0srloh6x+4qir4hAFBDrFqpuFg4i2SyDXtxm0XMm3CjkpgEC9JFLTq0I7xUbrtwBYdIF1CdHL8ZJ6KJjuZDOPkho6yorc1PNvALOJKl6eljUAmUzXbcEymMKVa+lfBN3h73K3FDmNvy4EglZNmMcgNsr7mkUYh654QNVH7KuvEXZcC17XiMhUrbX7hkvYUmNiNfG4wCxS7J4n6c9hQmw+wykA8B9E/1Pm7YTbEYApk3bGfb5u//dC3/8x/a0k19/8rs226n9W8edfncQI/wEFr3JU5JI90KNpjPgIxDvhZHXjU8BQkmxW0sHWPzWqPRA2965IdCZsrEs6eVkgqPYC+K434EndodDvclAkzvcw5oSMWSmySB7sywenxKoYNHZpgLYJMi5HVII71iJMg4wsMv1x3k4gP8/HkzsflkN2w0+BLJFmds8HOCymwAHz2C7oW3jk++ZezVt2s6w6QBMm7Zj7C/u/f0X3Pm263HizLHbT+8+c2DzqFT0Rl7dWXNIwY3VN0CgYcNAq+IcstYDIEuOl7BXsxdQeOAs3Rin7YYIpDKqidSzmYhx+pTipLtSEaKYzj8WWyDgOG2lh1RONk6VlKP5wN4SoJAeCGOkdQkjTE9FDQKApjPjyFJR5qalddxUBx/AmmWUBYw2LHwAXin+yXolEsD35MJoPjA5X6BE8zEU5xaAujiNnFruRi41dikWOXZc9YLKinNRw/baA1jZt8GNjb/TBzDftzoScavzuBzTBziPieDgGZxt2N3x4V+buzRt2o6xKQGaNm0n2Yd+6u1y8oazu49/8aHXHHn8lYNWBChonoVAU8AT5DwUOkAvLxOZmgdJYQb7irfzAVIrEoPXIjZYikD83zR9EW9wr4Eps+KynyLF0eJZBGGsfUiHhQHolQRZZv1qVjHyuelAWluFeaW8hxtXl+BoM3Jtc24lIdhgeqlcaTOpAh4C2yHXdiFfKc3KwmPreWV1bij7Fr3WlBJibnGuSPPdsdjCQrDEuTG3mKKm+p6U2WYKucRLyGl7M9/w+j4sC4NqHTwDJWPqNrc335OiGSvvcFQckipYWm1WN3x4V6vnOi1tYxunN7A1j/qaNm2n2fyNnTZt59n3vve9z9330HW7jyp233roMAGsKPycLHGkJp1XiI+aQqBdIUCzr7wXJHCW+lcAmnb1M7Z4rJIBNN7OyHK7S/MCnFpGRp78hRyEH9QGb3YvQ56qTZudFNZgg3RAmgI8w8tXB2ldATROCaotl2Azt5KEdpxZnXYX10r5rIzybn40GOwYtcZztUCUilQQEXoPB4TFlexFLrn2GqInUvh1lF4CjInLeT4XAJz3gDC/Qgb+fAeERVgBiBUJ3S+gDj40S20Yt6VcyZaRXU7wLMNCbLpqeD3nNhwQBgYF4srQrD4LLNVfQyJvTJKPqx4Qlm2kPKZ8UuP2TgOQXIMA9//K3JZp03aezd/badN2qr3p7l/eu/XIybPPe8mhjxuKUoiKoEcxRfMBGslhidN81QncZsdBGb6HF/Yk3AeyceJ4g+9QFZ437M0M1ncCLLVm3dtIBe42JWnB2ENtzFbhuDoV7If+qtO/DaDPoNFG2KC4Lsp7GdSEoDdt1sa8BRHfnKYQVXU/QcWPKKY3tUCWSx8g0PwCgI4+wHmRpV2pGhvPzCaklnLlPGg+Oy58AGF4xj2HugSMoNxnIrU4ksDdm7HZ+itrYXquV0F1GsrcRh9g3b759Tp4aXZeNH+eK4gAwXCluGrxxBcuVmzvNW+ae/bARP/Tpu1MmxKgadN2qv0/b/0/Tp593r6t419+5PVdmwMWlp2JUvQBgpgTXCQQVd4QOhbAK/CAoh9QnQ9gqM2uUMYYGlzL3pCyE8NXvUuIK2r6ACvDkJhFakUGUEGEr+TEVcGDe22tRbDU2Se04Mw9zWIv3SFwRD7s7s1HR7Nzx5jDPChMCpMc/0jecU1JHM5tHg7guyR89B6fsCelw5slZd/Cny2CpWx2Pu1TXuFmxvbOwwG+DQv6QCb6nzZtJ9t0AKZN28H2b9/6Lx4/+/y9m8f+4vh/8f+z9+bPll1Xned3nXvvm3IelLIky/OAZeMBg4vBQDiqKrq6o4iKhiKRlJZsGRu3hwaDTZWhICJ/6oj+H/rX+omO7o7o6qaLMm0aqjCGsmUMCFm25imlTGUqM1/mG+69Z/UPe6+11z73PuXLzDe/7wch5ztvn3P23vc6/V3fvfZeLfpW99SzupEloxmqWQvJFM0kWYAatbKUoLQqmS5FbVrqtj3KtJrYdoQq9jBtJ6glXZ1BLvkKfG9AzLP3Ez/zYkAWcyGM0RBppHR8izR852wtUgGBtq24SLWe5AmbrjW9bz5La0jSkMte5dkj5NnDrnikFHcjWAa8Vn3TINNLM50YQokBasWf32J90+oT9xjABxK2Mbguh/XcYwBYOn5nCFL6bPHJxNfSZ8ljAKDsRsgSNH6XwoR3bvTJjCFWXpywuyb6FmKA3LfyPdnPKBpTDcz8IWRXwwCAkN3N/3n67OLqqQODC89e/PkxBsGmdcnv6Q6qrQuu/J/5RH8xE1pMI4mfCSMogsytf1fSZp66QhK7qClDJYQKRX1aM1d7QHhL1na5vkGS/1mHmfco4bcWDBSRmsRzY+owLRfYtLzRSoitKljn1lSW9rTiLltY4sLdRGqMATwuEttHG/faAlUMoGWhpQjo0LddWhygfE+qyCH9X4wBNK6EVFa9jWgiBtBKzaNeCenEACGdh8UB1kP+PFo0Db7376j+CdndMAAgZNfzf9//B9dX75gfvPbMpV8c6Wz5hWnE5GtnkVoEYqUUTam1QJUrUk7XcS9ZXX65kjaX1Fqk/HpPtDBtbXouZX2gLV6yi1TEZkDbmvwKqTiak77LYS9t5eDmlRCPURSK1lWphUWmlV3fA6qt6BomdKdvcP1a3OU6CrJZqtxlLQk8xQhPmjiERhplq8U5RWcXO7wy5kPsZJ2U8PASG9QxgJZPoY406uOMrG9+l9qCRrhLQ9+6Vr0n8Explrvkqff2odj0VlGB9SE/tAopgXgoUO5qnQ1lXw1PPUrtYgzg0xu/lvs+Bmhs48Z3f4/qn5BdDwMAQvYC/9cD/+7a8NTC4Pxzl35+1M5mzVT+Z1qL8JMsplC8VFdIRax75FA9Iun4cjh+nQuESoCKabfiBLu7bBlHLsuieQ9VkYnDHLXkY4h0nmkDFPspL2jEJ0tR/9mYN+GeRWoLWyepxiu1ALUheFeDu2xRkHYN8nByZVCWlbCOCTy5WTcGgFSfkfVtIgbwsKdEcdUqBOofpw3BY4DwqWr4RELCUqdvk7sR4oSjrA+EQDRMr53VX8UAPplu3ldfTVtm8b51YwApMUB46UQMIOHg1zCZnRggflf3FS20hQi+S++fkD0BAwBC9gh//MDXrw/vmBtceObyLwzHc+mipeKY3HeXFOZ6u2ZyEz21y1FCtKVD9oiUM+M1StImO8m2+7a2w01guTDr5tkDyLGBQlq7rv4oe/JEEojZ5k2xt4sJ7VfKeoXNgCnLYk6XDrtI1TIEFgdgcYD4XcV+QG1rvdL7J2TvwACAkL3DHz/w9WujUwuDC895DGBqxuWXCICmMl89CcQFT64c0FGWWYcinTWUHx5MaFVoC987kB9uzqn9Qdq23OKWc1Zj3g8tShquPr3gAQDReOBPoxa1qHhOUQljAN+NgHKlJHmb9x9kem5pPnGZrolckRjGFDu8xAApVapUH1vLXbax+BWPT9y6nlT8sRlCKk5MMUKZXltDMeGeP8EyosqqN1EurtE7MUB+4xTFP92q1zhL8WsZzHuYIs9D0MmVkBCYlSFUMYBPb4kBclxQTbir+ZiJVCZtyhBCYGYj2Os0vTwDj/4B1T8hewcGAITsKf7k/n9zfXhqvn/++cu/OBzN2eWoalViokVxl+3A/bJQUFIvsvhL16R45EUZu5LW+l6Tm4Bq8v4b84mr9QELIdLGAJSAQc3BlajegiLPItXzxVXNKW7ToOALGAiaL71PWle8EzLd3GUEZQlXlhqUZcllt7FYrsiNTGhjmrtctLV58PaPLd1opeYRHX0Tu2IBVTxxSFDFAG7e17FilOk+QzmBR8MQxL9JNsPxigV43YNBJUwvwvR2DgYtyWAadDl8COg2i/FYWW3o9M2v+PTaCVoWA9QTXn1XqxCrxM17krFi3KLpUf0TstdgAEDIXuNP7v/a0vDU3OD8c4u/uDxeKJazOceSywVYvgZQxFxR/66HWsD0FiBNrSyrdI5UMymrUnVhZLKs7AmWrvxKwi+4y7BmKALUZa+24Tmpd2EbQ5LoJfMnbPRM6q1xsRuEe5HpIQaw0seTyrJ2l9PahU9aUfN1DDDhJXtY4ldYHEDRjQHqvtkXTi0GKAlLlaMf1Xz1fQ7TizC9LA4wQdtABK3iO1/fu4MkZL/CAICQPcifPPDV6+NT882FFy/8wupoIQvQytv2A3acbC2rdnRqqeolbn+mX3Wcbwl3KrJjL/ldUinLamUBtje3aDuXnr4YkN/SVnpOUXYjuHBvi57L6StF5Yck/raFqJQtuR7kVJGSJaLc2F2e0JrlpdG6niJJQy57lWPj8Un6PzfvqxggPckSeKq+Kaq9xagfXoawqcUBula9r4R0hiClz+U7EmKniZWQTiCaZ9iaTXwuLA5wM7Qp6m+BBt/nrl9C9iIMAAjZm3zj135naemOuZnzz772i8vjIwCKdgRQiblaWhWx622hYpWz7HqlLMWccpdfrt5SBk2QEBO5IhacVOFDkaSecVRnkAtEVVQUVhVY0EC1zTpSFZKrEofOxCwO9TpiAMJ+gDwoq2BQYoDc5zVzRULfQnyyz4sD1Fo/fPTTm5UQK83SrRcH8OlNVzTMOYsD3IheLw/6b+n9E7JHYQBAyJ7lGw//9rXVU/MzF1648LMro0Mu+l0hSZXA4HneCqRDgWqfGAjqzS3Yju4Jeii7+mELKXJVYPUrOXfGrhTPVaqVAfWH23+KIpn80V1Ws+obIKU5NdZ/V5atvbV40lqPS4FWXN/nDqxhQhcBag+ZcJeLT1wCMBYHsC55As+GFweo+8biAOtEgfEYbYumYa1fQvYyDAAI2ct88+GvLK2eXJi58NKFj6+MjnjBLO38L7uEkr3qUqlI+ez/inZUjvrDRCcum3qr0txduylQjmAH7ET5mNJd5GkLRecA/nL4UJZxvjEAgOeWh8x1AbRFU/vcYZgm/XyvQpDpk4q/mytS9S24yygxgFbON4sDFL/ds+oRhh8mnMUBtghFX9A0aFue+EnIHocBACF7nG8+/JXllTvm5l576fLHV1IuEFDli0f1XlJKTOPmgr4wJQhom2WTRNe8ekqSpFlToZJ9lrXvCjJqPoSXBmUl7hPnV2R9Ju4im0itdJitXBQnW5APfa9Pr7f+51mprwQv2a1rF6D2qDVz2UvfipsOsDiAfdvsO5O/XJ0VpDLhLA6wBTSCVtFv8P0/pPonZI/DAICQvc+ffuq3lsZ3zPXPv3jxZ4bjBSBm9UBcyicjuVbS1eGbIkWxRVmGoHo9XNAJhVRuhLgqdXEYigOUMxk77jIAqdVnV8tCyhXNFQ806sjOWysRLIgHPub8HBYHqKx6E+UsDhC+z3ElJH5VdhnpCN7/Su+fkH0AAwBC9gX/74P/49LK8YW58y9f+bnV1mKAkvlTydlgy0oldLSSPgKUuzxXJB8bavn3qGVx1odtlo4TeSzFXY4iNQjQlLtfpYAAQD6w03YMI7/Sc0W0OmjIh6B+0fNT1swVsebrLQ5QxwDW4bAOsKYJXSZ80l0u2tqiIPunrJlENY/o6JvYZXEArb8McSUEZXr3SXEAVYztv9zfYd4/IfsDBgCE7Be++dBXVsYnZnuvnbv4c8PxAbi+Vy2yJzj6EhVSxtRb3DGsrtWsSTndXou7DC1SrxHAUnFcHJd7FNrGk4OylEeweqGhQEHom7VMf7CtzAoxNTjRzNxlH8LUXJGqOIAfidNRlpPucog6ipqvY4CJ6Q3TN+EuB6u+BBVhRNY3a8biALWjH9V8nHCE6UWY3v1RHKBp0AAtuOuXkH0EAwBC9hHfuP93lldOzsycf/7Sz4xGc0DH2y4itVjkOUIImqZxsxlxO6wdwG8yL90OdSFsOsoUc5LdnlGT7nN1G+1VoOsuq91oz03SOmjrLMvSALOV2+TiAGFHQZSMJjer4gAq2harHj4Eyx55Q3d5QmuGcQXreookDbnsVY4N9kJxgG4MEKc3DkHCQoqG6ZUwbz5L5XtiHnxIWArfpTDh+744QFrHUUXD8/4J2WcwACBkf/Gnn/zta8MTCzOvvXTl50fjWQBF02T7M25/FKgZ7SU2yC5pPoAfJhZTIoy1ri32/PCcwONizuKIJLbKSURuuGr5W8p0mCAd9h9yRSwfXYBwUrslgRRxr8nTNf2XaoEl9dagSMaQLy5BzVerDRYDwF67lrJE6BssPtnnxQHqH8P01s02vjhAZ8LjN3//FQdQRaNACxWe+UPIvoMBACH7jj8/89WV0R3zg1fPXf54qwNzLmEevFmiRSGZWMxKqAjQkmgBQDUd819kJSx7RBX+hqSAg0LyIzs9AkFcGVAFysFBJpQVqimVqMoVyZZzW/XN5dqEgyuVmw6o70ZQ5Eph7jcHfQ/vsIldFgfwGMCH4HfpjikOgKpv+7k4gAJo0Aoaxfeo/gnZfzAAIGQ/8s0HfntleHKuf/7cxZ8f5xhAIbEWmKnt4OCKi2NvFuqFdZL2yx+yOWp6qAGKesq/bjzkgElk95KT5kwJ/bm9mrKsHX3VXDEA+fgfkWpVIT+yVYGqht3GwV2GucviXepY9Z0Fk6j4owA1gxwxPtGJXJEwvahOrQnKshLWMYEnN2NxgMmVEO0OwR/u0aBMxAD7pTiAxc5Ag+/+AdU/IfsRBgCE7FP+9IGvrqyenJs9/+qVj7dtr2i4iJ2pmX/r1qbLG8ktpFI5MXukBbJK7wpQk6SCNud1NKaZJncjlASVSjFLvI4Sn5jUS7FF6mKIW1QbsehKBz4nAAAgAElEQVRkwl3O6jRKUld0CDIdJaXEc0VKDPBGuezFqi9uOsDiAGXC/YOOkSG0M+EsDnDLtC0aofdPyP6FAQAh+5dvnPnayvjkbP/VVy7/LLQBzMEFgmRRRThiMqd9t9ZGs5yrpE+l7crRjbCs7qiQsmquHVzkB0gTZJzLdGsmQfNp3qrrHfBXhFwRl33QlLCUH94EL1k7fUPwia1rLA7A4gAIcdq0IYTAzEawA4idYN4/IfsZBgCE7Gv+06/97vLwxOzg1ZcvfcyliuuE5OmaD1v9ym3a4sLWojnIPFfGtbvctlJeA+S9pCVXxA98zGIrWvWpcVCWliuS3eD8H1GWaesy3c8/tdDFmokiyWbvqlUz2KDiAKGiGcxyhgnjNzShjWnuctHW5sHbPyVyi2oe0dE3scviAPEbXn2fPVDB7i4OoGUOvsczfwjZ3zAAIGS/8437v768emxu9rVXLn8UQHWyJ7QxC7PIr6CQ8m8QlCWAvAfXjNikkEo6R7rZvVuNJrSY3DTzOq5ImJcME+7FTY8xQKccmAL1yfolIDGxHQSoxUDBvE8iemOKA2g1aUHN1zHAhJfcGULlLgervgQV/pzSNxeALA5QOfpRzccJR72C5NO7e4sDSP4Xz/snhDAAIITgTx/4w5XR0bn+xfNXfjLuHxUEFThJSHeBuIbNDq6oya+kkIoGUlUViUfioI4BIOoasS5F7PretZ27qlG9FWM+vc0OBUrrGekcUhd/khLtWyDsKJDOgY/aKQ7gfWNxAPW3WN9KDOCRUrnL5s0HHua8igHi9MYhSOmzxSeIsdPESki9xBESluxrU0/4Hi0OkLfpCB6l908IYQBACEl84/TZ1dHxq3ddfu3qj2enMB/XA2lqzQRYbODytzahVQWNS6LKJU0SPz0q3dqYQjJBJuaRF+c45Irk52V9CY2KSqbtNk59a8wnhiWBwGR62yIfKNN1l8OPFgPAHH2XyzFXREtXp7jLLA6Q7wp9K3d1tH6Y3unNSoiVZonFAd6AFlgcA0LvnxCS6W13BwghO4Un/+jPZr/2z/7mF2fu/dsj8zMXAISSv9k+zEo2xwbp3J7UpEH+g4QDQQUKiGc/5F+bByxmVAsUaNxrTf8ZzOd8zXKJRNDacaLl+CHbrGDFCCzjIfUzKXxBY0ZoTsnOHRARFeu5Chrz2yVHOlGK+raIMiiJusqGWZqJtytXNMxHeqlkc9leZVGJ+EDcUo8/2s5bH29xwMP02hzalFbj9xuqKzbzlWaUyX/ZEVEq1Vusbxb8hFmyvslE38T7JvGddmV6s/z/9vow2agms3Q7/MF6X/omPm+5qzaZKCNKVyQ0Ex9v6Fs9mXF6t06IC/C9VQwET9L7J4QYXAEghBSevK//4f/aYP7eK8vvSNLHLXaz3t2xBpDllqpC2iwfPcu87IZMDbUOKFBZ9VlEVea9qchsDIsi6XhVzYV7rW95ZQDBhfXSV6r5XrjQLM9MFwWaUo9ybpBXBRaotnm3cch+yfZvdI6jbdyxnHMzmLtsE+cedlltAFgcIFr1nQmHP9zGG4LT/AULN06uhGh3CP5wm970p5Lolfu2i4sDCA6v4j0NXhlv0QsJIbsCBgCEkICcvev80dUrixeee+fi0r1ZNAWPOOVcKKKyRLpkdq6JVMCUkMcMHeWddXp6gPifqqggC2hBEX/WG9jDISjH9aBJ5cl8RCom5kzqwaWwDS7FOiqd0rOIxwRNSFJXdAgy3TvmGTWhGYsDsDiA920rYgBBs4LrDe5ugbO0/wkhBaYAEUIqfvTv//jUL/yr2RPXrvTeOYPXB4NrRRQnaznI3iqNIktxy5TwHBP4zYjCHJocfSm2uN1eTNqcaCGAoHWPOXrOuVuaXorGVgAETZL0kjYAmOEtgITDKkWzre6pGSXC8Es22NB5v1liV+2EmOAwW2KSOeTdXBEPLmzeEHJFfFaz2RxCsdIidCl8JCXHphJ+nnQz0cyGkHOKQsZR+rAkDCHfpS7ufUSesBRfGX7MD68+3zChnTukurmTDRXH632DbYgIfauyofyVVcKSls8uvlxDl+zTi28un5HdZV8AdJuVC53p3TRd3kKHQAO0+BbVPyGkhisAhJAu3/7N31yZO7mg5xcXP7wyPAbLvQeAdHyn26vZXYanc6c2wRDN/2nJJ0HkWx5LkYPQsqqQL6gppclcESDrLTOqWwXauB1WvDiAucvQVu0tgmzx5ivWLHnCUrpuHZhwcFkcwJd+3PmurHrkK0XYpwSekL4F/3x9wuMVn15fCcmjC9OLML0sDmA9Hwq0B23xHap/QsgEDAAIIVP49q98DquH+/2Lr1/+2OrogOn7LFZyQo1dqVIgitjIGlHKPUFZwnZJqgbVWDRfElIS9K42JoWbKbnsQAvPykgvKNkv+YXeMfWconAla8FGFdpk0aYIzdTUW8kXZ3GATt+qGKCaXonzxuIAm1wcoBH0BeMG36P6J4RMgwEAIWQ633zwy6vDE4OZC5cWf3bUzgVR2JpMB6JFXkmrLMikiNS8amDmvUJE2jb4xIjusjfOUi+KLV9v8EfB5V0KMILlnB9UCetyDumku5y8/7yy4HflV7A4AIsD7PziAGPFuEWvwd/z2B9CyBowACCErMn/d+ZLq+2J2d6rly79TIuB+e4Cq+NbEp6jT9xmqSTm4NaHAmWFFHL/Xe8X9ZYsYG2LNSvBJ/ZkfsDySVxa5W6YtGpgm5JN35uDq1FZ2mZQE6s5TXvSXQ4/WgwAFgeYMoQSA4SVkCoGcF3e6Vu5q6P1w/ROb1ZCrLyCBKljAI0rIZVVbyOyLtUTrmHOd3hxAEEjaBXf+TrVPyFkTRgAEELeiD//tS8PV47PzL566dJPp9QYV2qNqZmskADTu1br19cIirRPP7a2MtDVc6b/iwKO7rLUAYO/1NRtXnOw7B/7bdtmjz/vNygObhUDeKTgyw7T3GULCfyuOIryYyXTdQ0TughQe8iEu1x8YjfvUZ84FBN4SlfRzbPXKFvrIZRlgRAphb5NserLwHNsUMcA1gxavSWuhCAMwe9SW9AId2noW9eqL5HYZDNYrFhPeL0SUi1x+PRO9K3e7BESeOz7al+MFAPkB1YxgE+vPyRP5sbFAN47wffp/RNC3hAGAISQG/BnZ74yHB4fDF557fJH098ZKmrHseRc6kq8WGpMEKAKV/zRJS3quWO7okjS/MT8q/T+HHdEdxnIbq+peYUCbWmGCUcfeSwWOdR2OGyJI8UGFtugiHsWBwifV7UoMWUIHgOEFQJ309MEx/Wi0DcWB1g/CgCP/h7VPyHkBjAAIITcmG8+8LXV0eFrd79++fKHkPSnCWiXsp7yIenvFdvIW2SNajldxzR0JwZIufdaSVLYn5E0upUGsLtMZxdlWVxkuzfr+xCQuHrTEDkUjQjPFfH4YtJdDvk0NgNaZqTI9DJNJlJDMxYHYHEA79vtxADz8wDw6O9T/RNCbgwDAELIuviz+//wwvEDf/qrvcWld5tsSpi6gmblln+s92umS1132bUdkGIDbUsue27W0UZRQAOKdCiQlJAgNfZDgZCsb7vLvHRJ9cKigyv2Cim5IqrStiImSTtech2fBJ/YZq2S6WWWYtxid8VckRDGeN9iDKAaTGifzEl3GWV6O/PmA59U/OgOobLqYwwQDPIi3NOCRhhRZdWbKBfX6J0YwKZ/UvFPt+o1zpJNb5y3HJipeJdiAo+tNoTArAyhigHiZo8g7qtg1fsWPsGymFBPuA8hBGY2gptEFe96F+YX8Cgzfwgh64MBACFkvTz9/uY9fzn7ytUPXl++N8mySrt7rkhxl6OybLMei4540aOWbQ4zj+uUEol35S3IJVcku60lEdwUY/JtRdEUZWmK0DI74AOpXqpQSGuVnmJJ4KLeqrsqNT+ZKwK71yRpdJfB4gC2mTs0qyY8XvHpZXEAQBW9Ic69iOPH138TIWS/wwCAELJu5Ozck/ccnD2/uPrjyysnq+xwoMli2q9UIibrNwQBChOyAuR9upIeZL/PIt0q/6q2xSXNKSQptweWT5IcZ5hXnWu+BvXWqN2vSJIs/y1YUphQLgSrPqnBIvu8i8G8TyKaxQE6fatigNI3ZXEAXy+yl95scQBVrA4xEly/jD86TfufELJeGAAQQm6C7z/8sMjBnly8fO1jw+GBIIC0qHkET1RNvcGuJBUbkq2luMvRuM0aN3vw0qIFGlPSyZVPeyxdywqgLUJMUs5lj+5yUaIauwQ/taaxU4wm8uxLDFA6yeIA/vAyBBYHKDGAfwkxpW+3UxxAATTo9zFUlvslhNwcDAAIITfHfzn9+eHoxGzvlauXf0bbmSSgk/oWU3jdA3DSLzouaRLxbnNXSTJZJooZqvBbQzK6ANLAJFrrwjorS5i0yo9TaGvyOp/yH3JFcm8rn7gxZdnAFgRYHMDnLcZ7GmKAYNVPDKHEAGElhMUB8purlRD7r8Ma5K+4ounhMap/QshNwgCAEHLTfOuB3xgPj/dnzl288jFoI1o2/5Z0HUvFseNQtLKcJ8WxJ8mY7nFNHhShuaQ5g9yk/MQBOIJ4/kx6XJGkdqanSVJvlnVYdJdDyDHNwQ1KOgjoOC6UHyuZrmuY0EWA2kMm3OXiE3vUhPrEoZjAU7par4Tk5YEw3jiEGI/FjwBh3sKEh4eX2KCOAawZtHoLiwNMOb7pBjGAAg0gLSD4Hg/9JITcPAwACCG3wl+c+dLq+MjM4PzFyx/LRqYLd1G0SabD4oL0C7VLqWVrujBYzkBQqCbBo9xMUUa8YssI7i5XO5JdgpsizGnZ0YRGkmtttobRzRUJyk8RigN0laU5uLVqZHEAn//uEDwGCCsE7qYjBQclBoh929/FAdI2mQb4W6p/QsgtwQCAEHKL/Jf7v7Y6PNa/dnXx+n1Z60jQYEH/GNXpkEXJp2apXYMkrcS3ASQtC9PcqPW9qfksF31loOhs19NZ5xedKhYJpFaSdiMENR9iAE17Fcw2lyhAa3c55NMgT4crOgSZjrI+4LkiJQZ4o1z2aiWkCFAWB/AJt69b6lQdPZYJ373FAXoKAb7LQz8JIbdKb7s7QAjZxTz/v37jno//0vW/vnPwtlF/cBnmKgPpbM7GpIyYlMlH/Igbv1L0eH6olDQKKNDYBoJ0rKLYo6Rx2QgkJzu5ulIelm6B5Jwgkazv0kvzw7MWk9IBsQuCPATJawPi9nU+fNRkq3V92hUIRN3lzg/IJ8QEhzln/fgrcnkyKROmCA8RW22A+G9t7kTCWEqL0KXwkdhG69DEfq9Tm9kQUt/yu7xv+YqFgCplIDlcsa0i1rfwyrig4YGevzH8IJ07pLrZe1U+CO95+AQ1zrkHrv4oe6VnDJVmUn8W/vmWT6qacJ+5cJd9AdBtVi50pjf/6sgqWsHf/AHVPyHk1uEKACHktlj50ZHZ+65evXDf6vKdAJK9atLODuB3paOtCb+uu2yo+FmfCM43TLqnu1TRtvkvMDOh06KBGd6p1FdbvGE/vR7m0YbtsFIKhCV3WYox3yAf6C71NgYWByj7CsL0sjhA6Jtf8em9neIAqtBVXGswNwYhhNwOXAEghNwWL3/nP9z9K786s3BpNHxnf/acNEORsg4AuOfqvjnyj03Uodl2LaqpMcddGlPknliULfTcVgWNIKVYN6IqpiIbU9Ju1Tdu0wZdXLqRFwckyjcxWza6y+bI5oNBp5jQxbzPqw064RNPs+pv4C6bTRwRmfjNpJ//Bu6yTap6CzHNHZ1vlN90d0oUT7t+eI4gug8X/zfCn0rfJM6bJ26VwfqV0CwfJzrNqkc1hDK9NquiUp7anScBUC1xdJrpRLPujdbIZ6A4/xPzBltz8U/cXprWrtqxQNC2+Kuz9XeAEEJuEq4AEEJul29/7nPA8WbwytXXP4Z2UO/RDB60+/fFi03XPf26BZCTcVKSd7JKk7jLR8G0xaq3lQFV86rTOoD6Vtecyy4IJ9M3SPaqu8tBt9f54gpBe8M8exYHqPcWo354GQKLA/i+EV8Esw0qVd+mFQdooU3TqAq+R/VPCLltGAAQQjaAvzjz2eHw6MzglcWLP5UFJWD6JedUiEZp5YIV5sfmTBGXwoCige3XdEcU8J21yNdEgiCztQHf6mqGfmevbfJbNS9XpH834tpO29as7SDcJ5NANPvMVQKPdoSmxQBgcYApQygxgNossTiAf0/SV7qBohWR7/8h1T8hZANgAEAI2Rj+8syXxqtHFu89f+3aB7PgbtxkDdnk7nmjZNWL54q4UZ2IcsqDhfQLayaN+a0WaSBnVSiqQ4EaE22tiz/pnFWfBWg4pqYxL7mJ7nKw6qc5uEFJBwEdRT/Kj5VM1zVM6CJA7SET7nJJfHfzHiwOYF0qkdhks9wly+nxD8Wmt4oKrA+wr1zdt00pDiB6dQxp9NHfp/onhGwMDAAIIRvGX3zyqxdPzv35r+j1a+8Aik8s7uE2tTWrCHLcVXjIFckCLGSYFAmk6vo+hRdlHUDTz2LvKO5y0eUqJsuCde3xCcSarZUrEpSfgsUBoOFjNuGOeomj+gTVYqfuEDwGCCsE7qYjry95DBD7theLA4xbfG+lv9jKo1/vgxBCNggGAISQjeTZ+/Dub/WvLb9rdflNAKLNmRVekdgpNpCggE1dmbtsJXvTk4JIzXcGfxdtJ1dEJIqt9J+t/50nIQkkvzQ/WWEHCuVOdtR8iAFqX5fFASb6VpR0nF4WB4gPv0FxAJnpv2XQnhvzf6wJIRsJ/04hhGwocvbwM3fMNJevL354PDpox+RU7nIWWy2kKCSLCryNZ7Z0fFP7UUK+OOK9LhwR9KjWGSaIOTBaPcRXBsrBoB4DeMrHtFyRyRgg9cG7Hfzm4BP7vEWZbl2BIop+6ESuSAxj6pUQHy9CDBD6VscAPr12xfvm1vWk4kd3CJVVH2OAYJAX4Z4+wTCiyqo3UV42aXRigPzGKYp/ulWvcZZseuO85cBMxbsUE3hstSEEZmUIVQwQN3sEcV86EPsWv4QIcRpUVRsZSjs8OtPgbBkJIYTcPgwACCEbzHce/Hw7OjYYvLp06Z9AB2XXL1C85PRnV57o5pNkrZWIaetZ+Lksa6snq5bUEZiWqnNFpJMIbjeWJBCPPbrFASD5DKLK0i4xQEoAmSZAq7sqNT+ZKwKEvoUMkzxvLA6wL4oDaNvrN4peg+H3f5fqnxCywTAAIIRsPN/+5Ofa1WO9uVeuXv6p7ImWfAxA2zoC6CqknPmjYUNwUJYiqYKvq0B3jn1lQLsmtOWKiDv6RTUWqz4r2vxGhIcD3dOEQnwCLRpRTGyXQQV/vWhErJErEmKAuMRRK8v6Lot5gkYvIrg2ob3DWW6GIQSZjsqqL7MURmR9s2a+ryB8UvmZ3izmFIUYIPatigHC9PrBoHGJoxpsmHBrZusnE1Y96umNIZaiGwPUfcvzZusDMWGpcvSjmo8TjnoFyac3FwcoX0uB6HgsTe/Rf3sAhBCy0TAAIIRsCn/50BdH4yPXhivXr74/6618DE8r6ST+rq2ZpZW587W7DK+cBTOApcqNgSJtKLDjeoLpHs+UNMu5iK02P961nUtPf7jWOUUIOTZANwnE9JyZ0CbcWRxgy4sDdGOAOL1xCFL6bPEJYuw0sRJSL3GEhCX72tQTfrPFARodq0D10d8dgBBCNgEGAISQzeJb9//O61fv/M9//4mVpbdBgDZ51YJ86r8f82/FuaDSRBPafeL0W3EbWLUt7nLMfonqzdO+BUhH/EeNaJovG646ka6T/lg5+sGEjgk8k0kgqiwOYN31gCQ129LiAPWPYXrrZhtfHKAz4SFSrVZCOjFAeliL0bV51eZ7vzcPQgjZHBgAEEI2kedefft73/zUyrWfGI0Ow/Jzkj6yrQHupsMqhUE1HcAPIDv6mmKGRMwwMQQo8qsIrNwm3SudDJO2TZW/AEWjJacoPlzVdhubdA4ObhUDeM9LAo/1LMQA9hC/K6pSrcRljAGmmtBFgJbedtzlkvTi5j1YHKDzPZnaLHfpFosDoOrb+osDqGo7P9/MjtshvX9CyCbCAIAQspmc/cTR+blm8NL1Kz+j7cC9+fRL8dwYqLSVuxyOTAFEBaoNoC1Q/t7y7JFyaifCjeYlW+SgcDM8PUcUqpZ4YULWipe1otBWPDaYmi+Obq5IUKXp4ZO5Iv4uFgcoQ6sXJaYMwWOAsELgbnr6DoUYIPZtdxUH6I9ltIT53mNny+MIIWTDYQBACNlcvn3mzHh0tD948fqln8qOKkIdX5glCkuDyerNhbL9S1tzd11vifoxkZ7yHmMABH2P/Kac3+6RQ8wVQXCFYYoRdsUXJbpZ5lUMUPu6LA4w0beipFHu0rAbwad3nxUHUGm0bUSGf/8Vqn9CyObCAIAQsun89YOfa1cPXxuvLl37QLFOTW422bINad8u0Xz3bSVJ7Yr4mZtBI4rt501CVMxeDQkYlXDtJoGkvQoqmOIum088tTgAipKDZzpNxAC5mV/xGxF8Yps4FgfYN8UBREeDEYDm+189AkII2WR6290BQsi+4IX/7T/O/vNP/sPTH7r7+Ku9wWXPxxdXlFm4i8lHQT5Mp5KT/iv4ygDSqaBmqadFhnyev+eQ1JaqCFS0KY9KF7MYk6ZUGUPySRp7lD/VksPtdil9Ky8xEzpFDOXWcJf1zXsoEA3DlCSAzYK2nRP53MgwDaJVX6rfAhP9DH2Tqo2EIeQxhL7lk1RDT8JjpSjsTrP0EahdKalHYZZgd2kcQuxr9TmWKxZqle9Ducsaxis+vb5P2z8Cn974PcxhRd7WnR+lnQmwh2jdc+1+UvnHatoE0ONLR1sZf/f3FkAIIZsPVwAIIVvE86++9T33PDVa+shomD1OCc6xmKVdrriaFPdx3cqtxK22rQvKrJiLh+3ZI74dVsTK/eZckWA5Z3e5CXn2xU0HRKX1zJAYPsTlC7sS9phiq4sDuHANVr1Pb93MO5zHG4aQ7mJxAGxycYDeqHdtsDQ/mgMhhGwJDAAIIVvF2U8cW5hr+i8Or3xU28aXAJJAC9tJO+LV0ySsGSz1QuyKHywjyNka+XZ/Vps0n0JFvJllmAQta3616/sqBghRRydXxK6oiXsWB0jTW/VN673FqB9ehrB/igOkD3Hca0cy/rOzYe2FEEI2EwYAhJCt49tnzujoUDN4eeXST7ped3dZXNCrKTM3oRGawTRiW+vIpNGlkqTlXEpxx7lYs5am0SYRKRZUmEwv6TCqKn52kBQB6m/ParHrLgeZrsriANbd6NN7l6pmOm0IJQYIKyG7pjiAT6/tK4CghbStak8f/f1DIISQrYIBACFkS/mrM19oh4eb/pXlxfcCuTywmrI0GW8aMahSVXh2PETRYsJdRhC+6b6obk3fVz6xa1fbbZyVpZq6zRpRpJakVTPXiCwOEHV2scMrY37fFgeo+6aiqtLrjxTyd187CkII2UIYABBCtpq/OvO1dnhYXn/bcOWU+afZJy7+dVHSdlu0bDWIVNPKLuWDDkuoPcbWAsRsaVWIZhk56S4n0daqZ34H63qiWcgVmUzHt38rquIAXXcZwV021cjiAGqxU3cIHgOEFQJfrED+VD0GiH3bCcUBtJ09vNT028f+DdU/IWSrYQBACNkGZPmoLlwaLn6kbecAk3Ro82/zj5qlVJNiA0Gj2qZElK67LEWoJc1l6TqAHSZUW86A5tel84cEjUnSpnK+badpcL7Tc0JaeX5Xp1mIAUz+SokB1nCXQz5NmIFiqLM4wB4pDtCOm9Vr/f7sCIQQsuUwACCEbAPf+uxnx3pMZs4tXf6YXbNkGMDUlfhVycZ/fWYLwnE9HZs8P1AhKpbLbieKuodtwnHCwTWhidyyMbk5zV02n5jFAWJgUCt+dIdQWfUxBvDpRRDu+RMsI6qsehPlu6Y4ALRtGzQYr/a+8/m7QQghWw4DAELI9vA3Zz47Hh29PlxaufIBSWJbEMWWBAUGBbStTWhYs6je2qLbGpO4jbp8R35Dm3RbuTc7/ZYrogK0MpkIXkRqpSxDDOC63HOKbAgu062ZTBOgVQxQqXnzkrsy3dxlBF8cJtxLjvtEDGCSPKwD2PTGGKBiSt+Ctva1m/xPCeKimkd09D0byqY3njgkqGIAn97qexJmKYdzZaTdTQudCY9XfHo7B4NKmF6E6e0cDFo2fKt9T/wtnRgAAsh4CSKPff0ECCFkO2AAQAjZNr7zwJevXD311499fLh8b9GypVCSmpStvWQU9Sam3uzMnJAanjS9RKseijZb9XllQKMJnYsDoIWXpIq5IjHPvpv8g0rxd5xjbwkWB9jvxQFEMV58Fe3qY797HIQQsk0wACCEbCcvnn/Lu+9+Ql5/Tzs8kGVTEoWSbeMSDuS/rkzahnQXSDgUqHKXkZVlnS+OdB5nbq+qmpYLoCpNVvNuh2clF2KPdB7opLtcSdJ4ZdJd9qQXFgdIYRjCZFYPL0PY1OIAXas+Tm8cgpQ+W3yCGDtNrITUSxyqY4wwd0hXr4EQQrYPBgCEkG3l7CdODtDOXVi58pOa7eRizYq2Yso4a12xc3JcYqKBtiZAk/KTpLQrd9lVeFbb6WlZvdnTASCXKPOM9ib6zWVRAjEqwNRcEVhU0U0CYXGAnVYcoNb6YXqnNyshVpql9RUHwLjpAY32B4+d/cAa/30ghJCtgAEAIWSb+dYjnx+1R6+NloZXPlSEl7vLgMQ8e/O8BSHJ2wWooIQHUaTa+UIoujToyKyAW+ScIoRDHt3wTgsLrT0/27qVJM0C1KTzRL64r0KEFJo13WUNfeumlUMrcRljgKkmtEdB/pDQt7KNQePzAbA4QAzn1mqWu3TD4gCtysGZnja9f/waN/4SQrYZBgCEkO3nO2e+dGXxzr957KdHq28FgHwAT8kVEZfpWaADAFrLHonJISmVv3ZwrY0vAr7nxE8AACAASURBVGCK3KyvSGyTsrfdS47efHF8XSNOyxdHN1ckqNLU5zpXJLjLCO6yRRcsDqAWO3WH4DFAWCHwxQqk4KDEALFvm1scoPnAvXcemB08/jt3gBBCthsGAISQHcFL59/87nt/2Lv23nZ8oJywrujGAICpxJAEosW3FnFDWPPBQSF7RJCrCpR0/PQohFQchIfbw0TaYtXba6sk9XyX1te1q+ZDDFBFBp2DQWt3OeTTIEvSMOQi01HWB2wGSjMWB9iu4gAtWoyb589fPnXkIAghZAfAAIAQsjM4+4mTC824f354+aMqvay9GuRcEUFSV9JgQgEXd7mUA+u4y/HPRSNWZ+kINP2NqEHVZeWMyl1WF4gu0yfcZfOJpxYHmJYrMhkD5A77FfgVgMUBbEEjjKiy6k2U74DiAC10tm3aK9dW/+h0eSIhhGwjDAAIITuFbz3w2dHwyKxcWL364wBMhJXkHPGD3hG2w1qytUSJHN36dG9xl+OhQLmZHSe6dr54g5KKc7vFASpLW8MQsA3FAaSKAUpc5Q83jz/GABVT+ha0ta/d5H+yWs53TXX062woBOGO3VccoEGvmVuC9B77N6dACCE7AwYAhJAdxHcf/GJ/eeHOlw6Ml+4BEC1nU2VtSeMPXnKWlVnrtbl5k5vaUULuLkvaP1BeUdxlDUpaAG1KJlK12lCseneOu8k/KBpRKkmaG9gotrU4gILFAeKEWzNbPwkdvoXiAIr2nosyO3z8q0z9J4TsIBgAEEJ2Fgevzrx+dHn1+n3teD7Yxq65TZIGy1mCejPdV9xlAdCYcG9Sqkhr7nLWusWqd/O+bSF5L7J0tOz0XBGLAaaZ0NalcGXSXfakFxYHSGEYwmRWDy9D2NTiAN0YIE5vGEI3BvC+pVG9tqCHl0AIITsJ5iMSQnYcH/r3/0tv5hUZH+kd+8+qCmlUYds8Uza9tBCIqAogdoaOKBptgUZUGxOkjQqgjXoavjTaKqTRpKklP1khaYOwqmiKG9RKAEBUpG2TW96oIlcHUEU+ziYloniyiRv+UjdLaS1JfYv4XWKbFyQfQwrbDVDdJciF0cpd9kYNr/O7UB5VXP7YxvpWemt98xHlk208VqpqNYde2RDy60Lfcps4S9UQ7MkKiFQD8XkrQ9PcpbqZTBuCDbma3vxIG4LEu8SnsdwloW/QOHVv3AwCkfGgxVghj3/1zTf93wFCCNlMuAJACNlx/O2Zz8r4iA5eH117n4hA/RR/NXGVTWdJLq/lYiet7ia0p3Jkn1jdXYbaqkIgGPMp27+p3GUJ51SKtpYEYkn80apHuLFq5jY8iwNEE936toeKA4xVRjJq0KP6J4TsQBgAEEJ2It+5/8vj0ZHh0rva5ROd0+vDwaAhGQNhRTOlxhQBqqYsSzNBUI2eVaJt1veI+eJFXkuUjyGXfTIJpGSZv3GzKoEnLBtAURUHcHXu4p7FAcrQqh+nDcFjAPHJLDlF+RtTYoDYt1srDqC6gvFI2n/4Kmt+EUJ2IgwACCE7lHZ0vNe8Mn79w6r9KO6T3JTwoyk/uAITsYwhFGfalaXr+24M4LnsQLGcXYBCAU2nAZUs86KzK5mef0x3xfWBcldlkLuar7PI/WDQyl3W0LdKknp/EWQ6SgCjPlEeA8Qh1KsNFhKYmtcwSywOUJYm7BO0K6qtYjCAjL0BIYTsMBgAEEJ2KH935oysHlp8y0ujSx+pc0XiATNmQoetn27xZ/vcRWrj+s+8edeabdaIIvU+WhOa1cpA1N7dJJBg1U+4yygHg3oMYKlBqJNzUh5LFQNUJnTlN7skdec7weIA21EcQGRw/c39HvrP/PbbJ77UhBCyI5AbNyGEkO3jTX/3P537wOpP/O8rsvB01uwQTUn4kJQGpNqolDwY9X8UqrFNygT3pA1RabRNuUQ510fRqEDbJkcSKqqNNuncINuLLNKqaN6xKtlWLptBq521k9thU0EzADmmABB3rGbi3uLUMXt4aGavg+2mBeLeYutbvbdY7eHobiMud0lW0tVeW3tjaZaUv2/kFXj8Fe6S0LeyIbieJZtAu1LtLZ42vRIfbrNUNvLa9FrfwmbfMr3qDcqHUjWbfqXaum3TG8b7+G++4+S3L1/46aM3/V0nhJCtgisAhJAdzbkPrL79r+ax+r52fBBZ9Jn53cDTXZKVKx3LGUVhIvm+IVEGotDW3WUJSSDZF8/ucotWRcyqFyRXvs4VKRkm2Q5357ib/IOwWFH6VnKKYFfCHlOwOMDUdPwqp8jM+2kbKsK3okz4xhcHaKHLg7v/w/kL/+TI1C8zIYTsEBgAEEJ2NnL22LN3tb2X29c/asKvI8uQJKNo1HwoklSDnE3JOcVAj9kvIRHcbk93iifwqAUeuTiAFi07PVfEOuDSs6P46+wR09YoyjL0rcQA3smynmFqnsUBYgxQK/78FutbiQE8Uqqix+nFASCoYgCfXtWmFemPDz22bCEKIYTsUBgAEEJ2Ot+9/2FdPSy9i+Or90FNWSJmt4tAxTL7tW3zNVjSkKa/7WoT2tSbTLrLOYm/LY52ekh1LKaZ6dE2jlc8IIlRASY2LQSDvDoY1Hcj5LYpBjDBXfYVIPxYctm12mtbrTZ4DGDjqqV8PBgU9f6EEgXVJw51YoAqHb+W6Z08+7hpoQy86lvZV+CzVPn03qWqWXfCESY8rDao1jFAHiTQ6Vu5y0KpsIsjdVXQH6NtRH/wb9+y3m82IYRsEwwACCG7gL898wVdOdSef6sOj1umeEnVEDP/xUWqy9y847MUBwAAtFBoo3kxoIEl8Ni/4Lqutur94dZCOmfVZ2Wppm6DVR8ladXMbXgWB4jrANa3XVIcYGVJ21Ye+513rPtLTQgh2wYDAELI7kCvH20OXcDln1BtAEVjST2I+rITA4SDc7JsbU1Zdh1cIMh00bybtZNBHrxkMX/dXO4JdzmK+6whXZ6+YbMqgafKZUdVHKA+GDT1LWS/5PFHqz4mTXUUf0xh0jBxU1YbbDJrg3zfFgdQVR32e4N2PFrnd5kQQrYZBgCEkN3B97/wsOiRq+OruPRBIAvNdBgMBGgVTXaXs39torsoy6KAzbzXIMqz2M1eck4kASq5mWMDqVcG8tE2dQxg/S4Gv/3oz6mua7dZiAHsXVJiABegMQYokjzEABqsehYH2ITiAE3b11YFzVNff+cbfYMJIWTHwACAELJrePShX1+8evJ7T3xsvPRmiErJjTFtbGJR0qk+lUiNuSIQV/yVsmyn2cZmQidbWlvRiRvXyGX3/hSZPuEumy/O4gAxMKinF90hVFZ9jAE0zJsL9/wJlhGVtSF7qd5qcQBRLF/u6Uie+CrVPyFk18AAgBCymzj32j1vuedJufZ+Gc/VuSJVuo5kPWfxgSeIi6m34jEHZWnaOl+MPnFeRrDIofLRgXwo0Fq5IpauU0RqpSxDDOC63Iz5EJCUGEAAVUFHkuYBlLsqNW9WfVemY/puhLIOEF4RYwCT5NNDrJJ3FJnSt6Ctfe0m/yNAeU5Mxw9qvsqGQhDuKJsWLBOp7Ej270k1S+F0qDTSyeObqgkXQNG2g/6B8WiF/2NKCNlN8O8sQsiu4uwnjs73MfPS6PUPA9Cc0++yrMoeyVa968scG9T54lmAZu9fuu5ysOq1NdVbooLYrMQA0dEvony3Fwew3Jyg0Yssrpt5h/N4wxCCTEdl1ZegIoyo2o1gCTwafxumNzeLOUUhBoh9q2KAaiXkpooDNDJYunK5GcgzZ98+9dtKCCE7EwYAhJBdxvc/+el2dKCZvaSLb6ukfLKNK99d0YZ0fPfvS66I3ahQsUTwZlJZmiGNYNW7ee/rAywOsGazPVgcQLV5/M8fXbqy+MRXmPxDCNllMAAghOw+/v7B32rag/3xe9t2PuuzRpDSfhpXigBUgk+c9b3J+o4JLdNyRVxZCmBZQHX2iMcAuRGLA+SBd2MAjen4tUzfhcUBVNHXmbt/7G0Xnj13019fQgjZbhgAEEJ2JY2eHPZe0tc/iKxrVez0HwjQqvqhQE3SomFjK5BFatsmy9n1YZUrkuq7priiorbqFbVPvP7iALUkrZq5Dc/iAHEdwPq23cUBeu1Mi9GRkyfwR6fX83UlhJAdBQMAQsiu5LunP92uLjSDS7r4NsBNawGQ034swQVAkwW3ZdQ0JhcbVbUSwggiNSDRqo/p+Gt5yVCstzhAkNclNphsBmBKOr79OwU/NlwWB4Cb9/USR5y39OO0IXgMED5VX6xANv/b3rgZC+Qff4vJP4SQXQkDAELIbuUfHvhKMz4ws/x2beeDeR8t26LmXcqals1pPZJEapN/jcbcZUk6fiJ7JOayt2sIUChYHCDN0h4sDtC0vRlF8/hvvWft7yYhhOxoGAAQQnYxvdGx4cx5XP4IBGhNphelCCkZJipuQptIlawsfbGgyieRdEVMTEu0jdPTfJmhBB6T+eL599WpNVUMwOIA1bwh9M2DuknFj+4QKqs+xgAa5s0TvfJuhDIi9Xmzl+q04gAympF2pE3vxt9OQgjZqTAAIITsYr575nPt6DAGF9vFtxf9HfPFm5CKoyraulUvtbtceckwCe1X/OckX9PFpuMu1/ni+6I4gFQxgEnysA5g0xtjgIopfSvbGKwn/o/YR1CpeURHv86GQjDvcbvFAWTc096oaeXJL70LhBCya2EAQAjZ3fzDA1/G6EBv6Z06XsgxgLhYNMtZEHKBJqx6l8vFNg7KErV5L6YVLUHFjOiSwLOfigPYhASNHiIxhFDBPzGLecIQgkxHZdWXoCKMqNqNYAk8Gn8bpjc3izlFIQaIfatigGolxA4FQjM/kAZP/NZ71/o2EkLIroABACFk19OMjrczr+DKR4pu66jStg2isCTwVHkm6gI0BQndXPYcG4Rcdne+i1Xv5n129H0dQIuWdcVfWfUWA0wzodMfqit131gcYAuKA/TbmWt3zMiAyT+EkF0PAwBCyK7n7z75iI4PY+Zie+0ddq2rLIvzDW2iVZ+apSq/DfIZ8CKuYkuuCNA174EqBsjuMkoMgHwfiwOkf7oxgMZ0/Fqm77DiAGjl8S/ft3zXwR987sfW/80khJCdCQMAQshe4LEHvijtoZnVH8doTrJwhwn34kZrOpwH6Qh+PwO+pKdL0YhidyWfuEVSvOK5QFp3obbq1ZP405NZHMAipapvIYGndHViJURDAo/UQyjLAptaHECa0fxdf/z8hY/dcdNfTUII2XkwACCE7BF64zuvvOlpXP1IEalN112WkCsiMc8+5phk2eriWC1yqBT/ZJ59NwaA1DHANhYHcHXu4p7FAcrQ6kWJKUOQ8cy1t8wcfuJ63BtOCCG7F/5dRgjZO5z8u//5wgeWfuz/WMHCs6pQNGktQJtGFVBREfPSm6Qx2yTtVQSNNtBWFI2KqjbZo06H+NjGXs3/NCnNvMhJlbwxQEUk2O9ZYdoVlXRSj1R3oexZELED6D3iEIsdcihjd2UVnNWq5p6k1QEzvEXzwyWLdb8L4fkAIHl1ROEjyn0IPZHSmdxMbAj532EICH1LVRG6s+QTmNKWNMwbwizFK/HhPmmTzTrTG/uGMG9heiX0zUckKmjlR1/86PG/fvXiP7nz1r+ahBCyk+AKACFk73DhA0t3/+Usrr4b4xl3cNV3/Qa7V9ECAFQaZBe6+L5qCUN5KUCmu8vBFy+J9fU+WrO0w8rA9Fx29b65Ve8Z/8H5tqUKTxnyrPo6OceGABYHKPsKrG+op9c+lLWKA/Tk4F3/8bmLHzu1zi8hIYTsfBgAEEL2EHL28JN3Yu6SXvmg7XMNOhtwZYkgLpuYK5LkcQkVkmHeyRWBi34puSJxc621QZ2OD4DFATonDpW8o8iUvpVtDNYT/0fsw6rUfGoWY4A4vesrDtCMZhf7lw4/tcTkH0LIXoIBACFkT/H4w5+BHuk1b9aVe5LUk5wMYnox5IKrlfsVk+mdfHFLGEHxpP2Ay3RX4+5ysOrhae8lKmBxAHvjGgFVGlsYQpDpqKz6ElSEEVW7ETTsK+gss1SbFt64OIC0vR/e+YOl/vUffJEn/xBC9hQMAAghe41GDo/xqly9D9rzsl8A0Liyzyo/pMfEtJZE3vVbbYcNPrF03WVlcQCE9RMNfSvePGIeztRmO6U4gCoGWLjryt0XD752w68cIYTsLhgAEEL2Go+dPo3VBQwu9K58KGaYlOwR8ZUBz8NJhwIppE1iVzzJZNKEbmMuu+nI6C7HGCC7yygxALKOZ3GA9E83BqjS8WuZvoXFAXrtzBCjo6vHcfr0LX8VCSFkZ8IAgBCyB/nBJz8jo4O6dAdWjmfnOOXYZEFph8JEjah20KdEgZit61AcoJPAgyJSo7ucqa169ST+9GQWB7BIqepbSOCRML2dlRANCTydzR5lWeBWiwNob9w/otL7xy/edyvfP0II2dkwACCE7FFGB3TuNVn6CaCN+eIqKePfctRTDGDKUvK+Xs+ocfMeqi3yiUBBpBatnJ7nVzwS6KTrsDiAxQBhiQM7rDhAr52X9po2c+v/uhFCyC6CAQAhZG/y+Kc+BRyV/ivN4nv9vJosj6fniuQ/SsxlL8qyWNHFXY75JKahuzFAahYlKYIAhSIdv19OAQpWPSqZnn+0u+rr2m0WYoAqD6nsfEDctKChb1UM4P1FkOko6wN1wpLaFE9fbbCQIIZY1pOJTQtVAo9b9XHCEbKDtGpW4gTT9/UyS903n6X0HRgOWh02LZ76/Dvf8CtGCCG7FQYAhJA9yw9+7TPN6ODMyrsxmks1wUTSVmBL4BFAW6ASgkjbA1zfm7JM8l5v4C4HMV0S61kcIIYx9UqIjxc7ozgAgNUDGDc//NIH1/MdI4SQ3QgDAELIXqY3PvH6Xc/qpQ9rSvHPe0kBiIqiLVZ9OtXHVaO4ANU2Gc0AggmNqDWNtZxvf6ndVfnowL4oDlDHAGXJICYsbX9xgGa4sHTgEsYza3+nCCFk18MAgBCyl/m7Bx9cPN48eea1/vK9imj3tkUR5hM/g6NvujwITVSKPwhracPp9V13mcUBqt0IYpPWXQmpm3mH83jDENJdm1UcQHs/OvWj5ZnlJ3/n/ev7fhFCyK6EAQAhZI9z6YNLd//lbO/ijwl6VZZ5oqNKXRRqmzSiVJYzSipOky63b+guK4sD5BH4QOJKCMpL7UOZ2myLigMMVg7ceeXUxQMXb+b7RQghuw8GAISQvY6cPfLEm0bzrzWXP5g2AHTS3IGQPVKyaAT5xE+z6utm2rYpCwcSMky05Nh03eUYA5Q3hH0FYm+Ie4uzo9/Za5v6rWUIcdMCgnkPFgeY0repxQGa8fwIwyPXj/Hgf0LInocBACFk7/OPjzyioyO6+JZm+WhJlbEzPYuydE9aVdPhPLAj+POO1ZL3IlVxAJQYwJ8fY4CK2qr3h6crYHEAi5SqvoUEHgnT21kJUYsKUs/jEMqywJTiANLK8PXZdtw88ZsfurXvGCGE7CIYABBC9gerR7DwYv/6B2GyVUK+uB0KJFmypmQZyxWpYwBANIvJEgOUhJP9WhxgmuKPKUxVOv7kaoNNZljiwBYWB2jGh5uFlXa5fwvfLEII2XUwACCE7At+9JnTPSyMe+d7194OICtmzxdP5n3ru2NNHFuGugSRKrWy7B6JU5L4XadKNwbYg8UBqvWBOmHJQqw1Vhu6KyH6RpsWqgQe2BJHnHCE7CCtmpU4waKg1ELGM9qs9vr9536PR38SQvYFDAAIIfuFH9z/eRktDK68S9q+WdcKLwDWZndZgGKTh1wRSQlB0ZjPXvLuKg4AV8DqUVAVAwSrvtj5fiOAPVUcQBW90UFo8+SXPrK+7xEhhOx6GAAQQvYRvZXj4wPn+1d/PCjLbkqJtQ1WfdaNbeMCFF13uVKWCOIYaznfassIdldsBmCzigMgvrTEAAKsvziA7p3iAIPxwliWm5YH/xNC9hEMAAgh+4jHP/1pkQP9/h3N6lGIoIG2LSRrTfO9O/kkWcsmg15Mpk9R/JWav/3iAHUMEB39Isq3qTjA9INBd19xAFEZLc9K2/zoy9z7SwjZRzAAIITsL5rmwAgXmsUPu/ZOeThZdkar3iVplR4zYdWnqMDFbn5OiAFusThAjAG0aNm4s7aIY+uAG+QdxQ+trrh5v7+LA/TGh2RmpR1x7y8hZH/BAIAQsr94/Jc/patH2v4rvcV3VCZ0yDDx7JGkg/MaQJMaqTTBqk+t3sCELrnsCAk8IV0HKKLcbq2PxdyRxQFsCLu3OIC0syqrTdN75reZ/U8I2V8wACCE7DuevP+zzehA//p7gGz91urbfOK2TXa4/SadP9PAQ4MUCeRr2bre7uIAdQxQNXMbfiOKA3g0gnq1pGPVl4SlSvGHKMgeEvpWrYSU5wPYyOIAM6MDgubJL/zUrXyHCCFkN8MAgBCyH2mGJ4Zzrwxefz+SZkbIFUmCMRrkMPu8Lg4grYZTawAE876IfhOpRSsD0aqP6fgTdnjcabC+4gCwt1guzRs3K2o+WPWwrCc14W4Bhnrf/K4cXUwtDuBXguKPKUwhHX/aaoNNZljiwAYVB2iGh0bNao97fwkh+xIGAISQ/cgPH3pIxweH7b3N8GCRpGI+emM/RXcZvg7gv833lax6E8cbUxzAhXu6su7iABO7EWL+vXbVfIgBqsigczBovKuKeOIM+JBrqx6WwFM327biACqNHoD2n/jiR2/1G0QIIbsYBgCEkH1Kq0eGK1dmr/rxLwqotrUJ7SI1J/kAArStqWmVmGdflDSLA9RWvU1XSFhCuCs0C0MoKyEbXRygGR+6dk9PQPufELJPYQBACNmnPP/AA6tXj//wBz/Wu36PXSvFASTvJQU8BgCSspR0To7JTbEtp1mkdk1oFEnq4hhrOd/lpSZbo48O7OTiANgdxQGknXn6N356+e4jT36BR38SQvYpDAAIIfuXi6+dvPPNT84tvi875fV5MqbmAfhG3naqo8/iAL7asNOLA7Rolg+f+k+Pv/7RN9/cd4UQQvYQDAAIIfuYs584OtdbnXu1f+V9+Ypasdg13GVxSVp89zqtpZNR003HZ3EAFF1exScecdlAqpksL7UljqnNblQcQA+0/eWDTyxaRhMhhOxHGAAQQvY1P/jkI2gP9vVt0s4gKWQXmuK5J22272HKsuSxpKZq24U7J1dOM6GVxQE8Hd/VvD15c4sD9AarB4H+U1/m0Z+EkH0NAwBCyH6nwdG2d27w+oeCJ+xuOnKODVQAbTyPpcQAyXK2I4PiqTVw65rFASqZrmF6t7A4QG/14Hiw3Btz7y8hZL/DAIAQst958vSZ3vjA3NyxZvVIuOwJPJoy9EuGiQJNyklXNEBbdu5OiwGCeV9Ev4nUopVTw9DArtXpOrXix9SDQW3LbLTqUQUkN2hW1Hyw6qHYzcUBRBudPQjpP/klHv1JCNnvMAAghBD0+/OXry7NXHl/dVVbAJrSezzPXtFxlyWsA8Ad7ZhVb+J4s4oDKCZiABtCyLPf58UBeuOjS/Ia+rT/CSGEAQAhhACP//Knli8ff+qH7+st35WuZMkNlXIkDgCTwZYkI26TazHmWRygxACxb6itevhMax23bHxxABkPnj764kozfOaRj9z8t4MQQvYaDAAIIQQALl284+S9P5q5dl9xmpNwbUpxgKy2k/5OtQKA4uiH5ByJVn16YNbZteJHEMdYy/kuL0WJDVDuZXGAzolDJe8o02sP33H90OtzV9f5ZSCEkL0NAwBCCAEAnP3E4fn+qH9usPiudMEVbGXVa5bgeU8wYg4PiwPAkvhhUcr2FwdoRgutLB9cPYzTp2/2S0EIIXsSBgCEEJJ56sFHZLQwuPIO0Z7EX/iROECSleLucna7TZLG83w6uex2L0oqDjyBh8UBSthTxSc2Ah9INZPlpbbEMaVZg3lB8/Rv/NzNfBcIIWQvwwCAEEIKvZVj7YHzs1fum/hNyfaRkGFScmzck3bnm8UByjk8ntVTpq5aCfEwBlHN25NvozhAb/VQKyuCwa1/JwghZM/BAIAQQgpPPfJwDwfn8PZmNNf9Xdm3iiJAEcpOhRhALZedxQFC0g6iRkfHqi8JS5XiD1GQPST07QbFAdA0zbxo7+nPffwmvwiEELKXYQBACCEVfRxbGZ2bufrjQCehHAIT5X4kTogBLEc9xgDA9BggmPdF9KvdpfHVk3n2E+k6teJncYA879pfPYJ2LEL7nxBCKhgAEEJIxQ9On5alg4NX34TRYaD470WQp/9vOiZ0O5nHskHFASZiABYHqOKTeiUkdxLSDhaGd/THs09/ltn/hBBSwQCAEEK69K4dHJ84P//6BzztR6rfu3WdBWhW342L1JLG46L8NooDpD+ppdzU6fhTmsHUfLXaEHKKpsYAe604QLNyZNh/fdAeuLnPnhBC9gEMAAghpMuPfvN0vzmwMDjRW74DXfUPIByJk4/7NP3tifLu6IfkHBYHqNW8JzVtfHEAGc7cIQd72jz2pQ/c+PMmhJB9BgMAQgiZwqC3sCTn5q/dl3PsO/ixM8WTzu61JfF7Dg+LA8CS+G26sOnFAZrxkXPD5w/IzM1+7oQQsh9gAEAIIVN47PRpGS6szrzSW7qnXI1p9G3rUjbsao3NTJLG83y2rDgAYgzgonwPFwcQn/CmnXnupT9bXLn8nc//5E1/8IQQsg9gAEAIIdN56sHPYjw3e/XHpvzOfXx3xxtUkhS+87d2vresOEDIw9kfxQHUY4DB8MTJE++5fPWZW//sCSFkT8MAgBBC1qS/enI4f25w9Z3hWtgNm34s+TxFkrI4QO5wiAE09C0k7YThV46+PWoyoPJAZVpxgGZ0YNy7dmj2Xpw9e2sfOiGE7HkYABBCyJo889CnZLzQX3k3PNV8yo4Al626Rgxg9vnmFQfo6Hu36ksMsE+KA2BWjwl6T//Gz9/cJ00IIfsJsmyLBwAAGOBJREFUBgCEEPJGNOMTo5mXBlffk6306a2yJBVYug5CAk+dx7IpxQHcqi9nEAXhnq7sg+IAvdHBUbPYx/z6P19CCNmHMAAghJA34rkHH2xGB2ZX3iXaZFUcRXNBBW0pDiAmg4tILWk8LspZHKDEALdfHEAxaI9Ae0/++sdv+mMmhJD9BAMAQgi5Af3x8VH/hdkrnd3AEv8oCoigicdimv5mcYCJIVQxQKXmfWfzTRcHGAyPqi72dG5dHyohhOxjGAAQQsgNeObMrzWj+Znr94r2pzaQpIYnj8TJCp7FATTEADYnHp+E1YbbKA4gC6vzvbb31K8z+58QQm4AAwBCCLkxveGR1blXJxYBgKh7Yb44iwNseXGA/srxpd7SYDxY90dKCCH7FwYAhBByY57+9BmMD8jSW0WDxCzp6ZGQ6xJigJJj49kv7nyzOEDJX/KsnjJ11UrIxKZqQNE2veUZbfv/+IVP3NrnSwgh+woGAIQQsi5kdBRzL89fua9cgalf/zkTFD/EhSyLA5RZsxhAQ98saaoOgXwyYwxQB1QzwyPjmdVm1Lu1T5YQQvYbDAAIIWRdvPCp0/3xwvzy3U076CrtKbhs1TViALPPN684QH5HTNepFf+eKA4g6MnqCcHM01/+pzf+FAkhhDAAIISQ9TMYHVqZe3Xm9Q+gOgNoLeoYwATzZhYHkG4MsA+KA/RWj41nLst44cYfCCGEEAAMAAghZP388OH7m/bA4d5dvXadm03duo4p75tXHCCIaQ1W/d4tDtCoCA5D+s984WfW+ykSQsi+hwEAIYTcBLPNoaXeudnF96/x+3JQZ6YcieP7XK1dEeX1zloWBwj3vnFxgMHKSZVFwezanxghhJAuDAAIIeQm+MHp0834wCHc3YxnLLEHgB3Sg4ncoMkjcbKCZ3EADTGAzYnHJ2G1Ye3iAKJyWNrBc5/h2f+EEHITMAAghJCbYxaHrsu5mcX7qquqa+4KmDwSBy6gc4vozZvmnrDqPaOmm45/e8UBqhjARfkuKA7QXzo5xhUI7X9CCLk5GAAQQsjN8YPTp5vhwuGVNzXtTL4U9s2uQch1CTFAPMsyP8Wd7y0rDlAeviOLA3g2VF0cQNCT8byMerT/CSHkZmEAQAghN83s+ODSzCtzV96XflzHiUCoFD/EhSyLA+QOhxhAQ99CllSMnXRm9YT2r1d12QghhKwPBgCEEHLTPPHQ/c144dDqXc14MCXvf00sBtjG4gAdfe9WfYkBdkNxgFZ0dUF08PznefY/IYTcNAwACCHkVpgdH1qcPTd39X3V1RtHAnUM4Cf9bGJxgDoGcKu+c6JoWZ3QnV8cYDC6o+1fx5j2PyGE3AoMAAgh5FZ44qH70S4MxneJ9m/yVkU5EsezXzavOED6k1rKTZ2OP6UZTM1Xqw31waCTMcDWFQeACpaPiM7Q/ieEkFuDAQAhhNwiPT007J2bv/zem76TxQHgUUFpJtViRRlAiQEEAHqrJzBzBaO5m552QgghABgAEELILfP8Aw/0hvOzK/eIVn+XdmuBTTJ5JE5W8CwOoCEGsDnx+EQVkIPtyT5mXvgffnFdHxIhhJAJGAAQQsit0x8fXp57ee7aewE7jwc3lP8AzBffscUBEGMAF+XbXxxgsHx8qXdxRhfWNcmEEEKmwQCAEEJunWcfflDahcH1e5OWF9/aui5CrkuIAUqOjWe/hJP1J4oDlGYbWRwg9G0nFQdAvz2KtvfEr/Psf0IIuXUYABBCyG3RGx4Zzr00t/iO9cr+iqD4MfVg0BIDrFEcICwg7PXiAL3h0WHvSqPM/ieEkNuCAQAhhNwWLz70YG88v7D0rlt9gMUA21gcIL8jpuvUij8VB4hJ/G986n+VsLR2MwU6fbMYYGpxgP7KSWn7z/76P7vVqSaEEAIwACCEkNtnMDq+NPf87PW33uoD6hjAT/rZxOIA0o0B1lMcAJMFwmwEUw4GRYgBfG9A+dFCgvUWB+iPjoxnLjVjZv8TQsjtwgCAEEJul+c++cDq3TJ77Z3A+jcAdFBsaXGAsJF3lxQH6K+cEO09/zna/4QQcrswACCEkA2gPTDz0pmnBit33fojWBwAHhWUZikU6A0XxoPXaf8TQsiGwACAEEI2gKsfvHTsL04cuPbuW38EiwP4REwUB5gd3jk/OvT8r/+LW59eQgghBgMAQgjZCOTs/PlTevBkf/UIopq9KVgcwPoWo6BmPHdy9dRMe/CW5pQQQkgXBgCEELJBzCwMV15eWHzfemuBTWfiSJy4QXa9xQHgzfZAcYDB8psuNS8vjA/cxqwSQggpMAAghJCN4aVf+iVZmR8NTzaj+VvdCpyYOBInXbmJ4gDVWZy7uzhAOzO32G/H8p3P/+TtzCkhhBCHAQAhhGwYbbugM+fmrr7vtp80cSRONwYw+3zzigN09P1axQG6B4NucHGAwcqdKweW+6v8XytCCNkw+FcqIYRsGBce+pXeeH4wvlO0f9sPq2OArS8O4Fb9GxcHUEzEADaC2y4OIG0zOzoCmf3Rb/53tz2fhBBCMgwACCFkI+npweHg5YUr79mIh2k4Emc/FgcYDO9cHVzqt3MbMZmEEEIyDAAIIWQjefnM6d5ofmbl3lsuCVaxn4sDQAarR0T7T3/2n27ATBJCCDEYABBCyAbTGx9Znnt+fvHtG/CsfVwcoD88MRxc6o1p/xNCyAbDAIAQQjaYlx76teHdMnv9rRvzuB1eHKCKATayOMBg5fjSW649y+JfhBCy0TAAIISQjUcP9s998smZ5Ts26nnATi0OUB6+kcUBeqNDzz/yX8eH2w2aQEIIIQUGAIQQsvEsfvDSkW8cm11898Y9Mij+fVAcYGb11Mk/efuVj7y0cRNICCEkwwCAEEI2ATk798KpweKdzWhh4x5qMcBeLw4gOttvjy68fApyduNmjxBCSIYBACGEbAq91YOrB19YWNyQ80CdOgbYiuIAdQywJcUBZpfeNOpdbJTbfwkhZFNgAEAIIZvCS5//pV47O3PtLtGN/ZtWsaXFAdKffJPxphcHEJXZ9ljTDp555BMbOm+EEEIyDAAIIWSz6A0PrRx4Ye7qOzf4uXu6OMBg+U3L/Qt9nd/gSSOEEGIwACCEkM3ipc/8atPOzq+8dYOfu6eLA/RGx7TtP/XIP9/gSSOEEGIwACCEkE1kMD66PPfs7NJdG/zcPVocYLB6bDzzWtPS/ieEkE2EAQAhhGwiL33ywX57eP762zbh2SFd59aLA5RmO6E4wGD1VCODFx/5l5swXYQQQjIMAAghZHPpt4f6/SMbeh6oExT/LRYHCAsI210cQNo5zA8bndmEiSKEEFJgAEAIIZtL08yt4NX5DT4P1KkPBp0SA9gKwOYVB8jvCDHA1OIAfmWN4gBzS3e3q0MMWP2XEEI2FwYAhBCyubxw+nSzujC3dFc8XmdDqWOArS8OYI+7QXGAKQXCbAQCtDK7cqS3uvDC6dObM0uEEEIyDAAIIWTT6Y8OLS08O7/4tk17g2KXFwcYrLxpefZCf8ziX4QQsukwACCEkE3nxU//6rwenll66ya+Y5cXB5hdPbH81qWnP/ffbuIUEUIIAcAAgBBCtoZBe/DEzFx/9dhmvWA3Fwforx56/tOPjg8z+58QQrYCBgCEELIVLPT6r+vF+cV3b+I7dm1xgMHKPcf+n3uvfPjcJk4OIYQQgwEAIYRsBY+dPq3DA3PDU6L9zXxPSNe59eIA8GZbUBxAxv32+uHZF++AnN3MmSGEEJJhAEAIIVtEvz2wNPfc/OI7N/k9t18cIMYAm14cYHbpbiyc1+HsJk8LIYSQDAMAQgjZIp5/+JdX79a56/ds/qt2U3GAwfhED4NXvvDfbPKcEEIIyTAAIISQrUMP9l566EeDlRNb8CrEGGCnFgcYrJ5cnXmlp5tRJpkQQsh0GAAQQsjWcfVDF4998/D89Xdtydt2QXGA+ZU3NaMDz3/6l7ZkQgghhAAMAAghZEuRswsvnTywckK0tyWv29HFAWQ80NVDvTHtf0II2VIYABBCyJYyM164Ovfc7NV3bMXLdnZxgNmle0azr2LM7b+EELKlMAAghJAt5elP/euVy3fMLb95i963g4sD9Icnmnbwwmf/xZZMBCGEkAwDAEII2Wp06fC5J9/cXz26ZS8EdlxxgMHK8dW5l5uW+T+EELLVMAAghJCtZvHS4SNveXL+2tZsBU7suOIAsyt399uDLzzyr7ZqBgghhGQYABBCyJZz9hPzg8Hs9VNxF+3ms4OKA0g76ONorz24NSMnhBASYQBACCHbQH94YOngM/PX37q1r90pxQFmlu5Zac41mNva4RNCCAEYABBCyLbwwmf+dV8PzV57y5a/eUcUB5hbOdmMB88+xO2/hBCyDTAAIISQ7aHXHuzPLDSj+a1+8XYXB+itHFqaf7HP4/8JIWSbYABACCHbQ9MbrODcwrV3bvWLt7s4wMzqm5vxgece+e+3cMyEEEIKDAAIIWR7eOH06d5obm75rm1493YWB2hmh8d6Y27/JYSQbYMBACGEbBv90aFrC08PVu7YjpdvT3GAwdKblmdf7LdbnvhECCHEYABACCHbxgsPP9BrD80vvn2b3r8NxQFmVk7J8vxzn/6X2zRkQggh6G93BwghZF/THx1pZEHQKNrteH8600dFABVLBBKVJPglHRqUj/gUiOYYIP2gClEpsUO6kh8jFjmk8z8FgmY8aK7MymxvO0ZKCCEkwxUAQgjZThpZWBk8M7f4tu3rwuYVB9BOcYCZ5TcPj7wmK/SeCCFkO2EAQAgh28lLD/zrZvXI3PI929qLLSoOMLN8x+pbhy9++Ze3a5yEEELAAIAQQrad3vhAOz7SjGe2sxObXxygt3roxU/9/+3dW48UZ34H4Dp1VVcfBhuGgwHjOFptNk4iJytFSi59u8pq5RPeXYwxq1xF+RB8k2i18k20+Qi58H2UK8eJ1yfWwIBZ21mYme7p7jrkghkMeAwYM/NWk+e5GCE0dP3qBvWv3rfe/3v1eN9vDYC7KQAAgbVtvyou9Sc/CBtir4cD5NOTT/37ofW/vr7ftwbA3RQAgMA+f+uVfLFaTEIMBLjTng4HiKKiWi3XVqP4wn7dDwC7UwAAwkurcVEfTxfB98fs1XCA3uzItP9Z1gxC3BQAd1EAAMLL2vGk/7ty409DB4n2aDhAf+tYVg8uvf2zgDcGwC0KAEB4F8+/FNdJEWYk8DfdfTDoLh1gZwXgroNBv9kBbo8ZiIrFSlYNA90OAHdRAAA6IauHk9Gnvdlq6CC3PM7hAPnkmc3yUtYUge4FgLsoAACdcOXcL9NqXE6fDx3ktsc2HKBYHI1mw4vnXw55NwDsMI4RoCuyaiWtytAp7hBvf7vffrS//dZv1Ma3Hvrv/O32uN9bKwXtrfeCdxYM4rhJ6hvDpJgHvhcAdlgBAOiKtCqnw0/yaejzQG97HMMBiumz9YGr7SzomDMA7qAAAHTFlXNvpPVKufVs6CB3+N7DAYqt1aw5cP2fXguRHoBd2AIE0CFZPU6a4c7umo64/R5wtLMOEN063Cfe2f8TRdH2H+L4601AbZS0vaZaTZJJuPAA3MsKAECHJM1wWn6UT4+HDnKPRxwO0N98rhr8vjX/C6BLFACADrny5qvJfFxOu7QLaNujDAfIq6O9ZnTtVz8JFxuAe9kCBNAtaTWOq0HHdgHdsj3WK7512M/2aZ/x9qFA8fY7ATsdIErrIovGTTsLmhmAe1kBAOiWuBrMRh8XkxOhg+zqOwwH6G2cmma/TyLzvwC6RQEA6JZr51/NmnHRqbOA7hTHUXy7A7Q74353OkAU7XSAuL9YjZvxZ2f+IWBYAL7JFiCAzkmbURKVndwFFN3e8d+2bXz7CKC7BoRFURQlTa8pDqWV838AOscKAEDnJFE5zTu7C+ihhgMUk+eq6JM2c/4PQOcoAACds/aL19L5KJ92tQBE0dd7/bd/ttGdR4XGcT5ZzebltdPO/wHoHFuAALoorUZp09VdQNvar8eBfZ0zbuM2qbM0Kpt6ETggALuxAgDQRWlTTocfF9NjoYPc3+7DAfKtZ7f6V5KoFzoeALtQAAC6aO3c6awaFbOToYM80N0dII6iqC0nx3tbK5fPnQ6dDYBd2AIE0FFpNU4WZfRU6BwP1ka3Dwdq4zjKihvDqpiHTgXA7qwAAHRUsign4496s8OhgzyEO4YDFJsn1g9dzGZ56EwA7E4BAOiotfNvpNUw3+jqRLA73Xr+H0dt2/ZmR+N29Ok/vxo6EwC7UwAAuqs6nvarQ6FTPJyd4QDp/GBSD0OnAeBbKQAA3dWsRFfOfpAtDoQO8pDaYuvY1ujDpC5DJwHgWykAAN21/uKXK++W/clzoYM8rHzrZFYPr75t/w9AdykAAB0WX8ivHM9mS7ILKIry2VOL43HoFADcjwIA0GlxU87jQ0ldhA7yYOli5crZD+pxZ0cXAxBFCgBAx9XxoM0/zDdPhQ7yYOXk1Pjd/vqLX4YOAsD9KAAAnfbVmz/J67K/OBo6yINli8Ojy8ei+ELoIADcj0nAAF2XNYO0zeMoaaMmdJZvlTRFfz6qUgOAAbrOCgBA16VtvlF+2pscDx3kfvqTUxvDi1ltADBA1ykAAF332Zunk8WoPzsROsj99GZHkmp48fzLoYMA8AC2AAEsgaweJU0/dIr7SRfjJpmFTgHAg1kBAFgCSdOfDD/I5h0dCZxvHZ6MPkyaJTirFAAFAGAJrJ19I637/emzoYPsrrd1IqkHa+dOhw4CwIPZAgSwHNLFatamoVPsLlscjNIqdAoAHooCALAc4qact3ncZm3cra/aSZP38ryuO1pOALiHLUAAy6Fu86r8uJh07iyg/vTUNL2UpgoAwHJQAACWwxdnX80Wo3x+JHSQe/VmR9L56PJpLwAALAcFAGBpLE60yexQ6BT3ymYH0moQOgUAD0sBAFga9Up07a33s0WHDgPtzZ6ejP8nqTs9owCAOykAAEtj48U/rLzbLyYdOgy0Pz2Z1v0rb78eOggAD0sBAFge8YXR5SP5YjV0jq/1qoNF3aE8ADyQAgCwTNKmLOeDKIpDB7kl7qfjtLX/B2CZKAAAy6RX926MP8wnx0IHiaIoyifHbuQfZEkROggA34ECALBMPjn/WlyVxbwbBWB2LFqUn/z8ldBBAPgOTAIGWDL54mDUduLxTVo93UZ16BQAfDcKAMCSSesibfOkyZtkHjBG3GZRM4jjRcAMADyCTjxDAuDhpW2+Mfq4mJ4IG6OYnJiXH0VtL2wMAL4rBQBgyVw8/3JSD3rzwIdv9rYOp/Xg87e8AACwZGwBAlg+8xuro2EbNkPWPN2mTdgMADwCKwAAy6eZDS5/dCStBqECJHUeHxjFiQkAAMtHAQBYPje/Go6ff7+YnAoVoJicmi0+ivt5qAAAPDIFAGAJXXipn5e92eFQ18+3jvTmw7Wf/jRUAAAemQIAsJTiZtAmB5M6wDP4uM2G2cGsGe7/pQH4/hQAgOUUl3V2abDxw/2/crnxw/Xkcp6U+39pAL4/BQBgKV3/5c/Sut9bnEyafV0EiNu0v34qXpSf/NwBoABLSQEAWFZps1Jn1wfrL+znRQc3/2JRXsvmB/bzogA8RgoAwLK6euZ0bzFc2TyeLPZpO35a9VemJ3v1aO386f25IgCPnQIAsMSKxXizvPbUjb+L9+P/8/jAV38/Ka4W1creXwuAvRKHDgDA93L8nXc2qptFr10/9B97eqHxVz9OszrZOrh29uyeXgiAPWUFAGC5rZ05U9089Iff/flg/c/27irl+g8Op0eKesW3f4BlpwAALL3Jl4dXT1491jw/uvGXe/H5g/UflcVf3Uynw8TZ/wBLTwEAWH4XXjqykl0/ee2L12+O//g3j/ezR//74lfv/e3GF5MmP/j+ae/+Aiw97wAAPCnaC4P/KtMv69HlZ9dX/rPKb3zPz0sX4wM3frxerdfrq5MvjkYXXnosMQEISwEAeKI8885vqvRGMTuyVV7eXPnvNq4f4UPiNhncfGHl5nOT4dW0Ga+dOffYcwIQigIA8KQ5+et/rbKbTTYZbh3fyK9vrrzfZJOH/LdJXQzWf5RvHl+UV3vVsJg99ek/vrqnaQHYZwoAwJPp+V//dp5uzrPNdnE0i9fnxfV5ea3q/XHXX84WB/KtZ3pbh3v1cJZ/nlTDdDFe+9Xr+5wZgH2gAAA8yVZ/829JNGvSadP7ok1mB26+UGVVk8zaqGnaKI2TpM7jqFgfvRc3eT47lNRl2uaXz3nZF+CJpQAA/H/xJ//y2yZpmrhukkUT1VEUxW2aRL24TeMou/TWK6EDAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsNT+D4anIGJ6MOAyAAAAAElFTkSuQmCC" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></svg>"; + const menuIconURI = blockIconURI; + const actualModels = ["gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think"]; + const displayModels = ["Gemini 2.5 - Flash Lite", "Gemini 2.5 - Flash", "Gemini 2.5 - Pro", "Gemini 3 - Flash (Preview)", "Gemini 3 - Pro (Preview)", "Gemini 3 - Deep Thinking"]; + class Gemini { + getInfo() { + return { + id: "gemini", + name: Scratch.translate("Gemini"), + color1: "#0086c9", + menuIconURI, + blockIconURI, + blocks: [ + { + opcode: "generate", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "generate from [contents] and temperature of [temp]" + ), + arguments: { + contents: { + type: Scratch.ArgumentType.STRING, + defaultValue: "Tell me about Gemini.", + }, + temp: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: 1, + }, + }, + }, + { + opcode: "getKey", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "current API key" + ), + }, + { + opcode: "getModel", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "selected model" + ), + }, + { + opcode: "setKey", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set API key to [key]"), + arguments: { + key: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setInstruction", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate({ + default: "set personality to [personality]", + }), + arguments: { + personality: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setModel", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate({ + default: "use model [model]", + }), + arguments: { + model: { + type: Scratch.ArgumentType.STRING, + menu: "models", + }, + }, + }, + ], + menus: { + models: displayModels + }, + }; + } + async generate(args) { + const response = await ai.models.generateContent({ + model: getActualModel(modelChoice), + contents: Scratch.Cast.toString(args.contents), + config: { + systemInstruction: instruction, + temperature: Scratch.Cast.toFloat(args.temp), + }, + }); + return response.text; + } + setKey(args) { + key = Scratch.Cast.toString(args.key); + ai = new GoogleGenAI({ apiKey: key }); + } + setInstruction(args) { + instruction = Scratch.cast.toString(args.personality); + } + setModel(args) { + modelChoice = Scratch.Cast.toString(args.model); + } + getKey(args) { + return key; + } + getModel(args) { + return modelChoice; + } + getActualModel(display){ + return actualModels[displayModels.indexOf(display)]; + } } - } - Scratch.extensions.register(new smolderdevGeminiAPI()); + Scratch.extensions.register(new Gemini()); })(Scratch); From c97f9d3046adbde635e9d0a3018c45d05edfb227 Mon Sep 17 00:00:00 2001 From: Smolder Date: Sun, 28 Dec 2025 23:13:25 -0700 Subject: [PATCH 17/20] Update Gemini.js --- extension-code/Gemini.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/extension-code/Gemini.js b/extension-code/Gemini.js index 177dd18f..980084b1 100644 --- a/extension-code/Gemini.js +++ b/extension-code/Gemini.js @@ -2,7 +2,7 @@ // ID: gemini // Description: Gemini API Requests with Customization // By: cs3203402 -// License: ARR +// License: MIT // Version V.1.0.0 @@ -30,7 +30,7 @@ opcode: "generate", blockType: Scratch.BlockType.REPORTER, text: Scratch.translate( - "generate from [contents] and temperature of [temp]" + "generate from [contents] and creativity (0-2) of [temp]" ), arguments: { contents: { From af7087d2fb5acb279f42dedd3f6cf2291a08fc6b Mon Sep 17 00:00:00 2001 From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com> Date: Mon, 29 Dec 2025 14:03:53 -0800 Subject: [PATCH 18/20] format and optimize code --- extension-code/Gemini.js | 268 ++++++++++++++++++++------------------- 1 file changed, 141 insertions(+), 127 deletions(-) diff --git a/extension-code/Gemini.js b/extension-code/Gemini.js index 980084b1..c122b1cf 100644 --- a/extension-code/Gemini.js +++ b/extension-code/Gemini.js @@ -1,135 +1,149 @@ -// Name: Gemini -// ID: gemini +// Name: Gemini API +// ID: smolderdevGeminiAPI // Description: Gemini API Requests with Customization // By: cs3203402 // License: MIT // Version V.1.0.0 -(async function (Scratch) { - "use strict"; - const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") - let ai = new GoogleGenAI({apiKey: ""}); - let instruction = ""; - let key = "No API key has been set."; - let modelChoice = "Gemini 2.5 - Flash"; - const blockIconURI = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" zoomAndPan="magnify" viewBox="0 0 384 383.999986" height="512" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><filter x="0%" y="0%" width="100%" height="100%" id="fdc29b5ee1"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/></filter><filter x="0%" y="0%" width="100%" height="100%" id="c4b48f47d3"><feColorMatrix values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0.2126 0.7152 0.0722 0 0" color-interpolation-filters="sRGB"/></filter><mask id="2eb4ea65bb"><g filter="url(#fdc29b5ee1)"><g filter="url(#c4b48f47d3)" transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,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" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></mask></defs><g mask="url(#2eb4ea65bb)"><g transform="matrix(0.375, 0, 0, 0.375, 0.0000072, 0)"><image x="0" y="0" width="1024" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAIAAADwf7zUAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeZAk93XY+ffLvrv67rlncAzuiwRBUhIlShYty3KEN7yxsbF0xG5YFkmAAASRkrinrQ2ve3VSpEzQAEFgABAgwMMSZEm+JIW8YYEKSZZMUSRAXCSuGWAGc3d3dXVXVdeVv/0j85f5+2VlHd1d3VXV/f0EDQ9zurMys5LC+71876UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADANlHdPgAAwM557K7HlNZKfE+0iK4NKt9TekTd8/l7un1oAIAdwgIAAHa5L995YqRWyFQLh9bPj9TK35x/v+f7g15NRCraq02qD5z525IeOTd2KD+YWR8c/djj93b7kAEA24gFAADsTg/d98x4OTdXWty3fvG1qRumK4uHCxePF96aqeQSP5kdnDyVueqd0cPZ0Zlbsy8vDe+7PDJfGJq959H/pStHDgDYViwAAGC3WVh49uDimfnC0qWRw/vyZ27Lvnxd4WSbv3t29NB3pm+5NH78ytrpQmaqNjf/jxf+8bYeLQBgh7EAAIBd5UsfOzEyWH39yC23v/bfPrD8N3OV7CZ2kh2a+uu595euuz7zzlsXqpMfe5KiIADYPVgAAMDu8W9/+jfnytmTmavfn/32Tauvb3Fvp8av+Mu5D1xTOJkdnvkfvvLPO3KEAICuYwEAALvE7/+TXztUunR29PBPXfzGiF/uyD7L3tB/OfDjRwtnl4Zm/8Fv/3JH9gkA6C4WAACwG/zn//n/mS0vnR47/A8vPqu07uzOvzH/wQOlS4vD8z/5O7/a2T0DAHae1+0DAABs1e/+k8/OlLPLw3P/3YU/7Xj0LyIfWvzLxeH5mWr2D/7pr3d85wCAHcYCAAD62xMffWS+svTW2BU/fvkvt+9Tfmzpr05njsyXlr/6sS9s36cAAHYACwAA6GMn7v76/vLyqfGr/sHlZ7f7s37qwp+9nblqf3n5qXuf2u7PAgBsHxYAANDHJstLZzNX/f1Lz47UStv9WYN+9Scu/Nn5iSszpeXt/iwAwPZhAQAA/erJu5+cqWSPrL1+oHR5Zz5xvrx0IHdyopQ78dEnduYTAQAdxwIAAPrVVGn5QuboB5e+uZMf+sGlb741cmyusrSTHwoA6CAWAADQlx6/8/FMZfWK1TczteJOfu5IrXR94fVpP08nAAD0KRYAANCXhmvrZ8aOvif7/M5/9HtXnj83dfVQeW3nPxoAsHWD3T4AAMBmZGqFEb80Wc3v/EeP1dYz+fND0vkXDgAAdgBPAACg/ywsLIx6F4+sn+/WARwrnpssL5+4+0S3DgAAsGksAACg/0xnJ/7m+MQNa6936wBuWH39telrBmt+tw4AALBpLAAAoP9MlGpXvnVoppLr1gFk/OJopTq6/S8fAAB0HD0AANB/jqyUfW+xu8ewb33Rk1p3jwEAsAk8AQCAPvPQfc9M+IWjxXPdPYxj62enqmuP3fVYdw8DALBRLAAAoM+MVNdenLvjmvzJ7h7GtfmTL0/fNORXunsYAICNogQIAPrMWKUwWl0bq6139zCGdHW8Whj0q909DADARrEAAIA+c6B4vtYb/9f7YPEybQAA0HcoAQKAfvLYXY9NVteuWn+72wciInLF+umJWp42AADoLywAAKCfjPilF2ZuvbpwutsHIiJyVfHM8zO3jTAMFAD6Sk88RAYAtGm8WhgZKHu6J97ApbSeruQGaAMAgL7CEwAA6CeH1i8czF/o9lHEDhXPj3qVhYVnu30gAIB2sQAAgL7xxEcfGa8Ur+v2AFDbjauv/c3xD87kLnX7QAAA7WIBAAB9Y7yWf27m3fvLXX4HsG2munr8zCsT66vdPhAAQLvoAQCAvjFVXc34+W4fRdJ8YWmwwOvAAKBv8AQAAPrDU/c+NVNbu7LwTrcPJOmq4luT5bUTP/Plbh8IAKAtLAAAoD8MVIqvzb7ruvypbh9I0nX5Uy9m3jUqxW4fCACgLZQAAUB/GKvmK5X1wd6buelpf0aWvRqvBAaA/sATAADoDwcL5w6VznX7KNIdWj8/NnhxYWGh2wcCAGiNBQAA9IEn73ok4xd6agCo7YbV17919fjsSqbbBwIAaI0FAAD0gfFK/rnZd+8v9dAAUNtcJXvN6QMT61QBAUAfoAcAAPrAdCWXqfbcAFDbvsLlwULP9ScAAOrxBAAAet3Ddz4+Wc4dz7/d7QNp5njh1EQl99DHH+32gQAAWmABAAC9LlMrfHf61mt6bwCo7Xjx7e/M3jJZLXT7QAAALVACBAC9brKyNlEreKK7fSDNKK2Pri9qTRsAAPQ6ngAAQE97/M7H5yorxwo9OgDUdqR4dra69vC9T3f7QAAAzbAAAICeNuiXX5u8/sa117p9IK3dtPbGKzO3jFR4JTAA9DRKgACgp2Wq+bJXHvVL3T6Q1kZqpeni8oBQBQQAPY0nAADQuxYWFkYGLh9d74P6n8CR4tlxWV9YeLbbBwIAaIgFAAD0rrns+LevHrth7c1uH0i7bl579W+P//Bc9lK3DwQA0BAlQADQuybXq3On9s+Xl7p9IO2aqeSuO/VyZXS42wcCAGiIBQAA9K6rl9cqar3bR7ExB8oXhouVbh8FAKAhSoAAoEc9eecXJ6u56/NvdPtANuam3KsT1dUnPvpItw8EAJCOBQAA9KhMpfDCzC1H1s93+0A25mDp0nenbpuorXX7QAAA6SgBAoAeNVPJZqqFbh/FZhwqXxisUQUEAD2KJwAA0Isev/OR6Uru+rXXu30gm3H96uvT1dzjd1IFBAC9iAUAAPSiTDX/wvQtVxXf6faBbMaVxbMvTN8yXunLxxcAsOtRAgQAvWi6kpuo5bt9FJu3v7g4pKkCAoBexBMAAOg5D3380elK7pq1t7t9IJt3feHNmerKY3c91u0DAQAksQAAgJ4zWck/N3PztYVT3T6Qzbum8NZL07dkqn38EAMAditKgACg58yWc5OVgtK62weyeUrrg+sXB/1qtw8EAJDEEwAA6C2P3fXYXGXlhvzJbh/IVl27enK2nP3Sx050+0AAAA4WAADQWyaqqy9P93f9T+C6wsmXp27K8EYwAOgxlAABQG+ZKa9MVNf6uv4ncqB8YahGFRAA9BaeAABAD/nSx07MlrPXr/Z9/U/g+tWT05XcYx9hFhAA9BAWAADQQzLV/EtTtxwv9PEAUNvxwtsvTtw6UVvt9oEAAGKUAAFAD5ktZyequ+oFuocr5wZrtW4fBQAgxhMAAOgVT9712Ex15ca173f7QDpGK3X92pszleyTH3mk28cCAAixAACAXpEp516eue3K4tluH0hnaKVE5MrCO69M3swsIADoHSwAAKBXzJaXD+Tf6fZRdIBWSiulRWktouRA5YI3uLKwsNDt4wIAiLAAAIAe8dRHH5opZ29ZfbXbB7JVQeJfaxGtRSkRuWnl1RevGpjNZrp9aAAAERYAANAjpiq5l6dvPlK60O0D2Tw38a8k+LOoQ5XL1751YHK90u0DBACIsAAAgF5w4u4TY37xWKFf63+C0F/cxL8WJeaBwIH1s4dWaw/d90x3jxMAICwAAKAXDFcrb00cfdfqy90+kM3QJtxPJP7DBwJatJZ3r7xycvrG0QovBACA7uM9AADQfZPVfKk2Mt1v8XEU+ovWSgX/VWkRUUqLiCitdfBjE7X8TOEc/8oBgF7AEwAA6LKn7n1qvpzru7f/mpofFdT86OAhQFAOJKK1aK1NaZASUccK5+YqS4998qvdPnAA2OtYAABAlw1X1t6eueHW3Pe6fSDtSkz5jGp+JAj3dVgLpJVSosRsv2X1e6fmrh8p5bt9+ACw1/E8FgC6bLK8Uq7kR/1Stw+kLXGzr6Q0+wbbgz+LeSAgWrTIsC5PrV4almrXDh0AICI8AQCA7nro449OlZaOr53s9oG01mjKp2n2TU/8B9F/8Ofj+bem17Mn7n6626cCAHsaCwAA6Kbp8toL0zfctPZ6tw+kmZZTPqPEf9j7G/yKFq0l7goQdd3qG69N3Zgp57p4LgAAFgAA0DULCwvDA8tX5s972u/2sTTUzpRPu9m3PvEvpkNARA7m3xkcXFpYWOjuSQHAXsYCAAC6Zi47/vKVA+/OvdLtA0ln1/woEbFC+TCs1+GPiYiYBwL1iX/zQECLyI35V793zJ9emejeaQHAXscCAAC6Zma9dP1b+w6VLnb7QFJsdMqnbpz4D39flCh1oLR45enDU+uVLp8eAOxhLAAAoDsevvfpwyuVK3pv/P/mpnyKVQsUrxaid4FZDwSOFd45mKs+fC+twADQHSwAAKA7MpW116evuy37crcPxNGk2TdM/Ldq9nUS/yJilwyJElE35b53evKqkcp6104SAPY23gMAAN0xU85OVNYyfrHbBxKKmn0bzPlRweB/LaJEhXU+InHNj4hE24P8f7wkMLsSJaJH/fJUMTusyzt/jgAA4QkAAHTFlz52Yn598drVN7t9ICLxlE+1xSmf0XYliVWBCtcGwRpCqasLp6YruUfueao7JwwAexsLAADogsnK6vcmb7gx3/3x/9aUT73FKZ+m2dfqIpDoDxJOAlVKK3VN/u03p67NVFa7e+4AsDexAACAnfbkR56cqBaOFM+FczS7ZDumfLqdACJWE7BSceGQJ/pg8dzUQOmZhWe6ceoAsKexAACAnTYg6xdGrrh95YUuHsM2TfmMtqcm/rVSWiutRSu5ceXV0tErKiuFLl4EANibaAIGgJ02VckVhkrzlWxXPt1t9hVTox819SrdutnXaurVOuoKSN0eJ/518FnhzmerucLpy5PDtZ2/AgCwx/EEAAB21EMff3S6unR9l9p/d2DKZ7xCSCT+RbSSqDdAlLoyf3p0ZfnBj/FCAADYUSwAAGBHzZTXXp669rbVV3b4c93Xe9U3+zZ+vZdIfW2POM2+1mu/JBwB6iT+racK8WMBLdevvvnm6NUTNVqBAWBHsQAAgJ2zsPDs8IB/fO28p/0d+9Cdn/LZPPEvEm73lD5cPjczSCswAOwoFgAAsHPmshdeuvJ971p9acc+sStTPnWY+JfUxL9IvP3G/BuVK45VVngrMADsHJqAAWDnzBUW57MXDpQu78Bn2c2+SokJ5a3MfZD5d6d8hqF/oqlXJZt93Smfbs2PpNf8BO0Fie0z1VzhdHZiuLIDFwQAEOAJAADskIfvffxI7vR1azvR/tv1KZ9hq4AoUao+8W+tH+RI/vRoLnvi7q/uwGUBAAgLAADYMdOl3Pdnrrtt9Xvb+ilus69ENT+mtqdxs69Oa+p1X+9Vv715s68kegmiwqFo9qjIdfk338lcNcpbgQFgp7AAAICd8ORHnpwqF65afWfQr27fp/TUlM+g2Tc8KvNAIHrmEHUSD4g/Wzw3IqXPfYpWYADYCSwAAGAnDOn1S0NH35N9cZv234NTPkXi9Yb16MDabg7yprU3zs4cGS0Vt+niAABsNAEDwE6YrmQLQ6Pz5aWO7znuyg0m7zSe8hn+WItm3/opnxK+wddM+YwfF4Shv0QPBxLNvok9i4iqf2ewyGR1dWZ1eUhoBQaAncATAADYdk9+5JHZyuJNue93fM9dmPJpCofamfJZl/iv6yWQcB1y9eqpmfXsF+7hrcAAsO1YAADAtpuuZl/LXHdj/vUO7tOu+VEiYofy0Wu/6qZ8Nn69l9Ps6075dJt9g05id51gv94rsX4IPlolOgGsdoJgXXF18cxbmSsnaQUGgO3HAgAAtteJXzyRkfxVpbfCkLwT+mjKp6Qn/rW2Co2CKqIjxXOjev3zv/D1Tl0lAEAqFgAAsL0yheKpfcfes/xCR/bWd1M+GyT+zcpB4iXHDbnXzk0dHivTCgwA24smYADYRgsLC0Nnlw8uFjO1DsS1dlPv5pp97cBdmQR/o2ZfaaPZN/pEt9k3fHWw9dbh4M/aeW2wu33UL8+tLQ9JeesXCgDQBE8AAGAbzWZHXzmi3rXy8hb309dTPu1lRpz418H2cDhQ8PPH105OreceuedLW7xcAIAmeAIAANtovlCcXZk7Vjy76T3sgimf4ZE0SPzHB6PVweLllw7fPFXObfpyAQBa4gkAAGyXxz7y2NHs+s25Nza9h10z5bNJ4l/MdlFKlFyxdma0Vn7oblqBAWC7sAAAgO0yW1l+ffy623Kbqf/ZZVM+4+bg6MCiAiQdPxDQSl2Tf/vc6BXjVeaBAsB2YQEAANviqXufmvQL1xTf9EwSvH27cspnUHyULEzSwUeINhONlOj9pXOjtcL9d3+lE98DACCJBQAAbIvRcu789PE7VjY2/XMXT/l0E/9K6+D44/VG1DZwQ+718yP7Rmulzn0bAIAYCwAA6LxnFp6Z8oqza2c2NP0zburVyRbbMPFvpu5Ezb6Jmh8n8S+SSPxHZTkpiX9xA3FT8yOJEN88c1Bugl/r9MS/vd06QRUsPpIjRM3SYliXZ8u5obXlhQ8tdOLbAAA4WAAAQOfp5dXVY1e/J9tu+n+PTPkME/8qmfi3/hMsPdR1hVNnLuQnZqc7/MUAABgDCgDbYbKwlFtePVi61PIn99SUT5H0xL/ZSdzwMFvOHr72ZrVyebPfAACgIZ4AAECHPf2Rh6ezF25ee6XlT+7BKZ+NEv/26Qe/eGXxzPyY/sK9T3X+GwKAvY0FAAB02Gx58Y3MtTetvt7kZ/bslE9pkPgXa1hQsK44VjxzLnNosrLW6e8HAPY6FgAA0EmP3Pn4eK1wbf7VJj+zl6d8Nkn8W+uH8DSPFM8PV0u/ddfXtunLAoC9iQUAAHTSfGX5tYlr7lh5KfVvd+GUT52a+G825VMaJP7N9vg5xtWrb70zdHCilt+mLwsA9iYWAADQMSd+5ssT5fwNhZMDulb/t/0y5TNYm9gJ/mZTPpXa6JRPJ/HvrB/CdUi4bhA1IPpw+VJGrz/4iX+znd8bAOwtLAAAoGMma7m3R66+Y/m5xPb+mvLpHPD2TPmMVyzKSfwH/5+9rrgu/2Z2Yv9wZX17vzkA2EtYAABAZzzwya9mZO1o5cx4LY5Wo1L+1MS/SDzls0ni32r2rZ/y6ST+VXuJf52W+JfGzb6NE/9260LDxL9YNT/uIwWxE/8SrCuUin9dqWGpThZWRkqFz/700zv0RQLAbscCAAA6Y7K4+tbsle/Nfifa0oUpn2bPHZzyGRxMx6d8xn0IVs2PVmEnsb2uuGb1jUu1yZHB6k5+mwCwi7EAAIAOWFh4dlRVji6dm69kxa352dEpnyIdn/KpUqb01E/5lI1O+XQaHnR0yvHORSutlVJqwi9Mj64PDWcXFhZ24rsEgN2OBQAAdMC+7LnvH33XHavPi9ML6+bao2bfXTjl053m2d6UTzfx756+tt5cJuqq/JkLh3OZ3MyOfqkAsEsNdvsAAGA32F+4tD97/sj6edOnG2b+g//Pys2HUbiKCmCi7XZgHYbXOuoKiLabxL+p6hHT7Cuqcc2PJEN/CffVIGevRCllb7drfsySQJQyk4TMaTZJ/Nc3+5rEf2J7sMfgxWFRmdB8efnAO+/3hi515tsCgL1NdfsAAKDvffVnHrymcGqqtnrd2pthkjy92TdZ8xNm/e2YWMKAvq7ZV8IQPxH6i7OuiP42ztknjiTYRWLn2gm4Vdp2qQvQGzT7qpahv4r3LGIfibY/Pbn9/MiBwuDYxbEDnzzx05364gBgb6IECAC2al/p0pvjV1+7drJ3pnzaRfaJZl9r53GTQJz4b9Dsu5kpn6mJf3fKp93sayJ+qwApPEERpQ6WL14cOzBZWd257xUAdikWAACwJU/8zBfHaus3515hymdyymfU1xs1PNRN+bSbfcXdHr8jLOyVUEeKZ4f98v33fG1Hv2AA2HVYAADAluwvL74xfvUt+dd2YsqnWSdI56Z8inR5ymci8W8uXbw9Kkk6Vjh3YWT/ZDW/o18wAOw6LAAAYPO+fOeJjF+4Jf9aHMpv65TPIF/urhO2OOUzbUqPk/jXbST+Jar43/iUz6AZzXkgEP45TPxriZ8GHF2/OOyXP3vv7+7M9wsAuxILAADYvNny0tsTV9+We9mKmHfFlE8r8a/aS/zbNT8bmfJpFRqZxH9QgFTXoywicqx4+sLIQToBAGArWAAAwCY9dteTmWrx2rU3vGAQfsNmX5WS+Jdk4l83SfynNftK4pGCG6AHR9gg8W81+yYS/3azryRrfqRp4t9st55jOIn/5COFcPJpWuI/7iSO2gDMIkFEjhTPjfrl++/7gx36mgFg12EBAACbNFtePJk5fvvKi2Hiv2Gzb/xAIE78iyQS/1Y/bl3iv67ZN5rAX9/sq90pn3FLbl3i394ucddyw2bflMS/ttcP4TqkYeK/rtnXerLhNPtG6wRzPa3nG1pdWXh7eezgaJWHAACwSSwAAGAzHrvryYnK2jVrr3m+z5RPiRoeNjvl0272DQ4jWs/Y6wRRylMyWzo74hc+/cnf3qlvGwB2FRYAALAZM+Wl05mr3rv8vDDlM2p42NqUT/eRQnj6UeI/XhqJHF976+LYzES5uKNfOQDsFiwAAGDDHr/z8cnq6vH864NSi5p9mfKptzbl0309sDlNHT2XiNcbnuhDa0sjldKn735m5751ANgtWAAAwIZNl5fPjB177/LzIsKUzw5O+YyPzSpJMv3K5jS1Eq2uzL+9ODg34Rd26CsHgF2EBQAAbMzjdz4+Wc1flT85pGtM+ezslE+72VfrcGnkNDyYPQwofbi6OOKXPv1z/3bnvnsA2BVYAADAxkxXsmfGj7135QWmfFqJ/85M+XR7keOanyjxr00vgRI5Wji9ODY/XqETAAA2hgUAAGzAl+750kQtf1Xh1JCuMuVT7MR/h6Z8Rol/sU8nfnQQbtdKDWp/X2FptFb6zft+f6e+fwDYDVgAAMAGTK4vn5049p6VF5nymUz8S2emfNqJf3v9ECX+4yojUVevv708MjdepRMAADaABQAAtOuLdz2ZqeSPZk8O18rJmh/FlM+OTflMWz+E28NeAnNqnq7tK10erZU+ey8PAQCgXSwAAKBdc+Xlt8avfF/uBSuBzZTPzk/5dNcPKYl/c2oioq4snskOzY7xEAAA2sYCAADa8vCdj09UV6/Pvzmkq27iP+h2ZcpnJ6d8xuuHtMR/XGgkyvNrc6XLg7X1X/747+3UvQAA/Y0FAAC0Zb68fHrs6Huy32XK5w5M+QxbDsRaKriJ/7BVWpSIOrZ+5uLg7KSf35k7AQD6HQsAAGjtkbuenKgWblh7c1DXTGWOk/jXTRL/OqXZlymfLad8xtvTEv9OJ4D4R2sXR/zSr97DQwAAaI0FAAC0tr90+e3MlbfnXmLK545N+XQeKZjGBjvxr+ODVUcL55aG56Z4CAAAbWABAAAtPH73iUxt7ZbV73vaZ8pnvA4JT3Abp3wman6cpwrBwZh1glJyrHpxxC9/+l5eDAwALbAAAIAW9q0vnpk4cuvKy0z5jLbvzJTP+pofCVcIOty5jrspDhUvLA/NZGo8BACAFlgAAEAzX/7oI5lK4ebsq8q88ddqmVVOzY+JX5ny2cEpn4maHx2dprPn4If1wfKlEb/y2ft4CAAAzbAAAIBm9pUuvzN67Obcq9oK6JnyuWNTPpPbo1aH4PqImYCklIg6uH5pZWQmU+YhAAA0wwIAABp66iMPjdUKN61+L2r2TUn8x7XsTPlMafa11xubm/JpN/vWJ/7jBwKiRMmB/MUhzUMAAGiGBQAApFtYWBgavnhm7Oj1+Td1HLjXJf51SrOvKKZ8xtvjxP+mpnza6weRKPEvYeJfSzxSSWR/9XJ2ZKaYL3z4w89s8w0CAP2KBQAApJtfHn31iHpP7kW3H5cpn+1P+bQ6AcT++Q1P+QzWD4l1RV0vQXjNj+XPvFAYPTamd+pOAYA+o7p9AADQixbue+iq6uJoaervX3zWVOAoSST+JZn4t2p+7GFBUh/6x/l+q9lXopy9ij9RW9sbl/sHKXVrzw2mfJo/uzuPM+vhdusEmzT7Kif0r5/zY7aLiv9dE+bsnVMzp5/cru3DiHaeupNwu7ka35+8Pr9e8YenFx79R+1/6QCwR/AEAABSHChX3hqcf0/2BRPRMuWzy1M+o791jsRE/06RlVLHCmf84ekRtb4jNwsA9BkWAACQ9NB9T85WiretFfeVF+OaHxO/ClM+7dqeNqZ8inRgymf82q/UxL+7fcxfnx5YGdKVf/7JP9rWWwUA+hELAABImirlljKH7lh6Pk5sx72wTPnc8JRPaZX4j7c3nfIZrR8aJf7tMz22dm5xZCZTLe7ILQMA/YQFAAA4Hr3vyclq/ljuzJS/5tT8MOUzrdnXXm9s95RPu9nXXCW3cCg8TiUiw7p6cH1pzC//Cg8BAMDFAgAAHNPF5YuZw3dkX3Rr2d0QXzHlM675iRP/2z/lU8x2swc78R/XQQXriqPl84Xh6dEq7wUDAAcLAACIPXLPY5lq/qrlk6O60qjZlymfZrv182L//PZO+bT6JdzTDJde8QOBQb86u35p2C/9vz//77f91gGA/sECAABiB4qLZ8YPvTv3cmriX4WJZ6voxW32lboHAk7RixO8xs2+bma9Yc1PnJuPR4WKvX6QOHBv0exbN6XHbvaNAms3EG/U7Fuf+G9Q8+M8VYgS/07PcavEv93qYD/fCK+/1UkcnrU6VLyQHZmcKPMQAABiqvWPAMDe8MRHv3ikdH6iWrx+7c0Gc37CJYFEuXmlxAr94+12WU48ItOuwImjXrHH8DfYiQzXEzEAACAASURBVFPzUx/6W9vFys23HM/ffMB/+CuNpnxap6DSt2vzVMQsA6Ji/SbNvqlzftK2x9+OfTGt7cE/F4fnSoNDq8OTv/Tg/9jObQAAux5PAABAROSZhWf2DRXPjhy6fu0NpnxatUCtp3w2T/xvx5TPOPFvvqP4uYd2vgWl1HxlaXV4cqq0cuLuE9t7DwFAnxjs9gEAQE/wl3PrR6547/PPajf0lzBiTjYBm6r2hol/SWyPQn9JpucbJ/7dZt9Ed2ywN2e7Gb8T5+y1+fT6xL+EXchB6B/+V+s0dTCFyMrNm5x9vBOrJTo98Z/Y3jzxn6z5SUn8myVKsPBIJP6DZUb83YXrBK0Or10oD3nramyTNwcA7C48AQAAeei+J0eKK9WT7xwsX9RM+eyHKZ/NE/9ibRelJmr5FW/e14r3ggGAsAAAABGZKq2dHZx7X/a5OF3NlE+zPZrSk2z2VV2e8mk9Nokqo6y3m1lvDdNKHV4/d3Fkfry2vq03EgD0BRYAAPa6L9zzVKaSP5Y7P1nNC1M+UzsBxP75Xpny2Tjxby2QzJJpWJf3VVbG/Mqv/fyfbPMNBQC9jgUAgL1uX+ny2bHDt698lymfKc2+PTvl0zwfaJT4t08zaBk4XLxYGp4Z4b1gAPY81fpHAGD3euKuEweLF0b99Ztzr0VdsBLl5pnyqdznHs52HTf7BgcZ5eZ3cMpnfG2tFYV9Dc2/6ZQWuTS6r6YGV4Yy//LB/77RLQEAux5PAADsXc8sPDM/ULwwdvDm3GtiF724iX8rIW3/U0SkSeLfbvbt6ymf0jTx3/Upn3HiXyUT/ypqGDCns6+0tDKUmSlnGQkKYC9jDCiAvctfypUOH3nXd//cSjCboNzktFvn7IN/MuUzOp2dm/IZLAnC/mb3EUF4kDqeKRRcWX24cEkPVAve+MbuFQDYRXgCAGCPevCnnx5ZW62+8c6R0nkn+m+W+GfKp9Qn/rs35dM6QesbtBP/oqxGalFaqYlafnFwnyhv4f/4w+28vwCgd7EAALBHzfjZM5X59618NxGgB38bh/JRpCsiu2rKZ7jnaEpPstlX9dOUT7MwELHXVNHpmycVwVOFw+uXVyZmhsrlbby9AKCHsQAAsBeduPPxSX/t6tpbGb9gV97H3a6mByA18b8rpnxaPy/2z/fllM+wYMkpSTKnL9EBhAczpMvja2tD1cq/+BTvBQOwF7EAALAX7S9dvjB+4PbVV6KAPmCljU2QKuIk/pnyqXZkyqf5rEaJf/s0Gyb+3UcKVieAHCpeWh2eGC8Xt+0WA4DepVr/CADsLk//zEMHyhcztcLVxdNihf5i5ewlbkiVulk62kkzM+VT3Gbf7k35tEN8c2rp20VUdmi6PDCYH8j8yy/8o+QtAgC7Gk8AAOwtn7nvyVF/9eLwgasLp5nyKa0S//015TP+XbfmJ9pz1NchSs1Uc/mBzJCq/bN/9ufbfdcBQE9hAQBgb5lfXzs1efCOleclin1NUGg1+zqBu9PsawfounniP9nsawJfra3A3SqGMUF5XPEf7qW+2ddU/Ldo9jX9ym6zr5j1g72uSATi0eHZ25sk/q31Q5zjT1xA+0yDZZPTCVDf7BsthOxm3/AaSrI3QEREa/epRV3i3+kl0HKoeCGXmR8t8W5gAHsLJUAA9pAv3v3l/evnh2r6fSvPWwGiVTljEs9hClxHDal2Arths6/5pxX619UCheGpk7O3jiTu07U+1B2XKdGYztSdtC4cStb8WKcWHmTiE5uG/oly//AIzdMVu6k3vhqS2K7FvpJibQ8PPtHsG31rdYVDTWp+wkcKYWVU+IkXRg9UvYE1Gf+NL/xUezcRAPQ9ngAA2CsWFhZGBs5dGj307twLDRL/TPk0h+cm/nUy+hfp4SmfTaL/IPFvXX81X7q0JuOZGg8BAOwhLAAA7BWz2fHTB0u3Zl8eDINdpnzuzimf8Z6jFVrU2GAWQtFpeiIHyxeHdGXhE/9p++49AOgplAAB2BNO3P2VcX1GVyZ/fPEv43y/XfQS5ew3VfMT9+NKXF5irx9E27GvtXN7iJApgElM42ky6qedmp/oItRVEzWq+THriiizbnaeupNwu31N7NNPrfmxtke5eecE7dA/eUHM6btZ//gT0xL/dgWUfW2D7WfGj3paLw/P33//jzS+iQBglxjs9gEAwE7IVHL5oWM/svIXpuYnCk+lLrzWTqzZesqnjh4dhKG/ckN/q8ZdotoeqQ/cVSJwN78UPFKQsP03DP1NAN2RKZ+mvMaq+FfRykSZRU6Dmp+NTvmMC66i5YduOOXTrArqm31V2s6dq2Qq/rV1be3TDM5aKSWyv3z59cwN45W1tm4mAOhzPAEAsPuduPvJA8WLov07Vl6I407pQOLfbva14lorPI2z0S0S/3YY3Tjxn0zwt2z2lbQAvUHiv3Gzr8Trh2gnEn7uRhL/brNvi8R/SrNvSuLfDv3jz61r9nV2FQ0Lsj700uB81RssDoz+xoN0AwPY5egBALDLLXxoYXjx3MWxA7evvGxnnU1FuylkN5XoiZbc5ol/idYPYS27MOUz2NLGlE8Jr7PT7BteQ0n2BojIhqd82s2+5lMkTvwr+30OMldZLg6MVgprH/7wM9t6QwJA11ECBGCXm58efWtx/Se9l5TUtFPR3iLxr8JgWLmhfzLxryWu+Ukm/sMQ30pga1OX0nTKZ1riv1HFv7PdSvwHfboidmlNcNZh4t1O/Itd8xOdpr09LmeK2gMSO6mr7G+U+I+afaXdxL9ZsShRcbexSFrNT1jvpO2FR/TUJTx990sJC4qU6P3lxb/KDRzIDG30HgOA/kIJEIDd7Is/+7Wpy6e88YkfXvqmiCQD96hepWnNT+KH6wqHGlb8Ozu3an6c6LbFm33jgqJo/WDX/ER7ThblR9vNzp3cud0JkGx1sA47tdm3QUFRXc2POUjrEzfZ7Gt+uJ0pn82bfaOaH/MN6sTK5PzIwWK5rCYmf+NzPykAsEtRAgRgN5tfv5zbd/Ud2eeioFDHpS9M+ZSocMiqidpVUz4lqPnRyZqf+Itz9zBfuqwmJkcq69t3TwJA1/EEAMCu9eU7v7ivtDxaW782f1KcnD1TPrV9GJ2f8hlPPdpC4t8t948/cQuJ/3AtVJf4D3euRSuVHZyqeQPr3viv0g0MYJfiCQCA3enzv/D1cb94eWT22vzJOPEfJaFN+rlJ4l/CiFMnHx24iX+R8D278a83SPxLMrMeJf7rm32lWfSvxY13rcR/42ZfiQL0KPEf9cJaCX438S/xdnG2mzi7RbNvnPjXycS/jhL89Yn/tGbfhon/4HFH+HCgReI/+Mi6xL/9zarp6uq6N+7pyi/+4rPbfJMCQHewAACwO00VV85OHX730ktW1UrUSxqFg0EIKFq5YW59zY8T14a1PW7Nj7aqSsIKHLECcbsyp3HiP675CQqEotKUBpU54eMJsab0xHlut+ZHR6fp7DnYuY7WD1Kf+K97qhBX9STWG27NTzzpSJsVgoqvYbhysNYV8e82qPmJanvMusU8jVHuwWhtXWdrvaG1+bOV+A/+wu0Ynisv5gbHR6vlbb1FAaBbKAECsAs9ctcT+yqXle/fsfKS0+wrycx648S/3Sq6gWZfK2evncT2xpt9zfE4AzrjnUQ7dzLobu7cbfaNdiKJnW+82bfu9V7ms9yaorqaH3Nt7ZFBdT+8xWbf+AQbN/umbjffoIjIpcE535P1gbHPPEA3MIDdhgUAgN3mgU/+0Vz+7TVv+O9d/DMvrBzZWMW/1G0Xa/Hgvt5LnDA07tNtNuVTzA+n7KS913vZob91asGO2369V8oQofAIg/5oZyfO1Uiv+LfC601N+Wwa+lsHL4lPNCcizs80Wz+EH9ko+g8eI5weOzo2WFFTowsLfzf9VgOA/sR7AADsNpn1xaXMlXdc+FMvjAlVMvRXzoB/cRL/VvTfIPGvm075NDl4VRe4B2sBFYf+4TGkJv7DEDbac5SbV+4npiT+Ew8EzGGIWMFxw8R/ynYTOidC/+i6OWP4dRCf6+iNZlbor4KrkVwSROuE7ZryqeKViWq8fkguCZSar2SLc/O1QqXVHQcAfYYnAAB2lUfu+spcZVlr/33Zv3Wy4/Y0npaJ/7QQv2Hiv3XOXlslMYkAevOJfzv0D09ta4n/IPRPyc2bBwLtJ/61cna+lcS/fVnSAnetU2t+Eo8s7EcH8Qc1jv6DP2t9YWR+cFCKMvaZ+3kIAGD3oAkYwO6x8KGFoeWzS0Oz71r5rtitpa2afZUK/1/DxH88xKZFs28YLqdX/DtdsHFTb6NmXzPVXuLEf3qzr7jTe+KmXrsXViRO8CffHWYCd3s+UvifqNDIdBKHZx2P+nGafSXZ7CvmYUtKs2/UBxyfTqPEv8RDhOzO45RmXxW82ldSo38VdxKHjdQ63B7fGOH1Fy1qvpwtytgb75oxBUYAsBuwAACwe8zOjJ5eLN6Ue2lIV6MAvWnFf/BHFUW6YfxnBeIiTPncVVM+ndNvkPiP2gkGRE+Xs7/30ff82B+/uT33LAB0ASVAAHaJB+766szK2yqT+cDyt8VU8rTf7CtxjYpOa/Zt8Xovu3S+LvG/ucKhuOYnrSh/IzU/EhcORTuR8HOTpfDa2t685qfF671San7Mzzeo+Yk/N6XZ19pVtH5QKTuJantMB4VYp9ay5se6ttbBXBze9861UwdPrn/m8z9ed98BQP+hCRjAbrCwsDBy4Vx2+sqfuPwNO7xunvgXs06wokwdV64nos+oFiiOfU3i32yPmn3DBHkQkob/Ndnsq6IAPa2pt/WUz8T2JhX/KTU/G53yGaTexY68wwcsym72NdfWFPmIvRNtrayc7ak1P4mVgznNYBkTXL3Gzb7O9sahv7M+SYv+g53MlZeqJ4eH/fVWtyEA9AdKgADsBrMrmXMH8zfnvz+sq6YypGHFf1wZYgpCJIq8k6/3ireL2MX61uuETam9NoF4WuLfbNfxqNCgSMbuJbAqc6zuhbqKf/v1XuZg017vFb32Ky56iSLyuqcH4XHGYXFcaOS+3kus7XWJf7Ff7xXWRIVn2vD1XlFtjylYEtFWVU90+qbmx634d17vFR1M6uu9RJKJf+sbNA9b7DIhc+Se6MlqdsCv/Z+f/NNtvIkBYKdQAgSg793/8a/NqtNebeoDl75ZX/MT/SGZ393I673smh83bWwn/utD/5TEf5wptxP/idx83QMBp3LGTfwHh2GdmtnJxl/vlagRij/Lzs03qvlJPqwwp29+eLumfDYrHGpV8yNiDtD9RB39hvkxpS4M7h/0aoWxic9/+ocFAPoZJUAA+t7+8uKl4Sv+3uKft1vxH06DcSK8uOI/ChfTi/Wb1PzUT/nUDXZSv36IK/7ran4kzI7XN/uGjwjqan6SRxLXAtW3F0fxrtg7r6v4j557xNvjKhpdV5JkTl+UVsFjgTBnL1HobxUUhUeiVV2ArsPWhUTNT9TYUB/6xwfQKvo3w4LEPEBIbI9C/+CX5ypL52eOjpaLze5FAOgHPAEA0N+e+uhD0+WVMb98vHCqUejv5HcbTPkUsWLftMR/HCy6AXqLxH+r0D86kUa5eUnZru3DiMfkN0n8b6rZd0uJf7fZN/7ELST+w7C+E4l/+7XBKYl/ZV9YFXUv5AczVW+wLCOf+dcfEgDoW/QAAOhjD9z5tUylsDI83SD6D/5oCsR3cMqnbhL9p6Xhw0r0RPG9iJjDFjvxr5jyae3B+Wbd02+U+Leif6sTwHnDg+klUFGPgYgarxbKMjLgV37hF/6i83czAOwUSoAA9KuFhYWRC2fPypEPLf25juLg1JofEYmH2Oi4JD2uRUlP/OsNT/lMJv4ljJXTa37iPVsVO2Geu/2aH+uBQLQTCY+nRcW/Tkv8B38bTzrSpurJTvwnuxHMtW1c82NP6VHJnL21q4ZTPuNuivgKhAfYXuJfS1RQFF+E4BN1XNwVNyKH10/ZpzlTXr4wvH9El5rfnADQy3gCAKBfzWXHzx3M31j4/ogupSb+xYqAo6S1tgJ3e9KLTib+w73EDwQkGnnZKPHvvHjYzs2HOXu7bcB6INAk8R9vT5Ykmeg/yNabYUFNEv/xmbZK/CtlJu3YbxdOJP5N7rx54l+smh/3kULizb7mNcMmQK9L/MdDgZzEv6pL/OtwXRGdjvkGrZIqa6GotTXQyRy21ioe0GQNCxItntSm/dygrv1vv/CNbbu1AWB7qdY/AgC95/57nprTZwfKk+/Pmtd+pSX+rSVBlHdv8GYuZ0pPSuI/yJTHVeOpO9l4s6/ZsxWetvl6rwbNvlYtu1vZbyX+ne11zb7R9vYS/3H+vuWcH0km/tOL8pvvRJuP3EDiX+ydW7VAVhOwm/ivO03tPPa5NDQ36FdKA8Of59VgAPoQJUAA+s/ChxbGli4szR35iZX/Kk0S//XNviZtnNhu1/zEaWOxA/cgklRx6O8WFEXrB5G45ifac5SYV+4naudDzeLE7oI1hyFiBcfR672SNT8p200gmwj9xVy3xOu9wpIa86zDCv1VcDXqan5MgL5dUz6bFQ61Cv3FPLBIfGL4IMP6sTDxb65hyvpB2zuZrWQvD8+efPes6GhNCAB9gwUAgP4zOz1+/lLhg0OvD+tq2A9aH/oz5dP5RGmZ+N/jUz5bJv61tX7wRE/WCv/+o3/ng39y6i8b36gA0JvIWwDoMw9+/Omp5XfU+OQP5L6jw5S6Fbcx5TOt2Td5+lYTMFM+7fbi+LZJKxxK7GRlZPr08an5N4tfuP9HBQD6BwsAAP3kc596ZnZ1cU1lfvzSXwxKTcSuGEmv+Ym2S7PEf33OvlXo32gnbrjcOPFvBdBtVvynhv5p2+P4u0GxfhTphosfewaRvTgRN4AOdqKjU2tZ89MoZ6+dE0zU/CRD/+T2+PRbJf5Tt9uJf63ja+4m/hsUDtnrB1E1UReH54bGvOqh/Q/+/PUCAH2CEiAA/WSikFuenH/PuecGpeakZpnymZb413binymfKc2+EjZCON+gNt+siq+n9UAgWvx4IjOVlZXjNwws5xrcsADQi3gCAKBvfPGuL89Wl8XXt+deaj/x72yPc/a6LuxrM/FvN/smc/bxTpy0ccPEf7x9y4l/O/RvnvhvXPPjJP7tAnrZWOK/Wc1PfIKbS/xboX99zt69etEKqlni314/BLtvmfi3H6FokdzQpIwM18rq/vt/RACgH7AAANAfPnvv7x9YP58fHP87l//CU3aEV5ea1W5E6wbuQThXn/gPMuVx1XjqTpjyaW+vC/0lmfi3n7qY03e+lB6d8tks9A8/MV5A+qJWhuZUpVysDTz88I8JAPQ8SoAA9IfZ8uWLo4d+eOm/htE/Uz6d6ppE6C8i5nTCE6mr+VFu6K+Cq1FX89OhxH8cgicS/D055bNZ4j9afVkFS5lKbrGWGR7w625bAOhFPAEA0AdO3PXYTDk3pMs3rr2ZGvo3TPxvoNm3fsrn5hP/dugv0oHEv6lRqcvNm1C1/cS/3ezbkcS/NterLkBv0OybeGRhPzqIP6hl4n8Dzb4dSfyb6+xe2PBEdH4g4/tSGRx+4P4PCgD0NhYAAHrdF37u6/P5C7nBiR9d/GZ64p8pn4nTt5qAmfK56SmfTuLfqvlxl0bRtZKloZlBqVWGhh/8zAcEAHoYJUAAetrChxaGLp9b3Hf4B8//tZbk673ESmmLXZixgdd71df8SBjqdWTKpxYnQFdKrFE/yk786+QjCGmwJGiYm48G2lhTPnXDKZ9mVZBM8Gsn9k0k/q2ComBjohjGJP5FpO71XsGBKJXe7KuSp7nFxL+WjU/51E7oH+wtteYnXFYGv66UiPhKTVbXcmPTb946zeuBAfQ4FgAAetrs7Pi5C6sfGFgb99ft3DxTPoUpn9Enbs+Uz/DpQeIqaeuhSrRdha8HHi0X//Cf/tAP/ecz/y31bgaA3kCKAkDvevDup6eyZ9XE5HuXn2+U+He2M+XTPn1thafxT4q49fdOgr9R4j+x87005TO15ic+wfibCr/l3ND0O9dM7D9Vfviz7xMA6EksAAD0qN+6++v7KsurQ5M/evmvBnUtmfgXkUR8pqPYjimfTPl0T3MLUz5bJv5FnJ3XtGRH9w1VSrrmPfggzQAAehElQAB61Gwle3lo9gdWnh/UNW0F7vWJf6Z8Wol/pnymrh/ai/4lpeI/+FsJPzaup5Kw9EuHf20+0ROZKK+s++PKYyoogB7FEwAAvejRjz8+XcoO+ZXrCqekSeKfKZ91iX+72bcjiX9trlddgL6Hpny2TPxb/xQtUhwYF18qA4MPfY6HAAB6DgsAAD3nsx/7+pHqhfzI5AcW/0YkzKA7xTDJ8Jopn0z5ND/pJP6d9UOzxH99zY/EFf+NQn/nsE0nQLT0yg1MeNovecOP/qv3CwD0EhYAAHrL5z71zORqNutPfCj3VyN+JQocZZOJ/5TQP/yVjkz5FHEC9C03+0qT3LzZHkW6YqXh7cS/WXK4AXSwEy1O7NuqWD8tZ98g8b+hZl9zlFtJ/G94ymfjxH/iNE3i3zpC6xOtJVMy8W/v3NdedmhqYmB9aryysPB3BQB6Bj0AAHrLxPrq6uTM7RdeHKlVTLE+Uz6Z8tn9KZ9R4t9ZDtUl/lX8HelMLT816RfWhwQAeglPAAD0kEc+/vh0bVW0ujX7vfpmX2HKp3362gpP458Uk72OlkMiG0v8M+XTfaLiTvlsVPMT/rp2vw6lipIZGqwWZPSR32IqKIBewQIAQK+4/76v7S9eWhuc+OHFvw22pKVmRdIS/1rFIVpd4t9ZJzDls1HoL8nEv/3UxZy+86XsxSmf9vrB/XKjdYtzmlrL2tCU0pXS0MATn/4BAYAewAIAQE944JN/lCmdzw2OfODSt8ZrxTA0TIbXW03826F/tOdkbr7ugUCTxH9wGBLtMNrJxhP/4v5824l/c/paRJLbo3XCdk35TCb+09cPTZYEzXL2ycR/2k7M+qEjiX879G8z8e+G/nWPJrSIUr4v2fHMpJRnR8s0AwDoBfQAAOgJY6XL+ZFDNy59M+MXfWmUs08f8B+EbnVTPtsd9VOf+LdCf5ENVfw3SPyHNSpOhG1/orRM/OvmUz6T0b9Jcjeo+LffHhAeiVZ1AbqOivKVE3lr80F1oX98AC0T/06Cv3mzbzuJf22H/taRxKdvkvbOhQ2XlW0n/rVza6lk4t+K/oNvSomIeJ6Ml8qz0+V8iX/nAugJPAEA0H0n7n5sqlL0dfW2te+LVn4Q6Ptu0YukBOhM+WTKp30wOznl0/pm607T+ndr9PNFb3h4wC/osUc/e4cAQFexAADQZQ988rfnC+fXBjI/uPRtT2mtlfaVVkpFAZ/U5+ybhf4SpbTro383XG6c+HfCR4kT/3GCP5n4Z8pn4vRbJf5Ttzdq9nUT/00LhxKn726PLlp0GZ0Lu5Epn/HX5FyltIoyUaLFV6owOOGpWnV46PFfvV0AoHtYAADopgc++UcT5fNrw+Pvv/hX435JRLTvaRFRnhMUtjXl01kntFnz017iv3HoL/H6IdqJhJ+7kcR/+pTPBon/lGbflMS/HfrHn5uSs7d21XDKpxtANynKN3tsv9nXWZJZtT3Na36suNz54lok/ttu9nVvvE0m/hNLgppShfHJjF+cHS7SDACgi6hHBNBN4+XLa8OHblj+63G/JM6UT2la8W8i4/C/Jpt9lThx24anfCa2N0/8p3YSb2DKpxJxivK1iBYz4F8lHhGEB2kX0IvEY/i31uwbHJ1b8R8k+K23BDjbG4f+9Tl79+qZnbiJf+0m/u31g4RrlhaJ/+C34mvr1vyYMn7T8BB/gzr8a0luj7+atAWnOZFwLWevA60bIzxNT2SkuD47WVwtj9T9TwEAdg5PAAB0zSP3PDJTKfm6dkv+Ve2LUl4QLPpBTCxM+WyZ+G9cUFQX+ksy8W+Hqub07euWvn5okOBvtH23T/lsUvNj31rWCcr64NiIVy54o4//xnsEALqBBQCA7njgZ7++r3w+Nzj+geXvau2b/3OktFZaKS1KfDvxH0dyTtFLMsITsVOzTPnceLOvpCX40wqHWoX+IuYAGwTuVuJfzCKk0fqhl6d8tkz8J+9G7RdGJ7yqrumRL/3WLQIAO44FAIAuWLj760dqK+vD0z+U/evRWtUPYsug6EUH/xFRnhX610/53Hzi3w79RTqQ+Dc1KnW5eROqtp/4t3tSO5L41+Z61QXoDZp9E48s7NA//qCWif8NNPt2JPHfaMqnOfANJP7tnccHn9h5i8R/Suhvryq18ooypaTqe8NPfOYmAYCdRQ8AgC446K+cHZj+O7kXRvyKNnGnXZkjSmllxb6piX8T+ouITgv9g89SUWbXHqcT/E3Kdm0FiFYA3XDUjwncUxP/5nRMUCgSjNtX9v6txY9KJP6Dc6lL/IsVntqfuIXEf3hBOjblU8X1WmJi7uAq2TU/Ekz5lLARQswOw8S/CZejW6JR4t/tJK5L/JtOgPAwlJnRr5ok/lWj0D/4p/n+46VafDUaJP7tpwe+HlJr5YEpJWUBgB3HEwAAO+2Jjz84Vi2OKn08f0pETM2PlnD+j4m/lRLNlM/0BD9TPlO3RxctuozOhd3OKZ/thP6JG680MKi1V/Pkyd/kzQAAdhQLAAA76os/+9i+0uLaQOa9uRe1eCKixdNadBg9eVppJZ6vRZSnfTeA3kjNj6QF6HHkzZTPup3EAXSTonyzx3aafe1PdBL/u3TKp7Nu0dFq0/lhUc7OiwPDSktlYPQrv3GzAMBOYQEAYOc8+Imvz5Yu5QbHfzD73IBfE8/TWsT3fBGtRGvtiaeViPZ8X8K/TWv2FXHitg1P+RR3+5YT/3ao2jzx3zj0dxL/9oQc2Vjiv1nNT3yCm0v8W6F/fc7evXrRCqpZ4t9eP0gigI6/wYa5TV+GIgAAIABJREFU+cRpRjU/8QlaIX7dQwn3Fgp+XbtfR12C39l5y2Zf+zRN6J+8n329NjKlKpVKRf2bf/0uAYAdwQIAwA753KeemV7PFgYm3rP8rYlaISz71kq08pUSCQYBKZHwTcCmtn5jif/UnP2GE//JSE7E6VJwd+Kkh5sl/sXa3l7iX9zotlXOXiTxiVZRvvUzrQqHrOu2mcR/ohZoM4n/xjU/0vNTPqNVZfK7E/eBgLm7fOWtlodHdXVovfboo+8XANh+NAED2CFTpezK6MxNyy9O6oKvlPhBO6zyw/gsqPgPemFVsvPVSvwncvZRfKYSoZXUJf4TDwRM0CZiF2Y0bvZNT/yrutBfJIwmE6/30uGxqbabfTuU+A9+Rpz4Nfl6L9V4/dBkSZCes09cPaV0uAhJSfybfbeX+I9WX254LeHHxs2+ohu/3qthzU/do4kwbd868a+bJv61uYT2/RwtWT3tZ4Yr3opfGx0QANgRPAEAsBOeuPfhTK2gfP/6whsiytdWfKxFifKDwFF5IiJa+SKiPDOzZWOJfzv0F+lA4t/UqNTl5k2o2n7i3+5J3WLi374saYE7Uz7TE//2zuODT+x8a1M+UxL/KaG/vV3KakRVa+Whoa/+5q0CANuMBQCAbffAfU8eKF8uDE7csfJ8EBtp8XwdJv6VVlqLDuM2T4sW8XwR0V79673s0D/af9vNvtJ4ymfKTsLt4sa4UbDYtObHTfxv8PVebugff+KmEv9OWN+xKZ/R9W8QuMfxrhv6O4l/Z/3QLPFfX/MTBdCNQ3/nsLfW7Bs/fNhgxX/9uiK5ZJX4fi54I56q+UMDX/0V1gAAthcLAADb6/77np6rLK8MTX1g5VuDvh/l5n1RopWEL/8SEeVrLcoTkeBdYL4WT3l16fa2Ev92+CjtJP6Z8pk4/S0n/pny2Ubi32k79kWXRkdVzdcy8NVf5w3BALYRCwAA2+hzn3pman1pVY2/f/W5TK1gx2RaPPFFghBfixallQQ9waY/2ISAaTU/soHEP1M+3QDaSuRvpdnX/kQn8c+Uz8Y7iU7TfXQT7ryqVGVgeHC9OrxWpiEYwPahCRjANpoqLedG525ZfjHjF7UyOXsdRnK+EitRqnQQqZnC8UTgHiX4W0/5TGxvnvh3O4ml8boiDO6TiX8lyWZfCU5ElN3sKyaXHfyACaCDvzJ1Mltr9g2OTqn6xL/V7Otsbxz61+fs3atnduIm/rWb+LfXDxKuWVok/oPfiq+tW/Mjyix4VLznhs2+4ZHEv771KZ9aUhL/cejv3M8SrxOiOz8t8R98s8EneloGxR9eK1fG+LczgG3EEwAA2+XL9z405hdUrXZd6ZTEVf5K+yqo/tfaBHlaRHu+hK8AU0p0MBVHKfGdxH9qzn7Dif9khCfhvuOQNBn8tZP4F2t7e4l/saPb5qG/JBP/dqhqTt+JMpnyaX+5DRL/2z/lM7nzuGM4vAJ1rSC67A0OVPzq0PDXPn2TAMA2YAEAYFt88RNP7C9fynsT7177rlLBkB/PFxGJ6/51mLJV2helPF90MPZHPCVa+X6QAE4PoVIS/yKJxH8QjonUFWa0V/FvJ/7F/flEuLnJZl/zwx2Z8ummtDvQ7GsOsEHgbiX+xSxCGq0fOvJ6Lzv0N9+UlpRPjNd4buhf92hCh2u2lon/5PamNT/2beAk/tNqflK3i1JlNay07w94X/911gAAOo8FAIDOe+Dep+b8pdzw9A/kvjWgfS2ifSVa+V5QRRHUzHh+EBZrpUT5IhLGZJ4WEd/zdfgy4ETi3w79RTqQ+Dc1KilxGFM+U7fboX9HEv+7fspn/bqiPvFvXyWtpTI0LFrXBgZ/51evFwDoKBYAADrss/c+Pefn8t7k+9e/M1oraqep19Nai3haifie1iKe0sEYUJHoQYEWEfHCUFW33+wrTPnceuKfKZ+bS/zbpV+bTvzbt66vpTQ8or2B9czkf/i/9gsAdA5tRgA66UMfWlhbuSDTB+8ovzLql8wLv5SYTs0w2LKiHy1Bjbe73Q4W0xKlUbOvOPGZivK15vM20OwrTXLzwRpGmSMxB9NgyqdZFSQT/E2bfc3OTUuo2F2w8WkGZ53S7CtxxVSiFkglT3OLiX8tG5/yaT2CUGZvcceFdZpi6nLEbvY1nygqUTIU7cS9tnWdAO0l/sNraz4uurWCYzP7D7+p1Gbf8LI4280lj77ZRol/e+2nPDVcKa/MHbh4TbAqIWEHoGO8bh8AgF3lvfNDf3Yuf2P15HxtOYx3o9DaCwPHYEJOVDuuVdASoIKu3zgWjwN6Ff6MiIl9zVMFpXT4OgFl7zmYJKODUKxR4r/uqYIW0Vb4qIMQ38Ti0d8qFUSw0agf80+Jotvgz+HpxL+rzF+F2+0oX4WnFoXR1imHB6O1thdO4fJJtNbmz3bqWhqO+gkassMDM38wRyLO9jCyDk5QBd+aDuJa8wVFpxNut/YQnLUOr20yQNfB7sUJo8Vc8+gEw5KYOOCOvnoJb4PwWgWfrU2kHmyPT1OcW8ucdbw9WIVKdNeFt258DaMAPb61ohOMo/y4+aQ++jeJf3PfmrsiOhIJVmvB/SxKiUxkF//6f9p3639Z2vL/NAEgRkYBQMc8ce/DhdVLsxOjNxfeNOGj8kUr5YXBk46DY9HiqyBOUlGu1NdahcU/QYeAZw1cr8vvmrJsMUlaK3W9gdd7WTn++sS/+awWNT+m6MWtv3cS/I0S/4mdN675iU8wkeBPhP512+trfupz9u7VM9ewruK/6ZTPtMR/augvznbrm9Vify9WbU/dQwmn5if8dTfgtq5GmMh3dr6pZt/0xL9spuYneSTRDVD3wxU1dOn4yP5Tpd/5dZoBAHQGCwAAnfHQJx7bV17Ke1O3F56LU7NhhBRO81TKNP5G2XTf80VEhc2+vkgY9ItZM1glN27gzpTP+vWDE+W3rvhnymd49omY2znNjk/5dK+StfZLWSeEK4uKNyRatDfwzK9dIwCwZSwAAHTAA/c+NasXc0OT7199bkBqURAThOxai8nrKz9s6g2G/4h2mn09LVr7noj4Iko8rbUO1wYpif8gWhKxguO0BL802G5CtEToL+av2kn8m/DUifDC7dE6gSmfduCeOM29OeUzal+Ruk90b85w/aBFVQeGtfZryvt91gAAtowFAICt+vwvfX06t7xanXhv6TtjftHk7D0RiSuhwzqHMKMfRPn2dgnLoMUUQ2vRnmjRnif+lhL/pkalURwm7Sf+49IUkY4k/sPPZ8pntNtWiX975/HBJ3be81M+Wyb+49M3e9ZaSgNDWg2uD2b+eGFeAGALaAIGsCUnTnxralCvTM3eXH5lTK9rCTssw+J+FcY0QV+jH6wBzHYJInQVRv9imiBFJPyz1aaplYqbep0hQhJF+XWFGSZwD1Yd5ud1eBjB57sdmVZ3qdPsK8lm3yDMi37FNJuGO4n23CrxL1ELqXWQqc2+VoCemvhX4eea6x9uNwcWteqKaTYNTzP8xfpm37C9VeI9mEhUB4duHXazxL9p9rVPM4hxw/+qrAsYhuPB9THXMKooMwemxDokcU9Tks2+4d3VOPqPby3rxjD3ibs9TvxbgXvUCy5ibpvEfWtO09zPwX0eD27SyvoGzenrcHvwi6JkWNfWBzMH/EsLC8927n/BAPYixoAC2JLR82+sH73x2m//x1l/OQi2RETFhSth8CdK+b6IVlpJMONcqWRMLJ7yta+i/KuJsq3E/zZP+YyOJPwrpnxGzzqixH+DwiHrEcQWp3y6X0SvTfkM95x4IBDeE3G51OYS/2In/u3t5j7XE+Xl48PnLtamBQC2QLX+EQBo4On7Pj8+5vmF/DXFk2F46oeJ/Gi2iQR1/1aOP8j9hrU92tNKtHiig7p/ibL+YfozClXra34kjqskEf3b9SHNKv5Tan5aVPyn1PzEcV5q6B9/bkqxvrUrra0AsW79YA5b4iiz7Yr/tGZf+xPD2Nqq7Wmr5ie+zuHO3QBdJ6+Stq5ttD2t5sc6bGcdkvhE5zStf52lLgmcdYuOonPnh0Wl7dxdVzQI3KUucG8V+idvPF23MnFP32z3lTeu1tfU2O/9ynEBgE1hAQBgkx7/uUdmq5fzAxO3rr/iBxGVrzxRopSvo5ISiRL/WjzROhgJGtbJBOUTnvK11toTk/g3ncGeFq2VFyX4JREVbbzZt40pnyJ2zO38pNgxaH2AzpRPd23gnn59zt4K8eseSjixrzY3hvN11CX47XXgNk75TEv8p+Xs3SNpkfhP30l0nZV7P9cGBrQW3xv4d798pQDAxrEAALAZD//8o3OV5VVv+vbit5Uo7SutxIvG9psQX2ultRblaRFlNQSHZdOiRCs/3KUXhn1afOWJaC2eiPjas1KzVtzWJ1M+zZ4TiX87VBXnZ5qtHxok+BttTw393VogN/RsL/HfKPRXTPlsI/FfP+UzJfFvPlGb009s93VlaFjVfBH1B792lQDABrEAALBhD3/q8alyNjcwdUf+uUGpaV9EPFEi2gvCfRHxfaVFtHhi4ndfPAkCnWDaj/K01sEiwRPlB422IiLKl3CdIEEtkCSjoo0m/sX9+US42QtTPq3DZspnd6Z8tkj8b+eUz5SFpUn8a3EOMroaWsRXA+JpPaD/3cJxAYCNYAEAYGMe/r+fmshn11TmttXvjtVKWokK6/XNtJwgr68lqAVSYYhmh/ieFq3N4wLlq/BxgQnywkcEWgXBop8e4YlYtUCNQijzY20l/u2eVNla4t8KvlMDd6Z8pif+7Z3HB5/Y+W6c8umcplk/1G+3T81Xyh/U2vd8b+g/LhwRAGgbCwAAG/DZ//3pOT9XHpu8/tJLM9WsKeMRiSJ4PyjpMWn7YOxPMBJRS1jQH2Uxg7ZgHU1I1BI8FtCeFgm6BSScktkg8W+Hic0S/9oNHLeQ+HdD//gTU6L/1ol/J6zvROLfLihqGLjH8a4b+ruJf3EPpnHiX9ddpfTEvx36O4e9tWbf8BvcbOI/sT1YrboLIWft1zLxb4f+0Z7tNV5azY8Sq6ld1a8rksvC8DRrWmrDI1W/UvT8b/AcAEDbeA8AgHZ9+MPPlHPrS97UVYuvztSyUfQjEqeTfRUFfKKt8C4KaLSIH1b+iBOgB78YTQpScUiqg4WEmAn38XbzH6Ws6F9pUcGLBiTerkTiifLxwWgVj+EP/hklrZPRv8RTeqztWsKBntHxiAqGIAWLHzPEPfj0YPKpNieo7Bn8ktyDqMSe49NPjf61dtsJzElpHR6ntd4IejN0YmViov/4PQBiH4mYAwhPJ/wIcU5TRMVrA2W+ApUY8C/x7+rwmtsHY/7WPc0o/+1uD79B8yYHc/2Vuf4SvMogvjHCP5tTNgtRc2oSnY71DYYhfhjlO6N+Gkb/5jq7t1Z8P8fbzfokOFD79RH2TRvdGBLd+Up5A+Vy0fOX/QlZiP/nCADNsQAA0K5bMsvPLc/ckD91sHrJyqGqsGgnDKrCH44CGlFmsHr4zyC4V+G7nIL4TOLOYBMhBUGhmZdfn/ivq/iPAkeJYt8g3tZWuBlGtyLBmkNZQaoJ7sMA14prozA3jn3jg4zfwBWvW4KMr3IPRqe+3kuiQNxNXUvDUT/ailCjQFxbsW+8PQw5gxMMw/qwFTuOicO9mRbteA9OgF6X+NdW7BtuCU7WWW/oaC0Uxb7uYiw8NRWtHEx0Lu5pSvL1XuE9Y7Zrsd9fFt118TWMAnR7vRGvH8L7yqrY0dGpJRL/7pvjrCMJ1hfRq9Mk+XovZb/eK9oeLqu0e2tF97O1fhbzgMd5GOJ50+Wh5719N/q5Tf4PG8Deo1r/CACIfPUT/6q4Xp0ekWtLbzpRiPaiHH805CfMtgZZWC9Me2sloqNOAKVMs28YVOkwvPZFm+A+jJZ8LwiPRKxHCmKF/tHBtDHl02T3Vf1PSqLQwiT+3di3bruz8z095VOL/b1YtT1S94la7CORHpry2V7NT/JI3MT/RguHVP39bN3nds2P808VX1tfq8tqZJ+u/odfpRkAQGssAAC09tTPPzRdXVzzMjeVvm+yv0pUUPEfRO1B7leJp3xfiQ7T/KLFV0Hhixn/r5U27/HVJsQ3dSbhPpS1Tgj/qe2QNBn8mcoQd3vjZl83+ldbafY1ew5rQeoDd6Z8MuUz8Yl2iC+tQ39nieveGFqsH9Yy4IvWSv3hr7AGANACCwAALTz2iydmq0t5b+rW4vMSBS4mQA/LWiTO2eugPMLztNaila+U0uJrEfG0SDgYNGzwDV/4JSK+KcZQpgk46BiWsGzD6h5OiYqceC4RbvbClE83pc2Uz/rQv+7RhA7XbFtP/DsXZGuJfzv0N5++LVM+4503Sfwn/hcRvkBDlPL+0y8fEgBojAUAgGYe+sVH5qrZtcHZ2wvfDsZ2+kqUHwQunq/DogqtVPA2AC2ixPNFBy/2EqW0L34YGwXvBPC0hIVDwQvCgujNjwqKggmhIiKeaK3tpUJKHCbtJ/7j0hSRLSb+reA7NXBnymd64t/eeXzwiZ23SPzvlSmfqUsCHa6wzCfWr4fVgBatvYE/WjggANAACwAADT3wycdm9XJucOqOwvPDqhaW60TRmIiY+hw/yNArL8iIhnnNoEAomoIS1IrosGMy/LNIkPgX3zxSUFFwEzYG+GL6Jt2oKBn6W9vj+GyjiX839I8/MSX6bzfxH4b1e2PKp2ws8V93mta/lZycvTSM/ttJ/NulX1tM/Nuhf7Rne42XVvOjZFNTPttK/EfXNtiutR4c0uLLgPrjf3FQACANCwAA6b7wvz41VVnKysQd5efHpBzOr5RoxqIJaKLAPQq+zQu/4veCifaVCnqCzZZo5SBBHZHSSnvBD4SFQ6KtBUCwZ/PP5s2+IiaKsoMwKygUe4d1Cf62Ev/pOfsGif8NNfuao9xK4t9u9nVOs3nhUFriP3GaJlS1jtD6RCvybpj4d76mlAR/o+0tQn/nxmiY+HdOp8GcH/uKafcqNU/8N1w/mG/KvlU2kPiPQ//kns2ROMcmWms9PKBrUhPv/1vYLwBQhwUAgBQnfukr4+vLKzJ9W+H5Cb0axuiitMlPBjU/cSgvJgGslPjiBy2/Tkm3ebNv+Epg0UHo74tWntKixRMVzVQJph+GvQEqeL2AjtcYYueD3Q9qkfhPqflJSfzboX+057ScvbUrre0gLHX9EO8kNcQ3e2yn2df+RCfx337Nj5uGb53419a1jban1fxYh735xH9iSeCsW3QUnScT/Ck7d9cVbQfurUL/9hP/JnC3tkdftbOwlK0k/sU5fdGqMjCgxFMy+CcL0wIALhYAAJI+96nHZ1WhPDp7bfb5mVpOwiGWntZaiefrMCoypT7hdhM/BSG+SNAJEDTyhiU9nkTBfbgHT7RoL/wZUaaUKPwZL8zImgcCbUz5FLFjbucnxY5BN5X4b1bzE+xTnNBzl035DMWJ//aafcNf1+7XUZfgd7Lj2zfls2HiPy1nH33iphL/0XXe+pRPd2xReuI/ud3ztAwPlUtjxdLv3n+FAICFBQAAxzMLz5TWLl+qDd9Sfn1fdTEI6EUkDOtNzY+YVt0wJlJesCQQCYJ1rcXTSrTvKS3ihQsGid755QevUvJU0BwczAkV0SbN74cl7J5o0drTSkR7YgeFjZt920v8x+uHlqF/+MNpxfpM+WTKZ+IT7RBfWof+0QOB6FlH88R/653E27VMrpbWxiaKwzPfWOBf9wBig90+AAA9ZGFhYbV8ZnLi2HWXXthXWwxijiDYCV7aFSVEgxIUq+4//EEd5KzNIwIlboASFA5pEWUixzB8UuKLVirsJVBBLB9X/4sVz4UVR+bQTHgq8ftf7dBfBUFbckkQrRO2a8qniuMw1Xj90GRJ4GZ2TUjqhoMS1nyba5iyfmgv+o8abcV5gbEyuft4e7DnsOJfzLt7W9b81D2a0OGarWXiXye2u4l/bS5hnB2Pv1lrSZaWsxeJG9bjADq8ztF3p82dVj/lU29myme7iX8RrXRqQZEW58az67XskjARrWRlcrTszVy+pRz04AsAiAgLAAC2/YWB0+O525deOVI7FwQxnogO0vZ++CRAB0F2GNoo+f/Ze9dmy67rOmzMdW53o99A40mKEig7lkTxAUK0GFUqH5JUpRJXpSqf6J9Ap1IplR58gpTUIilSBEWRgkyJFEU9LCdx0S5/zBfHikpOrFIkoBvgQw9HtiWLBEgQRKMbjUaj+6yRD/Ox1trnnHvPvbeBvo85qtm8WGfvtdfae5/bY4415lxOAWsjtLa9lxSxnwElbLUC0Ho+Er4IPZji24FBKXRxLXlUvheEf25e5XMJP6PGD20A2q7EsYsrbDqtAFFHQ1XcVXLf8zO70CjNLs8YXsH+R4F/sb33/Kwj/HMaPzTq7/ffbvRwY42ec+h2E+Gffm/7zpvwv1As37ioTNttTUV6Zd2Ff4/9NG6xJ7Xg+bEny+7JTuOKW1Llc+x5FP7ZvxitfUGzl576+5KOTlXaiXEPx/iBffskgIwQS3AE3/3qu8793T+49ldIJBIJQ+oBiUTC8M9+/FHOrsxuHv87N/+DNVFGs76AZgQCINU/NS8QgaJJvSSKWoAodmJF1aKfUuDiKNXVYxnDBUB1ogcPLcIRhC4JuPGzVcm+S6TZxvOyymdW+Zy0L6X+0XMf4y3z/HSxXyf898L8+GLsKtlX+mEvFf4X2gXy3Bs37vzr+b/+ubuQSCQSGQAkEgnF//oTnzozv3xVTv9nN/8yqByN0Hv5TiGou4EVrQQEETXr0836epY4rQniTtK39xKhBQl2vG71ZanDwtB7xbcR0EjAq4tqH8gqn7IwzVXGoUXqv9AeNy1u43Bjs8rn6vjBn1T/qmwu/K+g/tOefSTD2LC6E2tdXCIDxL5lIr//c3cikUgcemQAkEgk8Ds/+ct3zi9dLad/8MZfqIEBptALrDy/pfCqxt/rlGrTrywArM5PbBbm5YBoZXJCHxWw395LKkGA1MjBNgAGWFGgSwqwaCGrfK6b7NsIonU+JdCTu8Tu3kb7Ms9PN+ydC/+TkGCIWxi0dSrwL+l8jCvWJu5bUf/1hX8n7l17POohsMTuhP9++lh4z5cK//GKmhlMiubt/MH5jAESicOODAASicOO3/2pXz09f/5yOfWW61/VYj7SEXelEbp9r+7da1X5USorxLbrUrqvf7TKJ9QaxFhAoH/qAYDYwYAuI6CwBE2xCETHgFJ78jql/oPw3zukgW0J/5t5frRPDNTzgFX55CBgdxR/c8+Pnc7xcSwI/EPnr16Vz21p9i1Y3YnwH/f59lT5bCPhQrjS7nmwfz29okAAkT/42dwcIJE41MgAIJE41PjiTz921/yFq+XON738VEFP6E3Cd+pgTh6xrAASQgGrbe+lFh1x6qMLAqrxBxlVmlLhvn8tJGprC4LJagNAzwEgIX48pux/lfDfBNGs8mmMnNiN8N/HD+jYaht8176G5wd+axe0+WlkYiPpHkpPlzFpnxL3gS5zvEsLwv++qvLZgp9Nhf9++gQghZW18t98JPMBEonDiwwAEonDi9/6qcdO1xcuzc4+dP0rxQhpuH3CkQ9Rmg41+VhswJat6zv4WrKvkEK378O39xIafa/SbEIVXi/IjtcCoNoDzCYkAhIsFdC9Agbqv0QQFSe6t0D4bxHCFsL/8vhhk5BgVHZH4h6HbWIo8vjhlgj/PfVfU/gfqf/C0gRN+R4o8o6E/wiTImLZsfDfU3+/+kJ5osa2F+OHoZPlVT6HF2OHnp8hquyf0dqen7i3i+8zgHklSoHM/s3PnUIikTiUyAAgkTik+OJPPXZnvXylnPnhV76yAZP0K9AoBWH7cIXurn4egDWKAkVuQPP20N078ORgsFBoyQDWf6kVEJBFCJZCciwK5AxJo4sqtUTOAHArhH9jlsu8E8uTfUc+N1D/dqEthf9tJPveEuHfl1+GkTh9n7L/zYX/vvM2+Enn20/23UL4X0L9+/ZXq8qntndT8Ol4/LBDzV47WFLlczF+WNLe7u34PrdpLhP++wmKyJwACoRS8IcfPo1EInH4kAFAInEY8cWf/vyZ+XOXy+m3vvL1I7gZ/IwM7VZYTfUnREL496JAWoidBCiwKp8FAnft6yqBQH1E9KrtnhKgzn50cYJdTgCWSkiRSoouAmgPJQoBrRb+R+qPoFBL2P/Wwv9A6w9HlU+9t8Owd5fsa8R9p8L/pJ2hfO9U+O+pf/Tcx3jLPD+CvV3lM17yBepvHS28XagUmaFCMJP/+4MnkUgkDhkyAEgkDh0+/77P33nz0hW58y3XLxzBTadohUKl5prsq3K7klCz5lcBhGJ5AhBWiFTQFwoiJNBjqsUJuixAWx+Q5jIyZg8AxdKOAT+mggVELX3njYMusp+p8j22d+RvlWafVT7j05XCf98+3qVtC/899R8it7WE/6zyGasKxHrC/yQmJARHROaYAX/w4YwBEonDhQwAEonDhS+979dOzl+4NLvrbS8/eZSvOFk3Jw8B1KDs2qJJvablA1GbHxCgClWhR+Mx4eRxshJZxQjhv/peAazSHaOFhrSdkCgKBKBUUFgWBM4lwn9P/bGZZt915XWHsspnN+ydC/+TkGAgoAzaOhX4l3Q+xhVrE/etqP/6wr8T9649HvUQWO5S+O+nPwRgOxH+OQROKzxsBChyRHCDcrPM/vhDx5BIJA4NMgBIJA4RPveTXziH5186cuaHrj11B24YZ/K8WxFRI36r2S9iHB3wfADXDmnEqKvmCUa6sJEPp1+WHqBhQ2nunSb8iwcPet1S6QFACy08LMESgp5VPsfYYJy+hwRtgh3FX1iUGLivnc7u3g53wznu4HTqBP61PT9NEQcG/tpPJ6t89p3vSPifxBWVmM82BJSZ/NEHMgZIJA4LMgBIJA4Lfv0nvngGz1+Ssw/dfOq4XAuVzX7WAAAgAElEQVSzvnNrmB1fzf1G8d0d1LO95u1RzqRitrt3YGsCcO5O3x2MnjcMq/PThH+VSCuEVSzqMK4jFRDvllZyFOgE0azyaYyc2I3w38cPbWqbCP9beH7gt3ZBm59GJnB6uhg/jJ1nlc9++msI/zHNZW6i1l4pOFpwc17q/P/52cwJTiQOBTIASCQOBX79PV88O3/+Bd71Vl64gy9DNMW2KAmrllwbXERpt0n1CFuOxwlWIMi1RvYav1gkACC28eriB4Bi6wZO/fUqvvVY7CpgDK/SKwtJRCNEsJzdCf8tQthC+F8eP2wSEozi60jc47BNDEUeP2SVzwXivrVmj16bXxGZLIsfhk72a5XPgf1PvxGt87GdIrN6o3IGlj86fwcSicRBRwYAicTBxxfe84XTfOEFueutNy4cx8uVhBf1dwlfBm5Et+9bsm+n5RNEEVGjP3WvAGj90NHb08w/BEsB6X4M3w2A0FqElYUVLCKt8H+prCJmKNJ4Q0OCMAtllc++fTISp+9T9r+58N933gY/6Xz7yb5bCP9LqH/fnlU+pwL/Djw/Xc/LPWz6nsscLCiCf/szGQMkEgccGQAkEgccX3zvF0/V5y/L2R+ef+UEX6pKosW34MVQpcdZOySq7tC394L9EduuS+t+sq8XFBWEogBohVB3A6gwN7UuLJRCErTFgUqRIrEFmNguARZ1mNeIoHgFUowUagn731r4H2h9Vvnc0vPToovWbsQdK9n/5sL/pJ2hfO9U+O+pf/Tcx3gLY4vYDxPhf0qgdy38t+glhr1N4X/9Kp9rCv9+n60HCGaVN4la8ae5DpBIHGhkAJBIHGT82nt+4y5eerHc9YM3LpzANXXylHDsAEQB2Nv0jcSE8N8VBTLhlFKNkffZAqgQYSsSyo6rWVqwnwhNM6jK6b1kkMQASnQOsydZ+aAqsEJAmwv/yzX7rPIZn64U/vv28S5tW/jvqX8XmQBrCf9Z5TNWFYidCv899V8ayrJr16OqgDcqCgTyJz+bOcGJxIFFBgCJxIHFb73/N07Mn/8u7nrb/MnjfInKU1pBnkKhu3os5RegV/kUiLCCvr0XPDaog5OnI3x2TIGm8yrVqLY4gHCDKB+iELrxsMYehUJhqQSk0OINXYIgUQgISxVYtrFTf0yJe0900BFEDiRsWfzQOllK8b3HVWb9Bc2eAwPrvD3LJFhZsOUMMvzWwj+d+27l+emGvXPhfxISDASUQVunAv+Szse4Ym3ivhX1X1/4d+LetcejHgLLCHJ2Jvz3019K0KeB2WbCP4fAaVjHGJ/jesJ/e7VsmsQcBAg8njFAInFAkQFAInEw8Zsf+PyZ+aUXy7kfeOXx47heCUHU8RQjEO66AYD2KSNCQJfUKwBFqDv+Ar75FwiQRQC4Wb8SAGIHX6hxyHtmFYgo0a9w7gUBNJdA4xCp6kqiCKTq6W0z4KzyOU7fQ4I2wY7iLyxKDNzXTm/3E0R/N5zjDk6nTuBf2/PTFHH9OfhrP52s8tl3fiuE/0mIu0r47z1stnJVK8sMMnviQ8kTEokDiPxiJxIHEL/xk79ytrx45cjdb3rl4jFeU3KvDNuUdf9Zif4ompLVduBCkBh4Oq9nAsDpnbJzRKVOMHKICbfsS19mtFRotzYApfgaLfhyAarxKrEiRdoboPHDKM0OhIYLhKaJr1sZh9qJOxL+J16gkXquJ/yv9vyA2I3w38cPbWqbCP9beH7gt3ZBm59GJnB6uhg/jJ1nlc9++msI/zHNZW6ixbhljFrHt6uPK+wUITkjyCIXP5hUIZE4aMhvdSJx0PBb733s1PzSJZ59C75+VK6D8E2+oDU0bW/dKhAxShGOHRqR0u29PAAw6g8v3l+93VlUhASonhOscn7xnoO4m/NHK5CKsAoiAECw/FBnNUvYQhTfNQwD+csqn9G+tvA/Uv9Rs/cAycTpJcR928m+t0T476m/Xz2rfC6++cs9Pxjf8/HJTl9Rmz5RSxGiAI8/kmwhkThQyK90InGg8Nvv/+zpevky7nzT/KmjuGmUy3Jt+2RfY//V2WKU7ontvQBTVt2R7/YbCwkExm6sQn9kAlhqL6FVPklrIYP0aPJBiUiAXkJUhX9CCswmRLTk4CFy0Akv805klc+s8qnt3RR8Oh4/7FCz389VPpdR//EVilW17n0uQCVIXPxwEoZE4uAgv8+JxMHBb733M2d4+crs7A/f/OoGb2olH5jxBs7a9V96JdYwf041lV2LAsElf7PfqHtHhvRf/VQpToWw2jFgqYRY4f/SrqUyvxnyBZYJILB6o4UkfekAaLuPAag1LEBiqxlrCP8Drc8qn1t6flp00dqNuGMl+99c+J+0M5TvnQr/PfWPnvsYb2FsEfthIvxPCfSuhf8WvcSwtyn8v+pVPmOymwj/k1BWD9Nve8ET6QVKJA4K8sucSBwQfOm9nznLFy7L2TfPv7YhN7Q8f8fGpBXZhKrscKLvhYBM4ydFUC1UqGiZAErQxRcQlH5V0hJ/WWL1QLTKJ5oXCJoWTGqZID2YtvWvHVwBy1Quuk0B9ELdRsVLFF8EDc0qn4v8cnlc4XPdhfDfU/8uMgHWEv6zyqfHfrsQ/nvqvzSUZde+NfWHLQgMA/ZhS4FuIXIxc4ITiQOB/CYnEgcBv/v+Xzo1v3xJ7npL/coG5k6XlcMFtTIlHkBVwmEsX5pG694GmG9HRXfAjwlvD9XbU03Rp/F+dRw5WaewiMUGIFBIipUJ0mhB635KJYSlArZDmQgrfHFASEGJnmFGJqAjiBxI2DKhFAiWAyxSfO9xlVl/QbPnwMA6b88yCVYWbDmDDL+18E/nvlt5frphDwR9csXNhf9JSDAQUAZtnQr8Szof44q1iftW1H994d+Je9cej7o9jsNV5XN6l7BU+J/Af4dABBcyHyCR2P/Ir3Eise/xu+999DQuXyl3vunGV2emHRdV7cKaDwgoVYTqTVE7kBcFgu34W1C1fKezNwh8Ky4Jcz8AWpF+NwVJkJtW+N+9/l7rswsz9Oqj8D+sKkT8oFsBoFRQVx68EugglALOwHYm/HfUfwmF6k+fULEVwn8fP2BCoBG8dqU2P8rMzfPTJthR/IVFiYH72umNIILo74Zz3EEebtx3fc9PU8T15+Cv/XSyymff+a0Q/ich7k6F/9a+GXQqBAQXMwZIJPY58jucSOxv/N4HPnlqfvkyzr4JX5/Vqsm+6Lb3UgpECoiqTL5tzgWtC2Ql/OEWIDf8OIkXOKEHQHX8i2/g5fSxooh1CE/57VcPBAhC3+0SQKmA7f7rF60iMOEfoK4huJtIohhRVvmcrCpMCTQ2Ef638PzAb+2CNj+NTOD0dDF+GDvPKp/99NcQ/mOay9xEi3HLGLWOb1cfV/SD3FL4n0LDbeY6QCKx75Ff4ERiH+N/f9/HT+LKC+XOH7rx9SI9fxL49l70f7OrM364t0eZAkVUiW9MhWTP2t1/L8bpJQr5G/nrswI8ZqhKYqqdLtYPoipRJaTrHJBaYasWUkgISpXKqoxf9yOLzYCnyb7AJsJ/E0S3pv4wCpVVPtcR/iNMiohlx8J/T/396lnlc3gllgr/wzS3IfxzMVRbB7qAmOsAicR+R357E4n9in/x3o8cx9XLcvYH+GdBWWLHrkj2BcECEqy6g2/QejSKTyvlicYRlaLZpr8kNXKoMAGeGkuIpQYCBZoxjKnwT0R6se4AYMQltvfCkOxbCA8DAFQlKKIFhai5B7UATnp6fjZleE6J0MvGmwv/20j2vSXCv9HBCT+ziUzZ/+bCf995G/yk8+0n+24h/C+h/n17VvmcCvx7rcondoBYBwAuZE5wIrE/kV/dRGL/4fz58/ffmN89v17mp/6O/Dv1ygMC2z9L4HYdI+vVfP/VG6FkmvCE2kb6db/ePmOYKErENSQggVJIWgl/1YOtbk+pys9c+EdbEwAgFSJq6SmWcCwh/EMNRSIiFZoeANGYAcU3Cbac4Kzy2V2xKeXoyWiMakJeu3Yj7ljJ/jcX/iftDOV7p8J/T/2j5z7GWxhbxH6YCP9TAr1r4b9FLzHsbQr/e7PK585BXCFeJJ6ZA+eTSyQS+wz5pU0k9hk+9z9/bnbyu8+cnD907ZUH+TcAml3Ht/dyKh87+E5YXUG1s4yjm4nby/arcChtNwCl3e7gFwiqVhASEV0W0IM9oogqn3rp6iV9wFJb5zqw0u3vW3S0tc821gETVgxUuhyAldQ/q3yO09y+8N9T/y4yAVYK/8N0JmnHWeVzT1f53AUuvILvP4FzZ/H4P0o6kUjsJ+Q3NpHYT/jCT3/heH3hyvWTbzz9H16Hp5W+s4oY25be5G20G4hvOrsCnYBZ7ZVDxL4BUQmUEDZtXjDU4lRRX6Qo7/f9gwk2Kg+LJdTubyGBVNpI1EGk+wSrYalqTrAAbZwwu5EXCa2t86zymVU+jbh37fGou0WVXQv//fSXEvRpYLaZ8M8hcBrWMcbnuJ7w314tneaOqnzuBuVuyEs4QvzRTyWjSCT2DfLrmkjsG/zmx/7xiZdevHL9rgeP/Pm9/JZ4lU9xww/pfh76trvw2vz6b785c0ybr0oddN3AMwcqnFt4KaGKdokQ/i2KsDr97OIKU/cFo2bfPDzKitzV49WBUKX6McLiqwr0GkReXAie2LC+8N9R/yUUqj99QsVWCP99/IAJgUbw2pXa/CgzN89PXLGn+AuLEgP3tdMbQQTR3w3nuIM83Ljv+p6fpojrz8FfJ9MZR5JVPvdTlc+dQgTHjuHGDZB4/ANJKhKJ/YH8riYS+wO//sivny3Pv3THme+/8ud3yfMgKQVV82iV+hPKqt3/A0rkgxoJaAQ96Je5dBirB9AqnyLoy/wjNgw215A5iIyZ+bpBZAXYAXCWzzYMadGFFLhPySMWjWEKRVgBCgvgOwBUwlIIpPT6rlIiYJGHrWhfSv1HL9BIPdcT/ld7fkDsRvjv44c2tU2E/y08P3Z8VvmcOmq26mR4PeyjHQr/Mc1lbqLFuGWMWieOsi6u6Af5qgr/ExStNFBw4f3JKxKJfYD8oiYS+wCfe//nzsqlK+XcD9Unz8plc883Iu7W/GbWVx1d/+3XFN7O/6OiIN0dxLYtQBhvAKlOYjhW+dREXmUb7jIi4OYcEhQt4xPxgNX+t6UGiyIswde3HK4RNohbiQhBqUKg+JoGadsDd4WA0ATRrak/jEJllc91hP/hhqwS/rPKZz9CfzMwfLRU+N92sm//LLonO31FseAFeg0gAGfATZSKx38mqUUisdeR39JEYq/jix969FS9+t1631vkiTO4ZoI6RYQuu06Ff90J2NR99+qEKUjJGbpMACPWLYUXBFqBIEZ9zwJAWb6gVHhQIVFBSGMD71zr+Xj8UM2tBKDFG37dWFiwTAAWXXAoFJJWh5QAWSiAjWcQRHtWtEL430ay7y0R/o0OTviZUdIp+99c+O87b4OfdL79ZN8thP8lnp++Pat8TgX+21vl0wb/Ggr/PUjMKlggs/QCJRJ7HfkVTST2NH77A586JZculbNv5tfuqK/4v+gFFCWiRuPo+2c1lbh0rh6NB7qiQOG08TjB6D6FhJRCVraiQIh9uABCCqsm/gqsnD+c21kAoL7/SqCrF6RrDiJSSS8hWqpyKVs0oCX7olSxKIICVgIFZhMSFjFStR3hf7k0OyHuje+O1L+xzNZJY5ZL2f+iwL9a+O+p/zDs3SX7IqxfuxD+o52hfO9U+O+pf/Tca/DLPD8miE+E/ymB3rXw36KXGPY2hf+DVuVzZyDKDKwA8URuEZBI7GHk9zOR2Lv4J4985DSvXuI9PyxPHZGbUNO8ESghwKo2ejf3B6OqEiZ752T0uvtuzhHjam7Raao8RP8Jl2pU26p8glHus9uuS5XytjgAzSQmwSooUvv6pLAqn1FcSM39QlR6DwDFoxeiAoB6fjyuEPENwpZJs4vsP6t8bkr9u8gEWCn8D9NZkezb3zGOd2lz4X9l/OBPyu/eNoX/Rv2nPftIhrFhdSfWOiHcuxH+e+q/NJRl17419QdejSqfO4MQ+qW/+MHkGInEHkV+OROJPYp/9qHzJ3nleZz9YfzZTHV6I+uAeWyohfONxIgV2xGAkWLbKL6V09F6PvQ4gebyL3AK2NYNWm6AUCC9y8j2FNNLlwoWL/yvRX7M0sOoCKQWIICi+wrbqoKtPKjwrwWL2kUre5InbgHSMXT7l23m+Vml2XNgYJ23Zy3PTyOI1vmUQE+Efzr33crz0w1758L/JCQYCCiDtk4F/iWdj3HF2sR9K+q/vvDvxL1rj0fdHkdW+bz9wv8C6PsO5jpAIrE3kd/MRGLP4ctf/vLsmW8ee/G5F6/OfhB/rqX03bhstNs4sXv6zZBTRay4vplnzAik5JjScTULA1q2rh8DSG1Cox0mZulRIuKufV83UD4FkapjYxxTCIhmCTeTkkUjLIWkVPP0N+OQCf/SVjzMDlRIus2pYBn1X0KhMLD/gYqtEP77+AETAo3gtSu1+VFmbp6fuGJP8RcWJQbua6c3ggiim44L/KM83An8a3t+miKuPwd/nUxnHElW+TwMVT53CEKAGTGruKPiD87vseElEoce+Z1MJPYWPnX+U687haPf9+CxJ//0+/AfYUVvjA0LQLfUkyQLBHBtHhBhMYZEYQGrb7PlmjcRwr/vABCLCcH40XEyaMKxbuClpX5C+Ic4Eddzq/5tUYpAB6wbhOluvhYY6MHKfWyCE+GfFKFUrUYKgG7+iUyAbQr/Ey/QSD3XE/5Xe35A7Eb47+MHYCR/S4X/LTw/dnxW+Zw6arbqZHg9sCvhP6a5zE20GLeMUevEUdbFFf0g96DwPwVx9gZeEsyJxzMGSCT2EvILmUjsIXzpw5/ckKvfnp1+2yt/fd/s28p6KWqqUTLtzn5COQShVT5Ft/RyTg9WNdPbbr6aqNuouVp0IBVu1xVN5zUWbrytSgsJCJh7p50OL/UDdfZb3c8Q/j04CXJvn1awMPxI0jn7UQhopVGPc+Dxg4UWVQnighciQoJRfB2Jexy2QlXt44dDUuVzC+E/q3z2I/Q3A8NHS4X/bST7Tl7F8clOX9FFL9CeBlFuoM6AGS48sudHm0gcGuS3MZHYK/ji+U+dmV96kWfeyL86J88bF68uddsPfRaskt2iJnvnEwIIq4v96LIC6uCfUaZl5KwVBYLV8rdFgEICRVzFN4uOBRs2HvPlW1F/aJyAdkwQdwjAygJS1AsU7a766+bBEKvzY9ctQlo6spmClMmtFviXtvfU/5YI/0YHJ/zMKOmU/W8u/Pedt8FPOt9+su8Wwv8S6t+3Z5XPqcB/mKt87hjUoIxAxcXcIiCR2BvIr2IisSfwhUcevXN26fLsrh+6+dVT8hKdzhBFSb9TBOn89wgZvlM3g6wXBAWsYtSnK+ljFT+ltI11w+JfATXedHkCyuZF2bwIfAC1AhB64oEUS/aFLx1oZU+4kydYsjJ+jTeIAkG1/Q0s2RdEVeFf4OxfMClPNAqlU2l2Qtwb3x2pf2OZrZPGLJey/0WBf7Xw31N/9ORvd8m+9nR2KvxP2pvyvVPhv6f+0XOvwS/z/JggPhH+pwR618J/i15i2NsU/rPK525AAHNAICXXARKJPYH8HiYStx+/8zMfOcUXn6v3vG3jwh24EYVxnLgojbZy+5b/alV3jGMSqr4L3Iiv0rsRccvHJbTcPqCF/OE02kz8rRio9uoCvK8kQDTZwCIBXROo7lNChCXu3tHO1bFDX8HQXcmgwn+FLkpU38kYEEZIAFTdA7hAQyBY0nPbDHi7wn9W+VxD+M8qnx777UL476n/pOethP/xKbcnS0wGvK9g6wAAgIsZAyQStxv5JUwkbjP+t0ceOVleel7OvQVfm5W5kR4Ba3HNU6yFwmosHIBv3QXjzcbyQRSQlCLVFhCM05vCWSxCMMc/QN8TgIAuCGi0EKsNEPGC/ZaOHFf0IkIQ6vBYRGwLMCsWZMI/BUWtQaUKwTi9FSwSWiRQPXhwuk9WiOcSePBTVmv2HBhY5+1Zy/MzyvBbC/907ruV5wcDr80qn0bcu3b43+1xZJXP/Sv8L0JvrAgu5BYBicRtRX4DE4nbhvPvPv/Aqet3HXlpPjv5po2/BARSXYA38V5JA52yh1kfSk20nqaIMLbUhbqAiohza3H+jToHUEy/h5J7IKT9lgSsnRAtKwC6vZc7f5opCGFEcX8RdDClVHJIXSgaSBSihsAfbn6yCFmt4Gn7gyo0PiewRIJSBaiuIk/p8hbCf+/AwYRAI3jtSm1+lJmb5yeu2FP8hUWJgfva6Y0gguim4wL/KA93Av/anp+miOvPwV/76WxLs48rTth/VvlEd2876j9Mc3vCf2s/ACAhBdiAbEBO4PF/dEDmlUjsO+R3L5G4Pfjl85848dLlZy4de/iByw+WvzbObYRGICIVbs4RVhU6SxhyAFHuSE+fbQypRnFPd9GARGGloFRCE3DRVfmEWPZtBTw2KASFXkrIrUSxGxeayQcm4dsYVKTvvEPiJ+oxVVcSAEszsElJMyPpIoAm+1qgImYH8qwAWNyCgV43TjxSz/WE/9WeHxC7Ef77+AEYyd9S4X8Lz0/IqAva/DQygdPTxfhh7DyrfPbTX0P4j2kucxOtXBBYKvz3cUU/yIMk/E8ggNyN+gL4Ei6eP2izSyT2BfKLl0jcBjx2/tGzuPQcTr+1/vt7y3MweucBgNX0hDPd0shEuO1rsa+v75yl7Fla4U44ty5GXKqKbxYtiFhycAj/dKqoPcAHEx4e3Q1ATxHxsamTp0ULvhlwdIsCmwWpnv6OpWkmAEp4gTyK0CRgDzMAdCFB+KAWiHuwpRWqqhNEPeQWCP899V9T+B+p/6jZu2yMWyH8Dzdkd8J/T/396lnlc3gllgr/PfXvn0X3ZKevKBa8QAcVfAWcgcBTWRookXjNkd+6ROK1xhfPf/wUXngWdz+Mr5yWF43WN8MPYT4fITHo4lZgRQir7g+wRjkgSkVRxhGKvrUHMYKgX0bwkj6ks0MtDWS5BE3q9nyDnnz7fxrF17Rd1ipuBLJ9u/qMhUqfmpPXShG3AIGopYDKPmWyGTAb+x83A84qn6uE/yWen749q3xOBf6s8vmaQjC/CSmQgouZEpBIvLbIr1wi8Zri937uZ07ixefk3rfJhTtwk+GrMeoUVMxpt+UEG/3V2ADNZkNz2FdlDMUDCRCaMVy0KKf7/qlVPru9urQreiqwFv4v0I29BJZ2jBYbVCGq1fvXjGHlMcrpNVuAgG8bXISovTVIVNpHbxkCpHqMocI/RCqLWEhADgeX8A6h59aN747Uv7FMvXkjs1zK/hcF/tXCf0/90ZO/3SX7GnHfnfAf7U353qnw31P/6LnX4Jd5fkwQnwj/UwK9a+G/RS8x7G0K/1nl83bBihMQFz90iGadSNx25PctkXiNcP78+fvwyjm8dIOn3yxfLeqaMddHAYQCq63Z2FVB7ABgP9i2XxWAa/DKy6Gkn4XCKCFKgCzq2AF0s15dBBAndqUSAqkUkVblE112gXRm/YhMWrQgKu0b7daFCIhel5ACah6CRTVVdEsycddTVx6UMOFfVwzYdgIGbAsw7aqq2gpfBEDPjLPK56LwP0xnknacVT6zyuftBYkXiReJZ+bA+UM3/UTitqDc7gEkEocCj57/3H2o38bRDWy8bfbUbEaXBoMEmIhI0gmr/kNIjrQGgkrSDgasE2MPcE5SNR6AQJSiuynf6QVFCFRl7aHQi13SPELmODLjSluO8CspW9JhaztFVHRuLZ2Lg0DYJGIY2rOyJe+5T0sQSEERm06R6j4enY6I7xxMQGDhhNqKOneTdWiLFRFoLRB0Bhnu6DKE/iDo03RLUj9Niavb1CTuobSoQLyeqY8Tk/YWF4HwCcKzNSwQsE+DBOstpHQTnAj5gN+lpcRd75jFn/1IoM9U0MI2v5/6ZDV0nLTrdOD54j4wdPdfXB3nZuyfngseU9Npdj1Ez2i32l8Pe9G6RxOD8YT7eBA2fdqAbWot9uueYyf8dwPznwkO77PHbEvZv33n/aKHDyI4XfDMHA8ewds+xa1PSCQSu8Zh/F2TSLzG+NWPfPwUrz3LBx7Ckw/MnkFfmrMZpt36AtqCABC6ONzbE7GBseHIClBWR1EnjxfPKUqfjVCaU1+gqb0VCCOQV94E4FV6PKqQtm8AgwDRmUr1tN2gQVZ6SKxsf/A/Cru6RgLUuAkAfdMA+lZloFT/CL4WoYTbMomLTQSj8N87cNBz3M2F/wXNvlPWB2m29/Zg4Yq958dOHwn3gn9m7DyrfPbUf5h4N02PebLK5wHD/AhwA1Lx5IfzhiQSry7yO5ZIvLr4wkc+cgaXv4NzD+HPzpYX4BtgwbkyAC3c2XbwraS5aJzjsknXqOYIMrpsNM/cOIxSQsqQ2JfwL6GzmqFfindiNp7QOKtqp0rKaxswg5GjFRJ1iz+IljNgSQW2Y0A7TDOVrRJoxA+Q6kGLaO0ji1is+ieLsGrGsPmgUFx17rkver7LrPLZt0+J+0CXOd6lYMBLqf9ygt5T/CknXkL9vd3/GVoi/O/IODQEPwvEHcgqn3sXVb/5AhFcyN2CE4lXE/kFSyReRfzTj77/BK4+y/veXp66g9cRtXRc/KPV7bHi+kqc2BUFglFDZ9ixbmDuBTRTR4QEYlo7jKNLbMqrHAVjQq0TPqFHCwSEUgXQfrqaQtqJVBf1EVGHgKxh+dCra9lQ3wushuOCbfp2DIW6T3BtVg13whRWQBDZzDZsTVAeVVUniAAWSN5S9r+V8N9T/zWF/5H6j5q9y8a4FcK/hRy3Qvjvqb9fPat8Dq/EUuG/TVPfrnWF/0NR5XM30EdwMWOAROJVQ367EolXBZ85/5m78NzpcvmaHH+zfF2l/khsdQUdCA+3SKPyTrulE/5ZVVbOxfYAACAASURBVHPWNF8TZim6Ua7Akm6dmuguAeqiKVZhU/lH7TxFRneqsO3468nBfunGxZXE1CDx0FRgK9/ZJtXZ9y3qGLYThq8SaCEgTfntSgAJim9fYHcMFZphXFrcUksV+kbFOxT+jQ5O+JlR0in731z47zuPrjjpfPvJvlsI/0uof9+eVT6nAn9W+dwvIFArWDGv+Pr5vFGJxK1HJgEnErcej33sk3eV557H3Ru88bbytZm2SjBLZ55BLi3zUp3udIUSLfHUlEaJhQExFmItltIqfrCAaBmZ5mL3q6AoF3E5s6eA7vtRLmdXt54ZrLTCHf/Kimy0kOhcW0Sa2qo/09iSCvnWT2jP4tmuCB+RViO1dEz7lGDRAXiAJBFvGHPllsK/J/v2GZxK/uw/JVJXY60DnhK6WbKvx2xtmvYnHquMhY9WC/+TpF5Ez5P2pnx3xL3L+Sbs7kV6cTu9TbAl+/rNnyT7ok/29anFe+vDE2nvLRYd//o4BhptkWOf7BuddzfQX4AQ+LtXZUz2jRtu01yS7DsNbzrhv7H/eD20vX9VvGdL9tVLYxD++7sXySrt1VrjF8nhhQBFMK84soF3/AK3PiGRSGwT+TsokbjF+PzP//yZcuU7cu9D9St3zS7Brfy2gy9DQBVfBABdZfdyMTCaa7afIkb14hSjj67Kd1kBkOIpv2z9qM+nuLQpgG0l5tkCYsfYYWE0gi0vVGdglAox4b9CM3F1JMrydGdfL+RvXNmmRoSHhygk6dNswj8LxLYAqz74kGYrC8iq+xnHIOGK/XaE/6k0u6jZNy7OkXfG38viCn8NdiP8956f9YT/YTor6vx0d2Z7wn/fydCO3Qn/zfMz7dlHMowNqzux1onTZjfCf/dkpz1vJfyPT7k9WWIy4MSWEJSKSgjwRKYFJxK3FPmNSiRuJX7v/PtPlKvP8t4fmT15vLxi6mB4ml09FSv4E9m6+rPV8hcniJXm7QHQKK+xf2VvxcuGaid6pG4rVkgKC0WqZx7rXgNmymd4bARAhScM2A8WP1RQ6/2LZhJb4KFeoGYBQrddl23yZYkHBQJUAaR2UYoX8hfdo0BDAoTzx4XqShQUitqiEH3S44olnp9GEPW2LRDo0ZixfrIvBl671PEPjOSP3e/YpSHBQEAZtHU4GLKs8zGuWJu4b0X9u56JLvhZ3N7LiXvXDv+7PQ7ZheN/MX5YStCngVnT7JdR/z5w6q84eY7ReYumus6XJftidPa3wafnZxcgUaiCSaYFJxK3Evl1SiRuDb5w/vxJeemkXH2xnnrz0a9voNI8IQDcqmGqv8veaMTdKaAEoamEF9JRqRusIuaMF+VlLS+WIEuxAqAlNPsg3MbsARX+vSiQhh+wYqOYEWjxA7RKD2w3XzeQKEFkl0ksSvcrK2A+E0YtUZGw+HuOQYUOTymWl/rx5RGNCqpYqANonFPpNYsIiy6UI2aVz0k7ttTs44o7Ev7jPmeVz+5+dvd2eLKtPbFDEBDUipopAYnErUPmACQStwCf/sinj5WXr/IEpDx07CsbqpWbPCpurQmeFGxciYLSEiUfIaMa0+gsyI2raedeK1P7ERGYOQcMdl7FEgNMrm1VdAThz7exiXYTLBaUGGSNgY1O6KbOan6kDGqu8eWBn6FWy1iAhPbf7xKl/2mOb/Tbe+nIRVi6WQ09iOdCmMkeCLM+faKd8N+RPxuAu54muQTRMzrh3/xa8YBiMN02XjqA5rMPVzr6/ct8ey8LlzS6i3SI9hrQVnIaEe/bp8SdPXFnO96t9nDHPyNmk3g9/OkM23v5NP15dNMBu7n7c/GnuUr4H1cPbJpsrxajHdN28dc+7hgkimvpy9y9GJYb07b3gsSoAA+P7aNYgvNvSnef0d3/aGe8dTFNE/6T/d8S+B2dVxw5gh99lFudkEgktkb+YkokdovPf/TnT8mVb9XXPVQu3jf7jpEPKoE2F7sSeFbn1m3/LCUTbv6h7gZgIYIXBVJ2AtAVdFLUBgNhpe/0WyhauNOq7lTCg3y7CquwmGmHAtRSCUGJFAJ4sU7qhlx2ITUIBZ8zOd96rmBXZpRRz0ev6M4l+j2pFClSnQlq7oHRRF9nMO5LbSk2KkFFQYXXCi9V7wl2Lvy39rWFf/R0dlgQcMX3Fgn/RnM2F/6zymc/QiLu7VbCf1b53H8gceQI5nMAeOKDeW8TiV0hv0KJxK7wTz76vpNy9Vne9/DGhePlulgaKwhBBZpVhk6/RD9qAYDb6KVTZ51MlFbR3yzyTu8ItG28IFrf04wxupGWl920s3wnLwGDfBOdEcj3KKD4Vl9FJtTfk3oRXiALCTyBQbyyDUze9j3CCklLMzAJuVBItAlqyi9KIUViCgAjihCwlkoWyxIuVXyai9TfQwJM+JlR0in7X3T8L40fssrn0vZhanbHBk5Mi7D8ipNOpvHDkvZ2b5cQd2Knnp+u56zyuT8gAs0IuvihvMOJxM6R359EYod47LHH7rz+zKn55RdvnHjrxldnpYrT8SG1F8qDrcBhx/udOekSgeX76onmeRCt1q9WHMvZFdP4RblUERGS8DRfjzecaVF6Gi2UKrQdA2yRwRX0rihQhSixFhSCGtJUTfYVS9IVt+lXyyHWVQjX8k3R92Mq0LdDgFJBtJ0K9LoAdNsvo/g6Zd0LjKKCa2wPLCxie4FhZP+LAv9q4b+n/lhX+AfGuILd79Jm/mny8LaF/0l7U753Kvz31D967jX4hbH59L0TWYwrbpHw36KXGPY2hf8F6g9/GyfsfxvCP7se2guwifCf1P+1gRquClDAgqfem3c7kdgJMgcgkdgJPvfRj9517ZuXjj2wcfPaw0ef3FA3CgCAMIM6wjcvpvdGjXwaW4Z4AU3CMgX0Bz2/MmghzGrsIqWTFZJmQfbOjTQaiTEDtPr70aRKeL/i2mXjPZYcoETP/3iGQBDKAgKV8ERfmz+jP6PRpLqaRnqtBum4V+HSVhXWcicAFI+UbNIeQpjjXM8dHP/uROod7QJIiw3E/eIirsQbQWzn0p9Fb/i2v4GRoC+yf+sh3Odw33mz2sd9E2Jw/MOn09ZbvOdluQTwnnv2H2/QcuG/zyWgRW3ejtbu8Ulz/DeK7CNvU7P70/2R2LbCl4xiavbtsHZpPWB4Cj4YAJ3HbJzmcuHfzfrSHP/trWjDi/e8c/zHNInICkC8Tl3Pw/ST/b9msP0qwALM8dAv8nYPKJHYl8hfVYnEtvHbH3vPKXnp2/V1D80unt24Aks69CqfTRxVUgXASmQayVBiUZWvFFCqy6th6XHyB/EkgSj4Y9RQwsADO170GOWjhYQUNdgUHZud5ZYbo1+EGYdiocAWHHRxwKoPmfBfmzvfyphqvoGX/VHK7Oxc8xkaUyRFROuWFk9Hhgn/bRtjodU+KpqNUAmrQNo5kcJ6pMPOKp8dJ55McPT8rC/8W1DXt8P/boQ7q3ym8H+7UAEU9Q7iQtqBEoltIr8zicQ28IkPfOLeY5fObFy5KifefvRrG5g7VzY2rKQsaixqSKACYVfr049hbM4KBOm3sEGcdLQqn1CyDiN8EjSabG4ZJ/S+p5in2KoXSLSSiRV4sXRb3zgMRJWiWcXS7PuWxyxENceRkLAynVVFbs0q9nwDEVRdHBB4t4jsiG6fMr8hjcpbbFAEVaVuAFIpIqWSQIk9wrSYqbA09tZxO4yeHwRv6yj+ZFFiQv3t9EYQXW4fCPrYeVb57Kn/GFe0aQ6RyZL2WN1aCFfaPd+Z438V9R+mudzx393b4cm29sRrD33/KrNCaCKxbaQFKJFYF7/x8Y+/7vjzz16/89is/uixJzfkplMkwOm6EyHztwhgxpv41HMHe6MFGvuH9SXGMghnZILmIBKgnQ7CpHzY6Sju5DH6q3v46qciHV0RAtV6AAWsVYo1NisRbIBKvtjkYf2r52f6sZ5uM2LvY3EfiBRY7IS4exKfdkyuGTPCgTPx/DjJm9LlrPKJrPJpL7l3Jd0XNTw/7T5nlc99BrF3AfOK2Qxv+yi3PieRSADIFYBEYk381iceOSNXvltf94Ny4e4jl5xuR/VMmKPGFgSUKHTLAkqOa3COUFJD+OzycV2Itn7MoqPBwHRXYML9x0HOVOwnfbesUNahBUOtGqnu2isF5lxChYgtKSg9V3MOAMstFimVPmCT/KVjgRJOJy34U5Vm1WZSr8XWCghQNwQotrYA2x7YiL6g1BYXlZgmm2HJVidG2XgQ/lv72sI/0H06LAi44nuLhH9/gzYV/rPKZz9CIu5t99FS4T+rfB4uEKhziKBI2oESibWQ35NEYgs89n88dvqZ75y+eunyi6fevnHhqNxU9iCV4cj3mjwCQOvSuLfHiKA0mdlsMGIEPfxC5ggyFh4LBSxd50KTZgGWqgdUY7VW5weNCDarfYUbkNSlo//pVXp6s77WEo3owkkbMTMeyeJjMwoOSpUi5uw39lbdFGT2JLEjdQ8vVqkCZ72x8bDQ8yJM0PUheYyhJMyPt3qjoNguCkBMfMr+Fx3/3d/oCGLPa4Ge/I2m/IX2JdQfo/neIxMbyTLq37dnlc9xmjvy/HQ9Z5XPAw59MMeP4/hxnLsb//wf5gNKJDZDWoASic3wmU995MzfPH3lgXvkyvydR/7fo3IjGEpPcQK0ejUqxnftgC0JeGONn8TtJRoC+PFGmsX/E+idPBR6hcYQMs2A48crY46ujH02ywTAAjc4QB0jkGJzIt1oJKF5E2gyvF5CWj1T40k+7MYdi/qOzIBRSfOlBK0XL64S8jx7odrunoU3On1Q9VkWiclqez+wzriiQ/OgIowlQOcM6SMNtNPdamKP0g1IFoGsFv6bt2cIpTBtb8p3R9zZmV7cUBTuo3b61JmD9tSat0cQ03fPz9RSFcOTuIce3gzCvz6OgUbrIWE9GjrvbqC/ACHw+yMQK4QFe7HbDQ8HVLxXffsK4b+x/3jztb3dNG8Pz499Dxv7t5GETah7LVv5oMSegj6Ta9dw7m5842m85Re41RmJxKFG/hZLJFbiSx//4MnZlafLfQ/Xr9175Dth7BHzZAdDgm1H5Umrg6gfThVBpUqIxbV2EJZHC4jmyLqDCLZ/sB2s/761LFvOYWxJJflidu9qiwCROmzEUSixXy8AsBCh2euixAyqpus+A11Sr4U8VWxUFBY9bEZo/nF4n3x7LzuxM+vrjgGePUzbZ0CqCCoqRESqW9X9HkolIEUnVXWFpBP+7WArNjlq9o2Lc+Sd8fcg/Pft7fQdCf+952c94b+NpG8HPArysQ6KONYU/vtOhnbsTvhvnp9pzz6SYWxY3Ym1Tpw2uxH+uyc77Xkr4X98yu3JEpMBJ/YqKjAnZoAILj6SzyuRWI78biQSS/DJT37yLj5/Vq68OD/z8NEnj5WXAej+WSajAlCV1K0ybkFxO0qz+HsMgIquh1BAG09qlXykk1TF6/m4Yt2KjSpNsUqgqOIhgUYCgJRaIWKpqE6sC4SsIQAX8R21ugG7w97GIab6E77j7wzdFsWWOmmbedGyDjS7wNXoGpanfjqUCg8D3IlUreJQ3DexAkEatLjabZsBA7pbWU/7lnp+MPDarPJpxL1rh//daHRW+UzPzz4FAVZUYj7P6kCJxBKkBSiRmOLTHz9/D779vNw14/zHjv/xsXKt40OA+lsA22AL9jMAhAMfzv4BOxjmDUIR96vASzXCiYgTTmmKIwTVuQ7cr1N9dYHKcWlypregamZvI7B9aZTYkQBu+xHEheG+C6NKxjg95NGduIozKyOcQb96Jwli7sr+MRgw9B4xNGhNOHa/CuFbgPXeDy1Y1KYp8SwQho22egCMnh+3ysANSIjIjfoQJwQ92GmTh3vhv5HIrnoPe9+R3fagnt3KRjO99D6l5u0BwvPTtbdpes2oqfBPRA/R3pw53m6en6WZAO3Gmt8sQsHOgQNbCessSd3bbgFqmL78RvU9eKTU7n8M0tqXC/8d+/ezpq9W93ZF1aPl23tJu5/o7rNFmNaenp/9CSFKwXyOjRnentWBEokF5C+1RGLA7378J4/Prv6n+evfefTJuzeeN7ld2W6zmrgFyCmXkvEQRF07D25hQmOru+9nGdVjcbtOVw/UVXzlg6q+E0Bz8gjVj2RapyfvKgusoBSPSIrRI93SyxN2xUR9td+otB8iPcTYZwGtcxunmOrfNhmQAkJ7UJdOUYW+Gier9IRjuzOq2fuozLA0Vj3ykQCxMqD3QdOafW8ySB/PbJ7si6bjrhb+t/D82PFLtPnuimOuQu9HWtZ5yxgGQvj3UGr7np9Vwr9fkT79tT0/7V6tFP637iTauWvhP6a5sCixrD06Xyb894aifpAp/B8MEMAcEEjBhbQDJRId8vuQSBg+8YnzD8h3z8jVF+dnHj7+1AZu0s0zEJFg7cGrICTVuC8IL5DKjaYWQ6TW8PC0KuO920ek2wk46rKHfd80dnHVtrTIwYTq0tOdqsdEeGCyd7EIQbMUKqxyDn0DL6jBSXfgKtU4WreHF0pXxtRyGNSlE34kdxkBxtqb419jgypFNwjQgVUIUKoquO74F3X8W3kiHYlUU5oRj4MxcbHcgKbZTwzfm3l+Wns8IHWDDBQ5q3xuRv19MENkAg9+phR/c+of93Yq/Mfp/cEL3h5Z1h49r+34zyqfBwrUXwkVIDjHxbQDJRIA0gKUSCg+99H3f498+xmeOyHX33niiQ2Zwz08apMJZ8SwCABRYqyMkYAX2HES45SJRpC0J7E9hBpXQwXCkqGqua83wD8BICxBtHQkzlpMs/TPfKMpp63hBiJQOgv7SJeL0rvqLEv1eBsX6aTW/zGFiNb914nrMKTFJ52lRHydBJDirh6RGqsodi1B79iJTrwEkF6DTtB74Z9oinjzhFjPDAtNmywwpdE2AACdG4TdVlPNGRJVemBT86hm4vmxHhDJ0Gg+n+bMMUPRqu29euEfYTRCbz2yKcfw0Jte/EHorYx2v7ovWLV26f/oRMwyE5VtpbuHfveCiNs9n3p77OgF9k+48O93z+9558zx4Xmfo7fHO2p1e9o0Gb4gaU+WbXuv4e4x2f9Bgz5JKeAcmOHhj3OrMxKJQ4H8HZc47Pjyu941f/3JY6fnTx97/TtPPnWqXDUCoVKiK58IjR/uVKGRFronuksFlurcMBYE6AJ1CN6m9fZ6f7SjiCe8Orv1UZl7R2V1O1i3JVV53vb5QjEqEwS0yzw2vhseG81djk2+mv2mAFKrEusCRq2eEvcHKFUgLGT4i3QHMXf4SGE1Bu+ava48eEkfgXZu3BpRoUisKxRfKiFY9Hii5SWr5wfrCv/AqPuy+00Yx3fy8LaF/0n77oV/P6YL2NZM9vVOBtOLU/A2910I/9o+lvrZnvC/4PmxjnYj/LProb0Amwj/6fk58CAguFJxteLpCuRSQOJwI1cAEocav/zLH5v/vTOzb169dubMf3Xmj0/NriofUBHdZX2FUXOX7o1yBulhRymqnxQV9+GHGZy6e2rwhPYBICk1sjCbsBr8Joq+w6ViX4oopnGqcN6kUBNHjRiZyKoytgqlOqdGgAT0LcKMwknVc0n95UHo3sTOvWrVLQJiIcLNISidvguR2jFsvWov/GvAU1261pUF61Y82deUeFOom9i8TPjvPrWLohf+4wF5u8vGS4R/v2+bCf9AJ8MPwv+qZN8thP/e8T8K/1iV7OvxyVT4j1FtLvy3NagIHWNq9u0Ykn19MN1TGIV/oj2LifA/bWcn2y8T/n14oqctFf7RJft2wn/reZh+sv/DAAGBM4KnK75/hnfkRgGJw438ZZc4vPjSoz95anbtG/KGt9cnXn/sWdZQ5ZVSABBT04ds1F7y78RR8VoiEBIF4fKHZbXSKaOzuibJu91fmWtR8du2LtKNAgReGRO+EOHjkdB9x7WIEj+bj1+JINTZD18isPFU67aIm/VpU7A8AWVatV29BJ1Va35bHJDWodr64ZZ9EirbV8t8LZUoLUsYusMxRKpJ+2LZEb6TsRYLqlUgpZLqwfLipLsV/ntlHb02HytCSlvXEP4HKrmu8M/Gg5dRf6wv/OvVs8pneHtGZ38K/4cchZgTEFz8UD73xCFFvvqJw4hPfOYT99dvn5HLL9w88/ePPnWsvOIkzwvwG2VolXxMRXYPNNAycZ24NEZunwo8aRWEFq5BKPaEGG0NWw60So+FBMGH6Em3yoDVzlGlFfyB1SkqGrH0CnQ1yqhnWTX9UMRhumyrCOS+ne50ZYrsu5Kg43q6VFYUcwRZ/q5YwrHHIbGNVziaCBEUkpDSZQyXajdHQN2hTBVci0bsdF+tqCwQVN8iLbivkb9GEF1uHwg60ZG/nSX7ugY9iRN24vmZjmTC/rdpHJKBuHvnA3HflPqPcUWb5hCZLGn3kXAhXGn3fIXw30UOfedL44qO+g/TbKFX/2S7ezs82daeOFSoFSKoFZWoNTcKSBxGpAUocejwa5943xvmf/utct/x+vJ/eeJPjpXrALpgeFwXFmuiV2tc+LQGNdGC/XaUO2TMLKF8TN3+LosCQSLbwSZ+Y+Q3AARiZhMNLUyK9mMEbmTo2CR9PjF250DSXTQInDmFEF2iWEs1l4qTKmm3RqCpAc7Pgop1nh93v9g6RPNmmGGDNsRgtDZE+kTcT9KSfe3iHkrZRIL8Rb5B477hwEGrVrTCmeM17NdI9l2akmvvTOfMmRJ39sSd7Xi24+FGo856JMFfxcOtztuDieen2YS6uS96fvwxjsL/uHpg01yV7Du2i79Accfai+HbI/RGI7tLo+fHX07pvT0WuCCOke4+o7v/0d6SfWOaJvwn+z/EKMV+P9WKjQ08/Ivc+pxE4mAhf/clDhE++clPnpPvnJHLz908+87jF08feYnVuThdFAfgFTwbewvfDp1ZojkZ0BJV3XKgxwQjpAikQim68yECVlzfMoARyrczWuvEPUi2hbBJ4E7m9CM1CBEQd+ZoegGlshQJ4qsF+0U8y7ZqhVNftaiWyAurDQrd8TcoWgFQWSCC2DnY9gQQYqZ1USlQbT72PFaOWCkoljdMxGoDbRUCIKVCBKWCop9qD1LQliBCbBZKYXVv9xLPz6jZu2x8S4T/jnD767FT4T80+y4mzCqfLQAeOl/W7jHumsJ/1vlJdCAww03BfIZXjuL/+/F8KxKHBbkCkDgs+Nyjj7yufOO7vGcDr/w3p//t6Y2rSrIl9Mr4G5rYisZnlP1If1gQj4gNKEDzMXcyvwiqsnHTX71zZSMQFkC8EmhI+CG3w/Vol+u79QSxpEkxo1Ftei1czNbsBkSyL8BqiY8+Q7JqwKDxSBFCI4o5YTp0yMYSPFhCwHZ9V8QWDZRqmdCLagkIYsJwH0FJCT3YlXtKT++aXG37FuizCOG/T/b1+zMsCITZqbHPqfDv4ZZsr8onhiUFuwO98G8i9KbC/4J/Jqt8bqPKJyJd2Nup7zbjDnR3L6t8JiYQoGJjjleO4o5reHtmBicODfKXYOLg48vvelf9nmPHzvKbJx98x9EL5468AIruMDXwFbrrhFEYR3qFnlCxHI30Q5RFs+ukJa16524eMvW3Y0hh3w+vP9ASbakauXTOkPDrVz3eZGOxrb5oxF1oJTKtjicspvF1g1I1xRgCTah1Oigo5vuv6r8HWjazLSCYxs9Sfaa2s5htDWZVSm0idE8/RCt4glYmSFcbqv0ML2ZaAMsW0BRhsFSBoJCoomsdvhCh+cpAl00xaPOD+N21tyBtF8J/tLc4aqfCvx9DdD33GvzC2Fyb9066kInxgrW570L4pwWx3bC3Kfxnlc/E3ocAlTh+AieO49w5/PN/mO9J4oAjVwASBxy/8uh78feOlW9cf/nU8f/65B+eO3JJBemJlu8QU/qdRgAIyRsmfDpx8RKfNf6lYGNCPUMDfJ0BCM7vCmVTuGGqqtIUAEWdQU46G9ehxe70FnMtVXEeJo2QtfG4IFptBlO2BFiA00r59x5rCMjq0/Hb41VIm1cbVg5Ib04Uo4SgNJbpf6BcPKxTVlOySd0aDkj1W7lU+G9SNNp0mvAfz6f5rLBK+Lf2rPKJnVT57BYK9EVaZP+aCOKy/TLh34enL8dmwn9bU5Ks8pnYFfS38csv49w5PPM03vFRbn1OIrGfkb8NEwcZv/Poj5+avfCN+X0/cvTr9x99DpPKPL5PFoxKq0pNK19DYyRQA424q8Y9GCpds5KWlhssWcKnXu1MaX22skJeL18/apZ6+4gsSqBcPDZ+6SNRhd5L+ig7tOHFuoHE7Kz6py1lFIklBXH9PtYxfJcuslCDkFoqCEhl0YQEO7gWCoEZvToQqBeirRVAKorYmkY/X51LLAUQUoJSW6kf/VRaFgH8DpBgyyXwRgBbCf+9so5em0dW+Vwu/PfT37Xwz+4+e/yJxRGuK/wzAtEFZ38K/4mdQ1BuohZIwRMfzNcmcWCRL3fiYOKzv/T+++W5k3Ltuzfv/tGTjx8pczfbNMZPN/Wbt0cFx0rEz8rGGHyokftWM6eKKZVDwdA4RosBucYZ8QNDSKZ/as4Z57tG7yCi2+i6H8aoMHpCLMLKJvpqIm9c1+bbaoAaD9P9Aew/exqtPWuCsqfeQpODNcgpqAIR9RqZ7UcvXQv8/lQRtTDBuL7ysNIIPS2u0PhBoN4ejRaap8iuGPcwQiYWdSUpKaxoidROo4mO/L2KVT67diyn/oZhJBP2n1U+0d3bjvoP05xke2/i+RnbE4n1QaD4e1QK/uR9+QolDiDytU4cQPzup/+Xk+XK384feKj85RuOP03V6E19b86QCACCyrAGWwLcjYNw8Ifw3zIBxEVQrZwDQlB9cSBWFYxsiRnvXUEHoEVsgHCxl8bhUGi2/sgTMLpfImaArVTEvlpeTEb992hFgTQGqIICte+7zC9t1aKq2abYCFkIvS3GyMV2Ana1HgIUcl7RogAAIABJREFULxwU7NNs/d5zhCJFYwbNCkAMKW51295Lh9Hm62GP7mjmP7PAdhBDs3yM2vyiZq9ceYk23xHWrpRTtyCwkDzat0+J+0CXtxL+B4q/Svj3K9rz3Zz6x4KAjXYr4X/rTqJ998J/THMhMlnWHp0vE/77uKIfZAr/id1DgNkG5nMAuRSQOIDIdzpxoPDpTz/yOvn2qfLS8/Nz7zh+8Vi5ERw9ZFfl6L3pAp2LxoiLNirfctGdQSVdVo8FBA8J4JwVA8uPn6kme93CVjoaPQj/FBGY092IeGeqAQS2m28zF5GFIFEkFjpgWntk8YIAi3Ll3g2lYYAbgQZ+T91mS81IpbBGKKI1OtU+NCMhKJrIaxVRAVBjA1RKQdEFAavy2cqhFnVJtTin6FZfhbogELsgSwRIuuaAykLQ1iUsOjLle/fCv2n2mwv/WeWzH6GHVhg+Wir8byPZN3peW/jPOj+JWwnx8mul4PEP5EuVODjItzlxQPDld71r/oY7jtxZ//rUgz8y+9r33vG0y59eqMeYK1z476RENccHXwfgHK2p406s0cnSUJ7P0fmjiYkVjdzbMMRNLJCoL4SusKOJ4iJeFQdeKhHBy9U4VAGJyjkm/CtpFkvHtNo4HKYALQpk3h7RdOCisxOCMlPiHgWIzNmvtn4LcsztYwJ8FctAtaJAYkWKahiiZgDJmQv5pWrnBEsJ35QGMPDBVEK3BxYdJzRysJiEFtFZ6oKVA+pKGizQ6yXUfwvhfwn179uXxBW7FP4JRvzQTcGn4/HDDjV7QbvipJNp/LCkvZHpJcTdvlw78Px0PQvInspv5fnp7m08vhT+E68OdLOwF27ixYpnKnA+367EQUBWAUocBHzmlz6IH7xj9rcvXz918h+c+L++9/g3Q291Zw7CQQ6r8WIyPbXgvUn21qHyCLPpa4vxSWfwaP8zGElrn1g1ITSVFL6gYP8h1hvB0PulMTD4dqVOaGS8Vt+58vDGdG2oFkJ4UaDYp3joVvmZxHBBtErtejtskCLVggUTxsRvGm3cFBTSi6CawOyFREGyQgcq4X2ycfoYotKLiD0UQbB/v//q+G8tMa/ohJuxf413/P43gh7TbO1N+e6IO6NmDgivk+MbArTTdYReY8deibYCE8VtfPqeHOKOJn1duuHpsG2ci45/e3btb4s3LIyk3x+23uyPF+kPgd/jYdH1KHtN2ikxTf3aLLSvEP4b+/cBWHu7afG98JI+8Fe/E/77uyfwZOcYABKJW4dSMK84JXim4o0zvD0LBCUOBPIXZWJ/48vvetf8e48dvbP+zYkH33nHxfuPfAdWJMcZIV0obQkAxv2FTv3ZcaYg13D2RkSfrsWWJgP7R+77R+ftgen6YoUgK1CM5QySf+cXsoxYVFppf4jn4+p16fkGqvqLhhqkCqBGwlCDTtkApNmB1FxUAFZfDAFUs9fBmAyvujus8Ofg8EFciN4hxTxCwdQpYrsQ+GHOF93K7/WCYCswtbdC2cQBeLKvz9dTCCTajX+vIfz3np/tC/+rkn2xU+G/72Rox+6E/+b5mfbsIxnGhtWdWOvEabMb4b99utDzVsI/umP6J0tMBpxIvDrgHMdP4sSJ3Csgse+RKwCJfYzPffKD5QeOzf7T9ZdPn/gHp/71A0eeBZzIKC1vhCZUczpDMWbrpMpZPho1hAv/5sqwfbpCjI8jI/PWQ2pX3HuliIIiTtld4PcPtXy+rzM4cV0gNMq64rSm2Zvk71OuoG8JrKOKEu+M42ujeqJXbPS6dUU9ktGbabSgbZtGv4qwhpiuvDbuP4mqhfxN+9dSS86J1bDkjyOIXRP+u8fREqyb1uvrCSG3T7R5WxAQLe7UrCabCP9NnB6E/1XE3RdMVgv/XC78Sy/8R7tNLeqitpUiH57T6FXCv7H/XviHL8LI0MP4ZFcK/317BHKj8K+vtD8XnVp8+/rnGIsq7Ac2Ff67l03iuzJl//ZlSOE/8Vphhpev49w5PPMM3vHxXApI7GPkb8zEvsT58+fvveOFuzauPD+/9+GTT9x/7Du9im+KbCi+ztAp5kdxiXqQaUlnnPSAwfiTq+wWCTTaB9HCQUZx2qeuuzcGZrxfYiSWS2AMyTeyre47ijRcGAM1dh7ZAtG5FPF6PmIieqOJENHApWp1/+Jb+fYLERVarlTr/5iur6S4L88f1hcbm/rvYYWAjCCW6r1ZgSPOjNtVX3/wDYxbSVAprLSMYd03ABDLIdYFBKlGoGEbGkDXXgogVQSQWguCLG4q/DMCFH1Sy4V/BFVdLfwv0+zjijsS/u1nIqt8dvezu7fDk23ticRrCkEhjh3H8dw2OLFvkSsAif2HX/v0e9548pvPvnx2Y6P+t3f+nw8c/Y5/0n4Lc/hbyYTL0SY6sqm/JuAH7QPMlN91KJ3oD/f3c8wcgK0DBH+LcWlqgK0zwC6PoDHGZUKEbn9iBcKTBEDYF1d/kKjiIlJJUkOA5p6nG0mMQrlYq1eMSZniq+N0tV4HzzIuZcAmSF1d8FvohUCtO6N6UtnINOnElZFQocOGxjXB/jy+srsdxL0J/J06LiE8W7ykwj874V88slJN3rM7mvDPifCPvn1K3NkTd7bjPd4bhH/2w1sl/Mc0daCj8D9dUgjVXJazfw7sv01zifDPyZIC7XWQReHf35cthP+2jqHPKLqyXA74k/VHsFr4j9yYFcJ/sv/EbQJxE7j2Ms6dw9NP4+2/wK1PSST2GPK3Z2I/4WO//rH767fO8sp3rt/z9+/403uOvtB8BcY4xZhB840oc7IMALZGmHFcxeAoDUQwKgn6QoE0mtX8/V4VR0iKO9TZ1hAkqFWBlbUJ6u9Jsk6wKilhrIfvCeCFhhDZAkXMLo8oCmT77Br7RFAuK5vT1hl6e32phHvfbaMAlOLbINhZUqzAjq0Y6BSsoj9Y3XyPwm47MC3c6TsG6BWLsFQUkFWK0LcHloIaW33p76K+pmfxIMEWAcbMCisi5JsVFJBWCGgN4d/+ud5c+M8qn/0Iibi3Wwn/g8A/dL7QHj2vLfxnlc/E3gKJKqiCGwV/8f58LRP7BrkCkNg3+NKn/6e/O//33yr338Fr/92Z37/n2AvoSADhdWgkuJEL7faha+rwgiG9pu6dwGhKcMS4SMfJpJ0C5z0cj3G+AxFUtJHGYTD1VNN6pevW2Y8P3f7fTC86AIH3qSMm2erDiOnw4WUyjb+Y4E+yhFgrPhK/F9VP8T2ATfI3pTYqrgiBlkggxSIoFEgES9p5RTUflk6zQOidM5ioJ1DEM2UjiDoN8QUKEZZe+FdF2Ge0hvDvXvY+ZyCWR1p0ZyL0psL/gn9myZJC6OvNQLVa+G/yfAjty4T/aKfWdhJbHonXg/amd3HvRPj3gbEn7lP2b9+Ilk0Rwj+XCP/dqzIK/25I69sJV/3Fw2+9/2zCfwsOTfhP9p/YYxDMgBsFRyse/gS3Pj6R2BvIX6OJfYBf/cwH7ivfOlGufvuVcz926qkTG9ealcQEcgg74hLFeVw+d2nTKU44+JUvi5BE7EobgYElunpxRrOg2Eft06BlTredQZrkbMRRnfHu1wci27d0LE3HX+j+8VhMiANM4zceWdw7UTxgMBketlGAMqpuuwD2ebGodF+NLhqowA/Yfr1tnwEfm21d3Gr7+C4EM5LAzChmLShSzfevHM62ICBnoFQBqzNCzvzZKae39Q2dXaUZZojISSiVBKS6BYrUHcS6xI/Vwv+kvSnfOxX+/RiPWAbh37V5TGw5LUDshf9emPfDdiX8a/tY6md7wv+C3d86aqdvX/hn1wNispsI/1ngP7G3QUKKfZFyy7DEvkC+o4k9jXd/4d1vvDF/QK5ffeUNbz3ylQePf8MFclHrDUwC9yRddHKspe0Wl9kbjTMqL03n76zegiEAUI9zCMYmaaNxcUA79PzdGqp78wh1xF35MSM2cAW6OsOGq6GW8svWjxUAFWEfM1gqMKhydRErb9pp5B6ukMX85bWFQMrOq+cZA0WpucYD7u1RUg7rPJKD1YlEYRGpUlGqHwn3/wCo5gKCpvZ6NFX0AXUZzwJKLQJKZRu8BgCW7MsC2x1MNwOGxD5oVgmUXearc2vIimTf5e0YqL+/UT1BX8b+148foFzWXpXRJtQR91VeoEb9pz37SIaxYXUn1joh3DbNJex/e8m+k57bNLeX7EtMBpxI7EmwYraBY8cyOTixD5AWoMTexT/+zE88fPOl/3hkdseNI//96X/1xhPfAJzhD4p+/Gf/2zbIdLNnd4dI9+47JzMbiHoY0IhauF/UDRLcMboSxH93Wx2huUSg4YC6L1C9mzYwC1GIjpJpnqMHI8JujsqUKKzShmduEFuTsBZ3hmggI+KuejfG6CWkmu/J5m/uFR+h5VBwbi1F2ubKZtWwfGii+nKKWJ50ENWoRio2796cYwe7t6fCnCHiR9JXLXzwqESxPaCyyqdPbWWyL7qQNat8JhKvCqSgzlty8EMf49bnJBK3CfkrNbEX8Yuf/cV75RtnZi9868a5Hzv+xD3HLjV/M0KSZ/NOGBszZd24CCFug1ELQWMqpqO3jGEvcAkjJW7daGYb0G0wYlqolGFn025twUfSS+wS3A5o9iQV0RFuH63p2RmKlHWJqCFHYgXD/TNgbMtF86mzmW3QimbGGFDgTLkjiyKRgFtBlFid8CqfvgxCQEql+n9g4/f9xUAhCjVF2J08Yh4kZfa+qiBSa9GVBIm9vaQQhRXVoqkiQJUCrfIpqHCxX80puiCgfiRBjWqqLT5bJfxjUM1XUv8Fzb49u50I//YzkVU+u/vZ3dtB+G/ticS+Q62oBVVwM5ODE3sSuQKQ2HP47c+++/s3/uJZfs8xXv0f7vz9e49eapFqCOTB/kPthgvjUG6jP5tWjgUaIUG8/L8ZwYUr5XCuUi1pUtmJqenGlsLVo6SqG4mbiZTrhBAbUwhmSSu4WUR8ocD5kmW+Vr9g04NtDOazcFJrOcutbKhmQBj/b5pvrHJonq7ptToRUf8P3FweyckSJzuzbPfZzi2eHmoTodv3gwyzSgzeplJNey4kqg7Jb3ST25tSrtMRiUQO0b2J23oC7OdO+M8qn95uL/GC8O8vYlb5TCRuAUrBjLhZcLTi7b+YSwGJPYf89ZrYQ/jML/30649+6+TspWdv3POfn7pwYuPlltqrvN4zPhvfBZrkj6ahGqtThmumc3pWQIj0cXDxX89Ra5KCIC5m2FAWNaw5OEsjrXNpznWgH5XoTlhRbyc68TRWuJXFuLiK2aGyK10Sek5tv2QRybtGNNtahMnwUlGLoNq5glJ9dlp5U6yeT3EmWszQokqxbeblm4jZUygoeoyytxmIKmrQt2UHqVKL5iTMjOqx+AJF8aG2BYT+VlvmsTlwLPmhLcIwKoGC4ikK1eMfe5ibCv9Z5bMfoYWssZ6wifC/jWTf6Hlt4T/r/CQOGli8XBpw4ZF8sRN7BfkuJvYEfuk3P3buxjOnePkbL937o6ee+t47nlaO3unNUIbtCbgdm2nZq42o9f4Z98ETrnGKp+oGCXMKDvftMHr2q0iI/xEM+N/FJPje7QN4OZ2R30fn8HZxCxDgdqMxb5hE22dAObRqyVqp0+rwAIUiIG3PAW1pcYXabEqI1hCpVScUpwfPLiYzi+8ibN4h1tah2YSqOpQIUMvyaEAyM9NUu5wXC7KFg+LBzCx2A/BQrZgdqIZMXkhBERK1Wh5zJVHUnlQqIG1D4qWen769V9CNcC8Qd7afB3q91PMjttZhT3CJt2fgvl37YHrxtzH+dubdFlCmnUzjhyXtjUwvIe72nu/A89P1LCB7Kr+V56e7t35RkSz1kzjgmCO3C0jsIaQFKHH78aXH3v1983/33SMPHLt57X+851997/FvAs754bza9OOREnkM4GYdRSQOIkJcem9KLdRR4zYV07kBM/3YRenOHCMrUC5PX0IAxOuTBOlS+gJnSHZRxvgKotEGbqECPOVX6D1YpVC7A26lML8OXIcWFJi9p8TUh2G7y4Iw67xx+0HTjfvsZLMizCZ2a9jSqQVFUFA9s8J4oYiFQn4/g3DbKoc7RMyjUmyGdF9MLZHH7OK6MJxX9NGYeySsMhHs2dS69qZ8d8SdnekFtm1wpBe306fOHLNL2fpDZ4aBoPf82InwpxbD02HbOBcd//YOtb8t3vBlKG2JzsOo41OIr0MLHWWa7Nt5ezw8nnp+puFNJ/w39h8vpLa3mxYvqnt+7PEPwn9/96RzoGWyb+LAgrTtAm58Dx74Q/o3PpG4bchftYnbiV/9lR9/w+zpO2avfPPG/f/FySdOblxzi47TT5PzBYBmwdIYYsvFdBJj7iDjmLpcELm2VtImSI8zMLtKMZGY0Q+7S0t86n3KsD5AF2vd9u6cT5yGuqBu5Iy9DK/hiLOlYmOAsIJShBEhiDEnLxhKFKFVzdesCPXeQKRSBLHxcPF1jBkpVUkYCwS2JXAptaKv9Qk1LIlvEhyb8lrnpWi5z6r2G1sQIDTZFwKpIsJS1aVTbQyw51JAqWoZQkEFi1CXJgBwhuqJvyzwBYrY+dgGifAL6eykkiLFFyiWCv+rkn2xU+G/72Rox+6E/+b5mfbsIxnGhtWdWOvEabMb4b99utDzVsI/umO66Xv8ndQ/ceCh/65ceARv/Jc49+d44kP5ziduG/LlS9wefOqzj9xfvn1q9uI3bt73Y8cuPHDiu8YPjGqrNOxFb9iRBufWqhy3IAG2426Qb4TcaNSTHY0OJTgIPRqnZ0j+xsvFknBdErbTEayoiyVcfw2SZ24WmNTKoFNO0Md0AjvGRqBXJJzyOjWPqwi0aGZ4hwDb0awWCyQokFLZHP/OjHUbL3iJHkBr7ZtPqTTjkNH3UknIDJUtFUEd/AQxA2AVjXzjMACVmhsgYKmCUktVW1GdQXzkcTyjNz3dDEu1Cor6lDzNAIXmjGq1jDQ46dinPtU1iftW1D+esr2KvuAzeH7EV2awxAuE9sJo584HVrD/1Y7/xfhhKUHnsnb9Xiyh/n3g1F9xGGHXeYumus7ZH2PtGJ39bfDp+UkcSpAo+huioGzg8ffk+5+4DcjXLvFa491fePeD85v3y/Xnrz/4tiNffdOpvxK3eVBpz0D3vUAkgBDpOzrSe/2VVkRswJbs2wUACJFeEMymCf+wJFSLQBBGHPMnuMucTjTFrCN6SYQrYyEJuLD+/+y9aaxt53Eltqr2vW/gTD7OkihSoizZmgcPEOykO8iP/ErQCBoJEKChTtp2t1tK7I7HlgMISHuGLFu2LFHuGIHd/xrdQH7kTxCknW4gbg8UNZiySJPWRFoU53l671blR9Wqr/a55/ENfOSbvoJAXe6zz7e/vc+5l2utWlUFF2EmwUeXGFbWFqAvohJaPtrlqgo2GgaZK+Dpfa9agijqdaQi7iyiTWRfVGFMEwvonx4buvAL+meRtKjvIe0iDo4eC3qjFKeXSAvAY+cxAgym4r4AiCxErGBRDewKETMVuMsCiCXDUc9FxKAiWfBgorBoGOo5v0ySC/GmiH1PIPxv0+wH2zwd4b/4w+zy2Z5ne7Yr4X8cnzHjIgwz7BzCwR0cOogjR+bUsBmvd8wagBmva3zu0//0g/bMN5edw3s7f+/K//P7rvjr8lEjgUGPAmeJpoml4lCACfreKz1A4TNf5T9pzU+8OF7lOwLu8Mp5ePMt8HIsBMrzdlEXDrQKKpOLhWqb+7W6N0Ig6qwFiQJfwnOIQW4jmUh2YmQKQuESFvB245keIHQTodLK54hxow6jwzw+AqG/CPTbiCsgMANoZcr8Q2YYPB9D3mZDt1mAHWQGaUACbyc2oMFnAJXMUiwji7KxSD5WIk4awQZ5W30WPL4J3L0Ddx/n14Og47+cWmW+z2fUHP9jcclPaHb55PHZ5XPGjOOGKuxlPP8cjhzBd76D982pYTNe35h/f2e8TvGpT/3PN+1899Kd5x88etMPXnLXdQcfXymXSNhb/TQx9PhYYGjV+erIABDztp6hTXCVgeNDLxWafJpO35oCESBKWi4yJxCCqLNPDhLs94QDoXPC1cJ8JdsDhJh5OR6Pf/WG2xwhb1dCgOqyBgiry9EzE6b5YCWBwOjhSWdUwcHwI6kDhqGjQxRp1kcK/xjmfkBhboUpw6Cfhn43aLYWddBllB4hhE1IxPdaWa0LVD2LGXRV+eDqsbiJL5oFEhwQVqYgRzVUVaPHSSJhclqaPQqeMplUySI0jje7fG4uvoLyJxT+Z5fPGTO2hFMZcuBLvzh/O2a8HjG/ZzNe8/iVz37iev/uFfL0Ay/e+IHDX37rZd8GQBxPcLCPABQKR3l1CjqkmwWWGHOF5ge0WtUQr8ENsbtQPV1Ri3QEAc0jZOs3hhTtBO6hQ1sta5xQ1vmD5EQxNM/6kKhZCZAEJqC5awqoqUNDxvzdojHaCIaMGxdxE0f472PDVeYbBCYIQD2rhUxJvAgAsoQgwLcJco6vj3OwchkpdxvjAnJZyOLkbFH+67IEAQD4s3LOAEDTUWxJk2AE3Ef+0wGYuGpUPLeuoF1BT8A9u3xuHp9dPmfMOKfCYIA6Fsdi+NNPzF+TGa9tzG/YjNcwfuyOO9587FvX7zz+qN3wLvvy+674muoeJfaBkNL3n0ecVbZBABKUoSuytGo4wcWoBMAw1iPdKSM50CAL9dqyT4BOfRKPkv/dRzGxO6KfvXAzw1IfPTEFMOJ4gFJ6pSySQgDU2js3EM7GSrO+c2ZW3hcA9+gkKvT9kxsgJPxVG0cnA3EXiSkB1ot6c9sGJZlR0iGtaQMFpt2UHYfgojCa+KPhD9TdnXMGUqoHYEqqo8GvzLPBP3yBRD1x1vKaKywTLHDNd0WegfkQE2Y83AEtepPpBdMNbf6Ewn+H/quvGTX4/aZ8pyC+IfxvAuhXLfwP9lLbPkXhfx/0z4X2of9TFv4dI6UwNu9Y3wgwof+MGScX8efjwFHsXI6Dl8zCgBmvbcwagBmvVfz+7/74D+DOb+7ccslLz/39S//NB6/+S9VjKAlTU0QU4pcIr3+A+EPG8YJBzAHAafAZa9T5TnMNF6lX6//blSsXAZcCVV6b6e9PeqIlYOd+QilOrC6otANiw0iFP69VSV8gFFapbYenOrrlxAV5P1HY7HUssSxLIDSPR6bB88ZpmqfsS+d3VkUzEyOWy2o9sRD6kzJlTiPpW3qiRBzYg9fYhL43GB1Jzo8pYLTGjfjwyufDLH4EEUlGJFxCqmY6ffYFPYe5qJnv09HuHf3zq3Ic4b/XEjgfSx7HOJ4AHcPxPyAyXVJBezYc//m/sI9JgOM8k2+Mp8ekzVgBXIf/bMDdN9E/vy5bhH+a9ZvjP9dc1Qbk1zf3BrLNQv+sCgDP97by6vYn+p8x4+Qi/lq/tIvnXmRhwC/5Cd81Y8bpxfyLPOPMx+/+7sduXh46vLz4wMs3f/iyv7jmwNNIrR3U4+EE791xkfJh+nYgtNwMv9Dw7suoJhQK/BRNHZBe/Vl2eV8hv15m0CxACgAibj6gW+8mxA3wjTrGBhNLpuieXiZirACLie181fknhfwQ2pEN+Et9h0jOkg+PO9w0jVJlRgqfUrqVHKjJu4FTw0qUE38zCZDteoCsNk6tPVMBMnIR1WvfK7EQ48eSH4D5hGEKqnm9yP5CbCWEhfYtFagJ4GpQcTEfQBmoWQES58TGDNkCiKwiLUBwNQBCC9AW4Z/a/PE8Pycv/CfZWpth9snws8vnFP5nzDjtYHlb/nNODJhxxmN+pWacyfjk7/3s9fLdy5fnHnj5pg8d/NKbL/sOkDhgoLFmuUH39qT+TQAxMHdRgkL/cbXAx0Q2Kb7CjIZv7wW1raXMMPSvz5Fs7YIwr4cDZ4WDQXE331jqcuYaUqxNJw8c1ZrTIM01FBpqg87V61MGlHcgJ3ARM9L6QutRentiS1GdHBamaBqj7hCpCgFEvazE3ACoGySb64tnUW9M4MLo+2lVxFzVApEoUM4jK8E7NrbE2C+4uMKNowZMPet3EfPLTBVGA48PvhHmIhct0O9ZP8DHldYgkitRM4Go1XdDdHzZyvRS8HR2+dzm+D8e9F/d5nbHf3u2nbe04zNmzDjtkMgrC5YFf/6z8xdqxhmL+WWacWbiNz/78av80ct3nv3WsTe8S7/y7ivuU60mjE6JHayIHW6P0vuLBiTUZluY8d7GHPhDNuAPb0ykCCjzNwST9bWVVVhfNCF46PcyyoshaXTxnNdLjtEqB5xJgHgKslnU62i9Fy3hkUPcPGXs1b1kRYFBWGsbECqGXgkhcqjmkMDZvKNRjYBgU4tYZFq0khLtNLDHf9g8sidPEBUSJG27CiAej0UigWCApOiuBoW7ySKWT8l6csBrYldUI8Bd3dVFzT06CAFqBpElWhL1pEQ2BdL8gLIpUGRRgvzQgsL9nLTwvy72PY7wDxDib2LiLdC/EgL51/VEwv+JF6njr174r9vcx0y2Ha/Ftwn/nVf0TU7hf8aMMxtmOHAAbhDBzi7+5J/N36wZZyDm12jGq41f+7WfvfLAU1cefP47cstt/rUPXnX3rh4LidQSx3vJrqF2C6X95vwpdd9XDVuafp/CKxH2AFIF1wKfDWkfgMQI3obGqr9QVQYnBwDQEHYZJFLCF5pwhgpOcO8o5w+arUhSk4YiZVsWKEONhg8fjyVKbIU+fVYPx72rwConMNiFokwv4i7BCuK6cPVo3hJviXeZMKXQqnXBQWMqbkEt4jY1hfaoCU61Pg08GA9E6T5Sdm3SGHxm0Lpxy4e8uAj7/2jmIlwc2fETMbwsXvXsbQos7grJB2UQ+GIARIw3ruQMoxNo0+zRtfktxb558uzy2Y/Xyict/M8unzNmvDbhEODgYSyKg4dwzTWzPnjGq435BZpx+vGJf/d3rnzk6quek4cfvv2Wy7/1g1d85ZL1kvVmAAAgAElEQVSdF5tVhoic1bjbvD2l2Y/yzzw5UD479CNXkY1MQhzmkF3QGJMbGO7/lcsoz2lLAagOPM0rkl6gGh3QBgYncoVUHWemC5Dm+zTqqAyL/OAbcbPRtr+MMcDgJJl2GLb7ylesm29mnkSNrCZcTC7gyOFU/ZNaOFw1ygxyca/GQcPkk3OLIzOQz1CL6ljysSWEfBhclnIZBSUwSEwVQOMJApgtrHAAXT3RQSjmG1Tz00gOCPsa1fRfYW1AuJXc0JxOeS96qsI/yzewxdl/WsL/SrPPEm4Zbzwuf9hyfIDpLcA9Bf7Z5XPGjIsh3KGCt96Ory145Ho89MNF+2fMOOWYXYBmnGb8/md+9G0PHXzquif8+av+yxv+r//s2j+7ZPdFkFNy1ifQ5NV6NX4aZ4Dqfj9FiTYoOKa4vPFPniMDNgGlULYrjAMyjncTduJs4X5qzw0C+bg1WS/lQ8vPdST9EIL4X64lpBbJYsZdOz1TcVocQUJ/wq/+117gcKvTJNeRqFwA57zmLn21DTKKVHKRowykoKfwNP4HJu7duIgrktVI9rSRfLe4OZ+L1fMUwF1zG+6WWxJwtLIDDgsHv0eTT8uS7OJ9uaIO7VlStq+dkEF15iPVmolESMbIWwj6ZF82sclnXvzBpX1JsIH+fStwT47pTPX0xfMHcWSrn/p2Fl2ESNDafAT1lrrNcpetjx9H+B/onxvI4+Oh8Xgx2PHlHMJ/f3oCFjvXBjBjxozXJkJNuPc+LPfioR/Gbf8WH5jzg2ecbsw/1jNOOX7vd3/0TbsPHVyOfvOlN334sr+49vBTcZxKeXls4uhap+zJgUoFeOn3oHKPcnW3sssGbuhsNvcEpM35U+16nFp7wjWRmgxQ+YHIGzihOpXdxEMj58A8Q+4NVYBL2TjfQmSW2u/AeQ3GarIRavbs7l8CvHDuFVZluw6ouOV1U/gvJ08+vZDtWVIc6FO6CSd+HuacuK5Rg4cj+/bE6IAwIzkhr9Q0sfhnfIgqoeu7urGSGMKpXsLmP+IukYJwV/qaNAaNuWRhA4t6Cd8h7gpV2xM2/ld3gYo5xJhwEDX3bAR0UsI/Bj7eWjF8usJ/L/bdn2rYtzccfxHwa7KRVTh94X+8um/l0y32dWxseMaMGa9DeOQuU7b5wj+fv4AzTi3mN2bGKcRnPv2xmw88dGh54esv3fThS79482WPAsO6Ezg4Slc7sqd8D1CFNsFAUV44u8A9pdBmBKrzmREofO8yAD2IszGg/CAVQr1ZcnEkUhtlu/UD0E3b5ewfnYgwdpWVACLeFpdEyZLGIVR/z8ZPxnVbTYKIeLS8BOt0s44iffCExVkmW9xAxCHiYqIgATBzII6E2FzzehGNgKDBFiRb9/CiJpINN6OYoSqMZcmBXyCgz50rfIwnGwuqYC+6i1JmjpoEi6Xio1dADZK8YjiXVEQst6E+zgR8yU/c1bUNCY6mQPuhf+Vc8ivkxK8d+wpYIbDFCwR+kcr0crqO//38YStA923H42szu3zOmDEjIv9WCCC46+fnL+OMk435XZlxUvGpz3zsxuXhy5YXv/XCLR+67Iu3Xf5A6KcYBEBosmldegpsDbzezmkia0LPwujxjqr37QTAV7W24g3ipKelRHpILYthuCn3fygn9LgHWyBY9zQVxeJWZCaN9bHySA6MtMaQ1WNX2Z2Te0uA2UcOD/NJ5SsAjtQFp/Y6++gLG/kLoXwWHMvIM2QRQkJ2F9esRrAw4rtAIgnAXkOuAjdRmJhAsAxI7cqq6yzPNcRHuiDyBgIzjeoCeO08mMki/FD4KASu5ppsxAJuaizuWIzjySCLRyogK5WZTpHF4ok5m7QKJxjEc/PTFP7z50w3vbLw/4rQf80rji/8bx7nTnwfXeHiZ0L479B/dZunJvyP4zNmzDj7ocgkr+AvfmH+Ys44ccxvyYwTxG/97v90w/LwpTsv3P/ym9534O53XvX11ASBwuUCjFJdJK4t0C80hFsBnSG6Q1Y1wQHLCFy8YMc4v2pzkWWy7oW2Cd/h7Z+FyJM2OD0zqDxAXprls6GjVy8gIvtC/GxG1KxENmhPPId6tTbDkytjAKd+nyW/5iLrImAHqh1QOKyMZmv4WDPgL+LkXMq5CJMD1MVDRPesZg4uAUkATUXfqnNoPB/lw4lznFeULPN1ZWKnSMViEE22IKbh24m0Q7btl2xhJAYVVxN1wAwB5cXVfIGE2C8uYp7MxH3JNAVMfDERxzKIXBQBbyv2PY7wDxDib2LiLdC/EgKkaicQ/k+8SB1/9cJ/3eY+ZrLteC2+TfjvvKJvcgr/M2acmyGACvYAV5jiyz8zf0NnvFLM78eM48avf/qnbth55PKd57/18pvee/Dud171NxoWDx81uYkYWIU6WIEMblAIgxWEQ9qXpusDoLDtKIONFLAWat5kF6QEKIDFutq2vUK9zB6gLZ4A3Uuhx0ggMMnQhP8gKuIYM7xoHHKmIOj7j71p5y2e+Lj4AHzkHzSWGGuWnJ9sASQVGOb7zCRIVl8wgeCjkX8CdNBaAwmRSB0SE7sckOgE2lX2rBAgZA/HjosIDAvcLa1BolDL219ywzYkeal+qeGGiuQAYqns/pnivUV3UbYBjdoAVM9TjYKHqHYAYg6AmLvIYllEoSVU90QQBtpeVaFsFf4b3gX2AfQTCP/H9/xsEf5P0fPDDfSXtgr/2709su14rXzSwv/s8jljxrkdDlEc24EezdzxnXOE8IzjxPxmzNgSv/7pn7ph5+HLdl64/8U3v+fQV99/1b3LYhjIGAWRE830wtxmyCmSkHhiTQD29/tvLKLWKRwfunieL+2K0f1maPkeenYJ/6wESOiZuKwQXmreKGs+i4ATXYEQnEiu2YRcJNtl8pY9pokN1pEXDfRcNp54S7r8wyOUg8ZCmOcVa3vMRQD02dM1BKJ2IPMDjfNEaW+8UcflSAyMQBxJAGrMcJYXx0e8l+UBQVoWGCzqd10hzlLgAPSLu6djJ41AURqhHsmBLOEFRMcYL6i5i7B5aDqRlE9PgCVcQwYoalKYQpC1BCaAmoBv0S7858cCbHH2v4piXyLv1ffWX4k/bDnei333AfcU+GeXzxkzZpxClK4DAJMGzNge8zsxYxW//umfunHn4Ut3nr//xVvfe/ju919976I2wE25X9JIk39oSnhGg/iDAJA2DBAz9PvEIo7C2ejMoUiFd9tPAXovUJWn5YCtkuGHyR6eNbJU620InITalc3o8J03DoCMInRxCIxTxko/jtXEYVJqer1KlhK2nNKq8+cA32WjRzr7E6CLBTJLz0zCcYjC8ggkZybUOdISFynwp0IfrEwEbaxYy4EkQ5AYo6YWGQDVrEmwlmnRSCZoWJjgasqiAhFL1T+VewcMCtYtRCGvB6VJB/+SeQZXl5iIHDOGxfIWIKJmKqpmUtXMgLgsMGdhAzMt2Or5EbLRlfC/CaBftfAfx9etfk5N+N8H/XOhVyP8e1sBdbOvIPxP6D9jxvkYpAEW0pbirp+bv8IzRsxvw4yM3/jUT95w4JHLdp+/78Vb33f4L9979b07i6G88gCG/z4O+saRRAxVI5sYPf1Co0AWaDZ6BGqnRx+J0YViLSjkD4IBlO85lW8fCYTSvwcnIe5xCMRCPSUc7OZ+IQI2shruNlZWKqbiEDf3sQEJrOydt+SW1AFwzi7pkLBrJ2eBAQOgVzOlhO+8/SoP6C+lS6eIRJvhBSANNoBT/rckQpxwHCifU5OL3iR85xivUdcrWfAAZ+5iqUplvj1rAzLtYMVMcpHmMgqWohauqj1xVeEeDEvelKuJwijquzhYA+AU/uOiruYCrenI2Frsi1cn/Pdi340ag+MU+55A+N8A3K9G+O/Qf2Pl0y32dWxseMaMGedP5C/wAg+L7aQBMxjzezADn/rsR6/Xxy7VF/762Vvfc9lXP3DNPaqW4maT9ocymtZ/9w0jPl8t4b+hfK+lBI02NGeLp9BaMqcUniaKzQzAhnEolnXqvWUEKmQPL8DHVIMT8tae44rolxNKxftcPenpL7QUyvqgDYnU01M0dtLcRHGOF+wOkRvlXEpOIuXbQVjk1wSgwe54YuzyiXqSWpeOR2GIXqI6Dpb1CGrxAZkCMImZACoQK40/n0mo8kD05AFTFlGpjCWzBFnm6yX8U9FHmfsBcVPXqKbQfAJYDHQiuRhEZKHnSqL1JzyhfziCMGoPluCH9cluavMgvVxXCHQYPbt8TuF/xowLJ+KPyM6kATNGzG/ARR2f+uxHr9dHL9t9/m9euuVdO/e+75qvLdH4cVOG75A6YXrihob11xB/jfIDdHmpnsPSQ6264f4S9cc6A983+R8l/CdzKMKAwmFt/VzKE2GvNP7cOWsDKBvXdXMPgtHLiBid9AOt8IDVzEIptprl17az4SmQqnljLHE5BeA2KIqXmB2moER4wrlXQmM9ElWDC3pcDjluzOnOj/3IoENhs5GgN8py3nhcHhi9aFLcZqQIqOW7uC4wmMeTCavS4vBqT8RqXbiJgeW/WKoMw6EmEFtsNbJAxBZXDf9SCv8QuBo82gTxSBCzZb/w3xNB2ED/m8D9FaH/mlccX/jfPM6dxG/Lfnn+zAj/HfqvbvPUhP9xfMaMGRdIFA04lr/jX/rF+Tt+8cb87C/S+OTvffSmne9etvPi/S+9+V2797z/mnuWZa/AuhRq94YkCnYnoIlTBzGAU1lcpwuG/ycLYdEgMiimQuh+caqPiVo8JuMOI777QGxE/82VjhLR82BsvlIN6Bp/SsXNC+Qd9gU9GHI+pX04hjkHtfP2KkmU1oYz8wAAasR53lbIot64X4/yYiTcF6SLJtTusv3k4tkLqBIIEK16gKyOCL9Q4HLvGjwtOkmHwrMUs8PYpZRFwPHooo+QJd/g2K981Is5JAcIRGWCuoubQMutVFUNWeZrrqpqhijtLQoUS+3FrkwgS7zdAGAxliKER0iyxkAEahZVAZsQfxMTb4H+lRDIv40nEv5PvEgdf/XCP7/Aa34yYP32hMBW4b/zir7JKfzPmHGBB1UzIArFcNekARdlzE/9ootPf+6fvGF56NDOS1974S0fPPSV91z9N6qOFLadkLdUw66IF0zH8QgACt8U2GoEAHxpCOGFwqm7UhF3Xy8uDWRT5eXwAaqVQS2y8KCQUP1cfn04FXEJ5hClrj11QKQ15N4S/pMniFTfnhLFHQjUjjqt7DqJpHMpScf/ym5UXh2RbC5E+z6NT50tlMMnETmc+H6YgqCe9pvMAPDVlnBwdZYiIPsU8YQs0o0ThIPGdC8fSNh1YgIA8wao4cGRbVDmSRKdwxcLB1HYftK3A5HFIDBdVzMrS4cXuJpEdfWSt1DpEVNoliikH8k10iNYC/8N7wL7APoJhP/je362CP+n6PnhBvpLW4X/Uy72rQ2fhPA/u3zOmHGxhDtcoDZKhL80pwhfZDE/74soPvOZj7zpwCMHd4/e8+Jbf+DgF99+9bdVvdR6Twi/hvJNKY/XAiJDJKb1pjU/ABCbvjdBnf8kAfD+kg/ZfrQEzT6YzqtAiK3JNwoE9zxDv1wD1paAhhad0OC9OX+GqF/kpGwbKYi22gAWoTbnjzQ4PhZnvyBQ+BcAYpYJB7bjdE/CQ+m9cheNQqS+btHdVDg8Kx5dDtWKnbO5fmj2XvA9ADFc4JEKQDXl9D3E4K3kTqNmAO5LpBSqdCFLeEUtKiOSP4j4EimdlhaIG1yGOi6h8Yv5Qp8Sgi0gML1JzBK2LJ4W99D1xUTcFhPE7DBnniHTF4ZcITefuQuuzy/J6Wn20pnwepFN/rDleC/23QfQU+A/u10+c/NT+J8x4+ILjy4dO5C9/Pv1xZkNuGhi52xvYMbrEZ//zD9848GHDux8657nbvnwga/+0M3/BwBgAIWEAe0tRPYApf9xSp2XP1QDH1+t0VaQIAwoi067UJ04zicS3tiJeFUReH/jvsvx9Dyt73V18ehX6XlTaQeqH4oa1YZq5aIQIvlgeF8OEWFlQh0PfuQOTcHY3Fm0kA8oOqvCgqoUvalHkiAvuwPVQwj24QIRzcECmS6xeoYuDuSruVnWQFtJyGKbT0gACyKR6NYEcFOBGZS+pih9FnNXwGMgsVFsj53FylZfAIkHBxOJFnX5uJSPJR+xQEYXVywuUSkRXBOcAw2h2E8uVw8T4uYiNROgAeiTdvyPbNJxin1PtsunrI4jVhHOlGjHjyP8+3GE/y3HQc9PffOb8C+bwr97Pz5jxoyLJ/K/YHvDEXTbv/EXr8V3/pP6AzLjgo35AV/I8bGPfeym655702WPvfnaJ772zFt/6Iov3nrVQwC6Qk9zTnXY7MI/UKJ+1fvmWdJGARRwWQmrZacJxOQNC483CuCtIHLYdbr8P8qLUdJ+5g1o7Al8XD51wKm117vgBawl3+gEmqGUp1CNqg1wkLfQdVPPqhnoo1Q37jfAFrLHDjx7YkqWIJMbxJ6lsD6yrtcdks1tMNICvQQ5Ma4rRlMggGZ67pOyPUV6fqwxK1cMCkPmEFDCvzuio/+w/ueXIXIOojCESM/u/ktswBxRd5uTfXNYr8DgS3p1WIss+UBscRExiv0SE4XHxLEY/pU3LhojBTLDkD2FaDqKGgBbLMC0iWjUDGgH0zg54X92+ZwxY8ZFG2L4wsfxjj/CVd/AIcMff2L+ZbhgY360F2Z84jM/cUSeufToc3fd94YPvvORH7nyi9df/mQJ8Bj+mfTos20/5XASgFB5xbuVv8A9DdDE/Ty+IgAppWdJ8ZobRE1w4enhnm/Xzd3mu7xzA/pqsrdPh/hZbSyExXXpwRZ87DyhMxrH4FMKjA6aoISuoaY3e92C1tNIdpGTsyQqYkFr/tgJkbqnah8CtnoxkNXl6lPL4cHl40dC+bDLA6zBJc0YzqVU6PcEkiYivqRwN1kyQSGh6ouo+l52N0pCEqTCAChE9hzR61OgJoLo7RPVCEE2PK1KLos5ROuIthkCrC2WxdKRKuQwGjXH0Sgp2goBcCwQsRyCFnXSS9Ew9ygXls1p0/zn7PI5PT8zZsw4bjiuPIrnFMcANdw5acCFGPNDvdDiNz77k9frw5fsPHf3i294+/KdHznypSsPP88Xh+bdmYAMad9XCL4lBzoyTpi+jwC0dyXUECJyFAEYnWqAhCOCkJB7wXHEODIc/+XPCZaSgE88MTqQjSylb5jcIDClewdnCfQbqegNf2LnoWEPUpE0I1VztD5Fg1YNSZ7MwWEiUoNvq9o47iUqYsFChZGCEAmF3uBSSZKqshXJ9pdJPIYLP5GsuMNVYQnr+ZLy4QddUVcQjkeZAYBWzstGQ87FY2Wj7Z75irxfwWKAQM2Y6Bi8RVnJsFhxMFnc3LHkEAP2+nQR31OXqAxOquCyeLwdiOJgIOuJwfxD1ihHEqllh07o+Rlfm1GVu1X43zxORO6VI9pc/EwI/x361yZPXfgfx2fMmDFjSzgcWI7CDwALZMGdPz3/YlxQMT/OCyd++44fu2l55JKdl/7qhe95187dH7r2nkMHXkaiY2DI88AQuQFW1uZhnlMqODqm38gDeMM6zTGPlaSNRjyYW2ByoI4MS1Lwg0C6Y28Fo8ugL6vLiZdqDurifGm/K2njcgUQ62kMkZ65C4rl+RDE1i2AiNW0iixZfSsBKtmtP1bWIlqe3IjNNEcDH+GZANTc4RrPdfAHV6HpxaPJpgsEObQrCguiJ0/UEKNsMwizTcn/I4sCtWAdtACxE78yyRCPJW6TPYjqJQkHjrjnDOBsz8+JwiHnA1E9DPb0VLecEyxQCzoHhS8myKV0jC7e8wXOGQIqHq2B9sBhwws4xpjNmhRAjlao34X2w/GFf+TPJzIOnRHhn7B+zU8GrN+eENgq/Hde0Tc5hf8ZM2acUohAdrH3MswAwZc/Pv90XCAxP8gLIX7/s//gTQcf2t059pcv3P6Bg199z5H7l8UCWAeALfsNRf2G75kTQAKJgdpln+hO/R5pdifYLdm+HESxuNXiRQAwuEHlIjYwuuyrBPACPURqZaDnrtwiHZCqObAC90NrrxQEb20kGSpfQSgPQnkQEOceYj/07lNox4qxDBNOnFxOnkCxg344vS7dOEQd3UM1b6Woma9ojfljGldc1KMGNx44xwWIZp9Td+r3KfwnjAbcFeJGUC7ZWlRq59Htp6iLDU2d2QmNob/RdWexlOqrskKNlwPnA5gh6IEkf1ARmC1OVhO9fSzYVNAeAL5kO9GEv+oitgfI0loeVSlCfckV8Gw9dIqeny3C/yl6fuL3CauXtgr/2709cpzjWAn5JxT+Z5fPGTNmnFZEczaBAk+9A7NK+MKI+fmdx/FLd/zYNfLczbuPXX/gqb98+m0fvuKLt179XZQ8SVeKZ/0uCmqDXgf65gnoCyIAMtIF5UdHwlZPQLQiAI1IoEPw1VXyukUzypwzFNbONxLvein6QoTd7UZxTt5RKeuhzVN3Z66gpP129WBKaVAZbIFuH1RKIVnHahEFAoNm3sPH3eVbMKp1pWH9UQLhVfaarCYgMkTU98a9GESSV0Rbm9pwkYSA0Y5s/C+sQND2wNVdoAITrzpaYVWxtaqAUP3BvqLe5pS5uJJUoL3aqpY9a4Ibt8GCVrqQQ4JDwg/5H5AA98iCYAMEi7m7LJwFhrAJQcSg5pFy0bxNV2PRsJsCmVpJalscrGv2JLRD7D+OwL/1eC/23QfQk07PLp8zZsy4YCKqhN/2R7jsG7M84PyO+cmdl/Hbn/mJ63YeueTAc3e//Ma36cMfvurL11z2bIr7haQT97eJWs2rIysADVpfBlsoEL+fAMSreSnvI3WHQr9JAKRVFFBERyUluPjG5cp+M6BMISf2ryQZ8P3uHRAWg/eemn1JpKjrCvMV65rRTCCQgXToT+NQ7rleFXF3N/amJG5u9Kl65EvWVw/+MHgCzfrOCWWaTCCqEQBDCfwsHhjoVlpagN1+aj91mompoCb7Rr8nJgQGWwgoL+LZKDRsPPHEItdRFcCJv+M5h1WJqQkIllFyHR6qKNVNSrC4u+uCvRwQZsjhZRBxi7ZC0fuILY9k2duL6gtxU1OkxcgXQCymnhV0jiRAfYInXex7sl0+18fjl2sf9K/f0Fcr/MfP4xfqFYT/Cf1nzJhxZkPghuUofIEo1PHnc3rAeRjzMzvP4vc+9w9u2nn0kt2jX3v2bd93+K8+dN09B3ePNvk8Mb0QdqfDBJkBKIs8Ty41keq1+0bjlEoRBCJfv1rsIk+TsU7TLAnNS6G3gjXlwCm0NI7kvN58tTwzpc03MT5gTsOXxUmiX814Ccwq0D6kguaxKbMQgXi6qIo/5KtjbHDD3GAvUUd5bLKYteUEgDC9BHSOj8xFyDc0kxJxFb6Upb1GeMqmpYHprS5XFCLBdxBAuoBUYbFzgnsRh5pxV8w/sAFoGPQXg0sW+Ga+ohUxJ1WAC6B7Jq7xoNRF3DROkKiOEDXnOrlCzBFT0xwDnMUG4mbiuriLmDg03pv5H1ngYi4WrAD1KNRdTBZADbqqfkGVUwvcoZG6WYnlkaAaRrUV9D+u8L8BuF+N8N+h/8bKp1vs69jY8IwZM2aciYi0+45hD6mFfGHSgPMq5qd1fsQn/uVPHfEnb9p99Mbdx778zO0fOPy1d1/3DVWj2N9tPNWLJBFAc/An7hhoo1Rzit+BXNYqeEr7TmTRNHuKiywp3mAUdRVyAycUbi8B6NAqUKl5nTPcSoNLrAiANABE0Z2MJRYfRIIsYjyxdqTyBtg0Dlm/LkVu1hsMu5EXWBQRbx6bfGLDlgPafhI9k9Wkms6cQ/GQ4WVycZVxOXpvPFV5zg3IUcFubNwJi5RFFQlkFyCO3QVieLCIu7opNPIA4gIzFcA1OvoX+YleosrNkPCEIccFLiYKT/O9u2BR24N7aPxanxetROquJAbB0zS5gWcbUFd1FyYBFkQ1AtgyyKMRqkJy2LBUEUiyneixqTCPjqjHE/675+dVC/8+fmuA2eVzxowZF0y4QwUwuEAOAgvkEtz54/PPznkQcxLwuR6/+S9/4jp59JKd+79y9K3XvvzkzZc89qHb7i1LTyGR4nL9147Vh/x32UL4iJLrxI1TiF3SUVQn+8aZ6ZShrWKs6KvrDnWcq7RbqC15vXGkNuIsJc+RTD5I4vWNNZDpikDYgf77timhspGR13V4fu1fmBsAhpHJSx6OJ2O5QMqxeV2MZ+LpNa81UdUFMoqwcy+CygnkOtxAoknzNF/lsmMIMPdAZCiCyIFAc1Prgu/crASsF1ZFKwA2V4WIwvfacxE0TpXv91gzMxhwCFTgnLkWfi3zaMUDjzKHJZZzh6u4BQG1GkBWKwfTcVnSpQY3EXW3RRGP3sU0Pm5td0eaJ0grlzSpflTlOrNY+7T5zgNlfIWYmenyvJ9B4d/ru7RN+Jc6HnvbIvyP4zNmzJjx2oXUf4MAvAS5Fv4kPvgvXDF9Qed6zI/n3I3Pf/4jN+88dPDA0a+8+PZ36tc+dOSeSw+/JB2yF76huX8A5gCOXuK4DOjZMWieGXCjjPvjIIbKXqkAgj9vIGaI5aNPaIKbxPidabSeNt7hb50mhXhk/CtxEst2Q/Af7p31dc0x1N/h/AG9K5CwyI+6CGmYO3MOzsslcGwJBAhVeQO1fMrwkUUJs42GdT4GKpeXqf3PPccAQyzBIuf+xkhgb2ak6OQzAGilIKLLpwBtPu54zkpFuYvlGFo+qMEbMgMgguzxDwzTTs9IxJoKiBlC+Ben/E9rEKIhD8T2HKrmdPhoWLMWc5Hw9qi4I3r5my+AI9v5x+e8uMWsALhmtTEQR3KKsGEBa5fdeEeerUgh3n5ThC1BCbK3Cf9dnj8jwn/+Jm4I/8PPsz0hsFX477yib3IK/zNmzDiLYQYV7DiOCZ74Xrx4HR76YWD+OTonY3MMQkYAACAASURBVH4q51z82md+4sjOEzcdfOz6Q0/e9fT3ff/hL77j+gfD7UMFsub1rghA6ZNIJEexPOHqsPIXE6gS24APA+IT5g40TAqxButULRsBaGW7oaASecdOBx8grvLaZ1X0piRbNZqDS0iJ4iIFxzFAGDFxXE7KFjVeYrLA+/lgxXBJ2oGVMTbAnceCyi11T5G4s2ZA4BB2qSde93FasQXWOdSDVR+8ZZhtLDxFzbBk1dHSo1sOewEF6gV6I3wXFs6Orj5wwEVhEmPCVjSGZcrwmvyVDiIrFpEshYxLNIqAgwaQhyz8IuUR407ElLML1KtSwuJyCsCgElxCwnq0mAMxqzhuc29xDUahJmKjdEHSSgRlSkXFSilPS5KMb8hJafOvAP3jm4zVS1uF/1Mo9q2VT9rxP7t8zpgx45yIcCjIgrt+Hm/9I1zyDewZvvqJ+afp3Ir5eZxD8Tt3/Pc37zx8ePflrzxz+9sPff2Hrv7qNZc/48NRUz5+EoBU66VeRTnO20uesvyKAJQGj7GUoBavmlcHUTgGxI/Lgf6WfXb/lkAIqIo1u8jzZVyl0hFEaR7mnpYrwOauBtzJDfgKapey62OA13gpn2M5bWIFpeAa47Sa7T7rI0TyusTKjUKkQFtlFYTv7uBUgbzBEtQp/A92Eaq5DU16TRUIE7OIFnALMTvvJRmUt3qD1njHCZHdEMI8V1b+4An3Rc0gOVer5yuiwyayWFkk+x05+4FiyYtCDYgiYOOzJddaHBCojYnF2SwoJvjGLLAs9t2TqA+OWzBXhVjSmMWragLiInt7Ep1/3FSWxSwfIBky6WXCZa3GoMcT/nux7z7gnl+hs9vlMy4xhf8ZM2acgyECM7x8FLu7UIUovvBz82/UuRLzkzj78S/+4J9d7Y/fuPPYDbuP3fXMO77/8F+++/pv7O4cAwgCkgCEIns8AoDA+eboPpx4W+HvlfMnPfRDrU/o0vR4KVwObNX4B/LA4AmdABCRY00ARp8ijzzDCvIGXOI2mjUoHoI0tZ4ANxMjPV8xUgeJbvkwh3mp5RB49SJRIzPADENbKhgCgDZFmPyBvh2FiJHeBDcI60v1wie29uHSSewONsNBQ/OJ8JqxJ68LwBo6R5uDK86GoaLusKHls+OQaZhqnPduDqQLKNsEMTOj0Ywo+oqGjm7cCaBW+8wiY90ziKiBNKymiTny+eTPSzEByAKDKdyX4E6VbUh24co9BIXI/Ibtae4WNTNh6dkP5LPKmoH47RDR8d0+ReF/dvmcMWPGjBNGpPNlge8hNCtTfPln5p+ssxzzAzib8Tt3/MMbdh49fODYl45+71vt/u+//K9uuebR1WcyMGuq+1sJgOwX/mnWF2mqIQp/p86dKDyXqixBIPLBDbZq/PzBC5ej0FJgIx9rMqsQZ9BI4yBEXhGAuvEyI7F+QHzkDVaXgwjLQ3Mz+ZL0vIGM1epyBffXHpu1qUn4VHMd42Zo4GleIxTFqpFYVecgKe178/bUwy/rTjUFEvbirE8fva2QNkrARMG4BW3plGrqPyb4hncIYQqCc0AYbC+pC2mVcG6xOP0/efV4kuntCUe+5HUjq+A5LywSBZ7Eb7Eq5FB1r+kBWrsFFoc7FmSjz0rjLNk7KB6OC3MI6uYxNhiyGNxcRTRORnIb9UzlSOJy0fqiIp7YNuF/A3C/GuG/Q/+NlU8k/KOdQ+jPhMBqwzNmzJhxroYZlgXHdqBH8z8td358/u06azEf/VmIX/rsPz6iT1+/+/gNh576wjPveM+hez54/f0Hdo9uPTmdOfGzl8+nXoX4WiDPo4S8lBm9YAQRNoYw30t1nV4gNL8Q5fxGGLYTAAG8amSHetoZi6Bxg2IjYw+DG6SgjsFABtxnwsHTZRQXFu9cBSNLEMahMtXETsbJwyZET1Hp8RhMqfhGuXcItevBCi3yXvi7bD9ExkE8KLrzY00cz1Ld0Mgl2nTSy+QkAO0uJMw2MBlDdgv1IgflWn5DIilR90sbTwjzIm4ebT3R5vWmwC9qZBfkKovB+c9MBUTqwxwyTPnSNwmNsl1xh/niQEz4MlFx92jfaQs0i5WNT158MRHYYmPnUbjMzbtGTmMv6yg0xgIAkQQA8pNad/90SNxsfF5notiXn0tLjqGlBU4k/OfvCLDf2T+F/xkzZpzvEX/uFsCAYwJXHBXcM61Br3vMJ/66xuc//9/dtPPI7u6xO5/9nu/ZeeD9V9x7y5FHT/CeYadJzwxRe4KU5uopAlCDtwJYbCUAtdSqf44TaK/E/qaIN6qQw4MHTtpGG3x1cqzcKmszRZBURFa4Fg5UNXOp9fUo6kzq94G5+dIAyqssRzsYj0Eqb2DJtfItQzzmXTf1vUT32rPUTsLUxPxDbZK7ajO8xNtbRABh4YGwo3+yBayLClwkJ3MBfQxwDf0t41B8LjFxrGboBsSvPEY47z3tWAExF0/XUNADQMRMXZDWo/Q4VdJDyVjUckizZEmuLSYIs5DETmQJ95QFZM9iYoXE7S/ulSoRl3ij0CakLmz4QxOUQNNKFCPAHIY8Pxw+4i2jEpXBIvzqptMpyVLmc/bL82dG+O/QnyufhvA/js+YMWPGeRqREHhOcWgPi0MEd/7z+Wft9Yv5rF+P+OTn//ERefzGA48fOfjkXU+//QOH/+r7rvv2zs7eSb35+ARAUgIvgbwr5SgsG6p+1RLsywBszgJrl1639IlK2E1kvyIAUvB3GwEY5vtVvoJ7HnmDNNuMeb3d+ROL036TpvB4TsP0wh+Mtzns+yM7MbIKyISJY/iFSrZHTxdQp0/G0u03vK9Y2SGZkWByg+b+fEvYUVxjhEqB+1wq9xzmGRVYEADNrEvO6wWrb4vbxNhdMWcFAp8GqwtEaEByGuiDQkDE3KVqdkNEt+jbg/T9ByI3gaq5S9TjQlotspASpKtnpBeSw9AdxKJkCACmBSDuUdoLpIMo7ytmiuXN+sL0y1KuJ/PFJSuMjZPFADAvEZ9jlUbUt1ohiHJnaVUopyH8F3dekdgB67cnBLYK/51XjN/ZKfzPmDHjggyHCsypTAq++AvzT9xrHnMQ2GsYn/yDj19uj1y388g1B+7+i2ffee2xJ954+SPvfcvfnJHFu6Vm49jqpIQXI2HAw/nu47yJr+YCkj8G7JB1CqL9UKbkHr4+4n3TtT1P6xBpibd3iWR6A/F3gs6cqCoISiJJV2pv463jxsmXkleQGxSN4Q0Gp/A4VLjNSzYeOAykXkGi8pzVU4mfDZxi5ojKU6YiOCOs6rYFMLfauSSNiQEAwVhQ6RFFv2EXT2gbOQAXuLPyOD5ACVrFD1eY2QgQG5uvlj7g4IFYS4PA0C2vRfZE8zE6vyExGJJgOj6rGPAsloQulfkYbhBSvWdtMQAxYm3kp+/5AbkCPqoR4DU8GJCswFaBA+YkGCS3Ku4Oh8WXTlCpI94499zrd8e/vrLwj3xW60Vk2/FauRiCrIT//eO9vB+fMWPGjAsnBAaYYHGYQhzv+1WHzFrh1zYmAXhN4nO//5EblkcOH7jr7pfff/nRR2489OhHb/vX1Sbk1UehpOO+CgANjlfZgBCxDoi8Wkqk4daxXkLn1YvE7o7VCzzYdEr3gZDin8RE8caNa77iYxrMIeB7oP9NJhPibGJPKVCOhJ55R3ndgZ+LJ8nYVd4BoIXM0q7hUi3863mI1XISDfhB2BrP0NmHvmUbIGBht2ti5dyCwRGwNf9EBhfKcWCZ7QgIm2g+P5FMUBSCDJk7VgPXqvoRQfuA4q1pvI/7c+HMZXUnMkfuDYnljSUKyZYw+I44BLakAyh9O245CRioQWnKW6sUTSWu0HcYn75AYc4vkfLSQQ9NBEgeFQ9YBW4s9g2pKcxB4QJCJEDyNinwb/P8oJ5YOf7zfAEZy6Ad49MsiB8f0BbPj2NFP3iJKfzPmDHjQg/Nv9UAoI5jC+QYbv23PqeJvUYxH+iZjE/d8Y9uWB678eDjVx989k+fevd7D3z13dd/83jVvScb+9w70gTyYbsHCiuhedxTJSW+BKim8iUf56C1BA0YOJrkQDbfSFRNqd4KxKx9DoGiuKV+uTTf+1r4bCu4OzVpacWvdaYU0ASNN2sbD+inH1b7fGPcpvMtVaS7KoyWAUyJR8MxAvS6Ya5fqnnelNbl4iqWDZ1aIW9bIU0vAnCebjyHlLohw1OUuQD6jmg0Cls8H11uIJw8yXOGtK/wLC92h2MZDwp0FgkANcs7RVp64gmwQtcRdbd8/uo5xEAcCwScOpwXjZutLXm2/M9CXpZPLIj5Xy6i7EDqYhz6m+cowkoU/UBdFofEDXLAs8LVJbqIBjnTLIqAiITjv9hLvNezQiBJ6xYvEHnvhvC/P0VAln78Yt/43mIl/M9i3xkzZswAkFlujWli/wqXfQtu+PL/Mv8SnrGYj/IMxKc++9Grlsev333s6kNP/enT73rPwb9+/9X3X3bp82dm9TUBoPZPwTjPSeDIVwvZh0SeBCBsNs3UDqqqae4nkfAGwdt1eeY+AlBrio/N5A8+7PtgDQDKMc/0QiA2+uy5DpV8EF8WmA58xh0meKW+XgaPqmFIHDZ+SBk3PesoGM1Lj/O9XhLnsCrUWCv0Pp4xr3dFq7IM15xsJ+C+rKt1g9ORz3jOBKghWWQsou7RVdNr8V4Imyb7YBd0xrdSYGlrBlBGtNmR6O/J8oZ8u8L3JJro8zYD3LPzZt2pqDmAVjesYhYgW7J5P/sjAbLn2v5VWSogBnUDVLNsYNQJSJYpRxWEu4lKDAAe9GZxATyqmTlnIEiLButQBL6X3Aa/dcP6j2AFECT65/fh1It9B609KeEf7RxCfyYE6qUZM2bMuAjDHaLYOwZVqEIEqvjzn51/FV9tzCd4+vFrn/voVfLkdTtPXHvw6Tufee9tB+57/xV/fdNVT5zhh9oIANEwthIAaRW9hcKLAHT9HtlbE4VdKJajrTkm+MpKUB/vItIlNioCUD+P00a+grifKD/d85vvDWdGWe2R4nE9jdrD6A7ka9JSvCiRWevbY0ldSkFHob2t0wCqfhd1ud5xaMD0YhRYLc7cAlX/LMmlJKxGNoJRrQtAjIq+eIriBTrZbzR62kTeII60hEBLevCgusMUsMDTIiGZD/SP7PgZj9rUNXYoEDUDfDFBaO0QNxNA3eC6wLNimHen63pf5MQuW1yQWQgIovkP1FzhcBX4gkzjaDwBM82nIWJQ7MF1galpPJPFHSYiHnp/sAUJow4sKJAmTUJ9jWv+cQP04ddJYobuBdrw/GDjy4mTFf7jG8gkwOzyOWPGjBknHYKdBceOBYiA7uDOn55/JE8z5oM75fjkH3z8Env0iD52ze6jdz73rtv0m++9/L5br334DFr8V0HIm6p6Onk2CUAZgVLA7gSAqxT4pvUlX5WVJ6ek8cEWMDIJaz0+d+UrqN3yANnmshEPrz0wm9G67qzsQ40boO9n7GRI5swhoNhFZRXozxkdhOoWvKF2+NiSoCb4pkUHpQ0To5OxDGDdz6d1inzAWV/rCU95I8UcuIHYTLf9BPovBjJgejpqsq3NsMrke9Ul+u6LO9xi6hZaL1HxbPnPNaMPTzGQksmruygb/rjGRx/uncpFRN6AsD4geEjvKuZwLO6RolGomNEIZOJQYHFhF9R8DuoiZksY/d0kOEYYjTgHTXMWgeWwM3GNQQGsElaQ1XjWQWv7osb8ssTj7lGeHTQvshOG4gwnIfx36I/TF/7H8RkzZsyYsT/csRyEvZwNNnyZ5cKnHPN5nWz80h0/eRWeOrLzxHWHnv3iSz943d7X3nvovu+5/sFlsdf60gl5NzB6IwBScH/YbzAaaNb5gadXYn/5HwDU4lXVSm5AOb+gal66EwYUA0m1XijtA1gt4rRJoCHpNQEQ1HE0fC9lYRriehKPJrJWuoCngZAXPZkQb6T1CE33dWYbaASSZFg2pgIzPVJt+8uuU+yrT/CtyV9Ihw8Kajd2MRZRAHQcaVGCzlWYzYhWnmF8D2gerWxgrpKXG8mK2ECkDkSat6eRB3M4+F5akrgrtfGFTEdQJARATxGZw+IOy8tlisANpio2eoA6ajDZ4i4GiGimNWJQQNAPgVnkK8JoFP3+BbxxY99SgVqQqGgVKgqIRDMjshSU20e0iKhki1VxFygbE1ni9dnlc8aMGTPOrfDsdbF3AHIUewtM8fJB3Pc/zr+fJxXzMZ0gPvkHH7/UHjuij121+9ifPf+eW+Vb77z0/rcd+dvdk+zif0ZiA6Oz0QoSo3ftfzCBTBlgEAavN46uOImGsXq797c3wlCApvTOQEUN+tRW1ymIUVRAztISEZ02gFi5Xa5hdBKAxiWkDCdwd/GB0VnhWgQgEVi5g7rDR1BFqM2GRHCPyjAMR1CmFFwyb9AriYNo9axCLWV5pwqBOSSKg/nECIvzh+giU3Z/pITvWaQbJbadFQTxyP734pkBEI8+pKMeV4TOe0ca9+GyBwQZkKjf9dFN34aDqMhMH0sMx5JWIuOUsTIOVU1CrBBvt8hpLAHc0z4UIxFydIAaxM1NFhiiUhlYnBPNotk/XC0rB8RlcQC+WN54FBhUG6JoQqSOVPojDZQsUSBZ+syvX1Yhx8n5RT/JYl9+mU9e+F95gWbMmDFjxkmGA2JwwbOX4/DzkKNwx57hq5+Yf05fKebT2R7/6x/+9FXHnrxOH79+95m7XvqBG/buffehe2+/9ju7u8fOwm62EgC+BCrWPDBQuAz46x1SB8KWfYp+O8ch/aV074y0g3cdPQlDuW4kUfuw6BBUYWxgHJFS7qmSDtZR8Bcjq1BcAsOQk4yl6ehO7Fs79wHoC8/FkYHRc4rtIAnwwvTxRwYYpvlIVoyd2IoAOG0nYL6i0HYeidZJgembgyhrZCVaWbqYI2E0gNbz3kXcakpXKPFCPI1y0cTiVSGQlx6MRXmVnAUWunj5+IfQLuoGGekCrT5ITBSEkA8uQlDu6f73bBW1JGNxsRhDpsFA8sbdFRq0ARZjvAQwNa1ZYAnujfW+ImrpL0pGwTLlTAFJFi3kw3S4OpMVkfnx1tKUbFOyKVAD9xvCP0cfdOU+ietJdPkEpvA/Y8aMGWcmHIBBBC8dxc4CX+CCo4p7fm7+ad0S86Gs4tc//TOX7zx5ZOfxqy978j8ee/9tL33z3Yfufdt1f3uyU3tfozgOAQjE2+37wAqFo1B49sSXgiZS4LutWbBbEjQ3P0NZdFLz7KYgH1g/jyaaGRA/MX280cvK0jZMGT72ySPs1Uhh1WpZWoB4fo64gjTiQZaSj0Y6AahHMaxBna6gsgoadIjCfyYcWi0yyQAtPbzfgaTLCEToDGYVaCWKDYSlvm4h9P5kGlqfbDS0yX47/VHQfy+5gVF9m+Ycr91qUJHIEsQVzQSC4ThKaF5PTNJTVBAcbMpJPiAi5sVPFitiEF8qWUZlRfqUFkemHdyW2pvlp0DjUG0ACxymChvlxRY1EpFDcIWoIUkFIrsSnUxV0k/FL0x8r4JQ5aSFSEB51iHkTIB25ITCP1NkmQQ4sfA/of+MGTNmnOmIv+cieH4HB/awE1qd4s6fn39pR8xnAQC//Zkfv1yfvnb3yasOPv8fn/iBmw9/4z2H7r39rOP+im0EQPJfNwjA0PjR7f7hLygovKHoF5oPABRX3E8A4hdq2O7rcoMA1CIdZiX0cVYqhxt7nJbyObMZY0ueMFryuk2YHzg+ZPjKDARExtihJTdYnV+XTvRs7V2NYIwTxhtJADSe8KgBsDqnsgoFzavdp2RJLnp1MgQU+2tvKcBrdMjhHtLbEy6gFPv5kIveBED3MNtYJUxcHCLVwj+Q8eAJiKG5bgGR1QRs+JMsAim6i0DM4ItG/W6CdZI0s+hctAySYCLRvSfzDLC08ks07gRgIAGAeDTsd4kun4Hvo5wgXjLXMdMgb3CBSaQILDiMKFxg6sKUiFQqANy2gI5/Pny4iAY/Gc4fYfugaCU0BP6TE/7RzinPD2aXzxkzZsx4TcMynw5dYEa7KvDnvzj/6l7cBOAzd3zkyPLEkd2nrtx9/k+eeP8bdh98z+X333LkEdXXvK731IJCPgaMjsPANgIwMPpwvwwCMJw/PNLgMlj1iwbNWREbr6/OD6jqm3xjLeTzuoTR3BvQKxYaFWn1vpRg8+QVjqc1CMOQ0xYvl1Hh45XMn8hMwhNCDX54ipofCdg4JwE9wATCwNC5qyqepsA/vCjW6w0S7rNEtfuF8ng9ZE2KElDbPB1H6M3ySUXy48i5XZGLoFJOCT8EflTZAEBLPUsR6qJpzYfBopVQNtKJXIFC0OoTogaABn36cMrb47xQFh+7iovrYtmsM2sPLOaIWbiMFHCTBZ4tRNMmJArjcIMVK4jiAbirhJUoGp4Gc5YsY0hTE0zKC4Tw/NDGxk8nRH1J9F/fLn7Pj1/sS+Y9hf8ZM2bMOJuROMWx69gTuODJd+DF6/Cdi3jG8EV32796x89d6k9dszzx1sPfvOTAi//hifd9z4Gvv/2yB2484/37z2AMPz0IK1DIeCB1YK3fywptJy2I12XLOStu4A1GrzMD5RpC31VRkYHs3XueQRB1qInphww/nP1p+xkyf09ZFM+hHt8KcAffoL+ILKW083L7sDYgcxFjzX3GoebbAeVhL+W4ac9DvzeAhiVq8ONO6YBPrT3sQCDBaEUUY3GCe0J8ASzHhKG33AnQHCtUWiDvpYYMcBs1wbeRqITviMECXNyQbKG/MWtzE1VXxyEgawCq8X824kwrkahbsAXP5EBkMLKQYKlEhHnVEoyyCgOAJQaBZad/c5HFs2ZaHIsZXAFfwq2EqCpOd5AX7icHAFTN68spA/RLlmSgblzUHTpKRGQl8NdvKH8BTyT8j+MzZsyYMeMshEMX3PlzuP1f4dCD8AUvXXztgy6Wu/3k5/7R1frUkZ2nrzrw4p8890PX+7ffefi+d1zz7cOHXzrbWzuJaASgKfT7CEBmBuiEAdYweh8BwOocABhY2YfGv3FdKesL13FAvBA5ih5wQSk/D/cNDKgNntxO6NzAEwqTXdBtD+IzrFF+5is8phCMpWJvQ+OHx95HOWzPXcRjYcns4CTjunS8DLdSrpCju5C1uQNqN6mYY6r6e4OjQRrHqDOVWRd6ijqv8AFSKbSDJbmVRnCnpx8mLou5gc3yo/q2iIfnJ6t7yIpkV4W5y1KXqxJbRKmDwWQBkFBe0Ww8iwDZm99jdthCoLy4FW9ZHDDq9zDNGm5RN7F0Oi3OFqKtHZACcYKaAKZugkVzQhmfM4F7tQByZL0EB4R5afZKPsAUE3K6mUQBRnjeji/8O/jrM4X/GTNmzDiHwwwL8PQVOPwClmMA4I4vXRwGoQv5Jn/jD3/64NHnr8RTtywPXHbwuX//1PveuvPtt1/ywJuvfnhn99ww959kdAsQCjGTANBFI4SnDUYPiC+tuSehan9VCpe3NbGNG3S7fzEKNgLq0H/t/AH9M+00ZjPYhsXbS4g7zZxAneP0uqBs9N2cMwxL+0qQ6baX4j+U/9HX5BOQIZC3pMQqsVCnNSyOkUnorIDGocFAJL00YXoZVb/i1ZBeCm0HTBfLjywM+jTrV7+gavJT9QYQNxGVUvQzKZHQVswkpHEH5XaoeYJj1AwBiEPM0lETDqKRIypKMIqMo2JYTBY3j+oCg6anyOCiko6gzFcYSYi5mi4ShchRruCC4eSB2+IC+GKRZ/C4QXFb4iHAtWU5EvfzO5wCP20/aKyAeSEg3f+ikWNyA5B8BpkwYd3L7PI5Y8aMGed5ONGwWSALHNuBKV4+cCGnBS7AG/utz/7TK+XJa3aevOrwc3+296Ern3/09t37v/fKbx+58unz9XadpuSGyNPrQuPOwMr8AQBRe7bIJGrHBj4OYLJBAFIjH9xAWrqAANepem4SgHHdBFWdeAwdvS5XMHrYYCRxKlkKSG/GEyiwXup4OYiKZowZWPkWX10XKA4Q98i2nuHYicuhfDhereJtTQ9IIWTjurZ+LKCc3x5UulwggA20XQs2djFeyuSAw0Wljo8xwOM0WY3xggNe/KE7diybCLmrRYUxBKKIet/sv4kh/EduIU1NYinDc8Mu7jHBV/m5iGOpZAtYZWs2yIOJxFQEd42EgEdWwfMpuUclV9r3DYu7mIpYpBcQrqQaNZDlztD8iw51WNy4aHzWUX2hxeswYL2Q+mp+gh6V38JuVEkqMKC/YyQB8ldGpvA/Y8aMGedPRLUABM9cisPPY9nL/3jfdcGlBS6Q+/nlT//4lcvzVy3PvOWShw4dOPb/PvGDtyzf/N5Lv37L1Y/sHjgbnfvPfKw0+4L4To29cP9+AiDObv3bCACota+RfUIZQQevw2hUlht6ZgYB8H7d3DBat808Us09fdydFDJu3h4M6N+P12q09OSW0LMfBaPX7KI3EsV4GkT/VeZbDCRRdd1vk/876Mdoi5nr1AyvKsAtxxFqFlgA8Xyqo/CAF8XIRdCiw72lwByqPMq74llmoMG+jIUHfJhLJj2cE7uqMU625PfYWzrscz/V/RPInZfdP+89RfriFVCHR2vOfFAaEr5Cic5d0KYBwME2o8sgLZn6UM+lNJ9z3ri6i7CvkUE5eow0gI9CovFRjPxKLX/MkXCif04KEzfQCxSsT/lLJ5LoPyuGcTzhf0L/GTNmzDg/gxAIwqIwM7hdOCPGzuN7+I0//OmDR5+9HM+8UR+8dPfFP378vbccePSthx64/YrvXHnFs2d7d2c61pYeQnynft9cPccF9+6FgIGAlbJG9mutnVfe4u2JC3f7jfd6g8pXYIWwEwmFvJx+GAMd5xTyg2MM8wyyuz9vf2D07tshAYhf1wHxabbZlOHHbmvQWMrwlrCP6QICRHp7gGgclMA6mYDwxodpx1EtgAAUlqV438xFCay9u/YJrCtHkXW0GqRFAwAAIABJREFU9PaoU6ag1M00RT5z5YOKqVjGKyqnmGWtQhUklNCe3zcJNT0mZy3mMW0XBkVYYnLbagJxsUw1DLg/qAi0mgIBHukCzwm+MRQshpGp5xF1SIB7g+fiAHxx0Xx7JA24f7iILGbOQcJqLhL1ylgcDld3qI5SYEBdXCITotUvFVrUK1s8wVUzDxYlxXDE4x0mtP2eH8wunzNmzJhxwYQLYHj5KHYWqOLY7nnvETr/9v1bn/sfrpKnj+w8feXhF//02Pdf8cJ337Lz7dsvffCma54459p3nsE4DgEgQIxTVuC+OuvTveND2AYwcF4r6l1xA4qX4xJSFAI8jQvS/FClsYbx3mG/CYQu5V/qNxXit6Ar5ZGv8LLmjy5DVTlQeYC8hTyZyYTyn6RbyUXcpCA+Rv/NRjlanoEdP4PRBKyPB6KVvli5bhyoxkG0gtBSjw1/jpvIEPvJc1K0jptKcz8v17aU+1cb2Q/2/Sw/EsQEaYjPB5J4N+G+Zw2AMZvhAnHl4w0ALZk9yGrmyDO08oAozLUarKv0fZEJaCYE8vYNriztTWeOZHdUD6t9DggbbCrk/6hAcDVAsLBiAUFUYk3EeGA2LHKWEefsO1dhX1F3DSRfCQHz7BMndPyHDyqhvG8MCFOp79gU/mfMmDHjIogQQFUAxTOX4vAL2NnDk4YXHd/ZA86rzMD5sddf/vSPX7M8c+3uU2+77MFl1/7vx77/tuWBt1/ywC3XPLKze2E4fE4U2wiADHsMQPPMQPDD5R8vBWNIrZ2KZiF4/isAQvwyBY3FsyBSCp5uEAAfXUqb5YbmHGfHzwLTdVNNYh+LU0GPe10TgELDJCfcFbxfd/QLoqJPW1G5dNCE/A1PUTl/2NDGyzjEIl3QRjLqBGi2qU+BcB/pI8+TweQM1McdJaznw1cyJR0GofSsD3M8kxI6yEyacLxGdLVeompwgvvo6J+MxSAiKahHpsKGOp5NMwvQB/AdHh4wDZI4nrYfqOWDWjy69aftPk5DzAKTLCoQkzHka88EiOahkbIQE/U9TeldgjmEPJ9zBqIMID1FAng2BUryUxK/Edwjvzyj9iMzULQkEfoDQKRNcoIyAEAikaJACf/xu3N+/GmdMWPGjBmnFynBCgT4wkt46w4uccDPG4/Qub7F3/y9f/Lm3QcP7774xadvu/3g377r0m++6ervHjx49Gzv63WPfQQAA9znD2gZAKxML0kA+kubVb/tBykyIESZCUYD3zdHTSMA7FNURKKp/iQAI0uwOQyYWBnDceSjutc3rlsKvRmiqb+Upu7R8IjLxruSOYw3NqjnqfTHOUBJ7Ont4ZH1lhJP9+s6kxidwyRzYDfJEA9ySK0AMWIssXLaoszbg+rcQHLGVgPovKkQ/lf5Cm4soLDDNdz/LhTy03WD8VhAS33W4+Z11V3NoZA9KBxWJEHEsMDcVWEaiRbzJTYf436hY2NWuQVwmACnBAxXT7AvW3KamAO6tEqJxSCcYhZYPJ6emtCDhDAsiZsiPEtYgmghk0WAjtEHlP0VVdcBzgrIb2YlVaqFaB7hkGlAdAr/M2bMmHFxhqe0ipeP4sAulgWq+POfPaf/W3Dubu5X7/joG/WhKw8899fP3fqfXvJn33fjt5ad86p355mNtXuHKrtjLfwH8k6wTxjdmIDv5wYUmIGm0POlViBLHR0oSkCID4BdETdTClhtoGw/Y+dDRGfeoBz8VTXL9EIrMxAXuBFsDbW+cR4gTR0l1afGn373YEHJXuKgrIB1brgyBvT8OBA1siD+rmfSCwDae6WxmrDNjK6U9ZakLi1NMVw0KG4ghOliEiAb1RXUWNjaGMvwqed1B72pOcGwzEKwELkyGOWxYXkx0nZfenzmEBAzE7IuIgaEiUHhbqpiPDKeoXCK2eJRb+ACWczdXbMGQKSqjaPA16GQxerusjCA3UWxGBSAmUgULeS9qFHgT+Aukj4fZIqGbYLgzm5I4RJLHpuuJwCob13mTyDBJWJG2IT+M2bMmHERR0isOzuwo5A9LIY/PVezAXq2N7A9/vCOv/+uw/c9YDdefuzZn3jLv373G79+UaP/VwqpfwB0KY8jvu3sVfgo+N0AL/veKzxa50l70TfPbwvlyl6sob9946pMbkCx/+6QancVEWQCrq1WJg54eL03bqB+TKtGKsKVVOEbnFese253KN7OTOLj62t5UpXcWzIizXQhD3LnCTXz40juxEXCam+1MnM2+RTyc6kyY9AwlbfQbFHO3WbttWcxsCTHEn6BYm9khtAoOYjSWQEkYH+jdSjOEB6xtPQzkwBWkTA5BKYC3OOOxA0WpixXuIgrm8AmHo9JBck30xoWtETh9cWI09JihszVCLMl+ZxFRKD8FvDTcRGowj27YEm8V+NO3c3dTbjh/IaJW3CNSnPNmDFjxoyLNOK/ikePwYDFcGzB+3/5HP2PwznHSz7x7/7OGx7Xm+ylxx+/+e+98d9fjG6frbHKABSOHii47DTCH0Zl8PDV+MrAk2I237j5krfkwMgbJDZF1+OBRK5N9S8J2VHeaG5mVBdUvmLVdrPlFrKHaUs7pJidR1l/2TZWN0WJ3augk9uT/jAHNOzuHdANkrkI+nyA7HEESvI5MBhDoW9dicIqY2WFyryB1uV4mo5cBxVxB1p5AB0poE1IYNGlhzsRkdHTs8aEOYbTPSqG023vIXVz2nG1EK2MBN1KSSzUAHF1kbyuKG8QbaRX3ZR64HpV92i3v7iJK2BislCDV5eY+bXEwAGWDdB/D4mhwubqoeuLRmLHXF2X7PYTd+EsLfCYHRYfijoWR7p6wrXVkgDCXxNhbUwQA6Gzfzj+PW1CKi5QgbFfKlRogXv1v+szZsyYMeNCCEeBoLt+4Zz7r8O5lQH4xEc+8oa/2n3wGtOnLvlv3vL/TPS/P0pm3MooQw5fG3bWr7bjvv+l7Zfad76sD2/fijQ7tJNIjHyD71tpKOg8Wup+ifLeZXiIK19NzZtC+2rVnnQokFZLirfla/0U2H2dtdDGkzYSBsm8xhNZXREsJW03FmSgpVOK3JGAiRil+nhXJQRKb6aAHdA08hQthwAfE9+iDyyTA67SHnhmFZw5AmrnOp6hIhpfkuzwswgrTtKxIGgUyAVYxqeT9isyungCVg/cLbcko2tt0su4BYX7HgQWVCmF/3BdOiE7jI/ahFmO3BiX0lq9khWKKCS2LPd10XwmIubu5q5x7yScCreoAUFwCh9fnBkzZsyYMWOgf/i5mAc4twjA7bc+8uCfveG/fuCJ//zWO2dGfRVbXDfb/+V4TpwV1F4B1HqN3nXQQOKEzxuxcYlEhCvXEfF961haeLesOMNTJN6X8rFeh9H9Z1mh+r7TceVGhDjlQOg+Ae0r/YZk36Eqjl0/L8/chjPbkfYkGSfQWFKlGglUC3ZnVUJCbXKG5pbJNAMrS2s/Bf0rUdNI3cgSRAlAcShFLD6gKp+kcj/KRIfWo0vO4szbePqqYAHUDUBexRoncohkrgOAB7iPdqWVC8mcB+BWLItkqR6lIOYMFF2pbZGQZZLG4lUVEYlWQGHkcQ3mkTknFw/gTlYAC05l4W6CeywVt5CPyqJraNQKB38wp4eqvmCjlAYzZsyYMWNGEwsdeN+vnFv/dTiHCMAf/28/8sbrH/8v/s5X337Tt8/2Xs7F2DTZrynB1tyS7zt3fThf2/9egspW09jkasKcja/yFurhoTuPnEPpy6s8xFhqNO3cv12ylsKkXckfwHrzdgbQT4jm3q8t47qNQ9DEBKyZA+rtlNjr5yQDOV9rtTe0kuPVtunmp5E/siVaqvlQDxyW6jixeG5siVxLNrEsgR+se66ruApgrAcgpZHEu6AqTsKWmn1WCNTOc1Yv3OEWVCHgu3N70h/4+AgsAXf47Mlt4NmqJxB5KPL5oLKnqsJhAeclhnBJPT0LvxMGiQpw75W6MXgWRmvyBwvNXpH6vbhHh6OyBoH5EMvTsuQa0VnIHeIx0ljaxScHmDFjxowZx4tzLw9wrhCA//1z/+2hQy/j4M4H3njf2d7L+RcFW1f/jrRexA8Nta/zBvswi9dK/UQ6ecps07mBr06j18XHKr5x0cYl2nXbrfQC2dRuV1RnAPQhO/eVht2lXZXGlFL0hQ9E8h8cXpv6fVt87Hm1bdlCv5o2n3ad+hTyOJsMlV3HW8Vq3tsgG6NwNp/RQMBg631PVgAwO5HXLSM9rzIya1L/x8Lf3H+1/AGBO1j1GyeYi8YILSSv4FNCZkLcYO4B7hEzd5NviAOW047rHXARidLcWCrNOYuAA+zy09T8k0XxHlmhEQmHyG9Q+I+PxwTQ6tKjACx9Su7xxVKYZ9fWdDE5LFof1a9LTFO29BchecU+DjB+Dc+hv/IzZsyYMePsBjsG4oO/dK781+GcIAC/8ps/dc3Os1975rYP33L32d7L+Rdbtf/NV2XI5+Of+8+VjbcBVNAbmF+j7/UCeVYB66aCg2+VcfWO4IlpZX1+FRQTaQ8Peinl3J7kHrSMGaXkJ9ZbUQIv1LjaIDnM2BNQvKCarNbOfFx33GxSpXxcDqfnZHCbtKQj3DLsFzT2kqfluClf1RgwqxDZlc5YWvee4jsW6N887yvhvpcMzzst+AxyI+VpljQD4m51C8bHk08/VlM+PU3+wM81KwCigtlruJZECyBUK556Vhka5qn0HbEEHYCYuy85/Tk0+wTx9YmouJvvObMK7pocAAZoPKXoLxQzJRxxMREjp5IwFEHCicTvdX17GwdYfXvPlb/yM2bMmDHjrIeHb/UgPnjHOfFfh3OCANx6+Nt3P/22/+rG/3ACMDvjOHFC3/+WEwi/2JK+YCvQdM/9awVcHCtvvWgXmfsbZeQNyi2xb7PowB0U8tvJw8MDlEW+mvg3JMrregjMlRrYckUU8h1HmByQeGPZXbgrVyfOjk2w8MDLJsTbrTxBURDP96IVA+Sy+b+AwbK5paIiIWl7tyTlItYmxY1mRDLMOeQdsnrC4izG8DC9JICuXE3sWQXp86lhCdxAoP+gGigvjZiwoDoLG9TdUE816Eg9fn6OFj574acLBdzIrcLfH8wB4u5h/Q+Zn7cfbEXo/6FmnzkRTWrGEmE3qzyJ098vgLsBkuaiBu75XWiUEuhlG3Lc38wZM2bMmHGRRWSk5XL482d7KwDOBQLwqd/50SsOPvt3j/x/l172wtneyzkfa4U+MNjxIMY2MjUE/I1XV2XBq2Y1W8575RggaQXp+wnrHRA+9rJR0Bxf+QLh8a13xrxBU8gpYZMbrO9B2nUTB6eu7D3JkEIz/2VfYoNXE7jXSAEKwh4A0NnQso5nh9OuGSNLB/L/E8ISQ0tjIEIWpXDQwT8WJ2dJQI//n713bbbsuq7Dxlzn9u03uvEk+AIJkpD4lkXSZCSZMk2XVfkDysdUUqaLiWXJdCxKpCC5YJUsxpLtSj4kJRXLoklLclLJF9tKlcsVJ0wcW5IpEHyCIiiKAEESBEAAjVcD6O67Zj7MOeaca59zGyAI4PTtXrPA5ul99l577ce9PcaYY84FqCh9XtK8VKCxKZC/RF2F+F7gda4iprD7hDqXiVs7o6Ng8WY4CY1FKnkj6XBAb3o8n5SgNW0swLXpNt4TW4+5KeJuKKRBe/c7z95C8aawjlm8dqLZosXMhNRECiSojTZBi1wMBOgu/Ec3JHgNhS8h4P8l8yQZ9JUKZHKAGTNmzJiRoQ9B9/D239z+Pw3bJwA3HvreXU+++i/cOK3/319Q4yx/Lx+K9r/hJVtD0AOc3YSvCXxkkLTzg5vL6Yj2obTMQOtQwSSUG4mzFWIqsgJWUFunmMNraPbjdF1NLt17Aq5rUAI6T3w6aSlZXjYnGzOVrE9FzJlQMqpupXzXdLhjSr1b/HKCDikX4XL86HNewGzRzjWX1atmg7FkzYNoPSxrA7T7A+yAFbZKrZQI7w18GS/lPrAGOzaymePL/RJ0LsMFP9ZqbYmYOT1LDthTUKAr8XJJ3fSe9I9VuR0Cb7yjok265Q2ElKVJdjL17AEgYmsheAMgUkSJhkLCLIcy6wI3AlmOwmbg3Y28PGHBAeLdUidZYskMdTuVLN/PGTNmzJhxJYcCexpLe24ztkwA/vHv3Hri6IUfPf6nbbV9MnSAYtSgN32b/xcfdLHZt45FixvhShhUBidOOq2zkrZa58ezZwfOYR6G0QeKgDDHgH5sQuoKDYeTaD08Pmu9FZqTMJ5TOYjB8ZZzc3LFWXDM2NmWkY1r3MSz6gmixhcB+13S5nwMiBJcll46XrnbWMbRapKkMJBAqZF+sa/zMXlLVkWWTyi6OnpFaa2afiSodyb1pycSj1zNWhMyv9JBlBdbHrWxAvtWFNZ2U0RFxNfxVe8HSlOQdRwq7XqgTg4J6K0tUJHizcRv39sZ1Pz7Dsdt2QGhw6p7IXKLBbQVYiv7KtC0idUBB+KPOxTMBfGeDByAb9jIc2fMmDFjxozVBTy5B9y25X8atkwATu49eNfe299549e2O42DFVKgVYSWb33LBkg6cANdAybr6F/LODJur5+G+Qz+irJFU9Vdn1jI7NW7X/aM7IDtE5b7gefosHOwgALb4zQg3s1TDNMTh3QVtUPL/lrn49uF3p4y67piF2xF5oT2hK1FpIeDYM6NhqVAlp3LEwO+6C8nIEE5HKDD1XpSKpO60fzCCychX4DSVV+ek90LR/l2rkYMDYhiTyHNLfKOmCErAQuXvWOPev9Q8+vEzfTCBr8u62wEb94vVrtsdcOingfo5ucRa/XjCQovD1A05hzoMrL+Qs23dmEHUgr/3W6Q0QBVtfXXogWQhPfLqhjK0/MibF1yAE5gNgadMWPGjBmLEODPzuHl27bgbPn816wefsX5Ow/vntvuNA5GJLR//gMQstk4WtHzMm8wnmw4edlH3WYjywPKaemkKa9b0a2XLukRqC/YDteHjZkkBHdqEBkJsAxgbVaaUrjj+BS8DcEHyIspDpdoO2uuaVVO4TXBFV57gkD9ckzRp7UmzqKFjFinHcCabDpUtVuRaYo4p+R8ASsOjptZUxO2CC46fI0sBIfxLEHXBl/umE5+v1eN7n44JjZs3QF0LgtAd76B4FwAwtbTsiUFunhTznjQYkYg0SbunhcrzDUJPesffIk0XxsBTZhBdbcSYIXLK2XFs4JckU/ZC3m96Wes42s0qfOeCMX7aJHrb6FviWXrBg7gz15H19bkADNmzJgxYwhVvPMQjmx0XLyEsbPd07929+6dQ3vbncMBCkNSFbVXBVsCcY6IYw13LLz6eSzK/ioJf/NbSWATQ21+h8OgErWl62kLytIIDOpDJu7y6wYF2Bhd3GsdjotsAyQGbDXQrQ/svpHl0gdUvn1nG9bxK5ElGUNwGcJTjgz4urQKQYsLEIeHInmxPKtr8yraTOduruHX+tp8BI4x7cJ79A/y2+P1DV3VPEJqjXEKw6/urO5bTKtvMUO7LAy1tuoZh+b+ensQKqId0ujQCqJmEySY700UXVuz/v8mq/dML6iqojVrZaTSbKUtrwJhXQR3VBVT97042AX+rp4JsdIJEacSYqUD0uP1kNILNd7RJjBOYBfSyHHthy1efaeaKmY9EpuyWIV1vsdsNJQ1ycxH8cdo27/yZ8yYMWPGtmNPcPpKzgD86m//rbbbb7rqgS3O4TIJJwVSt4zfZ2j8sXlfAFHPStgKN3J4hPF60yrC1QETIEiHbVUsT5OMb2/kGmGDEYIoHp4jCn3zYSYhjVAq+iApyu2G5FPPTkE6CA5LY+kwCYW3XKNXl8Id6gFroxZWoYoel+AglSmCvCksBnKlHDDDSr2Z7E0ZNIieHDpzALCPZzUiGS1iJYA7X+IpREm3q/G+DhoniWytCrfpg7fL0L+q19EilG+uXNBEwbSBrQYgzfV4NWc+IA1i0rut6sXEBLy0oEte+GBJEsuNaJidxMsPxNsCeV0BYh1f1e7FACJWw21kCb3HS0hGFOI9zWZk1vGMPJfg7ySwvlshcZHrKC/ujBkzZsy4ckP69v8x2CYBOIqn/+CRHz9xbHb//EHDsd7G12nh7VnbZeAGMm7diO/jXNXMH410Ft6etUKEskXWtmh8Ey3qDbwXKw5Mb5VhqgV3C6G61BHhPTpTmF+UIpSUSBTpLjw/DnOdDzgWz4WDyRw4z6LPB+cKCGvYXd3bI/SxRH5hQOFxHY0OmeRDvCOkB85ehEA/2YLCe13yhpCxsHKAFboInTwcOHEemnxgTntrDIqmwUB95wag0wsEbdL9BkQmRPh+WCUxr9rUdQlaqH1vz+68ROGyP8puhdFqpb2csQLe5NToGQ1NTrpAab41K/d1IN9SvC8cwF/ifP7xDB30k5EluB93i43JJZaWtxkzZsyYcaWFVfr96K9v85+DbRKAIzh/LR6dKfEfMC4uLI7u/BGaJASsPpkE6DKMmjK6lmG0bN9vBtR086/REWg5pOPDckrq6oGfG5F9RdRKjVxo7OaUaLBHKt4B6EoEnFYC6DyLNoGUJbwWmu5IJDgIGxaJX3kK/6EJF2c/woNkA0reD5+SVnRZjf1ZzgsmFkILz3so5bSRVBGoipla7Kq7rc8l7HLayArAXxUq3clZ8xplgcK76wAsWgDbnQqX123o6EHPqJ/Xtk6u+gdM91tBT46zghYExWuOPQPTWL8Aq1H2Ql7T/dnpVTwp1KC9qzSwMVHxZpHMVSg/4Pv4OZIoxvaHMxcHmDFjxowZzyFM99suAN4mATiBsyfx9BYncCBDNvxtPzQxiOCbd1oWA2wCtUOE4L1xVi56L1mB1H2yw6cMk9LF34CE7ymd08PDnbT4fhqxWw4h1mNnKO0NuEfaYNhNBmZTfEGprTvAq1Z4qrpwe3gUMISAnJfp+DtlY++sn08xfCQG5flVEwSCp5VIcvJgeYLQY2Mnctwf9btqQjoAs8d7BgNwNaJnEYKRKOdpqgLtBqA7l3ugng2JKXGlsAKfm9OygNFMoaitMdxtoS7hztYc2Tw25g2SFpNks6CmQLc8QI/GO2CSwXMOXr/R0L3oQGCeH3Ttmo8sX/iC5tcRv1+s3+xA/FL3wVwcYMaMGTNmPLdoW9aCtkkAdnHhkMz+P883SuvG2DJ+n1H2cDXa8cwCLq8fK+MHXWL95V9R8DgIuktH/AFR2+cQpOnCcCTMnRZkYi00Rta6Y+YRDGGOXxmSbpEU6TSa11GBgOkA7flxUQCkDffHLDZE/pHPkPCK2HRGliIU/MXLjCmSd95O0cpYAuY6RTFMacvc+uHCLITyAnwmTb1YGo7LkwIpLVLZoieaeHJdYUO8rM1IFgRLI3RFV/oatYUNSel/IXHybEF31Gy3s5H22FVYEbPD9IZmT4jFDBT+0SDqaRZWDIuVEKtKF8twNJCf9G6mo6Z+faSQfIID4k9Fn+K9nVRGDsCfIzc8BaOQBQew13QuDjBjxowZM6AXtjyBbRchz3i+MaL35XfCDwZe+MUCtJdhNvDQxRZJ7d9lae6Xm5YdgRY1AMtv6zcEiJG2qBZ8776ChTknqUa9oiRFLr3zGBmHzZOV7u4LtR4utPtuILCOSQ7OnLwogtK8SuXgUnBsDFt3cOCIpoHygyaVi7VVszRSF1yEi+kCEHL6VavABPDIDwCm0PdOSsIqZ+2Ar7+rhL+w9IA64o/cUWNBhQqAXF3Ysg1Srk9Kaa/Nykt1JZ+/AuFEMvu+90YSpyJeW0zSYhfuVb9WNKzWhScyA4CquBnIZxhSvcTjqg+QDzbQPIqBR0PRJwcor89cHGDGjBkzZjyn2DYA3+b5z+vOed3d4gQObhi+usi3HgFmiQi1FXBoexSMrmsYHak6az1o/H8soUzA21a3AQRWi4maaF3qfh2i+ikFwsrXxJFgz3iEQp+AO0FcAq/8UCB+5Qn1Yhy9Oaw1MNiGy+ScIzNCkT7zAzErgvcieJsIndWuXKZKrZfoMKWu5Vibkt9FqYW9pRFNcCD72EgiHJeDWFyVjYd8VvTKkzryKkQk+u4rIX5Dl7jHZunxil5V4Rpl5GzCxRASl4O8zF4MA+5du6q4n0cF0rtdkhf7wuhJl6iaaAJT9Js/cRW1tScEUBFOspnpKO4lhlnosrQjplraIM3FAWbMmDFjxgsS0rwUeFuxzZOf7UefvHBkixM4oHEx7b86X3Kb4bDh2/yiiN+bFfrqwx8QUp4ycLau7eNgiZ1YNn9bgbUiLDHligq0950kR86Tcvw2SNoB9zhiIUFBjYZbEaURw0paZjKxn1jxeafFXzkz/lULpTE4q7w+oFc24hft1b72ReNRjVYcEL6j1CwIL0h4K7S07hG6aACYo6YBbu5npbId2+K1qiTHfEFK7d/5jLLUQbPGwR+OM4gG7f5iiOTCxqqqnU2BRFw6t1raRjbmOxNoS/PbDgDarVAh6hPaolWoqqB7m06xlYQdksfKviBw5wnjcpnKyHY9IweQ5AB2eNCJgQNIcgDfTUBylRwgiNrkADNmzJhx5cXeCmfeuM0JbJMAnNNDj+Pk/Ofv+4jw/UtuqRBmADPxseLdGolOExrlfjL6Yap2vhxnWAxsfZ/h0EGtB6p+Px67HEdjtyWLAJEfcbwTBPOVIF3jgHL5LUfAGO5UcJ1w/TisKyv7BugmBOwF+ml0TmpwnIqAhzAfi0O/ANCcpAn/kosEa33KCsgqAKjP1GbZhV1ujEYI1Nrk2Bq7VOhL2ohEIwkYr5kZCVVgxQzMylcPDragzmDUSYWIuX0AWnHirWtOGzr1eJ98Q1dtrbQtirpepwrdnia3MMuhWhYA9rl3Pm/rOCRZSwCFaBNbyRiB5kO8dw5Asohye9muZy4OMGPGjBkzXthQxRd+Hk9fv805bJUA4PBPXfdHj589usU5HLzYr2h84fvf8P04TIX/GzMDSqqRHVyKch8fNpxsKHIYoctLAAAgAElEQVSUMhLWkI5sxD6h/ROm8/BBNQ8YnpM2YJesJbcrryUAcXbkFCihJ4SCbb24kd6whpZAOW4lZXieDq7+aof5ScYlAaL2VCk+R4MdXm+WqUKA3jMTQse/++yFly++gG7BmADMOg+bg5+C4/MBs3EnL0S1ayukgjenw4qnbU+bEjG32Lq84m34jU54fbLGOgP+YjTbF9bVRyXvpZXWKtebA6dgVKlwJ946MWc/oF2bAE21dzjTiOOWHMD/wi2WrZA1DgCsLw5QXoeyJY6qNLVy28WBySVk35/rGTNmzJhx2YUq3vC7uP/HtzmHbRKAX/iZ//nChXbv4zdscQ6XTQzWBm5S4pJlCqCov3Vz/XtFg3XnilMUCZYLoqXKfdG0AQJ6prKOCvcFpbw4nDiZNyhgShDSrLq8TqwpJBkxPbesCA+MLIqr0cFYlEdVGjAsBuxT8mNNIg+gR9yXiNynIUxHNELFTLloveNBAyI/oGAdbXIht5a4TadgTZb5AjTYc594JLZOsCpRryp6420UiBfMGpr3zjks8NWmAtbv9pWqQrX54lzNeA+b8Ldo/A/vSeSD2H3uCIKhXqSrZTkwlW7tP7Wp24FWyNamTfwRmO+nW96jaZPeQF4VpqlFUyW/7SMHQHKAuFUy0OI1fJ8v/1wcYMaMGTNmXDxWDSfuqRBqC7HlIuRvPHnTV87evN05XAax7iOoLXSG92so5i3cgH91LL6APZsimtRjQElxFpFwsY88QBdIugjhMcaoude5wRF3FAvw4uNwZw5arpfjcFtOPGR4ovnAdnTmlDn76YwV9EDkGgheA9mJS9qB5oMVpf8+sDjV5bBSpQuI8rOjShmeRuEP5jJKYFtkcgGgZsXpZGgWLe6cOIMi0/Bb10g5AKtF9uxJwnfjTF17FCdEpbIC6KbBx9RFFd2cNd7/tGm3+2l3o3EagMRFWc6iAWCFQORGmr8LzjHU7Vjh+Gf3UoWqNwxFJWjE+o7+SffWd9uI+EkdgfI85+IAM2bMmDHjoqEdj25b89kyAXjowtX3Pv36Z84d2u40DljIhr8t4PXGfRe2H37rf1T8XbHv+tk1ke0Steiw1/LtXvj+6/51ro7GxQ/RcS9IgWgD9xmk+spz1B35NQVCvM/CWZOmaUEh2YhRmNNQB+8yFJUOw4bN3+akiRzzqi3/YKB/05LLWcVL2Nq8GtitMtaTh4W/XvwKbhoetKp4JyHOQSG+5BfvcAzeUdIFNp5dQU/LPUSBJh20+PtywugtKFZXiHcytfM1lQbrztP9VieF8OV4s8SFtiEnWmpVv+LZCSV/8FdRm6KzR9Eqygz4kD0P0AsoRxHmmX0yDT5dV0Wqr4h/Lg4wY8aMGTN+gFDFHRfw1LZ/32+ZADx24Zo3nrzz9gdu2e40Dmqkfm9S8fr3JXS5eU2/HyC7DJ/K+IF6ZXmGGC9s3vFH8pOQTGlXWqD2taUEkLp3rskVM67/V9T2PDuBr8nWPjPNHjvqSBRwm3reRu5ccD7XAku93AVvP6HbTQp3MCwYJxkJGfxuaH7MNEIWGJjNfRCnXVmPsmN1ICkG3yWAfl6MMIsiSubBKUhSIqXK7js3+yUhsNac6hq/Of4jDcKhWnHVW4Vw89tmJc7KdXzdv9NVu7cq4kOLtk4E9wBM6fcboBjWoLDsAYLGLNG8rwQsKJ1JebsGcA9K9azoLsyzsIJC6MiOqqKPuANzcYAZM2bMmLEeDXh9w3f79qexzfiFn/vNJ8/vfvbJt+ztzfz384wBL8jah3Efze833nDZ+NfqfkDF6LIYeSAHILaq422U/jMzgAXmSsirGwhOIFpjDmMuxP0wbukm+FZZ3KI2XiKhcOrfiRPZzKdYwxV1gTRulzDHcDw64AkknVDxekknWraKdEOQFVQ03z++patKVTsH9zpZg5jNtWpQL7f77AP73TSTj4v0PWZlt4lau5/IS5QN5jrwZT1uVut22p94R0i0Om+Hg3sb30tsgSZihb+R0IBqMyYj2oDeYesAeHNPVdEuCu2dt5qOmnht7HZoPtIF4g/xfmAF9f3UdP7wjZ6LA8yYMWPGjOcfiqfP4ziA27aMe7e9EBlw3/kbbjlx9+fuf/22J3IQgz6TTW9RytJVOcY69l9H6cNXQOroSN//iFSozUex65KKROFtKKsyzFyH8/LCkldAILEMcFACpY+llFDGBfvJrLCTqqyDe82d3GTkoF/9Z0J4qbGKV73Y+Ev0skcWlnqdglabDUib4nobLCPhgrqL98pzO8rFQBsAmM+HLSt5Y3Ni5omXICluniEQt7Jdc+xEC04+soZAxCIawr/nL+CIv/NSeSdtQD41s1r5Sm3uzHF465fZPflTmIYoVJyCKIDuc+uulzNZ4SREtTXyMIG1AArx3lz1pGzxUnG+yRIDpvO9LBwg30VyAM12PXNxgBkzZsyY8fxCBYeO4sK25X9cCgTgv/uZ337s/PH/84kfe/zJY9uey0EK9n7Z51v7v9HEMHyFkGP3SQYMe0sKl/X8oeAmIShjSSrK3DcnspgYlfI6VJmzLA/c0DGF/pagFrppr3rKkKQRinW9XOGYBNsgGSh9e5gWyKkbWmQha5mvCi3ssn4Fea/U7rNY787wnSfWN/BPlZ3ic0WWtKF4EyQRQHslMKLabLVdA+i2pyCqIJRVuYKuvk9Uf7CRUcrkhoAjvdLJN3x5LyM5dghres35I5AmzcCx3x+h4UfouRHkOgMiXaC652XVEs+rPCAFRFW7307emZra8ceVBh5N8d6H4hsfdRya7Xrm4gAzZsyYMeP7DQVW16Lt4s5ty/+4FAgAgD8/9+q3Hvuzf/XAX5r/5D17FAl5w9byF32Wu6mJgdaHibN4jawu+s+kmB8bhu+pXa/trvyLIM8iUqH/hhMphktMY0ZNdCxBOFAWmvXT+AQ0Lk7Ztj3uyZIQBHKrDIT9SymfcykucoZsBGPcwGoD1HXfuAEKNgVqfiBFAW9RvybSiwTJ8bIAheFsM9k7+RDi5ux56fCTvIjeHhPX4w4BjbW54uWz7rAiNI66XucY8UyMStod6GVEvzOKrt3a9dggfuPzCWhXbehhWPInlvYaW9nX1v1SLrkQL0XW0fJC+Z5k8a4TihDjX9DFAUohb7xEyKPivY1cUd0tDkwuIfXna8aMGTNmHOhQoAn642iXhtx9SRCAX/mb/+OZ8ydfds09//E7b972XA5EbMLiKLhybZf1fTVx8YZvc4Aoei1nCcRcEHEFgqNMHsNUBbpIoDJCocDNw+VgMxYqlzMOrqxxDSZThtUAjs23DpL8UNhAxOxiP9IyYhDNT5fZA6WTiNkDwkffojEZYnHr0gM6WlLP1nobacZRceeTZQC02f6ijaPXtpt8OgALEwiIcyYClWaTtfwEwKZAJDaGelUEK59M9yXAmOKwvj3Z+FVhK/vCSQi6cgUDuxh3/MNaANkjWIHlvGGjcpjvK7UZNm+SKy7HhUq5z+hSET8Cgvuib9AXZXGAzEhwS1QjDIsDcG7x31wcYMaMGTMu+2j2C/48bv/g9uV/XCIEAMB//Tf+lwdWhz59087n7n/dtudygMOF9pESKD8Mb9wasFh/H3XtQ9nb+5nooqxWhp01piA5jToq7Ufhw/fBkxvEgM3hcp5l4Dph987/SxF6/ULUWUs2sSHa9jpS1uP67MpfWOeQkBQF9VZoGneZkja/dIyuVqtLx7pPQ3P/MgFDh504taUIbeUCLhmDxbvofsekjEZVnPK/36UWqjYQhn6/TaRuPdxQtiCAe/pVqOij+ToDfqLGh2LA2e5nsCn4Ayem7nwcLFoolEobgN57B1SbwK1GLDMYYLr2TuePxkUV8d4IRuUA8coU+jkXB5gxY8aMGS9gCPD4ayCKz370Uvm1fqkQAAB3n2qveujk/7P3vru+94ptz+VABqHIZsmwwuM1LF7g8tpXdcOSEoynWhtBNroYYkNRymO8zbPQclmGoZLqSEin5lzXHCQwFwK3BSeR3DjmQrKzPskGlWMvRo27l+4poazrdhfh3ES1O0z3myx1VgHE3dACCtU6zBVALIWswtSB9BhEgjnYrqw8NTAtELTmznu4297P19JIpBDvjiqwpkAKQBpgFCG61ohfi1prHyrWCi8R5qoLaCAeV4fDIoLGE+ZdDf5DEGxAmE4h9RSHDeXAvRGUN3KA3mFA2/E6fT6IXIXaGsrIc1VQXoX5GCRsYrx7+S4VxD8XB5gxY8aMGfvHZz+KJ27CZ2+9VNA/LikCcNtf+fQjZ3/4uuN3/u8vu+7f3fsjU/v6voIYeAit38ZGHTfVNva2gwwjyeJT7OaYTdbhCc+Q8v1IPGz1K8fwS/TN/xtnQGmZWxKFo4CyQPWNG6nrxxzYIIe+bBrJk9tE68sA6CzcdKU9hP/E4g4mHUZrlPkqRFQNhRtPiPdaNB6aGMz2lILzm+ZdQbUpRXSuhpvsBz1TElY+wAWxhFXiii6q2qnH593IFkxq/UAVEJUOtXE5TjzFqDxWf4IGqP0ueX8hMhfTzZvEhEXMyaPGgrq4KYgAGV3tdqkEz9GuCtW+XHaN4L5g/c5lx8pvtTbsRttPAnfx97cI8yHeL6R6Uqryo1FYQaD5oEODos+hQvfH2Bh0wQHANMJsDDpjxowZBzkMKjx+E27897jvvduezRiXEAEA8OH/8h/dc83ZV57Bhaue+b27/8oz5+cKwfuEDB8Iop5lX63Yonw7HKnl77L2Ib4MAI6hdclyKBCsI6H/2vxMNc8S3piga8N5LmgZr54rBfvynSKdJAVbS/AQJMjLGXIASezLyuCSLKCAzamJUvLPpERyLTbBzP+YB9AA5ATOOQlnGZrkzvkIbULqy2apYtDR409p0JaKPcClBpp2WpYU2cjfsgMqVpRM+tTI8kSg6OhO0LLJKf00TiGgvWsBr9rAlX1jGIH4cmDOGVZuE2reiSiMRhKnc2KBwjDcO6abpHpuUUUjQWoycIC5OMCMGTNmzHhxonf/BX/yXnz3JyUVoEsjVtuewDI+/cm7//X/evdf+6n3vOzwY//2/p849/TeK48/3Nr8x28RYQ0hYAzUPH6g3EyosvFbbjEYEhJ1HAyUr1I7jZ2zhrGGFwcotXnX56ltIj0ldm5r/iiIH5KcSUy7TsmaB2mZWx4bDWISu/NWxYQbtf8mdOaYOG2itegwYQSuV6lt6QVmbClrCBDle9N9vxCB22mEViEAIi1hY4NwTKlloXb5jTOP9jctpGkVL21Wvygxx4k6g2hcsjeM+OLQssXpBJDerTBaxKfRjJ+4I96W5YKI+fvVtjTlHHJZYAHQ4sHZrOoFqkC7qPiJtAm02Z1Bk06mqK2pQppYTsdbIPkDaQ7d+YhFrJVSuqni5jtBgD9Zvqs+kOQvZb5jTNmQ6OWrHq+3u/ptNHtx4ih7wYveP/wg+moEvptofsu3N1/9OKOUOc+YMWPGjAMQ5wFAGu74pUvxV/clRwAs/uW/uvNdf+2nbjz0XdmR/+PB9xy/cPa6I49PGlAiQXrR10fQUFC6Jixb+xb1QAf34/e5W8kNJDjG8Lk2/ynbxfhA9LKJ3YiZClZSYrWkB1LGQd2fJ42vAxD7bmpQVRL+FoDoIMzhf6A3lTyp12+qoIlX0A67OazXoSdl49wGa7/PnOPU26s2CPEgVFg50GIyvgzv8CeSJ9hNa/zWUKyDe4U0FXfpEN02b1BvM1QmPWBXbWAdqiQenCHvpKg0EAR7UYEarRCgdThDcSFfmwoETaVxyeFgfYnaoZZfkC5t8aCteMDO4lNiBqQA+gHcZ2W07xYPvWDuygE4h2fhAJaRiGF9t8oBuLMu2QUHr5g/iETZrfy4OgVd22HGjBkzZlxqYcngHWuXIcAePvcrl+gv7Ut0WhG/8VsfuPnwd47vnP/ykz908+7dbzx2982nHzy0c2Hb89pmpKSdpnOzE1QLAqI3jNJFo/VYN3vQ90BjRXqZWfFquEbdrUIDjkg4ITQBfY4DNUmY8+HZXXjWwJ3CmRdjRDSrCa8GkwmxiC+9HYb47Q7Ax5HILfjOPqbPQchAXOPXci09zuLauVWh8ho5QgwC2lQUgLaed8OWxfKhNGYet0LF76E2NLEJd5sDl3hQiNW6dqcEtlvLS0Pr/mRtzKatKRRqqrwp+s1m3tGg0gWizW5Rl+aXqaIiXcWLgmWVw2rrAqDtKWD7q3QjD9og0lUU0iEm+QOiHb3ZPAUqHSsFOpoYK+gO7rs2SFN/9M3vRm+9Nau06DYxbWhWENB4B6CwmbSYkood1WwFY+3N3xBtgubPkedKNd1+AOBrkpFRqOVA6A8yzqBes+wf624kPzbocBS5pZ0utsRbXbgmVCuHKc2YpNAYpjNmzJgxY8YlFQatzkFWaIIGfOaXL+nf1Zf05CJ+87d+5vTqzLU7Z645+uRnzr3r+PmHX7Nzzy3Hv/Xqqx5atUtgPeWXNlgjGdbgDQTAX0QVVUKLKkIDqATAACsclCSvSL+zOuyOb917HlpsVMjaBAzMECInwrYS3MDoxh+48pMkyMZAAEQbLzkJQKUfxPG8BNuoQJwuOIYmYUiUn+flZXJ6Eveta3wW96ZXCgRx8lCnLUYqGhTdDPTKXEEC+mA1Dk/VgSA6xBG2mknGcLYUNiLeIzOHcujZ0ZS0B3CYrmbL8S3QJtp9cFVRFWmtd5irB2idKQj7ljeqqbTeG808PkNbQsxufvenYHNocd7eg9X4Kcp9WwHoWMWlAa2r43WjNyQMfOgqkIa8b36Ub1E+I22Q5ukUOOdhzicwPUYOkMmOROTC2ovkAJt224j4N3AAYXX5Rg6AoCU86eQAM2bMmHEJhamZ5lF9/DiOnsXqPABgD5+77QD8ij4AU6zxm5/6+UN7T52Qx165uu/Ekaf+vwt/8YYnvvPK3ftfd/y7N131ULsyyIASE4R+jxDdfZdagClJAMKnYN8oKUEhAInaOaw6amf2oAwFiC5OF0fZUMTTqAxEU6Qnu8iq0hTIgeAJ+a0IvN28xBbxTAJx4ZBA0MgblPNaBeoSwavP3L8Vx9+oSNqFdtiNyhSEKjqJh+NI18VD/o9UgN0xB/eAdO5v0FnQuogtG+yAG9I9FxEzt8ObRgpCodb539CwOGMxbZ6X0GCKvqLb/U8NXsSb5rSuBPdo3Wpm1VkEZNVdgLeURTOeINK0i7aakTBw3xzjMj3StWkT9KZo2nhPYARANMR7z8807YIWuL9BI8HSoLAyZ40zevJErMCAmQGoFTKLaG8qpUXUfhxglOrXOEBI/vvstpkDCAUius42cwAeqIAsOAAy53DQfnXPmDFjxuUR3s6iAc8AK6DhwiH0hnO7+LOfO0i/mQ/SXBfxsX/xoePnHj+BJ14l9x3bPf8fHn/Xje2+1x/+5g9d9Z3Tx85ue3YvbgScXRIAFh8q39FByBcUIK4FwfshsvTtgAkEiWLQ3J9sIY+tOwwmH/frhNSNIADiqieZBmmG/yn514Dv3sfTgTtCyA9hWNDLpflCs0UgVyYlFm6foCthjCmSf1xy6woxRO4kKmoD4uqqtJ/T63bhmRCgm4Wchw/LkLFSwxanFhBRK5AFHfzNiAeA3r2WV1W0Ne3g4GYZIkpWaGvalWeR3gW2ELC07u2BBsrhc5OmgPaVNukq6NBV0y4dImhGM+iAsmtfaXiQ9tQHl9bdqBPEyZInK9Rb524fWDNUDtjs6cMtTE3sEnoMZeDeMzyxm2cb3A3lzqVU7hPNO3CPLAo2CfO5JW0/spkD1ANDvC9oXrizEtBLJBbK3NJTZIMpT3eQf3vPmDFjxsEK++XdFJ2IC3pgxP6NcVDnvYh/+PGfPSGPn2qP3Xzk20d2z//fj73jNfKdW45+6w2nv7t7ORYM7EcAXPxeF/JTKSdqzw7qvtH2HgiAOqRRFy/3IwAgRi+HRwWCjvuTEiAJgF9R8eHEVyHPZyZBMy9h06YkDKDX3AJM0g7XTQr5yk6W6cNB8TIF9FeF428ghm1MmEjMGUXmh1v5q2cmYDESo/tMHGd3FbXuQOQGrEagxg+weac5efwsPY1Aarq4/25yAb4kAeDDWlMgGBYXsVyHusDvaLuzdMG3iKv+vWjz7jvqglXTLgp0aaoNql0anBVYlgNdG1pTbarSW0MXyxt08AI7a6ld0W9+D1VEzIzkhIcpBZsbuYQGBxB0vyJVS3E0e2pxdemoCeA+2vHVecCaeF/Bvf8oFg6Qqr896SgGwMU4QKYd7NXfhwP4yOI/ZpMDzJgxY8aLHL27w+fUM3hyB3sCAALcfimt5/W843K4hkX8o9/5wCk8fs3qsasOn/sPF977srNfveXIvbec+PbLTz562VzuRgIgbsTfTAAg+cEJQKJwyFhADEfk4tKkmr5PD0+hB+nPQRKAQhuAQPZxulD0USfjhpzA6Knxx+nG7AQC92dxcLqMMG5JAw9Eu+OxmjeoJQSA9K4wQ0vieImcBqcd1QIApIuIIhAtVDpdSbYDzHbvVn4v9i31BoU52FWbn95gX4d/Tm+9qkrXhrAAuXwOFSk2nrjMZq14ugZjaRqwWKU3Sv666lA7C8QIA+sEuujKDDaGxVcKUVE1S4/Q+eOPr5UshF1XVBSsAHQz8Ph726BNG7SLtQTlDEsiguOIiHbeit60Ab2FNUgs6WFEghwACssPoENbGznAoOg7B1io/gHcFxyAW5IDSDKBkQOABp6kBM/CAcrcJgeYMWPGjJcg3NYvkO5i/66iKY7s4dMHVuzfGJfVxSzitt+97fj5752WMzev7j5x6Jn/98w7bj5y7xuP3fO6Uw8cWu1te3Y/UAyie4qRVMfXCEB8CNSOQgAI8TksxwkXjRGA1ObLbgiAjk0EQN25UH3/dRBAutq8ApU63JfiL9LKFlyMDS7B2oD0IDkO02QUkUCgsF16ehr8dcLA25vJgeQSsEpc2vcBK2AlcEfATXf7kCS4nu1os4POforZzhxMWa8FA1JyDm6Iyv9MXM/khuH+kPnDZlMKmrsihX+4Ccq2MKdRpXSYiq90LnWFW4/cONSsGqGL+LeyIky3uwrIShVuBxJBj/mvNK7Xbnhv9PqLhK3fOECHdRBi/UajTb9FjYQCMH+/fXBrUMuHiOIpcuxOV30g6RHfa1H0hxZAAdxjHI+xttjfwtoUSEcTPxH/wAHEf1rWd6scQHkgZzhjxowZM553SIc2oOOOC7hlBydt2R69TMT+jXHZXtgifuO3Pnh659Frdx695vBT/+mJd59effOHj9zztqvuOXnk6W1P7fnEQACsM48aSh8AOi5GAEBjP4o2jwUBQNmZXnkQbkICmkfqwGG3sl8QLUYoBCD991GcoMM4lVQYbA0BfkwvJAEouYLU9WFn0XDddK35ikX7HeGNRd1I7bkMnnkMl+E1DTzRb9Q9PJ3Svqh0AcF6ObWAQLaAe6Eu3gGvN3B/C4mHXaZ7gYrRqKnAO37aEyRcTuIhLcuXXfhn21DH02DNQG6XJr2LSgM8veDl0WgqXuxrCwh3KLR1CZeOG4e6NqiY+u53oDNBIaIdQFNprtCbou99irzBaEeDql9Ch5inqGcWRawNqD0gcweJKFMB4s+05UINIdUPHCC20GZmN1cuygE2NgYN8T45QAyFBPexxe1VGJMJZbdE/KWMgT+qM2bMmDHjuYcvfak4pNgTqOIRxdOK73bg8hL7N8blf4WL+Icf/4Uj8uip1ZnXHf3m8Z1nPv3IO245/I03n7znphMPH6CbUQkA8fQmAlA0fle+ww+zDwGIitWisgeMjvrd6ilKJ1KOo+IjDSg/C38rN8jpEYVXBO+8YiwgBolHEbYzvYBA576/EYDQ6UtWoTqI/MI1gXjwGTP389LsEmqdALMEy6QEFetyINL3X55U8cY4U/I29u5+icqBUPRFVEVUejTS8cNb5/zF2IL6gl/dymGdsTS/Y76Or9dFqEq3Bb8MyvMzawDgMj/ZUc8RmlqbfxVVdeuO7dlEO7pPw1YerN08G18bW0U5tP9GBxHUWo5qE+uY1J11OMHwrIJlAARoXv7ruwFqkyn5B21cV2sjBxjEe12C+0HRHzIDz3lxgCWUDy2feSoEB8h9BJkE4MagJWZhmjFjxowZzxZm8lHF7nmc23Ef8+qSb9v/gseVdbWL+Mcf/8A1q0eu2z1z+tCT//6xH7ll95tvPfGNm09+79JvJxoEQNYU/UoAJDC3HRXw3Z87jTcANGB0fBtsYYDRjklc6g6I70QiOIZJ9dWZg0WWINMFkjNfNNfXOqbwqomMTZn1rjWccDjyAfrIVTsoBkcKooB1O1atX1BI+5EEsHRGbfMPwnEEcwCkC3dYDC5rG1lim1cqrtlX3xFU1X3/rasqbf2lyNhNI50chkb8mGpLbmD1xNo6ICxU6NKgKE4eA+JCC5NXCRfi0bwagakAbdK7AK0LkXpSoJV6e6JmiyG4J8fEfgRMF6/cNS7R4V2MrPE/2QjIpjorEOCVAN79M5YCkFwyzA6HKBcI06ZcOyw5gL33CwOPp4oqB9gg3s/FAWbMmDHjYIS65vO5c3jDDk4pRLHq+OMrQOzfGFfoZS/i1z/+wWtWj15/6My1O4//4cM/cuOJ+990+M/fdvW3LtlSgYJ37a/h0pH81t/1RO1Vrbf/DwIQuN8VzLolCECt+l0SAAD8kGdZg++FgeSUaKTxWTvOQxW2EdzAZXsdR3BlPVMQfuGGX/1GVInd2tInAwERc0wv7Do1aQCg9O2BoHuehMSAbITzpHHIvEAC9ZqHMrJ7VFgBTAKgBKWGgF1xT+gvcKzMzADgGjylbjIHKItiu8AdMi3KBqDautpCY0TVbPjD+mD05nYd8SXGoM32iepeX2O4m8mne3aldzcIwf05ccPF8wB+pU0AcKEuv590HKmKRNLAmBJzIAAULWsGfJ2v0jwU4HVxVubqM88AACAASURBVN4tVJMDpOEeF+MAo1S/xgFC8t9nt80cQPiPEpsCbeYAPFBRPEVJPObiADNmzJixMUwbaQ23/yLe8Hu4cDeeVnx374ow+Vw8rvTrX8TH/qe/eWL3iat3Hr320ON//MDbX3H6228/9vW3nr53d+fSYgJqfXsUAehBHA8HFG4BWqJtCVBSCEAV6dNjk3q82klKrS0KIHYlXsWESnIDivRL/d4nnMYhM9IYfiqAfr1ygAeKqtJjY2NGsmKB1yXuCaozJ+V5IxXF5CO8GzT5GEkIuE9lnbq1ap60m58+Jmn4voHuGp95WHQUvUUZa5ATr1Utt6VxvTDPJIiAsJ65BfHUivX07HBSoUItP/wwEOVCY+QVzBuoQAW2GHCUz0JUVr13O9AqFro2WEkAWhegi7YVfHGxlvkNEV/ZV0S0IWbLD7GyL9hcNVv3WHsfE7gt9dFb2sDU+5+C3UKz4xA7CLn5TdlKyHMXWatgPyoLDjAXB5gxY8aMyyNEMzl65k14+jrc95cwM6UR80Zsjtv+yYdOHnns2t0z1x9+9DMPvu2ma771tmN/9qZT3969ZHICAb6XBIAQn7q+fwahuSQloI5eCIDjsCUBMP+PsjNPaOc8Ear5ZyQAhPIxZskbcGL+50gAYktgepv00IIToZUGah+4QeYipFCR5ABx7XYtPbaEy9/mmSQB4cgv/Cq8TAKvSRDYUc3BffdUAP3xNW+Qnwlw+ZnFvjYBa+0PodGoe5IhvDHuIB/aAakvrNu7SGtxIFS7w31X1qNGNibThSW2nekLA9zSuOCAuLWmN222MnHNhLDAwPA9bUVl7bPmN8qvwhco0JgJV/YdlgPrassD9w6RpiwD4E2ztYEB9wWF7UdEWXls/UCrVI/CAQK4z8UBZsyYMeNARbdVflqIlIDgjl+avxU3xLwpzxK3/ZMPnTr62HW7j1x/4ok/efrdN/S7fuT4199y6t6tM4H9CIAXImrB6IuWoImPFzo64lukkI/8VjUbcS7M/fV0zBhU4B7MITEu0bPhIXKMRXIACmEtcjKNIAzFJGNye1jtS94giEd4QqxzTiDpYg2qgxcSVSp0g5mMN8ps9NV6ZOJ9SPs9L0FA2R5cHjihs3+LXFgXRioEDV1TKTe3jycHOFvE0mCAotkqv5YusDpaWB2t+q32NcIUEsI/YbQao0BTwLtwisvnTpB6szUBSDkCuEtnTgNId/6g8ZNpkKxKbYUU+8DXIhBVQfdVAmpnz2AjhV2IQtBbcrCw/XT42mEF3BOmU7xPDjAo+s4BFqp/APcFB+CW5AClXc/IAUADT1KCZ+EAZW6TA8yYMWMGAHToCqsL2OMvcgg+99H5m/BiMe/Oc41f++Stx/Wha1cPX3fokc8+8+5r9+5614m73nr1t1eynYrhjQTA0MN+BIA4PrRz+5swb1CANQooB6jfa+L+8kHtBhA98yslhlYQ2aNAz3UCYG0rB609MgDFy6TKMe3bhOaJnmv2QFUA7YODiAxkIeRnlfCg+nMfvzqFRL1Bd0tPK8zHAfEg8CvdODGrQfhvrpq3FqamPMofdPOnGRWuWW7rJxLT7Hn5XizL6wJb6XslsQLifXuMG3SmRHpr6Oy7L9ZptEHBwt8ob2jdyqO1qZUpd9G2qjcTGjyqeW/TYtdB3Lc+cAOX8BF+fasSjiXDKOFrkIFmdcNRtCBc9QxZCuweJCgHXMB0/7miqz6Q9Ijv40cJAwcowN05QPxqHWuL7VNyAAL3RcfPMjipji45gP9IFw6gPJAznDFjxozLO0RhtlhQrLr9V+Zvv+cU8zZ93/Frn7z1aH/o+p2Hrtt58E8ee8vNx+59x/GvvuGq74XE99LEfgTAQfzFCYCjTw2RO/oFpcYPpwQGbHSNAJBmAKQQgVmdAIhBsdDRS5FuJBwC06vqMAfq9+Pp3OLiU0bK9uplu13jegN8C0RDIzfsKwHuK21wuB8kKvpvupXf6U0YcnxKfhYDowJ4lXBhIMZtfMuyB1GA+LzwWIW3JgFoSeKAsYIvBDFP0+mdS4gqujRFEy40lso6tFuCooeO7r6dbuPEGsNoHYLu98eMQ6pi6F+x0g5bC6xeiwN3RZm8G5BgYF0lJllc+z6OBOfxAgAb0DkArKWpd2dqdByJdqA1qC8moN3eiuZrAlgmRI1ENf4ULThAkeo3bxEmECw/dVEOsLExaIj3yQFiKCS4jy10r43JhLJbIn4p48SlzZgxY8ZlGL0x3QyI4Pbp8/k+Y96v5x+/+ts/c/rQozccevj6w4/98aNve+3uve889dXXnnjopbmnITm7gOionY2ADDfwA4kBtyQEV6XrgNhXKq5lSsGwbLh6iPXVHRM6Vg64v8j79oyeolS4MxfBMStJ4InSiB+uJClmpGyFqdw/ShdSyG/h7TEZPu5GdM8smYe4RU4AwEb4afvp2ij2++AB9xHifeJ7sDuNqGj3laqCjXguwrvXE9B3zyQoIbI19MxFdtldB27v6dKlW897382gvDOW1gXQ1tVMQZ48gbbu523w5YFFVeyiDLJ3b85jd4XLfnWBNAi6inbpraEUGwAkM13q8snRzkgycUHy4/37VbVBmzZf2ZdJAy8eyBRKdPdH6840fPFjSLM1AYw/JGGArVJmu0Ud8GjFAfbhAIN4r0twPyj6Q2ZgIwewQdc5QIXyoeWT9yI4QO4jyCQANwYHsNPNmDFjxuURiq5oK9zxEbzh93DiXqjg8x+Zv+WeZ8wb9wLEr3/8vz29evSG3Yev233sj554+5t273rP1Xddc/jsi3rSDQRAYXgRBNOxWxIAF4lDiVepuB9usQAJgNB0ARKAyDDU8fN0YdLwOW7gBkqUE0QCfl4ELJYA9Gn7KWfMCadxn3OjQo9gC6j7cEpguqCponjoUWaV6/jaZwnZvp6aHiSEWk+XUT08KQqapSm8n2bOioaWSE2Q2EB9MeCYsHfy8XvVusvzi6xCNO1hWsB6aKYJKtpi0hQEtg2VsOJ4usMNWqbQK8gNBPQdccUx0W6rjCkb87NRj3f3tw+VKblXB0TwmakIUxAVfYBLmDkJMVHflySD90Vtwn7/0WEJKvA0DpcL2A+m8y0iey7APbJOyQE2iPdzcYAZM2bMeKGiAytAgWfOYWcHj70ZT1+P785+Pj9wzNv3QsZ//zv/zXWrh+RVj/6b95/6y586+vYjX/nR03cffnHKhSsBQGDWNQIA281BMMDSXtqH1jB6CNsGNiqgNzXahXYIqqIf+DtmAquYLCAe4VQxYFT8Mwgvk9koCDcrwgZhYhmwMV+RWQWJ1EcaeJw20Pdf3EFkAtEgtXUoipWIWQJicbPyK2zZr848A2oyIQavFiOpbfvLbgjrC/+TULhJ1ViKQJcOswru6lH3xrShJrgrRBppRgxu828xcw7ekl04AzE3f/MbHmYbB+JgckAsOwE/kM6f6jhS+o788TWFWfaFS5XZJYg00c66he6ZAfUmoTayUNEXX/9Lwx1kF9gUlhsOAiBqaaAcwfoL7S/VI7YAg/dmjQOMUv0aBwjJf5/dNnMAzzbY6fbnADxQUTxFSTzm4gAzZsw40OEKR0Pv6B1dsbeHO2+bv9NemJj38YWPn9affs3nd17x+BO3fOf8559+58vkK+84dtdbTt3XHCG/MPF9EwCC4CAALiP6zqyLVScAWJPPDfYHWEclAEW/L7RhtAwx7UBkzw+VnyBqc8Hy4mhGJEsCEKwjrUS1kLfAcYKnqtb3oAqZ1ggBPviDTdJl6VwqePDxA1T6FV7P6qiXI3QQs4pymS27md6tQNXWEKjQ2Sp01dzq6mah1jOV0Qq5IiuQcPv4BLwfKEsXfOkuNAhJDqC9dURpr3jJL1gsC+lYKdSXBFaI+EphbLFvIr35dgJz5wd3/4uIt/Znd1FT/bWpZZoyA0ADjzuIGsJB5Lao5mN2f4jQlrkOmqz8ESgikyDqBcFW1LGU6gnQ5+IAM2bMmLHNUKwauv3bLBDB7dPq80LHvKEvYvzaJ289jgetXPiPHnvTG49+8z1X/ekrjz36ggyu/Jc+tXMlkCA4Fqr1AcT3JQBpmk/mMCBjB/R54LB/emx8ckkAlt4e4nsQtWtAfM/oOdxPVkM/jJQtpDTBFpwbSJH2qcHbKlZE9lWqdzphFKIr1XpD59UqM8j2iBWskuEIFXozycTVmZIdI4i4NyYvzTX7aJuT/T05zw54l0yJHpoAWu9Ac+M+3LiPrk1FrMOp9T7q2rj0b80zNIVa/37VbAqkaGIpEecY3iq0C9zAw5V9B3xvqry/GwnTtbiDYPmEqHJmasKYjETpgruDuMawIXWX7WO7prOIniKfmx0Clhc7bm6WMHEGosIlCIoqvy7Vo3CA5W4OytV/AtfE+wru8ycWCE8REPLW2Bh0fw6QaQfgIhzARxZnxpMDzJgx4yCEKppABXd8BLf8Hk5+E03wJ7OV54sW886+FHHbxz943c6jL9996GWHH/uTx9/0o8e//M7Td++2H8gapAQH1TwDh9GpFO5HACRLcuHCdtpgipknvnK0rUL9vriGiLZ5auJ+5VfDPpEKyJKA9AtJTnK0+AsrgOPUfUh9pLnIgWPlBqxeSK9OaPz0rjgKH8xI4tzAjUaFOfisGiTGQTjOK3wvSQmz3ygAX4tKJI+FeLOdyACYzqvSFaaCq5cT0I6v9Aux+lZhi/vC4W/jPh3KPv3uuuHN6dn8J9IImfFQdvvxbIw7dlDWMovTITIDToGiQaoI7Hoh2gncC38wygGK9zYU10IWha9Q5pkBhK3L0w4iQSeyjgLiLiOReHaNCwA7JRvB/SapPrbss5tzgIXqH8B9wQG4JTlAadczcgDQwJOU4Fk4QJnb5AAzZsw4SOH/cOPcORzawWNvxlPT4v+SxLy/L2n8D5/4r2489MCxQ3tffOZtr2l/+p6Td77m+JnnPVpg5XUCAKJ2BFjPelPbGq11HGZchAB0blRXN3OosMqY2j9wA6gmzWAqgJ5+jAQASt2dyQHULEFR6wleNQ4XR8bhaB/O4op++cpJQtiH4qtQx21wgJ15nFQw0WFUxIzpifuDb5jCjcCpUjGrPSBfz8sc+ZSuwVJdCS4UI9CQA3X8ahdizfsBFevpCRpyAtxDRW03ddTbIykB6SxLMI2fVhm78KaxGLDnduoaXtDBtCNwklAwOvsawVp5Rv5B4wJd5re3oQ7OpX+hsIpe80dlbUAo+s7QvGVQEjlw5QGI1RVArTuQ9RdCI58t4B5rMJ0/LFg4akZ8r0XRH+oKArj74PH7dqwttk+DE4nVCAHu/QSVA4j/GK/vVjmA8kDOcMaMGTMuhbDfnDsNe4q9Dp0W/5c25o3eQvyDT/38KfnejTsPXnfo4T98/C1vO3rXT1z91eOr89/vOPsRAKGjpmL0wNNSmABlWjtQTN6nrgwkBgX1bE3TS/ng+9QtNnpwA3OcDwgexNMOg0z5HWB00TvzQKY1aP6mZA4scTO31Fkl0LcRalkC4WkX13R5ruKcYUIAoLde1d3/yVXg7vPiBSqDqBQrv1rBcbbtF+ZSDPSrlfYW3FyJSiyOG21JBc2WAPMzdvIEQCDSu12Cmfjj1kk3f7zlE1ozKxGa9D17H6x/TgB3wvSoCoiKZKVZ3+dJe4/GLRoLA1SMDjlfciOQ5V68v7M38RSU5p6U8JNoWRLAD+lo3vFT4lzZvEgh4kmJ5yDV+xxw0S3+yPz1kotygI2NQUO8Tw4QQwFY2+IVFBiTCWW3RPxSxolLmzFjxoxthgpW16A/CrkwrT7biXnHtxkf+8QHbth56OTu3p39Ha84/+X3nPzSG0/e/9wfyUYCQKXfPi4JADIVYMC6EABCh0DtSGdLMIeBACR01nK6hNpakglYg9oYUg2FAFBZl5IciC2poystE6PD3uRwAGGncTjkS+pCFOhmDAptntida3gB4ksTx6peyjraUl3AdEHMwZlMcg8z9GsnMzFoW1CscwABdPD9a/ptPMnQCebU+EPM2SAyyyd8wp5VcOVbc2Sz9fOeWwrCvExmvndu0DxtEho/JwMH91x4i9Z5lebWmmBKEBp+bHASjGjzb/DVOvZ0BSkEr11ERNVbAPn7Y6mJbgmnluYiTw54FyNhr8/MQpgFyH5eOonHiPg3SPXRFGgzBxjEe12C+0HRHzIDGzmADbrOASqUDy3ff6gLB8h9BJkE4MagJaYQzJgxY8ZLHgYgtAEK2QV20I7i9g/O30jbiXnftx+3/YvbTu49cMPOAy9b3X/7E29+x/Ev/Njprx9pF571wMTQhLCyEPVHAgCQCRBhA8kWEsqHRT42AoSeQ5ehSA6QVBRAXwlAAvoN3p7MM0i0GQ1bRbYA8q41C34SpxuKCnwE7uyTyd3CR1FwcMJuJzPlKwzmIskupYukRIG/EAC9jpzmHA3jPmLtLa9UtmW2YuSmCjRol7qScTpwrGxXRaWJny4MSz4UorRAvaOOoX9nCJFYCNlemgK9L1B4EB7EgmW2UVytZ6mDUxHmWBS1DIA8sPTksaro3tCs6VMrPigu9WWVyj2E/6g2llD0fRUClVgcQNT8UUGiGtAAT2XE5EPs51u+D0wHiKQVCwOP2FOpHGCDeD8XB5gxY8aVGQYFFLjlFnzrW3jqaUDwuSn5bzvmA7iE4mOf+ODLD91/fOeZzz/5Q7cc+cZ7r/riq45erGXQggAYyAVhNBESYUaF3ZUAuNsHAwGILIEDnRDmtZhnsn4g7elMBQTmxmLMKB1OAhDcIAmApyOq6j+4elCZBgqGRu6TViKod8hZZCFQFvlCrthFEhUXZXJ4Il3AF/NCd1uORvkvZ8J0Qa6WZZ154N+W1pxBPAIZU2JHzCGEf1Djt4nlCsQi2uGrCKffhr5/JCj3lX0BeH9S6dLg63kZy/IiB668K/W5BD2je0dUBU1U2dwTYd2Jq2uwkoDGZIgt2iVsChRVAS7VB4/yYgn44gDQbtZ/T54Q9xu+FwWXIYNYDQCZjJ2lGSxWEgMEB0gZfn+pHgW4By7fyAFGqX6NA2TaZPNumzmAZxvsdPtzAB6oKJ6iJB5zcYAZM2a8ZNE7mqCt0DuOH8fuLq69Fv/bfzF//1wSMR/DJRe//E//9jU7j7xy93sv233kPz35lvccu+Pdp+5ZeQ/6ISoBCES+kQBQDq/m+PDfu1ZflHiAUNWkwmACQQBiBKRCT5heDgdiMkkAQtp3WVpYbxCDezaDRvbiCIpMgsS1EHL1DaYgSeAONdlbkicQ1MrALmA1AFzkq6e8DQQrqJNRnzl19GQs3j3TcS3nmYdz0QAFa2fBZv/lEijrujbP0lgjFaHfd5PPoV7y69K+42/31ucNp3AO4wPusWEfJF8xF8w2sCRXI/8AV9/tWS/LdlWtILxpInXC7sg5wFZGI4UQFjdb1S8JANlpo5mHNh5zLtk+3TkYuAJAWTuMN5NLj0lYmLQ5cMcA7ufiADNmzJjxA4ZD/+vc5S9tNvK/5GI+j0s3fuNTH3jloftOrM5/6ak3v+Hwne879eWrDz1VdwjULuHAWSMA/o9+Re2VAIhD40TtozvIEUYODt/H1UgZvyJYB/1IMSCnmiQhLCLpsdFA2CCpoCAdc3NFP31KQmk/vzIYTcXaawC0m8edzCHnE3UCOb2YUmxpYhW6JqIrxf60GNV5mrc+t8AX/4JPoGjqtl6v5wpMic/n1byPZTIHh/Jcw0tgnXwknPrauepW9uRRUZUeXUFFfLkuWwoATdG6Jrj3HvmcQ/ANmov8r1DR1tDdXJSGHDWXl8H0sOgE5xFWPMdtLwsIOKKlnO/1Cep1Aj4OF/dF8w6kZUUC5CU0OoKk+7oBPkJJL4gTTf+JIrgPRL4u1V9sNwfl6jxgTbyv4D6GAhCeIv7EYdkYdH8OkNySr9dGDuAji//ITQ4wY8aMFyFMsmlmat2F7ECOTZf/JRrzqVzq8Q8++aFrVg+eOPrUlw//0Gsf/vp7T3/hlmMP2ldKYS+RvbpuWDMAwCj8U+p2ebESAIJ1Jc4wkBPIz0wHKZYXbhCYPhV9P138J2uTDCm3WIYc2uacSQno24laAqi6nWYgACpxugCRfpNGSmCNiaJieAT9yTdoeSrHah3KV+qFA2VFT/He5im+0cF08TXFJGNAifpdAQ/nSf0/avYitkqA4+/mBccq6lzFhXlLGnRzzyOMN5mFsAmT3ghdJdHb1K7FgHgUQ9vMWxzCRIc5f0ir6A6KZwHkzinVo4zpjUdjMmwhqkKm1JQ1yoAUjuFlAPBLaF6XbC9nF21N0WCLB8dlBgegQD40Bl2X6mPLPrs5B1io/gHcFxyAW5IDlHY9IwcADTxJCZ6FA5S5TQ4wY8aMFz0EZxsO72GlEOCzt85fL5d0zMdzMOIjf/CR0089/PL24Cv0wc+c/eG/ePTOHz/1tZ2VdWjf0AnU/7kPK06i7SQA4G7p+C+WnuqxSUeQ2gAm05YBgwAg0b/62IFugaQBCwMPvBgUiP6GkbVIhT6AeBKVJAkmkiKQNMpXnudYfDUUCUBoiIcAbBkkmStY898HgscwcqQFvDDDGgG19PpDtKtJ8uZHN+P+UDAA4v5MF6SnX+sEtKGhe/Wt33xO0hv+IKV9sTyDcN0AW1I3LUMBoJt4U6B6Or+T5ANGw+jpVw1V3iZjhzSFAg3W+UdpE6JxSO0rg6n2wdw+zti8VNrX8CI34OUgPD9+jWXFAHhZs6j5voJvpGGpFTRvL7qD4wHcYw2mw3+4DJ0nkh7xPc1LCw5QgLsPHr+Ex9pif92rE4nVCAHu/QSVA4i/uOu7VQ6gPJAznDFjxoznHdLx2Vvxut/HsXtxXvDVX5y/VQ5AzId0wOLXP/XXX7Hz4MnVM186+8Y3H/nS+6++88Tq3EYCIKk0O3JwgdztCIHaCwEgnEXx4TA5oOHDEZKEPK/7cMBuoSbSg+v7hmqOyDxUAkDcX3b2fWQgAJEuEKii+/6cIcsMspMmypZQ9JUJkEgpVOF/sP0g7CI9lPsC7l1zjUxCEfW7kyj70GwCxdnPVEY6iISYWK1Ylg+0dVWjPbWQN5ceCzTs8/SKAtiCX76IWys4npq6ufOVliFPZQS9cfjujKvb0gEKN/DwqywVKOq+ApUA+G2sDftrBkCyh2knEbJenzZz0LSTFiDPLVjqQ7ov+MU6B/M4WVrGmENTKLRxZTSvRba7tIkDPAepHggYvf8Wzx35j5ZclANsbAwa4n1ygBgKwNoWvpNjMqHslohfyjhxaTNmzJjxXMM0jpWgK868EU9fh/t+ErPD2AGK+agOZPz9T/zt63ceOLnz1BeevuX1u3/+V6+649VHHi0qu0c6fyoBEIrzDra0ytg8cCAABu4hMdTwFZIA0BSdNnpUkgBN5pAHEm17k5zCJUKDj5kHW+gaiY7MLaQGD4DidzcQFcmEAu7VxX6BL+lFxT24gd9ANV9Kb+FvYWYgrpRL6pKxcK3fKAxA1fhBYdsvqoD7oEO1H6gsmENXQRu7/fCD3wo203TM7cq6aGPJrDQu1wX/4B0/syY4iQpoqmHbGVXJAgMBOufvpnzximR4Sx9376SBR+KqwcwDz+XAPQoGRMlAWMir2lTtEgxqk8P4gl9RDyCejoBaVUCHNSQV73BaBPJq4OFP0WJL7rndxQHGgoGYpP+YDxeSTiRBJgF4YNASY0EzZsyY8RxCFdJwAVhZq2nB7b80f4EcvJjP7ADHhz/x4atXjxx95YP/8f27P/G7R378xOfeeuI++4oGiQ0EINR3/6DqLUTNzlCPKjmEwg1GAoDMKsRZgi2EVwcqMauolAW10TyXq92ZMXD8xDl45ajErOhliG8Lo6DPO1CsJha3k/ayfwsNmymIRtoQBbsh8AvEvT1m1tcuDQp25Rex7cwewLv0xAjONKDNlwBD1CQU572QwzBN0bki7+K/4DDitEENoHckA+nS2ADHHf+q5Dx02mCh0LvlBtCGBnfm0ARFxsK1fuuUjB6wsFickrVILGgc6ykjX1aMg7fYDRCu6kVaooCZ+5tAYasEsE9orLkmqtI89ZEz8cZEvuaAKFrhANUYs7ZlI0z3d89x9mDgEedhhQNsEO/n4gAzZsw4QNGBVcdnL+D1OzixQge+ONv5H9iYT+7Ax0/rT7/6CzuvfuLRN3zn6c888ZZ3H//CT1z1ld1V30gARNNRQ9idBADBBEoyIeCvJIIn7q9qfTlLqSWInVHzDJVUxJ9WYKDCqoCA6a7Tw+T8xOhE//Fhad+vgB6CoQyAmQFEnqTI7SizDQk//PempabYX8z6kayAZEIgeAtYQeulEYHOIxUAmmdC0Ucvl2BXFHUCqjyLsp8mrJSCANoJT+vergeIJqF+CfZSWLKlFQIAWnS8Xz7yFlUCYDfZ+oHywOz1CUUD4kHYnyyHCHsPYb0KtK7sa2p9M6OOaNRR8D6MfUjLPuYp6gDYCygeBJqgdUsj8PDRGEMoX9H8RaR6FOA+eG/WOMAo1a9xgDjXPrtt5gCebXAL074cgAcqiqcoicdcHGDGjBkXDxODRHCm4xnFfR24bf7GONgxn9/lE3/vEz/7ykP3X7U6+6WnXvfGo3e9//QXT+0845YSYnSNDEBuofzncBYIEJxWmcoNUndf7pMHhoMoLEBrwBrC8wYKp/8H2R0IZYv7vPNbLXb/xN8xASnAWtFUlKBWvUjU51PKfz0hUNjC4NSHA2IacmIFMd4QJwBduCXKfIEOZgZ8Jq22E3XeolChQE7/fRcmMaqniPi+o9ErZatroSvlcHXVHICtI6ZMJrg0Tvjo5MQ/uPCfwBpSbrXEYsBMKAXij2W5HIsLPG/gvh3vIMTDK3OwFA1o4q+Ng7K3T5iOBB3WTtRxf4+3onn+oftVgwanoBDNFwdo1oMIAbgT5QcErzJ5keoJ0OfiADNmzLiMw34ttYa9PbcVfP6X52+JyyTmOpVdUgAAIABJREFUg7zc4tbf+bnrdh66anX2zide9/rj9/zVU7e//PATCuJsEOKPBEDCIu8EgJK8A5fFV/zPwIowSzAmEJw2dA29fyH8D5wBDmwCvqs1b4mOQws93mVYUS37lPwGqiQPrgzg2JQX7vL5sgLYQGGR3m3AcPVEvqIcCM1y2EqEHMeD3h43hPQE+mD5hLhHv/Ac5wlOohLud4GtRuz1BsEfkoDZga7smn3Imn4iuAH77hfqUlR8llLkClykYaCVSLK5UOn3z5LcUL69ZRCHYuN/8cWDG9C5KAEn4I2DPIfQVLUQjOZZFFuvwPlDY0KjlX6gZeZITxF8cQBh3bO9xQMHSLt8gPtA5OtS/cV2c1CuzgPWxPsK7mMoAOEpslnZlmQguBgHyJtvj3AfDuAjCxWCyQFmzJjh0TtWgvMNK/NKylzJ63KL+Tgvz/i7v/13rz505rqdM9996tprTjz+/qtuv+nwmYraqxiPBN/C5ICL+vsSAJrsXUZcEADHlwRXQ01wJhlqLiKTCZFACI8N5czgJOqqalKI7jkEB+ioKDztOr6PFOUepSrX78mQUiiOqSixdSGZSxAgwDqolHtyoMyzZYog/EIm/NPvBEQlQOwmQVf6EtwH5o50BPmJQBWdnX+ApXkmJ8n8Ay9KQILE8onmtpy4fFY8s6sPh8o+POKte3qkC5ArD3A3iSJj5Z1hWqAsOlY+xOIAdREDf73q4gD2ujY6l6Lg2F8naNPW0EtuRKqabj89hQNQIC/gfpNUH1v22c05wEL1D+C+4ADckhygzG3kAKCBJynBs3CAMrfJAWbMmLEeCojimfPY2YE0dJlG/8szVtuewIwXJf7wD/7w//qXd7zrP3/v0d1nrl+duSCH/vWZHzuEszfuPub/ukv5n0X8rWAP/zu/0noOcQ99PdAVZRlGH/fxcYR9Pxfn1TBWZEliQGTbaKP7t55qMKzWJHZzWOnIKoVaEdCIn8ibMKk5HiP282O5RQDAl/0CcxEQx+iQmID4BdZTG9pmQqAQGwANMasoLRVAmk/agLVdujS1nSVuXXqZ1NY144ES0r4Qy+ZtgUhLAOo3n9crfAQqaOKY2HcqVhPhIQZSbVUv8VM6tpZAvT5hkeavhAqa3zhwypxji4cYzz3fFuUWSY7KV1biOn0OfHJip3PQbwifwDoMPA6OF5epPCPqu5c3NF4A3uTxx4vPaTxQeJYC3JHXGLtKuV73zOWjh5DULu6fGDfI3UTLzCVOtXYtkwPMmHEFh3Tc8Us4djcOP4q9PXzpV+SBf/f3tz2pGS9KzN/yV0R87J//9Vcfuu9YO/elsze/8+SX/rMT3xBR1+8DQ1NE518dqbOiN1rrKH0jvhElA+BCviEOVgCPdiNhTgA0mVStXSlpg6aUUY9XW1kWjtFV00afOY1q6cnMg/0fzxsNRoszqtb7NjHbSQjwDt9tPYQUoT05AKi3l6meophzuG7C8d+Vl+AdeLyTDxDulMxpqHZE388wyTBRkG3+0dl7x7vdR/1rzJ9OpzTZg8kWRPceILw9XioQxyoBtHv66fYJGd6zIlknAG/O4/TGLyEqg2v9rvJDavx2IES0+6IELvkzUwGBrS/GG2Jrgbm7KesTBOhcCLlHesTOrqQKdNSkom9saUFkl1uQPK9I9Zu3eOIlme5oxy+DC/jSzsUBZsyY8WKHdKjMjv5XUMwHfAXFr/6zv/Hy3QdOrp6586k3vO34nT958is7jrFDR08CIPwwEADuSeaQbCFgNLMEhQAENF9WHsvwrbgiHg6iaF2abEEkzyLSVQnu/Vu35UipFtCYJOiel1K2S6oAEgmvDUAiYN/TuUT27JeYSTSaLO4dHg4rL2ZToB53Uoo5XsTXuGVToA4RZBvQYBpR+2vDcuYtPpNNhVUm7kDprpPQvGnXyFpwwd3CcIID0L4lNlQ4kVgPYIMjjgqwCxbpAhINf8Ale6PAlx1Ou5EHljdoZA+UxicjgV20q4ovaia+rIHmesC2Zln3FQBU+SGGUjFrq/8MBAcIcAxUAw9it2FL7rndxQGWUD60fP6A5LTTiSQ+Dn9mCwcgC5oxY8ZlHdHex359f3bW+F4xMZ/0FRd/75/9rRsOPXjV6uxXnnr9Xzj+hZ+86quHcMEVcYNrAFJNj5JcIPdB7LNOAEA3vGGegPiGnsW73Q+VA4TRJkVrbOGBhOCGoMqUCgmxbIYo632768pRG1CuBcwAsG4Y4fKHzcGQt5UXO6PoCmjrhQ9Ee35eaS4GHP+hbEEtLFZ6frwSAA70I5tRuQGgtmKAcQMRAUsFIKrorYGlw10afNlmLnpVSoppYRKNDwplR50U1IGyIACorFvegA8aTRs0G/CDjqPo5BOPTGxlNFKsSCwYd2pQRS49lmsCKJr2hgbRlsskR/dPkh9ExUIUMGi0HyXtkegxSvbSnaVIVeXNOZMcIK1gG7ZshOn2JXF20d3d8T9ygA3i/VwcYMaMGS92qKI1iGJP/Z/12d7nSov5vK/Q+OgnPnTjoftPr85+7ezr3nLVF9974s7d1gMGpSqfeQAqjITmw7eB75GYu7IFB/H2lbrmmLW5Ae4VgPbcX8r+AZqj+raMXKjC8s+gLpkcKDB9QSpS8/aJ5TwzIZDyvwGmPnyr2inSI508HemH6ZU1lW79AzdQ6WhgxgCtRfKhF2W9CP9QbdZECDZaV5bkIup0RdOnhCbawx9FDG2PPkuBHW2zjVIDoFmSm0mAItJ7WTAA7eJWfmUxbgX6vphXE6Ubyh9QK3ejMefAKmFajyxvQLNZ47noIPKXpuWqxswhiA3VfbXmgQP4K17LYQuUr2j+IlI9CnAPXL6RA4xS/RoHiHPts9tmDuDZhqGMYS4OMGPGDAsFBK1ZOwcI5jq+V2jMp35Fxy//079z/eH7T63OfvXpm998/MvvO/nlw62HQWUA2eolhdUIROE/QCQItWvewMV+ZEnACMcr2VCo+cwJ37GgItUdpADQWd+Y2vngILKzBCVQ2GpiIh2i3TGf6/0Gr90uD1+WOH0141kQxnfD9zG4wBR9if42Mgj/1r0erCVQ6c3gPumH31gi4KyIiHvCBqAIq4yv7Cuh2SeeJpp3aFh8SobgNdTo2v8nXEDg0gds7mkEYKAQYtYarzSgxg8mCiBiVhy69mPlr2ZzBhMCeaXdaxjQwz3FpkBacg7S2AVodAcZN7Clhc0UFHQLsLQAFNqbthb4PjlAqv4IJE0GvJDJi1RPgD4XB5gxY8alGaroO2gdDZDZ2fPKjvnsZ+Cjn/g71x964PTOk18/f9PrD3/9/Se/eEQuhMcGoaPX+l0gNPtIDozOn3TpOD7RkRukeG/4ntRi4A/iyKTK8GQjZXAB7TpZXRAem6AENiX3loj1INoEr6MxKOCzSvtNDt5C8KbAn0kAwP0zGiK6CrkBICpduQoBRvEbYlI3LUzhJkLXIDOi0hTVlSSqok1EzTwTajcNVGngCZMMOE+ow9/iwEkOMCYEtEGUAN0TAqPwLwCX5ULTDrTiRMrK3fD329wEhuz99kqlCoWNiDt/zMrfVaWJs6BGCpEVw8gMBh1ETgZUcqGxVj02F+cAaZcPcB+IfF2qv9huoOFWh6NCvK/gPoYCEJ4i/uAABbj7VPfhAJl2AC7CAXzk9UzIjBkzDnAY9De5Sxu+8Ivzh/pKj/kGzPC49Z//3NWrh0/vPPn1C6+5Zedr7zMaQAE+dHSki4YyvDrqSEyfojtc7SamR2j5IwHoCNqgCdbtAEfDWDTsJzkpyDvrfUNHr/uLQqvHZuQG5QMMTmlabspZkgkkJfAJmy/fcGSPMR33Bz6upQgOuLvXEIdBX6JlPmzYML3QwNMbRfSQ8735fZ0tWwmJFwlkgW+mGqQC8aRDNCypxldScjVJLUplduQBvJUQvErbbPeD8A+bsJ0XZW5Oh+KvDaH6x2XyWJ4lKpV9wlJ6AbEHUXiKhIUBwT0Eg0ifHGAuDjA5wIwZBzuUgp0lPif0n8GY78GMIT76+x+6pj10Sp742tlXvfX4Xe898ZXdtmcQntWojigK2oaDzoL7A4YCA1tY4HI4JtNom4NCAFLRRwBTwFrdV6RbDTZ+InOquOWDXMLYhXRAUCV2qAPrqOg16KnE4plScGlcoNq8mjnOLpkBKAJ8qRxgUoJlygCkh4MlapFBOJtCPjxv4IfbhI05OFAmMSsrjhWkLon741sK6nFeDQ+9Pd+mgBDTR5rCDTkK9a7/DqlL9gAmqwvPaMYn9DhvXbHLbUKZZfIplaGSXThVkDiRoX/Asg0qzUiUtwHVoFI2oDrob9YJFN4/dETzxmCBTeWwmQdwcLxsHLSA6RY8RcknoOJ7LYr+UFcQwN0Hj1/XY22xfRqcSKxGCHDvJ6gcwF70kQP4D3PhAItMyIwZMw5ImLRwXrHiv9OzzHdGjfk2zNgQH/7Ez95w6KFTh87etffaH25ff99VXzzazhOQuVY4An0Ttovwzy25c5p2woCOYtYPHV0dEgXul4LseRbJdpyag2d1QXUZBbVwoR2RmhCJJYF9zmkHMliphOOiQBcRjdacA7JH804+Nk6nKymV8gK7fUrZ7MhhKM0tfo0929rYbax9h7K0tzuziTHH0xnUS5dRcS6Z+yVYCojpyyIAQBppuLxu6Ohp+ynpAi5T0AVhysraYmM1LfV7epM0tmQDU6L8znO59h+UQ2MoT8soqxEgQEO316BZRQE6Yj6gcQjeg2gw8Ki9ms/OAZ6DVA8EjN5/C61HdpvSwLOJA9Rq4+AAId4nB4ihAKxtIUkekwllt0T8a5mQGTNmXNphv6hlB30PqujAl26dP7kzljHfiRn7xs///oeulYdPr57883OvfuuRr7z3+Fd2pCuQa4ElhCWqTlUeLs2K2PJeFce7fp9Eonp1TIENq0nZgZmHrM0VgWo21UmPTbAFSvLBXnImRZiPvEEeaFA1CEBUFNBkH1J9SPscp0fdcFr8A8I6zu4Q1R6FvCK1B6gA6AXl2z10IxCie2ZNKaAifoNqucZWPCkuOlbN/VzEIGpwG3IaRYMXUbfyK/zbNdW/XoI9MIn8Rq5rRkaR/qjcYjkHgXbR5D/JN6LXJ3uVovYXYurGj5UyN1f6u3ijJCsy7mJLAfgbXww8m/MAZbd1xL9Bqo+mQJs5wCDe6xLcD4r+kBnYyAFs0HUOUKF8aPmkgggOkPsIMgnAjcEB7HQzZsy4JMNUf3TLsEIa7piGnxn7xHwzZjxLfPh3P3TDzoOnVk99/dzr3n74cz9+/KsGAkUoG/MDYouWz4Y3RiEfoff7ztVF4wQghHDA3TKFaeS3hK0OuEXWSwVEHU8DQIH45qhB4RJmLqr+GRIAODdgw36glPYGyuq0xGisOJbSPl03nj3g9UJEWydPUMDaMxjW+v/Ze/dnTa/qPPBZ+5zTd3ULhEACIRBI2BicDL7DkHGIPZOZzDgIm0s8Hk8qNVXjMa5JiG8IB2InNalMTf4CalI15bHjiySYmpSrUhPbCYW5GtQSBmJutsEGWgL1RVJL6tvZa35Y61lr7ff7uiWB+nK690J0f+f99t7v3vt9j/SsZz1r7fw8yv2dyI/BPXE5fACAKyrsO0boHAg+NqE6Mw3qBYsoi2JYAEDcK8T3ed84KMA/OOnO83092ziuqHiWsC2qiwpThLtqFBeKM4a9F88Rc6fOXR2YTEjVtUCdRYG4XeoPzoVDHns5DzGfrLyAAp6h2fora2E6N81f9+TdXfE/+gBryPt5OMC0adMubAJskymB4v4p+Jl2QZvvx7SnZe/8N7/4go0HD7bHv3j6Jd+3777v2/cXcKxcNPp2RZ0xpHzfKf0VCdBA/AMZHIgYQtEURZsSGbAalNBg9FEQf7nogBujB0JCHSDd2xEYPUqCqiXdCqS7YImkfsBfgIqjEk9Ai0PBiOBFRYpzIl0VUesGUC8llJU9CVtNDoSs6O/eQpNMX67eTnP2WirUtmVSBeS4PLRAKIA+BPrhEjTPx+jupUh4MpEbEIMrxAMXjToTyRVF/c2g9u1KOgxQbdoAFe2N+9zgvkG4QNT5dDLZUWM0zi+D2InCqBkFPHkgxEgerAgfYNTZe3cDwkM6bIHyFc1fgKpHAe6By9f6ACNVv+IDxL3O02y9D+DRBpcwndcHYEdF0RSl4zEPB5g27co0TyUSKPCpWdd/2tOw+ZZMewb2zt94xwu3vn6wPfFnT976uus/+crdXw/ZvcN9YoUR32swzXCQJ0MDw1eovkH8s3QAykVApUNNyi/LbAGS5WzJi1qdCieYM16xUAepppA9cHxA7aBajINXonZ0FWVWACiA6WTria013BVYNrCjecYrMoc1vKPk3aFKkI3STCISotTYZMSALoFjYkGgdlL1pcyR+uljPFoLUWUI5qjEnyHZt6ffon4RO3qJnvBJuCd2hkBrVtFfIc76Z8yBWb9eE6lp814l26FJCXRwT+ghuIw+i4Tabkinw+BOSKD5AtwXPkCy/ggkjYj+DDR5oeoJ0OfhANOmTbsY5jyDAsADU+s/7WnbfFemPWN796+//cV7vr534/Tnzt32N/Z8/BV7vhHMNwi4y+fBAUi+uSqIEmbZv8jU6+4XmI74HEy8d/RsRsfxjmKhroxHNxgnlgvVVDQJ7+oAFHDPs8BM6uTZt5xGOdXL19ggYGUe2BG5VA1Jr95IOTiMFT+D+Cd1bUU/0ycJFtylVjCCPCrqBKrGgIlhfk4R9nDJoS+ihKaEBbRzDz2ztlYEYtwADdq1EO2qzT2lgN3xZ8qrLL24hBQKRvfB3SWIcIHEOQAs8iN+305BVIc0QQ/fKRKdPcdX1Mv/g26MVRNCd+RtQY+U449o3qDzhX2AlMsHuA9EvkrVX6iZg3J1P2CFvK/gPoYCEJoim5VdSQ8EF/IBMuwAXMAH8JFXIyHTpk27PGa/fs77Cw6/a/4+TntmNt+Yad+i/crvvP3Wza/ukzNfPPXSN1z3kRdvnViQ9EgKnw4AowTO+geu9a9cjmIY3QBSiM6HgEAR0CsUIzcPFW3ofWDNY6hOrA8X9AcqJVJHSvaBcixx4uwg8g2+S0DqbqR++A/B6ANxkq5C8vRigMQ/XH6jjGwkj54ujdPhGnOoWcJQ8EQtadoVZMRzWyKGkMg7vIumgGjw6OnDRCzFaXhzXXg7VxlpQ4N2oYCH2cZ0h9CBCHF0289mmbhQQYdR+1mtH5mIzLOERVWYuZsxBwG8FpBLerK+UIp/JI4CUHcAwKJArCy0kOJUHyAxcSJp+yUoPgAJ8gLu11H1ceU8zdwHWLD+AdwXPgCvpA9Q5jb6AKCAJ12Cp/ABytymDzBt2pVjCjTB4dO4bRPPaTg8BT/TviXbuNwTmLZT7Y/u/cTv3f35V7/xRw/i4Q8eu+Nr/YU37frmvnaWCYIu2rHP7g04dBFeEvtSopUqqVKBkf3WNfGGX0djp+EPAcEY70Kdg9A9IJCKOzmwY3fABzekQwm4lEUIICKRAABtXK/AsmDRZJhVhEdEVCRwpq0ODVSwWA+vZcTlBCnr0YSCz8CJ1aUIukJ8wmiI+UtdpuZafBgLFOTMY9qAtHhIfKStkNoijdg3AGg8bj4J5ZjRTMtLAN+nAjRFIM1/Ui6n3JSzFm4+MbHEJLlvkk+wrKJS6XEXEEnnUJKvDVLA4+B4VNS4Q8p1Le/Il114x3htC56W8juRwyifXXlxS0cOHo6KvexanrjwdY7Nib/tpWQzWexhbsG4lukDTJt2aa13oGHjBjx2GrsVf7WNI++Zv4DTvkWbDsC0b8s++P5P3va3X39o19n9curjx17zEA7cuuubm3bWFjlNrWCI4EED7SXU4F/rfIOQqju8LL6BOiYiIImExfA3EjJWAYXEBDT8jQLKguMHRO10KTFq3yjRir+zY3zrTHbkGTcfkJAy4axKoEtYQjDhuxT4DpK0VoM+QT8oRhLXsq/gzkD5FfI60LW7BFKmyIWbgBhOOSW42xN+SDofGg6eoFkzEdFYb1a5EdjhxNJQpmSHCmtcyac1+Dwt8W80bHQ449FD3JkhJvYB4jF4YShzM7SAfpCqH0n3eEzuA2DFB+CUsxevxK4mepd85otfhOoD0Kt5Ch/A5hbRiTI3+gA5t4V3wcEr5o9NWzdzzmo5zrRp0y6a2W/kmbNouwDFnuvwhZ8XfOCfXe55TdvBNv/FPe3ZsXe89x2Hdj9y/a4nvtxv+67dn3n9gc96yXhFoDrKeKhmMXCi8NqaAheliIbqHSHOieze8gF0ADRVMeEkRHKtII76UoHx435KV2D0kACh1tbMCRedPUKApFFKKMTudt+UzZSVip/mGw0iYwHKmqTlHN/ozlo6YJKx63ByyZTKKDIrt8EzXKOGach+sjqQz1w8NYLymw7W77fDgCN5AEwIVoVYTX1Ybm7OxIoINfd87AwviUpBNTlYQDVR5AN4Ec/4Ck21wQUqUm4h8NPWzK9ocbowl+nyJMk0Za8QCv8Wdgyw5ydY9KmoXxLsFgGPez6ggCcVNXz24bGsketky6vrcABKmKZNm3ZxrHdsi/+3ZHsb/+nX5q/btGfB5ms07dm0f/Sbd9248Y2DG4996fSLfuDAA6/Z82XifqeDa2UeSvNDvk/wbd+qY4ySODtkDJeCP0qQhxWMXlX7oMwm/ISKgxGgOY8dEFGg++2oXAc6HYnQymdoIkbOf1AygJf+Ru+ASLcjeInI0QpGZxYE6hoJ+hPWe9ZEoGQFWncel7fONk0VVuGUuQGxIX4LA9zZ3ShzV+H7TAivm8+8S47JERhdkTFpgUcOO6Zssb32Pkhsl+cfI2v8Iw4SbioN2t27IKz3ZGKISrMDiTVziAXdqhsxGbo3dY07gfvSBxhgukaDGmoozdZfWQvT/bFKVBxK4C7hH5ewSaYfEJH79Tr4umZLNH+eK5B1hUEVZUXzcIBp0y6xiWLbD5mZB/pOezZtvkzTnn37h7/xjhftevDQxhNfOfuiH97/8Vt2HbfDgBN5C2sBOdanA0BvgZiPzD0AHq2lUTC0tDek6wfiUm0STkXB3D46yf7mx3Uh/wzOHooeTkuUtJdUIgXhzW/H4IZKb5Eu7BfzuF8XNalW1j+qZEZwwAIduliUlGF5PSuHNo9FZAEcwvpaEhQVo0f7DH0YL55BA3AHLG+7N5tkhhQMzdvJaKY98eN+3RspcQARR+SI84PR607G3JpCVRvU6/dzn2PkBmHlJatDKo3UPpODAToY4UQJLAXZPENtMKlM8uIYfIDCfKcPYEB4SIctUL6i+QtQ9SjAPXD5Wh9gpOpXfIC413marfcBPNowpDHMwwGmTbsCTIP4AQQ4PKH/tGfb5is17WLZu377Z/c+8fin/+pl3/mdX/2R/R957uaTScAvgXhxAAyBJIxGwfFB/5eAgIp5F0zJDRyMLgFYM4wAgGU3iciHuEHw60Fa60i3uwMQCiLwvh1CwF30RZAOkSI36iHvcZeGwpWQElnAIQj75PspASrMegH3VlGHDo/nC1gNoiTjI+4BlSzzD6GHRmadSFeDqi9nCNB5o3uQsQ4S/Ag9Em+XxxSYQwIvCmQfoiS/NKhGQSQErKc7UfwK8BADxj3iQ4B7NHQPWSDjBlLUQfQiFEsfIKQ44QNI4vv0AZL1Zy8pGpuBJi9UPQH6PBxg2rRpC7N/F99xB44cwcmTs7T/tItlMwl42sWyD73vk8/7njc973mP7m+nPt5fd/zcxi27vrmB7ugfjlDzT2DgL8NKvqwxnt4KBW/ElSYw7G7oBelaWLtQcygimzYGkrgLkODbgRBDE+YbEBzabIR8sd8dgb89e1MQZYjCJ4m8TqlrYeKvIa1hSrFX/KCre5bfEpw2MJsCyqJAgoG1DSIYYFPUrRimJ8b4KjNrJRZuCFiGaZD+5v7Eo44nEs0IQQ25KlwNBauyZADdH5mW9RLxsq9AoaxlVEi0uhbi14Z4UpxrfbWECJooOVNyiX1lnIdUJI3spXWQ7PFUzfyNFwjf3Prqj1dEhu9Xf4/sNc0BzAdAbqZyQlkUCH7neOGB4ixx30TL7SZYmTbtWzSjvs6cxb79OHcOz38+/sPPzl+oaRfL5rs17aLb//Lbv/bc9tCh9sifn7r5e/Z+9vsPfEGca0fiaTLrCFJ/IP69JQbin8EB/oMi4OEH9lWn6pk5MGhsusJl9yiJCi5Zcdo0xzQdPBl9+Iemih7HDIfYxu7SQqXjlPzgk2ipGpQKHEGJG7j0pQQWsEgFdpFMaoGA2MDWgcwEAHX/gzQo5TdAKnNK9q1NzyrwlBPNTHnP5ODhLLBIDrYd6E1ic5h9myGOzEbwiqiRMwC1kqOS53yhafcx1bya3vxoMBcjIZcZcn9t9L6ab53tswUNQHAf3guWUpyqsy+YuJD3pdc8HGDatGlP1xQQbHacVWwrtvvM9J120W2+YdMukf3Mb/zCzZvfuH7jib86c+sPHfjoy3d/Y21JH1jSLbQ7Ei0UvgRUranDYjIQWPJuZgJ4lR6Ia2Dgmh/AUguMJ9aaTLxIGHCHAUvULl0ECtP29ILR0+UIhF0ap/8A6tEBYOW+EFWRYRrcHxfVAITRTBcuTkJCajYz6ZHnMFRxDijgCWEMJAU5iJTcyIEGWpl8U0A7Cw31bKae0xwSIDpvnpIbDoAtoVVFEHMAPMdXoegtZuW+VlekvogKK2vvq7OZA9LEXALxE8T4UtnZwJDUUxFbF3Ac0Ya1aF4REYKiqEk0H5oiXYL76AgwHhF3HBU1I77X8DEGH6AAdx88gx7FB2CgYVAilcJB6fksfABhgGalWfUBlB05w2nTpj0dkw7dhGxDgKb4xLvnr8+0S2HzPZt2Se0XfvMf73nZX33htfIdv73vb13/yYPtVEBtDGJ9kvoF0KOW3xkIfqAEE5zmd1BILVDQ8DXykHAZCvFMYof4jEioEt9FvZ8aAAAgAElEQVSDJYCQaFtCj84QgaiqdDS6K2ToJcF9TkkiGTrV+Uo4VWuPano19Svry5xX17JLhEciIGCIvyvESnBaCaBeMH0RmqtI5Ph6Y1ihTGQtI+to6+pwIVCw76Y7cik/5xnxBz/1zCC4KpqjcPc3kBWHpClEIuM52pgv0US7qYMk0osz1UG9hulYYzRCTKIidvIxshhRAe5M1Q2mXyq4JwS3N+Rp+ABPg6r3CeCCV5h+oMjbnc8H4BKGwqBB3qcPUERNWLnCV30MJpRmifhXIiHTpk17KlPFHXfgwQdx8gncf9f8rZl26WzmAEy7pPbR93/spn/9qhs+vXVg89x933zDie1+y66jrRQYX+CGQoamBMibEYZlVoAsuotnWbpSuXaU+MibCihqUO9CIBi8L4h0DSCxfxEdmVcgAsBTcmPmnEbOOJeQiDCOinWxvpQJC6ldXh/4Vm5BQDSJ2RKrxWlZrTlKy7k1KftgW5/7KQNatQ9+wQBl3E594YCAQ3Ljxc7wcuGN6+/FmfHhQTCPIjXy/vQ9Uq5+yFeu28b3okncZmum3CgPZSjylgVS2+DejMJ3aJXQ5Dm+Zbpl7hw2mi0TKobpDp01Bs/RJdYVD0B9UjG3IuIvb0iog7KZxLb40GMehdRVxRVB7SVlJus7hhcEekHTpk1bZxbN2yXYsxdnzuL5z8cf/sz8fZl2SW2+cNMuj/3cb/3z6zeOHNp49CtnX/jafR99xe4HC49OkQ+J/yrIWXD8cHWGJteuyIKh8YE8eofHEJCovXzwwv9OZ/pMYBr6iBtIRxDPDAiklF8NrfY8gipcF2r3s8w/xUIeHEAoZAqRH4NDMobguh02yzqhCCJc1MUtIqot1ttdKcRjv1QUoaIpRxBkNEAgLMeZQQmEOghdQn8fI8dRXDVeEeU7wTwBJPE/rCU1RT5U0468OywbIVT+EW2AH0qgPgFPM+BFT0voEDSVBj8coGlI4Q3frpL3dKvWEvPJykv4rEOz9VeGvIJSGBQE0AsBj3koocwZ4gDsRY9qHHxds7KEC12BrCsMqigrGguDrkRCpk2btmLNyBNgQ/DHvzJ/TaZdBpuv3bTLaT/32790y9ZfHZAnv3z6RT9y8MPP3XhcKbc2lI+auRsYffANigMAuFifVCwxLmG0I3itUDvhrNeqD4mLf9V5F1itT3cqhvTZHqJ/UctGyNtpRgYSoBf/pHfPRkBk9NpdTLtCr8YR2kK1D4JgmBQHRWOT+QausXFwr91qcdJV4Mgox/2CSh77anGOL/JHJ9HNv2q+TGr9XeUfmRKhwzGGXZsfK8bDfTPb2ORMw/m+XuZftamqfwAgDSp2fnA6GNK025OydOHmmqLiIwGNCcd+u+XJvtUHCE8gfIBRZz+EEebhAPNwgGnTzmceToQA903oP+3y2Xz5pl1++4XfevvBzSe+cOaVr957+HX7PrUl20qdASE7OgSKRZovQLivWoIDUQN01QGgX0Enwb6yhGP/M0hrOgB+XBfBN6xjt44ApOcpvy64qCcPJA0PYtnE8V7axRwGWaQgBwefqbEWXgjY6uuVEZQ7mKaTAEe9LYb1/SQNb7V9mDJh4QgW6SfLrqzJQ6peVZuHCzoglPVHOrJHA8RJ9wT3jey1RA4AsTuivlBmG9uUelD7QsQPlWaZAIAY3LdJAuaxhPNQhgIbN6g20TjfYKSuAULb0QcgOE4fQBLfpw+QrD97GXAfeq1Q9QTo83CAadOuPrPfxdNnsLmBjYb7Z3X/aZfbZg7AtMtvH33fJ170xp98/uaR3bL9sce+r2+cesHmCQzwHSCCchzlQnwUahbUXlN2ENroaK/84CECUZObJ8kKAavIJ0byYR1MCzNrxXF2jG/3C5gEn54goBSC2S00qiMlJ/K9Vy4wMKhD6jKs31idsg0SmotyUGYdNWUq0vLGdZfqNgIizuijgmA24H++8ooP7lfiLjFgDGKo0uT4rXxrD7eoRjRTFPJGfpfGOQuXJp6NQACKxl1yr6aA8rhpYGNQYpVLEA5UFsVtKhL5Atw1X4YcXSqSRvbSOkjZmKdoJgDm4QDTpu0sE0HvEMH2Nj79T+dvxLTLb/MtnHYF2dt/867n7zpy3cbJr5696Q3Xffg5m09Qi5KeALU9pPOda9e4EiGCDlC3k2Q8Ql80FO5cKPWhQA+NDdDtvkbqB08PYTOoNsnaQShDsVxPynUKHa70HyBK4VB2hCtbJMl7lHk2/0DZzHBHq+mZ+QYlZ4ANUKcHKRGA4RZxdm9RTIks8xOsl7HvQND53rGELJRtCqMfgQuFQFlAyeoLqaA1phkgP5DjjzQDQFAYfRf2sPqnokGVa7En6DkAcRyB//tQK2ytV3hxlOJUnX3BxIW8L73WlhMF1lH1WUpofTO7Mg8HmDbtijatv5G4f2p+pl0xNt/FaVec/ePf+blD7dSfP/mql+/7479x4IENV+WUpN7E/QHfVUW6QpAF+5lLIAqmw8ZX0JJL4GmvhtmqP8ChSPZ3Ty/uEJjun64IcpxwRQKRA8u03UDDVE8QW3dqu1PAw8Kgms4DAsejLsGbeWKrwbuqC8opqU2YVfNF1A5fIHCvE/CRTS7vJUFRsopdnEOlvsiI5jmCFhG/EMF791wO4sPoMLhjMCqRmPhra0FXSHgFVQIkroCKtbsqiTkAykqjjJ+sEccPuQEXQvO2jxF22AGHA6wpDFqKh6bns/ABxF5rrDarPoCyI2c4bdo1Yvbvhl1ncG4D2nB4an6mXWE2JUDTrjj72L2fuPW/++nnbH1tbzv3sSe+97rNY9dvPB5YBhVMhO6fUgXj2hMdYWRDhXIgF6cUzBfjIAh+UIejAazhjLh/NpQzFnBM7RC1I0WLkrIlk0mIhFwHxFT0GTjvbOxlIyBadyNE2y69SLWGI8MCyBS5QeyCnDzvGe3j7iqEk2yjChb6DKhK9QiiVxHJ2KS6sjQnSWhDiYY4RSBG1SORpTTWk6nsMrTcWqrEK6lrD+BIXRTrycaPrmZJcZHEgFwXlTlFb1V48YHiy2Zcgu+YN6sPrvaq0yyAO/dhvFIfUn39BgFP+ADRNZcwFAZV811kuLPWTaiD17emqIBWZ85ZLceZNu0asG4khGBzG5+cmp9pV57Nl3LalWs/81vvvO62r3zlh7Zfcs9zf/jARw9snB6PAAu220AZv5KhgeUNG+bpqSBCJ+GtgKhT74wb1OBAjTOkgCfaOyKPaIDV3yRhj6DzU58T1TZRvooogfQesvvQKdXwBRSWdysYwgLMvnXYnbw7Yjn8R6JjlsGhkCY8kEKZx+CSpYSszGitJgRxZZGfBZbaJF2qlWq6sKKpKHpDZFprU+kxOMbc4hT5UHok8IRgv3sKlpqiiaB3idPHLCk5lim95haHu1LIe/dRSN6bG1aY74Gqh19ZxgHotESzVdZ/DVVfC4OGXCdcl/CugpXn3IYDwsLtGARLKweE2aBDL6yJhHDO8YqmNolen4+D0nERCZk27ao2VTxwFi/ZwKGGP5nE/7Qr1WYEYNqVa/e978Mv+tevPPTZvfvbk5/85uu2ceamrWMDRU0iX6RCI6FYpdDDkhoKVdEWNyFbG/R5AP0k5pUlPol+4MEE0rmVma7sZ71CwtVvlJS7/2lRgg609CsWi0oiFmSyc5JCwCYyYizC1LyvQnhcFxEhYKd0xYCaA8jyLnExMLBNqbG2dbDLnkYcUFdQv421SSYelMHFEnnjKQa+5NMX7xu8MwtAlYdbUK/z4WymkNZiB5S76lR9Je8lNsoDQ5BwFZAtBmKeV5Q7l39ELzasVzInW5KqzyfI28cG+hsqUqek0TY2gq7FslmF+PXHcgXjFXuLXHgk0W75yuS+jZs5fYBpV69phyoeV+wSfK3joUn8T7uCbb6d03aA/YPfes/zN48c2njswe2bXrfvwzdsndQSCkDK/aGCrpktEAVDTeqtqfK3K4BIr6p6oGdycCjsVSGZWsBxECEC5/KlDh6Mvg8eWbPMCTbIqxF5MPhHHNxV7HCAFRG/5kVTt7eIEtQi98yZHtX/SHbcUS/P8ArQ2DJc4OtqqlDLxFUMs/I6nmJpykDLBaINQYmc9nAWWOnVrLIqchtbCO7jnIHc6og2dJEG+yrbSGOCBDMHMhtBSgilRZKASltS9ZW6NhtE/Ah/LL3PUWefhUExDwdgQIMRj2nTrjITQe/2nwN86t3zJZ92pdt8R6ftGPuHd/+j6zZPfEVfdJt++bUHPuXJwSrwKj0J60Org0TYvOjqHVWIKHqcDxAF+EMS40nA1gvEylTsIDG3IcAiswHANOVU1BTPYZDr6AK+g6h9WRQoYholpXiU6wDwAwp4F3osxvZqnmZQvQWX9+ThAFA07V5BCFnkx0Q16gKeBjvDy6cUU82TfZmGG9nM6RQ1CKIOT+JypWBJJCYMbRQsicYVO0mTHyBNe/NiUNpURCDamza7ryU6i3s7XU2nhNbQQ+lEkBo+QFLXNa8ASx8gEx0qTNelDxDAPXoJgznZK2D6IMXJOMCyWaB5B+5aeq2Ic8qVsqL1PkDtGDtQ0Hzs0jwcYNo1bvZqnz6DrU1sbODwu+a7PW1n2JQATdsx9vF7Pv6St/631+uJPXL2jx/7vv2bx6/ffBxReDDMMUzVGZhOwoE+L5kQyL9KPGdKBeVpAKFjYHelCoKobxwh7ztwyS6MYWv7mxoerQAytS6MM8TcTOfhiCtzbUMXIlCgCSSkOAnsJHbGOrSW6zVYFlMKjMi7SwzFPdEGy67IQapEZ1WuE4IlaSHF8a0oObuOk1tzXOxTqpBRHGoqU6sVnlCRD5EQndsILR+omjHHQZdPsBDULpqahwNQwBNZwrGN83CAade8bTRsd4jg3Db+5D3zrZ62Y2y+rNN2nv1P/+auhlOHT77yDc/55OsPfnyXnEvunyIfkPgnj25kf+QGaEQJXPkDlt0cxEKhtDHqU7oSkmb+cRQICl0NB+8RQJBAsRr/sLQ/IubAzGOqg4bc4mimqiqFKa+Dl8KdHohI5Q81P5pzcOV9FtOkaMqaNVFtcEUNysxDsAQIafvU6lhusbDjQvvkV8TJeOp2PCjhqboUmUfoo5XcYouBWGZw0+5+S9T6hJYoRKPIx2IagCuOImO4w4cKXyvFOUg3RnGeK4P3ElKclOsMmLiQ96XXPBxg2rQdZ6qQhttfjgcfxBNP4L675ss8bYfZjABM23l2//s/JH/7H7x0z9f3bZx+4Mnv37tx4jkbj5XkwuTgSbGTazd+OyuHJsRnP+KSVgAurEy8wKUQQUtLZUlVyZQjLqIMG7xruUtM0inmRWRAiLSGuMEwTwiikGVMyb9sBQICwe7nzJ00Xjsfy9+1+6kEgxvNbF6ZTJ3IuXztYLK1AKCEgq0gTolpggy1hzkScUaVG9uMlnIXar3QoBobZTNpPiMNdrpAYb+dJQnkugaqPojwRUgJhZUHCnwvvbgb5aYoS5CxMKhtr5ZeZTPjrYqXiPEBKf+PT4uym4W8D+A+bHgOni+SQujMlLmVgSX/zjiAwAvGjptZ9yp/Q6YPMG2nmip6x769OHcON96IP/iZ+RpP23k239ppO9j+x9/+Zwdv+7OHfvDJF9/z3Ndd99Hd7Vwi+5IJoIB2RFZAzzqh/JbtUc8Rqx9UtdlxUVBI95QAAQYXglw7gt2nwh4GZ0sdzPqt87WL4ABS9z/OBJ6x6iGLHp5MaRknW3nKr6qKGh1OHl0hMtxUoOqlSNUlPern+IoCcWxW3AsZu8jqnMTTLWaCUhLUrsiyV9yFyQaCzCsojL74UKI8HdnCDgCJfL8129DN0N5yKIARAEsYaGoxIMmiQEnVF3FRuFJAIe/NXykKeM8ace/FOyo9pDJ4ZfRLXsFTUvU+AVzwCmVRirydpBy/DJ5LGAqDBnkvoTcroiasXPG0lnCBVpol4l+JhEybtkNMAViVz4ZDMjU/03awzQjAtB1sn3rfB17yf77i4Gf37pMn7zvyQ7u2Tj5381EATqUH1ajwup9Sy0RqsN3K7zwroGA+8pqQUN8LAFnEAQJOMZjAlq0guZCbg9hIqL+PG/mUCeCCSiUi92/ZfWBbFzN3TOnMc6V6yRKv3Df2Rura/bMK8WtGM5RQWJA7sOCS8+hbL9xp1LeWu2Tv2KWmHrYISUkTUY8DIHYv0l6VRVcj0GEbYjtU+WrvW6hwKVR3LCuo+qKzD/IehbxnlKFKaIYqr7Gv+aCoqs87lh9k0WOk6mNWJSIRC+Hs4SGrMrchDhC3DHVQNitxj3iLpNwnoTzy5RfUXmM50dIsLywiIRNFTdsJ1rGleCyqfP7qfG+n7WCbr++0q8F++v/+J9fd/pVvvvb0zfc877UHP7a3nSExj85QAJB8vAIKdbK/iXagiPVZPCfjAHCVuYEfJ/I7KU8MDH1EA/x2SdUjTtTKxhBJJrvy9wIy5TEN5jCYtMZq+PiEa6wgGHoAXCybhUzfynRCooBmKQoEE9lLB/X0TplHnSJK56HMB2BwgGPWmSigJtpBzhkAvCpRrcPjdTzr1lk1IdUo6OlBBu8ogt5st/yKxxy4k9qkWfgiMhl8toiMAhYtXWX03TuJrOiBTcca8p7u2VpiPll581nS+6LnsPbKkFdQCoPG3Ox2VVKlGA8IW0PeLysOna9ZWcKFrkDWFQbV4mEuCoOuREKmTbtSTckVNaABn5hVPqftfJsv8bSrxN6ibznw2X3PPXru+Nduv/3Afa/c82VVdAnUjnAJ1CpsilZ836vYJkqCZioqGydYt3FEQkdUU3LrfYcy/ymD8YL6Cb5R9DAxCP0NVsaMewGAKVhQ7gvT0iB6+QRYfxNRkRMjkvZmQJT5F1FFXwh4lKQ+pPgP6qcEAFGQNFG4Nj88uKtIpCk3hGLKXQLLWDB51cJd8SCD+nrFHRt3Tkxyk5tgaN5HdmEPvRSWMQ1REywhuHggWVVq4QO4FdiazYoPEJ5A+ACafdMHMCA8DweYhwNMu+JNBNqg24DigXmy77SrxdpTN5k2bSfYPXLP//XqXz/+tdufu+vrZ7av+/eP/ujJvhsokgoiEWoTDOWY8h0EOaTOC20bcDsEPuEsLIQOYcoinHlnybv4rFQ54BBmADwx1cEVJTwxNEuuyLCaXJPS1VjMTYnpSnjAAgSNqhnheLyrAKod4GlnIP53vYe61qR3jyu4kyXgtrr3BEgjONRYb67AdtIbECHGzpSnoNCIskSzlHj5+PBcCQqOFOpeDx+BKYy6Z+LG7qkXK4ofI4hSN1nrEhzJRxstnbkDuQblWmIH66PnS2hTjbvknisTCcbtLU5ErDfmxofCe0nZN+UVTQeZzfKd4Qs/dozNjO0138g72rXl3DReHs5N48lOm3blmfunCtmY6H/aVWXzbZ52FdrP3vuOg3jka0++5DsOHn7l3r9QMYIfY+FOx3o8VIvSmmTZgyD3zMkiaHGOMyU9eerWKNFhKMCFN3EEmPoxWwG7fDRQ61Jul8my/qMmQV5my1mlgqjEIppHMyKkYLECVaPe/b7N1xtiG48DxMgQP8PLD9wFAwjOyjP3d8zo9SU0VQWaCrTb5jRqikS7TZiiIBUVtSPA0ES7QKx8J/ccAo8GAFrSlJtoh3bR1lQhsJPCOLjvT1NRdDsLTLQ3ZkVbEjCJamCFmEdC10VZTGfaSxyABHnGAYrGJuMAQd5HL48noPZKVn6Vqr9Qs4rQ15H3laqPoQCEpshXB6SAJ6a6Tg3FJawpDFqiDbMw6LQdYILW/fdmHu817eqzmQQ87Sq0T979sdt+7M4bdh/ZEHz61He9YOvIlmwDhFwIqntMr6x5veVq8N6IKzUVddFGOFAAsLyjIXKRdWNWhr3cn8jJIab1lmEteQvJ5Mtslktx6tt+inxQJkZHniw3IcYW8roCFZTT01i/CNl3UHI7ey8ZTgD5/DbMLXNtiYmbjxapqwx7xIZAVaTxovHqUrdrxNk2Nz+LgMsP/IryQEVqujenN14BNTZltfGcyx/eI3UvdaWOwIfdj7lRz5O9JOYm9Z68sr5ZfS8jKJAN80pMu3xYZhsLF1J+iSRcAq7IrkhpJrHeMrdxM+v2TqQ17TKbKlqcWKg4/CvznZx2Fdp8raddzfYz9/6vhzYe+/rZl75q/8dv2/oaSXrtQhnHmBvgAQGFaCHvFw0giBBBXPRjs+CMdVQCBSJhIPUc5LA17sKEAU9IjZQDF6/zdh5nyMgDkMGB8CIY5WgGzGrWbyhaSpnOpgJRqUsYIyENMVsugSd2BTpvw2wjNOFwu0VChXrdfbGZo0dspGm5o8vXe9MG1eZVXLUhQgS+sc33szXt8CPSPDrROIEG5vh6bAEqItqbWnKwelDCIwDhUGmFpCs6+wD4SZOLPQ9/+Zz5JqOvAe6dqjddATHxmA475BWsZCRHRwAZmqBXU9n09Crj9ShXgtF3LU8MntB8yCtQLSL+nNuyMGgZnOkHujwgzJrpuu3lDKdNu1y22bEtQJvE/7Sr2WYEYNrVbPfd/ce3/cSd6E988Juv092bN289KOiGtQpBOxKfEoQkkUoyoDLgpBIuGBBhUqMu6A4SmvLzypRH+zJyze/kxKR+JULw6W2GM5sQzWXBtZbB4ha2XsnMVLAjJBdfCXJbOvHsGIvglALU1rTXAd0xEmKKI/tQGH3Jwjsa7LLPyv7XmMLUBD3pbQ2Q6o2l4F4Yr10iA7aoyIaqtHT5K/j1pPC5lTXoEeS9BQ2SwsdA1ccDZWyB2wVkMxmmUANE+UQL4OYgyytlYQOjH+S933Sx4lzCUBjUyHuV4c5aN6EOXn91MnSzZuac1XKcadMurakHrLChuG8q/qdd1Tbf72lXv33ve997y/4jL9j98Ek87zX7PnTz1jcNmadwvxD8QFLsKFy7iZxD1J5y/6DhfdAxqYD0f4DjGgooRYEc7NZSQjW7QFDP0uJsfZKCDlfeZ9kiUU8zaFBFE9WmXTXq8IB6GEgequVZAaGYhwTZnyEL5jAgwX2psMk4gHH8yHyDWB178VSyWjjIlmCKfyh6TX6QKN8p5agvJg5niU9EPoC7Mc0LHCEzBzzmYA/UzwLzTSv0edDw9lpUqn4QLDEZQIde5mcU5nug6uFX1scBSrNV1n8NVV8Lg9LdGRYSbpanKkiWEhoZ/SEyMDQDytzWHBCW7l3xV1k1C3RYSxs6rigXl9s7bdolMlWgW7wQD0zif9o1YDMCMO3qtyO/93uff/8HvuOtf+c5OP6Xj37PN9veF+46UijUAkE0SGFH/4Rb4tcGIlPqB2dPjcMO9nogYqVCn5I/SuoXddjksAsrGgMCEDEcHyOTJyZNnmujVr/5IOrRgxIdMP8EOQfAx5dEunWv8uCturqk1eEJA9xDRkLY1yslxXIakWrIx724TOwDAIsRFLWI7wAZ/QKOhw/wqEJ8rwzySEt2X1PD7v3WMPqU4lDLPpD3woUzigQZsOw6Yp5XGC6QOueygHgP+bTWUfVcaXgVuYH2pW1vTElzufFcYwljsyEneDzqS/I3AKUNGMmpvZb3Q76Esb018jNt2kU2BUSx8TxgGzg7S/1Mu1ZsOgDTrhX79D0f+M4fe/Pu3Uf3yanPPPHXD209tG/jNICC2wqIMfozYKtxqAv0D2+T6H8BxwnjCuxjQ7LvdDXgShWKZzhO+gfIa4nIRSjZdwzNSALCKxH+B245N4JEqTMnthaiXmgoc9Jb4MhSeyFmbsBf040BpDmAbrleQu4qDQ9QmzKbysJzVrF7Wh2PbIU88lkD1vtNWwi0qLJpXsBHlng97iBaf1x5LuEDaD7fgNwVf5dPxQfIuYXfkN8l84+afqAiC5hefIDqcqRrseIDBPqu/gjqIE+j2fIK8X3sQMlMX+4b/ZPUFIUXVDydadMunllJXtkFdLQDuP/n5ys37Vqx+a5Pu+bsp+/+Jwc3j37j3E0v3vWlv3bgM4gy76HeSaVNEfB0pV5olABBJE7p0nrdP0MGuQ6rykscPauhRwIP54KYXAe1Y/SiIAcdAFSkRxIwchqot+MJx0wyBnKoBg2lk1j+sVheLFqOlusaz/S1lFwTlrCSplJ1o03QOZSnJCOn6ieFCVyY1BAL6UihjqmhugBIrQ5MQRRlTD1/d9QLiQ+o8BPKVPxcM0qtHE/3ljnKSLVPcNKolSuJpwdxTlDXY7PhgLCQ4ngvhhHMySmaIlQ/gSh/7EVcvSrFkbXNQD8W5tdq6eULUXpT9UpZUah61jTzD9wBW2jET0BP0nrF9pa5paZo2F7M/0hNu1imUKDvgpyFdDwwD/eddo3ZPAhs2jVnv/HWf/GNczcd3Dim2PyPJ/7Lx7b34qlQhqhiNU20kbT0vzV/dGW3Du3Bc5d4yQF55XwNXas6U47ATuVoJwBwVTuZYbZx54LcPcu+xPDOzQayagLtfn8vHNnKrOIgJw6lWdmn9OIZVXARvU+jGWTntnBusQTosD9+Mlqc8+U0tXcn7a5chp3dLCwoWl0V3q67R+MxGFUIT7DymI1qp6OnnImtRctUBcgDwpRE9rDhPpoyv4PNyiFi6tmFedKWhspFtRwQFo5S9NLyFnFu40FgKy/bshmfFF0wqpR4JQn/coW7hHzB4j1SvpaaDzS21z2CckBYkfNobG9schwQFtsb1aryptOmPWvmb5VAtqFbE/1PuxZtvvTTrl37+/f+0qGN4w+fveXl++5/2e6vFOYeNQIQiImpwJnaG4Xnma0bXxEY1gPCfDSrtsmvvEYnSXpibBmSX61vxgEcZ0W4QEVFesW/zsqD+J2FRxET9oRaMt/O6PtaSpaw9kxxRhyYJdI9zVdjnpn46xMoMQ1FsvtA5uyS0Rc7KaxrRAb8gOKoHOrT8KABYx2C1qQw+nbFAwjweqN2HBifUQwevkyJDBiBTRJ6kCeRqgfOfwWFql9eWWH0h1zbIdpQ2LSe54oAACAASURBVHTUXmvLia6n6uPKeZqJL3xk/YO8rwQ/8goH51TtSkYhACBzi33mcH8jUpDti9XtnQeETbs0Jmhb6GeBjvun4n/atWozAjDt2rVff/O/evjsLfs2vvK5J3Z95LHXbq9LiYn/OCQoKt8ZmNXkRkkABzHfVvhLstikbJPcZwyhNEHwr4g4QCqqs7C7grCO3HGPGSdVXwcDmWMmCDvyhA6311xCyX0wWj0nDuWZB4XBTeZ72LnazH6kNEk7GX13lIBUtHAJnXPwhTtTHDcQ1d6DXfZs43DKQiiEDnTn6MU8ohLKiCVEVMcY7FxyEuR+RQsHX5YGjD8OBPky2lBCC+HlgeBYofShYm4yUvWcW/LtjA+w2fgImHBdHsoQCdHlEmJwkvf2qYSA/LXMoEQJaIjNS+PJRXwpN3OIF5XtLb8Q06Z9y9YBVdx/F47djrY10f+0a9pmEvC0a9o+fc8HXv7mO/a0ffvak5994gcPbj68b+PJQJNCUAwgkIvn6ZLWdNI0El49DTTSgkESNJJBmRyZmbWE6ckdB1Met6NefJwS0uHwzF2HbFKHysnGsvLWnOmoaA/kFd+W5SAOyaSAqbVA4WR4q2RKyWFLAjvq7yOXtMBniZmLlsMBQG+CBXBEmcGLqDgEp5nHzOwBYkfKaW6KH99WePTyOLC8kmp4m2TNmkW54guLJFpuK7eBVP1IujNFN3OLs5kMUxh8q+Vs2TDL9eSV8mzm4QDTrhFTRdvAyVux6xF89b/Ckf98vk7TrmmbvwDTpgHA37v7n+7fPHrk3I2v2PXnrzrwaZeshHrH03+1SGWglqsq4MVMBUYeHSBMOUWW7S+KINMRGeerTu1K9gI1OSEBClUPkJIYAM6cW0IwgMzxVYiqSs7ExUWod+FNnTTurlMKmJ6yGap97NhdJZTXmoCr4EG8xPp+vUGUpwiLqoiEMoc5uKl9ahI1/hEnBoSMxzRUEmoi2AnKls4LoAta4xIaJfx2uxaqLa6uMTfakoBRXRGtqp6Q4pitzbVFTQjWoZd7cal+SbBbBDwac6gCntJsVZxTrmTLnXE4AGr+8eBE+pXYTKZMTJv2TK136G7INhpw/13zLZo2bUqApk0DAPzOW//5kXM33rBxfFvahx79kVPbu9e1MuSt4uKQkNxj0Oz4j+YBVOmFfVyRVayk6qZ2IuBTCkhGt10T2cHBuGlFghoOuQ7vwS6OrqOgvxIoBkUNFDhZJpbeCth1uQRLD5W6UqHCxDVFIqKqPXePabC+UcJYQex23IWKI/Y1mN45uAokjwgbOwJ8BLm3dr/IWM3ddD+rPoKQ4oBYfci1lXjilMG42N57Ka9wbitbZ/4Br1QBT2k2iHPqlZDiCKU4vrrYXvWbcG4ayhylzCm1YfUuHHxoxjc8JwyszC2uxPaK1iu62PCskYuyvaLc3mnTnoH5C7sBnINuTPQ/bZrb/E2YNm2wv//+X7yunXjw7Iu/e9/Hbtr10DICYMp35/glOX4gkBdZcC0xAc/3BZBkeUQJPGsW8KxiJgd7ujCc6mYcwBtHpVGj5LuR7p4g28GEY2kwFbzkUASVBqlqqrER5DlJlBUxqiBKUh+lbzcsaXPoRHCRdGsBgW7Y1rJ7m2+pkvVXUefsIeTjM8biS2hB2/celVUjRAA/UGw4BhjZBhB+UL8IkaadlUy7aBMpBHnS6kNKLkrGaokDDP5ZjQNEMwyFQYEhDlCYb2EoiR7W+fKPKw1/fqp+XILUXmJ7wTjASNUnK19DHBdoVqIN5Ur4l1RDpQNR4wAr2yt0wYQBDeW+TZv29Gx7A62jAYfn+b7TphWbOQDTpg32qd/9yK0/8cYDux7/M7zu5Cm5aesIEGx64huT0AAB0TCIzg3KNO9lH3gg2BIjUuXt0IqAkNBKJJtojqmS4wib5eBCfB/4Sr1hrIUM9sqUnB0X/kHcqZxVyQGItSOgbMQG4qDi1Is3KLQZCA54LQSC3EZGCLzKf36bG5W8dKBG4SZrHdldNUJXHhBW8yjUyqFGyIE6fOLb3MDyUEoIpC6w/MFm8XhLr3wEiGfDJUQOwKCzL4usH4VPbHgHazEfe54yLGE86kvGe8WoJRuhXtES0Sp7kM1k7KjjZkYaQ2Z/CPgOx7vkGzVmI9DFyg2ZNu28pgBw+x04ewanzuGBSfxPmzbalABNm7a0e9/yq0fby6/rX28bWx9+9L95bHu/XQ+2M36AX6HQIq/w7/QcomxLdDfOHYX41UzQ1cBnGmBqTJeMokBxL5LgCQ3VRRToyHvwj8USNK4H5qpLUBVFV3ofFIFYo8SrzrdXVJq6FCK4LPq+ohWR4IW5fNeKiGFjiTxnfpCYv3j9GcntRWRbQNgsjjuLu6h2EV4JLdBYEqfkgOQTmIcDpISpbriW9zI1RRi21x8ZO8f25gswDweY9q2bAHv34thR3PwC/Mk7J/qfNm1p87di2rTz2v9w77uv2zx+bPuWl+35+It3fdVl0ZEcDCCkNaDIx7NsoX7FgFVKbmwEF/BonM5L2Y+DnZr4mzmyyPxgUavhDubypqwlU3Ih0rv63IruCJHIG1nLPocopW+Og/g5walrgmcbh9qH0hHr3jskVEB5bLAnKDMbGH53wM8MFhcFRTPfhGErjK0YE4K7aZykDMisX+ThDOjNc6Bz9wR2UoGKdkizk4ZDOESpTE2HDb48hShVinP+K1hQ1/UKL45SnHk4AMrc5uEA056pbW5iexvoODwLfU6bdh6bEYBp085rv/nm/+3Y9i375M++9PjWA4/9wCB9KCQ0uXZgyMlFLR/jRkYz001jtOSJjaBVIrvSaKByk5v2v8m5Og0PL3MzMP0aBD+53Rig8SZNJbEdSdmYcEKvwsI6ha1tkQ47Mt+ZAA2e0FWo+oE2TqLXATnzk0mQjxy2aOJDdxA05hn+V7DLknEA7VxRzbX1ZvNwgNVIiC6XEINze+1T7Bt8bvNwgGkX3RRQ3H479u7FxsZE/9OmXchmDsC0aReyz979h3f8xMv3tH172pNfOPn9N2x9faudI/QhIVpzE3kgllWvDzl5tpFoJin7RtClSXYKP/hURAJPwZXyMojvfZz0EvwPY/QB3iVI3EqsFko1CNZmfLBl5EpOyohbqvOp02giCsYfOGHfJNdyD4cDGMD0uTkd3Ln0QOW+WeWKAJ3rFc7JiW11drkZ9hY0G9nKj+YggSydXRbAKpDGJsQ0DYXWwpTl6dcrQlS7RmePcsUs0mFNLq8B/UGqfiTdQ1Vf8wq8mQxTyF5rZjskLSyulEXPwwGm7UQTYO9enDuLG2/E7//P88WYNu1CNn9Dpk17Wvb3fvfdBzeOPXz6xa889OEX7H5QE7ogtSXG2w+0ash+8jMg3XnaqgWywkGu0hEsy/XUoVwNLanMSaGR+QndS61nL2dlDYc1FdEOyn4Aju9ct7O1pcy/hROal+2vFYey/E7MVlp88DiEK6ZaqX1kpwE09xmU+2B36QCssTo0N01RD6lVUzaDuBaoyn4UUFP+QPK+2tBEu7Dqv83NRE1NpdmepMIkq9YEsHZnqUR3ihTHnzo1NlXGg7hCpB+9xMv1hJeYYLcIeDTmIHWobLYqzilXsuXOOByAc8tm1QfD6vZOu9Ztyn6mTXtGNiMA06Y9LfvMvR98yRt//MDeR7/SfvDJM/3GXQ+t/4+Mc68j80rMxCti+N5xTi0xGXEDJ1YHqBRUf1Cz/D4bCwrijBGsfROJuQVsIjaFcEIt7qsO89g5JqOxTI7F9bYSbYjJ5bx89XEZBJP+qUFylRBHq367bli9AdBGrUqEPpTVifxujfx+mZtQ3JRUdCw2h5LF3CpVn8+5svJrGX3q7IVUfSXvfYPNB+CVgmXXEfO8wnBBbGzpFa9PuRLkfaXq87Xh7YO8ty9te2NKutiACHGMM19kKaD+GNtWf3Ukr6oOvZb3Q/hiub3+9iqGMaddS6YAcPsdOH0a29u4b9b6nDbt6dnMAZg27ena+3/qXce3XnpAvwbZ9dHjP3K67yqkLBsVEUkWhCmCZn6rUcBSgcgdQPEgUi1tYQNFZgUEoITGEEnzCgetFXVsGFGK9EexdUsxEbSUdpH4uFDHcJBgm8FAQqjzEZEPLkHKYlPLDkWPJeRNDZNmSZwOQc2USHU+IxBOkntiRhGa12blEfg2xYDc8NTZgzp7Us3jJIvO3jY2l38eOX4ticMl6KJcjy3XW+TcPLoTc8ukBb4nWYMomxURPydcDwiL7YXm9np8gup8Xc4tXi9/st7rPM34IFaucDNje5PSX9k3u99QSkgzr2BCvmvVzBO0aj8veAE+8cvzVZg27ena/G2ZNu0Z29vuuevQxvGHT9/yqoMfvmHraKmxAwd9rt5RxKleiLPAhAhRuiFH01wE4HIZTDkmjAVzYJDHRD52l9QdOXMeqh6qgyjKV62yH2iLjqqQ0M+EpCeKC5mUSN1L8Ao8lPEQrvKmPnNxIVA3vNZUodJC6cRiPhT/dGijYEmbS0EUkKaqCgp4egxeK//YblSJlPg+uISpiY3jR4A1APUYMtMpUVOk6KKtEY7WyjkooheEH4cqRFGgVq1xl4GBF4zU9aIkTs0AIYMuw12sczkgzCF39KLOfpwbcfWKFEfWNkMIeNwFK718IYsyQSi7NEwba5r5BxRNEYrUyv0Y7xXbW+aWmqJhe/lEpl1L1rbRG0Rw+Ffm05827ZnZlABNm/aM7bP3fOgld965X45+6cR36ebGc3d902FNqhTEicpI1TVdAyi9IGQJ/T1S2+OJAQGeAEBFhkTeEnPwRFf4jbKXRLNESBLNEDORIXbgf/KgMZFQE2VNIi1LKJMRr+Pp2FQhfiXAcTSmq5QTc0CPmEkjElXNpYlpRYgPfVOr5sSFQbkDuTO5BSq8wodliFfqzoRcBzlzGZfg+DXURP4jxgcd7kI8Xx0HF95geQUxWNwlkLpgsaicZP7IhZS5RY+nahY7IlnMB7UParvh+3zl0kTrANzeeOKRyqxSt12KZ2XLhzAfIDazvuHTrg3rHRtnoQ1Ncfjd87lPm/aMbUqApk37Vuz9P/meh594/nP2Hj23vfnHJ/7mOd0igFP/Y1D4IDlMgbOqAAr+rGIPMJAQFyn2KVqRVA0VDUvpztFB2IjsWxQmlMoU9UgAe1BxhNCKsKMV3xRJjI2sXKlB4cYkhXOmosankwvPuZHdpexHcnAfrkkRonQqdtQfQYpkEOEW7f4M4nYaAh72BTqUUY2ouYmyBC0CHlFi5SqmsudcBTzjvpHHLoPzn+GJq+Nlu1jvEgolXT5o76V8IUovLXPLnPDyKM/TzKcURL1f4dzyyvD28nUa5zYWBi0CnnAllIMrXWCwWmu88La9MQgdglkY9NoxqwHWgN4g27jvPRP9T5v2rdj8zZk27duyn7znlw5unnj49C3ffeiPrtt8zIFVinMSLmkt3ROiF0PZLFxDRBxVcZwFDwURJc8J4lDP8xKKc0xvA3aPuyAOwzKmlQdjNVMHgXId8AwvSdlPLMFxaNzFKoFShKPiSnNfbwOkK8CaQiYpcaFOiHOoOIILckLP0yDQFCyV48BA0REkNUVQP1zMJEAC7cIJCysL5VRNg2Tf+mwpKyImLQIeAvDVkjgprYnGIcXhdoGIPuInEVWJXiulhMQJbw2C36n6cCwHTVEVLNW5BcHPucVsk6rnioqmCDlPRNJKzHyQ4pTB4z8rkusd6wvVfWOWcGxgDs6Hq8sDwqxZ5o6vqKGmXaWm5CJaw+GZ7ztt2rdhUwI0bdq3ZZ+55yMvfdMbD24c+8tHX7O19ciBjceAQHgUWdjRs3GdeganNAUOQw1iaehVimKHkQIHgvatQzCpwMnbl58HaBRTgqBRaNTIqkkOQm5c0AKkgneX0I/ULlVxpNG9AD9AIE2c0B1LCQnHkuDtQaac+5YnVAkAdHBu5lRAHKtzQBF0LsfLGZV7SQMyGxaA+R6c1WK7iknQ+stm6zoScEusLrcxr/j2UpljER8H/YTXyphDbDoDQ4Ngids7TCF7rZltCpbqvsdbwKbzcIBpl9d6RzfMonhg1vqcNu3bs+kATJv27dqf3vuBl/3dn9i7/9Gvt+994ozeuOtB/yJBDEFtAKYCeYvu3/B68pqOd5MzFrQAssRbrfCgEpCxOfYfXZG4ncRxXdY3YLq1cPzFK+m3wAIHodfhioIdboHI+EcjhhW1aIJlM+TtwCWMAK7M3HZAkrdmNmnuHnIy0UwzV4FlJT2m4RAZAulaS+Nb0oIM+1X2KO8yNOH3urYZ34Sk6lF8AL/CDY/CoOkDcLtTsFRmVh/ratLCOsQ/wHSf6gju63prNgJxeQH34yvtEqx8ndb4ADb0qg8wvo2S7ySnXfyToVleWGzvBIhXkSkA3PEKnDmN0+fwJxP9T5v2bdvMAZg27Vmw9//0Lz+69eJ9/Uhrm4dP/M1zfZddlyhcCMAFzf4RvKzxZeqnAUfcCGTJtsrGvKJE8o1NvJh+5e01PQs4YpcscInEiBIzch0+Qvhu6NLxvEadGMepjsnjLlr+MTCnLYuHVvCJBIChjM+CjzaXmH8uipUrEXBSq4oqWiUJr4jpajQzYBnO14Axh32LddV9c0Ts/xCs5hI4JUmdfdGy2+C+vXChjffS3De6WMnPxw4ksI+ymGOzIbWjXvEd8LllKESwmuzhL2Go872caGRExA4gloBlM2AxNwVW5hZXYntFyxVZbji3F/GLwOKkUpJkpu1wU2jDnr04dhQvvBmfnsqfadOeDZu/SNOmPZv2k/e888DGI0fP3PLK6z94cOMxq9rpUEVZxt8VQVk5NCuBqnYEN58lPrMWpyMi1xSVfAOn6lWJZFk8NICzqtj5Wa7vV6hIVw7OGAVvB6rwmXhgzVjuU/1ejVjMJiyh9QdKxkIHWrPcg55rl9gW0cgQkChRCm1KIbip+RFnDOddmtRsBEQurV8Rab0DnvzQsqOKNoHCMhBEy5TQrAOfqiRVTy17EvxxxfF1qNXhTlQWBs1vpWDecfBoNhYGhfuMEndhX6mFQRFJCzFtZa9Bji9cAqdEOf64BKm9jKof1PnFveKKVsqJnqcZyi7llZXtLaCe46zbXqELJhjzCqbtbFNFa+7sPjCh/7Rpz55NCdC0ac+mfeaeD7/0TXce2n3sobOvETxyYPNRVDUChRaDdtmhs5vy+NvMBICkFMewoyTRihTdiAb4S2jFDynXEEeJcKinQbcGD8/oAKicAZZLcLKX1YGoY5FyO6puFBKJBKa8R84LKtKscI4k0MxJhjynAdBOYbjawkWUCiIp+1yzEST2sHzQHDjmGXqhaMatTinOGp19wbd1cH8KVL+kosbjEOWPxeCovVCmlNONx0S3oGhshrKYGEYJVyVWX0VThu9lWMIgWFIZ7xWj5kyGKxGbGqZdOsrYUcfNDCVWVmcVIPRRdZMjCBRCtRhlQsadbfGo75/of9q0Z9WmAzBt2rNsf3rvf/iOt715a+ORI/KfPXm63bB1JDF0xfSBy6RWhtEQL1Bjk+CSqLXqzAfYLQjCd0C0IZ4oGDfmY1RsgbDNZ+ITKFr2VOpEX+X3Og6e0nDDpLLYBOXCpWWqbqA31HUNTHxB+UFscyaxS2jCbGMO0mK05InRWgW7jHJw+EGOvxamFx9gBYCW9RKk5vwDdCOvyLN0OEA+yHGS+SMXUuYWPZ6qWQByodM6bMdwRWT4fnBL+AjrnGN7I0MgfIB5OMC1Z6q4/iy6oAvun+d8TZv2bNvMAZg27dm33/3xX3ikvWhff7CJPHDi9dsannbR7oP8KInS4HyzCDqIqUz3g0h+zf8c8ixguPYlJDCD8UrosMfS6ZYynLJv3kZd8+G42kuD1mamBwFF3g74wfruPaBfqswjAODQuafw3TBkU66XkYmiMg8pvCyvSG0TWDJnyyVY2VI0Ct+l7LKXqVEuQbMOPRc4DwfQ4kXlI4g0hnwo6UvxJV7ObR4OMG3V7C3eVJxq2Hduov9p0y6Kzd+radMuor3t7l88sPnosdMv/s7r/2j/5klHLhKae3HMFZp+AFTedymifL/uXyHOGRCw7n4t8w8CWDoH5VQBTf09QlptqQLdkX/zWTGjANK0QyWU9zEZk+mL5/+qlLmJY2m/XfO15MzFhfgiMTgUiobMc2i2OYg8Ch+wCVeXE7APlm9gNY66KBMPcgnakLkHcRyBoEuMA6/KKmBl/aHkPObhAMXPy6nazLkDGnEK8XHcJNdLxf88HGBamIZXK7h/VvuZNu2i2ZQATZt2Ee2z93zkpXfeuX/X0b889d17N07s2zwZLH8CIwFKVoAWqUxw8QRSQnwYIh9ARCiXjyvBqRLMuS4iM0KRiLNgI6YpR4tBbC1oRHKmzscoRKlYS0PhnevltCXwIMFkgyoas2AFYsFJ78i0VS5EvKMAcRQAoaymXpzwz3VKgPi3sQQNsC2ccwM9JZLQwkBH7lLsdJoErb9shjUdCbhXdfYoV/hC+N1t3Q76+VYoYw4BwUNVXwVLNWmhrDdvuTLbFCyVgE2+DGw6DweY9uzaxobHoR5493xe06ZdRJsOwLRpF9c+977/eOub7zzQjj/0xHd2OXto65hLGQKLD3XoHSAFpNZGpC8DRFMnepUi9YJ36V3oQOWm0CfaSNW+eysp33rya0XSBtrU+1YS2nBi00B4xKEVshlwD19nGDzYXDoM3EInf62ZhBfkhYY0EGyCRjoeLHjjIxfIKKWZKV3CN2gQLYcDEGIufIB8YLGWsUnMfG0zBI4v805MjHk4QImWxO7HIJx28U+GZnlhsb0TU165JkA7AwXa5pT9TJt20W3mAEybdtHt99561+Nnbty/9efHTz/5xZPfQ+GyfWkHXBUUE+pwE7iEbBpFGO3IUkPzUQaEy6AHHERJdzZTYTN2gYcfFKwSVN2Hqrq2bATSzEjvA6a/EYqzfdL1LgrtJTKgxIODXEPRs1eZg6ReXIA+HOQrMmYjWFxAOZRlBWD4FtSLm+jYB1c6GCHiX4jIdWVu1NkH9e69tCBuzWbCZqGzL1p2G/waOhxAytwUWJlbXIntnYcDXG2mgOLwu3Ds1ZBzuO+uif6nTbvoNiMA06ZdCvvC+/79K9/y0s22f3d78qtP/rUbdn+toReEHpx0/Egc6lLpQqk6RiZHHL2szH/yqUDl+9X8/RiZB/QaP+sTiDlIokh+SA6+flWIXrLsMU//WstEmYlKRjaK84TDQZVR6MNj7WJDLSpX+jfW3wQ8hSd2iX8pE+lLkAIFs5znwIsv+fwLsMsyUPW+iZoDVu6Zc0tHRmP5tVkpiQMsBx/ds9iIMrUS6/CSOGXaiCvLClTrqXoMS0jyPsqtevyk7NLwbo8hjkUzXWm27MhGtTDo4A2XfQNjLllKiM+n/HJNu4JMIYKTt2LXI/jqf40jb5gPaNq0S2HzN23atEtqb73nXQc2jp84ffMrnvNHe9opAFqyZlWiDIrxwMb01zOqxLI6mW6rKIm/npgLgYh2VbUsWDD7VqMB//TMXW2hqLGyL6075vIzuWJ84V04ASgsDddzXhVQNPgZZ5E9TE/DU3WNirXBW/L/2iL5uGQJN1WFeDpvplDzxC5VkRiK56nB59lKOm+e86UCVZ9bzAp20JhzyI3gcl1KrgcbJH2ARa4tRkcFSCWSgmKqkltMPB1OVTQrB4QVaItyBUBovWJuzuEnuB8TeUeNTaqk6sxzJk9xQBh/LKka8IV4OanxSlmRxGJXm/kH7oAwoCKIXVJubyYEl03O3OJhe/lEpl0BFlFJERyesp9p0y6hTQnQtGmX1O5+y788cfrmA7uOfv7E33rk3A3lG01YIoTSwejzOlUPhDk1RTPbjlqR5Fgbkiot6pFGglWDUPVmqt0HxICFHVH5504gVrQiEYDwJQTILzVGQ2OjypyBHnNGQEc7TFnpgLgYBjGmSPybTMdttHDAUsfC/eiFgnaBilKgknqSHNCbsQZlSnE05uYLRFSuLCR0KSfKuWXlSuGlkLJ4s/AHs9lYGLR2jLv49lKLxQ3PXmVuKHMbfixSnPXNMBQGdWRe5TpB+JcrVTNWX8K64Vr2PDVFcKdVOVRJCB4Kg0rZXi27NAuDXmnW0TfdQZvof9q0S2xTAjRt2qW2P33fB17242/cteeRL+t37zr3xIGtEwCS90UwoYKAYEnBcpSA6qjkqfWpAh6H82VgCS45cL2raFq5QhTMz1J0MsR1wdiWv6AwlyL9FEC0wYIMWo4ubqbD4ToXKacC1/yn4CT2h6w201QptE/SXX2pzdXq6SvkDopSgySkiiNRIBRBqPfhM5JIyS1UfbSPVUs8srKE1BpJpHLHjLjl5THL4NTkTYY/Uooz3CWjDX5Fxu111D7OTWJuUu9ZKg6tabZ8APmu5WrilR1e4pxVmVuRbMWjRinfxEd0vgPCytzGzazbOxHn5bTe8eQWWods4FPzlN9p0y65TQdg2rTLYJ+79w9v/u/fcp0cP7p5x+nTG8/ZeshxlRTYFPCUAB/AiJIK/ktgTcQvK0C29iLKDwQe+N4RsA538+o7Cgsj2DjMER2rGKX3wpo/KUQJpM42g148xhRI8wL8McMAqSBMF0l5TMhegtutOJviEI+GSPFnKA7xrVaxkqTpG6D4GrEQr1wZNwpkmftvAHTwAaxZNPRm+TCGDQ9c7k+mIqRh13IJ50XzxXGKpIWhMGiZWwDqvOMCpmf8pyD//LQou7nqBZUV56LGAk06+gA+tzKw5N/pA0gpilWaLXyA2MHy47RLb3fcgbOn8fg2/tM751OYNu0y2JQATZt2eewP/u47Tm3csG/7YWntTx95fTdgHaKeivlDo1JRGSisMBNFNyxM4tYVJgHSrVHUAkrphSo7sm/RisQ9Qw0yyDMAlfi3SJ0wZRuOzRbFXnwClujbeVVtnqEVkVCYRNmZQPuAgwAAIABJREFUmEnsicTcVHsPXGdz1kUznuybbpHdtlEr0oDOlArlLolQikNFjcgg4CGwTQEPN7Oca5vNhiUA7Bj7VudW9DOx7VhbSoiri9129RdjIRw8BUucG9+TqhnLucVsh4pDWq9QysUNH8InKeDxAEIZPAMlY1Egbq8/Am7vSl2mqDiUpbR8kLFZ3fAB+cdvwbRLZPZG792DY8dwy034/ET/06ZdJpu/e9OmXWZ7yz137d88ceLszd9x6INbcs7wuGfBWqqrIyJn0HkgLjwZV4DSJlKBmS4sVASJg18bR+Gn5DrE5uBonu+rgEO5koJsIplyFwP5cb4v4qBftDyRN654onNDAFUOBYhq87WIdDVgyzOJtako0LK9MsTRmzZoZxY1GkTQoZHOaykCXTzxFwAE2vyY4biFNHQDpE3RFGrnDTtN7tB13Qm1kaGbvhuv1Kr/2UsAilNqszhBbMgtzpAFr5CBj14yZCRnWAHUzICBFI+fLHKLkYm8w1TrlWyZ0R4HzzIsxKbL9yTmtnpMsqBcGZpZpKJsb/by2EBuePp6rBBFV6y0kfKY8kmN2zvtEpm9h4J5yu+0aZfZZgRg2rTLbPe85X8/cfbm/ZtHP3PsRx/v+yuqAVBo+GQ0gYJaCOqXvUpjh5xR+VKo0g++Nvhm7dlPSKPbeBLhCSWAJYPLkVk5nuqX6C9klzkVqWvxNsHgZlpy3ShGBhhVsI6i6ANVz8zjwi4j6WRn4FfzXFWZOkHKOdjqC5LQw4Yv2OXMWCUHz3+4BM1mS0afm+nbW8h7R+YlIxnL7S0PPjacV1QxDweIe5W3d9pFNY2CXzLR/7Rpl99mDsC0aZffPnfPB269887rto5+4/FX7938xu6NU4R03sBdAK+oE3L8QqaykVO89rOJ3YUMLlMtVU3g3ozR9QKdHMJpARHmvnLw4J6T1hbH4yHdhii1+3RIDHDHOJKEdPYFwBV5b0eyozvEUjtSEiSs2E3uQUPkA8QmuLh9JRshk6oFQEv/qWxXWS0/VuyycqXq7FF19ggwOz5B5DeZV5DfCmozGzwe6Dj46Dquytzn4QDzcIDLZUpPcWOi/2nTrgybDsC0aVeEffF9f/iyN71pjxx78MRf37X7+N7Nk0BAwKA9+cFzTBP6DOg/QZ7RqeVbYuGojOijavL5JP7FEnH9dgWQ5QQAoFYcShiXV+gJRHWdGEIRYFEgXq5nSCGNKRHue+l8pYfAb+2i1NsFmlWfbaaHSiwzPAclIpZcY+LKShKvg6T+v9xeIssx13Z0ZgYfgL0SJgeern8sBkftFU9HFjNDzK3C9PQBFuvlQ9McafABOPOSF77OBxjulZseMxmurFYcWnUVakcdN7P6APV2+cTT08jc4vABVvZt2rNuG819gPvfPfd52rQrwqYDMG3alWKff9/v3/p33rq19+hfnnrVVjt13dZxJGZCQvMCUqVg+gGvqSRAS8Qs7CFogZRaIkJn9AvGTc8hJ6CJgK14DgXtiSyD4KdPkni9TkZTfM4Ja/DBCjRKeZpQX1PRmxK+N59qleNLAlMAEvWUJMtEBuIvdSXNWyjHJFewW2zwAVyOv0Tzy/iJFCRdAGh5vgSpAe4TdCOvZEmcoVlxFmrHpacx+AB54zLJ/BEJtAeX4Ok0C0AuJa5R+6C2G74f3BJueJ1zjYQsfIDzFQZd+AB1M/N2E5teFDt0BtsANnD/LPY/bdoVY9MBmDbtCrIv/b//7sYff9v1e4+e3P3Ss09uHNr1jYStIGvPtMgkSp3RL/9xDdCVgEkSPzUh7JHQ2STQX5DQGMdJBYqUiwHuCbVLGifxXis5AwG/EHGAwICatxbYecDprgjsoN82sMsEkQXGaYwT6HLk+EUAUT+DrCBCizYwyLDOByhImjdPAc/CBxgeAZvPwwEwbGZOu3yYhwNcHXb/GWw13LCNj07uf9q0K8lmEvC0aVeWfein3r6959Decw/LhnzpkR/wcjiaamWKsEsfBeKUU4M9PTJclUoZRQWkkc5rfwaGH6jXkvXLlgT2cbvMLVaUo2dzdN5XO10F5UFhmrBQrWWPJfiU8jhb+G29aYiYIp+Y2cYtbqpacpGzI5EjPK0hrnArsnJlgGBVjXKiNr1audIgpjIlN7KBWYc0RhZZlsWElD3kTIQ7WOaWubbxoMelDT+uWwKnShStYzqso3nmFte5ycouxTvgMN3vGIna0YyFQWW4ImUzh8Kg+e4pyvbapywM6nNjVnTeNAaPs+/ykOC6mYsSrrG9SJd32rdj9mROdty0gS92fODXJvqfNu3Ksvk7OW3aFWpvvueX9m09evLcC2878EetnTPASFhk9TR5RSryEhhWkub4yFhzdgeivY0j6lcijODfet0Wq9qpURIUQFNIByuT8nYYBreCH9HAeymslqgY+NTWtIsz/R1A6agS5TjRpCt8Fb7whiz6aTVPuQQrWtrVTijQ3tBEVWAVP20CENVmN7V6oFDR1lg/1CYjyoRo0uGMuqxWrrStswToqkSCPZWVKxIhkryI1Wb+QSh6GQuDglS9T1JIk4+FQW1K5kNqdjTsT16cU4pmLpUZ5ibrZpur40zOc0U0yPi4nW2mgqx8Xe9KYdDYXif+62aubi88fBS7tNqsbniOE0ub9q1ahIWAwzPld9q0K9JmBGDatCvU7n3Lvzp57oV7Nx7+4iM/fHZ7j4Ict309/FdVi6xCoSALHlgNCCK2EurjOHHwFrUilYQuY0k0I8VvCKsqhjiUhqAlIgNCLp20sUAr0es8sd9FrJqk/bVKQofOhvGG4Iljo5R5BVomp5IFQwE7ISAYfduALEaZdHgWBnXorENh0DXsMvhIeCWY72WI5jzNkOQ9K1dmHEDrvtXCoBk4skaFqociKrEyzMLBK6O/IOaTzh9fm7EwKLd32De7otxzifjJEAkZqo5yCUNh0NhejYXAZ143PFB9vIQRTBg3PJZgU+Vmjr8g056huW+vE/1Pm3ZF23QApk27cu39b/7Vx848f+/msc89+oYnzx0omDCxbIXCAcj5fyW5uUDwyO4EPSVxlAKSBNYqWnAVjPwPmB4SFfLyMBm9wln9JbJEIFzHeAWZFTTvMN0u9S4pRPHZk7ENvlE5OZuw+oyrCMRY5AoKRZlGbEtQD0aETin3mQ5WAlApwDER//B06r4FTEc4Wrl2R8vei2jemlUfwFdeYSs9nuoDgM6eoIDynInOwwGYrD56QbG9074Va5tAg070P23alW3TAZg27Yq2f/u29zxy7qb9G0e/dPwNj597TtGUm3nao6GXoOAVI3yRgvr8ywCmChAiSvCpdQAhP0v3woCq8viAxNlOnWY7cSm2ZjNUSC1BaXNyQPonPhfpVbweO0CRt8Hp7ndv9o2OPLGB1G7NhT7PKrJU0ZI+Efu29E9GH2CFS0YEARC91lD16VTEOES91lG05BWUOICPGc2QbDqKD1DnNvgAOTeNtI0a4hgWq/nKsVno7JdUve+NhkeY26tY+gDj3HzfGB9gr7HZAs3XDccYQYrtTdXUyr7Z/TJTQtMLSu932jOwboW7OtoGHpgpv9OmXdk2qwBNm3al25fu/YNb3/gT1+0+euLcq7fa0d2bTxREH0gbRDEsXxOQmcgO/Ei0Z39GSU8PFlCw7W04QLR3chnsFCfolllVn4B+xtCmgDBvRUAnyEI0QuAcenFDi+JaEJ6MFr2iNFADeEBYA0z33wzBcnMipcF6xbepzuc8h4Rr35l5OIBwCYgehrfrEurg83CAq9qUMbPWcPiuuW/Tpl3pNiMA06btAPv/furnz+AFG/LQn538vuOnbgaQZKehewkkHDyxtRKncSMBsmAaFZWA81X+4aAvCv5kD7tOZb/dASvscmGRyw21NBAA0srloh6x+4qir4hAFBDrFqpuFg4i2SyDXtxm0XMm3CjkpgEC9JFLTq0I7xUbrtwBYdIF1CdHL8ZJ6KJjuZDOPkho6yorc1PNvALOJKl6eljUAmUzXbcEymMKVa+lfBN3h73K3FDmNvy4EglZNmMcgNsr7mkUYh654QNVH7KuvEXZcC17XiMhUrbX7hkvYUmNiNfG4wCxS7J4n6c9hQmw+wykA8B9E/1Pm7YTbEYApk3bGfb5u//dC3/8x/a0k19/8rs226n9W8edfncQI/wEFr3JU5JI90KNpjPgIxDvhZHXjU8BQkmxW0sHWPzWqPRA2965IdCZsrEs6eVkgqPYC+K434EndodDvclAkzvcw5oSMWSmySB7sywenxKoYNHZpgLYJMi5HVII71iJMg4wsMv1x3k4gP8/HkzsflkN2w0+BLJFmds8HOCymwAHz2C7oW3jk++ZezVt2s6w6QBMm7Zj7C/u/f0X3Pm263HizLHbT+8+c2DzqFT0Rl7dWXNIwY3VN0CgYcNAq+IcstYDIEuOl7BXsxdQeOAs3Rin7YYIpDKqidSzmYhx+pTipLtSEaKYzj8WWyDgOG2lh1RONk6VlKP5wN4SoJAeCGOkdQkjTE9FDQKApjPjyFJR5qalddxUBx/AmmWUBYw2LHwAXin+yXolEsD35MJoPjA5X6BE8zEU5xaAujiNnFruRi41dikWOXZc9YLKinNRw/baA1jZt8GNjb/TBzDftzoScavzuBzTBziPieDgGZxt2N3x4V+buzRt2o6xKQGaNm0n2Yd+6u1y8oazu49/8aHXHHn8lYNWBChonoVAU8AT5DwUOkAvLxOZmgdJYQb7irfzAVIrEoPXIjZYikD83zR9EW9wr4Eps+KynyLF0eJZBGGsfUiHhQHolQRZZv1qVjHyuelAWluFeaW8hxtXl+BoM3Jtc24lIdhgeqlcaTOpAh4C2yHXdiFfKc3KwmPreWV1bij7Fr3WlBJibnGuSPPdsdjCQrDEuTG3mKKm+p6U2WYKucRLyGl7M9/w+j4sC4NqHTwDJWPqNrc335OiGSvvcFQckipYWm1WN3x4V6vnOi1tYxunN7A1j/qaNm2n2fyNnTZt59n3vve9z9330HW7jyp233roMAGsKPycLHGkJp1XiI+aQqBdIUCzr7wXJHCW+lcAmnb1M7Z4rJIBNN7OyHK7S/MCnFpGRp78hRyEH9QGb3YvQ56qTZudFNZgg3RAmgI8w8tXB2ldATROCaotl2Azt5KEdpxZnXYX10r5rIzybn40GOwYtcZztUCUilQQEXoPB4TFlexFLrn2GqInUvh1lF4CjInLeT4XAJz3gDC/Qgb+fAeERVgBiBUJ3S+gDj40S20Yt6VcyZaRXU7wLMNCbLpqeD3nNhwQBgYF4srQrD4LLNVfQyJvTJKPqx4Qlm2kPKZ8UuP2TgOQXIMA9//K3JZp03aezd/badN2qr3p7l/eu/XIybPPe8mhjxuKUoiKoEcxRfMBGslhidN81QncZsdBGb6HF/Yk3AeyceJ4g+9QFZ437M0M1ncCLLVm3dtIBe42JWnB2ENtzFbhuDoV7If+qtO/DaDPoNFG2KC4Lsp7GdSEoDdt1sa8BRHfnKYQVXU/QcWPKKY3tUCWSx8g0PwCgI4+wHmRpV2pGhvPzCaklnLlPGg+Oy58AGF4xj2HugSMoNxnIrU4ksDdm7HZ+itrYXquV0F1GsrcRh9g3b759Tp4aXZeNH+eK4gAwXCluGrxxBcuVmzvNW+ae/bARP/Tpu1MmxKgadN2qv0/b/0/Tp593r6t419+5PVdmwMWlp2JUvQBgpgTXCQQVd4QOhbAK/CAoh9QnQ9gqM2uUMYYGlzL3pCyE8NXvUuIK2r6ACvDkJhFakUGUEGEr+TEVcGDe22tRbDU2Se04Mw9zWIv3SFwRD7s7s1HR7Nzx5jDPChMCpMc/0jecU1JHM5tHg7guyR89B6fsCelw5slZd/Cny2CpWx2Pu1TXuFmxvbOwwG+DQv6QCb6nzZtJ9t0AKZN28H2b9/6Lx4/+/y9m8f+4vh/8f+z9+bPll1Xned3nXvvm3IelLIky/OAZeMBg4vBQDiqKrq6o4iKhiKRlJZsGRu3hwaDTZWhICJ/6oj+H/rX+omO7o7o6qaLMm0aqjCGsmUMCFm25imlTGUqM1/mG+69Z/UPe6+11z73PuXLzDe/7wch5ztvn3P23vc6/V3fvfZeLfpW99SzupEloxmqWQvJFM0kWYAatbKUoLQqmS5FbVrqtj3KtJrYdoQq9jBtJ6glXZ1BLvkKfG9AzLP3Ez/zYkAWcyGM0RBppHR8izR852wtUgGBtq24SLWe5AmbrjW9bz5La0jSkMte5dkj5NnDrnikFHcjWAa8Vn3TINNLM50YQokBasWf32J90+oT9xjABxK2Mbguh/XcYwBYOn5nCFL6bPHJxNfSZ8ljAKDsRsgSNH6XwoR3bvTJjCFWXpywuyb6FmKA3LfyPdnPKBpTDcz8IWRXwwCAkN3N/3n67OLqqQODC89e/PkxBsGmdcnv6Q6qrQuu/J/5RH8xE1pMI4mfCSMogsytf1fSZp66QhK7qClDJYQKRX1aM1d7QHhL1na5vkGS/1mHmfco4bcWDBSRmsRzY+owLRfYtLzRSoitKljn1lSW9rTiLltY4sLdRGqMATwuEttHG/faAlUMoGWhpQjo0LddWhygfE+qyCH9X4wBNK6EVFa9jWgiBtBKzaNeCenEACGdh8UB1kP+PFo0Db7376j+CdndMAAgZNfzf9//B9dX75gfvPbMpV8c6Wz5hWnE5GtnkVoEYqUUTam1QJUrUk7XcS9ZXX65kjaX1Fqk/HpPtDBtbXouZX2gLV6yi1TEZkDbmvwKqTiak77LYS9t5eDmlRCPURSK1lWphUWmlV3fA6qt6BomdKdvcP1a3OU6CrJZqtxlLQk8xQhPmjiERhplq8U5RWcXO7wy5kPsZJ2U8PASG9QxgJZPoY406uOMrG9+l9qCRrhLQ9+6Vr0n8Explrvkqff2odj0VlGB9SE/tAopgXgoUO5qnQ1lXw1PPUrtYgzg0xu/lvs+Bmhs48Z3f4/qn5BdDwMAQvYC/9cD/+7a8NTC4Pxzl35+1M5mzVT+Z1qL8JMsplC8VFdIRax75FA9Iun4cjh+nQuESoCKabfiBLu7bBlHLsuieQ9VkYnDHLXkY4h0nmkDFPspL2jEJ0tR/9mYN+GeRWoLWyepxiu1ALUheFeDu2xRkHYN8nByZVCWlbCOCTy5WTcGgFSfkfVtIgbwsKdEcdUqBOofpw3BY4DwqWr4RELCUqdvk7sR4oSjrA+EQDRMr53VX8UAPplu3ldfTVtm8b51YwApMUB46UQMIOHg1zCZnRggflf3FS20hQi+S++fkD0BAwBC9gh//MDXrw/vmBtceObyLwzHc+mipeKY3HeXFOZ6u2ZyEz21y1FCtKVD9oiUM+M1StImO8m2+7a2w01guTDr5tkDyLGBQlq7rv4oe/JEEojZ5k2xt4sJ7VfKeoXNgCnLYk6XDrtI1TIEFgdgcYD4XcV+QG1rvdL7J2TvwACAkL3DHz/w9WujUwuDC895DGBqxuWXCICmMl89CcQFT64c0FGWWYcinTWUHx5MaFVoC987kB9uzqn9Qdq23OKWc1Zj3g8tShquPr3gAQDReOBPoxa1qHhOUQljAN+NgHKlJHmb9x9kem5pPnGZrolckRjGFDu8xAApVapUH1vLXbax+BWPT9y6nlT8sRlCKk5MMUKZXltDMeGeP8EyosqqN1EurtE7MUB+4xTFP92q1zhL8WsZzHuYIs9D0MmVkBCYlSFUMYBPb4kBclxQTbir+ZiJVCZtyhBCYGYj2Os0vTwDj/4B1T8hewcGAITsKf7k/n9zfXhqvn/++cu/OBzN2eWoalViokVxl+3A/bJQUFIvsvhL16R45EUZu5LW+l6Tm4Bq8v4b84mr9QELIdLGAJSAQc3BlajegiLPItXzxVXNKW7ToOALGAiaL71PWle8EzLd3GUEZQlXlhqUZcllt7FYrsiNTGhjmrtctLV58PaPLd1opeYRHX0Tu2IBVTxxSFDFAG7e17FilOk+QzmBR8MQxL9JNsPxigV43YNBJUwvwvR2DgYtyWAadDl8COg2i/FYWW3o9M2v+PTaCVoWA9QTXn1XqxCrxM17krFi3KLpUf0TstdgAEDIXuNP7v/a0vDU3OD8c4u/uDxeKJazOceSywVYvgZQxFxR/66HWsD0FiBNrSyrdI5UMymrUnVhZLKs7AmWrvxKwi+4y7BmKALUZa+24Tmpd2EbQ5LoJfMnbPRM6q1xsRuEe5HpIQaw0seTyrJ2l9PahU9aUfN1DDDhJXtY4ldYHEDRjQHqvtkXTi0GKAlLlaMf1Xz1fQ7TizC9LA4wQdtABK3iO1/fu4MkZL/CAICQPcifPPDV6+NT882FFy/8wupoIQvQytv2A3acbC2rdnRqqeolbn+mX3Wcbwl3KrJjL/ldUinLamUBtje3aDuXnr4YkN/SVnpOUXYjuHBvi57L6StF5Yck/raFqJQtuR7kVJGSJaLc2F2e0JrlpdG6niJJQy57lWPj8Un6PzfvqxggPckSeKq+Kaq9xagfXoawqcUBula9r4R0hiClz+U7EmKniZWQTiCaZ9iaTXwuLA5wM7Qp6m+BBt/nrl9C9iIMAAjZm3zj135naemOuZnzz772i8vjIwCKdgRQiblaWhWx622hYpWz7HqlLMWccpdfrt5SBk2QEBO5IhacVOFDkaSecVRnkAtEVVQUVhVY0EC1zTpSFZKrEofOxCwO9TpiAMJ+gDwoq2BQYoDc5zVzRULfQnyyz4sD1Fo/fPTTm5UQK83SrRcH8OlNVzTMOYsD3IheLw/6b+n9E7JHYQBAyJ7lGw//9rXVU/MzF1648LMro0Mu+l0hSZXA4HneCqRDgWqfGAjqzS3Yju4Jeii7+mELKXJVYPUrOXfGrhTPVaqVAfWH23+KIpn80V1Ws+obIKU5NdZ/V5atvbV40lqPS4FWXN/nDqxhQhcBag+ZcJeLT1wCMBYHsC55As+GFweo+8biAOtEgfEYbYumYa1fQvYyDAAI2ct88+GvLK2eXJi58NKFj6+MjnjBLO38L7uEkr3qUqlI+ez/inZUjvrDRCcum3qr0txduylQjmAH7ET5mNJd5GkLRecA/nL4UJZxvjEAgOeWh8x1AbRFU/vcYZgm/XyvQpDpk4q/mytS9S24yygxgFbON4sDFL/ds+oRhh8mnMUBtghFX9A0aFue+EnIHocBACF7nG8+/JXllTvm5l576fLHV1IuEFDli0f1XlJKTOPmgr4wJQhom2WTRNe8ekqSpFlToZJ9lrXvCjJqPoSXBmUl7hPnV2R9Ju4im0itdJitXBQnW5APfa9Pr7f+51mprwQv2a1rF6D2qDVz2UvfipsOsDiAfdvsO5O/XJ0VpDLhLA6wBTSCVtFv8P0/pPonZI/DAICQvc+ffuq3lsZ3zPXPv3jxZ4bjBSBm9UBcyicjuVbS1eGbIkWxRVmGoHo9XNAJhVRuhLgqdXEYigOUMxk77jIAqdVnV8tCyhXNFQ806sjOWysRLIgHPub8HBYHqKx6E+UsDhC+z3ElJH5VdhnpCN7/Su+fkH0AAwBC9gX/74P/49LK8YW58y9f+bnV1mKAkvlTydlgy0oldLSSPgKUuzxXJB8bavn3qGVx1odtlo4TeSzFXY4iNQjQlLtfpYAAQD6w03YMI7/Sc0W0OmjIh6B+0fNT1swVsebrLQ5QxwDW4bAOsKYJXSZ80l0u2tqiIPunrJlENY/o6JvYZXEArb8McSUEZXr3SXEAVYztv9zfYd4/IfsDBgCE7Be++dBXVsYnZnuvnbv4c8PxAbi+Vy2yJzj6EhVSxtRb3DGsrtWsSTndXou7DC1SrxHAUnFcHJd7FNrGk4OylEeweqGhQEHom7VMf7CtzAoxNTjRzNxlH8LUXJGqOIAfidNRlpPucog6ipqvY4CJ6Q3TN+EuB6u+BBVhRNY3a8biALWjH9V8nHCE6UWY3v1RHKBp0AAtuOuXkH0EAwBC9hHfuP93lldOzsycf/7Sz4xGc0DH2y4itVjkOUIImqZxsxlxO6wdwG8yL90OdSFsOsoUc5LdnlGT7nN1G+1VoOsuq91oz03SOmjrLMvSALOV2+TiAGFHQZSMJjer4gAq2harHj4Eyx55Q3d5QmuGcQXreookDbnsVY4N9kJxgG4MEKc3DkHCQoqG6ZUwbz5L5XtiHnxIWArfpTDh+744QFrHUUXD8/4J2WcwACBkf/Gnn/zta8MTCzOvvXTl50fjWQBF02T7M25/FKgZ7SU2yC5pPoAfJhZTIoy1ri32/PCcwONizuKIJLbKSURuuGr5W8p0mCAd9h9yRSwfXYBwUrslgRRxr8nTNf2XaoEl9dagSMaQLy5BzVerDRYDwF67lrJE6BssPtnnxQHqH8P01s02vjhAZ8LjN3//FQdQRaNACxWe+UPIvoMBACH7jj8/89WV0R3zg1fPXf54qwNzLmEevFmiRSGZWMxKqAjQkmgBQDUd819kJSx7RBX+hqSAg0LyIzs9AkFcGVAFysFBJpQVqimVqMoVyZZzW/XN5dqEgyuVmw6o70ZQ5Eph7jcHfQ/vsIldFgfwGMCH4HfpjikOgKpv+7k4gAJo0Aoaxfeo/gnZfzAAIGQ/8s0HfntleHKuf/7cxZ8f5xhAIbEWmKnt4OCKi2NvFuqFdZL2yx+yOWp6qAGKesq/bjzkgElk95KT5kwJ/bm9mrKsHX3VXDEA+fgfkWpVIT+yVYGqht3GwV2GucviXepY9Z0Fk6j4owA1gxwxPtGJXJEwvahOrQnKshLWMYEnN2NxgMmVEO0OwR/u0aBMxAD7pTiAxc5Ag+/+AdU/IfsRBgCE7FP+9IGvrqyenJs9/+qVj7dtr2i4iJ2pmX/r1qbLG8ktpFI5MXukBbJK7wpQk6SCNud1NKaZJncjlASVSjFLvI4Sn5jUS7FF6mKIW1QbsehKBz4nAAAgAElEQVRkwl3O6jRKUld0CDIdJaXEc0VKDPBGuezFqi9uOsDiAGXC/YOOkSG0M+EsDnDLtC0aofdPyP6FAQAh+5dvnPnayvjkbP/VVy7/LLQBzMEFgmRRRThiMqd9t9ZGs5yrpE+l7crRjbCs7qiQsmquHVzkB0gTZJzLdGsmQfNp3qrrHfBXhFwRl33QlLCUH94EL1k7fUPwia1rLA7A4gAIcdq0IYTAzEawA4idYN4/IfsZBgCE7Gv+06/97vLwxOzg1ZcvfcyliuuE5OmaD1v9ym3a4sLWojnIPFfGtbvctlJeA+S9pCVXxA98zGIrWvWpcVCWliuS3eD8H1GWaesy3c8/tdDFmokiyWbvqlUz2KDiAKGiGcxyhgnjNzShjWnuctHW5sHbPyVyi2oe0dE3scviAPEbXn2fPVDB7i4OoGUOvsczfwjZ3zAAIGS/8437v768emxu9rVXLn8UQHWyJ7QxC7PIr6CQ8m8QlCWAvAfXjNikkEo6R7rZvVuNJrSY3DTzOq5ImJcME+7FTY8xQKccmAL1yfolIDGxHQSoxUDBvE8iemOKA2g1aUHN1zHAhJfcGULlLgervgQV/pzSNxeALA5QOfpRzccJR72C5NO7e4sDSP4Xz/snhDAAIITgTx/4w5XR0bn+xfNXfjLuHxUEFThJSHeBuIbNDq6oya+kkIoGUlUViUfioI4BIOoasS5F7PretZ27qlG9FWM+vc0OBUrrGekcUhd/khLtWyDsKJDOgY/aKQ7gfWNxAPW3WN9KDOCRUrnL5s0HHua8igHi9MYhSOmzxSeIsdPESki9xBESluxrU0/4Hi0OkLfpCB6l908IYQBACEl84/TZ1dHxq3ddfu3qj2enMB/XA2lqzQRYbODytzahVQWNS6LKJU0SPz0q3dqYQjJBJuaRF+c45Irk52V9CY2KSqbtNk59a8wnhiWBwGR62yIfKNN1l8OPFgPAHH2XyzFXREtXp7jLLA6Q7wp9K3d1tH6Y3unNSoiVZonFAd6AFlgcA0LvnxCS6W13BwghO4Un/+jPZr/2z/7mF2fu/dsj8zMXAISSv9k+zEo2xwbp3J7UpEH+g4QDQQUKiGc/5F+bByxmVAsUaNxrTf8ZzOd8zXKJRNDacaLl+CHbrGDFCCzjIfUzKXxBY0ZoTsnOHRARFeu5Chrz2yVHOlGK+raIMiiJusqGWZqJtytXNMxHeqlkc9leZVGJ+EDcUo8/2s5bH29xwMP02hzalFbj9xuqKzbzlWaUyX/ZEVEq1Vusbxb8hFmyvslE38T7JvGddmV6s/z/9vow2agms3Q7/MF6X/omPm+5qzaZKCNKVyQ0Ex9v6Fs9mXF6t06IC/C9VQwET9L7J4QYXAEghBSevK//4f/aYP7eK8vvSNLHLXaz3t2xBpDllqpC2iwfPcu87IZMDbUOKFBZ9VlEVea9qchsDIsi6XhVzYV7rW95ZQDBhfXSV6r5XrjQLM9MFwWaUo9ybpBXBRaotnm3cch+yfZvdI6jbdyxnHMzmLtsE+cedlltAFgcIFr1nQmHP9zGG4LT/AULN06uhGh3CP5wm970p5Lolfu2i4sDCA6v4j0NXhlv0QsJIbsCBgCEkICcvev80dUrixeee+fi0r1ZNAWPOOVcKKKyRLpkdq6JVMCUkMcMHeWddXp6gPifqqggC2hBEX/WG9jDISjH9aBJ5cl8RCom5kzqwaWwDS7FOiqd0rOIxwRNSFJXdAgy3TvmGTWhGYsDsDiA920rYgBBs4LrDe5ugbO0/wkhBaYAEUIqfvTv//jUL/yr2RPXrvTeOYPXB4NrRRQnaznI3iqNIktxy5TwHBP4zYjCHJocfSm2uN1eTNqcaCGAoHWPOXrOuVuaXorGVgAETZL0kjYAmOEtgITDKkWzre6pGSXC8Es22NB5v1liV+2EmOAwW2KSOeTdXBEPLmzeEHJFfFaz2RxCsdIidCl8JCXHphJ+nnQz0cyGkHOKQsZR+rAkDCHfpS7ufUSesBRfGX7MD68+3zChnTukurmTDRXH632DbYgIfauyofyVVcKSls8uvlxDl+zTi28un5HdZV8AdJuVC53p3TRd3kKHQAO0+BbVPyGkhisAhJAu3/7N31yZO7mg5xcXP7wyPAbLvQeAdHyn26vZXYanc6c2wRDN/2nJJ0HkWx5LkYPQsqqQL6gppclcESDrLTOqWwXauB1WvDiAucvQVu0tgmzx5ivWLHnCUrpuHZhwcFkcwJd+3PmurHrkK0XYpwSekL4F/3x9wuMVn15fCcmjC9OLML0sDmA9Hwq0B23xHap/QsgEDAAIIVP49q98DquH+/2Lr1/+2OrogOn7LFZyQo1dqVIgitjIGlHKPUFZwnZJqgbVWDRfElIS9K42JoWbKbnsQAvPykgvKNkv+YXeMfWconAla8FGFdpk0aYIzdTUW8kXZ3GATt+qGKCaXonzxuIAm1wcoBH0BeMG36P6J4RMgwEAIWQ633zwy6vDE4OZC5cWf3bUzgVR2JpMB6JFXkmrLMikiNS8amDmvUJE2jb4xIjusjfOUi+KLV9v8EfB5V0KMILlnB9UCetyDumku5y8/7yy4HflV7A4AIsD7PziAGPFuEWvwd/z2B9CyBowACCErMn/d+ZLq+2J2d6rly79TIuB+e4Cq+NbEp6jT9xmqSTm4NaHAmWFFHL/Xe8X9ZYsYG2LNSvBJ/ZkfsDySVxa5W6YtGpgm5JN35uDq1FZ2mZQE6s5TXvSXQ4/WgwAFgeYMoQSA4SVkCoGcF3e6Vu5q6P1w/ROb1ZCrLyCBKljAI0rIZVVbyOyLtUTrmHOd3hxAEEjaBXf+TrVPyFkTRgAEELeiD//tS8PV47PzL566dJPp9QYV2qNqZmskADTu1br19cIirRPP7a2MtDVc6b/iwKO7rLUAYO/1NRtXnOw7B/7bdtmjz/vNygObhUDeKTgyw7T3GULCfyuOIryYyXTdQ0TughQe8iEu1x8YjfvUZ84FBN4SlfRzbPXKFvrIZRlgRAphb5NserLwHNsUMcA1gxavSWuhCAMwe9SW9AId2noW9eqL5HYZDNYrFhPeL0SUi1x+PRO9K3e7BESeOz7al+MFAPkB1YxgE+vPyRP5sbFAN47wffp/RNC3hAGAISQG/BnZ74yHB4fDF557fJH098ZKmrHseRc6kq8WGpMEKAKV/zRJS3quWO7okjS/MT8q/T+HHdEdxnIbq+peYUCbWmGCUcfeSwWOdR2OGyJI8UGFtugiHsWBwifV7UoMWUIHgOEFQJ309MEx/Wi0DcWB1g/CgCP/h7VPyHkBjAAIITcmG8+8LXV0eFrd79++fKHkPSnCWiXsp7yIenvFdvIW2SNajldxzR0JwZIufdaSVLYn5E0upUGsLtMZxdlWVxkuzfr+xCQuHrTEDkUjQjPFfH4YtJdDvk0NgNaZqTI9DJNJlJDMxYHYHEA79vtxADz8wDw6O9T/RNCbgwDAELIuviz+//wwvEDf/qrvcWld5tsSpi6gmblln+s92umS1132bUdkGIDbUsue27W0UZRQAOKdCiQlJAgNfZDgZCsb7vLvHRJ9cKigyv2Cim5IqrStiImSTtech2fBJ/YZq2S6WWWYtxid8VckRDGeN9iDKAaTGifzEl3GWV6O/PmA59U/OgOobLqYwwQDPIi3NOCRhhRZdWbKBfX6J0YwKZ/UvFPt+o1zpJNb5y3HJipeJdiAo+tNoTArAyhigHiZo8g7qtg1fsWPsGymFBPuA8hBGY2gptEFe96F+YX8Cgzfwgh64MBACFkvTz9/uY9fzn7ytUPXl++N8mySrt7rkhxl6OybLMei4540aOWbQ4zj+uUEol35S3IJVcku60lEdwUY/JtRdEUZWmK0DI74AOpXqpQSGuVnmJJ4KLeqrsqNT+ZKwK71yRpdJfB4gC2mTs0qyY8XvHpZXEAQBW9Ic69iOPH138TIWS/wwCAELJu5Ozck/ccnD2/uPrjyysnq+xwoMli2q9UIibrNwQBChOyAuR9upIeZL/PIt0q/6q2xSXNKSQptweWT5IcZ5hXnWu+BvXWqN2vSJIs/y1YUphQLgSrPqnBIvu8i8G8TyKaxQE6fatigNI3ZXEAXy+yl95scQBVrA4xEly/jD86TfufELJeGAAQQm6C7z/8sMjBnly8fO1jw+GBIIC0qHkET1RNvcGuJBUbkq2luMvRuM0aN3vw0qIFGlPSyZVPeyxdywqgLUJMUs5lj+5yUaIauwQ/taaxU4wm8uxLDFA6yeIA/vAyBBYHKDGAfwkxpW+3UxxAATTo9zFUlvslhNwcDAAIITfHfzn9+eHoxGzvlauXf0bbmSSgk/oWU3jdA3DSLzouaRLxbnNXSTJZJooZqvBbQzK6ANLAJFrrwjorS5i0yo9TaGvyOp/yH3JFcm8rn7gxZdnAFgRYHMDnLcZ7GmKAYNVPDKHEAGElhMUB8purlRD7r8Ma5K+4ounhMap/QshNwgCAEHLTfOuB3xgPj/dnzl288jFoI1o2/5Z0HUvFseNQtLKcJ8WxJ8mY7nFNHhShuaQ5g9yk/MQBOIJ4/kx6XJGkdqanSVJvlnVYdJdDyDHNwQ1KOgjoOC6UHyuZrmuY0EWA2kMm3OXiE3vUhPrEoZjAU7par4Tk5YEw3jiEGI/FjwBh3sKEh4eX2KCOAawZtHoLiwNMOb7pBjGAAg0gLSD4Hg/9JITcPAwACCG3wl+c+dLq+MjM4PzFyx/LRqYLd1G0SabD4oL0C7VLqWVrujBYzkBQqCbBo9xMUUa8YssI7i5XO5JdgpsizGnZ0YRGkmtttobRzRUJyk8RigN0laU5uLVqZHEAn//uEDwGCCsE7qYjBQclBoh929/FAdI2mQb4W6p/QsgtwQCAEHKL/Jf7v7Y6PNa/dnXx+n1Z60jQYEH/GNXpkEXJp2apXYMkrcS3ASQtC9PcqPW9qfksF31loOhs19NZ5xedKhYJpFaSdiMENR9iAE17Fcw2lyhAa3c55NMgT4crOgSZjrI+4LkiJQZ4o1z2aiWkCFAWB/AJt69b6lQdPZYJ373FAXoKAb7LQz8JIbdKb7s7QAjZxTz/v37jno//0vW/vnPwtlF/cBnmKgPpbM7GpIyYlMlH/Igbv1L0eH6olDQKKNDYBoJ0rKLYo6Rx2QgkJzu5ulIelm6B5Jwgkazv0kvzw7MWk9IBsQuCPATJawPi9nU+fNRkq3V92hUIRN3lzg/IJ8QEhzln/fgrcnkyKROmCA8RW22A+G9t7kTCWEqL0KXwkdhG69DEfq9Tm9kQUt/yu7xv+YqFgCplIDlcsa0i1rfwyrig4YGevzH8IJ07pLrZe1U+CO95+AQ1zrkHrv4oe6VnDJVmUn8W/vmWT6qacJ+5cJd9AdBtVi50pjf/6sgqWsHf/AHVPyHk1uEKACHktlj50ZHZ+65evXDf6vKdAJK9atLODuB3paOtCb+uu2yo+FmfCM43TLqnu1TRtvkvMDOh06KBGd6p1FdbvGE/vR7m0YbtsFIKhCV3WYox3yAf6C71NgYWByj7CsL0sjhA6Jtf8em9neIAqtBVXGswNwYhhNwOXAEghNwWL3/nP9z9K786s3BpNHxnf/acNEORsg4AuOfqvjnyj03Uodl2LaqpMcddGlPknliULfTcVgWNIKVYN6IqpiIbU9Ju1Tdu0wZdXLqRFwckyjcxWza6y+bI5oNBp5jQxbzPqw064RNPs+pv4C6bTRwRmfjNpJ//Bu6yTap6CzHNHZ1vlN90d0oUT7t+eI4gug8X/zfCn0rfJM6bJ26VwfqV0CwfJzrNqkc1hDK9NquiUp7anScBUC1xdJrpRLPujdbIZ6A4/xPzBltz8U/cXprWrtqxQNC2+Kuz9XeAEEJuEq4AEEJul29/7nPA8WbwytXXP4Z2UO/RDB60+/fFi03XPf26BZCTcVKSd7JKk7jLR8G0xaq3lQFV86rTOoD6Vtecyy4IJ9M3SPaqu8tBt9f54gpBe8M8exYHqPcWo354GQKLA/i+EV8Esw0qVd+mFQdooU3TqAq+R/VPCLltGAAQQjaAvzjz2eHw6MzglcWLP5UFJWD6JedUiEZp5YIV5sfmTBGXwoCige3XdEcU8J21yNdEgiCztQHf6mqGfmevbfJbNS9XpH834tpO29as7SDcJ5NANPvMVQKPdoSmxQBgcYApQygxgNossTiAf0/SV7qBohWR7/8h1T8hZANgAEAI2Rj+8syXxqtHFu89f+3aB7PgbtxkDdnk7nmjZNWL54q4UZ2IcsqDhfQLayaN+a0WaSBnVSiqQ4EaE22tiz/pnFWfBWg4pqYxL7mJ7nKw6qc5uEFJBwEdRT/Kj5VM1zVM6CJA7SET7nJJfHfzHiwOYF0qkdhks9wly+nxD8Wmt4oKrA+wr1zdt00pDiB6dQxp9NHfp/onhGwMDAAIIRvGX3zyqxdPzv35r+j1a+8Aik8s7uE2tTWrCHLcVXjIFckCLGSYFAmk6vo+hRdlHUDTz2LvKO5y0eUqJsuCde3xCcSarZUrEpSfgsUBoOFjNuGOeomj+gTVYqfuEDwGCCsE7qYjry95DBD7theLA4xbfG+lv9jKo1/vgxBCNggGAISQjeTZ+/Dub/WvLb9rdflNAKLNmRVekdgpNpCggE1dmbtsJXvTk4JIzXcGfxdtJ1dEJIqt9J+t/50nIQkkvzQ/WWEHCuVOdtR8iAFqX5fFASb6VpR0nF4WB4gPv0FxAJnpv2XQnhvzf6wJIRsJ/04hhGwocvbwM3fMNJevL354PDpox+RU7nIWWy2kKCSLCryNZ7Z0fFP7UUK+OOK9LhwR9KjWGSaIOTBaPcRXBsrBoB4DeMrHtFyRyRgg9cG7Hfzm4BP7vEWZbl2BIop+6ESuSAxj6pUQHy9CDBD6VscAPr12xfvm1vWk4kd3CJVVH2OAYJAX4Z4+wTCiyqo3UV42aXRigPzGKYp/ulWvcZZseuO85cBMxbsUE3hstSEEZmUIVQwQN3sEcV86EPsWv4QIcRpUVRsZSjs8OtPgbBkJIYTcPgwACCEbzHce/Hw7OjYYvLp06Z9AB2XXL1C85PRnV57o5pNkrZWIaetZ+Lksa6snq5bUEZiWqnNFpJMIbjeWJBCPPbrFASD5DKLK0i4xQEoAmSZAq7sqNT+ZKwKEvoUMkzxvLA6wL4oDaNvrN4peg+H3f5fqnxCywTAAIIRsPN/+5Ofa1WO9uVeuXv6p7ImWfAxA2zoC6CqknPmjYUNwUJYiqYKvq0B3jn1lQLsmtOWKiDv6RTUWqz4r2vxGhIcD3dOEQnwCLRpRTGyXQQV/vWhErJErEmKAuMRRK8v6Lot5gkYvIrg2ob3DWW6GIQSZjsqqL7MURmR9s2a+ryB8UvmZ3izmFIUYIPatigHC9PrBoHGJoxpsmHBrZusnE1Y96umNIZaiGwPUfcvzZusDMWGpcvSjmo8TjnoFyac3FwcoX0uB6HgsTe/Rf3sAhBCy0TAAIIRsCn/50BdH4yPXhivXr74/6618DE8r6ST+rq2ZpZW587W7DK+cBTOApcqNgSJtKLDjeoLpHs+UNMu5iK02P961nUtPf7jWOUUIOTZANwnE9JyZ0CbcWRxgy4sDdGOAOL1xCFL6bPEJYuw0sRJSL3GEhCX72tQTfrPFARodq0D10d8dgBBCNgEGAISQzeJb9//O61fv/M9//4mVpbdBgDZ51YJ86r8f82/FuaDSRBPafeL0W3EbWLUt7nLMfonqzdO+BUhH/EeNaJovG646ka6T/lg5+sGEjgk8k0kgqiwOYN31gCQ129LiAPWPYXrrZhtfHKAz4SFSrVZCOjFAeliL0bV51eZ7vzcPQgjZHBgAEEI2kedefft73/zUyrWfGI0Ow/Jzkj6yrQHupsMqhUE1HcAPIDv6mmKGRMwwMQQo8qsIrNwm3SudDJO2TZW/AEWjJacoPlzVdhubdA4ObhUDeM9LAo/1LMQA9hC/K6pSrcRljAGmmtBFgJbedtzlkvTi5j1YHKDzPZnaLHfpFosDoOrb+osDqGo7P9/MjtshvX9CyCbCAIAQspmc/cTR+blm8NL1Kz+j7cC9+fRL8dwYqLSVuxyOTAFEBaoNoC1Q/t7y7JFyaifCjeYlW+SgcDM8PUcUqpZ4YULWipe1otBWPDaYmi+Obq5IUKXp4ZO5Iv4uFgcoQ6sXJaYMwWOAsELgbnr6DoUYIPZtdxUH6I9ltIT53mNny+MIIWTDYQBACNlcvn3mzHh0tD948fqln8qOKkIdX5glCkuDyerNhbL9S1tzd11vifoxkZ7yHmMABH2P/Kac3+6RQ8wVQXCFYYoRdsUXJbpZ5lUMUPu6LA4w0beipFHu0rAbwad3nxUHUGm0bUSGf/8Vqn9CyObCAIAQsun89YOfa1cPXxuvLl37QLFOTW422bINad8u0Xz3bSVJ7Yr4mZtBI4rt501CVMxeDQkYlXDtJoGkvQoqmOIum088tTgAipKDZzpNxAC5mV/xGxF8Yps4FgfYN8UBREeDEYDm+189AkII2WR6290BQsi+4IX/7T/O/vNP/sPTH7r7+Ku9wWXPxxdXlFm4i8lHQT5Mp5KT/iv4ygDSqaBmqadFhnyev+eQ1JaqCFS0KY9KF7MYk6ZUGUPySRp7lD/VksPtdil9Ky8xEzpFDOXWcJf1zXsoEA3DlCSAzYK2nRP53MgwDaJVX6rfAhP9DH2Tqo2EIeQxhL7lk1RDT8JjpSjsTrP0EahdKalHYZZgd2kcQuxr9TmWKxZqle9Ducsaxis+vb5P2z8Cn974PcxhRd7WnR+lnQmwh2jdc+1+UvnHatoE0ONLR1sZf/f3FkAIIZsPVwAIIVvE86++9T33PDVa+shomD1OCc6xmKVdrriaFPdx3cqtxK22rQvKrJiLh+3ZI74dVsTK/eZckWA5Z3e5CXn2xU0HRKX1zJAYPsTlC7sS9phiq4sDuHANVr1Pb93MO5zHG4aQ7mJxAGxycYDeqHdtsDQ/mgMhhGwJDAAIIVvF2U8cW5hr+i8Or3xU28aXAJJAC9tJO+LV0ySsGSz1QuyKHywjyNka+XZ/Vps0n0JFvJllmAQta3616/sqBghRRydXxK6oiXsWB0jTW/VN673FqB9ehrB/igOkD3Hca0cy/rOzYe2FEEI2EwYAhJCt49tnzujoUDN4eeXST7ped3dZXNCrKTM3oRGawTRiW+vIpNGlkqTlXEpxx7lYs5am0SYRKRZUmEwv6TCqKn52kBQB6m/ParHrLgeZrsriANbd6NN7l6pmOm0IJQYIKyG7pjiAT6/tK4CghbStak8f/f1DIISQrYIBACFkS/mrM19oh4eb/pXlxfcCuTywmrI0GW8aMahSVXh2PETRYsJdRhC+6b6obk3fVz6xa1fbbZyVpZq6zRpRpJakVTPXiCwOEHV2scMrY37fFgeo+6aiqtLrjxTyd187CkII2UIYABBCtpq/OvO1dnhYXn/bcOWU+afZJy7+dVHSdlu0bDWIVNPKLuWDDkuoPcbWAsRsaVWIZhk56S4n0daqZ34H63qiWcgVmUzHt38rquIAXXcZwV021cjiAGqxU3cIHgOEFQJfrED+VD0GiH3bCcUBtJ09vNT028f+DdU/IWSrYQBACNkGZPmoLlwaLn6kbecAk3Ro82/zj5qlVJNiA0Gj2qZElK67LEWoJc1l6TqAHSZUW86A5tel84cEjUnSpnK+badpcL7Tc0JaeX5Xp1mIAUz+SokB1nCXQz5NmIFiqLM4wB4pDtCOm9Vr/f7sCIQQsuUwACCEbAPf+uxnx3pMZs4tXf6YXbNkGMDUlfhVycZ/fWYLwnE9HZs8P1AhKpbLbieKuodtwnHCwTWhidyyMbk5zV02n5jFAWJgUCt+dIdQWfUxBvDpRRDu+RMsI6qsehPlu6Y4ALRtGzQYr/a+8/m7QQghWw4DAELI9vA3Zz47Hh29PlxaufIBSWJbEMWWBAUGBbStTWhYs6je2qLbGpO4jbp8R35Dm3RbuTc7/ZYrogK0MpkIXkRqpSxDDOC63HOKbAgu062ZTBOgVQxQqXnzkrsy3dxlBF8cJtxLjvtEDGCSPKwD2PTGGKBiSt+Ctva1m/xPCeKimkd09D0byqY3njgkqGIAn97qexJmKYdzZaTdTQudCY9XfHo7B4NKmF6E6e0cDFo2fKt9T/wtnRgAAsh4CSKPff0ECCFkO2AAQAjZNr7zwJevXD311499fLh8b9GypVCSmpStvWQU9Sam3uzMnJAanjS9RKseijZb9XllQKMJnYsDoIWXpIq5IjHPvpv8g0rxd5xjbwkWB9jvxQFEMV58Fe3qY797HIQQsk0wACCEbCcvnn/Lu+9+Ql5/Tzs8kGVTEoWSbeMSDuS/rkzahnQXSDgUqHKXkZVlnS+OdB5nbq+qmpYLoCpNVvNuh2clF2KPdB7opLtcSdJ4ZdJd9qQXFgdIYRjCZFYPL0PY1OIAXas+Tm8cgpQ+W3yCGDtNrITUSxyqY4wwd0hXr4EQQrYPBgCEkG3l7CdODtDOXVi58pOa7eRizYq2Yso4a12xc3JcYqKBtiZAk/KTpLQrd9lVeFbb6WlZvdnTASCXKPOM9ib6zWVRAjEqwNRcEVhU0U0CYXGAnVYcoNb6YXqnNyshVpql9RUHwLjpAY32B4+d/cAa/30ghJCtgAEAIWSb+dYjnx+1R6+NloZXPlSEl7vLgMQ8e/O8BSHJ2wWooIQHUaTa+UIoujToyKyAW+ScIoRDHt3wTgsLrT0/27qVJM0C1KTzRL64r0KEFJo13WUNfeumlUMrcRljgKkmtEdB/pDQt7KNQePzAbA4QAzn1mqWu3TD4gCtysGZnja9f/waN/4SQrYZBgCEkO3nO2e+dGXxzr957KdHq28FgHwAT8kVEZfpWaADAFrLHonJISmVv3ZwrY0vAr7nxE8AACAASURBVGCK3KyvSGyTsrfdS47efHF8XSNOyxdHN1ckqNLU5zpXJLjLCO6yRRcsDqAWO3WH4DFAWCHwxQqk4KDEALFvm1scoPnAvXcemB08/jt3gBBCthsGAISQHcFL59/87nt/2Lv23nZ8oJywrujGAICpxJAEosW3FnFDWPPBQSF7RJCrCpR0/PQohFQchIfbw0TaYtXba6sk9XyX1te1q+ZDDFBFBp2DQWt3OeTTIEvSMOQi01HWB2wGSjMWB9iu4gAtWoyb589fPnXkIAghZAfAAIAQsjM4+4mTC824f354+aMqvay9GuRcEUFSV9JgQgEXd7mUA+u4y/HPRSNWZ+kINP2NqEHVZeWMyl1WF4gu0yfcZfOJpxYHmJYrMhkD5A77FfgVgMUBbEEjjKiy6k2U74DiAC10tm3aK9dW/+h0eSIhhGwjDAAIITuFbz3w2dHwyKxcWL364wBMhJXkHPGD3hG2w1qytUSJHN36dG9xl+OhQLmZHSe6dr54g5KKc7vFASpLW8MQsA3FAaSKAUpc5Q83jz/GABVT+ha0ta/d5H+yWs53TXX062woBOGO3VccoEGvmVuC9B77N6dACCE7AwYAhJAdxHcf/GJ/eeHOlw6Ml+4BEC1nU2VtSeMPXnKWlVnrtbl5k5vaUULuLkvaP1BeUdxlDUpaAG1KJlK12lCseneOu8k/KBpRKkmaG9gotrU4gILFAeKEWzNbPwkdvoXiAIr2nosyO3z8q0z9J4TsIBgAEEJ2Fgevzrx+dHn1+n3teD7Yxq65TZIGy1mCejPdV9xlAdCYcG9Sqkhr7nLWusWqd/O+bSF5L7J0tOz0XBGLAaaZ0NalcGXSXfakFxYHSGEYwmRWDy9D2NTiAN0YIE5vGEI3BvC+pVG9tqCHl0AIITsJ5iMSQnYcH/r3/0tv5hUZH+kd+8+qCmlUYds8Uza9tBCIqAogdoaOKBptgUZUGxOkjQqgjXoavjTaKqTRpKklP1khaYOwqmiKG9RKAEBUpG2TW96oIlcHUEU+ziYloniyiRv+UjdLaS1JfYv4XWKbFyQfQwrbDVDdJciF0cpd9kYNr/O7UB5VXP7YxvpWemt98xHlk208VqpqNYde2RDy60Lfcps4S9UQ7MkKiFQD8XkrQ9PcpbqZTBuCDbma3vxIG4LEu8SnsdwloW/QOHVv3AwCkfGgxVghj3/1zTf93wFCCNlMuAJACNlx/O2Zz8r4iA5eH117n4hA/RR/NXGVTWdJLq/lYiet7ia0p3Jkn1jdXYbaqkIgGPMp27+p3GUJ51SKtpYEYkn80apHuLFq5jY8iwNEE936toeKA4xVRjJq0KP6J4TsQBgAEEJ2It+5/8vj0ZHh0rva5ROd0+vDwaAhGQNhRTOlxhQBqqYsSzNBUI2eVaJt1veI+eJFXkuUjyGXfTIJpGSZv3GzKoEnLBtAURUHcHXu4p7FAcrQqh+nDcFjAPHJLDlF+RtTYoDYt1srDqC6gvFI2n/4Kmt+EUJ2IgwACCE7lHZ0vNe8Mn79w6r9KO6T3JTwoyk/uAITsYwhFGfalaXr+24M4LnsQLGcXYBCAU2nAZUs86KzK5mef0x3xfWBcldlkLuar7PI/WDQyl3W0LdKknp/EWQ6SgCjPlEeA8Qh1KsNFhKYmtcwSywOUJYm7BO0K6qtYjCAjL0BIYTsMBgAEEJ2KH935oysHlp8y0ujSx+pc0XiATNmQoetn27xZ/vcRWrj+s+8edeabdaIIvU+WhOa1cpA1N7dJJBg1U+4yygHg3oMYKlBqJNzUh5LFQNUJnTlN7skdec7weIA21EcQGRw/c39HvrP/PbbJ77UhBCyI5AbNyGEkO3jTX/3P537wOpP/O8rsvB01uwQTUn4kJQGpNqolDwY9X8UqrFNygT3pA1RabRNuUQ510fRqEDbJkcSKqqNNuncINuLLNKqaN6xKtlWLptBq521k9thU0EzADmmABB3rGbi3uLUMXt4aGavg+2mBeLeYutbvbdY7eHobiMud0lW0tVeW3tjaZaUv2/kFXj8Fe6S0LeyIbieJZtAu1LtLZ42vRIfbrNUNvLa9FrfwmbfMr3qDcqHUjWbfqXaum3TG8b7+G++4+S3L1/46aM3/V0nhJCtgisAhJAdzbkPrL79r+ax+r52fBBZ9Jn53cDTXZKVKx3LGUVhIvm+IVEGotDW3WUJSSDZF8/ucotWRcyqFyRXvs4VKRkm2Q5357ib/IOwWFH6VnKKYFfCHlOwOMDUdPwqp8jM+2kbKsK3okz4xhcHaKHLg7v/w/kL/+TI1C8zIYTsEBgAEEJ2NnL22LN3tb2X29c/asKvI8uQJKNo1HwoklSDnE3JOcVAj9kvIRHcbk93iifwqAUeuTiAFi07PVfEOuDSs6P46+wR09YoyjL0rcQA3smynmFqnsUBYgxQK/78FutbiQE8Uqqix+nFASCoYgCfXtWmFemPDz22bCEKIYTsUBgAEEJ2Ot+9/2FdPSy9i+Or90FNWSJmt4tAxTL7tW3zNVjSkKa/7WoT2tSbTLrLOYm/LY52ekh1LKaZ6dE2jlc8IIlRASY2LQSDvDoY1Hcj5LYpBjDBXfYVIPxYctm12mtbrTZ4DGDjqqV8PBgU9f6EEgXVJw51YoAqHb+W6Z08+7hpoQy86lvZV+CzVPn03qWqWXfCESY8rDao1jFAHiTQ6Vu5y0KpsIsjdVXQH6NtRH/wb9+y3m82IYRsEwwACCG7gL898wVdOdSef6sOj1umeEnVEDP/xUWqy9y847MUBwAAtFBoo3kxoIEl8Ni/4Lqutur94dZCOmfVZ2Wppm6DVR8ladXMbXgWB4jrANa3XVIcYGVJ21Ye+513rPtLTQgh2wYDAELI7kCvH20OXcDln1BtAEVjST2I+rITA4SDc7JsbU1Zdh1cIMh00bybtZNBHrxkMX/dXO4JdzmK+6whXZ6+YbMqgafKZUdVHKA+GDT1LWS/5PFHqz4mTXUUf0xh0jBxU1YbbDJrg3zfFgdQVR32e4N2PFrnd5kQQrYZBgCEkN3B97/wsOiRq+OruPRBIAvNdBgMBGgVTXaXs39torsoy6KAzbzXIMqz2M1eck4kASq5mWMDqVcG8tE2dQxg/S4Gv/3oz6mua7dZiAHsXVJiABegMQYokjzEABqsehYH2ITiAE3b11YFzVNff+cbfYMJIWTHwACAELJrePShX1+8evJ7T3xsvPRmiErJjTFtbGJR0qk+lUiNuSIQV/yVsmyn2cZmQidbWlvRiRvXyGX3/hSZPuEumy/O4gAxMKinF90hVFZ9jAE0zJsL9/wJlhGVtSF7qd5qcQBRLF/u6Uie+CrVPyFk18AAgBCymzj32j1vuedJufZ+Gc/VuSJVuo5kPWfxgSeIi6m34jEHZWnaOl+MPnFeRrDIofLRgXwo0Fq5IpauU0RqpSxDDOC63Iz5EJCUGEAAVUFHkuYBlLsqNW9WfVemY/puhLIOEF4RYwCT5NNDrJJ3FJnSt6Ctfe0m/yNAeU5Mxw9qvsqGQhDuKJsWLBOp7Ej270k1S+F0qDTSyeObqgkXQNG2g/6B8WiF/2NKCNlN8O8sQsiu4uwnjs73MfPS6PUPA9Cc0++yrMoeyVa968scG9T54lmAZu9fuu5ysOq1NdVbooLYrMQA0dEvony3Fwew3Jyg0Yssrpt5h/N4wxCCTEdl1ZegIoyo2o1gCTwafxumNzeLOUUhBoh9q2KAaiXkpooDNDJYunK5GcgzZ98+9dtKCCE7EwYAhJBdxvc/+el2dKCZvaSLb6ukfLKNK99d0YZ0fPfvS66I3ahQsUTwZlJZmiGNYNW7ee/rAywOsGazPVgcQLV5/M8fXbqy+MRXmPxDCNllMAAghOw+/v7B32rag/3xe9t2PuuzRpDSfhpXigBUgk+c9b3J+o4JLdNyRVxZCmBZQHX2iMcAuRGLA+SBd2MAjen4tUzfhcUBVNHXmbt/7G0Xnj13019fQgjZbhgAEEJ2JY2eHPZe0tc/iKxrVez0HwjQqvqhQE3SomFjK5BFatsmy9n1YZUrkuq7priiorbqFbVPvP7iALUkrZq5Dc/iAHEdwPq23cUBeu1Mi9GRkyfwR6fX83UlhJAdBQMAQsiu5LunP92uLjSDS7r4NsBNawGQ034swQVAkwW3ZdQ0JhcbVbUSwggiNSDRqo/p+Gt5yVCstzhAkNclNphsBmBKOr79OwU/NlwWB4Cb9/USR5y39OO0IXgMED5VX6xANv/b3rgZC+Qff4vJP4SQXQkDAELIbuUfHvhKMz4ws/x2beeDeR8t26LmXcqals1pPZJEapN/jcbcZUk6fiJ7JOayt2sIUChYHCDN0h4sDtC0vRlF8/hvvWft7yYhhOxoGAAQQnYxvdGx4cx5XP4IBGhNphelCCkZJipuQptIlawsfbGgyieRdEVMTEu0jdPTfJmhBB6T+eL599WpNVUMwOIA1bwh9M2DuknFj+4QKqs+xgAa5s0TvfJuhDIi9Xmzl+q04gAympF2pE3vxt9OQgjZqTAAIITsYr575nPt6DAGF9vFtxf9HfPFm5CKoyraulUvtbtceckwCe1X/OckX9PFpuMu1/ni+6I4gFQxgEnysA5g0xtjgIopfSvbGKwn/o/YR1CpeURHv86GQjDvcbvFAWTc096oaeXJL70LhBCya2EAQAjZ3fzDA1/G6EBv6Z06XsgxgLhYNMtZEHKBJqx6l8vFNg7KErV5L6YVLUHFjOiSwLOfigPYhASNHiIxhFDBPzGLecIQgkxHZdWXoCKMqNqNYAk8Gn8bpjc3izlFIQaIfatigGolxA4FQjM/kAZP/NZ71/o2EkLIroABACFk19OMjrczr+DKR4pu66jStg2isCTwVHkm6gI0BQndXPYcG4Rcdne+i1Xv5n129H0dQIuWdcVfWfUWA0wzodMfqit131gcYAuKA/TbmWt3zMiAyT+EkF0PAwBCyK7n7z75iI4PY+Zie+0ddq2rLIvzDW2iVZ+apSq/DfIZ8CKuYkuuCNA174EqBsjuMkoMgHwfiwOkf7oxgMZ0/Fqm77DiAGjl8S/ft3zXwR987sfW/80khJCdCQMAQshe4LEHvijtoZnVH8doTrJwhwn34kZrOpwH6Qh+PwO+pKdL0YhidyWfuEVSvOK5QFp3obbq1ZP405NZHMAipapvIYGndHViJURDAo/UQyjLAptaHECa0fxdf/z8hY/dcdNfTUII2XkwACCE7BF64zuvvOlpXP1IEalN112WkCsiMc8+5phk2eriWC1yqBT/ZJ59NwaA1DHANhYHcHXu4p7FAcrQ6kWJKUOQ8cy1t8wcfuJ63BtOCCG7F/5dRgjZO5z8u//5wgeWfuz/WMHCs6pQNGktQJtGFVBREfPSm6Qx2yTtVQSNNtBWFI2KqjbZo06H+NjGXs3/NCnNvMhJlbwxQEUk2O9ZYdoVlXRSj1R3oexZELED6D3iEIsdcihjd2UVnNWq5p6k1QEzvEXzwyWLdb8L4fkAIHl1ROEjyn0IPZHSmdxMbAj532EICH1LVRG6s+QTmNKWNMwbwizFK/HhPmmTzTrTG/uGMG9heiX0zUckKmjlR1/86PG/fvXiP7nz1r+ahBCyk+AKACFk73DhA0t3/+Usrr4b4xl3cNV3/Qa7V9ECAFQaZBe6+L5qCUN5KUCmu8vBFy+J9fU+WrO0w8rA9Fx29b65Ve8Z/8H5tqUKTxnyrPo6OceGABYHKPsKrG+op9c+lLWKA/Tk4F3/8bmLHzu1zi8hIYTsfBgAEEL2EHL28JN3Yu6SXvmg7XMNOhtwZYkgLpuYK5LkcQkVkmHeyRWBi34puSJxc621QZ2OD4DFATonDpW8o8iUvpVtDNYT/0fsw6rUfGoWY4A4vesrDtCMZhf7lw4/tcTkH0LIXoIBACFkT/H4w5+BHuk1b9aVe5LUk5wMYnox5IKrlfsVk+mdfHFLGEHxpP2Ay3RX4+5ysOrhae8lKmBxAHvjGgFVGlsYQpDpqKz6ElSEEVW7ETTsK+gss1SbFt64OIC0vR/e+YOl/vUffJEn/xBC9hQMAAghe41GDo/xqly9D9rzsl8A0Liyzyo/pMfEtJZE3vVbbYcNPrF03WVlcQCE9RMNfSvePGIeztRmO6U4gCoGWLjryt0XD752w68cIYTsLhgAEEL2Go+dPo3VBQwu9K58KGaYlOwR8ZUBz8NJhwIppE1iVzzJZNKEbmMuu+nI6C7HGCC7yygxALKOZ3GA9E83BqjS8WuZvoXFAXrtzBCjo6vHcfr0LX8VCSFkZ8IAgBCyB/nBJz8jo4O6dAdWjmfnOOXYZEFph8JEjah20KdEgZit61AcoJPAgyJSo7ucqa169ST+9GQWB7BIqepbSOCRML2dlRANCTydzR5lWeBWiwNob9w/otL7xy/edyvfP0II2dkwACCE7FFGB3TuNVn6CaCN+eIqKePfctRTDGDKUvK+Xs+ocfMeqi3yiUBBpBatnJ7nVzwS6KTrsDiAxQBhiQM7rDhAr52X9po2c+v/uhFCyC6CAQAhZG/y+Kc+BRyV/ivN4nv9vJosj6fniuQ/SsxlL8qyWNHFXY75JKahuzFAahYlKYIAhSIdv19OAQpWPSqZnn+0u+rr2m0WYoAqD6nsfEDctKChb1UM4P1FkOko6wN1wpLaFE9fbbCQIIZY1pOJTQtVAo9b9XHCEbKDtGpW4gTT9/UyS903n6X0HRgOWh02LZ76/Dvf8CtGCCG7FQYAhJA9yw9+7TPN6ODMyrsxmks1wUTSVmBL4BFAW6ASgkjbA1zfm7JM8l5v4C4HMV0S61kcIIYx9UqIjxc7ozgAgNUDGDc//NIH1/MdI4SQ3QgDAELIXqY3PvH6Xc/qpQ9rSvHPe0kBiIqiLVZ9OtXHVaO4ANU2Gc0AggmNqDWNtZxvf6ndVfnowL4oDlDHAGXJICYsbX9xgGa4sHTgEsYza3+nCCFk18MAgBCyl/m7Bx9cPN48eea1/vK9imj3tkUR5hM/g6NvujwITVSKPwhracPp9V13mcUBqt0IYpPWXQmpm3mH83jDENJdm1UcQHs/OvWj5ZnlJ3/n/ev7fhFCyK6EAQAhZI9z6YNLd//lbO/ijwl6VZZ5oqNKXRRqmzSiVJYzSipOky63b+guK4sD5BH4QOJKCMpL7UOZ2myLigMMVg7ceeXUxQMXb+b7RQghuw8GAISQvY6cPfLEm0bzrzWXP5g2AHTS3IGQPVKyaAT5xE+z6utm2rYpCwcSMky05Nh03eUYA5Q3hH0FYm+Ie4uzo9/Za5v6rWUIcdMCgnkPFgeY0repxQGa8fwIwyPXj/Hgf0LInocBACFk7/OPjzyioyO6+JZm+WhJlbEzPYuydE9aVdPhPLAj+POO1ZL3IlVxAJQYwJ8fY4CK2qr3h6crYHEAi5SqvoUEHgnT21kJUYsKUs/jEMqywJTiANLK8PXZdtw88ZsfurXvGCGE7CIYABBC9gerR7DwYv/6B2GyVUK+uB0KJFmypmQZyxWpYwBANIvJEgOUhJP9WhxgmuKPKUxVOv7kaoNNZljiwBYWB2jGh5uFlXa5fwvfLEII2XUwACCE7At+9JnTPSyMe+d7194OICtmzxdP5n3ru2NNHFuGugSRKrWy7B6JU5L4XadKNwbYg8UBqvWBOmHJQqw1Vhu6KyH6RpsWqgQe2BJHnHCE7CCtmpU4waKg1ELGM9qs9vr9536PR38SQvYFDAAIIfuFH9z/eRktDK68S9q+WdcKLwDWZndZgGKTh1wRSQlB0ZjPXvLuKg4AV8DqUVAVAwSrvtj5fiOAPVUcQBW90UFo8+SXPrK+7xEhhOx6GAAQQvYRvZXj4wPn+1d/PCjLbkqJtQ1WfdaNbeMCFF13uVKWCOIYaznfassIdldsBmCzigMgvrTEAAKsvziA7p3iAIPxwliWm5YH/xNC9hEMAAgh+4jHP/1pkQP9/h3N6lGIoIG2LSRrTfO9O/kkWcsmg15Mpk9R/JWav/3iAHUMEB39Isq3qTjA9INBd19xAFEZLc9K2/zoy9z7SwjZRzAAIITsL5rmwAgXmsUPu/ZOeThZdkar3iVplR4zYdWnqMDFbn5OiAFusThAjAG0aNm4s7aIY+uAG+QdxQ+trrh5v7+LA/TGh2RmpR1x7y8hZH/BAIAQsr94/Jc/patH2v4rvcV3VCZ0yDDx7JGkg/MaQJMaqTTBqk+t3sCELrnsCAk8IV0HKKLcbq2PxdyRxQFsCLu3OIC0syqrTdN75reZ/U8I2V8wACCE7DuevP+zzehA//p7gGz91urbfOK2TXa4/SadP9PAQ4MUCeRr2bre7uIAdQxQNXMbfiOKA3g0gnq1pGPVl4SlSvGHKMgeEvpWrYSU5wPYyOIAM6MDgubJL/zUrXyHCCFkN8MAgBCyH2mGJ4Zzrwxefz+SZkbIFUmCMRrkMPu8Lg4grYZTawAE876IfhOpRSsD0aqP6fgTdnjcabC+4gCwt1guzRs3K2o+WPWwrCc14W4Bhnrf/K4cXUwtDuBXguKPKUwhHX/aaoNNZljiwAYVB2iGh0bNao97fwkh+xIGAISQ/cgPH3pIxweH7b3N8GCRpGI+emM/RXcZvg7gv833lax6E8cbUxzAhXu6su7iABO7EWL+vXbVfIgBqsigczBovKuKeOIM+JBrqx6WwFM327biACqNHoD2n/jiR2/1G0QIIbsYBgCEkH1Kq0eGK1dmr/rxLwqotrUJ7SI1J/kAArStqWmVmGdflDSLA9RWvU1XSFhCuCs0C0MoKyEbXRygGR+6dk9PQPufELJPYQBACNmnPP/AA6tXj//wBz/Wu36PXSvFASTvJQU8BgCSspR0To7JTbEtp1mkdk1oFEnq4hhrOd/lpSZbo48O7OTiANgdxQGknXn6N356+e4jT36BR38SQvYpDAAIIfuXi6+dvPPNT84tvi875fV5MqbmAfhG3naqo8/iAL7asNOLA7Rolg+f+k+Pv/7RN9/cd4UQQvYQDAAIIfuYs584OtdbnXu1f+V9+Ypasdg13GVxSVp89zqtpZNR003HZ3EAFF1exScecdlAqpksL7UljqnNblQcQA+0/eWDTyxaRhMhhOxHGAAQQvY1P/jkI2gP9vVt0s4gKWQXmuK5J22272HKsuSxpKZq24U7J1dOM6GVxQE8Hd/VvD15c4sD9AarB4H+U1/m0Z+EkH0NAwBCyH6nwdG2d27w+oeCJ+xuOnKODVQAbTyPpcQAyXK2I4PiqTVw65rFASqZrmF6t7A4QG/14Hiw3Btz7y8hZL/DAIAQst958vSZ3vjA3NyxZvVIuOwJPJoy9EuGiQJNyklXNEBbdu5OiwGCeV9Ev4nUopVTw9DArtXpOrXix9SDQW3LbLTqUQUkN2hW1Hyw6qHYzcUBRBudPQjpP/klHv1JCNnvMAAghBD0+/OXry7NXHl/dVVbAJrSezzPXtFxlyWsA8Ad7ZhVb+J4s4oDKCZiABtCyLPf58UBeuOjS/Ia+rT/CSGEAQAhhACP//Knli8ff+qH7+st35WuZMkNlXIkDgCTwZYkI26TazHmWRygxACxb6itevhMax23bHxxABkPnj764kozfOaRj9z8t4MQQvYaDAAIIQQALl284+S9P5q5dl9xmpNwbUpxgKy2k/5OtQKA4uiH5ByJVn16YNbZteJHEMdYy/kuL0WJDVDuZXGAzolDJe8o02sP33H90OtzV9f5ZSCEkL0NAwBCCAEAnP3E4fn+qH9usPiudMEVbGXVa5bgeU8wYg4PiwPAkvhhUcr2FwdoRgutLB9cPYzTp2/2S0EIIXsSBgCEEJJ56sFHZLQwuPIO0Z7EX/iROECSleLucna7TZLG83w6uex2L0oqDjyBh8UBSthTxSc2Ah9INZPlpbbEMaVZg3lB8/Rv/NzNfBcIIWQvwwCAEEIKvZVj7YHzs1fum/hNyfaRkGFScmzck3bnm8UByjk8ntVTpq5aCfEwBlHN25NvozhAb/VQKyuCwa1/JwghZM/BAIAQQgpPPfJwDwfn8PZmNNf9Xdm3iiJAEcpOhRhALZedxQFC0g6iRkfHqi8JS5XiD1GQPST07QbFAdA0zbxo7+nPffwmvwiEELKXYQBACCEVfRxbGZ2bufrjQCehHAIT5X4kTogBLEc9xgDA9BggmPdF9KvdpfHVk3n2E+k6teJncYA879pfPYJ2LEL7nxBCKhgAEEJIxQ9On5alg4NX34TRYaD470WQp/9vOiZ0O5nHskHFASZiABYHqOKTeiUkdxLSDhaGd/THs09/ltn/hBBSwQCAEEK69K4dHJ84P//6BzztR6rfu3WdBWhW342L1JLG46L8NooDpD+ppdzU6fhTmsHUfLXaEHKKpsYAe604QLNyZNh/fdAeuLnPnhBC9gEMAAghpMuPfvN0vzmwMDjRW74DXfUPIByJk4/7NP3tifLu6IfkHBYHqNW8JzVtfHEAGc7cIQd72jz2pQ/c+PMmhJB9BgMAQgiZwqC3sCTn5q/dl3PsO/ixM8WTzu61JfF7Dg+LA8CS+G26sOnFAZrxkXPD5w/IzM1+7oQQsh9gAEAIIVN47PRpGS6szrzSW7qnXI1p9G3rUjbsao3NTJLG83y2rDgAYgzgonwPFwcQn/CmnXnupT9bXLn8nc//5E1/8IQQsg9gAEAIIdN56sHPYjw3e/XHpvzOfXx3xxtUkhS+87d2vresOEDIw9kfxQHUY4DB8MTJE++5fPWZW//sCSFkT8MAgBBC1qS/enI4f25w9Z3hWtgNm34s+TxFkrI4QO5wiAE09C0k7YThV46+PWoyoPJAZVpxgGZ0YNy7dmj2Xpw9e2sfOiGE7HkYABBCyJo889CnZLzQX3k3PNV8yo4Al626Rgxg9vnmFQfo6Hu36ksMsE+KA2BWjwl6T//Gz9/cJ00IIfsJsmyLBwAAGOBJREFUBgCEEPJGNOMTo5mXBlffk6306a2yJBVYug5CAk+dx7IpxQHcqi9nEAXhnq7sg+IAvdHBUbPYx/z6P19CCNmHMAAghJA34rkHH2xGB2ZX3iXaZFUcRXNBBW0pDiAmg4tILWk8LspZHKDEALdfHEAxaI9Ae0/++sdv+mMmhJD9BAMAQgi5Af3x8VH/hdkrnd3AEv8oCoigicdimv5mcYCJIVQxQKXmfWfzTRcHGAyPqi72dG5dHyohhOxjGAAQQsgNeObMrzWj+Znr94r2pzaQpIYnj8TJCp7FATTEADYnHp+E1YbbKA4gC6vzvbb31K8z+58QQm4AAwBCCLkxveGR1blXJxYBgKh7Yb44iwNseXGA/srxpd7SYDxY90dKCCH7FwYAhBByY57+9BmMD8jSW0WDxCzp6ZGQ6xJigJJj49kv7nyzOEDJX/KsnjJ11UrIxKZqQNE2veUZbfv/+IVP3NrnSwgh+woGAIQQsi5kdBRzL89fua9cgalf/zkTFD/EhSyLA5RZsxhAQ98saaoOgXwyYwxQB1QzwyPjmdVm1Lu1T5YQQvYbDAAIIWRdvPCp0/3xwvzy3U076CrtKbhs1TViALPPN684QH5HTNepFf+eKA4g6MnqCcHM01/+pzf+FAkhhDAAIISQ9TMYHVqZe3Xm9Q+gOgNoLeoYwATzZhYHkG4MsA+KA/RWj41nLst44cYfCCGEEAAMAAghZP388OH7m/bA4d5dvXadm03duo4p75tXHCCIaQ1W/d4tDtCoCA5D+s984WfW+ykSQsi+hwEAIYTcBLPNoaXeudnF96/x+3JQZ6YcieP7XK1dEeX1zloWBwj3vnFxgMHKSZVFwezanxghhJAuDAAIIeQm+MHp0834wCHc3YxnLLEHgB3Sg4ncoMkjcbKCZ3EADTGAzYnHJ2G1Ye3iAKJyWNrBc5/h2f+EEHITMAAghJCbYxaHrsu5mcX7qquqa+4KmDwSBy6gc4vozZvmnrDqPaOmm45/e8UBqhjARfkuKA7QXzo5xhUI7X9CCLk5GAAQQsjN8YPTp5vhwuGVNzXtTL4U9s2uQch1CTFAPMsyP8Wd7y0rDlAeviOLA3g2VF0cQNCT8byMerT/CSHkZmEAQAghN83s+ODSzCtzV96XflzHiUCoFD/EhSyLA+QOhxhAQ99CllSMnXRm9YT2r1d12QghhKwPBgCEEHLTPPHQ/c144dDqXc14MCXvf00sBtjG4gAdfe9WfYkBdkNxgFZ0dUF08PznefY/IYTcNAwACCHkVpgdH1qcPTd39X3V1RtHAnUM4Cf9bGJxgDoGcKu+c6JoWZ3QnV8cYDC6o+1fx5j2PyGE3AoMAAgh5FZ44qH70S4MxneJ9m/yVkU5EsezXzavOED6k1rKTZ2OP6UZTM1Xqw31waCTMcDWFQeACpaPiM7Q/ieEkFuDAQAhhNwiPT007J2bv/zem76TxQHgUUFpJtViRRlAiQEEAHqrJzBzBaO5m552QgghABgAEELILfP8Aw/0hvOzK/eIVn+XdmuBTTJ5JE5W8CwOoCEGsDnx+EQVkIPtyT5mXvgffnFdHxIhhJAJGAAQQsit0x8fXp57ee7aewE7jwc3lP8AzBffscUBEGMAF+XbXxxgsHx8qXdxRhfWNcmEEEKmwQCAEEJunWcfflDahcH1e5OWF9/aui5CrkuIAUqOjWe/hJP1J4oDlGYbWRwg9G0nFQdAvz2KtvfEr/Psf0IIuXUYABBCyG3RGx4Zzr00t/iO9cr+iqD4MfVg0BIDrFEcICwg7PXiAL3h0WHvSqPM/ieEkNuCAQAhhNwWLz70YG88v7D0rlt9gMUA21gcIL8jpuvUij8VB4hJ/G986n+VsLR2MwU6fbMYYGpxgP7KSWn7z/76P7vVqSaEEAIwACCEkNtnMDq+NPf87PW33uoD6hjAT/rZxOIA0o0B1lMcAJMFwmwEUw4GRYgBfG9A+dFCgvUWB+iPjoxnLjVjZv8TQsjtwgCAEEJul+c++cDq3TJ77Z3A+jcAdFBsaXGAsJF3lxQH6K+cEO09/zna/4QQcrswACCEkA2gPTDz0pmnBit33fojWBwAHhWUZikU6A0XxoPXaf8TQsiGwACAEEI2gKsfvHTsL04cuPbuW38EiwP4REwUB5gd3jk/OvT8r/+LW59eQgghBgMAQgjZCOTs/PlTevBkf/UIopq9KVgcwPoWo6BmPHdy9dRMe/CW5pQQQkgXBgCEELJBzCwMV15eWHzfemuBTWfiSJy4QXa9xQHgzfZAcYDB8psuNS8vjA/cxqwSQggpMAAghJCN4aVf+iVZmR8NTzaj+VvdCpyYOBInXbmJ4gDVWZy7uzhAOzO32G/H8p3P/+TtzCkhhBCHAQAhhGwYbbugM+fmrr7vtp80cSRONwYw+3zzigN09P1axQG6B4NucHGAwcqdKweW+6v8XytCCNkw+FcqIYRsGBce+pXeeH4wvlO0f9sPq2OArS8O4Fb9GxcHUEzEADaC2y4OIG0zOzoCmf3Rb/53tz2fhBBCMgwACCFkI+npweHg5YUr79mIh2k4Emc/FgcYDO9cHVzqt3MbMZmEEEIyDAAIIWQjefnM6d5ofmbl3lsuCVaxn4sDQAarR0T7T3/2n27ATBJCCDEYABBCyAbTGx9Znnt+fvHtG/CsfVwcoD88MRxc6o1p/xNCyAbDAIAQQjaYlx76teHdMnv9rRvzuB1eHKCKATayOMBg5fjSW649y+JfhBCy0TAAIISQjUcP9s998smZ5Ts26nnATi0OUB6+kcUBeqNDzz/yX8eH2w2aQEIIIQUGAIQQsvEsfvDSkW8cm11898Y9Mij+fVAcYGb11Mk/efuVj7y0cRNICCEkwwCAEEI2ATk798KpweKdzWhh4x5qMcBeLw4gOttvjy68fApyduNmjxBCSIYBACGEbAq91YOrB19YWNyQ80CdOgbYiuIAdQywJcUBZpfeNOpdbJTbfwkhZFNgAEAIIZvCS5//pV47O3PtLtGN/ZtWsaXFAdKffJPxphcHEJXZ9ljTDp555BMbOm+EEEIyDAAIIWSz6A0PrRx4Ye7qOzf4uXu6OMBg+U3L/Qt9nd/gSSOEEGIwACCEkM3ipc/8atPOzq+8dYOfu6eLA/RGx7TtP/XIP9/gSSOEEGIwACCEkE1kMD66PPfs7NJdG/zcPVocYLB6bDzzWtPS/ieEkE2EAQAhhGwiL33ywX57eP762zbh2SFd59aLA5RmO6E4wGD1VCODFx/5l5swXYQQQjIMAAghZHPpt4f6/SMbeh6oExT/LRYHCAsI210cQNo5zA8bndmEiSKEEFJgAEAIIZtL08yt4NX5DT4P1KkPBp0SA9gKwOYVB8jvCDHA1OIAfmWN4gBzS3e3q0MMWP2XEEI2FwYAhBCyubxw+nSzujC3dFc8XmdDqWOArS8OYI+7QXGAKQXCbAQCtDK7cqS3uvDC6dObM0uEEEIyDAAIIWTT6Y8OLS08O7/4tk17g2KXFwcYrLxpefZCf8ziX4QQsukwACCEkE3nxU//6rwenll66ya+Y5cXB5hdPbH81qWnP/ffbuIUEUIIAcAAgBBCtoZBe/DEzFx/9dhmvWA3Fwforx56/tOPjg8z+58QQrYCBgCEELIVLPT6r+vF+cV3b+I7dm1xgMHKPcf+n3uvfPjcJk4OIYQQgwEAIYRsBY+dPq3DA3PDU6L9zXxPSNe59eIA8GZbUBxAxv32+uHZF++AnN3MmSGEEJJhAEAIIVtEvz2wNPfc/OI7N/k9t18cIMYAm14cYHbpbiyc1+HsJk8LIYSQDAMAQgjZIp5/+JdX79a56/ds/qt2U3GAwfhED4NXvvDfbPKcEEIIyTAAIISQrUMP9l566EeDlRNb8CrEGGCnFgcYrJ5cnXmlp5tRJpkQQsh0GAAQQsjWcfVDF4998/D89Xdtydt2QXGA+ZU3NaMDz3/6l7ZkQgghhAAMAAghZEuRswsvnTywckK0tyWv29HFAWQ80NVDvTHtf0II2VIYABBCyJYyM164Ovfc7NV3bMXLdnZxgNmle0azr2LM7b+EELKlMAAghJAt5elP/euVy3fMLb95i963g4sD9Icnmnbwwmf/xZZMBCGEkAwDAEII2Wp06fC5J9/cXz26ZS8EdlxxgMHK8dW5l5uW+T+EELLVMAAghJCtZvHS4SNveXL+2tZsBU7suOIAsyt399uDLzzyr7ZqBgghhGQYABBCyJZz9hPzg8Hs9VNxF+3ms4OKA0g76ONorz24NSMnhBASYQBACCHbQH94YOngM/PX37q1r90pxQFmlu5Zac41mNva4RNCCAEYABBCyLbwwmf+dV8PzV57y5a/eUcUB5hbOdmMB88+xO2/hBCyDTAAIISQ7aHXHuzPLDSj+a1+8XYXB+itHFqaf7HP4/8JIWSbYABACCHbQ9MbrODcwrV3bvWLt7s4wMzqm5vxgece+e+3cMyEEEIKDAAIIWR7eOH06d5obm75rm1493YWB2hmh8d6Y27/JYSQbYMBACGEbBv90aFrC08PVu7YjpdvT3GAwdKblmdf7LdbnvhECCHEYABACCHbxgsPP9BrD80vvn2b3r8NxQFmVk7J8vxzn/6X2zRkQggh6G93BwghZF/THx1pZEHQKNrteH8600dFABVLBBKVJPglHRqUj/gUiOYYIP2gClEpsUO6kh8jFjmk8z8FgmY8aK7MymxvO0ZKCCEkwxUAQgjZThpZWBk8M7f4tu3rwuYVB9BOcYCZ5TcPj7wmK/SeCCFkO2EAQAgh28lLD/zrZvXI3PI929qLLSoOMLN8x+pbhy9++Ze3a5yEEELAAIAQQrad3vhAOz7SjGe2sxObXxygt3roxU/9/+3dW48UZ34H4Dp1VVcfBhuGgwHjOFptNk4iJytFSi59u8pq5RPeXYwxq1xF+RB8k2i18k20+Qi58H2UK8eJ1yfWwIBZ21mYme7p7jrkghkMeAwYM/NWk+e5GCE0dP3qBvWv3rfe/3v1eN9vDYC7KQAAgbVtvyou9Sc/CBtir4cD5NOTT/37ofW/vr7ftwbA3RQAgMA+f+uVfLFaTEIMBLjTng4HiKKiWi3XVqP4wn7dDwC7UwAAwkurcVEfTxfB98fs1XCA3uzItP9Z1gxC3BQAd1EAAMLL2vGk/7ty409DB4n2aDhAf+tYVg8uvf2zgDcGwC0KAEB4F8+/FNdJEWYk8DfdfTDoLh1gZwXgroNBv9kBbo8ZiIrFSlYNA90OAHdRAAA6IauHk9Gnvdlq6CC3PM7hAPnkmc3yUtYUge4FgLsoAACdcOXcL9NqXE6fDx3ktsc2HKBYHI1mw4vnXw55NwDsMI4RoCuyaiWtytAp7hBvf7vffrS//dZv1Ma3Hvrv/O32uN9bKwXtrfeCdxYM4rhJ6hvDpJgHvhcAdlgBAOiKtCqnw0/yaejzQG97HMMBiumz9YGr7SzomDMA7qAAAHTFlXNvpPVKufVs6CB3+N7DAYqt1aw5cP2fXguRHoBd2AIE0CFZPU6a4c7umo64/R5wtLMOEN063Cfe2f8TRdH2H+L4601AbZS0vaZaTZJJuPAA3MsKAECHJM1wWn6UT4+HDnKPRxwO0N98rhr8vjX/C6BLFACADrny5qvJfFxOu7QLaNujDAfIq6O9ZnTtVz8JFxuAe9kCBNAtaTWOq0HHdgHdsj3WK7512M/2aZ/x9qFA8fY7ATsdIErrIovGTTsLmhmAe1kBAOiWuBrMRh8XkxOhg+zqOwwH6G2cmma/TyLzvwC6RQEA6JZr51/NmnHRqbOA7hTHUXy7A7Q74353OkAU7XSAuL9YjZvxZ2f+IWBYAL7JFiCAzkmbURKVndwFFN3e8d+2bXz7CKC7BoRFURQlTa8pDqWV838AOscKAEDnJFE5zTu7C+ihhgMUk+eq6JM2c/4PQOcoAACds/aL19L5KJ92tQBE0dd7/bd/ttGdR4XGcT5ZzebltdPO/wHoHFuAALoorUZp09VdQNvar8eBfZ0zbuM2qbM0Kpt6ETggALuxAgDQRWlTTocfF9NjoYPc3+7DAfKtZ7f6V5KoFzoeALtQAAC6aO3c6awaFbOToYM80N0dII6iqC0nx3tbK5fPnQ6dDYBd2AIE0FFpNU4WZfRU6BwP1ka3Dwdq4zjKihvDqpiHTgXA7qwAAHRUsign4496s8OhgzyEO4YDFJsn1g9dzGZ56EwA7E4BAOiotfNvpNUw3+jqRLA73Xr+H0dt2/ZmR+N29Ok/vxo6EwC7UwAAuqs6nvarQ6FTPJyd4QDp/GBSD0OnAeBbKQAA3dWsRFfOfpAtDoQO8pDaYuvY1ujDpC5DJwHgWykAAN21/uKXK++W/clzoYM8rHzrZFYPr75t/w9AdykAAB0WX8ivHM9mS7ILKIry2VOL43HoFADcjwIA0GlxU87jQ0ldhA7yYOli5crZD+pxZ0cXAxBFCgBAx9XxoM0/zDdPhQ7yYOXk1Pjd/vqLX4YOAsD9KAAAnfbVmz/J67K/OBo6yINli8Ojy8ei+ELoIADcj0nAAF2XNYO0zeMoaaMmdJZvlTRFfz6qUgOAAbrOCgBA16VtvlF+2pscDx3kfvqTUxvDi1ltADBA1ykAAF332Zunk8WoPzsROsj99GZHkmp48fzLoYMA8AC2AAEsgaweJU0/dIr7SRfjJpmFTgHAg1kBAFgCSdOfDD/I5h0dCZxvHZ6MPkyaJTirFAAFAGAJrJ19I637/emzoYPsrrd1IqkHa+dOhw4CwIPZAgSwHNLFatamoVPsLlscjNIqdAoAHooCALAc4qact3ncZm3cra/aSZP38ryuO1pOALiHLUAAy6Fu86r8uJh07iyg/vTUNL2UpgoAwHJQAACWwxdnX80Wo3x+JHSQe/VmR9L56PJpLwAALAcFAGBpLE60yexQ6BT3ymYH0moQOgUAD0sBAFga9Up07a33s0WHDgPtzZ6ejP8nqTs9owCAOykAAEtj48U/rLzbLyYdOgy0Pz2Z1v0rb78eOggAD0sBAFge8YXR5SP5YjV0jq/1qoNF3aE8ADyQAgCwTNKmLOeDKIpDB7kl7qfjtLX/B2CZKAAAy6RX926MP8wnx0IHiaIoyifHbuQfZEkROggA34ECALBMPjn/WlyVxbwbBWB2LFqUn/z8ldBBAPgOTAIGWDL54mDUduLxTVo93UZ16BQAfDcKAMCSSesibfOkyZtkHjBG3GZRM4jjRcAMADyCTjxDAuDhpW2+Mfq4mJ4IG6OYnJiXH0VtL2wMAL4rBQBgyVw8/3JSD3rzwIdv9rYOp/Xg87e8AACwZGwBAlg+8xuro2EbNkPWPN2mTdgMADwCKwAAy6eZDS5/dCStBqECJHUeHxjFiQkAAMtHAQBYPje/Go6ff7+YnAoVoJicmi0+ivt5qAAAPDIFAGAJXXipn5e92eFQ18+3jvTmw7Wf/jRUAAAemQIAsJTiZtAmB5M6wDP4uM2G2cGsGe7/pQH4/hQAgOUUl3V2abDxw/2/crnxw/Xkcp6U+39pAL4/BQBgKV3/5c/Sut9bnEyafV0EiNu0v34qXpSf/NwBoABLSQEAWFZps1Jn1wfrL+znRQc3/2JRXsvmB/bzogA8RgoAwLK6euZ0bzFc2TyeLPZpO35a9VemJ3v1aO386f25IgCPnQIAsMSKxXizvPbUjb+L9+P/8/jAV38/Ka4W1creXwuAvRKHDgDA93L8nXc2qptFr10/9B97eqHxVz9OszrZOrh29uyeXgiAPWUFAGC5rZ05U9089Iff/flg/c/27irl+g8Op0eKesW3f4BlpwAALL3Jl4dXT1491jw/uvGXe/H5g/UflcVf3Uynw8TZ/wBLTwEAWH4XXjqykl0/ee2L12+O//g3j/ezR//74lfv/e3GF5MmP/j+ae/+Aiw97wAAPCnaC4P/KtMv69HlZ9dX/rPKb3zPz0sX4wM3frxerdfrq5MvjkYXXnosMQEISwEAeKI8885vqvRGMTuyVV7eXPnvNq4f4UPiNhncfGHl5nOT4dW0Ga+dOffYcwIQigIA8KQ5+et/rbKbTTYZbh3fyK9vrrzfZJOH/LdJXQzWf5RvHl+UV3vVsJg99ek/vrqnaQHYZwoAwJPp+V//dp5uzrPNdnE0i9fnxfV5ea3q/XHXX84WB/KtZ3pbh3v1cJZ/nlTDdDFe+9Xr+5wZgH2gAAA8yVZ/829JNGvSadP7ok1mB26+UGVVk8zaqGnaKI2TpM7jqFgfvRc3eT47lNRl2uaXz3nZF+CJpQAA/H/xJ//y2yZpmrhukkUT1VEUxW2aRL24TeMou/TWK6EDAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsNT+D4anIGJ6MOAyAAAAAElFTkSuQmCC" height="1024" preserveAspectRatio="xMidYMid meet"/></g></g></svg>"; - const menuIconURI = blockIconURI; - const actualModels = ["gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think"]; - const displayModels = ["Gemini 2.5 - Flash Lite", "Gemini 2.5 - Flash", "Gemini 2.5 - Pro", "Gemini 3 - Flash (Preview)", "Gemini 3 - Pro (Preview)", "Gemini 3 - Deep Thinking"]; - class Gemini { - getInfo() { - return { - id: "gemini", - name: Scratch.translate("Gemini"), - color1: "#0086c9", - menuIconURI, - blockIconURI, - blocks: [ - { - opcode: "generate", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "generate from [contents] and creativity (0-2) of [temp]" - ), - arguments: { - contents: { - type: Scratch.ArgumentType.STRING, - defaultValue: "Tell me about Gemini.", - }, - temp: { - type: Scratch.ArgumentType.NUMBER, - defaultValue: 1, - }, - }, - }, - { - opcode: "getKey", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "current API key" - ), - }, - { - opcode: "getModel", - blockType: Scratch.BlockType.REPORTER, - text: Scratch.translate( - "selected model" - ), - }, - { - opcode: "setKey", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate("set API key to [key]"), - arguments: { - key: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setInstruction", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate({ - default: "set personality to [personality]", - }), - arguments: { - personality: { - type: Scratch.ArgumentType.STRING, - defaultValue: "", - }, - }, - }, - { - opcode: "setModel", - blockType: Scratch.BlockType.COMMAND, - text: Scratch.translate({ - default: "use model [model]", - }), - arguments: { - model: { - type: Scratch.ArgumentType.STRING, - menu: "models", - }, - }, - }, - ], - menus: { - models: displayModels - }, - }; - } - async generate(args) { - const response = await ai.models.generateContent({ - model: getActualModel(modelChoice), - contents: Scratch.Cast.toString(args.contents), - config: { - systemInstruction: instruction, - temperature: Scratch.Cast.toFloat(args.temp), - }, - }); - return response.text; - } - setKey(args) { - key = Scratch.Cast.toString(args.key); - ai = new GoogleGenAI({ apiKey: key }); - } - setInstruction(args) { - instruction = Scratch.cast.toString(args.personality); - } - setModel(args) { - modelChoice = Scratch.Cast.toString(args.model); - } - getKey(args) { - return key; - } - getModel(args) { - return modelChoice; - } - getActualModel(display){ - return actualModels[displayModels.indexOf(display)]; - } +(async function(Scratch) { + "use strict"; + + const menuIconURI = +"data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="65" height="65" viewBox="0 0 65 65" fill="none"><path d="M57.865 29.01q-7.5-3.228-13.126-8.853-5.625-5.626-8.854-13.126a39 39 0 0 1-1.999-5.905A1.485 1.485 0 0 0 32.447.001c-.68 0-1.272.465-1.438 1.125a39 39 0 0 1-2 5.905q-3.228 7.5-8.853 13.126Q14.53 25.782 7.03 29.01a39 39 0 0 1-5.905 2A1.485 1.485 0 0 0 0 32.448c0 .68.465 1.272 1.125 1.438a39 39 0 0 1 5.905 2q7.499 3.228 13.126 8.853 5.626 5.626 8.854 13.126a39 39 0 0 1 1.999 5.905c.166.66.758 1.125 1.438 1.125.681 0 1.273-.465 1.439-1.125a39 39 0 0 1 2-5.905q3.228-7.499 8.853-13.126 5.626-5.625 13.126-8.854a39 39 0 0 1 5.905-1.999 1.485 1.485 0 0 0 1.125-1.438c0-.681-.465-1.273-1.125-1.439a39 39 0 0 1-5.905-2" fill="#fff"/><mask id="b" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="65" height="65"><path d="M32.447 0c.68 0 1.273.465 1.439 1.125a39 39 0 0 0 1.999 5.905q3.23 7.5 8.854 13.125 5.627 5.626 13.125 8.855a39 39 0 0 0 5.906 1.999c.66.166 1.124.758 1.124 1.438s-.464 1.273-1.125 1.439a39 39 0 0 0-5.905 1.999q-7.5 3.23-13.125 8.854-5.625 5.627-8.854 13.125a39 39 0 0 0-2 5.906 1.485 1.485 0 0 1-1.438 1.124c-.68 0-1.272-.464-1.438-1.125a39 39 0 0 0-2-5.905q-3.227-7.5-8.854-13.125-5.625-5.625-13.125-8.854a39 39 0 0 0-5.905-2A1.485 1.485 0 0 1 0 32.448c0-.68.465-1.272 1.125-1.438a39 39 0 0 0 5.905-2q7.5-3.228 13.125-8.854 5.626-5.624 8.855-13.125a39 39 0 0 0 1.999-5.905A1.485 1.485 0 0 1 32.447 0" fill="#000"/><path d="M32.447 0c.68 0 1.273.465 1.439 1.125a39 39 0 0 0 1.999 5.905q3.23 7.5 8.854 13.125 5.627 5.626 13.125 8.855a39 39 0 0 0 5.906 1.999c.66.166 1.124.758 1.124 1.438s-.464 1.273-1.125 1.439a39 39 0 0 0-5.905 1.999q-7.5 3.23-13.125 8.854-5.625 5.627-8.854 13.125a39 39 0 0 0-2 5.906 1.485 1.485 0 0 1-1.438 1.124c-.68 0-1.272-.464-1.438-1.125a39 39 0 0 0-2-5.905q-3.227-7.5-8.854-13.125-5.625-5.625-13.125-8.854a39 39 0 0 0-5.905-2A1.485 1.485 0 0 1 0 32.448c0-.68.465-1.272 1.125-1.438a39 39 0 0 0 5.905-2q7.5-3.228 13.125-8.854 5.626-5.624 8.855-13.125a39 39 0 0 0 1.999-5.905A1.485 1.485 0 0 1 32.447 0" fill="url(#a)"/></mask><g mask="url(#b)"><g filter="url(#c)"><ellipse cx="14.407" cy="16.95" rx="14.407" ry="16.95" transform="rotate(19.552 -44.576 -16.496)" fill="#ffe432"/></g><g filter="url(#d)"><ellipse cx="27.433" cy="2.587" rx="18.652" ry="19.062" fill="#fc413d"/></g><g filter="url(#e)"><ellipse cx="18.951" cy="57.386" rx="19.493" ry="25.253" transform="rotate(-2.799 18.951 57.386)" fill="#00b95c"/></g><g filter="url(#f)"><ellipse cx="18.951" cy="57.386" rx="19.493" ry="25.253" transform="rotate(-2.799 18.951 57.386)" fill="#00b95c"/></g><g filter="url(#g)"><ellipse cx="20.02" cy="56.211" rx="19.107" ry="21.035" transform="rotate(-31.318 20.02 56.211)" fill="#00b95c"/></g><g filter="url(#h)"><ellipse cx="67.391" cy="25.327" rx="18.346" ry="17.667" fill="#3186ff"/></g><g filter="url(#i)"><ellipse cx="21.222" cy="22.384" rx="21.222" ry="22.384" transform="rotate(37.252 9.752 -8.009)" fill="#fbbc04"/></g><g filter="url(#j)"><ellipse cx="24.469" cy="22.604" rx="24.469" ry="22.604" transform="rotate(34.51 19.587 64.852)" fill="#3186ff"/></g><g filter="url(#k)"><path d="M54.984-2.336c2.833 3.852-.808 11.34-8.131 16.727s-15.557 6.631-18.39 2.78c-2.833-3.853.807-11.342 8.13-16.728s15.558-6.631 18.39-2.78" fill="#749bff"/></g><g filter="url(#l)"><ellipse cx="19.902" cy="3.356" rx="27.971" ry="17.388" transform="rotate(-42.848 19.902 3.356)" fill="#fc413d"/></g><g filter="url(#m)"><ellipse cx="13.583" cy="46.75" rx="14.989" ry="8.717" transform="rotate(35.592 13.583 46.75)" fill="#ffee48"/></g></g><defs><filter id="c" x="-19.824" y="13.152" width="39.274" height="43.217" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="2.46" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="d" x="-15.001" y="-40.257" width="84.868" height="85.688" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="11.891" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="e" x="-20.776" y="11.927" width="79.454" height="90.917" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="f" x="-20.776" y="11.927" width="79.454" height="90.917" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="g" x="-19.845" y="15.459" width="79.731" height="81.505" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="10.109" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="h" x="29.832" y="-11.552" width="75.117" height="73.758" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="9.606" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="i" x="-38.583" y="-16.253" width="78.135" height="78.758" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="8.706" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="j" x="8.107" y="-5.966" width="78.877" height="77.539" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="7.775" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="k" x="13.587" y="-18.488" width="56.272" height="51.81" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="6.957" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="l" x="-15.526" y="-31.297" width="70.856" height="69.306" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="5.876" result="effect1_foregroundBlur_10859_4895"/></filter><filter id="m" x="-14.168" y="20.964" width="55.502" height="51.571" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="7.273" result="effect1_foregroundBlur_10859_4895"/></filter><linearGradient id="a" x1="18.447" y1="43.42" x2="52.153" y2="15.004" gradientUnits="userSpaceOnUse"><stop stop-color="#4893fc"/><stop offset=".27" stop-color="#4893fc"/><stop offset=".777" stop-color="#969dff"/><stop offset="1" stop-color="#bd99fe"/></linearGradient></defs></svg>"; + + // typically extensions should work offline, but this is a online AI extension, + // so all offline rules break for this... + const { GoogleGenAI } = await import("https://cdn.jsdelivr.net/npm/@google/genai@1.33.0/+esm") + + const displayModels = [ + "Gemini 2.5 - Flash Lite", "Gemini 2.5 - Flash", "Gemini 2.5 - Pro", + "Gemini 3 - Flash (Preview)", "Gemini 3 - Pro (Preview)", "Gemini 3 - Deep Thinking" + ]; + const actualModels = [ + "gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro", + "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3-deep-think" + ]; + + let ai = new GoogleGenAI({ apiKey: "" }); + let instruction = ""; + let key = "No API key has been set."; + let modelChoice = "gemini-2.5-flash"; + + class smolderdevGeminiAPI { + getInfo() { + return { + id: "smolderdevGeminiAPI", + name: Scratch.translate("Gemini API"), + color1: "#0086c9", + menuIconURI, + blockIconURI: menuIconURI, + blocks: [ + { + opcode: "generate", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate( + "generate with prompt [contents] and creativity (0-2) [temp]" + ), + arguments: { + contents: { + type: Scratch.ArgumentType.STRING, + defaultValue: "Tell me about Gemini.", + }, + temp: { + type: Scratch.ArgumentType.NUMBER, + defaultValue: 1, + }, + }, + }, + { + opcode: "getKey", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate("current API key"), + }, + { + opcode: "getModel", + blockType: Scratch.BlockType.REPORTER, + text: Scratch.translate("selected model"), + }, + { + opcode: "setKey", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set API key to [key]"), + arguments: { + key: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setInstruction", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("set personality to [personality]"), + arguments: { + personality: { + type: Scratch.ArgumentType.STRING, + defaultValue: "", + }, + }, + }, + { + opcode: "setModel", + blockType: Scratch.BlockType.COMMAND, + text: Scratch.translate("use model [model]"), + arguments: { + model: { + type: Scratch.ArgumentType.STRING, + menu: "models", + }, + }, + }, + ], + menus: { + models: displayModels + }, + }; + } + + async generate(args) { + const response = await ai.models.generateContent({ + model: getActualModel(modelChoice), + contents: Scratch.Cast.toString(args.contents), + config: { + systemInstruction: instruction, + temperature: Math.max(0, Math.min(2, Scratch.Cast.toNumber(args.temp))), + }, + }); + return response.text; + } + + setKey(args) { + key = Scratch.Cast.toString(args.key); + ai = new GoogleGenAI({ + apiKey: key + }); + } + + setInstruction(args) { + instruction = Scratch.cast.toString(args.personality); + } + + setModel(args) { + modelChoice = Scratch.Cast.toString(args.model); + } + + getKey() { + return key; + } + + getModel() { + return modelChoice; + } + + getActualModel(display) { + return actualModels[displayModels.indexOf(display)]; } - Scratch.extensions.register(new Gemini()); + } + Scratch.extensions.register(new smolderdevGeminiAPI()); })(Scratch); From 52934b84c54a05d11e9e76fd9b67b21573031842 Mon Sep 17 00:00:00 2001 From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com> Date: Mon, 29 Dec 2025 14:04:20 -0800 Subject: [PATCH 19/20] change name --- extension-code/{Gemini.js => Gemini-API.js} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename extension-code/{Gemini.js => Gemini-API.js} (100%) diff --git a/extension-code/Gemini.js b/extension-code/Gemini-API.js similarity index 100% rename from extension-code/Gemini.js rename to extension-code/Gemini-API.js From f7afbbec83919af75f429ae5d7999cf8e63a8cf8 Mon Sep 17 00:00:00 2001 From: SharkPool <139097378+SharkPool-SP@users.noreply.github.com> Date: Mon, 29 Dec 2025 14:04:56 -0800 Subject: [PATCH 20/20] Update Gemini URL in Extension-Keys.json --- Gallery Files/Extension-Keys.json | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Gallery Files/Extension-Keys.json b/Gallery Files/Extension-Keys.json index 27c4824d..c0c21544 100644 --- a/Gallery Files/Extension-Keys.json +++ b/Gallery Files/Extension-Keys.json @@ -596,9 +596,10 @@ "Gemini": { "desc": "Send requests to Gemini API.", "creator": "cs3203402", - "url": "extension-code/Gemini.js", + "url": "extension-code/Gemini-API.js", "banner": "extension-thumb/Gemini.svg", - "tags": ["all", "fetching"] + "tags": ["all", "fetching"], + "date": "Released: 12/29/2025" }, "Example": { "desc": "",