Initial import.

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..5b8bf82
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+ogre.appcache
+favicon.ico
+favicon_32.png
+favicon_128.png
+favicon_192.png
+favicon_256.png

diff --git a/Checkbook.woff b/Checkbook.woff
new file mode 100644 (file)
index 0000000..e8f6dff
Binary files /dev/null and b/Checkbook.woff differ

diff --git a/DejaVuSansMono.woff b/DejaVuSansMono.woff
new file mode 100644 (file)
index 0000000..d59080a
Binary files /dev/null and b/DejaVuSansMono.woff differ

diff --git a/FiraSans-Regular.woff b/FiraSans-Regular.woff
new file mode 100644 (file)
index 0000000..16e74f2
Binary files /dev/null and b/FiraSans-Regular.woff differ

diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..914e970
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,32 @@
+all: ogre.appcache
+
+appcache>contents = $(shell grep -vFx -e "*" -e "CACHE MANIFEST" -e "CACHE:" -e "NETWORK:" -e "FALLBACK:" $(1) | grep -v -e "^\#" )
+
+.PHONY: all clean
+
+.SECONDEXPANSION:
+%.appcache: %.appcache.in $$(call appcache>contents,$$*.appcache.in)
+       sed "s/<Last-Updated>$$/Last-Updated: `date -u +'%Y-%m-%dT%H:%M:%SZ'`/" $< > $@
+
+CONVERT.svg.png ?= rsvg-convert -f png
+CONVERT.png.ico ?= convert
+
+PNGCRUSH ?= pngcrush
+PNGCRUSHFLAGS ?= -brute -blacken -reduce -q
+CRUSH.png ?= $(PNGCRUSH) $(PNGCRUSHFLAGS)
+
+FAVICON_SIZES = 32 128 192 256
+FAVICONS = $(patsubst %,favicon_%.png,$(FAVICON_SIZES)) favicon.ico
+
+favicon_%.png: favicon.svg
+       $(CONVERT.svg.png) -w $* -h $* < $< > $@
+       $(CRUSH.png) -ow $@
+
+%.ico: %_48.png %_32.png %_16.png
+       $(CONVERT.png.ico) $^ $@
+
+all: $(FAVICONS) ogre.appcache
+
+clean:
+       $(RM) $(FAVICONS)
+       $(RM) ogre.appcache

diff --git a/brain.js b/brain.js
new file mode 100644 (file)
index 0000000..0d8e692
--- /dev/null
+++ b/brain.js
@@ -0,0 +1,100 @@
+"use strict";
+
+function randrange (lo, hi) {
+    return lo + (Math.random() * (hi - lo)) | 0;
+}
+
+function shuffle (seq) {
+    for (var i = seq.length - 1; i > 0; --i) {
+        var index = randrange(0, i + 1);
+        var temp = seq[i];
+        seq[i] = seq[index];
+        seq[index] = temp;
+    }
+    return seq;
+}
+
+var MOVEMENT = ["fore", "fore", "fore", "fore", "fore",
+                "left", "left", "left",
+                "right", "right", "right",
+                null];
+var RAMMING = ["none", "none", "fore", "fore", "aft"];
+var ORDER = ["nearest", "nearest", "nearest",
+             "threat", "strongest", "farthest"];
+var BREAKER = ["clockwise", "clockwise",
+               "anti-clockwise", "anti-clockwise"];
+var ARC = ["fore", "fore", "fore", "aft"];
+
+var FIRING = ["spread fire, engage 1-1",
+              "spread fire, engage 1-1",
+              "spread fire, engage 1-1",
+              "focus fire, engage 2-1",
+              "focus fire, engage 2-1",
+              "concentrate all fire"];
+var MISSILES = [0.20, 0.10, 0.05];
+
+function drop1 (seq) {
+    return shuffle(seq.slice()).slice(1);
+}
+
+function Brain () {
+    var movement = drop1(MOVEMENT);
+    var ramming = drop1(RAMMING);
+    var order = drop1(ORDER);
+    var breaker = drop1(BREAKER);
+    var arc = drop1(ARC);
+    var firing = drop1(FIRING);
+    var missiles = choice(MISSILES)
+
+    this.report = function (movePoints, hasMissiles) {
+        var ram = movePoints > 1 ? choice(ramming) : null;
+        var move = [];
+        for (var i = 0; i < movePoints; ++i) {
+            do {
+                var m = choice(movement);
+            } while ((m === "left" && move.indexOf("right") >= 0)
+                     || (m === "right" && move.indexOf("left") >= 0))
+            if (m)
+                move.push(m);
+        }
+
+        var launch = 0;
+        while (hasMissiles && Math.random() < Math.pow(missiles, launch + 1))
+            ++launch;
+
+        var instr = [];
+        instr.push("sensors sweeping " + choice(breaker));
+        if (ram === "aft")
+            instr.push("ram back if opportune");
+        instr.push((ram === "aft" ? "otherwise " : "")
+                   + "ahead " + move.join(", "));
+        if (ram)
+            instr.push("  ramming if opportune");
+        instr.push("target " + choice(order) + ", "
+                   + choice(arc) + " first");
+        instr.push("  " + choice(firing));
+        if (hasMissiles)
+            instr.push("launch missiles at howitzers and key targets");
+        if (launch) {
+            instr.push("  further expend up to " + launch + " missile(s)");
+            instr.push("    on the " + choice(order) + " vehicle target(s)");
+        }
+        
+        return instr.join("\n");
+    }
+    return this;
+}
+
+var brain, ttl;
+function think () {
+    if (!(brain && ttl-- > 0)) {
+        brain = new Brain();
+        ttl = Math.max(1, choice([2, 10, 18]) + randrange(-2, 3));
+    }
+    document.getElementById('report').textContent =
+        brain.report(3, true, true).replace(/\w\S*/g, function (s) {
+            return ["and", "of", "if", "at"].indexOf(s) < 0
+                ? s[0].toUpperCase() + s.slice(1)
+                : s;
+        });
+}

diff --git a/fastclick.js b/fastclick.js
new file mode 100644 (file)
index 0000000..2fda2a9
--- /dev/null
+++ b/fastclick.js
@@ -0,0 +1,818 @@
+/**
+ * @preserve FastClick: polyfill to remove click delays on browsers with touch UIs.
+ *
+ * @version 1.0.2
+ * @codingstandard ftlabs-jsv2
+ * @copyright The Financial Times Limited [All Rights Reserved]
+ * @license MIT License (see LICENSE.txt)
+ */
+
+/*jslint browser:true, node:true*/
+/*global define, Event, Node*/
+
+
+/**
+ * Instantiate fast-clicking listeners on the specified layer.
+ *
+ * @constructor
+ * @param {Element} layer The layer to listen on
+ * @param {Object} options The options to override the defaults
+ */
+function FastClick(layer, options) {
+       'use strict';
+       var oldOnClick;
+
+       options = options || {};
+
+       /**
+        * Whether a click is currently being tracked.
+        *
+        * @type boolean
+        */
+       this.trackingClick = false;
+
+
+       /**
+        * Timestamp for when click tracking started.
+        *
+        * @type number
+        */
+       this.trackingClickStart = 0;
+
+
+       /**
+        * The element being tracked for a click.
+        *
+        * @type EventTarget
+        */
+       this.targetElement = null;
+
+
+       /**
+        * X-coordinate of touch start event.
+        *
+        * @type number
+        */
+       this.touchStartX = 0;
+
+
+       /**
+        * Y-coordinate of touch start event.
+        *
+        * @type number
+        */
+       this.touchStartY = 0;
+
+
+       /**
+        * ID of the last touch, retrieved from Touch.identifier.
+        *
+        * @type number
+        */
+       this.lastTouchIdentifier = 0;
+
+
+       /**
+        * Touchmove boundary, beyond which a click will be cancelled.
+        *
+        * @type number
+        */
+       this.touchBoundary = options.touchBoundary || 10;
+
+
+       /**
+        * The FastClick layer.
+        *
+        * @type Element
+        */
+       this.layer = layer;
+
+       /**
+        * The minimum time between tap(touchstart and touchend) events
+        *
+        * @type number
+        */
+       this.tapDelay = options.tapDelay || 200;
+
+       if (FastClick.notNeeded(layer)) {
+               return;
+       }
+
+       // Some old versions of Android don't have Function.prototype.bind
+       function bind(method, context) {
+               return function() { return method.apply(context, arguments); };
+       }
+
+
+       var methods = ['onMouse', 'onClick', 'onTouchStart', 'onTouchMove', 'onTouchEnd', 'onTouchCancel'];
+       var context = this;
+       for (var i = 0, l = methods.length; i < l; i++) {
+               context[methods[i]] = bind(context[methods[i]], context);
+       }
+
+       // Set up event handlers as required
+       if (deviceIsAndroid) {
+               layer.addEventListener('mouseover', this.onMouse, true);
+               layer.addEventListener('mousedown', this.onMouse, true);
+               layer.addEventListener('mouseup', this.onMouse, true);
+       }
+
+       layer.addEventListener('click', this.onClick, true);
+       layer.addEventListener('touchstart', this.onTouchStart, false);
+       layer.addEventListener('touchmove', this.onTouchMove, false);
+       layer.addEventListener('touchend', this.onTouchEnd, false);
+       layer.addEventListener('touchcancel', this.onTouchCancel, false);
+
+       // Hack is required for browsers that don't support Event#stopImmediatePropagation (e.g. Android 2)
+       // which is how FastClick normally stops click events bubbling to callbacks registered on the FastClick
+       // layer when they are cancelled.
+       if (!Event.prototype.stopImmediatePropagation) {
+               layer.removeEventListener = function(type, callback, capture) {
+                       var rmv = Node.prototype.removeEventListener;
+                       if (type === 'click') {
+                               rmv.call(layer, type, callback.hijacked || callback, capture);
+                       } else {
+                               rmv.call(layer, type, callback, capture);
+                       }
+               };
+
+               layer.addEventListener = function(type, callback, capture) {
+                       var adv = Node.prototype.addEventListener;
+                       if (type === 'click') {
+                               adv.call(layer, type, callback.hijacked || (callback.hijacked = function(event) {
+                                       if (!event.propagationStopped) {
+                                               callback(event);
+                                       }
+                               }), capture);
+                       } else {
+                               adv.call(layer, type, callback, capture);
+                       }
+               };
+       }
+
+       // If a handler is already declared in the element's onclick attribute, it will be fired before
+       // FastClick's onClick handler. Fix this by pulling out the user-defined handler function and
+       // adding it as listener.
+       if (typeof layer.onclick === 'function') {
+
+               // Android browser on at least 3.2 requires a new reference to the function in layer.onclick
+               // - the old one won't work if passed to addEventListener directly.
+               oldOnClick = layer.onclick;
+               layer.addEventListener('click', function(event) {
+                       oldOnClick(event);
+               }, false);
+               layer.onclick = null;
+       }
+}
+
+
+/**
+ * Android requires exceptions.
+ *
+ * @type boolean
+ */
+var deviceIsAndroid = navigator.userAgent.indexOf('Android') > 0;
+
+
+/**
+ * iOS requires exceptions.
+ *
+ * @type boolean
+ */
+var deviceIsIOS = /iP(ad|hone|od)/.test(navigator.userAgent);
+
+
+/**
+ * iOS 4 requires an exception for select elements.
+ *
+ * @type boolean
+ */
+var deviceIsIOS4 = deviceIsIOS && (/OS 4_\d(_\d)?/).test(navigator.userAgent);
+
+
+/**
+ * iOS 6.0(+?) requires the target element to be manually derived
+ *
+ * @type boolean
+ */
+var deviceIsIOSWithBadTarget = deviceIsIOS && (/OS ([6-9]|\d{2})_\d/).test(navigator.userAgent);
+
+/**
+ * BlackBerry requires exceptions.
+ *
+ * @type boolean
+ */
+var deviceIsBlackBerry10 = navigator.userAgent.indexOf('BB10') > 0;
+
+/**
+ * Determine whether a given element requires a native click.
+ *
+ * @param {EventTarget|Element} target Target DOM element
+ * @returns {boolean} Returns true if the element needs a native click
+ */
+FastClick.prototype.needsClick = function(target) {
+       'use strict';
+       switch (target.nodeName.toLowerCase()) {
+
+       // Don't send a synthetic click to disabled inputs (issue #62)
+       case 'button':
+       case 'select':
+       case 'textarea':
+               if (target.disabled) {
+                       return true;
+               }
+
+               break;
+       case 'input':
+
+               // File inputs need real clicks on iOS 6 due to a browser bug (issue #68)
+               if ((deviceIsIOS && target.type === 'file') || target.disabled) {
+                       return true;
+               }
+
+               break;
+       case 'label':
+       case 'video':
+               return true;
+       }
+
+       return (/\bneedsclick\b/).test(target.className);
+};
+
+
+/**
+ * Determine whether a given element requires a call to focus to simulate click into element.
+ *
+ * @param {EventTarget|Element} target Target DOM element
+ * @returns {boolean} Returns true if the element requires a call to focus to simulate native click.
+ */
+FastClick.prototype.needsFocus = function(target) {
+       'use strict';
+       switch (target.nodeName.toLowerCase()) {
+       case 'textarea':
+               return true;
+       case 'select':
+               return !deviceIsAndroid;
+       case 'input':
+               switch (target.type) {
+               case 'button':
+               case 'checkbox':
+               case 'file':
+               case 'image':
+               case 'radio':
+               case 'submit':
+                       return false;
+               }
+
+               // No point in attempting to focus disabled inputs
+               return !target.disabled && !target.readOnly;
+       default:
+               return (/\bneedsfocus\b/).test(target.className);
+       }
+};
+
+
+/**
+ * Send a click event to the specified element.
+ *
+ * @param {EventTarget|Element} targetElement
+ * @param {Event} event
+ */
+FastClick.prototype.sendClick = function(targetElement, event) {
+       'use strict';
+       var clickEvent, touch;
+
+       // On some Android devices activeElement needs to be blurred otherwise the synthetic click will have no effect (#24)
+       if (document.activeElement && document.activeElement !== targetElement) {
+               document.activeElement.blur();
+       }
+
+       touch = event.changedTouches[0];
+
+       // Synthesise a click event, with an extra attribute so it can be tracked
+       clickEvent = document.createEvent('MouseEvents');
+       clickEvent.initMouseEvent(this.determineEventType(targetElement), true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null);
+       clickEvent.forwardedTouchEvent = true;
+       targetElement.dispatchEvent(clickEvent);
+};
+
+FastClick.prototype.determineEventType = function(targetElement) {
+       'use strict';
+
+       //Issue #159: Android Chrome Select Box does not open with a synthetic click event
+       if (deviceIsAndroid && targetElement.tagName.toLowerCase() === 'select') {
+               return 'mousedown';
+       }
+
+       return 'click';
+};
+
+
+/**
+ * @param {EventTarget|Element} targetElement
+ */
+FastClick.prototype.focus = function(targetElement) {
+       'use strict';
+       var length;
+
+       // Issue #160: on iOS 7, some input elements (e.g. date datetime) throw a vague TypeError on setSelectionRange. These elements don't have an integer value for the selectionStart and selectionEnd properties, but unfortunately that can't be used for detection because accessing the properties also throws a TypeError. Just check the type instead. Filed as Apple bug #15122724.
+       if (deviceIsIOS && targetElement.setSelectionRange && targetElement.type.indexOf('date') !== 0 && targetElement.type !== 'time') {
+               length = targetElement.value.length;
+               targetElement.setSelectionRange(length, length);
+       } else {
+               targetElement.focus();
+       }
+};
+
+
+/**
+ * Check whether the given target element is a child of a scrollable layer and if so, set a flag on it.
+ *
+ * @param {EventTarget|Element} targetElement
+ */
+FastClick.prototype.updateScrollParent = function(targetElement) {
+       'use strict';
+       var scrollParent, parentElement;
+
+       scrollParent = targetElement.fastClickScrollParent;
+
+       // Attempt to discover whether the target element is contained within a scrollable layer. Re-check if the
+       // target element was moved to another parent.
+       if (!scrollParent || !scrollParent.contains(targetElement)) {
+               parentElement = targetElement;
+               do {
+                       if (parentElement.scrollHeight > parentElement.offsetHeight) {
+                               scrollParent = parentElement;
+                               targetElement.fastClickScrollParent = parentElement;
+                               break;
+                       }
+
+                       parentElement = parentElement.parentElement;
+               } while (parentElement);
+       }
+
+       // Always update the scroll top tracker if possible.
+       if (scrollParent) {
+               scrollParent.fastClickLastScrollTop = scrollParent.scrollTop;
+       }
+};
+
+
+/**
+ * @param {EventTarget} targetElement
+ * @returns {Element|EventTarget}
+ */
+FastClick.prototype.getTargetElementFromEventTarget = function(eventTarget) {
+       'use strict';
+
+       // On some older browsers (notably Safari on iOS 4.1 - see issue #56) the event target may be a text node.
+       if (eventTarget.nodeType === Node.TEXT_NODE) {
+               return eventTarget.parentNode;
+       }
+
+       return eventTarget;
+};
+
+
+/**
+ * On touch start, record the position and scroll offset.
+ *
+ * @param {Event} event
+ * @returns {boolean}
+ */
+FastClick.prototype.onTouchStart = function(event) {
+       'use strict';
+       var targetElement, touch, selection;
+
+       // Ignore multiple touches, otherwise pinch-to-zoom is prevented if both fingers are on the FastClick element (issue #111).
+       if (event.targetTouches.length > 1) {
+               return true;
+       }
+
+       targetElement = this.getTargetElementFromEventTarget(event.target);
+       touch = event.targetTouches[0];
+
+       if (deviceIsIOS) {
+
+               // Only trusted events will deselect text on iOS (issue #49)
+               selection = window.getSelection();
+               if (selection.rangeCount && !selection.isCollapsed) {
+                       return true;
+               }
+
+               if (!deviceIsIOS4) {
+
+                       // Weird things happen on iOS when an alert or confirm dialog is opened from a click event callback (issue #23):
+                       // when the user next taps anywhere else on the page, new touchstart and touchend events are dispatched
+                       // with the same identifier as the touch event that previously triggered the click that triggered the alert.
+                       // Sadly, there is an issue on iOS 4 that causes some normal touch events to have the same identifier as an
+                       // immediately preceeding touch event (issue #52), so this fix is unavailable on that platform.
+                       if (touch.identifier === this.lastTouchIdentifier) {
+                               event.preventDefault();
+                               return false;
+                       }
+
+                       this.lastTouchIdentifier = touch.identifier;
+
+                       // If the target element is a child of a scrollable layer (using -webkit-overflow-scrolling: touch) and:
+                       // 1) the user does a fling scroll on the scrollable layer
+                       // 2) the user stops the fling scroll with another tap
+                       // then the event.target of the last 'touchend' event will be the element that was under the user's finger
+                       // when the fling scroll was started, causing FastClick to send a click event to that layer - unless a check
+                       // is made to ensure that a parent layer was not scrolled before sending a synthetic click (issue #42).
+                       this.updateScrollParent(targetElement);
+               }
+       }
+
+       this.trackingClick = true;
+       this.trackingClickStart = event.timeStamp;
+       this.targetElement = targetElement;
+
+       this.touchStartX = touch.pageX;
+       this.touchStartY = touch.pageY;
+
+       // Prevent phantom clicks on fast double-tap (issue #36)
+       if ((event.timeStamp - this.lastClickTime) < this.tapDelay) {
+               event.preventDefault();
+       }
+
+       return true;
+};
+
+
+/**
+ * Based on a touchmove event object, check whether the touch has moved past a boundary since it started.
+ *
+ * @param {Event} event
+ * @returns {boolean}
+ */
+FastClick.prototype.touchHasMoved = function(event) {
+       'use strict';
+       var touch = event.changedTouches[0], boundary = this.touchBoundary;
+
+       if (Math.abs(touch.pageX - this.touchStartX) > boundary || Math.abs(touch.pageY - this.touchStartY) > boundary) {
+               return true;
+       }
+
+       return false;
+};
+
+
+/**
+ * Update the last position.
+ *
+ * @param {Event} event
+ * @returns {boolean}
+ */
+FastClick.prototype.onTouchMove = function(event) {
+       'use strict';
+       if (!this.trackingClick) {
+               return true;
+       }
+
+       // If the touch has moved, cancel the click tracking
+       if (this.targetElement !== this.getTargetElementFromEventTarget(event.target) || this.touchHasMoved(event)) {
+               this.trackingClick = false;
+               this.targetElement = null;
+       }
+
+       return true;
+};
+
+
+/**
+ * Attempt to find the labelled control for the given label element.
+ *
+ * @param {EventTarget|HTMLLabelElement} labelElement
+ * @returns {Element|null}
+ */
+FastClick.prototype.findControl = function(labelElement) {
+       'use strict';
+
+       // Fast path for newer browsers supporting the HTML5 control attribute
+       if (labelElement.control !== undefined) {
+               return labelElement.control;
+       }
+
+       // All browsers under test that support touch events also support the HTML5 htmlFor attribute
+       if (labelElement.htmlFor) {
+               return document.getElementById(labelElement.htmlFor);
+       }
+
+       // If no for attribute exists, attempt to retrieve the first labellable descendant element
+       // the list of which is defined here: http://www.w3.org/TR/html5/forms.html#category-label
+       return labelElement.querySelector('button, input:not([type=hidden]), keygen, meter, output, progress, select, textarea');
+};
+
+
+/**
+ * On touch end, determine whether to send a click event at once.
+ *
+ * @param {Event} event
+ * @returns {boolean}
+ */
+FastClick.prototype.onTouchEnd = function(event) {
+       'use strict';
+       var forElement, trackingClickStart, targetTagName, scrollParent, touch, targetElement = this.targetElement;
+
+       if (!this.trackingClick) {
+               return true;
+       }
+
+       // Prevent phantom clicks on fast double-tap (issue #36)
+       if ((event.timeStamp - this.lastClickTime) < this.tapDelay) {
+               this.cancelNextClick = true;
+               return true;
+       }
+
+       // Reset to prevent wrong click cancel on input (issue #156).
+       this.cancelNextClick = false;
+
+       this.lastClickTime = event.timeStamp;
+
+       trackingClickStart = this.trackingClickStart;
+       this.trackingClick = false;
+       this.trackingClickStart = 0;
+
+       // On some iOS devices, the targetElement supplied with the event is invalid if the layer
+       // is performing a transition or scroll, and has to be re-detected manually. Note that
+       // for this to function correctly, it must be called *after* the event target is checked!
+       // See issue #57; also filed as rdar://13048589 .
+       if (deviceIsIOSWithBadTarget) {
+               touch = event.changedTouches[0];
+
+               // In certain cases arguments of elementFromPoint can be negative, so prevent setting targetElement to null
+               targetElement = document.elementFromPoint(touch.pageX - window.pageXOffset, touch.pageY - window.pageYOffset) || targetElement;
+               targetElement.fastClickScrollParent = this.targetElement.fastClickScrollParent;
+       }
+
+       targetTagName = targetElement.tagName.toLowerCase();
+       if (targetTagName === 'label') {
+               forElement = this.findControl(targetElement);
+               if (forElement) {
+                       this.focus(targetElement);
+                       if (deviceIsAndroid) {
+                               return false;
+                       }
+
+                       targetElement = forElement;
+               }
+       } else if (this.needsFocus(targetElement)) {
+
+               // Case 1: If the touch started a while ago (best guess is 100ms based on tests for issue #36) then focus will be triggered anyway. Return early and unset the target element reference so that the subsequent click will be allowed through.
+               // Case 2: Without this exception for input elements tapped when the document is contained in an iframe, then any inputted text won't be visible even though the value attribute is updated as the user types (issue #37).
+               if ((event.timeStamp - trackingClickStart) > 100 || (deviceIsIOS && window.top !== window && targetTagName === 'input')) {
+                       this.targetElement = null;
+                       return false;
+               }
+
+               this.focus(targetElement);
+               this.sendClick(targetElement, event);
+
+               // Select elements need the event to go through on iOS 4, otherwise the selector menu won't open.
+               // Also this breaks opening selects when VoiceOver is active on iOS6, iOS7 (and possibly others)
+               if (!deviceIsIOS || targetTagName !== 'select') {
+                       this.targetElement = null;
+                       event.preventDefault();
+               }
+
+               return false;
+       }
+
+       if (deviceIsIOS && !deviceIsIOS4) {
+
+               // Don't send a synthetic click event if the target element is contained within a parent layer that was scrolled
+               // and this tap is being used to stop the scrolling (usually initiated by a fling - issue #42).
+               scrollParent = targetElement.fastClickScrollParent;
+               if (scrollParent && scrollParent.fastClickLastScrollTop !== scrollParent.scrollTop) {
+                       return true;
+               }
+       }
+
+       // Prevent the actual click from going though - unless the target node is marked as requiring
+       // real clicks or if it is in the whitelist in which case only non-programmatic clicks are permitted.
+       if (!this.needsClick(targetElement)) {
+               event.preventDefault();
+               this.sendClick(targetElement, event);
+       }
+
+       return false;
+};
+
+
+/**
+ * On touch cancel, stop tracking the click.
+ *
+ * @returns {void}
+ */
+FastClick.prototype.onTouchCancel = function() {
+       'use strict';
+       this.trackingClick = false;
+       this.targetElement = null;
+};
+
+
+/**
+ * Determine mouse events which should be permitted.
+ *
+ * @param {Event} event
+ * @returns {boolean}
+ */
+FastClick.prototype.onMouse = function(event) {
+       'use strict';
+
+       // If a target element was never set (because a touch event was never fired) allow the event
+       if (!this.targetElement) {
+               return true;
+       }
+
+       if (event.forwardedTouchEvent) {
+               return true;
+       }
+
+       // Programmatically generated events targeting a specific element should be permitted
+       if (!event.cancelable) {
+               return true;
+       }
+
+       // Derive and check the target element to see whether the mouse event needs to be permitted;
+       // unless explicitly enabled, prevent non-touch click events from triggering actions,
+       // to prevent ghost/doubleclicks.
+       if (!this.needsClick(this.targetElement) || this.cancelNextClick) {
+
+               // Prevent any user-added listeners declared on FastClick element from being fired.
+               if (event.stopImmediatePropagation) {
+                       event.stopImmediatePropagation();
+               } else {
+
+                       // Part of the hack for browsers that don't support Event#stopImmediatePropagation (e.g. Android 2)
+                       event.propagationStopped = true;
+               }
+
+               // Cancel the event
+               event.stopPropagation();
+               event.preventDefault();
+
+               return false;
+       }
+
+       // If the mouse event is permitted, return true for the action to go through.
+       return true;
+};
+
+
+/**
+ * On actual clicks, determine whether this is a touch-generated click, a click action occurring
+ * naturally after a delay after a touch (which needs to be cancelled to avoid duplication), or
+ * an actual click which should be permitted.
+ *
+ * @param {Event} event
+ * @returns {boolean}
+ */
+FastClick.prototype.onClick = function(event) {
+       'use strict';
+       var permitted;
+
+       // It's possible for another FastClick-like library delivered with third-party code to fire a click event before FastClick does (issue #44). In that case, set the click-tracking flag back to false and return early. This will cause onTouchEnd to return early.
+       if (this.trackingClick) {
+               this.targetElement = null;
+               this.trackingClick = false;
+               return true;
+       }
+
+       // Very odd behaviour on iOS (issue #18): if a submit element is present inside a form and the user hits enter in the iOS simulator or clicks the Go button on the pop-up OS keyboard the a kind of 'fake' click event will be triggered with the submit-type input element as the target.
+       if (event.target.type === 'submit' && event.detail === 0) {
+               return true;
+       }
+
+       permitted = this.onMouse(event);
+
+       // Only unset targetElement if the click is not permitted. This will ensure that the check for !targetElement in onMouse fails and the browser's click doesn't go through.
+       if (!permitted) {
+               this.targetElement = null;
+       }
+
+       // If clicks are permitted, return true for the action to go through.
+       return permitted;
+};
+
+
+/**
+ * Remove all FastClick's event listeners.
+ *
+ * @returns {void}
+ */
+FastClick.prototype.destroy = function() {
+       'use strict';
+       var layer = this.layer;
+
+       if (deviceIsAndroid) {
+               layer.removeEventListener('mouseover', this.onMouse, true);
+               layer.removeEventListener('mousedown', this.onMouse, true);
+               layer.removeEventListener('mouseup', this.onMouse, true);
+       }
+
+       layer.removeEventListener('click', this.onClick, true);
+       layer.removeEventListener('touchstart', this.onTouchStart, false);
+       layer.removeEventListener('touchmove', this.onTouchMove, false);
+       layer.removeEventListener('touchend', this.onTouchEnd, false);
+       layer.removeEventListener('touchcancel', this.onTouchCancel, false);
+};
+
+
+/**
+ * Check whether FastClick is needed.
+ *
+ * @param {Element} layer The layer to listen on
+ */
+FastClick.notNeeded = function(layer) {
+       'use strict';
+       var metaViewport;
+       var chromeVersion;
+       var blackberryVersion;
+
+       // Devices that don't support touch don't need FastClick
+       if (typeof window.ontouchstart === 'undefined') {
+               return true;
+       }
+
+       // Chrome version - zero for other browsers
+       chromeVersion = +(/Chrome\/([0-9]+)/.exec(navigator.userAgent) || [,0])[1];
+
+       if (chromeVersion) {
+
+               if (deviceIsAndroid) {
+                       metaViewport = document.querySelector('meta[name=viewport]');
+
+                       if (metaViewport) {
+                               // Chrome on Android with user-scalable="no" doesn't need FastClick (issue #89)
+                               if (metaViewport.content.indexOf('user-scalable=no') !== -1) {
+                                       return true;
+                               }
+                               // Chrome 32 and above with width=device-width or less don't need FastClick
+                               if (chromeVersion > 31 && document.documentElement.scrollWidth <= window.outerWidth) {
+                                       return true;
+                               }
+                       }
+
+               // Chrome desktop doesn't need FastClick (issue #15)
+               } else {
+                       return true;
+               }
+       }
+
+       if (deviceIsBlackBerry10) {
+               blackberryVersion = navigator.userAgent.match(/Version\/([0-9]*)\.([0-9]*)/);
+               
+               // BlackBerry 10.3+ does not require Fastclick library.
+               // https://github.com/ftlabs/fastclick/issues/251
+               if (blackberryVersion[1] >= 10 && blackberryVersion[2] >= 3) {
+                       metaViewport = document.querySelector('meta[name=viewport]');
+
+                       if (metaViewport) {
+                               // user-scalable=no eliminates click delay.
+                               if (metaViewport.content.indexOf('user-scalable=no') !== -1) {
+                                       return true;
+                               }
+                               // width=device-width (or less than device-width) eliminates click delay.
+                               if (document.documentElement.scrollWidth <= window.outerWidth) {
+                                       return true;
+                               }
+                       }
+               }
+       }
+       
+       // IE10 with -ms-touch-action: none, which disables double-tap-to-zoom (issue #97)
+       if (layer.style.msTouchAction === 'none') {
+               return true;
+       }
+
+       return false;
+};
+
+
+/**
+ * Factory method for creating a FastClick object
+ *
+ * @param {Element} layer The layer to listen on
+ * @param {Object} options The options to override the defaults
+ */
+FastClick.attach = function(layer, options) {
+       'use strict';
+       return new FastClick(layer, options);
+};
+
+
+if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+
+       // AMD. Register as an anonymous module.
+       define(function() {
+               'use strict';
+               return FastClick;
+       });
+} else if (typeof module !== 'undefined' && module.exports) {
+       module.exports = FastClick.attach;
+       module.exports.FastClick = FastClick;
+} else {
+       window.FastClick = FastClick;
+}

