diff --git a/README.md b/README.md index 2362a66d..acddbce1 100644 --- a/README.md +++ b/README.md @@ -599,3 +599,17 @@ let sequencer = ImageSequencer() // also for wasm mode i.e. default mode let sequencer = ImageSequencer({useWasm:false}) //for non-wasm mode ``` + +## Experimental GIF processing support + +ImageSequencer currently can process GIFs but only for most of the modules. Every frame of the GIF is manipulated sequentially (parallel processing would be preferable in the future). +The final frames are then converted back to a GIF but in the process, the time duration of each frame is lost and defaults to `0.1s`. + +Modules that do not work: +1. ColorBar (Will get fixed upon fixing overlay as this is a meta module which uses overlay) +2. FisheyeGL +4. Overlay +5. Text Overlay (Almost fixed) +6. Blend +7. Histogram +8. WebGL Distort \ No newline at end of file diff --git a/examples/demo.js b/examples/demo.js index cce2a12b..af2a9edc 100644 --- a/examples/demo.js +++ b/examples/demo.js @@ -270,23 +270,26 @@ window.onload = function () { * @param {string} imageDataURL - The data URL for the image. */ function savePDF(imageDataURL) { - sequencer.getImageDimensions(imageDataURL, function(dimensions) { - // Get the dimensions of the image. - let pageWidth = dimensions.width; - let pageHeight = dimensions.height; + sequencer.getImageDimensions(imageDataURL, function(dimensions, isGIF) { + if (!isGIF) { + // Get the dimensions of the image. + let pageWidth = dimensions.width; + let pageHeight = dimensions.height; - // Create a new pdf with the same dimensions as the image. - const pdf = new jsPDF({ - orientation: pageHeight > pageWidth ? 'portrait' : 'landscape', - unit: 'px', - format: [pageHeight, pageWidth] - }); + // Create a new pdf with the same dimensions as the image. + const pdf = new jsPDF({ + orientation: pageHeight > pageWidth ? 'portrait' : 'landscape', + unit: 'px', + format: [pageHeight, pageWidth] + }); - // Add the image to the pdf with dimensions equal to the internal dimensions of the page. - pdf.addImage(imageDataURL, 0, 0, pdf.internal.pageSize.getWidth(), pdf.internal.pageSize.getHeight()); + // Add the image to the pdf with dimensions equal to the internal dimensions of the page. + pdf.addImage(imageDataURL, 0, 0, pdf.internal.pageSize.getWidth(), pdf.internal.pageSize.getHeight()); - // Save the pdf with the filename specified here: - pdf.save('index.pdf'); + // Save the pdf with the filename specified here: + pdf.save('index.pdf'); + } + else console.log('GIFs cannot be converted to PDF'); }); } diff --git a/examples/lib/defaultHtmlStepUi.js b/examples/lib/defaultHtmlStepUi.js index b4067a9d..a10467b5 100644 --- a/examples/lib/defaultHtmlStepUi.js +++ b/examples/lib/defaultHtmlStepUi.js @@ -356,14 +356,14 @@ function DefaultHtmlStepUi(_sequencer, options) { else $step('.wasm-tooltip').fadeOut(); } /** - * @description Updates Dimension of the image + * @description Updates Dimension of the image * @param {Object} step - Current Step * @returns {void} - * + * */ function updateDimensions(step){ - _sequencer.getImageDimensions(step.imgElement.src, function (dim) { - step.ui.querySelector('.' + step.name).attributes['data-original-title'].value = `

Image Width: ${dim.width}
Image Height: ${dim.height}

`; + _sequencer.getImageDimensions(step.imgElement.src, function (dim, isGIF) { + step.ui.querySelector('.' + step.name).attributes['data-original-title'].value = `

Image Width: ${dim.width}
Image Height: ${dim.height}
${isGIF ? `Frames: ${dim.frames}` : ''}

`; }); } diff --git a/package-lock.json b/package-lock.json index fb5e8024..5c2dd7e2 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10364,7 +10364,7 @@ }, "load-json-file": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", + "resolved": "http://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", "requires": { "graceful-fs": "^4.1.2", @@ -12466,6 +12466,14 @@ "version": "2.1.2", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "ws": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.1.tgz", + "integrity": "sha512-GIyAXC2cB7LjvpgMt9EKS2ldqr0MTrORaleiOno6TweZ6r3TKtoFQWay/2PceJ3RuBasOHzXNn5Lrw1X0bEjqA==", + "requires": { + "async-limiter": "~1.0.0" + } } } }, @@ -15849,14 +15857,6 @@ "signal-exit": "^3.0.2" } }, - "ws": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.1.tgz", - "integrity": "sha512-GIyAXC2cB7LjvpgMt9EKS2ldqr0MTrORaleiOno6TweZ6r3TKtoFQWay/2PceJ3RuBasOHzXNn5Lrw1X0bEjqA==", - "requires": { - "async-limiter": "~1.0.0" - } - }, "xhr-write-stream": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/xhr-write-stream/-/xhr-write-stream-0.1.2.tgz", diff --git a/package.json b/package.json index aa0aff8d..8afc0eb9 100644 --- a/package.json +++ b/package.json @@ -5,7 +5,7 @@ "main": "src/ImageSequencer.js", "scripts": { "debug": "TEST=true node ./index.js -i ./examples/images/monarch.png -s invert", - "test": "TEST=true istanbul cover tape test/core/*.js test/core/ui/user-interface.js test/core/modules/*.js | tap-spec; node test/core/sequencer/benchmark.js; grunt tests; cat ./output/core-tests.js | tape-run --render=\"tap-spec\"", + "test": "TEST=true istanbul cover tape test/core/*.js test/core/ui/user-interface.js test/core/modules/*.js | tap-spec; node test/core/sequencer/benchmark.js | tap-spec; node test/core/gifs/gif-test.js | tap-spec; grunt tests; cat ./output/core-tests.js | tape-run --render=\"tap-spec\"", "test-ui": "node node_modules/jasmine/bin/jasmine test/ui/spec/*.js", "test-ui-2": "node ./node_modules/.bin/jest", "setup": "npm i && npm i -g grunt grunt-cli && grunt build $$ npm rebuild --build-from-source", diff --git a/src/Modules.js b/src/Modules.js index 68bd2a16..3c34de70 100644 --- a/src/Modules.js +++ b/src/Modules.js @@ -30,7 +30,8 @@ module.exports = { 'grid-overlay': require('./modules/GridOverlay'), 'import-image': require('./modules/ImportImage'), 'minify-image': require('./modules/MinifyImage'), - 'invert': require('image-sequencer-invert'), + // 'invert': require('image-sequencer-invert'), + 'invert': require('./modules/Invert'), 'ndvi': require('./modules/Ndvi'), 'ndvi-colormap': require('./modules/NdviColormap'), 'noise-reduction': require('./modules/NoiseReduction'), diff --git a/src/modules/AddQR/Module.js b/src/modules/AddQR/Module.js index d5948611..d592fe1e 100644 --- a/src/modules/AddQR/Module.js +++ b/src/modules/AddQR/Module.js @@ -1,3 +1,4 @@ +const _ = require('lodash'); module.exports = function AddQR(options, UI) { var defaults = require('./../../util/getDefaults.js')(require('./info.json')); @@ -13,34 +14,34 @@ module.exports = function AddQR(options, UI) { var step = this; - return getPixels(input.src, function(err, oldPixels) { - function changePixel(r, g, b, a) { - return [r, g, b, a]; - } + function changePixel(r, g, b, a) { + return [r, g, b, a]; + } - function extraManipulation(pixels, generateOutput) { - if (err) { - console.log(err); - return; - } - require('./QR')(options, pixels, oldPixels, generateOutput); - } + function extraManipulation(pixels, setRenderState, generateOutput) { + const oldPixels = _.cloneDeep(pixels); + setRenderState(false); // Prevent rendering of final output image until extraManipulation completes. - function output(image, datauri, mimetype, wasmSuccess) { - step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; - } - - return require('../_nomodule/PixelManipulation.js')(input, { - output: output, - ui: options.step.ui, - changePixel: changePixel, - extraManipulation: extraManipulation, - format: input.format, - image: options.image, - inBrowser: options.inBrowser, - callback: callback, - useWasm:options.useWasm + require('./QR')(options, pixels, oldPixels, () => { + setRenderState(true); // Allow rendering in the callback. + generateOutput(); }); + } + + function output(image, datauri, mimetype, wasmSuccess) { + step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; + } + + return require('../_nomodule/PixelManipulation.js')(input, { + output: output, + ui: options.step.ui, + changePixel: changePixel, + extraManipulation: extraManipulation, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + callback: callback, + useWasm:options.useWasm }); } diff --git a/src/modules/AddQR/QR.js b/src/modules/AddQR/QR.js index b23e3ef7..d856c2b3 100644 --- a/src/modules/AddQR/QR.js +++ b/src/modules/AddQR/QR.js @@ -1,44 +1,37 @@ -module.exports = exports = function (options, pixels, oldPixels, callback) { - const pixelSetter = require('../../util/pixelSetter.js'); +const pixelSetter = require('../../util/pixelSetter.js'), + getPixels = require('get-pixels'), + QRCode = require('qrcode'); +module.exports = exports = function (options, pixels, oldPixels, cb) { - var QRCode = require('qrcode'); - QRCode.toDataURL(options.qrCodeString, function (err, url) { - var getPixels = require('get-pixels'); + QRCode.toDataURL(options.qrCodeString, {width: options.size, scale: 1}, function (error, url) { getPixels(url, function (err, qrPixels) { if (err) { - console.log('Bad image path', image); + console.log('get-pixels error: ', err); } - var imagejs = require('imagejs'); - var bitmap = new imagejs.Bitmap({ width: qrPixels.shape[0], height: qrPixels.shape[1] }); - bitmap._data.data = qrPixels.data; - var resized = bitmap.resize({ - width: options.size, height: options.size, - algorithm: 'bicubicInterpolation' - }); - - qrPixels.data = resized._data.data; - qrPixels.shape = [options.size, options.size, 4]; - qrPixels.stride[1] = 4 * options.size; - - var width = oldPixels.shape[0], + const width = oldPixels.shape[0], height = oldPixels.shape[1]; - var xe = width - options.size, + + const xe = width - options.size, // Starting pixel coordinates ye = height - options.size; - for (var m = 0; m < width; m++) { - for (var n = 0; n < height; n++) { - if (m >= xe && n >= ye) { - pixelSetter(m, n, [qrPixels.get(m - xe, n - ye, 0), qrPixels.get(m - xe, n - ye, 1), qrPixels.get(m - xe, n - ye, 2), qrPixels.get(m - xe, n - ye, 3)], pixels); - } - - else { - pixelSetter(m, n, [oldPixels.get(m, n, 0), oldPixels.get(m, n, 1), oldPixels.get(m, n, 2), oldPixels.get(m, n, 3)], pixels); - } - + + for (let x = xe; x < width; x++) { + for (let y = ye; y < height; y++) { + pixelSetter( + x, + y, + [ + qrPixels.get(x - xe, y - ye, 0), + qrPixels.get(x - xe, y - ye, 1), + qrPixels.get(x - xe, y - ye, 2), + qrPixels.get(x - xe, y - ye, 3) + ], + pixels + ); } } - callback(); + if(cb) cb(); }); }); }; diff --git a/src/modules/Average/Module.js b/src/modules/Average/Module.js index 4f19751b..577b3a71 100755 --- a/src/modules/Average/Module.js +++ b/src/modules/Average/Module.js @@ -54,6 +54,7 @@ module.exports = function Average(options, UI) { return require('../_nomodule/PixelManipulation.js')(input, { output: output, ui: options.step.ui, + inBrowser: options.inBrowser, extraManipulation: extraManipulation, format: input.format, image: options.image, diff --git a/src/modules/BlobAnalysis/BlobAnalysis.js b/src/modules/BlobAnalysis/BlobAnalysis.js index 1e79b9e7..7620ecee 100644 --- a/src/modules/BlobAnalysis/BlobAnalysis.js +++ b/src/modules/BlobAnalysis/BlobAnalysis.js @@ -1,17 +1,10 @@ -module.exports = function(pixels, options, priorStep){ - - var $ = require('jquery'); // To make Blob-analysis work in Node - - var img = $(priorStep.imgElement); - if(Object.keys(img).length === 0){ - img = $(priorStep.options.step.imgElement); - } - +module.exports = function(pixels){ var canvas = document.createElement('canvas'); canvas.width = pixels.shape[0]; canvas.height = pixels.shape[1]; var ctx = canvas.getContext('2d'); - ctx.drawImage(img[0], 0, 0); + ctx.putImageData(new ImageData(new Uint8ClampedArray(pixels.data), pixels.shape[0], pixels.shape[1]), 0, 0); + let imgData = ctx.getImageData(0, 0, canvas.width, canvas.height); diff --git a/src/modules/BlobAnalysis/Module.js b/src/modules/BlobAnalysis/Module.js index ebacb3c5..efd9367d 100644 --- a/src/modules/BlobAnalysis/Module.js +++ b/src/modules/BlobAnalysis/Module.js @@ -10,11 +10,9 @@ module.exports = function BlobAnalysis(options, UI){ var step = this; - var priorStep = this.getStep(-1); // Get the previous step to process it - function extraManipulation(pixels){ - pixels = require('./BlobAnalysis')(pixels, options, priorStep); + pixels = require('./BlobAnalysis')(pixels); return pixels; } diff --git a/src/modules/Blur/Blur.js b/src/modules/Blur/Blur.js index 0797e198..83bd5be4 100755 --- a/src/modules/Blur/Blur.js +++ b/src/modules/Blur/Blur.js @@ -1,3 +1,31 @@ +// Generates a 5x5 Gaussian kernel +function kernelGenerator(sigma = 1) { + + let kernel = [], + sum = 0; + + if (sigma == 0) sigma += 0.05; + + const s = 2 * Math.pow(sigma, 2); + + for (let y = -2; y <= 2; y++) { + kernel.push([]); + for (let x = -2; x <= 2; x++) { + let r = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); + kernel[y + 2].push(Math.exp(-(r / s))); + sum += kernel[y + 2][x + 2]; + } + } + + for (let x = 0; x < 5; x++){ + for (let y = 0; y < 5; y++){ + kernel[y][x] = (kernel[y][x] / sum); + } + } + + return kernel; +} + module.exports = exports = function(pixels, blur) { const pixelSetter = require('../../util/pixelSetter.js'); @@ -34,32 +62,4 @@ module.exports = exports = function(pixels, blur) { } return pixels; - - // Generates a 5x5 Gaussian kernel. - function kernelGenerator(sigma = 1) { - - let kernel = [], - sum = 0; - - if (sigma == 0) sigma += 0.05; - - const s = 2 * Math.pow(sigma, 2); - - for (let y = -2; y <= 2; y++) { - kernel.push([]); - for (let x = -2; x <= 2; x++) { - let r = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); - kernel[y + 2].push(Math.exp(-(r / s))); - sum += kernel[y + 2][x + 2]; - } - } - - for (let x = 0; x < 5; x++){ - for (let y = 0; y < 5; y++){ - kernel[y][x] = (kernel[y][x] / sum); - } - } - - return kernel; - } }; \ No newline at end of file diff --git a/src/modules/Blur/Module.js b/src/modules/Blur/Module.js index b470aae0..93f5fa28 100755 --- a/src/modules/Blur/Module.js +++ b/src/modules/Blur/Module.js @@ -27,6 +27,7 @@ module.exports = function Blur(options, UI) { return require('../_nomodule/PixelManipulation.js')(input, { output: output, ui: options.step.ui, + inBrowser: options.inBrowser, extraManipulation: extraManipulation, format: input.format, image: options.image, diff --git a/src/modules/Colorbar/Module.js b/src/modules/Colorbar/Module.js index 3d15f624..3765b03e 100644 --- a/src/modules/Colorbar/Module.js +++ b/src/modules/Colorbar/Module.js @@ -5,8 +5,8 @@ module.exports = require('../../util/createMetaModule.js')( return [ { 'name': 'gradient', 'options': {} }, { 'name': 'colormap', 'options': { colormap: options.colormap || defaults.colormap } }, - { 'name': 'crop', 'options': { 'y': 0, 'h': options.h || defaults.h } }, - { 'name': 'overlay', 'options': { 'x': options.x || defaults.x, 'y': options.y || defaults.y, 'offset': -4 } } + { 'name': 'crop', 'options': { 'y': 0, 'w': '100%', 'h': options.h || defaults.h } }, + { 'name': 'overlay', 'options': { 'x': options.x || defaults.h, 'y': options.y || defaults.y, 'offset': -4 } } ]; }, { infoJson: require('./info.json') diff --git a/src/modules/Contrast/Module.js b/src/modules/Contrast/Module.js index 2040f0ee..440d1066 100644 --- a/src/modules/Contrast/Module.js +++ b/src/modules/Contrast/Module.js @@ -31,6 +31,7 @@ module.exports = function Contrast(options, UI) { format: input.format, image: options.image, callback: callback, + inBrowser: options.inBrowser, useWasm:options.useWasm }); diff --git a/src/modules/Convolution/Module.js b/src/modules/Convolution/Module.js index 1c98ec62..003ef007 100644 --- a/src/modules/Convolution/Module.js +++ b/src/modules/Convolution/Module.js @@ -29,6 +29,7 @@ module.exports = function Convolution(options, UI) { extraManipulation: extraManipulation, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/Crop/Crop.js b/src/modules/Crop/Crop.js index 494e4243..b749dab5 100644 --- a/src/modules/Crop/Crop.js +++ b/src/modules/Crop/Crop.js @@ -1,61 +1,71 @@ -module.exports = function Crop(input, options, callback) { +const ndarray = require('ndarray'), + pixelSetter = require('../../util/pixelSetter'), + parseCornerCoordinateInputs = require('../../util/ParseInputCoordinates'); + +module.exports = function Crop(pixels, options, cb) { var defaults = require('./../../util/getDefaults.js')(require('./info.json')); - var getPixels = require('get-pixels'), - savePixels = require('save-pixels'); + options.x = options.x || defaults.x; + options.y = options.y || defaults.y; - options.x = parseInt(options.x) || defaults.x; - options.y = parseInt(options.y) || defaults.y; + options.w = options.w || defaults.w; + options.h = options.h || defaults.h; - getPixels(input.src, function(err, pixels){ - options.w = parseInt(options.w) || Math.floor(pixels.shape[0]); - options.h = parseInt(options.h) || Math.floor(pixels.shape[1]); - options.backgroundColor = options.backgroundColor || defaults.backgroundColor; - var ox = options.x; - var oy = options.y; - var w = options.w; - var h = options.h; - var iw = pixels.shape[0]; //Width of Original Image - var ih = pixels.shape[1]; //Height of Original Image - var backgroundArray = []; - backgroundColor = options.backgroundColor.substring(options.backgroundColor.indexOf('(') + 1, options.backgroundColor.length - 1); // extract only the values from rgba(_,_,_,_) - backgroundColor = backgroundColor.split(','); - for(var i = 0; i < w ; i++){ - backgroundArray = backgroundArray.concat([backgroundColor[0], backgroundColor[1], backgroundColor[2], backgroundColor[3]]); - } - // var newarray = new Uint8Array(4*w*h); - var array = []; - for (var n = oy; n < oy + h; n++) { - var offsetValue = 4 * w * n; - if(n < ih){ - var start = n * 4 * iw + ox * 4; - var end = n * 4 * iw + ox * 4 + 4 * w; - var pushArray = Array.from(pixels.data.slice(start, end )); - array.push.apply(array, pushArray); - } else { - array.push.apply(array, backgroundArray); - } - } - - var newarray = Uint8Array.from(array); - pixels.data = newarray; - pixels.shape = [w, h, 4]; - pixels.stride[1] = 4 * w; + options.backgroundColor = options.backgroundColor || defaults.backgroundColor; - options.format = input.format; + const bg = options.backgroundColor.replace('rgba', '').replace('(', '').replace(')', '').split(','); - var chunks = []; - var totalLength = 0; - var r = savePixels(pixels, options.format); + let iw = pixels.shape[0], // Width of Original Image + ih = pixels.shape[1], // Height of Original Image + offsetX, + offsetY, + w, + h; - r.on('data', function(chunk){ - totalLength += chunk.length; - chunks.push(chunk); + // Parse the inputs + parseCornerCoordinateInputs({iw, ih}, + { + x: { valInp: options.x, type: 'horizontal' }, + y: { valInp: options.y, type: 'vertical' }, + w: { valInp: options.w, type: 'horizontal' }, + h: { valInp: options.h, type: 'vertical' }, + }, function (opt, coord) { + offsetX = Math.floor(coord.x.valInp); + offsetY = Math.floor(coord.y.valInp); + w = Math.floor(coord.w.valInp); + h = Math.floor(coord.h.valInp); }); - r.on('end', function(){ - var data = Buffer.concat(chunks, totalLength).toString('base64'); - var datauri = 'data:image/' + options.format + ';base64,' + data; - callback(datauri, options.format); - }); - }); + const newPixels = new ndarray([], [w, h, 4]); + + for (let x = 0; x < w; x++) { + for (let y = 0; y < h; y++) { + pixelSetter(x, y, bg, newPixels); // Set the background color + } + } + + for ( + let x = 0; + x < Math.min(w - 1, offsetX + iw - 1); + x++ + ) { + for ( + let y = 0; + y < Math.min(h - 1, offsetY + ih - 1); + y++ + ) { + const inputImgX = x + offsetX, + inputImgY = y + offsetY; + + pixelSetter(x, y, [ + pixels.get(inputImgX, inputImgY, 0), + pixels.get(inputImgX, inputImgY, 1), + pixels.get(inputImgX, inputImgY, 2), + pixels.get(inputImgX, inputImgY, 3) + ], newPixels); // Set the background color + } + } + + if (cb) cb(); + + return newPixels; }; diff --git a/src/modules/Crop/Module.js b/src/modules/Crop/Module.js index e74eb855..1d4de3d8 100644 --- a/src/modules/Crop/Module.js +++ b/src/modules/Crop/Module.js @@ -1,3 +1,4 @@ +const pixelManipulation = require('../_nomodule/PixelManipulation'); /* * Image Cropping module * Usage: @@ -26,54 +27,35 @@ module.exports = function CropModule(options, UI) { var step = this; - // save the input image; - // TODO: this should be moved to module API to persist the input image - options.step.input = input.src; - var parseCornerCoordinateInputs = require('../../util/ParseInputCoordinates'); + function extraManipulation(pixels) { + const newPixels = require('./Crop')(pixels, options, function() { + // We should do this via event/listener: + if (ui && ui.hide) ui.hide(); - //parse the inputs - parseCornerCoordinateInputs(options, { - src: input.src, - x: { valInp: options.x, type: 'horizontal' }, - y: { valInp: options.y, type: 'vertical' }, - w: { valInp: options.w, type: 'horizontal' }, - h: { valInp: options.h, type: 'vertical' }, - }, function (options, coord) { - options.x = parseInt(coord.x.valInp); - options.y = parseInt(coord.y.valInp); - options.w = coord.w.valInp; - options.h = coord.h.valInp; + // Start custom UI setup (draggable UI) + // Only once we have an input image + if (setupComplete === false && options.step.inBrowser && !options.noUI) { + setupComplete = true; + ui.setup(); + } + }); + return newPixels; + } + + function output(image, datauri, mimetype, wasmSuccess) { + step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; + } + + return pixelManipulation(input, { + output: output, + ui: options.step.ui, + extraManipulation: extraManipulation, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + callback: callback, + useWasm:options.useWasm }); - - require('./Crop')(input, options, function (out, format) { - - // This output is accessible to Image Sequencer - step.output = { - src: out, - format: format - }; - - // This output is accessible to the UI - options.step.output = out; - - // Tell the UI that the step has been drawn - UI.onComplete(options.step); - - // we should do this via event/listener: - if (ui && ui.hide) ui.hide(); - - // start custom UI setup (draggable UI) - // only once we have an input image - if (setupComplete === false && options.step.inBrowser && !options.noUI) { - setupComplete = true; - ui.setup(); - } - - // Tell Image Sequencer that step has been drawn - callback(); - - }); - } return { diff --git a/src/modules/Crop/info.json b/src/modules/Crop/info.json index 1ae84206..0b37a0cb 100644 --- a/src/modules/Crop/info.json +++ b/src/modules/Crop/info.json @@ -16,12 +16,12 @@ "w": { "type": "string", "desc": "Width of crop", - "default": "(50%)" + "default": "50%" }, "h": { "type": "string", "desc": "Height of crop", - "default": "(50%)" + "default": "50%" }, "backgroundColor": { "type": "text", diff --git a/src/modules/DecodeQr/Module.js b/src/modules/DecodeQr/Module.js index e0415342..f7a9ee8f 100644 --- a/src/modules/DecodeQr/Module.js +++ b/src/modules/DecodeQr/Module.js @@ -37,6 +37,7 @@ module.exports = function DoNothing(options, UI) { ui: options.step.ui, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/Dither/Module.js b/src/modules/Dither/Module.js index 33333f0d..06176d4a 100644 --- a/src/modules/Dither/Module.js +++ b/src/modules/Dither/Module.js @@ -25,6 +25,7 @@ module.exports = function Dither(options, UI) { extraManipulation: extraManipulation, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/DrawRectangle/DrawRectangle.js b/src/modules/DrawRectangle/DrawRectangle.js index ee9bf114..069cba05 100644 --- a/src/modules/DrawRectangle/DrawRectangle.js +++ b/src/modules/DrawRectangle/DrawRectangle.js @@ -4,22 +4,24 @@ module.exports = exports = function(pixels, options){ options.startingX = options.startingX || defaults.startingX; options.startingY = options.startingY || defaults.startingY; + var ox = Number(options.startingX), oy = Number(options.startingY), iw = pixels.shape[0], ih = pixels.shape[1], thickness = Number(options.thickness) || defaults.thickness, - ex = options.endX = Number(options.endX) - thickness || iw - 1, - ey = options.endY = Number(options.endY) - thickness || ih - 1, + ex = Number(options.endX) - thickness || iw - 1, + ey = Number(options.endY) - thickness || ih - 1, color = options.color || defaults.color; - color = color.substring(color.indexOf('(') + 1, color.length - 1); // extract only the values from rgba(_,_,_,_) + + color = color.substring(color.indexOf('(') + 1, color.length - 1); // Extract only the values from rgba(_,_,_,_) color = color.split(','); var drawSide = function(startX, startY, endX, endY){ for (var n = startX; n <= endX + thickness; n++){ for (var k = startY; k <= endY + thickness; k++){ - pixelSetter(n, k, [color[0], color[1], color[2]], pixels); //to remove 4th channel - pixels.set(n, k, 3, color[3]); + pixelSetter(n, k, [color[0], color[1], color[2]], pixels); // To remove 4th channel - pixels.set(n, k, 3, color[3]); } } }; diff --git a/src/modules/DrawRectangle/Module.js b/src/modules/DrawRectangle/Module.js index 6f2cc2f6..a103a272 100644 --- a/src/modules/DrawRectangle/Module.js +++ b/src/modules/DrawRectangle/Module.js @@ -30,6 +30,7 @@ module.exports = function DrawRectangle(options, UI) { extraManipulation: extraManipulation, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/EdgeDetect/Module.js b/src/modules/EdgeDetect/Module.js index a90f6764..b9065211 100644 --- a/src/modules/EdgeDetect/Module.js +++ b/src/modules/EdgeDetect/Module.js @@ -1,4 +1,5 @@ -/** +const Blur = require('../Blur/Blur'); +/* * Detect Edges in an Image * Uses Canny method for the same * Read more: https://en.wikipedia.org/wiki/Canny_edge_detector @@ -21,42 +22,31 @@ module.exports = function edgeDetect(options, UI) { var step = this; - // Blur the image. - const internalSequencer = ImageSequencer({ inBrowser: false, ui: false }); - return internalSequencer.loadImage(input.src, function() { - internalSequencer.importJSON([{ 'name': 'blur', 'options': { blur: options.blur } }]); // Blurs the image before detecting edges to reduce noise. - return internalSequencer.run(function onCallback(internalOutput) { - require('get-pixels')(internalOutput, function(err, blurPixels) { - if (err) { - return; - } + // Makes the image greyscale + function changePixel(r, g, b, a) { + return [(r + g + b) / 3, (r + g + b) / 3, (r + g + b) / 3, a]; + } - // Extra Manipulation function used as an enveloper for applying gaussian blur and Convolution. - function changePixel(r, g, b, a) { - return [(r + g + b) / 3, (r + g + b) / 3, (r + g + b) / 3, a]; - } + // Extra Manipulation function used as an enveloper for applying gaussian blur and Convolution + function extraManipulation(pixels) { + const blurPixels = Blur(pixels, options.blur); + return require('./EdgeUtils')(blurPixels, options.highThresholdRatio, options.lowThresholdRatio, options.hysteresis); + } - function extraManipulation() { - return require('./EdgeUtils')(blurPixels, options.highThresholdRatio, options.lowThresholdRatio, options.hysteresis); - } + function output(image, datauri, mimetype, wasmSuccess) { + step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; + } - function output(image, datauri, mimetype, wasmSuccess) { - step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; - } - - return require('../_nomodule/PixelManipulation.js')(input, { - output: output, - ui: options.step.ui, - changePixel: changePixel, - extraManipulation: extraManipulation, - format: input.format, - image: options.image, - inBrowser: options.inBrowser, - callback: callback, - useWasm: options.useWasm - }); - }); - }); + return require('../_nomodule/PixelManipulation.js')(input, { + output: output, + ui: options.step.ui, + changePixel: changePixel, + extraManipulation: extraManipulation, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + callback: callback, + useWasm: options.useWasm }); } diff --git a/src/modules/FlipImage/Module.js b/src/modules/FlipImage/Module.js index c8b48946..b661e4aa 100644 --- a/src/modules/FlipImage/Module.js +++ b/src/modules/FlipImage/Module.js @@ -1,3 +1,4 @@ +const _ = require('lodash'); /* * Flip the image on vertical/horizontal axis. */ @@ -5,8 +6,7 @@ module.exports = function FlipImage(options, UI) { var defaults = require('./../../util/getDefaults.js')(require('./info.json')); options.Axis = options.Axis || defaults.Axis; - var output, - getPixels = require('get-pixels'); + let output; function draw(input, callback, progressObj) { @@ -15,35 +15,30 @@ module.exports = function FlipImage(options, UI) { var step = this; - return getPixels(input.src, function(err, oldPixels) { - function changePixel(r, g, b, a) { - return [r, g, b, a]; - } - function extraManipulation(pixels) { - if (err) { - console.log(err); - return; - } - return require('./flipImage')(oldPixels, pixels, options.Axis); - } - - function output(image, datauri, mimetype, wasmSuccess) { - step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; - } + function changePixel(r, g, b, a) { + return [r, g, b, a]; + } + function extraManipulation(pixels) { + const oldPixels = _.cloneDeep(pixels); - return require('../_nomodule/PixelManipulation.js')(input, { - output: output, - ui: options.step.ui, - changePixel: changePixel, - extraManipulation: extraManipulation, - format: input.format, - image: options.image, - inBrowser: options.inBrowser, - callback: callback, - useWasm:options.useWasm - }); + return require('./flipImage')(oldPixels, pixels, options.Axis); + } + + function output(image, datauri, mimetype, wasmSuccess) { + step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; + } + + return require('../_nomodule/PixelManipulation.js')(input, { + output: output, + ui: options.step.ui, + changePixel: changePixel, + extraManipulation: extraManipulation, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + callback: callback, + useWasm:options.useWasm }); - } return { diff --git a/src/modules/Gradient/Module.js b/src/modules/Gradient/Module.js index 5ddd4559..ab7788c2 100644 --- a/src/modules/Gradient/Module.js +++ b/src/modules/Gradient/Module.js @@ -1,52 +1,41 @@ -module.exports = function Invert(options, UI) { - const pixelSetter = require('../../util/pixelSetter.js'); +const pixelSetter = require('../../util/pixelSetter.js'), + pixelManipulation = require('../_nomodule/PixelManipulation'); + +module.exports = function Gradient(options, UI) { var output; // The function which is called on every draw. function draw(input, callback) { - - var getPixels = require('get-pixels'); - var savePixels = require('save-pixels'); - var step = this; - getPixels(input.src, function(err, pixels) { - - if (err) { - console.log('Bad Image path'); - return; - } - - var width = pixels.shape[0]; - - for (var i = 0; i < pixels.shape[0]; i++) { - for (var j = 0; j < pixels.shape[1]; j++) { - let val = (i / width) * 255; - pixelSetter(i, j, [val, val, val, 255], pixels); - - } - } - var chunks = []; - var totalLength = 0; - var r = savePixels(pixels, input.format, { quality: 100 }); - - r.on('data', function(chunk) { - totalLength += chunk.length; - chunks.push(chunk); - }); - - r.on('end', function() { - var data = Buffer.concat(chunks, totalLength).toString('base64'); - var datauri = 'data:image/' + input.format + ';base64,' + data; - output(input.image, datauri, input.format); - callback(); - }); - }); - function output(image, datauri, mimetype, wasmSuccess) { step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; } + + function extraManipulation(pixels) { + const [w, h] = pixels.shape; + for (var i = 0; i < w; i++) { + for (var j = 0; j < h; j++) { + let val = (i / w) * 255; + + pixelSetter(i, j, [val, val, val, 255], pixels); + } + } + + return pixels; + } + + return pixelManipulation(input, { + output, + extraManipulation, + callback, + format: input.format, + image: options.image, + inBrowser: options.inBrowser, + useWasm:options.useWasm + }); + } return { diff --git a/src/modules/Invert/Module.js b/src/modules/Invert/Module.js index ca0b9702..74541194 100644 --- a/src/modules/Invert/Module.js +++ b/src/modules/Invert/Module.js @@ -1,3 +1,4 @@ +const pixelManipulation = require('../_nomodule/PixelManipulation'); /* * Invert the image */ @@ -21,7 +22,7 @@ function Invert(options, UI) { step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; } - return input.pixelManipulation({ + return pixelManipulation(input, { output: output, changePixel: changePixel, format: input.format, @@ -40,10 +41,4 @@ function Invert(options, UI) { UI: UI }; } -var info = { - 'name': 'invert', - 'description': 'Inverts the image.', - 'inputs': { - } -}; -module.exports = [Invert, info]; +module.exports = Invert; diff --git a/src/modules/Invert/index.js b/src/modules/Invert/index.js new file mode 100644 index 00000000..71549002 --- /dev/null +++ b/src/modules/Invert/index.js @@ -0,0 +1,4 @@ +module.exports = [ + require('./Module'), + require('./info.json') +]; \ No newline at end of file diff --git a/src/modules/NoiseReduction/Module.js b/src/modules/NoiseReduction/Module.js index f2e03487..ee4892d1 100644 --- a/src/modules/NoiseReduction/Module.js +++ b/src/modules/NoiseReduction/Module.js @@ -25,6 +25,7 @@ module.exports = function NoiseReduction(options, UI) { extraManipulation: extraManipulation, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/Overlay/Module.js b/src/modules/Overlay/Module.js index 957afb99..1631eb01 100644 --- a/src/modules/Overlay/Module.js +++ b/src/modules/Overlay/Module.js @@ -18,16 +18,6 @@ module.exports = function Dynamic(options, UI, util) { var parseCornerCoordinateInputs = require('../../util/ParseInputCoordinates'); - //parse the inputs - parseCornerCoordinateInputs(options, { - src: input.src, - x: { valInp: options.x, type: 'horizontal' }, - y: { valInp: options.y, type: 'vertical' }, - }, function(options, input) { - options.x = parseInt(input.x.valInp); - options.y = parseInt(input.y.valInp); - }); - // save the pixels of the base image var baseStepImage = this.getStep(options.offset).image; var baseStepOutput = this.getOutput(options.offset); @@ -35,6 +25,19 @@ module.exports = function Dynamic(options, UI, util) { var getPixels = require('get-pixels'); getPixels(input.src, function(err, pixels) { + // parse the inputs + parseCornerCoordinateInputs({ + iw: pixels.shape[0], + ih: pixels.shape[1] + }, + { + x: { valInp: options.x, type: 'horizontal' }, + y: { valInp: options.y, type: 'vertical' }, + }, function(opt, input) { + options.x = parseInt(input.x.valInp); + options.y = parseInt(input.y.valInp); + }); + options.secondImagePixels = pixels; function changePixel(r1, g1, b1, a1, x, y) { diff --git a/src/modules/ReplaceColor/Module.js b/src/modules/ReplaceColor/Module.js index 9d011e62..0a4d0398 100644 --- a/src/modules/ReplaceColor/Module.js +++ b/src/modules/ReplaceColor/Module.js @@ -29,6 +29,7 @@ module.exports = function ReplaceColor(options, UI) { extraManipulation: extraManipulation, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/Resize/Module.js b/src/modules/Resize/Module.js index 46f39180..b097ae0f 100644 --- a/src/modules/Resize/Module.js +++ b/src/modules/Resize/Module.js @@ -1,59 +1,71 @@ +const imagejs = require('imagejs'), + pixelSetter = require('../../util/pixelSetter'), + ndarray = require('ndarray'); /* * Resize the image by given percentage value */ module.exports = function Resize(options, UI) { - var output; + let output; function draw(input, callback, progressObj) { - var defaults = require('./../../util/getDefaults.js')(require('./info.json')); + const defaults = require('./../../util/getDefaults.js')(require('./info.json')); options.resize = options.resize || defaults.resize; progressObj.stop(true); progressObj.overrideFlag = true; - var step = this; - - var imagejs = require('imagejs'); - - function changePixel(r, g, b, a) { - return [r, g, b, a]; - } + const step = this; function extraManipulation(pixels) { - // value above 100% scales up, and below 100% scales down - var resize_value = parseInt(options.resize.slice(0, -1)); + // Value above 100% scales up, and below 100% scales down + const resize_value = parseInt(options.resize.slice(0, -1)); - var new_width, - new_height; - - new_width = Math.round(pixels.shape[0] * (resize_value / 100)); - new_height = Math.round(pixels.shape[1] * (resize_value / 100)); - - var bitmap = new imagejs.Bitmap({ width: pixels.shape[0], height: pixels.shape[1] }); - bitmap._data.data = pixels.data; + if (resize_value == 100) return pixels; - var resized = bitmap.resize({ - width: new_width, height: new_height, + const new_width = Math.round(pixels.shape[0] * (resize_value / 100)), + new_height = Math.round(pixels.shape[1] * (resize_value / 100)); + + const bitmap = new imagejs.Bitmap({ width: pixels.shape[0], height: pixels.shape[1] }); + + for (let x = 0; x < pixels.shape[0]; x++) { + for (let y = 0; y < pixels.shape[1]; y++) { + let r = pixels.get(x, y, 0), + g = pixels.get(x, y, 1), + b = pixels.get(x, y, 2), + a = pixels.get(x, y, 3); + + bitmap.setPixel(x, y, r, g, b, a); + } + } + + const resized = bitmap.resize({ + width: new_width, + height: new_height, algorithm: 'bicubicInterpolation' }); - pixels.data = resized._data.data; - pixels.shape = [new_width, new_height, 4]; - pixels.stride[1] = 4 * new_width; + const newPix = new ndarray([], [new_width, new_height, 4]); - return pixels; + for (let x = 0; x < new_width; x++) { + for (let y = 0; y < new_height; y++) { + const {r, g, b, a} = resized.getPixel(x, y); + pixelSetter(x, y, [r, g, b, a], newPix); + } + } + + return newPix; } function output(image, datauri, mimetype, wasmSuccess) { step.output = { src: datauri, format: mimetype, wasmSuccess, useWasm: options.useWasm }; } + return require('../_nomodule/PixelManipulation.js')(input, { output: output, ui: options.step.ui, - changePixel: changePixel, extraManipulation: extraManipulation, format: input.format, image: options.image, diff --git a/src/modules/Rotate/Module.js b/src/modules/Rotate/Module.js index 010e8e5f..235a5f41 100644 --- a/src/modules/Rotate/Module.js +++ b/src/modules/Rotate/Module.js @@ -3,34 +3,57 @@ */ module.exports = function Rotate(options, UI) { - var output; + let output; function draw(input, callback, progressObj) { - var defaults = require('./../../util/getDefaults.js')(require('./info.json')); + const defaults = require('./../../util/getDefaults.js')(require('./info.json')); options.rotate = options.rotate || defaults.rotate; progressObj.stop(true); progressObj.overrideFlag = true; - var step = this; - - var imagejs = require('imagejs'); + const step = this; function changePixel(r, g, b, a) { return [r, g, b, a]; } function extraManipulation(pixels) { - var rotate_value = (options.rotate) % 360; - var radians = (Math.PI) * rotate_value / 180; - var width = pixels.shape[0]; - var height = pixels.shape[1]; - var cos = Math.cos(radians); - var sin = Math.sin(radians); - //final dimensions after rotation - var pixels2 = require('ndarray')(new Uint8Array(4 * (Math.floor(Math.abs(width * cos) + Math.abs(height * sin) + 5) * (Math.floor(Math.abs(width * sin) + Math.abs(height * cos)) + 5))).fill(0), [Math.floor(Math.abs(width * cos) + Math.abs(height * sin)) + 5, Math.floor(Math.abs(width * sin) + Math.abs(height * cos)) + 4, 4]); - pixels = require('./Rotate')(pixels, pixels2, options, rotate_value, width, height, cos, sin); + const rotate_value = (options.rotate) % 360; + radians = (Math.PI) * rotate_value / 180, + width = pixels.shape[0], + height = pixels.shape[1], + cos = Math.cos(radians), + sin = Math.sin(radians); + // Final dimensions after rotation + + const finalPixels = require('ndarray')( + new Uint8Array( + 4 * + ( + Math.floor( + Math.abs(width * cos) + + Math.abs(height * sin) + + 5 + ) * + ( + Math.floor( + Math.abs(width * sin) + + Math.abs(height * cos) + ) + + 5 + ) + ) + ).fill(255), + [ + Math.floor(Math.abs(width * cos) + Math.abs(height * sin)) + 5, + Math.floor(Math.abs(width * sin) + Math.abs(height * cos)) + 4, + 4 + ] + ); + + pixels = require('./Rotate')(pixels, finalPixels, rotate_value, width, height, cos, sin); return pixels; } diff --git a/src/modules/Rotate/Rotate.js b/src/modules/Rotate/Rotate.js index 06f246fd..a5f16863 100644 --- a/src/modules/Rotate/Rotate.js +++ b/src/modules/Rotate/Rotate.js @@ -1,38 +1,81 @@ -module.exports = function Rotate(pixels, pixels2, options, rotate_value, width, height, cos, sin){ - var imagejs = require('imagejs'); - var height_half = Math.floor(height / 2); - var width_half = Math.floor(width / 2); - var dimension = width + height; +const imagejs = require('imagejs'), + ndarray = require('ndarray'), + pixelSetter = require('../../util/pixelSetter'); - if (rotate_value % 360 == 0) - return pixels; - function copyPixel(x1, y1, x2, y2,pixel_set,pixel_get){ - pixel_set.set(x1, y1, 0, pixel_get.get(x2, y2, 0)); - pixel_set.set(x1, y1, 1, pixel_get.get(x2, y2, 1)); - pixel_set.set(x1, y1, 2, pixel_get.get(x2, y2, 2)); - pixel_set.set(x1, y1, 3, pixel_get.get(x2, y2, 3)); +module.exports = function Rotate(pixels, finalPixels, rotate_value, width, height, cos, sin){ + const height_half = Math.floor(height / 2), + width_half = Math.floor(width / 2); + dimension = width + height; + + if (rotate_value % 360 == 0) return pixels; + + function copyPixel(x1, y1, x2, y2, finalPix, initPix) { + finalPix.set(x1, y1, 0, initPix.get(x2, y2, 0)); + finalPix.set(x1, y1, 1, initPix.get(x2, y2, 1)); + finalPix.set(x1, y1, 2, initPix.get(x2, y2, 2)); + finalPix.set(x1, y1, 3, initPix.get(x2, y2, 3)); } - pixels1 = require('ndarray')(new Uint8Array(4 * dimension * dimension).fill(0), [dimension, dimension, 4]); - //copying all the pixels from image to pixels1 - for (var n = 0; n < pixels.shape[0]; n++){ - for (var m = 0; m < pixels.shape[1]; m++){ - copyPixel(n + height_half, m + width_half, n, m,pixels1,pixels); + const intermediatePixels = new ndarray( + new Uint8Array(4 * dimension * dimension).fill(255), + [dimension, dimension, 4] + ); // Intermediate ndarray of pixels with a greater size to prevent clipping. + + // Copying all the pixels from image to intermediatePixels + for (let x = 0; x < pixels.shape[0]; x++){ + for (let y = 0; y < pixels.shape[1]; y++){ + copyPixel(x + height_half, y + width_half, x, y, intermediatePixels, pixels); } } - //rotating pixels1 - var bitmap = new imagejs.Bitmap({ width: pixels1.shape[0], height: pixels1.shape[1] }); - bitmap._data.data = pixels1.data; - var rotated = bitmap.rotate({ + // Rotating intermediatePixels + const bitmap = new imagejs.Bitmap({ width: intermediatePixels.shape[0], height: intermediatePixels.shape[1] }); + + for (let x = 0; x < intermediatePixels.shape[0]; x++) { + for (let y = 0; y < intermediatePixels.shape[1]; y++) { + let r = intermediatePixels.get(x, y, 0), + g = intermediatePixels.get(x, y, 1), + b = intermediatePixels.get(x, y, 2), + a = intermediatePixels.get(x, y, 3); + + bitmap.setPixel(x, y, r, g, b, a); + } + } + + const rotated = bitmap.rotate({ degrees: rotate_value, }); - pixels1.data = rotated._data.data; - //cropping extra whitespace - for (var n = 0; n < pixels2.shape[0]; n++){ - for (var m = 0; m < pixels2.shape[1]; m++){ - copyPixel(n, m, n + Math.floor(dimension / 2 - Math.abs(width * cos / 2) - Math.abs(height * sin / 2)) - 1, m + Math.floor(dimension / 2 - Math.abs(height * cos / 2) - Math.abs(width * sin / 2)) - 1,pixels2,pixels1); + + for (let x = 0; x < intermediatePixels.shape[0]; x++) { + for (let y = 0; y < intermediatePixels.shape[1]; y++) { + const {r, g, b, a} = rotated.getPixel(x, y); + pixelSetter(x, y, [r, g, b, a], intermediatePixels); } } - return pixels2; + + // Cropping extra whitespace + for (let x = 0; x < finalPixels.shape[0]; x++){ + for (let y = 0; y < finalPixels.shape[1]; y++){ + copyPixel( + x, + y, + x + + Math.floor( + dimension / 2 - + Math.abs(width * cos / 2) - + Math.abs(height * sin / 2) + ) - 1, + y + + Math.floor( + dimension / 2 - + Math.abs(height * cos / 2) - + Math.abs(width * sin / 2) + ) - 1, + finalPixels, + intermediatePixels + ); + } + } + + return finalPixels; }; diff --git a/src/modules/TextOverlay/Module.js b/src/modules/TextOverlay/Module.js index 8589110a..db171aae 100644 --- a/src/modules/TextOverlay/Module.js +++ b/src/modules/TextOverlay/Module.js @@ -7,11 +7,9 @@ module.exports = function TextOverlay(options, UI) { var step = this; - var priorStep = this.getStep(-1); // get the previous step to add text onto it. - function extraManipulation(pixels) { //if (options.step.inBrowser) - pixels = require('./TextOverlay')(pixels, options, priorStep); + pixels = require('./TextOverlay')(pixels, options); return pixels; } diff --git a/src/modules/TextOverlay/TextOverlay.js b/src/modules/TextOverlay/TextOverlay.js index 1a248cdb..a66de987 100644 --- a/src/modules/TextOverlay/TextOverlay.js +++ b/src/modules/TextOverlay/TextOverlay.js @@ -1,7 +1,4 @@ -module.exports = exports = function(pixels, options, priorstep){ - - var $ = require('jquery'); // to make text-overlay work for node.js - +module.exports = exports = function(pixels, options){ var defaults = require('./../../util/getDefaults.js')(require('./info.json')); options.text = options.text || defaults.text; @@ -11,20 +8,18 @@ module.exports = exports = function(pixels, options, priorstep){ options.color = options.color || defaults.color; options.size = options.size || defaults.size; - var img = $(priorstep.imgElement); - if(Object.keys(img).length === 0){ - img = $(priorstep.options.step.imgElement); - } var canvas = document.createElement('canvas'); canvas.width = pixels.shape[0]; //img.width(); canvas.height = pixels.shape[1]; //img.height(); var ctx = canvas.getContext('2d'); - ctx.drawImage(img[0], 0, 0); + + ctx.putImageData(new ImageData(new Uint8ClampedArray(pixels.data), pixels.shape[0], pixels.shape[1]), 0, 0); + ctx.fillStyle = options.color; ctx.font = options.size + 'px ' + options.font; ctx.fillText(options.text, options.x, options.y); var myImageData = ctx.getImageData(0, 0, canvas.width, canvas.height); - pixels.data = myImageData.data; + pixels.data = new Uint8Array(myImageData.data); return pixels; }; \ No newline at end of file diff --git a/src/modules/Threshold/Module.js b/src/modules/Threshold/Module.js index cf9cb1ec..4aa29f49 100644 --- a/src/modules/Threshold/Module.js +++ b/src/modules/Threshold/Module.js @@ -34,6 +34,7 @@ module.exports = function ImageThreshold(options, UI) { extraManipulation: extraManipulation, format: input.format, image: options.image, + inBrowser: options.inBrowser, callback: callback, useWasm:options.useWasm }); diff --git a/src/modules/_nomodule/PixelManipulation.js b/src/modules/_nomodule/PixelManipulation.js index af69ccc4..9731fe07 100644 --- a/src/modules/_nomodule/PixelManipulation.js +++ b/src/modules/_nomodule/PixelManipulation.js @@ -1,3 +1,10 @@ +const pixelSetter = require('../../util/pixelSetter.js'), + getPixels = require('get-pixels'), + savePixels = require('save-pixels'), + ndarray = require('ndarray'), + gifshot = require('gifshot'), + fs = require('fs'), + path = require('path'); /* * General purpose per-pixel manipulation * accepting a changePixel() method to remix a pixel's channels @@ -13,9 +20,24 @@ module.exports = function PixelManipulation(image, options) { // To handle the case where pixelmanipulation is called on the input object itself // like input.pixelManipulation(options) - - const pixelSetter = require('../../util/pixelSetter.js'); - let wasmSuccess; // Whether wasm succeded or failed + + const isGIF = image.src.includes('image/gif'); + let numFrames = 1, // Number of frames: 1 for a still image + frames = [], // Ndarray of pixels of each frame + perFrameShape, // Width, Height and color chanels of each frame + wasmSuccess, // Whether wasm succeded or failed + renderableFrames, // To block rendering in async modules + resolvedFrames = 0; // Number of WASM promises resolved. + + /** + * @description Sets the render state of the current frame. True -> Renderable and False -> Not Renderable. + * @param {Boolean} state Render state of the frame + * @returns {Number} Total number of renderable frames. + */ + function setRenderState(state) { + renderableFrames += state ? 1 : -1; + return renderableFrames; + } if (arguments.length <= 1) { options = image; @@ -24,146 +46,278 @@ module.exports = function PixelManipulation(image, options) { options = options || {}; - const getPixels = require('get-pixels'), - savePixels = require('save-pixels'); + /** + * @description Returns the DataURI of an image from its pixels + * @param {"ndarray"} pix pixels ndarray of pixels of the image. + * @param {String} format Format/MimeType of the image input. + * @returns {Promise} Promise with DataURI as parameter in the callback. + */ + const getDataUri = (pix, format) => { + return new Promise(resolve => { + let chunks = [], + totalLength = 0; + + let r = savePixels(pix, format, { + quality: 100 + }); + + r.on('data', function (chunk) { + totalLength += chunk.length; + chunks.push(chunk); + }); + + r.on('end', function () { + let data = Buffer.concat(chunks, totalLength).toString('base64'); + let datauri = 'data:image/' + format + ';base64,' + data; + + resolve(datauri); + }); + }); + }; getPixels(image.src, function (err, pixels) { if (err) { - console.log('Bad image path', image); + console.log('get-pixels error: ', err); return; } - if (options.getNeighbourPixel) { - options.getNeighbourPixel.fun = function getNeighborPixel(distX, distY) { - return options.getNeighbourPixel(pixels, x, y, distX, distY); - }; - } + // There may be a more efficient means to encode an image object, + // but node modules and their documentation are essentially arcane on this point. + function generateOutput() { + if (!(renderableFrames < numFrames) && !(resolvedFrames < numFrames)) { - // Iterate through pixels - // TODO: this could possibly be more efficient; see - // https://github.com/p-v-o-s/infragram-js/blob/master/public/infragram.js#L173-L181 - - - if (options.preProcess) pixels = options.preProcess(pixels); // Allow for preprocessing of pixels. - - function extraOperation() { - var res; - if (options.extraManipulation) res = options.extraManipulation(pixels, generateOutput); // extraManipulation is used to manipulate each pixel individually. - // There may be a more efficient means to encode an image object, - // but node modules and their documentation are essentially arcane on this point. - function generateOutput() { - var chunks = []; - var totalLength = 0; - - var r = savePixels(pixels, options.format, { - quality: 100 - }); - - r.on('data', function (chunk) { - totalLength += chunk.length; - chunks.push(chunk); - }); - - r.on('end', function () { - var data = Buffer.concat(chunks, totalLength).toString('base64'); - var datauri = 'data:image/' + options.format + ';base64,' + data; - if (options.output) - options.output(options.image, datauri, options.format, wasmSuccess); - if (options.callback) options.callback(); - }); - } - - if (res) { - pixels = res; - generateOutput(); - } else if (!options.extraManipulation) generateOutput(); - } - - if (!options.changePixel) extraOperation(); - - if (options.changePixel) { - - /* Allows for Flexibility - if per pixel manipulation is not required */ - - const imports = { - env: { - consoleLog: console.log, - perform: function (x, y) { - let pixel = options.changePixel( // changePixel function is run over every pixel. - pixels.get(x, y, 0), - pixels.get(x, y, 1), - pixels.get(x, y, 2), - pixels.get(x, y, 3), - x, - y - ); - - pixelSetter(x, y, pixel, pixels); + if (isGIF) { + const dataPromises = []; // Array of all DataURI promises + for (let f = 0; f < numFrames; f++) { + dataPromises.push(getDataUri(frames[f], options.format)); } - } - }; - function perPixelManipulation() { - for (var x = 0; x < pixels.shape[0]; x++) { - for (var y = 0; y < pixels.shape[1]; y++) { - imports.env.perform(x, y); - } - } - } + Promise.all(dataPromises).then(datauris => { + const gifshotOptions = { + images: datauris, + frameDuration: 1, // Duration of each frame in 1/10 seconds. + numFrames: datauris.length, + gifWidth: perFrameShape[0], + gifHeight: perFrameShape[1] + }; + + const gifshotCb = out => { + if (out.error) { + console.log('gifshot error: ', out.errorMsg); + } + + if (options.output) + options.output(options.image, out.image, 'gif', wasmSuccess); + if (options.callback) options.callback(); + }; - const inBrowser = (options.inBrowser) ? 1 : 0; - const test = (process.env.TEST) ? 1 : 0; - - if (options.useWasm) { - if (options.inBrowser) { - - fetch('../../../dist/manipulation.wasm').then(response => - response.arrayBuffer() - ).then(bytes => - WebAssembly.instantiate(bytes, imports) - ).then(results => { - results.instance.exports.manipulatePixel(pixels.shape[0], pixels.shape[1], inBrowser, test); - wasmSuccess = true; - - extraOperation(); - }).catch(err => { - console.log(err); - console.log('WebAssembly acceleration errored; falling back to JavaScript in PixelManipulation'); - wasmSuccess = false; - - perPixelManipulation(); - extraOperation(); + if (options.inBrowser) { + gifshot.createGIF(gifshotOptions, gifshotCb); + } + else { + const nodejsGIFShot = eval('require')('./node-gifshot'); + nodejsGIFShot(gifshotOptions, gifshotCb); + } }); - } else { - try{ - const fs = require('fs'); - const path = require('path'); - const wasmPath = path.join(__dirname, '../../../', 'dist', 'manipulation.wasm'); - const buf = fs.readFileSync(wasmPath); - WebAssembly.instantiate(buf, imports).then(results => { - results.instance.exports.manipulatePixel(pixels.shape[0], pixels.shape[1], inBrowser, test); - wasmSuccess = true; - extraOperation(); + } + else { + getDataUri(frames[0], options.format).then(datauri => { + if (options.output) + options.output(options.image, datauri, options.format, wasmSuccess); + if (options.callback) options.callback(); + }); + } + } + } + + // Get pixels of each frame + if (isGIF) { + const { shape } = pixels; + const [ + noOfFrames, + width, + height, + channels + ] = shape; + + numFrames = noOfFrames; + renderableFrames = noOfFrames; // Total number of renderable frames (mutable) + perFrameShape = [width, height, channels]; // Shape of ndarray of each frame + + const numPixelsInFrame = width * height; + + /* Coalesce the GIF frames (Some GIFs store delta information in between frames + i.e. Only the pixels which change between frames are stored. All these frames need to be + "Coalesced" to get final GIF frame. + More Info: https://www.npmjs.com/package/gif-extract-frames#why + */ + + // Credit for the below code: https://www.npmjs.com/package/gif-extract-frames + // We couldn't use the library because it uses ES6 features which cannot be browserified + for (let i = 0; i < numFrames; ++i) { + if (i > 0) { + const currIndex = pixels.index(i, 0, 0, 0); + const prevIndex = pixels.index(i - 1, 0, 0, 0); + + for (let j = 0; j < numPixelsInFrame; ++j) { + const curr = currIndex + j * channels; + + if (pixels.data[curr + channels - 1] === 0) { + const prev = prevIndex + j * channels; + + for (let k = 0; k < channels; ++k) { + pixels.data[curr + k] = pixels.data[prev + k]; + } + } + } + } + } + + for (let f = 0; f < numFrames; f++) { + frames.push( + new ndarray( + new Uint8Array( + perFrameShape[0] * + perFrameShape[1] * + perFrameShape[2] + ), + perFrameShape + ) + ); + + for (let x = 0; x < width; x++) { + for (let y = 0; y < height; y++) { + for (let c = 0; c < channels; c++) { + frames[f].set(x, y, c, pixels.get(f, x, y, c)); + } + } + } + } + } + else { + frames.push(pixels); + } + + // Manipulate every frame separately + for (let f = 0; f < numFrames; f++) { + let framePix = frames[f]; + + if (options.getNeighbourPixel) { + options.getNeighbourPixel.fun = function getNeighborPixel(distX, distY) { + return options.getNeighbourPixel(framePix, x, y, distX, distY); + }; + } + + // Iterate through framePix + // TODO: this could possibly be more efficient; see + // https://github.com/p-v-o-s/infragram-js/blob/master/public/infragram.js#L173-L181 + + + if (options.preProcess){ + frames[f] = options.preProcess(framePix, setRenderState) || framePix; // Allow for preprocessing of framePix. + perFrameShape = frames[f].shape; + } + + if (options.changePixel) { + + /* Allows for Flexibility + if per pixel manipulation is not required */ + const imports = { + env: { + consoleLog: console.log, + perform: function (x, y) { + let pixel = options.changePixel( // changePixel function is run over every pixel. + framePix.get(x, y, 0), + framePix.get(x, y, 1), + framePix.get(x, y, 2), + framePix.get(x, y, 3), + x, + y + ); + + pixelSetter(x, y, pixel, framePix); + + } + } + }; + + /** + * @description Pure JS pixelmanipulation fallback when WASM is not working. + */ + function perPixelManipulation() { + for (var x = 0; x < framePix.shape[0]; x++) { + for (var y = 0; y < framePix.shape[1]; y++) { + imports.env.perform(x, y); + } + } + } + + const inBrowser = (options.inBrowser) ? 1 : 0; + const test = (process.env.TEST) ? 1 : 0; + + if (options.useWasm) { + if (options.inBrowser) { + + fetch('../../../dist/manipulation.wasm').then(response => + response.arrayBuffer() + ).then(bytes => + WebAssembly.instantiate(bytes, imports) + ).then(results => { + results.instance.exports.manipulatePixel(framePix.shape[0], framePix.shape[1], inBrowser, test); + + wasmSuccess = true; + resolvedFrames++; + generateOutput(); + }).catch(err => { + console.log(err); + console.log('WebAssembly acceleration errored; falling back to JavaScript in PixelManipulation'); + perPixelManipulation(); + + wasmSuccess = false; + resolvedFrames++; + generateOutput(); }); } - catch(err){ - console.log(err); - console.log('WebAssembly acceleration errored; falling back to JavaScript in PixelManipulation'); - wasmSuccess = false; - - perPixelManipulation(); - extraOperation(); + else { + try{ + const wasmPath = path.join(__dirname, '../../../', 'dist', 'manipulation.wasm'); + const buf = fs.readFileSync(wasmPath); + WebAssembly.instantiate(buf, imports).then(results => { + results.instance.exports.manipulatePixel(framePix.shape[0], framePix.shape[1], inBrowser, test); + + wasmSuccess = true; + resolvedFrames++; + generateOutput(); + }); + } + catch(err){ + console.log(err); + console.log('WebAssembly acceleration errored; falling back to JavaScript in PixelManipulation'); + perPixelManipulation(); + + wasmSuccess = false; + resolvedFrames++; + generateOutput(); + } } } - } else { - wasmSuccess = false; - - perPixelManipulation(); - extraOperation(); + else { + perPixelManipulation(); + + wasmSuccess = false; + resolvedFrames++; + generateOutput(); + } } + else resolvedFrames++; + + if (options.extraManipulation){ + frames[f] = options.extraManipulation(framePix, setRenderState, generateOutput) || framePix; // extraManipulation is used to manipulate each pixel individually. + perFrameShape = frames[f].shape; + } + generateOutput(); } }); }; diff --git a/src/modules/_nomodule/node-gifshot.js b/src/modules/_nomodule/node-gifshot.js new file mode 100644 index 00000000..b0003e99 --- /dev/null +++ b/src/modules/_nomodule/node-gifshot.js @@ -0,0 +1,47 @@ +/** + * @param {Object} options GIFShot options object + * @param {Function} cb GIFShot callback + * @returns {null} + */ +function nodejsGIFShot(options, cb) { + const puppeteer = eval('require')('puppeteer'); + puppeteer.launch( + { + headless: true, + args:['--no-sandbox', '--disable-setuid-sandbox'] + } + ) + .then(browser => { + browser.newPage().then(page => { + page.goto('about:blank').then(() => { + + page.addScriptTag({ path: require('path').join(__dirname, '../../../node_modules/gifshot/dist/gifshot.min.js') }) + .then(() => { + page.evaluate(options => { + return new Promise(resolve => { + gifshot.createGIF(options, resolve); + }); + }, + options + ) + .then(obj => { + browser.close().then(() => { + if (cb) cb(obj); + }); + }) + .catch(e => { + console.log('Puppeteer error: ', e); + browser.close().then(() => { + if (cb) cb({ + error: true, + errorMsg: e + }); + }); + }); + }); + }); + }); + }); +} + +module.exports = nodejsGIFShot; \ No newline at end of file diff --git a/src/util/ParseInputCoordinates.js b/src/util/ParseInputCoordinates.js index c16117bb..79dc2ec7 100644 --- a/src/util/ParseInputCoordinates.js +++ b/src/util/ParseInputCoordinates.js @@ -1,24 +1,23 @@ module.exports = function parseCornerCoordinateInputs(options, coord, callback) { - var getPixels = require('get-pixels'); - getPixels(coord.src, function(err, pixels) { - var iw = pixels.shape[0], - ih = pixels.shape[1]; - if (!coord.x.valInp) { - return; + const {iw, ih} = options; + + function convert(key) { + var val = coord[key]; + + val.valInp = val.valInp.toString(); + val.valInp = val.valInp.replace(/[\)\(]/g, ''); + + if (val.valInp && val.valInp.slice(-1) === '%') { + val.valInp = val.valInp.replace('%', ''); + + val.valInp = parseInt(val.valInp); + + if (val.type === 'horizontal') val.valInp = val.valInp * iw / 100; + else val.valInp = val.valInp * ih / 100; } - else { - Object.keys(coord).forEach(convert); - function convert(key) { - var val = coord[key]; - if (val.valInp && val.valInp.slice(-1) === '%') { - val.valInp = parseInt(val.valInp, 10); - if (val.type === 'horizontal') - val.valInp = val.valInp * iw / 100; - else - val.valInp = val.valInp * ih / 100; - } - } - } - callback(options, coord); - }); + else val.valInp = parseInt(val.valInp); + } + + Object.keys(coord).forEach(convert); + callback(options, coord); }; \ No newline at end of file diff --git a/src/util/getImageDimensions.js b/src/util/getImageDimensions.js index e04bf878..b2323cde 100644 --- a/src/util/getImageDimensions.js +++ b/src/util/getImageDimensions.js @@ -1,10 +1,29 @@ +const getPixels = require('get-pixels'); module.exports = function getImageDimensions(img, cb) { - var getPixels = require('get-pixels'); - var dimensions = { width: '', height: '' }; + let dimensions; + let isGIF; getPixels(img, function(err, pixels) { - dimensions.width = pixels.shape[0]; - dimensions.height = pixels.shape[1]; - cb(dimensions); + if (pixels.shape.length === 4) { + const [frames, width, height] = pixels.shape; + dimensions = { + frames, + width, + height + }; + + isGIF = true; + } + else { + const [width, height] = pixels.shape; + dimensions = { + width, + height + }; + + isGIF = false; + } + + if (cb) cb(dimensions, isGIF); }); }; \ No newline at end of file diff --git a/test/core/gifs/gif-test.js b/test/core/gifs/gif-test.js new file mode 100644 index 00000000..407f9762 --- /dev/null +++ b/test/core/gifs/gif-test.js @@ -0,0 +1,30 @@ +const GIF = 'data:image/gif;base64,R0lGODlh3ADHAPfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAEAAQMEAwhVmw0oRxAOERIAARIHBBWdWxadWxlOVxmVWx4eHCYtJz0rJUA9N0Sy0UWnd0wDBk5OTWVbVW4XGHNKLXNycnhtYXoFDHqDhpiRi50SHZ8GEqGhm6Smpqq0tbHCyLirmL+/vscJGMcNJMjIyMuOiszMzNCyjdI+TNO4nNTV1NUDGNq/peAAD+Hh4OIAFeThHefLruvRufLx8fjTq/jUrfjUr/jVt/nTp/nVsvrvC/z9//38+////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQFCgDAACwAAAAA3ADHAAAI/wD/CRxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bNmzhz6tzJs6fPn0Af9hPYr6jRf0aLBl3KNGLSoU2jQoTa0l89dua+edvK1Zs5dvD8KaUqtWw/f2jFCrTqjyhZj2nR1hu3bRqzYHjz5hXGbJq2b2Hjti2Ls2hbtAbP+oOnbZpjbYEHizRaD9y0ZseCCTPGuXNnvMKEFXu2Dd6/tEgJ26z37ZprbePqDZTrrRiA0LeZlT79tmM/1s9Ccz5mTJpxadmSZzPeObSwZt7qoVWqWmY/eNiK4Q5W7Bq7oWfHNf8T/ay89mLUpEuGC+9aMc3GjlXLxo1cu3jt3ul/165dt27ScAYaNuyItV51LtVzjXPFNBjaM+MMVQ81okEGDzviiXZNPb1p5A87z2hXXDbd2HdfPPHstx+K/XWznDG3PfNdhwiqNI52z3hToDnUvAdhP+ZoR01b4LEzjWjbHJjRb+Aws1lx9amoX4pSvoMiiuRwE6AxfIGjnlo1rrSgMBEOpKB20zAWGjhvoRMcM+b4Vo83TgYjTTXkVGkllSteeeU75GRzjDAAMBMdUkqGWdIzwTAj20DXudddcM2YVpA/NwozzaNL+gOOiCSSQyWL/ZFjan576skfgFwW841YNCr/GpI/zADQjHSzLXakc5teipakbCYqEaZOFtdNflT656JyJB6L4pTPJqvloMx8g6usJ/XD6K29mXMXXukhZM541ISVETy7SsMNtPEEGiAzzcRbjLGi+vmnlf4FGEwz4wiLLUiMMsPOQfVsox0A4RKsTZcI0XgUQf64J4w0zurXznLojcOOO/B0PM41zKgbrb1Xsvqcpf+SFLFo5vR23ZEIc1pQP+g4uaFBiLmlGKyIDRXkMceUaOWq0jhjLTznWPNlwc5QjCzJLAIYGjbXphxSP9+E5s1BbdUGQK9c+0NhMSjnCqlgBsJaz5HGVKNiu9I8g8516sRTTj5oIQ3POM5k/5Pnnn8+S043xnDnjb9WT2SVOeOMExY6zRQzjZJt1TNeMTIbdGMx2xCkWD0XjqNVV96A8w2G8BhsjN+AlxM3O/W4U7fd59RzTt3n+INOMdL8rSp+2XAJZ1yJV2QVONc800xfsB3ZDDo4F7VwMN8lBM94m1I11zV2CaOXc6HBe5kwx2RTzonxLGft7aSqc87576jD4TXIPatqO+ToO+RhxU901jZO2o4wnnGXYmxtZgIZR2iSJKyINQodiPHHNsajGbwU7nvBuE1ognEM5NhHP3FDWjlQpA519GeE+inHPP5hjqbZT1XvCB53+nWa/k0kSHyZBjWoMR7vhSZN1CEIPP+ctCkwGeQbDWIgOqbBwWIwIzklMpWp/rOsLYGvOAHyxuzilw96UKmEKKrdhIwxshdOyT/ee0ZkbBiRhXHuUYwJIHfAkTOCTGhfLaMR5ISRniVuBjn1MVF/Bok/cpTjP8lhTmeOcQ112Kcc7rCKOspxjnycw0rqoIcEj3EfGA4tf8Yw4HTYCJEjqdEq9UglOIIjpDrOpjbC0Ia/1jZAdlCDOE6DGslUlKUXFY58yKEkh/xxDndI5xz5oaQ/vsGMY3nSYoQbIDxiRUqcBadXcblOdkJDQ89dh1HP+AY40JE5gWjjGOghjvlO9Mw+2c8/L8ILM7xjGKPMoxz8UQexnKn/S3sFSBivomY1Z3PNsqXmTOjh1G/yNo0GNUhGifkUX8jXjRHySUrvZOfI8OciK5JGPWfJhzosBg9m8tNeGE1f4SZ3loEuRGz7muZbPnQkZrBpNsDRjmiasY1yXkc7wSiORWH4LI6eCnB+8k81OCOaaZhDNoupG3/EsY1jfPCZKNLSDAXqUqyF5lU4+9A1H4WpXTVqGqVx5VrqYRsArG6oz3QXZ+5UIj75Sa4VCovtyuE+eNzSfv30E+G6gxqXWg9NPvVZ5MaRwGZoMEfTXAvOFgYAAJQPrnEFUIA6SLFy1ItP8OQMegp0jnPQYy4hi1Y74XYMiHK1mmJr0Ddcdhpb/w6JTvK8hrm4dhokaoZ81YAfuwKXIha5C2hYLBGqVoTXZoADHtKpxzPaBrjVBiqUh0PcQMPjJIgeRELmoBMARkNHf6Flj6NhhnzOh6pd3s9doClfN6CmJeFBph7nZJ0ZieofLqXntWyUi6TSo9a1eCs03ikspGaDrtBQY4lCXa57VySlwQWPSyOqD2ivG0pqaOOJ3WhnlfD3rsgaNqxoAZFmbpYYeLDyGohL8Th2dUpsbMaZ7twvqZYr185Q7Kr4IUc1/gm0D150tfH4J2NPPLO9fUMb2gjOeLXxqKOcSTflLAg8vDGNzDRqtpVRp+8mbKXBVePMfhPsP//oLD5Jjf98f/OTiFG01Fgy2XPoWl5l9zLPyEgHRNXKMoO7p5liUFkg0rXTuob7JxJvycf06QY3uHHmQf1RXcsF1JbUlaf9EjUeUnuGdm24Ns3AK17yCt+h2oIOanQTIfUYV2iacY3nXssftSlOnFEKqAvrJahYVOQF4fNjQlJ6rtlg55zblQ2+DOzO/2CmphzHjmrThYeiIXANR4kQF2e7ejk7i7eNEeJRRetiXPo1ADK459+y+7d/VE41EFk4civbk/bLxnhnG0SXbqNLhxnlVcChDd0OZdT/AEdoqNxSz6GFmR3E8ZSspCXv/TovAHAGNrBBDWuECGgWf5JnOMuly97rd8X/7cagYFw1l2qjUa8uSCrDAuB/UAjG03mLYc5prLeR+ILHaAY1pkFA72V8HvfABz7mQY95iGObhAKNc4rDDC5RLFUoL27+pIlwq9XmjQnpd0OeUcSziN0wtFzd265LqGJgQxz5yIfTj8TBdOxjH/fIuz3u8W+8rBs07+5gaKyK9SrdC5TNMEeBSSnrNAk6NRAxB8r8dRY3AdM+KAqec7ZBj7vnPR/uwAYzmLGOfOD9HvsAvTMsDvgMbjA+SzVWcT3Ny+AVo7xMjph2WIySg5+TzSTmi8bpQY+4N93426CGO0yP97hn5xjMcIZjHEPAQd3GGPXVdXVhOLjCZdew4Lme/4YMWpKzLKzeFJPh292BD3qIY+jTwIY79kEPdxR/H/hA/Tyo4YxtiGP5cSd3XHYMf0cf0vBHcgZD/RUMPdV1sqIYCcdKzXBf5ScX1GBqwkEczDAPcbcOPeJExXAMzlB6d5d6p3cP7sB+Ach89wB6jIIXfgNKbSMqz4Q/XCJLNVcjDyMQ5jAmz3ENsTESRqFiz9CD3xIM1IB/8/AMrQUO7GAZxzAN95d6pod6xucO4vB/pmcPqZcOXuY3F7MlEnc/7eBfjzdQBdNDOaQNcQISmJI82sEM2IAO3tAMnLEN9kAPNjYNA1MU6MI5zBd3eIcP+eCBz+AMzfAM8leC+PCCaf8WQwR4dVgVINkDbTi1SgFEHtBzKRgBIsuzQc/xDRTCDOmQD+IALxGyGKbjHtTQeVSYevMgesWQiAQ0GvO3D/YwJpxRDZPWbLqWaXoSIM/AITt4Z8cDhwuXgw5xHaKTfMHBF93lDvtnDDj3DcpwjcQwGiQoiPlgMLoRGOMQHNSAD3gnDk4EbMchHHVFVO+yDU9VjF21M1fxDZU1jLNiFejgHnkxDfOwDsxANh/SDMoADQRJDM0Ad6/oDurVU2MxDv9od/iwDtjgDdQgRxkUVBRzZG9TZ7PoVEmBIMqIaNIBFSvDgGf4EBFkFRfSMR2zIJaFDfSwDdRoFdMwkAQZDdn/iJBJNw9dtiFpcRXjQA0AgA0BmH/44A7bcIjNgIihwTp6Qmf1VjjH4GqwohohKVkF4S22MiMWcRixtg3cUx5iSXfdsX8A1Q/g0AwEqQzE8I/MgJCpd4r8khbIg43B4AzFlw/4sHddlILrgIXOoGgoNy1DNhzNYC1XiSAHkkoLIww+mZinURmX4WVSx3rCN3r9og1qOQwh6D3FAJf5gA1TOUzfQHY36UQAOIjcmA8taGOr42lZJQ3HUA6U9k/MABljwRS94YCQRxS6giTqERGHYUshB32jd5w65W4D1BjXAA3EwIc1BZc8KQwt8w9uMgwEWZBv+Yp3t4Jx5w6BaQw0/4hR76Al0nAi+fJDMwKZNKFgw4JaXVI1ryVuu8IX1OB/WZiF27ANHBciXAI+yhAN32hKpWd66zAew6QNNjkM15hEJliC3ul86gSM++EuqTI4/1QuYtcUI9mVmxR0dDQbAiUWE+KZ1LAOeRmhcucO61AX6uVD2gEb2MOBcZcOs1gUlhMN0DAMxLBBn/mgJUiFAZgOzqBrGtlrbtMnFdcdxKgakjEYi5cQaIFbhmYuRLIY03Qgv7Eg3AGXQYp3+hCme0eOoIcNzjAopjYex4ANzbcP4oCEbWEOxFCQohE+56APzBek3rkPFBI0FIov47kf7bCkAWWVEOOeC9FSrHEe1P/gJaexTNOQijPTJOQDk1/KiHmXd+QopBJ5hHjxo/YQd2+KDUXhDXMaDaNBkY2yDi14qd65Ds8oDfhkePhheN1nDMPInjbBmw6XFqUZPq7GGKMhGw0XmRTCRxx4qZe6qRBKf+5Qn8KAl/uAp6YYDNdwFtcwkKh6OAsjrXnanYH4rD6EfYDFLrTaDgFiQD3Bq/6jFuIGMoU2HtUCHu76IbZBil+qdMyqrF8Kej1ianZHheLAR9g6kMpgQOgSDESppwF4D/pwD+uwKyIiDYGDVSkiNQmTExu6JN7kFlYRlMkJNmaHFubARJoCpPindPyqrIQYi5ZmDfPXgfBSsNCAqs//0CPH4KVCanziEBzGwAwEZKTFZbGaFgzexUbwODNyoZU2NRhmh5bjcRvXsLJU+6WfF5MhqHzdOZ3fka10+iDJCqHGJ5E65QzWYA1Fam9HSqsgxBdLhrTF+l01pECOeS2GkSE+5A1Vu7enR47zsJ9TKKEbAg5zuqOeuQ1kGohLZ6aZYQxme7bWgEuBOmfBwwxvixMOuDPsmhA2JgwQlCt463fgwLdVm3/duXdJB6Hr4Aw2ZTnYiaqaMg9kKraiiRciCLlnW3VWlYDtVLmXaxaIehHBoUYk6Slqql4z9K2ke6mol3oO27x3R4hVBR3aUAzKEI2sqa/deYoc9Li4i7ac/9Fm5uZJvqsTiDNTm7sQzRAMRZQW1wM02TBk45Way1u/EEoPDTVRHPQMpaepgOt8oeG932sNXGI+98JrE5dkz7GJQDFMD5O+DLEtfkYhxTGomwV3ymu/pFumh+gMpLF8d+d+HhyzNna7A3y2mcFpk7bC9dFJKhJ8aXITceubRKEzuqoQ16AZPXUaXtM2dqN51BB3+6rBG2x8K4h/phiYgNiN7yEfJ4y2GLkcx2EcUNQf0CI1MLarByIsTwESOAQhVvFhxFENQZYZ+Aq9RLy3pocP+rCp+WeF4rB63kMNHMiTt3EMTyzHPgQ+wvFjfrJUrnLDLtHFH7E2cTgNW1FVxP9xH+gaSs+QDpuqomncr4KovXf3txbpDCq4DXf8xHdBPk7kDKIsyp25OvNlg8ZwKzLcnn7VVt+jtgAyLzDLmjsriMuLxtFLiLbcnfiQDtMFiuQjDhx4gY47wNVQdc/xdjRKfGV6F6vTDuXQbK4SpQlCERt7Ee9aJ9+TkWynKetgD9R6xFRrunfXxusQsHqpy3lapqt3cQxYfKuHx997pprxDOJADw6rD1+KyeFbDYNSdtWRtBsBOtsAZVDWZeWTJ9dFLdswDxq8xncXx/2XrEbZRf0oemhaWX+HF9pQfNZAPt9bddxxoqg3xJ7Hd+/BVHJDzUsh0BmBNgIBOT2HP4X/ST7UcA40ussmzYiFKHp4ocmV3KLY0GWAp9EbHUtxdw7hM8qDIoKcl3f4l3TkuKl5Z5az1i8s3dKTgTPXMCJTEs0HqBlm29DFZ7qol6maqnTpYKYW53ZUtXHT4AzJeXHtthnbcMn1KSDsKw4qm8u4nH9MbCvlFbyW+FJtwQ7zcp5X4h+Z4RzQd5/p8JfzMNmU7Q7pUBeduRcNYmnu3NmmJg4lGLEEyB3NgA3zwIVsbA+oy6LSGL36F5hpkk1LAcEbEReiiX2d1C6NvUHx5cE79NtE52XOoRft5nfrtmcb/Wtr6tBby3H3aX+4qHT2oNbYgLamvcZWyESnlBaCfDU4/2MQLVcSOTMuqzOe7ZAZRp3e6q3exp3e7LbelWVx6yYM1x2kbwzV+RqLZ+p26XB/e5l6F9gMA0PYOWFEMAGl1Wtv+gFK8N3gDv7gRt0X1HCzGIzdaI3fEBrHojHLWyimAL4vfXjNmEvbbsgOdiirFhMgEL7iLK7Rz0B8KYp/arwP7jBduoF0+grO+sCF+XCBAoMUIi7D3c0RYrEw9ZN51tfiSt7g1hCARRyAJXwN+cCXuBimO/7hPw7ks92eYnE9xbEnDH7cS+7g7a3R4OLkp8ewEUqFq+cM85AOWZgOy/fGuhzgzxbkM0GSQ+4hcpHgbbYcPuR3RT3myS3m811JaP9OyXsawpkhfccpfetA53Gn3ZaC5zOR1SyRFCAyMTSoVdzhUJgh32OOTqzHbshqeovOr3m6DuBTDM5ADddwz0aZeuCJhByi5YXtK5g+ELnGOoFyG+OwDn+pkBdZ7PDtztNwDozCesstthlMte5QOMxADeJgheQYpi1oik4iS0C+5zER3hSRTQTOYMGhLqsSzHG3d4yS3Hvxbu7smN0IPo1CfJG8y1TLjf/Ied+6lw/bRaJpU5Di7S8BUrqKNh/ZMMv0R/lBOGtahfZwiqUOGv3Xzhcngk8XQKQhGmErpKru7ABOet+aqTy+uuyrUAJvEjtzqLBiGOGec0/B8jhTauT/Zirz8gxh+7dynBdRWHoe6KlnlTwm+oQNQoJiy7dCrO3nkK/QG5qD8g0Bf/IfYeCPuh7cTZKK4/JkYRhqFR4nbirv4g3pTH8S2cEfHIDzcA4bl/ZxDVScA13i8Zn2/uyeZ9KxuA6qDnp34Sip4dI9YXYqrxQkrhAHp1YKQhwlwip0jONU2HSTHaFNh4UNhd6S81T10GpIYu8rS87L2q+RDKuaMQ3k5PJScc0QeKggQRbscBeclq5wN6ZK553ucA77Cdf0PGvUYC2pVJrxscTLi/lzD6F617MhN0/Pljjr8SWnPxj4ZVl48iIv3p0p+4pJo17/WWjPwIZ65VdN48/H/7ANcm/fn2d8KSrEYrt02yDHyBUfRZTrHoEuhs8NmjcNqZm6Vdh+Gj6B3uA4qQQ6H6NeAFGtXLdjxcTtQ5hwXz6F++49zEcPmzNq29bNy5cx47x16SYKE3aMmTVrzooJK+bNX79+/1y+hBlT5kyaNW3exJlT586Y/lz6A8fsmDRy3aShxIaxoUOH964Je1bP39R67LxRY2ZMGrd28boZK7YO39KMCh/eo7ftGICQFLG9fUvNJMi2JO0eE0aNZUueff3+BRw4p0+X9a4dO5atqDRjx6bNe7iQ4Vh8+MQxSznO27VpzZhJy9aNXDvS2YQxozdWIb6y91Tnm4eNGciTdP9BBqMbrLEzu3af4b22kq9g4sWNH39J+F+/es2CgW7HjbEwZ9vc0SubEPa03MF0bx397l08cqat5VOdkDVDyfjSWTOGkpgyYsK8G8Nve2Rvks6OBSvGnOWGQ65AAw+kqZ7k+vGmmOdIM8q+YqbZBqPJEMpnm9puM6Yb8T6MRzphtkEPobFgc0c7d7BpRkJlhhmmPmGMyaYaaRgLBgBjmHGmGmuqcWY2AIPbC0EjjyxQwZjqoSakakYr7yiUKLxOo4i4ww0kadoBMZ52GHNGLNb2sQcfd6ahBrZ1WMRLmPlgJOYk0KAsKhvG4kOsTeq8qWcvApEENFDB/DHnmZC64XL/MfziY2YabMShZyF3nANJqw/fgbCxbSpjDR97YjumOmvaLIYYYmCM8aTEyLm0HXKkk0bPYp65Rio//xQ0V117kmmqb0Cqhpt4xIvSmBzte8YdhjIU0phq4oGWvGzwo8YdTlPTR5xiAECMrlJRjdE+GrkcL1poFaVtmz5ZWm6qXd/V1V13ZzJsRqKGxbTOo4I5hsSM0mLmu2C5kW43ZTVCaB5Ds/wW3FSFAU08L1/18EMIp2NGG6ng5XjXeW1ix9DEyJ3YRrqeifSeiMR5JiutbmxsmhTZy+ced5osptQ3HY5zRsXaGcjOG8mVuB2j8tO4Y6WXhqmfcWY7hpxhvSQo/z66trFHH9fwWWcbZ4QBALdjrlHWnn1Uc+c3N19ElT5Te6aRnMVwnFFqiaF1tZr4ikl6KuWYBlxQf7yxb6voqimoVGVOYqZCK2GbJ51z0jn47I0uA/tUcHPuTmyYQ9IqtK4kvtQrabjVxu+/A2cdQZbq1Yobvd08tefTtsFuIYWyq2yhdbDyDoCdwy2mGWqomWaa2RZ9ORtuyiF6vHLHKwq/Ysbxu3XtXfenHni408pqtnv2jpmkVMNHH7Pu2Wcer+0LPue3HaQGnXruh2ccLGO3+9K7ox1PO2Y3DXisbnsHLI7fQkYbzQ1jcaE7yqwsMg/sRIQe9HCHOK4xm5BgJv9n3gEhSjS2EuHUQ0NDYZX/VNild0xrRH1CYAyP0z1sgGR4xBjK8xBHF7fABRvUeIaD7JOxcXzDG9u4BjY6I8SMwbAfVMHGMeK2QiqOxyjBeAY7liNDLgamH0GRT9uIEbfyGAuEiwIhCI/RjGuYQyr10Iw3vMEOdoxDG9PImbpe8kR2OEga5agiFcuRDbaMo4uH3MkT/5E/QxWDbXCCmGgYwxbjPaMZl8RkM55BDXBIxW/bwA1u+MYOEo5jGwXkyxOf4izpBbJ05IhPcAyISFq65In1AIfyTtIwB54kG7+02jXQ0T10mMOYxmSH93yiumukETfPgEeR/uSPcRTDUqT/c2UA8fKMWnazV/7QxobCCCcHdUNvABrhEz/2j3mpzh/omMYznjGNa2ijk7aUyRPhYagtYTObX9qRkrzpTX+AMhj7GVUwNAc1EfENHugAxze0oY1tjKOAW7TJE9U5S5iA02fRc6WXGFMMLQ60m/34xmyYIQ958EMezlAojOwlnYMirxm1wU2jBHqTlbATVzL5hjWzAdJAQmukJTUpLRdoPn40VR7WcJNMnXVO26CEGbT6Bilvcj9zgMOr97yJOZrhrP5l06gBTaqRNnqrW/VFGzOyRlOdCtX51McYsjPWyewZzZ/KxDALAwk0cbJPrZQ1pPFgTDP62te06oQ5Ej1e/2QlO1nKVpaDvOnNLuEGs5yekiU9zck47AOAsDUDezjxBz8N6z9znWtvlb2GZxsLGHhQA6fOBCFpdbvbsKXxNmALW9h+m5sZ0WUabmQXY2UiWtqYVrkwoQa/VtslcxktPlmqKkiYgb3nzlYmT0FJMZgxXvKW17zk1aQ81bve9XrmvBtqBinn1d2XGAZN2kBqTpoZtaKaqxzSEOV5Z0Pa+BbJuzipx7YcuQwGN9jBD3ZwVuk4YQpTWBsQXsbicLMN1f3lfrbiCSj5218vZQMvzFAGhpfBQW+w68A4YYd9UpwMByPDxjfG8Y2XEY6NZfQby0iGjZNB48UBgBno2ChGdf8CWnYm0hu66cbUqBitoy14yEHW8TJOcg0XvxhkJ1EGlrGcYzILmcccTc6PhTxkZCgjsPKVl3LQTBwG4SbK01PhxKbTDCCXmcZbpu+L+yiMMCPjymX285lvgtI+szkZixNGfFX3WXTI8bQHqrMw7gytFUZJu31es6O1LAwuexkn6PhPoQ+NaBwPWdE+bnSQ/wwSlVBlHBuEHzO+sVPkPFnTK3SVouLD5zEb+spDHnWpTW0TdIB5GcY+drSlnYxX14TRssbyMijVjG1s444ByxIl+TSgQOOEcL9uVVFsdF1CA3nah052ub2LDhm7G9vvjna1aXJtaBt6GbfhXG+tWpv/xvFVkcV5qzCcRzAbwaxbp5kxvtkc72Uzu96Hlni+e2ztH99byJC2TfFSnGGc1s9vz/3pcPzRJIjBDD/dEi+fGZzxiQO64jWhdzAifm+a63sm/F41MhisDEwqY8Y3VgYHj/GMWjN5Jn9TpnLq8Qzd2Mfq2m3GyB1Nc6Hb/OYzyfnOod3zje+74/1ms40bLG2ha9tBAJrGOMqeHFsSUxu0UhJL0NEi8TLjkiOfebRD/e6uk1resw27vceecZ/n8+wYL/aNeU7jDHMQJdcAx0U7OhV0bAOPkdaiT5gTznY/eNXHHvy0C6/sr8ck8ZCnObXn7vhYY5vVYp44ydkCIKyC/wMdv9cMNW5Km1q3ix3NAEAx1h57rlO89a6/+NZj3/iYAP3Yz2a15HNM8t/mzPvFkBVImpFVeMCjUCDROvOb7/Xnv+T10if7nJfz+Otnn9UNJro4q4pionvrkgS3N/XLuNU7vMZ6v8mTOOprGvq7Muyzv1DDMfwzOqPLOqNjMKFrkdsgrUi7QMkTQMJzvvZziQNcvAScvepjQGR7QDJLuwdcNW3LpKPzwA9UvRAUQRJMvXdTwD3yhtpTwRVstcjLvq3DsGKjQRBkvxuMvrSbvhNMjsEJQNQrwSOkwiqUOAIUQfdbQtxjPCf8CShEwBy0wjEkwyCzwfY7QC40wTmbiv8eDMMpLMM4pEEszMJ/SEMxlLYdZCcwLEE8lMM/jD06zMI7hEONY0M+ZLtCBMRFRELDq0M73EI/PDY9bEMfZEJGxMT1c8Q6JMQmPEQ37ENFzMRMFEQl1LkAlMQro0REFDxRHEVGLEU0jERXlL1PtEQ1fMVcNMMklMVTlEJPtIlKfENdJMZd3MRBnEUpnMFa5ClQTMRi1MVYfD5CdEE9nL8oNDZahMYx9DdenMZZrEYvtKWOUzwgNMdzRMd0ZDBvbL3ECzwglD2U+wZZS8d6tMd7LLMz/EZfDDr7Y0Yf8zh8FMiBfMB1PEYRjLFTDDz1s0ZG08ZtXESDZD0RrAf7kDn/FcPIZXAj5TCwPSLHjATJkBTJkSTJjHSzEekyEeSO8Pq+lnRJ77sk9pJJefKgl7TJm8TJnNTJneRJzjkovqrDfmAHLPGt7DJK2yAt3OCtpeQtpWTKp4TKqJTKqaRKpsypb3jE5GCHO0oeqjsNAQNL82qG5CHLsjTLeHKvsFTLtWTLtnTL8RoisqQGuVun5/us7vkwXwO8klyGaICHDwPMwLwfdogGvjTMwzxMByGgD6vL9rvLqWgJcMANZXjIQ+OTxmwaf4CHaIDIiFRMJVmmrPQT0JJMQgvCQLzMOdMnzuzMP9SyYJgGGJK/RyxNyvxAGxu3fdsLzWTN1ozD14zN/wJ8PnBgC9tsRTjETV5rmt3cTN+UQ+CEoay8CeI0zURETmTIzZ9jzt50zjGETuFsPeo0TmUkPOxUzj3azu4sw++UzukszlC8zuzMp/RUT+/8TPD8OvGEz/KUz+qjz/qsQvZsz5rQz9s0T2v7TwA9QgEd0JkoUAFMTgT9rOZUUCpk0AaNiQdVvwjVzQnlzgoVwAvF0JfQUObjUO30UBBd0PscUZko0UA80A5dTRWlQRFt0RfluhhF0Rml0RBl0RaFCRzlutTcUd7sUR+FzegEUpcQ0gEk0vlM0SNlPhsd0Sa9wif1zyiVUpqjUgy1UnwzT8wcTQrd0ozr0gb9UsLD0uPl1NIyxbczHdA0Vb01Rc82ddNpg9P2lFO2o1NbStA7lbY8lc49Fbw+JTceBVQ8/dEl/QdCRT1DHdMPTdQGXNQldVTL9KQiJdNJvb5KBdJLZTNI/VNO/bMkxc+bA9Ugu0wZNVJS7VRTZVQmfU8D7c86tVNSFdSsBNUTzdJb5dRcpc1ZhVAd7VVEddVSDc5YbVRh3VBiZVNfnVRgrcNddVZbNVZXldYspNZa9dNR/VVPvVFmNdFq7VZoTdRsFcFtPc9DvVZcBdcqFVcY5VZ2bdVjRVYltdR4zdF5vZV6PVZ0NZKAAAAh+QQFCgDAACwRAA0AkwBoAAAI/wCBCRxIsKDBgwgN/lvI8F/ChxAjSpxIsaJFhA0bFszI8aLHjyBDhuSocSDJjCJTqlw58iRDgS5RspxJsybBjjhf3ixps6dPkDyBxVQY9KfRowmLujwoE6nTp8D89XNItCNTnVCz/uxXb9w2bdrQ7Sw6dqHWszbBNStWTBjbZ+NMki2Ltu5KcMWAuWXGDIAwZtrgCZ0r16zdwx/rTXN7DRy4cdfaFrsm2B9WjJcRa65nbtu1z+DqNRy39progeMWTxZNGGZmgnERjhvHTjPNepGF6Q5WjFroev62FWMG7p8/f8DqAYOnWhtwy1Qxv7Z91lvbYM3WCgMGGB5ugfCO9/8jyO6Z229SDSedTh1qeWHTxEbdpv0ZuGnAnkFXD4xdM+zsQAdRa+0h9Q1b3pjkDzrUtPUMM8I8I9pzBNXjjW7UhMdfVRsW+NQ2wRAnF3K5+SVhP+IVVA81fyXX4U7+AOfhWSCK6NpC9WhTTDB/mdOUQOiY9ww7/0w1nXH+fDOjVgcyo6RrUy3H4l/eHFeUdcVoY+WRMeK3JFTjQKhNYVQxpxs2rL1mHjDobOlQPfXAI+dz5X0JFTzmTSPYYMYNhE4zwjQjVlMLjZPXNVYKBJl5bj3zDWfN2AmVjsWAcyNyA23j1jY3UsXQioHKBwx9upX6lzakCdSOpEexA+E0yvH/GR08gDZTG5+y9vNNaXHmxlt22jVzTaTAkPMOq0ZR41dsTWnjVoKdMtSPmc+YM2Ux01i63DMGGYvsTPWA88246IQJgJ6yGuZfqGQWKdCFxTAqTIYwJQlhM8wI5O23KeXIDFsA4+uWc+lStQ2E1LBT2WW0ltqbQGkK9pczAx3Lr0jW7fWvqYGOs99CKErZFjPZEbnhNTyuVmRDijF28UoNM7MNOOaAow2gumGbJsjHjbpbb6wZtFgwQ05lZJHsLMZMbC+LBE4wwUA7EDzecKsXNc9JhSI8kfHYjDf1jGeQoW6Z8zFDYTIzza1Nh+SsMGwP5A/XzIS4zXM4XqMXttoe/4QbY2cP9LbebTutmzkGSaWceTYKlNtke8oGqJ5N1fMMW30X/hE8bRFOUD+gzz1NvLcK5/JDZoooIEEXRgix5okt1kzkUCJHt2lhMka7QezkBiswRhJkZjGcwh7SgcRvpBFn3+DJWKx+0ycZs9Elp2OEuxtvUXnxZp4uxJSii9Dfuj0zJkJBPnvQOFZrHxHyz9DeEWnYinqQcABkyQ70KuIVjPgF8Yc5iOU+iOTmGfbLiD+ctbSH5K4ZT3oIOpxhjCERpR/o8FIBE4KbtkBwLF1K3kNY5CSJ4OkYzUCc8oqUvQ0WBB5vK6FcpvUM06xORYAiWERA1cB2xYh/LoQYZP+0k7NmaGN/AkERnNKTmXrAp4UI0ZQwIugmJMEpiMlZzjUgJAweQY1HgQqL3FZWlHp8rSJvi2BUGnKcubVvgznaUTGaMY061hFn8eIfSbIoECRSxHRqBGGqgviNV6lwQCt800fYwaLegCNuLyxeEHUkw4v8iCLw2IZ5jlGqGiKEGm+ECj1+co0IMc0iVqmIN/41R7bo5hhYhIhwROiRS8bSJ38CEFAIdEuWlDJCkKyILXtJE+awhRmNaSEQOdShFxHzIjDcmNqwgaplPiSVuHpmv8ZBjY25ZTh8cZREYuJMbXrEHNqgBhHbAsxxLsWc4ELHN7SBDWqMbjXu3KNBvgP/z5DAaXhSiwg2CRLKfoIEHRAqRiCv+Zp6SNKgKjEdBK3JoRdGBqIzuV6WoEiXgbwHozOJpluytcxMisVIYgOGOdYkEG6AVCX+Ghk10AE93DCjNqBT15qkkY2XzsQco8vZNLZBm1J6CXRRKg8seVoOn4ZUk650i3aehFSusMgYxyBHOcjhVHDB4z4b+9WtkOqPjEmDG+1Ia1dtQrWgmmYgoPMPMI5RjXK8Ix5qXWtNDiSMh0YFGHnJRjniQdjCAqOpel2JsxRaELwYQxrkaMdd4/GOd6wqsSxhYObeY4xqtIOyk7XsZTGbklk+FC/COKtkJ0vZtMYDIcwoKGnR9x8A/5bysdn4bGULa9jZ+pMaPNLhNrp5DGl0Y7W87a1vPzIO3ahNG95IJzOMYYxsGIu1vF1uSA7GsS4K4xjVHSxlk/tau8RLtm2rxzcaxM5GTfeshMUuYbXrT3N8Yxve8IY5MlmMxyK3sHel721+aV35WkzALOEeT8mR3NUimCWkSS03ABzfyh72wSk50GO5UY7VWtbCGO5XKY+RDbRW9sMHDnFIzBTeE1dYxSmJ8Fl3C9oAwzgkYXpsN8jB4NaWVyB+vbFEzLrjwuYVlkK+SAerO2HCpnW0SYbmNHDbYwBHeZHPKO5xefsOxF7ZIuNwhpY/+2LAflmV/eVphQ+M5DNLRIg4OvYwlN08kciMebd0tgg8WFRctDr5x3mGSJwW81hjZTfQEkmaMIxRZOUiGiKKPoYz/AxiYAD60S80j45Bi2mJrHTR0vCwpVMcEfSqmHvVZfCJydHTTiOkPMFgalq56moHNkPHPG51rROiaOrmZdeQngZ4scjRGdVD0QIZBrCf4rllQwRTtgkIACH5BAUKAMAALAAAFABpAGIAAAj/AIEJHEiwoMGDCBP+S8iwocOHECNKFPivosWJGDNq3DjQoseKHEOKHAnso8mFJFOqZHjy5MqXGlsS/DiTZkp2DHHCLNjSY8mLHX/63EmUZU+XBm0WXVoTqFCTCocyZSqVosyDUKcurWo1K1auWl+Cfer0a9mwK8eSRYlQKdq0Z5vGlcu2o0d/bzG65anWLki6//zhzSux79OGSk8KrgfMGeGHe+kiPmrR379+5hw/dmjY8FqbgQOz07wZcGS/f6MiFWjZX71ppVEfVa12tV3L12J3pUy7dmSL/cbppnx691yyZgMPP3vVdF3JX/vVYxx7rFfjqZP2Ba77cPLUtrUf//fYr3vnocVl0xZYvnT6z+d9H+foLqK5a8+a6Z+mbRw8ox9Z1lt2gBHGGDjPCKOgMMEIA0wxzfRH3Veu4TXON9+MoxN2z0FHGDwJCvPMNCQ2I1AxwjBzzX8UwrPNNMwUUwwzz5gjG4E3bqaNMMVcM1098MCDzjbPoCiiNxPaVc81KAJQTIPCNAMOMP1UiaN4V04FzzQisjhQP659U2QwxUyDTk3+fGPkM9dQ04yCzaATmD/tTTbfUuwkSE2SAtXjGjvaMKPgM8JZlaeC1OBUDzhvCqMNmINx5hlRIAqz522CLWYONigWcykw/lCD4jNeAjOOgsz4GamkWTL1GgDPsP+z0F2Z0lnPNkZSc6Y5bzIzJUH1MOOkOXVCdudSOxbzzVqQ1spog9OY442C0/DpzzQACPPNqqx2+FI90nojbobsmINiM/WkBw81DNLI4zYG9bOjMN4UVlGmxa7EzjWCLijjM6IquE26rQq0rpEp2mjQvPAaW5mf4MJUT5FGIszggrH2U7DBnMLJp0Dz5uawRfWMAyNM807jDTjsoDOONzAuKOI4GkOkTTDBYINQyN0VNLGIZxYEzzjahBjMM+ik+5A3OGuzs4JO9zyQOYJGfVA97GzT7zPgCNjQvPUeBLbUA41TtUPscAkAM9vAA2Y9SfMEzLyFGsSuMA2TXek0pSL/xM7dwOiKDjWxej3QNTgrbBDiwTSjuNTXKBh2Q7c2CgwzwDxDcEVgBo5z3wP9TS3osQWbYt0NjRMwj97QCZyfkQtDukCHaks2yP+iztC6ZPJ92cPohDi7QOCM+nFB/kyuJZMQ6u73m4771c+6PGpzPEHsFuMNPOwE2bdrsKG1JIrMINlQ7OEX1M+ywmBzPUHgCEqjfiO2/ZNgJr5VT6Ap8p0QO436lUG4xAx2cOsgtZMZj8yUKXjkT3/faFQxtBG0guCqS1dDkTbmlK+CMI9GbXpGvxznJ3ZgDi1ZC6GCGvSMbWxIIEzCG0Lg0aBxcBBH/xjHjK7xDRbBwxsJAoaP/4CUv3UwBR74sdjFePQMbbCDMVs6HULQwSN0CEZjUqmINqYxDj4tykQFdM0zBKI8mNQOQs9IoxqbYSS2getN/juIOaL0HyzOJl6uYdw2BKMzV2lDRiozh/eCxI5xbOMa09BPfwRFjYTUoxlxJI5BMpVDBl3DNY+jFJeQxhAgcQ8e4KgeQ77hoxtFBkjpYgeDphGYejRyKeh40ysh8o0UVXCGbbmOQERFDUEy6BmZGgdpdnKoar2vILUcI0e4MqEocalxmbpVMYqypBQJ0CFmE9lGuBK1YxhDZs14IsSYVJRvCKpGEEmb8yZSlfgBQxrAyIY0pHEMVPFQnFqjVOy4dv/M0IlEKq8RSDXaAQxydIOewvhmMZpojnpEkFJ381RDqTKUbTgoG+WIRzwEYtCDflNBxXAGNvJJTH6hihrb8A9RaAJAb3KDHO14x0aB0Y52lKMb8qSnMYxxjGlSKoIVa8aItEENEk0jb/+81/iMIY2YvkOmB+kGN7LhTWME44hEEhTOoNS/FybVH2Z7JzecKtOZHsSg2TCGVpCIMGZM4xrg6Kde/rEkYBgjGzB9qkbNepB2dEMr9fDGCCk4PJIUg6nZiEdM98rXs07lVvJb0VS24c1sdEOvjN1rQgi6FF5FaVlamYY3u0GOsmZWo6VJ1jfkKhLGjGaneT2tZjfDLnT/wQQeHzMnU2PL2Kf69h2PiVwBKRckiawrk3NLaDVgetrf+pYw3pBRoq7GDpgxw63IRUj8QEsQbCQUr7J17lM/dLcWguO84PjGFt+Eogb1KK4NsShSgeHKnXajHc0VL3DJu6DrxqhJnUpkG/mjUp8hyFFCmwZTM6rRmmpUvHuFqv68wUYZWZgZzaDGN8SJoE7NCEJGLVGuCnKopu7VwfGAcIQHst+1fkNc3thGhj7mopgJAwBb3aqCAACrgsRSGMeoBoMjrOIHA2O8twOWOV7UrxuTiU3PAEA4CfLj73KjHPhNcZG1nGTKGWR/KVLelmQUDMSSlqy/7S2SuxwRswkj444CUe+byszU+zo3v2tms0NcOSidLGoaxahnVes8ZN+qucV6dkilUtQmQIMUGyZrrzQsW9M0P/i5iX7IOEKkwBZCEWYo2iml9evcgTQ206EL1Icj5NUfOiPU8yQHc7VcalTvWZBPRAiQiJTQY0zazvo9ta03AqgEAcDMWT6tQGo67JD8kI0JrTNpGYvfZqfkh0UC8qTxOmvUWpsk1Q3RMXxNacZ+OyV/7hdPq3HlLJ8b3eBwUz2Z+mtyvFslcNPajb056Xt/CxwxO4a/d+LQop1w4LddJ8JJwt2FO1zPjDn4RgICACH5BAUKAMAALAAAHgBYAFgAAAj/AIEJHEiwoMGDAusprIewocOHECNKJFjvG7VmxYIxowYO3sSPIENC3MZMmMmTzKaBYyiypUuJ4Eoye3bt2rRiwooVu+bxpc+fA+tdE8bsG0F210oKo4YOqFOX6J4Jm8aSILhnAIpNa/q068RvJrUhZEct5zN2XtMCY+dNmzZv38yxBGfSW0N41HQ+46oW6NViAADkbMaxHjuT2xziNTkNLUJz22p6q9q3YL1xSpkxw5lT6zdmwag9XDyVMrB65qZt5vxsXGWD9cruHDfum7abJnUKa+a4IbtpJq9RBtfsZLCTZ18TRFd8Wk+B8MABz5kz8cOo1QfCK56TozepWpUP//yGUyxsb9ynPm84rngxcGu5PzM3EB0zwesrxxRm/iC6vDnZBZE3OD1D2l4FYQWAUeK1t5RpBMFzDWDM9OZQWbsB1oxrBWkjTDDXiCcQcMxwiJBQwgBADYQGsSMVAMf1R9A2wYkIzDY4haiYVMwI6FBF9xGVn0A0CqOjeC4Shc4//vjTzz9QEjQOj9b9iBV/CGmDU5XikQfMWU4+CeWYAu3HnznebIPWP8CM+Q9zSiJETWAmKtePUMAsBc8//fTZJ5T+CKTlYMVs2OaY/vxD4IMIcTdkX3zCA55oTYYJqJP1DBrgoYj6E2IxDBoET0bNsOgVPOOA8w04RRajDUt/8v+J6YREmZcolH3CMw0wvPVz0FBGNqiaTsWUhNNOz7mp6LGvcppooJiV5qtAbAIjaVah9vVZbnkGc1yKS1kIJXx59odrk6ddc9w2TVZbX3HN8KXWtVrVVBM1zwAm2FYFAfdlPWwquxaGxbBDJkXAgfqaOSZRA8+t/hg2Tl6CPUMuMOQRNY6ygMZG6jeVBtohTrt6hWs/3wi2pMACIbVZUYaB96qYbgKjLgCNAdOPk+4SpJSpLSkroMEnT5vQONo00xp5wTTGMZPsgMYMV00++atJ2fo05s7+0HejrCGLik5sOXHIMTCDVslzzwPRFaxTykYsFW+VPml1iziJRlDNZTn/N9DaB5lT0lmPgsQyMAQW4/DaB1tV7MXUkpmXjDQf5GJWz9C0TeER1aydbJSeTZCWDhfENzNeRx6lZbidZFadH3len1RTuYar5/9oA7PpZE7M++oDuVjoM9NQMw13M4nkptECmUN7M4k9PS6XA3me3+HAoPPWOD1dBqAwQTdeX146TfMNPPXcKqbIBsn+u/gneugS9tAlDW4z12zzzdjwV9+///9rSDPCh6uCwIMkrstNM5wDPAAGUHUNhFSnEoIeYmmGGUp7BjXGkaiDiK4h0mMeS/T2Ej4BikmD0oo2wAGOcdCHT3drn/sQIj0YHpAaPvrJzpj0j6hlZXOUAVSf/2hIJrbJkGNNikpGmEG9lyTqSWLpEYSYFDH27e2BBbGbEPsBj280wxhgNEkwfiIrE4rmLBGEIfMI4qc10vCJfBrIhIAhjWxkA4xjBIY7lLc1XIWoRIzjVAQH0sbOiU9LYOwGOdqRDWkYQyDiCIn0/GEf8LFjh08j4iAjkqligFEa7YhHPMrBDWkQcHmAopX5APbBIxoxIt4AjTGyQY53vEOU7SDHKY1IlmM9Y4XwYSELt7ENeUXOjRCxDxiz0Y122FKU8WiHKSUZwEzRznV5cl0zUkfIkOjqGMaoxiJteUtodkMaxzAc/QZiDptkxFvACIZgctOan+DIGNLgBjnJCf9NRk5zIuu0DDzYQdCCwgMdEyrUNoCmHRbBoyT5rOU+nxmPd5DjjurE4hXdJaFjXcOYBjTfr8CZDW44c6LQfEcuq/FPQwa0fZZB4G60YaEZvccgmDmGNBTJT2j2U5TlaGTsMgmSy9zkOCnZHzoK6qCaxmaZiyQIRXHZz26kE6A1LOo28nWSYl1QJqbBDD6b2Y6CTLWctyTHVbFaw5dG6Bu4gZG3BBOeDoFPGrV8CFpVutahtnWTJ/rGNYyXubwZ5Bk65alEbEmOlmZUeiGhTEmwURB0pJOWIFHp/CD7k3pkhIQMsY4iQxKPXQLWJXNbD2XpmA2R6JKaGm0JsCCnt8T/lkNEbn1JtJpBrnqA4xpSSexrXzNDp/hqUBvRhk2AkRWT1PG2DSmt1jQa242Shlt5mkkxdFqNslYmoJyFCJngkbTVFIMm5jggM4xxjGZ+969/fUjjLrOqlcDQH+gBwCyhqxb4+teVbOsTz/7kD+J8shv8Pcg7NuvfBreyTbG6lD9cBM6dDlfB3uUjUTfq4PdR8VkTzgs+MWsjhzi4gW1tElmEAUZuRLXE4gUwh5/WpHqgZ8TdgPEuZxy3Z3mRxTvVMWwP5l8BU3jE3BCyX08sYCexAxuenOWFlSzf+CqLZjXWnTCOQcsMU9nE4YXg1hLl2+Lg06RfdilgOfakGqPjdSZjfXGayXjlRD15u3XM8ZzhhkR4xBLI1eBGggXi5T1LxE01rsebPXmMQBfa0Kd8FnkzMtayShfSDEbUVVjM5SRjms4nkxBELfxpUNf4KgfWc6l9EjLyMkMgj1w1UKjo25LJuitNIpBAlHHrXvv61z/BL0ICAgAh+QQFCgDAACwIAA0AqABwAAAI/wCBCRxIsKDBgwgTGoSnbZpDbfAUSpxIsaLFixgzagRW79u1j9rG1StYz1sxAMKEoWS2LeLGlzBjypx5EB62YikBBCt2jR3Bcc2EFXtGFGcxaiNpKl3KtGm9aymFFsMp7Nk4gfWoCYUIjx1QodeSNh1LtuzEcTifefNpjlqxYFaBmcNJrSC7aUK3md3Ldy9UYVcHPsU5jWFKcAbRPRPGzFzfx5BnPgvGTKxAeNemXlvczGVBtMKmWY5MurREZgCajQYGD29U0QgzF0NsurbtgpNVHzTHLJjvugjNBaXm+bZx0pOLFSe4DScA4Ai1MaZ9vPrjv8sHtlYJ/SA6ZsKuWf8fz/dbSm8JTQKYJlGrcvLwZ9Zjx85cRHTNirFHWC9osdU/TaVXfARmVA84mzHDzDQh4dUMOglJF4xPCcETFGwFZkjRNuDlFExVvRWDHkLjpDRgQtdQBqGGLAaH04LUUBOUMB+Glt1l4O2X0DcCtuhjQdIVs01SDHW4E3UkURNMM44lhJ8wSP3Y4j9U4vWMZ/UcuBhd6eGkjUL1WEmhlPFRaaY/i+lIkE1UBbbQZM98Aw46AAbZHZnjmUklmsAU9o9Bgx1lGZHTTDXVM2MSBM6LeMKn557ALAlPP/38SdBd05H0zTNUFdPMkDXhFEyjeeo5kHnCfOOPmXalKdY4rlH/Nk1LCdVzEgCkWveodoTVYypBwhUTGFAoVQUOgARJBwCuuR7360BuFfNNpaxeGiMw3vRG2TU3FsRjjc0+9mi1zwo0DnjPALMrQfWYky0AQyHppH/PMBMuX+PmSyVJsiHlz6r7AtthT/5QamlNrlGz4r1k6euwQexMFp6vz8Kz5TUAl3sZrCldybBZDj8MzzjfaKPNYvBqQzGl/XCUGUsUj6udN4X6xsw3H4Ncrr79tNYMajr5xhi3//ozUsQ3xywza9N0uFVSyOYMk8YCjRvmh8w0o7XWVDHjja+rokPNOBkPpGe7MzZzDTjwRC21TFSbbeY3OY7TFX3jbCOjUP7+/7Pqv5UWZKbFfCf6dsNxV03lNpkCyg442nBbacYHy/0POCmpfHhfiSv+JTNuHlQPPAWvKziVWom3OefVJvQPesVQlO9BZj6D4ep7mR5cM312S5Duv1NpH+74qtu5QJkBE1bcwFteOUXaHEO8RksjZKEwysPTevDbE8Ty8xNJOH1G1R8ETrrANAMRQok3D6aSxdg7vkQhgw+seCmpLRL3ARt0/EERq0qT5se++lnqeVSqxzZmxBgGNcl97iPRZt7CjGssjID8q5//zqQlpw0FHe3730Ai9rO3fKgZOMOg8wxYuaUdaIIf0ga17Ge87ilkZN/Q22IYIz8V6u5hiuvefP94VBWKKUSEokNHZnyjwiDSsIYhkwio6GdDi0CliU48YhRpx5vUGI52VawIXrAIRdmV73dZks7EqNg/Mm4kghtso0H64Y/tCImNYXSjGfPIvyMa7VyMCV0cz6jHiRBykFr0BzCasyR5rVBPBSvkRQ7ZR9cdLFtbWU4dJ0W5f/TjKZK0CCUVJzuCEPEoSPrGNMZBxyD2Axw9DKUh9UU7jWwqJcwYG0OGshqj3UmWeKRlTDDTG6EE5WbAnAkLZVKPcbglJcG4HbDUlExLGlAp7UINMxz5yqBUc5bCbEqJwlMQOn4Fe9+0JhJjgo2UXPBf5xxVOgvIx6UsxmPq+hc4eAf/jFjO83RyNEszojmSolnoGMfIRjWk8U8wBrQsuYnIv7IiDGNIox3cYGhDAfrQsaRIGEPym3qMUY14lCMbGx1kR5cyl6qQrR7aYMYxSJpSerLwiRcJ04um4Q1vbAOhxmhHTR16U5rUZVm+EZoxuiFUgcRuqE68ZkzqeA3wJFVo0ujGQIwB1QxqkIoOHd02TGayaSA0G+To6iRHWUMwFq1oVMKPRbWqVlHOzqGDnOGZrmFRlNbVrjeVY8j+9Q92FMOif8VIYBGYr7f+CxvGWGpTE1uRZXIUko4FijHQSlnyAdGre3KsP6In2c6Sj3uXxaxj2dEMi3LDtC951p8cJtp//0lHGn6FLfW2R9vaWgixut1tGwcrWpgelqnBVey6bsqyfgRQGuSIBzBem1xwLlZfJtlsWqtb2es2lnDSoC539+hdM9HRPBad7HitO1wDGm0awSjtemPiXn+cy6LbFYg45ivckD1lpnTVKH/76zB29Ca8A6Zv/WAKgGNAN8FTq19rACxeCBP4Ua9kBn4Fgk4LK1dfTxFGQrfqYc82tj/BwG2JY/uot3qDRtJ4x4rfqNp/wEMrx6hGfmf8YceaYzHHQC6PPSvab3yoGhUeMmA5CJUNA+MdMlZyd/UUwBFL2cRU6se5EJrWKF95yf4wSYpfm+QvU5FS/3WtmRVLx9HhBS64a75I0SIW55cYDRt1fgksBUKMPF9EkH4ONFm08VRBG/rQiE60ohfN6OPAIyAAACH5BAUKAMAALBIADQBGAGkAAAj/AIEJHEiwoMGDCAv+W8jwX8KHECMabNhQIUWKEjNqHHixIseOHjeKRAjSY0mMI1MSvAiMZUiBKFWqfHly4kuZG2+WPBgTp0Z/DG2y5BnU50Z/9cBp07YN3cqeFosalfitGTBhwooxmzbuo1SiC6dKBMdMoFZmWJlpgwcM6FehDsU+rDetGDBqwMaNu8YsWDFq9dq+hWu0nrlt1KhdAwePYVK01+r5GzhuGtbIDP1NTnhzZL1rxbAKCyZs2rd6krUJYzauX1iB7OoW0yb5X79+D6GK1FaMdLNmxQCsXvtZILx6rwWiq8vsm2Z/uHMP1oiumbBnTttqAx7sWWVgzWon/wfGrhmAZuz+QYfYWeO3YsW2cfRnjlrwZ826ux0PzFtowMjFRVJ7Em2zWlcwhQWaaM8EyN9nWjnHn0VIbTaSgax59U89qmHVDDpQofOMMB+61p56/nyj0nvNcWQiedRgFd9QA20T2jX7TdgSUtOoNI512ngVXWxZAabbiMCYg1I98DRZGzvPqATPiNOw1ZJU5uT34ZVSaQaOXTi+Zo42z/RWjDPeGGaVStdkhWBI9RhYjDcJvmYiXSRmFyd3AAgXjFo/ygQPWj3WKeCgADRYJ5fqkVVMZPAs6Ndv1gHDzDVrsonVmyGpFgydhjYEzzTBNGOOZVlxZVyUKSX1zTfgmP9jDlqAMfoaO2g9Y6WtcXmD1YhYUWNlo30xY5dEHBoLH3zKzhaYiUHF+R871O5HEDzWAeBXraJexUymENmY1bdoiVbqOJqxBI99JP6WHn/X9PkocjmOmtU1Eg2q1TbjmAMOX6NhNY1k6WYGjGrCzTvhNH0+8y60/0B5oETjYKUiQfV4w6owmN3GEDzYhLZamgISNI6Z5uTIEFnXsXPxQ9uQxs5EkaLFzDYE21YPXqmCk9DOl9Go2jH4UqXtzBYFNmIzPg+0IMe7HjROru9KVc+IxTQdETuhBRmVP/aiJ5CN8BWd0Kha+fzWN8IkGhiypDYTNaPk8RXZ1PfOXRA7bRb/MzCXGAPrdUa+CjO4objVM443Ev/19kEZA5cV0vzxdp3eD0ncDIIaxgWh4z8vWMwzh2OcpV9pGjQOqwd92fJTFYFjncMwh6YW0pB/c0xpmNMHbkGWP2MO7Av5Y+PmD+HNdESn025RP8sh9BlazYBqK11zQmRZ1vkuPXxU/WBuHGhaWc/l1ZG5Bbl1kSEbY4adI/W4QIqTKXJWpLPzOGrivVXP6xnRxu5eVrDiyW8gNSONaGSklWt8j1cPqt5GxPUywWRGM1MCBodE1oxpUMOD0wAOfBTVOf6gY34RMZAwKgg7fwTqG4QaBwolQqCMoCNGfwEH7gwCD/kcbDVaE4lu/5Blv2AosBlmKwg1WNUm5KWERu4xFjPKFBrSpBA+PnxiDeViMuuYSiZD5GJByOc8LU5HjASJ0WquMQ7xsUc3OvJJzdIyjWtswxwzlA5N4miU+ohwXMz41jSCyJmTlAyN6ECM5LLyKzcSD4oHKUthzPGNbVxjiVmhDQ1BArkkchE1jctiRCApkNWh0SDmCA33MtKZHp4SIeJqBgsLyZ91HeuVGNtgJh1pKIJIDBjHwKVBdOk3zl1rGzMLyeqEIcyfaaNczKBGdujHF6d4RGLGkAY3momQU/UGf/xCR5tYtRDXAGNKxjiGNLpRDm4ipIeokhF3QFXODcXoGMcoRzzi4f9O6cHjG9RQlocoVzz/ZLMb+9xnPx/yz4AKo1Yw6Ud5gGGMbOjzHe9Q6EIT4h/DKQQYdrFoPDCaUX5uFJarYSFZskmOdpD0pSc9iGqYEcQpCeMY1XDpS0kaU4PISZRfCoY2dbrTd/S0IHibBu7alM1stGOkJS3pUZWIFU0CAzHMYOlTS5pQjU4VHXRkyiWZgU+RcrWrU62RdRQ4GiMKo6L63OdZjZrWpNTlpjJ6RlbXKdeuejWt8BhHJb3xjXGww0bZ1KlcMWrStD6kTcLIBjmiClXHQkRi0pDsYuOhU8sm5EfZ5MZTR8pZnrbTswV5z0EvitHOonaY1zhGaKH6DtfavrYgo5KtRRm72NuickTa7CpJG+vbUhbjoOQgB22JW9yrFkOd3VAuSdtBDmA295yxxSk3EsrT6xpnGup0qnDpCgxnNHdK0J0sbavr3SQ946AZhWl7gaFaY1SjpdMVSDCv+8zViFa+7Y3Uc6Uh3YzO1zjUOEYx1ulS6jL3vGXKbEvbsdUDn0q35XiqSw9MnmkYI5s5HelAOHvdemCTrxjlsHuDkdjuHlhikWUtMLrx4mcI1am1Ze+BV3dQ6mZDxcBYzlvTCeTvvrXIAyGSQIZR5FkiGcnekGRBAgIAIfkEBQoAwAAsAAAVAFMAYQAACP8AgQkcSLCgwYMID/5byDChw4cQI0pUyLDiv4kYM2qkaNHixo8gHXYceTGkyYckB3YkuPKky4IkGwKraLDly5cxU9akedOlR4ExE/7sGZKnypEijRLdqBSoTY4Ll4Js6nQo1JJSM1KtKhOh1awSt3KNKnRrRX9gWYqduZYrTIv+0KZ167UtW5kk49abexfrVZQ5F/br96+fOb5t7QYW2M9fYXbPiC6u25XyU3+D6027Gbiy2qefvy50fI1zZ79vQR+lyrDfOJynyV6VnZr2UcdyTzbVGdpz77r+6tXz5tN338pILaNWG9e07dVdkyun3Bz289/HARuvWr349rGqey//55obpLlrz5qpn6ZtHLyko+OX/Yp9415wz4TpFxZMGLBizbS3l1dxxQXPOOB8Mw474o133HUTwZOfMM9MY2Ez/hUjDDPXvKdQY/BsMw0zGjLzzGHgzfedRNoIU8w1wtUDDzzobPOMhhR6M6Ba9VyjIQD98dcMOMAMtuJYIcEzDYUeDtRYPd/cGEwx06DD3Dc4PkMNNRgK0ww6hREWEX0YQSYMNTsOVE9w7GjDjH7PvOaUmWcyWA84XWrTWHnwQSiRhGfuOFqBwY1DjYbFoHmRP4cySdA4+jGzZj8T2fWQZgA8w2BfhOq1DY7UWGkOhswQSVA9zABQjDmUVnokRC0W//PNg3sSimd/05jjjX7TpCnQNAAI8w2f2jloUD26eqOsguyYo2Ez9YQHDDzU8Geii9sc1KIwxLn6T4GtJsTONW/u56KWOG4TrZ8CUYvjhigWtG22Y561JrIJ1XNjMfy+y99+mhJm7EDwYIMjtNrqV1q9FdUzzogJbTuNN+Cwg8443oxobpxiRqRNMMFgg9C2Cy+lL4VWFnSgNhMG8ww60UbkDcjajKxfzVKZ8ybOB9XDzjblPgOOY7Dq161B2x5N1Dg7Q8TOkgAwsw08T8KcsDByGlStMPQuBeg0TYq7daLooEONpkQTdA3I8Ra0djDNtN3T1krnu02XwDADzDPrCv+GFjUgh00QO1uDLRU8bzKT9UOG4liMN5i1tuY1+gk++ISzSqUNv3H+CTiV8BTGUHDoTGg5QeBoyPdD/tQdETw+Ari4uBjGvVo/1Lqoja9au+gNPOzMKHhwm2nUY4m/P0S5MMUX1M+swmDDu0HgJJ5eMxVOzVZczXxUj5suTrPpQex0aapBSzLDDrEG0Wlu+OgUCE/33n/TZTHapFzQp44epKE238KMQ2JnomucrVxxWxM79KaRnxmwZRTaxvgE4iOuIQQe/RlHADsGk3EUg0Pf8BA8vJEfYMBIRvRbx5/Q469/nUsb8NiLkjY0u4Ggw0Xxixxy/qGNaYzDV3dqRjD/1BecyADDdeSbEICewcQmNgNHUkMWhgx3EHN46T0Cy8lBMrM2AGwjLiKTyPf4NTFzCG9G7BjHNq4xDfW0503UyFczqNgZg8RlMJAKxjWCIzeHzPBlDpER8OABDt055Bswgo501BTDf7CDP9P4Vj3iGBF0YIiSEvnGhvR3QeU851DUMCN/nlGgcTgjImbq1fQOokkjTsUzOzqGM6oVDGcUqB6fgkiPNnQ+iDCtZB9pyuaAcQxjBIlC7BBOcHwEkW+86UQSeVoNtVKZ6gFDGsDIhjSkcYxjbOga30gmLhmYENjBCRyrLMgEg9kVzQikGu0ABjm6wU1hGMMYxXiGNswB/yX6lXNsoUync8iyDf9koxzxiIdAyDFPaRhjP8VwBjaA9pBxlYsZ1NiGe9JylvIVkxvkeMc7FCqQdpSjG9rs5j2PUQyIwMN+jsMee6hhoWl0TTejOZ4xpNGOeIiUpAVBaTWKacw/2ehNIDsmM8TXk9Ew7ZrdaIdIf5qQeWbDGBiB3buWeg10SuYfPQKGMbJBDqmONKEOaUc3MDIcBObvdD3RkDS64dOzotUh5JjIOL8JV6Jso5hk/WlCB3vXg8QzIqPyUub4AoxpFLMbISWsZE8Sq28I9CV7YYczihlSu0q2sMB4h0aqhTCv8c6ZOyXHZ+s6VdGChHLqu9SMshpKpP/Zsxqq/WxrRRoSb/CLGusUiM8yxoyl9hEh1VvsQLARjLH2VLe7de1GchdBcFg3QT3EkIb68yKvOqSgNwXGJO0ZVehGV7oaoe6GissvYagqfE+MFHs2WpA75Ydn7ZrGThGa0OeydqqDHan3vPHEfvGLGc2gRjhjGKWtAqimFwKVOvPD08G247nRnSxIXqosb2xDQbwL0TRwBKSkgkw/AMhUQSwpjGNUg78BznCAGdsuNWoMxVN6BnoA0IwJstie2eBGOTAs44Sil8bCPVaLmKE0JfGrudLIBmTNulvCjvTISDYI05gXtm9oA0PN3WlUq7xaoGa5Z1vTlHDBMWJvElW/zDAGcIx5e+aDAOqbNHUcNh623ShHlcp23W2dDzKOCb3vGeqaVsY0dE8pA/q8BDHzmdtEIhIFaJ0jdAajtwnZ3EJaIJKuM7KAt0oZ2ciex/BzWf9L1UGHpE35AUCjIVtmV5tkhPG951xBqltbJ4mEGkp1Nsi66hn7GiTsIKF+uuln/2L52Bm5042N4WIhPxfaJrkTl7y5U1Vj+yT1qNGbAFDMKH8bs2x+0zHO3RMo9ZCc7H7JgeJN73rbG7MECQgAIfkEBQoAwAAsAAAeAFgAWAAACP8AgQkcSLCgwYMC6ymsh7Chw4cQI0okWO8btWbFgjGjBg7exI8gQ0LcxkyYyZPMpoETybLlR3AlmT27dm1ayWLMrnl0ybPnwHrYhDH7RpDdtZIAppnzybSluWbCpjEsCK5ZsKjsmmr9+M2kNoTsqJl8lnWrWXjetGnb9m2pwK7CvDWEJ1bYM3RmtYJ7VsxksGLNONYbZ3KbQ7omp5U1OFgbzW9T8yI011cos2IZhRWb9o0ZAGoPEdtdPHDctMpjx0k+WI/aX47jvmk7bRKzsGakD8KbZvJaZGDfoAoDcDLY3dUFn2IlCA8c72AA/hp+iO6Z5unA0AkvRu3bNuHTkBP//Nb3K2Nv1hPvdKic2Up2fO3iFWjOs7D1yGEKM39wXN1ickHkTV/PwBOUXW4N9AwAABAlHjBPffZbQfBcI0wwzeDXEG/FxNeMagVpcyF/yLUmVIKsXdMXNRMyVt1VXv000Da9PSiQN8Nd8xA7HGLnkDfMQMeMhgLRKIyONsL3lzn99PPPk08SNA5UQ0FUT3okErRNMMFkKV4xwEyDjj9QlvmPQOBkVIw243izzWJlaocTigRd8xeID/pTj47CAAOPmWUKpKJmUH0IjJn9DHhkiwIJR6RkT+6GGYtPOlmmk/VoUxmAh5q5JzDMzNVXM4xuBc844HwDjpFr7oToP5n2/8XMdGQ+6Y8/uwGT4ZkGWSgMaOKZdhlmxUSnGTaumjmgRtowdKk/wIxTklS8HioQPM9c5eBqnZ0EzIVXQffrepWu9G2zApUJ7Z6F+eNkQdXdhmde2AKwGU00YZNeYvNdax0wz9QDraVRGljbmGQWVA+H2+ZF2bju/tNPPez4V5JdeCrq3j+1ltkagd/c6q7CIgYT3lZlfkMcOoAOFBZGVcJ3XT2AnmmhyVnd+q5BFz/akpkOstPyQKdq88wzsWWkGMFQ9oNOTPPdGmWvJjXME6BubVOzwvCgY6Iw5tasqTDYRVytlJoB65OZuPLGDDtMT03higUFKtY065l90NMdsv8DT6kTmZmQotTA0zGUBnXlXt2IU1OMj4EahK1mR2Pjjc8RRZ6QWNwBQybTBdFYOONRUsNMv53K/ZPjJhEnlKEiae6vSdQs5S7oh2qzOOlnjoMN7wXJ3Mw0xE+z3TOxyx5tes1sI3DN/4CDLvB+8n42Otp4Y85Og7HeZ/KqA1MPOqx3ePnzUOqJkPIDDZ0QazT+zH6mSN2GjTbfsENz+O0jvj77CAmGS5rWDwqR5CQn6VDhJGYQ9x1EcOKplM4S8g2+YIYZGGxGM55BjXEkrIEQbAj0zsYQfwDLRyCpVD9Eto2+bEYb4ADHOJYCwNTxD4SAIpM/0LENagTIJ3pSiD//2AGVVv0Gdzg8mwhrJrCnFIsZP+xJmUQEoBat0EkFTKJE2NakegDJGMY4hma+N8AmWQo0zUDHztpnxv/dMIkMFIimgCGNalQjjN9zB/gkZikdMWMcglNhFrUIEdlp6hjG6EY52pENaRhDIOIIyQjrM5paNYmPa6QeSGIlDGNIox3xiAc5uCENltRshbeyU1Qgc7g32lAkQAqGMapRjlDG4x2iNCX7wuLCZ7BpHMAMpptQJxBLheRpYMxGN9rxjmbish2llKT/GKMNjPjFJN86CQBgRxAlRmQ3iKwGOchxy2aCMh6NlGYN0VET1GSzdRjryYA8yQ1bNtOWoszGIz8S/0KEUAweAA0oPIwyKudB5G+6aQY9yelMXNqyHeTQZwpraBBjJqRkxbiG1+aikoNcA5HZWGRDHfpQclQjmlt0oAhJ5sJmaMNnmpoXfZhxDGl0gxy4HOk5bVmOdAZua5s0TWU2so1xsOOoFYOKhoACUnK0gyDO3OlDu3EMfo5wk9vYl6w02IyYGERanlxmPAziTHzikhxVteoI+wkWb9BmOMainEFENEtyPkSnaZ3oWl15EHPM5mjpUZuCarrMiTSTHChVJ/R4UhIkDQQdfQrpOz7yjqfqEqg9KZbaGBK/kIZkrHucJlOskyGCAMumIiFHaPNyIHMJBFg15UY5bMRWpv9I6zbm8gc4qGGdMCryQRR1SQHHthHHhMcvwZBGSC0LKdE+kK84pEtfoiPAb3WoGDXNBnPzUlsbBrebUcoURojVjGtsjyRhVW1z97rWh0zzVDLsiJ5udcBjVIMbq2GvfuFYkCbd7lYKqQoYbapes+j3wIsFb6U4pkP4IJLA+U2wghFsPQbbipeerIaNMofgs9WsVrciXycT6dQNb5G//RshgHUnDOUW1sSrTfFa61EVWUpDtrOFsVr9d+BbwacYnswGfnW84w6nT7rJLDCROdzeEa4QHiw2RjaUvGT3SjhdH9aTgOm53So7pLvelaCPp/HgmwpkrKD1svwuFSls9MVwxWrWSg5xBSRhHMO+sh3IZM8cZ8U2zRynufN97QqMNPcZfGasB5T7EtYuH1p+EVuhOdJzDGXm+NFXu1SFSuLiclAZ0+ADcAUfnI1sgJopItPTdwSyz1OvjWMVOZmrt3KrAQlEGbPOta53rRVoISQgAAAh+QQFCgDAACwGAA0AUgBpAAAI/wCBCRxIsKDBgwgTIoSnbZpDbfAUSpxIsWK9b9cyahtXr2A9b8UACBMmktm2iBVTqpQID1uxkQCCFbvGjuC4ZsKKPdv5shi1jiuDCq13bWTOYi+FPRsnsB61nBDhsbuZ8xpQoVgpjnv5zFtNc9SKBVsKzNxLagXZTcu5LatbiUWFMR1I9OU0hiPBGUT3TBgzc28DG3wWjNlVgfCuIb3WtxnKgluFTTss+C0zAM0oA4O31uhkhIqL6a0smHDmg+aYBVuNFqE5nNQek85KuJhsgtteAmiNUJvf0bOzxr09kDNJ3gfRMRN2LbjbbyO9JQQJYJrEp7adW2THzlxEdM2KWf9HWA9nMc02kbbVrrAeOMbMmE3buLYZuoS+g9VMCA/nZ/YIbbMcTMEopVox0iE0zkjrJXRNYfcBaJBZfk1DDTU4CVOgZMQhttx4CX2jnoQG+VbMNkAxNKBMwHlETTDNAJYQeML8RCIw/+S41jOP1eNeX2dN95I27e24n3Y5JulPXyAS1FJScxkED2HPfAMOOuiZiFxwSea4JDB3/WNQXT4dluI0SCH1zJEEgfMSM+x16SUwMMLTTz9iEqTWbx5980xSxTSD4kHwvBQMkl0OBJ0w3/iTZFpMXjVOZ4VNc1JC9YQEAKKPImZXPYkS9Foxc90kklLgoEdQfps6F+pAYRX/8w2enQ7EzoXAeKNaYdd0WJCIG2YlZ44DvSrQOMs9g6OxwNRjjq4A6NTijOY9A6dQw2ZLLEFk/uSPo9sOlNpINPlzZ56EdkZNhEFpq61B7BDGHKivTlkVuMxuNulIPGLlrrv6fqONNn1FS2SOd/bTrGIm0fvPueHC4w2aqzHzjbDGatsPZ81cFtNqfvX6rT8dxWuxw+aGytmAUAGlqkL5LttlPdMUyEwzOOOcFDPegOooOtSMkzK6tP7jbIbNXAMOPC9TFLNAXX7z4ThScTfONhjm5O0/jn6LZ0FJ2usTm27JmVCS2/A5JjvgaNMrnviiW2yO4IykTdMrmX32P0Qy/xPlQfXAM3StBD3KnKuEH/RPghUNq3iOz/w3m94JyXjXRJSDnaN3rsocLmgCWRVz5oUnPpE2xzROekH9CQNMr6Z7LjdBCc9+uoaqPy0QOMoC0wxEj8cuu0pOyXRt8O9W3txISXNUuvC6IxSvUjIa9C/0Rm+TYYXayPj06gmNw5hYzFzD7tzXfw61ksDwzrJO6HwfvZ7PdCxWgc1cjH76nzve7Ht/KpA2ioYQ8C1kHN/AWl/8crzMAWx9iasHO0SkFHrtTXgSqQc6FLOa/V3wUf5LyKAkMj+FFOV5tkNhtgqYGsyQDXlZWQsKMbdC8tTDN/MiIQbbVUIIpnAg/fCHcf9OpEMDqiSEMNsh1+qBLL/8zXrJw1gJozen3MBoWvuTk7negsTg6XAguoLKbYRop7g9jChc7OLzMEcQCvqkRd+YxjiCCMF+gON4/nog2ITip5EwI2gM0YlmSLYlKUbRLYlRTU5wYrGEFKMy/AsME8MykmBITlRNMuS/SOOsyzADi3bESejKpsfgLOhwtPMHVVyHLWLVUELYGEmExPStVR4qjTucTV/6haNvgUOUeDTkjQbSDEt2ZGT9OcYxslENaQSmh5UxTUS+5RRhGEMa7eCGM3GpPgA9SBgo4hp1jFGNeJQjG4JRo3MotBSSaYMZxyBnPEjDP2hmEE0V8oY3tqH/TGNwqZ7dxApaAPAxkBmjG+34Zz0DI8RrLGc1EBWGNLrBqUh+EYpGg8c2BjawaSgzG+QYZhYxGDsvjexbOQLPNSkqUh/Kz3ZdKpqSrnFNdLbUpRYdaZdQyo5iXDOhN8VpKYXKtZP6AxvGOChQgyq7QxLVqKpshjFAylSMqlFbUPUH6pRa1STOzl1ZZYdUpcGNrl6wWE1VUlZ9Iw2bmtWqKtxpVvtzzbfCUKdqNeoNfYpQu8aVqMNKWD+mJw1yzLOsdgVo+kAy1ZD6FbCKFWJfyPpYvCo2iND5aWVHGtdskaxmXN1sEcGqSmZc07Gi9eq/iBJPlm4ztchzFztUQ1nYq6pWWzcEwDEKO5De2bazcuJMaxH729gG9o6nLe5t5UQUYSzTsf5UruY8W55gtFW6HzTpt7yhIWm8A7sfHNk/4PGUY1QDteCdrlHN0Zdj9DW9UITqNwpUDeLCN64kK0pygfGO794Xp9Nb5lL/i9N+IEuZ6CXw/vwBEuuW1b4KRlg/WHtNCCsYR0EM3FrqemGDjCxeHVYIybARYoXcUSDEKDFkVMzilGjjkQYJCAAh+QQFCgDAACwSAA0ARgBnAAAI/wCBCRxIsKDBgwgL/lvI8F/ChxAjGmzYUCFFihIzahx4sSLHjh43ikQI0mNJjCNTErwIjGVIgShVqnx5cuJLmRsZ9rPY8WBMnBr/9RNqk6VPhkBF+oP3bZu2beZW/uS5MKlGcM2ACdta7Bm4ejBvUrUqcRwzgcWYMQMQrNg1di3FSq1K9iG8acKAUQM2btw1Zm2pgZU71yHQeuy8UaN2DRy8hf36gWMmTLBhvngr12u4MyFhjfX+bhUWTNi0b/X8+duWdtzQy+ymFSumDV5kf51JfpbIunSzZsUACGN2DV5oYM3g+aMrEB1eZt+WM9c9XeS4ZsKeoRPoTxvwYM3GTf8D9kw10oHssDdDJx3ibojehBXbxtHfOGqzn6mfyhqA5epUXSbSNgAwAw5HkQFzzWxbJXdTPdTIFx2AUvmTmkrbDDcOgsvVo00xWzHDjnTVofOMMM2wY1RB/aj2jUrxQffRcsCExpU3JFb3DYja5CjgQKrVM15KZtH2EV13bXXNZmKdCAw7r9FVDzxUpuYPO8+odFcw08ATlpTXoRhVlJctN04xCrYHjDnanCjfM9vUY05WKmkj34ZxTfehMN4IFCVMyyXZTFQCbYNdacEAUKA2c8rEDmVZfnkZPJQ1A1aeeUa2ozDXAAPPgiAW8xszIDZzDZ0ZXTrQNVvhGZOdfB7/yZBqgt4X6jR4whOpMyLBA84334BjjlnBCJbneemJup2k//hTaH6jFQfoN5SRmqo2pM42m1ptaTMYSqxVxg46I54n0KOkBfbtQkkyE2lE4aal1mi+meNjVfBQQ6p+KZorEDbCAODWYy0ylKRbEtVTrTfjmAPOqVuVNk1qFOEGTLjyLQlgZs88dhGWbWEV0TfBBPMiQfX0KZAw2DA566cgDudNPbkNVM+Z8rHX0WSmeQnvVnAVtNRfBcbZEITACIdrQjZyqhqJA8HaqUTfbEWoVDefyAyeAi24FTY+I4RVMdOo2Cxz8DjTlsoRwcNjUYjJlpxAH7YlbUK6Dndgi84S/1R1dmCpyjRec8/lLDsLLmlWxmEf5BeIEwPzNEG6HnOMNhvFN5/gkS3kbD2/Yjlb2UxvQ9mdfvYtkIcgdrzRXaJy7WeLLdbIejHUNF7Qp1xNQx9Cc8rHNkEmJsTzM0HPjltVYSL/UH/z6V4QOFs5b5A/jR50+zOyq/Zadxo+dJ2oB0I0ZzDWrzSUcwiFVirbTw8lZDEnJzRNgeVDJOiyc/Uj/UC8G079JCe/aXjLXzZby+8iAqFgbK0wzaqH4DzlF+DIpy3P0AY7LoWb1LwmMjWrUc80sqf6XSRIqkJczEYzmrRcwxyXAolBnjHAiJQQgk/TVdcChqJnLIYa07BgV/8E1xPiTRAiNzxKs64DjE1N42o5QSBo6oGOCLllHBtECDx+ZycDzeQ97TNUC7syNYNQI1IL0s4XwWgQaqXFgi2ECGvmI5OpjMQcQ5KIOSDFv5HYsS4G8dCb/peRPwISZbJx4TgI6R47UggonzodM6ZxjW2g44gPWRGmDikQPJKKK2pRi1ckcpJHkgUd2ggiiBK1lS6RsiSc1J7DtnGNM87GW68sYkGOE0uB6GptQTHku3q5plDVMJNSrMcCiTmQcDXjmNT5Ub7QxMyC1I02jETQdLCUl2NUE2V7Its4jrhFuAglQQIZh5O+GUiMMYMai7xUaJixHRB2hpvAkEY32Gn/EPGsEn3bGAc6roG+2SUob/nsRjv4aZAtPgNEbBFVMYKhsu/ZyBjHUGg8GBpIX+krZuAJWuf84Q3KSIMb7YjHOziKt2/oSzMDicyjgGGMbJQjHirFKUsR4o3ZLBMYO8lLNsjxjqIadSDS2GnUBFgQsxhDGkQ16jvaUVSlWlNvlJvGMYxRDaqqtKhfterqLnYMOg6kp8E4KU6/+o6wijWdlCHdDoVR07VK9ahv1ctWcHkxfT2VHCm9K17Fig4QTbKS2njpMYaK06kaVaV5vRhlSiOMY6SrsjYVbGPzCrpErrIrzHgqNxr7WJ1GFh7m+IY3vPENc2yxGE+lalvBatrI+iKEVYslx1pJa9uEmEgY0hhqW9cq294G8jppHe1uiwuMchjXb7CVxk3ZytznEuQaxqjpTY1aXev6Ei/aLW1VvTuQ4KnVrmAl70DMcgx9kkO3j1XvWaPbDfgOd6HeJG9oLFcN5Q53o/L1FF6CC9jhjhcYvPKurp5aX/SSI8B8cQaD0btSCO+ovdVg61QhrKDoFniw8oVZez8MYAjvV7Re1S2Hk/RXnOq2xPL9rTE0ulkO/7a93LCvQGrrXW4yuLsBViddsxHYCnPYHCfSbnEfDGGQBbcc7WgHkzl8nacOlRzZ4PBAnGNZjGo5q3T9ckGckxdgDEPMTSxIQAAAIfkEBQoAwAAsEgALAJQAgwAACP8AgQkcSLCgwYMIEypcyLAhwX8QI0qU6LCixYsYM2psOLGjx38bQ4ocSXLhx5MeS6pcabAevHHgtmnDhu2azZvato1DB88iyp8pWQoVCc8btmfCAAQLJmypU6fChDGbpu1bT5NAs1IcytUiu2vNijUVZqysMWlozZqFWqzZNnb1EGqdG7GrXYXmrjGLahattGyAuQEenM2vsWPHorbVZi7uQH90I4O8SxlYvW3N+J7Nxo1bu3jx3okePboduW7c0B4DwFpYs2vmBPqb/a+f5KyV77KjVixY2WzdyLUbDjo06eOgh582fJjZNXizId/WmpsrumdLNwt/Z1x09+Oji5v/7twtbVS30GlPx11dYceF45AyreY5fPjvyIsXH10utTFhwBQzjTnq1WbbekG1dxBKB5mD1FndtMMdd8kpR86FEn6nH2j3xdNON9kYA4BUz9nmTz8opogighApaBBQBcEzzVJ/keMdhR5aKNxnHG7o436mFfafgOxEpyKKA7HoYpLsWaZNb8JkY6OEHXr3I44/ZkmONKsB8Aw4swFzpEAsTjbURw9tReZEAo2TmTHZWAnenFZeWaePwHwojTHBMLONdEceqKRQP63ZYkHvXSPMMdJ0Q+ejpNmJ5YYCtSNkMMV8U0+ggoI03Zl0LSgRPG9mQyWkcw43aWg+gifQcksx/+NNPSeqSNF6LLFp6HsIoXiiN0xJKSeqjxrH6n7HnRoaOdkkVsw2m6ZYppokUQsMmgnN1s+Mx0SIY37vmKbcqaQVtOGw9n0o5LNirsgmripZe22CBs0Gz17GUIkshdyZFtxpwoF2EYdzMvufrLTNWxeC8db1Iq8I+eNNMWfpm1y/3FSzJzPFMMPxMWdxQw5D7RxUcLPGZMokRP3MW2tkDR/6sLwFXQPMMdUgF66laE2zjTfffOONN9tg0wyjESIUz0LJklPNf82gs2t02nba5Eg07ypzS9OQlTN4y00zzlX+1HPOOfXUw842zjRaskEXv5NQeO1knNg0PaV44j+AWv99dUi6zuzwQfBgZww34PGMDTznzEOrP/OoU4469JS9219vExQaj1Yq7aHTN18TdNBD7/T43qGWlPWuCbGDnTSIH5caNfDko446jsMjeTuTu5M2OtM0avK+5cKtZ8rCiBWVVM9Q4016L1NX7eCiUk8QOs4EIw05BIcrjTPomC0h7udwn1w55+TjkjXbez5hpAd5qDEwi4JsFv0dYwNXtNJnZCbrCcka9rRnvs2NDFr0UEePyhEudZRsaZSrhziYERyF4IdCB7GUQBrVjQ5mAxjScAoztAGdfhSIQf5DYfW2NpABbk8/zGpGY87xmdtJiBzqyMc5yjEQdbiDHcHjoUL/wNM9zQ0EdsMxzWkKs6djUKNI0oHRRfonOOq5sIDxYNY0XKLAeJzDHuogBzcqp7uRCQR31xAeQyL1nYKUBxhxGo1A+iOkY0wjfFR0SB7TBDF0NIOAycmiNK5hNtCUw3c6RFs/6mG7kbUjh95gxgc1dy5KnktuAynMMbaDyYH4Jxh4q40UK5K6FQ7Oddrrhn7Kgw3b9Ydy5hDHNWpyjWlMo21occYtGfWXzpSjHJzrkJ1C86psAMhGcqwUiP5zDVEWyifWwxYfAwcMGaUyiXqixjY0hpao0G8pAlHLWnxTFr8AB0MW249+bsQdYJSnUd0hiBg3RiC/QYwj1tPa/xRG/7MZwe6X5chGNY5RDLFARSDkPItf9iTO/wQDAOFEC3CCWSwYduMYcSweMJx2GELak5oMyRrE6EUQRRmDm6qxn0I52MGWXuilp2kpiKQBwj0R5Cz0Md+d1kmavxDRk3uK2kdXt0L3bOWeBKnHNSimloVWgz4dxGYSKaVE1GTsqYLhJsiAsZngtIqdo+ngT+cYImF4Y6hERRRRTxKmg4CDGpnhKi+D88vPEPFY+snTTMvC1X++Y4k2FQhGsXhBSBWnUqkRxjWiqEJ85nOaEvFHUl3ijWfgCy3/mirx7ooxjZUFQAM5KTdyBNi+cIZc34qUMJe2UWM+43FoheZjIcu3gv+srRlNPWeW+DUnGIbIocEAxlL4Ug3ihGs5XCpncMC1qla1Vir1cOZJppjWyBYEHPJhVE4x5KOY/qs73e2GMYQ7IgANVynG8CqO+jPQqNSITllCVmuZAg9pTVe2swWgQOChF9+cM2B4jQd7GVrOX3bmwAfWGGiPuFA+VaMcG+Jde/lSIw3Ft3sfIguBUCdNUoJ0Zf+TUV+CwyNjJUdIZclOTRe6UJA5JaJYFRI8c8Q7IU3lGSDDbIkvDIzufOgw5nBXY/X4YX4OBIhkkcaDeaov0+ypKUtRinAXtbzlQeXFvPwLiAqjSgHTUUROnIc7sCEWRu3owqwND1eLMQ605rf/ih3+Xz2osSi3sbFOW0pMVJ4S3OQ54xnWCPQ0qLGXYzDDGYi+mTj98lTPIsYZ25iHQNwhH9/ArkeJIwdAP9MNpgT5bwGcy0G+UQyk2fU+OGKWNPbclGM4gxkCcc086JGPWtODHjh2hjhunY6iYWOXDbWfM7CxDoJMMBiIKed2OKREwnCGGwHFVH1FjZU9AsNw1dBpfuTHJdZgymfrEAc16OeMfdT63PTAxjGwcWt031ocRWsGa1rDDGwAgx4Eycc2yO0MPkUJi1u+n0RBBF2YhfrNCNFGVLIB4QuOp4mrSQo10kHrWs/jHM9whj7usY+Od3wd1ljHPCy+DWqYfBvm/7g1PdIhDnGIvNYFyQc1EANoHJcT2oIxS0E9VmpvAmMaHKa24DIyDQg1/DtLNAtfkO2NWuOD4/nYxzq2cY9ad/we9hAzPvJBj3VMQ8/k1oY7bF1xmA8kH+tIDDMCbQ1n2I8+mizGM7CxjXNso2hQAsafTih0EGPkOnA6+neWWWVhWJYZ4jB31Leuj3zgQ/Ecj/zj8zEPez/DG+YYx5OK0cpze54g9KDGYarB9rbbLy31dodA9CGQeTwJQN+IzqemiRE3wQnArGKW/ThjzGK4HBsjx4c7fL2NXUf9Ho/3uLnpsQ25s2ORtHLTMc6xdc/nYyDM51gzSh9ot0fF1elIyP82mGHH0zG270VWiOvOgnvQbEmiv8xGQcVxD47jQxw2R4yfRm6P5Hv8HpRWDN5wIo9TDxPjDOsQdYp3fQKxbzfDfWy3F1LhgAkxc8CADlQze/zEQgwhem6zIczCDST2IR2TeBzndXaEed7gDK2HENvgRPDQE9RwDVUxZ+tGDx7HgMAwQTfjDBDYfQJxDfg2EOtwDgUhDomxWLKngR2mENsQFdnWPYlzUb63D/X3gs8ADLUCRJx3EDJ3DM9DDcowDMOgDMSgDezgMevQcWa3Ds5QZz8YaNUgEOKgg+fggwUxD0jhDNADL/qUfvv1IMICX6dxGNuQD1iHY7F3OuPgMar/F3OWNQ7boAzQUInQMAxnaDOHqHgNSFA+GIfs04LAgHaIJg4GgQ1SMQ6QcX4GB2L3VRDfwAy/wT2J4y+GGHXzcAzPAA98Uw+SuA2KYm8G8WfAEw2WWImY6A3AQA0KKBDpljygGGjHAAyt1HrWcIMxNzHP8jgMA2dIJRCRtHDLdR/DUQ7/QTv0IA7GQA3RVQ/aoAzwSAyu8Yhnh2jeQAyWaIyVqAxgwQzzkHzAMA90VgykF4fPMF6meG/qhoAxlw/ukD3syHet6I3UEhcGKBYKhRo7MlUgs4vMZwzaMBvfQInISAx+EnPO8Br4CA3KUFDKEA1mGBYJyIZ6JxbAAIr9/+aPAuGGxiCMZ8d1lCYMoVQmRPZY9WAO08BUA/dSw8Elx3BrT7gN/SAj03CMLemTApEPr3YNJKk8wqAM2sAMMqmA+wAM7tA1weVqEDiNBPGCx5CQo+huX7eL0+Jhs1UP35CUi1IW2kUfTbQN+CYMf+I62lCJ0XCYxTBu+UZn04CPw9AWYFEMelFQY1eWA4F/0ygMn8h2LFgQouePJXeI7jZzUVOXdsmBAwEP4KANR5MYTcUn1MB8evcPblKYyuAxt/kM9HhvWNgMl5iYSmV4SFEMkmYQ64ANe7GZgSYQz1BsAmENxqBLhzZ2nhd6x1CaRClbkNEyCXGU2jANllVmif/hDO6QDorli2cYDQW1nszgnM44MR7zjsA5Mc2AFM2QEG4IDGvHdoJFgcDQbyCja/Ngbopnnc3ADqZplyciHQQhWdGRmuPgDdqgDUjBDOegDwICD+bQDNqgns2QlIYGl5PGG8Xwkh1TS1GBFIqJEF3zn89gWVxlDfn2hskTkPjweJOHa7rIi9k5RWWjNvDADuYwpD3xOAfhD9pwM8BnWezgOjYhmQ4iFeFXEM3nGmFZeEfjnwZxbIhhP8wwpXF5jYbnDlZYf1D3kHbEo4OCEezgDYQWa8vzod4AFwMRF7WxoUI5ZoI5ZyZKSF/3pQehbl+ZlEqRPK7mntRoDdtAj2z/A2W6aIRZWWsvKAx1uHH2UH/mJg5ux449ehHf8AzKQxAvZnjXMA4EgSIyIqUT9FraQAzRYJJskzLTQBM0EX4OeZByxwyFagwnSRDWsCjWQI/igA0mR2w/WWtu+Jb5oA/2cKlQ94Lb2KkVcaXJ4zF/9qJhUVBM4RxSkzZl4w1RAXxJqQ2NSAzraWVkwauQCgzJymqHQQ3FSYdudxjPAKZmGa/WR3miZw3z0KzOig8C2SeqKK0NEY5ytw1So4XRURTToKux8jw/ei9SkY4cA2sFVXh8oYvxyq6E1qXMQA27SY2I4RvHEKwHsYCep6kWeqPNinzn4CzaEF3d6BVIIZTs/1Av0VEPb6U8iQlF/nANHcUb5CQQuoQNEzqhNKGldEh3xYev9PCQhXcMWqp8OWhrmhqs9IAP+qAPQbkowDCAM1sRk/oMCVsQVCMQvqiXwNAMA9uIBDUWxTBs4uAOtxaQIWGde+YUwoh8/ke16JYOinoPW1t5iTEQzcCKfecQ9aCXMXukCdOWEtgMmgIO8sYUzYANc1t256YRXMeDw8UUwtB5V9e3VWt27nCp9jB+wWVZAHAMiAtqDVEPe1EMseG4kNGgBhgWVpoZmEINdZiv+VoR54Z/wuUUrUF9Hfd0VFu6DLis+8CD12YN5McMr/tMFuGLzdcnCbGatGIm0REfTf+hPPsXdcCbr1eHqShrfeuQhQfxpaS7vCiLfeNHtG13GNogESaEvx91EeigF2MxDQnxJAM7GbTRD43IFK7WdFaXvsB7vhzHhvnqDitaEJw3oPCrfJ83acjJF69WFmTLN6uIOrbyjXhRs/+bEBODDTILwtJxL0vxDMa3wAy8vGb6wBB8bhKMEIkZfBd8w/g2fNSAY8vzWYtCDeFDG2VjG3oTdKiJEJSbPDPYGwDsxB4zDvpbNjYjFTN5wTf6vk9XwzeKsmeJEDBMaz18w2gnpmJRDMRgrlA2XK5xDeAAF1RTNkuYVqk5nNsQg73BvgfRiM9yfv4ADgLxLDJMtV0cxsr/98Vm2qzzQHxTfBDNacZnrIPp0G8FRQxjiIlJlhZ8eW3aED7mJ5EOoXDF0LgB0ieOYRDsEBaEFBEmFJw/V5kep8j7kMiky8j116z5GSALAZhdfMEFkQ6J0cabzMnHkGBpgT+XOw7de8cIJxCuk6GO8QwAwGYIQSpCeRV5LBXeQMnJ63+4fMZsiIQOEZtkCb8FoY3HTIZ1FmEz1UTBcHnQwTL2vE9ULAxJOhDXgCn7bBCFs80FYQ5i0QzrgIM9PM6VnG4V4QwI3cMFQWZfSYZkKI9/gVe8E1NpQVCXt8LO1BCkpjIDQWrzzM0E0crCwI7rnBTTcGvvW8s1TM5c58cM//EMOJjOymcQytPO8sgZd5JEAwYyUFwkgNiWqUgQMlJQymgQsajPBvGEwbA4D528/1fDNgy/nVsMFcFuBKrOxpY8xEDRZSgWg8hT4lFavAqxTfzUUkHIdTp+hnezSaUo7FIQ2rAUQojTiWzVNkwQt7x1AlkRiHd9EJzTBBGUJSrW5tooyEQ8FcI7M0VQT9RWDKGN31AQi1tQd1Snr/cMcl1STKENmuvAfO1/fn3L+gZrA/FiBuEnZqyA6RzRxSzWLYkz9ZFaOwUaguGU4FMR4MAxSutHBa0NElqzzGCqSI1diMFuFUfOy3valyyqxgsgHcMMzwCYtAawW0e1kGsMmv9M26XGcBnCU9umHDbFtg5RpYRkENiFsROYVNsAqt9n0+Ds3B6Xh7xxDFDxxolZfJl7a5XHrzhNhKCa2GJdaDtSJXclHuXxH55d2ZFbticdmRzTMbOCttjVc2WGeLdm3889onr2xvuNzujGDtqAGFtsdfKayWI91ouSRAq+4IbU4IZn0gbRiFW23geBDkTTNehdTf1FUFTxdTeY3c6NfFc3iuLmlXwGx/dmdVvXfGVRh2x4yzs4nG2c5eZ6scxQV6pC3hfmZInxzy0xkGCRPLUrfn1CyOggtIZnFV/bG7o22oeM1fmAf73BFA81b0oRXNT42tlnFlTOt/egh4rRxhf/W3jMgGDkoV7b5iPlcdR/vBcqTGpxrRDaAADHHdBWusqpOo9lp3jkPGZ7wWd93ufBVQwHTWuPzAxoUWr/2Kxbt77Ls8bWbXJBXGgsZk6ctFow1F4TTBDgygyXzV9igTcIMWcAcKD9nDxuTRBukqIxfG5Vjan4kA5HUbxNHmWFuoztxnyZUQ3y59BWiA9T93WgGxXEDg/e+uljMRB8ISU79lXcwSya/tkEoXDMkLAB7Xw7rqvU0NR1zdQcQyKzVr6UJ27OYJPbfl5LEWZcBw9hySjccDPMSHnYwIJkUevP4MxUg+NtoU13R6HTGDLzTt7h0g2L8uygzQyfndRSQa7c/+w6yZOXyaPjf1yzvKpNLdfzd0dohefnfKZnHP08MTgOACxaIDTYPHkzHbM801Ak3Ejzkrk/aZM2kQRCE5VOiVMOSXgQ/ezySL1UljsNN1GzA8IMArsQSAkli+IxHAOnTeFtey4QhVqfL6pN9AAPUMmCt9cOXAKvIPdoVdHUzEAg3orFBUVIdVw2T4xscBQhqEU35bAnzrDKAwGuIl2n36C7Y7E8nj0OURHs2ZyXTDVOCLXnfO5tRLuo6/CIUGlZEHIhT6Nr+aBuTgRFgMz4P+oP5kB+Ud/4QFTq3xcyuBcpTcmrNg4M0a7SmP0NR9EMzbAX+w4MBJ3SiuuOpw9lEP9l6qsfFdMwa7c2dRmfYzklGIZ2iO5AfrsYHc2XKbI3GzZDu+bnEl3jZ+D5JoyN8h6yJwBRDB4wggXhPRP2jF1BhgTZmRt3TRizccDYMRM2reHGhvCoHTNmTFiwYACCASNJEoDJkgAmbqNHTxw2Z8dMHqvWjRy5bNKMMYOZb5tIb/6M+pPYzNxRf/XqNQP2jKnRetqKFWOmbRw8duuoFTMmDVi7ePHenT1b1qdAjtuKCdvGsaG3Ys0qenzptGA9eFy9aWUI79rblMIMF3NWk6Thw9jo5XOHzdqzadiOXQZp7BgzbOtiunsGzBm6o/WmZYQ3ld3bbVPrecPIzFs9poL/ix2Tlq0cWbRpqxlju/GisGYL5RLcNrEiMNgTqWnztk3btWcYi00z17DetmfFVDpfF9kZM6zOnm2bty/f+pgxaSY2j03c43z0zjEDho021dPTUh/9Bx3DvpnqIGGK0WY/AMdpRhjcdGqnt3fa+Y2Zejiqp7tiqLnwOImYyQ6YeiRi7C3DgnnJOO3MuaalYJyBKSZxxNlmG3Hcweeefe65Zz0f3UknyHTcmQefeXzEBphiiiqtv//8+SdAw5ZiCpxjiGNnKqoGCyk3YHprhxyfQttoOxMzMqdDhuphMKGGuGMmzjibmeabgY6rhxoHfQLOGfnCmydQQQc9cj189tmn/yF82LOMon6Y+nAc1YQBhkqj/qFmpWug/GeqfsDByDBpqiEnwnfiIccwbThiMBhmECLumm/GYQcedL7RBqFiwNkInnF+BcccFY8D5pvbqunpysNepaZZZ6mZZppnqHHHx/U2ygcecabZbJxH/enntWKAuWa/ev65UxsA/yETnSg7PaofdK1jBqRsujmVJxSXe/PAbdg5bdlnnmnmqgPLJTbhwBA6hptyqjnGYMKECUmkggw75pn5rK2vPXeuaeZKR7/1Bx78mGGH5IWIA9Af/ICB5114oZQXIdka9BLVbIJpBp0ypwnmmQvZnCbUEw0DSk0895JrxKt0KkeaiIcZRv8ZYq6++ioliaFYJGFgDM8dsZmb5q3Lfvqmn0fl9WdVYJqpUZuvgDFsmmC5YiaYY859lypw+9lGb3hAFUaabtopyO2OmgGATILYlE6b6Rp0XOGEnS5GmlLJiZgYqj+nWhnRlQFGma75NAa+gYFhpktppD7GP6PUbpuxEwlipsFg6pJWGJfclbnkpv4B5zanJDKmGm58UsqfXhnXCE9tAEDZ8nrQCbFMqyiu5ixygPMcdPELAstwYDLjaFRulieIQHCBQadBwlBkhppxzAlYWRSF0UbeKP0xBzWy9I+LFIM2F8GNT4RRLudpR0/MuJNcvDERXhELHt5AyDaUJiJ0fCX/c9woVTu6AT6rEcNExFAG1ch3GeVxIxsvhOG9yFEOF0qNMXUCxzUwwpDiqMl50IoWNaxzDXSwYxxfQRmU/LENDjXlGi5BkdDU1pa3IEwuyVmSiDjCjm2U7ToRJMg4tFGwA1WjHOWYYTYOlLUzbW0Y5KOU6143Rzq+TjO2M9hErGGNk9HmHxjazg6bUR3DlOt/fDlK8Qxjl3pMUTi60iCGSMSMaWgDHL8axzeuUbQ82g0imqzOxArXjXJ0w4VIu0oz9mgNqGyEUg46BjAqZjuvHeYwZiPONuQhD2scyI/Hgcf2UHIgAfKNZEYJh800SDO5tAlB7FAaPNxyS9udCEV1/7mKsg7kuwNRhjyLOcb+YGkNefDDnPIoCOmAQQyCYE1JxcBaPMM3jLdkbSLlNKc1IsYvYqFjk88ZB238pzaCgksbxBmHzP5Ypm/I7xmyuqQ3hDiRaTSomox5hjbQwZ0zLVJW6BgcyDrKGHKa05wcYWcxUig+loKunlwTRkn5IQ/LHCMullPipQi6U4L+wy3MAIdCj9PBt1yFPAbLSl+8cQ1oDYwa2zBHBAcnOW1sYyva8dU3tBoqZuzypAThRzrXaZiWlpVqb7HagfC5S2eoaoNNa8rsdhov/9GFGd8QKp7gNBKX1C97lgNsQzByDGfgkyEzJY/nTKhSs7LUhMJIa/9XZ4oN/FxHoAqjK093+i7YFGMbMrMcO8BBVW3YKbCnbYh3YrnKhtRka+PCijxlG08TGewYq3xZVJ61W9721rfN6k5CnhXYt6LWuMdlyEWVW807Gia5y4Uu3aBrO5cwBrnXxe5p5bRd7nbXu98Fb3jFC97slte8BVlGetW7Xva2173vhW985eve89b3ushIRjKWkV/+9te//43vfwU8YALnFxn45S8y7Lvg4xr4wA+GcIQj7F8JV9jCF5awgyPMYA4HVsMYnnCBPwxiEj94xMnocIoV5mARQ1jECS5xjBGcjA2r2MZyYXGBD/xiHveYxzcGMkdovGMfF9nIPw5ykhtOYuIjN9nJ/FVylAsy5P8y5MlX9q+UtXxaLD95y1/mcpd9DGYyo1bMAy5zmpF75v6q2c3GZXN+3zznML8YGCKmc54ZjGY997m+KIZyfQMCACH5BAUKAMAALBYADgCYAHgAAAj/AIEJHEiwoMGDCBMS/MewocOHDhVKnEixosWLGDMWhMixY0ONIEOKHBnSo0mTJFOqXKnxpMuTA/+xnEkz5cubKGvq3IkRp0+PPIMKNfizqMN+/f75G8p0p9Gn//r5kyqzqVWVUH3627q1Hjx45r5t00aW7DZv4NjBq3e1bcKsJ7n6U+qv3rhv2qYxExisr19hfYUxm7YNHDq3iIHBjSuX3bZpzYoJAwAgmEBjmDMD/lus2TVwbBM3XdxQrul64KgxOyYMs7Rs2YB1I0e7Nu1u3WAfy3ysmTd4ooeSZmiaLjvVrqW97lauHLB27eK9excvHnTb3GBLM3bs2LNtwXkO/yd+WtuzYq6rcSMnsDqw6vDjV4duvRy37cGEFaNmLnzN8XRtBY83zQB2TDbdSCTddNTJ12B15ChnDADFaAOcfysByNU400h2zGvcTMTgdPJVx2B9uWEmDDXjYGjTeF0R2Jox0nBTTjsVkUgffCMy2A452RgjzDHMeOPiSBrCQ81uNHaDI0HvIGQbMLTt2GOP5KTIHTUXHtkTjOZMI4wwy02UZW7KpakcbOuRY+KV7/yYzXbFTNOllxUVFVNDUvkDznlE2mhQPAJFmeWc0jDjzDPPTOPoM8wwA2J08fUYj33SjGknnhYZJZBpwIDDTGvSlONeQkASSc1vU03FUD/wfP9DTTMHkmOpfD9uJ8w07HBKEVRbKVXPN83QmA03TyLUzn3HsFgPV8/ONRdS9ZijjXLcvBkfpe10oyuvvkoEbFffMGMsOZQm5C0z28DDFTz0RPtuPfTa5Yw0bj5Y4rLZsAZuuAi9pFhpXClV7pDVjNhOlAatu4289KhTzjnPMjSPOhR3BU4z0gBzIpzvRCjkpgAT9VPB/ozjzG7ZmHoioQW1U80xD3dljzrPqePOs/mog27GW4UjaTkg+3ifMcVcU7LJWnGFTrE0sufxgwaRc8w10dbjjs8DqTNPzwNNvFZd20hTzUBFk3PfmOAtvWdR/sAjpjHV2PqefAUB6Qw6wq7/c2NB6uBMUDnq5CPgM8cYZGmc3RwTDDPguC2QUXVd09qxlJaorbfYdHWO4MD8HbOpAqmzVj3bHCM12lda5613vboNdz3aFAOMNLONyGOJwBwzTl3nOCdQO+d8PnjxwgNTeD3oOONkQa1bV42Qz9wJ8E+o7XWMkwuSuGCJsdWTzzmnkqPOsxGHrs46danzJOH0PtOy4j7SV042AAiDtew4xf3M5dEpGviA4Y+tfa9wSInb5+I1lfQNhGLTyMbqoKQv19GpbdfzST2w0Z0aTc1jhXpZfHoHvIXFo3BbSWC9UlgPvw1vHfWQ3wRZVyL7YIYZ/QnXycr1oQQdRHe7y4Yw/7oisXK4Qy59QmL7BEIxeMjwhxWcz/SCQQ0vPeVZ8CiQMWZDv4917x39MoeAzgFDen3ljGikV9wwthZzNEOCCGmQjtwUoWAUI3IueopUUkej5FGwaO/wljbqhQ6xUANSYxpTMCrDjGdQQxvf2BnZioGuOFKnfq5znDNiFx5gsaNAHhwUIKlTDmk8wxzewMZ58qdIvvSFMpTRjyO3cZzEJYREIowHOaZHs05mhXa74R6PQPbF6tzvGMVAT3I6BptmJghRyhlTMZhRjFIp5JJA1CVmmmE94bwNKm4USL5G+abpHCpTyUFQ6JpDm+a40z5o2g6TEDRD1kWvHboyEmLGtf+VtjkpTuTEZpbwAwCzhWhbt4KPOLtRDXO5JjZQjF487hOMZ4TmKnDpSjN6N8o4OchbAlmOm3YHp3JSZyCH6s6BbDQij2kOPkBCmj4xmpW6jCMYNOqovgbKndega5glBSqDULpLaeymY7bKZqXm07gVdVMoi/EHNnCaMHLCp1voxFfmTJrLcr7JIN253T+/56ATlVIYzTiMVeAilXoUC1+38h5MyzEzMnWjq1+Uq+aC2o4gXS5beuVqTIWBQaZE1RzmkiAxrcPU7Yg1qVGUaIkWq8s50aga0ImswroxsotCdTH92AZ6srGwK0HntJU1xu1I272yKnWv39NrTJtUWrn/9gg622mGZ4NCmn5og2W1/ZiPRBYMBEVxW1niRjWWy9zmcmM243zZibyFGcXSx0re09VTdUKaDZIJsItj0GxxF50f5aaZ3MgOojKTmcskZ7k2Yidu0vvTvm6HvIF9mV9bNBq4hKZGeb0SZ2mErOqgqb3d0cyQkmk7BndnRh9CEDTXxL3xJhW28ZieML6xVrjI7UPRNa237CqdmAbGL69E6zSwsQ1xrOPFMBYHNlRJq/wAYzOJPGoAg2QMxe51OtwQUmE/mxW5RY2r08Eqd3KXqkQ6+cZDugY98pGPKVP5yleehzi20QzLKNLJ1bWVyLZoqskCOVNDJrJR+lEPakRN/44vm23dpDPiRKIYGH0xhjPckQ9gXBkf+NiHoPdx5XWMCsqL/DJt33E0fO1OPmtLs5pdMhc+sYVMIx1mJockwej4NT+byY+o9YMNgeRD0Pe4B6D1YQ8qz2MatlRkZRYZS7h2yzWZ1VZ1NDxTb2rlKPWw3PZKSlHMfCi9usoPdyJFTWAYIz/OWIefTw1oQNvjHlXexqjyjJm+AKMyY6qReV0DWRNZR2ZC4i9Ni4IUbVwOXZaaEwCIRKpkCwYb7qCHvrWMjdX0kh6DHnSqqzwN1ToDGNSYMTao4YxigLpJlsUM9xpkXuoKQ61ueUmloyKVcgXjNdXAjZuWhR9nbEM1UP9+9jPEQWVADzof6XiGMagxD2Bc2x7XTrWq3dEdaqSjz6bWN5chjJ8xiVU6ctqOkMb0DG1wsi2MkYs3/jckJhFYuUsvBj20TA3JCEYcVg44ofOxjmnsWSD3wLnOU61tbHyNygKxMj3EwQxQO847ietxOYCkdM30pRinDE5HGlPFITGjGc7YaEglNCaaUZke7ugdNraOD2pvfR7zmPI6rFFztOcc0Pegxjb2jfm4A7zy25CmM/AtWjy/xrLewYY4tnyNlQkGj2s9iENYSA1hAIMZsneHO9Zx8mIAAM9DGlMV8/E1azgjHamu/NwXjnAWz73zaFf1oM9xj3mc3FEJX4f/vk8NDGcYA98C0faNg/Fg4L+90F0XRuBnUhWYJGQr3nC4M1iOZchv4+A4tTIVFXmBdg6cF2j7QA9cljjF0B3MQA3SRhCpFnD5IA4d8mBDYnJyhw3RNhDaoFqOA23iMA/7oH2Clg/uAGv6w103ERMDETddxgzrQG1Xpm8K6GzH4HzcUWrAsA/2IH740GrYME3aYA7ogA7b8AzBMA3usA/4MBAmuA/psDLT8A3sgA7jcA17MXl+tmX0IBCvplqrgVbilw+stnZV5g6jUgzbJRI/4YIEZCTCgA0tJ3aEBh7HUA3WUA25JW1jd2oVCAzN8A1I0Sfo8D/Y4IT3MBAuhw+w/8Ylz5JA6pdvzId96WA7wIA48sdnp5Zz1/Z42CAkHMYSWTEQ01B+Mxhw+DCB+VBFwGANsDgzx6ANpnZl7gAp3pBCcjEOzdAM61CCizgQ+SBaz8AOplEXtEgN+lYQ1mAZzmANo3IM/NeIgHZldLcipAgRTMMRAsGLczhlgxaE2jcPiMMMsAiL0hAMzvCF05YPpUYN8hIgwQYM2LCKgjYQt3gMuVhpcuFEwCAOBSEOHgKLKzNzWSZ81ThlKWgMFoUVD6EQQOEN1DR6p0Zo9uAOlVeB5veM5+gMdhSBYCgmvzMVSAEPasE8xbBng/ZA0qBbJqkWcoE658eOwEAPHFR+5/+4G+voDtsAi9SQb/QQaPTQe5vkkB8xEa8yLWzmbswAdhUphdD4DCw2KhyJjvpRWHSnW60CD9dADF6pDKlBMyspEKGoDVNHDL1YM11xDB04EM/we+doDel4DP3Wc2VobTaJVjmEJA9ZEe+CDuAgJnsGjicIDBfodVXpfPoBkAOROtfwLtSgDNEwmcpADKc4efdYkzI3K9MADdAQDZ4xNjF0DCDJmObYkU5mcm9XgjingNN0Dd+gbiDRlwuhEOZwDZBBTb5HiZkJDO5wDQ43JlVpe86AffSoj12xDcrgmcypDLajjJlJD86gH9fAnJ85iNGCDYRlarcIDIDXkYGhgUH/yZqtKVr50RmE0YZvQZsmQxB2oRqJNBDNwIlANxDe53B0Q5C7UQxD1nvgkBTwQAzR4JmVaZl7AZ37EHejogyVyQzDQKDTEC3bEAzbYA/Sx0FDEpeA0ZTjR204Zw+uOSS6kpIW0inaGDBbIRCoU3c0ohx8KIgzeBBbx0F6do51J4MF4WbjwBDfQAwEmkzeuVHWAIgCoYZ1kkz6MaDQQAxi5A/upg3aB3k39ornqHxW9meqRmWiZSwS0h0rt1u6x40IwRXAsEGjcnXN0TG+qBB8NJxjwpgD0Xs7+g/U8KDQsBfy+YqENhDS2RmBIX8Eqg0pSlhRSg9vSaWwuIP5UI1U/+aE+DBlqUNeatMvrOEMshmmYnoQ0EKjPhUfQdKUCTGM6DGcz9afwgAOdfEMAxoNBoGNBeGR0iRNnjkM07AVSrMNUZoP2nOOvLQN+TBwjfqHoYg78cF3doR723iiulcX3tkkmVYdQdJLCFGBVBmXz8aDA3ENwZCLTjSrAjEN2rAXwYCtcTomzaBt+TGrz7AVsCYOhToqpymXAjGDwFqRVHaLTeI9coIZz4BxGxERA8MQKOpG3IFZ80Ef0UquBUF20xmv1lCqNPmPM+cVzeCtwOAN9XCKCDFV+uMPvScM6roVkbIO2kdldZeDiSoYU1av4bgO5qdYO6Ur8Jis9XeURP/hD2LyGpTiUdRBXc9gnAVBD2IiDM5QtOhxDD9HEO7gDMwQPwM6DOknN78HfQUhWisSbGMyq7U6DscwDfOQpZVHDQHItJixjr+KbdTmhPuwDUICs3K1S9zRa5NjswFbFURxGD32rG8CJI8DpwbhsnnGJM0CtPNQRduAs8vgmbbzDFqIcPNgDwVxi2ilDQVSDAT6mF03emA7dw4lJEIig2fbqKtoD/ogc9sTXDpyNIe6EHTLni+oNMM2WeY1JgpLEKkjGAxmcpG3sHRXjNvgo0tKEMxwDkFoEEPoZMu5pOAgKs9Ar5WXgN63MshETXRphtgmaEGoD3wkDXCSWTFVDP7/WresS7cDkUXAgFm4FCcmFDI3BLRF+j/z6Q7pEIHpgEGqNqOGaQ4C+pl4inCjaxD5OCbAqwzPwIv8OWX2QGj7sGXz4A4ztg1lp47uoA/Xi72SWyMgY0KNM67/KrDf5MExMQ6JFUC2tSB+VbvAcIlUNBCQ+3/MsLuqVnnkaJhdOZka67WLihDiYH51Ag1dWXt0+Xb6kIawNg1gd6FEUqEnCIqJBVklRQ7m0pDf1ME2yxDgsUUB5CDwcTTsUhDeV6r2OYQ7KBD6UG0V+JbUVAzEsLgzaKEJscOCscYN9pNXhm026ThEC304d43YkMB/eI3EWjTRUUp65q8AO74Q4aTf/7VVPFJafCcYQ2YNQ8Jn6TeGeTyBGYmCHJhMhyd65wAM2JegA5EOI7gOs9Js36FvgXZqnOtkzTsP+DAP08mEJ+h9dScMs0HC3UtXxgA5iGy3H9wQWAtXgdU94xYMzQCnS0u07JiCdta1lAiOriYO57Blh8S0zPBzAVekekEY7rBl1Sx++oa29LAOMudkQUxlRDmDzCfG5IW6pnU/SDOKdQvCv8wQwfYhtfVS0iE9ZbsNNUcPo+KK/zgqisR+bmeDV8p1q8Edz/hzTzmvF0gk2LAOzyt9hXaKTtYXTEhl2pnNPFmQrxFXrdNX8zy3ykrF/zDMe8fIZZV0QzIN1exw2P+aeidmGfQIlDYoDijXy6IXo8Eqyr6ZhEzyfGnXaos6dwAIan7xfPlgD7+Vg7bnrE9iQv3cWnESJMXAYUABkUrhbqd7XEBlXrqiKI6DrdppZwTBhFNWzojTOymMfUEt1PP6f/8clDbIZQIRan7RvIvqDayRGcsBHVBibliNbr6cEwHDEPmHxXCmVxTXDnRlVLvRFzX9ZQbBLt/8lmx5DvVph71Zi5vHGuyyD/Mgbazhe3j2SpURbU/tDTNCYO40QUI1XDOTVuKb0ogswnmrO2KNG9nAh5lCGRzMRJKhEIwiENZAspBrc2q3zcJYebHswAOxcObnFwhBc1TmbunRXAj/Ijq1zTjb0ZAAq9sozWZv6WhAJNn2Idzs1W2bUUX3sA8pWBF7Bnpppw/6HYW1+JSAVrjIlGBLh9N/epVWltaxzR1EclTqcSMB1i2s0TaH3BHBrDRY3Fo/kh2OBWWd0Yu96HDPAHCE5rIUcQ5+jGr3sN8I+HJBHWj4kI8KptooNiST93hKmJJF24tprB9HRU/BVVn5cSGHXM8nYQ750zJklRu7YXSMC0njYA7j8OSnyAwiTmXisLoDAUuU8bNzvXagbYcTqG1fdtAoVgxuZ4seOQ1Pbg5QDg5igZsGXV0OvsXpqHjie88eEUMfly0QYlnS9BlfoZRS0Q/6JA6opqUF/0Fr+cOf7dji2/zljdp9VBefKNYX+zdlj6p+h3uMZjQO/SYZ50IdJi0MtIjS9mzq2kgc5dJH+0o9JUpAG1eI/pBD1CDdgqawi5TryYxlV2aHPQjplofgvjcZlU4zQXkPKZiSYhQgMYlFSeh7PqVkuI3q6/mQr6IkrWEjnGVH2PB0A4MUHMdmp+jaVHYP1kAQsARqNXmlWCZ2vw7ajZptTzYZ6Z4fmtvKESotx1gXz8I88Ik7vMzoiIyUH5GUT6Mftucb9eIV5gAO23ANZVEW49A2kzdlr5bl9e577P6HFfnuqrjiJzh38YlnWg5uAK0PhqofkWMt1wDx2tDyhWEOY/+z0hvTGughf9bjutuI0oqcfJAjIONgHmNC3DbWKEW4Mk2ZhmJb8qxEtP3N8UKtiooI8vIOGHxR8sicDqSbersiEN/AKOL6Sn3hGWkxFbxoR4JxqUTu1R7sEP74e4cLD+ahm/ohS9dQGOgwNmC9fDbJ9KyEzDUXrHDnZwMRji4ehYSWl5QhEEy/IiQ4hWlfvuwwDt5wDYjU9IB3DeZQDxI5JvuD56dez//aD+CQTNRwHAYtGM3AYnnPFhuHz1Q3enNXIFrO1AKfEGLXiNqHgFX2DLD0bVjviygoJrc/t11RD44xK5KB06dvOXdEsy24Ef4A23VSIGOPDd/QTRwRTuz/InQGXeDKJxG8bviEVm0KyAyzxvi0ph/esHVLsis5zxGwUvmKJ3/xV+qg7xIIYTn6kR8AwUwbunrADB4E9k/hP38N+9XzVgxYsW305m1jhvBgMIoaD+YDGVJkPnwg8Z10Ny0YAGHCDAIIFlMgPHzYjgljhs5jwoX9+ilsWI+dNmAti7WkVvDgQoU8mT5duNMgNWHBhBWjplPqP5/++jUE288cs2DHqImj5+4cNmzbxFE7WMwbPXz6So7Mt0/v3n349oGc547aMZYtgTHblnjbOmDmsBVtBm6rwq5dwfpDh+3o1WlKDTJFCBW01KktBXre6dPyZX/1vjU7dsxZRZP2//Jdu+kS8Ty9IPnyPbnvnj2/9NLB1SiMmjt69PLRWzfNILNvwNgtXar6K2uw9bY1a/kM9ejJUaXCY3Z1GzzUGr/Wg899aL1xz4QZY7ZcuL582zYHmwgbe/i6p8AC7UEQQX30IU4cZ45ByKiKnOvPmem+Keia68x7qJ5+gNmOO2AgIkuYcUIjb6cUEapnmpa2qaehf4DZ5jpgHGptGnC488ebZ1qr5xpmbjoGm3To2Wcea2KCySpmsBFnHrxGwsedbayB8CBhYFJuHovEsUmYY6ZBByxmvPHHPOsQuoydbTTaZkvxUFTTI9Bm1Aic9KzzakZwnrnOq5/8YYc6r2RU6P9NGelz0RjZrmFOnPRiiuk+ZqaBkrnnmqMHTGyegdCYllwa9Rl34JkHmweNKUbDGFsTRps0mzIInWdOvBEsdpqp7iB4VJKLzjqXEo2peqgydNZff2ToJ58wAoernxQKMlew4PkG1KuawcYdH0ljhplmxiU3o4Nii41UrMa5aNVjnsGQKZ2wiZFW6565xqDL6nlmGngQ+iY9f4Wts9indgXmGXhk9OdNatJc9J9pmjFn2oV+FWZhRP+B5zurJtpmHm/YInnizUY1TEzZprmGZJLTERk804hC0Rxh/MXT12eaUQpHaoL11UVmzCHYYKOrE+aaVx+C65pBBa2nmcZ8Ygr/HvvM2RiobW4y6Bm0RppHnG2wsaZss61py63mSCpQL33EkbmlfHcCJxiFPbJ6aH371Ea5fw+KM1Y7jTbaH2o48mZvq11iCCF0xq3YYo5d3CbrhvQMhplizHInn3kYPKkki+YhvXQKfdvHngUZTMeZq9IrplePvAmmmb8Rsjr2vX+KE1DH03tGRaNJS/gqGw1ip6rENRpHXKI/U8jqYKhhaCFdn7HbPrPmqWv11e0xMHwDe9tn9XW0neZnZnD16Bq7b9e5o1x/Gucq9qdjibRiiZ/oKogbshkAxsGQy3yjGOvjirFU0pl6WK8h0jtgVcySjnsw6B7B6c1I/hKS8i1o/x2DuUkz0tMMdEiLKf4oisJmtRB2OIMil/lK/YRRwsvIjH854x9CmPGqyxlkHILq05uKEa2n+CNfCmsgUB4oHY84o1t32eCURlJBfWzDhR4BlOQYgjCcMaUfzTsTDP+Bq28o0R9Sy2EaNcIR1oCjJd/4X0OQ5g0t/sM/67McO7DnEi2Fx0jcY5vqvhfF53jjZ1uKS0tISDWmSCZpSbSeAYGBJtbUDwBw3E49jqJGTh6lGOxoU0tkFSJ/jCUY2vDQU/QkjMqtkCHNE0YzlHEQZRwFALKxxjY0NaXmgOkZ6VEkQsDTjB9CJXDb0KJ3joHHNm5pR7ryJCdzOK4XCaofhf8KRmdYE7WbtQcYj3ufUxhiwFgu4yDLWEYt07VMZ1CjLS4j25BuUoxiyFIjynhRKhdyLJwQ0Xq/et823TfDTPZNGLOUJv9qGcsfNuQaVWEGOEgpMZwc7yCwLAbRKNMaarBKGegEaTLQqYxmnGwlAEBpSguDE2V81CPLOIo2mTIWnAzwYOl5GAx3JbeF0Udm5kwo8ZYhM2Y8w6jFqBQ1NBYU901PI0EalTbBAo5i4MecQD0nSEl6MpQZRZYg3ckyYPfMf8DnoXLjYUMClxSwlBU3pTIqUbEa1LCKtaujKovSgoI5jmjjdga0ylWoMQ52sGMc4DmGS+eKEJA21rGNFSrVPhla2HFQpSpX8carOraZM72qHtpAKspuaZppLJauLy3pqMQVN2psQxvUSA+6ijENbWzjGpsRoVd/aRrTnjaNk2KGM5zBDFEdw5b5ce0hy7JMatT2Zyxpxm5H1Qx0+pZ/jzVI3NIVnmmElp7TRcd38Mpb6waVpHeN5UJZst2r/Me4qtUqZMsb1HQC06uS2cYzTtaMa/wNHtco6QGp29v5kmak9BRwadEZ4FHVc8H23ZZjC2zdBY/ro9HQSnivcY1tmKM9RKnuhOmK3XOS9KuMNTF1ORkQACH5BAUKAMAALC0AAACBAIcAAAj/AIEJHEiwoMGDCBMqFFiPnblx37ZJlOjt2zhz7OAt3Mixo8ePIDfWG7cN2zNmwlIKC8aSpTBmzaZd84YupM2bOHMOrFcPnbaTx4KpNEa0KNGVKosxm/atns6nUKMCY+ftWbFgRaVl29qtG7mv5Lp23WpMZTBm2tA5lcq2bcJ6VY9lzdaVXLly7fLqbQc2bDZp0o4Ka3ZNo9vDbsdNK0YUcDVu5OJJnhzvneXJe+1yqxb4WMpp4wwjHo0T3bViwoxp9dqOMmXLsF1Lfhcvb7m/xo4VoyaatG+O9bY1k2uMbuTZsSfDpi27MvN4fjs/+/a7ukJz0zyrrnYX+XLl32WH/69NDrewYoWtqx/orVnjbNzweg+/t35r8Mst880W9Ni0muv9FhwzjbH22nJ8lcPNVoA1qBV85Rzn3HftlFNNWcc8w06ApLFDDWPFQZbchO/w1c1f0jjjzDMssugMM6u1lt93mwV21jgcHgbPNMIcIw1k7Yy3XDfSHOPMNeCws5ZA8KDjDTbDPUbOjJeVaGFZzYCTI1vwUCPXj+U0N1uFfzGzjZIK1WPONTACOWJlkpUnzWA4bvkUO9mpFp+Ys8nJ20709AYMPKKhQ41W5ATJ521EMdOUnTh1+WU3QV7WXHn+bcjQOeqcs2Q9nNKzFp5alTMeZuVhqSWkIdWDzZfcVP8KZ3PcSPOMaKDiVY6nwOTajjr5DATPM1rJaCl4qQ4GIKsd1XOaat2YOquYKZoj7DlhSrZrrpL9Ss9A6DgjDV5UOtfOgmXdymxH3zCGqJgUHrPNQPmok+1s5dhL2a/BCrTNMV6ROCN0gQlDzZLrIjQOSsUqeuBytzkDYL33VXhvZRVOBqxT4WYT5rHz8RVYMdognDBB7DxDlMe1PTefZeRIg41T9KgzJW2d2ntfvpzGuTEwh37cHGx51ZoSdScXVA81qdEVZF6uzUjkvDVXWuE5hGJbmTrw+KN1PPkGu82PsioHXm380Zk0Qdu4q9ebAr9DZFNfg+0pT6Byg3U9/dT/Y7NeWHsjDaUgmz0ZORcKM42g66LDcDZxUwnb3MDUHCa/PPnzTz2i+uNPP/5QnBewghPusuHd1lrWNWt3mVI2kUku+dT1+OPOXRvXrvk/vPfju+fm4KWOqKWXHXVsfCXOzLLrtu3jcbJTWes1eK/DNU/wsKP99hll7rU67nh+jTSxnw5vsosnDM9wg5cffX4W3lo7POJ4ow01zzTDzP77N/PMNNjQhjfcISqePAN2zhnaiMIyMm8k7F+qudn7ZqQgR7FjG9NoRjFQoxIAAEAlIGSGM6ixDXgszCunex90smGMYDzDZDliB4EQGLmBQawcxtigUFIDmK348IcNauFK/2ByjES97H0iMwYAHMgqbTAmYHCq0sBQhZusaIUb8bkLWO5ylxOhyCjSAAb0Jkg0o70QUinzkemYIzvKyCklqoEQXtqhEL1gkTNyaRrUyDgZ1RUDaVtqmzHWyEdg/AUrMTqI5AxiIv60sFQPKxfYiKQ4xqlnGliRIBnpGBjV/IgcBSEjbAiyn05KoxpGVGFtiGQMZtQpQPWAB4GkIUr9nIgox+AOHQdSy+UUhIFFgV2l8pPAw7FQXlv6hlyqMUGMAcNo0BJIPAZSw+Plh5FV/BGJ8EO0mBljGjCsDjWC8aPYSHKFRSpON0JJzGLCa5QFKQcrI2isSJbIm80Ip2/q0f8MAJBPYAAFBpGOkUtQ8hIY4UGQfSJpEHkGs3zWvGfBXqkedjRDGNkwluSmeUhEGUQ2YfFiNUZKUix+5UAEmaZAO5kNhCZnRu34izC0wSFwzPA+D8PYPL0ikK8siCtYRBFgjEJUT0IILGJEqkBYCZhERS8eqqMGh7xRjGNkdGjdmicqezpPYwAjiGXpkW42SNaqpuY9YxEqXcoBDHkGpn2zYuNlVPcMDjmPkKeLadMM6s0PrqQlHyzGM6iBjYmI47DiKAn+mOGZswoRjk3NC1MppcB3MKquARJkN+I2GUMGhi49LZhfWxKMD1JjHfTIBz1Sm4/WupYe7hDHNZ6BFJf/EBU+eWFhcS6H0wmVIzDOmOoTa7jSVkJGICxMiVBK68HSnmcbq2XtPvBBXeq+FhtmAQBWiCKU4oBSdVoBBtQM91tjNIND7Rpk3OiIuAIJRHUtaaEHteuSZ8wjH/jYx3TvcQ982MMe+FCtOAjkEmF40MAuGVxoVTPH8ZiRQwuzqiaJ1o3GxnEzZdkhQYEBQpbIa7XTra5/+5sPd2SnsSBsblBUwxdvFselCjWaVAPkOAnn5TsxY0lVPcndYAgWG4hN7DRQYrD7hri6/MUHPQacG2dMgxpQnoZVWojIsYT1n5cxUTcuBADqwfIZ/qRLXabZjgsJhbBEzs15sOEO175W/xw8YoY7/PvfOtvjHvagBzZaCeR5RJce89jGM/LoI7loNzXrFC8DO9nCZqRFPaZBDUGPIZArqi4l2KDHOrDhjEljw8/50K+oW+sObDBjHfuws6rnsSJx3NfN1J2HO1SmnfO8iCWf5MZAJs3BlzzKNwsLBkGVwuGznlIw1FitaqdhDGcQcB77aO2oWzsPbJxjH/zF83+TvA5roNbN+ZhHgKmNkhw+YxvreAZLjFENVr5kGhOZbVVJps+ogKMZQjn3RLQxZDiqGQDOdu02jIGN/EYb3K+NrX75W2f+7mMd6VB2uFVLD+pGW8/PRe06nPHXSWdIHH+G7TY6/cfRpGzNr/9u7WrFMWiiqKhH23DtPKyRDv1SfNMvEiE2UEsPADP8zganNsuZAQxmnNsdKR8wNUKND3E4IzctOQY13KHfbd9j5VXNJ2K0genUjpvisH16s60hl2m0OcDrEHest0F0o+fPSNANdaq3HfRN66ZFVX3GOlzrjtMKvKqMPXNqrf5f1ebjVcJgYltkGQxnGNnmbqYHgY5hDWs0ENwHZzswrjEO7Y3jNMwQR6h/DuCLk3062wPHoAMe7m+rlhq5OYmwz+FaPGvbtetgRjDA6ZZvwFza+q1utMVBUGlUvhqemQZrWxtgdzCDZLvzB0+8YfT73jnJ+c3Hv+THN8/hCRiZXn7/a8XhLmt0+hjYcO3csa1yejCtGdZqy/v3Lvd8/Df7r8pl5S1/jNCDW8/oVzugI308cRqZhm3Zll8b50qe04DSNw4qAnLgpjLsVnly4XiA1lr9FWCARg9OVHJcQlvPIF3RRn/hBnuUt39kJy/4ZXMbB3+fwzsy6A8y5AzpkA/Zdg/R9ioHszv/4Dm1Q1PJJm35sA7lV3lzcgyolQ4lYQ3hF10DJgzzwhbmcFHhx3QzpyJApm7FoIJkZzDAd3jHcA0N2DfoEA7hYA71oA3oh4P1Z2LMkCRoGA5d84P+AA9KsQ4GB4ApWHlPZzAnxgxsxnR5tnHBwDpscW/CkGnShnbU/8BYz/cSXigXS2cPF0db6KA50qcNxNCJxIAkglVxkJcOztAMiuGJ0xAOQOgPXuINcud+BKWCyHcePTINEohfeBZuF4WIUkFViyhdHBhoFyUUzKCCSZh+0rZxxaA7a/iJ0AAN0aAM19BpVGdzS5Yhz6AM0fCMUjYO0ucP/4INlrgPADh2+xcUPTJ1jVhnJeYMXVZvNtEuv0gP+9V+LDdE+0cgxmBfNvdw/qGJ4EAM2vCM0BgNxFBVbXZdKaEMA0mQygBOtQMOghV0UdiH1iBpQ+h1c6cPsIVvXiYVNhUMjIiAB7dyF1WMflgWMaeD4/dNQHgNyvCMw9CJyqAMKSEOQf+nZz42DTS5jdBADOAAPEZXeqqFXcLgDPuHGs3Ac+qHD/xVYvg2M2wRbIzolDpYku7AcShpDYP2i0S5Di4pfcSwjQZZDAKhDETnavmFD9UGDJ2IGsVADM+oDD1oDkOZfdqXEkhZeSgxDfclbsB3D37mDh4JjyGBDvhGDfdllZAHaCqzlWQHDM6AgyS2DsAwDZ4DDjEJDcoADHlUDBdVOa/lmSgRDAMxDNAwDLfiDwszmXiJDVihggTyDKPnZiG2ZAQyhVIxLC5EQPiFlyrHbBYZFMzgdf21DhniOduwmcTAYXKhG0pYEP9iYCkhEKgJDc2QiQtDmyx5eLF5fAR1gF//x3Rs6TyKFxX1gEnO8G1Bd10EVQ3n2EqiSF1ZyQy1A5PPaJau9CoAwAzzIJ2ewQz2c5bP2Azh0A/KtHR4OS/GsH9/GHOQt47zwDTOQFFRwXXHIIHtqXL/0n8qInYjaHDkOA3AYA7+gJ/QYJYvJJHBYA0GIQ4XdSsAspkG6g80FXPWVYT6WQ2dlhuiF6F4uXGKY5itog1YwYj1F3wYt10D4X9yF2DYAAzbYKObqaJwIRdRWhAmNhgPYZ0FqhZWIXo5OqGeyV1EkWnz0J1O2VrTqS5UeFH9J35PCqMvwT8itA2vNmoDdivfIJc/KQyXORw2eBCIxyLngZrRcCvj4B9G/5ZfqcVyHHYWqOFs/RVt+xVtHOdjugkVzpISBBV3jaiD+Ydu53BYvgl8F/ch2sAOY8mZqAEMwvZpB5GVIOSn0pgyZtKICXcN2ABkozqOokZd5+Cp+2hJN2FRWOEZegduSsYj63l9rQUMtZdkwJB7cagNm2mTepkOCtFYxYCoruQliil3JRldKud0xqCYEVpiHKYanyoVXCcMQwU0KYdfhqiY96AP9xBu6eCET8oe+zNbMakNKBF6CqFnGxSTBkkN2YFZ9adpzjCI1EYP6nZq3QlozMZuFbaPRAoctHUMEdJSZkltAXYO/sJ0qjWNlAdt/MU2jLVBxHCS8/KfCBEs2P8As2T1cQIRaqoFNLFIf+SIXRlKEOuQJ7DzDixUDKuiE+bgLpVRYf2nDTR7eD5qf6rVNqlhJndmD/RCD+mAWQIxDd5AswqhWtpwXgPhdwOxr9p3FYBqdv6VD+IgFFNID97Qo+QTJJQ0YzpxDfLKDbPhR6clrUwjZ1YLozt0lHs3EPZAbSW2DuKQJEu2qQZRhN6wWpArDoSSWvcgEMNXmoAKNFRXYpg2D3C2YoNzH/ikKZFCW/+EMTJ1lHiqMs5QcYL5KrCKFIo5EGvJgRQHZ/tjmQhBscXwaYQ4bvclrSaWuBzmpMAwqRm0ElbVDZYSU9KgtDphUxjlGgw0bC9ylPT/iA/pVp0tUbzfolqWqnJ9x1gR6w41C4uUR3WVqlo0uw5e4hICgRUxp1rl1hjtMyWUQUklkxPb0DSuUTRVVBbFiV+kyBKwGnVTJ3HRNWu5MQ3fdhAy9yr7eHYyZ7pPR1oPjH6pJXk8dEVz5BpE4kLGChx+m7qykReIUzALjA+kuBIP3BLC8AwgN8JFmLERzFqVq74Zi6bqKxw9Zpo4zIjz4BmDsy/PQRvl0Z8rvBHDglEA/DKN1COLOWs2TFr4y2bR5SUNmpDSFsR8x3HFEHcerBtefMMZ2lrr0CNH20bt0A1CYaEfwQ6McbQ19A7lIRB7N10afMMg3HhA9izPcIOi/6ZfZsyhkyoRg+Zhf+XAyrWeV7tUE0ZMdaySN/EP44BomZwfdXyy4wcMXjVfzYXExMgYzJAO1JWD+NDIqlVqPcJYR1FshRyeryZVAOMwnFUhREEN/vARMvgPDjRIOGUpyZFotOla51CazEVfsEpfR2p/VkmtBYFwYVdr5NvGAmG8UNkjN8NNWcZWl/k5/cARxfwP2kAURiQesxIzwLCUJSkcy1XI99zK5JmABXFwCKfBIETILQF+Euc85PNSMAVK++g5/cA7CrHO/8A0x9Bbr+FG1fC8EFqC6jbJDuzF47rI2BbL2Qxr/JUOjBXQ0fzF9CiYLlocwyQ7nNRKAujQCP8B0f/AI8ZA0agjGUQCDM8gv013FQXW0dKbq5jHyP0M0k65pcwbzYcGNPnAkVMoDS8N01dSDOzgg/9wEDb9DxQIDHzyGt60iL85L/c80AXGekdtEP5MrvRwDehIvqisXcBgDfPAkcFFNpt01eMA0QZh0/7gHmEU1uBBSacGaPPC0XS9Q9+EcOq3D/1sm9NFD2yXuCwx16ZJDfkKm4ZkKptUZjkEDjZdEOusiYItI4QNMy2VIQQUhQjGXDjchrYJfGxtm/61ZPjmxfNVvrQ3hQgkSnlxIUo72gMB0ZpTD7ME1uZzPCIjEIrJxRxNyamxv48tamwN0qkWdl7sxcnnDhv/91WUJUpidCGuRNwCYdw/mNzTstPmojqXSdm6t93L9cbVjdTXvcj/RbFDTVo90gziMGuVlkoTJBBX/Q1dfd4Q3dD+MEt0ZD4O7sfudm5FJ9+wmqGphd0Jgd0Xd8O1tUNEpxhyTL0TckTwBAzCbeDE3dWbI9jvIE1RE0lkIsOF9Yj7wyJBwWHfhuEJgaqXaJrKxVie4QzbcLeecQwiAjdUMhDC3dcHruLpqRotDtYvzk0JYiMCcXTr4A7uUNmAmuOLvBHkOm4brRLbAA7iMA7iYGohTL2nEjcEIdzooOLAoOL+gEle5eJhTTQKEhgDkY47nJVHIYEajhAHF6w9m7gV/6opmLVBoDwb4nFNC4bVKj7p/+C3xmBQYK3TzP3HzysQKdEMu7tnuRF3gy7LohZ2KoF+5iAO1IC2xaAMzenC651Al1EQgWGfWk3pxVzAwkAppJTn5MENlCYQIjRpEct2Z8rj1m3qjByF+bYNjzjszzuTX/XO1lQZBxEY+ZTrus47vicMX7FL4tVbUwQdwy6I8mB+jWXju3fhX54QInrqbLdBLPJ8XrUiAtGc1U7Y2C7lAtEOgfEMntPkKv7JvW7O1FQbyZxXYVTX8sAP8pDundYjKxFwy74Ri1yU6ZgdemkNER9cZuld7I0cjCQXZMjtDj3peGjFv9QXLp8orQHwnv/58PxQ8xB/kUKB0cEC2R9hXRvXnzfLZxF/8wOxW3bx8n3RU3mhaJ4xpSi/1SrPcbAjUF3hIJXmIA2yFcRO8zYP8RyXv/Z1E6tFUwBQDJ3GDFxf8/JglgJRDVvBGQ3yVVjvQ9TLFykRlE8/54DdN7AHVneOEJNWFAJxDBGf9vLwIpGKfjhBmALB9h7f9RBPdLBKVAmBS19iI0o78H6N4OvsOx5SFNXpP9Mw+qRf+lKWP6/qmc4w9GqPkkExezYxvqYpEM4A+TdPaR7OIpdp+qWfP6DLEnFYO+bd1f2wGAY2zzNhDvCANwRIgNgDD+awDazD9pRH82SX7p4hFM4geh//MaFxrRRo3/WH7+mgrg3gQCi644ANGEvsAA785rYZYg4Nvc4EYdNruBLFwBTLrzsHwfwA4a9fP3/14I27VgzYMWvy5DlraE2YsGLFhD1blw/YRo4dO7rDduzYRGENIcrjx+8hsGLTvrGrJ3DgTI8cB/oryG4bM4vT2P0DGtRjUKD+vDEL1gxcvXr9gP2ryRGnzJk3/YFrBoyZNWvOHDITRkwZsYnOtrmL2nHeNmfGgpEU5rVrw4fGmF1jirMqzbQDgRE0SG0ktXpEoXYEOvAfvGbBin2Lmdbj3pkC/xUc52yhV37PRoolK7IYNW/0orrbNo2ZW2HMmhULBqwhNq6a/4ttgxdTb79/ig9L3jiV3TSK3ohGvRzz2kZt9YDX3F0VaGF/4xQ2E2ft87BhxBxbpPgM2zby5Kc5GzkRQNhhyhQydGhtI96C/nrzLur8uUd/5pgBa4Yd+34byqCsnoFnv47AiY6ggsD5xpzcluMoLGXas4gYDSuCq0OKNJyIGO6IUUirroBBsB5zvvkGHt+A8siimp4BZpwEgfFnm40YJHCo/sDSZiNvFJSKN6uGK6aZaa7ZpkStLuxuIijH4hCuijS8EKxioNywoyWnORCdF3sEZhtqWPKImWlwq5G53oCrDiwmsyLSpsQchGeb1zgqRkPuMGTvT+6UIbRQQQclS//EP7vsiJltYnrxOXOAmcajZrbBCphrnALun3rA+q/OjvCbqSh2rgkVGEVHrAjKQ199lcQ+BaVyo2KuEVM6GIk0s6Nm/vPGn+eAotFWCusk1Tec6vmGTrFGpKgYWKc91D0LBSURwEcb3FVUc1DliBl0hAWunmNFhc5B3uCZZilznpnINS1XpbZe9zYSSxlgJnpGwm+ogcc+gjhFl6NKmYOHzI6aLLgvvTylphht4GHnmdg2urZejTFEU6GLJhytMKEa7kgbhZjRhty0nCR5VJkuG4enaw6iU9WNb64VY2ZsvOaYZsYZEMYgW7aVI/2IrtMygrQR5phHj2LJ1Zs3Jsb/Vm/q2WailEcGEF10Ch4SRaRrMvIfdpoRphl42AXA5qlvJjGYShlLSsBuGx4nqmKBk3hspofqLchgrrnqw7fhrgiyoa+2r6MbRWUsKpY7ijkqcFKt80zkvgZQQHgDPZzaYIJhxp/In2FnbI6eYQacjipG0yMdoxq6psejOjitIB/LMcTQqfVOGGqu+m921YHR/GhN0yo2b1/Tuvy5byRTKGXrQP/9ULKE+cafIHc+3tfbrSs3Kuc7+mbyOtHJCuBxXqM3+0Etaj1BAJrh/PjpgUndaOAwDx9wnvEMhfRJQwdEYAIViMCKbGSADrxd+M63EQA+r07qQ5qHNLhBkoAnxoAfVF2QmjEpIjHDhCdEYQpVuEIQtrBlYRPVMmQ4QxrW0IY3dGEO0eW83O0nGT8EYhCFOMQZBlGH4TPeBC0YviEm44ZF/CEypFgTfSHviJmjRg/P5ZHacaR2W5zgMqLSRDIO8TlKDN80etiwLnZtI8ajYEeWc6O9PaeMTSTSM9CxtivWZBlVBKGa+vgcZ6hRMzVpYwsJRaRm1HGQDavgI1sGjzZiUJJpqVlUJrKyS0rmGvvrZMv+mEkZAuOPoUSlC2nox4YFBAAh+QQFCgDAACwAAAAA3ACHAAAI/wCBCRxIsKDBgwgTKlzIsOHCfxAh9ptIsWI/hxgzatzIsaPHjyAzRhz5z6LJiCFTqlzJsqXLgiRjljRZMebLmzhz6kwpM+ZJif16/ttJtKhRnT2DkuznrybEpkKHHp1KtapImf6y+ouotetWpk0p9rRKtqzVpWC71kMH7ts2bdquydW2zRs4c/CgflU60qzfvzexdoUH7tq0Z8WEKV4cLJjiYs2eUds2rt7TrCQBa97sUXA9wtSaFTtm7JhpY6hTqy4t7FixZ9vY1dsqk7Pt2wl71jOn7dmxYKilSctGvBu548i7KSd+jDGza5W1ZsZN3XbSetuakQ5uXGC5duDDh/8/LrBbNmmoFTOjBq/ebNoQq8v/uxRivW++g2fjxg1YvP8AxvPOgACKB0w53FRTjTSkCeOMN3nBF998FFJ1WVP+1DMONYkZMxx5AQY44Igh/vdOPMC0U855pR1DDTvSKVXhjERxpVU92mjnYTbdATMigQD+WKKAQAJDjnnoHdOMN7P9A5VUNEbZ0khMafiMMMFVU045Av0IJJEkxtOOiD8K1A453KCn2ItZ8QWllHB2NlKG2enHDZddenmimOKJF6KXBB35mzDTmAPVRG/GqShGS9VzTTEeStPjQF6eyd95wmUq3H7lkBPkiAS1s6BizRi6V6KLpopQRBShMw1pw3H/045BPx6HqTPPTEPNrrs+w8ym5LSjJ0EIomcMM+BIiKqqzArkFTzTtCYNN+Qc5GU3DMI2Tntt/lMPO+DkeEw1xgFaUDnVGCNMM9+0iWiz8Dq7VVbsvOqhrAeZeOZ5znwTYYYzOTnRt9s4I001wRJ4EDnnCYNsPWItG6+UXqHzDGqcIvTfvsdgAw9Y9biTT1hMwSPbbOxQ86GwKB60InrMMImoxBPP+Ky9ks6qcTwMuwhjlcCocw7EA6ujDj2zfatyNuUMiNC+6rI7M801zzfYNMH1p9B/C07znj/wpCimOu3Bo86YR79XzzTDgadQOw0zM850VdM4b4aPetgNngn9/yfNM+hkVQ89BxZI9jljjj3Pe+wY/N07Cq2o7jPs9FW3zV19A6mk1S4kZjHbAJNhPoUHWY465QTYjjoju7fNMca1nBA5ak6TF0qXU4iZP5rfq/NCK1Iu0Dz+/Xd66kGqCCDr9QDDzjPZOES7utc0OWHu1DnZlDkXD8c3Q9Jg0zw9Zw+4+jnnfCfg6eeczfPRAqmMUZrqMok79rjdGK0x2QTrELbe8Af5hPUOFZ2jPekT0AH9kcB4nG5k25CUQ9rRjeY0Yxzwwd9tIoIjLElDI9j6Rj0QB6ByDC1p7TthP0b4HfCQzRsSnGA2Jle562lQM08xBzOEEUOHvKMbwAgg+f9SZ0JubWVw7ynZ2VyYD2+YaX5qugZmqHbDqUgEWljqH0YGhK1tzMYd6ghaPtwzRaBMRICdSlsEuyEs6c3QYRjMShUB8xRtjEYanWPIj/pDDTK644CfYYc5xkHIQqKjPbNpHz2ycg1ppE5hDGGYumw3rzn6BSLw0E7O9OgldD2DW/AQR1wOw4xSmpIZuJoGNrbhDqR95hlGItJ/GEJB9IBOK5YkC1e0QZpq+BBQ3ABdOK7hq2IY0zSLWUxqhFEMZjxDG+j4BjNiF6JIzjAYzYhQLnXZD3Qwg395TAiJQIUgYxgTAIo5xqaIw052LkhNwghGM4/hPzA5bSHTA8A23rX/TapkxY7GYONCwjTLbiwoNeu805aQw9AjIUk4COWRicr0tjStC2JU7KdLsmIxvQ2UoLVsTtYU+jt8cgNT6vJQtcZ0onsmhH7FCOBFNGqUrGwDSwJViJfigSTgDCen/tGTUCFnpiNlo0EfIlPksEUoeGSUpivJ0DSAE05aAdNYH5TVULcqVD5hC6HqoyhCpic3f0C1KN/65gd1OqJZfbU0TGMpV+fqJaNuh0cEBNVYZ3gMbZj1rDvxhxON4Utx7smt0vBgNz7V0q6Siatiil7W7Ck7g0zPa4DdST+mOi2dAqhnpOnfXCc6JMbu1IFvzZksZwez5mU2J5kMBh4RIiSG/6HnYAkb6kTHcxw/TfS0YqoWxnILoIWhBxjgeG1OdAgMLeYLSOeRbf/0NaQzLYc4Csrufo7z2D2ZCIgY64aQDgI3gVxDuTj5xkcFdKTUxM5S1Wgnf97JoNXYVzgKRQ5/kDMm8wQnt+glyzYgtbdZEuSw2BJINhKHJNVkyhgCaU0zT1nKDgVnOMTRFI+4gVpjTfdEBSFQmoABywC7ZMA5E2uBspFFT/EMPehUTGOCgU5mqHIbdRGHjne8DWxMgxnNwRJqHKOYSAWrlsBQrex+K7lnNMXEUQ1dioFLjnSB80RfFUaMZ0xjQrWSdApxxzai5ZjGCBmhsoJbcFIHnseW4/+DzQgLlEPCFCdOWU+1vJenJBlP4NAYAIBGJ+joQbiE5CMf9MAGYwDgGHU1WrSSa1ubg2Q89MSZZHPuSEn+0Ts24plnVlYt/cpsjD+j08ywBDNCEC2Ob5pZy+hktGMk9Z/pTQs8QvqPRZ+BqIlkeiMS8cc4gCzanUoSGB6sBv36bM5TjqYxxwjdQtxxsSCbpjmADsYxAOAh6x632D+yVGKpgSFf//oqQWFHM/SMaxFLozGjCc6Q5TmNbazj3uvYBjUiPA2GDHgg1MCGwKnxY0eXRjlqSrKnCOTQbKQLANVz10w1SBhtYINX1NCGv0LipJnU4xnSVQ411ewYgTujyM3/eY7IDs1yeqyDGhB2x0L27YxrrIPQOJ+HN+wlLdIAANkBZemRIDrkZkDHIiCBxzj0PY2mU+MaG/cLO75BDWYkBtaMZmYxqAGOsnnDMM/IFdTDlpA2+QMc07j6aUYKDHUJAxv5mMc2fGOa0NEjH/vIe94PLXdgpGMfCXGHM6zxZbwfGh/4IBzWHO2wHzdmWmhKrIQr/BgvZmjiBlG6Ng6Tq8mgAxgauobVjQnrx9jYG7KpCjt6k0xmRCbszdjhYqZxjWbIOOuKeYYIEXJGacbzGBUWaaTSIwxqEBrRWHOGzPGxj0PrneXzWCXgD7KPdVjj5iw/PD5YDowdHqve6wA5/3DiqyZnTMYb3hgzkItRvZIgZBxkxn08jc4hZjrs9bBvPXRcS5RxEFPLDkMN3jAO7FCABWgO3xAt8RRoDChjDpNcBjEv0uQY9cZjVScMbdciAOAM64BowLANxoANwLB32Zd99DAP4pB31OcON3d3cYdziLd9wKBozCAOrbQOJwdtxwAMx5BqOAcMcucMruEN7mcQ4yAaycQYSvhM42AOBWgyCFh7gLYu0KET93ElWgYZ2kB2CXENWmd0eNE88JAd8cQM5hCB/2AOzRAMzCBtJvhy2+EMJxdthyYQ2JAOwMB8JygOVUcaLiIOd2cP+GAQJChmQogazoAN6zAPLNdq+/+Gd+Kwbs0RDDyIDfOwD/aQifcwEOswGswAMQahbuqhDewgEASDhMLwSQjRPPXgDYixGEvChSzBDo9ieteQeqYID7IIDMP2GtvweaGIhf1WEE3hhcdwXgNxaDgneKgBS6QxDSIjEO4wD8yHD9EHZM5wGELYhnc3fQSxd3DoTCQGZM8gDiznDtQgc4f2OsDXHMBgfPlwD/awiQSRD9jQHNvwVwThhesCDvw3EPCwc8UAANpQELooi2NodUQ2Df44i4hhTLBhDv+IH83QDNQAjO+4JKWYEOOgHuNAjOyQGM9QaMkIfd+0g0kGYdugaiN4aKLXV+ygi+ywDVa3kvFYEM3/Rw/W0IPboovA8CrK54EyBwzIVxq+QonnwHLyWBD54A7MEAyYRRDswAzopF4JAQ8J+AyuBQ85UpEFSRDRVHXGxAy7lxLeJE8XiRDUEE/MpA3/eJUDwY/IOBCCxYPSVhDMlw/iwIPOIBDWsFZ4mQ+d2IYUkSH3gUoiQ48D0Xz3SEkQI0fU0DGEVo+vk2TAIIQdw30GQThreUH6CAx2BACY9RlveRCtuEOMFpUGqQ07VAxWmXTRUgxbyJFYSCgYiRCrx5ACoTlNRRD+0G/NsA6GJoLj4pd9WYP1mGjHKDppgTfFgA304I0CsQ/p4HpxpBboIIeAWBCwRFgCQRrOQGjE/2MQ80AP/xZABLGWwhA6GkJ7EqkQ9VB/zPSaB+ENOyQ8IAEOTzkN6FCaA0Ew1CAZG4kQ8EB3AkhItic3BFGgP2kQ6TCe9LBvKAkM1mANyCaCyRiJzlCKSwE2FWmO32iPHTMbSlFJN2V8BCEOm2OhSdYae3kO2GANiVgQrfaBUvkMANCG4aKAzQCBq0hMGdeQ/vktigY6IOEqWkZvu8gRWFRqREZ67EeAYfORM1gQ8yCj5udEwFAMBLGTxVePkVmQbVIP4fAN39B1vAR3BUFtvBhNZgoj2gMPXCqcA3GPx8CilwlhAWoazrAN4ykQTdmX1QMP6OB/A7llr9YMt8kQ/v+ZMgOZe1S6EVeYTM0wmx+BI5vzYNvBTM5EexwygyQpEOuADdvIpQVxiPs2EPNwJRwKNudFDLB6DckVngWRDs7Qo9NADMpADM+QLBnyjtE2EBFqGng6EM3xhwcxD7YnGc8Qe0HmYBDlIkuqEQGZdle3JP4Jn95gew4jq+1REOBAcAI4rQbhTajBH/P1YKiBTO4InQchDr5BicxQrHZJEHTqLI5CDNoADdAQDcowDdqBEM06DfwKDbWXLM3jRNhgD3W6g33plzvYGpaIEIIHANd2XwqCrknio/D5DYYxDUxikP73iszglhjRiomxdWd4EOZQDI2BTs8QqV2YRYkTIMf/8VClAWHuupnrEC3dV6HF+qfAsA7HMA1mdXb6WrDREA3E0HZDKRD04IXAoAz7WrDKoAzuwYuvkaInd5lAu4PPGaoDYQ+BKi3CQS7GQQ47xQ2lVmIKgaTJpKUGgR22J5sYoYbMtA3kyosMCADsl60CIYq0ViLmo1/VsIM7WxCEIw7HCbR9uZ40agxGC3rXoAzAAA27CquWKwx7KazYwIa5qqvRAA3AQAzJwoskVhA35bUVyqUcKLbJKHg8xA17syXtJiQrIk8cexB2lIRfiRD6KU/0mRDxmbeA6zy+UkpGN6AIoQ2KAW56IiDGM2KJaxCC55df+6X2KrmCAwzR4L1N/2tMxKAdnTs8ihZ7iVG6pKsMfeQPOuS2RHlTDgK0AjENQqu47rBueES4O0VBk3S8dGtKF7QQwwaVezsQw1Z8B2yKg0SADFGgOJVXulVp71ieB0FosDSv2fuwnMi9Z3e5EUYQtnevdgh8BCEMwwAMw/BJwoZKBfG5xgC01sAMP8mS9aiXNLxg/FtAQFIOKSezBNqE28KoXuia/mZM2wAOb9F1KdE7+2tPLVUitENiK3fBWHOnQPuUNGyvPWhTykC6xICB39kaJPyB7jgQKMyvpdLC08CSMAy0hyuZ0jmdcYcNkJINBOVYb6Yud3mp4UIX9ikM1TNzj5Gy65ESzktYLv9GWZRmPDPkDOaYD4OYnHY6eBVKGswQqvPgDJ/oD5XLr+lLi9u2xQTxOv24DY7xxdDQDOHAOy5CmagBtGpijnOcd/YwD2spKUIywZJTfMfrEDRZyLl3vODArfQ2dghRqITUn/BpLzo8JHviXe1Fh3jHlOZpGqjEyc0YncJKDcFgKJ8MDRBZD+DgsqnKtalIqPGkyqzsycEKqIKpVtVwiMdAywTBfPuADzgIYWoLJLoFHtOTTQvRwE3onxX3YwAYUwZNk4nxHEPchbGnvOJzlbZnDAtXWiZCJNM8DS5YzQJhjWsJHMtUg3VYp8bgV9qgymHcDNhhGhhKEPMQLRfUkSr/rMb96Svlq4wSanAheIKLiQ/3kHevw890BSTtoCbMaxBdGXtGB7hKJ3oNfQ1L2rvLyxDecHV/ZjtXyW3SQEAYLb2Fa0vYh3fThw97uS5y2JfTAIjON4LAwLgb+g3EwK9hnIrYiIcGMWAAUJHMNAz9+kngYAznrIeC2W/NwckOsg73gM95dw/y6AylkSJF/SNqMrwF4YV/1pb/WJqrx62DPBDelKNAnBDOuxjFwJ8KwQ5cLcGl5V0ooibQSdb5bA/7cI+g4w7ikA7pUHhkXaeyCQ/E4NfDkBjQNrHWW5vCMNeYC02+Im353HLmsA1yIQ73+IG0rXf5fA835SE+Mtkj//JGcnsQ8CB6bOnLDTEOV2LEoBefxhTeAy0avrjA48DVX01pCvNVzpAOLMd8txwtHAgMjt1yd+fY9LgOsecNKc2vysClqagQ4jAoxTC6TIt2HTOdzcd35emC9GCrgn2JF35oOChbQOTdJvJGv7uKaDeWXuQQ+pmKrpXAfZQRU1cZDfENwJEN9Z3R0mskM2QMz8CI+XDd1RkMqaoP9xB355CIZI14AhGJW/cMyhANoodN5YsQ//bFw0AMBFe0Lrh39MC41DDW9cuG65CXh0ZtGMMl3r0nbzSXBExIrNgQ2GFMVvkoZJkTqMw/fwLNOl5LEst3ZHsOyCZtiZdoffkM7v+wD47dfALhDSeXGMSwQ80QOveb1+JrTKPxDB3ofIjmDoat6SWtaMBwDkBNaPCqGDG05lz0bsN4E3g7qNGiijiR5zie41HcMmfCIM/pDnmJoXSKaL/bhvMgjx8+tFVnStSwnQoxnnMnwOclyY2NaC9NYmXOsJ0Ld/QgZjqySd0NXKWVJlCpE2tJOaJ4zjdB6zWL0bc+EO1AP0Wr3/mwlswwlE1Eypep33q3fXHXlLhNgGLWx4s5EOJgdyy4DvCAaPHI6TVqrOlIlFSKDbjtG4rlP91OUBgN7q1+E85rht4kyDqR511t6wESKg3jIJYIS+EJ1MBaENQA5NCOeAhPaK7/2ExlzJ2vDO2CyHcsF34GgZzA0LIO4iu/h1cEIUvSW98W5eYv8Q3MNA4dr/QuAQ4eJCKt7V0FkevXBmQOMp7hpxgs/2XRaYLi8CrH0KdPexB23IProOhenuFjXxCNYQyhg2jed2FpaxBg7e0Bki6QmxNMLwxOv0NQ3xLjsDnpTvU7RV4nZSzqksmkkw5r2BgFMQ0tqIyTWW1hfncLcY/GwIGS3HJBaBDFfXf04H0/1VslJRBQnGtHHw9qMtot8feB7/Es6w1m+tAcEZIeYrs7PF5jZVBq4vh+l4NiTBDlqOGCeTEhmOEMgcuoAZ0a7g7YYO8DYWaxTTw8BETs/lxh/5LHfIIewbCoGaEhtv8NNG4Q3qAY4PA82guuKYvpsNGQV/mWHyct8UUtk2Zab1MtDNMaADEvH75504QFCwZM4UJgxaito0dvHrVjx6jNY5hRI7B5z4QduxZx3TZmDTciPCYuXz5xwY5lI7eRYTya72zetNmuHblu2aRJO2aMGbyM9djVkwmsHrpv04oJgyqs2LWN16SOg2dwGtGM8LQ9jfq02TakMrV5K4oNoTG20rJl69atXDmadeMlZUgum7GU+fYBwxYUrzNq3rAVM2ZtHd6N9EgKc7YNmzPGB52tW7ntY7eYeOPhrLmT59ufQfluzeiNGteN35pFPQhA2DR0Gv/rURP2jB0wq83GbUT3+pk2asygPmNd9Fqzsgu/MSsGtu1PuO0+v6PJeGE3tttW5lvnzJj26ELTad84L/Ax9MCOFcNGbyXFY93ag97pUxrbY1ChH9smI3aaQW2j24IRhhlqtpkGAGbA2YidZxxC6punrmluoXFewxAYeIRLLqOvClSonmmagYcdBotBaK2KpImrM+26OSaYZ/D5ThzjGFsLm/bSc6Y/7YJhZhv58nHntWNk9GynnoAyJjapptmGKGeQW6geE4XBJkOGbkvwN2C0SfCbjbaJLkAPPWpmty/RLEZNcJgJhhovGZpTmA41vAYeLb0x7phn6AyGr5+q4Wb/LsbI2a8ZzFZyjDIemTnvx4zyCWw8xo6JL6J80DRGmna0I4cb/fbrr5gJpdIGqXq2MTPLr+LEi8xi0ALGQi69hIdNcxbSTJjVSgQmuGJ8U0izW/HaEr7ktIQH0GCKmcYcc1Z8CkG3OBtVJnKqqSi+fXAMLyG8hLV0o3SYYe9cTukhyJ1nguImKdGeHO8jarcZB53DptXGz+bqgecaFrFM6jk9Feq1zC+tEkabjAya7Zt+vWlmWlwPbOZXvNABq5mzvvnGm2sMmrZPhuABh5pVhQk1G2661agbaSBbZ5978BGHRXNlYkacdDVyZ5qfT4KKGnr0cQxmaZhkqBybb0ZQ/xgCvXnW4OOu2cYbkrd5DcFYk+o1GNTqGce4Is1hCjdVvUTHKamaaeapYlpViB2tQvwSGHDshi3wqfgGxh92Wn6qLbjK0UivKLEZCJ9tjGmx8qOdcWdojdDM6GcAAEDImnmYZibUejPaiZtq9otyX3Pq8cc2bQiNCsH+oAJATbywsbo2hQCduxnjchNTwGugs7sZb5oLDt2k6pGWmWsGBQsqVb+5E5h+tu+nHnNmD4o6cmhWyGapxJFIzcpBR2ihaTTXCNDOP6c/IWwI4t2YbBhnKD+g+hOZOfzkDwIaaBxOqUgCi8EMbHiEGQGrVZiy9I0JRWeB1PCdTNABDm90Lf9E5oAOVWRiDqdMK0Bo20YKU4gVvHBve/6Ax4q0BZe87OUYl2FJSYDBvs+1TyE+gh9DxNEMhiCkfgoJ2qdKJ41E5cVmraMSPP5BQNj14x94Gcc2tLHFbYCDKOB4jbBeJxNvQKV4DANH176RQfiNIzq40ggFQRen7KHnH3d8IQFj6BHFjU8hjqOWO+RVxMoFsT2WU8hs5jHEUHFGIe0ox+r+9wys+cOK/piiJa84NLQZJxhjyZ4bgwFHQyZlHFIZ25fINJtx1NGOd8RjJv1RD3CsSn/dGFU7nggZcUjLhy0ShkKEVkpg0OMZCzmIDxXijHGEx2ky6knrKAkPTMISllb/NKTenjINNwnoKboj5kZOKYxUZokaAGhTKa25Tjx6hY9MLMeozGe1FGZMmQhSyGKIaUxg/sw/2xDHMV/SGb3sx2raYAcBFcrOTQbRRDYiHDu+GU5TQoWUC2nY+9TJUGv2wx/ooA8zYPKOcuwlIQ4xjDOY4YxpHHMhECllPowJDHwCg139iQzYFHKM0znOGNRqpUItaUV2EpNMzOgmQ9xIToqO0DgS0wg6jCNCQ3KUofX4ijCyoZCSRgkYURrLPOYRkSG+lB4xzcczquaebaDDreKgxkJc0g2bAANVZKHiQjlKzG9c5Ux+bapGyhbXOKKSmFZd5yytYgxctoMbNysG/zHAYhFxjDVzC0FfPhjzF5nsQ6YeCSbx2EEPb4A2Ol8FRjveoZf3rEOoBCQqQ4nJDqiAcyG4YYbHAvslathItwuxSjGSCj/EWtNwx4QRdqoBDGEQYxjDIMZBEjQNd6hHU97RLPz2QQ93SMo92DCHOKZBJ6kMQxnEsCs34qHLoHRJlrGVLTGfQtgSLeU1JNqthoxjp5XRiYiHLe4d/eENxIy0HfsBxnOhC5X+/HRB4jEG5PyiuX1sV0eJpNI0UiUV50LXrtmgCaOM8Qx0KHR7iA2nQR7EW6nYNr9K6e3dyhI3qEB1o1ZlyDXYQtfV3owZz0UvMJ7RwNs1I0hmk0+FOf/bHiU7piSqqiDMgtQQIDstJ3tZMUOKy9enPAN7vzMOwl7MEBBK5RnUOFF0uAngogr2GaHSybeg41zJQkYe/JAHMJwBloRgbiVKZjI+PEsPHzlkXh+hjDys0R/nKqMYx4AROXjyUxcvZK+GrIfWmHHm8Rp2zBqpZfUSdI3ham6djIEHYqQhNZ+8RxkLhg8/ZI1nbJC3IdhV8pI761l84EgclFEQYpzhozsr2tXQVTVcuNEf/Gokvg59TDA+Z7Uvf7oo7NDGM+hGjXIS99RYdNrqblcM8xYDAM6486z5AQxrBJOmz3CHX3Kt64UoeSX4iIhVGtKMYzAj3bOWB6ORDRX/voDrGCjaSEOB8W1Mf4MadDtzK639PHj4iaJtXriAMVlAhMAMd80duDz+Les8u6dGnLKHoOftWXlX+Dv7EOs6CMVcYVgDGOrGszOaqwxHWy86FRGGOfRqTYVckeGYrriWJr50SxM948at5j/Uaj1iEANBdJbKyEluDWcs+iDMOIdAWs7y7+DDHvb4Dj3WAVqoKETreG43MXhut6pH5yDfGDrDnc50vjeV6BwlICyb8VO5PxcqWD/G2/nB9XRYw6vOUEnLvzN5sbK8IDWyXpDermipvPopHT7vU7SR9y333fRsRixRPWScDhse5NEtxuatYY106Dy0kJ987vMh9t2v/wM3NK+5PLqudc53+PMKHsZ8FRL1AJ/e+UEsvVKPr2AEvTq6wti8v+Wxo+tHxh1H0r1M3bGNIwPfGoo+P86L/9zpV9mlGYn+8+X/o0uD2tytHwZUrH8Qa6jfGehetMhytEcTlG0Yq8mLCHdooGyxmroJBnTbvv5Tt+0DueSrQCD7pKTAMYWbvw50tmcTJxbBv86rMn8DuNkTOYVwroaAjRuiBmyAQRicEMyzngRDr2M4P67DhnQztgp8ih9TMGJAJ+0AQQ80wqbbO42InVwRQeSLjg6rM3TDM5ETOUl5LhasO7sLnLCoOg4zrxs8P0Urtlq7wB9EPiH8L8bAuCM8wv81hL/ls5BgwL/2iy4cpEJFo4xiWAhl6DxgCL0tfEKes6nyMi+FKIbhEzlrQJ5XY78LhK4h7AcidEM2fL41vCNni50mDEISBLKnUIgoobphMMTm0gieUwaZ6LkgCz1gSqTI2sRiYEQgQ6cTWzgtu0QkvEVKnL+jg6UPbAg5RL5TdMXnCj09DAtGBAbJgsWhia4g60SwaAhYVLDzIsQg/CRahL9cfDpt1MXT40VuLLpMBMYzdMQvrLqqi8Vi1JwBRK9pJAZmOMdYHDj8g65rxKaMcCFb7MVudL5v5MBwHER6lKxpkUfkM0gLCiLYo0eD3MRxJMdnyMeMUCh9BEd+XLr/JEzCorsjdmA9hlRGAWRId+QwQ7KggvRI6zHJbYpIhhAqirRIb9xHjQRHWKqHjvRIultID2uIIEtInPTILuTEYGSRa1jJhWhJXHxJ0xuqSFwI7vnHazIIabxJ0PG5jyQ4igqysLAggouSwmPInvOGolSIoszIpLQ24qCGtFTLtWRLthyeOTtHZRSGHqqa0GqRpuLJtaqdjnvCuKy7g3iGaRDMwWzLwkxLqjJLprMcH6KfxuwhqdjC0MIdqpxM09vLqtHLwKnLyGw74IONxDS9BWKG0STN0jTNkmiGZ1DN1WRN1hSe09ShT4PN07Sp2RzN2rRN2ARNplOGZfDN3wTO/+AEzm9gh+I0zuM8Tm0Qzt+cuOV0zueETujcTWvrzWQATmTAzuzUzuxchnCAnQ8UsFzxTescz2RIhokzz/RUz/Vkz/Z0T/XUzmWYTmtLBuysz+3Ez+xMBu9cQoZwodjxhvJUz6V7z/SMzgNdhvTUzvOcz09DBgXNT/zcz+/ER+4B0Pt80PWkzwLl0A5lT/1sUAc1zwiV0Akdqqb8z3r4BgzNUAbdUA+FUQ4F0RB9se2EUaFjPobqh29I0BZ1UQKN0SB1TxqdOP00T4V4Txwtrh3t0fQ0PSGF0gElUudL0sCLr39g0vp00r6L0iCdUg8cUpnMSLQ40vljz4V4T2BozwkvZVMalVI2DQgAIfkEBQoAwAAsAAAGANwAewAACP8AgQkcSLCgwYMIEypcyLDhwn8QI0qc+M+hxYsYM2rcyLGjx4sUQ4qs+LGkyZMoU6okOLKly5UwY8qc+dGlzZY0c+rcOfOmz5E8gwodCvKnUZFEkyolerRpyKVQo8J0SpWi1KtYOVbdOjGr168IuYqVCLbs17FoIZpdGzWtW7Zwh6ZlOTau3ZxiB5I0mPeu35Rc9aqlSzLw38MeDQPrKpBs46qII2tU/NTqY6qSMzek/FMwZs0x6ynd6jliv9OoTffbSxp0SXjgrsm+pm0cu3HevI1DJ5pm3n/+VktELRwi8X6LW8+sxw6duefmcM++Bg5e0nHPignbvr1YM2bbgxX/m7bNekyx/tKr9/evHrz38OsFP/3vNHv6n2HCvsZMO4D/AAIQjDDFPAPOUPA8AwCBDIYnzH8MejfNhBNqg45JVdkHzHrwfHPNNM+EKGKI01yzzTjBqaXYR+ZcQw2IIoKnXTALCkNjgAI+Yx5P2mh3jXn1jEONdts1M00zRHLHHTPlJebUesCw8w024ClpzJXGhBfMlsIc88w142yoHkTsGeURPNs0oyR34jVDzZADjreNOQLVc8121/SmEzvPCPMMnQTVk2aRJ/LHXTHg0TjehRtt5Y912DhzzDFXSmPppZhmmqUwzJAHT3FNdYTOkN0hueQ15nijpjDNaKOnQOg0/xNMM4zqNE5/1MDzqkDY2VhMed/0uSA14JDqHaB1CmTONtSMWOI3omWIZnbbVSpNNdxkS86225ZTTrbdZDOpjeI9ow076oFqkz8CwTPOhyNSs02tBI2zajHYgIMNdwaiWeUzYRbk3jScBpxTPd/MyOo1tYpWzzTa/epejwN+EyXErIKjp5A2PgihgOONQ1U94EyDpaXZkBPPyizH847LLLcjczvlhCvNMdsBwMw3uqZ3k31BYvzggIdSM46e4Kg5Hp3eMCNensBsE/E0u5qjjdIEWmwrtVsu+Ay0BLFzjXbNhGnnds9cCA82ZAc8aJHTTVMlM97IZ1M/ZY7KTKXZdP/DDTnttMzyO4S/LLjM33KTjTRXMmP0mC7hLRp4OpcoGzVVsrqNaOYojY11sW5HDeer5lrQN6YqmbZOBLPabDGwt7ojMGcXaB08rWMjGu7aPSP21NXV49575kAcDDDflBnSeo9qU6U0fQMeuOArF0449TDHQzM3lk7aTN0+qzsRwjL+GR880WHMzDXstD6NdXZqZ3qCeLJDEJr3PkPNqtPkdKsw76OdkCI2uvsRrBiuuhjsDkQ7ahSpd95IiKAEoqORqAdhfTKGpbgBjMFZr2UfpF7hWgaMbjAuS9MwR7pGUo9nAON7uyKIN7LjHdGZJ2EAtF89egTAXd2JU0ZrF8H/mGGwmHwDPHUbCDx4KAyoDSRprApY54RBjYGYo09oQxZCBKWdb1iweXvTYDa4UY7AWW+E1fugzEB4xnfIjByL244zkpcikSQsauxSCJ8i5ruBUAMAzQCUvaIYKKnBrkkD8QbsIjgTRRZDawMhXzDoVpBtgOcaA5FaMwhyRE7ZTyEQYcd2tCESvLWPUtAj4/Rc1kZgtINbsOTWQNJ4xnYAgxvFyBKT5JOa4WhDGMBARx4VMsVHRrI/26jTL40pQ+1Q8nSLpIkjk2kQRfrpkwP5ZTN6U48h0Ss72mAIcOAxSoqshmTPCIYYyYFGVr5jIORQ3AmxZAxUjpGDHWyj4bh3/4wBuUp8EPmlMNgxGAn26Bl6YkcxnFgPWWEybH361UG8QSBGygQcxQiGEwupnXAasBjIQgfACIKOcczuIPXpxzYIBI6JpKcfSUNlN/KJxncKpGaM69Q1vPGNnoJjG9d4BirJOJA2aq8cizMGAuthHFCBo5x7SQhs6IWdWqHjmgXpkcQMcjZmaBEmLWTVSes0Nmac1F6QpF1G6kM+PzGVeW3VIAfdabh4COSVi3OGNnp2n9X4Q3jmwEYzoEeOon7QjcBIajFGNx8y/XWIScyI8DjJDAYqEXYPNQg81ITQnPwwrffjj0cjqQ3LbmQ/4NnZW8lUj6ZdqW8dFFxBTOgM9v8BjZerIU490IGNaxWWIGlcWQkZ10R41BE4/kgaoqjxDWxu5Ke76tGPEDKOju6pGADoH0Lg8aEYeoQdmAMGS+XDPHDsjbBmJCE8+bk5+8DjHPOYTz/qQQ93CO9RlpTG32ZJveEq9Uf4gUhribQoj+yqm9M9yMMI5FyZ1GNfEpWqSlrnJo0hVz0Y1WA1APeyus5WGnR7KX3VUQ510EM99CDxOeQjvKZJoxzAPZx/F8tUiaRnHHITnXc7wo4dRw12VdzJIGnFkz4Bwxz1EM56xuGM18L4eoYzSDWkcY31zEMd1TOxP1K8snKs+KXaOEY2bEmQuhLultIg0DaWRzI1bXP/J3wqWFB4+DmHLOtD5OkxRghGO5f2I0GUSlls1Xs97R0jV+mphzvUscp4qCMfWGaZl4XnHmoYw5XuBEYrTWiMyipPIvDoj3Yt4p5vvGinDZbg2La6k0pvB7QI8caR/DOgaRzNIitFns+QCw8HanCm/dV04drRjcpKbh2RbhnNGh2PcqyDvOJgRjdUdj1hnzGxWSobRfyRsAg3JGiwK5WtG4JRKvpYJlPs40LcM45vaANz29mlQ24FDMb6bIfCkKtA6mpXaxMOqe+b7znKYbgSl+NwyS6HfR+bjYPzm5bvbEc1slRBGzvQqw4R1NyooY1vmPTcAmkfIL/KE0cmOOPs/1CVmjPuQFqt54i/Jng7POxvwpnQVfUYOOFk9uhFm1Ed54D0wdsBdF31lhvZE5z1gAHHeuZJInEuYEOk5qc5jVUh8fP2ULqJKFh/m21EdEg4K0veKRpj2tZmGU2tZ0Jv+GPgZiTHo+Wz6BIvnMvNVod9vSGNbsyc37EtNNMZJzHg/MO8CJw3rq7OkE5K/Trg6WxG/BVAhhyoiUztZr6rse9CC5euNpcGtM6xSoXfd8t6F57Ay8hzevDd757vd9Ltmo3GiWw1EaysQzC3uY30KexLiZ8wqKmRb0wj1QrODtX8ochg9L3m+mS7NNye8zKmfkx/le9f4T7p1/8de7JFKv/jEPpYYIx6IeiYhkUxgu+FSkWkfmJ8Q/TMkH70rxnoU9PZCxv96N9cPvCgYqenfS8FEQFYYsKzDX33feCndu2gOPW0DY/iQueHdcjnEJvFKhcoFO3ndutxGilhf8BQDL9TDNJQWKDXf4TDPVQjH/TwbOjjbtowgzSoGz3mD+5wDifmD9TQcKzUgCSEU9cUauaXHihBEQOGeVBhHFdkfuT1UgD1FOtGOw8jEBZzDCeogv2HVM5gDu8RG5sUbmuyHceAKM9wIj3GDs2QMkAYQivTdMDAPgKRK5MlTkAxErjzQigSEXJhGppHRB94FFxlDrEhG9hwDZsEDEIFPX+nhW3/9C2HFlREMin0VIlYgjMFog1jM20e9HBKpz3c02kjeAxu8ibAoA1zEhZUgVE0Zhl4MRGr8VTmFoU2UU3fwSACYSU+2InRR1ffUk8P0iXF4AzVUA3ZcIzIWIxTdkKHYgyA04lAyDLkMHGk2E/hIV4EMkd8URUOVAzg8Gl8KBM4YX4E8lV36Iph027M8gym4nywV2j9p2xxlG+JFT1r1IBvZDMCMSmMCHEq2GWMcwz90QzPUCKpiFKWARQDoVAAdBlSCBgKiTwZpTulUVCEUR8IUSZ/9Ttixk4j9I/aYzPWkjLb0mj/uC02Iw3AsE6NCJLNVnsF4g3owFdGuI2OcZEF/2Un4pFW44ghSDEQjzJEBnOTCJlSBvGB83UnZ9eSjhgPnJZv+sVhjmhUboSSKikMhDWVMcNpvlNj6MgYqhiO//M+UZUcD+kkRMkS/nAr2UUvCbEXeIM3R4lb89UMGjSVIxRPlIKFfpeCeBlC7wBH0jAgx0BGfvmDK0MzMOlFjpUiBdEV4ahHQ9RSFlmRZdkoYMkX84UNI7hRRUkSxDFMAnFBwoMOuVQNf4lXJ9R3B+eXf9lG5GBCMuWRgMlvsYkzeTJfiSYfj8mH6CgwPRKHdgNKaTkZmfmY6RFqiFJEvWka8gWCugIPJeUN27AN4AAO2gAA1/KR+pSYgtkl2AKN3f/5ifG4MqH4a2fERsNWDozTDOxgDt9Qnbrhhb1BHD95EP/DDOjCHovxmZW5VmcZa7DzJwc2HPYxH+6yjhl1PGvijuKpRibUJQuohcHVgL34ht1Ahn0Ze3SlPcSVUf+xJdjoJrWRZC0RQ1c0STzpn5GJET1pUNpRecAAD97gKqqBXPVgDvtDIDSiTieDM8bAhq55Pee5gC7zfWj0SuTgLYmTLWTEeuppm0nVd7RpZh80cYQ5T9jIHW5iDsYREtoQWRdDIAn0EBHpEC9qlpF5Nn6CZODAjnvYVBuJiMdAEKhUjGNUDYGmMjDTYYbzMu1AXPo1PYEpPTPzSuGyOJlyKX3/M22E6oaBWXvoCamFxj3gqThT5gzOUBCcgipMFWAVQZC8kSDyoycBeqZmepyWmZOYgyirJoEGykUAcCV1eoxmVFeS2g0cmj2RWil8iqiYoozENSkCcSMQAkwreS1/E5uJ2g2O+pKV8o7jaakvRj14BQzMuFTM81dataOLtSP32ZwtmqrjipM3qXHcQZbDwV1hBD0zJRDYk6sQdzjdIFOJmVSWeCVkyAzOMCIxIl4ncyn1xDfc8EaSmjKrlJ5OmWbVaq0CIZKdxj5whTs5wwx7Za7/iZOboaoYe5kYBQDFEKcR0WuUEnO/NWgtI6+g1zImhK0FG5IqWSPkEoytIg70/0AP83CzBDEP67AN0+AMxbCSV0I0+fZrgMNp0NOaK7uwWKm0aUQQ30KNAGRcytMP/yMMpuWQxSmul2mTGcu128UM2eWVBuhrjHgQ1JOr4xkP5MA4icVOTokzwLAgW1K3AKCI7pAP+UAPelsQ+6C3+eAOnClePYol22Gk3OOy2pOwRMqwTls4+zYQ30JciLZr/3BAjMexYEuumtsQ5vAgsMpaPfJrZEYQKCg4atud7SCpRtp0dWsMxvofAoENN6u3+1AQ9oAPe0sPfFa3RLsl6Elsl1YNrKew1OpwS2cQNMNpx5AnlktRAMCcRRGuLFquFkFRx6BCTXUrYlS6pouyK/9zsNH3SquJsElFNFlSt9shXsxgs/hwu7iru/PANsWqJbJrI0GqPW27kn7HlC9zvKCHENsTkHQUEZ/LTMZJvVyrub8pENswKeNAH+nha2OmENQToWOmT64rEGLEOHULDM5AIT9bv7TbtwVxD/jwgk22j8zQwv4BDMcwq9KAqHWqQdRWV680ZcdAvEy5EIsTDNOwHv8wDq8Wltb7El7buWpanN/wao5VD8xAKdXgvQbRidS6rFL5DokLwkJruMLgDNuwDvMwxvPgDuJADf30DPOAD/dgEPdwD/nwwMfgDNiwDeJwx+KQTJRChuc7EBuqmiDGj3/TkgsxZZzyhP6wUsH/IL1LbL1aW5wNnMTFiQ5OY29rWS0naMHuFE8MizLRUw5tmyXHoA3rIFh76SfAwLe2C7hxLCnrsA/2cBD2MA/W4DjrULt8e7PzYEnAiCX9IRA+GJuWsinAi15nVsibgiJ/pXnFcHVneplnqcQdq2AHBC03hiS/thAtczNEMykDomFJtR2DKw78UU/ikMr7kM7qDLji4AzigA+x7MbuQMeq/L75gA/2TA/boK/B4CXb4AxbQljz6B0hon+ka1NVLBCh7B3KzG1OQzXV+7WbG8lG7MjIAx7NwDN/NSr5JmgKEamYyK/P4Az9AUwDuynTQA8DgQ3GYA3zAAy6y8qsTA/n/7AN+ZAQ6YANOSvT9BDTN90nc8yZ84y/wwzD1iAO7pDUPesMyIpPCRGbWUINvIFfSFIM67fAEj3RW/uWFk1WQdspHRcbuZTJDtEM26DSqex6pAK7sDNJ4tC36QDGAwG4PVudYXyz7oAPCZGzOJvHdXzXL+3AcwwM97wOTUYuVwLGgT0QL1hFNqwQcCSQpQVUQgXDJ8fVKrKx4bjVr1FFh1LS+eZ3CbG6aeYM6bDYAoGzvGwMmjop2KC3eh3GBCG4m7qSQY3aCSEO/ZMlFLQNi93ONp0P+xBtSmUjOvPObTwQcJwP89BkxrBfyiu89QQ7MSyiUXIeqJoSgvIM/YEzSv/i0QhBeOegu+k8EPLr3NZgDSrpDLd80wWh2wLJce/WDIeG2wXRykFLg9nBJAOxy4Stt5w5x9pxDMGt18BwD/ZgD/lgD/rwwMawYQfxgLXHJgTCDOYifz5J0SchYOjALBSiJs8nwPlGDXqbu/gM03/rDqiU3rVdwu49ENPgJV4KHKIR44OLEOuATKenccdwzsDw0oA7zwJhDUxN4IALz/bwxvlwD/rgDs+QzQbByZNEIbTBG1ldEgoMkWQCH2jS0QKcoQS+D/g85gmuu3JcDemt3iA8D4A7EOIwxyhyW1fUDD5OEMmNxjiXZIkWZi4tEKw8uM5gDUJ1aDf7vvgwD0r/Dsv5gA2U8q4FEcrBsFfvUYBXXhMBqhLmxB58QroGwWmmPeZjjsL7QA+MfgxpTuQOfM/lrYhW7TPskWgJMw3ucBDnUCDoIsHLDDHJpMrMzQxGnd6DyQw56w5lnA7u0NP4HMe5lA0FMcDXhFs21hOXruWmQSZSo0FUPFxUxOb4fA+7vA3ncMsmY+qnXqevLdx/KzU6UrWo8TBa50cI9FcSjFzgEAzPULvpLhCBzuL9vA3e0Cyaetbdng/RJgzMThDkK5Dg00tdjeXT3shaIRKP0mTHcLJ31Q1Zcu5inruRwq/YEFGnbg11SuL4POqW5oHJqQ0TwjDecAw37udOrp/G/zchbkfjDVUM64DupP7rLE5x4HFo6VDPCj7UBz8Qwht/oMrZdsixWY7EqojVF9byxyDas8QNOIMNf7sPCH7PZxy0XcIMp97irDzPx8BL/hAOxKAMyjAMykAMR+Tr723h2pD2bE8MM5p94bQN6kwPQbbv6d1P+u7b9CDmCK7gzW3wMzcQ3DMg20CLZWnRTt+x0Bz5vQn16kE/C0gQ4iIMWC/cCC7m9UUlWwL2LC4Q7Qu4+5DjzqAe7aMM0PD60KAM7GgMs04QD9wMxKANsB8NuZ99FkMN9pDOpF6npJ/eGfVCZ227SD70AF30wAy7OmI31Av5abrEahrRjpyWISE5O/+07DCm0BPe+Ruf7DeLSZOU5nBPDT2d9etQhMDxDcQA+8MwDNGgDPnW/gSBDeKx9vP/+gARjRg8f/7GFXtmD9++fO6cAQPmzNrEY8KYbaOXT2O+ffYUNnwGIBtEktKECdtWr56/fv9cvvxHEiJMmTJh3nRZcybNmzp79tS5MydJnC5Z/mP3DJi0bO3iPeVmTBg2evv24VvIkB49d8+MMZtozSswbPkUMhQHbFrBesqUQRN4spiyYsLSkpyHLRgxusXmQoOmTNvKccwSLtSYNpjEiXWfucuXUaNVfBodGhsJzCk5YMKmwesXmudQYDiDlqaJmrTNl0JXqx4KNKhs2C//RfvbVmwpOafxlk6lZ+/qwsqRu1oMa+3YsWlm7zFcp7YgO2LRAvut2KzZsbsksQlrVvckM8DDphFm5gwrw3zbgBlLzszYs4z3Nlq9yrUZ5nfv2pHL7BuWWmqtNaJSOy012mo70MCYgEJwNtpwuq0er6Tppp134uFGmmCmmWc44jaiRymwwqrImarweS66tf75hhjAlDlJqmKYOSY6mbA5RryThBkGsGbYMciwfJ7TCJv3wqqGGbU4su8+rPIRRz5g+munG2CCeYagokgr6jTXXIupwde+VDBCCdE0DaJv6sKwnSw9fGYdjoSzikRqgDkmPosy2ucefNxJr6Br3oKG/xhhipnGmWOCOcadmrapCKFn6kK0mXEMYjQfxPJREr6JnDEGGG04Ym8yfOzJqxhjunmqnGyCKQYcM9k0UMyfcD0TVzJ1rc1XkuCZRhjMyIlHVmCYEQdK/EjU5piIUFyWHuLwmUcpgg4FrK5m4MkNgIdqEsdbdMAJRphMN/WGLE/ZS8sYxh7iDtX7rmJ1TwyfysYkauphjdfX1iwz2AXJlE3NmgRWGBz5pCkn2W5KPfWqZ7XaRhiIljum1LJQ3YeePcHxh1to/HqmnjeD2bOmdZ7hkh12hAkmSGiaMcefPbfxtLjLjpFGWj55RlKjrOypUphskO1Gmq/G8YnhgQMumP9NMYNdONeoRwszqHquMbaa/yY+hj6QKbPnOI2NkYo5yFCtjMd/t0FUUWbAAbsY93SiZtFttDnJ5iHhSc/OqyKjZxscae7MGBDnQfKq5+7h8VXesqnoGoATDLPrrQtG+GrRxyRY69FJYoeZYo4hp3WnixEHUPwETXoabMLCxh3JnnVI03FkvM6i1esMKrdgVF+0vPPco4qj4vKZRxscgaHGK2bteW72fQg1Rpp2yiEn6CFP/1xh2MhHP+upPU8fIkqPWbqdaoz5cJ7JrLInH2qOYXYe/+fZyr2K455psEMZQYpLMGi1N53MY38/qps3vGGYZtlLI1sxhzsAqLhjYEP/OByZDD2+Y4xqxANAxjiGNtqnPtORboXkM9/B2gePZwgDQ+9omkV4ZrRAdYVL7tCHPqKUj3Ok40j3EFRD9kQNullnGXXp4NUcQivgucUb4TnH/S4IEclAzyHCeMyzNKI4G5IDh07r0gupBjozqRGGLTyfG0kywe5144zCcMbb7JePdGypLIEKmTuwwYw/jmgeXQHGM5pBjGVMoxg/nMfVxOEMdUVDGU5yEjb2mCd6LOsZGNnIPKZBq3QgJiNVquN/smGMYrRLji6k2itFF0M4rrAefYPfOwC0nMdATx/teU+zsMKVcTkjHYH6oGWoIR6/MIMadhrdy/zyI2ZcA1BH/4oMMJqxsW3YrzIZAwZG8MGVQbItfv06xr9kGUcWrlNXcDTfC9GxnWNgyWlgFEeelJQjs+TDHH3TGFnmwSLKaGQe26AGNaZBDW9sJZKjc4c2EkqNa8TuSFaxj8ggkq6LDJRKwXAXPcSxTLZ57z8dY4Y53EnLqbmTQe10Z7SUxrRV6jAj1pBXiPJnvHQBQ28bAeGUIAJAdozUGqLDxjSi89ALYlMyezsJpHo5qIpQQxyD7BhTeCMrFKrQpVpjn0vXGEuXsqNYccJhTfG4DUqqqIfFUiBII2LRdx2OiyNdjjGvRqqLAGMhyQQg9BQHkahqbIf0YIbGOlbSbEQMQCb5jP9YIyRDsWLtpS4dx36kwY3+kKMaFVEsHr25DmfEdaMai901K+M+UhUDG905zST5556sGHQrbKVfZ+JqjObRoxlr6142usEbDjlNU5VtE2WRKyyxRqt7cjJhN/r1nj95Kh2/lWtcdQjAjDhUcV/pZidFh0rYQY9EgnSVaePawe4mVqu8kVM5yvFZYQxmuVar7Du/lF9g1GMaHcvQU/7DjZFYZLSUBGlc1wuM1G5lWeBNH6W4tA7JuGMbz+gYzRS4JQWixDIovOGG4vG9DpVtc/fdL39LV0t3FgZ+AX6KLrNhLMjsw4GMU/B6nbENd8AjOsKIYvpEthxq0OOgjgRyjkH/SrPyihRSS+vPhnD42bup2GAttTIs+fu1YjAlYjHOEp8q2B5XcRgACmacM5US5PZNclGNkhbNNKxgPoHRTqBCYYZEXI4OsdKrWVZulgUdFHjsjym98c/EeKunUgHA0Y+Oq6Pl+oyHtk+kupHJnHP8HmdYNFvLMeOe++UZeAza1KdOX+qARtwNdeORztgjSDisZDoDI4uCEl0+ZHJBpXQmquk6M50vIpl04EgayBJx077CDlQ329limiDQuPHl8PGvgiF7Wbpobdo84mcfp1PVPsQR5x/RDNIbtia28tKxpnRW2cxw5bPlLW8ud48bAsacMKgRosqIoxna3rbGPna//2+L6T73sAdpff2jYDz6zBqjhlnmUew69ice0mWl5ua98WcTa3XVkHIOmXFMQUm43Gjm6JiBahWdpApV93DglhjecIeD1Brz+OUIobwhdBaQ4z9vtjkSe4zh9meVatnKPdyT42B3OJFdBCrBve3tEOZm4Qp0OAAgcnN9pGWmG2pHn48LdLKb2upxMqE0+GTNxElLwU1XbMSjvvKp1z0/VUpwpB3Op7K4YxrvCXA5msa/eJfd8Cq+5XuWNuKJLatZVYJIsCW95A5GPVV2Zw9+VkWPdWxzo1h/NESMKUJpVQNZF1d7MTR+eNZv+e/dK4ecJmbT/Z2mRjuUOuZdjj9Wwf+spzrpkTWv4apjD9hp1IPHiVu//HX6g4ZAXlrrasoMbYjD93I9LaTGrPup0/0eW7l+QElykmmgg4yHVqVUnsFs5re/+f74hrGL3iG5WBXJJ1lOuoB8Z+53/15aCT9a+ZGyEQfp0ZjG0qUcagaScb8GlKOC8AdvqAsoa4eR0L9m2IZtwIYN3IZrYIZ0OQYjCpRPmbsSnLsaYrhpUMFpqCiA2g3/oL9iEJB+cMAaXCEIfJNj+Z7M8DVmmIZxkJmi2g8UEkEkyh4xMkFU8Yh8QEEgayXvoqSAIjre6JDjAQ0atMEsPB0IpIZU4jOT4IvEGo+KYgdz8IpSaZZAMUKsQAy3l6O7fRAie2hC5kAHd1gHbHCVYyAGYuiMxvqe1/mG0NDCQRSdfkAHUtkscuCGz5qLYRgGPuzBimIgbdiKSrTEAErCnuG8cYmIbbgqJ/ELYnBERdksickcQSTEVOSbvwMyaXDFDNtDYsA0kiiGZvi7zrDFFdTFXeRFXuw1iEAITgTGPWwcV3xF8FBBVVRGksA+tmEbYJzFoIjGZaTGarTGa8TGbNTGbeTGbiy7ZPDGcGw2NhLH5QsIACH5BAUKAMAALNsAxgABAAEAAAgEAIEFBAAh+QQFCgDAACwSABgAuABkAAAI/wCBCRxIENi/gggTKlzIsKHDhxAjSpxIUeK/ixgzaqzIsaPHjyAjahyZcSHJkxhDqhRJcqXLhihRJoxJc+PLkDVL3gSZMydCmz1P7rQYNOZQlkV1jiRoc2BSnUdNPqUZleHUiwWbGtQq8CrTrkY9Xu35kerPqWehyuy6lWpLsDU5jn1aMajTjUuXMn3bVujdknmBFp04ly7RwYEBcw0b92/KxGORFjb8cHJfrHrhysTL9/JBwZ2zcp05eW7l0Y5BY16sOnNn1amxwkxptXRhh1ClNlWa+3XozJr/7qU9W7ZC27ZrG1dunDdxzQdFA08tPXrv5cyPI0euO3rx5rRzX/8mHXr8cO/Pn2cnv720duy6hzuu7j22eOjSv9YdnZx95LTqQbScevfhV2Bf+Yn1221OdYcWgAESht2BztVX3Ut+nfdgWxp6lpR/8BF2oX/4mXRTeaZRVyKD9IWoYHcdVhVji4PZ56F9ZIEoo4o8fncgjBAaJuR/AEo4nYP1HQkiau9Z6GGNXj2Z44inreUjiT6W16SFt5nG4nxVWungQv2U6SJB9aRZDzD+9PNjQWXGqWF7dGY4npMI9ePPnnumCc+fazKH50BxnlkPONpQM80013wDD5v+XNQPRHFOCl17nknJ4psE6elmPehsMw0zwghTDDXmCNqQmS5uQ2qpwgT/w8w034ADzjjs1DMonJVq6h6CvhLJ6UDoeAOMNtc8A2swAJQ6DTtAMsQqnt8UIwwzzWTLTDHcdssMMOAEuqqc7v1GY7kEIlSPN89sy22pxTDzzKLTWDuNuD1KKx47zVwbLjD1mKPNq7Caeg06+CZUaX9M0hesTw3XM069phbMjDaPCgTPM9yOAyGl4m1jrTYIfdMMAADMam0xz2ijzTepKlwod//RiRA831yjaDPWzgprM94k7M3ILUrmHTzUmNpyzAON068wtFIMb7wHE1qpm3Vm/VSbArFzDc8FFzMNu0p7PBA84FCzLdRMmyegTuxQHEwwwjSjTaBrgvPqwddY/0u3tXVjHOk/C2tteE5mwqMN2BWbSg072nDbjNkaD1zwtd/kixttSZvKeDF3E+RqMMVsA0/fzTbzKjDUwFPP1YebWbibWGetZz2RCyQvrNfAw04xsm6DZuSlyvtqM2BKqOc3204zTsAUgy5uPSIX08yjItM9zuKkt87ntLbTPnOZg9OJNfWxMrON06WSzHqp2IirOPDF9C7QNbEaW/uute2JPzPgGAj1SGU3gsBjGqUSXj0QGIxpAMMcyhIGyV4HvsmUDyPfq1Sb9lQnM/mDedYzFv6E8YxHmcNaz4DWQPTGraANhF9Qa9hs/FEP/KUQTX2LV8a6xoxgXA8Y41AWM/88hg4hZi4jfOpTPTiYlCSC6hvIuoYUr4GNa6wPYW16ip6SyKeLtKkf7FBWMzIHwzECLIeZIwjFrlGQA7Lsgh35Rz2QRkIVqpFu7htI5IqRxqEJo3VAbIYP0bEntCVqGqqjWzOoAQ54/IOJV4sUnwKWM46h7JJzY1Ym60aN9cGDiVzEoBzZIapsNeMZ1KDGNbyRKxoisBjGAgY28CgQ9k1jh7izlv0MiMBn6OlMEKEh/pphx6b164YDMUe/qKExBDYDHQL5Rqmusa56vatgzRIbFiWlQRqywxvUaMYxhGGMchpDGuhMpzTMyc5ZbYOQXOQi9ZSFMrrBCgAsw9g4rEX/jUD1ixkZq14sNSbGthEUauX7iJ6qF0CE+DGP96tbqj5oLWDcTlliA5zYrhFFanCsVM8wxxKv1o96QA5s5kRnNbjB0pa6tBrVQGc5hXEMZlxDpPGkIfGuNa9nPINnGp2GGMfRp/b5A2C9xFe1SpcQGF7jlyHxxzhIBdGu1AMbdSsmv2CZxWcAYxu/TCMwfHiwJdKwTxMrnjm+SD52YINU5URnNrgRj4hwoxsxXacxTrXWJJ4ufdpghxMDpo0ICkQbfHpUCR8JD26JVSD9cqBFCwIOaxH1qCqph1f7KRx2kKqhA8HfNrJoLLBGqoiQDRcTMaInpBXjGP301DyPEdds/3SDHORoBzDiwVvevuO37+CtboHRjnaUoxzcyIZej+EM0/HJGwT8hlm/yEGTJg0YQ+QTtKh5EXhAbYfA8C4AwWIpYOAvvJhdCcmYsVaLSkog0BWeQNzkWW9Eqh9I2wZGasgyohJufxlBWk2JKjGO0VYatiWHQHrL4HgA97fFLS5BjMuNmJbzGM94nmbrRuALbrG7zHzGdMP4vDI19htdBGL9AsXakn6LGnt6ye8AcI0uegd3wnPi+rDmD9ex9ptrrYk/9PZVrwHvnLclR28fzOAHvyPCDQZuPMjBDWCs81raCMfIzEoTdFxDtTkVpiNZlbMdilK+KN6JGClYJjR9Ev+UacrIFgdXQZTMMbLPOLBti7tkJvf5tw3+M4TbQY5uWHmvESRqnTXCwTBv8HUacd1wepw0ZL5kXY4d3E8gWdKZEW5PAKbJnvRGt7hyoxztiDKgAU1o3Loayk128jsKrdyZBgOsoUaJo7tYuy1umoVsHEoYSThmOCWxxbPLopC9iI6k0Q3B3Eh1oKVM6G4oV50qtS2q2xFcWT+5HXiVRuoImeuadHMkrFIXMyd3FP4Cw74IkSc4tqGNbYhUUtwUMg3HsQ1xxvW2qeazgx0MYXLUmhnOoFcq23VOaawU1d5+MjnKcWgSeuPNVwmYN1z2DcFOB5rAuFdU0IE8kRMkicv/GxW8WsYOrNGOJvBwVTEEQk5pRHvgAl8yrZ3xjG1M14no0IYzmCGN2xLcyfEobjlqLQxg5HPMQSkw4JoxjbtNh5lAlBEzmQHygXxvv+O4htQeh2+SInGAxyBI0aUdaAcTWrnTCJcH2Ronf5DyGQiWtqx7C4xa0/yPSzT3PxRHKrFpo8Sdgce3RCwjs1VV2WdHWwSfhWxPF3IatBWIMbKR27b3th3JNQZ6++SOfIC6tfRIk92pcYxslOPowR04bwstjb8/c9GRplgznHvfDInsq+lttwOR53XIY3BwAyShrrhpeUpX9JydB3TbDS4NbDiykOfghjre3GN1qANgS0Qa/4LL4edVv732wLjWOEoak5L+z/rlM75ODihR/qnEH8IbYvFDzaqSQlcY3vBI/2V5ckQNM7d53eBbsdd2cMd9+XAOqEYO5/BJ8KAOqKYO9JBY07B53CZlskZ9Y9UM5oB7jyRV20JN5dYSRQQAt2R/KuExpfNIAvFFNDFA90J309ImByQQnJdqUqaACygNz4BFa2KBn7d95yBt7fB9SwQq4oRqsCdr4CZ6AARqJ7En2iAM3GUXJmheCXMUGxNyZvVhOdFv48B8OegPbHRON/eDUUhozGBfNJQPRshg5VCHwqUO+aAmTmd0EQdoBid6lHeFNORRWXRBMbEnaBZ8UVEPlf8GT+SDiCdRQ5cFOyXYUDa3ZLH2YEsHDC3nD/OgDkooioH2erylh970DK5HcNNWcOjXT1dYUva2Wj3hiNi1I6ITL+BwekWhJma3J06DZD4ofUAIXN0gDdQEiuoAXEvoDhDog+VwDudAiuSAgWlCDdLweguoasFFDut0DPZFEuQTeCk4iceEi8RCVWNYFB7mQf9QRLTFebC3icYoDcbiDqSYdOWwDmkCgcd1DksEgbx1h/TwVWtHjJs4ZcdoDM2wiyfhJpKYE+NQKliHjsBwTGtCgu0XSf6AVdBXjPT4W8coXc84kADZhNM4gU0oit+2fd5wkAgJkuRQDeWUQoSDbjf/GRSWkoXCAFromIXFUEwPI2eRVC1sGIV/KJL2GF4W+I+qJ0muA2o9loSnmA8v2Q0duI3FKHHZUE4wFkqUIRBiBF64uE8SFCSIIzHscgxFRw5J6W3HKF/0YIHnsIddJEnU5Q9zeYf5YJBYGZNbWVzcsE7FAA5YRItTIhDmcIJpYpHhpSyMNyc90WzWYgzVoGRvKWuDyUxpgo9RaVLoEJqhyQ6ftEXTOA9HdQ3ZyIqe12BLR4XPUGOI6RMChD+w5JgDMTRMdS6i5lnQl5netnQpREPwsD2IBDiXk3bO0EnmkCtzpIpu2ZrlN2VdKUE/VyPEckxkiY70N4S8mYjXcE7Z/5CVwAlcyAU64JAs43RhtMVO7ikMCXd40GV0mtiaOLeQxASWtBlapiJfuCkQ1UNNDRIUWYQOzLB5pgicsIdce8UMx7CeRIdtEjpTxeOguPVn0smM1TlaKIcSELkcv0Ns/ylAr/RYMyhn/zWAj6Qn2CCMboiUxAh61dCe4qlt2xZhEXZchWZtMlUqCJaAgrZ3EBYP+PlmlkgSCUN/xUA5I6piJOQxh2JFy/dfNnZ8YbR5mLlqf9hbtJdSCTZxxaWVSYejE8ejeoVkuVWe3diVsOQp5LNo/eBl1+Axp8OYTSpAxAM07ZKfLSZPpIkOYfdaf6mm1CkNNZdgUFaeY0pl2f/QleWUYDAqfUzWDeO0e+bwJ67jabUDDMwzK9Z0S3eKQ8gZUl2Rl/tGMvdUKsagpq5oDMGAoJGqqJ9Xa+X0cDAaZdQ5TqYyTmLjDSIlPrTBPLACqqEqqhxGKGzlD96ASMAwU7RVc2pKaINZWxDHqkjXZLSWUre1d20HbsdAN7TVLE23SLsIRwBqLc9UrAjROf45gzT0DR/VdOfElnpVDZkpXFSmVzand2/JjbIHe8ZlYWxInq1ZXA9Kr6+VdvDyOPeFJgjEXupKECFqchKLDcVgDOTUegkWepmogFs5e9lAW62XpfeKq1v5g+WwkGj6r635jaeGXNlgYaUyRktUEOb/ME0Rm5sJhBBxk3Z9N1e4JZjrJA1KdnQeC2ivKZ5pGnH4OnHH9bRPm3PzKFwqu69+xoDGcAynZlzlQGtdiV0YkzBC9IV3ukdM6ol5prQL1luOOp5NxprCVWvjx6U4SqbdYG2Nmrd5e7dBC5KfN61YerWBNpjCII+fBwx4BQwPyllq1CzbeadYBbECRA2PipW8BQxS5qhAOm2f1w3mtK3VBlN5y1J5dabu+aoNB22udrd8y2fH+KpEO4xaGnuDGQyud7XUVyoDJRDTgE+P26Q5RDmH4qBrt2SYG1ya67GBBm5D24OgR6vNek7mFL3umbU0mlISimBzlXTH+KA9GKRJ/+eNAHC7v4W5vZWyiLYmgdK7xUC2TQoOxwA6BIE/58R25QtoyWu0DWZwzVoN2+aN5VRqwTAQA8wo4iAO80APCqzA7iAOyeIMr9WsA8FO6BRhx2hllvuxbycM2QhcxxtcU3gtA9VYKZOzAlEPpMIMKkR/9QuEAxEPbUuexBiIfccNwXWMpdIsmTQ3ANBAA9GXC+EO20ANrxorPUxO5iSP7dC2rye1sce/Nset4KZI8oU77WPCApE0x/AsAONlNJXBD7ZbmtcNTMu8bKhkgWjEPHxJPVw6ClwQ+FAQCoxVpbLDsYK68hiIDrdt11oO6GfDHwxcBkc64/Aop4OuBqWuw/+GT9hQyOBQKoYLhDAsegnobVOmr92AatNKN5x8OXPjDO7wxgtBDyKDsfZ0yqVWdNw7tG3oZ34MADYXyMBVu88UKsoiK7trwkEkrvLCehy8ub5VV9wQjzA6hQPxozTJycFwDKa0NgN8DNtQkAzhDl41TvaUw83iqucUvujntldLuNkoy79FuPLyNAnkvopsgKUyTuO0r/X5DoPZel2bW1k5rQQxr8DQxtOwDevQz+sgDtjgDOVkDfPQEKUMDM6ADduw0NhggM+quCyFflZWtN14txYWDLFcjEtsqLECL3GHzjlrDuFEMO7ssfnKwY2KuEkWiAOMDUI3cwOhPtIsEPn/UNPzYIDM4A4NwXrNRQ81PRD0sA4VaWUSzYNNDMUzBQDiKbtPFrLwQq4gjcXAgA7g4A3XcKCraLQVh8QNN1eb/FX5IMSYd1gKXNP5sA/7YA/4kA/z8FbpwBDz4AzWsA4+bdZ27Q5D7XThNFb7am3RW8SxgqZZ6Y11sw3fgDBSHREkh2QQNmtOHb/MENkRTNQUSg1lTQ/WwFwJfA92bdYC0dbtihDrYA06XdM+XdZmTQ/fgl3WIA7UPFbnFFMCkdDisA4NbIACEcXF5dTYkNgVQblRzJUYeyq1/c9D7AzUG7/B4AzrkA8+fQ7HgA2dzdbrkA7pQNfAMA9vrRD74A46/53d1W3bCbzWzs1GzIDA+bAOAj0300sNzW3X9CAOysKBhEaYuezbD7ENtGWvT1a7slR6pu3c4sB65eQMzvCg22DWbZ0O+4AP+yDg1GDgBk4N4tAQ+/DZ2/AMztAMPIcNdG3W4sAM1FDT+FDhWZtJxoANpYfW+EDe6X2gxuBq0lBTQonfDqF45wRo37gN83DWdp3AcT3Q1rBOwLDiYT0PDo4P7vBW2GXgPMMMvd0Q4lAvCKfh3+IM4uDc9LDkAJ4P+l1Tuird+XAPZG4P9sDZ9qAP+l24d7W4Nk4RmLeqT1ZO00APLd7iaI3WbH2g0mANQ561CW7XD54PFgs6zhlzPP8T2giRZ86jJuPATMxt011ODxuIYaRyDFle0/dw5viA5vqg3hgdesZgom/uEN5AW0/WDTSV4A1+5w7+4BXOXH4+5CFX1yT+4uozODRUD8zjDAV95vdQENiwxY6EQUgjSwts1/ptDMxgDQItS2aND/MwD2SeD/ig1knjcDPOdaUuERtjuzEFn+lg7Xje2cN+DNUw68hdDFk+6M7NTMnIYzp1KgqRDtiyVnWXiuetwINOD8htDLOunD2ewO6wDuPd6ftQyugEeN0eEY4Y29IQDKRN7veAD9ftDglMuccw634uEGIO4gjncQPYWqpT4Qgx7PGTrCUoPJZt6+Iwc33u587/sMyuvQ3Y4OfR3OL2sA8hnrWA3vASMTTpJAzY4NMNrtYBzXPyPcAcn9msU9N63tuyySdU/Q3hgDvRjRDuMCq48g1e73GFFC/vvQ/00Nsbr+4Y61G0pT49fvTp7Qw0BZ9nC/QMsdgzJeZuT+hwX8fNru5pN+IOztZe9UmMdQ3EcPjEEHcIhxAh7gzgoAzEoAyQL11n1dusTvbMdPYBv8xZ694kvun6wNYzPzeMS/cO4YgPirEf3+Agnmfpw/EiG+hnrd7MYFY1RAzRAA3QEA3KgEjH8N0Dod8+pQy6v/vEsItLZCzYcA9oXfYPKtebv8xFb9edbg9hPfO6a/oRYZaq/1/Xem7aeP2gff/nJNTjUL8OISdJ4EAM2lD80KANxHCxwO/xpqIM7V/8va96+/QMr54PACGOmbBjzqwdLEYQGz16+Rzm24fPXj53zoIJK8YOGLB/Gz1+BBlS5EiSJU2eBDZQmLCFD10yXOfMmMGDzjZug+hwnzhj1Pz5qzdNGTRoyhISUybMmDiQ2IQxm1asGLFoRIl9+2mOGTCGD7dtpGlt4LOGLh/iyxczWLBpKN2+hRtX5DVhF6/BY5i3LEVnBQ9ae3YMGDV6+x6u6/kTHlVo0YglFNaMmbFzTY09k7qSGFFl1Or5MwfsWT5g+wx/Ff137N58+FzjM7yu2cpvcvVt38b9cRwzAMII6+3qcN4zY8z+WjsmzFlZ04h9+gO3uShBYxibGUtneWD1lcOgDXsGz9/u0RENYwtm7Phql65NOxQYWWNu+vVPwpu28pk7sw/r0SPumPWCYaYrtMQp5pmftBkKmseKcaaY6o5xB6RtjDlmpmIybLAZdMYrZhqH0KKHLvUOwowl1vrbJkNs6rEvRhlBGqgYqKZp6yNqqJlmMsGkkYaZDI+Z5qAiAytmx2aQMoqgCNcSDKS+iiEwoeKUUQaYaXg85kYcp3FmJWaChMyZL0cKc6YZ12TTpJWE+SiYj4wxBpgo5dxIqmLaJKlOPtcMCAAh+QQFCgDAACwfAC8AngBNAAAI/wCBCRw48J9BgwQTKlzIsKHDhxAjSpxI8eBBiRYzUtzIsaPHjxMzaoQosiRCkChTqvxosuTDli1JrpxJcyPMmAxFArt5sabPnxV5FrTYkGhCnieBKlWKtOfQpEd1EmyK8N/SqyCpOt3pMqpJgVa1WsVK1qbWqTh3ck27lmrZty/PPv06N63Om3DzKsTbdmzfk0bb1vXbt3BXvXk1Kg78dy5YxlIfX1y8FahbpkQpQxWMFjBjyYQ580UaUmxkkqONqg58mrPrup3HjjRd2SvtwzlvF349MrbjvZVXe6Zd9LZQ4MQlgyb8GTRs28ydSj8su/Vf42yvQ2fd83Nt542h+/9Wvnxz7KTYTT/PzX14dPPOw2ZGDpb82vEONac/27v4dL/Bfefdd/dFNZVXGO2nIIH0+YfgQs019xhwMy1oIU2hccXeZv0lZqGCiIEnnl4fXkiihB2qdR58CZZYIkrWIcdiitsxuCGIMuIYFG4Q2ihhjjYCaRxq6fXTT2k89uhjkIOxKGRyBTpWpD8t/qhkhiNW6SRB/uy33l3G9VOPiv4xeR6RWOZnJZcHdaleefK1pxuaaZZZ5287bimQm//048+ff/Zz3JtaCdqnkRGtuWGiirJH5J//1AOooThByZObbhqpp5lXMsrpgw1B2udBRlKqqVS6IeWPn/7UQ+qRat7/GauseNpEpkKAGtQqONhQQ80140jqJ6WTYXedQYLWM84100yjzTjwrAprUR41ut5MgHbpzzjTFCPMt8IUs82qq+pHXEutauPtt8EUcw08pf5kba0rZfsPOs4cI8wxzDAjTDDNjPNPuU01Vmg92/hbTDPMBBMuNfAK6tO8Iq40MKDjNBMuNvDUg3AxxVAjKZgdQkWVP/BoHLDH5kwT7jT1SFwTxa9l1WaX8FAjDDPaSPpnPToHzGd3NIpX0p/ehOvNz/6wo7Mw3sQMqMVFX0lrRD/Do02zzxQTjMjZ+qPNMcV84+psmdElmkiSYhNutNmi80wwzDwzDTVRq1R1mSvV/6ONvwA47G3PF//5jbfjuuSirtQADDeg8HTrrUDCTGNOSnvfqNI2wITbTLP+MvONveB4rc3Qi2fkj8vM+AzoNSDb/YzGwjTzDYyfZunQmAx5I5C46MADzzfNfM0On4cHsw2xqZPqzzW1P960t88Ez8441HjdDDss0XzmgROZ0wwwzZjDpz9Bs1M49MUI3LxIgnrjsPmBJi3MONr+qe7XCX5fbdp6Ikg9YCeus+lqG/xCh64iF4xnqO99GRGUOb51OlbZL1jZylm4boem8PxPbQyBFMq89oyRHWSAC3vgtvwlssJB8ITPEEYJ6/ct/IUtY5XTkJ0y56mqhW1g1xDINv8sIqjnNRBuQKMbOHQlqhf6YxtKc9M4ghEMb1DqZ0EERuIYlKQPMihsXWLH+JixjXGYMWb9gMfcIDYwdvgLZkxE3fvQ0YxiTAMeBoFHMQBAjSKyAxyAhB0wZmglHuZJSV0alp+8UQyB9Ct2ZvsGMwo4MJ0dY2mFk2PzUCgubU2jXebQ2iSLwYzOCQMY5mOe1So0oKPVAxwxBIYx9MUucTXOGcfzx+Eq57pcvfAgKdvZ8fqxy2vADlzfAgAAhEGNYVrHe7N6UqS8oTG6YcMb3/AGAUEWjGtIih0xbAY4TPjLkuxSZGmMYb+O0QxtfGMb2sjeyxQIwpp1j0MmUZbG3NX/MWmh8FvMUB8ne0awcrJNZ8yIWj+80bBgXFJSEAWHPEtYT2guqkkHAefOeua6mI1DYRXchrfAxjyDWkR8OwMHyqYROGdIjU+R+5Y3eWTRTsHJItr41jYgmsg/ZSwYd6wHSqtnQJMe7Rv/aoakzOEvijbxXqxTqeIqZjOTieRn3oLjqQ7y0WJow0/gUNkDb6OpUglqq1QRExRl+Cc1CsOlAyNWP3DIxsjUdJXHihQUmeG+qzJSXH3yR9KAcTomiqWspSLVpUQlJpc9A3/1iGlAE6m6nPK1pMvBEABFokagouOz6GCHAYFWO3MMLFLNAEAzMCUts6Y1sW0yYbkAJdsV/wrDmz/LqTAI+jNz+PZ6IKOGHD2ot6Ywcmf++tYg8bdQb81UV9cAQOvEhI5xwHMb2/gGPU87sHqwwxzj+AYgx2vG4AmLiN71hjfg6Q1orQoczDjGuHwW04CJCb5UXCbIdhYtvmj2JgNEJrg691h0+Gt7FnkiMJjxWWqMjyDFeIZUUfaNeM5uXf/6Fintdo0yonGaz4BwhLUBD/gCwxuROi187Ti8agZDmeAqxhL9+9+rhjGGGp6GMbtVu66VbWgK9mosB1IMWjrjG9+YxoJlaYwmN1kaUHayk5esDdF+VF/AaKQpI3yNUqKYUgGW4RiNiY2ugauFT80dR4ioq39o8P9h5hXe08LVM0MBaq2n5LJ4weGNaejrGMdwMpSlkY1CG/rQg5ayHTXmjOwieRvX0FiWszzEnq70XwI5XURxTMaYxUhefjrhMXfLjityjs7RumKYN3q8wIKjW4KWRjW4wY1y2PrWuLY1ObqRjWpIw8lUnAZtPYa9AX9VW91t2e/oF9eWeSuhQ0PMzyQJAH6ibhxZfm5cYxY5kIlOWPVAR/YCDeVsdIMc7YiHutfN7nW3493tKEc3eP3rWVIDg7TVLTBmyirIHRhuh7p09EI0lXq4jJnwiuBHoYbe4WWv2jv1GDy6LGhzlwPd7V73OzLu7njLO8rGYMa7MBW5Y5DvWR7/Y5WY5sYM6QFKjKfUBsEHMldvIZiIfjqcjM+HvUb+y5v3PbgxCM0NjHNc4xvf+NHjEW9u/Nph08BfskMskGZcI5fdvUa7XAXGJ8aOezPvBzU6t9OSkLZ6bkJYciMcNZTBbujSKPq7kc7xdyh96XZXejuy8euNPo4d26D6cmeL1GIsresxNfzMgVGP8RVju0SUpLtcx0jpYmOcrRpHDJucDbmz2+7tfjc5Rk/6ubc77/Gw+677fgyOZbDPBC51HjX2DJfndqS8C5GBB1nUE36y5dkKsThH5o+w/ssY1UB33pWOeqa3Y9e8NvS8R5/u1Kce9HYXfd9ZHKi2qsurZ/tY/yfL1W/4DpzgxxWu6urBSHEG3HfPMAd9gwjobGB8+erO+/O54WtpMMMZABiA8SVr1VAO6YZ9y9d09YZ2zpMw7cMqH8NXyJJBqSUMYBci0LNbcgROUecqRrI68ZdIAyQQhGZ01vd55MANfCcN1MA5ocUOwhNe2zANzEB0B5h0CVgOTmcMwBB1rYUyfzM6gcJ+dtNLgIJjHIQYBrdBbAMPoUQsBjc6BoFCQ2du1Xd0qycNl4dErWUkkfUN1EBo3ZB/ywd677aDg4R1fgI0p9N9TWNDP/Q0PRMibhUwVFEPUogyliQN5wZ6HPd8fPdYHxhZHgiB/fRKz8CH5XB9+Kdu8f/Gd8bwWGjkJ07YdZb4D8eVRYihUeWjFdpSD25zSnJ3d6dHDoEIh/XgDupwDh7TKvVwDueQD62oeXzYDmXYbruWDbMkiP1GLpYYNsCAVMxEcHQEAA7UFK0yhfuDfAa4dOrmdM6ADrS1Dupga6z4J+dga+rwOPgiDfeHfRrXDt3wa8fgQIqUSb/4J8H4LWOne7Q3VujygZGiLsfAh87obtLgDODAKvCQjdVHDucADOuQf+2wjYGyYidIhmVoioF2R13Yi5YoEMLYjpsYQwwIE9JiOAPYDc3ojPF2DAQVWdnIdNdXDuegDmRYkLLoMddwDORwd2Wof+Twa5NXVuk4NevJeAwUqRf1JXXxCCh0FAzGkA3xdoVHJ2/l4yf5MJLOp38KaXfXuC3OQJSOaIu3yHROd0pWdFY3qY45KXMEpzNlU1KvUirsoGRDWXS3Bm/wxm5OBzMoow5XaJLVCG/ksIoG+A4mCVFhWGtryZamFw/jKBDjYFaGeZiwklNlM3PNoC8h5iuQ6SsE0Y5dkxCDdpmYCWXsRA3NkpnT4AyYWQ3T0H/5eDfU4AzAkJmqKQ2pyYMJEZmwCZkDQTuCt3hkAS6uORFNZpsgERAAACH5BAUKAMAALDYATAByADAAAAj/AIEJHEiwoMGD/w4qXMiwocOHECNKnEixYsKKGCP+28jxYsaPAjt2BEmSoMiRJS2e5JgS5EqULTW+3BhT5UyaNR3exJkT4smBIns2hAksqFCFMwsSPaqUpcmXTHc25cl0qseQSYVKfUq1KlCnX7NaXLiT6lKvRcGm3drSaNirZ70SXRo340+uHt2ixWpW7dquH/X+zVs3Ksyzgu365UsY8N7DixPbvGtUMtrKYMUqLtv46t63ndlO5szY8+fSpUVP5Dzy7mmrCVkvfuh6ME7LpzG7Xbk6sW7Hr1FLrq2zNezBwRkGHV7YoGWUuJNDn42aNvW/b5MjnX69Oei5kIFL/1cLnnfxrHpbQ3VOGuH68jTLDpXdVfZ3+6lvFr2vXzl99vQFKKBgAfr3H2wDJsgagMath6BnxNnWl4KiaZYfgu4hFpd5ElJoIYd4mUZchNiF6JSHCZoI2IZ01dUiZSgOyB+E1KVXY3g/xeghf3htl5mLOJ6o4473gebjbUBOyNOQMR5XHYMXJQnXj0w2aZWRUDKW4YQzViljj9ltidyVXHWJn2kdHhgWe0eSuJ2Z8vE1VX5qpiWRetcZmOKTvwkYGEvRKUUnfhLyKaA//vSzWWzeQdkRopBGKulAklY66aCWVooRnuK1yVGmmgoEKqiYjgqpRf3E16iKpibaD6Kitk0a6av+xCqrpRW5qigw/fS6q3Un3QqrsLP2KpCvyCarLLIU9YoTNdBSE1G01FZrbbUCXavttdlu6y20FFHbEgAFCSOQuQqhG5G62g0UEAAh+QQFCgDAACzbAMYAAQABAAAIBACBBQQAIfkEBQoAwAAs2wDGAAEAAQAACAQAgQUEADs='; + +const outGIF = 'data:image/gif;base64,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'; + +const test = require('tape'), + base64Img = require('base64-img'); + +const ImageSequencer = require('../../../src/ImageSequencer'); + +target = 'test_outputs'; + +let sequencer = ImageSequencer({ui: false}); +sequencer.loadImages(GIF); +sequencer.addSteps('brightness'); + +test('GIF input works correctly', t => { + sequencer.run({mode: 'test'}, () => { + let result = sequencer.steps[1].output.src; + + base64Img.imgSync(result, target, 'GIF-result'); + base64Img.imgSync(outGIF, target, 'GIF-benchmark'); + + t.equal(result, outGIF); + + result = './test_outputs/GIF-result.gif'; + benchmark = './test_outputs/GIF-benchmark.gif'; + + t.end(); + }); +}); \ No newline at end of file diff --git a/test/core/modules/add-qr.js b/test/core/modules/add-qr.js index 8d402cdc..8e8180b1 100644 --- a/test/core/modules/add-qr.js +++ b/test/core/modules/add-qr.js @@ -1,5 +1,6 @@ const testModule = require('../templates/module-test'), + image = require('../images/IS-QR'), options = {size:200, qrCodeString:'https://github.com/publiclab/image-sequencer'}, - benchmark = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAklEQVR4AewaftIAAAApSURBVKXBAQEAAAiAIPP/5+qDMPsIJJJIIokkkkgiiSSSSCKJJJJIogNrygQcXEYsHQAAAABJRU5ErkJggg=='; + benchmark = 'data:image/png;base64,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'; -testModule('add-qr', options, benchmark); \ No newline at end of file +testModule('add-qr', options, benchmark, image); \ No newline at end of file diff --git a/test/core/modules/colorbar.js b/test/core/modules/colorbar.js index 55fbdbef..769bc6cb 100644 --- a/test/core/modules/colorbar.js +++ b/test/core/modules/colorbar.js @@ -2,10 +2,10 @@ const testModule = require('../templates/module-test'), image = require('../images/IS-QR'), options = { colormap: 'greyscale', - x: '20', + x: '20%', y: '30', - h: '50' + h: '50%' }, - benchmark = 'data:image/png;base64,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'; + benchmark = 'data:image/png;base64,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'; testModule('colorbar', options, benchmark, image); \ No newline at end of file diff --git a/test/core/modules/crop.js b/test/core/modules/crop.js index 5b85e50f..c118af3f 100644 --- a/test/core/modules/crop.js +++ b/test/core/modules/crop.js @@ -1,10 +1,10 @@ const testModule = require('../templates/module-test'), image = require('../images/IS-QR'), - benchmark = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAtCAYAAADcMyneAAAAAklEQVR4AewaftIAAAKGSURBVM3By29MYRjA4d/7ns/0Nr1MW5ditOnFpXTRiEqElcSSCEsJsZRY+AfsLZrYCxtdYidsJCISjSBITFRNm5ZKMNS0Y2Y6x/iwsOs52nFm+j2P2N9wmOI4xXGK4xTHKY5THKc4TnGc4jjFcYZVyuSW+JDNUyuGFcgt/eDaeJqH6U9kiz61ZPiHl3PzXLqXIpNbYi0YQrz7lufinZcU/DIIa0IJcXX8LQW/zFpSAsznSzyazrDWlABvPi/gAkOAbMFnpTY217O/u5PNrQ00xQxRMgQRQAjVsM7j3MHtHB7YhKdCNRgqFPOU0WN76euMU02GUJYgp0d66euMU21KBZJtTRwfSlILSgWGtybwVKgFQxhhWb2dzdSKoQJbWhpYiY+LRe68niOdyTHxKUu26LOcRGOM9oY6Rro7OLY7SaIxxl+GKrmdmuPK+CQFv8y/zOdLzOdLpL8scvPFLOcP7eTIji7+MFTB9SdTjD2dphKl8k9G76eI1xkO9KxHCSIWxIJYEAtiQSyIJUz6yyJjz6ZALIgFsSAWxIJYEAtiQSyIBbEgFsSCWBALYrn8IEW26KNE7MaLGaKQLfrcTr1Hidjj2QxReZNZQIlYrvSDqEx+XkBxWOb7EoYwwvKEYEKkFMcpjjOEsqyeJUqK4xSHtdavQwkjgAACCCCAEKqnPQ4CCCCAAAIIIIAAAggggAACCCCAAAIIJBrrUCLW29FMVIa3tKNE7OhgEk+F/+WpcHQwiRKxXRtaOTHUzf86NdzL5pZGDFVwZm8/C0WfuxNzrFbMU87uG+D4nm38YQgigFART4ULhwY53N/FrVczPP/wlYJfJoinQk8izkBHCyeHukm2NfHXL0aNt5iWSds9AAAAAElFTkSuQmCC', + benchmark = 'data:image/png;base64,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', options = { - x: '20', + x: '25%', y: '15', - w: '40', + w: '35%', h: '45' }; diff --git a/test/core/modules/overlay.js b/test/core/modules/overlay.js index b29293f9..4e514269 100644 --- a/test/core/modules/overlay.js +++ b/test/core/modules/overlay.js @@ -5,16 +5,17 @@ const test = require('tape'), image = require('../images/IS-QR'), target = 'test_outputs', options = { - offset: -1 + offset: -1, + x: 50 }; -let benchmark = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASwAAAEsCAYAAAB5fY51AACAAElEQVR4AezBCXycZ2Hg/9/zvnNqZjQ6Rhrdp2VbsuzEp2Injh2nzgHNRUNp0xa6nGkLWY42icu2y7YEtvRftp+0pFlSUgo0FGoggbgJBozBjh1f8W3rPizrGM1opNGMNOc7z2bsHRDzn1dOjKJIn53vV6wWuySvk4BEkCIRSNIEEpAIUiSCNIlAkiKQgESQJhGkSASSFEGKBCSCFIkgRSJIkaQIJCARSARJBCkSQVIIkihIBEkhSJEIkgikUEgiSCKQQpCSRCBRkEKAIkARCFVwhSIQigBFIBQBiiBFqAIUAYpAKAIUgVAFVygCoQiEKhCqQCgCoQquUEEoAqEKhCoQiiBFqAKhCoQqEIpAqAKhClKEIkAFFAEqoIJQBFeogCJABRQBKlcIFVAEqIAiQAWhCq5QARUwACqgClC5ygCogAqogEFwhQqogAoYABVQuEqVSBVQJKggVQkKV6kS0AAN0BBoXKUBGqCBiAFhEGGuCiNFGEQYCIMIIwlzhQgDYRBhpAgDYa4QYSCMKhIYASMSk5CkGAGTkBgBExKjABOSFCNgEhIjEpMAI5IUI2AUoAIGwACoXGUQYABUwAAYAFVwhQFQAQNgAFSuUoVABRRABRRAFVyhACqgACqgCFC5SgFUQAFUQOEqRYIiQZGgSFAkKJIrFAlCA5KABmiAxlVJQAM0QJOQ4KoECA1IAAkQGpDgqoREaEAC0EAkgARXaUAChCZBAxJcpYHQAA3QAA2ExlUakAA0EBqgARpXaUBSIKWCTCogFVKkVJBJBaSClAoyqYBUSJFJBSkVkAoyqSClgkJOTk7OEqGQk5OTs0Qo5OTk5CwRCjk5OTlLhEJOTk7OEqGQk5OTs0Qo5OTk5CwRCjk5OTlLhEJOTk7OEmE4k/wcOTk5OUuBQk5OTs4SoZCTk5OzRCjk5OTkLBEKOTk5OUuEQk5OTs4SoZCTk5OzRCjk5OTkLBEKOTk5OUuEQk5OTs4SoZCTk5OzRCjk5OTkLBEKOTk5OUuEQk5OTs4SoZCTk5OzRCjk5OTkLBEG3ma+UJThwAyLQb7VRHVBHqoieLN8oSj+mRh1xTZMqsJi4wtF8c/EqCu2YVIV3ohwXKPfP02l00K+xcRs47Egk7EQNXklGBUDb0REizEw46PcUki+0cobockkAzM+VCGozSvhrRTW4vSHfVRYCnAarMzmjQXxx6ept7owKQbeiLAWpzfso8pSgNNg5XqMxUJcjk7yRkmuj2QugpQCg4V6SyGqUHi7GHgbhKIJnn21h4M9YwQicRYTq1HlruYKfndDHU6LkWsJxzU+t/ccRwfGSbGbDXzs1hVsb3KzGITjGp/be46jA+Ok2M0GPnbrCrY3uZnL904P8uyrPcS0JCnv3JjHn2zYRDyZ4H91PM/xiW5SbAYLH268i1tcLczlB8PH+PqlnxFNJkjZ6b6BP2q4E1Uo6GkPDvO3nd/HEwuQUm8r5bGme6myFjPfvjtygn8ePEBMJki5q2Q1n6jfSSyp8dnuH3B4spcUu2rm4/U72VG8krn8x+gJvnz5FaLJBCnvLGnlT+t+A1UoXEtIi/LU4EH2T3QxmQiTIhGkScGvkPySJEWQIvm/BFdIfkkimE3yS5JZBEgEaVbFyAOuFj5ctpECg5WFpn7mdSygM0MTPP6DU5wemiCaSLLYJJKSds8UP+4YZUNNMQVWE3P5x5938rPuMdJiWpLD/T5ubiilwGri7faPP+/kZ91jpMW0JIf7fdzcUEqB1UQ2xy+N84WfXECTkrSu4TiWogkOTZzhFd9FEFwRTyY46u/ipuIVOI02snltope/7/oBGpK03mkPqqLSml9NNhEtxuPnnsMbmwLBFRPxaS4EL/MO91rm07HJPv6mZw+alCC4omtmDINQ+el4O/v9HaTFpMbBiR62FjVRaMwjm6OBfp7ofQlNStK6ZsYwKCo3OqqYy8ngZT7e8R1OBAeJJBP8kuAXBNcg+BWCLARviOB1grS4THJ22sOL/nZuzq+lyJjHQlJYQIOTM/zlS2fwTUdBAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEImAjH+OwPzxLTkszlYN8YCEAAAhCgScmhPi+LwcG+MRCAAAQgQJOSQ31e9Bzo9YIABCAAAQjYf1LjJ0dVMmkyyZHxTvQcGm8nm8PjHeg5OzWILxYkU+/0GAMzXubTAX8H2Rzwd3LA30kmTSY56O9Gz35/J9n8zN/JXAYifv6s83nGYiEWO198hj/te4loUmMhKSygr7zaTTiusVQMTs7w9WN9zEVLSrKJaUkWAy0pySamJdETSyTJJpZIkghbySaeTKAnnkyQTSyZQI8mk+jRpGQ+xZIa2cRkAo0k2cRkAj2xZIJsYkmNufzT4EHCyThLRV9kgn8aOcJCUlggEzMxDvf5WGr2dY0yl/XVRWTTVutiMVhfXUQ2bbUu9LTVFZPNploX66uLCF3YgNRUZttQtAw9G4qWkc2Gwkb0tDiqsBnMZHKbndTmuZhPbYWNZNNW0MBGZz3ZbC5oRM/mggay2VxQjx5/fJoDkz0sNXv8HSwkhQXS6Z1iKfKFogQicfR8dOsKGl120lRF8KHNy2h257MYfHTrChpddtJURfChzctoduejZ/syNw+sqWa2tVWF/MHGej66dQUNhQVEBlaQogqF99XtYLmjEj1bXS3cU7GR2W5w1vFQ9S3oyTda+VTTPdgMZtJcJgePNt2LKhTm023FK3mgbD2zrcuv4X2VN/OxuttZlldKmioUHq7ZRou9HD23F6/kwbJ1zLY+v4b3V25BT/u0h6XIEw8xmQizUIR8HQtgb/sIf/fTi7wRboeFtloXFU4rNpOB+TQ8FabHF+TCaIBQNMEb8bf3rWVNRSF6PMEIXz7URZc3yIM31nBvaxXXoiUl+7s99PhClOVb2NFUht1sIMUXinKgdwxvKEpruZMt9SWkXfRMcWTAh0lV2FJfQl2RjRQtKdnf7aHHF6Is38KOpjLsZgMpnmCELx/qossb5MEba7i3tYq0i54pjgz4MKkKW+pLqCuykTYcCNPpnaLCmcfyEgdpnmCELx/qol928eANNdxdvoG0zuAQx/zdmBQDbcXLqckrIW0kMkF3aJRySyHL7GW8EVPxMBeCl1GEwur8aqyqiWvxxYIcGO/AFwuyylHFlqIm0i6Ghjky0YNJMbClsIm6PBdpQ5FJOqdHqbQUsNxWRpomk1wIjeCPT9NiL6fE5CDtQmiEw5M9mBQDtxQuo97qIkWTSb42fIQXvedYn1/NI7W3YVfN6PlP33me6NtLmuRXSQRpZZZ8bnbWU2UuwKGakVyD4ArJbILZJFcNRifpmPFyKjRCUIuCAIkgTfKrJPCVpnex0VHJQjCwUAQgmJPVqPLHtyzn9qYyVEXwVgrHNZ490sP3z13m19HjC7HrxZMEInFSvnSwk4ueKR67vQU9WlLy+IunODM8Qdru05f44v3rCYTj7HrxJIFInJTvnIEdTWU8dnsLu09f4pnD3aR940Qfj+5oYWtDKY+/eIozwxOk7T59iS/ev55AOM6uF08SiMRJ+dLBTi56pnjs9hZ2n77EM4e7SfvGiT4e3dHC9mVuUiqcViqcVmbr8YXY9eJJApE4UMAzeT+hIzjMx5ffywtDR/jX/n1IrvrW4EH+6/J72OpqIaXcUki5pZA3I99o5aaiJt6o3ukxHr/wLaa0MCm7R46xw9XCY8t+k90jx/jywH7Svnb5EI8teye3Fa8kpdJSQKWlgEyqUFjtqCTTt0aO80+XfsYVAr46dJg/b7ib7UXL+WTHbk5NXUYCL/sucCp4mS81v4cSk4PrZVWMfKr2Nu4qXokqFN5KM8k4T15+hW/5zrCYqJ95HQugZzzE4X4fekyqwv+6fwMba4pRhOCtZlQVNtUU0+zO52c9Y0iJrjtWlON2WMnmib3nGJycYbY+f4jGYjvVhTayeeHsZfZcGGK26ViCyXCc/d0eBidnmK3PH8JpMfLMq91IyS9ICaeGJhBC8HL7MLNNxxJMhuPs7/YwODnDbH3+EE6LkWde7UZKfkFKODU0wQNrqlEVQTZP7D3H4OQMaTJqZcjYjsOYx9f69yGRpEkkpwMD3FOxEVUoLIQnOl9gMOIHwS/0zXhxGqw8c+lnJJGkJZGcnBrgXWXrUYXCm+GNBfnzzudJIrlCgERyYuoSQgj2eM8CgrSQFmUiHmZbURPZdM14OTDZgx6TYuSZ5vdwk7MORQjeakahcouzjjW2Ml6e6EIi0XNfcTOV5nwWgsKCkoAEJCABCUhA8r5NDTS67Cy0DdXFvL+tEZCABCQgAQlIQDKXi2OTgAQkIAEJSM6NTqLn3OgkIAEJSEACkvaxSS6OTQISkIAEJCDZfXoALZkEJCABCUhC0Th7LlwGJCABCUhA0j42ycWxSUACEpCABCS7Tw+gJZOABCQgAUkoGqffH0LPxbFJQAISkCSmCpk+u4nne8+gySSZphMRLs14WSjtoWGy2T1yHE0myRRKROkP+3izLoRG0GSSTCEtyvfHTpPNhekRrteHKzfTlFfCQtuSX8sjFZtZLBQWgeoCGw+srubtcm9rFYV5Jq6H3WQgmxKbBT0lNjPZ2E1G7CYD2TSV5KOnqSSfbOwmI3aTgWyaSvLRU5RnRo/dZCCbmugNSE0lm0KTnYViU81k02Rzo6fQaOPNKjLa0LPC5iYbu2rmetRaivgd91reLr9TcgMuYx6LgcIisLaqEFURvF1MqkJbjYvrcf/qajI5LUa2NpaiZ+eKckyqQqb7V1dz/+pqMjktRj68uYlGl4NMm2pdPLSuDpOqkOn+1dXcv7qaTE6LkQ9vbqLR5SDTploXLpsZPfevriaT02LkQxtbqJxeR6YNhcsoNjlYKPeXbyCT02Dlw7XbabSVkqmtoIESk4M3q8VezrK8UjJtLmjgvRU3YVIMZHp32Tqux4b8alSh8HYxKypb8+tYDNTPvI4F0DMe4vCAFwQgAAEIQMDdLZU0uRy8nYYCYV4b8oMABCAAAQi4Y0U5boeVbFrKCjCogn5/iISUrCorYNfOVqqceegpyjPTWl5A73iIiXAMl93MB29q4s6VFbSUFWBQBf3+EAkpWVVWwK6drVQX2NhSV8JoKIJ3OoLFoLJjeRmf2NZMqcNCa3kBveMhJsIxXHYzH7ypiTtXVtBSVoBBFfT7QySkZFVZAbt2tlJdYGNLXQmjoQje6QgWg8qO5WV8YlszRlVBT0tZAQZV0O8PkZCSVWUF7NrZSnWBjc2VVXhmpvElJjCrRraVrOKjy96BQVFZKC2OSoxCpW/GS0ImaXFUsqvpXqqtxWwpasITDeCNBbGoBm53tfDJhrswKipvliIEtxQtYyQaYCwWxKIY2elq4dH6O3Gb81ljr6R7xos/PkOJycEfVd/KO0ta0dM14+XAZA/Z3FeyhhW2Ut5OA9FJXg0Oks19xc1UmvNZCAYWgcp8K2+EJxjhpfYhenwhOsYCBCJxsinMM1FkNbOptpj7VlVTmGfiWvItRq6HqgjcDituhxVbLE6pw4LTYuJaCvNMlDoshGJxSmwW3A4LKaoieGhdPQ+tqyeTxajitltwO6yoQuB2WDCpCilrKgp56sFNZFIVgdthxe2wYovFKXVYcFpMpFiMKm67BbfDiioEbocFk6owF1URuB1W3A4rtlicUocFp8VESmGeicdWvxN4J5kuh8f5+sB+eqfHcJkdvLtqC+sKGkjZ7z3P90eOEUpEWeGo4H2123GZHES0GP82+AqvBfpQhWBL0QreXXkTqlDQowoFtzmfMrOTkBal1JyP02glxaIYcZuduM35qELBbXZiUgxcy499F/jO6GuEtAjN9nI+VH0rJSYHRUYbf9V0L9kUmWyUmfMJalFKTQ7KzPlcrypLAW/ESHSK533n6JzxcX56lIlEmCsEV0iuKjbmUWy0c4uzjveU3ECxMY9rKTRYWQwMLBF7LgzxzKtdhOMa1zIxE2NiJkbPeJDvnL7Ex7au5I4V5bwV9lwY4skD7aQNB8KcH53kqQfbsJsMZOMJRvj4944TiiVI8QQjfPo/T/HEO25kQ3Uxev7HD89wcshPWs94EE8wwie2NaNnz4UhnjzQTtpwIMz50UmeerCNz+49y8khP2k940E8wQif2NaMnj0XhnjyQDtpw4Ew50cneerBNuwmA9mMRQM8duZrTGtRJDAWDfA/Lnyb/97y23giAf6p94ekSGAkMsGFqcs8ecP7+VzH9zgdGADBFT3TY3iiAf5r493o2eM5xT/07gXBFUORCc4Hh3hq9R/y2a4XeC0wQFr39BieaIBPNtyFnh+Mnebv+36E5KqhyCRng8M8s/q92FUz2YxGp/ij888R0mJIYDQ6xZ91fJe/XfEu2px1vBW+6z3Dk4MHmEnGAcFcxuMz+OJhOma8fN3zGn9es4N7iptZChSWgK8f7+XJA+2E4xpvVkxL8nf7L3Co38tb4bnX+sjkCUbY1zmKnhfODRKKJcj0zdf60dPpneLkkJ9ML7cPE4jE0fPca31k8gQjPP1KJyeH/GR6uX2YQCSOnude6yOTJxhhX+coevaMnGA6ESHTty8f4j8uHyLTWDTAM/0/5nRggEx7x84wlQij598vHyaTJxrg6YF9nAwMkOmlsbMEEmH0/NvQq2QajU7xI98F9HzXc5KQFiXT14aP8FZ4ZvhV/mZgH+FknDcrltT4TP+P+OlkD0uBwkIREoQEIUFIEBKEBCGZS894kG+81gtCgpAgJAgJQoKQICQICUKCkCAkCAlCgpAgJAjJ3//8AoFIHF1CgpAgJAgJQoKQICRz8c1EQEgQEoQEIUFIRkNh9HhCYRAShAQhQUgQEu9MBD3DU2EQEoQEIUFIEBKEZHhqBj2+mQgICUKCkCAkCMnJ4XEQEoQEIUFIEBKEZHhqBj2+mQgICUKCkCAkCMloKIyescgk2fiiQXyxINmcnhxAz3B4Aj2+WJBsTgYG0DMcmUCPNxYkm9HoFHpGYwGyGYsFmW+dM17+efhVfl1/PbCPyUSYxU5hkdt9eoD5EIjE2XPhMvOtsdhBNo3FdvQ0FjvIpqHYjp7lJQ6yMakKdYV29DQWO8jmrpWVZGNSFeoK7ehpLHaQTWOxHT31NjfZ1NtKabC5yWanew3ZmBQDtXku9DTYSsnmrtLVZGNSDNRZXehZlldKNsvyStGzLK+UbJbllTDf/s1zgvkwmQiz23uOxU5hkTt6ycd86fRNMd8e3rwck6ow25qKQrY3lqHngdU1VBfYmM1uMvCBTcvQU5GfxwOtNWR6/6ZlWI0qeh7evByTqjDbmopCHlpbzwOtNWR6/6ZlWI0qeh7evByTqjDbmopCtjeWoefeik1UWYuZzWaw8L7a7Xyg7nZMioHZVjtreE/VFu4t30CmP6zZhlU1oecjdTswKQZmW5Nfw0OVm3mgbD2ZPlB9K1bVhJ4/rr0Nk2Jgthvzq9lRvAI973avp8ZSxGx21czD1VuZb4cm+5gvF2Y8LHbqZ17HAugZD3K430s2dyyvwO2wks2zR7uZL5G4xm+tqSWbnvEgh/u9ZHPH8grcDivZuB1W2mpdmFQVl83MO5or+ZObV6IqAj1GVWHn8grMBhWH2cjGGhef2tZChTOPNN90lMuBGRwWI6oiSNlQXUxFvpWhqTDlDiufuLWF25vKmYvbYaWt1oVJVXHZzLyjuZI/uXklqiLYUF1MdYENk6qwojSf/7JxGbc3lZMWjmt0jwcxqSoWg0qK22GlrdZFIBInqiV5z411PHJLM6oi0GNQVG4ruQGzasBhsLC+sJFHlr2DckshbouTDYWNGBUDxWYHd5bdyMP1d6AKhfWFDZRbChmOTFBuKeCRxru4rWQVc3GbnWwqbGQqMUM0meC3K9t4pP4OVKGwoaCeamsxRsXACnsZ76++ld8oaSEtrMXpnhnDpBiwKEZSysxObipsIJAIE00m+N2KTXyifieqUNBjVFTudrViVo04DBZuctazq+FOqiwF6Oma8XJgsods3uFaRbk5n2yeGnqF/z/BrxBkIcgUTsb5ffdasukI+/hpoJds7ituptKcz0Iw8P8Q33SUt0JjsYPGLQ7eDKtR5aF19WQKxzU+95OzHL3kI8VuMvCxrc1sb3RzcSzAvx7vxRMMk/Ls0W7cDgvVBTbm0ljsoHGLg2y2N7rZ3ugm0/fOXuLZo93EtCQpd62s4JFbmolpSb56rIejl3ykfPtUP26Hle2NbuZiNRj47aotZNNgc9NQ7yZTe3CYb1w6gCcWIOWrl36G2+ykylqMnrAW418HD3B0soeUbw8fwW12sr24mZTtxSvZXrySTN8dOcE/Dx4gJhOk3FWymk/U7ySW1PiXwYMcnuwl5ZvDR3GbnewoXslcrKqR91a0sZR4YiEWO4WFJAABCEAAAhCAQJ8ABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAMHcBCAAAQhAAAIQLJinD3dwdNAHAhAQiif4wv5zXBwL8Nkfn8ETCoMABPT4g3x+3znm2/HBcZ5+tZNYMgkCEPByxzDfOt3P04c7ODroAwEICMUTfGH/OfonQsyniBbjf3Y8jycaIK13eoy/6fo+c/nf/fs4OtFDWigR5Qvde+if8aHn2GQf/zSwj1gyQdpL3rN8c/goXxrYx6uTvaSFtCif63mJvrCPnIWnkLOoHOwbI5OWlPzvw534pqNk6hkP0j8RYj4d6POQzcG+MQ72jZFJS0oO9XuZT2enBvHFgmTqnR5jYMaLnoP+DjJpMsmhiS70HPB3kM0BfycH/J1k0mSSg/5uchaeQs6ioklJNuG4hh4tKZlPMS1JNjEtiSYl2cS0JPNJk0n0aFKiJykl2cSSCfTEkhrZxGQCjSTZxGSCnIWnsKAkIAEJSEACkrlJQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpDMTQISkIAEJCBZSOurigAJSEACEpC8f1MjdpMKSEACEpC4HRbqCu3Mp7YaFyABCUhAApJNNcWsryoCJCABCUhA0lbjYj61OKqwGcxkcpud1Oa50LO+oI5s2gob0dNW2Eg2bQUNbHTWk83mgkZyFp5CzqLy0S3NNBY7SFMVwYfaltNWU8Kjt7ViNxlIc9ks7NqxGlURzKftjWU80FrDbGsri/iDdY18dEszjcUO0lRF8KG25TSXOplP+UYrn2q6B5vBTJrL5ODRpntRhYKeP67fSaOtlDRVKHyodjvN9gr03Fa8kgfK1jPbuvwa3ld5Mx+ru51leaWkqULh4ZpttNjLyVl4Bv4f4rQYWewK80z895038OUjnXT5gjy4upZ7V1WT0lZTwqO3tfLs0W6sRpWPbF5Bc6mTFC0p2d87Ss94kDK7lR1N5dhNBlJ80xEO9I3hnY7Q6i5gS10p1/KhtuXYTAZe7hhmbWURD29egdWoYjWq/MP9bVwcCzARjtJc6sRls/Dr8MWCHBpvxxcN0pJfxU1Fy0nZVNjIM2s/woXgZRShsDq/GqtqYi6FRhtPrn4v7aFh/PFpmu0VuEwO0i6Ghjky0YNJMbClsIm6PBcpf1y3g/vK1tE5PUqlpYDltjJSrKqRp1p/nwuhEfzxaVrs5ZSYHFyLJpP8xN9B1/QY5WYnd7iasatmFrMCg5XFzsBCErxpdUV2+idCzIfCPDNzErztesaD7HrpBIFInJQvHW7nojfAY9tb2X12gGeOdJL2qReP8ei2VrbWu3n8pROcGZkgbfe5Ab74mxsIROLseukEgUiclO+cHWDHsnIe296KHi0pefylE5wZmSDlR13DnBmd4Iu/uQGXzYKqCFrLCpgPvZOT/GXXvzIVDyOB7w0fZXvJKj7VdA8p+UYrNxU18WaoQmGVo4pMu0eO8eWB/aR97fIhHlv2Tm4rXklKpaWASksBmVShsNpRyRulySSf7NjNqanLSK7699HjfKn5PZSYHMynRmsx3eFx5oPLmMdip7DINRQ7mC9rK4tY7J463E4gEme2fd0jfP/CIM8e62I2LSn5h1cusvvsAGdGJpjNEwzzlWPdPHW4nUAkzmz7ukc4NDCGnu9fGOTMyASzeYJhvnKsm/n2pYNdTHgczLbfe55X/V3MJ18syLOXfs5smkzyZN9eYskE8+m7npOcmhpkttHoFE8PHmS+LcsrYb5sclSz2Ckscve2VKMqgl+Xqgjubalmsbs4FiCb3WcH0JKSTKFYgj3tl8mmfSzAxbEA2ZwbnUTPOc8E2bSPBZhvF8cCJEarifU2M9uFqcvMp4uhYTSZJFMoEaU/7GM+nQ0Nkc2F6RHm27tLb0AVCr8uVSi8p3QNi53CItdc6uS3Vtfy6/r9tQ1U5Oex2NlNBrJpcjnQ0+RykI3dZMBuMpBNic2CnhKbhWzsJgPzzW4ykCIjecxWbHYwnwqNNvQUGm3MpxKTg2zsqpn51mor5/fc6/h1faS8jWpzAYudwhLwh+uXcdeKSq6HSVV4+KYVPLS2gaXg/lU1ZHJajHx403Iaix1k2lTt4qEbGzCpCpnub63h/lU1ZHJajGytL0XPzqYKTKpCpvtba5hv96+qIS05WUxKvtHKzcUrmE/N9goabaVkaitooMTkYD7d7VqFSTGQ6d1l63grPFy5hXtdq7geJkXlU9W38sHyjSwF6mdexwLo8Qc5fMkLAhCAAAQg4I6mCtwOK3oUIdhcW8IN5UWE4nHGZ6IkkhIEIAABCEAAAlRV0FDsoK26hD/b1kpbTQnX0uMPcviSFwQgAAEIQMAdTRW4HVYWQou7AIMq6J8IkZCSVe4Cdt22huoCG1vqShkNhfHORLAYVHYsK+cTW1dRarfQWlZI70SQiXAMl93CBzc1cefySlrcBRhUQf9EiISUrHIXsOu2NVQ5begpyjPTWlZI70SQiXAMl93CBzc1cefySuZbi7sAgyronwgRm3Ky0tLAY+u3U2ktYj4pQrClqAlPNIA3FsSiGrjd1cInG+7CqKjMpyKjjTX2SrpnvPjjM5SYHPxR9a28s6QVPV0zXg5M9pDNO1yrKDfno0cRglsLGlnvqCKoRfHGQsRlkl8Q/ApVKDTllbDVWc9f1d3BVmc919IR9vHTQC/Z3FfcTKU5n4VgYBEIxeK8EWvKC1lTXshbwTcd4Xr9pHuE589fIhRLsLLEyQc2LsNlsxCOa3z9ZA8nLo+jKoJb6kp5z5p6VEWgR1UEbrsVt92KLZag1G7FaTGSUmg18Re330A2hVYTpXYLoWiCEpsZt91KiqoI3HYrbrsVWyxBqd2K02LkWgqtJkrtFkLRBCU2M267lbSfdI/w/PlLhGIJVpY4+cDGZbhsFuYyODnNV4530TseosRm5ndvbGBDVTGqInjoxgYeurGBTBEtxr8NvsJrgT5UIdhStIJ3V96EKhQGw+P8y6Wf0zc9RrHJwe9UbWZDQT0p+7zneX70BCEtygp7OR+o2YbL5KDQaOMvlt9HNoNhP89c+jm9YS8uk53fq7iJjQX1zCWsxfnq0CGOTvajKgrbipp4qHwTqlAoMtkoM+cT1KKUmhyUmfO5XqFElDdinaOKdY4q3gqeeIjFwMCCkmQzPDXD263TNwVIspPo2dM+yJOvXCRteGqa854JnnpgM5/9ySlODvtJ6xmfwhMM84mtq9Czp32QJ1+5SNrw1DTnPRM89cBm7CYD2XhCYT7+gyOEYglSPKEZPv3DEzxx5zo8oTBPvnKRtOGpac57Jnjqgc3YTQay8YTCfPwHRwjFEqR4QjN8+ocneOLOdXhCYZ585SJpw1PTnPdM8NQDm7GbDGTjCYX5+A+OEIolSPGEZvj0D0/wxJ3r2FDlQs9ft3+X04EBEFzRMz2GJxrgd6q28Mlz32A6ESVlNBrgLy7+B3/d/G480QD/0LsXBFcMRSY4HxziqdV/iN1gJhtPNMAj579BMBEDAaPRAI93fIf/ueK32FhQj57/1vk8J6YucYWA7pkxRqJTvLfiJv7o/HOEtBgSGI1O8Wcd3+VvV7yLNmcdb9bl6CRvt/PTYywGCovA4YEx3k5aUtI+FuB6PHeqj0yeUJinX23n5LCfTC93DhGIxNHz3Kk+MnlCYfZ1D6PnhQuDhGIJMn3zVC/PneojkycUZl/3MHpeuDBIKJYg0zdP9fLcqT4yeUJh9nUPo+eFC4OEYgkyffNUL3o6fVOcDgyQae/YGf5t8CDTiSiZ/v3yYf798mEyeaIB9vnOo+f50ZOEElEyfWP4VfR0THt4beoSmfZ4z/IvQ4cIaVEyfW34CNfjwEQPbydNJjk3M8pioLCQBCAAAQhAAALOjU1yZsTP2+W5071MRKIgAAEIQAACEMzJNxMBAQhAAAIQcHLEDwIQgAAEIAABw1Mz6PHNREAAAhCAAASMhiLo8YTCIAABCEAAArwzUXwzERCAAAQgAAGjoQh6PKEwCEAAAhCAAO9MFN9MBAQgAAEIQMBoKIIeTygMAhCAAAQgwDsTRc/w1AzaWCXZnA4MkI0vFsQXC5LNaHQKPZ5ogGx8sRB6hiIT6DkxdYlsxmJBrsfp0BCvBS/zdnlm9Bi++AyLgcIi8bn9Z/FNR1hoPf4g3zzdy/VqLHKQzV3LK8nGpCrUFdrR01jkIJvGYgd6GoscZNNQ5KCxyEE2jcUO9DQWOcimochBY5GDbBqLHehpLHKQTUORAz3LXfkk/aXEu9ZAUiXNpBjYXrKKbBpspTTYSsmm0VaKnkZbKdk05pWgZ4WtjGxMioGdxc1ksyyvhOv1lz0vMRYLsdA6wl6eGT3OYqGwSEyEo3zke4fY2zXMQjnQ7+FTe46iJSXX6+G2FZhUhdnWlBfx0A0NPLCqhkzv39CE1aii5+G2FZhUhdnWlBexvb4MPQ+sqqXaaWM2u8nABzY28XDbCkyqwmxryovYXl+GngdW1VLttDGb3WTgAxubeLhtBSZVYbY15UVsry9DzwOraql22pjNbjLwgY1N6KnIz+OBVTWgqSQGG0j7w5pt/E7lZqqtxcxmM5j5LzW38pG6HZgUA7Otya9he/FK9LyrbD3V1iJms6tmPlh9K3oqLQX8Vtk6Mn246hbeW3ETNZYiZrOrZh6u3sr1Go9P83vnvs4e3wUWyo8nunl/x240mWSxEPJ1LIC9XcP83YFzvBHLXfmschfQ5HJSkmdmPgWicQYnpznY76HHH+SN+Nu7N7CmvAg9Pf4gz53qpcs3xTtXVvFgax2qIkjZ3zvKkUEvJlVha52bDVUu0sJxjf6JEBX5eTgtRtJ6/EF+1DWEdzpKq7uAe5trUBVBipaU9E+GUIWgrtBOWjiu8b3zA/T4g7jtVu5rqcZtt5LS4w/y3KleunxTvHNlFQ+21qEqgrmE4xrPne5lX88IayuK+IO1jbjtVlJ6/EF+1DWEdzpKq7uAe5trUBVBipaU9E+GUIWgrtBOWjiu8b3zA/T4g7jtVu5rqcZtt5Lmm47gD8eoK7RjUhXS9veOcmTQi0lVuLXVyvqCBlLCWox/HzrMT70XuMFZy+9X34zb7CSlZ3qMH3nP4osFWeWo4t6ydahCIUWTSfpnfKhCoS7PRVpYi/Hd0dfonhmjzJzPfe61lJmdpHljQfzxaeqtLkyKgbR94+0cnuzFpBjYVrScTc46UsJanK8Nv8re8XbW51fz/sotlJnz0fOfvvM80beXNMmvkgjSVtrdrLFX0JznptRkZzbJ9ZFcNZmI0BeZ4CeT3XTMeEGARJAm+VUS+ErTu9joqGQhGFggFfl5vFGdvik6fVMsFjazET3huMZXT3RzdNBLyrfP9OG2W9neUEbK9oYytjeUkel75wd49ngXMS1Jyl3LK3lkSwuqImgsctDYtpJMF8cCfH7/GTyhMCmNRQ523baGaqcNq1HloRsbyBSOa3z1RDdHB72kfPtMH267le0NZczl5c7LPH9+gJiW5Eddw6hC8MiWFlRF0FjkoLFtJZkujgX4/P4zeEJhUhqLHOy6bQ3VThtWo8pDNzaQKRzX+Nz+Mxwd9JJiNxn42JYWtjeUkbK9oYztDWVk+uHYGV4YOUEsmeDH3nOoQuFjDXegCoVGWymNttvJdDE0zOe6XsQTDZDSYCvl08vuodpahFU18XuVN5EprMX5bPcPODzZS4pdNfPx+p3sKF5Jyo7ilewoXkmmF71n2O05STSZ4GXfBVSh8Kd1v4EqFLKpshTwRl2c9nBx2kOa5JckKYIUyf8luELySxLBbJJfkrw5DoOJhaKwQBqLHCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACTAaFaqcNPU8fbefoZS8IQEAonuALB87SPxFCz/EhH08f7SCWTIIABLzcNcS3zvahJxzX+Oz+03imwyAAAT0TQT6//wxzefpoO0cve0EAAkLxBF84cJb+iRB6jg/5ePpoB7FkEgQg4OWuIb51tg894bjGZ/efxjMdBgEI6JkI8vn9Z5jL00fbOXrZCwIQEIon+MKBs/RPhNBzYrKXL/fvI5ZMkPbDsTN8e+gIesJajM92fh9PNEBaz/QYT3T/gLl8aWAfr072khbSonyu5yX6wj70HA3084+X9hNLJkjb4z3HN0aOoacpr5SlyKyo1JuLWCgKC8RqVNlQWcxSs62+DJOqoOdgv4dMWlJy6NIYeg70e8jmYL8HPWdG/fimI2Tq8Qfpnwih52C/h0xaUnLo0hh6DvR7yOZgvwc9Z0b9+KYjZOrxB+mfCKHnYL+HTFpScujSGHoOevrI5qC/Az1npgbxxYJk6pkeo3/Gh54D/k4yaTLJQX83evb7O8nmZ/5O9FgVI23OWpaaOwuXY1ZUForCAnpkSwtWowJIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEBiNSr8wdpG5qLJJCABCUhAApKYpqEnpmmABCQgAQlIYpqGHk1KQAISkIAEJCDRpESPJpOABCQgAQlIYpqGnpimARKQgAQkIIlpGno0KQEJSEACEpCARJMSPZpMAhKQgAQkIIlpGnqivkKyiSc19GgyiR5NJtGjkSSbmEygJ5ZMkE0sqTGXP6v9DayKkaUiTzHyx+WbWEgKC8htt/Lxm1ehKoLFzmkx8Ve/sQ633cpc1le6yKatugQ9bdUlZLOpugQ9q0oLsJsMZHLbrdQV2NGzvtJFNm3VJehpqy4hm03VJehZVVqA3WQgk9tupa7Ajp71lS6yaasuQc+minLkhItMmwob0LMqvwq7wUwmt9lJXZ4LPRud9WSzuaARPZsLGshmc0E9cyk35/N4/U5UobDYFRis/EPjPVSY8llI6mdexwKqK3SwrrKY4akwnlCYxUZVBLfWlfHXO9dRW2DnWtaUFXJyeJyJcIwUVRF8cMMKttWXoaeu0MF0LEG7N0Da2vJiHtmyCqOqkI3FoFJX6ODYZS8xLUmKy2bh07fdQKndip41ZYWcHB5nIhwjRVUEH9ywgm31ZeipK3QwHUvQ7g2Qtra8mEe2rMKoKmRjMajUFTo4dtlLTEuS4rJZ+PRtN1Bqt6JnTVkhJ4fHmQjHSFEVwQc3rGBbfRl66godhPxW2iOXEIYEKTc6a/lYwx0YFZVsLIqROquLY4FeYkmNlBKTg/+2/B5KzfnoWZNfxcnAJfzxaVJUofDhmm3cVrwCPQ15LkJalAuhUdLW59fwp3U7MSoqc2mwutiUX8tQdJKR2BS/JPgFwTUIfoUgC8EbInidIE0VCncULuOpZffQYC1ioQn5Ot4mnlCYHn+QUDTOYlBX6KCu0I5JVXgzPKEwXz7WQZdvigdb67i3uYZr0ZKS50738HLXEGvLi3i4rRm7yUCKbzrCgX4P3pkIre5CttSUkhaIxDg/NokqBGvKirAaVVK0pGR/3wg9/iBldis7GiuwmwykaEnJRe8kE+EYzSVOXDYLaRe9kxwZ9GJSFbbUuKkrtJOiJSXPne7h5a4h1pYX8XBbM3aTgRTfdIQD/R68MxFa3YVsqSkl7cigl2dPdGI1GPhI2wqaSwpI0ZKS/X0j9PiDlNmt7GiswG4ykOIJhfnysQ66fFM82FrHvc01XIuWlHzzfAd7Iz/nhsIqHq67HZvBzLUEEmHOT11GFQpr8quxqiauZTQa4OlLP6Nz2sNvl2/gfvdarkWTSb42fIQXvedYn1/NI7W3YVfNvBkj0Sm6ZrwEtQgg0CO5BsEVktkEs0mubZm1mEZLMWZF5e0i5OvIuW49/iC79h4nEImRtqOhnMduXYMeLSl5fO9xzoz6SXPbrXzx7k0EonF27T1OIBIjbUdDOY/dugY9WlLy+N7jnBn1k+a2W/ni3Ztw2Szo2X2un2eOd5CmKoJHt65ma20Zj+89zplRP2luu5Uv3r2JQDTOrr3HCURipO1oKOexW9ew+1w/zxzvIE1VBI9uXc3W2jIe33ucM6N+0tx2K1+8exOBaJxde48TiMRI29FQzmO3rkGPlpQ8vvc4Z0b9pIiyQcpKNf6/1odwmRzMp+6ZMR69+B9MJsKk3e5q4dON70CPJpN8smM3p6YuI7mqzJzPl5rfQ4nJQc71Uz/zOnKu2xP7TzMYmGa2vokQjUX5VDttZPPCxUvs6RhktulYgslIjP19owwGppmtbyJEY1E+1U4b2bxw8RJ7OgaZbTqWYDIS45ZaN9n4piP85b7XkJJfkBJOjYwjhODlrsvMNh1LMBmJsb9vlMHANLP1TYRwmk08c6IDKfkFKeHUyDhCCF7uusxs07EEk5EY+/tGGQxMM1vfRIjGonyqnTayeeHiJfZ0DPILM3ZmnINMxme4ufj/sAcnwHEdhoGm//de9+sbjW40unE1bpIAARICRYq3DkqmKV9appIoVpLdssV45YlHnNipmEPLieI4qpR3yt4tV8aJNdLsxC65HDuy4oSW7OigRJESRYmgJFIAQVwESACNPtF3v+7Xb9Xaai+m6z3LpLAwU6XvW89q+stLP2UuH2OlqWyEXoefdpsXPf8UOstPl94CBKrSaoF4Mcdt3nV86PqJfOgDGQ0n0HM+FMfI+VAcPWORZUbDCfScD8Uxcj4UR89YZBkjo+Fl1LJGrbRS4tjFOfSMRZYZDSfQ8+MLM6hljVpppcSxi3PoGYssMxpOoOd8KI6R86E4/5OyhLYY5GJ6gdU2ml5Az9upqxh5O30VPe9kFvjQByPyoQ/EIZvRAA3QAA3QAJ/DihGfw4oGaIAGaIAGOGQTDtmMBmiABmiABvgcVoz4HFY0QAM0QAM0wCGbMOKxyWiABmiABmiABqxrqEMDNEADNEADHLIJh2xGAzRAAzRAA9Y11KEBGqABGqABGrCuoQ4N0AAN0AANcMgmHLIZDdAADdAADfA5rBjxOaxogAZogAaUl704lAZWm1OyoKdRdmKkUXahxylZ+NAHI/KhD+Rgfzu13FaZWzsCGNnf24osidQ62N/Bwf52armtMrd2BDCyv7cVWRKpdbC/AyP9jfX0eF3U2t7WyH1DPciSSK2D/R0c7G+nltsq87ltG+jxuqi1va2R+4Z6kCWRWgf7OzjY304tt1Xm1o4ARvb3tiJLIrXuadzOavutppup5TbZuM27HiN3+waQRRO1fqdpCx/6YKSH38WHrtvGgAezJDAdT1Eqlxnw13P0ts20uR0Y8dosDAQ8TMVTxPMFfA4rh7Zu4MC6NjYGPJglgel4ilK5zIC/nqO3babN7cCI12ZhIOBhKp4ini/gc1g5tHUDB9a1YUQUBHa1+wllsoQzOaxmiX09zXxx9yB+h5WBgIepeIp4voDPYeXQ1g0cWNfGxoAHsyQwHU9RKpcZ8Ndz9LbNBN1OdrX7CWWyhDM5rGaJfT3NfHH3IH6HlYGAh6l4ini+gM9h5dDWDRxY18bGgAezJDAdT1Eqlxnw13P0ts20uR0Y8dosDAQ8TMVTxPMFfA4rh7Zu4MC6NlbbgKsFkyAxlQ1T0soMulr46rpPELR6MeI1O9jsbGUiGyZWzNIou/h88FY+3jjIhz4YE/8OPDc1z0/euUxaKdLXWM+hm9fjs1vJlVS+d+4Sr1+NIIkiezsC3LupG0kQmFvO8NgbF5mMp2i0W/n05h62tfr4VXIlle+du8TrVyNIosjejgD3bupGEgSMSIJAwGkj4LThUEz4nTbcVpmKXEnle+cu8frVCJIosrcjwL2bupEEAa/NQsBhJa0UabRbCThtVEiCwH2be7hvcw+1ciWV7527xOtXI0iiyN6OAPdu6kYSBIaavHznk7u4FjaziYDTRsBpQxJFmpw2ZEmkYqjJy3c+uYtakiAQcNoIOG04FBN+pw23VabCZjYRcNoIOG1IokiT04YsiVQMNXn5zid3UUsSBO7b3MN9m3u4Fl6bhYDDSlop0mi3EnDaeD85VeF7V07x+vI0kiCyx7ue32vZjiSIzOViPDr7ElO5MD7Zye+37GBbfReSINJkqaPJ4iat5glY6nCbbLyfm+qCPDb4h+j5RXSUHy2eJaUW2Ohs5oG2vfhlJ7lykceuvsLp5RlEQeQOzzr+sHkbkiByOR/jv86d5FIuTKPs5DPNt7DD3cn1msnH+fbVk4xnI/hlJ/c3b2NXXQcVx2JjPBE6R0pV2OQM8GDrbgJmJ9lyke8snOZUchYJkbs8PdwfuBlJEFkr0sPv4gb2rxfn+Oap80RzBVJKkel4ipdnQ+zvbeVrL4zw/NQCibxCPFfg3GKMaLZAt8fFF469wmQ8RUYpsZTJ8/zUPH2N9bTW2THy0LNv8PzUAom8QjxX4NxijGi2wM6gHyP/enGOb546TzRXIKUUmY6neHk2xP7eVr72wgjPTy2QyCvEcwXOLcaIZgt0e1x84dgrTMZTZJQSS5k8z0/N09dYT2udHSMPPfsGz08tkMgrxHMFzi3GiGYL7Az6uR4PPfsGz08tkMgrxHMFzi3GiGYL7Az6MfKvF+f45qnzRHMFUkqR6XiKl2dD7O9t5WsvjPD81AKJvEI8V+DcYoxotsDOoJ/VFErn+MKxV5iMp8goJZYyeZ6fmqevsZ7WOjtGvnrxn3gu8g6JYpZ4McO55CzRYppueyN/fP57TGbDpNUCS0qKZ6OjbHQ2czY5y3+Z+jmRYppUKc9UNsKJ+AQHGgeRRRPX6qmlt/ib6V8QKWZIqnkmcxFeSkzwMd8ARyf+hV9Ex4iXckSLWd5IzREpZui1NfKZd37ApVyYtFpgsZjimdgYg44m2qz1XKt5Jckfjv6Q8VyElFpgUUnxs9hFNjmbOJ2c4y8vP0e4mCGp5rmUj/JcYopPNfTzpamfcSx2kVgpR7SU5UzqCkvFDLfXd7NWpIffxQ3s4eMjZEslEAABECBTLBHLKZycC4EACIAACDARS5JWSoxFEiAAAiAAAixlcny0tw0949FlHh8ZBwEQAAEQYCKW5FN97VhNEnoePj5CtlQCARAAATLFErGcwsm5EAiAAAiAABOxJGmlxFgkAQIgAAIgwFImx0d729AzHl3m8ZFxEAABEAABJmJJPtXXjtUkcS3Go8s8PjIOAiAAAiDARCzJp/rasZok9Dx8fIRsqQQCIAACZIolYjmFk3MhEAABEAABJmJJPtXXjtUksVqeeGuSc6EYCIAACIAAS5kcH+1tQ894ZpHHZ1+i1kRmibRaYDS9AAgg8EuLSpJX4pNkVYWV0qpCo+yk39nMtTp66adkVYX3CLwnrSpEixlejE9Qazy7RFotcCGzyC8JvGdBSfJJ3wDX6rGF1ziTukKteSXFS8vTpFWFXxIgpSpESlmeT0xSazQX5tONm7GKZtaCyA0uks2jZ2QhipGRhSh6wtk8RuZTWYzMJ7MYiWTz6BlZiGJkZCGKnnA2j5H5VBYj88ks12o+lcXIfDKLkUg2j56RhShG5pNZVlMok0NPOJvHyHw+gZGR5cvoiShpwkoKPYuFJNcjrKTQ80ZyFiOvJ2fRs1RMcz3mlSR6lpQ0ISWNnteScxiZLSyzVkRucD3eOvTcva4NPbIkcmd3C3p6PC6MrG9wo0eWRDo9Loz0eOvQc/e6NvTIksid3S3o6fG4MLK+wY0eWRLp9Li4Vusb3OiRJZFOjwsjPd469Ny9rg09siTS6XGxmno8dejp8bgwst4RQI8smtjn24ieHnsjvXY/enrtfq7HOnsjej7hG0SPLJrY39CPnnW2Rq7HBlsjetbbfWywN6LnoG8jeiyiRK+tgbUicoN7YGsfsiSy0lCTl/s293Cwv4Nan92ynvs29xB0O1jJKZu5f8sGjLS47Bzs76DWZ7esx2aSMPLA1j5kSWSloSYv923u4WB/B7U+u2U9923uIeh2sJJTNnP/lg0YaXHZOdjfQa3PblmPzSRxrVpcdg72d1Drs1vWYzNJGHlgax+yJLLSUJOX+zb3cLC/g1qf3bIem0liNR3c2EnQ7WAlp2zm/i0bMNJi9XCw6WZq3R+8ld9v3UHQ5mUlp2ThUPBW/kPHHciiiZVuqguyr2ED1+M/tt+OLJpYadjVxv/Wsp3fDQxT6/Ntu/lMy3Y6rF5WckkW/rhtN9fj04FhOq0eVnJJFh5s3c2X2vYiixIrbXW18kdN2/h9/xC1Drfswi6aWSuC9i7WkKppzMRTSKJAZ72LlXIllZl4ipY6O26LTNVkLMkTb08yHl3m4+vb+Z2BLiRBoOL4zAKvXllCFkX2djSxrbWRilxJ5SfvzDAZTxJw2Linr4OA08b7OT6zwKtXlpBFkb0dTWxrbaQqV1KZiadoqbPjtshUTcaS/GLyKpFsngG/h3v6OpAEgYrjMwu8emUJWRTZ29HEttZGKnIllSfemuC5qXmGmxv4X4fWEXDaqIpk88RyBTrrXciSSNXxmQVevbKELIrs7WhiW2sjVbmSykw8RUudHbdF5tfx3NQ8Pzw/hc0s8Qebe9nW2sj7mYwl+cXkVSLZPAN+D/f0dSAJAhXPTc3zw/NT2MwSf7C5l22tjfw6Itk8sVyBznoXsiTyfnIllZ+8M8NkPEnAYeOevg4CThvv57nIO/xw/jQ2UeYP2naxrb6Lipyq8OTiWSaySzRZ6rgnMEyTxU3FRHaJn4fPE1bSbHK18r8EhpEEkfeTU4tM5SK0Wetxm2xUXcqG+R/zr3IxG+Kexs18umkrkiBS8WzsIicTU8iiiTs869jh7qQiVy7y3+dP8/PoGFvr2jnUsoNmSx3XK1su8tjCazwdu8g2V5D/vWU7LXIdFRezYX4aHSVUTDPsbOH3GjcjCSIVz8THeWl5BlmQ+Iinl911HawlQXsXa2Q0nOCRE+cIpXNU9HjrOLr3JoJuB0+OzvD42YsoapmKA71tHN45iKKWeeSlEU5fCVPhlM08uGOA2zubWUtPjs7w+NmLKGqZigO9bRzeOYgkCFyPJ0dnePzsRRS1TMWB3jYO7xxEUcs88tIIp6+EqXDKZh7cMcDtnc38Kk+OzvD42YsoapmKA71tHN45iCQIGBkNJ3jkxDlC6RwVPd46ju69iaDbwfUYDSd45MQ5QukcFT3eOo7uvYmg24GRXEnlkZdGOH0lTIVTNvPgjgFu72xmtY3Gojxy+Z8IFZap6Hb4+UrvJwnavKy2Hy2+wXevnKRQLlHx8cZB/rTzLpSyyl9MHuOVxBSaAE7Jwp923sVd3g38Kj8MjfBfr5xEKZfQBPiUb4Avd9yJJIhcjyeWzvHtqydRyioV9/gG+Er7HUiCyI1MevhdrIFcSeVLvzhNOJsHARAgni9wIRwn4LTxjZNvoWoaCIAAE/EkZlHk+Mw8L15eBAEQQCmXOTUXYk97gHqrhbVwZj7MN06+happIAACTMSTmEWRTQEv1+rMfJhvnHwLVdNAAASYiCcxiyLHZ+Z58fIiCIAASrnMqbkQe9oD1Fst6DkzH+YbJ99C1TQQAAEm4knMosimgBc9uZLKl35xmnA2DwIgQDxf4EI4zifWt3OtciWVL/3iNOFsHgRAgHi+wIVwnE+sb8fIt09f4MXLiyAAAijlMqfmQuxpD1BvtbBaciWVLz3zGmElCdYcFbFihvPpq3wicBOr6bXlGf566mlUTaPqUnYJkyjxXGyM52MXeY8AiqZyIjHFbZ51eMx29Ly6PMNfTv0cVSvzHgEuZsOYRYlhVyvX6lTyMl+d/gWqplE1lg1jFiS2uFq5kYmskbcWo0SyeWpNxpJ8/80J9JyYXeTl2RC1VE3j1NwSa+XE5UX0nJhd5HqcuLyInhOzi7w8G6KWqmmcmlvCyInLi+g5MbuIkbcWo0SyeWpNxpLMJFJcq7cWo0SyeWpNxpLMJFIYeXk2RC1V0zg1t8RqemsxSiSbh3AzlCWqJjNLzGQjrKbjsXH0vBgb53jsErVUrcyJ+ARGXohfQs8L8Utcj+fil9DzXGKCG53IGlE1DSO5kooeRVVRy2X0KKrKWlHUMnoUVeV6KGoZPYqqopbL6FFUFSOKWkaPoqoYUTUNI2pZ41qpmoYRtaxhRC2X0aOoKqtJ1TR+KdzESqpWZjUp5RJ6lLKKShk9iqZiRCmX0FMoq1wPpayip1AucaMTWSMDfg9O2UytgNPGvQPd6Nne6mdrSyN6trf5WSs72vzo2d7q53rsaPOjZ3urn60tjejZ3ubHyI42P3q2t/oxMuD34JTN1Ao4bXR6XFyrAb8Hp2ymVsBpo9PjwsjWlkb0bG/zs5oG/B6cspn3JD0w2Q8FKwGLm067j9W0s74bPTvru7jF3YmeXe4ujOyu70bPbncX12Ovuws9e91d3Oikh9/FGrCaJDrrnZyZj6CoZSp8disP3TrMLa2NpJUSY5EEVcNNDRzeMchwcwMji1HiuQIVkiBw6OY+butoZq101rtIKyXGIgmqhpsaOLxjELMocq06612klRJjkQRVw00NHN4xyHBzAyOLUeK5AhWSIHDo5j5u62jGSGe9i7RSYiySoGq4qYHDOwYxiyJ6rCaJznonZ+YjKGqZCp/dykO3DuN32LhWVpNEZ72TM/MRFLVMhc9u5aFbh/E7bBjZFPAyshglnitQIQkCh27u47aOZlaT1STRWe/kzHwERS2DJtIoNPDQllvxW+pYTd12H2m1wDvpRapurmvnTzs/wjZ3O28kZ4kVsyCAJIj8h+Ct7POux0i3zUdaLXAhs8h7BNhWF+RI552YBYlr1WNrIKUWOJ9ZpOoWV5CvdOzDLEjcyATtXayh01eXeGxkHJtJ4oGt/fT76qlQNY0n3p7g6YkrDDc18Pmt/ThlMxWhdI7vnh1jPLbMb/d3cc+GDt6Pqmkcn1lgMpYk4LRxZ1cLTtlMRSSb56XZRSKZPIN+D7uCAapGIwlOX1lCliR2Bf101ruoUDWNJ96e4OmJKww3NfD5rf04ZTMfxHwqy3h0mRaXnfUNbqpC6RzfPTvGeGyZ3+7v4p4NHVSNRhKcvrKELEnsCvrprHdRNZ/KMh5dpsVlZ32Dm6pINs9Ls4tEMnkG/R52BQNULRcULizFkUSBzYEGbCaJClXTOD6zwGQsScBp486uFpyymfdz+uoSj42MYzNJPLC1n35fPe8nlM7x3bNjjMeW+e3+Lu7Z0EHVaCTB6StLyJLErqCfznoXFaqmcXxmgclYkoDTxp1dLThlMxWRbJ6XZheJZPIM+j3sCgaoOn11icdGxrGZJB7Y2k+/r54KVSvzQnSMyewSAYubu3wbcUoWKsJKipdi44SVFIOuNvZ4eql6J73AK4lJZNHEHk8vXTYfVVfzCcYyIVqt9fQ5AlSpWpkL6QWipQwDjmb8souqC+kFTi5PIwsSt3p66bY1UKFqZf77/Gv8S+Q8W+va+U/tt+GSLHwQc4UE72SWCFrr2Wj3UxVS0jybmCCkpBl2NnNHfQ9Vb2UWeWl5BlmU2OfuptfWwFoStHexRn70zjSPnh2jShIEvrx7iL0dTRx59jXeDMWoCjhtfGv/DpYLCkeePcNyQaFqX1cLR3YPYUTVNI48+xpvhmJUBZw2vrV/B8sFhSPPnmG5oFC1r6uFI7uH+NE70zx6dowqSRD48u4h9nY0ceTZ13gzFKMq4LTxrf078NmtrKbJeJIjz55huaBQta+rhSO7h/jRO9M8enaMKkkQ+PLuIW7vbMbIZDzJkWfPsFxQqNrX1cKR3UMYUTWNI8++xpuhGFUBp41v7d+Bz27FyI/emebRs2NUSYLAl3cPcXtnM0Ym40mOPHuG5YJC1b6uFo7sHuJH70zz6NkxqiRB4Mu7h9jb0cSRZ1/jzVCMqoDTxrf272C5oHDk2TMsFxSq9nW1cGT3ED96Z5pHz45RJQkCX949xN6OAF8e/UfOJa+AwHsCFjf/58bfY7mU489Gf0SilKPqTt9GvtLzMX648DrfmX2R9wggCSJHu+/mzoY+rscTi2/wt3MvUaEBkiDyF90HuMOzjgcvPsnZ1BUqNAGaLXX8/YbfxS87WU0Xs2EeuPQUiVKO9whwt7ePRzr38z9CZ/nm1ZNUSYLII50f4YBnPWtFevhdrIFINs+fv/A6GhpVGhoji1EEAZ6ZmGOljFIkni9wfGaeuWSalaYTKXo8dQTdTvQ8dXGGY5dmWSmjFInnCxyfmWcumWal6USKOovMo2dH0dCo0tAYWYwiCPDMxBwrZZQi8XyBPe1NrKavnzjLXDLNStOJFHUWmUfPjqKhUaWhMbIY5WBfF5IooOfrJ84yl0yz0nQiRY+njqDbiZ6nLs5w7NIsK2WUIvF8gT3tTeiJZPP8+Quvo6FRpaExshjlYF8Xkiig5+snzjKXTLPSdCJFnUXm0bOjaGhUaWiMLEYRBHhmYo6VMkqReL7A8Zl55pJpVppOpKizyDx6dhQNjSoNjZHFKIJJ5enlM4AAAu9JqwXipSzPR8eYy8dYaSobwW228XezL1FG4z0CaGi8kZzld5q2IAki12JJSfNnl/4ZDY0qDY0zyVlEQeCnkQv8kgBptUCslOUOTy+r6c+mnmYmH+eXBLiUi1JvsvGtqycpo1GlofFq6gp/4L8JkyCyFkTWyGgkgapp1EorRY5dmkXPWCTBaDiBnvNLMYxcWIqjZyySYDScQM+PR6dQNY1aaaXIsUuz6BmLJFhto+EEen48OoWqadRKK0VmEimMjIYT6Dm/FMPIhaU4esYiCYyMRhKomkattFJkJpHCyGg4gZ4fj06hahq10kqRY5dm0TMWSTAaTqDnx6NTqJpGrbRS5NjYPMLEAELGxUpj6QVG0wvo+ceF11G1MrXSaoHpXJRrdSGzgKqVqZVWCzwVfgs9F9KLrLa3M4vo+YfQCKpWplZKLTCRj7JWRNaIx2rByHqvGz1O2YxTNqPH57BixGe3oscpm3HKZvSs97oxst7rRo9TNrPanLIZPeu9box4bRaMOGUzenwOK0Z8dit6nLIZIx6rBSNemwUjTtmMnvVeN0bWe93occpmnLIZPeu9boys97qpEEItUDJT5ZSsOCULetY7Ahjxmu1cqwazHSMb7AH0uEwWVptLsqBno70RIz6znbUiskb6G+vp8dRRa3urn/s29SJLIrUO9nVysK+TWm6LzK3tzRjZ39OGLInUOtjXycG+Tmq5LTKf29JPj6eOWttb/dy3qRdZEql1sK+T1Xawr5NabovM57b00+Opo9b2Vj8+uxUjB/s6qeW2yNza3oyR/T1tyJJIrYN9nRjpb6ynx1NHre2tfnx2K0YO9nVSy22R+dyWfno8ddTa3urnvk29yJJIrYN9nRzs66SW2yLzuS399HjqqLW91c99m3qRJRHKEuJ8kKrfatrCbzXdTC23ycbn22+n1+6n1s76bhplF9dqwNHMOnsjtXbVd/GZlu3Ioola9/qHWW33+W+iVr3Jxhfb9rDB1kitW92dBMxO1or08LtYA6IgsCsYIJTNEc7msJpN7Otq5Ys7N+N32Bjwe5hKpIjnC/gcVg5t6eNAT5CNfg9mSWQ6kaJULjPQ6OHo3mHa6hwY8dosDPg9TCVSxPMFfA4rh7b0caAnyEa/B7MkMp1IUSqXGWj0cHTvMEG3k13BAKFsjnA2h9VsYl9XK1/cuRm/w8aA38NUIkU8X8DnsHJoSx8HeoKsto1+D2ZJZDqRolQuM9Do4ejeYYJuJ7uCAULZHOFsDqvZxL6uVr64czNmUcTIRr8HsyQynUhRKpcZaPRwdO8wbXUOjHhtFgb8HqYSKeL5Aj6HlUNb+jjQE8SIKAjsCgYIZXOEszmsZhP7ulr54s7NmEURIxv9HsySyHQiRalcZqDRw9G9wwTdTnYFA4SyOcLZHFaziX1drXxx52b8DhsDfg9TiRTxfAGfw8qhLX0c6Amy0e/BLIlMJ1KUymUGGj0c3TtM0O1kVzBAKJsjnM1hNZvY19XKF3duxu+wMeD3MJVIEc+o+OoF/qh7F3c3bmLA1YJJkJjKhilpZQZdLXx13Sdot3nZ4+1lobDMkpLCKpr5iG8jf9b1UcyixLUSBYG9nh4WCklCSgqLaOajvn6Odu0nILsYcrVwKRsmVszitzj547Y9fNI3wGobcjZjEiQu5aIUtTI3OZv5m66P0mX1ckd9N/NKkkUljVU083HvBh7uuBOzILFWTKwhm9lEwGEj4LQjCQJNThuyJFIxFGjgOx/bQy1JEAg4bAScNhyKCb/Dhtsi8368NgsBh420UqTRbiXgsFEhCQIBh42A04ZDMeF32HBbZCq8Ngtf3bsFPUOBBr7zsT2slrlkmsdGLjIZT9Jot/LpwV62tTQiCQL3DfZy32Avtbw2C1/du4VrIQkCAYeNgNOGQzHhd9hwW2QqciWV7701zusLESRBYG97E/cO9CAJAkOBBr7zsT1cC5vZRMBhI+C0IwkCTU4bsiRSMZdM89jIRSbjSRrtVj492Mu2lkYkQSDgsBFw2nAoJvwOG26LTIXXZuGre7egx2uzEHDYSCtFGu1WAg4bFZIgEHDYCDhtOBQTfocNt0WmwmY2EXDYCDjtSIJAk9OGLIlUDAUa+M7H9lBLEkSaLHU0Wdyk1TwBSx1uk40Kr9nB19Z9Cj2z+Rh/P3eCS9kwftnFH7ZsZ7u7k1/FLsk0W+pottQhCiLNch2yIFGxxdXGPwz8Pv9/kwSRP2rexh81b6OWXTLTYqmjxVKHhEiLpQ6LILGWpIffxRp56IUzPD8zTyKvEM8XOBeKEs0W2NkWwMi/Xprlm6++TTRXIKUUmU6keHlukf3dbciShJ5QJscXnjnFZDxJplhiKZvn+Zl5+nz1jCxG+earbxPNFUgpRaYTKV6eW2R/dxuyJLEWQpkcX3jmFJPxJJliiaVsnudn5unz1dPqcrCa/vXSLN989W2iuQIppch0IsXLc4vs727jay+9wfMz8yTyCvF8gXOhKNFsgZ1tAa7HQy+c4fmZeRJ5hXi+wLlQlGi2QLenji88c4rJeJJMscRSNs/zM/P0+eoZWYzyzVffJporkFKKTCdSvDy3yP7uNmRJQk8ok+MLz5xiMp4kUyyxlM3z/Mw8fb56RhajfPPVt4nmCqSUItOJFC/PLbK/u42vvfQGz8/Mk8grxPMFzoWiRLMFdrYFMPIvS2/yX6Z+TqSYJlXKM5WNcCI+wYHGQWTRhJ7FQpLPXfg+E9kIabVASEnxb9FRNjqbabPWY+RPx5/iF9Ex4qUc0WKWN1JzRIoZ9tb3cCP4wsS/cCx2kVgpR7SU5UzqCkvFDLfXd7NWRNbIeHSZkcUotZ6ZnGO5oGDkifMT1Aplcjw3PY+Rf744Q1opUusH5yd44vwEtUKZHM9Nz7NW/vniDGmlSK0fnJ9gtT1xfoJaoUyO77wxyshilFrPTM6xXFC4VuPRZUYWo9R6ZnKOf3jrEmmlSK0fnJ/gifMT1Aplcjw3PY+Rf744Q1opUusH5yd44vwEtUKZHN95Y5SRxSi1npmcY7mgYOSJyTeptVhI8m+RdzDyZGiEtFqg1j/Mn8bIWCbE68lZav1L+DyJUo7ftHeyS5xOzVHryeg7JEo51orIGplPZzAyn8piJJLNoyeUyWIklMmhJ5zNE8nm0RPKZFkroUwOPeFsntUWyebRM7IYwch8Ksu1mk9nMDKyGEFPOJsnks2jJ5TJYiSUyaEnnM0TyebRM7IYwch8KouR6JwbPYuFJEYWlWX0LCkpjFwpJDByNZ/gN222kMDIbGGZtSKyRtZ73SBoIGggaCBoIGjIJoHOeidGerwuEDQQNBA0EDQQNHq8dRjp8dSBoIGggaCBoIGg0eN10eN1gaCBoIGggaCBoNHjrWOt9HjqQNBA0EDQQNBA0OjxulhtPV4XCBoIGggaCBoIGnf3toGggaCBoIGggaAhmwQ6651cq/VeNwgaCBoIGggaCBqySeDOrhYQNBA0EDQQNBA0erwuerwuEDQQNBA0EDQQNHq8dRjp8dSBoIGggaCBoIGg0eN10eN1gaCBoIGggaCBoHF3bxsIGggaCBoIGggaskmgs96JkR6XF2HZS61eux8jvXY/enrtjRjpcwTQI4smuu0+ftMG7AH0WESJXlsDa0VkjbS4HBzc0EWtzw71YTOZMPLAlo3IkshKQ4EGbu9owcjBvk6CdU5Wcspm7r+pjwe2bESWRFYaCjRwe0cLa+VgXyfBOicrOWUz99/Ux2p7YMtGZElkpaFAA/cNruPghi5qfXaoD5vJxLVqcTk4uKGLWp8d6uO+wV6CdU5Wcspm7r+pjwe2bESWRFYaCjRwe0cLRg72dRKsc7KSUzZz/019PLBlI7IkstJQoIH7BtdxcEMXtT471IfNZMLIA1s2Yo03IyhWqm6qC7KvYQNGfidwM+1WLys5JQsPBPdipM1Sz+8Ghqn1+bbd2EQzv2lBi5vf9w9R63DLLuyimbUiPfwu1si2lkZaXA6upjI0O+38yfbN3NXVSlWuVGIilkSWRKwmiYomp53trQFkSaLRbuVjve18YdsgkiBQoWoa04kUyYJCvdVChVkU2d/dhlUy4ZLN3NLq50s7hmhxOWhy2tneGiBZUCioKvcO9HL4lk1IgkCFqmlMJ1IkCwr1Vgsr5UolJmJJZEnEapJYKZLNcyWVwSXLSKJAlappTCdSJAsK9VYLFWZRZH93G1bJhEs2c0urny/tGKLF5aAqks1zJZXBJctIokCVqmlMJ1IkCwr1Vgsr5UolJmJJZEnEapKoaHLa2d4aQJYkGu1WPtbbzhe2DSIJAttaGgnWOTFLEhsa6vnMTX3c1dVKVa5UYiKWRJZErCaJlSLZPFdSGVyyjCQKVGxraSRY58QsSWxoqOczN/VxV1crZlFkf3cbVsmESzZzS6ufL+0YosXloMlpZ3trgGRBoaCq3DvQy+FbNiEJAkbMosj+7jY0DUKZHLuDTXxl9xZaXA6anHa2twaQJYlGu5WP9bbzhW2DSILAtpZGgnVOzJLEhoZ6PnNTH3d1tVKVK5WYiCWRJRGrSaKiyWlne2uA1JIdJWPh93o38iddH0ESRIyYRYm7fYNYJDMuk5Ud7i7+c/dHabPW86vscHfSZq1nLh+nxVrPf+78CAca+vl1LClpZvNx3CYrkiDy68iWi4xlw1hECatoZqWQkma2kMAtWZEEkYrddR10WT1YRBOD9gAPtu7kE94+1pKgvYs1MhpJ8Mips4QyOSp6PHUc3TVMsM7JkxenefzNMRS1TMWBniCHt21CEgSMjEYSPHLqLKFMjooeTx1Hdw0TrHNiJFcq8cjJEU7PL1HhlM08uHWQ2ztaGI0keOTUWUKZHBU9njqO7homWOfkyYvTPP7mGIpapuJAT5DD2zahqCqPnBzh9PwSFU7ZzINbB7m9o4XRSIJHTp0llMlR0eOp4+iuYYJ1TozkSiUeOTnC6fklKpyymQe3DnJ7RwujkQSPnDpLKJOjosdTx9FdwwTrnDx5cZrH3xxDUctUHOgJcnjbJiRB4Ho8eXGax98cQ1HLVBzoCXJ42yYUVeWRkyOcnl+iwimbeXDrILd3tHA9cqUSj5wc4fT8EhVO2cyDWwe5vaOFX+XJi9M8/uYYilqm4kBPkMPbNiEJAtfjyYvTPP7mGIpapuJAT5DD2zahqCqPnBzh9PwSFdZ1U/ynro+wr6GP1XYhvcBfTP2MhUISDVhnb+RrPR+jw+rFSK5c5CuTP+Pk8jQVTsnClzvuZL93Pb/KE0vn+PbVkyhllYp7fAN8pf0OCprKkamnObE8Q4XLZOFo+x0c8KznRiA9/C7WQK5U4kvPvUI4m6cqni9wIRIn4LDzjVfOoWoaVRPxJGZRZJPfi55cqcSXnnuFcDZPVTxf4EIkzid6OzDy7dfP8+LsAlWKWubUlRA3NzXyVyffIJzNUxXPF7gQiRNw2PnGK+dQNY2qiXgSsyhyfHaeF2cXqFLUMqeuhLi5qZG/OvkG4Wyeqni+wIVInE/0dmDk26+f58XZBaoUtcypKyFubmrkr06+QTibpyqeL3AhEifgsPONV86hahpVE/EkZlFkk9/LtTqzEOYbr5xD1TSqJuJJzKLI8dl5XpxdoEpRy5y6EmJPsIl6q4Vr9e3Xz/Pi7AJVilrm1JUQe4JN1Fst6DmzEOYbr5xD1TSqJuJJzKLIJr+Xa3VmIcw3XjmHqmlUTcSTmEWR47PzvDi7QFXBnuDl5EX2etfhMdtZLblykT8e+0dCSoqqWDHLW+l5Dvo3Y+T/uPw8/xYfp6qgqbyYmOIOTy9esx09p5KX+er0L1A1jaqxbBizIPHz+Dg/j1+iStFUXlie5s76HrxmO79pImvkrVCMSDZPrcl4ku+fH0fPibkFjLwVihHJ5qk1GU8ys5zCyMtzi9RSNY2/G7lAJJun1mQ8yffPj6PnxNwCL88tUkvVNP5u5AKRbJ5ak/EkM8spjLw8t0gtVdP4u5ELRLJ5ak3Gk3z//Dh6TswtcD1OzC2g58TcAi/PLVJL1TROXQlxPV6eW6SWqmmcuhLCyIm5BfScmFvgepyYW0DPibkFXp5bZCXpShcsBXg5NsFqGknOsaSkqXUpG2YqF8XIC/EJaqlamRcTkxh5Ln4JPc8lJnguPkEtVSvzwvIUNwKRNaJqZYzkiip6FLWMEVUrY0QtaxhRyxp6ckUVI7miih5FLaOWNfTkiipG1LKGEbWsoSdXVDGSK6roUdQy10NRy+hR1DJqWUOPoqpcD7WsoUdRVYwoahk9ilrmeihqGT2KWkYta9QSU26KeROrSdU0jKhaGSMlrYyeQlnFiFJW0VMol1C1MnoKZZUbgcgaGWj04pTN1Ao4bNy7sQc921v8GBlo9OKUzdQKOGx01rswsrXZh577h/pwymZqBRw27t3Yg57tLX62NvvQc/9QH07ZTK2Aw0ZnvQsjW5t96Ll/qA+nbKZWwGHj3o096Nne4ud67Gjxo2d7i5+tzT70bG8JcD22NvvQs70lgJEdLX70bG/xcz12tPjRs73Fz9ZmH3p2untZTZtdLTglC7WaLXV02xowssPdgZ699V0Y2evuQs9edxc73R3oudXdyY1AevhdrAGrSaLT7eLMQhhFLVPhs1t5aPfN3NLiJ10sMRZNUDUc8HH4lkHMoogeq0mi0+3izEIYRS1T4bNbeWj3zfgdNoxs8jcwEooQzxeokASBQ8P97O9uo9Pt4sxCGEUtU+GzW3lo983c0uInXSwxFk1QNRzwcfiWQYabGhkJRYjnC1RIgsCh4X72d7fR6XZxZiGMopap8NmtPLT7ZvwOG0Y2+RsYCUWI5wtUSILAoeF+9ne30el2cWYhjKKWqfDZrTy0+2ZuafGTLpYYiyaoGg74OHzLIGZR5Fp11rtIF0uMRRNUDQd8HL5lkOGmRkZCEeL5AhWSIHBouJ/b2pu5Hpv8DYyEIsTzBSokQeDQcD+3tTdjpLPeRbpYYiyaoGo44OPwLYOYRZFr1VnvIl0sMRZNUDUc8HH4lkGGmxoZCUWI5wtUSILAoeF+bmtvZjVZRTPdtgZeWZ5B0VQq/LKTr/d8nIClDiPDrlbOpOaIFrNUSILIf2zby13edRjpsTWQUguczyxSdYsryFc69rHD1c7p1BzRYpYKSRQ53Lqbj3rWcSMQtHexhpYLChfCMSRRYLO/AZvJRIWqaTxx4RJPT80yHPDx+eEBnLKZ97NcULgQjiGJApv9DdhMJipUTeP45XkmE8sEHHbu7GjFKZupUDWN0UiceL5Af4MHn91K1XJB4UI4hiQKbPY3YDOZqFA1jScuXOLpqVmGAz4+PzyAUzZTEcpk+e65UcZjy/x2Xzf3rOukarmgcCEcQxIFNvsbsJlMVKiaxvHL80wmlgk47NzZ0YpTNlOhahqjkTjxfIH+Bg8+u5Wq0/MhHntzDJvJxANbNtLf4KFqPp1hPLZMi9PBeq+bD2o+nWE8tkyL08F6r5sqVdMYjcSJ5wv0N3jw2a18EKqmMRqJE88X6G/w4LNb+XXMpzOMx5ZpcTpY73XzQc2nM4zHlmlxOljvdVOlahqjkTjxfIH+Bg8+u5X3o2plnotd5FJmiWaLm/2+fpyShYqwkuKF2CWWiimGnK3s9fRStVzK8WZqHkkQ2FIXxCaaqVC1Mv8WG+dSNkyTpY4DDX24JAsVqlbmfGaRaDHDoKMZv+yk6u3MIi8vTyMLErfX99Bja6BC1cr8t4Uz/HP0AttcQf40eCsuyULFvJLkm1deZjSzxB82DfN7jUPcKATtXfyGqZrGkRde5c2lKFUBh51v3bkLn93KtVI1jSMvvMqbS1GqAg4737pzFz67lWulahpHXniVN5eiVAUcdr515y6WCwpHjr/KckGhal9HK0d2DmNE1TSOvPAqby5FqQo47Hzrzl347FaM/GhskkfPjVIlCQJf3jnM7e0tfOjGoWplvnjxx5xLXkHj/9VkqeNv++8lUcrzJ2M/ZrmUQxN4z/6Gfv68+26MqFqZBy8+ydnUFSo0AZotdfz9ht/FLzsx8v3Fs/xfV06AwHtEQeSvOj/KnZ5ePn/pKd5IXaGqWa7jsQ2/TaKU44FLT5Eo5XiPAHd7+3ikcz83Aunhd/Eb9tT4DMcmL7NSplgkni+wJ9jMtXpqfIZjk5dZKVMsEs8X2BNs5lo9NT7DscnLrJQpFonnCxyfnWcumWal6eUUPfV1BOuc6HlqfIZjk5dZKVMsEs8X2BNsRk8km+fPXzqDxv9HA0ZCEQ6u70YSBT50Y/in0Fl+uvQWIFCVVgvEizmejY0xm4/xHoH3TOairLP76bB50fOjpRF+En6bXxIgrRaIlbLc4elFz5KS5k8mfoqGBgLvKaPxWmoOQRB4KnKBlVJqgXgpyzPxcWbycX5JgEu5KBtsjXRZPfymidwALkRi6BmLJrgeFyIx9IxFE1yPC5EYesaiCUYjcfScj8QwciESQ89YNIGR0WgcVdOolVaKzCyn+NCN4+30VfS8k1ngQnoBPW+mr2LkzdQ8ei6kFzHydmYBVStTK6UWeDL8NnrezoR4O7OInpHMPDcCEzcAn82KHqds4nr4bFb0OGUT18Nns6LHKZvIFM0sFxRq+Ww2jPhsVvQ4ZRNGPFYLRrxWC7+u2dlZTp8+zcjICOfOnWNkZITFxUVuZE1NTQwPD3PTTTcxPDzM9u3baW9v50bVKLvQ45QsOCULy6UctfyyEyN+2Ykel8mCkQazAyN9Dj9XlRS1XJKMS7IQL+WoFTA7uRGYuAHs7w5ybOoyilpmpYMburke+7uDHJu6jKKWWenghm6ux/7uIMemLqOoZVY6uKGbUCbL//32RVZyW2RuDTZjZH93kGNTl1HUMisd3NCNkX6fhx5PHZOJJCttb/Hjs1t5P6VSia9//ev89V//NaVSiX9PFhcXefrpp3n66aepMJlMfOUrX+Ghhx7CZDJxo7nbN8BPl95CKaus9DtNW1goJPlvV06ykttk43bPeox83DfAT8LnUcolVrrXP4yRTY4m1tsbGc+GWWmPu4tDTbdwYnkGpayy0n2Bm5gvpPjb+VdYqd5k4y5PLzcC6eF38RvmtVoY8HmZSiSJ5wv47FYODfVzoCvI9fBaLQz4vEwlksTzBXx2K4eG+jnQFeR6eK0WBnxephJJ4vkCPruVQ0P9HOgKstHnxSyKTC+nKJXLDPi8HN21hTaXAyNeq4UBn5epRJJ4voDPbuXQUD8HuoIYEQWBXW1NhDI5wtk8VkliX2cbX9y2GbMo8qu88847fPzjH+cHP/gB5XKZf+/K5TIvvvgiP/vZz9izZw+NjY3cSLxmB5udbUxkl4gVszTKLj4fvJWPNw6yydmCSZSYzEYoUmaTs4W/7Pk47VYPRhrMDoZcLVzKhokVs/gtTv64bQ+f9A1gRBQEbq/vYV5JElJSWEUzBxr6+GrnXTTJLoadLYznIkSLWQKykwdbd3OPb4AhZzMmQeJSLkpRK3OTs5m/6fooHRYPNwJBexc3uOcuX+Un41OklRJ9DfUc2tyPz27lV5lLpnnsrTEmE0kabVY+vXEd25obqXju8lV+Mj5FWinR11DPoc39+OxWcqUS3zs/zuuLYSRBYG+wmXv7e5EE4f8hD17A26wPQ/9/f+8rybpatuxYtmw5TpQ48SW2czUkwFxCcwJtV9L1KVu2slMuhbasFNINlkLnDMgeGKMb51lLR6GsdHQtnDI2WLNxCIGEgOMkDkkcJ44d3y+KfJFkSa/u70HnebR6+kssdoPxf3w+fJg3BkZ4ufsCgWic1UUF3NZQQ7FRz3y9MTDCy90XCETjrC4q4LaGGoqNeubjJz/5CXfccQfhcJj/jvR6PT/84Q+5+eab+a8o8TjPn+7m6LgHWQiudpZxU80KZCGYDyUe5/nT3Rwd9yALwdXOMm6qWYEsBEMBP0+Nvcn5kIcSnYUvO5pptlbxYZRkjGdG3qXN148kJD5VuJIvl21EFhLzEUrGeHrkPd6dGUAWEtcWrOB/lm5AFhIf5rWps7zgPsFMIsoas51vlm/BrjUTSsbQHv8xyZFjIMnIS69Cs+YmEDILRW79AIvYq70DPHHkBJNKmJlolD6fn0Mj42xb5kQny2TjDoa46/WD9Hp9BGMxLoYU9g8Ms7qokI6LEzxx5ASTSpiZaJQ+n59DI+NsW+bkz985yv6BEbyRCNPhCCcuTjCphLmyvJRcXu0d4IkjJ5hUwsxEo/T5/BwaGWfbMic6WWauXu0d4IkjJ5hUwsxEo/T5/BwaGWfbMic6WWYuzpw5w+c+9znC4TD/XcXjcfbt28cXvvAFlixZwod54O029g+M4I1EmA5HOHFxgkklzJXlpczHA2+3sX9gBG8kwnQ4womLE0wqYZYX5HPXvx+if0TFaxnDHZ3h9ckuas1lVOgLyOXb3f/Ev0+eZTquMBkLcWxmiIlYkKsLXMzH3edfYd/UOabjCpOxEO0zw3hiQX6rYDm5vOQ5xZ6BN/DEgvgTYc6HJ3nDe4EbbavRvPFnJC7sRw17UZVpkuPvo4YmkZ1XslAkFrkXznSTyR0M8Ub/MLm8cr6fQCxGpp+dOc8LZ7rJ5A6G+MHxTjrcE2Tad2EQXyRKLi+c6SaTOxjijf5h5uOFM91kcgdDvNE/zFzE43FuvvlmwuEw/92Fw2Fuvvlm4vE4uXRPeelwT5Bp34VBfJEoc9U95aXDPUGmfRcG+cnpbgKxGP9PUiLtJ6Nt5HI26Oaof5BM/+I5jTeuMFddQTft/iEyvTLRiTeukMsz4+1kMvmHSR75PsmxDjIlzu9DjfhYKBKL3EQoTDbuoEIu7mCIbDxKmIlQmGw6LnrIZTQQJJeJUJhs3EGF+ZgIhcnGHVSYi4cffphjx47xSXHs2DEefvhhchkNBMllNBBkrkYDQXLpuOghTeuxk3YxOkMuwxEvuYyEvczVUMRHLkMRH7m4owFmMydiPNZ/FO3IcUAAAhCAAAQgUP1jLBSJRc5VmA8CEIAABCDAVZhPLq5CKwhAAAIQgABXYT6uwnwQgAAEIAAB1y+vBAEIQAACEKDTSFRZLeTiKswHAQhAAAIQ4CrMZz5chfkgAAEIQAACXIX5XKrBwUEeeeQRPmkeeeQRBgcHyabaVgACEIAABCBAp5GoslqYq2pbAQhAAAIQgACdRmLr0goQgABZMZM36EJE81hhXEIuq012stFJGpYbi5mrGlMJ2egkGZehiFxWGZcw2793vU5pXEGu3g4CEIAABCAAjQ6pcCkLRWKRu7OpHp0sMVtjSREtleXksqN6GU6LmdnMWi23NtRwZ1M9OllitsaSInbWVrNj5XIy3bKmBoNGQy53NtWjkyVmaywpoqWynPm4s6kenSwxW2NJES2V5VyqtrY24vE4nzTxeJy2tjaycZhN7Fi5nEy3rKnBoNEwVw6ziR0rl5PpljU17KxdidNiJk0kJQp9FdzpvJpcKvIK+JJ9LZm+VrEFg6Rlrpx5BfyuvYlMd5VvwShpyWVXxdXoJJmUB0ZOkiKVNqBt+D00NTeSSbvuK6AxsFDk1g+wSCjxOD3TPnSyjF4jk1JqMtLsKEUnySwx6rlh+VLuWrcGWQhSEqpKn28GfyRKgT6PFK0ksW2ZE72swaLTsqnMzq6NjTjMJkpNRpodpfgjUSKJJDfVrODu9Q3IQrCxrASnxYxWllhlK+QrDau5bmkFaUo8Ts+0D50so9fIpJSajDQ7SvFHokQSSW6qWcHd6xuQhSAloar0+WbwR6IU6POYTYnH6Zn2oZNl9BqZlFKTkWZHKf5IlEgiyU01K7h7fQOyEFyqf/iHf+DQoUN8Eq1YsYKtW7eSzcayEhxmEyOBIGVmE/dsbOS6pRXM18ayEpwWM1pZYpWtkK80rOa6pRVoJYlty5yoKriDIbZUlPHApk2UG/NJ80RnGAp7ydfokYVEyhXWKpYabOgkmVpzKXdWbGF7UQ1pSjLGueBFdJIGvaRltovRAIPhaawaPbKQSNlsraJKb0Mnaagz2fl6+RZusK3mwzjy8vmsuYK7Pb1Uy3loqm9A1/x1EDJy+QYkiwPVP4qwlKG98ltolm9lIWlYJH7ZfYFnT3URTSRJ2b6skrs3NCALgasgn6+trSNT1+Q0e987jjsYIsVVkM/uK9fjtJgxaDTsrF1JJiUe57lTZ2kbc5Pyi64eSo0GWirLSWmpLKelspxMv+y+wLOnuogmkqRsX1bJ3RsaiCYSPHfqLG1jblJ+0dVDqdFAS2U5XZPT7H3vOO5giBRXQT67r1yP02Lml90XePZUF9FEkpTtyyq5e0MD0USC506dpW3MTcovunooNRpoqSznUp04cYJPqhMnTpBL1+Q0z50+hzsYIuXZk12Umow4LWbmq6WynJbKcjL96sIgL5+/QDSR5PX+IWQhuHtDA9FknD/rfY13vRdQBZjlPL5ddR3X2VaRcp1tFdfZVpHp5+4Ovj/8DtFkHFXAbxfXcd/SrUTVBN/p/Vfe8fWRYpbzuG/pVrbZqknZZqtmm62auSizOGDjHWRKTpwl9v5PUANuUuInfoxktiOsThaK3PoBPmbt4xd5rK2DhKqS1uP1oZUk1iwpIhslHmfXm4fxhBTSpsMROiem+Kyrilz+17FTvDU0Slo0meTwyDhXVZRRoM8jm/bxizzW1kFCVUnr8frQShIHBkd5a2iUtGgyyeGRcdaXLuGhw0fxhBTSpsMROiemsJuMPNbWQUJVSevx+tBKEgcGR3lraJS0aDLJ4ZFxrqooo0Cfx6X49re/TSAQ4JMoEAjw7W9/m0xKPM6uNw/jCSmkTYcjdE5M8VlXFZdT+/hFHmvrIKGqpPV4fWgliTdHB3kjcBKECgKiaoKD3gv8VuFKCrVGsnnP18+eC/9GQk3y/wg4F/KglWRenzrH69PdpEXUBG95L/CpwhXYtEYum7hC5N/+BDXoIU1Vpkl6OtFUf4aFIrEIHBweAwEIQAACEHBwZJRcTnommQiHQQACEICAXp+fft8MuRwaGQMBCEAAAhKoHB4dJ5eDw2MgAAEIQAACDo6McmhkDAQgAAEISKDy1PudTITDIAABCEBAr8/PT890gwAEIAABCDg4MsqhkTEQgAAEICCByuHRcS7V+Pg4n1Tj4+Nkc9IzyUQ4DAIQgAAE9Pr89PtmuJwODo+BAAQgAAEIODgyyjsDHvRDLuSQibSEmuTgdA+5vDl9nmzenD7Pm9M9ZEqoSd7y9nI5JcZPoYYmAQEIQACC5FQfSe8AC0XDIhBNJMgmmkiSSyKpkktCVckloapkE00kyCWaSJBNNJEkoapko8Tj5KLE42QTTSRJqCrZRBMJFsJrr71GcXExhw8f5p//+Z85cOAAqqryUZIkie3bt3P99dezceNGBgcH+dKXvsTllEiq5JJQVS6naCJBNtFEkoSqkqKdLCVu6iUtqibIJZqMk00kmSCuJskmkkxwWakJckomWCgaFoErHHb2Dw6TqbmshFzqim2YtRoCsRiz2U1GqqwWctlQWszB4TEyNZfZyeUKh539g8Nkai4rwR0KcXB4jEy3rqnh0bbjBGIxZrObjNy0agWPHjlOpuayEtyhEAeHx8jUXGbno+Z0OrnhhhtI2bRpE9/61rfo6uri8ccf56c//SnRaJTLSavVsnPnTu6//35Wr15N2qZNmygqKmJycpLLpa7YhlmrIRCLMZvdZKTKauFyusJhZ//gMJmay0pwh0IcHB5DJAW6qWKitglSNluXkcuWguXsmzxHpi3WZYxFfeyf7iHT1QXLuJykkjpEnhk1GmQ2YbYjFS5loWhYBFqc5XRNTfPy+QukrS0p5st1q8jFmqfjvuZ1PHrkOIFYjJRig4HdV6xHFoJcvrG2gdFgiF6vjxRZCG5ZU0tNUSG5tDjL6Zqa5uXzF0hbW1LMl+tWocQTjAZD9Hp9pMhCcMuaWprL7NzXvI5HjxwnEIuRUmwwsPuK9dTYCun2enn5/AXS1pYU8+W6VSjxBKPBEL1eHymyENyyppaaokI+as3NzWSqqanhmWee4aGHHuLhhx/mhz/8IclkkhSNRkN9fT1VVVUUFBRQUFBAQUEBKV6vF6/Xi9frpb+/n9OnTxOPx0kRQnDbbbfxwAMPUFlZSSYhBFdeeSWvvvoql4s1T8d9zet49MhxArEYKcUGA7uvWI8sBJdTi7OcrqlpXj5/gbS1JcV8uW4VSjzBaDBEr9eHZqYADBFur15HnbmMXK6zreJ0YJyfuztI25jv5PbyKwglogxHfHSHPKTIQuIb5VdRbyrlchJ5+Wi3fJvYO4+jRoOkCGMxuqv+BITMQhHqB1hAXVPTtI250UkSm8vLqMq3kDYaCNI97cVhNlFdWMClaBtz88ypMxg0Gu5sqqfGVkhKQlU5MDRCr9eH3Whk69IKzFotKe5giL872Um318cXV7r4/IplpHVNTdM25kYnSWwuL6Mq30LaaCBI97QXh9lEdWEBaQlVpWtymulwmJqiQooNBtLaxtw8c+oMBo2GO5vqqbEVkpJQVV7o6uZXfYOsLSnma031mLVaUtzBEH93spNur48vrnTx+RXLSOuamqZtzI1OkthcXkZVvoVMQgjm4/HHH2fXrl18mHfffZejR4+yceNGmpqa0Ov1XIpwOMyJEydob29nw4YNXHnllXyYRx99lPvvv5/5UFWVXHyRKJ2TU8hC0LCkCINGQ0pCVTkwNEKv14fdaGTr0grMWi0pE4rC28NjTCgK9cVFbHaUcilGA0G6p704zCaqCwtIcwdD/N3JTrq9Pr5YvZzPu5aT1hkY4x1fHzohc03hCpYbikgbjnjpCrqpyCugxmQnbSzi52+G3+Zs6CI77ev5Ukkj/5WEmuS0+31qR44jzHbkZZ9C6Ez8V9SIn+TFMyBJyPYG0OhZSEL9AAvkxe5enj7ZSZosBPdtWkeLs5z5eLG7l6dPdpImC8F9m9ZxdYWD+99+l/c9E6TZTUa+17IFXyTK/QffxReJknZtZQX3b1rHi929PH2ykzRZCO7btI4WZznz8WJ3L0+f7CRNFoL7Nq3j6goH97/9Lu97Jkizm4x8r2ULvkiU+w++iy8SJe3aygru37SOF7t7efpkJ2myENy3aR0tznJmE0IwH2+++SYtLS0sBgcOHOBTn/oU86GqKnORUFXuf/td3vdMkGY3GfleyxZ8kSj3H3wXXyRK2rWVFdy/aR3z0ev1cf/Bd/FFoqRdW1nB/ZvW8cL4Mf526G1SVEAWEn+2fDvX2VaRS3fIwx91/xJvXCFFBbYX1fDny/4HuSTUJIH93yVv/ARpwmRHt+1RhLGYxUzDAplQFJ49dYbZEqrKk8dPstlRhk6WmIsJReHZU2eYLaGqPHn8JOPBEO97JpjNHQzxo1NdXAyF8EWizLZ/cJgaWyHPnjrDbAlV5cnjJ9nsKEMnS8zFhKLw7KkzzJZQVZ48fpLxYIj3PRPM5g6G+NGpLi6GQvgiUWbbPzhMja2QZ0+dYbaEqvLk8ZNsdpShkyV+U1NTUywWU1NTLJRXevp43zPBbO5giB+d6uJiKIQvEmW2/YPDXFPhYLOjlLn62xOn8EWizLZ/cJgaWyFPeQ8xW0JN8lj/G1xT4EInacjmrwbfxBtXmG3f5Fm2Fq7gtwpcZBM8/6/kjZ9gNjXoJt7xHNot32Yxk1ggXZPTJFSVTIFYjH6/n7nqmpwmoapkCsRivNY3QDZnp6bpmpwmm5fO95JQVTIFYjH6/X7mqmtymoSqkikQi/Fa3wDZnJ2apmtymmxeOt9LQlXJFIjF6Pf7uRw6OztZLDo7O1konROTZHN2apquyWmyOT0xyXx0TU6TzUvne9GOl5IpkIhwQZkkl9PBcbI5MTNKLgb3KUAAAhCAAATJyW4WO4kFUqjXk4tNn8dcFer15FJdYCUbs1aLWaclm+oCK7nY9HnMVaFeTy7VBVayMWu1mHVasqkusJKLTZ/H5XD69GkWi9OnT7NQio0GsjFrtZh1WrIpNhiYD7NOSzbVBVbksAHtjJVMNq2JXCxyHtmU6MzkZCwGAQhAAAIQIHRmFjuJBVJTVIir0AoCEIAABDSX2Sk2GJirmqJCXIVWEIAABCCguczOzppqdBoJBCAAAQjYsXI5O1YuBwEIQAACrHodX22sw1VoBQEIQAACmsvsFBsMzFVNUSGuQisIQAACENBcZmdnTTU6jQQCEIAABOxYuZwdK5eDAAQgAAFWvY6vNtbhKrSCAAQgAAHNZXaKDQYuh/Pnz7NYnD9/noWybakTnUYCAQhAAAJ2rFzOjpXLQQACEIAAq17HNRVlzMeOlctBAAIQgACrXsdXG+twFVrRTRcjRXWkbS5YRonOTC432deSqUBjYGvhSnKRl28FOQ8QgAAEIJBX/zaLndz6ARaAJASbHWW4QyE8ioJelrm2soJ71zehlSTmShKCzY4y3KEQHkVBL8tcW1nBveubKDEaqSuyccHnYzocpthg4LY1tWyvqqS2yIZWkujz+4gnk9QV29i9aT1Oi4XNjjLcoRAeRUEvy1xbWcG965vQShJzJQnBZkcZ7lAIj6Kgl2Wurazg3vVNlBiN1BXZuODzMR0OU2wwcNuaWrZXVVJbZEMrSfT5fcSTSeqKbezetB6nxcJmRxnuUAiPoqCXZa6trODe9U1oJYnZ9uzZw3zs2bOH9evXsxgIIXj11VeZj9bWVubCptdTV2Tjgs/HdDhMscHAbWtq2V5VSW2RDa0k0ef3EU8mqSu2sXvTeiosZuajtsiGVpLo8/uIJ5PUFdvYvWk9TouFzY4y3KEQ0x4txoSRrc5Kdi/bhlbI5NJgLkMjyfQqE8TUJA3mMh5efj2V+kJyEYZCpCU1qN5+1PA0wliMtukPkV2fZrHTsIBs+jwevGIj2QzNBHjmdCe9Xj9LjAZ+b3U1G+0lpLwxOMTLPRcIxGKsthVyW30txQYDNn0eD16xkWwalxTzg60tZJKFYOfqanauriaTTZ/Hg1ds5HIxaGTsRiN2oxFZEpSajOhkmZTGJcX8YGsLmWQhsBsN2I1GTNoYJUYD1jwdKTZ9Hg9esZGPwlVXXcXtt9/OYnH77bfz/PPPc+jQIS4XJR7n+TPnOOq+iCwJri53cNOqlchCYNPrsRsNBKIxlhgN2E1GUmQhsBsN2I1GTNoYJUYD1jwd8yULwc7V1excXU0mmz6PB6/YSDYD4Sm+P/QO5xUPS3RmvlK2iSusVchC4payTdxStom5kOxr0F3/1/z/jdz6AT5m7lCIu/a/Ra/PTzAW42JIYf/gMKuLbHRc9PDEsRNMhsPMRGP0+fwcGhljW1UlOllmMXvgnffYPzSMNxJhOhzhhGeCSSXMlY5Scnn1Qj9PHDvBZDjMTDRGn8/PoZExtlVVopNlLsWePXuYC51Ox2uvvcaSJUtYLIQQXHnllTz99NMkEgnmorW1lWweeOc99g8N441EmA5HOOGZYFIJs7wgn7v2v0Wvz08wFuNiSGH/4DCri2x0XPTwxLETTIbDzERj9Pn8HBoZY1tVJTpZZiGMRfx85czPOK94CCQijMdm2Dd1lnpTKRX6Aj5JJBaBV3r6CMRiZPrZ2W5eONtNJncoxBuDwyxm3dNeOi56yLSvfwBfJEouL5ztJpM7FOKNwWE+Kvfccw81NTUsNjU1Ndxzzz1cDt3TXjouesi0r3+An5w5SyAWI9PPznbzwtluMrlDId4YHGahvHTxBIFEhEw/HjvCJ43EIuBWQiAAAQhAAAI8isJEWAEBCEAAAhDgDoVYzEaDQRCAAAQgAAEIGA0GyWUirIAABCAAAQhwh0J8VLZt28ZitW3bNi6H0WAQBCAAAQhAAAI6PBMgAAEIQAACPIrCRFgBAQhAAAIQ4A6FWCgX/TGyuRgL8EkjsQi4rFaycVnzcVmtZOOy5rOYVRcUkI1OlqjKt5CLy2olG5c1n49KfX09i1V9fT2XQ3VBAdnoZImtzgqycVnzcVmtZOOy5rNQamQnIimRaaVhCZ80EovAjhXLcVrMzGbWarm1vo47G+rRyRKzNS4ppsVZwWLmMJvYsWI5mW6pq8Wg0ZDLnQ316GSJ2RqXFNPirOCjUFJSQklJCYtVSUkJJSUl/KYcZhM7Viwn0y11texcXY3TYmY2s1bLrfV13NlQj06WmK1xSTEtzgoWyo4Vy1kZW8ZsFjmPb1Rs4ZNGbv0AHzOtJLFtaSWqCu6QwpbyMr6zaQMOs4lSk5HmslJ0ssQSg4Ebli3lrqYGZCFISagqfX4//miUgrw8LtWEojAcCGLR6ZAlQVpCVenz+/FHoxTk5XGpJhSF4UAQi06HLAlSNtrtOC0WtJLEKlshX6mr5bpKJx+m1GSkuawUfzRKJJHgpuqV3L22EVkILtWePXu4VM3NzfzhH/4hi9m+ffvo6+vjUrW2tpLNRrsdp8WCVpJYZSvkK3W1XFfpRCtJbFtaiV7WYNHp2FRqZ9f6tTjMJkpNRprLSvFHo0QSCW6qXsndaxuRhSAloar0+f34o1EK8vKYTYnH6fH60MkyelnmUiRUlT6/H380SkFeHilaSWK7w4UlVIRZL3NlQRUPVH2aCn0BacnQJOrMKEJnAUnmN6WGJlFnRhE6C0gy/0FNkPQOQHQGobey0DQsEr/qH+Dl3l6iiSSvDwwhC4m71zYiC4HLauVrDWvI1DU1zd4jR3GHQqS4rFZ2b9qA02ImFyUeZ++Ro7SNu0kxa7V8c20jLRXldE1Ns/fIUdyhECkuq5XdmzbgtJjJRYnH2XvkKG3jblLMWi3fXNtIS0U5KS0V5bRUlHOplHic5zq7aBt3k/KL7vOUmoy0VJTzUSgvL2exKy8v53JpqSinpaKcTAaNhp2rq8mkxOM819lF27iblF90nxL9HhAAAHnzSURBVKfUZKSlopyuqWn2HjmKOxQixWW1snvTBpwWM7/s6eXZzjNEE0lStlct5e61jchCkEvX1DR7jxzFHQqR4rJa2b1pA06LGYNGw++vWgWsYjYlGePh7td48MTfkyJ0JjQb7kSuvIp5iYeJHn6c5OgxUoTOhGbDnciVV5Gc7CZ2+K9QgxdJkQqXob1yFyK/nIUisQi0uy/y1MnTRBNJ0vb1D/Dzc+fJRYnHeaitHXcoRFqvz8feI0f5MD84eZq2cTdpgViMR9uP0TU1zUNt7bhDIdJ6fT72HjnKh/nBydO0jbtJC8RiPNp+jH6/n/n4wcnTtI27SQvEYjzafox+v5+PwtDQEIvd0NAQH5cfnDxN27ibtEAsxqPtx+iamuahtnbcoRBpvT4fe48cpd19kadOniaaSJK2r3+An587Ty5KPM5Dbe24QyHSen0+9h45yof5/sB+fv/UP4MQIARqLETsvb9B9Q0yH7GOZ0mOHQchQAjUWIjYe39DcrKb2OG/RA15QAgQgqS3n9i7T7CQJBaBgyMjIFQQKggVhApC5eDoCLmcnJhgIhwCoYJQQaggVHr9Xvr9fnI5NDoCQgWhglBBqCRI8tSpU0yEQyBUECoIFYRKr99Lv99PLodGR0CoIFQQKgiVBEkOj40xH4dGR0CoIFQQKgiVBEkOj43xUejt7WWx6+3t5eNyaHQEhApCBaGCUEmQ5KlTp5gIh0CoIFQQKgiVXr+Xn549C0IFoYJQQaggVA6OjpDLyYkJJsIhECoIFYQKQqXX76Xf7yeXuzp+yvKkl/9ETZAYaWM+kkPv8v+hJoh3PIsamiRT0tuH6htkoUgsAtFkkmyiySS5JFSVXBKqSi4JVSUbJR4nl4SqkktCVckmmkgyHwlVJZtoIslHYWRkhEgkwmIViUQYGRnh45JQVbJR4nFyUeJxsokmk+SSUFVySagquahqgqwSMeZDVRNko8bD5KKqCRaKxCJwRamdbJpL7eRSV1SEWaslk91opCo/n1w2lJSQza11tZi1WjLZjUaq8vPJZUNJCdk0l9qZjw0lJWTTXGrno5BMJunv72ex6u/vJ5lM8nHZUFJCNrfW1WLWaslkNxq5qXol2TSX2smlrqgIs1ZLJrvRSFV+PrmIoiYQAoQAIUAIEALJsYH5kMvWghAgBAgBQoAQaBv+AKEzgxAgBAgBQiDMdiRrJQtFYhFoqahgh8vFbGuXLOHLq1eTi1Wn474N6zFrtaQVGwzs3rgBWQhy+UZjAy6rlTRZCG6vr6e5tJT7NqzHrNWSVmwwsHvjBmQhyOUbjQ24rFbSZCG4vb6eGpuN+fhGYwMuq5U0WQhur6+nxmbjo9Lb28ti1dvby8fpG40NuKxW0mQhuL2+nubSUu7bsB6zVktascHA7o0b2Op0ssPlYra1S5bw5dWrycWq03HfhvWYtVrSig0Gdm/cgCwEuUj1t6IalvIfhIym8WakomrmQ7PudqSCZfwHIaNpvBnJsQFt8zcRWhNpwlCE9op7QMgsFLn1AyygrqkpXuvr58zUFBadjoK8PFI22u1srXRSa7NxU3U1v7uqGq0k8WEqzGaq8vPp8/spM5nYtW4tNTYbH8ag0bDRbmdCUYgkEtxcW8MXVrhIqTCb2V5VRV2Rja1OJ1+tr6fMZOLDGDQaNtrtTCgKkUSCm2tr+MIKF2ldU1O81tfPmakpLDodBXl5pCRUlTeHh/k/Q0MMBwJUmM3oZBmDRsP1VVWsLylhk72Ur66pZ6PdTlrX1BSv9fVzZmoKi05HQV4emfbs2cNcrF27ls2bN7MYvfLKK7z++uvMRWtrK5eLQaNho93OhKIQSSS4ubaGL6xwkVJhNlOVn0+f30+ZycSudWupsdlIWVdSgoRgNBhki8PBrvXrMGm1pEwoCvsGBjk4OkokkcBpsZBSYTZTlZ9Pn99PmcnErnVrqbHZSEmoKm8ODxN65mckO8+hdy1D0uchG41gbUBKTEEiirb+d9FUf5b5Eho9UmkTKJOQiKKt/1001Z8lRVgcyMu3IhWvRrP0GrRNf4gw21lIcusHWCAv9vTwSHs7pyYnOTExwb/291NhNlOVn0+KRaejKj+fIoOeS/FiTw+PHz+ONxphIqzw+uAgFWYzVfn55NLr83HvwYN0+7wE4zHa3W5GgkGucjhI0csyTouFCrMZrSTxX+n1+bj34EG6fV6C8RjtbjcjwSBXORy82NPDI+3tnJqc5MTEBP/a30+F2YzTYuH+d97hf/f2cmZqina3mwMjI1zjcGDUapGEoMRoZGm+BaNWS9qLPT080t7OqclJTkxM8K/9/VSYzVTl5zPbnj17mIuenh6+/vWvI8syi0ksFuPmm2/G6/UyF62trVwuvT4f9x48SLfPSzAeo93tZiQY5CqHgxd7enj8+HG80QgTYYXXBwepMJtxWizc/847/PvQIKF4nAt+HwdGRrjG4WAsFOKet9/mnbExzkxNcWBkhJFgkKscDl7s6eHx48fxRiNMhBVeHxykwmzGabHw/edeYOnvfJXowTa8/+cgk//0K4o+9z8IDwxz6vo/QI4PYLAnSY51oAbGkCuuYD6S3n5ibz5AcvoCxEIkxzpQA2PIFVeQIjR5SPnlCIsDJA0LTW79AAtgQlH47nvvofJrKtDh8bDD5UKWJOZiQlH47nvvofJrKtDh8bDD5UKWJLJ5uL2doUCA2fr8flxWK06Lhbl6uL2doUCA2fr8fvJ1Op4+fRqVX1OBDo8HAewbGGC2YCzGdDTKVQ4H2UwoCt997z1Ufk0FOjwedrhcyJJE2p49e5gLr9dLZWUl69atYzH50Y9+xE9/+lPmqrW1lcvl4fZ2hgIBZuvz+8nX6Xj69GlUfk0FOjweBLBvYIDZgrEY09EoB4aHGQoEmK3P7ydfp+Pp06dR+TUV6PB4EMDyW3ahicdBAAIS/hliE5NM/PI1wj19+E7OYKrUoy/NQ/UNIhVUIfLLmav4u4+jzowiBAgBQoDqG0QqqELkl/Nxk1ggXdPTJFSVTIFYjP6ZGeaqa3qahKqSKRCL0T8zQy5dU1Nkc3pykvnompoim5d6ekioKpkCsRiv9feTzdmpKXLpmp4moapkCsRi9M/M8Jvau3cvsViMxSIajfLII4/wceuamiKbl3p6SKgqmQKxGK/195PN2akpuqamyOalnh4SqkqmQCxG8H89i16JAAIQgAAEgWOnCBw7CQhA0PvUMO/v6iahqCQnzjIfyckeQAACEIAABMmJsywGEgukMC+PXGx5ecxVYV4eudjy8sjFrNWSTbHBwHyYtVqyqS4oIJfqggKyMWu15FKYl0cutrw8flN9fX38/d//PYvF008/zdDQEB83s1ZLNtUFBeRSXVBANmatFrNWSzbVBQVks7rjDFcHwmSjsVqQ8/OZLaEk6P5eP8JYxHwInZFshLGIxUBigdTYbLis+YAKqIAKqDSX2ik2GJirGpsNlzUfUAEVUAGV5lI7xQYDuexwuQAVUAEVULHqtFzjcDAfO1wuQAVUQAVUrDotX62vx2XNB1RABVRApbnUzs5Vq9DJEqACKqACKjtcLnKpsdlwWfMBFVABFVBpLrVTbDBwOdxzzz288sorfNx+8Ytf8Md//McsBjtcLkAFVEAFVKw6LV+tr8dlzQdUQAVUQKW51M7OVavQyRKgAiqgAio7XC52uFyACqiACqhYdVq+Wl+Py5oPqIAKqBRMTnHbgJvyXXci5eWRqfSrX6bsjj8gUyxkQKq4gvmQV36GTCLPglRxBYuB3PoBFoAkBJsdZbiVEJ6wgl4jc63Tyb1N69BKEnMlCcFmRxluJYQnrKDXyFzrdHJv0zq0kkQutUVFaGWJPr+PuJqkrqiI3Rs2UWE2Mx+1RUVoZYk+v4+4mqSuqIjdGzbhtFjY7CjDrYTwhBX0GplrnU7ubVpHidFIXVERF/w+piMRio0GbqurZ/vSpeQiCcFmRxluJYQnrKDXyFzrdHJv0zq0ksRse/bsYT6i0Sg///nPycvL46qrrmKhqarKd7/7Xb75zW8Sj8eZr9bWVi6X2qIitLJEn99HXE1SV1TE7g2bcFosbHaU4VZCeMIKeo3MtU4n9zato8RopK6oiAt+H9ORCMVGA7fV1bN96VJqi4rQyhJ9fh9xNUldURG7N2zCabGw2VGGWwnhCSvoNTKPvtdJ9V+1kldRRn7zOkKd54h5JtGVl7L0z3ZRsvMLWDauRei0hLrOo8ZjWDatpfrv/hJdeSXzIRWvQkgaVP8gJBNIxavQNn8LYXGwGGhYQAZZg91owm40IgtBqdGETpaZL4OswW40YTcakYWg1GhCJ8t8GFkI7AYjdqMJUyxKicGIVacjRYnHef7cWY5edCMLwdWOcm5aWY0sBEOBGZ7p7KTX72OJwcDvVa9iY4kdWQh2Vq9iZ/UqMtny9Dy4sZlsbPo87AYjgViMJQYDdqORtDeGhnj5Qi+BWJTVhTZuq62j2GDAlqfnwY3NfJRUVeVP//RP6ezs5Mknn6SwsJCF4PF4uOOOO3j55Zf5qCjxOM+fO8vRi25kIbjaUc5NK6uRhWAoMMMznZ30+n0sMRj4vepVbCyxIwuB3WDEbjRhikUpMRix6nSk2PL0PLixmWwai4v5Qcu1ZJKFwG4wYjeaMMWilBiMWHU6UgyyBrvRhN1oxHWunzxnOVJeHinakmLyKhzEfTPoHHbynA5ShEYmr7IcfaWDuM9CntOB1lZISiIYQjn0AjrRBZKMXN6MvPpGEDLqzAjxUy+g+voRhiLk1V9AKm0CISPX/A5yze+wGMmtH2CBPPDeYfYPD+GNRJiORDgx4WEyrHBlaRnz8cB7h9k/PIQ3EmE6EuHEhIfJsMKVpWXk8mp/H0+cOM5kOMxMLEaf38+hsVG2VS7lz9vb2D88hDcSYToS4cSEh8mwwvJ8K3e9dYBev49gLMZFRWH/8BCrbTbKTWbmyh0KcddbB+j1+wjGYlxUFPYPD7HaZqPD4+GJE8eZDIeZicXo8/s5NDbKtsql6GSZS7Fnzx4+zLJly7jjjjtYv349Fy5cIBQKkenkyZM8+eST9Pb2Ul5ejsPh4KPw7rvvsnv3bm677TZOnz7N5dDa2ko2D7x3mP3DQ3gjEaYjEU5MeJgMKyzPt3LXWwfo9fsIxmJcVBT2Dw+x2majw+PhiRPHmQyHmYnF6PP7OTQ2yrbKpehkmbl6tb+PJ04cZzIcZiYWo8/v59DYKNsql/Ln7W3sHx5ix8Pfp/GlffgPHSE6fhFTXTWntt1EsPMcCf8M0ZExJl56Fcv6Bnxvv0fvtx4kOu4h7vUROtPN1GtvsOR3b6T7f36Lwb9+iZItWkTCT9LTCeFphHUp0Td2o/oGIBZCDU2SHDyEZFuJMJeymGlYIN3eaTo8HjLtGxjg1tp6rDodc9HtnabD4yHTvoEBbq2tx6rTkc0L3efI5A6F+MGpk3R4PGTaNzBAIqkSiMXI9LPuc2wssTNXr/RdIBCLkeln3ecYD4XI5A6FeGN4iM8vW87lsHTpUh555BFkWebTn/40XV1dfOc73yEWizGboij8+Mc/5sc//jEbNmxg27ZtrFmzhoaGBqqrq9FoNMxFLBbj7NmznD59mlOnTrFv3z46OjpYCN3eaTo8HjLtGxggkVQJxGJk+ln3OcZDITK5QyHeGB7i88uWM1cvdJ8jkzsU4genTtLh8fCpf3mTqvMDIAQpF194GTWRJO4PgBDMNvzXTxMZGgEhmC0yPEr/g4/iO9QGQtD91wNU31OFbJBI9O8HNQHxIAj+k8S5l5FKm1jMNCyQ0WCQXEaDAaw6G3MxGgySy2gwgFVnI5sJRSGbjgkPuXRMeMjGoyjMhzsUJBuPojChKGTjDoW4XA4cOMD111/Pz3/+cz7zmc/Q2NiIyWTij/7oj0gmk2Rz9OhRjh49SlpTUxPt7e1oNBouRSgUora2loGBAT4Oo8EguXRMeMjGoyhMKArZuEMh5mNCUcimY8JD1bk+Wv7lTTL5Dr5HNtHRcaKjbrLxHXyPNGU4zMBPRlh+h5OU5MXTZKOGJlnsJBZIdUEh2egkmSpLPnNVXVBINjpJpsqSTy4uq5Vsrq9cSjY6SWZrhZNsXPlW5sNlLSAbV74Vl9VKNq58K5fT66+/zpYtWxgcHMRkMnH99dfz1FNPcSkMBgPPP/88Go2GS2U0Gvn+97/Px6W6oJBsdJLM1gon2bjyrbisVrJx5VuZD5fVSjbXVy7lK3/1YzJJeXks+Z3PkI2pbhWm+tVkU7LzC8zmfX+G418/w9RRBanyKkAAAhCAAASioIrFTmKBOEwmdrhcIAABCEDALXW1GDQa5sphMrHD5QIBCEAAAm6pq8Wg0ZDLnfUN6GQZBCAAAY1Litm5ajU7XC4QgAAEIOCWulp2Vq/CabGAAAQgwKzTcmtdHfOxY7kLp8UCAhCAALNOy611ddxZ34BOlkEAAhDQuKSYlooKLreuri4+97nPkZ+fT3l5OeFwmIceeoj/yuc//3nq6+uZqxtuuIEvfvGLfBwcJhM7XC4QgAAEIOCWulp2Vq/CabGAAAQgwKzTcmtdHXfWN6CTZRCAAAQ0LimmpaKC+bizvgGdLIMABCCgcUkxv1+9irLb/wAQgAAEIKh84FuU33MHhpXLAQEIQKCx5lP5wD1UPfQnSHl6QAACEORv3kTFPXdQdvsfAAIQgAAELPsSmtVfQFgc/CdaE5r6nSx2cusHWCAbS+w4TCZGAgHKTCbuaVrHdRWVpCnxOD0+LzpZRi/LzDahKAwHA1h0OmQhkbKxxI7DZGIkEKDMZOKepnVcV1FJmhKP0+PzopNl9LJMSqnRSLO9FJ0ssURv4IaqKu5a04QsBBtL7DjNFrSyxKqCQr5SU8d1FZVoJYltzkpUVcWthNhS5uA76zfhMJlJm1AUhoMBLDodspBIS6gqfX4//liUgrw8UrSSxDZnJaqq4lZCbClz8J31m3CYzJQajTTbS9HJEkv0Bm6oquKuNU3IQnCp9uzZw6W6ePEiFouFa665hhUrVrB9+3bGx8c5duwYuezatYumpibmY3R0lH/7t3/jo9Ta2ko2G0vsOM0WtLLEqoJCvlJTx3UVlWgliW3OSvSyjEWrY5Pdzq6m9ThMZkqNRprtpehkiSV6AzdUVXHXmiZkIZiPUqORZnspOlliid7Ab5dXcFdDE5IsU3DtVRhWLkPS6zCvXUPl7m+y5IufRdJpWXLT5yGZJDI8iu2GrVT/8C/RL6skz1lO4aevQdLryHPYsX/5iyz7i90IjUzBtVehX+Yk3DeAvqoC11+1suSLnwVJg7z0twAVlAnk8k1om7+JMJey2GlYQF3TUzx39gzuUIiUZ7tOU2o04jRb+OWFHp4900k0mSBle2UVdzeuJZpIsPfYEdrc46SYtVq+2bCWlvIKuqaneO7sGdyhECnPdp2m1GjEabbwyws9PHumk2gyQcr2yirublyLLAQuq5WvWRvIpqW8gpbyCjL9arCfly/0Ek0meH1oAFkI7m5cSzSRYO+xI7S5x0kxa7V8s2EtLeUVdE1PsffYEdyhECkuq5Xd6zfhNFv41WA/L1/oJZpM8PrQALIQ3N24FlkIXFYrX7M2sFAeeugh7rzzToqKinjuuee46aabqK6u5h//8R9pb28nzWazceONN/K5z32O+aqtreXj1FJeQUt5BZkMGg07q1eTjctq5WvWBi4Xl9XK16wNZFN843aKb9xOpov/8EvGnn6BZCSC5xf/gtBoWP7YgwiNjKl+Nab61WSaOXaSoUf/lsjQKCmDe/+GvEoHhhXL8PzinzBJryHrEiQG3gYho1l7KwiZxUxu/QALQInH2XX4bTyKQtp0JELn1CR2o4nHjh8loaqk9fi8aCWJAyPDvDU6TFo0meTw+CjrS+w8dLQNj6KQNh2J0Dk1id1o4rHjR0moKmk9Pi9aSWJNUTFz1X7RzWPHj5JQVdJ6fF60ksSBkWHeGh0mLZpMcnh8lPUldh462oZHUUibjkTonJrEbjTx2PGjJFSVtB6fF60ksaaomN/Unj17mItoNEosFmPbtm00NTWxbNkyTCYTjY2N/MVf/AU33ngje/fu5etf/zqFhYU0NjYyXzqdju9973t8lFpbW/nvxLv/HXru+g7q/2UPXsDjrutE/78/v9/cZ5JMLpOZ3Jq006ZNmqYNaUktVG5eqLJq2QURVlTKukURXFALAmtFi7IedUWOgAi6KHuRPehZdVEBqRZKS4GQNm3aNOk1bTKZXCaXuWRmfvP9M+d5Zp/5zzMjNlsH3N3XyzDICO87iJhNlL6tk3yMcIT9H7iO+KkRMhKj48y81I21vpb+j9/O3HCU8tVlpKnQMUQzoVW18FamUSR7x8cYi0bJNTg1xY8O9ZHPjuFTPD98ilyGUjzYu5exaJRcg1NT/OhQH/nsGD7FfOw4fYp8dgyf4vnhU+QylOLB3r2MRaPkGpya4keH+shnx/Apzgafz8eZ+vrXv84zzzxDRnNzM+3t7TQ2NvLSSy+RTCYRERYsWMB/hsfj4Y/J5/PxX834z58mn4lfPEMh0ztfJj4cIFe49xBDX3+QtFDPDK9+4gCIgAjG6Zd4q9MoEkOlQAABBBBAAIGokQQBBBBAAIF4KoWBAgEEEEAAgaiRBAEEEEAAAQSiRhIEEEAAAQTiqRTzEU8ZIIAAAgggEE+lMFAggAACCCAQNZIggAACCCCAQNRIggACCCCAQDyV4mzo6OjgTCmluPbaa9m/fz9pNpuNxsZG0j772c/S0NCAz+ejra2Nt7KOjg7+q0nNxUEAAQQQQCA1F6cQZSRBAAEEEEAAASMSAQEEEJjaO8P/k0rwVqdRJMsrqnCZzeTyOhx8cHEz+XR5faz2eMlnU0sbLrOZXF6Hgw8ubiafLq+P+VjrrSGfLq+P1R4v+WxqacNlNpPL63DwwcXN5NPl9XE2rFq1ivkYHh5mxYoVvOc97+HZZ58lFouRKxwO81a2atUq/qspf+fbUQgKQSEoBIXgfsfbKaTk3HPQS0tRCApBISgES0MdtTdeh0JQCAph4MGTvHbrIaRyFW91JoqkzGJhS8ca7u3ew2wiQVqVzc7nzzmXlvIK+qdC/OTIABkdVdV8uLmFqJHkdHiWwekp0nQRrmtpo8vrY0vHGu7t3sNsIkFalc3O5885l5byCvqnQvzkyAAZHVXVfLi5hfm4sK6evtAEPzkyQEZHVTUfbm4haiQ5HZ5lcHqKNF2E61ra6PL62NKxhnu79zCbSJBWZbPz+XPOpaW8gv6pED85MkBGR1U1H25u4Wzo6OhgvpRSPPXUUzz11FOkud1ufD4fiUSCyclJJicnCYfD2O123oo6Ojr4r6bqA5cy8+o+hh9+nIyy9V00fGYzhZgr3Cy5fxuHb7yD5PQMaZYaL80PfJWSznZmew4w/PDjZLhWr0Zf+ue81Zkooi6vjy0da3ikrxe7ycTm5e20lFeQdsPydt7ftIj+UIhap5NmdzlpdpOJ+99+MX2TE0zOxWgpr6DKZiety+tjS8caHunrxW4ysXl5Oy3lFaR9vHUFLpOZp04co8NTzQ3L27GbTLyRvskJdgdGsOga63y1NJWUkvbx1hW4TGaeOnGMDk81Nyxvx24yYTeZuP/tF9M3OcHkXIyW8gqqbHbSurw+tnSs4ZG+XuwmE5uXt9NSXkHax1tX4DKZeerEMTo81dywvB27ycQb6ZucYHdgBIuusc5XS1NJKbm6urowmUwkk0n+s0KhEKFQiGypVIq3IpPJRFdXF2fbWCzK706fYiwWpa2iknW+WjL6JifYHRjBomus89XSVFJKmqEU20+dZHB6Cq/dwSX1C3CZzaTFhwOM//wZ5k4HKO3qoOLSi8iYeWUvk0//Ds1mpeLSi3AsW0zawrs/S83HrmK2Zz+2hQtwrWzljZS/8+10vPgzZl7qRnSd0nWr0Z0O0hbe/VlqPnYVsz37sS1cgGtlK3+I1MQAqUA3opnRalYjpfUUk6jXUSRPDB7m4b59ZOgibOlYw4W19czHE4OHebhvHxm6CFs61rC+po7bdj1Pz3iQDK/DwTfXXUCVzU4hTwwe5uG+fWToImzpWMP6mjpu2/U8PeNBMrwOB99cdwFVNjuFPDF4mIf79pGhi7ClYw3ra+q4bdfz9IwHyfA6HHxz3QVU2ewU8sTgYR7u20eGLsKWjjVcWFtPrq1bt/LFL36RP4aZmRlcLhfzEYvFsNvt/DF84QtfYOvWrZxNg9NT3LZrB1PxOBkX1zVwW8canhg8zMN9+8jQRdjSsYb1NXXctut5esaDZHQOT/LFyy4jMRHiwAc3k5gIkeG5/D0suX8bpx94jGNf+iYZYtJZ8u1tVL3/3bwVGAO/INn7T/wH0TF3bkarfxvFolEkY7Eojx7sJZuhFPft6yaeMjhTY7Eojx7sJZuhFPft6+aJwX56xoNkC0QifK+vl0LGYlEePdhLNkMp7tvXzROD/fSMB8kWiET4Xl8vhYzFojx6sJdshlLct6+bJwb76RkPki0QifC9vl4KGYtFefRgL9kMpbhvXzfxlEGuO++8k87OTv4YUqkUbzWdnZ3ceeednG3/u/c1puJxsv3m1En+77FBHj3YSzZDKe7b180Tg/30jAfJsEVivPOrD3N8230cveNeEhMhsgWf/HeGv//PHP/KfWRTSYMjW7aRmovzZlPRCZL7f8z/jzJI9HwfjATFolEkfZMTGCoFKEABClDMJuIcm5nmTPVNTmCoFKAABShAMZuI84sTRwAFKEABClAcDE1QSN/kBIZKAQpQgAIUs4k4vzhxBFCAAhSgAMXB0ASF9E1OYKgUoAAFKEAxm4jzixNHAAUoQAEKUBwMTVBI3+QEhkoBClCAAhSziTjHZqbJZTKZeOyxx7DZbJxtqVSKtxKbzcZjjz2GyWTibOubHAcUoAAFKEDxr0f6MVQKUIACFKCYTcT5xYkjgAIUF/7st9z26f+FLRpn5tVeZl7dBwgggAACCKcf/BEqmQIEEEAAITk9S+TgAG82NTkApEAEREAERCAZRc0MUSwaRVJutVJIhdXGmSq3WimkuaycfFwmM4WUW60U0lxWTj4uk5lCyq1WCmkuKycfl8lMIeVWK4VUWG3k09raykMPPYTNZuNsMgyDtwqbzcZDDz1Ea2srfwwus4V8msvKKaS5rJyMC3++AwQQMLlLMJWVgAACCCCAgGtlCwgggAACCCBgqa7kTWd1U5C1jGLRKJKW8kr8pW5ydVX7qLLZOVMt5ZX4S93k6qr2cfWSZVg0nVwbFy2mkJbySvylbnJ1Vfu4eskyLJpOro2LFlNIS3kl/lI3ubqqfVy9ZBkWTSfXxkWLKaSlvBJ/qZtcXdU+qmx2Crn22mt55ZVX6Ozs5GwxDIO3gs7OTl555RWuvfZa/lg2LlxMrjKLlY+3tOMvdZOrq9rH1UuWYdF0bJEY2Wo2XU3N9VeTy1zhpumuv8G5fCm5yi9Zj6XGy5tNq/CjlTUigAACCKB7VyH2CopF3/o6ikATYZ2vlkA0QnAuis2kc3HdAm5p78SsaZwpTYR1vloC0QjBuSg2k87FdQu4pb2TaruD5RWVHJmZYjIeo8pu5/qWFVza0EQhmgjrfLUEohGCc1FsJp2L6xZwS3sn1XYHyysqOTIzxWQ8RpXdzvUtK7i0oYlCNBHW+WoJRCME56LYTDoX1y3glvZOqu0OlldUcmRmisl4jCq7netbVnBpQxOFaCKs89USiEYIzkWxmXQurlvALe2dmDWN38fj8XDdddehaRovvPACqVSK+aquruauu+5C0zTmw2Qy8Y1vfIN4PM58mUwm7rrrLh577DG8Xi9/TK0VlZh1jaMz0yRViuUVVXz+nHNpcJWwzldLIBohOBfFZtK5uG4Bt7R3Um13cJ4yse7L3yURHMdS46PxzpvwXvV+SlavRLOYifQNoBJJSlevpPk7X8G+eCGV776IuaFh4qcD6HY7nsvfg/9/3YVmMfOmEw2tphMiY6joBOhWtIbzMK3aBJqJYjFRRHbdhNfhwGt3oIuGz+HEouu8kWdPneAnRweYTSZY5q7g+mVtVNnsVFht3NW5lnxWVnp4YP0lnIkKq427OteST4XVhtfuYDYRx2N34HU4yXj21Al+cnSA2WSCZe4Krl/WRpXNToXVxl2da8mnwmrDa3cwm4jjsTvwOpxkPHvqBD85OsBsMsEydwXXL2ujymbHrpvwOhx47Q500fA5nFh0nT+EyWRi69atXHfddezevZvu7m5ee+01uru7GRkZ4Y1omobb7ebLX/4yuq7zn/GlL32Je+65h2AwiFKKN+Lz+ejo6GDVqlV0dHTQ1dXFggULOFPRZJIfHj7Ay8EAumisr6njg/6l6CIUoovgtTvw2h04zWaq7Q7KLFbSKqw27upcSz7VmolofQ3J6RmsNdXY6mtJE5OOtb4Wa0Mt+tQM1voazBVu0jSnHWt9DdaGGkQ3YW2oQbNaSYsOHOP4Pd8mfKAfa0019Tdtwn3ROv4Ygv/n3xl+5J9ITs1Qck4bjZ//FJYaL4gVcVQhjirQNMRRBbqZYhL1Oopky+4ddI+Nku3ShiZuae+kkJ8fP8J9vd1k89odPLD+HbjMZoohEI1ww45nmE0kyLbt3PMJRMLc19tNNq/dwQPr34HLbCafQDTCDTueYTaRINu2c88nEAlzX2832bx2Bw+sfwdfenUX3WOjZLu0oYlb2jv5H29sy+4ddI+Nku3ShiZuae+kkJ8fP8J9vd1k89odPLD+HbjMZvKZO3manndfTXJ6hmytP/o2sZOnOXL7V8hmbahl5a/+kUMf/xxTz79ENu+HPkD9TZvoeffVJKdnyNb6o2/jvnAdZ9PID/+VI7d/hWzWhlpW/uofOfTxz7Fo4zS6XSdDW3ABplWbKBZ96+sogv6pSR492EuugekQ72vyY9NN5LP1lReJJJNkCycTVNnsLHNXUAz/ONDHa+NBco1GI7wYGCaSTJItnExQZbOzzF1BPv840Mdr40FyjUYjvBgYJpJMki2cTDAxF+OFkdPkGpgO8b4mPzbdxP8orH9qkkcP9pJrYDrE+5r82HQT+Wx95UUiySTZwskEVTY7y9wV5DN03yNM7XwZEEAAAYS5oWEmnv4dxmwEEEAAwZieJTE6zsQvtwMCCCCAEO49hDE9w0x3LyCAAAIIc0PDVH/wfZxNB6//DMZsBBBAAMGYniUxOs7EL7czfSBMxeoyNLMGCGrqOPrCd4BupRg0iuR0eJZCTkfCFDIWi5JPIBqmWAKRCPkEoxHGYlHyCUTDFBKIRMgnGI0wFouST/fYKIWcjoT5H7/f6fAshZyOhClkLBYln0A0TCFzJ0+Tz9zwKPHhUfIJPf8ShYSef4l85oZHOdviw6PkE3r+JdIiQzGOPnaKbCo8SrFoFEmzuxxEgSgQBaJAFBZdo6mklEL8ZWUgCkSBKBAFovCXuikWf1kZiAJRIApEgSj8ZWX4y8pAFIgCUSAKROEvdVOIv6wMRIEoEAWiQBT+sjL8ZWUgCkSBKBAFotiwoAlEgSgQBaJAFBZdo6mklP/x+zW7y0EUiAJRIApEYdE1mkpKKcRfVgaiQBSIAlEgCn+pm0Kcy5eSj7N1Cc7lzeTj/dAHyEezWvBs3EA+ztYlnG3O5c3k4/3QB8gI9czw8if2M747BLoZKamjWDSKpNbhYmPTEnJdt7QNu26ikM0tK7FoOtlWVnq4sLaBYtm4cAkNrhKyucxmNi1dweaWlVg0nWwrKz1cWNtAIRsXLqHBVUI2l9nMpqUr2NyyEoumk21lpYerF7ewsWkJua5b2oZdN/E/fr9ah4uNTUvIdd3SNuy6iUI2t6zEoulkW1np4cLaBgqpuf5D2JcsBBEQARFMZaU03v4pmrbeimazggiIgAhl61ZTf9Mmaq7/EIiACIiACI23f4r6mzdhX7IQREAERDCVldJ4+6c425q23opms4IIiIAIZetWU3/TJmqu/xCIgAiIcPSx0+gtV4LJRrHoW19Hkazx+Kh1uBiKzFDjcPI3Kzp5R10jv4/P4aSrugazplNls/OehkXcuLwDXYQ3EjWSDEyHsGgaNt3EH8JQiqMzU0zH47itVtLMmsa76ptIoQhEI5znq+OOji5qnS58Didd1TWYNZ0qm533NCzixuUd6CKkGUpxdGaK6Xgct9VKmlnTeFd9E1Zdp8RsYY2nhs+0r6bW6cLncNJVXYNZ06my2XlPwyJuXN6BLsIaj496ZwkWTWepu4KPLW3jHXWN/GcYSnF0ZorpeBy31cpbjaEUR2emmI7HcVutZIsaSQamQ1g0DZtu4o2s8fiodbgYisxQ43DyNys6eUddIxlRI8nAdAiLpmHTTaT5HE66qmuYis8RM1J80L+Um9s60UUoRLOYqb7iMnS7DZO7lPKLzmPx1/8WW1MDtoZayi9ZT3IiRCoao/4TH2HRV25HTDrlF67D1tRA7OgJbI31LP67O/FcvgHNYqb6issgpZgbGqZyw0U0f+cebE0NZMSHR4kePYHJXYaYdDJU0iDSN0ByMoS5qoJsRjhCuPcgmtWKbreRZmuopfyS9SQnQqSiMeo/8REWfeV2xKRTfuE6bE0NxI6ewNZYz+K/uxNHx4UUk4ki6gtN8P3+/QSiYdIeOdSLz+6kwVXC7+MvdfOJVjdn4smjh3nkUC/xlEHahoaF3Nx2DroIhfSFJtjWvZtANEyav9TNHau6aHCV8NSJo/zk6ADxlMGvh46ji8bNbeegi+AvdfOJVje5+kITbOveTSAaJs1f6uaOVV00uEqw6yauWdxCPv5SN59odZPPRbUNXFTbwNnQF5pgW/duAtEwaf5SN3es6qLBVcJbQV9ogm3duwlEw6T5S93csaqLBlcJTx49zCOHeomnDNI2NCzk5rZz0EUopC80wff79xOIhkl75FAvPruTBlcJTx49zCOHeomnDNI2NCzk5rZziKcMvt+/n92jw6T9y5FDeO1OLqpt4PfRnQ7qb9pELiMc4cTXHmDy2edJO/Wdx7A21FL1vncx8+o+TnztAeaGhkk7/tX7sdbXYF/cxOg//V+GH/knUnNxRp/4OaLrLPrK7aTm5uj/5B1MPvs8aabSEhZ95Taq3vcuZl7dR/8n72BuaJg05/Jmmu/fhn1xE8Pf+yeOf/V+UnNx0rxXvZ9FX7md1NwcJ772AJPPPk/aqe88hrWhlqr3vYuZV/dx4msPMDc0TNrxr96Ptb4G++ImikXf+jqKIGokuXXXdkZjETIm52L0To5z2YJFnE17giPc27MHQykyBqZDmDSN9goP+USNJLfu2s5oLELG5FyM3slxvHYH9/bswVCKjIHpECZNo73CQz5RI8mtu7YzGouQMTkXo3dynMsWLOLNFjWS3LprO6OxCBmTczF6J8e5bMEi3mxRI8mtu7YzGouQMTkXo3dyHK/dwb09ezCUImNgOoRJ02iv8JBP1Ehy667tjMYiZEzOxeidHMdrd3Bvzx4MpcgYmA5h0jS2Dw+xffgkGfFUip2B05zvq8dttXKmjt5xL2M/ewYQQEjNxZn49W9xv30thzbfTvx0ABBASAQnmHm5B1t9DYdv/gLKSAECCOHeQ2gWM+P/9mvGfvYMIICQmosz8evf4n77Wg5tvp346QAggJAITjDzcg+2+hoO3/wFlJECBBDCvYfQLGbG/+3XjP3sGUAAITUXZ+LXv8X99rUc2nw78dMBQAAhEZxg5uUefH95OcWiUSQ940GCsSi5BqdDHJuZ5mzaMXKKfHaMnKKQnvEgwViUXIPTIX54+AD57Bg5RSE940GCsSi5BqdDHJuZ5s3WMx4kGIuSa3A6xLGZad5sPeNBgrEouQanQ/zw8AHy2TFyikJ6xoMEY1FyDU6H+OHhA+SzY+QUO0aGyGUOx0j+88+Yj/GnngMBBBBAQBkGx+7+BvGRURBAAAEEwgf6Ofn3D4MAAggggMD4U79h/KnnQAABBBBQhsGxu79BfGQUBBBAAIHwgX5O/v3DIIAAAgggMP7Ubxh/6jkQQAABBJRhcOzubxAfGQUBBBBAIHygn8ihQYpFo0gMpUAAAQQQQAABQ6U4m+IpAwQQQAABBOIpg0IMpUAAAQQQQACBaCoJAggggAAC8ZRBIYZSIIAAAggggIChUrzZDKVAAAEEEEAAAUOleLMZSoEAAggggAAC0VQSBBBAAAEE4imDQgylQAABBBBAAIFoKgkCCCCAAALxlIGhFAgggAACG//h37GEppkPZRjkY4SjFGKEo+STisVRhkE+RjhKIUY4Sj6pWBxlGORjhKMUopIGxaJRJG3llbjMZnJ57U6aSso4m7qqa8inq7qGQtrKK3GZzeTy2p1ctWgZ+XRV11BIW3klLrOZXF67k6aSMt5sbeWVuMxmcnntTppKyniztZVX4jKbyeW1O7lq0TLy6aquoZC28kpcZjO5vHYnVy1aRj5d1TWs9njJ9sW//hrLegYov2Q98+G+YC0ggAACCCA03vZJTKWlgAACCCBY62upu+FaQAABBBBAKL/kfNwXrAUEEEAAAYTG2z6JqbQUEEAAAQRrfS11N1wLCCCAAAII5Zecj/uCtYAAAggggNB42ycxlZYCAggggGCtr8Wx1E+x6FtfRxHYdBNNrjL2jI0QT6VI89js3Nmxlmq7g7NpYUkZs8kEB0MTZHRUVvPptnMwaxr52HQTTa4y9oyNEE+lSPPY7NzZsZZzPT5mkwkOhibI6Kis5tNt52DWNPKx6SaaXGXsGRshnkqR5rHZubNjLdV2B282m26iyVXGnrER4qkUaR6bnTs71lJtd/Bms+kmmlxl7BkbIZ5Kkeax2bmzYy3nenzMJhMcDE2Q0VFZzafbzsGsaeRj0000ucrYMzZCPJUizWOzc2fHWs71+JhNJjgYmiCjo7KaT7edwzmVXrrHR5mci2GLzPH237xM0+c/RdVl72A+yro6mHphD4mxcRAQs07T5z9F9RWX4Vi6iND2F0nF4yBgqa1m6Xfuofzi80hOzzD72n4QQKDs/DX477kN9/pzmXphD4mxcRAQs07T5z9F9RWX4Vi6iND2F0nF4yBgqa1m6Xfuofzi80hOzzD72n4QQKDs/DX477kN9/pzmXphD4mxcRAQs07T5z9F9RWX4Vi6iND2F0nF4yBgqa1m6XfuwVrno1hEvY4i2jU6zCP9+7DrJm5oWUWLu4I3EoxF2TEyRDAWpa28ivO8tbwRQykeH+jjl0NH6ais5oaWVbjMZtKCsSg7RoYIxqK0lVdxnreWjKn4HL2T4+girKz0YNdNZJyOzHJoapI6h4vmsnIygrEoO0aGCMaitJVXcZ63loyp+By9k+PoIqys9GDXTfwxGEqxffgkA9MhfHYHl9Q24jKbeSNT8Tl6J8fRRVhZ6cGum0gzlGL78EkGpkP47A4uqW3EZTaTFoxF2TEyRDAWpa28ivO8tWT0hSbYNTqMRdc4r7qOppJS3kgwFmXHyBDBWJS28irO89aSMRWfo3dyHF2ElZUe7LqJjNORWQ5NTVLncNFcVs4fYio+R+/kOLoIKys92HUTaYZSPD7Qxy+HjtJRWc0NLatwmc2kBaJhHjq4l2X/+19Yv/48aj5yBW9EJQ3GfvZrwvsPY22owbPxUkylJaSppMFMdy+J4DglHW1YaqrJSEyEmNnTg5h0Std2ojvtpKmkwdC3HyXwL/+G+7w1NH3hbzCVlpCmkgYz3b0kguOUdLRhqakmY/LZ5zl+73fQHXaavvA3lHS0kRE7NsTs3j5sTfW42lvIUEmDme5eEsFxSjrasNRUk5GYCDGzpwcx6ZSu7UR32ikmUa+jSJ442s93D+4lQxdhy8pzuaimgUIGp0Ns2bODqfgcGZfULuC2ledSiKEUW176HT0TQTK8diffXHsh0/E5tuzZwVR8joxLahdw28pzmY/B6RBb9uxgKj5HxiW1C7ht5bkUi6EUW176HT0TQTK8diffXHshHpudM2UoxZaXfkfPRJAMr93JN9deyHR8ji17djAVnyPjktoF3LbyXJ442s93D+4lQxdhy8pzuaimgUIGp0Ns2bODqfgcGZfULuC2ledSLIZSbHnpd/RMBMnw2p18c+2FTMfn+PpPn+Qv7/ouGZ4PvJsl3/oihaikwYFrPsXUrlfJsNbXsOJfH8JSU82ZUkmDA9d8iqldr5Jhra9hxb8+hKWmmkJOf/dxjm37Nhli0lnyza1Uve+d/KnSt76OIgjGotz16vMoFAggoFB0TwS4vGkJumjk86XXXuRkeBoEEEDg6OwU/hI3C1yl5PPT4wP8fGgQBBBAIJyME4rHeG74JCfD0yCAAAJHZ6fwl7hZ4CrlTH3ptRc5GZ4GAQQQODo7hb/EzQJXKcXw0+MD/HxoEAQQQCCcjBOKxzjfW8+Z+unxAX4+NAgCCCAQTsYJxWM8N3ySk+FpEEAAgaOzU5RZrHz3UA8KBQIIKBTdEwEub1qCLhr5fOm1FzkZngYBBBA4OjuFv8TNAlcpxfDT4wP8fGgQBBBAIJyME4rHeG74JBvuehBbdI6MyMFBnK1LsC9uIp+R7/+Ykcd/QjZjepbE2ASVGy7iTI18/8eMPP4TshnTsyTGJqjccBH5xIdH6dv0GUgp/kNKMfXCy9Rsugox6fwp0iiSvtA4hlLkmk0kODYzTSF9oXHy6Z0co5DeyTHy6QtN0BcaJ5/eyTHmoy80Tj69k2MUS+/kGPn0hSaYj97JMfLpC03QFxonnyeO9mMoRa7ZRIJjM9MU0hcaJ5/eyTGKpXdyjHz6QhOUPfkM7okZEAEREAERpl/eSyHTL+8FERABERABEWZ6DjAf0y/vBREQAREQARFmeg5QyEx3L8pIgQiIgAiIkJyZJXJokD9VGkVSYbVRSLnVRiEus4V8PDYHhVTZ7OTjMptxmS3k47E5mA+X2UI+HpuDYqmy2cnHZTYzH1U2O/m4zGZcZgv5NJeWU0i51UYhLrOFfDw2B8VSZbOTT+NEmPc+/Sr5WGuqKcRSU00+ptIS5sNSU00+ptISCjF7KinE4qnkT5VGkbS4K/GXusnV5anBY7NTyMbGJeQqs1hZ76unkHfXNWHRdHJd3riEjY1LyFVmsbLeV898bGxcQq4yi5X1vnqK5d11TVg0nVyXNy5hPt5d14RF08l1eeMSNjYuIVeZxcpfL2vHX+omV5enBo/NTiEbG5eQq8xiZb2vnmJ5d10TFk0nmy0yx19byqn52JXkMle4qdxwEYVU/8V70awWctV87Ermo/ov3otmtZCr5mNXUkhJRxvO1iXkKr/4PCw11fyp0re+jiLQRFhXXUcgGiEYi2Az6VxS28gtK1Zj1jQKWV5ehUnTODo7RTKVYnl5FXesXEu9s4RCKqw22sqrGJwJMTkXw2Oz81dL27m0fiHLy6swaRpHZ6dIplIsL6/ijpVrqXeWMB/Ly6swaRpHZ6dIplIsL6/ijpVrqXeWUCwVVhtt5VUMzoSYnIvhsdn5q6XtXFq/kPmosNpoK69icCbE5FwMj83OXy1t59L6hSwvr8KkaRydnSKZSrG8vIo7Vq6lwVXKuuo6AtEIwVgEm0nnktpGblmxGrOmUcjy8ipMmsbR2SmSqRTLy6u4Y+Va6p0lFEuF1UZbeRWDMyEm52K8+5VB7nTVUPvn76FkdTuaxUzk4BFUIklpZzvN374b+6IFFGLxVFKyZiWRvgESYxNYarw03v5JvFf+GfNh8VRSsmYlkb4BEmMTWGq8NN7+SbxX/hmFiKZR+a63M3dqmPjpUXSHDc/GS/Hf+3k0s5k/VSaKyG4y4bU78Nqd6JrgtTuxaDq/jy7CNf4WrvG3cCYqrDa8NgeziQQemx2v3UmaLoLP7sBrd+A0mfHaHZRarKRFjSSPHd7Py2MBdE1Y763nqkXL0EU4GZ7he4f2Mjgzhcdm52p/C2uqfOgi+OwOvHYHTpMZr91BqcVKWtRI8tjh/bw8FkDXhPXeeq5atAxdhJPhGb53aC+DM1N4bHau9rewpspH2rOnj/Pk8cPMJhK0uCvY1NyOx2YnaiR57PB+Xh4LoGvCem89Vy1ahi5ChdWG1+ZgNpHAY7PjtTvJePb0cZ48fpjZRIIWdwWbmtvx2OxEjSSPHd7Py2MBdE1Y763nqkXL0EVYWeHhwXXvJJcuwjX+Fq7xt5CrwmrjbzveRj4nwzN879BeBmem8NjsXO1vYU2VD12Ea/wtXONvIVfUSPLY4f28PBZA14T13nquWrQMXYST4Rm+d2gvgzNTeGx2rva3sKbKR9qzp4/z5PHDzCYStLgr2NTcjsdmJ2okeezwfl4eC6BrwnpvPVctWoYuwsoKDw+ueyf/z6X8B9F16m/8KPU3fpRcRiTKyb//HqHf7kZMOpUbLqLuhg8juo7FU4m1zkdyeharrxpbfQ3/GRZPJdY6H8npWay+amz1NbwRs6eSpd+5h3yig8c5fu93CPcNYPVVU3/jR3BfsJa04E9/xfCj/0JyepaSjuU0brkBi68aIxLl5N9/j9BvdyMmncoNF1F3w4cRXadYRL2OIvncy7+le3yUbBvqF3LL8tWcTYFomM07n2Y2mSDbPZ3rCUTDfOvAq2Tz2p08uO6d3P3aTrrHR8m2oX4h1yxqYfPOp5lNJsh2T+d6AtEw3zrwKtm8dicPrnsnd7+2k+7xUbJtqF/INYta2LzzaWaTCbLd07meQDTMtw68Sjav3cmD697J3a/tpHt8lGwb6hdyzaIWNu98mtlkgmz3dK4nEA3zrQOvks1rd/Lgundy92s76R4fJduG+oXcsnw1Z1MgGmbzzqeZTSbIdk/netZU+Sjkcy//lu7xUbJtqF/INYta2LzzaWaTCbLd07meQDTMtw68Sjav3cmD697J3a/tpHt8lGwb6hdyy/LVzMf+v7yZqRdeJpv3g5dRf+NH6XnvR0lOz5Kt9Qdfx33BWs7U3NAwPe/9KMnpWbK1/uDruC9Yy5maGxqm570fJTk9S7bWH3yd2NAIR+78Gtms9TWs/MUPOPSJO5h64WWyeT94Gf6v3k6x6FtfRxH0T0/ySP8+cg1Mh3j/gsXYdBNny+NH+nhtIkiuQCzCruBpIskk2cLJBJNzMV4YPUWugekQs4kEfVMT5ArEIuwKniaSTJItnEwwORfjhdFT5BqYDjGbSNA3NUGuQCzCruBpIskk2cLJBJNzMV4YPUWugekQs4kEfVMT5ArEIuwKniaSTJItnEwwORfjhdFT5BqYDvH+BYux6SbOlseP9PHaRJBcgViES+sWkk//9CSP9O8j18B0iNlEgr6pCXIFYhF2BU8TSSbJFk4mmJyL8cLoKXINTId4/4LF2HQTZ2J230FO/N2D5Arv78eYnmHmtQPkmhsaofrKyzhTQ/f/A1MvvkquuaERqq+8jDM1dP8/MPXiq+SaGxph4pkXMGbDZDOmZ0kEx5n41e/IFd7fj+8jf4Fut1EMGkVyKjxLIacjs5xNgWiEfIKxKMFYlHy6JwIU0j0RIJ9gLEowFiWf7okAhXRPBMgnGIsSjEXJp3siQCHdEwHyCcaiBGNR8umeCFDI6cgsZ1MgGiGfYCxKIafCsxTSPREgn2AsSjAWJZ/uiQCFnI7McqZix4ZAAAEEEEAAgdDOV0AAAQQQQGAuEGQ+5oaGQQABBBBAYC4QZD7mhoZBAAEEEEBgLhAkHhgFAQQQQACB0M5XQAABBBBAAIHYsSGKRaNIlpaVAwpQgAIUoLBoGk0lZZxN/pIyQAEKUIACFP6SMvwlZYACFKAABSgurVsIKEABClCAwqJpXFyzAFCAAhSgAIW/pAx/SRmgAAUoQAGKS+sWAgpQgAIUoLBoGhfXLAAUoAAFKEDhLynDX1IGKEABClCA4tK6hYACFKAABSgsmsbFNQsABShAAQpQ+EvK8JeUAQpQgAIUoLi0biGgAAUoQAEKi6bRVFLG2eQvKQMUoAAFKEDhLymjkKVl5YACFKAABSgsmsbFNQsABShAAQpQ+EvK8JeUAQpQgAIUoLi0biGgAAUoQAEKi6ax2ObkTLnalwECCCCAAIJmteL5wLsAAQQQQADB2bKE+XC2NgMCCCCAAIKzZQnz4WxtBgQQQAABBGfLEpytzYAAAggggOD94J8BAggggACCZrXiWLqIYtEoklqHi42NS8i1qXkFdt3E2XR5UzMNzhKyuUxmrm9u54Zlq7BoOtlWVlRzjb+VjY1LyLWpeQXX+FtpcJaQzWUyc31zOzcsW4VF08m2sqKaa/ytbGxcQq5NzSu4xt9Kg7OEbC6Tmeub27lh2Sosmk62lRXVXONvZWPjEnJtal7BNf5WGpwlZHOZzFzf3M4Ny1Zh0XSyrayo5hp/Kxsbl5BrU/MK7LqJs+nypmYanCVkc5nMXN/cTiG1DhcbG5eQa1PzCq7xt9LgLCGby2Tm+uZ2bli2Coumk21lRTXX+FvZ2LiEXJuaV2C22ThTtsZ6aj52BbkaP7uZ+hs/it3fSDZTqYvGz21mPmquuxK7v5FsplIXjZ/bzHzUXHcldn8j2UylLho/t5mmO29Cs1rIVra2g/obP0LNx64gV+NnN6M77BSLqNdRRM8OH+efjx7Erpv4sH85a6p8/CGCsSiT8ShNrjIsms4biRpJnjzez+BMCK/dyQcaFuO1O0kbnAnx+JED9E9Pclm9nyualqKLkPbcyAl2B4exaBrrvQ2sqfKRFjWSPH7kAL8ZPk5HhZdr/cvx2p2kDc6EePzIAfqnJ7ms3s8VTUvRRUh7dvg4/3z0IHbdxIf9y1lT5SMtaiR5/MgBfjN8nI4KL9f6l+O1O0kbnAnxq1NHGZuL0uau4v0LlqCLkPbcyAl2B4exaBrrvQ2sqfKRFjWSPHm8n8GZEF67kw80LMZrd5I2OBPiV6eOMjYXpc1dxfsXLEEXIe3Z4eP889GD2HUTH/YvZ02Vj4yokeTY7BS1DhdlZit/CEMpjs1OoYvQ5CojI2okefzIAX4zfJyOCi/X+pfjtTvJCMaiTMajNLnKsGg6Gc+NnGB3cBiLprHe28CaKh9pUSPJ40cO8Jvh43RUeLnWvxyv3Una4EyIx48coH96ksvq/VzRtBRdhLTnRk6wOziMRdO4oKqOTm8tf4j4yCjx4ASO5kVoVgsZwZ/+ilMPPo7utNNw03W4L+gizYhEGbr/BwR/+jTu8zppuPk6rPU1zJcRiTJ0/w8I/vRp3Od10nDzdVjra5gvIxJl+NEfEz5wGGu9j5pr/xxrfQ1p4QOHGf0//058OEjp6nZ8H/lzRNdJG/vZM0z+Ziea1ULlhotwX9BFMYl6HUXSNzXOtr27CETDpPlL3NzR/jYanCUUEjWSbNv7IruDw6S5TGZuau3kIt8C5iNqJNm290V2B4dJc5nM3NTayUW+Bfw+Tx7v55HD+4inDNI21C3k5tbVxFMG2/a+yO7gMGkuk5mbWju5yLeAvqlxtu3dRSAaJs1f4uaO9rfR4CzhyeP9PHJ4H/GUQdqGuoXc3LoaXYRi6ZsaZ9veXQSiYdL8JW7uaH8bDc4SnjzezyOH9xFPGaRtqFvIza2r0UUopG9qnG17dxGIhknzl7i5o/1tNDhLePJ4P48c3kc8ZZC2oW4hN7euJp4y2Lb3RXYHh0lzmczc1NrJRb4F/D5PHu/nkcP7iKcM0jbULeTm1tXEUwbb9r7I7uAwaS6TmZtaO7nIt4D5MCJR+m/6ApPPvUiaqdTFoi99hqrLLmGmez/9n97K3NAIac7WJTT//Rew+xsZ/v6POf61h0jNxUnzXnkZi778GUTXmY/h7/+Y4197iNRcnDTvlZex6MufQXSd/070ra+jCKJGklv3PMdoLELGZDxGb2iMyxr8FPLtvlfYPnKSjHgqxc7RU5zvrcdtsXGmvt33CttHTpIRT6XYOXqK8731uC028tkzNsK9vbsxlCJjYCaESdPYPnKC7SMnyYinUuwcPUVnlY8v9exkNBYhYzIeozc0htfu5N7e3RhKkTEwE8KkabSXeyiGqJHk1j3PMRqLkDEZj9EbGsNrd3Jv724MpcgYmAlh0jTayz3kEzWS3LrnOUZjETIm4zF6Q2N47U7u7d2NoRQZAzMhTJrG9pETbB85SUY8lWLn6CnO99bjttjIZ8/YCPf27sZQioyBmRAmTWP7yAm2j5wkI55KsXP0FOd763FbbJypo3/7DcZ+8RsyUnNxJp7egfv8NRy68S7ip0fJSAQnmHllH7Z6H4dv/TLKMMgI7+9HM5soPXcVZyr0u90cvvXLKMMgI7y/H81sovTcVfx3olEkPROjBGNRcg3OhDg2O0UhOwJD5DKU4oXRU8zHjsAQuQyleGH0FIXsCJwknx2BIXYEhshlKMUDB18jGIuSa3AmxA8H95PPjsAQxdIzMUowFiXX4EyIHw7uJ58dgSEK6ZkYJRiLkmtwJsQPB/eTz47AEDsCQ+QylOKF0VMUsiNwknx2BIbYERgil6EUL4yeYj7Gf7mdXMowOLbt28RHguQKHzjMyfu+Tz7jv/wt8zH+1HbyGf/lb/nvxkSRGEpRiKEUhRhKkU88ZTAfhlLkE08ZFBJPpcgnnjIwlCKfqJGkkKiRJJ94yqBYDKUoJGokySeeMijEUIpCokaSfOIpA0Mp8omnDAqJp1LkE08ZGEqRTzxlMB8qmQKEXEY4Cgj5GOEoIORKzcWZj9RcHBBypebi/HejUSRt5VW4zGYQQAABBLwOJ02uMgpZXeUDAQQQQACBtZ5a5mN1lQ8EEEAAAQTWemoppMtTAwIIIIAAAl2eWlZX+UAAAQQQQGDTkhW4zGYQQAABBLwOJ1ctXAYCCCCAAAJdnlqKpa28CpfZDAIIIICA1+HkqoXLQAABBBBAoMtTSyFt5VW4zGYQQAABBLwOJ1ctXAYCCCCAAAJdnlpWV/lAAAEEEEBgraeWQro8NSCAAP8fe/AeH2VhJ/r/851n7pckk8xkJpeBXEggEEGQm4g3UNRW10ttq2vVutRStdsq2kJL60/Xrq+11drrusej9Wxdu54fp3ZtsVZXkCMV0RZJEEhAcjMkzGQymUzmfnnmOeSP2eaV14xWmk273b7fAgggsMpdy3KXFwQQQAABBFa7azkdFeevBAEEEEAAgblf2oS+3A4CCCCAgMnnpe5zN4AAAggggIDzwrM5Hc51a0AAAQQQQMB54dn8d6PcdwqzwKzoabCX85vRk2TyeSa5zRa+tvhsqs1WSjmj0s2BsQDhTIpJigi3ti7hfI+P03FGpZsDYwHCmRSTFBFubV3C+R4fpTTay4nlMnRHxihYWunhzoVnsazKw4GxAOFMikmKCLe2LuGS2kYa7OX8ZvQkmXyeSW6zha8tPpuVrhpiuQzdkTEKllZ6uHPhWRh0OmaDWdHTYC/nN6MnyeTzTHKbLXxt8dmsdNUQy2XojoxRsLTSw50Lz8Kg01GMWdHTYC/nN6MnyeTzTHKbLXxt8dmsdNUQy2XojoxRsLTSw50Lz2JZlYcDYwHCmRSTFBFubV3C+R4fpTTay4nlMnRHxihYWunhzoVnsazKw4GxAOFMikmKCLe2LuF8j4/TUbbiTMb37iczOsYkURTmbrmN6o9dhqWlkfD/3Uc+nWGS0etm/vfux3nB2eQmokQ7jlBQseYsmr9xDzqDgQ/L2tpEbiJKtOMIBRVrzqL5G/egMxj470S57xRmSb3NQYO9nL7YODUWG3cvWklbeRXvx6LouayuibOqvKx0efls6xJWuGoo6IqE2HGihyPjIcoMRiqMZiapmsar/vf495P9DCWi1NvKMOoULIqeFVVegqkE6bzKzc3tXDOnlYKuSIgdJ3o4Mh6izGCkwmhm0rIqLwKcTMZYW13HPYtWYtMbsCh6VlR5CaYSpPMqNze3c82cVibV2xw02Mvpi41TY7Fx96KVtJVXMWlZlRcBTiZjrK2u455FK7HpDUwKphK8NNzHa4FB0qrKHFsZf4hgKsFLw328FhgkrarMsZUxqd7m4LL6JhaWu1hfM5fPtp5JjcXOpGVVXgQ4mYyxtrqOexatxKY38H7qbQ4a7OX0xcapsdi4e9FK2sqrmLSsyosAJ5Mx1lbXcc+ildj0BiyKnhVVXoKpBOm8ys3N7Vwzp5WCrkiIHSd6ODIeosxgpMJoZtKyKi8CnEzGWFtdxz2LVmLTG7AoelZUeQmmEqTzKjc3t3PNnFYKoh1H8P/keaJvH8JQUYahyskkTVUZ/cUrBH/2Esn+QSyNPnQmI4rNgvO8VaT9QfKpNHPu/Btqb/k4kyyNPqwtjSSO9mL21dLyD1txnLmISRXnLAedjtTAMFUbzmPeP2xFb7cxKeMPEtj+S0K/+r+oqRTW5rkURDuO4P/J80TfPoShogxDlZNJFecsB52O1MAwVRvOY94/bEVvtzEp4w8S2P5LQr/6v6ipFNbmuRREO47g/8nzRN8+hKGiDEOVk0maqjL6i1cI/uwlkv2DWBp96ExGPki04wj+nzxP9O1DGCrKMFQ5mU2incIs2T7QzePHOilQRNjSvpoLvXM4HdsHunn8WCcFighb2ldznsfHlv276QyPUOCx2Hh0+Tomshm27N9NJJumYH3NXLa2r2b7QDePH+ukQBFhS/tqzvP42LJ/N53hEQo8FhuPLl/HRDbDlv27iWTTFKyvmcvW9tVsH+jm8WOdFCgibGlfzXkeH1v276YzPEKBx2Lj0eXrmMhm2LJ/N5FsmoL1NXPZ2r6a09ETHWfL/t1EsmkK1tfMZWv7akpRNY0t+3fTGR6hwGOx8ejydbjNVkrZPtDN48c6KVBE2NK+mvM8Prbs301neIQCj8XGo8vXMZHNsGX/biLZNAXra+aytX012we6efxYJwWKCFvaV3Oex8eW/bvpDI9Q4LHYeHT5OiayGbbs300km6bgGlMlt513MUNPPEv/Q49RIIpC68PbqLrsAg7fvJnImx0UmOq8LH72B2TDEQ7fvJlsOEKB+68upvWRrzH0xLP0P/QYBaIotD68jarLLuDwzZuJvNlBganOy+Jnf0A2HOHwzZvJhiMUuP/qYlof+RpDTzxL/0OPUSCKQuvD26i67AIO37yZyJsdFJjqvCx+9gdkwxEO37yZbDhCgfuvLqb1ka8x9MSz9D/0GAWiKLQ+vI2qyy7g8M2bibzZQYGpzsviZ3+A0eumlKEnnqX/occoEEWh9eFtuC5fz2xR7juFWRBMJfh6xx40fkcDDowFuGZuK4ro+DCCqQRf79iDxu9owIGxACLCi0O9TBXPZRnPpnnVP8BgIspUfbEI5UYTjx/rRON3NODAWAAR4cWhXqaK57KMZ9O86h9gMBFlqr5YhHKjicePdaLxOxpwYCyAiPDiUC9TxXNZxrNpXvUPMJiIMlVfLEKzw8kcWxkf1gMHX2cwEWWqvliEZoeTObYyivm3wXfZcaKHqeK5LOPZNGur6ykmmErw9Y49aPyOBhwYCyAivDjUy1TxXJbxbJpX/QMMJqJM1ReLUG408fixTjR+RwMOjAUQEV4c6mWqeC7LeDbNq/4BBhNRCszJNOu//iMcZjP9Dz0GmsZ/0DQib+wHEQLbX2AqNRojGwozuuMVkr3vMVXiaC8GZzn9Dz0GmsZ/0DQib+wHEQLbX2AqNRojGwozuuMVkr3vMVXiaC8GZzn9Dz0GmsZ/0DQib+wHEQLbX2AqNRojGwozuuMVkr3vMVXiaC8GZzn9Dz0GmsZ/0DQib+wHEQLbX2AqNRojGwpTdcl5FJPxB+n67FdA0/gPmkbkjf3UfvrjiF5hNij3ncIs2D/mZ3dgEAQQQACBjJbnHHcdVSYLH8b+MT+7A4MggAACCGS0PMPJGPFcFgQQQACBdF6lPx5B4xQBBBBAYCAxQTSXAQEEEEAgo+UZTsaI57IggAACCKTzKv3xCBqnCCCAAAIDiQmiuQwIIIAAAhktz3AyRjyXBQEEEEAgnVfpj0fQOEUAAQQQcJktLK/y8mF9p/u3aJwigAACCLjMFpZXeSlm+0A37yUmQAABBBBI51Wu9rVSzP4xP7sDgyCAAAIIZLQ8w8kY8VwWBBBAAIF0XqU/HkHjFAEEEEBgIDFBNJcBAQQQQCCj5RlOxojnsiCAAAIIpPMq/fEIGqcIrH71IJ9+9OeYkxkSxwfIRaKAAAIIIOTTWVIDw6jROCCAAAII+VSaxLF+0DRAAAEEEBLHB8hFooAAAggg5NNZUgPDqNE4IIAAAgj5VJrEsX7QNEAAAQQQEscHyEWigAACCCDk01lSA8Oo0TgggAACCPlUmsSxftA0QAABBBASxwfIRaKAAAIIIOTTWVIDw6jROCCAAAII+VSa2ps+RjHjv/4toy+8CggggABCPp2l6qK1GD0uZoOOWVJptFCK02Tmw6o0Wiil1eGkGLveiF1vpJhWh5NSWh1OirHrjdj1RoppdTgppdXhpBi73ohdb6QYt8nK6bDrjRTjNlkpxWW2Uoxdb6SUSqOFUlodToqx643Y9UaKaXU4KaXV4aQYu96IXW9kkvfEKBfs+A0F9vZWSrG3t1KMvsyOvsxOMfb2Vkqxt7dSjL7Mjr7MTjH29lZKsbe3Uoy+zI6+zE4x9vZWSrG3t1KMvsxOKQZXJaUY3ZXMFh2zpK28imZHBdOtctXiNln5sNrKq2h2VDDdKlctNzQuwqhTmO4aXytXz2llunKDiU0tZ9LsqGC6Va5abmhchFGnMN01vlauntPKdOUGE5tazqTZUcF0q1y13NC4CKNOYbprfK1cPaeV6coNJs711HM6rp7TynTlBhPneuop5ZKaRow6hemu8bVSSlt5Fc2OCqZb5arlhsZFGHUK013ja+XqOa1MV24wsanlTJodFUy3ylXLDY2LMOoUprvG18rVc1qZdNU/78KczDDJ4Cyn8Su3Y2ubx3TOC1bju+MmdCYj09XefC01n76W6QzOchq/cju2tnlM57xgNb47bkJnMjJd7c3XUvPpa5nO4Cyn8Su3Y2ubx3TOC1bju+MmdCYj09XefC01n76W6QzOchq/cju2tnlM57xgNb47bkJnMjJd7c3XUopj6UJsbfOYznnBaoxeN7NFue8UZoFOhDXV9QSScYKpBGZFYb23gc0LV2DQ6fiwdCKsqa4nkIwTTCUwKwrrvQ1sXriCarOV9goXPbFxwpkUbpOVW1uWcGldI4sqXOh1OvpiEXJankUVLradsQafrYw11fUEknGCqQRmRWG9t4HNC1dQbbbSXuGiJzZOOJPCbbJya8sSLq1rZFGFC71OR18sQk7Ls6jCxbYz1uCzlbGmup5AMk4wlcCsKKz3NrB54QqqzVbaK1z0xMYJZ1K4TVZubVnCpXWNLKpwodfp6ItFyGl5FlW42HbGGuqtDk7HogoXep2OvliEnJZnUYWLbWesod7qoJRKk5n2Chc9sXHCmRRuk5VbW5ZwaV0jpehEWFNdTyAZJ5hKYFYU1nsb2LxwBdVmK+0VLnpi44QzKdwmK7e2LOHSukYWVbjQ63T0xSLktDyLKlxsO2MNPlsZa6rrCSTjBFMJzIrCem8DmxeuoNpspb3CRU9snHAmhdtk5daWJVxa18iiChd1J8NUv/A6WjZH2bJ25n/nXixNc6i8aC3pIT+Zk0EUqxn3lRcz78EvY6r1UHbWGcS7e8iOhjHWVNPw5U14rv0IZcvaEYOBxLE+tGyOsmXtzP/OvVia5lB50VrSQ34yJ4MoVjPuKy9m3oNfxlTroeysM4h395AdDWOsqabhy5vwXPsRypa1IwYDiWN9aNkcZcvamf+de7E0zaHyorWkh/xkTgZRrGbcV17MvAe/jKnWQ9lZZxDv7iE7GsZYU03DlzfhufYjlC1rRwwGEsf60LI5ypa1M/8792JpmkPlRWtJD/nJnAyiWM24r7yYeQ9+GVOth7KzziDe3UN2NIyxppqGL2/Cc+1HKEV0OiovWkt6yE/mZBDFasZ95cXMe/DL6AwGZotop/AXf5CdJwd4bvAYsVyGtrIqNrYsxm2yklRz/Lj3EL8N+VFEOLfax3UNbSgivJ+dJwd4bvAYsVyGtrIqNrYsxm2y8n4G4xM8cfwgPbFx3CYLf924kBVVNUzaeXKA5waPEctlaCurYmPLYtwmK0k1x497D/HbkB9FhHOrfVzX0IYiwvvZeXKA5waPEctlaCurYmPLYtwmKzMtqeb4ce8hfhvyo4hwbrWP6xraUER4P/4XdhJ4cju5aAzHkjYa7vksRq+b0xV8/t8Z/uefkovGcCxpo+Gez2L0ulETSQa/978I//o3iKJQdcl51G/6a0RRSPa+R//DjxPv6sHkdVN/26dwnreS/wzB5/+d4X/+KbloDMeSNhru+SxGr5s/R8p9p/AXp23HiR4e6XqLUDpJNJuhLxbh18EhNtQ2cv/B19nlH2A8kyacSdERHiGUTnK2u45Sdpzo4ZGutwilk0SzGfpiEX4dHGJDbSNGnUIxgWScO976d3pi48RzWUZSCXb6B2grr+LA2AiPdL1FKJ0kms3QF4vw6+AQG2obuf/g6+zyDzCeSRPOpOgIjxBKJznbXUcpO0708EjXW4TSSaLZDH2xCL8ODrGhthGjTmEmbet4jV3+AcYzacKZFB3hEULpJGe76yjF/68/p2frN8mMhMhFoiSO9hJ6eQ/V11yKzmTkw/L/6885/tVvkRkJkYtESRztJfTyHqqvuZSjd9xL8BevkA2Nkx0dI7LvAJmRUWwLmun82OeId/WgRmOkT44Q/PkrOJYsxDK3jpnk/9efc/yr3yIzEiIXiZI42kvo5T1UX3MpOpORPzc6/uIP8pP+wyAaiAaigWgEUjEeO/Y2B8J+EA1EA9FANF482UMkm6aUn/QfBtFANBANRCOQirHT308p/3biXWJqBkQD0UA0EI2f9B/hJ/2HQTQQDUQD0QikYjx27G0OhP0gGogGooFovHiyh0g2TSk/6T8MooFoIBqIRiAVY6e/n5l0bGKMA2E/iAaigWggGi+e7CGSTVPK4D89AyIgAiIgQno4QPDnr3A6Bv/pGRABERABEdLDAfoe/CHj+w6ACIiACIgQ+D8v8t73/5lcNA4iIAIiIMKJf3qGmTb4T8+ACIiACIiQHg4Q/Pkr/DnS8Rd/kGA6QTEHxgKUMpyIUUownaAYfzJOKYFUnGKCqQTBdIJiDowFKGU4EaOUYDpBMf5knJk0lIxRynAiRikZf5Bi0kN+TkfGH6SY8TfeppTxN96mmLQ/yEzL+IMUkx7y8+dIx1/8QZodToq5tLaJYow6hQZ7OaU0O5wUM89RQSnN9gqKaXZU0OxwUsyltU0UY9QpNNjLKaXZ4aSYeY4KZtL8skqKMeoUGuzllGJrm0cxtrZmToetbR7FeK79CMXoTEaqr7iIYmwLmplptrZ5FGNra+bPkY6/+IPc1rIUo05hqiXOam5oXMTVvlam2zhvMRZFTym3tSzFqFOYaomzmgs8cynlmjnz8dnKmMquN/KZ5iXc1rIUo05hqiXOam5oXMTVvlam2zhvMRZFTym3tSzFqFOYaomzmgs8c5lJtRY7V/tamW7jvMVYFD2lNH71DnQmEyCAAEL5yjNxfXQdp6Pxq3egM5kAAQQQyleeie/2T1F708cAAQQQQJh7963U3/4pLE1zAQEEEPRlDhruuZWZ1vjVO9CZTIAAAgjlK8/E9dF1/DkS7RT+iILpBMOJGH8Kyg0mfLYyFBE+jJ5omJdO9jGaTtJe4eLK+lYUESbt9Pfz7EAXFkXPjY3trKiq4YP0RMO8dLKP0XSS9goXV9a3oojwfpJqjmf6DrPLP8DSSg83NbXjMduY1BMN89LJPkbTSdorXFxZ34oiwqSd/n6eHejCoui5sbGdFVU1FCTVHP2xCLVWO+UGEwU90TAvnexjNJ2kvcLFlfWtKCJMUjWN/tg4iuhosJczVVLN0R+LUGu1U24w8fvY6e/n2YEuLIqeGxvbWVFVwweJdx1n5GcvkfaPUnZWOzWfugpRFE5XvOs4g489Q+zwMbyfvJy6jZ9AFIVJoy+8ytjuN9CZjFRdcj7Oc1cwSU0kOfHYvzDyi51UrF7KnL+9GVOdlw+iqSqJY32IXsHa0sjvI951nMHHniF2+BjeT15O3cZPIIrCJE1VSRzrQ/QK1pZGfl8Zf5DM6BjWlkZ0JiMFmqqSONaH6BWsLY3MNj1/BLFchid7DrJnZJBINs2fEoui59LaJm5oWES5wcTvo9nh5HaHk+m6JkI81fsOgVScSU/2HMRrseGzlvF+mh1Obnc4+TBeHO7hZyeOkcmrvOzvQ9EJX5y/AkWEZoeT2x1OpuuaCPFU7zsEUnEmPdlzEK/Fhs9axnODR3my5yCZvMqky2qb+OL8FSgiNDuc3O5wMl3XRIi/P7SXQCrOpGa7k23tZ+OzlvHc4FGe7DlIJq8y6bLaJr44fwWKCKV0TYR4qvcdAqk4k57sOYjXYsNnLeP92Nrm0dg2j5mgJpIMfPcpwrv3MWnoiWcx13lxffRCJrk+eiGuj17IdIHtv2T4x8+RT2cY+beXEb1C8/13IYpCKdHOIxzd/Pekh/xMsrXNY/4j27A0zaEUNZFk4LtPEd69j0lDTzyLuc6L66MXEu08wtHNf096yM8kW9s85j+yDUvTHEpRE0mObv4G4d37mKQvs9P8/92J66MXEu08wtHNf096yM8kW9s85j+yDUvTHGaLct8pzKLO8AhbO3bTEQ6Qzqv8qclpebonQrzi72dFVQ0VRjOnI6nmuPvtXYykExSEMykOjY9yed08ZtJvQid56Mg+VE2j4Hg0jF6nY3FFNcUk1Rx3v72LkXSCgnAmxaHxUTxmGw8d2YeqaRQcj4bR63QsrqimmKSa4+63dzGSTlAQzqQ4ND6Kx2zjoSP7UDWNguPRMHqdjsUV1RSTVHPc/fYuRtIJCsKZFIfGR7m8bh6zpff+7zH6y92AAEI+nWVs516qNpyLoaqCYsJ7fsO7X/4HNDUPCCDEjxxHDAbKVyymGDWR5J0b7yZzcgQQQMiOhpl4+xDe666glN77v8foL3cDAgj5dJaxnXupWLuc7i8+QObkCCCAkB0NM/H2IbzXXUEpvfd/j9Ff7gYEEPLpLGM791KxdjndX3yAzMkRQAAhOxpm4u1DeK+7gtmiYxYNJib4+sHXCKYT/Kkby6T4u3deJ5NXOR2d4RGC6QTT9cTC9McjzKQ9wUGK2TNyglI6wyME0wmm64mFebrvEMXsGTlBKZ3hEYLpBNP1xMI83XeIYvaMnKCUzvAIwXSC6YaCASb6B5ktoZf3MJ2mqoReeZ1SQi+9RjGhl1+jlMhbnWT8QaaLd/WQeLefUkIv72E6TVXpe/AfyfiDTBfv6iHxbj+lhF7ew3SaqtL34D+S8QeZLt7VQ+LdfmaLjln0xPFOkmqO/yoGExP8uO8Qp0PV8pSianlmUiavUkwmr1KKquUpJanmKCaTVylF1fKUklRzFJPJq5SianmKufT/vIGSyjBbNFUFAQQQQACBfCZDKflMBgQQQAABBPKZDKVoqgoCCCCAAAIIaKpKKZqqggACCCCAgJpMggACCCCAAAKaqlKKpqoggAACCCCgJpMggAACCCCAgKaqzBYds2Qsk2Lv6BD/1ezyD3A62ivc2PVGpvOYbTTYKphJq6rqKGaVq5ZS2ivc2PVGpvOYbVw3t41iVrlqKaW9wo1db2Q6j9nGdXPbKGaVq5ZS2ivc2PVGptp6z9OsGoxibWlgtlSsXQEIIIAAAgiVF6ymlMoLVgMCCCCAAELl+asppWxZO3qHAxBAAAEEU50Xa0sDpVSsXQEIIIAAAghzN38GvcMBCCCAAIKpzou1pYFSKtauAAQQQAABhLmbP4Pe4QAEEEAAwVTnxdrSwGzRMUuOTYzxX1EwnSCSTfNhlRtMbFm4GrveSIHbZGVb+xoUEWbShZ45XO1rZaqlTg83NbZTSrnBxJaFq7HrjRS4TVa2ta9hvbeBq32tTLXU6eGmxnZKKTeY2LJwNXa9kQK3ycq29jWs9zZwta+VqZY6PdzU2E4p5QYTWxauxq43MsmczFBWXs78R7YhisJsafr657EtaKZAFIWGL30Wx5I2SnF95EJqb7qaqSpWL8X3+ZsoxeAsp+WbW9A77BQYvW7mP7INURRKafr657EtaKZAFIWGL32WygtW0/LNLegddgqMXjfzH9mGKAqlNH3989gWNFMgikLDlz5L5QWrafnmFvQOOwVGr5v5j2xDFIXZItopzIKX/b18q+tNfh8es41VVbXUWRzYDQZm0lAiRk8szOHIKLFcht/Hw0vXs6SimtOxLzTEkz2dWBQDt7Uspa3MxQcJphPsGRkkmE7QXuHmHFc9BV0To+wbHcaoUzjHXU+DrZyC4WSUo9Ex6iwOWh2VFATTCfaMDBJMJ2ivcHOOq56CSDbNoUgQRYQlFR4sip5JqqbxTP8hfnWyl6VOD7e1LMOuN/JBItk0hyJBFBGWVHiwKHomqZrGM/2H+NXJXpY6PdzWsgy73sgHiWTTHIoEqRsK42uZh2K18EEy/iCjL+8h4w/iOKudqvXn8IdIDwXo++b/IHb4GHW3fJyaG66kINrZxdjufeiMRqouOgdrSwOTNFVl8LFnCPz0V1SsXkrjV29D77DzQbLhCBNvH0IUhfKVS1CsFj5IeihA3zf/B7HDx6i75ePU3HAlBdlwhIm3DyGKQvnKJShWCx9EU1WiHV1kR8dwLGnD6HVTMLZ7HwPffhLFaqHxK7fhWNLGbBLtFGbBy/5evtX1Ju/Houj5fOtZrPc0oojwnymp5niip4OfD73LB3l46XqWVFTzYW1/r5vHew5QoIiwZeHZXFg9l1J6YmG2dLxKJJumYL2nga0Lz2b7e9083nOAAkWELQvP5sLquZTSEwuzpeNVItk0Bes9DWxdeDalqJrGlo5ddI6PUOAx23h02UW4TVY+LFXT2NKxi87xEQo8ZhuPLrsIt8nKTIp393B441ay4QgF7svX0frNrZyOeHcPhzduJRuOUOC+fB2t39zK0FPb6f/W/6RAFIXWh7ZQdcm5HN64lchbnRSY6jws/pdHMXpczKR4dw+HN24lG45Q4L58Ha3f3MpMG3pqO/3f+p8UiKLQ+tAWXB+5gNmi40+EUafw6LKL2OBtQhHhP5tF0fO3rct5cMkFKCLMtGA6wZO9HUylahrfO/pbMnmVUn5wbD+RbJqpdgb6ef7EMZ7s7WAqVdP43tHfksmrlPKDY/uJZNNMtTPQz+ujJyjl+RPH6BwfYapAKs6TPZ2cjudPHKNzfISpAqk4T/Z0MtN6v/FDsuEIUwV37CK0cy+no/cbPyQbjjBVcMcuTj7zPAPf/hFTaapKz/3fY+hH24m81clU6aEA/Y88wUzr/cYPyYYjTBXcsYvQzr3MpExglIFv/4ipNFWl5/7vkU9nmC06/kR8unExzXYns21FZQ0bm85kpnVNhFA1jeliuQz98QildE2MUsz2wW5UTWO6WC5DfzxCKV0ToxRzaDxIKYciQYrpmghxOg5FghTTNRFipkU7uwEBBBBAACH69iFOR7SzGxBAAAEEEIb+10/R1DwggAACCLloHP///0tAAAEEEECIHjzKTIt2dgMCCCCAAEL07UPMpGhnF5qaBwQQQAAhF42TeLef2aLjT4DPWsY1vvn8sVxZ30Kl0cxMqjSaKcVpNFOKXW+kmFZHJaU4jWZKseuNFOM2WSnFZbJSjF1v4HS4TFaKsesNzDR9uR0EEEAAAQSMHjenQ19uBwEEEEAAAfuiFhBAAAEEEEDAvqgFBBBAAAEE9GV2Zpq+3A4CCCCAAAJGj5uZZHA5QQABBBBAAAGju5LZomM2CSCAAAIIILC00oMiwh+LUaewylUHAggggAACCKelrcxFs8MJAggggMAqVy1uk5VSrvbNBwEEEECg3Ghi07ylNDucIIAAAgisctXiNlkp5WrffBBAAAEEyo0mzq32UcolNY0YFQUEEEAAgWt88zkdl9Q0YlQUEEAAAQSu8c1nptV86iqmMzjLcV1yLqej5lNXMZ3BWU7jlz6LbUEz0znPX4nvc3+NzmRkutobr2Km1XzqKqYzOMtxXXIuM8mxpA3bgmamc56/EqPHxWxR7juFWdATC7N3dIhiPlo7jxZHJX9MJ5JR9of9FLPB24TXbOPD0ImwxlVPIBUnmE5gVvSs9zSwef4qDDodpSwqd6PX6eiLj5PT8iwqd7Nt4Rp81jLWuOoJpOIE0wnMip71ngY2z1+FQaejlEXlbvQ6HX3xcXJankXlbrYtXEO9tYxSKo0W2svd9MTGCWdSuE1Wbm0+k0trmjgdlUYL7eVuemLjhDMp3CYrtzafyaU1Tcy0sqULEb2BxLt9aFmVsqULmf/wV7A01HM6ypYuRPQGEu/2oWVVypYuZP7DX8HS5KNy/RrSQwEy/lEUsxn3FeuY93d3YaqppmxZO/HuPrKjYYweNw13fwbPNZcw08qWLkT0BhLv9qFlVcqWLmT+w1/B0lDPTBKdjsr1a0gPBcj4R1HMZtxXrGPe392FzmBgtuj5E1BrcfD7CKTi/PJkDz2xMN0TISLZNMVUGs04jRZWVdVyZV0rlUYzH6TcYOR07Qz089yJo8RyWdrKqtjYtAS3yYpF0eMx2/CYbSiiw2O2YdQpvB9FhBvmLuKGuYuYzqLo8ZhteMw2FNHhMdsw6hQmDSYmeKK3k55YGLfJyl/PXcSKyhoUEbxmGx6zDVvOiMdso8xgYlJSzfHj/nf47dhJFNFxrtvHdXMWoohQaTTjMduI5TK4TVY8ZhsFOwP9PHfiKLFclrayKjY2LcFtsvJ+Ko1mPGYbsVwGt8mKx2yjYGegn+dOHMVyIsgtvx2h5fM3YfS4UBNJBn/4L4Rf348oClUXr6X+1k8gikKyb5D+b/+I+NFeTB4X9Zuux7l2OaIo+D53Pb7PXc90aiLJ4A//hfDr+xFFoeritdTf+glEUUj2DdL/7R8RP9qLyeOiftP1ONcuRxQFc50HU60XxRHDVOvB4CxnkmI1Y67zYKrzIIqCqdaLzmRkktHlxFRbTS4aw+RxYarzUBD8xS6Gn/43ctEYjsULaNj8Nxg9LtREksEf/gvh1/cjikLVxWupv/UTiKKQ7Buk/9s/In60F5PHRf2m63GuXY4oCuY6D6ZaL4ojhqnWg8FZzgdJ9g3S/+0fET/ai8njon7T9TjXLmdS8Be7GH7638hFYzgWL6Bh899g9LhQrGbMdR5MdR5EUTDVetGZjMwm5b5TmAU9sTB7R09QzAZvI16znfezY/hd7jv0GgfCfoaSUdL5HKUk1RzhTJJ3IiP8fOgYbpOVZruT99MTC7N39ATFbPA24jXbKWbH8Ls8cvRNQpkk0Vyavvg4vx4dZIO3ifsP72FXoJ/xbIpwJknHeIBQJsnZrnpOx7Z3drMr0M94NkU4k6RjPEAok6TJ7uSO/S/REwsTz2UYScfZGeinrczFgbCfR46+SSiTJJpL0xcf59ejg2zwNnH/4T3sCvQznk0RziTpGA8QyiRpsju5Y/9L9MTCxHMZRtJxdgb6aStzcSDs55GjbxLKJInm0vTFx/n16CAbvE0YdQrFBFJx7tj/Ej2xMPFchpF0nJ2BftrKXBwI+3nk6JuEMkluu+dpUt09hHa+TvVVF3P0zgcIvvAq2bFxsqEwkbc6yYyEsLU20fnJLxA/2osajZP2Bwnu2IVj8QIsc2oppeu2rxN84VWyY+NkQ2Eib3WSGQlha22i85NfIH60FzUaJ+0PEtyxC8fiBUT2HeD4vY+SCYbITURJvNtHaOfrVF91MUfvfIDgC6+SHRsnGwoTeauTzEgIW2sTnZ/8AvGjvajROGl/kOCOXTgWLyCy7wDH732UTDBEbiJK4t0+Qjtfp/qqizl65wMEX3iV7Ng42VCYyFudZEZC2Fqb6PzkF4gf7UWNxkn7gwR37MKxeAGRfQc4fu+jZIIhchNREu/2Edr5OtVXXYzOZKSY9FCAzk9+gfjRXtRonLQ/SHDHLhyLFxDZd4Dj9z5KJhgiNxEl8W4foZ2vU33VxRy98wGCL7xKdmycbChM5K1OMiMhKi88m9mi3HcKs6AnFmbv6AmK2eBtwmu2U8qP+9/h8Z4D5LQ8H5aqaewdPUGz3ckcaxml9MTC7B09QTEbvE14zXaKue/QHhJqlqniuSzhTIrXRweZ7ngszJV1rZgVPR/GsegYT/Z2MN3xWJhYLkvXxCjTBVJx9oWGSKhZpornsoQzKV4fHWS647EwsVyWrolRpguk4uwLDZFQs0wVz2Vxm6wsKKuimGcGDtMxHmC6QCrOvtAQCTXLmft6WHBwkElqNE52NExo516mi3f1kIvGiR7sZrr0cADP1ZdQTOzwMQa+8xTTxbt6yEXjRA92M116OMDYq/tQ4wmmUqNxsqNhQjv3Ml28q4dcNE70YDfTpYcDjL26DzWeYCo1Gic7Gia0cy/Txbt6yEXjRA92M116OMDYq/tQ4wmmUqNxTB4XjjPmU8yJx/+VyFudTJceDjD26j7UeIKp1Gic7GiY0M69TBfv6qHm+r9CsZiYDTr+xPXEwjzd/w5/qEePvkkkm2amBdMJijkQ9lPKcDLKhzWUjFLKgbCfYoLpBMF0gmIOhP2UciDsp5hgOkEwnaAYfypOKYFUjGKC6QTBdALviTEu/elvAAEEEMb3dQACCCCAAAII4/s6AAEEEEAAIR0IUUrqvZOAAAIIIIAAwvi+DkAAAQQQQEgHQmQCIUAAAQQQQBjf1wEIIIAAAgggjO/rAAQQQAABhHQgRCYQAgQQQAABhPF9HYAAAggggADC+L4OQAABBBBASAdCZAIhQAABBBBASA+PUEpqaAQQQAABBBDSgRCZQAgQQAABBBDG93UAAggggAACCKn3hpktOmaTAAIIIIAAwvvaPtgFAggggAACCCCAAAIIIIAAAggggAACkVyaHcPv8r4EEEAAAQQQ3lezwwkCCCCAAAKX1jSDAAIIIICAUVFosFXwYc13VIIAAggggIBRUVjnaQABBBBAAIFmh5NmhxMEEEAAAQQurWkGAQQQQAABo6KwztMAAggggAACzQ4nzQ4nCCCAAAIIzLM7KaXZ7gQBBBBAAIFmh5Ob3hzmc//wAuZklqk8H7uEYnQmI9WXX0gxtvlNlGJf1EIxOpOR6ssvpBjb/CZsC5ooxvOxSyhGZzJSffmFFGOb34RtQRPFeD52CcXoTEaqL7+QYmzzm7AtaKIY24ImSrEtaKIY2/wmbAuaKMbzsUsoRmcyYm2Zy2zR8SfuzbFhZsqx2Bgz7bbmZRh1ClMtqfBww9x2rq6bz3QbG5dgUfR8WLUWB1fXzWe6jY1LuGFuOz5rGVPZ9UY+03gmtzUvw6hTmGpJhYcb5rZzdd18ptvYuIQb5rbjs5YxlV1v5DONZ3Jb8zKMOoWpllR4uKB6LqVcU78An7WMqex6I7fXLuKv1m1AZzaCAAIIlK9cjG/T9dTeeBUIIIAAAnPvvIX6TddjafKBAAII6MtsNNx1C6WY59RSe+NVIIAAAgjMvfMW6jddj6XJBwIIIKAvs9Fw1y00btmEzmwEAQQQKF+5GN+m66m98SoQQAABBObeeQv1m67H0uQDAQQQ0JfZaLjrFhq3bEJnNoIAAgiUr1yMb9P11N54FQgggAACc++8hfpN12Np8oEAAgjoy2w03HULjVs2oTMbQQABBMpXLsZ12fmUUnvjVViafCCAAAL6MhsNd91C45ZN6MxGEEAAgfKVi/Ftup7aG68CAQQQQGDunbegWC3MFuW+U5gFPbEwe0MnKGaDtwmv2U4xT/Z1MFNSao6P1S+gmJ5YmL2hExSzwduE12ynGK/ZzuqqOiK5NOm8ynW+RXyxdSWKCCsqa6mzODiRjFJjsbO5dRUXeRopSKo5jsfGMOoUzIqeD7KispY6i4MTySg1FjubW1dxkacRg07HBm8TeU1jJB1nrcvHtoXnUGtx4DXbWV1VRySXJp1Xuc63iC+2rkQRYUVlLT5rGUadwgJHFX/TeCYXeRox6HRs8DZh0ik4DEZWVtZxz/zV1FoceM12VlfVYdApuM1WPlozj8+3rEARYZKqafTFx5nIpqkwmplk0OnY4G0ir2mMpOOsdfnYtvAcPI5yzHUeKs9bRXZ8gnwqQ/3Gj9N8798iioJz7XIsc2pJDgxjrq9h3n13Un3FOnQGA9VXXgR5jdTwCFUXncP8b23FPKeW9+NcuxzLnFqSA8OY62uYd9+dVF+xDp3BQPWVF6Ezm9CXO6g8dwUtD9yFeU4t5joPleetQmcyYvS48F57GU3bbkcUBefa5Vjm1JIcGMZcX8O8++6k+op16AwGqq+8CPIaqeERqi46h/nf2op5Ti3mOg+V561CZzJi9LjwXnsZTdtuRxQF59rlWObUkhwYxlxfw7z77qT6inXoDAaqr7wIndmEvtxB5bkraHngLsxzajHXeag8bxXZ8QnyqQz1Gz9O871/iygKkzRVJXGsn9z4BIbKCibpDAaqr7wIndmEvtxB5bkraHngLsxzajHXeag8bxU6kxGjx4X32sto2nY7oig41y7H2uhDZzTiOGM+c7/waaqvWMds0vPfSDCdYKYl1RxP9XfyZmiYSf978Ages40Lq+fSNTHKU/2dBFJxJj3Z14HXbMNnLeO5E9082ddJJq8y6TJvM19sXYkiQildE6M81d9JIBVn0pN9HXjNNnzWMl48eZyfDR0lk1d5OdCLIsIXW1eSyas81d/Jm6FhJv3vwSN4zDYurJ7LpAur53Jh9Vymsyh6bpjbTjHNdie3zzuL6bomRvn7rtcJpOJMarY72dZ2Dj5rGS+ePM7Pho6Syau8HOhlydsDXPzJa8mnMwx8/8eEX3uLSUNPbsdc68F12flED3Yz8P2nSQ8HmDTw3acw11VjafQR+OlLDD/zPPl0hpHnX0EUheZ7P48oCqVED3Yz8P2nSQ8HmDTw3acw11VjafShWC34Nl1PMbYFTTQu2MR00YPdDHz/adLDASYNfPcpzHXVWBp9BH76EsPPPE8+nWHk+VcQRaH53s8jioJtQRONCzYxXfRgNwPff5r0cIBJA999CnNdNZZGH4rVgm/T9UynJpIMfP/HhF97i0lDT27HXOvBddn5RA92c/RLD5EeDjDJtqCJ+d/cgqXRh2K14Nt0PcXYFjTRuGATxbguOx/XZefzx6LcdwqzoCcWZm/oBMVs8DbhNdsp5umBd5hJNzWcQTE9sTB7QycoZoO3Ca/ZTjHff/c37A6+R0Emr7I3dIKznDU8cOTXjKQTFIQzKQ5NBPGY7TzU/QaqplFwPBZGLzoWV1RTTFLNcXfnK4ykExSEMykOTQTxmO081P0GqqZRcDwWRi86do8MsDv4HgWZvMre0AnWunxUGM3MlKSa4+7OVxhJJygIZ1IcmgjiMdt5qPsNVE1j0oKDgyz77vOIXs/or15j9FevUZDPZBnbtY+KNcvo3vwgGX+QguxomIkDRzDVenj3qw+jqSoF8a4eRK+nfPkZFKMmkrzz6S1k/EEKsqNhJg4cwfuJj/BhqYkk73x6Cxl/kILsaJiJA0cw1Xp496sPo6kqBfGuHkSvp3z5GRSjJpK88+ktZPxBCrKjYSYOHMH7iY9QSu83/pHRX71GQT6TZWzXPirWLKN784Nk/EEKsqNhJg4cwfuJj/BflY7ZIoAAAggggADC+xNAgP+qSz4uAAAGDUlEQVTXHtxHx13XiR5/f36/yfzmMY8zmWTSpHlom4SmKW1pC21hgfK0W62wqwv3RqpXHoSze61LUYTqUfe6iAjuonu8qyweuxxYV1c9iwprz7ZSS6G2QB9Sm6ZtmrQpaTOZyWSSzCQzk998L/ljzsnJmUETs5Hc83u9BBBAAAEEEEAAAQQQQAABBBBAAAEEEPITQAABBBBAAOE97Y/0ggACCCBgovi/595mIJUAAQQQQKArHuX5C+0ggAACCCCwP9JLPsdi/QykEiCAAAIIdMWjPH+hHQQQQAABBPZHetkf6QUBBBBAwERxIHKRuXQs1s9AKgECCCCAQFc8yvMX2kEAgQeeeJm7nv01iBDZ8zqR/zoAIiACIiCCymTofvJZUqEIiIAIiIAI8c5uev/pRRABERABERAhsud18okdbicVioAIiIAIiBDv7CZx9jwzFTvcTioUAREQAREQId7ZTe8/vQgiIAIiIAIiRPa8Tj6xw+2kQhEQAREQARHind0kzp4nn8h/HQAREAEREEFlMnQ/+SypUAREQAREQIR4ZzeJs+dZqDQsfxBTZchlzJwgnzFzglxSGZN8TKXIZ8ycIJdUxsRUGXJJZUzmkqkU+YyZE2RVvBMlK5NMocwMuZiJMfIxE2PkkkmmyEeZJvmoCZOZUqZJPmZijFwyyRT5KNMkHzVhko8yM+RiJsbIR02YLFQa80oBClCAAhSgeG8KUIACFKAABShAAQpQgAIUoAAFKEABClCAAhTvTQEKUIACFKB4L1eVVAIKUIACFKC4p24lHlsBoAAFKEARcLi4q7oZUIACFKAAxfrSIPm0FPrx2AoABShAAYqAw8Vd1c2AAhSgAAUo1pcGuaqkElCAAhSgAMXVpVXMpZZCPx5bAaAABShAEXC4uKu6meLIKJ/7zI8AAQQQSq9bR/GGNYAAAggggLB4+8exeT2AAAIIIBjBChZ94iOAAAIIIIBQet068ilcvRyb1wMIIIAAghGswLV0MTNVuHo5Nq8HEEAAAQQjWMGiT3wEEEAAAQQQSq9bRz6Fq5dj83oAAQQQQDCCFbiWLiaf4g1rAAEEEEAAYfH2j2PzegABBBBAMIIVuJYuZqHSsPxB/nrJVTR4SsjSRbi/fjVXl1bxSNMGPDY7WX7Dxc6mTWwur+OOqiamWlVcwbbFreRTVGDwSNMGPDY7WX7Dxc6mTWwur+OOqiamWlVcwbbFrfz1kqto8JSQpYtwf/1qmgt9zKWiAoNHmjbgsdnJ8hsudjZtYnN5HZ8POXGMpckqXr+S6gfbqH/sAdxN9WSJrlP70Cco/ZN1LH18Bzavmyx7wEfjk5/B/4EbCLZtZari9SupfrCNfAqKC1n6+A5sXjdZ9oCPxic/g+g6M1VQXMjSx3dg87rJsgd8ND75GfwfuIFg21amKl6/kuoH28inoLiQpY/vwOZ1k2UP+Gh88jOIrpNP/WMP4G6qJ0t0ndqHPkHpn6xj6eM7sHndZNkDPhqf/Ayi6yxUot7FPNjdf46vd75BLk+13sTK4gC53PzrF5grRQUG/37Nh8lld/85vt75Brk81XoTK4sD5NM/Huc7597m9GiEjyxq5kPBRrIODr7Dc91Hceo2HqxfQ3Ohj6y+sRE6RwepcnhY5i0jayCZYH/4AgPJBC1FfjaWVZMVSyc5MRxCF42VRQGcuo1JplK8cKGd/7zcxariCh5sWIPHZmeSqRQdw2EG02M0e334DRdZHcNhDg6+g13T2Vi2iFp3MZNMpXh1oIezo1EqHG42l9fhsdmZNJBMsD98gYFkgpYiPxvLqsmKpZOcGA6hi8bKogBO3UbW+IVLjJ48g6O6Es/ypWQl+/rpfup7jJ48S9XH7qDyf3yArPTQMMNvn0R0jaK1reguB5OUadL73X+j/ye7KV6/krpH7sfmdfO7DO47xPlndqG7nNR99l68rU38IQb3HeL8M7vQXU7qPnsv3tYmssYvXGL05Bkc1ZV4li/l95EeGmb47ZOIrlG0thXd5WCSMk3Cr/yaeOc5jGAA/wduwOZ1M0mZJiPHO0mHo3hbG7EHfGQN7jvE+Wd2xdaXogAAGBZJREFUobuc1H32XrytTUxSpkn4lV8T7zyHEQzg/8AN2LxufpeR46cY3HcYzSig7MZrcC1ZzHwS9S7mwe7+c3y98w1year1JlYWB8jlvrd+QU98iLlQ6y7m2TVbyGV3/zm+3vkGuTzVehMriwPk0jUa5ZH2PcTSSbI2l9fyuaaN/OhiB9899zZZugiPNG3kBv9i8ukajfJI+x5i6SRZm8tr+VzTRvIxleKR9j0cG+onK+Bw8/crb8FvuMjnRxc7+O65t8nSRXikaSPX+Wp4pH0Px4b6yQo43Pz9ylsYTid5pH0PsXSSrM3ltXyuaSOzEe88x2/v/wLpoWGy/FuuZ9njO8hHmSa/vf8LxN5sJ8sIltP6/a9hD/jI551dP6XnG98jS3SdZY8/hO+265iNd3b9lJ5vfI8s0XWWPf4QvtuuYy4p0+S393+B2JvtZBnBclq//zXsAR/5vLPrp/R843tkia6z7PGHKLt5I7+9/wvE3mwnywiW0/r9r2EP+MjnnV0/pecb3yNLdJ1ljz+E77brmC8a73MN7mLmyqriCubaP3YdJpZOMtWeUA//0dfJc91HmMpUim+eOUQqY5LPP3YdJpZOMtWeUA8HIr3k8x99nRwb6meq/vE4z3UfIZ+BZILnuo8wlakU3zxziB9dPMmxoX6m6h+P81z3Ef6x6zCxdJKp9oR6OBDpZTbOffU7pIeGmWrgF68S2XuQfC7968+JvdnOVMm+ED3P7CKfVH+Y88/sYiplmnR95dtkkilmKtUf5vwzu5hKmSZdX/k2mWSKuXTpX39O7M12pkr2heh5Zhf5pPrDnH9mF1Mp06TrK9/mnV0/JfZmO1Ml+0L0PLOLfFL9Yc4/s4uplGnS9ZVvk0mmmC8a80kAAQQQQAABhLw+VNWIrgkIIIAAAggggAACCCCAAAIIIIAAArom3B5cxnsSQAABBBBAACGvjpEwCCCAAAII/OidDkwUCCCAAAKjZoqexBD5dIyEQQABBBBA4MTwAPmcGB4AAQQQQACBjtEI+XSMhDFRIIAAAgiMmil+fvkMCCCAAAIIdIxG6BgJgwACCCCAwInhAWZj+HgnClCAAhSggOEjJ8ln+MhJFKAABShAAcPtneQzfLyTjGmiAAUoQAHpkTiJs+eZqeHjnWRMEwUoQAEKSI/ESZw9z1waPnISBShAAQpQwHB7J/kMH+8kY5ooQAEKUEB6JM7lH72CAhSgAAUoYLi9k3yGj3eSMU0UoAAFKCA9Eidx9jzzReN9rtnr48NVzfyh7q5pJej0Mtc8Nju5LPOUkU9JgZN8PDY7ufjtLvLxGS5y8eh28im1O8lnmaeMXDy6HY/NTi5+u4vZsBW6QQABBBBAwKgoIx97hQ8EEEAAAQRsXg/52H0lIIAAAggggECBr4SZsvtKQAABBBBAAIECXwlzyV7hAwEEEEAAAZvXQz52XwkIIIAAAggg4Fm+BAQQQAABBGxeD/nYfSUggAACCCCAQIGvhPmisQD8r9or+dOKBmbDruk8WL+GtpoW/jvcEWxiuqICg0/WrabBXcJ060ur8Bsu8rkj2MR0RQUG1/pqyOfWQD12TWe6P69qJJ9mr48GdwnTrS+toq2mBbumM92fVzVyR7CJ6YoKDK711TAbwbatgAACCCAUFBdRdtNG8gls3YxmGIAAAgggBNu2ko+3tRF3YwMggAACCKXXrsUI+Jgpb2sj7sYGQAABBBBKr12LEfAxlwJbN6MZBiCAAAIIwbat5ONtbcTd2AAIIIAAQum1a6m+7040wwAEEEAAIdi2lXy8rY24GxsAAQQQQCi9di1GwMd80b/0LuZBVzzK65GL5HJLoJ4Kh4d8NBGuKVvEyuIAoxMpwqkEEypDProI9e4Sri6r4pFlG7i6rIrfpSse5fXIRXK5JVBPhcNDLssL/dhEozsxxITKsLzQz87mTVS7CtlQtoj+ZJyBZByHbmNzeS0PLb2aAk0jn+WFfmyi0Z0YYkJlWF7oZ2fzJhY5C8mn1O6kpchP12iUaHocv+HivrpV3FbRQD6aCBvKFtGfjDOQjOPQbWwur+WhpVdTbrhpKfLTNRolmh7Hb7i4r24Vt1U0sLzQj000uhNDTKgMywv97GzexCJnIbNReGUzWoGNxJnzqPQEhVc20/S1h3EuriIfu6+EwlXNxDt7SEeiGAEfdZ/+GIHbbyYf0TTKblhPsi9E8vIAusPAv+V6ln7xU2gFNmZKNI2yG9aT7AuRvDyA7jDwb7mepV/8FFqBjblk95VQuKqZeGcP6UgUI+Cj7tMfI3D7zeQjmkbZDetJ9oVIXh5Adxj4t1zP0i9+CqPST+GqZuKdPaQjUYyAj7pPf4zA7TeTj2gaZTesJ9kXInl5AN1h4N9yPUu/+Cm0Ahvzxcb7wOhEit/HyqIAK4sC/HcYSCaYDV2EtpoW2mpamM6pFxBwuAk4POgIAcODXdOZ1JsY5p97jtAVj+K3u/ifNS2sLQmii1DhcBMwPLhtKQION4U2g0lj5gT/cuE4b0YvoSNc66vhrurl6CKUFjgJONyMmin8dhcBh5usPaFufvJOJ6NmimZvGffUrsJvuHDqBQQcbgIODzpCwPBg13QmlRY4CTjcjJop/HYXAYebSboIbTUttNW0MBNj3RfpeWYX8dPd2AM+qu/9S0o2rkZ0ner77qT6vjuZCXtZCY5KP+bIKPaADyMYICv0i1fpe+ElJkbieFc0Urt9G0bAh+5yYgTLMYIBRNdxBMvRjAJ+l9AvXqXvhZeYGInjXdFI7fZtGAEfusuJESzHCAYQXccRLEczCpg01n2Rnmd2ET/djT3go/rev6Rk42omhX7xKn0vvMTESBzvikZqt2/DCPh4L/ayEhyVfsyRUewBH0YwQFboF6/S98JLTIzE8a5opHb7NoyAD93lxAiWYwQDiK7jCJajGQVMKrpqBav+7R+YCd3lxAiWYwQDiK7jCJajGQXMJ/1L72IedMUHeX2wFwQQQAABBJZ5y1he6OeP6cd9HfSOxUAAAQQQQOCWQAMVDg8ztfPkXvYOdDOUHieaHuNo7DKR1Bj17mL+6tgrdMWjxM0UoVScPQPdNHt9HIld4ukzB4mkE4xMJOlODPHaYC+3lNfz5VP72DvQzVB6nGh6jKOxy0RSY9S7i/mrY6/QFY8SN1OEUnH2DHTT7PVxJHaJp88cJJJOMDKRpDsxxGuDvdxSXs+XT+1j70A3Q+lxoukxjsYuE0mNUe8u5q+OvUJXPErcTBFKxdkz0E2z10eV08tMjfeFOPbRHcRP9zAxmiB5OczAy/vwtjbirK5kpsb7Qhz76A7ip3uYGE2QvBxm4OV9eFsbif3mGGe+/C1S4SgTw6Mkzp5ncO9Byrdu5tSOJxh4ZR/paIx0ZIjY4XZSoUHKrl9HPpf//T858+VvkQpHmRgeJXH2PIN7D1K+dTOndjzBwCv7SEdjpCNDxA63kwoN4l5Wy7GP7iB+uoeJ0QTJy2EGXt6Ht7WR2G+OcebL3yIVjjIxPEri7HkG9x6kfOtmNMNOLuN9IY59dAfx0z1MjCZIXg4z8PI+vK2NxH5zjDNf/hapcJSJ4VESZ88zuPcg5Vs3c2rHEwy8so90NEY6MkTscDup0CBl169jNk7+9d8y8Mo+0tEY6cgQscPtpEKDlF2/jvmif+ldzIOueJTXBy+SSzJjcluggT8WUym+0/0WY+YEudwSaKDC4WEmTo9GeK7nKNOdjQ8yOpGiYyTMdP3JOAcHL5Iw00wVn0gRTY1xINLLdGfjg4xOpOgYCTNdfzLOwcGLJMw0U8UnUkRTYxyI9DLd2fggoxMpOkbCTNefjHNboIGZ6n32h8QOtzNd8tIAgQ/dxEz1PvtDYofbmS55aYDBfYcw42NMNTESJxWOEvnVQaaLnzpH5V1b0B0GuXQ89DhmfIypJkbipMJRIr86yHTxU+eYGIkz0n6a6ZKXBhjcdwgzPsZUEyNxjPIyvC3LyKX32R8SO9zOdMlLAwzuO4QZH2OqiZE4qXCUyK8OMl381Dkq79qC7jCYidGTZ+n51r8wXfzUOSrv2oLuMJgPGu8DJ4ZDHIv188fyQm87g6kx5tI7YyPkcyR2mVwGUgkGkglyORK7TD5HYpfJZSCVYCCZIJcjscvkcyR2mVwGUglmI9kXIpdUf5jZSPaFyCXVHybZHyGX2KFj5DPee4l8kv0RcokdOkY+sUPHyCXVHybZHyGX8b4Q+ST7QuSS6g+T7I+QS+zQMfIZ773ETI31XiKf8d5LzBeN94nHO19jIJlgvnXFo7zY285ca/SWkYtd07nRX0cuDe4SGtwl5HJbYAm52DWdG/115NLgLqHBXUIutwWWkItd07nRX0cuDe4SZsPdWAcIIIAAAgjuZfXMhruxDhBAAAEEENzL6nE31gMCCCCAAELg9lsAAQQQQABBsxu4GhaTj7uxHhBAAAEEEAK33wIIIIAAAgia3cD/Z9cDAggggACCe1k97sZ6QAABBBBAcDfWk4+7sQ4QQAABBBDcy+pxN9YDAggggABC4PZbAAEEEEAAQbMbuBoWM1PeK5YAAggggACCZjdwNSxmvmi8Twymxrj/yM/Z3d/FfPl1+AJ/c/yXmEox14IOL3cEm5juntpVtFWvoNpZyFQem517a1fxYP1V2DWdqVYWBWirXsEdwSamu6d2FW3VK6h2FjKVx2bn3tpVPFh/FXZNZ6qVRQHaqldwR7CJ6e6pXUVb9QqqnYVM5bHZubd2FbMRbNuKs24RCCCAgK3QTe32u5mNYNtWnHWLQAABBGyFbmq33039w/egGXYQQACBorUtVN/3EYJtHwQBBBBAoHb73eguB/nUP3wPmmEHAQQQKFrbQvV9HyHY9kEQQAABBGq33031vX+Js24RCCCAgK3QTe32u6l/+B40ww4CCCBQtLYF/22byCfYthVn3SIQQAABW6Gb2u13U//wPWiGHQQQQKBobQvV932EYNsHQQABBBCo3X43usvBTDmqKwm2fRAEEEAAgdrtd6O7HMwXUe9iHuzu7+LrZ97g97HMU8byQj+NnjJ8hou5FEsn6R2LsT98ga54lN/HUytuZmVRgNnYE+rmBxd/i1O3cXdNK2tLgkwaMyd4obedvQPdrCqqYFtNKwGHh0ld8Si/7O8inErQUljOhyob0UWYtCfUzQ8u/hanbuPumlbWlgSZNGZO8EJvO3sHullVVMG2mlYCDg+TuuJRftnfRTiVoKWwnA9VNqKLMOlXAz38ZvAd7JrOtb4a1pYEmTRmTvCTvg664lEChpvbKxsJODzMlpkYp+/Fl4h3dmMEy6m8cwuOYDm/izJNEmcvILqOa0kNWWZinL4XXyLe2Y0RLKfyzi04guVMind20/+zvaT6wxSuuoLKO/8M0XUmhV7ex8Xv/xjd6aTmk3dSsmE1WWZinETXeRzVlRQUF5IV7+ym959/yGhHFxV/cStV225HdJ1JA7/cz+D+N9HsBfhu2kDJhtVMMhPj9L34EvHOboxgOZV3bsERLGdSvLOb3n/+IaMdXVT8xa1Ubbsd0XXei5kYp+/Fl4h3dmMEy6m8cwuOYDmT4p3d9P9sL6n+MIWrrqDyzj9DdJ1JoZf3cfH7P0Z3Oqn55J2UbFhNlpkYJ9F1Hkd1JQXFhUyV7I+QjkRxLalBs9vJCr28j4vf/zG600nNJ++kZMNq5pOodzEPTgyH+Jv23SxE/3TlFhrcJcxUx0iYv+t8jf7kKJMa3CXsbLyWamchP+k7xXPnj5DKmEz608AStjesRxchn46RMH/X+Rr9yVEmNbhL2Nl4LdXOQn7Sd4rnzh8hlTGZ9KeBJWxvWI8uwkI10n6azkefZrwvxCR3Yx1NX92Bs7aK2RhpP03no08z3hdikruxjqav7sBZW0Xfiz+j55vPk0mlmRS4/SaW7HyATDJN56NPMbj/LSbZvG4aHnsA/62bmA0zMU7no08xuP8tJtm8bhoeewD/rZuYayPtp+l89GnG+0JMcjfW0fTVHThrq+h78Wf0fPN5Mqk0kwK338SSnQ+QSabpfPQpBve/xSSb103DYw/gv3UTI+2n6Xz0acb7QkxyN9bR9NUdOGurmC/6l97FPPDaDP714gkWGrumc3/tanTRmIkxc4Id7bsJpeJkRdPjnBgOETA8fO3MAUylyDobH8QmGq1FAXIZMyfY0b6bUCpOVjQ9zonhEAHDw9fOHMBUiqyz8UFsotFaFGAhMhPjtN+3k+TlMFnpyBDDRzuo/PCtzJSZGKf9vp0kL4fJSkeGGD7agSNYzunP/wPKzJAVP3UOrcDGwC9fI7z7AFmZVJrBVw/hu/FqCkqLmKmur36H8O4DZGVSaQZfPYTvxqspKC1irpiJcdrv20nycpisdGSI4aMdOILlnP78P6DMDFnxU+fQCmwM/PI1wrsPkJVJpRl89RAl11zJqc8+SfJymKx0ZIjhox1UfvhW5ovGPHHqNq4qDrLQXO9bjF3TmaljsX4GUgmm64pHeb73OLnsj1wgn2OxfgZSCabrikd5vvc4ueyPXGChir11gmQoAgIIIIBA/HQ3ia4LzFTsrRMkQxEQQAABBOKnu7nw3R+AAAIIIIBAeO8bRPa+AQIIIICAyphEXv0NsxHZ+wYIIIAAAipjEnn1N8yl2FsnSIYiIIAAAgjET3dz4bs/AAEEEEAAgfDeN4jsfQMEEEAAAZUxOff0cyRDERBAAAEE4qe7SXRdYL5ozKNPL1mHU7exUDh1G9tqWpkNU2XIZ8ycIJdUxiQfU2XIZ8ycIJdUxmShUqYJCCCAAAIIIKgJk5lSpgkIIIAAAgggmIkkIIAAAgggZJJplJkBBBBAAAGETCrNbCgzAwgggAACCJlUmrmkTBMQQAABBBBAMBNJQAABBBBAyCTTKDMDCCCAAAIIZiIJCCCAAAIIIKgJk/miMY8Choe/WXI1uvAuBShAAQpQgAIUoAAFKEABClCAAhSgAAUoQAEKUIACFKAABShAAQpQgAIUoAAFKEABClCAAhSgKCqw83+abyBgeJiNlsJyPLYCQAEKUIAiYLi5a9EVgAIUoAAFKNaXVpFPS2E5HlsBoAAFKEARMNzctegKQAEKUIACFOtLq1ioCq9sxuZ1M50jWI5rSQ0zVXhlMzavm+kcwXIWffwOcindtIaSa1aRS+m1VzEbJdesIpfSa69iLhVe2YzN62Y6R7CcRR+/g1xKN62h5JpV5FL7vz+KzetmOkewHNeSGuaL/qV3MY/qXMWsKQ7SlxyhPxkHAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEBA14Q/8dXyd82bWewqYrYcuo1adzGHh/pIKRME/IaLzzdex7qSKkbNFKdGwyCAwKriCj7dcDUFmkYuDt1GrbuYw0N9pJQJAn7Dxecbr2NdSRWjZopTo2EQQGBVcQWfbriaAk1jIdIdBq6GGqIH3iaTSjPJCJTR9MTDGBV+Zkp3GLgaaogeeJtMKs0kI1BG0xMPU7ppDRMjcUZOnCareF0rSx57gOL1Kxk6dJx0ZIhJouvUbd+G7+aNzEbh6uUMHTpOOjLEJNF16rZvw3fzRuaS7jBwNdQQPfA2mVSaSUagjKYnHqZ00xomRuKMnDhNVvG6VpY89gDF61cydOg46cgQk0TXqdu+jcAHb8TVUEP0wNtkUmkmGYEymp54GKPCz3wR9S7+SPqTo5yNR4lPpHg/qHUVU+sqxq7pzJVYOsmJkRC6CCsLK3DqNrL6xkfoHI1Q5fCyzFPG7yOWTnJiJIQuwsrCCpy6jay+8RE6RyNUObws85Tx/4P00DDDRzsQXadoTQu6y8EfIj00zPDRDkTXKVrTgu5ykDXee4mRk104qyvxXNFAljJNRtpPkwoP4V2xDCNQxh9CmSYj7adJhYfwrliGESjjv0t6aJjhox2IrlO0pgXd5SBrvPcSIye7cFZX4rmigSxlmoy0nyYVHsK7YhlGoIys9NAww0c7EF2naE0LusvBfBL1LiwWi2UB0LBYLJYFQsNisVgWCA2LxWJZIDQsFotlgdCwWCyWBULDYrFYFggNi8ViWSA0LBaLZYHQsFgslgVCw2KxWBYIDYvFYlkgNCwWi2WB0LBYLJYFQsNisVgWCA2LxWJZIDQsFotlgdCwWCyWBULDYrFYFggNi8ViWSA0LBaLZYHQsFgslgVCw2KxWBYIDYvFYlkgNCwWi2WB0LBYLJYF4v8B9f2RUjX77nkAAAAASUVORK5CYII='; +let benchmark = 'data:image/png;base64,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'; let sequencer = ImageSequencer({ui: false}); test('overlay module loads correctly', t => { sequencer.loadImages(image); - sequencer.addSteps('colorbar', {}); + sequencer.addSteps('brightness'); sequencer.addSteps('overlay', options); t.equal(sequencer.steps[2].options.name, 'overlay', 'overlay module is getting loaded'); @@ -34,11 +35,11 @@ test('overlay module works correctly', t => { let result = sequencer.steps[2].output.src; - base64Img.imgSync(result, target, 'result'); - base64Img.imgSync(benchmark, target, 'benchmark'); + base64Img.imgSync(result, target, 'overlay-result'); + base64Img.imgSync(benchmark, target, 'overlay-benchmark'); - result = './test_outputs/result.png'; - benchmark = './test_outputs/benchmark.png'; + result = './test_outputs/overlay-result.png'; + benchmark = './test_outputs/overlay-benchmark.png'; looksSame(result, benchmark, function(err, res) { if (err) console.log(err); diff --git a/test/core/modules/rotate.js b/test/core/modules/rotate.js index d02e65c2..72e3f9a9 100644 --- a/test/core/modules/rotate.js +++ b/test/core/modules/rotate.js @@ -2,6 +2,6 @@ const testModule = require('../templates/module-test'), image = require('../images/IS-QR'), options = {rotate: 45}; -benchmark = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAa0AAAGsCAYAAABuCviSAACAAElEQVR4AezBaZCc52Hg9//zHv32PWfPBWAGIDAAKJGCKB6SKImSLcrneju2d7lbzvpqp7zJh3xIbb6kUpt1dpNspXYrm3KysZ2kWeVky8fGG9SuQ8mWLOqAKOoimgRIHMQ509OYq2f6vt7ryTNDEsSQ0+BN9gDP74emaZqmaZp2FzuqoGna+85E07T3VU75hlJUCgqapr1vTDRNe9/klLyCklWKSkFB07T3hYmmae+LnJJXuEVWKSoFBU3T3jMTTdPes5ySV9hFVikqBQVN094TE03T3pOckle4jaxSVAoKmqa9ayaapr1rOSWv8DZklaJSUNA07V0x0TTtXckpeYV3IKsUlYKCpmnvmImmae9YTskrvAtZpagUFDRNe0dMNE17R3JKXuE9yCpFpaCgadrbZqJp2tuWU/IK74OsUlQKCpqmvS0mmqa9LTklr/A+yipFpaCgadpbMtE07S3llLzCByCrFJWCgqZpt2Wiadpt5ZS8wgcoqxSVgoKmaX2ZaJrWV07JK3wIskpRKShomrYrE03TdpVT8gofoqxSVAoKmqa9iYmmaW+SU/IKH4GsUlQKCpqm7WCiadoOOSWv8BHKKkWloKBp2k0mmqbdlFPyCgMgqxSVgoKmadtMNE3bllPyCgMkqxSVgoKmaZhomkZOySsMoKxSVAoKmnaXM9G0u1xOySsMsKxSVAoKmnYXM9G0u1hOySvsAVmlqBQUNO0uZaJpd6mcklfYQ7JKUSkoaNpdyETT7kI5Ja+wB2WVolJQ0LS7jImm3WVySl5hD8sqRaWgoGl3ERNNu4vklLzCHSCrFJWCgqbdJUw07S6RU/IKd5CsUlQKCpp2FzDRtLtATskr3IGySlEpKGjaHc5E0+5wOSWvcAfLKkWloKBpdzATTbuD5ZS8wl0gqxSVgoKm3aFMNO0OlVPyCneRrFJUCgqadgcy0bQ7UE7JK9yFskpRKSho2h3GRNPuMDklr3AXyypFpaCgaXcQE027g+SUvIJGVikqBQVNu0OYaNodIqfkFbSbskpRKSho2h3ARNPuADklr6C9SVYpKgUFTdvjTDRtj8speQWtr6xSVAoKmraHmWjaHpZT8graW8oqRaWgoGl7lImm7VE5Ja+gvW1ZpagUFDRtDzLRtD0op+QVBkzb9XGDkFrbJWIZBKHENASDJKsUlYKCpu0xJpq2x+SUvMIAqXc9LqzWeepcia+du0FhqcKPFjdYqXeJWiZDsQiGEAyKrFJUCgqatoeYaNoeklPyCgPk8nqDU1fX+FffvsDVjSaLlRaL1TYLmy0ul5t859IqU+kYiYhJPGIxKLJKUSkoaNoeYaJpe0ROySsMkItrdb57ZY0/O72AH0r8UPIaCfT8kI4f8Oz1dUbjDkMxm1TUZlBklaJSUNC0PcBE0/aAnJJXGCAX1+qcurrGybNF/FCyK8G2UMKZUoVMMspQzCYVtRkUWaWoFBQ0bcCZaNqAyyl5hQFyca3OqatrnDxTxA8lCPoTbAslnClVyCSjDMVsUlGbQZFVikpBQdMGmImmDbCcklcYIBfX6py6usbJM4v4oeQVAgT9CbaFEs6UKmSSUYZiNqmozaDIKkWloKBpA8pE0wZUTskrDJCLa3VOXV3j5JlF/FCykwBBf4JtoYQzpQqZZJShmE0qajMoskpRKSho2gAy0bQBlFPyCgPk4lqdU1fXOHl2ET+U7E6AoD/BtlDCmVKFTDLKUMwmFbUZFFmlqBQUNG3AmGjagMkpeYUBcnGtxqmr65w8u4gfShD0JRAgwBAg2YVgWyjhTKlCJhllKGaTitoMiqxSVAoKmjZATDRtgOSUvMIAubhe49S1NU6eLeKHkpsEOwxFbQ6NJjk4muRzhzKMJCKkHJuOG+AGITsItoUSzpQqZJJRhmI2qajNoMgqRaWgoGkDwkTTBkROySsMkIvrNU5dXePk2UV8KXmF4CbBtkdmx/jSkUl+99GjfHpunAf2jfLQ7BhfPjqFZRhYhuBGvcMOgm2hhDOlCplklKGYTSpqMyiySlEpKGjaADDRtAGQU/IKA+Tieo1TV9c4eXYRP5RsE7xK8Jpf/sQBHj86zVeOTRMxDeIRi4hlELVNbNPg/pkRkhELyxRc3Wiyg2BbKOFMqUImGWUoZpOK2gyKrFJUCgqa9hEz0bSPWE7JKwyQi+s1Tl1d4+TZRfxQsoPgVYInTszxs8emuXdyiC1CCG4lhGDL/uE48YiFKQRXyk12EGwLJZwpVcgkowzFbFJRm0GRVYpKQUHTPkImmvYRyil5hQFycb3GqatrnHxxET+U7ErAEyfmePzoNHOjSd6OqXSMWMTCFIIr5SY7CLaFEs6UKmSSUYZiNqmozaDIKkWloKBpHxETTfuI5JS8wgC5uF7j1NU1Tr64iB9KEOzqiRNzPH50mrnRJO/EVDpGLGJhCsGVcpMdBNtCCWdKFTLJKEMxm1TUZlBklaJSUNC0j4CJpn0EckpeYYBcXK9x6uoqJ19cxA8lINgm2OGJE3M8Pj/N3GiSd2MqHSMWsTCF4Eq5yQ6CbaGEM6UKmWSUoZhNKmozKLJKUSkoaNqHzETTPmQ5Ja8wQC6u1zh1dZWTLy7ih5LXCbYJtj1xYo7H56eZG03yXkylY8QiFqYQXCk32UGwLZRwplQhk4wyFLNJRW0GRVYpKgUFTfsQmWjahyin5BUGyMX1GqeurXLypUX8UPJmgi1PfHKOx+enmRtN8n6YSseIRSxMIbhSbrKDYFso4UypQiYZZShmk4raDIqsUlQKCpr2ITHRtA9JTskrDJCL6zVOXVvl5IuL+KGknydOHOTx+WnmRpPcTqPnsdLoEIaSatfDMgxs06CfqXSMWMTCFIIr5SY7CLaFEs6UKmSSUYZiNqmozaDIKkWloKBpHwITTfsQ5JS8wgC5uF7j1LVVTr64iB9Ktgne5IkTB3l8fpq5kSS38+9fXOTUtTX+8qUlnr60ygs3Kqw2OlS7HgdHk/QzlY4Ri1iYQnCl3GQHwbZQwplShUwyylDMJhW1GRRZpagUFDTtA2aiaR+wnJJXGCAX12ucurbKyRcX8UPJDoKbnjhxkMfnp5kbSXI7//3fnOHpyys8f6PCRrvHZrvHSr3L2eUq5WaXUq3Np/aP0c9UOkYsYmEKwZVykx0E20IJZ0oVMskoQzGbVNRmUGSVolJQ0LQPkImmfYBySl5hgFxcr3Hq+ionX1rEDyW7EvDEiYM8Pj/N3EiS2/m9v36eZ66v0/ECbhK8SlBu9bi60eBSucEXD0/Sz1Q6RixiYQrBlXKTHQTbQglnShUyyShDMZtU1GZQZJWiUlDQtA+IiaZ9QHJKXmGAXFyvcer6KidfXMAPJQjBbp74xEEen59mbiTJ7fze15/n2YUyuxK8SuCHkmK1zZVygy8dmaKfqXSMWMTCFIIr5SY7CLaFEs6UKmSSUYZiNqmozaDIKkWloKBpHwATTfsA5JS8wgC5uF7j1PVVTr64gB9KbhKCWz3xiYM8Pj/N3EiS2/m9rz/PswtlEPQneJVgy1KtzZVygy8dmaKfqXSMWMTCFIIr5SY7CLaFEs6UKmSSUYZiNqmozaDIKkWloKBp7zMTTXuf5ZS8wgC5uF7j1PVVTr60gC8lbyIEW574xEEen59mbiTJ7fze15/n2YV1QLBN0J/gVYItS7U2V8oNvnRkin6m0jFiEQtTCK6Um+wg2BZKOFOqkElGGYrZpKI2gyKrFJWCgqa9j0w07X2UU/IKA2Sh0uRbV1c4+dICfijZJniTX7l/jp85OsPcSJLb+b2vP8+zC+u8TrBN0J/gVYItS7U2i5UWjx2epJ+pdIxYxMILQhY2W+wg2BZKOFOqkElGGU84JByLQZFVikpBQdPeJyaa9j7JKXmFAeIGIT8srvN/nb6MH0p2ENz0pXum+Mr8DPPjQ9zO73/vPN++soLkjQTbBP0JXiXYUm712Gj1eHh2nH6m0jE6fsBao0ul7bKDYFso4cyNCkfG08yOJDCEYFBklaJSUNC094GJpr0PckpeYcC8XK7xz79zBi+Q7ErAaDzClw5N8dg9U9zON16+wbeurFDteOxOsE3Qn+BVAi8IkUgyCYd9Q3H6OTye4tpmk2vlJqFkJ8G2UMLZG1Uenh1jJB5hkGSVolJQ0LT3yEDT3qOcklcYMG4QcGZlE9s0uJ2ZdJyfOjLN7bRdn4Vqi8VqCwR9SG4S9CdQJFsurTdY2GzhByH9hFLylWPTjCUddiXYZhmCaxtN/DBk0OSVnIKmvUcGmvYe5JS8wgASCBaqTTqeD4JdmUIQsy0Et1ftulzdbHCToA/JTYL+BIpky/VKi3rPox9DCGK2iRCCvgTUuh7nVmsIBIMor+QUNO09MNC0dymn5BUGVLXbwwtDQikBCYI3CaQkk4himwb9SClJRmx6fsAOgj4kNwn6EyCReEFIMmJxO1HbZG4kDoK+QiSJiEXXDxhUeSWnoGnvkoGmvQs5Ja8wwKKWRdQyeZ0EwQ4CWG602ey49COEoBcEIHkzQR+SmwR9WaYgFbXwQsnttF2fasdjm2BXhhCkohYx22SQ5ZWcgqa9Cwaa9g7llLzCgIvZJhOJGImIxeskCG6SwI16Gz8IuZ2oZfKp/WNYhuBNBH1IbhLsyjIM7p8ewTEN+gmlpOsHrDU7gGSb4E0mU1EmkjH2grySU9C0d8hE096BnJJX2AMMIZhKxfjx0jrVrssOQvAaUwj8MOTY+BCOZbIbxzKpdHq8tFal7Qa8ieA2BNsEO5hC8Kn9ozx8YJypdIx+al2PPzl9ncvrDQIpeYUAwQ7HJtP8/U/NEbFM9oKsUlQKCpr2Nplo2tuUU/IKe8xIzOHqZoOG67GDEGzpBSFbJpIxMokolmmwm4MjSTqez5nlCrsS3IZgm+CmVNQm+/EDPHpogn5aPZ9nrq3zo4Uy5VaPnQQIth0cTfBf/vTHGIlHEEKwV2SVolJQ0LS3wUTT3oacklfYYyKmSdQySTk2S/UWTddnByHYUm738IKA/UNxUo6NZRjs5hPTo4RScnalyq4EtyHYJtj2xImD/Mon5uin5foUSpt8/eINzq/W2Z1gdjTOb3/6MAeGE0Rtk36CUCIlGEIwSLJKUSkoaNpbMNG0t5BT8gp7VMqxSTsR0o7NUr1F0/XZQQi2FGttmq7HTCpOyrGxDIPdfHJmlFBKzq5U2ZXgNgRbfu1Th/iNhw7TT8v1KSxt8tT5EoVSBQS7mh1JkPv0YY5PpBmKRejnwmqdZ6+Vea64yZZ4xMKxTAZFVikqBQVNuw0TTbuNnJJX2ONSjk3aiZB2bJbqLZquzw5CsGWx2qLpesyk4qQcG8sw2M0nZ0YJpeTsSpVdCfr6tQfu4TcfOkw/LdenUNrgqfMlTi9VuEmww+xInNynj3B8Is1I3KGf54ob/Ld/dZazN6q8tFLlGxdXmEzFmB6KEbEMBkVWKSoFBU3rw0TT+sgpeYU7RMqxSTsR0o7NUr1F0/XZQQi2LFZbNF2PmVSclGNjGQa7+eTMKKGUnF2psivBm/zaA4f4zYeO0E/L9SmUNnjqfInTpU1eIbhJsG12JE7u00c4PpFmJO7Qz2Klxe9/5yLrzS5dP8QLJKGUvLRS5cEDo4wnHIQQDIqsUlQKCpq2CxNN20VOySvcYVKOTdqJkHZsluotmq7PDkKwZbHaoul6zKTipBwbyzDYzSdnRpESLpSrIEHyBgIMA5IRi7/3yYP8xoNH6Kfl+hRKGzx1vsTppU22CV4leM3sSJzcp49wfCLNSNyhnzCUtFyfb768Qq3rsU2wzbEMjk2mOTAcxzQMBklWKSoFBU17AxNNe4OcklcYIH4Y0nQ9un5AxDQQQvBupRybtBMh7dgs1Vs0XZ8dhGDLYrVF0/WYScVJOTaWYbCbEzOjxG2LthvQ6HmEUiIBAUQtk+MTw/ytew/wxIlD9NNyfQqlDZ46X+L00iY7CF4lmB2Ok/v0EY5PpBmJO/TT7Pl4oeTaZpPvXlmj4wXcJMALQh47PMnhTIpBlFWKSkFB025homm3yCl5hQGyUG3w3I0N/s2Zy/zkRpleEJCK2CQjNu9WyrFJOxHSjs1SvUXT9dlBCLYsVls0XY+ZVJyUY2MZBrs5PjHEVCrGiekRRuIOB0eSHBlP8Sv3z/HoXIbH7pmin5brUyht8NT5EqeXNtmVgNmRBLlPH+H4RJqRuEM/L5Qq/MXzi3zj4godz6fa8ah0XG71hcMTfO6eDKNxh0GVVYpKQUHTXmWiaa/KKXmFAbLZ6fL0tWX+99MXWG50WKq3+P7iGiNRh0MjKSKmybuVcmzSToS0Y7NUb9F0fXYQgi2L1RZN12MmFSfl2FiGwW6mUjH2DyW4b2qYLx6e4r6pEQ6NpphOx+mn5foUShs8db7E6dImCHY1O5wg98gRjk+kGYk79HO6uME//trzLFTaLNXanFutYwg4NJbEFALHNvny0Sk+MzfOJ/ePMuiySlEpKGiaYqJpSk7JKwyYq5UG//rH5+n6ARKQvOJatcH9k6NMJmO8FynHJu1ESDs2S/UWTddnByHYslht0XQ9ZlJxUo6NZRjsxjQEEctki2OZmIagn5brUyht8NT5JU6XNgHBNsEOs8MJco8c4fhEmpG4Qz/lVo8/fe4ai9U2XhAi2SLoeAGPH5viHzx0iC8fneLBA6PcOzXEXpFVikpBQbvrmWh3vZySVxgwfhhSrLX4UWmdjh9wk4BExOJzByYZj0cxDMF7kXJs0k6EtGOzVG/RdH12EIIti9UWTddjJhUn5dhYhsG71XJ9CqUNnjq/xOnSJq8TbBNsmx1OkHvkCMcn0ozEHfqRUhIxDb55aYWlaptbWYZB2rH58tFpptMxEhGLvSarFJWCgnZXM9HuajklrzBA2p7PaqtDud1jo9Pluwsr+KHkVo5lcmQsjWOZ1LouiYiNKQS7ubRRo+sHdL2ARMRmNynHJu1ESDs2S/UWTddnByHYslht0XQ9ZlJxUo6NZRi8Uy3Xp1Da4KkLS5wubfJmgi2zIwlyjxzh+ESakbhDP8v1DpWOy5Vyk4XNJqVaBym5KZSSx49N88D+EYQQ7FVZpagUFLS7lol218opeYUBcr3a4JniKv/Lj17i+0trrLU69IKQlutjCoEQAgkMOxE6XsBfnLvGMwurbBmORkg5Nrf6F8+c5emry3zjSomzaxUmElEmkzF2k3Js0k6EtGOzVG/RdH12EIIti9UWTddjJhUn5dhYhsHb1XJ9CqUNnrqwxOnSJv3MDifJPXKE4xNpRuIO/TxX3OD3T13gm5dWKFZblOodWq6PZRpIKZHAZ+bGefTQODNDcfa6rFJUCgraXclEuyvllLzCAOl4Pt9bXOX/KJyn4XrUey43Gm0StsXnZidJ2BYHh1McSCfY7Pa4UK7R8nzqrsdPSmX2peMcHk1jCsGWf/nMWb55tcRaq0u161Lp9LhQrnF8fJjRuMNuUo5N2omQdmyW6i2ars8OQrBlsdqi6XrMpOKkHBvLMHgrLdenUNrgqQtLnC5tsk3wJrPDCXKPzHM8k2Yk7tDP2eUK/+SvX6Dc7lHreCzXOxgCZkcS3D89zFDM5vGjM3z24DgPzY5zp8gqRaWgoN11TLS7Tk7JKwyY1VaHPzp9nmrX5VZtL+BLc9P81ieP8uiBSVquz3cXV3ijWtflxOQYQ9EIlzbqfO3SEhudHtsE+KFEIPjE1ChTqRiGEOwm5diknQhpx2ap3qLp+uwgBFsWqy2arsdMKk4yYmGZBv00ex7PL2/y1IUlTpc22UFw0+xwgtwj8xzPpBmJO/TT8XyevV7m7EoFLwh5haDrhxwZT/EPHrqHrxyb4eNTQxwcS3KnySpFpaCg3VUstLtKTskrDJgglCRsiyEnwhItbmWbghCwTQOBYLXVIWIauEHITQJs02QsESUIJT3fZ6HaYAcBbc/nRqONKQShlBhCsJuZdJyH92fYcvLcAsuNDq+TIARI+N71NYJQ8jPz+7h/aoSUY7NFSokQAiklmx2Xb11Z5oeLZc4sV9iVgNnhBLmH5zmeSTMSd7idmG1R7bj0/IBtApASgeBSuY4A0lGb25FS8hohBHtNXkF5UkG7a5hod42cklcYIOV2l6uVOi+sbnC91uRatc5mu4fkdUIIDqQTGEKwWG/S8nzOrGxyq5hlciwzzEanS7ndY6XZwQtClpsdbjUad3js4BQvrFRouB5uEDISc9hNyrFJOxHSjs1SvUXT9dlBCLYs1dqst7osVJukHZuuF+BLybXNJguVFn98+grPlTa4vFEHIdjN7HCC3MPzHM+kGYk7vBXXD+j5IZfLDRo9j22CbT9zbIZPz43jWCb9hFLy0nKN86t1Vhtdul7AaMJhr8kqRaWgoN0VBNpdIafkFQZIsd7kmcUV/vSlK5iGYDwWxQsl9Z6LIQRdL6AXBIzHo4zGHBaqDUzDYCoRp95z2Wj3cCyTmGWSdGxaro9jmtR7LmEoGYk5bLnR6OCYBinHxjFNmq7HFsc0GY5G+IcPH+f+yVH6uVFv8+OldU6eW2C50WEnAZJtcdvEsUyGYxGGoxFK9TYd16frh3hByOsESG6aHU6Qe3ie45k0I3GHt+tGrc2fFq5xfrXGWrNLLwj53MEJHp+f5tFDGfoJQ8mfP79AYWmTS+sN/FDy+UMZPndPhs/fM8Fe9DvKkwraHc9Eu+PllLzCAPHDkMJKmT947jxuEOIGIdWei2UI7p8Y49H9k9w3McrHMsPUuy4XN2oEUuKFIZVuj+lUnF+99xAHh5J8fnaK1WaHUr1FrefhhSF+KGl5Pg9Mj5M9PsuhkRSP7Mvww9I69Z5HLwhpuT4d32et1ePe8SFSToTdpBybtBMh7dgs1Vs0XZ8dhGCLF0q6fkC147LS6NByfdwgJJSSNxGCLbPDCXIPz3M8k2Yk7vBOpKI2h0ZTHBxNMpWO8ZX5aR6ZHeehA2P0I6Xk7HKFr50vcXa5iheGBBKubbaI2SZHxlMkIhZ7TVYpKgUF7Y5mod3RckpeYcC0XJ8flNYIZMgrBFsqXRfLEPztY3PELJMf31jn3750lTdaaXaYSSf45XsP0nJ9nlvewAslNwlAQNqx+dzsJOmIzb87f50gDLlJQNsLWG60CQEpJUIIdjOTjvPw/gxbTp5bYLnR4XUShABJfwKQ3EIyO5Ik99A8xzNpRuIO78Z0OsZkMsqjBzNIwBCCt1Kstjm3WuN1EhA8e73Mz987QyYZZS/KKyhPKmh3LAPtjpVT8goDJAhD2p5P1DJJOzYSRaBItgig4Xq0PZ8tcdsik4jyRmnHZjIRpe35NF2PUqOFIdghlJJQStKRCKZhMBx1aHsBOwgwBNyotwmkpOcH9DOTjvPw/gy//LE5plMxdpIguD3BTbPDCXIPHeF4Js1I3OG9MAyBEAJDCPqRUtLzA+pdj5Rjk3RsdpJMpaIMxyK0XJ+eH7AX5ZWcgnbHMtHuSDklrzBAFmtNXixv8rUrRX54Yw0pYbXVpheEIHiV4O/ce4gTU2NYhkEoJd9fWqXadXlN1DLZl4qzWG9xvdpgodYikJLFWotbHRpO8YtHDzCVimEaBg3XY63VZbXZ4VaJiM3scJK/vrTEarOLIWA8EWU3Kccm7URIOzZL9RZN12cHIbgtAbPDCXIPzXM8M8RI3OGDFoaS715d4/vX1jm/WuPCWp2VRgc3CHlNPGIykYyxVO3w4nKV1UaXrh8ylY6x12SVolJQ0O44JtodJ6fkFQbIaqvNtxdu8Aenz3GpUuN6tcHlao3JRIzJRIwglCDg1++f57HZaZIRmy0pJ8LRsWHOlSskbItkxCYTj1JqtCk1WrywssHZ9Qo9P2QsHqXV8xiNRzk4nOTRA5M8tC9D2omwZSoZxwsCTCEo1luMxx2GnAgS+MHSOhc3alws1/hhaZ350SEmkjF2k3Js0k6EtGOzVG/RdH12EIJ+ZocS5B6a53hmiJG4wwctlJJ/d3aBr19c5tuXV3lxpUrL9TGFIGqbpByb8YRDOmqzUGmxWG3z0kqNHy9u0PUCHNtk/3CcvSarFJWCgnZHMdHuKDklrzBAQim5uFHjD06foxcEhBICKQklxG2L3InjfOHAND93+ACfn50i7US41Vg8ysMzGe7NjPDY3BSNnsflSp22FyABCbQ8j49lRvjdB4/z6f0T/PyRA9w3McpYPMqtjo4NMTuU4Atzkzw4k2E0HuX0jTIdP0ACPT8klCCE4Pj4EFHLZDcpxybtREg7Nkv1Fk3XZwcheKPZoQS5h+Y5nhliJO7wQZNScqPW4f87t8SZlQqvELRcn+FYhF+4dz9/+779PLh/jI1Wj4VKi44XIJGAYLHaZiIV5dhEGts02GuySlEpKGh3DAvtjpFT8goDxgtCVlsdQPJGpiHIxKMcGk5jCEE/U8k4k4kYEji9XKbrB7zRervLeDzKPSNpbuee0TRbWq7Pf7i4gBuE3CSg7fks1pqYhuB2ZtJxHt6fYctfXihSrLV4nQQhQLJtbjjBbz84z/HMECNxhw+DEIL1VpfL5QbbBCAlILhR7zAcszkxM0IQSr5zZRU3CHmdBAQXVus0ez7xiMVelFdQnlTQ7ggG2h0hp+QVBpBjmdiGQSAlb9QLQtbaXdZaHeo9Fz8M6edGs02p3iKQkoRt8Uaj0QgzqThvV8Q0OD4+TCAltzINwf50gq4f8FZm0nE+NzfJP/r8fdybGWIiEcUyBKYQGAKm0zE+PjnMP/rCfXxscpiRuEM/5VaXWtdlpdHh/SCl5MBwgql0lJsEimQyGWUkFsEPJS3XxzIFEdNgJ8lYIoJtGqzUO9Q6HntRXskpaHcEE23Pyyl5hQElpSQRsal2e1yrNhCA4BVDTgQvCHnqyiI/KK2SiceImiYx2+JWv/+jF/nOwjLPLZdZbXXY6PSQSELJtrmhJD99aIa54RQR0+TtMA1BteOy3u5SbvcQgCkEIzGHnzo0zYmpMd6OeMRiNObwhYNTTKdjzI8N8bHJYU5MjfDFQ9P8xyfuYTIZI2Zb9HO6tMEfP3eZr79c4tpmk3rXZX48zXshhKDjBaw1e2y2e7Rcny0Jx+LASIKfOz7DcCxC1DaxDMF3rq4igFCyLeVYjMUd/urCDb53bZ2NlkvbDZgdSbDXZJWiUlDQ9jQTbU/LKXmFASaEIGaZjMWipJ0IXhiSjkQ4kE7S9DxeWNtgvd1lpdnm9OoGn5gcZTwWxRCCLf/8mQJPX79Bsd6i1GjT8QNGYxFmUnH2pRMcGk7xxYPTfGbfBKOxKO/EwZEUhhCMRh2qPZeHZsb5mcP7+IWjB3gnDCFwLJPZ4ST3ZoaZH0tzYnqMgyNJHMvEEIJ+Xlje5L/6q+dYaXRYbXZZqDS5stkk7djcM5bivYhHLCZTUUIJMctkKhXjSCbFbz98hAMjCV4zMxRnPpNmvdljLB5hPpMm4VgUShXWml3KLZeXVmpsGU84ZJJR9pqsUlQKCtqeJdD2rJySV9gjAikJwpByu4cbBHxzocSfn7vCG31u/yT/xSOfIO1EeG55nf/5R2dZbXYAwWvmhpL85ieOcnRsiLhtYQhB3LZ4t+pdl5bn45gmo3GHD0uz5/FvClf46sUlekEIkm2WIfjKkX38ziPzpByb96rZ8wilxA8llmGQjtrsptzqIiU0ez7/4zdf4tpmk9cJBPCfP3aMnz02jWUa7EW/ozypoO1JFtqelFPyCnuIKQSGYTCdjFHtuaw0OxgCQsmbxGwLKSUtz6fc7oIApAQEW8rtLqGUTCRivBUpJa8RQrCbdDRCOhrh7QilxBCC9yqUEts02Gj3cIOQbQKQEErJxXINNwgJpcQQgvci6dhIKdkihKCf8USUMJRYhoFjGewksQyDetejF4SYhkAIwe2EUmIIwSDJKyhPKmh7jom25+SUvMIedK3WoNRs0QsCrlTrXK7UuVXMMvl4ZpTjY8M4lokfhlyrNlhvd0HwKsHhkTTZYwdJRCyEEPSzWGtS67lc3qwjgWTERgjBO9XzA9qeT2F5Ay+UNF2PoWiEd+t6pUG51eOltRoR0+D8eg0/lGwTICV8dnaClGPT6PmUWz3GE1HerZbrcWGtzmK1xVDURgKWYXCretdlo9Xj5XKDa5tNrm42KTe7SF5nGoK5kSSZZJQbtQ5eEJKO2uzmhVKFcrNHq+cRsy0s02BQZJWiUlDQ9hQLbU/JKXmFPegvL13n9GqZl9Y3MYRgfzpB2rGp9zxMIUjYFsNRh8cOTDMSddgymYxz/8QoLc/jeq2JEHBwKMln90/gWCaGEPTz3PI637p2g7NrFXpBwH0Tozw4Nc7PHtmPIQRvV88PeHGtwl9dXuLcWhXbMJhIRPn1Tx7h/slR3qnnSmX+6EcX6foBSIEQMBKLUO24eGGIH0rSUZsL61WeXVzDEIJ9Qwm+dGiKX7x3P+9UtePyL779EmvNLl0/IBN3+N3PHmV2OEE8YrHlRr3NC6UKf/HCIm3PZzIZo9p1idomSOj5IYGUxG2T65tN/puvvUAQSj4zN86DB0b54pFJbvVHz1zi+VKFStvFMgS/9cg9PHBglLGEw6DIKyhPKmh7hom2Z+SUvMIedHZtg69eXeSHN9boBgEdP2Ct1eH42DCf3TfJwaEUD0yN86vH7+H+iVFe45gmh4ZTpJwIB9IJ5seG+Mqh/Tw8M8F4PEo/y802/+HiAs8UV9ns9uj4AQu1JiCYScUZizkIIXgrUkoarsefnL3KdxdWaHs+jZ5HretytdLk45lhhqIR3q4L61X+2dPPs9Hu0XB9Wq5P0/UZizv8yn1zxG2bLxyapOcHXCjX6XoBHS+g3OpSrLeZTMbYP5Tg7Wq5Hv/Td89RKG1S6bi0XJ/1Zo/rm02+eHgSxzTwQ8nL63X+8NmXWWt26Xgh5VaPqGUyP57iwQNjHBpLcng8hZTw4kqVjhfQ80OubDRxLJMDw3GGYhG2/Mlz1/h/XyhSbvXoegFtN+C54ib3z4wwPRRDCMGgyCpFpaCg7QkW2p6QU/IKe1AQSm602hRWy9xKAqVGi3/4wMeYTScJpCRmWbzRcNThywf3YRqCLUEosU2D22m5HmfWNml5PrcqrJR59MAER8eGELw1IQRnVjd5fmWDmwR0/IBKp0e153JASoQQvBU/CFmsttgSSMk2IdgShJLjmWF+4dh+lhsdnrm+yjYBSAikZL3ZoVRrEcpxDCF4K1JKlqptSrU2XhgCgm0Crm82+cFCma/MT+P6Id+5skql44IApAQE5VaP+6eH+eX7ZxmORXjhxib/w+VVpORVEhB8/9o6PzU/yYHhOLWOx+X1Jm4Qsk0AEvxA8oPr69w7mSYVtRkkeQXlSQVt4BloAy+n5BX2KF+G2IZB3LZ4o7QTYSgSwTIMYpZFP6Yh2BKEEssQ9OMFIV4QEkpJzLJ4I0NAzLZoez5BGCKl5K04lkmj57GDgEBKNts93o6eH2AYgnKrix+GvE6yZbXdwTIEMdsi7dgYQnCTYJshBJvtHl4Q8laCUBJISa3r0XJ9XiF5TS8M8cOQQEpitoltGtwkUCQCaPQ8JBLDAMcySTgWO0kSjkXSsel4AW3PZ6nWwhC8TkCIJAgl8YjFIMorOQVt4FloAy2n5BX2MMc0GXIi2IYBApBsc0yTEcfBDUMMIehno92l6Xk8W1rFEIKHpjOMxaIMORFudb5codp1Waw12eKFIbcyBEyn4vzkxhpN18MPJPNjaY6PD2MIQT/D0QgP7x/nR0tlbjUUjXBiahQhBLdzbq1KsdZis9NjJO5gCMFOkq8c2c9Y3GFLKCX3T41wo9Gm4wVsE+AGIQ/uH8exTG6n3nX53vU16l2PfekYiYjFRrvHKyQgmExGCaXkL84s4AUhwzGbRMSi5fpsEyCl5L7pETLJKIYQJCIWQghuZRuCTNLh6ZdX2DcUx7EM9g3FWdhsc6uJVJSH58bxghDTMBlEeQXlSQVtYJloAyun5BXuADPJBHHb4sJGFds0GHIijMej/Mb9xzg2Nkw/tZ7L86tl/vVzL/FsaY2za5t8f2mVg0NJRqMOEdNky/MrZU5euM6/v7jAj5fXKdVb9IKAiGmSitgEYch0Mk6951JqtHl2aY2fLK+z0enR80MOj6YRQrCb8XiUtufjBSHLzQ5Djs3scJLfffAYM6k4lmHQz09KZf7Zt5/nuVKZwvImL5drJCI2phDYpoEbhHzh4CSPzk1wPDPMlkTERgAtz6fe9XAsAyT8J48c46F94ziWST/Vjss/+cbzfO/6Gs8tlfnJ0gYJx8Y2DVw/IJSwLx3HMk2eubbG2eUK59fqXFitsy8dJ2abuEGIAH7pvgP8rY/tJxGxEEIwGneYTscolDaJ2xaOZTCRjLLa7FCsdPj+9XV+tLhBKMGxDLpeQDxiMZWK8vnDEzywb4TxpMMgyypFpaCgDSSBNpBySl7hDvPCWpmNTo+YZTGZiHHPcJp+pJSst7v80+89x8ubNW41m07y333xYaaScRquy5+/dJWvXl6k6fq8ZjTq8MhMhvsnx7ANwflyla9fWaLl+dzqpw/O8FufPMpUMs7tnFursN7u4gYhn5oZJ26ZxGyLforVJr/3ree5UW8RSm6aSsb4jU8ewQ8lCcdiJhXnntEUb3R1s8FGq0ut6zEzFOfgcJJ4xKKfrhfwhz+4wN9cWsYLJa+JWiZ//8QhRmIRDEPgByH/5w8v0fICbpJwYCjOf/roMSrtHgnH4oF9Y0RMA9MQ3OrltTo36h1MIfjhQpnvXVuj4wW8QrDlscMTPLR/lC0Hx5IMx2wmUzH2it9RnlTQBo6FNnBySl7hDnRiYhwpJaEE0xDcjgRe3qyx3GzzRrWey/Vag0w8ShBKzpU3aXoerxBs2ez2EELwmX0TJCIWTdfHC0Pe6Hy5ynq7y1Qyzu18bGKELUEoMQQIIehHSknL8/HDkECyTfCKes+l4Xr80vFZTEPQzz2jKe4ZTeGHIZZhcDtSStqez0bbxQslt+r5AUv1Fv/RfQcwDYOvnl/CDQJAAoJtAkIgHjF5cP80QgiklAgheKOjE2kOj6eQSK5tNuh4Aa+TgGCp2ubXHzrE/uE4Wwwh2EvyCsqTCtpAMdAGSk7JKwwQLwiodHsEoaTj+/TTcF02O12klIRS0k+t59JwXd6KIQSmEHhhyBsZQhBKiSEEMdtiMhFnm0CRbDGFYDgaodzp0uh5+GFIwrZ5IyFgOBphvdWl6/tIKdlNx/Pxw5Bqt4ekv2rXZUu53SURsXiN5BVtL2A05mAagtuRUtJyfaodl1BKQinZjesHtFyf1WYHxzIQ7CSBlGMTSIkfhnhBiBCCV0he44chAhBCsEUIQT+1rstGq4cQgnjEZCdJPGIxkYxSabt0vYB+mj2PIJRUOy5BKBkkeSWnoA0UC21g5JS8wgBZqDe4XKny/eVVbEPwyNQkh4eHmEunuNV3ije4VKmy2uowEnX41aP3kIpEiNsWt3ry7HlWWx2Sts1sOkl2/hD9SCk5NjbEYwem+fq1JW51YnKMT02NI4RASjgykubiRpWlRgsEGEAmHuX0Splq18UNA4JQ4ssQAUheYRmC6WScP37+ZYQwyMSj3D8xwqf3T2AIwWtuNNo8t7zO+fUqQSh5YHqcT02PMZGIcavC8gbfvrZMx/PJJGJUOy6GgFCyTQKPzU0ymYpxO2EoefrqMhfWa7Rcj8lkjJ8/up+RuEPENHhNtePyZy9cZbPTYzQWpVhrYVkC35dIXpGMWHS8gH916hwC2J9OELVM3CDkFRIQfP6eCY6Mp3krf3r6OjdqbRBQabtIwBAQSrY5lsFE0uFffuscWw6OJjk2kebh2TFudWm9wbmVKueW62z50vwkRzIpMkmHQZFXUJ5U0AaCiTYQckpeYYBsdLqcKi3zhy+8xLVanWu1BpcqNQwh2J9KELdttvzNQpGvXl3k6YUSC/UGL1eqXKs1+Mz0JI5lIoRgyz995if8zfUlrlTqvLxZZaHWoOsH3D8xxm6EENimwXA0gmOarLY7jEYdvnBgir937xFSjo1pGFiGwXQyjheGOJZJ1ws4OjZEw/VYbna4tFnnaqVBrefiWCZTiRiZRIyoZXFkNM2lzRovb9ZZqDU4V67QdH0ipsnsUAIhBBvtLn/24hWevrbMC6ubLFSb/KC4xmjM4Z7RFLZhsKWwvMF//c2fcK3S5GqlwfVqk5RjMRx12JeK0/EDvnJkH4/OTvCpmTH6CaXk5PkFvn6pxPcX17lWafLSapVax+OBmTEipoEQglrX5R9/4zQ/XipzdaPJ5Y06EcsiFbGZTEURwNHxNHHH4idLGyxUWixWW1xcrzOVijGZjGKbBo5l8ksf288v3rufdNRGCEE//9szFzn54iIvrze4stGkF4TEbZPJdIzhWISxRIS5kSSnlza5utFkodLmzI0qXiBJORbT6RhbFist/u3pBb758grnV+ssbLb4/rV1Do0n2T8UwzQMBkVWKSoFBe0jZ6J95HJKXmGASCm5Xm/wvxbO0vF9XtPyPFqex2dmpklHbGquy9OLS3x36QYIwRYJrLTamIbBg1MZtjy9sMTXri7S8nxe0/J8/DBkfnSYkajDbgwhGItFeWByjE9NZXhsdoafOzxLKmJjmyavidkW86NDPDIzwWf3TzKZjHN+o0Kl4yJ5RdcPGI5G+MX5Of7ux+/hSwdnuFapc65c5VY3mm3G41HuzQwTMU0Wqk2+ernIQq3JrS6Wa3xicozJZIxq1+X/fuEypXobLwxBgBeEbPny4X38nY8f5PHDM3z2wATHMkPczlqry9cvlzh9Y4NXCJBwrdIkk4hyfGIYPwz52oUlvr+4RscP2BJK6Hg+904M83fvn+Pnju3jxPQo37y8TKPn85pQSkIp+c8ePc6X56f58vw0P3V4mpRjYwhBP6eXNvh/zixQ73m8QtDxAibTUbIfP8Cvnpjly/PT/HChzGKlxesEi5UWB0cTHB5LYQjB/88enMZYeh0Gen7P+fa71r239q27em9u4iaKoiiKWix5HdpxMnIc2zNuz5LJvyBAgADzx5M/ATJIBoh3oDiYSWDAY1mS5ciSJYqiSJGSuDWb3c3eu/a97r5+2zm5t9vVrC51UZRIScWgnufSRo2vvbXMRtMHwQ2x1syUyzwylSfruOwlT3UtdJ3uYt/Plcm+n6tTXdNd7DFKayp+QIxip1Knw3K9wUQqSSeKma81uEmDEKC5oR4EREohhaAehFQDn53maw3aYcQ7MaRECsGxfJYtQkp2SlgmnmmQc206UUy546OFBk2XoGez5YOAkVSCIFYo7myp3qQVRqRsi5VGi81Wh9sIMKSgHUVordFaU277hEpxi4BmGLFUazKZTWEbEiEEu9FaI4Sg7ocsVVu8TYMQCKDuhyilUVpT6QS0wogbBKAh1prFWpPRbILRTIJLGzVixQ8J4phis8MDo3lMKegRQvBOWkFEselzgwC0BgSrtTYpx2Q0m6DpR2g0t9OAYKnawo9jbFOyUG5R7YTcIgANCo0fRyitkUKwl0x30fV0F/t+biT7fm5OdU13sQcZUmIIQc5x2MmPYpKWhRCCoYRHwXN5mwYBadsi6zj4UUysNJOZNIOJBAhuc6gvzYG+NFpr3sl6q02p47NYb1Js++xmplJnodZAac1kJsUNgi5NT9IymcqmEdxkGxLPMthOCkE7ipBCcHGzgiUl1U7ATsPpBKYh6RHAsUKWnWKtGc8kuFauUfVDVhst7kRpzUazw8WNKmnbItaa22kKCYekYxJphdIwmUuRtExuEdxwpJAmn3AQ9GgyrsVOWkMziFittym1AkqtgHcSK81oNsFUPsUtgi5NxrWZzCW5uF7jWrGOaUgsQ7CdKSHlWGQcCykEQ2mXdhhzGwFjeZuFzhrloM5yu0igIvaS6a5TXez7uTHY93Nxqmu6iz1sPJ1iodFgtlYjVhpDCDTw3911jMfHRjGlJFSKAc9jtl5js92hJ2laFBIuv3nsMGPpFIYUBHHMerNNxffpxDE9k5kUn5gYY6ovg2ua7ObVlXX+4foif3XhKt+aXaQehiitGUsn2e6vL1zji5dmeGZ2iR8sr2MKSTuKCJUCARnH5hMHRrhnKE/ec7EMyVDS4/tL6wSxItaaHtuQjKYTPDe7wjevL7HSaCGFoO6HSAEayLk2D47289TxAwghcC2TSieg0vHZaPlIIdBA3nOo+SHPzqzw3blVLmxUKCQchlIeW5TSfOnCHF+9vMhXLy3w2vImScuk3PaJtaYnbZtMZpP85t0HyXkOppS0w4hiy6fYCgiVoufoQIZPTA1xKJ/GNCQDSZeqH3Bpo4rSIARoIGmbmIbky+fn+e7sGu0oxpSSwZTLnUghiJRmvdGh3A5oBhE9nm0wnPb4ztU1nr++zrVig0onpBVECASx1vTcN5rjDx49jGeZCCHwLINYKS6t15ECNNCfdGiFMet6ie9UXuG7GxdIWwlSpkvCdNgrnupa6Drdxb6fOYN9P3Onuqa7+AB4ZHgICeQ9l4xt81vHj/DkxBgZx6bHkBJLSk7k8wgBw8kEdxVy/NMTR7l3oMCWPtdhIOGSsR3StsWJQh+fPjjOh0cG6fdcdjNXrfOVK3O8sLDCeqtNLQi5UqrimAajqSRZx6bn767M8fSZS6w2WlT8gKofUO74fGxihOOFPvKew2cPjfORsSGO5rNsyXkO9w0V8KOYyWyKoaTHcMrjwmaFxVqTehCy0miRtCw+PDpA0rZ4cKSfD48NcOr+Ywgh2HI4n8E2DYZTHhr46MQgzSDicrFGPQgptnw2mx0ubla5azBHznPQWvPszArfuLLEGysl6kHIRrNDIwj58Fg/I+kER/uz3D2U47c/dJiJvhRbBlMeWdcmn3BwTYOHxgp84tAIH5noJ2lbbLl3OEfasUjaJvmEw8FcCgScWS5R80NKrYDZUoOEZTLRlyBhm9xJ0jYZyXikbItcwmY0m+CBsTyvL5ZYq3eo+xFr9Q6GEAynPe4eyTKRS/Kh0Rz/8tGjJG0T2zToSTom/SmXsaxHO4p5eKKAAJabVUqJy1RUlWrU4vXSVY5nxhn18ggh2Cue6lroOt3Fvp8pk30/U6e6prv4APmtE8dohiF+FJNzHYQQbNfnOiRti/+xcD+dKCKIFRnHZqfj+Rzj6RSWlBhSEsYxrmmyG6U1tSDg7EaRVhSxJVSK7y6s8KkDY4xpTbnj8/rqBqFSaG5nSsG/fvAkSmtMKfFMk50O5zL8qwdPYpuSzVaH//D9szSCiO02Wh1+NZ/hXzx4nIxrY0uJEIKdPjU1yscnh6kFIcu1Jt+dX+UWAe0optYJWag2mOpL0QpjrhVrXNys0iO4qRFEKOB/+vi9OIYkVIqUbbHTA6MFjvVnUVqTsExirbENyU6/enKCj08NEUSK82sV/o8XzqN5W80P+f78Bp87PorWGiEEdzLRl6SQcHBMg1gp/tOr12kEEQhAa0Cw2fSZKqR46p4JpvIpXMsgVhpDCrY7VEgxlU/y5JEhlNb85WuzXIvL4LRBcEOsFc+svcGJzDhZK8leMt1F19Nd7PuZMdn3M3Oqa7qLDyDPNHEMAyEEd2JJSY9rmrgmu/JMkx4BOIbBbmKlUBo6UUykFTtpIIoVWkOsNcW2j9aa7WKt0VojhcAxDAwh2E3asdBaozUEseKHaSKtyDg2tpQIIdiNZUgKnsNao4XW3E5AJ44ptwN6OlFMO4rZogHBTVpr0BrbkJhSshvPMlBaIwVIIdhNyrYIjBg/ikHzQyKlCGNFrDVCawwpuZOEbaK1xjANLCm4RQBaA4JaJ8SzDFzLoMeQgjsRQpBxLTphTKnlE2mFoQVCaHoUmkDFgGAvmu6i6+ku9v1MmOz7mTjVNd3FB9DFUpmNdpuMbWMbkpP5PD+JSscnUDFvrheRQvDRsWEE4Jom212v1GiHIcW2z0K9gS0NEIDmBgmMpBKYhkQKKHguDwwVuFissJ1tSCazab49u4xnmRzNZehzHVK2xZ0IIUhaJpYhMYQg1potg0mXrGNjGxIhBO9GwjK5dyjH83NrbNcIQkKl+PbMCkNJj3LHx7MM2mFMjwYyjoUhBS8vbaK15lghS8a1yHkO2xVbPtVOwFy5gRSCh8f7sQyJbUi2u7xZo9r2URpmyg0SjonfCthiScFAyuXlhU36Sw4jaY+0YzOWTXAnQgiCKOZAPsVYxmOp1uYGAWjNSMZjMpfkRzm7XMGPYjpRTD5lEjcVhtD0aMAUJvf3HcIUkr1quouup7vY91NnsO+n7lTXdBcfQH93fYa/vz7LF65c4+XVNc5vFklaFgezGX4cpXaHMxtF/vj0eZ6ZW+SV1Q0uFMscz+dIWCaGlPS8trrB316Z4W8uXedbc0tU/JB6EGJKgSkFQgiGkwk+d2iCT0yOIoSgJ2lZ+FHMbLWOJSWuYTCQdHlzo8QPltd5eXmd7y2tM5ZK0ufaOKbBnXiWyVQuzaurGwghCGLFQMLloZEBfve+owgheLf6XIeqH9KJItaaHTzToCfvuaw02vzDlUVeW95EaU0jDLENSRhrCgmHjGOxWGtyZqXMC3NrXNyo4MeK4bRHwjLpWam3+MHCBn/68iWen13j5YUNlmotDuXTpGwTKQQ93762wlcvLvKFc3O8NLdOK4ypdUIsU6K1JmGZDCY9VmptrpfqfPvaKq8uFvEjRcI2GEi63IkhJY4hKbUDOlFMrRNiCMH9Y3n+5aNHSdomUgh28w8Xl/mzFy/z/PUNvnN1jVBHGNlNIquBLS0kksf7T/Jg7jATiX72sqe6FrpOd7Hvp8pg30/Vqa7pLj6ALpXKfH12jpdX11Fa045iakHIYqPB8Xwfedfl3Yi1ptzx+ZM3znOtWiNSmlAplhtNKr7Ppw6M07PZ7vD16/O8sLhC1Q9QWlPu+ORdlweG+vnkgTEeHhngyclRfmFqgi1CCPpcm2P5Pg72pTmaz/LJA6NcKlZYbrQIlSJUinoQcrFY4bHxIfpch90UPJcHh/sZTHncP1zgsYkh/tt7DiOE4Md1vD9Lf8LlRH+WkwN9HM5lWG92mKnUibWmGUQ0w4hDfWkePzDMoxODfGg4z7VynY1mh2YQESvNZsun7odM5dIMplyU1syU6vzZy5fYaHYIlSaIFTPlBlIIHpkYoGeh0uRrl5d4aX4dP1IEsaLS8RlOJ/jweD9PHBrikYkBym2f5XqLaick1ppmELFUbTGS8ZjIJrFNgztJuxYHcikOFzIcKqR4ZLKf33/kCEnbwDENdnN6scT/+dwFyu2AThQTayg3I+47aPPp8eOczEzyqaF7eSh/mJOZCT4Inupa6Drdxb6fGpN9PzWnuqa7+ABSWlPxfc5sboIANDeESlHqdKgFIVprhBC8G6+tbbBQrwMahADNDZdKZc5vlrirkENpzVvFMq0wYruVZpNfOjzJLxwcJ2GZmFKykyklQ0mPXzo8SRDHvLVRpuIH7NQIQt5cLzKWTmJKyW4O9KUZTiVwTAOtNUIIflIPjvbz4Gg/zTDi2evLLDda3CKgE8XUg4hPHRrhYF+KK8Uaz82sEilNj+Cm66U6FzcqPDzWjx/FvLa8Sc0PuEmDEPScWyuzUGkynk3QiWLOrpaIlQYBaFAa1hptPv+hKT52cJCmH3Jls4YfKbar+SFvLJf5haOjvJPhjEch6fCRA/30aK0RQrAbpTRL1Raa7TRGusyy3uB3cw8y5hWwpYkUkg+S6S66nu5i30+FZN9Pxamu6S72kFgpGmFIT6QUuwnimHoQ4JgGhpDcILjFlgaWlASxohmG7CZSikgpBBAqhRD8Iw2CfyTQaHo808AxJAhuY0mJJQVBrIiUYjdCCHpsw8CUkiBW7CSEoBMppBC0owilNbtxTIMeIQTvhdaaWCnCWOGYBlprbiPANiVac4NpSEwp2KK5SQOWIekxpEAguJ1GAKFSaDQ9rmngmAa3CG6wDYllCMI4JogVCJBCsJNlCBzT4EeJlUYpTaQUmt01/BA/VggBhhTsJAyFJUxCFRNrzW5CFdPTjDoordlLprtOdbHvp8Jg3/vuVNd0F3vIcqPB2c1NvrmwwFulEkprMraDbRhs9/2VVV5aWeW1tQ2uVKoIYLPd5gYBtiEZSiYotjtcLJWYr9dpRxFjqRTbbbbbrLVafOnKDK+srVNwXc4VS/hxzC1C8Pj4CL92eAopBc0gZL3VZrnRxI9jeqSA4WSCThyz2mzx1maF9Vabw7ksu9Fak7QtSh2fK6Uq2xlCcN9gnu8trvHmRomMY2EKiWsa/DQorXlpYY3n51Y5s1ZisdokiBWVTsCWhGVwoC/Fk1MjJGyLPtfmzdUS89UmSnPL3YN9PDk1wlDKoydlW7yxUqLuh2z3K8cn+MTUMEIIGn7IerPDcq1FpDQ9piEYTnnU/JCZUp3FaovrpTqltk+sNFsGkg6fPTbGRF8S25Ds5lqxztmVMs9cWeGt1Qoj2QQacEyD7V6cWefFmQ3eXC6zUGmxUGkSxopbIoe7xhIU4xJv1eZZ7ZQJVcygm2W7Wtji9fJ1vrNxnnPVeXo8w8Y1bPaKp7oWuk53se99ZbDvfXWqa7qLPWSt1eK5pSX+9OxZLpTLvLm5yUqzhZSCyXQaU0p6vjozy9dmZ/n67ByXyxWuVit04pgT+T6aYcRgwmMslWKmVmO+3uDNzSKXShXOF0sUPJfJTJqeRhByvljij944x/eWV7lQKnOuWGQ44eFZJhpwTZOPj4/y+RNHSdkWhhB4lknCNAliRagUGjiYzVDudFiqNzm3WeLMepFrlRp1P+T+oX7uRAiBIQRpx6JnvdkmbVukbIuc6/Da6iavr21ysVjm5eUNDuezDCZcDCl5Pymt+evzM3z96gLPzqxwuVjlaqmGISWHcmmqnZCJbJKpXJo/ePA4o5kkPUIIHpscZKHWJIoVoVI8MFLg8QNDPDzWj2sZSCFQaIZTHhtNH63BNiS/fHyCXz4+TtI2EUKQcW0MKYi1phlEJG2Tib4US7Umi9UWZ1bKvLVeRQOGkPQnHQQwnk3y5OFhHhwtMJT22M31Yp0vvDnH1y8t89pSibfWKry5XOG+0RwZx0JKQc83Li3zH56/wFurVc6sVKh3QgxDkE84JG0TCRwZsVk2rnK+cZ1rzVVeK1+jHQfY0mTMK9DTjDp8eekHPLN+hu+VLnGlucqLxUuMuDlGvTymNNgrnupa6Drdxb73jcG+982pruku9hCtNZcrFf6vM2cIlEJz00anjSEl9/X3kzBN1lotvr2wyIsrKyBAa41G4McxHx8b5XdOHucXDxxgrdViod6gGUb0hErRiSNaUczdhTwJ0yRQij9+4yxXKlW2hEohhOB/fuRBHhkZ5InxUZ46coi0bWEZki0DCY+D2TRPTIzy4ZFBUrbFtUqVih+gNDc0wxA/jhlPpxhKJrgTKQR5z+W+wQJ39+d4dGyYuwZyvLayQbHt06OBVhgxW63z2NgwSdvi/TRXbfCNa0u8sVqiR2nQGlphxK+fOMhvnDzA5w6P8/iBIcYzSbYTQvD45BCHC2kenRjks0dGOTnYR8q22JK0LQoJhycODnPXcB9PHBzmF46OkXVspBRsGc8mOZBL8diBQZ6YGiaIFbOVBvUgokdpTTOIONqf4RePjfNLJ8b4lRPjHB/IMpZNspsginljpcQ3Li2z2fTp0UC5FVBq+Tw+NYgpJTPFOn/20mXK7YBIaUDQCmMGUi5PHhnmtx86yMemBqlQ5lJwGS00Ck3PYrvIqJdnKjmEJQyuNdd4Zu0MV5ur9Cgg1opztXkeyR0hZ6fYS57qWug63cW+94XJvvfFqa7pLvaYSGuu16oIejQg2HKlXGaz02EwkcCPFZfKZW4RgNaY0sCSBncXCnSiiLRt0whDEIDmhiBWbLbbaM0NM9UaK60mO5U7HeaqdX750AEENwkh2GkklURpzWgqSSuMaIQhOy3WGrSjCKU1UgjuxJSStG3x4HA/Gvjby7MU2z47+XHMRqvNQMJFCMH7pe6HXCvVuI2AhGXimJIHRgpoDYYU3IkQgnsGc/RoQArBThnXRmtNLlFAcJMQgp0mskmU1kSx4upmjWon4AYBaFBas1JvcWwgzeFChh4pBLvRWmMakrlyk41mh5sENwgotnzWGx3Gswn8SOHHCk2XALQGBGu1NoWEzWRfkkhpvjofIoVACW5zsb7IZ9X9JE2XYlBnob1JjxaCLY602AiqTOlBhBDsJdNddD3dxb73TLLvPTvVNd3FHuLHMWutFmEcE2tNyja5SbMlVApbSnqSloltGNxGQMoy6XNsYqUwhKDfczGl5AbBLQXXJe3Y9JhSkHMcdrIMAz+OqQcBoVI0wpDdrLfarDVbFDyXjGOD4DYJy6Q/4bJUb7LRarObZhihgM1Wh55QKXYqeC5VP8CPYyodn0gp3g8JyySIY3bKOjamIakHIWvNNrFS3Ekniql2AvxYUW777KbaCdlsdlAa2mHMbjabHVbqbfJJh5RtcYvghrzn0J/0EIAUgt1UOwFhrKh3QrTWvE2zpT/pstHoUG4HOJYk61rcIujSGFKQTzoYUqKFIpXxsU2D7SQCW1rY0qInaTi0VYgWgu367ASOtNmrprtOdbHvPTPY956c6pruYg+ZrdX43uoKT184zyvra9SCgMVmE601SmtA0PM7J07w0ZERpBAIIUhaJueKRfw4psc1DPoTHk8dOsRQMoEpJY0wpNzxWWu10HQJmMikeHJ8nKlsBscwGEh4LNYbXK9ViZVmS8qy6HMdvnJtlu8tr+LHMY5hkHMdtvvylRm+dHmG7yws8/raJknLotzxidH0mFIwkUlzdr3EN2cXuFiqUGx3ONmfY7vFeoNvzCzy5UszfO36PLHWVIOAdhizJec6KK1Za7b59twyLy6uMpDw8EwD1zR5LywpsU2DN1aLaG5KWiZp12Kl0eL7Cxs8e32JWGvynkPSttiyVGtyZrXI069f4YW5VS5uVsk4FkMpj+2+O7vGN68t88Xzs7yxWsSPYrKuTdK22O7/OX2N//fSAs/NrHFls4ZjGdQ6AUpzw0DK5ZOHhjlSyJCwTXZzcb3Kt66s8MVz83zr2gq2YbBWbxPEii0DSQ8/UixWmjx3bY0fzG3imiaVTkCkND2mIXjyyDAPjOXpTzrYhoFrGXy3+BYajUajgT4ryT87+ElGvTxSCDzDJkZzqb7ElrTpcTQ1yi8O349tWOxVT3UtdJ3uYt9PzGDfT+xU13QXe0g9CPju8hJ/8dZ5NtptlppNip0O/a7LeCrFeCpNxrb5p0eP8sToKGnbpseSEltKpjJZakHAaCrJsVyO3zp+jHv6C2wZSSaxpCRt2yg0J/N5PjUxziPDQ+Rdly0PDw8SxjGmIcnYNiPJBJ5l8traBivNFkuNJnO1Op5pMpZO4pkmPV+8fJ3/eO4ii/UGa602a6021SDg0wcnSNkWedfhvoEC54tl5mp1yh2f+VqDhVqTUCnuGcjTU+n4fPnyLM/MLnGxVKHY9pmt1hhMeExl0yQtixOFPhzTYKneYqHWYKnRYqXR4o21IvcM5BlIeEgh+Ek5pkHCMpnIJim1fQ7nM0xkk8yW66zU2yzUmhTbPi8vbtCfdDlWyCKFoB1GnF4t8WevXmSu2mCl3mal3uLCRpXj/VkKCZee08tF/u7iPC/MrbLR8pmrNFlttEhYFuPZJLYh6fmLly/ypbfmWai2KLZ81hod4ljx5KFhbMNgsi/JZ46M8vB4P6OZBLtZrrX40vl5nru2yvVSg/VGh/lKg6lCmvFskoRlcGIwS6w1K7U2C9UWK/U2640OpZbP41ODDKRcXMvgM0eH+ciBAe4Z7mPLkNvHVHKIetSm38kw5Ob4/alPcyAxSMJ06HENm4zpUbDTNKIOR1LD3JOd5PcOfIK0lWCve6proet0F/t+Iib7fiKnuqa72GM2O23+y9UrREqxpRGGpG2bT45P8NjwCM0oYiSRwJCS7cbTafo9jwcGB3ANg1YU0e957PTE+Bj39hfwY8VAwqMTRSQti53+2d0nWW02aUcx660W//7VNwiVYst6q833V9b45UMH0FqzUG/w4tIyfhyjeVusNEnT5A8/9gitKORLl2doBCHbrbVaXCiWWaw3GEslaYYRF0pl1ltttigNa80W//ze44ykEhhS8IUL17larhJrzZZSx+eLl2Y4nMuQsi3ei6lcmpF0go+MDZJ1bb5ycY6LGxXqQUSPpkvAX529zgPDBQ7nM7TCiC9dmKPSCbhBQDuKKXd8zq2XOdCXQmlYqrd4Y7VEqDSCm+YqTV5fLvKZI6NorbmwUeH0Sgk/jrlJ0NOJYib7kvzeg0dIWCahUqQdi93EStMMIt5aq1DphGwJlWaz6fO/fu4BDAHNIOYvT19jtqSIteYGAUprev7tZ+6l3ApI2AYZ12anh3KHmUz0kzJcfBWRMl1MabDd4dQwE4l+Hu8/Qcb0sKSJa9h8UEx30fV0F/t+bCb7fmynuqa72GNipWiEIZYh2anq+8Rak3Uccq7LblzTxDVNtNYkLIvd9DkOGhBAwjTZzXAySaQU54tF6mHATsV2h7Vmi6xtozTUwhCN5gYhQEOkFLYhEQKyto3WIARozW3WW2205oZaELDearOT0lDq+Dw8MkCsNZ0oJohjtlNaE8QxnSjGM02kACEEd6K1RgiB0hopBHfimgZDKY9YaUxD0ggjdnIsSRAreupBSBDH3EZA3Q+pdkJMKQlixXqzTRgrejQguGmj2abWCfBSHrHSlNs+b9MgBJHWuJZJn2cjAFcY7EZpjRCw0exQbPrs1Awi1httPjzRT6UV0IkUkVLcJOiJtMaQkiBWDGc83knBziAAz3TYjS1NxrwCWmuEELyTWCsMIdlLprvoerqLfT8Wk30/llNd013sIVXfZ73dQgEb7RYjySTrrTbbtaKIIS+BFIJ3QwjBbupBQKw1s9UaQghO5HNYUiKF4E5MKUnbNn2OQ6nts0UKwUgqwbVKlU4UM5jwSJgmb9MgBFnH5miuDwHEWnMwm6Lfc9lod0BzS9516PdchBA4hoFrGAgBWnPLUNKj6gcs1Zu0wgjPMlGaHzKSSnC1XCVt2xQSDlnHxjNNtlNas1Rvst5sk3MdhlMJEpbJTo0gZLHWpBGEuKZBpBQ7Hc5l6E84aK1xTYOjhQyzlQbbRVoznPKQQuAYkj7XJuWY1P2IHg04hqQ/6SKFoGeyL8VwyqPcDnibZjST5EghjdYaKSW7Wau3UVpTbPms1NqkXYtWGLPdeDZBwjIRQNazOZBL8uZKmZs0ILAMwbGBNKYUvJNm5FOLWqx2ymTMBIdTw7wTIQS7qYUt1v0aSmssaTDs9uEZNnvFdBddT3ex710z2Peuneqa7mIPma1V+fbSAn9y7k1eWl3m+2ur+FGEZ5q0oghTCEDwuydO8omxMWzD4L3YaLc5s7nJn549xzfmFnhucYl6GDCaSpG0LIQQ3MnBTIbFRoPFRoNIaUwpGEx4VP2Aq5Uq35pf5MXlFVK2RdUPiLWmJ2PbPDk5xv2DAwwkPAwp0cBGu03dD2nHEVLCwUyaf/PAPfQnXKQQ5FwHxzA4vb6JlIJYafo9l1ApFutNvjO/zDdmFtFoglgRxDFSCDQwmPBYb7X59twyLy+v88LCKkMJj6xj45oGPUpr/ubCDF+5PMdfX5jh/EaZy8Uq9w7mcUyDLZWOz//+0hm+eX2Jr19dZLPVwTIkDT9EAho40Z/l45MjnOjvwzIMUrZFqe3TjiLWmx0MIRACfu34JL96fALbkAghONGf5examWK7Q6Q0nmnQn3T5zbsPctdgDiEEUazo8xxmSg3qfkjPUMrjialh7hnqI+Pa7ObieoUvv7XA35yd5R8uL1NqB1TaIQjQGjQwlHL52MFBPnd8DCEEsdJkXZti02el1qbHkpInjwzz8HiBsWyS3dTCFn+38gp/v/IaX1l6hcuNZebbmzyYO8SPa661wXObb/EXM8/wg9JVnt04R9pKkLdTeIbNXvFU10LX6S72vSuCfe/Kqa7pLvYQP4751uI8f3T2DJFSbBHAp8cnGfASdOKIo5k+HhgcoOB6vBeRUszWavxvr77GfL0Omi5Bz++cOM7v3XWCH+VLV6+z1mzhmSbniyUuFMv4ccwW25D86tRBAqWQQnAyn2MineJYvo/trpSrzFRqXK1UsaXklw5NkrZtMo7Nds8vLHOlXCVWmqof8L3FVZphhOYmATw0PMBoKklP1rF5c73EmfUi2/V7Ln/4xMMczWfRWvP8/ApfvDjLhc0KWzK2xWMTQ/wPD9+Naxo0g5B/9/zrvLlWItaaLeOZFB8e6SfSmqRlcu9gnhP9WdKOzXYvza9xvVynFgSMpZM8PjlMn2tjSMEWrTV/dW6GUsunz7U5nE/zkYlBtttodii1fJ6bWUFpzYdG8oxlkhzoS7GbUsvnC2dn+da1FSrtgB4pBCPpBBPZJON9CQwhGM0k+MXjY2zXCiI2mh1emFmj0go4mE8zlU9x93AfuwlVzDfX3uBrK6+z0N4EBFpAzkry2aH7+e3Jj/Nu+XHEtzfO8acz3yTWihsEWMLgfzn+6zySO8Je8wddT3ex70cy2fcjneqa7mKPaYYh31iYQ2nFdqaUBCrmNw8fpidt2QgheK8E8PzSMsuNBjcIQGsEgu8sLvHk+BiTmTTv5DeOHKIVhlT8gIrvc3ajyHZBrFhttfi3jz5MqBQSgWMa7HQ0l2U8neTTB8ZQGgwpkEKw0xMTozww1I8hJN+eX+Ll5XU0b9PAfK3Bv7r/LnKew2arwzdmFhGA5m2NMOT5hRUOZtMIASuNFheKZW4S9NSCkI1Wh2K7w2gqwbVyjWonINaa7ZbrTQ7dfYjHxodIOxaRUphSstNjk0M8NNqPH8ekbYseIQTbCSH4/D1TBLEiVIqUbbHTQNIl59kcyqeRAiKlcUyD3WitsQ2Di5tVKp0ABKBBac1Gs80/uWuCxw8OkrRNPMtkp4RtMm4m+Z0HD9PwQyxD4pgGP8piq8hCe5MeLbihHDZZ9yuUgjp5O8270Yw7fGP9TZTW3CC45bnNt7gnPUHCdNhLprvoerqLfe/IZN87OtU13cUeorXGj2OU1lhSoukSgOYGrTW2YWAIiSEF75XSGq01oVLEWnEbAVprHMNACN6VhGURa40GYq3ZKVSKdhSRtCyU1uzGlBJDSgxAa81ubGlgGZKeSCvupBPHZB2bSsfHM000t9MaBKC0xhCCVhhhCEGMBq0BQU8nipFC0GNISaQVO1lSEsYKx5T0GEKwG8uQ9Agh2I0QAsc0cDDYjRQCKQU9GsVuwlhhSEEzCGkFEbcIQEMQK/woxjENLEOyG0MKelKOxbuioR0HIASa23XikEgr3i2lNbY0AQ2CGzSg0FjCQLM3TXfR9XQX+3Zlsm9Xp7qmu9hD1tst5ut1rteqJEyTjO2g+UcC0BBpDRqeW16kE0UczfYxlcmStm1+XOVOh2YY8r21NSSQME2kEKA1twi4q5BjIp3m3UrbNmOpBI4p8SPFFktKxlJJvnp9DikEJws5Cq7LaCrJdmvNFnO1OvO1BrYh+fSBcaQQeKbJdheKZa6Wq8RaM19tIOgSgOaWh4b76XNstNYMJjweGC4wW62zXaQUHxos4JgGsVIc7EtzIJvieqUOAtCapGXR7zkkTBMhBAMJF9swkEKgtGZLf8LBj2K+dHGOpGVyOJfmeH8fUgi2O7deYrneouaHjKWT3D2YI+NY/Ljqfkg7jHhxfh2lNScHsgylPAoJl+3mKg1W620WKk06UcyBXIqFapNIaW4QMJLyWKg0ePbaMoaQDKY8Hpno571SKKZSQ7xVX2TVr7AlYyUIdcxLm5eQQtBnJ3mi/y7eSdp0eajvEOfqC/Roboq04r7MJEnTYa+a7qLr6S723ZHBvjs61TXdxR6y3GzwrcV5/ujcG5wrbfLi2grtKCJj28RK45kGppRkHYey3+GbC/NcKJd4ZnGBgucxnkxhGwbvVtX3OVMs8sdvvsl3Fhd5ZX2dpUaDnOuiAAk4psljIyN8/thRkpaFFIJ36+5CgY1Wi2oQECpF2rYYSyc5Xyzxg5U1Tq9vcH6zRKgUA55HxrHpWW22+OtL1/jazBzPzi3x2uoGV8pV7unPk7BMpBD0vLKyzh+++Apn1ou8uLhKPQwAQdqyMA2J1pqPT4zw4ZFB7h0sIIRACoFnGiitWWm0cE0TS0r+9QN3cd9gHs8ykUKQd13KHZ9QKRpBSH/CZTKb4g8eOMFwKkFP0rY4Vshybr2EIQVKw3DKAwHfX1znzFqJlxbX2Gj5SOBgXxohBD3fmV3hK5fm+dtLc5xdK/Hs9WVsQzKVS+OYBu9WK4y4tFHlz1+5xNeuLPLaUpHrpTqx1oxmEniWSc+VzSpfODfH319a5IXZNc6tVdhs+hzMpYiUJlaKyb4UNT9kodrk9FKZVxc3ubBeRQjB8YEs74UpDdKmRzVsEqiIVuwz5PZhSZPFdpGL9SW+V7rMlcYKy50yH84dZjemNLCEgS1N5ltFPMPCFJLPj32UjxaOkjRd9rKnuha6Tnex74cY7Pshp7qmu9hDlNacKxX5k/NnCJUi0goQtKKIBwcG+ScHD/PE6DiHMlnaUcSlSoWeUClirXl9Y51HhoYZ9BK8G1pr6mHIH505w/VaDcVNrSgi77r8i7vv5qHBQR4dGea/PnqEjG1jGQY/rkdHhhlOJnhoaJBfnDrAuc0SC/UGW2pBSKnjc99AP3nXIdaa02ub/MPMPAv1Jj0aWG60qAchj4+PIIRgsd7g3798mmLLx48VPY0gZDiZ4JHRIf6r44d4dHSIx8aGeXB4gC1SCAqey4n+Pg7nsjw6OsSvHJ3kQ4P99LkOW1zT4Gg+y8n+Po4X+vjM1Bi/MDXORDbFdgXP5YGRAncN5LhvKM9dAzmen1ulE8fEWtOz0mjhmSbHC1kSlslas82zMyu8ML9KqDSR0mgNb66VONHfx2RfindDa41S8OevXOL0SoktpbZPK4z50HCerGvRDmN+sLjBM1eX2Wh1AIHWEMSKg7kU//2jJ3hgrECf6zBfaVDuBISxItaaRhBR74RM9iUZSLm8F2nL40BigPtzUxxJDXNvdpJrjVWKQYOOCtFAM/ZpRB1saXEkNcxuCk6ayUQ/J9NjPNx3mCf77+KxwnFydooPgqe6FrpOd7HvNib7bnOqa7qLPSbWilc31hAI3qYBwdVqhX9+/G4GPY9rtSp/fe0KCEBzi2cYXK6UOZnLI4Xg3Xhzc5P1dgvQgGDLXK2GKQWPjY5jSYnWGiEEP6nHRkeIlGKmWqPY6bDTSqPJmY1N7hsoIIVgtlZnsdHgBiFAc8NSo8lctc7BbJpOFAMCze0W6w3+mxOHuW+ggGsaSCHYyZSSfs/lE5MjhEphSYkQgp0yjk3KtjhR6CPWGlNK7mQik2IklUAA/+X8dQwh2OkHSxv82rEDDCQ90HBuvUSkNLcIcAzJxc0Kj4wPYBsGP4oQgrc2Klwv1enRgOCmy8UqlzarHC5kcE3B1WKdUtvnJg1C0KOBwZTLycEsb9plvnppgRsEoEFpzUq9RaQUsdIYUvBeDLpZCjrN0dQIC60ijmERo9C8ba1ToRa28FWEI012M+hkGLDThDrGEgZCCD5IprvoerqLfbdI9t1yqmu6iz0k1oqK7+PHMQXXxZKS7QSQME2EANsw6DGk4AbBLY5hkHMcQqWo+D5Ka+4kVIowjvHjGCEgaZncpNmSsCwsKbGkpEcIwW5qQUDF9+nRWrMbU0pc0yTvuuxkSoktJUpregwpeJsGwQ0Z28aPY0KlsA0DKQDBbQRgSIFjGkgheCcKaIURgVLsJlSKQCk6UYzSmt2YUqKBPs/BsSQ7JSwDKQQ9kdZozQ+xDEk+4SKF4J1EStHjxzGRUmRcky2am2wpCZUijBVhrIhixe00PX2ejWeamFJiGRIpBLcIbtBaI4RACN4XhpD0eIaFJQw0txNCIBE0wjZBHPJOhBDY0kQIwQfRdNepLvbdYrDvhlNd013sIQuNOq9srPGfLp/nSq3CUrPBSruJ1hrN2z5/5BgP9g8hhcA1DPw45lypyA0CXNOg4HpstNuc2dzkW4vzeKZJ2rLwTJMtm+0212tV/vOlC7y8vsZ6u81Co0GkFEprbhJ8YmyM3zh8GCkEQgh28/ezs3xtZo7vLC5R7HQYSiRwTRMhBHeSdWyWGw0uVyrESrPlYCbN799zkrRtoTQMeC5XKhU2Wh225D0X25As11u8tLTKa2vreKbJZrtDrDVbHh8f4SOjgwwkPHYTK803Zxf51uwiX7kySz0IibVmKJlgu0rH5/8+d4UXFlb57sIKBc/FNQ1c0+BOpBC4psHzcyt0ohilueVXj03yyalRBGAZEkMKXlvZRHOTJSWDSZfPHh5nLJNkN9VOwHy1wV++eY3nZlYotX3mqw38KCbW3JKyTQ70pfna5UVeW97ENQ3mKg1irdkymHT5+MEh7h8tIITAj2I2mh3W6m0ipekxDcGnDo/wwGiBPs/m/RRpxbpfpRjUacY+WwadLLZh8sz6Wa40V1lslziZGeP/r57qWug63cU+DPZxqmu6iz2k4nd4dnmBP3/rLKvtFperZdpRRNq2GU2myNg2SdPi80eO87HhMTK2Q49jGHimSc5x2Ox0GE4kmcpkWWg0WGzUuVypsNZq8cLyMhPpFAfSaQwh6UQRb5XL/Nm5s7yxucn1Wo31dpusbdPnOORdl7Rt89GRYX7r2HFSto0hJbv5q8uX+Y/n3+JatcpSo8Wra+tEWnF3voAlJUII7uSBwQHqQUCPYxgc6cvyb+6/h4Ln4pgmUgg0mol0ikYYorXmYCaDIQRLjRZz9TpXK1UW6g1KHZ+HRwZxDQPLkDwxMcpHRoZ4aHiQ3Sit+burs3z16hwvLa2x3upwdr1IpDQ512Eg4dFT8wP+3Xdf53tLa1wpVVmoNXhtdZNjhT6GkwmkENxJ1rG5dzDPYr1J0rJI2xafOzzOLx+dIO3YSCGwDIkpJaPpJMv1Jv0Jl6P5DL9+4gAfnRhiN2GsmK3W+fNXL/Hi/0cenAfbfd6Hff5839969nPP3TcABEAQBLiKi0hKpDbLi2RVTiPblWJnbFhumzaZZtJJMtNpmsaxXdt1/kgzTms7l2kzjmU7kmVr30iRsiiRlECQBLHvd9/Ovv32t+cAvuAFgo1U2lySzzO3yoVai4VGm7xjk7EtRrMp0pZJ0bUppmxenF/ndKXB2WqTxUaH3YM5UpZJyjS4fajAY9tG+Ll7drKhmLKxDIVtKMIkIW2bfGjXBA9ODbFvtMh/ao5hMeTkCZMYJYIhip2ZUbpxyOHGLGt+k1PtZS5466wFDR4o7uTt6uM9cz2HeniHE97hDvTM9LDFHK2W+YcvPEsYJ4CwYU9hgA9Pbec9oxNUfY/tuTy2YXC1dhiy0G4x6Lp84fxZvjU3y1q3y2ZF2+ZfvPd9TGdztMOQ//XF53llfZ3NhtwUH9mxg4dHR4mShD3FAfpMpbie45UK/8fLr3C6XuciTY/gGAb/6MF38fjkBDdzqlqjbyKbwVIK2zDYrBtFmKI4Wa0RxDGfP3WWgyvrhEkCmotMER6fmuC/f+AullsdBlyH4XSK69Fas971mHnlGE9fWGQz21D8g4fv5Ynpcfr+9OgZPn/iHI0gZIMAt5cK/Pr7HqLoOtzIWrtLmGjqfsCugRymUigRNmsFIesdD9c0CeKYbYUsN5Joze8+d5hvnV3kMg15x+Kn75jmXRNDoCFMNP/iu4dZ7/gIr7tjqMD/9L57qXkBtqHYWcpxLcvNDkqEbhiTtk2GMy7/X6oGbQwRFrwKZb/F75z8Agmai4SLbs+O87enn+D+4g7ezn6l58ke3sFM3sEO9Mz0sMVorVnutMmaFtXYBzQg9C11Woym0pRcl6FUiuvJWBZ7igMEccyg61IPfBBAc1nGsmkFIVprljpt2lHI1da9LlprdhWKGCLcTKI1fc0g4DIBtEaAZhASJgmWUmitERGu5faBIlprRIRrSZkmffuHSjSDkEhrwiTmIhHQEGmNaxokieb2gQI3IyJ4UczxSo2raQ2nKnUenxon0Ro/jmmHEZtpwBCh7gfkHRslwvUMZ1JorZnIpbmerG2RtS0SrRGuT2uNiLDS6rLe8biCQMMPqXsh+0cGUMBfHp+l0vXp04BwyVKzQ7njsW+kyI2MZlPcCq01IsLNaK0REa5nwM6gtWZvdpJnvKPkrRS1sAPCRRpY8qpEOkZrjYjwdjXTQ8+TPbxDmbxDHeiZ6WEL6UQhZc8jQVO0HXK2TTXwQdOjASHR4BoGSoRbYSlFwXa4TADNRWnTxDENZltNGkHAcCrF6Vqdq2UsC0OEm5ltNgniGA2ICFcQsAxFyXU4W29girCjkEe0RolwLSLCrUhbJgXH5nUaREDDgOuw2GpT9Xy2FXIkcYJlKK7HVMKg67Lc7pIkmg15x2Y8m0YELKUoug4azdWytoUfJczVW2Qci7xtYRsG1yIi3MxsvYUfx4ykU+QcCyXCZl4UISIsNDo0/IDxbJqXqXAFgYxtYoigtSbnWBRcm2o3oE8DAmwrZKh0fS7U2gy4NoYhZG2LzeJEEyUJc/U2grBjIIvWCaZSbNYNI7pRTL0b4BgGE4U011Lp+HhJiBghrmEzYGe4WjfyWQ9aaDRFK0PWTFGLOvRpLtFa4ygLEeFmFroVvCSkZGUZsDO81cz00PNkD+9ABu9AB3pmethCzjfrfHtpjt87cogfrK3wwtoyGtAagiRGBAThb91+J+8dm8RSilshIjiGQd+xaoWLBDKWRc6y+e7SIs8tL/LMwjxeHGEpRSeK6BPgfZOTfHLPHdhKISJcz+dOn+aPT57kaxcucLbewFSKqu+jucRUirFMmuOVKt+aneOpuXmaQchYOkXGshAR3qwoSSi5LnPNFutdjw2j2TT1IODLp8/zw5V1Dq+V2ZbP4ZoGllJcS862EYEXllYQEbSGnG0xlk3ziTt2UnQd+tKWSSeMOFtrsqHg2IjAM7NLvLC4yjOzSwy6LgXHwjVN3qgnDx3nL06c53NHz7PW9fCjhO3FLCJCX90LOLpa5d++fIqvnprj6XOLtIIQ21S0g4g+Ae4bK/GrD+7FMQ2UCLcVs7y2WmW15RFrTd9IxiVIEk6uN3j67BKvLlfwophSyiFjW/TFScLxtTp/cWyW/+el0zw/u8pcvcNkPkPaMjGU0FfzAr5wbI4vH5vjc4cvcHy9QRAl3D6UZ7Mz5Sb/6rmj/FXtVZ5t/JBOHOAokyEnz4YLnTW+s36M/+vcN3mpdo4fVM8gIiQk+EmEAAJ8avq9PFbag6kMbuRfnvkaX1s9zH9YfJFW7BHrhOnUIG81H++Z6znUwzuMwTvMgZ6ZHraQbhTx3ZUFZk68RjMMqfge9cAniGN+cuo2RlMZtmfz/Be37ea9Y5MUHYc3ImfZDDgOU5ksKdPktnyBvQMlDq2vstbtUvV9OlFEIwjYXxrkvuFhJjIZHh4d47/as4ecZWMqxfX8+enTPHn0KGvdLu0oYrnToRvFvG9ykpF0im25HI+MjXG4XGah3aIZBHSiiNfKZSxlcO/QIIZSvFmGUjiGwb7BATQwkknzrtFhqp7PqWodL46peT4XGk2WWh3eMzWOYxhcz66BAqOZNBnLYjKX4f7RIX5h/x62FXL0iQhZ22Ism6bo2AykHHYPFBhKuby2XqXuB1Q8n0rX58halXtHBhnJpHgj/uDgMf782HlW2h5BknCm2qAbxgxnXEYzKRKtWW13+cOXTvDSUpmaH+BFMdVuwHQ+w+PbxxhKu9w7VuLTD+wlY5vYhkGfiPD+HWN0woihtMv+kSJBErPY6LDe8ah7IYvNDmvtLoNpl4lcGlMJNS/ks0fO8+UTc3TDmIYfcnK9QSeIeGhqCMtQ+FHM108u8I1TCxxbrdMJY9ZaHucqbfKuxc5Sjr75ept//q1XOF1uUJYVGtYac511UqbNhFsiYzp4cchz5RP837PP0o59qmGbetwhSEJ+fOReRpwC29JDfGz8AR4duJ2CneZGfuvkF/n2+lFWggYhMSfby2gNo06BQTvLW83He+Z6DvXwDmLyDnKgZ6aHLabie/zp2RPEOuFKQqQ1/+M9D9AIAkpuCkOEN2NXoci2XI4nJqbIWRa/+/JBwiRhMyVCPfD5b++6B8cwGHJT9CkRrme53eZopUKUJGhe145CMrbFf3P3XSgRvnL+PF4UcZEAWgPCd+YXeM/EOPsGS/woiq5Dxrb4+w/cS8XzmG20+Ob5Oa52slrj2bkFfnrXDm7kx3ZMcd/oEDnLIkwSsrbFZqZS7BrIc1sxR7nro4Bfe+4lEq3ZrO4HfOnMBXaV8qRMk1txttrgdKVBpDWbHVxe491Tw9w3NoghwjPnlzhZrrNBAyLQDiPev2Oc4YzLYMpBA0qEzUSETz+wh5oXUPMCvnR8jlPrTWINwiUXam1eXqrw4d2T9J1Yr/Ps2SUu0YDQd2ixzMtLFR6ZHqbvTLnJfL0DAmiItWa902W+3qbhhaQsg1cWK7SDiERrpFVADazRoMv3yyf58Mi99FWCFv9h4fskOuEi4SINRDrh7+/+CI2wy4CdwRDFjbxan2W+WyZGs0EDz1aO8/jgHezJjvFWNNNDz5M9vEMo3iEO9Mz0sMXESUKUJJQcF02PcFmkE3KWRaJhOJXGEOFHYYpi0HXx4hjHMNBag3BZrDUlxyVrWQw6LkoEJcL1aK2xDAM/idFoQLNBgEYQYCiFpRSuYXAFoUdjKoUSIdGaH5WlFEqEQdfFNhR5xwY0oEG4KEoSlAhBHNOnteZ6BlwHxzTI2hbXokQwlWIw5ZBoTc6ySDRXiLXGMQziRBMlCTejtcYyFK0w5GqWUpS7PnGiaQchcaLRmitoIGtbFFybobSLiKBEuBYRoejajGRTRDohTBL6NK8rdzzKHY8k0URxgmMavE6DQAIoERKt6QQRi40OlwkXRYmm2vWxDMFQggZafggIxvAiYiT0hTqmHDTpC3XMoJ1D0yNcpIFIJ2RNl0QnDDk5DFHciNYaW5k0Y5+LBDSXZAyHctgi0Qm3ItYJW81Mz4Ee3iFM3gEO9Mz0sIVUfI+FdovlbpuC7eAYBpcJoCHRmu3ZPCnT5Ga+u7RAmCRkLYuHRsa4WiMI6EYhr5bLOIaBpQw0f00AzUWx1pyt16kFPpOZLNuyOdKWxdV+uLpCMwhQCGGSYClFmCSABoScbXP34CCGCKZS7CoWyds2657HZQJDaZfpXBYlwo+q4nmcrTWo+j4j6RSOoXidBhE00AxCvrewjAYenRhFEBzTYLNmEHBopUyiNXnb4l1jw1yt5vmUux5nag2yloVtKq6WaE0YJxxeq9AJI/aUCgymXNKWydW+P7+CF8V4UYSpBEMJcaLZMJx2uWt4ANA4psHuwTwigOYKE7k0E7k0N3N4pUK545OyDJp+iGMo/DihTwOGwHQhw0uLZQQhY5tYhuJKmpxjMV3IYCiFaSj2jw5wodamE0ZcJFBybSZyaUylUCIMpGxsS5GkVxCny4Y92QmG7Dx9I06e7elhznRW6NNckqDZlh7CNWxu5rnySUIdUw6aWMpAiRCj2ZAzXQpmmqfXj5ExHcadAjvSw1ztXGeNctCmHnaYSpWYTpVIGzZbxUwPPU/28DZn8jZ3oGemhy1kvt3k20uz/OnZE7iGidaQt22KtkM3ikjQCMInd97BXaUhbuY3XnqBo9Uya16X7dk8L6wu83fvuo8NVd/j0Poqnz1zitVul0YYMJXJMpJKU/E9tAbTEGxlUPE8fvulH9LnxzEH9u3nA5PT5G2bDZ85eYI/P3sGL4oYclOYSmEoIWPZtMOIjGXz+MQEuwoFHMOgbziV4uf33M5nTpykFYYoEcYyGf72nXsxRfhRna3V+eaFOT5/6ixpyyJlmmQsk6xtEcYJGo3WQinl8O3ZBc7WGuRsi6cvzHPg7juZzmcxlaKv6vn85vcPstTqsNrpsj2f44npCX7xrj1sWG13eW5+mc+eOEMYJ3SiiEHXZSjl0AhCtAYlkLEsTlfrfGduiYxl4pomB+7Zy0MTw6Qtkw2/98MjfHd2mXLXZ1s+QwI4hsK0FN0wZijt8p5to0zm0xhK0bdzIMcn797Fn752Fq3BUMLeoSI/f9dOwjjBMhTX87VT88y8dBKtNa5pkLMtDAVFy6IVRCgRxrMpXphf50sn5rANg1LKIWdbtIMIrTV9Ocfil961m4Jr05dzLB6YHGSx2eHwcpVuGDGYdthezPETd0xiGYq+9+wY5Vy1xZfOdQnMFbRo7ivexj357Qw7OfoMUXxgeB+NqMurjQskWiMIPz/1KPtyk9zMb578S443l1gNGmxPDxLpmLRhkwBBEpE3Uygx+P0LTxNrTT3q8v7Bvbx/cC+PlW5nw8Haeb6y+gqHmwtoDb6O+PS2J/jA4F5ypstWMdNDz5M9vI0Jb2MHemZ62EISrXlmaY7fPfwDQp1wkQZbGXx0eicZyyJjWgy5Ke4tDTPguNzIvz7yMl+aPUeUJGwYclP8zI7d/NyuPWitmW+3+PWDz3Ou2eASoe++wWHeNTSCoYSq71HxfP5qaYEwTthgKsVvvPsx7h8eoe+puVl+7/CrtMKQDWnTZH9pkDtLJdBwe7HIUCrFrkKBzZbbbda6XV5dL6ME3j81RdayyNk2P4pYa/785Bn+8PBRNkubJp+6cw+dKCJlGDSDkO8tLDPfaoPmskcmRvknjz6IZSi6UcTvvvgyz80vkWgum8xm+eS+3fz4bdMkWvPqapnf+v4hKp7PBiXwxPQE2/JZUqbJesfjfL3JoZV1Es1lI2mX33j/w2wv5Oj7kyOn+ePXTuNFCRsKjs0dgwXuHxuiE0bcO1qilHKYymfZbKHZZq7e5nytiRLhx3dNYRuKtGVyPS8trvNb332VmhdwkQbHMLhrdIBdAzmytkUp7fC1k/O8tlpDeF3Bsfhb9+2i5gXYyuDBySFGsi4F12azIys1Kl2fuVqL4UyKd08PkXdtrvbt8/O0zTKRCrg9O87e3ASGKDZ04oBK0OLF6mn6hu08d+WnGbAz3Mi/PvdNvrryCqFOuEhg2M6xMzPKu4u7qIQtBq0s/2b2OzRjj81+evQ+PjXxCENOjhW/weeWfsjX1w7TjgNA6LOVwW/s/Zvcn9/GVvMrPU/28DZl8jZ1oGemhy2mHYV8Y/E8Gs1lAkESc7ZZ53+5/1EspXANAxHhRta6Haq+R5TEXCL0rXtdqr5HJwpxDZPvLS+y0u3wOg0Ihyvr/PLe/ezI5elEIf/kxe8TJgmbmSK8uLLCnaUScaJZ9zz8OGazThQRJQk/tW07edumzzIMrjaWyTCcTnPHwACGCEoEEeFHtd7t8o3ZOZRAormsG0XMNpr8gwfvI4hjnp5dYL7V4iIR0Fy02GxzZL3CvSODlDseDT8g0VxhodWiGYT4UYwIPDu3SDsM2SzRcLxc5ZfuvoOi6zDfbPM/P/MiieYKXhxzcHmdqVyWZhBQ7vp4ccwlQl/dD8jaFh/YMUHRtYkTjWUorjaZyzCeTXPf2CCOoegTEa7Hj2JqXkCUJFwm4McxNc/nZ/bdRda2OF9tUu769GlAuKThh9T9kF+4dxex1lhKISJcbf9okSCOeXTbMIJgKOFaPrBjCi8exVQKA4WIsFnasHHdAf7G+EN4SYirLESEG1nzG1TDDqFOuEhAA6tBkycG9/JYaTd5M81nFr5PTMJmGvjq6qv8xPDdDDk5DBFebczRjgNAuEhAieLF6jn2ZcZxDIutZKaHnid7eBtSvA0d6JnpYYvpRCEamExn0VxJBFKmgZ9EpEwTEeFmHMOkG0cg/DVNnxKhFQZYyiDWmgHHxVSKK2nG0xkSrRERakFAojUXCZfFWjPoOtjKwFKKMEmIdMLV6oFPrDV9CddniGAbBoZSiAjX40URYZLQp7XmerwoQhCmc1kSzRWUCKZSNIMAUyk6UYhjGlyiQbjINBQZ2yJMEmzToB1FIFzBVIpmEGAoQQPDqRQiwtUGUi6x1qQtk24Y4ZgG/xENA66DCDiGgRdFCD1Cj6ZPgLof4JoGcaIR4briRGMqQXNzplL4cUwnjLiCQM0LqHUDDCXYpsFg2mGD5hJDCaIhiBNMpYgSzfUkGrQGQwlaa65Ho0GDiHAtSgQRIWXYiAg3EiYRphh04gAEENBcohAakYejbPwkZMjOYYpig+aScbeIRtPXCLvEWgPCRQIaiHVCyc4gInTjgK1mpudAD29DJm8zB3pmethCFjstzjRr/NXKPNPpHIvtNqYoYh2zQQMPD49TclxulamEu0vDzLaaLHfboOnRbM/meWB4jD5LKaazWRAwRIi1ZoMSOFmv8qULZ5nO5shZFpcJKIThVIqJTBYlgqUUO/N59g4McKxSZYOpFGPpDJ89cxoBCo7D+yYmmcxmeTNeK5f5/uIyQRyzPZ/jPRPjFBwHJcKGuWaTo+UKr66XmchkqHk+tqEI4oQNWmu6UcQXzpyn3PWYzmdJmSZ+FHOJJmtbZCyTL54+T862aAUh07kMC80W3SgGzUV3lIrcPVxCiWAqxW3FHH0ioDWXPTA6xEQ2Q9/OgRwPjQ/zpdOzbLCUYiDlMJx2USKYSrF/uMSJcp3z9SYIoDWuaTKaSfNvDh0nbZkUHJuf3DVFzrHZ7Ey1wYlyjVPlBmPZFDsH8jwwPoQS4VoMJUzmMtw3NshLS2U2CDBVyPDUuUX8UzGDKQc/irAMIYw1fRowRGgFEZ959SxRotk3UmTvUIGhjMtms7UW3zi9SBxrBlI2P7Z7gpxjYRmKDYuNDme7S3yvdoTp9CDb00M8NngHb9afLTxPK/Kphm2G7Rx5M0U96rIhZ6bImSn+z/NPUbIyrAQNQFAIMZoNd+em2J0eQWvNmFvkvYN7ODe/DgIaUAgjdp6jzUXqYZdK2OIDg3vZkxmlYKXZKmZ66Hmyh7cRg7eRAz0zPWwh616Hr86f5/ePv8Jcu8nh2jpxkmCbBiOpFEqElGnyqV138tjIBHnb4VZZymDAcWgEPrHWKIHtuTyPj03x7pEx8rZN33AqzW25AicaFWxlkLUsspaNBl5YXeZcs8FL66t4UcR4OkNfyjTZVSjwE9t28OHp7fSJCOOZDFXfw1QKL47IWTY7cnlO1Wu8sr7O8WqVuVaTY9Uqd5YGyNsOb8QPV1b5Z8+/wMlanWOVKs8vrxAlmj3FIo5hICIstNr85dmz/Nsjx5lrtjhRqaJEMJQwmk6DgGsYjGbSzDVbPL+0wrl6g+OVKgOug20YpE2ToZTLgOuy0OpwodHk5dV1ztYbrHU8dg0UMJXCNhT7hko8OjHGuydGcUyDvul8lpLrstjqYBiKrGXykZ3b+PBt0+QdGxHBFMG1TGxlUO56ZG2LHYUcP7t3Jw9PjNBnKGEo7VLzA0Qg0Zqi6zCeS/PqaoWj61VeW6sy12hxrtbkvtEhHNOg70y1wZ++doanzi3y2mqFg0vr1LoBplJsL2YREa5lNJuiFUaYStH0A1KWye5Sntlam0PLZc5UmpyttrANg76RjIupFK5hMJJ1OVVu8IOFdY6v1ZhrtNFaM5lPk7JM+s5Vmvzzp1/mtZUaryxXObRYodoNuHOkSNoyEBHW2h5fP3eOmblvshCucKQ5z8n2ErYy2Z0d4436305+gW+uHeblxixzXpm5boVJd4Cc6WKIYsTJkTFdXm5c4HR7lVeac7RjH9ewKFhpbGWQNRweK93Oz048RN5KYYjCUgaWKApWigWvRtqw2ZUZphZ1ON9d53BrngtehafKxxl18mxLlbCUwVbx8Z65nkM9vE2YvE0c6JnpYYuZbTf5s/PHCHUCWuhb9TvcXxrhwaEx9hZKRDphT75EyjR5oyYzOT65+046Uchsq8mufBHXMBhwXDZ7aGSMkusSxAmL7RbrXoc/PnWCbhxxiVAPA94zPsmjo+NkTBMlwr7SIJuZSvHJ2+/gfLPBuucx6Lo8efQIjSBgQ9nziJOEZxYW+Ju7dpMyTW7FcrvNn5w4QTeOSbQGTY/w5XPn2Vko8BPbp+k7Vq7wl2fO0RcmCWGSEHY7PDYxzr1DQ0zlslQ9n6+eu8D5RpO+SGuaQYgpin/88LtoBgFFx+EvT59jrtmiG8X0JVrTiSK01vzaex9irtliez5HyXVIWxab/cTOaabzWRDoBCH7h0o4poESoc9QinuGS9xWyPHo5CgF10KJYk+pwGZF1+GT+3ez1umy2OowmcvwW88dohUEgNC31vE4tl7jmQuL/NTuaeJEs9Boc2StylrHY8NLy+uMZlO8e2qYlGkiIlzLz+zdzl0jA7SCEMc0+PKJOV5brdIXa03dCwjjhB/bOcG+kSIZ28IPYz5z+CzrHR8BNHC20sQ1DJ64bYxEa1pByGdePctKq0uYaEDoe/bcMlP5NJ+6byd9s7UWf/bqOfREgtIxfat+g+9VTnJ7dpxdmVFu1Z8tPM+h+gXacUBfqGMiHdNNQv7R7o+y4jUo2Rl+49QXaMcBG1b9BttTQzxW2s0jxV3Uwg73F7ZjisIUgw37c5NMukUeLOzAEpODjQtUy8dYT1poenRC38zcd7kzO8HuzAhbyUwPPU/28DZg8jZwoGemhy0mShJONarYyiBMEkADQqw1c50mvzp4L9uzeQwRfhRDbgqtXbZl82itERGuZVe+SKI1O/MFfvflH+LFEa/TKISj1TK/uGcvA46LEuFaDKXYmS+wM19gsd0m0Zqr1YKAqu9hGwZaa0SEG9Fa4xoGYZKQaM1FAmhNX8Xz6EQRgnCyVsVWiiBJQHNRECestDs8ft8EWcviSLnCa+UyV+vGEecbDf7G7p10ooicY9ONIi4SAQ2J1hQcG1spHpsYo09EuJZ9QwMkWqNEuBZDKYquw7snR0i0RolwLVnbImOZ7CjkOFmpYygFAmgNCH0r7S7NIESJoAzhRLlGuetxtRcX1/gv77yN7QWLG9k1kKOv6gX4cYwSSDSXCHTCiErX5323jSPAdy+scL7aok8DwiUX6i1OlRuMZVMoBD+KCRPNJRpESLSm6gXUvZCsbXK63MARl243C26XvkgnLHQrmKLQWiMi3Iwfh/hJRCPqcpGABjSQN1NYYvDewT38oHoWW1lspoHz3XU+4T7InuwYhiiup2hluL+QIUgiOknAX6y8hOZKjmFRCdvEOsEQxVYy00PPkz28xSne4g70zPSwhYRJzKrXoex3mUhnUCK8TtOnEIIkwhDhZta6Hda9Lq0w4HpEhD4R4UaUCGESM5hysQ2DzUSEvcUBbMNAiXAjIoKIkLdtBlMprqUTRtR8n1rg0wwCrqfieVQ8j6rv041jriAQJTE528IxDBzDYDKbJeGvCZdFiaYVhCgRHMNgWy7H1fK2TdFxWOl0iJKEbhghwl/TIFyUNk1yjo2IICLciBLhVigRbkREEBFKKYeiY3OR0KPpM0QQQIkQxAlF1yFlmlxtTylP2jS4kURrwkSz0u7S8kNGMykSzZUENJq2HyJA2jIZyjhs0FwylHawlLDW8elGMd0w4koaDWRsk5RlYBqKiXwG00wQM6RPc4kgrAdNVoMG1aDNzVjKRABTKRDQvM5VFgNWlr4xt0DGcNiguSSlbNBgiOJWWGKQ6IRYazbT9Al5M4Uhiq1opudAD29xBm9hB3pmethCzrfqPLe6wL86dpBD1TWO1StowIsjYq25RPjkzr08MjyJqRQ38nvHDvHtpU4s/uwAAIAASURBVDm+NHuWKEkwRDHkpvhR2IaBIYqvz5/HEEEDSoRBN8WHp7axb2CQW2UpRc33qAY+Zc+jTwDHMBjPZPju4gLfW1ritfI607kcBcdhs0Orq/z+a6/x7MICJ6o10Jp1z0PzuscnJ3hsYpyxTAYlQjeKWO92We100YAIKCV8+q797CuVMJQwmHKZb7Y4WauiNRdlLYusbXG+0eCVtTJPXZgna5msdj2COGHDvqESH9g+xc5CHkMJ/38ThHLXo+b51P0ABATh3rFBfuX+vdiGwjIUGcvkO3PLBHFMorloMOXw+PZxHp4c4XriJOH4ep2vnJrjs0fP8+yFJRp+iAbaYUSfAKWUw68+cAdT+QxKKcZzKY6u1VhodEg0FxVci5RpcqbS5Afza/xgYQ3TMFhve8Ras+GBySHed9sY04UMIoIfxSy3ulTtJULTY8OQk6MV+fz7+eeY65Zpxz67MqNcjwYKVpoVv8GCV2XDjtQQ7x/ax+3ZUSxlEuuEJb9OPerSjH02vG/wDn524iEsMRARbkZEcA2bUMccaS3Sp4G8meIDg3u5v7CNnOmyVX28Z67nUA9vUQZvUQd6ZnrYQpphwNPLs8ycPEwj9Fnutln1OigR3j+2DUOE8XSWT+zYw6PDEww4Ljfym688zzfmLzDbblINfE7Vawgwkc6St21+FOPpDHuLJWqhT86yuWdwiA9ObOMj22/jjRARduYLRIkm79hkbYu85TCaznCsWuFcs8Fiu81qt8vpeo27BofI2TZ9L6+t8U9feIGVToelTofZVpNOFHHf8DBp02QoleIDU1M8ODrCQ6OjbBjPZLANg0HXJU40o+kUB+7ax11DJfKOzYYHx0bohBE522bAddiWzzHXbLLc7jDXbLHS6bLc6XJHqUjRsZnIZthbGuCJ6QkemRglZZn852AZim35LH2OaTCUcrljqMCn77uTnGNhGQZ9Rdfh3tESa12PnG2xf3iAhydH+ORdu7kerTUrHY/PHj3HF0/OUu541LyA5VaXgmvzyNQItqGYzGf4rx/cy23FHGnbok9EeHz7KKttj2LKZiKfJu9YzNc7rLa6LDQ6LDQ61L2Ae0ZLZG2T8VyaB6eGeGR6mEe3DaOUom8w7ZKzbQpmmtjsMu4MMOwUWPFrHG0t0ol9ZrtlTrWWyZguuzKjXIuI4CiLMbeIBnKmy5Q7wIeH7+LdA7soWhn6UobNhFvEVAYazYQzwMPF2/jZiYcommkMpbhVacMmbdiMOQWCJGbIzvHRkXt4d/E2dqaH2eo+3jPXc6iHtyDhLehAz0wPW8yZZo1/fPAZ6kHAZlnT4hM77uAjkzvpxCGjbgZTKW7keysL/MGJV1notLhMw6CT5tceeIw9hQH+U1jtdjCVwo9jxtMZ3qxEayq+RyeMEOB3XjrIiVqVzUZTaf7O3Xfz0OgY3Sji3x07xtcuXCBIEjb74NQUn96/nyBOSFsmRcfhWta7XfoSrSm5LqZSXMtcs4ljGHx7boHPnzpLxfPZbFsuy6+/9xG8KKbkOjimgWMY/OfmRRGdMKYZBEzls6A1hlJcreb5BHFClCRM5DLczDfOzPMvnz9CmCRcpmE0k+K/e3gfO4pZUpZJ1jYxleJqWmsWGh1irXnqzCJfPD5HO4wQXnf/eIl/+PjdtIOIgmuTcyyUCFerBC0EoRl1eXr9KH+28DwbNGCI4idH7uGTU48xaGe5niiJidEseVWG7BxKFGnD5mrNyCPRmlrYZipVQgAlijfDi0PWgxYZ00EhFKwUbyW/0vNkD28xJm8xB3pmethitNb4cUTOsqkHAZtFOmHQSZE2LQYcl5tJtAYR1r0uVxBANPPtJnsKA9wKrTUiwvWMpNLcjNYaEeFGlAhDbgpcOLS2ykq3w9VWuh2qvo8pQsayCJOEIIm5RNhQ9jxirZnIZtBacz1DqRS3YiqbRQMZy6Li+Vwt1pqldpv7hocQEd4orTUiQpIkBEFAFEWsrq4yMjKCaZrYto1SCq01IsKtck0T1zQZcG1EBES4lqLrcDNaa0QEL4oJ4wRTCWHC6wQcy2Asm2I0m0KJcD0iwmQ+jQYMJbTDiD4NCJe0goi6F7KzlONGSnaWPlsZnGwtYaCISdBcEuuE+W4FV1nciKkMTGB7aggR4Xpypktf3nQREX4UjjKZSg3wVjXTQ8+TPbyFmLyFHOiZ6WELaYY+K90O1cDDNUwSDQiguUwQCpaNYxjcCiWCowyKjstKt81mw26KXfkiN7PQbtIKQxpBwB0DJRxl4BgGb1QQx/hxzMl6DVspBl2XiUyWq1V9j6rvU/U9umHEtlyWmu+z2Xg6zYDj0BclCTnbwjYUQZwAGhD6JjIZ5ppN5lstxtJpSq5LyjR5M9phyMlqDUspVjsd8o5Fww/ZrODYaA0vLq8ymcuQMkwGUy63IooiarUaBw8epFar8eKLL7K8vEy32yWVSjE2NsbDDz9MsVjkgQceoFgsYpomt2Kl3aEdRpS7HtO5LAMpB8cweKPiRNMJQ85UmyRaEyUJsdZczTYUGdtEiXAzIgJak7UtXFPhRQl9GhBgx0CWwbTDzZzvrNEIu/hJyF35KY43F4mShA1pw2Y6NcjB+jmKZpqUYXN7doyrtSMfLwk5015lyM6SNV1GnDxXm+9WaMU+zdBjb24cR5nYyuRqrzUXCHWMLQb7c5NczU8i/CTkZHsVWwyG7CwTbpGrVcI2tbBDOWwzaGWZcovYymSrmOmh58ke3iKEt4gDPTM9bCGz7QbfX1vgj84eIW85ZEyLWGtWvQ6x1iRaoxP4xV37+Nj0bgq2wxvxx2eO8SdnjxMkMX3bs3keHZ7g49t3M+C4XM9L6yt8a2GWQ+VVbGVQtB1+ac9+9hZLpEyTW+XHEUcqZb4+d4HDlXUqns+Hp7bxyOg47xmfYMNiu8Xnz57hRLVCxfdp+D6DqRSR1qx2OqBhOJXiwZFR/od770NE6Kt4Hv/0hedZaLXoRBFaw2g6Tco0WWy1SFsWe4pFHhwZ5ce2TZOxLN6Iqufz2z84SNnzaAUhwymX5U6HMNG0wwgDYcB1SJkmdT8gbZmkTZOHx0f5sW1TbMvnuBHP83jqqaf44he/yGc/+1l830drTafTQWuNiJBOpxERHMfhE5/4BB/72Mf40Ic+hOu63MiJco0vnr7A8fUaYZKgBA7ccyf3jw2StS1uVZxojq/XePr8At+5sESYwPZClpoXsNTsYCpBEHKOxd97eB8PTAzjmga3SmvNP/v2IV5drtIOIkTgXeODfHDXBB/cOY4S4Xq+NnuSg+3jfL92giE7h6kUsdbUww6+jsgYDmnDIdYJGdNh1W+wIz3Eh4bv4qOj97GhErQ41LjA55cO0ow8Yq15fHAP7x/cyx3ZcTYcrJ3nqfUjvFSfxTEsilaGX556D3dkx0kZFhv+ePEFvrl2hLWgyY70EHsz4/zdHR9kgxeHvNZa4Ktrr/Fqc4H1oM1PDe/nsYGdvHfgdjbMe1U+t3KIY60lKmGHdhzwd6af4D0Duxiw0mwlv9LzZA9vAQZvAQd6ZnrYQsIk4fn1Rf7g1CsESUI7CqkFPhrNT0/tYjyVZX9xiJ+e3s17RqcYdFK8UXeXhinYDrflCkxlcnxsehcPD48z5Ka4noV2ky/PneW7K4vUA59mGLDmdTnfrPP42CRp0+JWaK1phCH//tRxnl2apxNFaOBMo46phB25Annbph2GPD0/x9MLc5xvNmlHIZHWtMKAh0bGePfYGPtKJR4YHuGX7tyHiLAhZZo8Oj6GiLA9l+ORsTHqgc/JWo1Ya7w4ZqHdphuFbM/nGXJdlAi3oh2G/O8HX+KHq6vU/YBuFFEPAsazaW4rFHjv5Di7BgpMZDK8slamG0W0wpCq77Pe9RjPZpjIZLAMxbW0Wi1+53d+h8985jN87nOfo9vtEgQBYRiyWRiGBEFAt9vl4MGDLC4uMj8/z4MPPoht21xLuevxtbNzfHdumZV2l1YQ0gxCjpWrPDQxzIDrICLcjNaadhTxuWPn+NKpWfw4IUwS1jseGcvio7dvYyqfYfdgnl++bw87B/LkHIs3QkR4344xYq3ZNZjjgYkhHt8+xmPbhjGU4npeWS7zpQtH+aF/BA20Y59G5FGw0vzc5CMUrDSPlW5nziuz5NWohR1CHVMJW8x7VUp2lm2pQbTWzHsV/vDCM5zprNGKfdqxz6JXpWRl2ZYaxDEs5rtVvrz6Cs9VT1GLujQjn7WwyYVumccH95AybPq+sPIyM3N/RSXqEOqEtaDFclAnTCLuyU+jtaYRefy7hed5pnKSThzQd6qziqkMbksNkTdTtCKPb6wf46nycc55ZVpxQKBjflC/wL25KSadIiLCVvHxnrmeQz1scSZb3IGemR62mHrg88X5UyQ6AQE0FzXCgEbo8/f2vosgSciaFiLCm/WR6Z20wgDHMOmzlOJGgiThh+srtKOQzVa6HZ5dmudnduxGiXArXllf45X1NV6nAeHbC3N8aGobU9kstqE4Vquw3O2wmRKh72M7dpKxTFKGiYhwtQHH5VN77iCMY+ZaLb4xO8vVjlQqHCmXuWdoiFuRaM1Su02567FZmCSsdTx+8c697CuVQOC3f/ASGs1my+0O35lb5ImpCa6lXq/zC7/wC7z88svMz8/zRjzzzDOcPn2agwcP8kd/9EcUCgWuZopweLVC1fPZrBmEfPvCItP5LI5hcDMiwplKg+fnV7jaarvLVD7DE9t3YYhgGwoR4c0QET51z07aYYSlFLahEBFuZLXb4pXmeciBCGguUaKYcAf4yOh9zHbXOVg/z3nWuUggQrPi16kELfwkxEDx9bXXWPLrbFaPunx97TU+OLSPvkBH/KB+jlYcAMKGJb/GM+UT/Mzo/TSiLvNelUgnaF5XDTss+nWakUfWcDjUmOWV5jxXEPjW+jF+fPBOptwBbGVytL3EUlBHI2xI0HyrfJz92XFypstWMtNDz5M9bGGKLexAz0wPW5BjGIynsiT8NeEiBRii6MYROctGRLiRKEno01pzPVnLxlIKSymuJ9GaKEko+x6WMrhIuMyLI/K2za2KtWbAcTCV4kqakusSJQmxTljrdmmHIRcJl8VaU3Qcio6DowxEhOuxlCJlmpRch6GUC2hAs8FUCg20w5BEaxKtuZ44SUi0JkwSljptLhIuC+KYtU6XvGNjK4OJTIYo0WwmgGMYNPyAq9VqNT760Y/yla98hfn5ed6M+fl5vvKVr/DRj36UWq3G1VY7HlGScDUviik4NkqEKEm4Hq01fUGckLUtMrbF1TK2iRKwlMIxDUSE64mShDjR3IiIkLUtHNNARLieRGuiJKHaikinQAQ0r9NaM+EWMUXhKpsVv85FAppLNLDqNzDFICb5f6mD8yA5z8Ow07/3u/u+5j6AwUUAJHjfACFRlGgpdMt0xpbWG2vtNeJ1Rbsbe6vsSlVSqXJ549o/veXa8q7jCrR2EotyVEysJSKFkiiJwrRI8QKPITGDG9NzYaaPr+/u73q3G9CQA3gGBElQHD0PGT2KJwPWSEACST1Mw+/QU3LqGEIDBJcJkEA78EhoIXwZYCoaZbdBgGQ9gSDfKuPLAB9JSg+jCsG7BJdl9AiuDPBlwIpTo+E7SATreTIgqYcJqwZb0dGuI11sYRpb1JGuo11sUTHdYNCKoAsFVwZcJugS7I2niesm7+f/mzuNJyWKEHxmaBthTUNXVD6oGbvESrvJ6UqZ7dEEhqLwLgEKgpFIlIRhogjBjdAUhYimY2oqiiMIpGSNlJJyp81Tp2dJmRamovIuAUjosyzsTptjF85Rd13uyPSxM54gZhhsRAhBWNPJhEJoioIXBIAEBBIotdt8P5/HDQJ2JxLsSSaJ6DrrVR2H5+bm8YKAhueyL53mtUsrSLoEIOGWVJK96RQ9YV1jKBLGUBUcP2C93akEfaEQ69m2TTabJZfL8VEFQUAulyObzXLs2DGSySRrxmIRDvSnOVOust5QJMTFSp1vn5mj0nE4NDbEUCRExNBZ4wcBy/UWb64UqTkuTddDEaAqAj+QrIkaGrdkEmiK4Hrmqw1eWlil4/lsT0Y5MJAibhp8GC/PFyg22xSaHRIRUFWJ5D0hRWfISgICIQSWqvNAciffK0zT8B3WbAtluCcxQY+p6PSbMSxFp+F3kLxnR7if8VCanr3RYfZEh1jsVECABBQEo2aS16tz1Lw2q06VYStJUg9Tdpv0SCCuhfhUeg+moqMJhYhqYioaihAESHokECApu03+w+KLZPQohqJxrT49ypARRxUKW9XRLrq+1sUWpLIFHek62sUWd19miPP1Co7v40uJpih8ZedtPDIwRlQ3uJ7/480X+N7iRY6vzPNmaZWVdpPd8SRRzUAIwY16vbjCU+dm+Hb+HO/YRV5evURPVDNQBAgE26NxnhjfwWdHt/FBZKwQo5EorxUvEVI1LFVDUxSius4bxQKvFlbILS/iS0ncMHECH0NRGY9GCaTkfK3CdKnI26Ui383PMRgKMRKJYKgqGzFUldvSGU6WSwgECgIJDIRCLDUa/HB+njcKBZYaDbwgYFsshq6q9NidDv/mpZd5YWmJl5YvMV0o0vZ8RiIR6q5LSNO4NZPmgaEh7h0cwFRVem7LpCl32lQ6HTpBQFjTyO6a4PMT24gbOkIIemzbJpvNksvluJny+TxTU1NMTk5iWRY9qiKwNBUhYKnepGdHIkbHDzhnVzlxqchM0WZqfpnReITBSAhNUQik5Ey5ytMz5/nG2+d441KR1WYbKUFKScw00BWFmKHxz+67lZ2pOKamsplzpSp/8vwJXlsq8Ppyke+fXSRi6IwnIliaxgfxnVPz/NfZPH9/co7ZVZuz1RLhdB2ExFJ0YlqIjBHjt8cfYU90iJ6waqAIQd3rYHtNDKExEe7jgdQu7k/uIKpZ9OyKDBAQsNSxcQKPiGZxOH0Lk8P3ktDDKELQE1YNOtLDdpsgYCLUR9VvcaFV5AX7LGeaK8zUl4moJkk9jAQiqsVnMnt5OLWTYStBT58RZdRK8VrlIpaiYyk6mlCIaiYnqnleqc7xfPkMgZTEtRCu9NCFyjYrzX3xbfzu+CG2uie78l0nuthiBFvMka6jXfwC+eHyRQIJUV3ntmQfUc3gev79mWm+eXGWtu+zRgCT22/h9265E0UIbkTV6fCtuTP85wunqXsul0mwVI3/bsdeYoZB2rQIqRr39Q/xYZ2yyyy3GhRbLYQQ/Kezpyi0W1wh6Dk4NMLBwWEEUGy3eX5xnvO1KkEgWRPRNP70oUPcmkojhGAzVafDKysruH5Ay/P4fj7PKdtmvbv7+/lf77yTsUiEju/zl2+9xXcvzuFJCZIugSoEB4eHeXz7OKV2m93JBKPRKBFd51rPzy8gJZfdN9hPWNdRhKDHtm2y2Sy5XI6Py6FDhzh27BjJZJIeLwgotTq8tVpCFYLTpQq5+WWW6k0k7xmPR/g3n3qAkVgYx/f5D2+d5u/ePgsI1qQsg4dGB7ltIIXrBxzoT9EfCRHWNTZTanX4sxfe4tXFAr6UXCZBUxT+5eE7eWTbIEIIbsR8pcFfnzjNjy9cQvAzisfQRIUjt95N2W0wbCXpN+LsjAxwrdP1Zep+m3yrxP7YKBk9QtqIcq2flE7jSp+273IovQdT0dEVlTVt36Xmt3jJPk9cC/GSfZ6f2ucoug0k7xkxE/zz7Z9l0amwK9RPQg+xPZThWjP1ZS45VVadGkIIvr74MgW3jkSw5lOp3RxK7UKRgpBq8Kn0bn6R/NOur3WxhWhsIUe6jnbxC+YzQ9vxZYAqFN5P03Ox3Q5t32c9CVxqNbjUbjAcinIjAil5aXWZhufyLgGuDJitlvmXdz6IqSqoQuGjuCWZYlciiQC+NjNNqd3mPRIQzNolfmfvrYxEoqy0mnx/fo5AStYTQrDUaLAnkcRQVTYTN0w+MzpGAPxkaYlz1QogAcGaU7bN+UqFsUgENwiodBw8KblMAFIiJaQsk1tSSVKmSY8Qgo18emwUPwhQFQUpJUIIemzbJpvNksvl+Djlcjmy2SzHjh0jmUyiKQr9YYvPTozi+D5x0+D7F+aRXK3t+SzU6gxGLFabbU6XKiAAKQFBT7ntYGoqj02MoAiBIgTXI6VEEdBwPHwpeZcARYGFWoOm6xMxNG5Eue3wwtwKPRIQSJCCatDAdps8OXQvARJVKGxkT3QIKSV3xbfTI4RgIwfTe/BlgCoUNmKpOpaq88sDd9L2Xepeh+8V3kFyNVPRiWgmv5q8ix4hBBvZFx1ijxxAIPi3+R9TchtIBGsE8E59if9p7BHGrCSqUPhFc7SLrq91sUUobBFHuo528QtKFQo3QhMKNddBVQTX8qUkqVu8n5bnUncdbKfDSDiKQLCeQLIjFqfqdGh5Hi3PYyO+DPCCgFKnjeP7BFKykY7v4fg+hXaLpGliaipXk+yOJ4kZBpoQ2J0OddflMsG7Gq6LRNLyPaqOQyAlG5FS0vQ8Gq6LKgT9IYsrJGuSpkl/KEQA+FJSdRwE6wgIkChCENN1hBAIIbgeVVHoEULQY9s22WyWXC7Hz0MulyObzWLbNj1CCHp0RaHuuniB5Fo1x8XUVFRFIWWZxA2dywRdkh5FCGodF7vt0HBdXD9gM03Xo+a4rDTalNodruX6AZqiENJV3k/D8Wg6HoGUbE9FWSMREKkTirgMWQl8GaAKhc14gY8TeJTdBhIIpGQjLd+h5TvUvTbvx1Q0Gn4HTSisJ4Fm4BHTLIQQCCHYTNt3cQKPVadGSg9jKjrrSWBvZJCYZqIKhV9UR7uOdLFFqGwBR7qOdrHFeEGAIgS+DOgRQvCRCUiaIU5WClRchzUT0ThPjO1kezSOpihs5o3SCrmVRZ46e5KS0+Z01abUaSG4QhGCtGnR9DzyjRr/NX+eQEpAkrFCrGl5HqcqZf7+4hmmlhc4vrzAeDSGriiYqsqapUadHyzmeebiOU5XbGbsMqvtJoEEyRVJw+S+/kEODg4jhMBSNdq+x9ulIpcJLhsJR0DADxfmmVpawFQ1wppGWNdZ40vJdy5e4PjiAj9cmGe50WC+Uaft+0iuiGg6O+JxHh0dJW4YKEJgaSpvFYp0fJ81t2bSPL5tnNFoFEUIPgjbtslms+RyOX6e8vk8U1NTTE5OYlkWa2KGTqnV4Uy5yhpNEXx2YpQHhgeImQa+DCi3HVYaLSodBwSXqYpgPB5lerXEK4sFThdtdqXjmJrKehfsGv/xrdMcn1tmsdai7fmsNtqsd99IH49ODDMYCSGEYDM/OLfIT+Yu8a2Zi1TbDufsOg3HY0046jKYgc/03Uq/GWczhU6NU41lvpY/zhu1OU43LjFoJgipOqpQWPN6ZY6flE7z1OKLzLfK2G6LnZF+rielR8i3y+TbZXokENdCfL7vNu6MjxFWDTaz0LZ5rjTDf770OqeaK7zTWGbFqRFIieSKlBbmgcQEj6R2837cwKdHEYJASoQQbCVPduW7TnTxCVP5hB3pOtrFFtLxfRZaNfLNKi8WFrlYr2CoCiWnTcqw+CgUIdCEwmg4ynKrQcIw2RaNc3hwnAf7hkkaFpt5p1zgG+dn+OFSnvlmjVPVMlJCwjAZj8bxA8ltqT4qjsNco8qZms1yq8E7domW5zMSiZI0THwZcL5W4amzM3x/4SLna1XmGzXeKRc5kOojZVooQrDaavKfzp3iR4t53i4XOVUp4wQ+Ud2g3woR0XR2JRLcmenn9269HSEEPaaqEtE1MpbFSrOJpWnclslQ6rR5s1hgsdFgqdFganGBsWiM8VgUTVEIpOSZ8+f47txFppaWmKvVWG23CGkaIV1jLBolY4WYiMX43QMHGIvF6FEVBVPVGI1GuVirkrYsbsukeXBoiIeGhwhpGh+Ebdtks1lyuRyfhHw+z9TUFJOTk1iWhRACU1WImjphXaPpeqhC8MSubTw8OsjeTJIeTVEYjoZpuh6mpmKoKqoiGIqEuWDXmV4tc7ZcZaHW4IJd457hPgxVped8ucof/+hVZooVzpdrzBZtfCnZmYrj+5JUyOTBsX4eHB3gwbF+FEVhM8+dW+DYbJ4fXFhiqdYkX2lgaSoRQ2M8ESFiqEyMwm/vfIhb4yNspuU7vFGZ49/NPc/J+hLnmqu8XVuk5rW5LT5GWDXoebu2wDcWfsqPijPk22VmG5d4p75IWDXYExlkI0IINKGQ0iNIegSGovPLA7dzMLWT7aEMm1np1Hhq+SWeK84wXV/iZOMSTuAT0ywGzDhh1WBPeIC74+P8L9s+zfU4gcds4xLzHZuXKhc50ypgKRp13yGuWWwlT3blu0508QnS+AQd6TraxRZysV5hplbiGxfewQl8Sk4bXVFI6CZpw+KLY3t4MDNMTDf5sPqsEPdrQ9yR6mehWWcoFMFQVGK6wWa8IGC+WWemUqTuOYAgkBLbbXOwf4THRrYxGo4xUylRnjvDaruJ5IqK0+anq0s8OjzG9mgcKeGHS3O8VFhGcoUvJedqFb55/hT/4o77EYpC1XV4u1xgsVkHBD2lTptd8QRPTuxmbyJFgGRnLIEQgvX2JtOMRWIcGhpFInmzWOD1wio9gZSs+cbpWW5LpxmPxqg6DtPFIqdsmx4JVBwHRQh+ffce9qVSxHSDuGGQtizWG4lGSJkGd/X3U+606QuFiOk6lqbxQdi2TTabJZfL8UnK5XJks1mOHTtGMplEVRQO9KXZnYzzuYlRLE0louv0hS3WS1omX751F+V2h2rHwQsCjr4+S7ndBgQ95bbD6VKFNy8VeXB0kLbn8d/OzFNsdXCDgDWlVpv7R/r4n+/fj5SQsgwyYQtFCDbT8nxmViu8vWrTI4G649Hza7fuYH9/kv6Iia4KhqIRrseVPt+69Br5dgnJFRLJVPkUOyMDfGnkfrzAZ75VYqaxRM3vAIJABpS9Jq9ULnBPfDtDVoKNhFSDu+Lj3BYb4UKzSFIPYyk6GSPCZgIpqXgt3qotstipIBH0FN0Ge8ID/Nrg3eyLDBIg2R3u53pON1d4uTLHt1bfohW4VNwWhqrRp0dIaCGOjDzE/sgQMc1kqzjaRdfXuviEaHxCjnQd7WILma0WyRXm+ebFWTwZsMbzA1q+x0q7ycl3XuR/2HGAw/3jTEQTfFghTSeETtKwuBESyXR5lZbvcYUEBL6UzFRL/O7eOxgORegEPsV2C8k6AtzA53TV5s5MPxWnQ9PzCaQEAUguk4AXBNRdl5Rpcq5WYaXd5AoJCHrOVivEDYMd8QRSSoQQbCSi6+xKJGh7HmcqNrqi4AYBSN6lqwqKEARAsd3mZLnEtcqdDk3X5fZMH9cT0nVCus5QJMyHYds22WyWXC7HVpDL5chmsxw7doxkMomqCCKGzt5MkusJ6xphXWM0FuHVpVUWaw0QgJSAoGep3qLcdlAEWLpG2/dwg4D1BHCp0SJuGAxGQ9yIasfh5cVVBCD5GQF1x2Op3uSf3LETIQTvR0pJoVPDkwGS90igE3i40qPpO2hC4a3aPG3fAwSXCfBkwEx9mQDJ9RiKhoHGbbERboQiBGeaq6w4NSSC9U43V0hoFjvDfbyfE9U8z5VO8V9W32SNBFzfoeE7qFT4F6e/xT/f9mkejG9nzEqyVRztoutrXXwCFD4BR7qOdrGFzFaLHF+d45tzM3jSByTXCpBI4N+fn+a55QtcqFf4sFqeR9Xp8I5doNRpUXcdrkcguC3Vh6VqvEeiCMG+RJrztQpzjSoXahUyVohraYpgdzyJKhQShklIU1GE4DLBZQKoey51z+GkXWIoFCZlWCD4GUnPzniCuutysVblQq3KZpqey/lqhcVmg6bn4QYBlwne1fY88vU6F6oVHN9jTzLBtZKmSdTQmS4WuVitUu502EjL81hpNpkplym0WnQ8nxtl2zbZbJZcLsfNIITgZsjlcmSzWWzb5oOSUjISi7AtEeUyQZekZygSIpCS06UqJ1fLSEBXFdaTwEAkRN11OVOqstpsE0jJ9SRMg/tG+pFcLWJoDMfCNFyPGyGEIGNEUYRgjeQKQ9HRhEpYNVAQHIiNYag6lwmQgIpgX3QIwc0VSMnucD/9Rpxr7Q73E9Ms3s+Jap5nizP8l9U3WSO5mk+AI33+fO55jtvnmG/bbCVHu4508QlQ+Tk70nW0iy1ktlrk+OocT+dP4ckABOsINjJdKRBRddJGiKRh8UEUOy3etFf5v2Ze5Seri7xcXKLpefRbYSKazkYUIWj7PkvtOhWngxcEqEKQNCyqjsOFeoW/nztL3XW41GrS9j2EEAgEMd3g4MAo9/UPkjQsJJK4blJst1hs1ulRFYGuqPSZIaaWF3lxZZEfLOYJqRoBEifw6UmbFj1nqxV+sJDnpF3idMXm/oEh1pu1yzw3P8fXZt7mufk5Or5Py/Noeh6KEChCIIG0abHcbPLti+f50cICvpT0tDwfAcQNg4iuM1Mu83apyAtLS7xZKLIzESdhmqxZajR4ZWWFP3/9dX566RKz5TJ112UsFsVQVa7Htm2y2Sy5XI6bIRqNkkql+IM/+AO2b9/Om2++yUeRz+eZmppicnISy7K4UUIIBFBstqk6DpWOAwKSlomhqpwqVXh5cZV3Vsss1ps0HA9VUQgCSU86ZNJz7NQcL+RXWKw1aLgeO1IxhBBsRFMUqh2HcrvDarODACK6RsIymNw/wVgiwo2SSKKqxfnmKnXPQSIRCA6nb+FLI/cTVg0UodAOXJY6FSpeE08GqEIhqUf4fP8B7k1OcDMJIfCkz7JTpeq1afgdetJ6hAcSE/zq4J1cz4lqnmeLMzxTmGaNZGMSCIDXavMMGDFSWoi4ZrFVPNmV7zrRxc+Rys/Rka6jXWwhs9Uix1fneDp/Ck8GvEuwjmAj05UCEVUnbYRIGhY3wpcB52oV/u3p1zlTsyk7bZZbDUpOm4wZYjQcRVMUNjIQCpMxQwyGInhBwMMDo9Q9h4uNGqvtFk3fY7nVIKRqTMQS3JMZJKxp/Or2PTw0MMLueIoeRQjCmsZIOEZY0xgKR4hqOmPRGKcrZRaadUqdNg3PpeP7fG5sO32WxYF0H6qikK/XKHTaVJwOS80Gy80Gdc/l7r4BeqqOw3fzF/jb0zPUXYem57HQqJM0TR4aHCZjhRgIh9kRj7PcbHK6YlN1HBqeS6nTZl8qzf2Dg/SHw+yIxcnX6xTbbVZbLQrtNuVOm4u1GgcyGaK6juP7vL66yl9NT3Op1cLudJir12l6LgPhMEPhMIoQbMS2bbLZLLlcjpthbGyML3zhC/zrf/2v+Z3f+R327dvHwsICs7OzfBT5fJ6pqSkmJyexLIsbZagqE8kYmqqQDpnsSMZImDrztSbFVodSq8OlRotASkZjEfZm4ozFo9w5mMEPJNOrZZquR9VxOFuu4gaSoWiI/rCFEIKN7EzH0RSFsXgEU9O4ezjDf3/HLg4MpvggdEUloprcEh2i5rXZHRnkgeROfn34PtJGBFUo9AyYcTJ6hEEzgRv4HEzt5nN9+3li4A4+DlHNZNxKEVENQqrOHbFR7omP89Vtn+J6TlTzPFuc4ZnCNGskG5P0CHoCJK/V5hkwYqS0EHHNYqt4sivfdaKLnxOVn5MjXUe72EJmq0WOr87x9PwpPBnwDwjWEWxkulIgouqkjRBJw+L9eDLgb869xVv2KpL32E4HieSRgTF0RWUzQ6EIu2JJPj28jbFwjLl6lYv1KhIJCCTgBAGPDY8zuf0WPjcywZ54iuFwhPV0RaXPtLi3b5DbU308PDjC80vz5Jt11hMC9ifT/N7+O9mXyODJgDdLq7iBDwh62r5PRNO5K9OPpaqcrVb42szbtHyP9wjqrsuv7drDr+/aw8GhEebqNV4trHCt0UiEr+zdz6Ojoxiqyuurq9RclzVOECAQ3NM/QNqyaLgu/+6dt5mr1VhvtdUiaRjc09+Pqihcy7ZtstksuVyOm2H37t38yZ/8CV/60pc4dOgQmqYRj8dZWlri5MmT1Go1Pop8Ps/U1BSTk5NYlsWNsjSNXak49w73c8dAGkUovH6pQNvzAEFPxw8YiIT4H+/ay+d2jDESC/Pds/PUHJf1lmpNJpIx9vUlEUKwmZ3pOHv7EnxqYoi7hjKMxSN8GBHNZMCIcyi9hzvj2ziY3kNMC6EpKusNW0l2Rfr5dGYvd8W3cWtshI9TQguxK9zP4dRu7o6P81ByB9dzoprn2eIMzxSmWSPZmKRHsEYCPpLX6vMMmjFSWoi4ZrFVPNmV7zrRxc+Bws/Bka6jXWwhs9Uix1fneHr+FJ4M2JTgZySb+cbcSZ5bvsCFeoX34wUBEU3Hl5LLBO9ShMB2OkgpkVKymbCmE9Y0EobJQrOORHKFpEciOVevEjcMIrpGSNPYiKooaIpCxgpRcTp0Ap/LBO9ygoC4YRLRdAZCIWynQ8f3uUKy5kylTM11kEDSNInoOleTRHSdnpCm0VNst1GEAMFVwprOaDRKTDcIJKy221zLdjqstloogKoIYrqORAKSNQrgS0nddbmWbdtks1lyuRw3w+joKH/4h3/IY489xoEDB1gTCoX4rd/6LYaHh7kZcrkc2WwW27b5IAxVxdJUkpZJ2/OoOy4IuiRrFmtNHD8gbur0RyxSIZNr6arA9QOaroeUEiklm4kYOhFDJ2JoXI+UEl8GbEZTVEKqQcaIogiBIgQbCasmEdUkplm8H18GXI+UEiklUko2E1J1wqpBQgtxPSeqeZ4tzvBMYZo1ko1JegRrJD8jwJU+//d8juOVc8y3bbaSo11Huvg5UPmYHek62sUWMlstcnx1jqfnZ/Gk5DLB5gTrCDYyXSkQUXXSRoikYbEZXVE5WSlyulbGkwGXCVAEJAyLnbEkrxaXUYUCCEKaxrVeXF1krl5l2i4Q1XXO1mx8KVljKCqPDo+z1GpQ7LRZbbUYCUe5nqiuc9Iucb5W4TLBZUOhCPf3D7EnnsQNAtqBz5lqmZrr8B7BL41t56HBYSxNo9xp88LKIhXHQfIeIWBXPEG506Hc6bDcbHCmYnOZ4LKYrnN7po/9qTSGquIEAfONOsvNJuvdls7whe0TxA0DKeGtUoEL1RqBlFwhUITgUyMj3D0wgBCCNbZtk81myeVy3AyJRIInnniCL3/5y+zZs4drBUFAvV7n5ZdfptPp8FHl83mmpqaYnJzEsixuxGK9wYlLBd4plBFAvlqn5rgg+BnBQ6MDPDoxQljXaLoerywXuFRvIXmPEILxRJSes+UaXiBJhUyEEHxQFbdJ2W3wfGmWqtvCkR4pPcKH9UL5LBdbJU7Vlxk0EygIFKGwpu27lL0mzxdPs+rUWHVqjFhJrrXSqXK+VeTFynk8Alq+S1IP8WGcqOZ5tjjDM4Vp1kg2JukRrJH8jOBdAZJXa/MMmjFSWoi4ZrFVPNmV7zrRxcdI5WN0pOtoF1vIbLXI8dU5np6fxZMBVwguE7xLEwopw6InbVjEdYOm7yHZ3HSlQETVSRshkobFZu5KD3KuZlN1Hdq+h6GoxHQDTVF4duE8J8qXeMcuUPccxsIxwprOmr87P8Pfnn2b7y9dZKZSYr5Rw9Q0FEAVCoaqEtF0ztUqvFRY5sfLec5VKwRSsjeRZjMSSdwwqbsOl1pNAikZiUS5t2+Q39y9HyEEqqJgKAqXWk0c36fj+/hS8sjQKAeHRtidSNGTNE0GQmFeXFnEUjVUIfBkQNqyuNRs8v2FOX68tIAfBKhCoel5mIpKOmQxEo3ylb37GQyHEUKQNAzsTpu271Fst9EUhVvTaQ6NjHAgncFQVTRFYW8yxTulEm4Q4EmJQPDFHTt4YscOIpqGEIIe27bJZrPkcjk+qkgkQiaTYWRkhD/6oz/i4MGDbMQ0TarVKl//+tfxfZ+bIZ/PMzU1xeTkJJZlcT3nylX+96nX+OniCq8tF3hpcZWIrhExdNqej0Ry/0g/h8aHuLUvhaIIwrrGtkSU1y4VUIVASvClJB0yqXUcjp2e4+WFVVabHTp+wM5UDCEEN8p2m7xSOc//c+E5Xiif5dXKeU5ULjIeyjBoxvmgnlr8Kf9x4UW+V3ybE9U8Sx2b8VCauGahCIETeJyo5vnbxZc4tvImPyqd4kyzgJSSvdEh1iy0bf5m8QWOrb7FlH2W46XTtAKPpBaiz4jyQZyo5nm2OMMzhWnWSP4hFYV+I0pYMVGAtB6mFXgESBBcRQIBkldr8wyaMVJaiLhmsVU82ZXvOtHFx0TlY3Kk62gXW8hstcjxwhxPz8/iyYCrCS4TcEs8zcN9o/zK6B5+eWQXjw/t4K7UIGkzhCcDyp0Wko1NVwpEVJ20ESJpWGzmU4Pj6ELhnvQQO6IJEobFW3aBpufSCXwKnRYNz2VXLMVgKIwiBM8tXeTo6bewnQ6elHQCn6bvMRaO8tu7D9BvhfmlkQnO1GwWmjWcIMCTkrLbYbnVYCQcZSQcZSOqUEgaJremMvSZIe7tH+KezAC/uXs/QgjWxHSDnbEE22NxRsIRHh+b4IGBYe7rH2K90UiUOzL9DIcj7IwnuD3Tx3KzyflaBTcI8KWk7HTYmUjyKxM72ZtK8+DgIJM797AtGmONIgT7UmmSpsmt6Qy392X4zMgY9w8OEtUN1oQ0jQeHhgjrGnf09fHo6BhPTEyQNE0UIeixbZtsNksul+PDCofD3H777Xzuc5/j0KFD/P7v/z5f+cpXOHz4MNfT19fH+fPnmZ6e5mbJ5/NMTU0xOTmJZVlsZKXR4v986S3O2VXqrkfb9/GkxJeSX7llgruGMhwaG+Lg+CAPjQ6gKgprMiGLe4b6SIZM9vclua0/id12OFWq4kuJGwTkq3UUIdiVihM3dYQQvB8pJQWnxl9e+AHnWwU6gUfDd2gFLitOlX3RYeJaiBv1vcLbHM0fp+w18WRAJ/A421xFFYL7kztQhKDhO3x96af8qHSKjvTwZIDtNVh2qoxaKUasJG3fJWef5bniDHPtEu3Apxm4LHUqDJkJdob60BWVG3GimufZ4gzPFKZZI7maguC2yDBf6NvPP+q7lV8buIPHM3t5KDGBrqr0FNwGayTvCZC8WptnwIyR1EIkNIut4smufNeJLj4GGh+DI11Hu9hCZqtFjhfmeHp+Fo+Af0gCgi8M7eTe9BCf7t+GBBQh6Amk5O7UED8tLvBSYYlvL54jQLKRb8ydpOezQxNMRBNs5le33YIXBKy0m/yrEz/GCXwQgOSyuUaVV4vL3JUeoON7XGo36AQ+kqsZisrOWJJPD43zemkFJ/C5QgKCQEqWmg1sp0MgJYoQbCSkaYyqUb60cy9eEKAKgRCCaw2FIwyEwhwaHEECihBs5NZUhr2JFD3fyV8gX6vxHgkI5upVfnf/bdySSNGjKQrX0hSFg0PDSN6jCMG1kqbJr+7YhQQ0RUFKiRCCHtu2yWaz5HI5PgxFUUgkEvzxH/8x99xzD7fffjuhUAjDMBBC8H7S6TTj4+MIIZBScrPkcjmy2SzHjh0jmUyyXiAlddel0nHwpWQ9AaQtg8cmRtEUBQEIIbjWtkSUkViYnpcWVvi7t89xrdeXi8xXG4zHI9yIAMlPy2e55FRZr+E7LLUrSCmRUiKE4P20A5dLnSqdwENytTPNVfKtMhPhDLP1ZWbqy6znI1ns2Nhek0BKel6v5VnsVJAI1lS8Ns+XT/NLffsJofN+TlTzPFuc4ZnCNGskV1MR/Prg3dwXH+fhxA4kElUo9ARScn98G98tzZKrnOe7pVkkV5OAI33+Yj5Hz2F2Mm4l2SqOdtH1tS5uMoWb7EjX0S62kNlqkeOFOZ6en8WTAZcJ/oEvj+/nybFbeHRgO0IIFCFYowiBIgQP943x+PAOfm3bLShCsJlvzJ3kueULXKhXuB5NUQiQDIbCvEtwmZTQb4WpOB0kcKnVRBWCa5WdNhFNQ1MUMqaF4/u8R9JjqirFTgs3CGh6LpsRQtDyPCQSJwjYjETS8DwCKZFSshEpJZ6U1F2XmG4QM3SuJhkKhclYIRQh0BSFzQghUIRAEQJFCDajKgqaotAjhKDHtm2y2Sy5XI4Po6+vj3379vH000/zm7/5mxw+fJhkMolpmgghuBGO45DNZrn77ru52XK5HNlsFtu2WU8RgmrHoeG6XKvheqhCwVBVFCEQQrAZL5B0PB9LU+mPWFwrbuoMRkLUHBfH95FSshE/kHhBQMvziGkhmr7DGskVQggWOza+DGj7LtdT9zogYblTRUFhPQmU3SZh1aAnbURoBx7vElxmKDoFp44rfUpug6QWRiBYTyIZNZMoCN7PiWqeZ4szPFOYZo3kaioKXx0/zK/0H+BQcieKEKhCYY0iBEIIPp/Zxxf7buOLmdtYT/IeVwb8xfxPOF45R75ts5Uc7TrSxU2mchMd6TraxRYyWytyvDDH0/OzeDLgKoJ3fXl8P48P7WBnNMX76bfCRDSdiKYzUy0h2dh0pUBE1UkbIZKGxWbiuslb9ipnamXWKEIwHI5QdRxKTpvcygJ9psVMtYQrA9bEdIMvju/i1mQfpqrR8FzKbpvFZh03CLhCoCkKtyf7+NFynsVmndVWkx2xBNd6q7TKc4tzPL80jycD3CAgY4VY71y1wkuryzy/lOfVwgrD4QiKEJiqyppASn68NM9PLi3yTrnIjF1iqdXE8X3WhDWNXYkUDw4OEdF1Pg62bZPNZsnlcnwYExMTPPbYY/z5n/85DzzwAOFwmA9DVVU0TWP37t0Ui0UuXLiAlJKbJZ/PMzU1xeTkJJZl0SOlJGoYrDRanC5XWe/+4X4+MzFCyjIRQrCZqbklXlkq8OLCCnOVBnPVOi3PY42lqYzGIlys1jlfrnG6VMXxA4aiYYQQrCk02uSrDb75zjnecs6w6BZp+Q41r43kPVHNYtxK853VN1nu1FCEoN+Ica1vr7zFK5Xz5MpnyBhRTjaWcKVPjwTiWognB+/ittgwpqLT8DqUvSYLHRsXnx4J6ELljugYzxVnKHoNXq/OU3Kb+EjWpPQw9ycmeDA5wfWcqOZ5tjjDM4Vp1kiupqLw1fFHOJzcxfZQmvczaiYIqwYqCqdaq0jWE0jAR/JqbYEhM0pSC5HQLLaKJ7vyXSe6uElUbpIjXUe72EJma0WOF+Z4emEWTwZsSMCXx/fz+NAOJiJJblSfGSai6UQ0nZlqCcnGpisFIqpO2giRNCw283D/KPONGhLoBB67YymqrsNiq87rpRVO18pcaFQJaTohVSOum5iaxmeGtvFw/yhjkRg9ccPEVFQc6VNxOiQNE0NRMFWVk5US03aBN0qrnKqU0RSFvYk0a14tLPOvXpliplLiVLXMG8VV2r7PgBUiZVr0zNWrfGf+An89O82pSpkz1TJvFFfZn8yQNC1UIQik5Olzp3h2/iI/XMwzXS7S8DxUIbA0jZhu0B8KMRaJ8U/3H2A0EuXjYNs22WyWXC7Hh5FMJjl48CB/+qd/yr59+/io4vE4Y2Nj/MZv/AaFQoFKpUKpVOJmyefzTE1NMTk5iWVZCCHQhCBuGmhCYbnRRBWCg6NDHBob5J6hPhRFYTP/7Wyeb5/J852zeU4VbQqtDgKwNJW0ZRIzdfrCFgu1Jgu1Bm8sF3ljpUSl4yCAiWQMIQR1x+W15QJ/9coMJ4pLzHrnOePME1JNdob7WXGq9BsxEloYieQF+yyzjUvMNi7xU/sct0QGGTDjrPn6wov8vws5TlTznG5e4mKrSFg1sVSduBYipBp8NrOPh1O7GLNS9CT0EIbQcKWP7bVI6mEMRcNQNN6pL/FmbYHXawsgBLqiktEjdAKPW8ID3J/Yzj8bP8z1nKjmebY4wzOFadZIrqai8NXxRzic3MW4leRGjZgJwqqBisJsa5UrBJL3BEherS8wZERJaiESmsVW8WRXvutEFzeByk1wpOtoF1vIbK3I8cIcT8/P4EnJZr48vp/Hh3YwEUnyQfWZYSKaTkTTmamWkGxsulIgouqkjRBJw2IzhwfHGQvH+OzQdixV50ytjO12kBIk0PY9MmaIP9h/L/dkhsiO7eLu9AATsQTrjYSjbI8mODgwyh2pfu7MDPBmaZWVdgMJBEiavkfL87glniJpWiw1G/zlzJustJs4QYBE0vY9Cu0W+5IZxqMxAil5cWWJvzn9NoEECfhSUnY62E6HR4ZGUYVgsVnn2NxZ3iyuAoKehueSMEye2L6TJyd28fDQCL80vp3RaIyPg23bZLNZcrkcH9b27dv5i7/4C/bv38/NYhgGuq7zxS9+kVarRb1eZ35+npsln88zNTXF5OQklmWhCEEmZHJbf5oD/Wk+vX2Yw2PD3DGQQVUUNlNstfn26TleXFgBBBJouh5hTeXzu8b45T3beXRimGrH5Uy5StP1kYAEFmtNoobOgf40lqZSc1z+6pVZzpZrBIpHkFpFKgEBks/3385vjD7IvYkJ0kaEVyoXaAYuEugEHpIAgWBfdBhL1Xm1coG/ns9hey0CJAGSVuDSZ0T533Y8zr2JCb44cAd3x7exI9zHeqNWkh2hDIdSu7gzNsZdsW28Xsuz4tQIAB9J03fYExkk2387/3jgTh5O7uTJgTu5nhPVPM8WZ3imMM0aydVUFL46/giHk7sYt5J8UCNmgrBqoKIw2yog+YcCJK/WFhg0oqS0EAnNYqt4sivfdaKLj0jlIzrSdbSLLWS2VuR4YY6n52fwZMBlQnCtL4/v5/HBHUxEknxYfWaYiKYT0XRmqiUkG5uuFIioOmkjRNKw2MxwOMqAFaHuOXx/+QKelCB4l6YIDiT7OTwwRsYKEdUNNpIwTPqtMMPhKC+tLvFyYQlPSq4QSKDmOXxmaJyMGaLle3xv4QLFTpt3CZBIkqbFXel+OoHPy6uXmC4XkFwtYZg80DdMRNc5V6vwrQtnafs+Vwh66q7Lp0fG+dTwGP1WiIhu8HGwbZtsNksul+PDSqfTPPXUU9x7770IIbiZhBD0PPLII/i+j+M4nD17lpsln88zNTXF5OQklmWhCIGhKozEIoxEI8QMHUURXM9yo8lTb5+l6XlcIehpej53Dmb4R7vG6QuHmC1WOLFc5FpCCO4eypC0DC6U6/zwwiI1twORGkTqSEWiCoVPZ/bxQGon/UaMby69zELbRvIzAhzpE1YNHsvsRxMq55sFvl98B08GrKcKlTviYxxO7SFjRIlqJhtJ6CEGjBgjVpIX7HO8VLmAKyVrJFD3OvyT4fu5Mz7GoBnnek5U8zxbnOGZwjRrJFdTUfjq+CMcTu5i3EryYY2YCcKqgYpgtrXKVQRIwEfyam2BQSNKSguR0Cy2iie78l0nuvgIVD6CI11Hu9hCZmtFjhfmeHp+Bk8GXEUI1nx5fD+PD+5gIpLko+ozw0Q0nYimM1MtIdnYdKVARNVJGyGShsVmhBDMNWqcrBSpeQ6XCS4zFJUnxnbR9j10RcULAnRF5Vp116Hte1xqN1CF4MXVRZwg4D2CfYk0u+MporrOqWqZc/UKl1oN1vOl5JdGt7M/lUFXFE7aRd4srRLQJbhMACFN59GRcaK6jq6ovFa4RKHT4j2CgVCYBwaG0IRCy/eI6gYb6fgeDdel3OkQSImladwo27bJZrPkcjk+rHg8zp/92Z/x6KOPEgqF+Djdd9996LqO67rMzs5ys+TzeaamppicnMSyLIQQrBFCsJlCq02l46ArgtOlCov1Jgh+RhA3dR4ZH0ZRBA3H42y5yvlyDTcIWG9bIsrjO8cotDpUOw7fPbuA60vQHGTCpiekGtybmGBvdBgBLHUqvFGb5zIBElCFwr2J7ST1EGHV4GRjifPNAjW/zRoJhFSDfzx0N31GlOupe23agctSp4oqFH5in8ORPuvdGh3mYGonaT3C9Zyo5nm2OMMzhWnWSK6m8v8zB+dhctaHgee/v/eqt+7q6vtuqVFLCAlhhBCXzGU7tpFNYo5xYmexYZ4QxvtkN+uNs5PEefJM/tts1kn2mWfIJmSTzMRDEjMOh42xDTYGDAIaCZCgG0ktqc/qrrPrrvf6bZVES91Q1RKIx+7PR+GBwRvYFxtl0Ixxsfp8UQKqgYpgspLkNAGSczwk44U5uo0QbZqfqGayUdxeN1N3sI4PSeVDurfuoTo2kMlCmudS0zwyO4EjPZoSgrsHL+WT3ZsYCcY4n4rr0KAKgSclQgia6fAFCGo6QU1nIp9B0tzh5RRBVSdu+IkZJq0MBSMczqWYKeWRgAAMVaE/EOZILsWr6QQ/T87hSUnUMAlqOivmy0V+NH+Sfzk5yXg6wXh6EZ+qUnYcXClpiOg+BDBfLvLU/CkytQonCstUXIfV9nb2cn13P93+IBKIGD4WKiXmykUaFCEQQnDf1p3sjHegKgoVx2GpUiFTq1JybBqCmkHEMJjKL/Naaok3MymO5bNc2dHNanOlIm+mU/zN24f52cIcqWqVsmMzFI5wPrlcjv379/PCCy/wYRmGwQMPPMDnP/95BgYG+EXYsWMHUkry+TxTU1N8VGZmZnj++ef5whe+gGmanM8PpmZ4dnqBx4+e4vmZBAhByXawXA8E+HWNdtPH0cwy76SXGV9IkSiVSVdqSCSe5LSgrtEfCfLU8VlenksyXyhjeR7LVQuhSmSgAKrH9W1buKP3KnyqjioUsk6ZpFUgZRdpUIVCXA+StorM1XI8mTxM1XOYrqapeQ6SBkFE83Nrx6VcHu4novlpZbaa5Qept3h44VVeXT7Jq/lpdEWj7Fq4SBoimsme6DCf6byM9RzMz/BUeoLHU4dZIVlLReGBwRvYFxtl0IzRiic9hBBYnoMtPTShsJ4+X5SgaqAKwWQliWQtCbhIXi3M0WOEaNP8RDWTjeL2upm6g3V8CCofwr11D9WxgUwW0jyXmuaRuQkc6dHK3QPb+WT3JkaCMdbzZm6JVzMLHMjMcbyYZaacR1cUfKqKrqg00+ELENR0gprORD6DpLnDyymCqk7c8BMzTFr5ePcgOatGm2GiC4Ur4t0cL+Y4VcyTqJSYKxdZrJYwVY2hYARdUcnWqnzn1CQ/SUxztJBloVIiU6ugCMHHuwewXY/L451oisLxwjKJSonFaplTpTymqtHtD3JJtA1XSj4zsJkbuvvZ3dlDgxACQ1XoNoMYqoJP1dAUhQcu3cWVHd2EdIOGgKbTEwjiSfBrGr2BIF2BADPFAkuVCvPlItPFAgvlEulqlas6u2koOzavJZf467fe4FQxT6pa5Ug2jQQ6TD+d/gCt5HI59u/fzwsvvMDFiMVi3Hfffdx88838Iu3cuZNSqUQymWRubo6PyszMDM8//zxf+MIXME2TVn42vcD3j03z3EyCZLlKulIlWa6ysyvOpliEiE9ntC3CXKHMUrnCTL7EXKFM1XGJBwz6QgEGIkEGwkF6QwEOJlIkShWWShVOLhcwVJUd3TEc6bKpy+S6js3c2buHNiOAKhQaNgU6UIVCXA+Qs8vsiW2i4FSZrWaZqWZZtPIsVJeJ6Ca9vhhbgt34FI39XZdzbdsoo4FOWsnYJR5eeJWfZCaZLC8yX8uTsouoQuGm+BYsz2FXZICroyP8h6EbWc/B/AxPpSd4PHWYFZK1VBQeGLyBfbFRBs0YrRSdGm+Xl/hp7jgv5k9xoppmoZZHAnE9QCt9vihB1UBFMFlJskKyQuAhebUwS48Rok3zE9VMNorb62bqDtbxAal8QPfWPVTHBjJZSPNcappH5iZwpAeCpu4e2M4nuzcxEoyxnr9452V+mJjiewvHmCxkOJhd5OX0PFOlHMlahc2hGD5Vo5kOX4CgphPUdCbyGSTNHV5OEVR14oafmGHSyt6OPnbGOrmlZ4gTpWXeyCbxkKzIWTVAcm1nP6aqkaqVeWzmGCeKeVaTwL6uAe4bu5wdbR1kalWmCjls6QECCdQ8hz2dvfz65m18ZnATuzu6GY3EWE1XVDpMP3s6e9jd3s2nBka4rK2DoK6zWsTwsSUa4/ruPvZ29uJKyZFsirJjA4KGiuuAgEtjcaKGj7xt8f++/QazpSLnCKaLBcaibWyORFGE4L2Wl5fZv38/L7zwAhfrU5/6FL/zO79DMBhECMEv0p49e0gmk0xNTZHL5fiozMzM8Pzzz3PHHXdgmibvVXVcnp2e55lT86wmgb5wkN++cjufGBlAVQRvJjMUajYgaKi5LjHTx2/svIT9Y8NcN9DDs6cWmCuUWa1su1w70M39u7fz8a7N3NS+lYjuR1dUVrsk2MWloT5uab+UQbOdd0qLJKw8HpIGW7qoQuGunt18vvsKPtV5GZeF+hgw21jPklXgu0uHOFFJIxGsdlN8jPsH93Fd22b2tV3Ceg7mZ3gqPcHjqcOskKylovDA4A3si40yaMZoJW2X+D+nn+EHmQm+l36LN4sLHCrO8UzuKLO1HCm7zK5QH630+aIEVQMFwWQliWSFYIWH5NXCLN1GiDbNT1Qz2Shur5upO1jHB6DxAdxb91AdG8hkIc1zqWkemZvAkR5nCUBy1t0D2/lk9yZGgjHW88eHn+XlzDyulCDA8lxWvJFbYr5c4Mhykv+4/Trihp9mtkU6WPHIzDt4UtLMw9Nv03BrzwgjoSitdJoBqq5DQNNxpMdpApCcVnYdMrUKUcNHolIi71i8V811CBsGcdPE8TzSVhXLczlDAgJPwmQ+Q8TwEfeZKELQjK4oNPQEgqwnpBusVrAtzpCAoGG+WKRgWUhAFQKBYC2JqqjkbYua66IpCqsVi0W++tWvcuDAAS5Ed3c3gUCAEydO8F6BQIDh4WEikQhCCH4Z/uAP/oBjx47x93//90gp+agcOHCAr371q/zjP/4joVCI1SqOw0KxjCLAk6zhU1W6g35UITBUlVS5CgKQEhA0pMpVXE/SGTApWDY+TeX9JDXXJaz5iPkMGhQhaCaq+4nqfizpcLKawkOyWtGxmKlm+WzX5ahCYT1SSoQQJGp5Cm4NiWC1qmcT0Uw6jBCKEKznYH6Gp9ITPJ46zArJWioKDwzewL7YKINmjFZSdomvH32UY+UUDh4NLh5lz6PhxfwppipZ3ikn+dPNn6aVq8KDnCF4NH0EEKwmAUt6/D9zP6fhRjYzaMbYKB6qo+7v6rhAKhfo3rqH6thAJgspnktN88jcBI6UvI/gtLsHtvPJ7k2MBGOs548PP8uL6TkkqwjWKLsOi9UyB7OLXNfej1/TaabDFyCo6QQ1nYl8Bklzh5dTBFWduOEnZpi0oikKE8tpjhey1DyX0wQIAT5F5bqufiaWM0R1H88kpim7DqsNByO0+UxCmsFbuTQ+VeWtXAZHeqyQwLVd/UQMg7xtkapW6DQDXCzb83A8l7dzWZbtGucIRiNRrurs4VQxz8nCMicKyySrFSTnqEJwY98Al7bFEUKwolqt8pd/+Zd8//vfJ5PJcD5+v5/f/M3f5M4776RSqTA1NcVqPT09/Mmf/AkjIyMIIfhl8DyPG264gVdeeYWTJ0/yUfE8j1qthuM47NmzB03TWGGqKrOFEgcX06wW0DR2dLaxrT2GT1OxPY+pXIFkuQqCdwm6Q34+samfY5k8yXKVyUyOZKmKJyUrVCHoCZts6Q5wrJJAAiHNRAhBK7Z0SVpFjpWXWCGBsGbyaz1XMmDGUIRCKymrSMYu8UZxjojm58fptyl7NquN+Nu5KjrC5kAH6zmYn+Gp9ASPpw6zQrKWisIDgzewLzbKoBmjlZRd4utHH2WivISHZIVkNUHRszheSTNRTvIr8a200ueLElQNVBQmK0lWSM7xkLxamKXbCNGm+YlqJhvF7XUzdQfruAAqF+Deuofq2EAmCymeS03zyPwEDh5nCN7r7sHtfLJ7EyPBGOv54yPP8mJ6jqYE75OxKhzKLXFdez9+TaeZDl+AoKYT1HQm8hkkzR1eThFUdeKGn5hh0sqOWCeT+QzJahlbemhCwVBVOswALyzN8dziDOPpBAFNo+K6NHhS0uHzI4C5coEfL0xzMLPI0UIOv6bjeh4C8JBEdR9lx+bphVP8bHGWY8s5LM9lazTOxVCFoGGpUqHkWBQdm4aYYeJTNX44e5IXFxeYKxXJ1Kq40kNXFDwpkcD+4c3cNrQJU9UQQtDgui7PPvss//RP/8T4+DgXQtd19u7dyze+8Q2OHj3Ka6+9hm3bNAgh6Onp4Utf+hI9PT38sgghsG2bSCTC9PQ0S0tLeJ7HRyGXy6EoCgMDA4yMjKAoCg0SCBk6ZdvhxHIBVQjChk7cb3L39lGGo2GEEBiqSrpcpWjZ5GoWQkDUNIgaBj86McfLc0sczSxTsBwsz0NXFWzXoyHs0/H7BY8VnuO57CTztRxl12I00IUQgmaCqo+8XSHrlElZRTShEtH87Itv4crIMJ1GmFZmq1n+OfEq/5p4jZ9k32E8P4NfNai4Ng0ekg49xN7oCL/Ru4f1HMzP8FR6gsdTh1khWUtF4YHBG9gXG2XQjNFKyi7x9aOPMlFeYjXJagLJOaeqWSbLSX4lvpVW+nwRgqqBimCykkSylgRcJK8WZukxQrRpfqKayUZxe91M3cE6zkPlPO6te6iODWSykOK51DSPzE/gSI/TBO8SrLh7YDuf7NrESDDGev74yLO8mJ5jXYL3yVgVDuWWuK69H7+m00yHL0BQ0wlqOhP5DJLmDi+nCKo6ccNPzDBp5cbuIRq2ROJ0m0E2haJM5NMkKiXKrkPOruFKyaf6RugLhNnT0UNE93GyuEy6VqXo2JQcm6JjE/eZ3DWylaCm8/HuAWquy0Q+TdV1qbgOyVqFmVKBLn+QwWCYixHSDYZCYeKmn55AkJ3tHfQEAoynFik5DhXXIVWtYKoaW6Jt7O7sZnMkxqcGh7lteDMRw4ciBCvy+TwPPvggDz/8MBfKcRyuvfZarrnmGhzH4c033ySRSLBi69at/Oqv/iqdnZ38MpmmSWdnJ/v27WNgYIDR0VGmp6fx+XxUq1UuxtTUFNFolOuvvx7TNGkQQhA2dIYiYXpDAbqCJh/r6eDObZvZ0RlnhU9V2RQLE/YZDEZDXNIW5bLONl5ZSLJcsyk7LplKjYbNsQiXd7VzWWcbm9rCmJrK4cQyeSVHRStyqpKmod+M0a6HEELQzJZgNxHN5JJgF2HNz+3dV7A3tomxYDetlNwaT6Xf4pn0JCerGUquTdYp40nJZzq2M+BrY29shL3RTdw3cB3rOZif4an0BI+nDrNCspaKwgODN7AvNsqgGaOVlF3i60cfZaK8xGqS1QSS9ztVyzJZTvIr8a200ueLEFQNFASTlSQrJOd4SF4tzNJjhGjT/EQ1k43i9rqZuoN1rENlHffWPVTHBjJZSPFcappH5idwpMcagncJ7h7Yzie7NjESjLGePz7yLC+mZzlNCNYleJ+MVeFQbonrOvrxqzrNdPgCBDWdoKYzsZxB0tzh5RRBVSdu+IkZJq3sbOvk8rZOdsQ6+ElimqniMgjOsj2PwWCE/3nblVwe78T2XF7LLFJxXVYL6TqfH7yE2wY30+YzeXrhFDmrxhkCCdRch9FwjEtj7QghuBhhw2AkFOHqrl62xuL8fHGeqfwyZwgayo7D1licL225lH09/WyPt2OqKooQrDY+Ps6f//mfk8lkuFCaprFlyxY+85nP0PDyyy9z7NgxVhiGwWc/+1kGBwf5ZQuFQnR1dXHTTTexb98+rr/+eq688kpKpRK6rpPJZPiwstks1113HUNDQ6xQhCDiM7isM87ung4u7WijNxTkvUxNYzgWZndPBx/r6eDVhSRvLmU4Q9BQdVx6QgHu2TXGjcO9dIX8PPbOKfJ2FRksga8GApJWgbFQD6OBToQQtDLsb+eyUB97Y5vZEuyi0wiznopn853F13i7lEAiWGF5LiOBdv6X4Zu5KjLMznAf6zmYn+Gp9ASPpw6zQrKWiuCBwX3si40yaMZoJWWX+PrRR5koL7GaZDWBpAkBEjhVyzJRTvIr8a200ueLEFQNVASTlSSS9/OQvFqco8cI06YFiGomG8XtdTN1B+toQaGFe+seqmMDyVoVDi0neGR+Akd6NCXgsz2j3NQ5zEgwxnr+9K3neDE9yzkSBOsTvM+JUo7/a+Illq0qrWyLdLC3vY/rOvsRtPbw9Nv8bGmGnFVlPbqi4kqJqWqcJTjNQxLUdKqug09RSVYr2J7Hey1WSigCpISI7kMVgnMkDYoQZKwqFdeh5rpcLENVUYQgrBsEVB0E75I0CKBgW0gp0VWVBiEEq3meR6VSIZlM8kGoqkq5XKZcLuN5HpFIBCklK9LpNLZts1FomkZDW1sbt956K1/+8pd55JFH+PrXv84dd9zBh5VMJqlUKniex2qKEDToqoqpabSiKwqKEBiqQkDXkNQJ6iQrqo6L43moiqAhoGugumBWaJCAIhQCikHJtXCkh5SSVhSh4Fd1VKFwPjXXxhQ6EsFqHpKQ6qNBV1TWk6jleS53nMdTh1khWUtB8OXePVwX3cSgGaOVrF3m9489zkR5idUkqwkkTQiQnPNS/hR/eurHrGdPeICPxzaxJzxAM1KAJT3+cv7nHChMU3BqbCQP1d1bRwsKTdxb91AdG4gnJcdKWf5h+g0c6dHKlmCcvfF+toTirOe/nXqTw/kk7ydBsD7BGq70eKeQ5Tuzk1Rdh1Z2tXVzdXsv7T4/6/mnk4d5NZNASsl6Os0AUcOHLhTOEtBh+klUiryUmufhE28TN0wUIUCwxo62To7kUjw5N8W/TR9lKBRBVxTOkVRdFyQ8NXuCnyZmeHFpno9CxXEYjcTo9gdA8C6JBHbGO+j0B2jFtm0OHTqElJIPQgjBLbfcQiwWQ9d1yuUyqwUCAebm5nBdl40oGAzS1tbGPffcwx/90R9x991382FIKTl06BC2bXMxbM9jKBJiJBrmNEGdpOGSeIThaAhFCKI+A1PTEAjwFKQABUGvL8qB5Sl+mp7g8cVDHCnO40nJxeo0wsT0ALpQWK3LCNOmBwioBuvxpMeB/En+efEgKyTv97HwAHsiw4z447RSci3+dv4lpqtZVpOsJpA0IUCyVk26/Hx5moeXDrGem2OjXB0eJKaarCYFdYIGW3r833MvMFlJIqVkI3mo7t46mlB5j3vrHqpjg0lZFR48MU6iVgRBS3va+vh3g5exnrlKgR8uHudoMUNLQrAuwRo1zyGg6uxp78NUVIQQNDMSjHKilGOqmOMMQTM1z2V7pJ2w7mM9ezv6mCouU3Ycyq7NUDCCBGbKBcbTCQ5mFpnMZwjqBqoQ6KqK5br0B0LkLYuXkvO8llnknXyWxWqJXn8IV3qYqoYnJRHDR6pW4aeJGcZTCSaXszRsi8W5GLqiENA1CpaN43mUHQchBJ8fHuW24c2ENB0hBM1IKfmXf/kXXnjhBaSUXCi/388999zD0NAQP/zhD3n99dc5fvw4K0qlEj09PXz6059GURQ2KlVVicVifPe73+Wtt97ig7Jtm7GxMT796U+jqioflioEMdOgYNk4niRVqWJoCjcN9/Hvto8SNgwUIQgaOqNtYd6onEQP1XBx6fPFyDsVZqs5Xswd55XlE6TtEjXP4ZJAF0IIPiwhBNdEN3GsnKLs2ZRdi2EzztXREX5r8AbO53glxX+ZfZ6sU6FB0tynOy5lf+dltOJJyclqhsfTR5iu5VghWU0gaUKAZC3JGSXPplMPcmWoH5+i0YyUksuC3RwozDBv5WmQgjrBCskZHpIrgr34VZ2N5Pa6mbqDdayiscq9dQ/VscFIKVEFVD0bybsEIFkjpBpcHe/D8lwMRaWVuUqB13IJ1idBCJC0JgDJWa9lE0zkU1zXMUArnoRuM4hf06g4DiABwWoSWKyUEELgSYkiBOv55uXX8bPFGWzPI2tV+f7cccqOgyclDalahR5/kN8e24UjJYai8npmie/PTiE5w8aj6sLWaJx/v2UnObtG0bZ4emGayeUMIHCly2y5wPdnpxiLtnFprJ2LMRAM88XRrSQqAyTKZYK6zsc6ujAUFSEEraTTaarVKlJKPohbbrmFW2+9Fdd12b59O7qus5rneYyPj/Piiy9yww03sFEJIfjrv/5rnnzyST4MKSXVapV0Ok1PTw8XI2b6uOvSzezp72KxWEZXFPb2d6EKBVURrBhrj/Gfrr6Jo+UEAjhSmOep1GFKroXkjJdyUwRVH1dGh+n1RbkYQgj+0yX7+Wn2KLbnEtZ8XBvbzPl40kMgKLs2DZLmuo0we6MjuNJDFQrNKEIwWVricDHBCslqAkkTAiRrSVYIGp7OHePXOnewU+uhGSEEVdehzwijCQUbDxCskJxhS4/5WgFdqEgpEUKwkTxUR93f1fEujXd9vu6hOjYgIQQnystkrAprCEBylockoOpoQqEVKSVl10JXVGqeC5J1SBACJK0JQHKaIqDmOqzHUBTGInEUBAhAUicBwWoFu8ZStUy3GeRCfLx7ECklk/ksj80ew0OCACSn5a0aedvi9sEt5O0ar6QWEAKkZA0FwSWRNkK6wc+X5pgtFThDAgIPyUKlRMG2+Ch0+gPETZOd8U4apJQIIVhPJBKht7eXD6qnpwchBIcPH0ZKSSqV4r1efPFF3nrrLa6//nqEEGxEzzzzDE8++SSlUokPq7e3l0gkwkch7DO4rKONnZ1xGqSUCCF4rwF/jB4zjIJC3qliey6Std4qLpCyCvT6olwsIQQ3tW1BCMGFksA75SXyThVJc5IGQUAxUBC04klJ3q2iCIEnJZLVBJImBEjWkqwQrDCEhuW5rCeg6Fwa7OaxzAQgWCFZK+2USdolwpqPjeihulTdY3XUKbzrQN14HRuUlJKMVQYkawjOcqRHolpEEYJWJFB0LDShcJrgPCQI1ic4LaKbRHQTV3q0IoSgaFtUXJvTBO+SrCaEgkSiCMGFyFlVGlK1MkFN5yzBaWXXIawbZGoVTFWj5roIIVhNFYKsVaXk2GRrFTrNAKaqco6kocP0oyoKy1aNbK3KxVKFwgohBOfj9/uJxWJEo1EuVDAYZM+ePUgpGRoaolQqoes676WqKg8++CCHDh1iI3r77bd54YUXeOaZZ5BS8mFEo1FisRh+v5+PSsmyKdsOJcvGo7WcXSHvVLA9l6DmYzUJCCGI6UGWagUqro2UkmbKroUjXVJWEVd6tJJzKkgpWXYqXAhVKHhIKp5NM5IGQc6pslDLI4SgFVu65J0qhlCRrCaQNCFAspZkhWC1uO7HVFSklLSiKyp5p4ZEsEKylgBqnouHZKMarztQx7s03rVYd1vd9+p217HBxA0/28IdvFVIARIQnCUACY7nsmzXsDwXQ1FpRhGCsVA7hqJylgAk65AgBEhaE9RJorqBKhRacTyPomNjKBpVz+E0AUjqJCBoGAlGGAiEkVIihGA9BzOL/CQxTdm16fYFyVlVVCFwpeQ0AQOBMK+mFngpOYcqFGKGD00ouMIFyWmulER1H//j1DuUHJuSY9MTCJK3LWzPo8GvahiKyhPTx1AVhbhhMhqO8SsDm/hFuuaaa4hGo+RyOS6UEALTNOnv72d2dpaxsTEOHjxIqVRiheu6LC0t8cMf/pCuri76+/vZKJ5++mmeeeYZ/uzP/gzHcfiwotEo11xzDR+Vg4spjmaWeSe9jK4q3HbJEH2hAHG/yWr/Nvcmx6sJLGnhSInteQgEEokEdKHR54vx0MzzCASdRohdkQGujW1GEQor5qo5Xlk+xZHiHK6U7I4Mc1V0iG5fhNVeWT7FM5l3KLs1un0RboiNcnm4n/V4UtJrRBgwY0xXs6wmaRA0KAjybhUpJUIImvEpGpcFe/lnXuccgaQJAZK1JCsE76ULlU49hBCCVkquRcGtAZIGyftJ4GOhPnqNMBvReN1tdYt1vEtjlcW62+q+V7e7jg1kc7CN4UCMtwopzpCA4CwBEnghPcN17YNsCsZoJagZbA7GyFgVHOlxmgAk65AgBEia0oXCnngfUd1kPVmrwk+XTmF5DmsIQFIn8Ska/YEwYc1ACMF6DmYW+YNDP0UgsD2PgGoQ95kMBMIENZ3pUp5tkXbmK0WeTkyzIqTpDAXDONJDIMjbFgFV52RxmVfSCRoEENYN9nT0cKqYJ6r70BSVt5fTzJYK1DwXVQg6fQFcKfns4GZ+EYQQBINBqtUqF6pUKjE1NYWiKNi2TSgU4tJLL8VxHN5rbm6Ob3/729x44420t7djmia/bH/7t3/LY489xpNPPonjOFyMarVKMBhECMHFeiuV5dF3TvL6YpqS7SCAQ4tpfu+aXYR9Brqi0PDPbx/lH6dfx4ot4eLRpgUIqDrdvjCqUCm5Ft2+CJOlBHmniuSMk5U0jvT4eNsWhBAkrQL/feEVxvOnmK8tIxA8nZnk/sF9/FrXFfhVnYZXl0/xe+98FwWBLV2CqsHz2eP84eZPc1mol1YUIdga7KbXiDBdzbJC0iBYYUmHn+WOc010mHY9SCtdRoixQCdvFBeQgKQJAZK1JCsEq0kgovq4NjKMqWis51Q1x1PZd2iQNBdQdEZ8bQRVg41mvO62usU6VlF5j1Ldo3U31/XVsUG40mMwEOV4KUOyVuYcwWqKEJiKyoA/gl/VaSai+1AE/Dw9i4fkLMH5CcF7CWAwEOGzvaNcGu2glYJt8dTiCd7ILVFwbN5HcNrmUIz/desewrqP9eSsKv/1xBHmKgVs6YEA23ORwCd6hrlzeBuf6BnB1DR+tjSDh2SF5Xl0mH5+77Kr+Xj3IFfEu0hUikzms6xW81yu6ezlt8Z2sa9nkGytwonCMhXXBgQSqLgOHpLLYu2EdINfBL/fj67r/PjHP+ZCCCHwPI8rrriCnp4eGnbu3ElnZyc/+tGPWE1RFJLJJKlUijvvvBNVVRFC8Mvyve99j29+85u8/PLLuK7LxfrmN7/JJz7xCUzT5GJYrstriRRPTc1QtB1WVByHZLnC3v5u/JrG0cwy//jWW6QDc3iaTUPVs2nTg3yuaxd39+7hlvZtHC8nOVJcYLU5K0enEWJ7qA9D0ThRTvNE8k1OVTNIBJIzJkqLXBEeoMcXIWuX+bu5F5mr5rCliwQs6dIQVE0uC/agKSqtSfp8Ud4szpN3q0gaBCsk4CFBQFA1GDbjGIpKM51GiLxTZTw/i4vkfQRI1pKsEKwmAU0ojPrbubNzJ5v8cVpZsAp8N32Etyspyp5DMxK4ITLM7w9+HEUINpLxutvqFut4D4UmFutuqxuvY4NQhUJU8/GrvdsYC7VzjmS1lFXmpewcU6UsBceilZs6R/ja6FW8j+A8JAjWEMAnujexr3OIVkqOxWvZBV5Oz5OolWhlKBjh31+yi5BucCGytQq253GWgLJjM1MpMBgMMxKO0iAQnCY4q2TbWK7HcDBCTPexVC3TjKlq9AfDtPv8CCEoOzZnSBpcKZktFbE8Dykl5yOlRErJxYhGo+zbt4+77rqLCyGl5NChQxw9epSG7u5ujh07xq5du/ibv/kbgsEg4XCYUCjE9ddfzze+8Q1uvfVWarUav0xSSk6ePMmJEyfwPI+Lddddd7Fv3z6i0SitSCm5EFLCTKFIyXZ4r6rrYrkuUkpqjku2VsPDY7WUVQQEfWaUDiOERLKG4LTZao6SW6NhwVomZRWRCFZThKDiWXjSQyLJ2GVs6SJ5l4CiZzFTy9IgpaQVQ9Ho80X5Ys+V9PmigGCF5F0CTlWzPJ87wbFyiqpn08qXe3bzP/VexfsIkKwlWSFYTXLOFzt3sTvcTytJu8RL+WlezM+QcSo0I4HdoX6+1nsNINlIxutuq1usowmVFkp1j9bdXNdXxwZgqhoRzUdMN0laZdJWhXMEK9JWhaVaiZFAlIBm4FNUmhkLt9Nu+HkpM8cagvMTghW/MbSDL4/soJWSY3Ewm+D7C8c5lFviNMH7DAUi3De6i0vCbYQ0g/Opug4LlSJv59OsJpHc0DlAUNMxVY1D2SXmygXKrsNpAhAgpeSazj7yjkXM8PF0YpqcXWO1Dp+fj7V3c0m4DYlk2a7xejaJ5bmcI9gWbWd3RzfLVo1crUbMZ9LMQrlE1qrhSI+K4xDQdD6swcFB8vk8ExMTpNNpzseyLJ599lluueUW+vv7CYVCxGIxxsbGGBsbo6enh1//9V/ni1/8Il/+8pe5+uqrMU0TIQS/LJlMhr/4i79gamoK13W5GGNjY9xzzz3cfvvtNFO2bRxPcnK5QMGyiJk+1qMpCnOFEgfml1hNEYLt7W2EfDoCqDouJ6pLLCqLoHg0SCCqBfjV7ivo9kVwpcv48ilmq1kc6YHgNAXBqL+TT3ZsRxMKZdfi35ZeR7LWJn87vb4YvUaUY5UUebfKRGmR0wSnSSQ3tm0hoBoYikbOKRPWTJoJaT7CqklU8zNdzVJwa0jeJThrtpaj5NUY9LUR0XxoQqWZqyKDeFJysDjHaQIka0lWCFaTnPMfh27m9o7ttJK0SxzIz/DPqTeZqKRoRgK7Q/18rXcvw2YbflVnoxivu61usY4WVNZRqnu07ua6vjo2AL+qE9NNYrpJ0iqTtiqcI1ixVCuxUC0yEogS0Ax8ikozY+F22g0/L2XmWENwfkLwpeEdfGXT5bRSciwOZhM8MX+M8WyCMwSnCc4aCkS4b3QX2yLtxA0/F8JUNXJWlaxVI1krowiBBNoNP3nb4pnENM8vzWJ5HouVEh4SV0oUIZBATyDETLnAk7NTvJpOENR1srUqLpKGsK4zFIxw5/BW2nwmmqJQcRzStQqZWhXb82gIaDphzeCpuZM8m5jlaD5HybHZGo2z2jPz0/xo7hT/cmKS5xJzVFwHVVHo8gf4sK688kqmp6c5cOAAUkrOx7ZtXnrpJa699lo2bdqEaZoUCgUMw+Bzn/sce/fuZcuWLaiqiqIoCCH4ZSqXy/zDP/wDU1NTXAxVVfnKV77C7//+79NMslzhrVSG/3LoCE9OTfNOdplkucLOznZakVIS8uks1yxOLhdRAFURdAZM0pUqp/JFfnxyjgPzS2hSo6wWsdQqDVEtwE3tW7k8PEDcCKIrGj2+KC/mprCki4uHBDb7O/na0E10GEGEEBiKhqkavF6YRSCQQFwL4AHztWWeTB3hhdwUWbuEEIKyZ6MgkECHHiLnVPhhepKf5o5xuLhAhxGkxxehmYhmEtVMopqfU9UsBbcGgjUkcKKaoeBWGfS1EdF8aEKlmasig3hIDhbnkKwlWSFYTXLOHw7dwh2dO2glaZc4kJ/h28nXOVJeohkJ7A7187XevYz5O4hoPjaK8brb6hbrWIfKeZTqHq27ua6vjg3Ar+rEdJOYbpK0yqStCucIVizVSixUi4wEogQ0A5+i0sxYuJ12w89LmTnWEKzrS0M7+MrILlopORYHswmemD/GeDbBWoLTBAwFI9w3uottkXbihp8PYjTchqmo9PhDSCTXdQ5QcmwmCxkKjkW6ViFVq9BlBhgNtbE92kHU8LEpFCVZLfNOPkvBsUjWyhRti6s7eukLhBiLtLEj1smXNm9nKBRhRZc/QNTno91nYqoaO9o66TL9vJZZImfVWLYtFsolZkoFYobJSDhKw1vZNE/MTPHc4izLdo1MrcqJQp6ApjEYChPUdD6sT33qU8zPzzM+Ps75eJ5HpVLhhRde4KqrrqK3txfTNOnt7aWtrQ3DMNhIfvCDH/DYY4+RTqe5GL/1W7/FX/3VX9GM7XnM5Iv859eO8E52maJts1Ass1AsoyqCbe1tNCOEIKBr9IeDxE0filD4WE8HFcdloVghUSyTq1ks1yyytSr7RjrYGu0kboT5dMcOrmnbxJZgNyviepBd4QFqnsOQP86WYBf/YehGunwRTFWnwa/qtOkBtgS7KLhVrooME1QNpippErU8KbtEzqmQtsuMBjq5qW0LINjXNkrRrfF2eZG8WyVll0haRY6UEuwM9RLXgzQT0UyimklM8zNdzVJwa6yQnHOimiHvVhnwtRHRfGhCpZmrwoN4SF4rzrFCskKwmuScPxy6hTs6d9BK0i5xID/Dt5Ovc6S8RDMS2B3q52u9exnzdxDRfGwU43W31S3WcR4qF6BU92jdzXV9dWwAflUnppvEdJOkVSZtVThHsGKpVmKhWmQkECWgGfgUlWbGwu20G34OZOYQrCJYQwCGovDFwcv4ysguWik5FgezCZ5YOMZ4LkFzgqFAhPs272JbpJ244efD2BSKcXlbF9d29BP3+fnB/BQV1+E0AY7noQqFu4a3cefwVi5v62SuXOTVTAIEZ1mex2Awwv9+2dXc0DXAjlgHXf4g79XrD7El0sb13f1cEe/i6YVTzFeKnCGQQNV16PQHuDQWRyB4O5fmf0wfw/Y8ThNguS4F2+bjPQOEdR0hBB/W/v37SSQSjI+Pcz61Wo1MJsMTTzzBtddey/DwMLqus9HMz8/z8MMP88QTT3Ax7r//fh588EFa8TyPhyeOMZ5IslrJtokaBts74vg1jWYUIYiZPq7o7mB3TwebYhEm0zmm80UkZ0gkdC0y2h7igeGb2Re/hG2hbnrNGO8VN4JcHh7g421jXN82SpsexFR1VovpfkYDHVwb3cy1sc0s2QXeLiWoSQfJGUJARPNz/8D1fKbjMuJGkO+ljlDxbBokYEsPTShsDXSxyd+OEIJmIppJVDOJaX6mq1kKbg3JWhI4Uc1QcGsM+GJENB+aUGnmqvAgHpKDxTnOEawmARWBLlT+j6GbuaNzB60k7RIH8jN8O/k6R8pLNCOB3aF+vta7lzF/BxHNx0YxXndb3WIdF0DhAi3W3VY3XscGETf8XBnr5dd6tzEWauccyWpv5pf4++nXOVHKUnAsWrmtdwv/25a99JohAqrOWYLTNKHQbYa4Z3gXXxnZRSslx+JgNsETC8cYzyY4TfA+Q4EI923exbZIO3HDz8XQhCCkG2hCIHkPATXPIWdV8SkqIc3A8lzOEpwlkXhSYigKfk2jlYCmE9YNNEVBVQTnSBo8JDmriu152J5HzfOQSNYQ4EoP2/OQrM+TkgZPSqSUNPPggw9y//33cyGq1SqWZaHrOkIINqJHH32Ub33rW1yM+++/nwcffJBmPCnxpEQIgeNJELxPtlbD8TzWowhBQ9xvEtA00pUqUkpWc4QLAjShENZM/KpBKwHVwFBUNKGgCoVmVKEQN4IYikraKmJ5DpJ3CZBA1XPQhEq7EUQVCp7kNMk5Vdch45RpcDyXVgbMGNdGR/hi98foM6KsJjnnmewx/tviOMfKaaqeTSu/3Xctv913LQO+GLpQWU0CIdWgzxfhm8O3ckfnDlpJ2iUO5Gf4dvJ1jpSXaEYCu0P9fK13L2P+DiKaj41ivO62usU6LpDKB1Cqe7Tu5rq+OjYAv6oT001iuknSKpO2KpwjWLFUK7FQLTISiBLQDHyKSjOXhOIM+COENJ2K6xA3TAKqjk9V+WzPFj7ZvYnberfQSsmxOJhN8MTCMcazCdYQnDUUiHDf5l1si3QQN/xcjGS1zOHlFLPlAieKOSquzUKlxGqO9PjiyHa6/UFMVWMin+ZYIYsjPU4TENYN+gJhBHCskENXVDwp8Ws6rZRdm1StyvFCFtvzWCGBzaEYYd0gUSnx9nKauXKRquuwQhMKmyNRru7spc1n0krBsqi4Ds8vznGykKfd58dFYigq77V//34SiQTj4+Osp6enh+985zvs3r0bVVXZaB5//HF+93d/l0qlwod1//338+CDD9JMtlqjYFm8NL/IRDqHX1OZzOSwpcdq+wZ6uWGgFyEE5yOlxK9rLJYqHE5mOUt4REyDzw2PMeSPoysqrSzW8sxXl3klf4plp0JUMzEUjVYEAke6PJ15B0md4KzPtm9nd2QIv6pTdGokrDwnqhlWs6TD7sgQ87VlKp5N0bWI6wGaiWgmUc0kqvmZrmYpuDUkqwkkcKKaoeDWGPTFiGg+NKHSzJXhfto0Px16kLRdplMP0qYFaNP87G+/lLu6dnJL2yW0krRLHMjP8O3k6xwpL9GMBHaH+vla717G/B1ENB8bxXjdbXWLdXwAKh9Qqe7Rupvr+urYAPyqTkw3iekmSatM2qpwjmDFUq3EQrXISCBKQDPwKSrN9PvDjIXaubFjiB3RLq5rH+BzvVu4qq2XsXA7rZQci4O5BE8kjjGeTdCUgKFAhPs272JbpIO44ediTObTfH9+iv9v6g0OpBc4lF2i7NrEdJOCY+FXNYSAB7Zcye72HgxFpeGKeDeT+QyZWhVberT7/IQNg9lyntczSZ5bmuXt5TSW59LrDxLQdJrxqxqO51FyLJatGh4SgSCo6QgBj88c5+dL85Qcm7xlYSgKEgioGl3+AF8YGeOK9i5aKdoWR3Jp/vrtN/jB7AleSSYYTy0yGokR0g10ReG99u/fTyKRYHx8nGZ6enr413/9V66++moMw+BiSClpEELwUfnJT37Ct771LY4fP45lWXwY999/Pw8++CDNZCpVXk+m+c+HDvP0qVkOLaWZzOToDvppqLouqiK4cbCPL166hYCuI4TgfIQQNAR1nZrjcnK5gK4oRE2DG0c7+Vh7L71mlFbmqjkeTrzCI4sHeSp1hDeL80yUFrkyMoip6DQjhEATCiHNx+HSPIai4UiPG9u2cENsM1uD3TTE9QDLToWKZ5Ow8vgVnYYOI8hsbZknUkc4kD/Fq4UZhsw2en0RmoloJlHNJKr5ma5mybs1zhBIzjlR/f+5gxPguu/DwO/f3//+vxsPD/dBULxlHZQom5Yly6avTUwl3mxzNOuNnYRJ4V21mTSZaTeTaWc7bSZJO51kpq0M7TqbwxrFjp0odGTL9iqWLJ+SDVMUSfE+ABDHew8P7z7+569/UAYJ0QBFkZQE7+ezRD1wGDEzpDQTTaisZaud4/Z4Hx/s2sp70pt4d2qU/7b3bu5LDrHVzrGeotfkhdoMTxQPc6xVYC0S2JMY4pGBvWy3c6Q0k41iMrI/ko/wBqncgGbkYGRfZDDCBmCrOhndIqNbFN0WJbfNFYIVBafJfKfBWCxNTDMwFZW1mKpGXDPoNeP0WnHSuoWpaqyn6bscqizw1PwZJssLrGc0luLAbXezM5Uja9jcDCfw+WZhhscvHMOTIU4Y4MmQVuDz7twgDw9t4fZ0jl8a3cW93X0kdYPV3t8/SlI3uDPTw+6uXs42KhQ7LRq+RyAli06bmueyOZGhz4qjCMFaBmMJ+u0EuzLdbE1l2JHOogjBy+VFPBnihiEV16E/FuddPf28r3+Evb0DfGhwjPt7B1lPKCWdIOA/nniZl0pFvDDEC0MWnTYzjTr7BkcwVZW1PPzwwywsLDA5OclqfX19fP7zn+dd73oXpmlyM3zf59ixY6RSKTzPQ9d1bkYYhjz55JP8yZ/8CYcOHaJWq3EjxsfHmZiYYC2BlCy1HR596SjnqnX8UOKFIU4QkNR1/u0972BLJsWDw4P88s4tJAwdTVG4XkIIMpbB9myGsUyS7dkMP7tllHt7+tiW7GE9TujxTOkEz5ROMN0p4wM1v0PVa9EOPe5ODqEKhbWkNJtBM809qRE22d18JLuTh7q2cl96E6vtivfTayS5IzHAnckBtsV6mXfrnG2XCJA0ApdG4HK+XWJPaoSkZrGWlGaR1izSms1Up0w9cJH8pPPOEvXAYcTMkNJMNKGyFkvRyWg2vUaCQTNFQjUxFY31FL0mL9RmeKJ4mGOtAmuRwJ7EEI8M7GW7nSOlmWwUk5H9kXyEG6Byg5qRg5F9kcEIG4Ct6mR0i4xuUXRblNw2VwhWFJwm850GY7E0Mc3AVFRuRtN3OVRZ4Kn5M0yW57lECK42GktxYPPd7EzlyBo2N6vidvjc9AkKnSaraUJhLJHmVzbtYlc6x3AsiaVqrGV7Ksvt6W5UReGlpQL5TgsEl1XcDoOxBPd093EtOctmOJ5kZ7qbtGHy5NRpWoHHqwQS6AQ+Pz+6lQ8NbWJrsouheJJrEULwg+ICB6fO4EvJal4YsjmZZjieRAjBWh5++GHy+TzHjh1D0zQGBgb47Gc/y969e7Ftm5tVq9X44z/+Yx599FE2b96Mpmmk02luRLFY5IknnuB3f/d3uXDhAo1GgxsxPj7OxMQE65ESvjkzy7Mzs4RSghCssDSV940O8YFNw+zIZjAUBU1ReKMUIYjrGtuyGXZ0pxlKxum2YlyLlPBU8QiH6jNIBCs6oU+3HmdPehRbNVhPQjMZMTNsj/Vye2KAHiPJWobMNLvi/Wyxe1hwazxTOkWAZJkEfBkSUw0eymwhq8dYT0qzSGsWGc1mqlOhFji8hgAJnO8sUQ8cRswMKc1EEyo3o+g1eaE2wxPFwxxrFViLBPYkhnhkYC/b7RwpzWSjmIzsj+Qj3CCNm5CP7I98ObInwgaQNWzuzQyw7Mn5E5xqlHiVBAQrjtQK/NX0YX599G42x7tIagY3oum7HKos8NT8GSbL81whQQiQXDIaS3Fg893sTOXIGjbrafguCc3ACwN0RWUtoZQ0fJdlXhhwNQH4YcgyS9W4Fi8M0ISCEwaoQnCZACRIwFBUroeuKEgpsVUNS1W5QgICU1XRFQU3CFAVBQOV1yMQSH5MAJJLhBBIQBGCa/n0pz/Nrl27KJfLfOxjH2PHjh3Yts2toOs609PTPPPMMywsLPCLv/iLfPSjH+Wuu+7CNE1ej5QSIQQvvvgiX/rSl/ijP/ojbsb4+DgTExNci6oIEAIh+DEJQoDkEl1RUIRgmRCCGyWEYJmhqlwvS9GRCK5mKhqhlLyeEIkrfQypoiAQQnC1UEokEjf0sRSNEMkyyY8JMBUNieT1DFsZ3sMYy57Iv8SsW+USAZIr/rlyBgl8om8PW2PdWIrOjSh6TV6ozfBE8TDHWgXWIoE9iSEeGdjLdjtHSjPZKCYj+yP5CDdB5SY1Iwcj+yKDETYAW9XJ6BYZ3aLotii5ba4QrCg4TeY7DcZiaWKagamovBFN3+VQZYGn5s8wWZ5nTUIwGk9xYPPd7EzlyBo26zlcyfON/AVeXJpntl1n0E5iqRqrzbRqfG9xlueLM5xrVghkyFSzxtV+/bY72ZLs4lqqrsOTM6f4bnGOpufycqVIy/cI+TEBt2e62de3iT4rhiIEr0cIQd13KXTazLYa+DJkmSZU+uw4Nc/lfKPKmVqZiuswlkizHiklKcPgYrPBdLPOJYJL7szm+PjWXaiKwuvZu3cv9913HyMjI+i6zq3yhS98gaeffppCoUChUOD48eN85StfIQxDyuUymzZtIgxDFEVBCIGUEiEEQRCwsLBArVbj05/+NAcPHuTRRx/lZoyPjzMxMcHrCaUka5kcXypTbLW5TAjeOzLIw7eNoQjBWy2QkqJbZ8GtUfHbrMjqce5NjfJg1xauZaqzxLcq53i2fJrTrQKeDBkwUwghWBHIkG9VzvLPS6f5Uf0iU50KrgxY8ttcIiCuGtxmZ/lI905iqsHrSWkWac0io1lMORXqoYPktSRwvrNEPXAYMTOkNBNNqLwRRa/JC7UZnige5lirwFoksCcxxCMDe9lu50hpJhvFZGR/JB/hJqncAs3Iwci+yGCEDcBWdTK6RUa3KLotSm6bKwQrCk6T+U6DsViamGZgKirXo+m7HKos8NT8GSbL86xnNJbmwNjd7EzlyBo265lcmud/PfJNjtcWebla4EyjwtlGmXu7+jFVjWXTrRpfmTvDX557mVP1JV6uFKj7LjkzBggyhoUuFH57293c09VPTNNZT9V1+F8OP893ihd5uVzgZK1MTNMxFJUuw8ILQ+7J9vHe3mHemRvA0jSuV0o30YSCj6TlecQ1ndFEitlWnYvNBofLRV6pljhVXUIVgh3pLGsRQiCArGnhhgFLTgdb1bkn18tvbb+ThK6jKQrXwzAMhBDcKocPH+Zv//Zv+drXvsaKZrPJ0tISX/va13j55Zf54Q9/yOnTp5mbm+Ps2bOUy2VOnjzJd7/7Xf70T/+Uz3zmMxw8eJDJyUluxvj4OBMTE1wPIQSBlPTHY1Qdl4bnYWsaDw0P8cs7tpIwdFQheKupQqHfTNEMHISEitfmtliOvZkx/t3oQ1zLVLvEPxaP8J9mv8PJVoEf1KZZ8lqoQrDZziGEIJAhTyz8kH8qHuPrSyc53sxzqlVEUxS2xXJU/Dab7Cxb7RyPDL+XITPN9UppFmndIqNZTHUq1AKHFZIVgvOdMvWgw4iZIaWZaELlehS9Ji/UZniieJhjrQJrkcCexBCPDOxlu50jpZlsFJOR/ZF8hFtAcAv1Rb4c2RNhg1hy2/yoMs+T8yc41ShxhWC1O1O9/Pro3WyOd5HUDK6l6bscqizw1PwZJivzXCL5CaOxFAfGdrMzlSNr2Kyn0Gnyv7/ybU7XlwikZEWfFeeXR25n/+AWBIJn8hf4v45/n6s9kBvmZwduI21YaEJhyE5gazrr8cKAvzp3lH+6eJp24HOJhLhm8EDPEA/0DKMpgtF4ipRuEtN0bsRMs07H9wiB7xZm+erF8yy5HUCwTEFwZ1eOR3bdw+ZkmvV0Ah8/DDleWUIguCfXix8GmKrG26FWq/Hoo4/yB3/wB1yLEIKuri46nQ66rjM4OEij0WB+fh4hBJ7ncbPGx8eZmJjgjWp6HooQHF1cQhFwZy6HAHRV4e1U9ztUvDazToW0brMr3s+1hFLy1dIr/NH5r7NC8qp/2XMnvz30Hrr0GGdbi0zMfodvV86zQvKq3xl5L1vtHDkjTlw16TOS3IgZp8J3qxd4Iv8Ss24VyQrBah/MbOHX+vawLdaNpehcS9Fr8kJthieKhznWKrAWCexJDPHIwF622zlSmslGMRnZH8lHuEVUbqFm5GBkX2QwwgZgqzoZ3SKjWxTdFiW3zRWCFQWnyXynwYCVwFY1bFXnalJKqr7D90oX+Xr+PJOVeS4TvMZoLMWBsd3sTOXIGjbrkVJS8x2eK05Rctus5gQBm+MZ7sz0EkjJNwoXONMoE0rJarqisH9oK5tiaXJWDF1RuZaW7/PtwkVO1Ze4TIAXBnSZNr80toPNiQwxTcdQVW5U2jDpMi3SuslCu8nzCxeRrBBIQAIP9g3TbVoIIViLpijoisJgLMFgLI4ANEXl7eC6Lp/73Of4nd/5Ha5Hu93G8zwcx2FxcZFarUYYhoRhyM0aHx9nYmKC9UgpEUKwFkNV0YRgMBFnIB5HFQJVUXizSSkRQrAeU9FIahYjdhc9RoLX48qAr5VOcLpVJEQiuSJA8mDmNtKazVRniX8ovEwzcFkmeVVcM3hPeowPZreT1mySmsWNSmsWac0io1lMdSrUAgcQrCaBc50y9aBDjx4nrVkYisZaZpwqz1fP88XFoxxrFViLBPYkhnhkYC/b7RwpzWSjmIzsj+Qj3EIqt1gzcjCyLzIYYQOwVZ2MbpHRLYpui5Lb5grBioLT5GK7RiBDbFXHUFR0oRBISdnrUPE6PDFzlG+XZjhWK/ITBJeMxlIcGNvNzlSOrGGznqLTQhUKi06bk/UlZtt1EFwmkTzYM0JSMxFCcKpW4nyzihsGrBBAUjP4yMBtpHST6+GFAdPNGi9XiryGgLu7+tibG0IVAkUIbpYQghBJ1XM4VMrTCQKuEPTZMT62aSsVz6Ht+8R1nbXUPBdFCBqehxeGmKrKW811XR5//HEOHDjA2218fJyJiQnW4vgBfihpeC4N1yOu66yl4rg4YYAqBG3fx1RVboQXhijAbKOJEwTEdZ211P0OmqJScOuEhJiKzlqEELweN/SZc6pI4Hgzz/l2iY70WSGApGrx/q6t1H0HJ/R5evEEjvSR/JiAXiPBA5nNbLazqELhZqU1i7RmkdFsLnQq1AOHFZIrznfKFL0Wrgzp1eOEUqIKgUBQ8lucaZf4z/lJnquc41SnxFoksCcxxCMDe9lu50hpJhvFZGR/JB/hFlN5EzQjP6mv9AAAgABJREFUByP7IoMRNgBb1cnoFhndoui2KLltrhCsKLltplpVvrt0kYbvcrRe5FityDcXL/CF2Vc40Six4DR4leBqo/EUB8Z2szOVI2vYrGeyPM9fnX+Zfy5c4Luli0gkLd/DDQMQXDJgJah5Ds/kL3CkUmDJ7VDotJBAKCXLFATjW+/hHekcihBcD0NVqXgOFbdDodNixY5Ulod6R9icSKMpCreKKhRagUfRaVPstPDCkGW6ojKWSPOthYs8Oz/DyeoSLd9na6qL1Y5XSjwzO8UXL5zm2flpWr6HIgQ9doy3iuu6PP744xw4cIC32/j4OBMTE6wl32pxqlzhL46+wjemL3KyXEEgGE0lWW1yocAz0xf5h9Pn+O7cAk4QYKoqXZbJG9HyfM5Wqnzu+Bn+4dQ5TpQqlNodduW6WG26vcTTi0f54sKP+PLiUSp+m1BKBq0Mb9SpZoGnS8f5y7nv81J9lpLXZMGpESIJkawYsbo42y7x94XDzDo1QLLoNblEQEI12Wxl+W967yKl2dwqac0irVl0aTYXOhXqgYPktSRw0a1yrlPiW7ULVPwOx1p5nq9d4J8rZ/mLhR9yvlMm7zdZiwT2JIZ4ZGAv2+0cKc1ko5iM7I/kI7wJVN4kzcjByL7IYIQNwFZ1MrpFRrcoui1KbpsrBCvaoU/NczhaK3C0VuCl6gIXmlWqvoMbBlwi+DHBitFYigNju9mZypE1bNbzcqXAf3jleWbaNebaDYpOi0WnxZ2ZPm6LZ1CFwu5MH1Wvw4n6EmW3w8V2nYbv0WVYbE5kGLQTpHSDA7ftZndXHwnN4I0YS6RZljQMQinZk+3nfb2jvLtniJimc6t1mzZxTSeh6ygIhmIJ7sj08OLiAhdbDRadNhdbdc7Xa8Q1nS2pDMvmWg2evHCGZxemOdeokm+3OFuroisKg7EEScPgzea6Lo8//jgHDhzg7TY+Ps7ExARrcYKAc9Ua/9/hI7xSWiLfajPXbHK6UmUgHmMokWDZ6XKFfzx7nm/OzDHbaDLbaDJVq2NrGkPJOLamcT1CKSm02vzVkRM8Oz1HueMwXW8wU2vihyHv6MmyrOw1+fv8If5L6TjHmwssek2ONxYQCPqMJN1GnOu15DX5x+IR/nr+BUpei+lOmWbgkNFjbI31MGymSWkWA2aaOafKkeYCZb/FuU6JZbcn+kloBtvtXu5MDPDbQ/czanVxq6U1i7Rm0aXZXOhUqAUOKyRXNAKXgtfkcHOeF+sXOdSc53S7RCv0cWTAWiSwJzHEIwN72W7nSGkmG8VkZH8kH+FNovImakYORvZFBiNsALaqk9EtMrpF0W1RcttcIbhMcInkVZI1CH5MMBpLcWBsNzuTObKGzXqavssXLh7nfLOCJ0NWCAQ9Zozf276XB3LDpHSTryycRUouc0KfnBnj54a28Wtjd7K3e5DbUzkSusGN2Jrs4h3pHu7vGeJDA2OMxdPENYM3y2AswZZkhvf1j/CRoTG+V5zjdK3MqwQSaAcecU1nRzqLqaoU2i2enDpNvtPiEgFOEFB2HB7sHyZtmAgheLO4rsvjjz/OgQMHeLuNj48zMTHBegIp+c/HXuFoaYkVgZR4YUjGMtnRlUEAZys1Dp49T931WNH0fJwg4AOjw5iqihCC1yOE4Kvnp/mnM1Os1vQ8bE1jW1eGpKFT8po8mX+J8+0SEsGyAMmcU+Fd6TEGzDSKEFyPI415/mzqWSSvkkA79Okzkvyr3rs5MHQ/t8f7udipcbgxxwoJtEKPD2a3Mz70Hj7Wcwf3JIYZMFO8WdKaRVqzyGg2FzoV6oGDZG2BkIRcIVmbBPYkhnhkYC/b7RwpzWSjmIzsj+QjvIkU3mT5yP7IZIQNImvY3JsZ4BcGdrI90c0VktcQvD4Bo7EUB8Z2szOZI2vYrCeQIYoQtAMPNwwACYJLQiQKAolkwE4gJcRUHQSvseS2sRUVU1HptxJoisJ6QilZJqVkPWnDZDiWRBcKpqqxHikloZRcj1BK1pMxTDKGSSglUrKKZJkvJWW3gxACBUGx02bR6fAaAqqeQ6HTIpQSKSVvBtd1efzxxzlw4ABvt/HxcSYmJriWuuvS8DwuEVzW8n2qjosQAgkU222qrsPVFjsdCq0Wy0IpeT1BGFJzXBD8hHyrTSBDllW9DgW3gUSwmi9DCm6dQIZIKXk9gQyp+x1iqsEyyRUlr0VMMTCFRo+eoOg1WCF5lSIEZb9Fn57EEhoZ3eZWCGTIekbMDA+kN/Hxvt0MGWnWIgURwQrJ2iSwJzHEIwN72W7nSGkmG8VkZH8kH+FNpvIWaEYORvZFBiNsALaqk9EtMrpF0W1RcttcIbhMcE2jdpoDY7vZmcyRNWzWM9WsUnE75J0mM60apxpLXCYEy/Z09WOrGjXfoeG7XGhWKXsdEFwh4V8O76DHinEtDd/lXLPCVLOKIgRxTUcIwXqEEKxnulnjYrOOFwbUPJeUYbKWo5Ui0406hqrihyGWqrFa0/cIkBwuF5lu1hECjldLBFJyheCebC/7BkYRQlBy20wuLtD0PVbbnEqTs2wUBHXPxQtDErrOreL7Pp/97Gc5cOAAb7fx8XEmJiZ4PU4QstBqcbJcRhIRXDaWSjGcjFNxXE6WK8w0GnT8gBWKEGzNpEkbBi3fRxECJwiI6Rrr8cOQquNycqlCy/dZrdu2eHBogHPVKrNeiROteWp+h9WGzQyDZpq0HmPeqeLLkKRmcbWK3+ZkM0/BbVAPOpxrlyj5LVYTCH6pbzc9RgJfhvygNs2sU8VHcomALi3GnuQIu5OD6IrKzTrfWeJCp4wnA2p+h7Rms5a0ZpHWLDKazVSnQi1wWCEFEcEKydoksCcxxCMDe9lu50hpJhvFZGR/JB/hLaDyFmlGDkb2RQYjbAC2qpPRLTK6RdFtUXLbXCG4TLCmUTvNgbHd7EzmyBo263lxaY7/+/T3ea44xdcXziEBNwxwwwBVCCSSXitB3m3ybGGKF5fm+OHSPEKApii0Ax9VEago/Ltte7inqx9NUVhPxe3wp698n68vnOer82dZ6DRxw4CxRBpFCN6I5/LTfOniaT534TjfL85xqFyg14oxYCdYbeLUIb544SRPz53jeLWEEwT0mDZx3WBZzXV4pbLIfzx5mH+cPs0LxXkuNGtkDBM3CPBliILgrq4exnfeja1pKELQb8dp+T6nqmUkEgn02TEansdUo8Zz8xf59sIsbd/DVFV67Ri3wuc//3l+8zd/Eyklb6fx8XEmJia4Hram0fJ9Gp5Hod0ilKAoYGsacV3nn86d5/mLc9Rdl8V2B01V8EOJpij0xmwqjsOZSpVnpi/yw3yBjh+QNAy6LJO1qIqCBBbbHequR9v3URQwFIW+eIznpuc4ePoCC0qRmmjgS4mCQkBIj5HAlQHTnTLfKJ3gq4uv0AhcFCEYtjKsONHI82ThMJ+++G2+V73AC7UphABNqLRDDxWBJlT+x03v597kCLqiYioaI1aGb1XOERDiE5LWLDZZXfzG4F5yepyb9bWlk3yhcIS/XPgh36qe58X6RQbNFINmirWkNYu0ZpHRbKacCrXAQQoighWStUlgT2KIRwb2st3OkdJMNorJyP5IPsJbROUt1IwcjOyLDEbYAGxVJ6NbZHSLotui5La5QnCZ4DVG7TQHxnazM5kja9is52S9xH84/k1Kbpua5+KEAYtOizvSvbwzO8j2ZDfvyg7SDnxON8q4MqDhe7QCn3bg87MDW7gj3cP2RJZf3fQO7u7qI6mbrKfpe/wfx77DS5U8Fc/BkyFTrRqBlAzaSXKmjRCC63GqtsSXZ8/wvcVZ2qFP1XOoug7nGhXuzPSQNkyW/c3Zo/zDzCnKroMvQ/KdFiWnw1A8Sb+dQBGCqu/w2MnDHCoXcMIAJwxo+B4p3eBXb7udwVicPbl+fnv7XdiqjqlqrLgr20OXaTEUT3BXtgdVEcw06pScDk3fo+65TDcbdJsWw/EktqZxM+bn5/nMZz7DSy+9hJSSt8v4+DgTExO8EZtSSdKmyVg6xUgywVgqRVI3OFQsUnc9Gp7HkuMwmIhze3eWPX093NOXo+X7zDaaLHUcOkHAUsdhvtliMBFnMBHHUFXWkrUs+uMxxtJJemM2WzJpRlNJXiqUyLfa+AQsmHPETY1tsR7el93GO5IDZPQY51qLLHoNakGHduhxpl0kpVmMWl0kNYt24PJ06RU+u/ADHBnQCByagUsr8Pj5nju4KzHEjngfvz74Lu5NDpPSLFZ063HuS42QUE12xHp5T3oz/7pvD2N2lpv1SjPPPywe5bnKedrSo+J3KHttTrcXuSc5REazWUtas0hrFhnN5oJToRa4rJCsTQJ7EkM8MrCX7XaOlGayUUxG9kfyEd5CKm+xZuRgZF9kMMIGYKs6Gd0io1sU3RYlt80VgssEl4zaaQ6M7WZnMkfWsFmPH4b8oDzP4WqeThiA4DJfhnxqy73c3z1MtxHjqflTNH2P1QxVZWsiy29uvpvbUz2MxTPENJ31SCk5US/xreIMS26H1ebbDe7M9LAl2cX1CKVktt3g89PH6QQBlwgIZIihqNzX3U/OjJHvtHhmforzzSoILqt4Dt2Gxf29Qwgh+Mb8FF+bu0AgJavZqsaHB8f4meHN3Jfrx1RVTFXlaltTXexIZ9mezlLstDlWKeHLkEsEuEGAG4bsGxzFUjVuRjKZ5OjRo3znO9/B933eDuPj40xMTHAjBhNxtqRT3JnrZms6w8Gz56i6LitCKQml5Jd3bONDoyOMJBPM1BucKleQXNH0fAxVZd/IEIoQrKfbthhMxNk70Mtdvd08NzPHuUoNicTPLBEmGjRDh/dlt/FzPXfy7sxmGoHDofpFOqGP5FUhkiWvyQeyO8joMWadCv/PzPO0ApdlkleZisbOWC/jww9wV2KQzXaOmGpwtW49zq54Hw91bWGb3UOPkeBmhVIy5ZT564VJOtJnhU+IoWi8JzVKr55ACMFa0ppFWrPo0mwudMrUAgfJ2iSwJzHEIwN72W7nSGkmG8VkZH8kH+EtpvA2yEf2RyYjbBBZw+bezAC/uWk393UNIASXCK7QhcK2RJZHttzHzmSOrGFzLYoQgMQPQy4TXOYEAYaiogiBpWhIJCBBcImUEl1RCKXEVFQEr08VCr4MuZquKHQCHzcIWCalZD2BlDhhQCvw8MOQ1xDQCXycIEAAgQzxZchlgsucMMAPQwIZIiVI1qYrCoaiskywvoRuENd0kOCHIa8hwA192r6HGwQEYcjN+MM//EM++clP8nYYHx9nYmKCm2FpGgldp+l7dAKfSwSXOUGAGwRYmoqpqYRIAim5mhMEtHyf16MJBVVREEDb90EAigRFguCSTuCT1mwsRUci8WWA5McEl4RAO/RYFiKxFR0JSK6QSAxFIyAkqVkoQrCeuGqwzFZ1blYgQzqhTzPw8GXIahLohB5OGKAIgRP6rGfEzPBAehO/N/wgO+weNKFwNVUIHkxt4veGHmC7nSOlmWwUk5H9kXyEt4HK26QZORjZFxmMsAHYqk5Wt9mXGwMh6DMTtEKPLt1md7qPPZkB/vst72LQSpDSTV6PEIKG7/J8aRo3DLlMwI5kN4oQnKiXaPgec+0GeafJZUIQINmVzDHfaXC8toitamhCxVRV1iKEACTfLs5Q8RwkV/RbcbYkMhyrLXK+WSGQkqxpoQjBakcrRV6uFDhSKTDXauAEPkWnzQpNKAzGEvhSMtWsUfdcjlVLlJ0OIZJLBPTZcX5m8DZG4kkUoRDXdQ6VC1Q8h9WypsVdXb18vzjHVLPGYCzBMlVRWIuqKCw6bX6wuIAvQ1YI4O7uHmqey/HqEm3fxw8lGdPkRj388MMsLCwwOTnJW2V8fJyJiQluBSEEbd8n3+owU68jiQhQBAwlEggEC60WhVaLk+UKi502QShZkTR0PjI2ytauNIaqsp58s8WJpTLfnctzbHEJU9WYrtXxQolUJKHdpMdM8O7MZu5NjSCEoO47PLt0Go8ABJd9sGsHe9ObSKgmlqKTd+scbS5wtV8feBeb7CxvlZcac0w2LnKoMcesW6UdehS8BsskoAuVYTONJwPOdkrMujVCKekx4qwlrVn06gk+nNmKI32GzBQCgYbC+zO3sS+zhX8//BDduk1cNdgoJiP7I/kIbxPB26wv8uXInggbhJQSIQQt36PktpBAWjexVR1dKAgheCOeXjjD49NHcMKAduAzbCdZcttUXQdT0fBlSI8Zw5chTd9FFQqBlKR1ixBJvt3EUjRSusG/3bKH+7IDWKrGes7Uy/zpie9R91wavkvOsAHBktsmlBInDLi3q58P94/xgb4xFCFY9s3CNP9l/jyHygUUIfDCgIRq0GfFOd+okNANcqbNfLvJsobn0mXYpA2TstPGUFRqnku/Hec9PUN8sH8TmxJpli05bQ4tFfi7CyeYbzdRhEBF0GvFWHI6lN0OihA81DfCgW130mPFUIRgPZ898wpfvXiepu8hkQzaCQqdFnXPRRMqSd3gvf3DfHholB3pLDfjU5/6FI899hhvtvHxcSYmJrjV/nl6hudn5zhcXEQA/fEYhVYbKcEJAixVpcsyKXccbF2n4jhkDJMHhwZ4aHiQ27uzrGe+0eQLp87ycqHEdK2BKgQxTWM4maDktClqBXr7Qu5M9/M/bf4wq32peIS/nvs+TujTCnze17WFBzJb+FD3DpYFMuRIY54vFY/wfPkMmlBY9qnhB3lv1xa69Thvha8vneLLpeO8WL+IKhRc6ZNUTQaMFGfaJZKqSa+RYNapIoFa4NCtxchqNv9+9P3cmxxiPVJKPBngy5CC1ySUkqxuk9FspJQIIdgoJiP7I/kIbyPBBtAX+XJkT4QNSkqJEIIbdbiSpxP6dAKflyp5nlo4zSWSSxQEPze4jc3xDEnNIO80ea44zan6Ekgu6zFj/J93fZDhWJJrudiqMdOqUfUcpIRHT0/SCQNW+2DfGAduu5ucaZPvtPi76eM8PXcWX0pW+6WRHexIdZPUDJ7JX+D7xTnqvsslEmxVZ0+2j93ZPixVY2sqQ1zV6bcTrFZ2OjhhwMvlAu0goOP7PHH+OC3fY7VfGdvJgW13IoTgWl4szuMEAYai8PTFC3ynMMtlEtKGyad23s2DfUNYmsbN+NSnPsVjjz3Gm2V8fJyJiQneLCeXypQdBynhpWKR5y7OUu44rNAVhTtz3dzT20POtuiPx0gZJiPJBOtxg4DvzM7zN8dOMdtoguSyrV1p/od772C6XSGdFLw7vZm1/Kg2Qyf0cMKAESvD1lgPq/lhwJLf4khjDoGgR0+wyc6S0izeCnNOjb9e+CH/WHoFX4as9mt997Ir1ktGs3mqdJxvVc9TDRxWxBSd+9Oj/M8j76NHT3AtUkqEEGxUk5H9kXyEt5nGBpCP7I98ObInwgYkhOBm3J3pwwsD2oHPM4XzqEIQSAkCkBAiOd+s8G823UlM1fnB0hzTzSogQQiQXCKl5GxjiSE7gRCC9QzHUvRbCYSAv5s+gaIICHmNF0tz/PzQNnqsGCA5WiniS8lqpqKiKIK9uUHcMOB4rUTDd7lMQDvwKHsOD/WNkNZNJBJVKFyty7QIpeRDA2NIJH/2yg9p+R5XO1MvU+y06bVjXMu7egbwwpBSp82i00IAkh8TUHUdDpUKPNg/xM2amJhg2WOPPcatNj4+zsTEBOuRUiKE4GbsyHYRhCFOEFJzHZ6+MAUCkFzihSHFdpv7B/oZSMRRAFVRuBZDVZmq1ZltNLhECJBcogqBrqh8ZGgzQgjWc29qBDcM0ISCIgRX0xSVHj3BB7q248kAXagIIViPlBIhBLdKiORHjTl8GbKapWioQuF9mc10Qp+XGmlqgcNqrdBjye+gCRUpJUII1iOEYKOajOyP5CNsAAobRD6yPzIZ4b9CUkrqvosbBvSYMVShcJkARQgMRUVKiaGoKEKgCMGrJAgusTWdpG7yevwwpBP4OEFATNOwVI2rxVQdRQiWBVIi+UmaotClW2hCwVRUDEXhJwiQSFSh4IUhTd9jPZ3AJ5ASLwzxwxAEPyFjmOiKwvXQFQVdUciZMQSC1VRFYKgKoZTcChMTE4yPj3MrjY+PMzExwVq8MMQNAtwwpOl53Kym79PyPQxVJURyieAygUBRBJoQqIrC9VAUwRUSBJekDANfhrhhwLJAhqxFSkk96NAJPdYjgRBJM3BxZcB6OqGPKwPqvkMgQ26FQIZIXksCmlDp1mJoKFiKhqGoXE0KkBJUBK4MqPodftpMRvZH8hE2CJUNpBk5GNkXGYzwX4nzzTLPLU7x2ekjzLSrzLYblJwWoQTJqwSC3xi7m23JLAJIaAZlz+FMY4kVcd1gOJbiZ/q3kNAN1jPfbnC0WuBvLhzh5WqB+U6D6WYNCYRSsuLhoa18oG8MAWiKgqoIfrS0gORVulDoteJ8ZOA2hmJJNEWh4XuU3Db5TpMVpqKyLdnFC6V5vluc5WRtibhm0GvFWO1UbYnn8jP808wZflCax9Y0pho1AiQreq0YD/UNc093H9crpulUXYeXlgoEUrKiy7T4jW13MBBLIITgVnj44YdZWFjgyJEjBEHAjTIMg9/6rd9iYmKCtRTbbc5WK/zNyRO8sLDAmWqVXtsmbZrciC+fv8DTF6Z4fnaOi40GqqJQ7jhcIiBp6HxgdJh3dGeJ6zrXIwhDemyb05UKxVaHFVnbwlAVZts1vtk6xuHGDLfZORQh0BWVFWdbizxTPsVfzn6f060iBbfOrng/q/ky5OnFV/hq6Th/XzhMze8QEDJgplhtyWvxmbnv8Y3yaZ4tnyFnJLAVHUvVuRm6UFGF4Pu1aSQgAUOo9BtJPta9ixErgyZU6r5D0Wsy59ZZJgVYQmdnrIfnqxd4tnqeY608SdWk30jy02Aysj+Sj7CBqGwwzcjByL7IYISfckWnycH5U3x2+mVKTouTjRKhlMQ0g9FYmoRmkNAM/rvb7uWudC8JzUQIgaGopHQTU1Fp+B6DdpLtyW5+a/NuhmMp1tPwXV5YmuWxs4c40yhzplGm4nbIGDa9VowuwyKhG/yLgdvYP7iFpG6iCIGuqGhCYSiWYK7dIGfabE1m+YWR7dzfM8SK4VgSJwiwNY1O4DNgJ9iS7OJH5TxnG2WmGlVmWw2OVIpsSWbosWIsm2rW+OLUCZ5dmOZEdYlzjSqzrQZbkxlimo6laWxPZXlP7xC/snkXb9TOTBZFgBsE2KpGfyzOp3buZlMiTUzTuZUefvhhWq0WlUqFQqHAG3XHHXfwyU9+kj//8z9nLR3f55XyEhNHj3B4cZHztRoXGw3OVCu8I5slaRi8EX978hR/9cornK1WmW20mKrX8cKQ+/r6CEJJbyzGB0eHeWdfH5vTKa6XIgQSyUgyQcPzkFKyOZ1CCMFso8X5ZpkT4izHWnOc75R4d3oMWzEQQpB3a3yx8BJ/Ofd9Ft0Gx1t5zrYXaYceu5PDLAtlyN8XDvNk4QjPV86Rd+u8VJ/Fl5KsHqPPSLKs7LX4g7NP8a3KOY63ClzolHmxNsXt8T4GzBSKENwoQ1HRhcKo1cXFTpU+I8HOWC+/2rubhzKbWbHJ6qIjfWKqTjv0GTEzbI/leKE+w4n2Imc7S0w7FX7UnGdnrIc+I8FGNhnZH8lH2GBUNqBm5GBkX2Qwwk+xl6p5Js5PskzyqmbgsS2R5SO9t/HxkTt4MDfCHaleUrrJCkUIcqbNXek+3pHu4V/0b2FvdpBBO8m1LDot/uzUiyw6bVZ0woC0bvKhvs18fNMd3JftZ1/fJlK6iSIEK7KmzWg8xbtzg3xkYDO7u/q4u6uXq+1IZdmW7OLduSF+YWQHz+WnmW7VuESAGwYEUhJXDbansghgulnnSxdPU3TarPDCkC7D4n/b/V7e2T3Au3ODvK9/hBt1R1cPW1MZPjC4iQ8PbmJTIk1SN3gzfOhDHyKRSBCPxzly5AjX6+Mf/zif+MQn+P3f/33W4wQBjx55mdPVCiucICCQkrRpsiWVRlUUrsfxpSW+cPo0hXYbCUgpAYFA8KHREf7Nrh18ZGyU7V0ZxtIp3ihL0+iyTPaNDrOru4td3Vku1htcbDRx8AisFlILKHh1FATvTG1CCMEPa9P8vzPPs0wCEmgELooQbLa76dbjFL0mX1l8hR/UZ1gmAR/JtFPmntQwo1YXUko+VzjEtyvnaYYeK1qhx4VOmfd3bcVWdW5GTo+z2c7yYHqMn8vdzn3JIe5LDnO1d8T72BXr5X3pzfzr3rv5avkU55wyKxwZ4MuQhGpye6wHQ9HYiCYj+yP5CBuQxgaVj+yPfDmyJ8JPoVBK5jt1YqpGK/BZbbZT47ZEFzkzhiIEa1GFQkxT2JXMsUwIwbWEUrLQaSIQIADJZflOg7imM2gnECQQQrCWhGaQ0AyklFxLvxWn34qz0GkSyJDXEFD3HKqeg6VqKMBUs0q+3eISAUgumW83KbabvCOTQwjBeqSUCCFYJqVECMFatiQzLBNCcC1SSoQQvB4pJUII1vKJT3yCXbt2cd999/EXf/EXeJ5HuVymVCqhqipBENDd3U1XVxe6rnPgwAEeeOAB3vnOd3It880mTd/jasV2m4bnoikKUkqEEFxLKCXLaq7LZQKQEgEkDJ3BRBxNCG6GrWks25XtouH5eDLEDQNQQGo+CPBlSC1wqfodUprFXKdKTNFphR6SK2Y6ZRQEy9qBxyvNPCskr5JITjYL7MtsxSekE/o0AocVEpBIVKFQ9Ttk9Rg3K6maJG2TUEoE6xs200gjxaxbI5AhV6sGHSp+G1vR2YgmI/sj+QgblMYGlo/sj3w5sifCT4l24DPXqYOEYStFTNVpBT6rSQl1z+Fcs0xM1Rm0k6yl5XuU3Q6uDEjrJlnD5mpN36Phu7QDDyklWcNmvtMAAUguCSW0Ao+pZpW4ppPUDGxNZy1TzSpOGNBrxkjpJooQrNYOfBQEs+06Nc9h0E7wUrnAawhIaDqqECxL6gZpw6TsdrhEABJG40limo4QgvUEUuKHIdPNGgLYnMwgwxBNUVit7Xu0A5+K62AqKkPxJGspddp0Ah8Q2JpG1rS4Wsv3WOy0kUCPZaMJBUNVudo73/lOdu3axUc/+lGEEHzve9+jWCxSLpfp6uqip6eH+++/Hyklg4ODJBIJXk/SMBhKxDlbrXK1ju8z12xgKCq6qtBlWqxlqlbDC0MkIITgNQQYqkLWsjhXraIKhc3pFEJKFCG4EfONJiESU1ERCBCS0G4hlZBXCYbMNKaisWyTnSWt2TRdj9WEEOiKihACXSh06zHmnCoBkksEpDWbQTPNMkNoZPUYkldJrug3U2Q0i1vlXHuJTujTbyTIaDaKEKxFCEFM0dlkdfFiY5bVJJBU/3/24DzYzvMw7PPvfb/97MvdN2wkQJAEQYoiKZEUKdi1vMBunMZqatex49pN/qrtyaQz9aQzradO/2iaiZ1OxkujqqndyApjW6AsybIs2bIWrpcACYDYcS/ufu7Z1+9869tzAF/w8hqXpIZ25oLs81hoQrLXzA+cHCgNsIdp7HHdgVMDJwamBtjjLrer/EnpGr+18CrzjXVONzcwpY4fRwQqRgACmLBTLPWa/O7yWa5362x6PY5lx9iu7vf59Ssv8fXNBU6tXaYXBQgEU06aLatum+/WVvjt66/x3coK364u48URupT0oxAhQAAF0yZG8bml85xvVrjYrnE0U8TWdLb7zLUzfGHlCn+wfJGy18OLIvYlM0ghGGr6HuebFT57/Q2+vHadb2zcoB362FKnEwYMCeDh/Bj/6N6HsTQdIQQHUjnONSqU+j0ipRgadRI8Oz7LsxNz7CaKYy40a/zR0hX+76tneaG8zlK3xUwyTULX0YRkqOF7nFq6yheXrvMfFy9xsVnDiyIOZwtsd7VV5zfOv8ZfbCzzZ6tL9MIAS2qMOgm2LLSb/Pn6Mv/m/BleLZd4sbTBdDJJUjcwNY2dTNOkWCxSKBQ4fvw4jz/+OI8++ijPPPMMDz/8MIVCgZGREUzT5L1wdJ1Kv0c7CKj2+wwJIGOaOJrOF65f55XNEueqNebSaXKWxXbPXbnC565c4SuLiyw0W+hSUvc8FLfoUjKRTPBmrc7Xl1b4s+UVOn7ARMIhaRgIIfhevLJR4l+ffoNvrqzxlytrOLpOve/j2R1ix2Xok/nDPJ07xD6ngBCCSMWseU2aoYsbBwgEupD84uyzHE9PowtJRrcRQvCd5gJCChSKjGYzY2X5qYlHyRsJhpKaRS/2ueJW2HIsOcWz+UM8kJxAF5L36zdWvsPny2/wu5unKQUd+irkkF1ECMGdOJpBI+zTjPqs+22GBPB4eoZ/Mv0UtjQQQrBXzA+cHCgNsMdp3AW6A6cGTgxMDbBHtQOfr5Su8rnVc/TjkEbQpxH0iVTMfzF9lLxhM5vIMmmnWXFbXO3WCVTMer/Dcq9FpGIezI4x1Al9fu3Ct3ilvsam18ONQq60axhSMumkyRk2fhzxerPEZ66fYb3foeb3aYc+bhTy8eI096YKzCUyFK0EkVKca5Zxo5CNfpf1fodSv8tH8hMYUmPot6+e5g9XLlHyevhxzLVOg14UMGonmbCTxCg2vR6/c+11XquXaAQe/SikHnjMJNI8MzbLiO1wPD/OL9zzMEndwNQ0tpyYmMMNA0btBA/kRvj46DR/f/9RdqOUohF4PLd4iS+tXMeNQlqBz+VWnU7o8/jIFIaUeFHIV1cX+OrqDS40q/SikM1+j4V2i4xhcjCTY2il2+ZXz7zAlVadiufS8D1udNokDIPpRIqkYeCGId8qrfKZS2fpBAE1r8+62+Vqq8nHxiZJmya7EUIghEBKieM4SCkRQiCE4HshheBwLo8hNfK2xXQyyaiTwNF1zlarNHyPsuuy6bosd9o8NDJC0jAY+oOrV/nshQuUXZduGLLR6+GGEc/OTDOeSDCXTvOxyQler1RZ63Zo+z69MORctYohNY6PFNGk5L06W6nyP3/3ZcquS63vUe17VNw+T05PMJEzmEtl+b7CEZ7KHeSJ3H625I0EE1aacStDUpocSBT4heknOZ6aIms4bDmcGGXSypDSLGatPI9lZvn5qY+xz8kzJIQgrVtMmVnyhkPRSHI8PcUPFu7jmdwBEprJ+/Uvl7/F58pnWPPb+CrikluhFwdMmCmmzAxCCO7kSGIUS2hMmWnGjBSPpaf55emnSGkWltTZK+YHTg6UBrgL6NwlSgMnB7408OgAe9BKv8XzG5f4awQYUvIrR56i6rv80dpFXqytsF016LHitqh4PQqmw5lGiU2vh2JAAAoCFfONzUW+f+wAQ24U8vzaZZpBn+2EgH4c8Uv3fgQvCrnUrvG/XXqBGMWWbuiz5rZZ73c4mMyx0G1yrVMnVIrtXquXeKI4zSP5cTQEf1Fa4nKrxhYFCKAbhXxyfI4xO0nBtFGAFIKdfuHe49S9PkN5y+adCCG41KrxzdIyO52ubnK6VuLjo1OA4Gq7wUqvxS2CSCkqnstyr03L93B0gzO1Mt0gQPFXBLQCj29vrPJDM/sZqnkun79+kVgptlvrdvjqyiI/c/h+NCH526ZLyQ/MzvH05BSdIKDa7/O/vPISQRyzxQ1DNl2XUs+lYDuUez0u1GqEcYziLd0wIGkY/OMHH0QKwZcXFvHCkJsEoBQg+MvVNZ6emuRoscB74YYhZ8oVhBDEitu8KKLcc/nnHzlBO+6T0AySmsVOR5MTzFg5/t7YcVphn6zuoAnJTj9cPMpH07OkdYswjknpFtvpQuNwYpRDTpFq0CNvOEgEhtR4vy73ylxyywQqZrsXW0s8kz3AY+lZ3skPF47wZGYfXhwyaiRRgBSCvWJ+4ORAaYC7hOQuUho4OTA/wB4UqZisYQEKUGwJVUxGt4iUIqvblPpdJIKdNv0umhAIQBOCTuhzm+AmW+rUfJehfhRiSQ2FAhQIboqUIqOb6EJStBw2vS6CAcHbbHpdIqUYMqSkE/rsZAhJzXeJVEw3DAiVQqHYTgFJ3SBtWBRMGyEEUgh2kzMtsqbFbpRSDMVKEcQxpqaxU6wUQ7FS9MKAtV6HtyiGQhVT9/oYUkMTApSiE/q8jYBQRVT7LkNBrChaDooBwW2RipFC4EcxsVIopfjbJoUgaRiMOQ6bbo9+FLLTZq9HLwyQgC4l/ShEoQDFFgG0fR9dSgwpMTWJYhvBgEKXgiGlFENKKd6JqWnEStELQnbqBSGlnsuIkcSRJrtJaRa60CgYSSSC3YyaKWxpkNIt7kQKgSE1RswkltQxpMY7CVXMu1FKYUmdVuixkyE1NoMusYoZUkqxm6xuM2amEEIghWCvmB84OVAa4C6icZfpDpwaODEwNcAeoZQiqZu83iqx1m/zFoEuBPelR6j5Lle7dRzN4Gq3hh9HbEnrJoeSBUIVsdpvs9BtcL1bpx+F3Cbg/swI3z92gLxpYwjJitvmXKvMbUKggH3JHAlN53K7RqgUq26bVuiB4CZDSA4kc2hCsun1WO93uNZpUA/6KMVt406Sk9P3MO2k0YTEjQK+U1khVortRqwE92eKnGtWaPoeWcPCkBo7na2XudCsstnvEaiYvGmzXaRiGr7HfK3EpVYNR9N5tVqiF4Vsl9QNjuVHudFtsdhpIYVgod0kUootBdPh8dFJHswX0aWk3Hd5qbxOEMds99GRCZ4enyFlmFia5EqrwbV2k5sEt92TzRHGMddaTfK2DQoMKflPwYsiljptNno9tkghmE2lSBgG1X6fsutyuVmn4vaJleIWgaVpPDU5SbnfZ7nTQSnFmXKFII65TUDOMnlodJQLtTqbPZcRx0ETAiEEdyKFYKXd4Y1KhTBWbHdstIiRDLjibTIUqIiUbrFdpGLOdzd4o73GdbfKtJ0lVDG60Phe1YIeS/06L7eWqQY9QhWTNxx2utDb5M1uiYu9TQypYQgNU2rciRCCII55obXERtBGoRhSAjK6ww8V7uWyW2HJaxCjyOsOQgjuBvMDJwdKA9xlNO5C3YFTAycGpgbYA4QQhComa9hs+l1agYeGRArBiJVk2W3y/MZlzrU2udKpkTdsBIJQxRRMB0czWHabnG9X+JPSNRqBR6RiNCGQQiCABzKjPF6Y4iO5CQypIYXAlBoxihW3jSYEutDIGhbdMODL69c42yzzWn0DBeQNBzcKcXSdMTtJpe9yqV3lT0sLrLptvDgiiCMcTSdGMWEleXp0hkcLE+RMGykEmhCkDJOLzSqaEBhSw5SStGHyjdINvlte5avrCxhSYyaRxtENtnxl7Tq/fvEVXqqsM18r8Up1nZlEmgknxVCsFJdbdZ67cZHPXnmD+doG5xtVHF3HiyI0IdClRBeSouXwZrPKl1au8Vq1RKnfY8S2CeOYWClGnSSHMjl+5p4HSOoGQ3OpDJGKWey0iBUIBB8dGeex0QmOF8eQQqCApG7QDgIqfRcpBLqUFCyLWr/PF25c41y9wiubJfalM+QtG11K/jYJIchbFmXXJYhjal4fU2pMJZI0fZ+LjQbfXlvjSqOOF0X0wpCUYRAphaPpjCUSXKjV+ObqKt9eW2O12yWh6/hRhJQSQ0o0KcnbNi9ubPDny6v8+coK/TBiXyZDQtcRQnAnh/M5yj2XsusSxDFSCGZSKdb9Jl92X+W1zg1ebt3AjQNGjBQ5w2EoUjG/v/EaXyif5d+XXuPV1jLnOhscSYyR1iw0IXmv1r0WX69f4V8sfZMXWot8pXaRVuyRlCbTVpYtX6td5nObZ/h/NuaZ76zxZ40rTFkZJsw0ptS4k6Rmcsgp8N3mDaQQxCgyuk1BT/Cd1hJ/0Vzgj2uXKAddIqW41ykihGAvmx84OVAa4C6kcZfqDpwaODEwNcAeYEiNjG7yWG6KnGHzcHaCQ8k8K26LG26LIT+OcOMQU2r84sHHmElkeLwwzfVOjZLXpRP5DDXDPnnD4WhmhB+bPMzRzAifGj/I44UpkrrJkBCCoumwP5lj1snwUHaM2UQageRSu0qoYvpxSKBiYqX49Mx9HMuOcWJsH2tuh41+l3boM9QMPIQQPJAd5VMTB7gvU+THZ49wPDfGTCLDloxhMWI5PJIfZy6Z5WAyx6F0jlerJZqBhx9HxCheb2xyMJ3jYDKHEILXahv8H5fmaQQeXhzRDQN6Ychmv8f92RFSukEYx3xh+TJfXLmGAkKlaIc+sVL83D3HuCed48H8KIczeS42q6y7XYYipehFISOWwy8cfogDqRxPjk/z9/cfIWtabPdQYZRR2+FYYYRHiuN8cnKWj49OoUnJkCYkOdPigXyRUdvhkeI4c6k0rcDnaqvBUD+KqHgui50Wz07OYGs6f9ukENxfKDLiOBzKZHl6copOELDW7dL2fSKlaAcBQRzzYHGET0xNc6w4wg/MzfFGtcpat0usFEMt3ydh6PzUkSMczuc4ks9zXz7Pa+Uy1X6fMI6JFVyo1clZFg8UCwgh2M0TkxNkTJNjI0WenJqgGwRcaFQIEm08EVAPXcpBlyPJMSasNBqSV1vLnCqf5XRnjSFfRSx5DcpBh+8vHEYTkvciVoqLvU1+fflbVMIu/TgkVDE3+nXGzDSH7CKOZnDdrfF89Tx/0VwgUDFuHNCOPM51SzyTPUDeSLCbUSPJxzNzzFhZ7kuM8uPF+/lG8zqloIuvIoYWvQZSSI4mRslqFkII9qL5gZMDpQHuUhp3se7AqYETA1MD7AG2ppPSTY5lx7knWaAS9PjTzWvcIthSNBM8UZjhB8cPYUqN11slNrwO27VDjx8aP8SJsf18JDfJqJXA1nS2k0KQ0U3uTRc4kMwxYiZ4buUCbhyAEGxJagbHcmP8vZkjZA2LtX6bc60y23lxyOF0gU/PHeXxwhQjlkPedNgpY1hMOSnuTef5SGGCL65eZbHXZDtdSAwpOZ4fBwRX23VeqKzhxxE3CYhUjKMZ/MDUfhzN4Ea3xe8tnKcTBiC4zY8jDqfz/PShB7g/N8LFZo0Xy+vsNO4kODE5xyfGZzmYzuLoBndyIJ1lXzLD0VyRcSeBlJLtDKmRMkzuzxU5mM4y9NzCZRC8jSYEU4kU+1IZhBD8bZNCMJVMciSfZ9RxaPo+r5U3iZViSxDHjCcS/Ox9R/nI+DgV1+Vba6u4YQgItnSDgCcnJ/nPDx7k4dFRvrW2xpu1GjcJbhIINCk4NlIkZRi8k3tyWQ5kM2Qtk+evL9KQLUKnh5IxQ53Iw9FMns0dQgrJq+1l/mDzDbYobtGE4JAzwpSV5b3wVcT/W3qN890SETE3CYhQbAQdPlU4TEa3Wfdb/M76y/TigO00IRkz09yfGEMKwW7yhsO9TpHH0rO80d3gO60l+ipku8V+nSczc+yz8+xF8wMnB0oD3MUkd7nSwMmB+QH2CCkEQ7am48cRlqZxi2KLLgRF00EAKd3AjUJ20oWkE/noQhKpGE1I7kQIwZAQ0IkCLKlxiwLBLQKKpoMCDKnRj0IEA4K3aQUettSJVAwIdhOpGF1Iqr6LG4XsFKqYgulgSx1dCrw4ohcGvI2AVujR8D0E4Gg6I5bDbYKbNCEY8qOYoV4UIAV/jSk1ErqBQqEJSawUu4lRKEAIwZ1IIRBC4Og6/SgkY5jcJLhNCkHBsnk3sVKEcUwQRbxfQgh0KUkaBn4UE6qYndp+QIRCE4KcbZE0DG5RbLE1DQVIIeiGIb0w4m0EKBQZ0ySh67wXtq6T1A1mUykiEaJkxBaJQEPQiXyGvDjEkjpDir8iQBcaSc3EjyOGYqW4E6UUbhQQqIhxI40Q3CJAAQoo6gn8OKIX+XQiH1vqbKe4pagnCFWMGwcopbiTSMWYUsdTITndwZY6O+V1h71qfuDkQGmAu5zGB0B34NTAiYGpAfYIpRRFM8GFToVNr8uWlGZyT6rIJ4pzJHUTP44pez02+h36cciWEcth1snwjcoiN3pNSl6Xe1IFdnq1vs5LtVVOrV1GoVhzO9SDPlsMqTFmJ+mEAdc7db5ZvoEpNWpBn14UguAmR9N5MDvG6cYG55oVFrtNZhMZLE1nu2vtOi/X1vnK2jVWe23cKGCp12a7cSvJ02Mz3JctIoWgFwaUvR7rbpctupB8/8Q+Hi1MkDJM0obJxWaNhU6TGMVNAgypsS+V5UKzyiuVdRxN52q7QaBitmQNi4Jls9Zr83q9zLV2g6lEGl0KNCHZstrrcKa6yecXLrLcbdP0ffalMuxGKUXOtLjRabHUbXOTAFvXmUwkOTE1R86y2U2177LUbfH7Vy9xqVFnudPiSK7A+yWFoBsGlNweFbfPlrRh8v2zszxYLOLoOpbUOFutsNHrESvFLYKEYXAwm+W76+tcrNeJY8Viq0XMW4qOzRMTEzw6PsZ7Zes6y50OF5pl+ok2CG7ShcbPTT7BocQIChgxk5zrrLPht7lJQFqzmDDTrPpNznXWea29wkGniEBgSI0t616L890Sn1l/mRv9OlfcCqtekxhFzFvGzDSakDxXOQtKsew1qYY9hhRgCo0JK0Mr9LjsVvha/QojRhJb6thSZ0sjdFnxW/y70mvMd9a40q+y7DXpxyExiiEFPJ6e4b8ZfxSJQAjBXjE/cHKgNMAHgMYHRHfg1MCJgakB9gAhBDGKMTNJPewTxjEjZoL9iTw/v+8Rppw0Q46mk9ZNelGAF0cYUjJtZwhVzOlmiaVekzPNEle7ddww5KHcOFu+W13huZULfLV0jZVei9ONDRSKMSuJLiQp3WR/MkfF77HQbXKmUWLV7XCtUydr2Ew5aYZyps2UneJsc5M3mxXOt8os91pc7zR5OD+OpekMXevU+f2lN/l6aZGzzTKvNzZpBz7TTppYKWxN51A6z1OjM3x67j62jDtJemGILiWtwCehG/xnk/t4ojjN4UyBLR8bnWKh00Qg0KXE0nRG7QRX2jVeqWxwqVVjqddi3EkghcTRDaYSKQwpWet1WOi0eL1e5nRtk5rn8kBuhISmI4Sg3O/xlZUFfvvSGVZ6Hc42Klxs1DGk5HC2wJ0IIZACMqZFEEd0g5CMaTGbTPNzhx/gSK7AbrphwOnKJr/95hucqZR5o1ZhsdNivdfl8bEJ3g8hBJPJJHWvjy4l/Sgkb9p83+wsH5uYZDaVZsjSNI6PjHK12UCXElvTsDSNgm1zplLhTKXC+VqNar/PZDKJAGxdZ38mw0OjI/zCgw/wvXpodISG59EnABmR0Ex+afZZjqenSeoWQghipRi30lTDLpGKGTVTFIwky/061/s1Xm0v80ZnnatuhY+kp0lpFkII6oHL1+tX+VfL3+Jyr8wr7RX6KiShmYwaKXShkdJMikaCRujyzeYCS/0Gr3RWUCjGzTS6kGQ0m0NOkU2/zdV+lZfbKyz263yrucg9TpEpM4MmJP045Fy3xL9a/Q5fa1zldHedWuDiSIOkZpLRLJKaycPJSX5p+kmyuoUuNfaK+YGTA6UBPiAEHzDjA18aeHSAPaIXBsQozjQ3KJoJCqbDuJVkpzW3TYziRq+JUvAvrnyXXhSw3dHUCD+372EeyU/QDPr8wepFnlu5QKhiUNykCcFPzT3IwWSeETPBn5cX+VZ5ibLvguK2ounwTw4/QaBiZpw0/+uF73C902C7cSvJfzl3Pz8yeYhIxbxUXeO3rp6m7PXY7smRaf7uzBGUAl1KjuVGuZNr7TrtMMDWNFK6wUwiw528Vt0gUAovCvnc4ptcbTdAcdtMIs0/feBx6n4fKQR/vHyNM7VNgjhmiyYE//XBo/z0wQcQQjBf2eB/fO3bhCoGBEOaEDxSGOPnDx/jnkye3XhRhBeFnK1XGHMSmFJjXyrDO6l7ff7ZK9/marMBCLbsS2X46cNHeXZyhvcrimMW222qfZexRAJLakwmk+zU9n2uNht0gxClFP/n+fNs9Hpsd3+hwM/ffz+9MCSh6xwbGeH9eLW1hCYkCWkyZ+dxNIPtupFHrBTz7RUyus1/KJ3hpdYNenHAFongR4pH+Wf7fwApBFd6ZX7pyinKQZfbBBxLTvB09gCPZeZY6Tc4293gP5bPEqHYognJfzv5OIfsIuNmii/XLvH1+lVKQYftDjlF/s09f4dxM0U/Dvnvr3+Fv2wtst2UmeEH8vfwdGYfvcjnY5k5BGBJnb1ifuDkQGmADxDJB0xp4OTA/AB7REI3SOkmTxfnOJIqMm4luZMpJ820nebJwgxuHOBoOjtd79UJVYxSilgpXqtvEKmYmwS3XW7X+EhuggPJLPsSWeqBCygQ3JbSDZK6wZPFafpRiC4kCN6m5HVphx5SCAypcaldo+q77HSpVSNv2hzPj3EsN8puDqZyHM+NciRdYCaRYTcfKU7wWHGCocVOi5sEt9X9PhWvx1Oj0zyYG0WXkiCO2S5Sirrn0fA9wjjmSruOpWncohiKlGKl10ETEqUUu7E0jYxp8dT4NIfSOfalMrwTpRRXWw3cMOQWxZYbnRb9MCRWivdLk5KDmQyPjY2zL5VmMpnkTtKmycMjozw1OUml36fs9gDFdqudDkOPjY/zYLHIe6GUYjePpmc5nprmSHIMRzPYKalZpHWbZ3OHOJwYJaNb9OKALQqIUHQinw2/jVKKS24ZheI2AQq44la4PzHO/YkxHsvM8np3nQjFThe6mzyRmeWQU+SgXaAa9thJARtBG6UUV90qlbDLTmt+i4w0eTQ1xSdzB7GljiV19or5gZMDpQE+YCQfQKWBkwPzA+wxUgh248cRjaBPyesyZacxhMZOjmbQDPpsel3qfp9JJ4UmJLcJMKXGoVQOIQSm1BjSheQWBYKbDKlRNB2EEBQsh5xpc5PgNk0IuqFPO/DZ7HdxNB1H09npcLqAo+lIIdhNrBSBiin1u5T6PWKleCdSCJK6QdGyuU1w04jloAtJ2XPxoxA3DEHw1yQNg4Suo0vJdCKNLiVvUQwJoOq5bPZ71L0+70YKwW68KKIbBmy4PXKmhaPrIPgriiFH0xmSQvBuKn2XjV6XTuCzGyEEQgiEELwTIQSRUqRNg7RpcItiy3QqRRDH1Pp9ukGAH0XciR9FbHS7bHR7KEApxU6xUrTCPpWgQzXoshs3CtgMOoRxTC8KENyi2CJIaCZZ3UYIwZyVx5EGNwlQ3OJIk5AYTUiG5qwcupBsUYApNO51RqgEXWpBj07soQvJdkqAKTVG9SRCCEaNBHndYScNiRACTUj2mvmBkwOlAT6AND6gugOnBk4MTA2wx626bV5trPGbC/PMN9Z5qbZGrBS+ighVzJa8aSOF4P+6cYZNr8dKr0XVd9GEQAGm1MiZNj86eS/7kzmG0rpFK/S51q2zZdxO8ezoHA9kR3A0Aymg4rk0/D6NwAMBAkjoJlNOmlNrlznXLLPca7PpdRFCECvF0Ijp8MzYLE+MTLObKI652Krx5dVrPLd8iW+UFomVIm/apAyT3UwlUrzZrLLa6xCjGMqaFrauc63d4JXKOi9V1jGkoNx3iVBs+WhxnGfH55hLZhBC4MUhG26XmtcniGNuEYzaCdqBz+9ePc+NTptOGHBvJs/3quz2eKNW4TMXz/LC5jp/ubGCFAIvjvDjmCGB4JmpaX7i4GEMKRFCsJsvLFzl1OJ1/uD6ZVpBgB9HzKTSvB9SCAq2zXx5k7rnESvFUN6y0aXkWrPJN1dWuFiv44YREwkHU9PYcqVe5+vLK3z2/EVe3ChR9/oUHZuUYSCEYCiMY/5o8yxfrr3J5zZOc6m3iRSS/U6B7apBl3+59Bd8o36Vr1QvkNItNvwOvorY8lByih8sHuGQM4ImJF4csejVaYYuvThgy0+MHuPHivejC0lSM/HjiG80rqIhiAFLaBSMBOWgw9luic+W5rGlQT106UQ+Q0rAlJnhB/P3cjw5iaMZCATloEstdKmHLlueSM/wS9NPYgkNIQR7xfzAyYHSAB9QGh9g3YFTAycGpgbYo9wo4OX6Kp+5cZrVfpt1r0PZ7xEpxYnR/VhSY9rJUDAcelHA2eYm3ShgodcgRjFqJrkvPUJKNzmWHePHJ4/w1MgsQ0IIErpOzrTJ6Ca6kIzbSX5k4hBPFKeZdNIMGVJjXyIDQmBJnRHLIWmYFEyHM40NVt0Oy70W3TBgxEowl8xQtBweyI7weHGKn9z/ALtRSlHyejy3fJHnV69S9Vwafp+XauvkTJvD6QK6lOzmmfFZyv0eOdNmOpEmbZgsd1ts9nus9Dqsuh0avsfx/Bgp3WQykeSxkQk+NjbFk6PTSCkZKloOWdMka9pEsWIqkWLMSbDhdjnfrNINA5a6La406yR0g3szed4rP4q40Kjxby+d5VKjxnqvS83r0wkDnhidJGdZTCVSfHR0gp84eIScZaJJyW7+w9VL/NuL51jpdGgHAefrVdwoYtRxGHMSvB+2rvP4+ASbrkvOsjiUzRErxWqnw4brstHrcb3Vou71yVgW08kkmpRU+32eX1jg9y9fpun7VFyXM+UKmhA8UCxgaBqxUnx5+Tqnqmd5ob1ALeyx6jU511ln0sqyz84z1AhdfuXaH/NS6waL/Tobfpt1r8X9qQlyusOcnedYapLvKxzmmewBEprJUFa3mTDTpDSLCMWsleVHR47yo8X7KRgJpBAM3ZsYYcrKEKqYjG7xSGqKVa/FktdgwavTjTyuuVWyus3R5BgTZpopM8vfLT7AJ7L7mbayDJlS44CdZ8iROuNmimPJcX55+kmymo0hNfaK+YGTA6UBPsAEHwLjA18aeHSAPajsdfmVN7/BUq+J4i221PnU2EH+4dxxKr7L2WaJ31yYJ1Qx2z1VmOXHJg9zMJnHjyPG7SQ7xUrhxxGbXpeC6aAUpA2TnfpRiBsFNAOPUCl+9fy32HA7bHcgmeNn9h/jnnQBpRSTTop386frC/zGpVfx44jtxqwk/9OxpzicKfBuVrptYqX42sYiX1y5SjcMQHHbI4Ux/ocHP0YnDMgaFmnDRArBTjXPRSBoBR5fX1/ic9cvcItgSBOCH54+wE8fup+i7fBe9MKAX33tBU5XN1GK2wwpeXx0gl984BHaQcBMKoVAIIVgNwutJr91/g3OVDdRbBEM/fKxR/iRfQf4m+CGIXXPo+37/OnSEl+9cQM/jtnuR/bv5787fhxNCF4tlfjVl17GiyJuUgwI8pbFP330ET46PoYfx/zryy/yh61XQSqGFGBrOv9g4qN8euxhEprJH1fO8ztrL1ANemxRwAG7yL+69+/QjwOKRhJb6lhSZ6da0EMTknrYY8bKoSEQQrDTitckIQ1ebC3xe6XTXHDLbGdKjV/b/ykO2UVGzSRKQUa32MmNAnpxQDPss8/OMaQJyV4xP3ByoDTAB5zkQ6A0cHJgfoA9qBP5OJqOQgGKLYGKyBk2mpTMOhmudesI/rqr3RqTdoq8aTNuJ7kTKQS2pjOXyJLSTdKGyZ3Ymk7edNiXyLLYbdAJPRC8zUK3gSYkE3aSCTvJu/GikCCO0YRgJ1vT0KQgVop3M5NMM5NMowtJNwy4SXBbJwio+x5zyQxZ00IKwZ0ULIe8ZTNiJ7jUrKIJwS2KoUgplnttLE3jvWr6HoaUKAYEtwVxTN6yMaTGXCqNJiRSCHajlCJpGLQCD8V2CkvTuNFp4UcRfxMcXWcykeCeXI4wjvDjCFBst9rpUHVdwjgmiGMSus5tggGFEAJdSiKlaPp9zjcqSMFNilv6cciG18KWBhJBpBTVoMcWxS2Rilnzmhx0imR1G0vq3EnBSJDVbfbbBXQhEUJwJzNWlrzuMGvlKAVddrKkwbrfYb+dJ61ZZHSLO3E0g6KR4KBTQBMSTUj2ivmBkwOlAT4EJB8SpYGTA/MD7DETVpqC6fAWxZBE0A49rnfrzDfWOZoZJambbGdKjcOpIufbZc40NrjQKnMnbhTQCjxerq1xoVVh3e3wbuYSGWadDDcJbjuYzLHeb3OmvsH5VoVuGPBODKkxZidQir8mVDHlfo8z9RIXmhX8OOKdSCFIGya21LlNcNOI7VD3XV6prLPWa9P0Pe5kod3k9dom5+pljhXGMKTkLYqErjOXzDBfLfF6bZPLzRrvpmA5jNgOtwlukkLQCwNWex1eKZdoBT5eFHEn52sVzlTLvFEtkzAMNCHYThOCuVSG16sV3qhWWOt2eD9utFq8Ua3wermMF0eYmuQWxZbpVIob7TZnKhWCOCZWircRDChShoEuJQnd5LHCNFIIFH9FQE53mLayRCpCCkFKM8lqNkOKt8zZeWbsHH9TXm2v8Gp7hTd7JQq6g0CwRQko6AmOJyeQQnA3mh84OVAa4ENC40OkO3Bq4MTA1AB7RKRiUrpJye/SCPqgQApB1rAJVcznV89zrr3J680SupDoQhKqGFvTyZsOZb/LlU6V51YvcKPbouK5HM+Ns6Ud+pxplvjMwhm+VrrOF9cv48UhhpRMOmnuRAiBKXXKfo9eFNIKPJSAcTuJF0dcblf58/ISb7YqvNmqciw7iq3p3IkQAl1KbE3nXLOMJiSaFAigYDpcbFX5k/UFvrp+HUNqjNtJkrrBbo5mi1xu1aj7fYI4RiIYdRJ4UcTzy1c5U9/k9fom3TBgwkmS1A22fHnlOn+yep3PXDnLuUaFxXYTS9eIYoVCkTJMUobFcrfFxWaNLy5f53KrThDHHMkWeCdJ3aTpe5TcLjFgSEnKMNCF5ItL1zldLfFCaZ3pZIqcaWFIyZbfv3qR37tygS8vLVByXZqeRzcMsDQdpRSWppGzLC4363xrfZVTi9dwwxClYC6d5nv1cmmDX3v1ZV4sbfBGtULT8+kGAbamEyrF0EQiQcPz+OOFBV4ulVhstRBC4IYhmhBoQiCAf/TggxwbKWJqGqam0Vc+jahHKWwjgLyeYMrK8rOTjzNqphi6JzHCut9i2avjqwgNyUOpKZ7JHeR4agpDarxf//vyN/n85hv8u83TtCKPRtQnUBGakCBgyszyTG4fT6Rnyeg2d5v5gZMDpQE+RDQ+ZLoDpwZODEwNsAfoUpLRTR7MjKELydH0KJN2mkBFXGxXCVVMJ/TpRgG21PkHc8fIGjafKO5jo99hrd+mHvQZKvs91vodTKlxJF1EKUU98PjM4mnONEt0w4BIKRa6DZK6yYFkjoRucCeWpnFPqkDesBmxEzxemCJQEau9Do2gjxuFVH2XqufSCn0eyo1hSMmdpHSTrGlyLDtGUjfYl8xyTyrPlXadFbdNPwoJVMxr9RIziTSH0jmkEOzmkxNzxCrmnnSe4/lRNCE51ygTKUUvDNjs92gFPrPJDON2Ek1KztQ2eX75Ki9XNhjqhgHt0CdrWvzkgaPkTIunxmdY6rZY63Vp+B6hiqn5fVa7bYqWw75UhjuRQpAxTQ6mcyQNg/uyRUYdh4Rh8Ga9RjcMaAcB5b7LYrvJJyamSegGQ1+8cY3PXjpP3fcIlaLSd9GE4HC+wLOT00wkUpyYmuVivcZqr0svDAHBtVYTQwr2Z7JkTJP36kKtxj9/9WUankcnCGh4Hn4UcSiX46GREe7L5/n45CQNz+Nyo0GkFP0ootrvY0jJjx04wGQyweF8jp++7z6OjRTJWRZb9iVzpHWb+5MTjJpJns4d5GcnH2OfU2C7p3IH0IXkaGKco8lxThaP8nTuIEnd5P36zbUX+b3SaSqhy1Ap6JDSLO5LjPGDhXuZMbP81NhxnszsY87OcbeZHzg5UBrgQ0bjQ6g7cGrgxMDUAHuArelkDZuP5qY4khohZ1p8Yf0ioYoBwZaUbvLR3BT/1cwD5AybxV6D690G2/WigP2JHPelRzCk5CsbV/lmZYlAxSC4KUZxo9fg2dF9FEyH3diazlwiyyO5CeaSGfpRxOnGBqFSbPHjiIxh8URxCltqCCG4k5xpM5tM83B+nI+NTPF6fZPXG5tsJ4BQxTyUHyOlm7yTY/kx7ssUmU6m+dLqNRq+B4Lb6n6flGHwsdEppBC8US/zhzcus1PetDgxMcuP7ztMQtd5s1Fhw+1yi0ABbhRyf26EA+ksupTciSE18pbNw8UxjmQLHMzk+KOFq3TCgO3COCZrWRzJFmj6Pi+U1nizWUUpBQiG+lHEscIInz54mGcmZ1jpdnhpcwMvjniLYLHd4onxCaaSKd4LL4q42KjzSqlEP4rYEsQxecvmHz94jI9PTpI0dP50aYlOELBdPwp5dGyUf3j0KI+MjrI/kyFpGOw0Z+c56BR5MneAB5MTFIwkd/JQaor7EuN8PLuPOTuPrRm8Xxt+m6/WLnOlX2W7TuTzqfy9fHr0GJ/K38uMlWXESHK3mR84OVAa4ENI8iFVGjg5MD/AHqEJgRSCjGHRCPokdINbFFsCFTFqJdGFJGfYbHpddtKEYLXfRhOCfhyRM23eRnDTqJXEiyNipYiVYje6lFiaRt6w6YQ+QRyD4G1Wei26oY8QgnciENiaTi8KaQR9BG+ngJRukjUslFK8G1vXSBkm04k0ir8iuEkiEEDL9wnjmLrfJ6Hr7BQrmEykGXJ0nZLb4y2KLZv9HlIIwjhmN1IIBJDQdap9F1PTuElwmxdFZAyLSCksTdLwPZRS3KIYEsBqt4MhNaQQjCcS6FLydoqC7RDGikgpYqV4N6aUtH2fdhCw00avS9P3sTSNrGVRdGxAAYotupQIIQiVwtZ1FLszpYYmJKbUUUqxm7RuYUodTUh2EyuFUjFKKd5NSmiUvRZb9DhGVzGFOGLZa5LTbAQCS+rcbeYHTg6UBviQ0vgQ6w6cGjgxMDXAHpI3bc62Ntnod9hiCI39iRwfL8wwaiUJVEwnDFhym7hRyJakZvBUcZbXWyXW3DZvtiuU+l28OOQ2AWnd5Eh6hK9vLtIJfbw4YsRKsJtYKdwoZLnXpB70QXCTLiQ/NHmQjxQmsTWd3bQDj/naBi9V11jutuiEPtc6DbbLGRaPFCY4lhvFkBq72XC7vNms8LX1Req+x8VWjZrnEqO4SYAQggknSaRiXqqskzYM3qhX8FXEFkfTOZTOseF2We11ONeo4Bg6q902kVJsyZs2Hx2Z4MXyGhtul5rXZyaZZqeLjRpvNmp8Y20JR9e50KjR9D1uEiCFYCaVIlIxlb7Li5vrZA2T5W6bfhyxJWNYnJw7yNF8AUvTaPs+39lcoxeGKN7i6BqHcwVe2tyg7PZww5CxRIJ34kYRq90OZddlu3uzOSxd4/VKmfVul4V2i4bnEysFCvQgREqNmUwaeXWRG9dv0EgnyAuJbhhsF/gdnq+c40ZzmXa3zISZBM1ACMH3yts8R1i5iLf0bdbNBEYcYZpJdhPFAZ+sXCdsLnNfe4Ofq1zlaK/JE36Pn3HG0ddeQ7VWob2GzO/nbjE/cHKgNMCHmOD/x/jAlwYeHWCP6IY+8811nl+/xEKvAQpGrSQ/OfMAz47sZ8vlTpXnVt/kUrtKN/QxpY6j6bRDj34U0Y9DZp0sQRwRKYUbhehCAAJb0/CjGDcKiJTiEyNz/NDEQR7OTbCbVuDx75fOcb5ZYcVtEcYxnxzbzydH53i0MMlu2oHH55cu8Fptg8Vuk0jFjNspNCEouT0sTaNgOswmMvzyfR8lZ9rsZt3t8LX1RT63+CaGkDiaQca0aPkeltRoBh4xkDctpBCsdjtYUiNjWJiapB0EDJlSI2OY1L0+AkHN72NJjYRuULBsym4PBaR1k+D/Yw8+AOy670LPf3//c87t986dXqUpqpZsybZsubc4fdIIBFIgELLAY7OUvLCPx1IWHrBLZxceLJBNwktZ0sBxsJ3YcUnibmckq0ujNipT7pQ7t9976n/PjDKyLCxFjpxESubz0QF1z8PXGl8HdMaS/Fj/Gt66chVLts9N88WjB9hfzOMGAQpF3DBQoqj7Lo4fsCKZpuDYOIFP3fOwlEIQUlYESwklx8FSitu6+ri7dyXrsy0seW56ir/a+S20Bq3B0wFNkQhuoCk6Drbvc1tXL3f3reDmrh7OxQsCPn9olBemcxwolfD9gL5UCrdQYsp1aKnb9NVtCv29lGyH/qlZ7FodM19kyPXoHJ8m89TzKKWI3Xw9na+/k5VvfyNGOsUC3SjgPvkXHGsUse0GvX6J1Oo3YKx7GyreCiJcKP/4k3iHHiTI7UIrEzfZRrxrC+baN6EyvZxLMDuKve8eGnOjxOwSgRlDqSjaKSNeA7wG0rQCY/AurM3v41I3EhoO5UL8iBOWLeoM3R/aEuISUfEcGr7H0/MnaI0kyJhRrsx0cLbjtSIlz+FwJc/KRBP/96FnGW+UOdNAPMs12S6uauogZ1cJtOazJ/ZQ9hzQLLJE8dP9V/HO3vXEDJNzKbs2R6sFTtYrdEQTNEdirEo1cy6+DthVmOGfDm3nYGWeM13Z1MZbe9bQ8H0ykSibsx2krQjnorXmqdlx/mjXk3has0hD3LC4sb2H1almWmNxSo7Ns7MTjORzoDmtI5bgF9ZsZt6x6Y4neeDkEbbnczR8nyUKuKq5nfcMbWC8WqYlGuNv9m5j3mkAwgIlwvpMC//T2qu4qqWdkmPzpWOH+LdjB6l6Los0xAyTdw+tJ21FaInGeG52iuemJ5lrNDhTdyLJhzZczXS9xmC6iYwVYWU6w9lGC/Pk6lVm63WUEj536ACzjQYSaLRSoDXv7B/ifes3ko5EOBc/CNg3M8O00yBimFT//WscfOgxMvMlTNejKV+gNriSltfdzsZMEzoRx3Fdiv/8eao79qAB0ZoFTbffyOCf/x6xwX7wbdyRjxMcfwy0TwAorUEMzKt/FnPtW0CECxHU5vB2f47g8EMQeJyW6sHa+suozk2IMjiXoHgcbZfR+cNI00rcZ/4GXZoANEukeRDrmp/FWHETl6qR0HAoF2IZJssW5ULDoftDW0JcAlJmhJQZ4a1d6/B1gCGKl7My0YTWmo3pNp6fn0T4j8bqBd7Vt4GbWvoI0Pz56NNUPIdFAmjwteaR6aO8oXOImGFyLmkrylVNHVzV1MECEeF8DFGMVYscqRY424lamfZYgo1N7QggIpxP3fd4IZ9DiQLts0ig7rvMNGr82vrriBkG+4pzfPTgDhYJoFlUch3yToMfW7GGqu/y7OwkDd/nTAGQtiL0xJNc09LBwxNjiPBtGhACrTlaKeLqAK01vtY8NzNFzXM5TcDVAQeK8/zW5q2IQMVzeHj8GAigOS2qDFKmxdaVQywQEV7O2mwzq5qyKOATu3cwX6sTcRyuffwFKpkU030dHJ7IU+1eQbq9jXMxlGJjRwcbAXd6jrGRPWSefgH8gCUtM/O0dnXR8f/8KaKE/AOPMLnnAAuEkAAaKjv2UNszSmyoH7/mENRLoH0WKEIigEZXptB2EYlluSBujeD4k6B9QADNotoswcQIqnMT56OaVoLW6PYNBBPPA8IpAmgW6PmjaKcKOgBRXGpGQsOhXIhlixTLTsuFhkMjIS4xhijOR0QQEbpjKZQIZ0sZEQpOHSfwmbFrtEbimKI4TSBAsyHdhh34lFybuu/ycgKt8bWm4Dao+S6B1rwcN/CpeS55p07cMElZEc7WE0+RjcQQQEQ4Fy8IKLk2rg7oiCVwAp+XEHADn9lGDUMUUWXSn8pwmrAoYZh0x5PM2XWCQJO36xhKOFugNdlIDCVCZzyJ1poXaRYkTYua5yIi+FrTk0whvJQAg+kMRcfG833ydgNTFGiN6IAFhufjOg4pK4KIICKci1+vQ61OPTfDrbuOsGnPEX76bz7L3fd+nZ/42Jd4/199mp/adZSmYhmvWMKvVDkXEUFEMFuyRLo7wQ94CRG8chl77DhesYwYBpHeLl4kIGC1t2K2NuPOzIFXRdfn0SK8lAZlgJXkgomBah5ikRASFhkWku4B7XM+OvBA+9CYR5JdIIDwbcKiSArt1kEUl5qR0HAoF2LZaQbLXqIaujd0V6gnxGWm4bvM2DVmnRr1wGNJ3DRZlWzmixP7mGyUGa3kmXXqLNCc0hKNE2jNiXqJ+6cOUfc9vCCgM5Ziia8D9pfneDh3lIemjvCN2RO0RuLEDJOYYbKk6No8OHWEh6eOMpKf5HC1yHSjiqsDNKdkzAhXNnVwe8cKIobJuYxVinwrP8Wnju7mublJZuwajcCn5rmc6ScH1nNdazeGCK3ROHuKs4xVimhOiZkmHfEER0oFDpcLPDk9TiYS4US1jKcDlgymmnhT3xD9qQymUtQ9j1yjxkyjhhsEnCLc0tnLO1auwVKKhGkxa9d5fnYKww9YYCC0xOL4lSr5qRyP7ttLizKZyeexGzbv/bt7aJueZ/VMiXemWlmxbjWxaJRzqY+dYPZLDzL1ic9R27EX55ntDD3wOJm5AobnsyCZSRPV0Dg8xvTn/h03N4NfaxAfXMk5CXj5eezxKdzcDKcJxFb2YR87ydy9X6UxNk7jyDH8egO0ZoGRyRDpbKO2ex/lZ7Zhj+4ivTYJtWlAs0Ta1mMM3ImkuxFRXAiJpglKJ9Az+1gkgBFBEm0Yg3eiMn2ci24UCfJH8XZ+hmBiBP/4k4gZRzeKoD1OEVTXJqxr3g/KQkS4VIyEhkO5EMteQlj2sjpD94e2hLjMHCjP8ejMUbYXpjCVou67CMK826DqOWig1YoTUSZNVpRZu8ZgMst4vUzOrqIQ/EBjiHBr2wre2bee9ek2tNYcq5X4/Mm9fC13FNGgRMhaMX51zXVc39KDpQyqnsMXT+znidkTjFWLLGi2YsQNC0MUEUORMCzaIwl+ec21ZCMxziVv17l/4jCfGdvDEl9rumJJhpJZDpbzRJTJW/pWcUt7H93xFGf6093PMFGvUvUc2qIJDpXnafgetu8jQNqK0JNIUXQc4oZJxopyfVsXd3aupCOeYMnI3BRP58Z5enqCTCTK+nQzb+lfTX+qCVMpljz43LOMbdvBtzrSXGnGkZHduFMzrN15GA0kvYDSugFSiTjtx6bwy1Wa3/1W2m6/kczVGzkXeyLH+N9+nMI3n6VxfBx0gNXRhhGLodJJglqdaG8XzmSOxrFxxFAEtgNBQMsb7qTrA+8me/sNnEvgekx99DOUR3ZS2zdK0LCxWrM4uVnc3AwLzOYsRlMafB+rtRmtNWIY1EePoD2PoF6j/a5Wut++CrOrF12ZRiJJJN2Nat+IMXAXEknySrnbPoaeGyWozqKaVmKsei3Gyls4F+27BDN7cV/4JHr2AGgfRIGZQHVeiS5NgGEhqU6sq96LNPUhZpRLxUhoOJQLsew/EJadU2fo/tCWEJeZWbuGpwNmnRo1z+OvDz3NrFPnTJsznQx3r2EgkeV4rch9kwfZWZwmQINmUUQZ/Pqarbyucwhfa+4dP8BHj27H0xo0p12Zaef3Nt5K1oox1ajylweeYUdhmjN1xVK8a8UVrM+0YoqiK5YkYVqcz+7CDL+z45tUfZczZa0oP79qE+syrQjQl0hjKYOXc6CYJ2GaPDZ1nPvGD1No1NCikCBAi7Am08JHNm6l4Xt0xZNElUHKinC26VoFJwioeC5rUk2gFIZSnK2ydxQ3Gaf+/A5mPvEFyvsPIX6AaM0C1dLEmj/5LSLtrVgtzahEnEhHK+eig4Da3oMc/PDvU9t3kFM0C5Ib1tL9wfeQ3LwBZyLH9Ge/RP7Bb6BdD9As6f/tX6PnP70fMRTnon2fxrFxgmoNv9Fg4r9/nPmvPsZpWmO1t9Lzv3yA1LWbUPEYM5//MtOf+TeCShXQdL62lc43tWENbMG86n0QuEi8FSIpxIzy3QrmDoEZATFQmV7OR/sO7pN/iX/sCUADmkXKxFhxE+Y1P49uzGO0rkEDokwuFSOh4VAuxLKXpVh2TrnQcGgkxGWmLZqgK5ZiY7qdQ5U5Kp7L2XaUcnRFkwwkmrgi007FcwjQLBIWKeBAeQ7b96j5LmXf4RQNwosEnCBgwUSjwrFaEYSXmGpUUAJr0y0MpbIkTIvz8YKAmu8RNQzOZoiiO55iZSLDYCqLpQzOZV1TC72JNJ2Y2HPzrDw8xbVP7mXr13eTLlbp3DdGvVxmY7aN1miclBXh5XQkUvSlMqzPtmKYJoZSvJzUhrVkV/aRXj2IMzWD8gOEF6lA0zh6ktTmDcQG+oh0tHI+ohTV/QexJ3K8SFhQ3TuK2dxEYt0qmm7dil+30Z7HKcICsUwq23fjlUqcjxgG8aGVJK9ajxGPUd25j5cQwZ2Zwy9VSG+9huTG9RipJEGlyilCfdLGiBtouwQCqnUtkmhFzCgXQ7WuRjWtRGV6+U50bQ7t24DmFGFR4CHRJiSSxGi/ApSJKJNLxUhoOJQLseycTJadVy40HLo/tCXEZSYA1mfaaLKiNGyPM21u6iRqmIgIDd8lZUZQCAGaRQI+mnXpVqKGiaU1KSPCizSIsKDmu8zaNQpOg6gy6ImnKbg2CKBZ1BVLojWMluewxKArliRuWpyLqRRxw6Th+6A1iLDAdDxEPATBVIrvpLLrACqTJLv7ML/w6cdhfJpkqYbha259aDuZdUMM3nw3pW27ifV1o2JRzEyKiyEiEAREujpw8wXQGkRAa8SySF65DjEMLoQOApJXrCHa00mtWOJFQnLjWrxiifroEezxKYx4DDFNtOeBJiRo1yO2egBnIoczNYPZlCHa08nZtO9jHx/Hr9YIGjbJTRtwJqY4k9XRhtGUpvzcdlQijl+to1IpgkqFBdUjDeonbVJ9nUiigx8ESbQiRgREgQ44RUCZYJhINM2lZiQ0HMqFWHZeBsu+o2ro3tBdoZ4QlxElgu37TDQqVDyHhu+xoDUS57a2ldzZPsCCJisGaJ7Jj2OKYoEpilvaVnBDay/t0QQLEqZF1XM5Ui0ggCEKQxRNVpT95TyPTR/jkekxLKXQGhqBBwLZSIyIMhgt53kuP8kL8zl2FWfYlGkjalqciyWKCDA6PcWtj+7mmmcO0n18hjdfcz1be/oxIhbnM/qbf8LMfY8wfc9DJMZnsQ6dIF5zEMdFAcl4nEQ6xfQXH6D41Ajz33wWr1Ij2t2BmU5yMaLdnXjFEqVnt4MIKMFsztLyutvJ3rYVq7WZCyEiaM/DHp/CK5TwyxXQGqujDdBU94wyc88D1A8epTF2Aq9UQVkWWgegNVZXB365yvS/fImZL96HNzdP0HBIrB1iifY8Jj/6GaY/9+9M/fPnmPvSV9G+z4KgWgMRzJYsRiZNZdtOys9tp/DQN3CnpvHmC4ih0K6HlbVofcP1RK+4DckOIMrk+04HSLyFoHQSGvOgNYiB6tqEufn9EEkiIlwqRkLDoVyIZd+RwbILUg3dG7or1BPiMpKNxOiOpWixYmhga3MvN7b28e6+jZxpVaqFFfEMccMkYZq8tXstN7X0cWVTBwtEhJQZoTUapyOaIGNFyUZi9CebOFErMVYtUnAb1HyXkutwQ3MPa9OtrI5n6HGgODXNnF2nli8wXyqy8pu7KM8XWb2iHxWxeDlx06LL0dzYMFj/xF4G42muff3dbFx/BdHWZs5n9Df/hJkvP4wzMY03N48zmyfW10V8oI+mG64mtrKH1IY1FJ/Zjjs3jzubxz45iTubJ9LRRmygD2WZXIzM9ZuxmrNEOloxk0m6f+5dtLz2VpIb1vBKmOkU8aF+zHQaI5kgc8PViKGoHxrDmZrFm5vHPj6OKEV8zRCZG68l0tZM8+tux8sXqGzfg1cs4ZerVF7YAwLxwZVEOtrQQcDsPV9h+v+7h9Ljz+LlC/ilCu70HOktV5F9za1Ee7tJrF9N49AYztQMzsQUzmQOv1ojNriC+NpVpK69iuytW2h9+xtQPdchVoIfBFEGYsZQLUMQ+KjsAKptLdbmn0XizYhhcakYCQ2HciGWXRCTZRcsFxoO3R/aEuIysibVSl88w3DXWjwdkLGivJw72vu5JtvFAlMUCdPiTKZSXJFuY22qlYpn4+mAz+x4GiZnoS3N3V/azuSKFiotSQZKMd58592YWjP1rZ0c/h9PcrA1RlO+SrJSp3OiQOKaPM61WzGScUSEl9PR1UVbaxv++vWgwcymEaU4n8reg9RGj0IQsEiEoFbHmc2z8tc+QHLDGlQsyqHf+jO07XCm2oEjzD30TVrfcDuvhq6feSduvoAohUQsjESc70Z8cAWRn/4xOt/3Drz5IrP3P0J5+x7wfUAAjTuXJ3XNRvo+9LNY7W2Ut+9m9ssPcYoAmgVz932N1je9huTGdWjfp7r7AJWdexHOoDUoRfcH34vZ2kz5mRFKz2wD32eRCH6xjF+t0f/7/yvxNYNYLUlQFqJMfpAk1oSKJDHarkA3Cki8GQ2IKC4VI6HhUC7EsgtmsuwVyYWGQ/eHtoS4jMQNiwuRsaKcjxJBidAciVOZmOKqr77AFQ8+Q6ElQedEAdP1KTfF6X/nm8i8MY4oRXIyT/roFNcc9AkElNYscMbGcefmia/oQSsQEV6OskxUcxMXKqg3qB08xkuI4FfrNI5P0HzXTfjVOpGOVrTvc4oAmgViKNy5eVQ8xgIR4Vy07yOGwflYLVm07yOGwblorVmkQZTwcoxEHO37RHq7cGfzBI0GLxIQqOw+gEZQiTjx/j7MTAp3ehY0IQE0ZiaN9jyCho1XKmNPTYNhoH0f0ZxmpFPEBleCodB+gDOe4yVEcGfyePl5rLYtLBCluGiBD8pAa42I8N0QZbJAEq0sEC4dI6HhUC7EslfEYNkrVg3dG7or1BPiR5gZjWLsPEzj2Z00FesYQYAAqVSKVFcHfqVGeecB0FA/dhKvUEZYICxIXrGaxOAKKrsPYE/OEGlrRkUjXKzAcXFyM9QPHeNMiXVDdL/vHUTaWjBiEco79lHZM4p2PU4RUAqrNUty3SoKTzyHmAYgGMk4Z8s/8iT1Q2NUdu4n2tcFShDDYIlfb+DO5Zl74DHsyWmcyRyxlb2czZ7IUTtwmMKjT6E9D79Wx2rJcrbKzn1UXthD8YnnMDMZantH8StVzpS97QaMdJL6wSOUR3bSOHwMN18ArTlFENOk6+ffTXRlL0YshjszR+GRJwABAQHMbIbMTdeR3rIJFYsSNBrUDx/DPj7OmWIDK8jcdB3lZ0awYhVUNIpEk3y3/BNPo0sn0MUTSKIVlImI8MNiJDQcyoVY9ooZLPuuVEP3hu4K9YT4USWCmU6C61E9dAwxTKI9HaioRXX/YUojeyg8vZ35x5/HSCUxM0n8egO0JtrbReA4TN/7NUrP76Sye5TyzgM0bd2EEY9xMaxsBq9cxa/WscenULEoibVDtN59C01bN2GmkyzI3ngNtf2HcQslglodFYtiNqVRpknuiw9QfHob5W178ItlYgN9mKkkS07+w6c5+XefZOaeByk+s43G8XHiQyuxshlEKQLbofTUCCf//pNMf/bLzD3wKNV9h8APSG26giWNY+Oc/JuPkfuXL5N/6BvMffUxgnoDszlLtKudJfNff5qD//NvM//Ik5Se3UbxiecwMimMZALtemjPI7qyBy9fZPbeB5l/5Amc3CxBpYb2fIxEHLFM0JqB3/8ITbdcjxGLIkphJOKIZVLZtgsVixHpaic21E/fR/4T0d4uRASrrQV3do6g1sCZmkYsk2hPF4gw+8X7KD89AoUDJJuPIi1rkGiGV8rd9jH8Q1/BH/s6wdQ2cBtIqgsiKUSEy91IaDiUC7Hsu2Kw7LtWDd0buivUE+JHkIgQacmSWNNPYlU/6U3riA/20Tg+iTM9h1+qEDRstOej/YDu97yV7I3X0HL7VlQsSvGZHeD7BLaDO1/Emy+iXY/01VegTJOLkdq4lkhblszWq0muHaTzp4bJ3nId0c42ztT2pjuRiEX25i0k1g5hZpsof2snfqVK0LBxcrP41RqpK9YQ7e1ElGLmSw9y/C8+ijs3j/Y8goZNbd8hRCmab78BUQq/WmX8Hz7F3AOPETRstOvhzhWwT04S6+8j1t+LX2+Q/9rjzH75a9QPjRE0bIJqncbxCaJ9XSTXrUJFLCq79nPoI3+AMz1LUKkS1BoEto2KRlnxn3+R5LpVtL39DfilCpVtu9Cuh3Zd3Jk5VDxG9rattL3jTSQ3rGXFr/8C2du2YmYzLLHaWogNrSR93WbiawZpvvtWen7pZ4ivGmCJKEX62k1Y7a2kr9tM5oZria8eoPDYk+h6A7RL200Rolkf3CqqdQ1ixrhQ3v4v4e+/F5wS6AB8Bz03isSbMdrWgwiXs5HQcCgXYtl3zWTZRcmFhkP3h7aE+BEkpkFsZQ/x/l4Cx6V2+DhzjzyN9nwQAa1ZJBBpzdL+ltfgVWqUd+znFAE0C9x8gcaJSdAarTUiwsVovv0GdBCACGiNKMXL6fmZdxK4HvZEjr0f/C8EtgMIoFlQOzTG/JPP03TTNfh1m8Z4jsC2QfMStX2HqB89TmLNIJWd+6ns3M8iATTg+zSOjePOzaODgAWlZ7bRODYOIqA1C7xCkfxXHqPjnW9CRSP4pTJBwwHfBwE0IQGlsNpb6XjXW2icmGD2/od5kQAaZ2oaq6ONrp99F6IUYhq8nPjACuIDKwg8jwXKNDmbWCbNb7gTtCaoNTjxJ38LQcASEQGngq7mQGvQGkT4TrRbR1enIXA5TQQQgvxhgvocKtnO5WokNBzKhVh2URTLLlouNBwaCfFDKPB8fNvBr9Y4FxEhaNho38eZzeOXq4CwSIQFfrUOCNrzMJJxrOYMaM0pwiIRvHIFe3KaoGGjPY/z8cpVgoaN1ppzEaUQEUQpzkdZJgQB0d4uXiQsiXV34uYLgMYenwLD4BRhiTMzh4rHcAslrLYWgoYNCIuERSoew8nNoh0XdyaP1dYCSlgkwqJAExtYgRgKDANnJo/2PEBYJCxypmcREfxKjUhHG2YqxUsJYll4s3ncuXmChs13okwTZZqck+8T2A6gMdta0I7LAjNpoLVGDAHfRVdn0IGL9l3ORztV8B10eRKUyUtp8BpIJIl2KqA1WmsuJyOh4VAuxLKLZrDsVVEN3Ru6K9QT4oeEWyiTf+wZZu57jOqBo9THTpLasJqz1Y4cZ+rzX2Xu4adAa2pHT+LNFwFhkQjR7g6inW3MPfYM8998DoIAe3KGoGFzigCaaG8X2vHIP/o09bGTxAf6MGJRznbyn/6FwlMjVHaPEjgusd5ORCkuhtXcRGlkF9W9BznNMIit6MGdL+DOzJF/6HEiHW1UduwjcF2EBYJEIjTddC3VXQeo7NhL4ZvPouJxnKkZ8AMWCYhlkbluE7NffhgnN0Pp2W14s/No32eRCFZbC9nbb6D5jptYYLU2Uxs9Qv3QGCAsEkhcsRpRBoXHnyX/lccwkgkaJybQts1pWpNcv5rG0ROUnttGffQI6Wuu5LvRGDtBdec+Jj/6GYrffAavUMLJzRBUa/j1gNSaJMn+OBLLgJUiOP44ujIF0QwSTXM2f/Tf8XO7CGZ2IWYMXTwGBJxmxlFdmwkmRwjyB9HlCSTeDFYcEeFSNxIaDuVCLHtVCMteVZ2h+0NbQlzmvHKFkx/7V+af3kb10HEIAmI9HXS85S5W/vJ7WVIdPcreX/lD/EqNoN5gQaSrHSMWwZnJoz2P+NAKvPkijfEcYigQgUATH+hFxaPYEzmCuo3V1oIOfOwTk6AUkfYWUhvWsPoPP4yVzbBk/6/9IYVnX8CvVAAhe/O1tL/lNbS/5TWIUlysAx/+Q6qjR7BPTpFcO4g9OY1fqRHYDRaY2SZULIJ2PZRpEjQaRDracKZm8EpltOshEQsjmSA+tILGsXGMeJyg0QClIAhwZvOIMoh0t6FdDxWL4UzlSKxdRWrzFQz9wUdY4tcblJ/fQe5zX6b8/A6c3CypqzfgTs9iT04jImAYiBLiqwfRvodfKOHOzRPpakf7Afb4JGhNtKeL7F23sOpPfotXwpmZY+7LDzL+1x/FK5VZoF2P2NAKrNYWavsO0vn6Ltrv7sVMCLo2C1pDNI0k2jGv/xAq3cMSb9vH8I9/E+1WAQWxLGLG0HYRzAQiCq0MqM+Db4MOWGCsfhPmFT8GsWZEhEvVSGg4lAux7FVjsOxVVQ3dG7or1BPiMqW1pnboBFP/+iCVvYdAaxZ45SpeuUpidT+x7nbcQoljf/cZyrtHCRo2WmvQmqBWp+sn3kjPe99K2xtvJ9LZSv6Rp9CeD34AfgBBgJFK0P9rH6D19bfRcvv1uPkC5e37WKQ1frWGX6tjtbaQWDOAGIqJT97D1BcfIKjUQGvQmsbxCcxUgsy1V2LEY1ystjfeQXxwBR1vey1GIk51z0HcfAGCAAJNUKsT6Whl9X/7CNlbr6fzx99Mdc8o1f2HwQ9Y5AcErktmyyYGf+dXaLp+M5mbr6X0zAs4kzkINAQBfqVOasMaOt/zNrp+5sdpvutmut73Y5xJWSaRznaab7+B1OYNtL9rGAJN4RvPQBBAoMH30Z5HtLuDoT/+TbK330j27lupHxqjtncUNCGNX67gF0tEV/QQXzXAhdBaY4+dYOx3/xxnchr8APyABWIY9HzoA3S878dJXruVaJuFntkNOgA0eDYELmLGkeZBRJn4x5/AP3AvuFWEkNbg1VGZXsxrPojRdTXG0GsIpnZANQc6ADToAF04ikp1o1pWcakaCQ2HciGWvaoUy151udBwaCTEZax+bJza0ZOcrTo6hleqoLVGDAOvXEV7Hks0p9SOniS1aR2ZazeiTBMMg0UiLBHTJNrZSvaGq4mt7KG86wCnCEuc6TmcqRnENNBBgFcqE9QbnCIsqY4exZnO82rJ3ryFzNbNxFf34+YLnCIs8UtV3PkizXfdhNXWghbhFOE0P8BIJYgPrCB7503Yxydx5+ZZJJzi+1T2jJLcuJbsLdeTuX4zL0fFohjZDNk7biR15XrENABhkfBtgkQiRDraaLrjRsymNLVDY7xIWNA4dhJ3Zo4LpT0f++Qkfr2BFl7KUER6OsncvIXUpg3o2f2geZEAdhldzYEYoANwq+BUOEUQYZG2i4gyUN1bQExEhJcQAa3RjQLarXMpGgkNh3Ihlr3qFMu+J3Kh4dBIiMuR1iRX92M1ZwDhTIk1/ZiZFGiNV6lixKOgDBBOC3yfxOAKrKY0RiyKRCPg+YCwSARECBo29uQM9uQ0Kh4juXaQFwkLzGyGSFcbQd0msB3EtDDSSRC+TVgQaWshtrKHV0t97CResYwzPUeks50XCQu05xHt7qR+aAyxTNz5IijhFGGBRCzc2XkC16V+aIz4mgHEMgFhkbAoecUaVCTCdyIiLDDSSSQSASWAsEgAJXiFEk5uhsaRY0R7u4j2dvFSQrSvB6u9lcBxuRDKMpFIBL9aAwQtvEhrnPFJ/EIBt1BHmocADQinmVEk0Q6+jdYaxIBYlhcJIiBmDEn3ISKIlUC7dRDhJQwL0IgV51IzEhoO5UIs+54wWPY9Uw3dG7or1BPiMiIieOUq9tQ0zlyBoG6zwGxKk75qHV1vvxsjFsVMJwkaDvnHv4UoATRoaLr+KtpedwuxFd0sMNNJ3HyB2ugYiAIloDVWcxNBwyH3xa8w9/ATCIJXqaFthwVGMkGko4Wun3gTsRXdKMvEymbIP/o0ft2GIGBBYvUA7cN3kVjdj4pGuFjjH/88uS/cT+6LXyGoNagfOU5gO6A1iCDRCLH+Pkrf2knhiefJf+0JrOYm7Ikc2vcRDYhCRSMk1g4y86UHKT7xPMUnnkdFIgTVOjrwWWC2NJG9bSsdP/FmLligsVqy2CcmaBw9AQgoBWhifd00jp1k9t6HmPvyQxjJOF6pgrYdFhhNaeJrBul8zzuwWpu5UEYiRlBvUNm+G5QBIojWmE0ZjFiMqY//C8nsfsyoB14dfAcQMCJIrBnVfwcqO4CIQhJtBLmd0CiADliU6MBYeRuqeQix4iAKrATB3Cj4LqBZoNo3Yl71XsSKcykZCQ2HciGWfc8Iy77nOkP3h7aEuMyU9xxk9uGnKO/cj5lJE+1oY8Uv/SSRlixnmn7gG8zc/xjO7DyZzevJXLuRttfegpgGCwLPo7JrlPzXn6X4/C4Cx8VMJ7AnprEnciwSQQxF0w1XY8SjuHPzWG0tdL/3bTRddxVnqu4/wrG/+WcCx8GIx8nefC3Nd2wl1tPJxRr/xBcY+/N/hEBDEGAkE1jtLZiZFJHWZuyJHIl1QxSeHMGdzQOaBWYmTfKK1fiNBmYyjlessMA+MYFXKLFIBKuthZbX3ER5227iqweIDayg/zd+kVfKr9So7NjD7H2PUDt0FDc3h9XRgn18HGdyhkUCKhal5XW34RUroDVWWzO9H/o5EmuHeKUqO/ZS+PpTzNzzVYxUAhUxcSdyNI5PEMka9P1kN9lNKaR1LRJvQ5dOIuleVN+NGL1bOZOuz+Pt/BS4FfAdVM/1SMcmVNMKlgTlSfTsfryDDyCRJMRbMNe9DUl1IWaMS8VIaDiUC7Hse0pY9n3RGbo/tCXEZcYtltFBAH6AkYxjxGO8HDs3i/Z9jFQSM5VAlOJM2g/Qvo8zPUdgO0z/+6OMf/wLLNKaJdlbtjD0X38JI50EhEhrlpfjzhcJbAcjEUcMhZFMcLHqxyc4/Lt/SfHZF0BrFmmN1Zpl5a9+gKabt6AiFhOf+AKTn74H7XqAZklm69Ws/j9/ExHwimUO//afU909CmiWqESclb/6AVrfcjdiGkTaW/luBY4LWuPMzOGXKkz846eZuecrLNJ8m6b9x99M///2KyCCsizMbIbvVmA7OFPTaD9g/tEnOPbf/goclwUDP9dDy9Yskh3EvOaDSDQLykBiWV6O9hrgVMCIglKIleRs2nfAqaJ9B5VsR+sAUSaXipHQcCgXYtn3nGLZ90UuNBwaCXGZsZrSRJqbsFqzGPEY5xLtbCPW04mZTiJKcTYxFGKZRHs7MZvS2OM5UAaLRFiiYhGifV1YLVkirVnOxWpuItLZhpFOYiQTXCwdBGjXpXbwGGjNaSJ4lRq1IyeI9XZiZtKoZALtepwinOb7BPUG0b5u3HwBv1rjFGFJUG9gNmeIdLYRaW/lYqiIhUQsor1dqHgUZ2YOEBYJ3yYYqSRWSzNWWwtmNsPFUNEIsf4+Ih2tNI6dBKXQAiqmsJojLFImkmhH4i1ILMu5iBmDeCsSTSNWkpcjRgSJN6NSnSAKUSaXipHQcCgXYtn3hWLZ900uNBwaCXEZEhEuhIhwLrXRMUoju7GnZlDxKAQBICwSwUgliLS14BUriAjn4hXLOLPzzH/9Gcov7MUrV7kYxed3Ut65n+r+wzTdsJmzKcskuW6QuUeepH58HHtiCrO5iRcJiMItFNGuS/7hJzDSKfx6Ay18m7AgvnoAFY8jSnGxtO9T23+IwtefIWg4iGFwirBIwGprRiyL+ceeZP7RJ3ELRYJ6g4tlpJKkrlyPth1ASAzEibRYYESQRDt4dRDhOxERLkcjoeFQLsSy7xth2fddZ+j+0JYQP0ImP3sfhWd3UN6+D5QQ7++ldvg4XqGEGAZGOoHV0sSq3/kQTdddxbk4M3lKI7s5+fEv4M7msVqbSQytZPC//hJWcxOv1MmPfpaZ+x7Fmy+i0ZjpFF6hhDubRywLsUyslixiKIKGjbJMor1d1A6OEdg2frmKWBZimcRXrUS7Lt58ETOTBsPAPj5O4DjgeES62ml53a0M/f6HuVja8zn595+k/K0dVPceREUsIr2d1A8excsXWWC1t2Bm0gQNGxWL4tcbRDvbGPi9DxNfN4SZSnIx6keOM/nRTzP1z59HxSOs+KkVtN3Vj7nx3Ri9W/lhNRIaDuVCLPu+Epb9QHSG7g9tCfEjoLhtNyf+6XMUnn6BBUJIhKbrriS5dhC/bhPtbCF787WkN63nXLTvUzs4xoHf/DPqh4+xxGrJ0vbGO+j/9Z/DSMS5UFNf/ApH//i/EzQc0BrQLMjetpXMliupjR4luWE1U5+9D/vEBIu0xkjGia8ZJN7fS6S9FWd2DjEM8o88hTdfYInZkqXjba/DK5aIdLQR6Wil+/0/zsXSWpP/2uOM/8OnqIzsYolELJrvuolIVweIIIZB4bEnaRyfQDsup2hSV29k/Sf+Gqs1i4hwMWoHj1J+bjul57fT+64ria5aj9G1mR9WI6HhUC7Esu87k2U/ELnQcOj+0JYQP8S079M4MUXh+V0s0YBoTf3YOAO/8UESQyvRvo8Rj3E+OtDMfvVx6kdPAAJoFrj5ArVDY7iFMioeQ0T4TvxanereQ2jPB605RUAJyjToePvrMLMZ8o88iV+ucJoIfrWOO5tn4Dd+kfTmK/BKFQ791p/izRcBATQLvGIJr1xl6H//MGKZqIjFq0E7LrV9B6m8sAdEQGsWaMelcXKKwT/4CFZLM5UX9lD4xtNo1wUBNCGhNnqUwiOP0/4Tw2AYXIzEmkESawZpe8cbUZaBRKL8sBoJDYdyIZb9QCiW/cDkQsOhkRCXGe0H+A2bBVprziVwXPxqHRWxMJMJEE7TgJltwspmENPAiMc4F+0HaN8HHSBRCwLNKcISv9HAnZsH30f7Pufj1xsEDZv62AlAQHhRoPHrNkYijhGPYSSTeMUKLyGCDgLsyWkkYuFXa6hEnBcJi/wAsylF0Ggglon2PC6G1prA9fDKFSQSQUyTRSIssbJNKCuCRCwCx8UvVwFhkbAoaDQIPB/t+WjfR2vNxTKSCSQS5YfVSGg4lAux7AfGYNkPVDV0b+iuUE+Iy0D9xBTl3aPMP/4tyrtGia/shkCjIhZnmn/6BYrf2kVtdIzyzgPUj08S1G0QFqlYlMSqFTTfsgUrm+Fc7Nwsdm6G3D1fo7x9L9p2qJ+cJKjWOUVYYDVnSa4dZP7rz2JPzRDpaseIRTnb7Fe+QWXnfqp7DwGayq4DLBIWmc0Zut/zNpLrV6GiEbxSGWdmjsbYSc4kpknzbdcz/+hTBI5L4fHncOeL4AecIkS6OlARiwXz33wOMU0wDMxUgldKez6Fx5+j8NhTOJM5Ss9ux56cRtsOi0QwMilSm68ge8eNqHgMq6WZ6r6D1EePAMIigeiKHtJXX0nxqecpb99NrKcLggAVi7LsPxoJDYdyIZb9QAnLLgmdoftDW0JcwurHJph56AlO/vO/gR8ghkH6qrUM/cYHifX3oCyTBZNf+CqzDz9JaWQ3Goj3deGVqxBodOCj4jHMTIqh3/gg2a2bORd3vsj8U9s5+dHPYo/nWBLt6UQEaoePoaJRzEwKsymNk5vBrzWIdLSSWDPAmj/6z1jNTSw58Y//wuSnvoRfq6F9n2h3B369jpcvYaQTKMuk5bW30PH215PetJ4lU5+7j7mvPU7h8ecxW7KgNWYmhXY9nOlZzEwKszmLN19ALAtncpr46n4C28EvltFogoZNYvUArXffSud73kqkvZULpX2fk3//SQrfeJbKjr2IZRHt7cQrlNBBQFCtEelqJ9rTxeDvf5jE2iEW+A2byrZdTP6PLzD/6JNoxyM2uAJRgj2RAz8AJcQGVjD0x/+F5MZ1GPEYy140EhoO5UIs+4ETll0yOkP3h7aEuAQFnk/+m88x+jv/F4HtgOa09jffwbo/+nUW1MbGOfa3n2Lu0ac5U7y/h5Y7byC1bhCVSBDraSe5ZoBz0YHGzs2w/9f/mOq+Q6A1S6y2ZgY+/POghKBuUzt4lNy/Pkhg2yyx2prp+el30PP+d6IiFnOPPMXB3/4L/FIV0Cxp2rqZjre/Do0m1tdNpL2F+EAfZyu9sBdnaga/1sAvlhn/xOdxcrMs0hqVjJO9eQtNN1yDlc3gzMyR+9x91I+NQ+CzJHXVegZ/91dJX70BEeE70VpT2bmP43/2jxSf/hZoTjEUiTVDtL7hdmIDfRipJIn1q4j1dXMmv1YnqNYoPjVC4Hnohs3Y//G3+OUKaL5N03Tr9az/f/8CI5lg2SkjoeFQLsSyS4Ji2SUjFxoOjYS4BAW2TWXvYbQXAALCaY0Tk9RPTKLMyJGhAAAyV0lEQVS1xp0vUty+l7PVj00Q7++l7Y2303LrtSTXDHB+msqeQ9gT0ywSYYn2A4x0gvY33kHLa26isu8wge0AwhJ3dp7GiUm066GDAGd2nsBxOUVYYk9OE13RTftb76bp+k3EB/p4OZmrN9D2xjtof8traIxP4eaLnCZCUK1jn5yi5bW30PbWu8lcv4nA8yAIAGFJ/egJKrv2IyJcEA32yUkqu/ezSDjFD2icGCd19Qba3/EGmu+8iVhfN2czEnHMthba3v562t7yWgLHJbBdFgnfJtjjOWoHj6IDzTIYCQ3//+zBB5yd50Hg6//71dPPnOlzNOrFlmRZsmTLvYwdO4lPkk0xTkIJmGQhsLuEFmB/sCzchb3Ape2lLksLCSQkMfGY2E7cbdzlI1vd6nU0c6ae3r7y3veMPJLw1cgt5cj+nkfJKQTahkagreSUjJJVaDNGNILQdRCCUwQIQBO4pQrS80FCeOEAdl8XIDib1dOJ1d1BMzeJky8xH7/p4Dcd3HwJv97AbzQBwSwhaBG6xixdQ4+GCS3s5wxBizAMzK4U9ZEx3HwJ2XQw4lEQvEowSwisrhTOxDRetYb0JefiVar4jktzYgp7QR/Scfh3hMAa6EU6LkII/HoDIxHjDEGLV65gJOM0xiaQrodXq3Mu0vdxS2WaozmsdB9aOAwIZglm2QO96LEI0vMQhs58ZNPBLZTwHQe/2UQIFMEsAQiQros7lcedyeM3m0jPYz7N3ATOdJ75SN9FSomszSCdGhearJJRcgqBtqITaDsVZVgZUtIKbUJ6HmZ3ivKegzRzU8wSAqRk4afvoPPaTQhdw8mXaI5N0BibwK81aNFCNnZ/D7VDxym+vIfS9r3UToyRWHcRZ2uMTlA9dIzjf/Flph55Gum6NE6O45UqgGCWEHQOXUX6h/8DmmkiXY/m2CT10XHcfJFZuo490IMzMU19JMfME8/TGJ2gfmQEv+kCkhZhWcRWr6C4dSf5Z7dS2bUfv9kkvHgBQtOYUzs6wtRDTzP2j/eQf2YrtUPHkK6HVywzx+jsoOPqjfRkbqYltKCfwvPbqB48BlJyiiC0dBF+rc7M48+R/7fnkb7EiEUw4jHmSNdj4p4HGb/7AWYee5bC01vQbBtnagY8nxYtFiG6chk9H3kfRjLOfGqHjlF+eRcjf/4Fpr71OHokRPWVg/j1BiAAQYvV04UWCTPxtfsoPL2F8NJFIAR6OMTZjv+vv2HqXx8i/+Tz1A4cJrH5Ms4mG0VkeRTvlW/gj76ArEwg/SZarJ8LQVbJKDmFQNvRCbSlijKsDClphTYgNA0BhAb78Wp1hK4jDIOFn7mTnvdcg5GI0WLEo5gdCaTn0WJ2p4guXUjl0DHqJ8ao7D1MefcBqgeP4VXrJDddQotXrVHc/gqHfud/U9iyg/rhE5R27MPsTBJetADpeVjdnXTddh2Dd92B2ZFA6DqaYRBaNACOixay8Wt1Ypesws2XqR8fpbL7ANV9h3GmC+iREKEFfdgDveiRMNGLl1HedYDKrv3UDhyltG0PbrGMZluEly1CCEEjN8mJv/oyk//6CMUt26keOEr96AhmKkli4yU0x6dJXL6O1PVXsPSXP8vZut93I82T42ghG79SJbF5A85MgdKW7dQOHKGy5wC1Q8dA14msWIIWspGez+gXvsb41x9g5uGnqO47RP3YCH61Tse1m5CeT3j5EmJrVrH48z9JeOlC5uPki+SfeI4j/9cfU962m9r+I5S37SY0OIC9MI0IWeihEPbCNNJxmHnkaWr7DlHZvZ/iCy/RcdM1mMkEQtNoOfRrv8fo336FyvbdVHfvo7b/MPVjI6RuuY4W6TnIwnHcXf+EHNuKLJ1ETu0B30WYUUS0l3aWVTJKTiHQlnQCbauiDCtDSlqhDejhEFZ3J93vuYaOyy+h9/Yb6bz+csxknLPZfV1EL1pGz63X0nPbtbjVOuXdB/FKFeZ4lSq+6xJfswKzM4nfdDjyh39Leed+5ggp8ao1Bj9zJwOf/CA977+Bvg/fipGMoZkmc/RwiNjqFaSuv5yuoaux072Utu3BmcyD9Gnxa3XMzg4GPp5hwV130HP7TVReOUTp5T2crX58FKu3m8SGNWi2Re3AEXJfu5/awWOcIZG+z+Cn72TBp++k+/ab6Ll9iHPpvOVaEpevoztzM5ptM/XtJ8DzmeNM5cHzSd10FUY8SmM0x/jXH6Dw1IucJsGvN0jdci1LfuWn6f7ALaTecx2hRWnmI6WkmZvk8G/+EY0ToyAlszwf6fss/Y2fo+ejt9N5241ohsHMw/8GnscsCc7kNH65SuqWaxGGQf7J5zj5l1/EnSkAghavUkW6LpGVS7AXDCAEuK/cjRzfBoLTZGkEER9EJBcjNIN2lFUySk4h0LY0Am0tp2SUrEKb0CMhNNsiumoJ0ZWL0UyDc7F7OrH6urD6utEjYZx8kdeqHxnBq9ZocfJFnEIZBKdJQLoezYlpoquWEFu9AjQNzTB4LT0axuxKEb14OXZvN87kDEgJCOY0J6aQQGjhAGZvFxJF8CrBnPrxUbxyhZb6iVGa41MgOItA6Dp6Ik50zUpCgwOcT3jpQiKrloEQCCE4RTCnMTZOMzdJi5svUjt6glMEpwnQI2FCSxdipfuwujs5Lylx8wW8SpVZQjDHbzRojk0SXbuKyMql1I4cR3o+swSvEnilMn6jiZQSt1yhOT7JGYKW+vERnJkCEpBOHZpFThOCObKSA69JO8oqGSWnEGhrGoG2l1MySlahTQgheCOEEEjXI7J8IaGBHkBwNntBH1Z/D+XdB6nsPYwRCYGug+A0YRgYyTh6JEyLEIL5CCGQvsTsShFbs5IzBC2aZRJalKa4bQ/1IyPIposeiYDgVQI0Ha9SBV2ntG0PwjRxZoqAAMFpoYVphGkihOCN0CwTPWRjpJKcIUAI3JkCbrlM6eVdGB0JpOchBa8StFh9PRiJGNJxEULweoSmgZSYnUlOEwKEAB+MjgSaaWJ2dhBamOYUwSwBWiSE2ddDKbuD8vY9WL3dhJYt5t8TmKkU4VXLKG/djswfAWEgNJPThABNR5gRhBWj3WSVjJJTCLQ9ncAFoaIMK0NKWuECInQdv9GkMTaBM1PAq9Zp0WMR7L4ucvc8zOQDT1IfGaOZm0I2miA08D1aum69lsEf+xhayEYIwesRQiAMnWZukubkDG6+CAI028ZO91F8YRvTDz1FYct2vEoNN18EIZCeR4tmW4QWpZm8/zHGhx+mfvwkQhO4hTLoGkiJ2ZOi49pNpH/4w7wZsbUrKb28m8aJUaTrga6DBHtwgNrBo+S++k3y/7YFIxbDmZxBei4CMDoShFcsIf2ZT2B1pXij7IFe3JkipZd3IX0JQoCU9P3wR+j7xIcQlgmej9mVojEyRv3ICUCgRcJYA700jp+ksn03E9/4FjOPPo0ei+JVq8hGkxYtGiG0KM3kPQ/in3ieWN8kwimDW0OggfRoET1rMNZ8HGGEQQjaRVbJKDmFwAVBELig9Cn3KZsULjCl3QcoPL+N8iuHEKaBHg4z/q+P4DeazLEHerD7urH6u5GNJuFlC+m/431YqSSabfFmONN5Jr/9FJX9h2mOTRBeupCJBx7HGZ9ijtnZgdXbTXhxGgwdr1wBCcWtO/GKZebYC/pJbFhNc2yS0JIFhBalGfyPn+CtOvqHf00jN0EzN4keDlPZvZ/GyTHm6PEYqeuvwG800aNhrO5Oen8gQ2TFEt6KsX/8BqXsDpyZAsmrN9L9wVuxersQuk6LW6pQP3SUyX99mNrhY1h9PZRe3Eb9yHH8WoNTJFokTN8nP4ybL+DX6tiL0uT+6R78apnOTQkWf2IALdGFCHVCtBfhe2An0FfcDlYMYYRoF1klo+QUAhcMQeCC06fcp2xSuMC45SqaZSJ9nwO/9edM3Pc4r9Vz+40M3vUxrJ4uzGQM6fsITeOt8BtNhKHjVWqM3/MQh//gr8HzAcmc2KWrWfy5HyW+fjXN8SkO/PofUXxhO6dIWoShs+hzP0ZP5maMVALdtnm7vEaD5tgEo1/8BqP/cDdIFMmcrvfeyPLf/jyabSEdByMe4+1wZgpIz8Pq7kRKiRCCs0nXRRgGTr5I7cBhjv7PP6X04jZmSWYJyyT9Ez/Ewp/9DC3H/p+/4ORffhGhw8D7euh/bzeaIRC9l6Jf9BFEYiFCt5DSRwiNdpFVMkpOIXBB0QhccHJKRskqXGD0SAhh6GiGgTANQPBaznQBIxbBTMZoEZrGWyUsEzQNLRxCWCb4klMEc7xSCaREsy2k5yEdFwSvErRIKZGej9mRQLdtzkdKid9oIqXkfHTbxkjE8RtNkLxKcJqU4PtotoUeCfN2GfEYRjJBixCC1xKGQYvZkUCPRGiOTwKCWYJZ0nERuo4wDIRhICyTFimZpRkas5pl0C2EbtEihEa7yCoZJacQuODoBC5IFWVYGVLSCheA5nQeN19m5sktlLbvRY+GKe/ej2y6nK3rPdfQdcvVCCF4O7xqDSdfZPrx56geOIpfrVI/PopbKHGKoEUL2XQNXU3xxR04kzMUX9yJO1MAKTlFEBocoOOajcTXr+Z8GqPjFLM7qR05TmN0HDOZQAvZzEcPhyhtf4Xy7n1Ix+UUgdGRJLQwjRBQ2bUfzbKQvo8ejfBWlLfvobpnP/UjJ2iOTxIaHGA+UkqMVJLa3oNUdu0DBLMEGB0Jeu74AKWtO6ju2ocwTSq79+GXq7hVj471cfSQjta1Gn3JEAhBO8kqGSWnELggCQIXtD7lPmWTQhtrTs6Qf3EHI/9wD/XjYwhNA0PH7u2iOTmNM5VHaDpd77maJZ/7FHZfN0LTeKu8eoPiS7sZ/ad7Kb64gxah65idSfxGk8ZIDmGZaJZFaLAfr16jeXICq78HkDjTBYSm4RaK2AO9dFx/BSv++89wPqUde5n45qPkvn4/mmkiXZcFn76T3g/fhj3Qy/ns+U//jcJzL+EVy1h93ejRCG6xhDB03HyRyKpldL3nOno+8l7s/h7ejInhB5m6/1EKz2RB0wgtHKDnY7eTvutO5uM3mpS37WbkL7/IzGNPgycxuzowe7txpmbwKzUQIEwDq68Ht1DEMAos/4+LCV20HmPdjyAiPaDptIusklFyCoELliBwwetT7lM2KbQh6fnUTozyyi/9PtUDR0ByWnjpApb8zKeoHT6BEY/Rfes1aLaFZlu8VVJKvHKVg7/1Z0w+8ARIyRw9Embwsz+I0AR+o4lXKpO752HcmTxzzM4ksbUXkdx8KQiB1Z2i5wM3cz5evcHol+7h6O//H86QtKz8nV+m98O38XrG/vmbeKUymm0x9s/fpHbwGNJ1mBNdvYLFv/gTJK/ZhGYYvBG1g8c4/id/x9T9jyAdj1maRnj5Ipb++s/Scd0VzMerVHGn80w/9gxeqUJ4+SKO/OYf0xgZBcmrJFZfD4t/9WfQ9SLJdSm0wWtBaAgjRLvIKhklpxC4oGkELng5JaNkFdqSJP/cNmrHTgICBKf59SZ6JMyCT32Y/o/dhh6PotkWb4cQgsq+wxRf3MksIThN19Asg4Ef/BDpH/kwznQBN18ABHOc6QLCNum67ToW/NjH6PnAzbwet1Bk5okXQNM4QyBMk/xzL+GWKrye/o9/gPSnP0584yXokTDSdQHBnMreQ5S27UEzDN4IKSVetUrx+ZeQrgeCU3yfxokxnIkppOsxHz0awVrQz8Cn7mDBZ38E2WjiTBeYJXiVQHoewtBJfeAO9KW3IowwwgjRLrJKRskpBC54GoF3hJySUbIKbUboOgiBYI4AwWnScfEbDrOkZD5uqYxXrTMf6Xm0uKUKsung1eqAYJYQtAhNIB0XoWv4jSZaOASSVwnm6CEbv95ESonfdHg9QtOQTQcEIDhDCKTjgOB1+Y0mLX69gTANzhDM8n2EruFVqrT4jSbnJUGPRdEiYUAwSzBLC9lotoVbKuOWKsxHaBotQtcQlgVIQDBLcIqmIUwToWnMEoJ2kVUySk4h8I6gE3jHqCjDypCSVmgT0vexulOUdu6jMTbJKQIEWN0pwovSTD70NKWd+4gsW4j0fTTL5Gy5ex9h+rHnKW7bQ2N0gtjFyzibW6nRODHG2Ne/xfQTL+DXGzRykzhTeUAwSwiEbpDYtI7pR5+l8Pw2/Fqd5sQ0fq3OKQKzuxMEeNUaM09uoX50hNCiAfRwiHnpOkITzDy5BaQEwSwhBIs/dxfRi5ZzPs2pGUb/4V+YfvhpvGKZ4pbteJUq+D6nCKy+HsJLFzLz5PMUn38JEGiWiRGPcS5CCNxCkebJHPWjI0jHpUVYBqHBNM50nsqeg1R37cOZnCayahnzkb7E6ExSO3iU2oEjgGCWgMRVG1n4X+5CGAbtJKtklJxC4B1DJ/COUlGGlSElrdAGhBBI1yeU7sEplHBLZfRICLOzA2EaTD36LMWtuym8tIfynoOkrtmAHgkhNI2WY//nqxz7sy9RfGk3xewuKnsP4+SLdGy+lBbfcansPczRP/sSubu/TXnnPopbdqCHQ5ipBEgwOhIYiRhmVwf5Z7ZSeO5lyrv2Uz10jNDCAex0L26xRGTVUhCC+pETlLbtoZjdQeWVg1T2HKTj6svQQzbnohkGwjIxu1NU9x/F7Eyh2RZLPv8TJK/cgB6NMJ/m1Ax7PvurTD38NMUt2yjv3Icei6KFbKzuTmSzSWTVMjTLZOaJ5ym/vIvS1p1U9hwATSO8dCF6OMS5mB1JhGkgXQ+vXMGIxwmvWEL98HFqh49Tev4lSlt3UtmxB6EbxNav5lyEELRYvV34jSbNiSn0SITkdZtZ/Ms/jZFMoJkG7SKrZJScQuAdRSfwjlNRhpUhJa3QBvSQjdnZQc9t1xFfu4KOqzZg9/cw8+SL+LU6s6SkcXIcv+nQdeNmWvIv7uTYX34ZZ7oAvqTFK1fx603CSxZgD/QggJEvfIOJ+x7nNCnxKjUGfvBD9H3sNrpuvZbEhtXMPJ3FmZhmlpTg+QjDYNmvfJbu264jsX415V37aeamkI5Di1+r4zeaGPEYsdXLEZrGuVhdKSLLF5G68Uq633c9vR++leTm9ZgdCebjNx2O/8WXmHnyBfxqDYTAbzSQrkvqhitJf+qjdGeGSF65nonhh/DLVUDS4kzn8RtNUtdvxkjEEEJwLuElC4msXErnbdfTffsQfqNJdd8hvEKRWZ6PW67g1+rELrkIs7uTc9FME7Oni9TN1xK/7BK6b7+ZwZ/+UfREDD0col1klYySUwi842gE3pFySkbJKrQJIxZBC9ukrr6Mjqs2UDsygl9vAAIEpzVGJ2hOziClxCtXcYtlXqt2dASvUgMpaU4XqOw/CoLTJCA9j/rxUZKXr6Pjqg040wWaEzPMEoI5mmWiWSYd124ismop0vWQngcI5jQnpmhOTCFdDykl8zE7O4ivu4jY6pXELl6BHgkzHyklXq2OM5XHr9U5TQi8cpXm5DSJK9bTcd0VeOUa+D6nCOZU9x2idvAoQtOQUjKf8LJFRNesInLRcuz+HpzpPLMEp3g+taMj+E0HKSXz0cMh9HiU1I1X0XHDlaBr6KEQ7SKrZJScQuAdSSPwjpVTMkpWoU0IIWgxomHMZIwzBAgQpo7VnaI+kqM+ksPu68JMJQDB2fRoBKu/m9rRkzTHJjGiYYRpguAMQ0ePhtHCIYSmYSTjyKYDCGYJQYvV24WwTVo0y8Qe6OUMQYt0PczOJPXjo7jFMl6tzvkIQ+d8vEoNt1Cicfwkdl8XSP5/7IFehGmApqFFQhipJGcIQIDn41Vr1EfGwPdxyxXmIzQNhMDq68FMJQHBLMEsIxnHSvfRODFKY2SM+QghmCOEoF1klYySUwi8Y+kE3tEqyrAypKQV2oTvuNi9XVT2HqY5Pk2L0A2sgR7cYpnyK4eY+vZTzDz3MkYsijOdR7o+LcI0iCwdpPjiTsa/+RjVg0dpTszgFcvgA9KnJbJ8MUt+7i7MVIIWMxHHLZap7D0MQtBi9nTSceV6+j/6XoQQCE2nMTZBc2Iad6bIKQJ7sB9npsDENx+h+MI2KnsPE1uzAj0c4s1qTs5w5Pf+kvF7HmLqwSdp5KYQmo5XLDEntn413e+9gehFS9EMg8iyRRS3bKdxYhTpeiAELVZvFy2jX7ibwrNZ/HoDI5XESMQ4F6HreJUqzbEJmqPjyKZLi7AtoiuXMnX/o0ze+xDlbXvwylVia1dxIcgqGSWnEHhH0wm841WUYWVISSu0AaFroAliFy9HOg6abZNYtwq3UKI+Mk7t6AiN0QkaoxM4+SK9H7gJIxnD6ukkufESStv2UD10HGcqT+3ICMLQMVNJYquXY/d2EVu9nGWf/wxWTxd6OIQQAj0cwurrwkjG8asN4pdeTOf1m1jy859mjmYaRJYOghAYyThCEyQ3r8eZzlPZuQ9ncobakRFqx05SO3SCjqsvQ7Mt3ihnpsjen/kNZp56kfrh4zTHp2iezGH3d9Nx3WaQko7rLqfn/TfRefM16NEIc7pvvwlnOo+RjGMk44QWppGeR+GZrTjjk9QOHKV+7CRGPEp42SI02+JcrL5ujFgUIx5HGBqhpYtIXLGemcefpX74OM2xCeqHj1HdexA9HiW6ZiXtLKtklJxC4B1PEHjX6FPuUzYptAm/0USzLeojOWrHRjn+N1+n+PIekD5IZgnTJP3JDIt+6hN4lRojX7yXkb+/m9fqvGkzA3feTnTVUvRICGEYaKbB2aTvI32f+vExjFgUqyfFuXi1OkLTaIxNUHnlEPt+6XeRngdI5kQvWs7iX/g0HVdfhhCC1yN9n9zd3+L4n/4DzdwkpwkwUwlW/cGvYQ/0Yqd7kb5ED9mcSyM3iTM1Q2nrTg7/33+ObDqAZE7nLdey8g9+DT0SRgjBfJqT07TosSiHfvX3mPjGt5glmSVMg56PvJdFv/CTWL1dtKOsklFyCoF3BY3Au0ZOyShZhTah2RYtoQV92H1dOIUSSAkIEMySrotmW4DATCZAAELwWo2xKey+bszOJHo4hGYavJbQNDTDILJ0EKsnxXz0cAhhmYQG+wGJHotwimBOc2oav1anRfo+5yN9H+n5eOUKbqkCgjMkaHYIPRwitHAAYZroIZv52H3dhJcM0hyfQroupwjmNMYmcGeKCCE4H6u7E7MrhXRdpJSAYJZglnRcnIlpELSlrJJRcgqBdw2NwLtKTskoWYU2IqUkvDhNZOkgZwgQYHYmia1ejhAC6bpEly/C6u8GBP+OACklhee3Udq5n7fDmSlQ3LqT4rY9SMfFHujhDEGLV67iV+vkn85S3XcYt1ThXNxiifKOvRSeewk9HEI6LiBAcJqV7sWr1im+vIvSy7vxqjXOR4+EMbtSGIk4Zwg028bu70FogjdCCAFSEr1oOXoiBghmCWZZC/qxerpoN1klo+QUAu8qOoF3nYoyrAwpaYU2IITAbzpY3SlqR0dpTkzTYqaSdN92HR1XrMPu7UIYOi3N3CRusYxXqYGmo9kWoXQPk99+itF/vp/yrv00x6dIXrGON6u0ax+j/3w/R//478k/+SL5Z7aCEAjTwK/WELoOmoad7qN66BijXxqm+NIuyjv3kdh4CXo4xJzm5DT7f+X3Gb/nIcb/5ds0xibQbAu3VAGhARKjM4mm60w+8DjTDz/D+PCDICWhBf0Y8RjziW9YQzG7g+b4FNJx0KMRrP4e0j/+cRKXreWN0mwL6bo4UzM4k9P4jSboOomrNrLkv/4n9GgYoWm0i6ySUXIKgXcdQeBdq0+5T9mk0Caa0wXcfInxB57Aq9RIXHoR4cVpYquXc7by3kNU9h+l8sohpOPiN5tMPvQMXqXKHLu/m8G77mDgzvfzRnnVGiNf+AbH/+IfmSUlLcI0GPjB/4DQBX7TwSuWKLy4k8bIGHOMZJzOoatZ9qs/jR4O4ZbKvPK5/0Fxyw6k5zInvHSQ1PWbka6LsC38ep3cV+9HOi6nSFqW/8bP0v+JD/J6TvzVl3EmpzE7O4iuXk7qxqt4K4pbtlPdd4jagSMYHQn6fujDaLaNEY/SLrJKRskpBN6VdALvWhVlWBlS0gptQA+HMOJRUletJ7lxDeGlg4QGengtqztFeHCAzus2kdi4lslvP0Vl32HO5pWrRJYNEluzAj1k80bUj49x5A//Fq9c5WxayCK2ZgWL/8uPEl+3ivrJHNOPPMvZ/EYTszNJ4vJ1GIkY5R17mXroaZyJaUAwxy2W6bvj/Qx84oN0XLmBiW8+Ru3QMfAlpwjQdbxyhdR1l6NHI5xPYtM6kps3EF27kuiqZbxV9oI+wssXk7z2CjquvwItZKOHbNpFVskoOYXAu5ZG4F0tp2SUrEKbEIZOix4OoYds5qNHQghdByHwGg1A8Fp+vYlsOkgpeUOkRA+HQHKKEMySEs0ykb6Pnojh1xuga5wimOPVG0jfZ5YP0nFB8CpBi2aZSNfDSMbxHReha0gJCM6QoNk2CMEbodkWRjzGfKTnM8d3XOajR8PokRAtQtNoF1klo+QUAu9qOoF3vYoyrAwpaYULjF9v0BidoHbsJH61wRyrrwsjGUM2HIrb99LMTRJZtoj5SCnRQzb1sQnK2/cCgllC0LLwJz5BZOkgSIkzXaB27CTO5AynCPR4DLu/G7/WoLxrH/UTOcrbX8Gr1kFKThEkNq6lOzOE1duF0HWk4zD96LMgJQhOkZK+O95P6obNvF1OvoibL5D72v2UsjsQmga6hhGLcCHIKhklpxB419MJBJSKMqwMKWmFC4hmW+iRMG6hhFdv4NUaRBYvQDou1cPHKby4k+nHnqO0+wDuTJGOzZdyLkIIhKajR8JIz6cxkkOPhNFsi6W/+BkSG9eiR8MITcPq7cKZyiMdB7dQwhroxUwlqR0+QXnHK0w/9hy1YyNohoFmmuixCNL3SWy6hM5brqHjmk3oIRuh66BpmF0pKnsOooVDaJZJ/50Z+u54P3o8hhCCt8otVylv28Ph3/4Tcl+7j/xTW6js3g+uR2jxAvRohHaWVTJKTiEQUASBwFn6lPuUTQoXmOrhE3i1OrVDx3FLFUa/+gC1oyMgJXMiKxaz+Kd/iK6hK5mP73o4kzMUt+1BaAKrp4vIsoUYiRhncwol6kdHqB46htmR5MTffo3yzn3IZpM5Vk8Xyc2X0vWea/EqVaKrV2Iv6MWIRTlbY2yC+rGTODMFhKaRvHIDejSC0DXeKiklfr3BK//518k/+QIgmRNbdzErfvvzRFYuRRg67SirZJScQiDwKp1A4CwVZVgZUtIKFxAzlcBMJYmuWoJmW0w9/AxuvsjZ3HKVjqs3EFk6iNB1zkVoGno0TGT5IsILB7DTfeghm9fSQzZWdyfR1cvRLINidge1A8cAwRyvWiNx+Tr6PvJe4hvWYHYm0W2b1zJiUex0H+FFaaKrliIsE6FpvB1CCIpbtpH78r14lRogmNOcmCK6ZgXxS1fTjrJKRskpBAJn0QgEXiOnZJSswgXGK1Xwmy6aZSJ0HRCcTQCaaSI0jfOSEnwft1zFbzSZj+84+I0m0vXQLAsErxLMEgLNMtHCNi1C05iPEALNsmgRQjAft1yhOTmNlJLXo4VDGKkkZwhaNNtCs0zaUVbJKDmFQOA1dAKBc6gow8qQkla4AOS3bOfE393N1KPPkX/2JfRIiObENNL1mNP1nmvpvP5y7L5u5iNdj/F7H2X8m48y9uX7cAslpOcRSvdxtubUDMf//B+ZevApph55Bun7eKUKfrXOKYL4htV033Y94eWLEJrG23Xir7/CxD0PM37Pg+C6WN2d6NEI87EHeim9vJv64eNIz+MUQfKaTSz63I8jDB0hBO0iq2SUnEIgcA46gcA8KsqwMqSkFdpY/vlt7PnF36V68DiVvUeoHRnBmcrTee1GtEgIYZp033YdXddfTuqqDcxH+j6j/3wfY1//FtOPPU9jbJLi1l3guJhdHdj9PbQ4MwX2/vz/ZObx56nsPkD9+CiNkTHCyxYRXrIAoeskNq6l+7br6Ry6Cj0c4u069Ft/yskv3E155z6aJ8eZfuRpjGSc2NpVaKbBfLpuvZ7GiTGEaaDHIiSvuoylv/ST6LEommXSLrJKRskpBALz0AkEzqOiDCtDSlqhDTWnZjj6Z/9E7dgostnkNCmJrljMxb/zC6Su2kDndZtIXHoR85FS0hyfYvzeR8k/9zKzpATPp3pkhMTllxBeMoiUPqNfupfpJ1/Aq9Q4TUo022LFb36Ozhs30/fhW4mtWYkRi/B2TT/+HKNfvhdnYoZZUgKC8vZX6Lj6Mux0H+fTecu1xC+9mM6hq0l/6qPo8Rh6yKZdZJWMklMIBM5DIxB4HTklo2QV2pAwTXzPQzYdQIBglnQ9tHAI6XpEL16G3dfFfKSUCCHwag1Kuw6A4DTJKZU9BwGJdD28egOvVGWWEMySErMjjmaaxC+9GCOVRI+EOB8pJa9Huh7S83EmZ0Dw72jhMG6xgpSS1xO9eAXx9WsQuo5mmbSLrJJRcgqBwOvQCATegJySUbIKbURKiRENY6YSnCFAAALCg/1oIRshBPORnk9zMk95z0EaoxNY3SnQdRCcZnQkCA32AwLNMrG6O5BSAoJZQoAQGMkEXq1O7dBxmuNT+I0m59IYHaey9xDN0Qm8So3z0jXMVAKh64AAwWl6JITV10XllYNU9h3Cd1wuJFklo+QUAoE3QCcQeIMqyrAypKQV2oAQAul6WF0d1I6M0Byf5hRB1y1X03XjFUSWDDIf6Xqc/Mp9jN39LY79+T/RGJugOTGNV64iNA2kj9ERJzTYz4If/QhWZ5IWIxrBr9ao7D0MCFrMVBIJTH7rCWae2MLkA09gdXdippLo4RBzJr/9b+S+ej/H/uyLFF/aRWnHPhLrL0YPhzgXIQRC19HDIYovbgdfggAtEsLq72H68eeYfOBxcl97ACHA7u/BiMdod1klo+QUAoE3SCcQeBMqyrAypKQV2oDQdfSQTXzdRbSE0r303HoNnddfTuqay5iP9H3Gv/k4uW88RGHLdqTjUh/JoVkmoYEeUtddTnhxmuTm9Sz6yU8QWTJIixACIxHDXtCH1dWB1Z0iunYFVk8npZd2484UcSancSZnKG7dRfKKS7HTvbQUtmxn7Cv3Mf3os3iVKo2TOeonRmmMjJO8+jI0y+Rc9GgEIxEndskqhKYRWbmU1A2byT+1hcaJMdzpAn61Rv7pLHa6l9i6ixGaoF1llYySUwgE3gSdQOBNqijDypCSVmgDetjGTCXounEzicvWkLx8LdEVi5mPlBLpekw+9DRTjzzD2bxqjc4brqD/jvfR/9H3klh/MXZ/N2cTmobZ1UFi41oS61fTceV6cnc/SHN8CqRkju+6+PUGHddsRGga5d0HOPmFf0E6LnNk00GPhIlvWIPZ1YEQgnMxuzoIL11I8uqN9H7oPcw8+QKll/aA73Oa0GiM5EhddzlmKkk7yioZJacQCLxJGoHAW5BTMkpWoU1opoHQBHZvJ0Y0wvkIIZC+pD6SA13ntRq5Sez+bvSQjRGPci5C09BMA7MnhfR9jHgUpGSWELRIz0cL2UjXAyFonBwHTXCKYE5jbAJ8DyEE0vOZj7BMrO4UXr2OZpkgJQjOkBIjEUPoGu0oq2SUnEIg8BboBAJvUUUZVoaUtMIFRrouzkyB6v4jeJU6c4xkjOiqpUjHpXZ0hObENOGFA7xWcypP7egI+ee24RXLVA8eo3b4BCCYJQRISe8HbyF5xaUgJV61TmX/EZzxaU4RCMsiumIxwtBpjORo5CYxO5NotsXZ3FIZv1xl6uGnqR0dwStVKG7dCb4EwWnJKzfQd8fttJusklFyCoHAW6QTCLwNFWVYGVLSChcQzTDQLIPm+BRuuYrfcLC6O9EjIWqHT1B6+RVyww9T3n0AZ7pAxxXrmFMfHWfywac4/Lt/xczTWSYeeAK/3kAP2UjXA8NAM03677yd3g/dgh6PIjQNIxmnOTqO33RwC0X0aAQ73UtzbJLSjr1M3PswlT0HKO3cR3LzpejhEC1usUzxpV0c+d2/Inf3A0ze9zjO1Ax6NIJXqyN0Ay1kkbjiUhZ/7i70RBSh67SLrJJRcgqBwNugEwi8TRVlWBlS0goXEKu7k/CiNMnL1xJeNEDq2o1U9h2lMTqOV6rQ4uaLNMen0aNhYhctQ/o+lVcOcvj3/5rmxDR+vQGej1epkbpuE123XkPn9ZfTdfPV9H30VqyeLoSm0aKHbGJrVxJZOkhk6UK6b7+J+rGT1E+M4RVKtLj5Is50Hq9aJ7lxLeg6frXG4d/93xRf2I5sOrS4+SJ2upcFP/4DJC5fR8dVG1j8ubswO5LoIZt2kVUySk4hEHibdAKB74CKMqwMKWmFC4jV1YHd30Py8kvQbIviiztpjOQ4m1sqk7xsDdGLloIvGfniMOWd+5GuxxwhJV6twZKfv4vkxrXE1q1CD4cQmsbZ9JBNaLCfxGVrMZNx6sdOUtq6GxDM8esN7AV9pK7dhGZbTD3yDBP3PoxfbwCCOc50gYGPf4Du228iecV6tJCNZpm0i6ySUXIKgcB3gEYg8B2SUzJKVuECo1kmQtMwYlG8Wh0QnE0YBm65inRc/KaD3dcNmgaC0yRgdXcgHQcEICVCCM5F6DpC1zEScbxaAzTBKYJZAtxCCaFr+PUGejSCFrJB8CpBi5lKInQdPRyiRQhBu8gqGSWnEAh8h+gEAt9BFWVYGVLSChcYv9GkMT5F/WQOv9pgjt3bRWhRmokHnqR2dITKviPUT4wifR+QzLH6utEMndGv3I9XruA3Hez+Hs7HK1WonxjFmcpzikCPRkhsXEvh2a2UXt5Ndf9R6sdO4tcbIH1OEXRctYEFn/k4aBpCCNpFVskoOYVA4DtIJxD4Dqsow8qQkla4gOiREEYihlep4TcaaJZJeNECpOuQf2E7tSMnKGzZgVevo0fC2L1dCNPEiEexujpw8kWmH3+B+rGTzDydxavUMDuThNK9nIvQdez+bpyZAkLTkJ6H2ZUitHCAwpYdlF7eQ+ml3ThTM+jhEHosipGIo8fCJDauZfHP/ThmIoZmGrSLrJJRcgqBwHeYIBD4LulT7lM2KVxgasdHQUqqh44jPZ/9//3/xatUOVt83So6b7iCjis3UDt+kvKOvZz86v3g+rQIQFgmS3/x0/R95DY0y2Q+bqlCY2yC+olRwosXsPfzv0N172FAMsdO99H93hvouH4TXqVG6uqNIASabdEuskpGySkEAt8FGoHAd0lOyShZhQtMeOEAoYUDdN64Ga9WR4+EeK3KgaPE1qwgtmY5HZvXU9y2F3zJHIni+8w8vRXpOJyPEY8SWbGYzpuuwqvW0QyDUwRzGidz6LEIyU3r6Bq6Gi1ko9kW7SKrZJScQiDwXaIRCHwX5ZSMklW4gPiNJs5UnsbJcUKD/QjLAgRn08MhpOcjdJ2W0MIBhG6A4DRhW8QuWgqaxusRQiCEwOruxOxMcoagReg6QhMIXafdZJWMklMIBL6LdAKB77KKMqwMKWmFNlc7PsrMMy9x+Pf/hvxz25h5KouUPrLhIB0XELQM/MD76fvQLQhDx4iG8V2XqYefQegaSIkWsjA7O+j/gfcRXb6IN0pogub4FM5MHme6wCyh0XHVZSz+2R9Hsy2EELSLrJJRcgqBwHeZTiDwPVBRhpUhJa3Qprxqjemnsxz9ky9SPzFG/USOZm4K6Xr0vP8GtJBFeFGa3g8M0fehmzE7OxCaRkt05RJCg/1I18NIxklsXEv6kx+k66YreTM00ySyfBEg0MIhrP5u4usuYvHP3oWZjKNZJu0iq2SUnEIg8D0gCAS+h/qU+5RNCm2oMTbBzv/8P6gdOQFSgmSWFg7R96GbWfRTn8SZLhAa7EfoGkIIXqt+YgwtEsZvNAkN9PBWebU6XrWGWygTXpymReg67SKrZJScQiDwPaITCHwPVZRhZUhJK7SZxtgk+Wdfpjk+DQgQvEqSum4TyfUXY/d2IjQNIQTnYiRi6OEQRjzK26GZBnokjJlKIjQNoWm0i6ySUXIKgcD3kE4g8D1WUYaVISWt0Eb0cIiZZ7dROzrCKQIECNMgumwhRjJG7fAJ7N4upO8jdJ03y6vU8Gt18lt24OSLSNfFSMS4UGSVjJJTCAS+x3QCge+DijKsDClphTYhPQ8jHqUxNoEzXaBF6DpmRwLfcRj5u29Q3LqLQnYX4aULMJNxhK7zRrnFMoUtOzjyx3/PxL8+xtjXHsCv19Esg9DgAO0uq2SUnEIg8H2gEwh8n1SUYWVISSu0Ac0wMJNxEhvWoJkGiUsvIjTYj99wKO3aj3Rc3FKF2tGTNMen6L7lGjTT4I2QUuJM5znyx39PYcsO3HIFXI/KviPo8SiRFYsxYhHaVVbJKDmFQOD7RCcQ+D6qKMPKkJJWaAN6yMZMJUldvYHY2pWYyRgnv3IfuB4ITvMbDqF0H9Hli3ijcv/yIJMPPoVsOpzm+9QOHqf7vddjdadoR1klo+QUAoHvI41A4Pssp2SUrEKbELqG0DTMZAxnpogRj3KKAMEs6TiYqQS+49AipeRcpJS0+LUGZioJCBCcJgG7vxvZbNKOskpGySkEAt9nOoFAG6gow8qQklZoI2ZnB8WXdtE4Oc4pAmFbRFYsws0XqZ+coPDCNiJLF9KimQZznEKJ5vgUo1/+JrWjJylt30NjdBy/0QQkc5Ib1zLwyQ8idI12klUySk4hEGgDOoFAm6gow8qQklZoE9L3MZNxnOkCXq2OFrIJD/bTHJ+ieug4U488S3nXfkq7DxBfuwIzGUdoGl61TmHrTo78r39g8pFnmX78efymA0JgREIITUePRUhuWsuin/pBzFQSoeu0i6ySUXIKgUCb0AkE2khFGVaGlLRCG9AsE6unk84brsDu7aI3cyPOVJ7a0RHcfJEW6bjUR8Zwi2W6b74KoWn49QZH/ujvKby4A+m6tLj5EnZfN53XbWLgkx8ksf5iFn32E5hdHei2RbvIKhklpxAItBGdQKDNVJRhZUhJK7QBzbYwomHia1ZgdXdSPzHGzFNbAQGC04xknPglq7A6kxSyO5n49lO4hRJnc6YL9N/5frrfcw3xtSvRLAvNMGgXWSWj5BQCgTajEQi0oZySUbIKbUaPhHBLZYRlcooAAQjwa3XMZIzmxDT2QC9CCEBwNj0exavW0QyDdpNVMkpOIRBoQzqBQJuqKMPKkJJW/kIyGPsAAASMSURBVL/24GfHz6oA4/jzvmd+nXbqOIVBSk4iFYkRg7iw6MaNZ32uQEm8gG68B+/BK/AKzoKlC1csyFkYQzQSo7BATxBhCqdYp53xa6sklZbOTAu8f57PRxOy/fS++h/+rJt/+7vuGjTuXNBXvvNN/eM3r+ugvqH3fv2aws55HX5wXceHt/U/ey+/pCvXXtGw2dIwDJqKiowGmU1UkNmEdRQkRGgChmHQEEadj5d168OPFHbOa7O3q53nvq7rv/29bvzpbd34419086/v6vDgQ136wfc0bAVtP/M17b70gq5c+4k2T+5p3GxpKioyGmQ2YYPMZuAyXsVVaCJu//Omjo+OdOPNt3TuqSf05i9+qYP6hnR8JB3rjmGzpf0f/1Df+PnPdPjeB7r4wvPSII1bW5qKiowGmU1ckNkMdBQkRGgCxq0tjZuNtp95SofXP9LB67/Tx2+9I2mQBt11dKSvXn1RT/zo+7rwbNQQRg3jqKmoyGiQ2QyMMpuJhowKTcz2009q3D4nDYPuGqRBGjZbGjcbbfZ2NTUVGQ0ym4kgsxnpKEiI0EQc3z7SZv+SPn77Hf3r3fel42MNIWjv5e/qyrWfKuxe1DAMmoqKjAaZzUiQ2cx0FCREaAKGEBR2Lujit5+Tbh9p5/lntfvit3Tl2is6t39J47mNpqIio0FmMzPIbKYu41VchSbi6NYtSYNuvX+gzf4l/ccwjpqKiowGmc1QkNlMdRQkRGgChnHUMI4KFy9oGAYNw6CpqMhokNlMBZnNWEdBQoTsvioyGmQ2Y0FmM9dRkBAhu0dFRoPMZi7IbAE6ChIiZHdUZDTIbAGCzBaioyAhQitXkdEgs4UIMluQjoKECK1URUaDzBYkyGxhOgoSIrQyFRkNMluYILMF6ihIiNBKVGQ0yGyBgswWqqMgIUILV5HRILOFCjJbsI6ChAgtVEVGg8wWLMhs4ToKEiK0MBUZDTJbuCCzFegoSIjQQlRkNMhsBYLMVqKjICFCM1eR0SCzlQgyW5GOgoQIzVRFRoPMViTIbGU6ChIiNDMVGQ0yW5kgsxXqKEiI0ExUZDTIbIWCzFaqoyAhQhNXkdEgs5UKMluxjoKECE1URUaDzFYsyGzlOgoSIjQxFRkNMlu5IDNTR0FChCaiIqNBZqYgM7ujoyAhQl+yiowGmdkdQWb2iY6ChAh9SSoyGmRmnwgys3t0FCRE6AtWkdEgM7tHkJl9SkdBQoS+IBUZDTKzTwkys/vqKEiI0OesIqNBZnZfQWb2QB0FCRH6nFRkNMjMHijIzD5TR0FChB6ziowGmdlnCjKzh+ooSIjQY1KR0SAze6ggMzuRjoKECD2iiowGmdmJBJnZiXUUJETojCoyGmRmJxZkZqfSUZAQoVOqyGiQmZ1KkJmdWkdBQoROqCKjQWZ2akFmdiYdBQkReoiKjAaZ2ZkEmdmZdRQkROgBKjIaZGZnFmRmj6SjICFC/6cio0Fm9kiCzOyRdRQkROi/KjIaZGaPLMjMHouOgoSIiowGmZmZTdFl/AqXITMzs6kbITMzMzNbr38D2AS8I+ojOkYAAAAASUVORK5CYII='; +benchmark = 'data:image/png;base64,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'; -testModule('rotate', {rotate: 45}, benchmark, image); \ No newline at end of file +testModule('rotate', options, benchmark, image); \ No newline at end of file diff --git a/test/core/sequencer/benchmark.js b/test/core/sequencer/benchmark.js index ee8dfc6a..5e6b0730 100644 --- a/test/core/sequencer/benchmark.js +++ b/test/core/sequencer/benchmark.js @@ -42,19 +42,22 @@ function runBenchmarks(sequencer, t) { function cb() { var end = Date.now(); console.log('Module ' + mods[0] + ' ran in: ' + (end - global.start) + ' milliseconds'); - mods.splice(0, 1); if (mods.length > 1) { // Last one is test module, we need not benchmark it sequencer.steps[global.idx].output.src = image; global.idx++; - if (mods[0] === 'import-image' || (!!sequencer.modulesInfo(mods[0]).requires && sequencer.modulesInfo(mods[0]).requires.includes('webgl'))) { + mods.splice(0, 1); + + while (mods[0] === 'import-image' || mods[0] === 'minify-image' || (!!sequencer.modulesInfo(mods[0]).requires && sequencer.modulesInfo(mods[0]).requires.includes('webgl'))) { /* Not currently working for this module, which is for importing a new image */ - console.log('Bypassing import-image'); + console.log(`Bypassing ${mods[0]}`); mods.splice(0, 1); } + sequencer.addSteps(mods[0]); global.start = Date.now(); sequencer.run({ index: global.idx }, cb); - } else { + } + else { t.end(); } } diff --git a/test/core/templates/module-test.js b/test/core/templates/module-test.js index befe8da1..9e6ab71f 100644 --- a/test/core/templates/module-test.js +++ b/test/core/templates/module-test.js @@ -38,11 +38,11 @@ module.exports = (moduleName, options, benchmark, input) => { sequencer.run({mode: 'test'}, () => { let result = sequencer.steps[1].output.src; - base64Img.imgSync(result, target, 'result'); - base64Img.imgSync(benchmark, target, 'benchmark'); + base64Img.imgSync(result, target, `${moduleName}-result`); + base64Img.imgSync(benchmark, target, `${moduleName}-benchmark`); - result = './test_outputs/result.png'; - benchmark = './test_outputs/benchmark.png'; + result = `./test_outputs/${moduleName}-result.png`; + benchmark = `./test_outputs/${moduleName}-benchmark.png`; looksSame(result, benchmark, function(err, res) { if (err) console.log(err); diff --git a/test/core/util/parse-input.js b/test/core/util/parse-input.js index f8560ab8..3b46b7b8 100644 --- a/test/core/util/parse-input.js +++ b/test/core/util/parse-input.js @@ -1,17 +1,18 @@ var test = require('tape'); -var red = 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAAQABADASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAABgj/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABykX//Z'; - var parseCornerCoordinateInputs = require('../../../src/util/ParseInputCoordinates'); test('parseCornerCoordinateInputs works.', function (t) { - var options = { x: '10%' }, - coord = { src: red, x: { valInp: options.x, type: 'horizontal' } }; + var options = { x: '10%', iw: 10, ih: 10 }, + coord = { x: { valInp: options.x, type: 'horizontal' } }; + callback = function (options, coord) { options.x = parseInt(coord.x.valInp); - t.equal(options.x, 1, 'parseCornerCoordinateInputs works.'); + t.equal(options.x, 1, 'parseCornerCootesrdinateInputs Works.'); + t.equal(typeof options.x, 'number', 'Correct output type'); t.end(); }; + parseCornerCoordinateInputs(options, coord, callback); });