diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f9cf497 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.env +.DS_Store +node_modules +npm-debug.log +browserify diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..3fd76ad --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,9 @@ +The MIT License (MIT) + +Copyright (c) 2017 Tomomi Imura + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..141cb61 --- /dev/null +++ b/README.md @@ -0,0 +1,190 @@ + + +![filterous-2](images/filterous-2.png) + +# Filterous 2 + +Filterous 2 is an Instagram-like image manipulation library for Javascript and node.js. + +This is a revamped version of Filterous, which was written for JavaScript for browser about 4 years ago. +This version works on both Node.js and browser, and comes with pre-defined Instagram-like filters (with the same filter names and very similar effects). + +## Installation + +**For Node.js:** + +first, this module uses node-canvas, so you need **Cairo** and **Pango**. Please follow the [installation guide here](https://github.com/Automattic/node-canvas/wiki/_pages) before started. + +```bash +$ npm install filterous +``` + +**For Browser:** + +```html + +``` + +The minified JavaScript code is available on Release page. + + +## Usage + +The usages are slightly different for Node.js and the browser. + +### Basic Usage for Node.js + +Import an image buffer to `filterous` then `save` to the disk. + +```javascript +const filterous = require('filterous'); + +filterous.importImage(buffer, options) + .applyFilter(filter, value) + .save(filename); +``` + +also: + +```javascript +filterous.importImage(buffer) + .applyInstaFilter(filterName, options) + .save(filename); +``` + +The `applyFilter()` can be used with other filters and the results are accumulative, while +the predefined `applyInstaFilter()` overwrite the previous filter result. +However you can use `applyFilter()` to adjust the colors after `applyInstaFilter()` is applied. + +Options are: + +```javascript +{ + scale: , + format: +} +``` +The value must be less than 1. You can only scale down an image. +and the imageFormat is either 'png', 'gif', or 'jpeg' (default). + +### Example for Node.js + +Using color adjustment filters: + +```javascript +fs.readFile('input/leia.jpg', (err, buffer) => { + if (err) throw err; + let f = filterous.importImage(buffer) + .applyFilter('brightness', 0.2) + .applyFilter('colorFilter', [255, 255, 0, 0.05]) + .save('output/leia.jpg'); +}); +``` + +Example with predefined Instagram-like effects: + +```javascript +fs.readFile('input/leia.jpg', (err, buffer) => { + let f = filterous.importImage(buffer, {scale: 0.5, format: 'png'}) + .applyInstaFilter('amaro') + .save('output/leia.jpg'); +}); + +``` + +### Basic Usage for JavaScript on Browser + +Import an image object to `filterous` and render as HTML with `renderHtml`. + +```javascript +filterous.importImage(imgObj, options) + .applyFilter(filter, value) + .renderHtml(imageDOM); +``` +also: + +```javascript +filterous.importImage(imgObj, options) + .applyInstaFilter(filterName) + .renderHtml(imageDOM); +``` + + +```javascript +var imageDOM = document.querySelector('img.photo'); +var imgObj = new Image(); +imgObj.src = 'input/leia.jpg'; + +filterous.importImage(imgObj, options) + .applyFilter('brightness', 0.2) + .applyFilter('contrast', -0.3) + .renderHtml(imageDOM); +``` +Example with predefined Instagram-like effects: + +```javascript +filterous.importImage(imgObj, options) + .applyInstaFilter(filterButton.id) + .renderHtml(imageDOM); +``` + +## Available Filter Effects and the Values + +Most effects take a value (the amount of the effects) between -1 and 1. +for example, the value for the `brightness()` 0 means unchanged, -1 darkens the image, and 1 means full-brightness. The image will turn almost completely white. + + +| Effect | Adjestment(s) | +| ------------- | ------------------------------- | +| `grayscale` | N/A | +| `sepia` | 0 to 1 | +| `invert` | N/A | +| `brightness` | -1 to 1 | +| `saturation` | -1 to 1 | +| `contrast` | -1 to 1 | +| `rgbAdjust` | [r, g, b] | +| `colorFilter` | [r, g, b, adj] // adj is 0 to 1 | +| `convolute` | 3x3 matrix | + + +## Available InstaFilter Names + +| Names | | | | | | +| -------- | --------- | --------- | ------- | -------- | --------- | +| normal | clarendon | gingham | moon | lark | reyes | +| juno | slumber | crema | ludwig | aden | perpetua | +| amaro | mayfair | rise | hudson | valencia | xpro2 | +| sierra | willow | lofi | inkwell | hefe | nashville | +| stinson | vesper | earlybird | brannan | sutro | toaster | +| walden | 1977 | kelvin | maven | ginza | skyline | +| dogpatch | brooklyn | helena | ashby | charmes | | + +Note: `normal` gives no filter effect. It normalize the image to the original. + +## Demo +[Try the demo on browser!](https://girliemac.github.io/filterous-2/demo-browser) + + +## Behind the Scene + +Filterous takes an image into a `canvas` to manipulate the pixels of the image. Unlike the CSS filters that alters how the image appearance only on browsers, the JavaScript library actually alters the pixel color values. So you can actually download the modified image. + +The `CanvasRenderingContext.getImageData()` method of the Canvas API returns an `ImageData` object representing the underlying pixel data of the canvas, and the `data` property of `pixelData` stores the color info of an each pixel in the canvas. (The diagram below shows a canvas size of only 9x9 pixel to make it simple). + +Each pixel in the data array consists of 4 bytes values- red, green, blue, and alpha channel, and each of the R (red), G (green), B (blue) and A (alpha transparency) values can take values between 0 and 255. + +![canvas image manipulation](images/canvas-pixels.png) + +This library alters R, G, or B values of each pixel (yes, each pixel in the entire image! so the operation can be quite slow with JavaScript!) to get filtered look. + + + +## Browser Supports + +Filterous 2 for browsers should support all the modern browsers that [supports Promises](http://caniuse.com/#feat=promises). + + + +## Contribute + +I am pretty sure this library is buggy. Please feel free to send me pull requests. \ No newline at end of file diff --git a/demo-browser/app.js b/demo-browser/app.js new file mode 100644 index 0000000..a6e87a7 --- /dev/null +++ b/demo-browser/app.js @@ -0,0 +1,158 @@ +(function() { +/* DOM */ +var imageDOM = document.getElementById('photo'); +var caption = document.getElementById('caption'); +var input = document.querySelector('input[type=text]'); +var upload = document.querySelector('input[type=file]'); +var errorText = document.querySelector('.error'); +var loader = document.getElementById('loader'); + +var willScale = false; +var scaleFactor = 1; + +/* Page and image setup */ +var currentImage = ''; + +var photos = { + bubble: { + caption: 'Soap Bubble', + url: 'images/bubble.jpg' + }, + sf: { + caption: 'SF Bay Bridge', + url: 'images/sf.jpg' + }, + bride: { + caption: 'विवाह', + url: 'images/bride.jpg' + }, + latte: { + caption: 'Caffè latte', + url: 'images/latte.jpg' + }, + cats: { + caption: 'Kitties', + url: 'images/cats.jpg' + } +}; + +if(location.hash === '') { // default + setImage('cats'); +} else { + var imageName = location.hash.substr(1); + setImage(imageName); +} + +window.addEventListener('hashchange', function(e) { + var imageName = location.hash.substr(1); + setImage(imageName); +}, false); + +input.addEventListener('keyup', function(e) { + if (e.keyCode === 13) { + if(input.value === '') return; + errorText.textContent = ''; + caption.textContent = 'an image from web'; + loadImageFromWeb(input.value); + } +}, false); + +upload.addEventListener('change', function(e) { + errorText.textContent = ''; + caption.textContent = 'an image from HD'; + loadImageFromDisk(e); +}, false); + +function setImage(imageName) { + willScale = false; + currentImage = new Image(); + currentImage.src = photos[imageName].url; + imageDOM.src = photos[imageName].url; + caption.textContent = photos[imageName].caption; +} + +function imageError(error) { + console.log(error) + errorText.innerHTML = 'An invalid URL.
Possibly blocked by CORS policy.'; + imageDOM.src = 'images/fail.png' +} + +function loadImageFromWeb(imageUrl) { + currentImage = new Image(); + currentImage.crossOrigin = 'Anonymous'; + currentImage.onerror = imageError; + currentImage.onload = function() { + imageDOM.src = imageUrl; + checkImageDimension(); + } + currentImage.src = imageUrl; +} + +function loadImageFromDisk(event) { + console.log(event) + var reader = new FileReader(); + reader.onload = function(e) { + currentImage = new Image(); + imageDOM.src = e.target.result; + currentImage.onload = function() { + checkImageDimension(); + } + currentImage.src = e.target.result; + }; + reader.readAsDataURL(event.target.files[0]); +} + +function checkImageDimension() { + if(currentImage.width > 1000 || currentImage.height > 1000) { + willScale = true; + scaleFactor = 1000 / Math.max(currentImage.width, currentImage.height); + } else { + willScale = false; + } +} + +function show(loader) { + loader.removeAttribute('hidden'); +} + +function hide(loader) { + loader.setAttribute('hidden', 'hidden'); +} + +/* Insta-fy the selected image */ + +document.getElementById('filterButtons').addEventListener('click', prepFilterEffect, false); + +function prepFilterEffect(e) { + show(loader); + + var filterButton = getFilterButton(e.target); + if(!filterButton) return; + + var options = (willScale) ? {scale: scaleFactor} : null; + + var promise = new Promise(function(resolve) { + setTimeout(function() { + var f = filterous.importImage(currentImage, options) + .applyInstaFilter(filterButton.id) + .renderHtml(imageDOM); + resolve(f); + }, 1); + }); + + promise.then(function() { + hide(loader); + }); + +} +function getFilterButton(target) { + var button; + if(target.classList.contains('filter')) { + button = target; + } else if (target.parentNode.classList.contains('filter')) { + button = target.parentNode; + } + return button; +} + +})(); \ No newline at end of file diff --git a/demo-browser/filterous2.js b/demo-browser/filterous2.js new file mode 100644 index 0000000..1eba0a7 --- /dev/null +++ b/demo-browser/filterous2.js @@ -0,0 +1,798 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.filterous = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1 ? 1 : adj; + adj = adj < -1 ? -1 : adj; + adj = ~~(255 * adj); + for (var i = 0; i < d.length; i += 4) { + d[i] += adj; + d[i + 1] += adj; + d[i + 2] += adj; + } + return pixels; +}; + +// Better result (slow) - adj should be < 1 (desaturated) to 1 (unchanged) and < 1 +module.exports.hueSaturation = function (pixels, adj) { + var d = pixels.data; + for (var i = 0; i < d.length; i += 4) { + var hsv = util.RGBtoHSV(d[i], d[i + 1], d[i + 2]); + hsv[1] *= adj; + var rgb = util.HSVtoRGB(hsv[0], hsv[1], hsv[2]); + d[i] = rgb[0]; + d[i + 1] = rgb[1]; + d[i + 2] = rgb[2]; + } + return pixels; +}; + +// perceived saturation (faster) - adj should be -1 (desaturated) to positive number. 0 is unchanged +module.exports.saturation = function (pixels, adj) { + var d = pixels.data; + adj = adj < -1 ? -1 : adj; + for (var i = 0; i < d.length; i += 4) { + var r = d[i], + g = d[i + 1], + b = d[i + 2]; + var gray = 0.2989 * r + 0.5870 * g + 0.1140 * b; //weights from CCIR 601 spec + d[i] = -gray * adj + d[i] * (1 + adj); + d[i + 1] = -gray * adj + d[i + 1] * (1 + adj); + d[i + 2] = -gray * adj + d[i + 2] * (1 + adj); + } + return pixels; +}; + +// Contrast - the adj value should be -1 to 1 +module.exports.contrast = function (pixels, adj) { + adj *= 255; + var d = pixels.data; + var factor = 259 * (adj + 255) / (255 * (259 - adj)); + for (var i = 0; i < d.length; i += 4) { + d[i] = factor * (d[i] - 128) + 128; + d[i + 1] = factor * (d[i + 1] - 128) + 128; + d[i + 2] = factor * (d[i + 2] - 128) + 128; + } + return pixels; +}; + +// ColorFilter - add a slight color overlay. rgbColor is an array of [r, g, b, adj] +module.exports.colorFilter = function (pixels, rgbColor) { + var d = pixels.data; + var adj = rgbColor[3]; + for (var i = 0; i < d.length; i += 4) { + d[i] -= (d[i] - rgbColor[0]) * adj; + d[i + 1] -= (d[i + 1] - rgbColor[1]) * adj; + d[i + 2] -= (d[i + 2] - rgbColor[2]) * adj; + } + return pixels; +}; + +// RGB Adjust +module.exports.rgbAdjust = function (pixels, rgbAdj) { + var d = pixels.data; + for (var i = 0; i < d.length; i += 4) { + d[i] *= rgbAdj[0]; //R + d[i + 1] *= rgbAdj[1]; //G + d[i + 2] *= rgbAdj[2]; //B + } + return pixels; +}; + +// Convolute - weights are 3x3 matrix +module.exports.convolute = function (pixels, weights) { + var side = Math.round(Math.sqrt(weights.length)); + var halfSide = ~~(side / 2); + + var d = pixels.data; + var sw = pixels.width; + var sh = pixels.height; + + var w = sw; + var h = sh; + + for (var y = 0; y < h; y++) { + for (var x = 0; x < w; x++) { + var sy = y; + var sx = x; + var dstOff = (y * w + x) * 4; + var r = 0, + g = 0, + b = 0; + for (var cy = 0; cy < side; cy++) { + for (var cx = 0; cx < side; cx++) { + var scy = sy + cy - halfSide; + var scx = sx + cx - halfSide; + if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) { + var srcOff = (scy * sw + scx) * 4; + var wt = weights[cy * side + cx]; + r += d[srcOff] * wt; + g += d[srcOff + 1] * wt; + b += d[srcOff + 2] * wt; + } + } + } + d[dstOff] = r; + d[dstOff + 1] = g; + d[dstOff + 2] = b; + } + } + return pixels; +}; + +/** + * References + * https://en.wikipedia.org/wiki/HSL_and_HSV + * Grayscale https://en.wikipedia.org/wiki/Grayscale + * Sepia https://software.intel.com/sites/default/files/article/346220/sepiafilter-intelcilkplus.pdf + * Brightness https://www.html5rocks.com/en/tutorials/canvas/imagefilters/ + * Hue Saturation hhttps://gist.github.com/mjackson/5311256 + * Persceived saturation with RGB https://stackoverflow.com/questions/13806483/increase-or-decrease-color-saturation/34183839#34183839 + * Contrast http://www.dfstudios.co.uk/articles/programming/image-programming-algorithms/image-processing-algorithms-part-5-contrast-adjustment/ + */ + +},{"./util":4}],2:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var filters = require('./filters'); +var instaFilters = require('./instaFilters'); +var fs = require('fs'); +var Canvas = require('canvas'); + +//module.exports.Filterous = Filterous; + +module.exports.importImage = function (imageBuffer, options) { + var filterous = new Filterous(imageBuffer, options); + return filterous.importImage(imageBuffer, options); +}; + +/** + * Filterous Class + * + * @class + * @param {Buffer} imageBuffer + */ + +var Filterous = function () { + function Filterous(image, options) { + _classCallCheck(this, Filterous); + + this.options = options || { format: 'jpeg' }; + this.scale = this.options.scale ? this.options.scale : 1; + this.w = 300; + this.h = 300; + this.vignette = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAMAAACtqHJCAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5+mlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS42LWMxMzIgNzkuMTU5Mjg0LCAyMDE2LzA0LzE5LTEzOjEzOjQwICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6cGhvdG9zaG9wPSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8xLjAvIgogICAgICAgICAgICB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIKICAgICAgICAgICAgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZUV2ZW50IyIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPHhtcDpDcmVhdG9yVG9vbD5BZG9iZSBQaG90b3Nob3AgQ0MgMjAxNS41IChNYWNpbnRvc2gpPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx4bXA6Q3JlYXRlRGF0ZT4yMDE3LTAxLTE2VDEzOjAyOjU5LTA4OjAwPC94bXA6Q3JlYXRlRGF0ZT4KICAgICAgICAgPHhtcDpNb2RpZnlEYXRlPjIwMTctMDEtMjlUMTg6NDY6MTYtMDg6MDA8L3htcDpNb2RpZnlEYXRlPgogICAgICAgICA8eG1wOk1ldGFkYXRhRGF0ZT4yMDE3LTAxLTI5VDE4OjQ2OjE2LTA4OjAwPC94bXA6TWV0YWRhdGFEYXRlPgogICAgICAgICA8ZGM6Zm9ybWF0PmltYWdlL3BuZzwvZGM6Zm9ybWF0PgogICAgICAgICA8cGhvdG9zaG9wOkNvbG9yTW9kZT4zPC9waG90b3Nob3A6Q29sb3JNb2RlPgogICAgICAgICA8eG1wTU06SW5zdGFuY2VJRD54bXAuaWlkOjZjZjg0NDM2LWY0YmUtNDlkYS05YTNiLWQ1N2NiM2IzNGZjYzwveG1wTU06SW5zdGFuY2VJRD4KICAgICAgICAgPHhtcE1NOkRvY3VtZW50SUQ+YWRvYmU6ZG9jaWQ6cGhvdG9zaG9wOmE5YTM0ZTJkLTI3MjQtMTE3YS1hYTY1LWQwZTNmNTAyYWRjMDwveG1wTU06RG9jdW1lbnRJRD4KICAgICAgICAgPHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD54bXAuZGlkOjE1MjM2NjQ0LTI4OWUtNGE3Ny04OWIwLTI0YzRiODQ1YWFlNTwveG1wTU06T3JpZ2luYWxEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SGlzdG9yeT4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnNlVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6YWN0aW9uPmNyZWF0ZWQ8L3N0RXZ0OmFjdGlvbj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0Omluc3RhbmNlSUQ+eG1wLmlpZDoxNTIzNjY0NC0yODllLTRhNzctODliMC0yNGM0Yjg0NWFhZTU8L3N0RXZ0Omluc3RhbmNlSUQ+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDp3aGVuPjIwMTctMDEtMTZUMTM6MDI6NTktMDg6MDA8L3N0RXZ0OndoZW4+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDpzb2Z0d2FyZUFnZW50PkFkb2JlIFBob3Rvc2hvcCBDQyAyMDE1LjUgKE1hY2ludG9zaCk8L3N0RXZ0OnNvZnR3YXJlQWdlbnQ+CiAgICAgICAgICAgICAgIDwvcmRmOmxpPgogICAgICAgICAgICAgICA8cmRmOmxpIHJkZjpwYXJzZVR5cGU9IlJlc291cmNlIj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OmFjdGlvbj5zYXZlZDwvc3RFdnQ6YWN0aW9uPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6aW5zdGFuY2VJRD54bXAuaWlkOjZjZjg0NDM2LWY0YmUtNDlkYS05YTNiLWQ1N2NiM2IzNGZjYzwvc3RFdnQ6aW5zdGFuY2VJRD4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OndoZW4+MjAxNy0wMS0yOVQxODo0NjoxNi0wODowMDwvc3RFdnQ6d2hlbj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OnNvZnR3YXJlQWdlbnQ+QWRvYmUgUGhvdG9zaG9wIENDIDIwMTUuNSAoTWFjaW50b3NoKTwvc3RFdnQ6c29mdHdhcmVBZ2VudD4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OmNoYW5nZWQ+Lzwvc3RFdnQ6Y2hhbmdlZD4KICAgICAgICAgICAgICAgPC9yZGY6bGk+CiAgICAgICAgICAgIDwvcmRmOlNlcT4KICAgICAgICAgPC94bXBNTTpIaXN0b3J5PgogICAgICAgICA8dGlmZjpPcmllbnRhdGlvbj4xPC90aWZmOk9yaWVudGF0aW9uPgogICAgICAgICA8dGlmZjpYUmVzb2x1dGlvbj43MjAwMDAvMTAwMDA8L3RpZmY6WFJlc29sdXRpb24+CiAgICAgICAgIDx0aWZmOllSZXNvbHV0aW9uPjcyMDAwMC8xMDAwMDwvdGlmZjpZUmVzb2x1dGlvbj4KICAgICAgICAgPHRpZmY6UmVzb2x1dGlvblVuaXQ+MjwvdGlmZjpSZXNvbHV0aW9uVW5pdD4KICAgICAgICAgPGV4aWY6Q29sb3JTcGFjZT42NTUzNTwvZXhpZjpDb2xvclNwYWNlPgogICAgICAgICA8ZXhpZjpQaXhlbFhEaW1lbnNpb24+ODAwPC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjYwMDwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+dy/82gAAACBjSFJNAAB6JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAABm1BMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2E+W/AAAAiXRSTlMAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4CBgoOEhYmMjSzlzbUAAPgiSURBVHja7L3JliRJritI6PEeFv0+tX++V303grcwVRGCg6iaD1GRWR7n3soIH8zNzYRCEgQB/L//6/83M9DMjK//5/rX+YH5N/0vhsFI/SLw/Bevrzsf+PWgNP+Trr8YyOtR3A+nPMyYD8DzJ13fT8P5YOubef2U9QD6DOJ/z8+B+ddev8l8wvI8/RdcL8L5F/9JIn7h60Pnh/H6G4znX6FfC5ph/QM0+QIUfwVx/gPxM/JBXI8//35+Bu4/eP3/fIjj9U+uj19fBhoMOJ8y/MNhfv96bPfc8PofmtlhBM5HJ9bzhMGu3x2vp2HyzEC8Hpavv63X4vVtMMJ90F4fuV4n+t////7/Pv7X//N/unOA18lGOmtyFNw7Pl5nDK/Tex6468PuOIzzf3n9EzQb4HWUXmedkHCjj7Mr6lb48vqf6xiS87z7EOR6Zu5xXz8V58NiRRL9Mw6/vc0fD77OcQwOH0uE3CrgFX12vtaQSwevwJI40BPtQ+Z6J68woQTC+WBwJ/E64OvzEiDgPMV4Pb3XobsO2fxu+BMuQYN5fs1ohwsZuPMfvx/w4YoztM6/z2jzP8AMZsc6yRK/V+xev5a8jvNnH8S6iUDDK2p4xs/19f8HP/7n//offyMaz+vPnypNH/TXJGlmQ97o1//px678sX4UCV6heOWKcMVLGiLNZ5zr5NPFLDWauXLU/MWu/Lh+qP9in0og0aKvjQ+UmBE0qED9JNznEb9392eGg0sO7kz7AOEuW8DimfFnHOEyft3eh8lxg36d/xAklcyjDhddZwD643pcP+iKv/UjCUB+gYP+Z7zuEqD+JeF/F9AOWojZeVO8/nOQB02ezf98zDcfVXxI9RXCw647VCoHrvvRHw2uQ3X9/1ghAXLejvKTWPyLM+O4s34Gg6+P6HMYjZhVHtiFB32Mx+jQgJwx1EaH/1+kELN34mNdLS4OzjcA84NXxuL8itcJ4ooIuti4ktj88JW7OL8Cs4A9Y/pV2XE+AK/gfFW5uIoQrNoSxlXT0CfI82EGzm+byfA8DAS4wpY47+L54zFeddTrN4OvWzW7rsvJ3SpGn3pfv+r6eddr9jFfMt+FrLe6v+Y4CxFQ3/PrPaTWZGfHYBiG/FiM3QB8fHA+myt9+DNutPG6T+iLKUj6cElMg20lFDClEin2oC1aWVuFuGHqYt6KC6teKHe2sJLqdVkg/pxVzJ3HlKan4CrvrkNyvrKz0roe1f1krgcYcKeT6wFwvaRwvdb5Lo4D14v1epuPdY0PYPZfNNiZTdxDvqrbK4xecbme+fXTXvcCsVKCvR54Vb6rQ7y+IfdxH6lj1DdxtbTQQ7EOky+MZ9RIg0mGDpb+ILk+QCs11yr4nj4+3iqmoBf40DZ7JTFCGnfpUWhFaaXtemo86F69GcJg1ZTnI3/3NdhdUGcbOl86XF2M3NH06SUmifOrV2qh3u/XS3Os7xq+H7pe9yuZmEQGXyf+qik08axHGYdJczSzDF0peYUk9ce/fnv4cLzayhnikKuKZ2ezHgI+nXBBG1eAsEwXNH/miFRK+RO5IlyBHNYY2JArLpQyV0Um6NUqL0iG25TrQnT1j482/amjar8thgctdypWB8fKj3aBHNxki5xj4G9evV22kcKV0yBNmkskZ/PvI4RXQrne0+tE+fAi4Y7ydc5fkU9IhMAd2rPiWfBWKKxej3EVXWNlNazTLzE+w3YVQ+uHmBFw8UWPT3FCU2cluMKACXXk2QzN5EXMAMFZkmCE8wF5ewSFed1cZEg3tIBDwdz9Pj+HWY2TDho2Rjj26nNcXjCpxin9xSyiSAvgVYAZmGG63EMoYlCe7fydTU5IaQ+EXgsZJvRhwT6tMH+Cli/dFUVAqsLMaBgIeLK7zekLLeiZfz3rwyUsBAxb2h9eEKw76g5BuNLVjCgeDjp3gXKWZmfmoAPHXeHkQKkrEw3Noj7TXljE9eM+5KUd0q5Dcc8YHzQaB1IfOZsrwXEo7/+8YxVpcj9IpxeMtzddJK4Hc4HDkD1cfzKvWsSpTNV5uIKsqqtiF98jWy6Fu8HNg67DVy9cBVGcgzDUKALSrNoD806BL7ngf2uslp6YZ/msljh/xCpMiJlGfJ+y/kNIg0w7Ky9flLksMQ6TKkz76bMvoS9kxgLH3AFGfAfOZIt4y7hG/ZB35YNu7KYjJcb40GacCyuxNWSja8/TpI2rf/Fhk7p5bR9eRRXKbkRBqAsb88Gl2LENn1NGKq4KxI7n94AVXFUOE/t+nNrEnBgTMiCm4JCgc+7kMWUTaj1Do294fTGz3j4eoSwLXYC/YedJdQNNnx7oELLZhK9sCR+KqVOCjxDGqkz++3pl4BGLCIPCHXvXDfCgHVdhA9M8hgnb4axxPqRpAKWoDqVM6FGOESZoc/jhOxX6bl6xW9/pzJnIq2pzTwIy4UMAbzX8SGDFx6rdZqpggrLDeCWmAzLMw5mR123SqCce645/kRFe9f+rA4B/VXzM5s5kJQvEsj0gVSjw1RkTAy4gzXe1qyK7WpBXNL2QSLhb+kKSVrrzt7LPgnQJY3UtnA/2+sKxsDKfdQWaWy0DsSBmSA0bIYerQTfLSXi+mFhT3o9zqG0gr7F+GGQgXpGvCug1LfeoFulgPskVuW6Rv4PmjgYV/iKZ8GB3egWOose+Xs06Z+nok4mf87EgjcSAKiYdaTKUYyOBgpyHxX3TgJt7gpxHjetUc4JHfqJx3mcQeEYm9w7hveoLSF1zjo5Xb1DVNDPTSfk0mwd3gXoQzDXfJl0QsaCMUGY5HM1HlT/452/ingtiNBDulTWjsna42vfwmTNmr8+CZvZxEl9eRSlnJVHX3eY+h5gIaIZhxWHWPiVQnwLcFGFVT746Cy8KWYxrgkNi1WYLtVVwmIF2YiPhVmR+FhFmswZvluPJcoSoQB8sUWEciQXjdXXNmkQGf/NqNZP6yZ2EAQFqIKWWdO6caOz88R5chQcVrsNFQCulBemu+sqNRBTkpR/7S5NC/1TWVw7/FAPoB2ne5Sn5ENVH1w9fRdachpoZPzyAvshC9KOUEr5BuLDm5ALhICIX0GvkNBw+OgHYxDVhHLFzNQ7wbQkZRx+Q7sMi/MqMMxcglxVcgpArF1wKDz43vQmMXXFWpqpZ+wzTn7MGXDL9m3UaJRLOR3nNn91nrnEdzM0GOb/6LMPoqidXhsHIkzC4uiIty+EbjIUKuwSwnuQFSM2jH7OMdCX0bT8j0nv+VGg9d/JT1j/djQJ66OEF80ISAxtWanOmGCfGyORYPbJgQlALClUc8J2de5gk+kTOOMe4iC2RgRgGNNSpzdWdJHwi0gziDMUB2qs91oS6TvLb03T6cZQhwguYVbytyEDqR1bCclNViY1Zz+l7ABfw6+e4m9iNALFKItc24ySGBKT2AmrnU8F4TTVY4VfKKuHis0xu2Li4vUSoqCxMSniMKyIlC4Qww4c2A01BnejehL+ur9l5oOZV1zNNCVMWKb+MGFIi00jOslg3uXMzib42kJoNVoRl+jml1IrK3t0NQ6rOfdGjmwkJaM0ouWWbXKCvm9oqFZiBdgJ/h7nTO7vrMOvwA/bZsRB0A+qrezQ/1bA5m79iSTDkgBNok3LeobBYFslIXdsJQVEQOQBXEaj8aK7AoUaTe/445yAz3tvGM21EsPgQ2Y3DQqBhxVSYRIBxlu3ZVUz4aoRmGWckEwhi5onIYonGa5530D8Gq+goXyl0o5HQF0iqeQU09Gx2oeI/OdYwumSLwPMVV1Hm0EpczaivbkK4XtXPPHrjNVG5OFMk1kiEa/ruASdH5XAtiXbYJyrq6YNzYn4teuDkiXjqFpQwY65kYwi6RTSJF9nq7j8m7Yux3/DgvHafDDgM1wvORNPTzONZMQaOWN9L+TV8d46Gi5WXPBw1nitrEcNf1HQsVRa8yGoYWOcOYTpaFR5NvTQZHzkiKSODq1smmsdaZKxhk8aHkEb0+Pm+Vkd6viu4JtQXNYQYrlv3CQpICKvvLTxpeBKNJXqkD8HFyeUJK8+44BmInv04m30fA1JDOj7Si4W16vNX21EiLTBebF4oSwG0kpdNwzjiKIOZpsREF5mkEim1PLucFtiJYVrIOSOPk/Hwoy6e0RAi45qGcKUmhuqMBakkj06KtgA8yzj9HHfTEW1XQrOCwI5xo9wwETBfqXANtOZQhdKCXLf3IinqiP3w8z0s8tVsYNbc7TV1cifFjTgInRrKjENue5ehQqcuDUyE4jyRK77I4Sp5PdljxcjE6K6nxDCQnAMPXFQTlq15mqCDhhHWoQyMh4HUBxkIoI0PFakzrZjnxdOsfx+ICx0evfVjTur0UPMci6dC9/bTFgTO9QJfp3OA1uLifh6CcLOkxOtfKDDSq+hLq1SRO6YuU8aAb/NnBwEdoc3SiQhzETOee0w+oWjppaMSCNP1YoDxYq6s5mRgZQMea1qzCpNJ5x2Hq6JcJ5aovbFfIWZJyFlXpUWSCVataP5wU2uwJNeGbtViLmUIrDnBIguWr6sLRjgzujzIxMtAepJkYuG+NmoYSCRD+qfYT/v9XiR21dAOW8d/fkWx2aAKAcm0atuWYXFwYKniS9NgPzeEDWDW+zpqcy+mu8D9fpQHfT2/xCOWCmddtEJ3GczpHR0ll6sjKchSphNNz7e6Ook1QPERXKC2yoaEZ22uV1Wbf8xjcAyQJ8xbTetMMoT2gjU4df4mIFJxUUwVJX+MSKBlKkcoP8oKvMws7v+WDMTIFCt3Por6K8MDPh3RGm2HRFZkk2XW+x/XJaibgMVPQWggEcBnREaTcOIQzvuF/Vha5LhWBfXTwteCCw8bxxrrrVPvVjVcF29zHworz0S+8QsDkA4t/nzq0P/6C+h/K4trbYgpFxPFcr13YJKXnTrjAPmav6+1TSZVFEL5tcC1hJvwT2obPvKiBmnFcuD1cY/LGBNpimGi7slYYEoroJVEE8v8/DI4Ut3qivg5IIf2Sj5h0uM4Ja/dHDs3MMCguIIURdIm6xx6jlHowwEmR3oFx/qiYYfMz18yIvGg+47EYrk1B8aHCZxsfpMDurQoyFRMa7BQFuvNvzaYg0LMdUl9mI6+/Ywp385+P8c1GNRMkwR+LALDCDdj5Dax6J6VzJu784l5UdOHlzBJ4075D5jzxOgg3ZqKU6icoJ6PyGaMVeOmEKkhLlJKKfiMlCve9wS6eut22MssohNvlwUS4YPCzhL6pQnQGh5N0iV43vdCHXFZYSB/m49krGmmr7tw8g0l6Sjj0eNur399hPmFvJ8SCS+dHgtLHiapo+BTFXfsRWBlVW+HgceIq+ZXervikuVc/uxFXO0oA8BAzmKmIbIgCliiN6KrqkIGlcUo8IYTv+WeeO6RyV5UoGUl1q7/3LpZr6nH2R7Dp4s1LHFVPxg31Lm+67XaZA7A9RxdXg21W4G8CFYvPRG/+OdXTqLWgmfw0+ygMN5d0yLUYcFrYU2RZdL0fpQLdHNVRkHhUyNJkwqkDGG4j1O06YziBC8b/NO1635e4cl5qdsOvK/YWqSNRdL1bl4WhMZC/6AvvtKxRzM/+ZJqg24JIbBg3QsfAujixg7hQUmgT1YxhBDoD/iVWyYMzIlBXcd2wCs/eKzrxJYOYW6EUslT54PYAVzxRuhUccAThV+rhhGjW9A1JvHKPUSeMr0YLx9lR76evSidMSwrBfUFPUqUvX76/mFJIprl+YdjHA5HEBP5oSGx6GcdppPzlJgqzZ+onuWn8CnIq+mQtctUfBIT3Ilk4SZSfMF0EUNrqgon5g5FfmczstoJN+kQ/q7yZdepHCbjd783tUILJoyseclfCjaHDtX5Uq1bzbeyQ0O5toLj/MeAKfkEAwfT+qTXiQvwF8zsA7LfF9lUaKlAKydgwC/lDghaStGQmqCJT9IDzEMJ13B4NQK60UwUe7OSUOjG6esRhqXbnS6QmXY5ztZrWEPSTB/d79OqJOk2hHyP3Y7SPUnRA2WIwNaklIU9XLcfAiGar1aETjZkuOveBM7Cgqzc9/sF3XFc870ZS0RIfecA3YMBwyXM1yQmyOD4VxfkAb+jbgQGtA/VzgOq93BhZR9DqgHWqrxRrM3kHhdCO3Mf4bZqX1STcL8ffqjHtPGaiU4jiC4KcAyG8OGcTKZLnrkFKoTj/PJfkSeLFp63UcH686qo0aUMlJ8JFKqrPUDqR6Qjh4WmQC4wBYC5GmZ6nEhmEnNPSxREoCD34uhDZOeSNopjIwJWXhELgvArlSB8Qpyv0jiQJnNEXPJfUhAfVyozlQYpEv9QvH0NwaZEA0ZJ/g0TdlVtDOo8ENE6ZRaGXY+8H3KVfQzNh7Y9VEGG0FvEjgNTtBSdApzX29iydXlTXo1zN2q1ZVmiukSwHGrlC28quKUD3hiw1FrNl0i+W0da2CXicuH5bXOTxCARIUOONKeZa4Dz9Za1W/MTTi1FuV4uvqRGi5pMGZHzOkLENq6j+uEBP5aMIYm3MPFzlPLFFor1PRhVGGXeIGOFUbHH9XkNmVfE+75YByzx2cS0WougacpOS2LcNLdcxrpRL9gJid5YdjNcN7ZwRooxYWKmEh59sjCXPteuMKnxXjnRbBgcadHzTIQH6O78QFeFZC4KIqwMe8Irl3q2iFAXk3BDyFaL12IXrfcVB+O16iV1wzlj1J1GnzEO9+Xn5f1xcUdIjLr2pWfFDHdXohLPoQr56USceC0R2qIdkl2uqVVDGMiRCF0HtXt3U/qYirxm2oTKWHLoM32RKFa7rKP66nXzUJw3r6gFAXcrai4m8h/NqzG4TH2eIF0Zp+8BtFHwsnIu78G35QPVXusc9ns4jKo+uiaGgZbuA9VRe13I0cFXHm5CUHvApezr6b/mi1Cf184xygXzDujU45p1z8igTkbIoiCWHdOGvMIwJws41OxVLMqFXv8QLmIIGEYPkLWGKHu0kcbut3IVvaoKrypu2Iw2ihSSN0Pz96qAqHC3qQhvQvHXZNHFCCOQeSJPvhGga9PnLeAp8aG3v/KA1HWcmgcMX6q/8LALDXBaX0uvLVDVYRZSVojiNFZPA5hJY2FwQPH/K5DYCwr4SBAJEwErrZQ3vea5dpfAmQWshsEag7wVWOQPeiHRpEAyMs3X2Gx8y2OEzeAUz7xKhVQDITXlrAd6cRRfca+KjmQByrXM96Sgi9VLLQwEPWaBtIJxrG0K6rCc5pvzyL1ym7uxFZ8LSmvxym0XWtjUWHF5hHF63HJcjc84zFSZyF0ebotFab5RStrRNSfPAIx0Ez8HQWw90Wgb5FG0o2fHLl6ZH/Q9SFquivsR63YfesQjG7Epr6hxk1Y+qvVzS2RhBr65tDWFlru1HYmXvx9wUxkwUBHosQdwbvWoUJu7cvTKDeVX3DWHCa1o8cJkbzaw3VfbIpJUXCTACc76TQubC05JU8gDTi8ThCAJMaXjdR8xXTPCLUifdPEAn5xdecZM1bo2mj9q/CWpxoLa7npnJo/8U+r7CFAJ2yM01sPJKBpLLuCZcYZpf7/EIGheXpjViq1Xwkk9fS3OwArzjpslzLd87smR+hreYcNWi8orsYqeqBfwGE0Fobmnj06ln8O06I+0xutqkCx3zdHPu3sc1/+8CKoXGUNvf6q2tNv10p87q6ih88xFJJmz8lmuzQLQJaYjkPhnv5I20TgXpqJjkhelriD5ZUQot1F0v/FMKITBHQJQ5dUPV0ml8xTJJmEJ0ajXsG6T0G/fBv6k+l5JawSWnM1iO71JHJV279f+MCJTul+V9pj0wrdqiOg8Ede3vk7hgJRYDvu6VhdhS/l9SaUuxdywRuXdCszJRAvP383ydTNqaS1AU+jln2aSjaLUliv2wjLKSKpz56c+LGzHLdKMlF5k3ozK1VfdgddsPkY3TV+qMY8/AqkQSXdHR+TMXbuvQbNeNTPpOC+E0Irtc/Wk2+BY3/mH5jTRFOQ1ZCsd0LQFUVEehuFhwK+ECn/t7V4S5K46oR9N6mh9zTL9kNHpGJqODbV7gIUaKLXtUgjCE/iLNg7HMEgmWvud7kcffIlXB3tJEwGHV02Dgc2moddZr/DMOQBkUU9EwdEBJqLjyhAsx4pKfe/Kq2SzFn3d8gTGMpBFFpZz5nbmA976c39ocaGBbhIShO2Wglth2cEJ0brW1m/wOgXU2RVBxRS8kdlimASu/FVlzfYZQe8+wKzzKTipBrC0+XHWN7JWqAslJ478CgV4AuJiMcqo66OGYmPr6W1swSx2Q1nW84LVUsuDEWq61EkNpXIcw0CRpVIDM3qVzHJ1aTH7mBRc3Qxb0TqrkEAlNhYiY9ZAVlNhwV2OeCNMIGo1FPZHtUCSWIqOraLqVXPeFwbfFne+MOCBAAd/Je7i6k8FZgqaP0vJaoAHbO4myjjC2YIoOAiHXYcwXTxIR8lUqpsbaF49CBrWKfPWMNJ9yUioQNq3g6lKLwv2U7awGd5dJLITl+ABLejChcNfOODWdgeFiXoQTOV2kKe/WycqiuXY9uJ5UnlWbK0hsckkqwpQubdsa6AWg1FeALKe1GgoUhZFzm4TYcouDJcg/asjRD/+YCqfzjM4DktEKZkBiYoXEe43ifolXeIg54tutdDbF8yLLGOiq518idpANveYAHc26I2JgUBaSArDdF161V5nxIQlCYOb9JHkTfNQhUnMMfvEs4sO+sH81t6ZUUCi6cHN1oKRLOC1kcL0fqzJnrTsrvyx6dZpkbkBZ3uM86vWTT0MRcti2ohQN63chrtM7+F1qynq7/4LESYq6LPya6XwIueEF+FKTuMwm7qjp3vo9I9dr/dHJGZkup6yAVnSgJJWp+MIu/+dNz1Dd62rtLj4t2tdUK9u1Z+LTTlj60+aWoIEyvvstERvpIIfahbOitpGrfpJ6DSA2Hr1455TsphKnmKeGWIhefsOZPXVcHiYpgCdEMJLNFzzDj/qUAPNgaBS/XKQWjuKcXgnlHtf9K9Jhko3Ru03ICkHr3oOFEKyJS0Nl0I+TM9OnHWfr1VBrDOLdNnyI84+uZ+gFUWKFDwq2utE2xkt1KN6+4UxxI9ZrfyD2hSLTWJMB59daNygvNfFGuyMG3ZX8lxOV6igdRnjd+RUSIg49i4sCefo8MCTZ5e6NZTfq23J4qx4202PBYTkAJ9NIjd3HA5yDeTFZrIY+0pkiXfz9CzwYwk+LKPReGqZ1qjlOs4q6lrrQ4SmoyABvRun51KwBpW0p6C25xW4Wy0Ec7cIH34mVeJWZpM6sOynImy6a4rSG4Yp66PIElpqeTGG7vjTipZd1wdzXOVRAZKhhzcNQdICouQZF0jnCuIR5FQCBee6MIZsTumal3uKWNNA9/4gPG6hYMm1UUhE1iMNHwEtvpbn9c+IwzVGf7Dsubn4ul4CV/0+eM3Np9eZ1FmZ0DKZ5w2JhBHUGmCoo4okkpoPVniw8tNdXYj6+Hcft2q0mqeP/kVC03gsU5Yykzjqu+cuevAdwdxJV0C0WaeQd8GpgwjfOIsLh0SIjmicF9plKTr3FY85qBmIx1NnHnruz6d2sKrzzIJnzml9QEdEuQg9q0P7oHo/B3ASzJYdaYpMlSiIEzOQTITCFVjUga5uOKWWonI/Y5QstWAJXRJLEkZdYVBZg7hwlGZDKGRTIb0xMNeXHW2PXm4azvdFbAiSibrbQkKaHCKK96pIDt0IXu0XaDb3TjzINOlaPlW6E+tN0f0+5ItYCbi5hk8lQYHUs3Hcr+5lH64UHBS/whTVPiAL/EBhH8tDV7GhClNMrjKTuHgFMZGRGz2BozltSZma6jUoM8FMpPIdZ6I6WmminsjxBcXkevvqBaksjJUZ0p+hlzhZaiRZWX8PNrhytZ1IGrxeSbRHZ9QoEbrsKg4FqTzCD0cAtATM4qX6U1HbPQgWVz4YITR33DRz6AJwYhuGqYoSeT4K5Zzwzox4nLzNmLhIMVqScJl70pGw4jTCOTsF+xFaHg8y7BI6+Nly3ccQax68qlbSS62eYsVlWLUjRZaU4EfJQ+z4OglFzygOQzKrbKGDXHUx/4gaU27Zw1JNLkmEcyU45Bu/nW5RQP7S/YGJk/RaGQkHn4eu/0ZJSRfSwqxEFGSEZcc36JiEUkG+AoR+2I5sB+42p1i2s5Z3RtliVRRpdJqEf+J2pPxRULfmMIlpDqj2hrn7YFOyWbUfogN+NNO6DpfLMy5BVNM3VZgyOuwvBEloV9dTw8oYUrHxpdvOFEPOjkp1gdTHj7KXSK+zS9HU0o3AwNiFSFurHI9gZ+ucX/qkMlGnp8S4C+fQmwhUhaPXJ47FgLGozRvwGq4aTVsSZqDTj9JlWds5lIc3a4B5cs5YsQUOlR94nXRgigypP9xkMSapwsMKRzhWisTuV6BVleA2NJoeju/WWcnthcw+CTX4da2CTxNl00Vw3yas4hjRj0Zsz0T1avKwPNYVByJTOQhLbvH6Ny4HhOWScjAbIXoQOPJDPIk34WPiL2qXNum1fnuQ9oqkBYx8UIX0GcFdMNuLoSBL+ZDCWgMKU3PvNBJ8B5xmoIwHh6YvOdwyKDGtrCphCBaBzRrYrY71JjGWA9OfofOyDBMtyejBfAGmM4nczxhls5xCZ9KqGeI8GDBUeoPzZYHITDORq9+cvy4cjrWoH276TUOYWOYF3WoDCn6/NgYWgqfnlUHKLcI4/rOksGOFLHNQ11kTOnrk02+D5Ck8ff4YJTEwsOEz6CvRliu14LPIRH8pi6ti3pGbDr4XHG/QEqthR/6QyO4mYAuTp4BkERAI8q4i9A+clzdEcYfBztlVOqHUMtlqWte+b0pCow5G2jujmpV5WV4MCL1fujak9cThbNwgsj8yeLr+HCMxk/yOuXUT9MzsikePocDxu7AoIVT6hXfGYWGaftyUV9HJlo1tbXjW3DQeNcH3CYjbfRWS2mbHPIoxMJS4jcA9nf3CMCCHiLQiijYRoasPJuV+BfzcWVrjdUc30cm3M/Rcg1nCU3HDZN5cQy86JAhGH6FTQUFe0J0/Fe0inE+69EvLNwlBCmp2xfBYrkn1FeSpC94rdZTol2pZsGtXcnJWoBofTOXVmnLeNOel7mkR05u2nI+j462Wg6mku5+A0GvAmZreOkAETs6pDJG4BxhtM1lo9TrxEhfaYpKgXiCEiiK60Eba4Yii9aH7mC0OivrqmneHqgrhEeGAD9eDMI5+ubh3cp+vvYO10DeK5aaiXOHy5JxiWtxU90keUSPCZYk0/SAzgjt0vM0ke1X2Hr1HTqOWtQ8CbgstTyq6zzy4C5OiYNIYgavz1dNDnXEuxNfM5Mja2WzihH+CQQihViKrD7m6GHjYC5F2OOB5zGFxPRAtxe/piCGLOISJHQrVVR2TqvmyYOO6+33/gUIVCnnMzNQdww/M6P+qPbGOxifRWFRQSkIJZVt9pMEH0y2/A6/kWaGsrYro6G1BaE/Dw9uLUDb461suPRp2fQm9GGOhCTQFDRampaVBVDDVVphh0jDA6PbnGv9xhAEd0pYtiqNLH8Cz+Y7ez6ItET0K6UUiDt26D4nKc0dwjk9diVW8zKLDyO5YBB4s0t2qyQV0glhMigrFfLBShpP4sBQfAafadR/d+CEqOtQnvfXZ2YSGtFlYek5WeKiCDoV80Kdb9NtTW0KUAEEugeJjiaSDDhbDxeydnJ1WirN0mxDuPPBhL1B3cE9yFp2AMULngMVXDmx7Nxpf9ANUAIkzPz1JLctAp+hNGThYl9zpch1JK6yZuUivc8u0dBJIhhDCVkoFKQFVlVAZH6y827MWXhrvbBhVtZI7q6FgQ9OqxkhtI7Lo00VW4S5GRLNcY6S0r/Xc3bAWuET04MVzl+BbFrxVyqKyfkN+4pHII76jQBTUJYL43AsAVmaBY7LD+edEboCIa015lEse6iNhWHM9Oiq7M+ai0KdGTEtaP+UJyvFLhMgURYpEsVasoi6eM+vaFXJ1LJvzVnI3EBU3eyAsuxJ+mpFFWRZXeffkc2tRdUr+7pmKpy6K2Lach/OyMXBTRUrfYmq3HmSumRRRpjIE1yjDlpyqCg/RwwAM/j1m4GSgnCK6XL+G2/wNS8CvvwxXkE2fvmyOcQnHlSbGrA4qWM4rWh04qYgKiiw9CyLsz1bunUlIMbfmYPysMtcTT9L7sCVCWrGEviOj9DXYfZOSMZpNQolDugV9VImEJ+rqfjVoQnPbrt6JB+lOFxVqE78c86uAXq/Xt/VIKiRWGNnyQGSoyfIwVCE45cagMul1G7iWDfWLEEaM86X7iFAlqndXeE/zPErbEbyNvOD0PN+e1rW2cFmgvdlczbNQmDMWI6ZANt1HJWnIREauehLWiaSODaIy+tx0JhklMK/SFqbCDJT1pnX3pgLiYhM2KESnNChSeXu/RaD3IPBlSEuo86ac3ZNC4omBp5pPYqE7Njy8aQij8Hvox/WlmkQwpq9dq1HgCSHPiQrcMB0WVE0ufLsQdSIjdyHcs+s1oxMDtbXUHjTc6S2lySSxG8aPwc42sq8CBzjGR5ahy6zd7Hdd8knYtB2yr7uZoIg20nU3BnUPr9tT7NrGFp0mQzsrQyYU8TFE1OcvtSKB8VuUWUuBwYdCBQJ4orkTnDvcJV6ZaqpQl27poyouxcDkQoeRnBmmv9zVTo3lSurIiozv4eIc0iy+X4yDQDdCr1RwXOevk5Ps2lGa7ubGXtqRYVZsRjXa1QEXq+KCbUfBrinnncwopTmrLeKDEgzFYYqGgW7ewbiyXR4sMGuTKg1Ew8VSEpkTjjUN9wJYs7Vxs26n12PmXT4KUjCKhQ+KtGMYaC+dVILB7aScFs7VSoeaiRNCqHA/zqda6JKz5cNZQ0ByqXqkQsHcrMOmz6BbK8xivIqJCa1E6quRhjKO317FB6t2PA8QbUdV7L3YaHfA8LM+Pc3Srw6CaThuEaHNkw+ErOMfwwudWwqRmGMW+cqvV6mdree5E+MQMaEX6+R1MJ16g58pQlczxAJunuL5vVzxskaunkecNeXhHUIqWd7ziXwU7zC7snj+D4aasTH0Ej5glrHyCQ4Hf0/ZrmDwL7Cg5VblDzIph0p8BNFFy+qOsfkgKh8DlqKq2FvbvkldfB44Ge3NGg4xYGYCKzwLl6qimJS7QZskkelo5jsPZQy6HuagZeqi53ORiEslr6vvWKZq52WfqMbR+WRxdmmJA6NEl+uJKhXeaZ0YP2RF3dSmQKNTt2zdFiFFDD52FJ6Mrv4gVpAeBSpbIwDSS1pH0Xctcar2IzJ36XHobG7oz784Wlu5oNsud/DbgyM9Xlo4DHbiEgNBxoeZjkQ1fKpVqqILzaoUMEcmYFhaDOonXvXXpjmJXyu8Jnz2QmbXj5pfc6yq7PW9k8geF0E8TTKMK5x6WGUs+uFb9OW6NqIKXJzvgToav2YnTjMOVBepVCwUSxpcIsD0dtEsQsBKC1sdyEfJFf9QzIv0eTjJQgyyHG9sAK23guOGjFUiX8XiR4Rmi4l/klxzlETvx4xG1Meg3DH6NT2a2SFlEkwVqeIC1Czc7JIFCihgwBZg4Bqrx8CmOvA6TDnq1GkySUXWR7R7RmdISVjROavBZLW1AVUwLEbR0v4PZhYVdZndhQt1Q4+xjYgjmrCGm55Wjev2NjlmtnGoeh4dzjnGfwPu44Uli6TUy4oz9iJERMDHRPnQ+0XRbVKJt3mAWX3qWEZUFkRRdHE8au7qT6Ezu/ExIKVUGJxCI145OOb8plAsWn3UQEtF8JC6aEAhXi77g+FrNc5egGacANYEqMmKTDvh4CRQ5RavmAbiFLoiG3ldNr15hCqSd87T8LhzsZ3rDj2pKw9cbtZCukRSErQSagolUGJyGOXe17Qy/XMcSdB5t/lhCfwcgBEpQ9ww8UIQJt5PsvSRyihCJhiM41D31S4/uc/rAPH1tD+8Am4H0ob3Dryo6zLAm5z4iQtT+YYUvZ5w+bsO3nKHEgXqaGrGlmeH829D80T2JWQ1+GCp5FCHR4H3wraicXzfboo3QXJeWn5rH0FKMcqhW+dIxbAJ4pUSHFBMT2q/8LXDfCOi+m1RgzdmDcaMGcwWEssSUy9oeQHqMrEQt1xLf90nU+txWhiG6+hDx1tRKQfBHE/n48gTuyhf4FdMOJcxKGrWMhKEzMytah7mg49q4kdVk2diuIQasayQuLkfKipwKjjL2eA3NeYtAZ7R0jM7Fqa/ZI+ElQeWJ6eQrJLAWnTqQYSVU4M+FwbnCM9HCAMrZQlgnz/BV0zjyCNOHZ0Wcr3Qh5/SlR7AemFhHyqpGJ0pKAjiNTGR41OeOxYlWsoB5mXbWWvkLrEG5AFJjI9Rz1BYBdgmfaTf6FHyYCtdfZMs0htltl9VZxsmflO2/NpklhEqmfDZZbjs0B7H/V06dvDGBESDXK1rncIVQGbPn/iwG+rNn40ATbGsHsX2xwLLim71fCWjaM1gHKeqScWBMOd3Ez1yfPCsdgBePlSY5xS+IlMXnYcIvOxTZ+0kzUeZP0ZyEww62bVoagk7NMo89OUMq17h0dwj8Hi208e3VqZMzc4zqhVs1zyQG6ePS6yTyjCRhfVgXKBbiqpoKG4M0iWIAmiGl2hwi1JezsHirB6yPLMoWi8FIan2KgU5RMr6+JDGXoVwr2YtVDq4gCmFUOlubNAXTFJJqRVM2rtyhxmkkkg4V9YZeotgkZAscnN4FAzJ++xRmDYHv+vb4PiMs2feSic2QVI0G2pTFlHOq+8NXzQXDpVvHlw9J5hl0GH2+rRTt1aka44PRxSQ095fmhGtIguOpFOHN7fla2F78HrOYR1f7jBAF6ZC83qFDIOPHddYiEWgxNHuUnEPB3npdypp10mzEX4WkVJQ1X6EMb0EQtGd1/SRfXj4bxhmbwbHd/Qh0eq8+iL4Nj17dqZQKWRMl2Bv2Bh3ukBTOFr8AZf6D3SQInPA7Gv7+oqjGIycXwVmn4Yur3rQws3kXfXo4kHKwiu2aB+jh63oJn6myOxkVZHFrP0yCGZqVBr+uJ5JJ/xG9/MXT3jWVyjtPnP+sNx+zGQJZuSKu5MpFRqexsFjVfewEUUQt61Iv6Eu0ZC5867kHshoKAu7Ze3VZYCjDpoaqnm3RAIPYb1Xbc2vh4EjXChZLIRRVpKL0AKmyYK+Ps5YHTQTXaxRwetq1uL+dnnWlhNAITOhNBWQgTiTbbogv6wMZhnwXS2YRku9CjtPfdao5xTiEnwro3jTnt88Aissqmnxm3khxCYASenH+8ZHXRWBgcUiUOBXd6Z8iWRFvMT24xxcvHpv18JbjJCr84u+ahWlltaAHWK3xeJighxd+kFh8h4zRJIGXtOPUuzmIrKDtXTvMmPCWp/yR5hJjDpKIXJKf0SHt1ICJSNxw+pmx0pOV9GbO2XIujHnfXBM2Rv/s2Jr+B7Ey1bvx0dF4qsyF1x+MyXjP2oYGAyf3MosXvlIxuhqZTPHcPDy7LkFYrTg8TXZ4achZuGxX0nxUM+2mT8Wq5MF5RneYOdj/Qgla89HcSifmA/gtVjiBySQyZ1bGFwuUuDJ8+IcCwbPTUaylVYUVDigGt7ocDEcZuHOlwVeByhNV5SGsc77MgsUtlo9N4S368vn3XAbPbRCQzDZ4JQhAlPG65w2SD3kOOUeCPMivjT9lLC0VFU02hrEWgwyPXGZMTgfLN6IU130pK9zKOh+fy83H/esXt/1EfhX630baazuHL3m95TLeLFeKQiLklUyyQOpwaYA8oIJ5HlhBV/l/flNcx7jDdGV9F1a+8261ZMvxdqLayoudru3TCyswDmKbbv2WbERcQvmc8BBT75y/XXSBH3180wjB0RxU8/jqqup1QVBPBB12zFpHb0MoBAbN1QGqvhwfC65sEHHoTl/2tA6HmELlou5M7wl2/qqaINmwhEJpF2K56Y4ImfBEloIGNdER3pvMfFnRythwKr25ga70PgW/Ipe/fNBtYUwzo8YZ0K2dIVWKg+vYXh5FCBwxNe+UyEqgsiapUVJ+NfTGdp4VxqnRq1Lp588Bda4El/aw58S3EIFu3qrqXxywbxRhuGKkEy9DQettKBkFBBhGioO+AYCQp33m+yQ+AgmTnMFSzlZkj5oGwveW9pV6RHFDcXqB3Ddzbjc9rpxqekwAYdRzqEvWNcKrXehU1lccU1JQPdwl9ZpbGtYkq3ov8H5ZIU1xsuE6jxTjFp7TtTR9WTQTXkuzwia90YkP3ohk3T4HRXlSiaOnz0CqaoaocNDyA6JGv6HJsoKU64gs8SQ8Hn1m5NWD9mPBpO+MPfzct5Hx/u0xP0QvWOrF4yVtH6uw8MsY2KRte6ufE0ioto+5UcOP7ETXcYXV36hVozt/7R903T0Mq6NU0HdJUF61eYQnZ654hIcGJk9OLezzJwy6ocTMgmdA5TBKwsfjIjT0n97Nf+cwEQSxu0ncL77Zm0lOyyT70cBIliU9MmlWSj1R1NdcZM9+KAH4aOYaMSBuAsUWlduFaIMsaeweJvHOotqLhDNYLm4V8rYld58qUDQ7HAscoS2Fq45uWoj/bIJVb9GfFIIIgq7hER2/g0U25zgBe8H4Mt9/UNrm0t1ZiylDOeEF/1mULiwmdW6nazLNM929IwV+K2/osN3jzpymrNSPaiQXmDbfZQbKk94Iw+jo6VjbTIGSzf0elJI60ROtBUvQySHXlTpdXCv56OPyPqIYNQKJW29M/z1aqej6XSyYjtXkA6pEg//vh1OoOs06Fk8GG3TT9qwb9E+PCFEzWs8MASytu62foNEW3M5ByN/gWxzUHSomfHc0JpYjgqimDsyVkXafdC6ZoOPaVU3LgjEp+hY/pVFX22hL7Wa7r2ILKSePY5EsgH5nE5EIwU/FOeh4wpLTYxvzC3PHsWcwUeJ9007zzjGYeKfjkvnehZSlSTQSQhZvdSHtAzpnoeJT2GhH+qxTwvOzCyv62QfmBSphhUSOtGpI64PqlUIWwsf1h1XhUb01dVdcPQR9fXGvWrOZa+jXCTcIFy0yjzjEjFZFVlu1Vn9R04z/UBOpaujFq9JYjkVfOM0BIlEkn6U6bB+hd2V4+ZFdWYXn/AObf/w2klPVdjQmgTU6TwRWEOUoaHVAC6rPKCgrksi8H7P5xxiWBINGnn8V1FRqiwR1oZZAwNlc85deLCaD/4UlJWLKlb3fgVpLYX0q4xHlURy6MhExK+IEALAag6ZhPMkB0m/HeJ8d6ZAo3ABDBebUVEEM0BrpYgCO97TNU6PvzOCmJ15l1s2JCwvazW/YMAb4kJVcd3DDV/gRCMCv6wbBBGHTtJHMSBk7E5o5QK6/+0G0vSDLJsP/9B4Hh58UIV9Z5DkmfmuvGJ00dGviQtG1zm0okO5SpxXo0CL5gLlxU6Wxc3wDxiYYovSmDqposle8xeGdV/5BTajpPgSfzhftsZL7HKHpszAVT8zt8DM82k40He2H4WG+2x6cgYgm/6DcYof4mM0z4mlBw55RyLhzTTwh2LiNpUIIx3bwInNSElhTIqNPMKaeNixhVJJHNp0eTrD7WvArYxkzXU2wlr28ikNUpBCdIHiCjrtAWREk1ZLfPf+4VocLBrWQJpqrGEe9TbxAcC8NB4SSHQUTElriBsBW8G2tv8IPK5iKd1Kveqm3LrtPfiUivX4zD9Q+9mlktgnt1MSVUQMQxG1LlxR560SZGToHGvimFvo6AHchghZU2w4DfRSii4ruSedbG0tzNhTiPFSc0/UZrf3Mpv0pcbuwbu4RUglg49XWzAXy52wRNK3PZ0L8/qegAOy6SokFi8Wz6IKZC2yzo2/GlsArhZOvE0e/I7YaJoePDNTb7adtvlEzmygMEb8F1rel40IBOApc4jy3ZkSR/QMZLTuOP1yzm15LwxkIsFL764uTOPrmlfaTK7j+LI/oHOWumYgqa1UGkr6JCrjDY8+ozin5O22RNBWDO03t/05I/aVyFesz2WTPnaDPH4qOlgo5zY/g9u5epdIggZJ1YvQj1dCh+B4vF4g2zkdRNO1CGdFnu4rvayBoRPkMYgSimDK5/Ed2fPW/9bO8pBRflRuezdoTM7q3sj3moNEiZ2QQOhvdAe/FjPCuGHOCJ+A1B0nX32NGTUFhYoia/Wqw1z/odKO7MwTFdVl2ZzX13i7RfVeZUUD8el086ytTAZSdWCgqLNU6XBJyFWFGy0OMGQ/I+WBq5jSkzsAx+pacu3hdo9PE1YYItoSSIyeuXQQl67GV1Wnf+If5zY7C2me8uR7GYaC5GSVywDo4N7UY9O30XR+PAUnMjUT0QG3XDysrEM7JmblvtZHB57lDlGYpUVieuFbuCVhPUgl+vis2vUoI2hxSG2mHStja0PECPHiU8mHJyisc/nfQhi/wT2UUZPlxHSJgBD4NxJxuuNf28vhJClcr2nh1feLsuIZ0hHBYSzsWQOdKO9c+npoMJ/ziD/poSucqYzdTc4K00r7VGlaadlxlr0Ulpy6+/ho4N8NPSV/JHFM7mUWQz01kEOEJe2XRKHrWS5B+ZqfXsr6nMhRxUd9SKxO/zCRJckOCHEG6aZY0SaH0u5UL9lCDw5/Uo90S1xcLTuIuH8kvEWeovIrGxhJxWrjCKTURfQX6esIDwFpqTNBenH317+o+rvrnM8H8qpA5q2w3HMZhRIWa0pZjJV0yG+3nxjlHxhevOcck/Sdtw9D6fYGN1thZEfqF1fiYIPnbS6Mlf9c9qmc7O3rn6MlRkTDGdV4mrCPmxbETdGhTwv+gWff4NvraaW5MKWPYBNxuX0sc2bQEN2aDJUCQoS64t5s0NtF0UCz6rJ7YCl4GMh7wk2nnfslDY+dktvjkcePbIcEIcLSy89u2SX1kJxCfKyWdJcAaCYvSm8cHGnMkBAr2UwJ1/frcVYH4W3ULYHFpptY669Yy+9W0humpHtmJVwf+AgVFViZAITjh+A960IrVjJ+6se8AWvJhAM6KGEeIrL2NEz77RbcP+MXl8HcmXS24dFxEvn9wZHBgRPS35RbRP2vYhbnKxyR3BUt63AuC30Hb5quVs+zDdHdKXVST39e8jxikSAV3akScQTkmuA1TfSq8q6GO2avooTiqeZldpZYS1TEgPu7EFZcosGLRi7uMXINj2VsPmnzDLxIrsqptmYuWJHc0Dvc4+X4mHvDhdgwk117rmO0+PnJ+NCfTqus36onSBaFFksBVSbjrPX6hlJs+AKn27P2NbO2pf63iBPfNZJ216172kiFRbERNK05fC2HDN7GrZwzkR5qOTYGW/IqV+3TkWPlVFu5n2RiIRh6/uSDc70MlOF8bMZD3TRftcF4QMr3fiuFZeFXsqr9ums7fpZs8jr4fNgIlTBKBv2SLx2jyxA5MrrIZneAQaZWTZAKK5cRnIVZuBkNoQO6CFFTAuR5lbztsOuBRgZ/P/R4gIUZgqdSicmHBb1QVlWZuaunsmwSBDi7FpJeny4iymR+XwXbTY105SnIhsKbv/Hh4PBp6vDjZbcAS3wiTLZyJ7X7bZYgNaitVACIgtYjPO8EOkU07x0CHYd4zqBO1BdM7JlVL1dpZauEeslkEk7XiLARQ5odyNRWRYQNCeNHfB996ZOsbLOsTzyUReObLulCT+QKvJNo78VHZUBIxn0SjUl/mEeFrJJVsCRb6Lr5uGk93omOxhq9ILhc8q+4jZDotNn0IpXwIBOhSb3SYqBoc2IW1UWkF4MKYF8wg2/MLTuGIg3tioPumTRkdlCQzRMfT+Mwy8Y9qk5KkGrBpp43XdGfOvGL2pJ39yRO2MiMetdNWu9DxqyoOFypVWldJRm4fXzs08d74fEU2yrb+ywjzXstB0aGYdutnxz1JonI3rZFtl/wTyvowFORgUjzGIWrFrE3mLvNFXXV1pq20iaqvtePrtWz4FSGnNeBGv4iyPme/TgRfdKDl1o4FVDjuygI5w8cruLyMsyl1zgEi2lC3KzNS+uOkRIMc4pVLaYMczVnIWSQMOgSuuLz8HhfvjrfSTeCvK1pSLvqEDFfood8dSU9GNN603RbeiGKZUEVDeXwZ6Gs9EXXYzggLbkLnZRcdSYxr+37grF0iGjTDlppKmJt4nLjR3lhI4ka6mRldjGjuNmNxFiFDq1jjZPJLD1R3BP8WjQbjGISuf/oSqeGfL/LHlvzwWp7kAZum5D7uEE7EGljp9QDamUccpKRCKl0ovVcC0aqbVTYMPSutlQVU2oxGUXkk8s6zAaOmSecvGL4VfKHx1xUX0NzMPG1ziF77IyXf2Co9mUP9rSzEX6641VxCNI7j/7QGenCDnFBvuGUtwPDhO35iMjTPg+M9O0H07T4Qa/dckgiz0Un16Q9g7hIvmFhVZsxJkx3kO1kPaLAoktWMfXS2g3DRg8TkqM+3pQ3ICGFZEBP9YI91USXjsIsuQlcYKh4brGqVwsXwSMqMqE40/6mFpOflbahIWNqZI76fXWImGLhc9uEKSA4KSUREhOtuvwal+3H+upm2SPFHXsUlcWBrL6cbOLmZuRRg8pbrDl9lvKyMb0hjNyTUpQyzhWEdcIozjfkcNNtUw+3pad4pCsnggwalYqRbZDCoGJkWswr40QQNCKbPAPEB4TcgAiOuDrpsTS9mNAfU7BxYIkoXjqKpE7tySpPWMHAStWR6ecyJUsX5RPW253s22UoFmVcd8F/iob1Xjzsxh3Nw+W4idlEMkL281r/pFunk+QZ5lbZOUNp22G/2yo2Fuaob6nT0h//4Wd/vEaDZHcjhO7v2ri3Y017kDTc0l+RVKkyc+QsuYepEHbR6lxLj0yKo06remRDtVAOSkfL+ZH83jf5o2k7QkxVERAHX5tT+53TwvufVvMAqmEodzrcnTZzI33mZWhZJZ1VYlxfO1juU5slnfMwaBwuIQ0nDVbkO9RGFwsCi1xVqY+O5CWhvzarCaZrm1gIYXlol64h0MqCxeJr+ooT2z6T13B/TxNBfTt8frfCkGeeMhbqvKX810aVl7sj/A2J41mQFDP8OkRqUnDOIZFdkiIkno2ArjgUn7H9Wkd6nf8xI20JOtHoOJTC57OCZreeDvbrPFmwYDnyzErQzHg4vYpXn6yEDP2xY43UQY+TwL0eazgyye2Id88ZMyMVabVIQzsbkWCyekhuSUpFC4cyPOIgMj8Bsm8z/gzNhJuQKK67tltn38EYu7HWWSI3e/RBQdD12P5edfpOAq2SkTThWhlY7DixDp6eBkamfvlmrBXAtFf0ChtJaXANCGu4kflOXmwYf5fk5DMs/LiYRum4OQyZgm4WwyBITfq/xauzoOCybT8SErMZfJTnnz9QVe16910aIe8HmYsUWCVJso6Qik/h34pymVkJ3fOzg6GiC3GX9QU0+IjE8JhOf0iEjSgruT6FwtLriNO1zQSYAgdxEqA7CPJ6qQarQbRraxigiGprQxDkJRYciyIytl7a4rCAjsNsptGSK1r4hsn7Hamj/QH3eSQ1P7xrRXKIMPUX6apJC0HMFSkFQjlrfgbdDVmT8hHniizmtiiwNHRy7diQLA/1PBnTOjczKvgaFMbZU5yl1yVMHuRFtjRYabGT8ZuZ4uGq16BvEzNmNlIzGVbjmgFgu/nBrkjLU852HsIvB0Z4LDz5rkZhUSaArbCimbHzBikHiNDpd5gYrtl01jQxCx7llPV3eXJzUriksbKhokjY6TNcpMpSO/JiqBzt8JQzg0g6io0OGUe0kWUYykVdck9AHX3WKK7KWWBRWv0ZtsOqBp2rs7JwiwR5idx+WN+dN+AQt0n2zYjg+rMBd/lOImkqLfZQMPtIJVMOWaXwYGo7SrVlzx+iHyNTnJR8xqoZnbnKKzBW3y8wNPO6SiINRH6ND/fLYdTX2eKHrfss0ZOYVkUut+c46YkqWjQWs3EG44/GfzkDtWz6iOKry/UARpC+Co96ZPfu6O/sc/kwkm6jj2x7jgr0zpilfmX81sq8jtYuDST0t96NZpiBsqiw4R56VK/yCKxXg8HGUM0Yht/UloPB0FeHuQdBQnpYHrzqFTELW4YiPjK90/2dQDK2T1evtgRI4yAyUcGiUt2IWkTFh3R4n9LHfi2RLcD60NqAN8ni2QPcfMHN+IMtmsVWkLWwv8idUrQ8Ypz0CrKv09xCaNxDNxTZtlkv6KK2cPReczYUWxZpmRGYG1ZI7+Jx/tCX5RVlHO47H2RILexTLQKwdnIja08MZx6/Zn0aXOvMjToDMFqGkqmYyINPktuSQoC1kndSAkl8dLt/F6zFffvOJl2UdVY1LGmm6WQh2EpTZRLxl0iFq4fdMwZNpXBxS3YoER/39g2d3uOaqUtZCTH9y8XENAzBa9sQUaUk48UVBWPVlVPyjQmBYATtaCQGywskrGPpZJaM8WGWZ62sum12iO8DZiJrVJXPksb3grt3IHINXZHdvRGHOxUWnKp5S7wn9eoOmmdK2Ipj5cQeq8b4J70zrOL79ThvUv7alw/jyeiDHu7csOJx6akEpgCJVDUVt4Ef1C/RCzpObgUFgQbf2VnBNhhWWSKIBpZS1xb+m/NH2eqRXfux6T66M9nOUv70oPD2SZXlFzOLt0o2bBrCIkKs4S1SHF+Y8M3cimcpZqaSTyCi5HyGUJiFky4Ibp6b+DkIW6FaXq6aBRVHXlB4nDjNXMiYd4uZdzBIJMtFVKc1yqp1z8RHBWLa9qPuPliFB/txCNvp0J8MEpLV6HAHRqfNgdhTV1pJTGLIg0FyzkFZjEo0UZZcssx0PU8vdjlgYBjUIjVH17mS1Tms1iG6rRxyYODatTEUMo+mnZGgz+Rhs5CdxreA0R2Hd2o5o8sLujjFeqjRtedVg3NfXJntwuOPOehsf9bGDIsdga/JpKzUl6tymzZ6y7oSnw3Yj2vqryEzvduM6/ZHXfGzRRYR9DbhM42zvJkp5ZhhAa2d/HLJ2mJiHrSmfCrZwHNicgYAI4h4MjV1L8FdNo5JxZAyymO/80jvRRKZK/7qTHJLNbG/IUTKJFeAbiz0ZKx8s1nKOMl6CFLbs+7CESo9z8lK2makW7lg7/6VfGnOXQ4PD3s3QEDVvWfrkY/pkSexG0fw9G4AcberHhQUJAFdkB1Vhkn8S0/s9BGpnQQvamiRArr2w7Mk05Ctm4ZsUdY/HSJ9g0RraIw9yMWuVY/XUZYTZ1ruSOwq5vULlh7co1stYzvVcktGYacHNZXmtPSd7AB1iuVhJ02SAaK2YL/hAjnOSujt2asqxAlKcFhF8AgwtgxXvQiWyx9kbuw7VHEOfNkO0Jpj31RQ7bDQ/oN/uFVSKbNICWdtGpH80ci5nfETugtYKoY70yN/ZHwG8tu3imTn5+X3dIWBb6EICSuouHRIpUkH6ulOmG4ys2RHReO9DjXUktbtoazycezKm2sCk17QatdQK6t6fs5bHMeaBH4fHv/h6Ng+hxpNIDcRso21gi6YLR06JfgRejWVdfLjRO/nloy2mMjFXCeMkW2tsaqAr3c2sLBqZAdjCQHLi+XhaqH3azc/hmeJ0jGAC+ESYcByKRuLLB03c9IpCopYVXHTqJJPuvNW+fcviI5tjNxUvn0OidgRK7c9q1UCruvSKgN7S0vWXuID1kvsDz9HTBeWZkZUI5mwAB8KD5qXqD6iQAyYpGimzKLW+bqhXlrWNj19mERyMGYAiy91WKU69cOM9THv5mAlJTlbthVI4mYW/R9qzN+dgJQhkn9DNpkznr/KMbgWwjYx1BPKw7k5yAT+XRrRL/ZiwYOMc7pwEhGyQgC3kO4Ft7qhfw5tXgrpylkTTduT80twZkuk+dIZg0Xo6u8yQsr0xDV6EIwFXC6BM4qRSpYOquGr4L/SorWP1HT+ASGyjZA8TOugvjSHYOg6+0ad1bFO40KT1qH2naCGiwwT3fQrPFcUIg1aYDEOClkpo80zulzTL9sE7xwdJVfO1XHmnoAsD2ulHRLzj4tOZjdCBpmFwp6zsfYsLJCapLBZn7K/788GgN5fAzl0cg3DykWMCSFk29gytDOMzwO0SsiWadnHdOk6Q14sftcwxE6y9f5bj/h6uY77bI9PE2cvau2nAGKYnkFYUEqhtX+crT1eTb+y1RpVRnqKqG1QfnaVEdmD2sXQpE0ff2V4dHVfnSkrEwsrRarqwV/rfMq0/kXLW3LF1Ck5HTM9+MamVZYl2Bjl5XsaKo5zZZBiSV7Hj2gq7qXiWMkrQOJS8l08w6PeT6TKlEmQ6QBklMDUAnjjoGAv416OEHmbV/7G+HiIUbfiR6ymq6HniLEyLEy5GHe583qJuGGU6yikipzrQ9bCsLN+J2v/SepZXjvpXHWSHdpxqFZJWXSF50UGVyruu2X3VIcVgIjgiGzzvv8vCoCXebqBOoyq0ryLj+329z8jiZRwRIdmpXIoN90W2hAF7iNNkfS3FgXrjYO4VCpjKcoWdHm65Si/FIMKYQjU5NQhredy6IMQEcHmUBZlpbWUBXNa5ykZcWhdKY44o3zwKdzAAuhiRV0jy0DoxILKwVoHXn1rdNxb5n5XL1KtuzR4HXv2qhUFGEmvJcpKC4EWlBZq/vwmuadN60S8kEce+TjO36FaQndqh8sumjJSAcSMFnWdWDJgaxnJJXo46g499ygKpGhcOoetQo6a7b3YTzPIfjrYnlx+7WanV5eid3omSx7uN2aR4o6z1sKBfYQ0SkFl8cHNK83ip9AL2VytJhQuTtx2MndWDCUA66s6/dovLPi4sFpYXBkzQYCZurl4IpfbwZJpCDrTV7E3LE93lc4FacbDpVeIuFZEg+5tSmgjuxbfNhq3X1iZnRQI7uYNS87hu7MIe4Z+VSqXEcLWVIyFiKwVC7j+CIwoS+DPv9dOSeTcxtwsNTtMZhJOsnbNMhEf6fCTe5g92HOkSVaQKMUCZXXCIdtOBlYr57pWJtYJ/rVmhZn7PcvkEMJO3pm3Ffr3xMcXz/rXlxL5bGDCem7Sr1tGO7xwvYycKcwq3NcK0qjJCl7ib5dIbwKa55OEVcOP2cpfvrcMgBYPKL5AyL4IiHQnY5NAihqFiVDDojYrN6LrrcvKTo3ar3t8rfRbtWZ83gvy3nIYtxf4t1RLXwmSFp0m2xxiWyDcj54qoMVUoiAXWQylNUUVnVU3mXQWvayvSrMgDtK2lUZww8Vq+A9qvsJEXVMndSWNYkQQ8cCxToa8+knpQVVs49lF+nWS1ErJqfQZsUNueKcMZztp268N7L4YJJ8LlGeDzy6HsAB72CbZwLVVrJejgOgLG7HksW6WjVgZMd2CmQmv/g5vrj55VRddZI38rkvtyLFKhIcO84+w/oSkOse1gsXY9+QXMppTUpnsyeOEzOUf60qUxTu5w6+69oOfLK9+EAb+RJTcJ5FNDilLg7x+WEHATBSTRAUaRa/saBNqRuasALlBFlAGlJyn1Xc0+6EwO0wJXjT4qAbKKhD14aE6ZrBiHjK5a+V4CR16RlqCnw6rd5LcvLvN0y9nHp+cnf+BIcm7QcIn1rus4d5+WYaRFtuwSqzaQN88Ac334IjdhlXub0XNj0MOI+Oeirg/rUT0UlI8XjkHZYbF3MtD6ZziQFylmY8TFyNlATlpxOlovXUNOL8CYYQeLY6sMjcsUZi+PyffzBLvg6s/kErIT4VI0ff1lkKszrUfNZRXFatuo3oTgxBWGrmwsZrKpZ/rdUYzb87NPc5WBjGFHabaD3orj/TqZNKm5dl6z38voDGEjktUF59YaFq91laFwqY/f4zu8u/IHvaJp9UMItJfdjbWRYQQ2cHoxjoijbtY+fM4rWWy0kJtfk5haJgLcit8+k7vtkuJnsBk8/rGYfYf/lkPSUf1FNaTMU+5b28xFVW+liUpYcgMfW+f5T1hWflutg145QTU9ZfFjfoZ9Oo/QkB5HJR8r1VviIjdbHC1IQupCamiCkV/xTEIFxS416h0fnO7gQJWphN7t+A+g7lxe5nILtGG4Fq+hNgdnyv501NqNz1k0Zgw7zbJgnBh90BDVcoyVgKFvwqtlzh5Jz7+Ednj3cCsaVdtlRX6EBbdA5MAmbtqk6SPVZUyi25TwwpZCrruR1zdNL98wFKCKgldVMBowbzw+FPkgNQXBgtCTxgLscTUs1SWuFFxrqHPRShGBazYTIcGpEy/3OO7t2yovzd7vNu113tgDwYixXvNrjLzUh/qL91Ys1s/mTIv+zeBJBVqZ7gdaWO9HiBsK5n3KlbkTobZQrFmxAxK2xLSX1JUh78kXr/5WDpcu2Bxckn6vDbSsRHtvcsAxVIc7xfKm0Dhu5fzX51GrLnYtsAWexELbdTp3VpSz1DedUEZap1sGVtcD4hlP0X2F5zqgZ6mOl4IKKjzJiGHRXdntBVpa3yqRGFtsM3EBBU3xnAM4fKAk7eLw9PcRHTEKlahVgCN+/7j3aP/d7Df+XYks0om7L8pKiwUlxLFCIb7mUUQy6VfVs+3YhRIQ4s/q4jaMuQIbp8Mk5OwUWiNXrMz9Jy1IpII2XAqqtR4ZFh2yfrEhYdOMq4y57Pi5/Q1KUfN7er5Rn3f3PQf/JG7+z+ZRPaNSFdRsR1icONS5TgREiwMgcY8NQ4rgRk9KS5iZGo3RUkYUtYotLsW6GFmPAhPRGE13+mv7xy+U/6K7DbyaNkmcM3Y/V2DsgxQOlxYDC1KWTZYl/VFhN3sZ/7d8fGJ5/s4QuxJhHBb3IY8NMwqunqrkyCH2uuhr2qMifrHBO+GLJDJvmcSPMwrn3pr3uJliuCEvIKLwEurdXXiQlVYKmA235H0Um7Moq0NWOK/5HbO8YCg9FeXV+9VhJ+IEFZ7lu2so/X6YNKUjXfwMJH7MTU51MyRrdPTVY64IcUuDCEmBU60IchjOeM29wiofk1WMFnGRK5aFGqfqwxN1iZ17jUe+V0I73CNvNXPrlGA4j84fTx/RreaXxsWb9PlN5gWkxijsVFParSBLBlXZ9dKVqDoHPcj1BpL29R7xDEIShziW+Wp6SgKPu+Yg0qYKEv6yp0OT/FtFAWSaB9Y+UPe3PvsrXE28fH4kPzd6ePxk+IDkdHdOCQcbbZyoH3fHyS4GGVqbhhCy1apmub7Z+g9qb2sHFZeQOGgc3iNn/4CQrGIGqjotIqQXjzcJXZfb8nmYQWLRZkIfVvnjR5Ltu0p4CeP+98q3fBeEmElC3Vj9Lb9UZFEG6NGaBEjpiCy8qXFGDEqfeXEiJpWDnRYHTJ7GPu8zI/V3chBHbGiyzCTvkJjBqqpFmK6jbNGPCtGVy3JOKy0MmYD/+4EYdr4kNeU/9z4+Gxmo7X4ftuGlKS2aD5WEpSicwDqTE8NBi8vGrMWwr2eTAJXp+FMpRiG5STJi4uF9EbjWgRmFM5CmPc7NdLqrAYVvoA1Dd6NrKpdf9geLNkoodlOquNTx/3vlv7hO0+/zCFto17p4FdT3UqJK+iAMvWYvfQGC36dzq3ZNEgIjN+auupV5GF2uDkkwu9aSARbuTts82tbExZlmYQXcO1JJUN5Ium8Z55VdqqoKAt8dLz5jzn7T+OXb8RQWWXtIoSp4NkxEThqLdL6RI9FpGfJdxL3tFfHDWHyZl5Z6RCioC9fSeCUMTmKk3blEOg1H44Y8tvAkfwImMUjGbTALCbiIPLamnpsG4u2Adlagfw72vM3s8j7EXJDwNJY8SkE2e+2IK+TTXHMyw3Q38c6Ys+uH2ByNYkNNwqdg3PX6YgTwvPCHq62kt7e3xQwcWy2NH7xFiH30q7FIn2h7K0aQCwn6ps46qSg2PWs//Tw+GSE8DEKvnktir03K42ORvlATGQLesoInUIiGBw4Z/itTYqoOYI1nZ7zNFiYWh/nR337jto3VFQX/RMNUJrlIWKuVBmbE2OxQtl14EWHTtvsoPOWQMLP9B//mArsLpA3dWUDkLeKXgUbPtbNlVsYk6vNCicozoTi5gzthHd5KiV2dI2V+p3wQ/UjsTpIwoDUAbEW+UB1VCrlw9yBpMxqjaSyzx0sPORD2t4My9mc7s/lj39SK/L2p7mNEGZlVi+byWoYsvPq6gqBdO/5rRDOLgDTKzPgBOf602xqROGnT34rII+X1AkNW6OmoI2ICkUi0zln2nvpenZVimGy6Gp6H+upVlUm36jRbqLnXxAftxHPm1+eDx4VfbCxKLKsnG+RWdmT5uHdJcIO22gQzS5iuIdD+Ssh/BJ0PcQhH7meFBxuWwkoDGSvLg0vJwW0Gqro3iMtl0nbxlz9hNE4u36CfYFguwbkXx0fn0gizTikF9VjlJIrOT+b708A6FAYaPmsy3ZuLTywMKlreUS3VnxBBykH+Zolvv51vDhcIS8wFe/QNDcMVkwdnuhHkQkcRGvOzmXkEzI7i4Fhb5nwoAH5t8fHGxFCPomQIghoWyiw0nsni/eu0BSVz1U0SdlVjBbphSCE45gwTZgJnp8+4qjGamWKIHgPK3dfwYiKsyGcTfW5Nc8kN6+qbXWtCtSx+OpStyE3kv/W+Hgnh5QrNHXdVHCyCvikX3clrVHd5bY2fNAw8vY2LAptvfnPOUi+LiLtD0UpmYCLCsGw4uVhlshGMRIn6wNdn/DmdiOfxMc3o0Lf1TZwKY1+y4/8bITsUsi2yWcgx3kf8mUtVt15RfPCCBRX/mvlXtBi2F5nGcv1EhZZjstiAyfMq7WK2ukg24yAo7w9EM91WOSKNwULdR02u0qlNkYW+9ncVLuj8hZ+9ZPh4XxCsv1koVb5Z/qQ7dIlizZEH6NUSKvyFLXfZIdzVUglskrKbAzgaVGR/VW8ppPeSxzO5znBY9DFxrV86Ecl5YOrHYLPWqPpnN2OFKId6WYDvQaES8xkg/C+VV/xJ1PGg5HF13wQ+LQP2UXIbeIo7vZRok10W9qskN5mOJCRm/tBpVnecr+j4vG4JpFIJg+ekxUzVl61LRqA6c8+endu7k5Aqw4neODervZRA/LG6f+x9PGGntYPprAO6uddNmZ/zK7qpip9zNpWsItIapXTCq1470M/tUkyu8gY7Np2OorJgktxkIkHxTeqnkFwt1bMFkhk3AqurDZr0qW7mXaOXP1FyU8doO/uNX4qmj4fXb0IdSewOf+LRMlisM51LUpJGC2J9E5ovVinYEMIIMP8oxje6JPEsrw9Ljip8+vDnGLUn2ehuBJOM4runZG8yFwttXtlzRB8g2CxeYH4Zv/Bn4iOz971n30y/EwbsvvsdrJYDXZRMuNCA5Fpj1IBsDI38BnLpQtxERe2ephFY3YFV9tynEEAbcJDW2CtgRkCLFcZkg4Pm63nr9cPaiCMsbOxAF1P1eHiVbptQN7MH99e2nxJppSftpziw1+SfXFe+MlmDmkNZOUuJAEw5dyXRW1AYqnJzWZ6zJ4nYWNwHTdYVCuBIMPj5XYL6c8JZLmUvP+B0JVV3Vk1bVA/UJY0xShvwiJHWVGF1fB904DwixjPlwurn0duv/ZNt6sEYrHUv+55N7EybI7UbGZoMiGkYDwU9O0OVjaBu4pdHc/ak/qyGLAji8HR0xfPEYUSeR1oRu/fbsHMIKlbAfISkVtgNw6PeAe53+KT/Q+7Pzbfmz6+79H4FbXRR5/cIVnsKhxWI6nX/46N7NbmnYotw9RgwKZNj45idKoTK7xgQGncc4pXs0OC6BEDxDEhLXmxyzrw+a8RgC1qmWiV3MPIvlXcHTF2rf8bZ5Tff1P/RGVV/R4/FiH3RVbbhlQsYKSuxG08sLYxD9EmMjpc1YVTci8k7ViqETojS5IoMCQufxD55vRE9TmkMY6bpbP2DArLTbBaeZG6Wl/oCrPIxVlNhQ8KrLeOPb/vuv8JkPb9x+Rnv2wzOGA7V2RVD28qXFIFhk6a6yiWUpV9xXIiX7MwKJYKAJAIxTjJihWskF4HutIZE85j3eyyPK4lWC5OcawlLZWSxZ0PLR8WWO8AWN9zpp/MAf/cn3f0fLbjwqIfLGiM3lPHLHmWs8wZePZrJHiTSN3yEiFxXUjGnC22CkeAgnGzQhEAqLM7QTUhzXsvsCgnZlGK+m5UtXc4uHn/+chq7IfO4w+Hxh/JIRsOY/4UchGGTOYDGzgsj0KiidKG+sJeq9wiCUzfn3Vdc8G87FpVNjdC4TOFVJpl2iOrwt8nI1oBTqOQVyE7LJd3F14dHz+YPz5rbP7jIcKvfim7ijt9WK+nOJWKktDacLRvW/BnVmz4krpyngbV2dPZ4onnDvcjDm9VxSAYdH1Da4XNNdbUW7K0Lfevz0h7T9yCNIUpt/+Swf2reNe1/6Sf+Z/MUt8WIRHVLGLhKe7VAO5skSsWAtXGMiazevzl50MpaSlFPKxaLUT5Ahz6w9Eu5asfdIEGbIElZMArSBOT9a/qC8oSLVcdlwJpe9KA/Ez++IvNbr/YqZdFVu1IWauI5wqF+UwZFJmtX9LaHQpFb6rokdec8vY3Z81yZpeDPSkAvr4CQiMUAFinDWSVKJarsBBP7UTt6HDhWqa6ucE+IbHAbz1Df0N0fOL58vGnttbQG6NKfZvZ1luVxC3zui4sbzt56UPeQNWCYpnU8J6juAYQh8beQL1A6wculb6jGuyKww6jym5Jwwr8seglVGjdt607d1LiZbHFb4+Pv9/q9r0qyyohpgahLRtZ1sBKPuOFGNbaeCqUrxybqZzVlxUEtVMBFv9JChdeTXrobNSEMKW9EUKPjIp4Mve3MLxJLyjcDRNdR6oxaQqOKj5u7r0fjY//LJb7XnDy8VexSQ1vQWDsqSlVjVU8IMSTs/9d0P1c2nAmbVaJ6V5H8NTFcguFcNqNs5eR3UYZaga/0KKfD5hb0gXiVfBt9sxmUTb2WlbNa1PdHz8ZH/9Ip9tv+YGNFHIVUkx8xFJ6M6tncvoIWOWhs0YbcYhP30izAQXORgKr0HIlVjNl9pL0QhXAgzIVTs6NZeb29wFpSaCSxUBvp1PSeHzwbdmST56zv8Tp9rvbkF0Nte4uxs673TOQC3UlhEuhwN3Y0u5qA7s0q8PbjnxYXlECfZMS9eW6wBdR6kBV/2c0aCbvWj6hYrqzAY6gyi9eIRJ1Ntg7wEcPheqM8t3u85Px8dcMyvkDX7rzU0fdF7LlkTLq1dSer+kc+hJnFUKzL0ZlYBOKt1eeuLbHF0oUvEPOQeFwnGAGffiMLqCQzyOL4XtOpOjQQcFro+9h32qJumqF3fb/4I/Fh/01f74lQjYLobVTUX7FWyDLFyji2Bd2qSt9Om2kJ3oFVFcVnRh14I9zTEoLOJyx+jq+LoNc4Rf5uZijdizrqoVNzcKtMNS0jDiot4Qj78OK9XJYsr59NOzbFFj8scP+d2m985sfhLZtKuwhyGVNFd99iBtHcs9TEYmnglPld9kLzZTXKR5yM5MvNi9rfz/WGvd57xcUiWD/xND1B3z0huZNc+Z0wW6ITn4FwXrfaOpv05LjN1OVeQMK89lbWtGulFvEyjVXb3HfvyuXPTyN4GgYAwhJdtdHEmA8RJihkSBSWaHmRWAhlVrpOBVSKJnZybIlN119bAVL7XGH/l3x8Q/3onpcZ26HIeFTVxVjVi9Ab3RQNphw1BPUMmp4L5yqk0GMI6SaZZ21C8XKFMxS2TNWeUG5KCEBcSeXo0ACnXh3dQWhg6+63u/u6vsR/OpvDY/vyCEPiqy9Qmmv+JTlbotLOgcJKhwHaiHeanIOfQjKY57PCB4bOqLYPDyW5ZeX6peLWukFiaGlKOqfEh8h6WoYarvqbH/B8f0C60cYTf/YRuRpkZVSCHmX2+Oxp2162ChgW5qOk9g8QcRSiLYjd3EZ6Ph4ZHcVTenLQohFXHhdWQhriDeVm/DkvDMidR3nn41e8Gda+X9ffPwcJNGnEGyjB9bQQGjZvrBKKVS1xVJX3qvFiTipNeJWhSPUdd0fTuPnOo5IUhWoKqwiBcLCcIZeGGtXBFSjlLyW+KAPZN8W/siJ/9u7jy9HyCNLi+4Lilyuzbg6zTLPAhD9Li1sCDGK9bIDECiKiAw/ppnlHfkOV7zaqT2M5mVRKSNoK03bujGL2Pz5w7tzGMlzbPSUuekg+YVb8x+XPt6K4CcRwieg4/Yrn3G3alzVXXhIZwLctUJ4EMf6wUsw8fB413VEOXv11jQ2PlYQnHSs4fhGzUQ3HLQB0Stq9kpw0233dhBvdfX/AnP0n8xH3HcUAaYsHQqEnJ39vnmdwvgYTuqnQs3YXMJW6hzAhklTAs5Z+eJz4eiWnFbJ5ZqSwe5JqRgQN89z+B2vgrv8wDiwDtuWCfFUB+j9+PhnoLvfuha1FRpNCKwXfjJHS0J9Y9fTc1QgQLRYXxcslDA1mt9qZBXr+UzcZw7TnxHXszAzQ9OABT8TVXxkAwJ3ca16chUz+EvHgN9cYP1Tcs03YttbNXI+q6n4HKGv+e9JzQOePdL2qiwmYlQtKkDgBHtRTVbnwOXahs2rg3Lqo/Cuws3VDha3HQMr9KskTVvehGKdQPC9h/6fU4vxW7+9TyHYDBYrbnuxCxdaTiqBpPA9Zsg9iAaYpXPlRKkAMqFpC66aGaTz7KPXS7gO2ChfoRkU0+xHQbfcYj94E/tLqVRbfN4W8r8oPt5Zi3qzT+cNmsV2jpZuwxLYFS1OLhi1Ent3acd/bOkhsK7EnYMPB+CKJ/IlPXq1GqsiEqR3rkOx4yIWvp8lVsWbhpnNtUNUVqRvC47yvzU+vrlb2tkd9N5ID6wluKmzmKbQsYdp5uissCzAee4iWKK50TmP3ZMioz8b4tTmBjliVVi5ujE7AXdj+93L/ai9/GY24b8S6/rWFLJ9twrnyVQZFCKnhYA8M1CEJD0fV08cwdAhAShA4YPS68hTQriCxGWk36ti4ieTabfL77BUTtH766dX+MuQednvffnU899z+L+pnec2nqJoCW7c65m5WPHrNLZa75hGyYFUEwY2ZjLOBpoUytSrUffZJvEztQXRgw02tKv8O7kVXpTHWzNZD77vaVq3OYf/5vj4YoQ8TSGNDyi7EsN6dDejvYUMStnLdD1ADYmtQR68LM9pW3toFccqx9VCFIhKisiYRnWnpy8jy8ab25ed/QbCp2cdeHzU/pn1Ff/Aw7/NbHkiFhDwngb2ZFX3yOFk5X55vfmIRiCgGXCUB4QoMNM5xlyIwCUYDyaf21GEd7kAIwBGr2xS/Fq4L5z5hw7Hvz9CWoGYm1xQWEoyasnmB0CyZitwKgWG4GuRoumfxV09fCDh15euvn0cYtkDFBZCs4ZC/pUZcN/SAEVljMpWrNlb51MQqhvdv3NPPS7A+V8ZRI8/0dN8uH93WOcIdnmntl1gFjOZd/6r7hgrxKAhBzD64R61rTqjd24dzslMCy5j0eLSlMpiF7NIlnqujYsouUsv7yv98Oev4X9CCnlWofZtesMv7B6fVs2Re1UDsnln2RfLerRPwXcvpVCJFJ1jxKP7naGtRbLXtOCHGEDcpC3f78dejxD6E7kFiEKQsrtA/isR2j8aIW2X/LS/Z1LE6m5i0xOyC0pzLL8KIo0ljtMzLfDds846JB4ixoaChFko85ZzbjjXxORV5xXu640n3N1XD97OjfDG39rp/sVtyCMZ17ZE5s17WHqIkw4SjUeP0rLI4cr6bZhRgxNvxSpBQLiA8SUKXZMONDG+jjRmv6Gbi3nzJTwGERwnKk47In7H3JNtaq73PDm/eHH+V4bIneSxdZjmrf0Og0dljWEtoIhMFTrvahYmF2m0T+eik7gMMpuOqOvjt23vXmOE84sn7wqKZeaSR9/XabzpFp/w3P9b6i7i+6+KforbOunUEhws65jmpzHwOUpB6nWM07ethEBcSj+52DuaZJWCbLY0G7n1eCTZ/G7sFcPKpPwMYcemzbuH2v8rCqxv+xXeU1FqapMbK2qgR7YCLUtXcSm9jSC7aAvw6QQoa3luDlKRwbEG5MmHcesQvMcEKXq7V06T/KjLySDrjlyGQH/gVP8r0szn8bzPqggxkEs2TXdY9WaHSWlHDVoSzEIxwbOg2KsLVwh9Ow2k90kv/HxR/VIiC1qUnyUAzvs6B8EhuH5T+JTk/niX+r+oAfnOKLvhT2/ZIywwy/J1htzOqtVA7k+e3uxJ3W1VVCi0CZeqiX6YbZSXpT8jvPrCG4C8wY9eFJQ3ewV9ZnpCqeafu3r/7Snk9qt20/FEWGTXw7u66oFyf4PPdOZ9ZOEWQIcR0ctVibJibqBQEe432U9zW3e1qFrpFVh86opXpNN9vffZj/5r88enI4RvBcruY/WUuAeD642JfhO1GqRMhiAUIPOFESJsdOiP9QN4khvWzbMFcfECYezZ0LIzuVsv2XQ3dU3Ff+Eh/7uCrMJTbvRk2tUnytYR7EZqOV/PwfEvKDewNsSJXe31HI/NyVFmYiB2RBscixqIpXRdWgnEpQ2PGqHrboS9Px2/+0b9V5/uL4fFUzXYVAsodZZFtJQbHxHDnQUUNvPIO5R0oWby53B9C1KEz+kHinKvIr+wZ/AWLYjH8Gi9qSp2GFbVgOMtGtZvh/79v215zhveXmh5kW96piSx9SFh2k/F3ZNsf99ZYo1qAQ91VrltFpi/F03gPrQvWK/Zm7tO38Uy4e/5f15jNdXI5hkUxjSNCg2NtV/H4pu/qhJsOva2u9WHBq3aBylJLtwGm1ZYtbQDK2zswTvGza/0QCv2F8H61O/zXfuHaaG8oEhEEbhCFahoR3udaBJBzA3bS9R8mR/Gccd0QrMomSXPggVKFZBh5EaKgQFWO8lbJgq39JGnbx6/OYH8/nnzJWR3DaK4MxUsRTpPwelg5IqdDpWqfrxasWG20YQGqbMG1BKLevXXWyKaYKrjHG4EtHo+EX1LKr54/0jz597z39Davib3Q2CmRoRd6XJ/KSLX+oFMwlqJiqnfR4a0pDQ7A8R/wpneMl3kxLbAj/5V4ew7c4hLPHtLz6reiVIygLsF9t+125+vsbj5UPvGojIzTsZpscYqndvIwt8w1WwFW1z2pqph/CGRDZGCBHKDUpvrAO3r1MG+zeyn6vqQgS7+wZPyLw0t/uS3PXpR1SOcz0CXtn4uUQHQSZX4dfQYcLOtVz+SS9WETvDh5C9iGJbBJzrzNYt9CGusufQ+I61bPva3x0O9nm6V5eun/L8z9byZY56wfBibEXQdC0x8lxomH4sOZ8gJQy0MveiIsSeKTchxNUZJOhvihUbHOERZ/dHP/r3bQ1hP5C0AyBsFHv7pBPJf3m+/GxabN+2ZUR6rJptBCMGlie158rKgAUAm8qI2vBgDZpNOIgFQDNu6RWtUVPlojn1iIVCbEHs023tIeOFvBPyHI4jvvUn+MLEquptt9lfEBL1Em8bJ2hswLmW9xA11rY9w7fLqQVCUfWKVIOTF1Jtn/0W+v1PADARa5aXCN4Po7rL6r00yX04h2vQ+eDhkRm83WER3z3ZXqTTZsFJY8LDoj2NVDzTHIuR0uUU7+bb4gy0Weakzql5JpkVHNfbVKWag2XCbX9h0aE9VTn6LsB/5zdkllk/uJDBrqHtDG6l0Zp1EbrZWkRoYpzNynp6rxBo1fkDzMed+GnzySL6FVFaxh6LkB5QmWCxtPqeL4pNSir+H/y/47fnmVVYkIzJJ04aT4i9B1ErVsWtCpRE/l6jC2uyhXYv7DlnbGBl49v+Fr354K89+vzi+/yhKpG7/nb+tyM9GCHOuiKBqolygV0mOqvxIdV2AclY7O8r7lTIUvDSppuca5kkCfT9/LkxdKyNwWLEr9+kqQuTD2po/qAwei/Ydd1RpGm5beP7otcjfANp+nu29x5tms7OmYMG/4N3MY8FMSNlJHg5mLAqmwbPPCItYh8FtSbVzic1lzgUIJ725gm4sllp8oN7KNyH238P/1zf361D3Vi/sv9HXDk8hs5WHXhLUiLEEl2jG7A8uVROYdSwvLajOJ9VMAxFvBEhCM0taj6Zdy00MsHI3fGaYzj98Gn5rsO49NI/y38JgG15W2EmFxA/dLA5hJrdyBBOBHbExOiriWKcwBYciOPTglmt201ykhHrzSmltC/4e6D8cAF9YMcBN3xI/mat6mpY8iDehK7WgCgmpKcBwSg0scALyiE11snfzIFZRE7JYSGbYDQFO3M1P4bmpZ/noreBX3/xfoevvCLCmCeF9UwLb7fppxrFO/sRilZIuXHbKWlcqKJ7HuWELHOWmbcyK7FYlWSIRM6UgJzCyxs342WKI+D3UfxuO1WeJHqm/myB7IgYcXaoSrq0qjtp+maBTMkE8UlM4bmWDSxVCZtb1Yi9Dv2VRlzWTJ2uKI2trtt0LTmt0JOuP8D9/fv79EfKJn814zykLo8Pvuz0Q7DnBvJxB9O6XyHPd/4u6y9A8w4f6RRLGjT+DxfqOG9hru7HuPolHnBI+M0D4LZ9+Ji3c4J6bLqRTEcz1enHvz4SS9HzYxVMEoubWk+QO4RnTxMRTWb2Y0Fe2PixoA2golfGlBNfeFJBz4oZVz9+z/nf+6QlTG8eoLz0+TiFdOJ9xRxQsl8CX7yvCBjm03aYLFPKI3k47LmURBEg5DdvXQVWpi+ELrDWPfmJq9L0rVb9x970vHG9YrGlj43ViyRadcfOEpLmW9dsnnQTxp15ZgJ6ayGs7Csnixv8LbLAJARoKV8Pbc8ab1+jLl9jv6f8Td8RjeOVGxKFsG7nIuX7fnGxgLSCRU4JstbC35pWeNnvPMDuohp0rmvIPAOvFXWyq0gt0SNPPR2UTN7VpCyA+HRPiN4T+SKn1fnjFiRhWER+rJ6JQLo0FenB+dj0DEcQYp5QCTuWTo4CkICQQblcAYdHqs/mG7TjvSdXEpx///fPziZTP3wk+jCBU918oZhiLJgYmb2OguQS2is0NRDneieUu+wOkvRNYudsS1VUqajoYF6t6EeJ+/zCbCvHBq8yfPhm/fx53G4/WPTtlmozNtCwluMPUCODomB2GEkVb7bgTiTtW6Za+kBpgheIXyloMizPFjfghUcwJizYOfSL6C+/Wf10K+R5pMtbVMfB4kQfoZmCbZ+Bx2L73WUSRi/6+HuVoCqlFfCcqu6awGkzWP5s7GMPpS9696LzRWvzE2/pr6/mTMYaH8AzvK7fypo9NL99IYlQrAXj0SQS0WgOd8PwAtMF3c6CKUHlYIvHhajl/z/J/Pjielr33QlaK7ewelB3RyTcvpbi71y9EYcxGB5mda+yoT7TrhFBe9WKpi8/dNc3nsAs52iPs+Mtc998/b3Xp9b3laxkWfF5I250yTFVhMPh1dE8SyVnwyhAgrlk5Yxs+67mzSb9ANNb2DWEnBV8tRbI+6v6Lv3C68X1H4LcJ+Y6X7D2evKM/sb0CvWoPt0dGCSeFc7I0u1d3dCw0Co5rS7ZHWALN4VPcl0fQ1IDadToCD7AmZWk52bzWv+SUP/AHfXOBd9+UUrAWtbgHO2lorhkHmRQ9Y7teSn9icRGPSyJOLBKQWnx4qSLXyKDhoaTnwA3jdumsoAexnh50/Mgb//vnEzfNwyk8+8v+PKrEPEJx+JCMPFftFeWl2aFcdXGHU1lRykKULjcivcC9UR13+4DkS3SiJapv+MLni4YvvGG/Jdb3vRJ8dr/UqKt+BA8rLhGACn/rIiBqnywG+NWTB0VchEN8rB/e3MWZYoV6hfzJdQy3BvzkMViCW/eCDb/Y1o8VUZ8ErIrdhJvtCa8eJFDZzdvP3HJUK+VX8hpJz0oe4PBTw46kn8mUaLea4DVNqocrWZtNXWbxziA+Uf38BsqfyqW1p+WuCYnuawUYxN2lV4zOkRUhUFX17sCGFt3zIg9pM1Y2cwBxqs6w2oVaShdteen8e4A9/Xnz1nwWWf8y4PJfHwE3bcQnAK9u34d1aYbd210DNmjNaON3OQmFCZ8dtrwNsJpkFmMa94Fh7qHWs7kYJsgoFNOT3XukwGrROO5OPu03XfyFsfdOwkdbRXRfvzWumY+UIxjlt1wg1SUy8pqkr4bqskcE2Rh5MLVW3PfV715XfOMu4m8S+Adko1tY8jbVczMWdppvCA2HHiVYMs20pbErA2iscx4E4TOau/RHhkAJihHAI9b0iJte+nzPhYCb9u03NP7+uoxvP1SH2uO+mU+tAivjZihFBbZ0Fi/urV8Ht6MitCBJ1TlYrBC2U+uq8IuEahM3UBXrq4XvvwO/UfJdh/1T+mGl7gw/FwNoarGlHAi5r9PjXl5SxRlEdXDpYF68USBVZ5yr59Y+HIvR7HqQ0oE3rld2LwvvtVvxKHH/Il/v/MG7EMh7X899JVbOB3n7HJAVs0JkXQ/FGCRucdexeZ3Pp5usO80UW8xg12hj4xCnE3crpowa6RsJuMZw6Anq+3vW/1zWYbqZH8ErfBpZlf2HXJ0eLcK7MV1NLA8zg5hFZxzMu8aivr4Rv8LMxtI9QZxMUgeQ3WvgPlpHyE4v7rf8+oPtRrsaWrFc+5G0O+/sCwQUBwZlHNZFCCu1dsGglqzP8WpJuICr86/OlnDBv8kcBKVyvT5lrCwEXcXXoU1PUuHja+s7aoHfP5+IH96327nciUdHdmE3scZrJFHAUkhlChKkVD5D7/18bcq+UKzr5HswC/lQYi6gIMlAGCO/kdvKyEnUPWnKnQjFH6qlfjPM57oLfOUVRhtgQdDBrULJ9JpcJzKGjXYXa1iBKoPRr9wCDj7OOgqVoKPXsGPdPt011p88rvw93v+pIuqr37wZtuv5R3GxV14ccREcKH0sve9a4QTqvJVxND1I46oJpb4zycnDE4q9gtEK8s7t+vbFxX/WM+q3LPup8MPN647qnaBTxsKdklARYGABYOWuP61BvnoQGmZJt6R2KZ0DpDpjnSA2hzTDCvzyXfSMi/CbT/7khfCQZx1PMPtLMTmZMQBICMuyaihe/nKMO4q+tD/HKtcKyqGddrEDxjd9BJxMEYoehP553DzQ7c4Bfuqd/g2qn2pPEg6JN191BFcd28xpWGQNaCG3tA5l6n6JOpwbhUB7HXMWezoJ5C16R6crlwPvhka1o3PhvQzy++dvvC/w1VttyuwWS7PNHETvVEr7Iq27e2KHfOtYQYqsovjgNeRSr6M8FSxUYP+qvLNw+9sp/IURwNxihya96sLLb2eH+3eSN1HQE7Wrn2+u4ZfK59RvpYzDMvYctvYGo71N9QshtUEsYVt6HKx4VaQcfP/d5E/eer+V0pe/kRaHIbBalEGu+80aN+IYG7FGV0EhBNe25cCBReIFcTY3h579ClE7Mn+qmhm2h7RcOQa+dpXtdmr5tTf1NwK+lGBw+9CFa+064Ch7DdhOmRda6mBzwzrDTsah+7JCuAZ+WmJJG1S2VwvjQjXxgHdzKHG1jkDmvoKbJp3v3Gm/GeTvAbne2DTccX0ZNjPCYzswlzVCIOVRGHvIj1zA1ZqkcwMJTPlqxrWpMFDca+DDPOk3Iw7f9Mb95o4/3Lfwi+HC6ubr5gCFMefNwi/UZ3kBVZZ7/ITZHmv66O9uZGqVSw5s5T2BHR+H3FaTFdDFJr1wk4h+S6y/pt/PvKpnqR99+dyPBqFdfG2evGp7pFt+mXc6ci1EoOF6pGwlyLxpEZOAZ1qi6UPqoSptaxXyx5GY3z9vpW/s8jcfP4zcfLdiWeyTSiWixuhRVVHSJTxfNN0jhlkJBluYgtSSKlEF2Fm5sc977QXj+qns1F58C76vP/mNte8LInQ9Zv0NKIXQHRL7fPvxycaK11hYSlqOP3XMUwzt0uEa8vrnAdsaEWUS7EvMVEji5mf9YNP5X1ee8fs+zc//6LsNaz/a26uoCxVeN0Dmp/zFzwRqXafVKSvWp0Rd1p74lBBlaXgX6rgXWLrXw+Ln36jfP3/iwtg2GLt6O9Tz7OYFqHufdctn1VJexcqMp7FG9Me89Yc2Fz0kwI2v5w2xZmd6oMjy/2bvW9fjyHVdCW2//xuf5vnRVRIBQlVlx8lkZjnf3msSX9rtblEkQRDAJ9JLv19+/vxjEXBL1734YFbO+Da7PH7s85QjAi/JUNkqfCSJKp5fNTBX0FMSSdaikB8LVzEkmELmLsBBkeFnQfm5txG9afrpMf5sp/HE/A5XPYj7aF5G1YOAQfQZi3gy8/18HsYxOxL4K7o+QF7njBqZlAJxY5FgNmWS0QI8HJX8nPx/vIO5GWTgUWEMK0R1H6gtBAAfzTDoEwlbn0E/5qcSSJKBY0W6et9vV+or2huWiWNnFGjF422++FFk+LeUbdn+iU/XaLnHKL09zuK0pwj76kVbm3eelS/ZH9RJ+TE4BOuIZImw3GFxNReKW8+vV7L5CMvyofbz5w8mkV973UF3KC5w4Xri/U92WDFevaRKtMMT1KSfQ/YMu+AkpRvwtA5MFYWMxiejEus2C/yc+X9x//94WxR0QBKxkYWCtifYS0MtAd9iQIVSvXNnXCZ64734B4lGcFhVxdGjvoLPEiBpxV0rj1oc4jkIkndf5sxVb9eWf/780/GTmz7iUrT32v/ZoUIRRgCUJefeLFyW/TH9/Y3xHLadk8DcsC+F76Tw4DX5fGX28+cPJomHb0GfK+Im3+TVZglXLCnaPs26SX5gdnvZI/je45GReVznKWu3i6MIVi2FJR2i8womX1gUS3H18uI+UnHzNt0/xE+t9vtCJS+jCLj8HD533yEIhMXJ1c3c9iDLw+ZU0QLamuFrfdN4MxVTM9GkmMDJRJwiidCAyE5GZM8pv2Po00YDAvLX77efRPNH08mnWvzcl19593MKfiTScvrVPRWdOSBjGaJP/aoxsQJExMAGOkuuEDuTUod8cCxGz13cx8DnKVP509r/oxDW174ILf2oDIIDhs4m/RWgiguoh1Uq94LNdpLrMkpYMPHY00M6Warv9WaHALxVDjcguHuxALe6fA/n/aSGfyhpfIrkcBE7n+OY5NS4krUkaxOdWYIme1lzijTQt40mGZo1pbTCqPbTKCcf2rjD0fSVzH4DCqbOZX/O/1+eQe73CPITsYaryEPOxqPLpIjXmTuw8xzKuZx2JFW0IUsL0zpplP67arNbUO5CZRL717Zlu9wUmbae/A3q7j+R+LeVbl0uCBv8pQSHIRLapfead+StH+kPRpLk79F/ix5imlbar5zDaHG7k5j7x/nM5BCfeeW/XlX/NON3HXDfl3ogepK2BW8LdoUBtb+Vm3BhI0qitNfQZznnIICLwxJfUO7t3blUDiPY2Cp2amHXdIGNae9nE/1PgvgDrwd+5ev8AA3SDehX92qLj4YXoJLuWQ74qFyrlTcgE/xjXA9zcfDiSt78wsuG0PMCwAVcOJoLfv+7/BNB34Vi5eOv7F0Hog3y1mFOe1tWKex0wAD6dbuR28pSYj21JcjeNAstHi3sNzDGIW19p0CCrxzXXy+xfv78zlSFeKDNC84aV8yh86RPA52m33gRpppkRPJtjLuWOtOoOmBR4tHCAdgUoklYhkc0hikPP3Gyn0G+Pwnij1VTePBy52XCIUC2CC1QCQJsy/ztLe18mRkTyKJqkvyQSGCTwipcZxynK5LdajIkSv5DXBnbVg3Jrxzp/AmHv67g9CPzpsGL3Q/O3J56ezcifI9dYkWFcotAArlOgY4kPce1SlIQMXjYDA07yGwfwsNX0gXL88sIv/xG/vz5nhDKR41j11PrbSqQXNlfEvlKesD+uU2MtcK8U/hn0NOA6TegzwFc/nwKx0slrdx1bCU1/fz5G5vwTTXtj0AvvpP71+LsWipzrYCya2xunyi24ZNUA6rbiJT8xsaqigotbkx6afcMNGoiPQ8RxkrfxuPyMnhyZ+E7brxv1+H6b5dQn7G2vWhJslVL2UqCTOlr8oqdsdNKr0dylE4Hi4ebi4yu4PKyFZ1AFQzTClL/ZTe9vuibYboUXGBmRb/u4kb6+fPnAuhXtPdw0T64WWOhT0EAHOxizLTjMmjEuvP5IfLcOzxUTQQBgOmuo1eGV6V/dgQins7Ct425JWNJevoHqoqfsuvXUguoXr/XP3u07NM7lKmosJY4zgsaQnA6u4hiA80eJWAEjUEw+MGFUYKEaUaM9WBWqmNeyFjiwcv1fbDLT2r6nhcIz7+qs+2u9D7QTkWKtwZcbsqr2MMpi4i1GTsCdVMDZeayJIqSGyd0hlRu9IVwkyc4jBId0MYDmPDnzz98GeDLj7VxvrQNrZVBx04mMDUa1Nlz4gPMOVnNzKFq8n4gFUs064+55CaqOEte5g1w82LVRWcDg6sXOn3J+pMO/iuh2OAowFQnoHLI3dALZ0XLUDH2z4rO//zmEQ4qlvEJlt47UnMbfCOeFoErA303skgVmfilU/4TF3/+/Ocne3i5E80NmY4Mtfi2Tie6tQHZM5ZmHujQO9+j8nEgRMonAeJV6eygp5L+MjfzioocoLgs7GtLr+K1o3DiJyL+qrSAy3frjuzeDGrtCSDZQixIyq1OibNHMfOw1XoP0GFP4Lv6QuutN05rPW6azBaXZKkiKDfUNTw7/PmNQfITbE9firzpods7hF4hGWSLeSfQtT/jD9WdpWGbVhQJFH+XY/mHjMP6GY2EDi3HAOkcIq9fHQtuha/IyouQcfftP+f/3/InqbDoEC1sn52+RmCGyYJeseow3ve+8INuxNpTEAWTFjytcIHlUYDdY+yEWXZC2aF7Llu6Mq4un5Ta6zpT4zvP//9MCOEXvwlPHkvf1O1EHQ9/uhmaA5vDhC5fCqYmSmlXGOrvEmt0BC1Ta8uE6SsuqJRJBnDxKZX8+F4s9ydf/BMhhk257MkhPs5y+70kvnC3GZW3PSxoxWk99Qp7Da5vzCRiv9GXG0YJNjDExavdIN/wuNi+X/n5849kmM/LL/0aVQiPdQUzKjmk7H6nb1TKXweW8VRu5A6TxIbsYm/uEtsm0nwasszkLaH515R6f3R+v+nXxCe/Mj/3kNicGuw1F+tpLdhVlnY+qVBqtPX15WsfZHdva60lbJERdc3x9pfGLvyLGl7aDz8m9nxbafYzr/++CNx4gefdN0Fu5cE9OKjqgod6WmNcPzVwUacgjp10zNop+wFGv7fJpkY9bfGkGUc84lHhH7sXf2q1T782t+XuLSiJ24eYJRHy1KCW5ZEwC07SqVOdonvdoiMXA4efFMFryQ+PB9ZvBsS7GIYnPfEmMdSumDunxrvK6+ewf+81kF95iLx88/ZEVLgqYs0lpvZJChBs/AlTH0p2eLMAs3miWK3iy00fIEtPePraG1Hrmn7Sd/rt77h48WKfUH/+/FHc6qJ6eLKVsGez48IjYDO3brOLaVfFk/pU/KkUUmMFXmJ3sLaSbNCFXPpflKxwMaJQDoyHHp7dVojHa+8/Xfq3pBj86oMCuiXoy4HkSi0busMybR4Pcuq4ijPxrvkww3OZQ65tDZQfgfs0W1cZL0KNGfp/bknwJ0L+2J+Coz54fxObDJIX5DxJXlm7DjZg6+xayKVeTv97UPgmxUOWSUpIJbRAuhluWDVq6tNwV3zCIx+X65pxV8f+/Pnjd4Bb/XHiIP2qjF0L4fr93N+vQHXwPFNJUgviltyPfRAsvwNYnGF9NJdhKGTJI3c1pzY1eSsRg8+9mfmgcPvBbH9jhbWj/8C12VdBAGssUA8vriCy9H0HBZjaPQEyncl5uA8q1phPfMwQbLjZ2acMm9sUi6oTGVNxulcHu8yL/kb8yZvyJ+/cvy54illlKyqg9YJ+vfCrLJ0RXCVpmZaXUS0rjYXymDMsitlI6lYiTJ10a4hbG+tsT+vOQgVxl2c1cf/OlRD8D530X38kXD4qWpnk18a1Ist2qrDvZLBTokPFgbGFiM7bPk9AdwRPT9Iuu/YCao3OVT4e0mnsNrdgMgMuV6Qe6bzGd40af/782uvXDyFsWZHPfmaW+odCrJs7S3sLXsPqdzZCqPSlwT6qpjRwGrCLy4zb2+LSKefbBDGupiY/INWfiBr8+usLU32jnxzQXayjbLJAu4nApAhKcFvAPx45pHxSrvqKiao6HZUS2cc3WfucC+Xpm8YDnzvvP9Hwl7wotzUv7tAa5y2od2DbpugJ5wwmhQLqyKPt8Z5A1PGJEVb+PSFKPoZuYlYcJ9JWDHD6L6Bi3pIIvVD1hVb7z9n/ByMIn6p+Hz40wlfkG95ftpKdtuuQ2+O0jv7cnzpVdg8191Fx2ATpz1HOm5pVRw4xqHYawwR7nCfrGHBcKnCv4x+raI1dTix/jfL+E3xffXU2LQh0WwrKx/IR580P23RtfqJ9FtypM3Z26isuY1Cc3zX0hq5zeQoz0V1EA8ceTuXyKjM+aTSeqileKtD9HP/fXphh166gI1H3/uD2+5zxTSPs5o3TeswVXKSSm/LY54CDk51GUXnkvCWfUWo7nR0g1BMlatV5itpvPRYaxR8/Df/Nk/6Yh4XvezY0VMSjNzolUZhT+05W6FAW1XBjFVPnt42LBT40GGHO6GnUItIU2GgNwaqRYh+F1rfa1Vj/wkb2Pxhj147edpj+GA0Dove8qJ9k29dWmK8xO5His3JEKmEES/anzjI3ytGOkI6rwuV4UgDzTeQb9xhWrUPzCvvKK9gE33PS8T9wuP/YwzbpNENhL58jmAitw449RCZE9pWQEAE0BejDC2E2KGmE40JcF0At8vtD4/AWTIMsGF5N1QgbVRLYfQ9cmXXzuuMX3/uf9PD5VwdPPr3RlN7Yaohz0pPe/5KPUVV9s0lP5ZK52nGC1xU9OPNV7lkVOMnKdcRNJYrw8g68cOUbiy6q95hJ8nPY/6pIuoYTnwllQscHUmI9s8No5jutQEcT5ZwneKxyZ1+5IE/dk9PGjW9+7LrpzH7CYRYWcZUfdgT3HaT1qRrrJ6q+HAzXQKz9+M39Bl8s1Ro9w6907PNK+5yXC6nrJqTq0DiSyWeZU6C0R/qDlbA5amYyKy3b38SJfl8c/G9gPPzvpSZ82++9jQH0oucaj2qHTMZivZZfo3HMy5oohdcqUii2IaAq7zi6xcOwcItpmhiRmX29HvtbICtz8wTXvHZWzWp4cODxq+/ZTwr5xnsB+wrqdqsHuEk76W7Thma5uMuOpIIAXUWdsE9co4ELZw/Pm4gMX6Wwc5vXTkOB7YsEq3NdW3lV9sYvvcdfxrHwv3j+8yst+peehR8ZtnMQ1/ukqREKAcCQ/XYGndHUH7iadMok1r4tt1uy0DINSLNFsgM98NVR38bZ7icp/KkM8gWZkrsWhMeEFWvFdVkGV41MgDcfPynQCnsePciiJlbFoDyR2RgkEpzt0k/+FRPQ5134KatmzA3QBm/fi45nbK+Tb+4w8L93/L+mZrJhYKO1shvLA/0kzLVXGHjQluUcmS+Zq33vujwOoKSulVFGtNZ5ErkQXlAU8NQrmBAqVRd6y4ZF8c/7SuaxCDZio7P9jyo1/tsajF/4PtxUZtmIIejFLCwNr2E2tWVQwV6EuqGJCNyp2lu3TYDaSYyYTX+jK2aKYZqc8CyNDiMPyCbxbu/65DI0N1BD3HNKfiHN438yQr4vyD7/0sNIM25WHFLxTZcQcPv0eGEQHkglhWtu0uE2f1WqV/+aSiSpeyi4hpWyth+qAQwRMur9MmCbkJ/T/btTDCya5ARJbH7w+cLTtMAkLHRPv7bymkWMuoPCZTcqV49Rw+fgm5SKMGeJlXBsQYmVJA/OAkVl7AQWYXArswvZSShfOt9+Y+R7IgX//eP/FZBkC7yY6jv9MAPUpOCutwR1suGtMNEu+WJ04KzQStXF/iDzM+UIu+HjQLElFMWJ9ethA89Z4LTli/IEkvo5XImK/rLdLf7nIuRbZqf4QuA8KIV63QAUSau5plT7e1ZewP7ISbZr4oSLbvXuZYBx9vppJtsZG9eTVMH5tmGP2HVbEvPY3Cr41B12N6HFXU3804Z89RXw++Bhq3z7nXnxvqVKOoxSxMB37DBgzU2Ub3aggMzhCrpozgQoYlrQ7JQdsMNkaBWYDM+bZZkfZjPJxs+B/p0JBN/wwHr+KjUc8IDNpnmhEmotAUrFAzlquOqg++3JjPjzK4aLZ/u7JxkyEN8eF+ZBuTn+CC8TtlKcoUDv5Xoft+k/9iFf/20dTxEOddSBw+34HX3OETRm6M4g1CtkP3man1wlXn2j+/5Tzkm6HFQ3s6kqvKkhmkTA35NsACenB6tvzM+2FWK4dl3Bbzn8/w3Kya9LVTzawtm6djvBq8vXV0jnKve5rd+zwltI4xWuaqWAwE9Z90EA/nzRtipBNuM6eSFMr3K0XgJPJaTZDu5p941P3H4/1dhXAgDXrXX/wv2gpJ8UOzDPprnOsBimUAm86miRmpP5e1UDQiR2v8WQ8g5mo1XTSeoubK+xHDRl/4nmRiLRjV94//Dthx//2dP/TU3HvqMEnk5sS3OB2sWmTU7dEhcsALw/mMnjh4zIwh95q8GNzfW9PN/GRedkCOrY3hGbkm0R4uvvnZLIcFXubIWTn6v0/uzoPv8dcfnK4uGQxUv+kzKb2IHgFsH1CmkQxPXo8qssQ6EFym09QnKYOFbB9cTn823O6Uy3wqZHtzlTL4/92/Ws5sJvOuP/9j7kD9HREDvOt0Cz2NS+XOu3k+bVrjbDspyzkgKsFmuQwiJJqe1rfkDDAoDKxsV1AyAJ0qjDYTMHCuTdG3I3Jry8uf5H+bpfDe9PJBC4yqiJSD/RVsYWZ0HRgW6NP0j9pGusA6VVaZIqlVZfRHPpqQ5B47Q3TnfDq8WD8ywQyftskt3omVqyLq5D8AlSZVcg8U/dwf+5P/nkxtxnlFDpH92kUzPzXGVYNsLI/TqQlEODYKSNPOMIrvRp6JfOLceDbUbeDpWP78EJfflwf921MaGmkK+uTeF/IEJ+ZbyKPUz1mQfFdUe+QWV6i7vTbF7f4Hyj3VdjppqsA5EjBZ1s3je1PdHwn9RbeAo5LgQqlxQXasf0EC9HXE5CPlEW4Bfa9P+BCME3f+++wuodOOR+w8NYqnsQRBh023QWLINPeOeO7Knjrgahh/rD4LOVoVsp0KYJsfFR2wGydWH+yhEEa2tqfydsaqxPl7U/f77agTzNQttu0ZRe1Vogok2bsRVVgPQHsXGsmoqJaEAQdK+KjdhH0R0VCaJeuHcXXngQAuEGKttjCo+C8V/zFtX61RHgfz2FfFeBdfGJTf6HR1z49vJ2xZwZZlUyCliKMM11rdqi7D0tciFZ0mI0z4JTvHppKuByfaJnSqrssHt14DaQuevIB4d7O8bdf9tvTCH4j8bHswdxFh542p7YusyGxpaf7r68bJXDjNszlLB1EuhBFdZMFHjnjFxUk9x0uwBaAUjLg4wlGMggW38EVeLdSOXtpoF3kO8OyPq+I4T/Znw8Zlk9fgC0+txfcYANPJzlkwhW5yaaqPRKPT1pF5WgyaU8KuocHzrJlBhNCOCVtXcHNiUPsEkhXusUuCq34jPAFp4kl/+ZCPmOXwrXjcYuswP73pB5SuiQfBXEOesRrDHHBhmm+j+7vlZKUGXBo1Z45fQHgSet7+zNMoT3bmC7sevx+jWCTaaGXiqIC82STSj9JnbivytCfo0AgE+9nveeYF6ywBRN2J/Gt2FAD7nkIYnmI3QHURwqI0LVfff2QzJEmtt/fkca5M28WGNVX9hMNoq0RO3lKAJl/Gi5YM9HgHh0rPHHztzf2H98PYG4RVJuVrdS4zBL6YCuKoHIHKSRi97WNl7v0csXNAi1Ukk+SVWUYZTt7/6OZ0RmHXHkFu6+WggG+qWwA8Sx+02vej2NAGz7j4xvK7L+c2UWvvH3fMbFvpYPvco26iUAe68GAWQ0nZiZIDOuvncc5MaqD7rI7Ifc26Q6Zn9KhQ3AYZBmHmiWdq/QWoF/gU83Efi9Z/pfEiHA98THDYTVPwPsuvMNRDyc/xQ2WcqBolCQty4dIsfmKZchjETeEFJM5Rjqg/UE6+5jkMUuaCSCseBua90JSk656+ntHfTMNuRbBmH/rgjBH3sc+NcS/hjjquJouj0imFOmf8l1h5nMzDruAJoKtFQd2tzvMOiCbwabIFvaefazpQbKPQO7I5rRaYfbcYWuiZny9zZDwF5w33ds8J+Jj08XWBspG97FvkpCtaJWlfd+8W18xrFIf+1IRp/PweCmEcbVaelmF6bk2azwqZylFe0oSq0EapzS4VwXjpto2nN+QRA7NUVcZ29/v33Lmcf/THzgM4k4tgDnbgMdrQHld3XMO5sSUFauSF61MVjIUJ4Pkn2snwXrQimxNgrxGVk2S9BjG5s2CrTokaaAYa0SCxnfy752bdLbJV1875nH341m4Xu//3YPrdXhuNwM5Tc8Nz8SXODA4WcIHuEBuNDISpA0Q5QQKoTe4jBVVkvoSOPCSBOXFzWo1cB0x3Kdl31YtOsG1+bRt0AWvvfs/Jf6j0/2F7hisF+/t1dL2bCCv5ueHuFYfMAux2XWbHSa32b6Gz4X2GzX37nBSrmt3xkqN/GCInIvrc7t7dRehMSF15tPIVd31BZR+ZXIwf9aHD3DQPr7mfDgVRCDF67RKTI/lpG7vqoey2S9qLrpUaGnk34lKgtHiSUJLrcq3BQXJttxFKR2cdh0X04aCb2GejCO3XYkn0Sy/jsR8ssNCK7vnYv+D7jHiW2uwebaOwuQbCse4CWng3K4BXCyjhx3VzWyCMdpL+Py3Xo+JRL1RUiI9VU4Vgg2PV8K5ttM5+xMtr3eVynlaZH16Qj5GxuR739SuHqB4BPIVYvepugG7IU3HZeqe4Tue6yWoZVfCvTkAReLIhCOHkTtl1Pm/1Xs3VkyrAN9o12HaPIulBRH6Zlm/4/bSuiWfoXP9+n/WwJY+GRAIJxGm/vSNHM/W8Ybzt3FE0vSfYv9RqoXK0zRZayaiBWOStQMkkfjkn2fRZzQRQyo9DCjRjlCfaW50CM1CVzmO6lVI7YCFxHXKvj4/uP1CHL7B9LH98fHbYXa7s+Ol1yDuyEwjqyeH1BPzSHwtjrl+q6PY3qNg2RI7cN54WfGQNMo6WByuTHGmL+C2RK8oAOPzZ2e0SDkixX7DXP4yRuPLRTyXTnkbwqR7yDuPwsEn0Dg6l6vWoN9hVarjc2Kh5w1FmMfp6wo7XKnnp98N+rJgZ1H7QZUr4Pkufh80LmRmLsXZiMYDd16gkj/ECAhm8MwXZ/L2di/X/6d/g59qL84RPDNiy37BALN6vv7aFvpPtDNwg0CudmS4N58abb1Ljh7NX/qLiZhUrsqxy5ioS2fA9s1GtEucb+SffWwz/V3x2GPnvy2ZuOviBB8y9fuOvK8ZIriGulyTCkaQA/0cnrdm2AeFdXxdPZmiVWQHwjca4kwKYXdoPs9ywzDzqTB936/uFKI/eW7dkhS3RWzbHRsuQl4CGRdc6y/97D/0yHyKewKn4gP9y7AV8Jzpr3j3Y2rdVHstc+KFmL16dvEMxzMQ01vx64ieBI/slKmpu1txV2zvAIJKOl946RuV1dqEEBEtFoNhnCKcribf9QkiwdH9+qMfGkRAv+W6PhcnG8hXuyvptzkluomQzxcI3iCvlbqR2OZV7++5acYCrDOVIZ5S7FtKNyMgakyKoHdNFE3KQT89nqT9T55xF6G9G7ai9925+MfmorgGwec2AMjD47Glu5Re/dxnBOPz4gyAlQKF1qUZBVHBKe2MrQ+9U3y7kJ8zeY7r26Kbs+LjeKIfKyKtozYegxCXvg0terVgdsBWtio0nwyIr580v+BEMFvIQDgoiLdAzVeDMsKMolXWfE0hmd3QfeiKn6MliFEhS7Ld4G+0fsaDre2coqUGLVrnEqmmpRwdYXjPOUI04KFfbm2nvVhtEodAS63ffoT3OSX08ufzCP47h/2KScvD09BtqrReURcOl2yYvmvucl1ThHHNyYrWGBbl7kSO3qxiNq0u2cL6eqvISsjQuLEr5OfYfqHxbYWvKW9X8zTf9tJ/jMh8tWf8oCB1aA/PMZtzddR67EVL4Bxc1aWIxqPr16/yg3OWNys3Qg5kXIMD5i3Fnun4FVCJvlBKer4v1O1JCunHbmDdov8OyVMuM3llaNOOQu4FIK4skbH1xdvv+2Q/+4Q+YXU8Qkl0v1GOfa4YStxVTwDroLbdLnr6kcETmjpTUpsRzUzQ/dOZ5+MGFn2/ZKHbK0UGZndimOaHK7fb5hr9xTvSgOjwC3SdmZ8Kh4msfP4vD2QdL9aQcSvnqR/IkR+ra76BIfAVw89PpgBchUbHkXm8ZjQhrSqSLlJy5+xLHP0cB/2s8IqQZ+Bz4NPfpw0QsmK1SZfzPVJM3jVaCKoyWl72bfk2Hg9miE1ceN6wf0Z1v+buuff0nPg9zwpbAGsW63k1tbTu6Us3GNIYSgmaMtJVBMIkzYVFcBe3BPWdgmJjehP5ji3auvTS6mpBGFP8aDVwT3Y2MqgEMo4qw8w7uUs4WA13DbjuEIg8RuTwPf10JBy8zfEx2UqwUM8WFenN0GXG8yRcgh6SxtHmWWeJU2bFSN9g8okRHKY2RqnqPcjjEQzXgPUv4fG4gma9UUXUPV1ZlROJo3ti/Q96lwSqFvvD9dmG9Qbj4qs354EfiVKcAQGvisffSY+LhIILhH3izJ2zyPdEr40q2QQtRcWKztDJm9+XYCNQtebNSDdRsfMzoYkr+w80Q1Ad81WAa2c7ekJP28dScKqS15gac+oQ8BvjpAvPgw+Gcvf/TSu42MH8fazUTtRJsh6Zq8U6nQK0DgD4nU4S53GOhfkc6CqChnK2NA2exHpUxWx00ROYwIA+/VZi4LLr1uKyt2a8g4+xDbHx0XJ9fDYfF+N9NnT+f1d/qP+42qZ34Uu9P6yXHfs30pA/mKqEymSWaOXGo73LvmLW5D2/DPrASyI6xzvv4fcw/rNlkrtlbaX4oX05pAm9rqtezrWi2UlcneEcFHjmhxvL7Sn9ni/tdc+WuwWK2WiC8wv+oOgga1r2kUYVxZFZmMHYS2UQtcYfD5Cu4shm7oaqwbdMXynWrkkIiPT6MkfLJBkM0LY51b3FJOg2WThRuwNf0uSjXOKD+msVIaoH3T7Hmw7xouN3Edyc78LjQLdXQf1QRrIPwuq4bq+2u0c3KlbppJDYmB/mZU7orpWXhfw3ass5wptPc3LcODYCSksP8CmxnEe81zE+UxQA4D5RtYePhlUuvTlhV94SfclwFbqwgDwto3DHdTyV0SI3AN/iJeCh/HxpO/xxazKIzYm1Cbxm56jiazFMiuswO8cMIBiMHl4EZW1CJoNyDLhcTgzlw10bZ9hLHURbNJWUCdcvxucYc1uGjPGNDNfiljBPEszLbnRffhEhPzbtRwerxj3st/ZM4ebN9g+PQSWJMB+sQfrYafCDmjAS178ZugH+T1DKGcZDgNql3yRWeizzYzYmJ43pjmiKbRD5C2whbdRxLx2zpDojeCmc9MIwWeuxvz9eO8/GR/xpfjYwLXmdumrcbjaniATPz6sW7S+lKbYK3lkdCCpuCWj/GeDUb07/RyH+Rp4g6OMJ7qID2hQ0ZVaxnsPK0RtFEHDUI6WdO4KUnrp4Mli9rtthWeUk/spHP6T6eN6tcw3INhD0ts1BNTpWJlh1Dokm2nz6QGlQJhT/S20QKdnOuQAznDLNKPKDIzIdHyvttd3vVJGau98eWzRcewUq43DFGyau+YsbnuiLur6X3VeexzauPo9cT1q2qNDFl3x+4DDXIO60cF9Ag2iO9hGh2iJr6f5rbIcJN2SPde6hJOODMIPcMJYdjv87LyGBuzOPx1+gcxf9zBaVzA7iqbL2Y0LcXll3kYA/uvxgYvrcA/XLl2F3VejwSxwzsp8dW7BZUCQsm09iB22bIoaKbRivL2gs+qbYIdCVzMDhPt9MK8Ds6hpStIMIZZgt6aB8O6dl0sdu0Z9v2z4KAL+fUnkunK8jY9tgUWdIWJD0SNbSktlRJ91+9QxiU5gz4OxrXFU5rkeXjFfL7Pxc0QX41gKBolNE1JdmZOwputWbYRw5vryjSB+v+3D+UWpb9XYd9rY5X5YJf0+xn2eI/5THtDPtFvjNpHsXmK42No1/bMCSU+th8NGC8tj1fzjjqt9nuyEA5+OLmTMH54FXG6/6lJb3DCYdKd+l4R2Z1qgAPRpSNVz7Fm3sut3HInvVFP79ySRz66qC5HImir7S+immk1vxgkZQKwIyrmmnbXlRs9i/BSqDW0XfqiNhOCplcx1ZrJaDYnRGkm0n7op9WlmZ4AJ//6872lq87YvUZ17apZZXAjYR7+YX19A+XdF1idzyL/G4fZ22ne3lnbDJ9njVfy3MSK85F/9n3o5DnpjD85G+ncYHVmA4lt5ZJXzcL5mmCBbO5O1SU9ppll4buRFrVqiDqZ3Dyd/n6XYyh3FB2qHKrAvzOpUtLvpYaMOfOH841+QRfDpYhH7/sPTzukdguCREN3o0W57+BHKsTTVkU5A1DhYd3e1AgWiqtKE9ft0tzG14ccZUkFWHm+EOsHKbUphTqavYRK0lHoMet6EdqBZN95IdKEvWLk3e3ve8awVfZoh8Nenjy/Ex9PvuGFkuW8DgadG6Da3ug+o+msMYG09LYGsySH7YpIWVCcfbnn1jPVIQTDVG9qivXZye0DZwiry1rVh4Ca8LTaLfDe7F5yTQ9wgVP4ii+1GPJ6BmY8jBP/u9LHV8Ov/2mDiweeL38SKN0JsZ7L3j+I/g4Tb1eZeE6NxQJhdL97MzfbzUisUs34Csp7/6vWWo+NyBoRNC2Apqtf5JvyqZ+tmOAUNGWGCLSAc7n65/+EAjE/lh781RPA9YkAGYrnatg6nvWObPpwbpcy7Q+32hwPGTlaufcNX65JctUzC9IpDFKmGNUafVp+HNdRYsQth2tIC0jr/1ougEMjWjXGidVjWJ6Xm6gAvSMma9vk52xhCpr4H2zbkCS753Rf135g8YuN/ursxnC5OUzCMnSUIEOyHudli2uKxuBhzyGJVbYdzlT253J6P85zcw6iwynzSveo712tTTlw63AnLWBHvDd5pPKLuUcDyGVnP5yalA3SZ2Hyq0hm7BbKrlsbpBjw8+/g3hsdOkf0yk2DvwuptoB01q7X+TGDV7OHWDmW/Qp9vohkcorv3TJUQpMtUAEFp/GugLzGuSaTIZsFL+kAwghQvxDQapDB2IWbp1u30xn1ZtVlRv+rU418YIV+M6if9Bzw0YlAcRmphTlcKwwSk90PsKNx4FyrVq5Qy2TBRZXFMtQWcJRZ1LGN6fFJ2eR/+zNKPiNrDuWcVJrkKuUDiI/zaHExSBnymwO4Tu1ftKod8S4T8PXUWvhZFTX7mXtDCoL5g61elRaBVbztlRUw/Qq1Bjtt3UU+akHsNukEqvJV2Ah0MrKY5Z02GHKUbJ5QqYUjl/UWujm7+V60pzTTCEPb6DTcNOult6cayYfYxYCIEX8oOf0OMAN+SPi50YHa6ADIsFu+8yloF2TcHSwyCZyDBGyOVC7W+NQWWmtFDq4QaxY2bwqUKjgkdBuFMlF4Kt2P162m3+EvBV7DqzcJAcalqCvLM8BduewW2sgEruMJ6dcp4WWV9uX761/BPHu284EkDArsQgdhq7htHpU13GeYx9TgjgRHqWU6U+KYWkunIwjU31e2q49Gnw+eVbnwI+7YOW8orlPIil8HL7p3KBpxTL4JOyRpXAyqYevla7Oc6h3wmRPBPpo8vxgcuf2lYtQbFDi82SroIqZkRggfHcPs+2a++0dQ+JiEl6bYWnWms6QbkfOcZRji9bdo5f09p3JRuWMkuzJFEKpUNEkpKOdtSz2ua1S3EnXD3BjEAtp2OKy9cI4L422Pk+U/FxiTyDu82qzab5Q9jew9LiwOke1B+LRXgOXQDCkuClJLEWnDf3YSLd6gO6vL7jvOpnQq94vs2y7r1MOvZZ1/+gui/t5BHI+irvKk/YWja9NgjWfpjjXPqBQJ/DXX9laXWZ5LcTT21Qyng6QlW+aoCpKzT4CRqoW8v7TR0qfLJk6VKBsZDRKbPumtCYHKvtd7bv6rBUk3gUmzRNCsJ/IaLexdrgWzSW2rFVF9wwgOx8/GCL42dRd1dhDy5QvHJEPmDQYJfsEXvKBJi49DkphtX2cHVrOQMoPomznusvitDqwAyRWBUKyIyF8QFZTjl2uJIL8B9sCIXBzm5T8hknoghRQGGzAjZaTLwoScopOvTyxGAq89MEecsrWwrfhchv5RE/lyt9cnI3U8Q9q/MvlytN/juHhO4E9G3zovGGyCOtNYfYaMQuIOjUeUVj95lpqM6u54U37fgOwAdWGa9AiGlmTi3F3okwnmKArmFLbCBenVCCHvYoQ+FzfH2zIhNH3IjUYqv3O34e5LHthF/IJaF7b5zQyHRCqxQsLXthfPLPRQE4hFyqh6a0KSmlM6BR/H2RmuPss0SzscEchVhmeHuevhd2PqL1DRFghCboActx7Qczscbvkzlw2w5Dl4XZRchtkj8tTLrDzQk+JUvd46X+23YCxWF7caqJpDK29D5u0ssjGyaARdYx0D64Nk312t2rpSkWBJogXgknEEYmy7eQyVPL2CnJV1UQnusO2E/lWCJFvl9gdoDQas3GZuoathNhFw0q9jpsXxtfPcbJNo//ZjPlqcQ1wAWuAXulFKIfKyKlEBPsByG0X4w3AU7bn45iAIQjKoKrVCd9Kc8iV5J/ggnE8WOa4aZjpZXqa5+YMuaRXkop/VuEHipd+b8o/7c64LJV8aA6TNwmfd+OR98a4h8IeBwnz8ULsVl/rAvGjpfKIzC7qyAQHUKGN13ujYJOg8VtUW1jcIFFJ2L96upE4v1fqqarObluiSth647Hq4dLOF9HLDYsKV997nVMfwFH0hd2NA0Kewq5P6+tIITiG8MkW/yGPmiD48Hb+/7840MxkWDD9sN4kLyCjL9qkxw9UBbZcK5mDjgVii060DmxABEzaSWSfxQlW6ZeS5Ora7Ev5DJJia0L5UuH7ZnL3yc0o8rHIdR9iF3G7c2erxS5VUf4nwe8T111velkW+ID6NuiEfxAYuVXxkjlAYEE78xiyNx4Y4ccWg+gCo70CAuiqJpFBkrwmAriaRQ1CGrhOXCHuLsUy7v0awO1/fn6tOxf9vQpxWozQIqg8slBxgWHbnmmibPzE0cLcVGyCaJ4BuP+a/1I1/85g34gJtp6ba+YnH2Vtnvbi3nwUG1FpdghbUEL5Stf8nizIwqJ1LEputlLg87ZmJYm0/jdPisprpV9hcdyV5tjLpNM2lRpzrA5UU+jdf5u1eaUnRgaPoHGgfFRAhuI+Q+Z/yqB/NXvh/4au66TR+djeUE9s0FIwNYJvrwwYEsefT+pxlqSaHdFuxOi/IlnEJC7e+HGBpWc3s2j3u+bhZqIdfWfhPyD0080Uw/iVsM547ebDycF2nvutvClFVwyNgiW5fjkB1E8AT//bU66wu5AAC++jOvHe1u2jEEnKkkPNYLR/t08nK86gcn097EA/V+LISOrO0LNSDJwAGHkwd1+PUaSACeLI/CX8eGv8x75m3RXFaUsjV4bTegs3agu2ioOQeD4LE2tMLlVYldDmkXgKmzfrmfeBYkv4YR7/g/sPiLGZfFtg5tL7aFx4iFjqWyaLdw3ZNDuyzfncHgRKZUd3T6oXBCUHXoum7v2YOcX4ZNGs/wE5DlCj3s3Ai+RlAvUyP4tldQ0WnIBrg3+Ap2iP/ONxKXH/meLFJ6EvyO4Ig9G2C/M7bdWWtuRumac2xuInX+g2taaoqhOn85Ri1Iqg/Z+cejJJc4HUDKlw5W9yzNYbUKGanDtVfQWq0ftLFinixv1N118A5Ve9TNRjt3aC0VmGU23SgwyLTPE47IEnZGgu9uRejq0Dz/HdPFXReOC26TPKt21tchFRF/NDF2wFS6SKL0onaKzR3kWN6ASeQjqkcytELq0nLgpXPVWcwkbWqsHqS4Sc1TnB2F6taLa8vQTJT4djnoMIAxxRGI9/hvQs3dGitxdu8ZmwipFdLWOhK7PvaJ/PV3jv9Ov9vvMn/eom+4mvUA7hObbX+Nj43VH8zGlLzQgq0PS65PQ4GHM3Aib8NBB3H4V2VuEqqzzzgJhYtT0ve+O0Ze6C2DL4kMDT1s5kLrRcpeMyFdokBDCN/tx04BwBKRm2TybhMdzZvNKj3/lYu2+3T3LH3sbgXIKk/c7xlCIHvAqs2C+D0Ga5zLsOgkQUDnfT1KS+6CGgU0Mvz52dGrfrZvguzFXvhcAt7vrNYKKLokMDM78AZ+lR2mYc2wBwF+GuIhqGtm9645BeK3ppFvDJEH3QeuGIzm9ihzOvnW0SYKPEJPozlH9fcuxqpFLTbb8IqvVe/L+bWZ6/Rmr7uros8o08A1f7h7jfuKsSUbLPXfTtrHBrdwUCHg2NY6SDfqrXBkFgvoyND0rsza4VnxQLbxT6eP7WzzOn3gNrF0huLZKqCrBhVgEbAiB9GsWc+/ukl97sIdoQdyAVIFtsJZ2BxNX4ZfSc0a+NwCp3LQo8LLZFcbTZEn+2Qi6jAHXgQOOAo1zFHOGg72lYPmzdU32qw+qd2yiYsJy6Pm5JeneN+dNmxvb2bn2KePNp2y8OBeimyQZqewWwe6YS1EyQH+SYFRsPouDTI7DN6/ijoHWO9WwmkhyFkZuZkUGjZVHbJn1RYqS4R1GIE+ymAHnlAbxt32B90qfJELtnygHjsSrx2AbCX7YG7jztf6m7qRTZjieiZiosjtjjscstw/7LAKv7gm+wyAu5uq82AX/q13sDNdB3vRnKBUvkjPM921h247O1BAxoiqtCsQlFwwmcLUqhd4r4d4bAo2YZx0TblJwi5UtqVp+A2VPqnaTdp3O8U2/V72HfgHg2T3s7Fbl74YkcClS2xmZQriVPOPtFbHBp8sYuVMsQN4iYT2KzB6IQPSKSw0eZ2i1/ZYQy91yJdBQBZZNQyXTQfa7kChSqploY6Q0B0P25zFFjV+3ou60m/HIVuL0Ivx4rYTwWXC+AeCZD8zgbcl3ytI7mZDItGAqxWpDgO4xZ3hpE5rOA2WyzlG5xBGUuyKAoMUzcRzDjkLGeu49UeWQMoziVGJBd20CmoGYDIx1y4rz631JvT0rgY5o/JoClZF7nVVvlEW6kd9i8bmOGAjmnajjPxZKTn82ei4fx4d7NtfD87xzsIRcAOQ8700SAsaHSS6kR7Y9XPcv8RokaaMvmz39EhDTwbEaGHupK98WAf8Zxm3ZnYZfm2G0IOzaMuIzGHeTd2gqe2X9PLXDIiS8uvLMJoOQJmW7Fr1PdqFbStykSzwxzRNcD8LMe6mG/UfXLXghly3icRKf6A3Y4Bd1d0AuHa/ibhgZqU1TNqxhLgNKnZTp9TisVNVSL3vDHK4jABrmz2KvBCOAWbWSxq6C9C2kLNqMoA81nd0qq2ZLTnaKrC2/jn25wByTexevn2dEI/mbn92PHIThP4J4hbCtfVV5Y5UlARAoynomgG85PI6AwNMopo1c6mb0bfTjRNALpfPJmmOdfOfl76FqIoEFU5lxd6KbJhqpIDacOk5SEyrxttnHhAZuaOsGrW2xWYtdu+7iYIQw7bkd1UUbr9Cf9wne4PfHx028W3mnE0r1qz37WZJ0lKHkcEq42u+RjvfB9btwwGJgRgdznTGmKfOdVbqedmCImq8bgmPUK2KOAw9q6Mns6wQjZl4JiMs5a97tAUQ5KtdNE12axWJ8hDg7s0uz14QdbsBhRew3e63X/UBvyNIvhQdl79FV7pAzx+dLeTjI0x80DYICLVijIwdw2NHu2bV6tXLp0633plozdSHtp7N4i3qoHDWXCl9NqmSZtPJYlmhKkgKXY46Gm40oEJ7Y3TAG2ofwZoXTE3R/rFt1RtGFXZJ5MHhAvDsyH6n8s/9Q+2iAzfgHTZ1Jgy1aps/mLa0gcQ6xUTvskHY6AHIDOpyjhk+3NwGgF7rzCHu6lUw5WcWLhZ4/bBPGXnsJ2z7U2W7SKRgp6wT0qTrRcKJHQIrBDvFY+NcQHP4qz6kaTrd4MD7muX+4P6RFStfSGKDYrfu/DY+WlhxfIzVV/CnR7/+JjTZKWANA2u/h+HSpRl1nZht1zApbTo9Bq00Dmpz6++e9bnMgYzIODIgWLSrqsDE+eHNkmUnbraZJvdwELovfRzdftvnEOzKLGztdHzl8hnfz1/JI4++F37Sv6kcsZ8DtfrK9SjhdYO66g8umfFdaQFS7k4505kHstLcwyytFNn3AHCamQMwYqf7C2yc0ZBrBz6M8W5WZ8TqRIcTE0shR6byiWuT1pUSsZGJR0OyZO5xvVuNHdzgJ7u+y7tBhj45JPlCkOBpcOCitoo99Qpt3K4eFrDezmihx4Lm1rKiKPw7tuACq0bsrL2bx+HQaZZgRCkLVNTss5pCUPcNortzGy/KpcREq1GbA5KE4HN6G7vL9IgjQallSkPrbQjL3C+aqWJZY9dwwCT2R6VKG5I8CpL7L9JlgQf124VGEfYCllu/LqK3N5vVtnqqO4RgEVk9vGibQT2rVBk56oF5ay5DNufUP71VUMaqgbw+3zsjI2QwuL5bVnhzl0wNgZo4tQMO3kXlY+m4UOi46PYsDoG0EULO7OEWwfy8Kz6VRFxPf3v+Z+8OlDa+/uPpbiF2sNW+XnS3VRssrj7S3inN0QOFpdo3cPukb4GV8/R3a3DAqcmRM/nU8annJK1xyepfke5dxzKCriWWYkfZRzr+zgN0T576WbVdu7qsou1OwdEQaxwwENDdXHZScmM7+TBl1l4YZHclP2xI5FZpVcunW5Mr4ZWr9OEGX6YUpn5+OH9ttw9YEDw0EF9bDSnhq+Ah0Dd0lRlCzdHoNUoUQi/7vnW8LYPIirX7Ndv2UTY+6Acqa7i4OKBvIShaAVVsQQiXakUazCxJhqtQC3ZFAEM1heBcL56kh82xc+JAv2dSCMWOcaGTCOzTB7pcYpsfdvhqhPH4MhWxUYtTudmIRssIY2BMi0rIrrIIyCIXLu+i3O2OoUzcgQ+swfi0+Jx8k5WEEm8hupzgWLFBXIp25b9vWiSpPb6OicqhMv+280G1asAiE+d8MsjAa0K8kcj5n/l95T/IInWcEREjI+kZrxyc5jVkvJpnVu3f208o/vi9wXFhn7VP0K6O3IVHeFqW8Z8gsaqSI7JrIFKz6kp0xrgQzp4G6oCg7IrCF8Hh/Ol+d7Gu1ZtxvE/K4GRb1eZYP7Fe31VlAYjEMO9KdnLByHR9TM1/M6kCjX9gbLjLihkPDIHYoJaqeo1d/40A8OAEOjbHb1CZu8gUwLU95IUy71V8YFeIwk5lB8+1J2cU3auyVWHnzjquOvSCYE0UCZMACTP3ONTUYWwYSiSg13OTs7V0sYifvumGtdQLWdHFMR4q9EbewBuoN7ShTrXFXm5fjMD+RpMPNBKEwdVg7BEEe3nWithuxDYkv6wB5x5jU0ncV4euktwWxY0CDycScKIiRor8TWIiWhENWEb5oBnXZlRyMN2xBbVFrknQOKOl6fVGB7wanofT22BI045xyFvnmzPvbLFYGLEA0UsjC7OFTh5kVsg9Rh0MNTgRayzLhl3MAzOqPsaM2pgl4NTw3p86SQaX9/ST2cVXpdmxhYXvdIi2zxhxwbZU5cvenzXNXiDCTkzW2uupGFrair7ZkBBKUpzHHTLVALf6wd13NBB4g9sgd46UQAKDr9A8N2lPxnqaLibyotrNCkhAd11VqyX92A0Mfq9GXfVPKj2aQ02rLLcaONxcsk+lrkLkJkNcDO0eFlNXotW4Ac6wfbpA7Lvzpldo8A23u6yKocF6JjrHgxO0eWeZC9vENtov8mw0vzZvY2Omlna62M4uiCsjPjjtQLqEJq91bous4Mn3P89d/beCY8b50Xhx21yeESpj/vjH8aU4EYHaqGd9okvs/v2DKm7wlhumr3/znRkMiKpLnBfdOF1B/HmoeHHacifbObNtOxJJrd+DXcFdvN405+GlSvrJi9jv9iP65I9XBeGWlUznTpiv7eLqlcuqwEc3zvbjE7IpyxzlGm/3tbhO4diJyg9QlpgHZp7wiv4gy6lcAFYyGTgZzUKsM86Y1RudQpSvETyq9jJ51ETz0TDpLy+yRpnRVbciS6AQ7jV/El4dxqrIWt4DWheQVVfc260sPZIPuo2OvFHa3jvVNkVL+tfgCAp3vKsRXznWkaMSw9FJK2cfgeaSwcL9VJ7Bmrws5pUsTclDND/zhrZUCbyktzrDTXJblgpiEUTW3XKr7cu/90BzPIjWlhDnF1X9cRHz3by89SGNtAqrduxqD+BirPCMjPU9lPeteEmFUC7ig+2csAO9AHReIjLax6LDVCwPoCyLxtfW1VzlnqPOxZdQLdJUwkAH6IxDAym5VTeo9sJ9rBKFIdz5ckhhE8mlyxzOvzFcLovO1LKyxLuqyVxP8P1o40UjlAzKXlFLqVkxNZ9rrMy1qjWq6lKHJuVLaOzDyQHNVrsT1e7TSC2wTgT+UwOSL/s4O+ezTeoxTjhBxCn1rifqqvGVAOv7yNjcyASYAx1q0aau4RcuD0j4lStELpdD7N6KD32z+dy9TRUksSBntcxlSz1TK1rQy3scBU1pNFbsYbUSMXuJozGJoNptth/IOX/UwuDU1cvcBgpY9cjOAXe/5z5G8vaof49gKe7iZxseV9KRRrqh973BwgtNr1I8WZEwc79UPKdgv+fD5lCFeNlaQFMSvtTjcqVkpW+sZz36GHm03Vz9krYrRlrUC2ZNQrtZRxRwqBZC0Fyjzg9LiAg2Q+lnEEBsCSVbGc1Gk7paIcQ1hvR7/uCmegN2E0yzHOA9hOv0A7v4aENvqMFneUUG79+Wi6nS2UfIaFgm6bXjUghtpehzbYSqI1a3BgmRUkwrbQ9KcxnsaTL9OMwslcUsZpB0wn+NJqb8nGEz6OiOKmtCrCwGeWXk6lwQo2Id7dtMeR7NFSbs27bDWX9vkLSovZiTeN8U99RhKOuiq0xcOpx3bb35WgNnvczrKw/3soNIgtVVma7STDcKRajnAg8Y6AZOTfr57vb1TsnyANzDTDp9mwztauFTxxQifITKhuRl9CYsVJeTi2x3Aw2NwY9ChvC+hbG59nebLPBulvtEgt8VHLh+dM138FuU/DSFe8sL7oD84iL1D7tGWMEBPQE6gVZ5xUKvUnwZI5qZ04yEFBRJZWthQC3NdxGBD939U4puCrDFSDLqHCNXnz1eFTjOVftvGt2cvUCnINYpCPLdS9c5x6IvFq7jGpYYod81t5n0yKSGHKlNE3N0qBnJi7o/b0cfX4mMLJ3no5beW6FsbMcNIKhgl6FMoW0Q8iwE2GjMM913hEhBLHgZG3XgxeLVGWVFb3PYnJrwbdispN5Ob7IhkxVsHrJiH1WbtBaSKaYd1aQxmSiW9KIXv61ito3WhiitoWyYOQaXCFzGrgPRREObwTtTcVys5W6HD19JJmWaXneqxicEIrSfNLi2qO4b84hw3tDwO4Ngym4ieC8Koe+fkEac4Em/6hvalfosKf5TplxaiqtHFQ4UCzLky4jxKqOGVHUtpravD5cqDpM8fwztkGUMScmiTANp8p98fZfEclzxddReBoX1C2nIz2CWjjNp3C/ocoelOmKWNxGS5gPIR/e/SPqPyE/kjsCmWjTYbrTBt0sjRv7HjR27Ej8N29XkZVFMjK4JsGfeKzA86vAX2biEodVaxwIrEn8ECLX3s1TJiASyDPaPM77G4gmuNVZtwvNnRPZRbR2oI5TSkRxJZUnk/YPq7F15KaUHyzpjnwgz+Pk1wJoUj9MUU52qls/OLOsoZ8FEElnfwEt0+GHK2vdS9E1DsR1be7V1UWqV+6BbJEyc4EjIjMT1SM20vekzCoSyHnW+u/+X83VN6srrM6vOONnI8FQoJBdV1V+u3S9YqFReMK+xtjyOf4759aBIYr4PCKCuFw/qpBWxr7L0uhiGA9ykYBjPsju2EGD0+fr43EOXNWXsaSR40uxblBl38aHSWPLbwteaQkrYG8+X83YaTwGKQnEI8c9KtpMRdgTCypmyul3CqKEr51uuheORPuaHXusvyG372ebXTPiN8dIvm0NtboUzxqskojg77SLSHq/FeSxl2MnKoseH8KaO3SykAnNlWshlVmjvn47CiE5NxOM0IryLLb4YEVcl0YMp+0VQWPObrQZimyZFWwRo6L4IYDIlu/bQuo+7aSDhcEbdYqBd7/DbkuGUTrIZMFNB9zFH1rUCrzxF6PtHJYzQOSZ+xVBRVITr5J/MqFgVEo4ffipgT84kymT+jBbGuCYxV5ktq5wC9wxCxqz1mjnukF1jCisqnD4NVp0ujkHP8FOwFvw/74fs3Vaqdz4NKFf10eYsEM3igs9wgblk+aOOCCFE+s2Uk9liOgOQrJZQzUh56eK9Rjjz3kftfeeRex+eNYSUizVDy+/S570jpGKwwSc368ezEEeykkxqQlgRAepDak5ZDF7iT01OCp9jiV7fq7e99NwGDhPivwToIuJrRqDwni0bWy4bH2ZTM5yNcV8vLGQKvkVpHEWqC4pSmbGkcUOWGmo4CBGwe+5AAxawkI6EbRvOX+Dj/PpEvBaS1YYcSnuPykjPcNxCvPhAztyCI4QyT1IWkMREXMIO9DPB/6Ac0oQbWoYQJaR8v6m+zApXZ3mUq4JrvxgjX+SZeCzmqty6BEvbdxvHg35P0yYIulWVSUszNE4i/Jn7uti+6XaEdO+eJINLoZroqz0CWgsxOR0FUZlPYmgB6VhuW2mpocOcRm2vIo0leY/o++OjjjzqAFflgqqqEro8Ym/dzEqpk5eFJZcAjqMhlPg/wjPxBZNjjDXZNzhIqsIPjfXWuOSAYzbS2Rzr6h9cq1WLmLrBTT8GoGFMZ1GjD2ahirYnezx7hhn8qiRvib2XrY7CZDpvRhrPkiTSFACZvmOD80zGcbUsIZaJplo+nkxfo94NXni8b3UuyeIGGuLckVZKIvooKdzQUYuVzjP5Tf4gfpl3r5VlzOnDGpyyiVpTZRuNEBREVK2DkuRNnkZgxAWMIIJYUxldGC8VhGQyGbL+aBSjQR1Ai5n0qK/TR2ma5upqvKQHTIAke2h9VaqvxR7POXE8UmdmGUVQszELvTIdSOoWViNfdhm1wZrsyBeBDbVX6KQauHFHnWoqt0S6nF5Wwe7dfkvRhU8MSHABcu3Dw8yvN+juPn8QUu6Yb023tBQGo0DCViQTVjHYanaF4cuNDmhgU3gi4gOlweAtiLILO9d+14YUkr5z9gUhk+wyVqvadPUwFcSsYAJzZ6Run5cIeY/F53cgiradjuMRuZhasv3S8SmEmaxDgsFjWmbOaM/o17r4zQwRiQuc17XmaZy33YyrzsZGb6HhrGrrOEW03sGJCTRBj6bEMIIqkCbS2DBd1EngrNcmC+v4FdLxI+vwdllsZuBjvWEq23uOdyMqCHzSTYDMcmrjYi1qdc5nAz3yVZgs9hSu/FMa9ff2Oda24AxRxrLKA42UZSjZwU/KJbtuHWnkGtL046yInHeJID+VNi7kjHE3Tjfw6BV5Q2/hMKusPbh6RlkCTmvswXuHQ4YTyrZ7n/muzqV0chySQQnH4Oag5xvCkU/m+/hx1jFKL0oEmz5nVVvIY15Rt2zllufBHaLO85aXHOpRy+jHkiFZqbL4MzVC3oGBxgeBElqYM8NhTuSZviDrqVuaaeIJ4yo/U0/F3ezvMpO4eqRXUbbxMu25DMMllGSECNEqQG9+aowWAi7aJLIPFWuT4l+CNd2AK4aPT6MSAPJjDiNkMqB1dOmz5zylHInxqrGBTalxrBmmrrtqUYP3OB+RwXCtFkiFwgVSNDGPudKma0REO2gFF2jL1+/V0sfR6Dr5OEd8pRl53nnkZeOCXTuDlj6QQBeF1e1bkXVjgsl2UXz9ZXB4nrtLCOMw5tNjDk2zbDWTO9vkVdKtQaGoQC8JoFKEEKVDxiTZSLT8lbRwXsSnywB5DfWYTzLytagqR+oihS8hAstQvFRQZ/NC1STSM0fWyF4e3rUdVzvpeF5NfS46rgWsrWNzuL45uhNl3x6pkTB0sglv01UbA3SdINn5Wz5p80mmYvFFUzdVBAjUrHm1BrB07+2d81GdDYgCnQk5EpUWnfUwv4I7gdqmr6clzNu6ljSTRHgdiBAoK7LSfMv5rWXfsevS5n5O9oqSW9F1WbsBhlvTmg1Et44PIUp/MSLyVr1dMb3N1cp3rxFI8uOtyy3MNjyUMmjQVF56m2qIdujpjiVHjiVyRcQTIdnmwNK2TeducZZW5iyXAnxUA6pM4OxBojfpIP+DRM4Oeb3Mh1jPUvw5YoeyCd+75YzKsT8hhKUlN6EsISoqF4oH7kBmE3qr1Kx2wZ+/J/rt3xgCsK4JjeHSj1Kl7/Nm5ZNkgevguCq6DLMZGRvsCr79QONXGcqJWovZ7IJkbfQzGQ1KyuhIs2JNU8zK6ZCWMbmahwuLJgmVfoG9dQqbV+/txRFE/SxxrJK0fwjfLUhs63NTOwHwCY7XWpY4qV21zcAr6voI8lzEpeqKKFJyc+SGGtK/frO/tYFhr/ArSuwg9KNSIC73Qe41Fa/qcsujCqeIf0eYQKlVQIMJmewdR782LCT0QEsY6A5UdXmRRx7JQnGQVNAmIoYq8D5fF5l2wbwwLKI6cOi54IzbFAJUxPuAU1g0MHb+/Dzh2zprXJyrjEWgD7M+WAo0HogQeDapacmtdu1+5hW/sgkDWlwtITcCo7np1PX05rarxmdC45OpJbClv8N7L/ZBh7msubWBSr2jSzqFCG+q6onZUVQ3v477RhUKORsf95JQr5I0jG/z4A8eZCPMml1wPXQ2TgcjPSpnsWwatlt5oqypIokvgYlnTESZLJZRhVXLTVj9XAint85tVFwpN0PAMi5lPvBljMQVaRFt3HQ2QeD9EOwzCm7ix0iqwvejcIuok6phhBIrySexyx/YyvzCEJTqlLwZgy92UoZalAO5+81B+8m55ipaYhUAaLVqOSI/dOq1giIVk5XlpNaJn1+bfWaWdaoBRYPHq4QMXuc9jlzjwSA50TWjWW34YP59nX9GCyec/UzTrBb4QIgqT3puPNVyN0iqW3x7kEyeRMfVDrlyQKOr3bahG9NEg4uozgtpo5ASiDrY2+U9eN+S051HNVIgJCSLW8Fwb+p98EEslZfsYtez2coK6iNEdoEh3SLWkCz8iVon1aKJmp6zcVn/RF2cL8e1qkVEkKB8JHUY4Em75I7eixTIuKoA5r7d2DXq30zEwjNu1jZ77Ow1WyNueOptoFH2W2cV3+PDNR0ikxYSXCDMS1LWYgIXW3Miig2eYVDrE7MeY+zx/bgfwhDK4EsV2fpuoqH0bmOirXUYv6HxmQEId/sxxyHg3p7jgMQP1gJXF8pCDwfqRLJtGzftkgPdmwh9buoo5MVhfr6a+4We3dVWW3HVSvB2Bp71kk3Z4UsjHqdCUAgRr5xqvLULz5rCgB169xalGvvJhX89ss4qe8cv7RC/8h9l1PYOhlLLl3L9xKTwWkLsYzbE1M5n7YC09qg0EF4mD0ayIoSnVbNErg8hwu1rgVqVuo1rDFDq/PLMfiuUzMYVmHwWe9jqgkSS12GRtxImF9RF7CqJHkVjfleLD8g9rRljJFxzspQN0alQtohaocYV2lnkpSpEyMZIjR/U8Unde3dTn8SWhHKcw4/S4uT5vqxEJsvob70d8D2b5kjqNut4pZCfjoccWRkhxLgiOlakTjHKOm7WI1VrsSjOV2xJXTfoQXOaEgQun0TK6UcduccnwkTUZjZQy2e5KejLbcboN3vPcUH5NtWRUfrp36yNOhx5ClhROsIIjg6px+DE5DU+iBKgaEZ2an5MJ4NVYeUxSQ81/Fh3JjsGdDbUeT5X1XPMPZJyQqWtINa3oKFmZHA1C7ZGBxHgtwBsqEwVD3eRZ1VFh9vcsOa3tOOOGiaJPe1KjFV+iYZ1g2rZzU+LJTe5UUk3d8PBzvdFt1Qr8VdTEdVU5Qcmovl6+iYK8L8zXb8Xl06ZpSemAkPrOD9WzzHtbAQMRuQaBJ/DQXRuXiJEwwRtFLc+U+aFpR8vxMQ5RH9/dmTWRFOrrPkI1Swx12Hf0Vhmry6E/dKtWwne3pas5JyxVUwsLlxf13WI59Gx04CwKv+b6OnMcrPMK2rhplSSaTvi7bHBqBfEwYANMuZNNZgBk2uBm4eOuh8STAsjbPtwEnQc54+QMj4iEq/1fF4ydiDnq/PHvBpGLGdMi6YKZRV+ZF3RmvoowSrTcAmCNBV5mJ4shEVyEAeVDKputFLeElvZCFbjvPQmDfKWdkUiNOuXMhtYhdz2IHI2lt87tUU3Yc6RxpTNVTVA2FCaSULl1YkScp7fQaLSMPO6AjYnjKcALCMR093ZrYJhO4PMBoV/yJl95wi+ObuM3MoVr/OAEEelg0DAS7qHcvmeMidnBVbb8gyFAQp3mPuQ4zrKoDWV8ZLEUE/cOxDXnjJlPKS2krbJXtJ0KYhzPhAktePoTzQjHrO6jg5nc3Z27IZk5RgngNUILz96NJMlmWUc3elSERGhFLQZYqmbzoArxzp56onN7KO/FGlfqSNyPwyeUpvzUw5CF6DO/x0ZowpVzW+IWgy1CTXtLRUtx7Jee5IWV9EyXij0rPp8KB9p7hiZXOHV0op3Hem1GFwO9jF5vzGQZpSL3yEBdLIeNxX45SoVPLERjfJO6QF1uULqHIk5FYsb2pHUcgn0gzDxWBWWJ4nG2ZBnUYg4N8MPr9y2jguP6GXnrBQg8CNF6Wq+8uyoLvvlQkhg248XjQExvXjqgjufVrWWLsOR0mu8h+VrLbB0KivZ6KyklZBCN3l/aESzKSyiWNYyRL0dg2ut2R0hSPj+O4Ij4mrivgmONGYz/vudRPCk9cGzpViemuqrblyAvvwHmRy2NIgKG8+Et8ifowxqtM2HASb0Wki4D4En6W8KfEbYnYc5HJSFwobqitZB6QBAs8iqqVD7hlGW3cuyCU2zedd2EfWJi7KGjByf59e86q+ATB4WzrI0pxOxpBGBcNHbCLD+8tfH6WddmBs10Wux0Tqa24UHXHwsX3ShEmrX7Y6yy1rsh7CezqCRuPqTlP/WhcVM8HNeyYfUV9kEgfxxxL+qV50fDecPoSmWGznfP73vrwcL6eYkYTg1h+JcO6/z8SISYf3CUdexpr1HmRgi6w6IqDaApx+r5nwrXDMAsJSG+BWBMN6x2x2speZ2Lvhpu6nCcI7N7b5NB2404XKACw+0YQZLAnbrta5gxsedGpzRLQ9bOyYU92Hm5qfeDk3J1VghdsJHlddXyoY19P/obClk84KOsoY2YaSUJagizlBOw4t1pCr8WnGt8SoCWMfJbcvoRVtBDdQoJEbKRD95gWRmpdqKJwtlsSFDCp8KZtV+vdEqDSF0sc5kCzeN6g24WRaZJpZxk1rkXHlDX7c2Ic/DoUbo7fVcWRo73GzUROVtjmF9D8nPpCNTh/m5e+6x1Wql7RwiqXxQM6E6zG1+vK7YYKAzSNFhFle06JhyRliGvcZa4lUjTpi/cbogIhkOiLrFuOZ9LYnEoCFknVPSdFyONjUTnUdTc4Tp+cvhyMs9QdS8kNvjPjvUxBYCy7Jl69ctom2CtDu98QshkTFa2U/VVA4aQpg5ILt2Z3N+606h8myT6ClJe1hKfsyip0V3IV8fx2z93AchORMEadyUgivLU9ptjcpNWLlQdThxnJ4xV9+xISsy+WqtbY1MUh5R/ZJUymFdtQC6fRrXWeI3Gmbv3Gm26OcQeTUIuQVuL9enxkXbIcOJsblFYQzW+Pi1ggrhZa+djRuInp6AuDKXmQhODHf4+AUvp8fONm7eBjzwKLK8ScuQUlbWIx7AJCuu1iFPxQap45meLmGVq0EI9Z7J6BJSi/+47nniyq9l9BAxhYXYguFeVgt9z2eyMFeEMzzDAQJiz24daUMkULkFu0qqnPPWjf0qhHW/IoKbKckuPprsQtryip4LrJlI961nBZMcO6Rg4gMUWXpxQLXgQiFjuoxKsg1dyk1Xb+YRtx8uAWQd4Z/BlJx+ye/loJKHm7InySdmaXlDVH5iN1IvRRINz1drTyzd0PYk2KSKsNuzz2/zySBKb/CirfpGO+pVP6O49+68xbEQn4iO2MCmnd2ENltGTwewXlMcHyokhwKG1R84hAaJc9IyKYozvN6JBzVtGttzOpqXSRur2l9QvOCDszNoAdLoTEHk8DVBz0Rz1SnJgPUf+HL3rKxZ90z3HtUwnWPBUDOo1fYgC2XeVF1Mq5k1n7RF0VanenrI2MBaW+SqbCYwmpfbLjH6cC56+3cbLIh+cNoW+j48si07ovN5scbnCztouifFiraxsUaoR09ZDkyjxB7sx03UGN0irLdEYt+mLwAraWGqigTC7leglPnZiqxgXQc0xju9q0nVF7J59IyXHZYjVVUaM78dROL1eFRAcaqhZWFV7s5e8e0rKPcPDhIYrSxJCHCddS5CNLaRcS1ZbdzI+ieH9PNNYMGQNtD4WOIlFYXGfrpuwICvOeD2gmECi5UjVs2WrIeXdsgIneGE36Sk4Hnvg8wznx12nMcUFdU9cuCLO3VeXk+hKpaEkaX0y2ghmJp0TkgK1RPqRH3P+UeJMUgVpLzIKlca6tNW6qz5oxpeVTqoYBq7B6765ENPbFWL3Cqv75mJdy26+WIdNSBaMLgmvPOzCFcCNQnrw2LlklNDGuVQr6UtEuPtA84cPLaQQHrjPn5wXispROTACw1gqgpNH24XKLnWeiv5rOVbHGu9GXTrgzepcC6gn7ProrPO1mnLCA1JN7eO5Oumx7IAKbzEJCrtFJErGK1RxFoMRtDgsCBRSEcsIDuje6HRq0k6jEUhHhRUu6+9EBnd2TdL+mhSoq0Oga4Tog/LS+eyUK26s84skDq/r32NjDEPAKYN8UuQpbTpib7DEjm9yDUf5yweiy7WEqcytInDYSMpPTTCSTWzrSUaTfdq6mhOs2/zHuhBTTYSrA3AhHuzgWXzSwtUtkaFvOAroSPr9GjqDDD1FdKORXaH+XmzjuZWvGvKk1QDPZlV7ZtdeDBWy8OPJBHQrozCnh469VYjON1nb8xEGDtCAos7MEXNj5IR+GUdIWvoyKJpl+8eBETCYOHsQlEcGVHoYMlYFlvPiiI1XojTIbrubbAtJ3UmUVv7wshdkAFKmbXSVihE0GupOJMNsYutoMnMHkZylPcQW+q4pZSsndvtHmLeGDnv9al9gYENjcM35wL50iMMXR2EtB+0lojSSXgHEVo1hwvAU65a9oSnSlwswUV4QyBJrQm03Yej4lmgyIfwJJLxLBFBQ6EpZpQlxHrNn0eaRNuCh4/UuzBdfYj6add2bNpzb78SIrlXpKhVgpW7sh4ZRm6x6jcA6Twk2Qmi5QZobnGH/Jk23OUnO38Ese08nA4UNgUVdhoQMPy+dbKZ08WddtZKSlsuio9E4IqJmyR5h1YeYkIuaI3VSUUgXkhL1B9wPKDVNVVbqUSI65rwotZkQe/ciTQnwbYpW/D15IuXB1KKqxpWCOadBI/EkXU4X5MNjUbW5pNqKi5owOhWJ8QLsWcObJUYf2VeeBENQNyHh2YJ0pCSnCQYV12EBVpJo4CxkB51qiIqpFVtv7QsEICgy82dI3IwTogqpbjmgIFkY57E6L8DU03YA71zjJLuY+h6XtJ2H0/QJzPrvfsUr1h8rXgnjile9arPYRJ4mV51WCqUoXrZLqGfVVhXSe0RbTlhM8LoFiNmv8zYkQpfp9BHvzokzE3rzr27Myw0KlBxI2jd7DIlskiaBxVhTZhVEe7JZRQOo2qIcu/3tSxs/p/U39bWU5bxODfu6e3hy6n+qDt76VROaSMRVF+dGJL1gC1GiOkORvczU7WhU36O1BuCWohZ2I3sroVF9A7VuwGyP0WLIqlTcyUn+kXa4xs4kehlI0BJPk8SrkMvqKjSkDplscv7eCTLmXhqZI3GB6vRNGArprB77m33C6MAUqOrqXjXntBpyDrR5ZnJdj9UQmykERD7ADO7T70G8Xilmvwlglnjpe8HbStpB05YFo87Vh9yfg0tnFf1uHDeofsyawJB7QM1RIgcJojWW8ChapNYNkO2qmbDw3JNQuIzNdZ48rFw6lfYcTCgLKtWmBnxKSbiyniRl0rW1kZvVFrYItF5LWoyvXgGWGTEXmbiKEZKhR28TZUjlaq1mvRgMKAWItm2czDKBfz+kjoFpE1VoyHUE0iFxKJR04uNznF2yeypGNJOAZLFrkLld2mIdBIXz82FxUiVlsWe3uuQyreaVcG3WBVOobCLImqDAMBVUbvwmK0FK5SisdlF2QqqNIcq6UBq0wbflRYHQacYfeLOFVOn1xzXRsZuFb8eyNHBaHyE7HrEq765SyQ06Hp1QjuVR1WowcG0oxCMqDoHZiGdhLDbuTgsfVAZSFbSe6k+hfgUopCF5gEd0diKNeYlP7bz2EK8XJIi0OpZXM31cOnYw9GRYj/t0OjoW0bdFqRS6VWlSgOuMGasGs9wMxaI4CGzwlB1441KddLg731uhmVdtUS0WpHmfrG7Xz5CmtXE0qNKpMgY6Nv4Xk55gZr6yUPPijlpv4lFR89oqg0yfQApA6Xj0CMS//eqntPRCY2RtYbKuihZp2y09qvTR0qQe54i7IiDqM6cV60eL7gXxyXP7h7z7d5qtjVRNwSIsE+935vwe7i9EWNwXm3LlXfog5vMPVGp7Ll8xVWmyVRnyzOTb40E93YTxWKWXmYly/HmUcZ4ZR1/lEAvZ3y8yq4TykyxrrlWjZ8p7LOG4krLFWjs4IZkXUqknZBF061n/T1CDz8loc3J0nnwlV4zzH7OR21huhZEJlQ5DEhCCwtLlhn7uXqfGbvoyEGGMEbV0zFS0KorblpELb0Cs1UJqxiCQJud83dNoO20rKIAqGgZjJohjbPnbmPBx7h3yJLSkvjBH8tW03nwQbeCWB601B5JFusTm0VUP4VQmaA1d0e+G54im/taoqCgVl6BTbncl/YVMpVlthYRlT1Iu+kyXFTZn2O1fw1sro2kqnPpzheh8ReXlBGY4ABcLRri0vr7+OtwN2sFqXrBDs4RqGaFs5pixTZEI4vM+OgocM1Iie7CLl4LsJPyaLDYCqz6uudIW3C2d++jabgXZYR18AXrrXdoyl6R1mDLUHMqey1lU6EQIyoLWKbtjPamJBOq0dZaL44d/rIc+SYAT1HPRDmNoftcHW1YX14wVJyuLJu9QVTgkex9bhr2sVy+ELjo4rFhnpjamHQ85KI2K+uikg4JZzSLaHhx0vlww/tfEd0KjYG1aFPoVJhEm3KiZkpqLotc3flGjuqpU0wREB/hRoK0Ed5snLPbmq1pc7Er34FSOo1is/M19gZjslGJhiSPUuaNB4zEBgjVXCp1Y6Y9S5C9eu9FyoBj1MFJ3GrD1YXS1IOYbBPMGcrPxi9IWbmVT6QsM9JIpvMwumO7dRhp/tLiY0TDwuZhFmdd8BhRIOdS3B3rTE4xhbj7vH1emzmGc2d7N5LtwD+I4XHccVndD7JLCJ5uk6hHObcTAaGfBPGbXtprGzow2tp6yWKnEU8YpwVjWVI1gForUvt3nYOC/BcZSUm+su9mgIi2YUWuS1Wx8+lQROqqsRk3Gk8ouaMVGuhhAJqwS3vS9psov4xm0zPnIll+ELp6SQ5fvB7cFA9zWy+hOiI8nsPLOVO/F73eVJPMQugGH8wiemUvrDXee/HAi+TgxwtLWs7t2M3mBlTqMCRb6e+MhgqztupbHyUVLXHByQ/NahE0lYSMUyTlHjznysYqfKzH43J8flZoECsI0uVtQcKIv5dNWBUhBbH7hulb0MQe2HXQoVM1JQ4SmINEniejbJoPZSU7mmNzhlroddbePyPyA732L0TzokVKmDypg+YMysXTyEXcKFSo4gIC3e2ee7pFjESM0EDjdnINZbiXfKaKdxW4ZiurUKiL8QSYUU5Q485JqQsjWmoGIp9lIT74QvRJut/j3Ryy2RRnF5GKyv7DZIJw14N1v+tyVLCDRxt/g/mJqtFHPJDgiUxoR8/+t6le0blMpEbqFVJ1gVgqaGrzjuTRybyrR2FWNWnzhFPobYCSOAmAZR0WoFsgIvlRFGJHU3UuoYeq/ky3zlVmRRnMBOkocndSh4EQV4OULqpZRIsPxIyfMe2Fvo/RawcmMG3e8UsNmSMQtVGkOrUpQGNeQRphLq8gi7f1kdgfl1Z152kXAguhzrUjx+mi23XExA13bR6ZC6uezYRWZx/tIVP8D1hq//jSIg/KonLZWnk6RqXr53pf7v6y3sR6iZIGMsT5wHbYTXphvvyvEGVUtpsSPfpVUIKl885EkmZbcClM4fP5xACD3izH6YUy8FtW7tDGBYguZ0CNPnjQraYhFea1ts9zCNvlQEeNyERFxaBWDvQ8U2ZJTTFYxYTjQFWISTrRzug2joj8iAoveK3YsypSdxlhB6fu2La9wtQGo2qTyF5u6bRHVs9zlEYJzMWY81Ge169A5k4l+6JtFk9p4cIneHME4kkIzhqpG4gzqjzVcRsQFA4jHQsLaeutrF1wxk4VsUsjouLBFqz10xER5kEF30a9nmsfM2oQc3ycEg0JdKOhEHxKnXYQ3Sf1VFTvllIns0jwPoyPwghM0RgRkHdW51Nqi84Zhcj7JDbp0XSjFgJO2THR+IWowmiQXErZESny+MWDRHhQ59YUtSJnVUuYQdnxWIxFHaOXT0E4ZXq15QJ322OsjA1JYBv/KSPNkLsTTeWC+/7a1w65lJv6CYTcp+4irPwApyPsiryWm86cMQJ2JkrifKLYlXVHH607KQkko+FMH6VkKdCVl/eHmHSWYlc58qXREXqsUZejnzCSMNgQrlSyUwe4sWBFYSqaCpErSP3t3a6UEMEEfZGePFiJVG86mhM1mcwF8rjWhIOo7GC4qS48oSSwHYO8zRJRIhtNEArpRICNYnSIYkjRJEVYo7XmdlNjQ9xzKe2M2vTA08c42lMY96HdlXg7JGASaCOgoFBN1MED2Sh4KcPtOYCe8j/dSjpFx6e3qKhM2iqXqHNK9javW7/skHOMEJcvVXHAiZO9AnY/QSqdt66shyzhLk0shvV8dy7vmlu1whXVYcO04j45napP9uKfD0WySg+fQSykm8mLiEYniWz8D512v3/YqLSTNPyS6G43px3nzHtzfbLY2fuOLNuwyl88h0Jo+9rzUT9in73FpYnpESPzZJefailI5Kv53KLiY2xWwBNEHvDN8QVF16E+P3joXaqYbPUZsXsXfb+iV5gm8qz4WGS9HBu+LnuFW7LVNFis42LDy7rzUkc37AiPSJV5ujN2xZUsu9Y7kE9nqddBeiRuF5E3v6sMFXRaqBuOpFGSkE5pWsEEi40WugiMbXXo3R+JTro5vuUD1NnW/66hWLZ9QFrAzcnaSmLxsaIOZFeWCSmtSVlYGnk2nYkpdTBetYpSsk+JRURzgFK5RUJuywYLQqzZ9CIJw/Zk5YtiiaSIbMZ2KSHi2inEDAiI8Gel4Bohxe2/dpQJiz2rslVNb71wOYHWKfjJpQQjqMpDkGtn+6aSe6YpSZmLlyqPmIe+rj0OwQc3+czkPfZv4exAqOAqRwCs7oNQo5E65WatNyR3MSiMRPEzpMUlPbsp/F7Ctdhauo7i1QqhsvGbUh6UvlIvMu3EYOZI6wVK5vzupul+yEFOr/K2I6Fb1sgII/CjPYeJjyEwsyeZrHM9m2FUKXfJZ+rx2dJvOWSNgp9dYKKcc6NdnJJ034Yj5gFrpvw4ib82z4/khkF04mib6jyWKfDAOhjiLU08lWMhnnR23z9/dSZTLIh1SQ+VxAyyZ4N6RXE6cd36GSJyvSfJ8VLvkSDj9YxtvcUavWQi3KslPKTsnpuY5otGlhXX2LnNNAW2Old1+1CnmsKqadFHFgAa+9HlMO4/Tr5JogJpR40xSC0lh2vZ1m2Q3aStoIqbqye7nEUi4qMeiHlR48IdqZhhJph+So5/HeUqkb280nljD2rGDPZ+o+dxGvaMF5V8fdmW3RlmS58ETNfsQuMV8r1u/fkcbrS13cR296NdbWSPuIwr7hv2kk/WHVirK3rLvV0faCGcl0+KiQ5KI1XdObW8Eups/wxk2DI/mI56VbDeLOBbU6zD2RaxnunMJEsgDrYrMS3KiMBHRZrW2UhDtntXH0khouRbNGi37vmRImJxZK48P5CgT7WeLfzdBBV5U/NHxET5ezMrJ1GnlpN8kynWHsw6QTeWWtueonnqbBkf80buTdrKQchaFnA30ipv+JSCRpI9u6XBY3fD3A0rO1oCaTfdrttSqoAltLBCTao4XeXvX23iYL5MWlMJRX7q8+Yy0KmWhy+ZD6rzUpmWF4ZeWRalGnlPQKq8keJRHto7Vx81sHUijpIsaO+p4kvEbTzF5UjMJCt7uQ48KY1kLWcymkb8tNJMa5xDmi/xZY1FMHCcIDyB6IraAW1spFu7nKa46tN2XaESEyqYiWM0fkobjadmm9owVcdn4RfoeDFS3XrZstNN7IJNWEoV/HFI1cwvH2ltOINZUJXZ6mo70ApuPWwvcTyrPp3vzxDPkCVGSWRrZN0/xwvHWKauoi+rw+WwQ7gVYg5Nai8iTVN5tueSujJ1y6Jhk3pZXt5S4uaDkFjfGMZHUD8MbdV78mjAJ5Oc4B68DPvQFtR5OiLUd1EhhfNN6zIOVSyx36zobH3bppE1NOnuFrk2sV6I5bBwzEHguD2pFDA2CyTZuJBhtRNJkzK977AOhphHtj3aLpyFvtNB5z+yNCqlMV//g1ewxwIRWIDIFHTKYLoaJHSLdTSLiGksgIJ2lZ14dzgLyl5E6bMa0RQHm0tUOFddVHA2zPgPjkxS4wO0t1UruGz8W8C0AkX9AE11Oui4Q4b8bXtq2Io1eT5lUnXxKJyJK89+ftKu+DrNrtdUXXOacdSUlltLsO8Tn+BKCyIoQpqLVe6RdEvAFFsdVgQvYIG3JNGsnxfqm5IJBXo6zCAg6O/U/Ba/H1MYF7D+aOeHP/4y+O3tt5+AnavnTlX66oT3NdiFRgzFdqv7IapeDsSykFVP0GJK+PbvnfREQDfQJ/TBDcjaURtsEVJOcYGUZA4DUVwqbhsfhU2h70MGC5DMi9asZ1fvg3dzUK7fE0ZK5ToslXY2IBPKU4kQ0ADlzJxMTZHAKlOMU4oBKs5L7frcxc5Its5ZbV5CFot5Q+TQikgh+aQo1m/QWzv+aNwUK/1DzQkY8UmjIucqEqcER/AQTIODOGR5eVRP2ril5IgNjZ32PyZrr9Zi7+5kuNuDmhxe8ARSoQhcASXzyz86P3rxFpX9OXvqF6X3bCu678ZdWhmm8I54RcN86BwrlaNOJmqzzSFAgO9BJKyq8KuXn2hvcSTkkWBhyWR04mR9sSAgQ9ubt8TyMvjn74WuFpgEhD2ta27eOis2mIl2RGBXdy3hA2PlQYebzQjAQnFr6bA+l1QBIZNoxxaQOz46Gj6EiAv737RikPUzKBuFMABZHRAnmU3NJVrVKSHKERSUGhU8bbO4g/Mo3rVRuLtNdpoxBEKpSYxFGAJrpgcNTZilyepSKOSUMmREFQVm8lV7TXeYrZbW3gsHG6PCRrHb+CwZEBV9Gq2zdDTCYuculvhQNjuNM6EON4WNCNaNjwSLHIJdpicMINPWRGfmjHyNZuHSM3ei+Ma8P/ER2W+oozhYFrcvZkURMnrMsEGMX4hwQ2Eong9kTBPannqdmowX+eWse3y8JtzbdbpOl2hCkpEqAnGW66mq7tyWJ1/rJeRPE8dO7C0HPxERT1UcxFILcWl6ay5OK0w6ImK/N9XdPwSsbeSQFL7iSXpo2up9u7ZkGhPAubTiq/NRB7CdGwlJVM69Z5QVBQi7c8IjiBf19B8SUe/n8oIq3BDsi5TBR5jhO0HEqWU+nXEwR4pBKqi84anVWxqJkaK+UGbkSzmr7oC8DsGhlqHqOuEMr677M+8IocJrDuzwY8P4cqFuC4RcYP7Roz3wKLTQrPk8rOUAxCQn5SRroT9pi5CNqXdvDp5RGPUriyyXKd1pgz7a3EaHk20dpewuZptkFsjUJV953A9ACLz101kzSgvMynwXCezJ26LNqhwvEkNsmlVlelLG4FNSccxMljil4KcGC2JHPW8nOd9CA5XhOwMFkri4C2GfTt4tzCp6YqSvdgNy7zh5L4rZi7QHP6UlIuOPXudv00qj+6eRUim1H62PX2vS6/GUoDUK66JG9Kj1buuzqC1Hp4Wl8hfZSKe/cG8wcTWQHzR/2Eyuyhbo7GXNVNzPE8tD4IWOTxUQK5cXNTmmHw49OLRX6gSIJ2rEYOGEBDvFoJVimkKMDMpmS29eD332Y552OvLrf3iOqe/xKUDQmt3oyx86GzFtK2nGtnGI65+m6iGU/IWKyArHfat8BX+UUXiDc6u6sg3TWFBxJVUccZUTfDKg8yCmT12suqmnpPFSO+d5qBW0oZ3AQ8EEp3N0wQiy6knQG46GCJxDvkNBJWTLKXm0mjEzTAjjsqrHkT4q7aPUBUJW5p7sxjVbeukLn1TwevvbxKM+JNzweAMBw5OzTHR0k7Jox5g+PnJiT6SfrtSS5kuFsoHEi71k8mEoaBWrAFduWWS68rDlTODyxeoEgrJjFW5ClJODezz6B3cFy+4wldUJ0miAbGG8AmmdLEHqml1cS4VBCq/8cCtgci+HYQEPcmSimm6EuNsiZX0XZqUENUYYIMvSZRxLjZvV/XWNrdI1O7C6ikO6K3JjK7qtqrD/OjYsyH14tL7kSAWDWbly15dmHNn32AssoJRFLsSQ/EPQbn/UraMEabkcs9nRKlWKgCrg0ZLOlrsWH6s5zbMjJWZJryTyIGzR4PrUUpQWPXkxKc3oXXcz2CNqSjieZRaNNCDwGsiWxgzCwatXojpyFqyvEPMOqmdDFtShy1oKdL1xwNBpJKmkd7Wqy2TS9mx9CEEIq0ZW0bO1jhd06FdFIxQyBlB+kWFYkbqnXuTlNh4+wtKcLoMm4XhgIsl1NxN+AnIOrus6/6Hurrg/rN2wLDecbBEabrGNeVFjIGyrKIIuVQc0YSodQi6rUFSTt4hkYV1e222aD8crXMGmRXCfJtWnJfU4DBhrm68VlZcaLocpC5oiIn5ZtS2qR28Xl1QjwULmQm6iQ9lRNjqoo5g97XCjdbdWK5d8WDEharQPM1wTCwKSjWpJEAo205WS6KQqYL3wlrRMJZMJ+UlWVFWf+S+aF6LjtwjVbBbNBIh62gJRy1EZLOqOyrV6nXN7RI7IZsyMQn5OmYJMIWrd4qijdS3FENSvrz0bRcSIyBi93dC9EDDEVikRaJ5lazluMk7RbzILVcqGLfpdyb0AR/SxiCibSKuBta7lNTwsujvY91BYBSz3GS0CUAQBqchbjKxEbsi9Z9OSJJwVdTehVsVYZzTKHCR7A1G6jaInkCtRIZULHymw0BllBuSCHMckBV7y9SSl9uRnwpImxQuBGgfRbtPN2QwSpIO4dc72Q6mahaVlGPKdwlhlvIV2sux66g9rtBKpmDzeSHRdbFr8eeFWGkfl6/Z0s0zRVqDUD8iCEyxIFs1rxHF6ASEdj6X8x44fcNQvvSdm/ZXKzYdpP1h5cfmD1C2+3EQjrYLU7whvaYnsdc9SM6nUWSSrOeBFuztNnXctlidIEpKVSDBlf+pOx1E1oSrljSq3RTMPmFHpArm6ZYj1UtHGOje0FMs/TELxL4RP3PDE7LovSeehweRONjLGSVEv48MSLmoZwmxOUUVJGCUiNBdeBzekUKnM8izMmB2tu8uxXWfOtVmqulh0MI6PvITv0KTViiTDm5P0xj8T2QTHqRRjHbkKRp3Pz0fIWi+cm1EIFsiS3XUy2cnKFlv0kyMoQ5ZDqsjCHCSGrHrF2hOokj7Zzmp6YuHubUqxKNxrAm3Vqx0OBp1AzCOU7eJfO4UIsT8nB82AElXYboFWpBxlCyVHLiXe8jyxICfNiusxE6LQA2q5qyR5gt2CE52kljODHOnLiZiJrk2mTBSTFwxj5NRmo1CiAs78LLytS0S3sfA1UyeMqNbtVVhumiEu7cTmiZ1cfh2PN5Js08vyLpqlFetCcn0FauF6UORqjC7NOMMQ1a/zBrEZEQ7qMhpQON+7oUBvdxE5+yOanKcyhOtKFBG1QuxxUQb2Jyo83rqp2jxn79JTsy8tSSU549A3SCpILNeQYrP7DhAwU7c2Fuuaz6rUx1NkMFGbRHBP4JONbZOszFFvzKIBv0R4UeHgnBaUa8V88gRXXpMGIHW3K4zSlchSE+YkmARrvdV6i16L48u93CgsUnjLYIwdFTVVgqSF0Gjclvo0RifK6uLUkP0klEvdqlezNMP5bomxLVjyvMfP+4LFLhv2YQaK3BhkKte7tffgGy9kWabJ0qTXD2dVrkVdwZscJRWnDnUgJM3nw2Q2mQp1zgjOTj3PYeN8qyEubkmgxfGOvlTJp26JTOZWzQYsBtwG5NKZsBjPJCw2v2zQp89cn7GEnh4JNXzKXMoY2nq3sd6TbDqVWjGgsXmzE00QQOsf1KVTJ3d9vRZFUxT1S1ZmwhaIiMP1irEnuI0ZcP3E08KFqcnC7kd5yV+qHFsBcvXdYMfAmh46meJcVVeoNNlZc/T1VJIYOiqdVwFpXwgd362EMYQA8v5P1oGgxm6BiZV8Gad6izCd2yoVaZxUWtGvcrLaSLAaX+Z2S64elZGttEKK03Ol12b192j2oKLekOJAco7vFxSQbHSleu/JzBVVjETn2xr+1RJM5BVgoTgoknIqv2ssfpTedW0upYFvM5pWQFlqrdntFGQzMvF1XAgWzBUwjfRFiSCAstMI6oESyVATImWXimhcI7cSi92DTav7yqAJXbzF0k9m5k+yeVf464DYcVZGsyNOO8OEPpxoI0fvS1OX+cziLoz4tc7kD9LUfNdIMmZwdZag3adgYTp9+PkkXwPBTDMiQlY115IKU/3UUaeI5+g4MvCxBoHnGH4xmvQGRQReg3Fd8oViLu1q0c9SnMSzshA1zhJJh+ovMVlKxtAOxewgadWsw5iRps7qtp8UIiVnTiY/9x7zzV8SLToYzCruQGGCB0UWqg1aoF8ulxSstnuu1A3S2bTuOeGERFjqOrXgGhrrU+xQ5OGizSKKJiIuW632yw6EBq5ZRy5tkFB4c+ljikvL+y3+IKbZiCZpqPImY0FaNcMICxH5Enf1bKtXqA1ROUwLLyBfuKpKEkYMchLjoSRexrNICA6IV5gFyDw+ldXHNrn5xrIqjV7m1Vwi6SH3MrH+be2FfOegmNQBqjn4ynRyiqJj0puFtvmLMBQYepYgn1rrYhXSOehTgK/PDotZdMrIvMaqTParVm4sKZfTJQYqFnC43BZ6T8ZLRvuV3yps0xTuxTk8mQU4ER91iHigZLAbKUc3UFfz6p5F0XysDiFVWvgopcaLjaFOJG7+3DFhYg2RybJv43ecFAE35mltyQKYULqU3r6FSDVU8LBteOyxXDmwtbAWp8uuW9LDA+pZNk1HIHwU1U0vVM00BN2inhjnEknfvbX74yg3Vcts3uX0uHt10b1uuHkTn4+QejpxcN2zE3kbNMqDjJI/kqIiZ81CjcL6Ibmw0rNzDhaJm+OQOgd5J4myO0+XyVE5/d//KyUj1pCSTvu0tlGCyRzWJQQ1CDJta32inFXe/MninTwbMhwSl70Yg8Feejvo2MBqGlJabBniwE7zUaGqrJMLSW/KlUfUPWFAbA9mAbZkaUbk0OEf4urc7xzozscp8leJgIHA6SpJ3agl4bg5wS7Cg2saSE45zSH83NnWRZQ85+uQAVutspobyCDiSBdOgIjmHhc901Fqdvu/zCLSRWbt5T1PYvfWCJs7tGwxLeiuzFw6uHL8hiOy7xhFU5yKDRx1MVVs779oo5AdEwNSYX3KFvzG8BaQ4O+ADuDVL1pLKQj79xQ40fggibczk7I9oQGB28v1GpWiopcMqQVp6HwIgJiFcKHGBAkDv2aU9JDEwqrkPES+tzdEkhZ4JXfqRSA0o+lyUZMUZW89F7/+FPcNcY8S/47KGz7vdagOw5w7MshV3KAjOcMKxMX6QxwEKaLby8LkKe47DQFSZKuhM7KcJoGHq9GGxySnNPkq71qHYI/mIpMonEKGkYR8NbgQnE8jg+OD0mTaVX1W7XmfxFFUTNaWbgF1Ek6atcxBSBY93n1ILJHH92OOjF4u8z5iKsWE83tG50KKrHilWpX19AjWKFHax/9v7VqWHEeOWKJGEZ7//9Q9+ST4QLIKQCZ7xmEfN1YjdatJViaeFkkvL7oGRp4pSvZpSHSvOpEIE/vvUgelTiu29ibeojyaWhxrvWkU8ZeEYUt+Wy5v6HJgm3aqGwSZR9iqbDiEKZa092ZaRpoi3xgVozvwpI+fSx/leFKeU+HiCq0qZvqoZx/rMjR23OHTdEJVxDO0EMmCcRDtPvqSbz44UUo8B+MtKz+yU4MuGC5/1lusdVPGVhQfPiEC1GTte+i9myAtqwcql9K7fcsIEPxjTZ0HHpJdVsbz/yMLx7CowfzBgaiYyTqFqZDIbktgp5nVq4b7Y53IsVJjicBf10K2zv0CW3KmdrShmJTd1DXMXK8pxSA9rvsSAH6Aiba6ln7B0Ni6D7zZk6HQ3Y9QehWHtHoaY6gRQ/sMoeFNAnjwPiPgq02EDPnQd7mvfCpEv8ztWmM5zaiETj4r7k2GI9JELTfTwKP/4rYgKjSobd4KD+lVlRYXzUspMioFHitvjybXIACblWy5UXo94kvR8OvIV+BKWdgb2dOYSwzfG1F8K37UgWYpFH+NIh9mITrs6nHbVLVc6ftwlAtWvixSbVXQzl1lpyOG94GqtvLx2c58e77TsjSSTrbmCN7ZL4DY7sGclkrtaVSoKuyyOmxBCtMgea0M4PMetBYrDxWXsInQXfBnZ7MzuSjawg9NQzPuTTfEjSU5f41hTKipXwTT8YFOuuhCgpYlj8lF1iODxyhvzvpD+TvJlCxTP98CherQ5vXE/jjUj9PQXOf4cUWixcqJxcJbcg865m0gkcyGqktiVdVSImTXNwn7dQKiLKyIp5qHHq9oDVlwgJcRF+xSs34beY4cNZVKtAtEEujimnZBpFxZu7arz5gTqsVmjENqdGlxbTVdb/EOaDQcevtg4UX/q77cH+nGie3wGYmYfl7QSEMd1RKB27v5WbGMyXXfjf0gF+JOfjx4FKon4rm04X/QmGzBChftdQlFmUy9hNNdLU9LxehESEbSsGi9Bpaq6AuyCGst2V3B5Wv6pLpwYQbDGLU8n0hA6Cb8r6dEhBGG4elC03i9HC9+USGia0JTBwQHdFPPy0k/EkQihv0lTbZb+4TUTmEYRfV0SQYn0d7shrZFQZtvN1AsGDsMVC8vhgJfvt/7WVsFxIi1RwWCKQSClaH1y9WddnPWOqenqxmTtggNW0oo4hNHYHeUoCfHf93gvtkdK576ZolyBPrcS5ukuyeaK8ubBgf7RuP5TUQGwQygFTFR43pzDfgm02b9HC5cxUm6mBN+pSN90Ip3/rG5R1Y7mWDsHSz5x64wZ2IPIs23EIkmkoFKUnxAOQnW1X+2i/xaPnXdN88HiCDaC/58EU8zcTPGAwxs4UAF75+tTIwTdiQzo766CMGXBVrt+HFgcdEyrLDfRd2zsZ5JpGrsUSa1mfxWexh9c/55f/Ki3sx/UCw6YfHGoj9WAfv/qym3plzevNIWYWDAITHZTo92e7TO5xrrFeSz17yx9JjscT+Po+URCOfDgCKWECiZ3hiC/r5EpLvbS24CmarLckcHQ551mUGMB1yPbMUxr7JSqbtgAfYqybthXMtf723++lQTcVrnEUIVjjEGLSW+6aD6VN/uN8mWJYOtOYcjRLtjxOTkl6bsSZX+k54RHPI8kEdHBqX1rBTYziwqrOZCH0QqaPZXxI69/EtYhDoFCfypAipG0jgNiBckfDosGSVBTp0e+9KnumH8oEswhUmuD6f2HHKHRNYgFIVhWTaWa8mui2ZHKUqsAmgBImswVblhhGrQl/4CawRBRkzzWHildx13RdVetIYoxXPLhQJlYo2mTaCCJKhXNHdYxyeW8Q3Rbdr03SzZZH/MKkI/kiLiJ90azRlYqSKI2oRFYKAW4/OZyJksz+snnRaGttqW4J83Aas+zOtNAd9s4ltxQPj0ctQSOKqtqBMAJdnXiLvoVTbWEywtZUN6ca3CtmJZse7zMjuVNUfddQhsVBqX6t1xs65Of+yJk/5Hk5pPSWrgX3CBf3gBXmn59uilcRzExOsNaBIwdMatrqi9Yc5VL86sKdEIj35x2LehIW+UsQnO22NajxQjWq5CD+X1rRaXYk3fDe/3+aBRd6ZdbCmYT0bufbas8KjTZeP5ljAIlshROnum9D6KEeSsA79IixKWhqvjVJdWqcBvmyAriRS0Wme0hueDZO2ghqXmdxdmoz+N2vdVvUdiNhbWsOq23fr0SQ8eE6AQC5HUerj6sY8xJzgB07YxFVdxpwXFB5qIq6gCRn8v3cQxhOMxxfJiCBEK6uhRHdg7q/3nQQksozndgJhUWJUtJUJwaLTac/Q0KisSUXCBvRlEqruYSGcFsAt8+Hv+7f3Tn3uGGsJ7sg6p3vdnX1eWcPREVVRvnnWPyLT8+jm+QQZxilk30JI5gncUtSZ+9qLPaLSdIkXMhzOGHb93i1yW6GW8PJd/wGLkhbod91nh+Up/rPzmlp4+8mfZD48jZT5XP75AWx72es0LxXKHSJn2dHedaW/yLc3rMXMlxDAsT5ABlEWskV1k+AIp7y33CTpObDrJHW91xjYG66ThwtLX7imHDJaw3ElD2xqHS/22NsLWbjg2Fr9CQzH3g2sZ+Js3LF4QYS9THiMWWeNIjyZx1LUll/Xeg/ZtPtzFVQkn92z1hqotxun1FLJz1AS4hFg5MYTeMMJ+Oa52qAI+gxzsNHKKS5eRH3WWJtIefxsECw0LqikMtWwk1BxIvTkNzoqkBEIrbaQmpw42LBg0Ms96SGindkDDHWWUDNfwJzZwgvByK7Yr9U/q9iS9m2YkgUiOpHkvSvDA6T5b6erSntiIJg0Nilth8IJbL4cG3lFnBbfley3BJH9ReZbi1u8Vdqvt6HBinJ962ixpWYUSSH4TCTtNDtl75jGhO+qwdP1lZHKefDht7dl5u1GXIOT186EEV30VgrrS3z2KRMNxLfBQkojP5pTD47OBwY2EyAx9tGI2XV83N6kNce8JyA1mAd52kIH+bbFwHsbji9VpwrJ1Hlr4d88RQ7zvlClvsxQmCf9yziG2bK09zDYdzvYoadjjkGRPL0VTjPhZtNkcyXsSIj7Fb0O52pohFVNGmHEejPkCboK5xiwL032aGXsTVAXB2EsKS3ucRG6V0lt1tfvFatmLEox4/pXmUCWviHnhLolw1hVKwkyzr6SMRkJXJ0631NSuXjUZ7GCby8C5pOBjSIbGyGujdaKhCbjQdJUyqPEntXKpTTmmzWmx2ocpPcTFtjbCMNzMtQL4qQJAGfzlQvQqA5urbAuC83J7H5Jsw2uXfnzpsTpXlMq6n+Oh9vG1Fq2tHtabVdy/VuBprVZPBq+lO279MJpF/+gu04Ooy4QaN/lym4jZpRN7/IE0XsX6y3xeUJ+4vXkpJLUGNi22q1xrD1KkEUfEGLoQh0Voo2DnHqbw3jOxrkGpOdCwRCo2I2qIWobAREge/Pc2DHwKqC+4HkZjX5H31zSUfkyHq4hon5meIi2vHeNDtZkMaSfPdXhZfzn8XaiPVOiYJdpxXUvgcyEkqUxODumt8gklamzRzO0Vx+D5rw5ZwdOID8kIAxHAPFCGW4eDXapak7ihjXM+aVkLrakFd/Vfl1flBJVi3+6zf5N5CeAHs2khJD9NHUyEOJ4mxvLoCFWVVC/WNUR8myc/kjENtOJmixfRaie9OEpcFs/3+OBnIk55Qju2+L3JNGVqZo5P1Zp47nNBmJhbX+i0i3pfNdbdbk9E520fnSiohVcRlgiyRFcMPWX4wqRj1oG8Uh6vA1UiYWzKi5YcPeJWL/7EKZSLKzCydXKKbl4lDDGBL6CJS96acJhFvGcGLS8mwCn4KLnMbUNe7zkNJ9r9ORM+u06Mp2/vJHjgrTmdUYPR+jsf0TiTbuoxVUQravO0edHu6uJBN2KJZI/KO5hE0dwh9qvW8WOEL3jXPp9NBBZjDAuyShPPOV3+x7Z0TJOFyxmZjIfn9+Bls8fcilDv90dYa3H7PPUWzRxFLC43z/cbcFKtcIYl7DCUHfME/foClcKUmha73l71MReu/BGZG3tALxmrK3k9umGsb67+lhGkMhGvVcg4E6Urjns8/cLwkjSN6bE0LCjw7HJj2Wr0HtkNiYunRd4WxSMk0xAQg9AqJDh/c1cw7wuMQxZG3rm8vKMjnqf9xmYRq5AKUaLzDTxjWaT7urpplXdaPbqRtrXUO8JF+9VlmyHORniclE8857C6sE6p28vD5j6EPr9//X4ys4xS1qc08a3Fg76eTCC5pWiVMXwWVYrZ/D5OSL8Z+UTs0u5PVhXlPZ+3/J7n8YUSF/Vf3igxDyF6Tjv6r1bFnZdF3fj5vHE0N3LXnssezjijKb+wUuf0/lLWEeljHMH0UM+2q2oCzZqrOvdDE2/p1wjmQJd4ngYHq21Oet5gIpymnZ2cfjWuA9V3lIq8UmiR44Y1E1hjA4fBXm06QnGqilhtqTNw4Nfvzz/8d8kgpMNFjAX7ipd+HQqFqGz9PTixrFCE59Kn/jd4XZKmoefdvUOJAnouUg5vmB9jP9YRsOwPkohhA52ocgP2ueh7wLWav6hDM47JDDyjZZWlDLOLTH+UMeJ1fV9sYt/+siFxqB0fJuLa1tHEjF0qjm5ruu+gZRGXqO6l9PQs/yxjLNDkX65znACsc3NwqMa+umn1xcS//vkPIX9UDXQnY5kAAAAASUVORK5CYII='; + } + + /** + * importImage + * + * @param {Buffer | Object} image - an image buffer (node) or image object (browser) + * @returns {Function} + */ + + _createClass(Filterous, [{ + key: 'importImage', + value: function importImage(image) { + var _this = this; + + if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') { + // browser + this.canvas = document.createElement('canvas'); + this.w = this.canvas.width = image.naturalWidth * this.scale; + this.h = this.canvas.height = image.naturalHeight * this.scale; + this.ctx = this.canvas.getContext('2d'); + this.ctx.drawImage(image, 0, 0, this.w, this.h); + } else { + (function () { + var img = _this.initImage(); + img.onload = function () { + _this.w = img.width * _this.scale; + _this.h = img.height * _this.scale; + _this.canvas = new Canvas(_this.w, _this.h); + _this.ctx = _this.canvas.getContext('2d'); + _this.ctx.drawImage(img, 0, 0, _this.w, _this.h); + }; + img.src = image; + })(); + } + return this; + } + + /** + * Apply filter - e.g. applyFilter('contrast', 0.1); + * + * @param {String} effect - the name of the filter effect + * @param {Number} adjustment - adjustment value (mostly -1 < v < 1) for the effect + * @returns {Function} + */ + + }, { + key: 'applyFilter', + value: function applyFilter(effect, adjustment) { + var _this2 = this; + + console.log(effect); + var newPixels = void 0; + var p = new Promise(function (resolve) { + _this2.pixels = _this2.ctx.getImageData(0, 0, _this2.w, _this2.h); + newPixels = filters[effect].apply(_this2, [_this2.pixels, adjustment]); + resolve(newPixels); + }); + p.then(this.render(newPixels)); + return this; + } + + /** + * Apply instaFilter - Giving a predefined Instagram-like effect e.g. applyInstaFilter('amaro'); + * + * @param {String} effect - the name of the filter effect + * @param {Number} adjustment - adjustment value (mostly -1 < v < 1) for the effect + * @returns {Function} + */ + + }, { + key: 'applyInstaFilter', + value: function applyInstaFilter(filterName) { + var _this3 = this; + + console.log(filterName); + filterName = filterName.toLowerCase(); + var newPixels = void 0; + + var p = new Promise(function (resolve) { + _this3.pixels = _this3.ctx.getImageData(0, 0, _this3.w, _this3.h); + newPixels = instaFilters[filterName].apply(_this3, [_this3.pixels]); + resolve(newPixels); + }); + + if (filterName === 'mayfair' || filterName === 'rise' || filterName === 'hudson' || filterName === 'xpro2' || filterName === 'amaro' || filterName === 'earlybird' || filterName === 'sutro' || filterName == 'toaster' || filterName === 'brannan') { + var p1 = new Promise(function (resolve) { + p.then(_this3.render(newPixels)); + resolve(); + }); + p1.then(this.applyVignette()); + } else { + p.then(this.render(newPixels)); + } + return this; + } + + /** + * Overlay an image on top of the canvas + * @param {String} imgSrc - the path to the image you want to overlay + * @returns {Function} + */ + + }, { + key: 'overlayImage', + value: function overlayImage(imgSrc) { + var _this4 = this; + + var imgObj = this.initImage(); + imgObj.onload = function () { + _this4.ctx.drawImage(imgObj, 0, 0, _this4.w, _this4.h); + }; + imgObj.src = imgSrc; + + return this; + } + }, { + key: 'applyVignette', + value: function applyVignette() { + this.overlayImage(this.vignette); + } + + /** + * Render the pixel data onto the canvas + * Callback after done applying a filter + * @param {Object} newPixels - altered pixel data + */ + + }, { + key: 'render', + value: function render(newPixels) { + this.ctx.putImageData(newPixels, 0, 0); + } + + /** + * Save a file to HD (Node only) + * @param {String} filename - path/to/file.jpg + * @returns {Function} + */ + + }, { + key: 'save', + value: function save(filename) { + var type = 'image/' + this.options.format; + + this.canvas.toDataURL(type, function (err, base64) { + // Sync JPEG is not supported bu node-canvas + var base64Data = base64.split(',')[1]; + var binaryData = new Buffer(base64Data, 'base64'); + fs.writeFile(filename, base64Data, { encoding: 'base64' }, function (err) { + if (err) return console.log(err); + console.log('Saved as ' + filename); + }); + }); + return this; + } + + /** + * Render the image object into DOM (browser only) + * @returns {Function} + */ + + }, { + key: 'renderHtml', + value: function renderHtml(dom) { + var _this5 = this; + + setTimeout(function () { + // quick-n-dirty, to avoid it renders before vignette is applied + dom.src = _this5.canvas.toDataURL('image/' + _this5.options.format); + }, 10); + + return this; + } + }, { + key: 'initCanvas', + value: function initCanvas(w, h) { + if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') { + // browser + var canvas = document.createElement('canvas'); + canvas.width = w; + canvas.height = h; + return canvas; + } else { + // node + return new Canvas(w, h); + } + } + }, { + key: 'initImage', + value: function initImage() { + if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') { + // browser + return new Image(); + } else { + // node + return new Canvas.Image(); + } + } + }]); + + return Filterous; +}(); + +}).call(this,require("buffer").Buffer) + +},{"./filters":1,"./instaFilters":3,"buffer":5,"canvas":5,"fs":5}],3:[function(require,module,exports){ +'use strict'; + +var filters = require('./filters'); + +/** + * Instagram filters + */ + +// Normal: no filters +module.exports.normal = function (pixels) { + return pixels; +}; + +// Clarendon: adds light to lighter areas and dark to darker areas +module.exports.clarendon = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + pixels = filters.contrast.apply(undefined, [pixels, 0.1]); + pixels = filters.saturation.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Gingham: Vintage-inspired, taking some color out +module.exports.gingham = function (pixels) { + pixels = filters.sepia.apply(undefined, [pixels, 0.04]); + pixels = filters.contrast.apply(undefined, [pixels, -0.15]); + return pixels; +}; + +// Moon: B/W, increase brightness and decrease contrast +module.exports.moon = function (pixels) { + pixels = filters.grayscale.apply(undefined, [pixels, 1]); + pixels = filters.contrast.apply(undefined, [pixels, -0.04]); + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Lark: Brightens and intensifies colours but not red hues +module.exports.lark = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, 0.08]); + pixels = filters.rgbAdjust.apply(undefined, [pixels, [1, 1.03, 1.05]]); + pixels = filters.saturation.apply(undefined, [pixels, 0.12]); + return pixels; +}; + +// Reyes: a new vintage filter, gives your photos a “dusty” look +module.exports.reyes = function (pixels) { + pixels = filters.sepia.apply(undefined, [pixels, 0.4]); + pixels = filters.brightness.apply(undefined, [pixels, 0.13]); + pixels = filters.contrast.apply(undefined, [pixels, -0.05]); + return pixels; +}; + +// Juno: Brightens colors, and intensifies red and yellow hues +module.exports.juno = function (pixels) { + pixels = filters.rgbAdjust.apply(undefined, [pixels, [1.01, 1.04, 1]]); + pixels = filters.saturation.apply(undefined, [pixels, 0.3]); + return pixels; +}; + +// Slumber: Desaturates the image as well as adds haze for a retro, dreamy look – with an emphasis on blacks and blues +module.exports.slumber = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + pixels = filters.saturation.apply(undefined, [pixels, -0.5]); + return pixels; +}; + +// Crema: Adds a creamy look that both warms and cools the image +module.exports.crema = function (pixels) { + pixels = filters.rgbAdjust.apply(undefined, [pixels, [1.04, 1, 1.02]]); + pixels = filters.saturation.apply(undefined, [pixels, -0.05]); + return pixels; +}; + +// Ludwig: A slight hint of desaturation that also enhances light +module.exports.ludwig = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, 0.05]); + pixels = filters.saturation.apply(undefined, [pixels, -0.03]); + return pixels; +}; + +// Aden: This filter gives a blue/pink natural look +module.exports.aden = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [228, 130, 225, 0.13]]); + pixels = filters.saturation.apply(undefined, [pixels, -0.2]); + return pixels; +}; + +// Perpetua: Adding a pastel look, this filter is ideal for portraits +module.exports.perpetua = function (pixels) { + pixels = filters.rgbAdjust.apply(undefined, [pixels, [1.05, 1.1, 1]]); + return pixels; +}; + +// Amaro: Adds light to an image, with the focus on the centre +module.exports.amaro = function (pixels) { + pixels = filters.saturation.apply(undefined, [pixels, 0.3]); + pixels = filters.brightness.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Mayfair: Applies a warm pink tone, subtle vignetting to brighten the photograph center and a thin black border +module.exports.mayfair = function (pixels) { + filters.colorFilter.apply(undefined, [pixels, [230, 115, 108, 0.05]]); + filters.saturation.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Rise: Adds a "glow" to the image, with softer lighting of the subject +module.exports.rise = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 170, 0, 0.1]]); + pixels = filters.brightness.apply(undefined, [pixels, 0.09]); + pixels = filters.saturation.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Hudson: Creates an "icy" illusion with heightened shadows, cool tint and dodged center +module.exports.hudson = function (pixels) { + pixels = filters.rgbAdjust.apply(undefined, [pixels, [1, 1, 1.25]]); + pixels = filters.contrast.apply(undefined, [pixels, 0.1]); + pixels = filters.brightness.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Valencia: Fades the image by increasing exposure and warming the colors, to give it an antique feel +module.exports.valencia = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 225, 80, 0.08]]); + pixels = filters.saturation.apply(undefined, [pixels, 0.1]); + pixels = filters.contrast.apply(undefined, [pixels, 0.05]); + return pixels; +}; + +// X-Pro II: Increases color vibrance with a golden tint, high contrast and slight vignette added to the edges +module.exports.xpro2 = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 255, 0, 0.07]]); + pixels = filters.saturation.apply(undefined, [pixels, 0.2]); + pixels = filters.contrast.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Sierra: Gives a faded, softer look +module.exports.sierra = function (pixels) { + pixels = filters.contrast.apply(undefined, [pixels, -0.15]); + pixels = filters.saturation.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Willow: A monochromatic filter with subtle purple tones and a translucent white border +module.exports.willow = function (pixels) { + pixels = filters.grayscale.apply(undefined, [pixels, 1]); + pixels = filters.colorFilter.apply(undefined, [pixels, [100, 28, 210, 0.03]]); + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Lo-Fi: Enriches color and adds strong shadows through the use of saturation and "warming" the temperature +module.exports.lofi = function (pixels) { + pixels = filters.contrast.apply(undefined, [pixels, 0.15]); + pixels = filters.saturation.apply(undefined, [pixels, 0.2]); + return pixels; +}; + +// Inkwell: Direct shift to black and white +module.exports.inkwell = function (pixels) { + pixels = filters.grayscale.apply(undefined, [pixels, 1]); + return pixels; +}; + +// Hefe: Hight contrast and saturation, with a similar effect to Lo-Fi but not quite as dramatic +module.exports.hefe = function (pixels) { + pixels = filters.contrast.apply(undefined, [pixels, 0.1]); + pixels = filters.saturation.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Nashville: Warms the temperature, lowers contrast and increases exposure to give a light "pink" tint – making it feel "nostalgic" +module.exports.nashville = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [220, 115, 188, 0.12]]); + pixels = filters.contrast.apply(undefined, [pixels, -0.05]); + return pixels; +}; + +// Stinson: washing out the colors ever so slightly +module.exports.stinson = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + pixels = filters.sepia.apply(undefined, [pixels, 0.3]); + return pixels; +}; + +// Vesper: adds a yellow tint that +module.exports.vesper = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 225, 0, 0.05]]); + pixels = filters.brightness.apply(undefined, [pixels, 0.06]); + pixels = filters.contrast.apply(undefined, [pixels, 0.06]); + return pixels; +}; + +// Earlybird: Gives an older look with a sepia tint and warm temperature +module.exports.earlybird = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 165, 40, 0.2]]); + return pixels; +}; + +// Brannan: Increases contrast and exposure and adds a metallic tint +module.exports.brannan = function (pixels) { + pixels = filters.contrast.apply(undefined, [pixels, 0.2]); + pixels = filters.colorFilter.apply(undefined, [pixels, [140, 10, 185, 0.1]]); + return pixels; +}; + +// Sutro: Burns photo edges, increases highlights and shadows dramatically with a focus on purple and brown colors +module.exports.sutro = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, -0.1]); + pixels = filters.saturation.apply(undefined, [pixels, -0.1]); + return pixels; +}; + +// Toaster: Ages the image by "burning" the centre and adds a dramatic vignette +module.exports.toaster = function (pixels) { + pixels = filters.sepia.apply(undefined, [pixels, 0.1]); + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 145, 0, 0.2]]); + return pixels; +}; + +// Walden: Increases exposure and adds a yellow tint +module.exports.walden = function (pixels) { + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 255, 0, 0.2]]); + return pixels; +}; + +// 1977: The increased exposure with a red tint gives the photograph a rosy, brighter, faded look. +module.exports['1977'] = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 25, 0, 0.15]]); + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Kelvin: Increases saturation and temperature to give it a radiant "glow" +module.exports.kelvin = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 140, 0, 0.1]]); + pixels = filters.rgbAdjust.apply(undefined, [pixels, [1.15, 1.05, 1]]); + pixels = filters.saturation.apply(undefined, [pixels, 0.35]); + return pixels; +}; + +// Maven: darkens images, increases shadows, and adds a slightly yellow tint overal +module.exports.maven = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [225, 240, 0, 0.1]]); + pixels = filters.saturation.apply(undefined, [pixels, 0.25]); + pixels = filters.contrast.apply(undefined, [pixels, 0.05]); + return pixels; +}; + +// Ginza: brightens and adds a warm glow +module.exports.ginza = function (pixels) { + filters.sepia.apply(undefined, [pixels, 0.06]); + filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Skyline: brightens to the image pop +module.exports.skyline = function (pixels) { + pixels = filters.saturation.apply(undefined, [pixels, 0.35]); + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Dogpatch: increases the contrast, while washing out the lighter colors +module.exports.dogpatch = function (pixels) { + pixels = filters.contrast.apply(undefined, [pixels, 0.15]); + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Brooklyn +module.exports.brooklyn = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [25, 240, 252, 0.05]]); + pixels = filters.sepia.apply(undefined, [pixels, 0.3]); + return pixels; +}; + +// Helena: adds an orange and teal vibe +module.exports.helena = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [208, 208, 86, 0.2]]); + pixels = filters.contrast.apply(undefined, [pixels, 0.15]); + return pixels; +}; + +// Ashby: gives images a great golden glow and a subtle vintage feel +module.exports.ashby = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 160, 25, 0.1]]); + pixels = filters.brightness.apply(undefined, [pixels, 0.1]); + return pixels; +}; + +// Charmes: a high contrast filter, warming up colors in your image with a red tint +module.exports.charmes = function (pixels) { + pixels = filters.colorFilter.apply(undefined, [pixels, [255, 50, 80, 0.12]]); + pixels = filters.contrast.apply(undefined, [pixels, 0.05]); + return pixels; +}; + +},{"./filters":1}],4:[function(require,module,exports){ +"use strict"; + +// Based on: https://gist.github.com/mjackson/5311256 +module.exports.RGBtoHSV = function (r, g, b) { + r /= 255, g /= 255, b /= 255; + + var max = Math.max(r, g, b), + min = Math.min(r, g, b); + var h = void 0, + s = void 0, + v = max; + + var d = max - min; + s = max == 0 ? 0 : d / max; + + if (max == min) { + h = 0; // achromatic + } else { + switch (max) { + case r: + h = (g - b) / d + (g < b ? 6 : 0);break; + case g: + h = (b - r) / d + 2;break; + case b: + h = (r - g) / d + 4;break; + } + + h /= 6; + } + + return [h, s, v]; +}; + +module.exports.HSVtoRGB = function (h, s, v) { + var r = void 0, + g = void 0, + b = void 0; + + var i = Math.floor(h * 6); + var f = h * 6 - i; + var p = v * (1 - s); + var q = v * (1 - f * s); + var t = v * (1 - (1 - f) * s); + + switch (i % 6) { + case 0: + r = v, g = t, b = p;break; + case 1: + r = q, g = v, b = p;break; + case 2: + r = p, g = v, b = t;break; + case 3: + r = p, g = q, b = v;break; + case 4: + r = t, g = p, b = v;break; + case 5: + r = v, g = p, b = q;break; + } + + return [r * 255, g * 255, b * 255]; +}; + +},{}],5:[function(require,module,exports){ + +},{}]},{},[2])(2) +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../usr/local/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","lib/filters.js","lib/index.js","lib/instaFilters.js","lib/util.js","../../../../usr/local/lib/node_modules/browserify/lib/_empty.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\nconst util = require('./util');\n\n/**\n * Filter Effects\n *\n * @param {Object} pixels - canvas imageData\n * @param {Number} adj - adjustment level for the effect\n * @param {Function} callback - callback to return after obtaining the new imageData\n * @returns {Function} - callback with a new imageData\n */\n\n// No adjustment\nmodule.exports.grayscale = (pixels) => {\n  let d = pixels.data;\n  for (let i = 0; i < d.length; i += 4) {\n    let r = d[i], g = d[i + 1], b = d[i + 2];\n    let avg = 0.2126*r + 0.7152*g + 0.0722*b;\n    d[i] = d[i + 1] = d[i + 2] = avg\n  }\n  return pixels;\n};\n\n// Adj is 0 (unchanged) to 1 (sepia)\nmodule.exports.sepia = (pixels, adj) => {\n  let d = pixels.data;\n  for (let i = 0; i < d.length; i += 4) {\n    let r = d[i], g = d[i + 1], b = d[i + 2];\n    d[i] = (r * (1 - (0.607 * adj))) + (g * .769 * adj) + (b * .189 * adj);\n    d[i + 1] = (r * .349 * adj) + (g * (1 - (0.314 * adj))) + (b * .168 * adj);\n\t\td[i + 2] = (r * .272 * adj) + (g * .534 * adj) + (b * (1 - (0.869 * adj)));\n\t}\n\treturn pixels;\n};\n\n// No adjustment\nmodule.exports.invert = (pixels, adj) => {\n let d = pixels.data;\n for (let i = 0; i < d.length; i += 4) {\n   d[i] = 255 - d[i];\n   d[i + 1] = 255 - d[i + 1];\n   d[i + 2] = 255 - d[i + 2];\n }\n return pixels;\n};\n\n/* adj should be -1 (darker) to 1 (lighter). 0 is unchanged. */\nmodule.exports.brightness = (pixels, adj) => {\n  let d = pixels.data;\n  adj = (adj > 1) ? 1 : adj;\n  adj = (adj < -1) ? -1 : adj;\n  adj = ~~(255 * adj);\n  for (let i = 0; i < d.length; i += 4) {\n    d[i] += adj;\n    d[i + 1] += adj;\n    d[i + 2] += adj;\n\t}\n\treturn pixels;\n};\n\n// Better result (slow) - adj should be < 1 (desaturated) to 1 (unchanged) and < 1\nmodule.exports.hueSaturation = (pixels, adj) => {\n  let d = pixels.data;\n  for (let i = 0; i < d.length; i += 4) {\n    let hsv = util.RGBtoHSV(d[i], d[i+1], d[i+2]);\n    hsv[1] *= adj;\n    let rgb = util.HSVtoRGB(hsv[0], hsv[1], hsv[2])\n    d[i] = rgb[0];\n    d[i + 1] = rgb[1];\n    d[i + 2] = rgb[2];\n\t}\n\treturn pixels;\n};\n\n// perceived saturation (faster) - adj should be -1 (desaturated) to positive number. 0 is unchanged\nmodule.exports.saturation = (pixels, adj) => {\n  let d = pixels.data;\n  adj = (adj < -1) ? -1 : adj;\n  for (let i = 0; i < d.length; i += 4) {\n    let r = d[i], g = d[i + 1], b = d[i + 2];\n    let gray = 0.2989*r + 0.5870*g + 0.1140*b; //weights from CCIR 601 spec\n    d[i] = -gray * adj + d[i] * (1 + adj);\n    d[i + 1] = -gray * adj + d[i + 1] * (1 + adj);\n    d[i + 2] = -gray * adj + d[i + 2] * (1 + adj);\n  }\n\treturn pixels;\n};\n\n// Contrast - the adj value should be -1 to 1\nmodule.exports.contrast = (pixels, adj) => {\n  adj *= 255;\n  let d = pixels.data;\n  let factor = (259 * (adj + 255)) / (255 * (259 - adj));\n  for (let i = 0; i < d.length; i += 4) {\n    d[i] = factor * (d[i] - 128) + 128;\n    d[i + 1] = factor * (d[i + 1] - 128) + 128;\n    d[i + 2] = factor * (d[i + 2] - 128) + 128;\n  }\n  return pixels;\n};\n\n// ColorFilter - add a slight color overlay. rgbColor is an array of [r, g, b, adj]\nmodule.exports.colorFilter = (pixels, rgbColor) => {\n  let d = pixels.data;\n  let adj = rgbColor[3];\n  for (let i = 0; i < d.length; i += 4) {\n    d[i] -= (d[i] - rgbColor[0]) * adj;\n    d[i + 1] -= (d[i + 1] - rgbColor[1]) * adj;\n    d[i + 2] -= (d[i + 2] - rgbColor[2]) * adj;\n  }\n  return pixels;\n};\n\n// RGB Adjust\nmodule.exports.rgbAdjust = (pixels, rgbAdj) => {\n  let d = pixels.data;\n  for (var i = 0; i < d.length; i +=4) {\n    d[i] *= rgbAdj[0];\t\t//R\n    d[i + 1] *= rgbAdj[1];\t//G\n\t\td[i + 2] *= rgbAdj[2];\t//B\n\t}\n\treturn pixels;\n};\n\n// Convolute - weights are 3x3 matrix\nmodule.exports.convolute = (pixels, weights) => {\n  let side = Math.round(Math.sqrt(weights.length));\n\tlet halfSide = ~~(side/2);\n\n\tlet d = pixels.data;\n\tlet sw = pixels.width;\n\tlet sh = pixels.height;\n\n\tlet w = sw;\n\tlet h = sh;\n\n\tfor (let y = 0; y < h; y++) {\n\t\tfor (let x = 0; x < w; x++) {\n  \t\tlet sy = y;\n  \t\tlet sx = x;\n  \t\tlet dstOff = (y * w + x) * 4;\n  \t\tlet r = 0, g = 0, b = 0;\n  \t\tfor (let cy = 0; cy < side; cy++) {\n      \tfor (let cx = 0; cx < side; cx++) {\n  \t    \tlet scy = sy + cy - halfSide;\n          let scx = sx + cx - halfSide;\n          if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {\n  \t    \t  let srcOff = (scy * sw + scx) * 4;\n  \t    \t  let wt = weights[cy * side + cx];\n  \t    \t  r += d[srcOff] * wt;\n  \t    \t  g += d[srcOff + 1] * wt;\n  \t    \t  b += d[srcOff + 2] * wt;\n          }\n  \t    }\n      }\n      d[dstOff] = r;\n      d[dstOff + 1] = g;\n      d[dstOff + 2] = b;\n    }\n\t}\n\treturn pixels;\n}\n\n\n/**\n * References\n * https://en.wikipedia.org/wiki/HSL_and_HSV\n * Grayscale https://en.wikipedia.org/wiki/Grayscale\n * Sepia https://software.intel.com/sites/default/files/article/346220/sepiafilter-intelcilkplus.pdf\n * Brightness https://www.html5rocks.com/en/tutorials/canvas/imagefilters/\n * Hue Saturation hhttps://gist.github.com/mjackson/5311256\n * Persceived saturation with RGB https://stackoverflow.com/questions/13806483/increase-or-decrease-color-saturation/34183839#34183839\n * Contrast http://www.dfstudios.co.uk/articles/programming/image-programming-algorithms/image-processing-algorithms-part-5-contrast-adjustment/\n */\n","'use strict';\n\nconst filters = require('./filters');\nconst instaFilters = require('./instaFilters');\nconst fs = require('fs');\nconst Canvas = require('canvas');\n\n//module.exports.Filterous = Filterous;\n\nmodule.exports.importImage = (imageBuffer, options) => {\n  let filterous = new Filterous(imageBuffer, options);\n  return filterous.importImage(imageBuffer, options);\n}\n\n/**\n * Filterous Class\n *\n * @class\n * @param {Buffer} imageBuffer\n */\n\nclass Filterous {\n\n  constructor(image, options) {\n    this.options = options || {format: 'jpeg'};\n    this.scale = (this.options.scale) ? this.options.scale : 1;\n    this.w = 300;\n    this.h = 300;\n    this.vignette = 'data:image/png;base64,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';\n\n  }\n\n  /**\n   * importImage\n   *\n   * @param {Buffer | Object} image - an image buffer (node) or image object (browser)\n   * @returns {Function}\n   */\n\n  importImage(image) {\n    if (typeof window === 'object') { // browser\n      this.canvas = document.createElement('canvas');\n      this.w = this.canvas.width = image.naturalWidth * this.scale;\n      this.h = this.canvas.height = image.naturalHeight * this.scale;\n      this.ctx = this.canvas.getContext('2d');\n      this.ctx.drawImage(image, 0, 0, this.w, this.h);\n    } else {\n      let img = this.initImage();\n      img.onload = () => {\n        this.w = img.width * this.scale;\n        this.h = img.height * this.scale;\n        this.canvas = new Canvas(this.w, this.h);\n        this.ctx = this.canvas.getContext('2d');\n        this.ctx.drawImage(img, 0, 0, this.w, this.h);\n      };\n      img.src = image;\n    }\n    return this;\n  }\n\n  /**\n   * Apply filter - e.g. applyFilter('contrast', 0.1);\n   *\n   * @param {String} effect - the name of the filter effect\n   * @param {Number} adjustment - adjustment value (mostly -1 < v < 1) for the effect\n   * @returns {Function}\n   */\n\n  applyFilter(effect, adjustment) {\n    console.log(effect);\n    let newPixels;\n    let p = new Promise((resolve) => {\n      this.pixels = this.ctx.getImageData(0, 0, this.w, this.h);\n      newPixels = filters[effect].apply(this, [this.pixels, adjustment]);\n      resolve(newPixels);\n    });\n    p.then(this.render(newPixels));\n    return this;\n  }\n\n  /**\n   * Apply instaFilter - Giving a predefined Instagram-like effect  e.g. applyInstaFilter('amaro');\n   *\n   * @param {String} effect - the name of the filter effect\n   * @param {Number} adjustment - adjustment value (mostly -1 < v < 1) for the effect\n   * @returns {Function}\n   */\n\n  applyInstaFilter(filterName) {\n    console.log(filterName);\n    filterName = filterName.toLowerCase();\n    let newPixels;\n\n    let p = new Promise((resolve) => {\n      this.pixels = this.ctx.getImageData(0, 0, this.w, this.h);\n      newPixels = instaFilters[filterName].apply(this, [this.pixels]);\n      resolve(newPixels);\n    });\n\n    if(filterName === 'mayfair' || filterName === 'rise' || filterName === 'hudson' || filterName === 'xpro2' || filterName === 'amaro' || filterName === 'earlybird' || filterName === 'sutro' || filterName == 'toaster' || filterName === 'brannan') {\n      let p1 = new Promise((resolve) => {\n        p.then(this.render(newPixels));\n        resolve();\n      });\n      p1.then(this.applyVignette());\n    } else {\n      p.then(this.render(newPixels));\n    }\n    return this;\n  }\n\n  /**\n   * Overlay an image on top of the canvas\n   * @param {String} imgSrc - the path to the image you want to overlay\n   * @returns {Function}\n   */\n  overlayImage(imgSrc) {\n    let imgObj = this.initImage();\n    imgObj.onload = () => {\n      this.ctx.drawImage(imgObj, 0, 0, this.w, this.h);\n    };\n    imgObj.src = imgSrc;\n\n    return this;\n  }\n\n  applyVignette() {\n    this.overlayImage(this.vignette);\n  }\n\n  /**\n   * Render the pixel data onto the canvas\n   * Callback after done applying a filter\n   * @param {Object} newPixels - altered pixel data\n   */\n  render(newPixels) {\n    this.ctx.putImageData(newPixels, 0, 0);\n  }\n\n  /**\n   * Save a file to HD (Node only)\n   * @param {String} filename - path/to/file.jpg\n   * @returns {Function}\n   */\n  save(filename) {\n    let type = 'image/' + this.options.format;\n\n    this.canvas.toDataURL(type, function(err, base64) { // Sync JPEG is not supported bu node-canvas\n      let base64Data = base64.split(',')[1];\n      let binaryData = new Buffer(base64Data, 'base64');\n      fs.writeFile(filename, base64Data, {encoding: 'base64'}, (err) => {\n        if(err) return console.log(err);\n        console.log('Saved as ' + filename);\n      });\n    });\n    return this;\n  }\n\n  /**\n   * Render the image object into DOM (browser only)\n   * @returns {Function}\n   */\n  renderHtml(dom) {\n    setTimeout(() => { // quick-n-dirty, to avoid it renders before vignette is applied\n      dom.src = this.canvas.toDataURL('image/'+this.options.format);\n    }, 10);\n    \n    return this;\n  }\n\n  initCanvas(w, h) {\n    if (typeof window === 'object') { // browser\n      let canvas = document.createElement('canvas');\n      canvas.width = w;\n      canvas.height = h;\n      return canvas;\n    }\n    else { // node\n      return new Canvas(w, h);\n    }\n  }\n\n  initImage() {\n    if (typeof window === 'object') { // browser\n      return new Image();\n    } else { // node\n      return new Canvas.Image();\n    }\n  }\n}\n","'use strict';\nconst filters = require('./filters');\n\n/**\n * Instagram filters\n */\n\n// Normal: no filters \nmodule.exports.normal = (pixels) => {\n  return pixels;\n};\n\n// Clarendon: adds light to lighter areas and dark to darker areas\nmodule.exports.clarendon = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  pixels = filters.contrast.apply(this, [pixels, 0.1]);\n  pixels = filters.saturation.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Gingham: Vintage-inspired, taking some color out\nmodule.exports.gingham = (pixels) => {\n  pixels = filters.sepia.apply(this, [pixels, 0.04]);\n  pixels = filters.contrast.apply(this, [pixels, -0.15]);\n  return pixels;\n};\n\n// Moon: B/W, increase brightness and decrease contrast\nmodule.exports.moon = (pixels) => {\n  pixels = filters.grayscale.apply(this, [pixels, 1]);\n  pixels = filters.contrast.apply(this, [pixels, -0.04]);\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Lark: Brightens and intensifies colours but not red hues\nmodule.exports.lark = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, 0.08]);\n  pixels = filters.rgbAdjust.apply(this, [pixels, [1, 1.03, 1.05]]);\n  pixels = filters.saturation.apply(this, [pixels, 0.12]);\n  return pixels;\n};\n\n// Reyes: a new vintage filter, gives your photos a “dusty” look\nmodule.exports.reyes = (pixels) => {\n  pixels = filters.sepia.apply(this, [pixels, 0.4]);\n  pixels = filters.brightness.apply(this, [pixels, 0.13]);\n  pixels = filters.contrast.apply(this, [pixels, -0.05]);\n  return pixels;\n};\n\n// Juno: Brightens colors, and intensifies red and yellow hues\nmodule.exports.juno = (pixels) => {\n  pixels = filters.rgbAdjust.apply(this, [pixels, [1.01, 1.04, 1]]);\n  pixels = filters.saturation.apply(this, [pixels, 0.3]);\n  return pixels;\n};\n\n// Slumber: Desaturates the image as well as adds haze for a retro, dreamy look – with an emphasis on blacks and blues\nmodule.exports.slumber = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  pixels = filters.saturation.apply(this, [pixels, -0.5]);\n  return pixels;\n};\n\n// Crema: Adds a creamy look that both warms and cools the image\nmodule.exports.crema = (pixels) => {\n  pixels = filters.rgbAdjust.apply(this, [pixels, [1.04, 1, 1.02]]);\n  pixels = filters.saturation.apply(this, [pixels, -0.05]);\n  return pixels;\n};\n\n// Ludwig: A slight hint of desaturation that also enhances light\nmodule.exports.ludwig = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, 0.05]);\n  pixels = filters.saturation.apply(this, [pixels, -0.03]);\n  return pixels;\n};\n\n// Aden: This filter gives a blue/pink natural look\nmodule.exports.aden = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [228, 130, 225, 0.13]]);\n  pixels = filters.saturation.apply(this, [pixels, -0.2]);\n  return pixels;\n};\n\n// Perpetua: Adding a pastel look, this filter is ideal for portraits\nmodule.exports.perpetua = (pixels) => {\n  pixels = filters.rgbAdjust.apply(this, [pixels, [1.05, 1.1, 1]]);\n  return pixels;\n};\n\n// Amaro: Adds light to an image, with the focus on the centre\nmodule.exports.amaro = (pixels) => {\n  pixels = filters.saturation.apply(this, [pixels, 0.3]);\n  pixels = filters.brightness.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Mayfair: Applies a warm pink tone, subtle vignetting to brighten the photograph center and a thin black border\nmodule.exports.mayfair = (pixels) => {\n  filters.colorFilter.apply(this, [pixels, [230, 115, 108, 0.05]]);\n  filters.saturation.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Rise: Adds a \"glow\" to the image, with softer lighting of the subject\nmodule.exports.rise = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 170, 0, 0.1]]);\n  pixels = filters.brightness.apply(this, [pixels, 0.09]);\n  pixels = filters.saturation.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Hudson: Creates an \"icy\" illusion with heightened shadows, cool tint and dodged center\nmodule.exports.hudson = (pixels) => {\n  pixels = filters.rgbAdjust.apply(this, [pixels, [1, 1, 1.25]]);\n  pixels = filters.contrast.apply(this, [pixels, 0.1]);\n  pixels = filters.brightness.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Valencia: Fades the image by increasing exposure and warming the colors, to give it an antique feel\nmodule.exports.valencia = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 225, 80, 0.08]]);\n  pixels = filters.saturation.apply(this, [pixels, 0.1]);\n  pixels = filters.contrast.apply(this, [pixels, 0.05]);\n  return pixels;\n};\n\n// X-Pro II: Increases color vibrance with a golden tint, high contrast and slight vignette added to the edges\nmodule.exports.xpro2 = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 255, 0, 0.07]]);\n  pixels = filters.saturation.apply(this, [pixels, 0.2]);\n  pixels = filters.contrast.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Sierra: Gives a faded, softer look\nmodule.exports.sierra = (pixels) => {\n  pixels = filters.contrast.apply(this, [pixels, -0.15]);\n  pixels = filters.saturation.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Willow: A monochromatic filter with subtle purple tones and a translucent white border\nmodule.exports.willow = (pixels) => {\n  pixels = filters.grayscale.apply(this, [pixels, 1]);\n  pixels = filters.colorFilter.apply(this, [pixels, [100, 28, 210, 0.03]]);\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Lo-Fi: Enriches color and adds strong shadows through the use of saturation and \"warming\" the temperature\nmodule.exports.lofi = (pixels) => {\n  pixels = filters.contrast.apply(this, [pixels, 0.15]);\n  pixels = filters.saturation.apply(this, [pixels, 0.2]);\n  return pixels;\n};\n\n// Inkwell: Direct shift to black and white\nmodule.exports.inkwell = (pixels) => {\n  pixels = filters.grayscale.apply(this, [pixels, 1]);\n  return pixels;\n};\n\n// Hefe: Hight contrast and saturation, with a similar effect to Lo-Fi but not quite as dramatic\nmodule.exports.hefe = (pixels) => {\n  pixels = filters.contrast.apply(this, [pixels, 0.1]);\n  pixels = filters.saturation.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Nashville: Warms the temperature, lowers contrast and increases exposure to give a light \"pink\" tint – making it feel \"nostalgic\"\nmodule.exports.nashville = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [220, 115, 188, 0.12]]);\n  pixels = filters.contrast.apply(this, [pixels, -0.05]);\n  return pixels;\n};\n\n// Stinson: washing out the colors ever so slightly\nmodule.exports.stinson = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  pixels = filters.sepia.apply(this, [pixels, 0.3]);\n  return pixels;\n};\n\n// Vesper: adds a yellow tint that\nmodule.exports.vesper = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 225, 0, 0.05]]);\n  pixels = filters.brightness.apply(this, [pixels, 0.06]);\n  pixels = filters.contrast.apply(this, [pixels, 0.06]);\n  return pixels;\n};\n\n// Earlybird: Gives an older look with a sepia tint and warm temperature\nmodule.exports.earlybird = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 165, 40, 0.2]]);\n  return pixels;\n};\n\n// Brannan: Increases contrast and exposure and adds a metallic tint\nmodule.exports.brannan = (pixels) => {\n  pixels = filters.contrast.apply(this, [pixels, 0.2]);\n  pixels = filters.colorFilter.apply(this, [pixels, [140, 10, 185, 0.1]]);\n  return pixels;\n};\n\n// Sutro: Burns photo edges, increases highlights and shadows dramatically with a focus on purple and brown colors\nmodule.exports.sutro = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, -0.1]);\n  pixels = filters.saturation.apply(this, [pixels, -0.1]);\n  return pixels;\n};\n\n// Toaster: Ages the image by \"burning\" the centre and adds a dramatic vignette\nmodule.exports.toaster = (pixels) => {\n  pixels = filters.sepia.apply(this, [pixels, 0.1]);\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 145, 0, 0.2]]);\n  return pixels;\n};\n\n// Walden: Increases exposure and adds a yellow tint\nmodule.exports.walden = (pixels) => {\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 255, 0, 0.2]]);\n  return pixels;\n};\n\n// 1977: The increased exposure with a red tint gives the photograph a rosy, brighter, faded look.\nmodule.exports['1977'] = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 25, 0, 0.15]]);\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Kelvin: Increases saturation and temperature to give it a radiant \"glow\"\nmodule.exports.kelvin = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 140, 0, 0.1]]);\n  pixels = filters.rgbAdjust.apply(this, [pixels, [1.15, 1.05, 1]]);\n  pixels = filters.saturation.apply(this, [pixels, 0.35]);\n  return pixels;\n};\n\n// Maven: darkens images, increases shadows, and adds a slightly yellow tint overal\nmodule.exports.maven = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [225, 240, 0, 0.1]]);\n  pixels = filters.saturation.apply(this, [pixels, 0.25]);\n  pixels = filters.contrast.apply(this, [pixels, 0.05]);\n  return pixels;\n};\n\n// Ginza: brightens and adds a warm glow\nmodule.exports.ginza = (pixels) => {\n  filters.sepia.apply(this, [pixels, 0.06]);\n  filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Skyline: brightens to the image pop\nmodule.exports.skyline = (pixels) => {\n  pixels = filters.saturation.apply(this, [pixels, 0.35]);\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Dogpatch: increases the contrast, while washing out the lighter colors\nmodule.exports.dogpatch = (pixels) => {\n  pixels = filters.contrast.apply(this, [pixels, 0.15]);\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Brooklyn\nmodule.exports.brooklyn = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [25, 240, 252, 0.05]]);\n  pixels = filters.sepia.apply(this, [pixels, 0.3]);\n  return pixels;\n};\n\n// Helena: adds an orange and teal vibe\nmodule.exports.helena = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [208, 208, 86, 0.2]]);\n  pixels = filters.contrast.apply(this, [pixels, 0.15]);\n  return pixels;\n};\n\n// Ashby: gives images a great golden glow and a subtle vintage feel\nmodule.exports.ashby = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 160, 25, 0.1]]);\n  pixels = filters.brightness.apply(this, [pixels, 0.1]);\n  return pixels;\n};\n\n// Charmes: a high contrast filter, warming up colors in your image with a red tint\nmodule.exports.charmes = (pixels) => {\n  pixels = filters.colorFilter.apply(this, [pixels, [255, 50, 80, 0.12]]);\n  pixels = filters.contrast.apply(this, [pixels, 0.05]);\n  return pixels;\n};\n","// Based on: https://gist.github.com/mjackson/5311256\nmodule.exports.RGBtoHSV = (r, g, b) => {\n  r /= 255, g /= 255, b /= 255;\n\n let max = Math.max(r, g, b), min = Math.min(r, g, b);\n let h, s, v = max;\n\n let d = max - min;\n s = max == 0 ? 0 : d / max;\n\n if (max == min) {\n   h = 0; // achromatic\n } else {\n   switch (max) {\n     case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n     case g: h = (b - r) / d + 2; break;\n     case b: h = (r - g) / d + 4; break;\n   }\n\n   h /= 6;\n }\n\n return [ h, s, v ];\n}\n\nmodule.exports.HSVtoRGB = (h, s, v) => {\n  let r, g, b;\n\n  let i = Math.floor(h * 6);\n  let f = h * 6 - i;\n  let p = v * (1 - s);\n  let q = v * (1 - f * s);\n  let t = v * (1 - (1 - f) * s);\n\n  switch (i % 6) {\n    case 0: r = v, g = t, b = p; break;\n    case 1: r = q, g = v, b = p; break;\n    case 2: r = p, g = v, b = t; break;\n    case 3: r = p, g = q, b = v; break;\n    case 4: r = t, g = p, b = v; break;\n    case 5: r = v, g = p, b = q; break;\n  }\n\n  return [ r * 255, g * 255, b * 255 ];\n}\n",""]} diff --git a/demo-browser/filterous2.min.js b/demo-browser/filterous2.min.js new file mode 100644 index 0000000..7bc191e --- /dev/null +++ b/demo-browser/filterous2.min.js @@ -0,0 +1,2 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.filterous=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o1?1:adj;adj=adj<-1?-1:adj;adj=~~(255*adj);for(var i=0;i=0&&scy=0&&scx + + + + + Filterous 2 Demo + + + + + + + + + +
+

filterous 2

+
+ + +
+ +
+ photo +
Kitties
+
+
+ + + + +
+ +

or enter an image URL:

+ +

+

or upload from HD:

+ +
+ + + + + + diff --git a/demo-browser/style.css b/demo-browser/style.css new file mode 100644 index 0000000..396cefc --- /dev/null +++ b/demo-browser/style.css @@ -0,0 +1,282 @@ +/* Reset */ + +article,aside,details,figcaption,figure, +footer,header,hgroup,menu,nav,section { + display:block; +} +html { + font-size: 100%; + -webkit-text-size-adjust: 100%; + -ms-text-size-adjust: 100%; + -webkit-tap-highlight-color: transparent; +} +html, +body { + height: 100%; +} +body{ + margin: 0; + font: 1.2em/1.3em 'HelveticaNeue-Light', 'Helvetica Neue Light', 'Helvetica Neue', 'Roboto-Light', 'Roboto Light', 'Roboto', 'Segoe UI Web Light', 'Segoe UI Light', 'Segoe UI Web Regular', 'Segoe UI', Helvetica, Arial, sans-serif; + background: #443c34; + color: #fff; + padding: 0; +} +img { + border: 0; +} +a { + color: #72b809; +} + +/* Base Styles */ + +* { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + -ms-box-sizing: border-box; + -o-box-sizing: border-box; + box-sizing: border-box; +} + +header { + margin: 1em 1em 2em; + text-shadow: -1px -2px 0 #000; + text-align: center; +} +header h1 { + font-family: 'Life Savers'; + font-weight: normal; + font-size: 36px; +} +footer { + padding: 3em 1em 1em; + font-size: 0.75em; + text-align: right; +} +*[hidden] { + display: none; +} + + +/* Photo */ + +#photoFrame { + position: relative; +} +#photo { + width: 500px; + height: 500px; + object-fit: cover; +} +figure { + margin: 0; + text-align: center; +} + +@media (min-width: 700px) { + #photoFrame { + padding-left: 90px; + } + header h1 { + font-size: 48px; + } + #originalPhoto, #filteredPhoto { + width: auto; + background: #111; + width: 500px; + } + figure { + text-align: left; + margin: 1em auto; + position: relative; + background-color: #fff; + width: 540px; + padding: 20px; + height: 610px; + vertical-align: bottom; + box-shadow: 2px 2px 8px rgba(0,0,0,0.6), inset 0 0 30px rgba(0,0,0,0.2); + } + figure::before, + figure::after { + content: ""; + position: absolute; + background-color: #fff; + width: 540px; + height: 610px; + box-shadow: 2px 2px 8px rgba(0,0,0,0.6), inset 0 0 30px rgba(0,0,0,0.2); + -webkit-transform-origin: bottom left; + -moz-transform-origin: bottom left; + -ms-transform-origin: bottom left; + -o-transform-origin: bottom left; + transform-origin: bottom left; + } + figure::before { + top: 5px; + left: 5px; + z-index: -1; + -webkit-transform: rotate(2deg); + -moz-transform: rotate(2deg); + -ms-transform: rotate(2deg); + -o-transform: rotate(2deg); + transform: rotate(2deg); + } + figure::after { + top: 10px; + z-index: -2; + -webkit-transform: rotate(3deg); + -moz-transform: rotate(3deg); + -ms-transform: rotate(3deg); + -o-transform: rotate(3deg); + transform: rotate(3deg); + } + figcaption { + color: #333; + font-size: 1.8em; + line-height: 2; + padding: 10px; + text-align: center; + font-family: 'Homemade Apple', serif; + font-weight: 400; + } +} + +/* Loader */ + +#loader { + width: 200px; + height: 200px; + line-height: 200px; + background: rgba(0,0,0,0.5); + text-align: center; + color: #fff; + border-radius: 12px; + position: fixed; + left: 50%; + margin-left: -100px; + top: 50%; + margin-top: -100px; + z-index: 10; +} + +/* Filter Effects */ + +nav { + position: fixed; + bottom: 0; + text-align: center; + width: 100%; + padding: .75em 0 .5em; + background: rgba(0, 0, 0, 0.25); +} + +#filterButtons { + text-align: center; + width: 100%; + overflow-x: auto; + overflow-y: hidden; + white-space: nowrap; + padding: 0 .5em; +} +.filter { + display: inline-block; + margin: 3px 8px; + border-radius: 8px; + box-shadow: inset 0 0 10px #000; + height: 72px; + width: 72px; + cursor: pointer; + background: url("images/fish-normal.jpg") no-repeat 0 0; + background-size: cover; +} +.filter:hover { + box-shadow: 0 0 12px #72b809; +} +.filter.clarendon { + background-image: url("images/fish-clarendon.jpg"); +} +.filter.juno { + background-image: url("images/fish-juno.jpg"); +} +.filter.lark { + background-image: url("images/fish-lark.jpg"); +} +.filter.ludwig { + background-image: url("images/fish-ludwig.jpg"); +} +.filter.gingham { + background-image: url("images/fish-gingham.jpg"); +} +.filter.valencia { + background-image: url("images/fish-valencia.jpg"); +} +.filter.xpro2 { + background-image: url("images/fish-xpro2.jpg"); +} +.filter.lofi { + background-image: url("images/fish-lofi.jpg"); +} +.filter.amaro { + background-image: url("images/fish-amaro.jpg"); +} +.filter.brooklyn { + background-image: url('images/fish-brooklyn.jpg') +} +.filter.willow { + background-image: url("images/fish-willow.jpg"); +} + +.filter-tag { + color: #fff; + font-size: .8em; + text-shadow: 1px 1px 1px #000; + text-align: center; + padding-top: 58px; +} + +/* More Photos */ +#more { + position: relative; + margin: 6em 1em 120px; +} +#more p { + margin: 0.5em 0 0.2em; + color: #fff; + opacity: 0.8; +} +#more p.error { + color: #ff4fff; + font-size: 0.85em; + font-weight: bold; +} +#more ul { + list-style: none; + margin: 0; + padding: 0; +} +#more small { + display: inline; +} +#more input[type=text] { + font-size: 0.85em; + border: 0; + border-radius: 4px; + padding: 2px 5px; +} +#more input[type=file] { + border: 0; + border-radius: 4px; + padding: 2px 5px; + color: #fff; +} + +@media (min-width: 960px) { + #more { + display: block; + position: absolute; + top: 0; + left: 1em; + } + #more small { + display: block; + } +} diff --git a/demo-node/demo.js b/demo-node/demo.js new file mode 100644 index 0000000..642fba4 --- /dev/null +++ b/demo-node/demo.js @@ -0,0 +1,34 @@ +'use strict' + +const filterous = require('../lib/'); +const fs = require('fs'); + +let imgPath = __dirname + '/images/leia.jpg'; +let output = __dirname + '/images/output/'; + +// Async +fs.readFile(imgPath, (err, buffer) => { + if (err) throw err; + let f1 = filterous.importImage(buffer) + .applyFilter('brightness', 0.2) + .applyFilter('colorFilter', [255, 255, 0, 0.05]) + .applyFilter('convolute', [ 1/9, 1/9, 1/9, + 1/9, 1/9, 1/9, + 1/9, 1/9, 1/9 ]) + .save(output + 'leia-1.jpg'); + + // with optional params + let f2 = filterous.importImage(buffer, {scale: 0.5, format: 'png'}) + .applyInstaFilter('amaro') + .save(output + 'leia-2.png'); +}); + + + +// Blocking (sync) example +let buf = fs.readFileSync(imgPath); +filterous.importImage(buf) + .overlayImage(__dirname +'/images/bokeh-stars.png') + .save(output + 'leia-3.jpg'); + + \ No newline at end of file diff --git a/demo-node/images/bokeh-stars.png b/demo-node/images/bokeh-stars.png new file mode 100644 index 0000000..666b2e2 Binary files /dev/null and b/demo-node/images/bokeh-stars.png differ diff --git a/demo-node/images/leia.jpg b/demo-node/images/leia.jpg new file mode 100644 index 0000000..8cadea6 Binary files /dev/null and b/demo-node/images/leia.jpg differ diff --git a/demo-node/images/output/leia-1.jpg b/demo-node/images/output/leia-1.jpg new file mode 100644 index 0000000..e8b70ce Binary files /dev/null and b/demo-node/images/output/leia-1.jpg differ diff --git a/demo-node/images/output/leia-2.png b/demo-node/images/output/leia-2.png new file mode 100644 index 0000000..19151f1 Binary files /dev/null and b/demo-node/images/output/leia-2.png differ diff --git a/demo-node/images/output/leia-3.jpg b/demo-node/images/output/leia-3.jpg new file mode 100644 index 0000000..2fa5efc Binary files /dev/null and b/demo-node/images/output/leia-3.jpg differ diff --git a/images/canvas-pixels.png b/images/canvas-pixels.png new file mode 100644 index 0000000..36664ae Binary files /dev/null and b/images/canvas-pixels.png differ diff --git a/images/filterous-2.png b/images/filterous-2.png new file mode 100644 index 0000000..5e9df7c Binary files /dev/null and b/images/filterous-2.png differ diff --git a/lib/filters.js b/lib/filters.js new file mode 100644 index 0000000..05629a5 --- /dev/null +++ b/lib/filters.js @@ -0,0 +1,174 @@ +'use strict'; +const util = require('./util'); + +/** + * Filter Effects + * + * @param {Object} pixels - canvas imageData + * @param {Number} adj - adjustment level for the effect + * @param {Function} callback - callback to return after obtaining the new imageData + * @returns {Function} - callback with a new imageData + */ + +// No adjustment +module.exports.grayscale = (pixels) => { + let d = pixels.data; + for (let i = 0; i < d.length; i += 4) { + let r = d[i], g = d[i + 1], b = d[i + 2]; + let avg = 0.2126*r + 0.7152*g + 0.0722*b; + d[i] = d[i + 1] = d[i + 2] = avg + } + return pixels; +}; + +// Adj is 0 (unchanged) to 1 (sepia) +module.exports.sepia = (pixels, adj) => { + let d = pixels.data; + for (let i = 0; i < d.length; i += 4) { + let r = d[i], g = d[i + 1], b = d[i + 2]; + d[i] = (r * (1 - (0.607 * adj))) + (g * .769 * adj) + (b * .189 * adj); + d[i + 1] = (r * .349 * adj) + (g * (1 - (0.314 * adj))) + (b * .168 * adj); + d[i + 2] = (r * .272 * adj) + (g * .534 * adj) + (b * (1 - (0.869 * adj))); + } + return pixels; +}; + +// No adjustment +module.exports.invert = (pixels, adj) => { + let d = pixels.data; + for (let i = 0; i < d.length; i += 4) { + d[i] = 255 - d[i]; + d[i + 1] = 255 - d[i + 1]; + d[i + 2] = 255 - d[i + 2]; + } + return pixels; +}; + +/* adj should be -1 (darker) to 1 (lighter). 0 is unchanged. */ +module.exports.brightness = (pixels, adj) => { + let d = pixels.data; + adj = (adj > 1) ? 1 : adj; + adj = (adj < -1) ? -1 : adj; + adj = ~~(255 * adj); + for (let i = 0; i < d.length; i += 4) { + d[i] += adj; + d[i + 1] += adj; + d[i + 2] += adj; + } + return pixels; +}; + +// Better result (slow) - adj should be < 1 (desaturated) to 1 (unchanged) and < 1 +module.exports.hueSaturation = (pixels, adj) => { + let d = pixels.data; + for (let i = 0; i < d.length; i += 4) { + let hsv = util.RGBtoHSV(d[i], d[i+1], d[i+2]); + hsv[1] *= adj; + let rgb = util.HSVtoRGB(hsv[0], hsv[1], hsv[2]) + d[i] = rgb[0]; + d[i + 1] = rgb[1]; + d[i + 2] = rgb[2]; + } + return pixels; +}; + +// perceived saturation (faster) - adj should be -1 (desaturated) to positive number. 0 is unchanged +module.exports.saturation = (pixels, adj) => { + let d = pixels.data; + adj = (adj < -1) ? -1 : adj; + for (let i = 0; i < d.length; i += 4) { + let r = d[i], g = d[i + 1], b = d[i + 2]; + let gray = 0.2989*r + 0.5870*g + 0.1140*b; //weights from CCIR 601 spec + d[i] = -gray * adj + d[i] * (1 + adj); + d[i + 1] = -gray * adj + d[i + 1] * (1 + adj); + d[i + 2] = -gray * adj + d[i + 2] * (1 + adj); + } + return pixels; +}; + +// Contrast - the adj value should be -1 to 1 +module.exports.contrast = (pixels, adj) => { + adj *= 255; + let d = pixels.data; + let factor = (259 * (adj + 255)) / (255 * (259 - adj)); + for (let i = 0; i < d.length; i += 4) { + d[i] = factor * (d[i] - 128) + 128; + d[i + 1] = factor * (d[i + 1] - 128) + 128; + d[i + 2] = factor * (d[i + 2] - 128) + 128; + } + return pixels; +}; + +// ColorFilter - add a slight color overlay. rgbColor is an array of [r, g, b, adj] +module.exports.colorFilter = (pixels, rgbColor) => { + let d = pixels.data; + let adj = rgbColor[3]; + for (let i = 0; i < d.length; i += 4) { + d[i] -= (d[i] - rgbColor[0]) * adj; + d[i + 1] -= (d[i + 1] - rgbColor[1]) * adj; + d[i + 2] -= (d[i + 2] - rgbColor[2]) * adj; + } + return pixels; +}; + +// RGB Adjust +module.exports.rgbAdjust = (pixels, rgbAdj) => { + let d = pixels.data; + for (var i = 0; i < d.length; i +=4) { + d[i] *= rgbAdj[0]; //R + d[i + 1] *= rgbAdj[1]; //G + d[i + 2] *= rgbAdj[2]; //B + } + return pixels; +}; + +// Convolute - weights are 3x3 matrix +module.exports.convolute = (pixels, weights) => { + let side = Math.round(Math.sqrt(weights.length)); + let halfSide = ~~(side/2); + + let d = pixels.data; + let sw = pixels.width; + let sh = pixels.height; + + let w = sw; + let h = sh; + + for (let y = 0; y < h; y++) { + for (let x = 0; x < w; x++) { + let sy = y; + let sx = x; + let dstOff = (y * w + x) * 4; + let r = 0, g = 0, b = 0; + for (let cy = 0; cy < side; cy++) { + for (let cx = 0; cx < side; cx++) { + let scy = sy + cy - halfSide; + let scx = sx + cx - halfSide; + if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) { + let srcOff = (scy * sw + scx) * 4; + let wt = weights[cy * side + cx]; + r += d[srcOff] * wt; + g += d[srcOff + 1] * wt; + b += d[srcOff + 2] * wt; + } + } + } + d[dstOff] = r; + d[dstOff + 1] = g; + d[dstOff + 2] = b; + } + } + return pixels; +} + + +/** + * References + * https://en.wikipedia.org/wiki/HSL_and_HSV + * Grayscale https://en.wikipedia.org/wiki/Grayscale + * Sepia https://software.intel.com/sites/default/files/article/346220/sepiafilter-intelcilkplus.pdf + * Brightness https://www.html5rocks.com/en/tutorials/canvas/imagefilters/ + * Hue Saturation hhttps://gist.github.com/mjackson/5311256 + * Persceived saturation with RGB https://stackoverflow.com/questions/13806483/increase-or-decrease-color-saturation/34183839#34183839 + * Contrast http://www.dfstudios.co.uk/articles/programming/image-programming-algorithms/image-processing-algorithms-part-5-contrast-adjustment/ + */ diff --git a/lib/images/vignette-sm.png b/lib/images/vignette-sm.png new file mode 100644 index 0000000..e060af6 Binary files /dev/null and b/lib/images/vignette-sm.png differ diff --git a/lib/images/vignette.png b/lib/images/vignette.png new file mode 100644 index 0000000..85ddd71 Binary files /dev/null and b/lib/images/vignette.png differ diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 0000000..489630b --- /dev/null +++ b/lib/index.js @@ -0,0 +1,190 @@ +'use strict'; + +const filters = require('./filters'); +const instaFilters = require('./instaFilters'); +const fs = require('fs'); +const Canvas = require('canvas'); + +//module.exports.Filterous = Filterous; + +module.exports.importImage = (imageBuffer, options) => { + let filterous = new Filterous(imageBuffer, options); + return filterous.importImage(imageBuffer, options); +} + +/** + * Filterous Class + * + * @class + * @param {Buffer} imageBuffer + */ + +class Filterous { + + constructor(image, options) { + this.options = options || {format: 'jpeg'}; + this.scale = (this.options.scale) ? this.options.scale : 1; + this.w = 300; + this.h = 300; + this.vignette = 'data:image/png;base64,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'; + + } + + /** + * importImage + * + * @param {Buffer | Object} image - an image buffer (node) or image object (browser) + * @returns {Function} + */ + + importImage(image) { + if (typeof window === 'object') { // browser + this.canvas = document.createElement('canvas'); + this.w = this.canvas.width = image.naturalWidth * this.scale; + this.h = this.canvas.height = image.naturalHeight * this.scale; + this.ctx = this.canvas.getContext('2d'); + this.ctx.drawImage(image, 0, 0, this.w, this.h); + } else { + let img = this.initImage(); + img.onload = () => { + this.w = img.width * this.scale; + this.h = img.height * this.scale; + this.canvas = new Canvas(this.w, this.h); + this.ctx = this.canvas.getContext('2d'); + this.ctx.drawImage(img, 0, 0, this.w, this.h); + }; + img.src = image; + } + return this; + } + + /** + * Apply filter - e.g. applyFilter('contrast', 0.1); + * + * @param {String} effect - the name of the filter effect + * @param {Number} adjustment - adjustment value (mostly -1 < v < 1) for the effect + * @returns {Function} + */ + + applyFilter(effect, adjustment) { + console.log(effect); + let newPixels; + let p = new Promise((resolve) => { + this.pixels = this.ctx.getImageData(0, 0, this.w, this.h); + newPixels = filters[effect].apply(this, [this.pixels, adjustment]); + resolve(newPixels); + }); + p.then(this.render(newPixels)); + return this; + } + + /** + * Apply instaFilter - Giving a predefined Instagram-like effect e.g. applyInstaFilter('amaro'); + * + * @param {String} effect - the name of the filter effect + * @param {Number} adjustment - adjustment value (mostly -1 < v < 1) for the effect + * @returns {Function} + */ + + applyInstaFilter(filterName) { + console.log(filterName); + filterName = filterName.toLowerCase(); + let newPixels; + + let p = new Promise((resolve) => { + this.pixels = this.ctx.getImageData(0, 0, this.w, this.h); + newPixels = instaFilters[filterName].apply(this, [this.pixels]); + resolve(newPixels); + }); + + if(filterName === 'mayfair' || filterName === 'rise' || filterName === 'hudson' || filterName === 'xpro2' || filterName === 'amaro' || filterName === 'earlybird' || filterName === 'sutro' || filterName == 'toaster' || filterName === 'brannan') { + let p1 = new Promise((resolve) => { + p.then(this.render(newPixels)); + resolve(); + }); + p1.then(this.applyVignette()); + } else { + p.then(this.render(newPixels)); + } + return this; + } + + /** + * Overlay an image on top of the canvas + * @param {String} imgSrc - the path to the image you want to overlay + * @returns {Function} + */ + overlayImage(imgSrc) { + let imgObj = this.initImage(); + imgObj.onload = () => { + this.ctx.drawImage(imgObj, 0, 0, this.w, this.h); + }; + imgObj.src = imgSrc; + + return this; + } + + applyVignette() { + this.overlayImage(this.vignette); + } + + /** + * Render the pixel data onto the canvas + * Callback after done applying a filter + * @param {Object} newPixels - altered pixel data + */ + render(newPixels) { + this.ctx.putImageData(newPixels, 0, 0); + } + + /** + * Save a file to HD (Node only) + * @param {String} filename - path/to/file.jpg + * @returns {Function} + */ + save(filename) { + let type = 'image/' + this.options.format; + + this.canvas.toDataURL(type, function(err, base64) { // Sync JPEG is not supported bu node-canvas + let base64Data = base64.split(',')[1]; + let binaryData = new Buffer(base64Data, 'base64'); + fs.writeFile(filename, base64Data, {encoding: 'base64'}, (err) => { + if(err) return console.log(err); + console.log('Saved as ' + filename); + }); + }); + return this; + } + + /** + * Render the image object into DOM (browser only) + * @returns {Function} + */ + renderHtml(dom) { + setTimeout(() => { // quick-n-dirty, to avoid it renders before vignette is applied + dom.src = this.canvas.toDataURL('image/'+this.options.format); + }, 10); + + return this; + } + + initCanvas(w, h) { + if (typeof window === 'object') { // browser + let canvas = document.createElement('canvas'); + canvas.width = w; + canvas.height = h; + return canvas; + } + else { // node + return new Canvas(w, h); + } + } + + initImage() { + if (typeof window === 'object') { // browser + return new Image(); + } else { // node + return new Canvas.Image(); + } + } +} diff --git a/lib/instaFilters.js b/lib/instaFilters.js new file mode 100644 index 0000000..623d309 --- /dev/null +++ b/lib/instaFilters.js @@ -0,0 +1,300 @@ +'use strict'; +const filters = require('./filters'); + +/** + * Instagram filters + */ + +// Normal: no filters +module.exports.normal = (pixels) => { + return pixels; +}; + +// Clarendon: adds light to lighter areas and dark to darker areas +module.exports.clarendon = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, 0.1]); + pixels = filters.contrast.apply(this, [pixels, 0.1]); + pixels = filters.saturation.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Gingham: Vintage-inspired, taking some color out +module.exports.gingham = (pixels) => { + pixels = filters.sepia.apply(this, [pixels, 0.04]); + pixels = filters.contrast.apply(this, [pixels, -0.15]); + return pixels; +}; + +// Moon: B/W, increase brightness and decrease contrast +module.exports.moon = (pixels) => { + pixels = filters.grayscale.apply(this, [pixels, 1]); + pixels = filters.contrast.apply(this, [pixels, -0.04]); + pixels = filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Lark: Brightens and intensifies colours but not red hues +module.exports.lark = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, 0.08]); + pixels = filters.rgbAdjust.apply(this, [pixels, [1, 1.03, 1.05]]); + pixels = filters.saturation.apply(this, [pixels, 0.12]); + return pixels; +}; + +// Reyes: a new vintage filter, gives your photos a “dusty” look +module.exports.reyes = (pixels) => { + pixels = filters.sepia.apply(this, [pixels, 0.4]); + pixels = filters.brightness.apply(this, [pixels, 0.13]); + pixels = filters.contrast.apply(this, [pixels, -0.05]); + return pixels; +}; + +// Juno: Brightens colors, and intensifies red and yellow hues +module.exports.juno = (pixels) => { + pixels = filters.rgbAdjust.apply(this, [pixels, [1.01, 1.04, 1]]); + pixels = filters.saturation.apply(this, [pixels, 0.3]); + return pixels; +}; + +// Slumber: Desaturates the image as well as adds haze for a retro, dreamy look – with an emphasis on blacks and blues +module.exports.slumber = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, 0.1]); + pixels = filters.saturation.apply(this, [pixels, -0.5]); + return pixels; +}; + +// Crema: Adds a creamy look that both warms and cools the image +module.exports.crema = (pixels) => { + pixels = filters.rgbAdjust.apply(this, [pixels, [1.04, 1, 1.02]]); + pixels = filters.saturation.apply(this, [pixels, -0.05]); + return pixels; +}; + +// Ludwig: A slight hint of desaturation that also enhances light +module.exports.ludwig = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, 0.05]); + pixels = filters.saturation.apply(this, [pixels, -0.03]); + return pixels; +}; + +// Aden: This filter gives a blue/pink natural look +module.exports.aden = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [228, 130, 225, 0.13]]); + pixels = filters.saturation.apply(this, [pixels, -0.2]); + return pixels; +}; + +// Perpetua: Adding a pastel look, this filter is ideal for portraits +module.exports.perpetua = (pixels) => { + pixels = filters.rgbAdjust.apply(this, [pixels, [1.05, 1.1, 1]]); + return pixels; +}; + +// Amaro: Adds light to an image, with the focus on the centre +module.exports.amaro = (pixels) => { + pixels = filters.saturation.apply(this, [pixels, 0.3]); + pixels = filters.brightness.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Mayfair: Applies a warm pink tone, subtle vignetting to brighten the photograph center and a thin black border +module.exports.mayfair = (pixels) => { + filters.colorFilter.apply(this, [pixels, [230, 115, 108, 0.05]]); + filters.saturation.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Rise: Adds a "glow" to the image, with softer lighting of the subject +module.exports.rise = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 170, 0, 0.1]]); + pixels = filters.brightness.apply(this, [pixels, 0.09]); + pixels = filters.saturation.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Hudson: Creates an "icy" illusion with heightened shadows, cool tint and dodged center +module.exports.hudson = (pixels) => { + pixels = filters.rgbAdjust.apply(this, [pixels, [1, 1, 1.25]]); + pixels = filters.contrast.apply(this, [pixels, 0.1]); + pixels = filters.brightness.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Valencia: Fades the image by increasing exposure and warming the colors, to give it an antique feel +module.exports.valencia = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 225, 80, 0.08]]); + pixels = filters.saturation.apply(this, [pixels, 0.1]); + pixels = filters.contrast.apply(this, [pixels, 0.05]); + return pixels; +}; + +// X-Pro II: Increases color vibrance with a golden tint, high contrast and slight vignette added to the edges +module.exports.xpro2 = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 255, 0, 0.07]]); + pixels = filters.saturation.apply(this, [pixels, 0.2]); + pixels = filters.contrast.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Sierra: Gives a faded, softer look +module.exports.sierra = (pixels) => { + pixels = filters.contrast.apply(this, [pixels, -0.15]); + pixels = filters.saturation.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Willow: A monochromatic filter with subtle purple tones and a translucent white border +module.exports.willow = (pixels) => { + pixels = filters.grayscale.apply(this, [pixels, 1]); + pixels = filters.colorFilter.apply(this, [pixels, [100, 28, 210, 0.03]]); + pixels = filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Lo-Fi: Enriches color and adds strong shadows through the use of saturation and "warming" the temperature +module.exports.lofi = (pixels) => { + pixels = filters.contrast.apply(this, [pixels, 0.15]); + pixels = filters.saturation.apply(this, [pixels, 0.2]); + return pixels; +}; + +// Inkwell: Direct shift to black and white +module.exports.inkwell = (pixels) => { + pixels = filters.grayscale.apply(this, [pixels, 1]); + return pixels; +}; + +// Hefe: Hight contrast and saturation, with a similar effect to Lo-Fi but not quite as dramatic +module.exports.hefe = (pixels) => { + pixels = filters.contrast.apply(this, [pixels, 0.1]); + pixels = filters.saturation.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Nashville: Warms the temperature, lowers contrast and increases exposure to give a light "pink" tint – making it feel "nostalgic" +module.exports.nashville = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [220, 115, 188, 0.12]]); + pixels = filters.contrast.apply(this, [pixels, -0.05]); + return pixels; +}; + +// Stinson: washing out the colors ever so slightly +module.exports.stinson = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, 0.1]); + pixels = filters.sepia.apply(this, [pixels, 0.3]); + return pixels; +}; + +// Vesper: adds a yellow tint that +module.exports.vesper = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 225, 0, 0.05]]); + pixels = filters.brightness.apply(this, [pixels, 0.06]); + pixels = filters.contrast.apply(this, [pixels, 0.06]); + return pixels; +}; + +// Earlybird: Gives an older look with a sepia tint and warm temperature +module.exports.earlybird = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 165, 40, 0.2]]); + return pixels; +}; + +// Brannan: Increases contrast and exposure and adds a metallic tint +module.exports.brannan = (pixels) => { + pixels = filters.contrast.apply(this, [pixels, 0.2]); + pixels = filters.colorFilter.apply(this, [pixels, [140, 10, 185, 0.1]]); + return pixels; +}; + +// Sutro: Burns photo edges, increases highlights and shadows dramatically with a focus on purple and brown colors +module.exports.sutro = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, -0.1]); + pixels = filters.saturation.apply(this, [pixels, -0.1]); + return pixels; +}; + +// Toaster: Ages the image by "burning" the centre and adds a dramatic vignette +module.exports.toaster = (pixels) => { + pixels = filters.sepia.apply(this, [pixels, 0.1]); + pixels = filters.colorFilter.apply(this, [pixels, [255, 145, 0, 0.2]]); + return pixels; +}; + +// Walden: Increases exposure and adds a yellow tint +module.exports.walden = (pixels) => { + pixels = filters.brightness.apply(this, [pixels, 0.1]); + pixels = filters.colorFilter.apply(this, [pixels, [255, 255, 0, 0.2]]); + return pixels; +}; + +// 1977: The increased exposure with a red tint gives the photograph a rosy, brighter, faded look. +module.exports['1977'] = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 25, 0, 0.15]]); + pixels = filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Kelvin: Increases saturation and temperature to give it a radiant "glow" +module.exports.kelvin = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 140, 0, 0.1]]); + pixels = filters.rgbAdjust.apply(this, [pixels, [1.15, 1.05, 1]]); + pixels = filters.saturation.apply(this, [pixels, 0.35]); + return pixels; +}; + +// Maven: darkens images, increases shadows, and adds a slightly yellow tint overal +module.exports.maven = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [225, 240, 0, 0.1]]); + pixels = filters.saturation.apply(this, [pixels, 0.25]); + pixels = filters.contrast.apply(this, [pixels, 0.05]); + return pixels; +}; + +// Ginza: brightens and adds a warm glow +module.exports.ginza = (pixels) => { + filters.sepia.apply(this, [pixels, 0.06]); + filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Skyline: brightens to the image pop +module.exports.skyline = (pixels) => { + pixels = filters.saturation.apply(this, [pixels, 0.35]); + pixels = filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Dogpatch: increases the contrast, while washing out the lighter colors +module.exports.dogpatch = (pixels) => { + pixels = filters.contrast.apply(this, [pixels, 0.15]); + pixels = filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Brooklyn +module.exports.brooklyn = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [25, 240, 252, 0.05]]); + pixels = filters.sepia.apply(this, [pixels, 0.3]); + return pixels; +}; + +// Helena: adds an orange and teal vibe +module.exports.helena = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [208, 208, 86, 0.2]]); + pixels = filters.contrast.apply(this, [pixels, 0.15]); + return pixels; +}; + +// Ashby: gives images a great golden glow and a subtle vintage feel +module.exports.ashby = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 160, 25, 0.1]]); + pixels = filters.brightness.apply(this, [pixels, 0.1]); + return pixels; +}; + +// Charmes: a high contrast filter, warming up colors in your image with a red tint +module.exports.charmes = (pixels) => { + pixels = filters.colorFilter.apply(this, [pixels, [255, 50, 80, 0.12]]); + pixels = filters.contrast.apply(this, [pixels, 0.05]); + return pixels; +}; diff --git a/lib/util.js b/lib/util.js new file mode 100644 index 0000000..e543e5d --- /dev/null +++ b/lib/util.js @@ -0,0 +1,45 @@ +// Based on: https://gist.github.com/mjackson/5311256 +module.exports.RGBtoHSV = (r, g, b) => { + r /= 255, g /= 255, b /= 255; + + let max = Math.max(r, g, b), min = Math.min(r, g, b); + let h, s, v = max; + + let d = max - min; + s = max == 0 ? 0 : d / max; + + if (max == min) { + h = 0; // achromatic + } else { + switch (max) { + case r: h = (g - b) / d + (g < b ? 6 : 0); break; + case g: h = (b - r) / d + 2; break; + case b: h = (r - g) / d + 4; break; + } + + h /= 6; + } + + return [ h, s, v ]; +} + +module.exports.HSVtoRGB = (h, s, v) => { + let r, g, b; + + let i = Math.floor(h * 6); + let f = h * 6 - i; + let p = v * (1 - s); + let q = v * (1 - f * s); + let t = v * (1 - (1 - f) * s); + + switch (i % 6) { + case 0: r = v, g = t, b = p; break; + case 1: r = q, g = v, b = p; break; + case 2: r = p, g = v, b = t; break; + case 3: r = p, g = q, b = v; break; + case 4: r = t, g = p, b = v; break; + case 5: r = v, g = p, b = q; break; + } + + return [ r * 255, g * 255, b * 255 ]; +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..f67b4b9 --- /dev/null +++ b/package.json @@ -0,0 +1,31 @@ +{ + "name": "filterous", + "version": "2.0.1-beta", + "description": "Instagram-like photo manipulation library for Node.js and Javascript on browser", + "main": "lib/index.js", + "directories": { + "test": "test" + }, + "scripts": { + "test": "mocha --reporter=nyan" + }, + "keywords": [ + "photo", + "image", + "image manipulation", + "canvas", + "filter", + "effect", + "instagram" + ], + "author": "Tomomi ❤️ Imura", + "license": "MIT", + "devDependencies": { + "babel-preset-es2015": "^6.22.0", + "babelify": "^7.3.0", + "mocha": "^3.2.0" + }, + "dependencies": { + "canvas": "^1.6.2" + } +} diff --git a/test/leia.jpg b/test/leia.jpg new file mode 100644 index 0000000..8d32b6c Binary files /dev/null and b/test/leia.jpg differ diff --git a/test/test.js b/test/test.js new file mode 100644 index 0000000..10255d8 --- /dev/null +++ b/test/test.js @@ -0,0 +1,65 @@ +'use strict'; + +const filterous = require('../lib/'); +const fs = require('fs'); + +let input = __dirname + '/leia.jpg'; +let output = __dirname + '/leia-alt.jpg'; + +describe('Resize the image', function() { + describe('#resize)', function() { + it('should reduce the image size without error', function(done) { + fs.readFile(input, (err, buffer) => { + let f = filterous.importImage(buffer, {scale: 0.5}); + }, done); + }); + }); +}); + +describe('Apply a filter', function() { + describe('#applyFilter()', function() { + it('should apply a filter without error', function(done) { + fs.readFile(input, (err, buffer) => { + let f1 = filterous.importImage(buffer) + .applyFilter('brightness', 0.2); + }, done); + }); + }); +}); + +describe('Apply an Insta-filter', function() { + describe('#applyInstaFilter()', function() { + it('should apply a filter without error', function(done) { + fs.readFile(input, (err, buffer) => { + let f2 = filterous.importImage(buffer) + .applyInstaFilter('1977'); + }, done); + }); + }); +}); + +describe('Save an image', function() { + describe('#save()', function() { + it('should save without error', function(done) { + fs.readFile(input, (err, buffer) => { + let f3 = filterous.importImage(buffer) + .save(output); + }, done); + }); + }); +}); + +describe('Apply an Insta-fileter, then another filter and save', function() { + describe('#save()', function() { + it('should save without error', function(done) { + fs.readFile(input, (err, buffer) => { + let f4 = filterous.importImage(buffer) + .applyInstaFilter('amaro') + .applyFilter('convolute', [ 1/9, 1/9, 1/9, + 1/9, 1/9, 1/9, + 1/9, 1/9, 1/9 ]) + .save('test.jpg'); + }, done); + }); + }); +});