diff --git a/favicon.svg b/favicon.svg
new file mode 100644 (file)
index 0000000..930ec56
--- /dev/null
+++ b/favicon.svg
@@ -0,0 +1,165 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:osb="http://www.openswatchbook.org/uri/2009/osb"
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="3543.3069"
+   height="3543.3069"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.48.5 r10040"
+   sodipodi:docname="favicon.svg">
+  <defs
+     id="defs4">
+    <linearGradient
+       id="linearGradient3757"
+       osb:paint="solid">
+      <stop
+         style="stop-color:#0000ff;stop-opacity:1;"
+         offset="0"
+         id="stop3759" />
+    </linearGradient>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.125"
+     inkscape:cx="1771.6534"
+     inkscape:cy="1569.487"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     units="cm"
+     inkscape:window-width="1024"
+     inkscape:window-height="771"
+     inkscape:window-x="355"
+     inkscape:window-y="25"
+     inkscape:window-maximized="0" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(0,2490.9449)">
+    <rect
+       style="fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.79178107px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       id="rect3083"
+       width="3542.5154"
+       height="3542.5151"
+       x="0.39589053"
+       y="-2490.5491" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094"
+       width="812.36633"
+       height="812.36627"
+       x="320.19479"
+       y="-80.199097" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-7"
+       width="812.36633"
+       height="812.36627"
+       x="1359.5637"
+       y="-80.199097" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-7-0"
+       width="812.36633"
+       height="812.36627"
+       x="2398.9351"
+       y="-80.199097" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-2"
+       width="812.36633"
+       height="812.36627"
+       x="320.19479"
+       y="-1119.568" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-7-1"
+       width="812.36633"
+       height="812.36627"
+       x="1359.5637"
+       y="-1119.568" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-7-0-3"
+       width="812.36633"
+       height="812.36627"
+       x="2398.9351"
+       y="-1119.568" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-2-7"
+       width="812.36633"
+       height="812.36627"
+       x="320.19479"
+       y="-2158.9395" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-7-1-9"
+       width="812.36633"
+       height="812.36627"
+       x="1359.5636"
+       y="-2158.9395" />
+    <rect
+       style="fill:none;stroke:#000000;stroke-width:73.46047974;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="rect4094-7-0-3-6"
+       width="812.36633"
+       height="812.36627"
+       x="2398.9351"
+       y="-2158.9395" />
+    <path
+       style="fill:none;stroke:#ff0000;stroke-width:74.77600098;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 462.58486,-2016.5505 527.5862,527.5862 z"
+       id="path4184"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;stroke:#ff0000;stroke-width:74.77600098;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 990.17106,-2016.5504 -527.58621,527.5862 z"
+       id="path4184-1"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;stroke:#ff0000;stroke-width:74.77600098;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 1501.9537,-2016.5494 527.5862,527.5862 z"
+       id="path4184-7"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;stroke:#ff0000;stroke-width:74.77600098;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 2029.5399,-2016.5493 -527.5862,527.5862 z"
+       id="path4184-1-6"
+       inkscape:connector-curvature="0" />
+    <image
+       y="-727.64441"
+       x="1639.9323"
+       id="image4434"
+       xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAW8AAAGQCAYAAABh+OHYAAAABHNCSVQICAgIfAhkiAAAIABJREFU eJzsvWmsbNl5Hba+vc85Nd55enPP3aTUZDfFoTmIEZsaIkYmCdKKFMGCHUOAFQdIAttxACtAfihA jCA2Eig2YCD+kfwwDASOE8CIAxiQ/gQUQ3VTLc5N9dxvvFPdW9OZ9t7flx97n3Pq3vded5Psfu91 v7Ma1fdW1amqU1XvrvOdtde3PhIRtGjR4t6BiEBEsHtjd5ClabS8slJubm1md3u/WtxbiO72DrRo 0eIkmJlGh6NuWRR6eWW5XF5ZLu72PrW496Du9g60aNHiJkiWZdo5h06nY5Mk4bu9Qy3uPbSVd4sW 9xCcc2o+nS4Jux5ByiLPoRQBgkSAiADq9Hp5FEXubu9ri7sLajXvFi3uDThro/lstnawt/uIiDys lJoopSYAREQGIpIopX6wtrF5pdfvFwIQARTFMRPR3d79FncYLXm3aHGPYHw0Onewt/dz1tqPAPh7 SqllrbUEYiYimimlflcp9X0iigE4raP5xs7OPIqilsDvM7SySYsW9wiMtZtZlv0GM/8mgLNRFCkR gVJ+aUopNQTwz5g5gyfzF5xz/+Bwb1fWNzezpNNtpZT7CC15t2hxD2A2nnRnx5ML1pjH2fEFEAAB SADRGkQAWAgajwEAAYCiC0TKmqL8Q2F5427uf4s7j5a8W7S4B5Cl6Xo6nz/Nzn2YmQUAMREcASIM IgITQYmDIgUiAoHWoPAVLfijdD67bkxh4CkfACCCqNfvcxTHrVvlA4iWvFu0uIsQEZRF0Svy4gHH 9mkBP8Ti1Q/HALEvuAGAiKBYQWsNpRQUFABRgPrV6fjo5xRRDiITFHLHjO84t3bQ7fWcUkriJGl1 8Q8QWvJu0eIuQpjV4e7+hdl0+gl2fFFEwMwQERARnHMgovq6UgoiAq01mBlKqTWt9T9kZqlIXQAQ MBfQfzoZH//JdHycdns9t7lzJr3b77fFu4eWvFu0uIsQgJhd31r771tnP+acq8nbOV+BV+QNoF68 rMiciMg5FymlwMzQWlckvwLS/xNE/o4A/wcAfbfeY4v3Bi15t2hxd0HM0mfHK+y4w8wnKu/qsmjp dc7V16tqXOuGm0P1TZHW2yAa9geDcnl1jVrJ5IOFlrxbtLiLICIBpOecU8YYOGdQ6R7CDA6dOAgk rYjgrIUDEOkISmvvSGGGE4E4htIKWmkwaZBSYq2VdD4TzPxTewggUDrS0XBpuSTVJmW839CSd4sW dwnMrGbT6YYpzTnHru+sBTtXkzRYwHAg8tU0kQIJwNZCRKBA0EoBIhAn8P8RhBVEMYQUlNafc/O5 y9JUlFJ06vWvJp3OtwbDJUOLvN7ifYGWvFu0uAtgZqTz+dKNq9c+k2fZ551zm56kQ6UNoOJTEa9x MzsAUkfGOmcXiN0/SCnliVwEriQorf+GUupvVLKKOllh/98Q+S6Ixnfqfbd499CSd4sWdwF5mqmD 3b2LaZp+3ZTmP2DmtUrWvlVkBTPX9zXk3SxoVtp3cKDAMYMdg5RGpDWiKELVrVltz8yaRfrMrAHY W+1ntW2Lew8tebdocRfg2A2LoniyLMtfddatO8dKRCAsAOQEaVY/K1IXEV+Ti8Bae8JCWP0kIlhx ADlwsBUyM6Io8rKMr8DZGqP2rl9bV0rNCeQAoYVDh1rb2Mw73bbt/l5ES94tWtwNCLSIDAGsQUQJ gr/bOmDBZeIrZd8z6VlV6t8FAqkWNyEQsL+uCCDyzT3UNFdWFbvWumr0eYqZ/4ciz51SyhCREHmZ BiJjAf7oeHT4xvLqatHrD25Zmbe4e2jJu0WLuwMBwOECVM05riFvVQngocOyyjvxm0t9E0QgzBBR YMVQQhClQIr8iwTrYVV96yCjRFF0Xil1vtLDG2siICLHBPxzpbVTSrWLmfcgWvJu0eIuQCBKRPQi qQoLWHxlXUkfVbVcP27h90UtWkTgxIECcSsAULq+b/F1qotzDlprxHFcN/csyDUZgFm328sBIM8y IqUoaVvs7xm05N2ixd2AIGbmgbWWnHNgqbTucH/4uUjevoJmAIuVObxlO2xXE6s/AkBw8yKnq+yI 4eKcQxzHEJFaE4fvyDxzPDosAUQsKKI4GW3vbM/b4Q/3BlrybtHiDuFkBc1D5+yWMYbYVq4RACpU 3QAADmK3V0sEAscOAEEpAokGkQJIQkMPg0AgFpDSgLD3fS+QN4CawIkIKlT3VVt+tahJRBsA/oWI WL8H9CellH+wu7tL29vbszbk6u6jnaTTosUdxGQ0imbT6cemk8lvH40Ovp6m0wfYGUUiIF9Cexuf NL8rraGVrkmWFDWxsEQgilCxPEH5+xTBKvZtO6Sgtfd3V/ZCraLgTAFI+cfEcYQkSZAkCZTWYeUS /jmVOiSiP2Z2/6TX619b2dq80en153fpY2yBtvJu0eKOgJ3DbDqNj4+OHp2Ox7+dzqe/VebZRbYl 2JVAyOlWpAEQEKpgAIAwSHu5RNiBQIASiISynACiKGR8h6YeFrAyYDC00oCKvaQi/jmJfJUuoTuT ycGCoUI1rrnajqBIIMAGQb4izLpI5//L7Cg6yudZJCKxivTxcHnZKt1mX91JtOTdosUdAItEx6PD x2bTyW/lefZlY8qLHKQKx+yrbAUvkSxIHNVCYyWC+1AqVRXFtTvEx59oEFXbEhgOHIJSKOjczFw1 6IDhfeVKaTBXr+lFdKX0CV1cCYMEXRH5OhEdpLPp48yTxDlXxN3uH/eHw5eU1q2d8A6iJe8WLd5j MDNMWfTLMv/3sjz960WZPWStAYv1C5CCQJa6JljgpEukul4tWop4GYSo8oELiCQQuGdzFi+bMAv8 8UHVC57ekRiUdaaF55baTqiUQhRF/vdgACdSpJT6fYHAWAtr7RsCKFMW+0rrQ6WUMDtix1pHkW11 8fcObZRYixbvESSQoSkLdXywu2nK4jFrTY+dhYgLJOzb2eM4RhTHfgGyHmN20iWySK7W2oVFxuY+ T84n17Fql4m1fmGTF+yHgrAf4XmNgSlLlGUBY0z9OtZamNKA2S92WuOvl2W5nGXzzxxcu/rhMs97 AJBnWfdwf3dDmFvmfg/RVt4tWrxHOD4erURxXMY6GmTZ/FfLMv8qu3KD2cKxhXPGV7lK+aqbVKjG fbV8GouWQQCB6Nk7T1TV81PxpfghaSQQBtg6gOB1dRW6NQVQRP616gOF18uFFQh+bqYLzyrMIEUg 8i341hoYY5astZ/Psuw7zO4VAKmIELOrjkKtI+I9QkveLVq8i3DOYXx03DGmeDRL52txHO9pRdtZ Ov9yWeQXrSlia0pYa2GtgbUO0BrOeWLkxaad4P1uBi+EcO+aEqWutkUUJOjdIjdnodSErxvrIAUf eH2gOGUpZOfgqhFs4f0tDoYI1XzEwltZFj17tL//F0Q06XS62eraxjEp1Q4+fg/RkneLFu8SjDE0 PR5vjA4On8qy+dcAXkuSeAThlTxLP1UWWVSWBawxnvjYoco0MaWBaL9w6ZyFtQ4n5GISqOAmOV3O VgTOIdSKyYGgINofEKo42WpxE0B9gCBSYG6ae2ryFgoSCdXE79PABQh2w+o5jDU6TdOPjQ72frs3 GBz1BsNvRXGcvbefdouWvFu0+BlhykI7xzqdz5cO9w9+IZ3P/2Y6n31Z4AbdbgdaKxhj/AQca2Ct gYh3fWhNAAPGGLDzVj1jbN1E4y8SdA4/7oyUCiFVdQ5JyPomSJg8T1AQFuioaZEHQuFOCHp51YLv F0xPjlvzDT6OXV3la0Whyqc6dFy8/q6ttVsQ/mpZlt8C8K079+nfv2jJu0WLnxIiAna2MzrYO5fN 001T2vNZlj87m02/mk6nXYDB1qDTSXxFG/JLqgVCrQikNFgY1llPtkoFdwiHFnjyjTYCMJrbmtwT vy9+EbLaL0BQNUY2Ugepqrqusk34VOxs5V9YlGOk7txU0LAcFkRJgcjve8hJERFZzfN82zmXaK3L O/ld3I9oybtFi58QteZrTXd048qn5pPxF7M8+9U0zR6ez9NeWZTd4+NjiiKNKFpFEhPElt6jzQrE EYQtHDOUrux6DChCrBS0jkCEU9p3mJLDDKVdLZNoraB1DBG/kFjleRtjAUVwjNr2BwCl8ZxK8FU/ hQVLX7FXS5MLFXaAIoIQ1wGHEG8xdCzQCoBostZh/8aNp3q9/sd3zp//5h34Ku5rtOTdosVPiCyd dybT8SpbeyEdH301T9Nfz4v8kSxNO0WehUYaB6UixLEn4vk8hSktnKusewzHZZj87r3UEC+fLGrd Ik2kq5dSgCiupBIBEIFIQ4RC3VwFU3k5hIVBTHVRTaErk4gQsgexONpSJEg0cnJiPRGBfaell22I QAqIlIaw78JUjmFM+VhR5B8B0JL3e4yWvFu0eAcQEUwn4zVjzTBL56vz+expZ82XbZo+nWfpg0WR x3meoigygAhaA51ujF6/i06SIEsTsMNCJa3ADDhnIQJEOsSyoqm4qwCpyguuNEFrBZHqdgTpI1TM VDXt+IVNFgYc4Fh8TGzIB/cyCsEFGSaK4noR1Oer1DJ3I8uQgP29IBEoresMFaFwZBCAnbs0m02e mRwf/V/D5ZX9Ngv8vUNL3i1avAWstaoosq5z3B2N9h8rivyzzrlL1tonrSl/xWYZ0nSOPE8xT2fI 8ywQLAD0fEWqCEpplKVFlpVhoVJBqwgsLhg4OHiwNQCudW9mrm16/nkUrLXhIAAoVXVcAlCAEq9d e8eIlzkEDGECdNQMeAi5JkQEUToU7IvVdqWhUx0t63tuPIlXWnpF8By0cTZmZTqZfHx0sPeLw6Xl fwPA3MGv675CS94tWtwC1loSYT2fz4ZHo/0HnHNPWmsftNb+rjHmQ6Up4UwBl+fI0xTzdILp9Bjz dOYXFEFQxOjEGkQa167t4cb1Q8xnGbqdHlZWl9AfdBDHGtAapBjGWFj4CfFUE7mEKtyismP7YrbK IUFN3swABzlDhH1UrIRKmghENgRYVZWyVIuuCyPraeH/gaCJQLXfXCBM4EDeFEjbOS8FCSvkeX5x Ppt/rSiKb3S63X3V+r3fE7Tk3aLFAoLLgo5G+/08z844Z3ecc89Ya//A2rJXmrJTliXKsoQ1BTjL kM1TpPMZ5rMxJtMjMFs4K5jPpjgejTCfFfjxi6/h2tU9TKYpuv0Btrc2sLW1gY3NVaxvrmFlZQUR aYCBOI6gIw0igXMCY0pY57VwpQhJEnsXyk1NOMGNAgGLq5YeAfgFSu849M05dUK4CJxBUF0WJuks yC/1YAhfcwciBxxbKOgTQVmAwFq7OptNP7t77fKnz1184I+TTnd2577B+wctebdosQBmh9Hhfi/L 0hXryv+EnfsN69zQOrtpbAljfO5HWRawZQFbFCjLHNaWcK6EtTlKUyDPCsxmU9y4cQMH+2P86Aev YW93hFlWQOsEg34PK2sDbG1v4PyFszhzZhtb61tYXV5Fv9+DjjrBJaKDROGJO44TKEXB190Qd5XT DQBaV+mBVUHdSCkibiGl0C96SriuwkKk/ynBoeJNgggDjn0V7qNlxQGuatyB8p51H66lmLlnjVlj lpZj3iO0H2yLFgCyLO3O59MBM6t0Plt3zvwtFvebztlLvpW9amcvYUxF3iVsXqAsClhbQMSAwCCy ELYoyhJZWmBv9xAHByNMp3OUhiFwyLIMo+MD3Ni9jitXL2NlZRnnz57HhbPnsbq2gs3NdQyHfWit 66jWqhlHQphUBSLl2+zr69HJSjzYBKs2+EVvt6+gQ7Y3vO4uIrXlsCLyMMcnHBAqJwvAtUUxglIR oihGJ0lm3U7nB1EUvUZExZ36Du83tOTd4r5HlqV6Mj5O5vPpz4vwl0Rk4Nj8DrPb9I4PC+t8Z6QJ BO5DmUoUWY48y1DaHMYUYC5BEGgNKPJ6sjUmdDMqHwQlCuwcjCuRlzlm8xmuX7+Ba1d28fr661hZ WcL2zia2tzexvr6GpaUhev0O4jhCNedyMXFQKaobbny8q6obcQJvh58E52Shc7PKjvLdlBBqoq14 obmH/DaAqzVw3xbvYJ2vuiOdQMcxoqSDTqdzfWm49P+srm9+P4qi/C58pfcFWvJucd/Cx7WWanx8 nKTp7BER+To7/i9YOESnsg9nsg5sGewY4hhs/eKctQ6FmaO0GUqTw5gSjh2YAaWi0ASjfYXKDr5H 0iEMPIMKP9kyCsPYyw5wuH+IbjfGcGmAjfU1bG1vYmdnG5tbG1hbXUG/30eSRIhijTiK4djvC4d2 e8UE56jONPG+8pAZrv1cyxBRBUUCqqUR1D9pYXhxvS5a694CqWJhrYOxDiIEqyyUVYiTCI77Fkps 0u0MSakxgHZIw3uAlrxb3FcIwwx8celYHRzs9Yui2BCR33PO/S1hFmEhiAJYIJbAFmALwCrAasAp SEngkuFojKhbwIgBSkDpbvBu+5wRYzPM5wUm0ymEK9peaH6Bv+oVaA0hjbwE8sM5RkdzvH75BpaW BtjY2MD29jbW19ewtrbkFzs31hGzgnMGWhOiWMOwhbOMOI4BUWDHcOLAGojjMOzBeXuhgx+6EMex 35mQcbLYoi9oOjS9XbDJEVdKkMSAdQ6ODcrcAmTgJH8iLyb/QMhtXXzwiX/a6fZv3Nlv+f5AS94t 7iuMx8ed+WyagCgSlr61VjG7P2R2XxGRWEK2ta+6uWlRZwHXk22kHmgQRREIDKWiuqsRUCF/xNfX QuRHjkECdS/GBS5MlEcV1eqp3LJD6QzyIsdkMsXe3j76/T76/QRbWxs4d+4cNjbWsLy8hLW1lXqg sPeBC7REdbcNs8CYSgKRWjbxC5NNx6a1JlTraLaDQKDr90chE9z7TpSfhxmyWKy1mEwmyhjeSrrD v3n2gv3XiciNdqLOu4+WvFvcV7DGrKRp+jWl1NdFvBOCxT0tjlewkCXi2GvdrppSEy7Ohck1YYSZ VhGgHLTS0CqG1gJx7B0aJHCW4Uy1yAjU3uyatAOZoqJx7wxRKiQDigM7RpaVKEuD8XgKpYDd3X1c vXIdy8tDrK2tYufMNjY21rGysozl5WWsrCzDz6JsQqz8GYGflenb8n2OeJaZsE/1TvgJ9aErk4Wg OAKpuPZ6I8TLKvISDUFBk4Z1DGMZWZbr8dF45/Lrr/7HFx94JB0sLf34jnzB9xFa8m7xgUWe5zrL UoLXXDsCTrIsXWbmD4vIrwGhwYVdnfhXkbd11pO0q5IAq4sLGnLVAKMgoqBVgjh2gChoElgrEFci ywpkWR5IsRGPq3p2IVUkKM663sLPyfG/C7zn2zpPtKa0mM8y6Eij202w9uYVbKyvYXNrE2fOnMGZ MztYGXTR63aQdBKfnVIxc0gMdE5gg0Fba1W7SABAiaoXKp1jWHGoent8tV5V79X+ewthFGmQAM4J 0nmq9m7c+Fqc9N44g/PjwdKwlU/eRbTk3eJnhjWGTFnEIIq7vf78XjhFLopcTSbjaDabPiiQT0Gk J+AeW+4D8ng91JedX4RcqLr9RPdm3iNq4g65JCJ1Q4tjgrAGqRhRJBDR9Ugy6yaYz1OkWVZX3eGR TY5IXYNLoGuq5ZMmZGTxMdVWgDEOuTGYZzmmkzn2dg+wdOU6NtavYXt7Eztbq1hbW8bK6gqWl5aQ dDqI49g3AVXxsEAdYFKRsXeY+Hurit2xAoW0Q0US5BMsEL7fOxXF0MGHboxR8zS9uLe7+1Wt42sq 0v+m1+vN78DXf1+gJe8WPzPyLO2MDvZ2iGhj68y5l5NOd3anW6JDC3nFSHR0dNRP0/mOgH9ThP9b ESGfTX2KiF0TAtUM85WmuuZme++xbqbKRErDqRhCDFICpRnEPnubFMM4wTwvkOUlmvFkIdUvkPTJ uZMn0/2aypzCf1VfJMIBRIU6XcBOMJ/nmM9zHB4c4fLla1hZ7mBtbQVbWxvY3NrE6upqLassLQ3Q 7XahlIazpX+fgbCbYcbeO+6cgyCq904W9qSa3oOg9VtrwKjmYhqURY48Sz8+Ojz4Cin12tnzZ/8i jpPiXjjAv9/RkneLnxksvGJs+aRz7rG9G1dWts6c//NebzB+L19zcdYiAMzns+T4aDQA0BGRvnOu w+x+X9j9Hgv7sDxpwp4qEVpY6vQ+5jCaLOSB1NkfwRrHzssrCN5nUgpRnNSET+SteEp5GUIYKEuD srRosrGroQcNAVY1NYC6uib4jJKTDTUCQPszAhF40x97ClfhGUVgrMDNMszmMxweHuH69V0Ml4ZY Xgr6+M4Ozp49g82tDQwGA2gFsAZ01HjIawW+WuBUzRAIIlnYW144OxA/VZ69LVErBjsDU+b9PE8/ PjkefRnE2dlz5/8yjpO8JfCfDS15t/iZIcLLzpnPWGu/lmXuX7NzrwJ4T8nbOUf7Bwc9do4BsLOm Y0z5aQD/DTN3faXN55jdcHGggR+I4Amzqqor4mbmejIMVVGozMEeZ8EVgQdS992LEYhiqAhQAmgn dZOMgGCMgzEuVKuL8kcFnyJYyScSBiIQKBxfwkEqcL1AvHVPKPDmgo5eP6kn90RrOOtwfDzHeJLi hj5Er3cVa5evYnt7G1vbm9hYX8fW9ga63Q563R66Xd8MRMq3wFNY2PQSEUOHUEKGTy30B8BqIo/X yJWiWpZhdrC2pLLMHkgz9R+KkiHA/3Z759y3er3+e/pv5IOOlrxb/NSYTo4SZw3ledoBMGB2D7O4 TzDzvwLwxnvxmmma6vlsHjOzzmbzdWb+fQEuAqwAuSQin24q7GriDNckyM5r3MDJLsVF4l5coGQJ jTonLtXzAdU8R61iIA76r5Bvk1cK1jmUzkGhycxu4G9pQlir2xpppLIXQnxTz+L4M0GjvVeSUCNh 4MT7hgPYMawpkc1LjEZjXL58BUtLQ2xsrGJ5eRkbm76rc21tFb2ez1aJIng7JAHWGd9cVB19mP1F Kr2cAKUQhXmYznHQyy2YbYfFPWyd+VKepy+L8Lffi38f9xNa8m7xE4PZIUvnyWxyPLCm/GVr7aed c08556CINgHpvNXjrbWUpVkMCHr9vomiSG63rXMOaZpGgFgI9Hw+68ymsydZ+NcgGArwewRsctCk PWShYq407LAsyIwqW7WaK1lJJRUZKkVBmvDk5AnfR7UqIiiq5A2B1jEi7WCdgyJBEnfgnGCcHmF8 PEael1CkAqeerL4bLMaw8gmSpwVKJ0/fkCqjpFbCceqo4Ld2XNN7mDzvtejcWeSlxXQ6x8HBEa5e u4HBoI/19TVsbW1ic3MDq2srWF1ZwerqClZWlhF3FBwcSOn6c6NKkxeAxGeUq2pnQk45W4eyIMQx IY4p6iT0oDj17Hg0Oihz86fdXvdyt9e77fff4vZoybvFTwznnJocHy4bYz4Nlr/rrP2MLUuws4WO 4xygt1ystNaqw4ODLgDaPhNxFEWWHaM0ZSUGV+CyLPXhwcE2wI+JyIqIRCzuC865/6yZ7eizNqw1 tUbsrwe5I4Q5AaF6RdCPZXFaTZBBtPZhUKGCdYHAVdWwohUgKkgGBKUTT7aFj/AgEpRFjmvXbuDN y1cwm86glQa7ymlS1dqNv7t5ywyqzYENmt8ZLABBoxp6tlhp04KE4hGFVxM48ZdGcwcsA7ZkpGWO 6bzA4fEUl6/ewKDfx9raCnZ2zuDc+TPY2tzEyuoyBstddLtdRCEwRSuCVsq/ArN/3nDmQsoTuWWH MncgWGhySCKJS7Jf2kv5fLe73Nnc3vzfu71e9lb/XlrcGi15t3hbLLgzFABi55SIbDDzH4pzH3XO gUWglXZRFF0joqx6HPvxKwRAlFISpAsiIlJKsYiQtVbnWRYdHhyuMPMZBHYhokKEYZ15WkT+IYCd 4BpRiwuWp21+izGplYsEqEjTV8EcAqeq+yrSr7YXZ2otvPKFVNJA1bxSvT6RQpIkYDBsaZFlOfb3 D7C/t4/pbAbnAFpwa5xcpqvsgtXC5VujEVXcW2+4UOWf+jbDx8v1NYEflcaFgSkN0nmG8XiCg4MR Ll++jH6/j+2dTTz86CWsrq1gZXkFg/4A/W7Hu1XC2Y0xFjpM65EgpWitIeQ/1zzPoaMIALqdzuAT EPkkM/87AC15/xRoyfs+xaJTA2jI61b3AcDRaNTN0/kmEToACmvtsrO2x85qYwzYMTqdxCRx59tK qZGIIMuyaHRwOBCRPhFl65sbM2HB4cHBEoh6m9tbB7PJdPlgb3+ZmbvW2g+JyB8S0ZLU5mEBi+uI yLaI6GrRriFqV5O3W1hMrKe+LL4XAVi85u2rchdyr/2YMqUAEr/Y56wLp/7N4xf18ZN6uQOIkESJ n+tIQJZlyAufhhrpCOxQ19v1zpz8RlANO3jb7+6EvfD2WxH0wvXTLfmNbzwOE+y9PZJhHcNmBYrC YDKZIY4j7O7t4ur1y9jY2MTOzg7OnT2Lszs7WFtd9gTN/hDHzkIpn5kSJTGiKELlY3fOwRpD1lgk MWvr3LY19pyIXAdO/hts8fZoyfs+BRHh+Og4yfM86vd7ZnllpZ41OJ1OoixNFSmyAJSIdMsshymL 3wT4q0opJyKJs+68tQ7G+Ao2imITx8lLSqlpOk/10dHRUpZlTwP420qpf3Q8Ovo2AFhrfw5E//Vk PHFFnsdlWSbOV/PLAJ5sFuWqBbhqTmOYqxjcF1Lr2lXlzfXC4wks+LsRMkt8Kp6t5RIIA9WMRmY4 a4MlsCGV2pniHNj5Jh6E/GthgWhVDzQwxsAaC3YCrU72Uta7Vde9jIbM30n13Tiu32qrm3+vDh+N WCPh/VYLnyCNaggxs/iJ95aRFyWOxlNcv3aA11+/jI21dZw7ewbnzp3B5voGlpeXsDQYIkliv4dV 3KxrPntFXrfX2o9iY+b12Wz6yOHe/rX1rc1doreW21qcREve9wGmk0lsrVUiiACJqmJyNpslpiy1 MWXhnM0E6Ajz0nw+j8sy/xgRPaM8kXZI4JjdF5nd0+E2T1DWwhgDVLKKpdeQAAAgAElEQVSJiq5p pdM8z3WeZb/AzP85gC8BkCzLXgvE/Kgwfymdz0+6PRYkjBMLjKG6XrTo1R2AfiLAguQQCLp6/ILL xFXlrzRnF9Xim7iTRM3sq+5FeaTqtgQktIgTlI5QLZZSqLpBhNKUMM55gqaTenSdk117SU425Lxz 3G5bucUmJ+v+xU057IuS4FxZuJvFZ7WwE7hSYEqDyXiG/b0jXLlyHetrqzizvY2zZ8/gzM4ZrKws YdDvot/vozccIPIyiSdzIbADTGERRRYC+3ieya9Np9OraxvrB2hnXf5EaMn7AwxmRpam0fHRcacs y88Ky6MsnDRaLQkAyrPM5PncMnOPmdcAgIDPK6JnZeFU1loDZ21NcGVZwjmHsjDezSAEEsrzLOey LBVEHhORrwQC/a26yg1YJO3TGnZ1vwh7KWNhO0+ezXv00aVVFyTD3ULWcOwrZm/jW9wHDlW0X9Ss A5tCVV5NoWngSRshZY+0RoQYzAo68hNtrHPI8hzGWk/JFBws0lTwWCBu/3lXy5mnX+92eOsKPXyS gLzdwUBqJwqqY1Oj8i8srVbt8BHAgjy3yLJjHI3G2LtxgKuXr2NjcxMb6ytYX1/FxsYmNrc3MRwO kSSJr8hJwxQGOXKQzpF09EVSyVMAuu/wTbdYQEveHxCICKy1dQ+2AGSMUQf7Bz3n3GMi8vdZ+Jcr wjwBEojYBYL0p9GammoRgPfs2iZXvygKOOtQFDk0aTBzbKz5hdFolLDAgmgHaAi2Wuyr8qGblnS+ icSbKhuIFPnxXOCGiG/a1sslwlJr4t5R4rVkhAOHs1U3ZBANnK3176bxRkGcq6UawKfnqZDGV3ua QSfOFpxjP5jYei+4d674zks/HKEZRVY5uMM4Bh8fK5683144eWvNe9GdcrLePr1UWlkjfZiULEyb bw5wlY+c/bwd8sORdfC/M1uMp3PMpimu39jDoN/F6soytra2sL2zg9XVVQyXBlhZWcba+hpWV1fA A4bDDB1HUEoZAmzIz23xE6Al7w8AAnGrvRu7Q2vtqgAxRBLxRG4A/BGAXxARWuw2bB7PcM40Dg1m kPiKbBHVVJkKnrwtyryE1hplaVYB+h9VoqyQhoh0KsueDaTvGz48QRpjbiLr2u0hwRtCgBZVSxMu kO1pmcVr2I1VsHHIcL1gRqi2855tsDvhSFms/kmatngJw3y1VoiiqBlOIICtDgrO+inv1qHT6eDs 2TPIsxLj8QzpvECRFX4fAhGe1Lgb1wqkmq/zVlB4u8o7fGNveW+tebvGH9/cRyd+KtIAFNiR98WH xdWq+QhwMCVjYuZI5xlGozHefPMqOp0E/b73kJ89dwbnL5zH1tYW4sEEw5U1bG1tXewN+l9yzn1X KXVMLYm/Y7Tk/QFAWZbx/t7eZp7l2yLyX4nIh0WEiIjiOGYAHxaRzkknhgdRNe/QZ1dby0FeOOmy AOCr2gWSK8sS4hjG1MSvjLUrcSQgXb2Wt4mVZVk/V6WDLi4YLkooVRUMeM3VsoVfSAz5I66p5H0X YFRPVF98Lk/Mpu6IJCI/kix0/nE4CDSLoc3BQwGBkL2uTxBEkZ864+1wnrIK650V1pVw1qLb6+HS pUv43Gc/j0cf2cPe7gFeeuk1vPjDF09MeG8kk0prD1ffkeb99tuEpVeAwsFLbu7vbP4NLH7dN28n 0kgoTapJ/QoLNO8/39I4WJsiTXPv4CHgypUrePW117Cxvo61tTVsnLuIsxcu4oEHL22D8Fs6iqKH Hnn4H3W63TY29h2iJe/3MWaT6SBL0yVjjC6yfEsr9V9C5DdYZEXCCCtTlnWQUV1Vhsd7wnJ1njUB PqTIhtP/QMq6yrcQNN19ihABMMyYjY9xsL+Pq2+8gcFwgO0LF7Bz7hy6nS5MmcIUOSRUuJoY4Aim dBDnNfPaOx0OIipU1E2jDQdpB6Ej0leucRShk3TR6Xb8FBdjYK0LZxJ+QvvcOJSlqVveFZWIlINS hIL9foX40pNnAiEtz2v6BZgZSSeBczEgqGdViiwhSToYDIYYrg2wsrKCtbV1KO7BlYTda4fI5ll9 oKo1+5rydODKSjZ5N9fsCCT67TeT09KKLPzebESV/IRFcUcW70XlZmFvHgdc0PZLi1la4vBoiiS+ jrU3r2N17S/x4tZW8tAjDz/wkY8+9Tv5LL346Ief+MfD5aU/+9ne9/2BlrzfhxAA6WzWnxwfx1mW fYqIPhtp3SOiv8rMXalkAGa/aLag5S5qtrX+rRSi4Am2YuGUL8XYWljnwASw0l5GCc0XsYoBRZhl Kd58/XW88Od/jsl4jOWVFTz84Q/hE898Cg8/9DCstUjnM+R5DhGBXl0BoQffkelqDV37WVxgYxsr oPX3C3RNvhyG7SqlEUUxut0eBoNBLcPYsKDKzNA6gXMCZwW5yZHnBWKagxIHpTTEFr4j0DnYsoAt S19dMqNaEbXWwtnSnwGUDrbMgqZtkSQ9nD3zKJaX17CysgxmxtHoCFfefBGvvvIKXn7lFbzyysu4 fvUanGvWCqr2mROu77rYfffIm97x4ufNj7z1rdVC682u8ebn7RddrQhMYZAWJfI0xeHeLq688QYu v/6GOtw7PDebTH8LkPzxn/8w94fD53/Knb9v0JL3+wzCjKIooqODwyVjzENRFP1VpdRfr+YHlmVZ yxgVOVekrZQKEkPzx+XXpzSYq+5CgdYROp0OtNLeYWKqhhZXOzDiOIEpLfb3D/DSyy/jO9/5Tpix 2MNrV6+itBZgwdr6OtI0xWQygSKFbrcLZ8NE9gWJxCL4qI2XSACEYCMHUDU3spE/tPZdjb1eD/1+ v36vlYwiEtL3FCGOY4wnYxRFCesEWWbAXAa5BJ6MrXdSSJjG7iUWhufcCIqA0nj/t9Yag8EKNja2 8cSHPoRet490nuLFF1/EN/70G/jxj3+MNy+/iTzLURQFClPcotPxJG63qHhv4dZmxne+x83jLTuQ AzjPce36NaRlgXmWIk7i/6jb6+098qEnvh3FkbSNO7dHS97vI4gIyqLUh7v7Q2ftulLqD5RSv14t 2JVliTzPve8aOFFtV6RWxXs2fxTeBeHA8EU4I44JURQDHYGzFqYoUZYlZtMZyqJAp9OBjRwOD0d4 4403ce3adczTHJaBNM3x5utv4Pk/ew7EwOOPP4atrS10oti3SM9TzJKJ369Asouuk0V5gesEvyrY yS+ixkkS7GcJkjhGHEU+rjQsJC4uisZRjOFwiKWlJQx6A8zGu0hnRzCmADNgjKn1eK01mBnGAqUp AJCfOhMnXmd3Jbr9JWxvb+PChQvYWN+COI0XX/wx/uIvXsDzzz+PH/7oh5hOpii5hCZd77f/pFsi atqF/IQe6xyMOMzyDHleYDAcxFs725dW19ce2D539o12AfP2aMn7fYQ8zaLjw8MeO7cdxfH/DODT zByXZekrvKKodduKtP0C20niBppFyKoxRSnlh+lGFLRhquUHG/tqnkAokwRxnMBag1deeQXPP/88 Xn7pZRR5jlj7CNT5LMUPf/BDjI/H2N/fwzPPfBpbW1sACGVpYIzFYDCADUMMqotfiGwqbBfiRuN6 /JZCFEfodrro9XroJR0oEGzpD1aRUqFh0S+jaRB0kqDf7WLYH2DY6yNbG2I6OcLx8TFmsxnGx2M4 dv5shCIIXFiYHITPTYduQUGn28XO9g42NzcQxzH294/w/PPfwPPPfxs/+OEPcGPvBpy16MRdJG6h lmblkwkXtO77FZXkoklD4ODEQYeuy8PRAf78hRfo7PlzX3ro0UfV1tkzfw1AeZd3+Z5FS97vIySd xC2trOTj0ZEBcImZB1W1XRRFbcdbJOtKJqmkkkWrYHWbr1YTP/mcQy50uDALYhWj22EkcQJnDYgU JpMJxuMJrly+gt3DQxALIqVC2qognaW4dvUaet0uhoMhzp8/j/5ggLW1NQwHQwyGQxRleZNFT2sN pb3+HosgimIs9Yb12UIURWEOoz8oVa4Xpbxf2bEftgBq/OVRpKGJ0O10kMTr6PX66PaWMZ1OkHQG cM6h0+kiieMwcMAfhIh8LgnIa99KafQHA0ymGa5eeRnf/d738Gff+gu88cabOB4fwzGjkyQgRb41 Xhia9H1P2Cfh6VtpVXdv+sJBIzMF9kcHuL67uzSdzx7AO+9Yui/Rkvf7CCICa4yIiDGlMVVretXp WJFbdakq6sWskEWb4GLHI5Hy9jfdtIyz8yO9ovDH1e/1aj1dkcLScBmdTg8EBWYLhic7xw4kAlOU 2L2+i++88B1cv3YdW1tbOH/xgj+wxBGssz46tFpEVQpaK4AUlPZSTzfpYqk79PuLqlmmeUzT4EPQ OsxODPa7pqL3Nj+l/T/3JOlhbS1Bvz/EcLgCrTU6He9YKYoSRIBj9iO9TIk08yPFDvb3MZlMsX+w j9deew0vvfwyDvdGSNMMDg6KlB88UPr1AcAHYQGVka4l8Uo4qZuBwtqCdRbDwRBnzpzBzpmdyWAw eAnvrvXmA4eWvN8nKMsymo0ng8nR8TkR+UJeFiuns6i11kiSpCbuCieaT2qyphMSigsVUD3OKpC5 VgpxFCGOYiBUucYYKNJYW9/A6uoaekkXqZ3BMSOOYgh545gwYzweI8sy7O/vYW19HYeHhyiLEkop bG5vI0k6vuElKMNKKU/iUYROJ0E36UGRd5sg+MbrEVxoDkoMqf3cWntnjCfyJiSp6nAkpdGJEigV AVC1vz3Pc8xmMxSll5/G4wlGo0OMRiPs7e3hypWrODg4wPHxMY7Hx5jOpogp9jknQmBxYOugoEK6 oCcm/9mrlrxriB9eofx3Y9lBg/DAAw/iE5/8JD71qWd+fOHihf+TiN4u9/a+Rkve7xPMJtPB8Wj0 uLPurzjn/r6xprtI2tWiZPU7cLKyXqy4G5KuiH2R4IOtsIpJ1Tp01/mKN1IxLBxE/HzG0lgwV43e AmsdtPamMud8zkdeFMjzHIeHI4xGIyitcOmBB/Dgw49iOByCRWCsQVGWcMJg68AgRLGvnK1r/NcI IU8nHTNNuBURhTAr1E4bIq+Lz2YzCPkuT2stxuMxDg8PcXg4Chr4FPP5HNPpFOPxGHt7e9jb28dk MkFZFiiKsm4EAoBYJ3DOQlMg61M5Is1n2pJ2heqTYDBI/NRkIoXh0hBPfuRJfOHZL+x+6tPP/Nsz 5879q7u6o+8DtOR9j6MJa3KRte5ZZ+3ftdZ2AVDTpt0QV/WzwsmhAXQTcVfbR1F0MhDKs2TtBnHO +Q465xtaptMprl+7hhs3bmCWzxEHn7ifqgIfxkShkTsQamYtsqJAJ+7gwnnfJt3r9WCsRZqlcMww Re7dH8b4AQ9QSKLeTWcKi4R9Wg6q3CvV4i0ApGmKg4MDjI6OMJ3PMZtOce3adVy9egVXrlzF0dFR 0LUV0jQNrhM/kEGRl3PqtvpwoHKuyt+mxYbU5rOFz4ip/PEtGhBU3Tim4whr6+t4+JFH8PTHf+G/ P3/p4j9vLYJvj5a83wcYHRyuTI7Hj1hrH2bnhhRS6hDIum5fr5pu0FTX1SLm6XS8E4QnADuB1C3U 5KOt68wNQEPVmSKRipHNc+zt7iOb59CIQJpgnT/9VUEu4CBtKBAsOwwGQzz28GN48uc/go21DXST BJHS0IlCHEfodbuYpymmsxlKUwIi/jVV1VbvD1bez27qs42yNKAQqjQajXzminOYTCa4ceMGrl69 it3dXezt7WF0dIQ0y2CM8QMT8gxZnocWeP85VTMvq5hWIQIzLRwg/Ofk21H0AjGfJBxVDUN422S/ +wd1GJaOYNgCSmFzcwuPffgJbO1sI8uytdl01lldW53e7X2919GS9z0M5xym43F3OplsFUXxZefs FyEAhcCIk+l7tyaIW913ulIFagkZgFrIta5iQn0VWT02nc9x/fp17O7uIS9yNH+SVfofABAU6VC1 aiiKMOj3/VDblVUM+gNYY+GsAymCjmJ0kk7Qp4G8KMDCiKIYKkS0Al4KKcsS0+kUxhgURYHpdIrJ ZIzR6BBXr17FeDxGURSYTCa+2h6NkKYp0jSFsbaeEl9HyYY9VlAnz1zCgtrNn9dp3/Zbq9mtRbAB hbMWww6kFTa3tvDU0x/D5z73OTzxxBP/28bm5p90Op38bu/n+wEted/DEGY1nUyXyqL4srX2a9a5 xxR8VKssNH9UqKSFxUt1e/2cCyRUbyOh9ZmoJu5aoghDbyV0XjrrcHh4iJdeegl7e7soytzvh2BB 1mg6IX24v0CRgjUWR0dHuH7jOo6OjuBEQMpLOUmSIOokAIKjhAjOCawxyEyK+XyOPM+RpimOjo6a hcPjYxwcHGA8PsZ4fIy9vT3M5/PahVOUBRgMDT9U2FsRqznH5OcIn87pOJEB02SH3/wFvTM9uyXu W4CA9fV1fPQjH8UXn302/aUvPvsvz5w980/WNza+m3Q6rcvkHaAl73sbJMxL1trfsdb+vG8VV7W/ GTht97uZvG9XkZ8m9lB01wl3FPRuz9w+3S8OyX2j0QivvvoKRkejOimvXiyUhSEDEix3QS+31uLy 5cv4wQ9+gLNnz+KRxx9Dp9OpdghCPvGvKAtkee5dH4WBSU1YWPSX/f19HBwcYDqdYjqdYjQ6ArNF HEdI8xQAQStdB4Zo8ouujqsW/2BikCbZr/4MThzc3vbreUdfYosG1VlIknTx0EMP4zOf+czRpz/z 6T954kMf+jvdfm/aat3vHC1538MQgERkIH5iet2exiE4yVvyTpHwW5D3TYRd33/zaX1doYebVdjO OoPZfILdvRvI8wyKCEIEx9bb5Zp9rw8CTgQagHUWR8dHeOWVV3Du3Dmsrm2gN+gjzzKMJxMcHR1h MplgnmfIMn+ZTac4uHGA8XiM6XSKNE2RFzmcdbXf27kQZ+scBFSTNUgAXhieQF6Hp0YjCm/xdoRx eyK59VTKFu8UnSTBAw8+gKeefvpPz54797cPDw7U9pkdnXQ6rT3wHaIl73sbioUHIqJ9E8vNtr+K Qd5p1X0rn3dF4B5SF59ElY4NUBTI29paZ64WQxcH6MrCMxEpkFZQTFDadxpWsstfvvQSNrd2EMcx RkdHuH79Oq5evYrRaIQsz1C1/PvMcMA442dQcr2XUKKgWIV2fn9GwtLYBJ34lnQt3kKpSXsrIrxM dCvSbvXpO4MojrG6uopzF87lW2d2jvb39jdZJAPQkvc7REve9yjKouju7+0/WuTF48zcB3y2ByFI JerWFfWtSPv2FTeCNiBQvq0GwOmDQ0XgtHCgAJouRv+3pkInswJQ5QJS6KUR+IYZBYID43g6wV/+ 5UvIshwiwHQ6rZteirJE6LH3i4rSWPMUQmclmuYXJ83fOrvKmuf3pSJhgZxw5aigd9+KpE/c8hb2 vpbgfzasb2xga3sb/f7Adrpdt7m9dRzHsX37R7ao0JL3PYg8y7tHR6MHj0ajXzRl+VeYedtLBFRX lYRbVc8epxclgZsr82bbsA3dXHFW1wSVtg7EcYSlpSHW11cxHA6Q5inY2YYwZeEx1fODAKHgmCNY 63BwcIDJZAoWRmlKWGd9lewpOhw0AE3KNwBJ2D8BhKRO6yMQIh35BqGQmc3C9VlDTeDSTIKv96n5 FE69WwJ+AnJu23B+cmxvb2F7e/v1brf7HaWU9Pv91mHyE6Il73sQWZYOj0ZHH82L4iumKH6FiOI4 jqGjU1/XbSrsCrdriT/ZdRna0rFYWd/cDOMC+XV7HWxubuLcufPY3HgDx5NjZJkNVTj7oZMMAApC gWBJ1QuBijyBWmdhM3fCpldX+NVr1z7z0DEKaUic4KfVBzmJhOrqv3p89T5qMlcEYu3VaqmevVGv F/9/u8r8xOd7wqXyQabvn/79ycL/F9Hr9TAcDl+Mk+S5n2XP7me05H0PgplXjSk/UeTZr1lTqkhH iCPf8FHVhBQq07fTum9nGzwhjYS/zWbgMNXEJMywft4XtERIOh1sbG7g0gMP4NXXXsWN3eso8zxU 76rZP3hC5UCNDPFDjeFboisS1uQjV70c1Awe9s9Rtflz/edP5J0kRD7D3Imr42oXSaa2KYYDlBMG bCU9qcYRUz8OOE1Qp62Y9y/obT+LxfOWm29fONMLcltZlrDMY6X16F3c0fsKLXnfI1jsdrSm+Fg2 O/r1bHqslAJ1+kNEKoYSB2Gv6SoiQAVhgJq298X41+r6IqoOzPp1AZAIxDqQCu32oWJ2zLBgCAmE BE4sukpjuLWODz/1JK7t72Lv4AClMSjzAt1Y+3hWVFKJfw0CIULj+RYW+LRtqpuAFoSeW34+9a2C hWnnlX59yw90wa/tX83fzLegoZ+tar5f9G85FfJ36/ddHRb9f5GKEGmfjeOcBbODUjFKH11wLY6j V+/Evn8Q0ZL3PQIRwfHBcc/afHh8dPjRLMseS9MUSRKh2w3T3KsQKQgQyO9WBA3crIefjoJd2BBA sxjqtWRuJIuwDSEMZnAOcZLg4qVL+PgnPo5sPoctDV5/9VUURVHXsb6m9ZU1gLpdvlp4jFRUdzie rnwXa+Hm1nrvT913Wqu+eSu6ze2n7/9pKu37hbhvjVt9Xif7TpkZhRS+4PDCWC1pKaUyImrb4H9K tOR9r0BAeV5EZTHfyrP0bJEX3TxkS1e51NVEKKpq24VK+1YOk0VSX5RLbrkthfGyoTKV+vZKb26k GjCj3+/j4QcfQjqZweQlIqWwv7vnuyDzEqVxEHi7noK66QCySHpv6/o4dc/b1OZvs9VP/swtPN7Z 9yT1gdtPJ6oW2AmkFIQtLLtqSEjELDFae+BPhZa87xUQZDDsl5CCRUR8pdosplUVKpHyk2YIN8kk J55uQfNdXLi8lfe7GnmGsDApAr+4p7zH22ebABABia/SO0mCtdVVPPH44+gmCS5dvIgrb17G/t4e dvcOcXA4wtHxEWbpzA8GhvdZVwuRPrSqxfsLt1a0b73lyQM1geqMnF63h7X1daxvbHC323mP9vWD j5a87xEopbCyvlIw57tRFI21DjMnVeS16JAZrZSG1gruFhp3pWcvLlKerrTfqnFHgKCjV+TtLXuO fVeisF9sinQEBUIn6eDs2bPY2dnBkz//JK5cuYJXX34Fr772Bl599XW88sorKK+WyDmvrXpAOBgE 8m6r3XsfC8vAb3FfhWrpWGDZNvcGuS/udHDx0iV54onHpw888MDucGmptQj+lGjJ+x6DIjXRWs/9 DMoYWkdQOkYUJ4h0DIKfNLM4DqzyL1c/32muSbjiFycXBh34x6p6gVEBEJZaFzdlCbF+FNpwOEQc xYh1hCtXrmA6nyFNs3o02+105EWduSXw9wdOn9/ddo2AFDQpMCRE7DIcO0RxhJ2dM/jkM8/gk596 5v/d2dn57nu+0x9gtOR9j0FEOpWvu9PpIEkSJEmCuNPxw3CdD4k6rXXfzsu9qDXfLuvkhLeZTi6C ijDABBIFCXGsHMadRTpCWVhcvXIdP/j+9/HNb/4pvve972Nvdx/T6QxplqIwRa15NyPBvPTSSifv H3jr5q3I+qTpsjosM5pseSs+9ndtfQMf/ehH8cu/+iv4xKc+8S/X1tf+vzu0+x9ItOR9l5FlWf/4 6GgTEE2KclfmQ6XVymA4gNYacRyj2+0himJopb1tzzFoYdzZrQgcuLnT8nbb1duATkgb9XAH9tU3 SCGKVL2QeXx8jJdffhkvvPACnn/uOfzwRz/C0WgUxoV5bbuani4icGha6b3G/t58pi3efRDCVKSF evuk08f/X6sIogjGliAQOp0OulphZW0VTz75EfzSs1/IPvuLv/j3tre3/10URemdfycfHLTkfReR pWlyNDraGI/HHwfxrymlONISR7H+xPLKCpaGS36BUjVzJEkRtALq/FbghJ78VnJJdf+tflZ2wKpS Z/Yat0iTF6K1ggiQpSn29vbwwgsv4Fvf+ha+9/3v4fLly5hOpjUpV44DoDm9VnVzDE5kkrR4f+Ck 7n3am18ROIPZr+FsbmziwQcfwvLKCi5cuohPPvOpy5/9xc/9s/MXL/yvURRld3j3P3BoyfsuIpvP h/Pp+CPszNdZ3O9GUQwVx4jjqG4rEQac81NfQiiHr8ChbpqbuIhFp0klr9SShbq1da9qg68aXEQ4 ZJWEQcDGYHw8rqvtb37zm/jRj36Ew9EhHJx3lCjtp/KE566kkWqi+qLbZDF7pMW9j2Yp8vYnTcze mdTrdfHwQw/LLz37LD/+xOPfu3Dp4tVHHnv0uQuXLv13d26PP9hoyfsuwVkbidghwX1enPlrxhiJ lKJudxlRnKAsjR9wSwSlFQQuJPiFJT7yQVWnR3SdHs7gZz9GdTs5AO9iIapnUtadj25Bg2ZvCyQi mLJEmqa4ceMGfvjDH+K5557D899+HtevXQ+NOVRX1dZZv6h6QgFtckkqtKT9fsTb61yV7bQT+wyc jz31lP38Lz/7j9e3Nv8FcOs+gxY/HVryvoNYmH6jRvu7F+az6TlA+oAftnDzwiIB0pySvhOcXsiM 4xhRFJ0ImaoWkhan37BjJHHsydqYeiCviODw4ABvvPEGvvGNb+C5557D9evXcWPvBow1dUWtRNXO kds3TXu0Fff7E4I6Tv2mLlh/G8GJA4tfVGdmWGsTdq4XMulbrexdREvedxC2LNX48LDvxK3NZ9On rTG/6dh9wVoLUxbQ2k8uX3R/SFjjF4QpNeEuVQnLOOkwudWlImznXE3YVb51TfaKkKZ+/SiOInSS BHme49rVa/jzb38bzz33HL77ne/g6tWrKMoC1hk/sUap/5+9Nw2W5Myuw863ZGatr97a2+sVjWUA cjgzHG5DjihzOKJsUxPmH0dINDWUadljmUEGZfGHQjIVtoOiFA7KDMlBORTSD5sKy2aYMi3LVEgO kyGaDAyngUYD3QAaQDd6Q++v31ZbZn7Lvf7xfVlV76GBwQC9I78A+3QAACAASURBVE9Edb+l+nVV vcxTN+8995zJ49gdajyLmqwfb0yJ+/0+gbPuiuGqi5GXY7x35Yp47dXX0Gy1fvmpp48f33dg/z9Z WFk+/0Af+BMM8WEnXI17hzLP5XBrK8uHw2PWm18qyvIZT/67vffLeV4gz8doNptYPXgErU4HprRw niZ97crUB2BIKaLmejqcrKrtWZOqChV5z5pSVV8LdxMgz1ECGBZwtjY3ce7cObzy8km8/NLLeOud t7C5sQHv3A69QdXDnli1oiLqmqyfFATLYA4Fw+Rr0973Dq8ZEa7ACIROu4Nnn30WTx17Cseeeur6 M889++JTTz99a+/evXTo2JF/kGZZTeSfADV5PwAURSGHm1utfNB/npj+gnPm5/OiSB15OGcxHuco igKtVguHjzyFTqeHsjSw3qO6QA1VswcEQ0pMJHi7q+wPIu7dffGdXw/tGaUUvPe4feMmXjt1Ci++ +CJOv/oarl+7juFoAIChqm3O6g0h5u9MWiECANdtkScJ4fdbXQPu/PqspVjwvwmfEYIRWaPRRKvV wuLCIg6uHsSxp47h+PHj+Nz3f/F/OHTkyKk9e/dcWFhY+MMH+XyeFNTkfZ/ATLDGSgbrzc2NRt4f fkZ4/zPE/hecsyjLEp49jDUYjcYwxmJhYQEHVg+j2eigNBbWe4QgAgaRj658BCkBLdQ0vWYXgVeo 2iNVxT3bPpk+zrg5KRS2t7dx5coVnHr5JP7kxRdx5vQZbKyvAwB0fByVcRWBJ9XX9Aog+ndz3SZ5 0sA7Ot4V3v9bJoSBpJJqko7ECMdYI22gtzCP5eVlHDx2FJ/5rufxwz/8w3/4pS/98M93up230zR1 9TDzo6Mm73uMWM0Ka4y6vXar55074onabN1fhHVfJ/apc1Y4b8FMIcx3NAIArK4exMLCXkiZhaEh T71KglGVhxAEKQW00JPwhN0H/AdV2RVxVwqUqtIuS4P1Oxs4efIkvvnii3jjzOu4fvUqxuMxJAso KUHkYzNkWn9NKq+4bxOMh3jq513jicGUvHcvdt3lfnGJa7dVw0S6qiRElmB57x584fNfcH/mJ37i rT/15S//9JFjR99qNBq2JvCPhnpgeY8xGPTT4aDf8t53yrJ8ioh+lYgOwrkFsi7z3sF7B+ctiByK ooApCug0RaPRgFI66LrjgT4r+wu2rSKcHDNBDMAOJcuO26xEUAhRWXFCSok8z7G5uYl3372Aky+/ gldeeQVnz55Ff2sLiGG+BAITTUIPaFJzA4jywIq0q+ZJjU8rqhbcNHrO0/QqrzoyiEJu6bC4jOFw qIuieI6J/tmPEP3CsaeO/XGr1aqDiD8CavK+h9ja2tSD/nbDGPNniehnvfdd7/0PEFEK58DOwjoH Zy2sK+HJYTweYTQaowkBrYN6w7mKfGNVLWJHcSazsUpRn8XuKhvAxKwKCPruahNzNBrh3XffxZkz Z/DySy/j1dfOYP3OHQyHQwgKvW0pBKRQUEKAPVcLnbF9E4ZTEICPniVChL45e5psZtb4TvF+n75H Bbt1JrNyQbHjflP/GgkZW20xQiSGc2ilUZLD7bU1nHjpRMLM3+2c+zUm+jtPPX38X7Zarfv/hB5z 1OT9MTHOR9qYMgUjBXPKzFm/v90yxnyZmX+GPP073js458Kw0RO8c3DOxqrbwroCxo3BKAFOsL25 DpCEkg1IEpOAXSnCIJBAgOAQK0UIlq0AvPOT5HQxaW7EjUlHkFJCKQ0hgCIvcOvWLbzzzjs4efIk Xn31Vbx7/jzW72xMdNpKCAieOv6F9kh4M4GoRlfxTxYx/Dcibmh+OnA/nuejSdwB4i4f3e1eVbBH dU8502wL/1ILCRYK1lts3L6Dl791Amz9l2xe/qLNzaFnnnv2m5357qkPezSmyGHLUjKQEnGipDBC sAY4JaKetfbpvCg+5x0lSupBtzf3Und+4cQneQUeJdTk/R2AiGBMqZjZ97c31Tgff4GZvxdETQq3 lIi/5ok+y97D20DezjlY72GJQN6DnAFxCWfH8FQAwsGYEd67chHlcon53jLStA2tskCmUoAl4IkQ FB8M58JgEAIgCmv0YVMSACN4oQjEZZugHx/1B7h88RJOvnISJ06cwNmzZ3Hz5k0YU0Kjsh5CWI+P J5sH4HeKeqevB++swsDTfMlPT9X9Ycvi3ykeTYnldPnq2z+2WZ/K2QzR6jsUXypJDMUMEQfv2xtb ePlbL8GX7quucN9Dln73uc9+5h+15zqnq+Ue7z1cWUoA0hMtDDbXnxkNtg8Soe08Z2kiC61FIhUa 5N3ePM+/f3Or/xOm9Eh1emv1yNH/vibvTyGISBRFnqxv3O4S0QozZwC+Dua/XA0CvfdwzgvvPbxz IOcn5O18IHDyHuQNrMvhbA5rClhj4U2ODd+HMwLkFebnFdrtDEpKCBE9IzyD4cFCAixhvQUQSDtN UwCAtRaeCErKSX97NBphbW0N5985h1dOBuI+d+4chqNhVAZocBxIBnx86n30qOdB4ZM+80f3auXj Hg0fFJvGYHgfWilKKWidgJkxGo3w+huvA0KseE9/3lq777u+8N3/TXuu86aUsjRFkW3cvLmX2a8W RfGFwaD/58fj8Q9655UQClkjRdZIkCRKSMmxcBGspRJSyvdPWx9z1OT9ERAPrOb6xtoykTsM4DeY 6BARdbzz0loTidsF0o5GUkR+4h9Sfc9aC+8MnC/gnYGPbRVrCaYkDAYDzHXH6HYJMvaoOUaihRsA YiiEYZC1gcCrfrYAojqEUBQhpOTtt9/GSydO4PSrr+Hc+XO4eeMmxuPxtLXCDup9Vvs1atw/VIP2 6tyQUsGTx9rmGk69dkoUednt9/tfNbY89rnv+8IvzS30/pC8XxqPx/9hWeY/XxTFfL/fbw2Hg4SJ Rbs9F4b4kkEkIUSQtYI5fs3v8d7vnbWgeNxRk/dHwGDQ11tbG/PWlF9m5l8C8DkmSqpqG0QIbRIL ax28s3DeTQidojzPOYeyKEHegNjA+xLOGYCALMvQamZotlpIkgRpmkApBYoLOlW2ZNVLtM6FLMks g/cexhgIhJ9T+ZPcvn0bZ994Ey+dOIGTJ0/iyntXMBqPQI4mZO98MMCqUeNBQUCARWjFEBOsN5Ck obUGEWHQH+D1N96Q/X6/7bx9oSiLv//FH/y+v9Nut/4Vea+2t7f3jkajVp7nsNZACBmOfwl4cpBK QAiGFDMe9cxqPOrv3VpfW5pfWll/2K/BvUBN3h8AIhLb21tdJu/yIpfGlF8iov+Cib4fCP03Yy3Y e0iB2DZxcM7AWgNnLZzzYTjpfWihGIOyLMDsQXAwZgxnDbROMd/roTe3hGazi1a7jSRNASHgvIdn mkr0RLRZ5WivKoLCRM3EoW1ubuLSpUs4ffo0XvyjP8b5c+dw8/YtlKachiBE21bBoq66azxQcOXL I4MiJRTIDCYO8WkMjEZDnL9wHur3hSbvPiuAX3r2uWeOCiGtgPCmNCGOj8MVKhHBu+i6aTwAQqJV lN8GB83xaPDF9bWb32Dgd+YXli5IpR5rSWJN3neB906MhoP21ubGXoC+LIRYFMCfZqIfCb7aCMoR Y+C9g4z2qtaEA2pK3g7Ox5aKMXBFCeccIBneGxT5GNZZdDohLafb7aHRbCNrZhBShjcER6AQ2R7M qWJCTSJFCEugkC+vlIIxBnfu3JnYtr566hTePXceg+EAEECapJBCwloTlm5E8NmGkLW0r8YDBcfC QQgBLRWYo1maECFkWyhYa/Hu+fPQSoGJfmC4vXXo2FNHv9VqNpO80UCRj2FKAyEcnCNYm0AIho8L cM1mGq8wk7BTkbunt9bxc+RJa61/s93trSulHvZL8bFRk3cEM8N7J8j7pCjyzsbG2iEi+qKU8r9i 5mNMYVmFiCCIwd6DvIOzBkBoiThjA3nH6ntC4t7BlwbeWgAMCQFvHayxEFKg2Wii0+mg0WgiS7PQ LmGGdQ6ep34RzCLIr0iAxXQtnr3HcDTClStX8Nprr+HEiRM4/dpruH79evDlhgiZk9EaVgoZKm6p JhVPTds1HiR2h4UopcJciDzAgFIJhAxF0blz51CaAnkx3v+j7ss/dejQKogIo9EIGxvrMMaBWEJr BTDBOQMhBebn5wAQ5ufn4cnBlEZZ645CiK8niX5NCPEHrU53oNTjSYOP56O+T+hvbzaGw/4x59xT 3vvnhZC/DGAJiJd1PhB4lQRDRCBPYPJRwx103MaUMKZEWRawRQlrLQT5sI/IDA/A2AJEhHazhYX5 ecz3FtBsNKGTEOwbpFbxgcnK8CloA5VUIEeTiv/OnTt4++23ceLECbz88su4eOECRoMhKn/liqSt tSDy8BRSb6Ye4o/uYkiNJwtTL5wgNfXswZ4goaCEnKQ4VZJTnSiMyzHevfAuvHcwpsCzzz4D7x1u 376FjY0NjEZj9Ac5pACIwjmYNVIcPnwQgIdOFNJUw5OD816KPh+SQvwqQ/zKyr4Dv9ftLdiH+qJ8 TNTkHSGEgPOuY4z5C9ban2HmRpY1loUQsqpOKeq0wzEWddDkYcvQDrHWwjoTFnGcBdlwIFlnAO8g nA89bPKwtoRQQJqm6HS66Ha7UDKDShIkSQKpNJjUpJ0RFnTC8EUnCbSW2NrcCkqSl17Cyy+/jPPn z+POnTsoihyCQ1xapSiZOAgyRx9uNaPFnXjCPcTfQI1PAyqpIBFPPHqIaLJkNlkMi7sGpXUQCAP4 y5cvod/fwpkzr0GI4D9vbQnvGeOxAbMPhZNzaLYaGI0G2LNnESt7ljDX7UIKAc8QRVEkxFvPslA/ 1+0t9rs9/MHDfVU+Hj715O2clcPhZkbE0ph8gdgf8uSOOuvAzod1b6ZAzCZI+wCK7QaCAsODYIsx jAn97aIYYzgcwnuHROsgHTQGGgQJwJgiyJigUOQOw0EB8kCWJkiTFqRKw+aiIAgFEHlIAEomABjD 7T421zfxxutv4Jvf/CZeffVVXL96FYPBMMaQiUlEWrU8M62wEbYniSYLPTV113gYYKq8e+6+YVAV F9V2pjEGa7fXsL21FXcfgooLQoSltdhmCQotiytXruCtt5awd2UF7WMZGs0MAMMYI8bjfuq9+7IU sgnm1ZX9B/7pg332nxyfevIOvbPBsvfup53zh4n85yrjKFeU0R2NQgVtLbyzkXhjjBgAJQElBbyz yPMc49EI+XgcWhRpGqSCVLkCiqlFKwFFXqLfH2I8LtBsdgEogBVkPIZZRhtWCn317f42Ll28hFOv vIpTp07FLckbIBsOZFmZVXF14E99AKu4hDDtZ9QDyhoPC5Nk0x3H4bSMmI31mN3wDE6cxY5io0qa klE1pWS436A/wNUrV3H96jXs37OMLEvhnIlSXoIpzYK37sfA3CEimWWNE51e74JOkvLBvRIfH59q 8vbeybLMm0S0xzn/C8651YkXCRG8MwBClepsGE46ZydtCOcchACy2OoQQmA0GsUFGEBKhWKcQ2sN LRXgPYgZSuuQ80eAcx6j0Qibm5vodOaQJB1MKuRorUkQGI+HuHHzBs6dewenT5/GiW+9hMtXrqDf 74O8RyL1jniz6RJCZaU/PWF2Vjdisgpfo8aDwIeXDFPavttxOaV13vV1NZkJgUNbxlqPjfVNXL5y BUeOHEKz1YJxNpwjFMKyRzxUt2/d+IEiz1d7vaXfPvaZ535DJ8n1e/NM7y8+teRN5DEeD5pbW3cO Oee+yzknjDGhuq5SaxDc8SgqS7yvTKbC8o11IZrMSIlGowFmRlEUGI9G6Ha6aHfaGA6Hob+nBJRM 4L2HajbArGCsh7Ue/e0hbt1aw8LCMrrdZSgVlmcEBIQXGPa3ce7cOZw89QpOnnwZZ8+excb6FsZF DiaCFmrizT2L3ZegdyPuGjUeNew+Kj/IvXB6h8pQPvqvRJdLyx531oPl8TPHj2N5aQkyUdBaxytP DyKHPB8IZl6VQv6lIh//26zR2BRS5ORJAKzi/01SKqpcOR8FfGrJezjcTofDrTYRfcE593ettXsq HxLvffT6CH8zexBbELs4zY6abhssXjFjw1qWJQb9IbK0iSNLe9CbW8Dt27dh8gFYWFhPSGUDQqiw PECAdR7jcR59jkuIKJ0yxuDmzet45ZVX8M1vvohXX3sV165dwzjPoWQCLRQoSq6stWGoCUzyLaeH fN3RrvHo4sOPzo/gZMiV72U49okrJ0NgXFhcv3YL16/dxNGjxzC/MIckOmyGkJOw+mZMjsFwc+Hy ubN/+8gzn/mvW+327w021pY80ZIPwq6NTm9hszPXKwFBAPhhr9h/asmbiKz37itE9CtEtL/akCQK 1TSTB7yZ+JGEtkmolK01MMbAmkD0YMaYGUJIkCMMh0NkWQPzc3NotTrYWt/C0Fq0WwpaSrAQ0cYV ENDQSQapVTBZZYIxBba3+7h48QJOfOsETpz4E5x79xw2NzdB1kIKCU8ursvzzOWlgBZykmKy23l5 tpO4+4SpGyc1Hgamx+Hsn+/HtAm4u10y/TlVio+IxJ0oCecshv0Rblxfw/qdTXS6LSRawYNA3gIy LAU5V4jBwErv7Aue3N9ut9u/6KxJAaQ+WCHa7c2Nm+1u94873bn/q7e094IQ4qGeNp868g4mU9ud ohiDiI9675+v2iTVraq8JTmQN/A+bks6D2srMreTFor3QY3SbLSQpllIw7EeWifozfXgfehrNxod JEkGT8HeVekMnVYH3e4cllZWkGUNAMD169fx8ssv41vf+hOcOX0aN25cR1HkAAAVgxkIHOR+cmbZ AaFHDq4O8sqSc/pn9bec+awm7hoPA7OjSUw+5pnvVV+f/skfcMSG+0uA472FCIs+xPDO4c7tddy+ tYb9B1aQJhqeLDxZ6ETF0BGCMUYMvE2cLV5oZNkLWidQWoFZgpgh5ZYb9lsvlAsLx5n4t3qLK6dV khT359X59vg0krcYjfqLRTH+Ie/9D84OKMOWZUxq9w6KLLyvbg7O+4nqxDkHUOXxbYIta+LRajax ML+AVKfwjsAMKKXDEFMYLC2vgFkhSTPMzS1icWkF8wuL6HZ7cJ5w+cplnHrlFH7/938fr756Ksii ME1trzZ3KsMdGR0EKerBmcMCEd9FTfL+z2vUeDjYSdxi8rXd+GgO56HantyTK8WVgJQanggbG1u4 deM2xs8eRauZBb0sPMLSGwOK4SSByKIcO/hiDJ2mSJIUQih4BpiFtsZ8hoj2OeNaUulf684vnlf6 4dDop468ozf2nPf+6865nwzk7cJgksKA0nuCdxbeFXDOwBgHaxyMcTClgSktyBOEUKBI9olO4IxF ojWWFhYgpYYxBs45LC2tQEmNW7duodOdQ5q00ZvvYe++/VhYWIZOMhhjceXaRbx++jW8/NJLePPN N7G5uQEtwzCSKVT4QghoIaZLQ5G4Q5tkIsDCJN9yhuyraubRGbk8SaivX74TfLLYifdX3xJyR3oP s4BzPkpuJba3B7h96zYGW9tY6HWQNDQgJKTksE8hGFrJULi7sEntbZCECRnUYZ4YzloQ8bx3/i/q ZuOPoOR2p9vb1joxH/vpfEx8asg7tBZIMLMm8l3vXTLpc3s3qbyDh0kMUcjHcLaMfW4HU1qUhYEx FuQBJTWkVEikQqICWQNA1siQJg1Y60EEHFw9iHdXVrDZv40sbaLV6mJhfgmddhfGGFy7fhPXr9/A SydP4s03zuDa1asYjUeQEJN1di0lUq0BYnjygair/XkGFGRcKIrblLsO7tnP7z/NfHrjwWp8OKoC 4u65PHePbLp7l3tWgTK1j6D4eVCbEFTsgBdlifX1Tayvb2LPvhWkDR3iBZmCkoymMX9KS4A4Ksx8 KNIAeB++H9urQjeaf9kR719aLv/10sq+00JI9yCHmJ8a8rZlIftbd+Y82SNUjJ9R3nfJG0hvQN5B uupmIb2B8g7OMoSTkJ4gHCA9I2GEwaT0YDaAB4SSkJKgE4KQEknaRLPVgmxoDK1F2upCJgsY9hOM RgkWF5eRjxmn3zuLi5cu4sKFi7h+/Tru3LmDwWAAY0tIVpgOGgEiAUtAULjGdYR49FaHC/nZpO4Z cp/BB4d23auD7l7GglV4lMnxUX5sjx6mKu0P2y7YfQzNtleqjyWmOwwMhonf06iuLyuteDBgdriz vYUr12/iqeeeAQsFIgkZz2fBYftZCAWlBZy3KPMCriyhE40kySAAOEswVCJRXvbX/BfcuH8c5fiL kv1vLu45+IeIkW0PAp8a8iamzJTjz3ty/yV5fwBMx6KRcNCFEgGVyoQIgjkYOolgAVu5Clb3R+UV AgYkQ0odkm90ApVoQAoQA3lR4sbtTVy89B6uXr0FrZtYX+/DWoMbN27gyuUruHnrJobjYeijR4gd I8UPOpxn1a+847PqoP6ouPea73tF4I8yOT7Kj+3Rxvt9LD/oePmw13hGg8IzPg+Tun66ysMARvkY t27dxtbWNrpzDSgdyJ+inzhFd82QWBUW8JQOoSXTPc5wZW5NKbznpne+yYwfF0pbyOT8/OLKVaX1 A0k3+VSQtymLNB8NesS0SsQ/Tkwtjv4kFD2xmWnmF81g0MSW1ZjQKgkpOQ7euok3iJACCoCQClJp JGkGIROABcgTBv0+Tr/6Ol5//Qzee+8y+v1tNBqNoAcfDjAYDlCW5YRoPyjo9e6HsNjx8fuXGx42 uXzS/7/uIz+p+KhH+EfBrLXa7u/MptZba7G9vY319XXs3beIdppCiMABRGF2FYzgqh64hoh2sRTb KsHQTcI5D/YWxjMsoUdC/ThU+rOduYX/UWl952M/me8AnwryLotRYzzcepqIvkhEPLFzjX4j4e/p AJCZovOfQ1ka5EUJY0yUBfqJV0nIjAxtjCoFWwiJRKdQOsj+bt26jTNnXseFCxfR397CcDgCA2Fb E+EKSwoJGS1aa8KqUeOTgLHzOnVK3j7uYNxZu4OiOIJOpwkgOoVCAggBJeBQ+GilIIScRBoyixju oOB9tHcmB0cjsNSLWbv7c0T+twHU5H0PIRj8vcz8i2CWPEvenuDJTT+naojpJ8O/yTAz9pBZAHFF axKIIIQEQ4JIIE0b6HTn0R/kuHjpMi5duoTBYABAwFEgbAaghIZSauJJEhwBa9So8bFQ2WRObjvP Juc9trcHuHbtBrY2t9HttpAkYbVeKRlDIRIIDgWcEFV6FeCjX5DUahKWLGWYS1GwkxbW2jlmfmDR PE+4amw2bAACgGJAhDYJT2V2xLGqdjGQ14evCwGhFXQSwlGVDmSrlIJQEkJJQIZqW0oNKTWE0Gg0 Wuh05jAa5njn7FtYu30bzrsg4YtkX+VNVj7g3vtvM8SpUaPG3VEJYGe03gB2VOAiLNqMxmPcuHET a2t3MB4XsYIGmMXE0yhcRQcZMHkfCi2loXUSz3EFSAWhFHSaIssaoV2qdv//9xdPOHkLjAabc+NR v8fMmgN2JMhwJHCi0CrxccPSWoc8L0Kv2xOcJ3hHcJ4BhHdorRKoyU0hSRtxy7KJsjC4cuU9nD// Lgb9PsJW5LSKr+R8VbAwgBCS8AHduxo1anxU7G6dVAh+35tbW1hbu4MiL4NHkE7iOYlJFBtz7HNT kAQnSQqtUwipYps0FGFJkqLZbKHZbNk0zc4LIR6YnewT2zYhIuSjfjoe9VNnzVeZ+aeqtsgsgU9a KBzX4z2FwGDnUJZlbJswXLSAZSJopaG1glY6bDlqDaUTJEmKVrsDJuDKtat4/cwbWFtfg/UWSUyv mT2eJr7b4Y+4JfkoDBpr1HjCEPvYRIzRcIRbN9cwHI6xf79CmigUpUeSJMGrP/oChVYoAIS2qJDT ylqqcM43Gg002508bbTeaTVb/7eUov+gntITS94Ai9Go37a2/Aoxf52Ivlx5l0y2aKseNk8zKX01 lCSCjC0SpUKPyxoT1s6lmLRQpJRQiQ6/TKXQaDSR5xbvvPMOXj9zBmVRTGRLVZzZpH0SlwuqyKdq M7JGjRqfEIInPidT8ayAFAJlaXD79hoGg0FUmgHWWiSJnqpKhISUoQi05CGYgyZcAhAKWidI0gZa 7TY6c3NXm63u7/QWl/+F0rom70+CEJ5gFDO1mPkbTPSneVJ1B402QJiY4FSblTtCFgQWlpaQ6gRE QfK3wesoxjmElJBSBV137HsJqNBK0Sn62xt4++1zeO+9q+GyS6jQQ/eEyv3sbpLAmrhr1Pi4qLTY QJh1vf8eYdYUzsXt7W3cubOBwXAEqTpwMfLQe4KEhNDVXCrwCcXiSkkBrROkaQNpo4lGs5U3m81X unO9317es++8lPKB9TyfSPJ2zsjtzVtdcmYvmFKAwKBJm8KYchJlFv6mSTSZcxZlMUbWbGH18NPo 9XrQUmBt7Rbc229hNL4GT+EtOPTCMmRJC0SMdqsHwQqXL1/Fm2++A+sZiI5klVHlrM9fjRo17i3u fmaFNoiP4gQpJcbjAhcvXMHBgwfR7TyNVrMDIgulgmLM+lhpi5CSRQxASugkRdZshSFl1gCkPsdC /5FO0ut4wMOqJ5K8GRBEfj+AXwfw+dkKu/qYiKI7oJ/0uKvUdwig0+li374DmJvrQamwjLNx5w6G /QHY++hroqGkRqoTCKmQaI2bN2/h3fPvBu9tJiihoKQEE0/6bjVq1Lh/4Mmfs27fcSeZESyahzmu X7+BixcvYa7bRq/XRprJcK5HHYcQiNuVEkoISKWh0wayNEOaZdBpBp0kt9vd7uX5xeXxgw5neCLJ OxJkCuBZIdCZ/uJ4IhqsCLvy73bOwZgSRRHseTudDjrtLtrtNqQU6HZ6mJubR6vVQZnnE+lQmmbI Gk1oncJ7j/Pnz+Hs2TcxGPQnx0zlyPB+5WmNGjXuDaa+J9NzjCbfCwNIEYNMCMYZrK2t4dLFS1ha 7EHrg0jSDrROQSQAElBCxRZpMKBTSYoky5BmDeg0Q5qm3R4JogAAIABJREFUJ7JG43ezrHlKJ8kD l4g9cVJB54ws8oFmRsnM5n3SwPhxNZQEYp/bexhjURQFiAiNRiNYQZIEU/AFTrMm0jSLk2aNNE3R aDTQaLaQpCnu3FnHW2+/jUtXLqN0BlKImPzuo792jRo17j3Erht/wE3EoWVQjYxGwevk9u01lGU5 8f/WKtyUVLFI00jSNN4y6CRzWicX0qzxf/R6C/+63e5cexjP+okib+eMzEd9PRpu7WX2P8Kg5ix5 T7coaVcLxcM7GytxglISjawBQMN7wDkGRNBxp1kDSRJ+iWmjiazRRJplMNbi3LnzOHfuPLa2tyEh oKQAg+DZoTKrrFGjxr3E7oK3Oq9p5ns8+SsMMiWU0PCeMBgMsLGxhfG4CN5F3kMJiUQnUDpcXWuV QKug81Y6hVLaSqlOd7pz/7a3sHSl2e48oOe6E09U22Q82s7Gw+1FZvoqsf/7zNycarn9tOKOm1Qh eCF6dVsDIg+tNdrtNrrdLrKsBak0pCAkSROtZgftdhfkCK1mA61mE1nWBCCxtraO02fO4L33robJ tVBhg/5uY+8aNWrcY+yuuDHzsYyf8UQ8ABFkDKNxjs3NTWxvbWNpaR5pppG1GkjTNNhfqDDXElpD qgRSaieU2pBKv7ewtHKr0Wy5uz6cB4AngrwrvTYRNb33PwPgl5m5yURi1sekapX4qPeerKa74GUi pUS73cLC/Dzmej1opcM2FQS0StBsttHt9iAh0GqFwQUTY3NzG2+//Q7eOvsONjc3ASAm9oR3fyVi Oh/XtXeNGvcHs5ruuzmyVoQeWiaVi6gxFv3tPvr9QUzeiW2SKEIQKggTpE4gk4R1ml5K0sY/TbPs JSnV5sNMkH8iyBsA+v31LM9HLWZaZNBypd2mXbcqPacaUnryUFpCaw1mRpqm6HQ7aGQZrBdRWkRg SCRphmarDSkEms0GtJLY3NjChYsX8corp3Dz9k0YclDRIbAytxGCwVzTdo0a9xcz55iIVTdXZB5U I0LIkKBDBImg687zAnlehBzaoCCJS3hhi1JIDalTqCx7M8ma/0uz0/nniyt7bqdZNnw4zzPgsSdv IsJwuJWOx0PtrP1zYP4KxyEkdqzBx2BexIzKGH0mhECj2QiLPc4hTRNoHdI4Yj5DkPgJARXF+SBC mgQv4HGe4+KlS3j97JvIiwJaqpjxUG1MhrV3sEBw/q5Ro8b9Au/+6AOsgjheUzN5lKYMnvrEUCps YQqB4FekNYROIHX6tk6y32t3uv/P/MrKu61Oxz/Mqht4jMnbOSOdK5X3XoxGm/Pk/Y9B0M8x0/dx FOOH9JtgLsOeQ2SZZwgOgaVSiOgqSJBKQPjpQIMhwOygtJ60PKTQyNImyHlolWCcj/Heles4/drr WL+zBfYI7+a7JEo8cxzVqFHjfmBWzSUAnk2imk3cIRBCylQ4/wVKQ8gLD8gGGE1I3YJMMkAqQKas kuwdnWT/vNWZ+1dzC4sX2t3uA4s6+zA8tuRtypEaDddXmfEsyC+A6VcB/zQLD/Y8SVdnx2DHgAOE YwgHaCiIJAFAyIsSRTkOP9M4EEl4LwGhQVxAJ80QRmrC7ytJG3DWQwiNtVs3cOqV1/HqyTNQrOCI QVz9XuP6O1ei/3pwWaPGvYeoSqTJ5/iAK9ygQfHTolxIMGsYLzAsGCzaEGoOKpv3Mk2cZ7ZS6c0k afzvzU7nd3sry2c7vbn8ATypj4THjryjxE8wk2fGDzHzPwIg44By4gjGzAAxOBpNeXLBORAMlUiQ 4ejdGy6PjHEwxgJQYSIdPbe98+G9W4bLKSJCljXQ39rC2TffxNmzZ6OFJEct99SzZMZpAUBdedeo cX/wUc6sqc47fDYtprz3GI9GGA6HgVyE2BJCXMvS5JJO0zNJlr06v7J8rd3tPjLEDTyG5C2EwKB/ p1fkg4yIlph5buqRHW5Vr6KSCJK3sccdzdbhYZ2FtSaEJBDHRB2CrzKGGRBSQgjE4GFMXAY9WVy+ dBkvnzyJd95+B866ieJl5/o7zxhRhe/WqFHj4UJU7dJ4zjrnMBgMMBgMkCTJzbSRnZtfXvwX+w4c +D8hxFhKUSRJMhTy0Tp/HyvyZiYxHGz08nF/3jv7HzDwM+9bvqGps8HU6tWDyMF7B2YPYwpYV4I4 aL2d87DOwTmCVDF4gRiKGSrRsKUB+9gOYeD27TW88soreOONN7A92ILgqeVkNcSoVvF3Z7rXqFHj YUBMzkUpJARHAgfDeYc8z2Gds6vHDv29/asHXkob2aVmu/XeQ37QH4rHhryJPIq8n+XjrY5z7mvM /JeY+fOBvD2IOZo/xcujSilUETgTmD2IHYzJQeQhpQBZQllaOB/lREKBSMA5hkwwmTwTwoLP5tYm Xj9zBi+99BKuX7uO6qCYXI5VHuHgmXZJbUdVo8bDBwOxHTpbeTMxjDEoi4IF5O3e/PwJoeQDS8T5 uHgsyJu8E2U50qPhxpz3/svM/A1m/q7ZJBzmql0iQsuECJWHd6iwHRgOxA5Eoc1BPhC3MRZp1kKz 2UCWtZGmLYROCcP7ICfUSqMY57hy5Qq+deIE3n7nbQxHQ2il4P10+FwR9mxPrabuGjUeBczqUXZ+ XJYlbty4oU+fPPXTUsnG/PLieZ3ootloXGy2WrcexqP9dngsyNuYcTIc3Fkgou9h5r/LzIdm/UqY q0AFjstVPEmGJ/LgSdvEwpODEAxrLcbjEvm4hFIJlpf2YH5hBUnWQrPZBoSCgIBzFlKE5BxrLa5d u4bXX38d61sb8PAQ9P4hyGzFHT6vmyY1ajxcxLlTFTQc/fyVDMqU0WiEN998U2qtf+Ktd9/56vK+ Pby0tHT92LFj//D4M0//y1ar1U+SZKC1Hjy857ATjwV5E1Hivf9RZv51Zl5lZrnbw4DiULHSd1Nl +eoJnhw8hWR4Fw2oiiKHsR7NZgsLC3tw8OAxLC3vhVAJvBdQMsUOK1me/syNjQ240kIiXH6pXf5e u9UmO2VMNWrUeBioRIUVcc98A8YZXLh0Qayvr6tvvvwt1ey0sGdl5dBzzz331z/zwgu/cOzYMf7u z372N48cPfLrAOhhL+gAjwl5A0iismSVmd8n4pxsUVLUd3sP7yqJoN+1Hu9QFiEVPsta2Lv3APbt O4L5hT1oNDuh3+0RU6IZiU7grINxBkII9Ho9yOgLLISYtmtmMLkkE9MeeI0aNR4dSCEn8zDBIl5l O2xubQKDLbACrly5rC5evLh46tVXF48fP46rV6/+lR/7yo91n/vMZ37lYT9+4BEkb+eMLPNBymAw IwU4M2U+R0QKgGdmVfW4mWlC3IFIAVBFngyGByO0TKwtURY5rDWwltBotLFnzwEcPnIcCwt7IHUG ITIwS0hdtc+n79ACAmmWYXFxEa12C0orUNQVVu/os6gS4T9gO7dGjRoPCTtmUFEVFiIKYzHmGd55 2LKEHZfYWFvH9Svvob+5dbSZpD9+YO++f9xdmL8CAKYoe/l4vJik6Xar0954kM/jkSNv7y1Go80V Zvp3mblHxA0i0sz8NAA59eOe9eWOqIaVDAR9iAN5A2sKFHmOPB/HHrhEd66L5eW9WF7ag6zRhnEA IAGpIaJqZdYZUCqFNE3R7XbR7c5BKQ3nCsy2RGZ737OLOfXAskaNh41QRk0W5Xm6e3G3c1VJBWYJ IkKZj3EzH4JPeizPL+w7dGD1G4ePP/XmOB+7q5evHN5YX1/p9uY2jj/77KWFhQVut9tX253O2SRN 7iuZP1LkTeQFectCiH3M4r8DMD8NTKDJ37M2r9OUHEwUJJ5s7G87lKVBnufI8xxlaWLvOlTpSikI IYOyJGYlTH42M6SqfpnhFyqlRLPZxPz8PLRWKAre0e/ePZisSbtGjUcJ4i4f7TxPK8MqIcKCHvlg 1y2FxMbmBl78k28eI6a/cfDgIVy9ehWXLl7E9mCAbm8Ozz//PJ5++mkcPnz4//vMC8//1tHjT/1B s9m8ppPE3I8e+SNB3tXKez7eTsejzTZRsHSdbk7SpAKe/fruj9kzfBxKem+D7as1KMvgGmZKAyKC MR7WOFQGVI4YLCSklhBQUCQhiIDYNgmhCoCSEt1OB/v27kWaZaBhH1oqhGjpWlNSo8bjDgEBzx7w DAEJBkPLEHnoyOHKe5dx6+ZNNNIGbLSWpljFv/XGm2AhsLJn5Us/+qM/+r0/+ZM/+c3Pf+Hzf23/ oYNnldb3PLThkSBvIQSG/fX5ougLIvoKM/8aEXV2VtY7o8ym5M0xFSe84OQdfEXeZKdSQg8462CN RekYzBJKpQBUsH2VAlIqCKEgJIMY8H7a/mCEdflWu439+/ej2WyAQl++Xn2vUeMJwbT/PZX8WrJw pUOiErSyFtIkBRHBGotmq4l2uw2tQ4iDsQaNLEsAJPl4/H1bm1v/+d7VA39TAVv3+rE+VPL23qrR cGMODFuaceKd+ykA/wkRPUPVgg29PzyYY187/O0nniXwBKKwhOOcgfMG3nmAwnakKUMV3uwsoDvX Q6PRhpIJHAUnMqbgOubZT4agmOTehc+zLMO+ffvQbrVRWUzW5F2jxpMChhDBBVQrhfn5HpI0hTEl er0FvPDCC3jhhefRarauDYaDA0mailazCZ0km3O93j+BwG1AHDh09PD28WeeOTc3N3dLKXVfDK0e CnkbkytrS+Wd1fl4ew8zvgZgjpn/PWb+vilx06TX/f6qu+p7T5Nx4D3YO3hnYG0ZlCWmhClLmCK2 TTxhaXEZy0t70Wq2IYWOfiQK3jN8VKcAgNZJ+L8RhxlCINEae/buxdzcXEjMqdslNWo8WRAAMSNN FPbtP4Djx49DAFhaXsIP/NAPXfvhP/Xl/63Val0ty3KvENBKKSmlutNqt/+ZUnLNeb+v0Wz2s2bj zv18mA+UvJkZzhk5HG4lRTF6BuDnJXAAwN8EMD/tYb9/IFl9z3s/Ie/qfs45OOcAZwFrA3mXJUpT wBiD8XiMPM9BxOi0u9i37wAWF1eQJk1wTLgRUoWKOxpbCcETHbcQU9MpKRWWl5awML+ARKfwzj7I l7BGjRr3GQwRvIzAyJoNfPf3fBYHV1ev792379rTzz37/x579um/8W1+xIUH8TgfcOXN6PfXm8bk ywD+IzD+KoeQOQ0AdxtCzn7sozf3VN8diNv74AqI0gAuKE2MLWFtCWMMiryANQaNRhMH9q/iwP5V zPV6kErBE0NIGcxqiCEERZLeWU1LKcNijhSY6/XQm++hkWUY1eT9IagV7jUePwTv/pBvubm9BUiB o08d+6NnX3j+Hy7tWfnmpKX6kCG//V3uDaZ9aiJm+mvM/A0GpwASAGKq197d255W3NMAYb+jreK9 h3curL5HiWClNiFP8C4YUbXbbRxYXcXy8gra7Rak0iFbMlbWPMks20U6McNSyvByNZthSJEkyc47 3XVVhz/ge48S+B7eZiE+4a1GjQcLAQHr7OQK/MaNGzj/7ru4dWftz26sr39le3Mze8gPcYIHVnkz eTUY3FkgXyZS0CqAeWKG8/Q+suZIyIGEQ4gCwHEt3QeC9i56mBC8LWGKAsjHSAWgBGDGY3gCyDEg EngmGJeg29uDpNGChwALAisBLyw8O0AQpPJh14oBprD0o5QEBMN4A5kq6EaCxX0raM13cXtrDRkU qpyOWb+VnVT2qJPRvXxzuVfk+6i/ZjWeRGgpQWBYa0AgXLh8Ae9dvzp/8OihpUVafmAF77fDAyFv Z40cj7ezshj2iPzPgvmzDJooOSbtEQCYhAbzNOHGO4AcoBSIPawt4ayd2L66MmxRSlvAgeGYYIox itKhtITCEJxnWM/IWl1IpYP/d9AFgUTMtRNcLcnGBxY2d6QUIGZ4JgglkWQpFleW0e11wWDQzIZW iN7ZWYVOR5qPMhk9iuRdo8aDBQMIHdOQASDJYzjoYzDooyzLBjO3APQf7qMMeCDk7b1FPtpeZtBP EdE3mHlP6FsDgoNED1XmZExzR7wJRvAa8B4cHQKdMbA2ariJYI2BNw5MDt7lyIsSxhYYFyWK0sOR gvcCzpnQy676VYFtQ5Ud/CJ3LrsLEdspgYylDGY2aZZheWkJvV4vblh+0C7lNLX68cAnJdxaeVPj 8YZA3OIWFM9swLsgMzZlueKcOwzg5sN9lAH3nbyJfKXIWGWiXyGi3mx4QmhPBLvVUEkHr13yPt4I 5B3IOZAQ8M7ClRbOmIljoLUWtjSQXMAWA4xGOTwJsPBgQcHlhBjGFihNDiaCUKHVQR/INXElXkTT qdj3BoA0TbF3714sLCyEnEv6oJ9Ro0aNxw0U528qNkjKosB4NMI4z49aaz4H4CU8AhXZfSHvQMws GBD5aDsZD7fmwXQwanBCYMIkPCFU1DwziKxI2Tsb7V3DxiSiusSW5SQ82HsfI4xKsOvDmgFK6wCh ACFgvcW4sPBeYk5JWHIgfBDb3oXJYxtk0slmhpISi4uLmJubwyMwdK5Ro8Y9hkAs3JhRFjlGwwHy 4eiwNfazD/uxVbg/5E2k+lu3DpK3isgbIvcVZv5bzNye3Ce2hdlXVbaLyTcufhwUJOQdnDVwzoA5 JOAYEySA1lo4Z2DKEmVpUBRbAEokSRZW1yHATJBSot2dx4GDq0FlIuSut83dYQkzee9VKryIeoo4 VG232+h0u9A6AflaLlijxpOCyl1QQsAzwxQF8uEY49FozpbmkBDioVfdwP1rmwhr8kXnzNeFEIcB cYSZj+8IRSACPEGQmyzcMIe+dfAncbCmDCZTUfpH5GGtQVmGzcngzW1hYiVuSgshg7x+lBdwHmCZ YnllDw4dfgpPHX8OnW4HQu0ulysy56gXkbu61VWiTtz2BKPRaGC+10O73cag3ELd761R4/FH1DAg jsAgGXDGosjHKMZjtb21deD2jRvfv7Rnz6tKqYdatd1z8o4p7w1i1wX4K8z4nmqphiYSQB+HjR7C GRATvCeQsyDvQg87ugEaa0I/nIOOOw4OJsTunIN1NvbVBZwTyIsc28MRGAqLy3NYXT2MZ597HgdW D6HRbIbNyZnqejfpTr8aVCbVwg4TT4aYWZZhaWkJS0tLGGxs1dRdo8YTgolWKi7jeO9hTYkiz7G9 uXHk1o0b//Hi8vJfx5NE3t47YYqRHA022kT+BwF0ptuRgbhDq8MHfbe3YJuDI3lzdAQ01sKYAkUR 1tvJOzB7GFOiKAqURR4GlnFVnqKRFBGjyD3ywkAnTTRbHezdu4pDh49g3/79aLXakDIBIECVwiRK BHfK26K5t8B0Xb4yaVcK5Hwg7+VlLC0t4dK5dz/kVXkkrrBq1KjxEREKNAJFG2gmhnMexhQYDgd7 t7a2vjYej36j050bSikfmlzhnpK3KUZ61F/vADgO5p9n0CFmRNvW6So7eQqyP+9BzgZyp6AqqQi+ LC2K6MPtrIGzoQo3ZYmiLOCsCZLCKocOAJGCdRLNdg9Hjh7Fyt592LPvAFYPHUGr1YUnhtYKRDMV 92y5XLkXYmpEhUlDpep9CyilwMyY7/WwsLCw4zWoNkXFJKGjov26Lq9R47EAz0zBhIBgDrM56+GM wWCwlV27fPErh596eqvVaq8J+XD2du5t24ThmOh7idw/JmdXnXfSexsJTcAZC0BjrjMHKTJ4ctAp AMEoSwNTFjBliXw8Ag8HEEkTKi2xtbWBYZmjkbWxOL8n2L2aoEQpigIbG+tw3mFpYT/27FnF8p4V 7F9dxfzCEpqtNtJGAyxSCKHgWAUlymQfspqcVsQ93ZCUQiJJFJxzYDC01sGoSoaw0vmFBRw6dAhC SbD3IFDQh88mdsxIDWvUqPHoI1x3R36goC6Dd9BSoJVlYFMuvnfh3b+VaH39wJGj/6bZ6tyXpJxv h3vc8+Y2eXuM2B+VUgoFEXdtgluf9w5KKmRZA53WPIQEROIhBIJ6xFk4a1EWBXr5CM67OCzYi9Lk 0FqjmTUmPXHnHMbjMdbX18DMWFxYxd6VQ6GdsbyMRrsNIdVEnYjKvyQu4Ox4i62ewYRpQ68LsecF hDAGIoISElprdDsdzPXmQt6dr/6H3b/EKlOzjkWrUeNxQ9Xydc6BPUEKQICVNcWBtds3/luh5JGV vft/Z25+8YEv7twz8i7Go2w86O+31u1jeC8l6WDZWvW5HUzpobUAeUKSJtBZA967cGmSOiQJgRuM ZtOh2zWTISeYIODhPUErFaxe4zBzPB6j21mCUgqNtIduZxHd7gIazS4SnUZJOUOCQby7DbLbTGlm 87Ja2RciPIbQlwnsLgGdJGi32+h2utCJhrMWUoTLJ+aZBB4GGATx4DzAatSo8QlQXT1zNMlzUUQR bDoIUkgQA4Pt7c8rpf4zraTTWv9WqzM3fpCP856Qd5nnari12c3Hgy8QuS958oK5BMHDGoPSGFhj YS0j8QJFWcBYB5VIeJ9CCAFiBSDoqVMNsPZRJB82naRgWGMBIaDUGELkAApQloI7KdIkAXMCiATE Cs4LCBc2KBlhJV5UH0+0JozKS2pK62FdPn440/vGdLFIBgF/o9FAt9tFs9lEkefh/8C07w3MNmLq vkmNGo8HBIJgMOTm0kRoYQGE6pvB8M4gz4ef3dq4/bMQXC7xgT9qt+cuiAc0xPyOyDs4/nnFRIKr PUli2V+/0zbl+Flm+hoR/fvkHUpbgChotK21cNaBSQEMOGthigKJboBkEoeO4V2uetkAgIWAkAIM giMPEqFStuTDMLMo4JyDVAo6TUBeg4UCsQB5wCsGpAxiTTF9DhDhxqhMpDBD4hWFy/BLEgIKkXoF QJim+2it0el00Ov1sLW1GX/WrEJ8+h5eo0aNxwEMxDlVCGqp1HIOnly4io4icKkAZ0tsb238UFkW x4ti/D+vHn76f2q1u+elVOX9fqTfceWd9+8smHw8RySISBgibnvnmkz0V5noz1VeJGAP8uFSI0j9 CFolaDUayJIshHwSB48R5mgAFfTgXoRhIVH0kArb9mBWYCaY0mM0KjAejyEgkGoNJRLIJIPSKaRW gBRgGchfxPj36g0CMwtSH24ohYnWs9KGV1U4M0Mphe5cF8vLy3jvvSsgG3rjM3qVKDuSdeFdo8Zj ghAqPj13hYi5AtG+OjIAAA9nCWWRYzgaLOVF/p96744dPPLM32t35k8JIawQwt+vYeZ3RN4CgPdu zlrzV4jEV8kLJmJJRJLIHfbkGs5ZOHJw3qIsi7gF6eA90GomaDQaaLVaSNMUQkgQS5APlbFgGUyj RBgOcuwvh69PhwemJOQji/HQQCkF3c7gvYJKJVQiIWX06uY4qhRi+i4gKDoIRjdBvJ/ARSyziT2I q6SdQMZSiGBGxYwkTTE/v4ADBw7g9dNnUFj3vtdLxFZKTd41ajw+CLoFAakEwHG5MG55CxEu6OHd ZD7mDMn+1mbPWvNnRqPRC735hRNLS3v+16U9B//N/XqMH5m8mRnD4WajLPN5Iv+M9+Lz3gMU7Vo9 BZ8R7w2cL2F9jjwfR2WIg/cMrTJIKZGmKbROYkXsIWSQ30EGwg2pNQB5DylFeOeLunAmB608tPaQ ykFKgpAGDIm0kaHZzpCmGjoRELFdIgRH8iYEC8D43il2FOERYmpkgonJVhxCAhCBwClW3r3eHFZX V5H+/+y9abAkV3Ye9p1zby61vqp6S7/e0Y1Go7GDGACDhRxOaCjSokI2FWbYosIOSXQowg6HZYep sBUKyWExZDNC/kE7FFpoSbYlkZZJWaLssDUR5MgWV2kGs2CGxAwwxDZYutH7W2vJvPce/7j3ZmXV e91oDBrdr+E6Mw/9Xi1ZWVWZ3z35ne98J00xHu8dEl3pROtzGhaxiEUc4JhN55w4lMagLHwHOCBQ DFhxfkCM8vx4YSbY3iq6w+FOd3Pj6pGd7a37J0Xx/OEj9/0cMe+hUTY2Nmg0Gp00xtznnFsCIEQk zHyh3++/3mq1Nm62lx8K3sYUNClGWpyj3d3NTEz5I+LcGecAZwFj4qpkUJoiAHiJ0hYoyiJwRRZl 6a1biRlJkkBrDSsEwAJRjUHifw/FRcCgynaVwDkP1nmm0WpmcHbiDdOVg0gBnQBZI4FSHrhFDCqK O8gERRyEVEjEI6ij3m7puS4SMKnKHjKCd33iDwFoNptYW11Flk2nI1WV6nsOrW/H/i6MAhZxr0es UjmIEExQnESfJd8DQhUGEAMKDC0OpZXAOJiloih+cDwZn7Oir+R54+udTvf38zzbstbRxsb1+y9d vvzI7s7uC2VZPGid6/ordXZJmrxsrf1VIvpqs9m8IXd+U/A2ptDD3c18d3fjiDh5RES0WPPvWVs+ Ym3UP9bmR5oJTDmBsQWMK3zjirGwxn8IxApKa89JK4IYB+sIzk0lexKKhuLEjzEL424YCiIMECHJ mmh3BMQaRVF6FZ8I/D4ZAKr6+AUAubgY0LQbPoZErXetPT60y7MisEwdCKuZmhV3TsjyHEv9PlSS QCjKEqesWDSz+mQ6dW4nSC4AdxGL8BEEDeFcB8hbdpQFbJQBEzw9C8+FA4BiHS7wS5iywGjHwFk7 2B26/7rV7v728WPH/tlgMPhWURTqwvvv/9D29vYfn4zHTxljmgCq+pwz6fFrV6RIE73dbDa/daO9 vCl4D7c3OsPdjePOmh8XY/+yOFEjs50YVwLWwZTeIMoVfkyZtSVs4bsfi9J5O8XCYGIcdNZA1uiC 0wxGM0RZWBHAKZACBL7Yh2i9ChtuBywJHBGQpl5nqRSaSYKk1cJkMsZ4PPFt80ZAwwJZliHPU2it AXjPk+hRooj3yrvrwFX9Kn6yfCxQYrZwKQSwUsjbLbSWe+BGipIEDL/URLmgczG7P8jA/UlsbxGL uPfCu5r42QEAwwqgoDAaFhiNDYQYNhQr0zSDMxblpIQ473vE8DSLSOkngI0NbQwnAzvu/9H3y+EX rn/QelexflOcy3kyelxGuw1nSi+K0wqAiDF8pqQ/koKiAAAgAElEQVTi3zeTpZG19jvMXO5X9NwD 3nWNshOnjTE/Ycriz5mibDprUUgJBws4B2scytLAlSWcMRBbwhqL0ljsjibQKoHSGRoJI2u00Wq2 wDrxq5kVOPH67akPSF1vHToSY5YbbyOq2tSV0kiSBGmaeTlibcJ8HJNWf9PMXHU5RoVL7VurUvKY JEt4vSgnJKKZfQH8F9ZqtdBut6GUhpQGYAKD4aqse9pyf3tiAdyLWMQnFVT9Z3rqOueHpRvrQkLm pnUwxMcGnGAGswJg4ZylophgPBnq4TBpQ3AmSdKTSjGYKVdMJOwpY+u9ncg6S9a5w9mVSy/keePx 5UNHXyYiO7+fe8DbWUO729capTErk/Hu2bIsHimLYtmWBs5YjMwY1hmQALYsMZlMUI4nsMZAQgeS sw7iCDrPkDdbSPImGs02ut0B0iSHOKra1f27xgzI3gxKfDGTa5I9D+DOOYzGI5ShYzNqsePjeR/z mJmP/hZwdb+HaK3R7XaxvLyMJEkwKUsgZulSX5TqroUfJ+41Hn0Ri7j3wuMLVcNYqk7x0sA5L7Bw oeO6uhoPvyulAOjKSdU6g7IsMB4PAZEkz22SJpkXZ7CnZ10wvyrLAkVZwlqnNtONx9vd3r+zfOjo KwA+HLxFRA13t06OJ5M/Y0zxkDXmIWctCIBSDDIMkPKgqACtMlgtECGA/GUDEyEDo9XqoNnuIGu0 kDfbaHf7SLMGiDQADi3jkcO4ObDFD2b+93omLgB0AO94343A+5a0lx+Ck1HrvbS0hPX1dWRp6k21 4v7RPhn+IhaxiHso/LlrjQtd4mWtL2V6RR4v0Im8jSzg3UudODAriPOWsgjyZY98Ug2iQTWQxqvb SlNiNBytbW9vP7+9eT1rd3tjvyhMYwa8rTU8Ge92jbGnjCn/hDX2eAQonSooIjhFMOKgKOgfy6af 3l6WIBEoxdCsIKSRZnn4aSBvttFotKGSDE4Y1SAE2bOg7P8RzlEW0Syqfn+SJEhSn4XXP9gI3FKj YD4UvONrfQiAK6XQbrVw+PBhNBoNXN+47gc47Lv5hRJjEYs46BFp0zpEGGu9zUfp5y8wB7SuJZI+ fGMgxz5xESSaoVjgxKAsPX2baJ8AW+dHPnp62Pe4sPIijkkx1ttbm0euXbn8ZKPZ/rJSalzfzwq8 nTVqMtxubm9eOeqcfcRn/wwiBa0U0kR79zzFKF3QNwKAEz/ZvZada6Ug8DI7IQWwBikNVhpEOvDI oW38FsEbwEzmPc+DVx9oAOvId9cpljqo364gIuR5A0ePHkWn04G6ECrQbmpvUNlLYgHdi1jEvRDz OBEHnU/Bm2ewa+Zqv3aWCwRKAay88sw5P5O3LLVXq1gLcS5ghgkSZcDCUyi7w53l3d2dP+2cewPA e/V9qsB7uLO5srt1bdmJO8eKfybldAUAmPyOamYwcZUBW+fgyA/pZKXBoSPS8z8MEHvuxjlklCAX 8q5+IiBihC6c8AY/GqjN0ycRpP3gB3tTgL7lVtWqUPnhYJ9mKY4ePYpev49EJ57/r3PdsQJymxeO RSxiEbc/poKJaUTwLsoy0CMcKJB4dS+hPyTy34CT6RZFLEQ8T86WUJYTaFYhyYTv0rSl326gW50z MJOiOxoOP2et6cpcll/PvBumLP9NKP5pxWoNzDQ/htevEGHDgbbQrKpp7NYKTABP6wjj8RikNJKs AaVixj3th4m9jrcCp/M7Xl/pIqdtxe3B2nnFyfzzb/Z6txpJkuDw4cMYDPrI8wZGu7v+EqhWkF0U GhexiHsnfP7M1V9WDMqQefur6pomjth3iCOyAhbO2VDOY89pB7YB8FSJMQWEvFcTMyN6aPhfGSkI AgWdaLbWLl+++MHJQ4ePvtGoNe3UOG8yIPSI6IHYTh5lciKAuKlo3Trns0sRCDuI0hDnUAaNt7UW xhEmRYG80USiNbIs9/MfvUcrXKzOxh6ZfWiQ+Pt+FEmdOom/MzFIESof8Np9MUP/JExitNZYXl5G p91BlqUoxiOUxu4pVC4ok0Us4uCH73QMWXSUCsLBWANrTBieLjPn8/TxAmOlomijKV6838LP3C1N CQsDCKC1AnvpILTWIKUAMJiSkPiqZLSze9Ya8xKAKXiLCCbjYV6U48yJEzHOb4xUtQMiDhJIdWN8 91AF3srCOd+Gbq1BYUsUkxLGOhSlAWuN0ng7RRYNIQHEhS7FUPi8BVibz7zn73POgdWU3440zn7P +2i894c32DARms0mVtfW0Gw2sblx3a/bM8MZFuC9iEXcCxFVcE4cBOQ7Jx2jLA3G44nHFGagqqsp EPygYg/s3mLD1zMFYg0cExgKHBNiayvmwRgHsgQXZBwJ52g2Gmg02tBpDidKlWX59Ob1jdeV0l9p tJqXgZB57+5stoaj7cdKWz7ojAVzo9JKO2fhxMGUBkwCUxRh+K/1XtviUIZBM0IAmOBI4GDhwsT3 nd1t5DtNtNqeYvDP85cVxGn1odUz6fnsO65qN8qiIw8//5wbAfdNATx8wLdK5wh89n306FG0Wm0Y a6HAMwvIoly5iEUc/BAEO2o4bzwFBWIFdgqTicFwOIJz4u064AfGeAkfwTgXANsnpCKAsw4OvhBJ OvNA7ygwBYFFcBalMTDWolQKDSF02l102i0kaRPDUanHhXnu8sVLY6319gx4AzDWuh81pfljCFms B2/rRebBlMU7gzhQ8MYmERA8b+MkTgnz0sJ4yUEElGWB0WgEpTSAJpI08W+Y9oLozTLs/YC44r6n D7rlL+p2UihKKfR7PTRbTcQRDNbZPd2ji1jEIg5yTMexUDC7EBEP5i6OQ/O0R6K5pmYLognlNd1A raFQKTBrMMJjieaoGY9jJrAZZVmimPjiqE4clFLMZE87Zy9b59binlactzinnTjNiPK6KR3hnIN1 FhwKbxHEPRx5cbkxzg9PAENrBUCBiCGhTXwy9gOElVbB8CmAO5Lpx/YJ8NF3ImJX1draGrqdDqKR e9Uev4hFLOLeCZnCNxAkxvCNOkUR5vEWJRKVVPcTTRsBxTHY+r+11nCKoVj7rFtmFwcmqkaHRebA GYOd7W0QKYwnJYgTAhSxSraYaScmvHrj2sVmWUxSEBGT12hrHTSIEbyltkIIQOK8xlHY74x1sKWB CEEpgtIaRAylEkAYHAqatvTT4ZWKAnYCJWrPCnRPBYWvgRnLKyvodDqe6w5UebSGXXRZLmIRBz/8 aespzjho2CdhEoaoF97oLkoBjYXAgSmBUr670rHyoxlF+6ZGWDB54A6TYAAhSMzYicA69f0p4t1a J5MJzPXr2NkdQ6c5mo02Ot3e5dFotLWxsaF7vZ7R49Fu5pz9KQKeYfYZpFIKzAQbhiGwRO5YIAgT 1IONq5BAgp8JQIDyje/EHrQZsXLqx545Y2GK6P/BcCrbw0/fKwBeb4MHgG63i263iyRJYIKYf0qb LDjvRSziXghvSBdojUpswLDGYjIpAEHVV2LF212DXaCCQ98JMRwpMAQsXhftZdbwAC4EOAkAzlDM wePEt88bG+iT0oJGYzgL5I3mo5Px6LPD4fCNXq93kQGkgPykiDwRq6NAHDhQ1zMGb20XWkIDHokT OBsfHx4unvPVrKCTxGfiwQvAGgNnvLGVn1MZFS2yh/++VyIuPM1mE/1+H81mE9H/YL7jahGLWMRB j3qbTlCvQcEYg/F4XNX1mILGG1FZMn1qxE/nBOTYm/F5C5PqsfGHAl76bbHvUteeASFGGOJeoJxM nizL8ocD700acB3xASeuKlICgA1Kk4o+sZ73JscgYUDIA7fznTe+68j35bMFOFFQpMKlRxhlZgws KyQ6gVa64nnqbewzH+OtepHczQiuiI08x8rKCvr9HjY3rmOaaR/gfV/EIhYxF5EBiH9546miLDEc DmGMBTNDaS8PFJ429MxYajsH4yyYdZAORilDCCGQ8DTJIxWyfAEzQbFCAoZNCEmiAQKctblzrg8A LCItEVHx0j4CtbW2mpZcvZY4PyA4yuicQLy1dyDfGQD5TksLiPMGLYoUFBTgCKawVcUWMn29ezn7 9v4FCnmeY21tDYPBcrV2V6OS7uYOLmIRi/gIEaV+dddAQlEU2B3uoiyLQJmyN+1TOvh3++cSKRD5 v8W5sC3fnBg7N/3/qMremTW01iHb5iCC0MjzHO12G61WE2maAESJONdwzgVvVoA8TzOrmwamGTEz wVV2H2GlCR2Xfqe8iRWEA5iHDiOoMATBq1GcMTACGKWhVQKptZXW48AULz+kRycy2UoppGmKfr+P paVuuK9eqPzwZp9FLOIgxker1tz65NZ7gU7057DHulJKjMdjlKWX9CE261Dw7heAxGNBkmgYo2As e2EH4tlPlaDBe4XHrDvIrJmRJolvDtIp0qwBpdPKP4oAHo3H+fnz5w9pZh6Js5YCqc4KgLNg8uJy Z4z3pIUf/ivMEKUBWFhTojQGDgKlGSqMMxOxKC1hXACsgSzLobWCMQ6m9N4nhSmhTAmdebVizMDn VSe3TpvEVtbbA5DzLfs3ftXoO+X3u9/vY3l5ubYdwfRi6XYerLdmmnVrsbg2WMSNIwKP853eN3mc YL8Kz35HVrjOP4AAPn0PseYnYgMfDZjSYrg7AUkCga4AOcoJFSuIWBhnYQkgpSB2Mm0OBEPYO6wy +QKngVeYKPLD2RkE57wCJcvbyPIGBAQn8j4p/mqeZW90Op0dzUTbwoF2FwTNdgmlQ/YcZlNCvGmK U1ytRFa8NpGYQDXbQ2IL54DCjMElgRNCmuRgjTBIGDDOojAGOpuCtHNu34k3H+WDv1XW5aNk9eIF 6R/2IDgRdLpd9Ho9b9Yl8xPkb9eBKnP/3o44aCfRIg5SVKnCDQ6T6FHk04C9nj7zT7P3wFUoEaCI IM7CYeog6AedE5xjxJG4DhKfALFBhQL4zNxO4iMABEUKM1glACvPhwfJMTip+HNWGZK0uZPnzd8U 0MjY8p281frSYHn59aWlpbEGMCLi31dKPWiZV40pYa1Blnm5YMyEY1ZMwRZ26uanQIzKLtbLXvwU ZSdAMSnApMBQSNIMmVKw1k9cNqUJq9tUIjjvR/LRqBOK///4XxzgZTwSbW6BOljOXhn4yx5mRrPR QKvVRpqmKIpitmaATwIiP+4WD/5JtIi7HwT4Jr3a4Sa4eSYeH1Pfhr/tIB9zU0tXRV75YcRbfRAx ms0m2u22rwk6BRYOskL/r2+6YSilwcbCUQkKAO1iy3nFcxNYKSDy40ClOIEiKKUmSqlXkiT92TTP LwpJo91dut5dWhoDgFZKGwA/q7S2XJZ/xk5M09gSoARZmiAOFrDWel+SwM9E8FYqgPfMqDGP3KY0 VcunUgnSNIdOUhAMxqXxw4udVFXdetHyIHDe8XKRUPvPfi39laif0G630e/30Gg0UJallwFF862D fMwuYhEfEkJ1AJ4F7tmKzhTl5ys998L1XWysgwDkfBatlUav28XRI0exsrKCLMt8cgtPp9QJAw/M KmTdvsUecPUXqHSFFLLweHNMkP3CoS4rpX4zzfO3ltfXr+gkkRk/76XlwzvbG1dKZ80vKcW5gP4D 3/4pUH6RmFGBxK8kAnf0oiWmCoSZCcaKt4Y1vhOzTA2McVDaP1+cwJGdoUri69Q9uA8CgM8fgvPD IKrPhwiNRhO9Xh+dTgfb29s1znsK8otYxKcp6ke07HPb/H0HO8SPMKMpE8BgHD96HOcePIunn3kG J0+e9FfW5cj7dkOCgZ8N3ZcuWH/4Rh6xwZ4aNSZDHGwwhGJYr1AJGXqcPk+gQut0Y/nQoe0kTd08 FmqtU9fuDiYEvFFOirdVkLyY0qJgA8WhGwiYmZZM5L1nAfhiHeJOe4iytYk2TgRlaVAUBZi97huh eWU/X+55/vtOA/gMxN7ktete43G/0zRBv9/D8vIyLly44AE7Zu33oAxyEYuYj3rWvZfd9umK/2+8 lapz6qCfAYEErTDHhaz7zJkzePEHfxCPPPIwer2eTzDZT7txznmGwcjMJC9B8D0Jw9krhkLpICWM 07/83EpVlxuCQayktIa2NzezpeXlsdZ65uNjAEjS3GmdFsxskiRBknjDFRO8SJwL0nHnnxIvC7wk JvH+3+w13hK0jJ4OoSo7d86PEZoUE1jrKo3kvLY7GmHV503eHe135KZmG23mbWbrviy+qMvo9Xo4 fPgw5qc9L2IR93rcGLgjOE/tICK3HYFcaj8HNeLy48SFH4HSGocOHcLZs2dx8uR91WCZLMuQZQ2k aY4kSaFUEmiU2C0ZGtJJgUhDcQKtU/+jovxPhR8N5kq5HW5j55wrhzs7ibN7Z/1OXQUhjpltkibI XIbJxMGaAtZKRZGI+AHDJMpXX0nC+B/yywdiluy9TCgYVPnuIt+rz0ojTVXwUJkZXj/N1Ge2hY+p QPmYIXE/wgI2J12MTTi+Eu8nR/d6PRw7dgxJkmA8GcPTZwf5kF3EIj485jnu+ZhSJvVMeyoHpLnH HeSIArNYy3NOwOwb8TweMspSwYaO9MpsL1AoCEVMz1p4+2smBabgLkgBsJUGs7cQYaUrxiHgY6l1 stlotcr9MLBCTwIVzDxJtIZkGaw1KMsJrDFVZs3MIbVniJW4rzNdkoAXqWutq6rqtKc/jrePBli8 5yCoA/jNpuHsiY/ArHxoJk9zvwSaJxYY6tuISpRKgeMEnU4XR44cQZqmlWTQb23Bdy/iXo5p3Uvm ALn++zTfrt9+oyJmrATNMuezz73T503sfPRYJs7h/PnzeOutt7C+fgiHDh1ClmV+t8oijHeMV9ke vI1hFKrwf1sHCMMRgRwBLkirQaGzMvEzfpXPupW/bah1ciHLGx/0V1d3mXkPaE3BmyLXw9A6QZJo jMcUdkQqfpsVA6KCVawEffO0vd13ZHJlC+vfYXhs+GAqk/J9VpMZUJxpzd+b8e553lQWcvOv5pY5 dJk95GpH3X7biF94s9nAYDCo1Dl1OeQiFnHvxmy/8P6xN1GRWh4+fXaEeJr5K6DQ3PbvfKHfNyZ6 rBoVI7z2B9/Foa+uYTDoI0kStNttgOqDZ8JQGudgrQEAMHsMtDGxJQcHCwXv1KrYsxRE7Ec4soII hJVyrPVv61T/E53odwi0p1gJ1GkTkQyEXLH2gxc4QZY2IE5QlgUmkwmYGab0I31EvCEVMfk2dwGc K6dpPzNcMKkSiRm4Q1kaNBre65vC1HnMKUxiRJAHZjPx2j5Xj7uV4cIfSX7o1xz/vJkb98/akySB GAsRh0aziZWVFTRyz40haMGdHMSOskUs4uZRV0zN3z5/RFfwHM5H51xoT4mPJDADM3NKQj/FvFCA iCChc/FOnTXxKtqfr96HiaBw9cp1/Kt//RWMxgWub2zjqad+AGury8jzJogJpixRFiWytBlAfBeK C7SaPZi0RPRGESIkSQ7rHHSSQetQXzTO675Zk07Sl3SS/ovOUu8ry2tr3yWmvYQ3ZqfH27qFKZGn PpRSMIaqIiLxtCoapygz+7ZQyzZkmagI+/ilETNMzejKi9r3OnFVH+KHGFXdiE651S/5VoA+/jtf oKxHnS6Kr58Fj5NDhw7h0qVLMKaMpPgt7t0iFnHw4sbZNFW3Kfb8rp/dGBxDfRefd+ATgQt1pLqq o26hHP++W0HhKlskZODEKE2JCx98ALz8TYgAW1tb+MEXn8exo0eRpAmcE5gwvF3r1OdrjmAbFpNi DGMMWCfQodBZTApkWe7pF/++L+ok+5daqes6y3+r2+9/vTfov5fl2fBG+1mnTQwRfUsEv0REa8z0 HLPqaKVhVKBJnCDRCZIkr5wBrbXe1jBIB31VNCo1YldWKGK6OgkRpIKYzaTruunYHFS3i/2w+ZZ3 S0ldLSbwn0O/38eZM2fw6quvYne0G4ZSLGIRn46YJzv2eUAFgj6zDiqOYFinwjxHDuqM+vPiY6eO nHfhjBbAs9IheROgNCUuXb6Eb3zjG/jggw9gTYEHHjhT+fdPJmN0Oh30ej0oxYHB8MnuxasXsbOz A60TtJpNNJpNdJRGq9WOjoTv5M3W32h1Oh+oJHm/2WkP0yy76S5W4K104pKs8Rsi7l9bW77IrB7Q KunYJEUSBm86Z8FKIU0zEDGMMZW1KwfuxwZFRmR5SSlACCIMZgnZdhzE6V+7DswRwKft+P6+KCvc Lwuel/PdyYgZRN1Sl4mxtLSEBx54IKysi1jEvR91kK6dhaApWQLjjE9glB/AYpytbkuTFDrxtCyc HytmnIGCQuxqZMczW56+8p08t/eWUCM2jSYjvH/+fVy9ehVlMcL6+jryPA/rk2BtdQ1HjhxGq9WC Uow0TeGcw+/93u/h4sVLYGYMlgc4++CDSNIU3W4PaZpBhMZJkr3b6HQ2WKnMOcnGo7Fh5iJJk8lN Oe+s2S2yZgemLFAW410ndgOiisQlqbVpGNLgKu45TVM/WMEa3zZbA1rrHKraaDAhBxjOerqEY/9+ UBnGD6f66PaRDO7nd3K3W+jj6xMT4CRMhvOF0zzPceLECWRZVl0ORh+URSziXox5bnvaNzwL5Rxq Wc5ZCPnxYN12F4fXD2N5eRlFUWA0HOHypUu4evWqB3BSXlcNV12VM/Md57wJqDxIfKIpVe+KIlVh 02Qywe+98gq+/Z3vhFmXDkIO/W4Pg8EAaZqCiJAkCZxz+N4772B3Z8dLift9bG5uI00zNBsdrKxo KK3XdnZ2//jO7nALRBNi3iXiq41W4731o+tvE9GeaeY12iRcoBAZZn5XKfVfkch/Kdq+mLgE1paw doKyKGGMRZJopFmG0hhYMTPAqpQKMy45NBUG8NYASFVZ94e59c13Wx70YQ11n4IkSbCysoJWqzUj F1zEIu7VmJUC7r09/hUncmVJhiOHDuHo0aO4//77ce7cORw/fhxFUeD9997HV196CV/72tdw8dJF T41KtFaNVMXdOWcE4r22AyZO63RziSMIzlpYsVVytrGxha2tndBZLUiUhrHO97iQn4M5HI7gBNDa N/YolQCgU5Oi+AsCKZnVF5n111WCLScY4QbMlJ6/gZU27f7ahd2ty1w4u+M127546QdilijLAlpP OyxhKbTGe6qDK3COHtu+OCmOAKoZWMmUN9sv8543qvpwzfedzWwrnwLroOL0C80g8eA9GAywurqK t95+C+PJZMF7L+KejdpFchXz5ELktFkrrPYHOHP/GTz99NN46KGH3jh+7PivHT565Mvrxw9vOSc4 /713n0+0/mOXLl86d/XaVd/owipcxaKy2cA+r3unYsb+AtPGnUiRiPOCNCYCk29cLG0JsVMdjigA xHAAjDNo5i2cPv0AnnziB3D/qTPodLpwgtdF5KtK6avMvKuU/q1Ov/vdZrt5XWu9RbS/d+Ne8GYl ad4ejneubxLRvySmo0rpR6fKE4PJpJg6DDJDQcG5KAuUSuInLjZeBgtEBZBv+4SE5h6aw9v9OO15 s6p6zGS0dOdLG9FkRsf5c+TdeLXW6PV6OHHiBF555RWMJuM7vGeLWMQnE3vpk3i7/23QH+DpzzyN 559/Hj/8hz7/Px0/cfy3m83WV7JG/p281XAA0G61vnX92vWjr7/++rn333sfFy9drGjS2a3Pv+In H/F9zF8tT9UwU2UM++oqHDy452kDjUYDADAaDTEpC3Dwh0qTDCdPnsIPf+7zV1944Qd/5f4Hz1w1 hfmpyah4PcnTv91aan9ATBNmvtRsN4dplt50P/eAtw9BkrU2y2L8JWfN48z8aPQosaXXPhZFUWmY p66ADKIaeGOWt/Yrq6qoBScyU2veT+c9D+B1rfeeD7fyrLxBFZymmtV6F9c+D7tpzB9SkSoqS1Op bZgZS90uTp48iW63i6vXr820/NSff/PL0A+LBR2ziE8+BLPH/X7HqIPDUmcJTzz2xPDHf/zH33nm uc9+59xjD/+VLM/emX9so9N64/4HH/jiU0899dhbb7312NbWFobDIeaXg/rr12/ZR1z8fb0vmtti vJoQ1LPu/bdNxGEIhWcd0jTFieMncN9990FE8L133sbb774NCKPX7WF5ZRXPPvNs8cOf//zvP/To Iz/bXGp/sHl1A7Z0Ravd+sbyoeWtj7LvNwBvQtZaKorJblGW46vEfJlYrRArYuU7iaJPN2g6lMGJ C1wRg6AgJFEl5P8lAEwASVQTgnBrjSvzVEqlVpn/XGt66htuNezUjV81bjjyXrPbn69C1xcY41w1 WDTNc6wfPoxOt4vo+1vbyRvmFbdO/iyKn5+u+CQW4ttzjAT2F8DsXtZ/V1rhwXPn5I/80T/yxh/+ N37svz926vg/YqVGN9rmyurKP378iccbr7722v/4znvv4vz751EUk5kSaDwT50F777v6/t7nfo34 U8ieHRQDAZzYsD8C46wvZLJCp93EkSNH8fzzz+Hxx59AUUzw9a9/HUmSAUrh+PHjOHHiuDzxxJMX zpx94He6q73N7atbDbHyd9M806yU/qgCjH3BW0SwtXWlUTr7LrLmz7uyfNMw/TXKWLdbGgzAWp9l ap3CT0sGWKh6c1FhwomCE4F1Do4FzAaGCnACaFagMhYILPxFSJ37jjUL8fMxY6ZNYWxQaPIBh05M O30MhSIpqL660nTDM0fDDBwjrr1CBW5+QolviQdhd3cXzAyt/ZWFE8FoVGL18CE0Om0ICepjSP1+ zuYyRNhzNXHjWAD3pzNuJ4DfrmMkUAXh+LSwYKUBoWDCRBAmHDl6BD/0hz43+vyPfuF3I3DfDIzy VmNy7IFTVx579gcm71/7IC1fcrhw/jxNJmOwAAocABR+XgAoTGOX6bkvlRp7z/b3yDMQrpKD1Yef hmOrAuk0CXMhSfMJIjNDaRWsX32WrZSGEFAag6VBH08//TRefOEFPPvss1jq9fDWW2/h+OZ19A+t yurhQxgs993Kyur22trqS9zQv05M5dJqzwfQMmMAACAASURBVIjIe2G/9tvdm8a+4E1EaLf7E5He eDTeGW5tXb3IrJR3AQzdluK8aXl8TngeV92XElPr6kPh8EFMSYtpsbJSq6B++MZVLxY/aQroIZXn 6GoohFDpQPUkTDl1Qt1HRWqgvTezBgRS873c78CIM/vCoyuqKFJCUSa01Ouh2Wp6nbqxN2ky2i+/ uFHsvaxcxKclbhd4fxLHhj9ntdIIA3EB+C5ECOPI0SM4dfrUlwbLg19UWt8w4672kBmra6u/8YUf +cKfbjQbf319fX3lm994GW+/+SauX7uOcjzxAwsg8BPYZdq1iVjUdPDjEmabfeavXgUShhz4bslI n9bpXScSio9+RJmIoHQGxhqw8xLnuC1jLQwsDq0dwnOffQ5f+MIX8Ohjj+Lw+mGICJZXVvDwI48g SRLK2vm1ZrP5Srvd/uerq6u/tra29l1mNgEL9m19v5W4IXgnSWYBoCwnjoleVUr9gnPuTzLQRXyz QWhfgSmm03UKY0OG6/NpYfa/xwHGLhAmVPsBQWgKsyKzB6CIn7IsAFgUSEXgrjAXUxt4f8njv0T2 aBtPjCrrjdl5vJ2mv+9ZQvbhpmvV6GjcFSVOIoI0SzFYHmBpaQlJkmBizMxGZg62+Ab2vOp8LDju T398XOD9ZI4RD5aCRCmU1kv6QF5pppXC6dOn8cDZs7+/1Ot9/Va3mSTJtSNHjvyzz33uc/rwofXl hx8896e++fLLP/C1l76K73z727CTsqJdmTj0U0yTvnmMAGb5ef93vNp1MCHxjMBNTLBu6j0eM3on 09tUEFl42sSB4K2x2+0OHn7oYbz44ot45plnsLy8DBBhMpmg3W5faTQav9lstX5XWLYHy4PvNRqN VxqNxvt5nt+WL+gGnHftATp1ed5+w9rtf6qU+8mEGXB+zI8xfkalsQYgP3Qz1QylGSqMAnICAFwN M/YUiwJkKh30n9r+U3OmjS1RzeK3C81+bpxQTLIRtZXzJIj/Kl2NpYhXKHFVr8Fz9eRb/3yjm2JF eQTwTpIEg/4AKysraDabmIyGNaJkliuXmcVikVEv4mCGgwdP35TiAdU6h1arJadPnx6eOHHiUqPR uKEfx37BzOP19fVfbLfaOHXqvo1Tp079R8288dndnV28+873MJqMKj+Uact6mLAO1M7fKXDvZedD 8414MI6USHT849A8CIJvDJKpVa1vKiRY8VNy0jTD0lIPDz50Ds8//zwefvhhLC8vD5n5a2VZToho p9lsvp5l2a/3Bv1fd+TQ6/Wkmjx2m+JDt5ZlDQtgNB7vbouoVxXzZ0DcUMp3FFprYayFwELgoCxB aW93GBNcCRkuszcjp2Ab672wa0XBMIF5/xpzfWSaeJ+U6lvy2W5VFA2AXxVLEcCxDswz2fZNwPIW q4expT8o+Sv6pt1uY21tDZ1uF9evXg2bnC3SLoB7EfdC+NPNz6b1jSlhyIBSWDu0hhMnTny52+2+ +v1uv91po91p//1ms7VZFuV/u7m5eW443KULH1yAsQZiA5j6EWGASMiQAYUbA3eVVQNAAGkBYJ2B jfMFyGvMvfkeQ6ua+Z6I9ylRjG5vCevrh3HffffhmWeewaOPPorV1dVhWZbfFOBv5Y383WaSvkeE nbyRl/2VwSd2qXyrS4FlTv6A2f1F5/BXYeVJAKlizoUAhsBaEwY4eNBMUt8WLlV7fFjBiMGUVNz4 lPKJAA3MUBYhrfaV2ADeAohYOEcB7KO/CKawSBEk4VUvNwXFGpjHW6rV/MPBdMa2NjYphb+TJMGh Q4ewPBjgvbe/5/nBD4m9RpuLWMTdjVij8v7UtrrNOYe80cDpU6fd4aNH/k7eyL/0cV+rP+j/X08/ 9+z1S5cu/tM33nyzNxyPeWd728two6A6nORxQZl1zJe532h6TomgDH7bRATNuurV8A6pjEF/gF6v B2bGeDz2g8QDj3323IN48skncfbsWSwtLWFpacnoJHnFWPsrjUbj8vrR9W8mabrjX5Xkk7TwuCXw TpLMDgaHNq5fv/htNyn+EoBTAH7MQf6kf8SUQ47WsVZcmMNGgDAABYIf+UOkwaQAkgBmYW2staFO /41KDAqzNMPrOQFs+MriCCKa7k0ltI8305xas86V1fnw2uP9ft885i0so3wS8FclALC+vo7V1VVo rf2VijP7AvQCsBdxEKMuIlCs/LntACvez7/f7+ORRx/FfadPb2aNxvddgKtej9m0Wu1XH37kkZ// 0R/90f/syJEjyxcuXMD1a9dw5dJlXL5yGZNyUhUpY5VsvyLlfPIl5HlrFSyvnXMwzvjZs/0+1g8f xg888STOnjkDnSS4du0a3nnnHQxHI6ytH8JDDz2Es2fPYnV1FcZaENF3ReRreSM/f+TEkZfSLNu5 UUfk7Y5bAm9vRJXbXm9tQ5z7ynB7881y+/opJxLkNsHrmwBSBAcHKwaA10Aq0r41XBJ4EPc/gMDB olo7a/VE5vjvVBHCHOBNAD+dx2Msi69cRwPJ+JC4CEi1CMR76pn2PIjH4uetAemMl3dthWVmnykQ cOjQIayurlbOiNWQh1oTwKx51SIWcTAj8sOWBRKuLI8eO2oefezR9wbLg53bNW82y7NrDz780N9f PbT2jSe+/eqfeu/dd3/svffe637z5Zfx0le+gqtXr/jhwIGPjqxofehxHQsAjxFKM9gxxImv1QFo NVtYP3IYDz/8CM6dO4dHHnoIx48dR5qm2Nrawrvvv4fReBwHi1/o9/tfTJLEsVKvOed2Wu3W+ZVD q1/N8nzztrz5W4xbZtCJCHnetABsORlvAfRdAP+CgA4gj4i4lhOBmACays+7ZCLvg4IE4nRFoxC4 araJ8r+pRjtcGVVmV9U3A46FScRpPgA4zvngPRdM1fYoEiuEWXis/RW9Vmj2/rgvN4Lz2PlZ9yKv CphOMBh4xYkKvug34ruZyc/7XAD4Ig5Q1K9kXdA4k/XHbp7lOHb02O5jjz/+t1rt9pu36zWVUmV3 aend7tLSu4PBYGNrc+vLH1y48NxSt/uTm9c38F0Bdnd3vbOpiT0itSvzPe8gCAOcHxhR2hJGSrSb HTzwwAN4+tln8dRTT+HYsWNYHgzQbraglEKz2US724ETQZZlf5Dn+f+RZdmvt5c6V9I0fWt3e3c1 yVJptVvnb9d7v9X4vsqfOklNq939WmmK7fFo90EY/IxAWsYZWGfhCgPrHJCLH3EfWuOFGCIMsWGq Bpxv6omVzSCeFniduGIOHDIgsN60JghHXHSFQRizFi6foiwwFkSnS7IHYUGQHFVFxfjDoHrmTZg5 IOoLS7WiVwVUzBhmzXeBtlot7y5YZSV+v4h95dx3as3KkxaxiIMWRFNtt79a9FTDw488Mjp+38lf yrLs/U/idbu93u90e73fWV5deQJAtruz+/j64fXj779/ns+fP4/Lly7BFrZWT4oZt99XBsMFrHHW gcVbuLYCcL/w4ot44cUXcerUKTQaDW8yB4J1Dkpr9Pp9KKVeI6J/pLT61Xanc2WwtnzeN+9oEudu z+XGR4zvC7wbrc6o0ep815TFu5cvvrPFht9WqeoXZZGX5QRlaTDa2vST51kjUykoTaG1AqDgCChL B2dKAAUEAmYFIoZQoGKMBbRGorWXBlk7HfbJgLWxyOAAR3BWICrKERGaZrwhlk+AfWeUOAfSqkLo +hzMSoQflCvEqCihPRHXhdCcY4xBkiRQRDDGD6+I0qA8z5E3GmEUXCz2hGHOAOAsiLhqt+Ub5viL WMSdj8h5+zqhl/j6GYwax44fd8+/8Pwky7Lbq4PbJ/JG45uPPfnkT7fa7f/whfMv/sRrr772wJe/ /OXuV1/6Kt5/611MTMCSWhJF8H77JP6KWwVvpWarhTMPPIAXX3wRzz33HE6cOIE0TSuMASp9tyOi iwB+Xin1xVa3vTNYXb4W96mz1Lm2377eifi+PvCad3eplHpHoH5OrPznWtwPiThvr5d4EB6NRlCc QusMaeJ13kYc2Hqhu9IJXKAmRPzYM2NKOGshtoSzJRLF0KHjKdIT8UdEYMoSYh2QcqUX90NA4/56 mWKSJGAmFEVZvY+o7QTmhz8Avro+q8f2IbVGzjmeOqhNXAD1OGE6z3PkeY6tLe89472AXe1p/gBb wPYiDmZMj/Houd1qtrB2aG3Y7Xa/xcyTT3oPiAhpll498+DZ/+H0mft/4fCRo3+l3+//2Wajqf/J hf8dZmirnokI3IC3YvWDfv2Cc/+p+3H8vpM4ffo0Hn74Yayvr6PZbPp3OcUYy8yWiDaZ+T8mopc7 ve7WUn9pcz/n07sRH2u1VErb3vL6hc2NS0NXjP4agA0i+glmBYZCMSkwHA5B0MizJrKsAYIDwYHJ QSvAKQUKkiPrfAdmxgnEKYh1cNbAwAPbeFz6IkOFoZ7ySJMUaZYiSTRUMMOa6sLdtLEn0CPO2rAi e1qEwsQOP3NOVSZbvhW3xpdF0HZ7KZI4bzM26MTb4t+ddhu9fg8fXPrAU0jh/oUscBH3SsQr5CgV DJbHr/cHg59TzHckAyUiSZJkG0myPVgZ/C/3nTo1ePfd9/7ddruN3eFuRVfGJM9YAwuLVtZCf7CM I8eO4KmnPoPTp09jeXnZ92B0OkiSBKUxnspkhmL+XSL6m8x8lYh+r9tf2mh12iUrdWB4zY8F3sQs WdacdJZWrtL2tX81GQ+FiceK1J/QwrClnyBRTCYYj0fQOvG6SufBWCkGFFVctCJCwgmUVoBzGA9H 2BkNUU7GsKbA7u4uRsMRnDUVPaIUo5HnaDabaPVWkLU6SBKNJPFg7vXk3tDGNxR5sFQ1ET7Dc+AE L+BXyptcOcx6iFcc95xu3DlX2QLErHvq1UJgpbCysoIjh4/gtddem1GZ+Mu8u0KZLWIRtxxTxQYB zl+s9ns9nDx539baoUNfZ6WKO71PRPxe1sje6w/6WF1bxZWrV1C6MjTh+MYapRSajRbuO3kSDz/y KB565GGcPXsWg8EAzIwsy6paVPyXABDRhSRNv9Ttda8Qkc5bDau1PjDADXxM8I7RyNsWIjsk9FuT 8XBIipgT7meZ+yxAXRAwHo8gzkGxglYJ8iyH5iRsIXDMipFoDa0VTFmiKMfY2trA9uYGxqNd7Oxs YzwcA5BKNshMSJMEjUYDza0tNDpd5HmOTruDTqeLZrOJJEkgTDDGT7tXKoFWNBXmEzzdIn4qBkLG vt8VUfRgqQczT4dFBOCOKz+TXyjW1tZw/PhxaKVhjAnvOhRUFuC9iHshKAAcEUgYnW4X64cPS7vb cbdLIvhRImvk40536Y1+v//dEydOnnnzzTd5Uk4qKW6apzh65BhOHD+Bhx95GI8+9hjuO30KnU4H SilYa4Oddci2iWCthXjzPNJaFe2lDojI3PE3dwtx24oMjUbHeFCjb4hz/2mB0Zk8x3+idfKIta5v yvJIOZmAyBfwlBawAMZQsHSNgAdYU2I8GmJnexObm9ewtbGByXiISTGBs35+plKe6jCmhC3HKCZD bI93oa43kOcZ2u02Bv1l9PsDdDpdZFkOrRgqzpMUAxIJkzA8XRIkH3DWwlkD2Wehjb6+wGxjTkWT 1Frjp/4IwGB5GUePHkWWZd7MqwbcC333Iu6FiJJBJoJjQrPdwlJvCbKfO9QdiG63e02c/PrK6urp +++//8998+WX0/FkDGZGq9nGkaNH8NnPfhaPPvooTp06hdW1VSTh/PPS59wXKJnnuesLIPoDgIq7 PeT8ZnFbK8RZ3jJp1tx2zo6uX77AipO/6BLbKsviJ4vx6C+PiwIiFsyCyUQBDFiVQrMOKyBgbYnJ eITtjU3sbG+inIzBLMgbKdJMg0FIUw2tFMRZmKLwmSwJJs5iPNrCeARsb13D1uY1bFwfYDBYRr/f R7vVRpKmsMaPZ6v8VZyFI692gXi3Q2ZC7P2cV6QQTYub+0kE62PbrADiHJqNBgaDAbI8m3Jz2JvF L2IRBzVIfJIRs9RG3kCr1bqr4MaKP+j2lr555v777QMPPCCNZpOazSaOHjuKBx98EM899xxOnjyJ ZrMJKw7jyQTGGGRZhizLAK8Os8aYiVLKKKUcK/U3iPnvsLoLlxMfIW4reNdUIKa/sn4RAEY7m7S7 df0dEustGW0JgUVRjAAmqIaGcxbWCowVFMUYu1tb2NzcwHA0BEiQ51los/dUhmaGCn/bVMOaEhBB KhaFtcHt0GK4swVTjDEabmF78xo63S7yvAGxBGsFzBpaJ/53YmRZA2maI00y5I0GrJr6OABTU3aG v7yK7e+xIScWLa0xKI3xBUnrpYbGWqRpijRJfcHS1tqJKg15vRF5EYs4OFEpN4wBKQYrhSzP0Wg0 7mr20Ww2d0+cOPHm1sVrwx/5kR/JN7Y20Ww2sbq6isOHD+PYsWNoNBqV5FcphSzLkKQpiDmex+8Q 0f+WJMnXlVIXiOi9Zru53Rv0xwc16wZuM3jHICLoJLUAwKw0E/1OlmV/VTH9haIkbWyJ0kxgRwJy PG1jh0NZTjDc2cF4PARE0MizcL8LwxxiK45Xmjhn4Uxw9BMCC4OQBq9xi7K02NnexO7uDq5cuQil E4yHJSaTEkolSJIUk0kJJo3e0gBLS330+wP0l5dBeVIBsi+Oamht/WWjtShLPwoudk6WpkQ5KVBM xphMChRFAVOUsM4iVRpx1mXk26p37VxlcTnvxbDPp3v7v7BFHLA4eAt4TCusWGjxSVqS6HGappdw l3Z4c2szJSLXarbePnzk8N/tdLt/1lgziB3PWZYhTVN//rJXl7F4732lvSFVOA9HWZZ9eXV97Te0 VpsASCcJdHKwCpTz8YkL65MsR9rqvDkebf9D6KSvCB2x+vPW2hNWADce+QELIsEp0DfoKKXBuYKi UESkWAUO8BWKiiwO0CnIOaRioKMxlBOUpQGTH5ZsjIEpDQQjDHdGGI8n3juFfIMNhLG9dQXXrrVx 5UoHS5d7aC51YIxBUfhCepZmaDQaSJME1joUxQTWWmhWFciXRYnxaIzRaITxeBy2DfT7K1CKsNTt 4Mrly14iSF4JA4q6cYKvtgRKZu6zrHd3LkD80xq363u9vceHwE+XUkrDOIdOq4lOt3tFaf0a7hJ4 K1Ze6cB0NWs1/3mrt/RTEBlMJpPvTIriJYgkFtKx1v4wQ11UWn1FUXKJmVYA+rdB+B2V6G+xyPs6 TV5tddpbSnFsuT7w8YmDd5o3DZidETnPzv03bjJqMdsLpNxzzjlGWfYEeNiJKHF+zmOaZEiTBIIp dxxNnbxmO/j4htFFsUConfMLgHVwzoApzJQkhSSxlTevZkaeJyhN6Ts5xYOxtdvY3NzC9jbh8uUE zXYHRTHBeDwGBGjkOdrtNrI0gxPnF4XSQIWmnsDkwBiL8XiCopj4qwGlkCcKWjFWVpbx5ptv+eKP EIhVqJPGhp2ptrzSmKN+KhIWwP1pjYP73UZEU6wwMSWWV1dw/MSJ73a6nd/4fuYv3o5ot9slAIzH Y3FM140460ResUz/c9rIf1UnOt/d2T1nnW06cd/J0sbfazQb3x7uDs86Jwkz/6/NRuOLOtHQWjH2 H3t5YOMTB28ASJLMLS+v74jI7rVrlxrFZPLzgGjnXMMyP+Gc+0vOuXPO2VzExdS6AupZVUfotBTx XYy1IqEQIME2lkRVr+8LoYFagSBLNfI8hzHGXzaFcW5FUaIsCzhnYYzFtWvXUJYlyrIEBBjtDrG9 vVMtJMYYOOtAcfFQ3mZSheGszN7gXTH7rlHnsLTU84+ZKEhQmcx0bN2JL2QRi/gIEXsRhARFUSBR CY4fO44Hz5175dD6+pdwMDJVttZCRP6mVuqXOp32uNPtqO+9/c4RY8z/mabpe0u97pVOp2OtMVec c3+eiIbdpQ51up07rlG/HXFHwLsGTtLvr44AGQNAWUz0xvVLW9aYn3bO/XXn7IuzHY122olYB+mQ gddvB+ApF+tpFlvTXDun/LTnYIJljf+uKlG+JmitfZdVmYTBEhaFKaG1Qpal3kMlOB8aU8a3E3h6 vz1rVQXGWuvKV0XgKRYiwtqa9/WmYH5Td1NETYa4iEUcpCAixOGyR48dxRNPPG6PHz9u7pR39S2E OOdKEbFLve641+9NrLU5Me0C2B4sD97o9fvnmcmuH/FiCgDCzHKQi5I3izsC3jEC/VFxSpxx0euv Xd3cuDwxAQElDGeorGLhQIrmQNpBhMHsZiV78MaEjmzomAya1ArkNQCBCYZVXu/pC4fEfpyTUipk 5AYIfirOOa/9NhY2cNtxm4oZWavlrwbgs22lov8KqquH0hRQKsfq6rK/H3HOT63TMlw2exFhJEtk H8rk3jzYFnFvBiEMWRGHZqOJz3zmM/jMZ57+B+uHDv3i3d43HwQAFwH8DIDzzJwqpSbWOsfEu4rV jtZqpBRbANBa31P0yI3ijoL3fBAz0iy3YfX+e0TUAOi5eL+It/bzA0enwB2ledFnuwL26se7nxFZ OALI+QJmTBESrWCTFGVZwtqyAmIIYJljeyxYeR+HKAt0bKGiHDDM7qTKS2E6jM05Gzo0py6HgEAn GktLPaRpElzaok1t3Qp2Cs5TAK8+McjM/YtYxJ0JB4c0SXHmzBn34gsvXnv8ySf+396g/827vV8A kGjtllcG15yTXwMkyfJ8emlM2GGlzhPRzl3dyU8g7ip4+yA0Gu1C3PavGlNogN+Cn4rQYcaLItLz wDZ1/JvGbI3Bz8f023TkvBs3x0s+qVES0xZ2YxScM9VkelD0O/FZNdnKEBMMhIx/mlXbIEdk9ll+ 1MMSA1ppsNJQzBDyXi7tdgvtdhuXrlyDNQ5xhNPsJ7IXtgEgtvXEe/Z7zCIWcbtD4AcYrKys4Lnn njPPvfDcrxw7cfzraZZ97JFntyOUVtLpdiJgV/y1YrbdTuf6NnYMEW3dpd37xOKugzczo7O0PBYg L8ajfwzCL4uIMuXkPhH6ZRHpuZorIDPXBjEAdQBnJg+xAaSd8+MtHfxDKLSrm7L0HHa0bYX2WbpD 8DkgwBGIfQs/V+ZZIcsHgVxwnyXfTk+kqizaq5cYrAhKEZj9oAUiIG/kWF4e4N333vcuZmEOX4zp AIgpbRLdEPfKBBfwvYhPPgSCPM1x/Phx9+yzz249cO7BX2g0m6/c7f36sFBaueXV5esAxlrrA+lP 8nHiroM34OmDTrc/lk4fAGBNSRvXLly11lwTkQIO6RTOAsfNUvPfDgMXQAA5sPjCn5/8AcD5xwPB d4So8jMQRA49ZMwB0JVSUBrTphqtPedtLQBTUS1MBFHRfdBbwMaCpTd2l9BBaqCUIE0TrK2tIs9z DMfeZIuqOXw0R58clFrQIv7/Hnme4/Dhw+XJkyffSNP0nlJnDFYGo3u1KHmzOBC9+54X5prDFwHA GMCfB/D/xPsJFLLlWee+KQ1CwZaVaxatKnh0c/WcJEmQpimSALDxPqU0sixDq9VCs9Ws9k8pBR06 JJ1zXiIYFg5VyQMpTPCY7osKhdayLFGUBZwz0Fqh1+shTVMAMVMnMKn6J4IbZ9SfvoNwEQc7BII0 TdHv94etVuurzLx9t/fpVmMWJz5dcSAy7/lg1tJZWtnd3rz6rbIsNzwg1qgE8X+L2H04cAGxQIgA ZpBzIDe1f4UIvATcc+CK/PQdtrYa3AARKBASnVaeCEKAYg2tBKIBorIavsAscIHJUeTCIhSUIgRo zWE+pUOaahw9dgRpquHgoBEGM0hQvVQ0yWwB0/PdjOl6+6komC/iHogI3r1eb7PVav3fzOr63d6n RRxY8GZkeavc2d7QQPFFgN4n4pOA/CQqm9XoBzJHLURL1tjIgwB9DqFoGQuX/l8GB3dBX7i01sBz 64BSSZASWj8wmRW0Dm6EhkBkINaC4CqpIijO0PSvQeRnVSbQSBKNPM+wsrKCPM/ncmipmJIpkz3P bUc9yyIWcWeDmZGmaaG1fpMI47u9P4s4oODtQ5BmuTDzL1tr/4Epi6eI0AGoAeBxEfQijQKERpcI 3JXTVRjyUJtsI4jDDyLYSpXEEqnK7lUcwbF/nIhAlKp49OmUHIYlEwYpz2bCM/bc4jXkaZoiSVK0 Wk20Wy1o8lk3M0GEvOIFrlbArGffi1jE3Yto4iQiWhYH5IGIAwzehE53eQwA49FOsrN1/XUAP2VM 2QH4v2PGC865FkH1BQ5Cwe8EQMxUPch6n3Ag6qol6MYj4AsUE8hOhxp7fThBOT3l1MFwYDg3pWr8 VB2gtCZk7xyajOKCMl1HKCpVxCHPG2i320hSjfGkAIvGbIFyP0uqxfmyiLsX1lpMJhMI4BZH4sGI AwvedS47z1tlmjWMc442rl001pT/hQgtAfi3/j/23jRGsiw7D/vOvfe9F2tGREYukWtVdfU60z0L p3tmyBEpi5Q1ImnDEjA2TUAGF9iGLcCACRgwTAECLNuwYf0RbMAyQNAwCViUJcIEPVogkJZBkzMa zUx3D2d6eq2uqsysrNwz9oi33Xv84973XmRWVXd1d81UdVee7qjIjOXFi5cR3z3vO9/5DjP/bQAS YLLDjYEMCFkIwFgttf3R5IAL1/iTAzrPVm8JRE5NYiyloim1Pt4OzLPnCSmKpiEjzqXcBSBrrRGG ITzlg4hQLpfhKQ/TKHKAfz+144uvzUX8+INASJIEk8nEENEYoEdC3/24xyML3rNBQkBCsBDMzdbi xDAPp+N+fTLu/1MioZnpv2LmGmDtVQHrc5I9l40FR1tEhBWAI2t6sR4qGVFd0CICSnowkABrgAnG Mie5/3ZxkU7COEvjzF7bGZdxHGEymYJZo1wOEPg+aOyKqWDLv5/JwM92VxbXF6z3Rfx4Q2sNw6zn O4td5X0sYOMTHx+rvwIRwfNL2v0cAfTOdDKYA5DY2ZIu42Z2mbZLELIMPGuldwZQGQwSBCAyuoMg 3Cg0khIa2t7OsPMtiR03rnOgF0LA2aIdDQAAIABJREFUuPmbmBnnd5aGt4VGrRMAAqVSCYEfQEDA 5O3xswMZZhtw7kajXMRF/HiCQEjTFN3T087u9s7fMan5XRJ0UqqUB+VKpfew9+9xjY8VeM+G75di rugkCkeJMcYDnKYT2QxJOAmf7dIhMUNpzBQv7U8ONLPmTEuFQ0A4C1rb5MPCQLIBS4YxEkIwhDBO R+o47/MyP3at9cJKEkFWTpI38ZzponwvwJ6NjAO/yMAv4kcfBEIYhrh+/Xr7j/75v/jPrz71ZEP5 3tFcs9m7fPWJ76ytrf3xw97HxzE+tuDtggH0haDvMaNFYMpFdkQSEB6RUQw0wZhz8hKQsIBM7AqJ 5CA3a6sHrCbcZCZVwo5QEip/UWv9atFeU+y4dNeqf9dJ8OSkjZYmyVzaTO5Y8l5gfO9Mm98HwO9v wPGDWwT4vl/z/Cvfex8uhjQ//IjjGDdu3MDXv/51LHU6v6Z8hdrcHL7w0kuvfu1rX/v1ucbca0KI T1wL+qMcH3PwJiWl3GHmX2JGFQTJYAazJBJ1Y/QiM7eJ6ZeY6Oez7JZI2AEKmebbuRAaoFCmgEEs QJS1xwirE4eAZAWW1rpWS1FQ3bkoZLbVPWuycQ1CzEjiFFEcI0kSMAzEzJ+BkTXqZL+deb8zYJ1Z xb4/sL03NN/pj/Jeuf/73eeIqzsef699obv8dPd9fJBxsRh8kMgqQ+PRCN/5zrchlEJiNCrVCrZ3 dl5YXFj4xz/7l3/uF2u12rWHNVXncYyPNXh7filtzq8OAfSde8nst1Iys+p1j4PpdPJ5An4+02Ib kzrgNm6og5XwWRvZwvcETNAGNlMnO+U+SQFtUjBrxEmIKJ5CcwIWGiwTSGV3QesEQkgYJiglgVRB iBIqlQpu7byN/YMDTKZjK1sUBtponDWpmqVfeOZfwC416o6MlHEvmLsfAys6dz373POPKe47I83M VjFOZ/TqM8/JumS5eF+C3DhpBgjSKXfsoNvsFQ3S+3oH9xcXwP1Bg2E7jiUJJGmCNE0hhcK0P8Jr r35P/fOv/5OVleXl//D5z37271eqlRsPe38fl/hYg7dtQ/dnhz/OhgYQC6ESIvEPCagT8OsALPc8 kx/aZKHQZluPkmwIg6U3mNl5eydI0wRpGrtLBMMJlCdhGEjSyE6VN4xqtQYhfCilAL8KJWogAvqD AYbDAeI0Aci6IRozO54hC8LZmZZFZm4v4szts8/ic4B/r0z57PMyl8XsSQxz5olFaXX2ORa0Mx29 cbx+VldwmvqZPZmtCzDsc7RT/SjjW0AnJ798z3fwYeICvD90MENCQDtJLhuDQb+PN998M3jtB6/9 e1eevPoHF+D944uPNXi/XzAzypUqtE5fjaPpbxFRFcC/S5Z8Ru6FQucyxLyF3lq5pqkGs4bhBFrb rNs23ttrW9QkJDEjjhkgD6WgjHJQx2QSY9gPARh4ymA8HuHWrV30en0kSYqsAcj5G87sx1m54CwJ c8f7PPdongFGe3131jh/jiBIZ4yVWe9m1+SOj70ogDjn6+EWOnLqHQ0N4zJuAkM7sBdsTbs8z4NS yhVrBcpBAM/z7bFLNaI4QRKlSJMUSZq6yUnvlfl/0Lgo8H64ILfIwtV5bCLDAJIkxfb2tnrllZcv ffozz//1Wq3WLVcqbz7sPX4c4hMN3kSEarWeEJEaDvj7Oon+W4DLRKIN4ieJzTKzxXFLnfCZ5woh AaSWWmHtskpjXQ0FA2Rv05qh0wRhmEKQh0qljnJQQRQa3Ly+j52dW9AGCIIShsMh3nzzLZx2u0iN gXQ+4ICTLN6VtjgL4OfvnX0U33HLncHnfhZwQ5pzUHY0CGHmYl0SMwUNZ7JMFFOMstcWRBBSQAkF qSQC5aFcLqFWq2Nubg61WhXlcglztTqCIIAQCkmi0e8Nsbe3j729PXR7PWhjLvLkRyTsMprRXAST 2SEbg6OjQ3zv1e/xp5771H+wsrL61ublSxfg/WOITzR4Z1EuV1MpBPq9oy0wflXruM3M/z0YXzPG yfgc8Fi/bhsWtJwshbNp9gbaWOokjhPEcYQ0se3xQjIC34cUEt3uADeub+E733kVWze3kRqDICgh SRKcnnYxmYYQ7r98wMOZDDkjNbJhE0VGfp4VnyUkiuv7AG5XXDXGIDIJTDbUAiK3qC3GzRlox6Fk lrdO2I5MSeORgBQCfuCjXLFg3Ww20Ww20Wo10J6fx/z8PBqNBqrVKnxPQQoJpXwYAxwfn+KHr70O rVOMxyPEaXRPJv4ifvwxq7Ii1k6BRUjSFFtbN/Hd7353+YXPffbJ1bXVpvK8C/33jzgeC/AmIvhB KW0vro2YmXqnezKJwhhZg43JhinADXBwbfOOIrE0gkaqY4Th1PHaMZLEQKcCbMool+vwBCMME+xu H+Htt67j9dffxrVr72I6jQCkYEoAkLOSJesRDnHOkOpuMDU77i1Tr5wF8zsld/dWfJw7Ou5fgnQF QykscGujoVmDQFCkoJREEPioVCqoVqvwPA9wdgNSSgRBYM23Ag9zc3UsL3ewtraKpaUlNOYaqFWr KJfLKJdL8H0fbLQbAi0BJjSb8+j3B7h27R0opS4A+xEK+6kjpKzdwm7PwMj1Bfd6fXr55ZfxzHPP /fr65iZfeeLKbz7sff6kx2MB3oDl6qQUzMxMJOzQnewjmQO3e3CmRIGlS4yJkaQRwjBEGIYO7BVK fhWBV4UQEswCB/vHuP7uFt544x28/da7ODw8xnAyhq98AMbyuHAstzv9tIyDzbAtn1jQEWeZ6ln7 W0ZmdlsA990LlLNbyO+j4j5rzgUIgrW9NRoJ67xYKIXEXL2OxlwDS0uLWFhcQKPRQKvVRLlcyc9a hLDAHgQBpKdQrVYxPz+PdruNer0Gz/MghYQgyqcTsdGI4wTGMOIoQZpGGI+HGE9GSNIIgLGKHfNe 5xIX8aMPVyYXDG1MLoNlk9FkAmkS490b13HtnXeWBv3eEw93fx+PeGzAu4iMLLizKSYD0ozDNSaG 1iHiJLT0SJogTQ3Y2C0Y4zZHAicnp/jha2/jh6+9iXev38TxyQk4tRSEfUkL2Jl6gxmWhmC7LQEq UDXfO85/vlvhLndGzB+L/JH3EvwVbUyFwI/ZQLMlTQQATyn4QYByuYxmo4nV1RV0Oh1sbm5iZaXj 6JCG9SR3lgPkCpKe58PzvXxake97kFLmL0jgfLJJmmgoJZDEKUajIba3t/HutWs4ODhAGIdn7Hcv 4mGG6zzg7POSMeDO50fYRCSKQoTTKYw28r23dxEPIh5D8H6fdhDOui0N4nSKMJ4giiPoVDvPFIk4 0RiPJuj3RxiNJphOQ2xv3cLrb7yJW7f2MByMkBoDX/owOuPR7cRimbfmUw68mb57lvkuCpB3A3HK 9/Vu76r4KYP0ItUmnr0dMLAFWOX5EEKgXCphfr6FxcVFLC0tYXl5Caura1heXrb0R6OBIAgQBIGV QGav6TJqqyaRgCtmZcBObkgFu7MazRqG7WunRuPk9ATX3r2Gd969hpPTU2ijIckNm76Ihxr5uSAb l4A4RZFbuLXR8D0fJRE4q2PvkRiv+EmPxxK8GXCk3UymPXu/MdCpRhzZLkidahAJ+J6HJJ7i5KSL 7a1d7OzcxsHBIbrdExwcHOP45BRaM5Tw4Lvhw0wamb9JRtEIYTNwNpkkD04oyOdmyReMNIAZQGec zcfPUibnn52D9cwDsiHLQilUqiXMt+ZQqVSxuLCA9fV1rK+vo9PpoN1uo9lqop4pQ6SlPjKuG0De 2CSdPa5mA9bs3BzdEGdlH2O0RhynSJMk58rDKMT+wQFubt3AwdE+4jSCIGE92vX55qWLeDhRUCTZ 4BNBAoYYbFJIKbGwsIClpaVhpVw5fsg7+1jEYwnexpgSESlmRjqjJ87mVSZJgmg6BRsJX1UhoKE8 DwISt3dP8a1/9R289trruH17D+PRGIBAYrTlh2tVBEEJBEKSJohCD9MohGFr+2BNswwMw2UwNkmx bfIyz7otmBt4UoJIOH25yZtXcjqBOW+dmW3aAQoOn9kuDNkXTiqJSqWCdruNhfYC5ttNLCy20Ol0 sLa2hoX2AupzdVSrVasK8f180ckoj3sNdjVOFy6VAEPagc3GgrmEBXqlFJgZaRxBSonBYICbN2/i 5s2bmIwnuZlYQexcxMMPKmokKGyMszPGJEmwsLCAztLyn5dLpf/nYe/t4xCPJXgTUUhEKUD5IAWt U2itkSRJfiEDVCp1EBHiOMbR0TFu3LiBa9fewd7eLSRJinKlBCEUGo0GVjorWFpaRq1WBzMwHk9w eHiE/f19HJ8cYTQeIjEpJEt4nu8yUUaqNcCAUjLXmxMsxZFNqde56sUWK9Ps1NX9J5x5VrY4zIYQ wipFSiXMzc1hfn4ey8vLWF21SpCFhXm0F5toNJtozM3BDwKnOhEQjgKxO+Qqm7n4O+PQzzcWIc/M i47NojhrC76A53mIogiHB4fY3d3F6WkPSZy6R1+ceT9awdDQEDw7ssTJRt1tcRxjNBp9djqd/iyA f/Rw9vPxiccTvAHNM+30GXc3C9zMQL3WQLlUxnA4xNbWDr7//e/jlZdfwe7uDoQANjZXsbG+ieXl FbTbbXSWV9BsNuEHAcCEOE5wctLF/v4+3rn2Dt69cR29Xg+D3hBhHIE1Q0A6ioCQmhTEmfsgAJed Z3JAIYSlLIzzG+eibcdO8jE5BaSUstx0qYRqrYpWq4XFpSUsLy9jeXkZi4uLaM3Po1qtolavoD5X cQVHLz8eyF5TWorlzPi3meEVZ46su848zIUouNHMQ4aZADcvtNvtY2trG9vbO+j3+1bNANcQgsxj pqCdLuLhRXZWKEhAzPB9AgRtNPr9Pl7/4Q/ri//v4i/2+v3/4XNf+Im/JYS4mLrzI4rHErwZ8NmY kjE6zwK11vmFAZAQ8FQJR4eneOPNN/DKK6/gjTd+iG73BPPteXQ6y7h69SqeeuoprK2to1KpolKp OgkcwEwQJLF5KcVw8AQuX97EU1tPYX9/HzdvbmF7ZxvHJ6eI4xiSJAQppK7lWFCmQsnoENvNJrIM GPYLw+TA0FEmyhUMy+Uy6vU6mq0WFpYW0W63sbKyguXlZSwsWKlftVaF7wcgQVCeRBB4drszxlzZ z0rZyfds+KwmPlf/4gyuFlQQnE8JHO3jOH7nrR6GU+zv7ePmzZvY39/HNIzybWZbmu0bvYDuhxfu PAqA/ZsamJxuBADDGoNBH6+8/ApOT0/Xd3Z2/pNKpdK98uTV/z0IgoOHt+ef3HgswRuAZ4y5bozZ NsZsAkCaWtqEiKCkRKoZp6ddfPe738U3v/lNXLv2Dpg1Ll3exLPPPoPNzU2sra1gYWEBpVI5ByZj jG0zNwxSjHLZQxA00Ww18NRTT+H4+ATb29t488238NoPXsfNrZsYjkZgNpCQMNAwRtvsJpv8AwBw A5YNO67c6bOF5bDLQQm1um0/d4UjLHc66KyuYN51Ntbrdfi+D6mk5fAdpSFdZm3pFmsLoJQszgBA LlsmZ307IxTPlTEFtFrdO+eFLXLPz7wxhLCNSv1BHzu3bmFn5xZ6/b4De4XCL6CQc14A98OLbOG0 DWyFOVm2pGYKlHAa4saN69jb38NwOGysr2/8naXO8r+8AO8fTTyO4M1KqmkqxP+mdUrM/F8YY2zG zexoAokojHD92nW8+uqruHHjOoLAw6c//Rl86ctfxDPPPI1qtQKlrC9JFNnmHWaGUh5sQSdFEkbO hEmhXK6h2WhicXEBTzzxBJ599llsbGzgm9/4V3jjjbcwGo2Q6hQwXNDLQsAYwHDqnA3tl0gKApNA 4PuoVqpoNBqYn5/HkqNDOp0OOp0OFhYXUKnVUCqX4Ts6JHNINMZYtYkDf+V70K6JSCgJctpsrTXY MDSbvLkmA9d8EijNOCJSRvsUFEn2RZ8tciZJhJOTHrZ3bmH/4BDTMHK8PeXad7sN+0e7AO+HF7lk lY0dC+gIx6xgKYSAMgomtdZkg9EA12/cwLvX343DMLrQev6I4jEEb0K9uXhKRFE6OO0CLlvWJldC CCdp29vfhVLAZz77KVy+fBnPP/88Ll++hHq9hiRJEMcxjLHZeka5ABZ00zRBksQwRsH3fYQhIYm1 bXxpNtFoNFCr1c38fNtsbG6IN15/k956+22ahBNkWTZYgKHz7Ns68ylUKmVUKnUL2DM89tLyMlqt Fur1Our1OsqVMtgBppTSUiTCy0GYiHIapNC3n6VGspiVU3LOQxf3ZTM6MwCHK7wWF4CcmiZNNcaj MQ4OD7C7u4uT01PESQpJCnB0E1zHp+H0ArgfcmQLL4QAu8/4rI8O54s5w5MeNBuMp2McHh0hSZKH tt+f9HgMwRuYjHr1OJr6NINQmfohCAKAGVJKVKsBXvjMc+h0OtjY2ECrNQ8hBOI4djaxFqg9L0AQ WIdBS0UY64lCCkQMwzF0PFOdFwKVSg2XLm3+zkK7/a2nnnrq3/ze9/78a3N/8v/hjTdex/HpMRKT QGj72CDwrNlTqYRq1Wbanc4qOp0VLC0tYXFxEc1WC81mE+VyOc+oBQmbQTvqWORNNCqnTJgZJAhC FjSJpTZccRTFF9W6LBbAXQB6ZjOQOQtYH3A+d7G+5YxwGuL0tIvtrR3s3rqN4WgEm8FbnxchnASN L5juRyWyz21WE5olyuwgkUJKyMZA6xSj4bAYAn4RDzweS/AOp+PVOI5+gZl/IbvNgrCHICiBjUZQ 8vHE1U3UajUsLCyiUq4iTTXCMLbaambo1MAYO0ZAkHAz1NzQYwKUIhhtEIZTmDSBFEVnpBASlUq1 31lb/dPOpc0fttvt63P1uV8zxiyGP/geRpMR2BiUSwFarSbm5+fRbDac1K+NxcVlLC4uodVqolqt IggCVMoVBKWSdfxjK+Oz49dcFyeJPNvWWueabyIBbTi/P2u6ydUkmUoEZ/s888Yf+621J9HO2MsY cxa8YSeMGq0RhiH6/QFu7d7CweEBwjCEIHs2kBq7KGb0TlG+LJQ1538vbkO+b+93+70fNfum7i8e l+WFc7YbedtU1o+gIHLum8FQQiGOIuqdns4l6+vS8/0LFH/A8ViAd5rGQqexx8yCmY02aYnBfwWE n8oaT5TnQXkKUgkYDVRrVVy6vIHA96E8H0YniJPYtXRbtQRTitSN64K0mWKqNXSqoQ0AuE5KCmIo z0Aow1IOUyCNdBpSEqGqhGottL+xHk5vCSn/+v7R7cVR2MWtnR0YrdGeb1lKZHERzWYD9bk6ms0W glIFtbkSgrKC9AgQBinHENo6AEqXOWu4rEkSSDhQdJSGlBLC+a6w4QKshbDdkZmW21EfZAAWjofO s252/xOIGUwEFllNkx3EGkC7BiMNTMdT7N/ex413tzDojQBji162E946OJ71auFcOggUXLuYkVSe BXLKi6qz03iy5+cl1vwkonh2pp+50zn9ziiOwKPYSFQoQc7Gvfb0vd8B86y41j4+P1NjgCGRTagC M5T00Kg3KBqHQZqk8Hz/g7+Fi3jPeCzAO47G3nh0UmNGk5kvM5t5qYTVxhGDiSGUa+02BiCgVK2C Y4IxGlFsnQQhGNK3BUQ2BuQZeEoAQsEY45zxAA0JhoIBhcr3+gsLzdeVF4w1c6qUuiUEjaWSJ56n 3hCB1zWswdLo1kJ97zNf+NT6YXenDMQgZmysraE9P496rYZyuYRSuYRaVUEjQaLHiDVBEaBUCSki cJpCswdP2ak1QipbBJSAIdfYI8g6/AlhgRam+CAwg0xRfGQ4XTfs46DPCvmKmOnzFwZCWkMuggFr AxgNYRSQGPSP+3jn9Wu48e4OosjAkwG0TpHqKM/nMvjMXh9uf8DWSMuqYmynpnFnBTnAO9rHZvzG PR4goUCsATZ5i39eX8izequGYZOB/r1AzUL2o12Ny5LdLEemmcvZ5eq9wxWRjR2DVgB3thgKMAgG RcIglML6+gZXy9WpILrIun8E8ViANyxxkAK8QkS/TUTzRFSyWZ4t5s0aKGWuglpb2V7WNn/eOTs/ bbQ0BBtLhxglZSqVP/GD8huVcuWfraxv/kG1Vt/JHg5b82OANBFpnaYkhJyC6LelVI16vfHZlZVV +J7CyuISKpUKfN+DkhJCKIAFPN+69kmpXMs8oHUGagWkJGlq+WtmCKnOtLTnhUwArM9NrZlpyDl/ fd4L5kw4aiSjhjIEtq8LTCZT7O3tYWvrJuLYUlCFQVdGiMxACxE8z7egoA3SNONXbWNIlnVnXabZ HE3tMn07ZE7AJuPOqx1sfcqZzu447LYynrYgiO75oXrE4+zn9f7vu9sj7R8y03szMwyyblhZGI8R QymFerWGaq0KIRBorUtaa01EKRHxhVPkg4nHArxLpXoCEEbDY8HMc0RUz+ZWSkk5D5zbqzpAyVQo 7GR6AM94YVtugI316QYDvhfEXsV/x/OClyvV+reWOht/IqU69n2/K6RM77V/pBRaC0tDk+pXW63W 6draGqJpCB0n8IISpJMbCimgtUEYRfCJQFJCyBhCSjATpLLNOoYYWmgLmKLojMyUAXnLfaaOyRqA zu/XudvOA/m9whi2jUb57xoAIYkTnJ6e4ubNm7h+/Toi541+dtBw/mqwWbFBnCZozjWRxAmMCd38 RHufgICS9mOc6jQH8gxMimBonUAIgnRnStnrZo8Hzqlq3vNdZo/4OADRbNb94bdhnKugZcTy8yJ3 /mGgjbVxKJVKmJ9volwqeZPJ5Jd3bt78N5Sn3mg0m3/cXl7ex8dh3fsYxGMB3kIqltJLmCkC4JED lvN+0Rmw5Z2A+Ze6aFbJaD0j2GmynRGTVKZcrvzZ/ELn/6zWmv9aef5epVI7up/9IyHgBaW4tbh8 fSOe/m44nVY84X3p+OgIcRhZrbcrgpJg64nCsFlolABk9eA+CJIMjHAFSSFcZk459ZG9zzMeKKIo Zt6xb/cA8HuHk5W5xM6acNljNRlPcXBwgFu3buHo6AhxkjgTqvP6hYwEsduqVWp47tnn4Ps+hsMh BoMBRqMRuv0u0jhBahJX3KQz22LWhU5cAICBcc1C53nyO9/F/eALzfz7KMa9APuDLzrZmQ0YMJgd FWi/AwaFlcPcXBVr6yuoVHw1HPb/amqStFyp/GG5XP5T16n1Ed7TRWTxWIC3CwLjEITfYqZfIcJ8 fodrLOFsgozrhpFSObMnk4M54JIOY2DIQEjAExJKelQql16uzzX/qFafv/mBd44IpWp1vLJ+6Q8J pAIVYLe++8WD/X0KpxNonSJJUghJKJGdMUkQYCZobSfcC6khRZqPMjOGQQ6gc5liBq7Z745GOT98 2b5PPvP7/R5mIS1NYYyGsZVbGGMwHA6wv7+Pg4MDTMOp8zHJOO47GfRMtdBqtvDiiy9ic3PTGlkd HuLw8BC3bu2g2z3FSfcEw+EQaZzYv5vr8EySBLFOADAkZ2VKt1CJrPOz0KKffReFv/rd4+OQPM5O Xzof97//eYMVETRn6qqs4GugM+qKgHa7hWeevoqrT15GtVYRcRJ1vNTvlSuVYb3R6IHo43DgPhbx 2IC3EJL8oLyfxOF/zTANZn4GwCqAK7MZeNGZbQcU2MnxWSaeZawAoPOTRgWhPc87lEptAzT9MPvH zEjiSBCJ6cJS5w+VUH6tUn+xWqnJbvcE/X4Pg+HQ2tXGKUj48KQ9KyAIgAWM44SlMDCSwdpa3gph 9d4SAEkqMvEMvIEzgxOMMXeA+t1ohXuFlHYuaKo1WBtIYT9mw+EIBwcHODk9cdRHoe7IMvbCDgA5 tx0EAS5duoQvf/nL8DwP3W4Xp6enODjYyzP5vf3bGI+HuUY9iiJ0u110u11MpxM7MDpJ887VfEEy ZxUpwIxn9cc27JEthJXnM21z5vf7Wpq5UP1YmsneaFyiUy77qNUq+NSnnsXnP/95XL68iUqlBCEA KcVOqVx+p1SpXAwlfoDx2IC38gJdbyxGg96BMib928zaGGN+iYj+SwCuiEItIiqR8xVR0mbdxmSg ZT+spE0uV4PNyqck5Z8o6b8thJx80H1jZqRJIk6OjqpxOP3MXLM1XuysdgUTSuUyBv0lnJwcY/9g Hyenx4iTFGxCR6VISOVZbbQBdGqQUJrPyMw4fXumQAD0GX4fcKfE577fdwPw+38/ji5xVrcgy68P BwMcHR2i1+3d0YBDNAuiBZVimDGdRojjFKVSGfPzLTQaDayvr0Pr5zAajXB4eIher4skjXNQ6ff7 2NrawvXr17G3dxsnJyfodruYTCJrQ5CLYwqaZZb7/iQE3RW4gYIGvJec8Px23CNzqqnwrZGeRK0a YGNzHZubG3jhhedx9eoTKJUqEJIhpYDyJMLppNQ7Oa0udJbHD/AtPtbx2IB3xks3Wp0RwOPxsBuE 0+EfEuEbRGICMIQQf4+Zf5aIBBEgnDdHDizMIGYYJpCx1taGUjbMsed577baK2+XyrXRB923NEnE 8eFRNY6SqpTefxxPpn9Jh5FfKpXF0tIymo0G2gsLWFxawt7BPo6OjjAZjcEAkjQBhxYc/cAHYD1M wAyjDSq+KlrgtTPMctm1MVbSp4SEEvIOiuC9MvD3ikxtQkLknuRhGOK028XR0TGGw6HdVg6YPAMM +V8sk5kjTVP0+32MxxPU63W3X0CpVEWlUkG9XsNkOkIcR7BqG8J4PEK7PY/FxTaOj4/Q6/fR7Z7i 3XduYu/2IeI4RhiGSDm9A7g/SNHyUYT6Aq7Pc97nhY0z9R7c+71kck2rxbe+8p7noVarYL7dwvp6 B08/+zSuPnkVS0uLbraptEy4db58Ok3SryRJ8kdgvsbusH6SFsqHEY8NeAM5gDMArtSaEQnaT+Lp UbU2Px6PTkrGpH9XCBEC+LeICEhjzEqqMoWKnUfAIDIQQg6lEt8OguBbnuedCCE+8Pm2VMo0Ws2w e3wijdb/axhGHmv9y6UggJQsJZbQAAAgAElEQVRW1VKpVFCulDHXbKLRauL08ATD8QiT6QRRFCOO E2g3oMF+yQzYGKjIg1ASQks7wszpuwtJpN2HWaXNLK0wC9r3m4FnjUyekmDDiKIYo9EIvV4X/X4P YRg6Th4zksTzmbcFVMOMyWTi6I+ppbOURJLYwRna2DpApWKNwqx1QYI0tRRJrV6DH3jorCxhPB7j 8qWrODnqY3f3Fra2tnB4fIRwOsXsWzvbsgPcCW1nwf1RhqCiI5bhjIRn7uVzv2XPuXMrRYGXUAoC dDqLuPLEJVy9ehlr6ytoL7ZRq1Xt5xUM31cwxloikKBbRHSTQEYb450cnn5qrlnfKlfK3R/Nu348 4rEC79lQyjflylzk+SXpB1Vm5nQy7v5pkkR/FXBgIpyDnrvYM0WCIAMJ2M+01qGQ3s25xuIPpPI/ FN8thEC5UknMvBkPe/3vhEnyFoRAygytDTRsu7pUCnNeABWU0Ky3MB6PMRyPMBgOMZmOkaQpojiG 1hpKShjlQUYxlFYQHkMykA1yzya6G0enZPMns8lCd8z1ZL5npnSniZW7OMDXOjOiOsRJ9xSpU8LM okRea4DTERerCgwzhqMRUq0hlQKzhjC2WSRN01zlYJiRmhTTKMQ0miJ1wK48CcBOGlpor+DKZYWr T17F4eEhtra2sL29jePjY0wmE4RRBJ06ygbFYqhZ50B4hl7hRw/As2Ir20+Oa2XPQNzMUEX2ljsn op6XbloJqu8FmJ9vY31zHU9c2cSlyxvorCxhrlGH5ysQGaexT5GmCaTwoZQH3wu+W2/M/XFjvrVH RDoK4ykbziUrOtVi2O/XjTFUrdcmQakU/ziO08c9HlvwBgClAqNUYACgVK4ncTTmNI2/S0T/mpm/ RA682cnZiNxHna1tLIhggISE6lWqrRMp1YfuJCMi1Or1ZDqe1EjKmhAin+LIQtprY7PiWq2BalBG miTfnsbR7nA0avf73Y3eoH9lOrHFOe34Zp5M7YQcE8DzC4VJxuUDANhAksgBHShoouy2nDai9+eF rYWsVZpobRBHMXr9Hg4ODtDr962tqFPvMBewUdA2BCAroIrcSCu71kbb4w8rszSJhtYJkjRGmqZI ksTy2mQNt6ATaG0pIiElSuUKGo05PPnkk3juueewu7ubq2AODg7stKPBAMPREEmazJ58uX0ttOFZ IftRgu98/wRs63quyZ49s0F+LVyn6ezjsgKyUhKelKhUqlhaWsbly5fw5FNXsbq6jLm5KvzAs3WV 7NPqzqDSVEMFbpKSLRMH2pjGdDzt1+dq7xitKYkT8nyPASBNEjUajqrK89IL8L6/eKzBezbYdiAq KeXvG2O6BPxPIHqCmV3/yqzLXZGFChKhVHIfuE9O4T52BcABgDcAeARcYsA7u68GUipIIf6+Vyr9 frVe/3Sz1fq5hen4rw36vfag329OJ+N6HMVe4jLx1GgYLuXgnalQsiEM1t7WnBl3lmXhGY2S8eRZ 3EsDrvMJRQSTGgxHQxwdHeHk5ATTcAIDO3jCPmf2yN0JgtmCMTc3B9/3csOqTApIbtFJ0tiCdupe G1bj7vu+lQ7C8f6pRBInICJUq1VcuXIFzzzzDLTWODk5wdbWFm7duoU33ngDb7/9No6Pj+1iAZEv HAYG4Mwr5aM2v/zowhOeBVKdOm02u/chYcHaZeHE+R/B6rYBIoEgCNBsNdBsNrGysoIrl5/A0tIi 2gvzKJV8kAC0MRDGLpLWH0e4YR7WejhNNSaTyU+ZwyM1Hk6/Va5U31paXdwadnuncRQNao25qRCU tJcWTxggKeWj7TjwCMUFeLsgIlRr8yGRCKaT3jcB/CoD/4BItF0mokAIbHKRnYwCQtBYKbUN4IH4 NwgpjJTyd0H0f7Axlxn4AyJantUjGwBkEx1RadTHtVbjZQK+b5j/l6O93c+cHB/9tfFo9NXJeHxl OJ6IMAq9OE1ITyaU+Y4HgQ/PTdNh2FbzWdCe9frOjo+1Czh72+zxy38WWdeqlSr2e33s7e3h9PQU cZTkBlHvGy6Li+LILjBJjCgKASBfcOyZgWuCFwpKMXw/cM0/BN/z8wVISEDAh04YcRwjiiJorVF3 E4harRZWV1fR6/XQaDSQJAnCMMRgMLBnHIJAbAfu0iMM2hltEqex+x15Z6T9OxULYNapSgCkW8yF tA6b8/PzuHLlEq5evYr1dWuJHPi+o0gs0EslID0J6YzZQARpqRIIoaBTg5CjFZD3i8oLvuqlqT7e P9VJMv17YPPNYb9/GpRLNxaWlwftxYUT+hA1o8c1LsB7JogEypW5WAipx6OTNwXolw2ZOuxx+ncY 9B8VygQD57yaEIkhET2QjKHRbIb1ubkwiiI+PTltMlvSxu2gBW5meI7SCccTBUGy2Z6fSmC6uLL6 bT8Itobd03+aJMlTkyi6OhwOf6k/HG5Mw2kOepab1PA8D0oqeLJQpcwWK897vtxNdXI+A1fk6Bdm RHGMk5MT7O/tY9Af2CKqUB/oPIVZo9c/xWDQR5quQCmVLySz+ymIwCQhhYKnfDAX3L4dQCFArGAU w/f9/MxCa43pdJpb5cZxjOl0atUoaVrMa0wtMEohXcG1sE14NIF8lutxTDZnfy/O1TxslaRgGJQr ZSwtLWF1dQ1raytYXV3BwsIiqtUqhFAwrKE1o1QqwQ98SGmLykIK+L6HzMRXKQ/MdgGXAlIIIaWQ ATMjikIYnfynaZr8DWa+HobhPzLGfGOxs3zDk/KCMrnPuADvcyGE4qBU1UKIPhjfZEBOJ4NSFE6O CHiZhKjD4G8xcdN++CklIjv+5gGE8iwH6KaoK0eZ/M8M/DmYPWZmIUSFSPxmtVk3cRyno8GwliZJ hYQI51rNSaM1v1Wp1vbY8J8bNs04jv/s6Ojg6ZPTk5em0+lX4jheNUYjTVOkaWqLm14AeZdhDbMN PbPxXr8nqeuq1AaTyQR7+3vYvb2L/rAPzQaeKOZlvid97oCGCdjd20O314Nmhq8kOE0glAdmbafS EwFC2QycCQoEZK9DsKZeUoIMYFKDEpWcpI0QRREAK7ccj8e4ffs23nzrLezs7mASTSGlAsjJMsGQ bp8ydc+jZgiba3XyLHuW6nKPYFu6BAGBJ1EqldFsNrC6uoLLly9h89ImFhfa8IPALvTGWvPYOa/2 jC3wfZAQubcPYDt/AQGwzChwSKGglOeGcaRIEg0luEPMnTRN15k5CCfT28bwDoAL8L7PuADvu4QF 8HpmJKWJRKRU8Iox+ttROGoRqE4kliHwFWKjgAcH3nkwiJkHxPxbDPxeuVL+ge8HMBZgmjo1T6WJ PvV8v1wVImZm34k0hOcHxvOD2BhzHE0nJ/VG81q5Uqm22u3PTcbjb3W7p8+G4XQjnE4/Pw3D5TRN LR3guHA7d1PmoJ3PrsRZDfQ9s29tp/OkqcZwOMT+3j4ODw8xDafOaqCQA95PJDrF3v4eTrqnSNIE JZTAAJTnIUkAFgwBZflWZpCQEFJBeUXXaPYeBAMmtZPsS6XSmfdFRPB9H8YYTMMpppFt6FFSQQkF KOQNTtpoGC64+0cvzhcn7W3GnSkIQVBSIQh8LC210FlexvrGOtZW19BeaKNeryEIrAd36hZjT0ko Zb3vpRSum1VCKUu7pQmDiCFktkg4BZPz18mGc8dxAkgrWyRQmYBnjTHN0WAwF4e+8YMgCcqlCxvZ 94kL8L6PCErVNChVodNEMHNkjPnv4jjyTZr8TTA+LYTo4yOAt2GDJI4lM8PzfCOlZJu6oMtE/43v +6LRaKhKtZqmaUrGGB0Pwt8ZnPR0Y7FVbS22jwDc0bmWJonsnhzNaa0j5ftRu730jfl5841arVaN 4/izvd7pv9/v938ynE47JjVzzFw2xni28JfmxU2lVE6b3K1geWcWDsAA0+kUx8fHuL13G/1e321T 3PU5dwsi22GZpinCMEQURYiiCKVS6UxxVZCEcawVESCVyL2+LT1QcLm+lGCnSMnPLoTlzIPAnn2s rq7i6aefzguY03AKrbWzz3UOlObRHMEAzHZEaltSJeG4bQvnnpKo16puKlMLV5/cxMrKClZWOqjX 6wDYTY0aw/N9BIEHqTxIYd0tpSxoIwvg9own1W5ItiCA7e2Z/NQYgyRJwID16TEEKdznS0jPGPMT vZPThpTy24351hsX4P3+cQHeHyCEVKbRWp4AwOnpQS1Ok69LIf9vz/ePXAnxA4floCN1fHJQMcaI hfbSuFKpJQxk9rPefHt+UiqVUgCQUvLC0uL4ND0+isOYwBTrVBMIEELwuWyYhJClQa9bZkJYm2uM 5uaacXtheWyM/rbv+9cqlcrzURh9OQ7jn4ii8GoURZeTJKmnaSrtKTKgtZdt777BO0kTHB8fY3t7 Gzs7OxiNRza7p3sXKzOVca46drRJUA6w1FlEfa4OcgMzGLDeKe552jBSPcPZn1MIMchKIxVB+R5I FiPffBNYF0YpUKlVsbaxjpdeeinPzre2ttDtd8Ep36mFN2f3/qNEpr7+aEtCodu2JlwMoChIBoGP 1nwLqysrWF1dRaezhI3NDsrlMjzPcwt0CiEAz/cQBD5834f1RhfwPAUpPcDx2cZoCElW2eMRQDIH 7XyW6kxtAS4hgBuo4R4zz4Z/Q0MzEf0mmN/8qMfycYgL8P4AcQ4YQwCTICjTfGt5/GE6KwEgDKeq 1z0pG2OImcvMiAAkwJnGGJ4FSiGEmV9pbw+OB+XpeCqm07AmFZn5pYWJVDLfD+V56UJn5TBDRRLC WADW4uT4YL5ebw6brfY3mPmVJI7rR/u3nx0MBl8bjUY/b4xZjeOYtNZkPc2ZZmWE78V5a5NiNBph b28PN27cwO7uLiaTCQQp2/CSZoh3lvO+G2z5voeVlRV8+tOfxvrGGmq1KjzPz/XcxXGyA6TvVnAF Ct7e2gOcdVaUUtrTfiefrNVqeOaZZ1AqlbCwsIDvfe97ePXVV3F8egyjjfUPJ8vpF8qZj56Fn22U ufu9s4r4s32e2WNmj6I1VSMiBL6PRqOB5eUlrK+vYXVtFYuLC6hWK7BNxwbkBilI6dnmJucjr5Rw Zl1uADEDghRsCzw7HpzgeQE8L4CQBazIc57y+dmcUPAcuAMgNkbZ5i6W9qzhzsL4RZyNC/D+kFGv N8NyuXYgpSTXcv+hwvcD3ZpvT92XM/J9PwGAIAh0p9OZ2Mf4Z6cHEkEqldbm6+NyWhHWR4RwfgGx TRbeHaefRIIbjfm+5weJ09VGnuf3OmsbJ+2lZEun+h8MBoPFk8Pj58eT0Vcnk/FLk0kopTTw/HxA paMs8kYMezMBxCWMBwlu3TzA1vUdjAchtGGAUqtGoOy5Ns9mY9sUyRW20sQChOf72Nhcx1/+6l/E iy++iI2NdShPQpsUDOtvYrNvYztEZZHVF63/BORFV4CNhkY2jMJACQ8y8OBL4ZqLgNQYKCWxtrYC z7NZ5GA4QP/VHuIogdGOjskcHR8QfULEgMgy+rOWWbOgfk4JfwbocwkjAUCCwCPU61UsLi5ibXUN a+trWF5aQr0xhyAIrATUaIAkiCxwS6UghMwpkexnO9Yum8DkbndTdGyGDdgsXxefD0FQgm0jj7Ai RrCGkD5YErTrmRBSwekPy6PhsA2iUas9f+FC+B5xAd4fMjwvMJ4XhB91O0opVkplxdF82o6UkiuV yj2n7wCA53vG870PTNcIIbhUrkSztxERSuXKpFTG2wDertbqKJeq3z45PrrW7/f+baVGz8XJ5Alt 4iocd0rkvCuM/ZIKKcBaIxwb7O8dYevmDg73j6BTq8qwGbKjMdjAgEFkG0aMU0Bow9Bs4AcVdDqr +MxnPo8vfOELeOqppzA313DZc4p8wWLK/VpsZPa9yFEu0yQTETSza6eHaxS3XaQkBExqjbsY1t+9 Wq1hddVDGEbY3d3FzRs3cXR0bDtdKZt1+UGP/r2DwQCflR8WnZw5k53/B2TSRcdpG0bmdylYoNWs YaE9h5WVFayvr2N5eRnNZtP6wHhebl8glbQDuH3fctsz4/Jsdu2A3A3sKCgRaX3lz0hJMzM3ysHb +ssXZ1mZX/6sBBbCWkCA+atJHB9G4fQfO97swR3gT1hcgPdF3DU830Or3doWgv6v+lz9epIkL/R6 J39hMDj5XJqmy1rrxUxuyKzttHoJxFGCo/0url9/Fzdv3kCv2wPgJr07egOwUkjirOHHAhARkKYx DBitVgPPP/8pfPGLL2Fz8xKazSY8z8tHt83SIxlw2/syDfP5Tk3kz7OLB5xFgHEdmXBA4wY5uMaV SkWh01nBpUuXsbqyhkF/iGk4ndn+/c3ceb8gt4+cz9WcbaopnBdtGNsx6hYZ6ynC+RlIuVRCrVrD E5eXnVZ7FYuLi6hUKm40nrUJIAfQ0qmLVDa0WhSATDMeNBmg58B+7hwgO7uZBfjMMyejrtwDZ94b ip/tG/wyiG4S0T98AIf1Ex0X4H0R9wzlKbSXFiYAvgngm73Txr88Pa7/hSgKvzQcDX9uOp22x+NR PU1iZQSD4xT9/gDb27u4du0adm7dwnA0dFubrRfYa+GKj4IEPOWBhIQxCerlGp68+gReeulFfP7z n8XKygIqlQoAaw+bPfd8G3+x/YLznv292A/r7ZI6yaAxrrtQKHie7R40aQKdppBSoV6fw9raOi5t XsLOrR2Mw7GlGpCxzA8qBAjqDOtdyCozQ6mMsnE0C2lop3P3fYVWs4H1tXWsrq1gc20ZCwvzaDQa uUJHawM48M4Kip5rWBJCnSkyZhp75ItEkVFndNH5PoDsubk0c8bFMvtbWL/ls7ed+zsluNO/9iLO xQV4X8R9x1yzdb0+19iO4/jr+7u3/mA4HP4Ckfz5cBqupzqVo+HAu717QNeuvYtbt25hOBxCs3E5 pJtOz5aPlcJ+uTXbMWVGG+jUGk5dffIJ/NRXfhJfePFz6KwsQSmRZ8izXaBZR+T7WdWetbU1+fOy LB4gsJEgZedeEgG+HyBhgnaSxIWFBTz99NO4fv06Bv0B0iS1E4Nmhh5/tGDYIQkS1mmBHAXi5qS6 CwP5cGd23FUpUKhWq1hYaGNjYx1XrlzBysoKAl+iFAROLeKWGVmoQLJjk3HasyBKWaExP0LF+2ND 4KL0cQbAhZQ2k5+hVrLlLSsOCyFgyI2lm8nks8cASACaMgA+1/V7EUVcgPdF3HcIITSE0CUpo9WN zT/VRr92eHD4L/q9/hPT6eTzw9HkV/YPTuS7717HwcGBHclGCoYL6t4wg4zTcBsH7AwkOgZJidWV NXz5y1/ET/7Ul3D58iaElDA6RcLJmXb98wB8PnvLHjcL7MbYbDuTOwohIaUHpYpBFNl2BdnsNHVt +LVaDVeuXMHm5iZ2drdx2j2FhIciQXwQ5EmWVWd0QjaD0jj8YwvpbAeBlEoKtVoVCwsLWF9fxfqG K0bO1eB7vmu8ygqPEpASghmCioxYyPPDp4ulgs7tmZuBjWzoMBPsjgjKqZYs4yaSAAl3jpBtmnKw NjM/z4LzjLqKmZlOj47L9cZcVCqXL3Tf5+ICvC/iAwcRISiVJgAmnc7KSWt+/juj4Wir2+3/JQZt nHZ7qj8cgAD4UiJOUxSqCWOHNaAAVgajVAqwvrGBr/zUT+NnfuancfnyJvxAWTmguJMCuVfWfWYK DhfUQ/FzRgEIKEWFFYBTpxQZvnZZqS26BYGPpeVFbGysofF6Hcfd47xlnB4IcNsjYd+j3aotvlou m9nk9/tKYG6uhsXFNlZXO+isdLC8vIT5dhOVShkAoNMUSpUghbTFQcqoJtvCnlkhCCHAJFzN0A5m BhUNWZl6Jc/GM8AVhf97NuQjU40Ioc5SLLPZNUl7QdZURWfOAgCgUq2GlVo17p2cUjidymq9dpF2 3yUuwPsiPlKUyqWwVC6Fvh98p91e+L1OZ+Vv1qq1pqCsocd2QPJMcZLZFQxn8rJatYpnn3kGP/3T X8Fzzz2DUilAHIcAEZT07grEdxYl7857z14smBSuiRlIGa1tIwukzeYdD+55Fmh0KlCrVXHp0jrW Vldwe2/XTqt/oKx3MUAhW+Ts72x9tZWybn+tOlZWlrGxsY71jTU0mw0EgQ+lKFfVCN+OthMkcwpE SgklvVxdky0SOcct7LEp3k6x0M1aJBSFSwvaUhQ8uThPv+QywnMTnIBM3prfNvP3fEGn6X82Ho08 AL9PoIu5l3eJC/C+iA8dURiV0jRtWuUf95aXl3/nySef/BuXL19u3t69jW731FIjJKGdpi7rsGTm PGNlWFe6SqWCZrOBUsmH4RRap67x5rxa5CzPeh6cs+1nccZO9xxnnt1vdAp2/LbWGp70oLLhzWAk aQQSjNW1FVy6tIm33n4TpyddzIL3rAb7g/DgWQ+ojUwqaNwkH4bn+5ir19FqNe3w5bUOOp0ltNtt tOYb8DwFY1IYTh1fb/XyOrXdjsppsjOAVUqBhOXzjbH+LBlfPUufEKhoh58B77PFybMFTgAwhiFm itIyz8xF/jdgYQuX55uqhBCIwvBnojD8IoBvAPhneNC+QZ+QuADvRzCsd4Y5n9IxCcGFnvnHE+7L JtiYCgOSXF+FNrq6t7f37KDf/0kAaaPZ+EZ7oT1eX1+lp59+CtfffRfDwQBGa2vhypmET0CSs1MF IxtwMB6Psb29jevX38VyZwmtdgueL0Fkm2myON8ZmdEcsxz3vbLurEU7AwljDDLNuk61G9+VIk1S IDAA22ahOI4wnowAwyiXrWVqq9lCrzcA65mFBbO9jufJlLvhD93l34I68YQbiNBsotPpYGNjHUtL i1hbXUa1WkHmFqi1hvIkSp7l7/PMmHx4yo4is8exKNAKZ97FjirK+WiZ8f8CglyXpVK2EHnuTMdy 6eey9qxBaDbrzgqkbO1jjTGgc4Zg58+amPkHAH5NStkju+ELzvtcXID3A4rz3OtHqY5PRmOv3+tV wVwBQK5VYVqt1UbN9nz0vhv4kHEX1QYZreXJ4f5Sr9/9VWP0qlJyD0BlGk6+GkfRUhzHlSRNMBod Tnu928bzks4XXnwBu7vb2D/YRa/bh1QEbWwnpdbZCDEJErDeGCQQxzFubl3Ha6/9AFefvIJavQq/ 5AMwAAtrqnQXWuRuSoR7AbidOl/4bGhHlRS8rs26tWEkSQStYwdyQLVawbA/QBxHWF9fw5e//CUI IXB79wijydhq2F2rPLtFquCpZ2F95uC6SybbEGRpE20YnhRYaLexvr6Ozc11dDormJ+fd+3sAEjn unRLh1iKBCzsBYRqpQYri7QNTYHvu8YagczxjwQhde3tQgqQLGgQEhbA4S5Mtmhpz5rs/pKwChYS tttUyqLJRworSTGwfuEZJy49HyAGE+fSz2wxnjmTIhBke2lx6gfBBXDfJS7A+wFGv98NoiisVMrV pD7XGH3Y7QTlkq6mtXG/211h5v8RQA3Ab2utf+/B7e1dghmDfleE0+kTcRK/GMfRS2EYPTMZj8rj 8ehqksRlKTElIpWk8YqwbkVgZqSpgBAMKSTW1lbx/PPP49q1d/D94fcRJVMQWUBgwzmlwKYAZK01 xpMxjk+OMRoVOmpkxbsZzvt83I0qmaVEsuu7gTqybsZz9EuSWq551lgJAJRSWFxcxAsvvAAhJF77 wdu4ffs2+oO+Hd7AGhKWmtDGDuMt2niK2ZcZP5wvJDAAGwSewELbTvS5dOkS1tdX0W63Ua1W4HmW rzas8xqCbYLJ1CMqG4/n6BEPcIVhIQSEsoMqbONiIdvL6BISFrxngXuWIpFSQGt3pmMP/MxH5y50 lftM5f4yjksRbGkyAudukHdSL4YECaE8z/y4zzY/LnEB3g8wonBamYxHzSSJESdxXQpBc43W3gc1 rfI8z5TKJe53MSKilwH8BoA/I6IHkoGwMRj0B0GlWkm8Wd8UIvROj3+le3r6F6fTyTPTcPpkFIUL RNabW5sERLadnNm4wQ0SQlh7T8C6zFWrc3j22Wfwuc99Fvv7e9jdvQVJgCRZJKGuPR5OKmhtcVN0 u11MJmMY5xA422o9W6y84z2du+98xn03CsVeMhUen6FgmG3BMDOryrYtpUStVoUfrKNULqFea+H6 9RvY2dnBweEBev0ekjiBMdpl41kPZjY/suD8U7ZDDISU8JSHer2CztI8VldXcOXKZaysrGJurg6l VLEAEMOTCrPWupnkT0lvpkuyALwMoKW01q02kXbgLaUVBhJZp0W3qAiXSc92V0pp2YuCnsqKlzKv ZdAZQJ+dwuQW4OyMCcjVK7OFzeKjSIaZ436360shuVQppxdywbNxAd4PNgSIRBSGz49Ho08JId5k 4M8DP9j3fH/qef49QZyZEU5D5fmeVkqxEJIq1erxdDL5u2CuAngzSRJvOplyUArSOIqk0UZ4vqe9 c8ZVd4soDCURsVSKw8lUJXEsTKVMAGB0KuJwshxG4YvHRwe/0T09eSGOYySpBSHf96wSgxhCANb/ SUBJ51nhDId0EoEZUCLC0tICfuInPoe9vdsIpxMMeoOcIsmBeKZtnmG7J3u9HsbjiZ2rSMK5ABbH aPb6bscwi1nAPgveOHubnf+VP8eOV9M2uzXFqLWc1zVWJVEul7DS6aAc1NBut7HSWcb29jb+//be PMiy677v+/7OOXd9+9Ld07NiAIILMAA3UAxFMZJsqZyoJJWjcqzItky7kpRdjkynnJIcJUqFLtvZ vESW5bJSlsQwErXYkmJbdCypLIsWSJMUFxDrYBssg1l6en391rud88sf5973XjdmCJCcmR4A51PV bOIt/e673fO75/3O9/f9Xrx4EZtbm0iTFFmeATBWrU2liRdZIyjNtgiGQYhOu4t2q4WTp9Zw5q51 9Ps99PsriKIQQNnzZ5TyPjl39KtaMlX7xBbuqnjbCy4ACGkDEaRY+LJXG5dSKRRse97yUMtkaSN2 RIQ9IrAQwieiYwDI9mFfryAAACAASURBVNUXMsHqPIkDRblaTdMVInqciJisJMaAcJ8gcfbwpmX5 1WPmP7W/N8iJ6LNd0XvaFe+DuOJ9E1GeN1VKySzL3maM+Wie5394bePKO4PA//1ud+XxVrs7u9Fz 2Rjs7eyErXY7VY167ge+6fZ7yfamibM0/VvMjCxNo8loVHi+pwc7u1GaprLRbGbNTjuRUh7w8j7M dDLxpFTsB74e7O7GayeOD5VSrAstJ+PB6d1rF39ob2/vx7Y2rp2cJYktNNKaL6lqRUSAmE/W2YLN xoC1LcS5sRakyZQRxU2cvfssPvKR70A6neFrX3sUg/0BGDYWq9BWQyxIlBmRVqUwmUyRJMnSRpY5 uGt7gwK+vPK+XuFe3LbovRvWYL2kODHGqjaMgc5T2/Ioj2PumkeMosjnm6jtVhNKSvS6bZw4cQzr x9fw0osvYuPaNWxvbWE8HkMbAyWtZ4o2Nkot8BQa9Ua5EXkax44dw/rxPlZWWwiCcJ7TWfWEg8BH EARQSsHo0psci5V3pQaxcWNVG6RaYSv4nl9+YgKYDYSUUJ4P5SmYooAQNFLST5RSuZQyIyE0ADBY GmOeU1I+5vlqXOR5m5k/DKBZdbEBKGb2mVkJIepCiLA8LiYSV4nETAjxaSHETytPpUTEeZEbZv2X QfRnAATMfJqZxVLxPgHgrzGzBrCltX4mz7L50lwq9ZZvp7jifRPpdPozIYTZH+x9WgjhFUX+N4oi VwDHhS42Abz0jfw8ISX311anO5tbcTKbqbhWyzr93gxLhWoyHnvGGOqtrkyXn7tUzAQAbrXbKYg4 TZKQmWMwxgD0YG9v/eqlF390f/fyj08mk2g02hfMjMAP5lI3XeTlZh+Dpd1mk0JBV+EH5eB2tUrN dArDI9Trdbzvfe9BOpthb28Ps6enSNOsTCtn2FFwmvfABQkUhUaapOXPtqZL12NZoXC9dsgBDbcx 88dqbWD0YtSey2EcOzavSzWKQVHk9sLEpZ8IMZSQQHlflmXQ2sCTORgazVYN9UaEbreN9fVVXLp0 Cc8/9zxevvgy9vf3YQyjMDY8IopCrK30ceb0Gdx11104tr5e+o9IKGVfrzqXVZ9bKftPNcsySOHb Fsj8orLwJal64ADmIcuq1Idb33LrnCikgPKU8TxfQ6hESvm7fuA/5nv+S1Kpi0LK3VKJ0tVat+qN xrVuv/vk7ta1utHaBxMxwzPGtLTWa3lR3FXk+aoQ4nuEEO+zvySRCCF/Skr5ZSHEKIjC7e5KbwoC dja3urPp9JNE9PPM/HYAn2Lm9tLv8EkAPy6l3BNCbE4nUy+ZzrzyYsr9tdWpHwRvaf8TV7xvEtVH v0ajnQHY2NnevCSlDLXWYZ7n79CFPo7XKN6H181lX5I7vd7MGE1SSjOXuC1t7BijX7XkTpNE7O3s trTWx4QQw06vtx3FUaVUmT9+OBz+8NXLl//ydLhRZ2ZAF/CUghJWO2GM3biD1iBIqyAAoKjSadC8 WBiY0ujIwyzNkSQz9Lp9vOc9D+K5Z5/F1atXcG1zc94+Acp9SK6mLwWMNhhPpkiS1BZOWig1qmJ1 uLd9uKe97INy+D5dMGy4RDWhqcHlRKUpcymZzXyjzeYuamidQwoqV9A2uEAImzqTZdYZWAiBKPZx 8uQx1OsRfF8iCBUuX76C4XAIqRRqtTpWVvo4dfIkTp06hX6/jyiybn8gezx2U5Dnq2aab2yWo/uB P1dmVJuOc3/tpR5yJf2T8x55dfu8F31NKfV7QRR+Xil1vtPvvRzXawMiSgHKy/PuMbMnpSyU5836 a+sTXuzAEjMrMPuG+YuDne3GbJr8ezZ0igFPEI1B9ESz03o5rsUzEoKlkgYAOr3eoNVp76VJwoPd vQzAf0FEqvo9M/NECHGht7o6VEqVRXohxFTeN26F/GbDFe+bjFKKfc9PlJJTY5RXZvfdPdjb+6Dn Bdc63e6F6z2PhECr20mu17+2nt3e4gYGwIx6o5EFYairfxDMjNH+0M/SNCiKXM2m07drrX9MSvkP 9/f2dpmN8oMg7/R7AyGFAYAkSY7v7++v55MRfD+AJNsmsb76GlSKu60UjMC6vKiUwbsLNRwB2vY4 lZKgPEOSTG0B7/Vw5q4zaLea2NzcBMMAWGzc2U00W6SLosBgb4DhcIg8z0unwevLBAFct0AfXnEf WHkbU/aCy4Jd9birPndVvLVGleVp2GrABQGBb1PQ55t1ABgaWZahktCREGi26jh95iSC0EN/pYvB YB+1Wg3dbgf9/gp6vR4ajQZ8z7O+IVoDpEB0MHtTVBOOQsH3ZbmZqEr1zvLKW8z/u+o1Y6nnXF34 iAQkaFtJ9VwYBH9Uq9V/p7O69hUh5TiMo1m1wl9CA5j71nt+sNyvYlgHwBzAhGhlp57nV8EISvuV HCCEcZh43sFQEM/3CsCDVIqElAMADx94VQZIkIprcfGtyG7fzLjifQtgwBDRK1KKXxeCThtjjo2G wz8mIC97nnclrtVmh/t1RIS4Vvu64QvzxwpC3KjnURTlyx8dmRnT8TieTCYxEb2TmX9USvlniSid Tae/EATBI3Gtlqh6fbp4DjQbuzmHUjqnC23TbcpVNcmyNWIvESBZBvwa2EJcjrsbbT2x0yQBYEMP 9gY7aDfaaLWaCKOwnN8gMDSqPz8qdcSmLKyDwQD7+0NkWYYgCA/0sw8X7uWCXZ2DG21WAja6zPar ed42sSvdqngvrF7zPEeaJqDSW0Wzffxi4IXhKVlmPnIZsmt/hb7vodVqIAw8rK2tIM8LBEGAOI7m eZHVpwhmBglGFW5QhUXYCDFVRq0JSFLw5g6BmJ9L+4XygrIYR2e2NwoillLsKM/bVEptCqGerDcb X4rr9cfCMHqp0WnvvZ6/u9cijCKEUZQCeN2zCEoprjcaN/q7f13/Ht6quOJ9C5BSmTCMn9Fa/09F YT5ElP+EZv3+yWTy0s7W9tNhFD0lhPim/jCNMcizXDZbrbT6R6y1FkWeK8/3cz8MkCRJO8uy7xNC /IhS6svM/G5mvpuBRw7/PJuAIwEhwGRgDNlBGm1XkApAYfKy+FlTI1CZ5GI7HQBs0WdhQwLyLLHD HgQkswmmUiGKQkRhhMqYn5c+CIty1W2T4jVGoyGS6cwmtNPCYw/ADVfgN9rAfLUyZSmmC+VkJmyb BKYygCrfkrFyQTJl8c5zpMZOYWpdAAREYQAiwCtVHkQoh16AIPAQhD46QsLzfNuSMWXijVlkP9ov hWq+spLqSWUzP8sPWiiMAYoCvu/Z3xnKASMSYFu5QVIaqbyRkmqfpNolIdLA9/fCKLrg+d4zSvnP KKkuNrudV+JGw3mGvIFxxfsWEIaRDsPjQ63NLE0vtoscezmyc1rr70nT5AlmvoBvclVRFIUY7O6E 3X5/VrVY8izzBru77f7a2lar09mfTKbfPRsMPhyG4Que5/05pdQOACPlq/XmRaFR6AKGgIIZUh2U ejEZ5Jzbj9sS1uFPMDIzLRUNy0WVkSNF5EvbjtAM5Xko0gS9dgf9Xh+BH2KapFDCgy5X7oZLE1IG 2BSYTsaQxKgFAZRUyJnKnu/ik3elAql6v4ftYZdbBcsF3BMMKUt1C9jGogEQDGsBZUS5gs4hBCH0 feiyhZLnhR3EKbXfnqcAYWV5hqzW2vdihOUyeHHhscXX2rISFIRVvTABvGhnGM5gOFkM2sgyH7Ry A6wGe6SEKRPaSUgmooIgcqG83AvDzSiOvxr4wRf8KPwMCbHRarUmnU7HfhwCDNmejPMLeYPjivct gKrNPGIjSIyFEDkAwcyKmeW38rM9zzO9ldUDKfF+EGT91dVtKYTZ29n1Rvv798yS5G5tzNDz/bWV Y2sXPd9Pl1s1izaDKQvLoge9PFyxLENbHkm/7gqYSgEhczmyLWAMASTR7Xbxtre9Dc88/RwuvPjS 3HEQWAzKvHolXa28X+1ZcvgYlo+luvgc3rgE7ECMYJTqGDH3OFFSzn03mBm+75e9cPvcQucIw3Be vIms70cQqQMXO9sCOrhpSiB4yqpDqhaTXegv7GusZlpAkFdqtiv1iJrbr1abjoW2J00phSAIM98P nvL94Cue5z/W6nYfW1ldfYaIZkQ0BVEhjsATx3HrccX71sIkxHTJ9vJbDjwkIijvYFp9+Y9TA0Ca pqvT6fQd4/G4AyAiIf7q8dOn/rrneZcO/6zhYJ/Go5ECrPa6+nhuayJZRzql5oWkktQtXDnKL65W u/bnGm1KjwwFU2gQBBr1Jt71rnfh/PlncfGVS8gLPZ96J5TqmXLUvlJNHBKbHCjuy+djuXc8P/G8 MJ+af803FOX84mD74jx/b1XbhGipfw57UoqiQJqmyIuiVJwAmvPyGA7am2pTzHXaBCv5s68BsEbp smgAWoQhEAkwrHJElW5+ILtK15rnsskwrCEI460wDB5rNJqfWTl2/HOe518lIfZ83x/4QZB9U39c jjcUrnjfWpiIpkKI35RSdrUQXSLKgG+1hFsm47GSUrLn+Xo8GvrGGDGbze5J0/TkZDLxiqJQDHz3 5sbGB9aOHdsPwnC0/PzpZHJqNp31DbPdHENl/g+gbANIZUeohazsPIG50rAquFhadQKgUn1iLwZs fUqIcPr0Kdxzz9340pe+jP39YXkSlnRn5c/1PAUh5BaAL4HxVQCCqskg4HuJ6KHDK/HDnwRupPcW wq68q+lE+34XhXwhSzz4KaS6EOR5Vmq8NbQpME0mYDZLao/ykweL+QodvMjZNJrBVMabVadR2OGn 0jXA9tuZoI09mVV7yPd9eJ7abba6/7rdXfl8rd64EIThk41W+7JTZLz1cMX7FkJEXKvFU6P1r+VZ 1lJKfZcQYkCvM1zVGIM0SVT5MV4rzztQ9CejcYOZOYzCyWBnt1to/b1pmn7AGHO27NvSZDyub29u vb/dbj+yXLyJCGmafleSJPdprSFV9Y+/lJdVH9PnenK7DCax6Post1EOfMFWIl1aqho2SJIEzVYL p06fRL/fw3A0KsUtVSDDoviUk4TXlOf/VlSv/4LHJJgZaZL4RVG8wMwbRNRi5g8KIfyqwFatEWBR eJdX5baoUpmpiXKflTEP910+u8RzvTeVrSMwI8usPaqVEQp4OrdKneotVKt7VOPwouzrm/mF0YYs cLk5WRZvSWAWYEgwCNrYjVQpPXheUNTi+HKz1Xq80Wo9U6s3f6nZ7j4axrXX82fkeJPiivctRAiB bq+XgGGKPP8DMG9IKbdwo7HBQxhjaHd7JyrynFqdTlJr1DOUVU7ZUbx4Mh4fn02nPjMfZ+a/D2BF KYUwDEFE8H2ficiHzZ6yQydF4RljauPx+Aem0+kDRaERKFEec2kzWmqJwQKmVFsoJeaG/BWL/v6i iEMBeaFhtIFUClwYpFmGZlNh7dgajh9fx8svX7TtlQMV0/7/KIrh+/40iGvT9uoaABhmxt7ODpLp 7NcM868Vef5eAP+CiBIAUwDMzFF5HkS12j6MhCyld8u68EXE2EKSWO0HVCtfAcMaKAQMW0VJoQ2U UGBYT3Kjrdqmel7py14W6yUFDLCk1mFYh1aCJAVhpFWOABBCIQzjWbvVfr7b6/1Gu935x62Vtd3D F3HHWxNXvG8D7W4nYzYbO5tbMRFNlz+OH+aAZtlYn00iCsbDYTQZjZgBFkIkK2trExI0JKL/iog+ Bivaa0opEccxAGv0FASBiaLoaSLaM8ZQmiT+1rXNU0ky+479weC+PM89W+TkvEgtpvXK8XWuNget vrtqORxolcy7GnYVqdk+xvN8SMnIc/t+u50ujp84DqkIeekPQqikggaAhziOEQbhhhDiWnVeiAjt bjfhDtNsOsXO5tYUwB6AjwshPgsgY+b/iJk/xcxhlZiz/HwigjACxGXxRjW8Iw+szgFAykXrpdJQ m4LBhqALgzyz/WxB1qvaasWLRc98bholYDRbaeH8d4yl46q+7GcQtr1v9jwfcRTnrVbri8dOnPyn qydO/UtBNKVv0KHS8ebFFe/bQDm+PJRSbmmtg53Nrai30s89/9Uug/t7e0EynQkSZOzgiyYA/4sx 5j1lMXlRCPHfAzwBwwPQIqIusNikq4ZAjDFQShnf9y8PBwMeDfdPFYVu5Fm2brT5q0KIu5WnSIpF NuGrY60WVp2HbzugsMDiwiOlggeCFtpKCdn2sZkZYRii3+9br440R+VvXT0fAMIwQhBGG1LKa8vn pjwOFkJIIroE4C8AeLHVaV9jRrG/tzcg61p33QsjABALEM9L67zVYXddFwW/6l0Di8JvN1DlfIPR jvhX7oTVfkB5ISPYkGWyToTL8Wv2/soSYFG8tWawEYiigJrN5rTdbn9y7fjJX2/3+19TSjlNtuMA rnjfJoiQkBD3GGP+82Q2+9s729thu9MZh1F04B9lnuVqNpv9gCD6T2ALkSSi72NrkQlmbmmtw92d nU46S2rMTIdXjZURUblJFwD4WJqmu8aYCIAvpYzCMHwgjmMvjiJkiQ+ibL4xt/x1+DZgyfZTEJYz KedUKSogFLlGUWiEgQ9TZkTW6/W5H0p5dqp1MAAgDEMEQbArhNy93rkMwtC0u93d/b29LzeaTVOr N3Qym0lmjoUQdL3hnfn3Upp46LdT/u/CPbF6zEJLXraOpITnedA6hJEFjMnnhR2wSTOVhNpwqXKp PmEc2huwL7W4cCnlIfDjotPpPnLq7rs/UYtrfxjVG895vu/UI45X4Yr37cMAmBHR1BjTHu0PawRs AJiFUbTcnCUieghEH72emkII0WDmj05H45SZJQnx3uqJVXFd1joD8I0x31fptaterJQSYRii1WpB 5zPk6T7AgBQSSqr561rZWpU2Xm1Iln1uXqhO7O0MrnrfpTqDCw3peTAwyHQOkoS4HiOMAgxHo7Ld YvvOVSFLkgRseMsUxSQZj1tBrbZfnYs0SWSapB4AVW82i3qrmSulmGeMsmoHyyf9enpwPviAxXs4 dK9tq+AyMb4giBIhZeZH0fca0EmQRJLMIEs5o22Z2GJsx/zzRQtFLGvVy2gwrnxdAMMMRUA9rl9c XT3+mdX19d9bO37iV0mIt7z5kuPGuOJ9m1DK47hW+4Ix5rHZdHqPMeZ9o+HovFRqEEbR9NDDD5jx LAfsCiGOEdFPVEG6VXEiInjewryquk0pVU4LirlH9Gw2m8vYGs0mjE4x2suQpmmZFq7m0jop7KAI sLgoAJgX8AM67/I+U110yEZvBUGE6XgGEjmEr9DqtLB6bBW7e3vz46ByeEVrjWtXNzAZj9fzWfK2 Is+3glptiLKq5lkuxqNRqJRS/bXVnSqliOzk4BaAzzGzD+AdAFoHCzeDSWAebb40IFPdv5BBAmzM BjP/lhD4RyoIdos8n/lC/k0S8s9qNutJmkASYMiAuQC4sNOWbFDkGYiE9TAhgZyLMmBClu/TwBhA SgFPKoRRbbfbX/tXJ06f/T97aysvfHN/ZY63Eq543ybiei2PanFeFEV25eIrXBTFXzLG/Fs2/CSs WqJiITbG9T07DnOj4ZXDOudqfLwq4sYYeEqh2WxCcIr9weCAtlmWU4Gm+m+xUJtQudO2PBlZfdcw ZX6jLjfz9PzYpVXg4F3334eNK9ewub0FKQlKKGRZhqIocPXqVWxubv61LMtrtTD8b43W85zFWqOe x/XawHp6LL9foYRS5wn4IWOMYOafAfD9AOKlR5Vbo4uBosXz7f2wLnpDwBgi+n+klL8Y12pXOv3O bHdzJ0qT9O8SIRdCfEwqERdJQUWRw+gC2miIMmbMtlrspxVdJfLwwvu8GkaKwphbrda411v57ROn zvxqd7X/4o02sx2OZVzxvk0s9TpNqTgRYNQMm/DQxlgC68q2mF1Z4vUU8+pnVd/nAyJlerosdcpa a/i+D99rACbFZDqzHtck5j7RJCUIthiJKhvxgL57cYiLPq5G6R1rvVCY59+ZgU6ng/e+5724cvEK prMZxuMRIBme5yHPc1y+chXPPXfB+8CHvh29Uyey7c3NWm9ldao89arNyOr9R7U498NgaIzBzuZm rciLnwCwC+AvHTyH1y3cvHT8GwD+CkjsCMao1qjttPvdqZSSu6v96WBnR4+H+W9KKetKyv+GyRCV 05I20MFudvplUjsAsGZII6G19eQGETzlcxjG6HR6095K/+8dP3nmnzdb7RfIeY44XieueN9+TDl1 KZjZS6Yzf7C7F7Q77RR2tawA/AYzhwD+xo2K841uP3x/teG2nKa+/EXC5lAu98Sr5JaqgDNbg6nD /ibL3yuICAIMWfa+bdxY2QNnRl7k8DwPd99zNz78kW+H1hqPP/EExuMRfN9HoW0I8WOPPYb3PP7E sWPH19/VaLUuiOuYajEzBrt7YRiFRRTHhT2ljG6/Pxvs7l5Nk/RnywvlX7fHhlJdsli1l/r0n2Pm L8BOcu4S0eeb3eZAeUooT5lSUw/lKW522hmA59Ise3KxD2B1mnayVEMIr5Rblhp5AgJipFkOYxhK KtRrDXQ6vfO9ldWfXls/+Xv1RvOSlMplNDpeN/LjH//4UR/DWwo2hsajkTLGsBDiCTC/RERprdHI ys1AYYzeyvP8MoCqd+tfr1i+VgE/0KNeWrFWLRNrHqVQFBkm431kWQalFHzPg5wbI8l577waAX/V ROVhyaAgQNhpTOuWx+VUo20hMDPCKMRqr48g8DEajbC3N0CeW+vZXBfIsxyB70cnjh/nM/fe82+J CMPB/prW2vN8P6ne//7ubiiVMkEY6up9Ks9jIaQwRm8VefFKqdh5L6x3KsrV9y4RfgHA5wB8KozD 368364+GcXg+jMKi1qzlQRjMgy4qpFJcFIUZj4bvTJLpn9TphHQZ1MxsQAKQyp5X+96tpwoItgfu B6jXG8mx9ZN/ePrsPT/T7fV/o95ob0kp3Yrb8Q3hVt63GRKC43p9GIThzzHY04Wm5Y/Kcb2WkyDF jBfSJPlZAD/AzPXDWmjg+r3uiuXHLWuMqxW47y8CaWdZhiRNIaS0aTrSJpMTlixVq5H5g43msod8 6LVhyrR0KwK0r68gDCPLDPIiRxAEWF9fxwe+7QOYTqcYDUc4//T5uVzv2rVr+Px/+Pxda+vrP7x6 5uQXT5w8+Xt5ngfLI5lEhDCOC5s0dJC4XstB8Jj5uSzN/lcAHVhflA6AiyD6f4nwv4VROCEiEzdi HdfjapLm60rzmFna312OLE1Q5En5icVa5ApBANnBHF1GrIEI9biGMK5tdHsrn18/ceaTvZVj//Lr vY7D8fVwxfs2I4Tgbr83T5GfjMb+eDj0lx8TRlEBoNjauKaZed7nXVaXAK+98gYw36gUhzYbq+Kd ZRnyQkMbQCofnh8ceA0hpd1wJAGQnCtKlnnVJaTKgKw2NUuTK2Iunfbs9GeWZ+j3+3j/+9+HaxvX 8Morr2A2S0EgFLnBhQsv4t/8m995W73b+sSf+uE//cP9lZUvSCkPKHPa3U5y+OUrojjOhRByd3tn WxfFx5j5t0H4AIj+gAT9D77vU2elc8Be9/XBIRtTM8YgLYu3lNKaeJV7AsZoaLOw2xVSmVartdvt r/7GsRN3/Xy92Xn0G3tNh+MgzuT3NnO4zVAZFB1+zPL4+eG2BPD6CndV7JdX7TZEwJvHcGltcxwP D+ZUvfJlS9iqB/5aX7K0M7WKlNJDW9iVu/AUhLJSxMl4jMlkgk6ni3e/+0Hcf/85xFEMKQSUlJgl M5x/+jx9+tOf7n7u4Yf/2WBv748ZYzzmuW3Aq87L4fMYhKHura5MhdVMpyCaAZz7vtK9te5UKvl1 JzKvd061Ng1jTJeIIKkytrKhxCCeJ9ITEYLA50ajbrrd7m6/v/oLJ07f8zO1RvtJpyZxfKu4lffR o5g5ImB8o/sP97srB7x5Aa96F4RSigagLNTVaruSDFZ6byEkiqIK2DUHAgysk96ieB+esFzmehcR JQmaTZmmAwhh/bAZVokhFSE3tg+8PxjA9wOcOXMGD73//XjpxZeRzGbWxRCE2XSGZ555Rjz26GO9 Vqv9906dOvVAf6X/iW6/v/F6Tm51EWIgA/OPg7gOqweXUtrC/Y0w2N1tDvcHXWYOhLRZlUZnpWTF Fm7DAAkJJX3EcUzNZvP5erPzqdXjd/9yGNdf/mYj8ByOZVzxPmoYns7zxmB3b9xstxJZKhvAHJhC CwA/AyH+ihC0Pi/YBvCUX64Cq1WeHemupvqEsJak5Y3zYu5JCVWG5s6mE0zGI2RZDqFsgov01HyV LIUEpIAQPLeIJTogQp8X5Wo+3NpX2XBe61tS3Y9yqpCgSICksqZ60l5EgjDEuQfux6XLl/DFL3wR W9vbYGMgAMwGu/jiw59BPhm+40Mf+vY/3/jgB/dMt/N/jQd7rbjRGqfpjACgVm/mxhgMh4NQF8V8 YFKQQKvTnhHwhbLJI6SU39SnzjzLwjzJvgtM/6kgRfAFyJRBFlXeJCSCMEaz0f7/+qvrn2l3e895 fvBoVGu86FbcjpuFK95HDBEZU2g9GY78erORyrI2SqVQa9R3J6PJJ62uj34UwDtgP5lDlEqG0o4a 1aQ6uPKTLvMOjS2idlLSqkXYGORZhixNUWSZLexlgK70PDsOv1RkqFKYVCP3h3rutDS+D2YQaUhe JJoDAAu24/REgJDWedBo1OIYSZqAjcHKSh8f/vCHMBoN8ZWvfBXD0QhSAiZL8MLT56HYYLXXfftd Z+/6481W+5+BwWT9X6hqpZSvdvAcC8H1Us1TUsbYfBO/LwhNoLeB8W4iAU0EIwmmDEsWpCBVYGqN zsXV46d/ZWXt+D8Po9h5kzhuOk4qeMQYrY3RJvN8X0e1OK9SwaWSOoiikS6K3GjzWQYCML+DmVvV hJ7WdjNy2WzJ1vmlCchyMrJqfzBsuG6WZlaaB4aQEspTB7TdVR940cc+eHvF4b6zfb1qQrC6rfJZ sWoVJtv2KYqiBedq8gAAEy1JREFUTFwnFKVlaqvVAjPj2rVrGAwGABim0PNPA2EYU6NRz9ut5tVW f+UpMIwXhCYIo6J6/TCMiziu2a9arQijqLhZK97ZZCKTJPmOvCi+Pc9TZPkYRZ7DaAZBwPMDE8e1 /Xar8ytr66f/RVxvbN+UF3Y4DuFW3kdMEEVFPwyLcgfuwH1CCHRXV2Y7m1vRdDL5RWNMwsz/MzMD LImBGoisUoUZhlGuxu02qIQNqSVpo8yYDYpcI0lTpGkKwwbK8+AJO2VyPZvX691WcWDYZ7mggwE2 IFR5lwAbWf63DUSAWIzwV98LrdFutvCud70TL7zwAra2NrGzvQ3BQJJmuHZtE08+9ST6qyvn1k+c +Kkgir7A4LTZ64/qjdaN9gy+JWyYgl3VCyG43J5kbTQ0M4TwIIQPZg2pPA7COGk0Wo+2Wu1f8jz1 4q04JocDcMX7yHkttQQRodPvJSQEj4fD3yYiKzFjjgD8pBDiI7zUdy73Lqm6jYElb5MCeZ4jz/O5 9lspZT23xfVfe2n1Pd/cW5Iq0qssV5khyigv+9yyQAuGAUEYghECQgKBH1gHwXKqM8sy7I/2UW80 cP/99+HKlcsY7g+gc7sqz7IcW5vbuHjxFbk/HPnNXn+2v7fbM9oY3HjD91tiNp2pvd3dSElpStXK jIiy6tz4XggBAcPMyve5Vmu81Gi0P9FZWX/JCyLnCui4Zbji/QZAKcWtdiuL4/gVEF5hw2J3e7ev c/13iKjHxMoYEwPoEon/EoR7Dk9UFkUxL96V6mTeDpHCtjKA+RDP4bYJEf0jIvoigJyI7gbwt8tR /gOWtfaHoHQaXOp5wypYSBIEaxv75QtrnQoDz5PIc4HReIRaHOPM2dN493sexPb2Jl668DK0NhCC kWUZxuMJZrPEKD/Iuiurr0il8lt17v3A1+1uJyESLOwUpCYiMz93FMLzQggpLnt+8Llmo/27q+sn fjcI49H11DkOx83CFe83CJ7vG8/35ys5Y3hfa/3vCCgAkNY6Hgz236W1+aHFpiWAUiJoR+K1HVWX pXJElJuQQkAIzI2rAPwHAE8IIbQQlJE1y/r1KIofFVKa6WR8CuCISATM/P1EdO7ARGc1Ds6VvJFB ZJNmbNhuGcRrcihPwbCGMQTP9yClQF5kiGsR3v7Oe7G5eQ1bG1uYTGcweQEvybC/P8S1jWvh3ubW /SvH178kpUxv1XlXnsfK8+YXh0Lr1bwoOoW2kkAlAviB92Xf9/91rd74/Xa390Rcb+7dquNxOCpc 8b7DYWakSRIUWldm3ZqIUGvUJksrO9ZaZ4Ph0NO5fdxc011qt03ZRiEp5tpnYHmFPX/JrzDzz/u+ /++CIJwR0QxEMzCreqMlpA133Abwt9I0gdb6DIBzy8dMZYoOQBCmTGYvV95Lwe3IMw1SAsIooCgg pUAUhZjNZiACVlb7eODBc7jwzAt45rnnkWQpMJ1g4+oGnnryqfYDT53/aLPTvhjX6xdvzdlfwMxI kkTNkuRsmmXH86IAM4xU/rOBH36y3mz8q1ane7HWaN7qQ3E4ALji/YZgOBzVZrNpu/QVmQkh2Du2 lvu+XwB2xZxluWTDYMYGwB3YxHVmZklELIQwRFavVxbsylOFqw6LlHLKzH9TSvlIs9UZNpvt4dJh zAdLev21GTNja/NqpLXeAnCBiGJmXgcAIgkIO2RzUFpoQEzQsOZ5lduhlNJmXJpiLmcsigJxHOHs XXfhve95H65tbmNzewtZnuPqxga+9sjXmvffd+7P3Hv//b8cxvFlIcQtdeRjwxju7/tZmgZCiJGU 8pKSat/3vF+JovrvtDv9S1G9disPweE4gCvebwB6/d4ec3cfKHNrbC963kLJskzsbG3HDC48T/0d IURKRGMA2hjTF0IkRDQmQTkRg5kFbEhBQkTFwjqFwcy63ekNarXG5LWMr4hICCH+DwB/1xjzYSL6 pwC8+fJaCAkmj7hKApJWk166u0ZxjNl0Wk59Slh3PquAYaMhJKHVbuPcgw/gsSeewGw2w3SWYDpL 8NLLL9Ozzz0rX3nhxQebreb5uFHfvEWnH4DVuvdXVmYAHhFD8dPM/KtElAhDcXdtdS+KI+MGcBy3 E1e873DKFgcDuOHK0vd801/tD5n5PABNoMImIoCZ+UUCGRB0NRxZdqclbHQYH3CWYvaU5+sqXuzr HVe705sx83Q6nYjRcPAwEf0QylY3QCmA7wHwUwal4qXc2DT2B4AE4AWedd8rGF4YoAa2OvQsQ641 SAL33vt2fOd3fie00Xj2ueeR6wJpmuHRRx/lH/jBH8xux7h59Xvo9nrjVqv1FAPPkt2aDfwgGF/P sMvhuJW44v0mQEiBUIYFri+Xu9F0340uBq9LuWGdCQMDWP0zgO3xaP+zAKPZaKdZnvN0OjltV/rV BaMy4aLSwIlt5qOhuWyRgwAMQBuDItUotEYUeLjvvvtwdeMqNre3Mbl6BVpr7O7teVtbWz+SpelT YS1++PUc97eK53nseV6GxXm9oauhw3ErcROWjm8ZKSV7nmfAUL4fUqPZKgwbmSbTJhF1AZwlsguF uXyQAWZdtsMX05hgwBiG0cYGGWgGa0aj2YIQAltbm7h2bQNGG8RxJNaOrd3Varf9eqNxJYyiS0d0 ChyO244r3o6bghASURQXURQXpWOhV+j8kmFznkA/AnB0uCN80JHQhvOCCWy4sgS3FgCFRrvTRrPV xGg0wqXLl7A/2gcB0EZjOpk8WIvi3trx9a9IpfZc79nxVsC1TRy3hDiuZwBod29LsgCIycpaqgcI AWEE+FCrWBiGVArK0zBswIahjUaWpVhbW8W7H3wA588/iatXrmAyGePxxx7DaDiE53l/YmVlJb/3 /nd9VCqVuALueLPjdlkct4TpdOSPxntBFTZvh3PKQB5R5WvK+ReRBCBAQkJIBaV8eF6AIAjh+R6y LLXSwbvP4uzZs/B9D8yM3cEennv+OTzyyFeiJx9//NTO1Y2a0S7H1/HmxxVvx02FmTEa7wWT2X5h OP82EP/vRKihlLpUPW8SAIQAQYIg7BcJCJI2iUcpKM+HUh5IEAwY2hjU63V0ux14noKUAmCDZDbF xtWr9OKLL6wPB4M/yQz/tY7T4Xij44q346aT5TOv0OkPEtFPAvzdAPsLvUlFOXdp7RRLL+zSb6Vc jUtZZmYSQ0hCks4gpUCz2YTneQAYkqxv+GQyxsbVK6tXr175ry9ffOnjaZLcdQRv3eG4bbji7bjp MNhj8DsYHAH4AsjkKPMd7f1LbodcjnjOo9YWOZlVUbf5mQJpmkJ5Cr1eF1EUodA2sYeNwXg0wqVX LsZPn3/qg1/9oy/+5OVXXv5zWZqeOrqz4HDcWtyGpeOmI6UipbxfBuMT2hT3M+i3AG4ffhyzmYdI ENnoNpCNSqNyRS2kQBD60FpDcwE/9NDpttFoNrGxuV2G/RoM94e48PwFNBpN9FZWWBv+MaW84YlT Z/6JkCJ3G5iONxuueDtuOq16f4+ZB2k65f39rQmzYVE6jRvYUXmwAaABMuUQzyJMmaWB8BlSEKAE jPZgcoIBIclzMAl0O1144iVkWkNBATlh49I1PLz/WayurSNLuF8LO99WC5t/0D3We/woz4fDcStw xdtxU7ErZskAWAgJlG1tc8Dzu5yzLPvdXHqfLOB5kIPt7ElIw9C5gTEGURSh3+tDCgGPJAhAVmQo TIEszzGdZeT5oTx58vSfuOftb9vtrfc/drvev8Nxu3A9b8cthAH7NxbMb1kq0oczMavEn3mwMS3a J5WFbVW8V9dWy164BJGAhkFhNPI8x/5ogGeffxaPPf5Y/8KFC/cM9/ZFFTLhcLxZcMXbcSshgAcA fhPAaHHzweIMHMzDnD+5vN8YA0EEKQWM0fA8D2tra/A8bx78IMgm3jPZFszu3i6eff45PPPssyvb W9vfbYxx8kHHmwpXvB23DCIpPC+8TEQ/RSR+l4gG8xT5MmJteSOxqtvMmN8PENgYsDZQQoK1gRQC KysrqNXryE0Bbex9wk7/QEkfpizgG1ev3jseT/4C28xPh+NNgyvejluG74e61VqZKuUPiMR/RyQ/ TSRnRGIxUUmL6crKoMoWdFvkBQkIImit5ynzSkmsrKxg/fhxBGEIw3aAR4OR6xxaF5Ak4UkPJIQA OADg5CaONxWueDtuGdbm1TedztrY94NdIvr7RPTLh1fch5619GUj1ZTywGzm4chKeej3+3jggXO4 6/QZBGEAzQZEBA0DbTTarTbuuusunDl9+rlGo/GLgmh6W960w3GbcMXbcUshInheYFqt/iwM4+eJ 6OpiCAcHNievt4EJAFLaqUtjDHTpWxLXa3jooYfwH3/kIzh18hRICDADSii02m3cf//9eOgDH8Dd 99yzF/jBEyTELUuYdziOAicVdNwWgiDSSnkawJcA/BOAQ2buAvgQgNXDK/GqcFffPd9DMs2g2SCn HJ4McO7cOXTaXVy6dAUvX3wFWZbC8wKsrx/HQw89hPe9973o9Xrt6Wz6wGB3L2u2WztKKeda5XhT 4Iq347bheYGO4/pnmPE5ZlOfTif3MBcnheBVwIYwANYG9kDMPFO5GQkUeYE8LxB4jPVj62jUm1g/ fhye5yHJUsRxjHvffi/uP3cOJ0+dgB8EZ5Ik+ej25qYX1+I/UEqNbniADscbCFe8HbeNWq2Z1WrN DACM0ftFflkT0ueNUfdqrZsaGlprMAyodEAhso6CeVGAQMiLArNZgtTP0Zy2EQYRwrgG5QdQaYZO v48HHnw3jp86Di/woBT1pae+N03Ty2maPuX7/lRI6Vbfjjc8ruftuG0shm4IAFgIMSYS/yMR/ToR ZUSUCyF4ufdNgkBU9scBoBzkybIcs+kMWZYjiiI0m000Gg0cP3kC68fX0Wq14HkeGCCttdRatzcu X3n/eDRePcJT4HDcNNzK23EkCCG5012ZDPa289ls+gki+rwQ4m4AP45yItMO7ZjSA9yOy9uNSUaa JhhPJwjjGlaPHcMD734QhdY4d+4czp49i2ajAQaQFzkEiZZS6vvzPN8rdPEYgKtH+d4djpuBK96O I4GIEAShbra6WRzXv5amyTPD4eAegGIAfxFAh7nMsoRNuJSlxzfAyLMcSZpmUqmfO3v32Q+B6ANB EOQnTpz4o2PHjn1WeV6WF0VHSqk9T12RUoo8z/cJ5ObkHW8KXPF2HClRFGtE8SzI0twYfnEyGX0S gE8k/jNjzAmGdRMURKiqbrmtCQbrRqv5S/edu/+Pzt5z9/f4QbAfBMHni6z4KjOPoziKgjDIpBSX GCyG+8N3CEF7R/h2HY6bhivejjsC3w+Kbm9lj9mI2Wz2D7QuNBH9aSasQylkWQatNYqiAAB4vsd+ GKTNbptarfanAHwKsMZVW1c3Txtt8manuVVr1AsAYGYD4EXlecWRvUmH4ybiirfjjkFKqfsrx7a3 tzYwm03/sTYmJeAnSNk/06IoUOgCQkrUgyhrNBpPSSEnyz+DiLCyvvpK+f+XfWbR6fVcqrzjTYNT mzjuGMopS9Prr+7EtfpVIoyrYlt9F0IgiiN0ut3tbqf7D5RSr1znZ7AQgpcL9fWMsByONzKueDvu KKwfiqelkJJA/x6EnzXG5ID19PZ9H7U4vtbpdH7z2IkTD3u+Pz7qY3Y4jgJXvB13JFEUZ1FUe5oN f4mZjdYGhhmeF+y0273fP7Z+4v+uN5o7Ukp+7Z/mcLz5cMXbcUcS1+qzKK7lxnAEgIpCQ2uGVN7l ZrP9mU5v5REicpOSjrcsrng77lgIlBLRmJm5GtKRUg6FELtHfWwOx1HjirfjjoWIZrZQExMRpFIc +P4lz/MuHPWxORxHjSvejjsXAtvWiG1rKymvdnr9L3Z6K88e8ZE5HEeO03k77miYmQ1zqUJRF8Io etYPApeK43jL41bejjsXhmLmiA2TTeTxXpJCbh31YTkcdwKueDvuWAybWGu9wmyo1H9fllJuH/Vx ORx3Aq54O+5YmLmmte4YwxoAKyWvCOmUJg4H4Iq34w6GmUNjDBj8NBGlQshdInIxZg4HXPF23MHU arXNldW1rwqiLaWUAbjLhutHfVwOx52AK96OOxbfDyb1euOiEGIqhDDGcMewccXb4YAr3o47HjZC yj0iwBjdZsPxUR+Rw3En4Iq3445GkJj6nveMEGJLG7OSF/mq1loe9XE5HEeNG9Jx3NEIIYZhGP6h MSyzojixv7f7dknyxd7qmgsRdrylcStvxx2N8v2ku7J+3vfDRwm4L8+y78qy9NhRH5fDcdS4lbfj jkYIaYIwHinPuyqk7BrDBQPRUR+Xw3HUuOLtuONhMEsptzylHtbaJIJo8trPcjje3Lji7XgDQCwE DZRSn/B8KYIwvHbUR+RwHDWueDvueAiAEJKV511tNDvTerO9f9TH5HAcNcTsIgAddzbMDF3kgpmF kMpIKc1RH5PDcdQ4tYnjjoeIoDzfJFki0ixxf7MOB1zxdrxBYGbMppM4S5PgqI/F4bgTcMXb8UZC wv3NOhwA3Ial440EUQIifdSH4XDcCfz/a8zMyDyOa/8AAAAASUVORK5CYII= "
+       height="1771.6536"
+       width="1771.6536" />
+  </g>
+</svg>

diff --git a/ogre.appcache.in b/ogre.appcache.in
new file mode 100644 (file)
index 0000000..460bc23
--- /dev/null
+++ b/ogre.appcache.in
@@ -0,0 +1,19 @@
+CACHE MANIFEST
+# <Last-Updated>
+
+ogre.html
+ogre.css
+
+Checkbook.woff
+DejaVuSansMono.woff
+FiraSans-Regular.woff
+
+fastclick.js
+ogre.js
+units.js
+
+favicon.ico
+favicon_32.png
+favicon_128.png
+favicon_196.png
+favicon_256.png

diff --git a/ogre.css b/ogre.css
new file mode 100644 (file)
index 0000000..fe9dcaf
--- /dev/null
+++ b/ogre.css
@@ -0,0 +1,412 @@
+@font-face {
+    font-family: Digital;
+    font-style: normal;
+    font-weight: 400;
+    src: url('Checkbook.woff') format('woff');
+}
+
+@font-face {
+    font-family: Sans;
+    font-style: normal;
+    font-weight: 400;
+    src: url('FiraSans-Regular.woff') format('woff');
+}
+
+@font-face {
+    font-family: Mono;
+    font-style: normal;
+    font-weight: 400;
+    src: url('DejaVuSansMono.woff') format('woff');
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    font-weight: normal;
+    text-decoration: none;
+    list-style-type: none;
+    font-style: normal;
+    cursor: default;
+}
+
+html {
+    font-size: 18px;
+    font-family: Sans, sans-serif;
+    text-align: center;
+    color: black;
+    background-color: white;
+}
+
+header, nav, main, section {
+    display: block;
+}
+
+body, nav, .tray {
+    user-select: none;
+    -moz-user-select: none;
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+}
+
+h1 {
+    font-family: Digital, Sans, sans-serif;
+    font-size: 2em;
+    white-space: nowrap;
+}
+
+body [href], body [onclick], .ticks, input, label {
+    cursor: pointer;
+}
+
+a[href] {
+    color: red;
+    text-decoration: underline;
+}
+
+header {
+    top: 0;
+    position: fixed;
+    left: 0;
+    right: 0;
+    display: block;
+    background-color: black;
+    font-family: Digital, Sans, sans-serif;
+    color: white;
+    z-index: 2;
+    height: 1em;
+    line-height: 1em;
+    font-size: 2.5em;
+}
+
+header h1 {
+    font-size: 0.75em;
+}
+
+nav {
+    padding: 0 8px;
+}
+
+body { padding-top: 2.5em; }
+.standalone header { padding-top: 20px; }
+.standalone { margin-top: 20px; }
+
+
+body [onclick]:hover, body [onclick]:active,
+body [data-tray]:hover, body [data-tray]:active,
+label:hover, label:active,
+#addUnit li:hover {
+    color: red;
+    cursor: pointer;
+}
+
+section {
+    border: solid black 1px;
+    margin: 2em 3em;
+    padding: 0.25em 2em;
+    position: relative;
+}
+
+.close {
+    font-family: Mono, monospace;
+    line-height: 1em;
+    position: absolute;
+    font-size: 2.5em;
+    width: 1em;
+    height: 1em;
+    top: 0;
+    left: 0;
+}
+
+.close:after { content: "✕"; }
+
+section > .name {
+    line-height: 1em;
+    font-family: Digital, Sans, sans-serif;
+    font-size: 1.5em;
+    white-space: nowrap;
+}
+
+section > .aside {
+    display: block;
+    font-size: 0.75em;
+    padding-top: 0.5em;
+    font-family: Sans, sans-serif;
+    
+}
+
+.weapons > li:before {
+    content: attr(data-remaining) " " attr(data-name);
+    display: block;
+    width: 100%;
+    text-align: center;
+    font-size: 0.9em;
+    font-family: Mono, monospace;
+}
+
+.weapons > li[data-count="1"]:before {
+    content: attr(data-name);
+}
+
+section > .type {
+    font-family: Mono, monospace;
+    font-variant: small-caps;
+}
+
+.stats { font-variant: small-caps; }
+.stats > li {
+    display: inline-block;
+    padding: 0 0.25em;
+    font-family: Mono, monospace;
+}
+.stats > li:before { font-size: 0.75em; font-family: Sans, sans-serif; }
+.stats > .attack:before { content: "Atk "; }
+.stats > .defense:before { content: "Def "; }
+.stats > .range:before { content: "Rng "; }
+.stats > .aside {
+    display: block;
+    font-variant: normal;
+    text-transform: none;
+    font-size: 0.75em;
+    font-family: Sans, sans-serif;
+}
+
+.weapons {
+    display: -webkit-flex;
+    display: flex;
+    flex-wrap: wrap;
+    -webkit-flex-wrap: wrap;
+    flex-direction: row;
+    -webkit-flex-direction: row;
+    justify-content: space-around;
+    -webkit-justify-content: space-around;
+    align-items: flex-end;
+    -webkit-align-items: flex-end;
+    align-content: center;
+    -webkit-align-content: center;
+}
+
+.weapons > li {
+    display: inline-block;
+    margin: 1em 0.75em;
+    margin-bottom: 0em;
+    flex-grow: 1;
+    -webkit-box-flex: 1;
+    -webkit-flex-grow: 1;
+}
+
+.ticks {
+    display: inline-block;
+    font-size: 2em;
+    font-family: Mono, monospace;
+    line-height: 0.75em;
+}
+
+[data-remaining="0"] .ticks {
+    color: red;
+}
+
+.treads {
+    margin: 0.5em auto;
+    padding: 0 1em;
+    padding-right: 1.5em;
+    list-style-type: none;
+    display: inline-block;
+}
+
+[data-remaining="0"]:before {
+    text-decoration: line-through;
+    color: red;
+}
+
+.treads:before {
+    content: attr(data-remaining) " Tread Units";
+    font-family: Mono, monospace;
+    display: block;
+    margin-top: 0.7em;
+    text-align: center;
+    margin-right: -1.25em;
+}
+
+.treads.propulsion:before {
+    content: attr(data-remaining) " Prop. Units";
+}
+
+.treads > li {
+    text-align: right;
+    display: block;
+    line-height: 0.75em;
+}
+
+.treads > li:after {
+    margin-right: -1em;
+    font-size: 0.5em;
+    width: 1em;
+    display: inline-block;
+    font-family: Mono, monospace;
+    vertical-align: 0.125em;
+}
+
+.ticks > span {
+    display: inline-block;
+    padding: 0 0.111em;
+    height: 0.75em;
+    overflow: hidden;
+    cursor: pointer;
+}
+
+.treads > li:first-child:before {
+    content: "Move starts at";
+    font-family: Sans, sans-serif;
+    font-size: 0.75em;
+    display: inline-block;
+    font-variant: small-caps;
+    vertical-align: 0.25em;
+    margin-right: -0.125em;
+}
+.treads.propulsion > li:first-child:before {
+    content: "Must move";
+}
+.treads > li:first-child:after { font-size: 1em; }
+
+.treads > li:first-child:nth-last-child(n+1) { counter-reset: i 1; }
+.treads > li:first-child:nth-last-child(n+2) { counter-reset: i 2; }
+.treads > li:first-child:nth-last-child(n+3) { counter-reset: i 3; }
+.treads > li:first-child:nth-last-child(n+4) { counter-reset: i 4; }
+.treads > li:first-child:nth-last-child(n+5) { counter-reset: i 5; }
+.treads > li:first-child:nth-last-child(n+6) { counter-reset: i 6; }
+.treads > li:after { content: counter(i); counter-increment: i -1; }
+
+#unit-template { display: none; }
+
+.tray {
+    position: fixed;
+    border: solid black 1px;
+    border-top-width: 0;
+    z-index: 1;
+    transition: transform 0.3s;
+    -webkit-transition: -webkit-transform 0.3s;
+    background-color: rgba(255, 255, 255, 0.9412);
+    overflow: auto;
+    max-height: 80%;
+    -webkit-overflow-scrolling: touch;
+}
+
+.tray.visible {
+    transform: translate(0, 0) !important;
+    -webkit-transform: translate(0, 0) !important;
+    transition: transform 0.3s;
+    -webkit-transition: -webkit-transform 0.3s;
+}
+
+#addUnit {
+    transform: translateX(-100%);
+    -webkit-transform: translateX(-100%);
+    font-size: 2em;
+    display: block;
+}
+
+#addUnit > li {
+    display: block;
+    padding: 0.25em;
+    text-align: left;
+    font-family: Digital, Sans, sans-serif;
+    white-space: nowrap;
+    cursor: pointer;
+}
+
+#legal {
+    font-size: 0.8em;
+    left: 40%;
+    right: 0%;
+    transform: translateX(100%);
+    -webkit-transform: translateX(100%);
+    text-align: center;
+    padding-top: 1em;
+}
+
+#legal p {
+    padding: 1em;
+    text-align: justify;
+    text-align-last: center;
+    -moz-text-align-last: center;
+    -webkit-text-align-last: center;
+}
+
+.stats { margin-top: -0.3333em; }
+
+.colophon {
+    font-size: 1.5em;
+    font-family: Digital, Sans, sans-serif;
+    margin-top: 0.25em;
+}
+
+#brain {
+    right: 0em;
+    transform: translateX(100%);
+    -webkit-transform: translateX(100%);
+    padding: 0.5em;
+    text-align: left;
+    overflow: hidden;
+}
+
+#report {
+    font-family: Mono, monospace;
+    white-space: pre;
+}
+
+#howto {
+    left: 25%;
+    right: 25%;
+    max-height: 50%;
+    overflow-y: auto;
+    transform: translateY(-100%);
+    -webkit-transform: translateY(-100%);
+    padding: 0.5em;
+    text-align: left;
+    overflow-y: auto;
+}
+
+@media (max-width: 1023px) {
+    html { font-size: 16px; }
+}
+
+@media (max-width: 768px) {
+    html { font-size: 13px; }
+}
+
+@media (max-width: 640px) {
+    section { margin: 1em; padding: 0.333em; }
+    .weapons > li:before { content: attr(data-name); }
+    .weapons > li { margin: 0.5em 0.5em; margin-bottom: 0; }
+    .stats > .attack:before { content: ""; }
+    .stats > .defense { padding: 0 0.5em; }
+    .stats > .defense:before {
+        content: "D";
+        font-family: Mono, monospace;
+        font-size: 1em;
+    }
+    .weapons .ticks {
+        margin-top: -0.125em;
+    }
+    .stats > .range:before {
+        content: "/";
+        font-family: Mono, monospace;
+        font-size: 1em;
+    }
+    .stats > .aside { display: none; }
+    .stats > li { padding: 0; }
+    .treads { margin: 0 1.5em; min-width: 12em; }
+    .treads:before { margin-bottom: -0.75em; }
+    .treads > li:first-child:before {
+        content: "M";
+        font-family: Mono, monospace;
+        font-size: 1em;
+        vertical-align: 0.125em;
+    }
+}
+
+@media (max-width: 480px) {
+    html { font-size: 11px; }
+    section > .type, section > .aside { display: none; }
+}
+

diff --git a/ogre.html b/ogre.html
new file mode 100644 (file)
index 0000000..bcdb0f5
--- /dev/null
+++ b/ogre.html
@@ -0,0 +1,173 @@
+<!DOCTYPE html>
+<html manifest="ogre.appcache">
+  <!--
+  The person who associated a work with this deed has dedicated the work
+  to the public domain by waiving all of his or her rights to the work
+  worldwide under copyright law, including all related and neighboring
+  rights, to the extent allowed by law.
+
+  You can copy, modify, distribute and perform the work, even for
+  commercial purposes, all without asking permission.
+
+  See https://creativecommons.org/publicdomain/zero/1.0/ for details.
+  -->
+  <head>
+    <meta charset="utf-8">
+    <meta name=viewport content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1, user-scalable=no, minimal-ui">
+    <meta name=description content="Digital record sheets for Steve Jackson's Ogre boardgame.">
+    <meta name=apple-mobile-web-app-status-bar-style content=black-translucent>
+    <meta name=apple-mobile-web-app-capable content=yes>
+    <meta name=apple-mobile-web-app-title content=Ogre>
+    <meta name=mobile-web-app-capable content=yes>
+    <link rel=icon sizes=32x32 href=favicon_32.png>
+    <link rel=icon sizes='16x16 32x32 48x48' href=favicon.ico>
+    <link rel=icon sizes=128x128 href=favicon_128.png>
+    <link rel=icon sizes=196x196 href=favicon_196.png>
+    <link rel=icon sizes=256x256 href=favicon_256.png>
+    <link rel=apple-touch-icon href=favicon_192.png>
+    <link rel=stylesheet href=ogre.css>
+    <script src=fastclick.js></script>
+    <script src=units.js></script>
+    <script src=ogre.js></script>
+    <!-- <script src=brain.js></script> -->
+    <title>Ogre Record Sheets</title>
+  </head>
+  <body onclick="boxes(event)">
+    <header>
+      <nav>
+        <div data-tray=addUnit style="float: left">+</div>
+        <h1 data-tray=legal style="float: right">Ogre</h1>
+      </nav>
+    </header>
+    <ul id=addUnit class=tray>
+    </ul>
+    <div id=legal class=tray>
+      <div class=colophon>
+        <a target=_blank href="https://yukkurigames.com">Yukkuri Games</a>
+      </div>
+      <p>
+        <a target=_blank href="http://www.sjgames.com/ogre/">Ogre</a> and
+        its associated names are trademarks of
+        <a target=_blank href="http://www.sjgames.com/">Steve Jackson Games</a>;
+        its rules are copyrighted by Steve Jackson Games. This tool is
+        not affiliated with or authorized by Steve Jackson Games, and
+        uses unofficial adaptations of some Ogre model statistics.
+      </p>
+      <p>
+        Typeset in Fira Sans by
+        <a target=_blank href="http://www.carrois.com/home/">Carrois
+          Type Design</a>,
+        Checkbook by Allen&nbsp;R.&nbsp;Walden, and
+        <a href="http://dejavu-fonts.org/wiki/Main_Page">DejaVu Sans
+        Mono</a>.
+      </p>
+    </div>
+    <!--
+    <div id=brain class=tray>
+      <a data-tray=howto>(what's this?)</a>
+      <div class=brain-movement>
+        <input name=moven type=radio id=move1 checked>
+        <label for=move1>1</label>
+        <input name=moven type=radio id=move2>
+        <label for=move2>2</label>
+        <input name=moven type=radio id=move3>
+        <label for=move3>3</label>
+        <input name=moven type=radio id=move4>
+        <label for=move4>4</label>
+      </div>
+      <div class=missiles>
+        <input type=checkbox id=missiles>
+        <label for=missiles>Missiles</label>
+      </div>
+      <div class=roll onclick="think()">Think</div>
+      <div id=report></div>
+    </div>
+    <div id=howto class=tray>
+      <h1>Automated Ogres</h1>
+      <p>
+        Set up your defensive forces as desired. The Ogre enters
+        directly opposite the CP. Each turn, select the Ogre's
+        available movement points and whether it will ram.
+      </p>
+      <h2>Movement</h2>
+      <p>
+        The Ogre first moves towards the CP ("north"), then if it
+        destroys it, retreats back to the side it started on ("south")
+        to escape off that edge of the map. If the Ogre is on the
+        final three rows of the map, or less than five hexes from the
+        CP, "ahead" refers to the shortest path directly to the goal.
+        Otherwise, it refers to the edge.
+      </p>
+      <p>
+        While moving, the Ogre may decide to ram. If it does, a
+        potential ram overrides other movement commands. It also rams
+        any vehicle in its direct path. The Ogre always re-rams a
+        disabled vehicle in the same space.
+      </p>
+      <p>
+        The Ogre never moves backward, except when it decides to ram
+        backwards. If the Ogre is adjacent to an immobile unit (e.g. a
+        howitzer or CP) it will always ram it.
+      </p>
+      <p>
+        If multiple ramming targets are possible, choose the first in
+        the direction of the sensor sweep.
+      </p>
+      <p>
+        If the Ogre tries to move into a crater or off the edge of the
+        map, choose the first space available in the direction of the
+        sensor sweep.
+      </p>
+      <h2>Attacks</h2>
+      <p>
+        The Ogre always fires AP, then secondary, primary, then
+        (maybe, if possible) missiles. Targeting order is determined
+        by explicit targeting instructions - target priority may go to
+      </p>
+        direction of the sensor sweep.
+      </p>
+      <h2>Priority</h2>
+      <p>
+        The Ogre will always prefer to target CPs, howitzers, and disabled
+        units (in that order). Otherwise, target priority is determined
+        randomly as nearest, farthest, strongest (highest defense) or most
+        threatening (highest attack).
+      </p>
+      <p>
+        Priority is also given an arc (fore or aft). All possible
+        targets in the chosen arc are considered before the other arc.
+        Units on the same line as the Ogre are in both arcs.
+      </p>
+      <p>
+        Finally, priority has a sensor sweep direction - clockwise or
+        anti-clockwise. This determines the order of targets with the
+        same combat statistics, distance, and in the same arc.
+      </p>
+
+      <h2>Suggestions</h2>
+      <ul>
+        <li>Once you find the game too easy, move your CP forward.</li>
+      </ul>
+      <h2>Further Reading</h2>
+      <p>
+        These solitaire play rules are based on
+        <a target=_blank href="http://www.sjgames.com/ogre/articles/uncertain.html">
+          Brian McCue's <em>The Uncertainty Principle</em></a>
+        as well as <em>Solitaire Ogre</em> by George Collins in
+        <em><a target=_blank href="http://www.sjgames.com/ogre/products/ogrebook/">
+          The Ogre Book</a></em>. It expands on the
+        card system suggested by McCue but hews closer to the tactics
+        suggested by Collins.
+      </p>
+    </div>
+    -->
+    <main>
+      <section id=unit-template>
+        <a onclick="removeUnit(this.parentNode)" class=close></a>
+        <div class=name
+             onclick="this.textContent = randomName(UNITS[this.parentNode.getAttribute('data-dfn')].nameScheme)"></div>
+        <div class=type></div>
+      </section>
+    </main>
+  </body>
+</html>

diff --git a/ogre.js b/ogre.js
new file mode 100644 (file)
index 0000000..c670e93
--- /dev/null
+++ b/ogre.js
@@ -0,0 +1,342 @@
+/* The person who associated a work with this deed has dedicated the
+   work to the public domain by waiving all of his or her rights to
+   the work worldwide under copyright law, including all related and
+   neighboring rights, to the extent allowed by law.
+
+   You can copy, modify, distribute and perform the work, even for
+   commercial purposes, all without asking permission.
+
+   See https://creativecommons.org/publicdomain/zero/1.0/ for details.
+*/
+
+"use strict";
+
+if (!String.prototype.repeat)
+    Object.defineProperty(String.prototype, "repeat", {
+        value: function (count) {
+            var string = this.toString();
+            var result = '';
+            var n = count | 0;
+            while (n) {
+                if (n % 2 === 1)
+                    result += string;
+                if (n > 1)
+                    string += string;
+                n >>= 1;
+            }
+            return result;
+        }
+    });
+
+if (!Array.prototype.fill)
+    Object.defineProperty(Array.prototype, "fill", {
+        value: function (value) {
+            var beg = arguments.length > 1 ? +arguments[1] : 0;
+            var end = arguments.length > 2 ? +arguments[2] : this.length;
+            if (beg < 0) beg += this.length;
+            if (end < 0) end += this.length;
+            for (var i = beg; i < end; ++i)
+                this[i] = value;
+            return this;
+        }
+    });
+
+if (!Element.prototype.matches) 
+    Object.defineProperty(Element.prototype, "matches", {
+        value: Element.prototype.matchesSelector
+            || Element.prototype.mozMatchesSelector
+            || Element.prototype.webkitMatchesSelector
+    });
+
+function removeUnit (element) {
+    element.parentNode.removeChild(element);
+}
+
+var EMPTY = "☐";
+var CHECK = "☒";
+var FIRST_EMPTY = /☐/;
+var LAST_TICKED = /☒([^☒]*)$/;
+
+function choice (a) {
+    return a[(Math.random() * a.length) | 0];
+}
+
+function cap (s) {
+    return s && s[0].toUpperCase() + s.slice(1);
+}
+
+function letters (n) {
+    var r = "";
+    n = n || 1;
+    while (n-- > 0)
+        r += choice("abcdefghijklmnopqrstuvwxyz");
+    return r;
+}
+
+function range (a, b) {
+    return a + (Math.random() * (b - a)) | 0;
+}
+
+function numerals (n) {
+    var r = "";
+    n = n || 1;
+    while (n-- > 0)
+        r += choice("0123456789");
+    return r;
+}
+
+function pid () {
+    return letters(range(1, 4)).toUpperCase()
+        + choice(["‑", "", ".", "/"])
+        + numerals(range(1, 4));
+}
+
+function roman () {
+    return choice(["I", "II", "III", "IV", "V", "VI",
+                   "VII", "VIII", "IX", "X", "XI", "XII",
+                   "XIV"]);
+}
+
+function oid () {
+    return choice([letters(1).toUpperCase() + choice("-./") + numerals(2)]);
+}
+
+function randomName (scheme) {
+    switch (scheme) {
+    case "id":
+        return choice([pid() + " " + cap(choice(NOUNS))],
+                      [cap(choice(NOUNS)) + " " + pid()]);
+    case "air":
+        return choice([
+            oid() + " " + cap(choice(ADJECTIVES)) + " " + cap(choice(BIRDS)),
+            cap(choice(ADJECTIVES)) + " " + cap(choice(BIRDS)) + " " + roman()]);
+    default:
+        return choice([
+            oid() + " " + cap(choice(ADJECTIVES)) + " " + cap(choice(NOUNS)),
+            cap(choice(ADJECTIVES)) + " " + cap(choice(NOUNS)) + " " + roman()]);
+    }
+}
+
+var STATS = ["attack", "range", "defense", "aside"];
+function createUnit (dfnName) {
+    var dfn = UNITS[dfnName];
+    var weapons = dfn.weapons || [];
+    var unit = document.getElementById("unit-template").cloneNode(true);
+    unit.removeAttribute('id');
+    unit.setAttribute("data-dfn", dfnName);
+    unit.querySelector(".name").textContent = randomName(dfn.nameScheme);
+    unit.querySelector(".type").textContent = dfnName;
+
+    if (dfn.aside) {
+        var aside = unit.appendChild(document.createElement("div"));
+        aside.className = "aside";
+        aside.innerHTML = dfn.aside;
+    }
+    if (weapons.length) {
+        var weaponList = unit.appendChild(document.createElement('ul'));
+        weaponList.className = "weapons";
+    }
+
+    weapons.forEach(function (weaponRef) {
+        var count = parseInt(weaponRef, 10) || 1;
+        var weaponName = weaponRef.replace(/^[0-9 ]*/, "");
+        var weapon = WEAPONS[weaponName]
+            || WEAPONS[weaponName.replace(/s+$/, "")];
+        var weaponItem = document.createElement("li");
+        weaponItem.setAttribute('data-name', weaponName);
+        weaponItem.setAttribute('data-count', count);
+        weaponItem.setAttribute('data-remaining', count);
+        var stats = document.createElement('ul');
+        stats.className = "stats";
+        for (var j = 0; j < STATS.length; ++j) {
+            if (weapon[STATS[j]] !== undefined) {
+                var stat = document.createElement('li');
+                stat.className = STATS[j];
+                stat.innerHTML = weapon[STATS[j]];
+                stats.appendChild(stat);
+            }
+        }
+        if (stats.children.length)
+            weaponItem.appendChild(stats);
+        var ticks = document.createElement('div');
+        ticks.className = "ticks";
+        ticks.innerHTML = ticksText(count);
+        weaponItem.appendChild(ticks);
+        weaponList.appendChild(weaponItem);
+    });
+
+    if (dfn.tread) {
+        var move = dfn.move || 3;
+        var per = dfn.tread / move;
+        var treads = document.createElement('ol');
+        treads.className = "treads";
+        treads.appendChild(document.createElement("li"));
+        treads.setAttribute('data-count', dfn.tread);
+        treads.setAttribute('data-remaining', dfn.tread);
+        for (var i = 0; i < move; ++i) {
+            var tread = treads.appendChild(document.createElement("li"));
+            tread.className = "ticks";
+            tread.innerHTML = ticksText(per);
+        }
+        unit.appendChild(treads);
+    }
+    if (dfn.propulsion) {
+        var move = dfn.move || 3;
+        var per = dfn.propulsion / move;
+        var treads = document.createElement('ol');
+        treads.className = "treads propulsion";
+        treads.appendChild(document.createElement("li"));
+        treads.setAttribute('data-count', dfn.propulsion);
+        treads.setAttribute('data-remaining', dfn.propulsion);
+        for (var i = 0; i < move; ++i) {
+            var tread = treads.appendChild(document.createElement("li"));
+            tread.className = "ticks";
+            tread.innerHTML = ticksText(per);
+        }
+        unit.appendChild(treads);
+    }
+
+    return unit;
+}
+
+function addUnit (dfnName) {
+    document.querySelector('main').appendChild(createUnit(dfnName));
+}
+
+function spre (c) {
+    return new RegExp("(^|\\s+)" + c + "(\\s+|$)");
+}
+
+function hasClass (e, n) {
+    return !!e.className.match(spre(n));
+}
+
+function addClass (e, n) {
+    if (!hasClass(e, n))
+        e.className += " " + n;
+}
+
+function removeClass (e, n) {
+    e.className = e.className.replace(spre(n), "");
+}
+
+function show (id) {
+    addClass(document.getElementById(id.id || id), "visible");
+}
+function hide (id) {
+    removeClass(document.getElementById(id.id || id), "visible");
+}
+function handleTray (evt) {
+    var id = this.getAttribute('data-tray');
+    var el = document.getElementById(id);
+    var f = (hasClass(el, "visible") ? hide : show)
+    autoClose();
+    f(el);
+    evt.stopPropagation();
+}
+
+function ticksText (n) {
+    var blocks = [EMPTY.repeat(n)];
+    for (var i = 5; i >= 2; --i) {
+        if (n > i && n % i === 0) {
+            blocks = (new Array(n / i)).fill(EMPTY.repeat(i));
+            break;
+        }
+    }
+    return "<span>" + blocks.join("</span><wbr><span>") + "</span>";
+}
+
+function rub (content) {
+    return content.replace(LAST_TICKED, EMPTY + "$1");
+}
+function tick (content) {
+    return content.replace(FIRST_EMPTY, CHECK);
+}
+
+function findParent (el, selector) {
+    while (el && el !== document && !el.matches(selector))
+        el = el.parentNode;
+    return el === document ? null : el;
+}
+
+function boxes (event) {
+    var target = event.target;
+    if (!target.innerHTML.match(/☐|☒/))
+        return;
+    var par = findParent(target, '[data-count]');
+    var ticks = findParent(target, '.ticks');
+    if (!ticks || !par)
+        return;
+    var content = target.innerHTML;
+    var rect = target.getBoundingClientRect();
+    var total = target.innerHTML.match(/☐|☒/g);
+    var ticked = target.innerHTML.match(/☒/g);
+    var p = (event.clientX - rect.left) / rect.width;
+    var pr = (total && total.length)
+        ? (ticked ? ticked.length : 0) / total.length : 0;
+    par.innerHTML = ((p < pr) ? rub : tick)(par.innerHTML);
+    var rem = par.innerHTML.match(/☐/g);
+    par.setAttribute('data-remaining', rem ? rem.length : 0);
+    event.preventDefault();
+    event.stopPropagation();
+}
+
+function fade (p) {
+    return p * p * p * (p * (p * 6.0 - 15.0) + 10.0);
+}
+
+function scroll (y1, t) {
+    var y0 = document.body.scrollTop || document.documentElement.scrollTop;
+    var n = (t || 150) / 15;
+    var i = 0;
+    clearInterval(scroll.owner);
+    scroll.owner = setInterval(function () {
+        var p = Math.max(0, Math.min(++i / n, 1));
+        document.body.scrollTop
+            = document.documentElement.scrollTop
+            = y0 + (y1 - y0) * fade(p);
+        if (i >= n) clearInterval(scroll.owner);
+    }, 15);
+}
+
+function next (el) {
+    scroll(el.nextElementSibling.offsetTop - el.parentNode.offsetTop);
+}
+
+function previous (el) {
+    scroll(el.previousElementSibling.offsetTop - el.parentNode.offsetTop);
+}
+
+function autoClose () {
+    var open = document.querySelectorAll(".tray.visible");
+    for (var i = 0; i < open.length; ++i)
+        hide(open[i]);
+    return open && open.length;
+}
+
+window.addEventListener("DOMContentLoaded", function () {
+    if (navigator.standalone)
+        document.body.className += " standalone";
+    var units = document.getElementById("addUnit");
+    Object.keys(UNITS).sort(function (a, b) {
+        return (b.indexOf("Ogre Mk") - a.indexOf("Ogre Mk"))
+            || (a > b) - (a < b);
+    }).forEach(function (unitName) {
+        var unit = units.appendChild(document.createElement("li"));
+        unit.textContent = unitName;
+        unit.addEventListener("click", function () {
+            addUnit(unitName);
+            hide('addUnit');
+        });
+    });
+    addUnit('Ogre Mk. V');
+    FastClick.attach(document.body, { tapDelay: 50 });
+
+    var trays = document.querySelectorAll('[data-tray]');
+    for (var i = 0; i < trays.length; ++i)
+        trays[i].addEventListener('click', handleTray);
+    window.addEventListener('click', function (evt) {
+        if (!findParent(evt.target, ".tray.visible"))
+            autoClose();
+    });
+});

diff --git a/units.js b/units.js
new file mode 100644 (file)
index 0000000..984b6fd
--- /dev/null
+++ b/units.js
@@ -0,0 +1,352 @@
+/* The person who associated a work with this deed has dedicated the work
+   to the public domain by waiving all of his or her rights to the work
+   worldwide under copyright law, including all related and neighboring
+   rights, to the extent allowed by law.
+
+   You can copy, modify, distribute and perform the work, even for
+   commercial purposes, all without asking permission.
+
+   See https://creativecommons.org/publicdomain/zero/1.0/ for details.
+*/
+
+var ADJECTIVES = [
+    "angry",
+    "cold",
+    "deadly",
+    "easy",
+    "faithful",
+    "fatal",
+    "fiery",
+    "harsh",
+    "lost",
+    "mean",
+    "mighty",
+    "noisy",
+    "old",
+    "proud",
+    "pure",
+    "quiet",
+    "sharp",
+    "slow",
+    "strong",
+    "true",
+    "",
+    "",
+    "",
+];
+
+var BIRDS = [
+    "angel",
+    "arrow",
+    "cloud",
+    "eagle",
+    "falcon",
+    "owl",
+    "raptor",
+    "storm",
+    "swan",
+    "swarm",
+];
+
+var NOUNS = [
+    "axe",
+    "boar",
+    "brute",
+    "claw",
+    "cobra",
+    "dagger",
+    "demon",
+    "fox",
+    "hyena",
+    "knife",
+    "lion",
+    "lynx",
+    "saber",
+    "scout",
+    "snake",
+    "spear",
+    "spire",
+    "stone",
+    "stream",
+    "sword",
+    "talon",
+    "thorn",
+    "tide",
+    "tooth",
+    "tower",
+    "tusk",
+    "venom",
+    "viper",
+    "wall",
+    "wave",
+    "wolf",
+    "worker",
+];
+
+// Most game data in this file based on
+// http://www.sjgames.com/ogre/kickstarter/ogre-rec-sheets.pdf
+// http://www.sjgames.com/ogre/kickstarter/ogre_rulebook.pdf
+
+var WEAPONS = {
+    "Main Battery": { attack: 4, range: 3, defense: 4 },
+    "Secondary Battery": { attack: 3, range: 2, defense: 3 },
+    "Improved 2° Battery": { attack: 3, range: 3, defense: 3 },
+    "Antipersonnel": {
+        attack: 1, range: 1, defense: 1,
+        aside: "Only against Infantry or CPs"
+    },
+    "Missile Rack": { defense: 4 },
+    "Int. Missile": { attack: 6, range: 5 },
+    "Missile": { attack: 6, range: 5, defense: 3 },
+    "Ext. Missile": { attack: 6, range: 5, defense: 3 },
+    "Manipulator Arm": { defense: 2 },
+    "Main Gun": { attack: 3, range: 3 },
+    "Bombload": { attack: 6, range: 0, defense: 3 },
+    "Air-to-Air Missile": { attack: 6, range: 5, defense: 3 },
+    "Antipersonnel Bombload": {
+        attack: 1, range: 0, defense: 1,
+        aside: "Only against Infantry or CPs"
+    },
+    "Pod": { defense: 2 },
+    "Eye": { attack: 2, range: 30, defense: 3 },
+    "Tower": { defense: 6 }
+};
+
+var UNITS = {
+    "Superheavy Tank": {
+        weapons: ["3 Main Guns", "3 Antipersonnel"],
+        nameScheme: "id",
+        tread: 18,
+        size: 5,
+        au: 3
+    },
+    "Ogre Mk. I": {
+        aside: "Pikeman",
+        weapons: ["1 Main Battery", "4 Antipersonnel"],
+        tread: 18,
+        size: 5,
+        au: 4
+    },
+    "Ogre Mk. II": {
+        weapons: [
+            "Main Battery",
+            "2 Secondary Battery",
+            "6 Antipersonnel"
+        ],
+        tread: 30,
+        size: 6,
+        au: 8
+    },
+    "Ogre Mk. III": {
+        weapons: [
+            "Main Battery",
+            "4 Secondary Battery",
+            "2 Missiles",
+            "8 Antipersonnel"
+        ],
+        tread: 45,
+        size: 7,
+        au: 17
+    },
+    "Ogre Mk. III-B": {
+        weapons: [
+            "2 Main Battery",
+            "4 Secondary Battery",
+            "4 Missiles",
+            "8 Antipersonnel"
+        ],
+        tread: 48,
+        size: 7,
+        au: 20
+    },
+    "Ogre Mk. IV": {
+        weapons: [
+            "Main Battery",
+            "2 Secondary Battery",
+            "3 Missile Racks",
+            "15 Int. Missiles",
+            "8 Antipersonnel"
+        ],
+        move: 4,
+        tread: 48,
+        size: 8,
+        au: 25
+    },
+    "Ogre Mk. V": {
+        weapons: [
+            "2 Main Battery",
+            "6 Secondary Battery",
+            "6 Missiles",
+            "12 Antipersonnel"
+        ],
+        tread: 60,
+        size: 8,
+        au: 25
+    },
+    "Ogre Mk. VI": {
+        nameScheme: "grand",
+        weapons: [
+            "3 Main Battery",
+            "6 Secondary Battery",
+            "3 Missile Racks",
+            "12 Int. Missiles",
+            "6 Ext. Missiles",
+            "16 Antipersonnel"
+        ],
+        tread: 72,
+        size: 9,
+        au: 40
+    },
+    "Ogre Vulcan": {
+        weapons: [
+            "2 Secondary Battery",
+            "6 Antipersonnel",
+            "2 Manipulator Arms"
+        ],
+        move: 4,
+        tread: 48,
+        size: 7,
+        au: "25+"
+    },
+    "Ogre Ninja": {
+        weapons: [
+            "Main Battery",
+            "2 Secondary Battery",
+            "Missile Rack",
+            "4 Int. Missiles",
+            "2 Ext. Missiles",
+            "8 Antipersonnel"
+        ],
+        aside: "−1 to rolls when attacked (except by infantry overruns)",
+        move: 4,
+        tread: 40,
+        size: 7,
+        au: "25+"
+    },
+    "Doppelsoldner": {
+        nameScheme: "grand",
+        weapons: [
+            "2 Main Battery",
+            "8 Secondary Battery",
+            "6 Missile Racks",
+            "20 Int. Missiles",
+            "12 Antipersonnel"
+        ],
+        tread: 60,
+        size: 9,
+        au: 40
+    },
+    "Fencer": {
+        weapons: [
+            "2 Secondary Battery",
+            "4 Missile Racks",
+            "20 Int. Missiles",
+            "8 Antipersonnel",
+        ],
+        tread: 48,
+        size: 8,
+        au: 22
+    },
+    "Fencer-B": {
+        weapons: [
+            "2 Main Battery",
+            "4 Missile Racks",
+            "20 Int. Missiles",
+            "8 Antipersonnel"
+        ],
+        tread: 48,
+        size: 8,
+        au: 23
+    },
+    // http://www.sjgames.com/ogre/articles/goliath.html
+    "Goliath": {
+        tread: 40,
+        aside: "Self-destruct capabilities",
+        move: 4,
+    },
+    // http://www.sjgames.com/ogre/articles/csa.html
+    "CSA-10 (Magi)": {
+        nameScheme: "air",
+        weapons: [
+            "2 Bombloads",
+            "1 Air-to-Air Missile",
+            "Main Battery",
+            "4 Secondary Battery",
+            "12 Antipersonnel Bombloads"
+        ],
+        move: 4,
+        propulsion: 48,
+    },
+    "CSA-15 (Magi)": {
+        nameScheme: "air",
+        weapons: [
+            "4 Bombloads",
+            "3 Air-to-Air Missiles",
+            "2 Main Battery",
+            "6 Secondary Battery",
+            "18 Antipersonnel Bombloads"
+        ],
+        move: 4,
+        propulsion: 60,
+    },
+    // http://www.sjgames.com/ogre/resources/record/ogrethulu.html
+    "Ogrethulhu": {
+        weapons: [
+            "2 Main Battery",
+            "6 Secondary Battery",
+            "6 Pods",
+            "Eye",
+            "Tower",
+            "12 Antipersonnel"
+        ],
+        tread: 48,
+        au: 50,
+    },
+
+    // GURPS Ogre, adapted by me.
+    "Steel Demon": {
+        weapons: [
+            "2 Main Battery",
+            "4 Improved 2° Battery",
+            "Missile Rack",
+            "4 Int. Missiles",
+            "12 Antipersonnel"
+        ],
+        tread: 48,
+        size: 7,
+    },
+    "Steel Samurai": {
+        weapons: [
+            "2 Main Battery",
+            "6 Improved 2° Battery",
+            "Missile Rack",
+            "8 Int. Missiles",
+            "16 Antipersonnel"
+        ],
+        tread: 60,
+        size: 8,
+    },
+    "Golem": {
+        weapons: [
+            "Main Battery",
+            "3 Secondary Battery",
+            "3 Missile Racks",
+            "9 Int. Missiles",
+            "12 Antipersonnel"
+        ],
+        tread: 45,
+        size: 7
+    },
+    "Ogre Mk. VII": {
+        weapons: [
+            "4 Main Battery",
+            "12 Secondary Battery",
+            "4 Missile Racks",
+            "32 Int. Missiles",
+            "24 Antipersonnel",
+        ],
+        size: 10,
+        tread: 60,
+        move: 2,
+    }
+};